componentsjs 5.0.0-beta.3 → 5.0.0-beta.4

package/CHANGELOG.md

@@ -1,6 +1,17 @@
 # Changelog
 All notable changes to this project will be documented in this file.
 
+<a name="v5.0.0-beta.4"></a>
+## [v5.0.0-beta.4](https://github.com/LinkedSoftwareDependencies/Components.js/compare/v5.0.0-beta.3...v5.0.0-beta.4) - 2022-01-29
+
+### Added
+* [Support ParameterRangeIndexed for fixed literals](https://github.com/LinkedSoftwareDependencies/Components.js/commit/0d97782a4a8dcca9fc5bbb3389a4213eca5a5205)
+
+### Changed
+* [Propagate original error messages to require calls, Closes #65](https://github.com/LinkedSoftwareDependencies/Components.js/commit/8934ec9b784def601730b3d3f2e60c4ff0b8776e)
+* [Include config id in invalid param error message](https://github.com/LinkedSoftwareDependencies/Components.js/commit/e724f44e2222eb9917da3b227e2ce0dc9cde15f9)
+* [Update memberKeys to memberFields](https://github.com/LinkedSoftwareDependencies/Components.js/commit/2c7437e1519c1813fb1a29f50d7c20bdbdf7f06e)
+
 <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
 

package/components/context.jsonld

@@ -32,8 +32,11 @@
     "parameters": {
       "@id": "oo:parameter"
     },
-    "memberKeys": {
-      "@id": "oo:memberKey"
+    "memberFields": {
+      "@id": "oo:memberFields"
+    },
+    "memberFieldName": {
+      "@id": "oo:memberFieldName"
     },
     "genericTypeParameters": {
       "@id": "oo:genericTypeParameter"
@@ -144,6 +147,17 @@
     "GenericComponentExtension": {
       "@id": "oo:GenericComponentExtension"
     },
+    "ParameterRangeIndexed": {
+      "@id": "oo:ParameterRangeIndexed"
+    },
+    "parameterRangeIndexedObject": {
+      "@id": "oo:parameterRangeIndexedObject",
+      "@type": "@id"
+    },
+    "parameterRangeIndexedIndex": {
+      "@id": "oo:parameterRangeIndexedIndex",
+      "@type": "@id"
+    },
 
     "rdfs": "http://www.w3.org/2000/01/rdf-schema#",
     "comment": {

package/lib/construction/strategy/ConstructionStrategyCommonJs.d.ts

@@ -16,7 +16,9 @@ export declare class ConstructionStrategyCommonJs implements IConstructionStrate
      * @param requireName The module name that should be required.
      * @returns {any} The require() result
      */
-    requireCurrentRunningModuleIfCurrent(moduleState: IModuleState, requireName: string): void;
+    requireCurrentRunningModuleIfCurrent(moduleState: IModuleState, requireName: string): {
+        value: any;
+    } | false;
     createHash(options: ICreationStrategyHashOptions<any>): any;
     createArray(options: ICreationStrategyArrayOptions<any>): any;
     createLazySupplier(options: ICreationStrategySupplierOptions<any>): Promise<any>;

package/lib/construction/strategy/ConstructionStrategyCommonJs.js

@@ -14,16 +14,14 @@ class ConstructionStrategyCommonJs {
     createInstance(options) {
         // Call require()
         options.requireName = this.overrideRequireNames[options.requireName] || options.requireName;
+        // First try requiring current module, and fallback to a plain require
         let object;
-        try {
-            object = this.requireCurrentRunningModuleIfCurrent(options.moduleState, options.requireName);
-        }
-        catch (_a) {
-            // Always require relative from main module, because Components.js will in most cases just be dependency.
-            object = this.req(options.requireName.startsWith('.') ?
+        const currentResult = this.requireCurrentRunningModuleIfCurrent(options.moduleState, options.requireName);
+        object = currentResult !== false ?
+            currentResult.value :
+            this.req(options.requireName.startsWith('.') ?
                 Path.join(process.cwd(), options.requireName) :
                 this.req.resolve(options.requireName, { paths: [options.moduleState.mainModulePath] }));
-        }
         // Determine the child of the require'd element
         let subObject;
         if (options.requireElement) {
@@ -31,7 +29,7 @@ class ConstructionStrategyCommonJs {
             try {
                 subObject = requireElementPath.reduce((acc, subRequireElement) => acc[subRequireElement], object);
             }
-            catch (_b) {
+            catch (_a) {
                 throw new Error(`Failed to get module element ${options.requireElement} from module ${options.requireName}`);
             }
         }
@@ -65,11 +63,11 @@ class ConstructionStrategyCommonJs {
                 const mainPath = Path.posix.join(moduleState.mainModulePath, pckg.main);
                 const required = this.req(mainPath);
                 if (required) {
-                    return required;
+                    return { value: required };
                 }
             }
         }
-        throw new Error('Component is not the main module');
+        return false;
     }
     createHash(options) {
         return options.entries.reduce((data, entry) => {

package/lib/construction/strategy/ConstructionStrategyCommonJsString.js

@@ -30,14 +30,12 @@ class ConstructionStrategyCommonJsString {
     createInstance(options) {
         // Call require()
         options.requireName = this.overrideRequireNames[options.requireName] || options.requireName;
-        let resultingRequirePath;
-        try {
-            this.strategyCommonJs.requireCurrentRunningModuleIfCurrent(options.moduleState, options.requireName);
-            resultingRequirePath = `.${Path.sep}${Path.relative(options.moduleState.mainModulePath, this.getCurrentRunningModuleMain(options.moduleState))}`;
-        }
-        catch (_a) {
-            resultingRequirePath = options.requireName;
-        }
+        // First try requiring current module, and fallback to a plain require
+        const currentResult = this.strategyCommonJs
+            .requireCurrentRunningModuleIfCurrent(options.moduleState, options.requireName);
+        const resultingRequirePath = currentResult !== false ?
+            `.${Path.sep}${Path.relative(options.moduleState.mainModulePath, this.getCurrentRunningModuleMain(options.moduleState))}` :
+            options.requireName;
         let serialization = `require('${resultingRequirePath.replace(/\\/gu, '/')}')`;
         // Determine the child of the require'd element
         if (options.requireElement) {

package/lib/preprocess/ParameterHandler.js

@@ -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.js

@@ -259,9 +259,9 @@ class ParameterPropertyHandlerRange {
             // Simulate a union of the member keys as literal parameter ranges
             const simulatedUnionRange = this.objectLoader.createCompactedResource({
                 '@type': 'ParameterRangeUnion',
-                parameterRangeElements: component.properties.memberKeys.map(memberKey => ({
+                parameterRangeElements: component.properties.memberFields.map(memberField => ({
                     '@type': 'ParameterRangeLiteral',
-                    parameterRangeValue: memberKey,
+                    parameterRangeValue: memberField.property.memberFieldName,
                 })),
             });
             const subConflict = this.hasValueType(value, simulatedUnionRange, errorContext, genericsContext);
@@ -274,6 +274,39 @@ class ParameterPropertyHandlerRange {
                 causes: [subConflict],
             };
         }
+        // Check if the range refers to an indexed type such as `MyClass[myField]`
+        if (type.isA('ParameterRangeIndexed')) {
+            const object = type.property.parameterRangeIndexedObject;
+            const index = type.property.parameterRangeIndexedIndex;
+            // Collect field ranges
+            const fieldRanges = Object.fromEntries(object.properties.memberFields
+                .map(memberField => [memberField.property.memberFieldName.value, memberField.property.range ||
+                    this.objectLoader.createCompactedResource({ '@type': 'ParameterRangeWildcard' })]));
+            // Handle literal indexes
+            if (index.isA('ParameterRangeLiteral')) {
+                const field = index.property.parameterRangeValue.value;
+                const range = fieldRanges[field];
+                if (!range) {
+                    return {
+                        description: `indexed index does not refer to a known field`,
+                        context: errorContext,
+                    };
+                }
+                const subConflict = this.hasValueType(value, range, errorContext, genericsContext);
+                if (!subConflict) {
+                    return;
+                }
+                return {
+                    description: `indexed value is invalid`,
+                    context: errorContext,
+                    causes: [subConflict],
+                };
+            }
+            return {
+                description: `indexed index type can not be understood`,
+                context: errorContext,
+            };
+        }
         // Check if the range refers to a generic type
         if (type.isA('ParameterRangeGenericTypeReference')) {
             return genericsContext.bindGenericTypeToValue(type.property.parameterRangeGenericType.value, value, (subValue, subType) => this.hasValueType(subValue, subType, errorContext, genericsContext), (subType, superType) => this.hasType(subType, superType, genericsContext, undefined, [], errorContext));
@@ -467,6 +500,13 @@ class ParameterPropertyHandlerRange {
             return `(${ParameterPropertyHandlerRange.rangeToDisplayString(paramRange.property.component, genericsContext)})<${paramRange.properties.genericTypeInstances
                 .map(genericTypeInstance => ParameterPropertyHandlerRange.rangeToDisplayString(genericTypeInstance, genericsContext)).join(', ')}>`;
         }
+        if (paramRange.isA('ParameterRangeIndexed')) {
+            const object = ParameterPropertyHandlerRange
+                .rangeToDisplayString(paramRange.property.parameterRangeIndexedObject, genericsContext);
+            const index = ParameterPropertyHandlerRange
+                .rangeToDisplayString(paramRange.property.parameterRangeIndexedIndex, genericsContext);
+            return `${object}[${index}]`;
+        }
         return paramRange.value;
     }
 }

package/package.json

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