componentsjs 4.3.0 → 5.0.0-beta.0

package/bin/compile-config.js

@@ -30,7 +30,7 @@ if (args.e) {
     exportVariableName = args.e;
 }
 const asFunction = !!args.f;
-__1.compileConfig(mainModulePath, configPath, configResourceUri, exportVariableName, asFunction)
+(0, __1.compileConfig)(mainModulePath, configPath, configResourceUri, exportVariableName, asFunction)
     .then((output) => process.stdout.write(`${output}\n`))
     .catch(error => {
     process.stderr.write(`${error.stack}\n`);

package/components/context.jsonld

@@ -61,6 +61,42 @@
     "undefined": {
       "@id": "oo:isUndefined"
     },
+    "ParameterRange": {
+      "@id": "oo:ParameterRange"
+    },
+    "ParameterRangeUndefined": {
+      "@id": "oo:ParameterRangeUndefined"
+    },
+    "ParameterRangeArray": {
+      "@id": "oo:ParameterRangeArray"
+    },
+    "ParameterRangeLiteral": {
+      "@id": "oo:ParameterRangeLiteral"
+    },
+    "parameterRangeValue": {
+      "@id": "oo:parameterRangeValue",
+      "@type": "@id"
+    },
+    "parameterRangeValueLiteral": {
+      "@id": "oo:parameterRangeValue"
+    },
+    "ParameterRangeUnion": {
+      "@id": "oo:ParameterRangeUnion"
+    },
+    "ParameterRangeIntersection": {
+      "@id": "oo:ParameterRangeIntersection"
+    },
+    "parameterRangeElements": {
+      "@id": "oo:parameterRangeElements",
+      "@type": "@id"
+    },
+    "ParameterRangeCollectEntries": {
+      "@id": "oo:ParameterRangeCollectEntries"
+    },
+    "parameterRangeCollectEntriesParameters": {
+      "@id": "oo:parameterRangeCollectEntriesParameters",
+      "@type": "@id"
+    },
 
     "rdfs": "http://www.w3.org/2000/01/rdf-schema#",
     "comment": {
@@ -116,7 +152,8 @@
     },
     "fields": {
       "@id": "om:field",
-      "@type": "om:ObjectMapEntry"
+      "@type": "om:ObjectMapEntry",
+      "@container": "@list"
     },
     "elements": {
       "@id": "om:elements",
@@ -125,7 +162,8 @@
     },
     "collectEntries": {
       "@id": "om:collectsEntriesFrom",
-      "@type": "@id"
+      "@type": "@id",
+      "@container": "@list"
     },
     "keyRaw": {
       "@id": "om:fieldName"

package/index.d.ts

@@ -1,5 +1,6 @@
 export * from './lib/construction/argument/ArgumentConstructorHandlerArray';
 export * from './lib/construction/argument/ArgumentConstructorHandlerHash';
+export * from './lib/construction/argument/ArgumentConstructorHandlerList';
 export * from './lib/construction/argument/ArgumentConstructorHandlerPrimitive';
 export * from './lib/construction/argument/ArgumentConstructorHandlerReference';
 export * from './lib/construction/argument/ArgumentConstructorHandlerUndefined';

package/index.js

@@ -12,6 +12,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./lib/construction/argument/ArgumentConstructorHandlerArray"), exports);
 __exportStar(require("./lib/construction/argument/ArgumentConstructorHandlerHash"), exports);
+__exportStar(require("./lib/construction/argument/ArgumentConstructorHandlerList"), exports);
 __exportStar(require("./lib/construction/argument/ArgumentConstructorHandlerPrimitive"), exports);
 __exportStar(require("./lib/construction/argument/ArgumentConstructorHandlerReference"), exports);
 __exportStar(require("./lib/construction/argument/ArgumentConstructorHandlerUndefined"), exports);

package/lib/construction/ConfigConstructor.js

@@ -4,6 +4,7 @@ exports.ConfigConstructor = void 0;
 const ErrorResourcesContext_1 = require("../util/ErrorResourcesContext");
 const ArgumentConstructorHandlerArray_1 = require("./argument/ArgumentConstructorHandlerArray");
 const ArgumentConstructorHandlerHash_1 = require("./argument/ArgumentConstructorHandlerHash");
+const ArgumentConstructorHandlerList_1 = require("./argument/ArgumentConstructorHandlerList");
 const ArgumentConstructorHandlerPrimitive_1 = require("./argument/ArgumentConstructorHandlerPrimitive");
 const ArgumentConstructorHandlerReference_1 = require("./argument/ArgumentConstructorHandlerReference");
 const ArgumentConstructorHandlerUndefined_1 = require("./argument/ArgumentConstructorHandlerUndefined");
@@ -30,13 +31,15 @@ class ConfigConstructor {
         this.moduleState = options.moduleState;
     }
     async getArgumentValues(values, settings) {
-        // Unwrap unique values out of the array
-        if (values.length > 0 && values[0].property.unique && values[0].property.unique.value === 'true') {
-            return this.getArgumentValue(values[0], settings);
+        if (values.length === 0) {
+            return this.constructionStrategy.createUndefined();
         }
-        // Otherwise, keep the array form
-        const elements = await Promise.all(values.map(element => this.getArgumentValue(element, settings)));
-        return this.constructionStrategy.createArray({ settings, elements });
+        if (values.length > 1) {
+            throw new ErrorResourcesContext_1.ErrorResourcesContext(`Detected multiple values for an argument. RDF lists should be used for defining multiple values.`, {
+                arguments: values,
+            });
+        }
+        return this.getArgumentValue(values[0], settings);
     }
     async getArgumentValue(value, settings) {
         // Check if this args resource can be handled by one of the built-in handlers.
@@ -90,6 +93,7 @@ ConfigConstructor.ARGS_HANDLERS = [
     new ArgumentConstructorHandlerUndefined_1.ArgumentConstructorHandlerUndefined(),
     new ArgumentConstructorHandlerHash_1.ArgumentConstructorHandlerHash(),
     new ArgumentConstructorHandlerArray_1.ArgumentConstructorHandlerArray(),
+    new ArgumentConstructorHandlerList_1.ArgumentConstructorHandlerList(),
     new ArgumentConstructorHandlerValue_1.ArgumentConstructorHandlerValue(),
     new ArgumentConstructorHandlerReference_1.ArgumentConstructorHandlerReference(),
     new ArgumentConstructorHandlerPrimitive_1.ArgumentConstructorHandlerPrimitive(),

package/lib/construction/argument/ArgumentConstructorHandlerHash.js

@@ -7,11 +7,12 @@ const ErrorResourcesContext_1 = require("../../util/ErrorResourcesContext");
  */
 class ArgumentConstructorHandlerHash {
     canHandle(value, settings, argsCreator) {
-        return Boolean(value.property.fields || value.property.hasFields);
+        return Boolean(value.property.fields);
     }
     async handle(argument, settings, argsCreator) {
+        const fields = argument.property.fields.list || [];
         // Determine all key-value pairs
-        const entries = await Promise.all(argument.properties.fields.map(async (entry) => {
+        const entries = await Promise.all(fields.map(async (entry) => {
             // Validate entry
             if (!entry.property.key) {
                 throw new ErrorResourcesContext_1.ErrorResourcesContext(`Missing key in fields entry`, { entry, argument });

package/lib/construction/argument/ArgumentConstructorHandlerList.d.ts

@@ -0,0 +1,11 @@
+import type { Resource } from 'rdf-object';
+import type { IConstructionSettings } from '../IConstructionSettings';
+import type { IArgumentConstructorHandler } from './IArgumentConstructorHandler';
+import type { IArgumentsConstructor } from './IArgumentsConstructor';
+/**
+ * Handles arguments with RDF list values.
+ */
+export declare class ArgumentConstructorHandlerList implements IArgumentConstructorHandler {
+    canHandle<Instance>(value: Resource, settings: IConstructionSettings, argsCreator: IArgumentsConstructor<Instance>): boolean;
+    handle<Instance>(argument: Resource, settings: IConstructionSettings, argsCreator: IArgumentsConstructor<Instance>): Promise<Instance>;
+}

package/lib/construction/argument/ArgumentConstructorHandlerList.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ArgumentConstructorHandlerList = void 0;
+/**
+ * Handles arguments with RDF list values.
+ */
+class ArgumentConstructorHandlerList {
+    canHandle(value, settings, argsCreator) {
+        return Boolean(value.list);
+    }
+    async handle(argument, settings, argsCreator) {
+        // Recursively handle all sub-args in the list
+        const elements = await Promise.all(argument.list
+            .map((entry) => argsCreator.getArgumentValue(entry, settings)));
+        return argsCreator.constructionStrategy.createArray({ settings, elements });
+    }
+}
+exports.ArgumentConstructorHandlerList = ArgumentConstructorHandlerList;
+//# sourceMappingURL=ArgumentConstructorHandlerList.js.map

package/lib/construction/strategy/ConstructionStrategyCommonJsString.js

@@ -103,6 +103,9 @@ class ConstructionStrategyCommonJsString {
         return `new function() { return Promise.resolve(${await options.supplier()}); }`;
     }
     createPrimitive(options) {
+        if (typeof options.value === 'object') {
+            return JSON.stringify(options.value);
+        }
         return typeof options.value === 'string' ? `'${options.value}'` : `${options.value}`;
     }
     getVariableValue(options) {

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

@@ -111,9 +111,9 @@ export interface ICreationStrategyPrimitiveOptions<Instance> {
      */
     settings: IConstructionSettings;
     /**
-     * A string or number value.
+     * A string, number or object value.
      */
-    value: string | number;
+    value: string | number | any;
 }
 export interface ICreationStrategyVariableOptions<Instance> {
     /**

package/lib/loading/ComponentRegistry.d.ts

@@ -1,6 +1,6 @@
 /// <reference types="node" />
 import type { Readable } from 'stream';
-import type * as RDF from 'rdf-js';
+import type * as RDF from '@rdfjs/types';
 import type { Resource, RdfObjectLoader } from 'rdf-object';
 import type { Logger } from 'winston';
 import type { IModuleState } from './ModuleStateBuilder';

package/lib/loading/ComponentRegistry.js

@@ -55,7 +55,7 @@ class ComponentRegistry {
     registerModuleResource(moduleResource) {
         if (moduleResource.property.components) {
             for (const component of moduleResource.properties.components) {
-                component.property.module = moduleResource;
+                component.properties.module.push(moduleResource);
                 this.registerComponent(component);
             }
         }

package/lib/loading/ComponentRegistryFinalizer.js

@@ -75,11 +75,26 @@ class ComponentRegistryFinalizer {
      * @param extendingConstructorArgs The constructor argument resources to inherit from.
      */
     inheritConstructorArgumentsEntry(constructorArg, extendingConstructorArgs) {
+        // Make sure that we have fields in list-form
+        if (constructorArg.property.fields && !constructorArg.property.fields.list) {
+            if (constructorArg.properties.fields.length > 1) {
+                throw new ErrorResourcesContext_1.ErrorResourcesContext(`Invalid fields: Only one value can be defined, or an RDF list must be provided`, {
+                    constructorArg,
+                });
+            }
+            constructorArg.property.fields = this.objectLoader.createCompactedResource({
+                list: constructorArg.properties.fields,
+            });
+        }
         for (const extendingConstructorArg of extendingConstructorArgs) {
             if (extendingConstructorArg.property.fields) {
-                for (const field of extendingConstructorArg.properties.fields) {
-                    if (!constructorArg.properties.fields.includes(field)) {
-                        constructorArg.properties.fields.push(field);
+                // Inherit fields
+                for (const field of extendingConstructorArg.property.fields.list || extendingConstructorArg.properties.fields) {
+                    if (!constructorArg.property.fields) {
+                        constructorArg.property.fields = this.objectLoader.createCompactedResource({ list: [] });
+                    }
+                    if (!constructorArg.property.fields.list.includes(field)) {
+                        constructorArg.property.fields.list.push(field);
                     }
                 }
             }

package/lib/loading/ComponentsManagerBuilder.js

@@ -33,7 +33,7 @@ class ComponentsManagerBuilder {
             Boolean(options.skipContextValidation);
     }
     static createLogger(logLevel = 'warn') {
-        return winston_1.createLogger({
+        return (0, winston_1.createLogger)({
             level: logLevel,
             format: winston_1.format.combine(winston_1.format.label({ label: 'Components.js' }), winston_1.format.colorize(), winston_1.format.timestamp(), winston_1.format.printf(({ level: levelInner, message, label: labelInner, timestamp }) => `${timestamp} [${labelInner}] ${levelInner}: ${message}`)),
             transports: [new winston_1.transports.Console({

package/lib/loading/ConfigRegistry.d.ts

@@ -1,6 +1,6 @@
 /// <reference types="node" />
 import type { Readable } from 'stream';
-import type * as RDF from 'rdf-js';
+import type * as RDF from '@rdfjs/types';
 import type { RdfObjectLoader } from 'rdf-object';
 import type { Logger } from 'winston';
 import type { IModuleState } from './ModuleStateBuilder';

package/lib/preprocess/ConfigPreprocessorComponent.d.ts

@@ -20,7 +20,7 @@ export declare class ConfigPreprocessorComponent implements IConfigPreprocessor<
      * @param config A config.
      * @param handleResponse Return value of the {#canHandle}.
      */
-    transformConstructorArguments(config: Resource, handleResponse: IComponentConfigPreprocessorHandleResponse): Resource[];
+    transformConstructorArguments(config: Resource, handleResponse: IComponentConfigPreprocessorHandleResponse): Resource;
     /**
      * Let this config inherit parameter values from previously instantiated configs.
      * This will check for inheritanceValues that are defined on the component,

package/lib/preprocess/ConfigPreprocessorComponent.js

@@ -82,7 +82,7 @@ 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;
@@ -93,23 +93,28 @@ class ConfigPreprocessorComponent {
      * @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 = [];
         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);
+            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

@@ -10,7 +10,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): Resource;
+    getParameterValue(configRoot: Resource, parameter: Resource, configElement: Resource, rawValue: boolean): Resource | undefined;
 }

package/lib/preprocess/ConfigPreprocessorComponentMapped.js

@@ -43,16 +43,14 @@ class ConfigPreprocessorComponentMapped extends ConfigPreprocessorComponent_1.Co
             }
         }
         // Fallback to original constructor args
-        return [constructorArgs];
+        return constructorArgs;
     }
     getParameterValue(configRoot, parameter, configElement, rawValue) {
-        var _a;
         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') {
+        else if (parameter.type === 'NamedNode' && !parameter.property.fields) {
             valueOut = this.parameterHandler.applyParameterValues(configRoot, parameter, configElement);
         }
         else {
@@ -60,12 +58,11 @@ class ConfigPreprocessorComponentMapped extends ConfigPreprocessorComponent_1.Co
         }
         // 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/ParameterHandler.d.ts

@@ -11,9 +11,9 @@ export declare 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)
+     * @return The parameter value
      */
-    applyParameterValues(configRoot: Resource, parameter: Resource, configElement: Resource): Resource[];
+    applyParameterValues(configRoot: Resource, parameter: Resource, configElement: Resource): 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,10 +15,8 @@ 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 ParameterPropertyHandlerDefault_1.ParameterPropertyHandlerDefault(this.objectLoader),
+            new ParameterPropertyHandlerFixed_1.ParameterPropertyHandlerFixed(this.objectLoader),
             new ParameterPropertyHandlerRange_1.ParameterPropertyHandlerRange(this.objectLoader),
             new ParameterPropertyHandlerLazy_1.ParameterPropertyHandlerLazy(),
         ];
@@ -29,11 +26,25 @@ 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)
+     * @return The parameter value
      */
     applyParameterValues(configRoot, parameter, configElement) {
-        // Obtain the parameter's value in the given config
-        let value = configElement.properties[parameter.value];
+        // 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)) {

package/lib/preprocess/constructorargumentsmapping/ConstructorArgumentsElementMappingHandlerCollectEntries.d.ts

@@ -9,6 +9,6 @@ export declare class ConstructorArgumentsElementMappingHandlerCollectEntries imp
     private readonly parameterHandler;
     constructor(parameterHandler: ParameterHandler);
     canHandle(configRoot: Resource, constructorArgs: Resource, configElement: Resource, mapper: IConstructorArgumentsMapper): boolean;
-    handle(configRoot: Resource, constructorArgs: Resource, configElement: Resource, mapper: IConstructorArgumentsMapper): Resource[];
+    handle(configRoot: Resource, constructorArgs: Resource, configElement: Resource, mapper: IConstructorArgumentsMapper): Resource;
     handleCollectEntry(entryResource: Resource, configRoot: Resource, constructorArgs: Resource, configElement: Resource, mapper: IConstructorArgumentsMapper): Resource;
 }

package/lib/preprocess/constructorargumentsmapping/ConstructorArgumentsElementMappingHandlerCollectEntries.js

@@ -15,22 +15,34 @@ class ConstructorArgumentsElementMappingHandlerCollectEntries {
             constructorArgs.property.collectEntries);
     }
     handle(configRoot, constructorArgs, configElement, mapper) {
+        if (constructorArgs.properties.collectEntries.length > 1) {
+            throw new ErrorResourcesContext_1.ErrorResourcesContext(`Invalid collectEntries: Only one value can be defined, or an RDF list must be provided`, {
+                constructorArgs,
+                config: configRoot,
+            });
+        }
+        const collectEntries = constructorArgs.properties.collectEntries[0];
         // Obtain all entry values
         const entryResources = [];
-        for (const entry of constructorArgs.properties.collectEntries) {
+        for (const entry of collectEntries.list || [collectEntries]) {
             if (entry.type !== 'NamedNode') {
                 throw new ErrorResourcesContext_1.ErrorResourcesContext(`Detected illegal collectEntries value "${entry.type}", must be an IRI`, {
                     constructorArgs,
                     config: configRoot,
                 });
             }
-            for (const value of this.parameterHandler.applyParameterValues(configRoot, entry, configElement)) {
-                entryResources.push(value);
+            const value = this.parameterHandler.applyParameterValues(configRoot, entry, configElement);
+            if (value) {
+                for (const subValue of value.list || [value]) {
+                    entryResources.push(subValue);
+                }
             }
         }
         // Map all entries to values
-        return entryResources.map((entryResource) => this
-            .handleCollectEntry(entryResource, configRoot, constructorArgs, configElement, mapper));
+        return mapper.objectLoader.createCompactedResource({
+            list: entryResources.map((entryResource) => this
+                .handleCollectEntry(entryResource, configRoot, constructorArgs, configElement, mapper)),
+        });
     }
     handleCollectEntry(entryResource, configRoot, constructorArgs, configElement, mapper) {
         // Determine the (optional) entry key
@@ -82,12 +94,13 @@ class ConstructorArgumentsElementMappingHandlerCollectEntries {
         else if (constructorArgs.property.value.type === 'NamedNode' &&
             constructorArgs.property.value.value === Iris_1.IRIS_RDF.object) {
             // Value is the entry value
-            value = mapper.applyConstructorArgumentsParameters(configRoot, entryResource, configElement)[0];
+            value = mapper.applyConstructorArgumentsParameters(configRoot, entryResource, configElement);
         }
         else if (constructorArgs.property.value &&
             (constructorArgs.property.value.property.fields || constructorArgs.property.value.property.elements)) {
             // Nested mapping should reduce the parameter scope
-            value = mapper.getParameterValue(configRoot, constructorArgs.property.value, entryResource, false)[0];
+            // ! at the end of the line, because will always be truthy
+            value = mapper.getParameterValue(configRoot, constructorArgs.property.value, entryResource, false);
         }
         else if (entryResource.properties[constructorArgs.property.value.value].length !== 1) {
             throw new ErrorResourcesContext_1.ErrorResourcesContext(`Detected more than one value value in collectEntries`, {
@@ -106,7 +119,6 @@ class ConstructorArgumentsElementMappingHandlerCollectEntries {
         if (key) {
             const ret = mapper.objectLoader.createCompactedResource({});
             ret.property.key = key;
-            value.property.unique = mapper.objectLoader.createCompactedResource('"true"');
             ret.property.value = value;
             return ret;
         }

package/lib/preprocess/constructorargumentsmapping/ConstructorArgumentsElementMappingHandlerElements.d.ts

@@ -6,5 +6,5 @@ import type { IConstructorArgumentsMapper } from './IConstructorArgumentsMapper'
  */
 export declare class ConstructorArgumentsElementMappingHandlerElements implements IConstructorArgumentsElementMappingHandler {
     canHandle(configRoot: Resource, constructorArgs: Resource, configElement: Resource, mapper: IConstructorArgumentsMapper): boolean;
-    handle(configRoot: Resource, constructorArgs: Resource, configElement: Resource, mapper: IConstructorArgumentsMapper): Resource[];
+    handle(configRoot: Resource, constructorArgs: Resource, configElement: Resource, mapper: IConstructorArgumentsMapper): Resource;
 }

package/lib/preprocess/constructorargumentsmapping/ConstructorArgumentsElementMappingHandlerElements.js

@@ -19,7 +19,7 @@ class ConstructorArgumentsElementMappingHandlerElements {
             });
         }
         // Recursively handle all values in the array
-        const ret = mapper.objectLoader.createCompactedResource({});
+        const entries = [];
         for (const element of constructorArgs.property.elements.list) {
             if (element.type !== 'NamedNode' && !element.property.value && !element.property.valueRawReference) {
                 throw new ErrorResourcesContext_1.ErrorResourcesContext(`Illegal elements value, must be an IRI or resource with value/valueRawReference`, {
@@ -29,11 +29,14 @@ class ConstructorArgumentsElementMappingHandlerElements {
                     config: configRoot,
                 });
             }
-            for (const value of mapper.getParameterValue(configRoot, element, configElement, Boolean(element.property.valueRawReference))) {
-                ret.properties.value.push(value);
+            const value = mapper.getParameterValue(configRoot, element, configElement, Boolean(element.property.valueRawReference));
+            if (value) {
+                for (const entry of value.list || [value]) {
+                    entries.push(entry);
+                }
             }
         }
-        return [ret];
+        return mapper.objectLoader.createCompactedResource({ value: { list: entries } });
     }
 }
 exports.ConstructorArgumentsElementMappingHandlerElements = ConstructorArgumentsElementMappingHandlerElements;

package/lib/preprocess/constructorargumentsmapping/ConstructorArgumentsElementMappingHandlerFields.d.ts

@@ -6,5 +6,5 @@ import type { IConstructorArgumentsMapper } from './IConstructorArgumentsMapper'
  */
 export declare class ConstructorArgumentsElementMappingHandlerFields implements IConstructorArgumentsElementMappingHandler {
     canHandle(configRoot: Resource, constructorArgs: Resource, configElement: Resource, mapper: IConstructorArgumentsMapper): boolean;
-    handle(configRoot: Resource, constructorArgs: Resource, configElement: Resource, mapper: IConstructorArgumentsMapper): Resource[];
+    handle(configRoot: Resource, constructorArgs: Resource, configElement: Resource, mapper: IConstructorArgumentsMapper): Resource;
 }

package/lib/preprocess/constructorargumentsmapping/ConstructorArgumentsElementMappingHandlerFields.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ConstructorArgumentsElementMappingHandlerFields = void 0;
+const ErrorResourcesContext_1 = require("../../util/ErrorResourcesContext");
 /**
  * Handler for field definitions that contain key-value pairs to form a hash.
  */
@@ -9,17 +10,22 @@ class ConstructorArgumentsElementMappingHandlerFields {
         return Boolean(constructorArgs.property.fields);
     }
     handle(configRoot, constructorArgs, configElement, mapper) {
+        if (constructorArgs.properties.fields.length > 1) {
+            throw new ErrorResourcesContext_1.ErrorResourcesContext(`Invalid fields: Only one value can be defined, or an RDF list must be provided`, {
+                constructorArgs,
+                config: configRoot,
+            });
+        }
+        const fields = constructorArgs.properties.fields[0];
         // Recursively handle all field values.
-        const ret = mapper.objectLoader.createCompactedResource({});
-        for (const field of constructorArgs.properties.fields) {
-            for (const mappedResource of mapper.applyConstructorArgumentsParameters(configRoot, field, configElement)) {
-                ret.properties.fields.push(mappedResource);
+        const entries = [];
+        for (const field of fields.list || [fields]) {
+            const mapped = mapper.applyConstructorArgumentsParameters(configRoot, field, configElement);
+            for (const entry of mapped.list || [mapped]) {
+                entries.push(entry);
             }
         }
-        ret.property.unique = mapper.objectLoader.createCompactedResource('"true"');
-        // Hack to enforce ArgumentConstructorHandlerHash
-        ret.property.hasFields = mapper.objectLoader.createCompactedResource('"true"');
-        return [ret];
+        return mapper.objectLoader.createCompactedResource({ fields: { list: entries } });
     }
 }
 exports.ConstructorArgumentsElementMappingHandlerFields = ConstructorArgumentsElementMappingHandlerFields;

package/lib/preprocess/constructorargumentsmapping/ConstructorArgumentsElementMappingHandlerKeyValue.d.ts

@@ -6,7 +6,7 @@ import type { IConstructorArgumentsMapper } from './IConstructorArgumentsMapper'
  */
 export declare class ConstructorArgumentsElementMappingHandlerKeyValue implements IConstructorArgumentsElementMappingHandler {
     canHandle(configRoot: Resource, constructorArgs: Resource, configElement: Resource, mapper: IConstructorArgumentsMapper): boolean;
-    handle(configRoot: Resource, constructorArgs: Resource, configElement: Resource, mapper: IConstructorArgumentsMapper): Resource[];
-    handleKeyValue(configRoot: Resource, constructorArgs: Resource, configElement: Resource, mapper: IConstructorArgumentsMapper): Resource[];
-    handleValue(configRoot: Resource, constructorArgs: Resource, configElement: Resource, mapper: IConstructorArgumentsMapper): Resource[];
+    handle(configRoot: Resource, constructorArgs: Resource, configElement: Resource, mapper: IConstructorArgumentsMapper): Resource;
+    handleKeyValue(configRoot: Resource, constructorArgs: Resource, configElement: Resource, mapper: IConstructorArgumentsMapper): Resource;
+    handleValue(configRoot: Resource, constructorArgs: Resource, configElement: Resource, mapper: IConstructorArgumentsMapper): Resource;
 }