componentsjs 4.4.0 → 5.0.0-beta.1

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

@@ -1,4 +1,5 @@
 import type { RdfObjectLoader, Resource } from 'rdf-object';
+import type { GenericsContext } from '../GenericsContext';
 import type { IParameterPropertyHandler } from './IParameterPropertyHandler';
 /**
  * If a param range is defined, apply the type and validate the range.
@@ -6,8 +7,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, genericsContext: GenericsContext): Resource | undefined;
     /**
      * Apply the given datatype to the given literal.
      * Checks if the datatype is correct and casts to the correct js type.
@@ -15,7 +16,20 @@ export declare class ParameterPropertyHandlerRange implements IParameterProperty
      * 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 genericsContext Context for generic types.
      */
-    captureType(value: Resource, param: Resource): Resource;
-    protected throwIncorrectTypeError(value: Resource, parameter: Resource): void;
+    captureType(value: Resource | undefined, param: Resource, genericsContext: GenericsContext): 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.
+     * @param genericsContext Context for generic types.
+     */
+    hasParamValueValidType(value: Resource | undefined, param: Resource, paramRange: Resource, genericsContext: GenericsContext): boolean;
+    protected throwIncorrectTypeError(value: Resource | undefined, parameter: Resource, genericsContext: GenericsContext): never;
+    rangeToDisplayString(paramRange: Resource | undefined, genericsContext: GenericsContext): 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);
-        }
+    handle(value, configRoot, parameter, configElement, genericsContext) {
+        this.captureType(value, parameter, genericsContext);
         return value;
     }
     /**
@@ -26,11 +24,36 @@ class ParameterPropertyHandlerRange {
      * 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 genericsContext Context for generic types.
+     */
+    captureType(value, param, genericsContext) {
+        if (this.hasParamValueValidType(value, param, param.property.range, genericsContext)) {
+            return value;
+        }
+        this.throwIncorrectTypeError(value, param, genericsContext);
+    }
+    /**
+     * 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.
+     * @param genericsContext Context for generic types.
      */
-    captureType(value, param) {
-        if (value.type === 'Literal') {
+    hasParamValueValidType(value, param, paramRange, genericsContext) {
+        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 +62,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,44 +72,170 @@ 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);
-                    }
-                    else {
-                        value.term.valueRaw = parsed;
+                        return false;
                     }
-                    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, genericsContext));
+            }
+            // Check if the param type is a composed type
+            if (paramRange.isA('ParameterRangeUnion')) {
+                return paramRange.properties.parameterRangeElements
+                    .some(child => this.hasParamValueValidType(value, param, child, genericsContext));
+            }
+            if (paramRange.isA('ParameterRangeIntersection')) {
+                return paramRange.properties.parameterRangeElements
+                    .every(child => this.hasParamValueValidType(value, param, child, genericsContext));
+            }
+            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, genericsContext)) {
+                            tupleIndex++;
+                        }
+                        else {
+                            listIndex++;
+                        }
+                    }
+                    else {
+                        if (!this.hasParamValueValidType(listElements[listIndex], param, tupleTypes[tupleIndex], genericsContext)) {
+                            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 the range refers to a generic type
+            if (paramRange.isA('ParameterRangeGenericTypeReference')) {
+                return genericsContext.bindGenericTypeToValue(paramRange.property.parameterRangeGenericType.value, value, (subValue, subType) => this.hasParamValueValidType(subValue, param, subType, genericsContext));
+            }
+            // Check if the range refers to a component with a generic type
+            if (paramRange.isA('ParameterRangeGenericComponent')) {
+                if (value) {
+                    if (value.property.genericTypeInstances) {
+                        // Once we support manual generics setting, we'll need to check here if we can merge with it.
+                        throw new ErrorResourcesContext_1.ErrorResourcesContext(`Simultaneous manual generic type passing and generic type inference are not supported yet.`, { parameter: param, value });
+                    }
+                    // For the defined generic type instances, apply them into the instance so they can be checked later
+                    value.properties.genericTypeInstances = paramRange.properties.genericTypeInstances
+                        .map(genericTypeInstance => this.objectLoader.createCompactedResource({
+                        type: 'ParameterRangeGenericTypeReference',
+                        parameterRangeGenericType: genericTypeInstance.property.parameterRangeGenericType.value,
+                        parameterRangeGenericBindings: genericsContext
+                            .bindings[genericTypeInstance.property.parameterRangeGenericType.value],
+                    }));
+                }
+                return this.hasParamValueValidType(value, param, paramRange.property.component, genericsContext);
+            }
+            // 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, genericsContext) {
+        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, genericsContext)}"`, Object.assign(Object.assign({ value: value || 'undefined' }, Object.keys(genericsContext.bindings).length > 0 ?
+            { generics: `[\n  ${Object.entries(genericsContext.bindings)
+                    .map(([id, values]) => `<${id}> => ${values.map(subValue => subValue.value)}`)
+                    .join(',\n  ')}\n]` } :
+            {}), { parameter }));
     }
