componentsjs 4.3.0 → 5.0.0-beta.0

package/lib/preprocess/constructorargumentsmapping/ConstructorArgumentsElementMappingHandlerKeyValue.js

@@ -27,15 +27,15 @@ class ConstructorArgumentsElementMappingHandlerKeyValue {
         return this.handleValue(configRoot, constructorArgs, configElement, mapper);
     }
     handleKeyValue(configRoot, constructorArgs, configElement, mapper) {
-        const ret = mapper.objectLoader.createCompactedResource({});
-        ret.property.key = constructorArgs.property.key;
-        for (const value of mapper.getParameterValue(configRoot, constructorArgs.property.value || constructorArgs.property.valueRawReference, configElement, Boolean(constructorArgs.property.valueRawReference))) {
-            ret.properties.value.push(value);
-        }
-        return [ret];
+        const value = mapper.getParameterValue(configRoot, constructorArgs.property.value || constructorArgs.property.valueRawReference, configElement, Boolean(constructorArgs.property.valueRawReference));
+        return mapper.objectLoader.createCompactedResource(Object.assign({ key: constructorArgs.property.key }, value ? { value } : {}));
     }
     handleValue(configRoot, constructorArgs, configElement, mapper) {
-        return mapper.getParameterValue(configRoot, constructorArgs.property.value || constructorArgs.property.valueRawReference, configElement, Boolean(constructorArgs.property.valueRawReference));
+        const value = mapper.getParameterValue(configRoot, constructorArgs.property.value || constructorArgs.property.valueRawReference, configElement, Boolean(constructorArgs.property.valueRawReference));
+        if (!value) {
+            return mapper.objectLoader.createCompactedResource({ undefined: true });
+        }
+        return value;
     }
 }
 exports.ConstructorArgumentsElementMappingHandlerKeyValue = ConstructorArgumentsElementMappingHandlerKeyValue;

package/lib/preprocess/constructorargumentsmapping/ConstructorArgumentsElementMappingHandlerList.d.ts

@@ -6,5 +6,5 @@ import type { IConstructorArgumentsMapper } from './IConstructorArgumentsMapper'
  */
 export declare class ConstructorArgumentsElementMappingHandlerList implements IConstructorArgumentsElementMappingHandler {
     canHandle(configRoot: Resource, constructorArgs: Resource, configElement: Resource, mapper: IConstructorArgumentsMapper): boolean;
-    handle(configRoot: Resource, constructorArgs: Resource, configElement: Resource, mapper: IConstructorArgumentsMapper): Resource[];
+    handle(configRoot: Resource, constructorArgs: Resource, configElement: Resource, mapper: IConstructorArgumentsMapper): Resource;
 }

package/lib/preprocess/constructorargumentsmapping/ConstructorArgumentsElementMappingHandlerList.js

@@ -9,39 +9,24 @@ class ConstructorArgumentsElementMappingHandlerList {
         return Boolean(constructorArgs.list);
     }
     handle(configRoot, constructorArgs, configElement, mapper) {
-        var _a;
         // Recursively handle all field values.
         const ret = mapper.objectLoader.createCompactedResource({});
         ret.list = [];
         for (const argument of constructorArgs.list) {
             if (argument.property.fields || argument.property.elements) {
-                for (const mapped of mapper.applyConstructorArgumentsParameters(configRoot, argument, configElement)) {
-                    ret.list.push(mapped);
-                }
+                ret.list.push(mapper.applyConstructorArgumentsParameters(configRoot, argument, configElement));
             }
             else {
-                const mappeds = mapper.getParameterValue(configRoot, argument, configElement, false);
-                if (mappeds.length > 0) {
-                    if (((_a = mappeds[0].property.unique) === null || _a === void 0 ? void 0 : _a.value) === 'true') {
-                        // Only add a single value if param was unique
-                        ret.list.push(mappeds[0]);
-                    }
-                    else {
-                        // Add all values as an array if param was not unique
-                        ret.list.push(mapper.objectLoader.createCompactedResource({
-                            elements: mappeds.map(value => mapper.objectLoader.createCompactedResource({ value })),
-                        }));
-                    }
+                const value = mapper.getParameterValue(configRoot, argument, configElement, false);
+                if (value) {
+                    ret.list.push(value);
                 }
                 else {
-                    // Explicitly pass a single undefined value if no param value was set
-                    ret.list.push(mapper.objectLoader.createCompactedResource({
-                        undefined: true,
-                    }));
+                    ret.list.push(mapper.objectLoader.createCompactedResource({ undefined: true }));
                 }
             }
         }
-        return [ret];
+        return ret;
     }
 }
 exports.ConstructorArgumentsElementMappingHandlerList = ConstructorArgumentsElementMappingHandlerList;

