componentsjs 4.4.1 → 5.0.0-beta.2

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,25 +26,30 @@ 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)
+     * @param genericsContext Context for generic types.
+     * @return - The parameter value
      */
-    applyParameterValues(configRoot, parameter, configElement) {
-        // Obtain the parameter's value in the given config, and flatten RDF lists
-        let value = [];
-        for (const element of configElement.properties[parameter.value]) {
-            if (element.list) {
-                for (const subElement of element.list) {
-                    value.push(subElement);
-                }
-            }
-            else {
-                value.push(element);
+    applyParameterValues(configRoot, parameter, configElement, genericsContext) {
+        // 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)) {
-                value = handler.handle(value, configRoot, parameter, configElement);
+            if (handler.canHandle(value, configRoot, parameter, configElement, genericsContext)) {
+                value = handler.handle(value, configRoot, parameter, configElement, genericsContext);
             }
         }
         return value;

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

@@ -1,4 +1,5 @@
 import type { Resource } from 'rdf-object';
+import type { GenericsContext } from '../GenericsContext';
 import type { ParameterHandler } from '../ParameterHandler';
 import type { IConstructorArgumentsElementMappingHandler } from './IConstructorArgumentsElementMappingHandler';
 import type { IConstructorArgumentsMapper } from './IConstructorArgumentsMapper';
@@ -9,6 +10,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[];
-    handleCollectEntry(entryResource: Resource, configRoot: Resource, constructorArgs: Resource, configElement: Resource, mapper: IConstructorArgumentsMapper): Resource;
+    handle(configRoot: Resource, constructorArgs: Resource, configElement: Resource, mapper: IConstructorArgumentsMapper, genericsContext: GenericsContext): Resource;
+    handleCollectEntry(entryResource: Resource, configRoot: Resource, constructorArgs: Resource, configElement: Resource, mapper: IConstructorArgumentsMapper, genericsContext: GenericsContext): Resource;
 }

package/lib/preprocess/constructorargumentsmapping/ConstructorArgumentsElementMappingHandlerCollectEntries.js

@@ -14,25 +14,37 @@ class ConstructorArgumentsElementMappingHandlerCollectEntries {
         return Boolean((constructorArgs.property.value || constructorArgs.property.valueRawReference) &&
             constructorArgs.property.collectEntries);
     }
-    handle(configRoot, constructorArgs, configElement, mapper) {
+    handle(configRoot, constructorArgs, configElement, mapper, genericsContext) {
+        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, genericsContext);
+            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, genericsContext)),
+        });
     }
-    handleCollectEntry(entryResource, configRoot, constructorArgs, configElement, mapper) {
+    handleCollectEntry(entryResource, configRoot, constructorArgs, configElement, mapper, genericsContext) {
         // Determine the (optional) entry key
         let key;
         if (constructorArgs.property.key) {
@@ -82,12 +94,15 @@ 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, genericsContext);
         }
         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, genericsContext);
         }
         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 +121,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

@@ -1,4 +1,5 @@
 import type { Resource } from 'rdf-object';
+import type { GenericsContext } from '../GenericsContext';
 import type { IConstructorArgumentsElementMappingHandler } from './IConstructorArgumentsElementMappingHandler';
 import type { IConstructorArgumentsMapper } from './IConstructorArgumentsMapper';
 /**
@@ -6,5 +7,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, genericsContext: GenericsContext): Resource;
 }

package/lib/preprocess/constructorargumentsmapping/ConstructorArgumentsElementMappingHandlerElements.js

@@ -9,7 +9,7 @@ class ConstructorArgumentsElementMappingHandlerElements {
     canHandle(configRoot, constructorArgs, configElement, mapper) {
         return Boolean(constructorArgs.property.elements);
     }
-    handle(configRoot, constructorArgs, configElement, mapper) {
+    handle(configRoot, constructorArgs, configElement, mapper, genericsContext) {
         // Elements must have RDF list values.
         if (!constructorArgs.property.elements.list) {
             throw new ErrorResourcesContext_1.ErrorResourcesContext(`Illegal non-RDF-list elements`, {
@@ -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), genericsContext);
+            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

@@ -1,4 +1,5 @@
 import type { Resource } from 'rdf-object';
+import type { GenericsContext } from '../GenericsContext';
 import type { IConstructorArgumentsElementMappingHandler } from './IConstructorArgumentsElementMappingHandler';
 import type { IConstructorArgumentsMapper } from './IConstructorArgumentsMapper';
 /**
@@ -6,5 +7,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, genericsContext: GenericsContext): 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.
  */
