spec

A spec.Complex represents the union of JS types that can be used to describe a complex value.

Like with all other value types, complex values can be described using the general object form. The object form conforms to pentaho.type.spec.IComplex.

Complex values support an additional form of value specification, the array form: an array of pentaho.type.spec.Instance, each the specification of the value of one of a complex's properties, in property definition order, according to PropertyType#index.

Take the following object form example:

{
  product:"boeing-737",
  price:   1500
}

Assuming that the two properties were defined in the order "product" then "price", it could be written in array form, like this:

["boeing-737", 1500]

However, note that array form can only be used if the inline type property can, in fact, be omitted.

Source: doc-js/pentaho/type/spec/Complex.jsdoc, line 17

A spec.Element represents the union of JS types that can be used to describe an element instance.

Source: doc-js/pentaho/type/spec/Element.jsdoc, line 17

A spec.EnvironmentPropertyFilter represents the union of JS types that can be used to filter the value of an environment variable, in the select attribute of a type configuration rule.

A Nully filter is equivalent to not filtering a variable. When unfiltered, any environment variable value is matched.

An array filter matches an environment variable if any of the values in the array are the same exact value of the environment variable.

Any other value is assumed to be a single value, and matches the environment variable if it is the same value.

Source: doc-js/pentaho/type/spec/EnvironmentPropertyFilter.jsdoc, line 17

A spec.Instance represents the union of JS types that can be used to describe an instance, or the absence of one.

When an instance is described using object form, its specification is of type spec.IInstance.

To describe an absent instance, use a Nully JavaScript value.

Source: doc-js/pentaho/type/spec/Instance.jsdoc, line 17

A spec.List represents the union of JS types that can be used to describe a list value.

Like with all other value types, list values can be described using the general object form. The object form conforms to pentaho.type.spec.IList.

List values support an additional form of value specification, the array form: an array of pentaho.type.spec.Instance, each the specification of the corresponding element of the list.

Take the following example of a number list in object form:

{
  _: {base:"list", of:"number"},
  d: [1, 2, 3]
}

In array form, if we assume the type of the list is implied, the same list could be written simply as:

[1, 2, 3]

However, note that array form can only be used if the inline type property can, in fact, be omitted.

A list of complex values can be written in array form, and its complex elements be written in array form, as well. For example:

[
  ["boeing-737",  1500],
  ["airbus-A320", 1000]
]

Source: doc-js/pentaho/type/spec/List.jsdoc, line 17

The signature of a function of a dynamic attribute of a property.

Examples of dynamic property attributes:

• pentaho.type.PropertyType#isApplicable
• pentaho.type.PropertyType#isEnabled
• pentaho.type.PropertyType#isRequired
• pentaho.type.PropertyType#countMin
• pentaho.type.PropertyType#countMax

Source: doc-js/pentaho/type/spec/PropertyDynamicAttribute.jsdoc, line 17

A spec.PropertyType represents the union of JS types that can be used to define a property of a complex type.

When the value is a string, it's taken to represent a property whose pentaho.type.spec.IPropertyType#name is that string and whose pentaho.type.spec.IPropertyType#valueType is pentaho.type.String.

Source: doc-js/pentaho/type/spec/PropertyType.jsdoc, line 17

A spec.Simple represents the union of JS types that can be used to describe a simple value, or the absence of one.

Like with all other value types, simple values can be described using the general object form. The object form conforms to pentaho.type.spec.ISimple.

The following is an example of an object form specification:

{v: 1, f:"1.0"}

If the formatted is not defined, it can be written more concisely as:

{v: 1}

or, simply, as:

1

Note that, when the underlying JavaScript value is a plain object, it must always be described using the generic object form, spec.ISimple, as in:

{v: {}}

Note that a simple value cannot have a Nully as its underlying JavaScript value, and, as such, the following example would not be valid:

{v: null} // throws if given to a Simple, derived constructor

A Simple instance can also be used as a simple value specification, in which case it is used as a source of its value and formatted properties.

To know, exactly, which types of JavaScript values are accepted as specifications of a specific pentaho.type.spec.ISimple subtype, see the subtype's documentation.

Source: doc-js/pentaho/type/spec/Simple.jsdoc, line 17

The spec.TypeReference union represents the set of JS types that can be used to reference a type.

It can be one of the following:

"pentaho/type/String"

"_:1"

require(["pentaho/type/loader","pentaho/type/Complex"], function(typeLoader, Complex) {

  typeLoader.resolveType(Complex);

});

require(["pentaho/type/loader","pentaho/type/Number"], function(typeLoader, PentahoNumber) {

  var numberType = PentahoNumber.type;

  // Create a number list type
  var NumberList = typeLoader.resolveType([numberType]);

  var numbers = new NumberList([1, 2, 3]);

  // ...
});

require(["pentaho/type/loader"], function(typeLoader) {

  // Create an anonymous, derived complex type by using the type loader.
  var MyProduct = typeLoader.resolveType({
    base:"complex"// optional
    props: [
      {name:"id",    label:"Id",    valueType:"string"},
      {name:"name",  label:"Name",  valueType:"string"},
      {name:"price", label:"Price", valueType:"number"}
    ]
  });

  var productA = new MyProduct({id:"mabc", name:"Principia Mathematica", price: 1200});

  // ...

});

require(["pentaho/type/loader"], function(typeLoader) {

  // Obtain the List type instance constructor

  // Using the id
  var ListA = typeLoader.resolveType("list");

  // Obtain a derived List type instance constructor
  // with Number as the element type

  // Using the generic type specification syntax
  var NumberListA = typeLoader.resolveType({base:"list", of:"number"});

  // Using the shorthand syntax
  var NumberListB = typeLoader.resolveType(["number"]);

  // ...

  // Assuming the type MyProduct from a previous example

  var ProductList = typeLoader.resolveType([MyProduct]);

  var productList = new ProductList([
    {id:"mpma", name:"Principia Mathematica", price: 1200},
    {id:"flot", name:"The Laws of Thought",   price:  500}
  ]);

  alert("Product count:"+ productList.count);

});

A spec.Value represents the union of JS types that can be used to describe a value instance.

When a value instance is described using object form, its specification is of type spec.IValue.

To describe an absent instance, use a Nully JavaScript value.

Source: doc-js/pentaho/type/spec/Value.jsdoc, line 17