componentsjs 5.0.0-beta.0 → 5.0.0-beta.1

package/CHANGELOG.md

@@ -0,0 +1,231 @@
+# Changelog
+All notable changes to this project will be documented in this file.
+
+<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
+
+### Fixed
+* [Fix RDF lists not being accepted for all params](https://github.com/LinkedSoftwareDependencies/Components.js/commit/a01e3c80a3a5ce28180f57e8358327c53774b9ba)
+
+<a name="v4.4.0"></a>
+## [v4.4.0](https://github.com/LinkedSoftwareDependencies/Components.js/compare/v4.2.1...v4.4.0) - 2021-06-30
+
+### Added
+* [Accept RDF lists as argument values, #47](https://github.com/LinkedSoftwareDependencies/Components.js/commit/3501a0fe676d1bc43c2d3ad329fca0adef48c8cd)
+
+### Changed
+* [Allow arrays of resources to be passed to ErrorResourcesContext](https://github.com/LinkedSoftwareDependencies/Components.js/commit/aedd53a3e923e030bf0d8433c27f1259183a0a14)
+
+<a name="v4.3.0"></a>
+## [v4.3.0](https://github.com/LinkedSoftwareDependencies/Components.js/compare/v4.2.1...v4.3.0) - 2021-06-14
+
+### Added
+* [Support JSON param ranges via rdf:JSON, Closes #37](https://github.com/LinkedSoftwareDependencies/Components.js/commit/339d2219915bc618991a42adcd8b63a3d6caa9b5)
+
+<a name="v4.2.1"></a>
+## [v4.2.1](https://github.com/LinkedSoftwareDependencies/Components.js/compare/v4.2.0...v4.2.1) - 2021-05-26
+
+### Fixed
+* [Allow configs to have multiple identical types, comunica/examples#11](https://github.com/LinkedSoftwareDependencies/Components.js/commit/5285f8e68fefb13d46538c6949238200055a2047)
+
+<a name="v4.2.0"></a>
+## [v4.2.0](https://github.com/LinkedSoftwareDependencies/Components.js/compare/v4.1.0...v4.2.0) - 2021-05-19
+
+### Added
+* [Expose RdfObjectLoader ctor from ComponentsManagerBuilder](https://github.com/LinkedSoftwareDependencies/Components.js/commit/1b1c85adb50855eed5b628788ccea3609aa841ca)
+
+<a name="v4.1.0"></a>
+## [v4.1.0](https://github.com/LinkedSoftwareDependencies/Components.js/compare/v4.0.6...v4.1.0) - 2021-04-27
+
+### Added
+* [Allow JSON-LD context validation to be skipped](https://github.com/LinkedSoftwareDependencies/Components.js/commit/40931625dc0a577800c60e0cb4aa12393eb26bab)
+
+<a name="v4.0.6"></a>
+## [v4.0.6](https://github.com/LinkedSoftwareDependencies/Components.js/compare/v4.0.5...v4.0.6) - 2021-01-27
+
+### Fixed
+* [Fix undefined root constructor args missing instead of being undefined](https://github.com/LinkedSoftwareDependencies/Components.js/commit/de14c611122ddb031d2973d4e667efa5b13bdf45)
+
+<a name="v4.0.5"></a>
+## [v4.0.5](https://github.com/LinkedSoftwareDependencies/Components.js/compare/v4.0.4...v4.0.5) - 2021-01-18
+
+### Fixed
+* [Allow module discovery in packages without package.json](https://github.com/LinkedSoftwareDependencies/Components.js/commit/a0ac0cb47b2ed07ef7a88619133af15ba71f3577)
+
+<a name="v4.0.4"></a>
+## [v4.0.4](https://github.com/LinkedSoftwareDependencies/Components.js/compare/v4.0.3...v4.0.4) - 2021-01-15
+
+### Changed
+* [Bump rdf-parse with updated components.js context URL](https://github.com/LinkedSoftwareDependencies/Components.js/commit/7525a027c683890f30f4e47402c89dcca7dd89d7)
+
+<a name="v4.0.3"></a>
+## [v4.0.3](https://github.com/LinkedSoftwareDependencies/Components.js/compare/v4.0.2...v4.0.3) - 2021-01-15
+
+### Fixed
+* [Fix broken infinite recursion workaround, #31](https://github.com/LinkedSoftwareDependencies/Components.js/commit/e9f2fdc78eca77f3070663c4dc360e93b1f4c0bb)
+
+<a name="v4.0.2"></a>
+## [v4.0.2](https://github.com/LinkedSoftwareDependencies/Components.js/compare/v4.0.1...v4.0.2) - 2021-01-15
+
+### Fixed
+* [Fix instances being created multiple times, Closes #31](https://github.com/LinkedSoftwareDependencies/Components.js/commit/94ce08874b24bf9c64d7f722beb2d5556aa9c7e9)
+* [Fix value inheritance happening multiple times](https://github.com/LinkedSoftwareDependencies/Components.js/commit/1855178930d2babd2c3a4c6cdad66087c1db79cd)
+
+<a name="v4.0.1"></a>
+## [v4.0.1](https://github.com/LinkedSoftwareDependencies/Components.js/compare/v4.0.0...v4.0.1) - 2021-01-14
+
+### Fixed
+* [Fix module resolution failure when outside main module](https://github.com/LinkedSoftwareDependencies/Components.js/commit/2fb4de8abda5d5e91d39942edcc0bafd29acd8ce)
+
+<a name="v4.0.0"></a>
+## [v4.0.0](https://github.com/LinkedSoftwareDependencies/Components.js/compare/v3.6.0...v4.0.0) - 2021-01-14
+
+This release contains breaking changes in the programmatic API,
+but module and configuration files remain backwards-compatible.
+
+### Added
+* Developer convenience
+    * [Allow `lsd:module` to be set to true in package.json](https://github.com/LinkedSoftwareDependencies/Components.js/commit/afeac8ab11e801376d265d3e42b5df7e113bfce4)
+    * [Emit warning when a remote context lookup is being done](https://github.com/LinkedSoftwareDependencies/Components.js/commit/0f3968c26ff5c3d38e3cc8282c6039ff1221b4fd)
+    * [Emit warning on potentially invalid parameters in config](https://github.com/LinkedSoftwareDependencies/Components.js/commit/a3ebb95a8d0e18ad062269c47b65cc2d9d1b603a)
+    * [Emit warning on potentially invalid IRIs](https://github.com/LinkedSoftwareDependencies/Components.js/commit/18f9f974965d049fd3808ae3a725a36bf264183b)
+    * [Generate componentsjs-error-state.json on error](https://github.com/LinkedSoftwareDependencies/Components.js/commit/bd47b17ba3fe82b2486e86bc678d950a9c478d18)
+    * [Validate multiple key-value occurences in collectEntries](https://github.com/LinkedSoftwareDependencies/Components.js/commit/ab88b14aa5f2c0c18b34668d6ca1aed8d611de11)
+    * [Improve printing of Resources in error reporting](https://github.com/LinkedSoftwareDependencies/Components.js/commit/48d2df7196a1e80e1bb55ac5c6518394b0942d4d)
+    * [Rewrite injection of custom JSON-LD document loader](https://github.com/LinkedSoftwareDependencies/Components.js/commit/98ae62f9ddb6589a8651f3a4b9bac6b2bb6642b4)
+    * [Migrate RDF loading logic to rdf-object](https://github.com/LinkedSoftwareDependencies/Components.js/commit/e5eb9d27e04a4a333487d5805ce5b0d17cd578a7)
+
+### Changed
+* [Use rdfs:seeAlso instead of owl:imports for importing](https://github.com/LinkedSoftwareDependencies/Components.js/commit/4e4227cca2c588e008259440e211af90e6756949)
+* [Handle semver on multiple occurrences of module packages](https://github.com/LinkedSoftwareDependencies/Components.js/commit/c8b2e3377d397179505064e43c4408e19447df6f)
+* [Improve performance of module state loading through parallelization](https://github.com/LinkedSoftwareDependencies/Components.js/commit/4c475b0ee4d7fae31a818dc72fe28223827fd1f1)
+* Refactoring
+    * [Accept loading from RDF/JS streams, Closes #1](https://github.com/LinkedSoftwareDependencies/Components.js/commit/749a7e7b5166414f68b5aabd285e5fd747b4dac4)
+    * [Add logger](https://github.com/LinkedSoftwareDependencies/Components.js/commit/a5497590d3dabf06c00831f53d95da1554305b10)
+    * [Split up Loader into ComponentsManager and loading classes](https://github.com/LinkedSoftwareDependencies/Components.js/commit/687b15c61ea8766b49dadf132fd38b0151f7f6ac)
+    * [Split parameter property handling into seperate handlers](https://github.com/LinkedSoftwareDependencies/Components.js/commit/e60a2a8bddc8a89b834cc21db51964bb2f8c3a93)
+    * [Create dedicated ParameterHandler component](https://github.com/LinkedSoftwareDependencies/Components.js/commit/408d299f77bc172e61a46d7dfbc4a6c931cecff6)
+    * [Reorganize relevant classes into construction package](https://github.com/LinkedSoftwareDependencies/Components.js/commit/aa6b56328fd4442886a82fcad187bd7380c05f27)
+    * [Split arguments creation into separate handlers](https://github.com/LinkedSoftwareDependencies/Components.js/commit/f3e995bd603369fb6e21d9be041ce96bec3b475b)
+    * [Split constructor args handling into separate handlers](https://github.com/LinkedSoftwareDependencies/Components.js/commit/33f678c5e5df96277243feca893d46882ebdd927)
+    * [Refactor component factories as config preprocessors](https://github.com/LinkedSoftwareDependencies/Components.js/commit/181b165f929cfcab206bc6d5ba22032f76d723c8)
+    * [Remove Util.PREFIXES in favour if Iris](https://github.com/LinkedSoftwareDependencies/Components.js/commit/0c0c671b18bd8fe2161d56fd39ee8645adc12c63)
+    * [Decouple CommonJS instantiation and serialization into strategies](https://github.com/LinkedSoftwareDependencies/Components.js/commit/4756e0ce2f52711d7eb6df7afcc1011da210dbf0)
+    * [Decouple instantiation logic from Loader class](https://github.com/LinkedSoftwareDependencies/Components.js/commit/02dd0e64e37c9961be68beba09f03a3b52d0c00f)
+    * [Rewrite RdfStreamIncluder as Transform stream](https://github.com/LinkedSoftwareDependencies/Components.js/commit/edf6c61b28f06d2539bcdc8498f10586272a2632)
+    * [Delay module registration until finalization phase](https://github.com/LinkedSoftwareDependencies/Components.js/commit/0de3b7940277fd207d7729da4921e62063434e20)
+    * [Refactor module loading into ModuleStateBuilder](https://github.com/LinkedSoftwareDependencies/Components.js/commit/6e6e54b498efb3e922466ef9868995926cd20ca8)
+
+### Removed
+* [Remove feature to use global modules](https://github.com/LinkedSoftwareDependencies/Components.js/commit/fc0f943ac7e1cda4f84b3a65e2ad05ad1c7c42dc)
+
+### Fixed
+* [Fix config compilation using wrong file path](https://github.com/LinkedSoftwareDependencies/Components.js/commit/fd3f806fe9cbb4f74a433e2a31212b5acdddf056)
+* [Fix mapped components only keeping first element of root arrays](https://github.com/LinkedSoftwareDependencies/Components.js/commit/0d33a9d88d473f930ce60c80949d13f5679b0df0)
+
+<a name="v3.6.1"></a>
+## [v3.6.1](https://github.com/LinkedSoftwareDependencies/Components.js/compare/v3.6.0...v3.6.1) - 2020-11-25
+
+### Fixed
+* [Fix Array checks.](https://github.com/LinkedSoftwareDependencies/Components.js/commit/fdd48f6910ce395c72607992056f724953729f32)
+* [Fix function check.](https://github.com/LinkedSoftwareDependencies/Components.js/commit/b685468cfc9de39c74207a1f79cc9efae2bffa4e)
+
+<a name="v3.6.0"></a>
+## [v3.6.0](https://github.com/LinkedSoftwareDependencies/Components.js/compare/v3.5.0...v3.6.0) - 2020-09-14
+
+### Added
+* [Supporting variables in config compilation](https://github.com/LinkedSoftwareDependencies/Components.js/commit/5eb5def9d77b7755d9e121b07c9d23676684a5f1)
+
+<a name="v3.5.0"></a>
+## [v3.5.0](https://github.com/LinkedSoftwareDependencies/Components.js/compare/v3.4.2...v3.5.0) - 2020-09-11
+
+### Added
+* [Accept variables as parameter values, that can be set at init](https://github.com/LinkedSoftwareDependencies/Components.js/commit/cbd6f115cabf2bfcdcc8466f434d5cf52a4c23d5)
+
+<a name="v3.4.2"></a>
+## [v3.4.2](https://github.com/LinkedSoftwareDependencies/Components.js/compare/v3.4.1...v3.4.2) - 2020-08-27
+
+### Fixed
+* [Fix empty list class loading failure](https://github.com/LinkedSoftwareDependencies/Components.js/commit/3590171287d2d765417469ea85012b651c88064b)
+
+<a name="v3.4.1"></a>
+## [v3.4.1](https://github.com/LinkedSoftwareDependencies/Components.js/compare/v3.4.0...v3.4.1) - 2020-07-01
+
+### Changed
+* [Make types proper dependencies](https://github.com/LinkedSoftwareDependencies/Components.js/commit/d50005517d606798de130a6cb2a4a4456683574c)
+
+<a name="v3.4.0"></a>
+## [v3.4.0](https://github.com/LinkedSoftwareDependencies/Components.js/compare/v3.3.0...v3.4.0) - 2020-04-06
+
+### Added
+* [Add requireNoConstructor option for raw requireElements](https://github.com/LinkedSoftwareDependencies/Components.js/commit/2d3144b8baad1464d590b691da10b752f7b83342)
+
+### Fixed
+* [Fix incorrect error message for invalid dynamic entries](https://github.com/LinkedSoftwareDependencies/Components.js/commit/91b3a543973c06e3a0f3b6f667cc04a49e499103)
+
+<a name="v3.3.0"></a>
+## [v3.3.0](https://github.com/LinkedSoftwareDependencies/Components.js/compare/v3.2.1...v3.3.0) - 2019-10-21
+
+### Added
+* [Allow requireName to be a relative path inside the module](https://github.com/LinkedSoftwareDependencies/Components.js/commit/562470dfbe6d3b1ab50e1202d8319adfafda024c)
+
+### Changed
+* [Return error code on failure to compile](https://github.com/LinkedSoftwareDependencies/Components.js/commit/06aa3420911a41963a97586cabbf34ae477084b1)
+
+<a name="v3.2.1"></a>
+## [v3.2.1](https://github.com/LinkedSoftwareDependencies/Components.js/compare/v3.2.0...v3.2.1) - 2019-02-21
+
+### Fixed
+* [Fix issues where context and component files would conflict](https://github.com/LinkedSoftwareDependencies/Components.js/commit/9e4812b23f6bc70099672172d480fc4855775622)
+* [Fix incorrect comment context entry](https://github.com/LinkedSoftwareDependencies/Components.js/commit/21873b34a0dfc366f02ee1ad7dbd580795254ba5)
+
+<a name="v3.2.0"></a>
+## [v3.2.0](https://github.com/LinkedSoftwareDependencies/Components.js/compare/2.0.0...v3.2.0) - 2018-11-13
+
+### Changed
+* [Prioritize main modules when instantiating](https://github.com/LinkedSoftwareDependencies/Components.js/commit/c97f104d101f8dac96b501def69698615f58385b)
+
+<a name="v3.1.0"></a>
+## [v3.1.0](https://github.com/LinkedSoftwareDependencies/Components.js/compare/2.0.0...v3.1.0) - 2018-11-13
+
+_Start tracking of changelog_

package/components/context.jsonld

@@ -22,9 +22,16 @@
     "components": {
       "@id": "oo:component"
     },
+    "component": {
+      "@id": "oo:component",
+      "@type": "@id"
+    },
     "parameters": {
       "@id": "oo:parameter"
     },
+    "genericTypeParameters": {
+      "@id": "oo:genericTypeParameter"
+    },
     "constructorArguments": {
       "@id": "oo:constructorArguments",
       "@container": "@list"
@@ -94,7 +101,25 @@
       "@id": "oo:ParameterRangeCollectEntries"
     },
     "parameterRangeCollectEntriesParameters": {
-      "@id": "oo: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"
     },
 

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,6 +16,7 @@ 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.

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.
@@ -87,6 +88,24 @@ class ConfigPreprocessorComponent {
         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.
@@ -94,10 +113,12 @@ class ConfigPreprocessorComponent {
      */
     transformConstructorArguments(config, handleResponse) {
         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}"`);
-            const value = this.parameterHandler.applyParameterValues(handleResponse.component, fieldData, config);
+            const value = this.parameterHandler
+                .applyParameterValues(handleResponse.component, fieldData, config, genericsContext);
             if (value) {
                 field.property.value = value;
             }

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.
@@ -11,6 +12,6 @@ export declare class ConfigPreprocessorComponentMapped extends ConfigPreprocesso
     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 | undefined;
+    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,28 +33,30 @@ 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;
     }
-    getParameterValue(configRoot, parameter, configElement, rawValue) {
+    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}"`);
         }
         else if (parameter.type === 'NamedNode' && !parameter.property.fields) {
-            valueOut = this.parameterHandler.applyParameterValues(configRoot, parameter, configElement);
+            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) {

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
+     * @param genericsContext Context for generic types.
+     * @return - The parameter value
      */
-    applyParameterValues(configRoot: Resource, parameter: Resource, configElement: Resource): Resource | undefined;
+    applyParameterValues(configRoot: Resource, parameter: Resource, configElement: Resource, genericsContext: GenericsContext): Resource | undefined;
 }
 export interface IParameterHandlerOptions {
     objectLoader: RdfObjectLoader;

package/lib/preprocess/ParameterHandler.js

@@ -26,9 +26,10 @@ 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
+     * @param genericsContext Context for generic types.
+     * @return - The parameter value
      */
-    applyParameterValues(configRoot, parameter, configElement) {
+    applyParameterValues(configRoot, parameter, configElement, genericsContext) {
         // Make sure that we always have a single value with list elements in it.
         const values = configElement.properties[parameter.value];
         let value;
@@ -47,8 +48,8 @@ class ParameterHandler {
         }
         // Run the value through all applicable parameters property handlers.
         for (const handler of this.parameterPropertyHandlers) {
-            if (handler.canHandle(value, configRoot, parameter, configElement)) {
-                value = handler.handle(value, configRoot, parameter, configElement);
+            if (handler.canHandle(value, configRoot, parameter, configElement, genericsContext)) {
+                value = handler.handle(value, configRoot, parameter, configElement, genericsContext);
             }
         }
         return value;

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

@@ -1,4 +1,5 @@
 import type { Resource } from 'rdf-object';
+import type { GenericsContext } from '../GenericsContext';
 import type { ParameterHandler } from '../ParameterHandler';
 import type { IConstructorArgumentsElementMappingHandler } from './IConstructorArgumentsElementMappingHandler';
 import type { IConstructorArgumentsMapper } from './IConstructorArgumentsMapper';
@@ -9,6 +10,6 @@ export declare class ConstructorArgumentsElementMappingHandlerCollectEntries imp
     private readonly parameterHandler;
     constructor(parameterHandler: ParameterHandler);
     canHandle(configRoot: Resource, constructorArgs: Resource, configElement: Resource, mapper: IConstructorArgumentsMapper): boolean;
-    handle(configRoot: Resource, constructorArgs: Resource, configElement: Resource, mapper: IConstructorArgumentsMapper): Resource;
-    handleCollectEntry(entryResource: Resource, configRoot: Resource, constructorArgs: Resource, configElement: Resource, mapper: IConstructorArgumentsMapper): Resource;
+    handle(configRoot: Resource, constructorArgs: Resource, configElement: Resource, mapper: IConstructorArgumentsMapper, genericsContext: GenericsContext): Resource;
+    handleCollectEntry(entryResource: Resource, configRoot: Resource, constructorArgs: Resource, configElement: Resource, mapper: IConstructorArgumentsMapper, genericsContext: GenericsContext): Resource;
 }

package/lib/preprocess/constructorargumentsmapping/ConstructorArgumentsElementMappingHandlerCollectEntries.js

@@ -14,7 +14,7 @@ class ConstructorArgumentsElementMappingHandlerCollectEntries {
         return Boolean((constructorArgs.property.value || constructorArgs.property.valueRawReference) &&
             constructorArgs.property.collectEntries);
     }
-    handle(configRoot, constructorArgs, configElement, mapper) {
+    handle(configRoot, constructorArgs, configElement, mapper, genericsContext) {
         if (constructorArgs.properties.collectEntries.length > 1) {
             throw new ErrorResourcesContext_1.ErrorResourcesContext(`Invalid collectEntries: Only one value can be defined, or an RDF list must be provided`, {
                 constructorArgs,
@@ -31,7 +31,7 @@ class ConstructorArgumentsElementMappingHandlerCollectEntries {
                     config: configRoot,
                 });
             }
-            const value = this.parameterHandler.applyParameterValues(configRoot, entry, configElement);
+            const value = this.parameterHandler.applyParameterValues(configRoot, entry, configElement, genericsContext);
             if (value) {
                 for (const subValue of value.list || [value]) {
                     entryResources.push(subValue);
@@ -41,10 +41,10 @@ class ConstructorArgumentsElementMappingHandlerCollectEntries {
         // Map all entries to values
         return mapper.objectLoader.createCompactedResource({
             list: entryResources.map((entryResource) => this
-                .handleCollectEntry(entryResource, configRoot, constructorArgs, configElement, mapper)),
+                .handleCollectEntry(entryResource, configRoot, constructorArgs, configElement, mapper, genericsContext)),
         });
     }
-    handleCollectEntry(entryResource, configRoot, constructorArgs, configElement, mapper) {
+    handleCollectEntry(entryResource, configRoot, constructorArgs, configElement, mapper, genericsContext) {
         // Determine the (optional) entry key
         let key;
         if (constructorArgs.property.key) {
@@ -94,13 +94,15 @@ class ConstructorArgumentsElementMappingHandlerCollectEntries {
         else if (constructorArgs.property.value.type === 'NamedNode' &&
             constructorArgs.property.value.value === Iris_1.IRIS_RDF.object) {
             // Value is the entry value
-            value = mapper.applyConstructorArgumentsParameters(configRoot, entryResource, configElement);
+            value = mapper
+                .applyConstructorArgumentsParameters(configRoot, entryResource, configElement, genericsContext);
         }
         else if (constructorArgs.property.value &&
             (constructorArgs.property.value.property.fields || constructorArgs.property.value.property.elements)) {
             // Nested mapping should reduce the parameter scope
             // ! at the end of the line, because will always be truthy
-            value = mapper.getParameterValue(configRoot, constructorArgs.property.value, entryResource, false);
+            value = mapper
+                .getParameterValue(configRoot, constructorArgs.property.value, entryResource, false, genericsContext);
         }
         else if (entryResource.properties[constructorArgs.property.value.value].length !== 1) {
             throw new ErrorResourcesContext_1.ErrorResourcesContext(`Detected more than one value value in collectEntries`, {

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

@@ -1,4 +1,5 @@
 import type { Resource } from 'rdf-object';
+import type { GenericsContext } from '../GenericsContext';
 import type { IConstructorArgumentsElementMappingHandler } from './IConstructorArgumentsElementMappingHandler';
 import type { IConstructorArgumentsMapper } from './IConstructorArgumentsMapper';
 /**
@@ -6,5 +7,5 @@ import type { IConstructorArgumentsMapper } from './IConstructorArgumentsMapper'
  */
 export declare class ConstructorArgumentsElementMappingHandlerElements implements IConstructorArgumentsElementMappingHandler {
     canHandle(configRoot: Resource, constructorArgs: Resource, configElement: Resource, mapper: IConstructorArgumentsMapper): boolean;
-    handle(configRoot: Resource, constructorArgs: Resource, configElement: Resource, mapper: IConstructorArgumentsMapper): Resource;
+    handle(configRoot: Resource, constructorArgs: Resource, configElement: Resource, mapper: IConstructorArgumentsMapper, genericsContext: GenericsContext): Resource;
 }

package/lib/preprocess/constructorargumentsmapping/ConstructorArgumentsElementMappingHandlerElements.js

@@ -9,7 +9,7 @@ class ConstructorArgumentsElementMappingHandlerElements {
     canHandle(configRoot, constructorArgs, configElement, mapper) {
         return Boolean(constructorArgs.property.elements);
     }
-    handle(configRoot, constructorArgs, configElement, mapper) {
+    handle(configRoot, constructorArgs, configElement, mapper, genericsContext) {
         // Elements must have RDF list values.
         if (!constructorArgs.property.elements.list) {
             throw new ErrorResourcesContext_1.ErrorResourcesContext(`Illegal non-RDF-list elements`, {
@@ -29,7 +29,7 @@ class ConstructorArgumentsElementMappingHandlerElements {
                     config: configRoot,
                 });
             }
-            const value = mapper.getParameterValue(configRoot, element, configElement, Boolean(element.property.valueRawReference));
+            const value = mapper.getParameterValue(configRoot, element, configElement, Boolean(element.property.valueRawReference), genericsContext);
             if (value) {
                 for (const entry of value.list || [value]) {
                     entries.push(entry);

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

@@ -1,4 +1,5 @@
 import type { Resource } from 'rdf-object';
+import type { GenericsContext } from '../GenericsContext';
 import type { IConstructorArgumentsElementMappingHandler } from './IConstructorArgumentsElementMappingHandler';
 import type { IConstructorArgumentsMapper } from './IConstructorArgumentsMapper';
 /**
@@ -6,5 +7,5 @@ import type { IConstructorArgumentsMapper } from './IConstructorArgumentsMapper'
  */
 export declare class ConstructorArgumentsElementMappingHandlerFields implements IConstructorArgumentsElementMappingHandler {
     canHandle(configRoot: Resource, constructorArgs: Resource, configElement: Resource, mapper: IConstructorArgumentsMapper): boolean;
-    handle(configRoot: Resource, constructorArgs: Resource, configElement: Resource, mapper: IConstructorArgumentsMapper): Resource;
+    handle(configRoot: Resource, constructorArgs: Resource, configElement: Resource, mapper: IConstructorArgumentsMapper, genericsContext: GenericsContext): Resource;
 }

package/lib/preprocess/constructorargumentsmapping/ConstructorArgumentsElementMappingHandlerFields.js

@@ -9,7 +9,7 @@ class ConstructorArgumentsElementMappingHandlerFields {
     canHandle(configRoot, constructorArgs, configElement, mapper) {
         return Boolean(constructorArgs.property.fields);
     }
-    handle(configRoot, constructorArgs, configElement, mapper) {
+    handle(configRoot, constructorArgs, configElement, mapper, genericsContext) {
         if (constructorArgs.properties.fields.length > 1) {
             throw new ErrorResourcesContext_1.ErrorResourcesContext(`Invalid fields: Only one value can be defined, or an RDF list must be provided`, {
                 constructorArgs,
@@ -20,7 +20,8 @@ class ConstructorArgumentsElementMappingHandlerFields {
         // Recursively handle all field values.
         const entries = [];
         for (const field of fields.list || [fields]) {
-            const mapped = mapper.applyConstructorArgumentsParameters(configRoot, field, configElement);
+            const mapped = mapper
+                .applyConstructorArgumentsParameters(configRoot, field, configElement, genericsContext);
             for (const entry of mapped.list || [mapped]) {
                 entries.push(entry);
             }

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

@@ -1,4 +1,5 @@
 import type { Resource } from 'rdf-object';
+import type { GenericsContext } from '../GenericsContext';
 import type { IConstructorArgumentsElementMappingHandler } from './IConstructorArgumentsElementMappingHandler';
 import type { IConstructorArgumentsMapper } from './IConstructorArgumentsMapper';
 /**
@@ -6,7 +7,7 @@ import type { IConstructorArgumentsMapper } from './IConstructorArgumentsMapper'
  */
 export declare class ConstructorArgumentsElementMappingHandlerKeyValue implements IConstructorArgumentsElementMappingHandler {
     canHandle(configRoot: Resource, constructorArgs: Resource, configElement: Resource, mapper: IConstructorArgumentsMapper): boolean;
-    handle(configRoot: Resource, constructorArgs: Resource, configElement: Resource, mapper: IConstructorArgumentsMapper): Resource;
-    handleKeyValue(configRoot: Resource, constructorArgs: Resource, configElement: Resource, mapper: IConstructorArgumentsMapper): Resource;
-    handleValue(configRoot: Resource, constructorArgs: Resource, configElement: Resource, mapper: IConstructorArgumentsMapper): Resource;
+    handle(configRoot: Resource, constructorArgs: Resource, configElement: Resource, mapper: IConstructorArgumentsMapper, genericsContext: GenericsContext): Resource;
+    handleKeyValue(configRoot: Resource, constructorArgs: Resource, configElement: Resource, mapper: IConstructorArgumentsMapper, genericsContext: GenericsContext): Resource;
+    handleValue(configRoot: Resource, constructorArgs: Resource, configElement: Resource, mapper: IConstructorArgumentsMapper, genericsContext: GenericsContext): Resource;
 }

package/lib/preprocess/constructorargumentsmapping/ConstructorArgumentsElementMappingHandlerKeyValue.js

@@ -10,7 +10,7 @@ class ConstructorArgumentsElementMappingHandlerKeyValue {
         return Boolean((constructorArgs.property.value || constructorArgs.property.valueRawReference) &&
             !constructorArgs.property.collectEntries);
     }
-    handle(configRoot, constructorArgs, configElement, mapper) {
+    handle(configRoot, constructorArgs, configElement, mapper, genericsContext) {
         if (constructorArgs.property.key) {
             // Throw if our key is not a literal
             if (constructorArgs.property.key.type !== 'Literal') {
@@ -21,17 +21,17 @@ class ConstructorArgumentsElementMappingHandlerKeyValue {
                 });
             }
             // Key-value
-            return this.handleKeyValue(configRoot, constructorArgs, configElement, mapper);
+            return this.handleKeyValue(configRoot, constructorArgs, configElement, mapper, genericsContext);
         }
         // Only value
-        return this.handleValue(configRoot, constructorArgs, configElement, mapper);
+        return this.handleValue(configRoot, constructorArgs, configElement, mapper, genericsContext);
     }
-    handleKeyValue(configRoot, constructorArgs, configElement, mapper) {
-        const value = mapper.getParameterValue(configRoot, constructorArgs.property.value || constructorArgs.property.valueRawReference, configElement, Boolean(constructorArgs.property.valueRawReference));
+    handleKeyValue(configRoot, constructorArgs, configElement, mapper, genericsContext) {
+        const value = mapper.getParameterValue(configRoot, constructorArgs.property.value || constructorArgs.property.valueRawReference, configElement, Boolean(constructorArgs.property.valueRawReference), genericsContext);
         return mapper.objectLoader.createCompactedResource(Object.assign({ key: constructorArgs.property.key }, value ? { value } : {}));
     }
-    handleValue(configRoot, constructorArgs, configElement, mapper) {
-        const value = mapper.getParameterValue(configRoot, constructorArgs.property.value || constructorArgs.property.valueRawReference, configElement, Boolean(constructorArgs.property.valueRawReference));
+    handleValue(configRoot, constructorArgs, configElement, mapper, genericsContext) {
+        const value = mapper.getParameterValue(configRoot, constructorArgs.property.value || constructorArgs.property.valueRawReference, configElement, Boolean(constructorArgs.property.valueRawReference), genericsContext);
         if (!value) {
             return mapper.objectLoader.createCompactedResource({ undefined: true });
         }

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

@@ -1,4 +1,5 @@
 import type { Resource } from 'rdf-object';
+import type { GenericsContext } from '../GenericsContext';
 import type { IConstructorArgumentsElementMappingHandler } from './IConstructorArgumentsElementMappingHandler';
 import type { IConstructorArgumentsMapper } from './IConstructorArgumentsMapper';
 /**
@@ -6,5 +7,5 @@ import type { IConstructorArgumentsMapper } from './IConstructorArgumentsMapper'
  */
 export declare class ConstructorArgumentsElementMappingHandlerList implements IConstructorArgumentsElementMappingHandler {
     canHandle(configRoot: Resource, constructorArgs: Resource, configElement: Resource, mapper: IConstructorArgumentsMapper): boolean;
-    handle(configRoot: Resource, constructorArgs: Resource, configElement: Resource, mapper: IConstructorArgumentsMapper): Resource;
+    handle(configRoot: Resource, constructorArgs: Resource, configElement: Resource, mapper: IConstructorArgumentsMapper, genericsContext: GenericsContext): Resource;
 }

package/lib/preprocess/constructorargumentsmapping/ConstructorArgumentsElementMappingHandlerList.js

@@ -8,16 +8,18 @@ class ConstructorArgumentsElementMappingHandlerList {
     canHandle(configRoot, constructorArgs, configElement, mapper) {
         return Boolean(constructorArgs.list);
     }
-    handle(configRoot, constructorArgs, configElement, mapper) {
+    handle(configRoot, constructorArgs, configElement, mapper, genericsContext) {
         // Recursively handle all field values.
         const ret = mapper.objectLoader.createCompactedResource({});
         ret.list = [];
         for (const argument of constructorArgs.list) {
             if (argument.property.fields || argument.property.elements) {
-                ret.list.push(mapper.applyConstructorArgumentsParameters(configRoot, argument, configElement));
+                ret.list.push(mapper
+                    .applyConstructorArgumentsParameters(configRoot, argument, configElement, genericsContext));
             }
             else {
-                const value = mapper.getParameterValue(configRoot, argument, configElement, false);
+                const value = mapper
+                    .getParameterValue(configRoot, argument, configElement, false, genericsContext);
                 if (value) {
                     ret.list.push(value);
                 }

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

@@ -1,4 +1,5 @@
 import type { Resource } from 'rdf-object';
+import type { GenericsContext } from '../GenericsContext';
 import type { IConstructorArgumentsMapper } from './IConstructorArgumentsMapper';
 /**
  * Handles a specific type of a constructor argument element.
@@ -10,8 +11,9 @@ export interface IConstructorArgumentsElementMappingHandler {
      * @param constructorArgs Object mapping definition inside the constructor arguments.
      * @param configElement Part of the config resource to look for parameter instantiations as predicates.
      * @param mapper Instance of the constructor arguments mapper that can be used to handle recursive args.
+     * @param genericsContext Context for generic types.
      */
-    canHandle: (configRoot: Resource, constructorArgs: Resource, configElement: Resource, mapper: IConstructorArgumentsMapper) => boolean;
+    canHandle: (configRoot: Resource, constructorArgs: Resource, configElement: Resource, mapper: IConstructorArgumentsMapper, genericsContext: GenericsContext) => boolean;
     /**
      * Map the given config element with param instantiations
      * to a raw config according to the given constructor arguments definition.
@@ -19,6 +21,7 @@ export interface IConstructorArgumentsElementMappingHandler {
      * @param constructorArgs Object mapping definition inside the constructor arguments.
      * @param configElement Part of the config resource to look for parameter instantiations as predicates.
      * @param mapper Instance of the constructor arguments mapper that can be used to handle recursive args.
+     * @param genericsContext Context for generic types.
      */
-    handle: (configRoot: Resource, constructorArgs: Resource, configElement: Resource, mapper: IConstructorArgumentsMapper) => Resource;
+    handle: (configRoot: Resource, constructorArgs: Resource, configElement: Resource, mapper: IConstructorArgumentsMapper, genericsContext: GenericsContext) => Resource;
 }

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

@@ -1,4 +1,5 @@
 import type { RdfObjectLoader, Resource } from 'rdf-object';
+import type { GenericsContext } from '../GenericsContext';
 /**
  * Instances of this interfaces can apply constructor arguments on configs.
  * This is mainly used by {@link IConstructorArgumentsElementMappingHandler}.
@@ -15,14 +16,16 @@ export interface IConstructorArgumentsMapper {
      * @param configRoot The root config resource that we are working in.
      * @param constructorArgs Object mapping definition inside the constructor arguments.
      * @param configElement Part of the config resource to look for parameter instantiations as predicates.
+     * @param genericsContext Context for generic types.
      */
-    applyConstructorArgumentsParameters: (configRoot: Resource, constructorArgs: Resource, configElement: Resource) => Resource;
+    applyConstructorArgumentsParameters: (configRoot: Resource, constructorArgs: Resource, configElement: Resource, genericsContext: GenericsContext) => Resource;
     /**
      * Obtain the value(s) of the given parameter in the given config.
      * @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.
      * @param rawValue If the IRI represents a raw string value instead of a parameter reference.
+     * @param genericsContext Context for generic types.
      */
-    getParameterValue: (configRoot: Resource, parameter: Resource, configElement: Resource, rawValue: boolean) => Resource | undefined;
+    getParameterValue: (configRoot: Resource, parameter: Resource, configElement: Resource, rawValue: boolean, genericsContext: GenericsContext) => Resource | undefined;
 }

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

@@ -1,4 +1,5 @@
 import type { Resource } from 'rdf-object';
+import type { GenericsContext } from '../GenericsContext';
 /**
  * Transforms a parameter value based on some kind of parameter property.
  */
@@ -10,8 +11,9 @@ export interface IParameterPropertyHandler {
      * @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.
+     * @param genericsContext Context for generic types.
      */
-    canHandle: (value: Resource | undefined, configRoot: Resource, parameter: Resource, configElement: Resource) => boolean;
+    canHandle: (value: Resource | undefined, configRoot: Resource, parameter: Resource, configElement: Resource, genericsContext: GenericsContext) => boolean;
     /**
      * Transform the given parameter value.
      * @param value The current parameter value obtained from the config.
@@ -19,6 +21,7 @@ export interface IParameterPropertyHandler {
      * @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.
+     * @param genericsContext Context for generic types.
      */
-    handle: (value: Resource | undefined, configRoot: Resource, parameter: Resource, configElement: Resource) => Resource | undefined;
+    handle: (value: Resource | undefined, configRoot: Resource, parameter: Resource, configElement: Resource, genericsContext: GenericsContext) => Resource | undefined;
 }

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.
@@ -7,7 +8,7 @@ export declare class ParameterPropertyHandlerRange implements IParameterProperty
     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;
+    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,8 +16,9 @@ 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 | undefined, param: Resource): Resource | undefined;
+    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.
@@ -25,8 +27,9 @@ export declare class ParameterPropertyHandlerRange implements IParameterProperty
      * @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): boolean;
-    protected throwIncorrectTypeError(value: Resource | undefined, parameter: Resource): never;
-    rangeToDisplayString(paramRange: Resource | undefined): string;
+    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

@@ -13,8 +13,8 @@ class ParameterPropertyHandlerRange {
     canHandle(value, configRoot, parameter) {
         return Boolean(parameter.property.range);
     }
-    handle(value, configRoot, parameter, configElement) {
-        this.captureType(value, parameter);
+    handle(value, configRoot, parameter, configElement, genericsContext) {
+        this.captureType(value, parameter, genericsContext);
         return value;
     }
     /**
@@ -24,12 +24,13 @@ 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) {
-        if (this.hasParamValueValidType(value, param, param.property.range)) {
+    captureType(value, param, genericsContext) {
+        if (this.hasParamValueValidType(value, param, param.property.range, genericsContext)) {
             return value;
         }
-        this.throwIncorrectTypeError(value, param);
+        this.throwIncorrectTypeError(value, param, genericsContext);
     }
     /**
      * Apply the given datatype to the given literal.
@@ -39,8 +40,9 @@ class ParameterPropertyHandlerRange {
      * @param value The value.
      * @param param The parameter.
      * @param paramRange The parameter's range.
+     * @param genericsContext Context for generic types.
      */
-    hasParamValueValidType(value, param, paramRange) {
+    hasParamValueValidType(value, param, paramRange, genericsContext) {
         if (!paramRange) {
             return true;
         }
@@ -108,16 +110,16 @@ class ParameterPropertyHandlerRange {
                     return false;
                 }
                 return value.list.every(listElement => this
-                    .hasParamValueValidType(listElement, param, paramRange.property.parameterRangeValue));
+                    .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));
+                    .some(child => this.hasParamValueValidType(value, param, child, genericsContext));
             }
             if (paramRange.isA('ParameterRangeIntersection')) {
                 return paramRange.properties.parameterRangeElements
-                    .every(child => this.hasParamValueValidType(value, param, child));
+                    .every(child => this.hasParamValueValidType(value, param, child, genericsContext));
             }
             if (paramRange.isA('ParameterRangeTuple')) {
                 if (!value || !value.list) {
@@ -131,7 +133,7 @@ class ParameterPropertyHandlerRange {
                 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)) {
+                        if (!this.hasParamValueValidType(listElements[listIndex], param, tupleTypes[tupleIndex].property.parameterRangeValue, genericsContext)) {
                             tupleIndex++;
                         }
                         else {
@@ -139,7 +141,7 @@ class ParameterPropertyHandlerRange {
                         }
                     }
                     else {
-                        if (!this.hasParamValueValidType(listElements[listIndex], param, tupleTypes[tupleIndex])) {
+                        if (!this.hasParamValueValidType(listElements[listIndex], param, tupleTypes[tupleIndex], genericsContext)) {
                             return false;
                         }
                         tupleIndex++;
@@ -153,6 +155,28 @@ class ParameterPropertyHandlerRange {
             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
@@ -162,16 +186,17 @@ class ParameterPropertyHandlerRange {
         }
         return true;
     }
-    throwIncorrectTypeError(value, parameter) {
+    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)}"`, {
-            value: value || 'undefined',
-            parameter,
-        });
+        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 }));
     }
-    rangeToDisplayString(paramRange) {
+    rangeToDisplayString(paramRange, genericsContext) {
         if (!paramRange) {
             return `any`;
         }
@@ -179,29 +204,37 @@ class ParameterPropertyHandlerRange {
             return `undefined`;
         }
         if (paramRange.isA('ParameterRangeArray')) {
-            return `${this.rangeToDisplayString(paramRange.property.parameterRangeValue)}[]`;
+            return `${this.rangeToDisplayString(paramRange.property.parameterRangeValue, genericsContext)}[]`;
         }
         if (paramRange.isA('ParameterRangeRest')) {
-            return `...${this.rangeToDisplayString(paramRange.property.parameterRangeValue)}`;
+            return `...${this.rangeToDisplayString(paramRange.property.parameterRangeValue, genericsContext)}`;
         }
         if (paramRange.isA('ParameterRangeUnion')) {
             return paramRange.properties.parameterRangeElements
-                .map(child => this.rangeToDisplayString(child))
+                .map(child => this.rangeToDisplayString(child, genericsContext))
                 .join(' | ');
         }
         if (paramRange.isA('ParameterRangeIntersection')) {
             return paramRange.properties.parameterRangeElements
-                .map(child => this.rangeToDisplayString(child))
+                .map(child => this.rangeToDisplayString(child, genericsContext))
                 .join(' & ');
         }
         if (paramRange.isA('ParameterRangeTuple')) {
             return `[${paramRange.properties.parameterRangeElements
-                .map(child => this.rangeToDisplayString(child))
+                .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;
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "componentsjs",
-  "version": "5.0.0-beta.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"