componentsjs 5.4.2 → 5.5.1

package/components/context.json

@@ -80,12 +80,46 @@
     "Override": {
       "@id": "oo:Override"
     },
+    "OverrideParameters": {
+      "@id": "oo:OverrideParameters"
+    },
+    "OverrideMapEntry": {
+      "@id": "oo:OverrideMapEntry"
+    },
+    "OverrideListInsertBefore": {
+      "@id": "oo:OverrideListInsertBefore"
+    },
+    "OverrideListInsertAfter": {
+      "@id": "oo:OverrideListInsertAfter"
+    },
+    "OverrideListInsertAt": {
+      "@id": "oo:OverrideListInsertAt"
+    },
+    "OverrideListRemove": {
+      "@id": "oo:OverrideListRemove"
+    },
     "overrideInstance": {
       "@id": "oo:overrideInstance"
     },
     "overrideParameters": {
       "@id": "oo:overrideParameters"
     },
+    "overrideSteps": {
+      "@id": "oo:overrideSteps",
+      "@container": "@list"
+    },
+    "overrideParameter": {
+      "@id": "oo:overrideParameter",
+      "@container": "@list"
+    },
+    "overrideTarget": {
+      "@id": "oo:overrideTarget",
+      "@container": "@list"
+    },
+    "overrideValue": {
+      "@id": "oo:overrideValue",
+      "@container": "@list"
+    },
     "ParameterRange": {
       "@id": "oo:ParameterRange"
     },

package/components/context.jsonld

@@ -80,12 +80,46 @@
     "Override": {
       "@id": "oo:Override"
     },
+    "OverrideParameters": {
+      "@id": "oo:OverrideParameters"
+    },
+    "OverrideMapEntry": {
+      "@id": "oo:OverrideMapEntry"
+    },
+    "OverrideListInsertBefore": {
+      "@id": "oo:OverrideListInsertBefore"
+    },
+    "OverrideListInsertAfter": {
+      "@id": "oo:OverrideListInsertAfter"
+    },
+    "OverrideListInsertAt": {
+      "@id": "oo:OverrideListInsertAt"
+    },
+    "OverrideListRemove": {
+      "@id": "oo:OverrideListRemove"
+    },
     "overrideInstance": {
       "@id": "oo:overrideInstance"
     },
     "overrideParameters": {
       "@id": "oo:overrideParameters"
     },
+    "overrideSteps": {
+      "@id": "oo:overrideSteps",
+      "@container": "@list"
+    },
+    "overrideParameter": {
+      "@id": "oo:overrideParameter",
+      "@container": "@list"
+    },
+    "overrideTarget": {
+      "@id": "oo:overrideTarget",
+      "@container": "@list"
+    },
+    "overrideValue": {
+      "@id": "oo:overrideValue",
+      "@container": "@list"
+    },
     "ParameterRange": {
       "@id": "oo:ParameterRange"
     },

package/lib/preprocess/ConfigPreprocessorOverride.d.ts

@@ -7,25 +7,26 @@ import type { IConfigPreprocessor, IConfigPreprocessorTransform } from './IConfi
  * Values in the given {@link Resource}s will be replaced if any overriding object is found,
  * targeting this resource.
  */
