componentsjs 4.5.0 → 5.0.0-beta.3

package/lib/preprocess/ConfigPreprocessorComponent.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ConfigPreprocessorComponent = void 0;
 const Iris_1 = require("../rdf/Iris");
 const ErrorResourcesContext_1 = require("../util/ErrorResourcesContext");
+const GenericsContext_1 = require("./GenericsContext");
 /**
  * Handles config that refer to a component as type.
  * The component may have parameters that can be applied on the config.
@@ -82,34 +83,55 @@ class ConfigPreprocessorComponent {
         if (requireElement) {
             configRaw.property.requireElement = requireElement;
         }
-        configRaw.properties.arguments = this.transformConstructorArguments(config, handleResponse);
+        configRaw.property.arguments = this.transformConstructorArguments(config, handleResponse);
         // Validate the input config
         this.validateConfig(config, handleResponse);
         return configRaw;
     }
+    createGenericsContext(handleResponse, config) {
+        // Create a new generics context for the component's generic type parameters
+        const genericsContext = new GenericsContext_1.GenericsContext(this.objectLoader, handleResponse.component.properties.genericTypeParameters);
+        // 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;
+    }
     /**
      * Determine the constructor arguments of the given config.
      * @param config A config.
      * @param handleResponse Return value of the {#canHandle}.
      */
     transformConstructorArguments(config, handleResponse) {
-        // Create a single-arg hash constructor, and add all params as key-value pairs
-        const param0 = this.objectLoader.createCompactedResource({
-            // Hack to enforce ArgumentConstructorHandlerHash
-            hasFields: '"true"',
-        });
+        const entries = [];
+        const genericsContext = this.createGenericsContext(handleResponse, config);
         for (const fieldData of handleResponse.component.properties.parameters) {
             const field = this.objectLoader.createCompactedResource({});
             field.property.key = this.objectLoader.createCompactedResource(`"${fieldData.term.value}"`);
-            for (const value of this.parameterHandler.applyParameterValues(handleResponse.component, fieldData, config)) {
-                field.properties.value.push(value);
+            const value = this.parameterHandler
+                .applyParameterValues(handleResponse.component, fieldData, config, genericsContext);
+            if (value) {
+                field.property.value = value;
             }
-            param0.properties.fields.push(field);
+            entries.push(field);
         }
+        // Create a single-arg hash constructor, and add all params as key-value pairs
+        const param0 = this.objectLoader.createCompactedResource({
+            fields: {
+                list: entries,
+            },
+        });
         // Create constructor arguments list
-        const args = this.objectLoader.createCompactedResource({});
-        args.list = [param0];
-        return [args];
+        return this.objectLoader.createCompactedResource({
+            list: [
+                param0,
+            ],
+        });
     }
     /**
      * Let this config inherit parameter values from previously instantiated configs.

package/lib/preprocess/ConfigPreprocessorComponentMapped.d.ts

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

package/lib/preprocess/ConfigPreprocessorComponentMapped.js

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

package/lib/preprocess/GenericsContext.d.ts

@@ -0,0 +1,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
+     */
+    genericTypeIds: Record<string, boolean>;
+    /**
+     * Mapping of generic type id to the resolved range.
+     * @private
+     */
+    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 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, 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 | 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

@@ -0,0 +1,326 @@
+"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.
+ */
+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.property.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 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, valueTypeValidator, typeTypeValidator) {
+        // Fail if an unknown generic type is referenced
+        if (!(genericTypeId in this.genericTypeIds)) {
+            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) {
+            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) {
+            return;
+        }
+        // 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.
+     * @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
+        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,19 +1,23 @@
 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.
      * @param configRoot The root config resource that we are working in.
      * @param parameter The parameter resource to get the value for.
      * @param configElement Part of the config resource to look for parameter instantiations as predicates.
-     * @return The parameter value(s)
+     * @param genericsContext Context for generic types.
+     * @return - The parameter value
      */
-    applyParameterValues(configRoot: Resource, parameter: Resource, configElement: Resource): Resource[];
+    applyParameterValues(configRoot: Resource, parameter: Resource, configElement: Resource, genericsContext: GenericsContext): Resource | undefined;
 }
 export interface IParameterHandlerOptions {
     objectLoader: RdfObjectLoader;

package/lib/preprocess/ParameterHandler.js

@@ -1,13 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ParameterHandler = void 0;
+const ErrorResourcesContext_1 = require("../util/ErrorResourcesContext");
 const ParameterPropertyHandlerDefault_1 = require("./parameterproperty/ParameterPropertyHandlerDefault");
 const ParameterPropertyHandlerDefaultScoped_1 = require("./parameterproperty/ParameterPropertyHandlerDefaultScoped");
 const ParameterPropertyHandlerFixed_1 = require("./parameterproperty/ParameterPropertyHandlerFixed");
 const ParameterPropertyHandlerLazy_1 = require("./parameterproperty/ParameterPropertyHandlerLazy");
 const ParameterPropertyHandlerRange_1 = require("./parameterproperty/ParameterPropertyHandlerRange");
-const ParameterPropertyHandlerRequired_1 = require("./parameterproperty/ParameterPropertyHandlerRequired");
-const ParameterPropertyHandlerUnique_1 = require("./parameterproperty/ParameterPropertyHandlerUnique");
 /**
  * Handles component parameters in the context of a config.
  */
@@ -16,11 +15,9 @@ class ParameterHandler {
         this.objectLoader = options.objectLoader;
         this.parameterPropertyHandlers = [
             new ParameterPropertyHandlerDefaultScoped_1.ParameterPropertyHandlerDefaultScoped(this.objectLoader),
-            new ParameterPropertyHandlerDefault_1.ParameterPropertyHandlerDefault(),
-            new ParameterPropertyHandlerRequired_1.ParameterPropertyHandlerRequired(this.objectLoader),
-            new ParameterPropertyHandlerFixed_1.ParameterPropertyHandlerFixed(),
-            new ParameterPropertyHandlerUnique_1.ParameterPropertyHandlerUnique(this.objectLoader),
-            new ParameterPropertyHandlerRange_1.ParameterPropertyHandlerRange(this.objectLoader),
+            new ParameterPropertyHandlerDefault_1.ParameterPropertyHandlerDefault(this.objectLoader),
+            new ParameterPropertyHandlerFixed_1.ParameterPropertyHandlerFixed(this.objectLoader),
+            this.parameterPropertyHandlerRange = new ParameterPropertyHandlerRange_1.ParameterPropertyHandlerRange(this.objectLoader),
             new ParameterPropertyHandlerLazy_1.ParameterPropertyHandlerLazy(),
         ];
     }
@@ -29,25 +26,30 @@ class ParameterHandler {
      * @param configRoot The root config resource that we are working in.
      * @param parameter The parameter resource to get the value for.
      * @param configElement Part of the config resource to look for parameter instantiations as predicates.
-     * @return The parameter value(s)
+     * @param genericsContext Context for generic types.
+     * @return - The parameter value
      */
-    applyParameterValues(configRoot, parameter, configElement) {
-        // Obtain the parameter's value in the given config, and flatten RDF lists
-        let value = [];
-        for (const element of configElement.properties[parameter.value]) {
-            if (element.list) {
-                for (const subElement of element.list) {
-                    value.push(subElement);
-                }
-            }
-            else {
-                value.push(element);
+    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;
+        if (values.length === 1) {
+            value = values[0];
+        }
+        else if (values.length > 0) {
+            if (values.some(subValue => !subValue.list)) {
+                throw new ErrorResourcesContext_1.ErrorResourcesContext(`Detected multiple values for parameter ${parameter.value}. RDF lists should be used for defining multiple values.`, {
+                    arguments: values,
+                });
             }
+            value = this.objectLoader.createCompactedResource({
+                list: values.flatMap(subValue => subValue.list),
+            });
         }
         // 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;