componentsjs 5.0.0-beta.2 → 5.0.0-beta.3

package/CHANGELOG.md

@@ -1,6 +1,30 @@
 # Changelog
 All notable changes to this project will be documented in this file.
 
+<a name="v5.0.0-beta.3"></a>
+## [v5.0.0-beta.3](https://github.com/LinkedSoftwareDependencies/Components.js/compare/v5.0.0-beta.2...v5.0.0-beta.3) - 2022-01-17
+
+### Added
+* [Add support for wildcard parameter ranges](https://github.com/LinkedSoftwareDependencies/Components.js/commit/83238a9fa08877f29326be562d7d3d5fff860c69)
+* Improve error reporting:
+  * [Add causes for param check failures in error messages](https://github.com/LinkedSoftwareDependencies/Components.js/commit/9be1fd0899ffb8a77ea99e5fb86e661526ef6d1a)
+  * [Improve error message on invalid generic type instantiations](https://github.com/LinkedSoftwareDependencies/Components.js/commit/6ecb9798eeb84f09fece68b3a47454fa8c857ba4)
+  * [Move error context to error state file](https://github.com/LinkedSoftwareDependencies/Components.js/commit/dbf26e072bdc63168814ef4d503777efaf4745eb)
+
+### Fixed
+* Resolve several issues related to generics:
+  * [Throw error on invalid ParameterRangeGenericComponent](https://github.com/LinkedSoftwareDependencies/Components.js/commit/c692ab6175ce466fb32fbe38b973644e2601b2e6)
+  * [Fix generic components not accepting specific types](https://github.com/LinkedSoftwareDependencies/Components.js/commit/c7739182fddcb92d46a86fe3e33d6e29fd1134b6)
+  * [Support generic type instantiation during component extension](https://github.com/LinkedSoftwareDependencies/Components.js/commit/98f70e350cc3f9bf8a4ea632db546f74624ddda7)
+  * [Support generic components in params with fixed generics](https://github.com/LinkedSoftwareDependencies/Components.js/commit/d8b30972e1306e9fe9db391d4693aa6000917e60)
+  * [Use GenericComponentExtension to refer to wrapped generic comp extensions](https://github.com/LinkedSoftwareDependencies/Components.js/commit/239895accfdb7f09a7ac8454928bd3e0be5e5f15)
+  * [Fix invalid range display with multiple generics](https://github.com/LinkedSoftwareDependencies/Components.js/commit/b98baf0bcf4546b60299ae548f929693345292bc)
+  * [Handle range merging if left or right is union](https://github.com/LinkedSoftwareDependencies/Components.js/commit/637e140106691b95f0f546cf88eb39f3f80dc61d)
+  * [Handle sub-types when merging param ranges](https://github.com/LinkedSoftwareDependencies/Components.js/commit/43290525b2e244f5fbb6d5f344760b863329c31b)
+  * [Allow merging of generic component param types](https://github.com/LinkedSoftwareDependencies/Components.js/commit/ee8de7d9b8d18bf6968a17078e493946e5fca8cd)
+  * [Allow param range merging with generic components](https://github.com/LinkedSoftwareDependencies/Components.js/commit/bcea7dcff288ce7068ee244c49c12134208c89da)
+  * [Fix generics crash when doing repeated param type checking](https://github.com/LinkedSoftwareDependencies/Components.js/commit/237572cb8a9c546b098582041ccd7a457b41aecd)
+
 <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
 

package/README.md

@@ -202,6 +202,22 @@ const myInstance = await manager.instantiate('http://example.org/myInstance');
 [RDF]: https://www.w3.org/RDF/
 [JSON-LD]: https://json-ld.org/
 
+## Cite
+
+If you are using or extending Components.js as part of a scientific publication,
+we would appreciate a citation of our [article](https://linkedsoftwaredependencies.github.io/Article-System-Components/).
+
+```bibtex
+@article{taelman_swj_componentsjs_2022,
+  author = {Taelman, Ruben and Van Herwegen, Joachim and Vander Sande, Miel and Verborgh, Ruben},
+  title = {Components.js: Semantic Dependency Injection},
+  journal = {Semantic Web Journal},
+  year = {2022},
+  month = jan,
+  url = {https://linkedsoftwaredependencies.github.io/Article-System-Components/}
+}
+```
+
 ## License
 Components.js is written by [Ruben Taelman](http://www.rubensworks.net/).
 

package/components/context.jsonld

@@ -2,6 +2,9 @@
   "@context": {
     "rdf": "http://www.w3.org/1999/02/22-rdf-syntax-ns#",
     "xsd": "http://www.w3.org/2001/XMLSchema#",
+    "type": {
+      "@id": "rdf:type"
+    },
     "types": {
       "@id": "rdf:type"
     },
@@ -77,6 +80,9 @@
     "ParameterRangeUndefined": {
       "@id": "oo:ParameterRangeUndefined"
     },
+    "ParameterRangeWildcard": {
+      "@id": "oo:ParameterRangeWildcard"
+    },
     "ParameterRangeArray": {
       "@id": "oo:ParameterRangeArray"
     },
@@ -116,6 +122,10 @@
     "ParameterRangeGenericComponent": {
       "@id": "oo:ParameterRangeGenericComponent"
     },
+    "genericTypeInstancesComponentScope": {
+      "@id": "oo:genericTypeInstancesComponentScope",
+      "@type": "@id"
+    },
     "genericTypeInstances": {
       "@id": "oo:genericTypeInstance",
       "@type": "@id"
@@ -131,6 +141,9 @@
       "@id": "oo:parameterRangeGenericBindings",
       "@type": "@id"
     },
+    "GenericComponentExtension": {
+      "@id": "oo:GenericComponentExtension"
+    },
 
     "rdfs": "http://www.w3.org/2000/01/rdf-schema#",
     "comment": {

package/lib/ComponentsManager.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ComponentsManager = void 0;
 const fs = require("fs");
 const ComponentsManagerBuilder_1 = require("./loading/ComponentsManagerBuilder");
+const ErrorResourcesContext_1 = require("./util/ErrorResourcesContext");
 /**
  * A components manager can instantiate components.
  * This manager should be created using {@link ComponentsManager.build}.
@@ -51,17 +52,14 @@ class ComponentsManager {
      */
     generateErrorLog(error) {
         if (this.dumpErrorState) {
-            const contents = JSON.stringify({
-                componentTypes: Object.keys(this.componentResources),
-                moduleState: {
+            const contents = JSON.stringify(Object.assign(Object.assign({}, error instanceof ErrorResourcesContext_1.ErrorResourcesContext ? error.exportContext() : {}), { componentTypes: Object.keys(this.componentResources), moduleState: {
                     mainModulePath: this.moduleState.mainModulePath,
                     componentModules: this.moduleState.componentModules,
                     importPaths: this.moduleState.importPaths,
                     contexts: this.moduleState.contexts,
                     nodeModuleImportPaths: this.moduleState.nodeModuleImportPaths,
                     nodeModulePaths: this.moduleState.nodeModulePaths,
-                },
-            }, null, '  ');
+                } }), null, '  ');
             fs.writeFileSync('componentsjs-error-state.json', contents, 'utf8');
             this.logger.error(`Detected fatal error. Generated 'componentsjs-error-state.json' with more information.`);
         }

package/lib/loading/ComponentRegistryFinalizer.js

@@ -41,7 +41,13 @@ class ComponentRegistryFinalizer {
      * @param superComponents The components to inherit from.
      */
     inheritParameters(component, superComponents) {
-        for (const superComponent of superComponents) {
+        var _a;
+        for (let superComponent of superComponents) {
+            // Check if the super component is wrapped in a generic component instantiation
+            if (((_a = superComponent.property.type) === null || _a === void 0 ? void 0 : _a.value) === this.objectLoader.contextResolved
+                .expandTerm('oo:GenericComponentExtension')) {
+                superComponent = superComponent.property.component;
+            }
             this.componentRegistry.requireValidComponent(superComponent, component);
             for (const parameter of superComponent.properties.parameters) {
                 if (!component.properties.parameters.includes(parameter)) {

package/lib/preprocess/ConfigPreprocessorComponent.js

@@ -89,20 +89,16 @@ class ConfigPreprocessorComponent {
         return configRaw;
     }
     createGenericsContext(handleResponse, config) {
+        // Create a new generics context for the component's generic type parameters
         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;
+        // If the config has a genericTypeInstancesComponentScope, it will also have genericTypeInstances.
+        // In that case, we bind these instances to the component's generic type parameters within the context.
+        // (these values may have been set during generic param type-checking in
+        // ParameterPropertyHandlerRange#hasParamValueValidType)
+        if (config.property.genericTypeInstancesComponentScope &&
+            handleResponse.component.value === config.property.genericTypeInstancesComponentScope.value) {
+            genericsContext.bindComponentGenericTypes(handleResponse.component, config.properties.genericTypeInstances, { config }, (subType, superType) => this.parameterHandler.parameterPropertyHandlerRange
+                .hasType(subType, superType, genericsContext, config.property.genericTypeInstancesComponentScope, config.properties.genericTypeInstances, { config }));
         }
         return genericsContext;
     }

package/lib/preprocess/GenericsContext.d.ts

@@ -1,30 +1,74 @@
+import type * as RDF from '@rdfjs/types';
 import type { Resource, RdfObjectLoader } from 'rdf-object';
+import type { IParamValueConflict } from './parameterproperty/ParameterPropertyHandlerRange';
 /**
  * Context for binding generic types to a concrete range value.
  */
 export declare class GenericsContext {
+    private static readonly XSD_INHERITANCE_TABLE;
     private readonly objectLoader;
     /**
      * Set of generic type ids.
      * @private
      */
-    readonly genericTypeIds: Record<string, boolean>;
+    genericTypeIds: Record<string, boolean>;
     /**
      * Mapping of generic type id to the resolved range.
      * @private
      */
-    readonly bindings: Record<string, Resource[]>;
+    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.
+     * @param valueTypeValidator Callback for validating values against types.
+     * @param typeTypeValidator Callback for validating sub-types against super-types.
+     * @return boolean True if the binding was valid and took place.
      */
-    bindGenericTypeToValue(genericTypeId: string, value: Resource | undefined, typeValidator: (subValue: Resource | undefined, subType: Resource) => boolean): boolean;
+    bindGenericTypeToValue(genericTypeId: string, value: Resource | undefined, valueTypeValidator: (subValue: Resource | undefined, subType: Resource) => IParamValueConflict | undefined, typeTypeValidator: (subValue: Resource, subType: Resource) => IParamValueConflict | undefined): IParamValueConflict | undefined;
+    /**
+     * Try to bind the given range to the given generic.
+     * @param genericTypeId IRI of the generic to bind.
+     * @param range The range to bind to.
+     * @param typeTypeValidator Callback for validating sub-types against super-types.
+     * @return boolean True if the binding was valid and took place.
+     */
+    bindGenericTypeToRange(genericTypeId: string, range: Resource, typeTypeValidator: (subType: Resource, superType: Resource) => IParamValueConflict | undefined): IParamValueConflict | undefined;
     /**
      * Infer the parameter range of the given value.
      * @param value A value.
      */
-    inferValueRange(value: Resource | undefined): Resource[];
+    inferValueRange(value: Resource | undefined): Resource | undefined;
+    /**
+     * Merge the given ranges into a new range.
+     * This will return undefined in the ranges are incompatible.
+     *
+     * If one type is more specific than the other, it will return the narrowest type.
+     *
+     * @param rangeA A first range.
+     * @param rangeB A second range.
+     * @param typeTypeValidator Callback for validating sub-types against super-types.
+     */
+    mergeRanges(rangeA: Resource, rangeB: Resource, typeTypeValidator: (subType: Resource, superType: Resource) => IParamValueConflict | undefined): Resource | undefined;
+    protected mergeUnion(rangeUnion: Resource, rangeOther: Resource, typeValidator: (subType: Resource, superType: Resource) => IParamValueConflict | undefined): Resource | undefined;
+    /**
+     * Check if the given type is a subtype of the given super type.
+     * @param type A type node.
+     * @param potentialSuperType A potential super type node.
+     */
+    isXsdSubType(type: RDF.Term, potentialSuperType: RDF.Term): boolean;
+    /**
+     * Apply the give generic type instances for the given component's generic type parameters.
+     *
+     * This will throw if the number of passed instances does not match with
+     * the number of generic type parameters on the component.
+     *
+     * @param component The component
+     * @param genericTypeInstances The generic type instances to apply.
+     * @param errorContext The context for error reporting.
+     * @param typeTypeValidator Callback for validating sub-types against super-types.
+     * @return boolean False if the application failed due to a binding error. True otherwise
+     */
+    bindComponentGenericTypes(component: Resource, genericTypeInstances: Resource[], errorContext: Record<string, Resource | Resource[] | string>, typeTypeValidator: (subValue: Resource, subType: Resource) => IParamValueConflict | undefined): IParamValueConflict | undefined;
 }

package/lib/preprocess/GenericsContext.js

@@ -1,6 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.GenericsContext = void 0;
+const ErrorResourcesContext_1 = require("../util/ErrorResourcesContext");
+const ParameterPropertyHandlerRange_1 = require("./parameterproperty/ParameterPropertyHandlerRange");
 /**
  * Context for binding generic types to a concrete range value.
  */
@@ -12,7 +14,7 @@ class GenericsContext {
         this.bindings = {};
         for (const genericTypeParameter of genericTypeParameters) {
             if (genericTypeParameter.property.range) {
-                this.bindings[genericTypeParameter.value] = genericTypeParameter.properties.range;
+                this.bindings[genericTypeParameter.value] = genericTypeParameter.property.range;
             }
         }
     }
@@ -20,27 +22,68 @@ class GenericsContext {
      * 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.
+     * @param valueTypeValidator Callback for validating values against types.
+     * @param typeTypeValidator Callback for validating sub-types against super-types.
+     * @return boolean True if the binding was valid and took place.
      */
-    bindGenericTypeToValue(genericTypeId, value, typeValidator) {
+    bindGenericTypeToValue(genericTypeId, value, valueTypeValidator, typeTypeValidator) {
         // Fail if an unknown generic type is referenced
         if (!(genericTypeId in this.genericTypeIds)) {
-            return false;
+            return {
+                description: `unknown generic <${genericTypeId}> is being referenced`,
+                context: { value },
+            };
         }
         // 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;
+        if (existingRange) {
+            const subConflict = valueTypeValidator(value, existingRange);
+            if (subConflict) {
+                return {
+                    description: `generic <${genericTypeId}> with existing range "${ParameterPropertyHandlerRange_1.ParameterPropertyHandlerRange.rangeToDisplayString(existingRange, this)}" can not contain the given value`,
+                    context: { existingRange, value },
+                    causes: [subConflict],
+                };
+            }
         }
         // 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;
+        if (!valueRange) {
+            return;
         }
-        return true;
+        // Save inferred type
+        return this.bindGenericTypeToRange(genericTypeId, valueRange, typeTypeValidator);
+    }
+    /**
+     * Try to bind the given range to the given generic.
+     * @param genericTypeId IRI of the generic to bind.
+     * @param range The range to bind to.
+     * @param typeTypeValidator Callback for validating sub-types against super-types.
+     * @return boolean True if the binding was valid and took place.
+     */
+    bindGenericTypeToRange(genericTypeId, range, typeTypeValidator) {
+        // Fail if an unknown generic type is referenced
+        if (!(genericTypeId in this.genericTypeIds)) {
+            return {
+                description: `unknown generic <${genericTypeId}> is being referenced`,
+                context: {},
+            };
+        }
+        // If we already had a range, check if they match
+        if (this.bindings[genericTypeId]) {
+            const mergedRange = this.mergeRanges(this.bindings[genericTypeId], range, typeTypeValidator);
+            if (!mergedRange) {
+                return {
+                    description: `generic <${genericTypeId}> with existing range "${ParameterPropertyHandlerRange_1.ParameterPropertyHandlerRange.rangeToDisplayString(this.bindings[genericTypeId], this)}" can not be bound to range "${ParameterPropertyHandlerRange_1.ParameterPropertyHandlerRange.rangeToDisplayString(range, this)}"`,
+                    context: {
+                        existingRange: this.bindings[genericTypeId],
+                        newRange: range,
+                    },
+                };
+            }
+            range = mergedRange;
+        }
+        this.bindings[genericTypeId] = range;
     }
     /**
      * Infer the parameter range of the given value.
@@ -49,15 +92,235 @@ class GenericsContext {
     inferValueRange(value) {
         // Value is undefined
         if (!value) {
-            return [this.objectLoader.createCompactedResource({ type: 'ParameterRangeUndefined' })];
+            return this.objectLoader.createCompactedResource({ '@type': 'ParameterRangeUndefined' });
         }
         // Value is a literal
         if (value.term.termType === 'Literal') {
-            return [this.objectLoader.createCompactedResource(value.term.datatype)];
+            return this.objectLoader.createCompactedResource(value.term.datatype);
         }
         // Value is a named node
-        return value.properties.type;
+        const types = value.properties.type;
+        if (types.length > 1) {
+            return this.objectLoader.createCompactedResource({
+                '@type': 'ParameterRangeUnion',
+                parameterRangeElements: types,
+            });
+        }
+        return types[0];
+    }
+    /**
+     * Merge the given ranges into a new range.
+     * This will return undefined in the ranges are incompatible.
+     *
+     * If one type is more specific than the other, it will return the narrowest type.
+     *
+     * @param rangeA A first range.
+     * @param rangeB A second range.
+     * @param typeTypeValidator Callback for validating sub-types against super-types.
+     */
+    mergeRanges(rangeA, rangeB, typeTypeValidator) {
+        var _a, _b;
+        // Check if one is a subtype of the other (and return the most specific type)
+        if (!typeTypeValidator(rangeA, rangeB)) {
+            return rangeA;
+        }
+        if (!typeTypeValidator(rangeB, rangeA)) {
+            return rangeB;
+        }
+        // Check XSD inheritance relationship
+        if (this.isXsdSubType(rangeA.term, rangeB.term)) {
+            return rangeA;
+        }
+        if (this.isXsdSubType(rangeB.term, rangeA.term)) {
+            return rangeB;
+        }
+        // If a range is a wildcard, return the other type
+        if (rangeA.isA('ParameterRangeWildcard')) {
+            return rangeB;
+        }
+        if (rangeB.isA('ParameterRangeWildcard')) {
+            return rangeA;
+        }
+        // Ranges always match with generic references
+        if (rangeA.isA('ParameterRangeGenericTypeReference')) {
+            return rangeB;
+        }
+        if (rangeB.isA('ParameterRangeGenericTypeReference')) {
+            return rangeA;
+        }
+        // Check parameter range types
+        if ((_a = rangeA.property.type) === null || _a === void 0 ? void 0 : _a.term.equals((_b = rangeB.property.type) === null || _b === void 0 ? void 0 : _b.term)) {
+            // Check sub-value for specific param range cases
+            if (rangeA.isA('ParameterRangeArray') ||
+                rangeA.isA('ParameterRangeRest') ||
+                rangeA.isA('ParameterRangeKeyof')) {
+                const valueA = rangeA.property.parameterRangeValue;
+                const valueB = rangeB.property.parameterRangeValue;
+                const merged = this.mergeRanges(valueA, valueB, typeTypeValidator);
+                if (!merged) {
+                    return;
+                }
+                return this.objectLoader.createCompactedResource({
+                    '@type': rangeA.property.type,
+                    parameterRangeValue: merged,
+                });
+            }
+            // Check sub-values for specific param range cases
+            if (rangeA.isA('ParameterRangeUnion') ||
+                rangeA.isA('ParameterRangeIntersection') ||
+                rangeA.isA('ParameterRangeTuple')) {
+                const valuesA = rangeA.properties.parameterRangeElements;
+                const valuesB = rangeB.properties.parameterRangeElements;
+                if (valuesA.length !== valuesB.length) {
+                    return;
+                }
+                const merged = valuesA.map((valueA, i) => this.mergeRanges(valueA, valuesB[i], typeTypeValidator));
+                if (merged.some(subValue => !subValue)) {
+                    return;
+                }
+                return this.objectLoader.createCompactedResource({
+                    '@type': rangeA.property.type,
+                    parameterRangeElements: merged,
+                });
+            }
+            // Check sub-values for generic components
+            if (rangeA.isA('ParameterRangeGenericComponent')) {
+                const mergedComponent = this.mergeRanges(rangeA.property.component, rangeB.property.component, typeTypeValidator);
+                if (!mergedComponent) {
+                    return;
+                }
+                const valuesA = rangeA.properties.genericTypeInstances;
+                const valuesB = rangeB.properties.genericTypeInstances;
+                if (valuesA.length !== valuesB.length) {
+                    return;
+                }
+                const merged = valuesA.map((valueA, i) => this.mergeRanges(valueA, valuesB[i], typeTypeValidator));
+                if (merged.some(subValue => !subValue)) {
+                    return;
+                }
+                return this.objectLoader.createCompactedResource({
+                    '@type': 'ParameterRangeGenericComponent',
+                    component: mergedComponent,
+                    genericTypeInstances: merged,
+                });
+            }
+            return rangeA;
+        }
+        // Handle left or right being a union
+        if (rangeA.isA('ParameterRangeUnion')) {
+            return this.mergeUnion(rangeA, rangeB, typeTypeValidator);
+        }
+        if (rangeB.isA('ParameterRangeUnion')) {
+            return this.mergeUnion(rangeB, rangeA, typeTypeValidator);
+        }
+        // Check if the range refers to a component with a generic type
+        // TODO: somehow pass the range's component and genericTypeInstances (like in ParameterPropertyHandlerRange)?
+        if (rangeA.isA('ParameterRangeGenericComponent')) {
+            return this.mergeRanges(rangeA.property.component, rangeB, typeTypeValidator);
+        }
+        if (rangeB.isA('ParameterRangeGenericComponent')) {
+            return this.mergeRanges(rangeB.property.component, rangeA, typeTypeValidator);
+        }
+    }
+    mergeUnion(rangeUnion, rangeOther, typeValidator) {
+        const elements = rangeUnion.properties.parameterRangeElements;
+        const mergedValues = elements
+            .map(element => this.mergeRanges(rangeOther, element, typeValidator))
+            .filter(Boolean);
+        if (mergedValues.length === 0) {
+            return;
+        }
+        if (mergedValues.length === 1) {
+            return mergedValues[0];
+        }
+        return this.objectLoader.createCompactedResource({
+            '@type': 'ParameterRangeUnion',
+            parameterRangeElements: mergedValues,
+        });
+    }
+    /**
+     * Check if the given type is a subtype of the given super type.
+     * @param type A type node.
+     * @param potentialSuperType A potential super type node.
+     */
+    isXsdSubType(type, potentialSuperType) {
+        const values = GenericsContext.XSD_INHERITANCE_TABLE[potentialSuperType.value];
+        return values && values.has(type.value);
+    }
+    /**
+     * Apply the give generic type instances for the given component's generic type parameters.
+     *
+     * This will throw if the number of passed instances does not match with
+     * the number of generic type parameters on the component.
+     *
+     * @param component The component
+     * @param genericTypeInstances The generic type instances to apply.
+     * @param errorContext The context for error reporting.
+     * @param typeTypeValidator Callback for validating sub-types against super-types.
+     * @return boolean False if the application failed due to a binding error. True otherwise
+     */
+    bindComponentGenericTypes(component, genericTypeInstances, errorContext, typeTypeValidator) {
+        const genericTypeParameters = component.properties.genericTypeParameters;
+        // Don't do anything if no generic type instances are passed.
+        if (genericTypeInstances.length === 0) {
+            return {
+                description: `no generic type instances are passed`,
+                context: errorContext,
+            };
+        }
+        // Throw if an unexpected number of generic type instances are passed.
+        if (genericTypeParameters.length !== genericTypeInstances.length) {
+            throw new ErrorResourcesContext_1.ErrorResourcesContext(`Invalid generic type instantiation: a different amount of generic types are passed (${genericTypeInstances.length}) than are defined on the component (${genericTypeParameters.length}).`, Object.assign({ passedGenerics: genericTypeInstances, definedGenerics: genericTypeParameters, component }, errorContext));
+        }
+        // Populate with manually defined generic type bindings
+        for (const [i, genericTypeInstance] of genericTypeInstances.entries()) {
+            // Remap generic type IRI to inner generic type IRI
+            const genericTypeIdInner = genericTypeParameters[i].value;
+            if (genericTypeInstance.property.parameterRangeGenericBindings) {
+                const subConflict = this.bindGenericTypeToRange(genericTypeIdInner, genericTypeInstance.property.parameterRangeGenericBindings, typeTypeValidator);
+                if (subConflict) {
+                    return {
+                        description: `invalid binding for generic <${genericTypeIdInner}>`,
+                        context: errorContext,
+                        causes: [subConflict],
+                    };
+                }
+            }
+            this.genericTypeIds[genericTypeIdInner] = true;
+        }
     }
 }
 exports.GenericsContext = GenericsContext;
+GenericsContext.XSD_INHERITANCE_TABLE = {
+    'http://www.w3.org/2001/XMLSchema#number': new Set([
+        'http://www.w3.org/2001/XMLSchema#integer',
+        'http://www.w3.org/2001/XMLSchema#long',
+        'http://www.w3.org/2001/XMLSchema#int',
+        'http://www.w3.org/2001/XMLSchema#byte',
+        'http://www.w3.org/2001/XMLSchema#short',
+        'http://www.w3.org/2001/XMLSchema#negativeInteger',
+        'http://www.w3.org/2001/XMLSchema#nonNegativeInteger',
+        'http://www.w3.org/2001/XMLSchema#nonPositiveInteger',
+        'http://www.w3.org/2001/XMLSchema#positiveInteger',
+        'http://www.w3.org/2001/XMLSchema#unsignedByte',
+        'http://www.w3.org/2001/XMLSchema#unsignedInt',
+        'http://www.w3.org/2001/XMLSchema#unsignedLong',
+        'http://www.w3.org/2001/XMLSchema#unsignedShort',
+        'http://www.w3.org/2001/XMLSchema#double',
+        'http://www.w3.org/2001/XMLSchema#decimal',
+        'http://www.w3.org/2001/XMLSchema#float',
+    ]),
+    'http://www.w3.org/2001/XMLSchema#string': new Set([
+        'http://www.w3.org/2001/XMLSchema#normalizedString',
+        'http://www.w3.org/2001/XMLSchema#anyURI',
+        'http://www.w3.org/2001/XMLSchema#base64Binary',
+        'http://www.w3.org/2001/XMLSchema#language',
+        'http://www.w3.org/2001/XMLSchema#Name',
+        'http://www.w3.org/2001/XMLSchema#NCName',
+        'http://www.w3.org/2001/XMLSchema#NMTOKEN',
+        'http://www.w3.org/2001/XMLSchema#token',
+        'http://www.w3.org/2001/XMLSchema#hexBinary',
+        'http://www.w3.org/2001/XMLSchema#langString',
+    ]),
+};
 //# sourceMappingURL=GenericsContext.js.map

package/lib/preprocess/ParameterHandler.d.ts

@@ -1,11 +1,13 @@
 import type { RdfObjectLoader, Resource } from 'rdf-object';
 import type { GenericsContext } from './GenericsContext';
+import { ParameterPropertyHandlerRange } from './parameterproperty/ParameterPropertyHandlerRange';
 /**
  * Handles component parameters in the context of a config.
  */
 export declare class ParameterHandler {
     private readonly objectLoader;
     private readonly parameterPropertyHandlers;
+    readonly parameterPropertyHandlerRange: ParameterPropertyHandlerRange;
     constructor(options: IParameterHandlerOptions);
     /**
      * Obtain the values of the given parameter in the context of the given config.

package/lib/preprocess/ParameterHandler.js

@@ -17,7 +17,7 @@ class ParameterHandler {
             new ParameterPropertyHandlerDefaultScoped_1.ParameterPropertyHandlerDefaultScoped(this.objectLoader),
             new ParameterPropertyHandlerDefault_1.ParameterPropertyHandlerDefault(this.objectLoader),
             new ParameterPropertyHandlerFixed_1.ParameterPropertyHandlerFixed(this.objectLoader),
-            new ParameterPropertyHandlerRange_1.ParameterPropertyHandlerRange(this.objectLoader),
+            this.parameterPropertyHandlerRange = new ParameterPropertyHandlerRange_1.ParameterPropertyHandlerRange(this.objectLoader),
             new ParameterPropertyHandlerLazy_1.ParameterPropertyHandlerLazy(),
         ];
     }