package/lib/preprocess/constructorargumentsmapping/IConstructorArgumentsElementMappingHandler.d.ts

@@ -20,5 +20,5 @@ export interface IConstructorArgumentsElementMappingHandler {
      * @param configElement Part of the config resource to look for parameter instantiations as predicates.
      * @param mapper Instance of the constructor arguments mapper that can be used to handle recursive args.
      */
-    handle: (configRoot: Resource, constructorArgs: Resource, configElement: Resource, mapper: IConstructorArgumentsMapper) => Resource[];
+    handle: (configRoot: Resource, constructorArgs: Resource, configElement: Resource, mapper: IConstructorArgumentsMapper) => Resource;
 }

package/lib/preprocess/constructorargumentsmapping/IConstructorArgumentsMapper.d.ts

@@ -16,7 +16,7 @@ export interface IConstructorArgumentsMapper {
      * @param constructorArgs Object mapping definition inside the constructor arguments.
      * @param configElement Part of the config resource to look for parameter instantiations as predicates.
      */
-    applyConstructorArgumentsParameters: (configRoot: Resource, constructorArgs: Resource, configElement: Resource) => Resource[];
+    applyConstructorArgumentsParameters: (configRoot: Resource, constructorArgs: Resource, configElement: Resource) => Resource;
     /**
      * Obtain the value(s) of the given parameter in the given config.
      * @param configRoot The root config resource that we are working in.
@@ -24,5 +24,5 @@ export interface IConstructorArgumentsMapper {
      * @param configElement Part of the config resource to look for parameter instantiations as predicates.
      * @param rawValue If the IRI represents a raw string value instead of a parameter reference.
      */
-    getParameterValue: (configRoot: Resource, parameter: Resource, configElement: Resource, rawValue: boolean) => Resource[];
+    getParameterValue: (configRoot: Resource, parameter: Resource, configElement: Resource, rawValue: boolean) => Resource | undefined;
 }

package/lib/preprocess/parameterproperty/IParameterPropertyHandler.d.ts

@@ -11,7 +11,7 @@ export interface IParameterPropertyHandler {
      * @param parameter The parameter resource to get the value for.
      * @param configElement Part of the config resource to look for parameter instantiations as predicates.
      */
-    canHandle: (value: Resource[], configRoot: Resource, parameter: Resource, configElement: Resource) => boolean;
+    canHandle: (value: Resource | undefined, configRoot: Resource, parameter: Resource, configElement: Resource) => boolean;
     /**
      * Transform the given parameter value.
      * @param value The current parameter value obtained from the config.
@@ -20,5 +20,5 @@ export interface IParameterPropertyHandler {
      * @param parameter The parameter resource to get the value for.
      * @param configElement Part of the config resource to look for parameter instantiations as predicates.
      */
-    handle: (value: Resource[], configRoot: Resource, parameter: Resource, configElement: Resource) => Resource[];
+    handle: (value: Resource | undefined, configRoot: Resource, parameter: Resource, configElement: Resource) => Resource | undefined;
 }

package/lib/preprocess/parameterproperty/ParameterPropertyHandlerDefault.d.ts