@@ -8,18 +9,24 @@ class ConstructorArgumentsElementMappingHandlerFields {
     canHandle(configRoot, constructorArgs, configElement, mapper) {
         return Boolean(constructorArgs.property.fields);
     }
-    handle(configRoot, constructorArgs, configElement, mapper) {
+    handle(configRoot, constructorArgs, configElement, mapper, genericsContext) {
+        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, genericsContext);
+            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

@@ -1,4 +1,5 @@
 import type { Resource } from 'rdf-object';
+import type { GenericsContext } from '../GenericsContext';
 import type { IConstructorArgumentsElementMappingHandler } from './IConstructorArgumentsElementMappingHandler';
 import type { IConstructorArgumentsMapper } from './IConstructorArgumentsMapper';
 /**
@@ -6,7 +7,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, genericsContext: GenericsContext): Resource;
+    handleKeyValue(configRoot: Resource, constructorArgs: Resource, configElement: Resource, mapper: IConstructorArgumentsMapper, genericsContext: GenericsContext): Resource;
+    handleValue(configRoot: Resource, constructorArgs: Resource, configElement: Resource, mapper: IConstructorArgumentsMapper, genericsContext: GenericsContext): Resource;
 }

package/lib/preprocess/constructorargumentsmapping/ConstructorArgumentsElementMappingHandlerKeyValue.js

@@ -10,7 +10,7 @@ class ConstructorArgumentsElementMappingHandlerKeyValue {
         return Boolean((constructorArgs.property.value || constructorArgs.property.valueRawReference) &&
             !constructorArgs.property.collectEntries);
     }
-    handle(configRoot, constructorArgs, configElement, mapper) {
+    handle(configRoot, constructorArgs, configElement, mapper, genericsContext) {
         if (constructorArgs.property.key) {
             // Throw if our key is not a literal
             if (constructorArgs.property.key.type !== 'Literal') {
@@ -21,21 +21,21 @@ class ConstructorArgumentsElementMappingHandlerKeyValue {
                 });
             }
             // Key-value
-            return this.handleKeyValue(configRoot, constructorArgs, configElement, mapper);
+            return this.handleKeyValue(configRoot, constructorArgs, configElement, mapper, genericsContext);
         }
         // Only value
-        return this.handleValue(configRoot, constructorArgs, configElement, mapper);
+        return this.handleValue(configRoot, constructorArgs, configElement, mapper, genericsContext);
     }
-    handleKeyValue(configRoot, constructorArgs, configElement, mapper) {
-        const ret = mapper.objectLoader.createCompactedResource({});
-        ret.property.key = constructorArgs.property.key;
-        for (const value of mapper.getParameterValue(configRoot, constructorArgs.property.value || constructorArgs.property.valueRawReference, configElement, Boolean(constructorArgs.property.valueRawReference))) {
-            ret.properties.value.push(value);
-        }
-        return [ret];
+    handleKeyValue(configRoot, constructorArgs, configElement, mapper, genericsContext) {
+        const value = mapper.getParameterValue(configRoot, constructorArgs.property.value || constructorArgs.property.valueRawReference, configElement, Boolean(constructorArgs.property.valueRawReference), genericsContext);
+        return mapper.objectLoader.createCompactedResource(Object.assign({ key: constructorArgs.property.key }, value ? { value } : {}));
     }
-    handleValue(configRoot, constructorArgs, configElement, mapper) {
-        return mapper.getParameterValue(configRoot, constructorArgs.property.value || constructorArgs.property.valueRawReference, configElement, Boolean(constructorArgs.property.valueRawReference));
+    handleValue(configRoot, constructorArgs, configElement, mapper, genericsContext) {
+        const value = mapper.getParameterValue(configRoot, constructorArgs.property.value || constructorArgs.property.valueRawReference, configElement, Boolean(constructorArgs.property.valueRawReference), genericsContext);
+        if (!value) {
+            return mapper.objectLoader.createCompactedResource({ undefined: true });
+        }
+        return value;
     }
 }
 exports.ConstructorArgumentsElementMappingHandlerKeyValue = ConstructorArgumentsElementMappingHandlerKeyValue;

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

@@ -1,4 +1,5 @@
 import type { Resource } from 'rdf-object';
+import type { GenericsContext } from '../GenericsContext';
 import type { IConstructorArgumentsElementMappingHandler } from './IConstructorArgumentsElementMappingHandler';
 import type { IConstructorArgumentsMapper } from './IConstructorArgumentsMapper';
 /**
@@ -6,5 +7,5 @@ import type { IConstructorArgumentsMapper } from './IConstructorArgumentsMapper'
  */
 export declare class ConstructorArgumentsElementMappingHandlerList 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, genericsContext: GenericsContext): Resource;
 }

