componentsjs 5.1.0 → 5.2.0

package/CHANGELOG.md

@@ -1,6 +1,12 @@
 # Changelog
 All notable changes to this project will be documented in this file.
 
+<a name="v5.2.0"></a>
+## [v5.2.0](https://github.com/LinkedSoftwareDependencies/Components.js/compare/v5.1.0...v5.2.0) - 2022-05-20
+
+### Added
+* [Preserve literal values for params with type unknown](https://github.com/LinkedSoftwareDependencies/Components.js/commit/ad52da8afc2340ddc63e8a45c4d560e11ecb3ceb)
+
 <a name="v5.1.0"></a>
 ## [v5.1.0](https://github.com/LinkedSoftwareDependencies/Components.js/compare/v5.0.0...v5.1.0) - 2022-05-10
 

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

@@ -33,6 +33,11 @@ export declare class ParameterPropertyHandlerRange implements IParameterProperty
      * @return IParamValueConflict A conflict value if there was an error, or undefined if there was no error
      */
     hasValueType(value: Resource | undefined, type: Resource | undefined, errorContext: IErrorContext, genericsContext: GenericsContext): IParamValueConflict | undefined;
+    /**
+     * Utility function for handling Literals.
+     * If the provided value represents a valid Literal, the `valueRaw` field will be set.
+     */
+    private interpretValueAsType;
     static throwIncorrectTypeError(value: Resource | undefined, parameter: Resource, genericsContext: GenericsContext, conflict: IParamValueConflict): never;
     /**
      * Check if the given value is of the given type.
@@ -54,3 +59,13 @@ export interface IParamValueConflict {
     context: IErrorContext;
     causes?: IParamValueConflict[];
 }
+/**
+ * Represents the result of an interpretValuesAsType operation.
+ */
+export interface ILiteralAsTypeInterpretationResult {
+    /**
+     * Value is true if a matching literal type was found.
+     */
+    match: boolean;
+    value?: IParamValueConflict;
+}

package/lib/preprocess/parameterproperty/ParameterPropertyHandlerRange.js

@@ -53,6 +53,11 @@ class ParameterPropertyHandlerRange {
             return;
         }
         if (type.isA('ParameterRangeWildcard')) {
+            if (value && value.term.termType === 'Literal') {
+                // Get datatype of the configured value
+                const configuredDataType = value.term.datatype;
+                return this.interpretValueAsType(value, configuredDataType, errorContext, genericsContext).value;
+            }
             return;
         }
         if (!value && type.isA('ParameterRangeUndefined')) {
@@ -64,69 +69,10 @@ class ParameterPropertyHandlerRange {
         }
         // Handle literal values
         if (value && value.type === 'Literal') {
-            let parsed;
-            switch (type.value) {
-                case Iris_1.IRIS_XSD.string:
-                    return;
-                case Iris_1.IRIS_XSD.boolean:
-                    if (value.value === 'true') {
-                        value.term.valueRaw = true;
-                    }
-                    else if (value.value === 'false') {
-                        value.term.valueRaw = false;
-                    }
-                    else {
-                        return {
-                            description: 'value must either be "true" or "false"',
-                            context: errorContext,
-                        };
-                    }
-                    return;
-                case Iris_1.IRIS_XSD.integer:
-                case Iris_1.IRIS_XSD.number:
-                case Iris_1.IRIS_XSD.int:
-                case Iris_1.IRIS_XSD.byte:
-                case Iris_1.IRIS_XSD.long:
-                    parsed = Number.parseInt(value.value, 10);
-                    if (Number.isNaN(parsed)) {
-                        return {
-                            description: `value is not a number`,
-                            context: errorContext,
-                        };
-                    }
-                    // ParseInt also parses floats to ints!
-                    if (String(parsed) !== value.value) {
-                        return {
-                            description: `value can not be a float`,
-                            context: errorContext,
-                        };
-                    }
-                    value.term.valueRaw = parsed;
-                    return;
-                case Iris_1.IRIS_XSD.float:
-                case Iris_1.IRIS_XSD.decimal:
-                case Iris_1.IRIS_XSD.double:
-                    parsed = Number.parseFloat(value.value);
-                    if (Number.isNaN(parsed)) {
-                        return {
-                            description: `value is not a number`,
-                            context: errorContext,
-                        };
-                    }
-                    value.term.valueRaw = parsed;
-                    return;
-                case Iris_1.IRIS_RDF.JSON:
-                    try {
-                        parsed = JSON.parse(value.value);
-                        value.term.valueRaw = parsed;
-                    }
-                    catch (error) {
-                        return {
-                            description: `JSON parse exception: ${error.message}`,
-                            context: errorContext,
-                        };
-                    }
-                    return;
+            const result = this.interpretValueAsType(value, type, errorContext, genericsContext);
+            if (result.match) {
+                // Stop processing and return (with a possible IParamValueConflict) if a match was found.
+                return result.value;
             }
         }
         // Allow IRIs to be casted to strings
@@ -359,6 +305,93 @@ class ParameterPropertyHandlerRange {
         }
         return hasTypeConflict || { description: 'unknown parameter type', context: errorContext };
     }
+    /**
+     * Utility function for handling Literals.
+     * If the provided value represents a valid Literal, the `valueRaw` field will be set.
+     */
+    interpretValueAsType(value, type, errorContext, genericsContext) {
+        let parsed;
+        switch (type.value) {
+            case Iris_1.IRIS_XSD.string:
+                return { match: true };
+            case Iris_1.IRIS_XSD.boolean:
+                if (value.value === 'true') {
+                    value.term.valueRaw = true;
+                }
+                else if (value.value === 'false') {
+                    value.term.valueRaw = false;
+                }
+                else {
+                    return {
+                        match: true,
+                        value: {
+                            description: 'value must either be "true" or "false"',
+                            context: errorContext,
+                        },
+                    };
+                }
+                return { match: true };
+            case Iris_1.IRIS_XSD.integer:
+            case Iris_1.IRIS_XSD.number:
+            case Iris_1.IRIS_XSD.int:
+            case Iris_1.IRIS_XSD.byte:
+            case Iris_1.IRIS_XSD.long:
+                parsed = Number.parseInt(value.value, 10);
+                if (Number.isNaN(parsed)) {
+                    return {
+                        match: true,
+                        value: {
+                            description: `value is not a number`,
+                            context: errorContext,
+                        },
+                    };
+                }
+                // ParseInt also parses floats to ints!
+                if (String(parsed) !== value.value) {
+                    return {
+                        match: true,
+                        value: {
+                            description: `value can not be a float`,
+                            context: errorContext,
+                        },
+                    };
+                }
+                value.term.valueRaw = parsed;
+                return { match: true };
+            case Iris_1.IRIS_XSD.float:
+            case Iris_1.IRIS_XSD.decimal:
+            case Iris_1.IRIS_XSD.double:
+                parsed = Number.parseFloat(value.value);
+                if (Number.isNaN(parsed)) {
+                    return {
+                        match: true,
+                        value: {
+                            description: `value is not a number`,
+                            context: errorContext,
+                        },
+                    };
+                }
+                value.term.valueRaw = parsed;
+                return { match: true };
+            case Iris_1.IRIS_RDF.JSON:
+                try {
+                    parsed = JSON.parse(value.value);
+                    value.term.valueRaw = parsed;
+                }
+                catch (error) {
+                    return {
+                        match: true,
+                        value: {
+                            description: `JSON parse exception: ${error.message}`,
+                            context: errorContext,
+                        },
+                    };
+                }
+                return { match: true };
+            default:
+                return { match: false };
+        }
+    }
     static throwIncorrectTypeError(value, parameter, genericsContext, conflict) {
         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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "componentsjs",
-  "version": "5.1.0",
+  "version": "5.2.0",
   "description": "A semantic dependency injection framework",
   "lsd:contexts": {
     "https://linkedsoftwaredependencies.org/bundles/npm/componentsjs/^5.0.0/components/context.jsonld": "components/context.jsonld"