-    throwIncorrectTypeError(value, parameter) {
-        throw new ErrorResourcesContext_1.ErrorResourcesContext(`Parameter value "${value.value}" is not of required range type "${parameter.property.range.value}"`, {
-            parameter,
-        });
+    rangeToDisplayString(paramRange, genericsContext) {
+        if (!paramRange) {
+            return `any`;
+        }
+        if (paramRange.isA('ParameterRangeUndefined')) {
+            return `undefined`;
+        }
+        if (paramRange.isA('ParameterRangeArray')) {
+            return `${this.rangeToDisplayString(paramRange.property.parameterRangeValue, genericsContext)}[]`;
+        }
+        if (paramRange.isA('ParameterRangeRest')) {
+            return `...${this.rangeToDisplayString(paramRange.property.parameterRangeValue, genericsContext)}`;
+        }
+        if (paramRange.isA('ParameterRangeUnion')) {
+            return paramRange.properties.parameterRangeElements
+                .map(child => this.rangeToDisplayString(child, genericsContext))
+                .join(' | ');
+        }
+        if (paramRange.isA('ParameterRangeIntersection')) {
+            return paramRange.properties.parameterRangeElements
+                .map(child => this.rangeToDisplayString(child, genericsContext))
+                .join(' & ');
+        }
+        if (paramRange.isA('ParameterRangeTuple')) {
+            return `[${paramRange.properties.parameterRangeElements
+                .map(child => this.rangeToDisplayString(child, genericsContext))
+                .join(', ')}]`;
+        }
+        if (paramRange.isA('ParameterRangeLiteral')) {
+            return paramRange.property.parameterRangeValue.value;
+        }
+        if (paramRange.isA('ParameterRangeGenericTypeReference')) {
+            const valid = paramRange.property.parameterRangeGenericType.value in genericsContext.genericTypeIds;
+            return `<${valid ? '' : 'UNKNOWN GENERIC: '}${paramRange.property.parameterRangeGenericType.value}>`;
+        }
+        if (paramRange.isA('ParameterRangeGenericComponent')) {
+            return `(${this.rangeToDisplayString(paramRange.property.component, genericsContext)})${paramRange.properties.genericTypeInstances
+                .map(genericTypeInstance => this.rangeToDisplayString(genericTypeInstance, genericsContext)).join('')}`;
+        }
+        return paramRange.value;
     }
 }
 exports.ParameterPropertyHandlerRange = ParameterPropertyHandlerRange;

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

package/lib/rdf/RdfParser.d.ts

@@ -1,6 +1,6 @@
 /// <reference types="node" />
 import type { Readable } from 'stream';