package/lib/preprocess/constructorargumentsmapping/ConstructorArgumentsElementMappingHandlerList.js

@@ -8,40 +8,27 @@ class ConstructorArgumentsElementMappingHandlerList {
     canHandle(configRoot, constructorArgs, configElement, mapper) {
         return Boolean(constructorArgs.list);
     }
-    handle(configRoot, constructorArgs, configElement, mapper) {
-        var _a;
+    handle(configRoot, constructorArgs, configElement, mapper, genericsContext) {
         // Recursively handle all field values.
         const ret = mapper.objectLoader.createCompactedResource({});
         ret.list = [];
         for (const argument of constructorArgs.list) {
             if (argument.property.fields || argument.property.elements) {
-                for (const mapped of mapper.applyConstructorArgumentsParameters(configRoot, argument, configElement)) {
-                    ret.list.push(mapped);
-                }
+                ret.list.push(mapper
+                    .applyConstructorArgumentsParameters(configRoot, argument, configElement, genericsContext));
             }
             else {
-                const mappeds = mapper.getParameterValue(configRoot, argument, configElement, false);
-                if (mappeds.length > 0) {
-                    if (((_a = mappeds[0].property.unique) === null || _a === void 0 ? void 0 : _a.value) === 'true') {
-                        // Only add a single value if param was unique
-                        ret.list.push(mappeds[0]);
-                    }
-                    else {
-                        // Add all values as an array if param was not unique
-                        ret.list.push(mapper.objectLoader.createCompactedResource({
-                            elements: mappeds.map(value => mapper.objectLoader.createCompactedResource({ value })),
-                        }));
-                    }
+                const value = mapper
+                    .getParameterValue(configRoot, argument, configElement, false, genericsContext);
+                if (value) {
+                    ret.list.push(value);
                 }
                 else {
-                    // Explicitly pass a single undefined value if no param value was set
-                    ret.list.push(mapper.objectLoader.createCompactedResource({
-                        undefined: true,
-                    }));
+                    ret.list.push(mapper.objectLoader.createCompactedResource({ undefined: true }));
                 }
             }
         }
-        return [ret];
+        return ret;
     }
 }
 exports.ConstructorArgumentsElementMappingHandlerList = ConstructorArgumentsElementMappingHandlerList;

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

@@ -1,4 +1,5 @@
 import type { Resource } from 'rdf-object';
+import type { GenericsContext } from '../GenericsContext';
 import type { IConstructorArgumentsMapper } from './IConstructorArgumentsMapper';
 /**
  * Handles a specific type of a constructor argument element.
@@ -10,8 +11,9 @@ export interface IConstructorArgumentsElementMappingHandler {
      * @param constructorArgs Object mapping definition inside the constructor arguments.
      * @param configElement Part of the config resource to look for parameter instantiations as predicates.
      * @param mapper Instance of the constructor arguments mapper that can be used to handle recursive args.
+     * @param genericsContext Context for generic types.
      */
-    canHandle: (configRoot: Resource, constructorArgs: Resource, configElement: Resource, mapper: IConstructorArgumentsMapper) => boolean;
+    canHandle: (configRoot: Resource, constructorArgs: Resource, configElement: Resource, mapper: IConstructorArgumentsMapper, genericsContext: GenericsContext) => boolean;
     /**
      * Map the given config element with param instantiations
      * to a raw config according to the given constructor arguments definition.
@@ -19,6 +21,7 @@ export interface IConstructorArgumentsElementMappingHandler {
      * @param constructorArgs Object mapping definition inside the constructor arguments.
      * @param configElement Part of the config resource to look for parameter instantiations as predicates.
      * @param mapper Instance of the constructor arguments mapper that can be used to handle recursive args.
+     * @param genericsContext Context for generic types.
      */
-    handle: (configRoot: Resource, constructorArgs: Resource, configElement: Resource, mapper: IConstructorArgumentsMapper) => Resource[];
+    handle: (configRoot: Resource, constructorArgs: Resource, configElement: Resource, mapper: IConstructorArgumentsMapper, genericsContext: GenericsContext) => Resource;
 }

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

@@ -1,4 +1,5 @@
 import type { RdfObjectLoader, Resource } from 'rdf-object';
+import type { GenericsContext } from '../GenericsContext';
 /**
  * Instances of this interfaces can apply constructor arguments on configs.
  * This is mainly used by {@link IConstructorArgumentsElementMappingHandler}.
@@ -15,14 +16,16 @@ export interface IConstructorArgumentsMapper {
      * @param configRoot The root config resource that we are working in.
      * @param constructorArgs Object mapping definition inside the constructor arguments.
      * @param configElement Part of the config resource to look for parameter instantiations as predicates.
+     * @param genericsContext Context for generic types.
      */
-    applyConstructorArgumentsParameters: (configRoot: Resource, constructorArgs: Resource, configElement: Resource) => Resource[];
+    applyConstructorArgumentsParameters: (configRoot: Resource, constructorArgs: Resource, configElement: Resource, genericsContext: GenericsContext) => Resource;
     /**
      * Obtain the value(s) of the given parameter in the given config.
      * @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.
      * @param rawValue If the IRI represents a raw string value instead of a parameter reference.
+     * @param genericsContext Context for generic types.
      */
-    getParameterValue: (configRoot: Resource, parameter: Resource, configElement: Resource, rawValue: boolean) => Resource[];
+    getParameterValue: (configRoot: Resource, parameter: Resource, configElement: Resource, rawValue: boolean, genericsContext: GenericsContext) => Resource | undefined;
 }

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