@@ -1,9 +1,12 @@
-import type { Resource } from 'rdf-object';
+import type { Resource, RdfObjectLoader } from 'rdf-object';
 import type { IParameterPropertyHandler } from './IParameterPropertyHandler';
 /**
  * If no value has been set, its default value will be set.
  */
 export declare class ParameterPropertyHandlerDefault implements IParameterPropertyHandler {
-    canHandle(value: Resource[], configRoot: Resource, parameter: Resource, configElement: Resource): boolean;
-    handle(value: Resource[], configRoot: Resource, parameter: Resource, configElement: Resource): Resource[];
+    private readonly objectLoader;
+    constructor(objectLoader: RdfObjectLoader);
+    canHandle(value: Resource | undefined, configRoot: Resource, parameter: Resource): boolean;
+    handle(value: Resource | undefined, configRoot: Resource, parameter: Resource, configElement: Resource): Resource | undefined;
+    protected handleValue(value: Resource, configElement: Resource): Resource;
 }

package/lib/preprocess/parameterproperty/ParameterPropertyHandlerDefault.js

@@ -1,15 +1,32 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ParameterPropertyHandlerDefault = void 0;
+const Iris_1 = require("../../rdf/Iris");
+const ErrorResourcesContext_1 = require("../../util/ErrorResourcesContext");
 /**
  * If no value has been set, its default value will be set.
  */
 class ParameterPropertyHandlerDefault {
-    canHandle(value, configRoot, parameter, configElement) {
-        return Boolean(value.length === 0 && parameter.property.default);
+    constructor(objectLoader) {
+        this.objectLoader = objectLoader;
+    }
+    canHandle(value, configRoot, parameter) {
+        return Boolean(!value && parameter.property.default);
     }
     handle(value, configRoot, parameter, configElement) {
-        value = parameter.properties.default;
+        if (parameter.properties.default.length > 1) {
+            throw new ErrorResourcesContext_1.ErrorResourcesContext(`Invalid default value for parameter "${parameter.value}": Only one value can be defined, or an RDF list must be provided`, { parameter });
+        }
+        return parameter.property.default.list ?
+            this.objectLoader.createCompactedResource({
+                list: parameter.property.default.list.map(subValue => this.handleValue(subValue, configElement)),
+            }) :
+            this.handleValue(parameter.property.default, configElement);
+    }
+    handleValue(value, configElement) {
+        if (value.type === 'NamedNode' && value.value === Iris_1.IRIS_RDF.subject) {
+            value = this.objectLoader.createCompactedResource(`"${configElement.value}"`);
+        }
         return value;
     }
 }

package/lib/preprocess/parameterproperty/ParameterPropertyHandlerDefaultScoped.d.ts

@@ -6,6 +6,6 @@ import type { IParameterPropertyHandler } from './IParameterPropertyHandler';
 export declare class ParameterPropertyHandlerDefaultScoped implements IParameterPropertyHandler {
     private readonly objectLoader;
     constructor(objectLoader: RdfObjectLoader);
-    canHandle(value: Resource[], configRoot: Resource, parameter: Resource, configElement: Resource): boolean;
-    handle(value: Resource[], configRoot: Resource, parameter: Resource, configElement: Resource): Resource[];
+    canHandle(value: Resource | undefined, configRoot: Resource, parameter: Resource): boolean;
+    handle(value: Resource | undefined, configRoot: Resource, parameter: Resource, configElement: Resource): Resource | undefined;
 }

package/lib/preprocess/parameterproperty/ParameterPropertyHandlerDefaultScoped.js

@@ -9,11 +9,11 @@ class ParameterPropertyHandlerDefaultScoped {
     constructor(objectLoader) {
         this.objectLoader = objectLoader;
     }
-    canHandle(value, configRoot, parameter, configElement) {
-        return Boolean(value.length === 0 && parameter.property.defaultScoped);
+    canHandle(value, configRoot, parameter) {
+        return Boolean(!value && parameter.property.defaultScoped);
     }
     handle(value, configRoot, parameter, configElement) {
-        // Multiple scopes can be defined
+        let applyingValue;
         for (const scoped of parameter.properties.defaultScoped) {
             // Require defaultScope
             if (!scoped.property.defaultScope) {
@@ -25,13 +25,24 @@ class ParameterPropertyHandlerDefaultScoped {
                 if (!scoped.property.defaultScopedValue) {
                     throw new ErrorResourcesContext_1.ErrorResourcesContext(`Invalid defaultScoped for parameter "${parameter.value}": Missing defaultScopedValue`, { parameter });
                 }
+                // Require RDF list or single value
+                if (scoped.properties.defaultScopedValue.length > 1) {
+                    throw new ErrorResourcesContext_1.ErrorResourcesContext(`Invalid defaultScoped value for parameter "${parameter.value}": Only one defaultScopedValue can be defined, or an RDF list must be provided`, { parameter });
+                }
                 // Apply the scope if the config is of the required type (also considering sub-types)
                 if (configRoot.isA(scopeType.term)) {
-                    value.push(...scoped.properties.defaultScopedValue);
+                    applyingValue = !applyingValue ?
+                        scoped.property.defaultScopedValue :
+                        this.objectLoader.createCompactedResource({
+                            list: [
+                                ...applyingValue.list || [applyingValue],
+                                ...scoped.property.defaultScopedValue.list || [scoped.property.defaultScopedValue],
+                            ],
+                        });
                 }
             }
         }
-        return value;
+        return applyingValue;
     }
 }
 exports.ParameterPropertyHandlerDefaultScoped = ParameterPropertyHandlerDefaultScoped;

package/lib/preprocess/parameterproperty/ParameterPropertyHandlerFixed.d.ts

@@ -1,9 +1,11 @@
-import type { Resource } from 'rdf-object';
+import type { Resource, RdfObjectLoader } from 'rdf-object';
 import type { IParameterPropertyHandler } from './IParameterPropertyHandler';
 /**
  * Irrespective of any set values, prepend the parameter's fixed values.
  */
 export declare class ParameterPropertyHandlerFixed implements IParameterPropertyHandler {
-    canHandle(value: Resource[], configRoot: Resource, parameter: Resource, configElement: Resource): boolean;
-    handle(value: Resource[], configRoot: Resource, parameter: Resource, configElement: Resource): Resource[];
+    private readonly objectLoader;
+    constructor(objectLoader: RdfObjectLoader);
+    canHandle(value: Resource | undefined, configRoot: Resource, parameter: Resource): boolean;
+    handle(value: Resource | undefined, configRoot: Resource, parameter: Resource, configElement: Resource): Resource | undefined;
 }

package/lib/preprocess/parameterproperty/ParameterPropertyHandlerFixed.js

@@ -1,15 +1,38 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ParameterPropertyHandlerFixed = void 0;
+const ErrorResourcesContext_1 = require("../../util/ErrorResourcesContext");
 /**
  * Irrespective of any set values, prepend the parameter's fixed values.
  */
 class ParameterPropertyHandlerFixed {
-    canHandle(value, configRoot, parameter, configElement) {
+    constructor(objectLoader) {
+        this.objectLoader = objectLoader;
+    }
+    canHandle(value, configRoot, parameter) {
         return Boolean(parameter.property.fixed);
     }
     handle(value, configRoot, parameter, configElement) {
-        value.unshift(...parameter.properties.fixed);
+        if (parameter.properties.fixed.length > 1) {
+            throw new ErrorResourcesContext_1.ErrorResourcesContext(`Invalid fixed value for parameter "${parameter.value}": Only one value can be defined, or an RDF list must be provided`, { parameter });
+        }
+        if (value) {
+            const fixedValues = parameter.property.fixed.list || [parameter.property.fixed];
+            if (value.list) {
+                value.list.unshift(...fixedValues);
+            }
+            else {
+                value = this.objectLoader.createCompactedResource({
+                    list: [
+                        ...fixedValues,
+                        value,
+                    ],
+                });
+            }
+        }
+        else {
+            value = parameter.property.fixed;
+        }
         return value;
     }
 }

package/lib/preprocess/parameterproperty/ParameterPropertyHandlerLazy.d.ts

@@ -5,6 +5,6 @@ import type { IParameterPropertyHandler } from './IParameterPropertyHandler';
  * make the value inherit this lazy tag so that it can be handled later.
  */
 export declare class ParameterPropertyHandlerLazy implements IParameterPropertyHandler {
-    canHandle(value: Resource[], configRoot: Resource, parameter: Resource, configElement: Resource): boolean;
-    handle(value: Resource[], configRoot: Resource, parameter: Resource, configElement: Resource): Resource[];
+    canHandle(value: Resource | undefined, configRoot: Resource, parameter: Resource): boolean;
+    handle(value: Resource | undefined, configRoot: Resource, parameter: Resource, configElement: Resource): Resource | undefined;
 }

package/lib/preprocess/parameterproperty/ParameterPropertyHandlerLazy.js

@@ -6,12 +6,19 @@ exports.ParameterPropertyHandlerLazy = void 0;
  * make the value inherit this lazy tag so that it can be handled later.
  */
 class ParameterPropertyHandlerLazy {
-    canHandle(value, configRoot, parameter, configElement) {
+    canHandle(value, configRoot, parameter) {
         return Boolean(parameter.property.lazy);
     }
     handle(value, configRoot, parameter, configElement) {
-        for (const subValue of value) {
-            subValue.property.lazy = parameter.property.lazy;
+        if (value) {
+            if (value.list) {
+                for (const subValue of value.list) {
+                    subValue.property.lazy = parameter.property.lazy;
+                }
+            }
+            else {
+                value.property.lazy = parameter.property.lazy;
+            }
         }
         return value;
     }

package/lib/preprocess/parameterproperty/ParameterPropertyHandlerRange.d.ts

@@ -6,8 +6,8 @@ import type { IParameterPropertyHandler } from './IParameterPropertyHandler';
 export declare class ParameterPropertyHandlerRange implements IParameterPropertyHandler {
     private readonly objectLoader;
     constructor(objectLoader: RdfObjectLoader);
-    canHandle(value: Resource[], configRoot: Resource, parameter: Resource, configElement: Resource): boolean;
-    handle(value: Resource[], configRoot: Resource, parameter: Resource, configElement: Resource): Resource[];
+    canHandle(value: Resource | undefined, configRoot: Resource, parameter: Resource): boolean;
+    handle(value: Resource | undefined, configRoot: Resource, parameter: Resource, configElement: Resource): Resource | undefined;
     /**
      * Apply the given datatype to the given literal.
      * Checks if the datatype is correct and casts to the correct js type.
@@ -16,6 +16,17 @@ export declare class ParameterPropertyHandlerRange implements IParameterProperty
      * @param value The value.
      * @param param The parameter.
      */
-    captureType(value: Resource, param: Resource): Resource;
-    protected throwIncorrectTypeError(value: Resource, parameter: Resource): void;
+    captureType(value: Resource | undefined, param: Resource): Resource | undefined;
+    /**
+     * Apply the given datatype to the given literal.
+     * Checks if the datatype is correct and casts to the correct js type.
+     * Will throw an error if the type has an invalid value.
+     * Will be ignored if the value is not a literal or the type is not recognized.
+     * @param value The value.
+     * @param param The parameter.
+     * @param paramRange The parameter's range.
+     */
+    hasParamValueValidType(value: Resource | undefined, param: Resource, paramRange: Resource): boolean;
+    protected throwIncorrectTypeError(value: Resource | undefined, parameter: Resource): never;
+    rangeToDisplayString(paramRange: Resource | undefined): string;
 }

package/lib/preprocess/parameterproperty/ParameterPropertyHandlerRange.js

@@ -10,13 +10,11 @@ class ParameterPropertyHandlerRange {
     constructor(objectLoader) {
         this.objectLoader = objectLoader;
     }
-    canHandle(value, configRoot, parameter, configElement) {
+    canHandle(value, configRoot, parameter) {
         return Boolean(parameter.property.range);
     }
     handle(value, configRoot, parameter, configElement) {
-        for (const subValue of value) {
-            this.captureType(subValue, parameter);
-        }
+        this.captureType(value, parameter);
         return value;
     }
     /**
@@ -28,9 +26,32 @@ class ParameterPropertyHandlerRange {
      * @param param The parameter.
      */
     captureType(value, param) {
-        if (value.type === 'Literal') {
+        if (this.hasParamValueValidType(value, param, param.property.range)) {
+            return value;
+        }
+        this.throwIncorrectTypeError(value, param);
+    }
+    /**
+     * Apply the given datatype to the given literal.
+     * Checks if the datatype is correct and casts to the correct js type.
+     * Will throw an error if the type has an invalid value.
+     * Will be ignored if the value is not a literal or the type is not recognized.
+     * @param value The value.
+     * @param param The parameter.
+     * @param paramRange The parameter's range.
+     */
+    hasParamValueValidType(value, param, paramRange) {
+        if (!paramRange) {
+            return true;
+        }
+        if (!value && paramRange.isA('ParameterRangeUndefined')) {
+            return true;
+        }
+        if (value && value.type === 'Literal') {
             let parsed;
-            switch (param.property.range.value) {
+            switch (paramRange.value) {
+                case Iris_1.IRIS_XSD.string:
+                    return true;
                 case Iris_1.IRIS_XSD.boolean:
                     if (value.value === 'true') {
                         value.term.valueRaw = true;
@@ -39,9 +60,9 @@ class ParameterPropertyHandlerRange {
                         value.term.valueRaw = false;
                     }
                     else {
-                        this.throwIncorrectTypeError(value, param);
+                        return false;
                     }
-                    break;
+                    return true;
                 case Iris_1.IRIS_XSD.integer:
                 case Iris_1.IRIS_XSD.number:
                 case Iris_1.IRIS_XSD.int:
@@ -49,45 +70,140 @@ class ParameterPropertyHandlerRange {
                 case Iris_1.IRIS_XSD.long:
                     parsed = Number.parseInt(value.value, 10);
                     if (Number.isNaN(parsed)) {
-                        this.throwIncorrectTypeError(value, param);
+                        return false;
                     }
-                    else {
-                        // ParseInt also parses floats to ints!
-                        if (String(parsed) !== value.value) {
-                            this.throwIncorrectTypeError(value, param);
-                        }
-                        value.term.valueRaw = parsed;
+                    // ParseInt also parses floats to ints!
+                    if (String(parsed) !== value.value) {
+                        return false;
                     }
-                    break;
+                    value.term.valueRaw = parsed;
+                    return true;
                 case Iris_1.IRIS_XSD.float:
                 case Iris_1.IRIS_XSD.decimal:
                 case Iris_1.IRIS_XSD.double:
                     parsed = Number.parseFloat(value.value);
                     if (Number.isNaN(parsed)) {
-                        this.throwIncorrectTypeError(value, param);
+                        return false;
                     }
-                    else {
-                        value.term.valueRaw = parsed;
-                    }
-                    break;
+                    value.term.valueRaw = parsed;
+                    return true;
                 case Iris_1.IRIS_RDF.JSON:
                     try {
                         parsed = JSON.parse(value.value);
                         value.term.valueRaw = parsed;
                     }
                     catch (_a) {
-                        this.throwIncorrectTypeError(value, param);
+                        return false;
                     }
-                    break;
+                    return true;
             }
         }
-        return value;
+        // Allow IRIs to be casted to strings
+        if (value && paramRange && paramRange.value === Iris_1.IRIS_XSD.string && value.type === 'NamedNode') {
+            return true;
+        }
+        if (paramRange && (!value || (!value.isA('Variable') && !value.isA(paramRange.term)))) {
+            if (value && paramRange.isA('ParameterRangeArray')) {
+                if (!value.list) {
+                    return false;
+                }
+                return value.list.every(listElement => this
+                    .hasParamValueValidType(listElement, param, paramRange.property.parameterRangeValue));
+            }
+            // Check if the param type is a composed type
+            if (paramRange.isA('ParameterRangeUnion')) {
+                return paramRange.properties.parameterRangeElements
+                    .some(child => this.hasParamValueValidType(value, param, child));
+            }
+            if (paramRange.isA('ParameterRangeIntersection')) {
+                return paramRange.properties.parameterRangeElements
+                    .every(child => this.hasParamValueValidType(value, param, child));
+            }
+            if (paramRange.isA('ParameterRangeTuple')) {
+                if (!value || !value.list) {
+                    return false;
+                }
+                // Iterate over list elements and try to match with tuple types
+                const listElements = value.list;
+                const tupleTypes = paramRange.properties.parameterRangeElements;
+                let listIndex = 0;
+                let tupleIndex = 0;
+                while (listIndex < listElements.length && tupleIndex < tupleTypes.length) {
+                    if (tupleTypes[tupleIndex].isA('ParameterRangeRest')) {
+                        // Rest types can match multiple list elements, so only increment index if no match is found.
+                        if (!this.hasParamValueValidType(listElements[listIndex], param, tupleTypes[tupleIndex].property.parameterRangeValue)) {
+                            tupleIndex++;
+                        }
+                        else {
+                            listIndex++;
+                        }
+                    }
+                    else {
+                        if (!this.hasParamValueValidType(listElements[listIndex], param, tupleTypes[tupleIndex])) {
+                            return false;
+                        }
+                        tupleIndex++;
+                        listIndex++;
+                    }
+                }
+                return listIndex === listElements.length &&
+                    (tupleIndex === tupleTypes.length ||
+                        (tupleIndex === tupleTypes.length - 1 && tupleTypes[tupleIndex].isA('ParameterRangeRest')));
+            }
+            if (paramRange.isA('ParameterRangeLiteral')) {
+                return Boolean(value && value.term.equals(paramRange.property.parameterRangeValue.term));
+            }
+            // Check if this param defines a field with sub-params
+            if (paramRange.isA('ParameterRangeCollectEntries')) {
+                // TODO: Add support for type-checking nested fields with collectEntries
+                return true;
+            }
+            return false;
+        }
+        return true;
     }
     throwIncorrectTypeError(value, parameter) {
-        throw new ErrorResourcesContext_1.ErrorResourcesContext(`Parameter value "${value.value}" is not of required range type "${parameter.property.range.value}"`, {
+        const withTypes = value && value.properties.types.length > 0 ? ` with types "${value.properties.types.map(resource => resource.value)}"` : '';
+        // eslint-disable-next-line @typescript-eslint/no-extra-parens
+        const valueString = value ? (value.list ? `[${value.list.map(subValue => subValue.value).join(', ')}]` : value.value) : 'undefined';
+        throw new ErrorResourcesContext_1.ErrorResourcesContext(`The value "${valueString}"${withTypes} for parameter "${parameter.value}" is not of required range type "${this.rangeToDisplayString(parameter.property.range)}"`, {
+            value: value || 'undefined',
             parameter,
         });
     }
+    rangeToDisplayString(paramRange) {
+        if (!paramRange) {
+            return `any`;
+        }
+        if (paramRange.isA('ParameterRangeUndefined')) {
+            return `undefined`;
+        }
+        if (paramRange.isA('ParameterRangeArray')) {
+            return `${this.rangeToDisplayString(paramRange.property.parameterRangeValue)}[]`;
+        }
+        if (paramRange.isA('ParameterRangeRest')) {
+            return `...${this.rangeToDisplayString(paramRange.property.parameterRangeValue)}`;
+        }
+        if (paramRange.isA('ParameterRangeUnion')) {
+            return paramRange.properties.parameterRangeElements
+                .map(child => this.rangeToDisplayString(child))
+                .join(' | ');
+        }
+        if (paramRange.isA('ParameterRangeIntersection')) {
+            return paramRange.properties.parameterRangeElements
+                .map(child => this.rangeToDisplayString(child))
+                .join(' & ');
+        }
+        if (paramRange.isA('ParameterRangeTuple')) {
+            return `[${paramRange.properties.parameterRangeElements
+                .map(child => this.rangeToDisplayString(child))
+                .join(', ')}]`;
+        }
+        if (paramRange.isA('ParameterRangeLiteral')) {
+            return paramRange.property.parameterRangeValue.value;
+        }
+        return paramRange.value;
+    }
 }
 exports.ParameterPropertyHandlerRange = ParameterPropertyHandlerRange;
 //# sourceMappingURL=ParameterPropertyHandlerRange.js.map

package/lib/rdf/Iris.js

@@ -4,45 +4,45 @@ exports.IRIS_OWL = exports.PREFIX_OWL = exports.IRIS_DOAP = exports.PREFIX_DOAP
 const definePrefix = (prefix) => (suffix) => `${prefix}${suffix}`;
 exports.PREFIX_OO = definePrefix('https://linkedsoftwaredependencies.org/vocabularies/object-oriented#');
 exports.IRIS_OO = {
-    Module: exports.PREFIX_OO('Module'),
-    Class: exports.PREFIX_OO('Class'),
-    AbstractClass: exports.PREFIX_OO('AbstractClass'),
-    ComponentInstance: exports.PREFIX_OO('ComponentInstance'),
-    component: exports.PREFIX_OO('component'),
-    componentPath: exports.PREFIX_OO('componentPath'),
-    parameter: exports.PREFIX_OO('parameter'),
+    Module: (0, exports.PREFIX_OO)('Module'),
+    Class: (0, exports.PREFIX_OO)('Class'),
+    AbstractClass: (0, exports.PREFIX_OO)('AbstractClass'),
+    ComponentInstance: (0, exports.PREFIX_OO)('ComponentInstance'),
+    component: (0, exports.PREFIX_OO)('component'),
+    componentPath: (0, exports.PREFIX_OO)('componentPath'),
+    parameter: (0, exports.PREFIX_OO)('parameter'),
 };
 exports.PREFIX_OM = definePrefix('https://linkedsoftwaredependencies.org/vocabularies/object-mapping#');
 exports.PREFIX_RDF = definePrefix('http://www.w3.org/1999/02/22-rdf-syntax-ns#');
 exports.IRIS_RDF = {
-    subject: exports.PREFIX_RDF('subject'),
-    object: exports.PREFIX_RDF('object'),
-    type: exports.PREFIX_RDF('type'),
-    JSON: exports.PREFIX_RDF('JSON'),
+    subject: (0, exports.PREFIX_RDF)('subject'),
+    object: (0, exports.PREFIX_RDF)('object'),
+    type: (0, exports.PREFIX_RDF)('type'),
+    JSON: (0, exports.PREFIX_RDF)('JSON'),
 };
 exports.PREFIX_RDFS = definePrefix('http://www.w3.org/2000/01/rdf-schema#');
 exports.IRIS_RDFS = {
-    imports: exports.PREFIX_RDFS('seeAlso'),
+    imports: (0, exports.PREFIX_RDFS)('seeAlso'),
 };
 exports.PREFIX_XSD = definePrefix('http://www.w3.org/2001/XMLSchema#');
 exports.IRIS_XSD = {
-    string: exports.PREFIX_XSD('string'),
-    boolean: exports.PREFIX_XSD('boolean'),
-    integer: exports.PREFIX_XSD('integer'),
-    number: exports.PREFIX_XSD('number'),
-    int: exports.PREFIX_XSD('int'),
-    byte: exports.PREFIX_XSD('byte'),
-    long: exports.PREFIX_XSD('long'),
-    float: exports.PREFIX_XSD('float'),
-    decimal: exports.PREFIX_XSD('decimal'),
-    double: exports.PREFIX_XSD('double'),
+    string: (0, exports.PREFIX_XSD)('string'),
+    boolean: (0, exports.PREFIX_XSD)('boolean'),
+    integer: (0, exports.PREFIX_XSD)('integer'),
+    number: (0, exports.PREFIX_XSD)('number'),
+    int: (0, exports.PREFIX_XSD)('int'),
+    byte: (0, exports.PREFIX_XSD)('byte'),
+    long: (0, exports.PREFIX_XSD)('long'),
+    float: (0, exports.PREFIX_XSD)('float'),
+    decimal: (0, exports.PREFIX_XSD)('decimal'),
+    double: (0, exports.PREFIX_XSD)('double'),
 };
 exports.PREFIX_DOAP = definePrefix('http://usefulinc.com/ns/doap#');
 exports.IRIS_DOAP = {
-    name: exports.PREFIX_DOAP('name'),
+    name: (0, exports.PREFIX_DOAP)('name'),
 };
 exports.PREFIX_OWL = definePrefix('http://www.w3.org/2002/07/owl#');
 exports.IRIS_OWL = {
-    Restriction: exports.PREFIX_OWL('Restriction'),
+    Restriction: (0, exports.PREFIX_OWL)('Restriction'),
 };
 //# sourceMappingURL=Iris.js.map