-import type * as RDF from 'rdf-js';
+import type * as RDF from '@rdfjs/types';
 import type { ParseOptions } from 'rdf-parse';
 import type { Logger } from 'winston';
 /**
@@ -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
@@ -61,7 +73,7 @@ class RdfParser {
         if (!(await fs.stat(pathOrUrl)).isFile()) {
             throw new Error(`Path does not refer to a valid file: ${pathOrUrl}`);
         }
-        return fs_1.createReadStream(pathOrUrl);
+        return (0, fs_1.createReadStream)(pathOrUrl);
     }
     /**
      * Add the path to an error message.

package/lib/rdf/RdfStreamIncluder.d.ts

@@ -1,7 +1,7 @@
 /// <reference types="node" />
 import type { TransformCallback } from 'stream';
 import { Transform } from 'stream';
-import type * as RDF from 'rdf-js';
+import type * as RDF from '@rdfjs/types';
 import type { RdfParserOptions } from './RdfParser';
 /**
  * A RdfStreamIncluder takes a triple stream and detects owl:includes to automatically include other files.

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))
@@ -70,7 +70,7 @@ class RdfStreamIncluder extends stream_1.Transform {
      */
     validateIris(quad) {
         if (this.parserOptions.logger) {
-            for (const term of rdf_terms_1.getNamedNodes(rdf_terms_1.getTerms(quad))) {
+            for (const term of (0, rdf_terms_1.getNamedNodes)((0, rdf_terms_1.getTerms)(quad))) {
                 if (!RdfStreamIncluder.isValidIri(term.value)) {
                     this.parserOptions.logger.warn(`Detected potentially invalid IRI '${term.value}' in ${this.parserOptions.path}`);
                 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "componentsjs",
-  "version": "4.4.0",
+  "version": "5.0.0-beta.1",
   "description": "A semantic dependency injection framework",
   "lsd:contexts": {
     "https://linkedsoftwaredependencies.org/bundles/npm/componentsjs/^3.0.0/components/context.jsonld": "components/context.jsonld"
@@ -33,17 +33,17 @@
     "version": "manual-git-changelog onversion"
   },
   "dependencies": {
+    "@rdfjs/types": "*",
     "@types/minimist": "^1.2.0",
     "@types/node": "^14.14.7",
-    "@types/rdf-js": "*",
     "@types/semver": "^7.3.4",
     "jsonld-context-parser": "^2.1.1",
     "minimist": "^1.2.0",
-    "rdf-data-factory": "^1.0.4",
-    "rdf-object": "^1.8.0",
-    "rdf-parse": "^1.8.1",
+    "rdf-data-factory": "^1.1.0",
+    "rdf-object": "^1.12.0",
+    "rdf-parse": "^1.9.1",
     "rdf-quad": "^1.5.0",
-    "rdf-terms": "^1.6.2",
+    "rdf-terms": "^1.7.0",
     "semver": "^7.3.2",
     "winston": "^3.3.3"
   },
@@ -51,7 +51,7 @@
     "@rubensworks/eslint-config": "^1.0.1",
     "@typescript-eslint/eslint-plugin": "^4.6.1",
     "@typescript-eslint/parser": "^4.6.1",
-    "@types/jest": "^26.0.23",
+    "@types/jest": "^27.0.0",
     "eslint": "^7.12.1",
     "eslint-config-es": "3.25.3",
     "eslint-import-resolver-typescript": "^2.3.0",
@@ -60,14 +60,14 @@
     "eslint-plugin-tsdoc": "^0.2.7",
     "eslint-plugin-unused-imports": "^1.0.0",
     "jest": "^27.0.1",
-    "jest-rdf": "^1.6.0",
+    "jest-rdf": "^1.7.0",
     "jshint": "^2.1.10",
     "manual-git-changelog": "^1.0.1",
-    "n3": "^1.6.3",
+    "n3": "^1.11.1",
     "pre-commit": "^1.2.2",
     "streamify-string": "^1.0.1",
     "ts-jest": "^27.0.1",
-    "typescript": "^4.0.3"
+    "typescript": "^4.3.5"
   },
   "files": [
     "components",

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