@@ -1,4 +1,5 @@
 import type { Resource } from 'rdf-object';
+import type { GenericsContext } from '../GenericsContext';
 /**
  * Transforms a parameter value based on some kind of parameter property.
  */
@@ -10,8 +11,9 @@ export interface IParameterPropertyHandler {
      * @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.
+     * @param genericsContext Context for generic types.
      */
-    canHandle: (value: Resource[], configRoot: Resource, parameter: Resource, configElement: Resource) => boolean;
+    canHandle: (value: Resource | undefined, configRoot: Resource, parameter: Resource, configElement: Resource, genericsContext: GenericsContext) => boolean;
     /**
      * Transform the given parameter value.
      * @param value The current parameter value obtained from the config.
@@ -19,6 +21,7 @@ export interface IParameterPropertyHandler {
      * @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.
+     * @param genericsContext Context for generic types.
      */
-    handle: (value: Resource[], configRoot: Resource, parameter: Resource, configElement: Resource) => Resource[];
+    handle: (value: Resource | undefined, configRoot: Resource, parameter: Resource, configElement: Resource, genericsContext: GenericsContext) => Resource | undefined;
 }

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

@@ -1,9 +1,12 @@
-import type { Resource } from 'rdf-object';
+import type { Resource, RdfObjectLoader } from 'rdf-object';
 import type { IParameterPropertyHandler } from './IParameterPropertyHandler';
 /**
  * If no value has been set, its default value will be set.
  */
 export declare class ParameterPropertyHandlerDefault implements IParameterPropertyHandler {
-    canHandle(value: Resource[], configRoot: Resource, parameter: Resource, configElement: Resource): boolean;
-    handle(value: Resource[], configRoot: Resource, parameter: Resource, configElement: Resource): Resource[];
+    private readonly objectLoader;
+    constructor(objectLoader: RdfObjectLoader);
+    canHandle(value: Resource | undefined, configRoot: Resource, parameter: Resource): boolean;
+    handle(value: Resource | undefined, configRoot: Resource, parameter: Resource, configElement: Resource): Resource | undefined;
+    protected handleValue(value: Resource, configElement: Resource): Resource;
 }

package/lib/preprocess/parameterproperty/ParameterPropertyHandlerDefault.js

