componentsjs 5.0.0-beta.2 → 5.0.0-beta.6

package/lib/preprocess/GenericsContext.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.GenericsContext = void 0;
+const ParameterPropertyHandlerRange_1 = require("./parameterproperty/ParameterPropertyHandlerRange");
 /**
  * Context for binding generic types to a concrete range value.
  */
@@ -12,7 +13,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 +21,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 +91,238 @@ 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) {
+            return {
+                description: `Invalid generic type instantiation: a different amount of generic types are passed (${genericTypeInstances.length}) than are defined on the component (${genericTypeParameters.length}).`,
+                context: 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.
@@ -19,4 +21,5 @@ export declare class ParameterHandler {
 }
 export interface IParameterHandlerOptions {
     objectLoader: RdfObjectLoader;
+    typeChecking: boolean;
 }

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, options.typeChecking),
             new ParameterPropertyHandlerLazy_1.ParameterPropertyHandlerLazy(),
         ];
     }
@@ -38,7 +38,7 @@ class ParameterHandler {
         }
         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.`, {
+                throw new ErrorResourcesContext_1.ErrorResourcesContext(`Detected multiple values for parameter ${parameter.value} in ${configElement.value}. RDF lists should be used for defining multiple values.`, {
                     arguments: values,
                 });
             }

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

@@ -1,12 +1,14 @@
 import type { RdfObjectLoader, Resource } from 'rdf-object';
-import type { GenericsContext } from '../GenericsContext';
+import type { IErrorContext } from '../../util/ErrorResourcesContext';
+import { GenericsContext } from '../GenericsContext';
 import type { IParameterPropertyHandler } from './IParameterPropertyHandler';
 /**
  * If a param range is defined, apply the type and validate the range.
  */
 export declare class ParameterPropertyHandlerRange implements IParameterPropertyHandler {
     private readonly objectLoader;
-    constructor(objectLoader: RdfObjectLoader);
+    private readonly typeChecking;
+    constructor(objectLoader: RdfObjectLoader, typeChecking: boolean);
     canHandle(value: Resource | undefined, configRoot: Resource, parameter: Resource): boolean;
     handle(value: Resource | undefined, configRoot: Resource, parameter: Resource, configElement: Resource, genericsContext: GenericsContext): Resource | undefined;
     /**
@@ -20,16 +22,35 @@ export declare class ParameterPropertyHandlerRange implements IParameterProperty
      */
     captureType(value: Resource | undefined, param: Resource, genericsContext: GenericsContext): Resource | undefined;
     /**
-     * Apply the given datatype to the given literal.
-     * Checks if the datatype is correct and casts to the correct js type.
-     * Will throw an error if the type has an invalid value.
-     * Will be ignored if the value is not a literal or the type is not recognized.
+     * Check if the given value is of the given type.
+     *
+     * For valid literals, the `valueRaw` field will be set.
+     *
      * @param value The value.
-     * @param param The parameter.
-     * @param paramRange The parameter's range.
+     * @param type The parameter's range.
      * @param genericsContext Context for generic types.
+     * @param errorContext The context for error reporting.
+     * @return IParamValueConflict A conflict value if there was an error, or undefined if there was no error
      */
-    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;
+    hasValueType(value: Resource | undefined, type: Resource | undefined, errorContext: IErrorContext, genericsContext: GenericsContext): IParamValueConflict | undefined;
+    static throwIncorrectTypeError(value: Resource | undefined, parameter: Resource, genericsContext: GenericsContext, conflict: IParamValueConflict): never;
+    /**
+     * Check if the given value is of the given type.
+     * @param value A value.
+     * @param type A type.
+     * @param genericsContext The current generics context.
+     * @param genericTypeInstancesComponentScope
+     * @param genericTypeInstances
+     * @param errorContext
+     */
+    hasType(value: Resource, type: Resource, genericsContext: GenericsContext, genericTypeInstancesComponentScope: Resource | undefined, genericTypeInstances: Resource[], errorContext: IErrorContext): IParamValueConflict | undefined;
+    static rangeToDisplayString(paramRange: Resource | undefined, genericsContext: GenericsContext): string;
+}
+/**
+ * Represents a conflict between a value and a type.
+ */
+export interface IParamValueConflict {
+    description: string;
+    context: IErrorContext;
+    causes?: IParamValueConflict[];
 }