-export declare class ConfigPreprocessorOverride implements IConfigPreprocessor<Record<string, Resource>> {
+export declare class ConfigPreprocessorOverride implements IConfigPreprocessor<Resource[]> {
     readonly objectLoader: RdfObjectLoader;
     readonly componentResources: Record<string, Resource>;
     readonly logger: Logger;
+    private readonly stepHandlers;
     private overrides;
     constructor(options: IComponentConfigPreprocessorOverrideOptions);
     /**
      * Checks if there are any overrides targeting the given resource.
      * @param config - Resource to find overrides for.
      *
-     * @returns A key/value object with keys being the properties that have an override.
+     * @returns A list of override steps to apply to the target, in order.
      */
-    canHandle(config: Resource): Record<string, Resource> | undefined;
+    canHandle(config: Resource): Resource[] | undefined;
     /**
-     * Override the resource with the stored values.
+     * Override the resource with the stored override steps.
      * @param config - The resource to override.
-     * @param handleResponse - Override values that were found for this resource.
+     * @param handleResponse - Override steps that were found for this resource.
      */
-    transform(config: Resource, handleResponse: Record<string, Resource>): IConfigPreprocessorTransform;
+    transform(config: Resource, handleResponse: Resource[]): IConfigPreprocessorTransform;
     /**
      * Clear all cached overrides, so they will be calculated again on the next call.
      */
@@ -35,7 +36,7 @@ export declare class ConfigPreprocessorOverride implements IConfigPreprocessor<R
      * Keys of the object are the identifiers of the resources that need to be modified,
      * values are key/value maps listing all parameters with their new values.
      */
-    createOverrideObjects(): Record<string, Record<string, Resource>>;
+    createOverrideSteps(): Record<string, Resource[]>;
     /**
      * Finds all Override resources in the object loader and links them to their target resource.
      */
@@ -47,6 +48,7 @@ export declare class ConfigPreprocessorOverride implements IConfigPreprocessor<R
      * Chains all Overrides together if they reference each other.
      * E.g., if the input is a list of Overrides A -> B, B -> C, D -> E,
      * the result wil be [[ A, B, C ], [ D, E ]].
+     * The last element in the array will always be the non-Override resource being targeted.
      *
      * @param overrides - All Overrides that have to be combined.
      */
@@ -60,14 +62,15 @@ export declare class ConfigPreprocessorOverride implements IConfigPreprocessor<R
      */
     protected validateChains(chains: Resource[][]): void;
     /**
-     * Merges all Overrides in a chain to create a single override object
-     * containing replacement values for all relevant parameters of the final entry in the chain.
+     * Merges all Overrides in a chain to create a single list of override steps.
+     * The order of the steps is the order in which they should be applied,
+     * with the first entry being the first step of the override closest to the target resource.
      *
      * @param chain - The chain of Overrides, with a normal resource as the last entry in the array.
      */
-    protected chainToOverrideObject(chain: Resource[]): {
-        target: string;
-        values: Record<string, Resource>;
+    protected chainToOverrideSteps(chain: Resource[]): {
+        target: Resource;
+        steps: Resource[];
     };
     /**
      * Finds the final target and validates its type value.
@@ -75,11 +78,11 @@ export declare class ConfigPreprocessorOverride implements IConfigPreprocessor<R
      */
     protected getChainTarget(chain: Resource[]): Resource;
     /**
-     * Extracts all parameters of an Override with their corresponding value.
-     * @param override - The Override to apply.
-     * @param target - The target resource to apply the Override to. Only used for error messages.
+     *
+     * @param override
+     * @protected
      */
-    protected extractOverrideParameters(override: Resource, target: Resource): Record<string, Resource>;
+    protected simplifiedOverrideToStep(override: Resource): Resource;
 }
 export interface IComponentConfigPreprocessorOverrideOptions {
     objectLoader: RdfObjectLoader;

package/lib/preprocess/ConfigPreprocessorOverride.js

@@ -4,6 +4,12 @@ exports.ConfigPreprocessorOverride = void 0;
 const Iris_1 = require("../rdf/Iris");
 const ResourceUtil_1 = require("../rdf/ResourceUtil");
 const ErrorResourcesContext_1 = require("../util/ErrorResourcesContext");
+const OverrideListInsertAfter_1 = require("./overridesteps/OverrideListInsertAfter");
+const OverrideListInsertAt_1 = require("./overridesteps/OverrideListInsertAt");
+const OverrideListInsertBefore_1 = require("./overridesteps/OverrideListInsertBefore");
+const OverrideListRemove_1 = require("./overridesteps/OverrideListRemove");
+const OverrideMapEntry_1 = require("./overridesteps/OverrideMapEntry");
+const OverrideParameters_1 = require("./overridesteps/OverrideParameters");
 /**
  * An {@link IConfigPreprocessor} that handles the overriding of parameters.
  * Values in the given {@link Resource}s will be replaced if any overriding object is found,
@@ -14,37 +20,48 @@ class ConfigPreprocessorOverride {
         this.objectLoader = options.objectLoader;
         this.componentResources = options.componentResources;
         this.logger = options.logger;
+        this.stepHandlers = [
+            new OverrideParameters_1.OverrideParameters(),
+            new OverrideListInsertBefore_1.OverrideListInsertBefore(),
+            new OverrideListInsertAfter_1.OverrideListInsertAfter(),
+            new OverrideListInsertAt_1.OverrideListInsertAt(),
+            new OverrideListRemove_1.OverrideListRemove(),
+            new OverrideMapEntry_1.OverrideMapEntry(),
+        ];
     }
     /**
      * Checks if there are any overrides targeting the given resource.
      * @param config - Resource to find overrides for.
      *
-     * @returns A key/value object with keys being the properties that have an override.
+     * @returns A list of override steps to apply to the target, in order.
      */
     canHandle(config) {
         if (!this.overrides) {
-            this.overrides = this.createOverrideObjects();
+            this.overrides = this.createOverrideSteps();
         }
         return this.overrides[config.value];
     }
     /**
-     * Override the resource with the stored values.
+     * Override the resource with the stored override steps.
      * @param config - The resource to override.
-     * @param handleResponse - Override values that were found for this resource.
+     * @param handleResponse - Override steps that were found for this resource.
      */
     transform(config, handleResponse) {
-        var _a;
-        // We know this has exactly 1 result due to the canHandle call
-        const configType = (0, ResourceUtil_1.uniqueTypes)(config, this.componentResources)[0];
-        const overrideType = (_a = handleResponse[Iris_1.IRIS_RDF.type]) === null || _a === void 0 ? void 0 : _a.value;
-        // In case the type changes we have to delete all the original properties as those correspond to the old type
-        if (overrideType && configType.value !== overrideType) {
-            for (const id of Object.keys(config.properties)) {
-                delete config.properties[id];
+        // Apply all override steps sequentially
+        for (const step of handleResponse) {
+            let handler;
+            for (const stepHandler of this.stepHandlers) {
+                if (stepHandler.canHandle(config, step)) {
+                    handler = stepHandler;
+                    break;
+                }
             }
-        }
-        for (const property of Object.keys(handleResponse)) {
-            config.properties[property] = [handleResponse[property]];
+            if (!handler) {
+                throw new ErrorResourcesContext_1.ErrorResourcesContext(`Found no handler supporting an override step of type ${step.property.type.value}`, {
+                    step,
+                });
+            }
+            handler.handle(config, step);
         }
         return { rawConfig: config, finishTransformation: false };
     }
@@ -59,18 +76,18 @@ class ConfigPreprocessorOverride {
      * Keys of the object are the identifiers of the resources that need to be modified,
      * values are key/value maps listing all parameters with their new values.
      */
-    createOverrideObjects() {
+    createOverrideSteps() {
         const overrides = [...this.findOverrideTargets()];
         const chains = this.createOverrideChains(overrides);
         this.validateChains(chains);
-        const overrideObjects = {};
+        const overrideSteps = {};
         for (const chain of chains) {
-            const { target, values } = this.chainToOverrideObject(chain);
-            if (Object.keys(values).length > 0) {
-                overrideObjects[target] = values;
+            const { target, steps } = this.chainToOverrideSteps(chain);
+            if (Object.keys(steps).length > 0) {
+                overrideSteps[target.value] = steps;
             }
         }
-        return overrideObjects;
+        return overrideSteps;
     }
     /**
      * Finds all Override resources in the object loader and links them to their target resource.
@@ -96,6 +113,7 @@ class ConfigPreprocessorOverride {
      * Chains all Overrides together if they reference each other.
      * E.g., if the input is a list of Overrides A -> B, B -> C, D -> E,
      * the result wil be [[ A, B, C ], [ D, E ]].
+     * The last element in the array will always be the non-Override resource being targeted.
      *
      * @param overrides - All Overrides that have to be combined.
      */
@@ -148,31 +166,35 @@ class ConfigPreprocessorOverride {
         }
     }
     /**
-     * Merges all Overrides in a chain to create a single override object
-     * containing replacement values for all relevant parameters of the final entry in the chain.
+     * Merges all Overrides in a chain to create a single list of override steps.
+     * The order of the steps is the order in which they should be applied,
+     * with the first entry being the first step of the override closest to the target resource.
      *
      * @param chain - The chain of Overrides, with a normal resource as the last entry in the array.
      */
-    chainToOverrideObject(chain) {
+    chainToOverrideSteps(chain) {
         var _a, _b;
         const target = this.getChainTarget(chain);
-        // Apply all overrides sequentially, starting from the one closest to the target.
-        // This ensures the most recent override has priority.
-        let mergedOverride = {};
+        const steps = [];
         for (let i = chain.length - 2; i >= 0; --i) {
-            const validatedObject = this.extractOverrideParameters(chain[i], target);
-            // In case an Override has a different type, the properties of the target don't matter any more,
-            // as the object is being replaced completely.
-            const mergedType = (_a = mergedOverride[Iris_1.IRIS_RDF.type]) === null || _a === void 0 ? void 0 : _a.value;
-            const overrideType = (_b = validatedObject[Iris_1.IRIS_RDF.type]) === null || _b === void 0 ? void 0 : _b.value;
-            if (overrideType && overrideType !== mergedType) {
-                mergedOverride = validatedObject;
+            const subStepProperties = chain[i].properties[Iris_1.IRIS_OO.overrideSteps];
+            if (subStepProperties.length > 1) {
+                throw new ErrorResourcesContext_1.ErrorResourcesContext(`Detected multiple values for overrideSteps in Override ${chain[i].value}. RDF lists should be used for defining multiple values.`, {
+                    override: chain[i],
+                });
+            }
+            let subSteps = (_b = (_a = subStepProperties[0]) === null || _a === void 0 ? void 0 : _a.list) !== null && _b !== void 0 ? _b : subStepProperties;
+            // Translate simplified format to override step
+            if (chain[i].properties[Iris_1.IRIS_OO.overrideParameters].length > 0) {
+                subSteps = [this.simplifiedOverrideToStep(chain[i])];
             }
-            else {
-                Object.assign(mergedOverride, validatedObject);
+            if (subSteps.length === 0) {
+                this.logger.warn(`No steps found for Override ${chain[i].value}. This Override will be ignored.`);
+                continue;
             }
+            steps.push(...subSteps);
         }
-        return { target: target.value, values: mergedOverride };
+        return { target, steps };
     }
     /**
      * Finds the final target and validates its type value.
@@ -196,36 +218,21 @@ class ConfigPreprocessorOverride {
         return target;
     }
     /**
-     * Extracts all parameters of an Override with their corresponding value.
-     * @param override - The Override to apply.
-     * @param target - The target resource to apply the Override to. Only used for error messages.
+     *
+     * @param override
+     * @protected
      */
-    extractOverrideParameters(override, target) {
+    simplifiedOverrideToStep(override) {
         const overrideObjects = override.properties[Iris_1.IRIS_OO.overrideParameters];
-        if (!overrideObjects || overrideObjects.length === 0) {
-            this.logger.warn(`No overrideParameters found for ${override.value}.`);
-            return {};
-        }
         if (overrideObjects.length > 1) {
             throw new ErrorResourcesContext_1.ErrorResourcesContext(`Detected multiple values for overrideParameters in Override ${override.value}`, {
                 override,
             });
         }
-        const overrideObject = overrideObjects[0];
-        // Only keep the parameters that are known to the type of the target object
-        const validatedObject = {};
-        for (const parameter of Object.keys(overrideObject.properties)) {
-            const overrideValues = overrideObject.properties[parameter];
-            if (overrideValues.length > 1) {
-                throw new ErrorResourcesContext_1.ErrorResourcesContext(`Detected multiple values for override parameter ${parameter} in Override ${override.value}. RDF lists should be used for defining multiple values.`, {
-                    arguments: overrideValues,
-                    target,
-                    override,
-                });
-            }
-            validatedObject[parameter] = overrideValues[0];
-        }
-        return validatedObject;
+        return this.objectLoader.createCompactedResource({
+            types: (0, Iris_1.PREFIX_OO)('OverrideParameters'),
+            overrideValue: overrideObjects[0],
+        });
     }
 }
 exports.ConfigPreprocessorOverride = ConfigPreprocessorOverride;

package/lib/preprocess/overridesteps/IOverrideStep.d.ts

@@ -0,0 +1,24 @@
+import type { Resource } from 'rdf-object';
+/**
+ * Transforms a resource based on the contents of an override step.
+ */
+export interface IOverrideStep {
+    /**
+     * Determines if this handler can apply the given override step to the resource.
+     *
+     * @param config - The resource to override.
+     * @param step - The override step to apply.
+     *
+     * @returns true if this handler should be used.
+     */
+    canHandle: (config: Resource, step: Resource) => boolean;
+    /**
+     * Applies the changes described in the given override step to the resource.
+     *
+     * @param config - The resource to override.
+     * @param step - The override step to apply.
+     *
+     * @returns The modified resource.
+     */
+    handle: (config: Resource, step: Resource) => Resource;
+}

package/lib/preprocess/overridesteps/IOverrideStep.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=IOverrideStep.js.map

package/lib/preprocess/overridesteps/OverrideListInsertAfter.d.ts

@@ -0,0 +1,14 @@
+import type { Resource } from 'rdf-object';
+import type { IOverrideStep } from './IOverrideStep';
+/**
+ * Override step that inserts elements in a list after a specific element.
+ *
+ * Uses the following override step fields:
+ *  - `overrideParameter`: Parameter of the original object that contains the list.
+ *  - `overrideTarget`: Element already in the list that is used as reference. This can be a named node or a literal.
+ *  - `overrideValue`: Element(s) to insert immediately after the target element.
+ */
+export declare class OverrideListInsertAfter implements IOverrideStep {
+    canHandle(config: Resource, step: Resource): boolean;
+    handle(config: Resource, step: Resource): Resource;
+}

package/lib/preprocess/overridesteps/OverrideListInsertAfter.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OverrideListInsertAfter = void 0;
+const Iris_1 = require("../../rdf/Iris");
+const OverrideUtil_1 = require("./OverrideUtil");
+/**
+ * Override step that inserts elements in a list after a specific element.
+ *
+ * Uses the following override step fields:
+ *  - `overrideParameter`: Parameter of the original object that contains the list.
+ *  - `overrideTarget`: Element already in the list that is used as reference. This can be a named node or a literal.
+ *  - `overrideValue`: Element(s) to insert immediately after the target element.
+ */
+class OverrideListInsertAfter {
+    canHandle(config, step) {
+        return step.property.type.value === (0, Iris_1.PREFIX_OO)('OverrideListInsertAfter');
+    }
+    handle(config, step) {
+        const { parameters, targets, values } = (0, OverrideUtil_1.extractOverrideStepFields)(step, { parameters: 1, targets: 1 });
+        const list = (0, OverrideUtil_1.getPropertyResourceList)(config, parameters[0]);
+        const index = (0, OverrideUtil_1.findResourceIndex)(list, targets[0]);
+        // +1 so we start after the selected element
+        list.splice(index + 1, 0, ...values);
+        return config;
+    }
+}
+exports.OverrideListInsertAfter = OverrideListInsertAfter;
+//# sourceMappingURL=OverrideListInsertAfter.js.map

package/lib/preprocess/overridesteps/OverrideListInsertAt.d.ts

@@ -0,0 +1,16 @@
+import type { Resource } from 'rdf-object';
+import type { IOverrideStep } from './IOverrideStep';
+/**
+ * Override step that inserts elements in a list at a specific index.
+ * A negative index can be used to count from the back of the list.
+ * An index of `-0` can be used to insert at the end of the list.
+ *
+ * Uses the following override step fields:
+ *  - `overrideParameter`: Parameter of the original object that contains the list.
+ *  - `overrideTarget`: A literal containing the index.
+ *  - `overrideValue`: Element(s) to insert at the chosen index.
+ */
+export declare class OverrideListInsertAt implements IOverrideStep {
+    canHandle(config: Resource, step: Resource): boolean;
+    handle(config: Resource, step: Resource): Resource;
+}

package/lib/preprocess/overridesteps/OverrideListInsertAt.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OverrideListInsertAt = void 0;
+const Iris_1 = require("../../rdf/Iris");
+const ErrorResourcesContext_1 = require("../../util/ErrorResourcesContext");
+const OverrideUtil_1 = require("./OverrideUtil");
+/**
+ * Override step that inserts elements in a list at a specific index.
+ * A negative index can be used to count from the back of the list.
+ * An index of `-0` can be used to insert at the end of the list.
+ *
+ * Uses the following override step fields:
+ *  - `overrideParameter`: Parameter of the original object that contains the list.
+ *  - `overrideTarget`: A literal containing the index.
+ *  - `overrideValue`: Element(s) to insert at the chosen index.
+ */
+class OverrideListInsertAt {
+    canHandle(config, step) {
+        return step.property.type.value === (0, Iris_1.PREFIX_OO)('OverrideListInsertAt');
+    }
+    handle(config, step) {
+        const { parameters, targets, values } = (0, OverrideUtil_1.extractOverrideStepFields)(step, { parameters: 1, targets: 1 });
+        const list = (0, OverrideUtil_1.getPropertyResourceList)(config, parameters[0]);
+        const val = targets[0].value;
+        if (!/^-?\d+$/u.test(val)) {
+            throw new ErrorResourcesContext_1.ErrorResourcesContext(`Invalid index in Override step OverrideListInsertAt for parameter ${parameters[0].value}: ${val}`, {
+                config,
+                step,
+            });
+        }
+        // Support adding elements at the end using -0
+        if (val === '-0') {
+            list.push(...values);
+        }
+        else {
+            const index = Number.parseInt(val, 10);
+            list.splice(index, 0, ...values);
+        }
+        return config;
+    }
+}
+exports.OverrideListInsertAt = OverrideListInsertAt;
+//# sourceMappingURL=OverrideListInsertAt.js.map

package/lib/preprocess/overridesteps/OverrideListInsertBefore.d.ts

@@ -0,0 +1,14 @@
+import type { Resource } from 'rdf-object';
+import type { IOverrideStep } from './IOverrideStep';
+/**
+ * Override step that inserts elements in a list before a specific element.
+ *
+ * Uses the following override step fields:
+ *  - `overrideParameter`: Parameter of the original object that contains the list.
+ *  - `overrideTarget`: Element already in the list that is used as reference. This can be a named node or a literal.
+ *  - `overrideValue`: Element(s) to insert immediately before the target element.
+ */
+export declare class OverrideListInsertBefore implements IOverrideStep {
+    canHandle(config: Resource, step: Resource): boolean;
+    handle(config: Resource, step: Resource): Resource;
+}

package/lib/preprocess/overridesteps/OverrideListInsertBefore.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OverrideListInsertBefore = void 0;
+const Iris_1 = require("../../rdf/Iris");
+const OverrideUtil_1 = require("./OverrideUtil");
+/**
+ * Override step that inserts elements in a list before a specific element.
+ *
+ * Uses the following override step fields:
+ *  - `overrideParameter`: Parameter of the original object that contains the list.
+ *  - `overrideTarget`: Element already in the list that is used as reference. This can be a named node or a literal.
+ *  - `overrideValue`: Element(s) to insert immediately before the target element.
+ */
+class OverrideListInsertBefore {
+    canHandle(config, step) {
+        return step.property.type.value === (0, Iris_1.PREFIX_OO)('OverrideListInsertBefore');
+    }
+    handle(config, step) {
+        const { parameters, targets, values } = (0, OverrideUtil_1.extractOverrideStepFields)(step, { parameters: 1, targets: 1 });
+        const list = (0, OverrideUtil_1.getPropertyResourceList)(config, parameters[0]);
+        const index = (0, OverrideUtil_1.findResourceIndex)(list, targets[0]);
+        list.splice(index, 0, ...values);
+        return config;
+    }
+}
+exports.OverrideListInsertBefore = OverrideListInsertBefore;
+//# sourceMappingURL=OverrideListInsertBefore.js.map

package/lib/preprocess/overridesteps/OverrideListRemove.d.ts

@@ -0,0 +1,13 @@
+import type { Resource } from 'rdf-object';
+import type { IOverrideStep } from './IOverrideStep';
+/**
+ * Override step that removes specified elements.
+ *
+ * Uses the following override step fields:
+ *  - `overrideParameter`: Parameter of the original object that contains the list.
+ *  - `overrideTarget`: Element(s) already in the list that need to be removed. These can be named nodes or literals.
+ */
+export declare class OverrideListRemove implements IOverrideStep {
+    canHandle(config: Resource, step: Resource): boolean;
+    handle(config: Resource, step: Resource): Resource;
+}

package/lib/preprocess/overridesteps/OverrideListRemove.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OverrideListRemove = void 0;
+const Iris_1 = require("../../rdf/Iris");
+const OverrideUtil_1 = require("./OverrideUtil");
+/**
+ * Override step that removes specified elements.
+ *
+ * Uses the following override step fields:
+ *  - `overrideParameter`: Parameter of the original object that contains the list.
+ *  - `overrideTarget`: Element(s) already in the list that need to be removed. These can be named nodes or literals.
+ */
+class OverrideListRemove {
+    canHandle(config, step) {
+        return step.property.type.value === (0, Iris_1.PREFIX_OO)('OverrideListRemove');
+    }
+    handle(config, step) {
+        const { parameters, targets, values } = (0, OverrideUtil_1.extractOverrideStepFields)(step, { parameters: 1, values: 0 });
+        const list = (0, OverrideUtil_1.getPropertyResourceList)(config, parameters[0]);
+        const indexes = [];
+        for (const element of targets) {
+            indexes.push((0, OverrideUtil_1.findResourceIndex)(list, element));
+        }
+        // Highest number first so indexes remain correct while sorting
+        indexes.sort((left, right) => right - left);
+        for (const index of indexes) {
+            list.splice(index, 1);
+        }
+        return config;
+    }
+}
+exports.OverrideListRemove = OverrideListRemove;
+//# sourceMappingURL=OverrideListRemove.js.map

package/lib/preprocess/overridesteps/OverrideMapEntry.d.ts

@@ -0,0 +1,35 @@
+import type { Resource } from 'rdf-object';
+import type { IOverrideStep } from './IOverrideStep';
+/**
+ * Override step that updates an entry in a key/value map.
+ *
+ * Uses the following override step fields:
+ *  - `overrideParameter`: Parameter of the original object that contains the key/value map.
+ *  - `overrideTarget`: The key that needs to be updated.
+ *  - `overrideValue`: The new value for the key. In case this is not defined, the key will be deleted instead.
+ */
+export declare class OverrideMapEntry implements IOverrideStep {
+    canHandle(config: Resource, step: Resource): boolean;
+    handle(config: Resource, step: Resource): Resource;
+    /**
+     * Finds the URIs used to link to the key and value of a map entry.
+     *
+     * @param type - Type of the class that contains the key/value map.
+     * @param parameter - Parameter of the class used to link to the key/value map.
+     */
+    protected findProperties(type: Resource, parameter: Resource): {
+        key: Resource;
+        value: Resource;
+    };
+    /**
+     * Finds the index in a list of key/value map entries of the entry with the matching key.
+     *
+     * @param entries - List of key/value map entries.
+     * @param key - Key of the entry to find.
+     * @param properties - URIs used to link the key and value of a map entry.
+     */
+    protected findEntryIndex(entries: Resource[], key: Resource, properties: {
+        key: Resource;
+        value: Resource;
+    }): number;
+}

package/lib/preprocess/overridesteps/OverrideMapEntry.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OverrideMapEntry = void 0;
+const Iris_1 = require("../../rdf/Iris");
+const ErrorResourcesContext_1 = require("../../util/ErrorResourcesContext");
+const OverrideUtil_1 = require("./OverrideUtil");
+/**
+ * Override step that updates an entry in a key/value map.
+ *
+ * Uses the following override step fields:
+ *  - `overrideParameter`: Parameter of the original object that contains the key/value map.
+ *  - `overrideTarget`: The key that needs to be updated.
+ *  - `overrideValue`: The new value for the key. In case this is not defined, the key will be deleted instead.
+ */
+class OverrideMapEntry {
+    canHandle(config, step) {
+        return step.property.type.value === (0, Iris_1.PREFIX_OO)('OverrideMapEntry');
+    }
+    handle(config, step) {
+        const { parameters, targets, values } = (0, OverrideUtil_1.extractOverrideStepFields)(step, { parameters: 1, targets: 1 });
+        const properties = this.findProperties(config.property.type, parameters[0]);
+        const entries = (0, OverrideUtil_1.getPropertyResourceList)(config, parameters[0]);
+        const index = this.findEntryIndex(entries, targets[0], properties);
+        if (values.length === 0) {
+            // Remove the entry
+            entries.splice(index, 1);
+        }
+        else {
+            // Replace the value of the entry
+            entries[index].properties[properties.value.value] = values;
+        }
+        return config;
+    }
+    /**
+     * Finds the URIs used to link to the key and value of a map entry.
+     *
+     * @param type - Type of the class that contains the key/value map.
+     * @param parameter - Parameter of the class used to link to the key/value map.
+     */
+    findProperties(type, parameter) {
+        var _a, _b;
+        const constructArgs = (_a = type.property.constructorArguments.list) !== null && _a !== void 0 ? _a : [];
+        for (const arg of constructArgs) {
+            const fields = (_b = arg.property.fields.list) !== null && _b !== void 0 ? _b : [];
+            for (const field of fields) {
+                let collectEntries = field.property.collectEntries;
+                // Not sure when this is not a list in practice.
+                // Based on behaviour in `ConstructorArgumentsElementMappingHandlerCollectEntries`.
+                if (collectEntries.list) {
+                    collectEntries = collectEntries.list[0];
+                }
+                if (collectEntries.term.equals(parameter.term)) {
+                    return { key: field.property.key, value: field.property.value };
+                }
+            }
+        }
+        throw new ErrorResourcesContext_1.ErrorResourcesContext(`Unable to find key/value URIs for parameter ${parameter.value}`, {
+            type,
+            parameter,
+        });
+    }
+    /**
+     * Finds the index in a list of key/value map entries of the entry with the matching key.
+     *
+     * @param entries - List of key/value map entries.
+     * @param key - Key of the entry to find.
+     * @param properties - URIs used to link the key and value of a map entry.
+     */
+    findEntryIndex(entries, key, properties) {
+        for (const [i, entry] of entries.entries()) {
+            if (key.term.equals(entry.property[properties.key.value].term)) {
+                return i;
+            }
+        }
+        throw new ErrorResourcesContext_1.ErrorResourcesContext(`Unable to find key/value entry with key ${key.value}`, {
+            entries,
+            key,
+            properties,
+        });
+    }
+}
+exports.OverrideMapEntry = OverrideMapEntry;
+//# sourceMappingURL=OverrideMapEntry.js.map

package/lib/preprocess/overridesteps/OverrideParameters.d.ts

@@ -0,0 +1,15 @@
+import type { Resource } from 'rdf-object';
+import type { IOverrideStep } from './IOverrideStep';
+/**
+ * Override step that replaces properties of the target object.
+ * Only the specified parameters will be replaced,
+ * others will keep their original value.
+ * In case the type is changed all original values will be removed.
+ *
+ * Uses the following override step fields:
+ *  - `overrideValue`: New properties for the object.
+ */
+export declare class OverrideParameters implements IOverrideStep {
+    canHandle(config: Resource, step: Resource): boolean;
+    handle(config: Resource, step: Resource): Resource;
+}

package/lib/preprocess/overridesteps/OverrideParameters.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OverrideParameters = void 0;
+const Iris_1 = require("../../rdf/Iris");
+const OverrideUtil_1 = require("./OverrideUtil");
+/**
+ * Override step that replaces properties of the target object.
+ * Only the specified parameters will be replaced,
+ * others will keep their original value.
+ * In case the type is changed all original values will be removed.
+ *
+ * Uses the following override step fields:
+ *  - `overrideValue`: New properties for the object.
+ */
+class OverrideParameters {
+    canHandle(config, step) {
+        return step.property.type.value === (0, Iris_1.PREFIX_OO)('OverrideParameters');
+    }
+    handle(config, step) {
+        var _a;
+        const { values } = (0, OverrideUtil_1.extractOverrideStepFields)(step, { parameters: 0, targets: 0, values: 1 });
+        const partialResource = values[0];
+        // In case the step has a different type, the properties of the previous step don't matter any more,
+        // as the object is being replaced completely.
+        const originalType = config.property.type.term;
+        const newType = (_a = partialResource.property.type) === null || _a === void 0 ? void 0 : _a.term;
+        // In case the type changes we have to delete all the original properties as those correspond to the old type
+        if (newType && !newType.equals(originalType)) {
+            for (const id of Object.keys(config.properties)) {
+                delete config.properties[id];
+            }
+        }
+        for (const property of Object.keys(partialResource.properties)) {
+            config.properties[property] = partialResource.properties[property];
+        }
+        return config;
+    }
+}
+exports.OverrideParameters = OverrideParameters;
+//# sourceMappingURL=OverrideParameters.js.map

package/lib/preprocess/overridesteps/OverrideUtil.d.ts

@@ -0,0 +1,31 @@
+import type { Resource } from 'rdf-object';
+export declare const OVERRIDE_STEP_FIELD_NAMES: readonly ["parameter", "target", "value"];
+export type OverrideStepFieldName = `${typeof OVERRIDE_STEP_FIELD_NAMES[number]}s`;
+/**
+ * Extracts the fields from an override step and checks if the correct amount is present.
+ * Will throw an error if the amount doesn't match what is expected.
+ *
+ * @param step - Override step to get the fields from.
+ * @param expected - For each field, how many are expected. The value can be undefined if there is no fixed amount.
+ */
+export declare function extractOverrideStepFields(step: Resource, expected?: {
+    [key in OverrideStepFieldName]?: number;
+}): Record<OverrideStepFieldName, Resource[]>;
+/**
+ * Returns a list containing all values for the given resource found with the given property.
+ * In case there are multiple matches, the lists will be merged.
+ * The parameter of the resource will be updated to have a single value which is the returned list,
+ * so the returned list can be updated to modify the resource directly.
+ *
+ * @param config
+ * @param parameter
+ */
+export declare function getPropertyResourceList(config: Resource, parameter: Resource): Resource[];
+/**
+ * Finds the index of the given resource in the given list.
+ * Will throw an error if the resource is not found.
+ *
+ * @param list - The list to find the resource in.
+ * @param target - The resource to find.
+ */
+export declare function findResourceIndex(list: Resource[], target: Resource): number;

package/lib/preprocess/overridesteps/OverrideUtil.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findResourceIndex = exports.getPropertyResourceList = exports.extractOverrideStepFields = exports.OVERRIDE_STEP_FIELD_NAMES = void 0;
+const Iris_1 = require("../../rdf/Iris");
+const ErrorResourcesContext_1 = require("../../util/ErrorResourcesContext");
+exports.OVERRIDE_STEP_FIELD_NAMES = ['parameter', 'target', 'value'];
+/**
+ * Extracts the fields from an override step and checks if the correct amount is present.
+ * Will throw an error if the amount doesn't match what is expected.
+ *
+ * @param step - Override step to get the fields from.
+ * @param expected - For each field, how many are expected. The value can be undefined if there is no fixed amount.
+ */
+function extractOverrideStepFields(step, expected = {}) {
+    var _a, _b;
+    // Type is not correct yet now but will be completed in the loop below
+    const result = {};
+    for (const key of exports.OVERRIDE_STEP_FIELD_NAMES) {
+        const overrideKey = `override${key[0].toUpperCase()}${key.slice(1)}`;
+        const propertiesKey = `${key}s`;
+        const properties = step.properties[(0, Iris_1.PREFIX_OO)(overrideKey)];
+        if (properties.length > 1) {
+            throw new ErrorResourcesContext_1.ErrorResourcesContext(`Detected multiple values for ${overrideKey} in Override step ${step.value}. RDF lists should be used for defining multiple values.`, {
+                overrideStep: step,
+            });
+        }
+        const list = (_b = (_a = properties[0]) === null || _a === void 0 ? void 0 : _a.list) !== null && _b !== void 0 ? _b : properties;
+        if (typeof expected[propertiesKey] === 'number' && list.length !== expected[propertiesKey]) {
+            throw new ErrorResourcesContext_1.ErrorResourcesContext(`Expected ${expected[propertiesKey]} entries for ${overrideKey} but found ${list.length} in Override step ${step.value}`, {
+                overrideStep: step,
+            });
+        }
+        result[propertiesKey] = list;
+    }
+    return result;
+}
+exports.extractOverrideStepFields = extractOverrideStepFields;
+/**
+ * Returns a list containing all values for the given resource found with the given property.
+ * In case there are multiple matches, the lists will be merged.
+ * The parameter of the resource will be updated to have a single value which is the returned list,
+ * so the returned list can be updated to modify the resource directly.
+ *
+ * @param config
+ * @param parameter
+ */
+function getPropertyResourceList(config, parameter) {
+    const properties = config.properties[parameter.value];
+    if (!properties || properties.length === 0) {
+        return [];
+    }
+    // Having multiple lists can happen if multiple config files add elements to the same list
+    const list = properties.flatMap(prop => prop.list);
+    if (list.some(res => res === undefined)) {
+        throw new ErrorResourcesContext_1.ErrorResourcesContext(`Invalid target in Override step targeting ${config.value}: ${parameter.value} does not reference a list`, {
+            config,
+        });
+    }
+    config.properties[parameter.value] = [properties[0]];
+    properties[0].list = list;
+    return properties[0].list;
+}
+exports.getPropertyResourceList = getPropertyResourceList;
+/**
+ * Finds the index of the given resource in the given list.
+ * Will throw an error if the resource is not found.
+ *
+ * @param list - The list to find the resource in.
+ * @param target - The resource to find.
+ */
+function findResourceIndex(list, target) {
+    const index = list.findIndex((element) => element.term.equals(target.term));
+    if (index < 0) {
+        throw new ErrorResourcesContext_1.ErrorResourcesContext(`Unable to find ${target.value} in targeted list while overriding.`, {
+            target,
+            list,
+        });
+    }
+    return index;
+}
+exports.findResourceIndex = findResourceIndex;
+//# sourceMappingURL=OverrideUtil.js.map

package/lib/rdf/Iris.d.ts

@@ -9,6 +9,7 @@ export declare const IRIS_OO: {
     Override: string;
     overrideInstance: string;
     overrideParameters: string;
+    overrideSteps: string;
     parameter: string;
 };
 export declare const PREFIX_OM: (suffix: string) => string;

package/lib/rdf/Iris.js

@@ -13,6 +13,7 @@ exports.IRIS_OO = {
     Override: (0, exports.PREFIX_OO)('Override'),
     overrideInstance: (0, exports.PREFIX_OO)('overrideInstance'),
     overrideParameters: (0, exports.PREFIX_OO)('overrideParameters'),
+    overrideSteps: (0, exports.PREFIX_OO)('overrideSteps'),
     parameter: (0, exports.PREFIX_OO)('parameter'),
 };
 exports.PREFIX_OM = definePrefix('https://linkedsoftwaredependencies.org/vocabularies/object-mapping#');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "componentsjs",
-  "version": "5.4.2",
+  "version": "5.5.1",
   "description": "A semantic dependency injection framework",
   "lsd:contexts": {
     "https://linkedsoftwaredependencies.org/bundles/npm/componentsjs/^5.0.0/components/context.jsonld": "components/context.jsonld"
@@ -19,21 +19,19 @@
   ],
   "author": "Ruben Taelman <ruben.taelman@ugent.be>",
   "license": "MIT",
-  "engines": {
-    "node": ">=8.0"
-  },
+  "packageManager": "yarn@4.0.1",
   "scripts": {
-    "test": "npm run test:jest && npm run test:webpack",
-    "test:jest": "jest ${1}",
-    "test:webpack": "npm run test:webpack:node && npm run test:webpack:web",
+    "test": "yarn test:jest && yarn test:webpack",
+    "test:jest": "jest",
+    "test:webpack": "yarn test:webpack:node && yarn test:webpack:web",
     "test:webpack:node": "webpack -c test/webpack/webpack.config.js && node test/webpack/build/test.min.js",
     "test:webpack:web": "webpack -c test/webpack/webpack.config-web.js && node test/webpack/build-web/test.min.js",
-    "test-watch": "jest ${1} --watch",
+    "test-watch": "jest --watch",
     "build": "scopy ./components/context.jsonld ./components/context.json && tsc && chmod +x ./bin/compile-config.js",
     "build-watch": "tsc --watch",
     "lint": "eslint . --ext .ts --cache",
-    "validate": "npm ls",
-    "prepare": "npm run build",
+    "validate": "yarn info",
+    "prepare": "yarn build",
     "version": "manual-git-changelog onversion"
   },
   "dependencies": {
@@ -54,7 +52,7 @@
   },
   "devDependencies": {
     "@rubensworks/eslint-config": "^1.0.1",
-    "@types/jest": "^27.0.0",
+    "@types/jest": "^29.0.0",
     "@types/stream-to-array": "^2.3.0",
     "@types/streamify-string": "^1.0.0",
     "@typescript-eslint/eslint-plugin": "^5.0.0",
@@ -66,17 +64,18 @@
     "eslint-plugin-jest": "^26.0.0",
     "eslint-plugin-tsdoc": "^0.2.7",
     "eslint-plugin-unused-imports": "^2.0.0",
-    "jest": "^27.0.1",
-    "jest-rdf": "^1.7.0",
+    "jest": "^29.0.0",
+    "jest-mock": "^29.0.0",
+    "jest-rdf": "^1.8.0",
     "jshint": "^2.1.10",
     "manual-git-changelog": "^1.0.1",
     "n3": "^1.11.1",
-    "node-polyfill-webpack-plugin": "^2.0.1",
+    "node-polyfill-webpack-plugin": "^3.0.0",
     "pre-commit": "^1.2.2",
     "simple-copy": "^2.2.1",
     "stream-to-array": "^2.3.0",
     "streamify-string": "^1.0.1",
-    "ts-jest": "^27.0.1",
+    "ts-jest": "^29.1.0",
     "ts-loader": "^9.4.1",
     "typescript": "^5.0.0",
     "webpack": "^5.75.0",