componentsjs 4.4.1 → 5.0.0-beta.2

package/CHANGELOG.md

@@ -1,6 +1,52 @@
 # Changelog
 All notable changes to this project will be documented in this file.
 
+<a name="v5.0.0-beta.2"></a>
+## [v5.0.0-beta.2](https://github.com/LinkedSoftwareDependencies/Components.js/compare/v5.0.0-beta.1...v5.0.0-beta.2) - 2021-12-09
+
+### Added
+* [Handle keyof parameter ranges](https://github.com/LinkedSoftwareDependencies/Components.js/commit/0f55ba05bff5311d111ca97256aaa2e7be7ae83b)
+
+<a name="v5.0.0-beta.1"></a>
+## [v5.0.0-beta.1](https://github.com/LinkedSoftwareDependencies/Components.js/compare/v5.0.0-beta.0...v5.0.0-beta.1) - 2021-12-07
+
+### Added
+* [Handle generics in nested components](https://github.com/LinkedSoftwareDependencies/Components.js/commit/d33d4c2668974087873943b3d5c66300fa3df65b)
+* [Handle generics in parameter ranges](https://github.com/LinkedSoftwareDependencies/Components.js/commit/d3358b74ab25a3aca13d6dfc97b16cfd836d4ba9)
+* [Add generic vocabulary changes to context](https://github.com/LinkedSoftwareDependencies/Components.js/commit/b8af018bb8f344833c07d1ef795a6b08d414c2ad)
+
+<a name="v5.0.0-beta.0"></a>
+## [v5.0.0-beta.0](https://github.com/LinkedSoftwareDependencies/Components.js/compare/v4.5.0...v5.0.0-beta.0) - 2021-11-30
+
+### BREAKING CHANGES
+* [Remove required and unique param flags in favor of parameter ranges](https://github.com/LinkedSoftwareDependencies/Components.js/commit/0df26318e4803b06660b3458fc75d565c4b60f67):
+  This allows more complex ranges to be defined, such as nested arrays, or arrays of union types.
+  **Because of this change, arrays now must always be explicitly defined within an RDF list (or @list in JSON-LD).**
+  If one param value is provided, it is considered a singular value.
+  If the param value contains an RDF list, it is considered an array.
+  If multiple param values are provided without RDF list, an error is thrown.
+
+### Added
+* Validate parameter values by type:
+  * [Validate param ranges with union and intersection types](https://github.com/LinkedSoftwareDependencies/Components.js/commit/d08ecdb94051d3e88e7e1ea09f0f77518fb0debf)
+  * [Validate types of resource-based param values](https://github.com/LinkedSoftwareDependencies/Components.js/commit/2be90ccb416215261ef9c785e89302f3c4ef9264)
+  * [Validate param ranges with tuple types](https://github.com/LinkedSoftwareDependencies/Components.js/commit/05d84c4c1d4bde6bcb5a99d53df4e66ca69536bf)
+  * [Validate param ranges with literal types](https://github.com/LinkedSoftwareDependencies/Components.js/commit/7373b0fc06bdaf95a8099b9f58b741cd6f4f1b9d)
+
+### Changed
+* [Allow IRIs to be casted to string params](https://github.com/LinkedSoftwareDependencies/Components.js/commit/978985684dcba67629d44bfd0e5cf75293c5ea7a)
+* [Allow components to be registered to multiple modules](https://github.com/LinkedSoftwareDependencies/Components.js/commit/e575e64ebd26092a6bb005d837023e35877e9308)
+* [Make relative IRIs make use of importPaths-based URLs if possible](https://github.com/LinkedSoftwareDependencies/Components.js/commit/6a2e18c3bf6a1b95f826b66ee0ef8b154f10c3cc)
+
+### Fixed
+* [Fix raw JSON values not being serializable to strings](https://github.com/LinkedSoftwareDependencies/Components.js/commit/96fe46eda1e153e87b29689196506ce6fbbdae58)
+
+<a name="v4.5.0"></a>
+## [v4.5.0](https://github.com/LinkedSoftwareDependencies/Components.js/compare/v4.4.1...v4.5.0) - 2021-08-30
+
+### Changed
+* [Migrate to @rdfjs/types](https://github.com/LinkedSoftwareDependencies/Components.js/commit/b2f9f2e0c5512e743b324f48f332d96e4214ec84)
+
 <a name="v4.4.1"></a>
 ## [v4.4.1](https://github.com/LinkedSoftwareDependencies/Components.js/compare/v4.4.0...v4.4.1) - 2021-07-26
 

package/bin/compile-config.js

@@ -30,7 +30,7 @@ if (args.e) {
     exportVariableName = args.e;
 }
 const asFunction = !!args.f;
-__1.compileConfig(mainModulePath, configPath, configResourceUri, exportVariableName, asFunction)
+(0, __1.compileConfig)(mainModulePath, configPath, configResourceUri, exportVariableName, asFunction)
     .then((output) => process.stdout.write(`${output}\n`))
     .catch(error => {
     process.stderr.write(`${error.stack}\n`);

package/components/context.jsonld

@@ -22,9 +22,19 @@
     "components": {
       "@id": "oo:component"
     },
+    "component": {
+      "@id": "oo:component",
+      "@type": "@id"
+    },
     "parameters": {
       "@id": "oo:parameter"
     },
+    "memberKeys": {
+      "@id": "oo:memberKey"
+    },
+    "genericTypeParameters": {
+      "@id": "oo:genericTypeParameter"
+    },
     "constructorArguments": {
       "@id": "oo:constructorArguments",
       "@container": "@list"
@@ -61,6 +71,66 @@
     "undefined": {
       "@id": "oo:isUndefined"
     },
+    "ParameterRange": {
+      "@id": "oo:ParameterRange"
+    },
+    "ParameterRangeUndefined": {
+      "@id": "oo:ParameterRangeUndefined"
+    },
+    "ParameterRangeArray": {
+      "@id": "oo:ParameterRangeArray"
+    },
+    "ParameterRangeRest": {
+      "@id": "oo:ParameterRangeRest"
+    },
+    "ParameterRangeKeyof": {
+      "@id": "oo:ParameterRangeKeyof"
+    },
+    "ParameterRangeLiteral": {
+      "@id": "oo:ParameterRangeLiteral"
+    },
+    "parameterRangeValue": {
+      "@id": "oo:parameterRangeValue",
+      "@type": "@id"
+    },
+    "parameterRangeValueLiteral": {
+      "@id": "oo:parameterRangeValue"
+    },
+    "ParameterRangeUnion": {
+      "@id": "oo:ParameterRangeUnion"
+    },
+    "ParameterRangeIntersection": {
+      "@id": "oo:ParameterRangeIntersection"
+    },
+    "parameterRangeElements": {
+      "@id": "oo:parameterRangeElements",
+      "@type": "@id"
+    },
+    "ParameterRangeCollectEntries": {
+      "@id": "oo:ParameterRangeCollectEntries"
+    },
+    "parameterRangeCollectEntriesParameters": {
+      "@id": "oo:parameterRangeCollectEntriesParameter",
+      "@type": "@id"
+    },
+    "ParameterRangeGenericComponent": {
+      "@id": "oo:ParameterRangeGenericComponent"
+    },
+    "genericTypeInstances": {
+      "@id": "oo:genericTypeInstance",
+      "@type": "@id"
+    },
+    "ParameterRangeGenericTypeReference": {
+      "@id": "oo:ParameterRangeGenericTypeReference"
+    },
+    "parameterRangeGenericType": {
+      "@id": "oo:parameterRangeGenericType",
+      "@type": "@id"
+    },
+    "parameterRangeGenericBindings": {
+      "@id": "oo:parameterRangeGenericBindings",
+      "@type": "@id"
+    },
 
     "rdfs": "http://www.w3.org/2000/01/rdf-schema#",
     "comment": {
@@ -116,7 +186,8 @@
     },
     "fields": {
       "@id": "om:field",
-      "@type": "om:ObjectMapEntry"
+      "@type": "om:ObjectMapEntry",
+      "@container": "@list"
     },
     "elements": {
       "@id": "om:elements",
@@ -125,7 +196,8 @@
     },
     "collectEntries": {
       "@id": "om:collectsEntriesFrom",
-      "@type": "@id"
+      "@type": "@id",
+      "@container": "@list"
     },
     "keyRaw": {
       "@id": "om:fieldName"

package/lib/construction/ConfigConstructor.js

@@ -31,22 +31,15 @@ class ConfigConstructor {
         this.moduleState = options.moduleState;
     }
     async getArgumentValues(values, settings) {
-        // Unwrap unique values out of the array
-        if (values.length > 0 && values[0].property.unique && values[0].property.unique.value === 'true') {
-            return this.getArgumentValue(values[0], settings);
+        if (values.length === 0) {
+            return this.constructionStrategy.createUndefined();
         }
-        // Unwrap RDF list-based values out of the array
-        if (values.length > 0 && values.some(value => value.list)) {
-            if (values.length > 1) {
-                throw new ErrorResourcesContext_1.ErrorResourcesContext(`Detected multiple values for an argument while only a single RDF list is allowed`, {
-                    arguments: values.flatMap(value => value.list ? value.list : [value]),
-                });
-            }
-            return this.getArgumentValue(values[0], settings);
+        if (values.length > 1) {
+            throw new ErrorResourcesContext_1.ErrorResourcesContext(`Detected multiple values for an argument. RDF lists should be used for defining multiple values.`, {
+                arguments: values,
+            });
         }
-        // Otherwise, keep the array form
-        const elements = await Promise.all(values.map(element => this.getArgumentValue(element, settings)));
-        return this.constructionStrategy.createArray({ settings, elements });
+        return this.getArgumentValue(values[0], settings);
     }
     async getArgumentValue(value, settings) {
         // Check if this args resource can be handled by one of the built-in handlers.

package/lib/construction/argument/ArgumentConstructorHandlerHash.js

@@ -7,11 +7,12 @@ const ErrorResourcesContext_1 = require("../../util/ErrorResourcesContext");
  */
 class ArgumentConstructorHandlerHash {
     canHandle(value, settings, argsCreator) {
-        return Boolean(value.property.fields || value.property.hasFields);
+        return Boolean(value.property.fields);
     }
     async handle(argument, settings, argsCreator) {
+        const fields = argument.property.fields.list || [];
         // Determine all key-value pairs
-        const entries = await Promise.all(argument.properties.fields.map(async (entry) => {
+        const entries = await Promise.all(fields.map(async (entry) => {
             // Validate entry
             if (!entry.property.key) {
                 throw new ErrorResourcesContext_1.ErrorResourcesContext(`Missing key in fields entry`, { entry, argument });

package/lib/construction/strategy/ConstructionStrategyCommonJsString.js

@@ -103,6 +103,9 @@ class ConstructionStrategyCommonJsString {
         return `new function() { return Promise.resolve(${await options.supplier()}); }`;
     }
     createPrimitive(options) {
+        if (typeof options.value === 'object') {
+            return JSON.stringify(options.value);
+        }
         return typeof options.value === 'string' ? `'${options.value}'` : `${options.value}`;
     }
     getVariableValue(options) {

package/lib/construction/strategy/IConstructionStrategy.d.ts

@@ -111,9 +111,9 @@ export interface ICreationStrategyPrimitiveOptions<Instance> {
      */
     settings: IConstructionSettings;
     /**
-     * A string or number value.
+     * A string, number or object value.
      */
-    value: string | number;
+    value: string | number | any;
 }
 export interface ICreationStrategyVariableOptions<Instance> {
     /**

package/lib/loading/ComponentRegistry.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 { Resource, RdfObjectLoader } from 'rdf-object';
 import type { Logger } from 'winston';
 import type { IModuleState } from './ModuleStateBuilder';

package/lib/loading/ComponentRegistry.js

@@ -55,7 +55,7 @@ class ComponentRegistry {
     registerModuleResource(moduleResource) {
         if (moduleResource.property.components) {
             for (const component of moduleResource.properties.components) {
-                component.property.module = moduleResource;
+                component.properties.module.push(moduleResource);
                 this.registerComponent(component);
             }
         }

package/lib/loading/ComponentRegistryFinalizer.js

@@ -75,11 +75,26 @@ class ComponentRegistryFinalizer {
      * @param extendingConstructorArgs The constructor argument resources to inherit from.
      */
     inheritConstructorArgumentsEntry(constructorArg, extendingConstructorArgs) {
+        // Make sure that we have fields in list-form
+        if (constructorArg.property.fields && !constructorArg.property.fields.list) {
+            if (constructorArg.properties.fields.length > 1) {
+                throw new ErrorResourcesContext_1.ErrorResourcesContext(`Invalid fields: Only one value can be defined, or an RDF list must be provided`, {
+                    constructorArg,
+                });
+            }
+            constructorArg.property.fields = this.objectLoader.createCompactedResource({
+                list: constructorArg.properties.fields,
+            });
+        }
         for (const extendingConstructorArg of extendingConstructorArgs) {
             if (extendingConstructorArg.property.fields) {
-                for (const field of extendingConstructorArg.properties.fields) {
-                    if (!constructorArg.properties.fields.includes(field)) {
-                        constructorArg.properties.fields.push(field);
+                // Inherit fields
+                for (const field of extendingConstructorArg.property.fields.list || extendingConstructorArg.properties.fields) {
+                    if (!constructorArg.property.fields) {
+                        constructorArg.property.fields = this.objectLoader.createCompactedResource({ list: [] });
+                    }
+                    if (!constructorArg.property.fields.list.includes(field)) {
+                        constructorArg.property.fields.list.push(field);
                     }
                 }
             }

package/lib/loading/ComponentsManagerBuilder.js

@@ -33,7 +33,7 @@ class ComponentsManagerBuilder {
             Boolean(options.skipContextValidation);
     }
     static createLogger(logLevel = 'warn') {
-        return winston_1.createLogger({
+        return (0, winston_1.createLogger)({
             level: logLevel,
             format: winston_1.format.combine(winston_1.format.label({ label: 'Components.js' }), winston_1.format.colorize(), winston_1.format.timestamp(), winston_1.format.printf(({ level: levelInner, message, label: labelInner, timestamp }) => `${timestamp} [${labelInner}] ${levelInner}: ${message}`)),
             transports: [new winston_1.transports.Console({

package/lib/loading/ConfigRegistry.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 { RdfObjectLoader } from 'rdf-object';
 import type { Logger } from 'winston';
 import type { IModuleState } from './ModuleStateBuilder';

package/lib/preprocess/ConfigPreprocessorComponent.d.ts

@@ -1,5 +1,6 @@
 import type { Resource, RdfObjectLoader } from 'rdf-object';
 import type { Logger } from 'winston';
+import { GenericsContext } from './GenericsContext';
 import type { IConfigPreprocessor } from './IConfigPreprocessor';
 import type { ParameterHandler } from './ParameterHandler';
 /**
@@ -15,12 +16,13 @@ export declare class ConfigPreprocessorComponent implements IConfigPreprocessor<
     constructor(options: IComponentConfigPreprocessorOptions);
     canHandle(config: Resource): IComponentConfigPreprocessorHandleResponse | undefined;
     transform(config: Resource, handleResponse: IComponentConfigPreprocessorHandleResponse): Resource;
+    protected createGenericsContext(handleResponse: IComponentConfigPreprocessorHandleResponse, config: Resource): GenericsContext;
     /**
      * Determine the constructor arguments of the given config.
      * @param config A config.
      * @param handleResponse Return value of the {#canHandle}.
      */
-    transformConstructorArguments(config: Resource, handleResponse: IComponentConfigPreprocessorHandleResponse): Resource[];
+    transformConstructorArguments(config: Resource, handleResponse: IComponentConfigPreprocessorHandleResponse): Resource;
     /**
      * Let this config inherit parameter values from previously instantiated configs.
      * This will check for inheritanceValues that are defined on the component,

package/lib/preprocess/ConfigPreprocessorComponent.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ConfigPreprocessorComponent = void 0;
 const Iris_1 = require("../rdf/Iris");
 const ErrorResourcesContext_1 = require("../util/ErrorResourcesContext");
+const GenericsContext_1 = require("./GenericsContext");
 /**
  * Handles config that refer to a component as type.
  * The component may have parameters that can be applied on the config.
@@ -82,34 +83,59 @@ class ConfigPreprocessorComponent {
         if (requireElement) {
             configRaw.property.requireElement = requireElement;
         }
-        configRaw.properties.arguments = this.transformConstructorArguments(config, handleResponse);
+        configRaw.property.arguments = this.transformConstructorArguments(config, handleResponse);
         // Validate the input config
         this.validateConfig(config, handleResponse);
         return configRaw;
     }
+    createGenericsContext(handleResponse, config) {
+        const genericsContext = new GenericsContext_1.GenericsContext(this.objectLoader, handleResponse.component.properties.genericTypeParameters);
+        // Populate with manually defined generic type bindings
+        const genericTypesInner = handleResponse.component.properties.genericTypeParameters;
+        if (genericTypesInner.length < config.properties.genericTypeInstances.length) {
+            throw new ErrorResourcesContext_1.ErrorResourcesContext(`Invalid generic type instantiations: more generic types are passed than are defined on the component.`, {
+                config,
+                component: handleResponse.component,
+            });
+        }
+        for (const [i, genericTypeInstance] of config.properties.genericTypeInstances.entries()) {
+            // Remap generic type IRI to inner generic type IRI
+            const genericTypeIdInner = genericTypesInner[i].value;
+            genericsContext.bindings[genericTypeIdInner] = genericTypeInstance.properties.parameterRangeGenericBindings;
+            genericsContext.genericTypeIds[genericTypeIdInner] = true;
+        }
+        return genericsContext;
+    }
     /**
      * Determine the constructor arguments of the given config.
      * @param config A config.
      * @param handleResponse Return value of the {#canHandle}.
      */
     transformConstructorArguments(config, handleResponse) {
-        // Create a single-arg hash constructor, and add all params as key-value pairs
-        const param0 = this.objectLoader.createCompactedResource({
-            // Hack to enforce ArgumentConstructorHandlerHash
-            hasFields: '"true"',
-        });
+        const entries = [];
+        const genericsContext = this.createGenericsContext(handleResponse, config);
         for (const fieldData of handleResponse.component.properties.parameters) {
             const field = this.objectLoader.createCompactedResource({});
             field.property.key = this.objectLoader.createCompactedResource(`"${fieldData.term.value}"`);
-            for (const value of this.parameterHandler.applyParameterValues(handleResponse.component, fieldData, config)) {
-                field.properties.value.push(value);
+            const value = this.parameterHandler
+                .applyParameterValues(handleResponse.component, fieldData, config, genericsContext);
+            if (value) {
+                field.property.value = value;
             }
-            param0.properties.fields.push(field);
+            entries.push(field);
         }
+        // Create a single-arg hash constructor, and add all params as key-value pairs
+        const param0 = this.objectLoader.createCompactedResource({
+            fields: {
+                list: entries,
+            },
+        });
         // Create constructor arguments list
-        const args = this.objectLoader.createCompactedResource({});
-        args.list = [param0];
-        return [args];
+        return this.objectLoader.createCompactedResource({
+            list: [
+                param0,
+            ],
+        });
     }
     /**
      * Let this config inherit parameter values from previously instantiated configs.

package/lib/preprocess/ConfigPreprocessorComponentMapped.d.ts

@@ -2,6 +2,7 @@ import type { Resource } from 'rdf-object';
 import type { IComponentConfigPreprocessorHandleResponse } from './ConfigPreprocessorComponent';
 import { ConfigPreprocessorComponent } from './ConfigPreprocessorComponent';
 import type { IConstructorArgumentsMapper } from './constructorargumentsmapping/IConstructorArgumentsMapper';
+import type { GenericsContext } from './GenericsContext';
 /**
  * Handles config that refer to a component as type.
  * The component may have parameters that can be applied on the config.
@@ -10,7 +11,7 @@ import type { IConstructorArgumentsMapper } from './constructorargumentsmapping/
 export declare class ConfigPreprocessorComponentMapped extends ConfigPreprocessorComponent implements IConstructorArgumentsMapper {
     private readonly mappingHandlers;
     canHandle(config: Resource): IComponentConfigPreprocessorHandleResponse | undefined;
-    transformConstructorArguments(config: Resource, handleResponse: IComponentConfigPreprocessorHandleResponse): Resource[];
-    applyConstructorArgumentsParameters(configRoot: Resource, constructorArgs: Resource, configElement: Resource): Resource[];
-    getParameterValue(configRoot: Resource, parameter: Resource, configElement: Resource, rawValue: boolean): Resource[];
+    transformConstructorArguments(config: Resource, handleResponse: IComponentConfigPreprocessorHandleResponse): Resource;
+    applyConstructorArgumentsParameters(configRoot: Resource, constructorArgs: Resource, configElement: Resource, genericsContext: GenericsContext): Resource;
+    getParameterValue(configRoot: Resource, parameter: Resource, configElement: Resource, rawValue: boolean, genericsContext: GenericsContext): Resource | undefined;
 }

package/lib/preprocess/ConfigPreprocessorComponentMapped.js

@@ -33,39 +33,38 @@ class ConfigPreprocessorComponentMapped extends ConfigPreprocessorComponent_1.Co
     }
     transformConstructorArguments(config, handleResponse) {
         const constructorArgs = handleResponse.component.property.constructorArguments;
-        return this.applyConstructorArgumentsParameters(config, constructorArgs, config);
+        const genericsContext = this.createGenericsContext(handleResponse, config);
+        return this.applyConstructorArgumentsParameters(config, constructorArgs, config, genericsContext);
     }
-    applyConstructorArgumentsParameters(configRoot, constructorArgs, configElement) {
+    applyConstructorArgumentsParameters(configRoot, constructorArgs, configElement, genericsContext) {
         // Check if this constructor args resource can be handled by one of the built-in handlers.
         for (const handler of this.mappingHandlers) {
-            if (handler.canHandle(configRoot, constructorArgs, configElement, this)) {
-                return handler.handle(configRoot, constructorArgs, configElement, this);
+            if (handler.canHandle(configRoot, constructorArgs, configElement, this, genericsContext)) {
+                return handler.handle(configRoot, constructorArgs, configElement, this, genericsContext);
             }
         }
         // Fallback to original constructor args
-        return [constructorArgs];
+        return constructorArgs;
     }
-    getParameterValue(configRoot, parameter, configElement, rawValue) {
-        var _a;
+    getParameterValue(configRoot, parameter, configElement, rawValue, genericsContext) {
         let valueOut;
         if (parameter.type === 'NamedNode' && parameter.value === Iris_1.IRIS_RDF.subject) {
-            valueOut = [this.objectLoader.createCompactedResource(`"${configElement.value}"`)];
-            valueOut[0].property.unique = this.objectLoader.createCompactedResource('"true"');
+            valueOut = this.objectLoader.createCompactedResource(`"${configElement.value}"`);
         }
-        else if (parameter.type === 'NamedNode') {
-            valueOut = this.parameterHandler.applyParameterValues(configRoot, parameter, configElement);
+        else if (parameter.type === 'NamedNode' && !parameter.property.fields) {
+            valueOut = this.parameterHandler
+                .applyParameterValues(configRoot, parameter, configElement, genericsContext);
         }
         else {
-            valueOut = this.applyConstructorArgumentsParameters(configRoot, parameter, configElement);
+            valueOut = this.applyConstructorArgumentsParameters(configRoot, parameter, configElement, genericsContext);
         }
         // If the referenced IRI should become a plain string
         if (rawValue) {
-            const unique = ((_a = valueOut[0].property.unique) === null || _a === void 0 ? void 0 : _a.value) === 'true';
-            valueOut = [this.objectLoader.createCompactedResource(`"${valueOut[0].value}"`)];
-            // Make sure to inherit the original param's unique flag
-            if (unique) {
-                valueOut[0].property.unique = this.objectLoader.createCompactedResource('"true"');
-            }
+            valueOut = (valueOut === null || valueOut === void 0 ? void 0 : valueOut.list) ?
+                this.objectLoader.createCompactedResource({
+                    list: valueOut.list.map(valueOutSub => `"${valueOutSub.value}"`),
+                }) :
+                this.objectLoader.createCompactedResource(`"${valueOut ? valueOut.value : 'undefined'}"`);
         }
         return valueOut;
     }

package/lib/preprocess/GenericsContext.d.ts

@@ -0,0 +1,30 @@
+import type { Resource, RdfObjectLoader } from 'rdf-object';
+/**
+ * Context for binding generic types to a concrete range value.
+ */
+export declare class GenericsContext {
+    private readonly objectLoader;
+    /**
+     * Set of generic type ids.
+     * @private
+     */
+    readonly genericTypeIds: Record<string, boolean>;
+    /**
+     * Mapping of generic type id to the resolved range.
+     * @private
+     */
+    readonly bindings: Record<string, Resource[]>;
+    constructor(objectLoader: RdfObjectLoader, genericTypeParameters: Resource[]);
+    /**
+     * Try to to bind the given value to the given generic.
+     * @param genericTypeId IRI of the generic to bind.
+     * @param value The value to bind to.
+     * @param typeValidator Callback for validating values against types.
+     */
+    bindGenericTypeToValue(genericTypeId: string, value: Resource | undefined, typeValidator: (subValue: Resource | undefined, subType: Resource) => boolean): boolean;
+    /**
+     * Infer the parameter range of the given value.
+     * @param value A value.
+     */
+    inferValueRange(value: Resource | undefined): Resource[];
+}

package/lib/preprocess/GenericsContext.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GenericsContext = void 0;
+/**
+ * Context for binding generic types to a concrete range value.
+ */
+class GenericsContext {
+    constructor(objectLoader, genericTypeParameters) {
+        this.objectLoader = objectLoader;
+        this.genericTypeIds = Object.fromEntries(genericTypeParameters
+            .map(genericTypeParameter => [genericTypeParameter.value, true]));
+        this.bindings = {};
+        for (const genericTypeParameter of genericTypeParameters) {
+            if (genericTypeParameter.property.range) {
+                this.bindings[genericTypeParameter.value] = genericTypeParameter.properties.range;
+            }
+        }
+    }
+    /**
+     * Try to to bind the given value to the given generic.
+     * @param genericTypeId IRI of the generic to bind.
+     * @param value The value to bind to.
+     * @param typeValidator Callback for validating values against types.
+     */
+    bindGenericTypeToValue(genericTypeId, value, typeValidator) {
+        // Fail if an unknown generic type is referenced
+        if (!(genericTypeId in this.genericTypeIds)) {
+            return false;
+        }
+        // If the generic was already bound to a range, validate it
+        const existingRange = this.bindings[genericTypeId];
+        if (existingRange && existingRange.some(existingRangeElement => !typeValidator(value, existingRangeElement))) {
+            return false;
+        }
+        // Infer type of value
+        const valueRange = this.inferValueRange(value);
+        if (valueRange.length > 0) {
+            // If we already had a range, try to align them
+            // TODO: this will be needed for resources with common inheritance hierarchies
+            // Save inferred type
+            this.bindings[genericTypeId] = valueRange;
+        }
+        return true;
+    }
+    /**
+     * Infer the parameter range of the given value.
+     * @param value A value.
+     */
+    inferValueRange(value) {
+        // Value is undefined
+        if (!value) {
+            return [this.objectLoader.createCompactedResource({ type: 'ParameterRangeUndefined' })];
+        }
+        // Value is a literal
+        if (value.term.termType === 'Literal') {
+            return [this.objectLoader.createCompactedResource(value.term.datatype)];
+        }
+        // Value is a named node
+        return value.properties.type;
+    }
+}
+exports.GenericsContext = GenericsContext;
+//# sourceMappingURL=GenericsContext.js.map

package/lib/preprocess/ParameterHandler.d.ts

@@ -1,4 +1,5 @@
 import type { RdfObjectLoader, Resource } from 'rdf-object';
+import type { GenericsContext } from './GenericsContext';
 /**
  * Handles component parameters in the context of a config.
  */
@@ -11,9 +12,10 @@ export declare class ParameterHandler {
      * @param configRoot The root config resource that we are working in.
      * @param parameter The parameter resource to get the value for.
      * @param configElement Part of the config resource to look for parameter instantiations as predicates.
-     * @return The parameter value(s)
+     * @param genericsContext Context for generic types.
+     * @return - The parameter value
      */
-    applyParameterValues(configRoot: Resource, parameter: Resource, configElement: Resource): Resource[];
+    applyParameterValues(configRoot: Resource, parameter: Resource, configElement: Resource, genericsContext: GenericsContext): Resource | undefined;
 }
 export interface IParameterHandlerOptions {
     objectLoader: RdfObjectLoader;