@@ -1,15 +1,32 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ParameterPropertyHandlerDefault = void 0;
+const Iris_1 = require("../../rdf/Iris");
+const ErrorResourcesContext_1 = require("../../util/ErrorResourcesContext");
 /**
  * If no value has been set, its default value will be set.
  */
 class ParameterPropertyHandlerDefault {
-    canHandle(value, configRoot, parameter, configElement) {
-        return Boolean(value.length === 0 && parameter.property.default);
+    constructor(objectLoader) {
+        this.objectLoader = objectLoader;
+    }
+    canHandle(value, configRoot, parameter) {
+        return Boolean(!value && parameter.property.default);
     }
     handle(value, configRoot, parameter, configElement) {
-        value = parameter.properties.default;
+        if (parameter.properties.default.length > 1) {
+            throw new ErrorResourcesContext_1.ErrorResourcesContext(`Invalid default value for parameter "${parameter.value}": Only one value can be defined, or an RDF list must be provided`, { parameter });
+        }
+        return parameter.property.default.list ?
+            this.objectLoader.createCompactedResource({
+                list: parameter.property.default.list.map(subValue => this.handleValue(subValue, configElement)),
+            }) :
+            this.handleValue(parameter.property.default, configElement);
+    }
+    handleValue(value, configElement) {
+        if (value.type === 'NamedNode' && value.value === Iris_1.IRIS_RDF.subject) {
+            value = this.objectLoader.createCompactedResource(`"${configElement.value}"`);
+        }
         return value;
     }
 }

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

@@ -6,6 +6,6 @@ import type { IParameterPropertyHandler } from './IParameterPropertyHandler';
 export declare class ParameterPropertyHandlerDefaultScoped implements IParameterPropertyHandler {
     private readonly objectLoader;
     constructor(objectLoader: RdfObjectLoader);
-    canHandle(value: Resource[], configRoot: Resource, parameter: Resource, configElement: Resource): boolean;
-    handle(value: Resource[], configRoot: Resource, parameter: Resource, configElement: Resource): Resource[];
+    canHandle(value: Resource | undefined, configRoot: Resource, parameter: Resource): boolean;
+    handle(value: Resource | undefined, configRoot: Resource, parameter: Resource, configElement: Resource): Resource | undefined;
 }

package/lib/preprocess/parameterproperty/ParameterPropertyHandlerDefaultScoped.js

@@ -9,11 +9,11 @@ class ParameterPropertyHandlerDefaultScoped {
     constructor(objectLoader) {
         this.objectLoader = objectLoader;
     }
-    canHandle(value, configRoot, parameter, configElement) {
-        return Boolean(value.length === 0 && parameter.property.defaultScoped);
+    canHandle(value, configRoot, parameter) {
+        return Boolean(!value && parameter.property.defaultScoped);
     }
     handle(value, configRoot, parameter, configElement) {
-        // Multiple scopes can be defined
+        let applyingValue;
         for (const scoped of parameter.properties.defaultScoped) {
             // Require defaultScope
             if (!scoped.property.defaultScope) {
@@ -25,13 +25,24 @@ class ParameterPropertyHandlerDefaultScoped {
                 if (!scoped.property.defaultScopedValue) {
                     throw new ErrorResourcesContext_1.ErrorResourcesContext(`Invalid defaultScoped for parameter "${parameter.value}": Missing defaultScopedValue`, { parameter });
                 }
+                // Require RDF list or single value
+                if (scoped.properties.defaultScopedValue.length > 1) {
+                    throw new ErrorResourcesContext_1.ErrorResourcesContext(`Invalid defaultScoped value for parameter "${parameter.value}": Only one defaultScopedValue can be defined, or an RDF list must be provided`, { parameter });
+                }
                 // Apply the scope if the config is of the required type (also considering sub-types)
                 if (configRoot.isA(scopeType.term)) {
-                    value.push(...scoped.properties.defaultScopedValue);
+                    applyingValue = !applyingValue ?
+                        scoped.property.defaultScopedValue :
+                        this.objectLoader.createCompactedResource({
+                            list: [
+                                ...applyingValue.list || [applyingValue],
+                                ...scoped.property.defaultScopedValue.list || [scoped.property.defaultScopedValue],
+                            ],
+                        });
                 }
             }
         }
-        return value;
+        return applyingValue;
     }
 }
 exports.ParameterPropertyHandlerDefaultScoped = ParameterPropertyHandlerDefaultScoped;

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

@@ -1,9 +1,11 @@
-import type { Resource } from 'rdf-object';
+import type { Resource, RdfObjectLoader } from 'rdf-object';
 import type { IParameterPropertyHandler } from './IParameterPropertyHandler';
 /**
  * Irrespective of any set values, prepend the parameter's fixed values.
  */
 export declare class ParameterPropertyHandlerFixed implements IParameterPropertyHandler {
-    canHandle(value: Resource[], configRoot: Resource, parameter: Resource, configElement: Resource): boolean;
-    handle(value: Resource[], configRoot: Resource, parameter: Resource, configElement: Resource): Resource[];
+    private readonly objectLoader;
+    constructor(objectLoader: RdfObjectLoader);
+    canHandle(value: Resource | undefined, configRoot: Resource, parameter: Resource): boolean;
+    handle(value: Resource | undefined, configRoot: Resource, parameter: Resource, configElement: Resource): Resource | undefined;
 }