spec

The spec.ContextInstancesConfiguration interface contains the configuration of Type API instances and is part of a spec.IContext specification.

An object whose keys are instance identifiers and whose values are instance declarations.

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

See also: pentaho.type.InstancesContainer

The spec.ContextTypesConfiguration interface contains the configuration of Type API types and is part of a spec.IContext specification.

An object whose keys are type identifiers and whose values are type context configurations.

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

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

Examples of dynamic property attributes:

• pentaho.type.Property.Type#isApplicable
• pentaho.type.Property.Type#isEnabled
• pentaho.type.Property.Type#isRequired
• pentaho.type.Property.Type#countMin
• pentaho.type.Property.Type#countMax

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

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

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.UInstance, each the specification of the value of one of a complex's properties, in property definition order, according to Property.Type#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.

When a complex value is absent, it can be described with a Nully JavaScript value:

null

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

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

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

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

A spec.UEnvironmentPropFilter 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/UEnvironmentPropFilter.jsdoc, line 17

A spec.UInstance 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/UInstance.jsdoc, line 17

The spec.UInstanceModule type is the union of types that can be the value of the AMD module that defines a Type API named instance.

An instance module is either the instance factory function directly, or an array whose first elements are dependency references and whose last element is the instance factory function.

The instance factory function can declare as many arguments as the dependency references that precede it in the module array. The function is called with the values of the resolved dependencies.

One last argument is supplied containing any configuration registered under the instance identifier (see IRuleSelector#instance).

The following is an example of the AMD module of a Type API named instance, an instance of an hypothetical my/CustomSpecialService type:

define(function() {

  return ["my/CustomSpecialService", function(CustomSpecialService, config) {

    return new CustomSpecialService(config);
  }];
});

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

See also: pentaho.type.spec.UTypeModule

The spec.UInstanceReference union represents the set of JS types that can be used to reference an instance.

Instance references are the main arguments of methods such as InstancesContainer#get and Type#createAsync.

An instance reference can be an instance specification, used for constructing a new instance, or a resolve instance specification, used for resolving instances from the instances' container.

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

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

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.UInstance, 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]
]

When a list value is absent or empty, it can be described with a Nully JavaScript value:

null

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

The spec.UModuleDependencyReference union represents the set of JS types that can be used to reference a type or instance dependency, from either an instance module or a type module.

Dependency references are the main arguments of methods such as Context#getDependency and Context#getDependencyAsync.

A spec.UPropertyTypeProto 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.IPropertyTypeProto#name is that string and whose pentaho.type.spec.IPropertyTypeProto#valueType is pentaho.type.String.

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

A spec.USimple 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: {}}

When a simple value is absent, it can be described with a Nully JavaScript value:

null

Note, also, 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/USimple.jsdoc, line 17

The spec.UTypeModule type is the union of types that can be the value of the AMD module that defines a Type API named type.

A module is either the type factory function directly, or an array whose first elements are dependency references and whose last element is the type factory function.

The type factory function can declare as many arguments as the dependency references that precede it in the module array. The function is called with the values of the resolved dependencies.

The following is an example of the AMD module of a Type API type which is a subtype of Complex and that depends on all registered instances of its special type my/SpecialService.

define(function() {

  return [
    "complex",
    {$instance: {type: ["my/SpecialService"]}},
    function(Complex, specialServicesList) {

      return Complex.extend({
        $type: {
          // ...
        }
      });
    }
  ];
});

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

See also: pentaho.type.spec.UInstanceModule

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

It can be one of the following:

"pentaho/type/string"

"_:1"

require(["pentaho/type/Context"], function(Context) {
  Context.createAsync().then(function(context) {
    var Complex = context.get("pentaho/type/complex");

    // ...
  });
});

require(["pentaho/type/Context"], function(Context) {
  Context.createAsync().then(function(context) {
    var PentahoNumber = context.get("pentaho/type/number");
    var numberType = PentahoNumber.type;

    // Get a number list type
    var NumberList = context.get([numberType]);

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

    // ...
  });
});

require(["pentaho/type/Context"], function(Context) {
  Context.createAsync().then(function(context) {

    // Obtain an anonymous, derived complex type from the context
    var MyProduct = context.get({
          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/Context"], function(Context) {

  Context.createAsync().then(function(context) {

    // Obtain the List type instance constructor

    // Using the id
    var ListA = context.get("list");

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

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

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

    // ...

    // Assuming the type MyProduct from a previous example

    var ProductList = context.get([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.UValue represents the union of JS types that can be used to describe a value instance, or the absence of one.

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/UValue.jsdoc, line 17