componentsjs 4.5.0 → 5.0.0-beta.0

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/RdfParser.d.ts

@@ -41,7 +41,7 @@ export declare type RdfParserOptions = ParseOptions & {
      */
     contexts?: Record<string, any>;
     /**
-     * The cached import paths.
+     * The cached import paths. (URL -> file)
      */
     importPaths?: Record<string, string>;
     /**

package/lib/rdf/RdfParser.js

@@ -20,10 +20,22 @@ class RdfParser {
         // Parsing libraries don't work as expected if path contains backslashes
         options.path = options.path.replace(/\\+/gu, '/');
         if (!options.baseIRI) {
-            options.baseIRI = options.path;
-            // Windows paths always contain a ':'
-            if (!options.baseIRI.includes(':') || /^[A-Za-z]:[/\\][^/]/u.test(options.baseIRI)) {
-                options.baseIRI = `file://${options.baseIRI}`;
+            // Try converting path to URL using defined import paths
+            if (options.importPaths) {
+                for (const [url, file] of Object.entries(options.importPaths)) {
+                    if (options.path.startsWith(file)) {
+                        options.baseIRI = `${url}${options.path.slice(file.length)}`;
+                        break;
+                    }
+                }
+            }
+            // Fallback to a baseIRI using the file scheme
+            if (!options.baseIRI) {
+                options.baseIRI = options.path;
+                // Windows paths always contain a ':'
+                if (!options.baseIRI.includes(':') || /^[A-Za-z]:[/\\][^/]/u.test(options.baseIRI)) {
+                    options.baseIRI = `file://${options.baseIRI}`;
+                }
             }
         }
         // Set JSON-LD parser options

package/lib/rdf/RdfStreamIncluder.js

@@ -51,7 +51,7 @@ class RdfStreamIncluder extends stream_1.Transform {
             // Recursively call the parser
             RdfParser_1.RdfParser.fetchFileOrUrl(relativeFilePath)
                 .then((rawStream) => {
-                const data = new RdfParser_1.RdfParser().parse(rawStream, Object.assign(Object.assign({}, this.parserOptions), { path: relativeFilePath, importedFromPath: this.parserOptions.path }));
+                const data = new RdfParser_1.RdfParser().parse(rawStream, Object.assign(Object.assign({}, this.parserOptions), { baseIRI: undefined, path: relativeFilePath, importedFromPath: this.parserOptions.path }));
                 data
                     .on('data', (subData) => this.push(subData))
                     .on('error', (error) => this.emit('error', error))

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "componentsjs",
-  "version": "4.5.0",
+  "version": "5.0.0-beta.0",
   "description": "A semantic dependency injection framework",
   "lsd:contexts": {
     "https://linkedsoftwaredependencies.org/bundles/npm/componentsjs/^3.0.0/components/context.jsonld": "components/context.jsonld"
@@ -40,7 +40,7 @@
     "jsonld-context-parser": "^2.1.1",
     "minimist": "^1.2.0",
     "rdf-data-factory": "^1.1.0",
-    "rdf-object": "^1.11.1",
+    "rdf-object": "^1.12.0",
     "rdf-parse": "^1.9.1",
     "rdf-quad": "^1.5.0",
     "rdf-terms": "^1.7.0",

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

@@ -1,11 +0,0 @@
-import type { RdfObjectLoader, Resource } from 'rdf-object';
-import type { IParameterPropertyHandler } from './IParameterPropertyHandler';
-/**
- * If no value has been set, but a value is required, throw.
- */
-export declare class ParameterPropertyHandlerRequired 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[];
-}

package/lib/preprocess/parameterproperty/ParameterPropertyHandlerRequired.js

@@ -1,23 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ParameterPropertyHandlerRequired = void 0;
-const ErrorResourcesContext_1 = require("../../util/ErrorResourcesContext");
-/**
- * If no value has been set, but a value is required, throw.
- */
-class ParameterPropertyHandlerRequired {
-    constructor(objectLoader) {
-        this.objectLoader = objectLoader;
-    }
-    canHandle(value, configRoot, parameter, configElement) {
-        return Boolean(value.length === 0 && parameter.property.required);
-    }
-    handle(value, configRoot, parameter, configElement) {
-        throw new ErrorResourcesContext_1.ErrorResourcesContext(`No value was set for required parameter "${parameter.value}"`, {
-            config: configElement,
-            parameter,
-        });
-    }
-}
-exports.ParameterPropertyHandlerRequired = ParameterPropertyHandlerRequired;
-//# sourceMappingURL=ParameterPropertyHandlerRequired.js.map

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

@@ -1,12 +0,0 @@
-import type { RdfObjectLoader } from 'rdf-object';
-import { Resource } from 'rdf-object';
-import type { IParameterPropertyHandler } from './IParameterPropertyHandler';
-/**
- * If the value is singular, and the value should be unique, transform to a single element.
- */
-export declare class ParameterPropertyHandlerUnique 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[];
-}

package/lib/preprocess/parameterproperty/ParameterPropertyHandlerUnique.js

@@ -1,34 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ParameterPropertyHandlerUnique = void 0;
-const rdf_object_1 = require("rdf-object");
-/**
- * If the value is singular, and the value should be unique, transform to a single element.
- */
-class ParameterPropertyHandlerUnique {
-    constructor(objectLoader) {
-        this.objectLoader = objectLoader;
-    }
-    canHandle(value, configRoot, parameter, configElement) {
-        return Boolean(parameter.property.unique && parameter.property.unique.value === 'true' && value.length > 0);
-    }
-    handle(value, configRoot, parameter, configElement) {
-        value = [value[0]];
-        // !!!Hack incoming!!!
-        // We make a manual resource to ensure uniqueness from other resources.
-        // This is needed because literals may occur different times in param values.
-        // This ensures that the unique label is only applied to the current occurrence, instead of all occurrences.
-        // TODO: improve this
-        const newValue = new rdf_object_1.Resource({ term: value[0].term, context: this.objectLoader.contextResolved });
-        for (const key of Object.keys(value[0].properties)) {
-            for (const subValue of value[0].properties[key]) {
-                newValue.properties[key].push(subValue);
-            }
-        }
-        value = [newValue];
-        value[0].property.unique = parameter.property.unique;
-        return value;
-    }
-}
-exports.ParameterPropertyHandlerUnique = ParameterPropertyHandlerUnique;
-//# sourceMappingURL=ParameterPropertyHandlerUnique.js.map