@shaclmate/compiler 4.0.40 → 4.0.42

package/dist/generators/ts/ObjectUnionType.js

@@ -16,28 +16,28 @@ import { UnionType } from "./UnionType.js";
 export class ObjectUnionType extends UnionType {
     kind = "ObjectUnion";
     get identifierTypeAlias() {
-        return this.alias.map((alias) => code `${alias}.Identifier`).unsafeCoerce();
+        return this.name.map((name) => code `${name}.Identifier`).unsafeCoerce();
     }
     get objectSetMethodNames() {
-        return this.alias
-            .map((alias) => ObjectType_objectSetMethodNames.call({
-            alias,
+        return this.name
+            .map((name) => ObjectType_objectSetMethodNames.call({
+            name,
             configuration: this.configuration,
         }))
             .unsafeCoerce();
     }
     get schema() {
-        return this.alias
-            .map((alias) => code `${alias}.schema`)
+        return this.name
+            .map((name) => code `${name}.schema`)
             .orDefault(super.schema);
     }
     get schemaType() {
-        return this.alias
+        return this.name
             .map(() => code `typeof ${this.schema}`)
             .orDefault(super.schemaType);
     }
     get staticModuleDeclarations() {
-        const alias = this.alias.unsafeCoerce();
+        const name = this.name.unsafeCoerce();
         return {
             ...super.staticModuleDeclarations,
             ...this.identifierTypeDeclarations,
@@ -47,22 +47,22 @@ export class ObjectUnionType extends UnionType {
             ...this.graphqlTypeVariableStatement,
             ...this.isTypeFunctionDeclaration,
             ...this.schemaVariableStatement,
-            ...ObjectType_sparqlConstructQueryFunctionDeclaration.call({
-                alias,
-                configuration: this.configuration,
-                filterType: this.filterType,
-                reusables: this.reusables,
-            })
-                .map((code_) => singleEntryRecord(`sparqlConstructQuery`, code_))
-                .orDefault({}),
-            ...ObjectType_sparqlConstructQueryStringFunctionDeclaration.call({
-                alias,
-                configuration: this.configuration,
-                filterType: this.filterType,
-                reusables: this.reusables,
-            })
-                .map((code_) => singleEntryRecord(`sparqlConstructQueryString`, code_))
-                .orDefault({}),
+            ...(this.configuration.features.has("Object.SPARQL")
+                ? {
+                    ...singleEntryRecord("sparqlConstructQuery", ObjectType_sparqlConstructQueryFunctionDeclaration.call({
+                        name,
+                        configuration: this.configuration,
+                        filterType: this.filterType,
+                        reusables: this.reusables,
+                    })),
+                    ...singleEntryRecord("sparqlConstructQueryString", ObjectType_sparqlConstructQueryStringFunctionDeclaration.call({
+                        name,
+                        configuration: this.configuration,
+                        filterType: this.filterType,
+                        reusables: this.reusables,
+                    })),
+                }
+                : {}),
             ...this.toRdfResourceFunctionDeclaration,
         };
     }
@@ -72,7 +72,7 @@ export class ObjectUnionType extends UnionType {
         }
         return singleEntryRecord(`focusSparqlConstructTriples`, code `\
 export function focusSparqlConstructTriples({ filter, focusIdentifier, variablePrefix }: { filter: ${this.filterType} | undefined; focusIdentifier: ${this.reusables.imports.NamedNode} | ${this.reusables.imports.Variable}; ignoreRdfType: boolean; variablePrefix: string }): readonly ${this.reusables.imports.sparqljs}.Triple[] {
-  return [${joinCode(this.members.map((member) => code `...${member.type.alias.unsafeCoerce()}.focusSparqlConstructTriples({ filter: filter?.on?.${member.type.alias.unsafeCoerce()}, focusIdentifier, ignoreRdfType: false, variablePrefix: \`\${variablePrefix}${pascalCase(member.type.alias.unsafeCoerce())}\` }).concat()`), { on: ", " })}];
+  return [${joinCode(this.members.map((member) => code `...${member.type.name.unsafeCoerce()}.focusSparqlConstructTriples({ filter: filter?.on?.${member.type.name.unsafeCoerce()}, focusIdentifier, ignoreRdfType: false, variablePrefix: \`\${variablePrefix}${pascalCase(member.type.name.unsafeCoerce())}\` }).concat()`), { on: ", " })}];
 }`);
     }
     get focusSparqlWherePatternsFunctionDeclaration() {
@@ -96,7 +96,7 @@ if (focusIdentifier.termType === "Variable") {
   }));
 }`,
             code `patterns.push({ patterns: [${joinCode(this.members.map((member) => code `${{
-                patterns: code `${member.type.alias.unsafeCoerce()}.focusSparqlWherePatterns({ filter: filter?.on?.${member.type.alias.unsafeCoerce()}, focusIdentifier, ignoreRdfType: false, preferredLanguages, variablePrefix: \`\${variablePrefix}${pascalCase(member.type.alias.unsafeCoerce())}\` }).concat()`,
+                patterns: code `${member.type.name.unsafeCoerce()}.focusSparqlWherePatterns({ filter: filter?.on?.${member.type.name.unsafeCoerce()}, focusIdentifier, ignoreRdfType: false, preferredLanguages, variablePrefix: \`\${variablePrefix}${pascalCase(member.type.name.unsafeCoerce())}\` }).concat()`,
                 type: literalOf("group"),
             }}`), { on: ", " })}], type: "union" });`,
             code `return patterns;`,
@@ -107,11 +107,11 @@ if (focusIdentifier.termType === "Variable") {
         if (!this.configuration.features.has("Object.fromRdf")) {
             return {};
         }
-        const alias = this.alias.unsafeCoerce();
+        const name = this.name.unsafeCoerce();
         return singleEntryRecord(`fromRdfResource`, code `\
-export const fromRdfResource: ${this.reusables.snippets.FromRdfResourceFunction}<${alias}> = (resource, options) => 
+export const fromRdfResource: ${this.reusables.snippets.FromRdfResourceFunction}<${name}> = (resource, options) => 
   ${this.members.reduce((expression, member) => {
-            const memberTypeExpression = code `(${member.type.alias.unsafeCoerce()}.fromRdfResource(resource, { ...options, ignoreRdfType: false }) as ${this.reusables.imports.Either}<Error, ${alias}>)`;
+            const memberTypeExpression = code `(${member.type.name.unsafeCoerce()}.fromRdfResource(resource, { ...options, ignoreRdfType: false }) as ${this.reusables.imports.Either}<Error, ${name}>)`;
             return expression !== null
                 ? code `${expression}.altLazy(() => ${memberTypeExpression})`
                 : memberTypeExpression;
@@ -124,13 +124,13 @@ export const fromRdfResource: ${this.reusables.snippets.FromRdfResourceFunction}
         if (this.synthetic) {
             return {};
         }
-        const alias = this.alias.unsafeCoerce();
+        const name = this.name.unsafeCoerce();
         return singleEntryRecord(`GraphQL`, code `\
 export const GraphQL = new ${this.reusables.imports.GraphQLUnionType}(${{
             description: this.comment.map(JSON.stringify).extract(),
-            name: alias,
-            resolveType: code `(value: ${alias}) => value.${this.configuration.syntheticNamePrefix}type`,
-            types: code `[${joinCode(this.members.map((member) => member.type.graphqlType.nullableName), { on: ", " })}]`,
+            name: name,
+            resolveType: code `(value: ${name}) => value.${this.configuration.syntheticNamePrefix}type`,
+            types: code `[${joinCode(this.members.map((member) => member.type.graphqlType.nullableExpression), { on: ", " })}]`,
         }});`);
     }
     get identifierTypeDeclarations() {
@@ -148,13 +148,13 @@ export namespace Identifier {
         if (!this.configuration.features.has("Object.type")) {
             return {};
         }
-        const alias = this.alias.unsafeCoerce();
-        if (alias === `${this.configuration.syntheticNamePrefix}Object`) {
+        const name = this.name.unsafeCoerce();
+        if (name === `${this.configuration.syntheticNamePrefix}Object`) {
             return {};
         }
-        return singleEntryRecord(`is${alias}`, code `\
-    export function is${alias}(object: ${this.configuration.syntheticNamePrefix}Object): object is ${alias} {
-      return ${joinCode(this.members.map((member) => code `${member.type.alias.unsafeCoerce()}.is${member.type.alias.unsafeCoerce()}(object)`), { on: " || " })};
+        return singleEntryRecord(`is${name}`, code `\
+    export function is${name}(object: ${this.configuration.syntheticNamePrefix}Object): object is ${name} {
+      return ${joinCode(this.members.map((member) => code `${member.type.name.unsafeCoerce()}.is${member.type.name.unsafeCoerce()}(object)`), { on: " || " })};
     }`);
     }
     get schemaVariableStatement() {
@@ -163,7 +163,7 @@ export namespace Identifier {
         }
         const commonPropertiesByName = {};
         this.members.forEach((member, memberI) => {
-            for (const memberTypeProperty of member.type.properties.concat(member.type.ancestorObjectTypes.flatMap((ancestorObjectType) => ancestorObjectType.properties))) {
+            for (const memberTypeProperty of member.type.properties) {
                 if (memberTypeProperty.kind !== "Shacl") {
                     continue;
                 }
@@ -199,11 +199,11 @@ export const schema = { ${joinCode(super.schemaInitializers.concat(code `propert
         if (!this.configuration.features.has("Object.toRdf")) {
             return {};
         }
-        const alias = this.alias.unsafeCoerce();
+        const name = this.name.unsafeCoerce();
         return singleEntryRecord(`toRdfResource`, code `\
-export const toRdfResource: ${this.reusables.snippets.ToRdfResourceFunction}<${alias}> = (object, options) => {
+export const toRdfResource: ${this.reusables.snippets.ToRdfResourceFunction}<${name}> = (object, options) => {
 ${joinCode(this.members
-            .map((member) => code `if (${member.type.alias.unsafeCoerce()}.is${member.type.alias.unsafeCoerce()}(object)) { return ${member.type.alias.unsafeCoerce()}.toRdfResource(object, options); }`)
+            .map((member) => code `if (${member.type.name.unsafeCoerce()}.is${member.type.name.unsafeCoerce()}(object)) { return ${member.type.name.unsafeCoerce()}.toRdfResource(object, options); }`)
             .concat(code `throw new Error("unrecognized type");`))}
 };`);
     }

package/dist/generators/ts/OptionType.d.ts

@@ -4,22 +4,26 @@ import { type Code } from "./ts-poet-wrapper.js";
 export declare class OptionType<ItemTypeT extends OptionType.ItemType> extends AbstractContainerType<ItemTypeT> {
     readonly discriminantProperty: Maybe<AbstractContainerType.DiscriminantProperty>;
     readonly graphqlArgs: AbstractContainerType<ItemTypeT>["graphqlArgs"];
+    readonly jsTypes: readonly [{
+        readonly instanceof: "Maybe";
+        readonly typeof: "object";
+    }];
     readonly kind = "Option";
-    readonly typeofs: "object"[];
     get conversionFunction(): Maybe<AbstractContainerType.ConversionFunction>;
     get equalsFunction(): Code;
     get expression(): Code;
     get filterFunction(): Code;
     get filterType(): Code;
+    get fromRdfResourceValuesFunction(): Code;
     get graphqlType(): AbstractContainerType.GraphqlType;
     get hashFunction(): Code;
     get mutable(): boolean;
     get schemaType(): Code;
+    get toRdfResourceValueTypes(): AbstractContainerType<ItemTypeT>["toRdfResourceValueTypes"];
     get validationFunction(): Maybe<Code>;
     get valueSparqlConstructTriplesFunction(): Code;
     get valueSparqlWherePatternsFunction(): Code;
     fromJsonExpression({ variables, }: Parameters<AbstractContainerType<ItemTypeT>["fromJsonExpression"]>[0]): Code;
-    fromRdfResourceValuesExpression(parameters: Parameters<AbstractContainerType<ItemTypeT>["fromRdfResourceValuesExpression"]>[0]): Code;
     graphqlResolveExpression(parameters: Parameters<AbstractContainerType<ItemTypeT>["graphqlResolveExpression"]>[0]): Code;
     jsonSchema(parameters: Parameters<AbstractContainerType<ItemTypeT>["jsonSchema"]>[0]): Code;
     jsonType(parameters?: Parameters<AbstractContainerType<ItemTypeT>["jsonType"]>[0]): AbstractContainerType.JsonType;

package/dist/generators/ts/OptionType.js

@@ -13,18 +13,20 @@ import { code } from "./ts-poet-wrapper.js";
 export class OptionType extends AbstractContainerType {
     discriminantProperty = Maybe.empty();
     graphqlArgs = Maybe.empty();
+    jsTypes = [
+        { instanceof: "Maybe", typeof: "object" },
+    ];
     kind = "Option";
-    typeofs = ["object"];
     get conversionFunction() {
         const itemConversionFunction = this.itemType.conversionFunction.orDefault(this.itemConversionFunctionDefault);
         return Maybe.of({
             code: code `${this.reusables.snippets.convertToMaybe}(${itemConversionFunction.code})`,
             sourceTypes: itemConversionFunction.sourceTypes.concat({
                 expression: this.expression,
-                typeof: "object",
+                jsType: { instanceof: "Maybe", typeof: "object" },
             }, {
                 expression: code `undefined`,
-                typeof: "undefined",
+                jsType: { typeof: "undefined" },
             }),
         });
     }
@@ -40,9 +42,12 @@ export class OptionType extends AbstractContainerType {
     get filterType() {
         return code `${this.reusables.snippets.MaybeFilter}<${this.itemType.filterType}>`;
     }
+    get fromRdfResourceValuesFunction() {
+        return code `${this.reusables.snippets.maybeFromRdfResourceValues}<${this.itemType.expression}, ${this.itemType.schemaType}>(${this.itemType.fromRdfResourceValuesFunction})`;
+    }
     get graphqlType() {
         invariant(!this.itemType.graphqlType.nullable);
-        return new AbstractContainerType.GraphqlType(this.itemType.graphqlType.name, this.reusables, {
+        return new AbstractContainerType.GraphqlType(this.itemType.graphqlType.expression, this.reusables, {
             nullable: true,
         });
     }
@@ -55,6 +60,9 @@ export class OptionType extends AbstractContainerType {
     get schemaType() {
         return code `${this.reusables.snippets.MaybeSchema}<${this.itemType.schemaType}>`;
     }
+    get toRdfResourceValueTypes() {
+        return this.itemType.toRdfResourceValueTypes;
+    }
     get validationFunction() {
         return Maybe.of(code `${this.reusables.snippets.validateMaybe}(${this.itemType.validationFunction.orDefault(this.itemValidationFunctionDefault)})`);
     }
@@ -71,10 +79,6 @@ export class OptionType extends AbstractContainerType {
         });
         return code `${expression}.map(item => (${itemFromJsonExpression}).map(${this.reusables.imports.Maybe}.of)).orDefault(${this.reusables.imports.Either}.of(${this.reusables.imports.Maybe}.empty()))`;
     }
-    fromRdfResourceValuesExpression(parameters) {
-        const { variables } = parameters;
-        return code `${this.itemType.fromRdfResourceValuesExpression(parameters)}.map(values => values.length > 0 ? values.map(value => ${this.reusables.imports.Maybe}.of(value)) : ${this.reusables.imports.Resource}.Values.fromValue<${this.reusables.imports.Maybe}<${this.itemType.expression}>>({ focusResource: ${variables.resource}, propertyPath: ${variables.propertyPath}, value: ${this.reusables.imports.Maybe}.empty() }))`;
-    }
     graphqlResolveExpression(parameters) {
         return code `${this.itemType.graphqlResolveExpression(parameters)}.extractNullable()`;
     }
@@ -84,7 +88,7 @@ export class OptionType extends AbstractContainerType {
     jsonType(parameters) {
         const itemTypeJsonType = this.itemType.jsonType(parameters);
         invariant(!itemTypeJsonType.optional);
-        return new AbstractContainerType.JsonType(itemTypeJsonType.name, {
+        return new AbstractContainerType.JsonType(itemTypeJsonType.expression, {
             optional: true,
         });
     }
@@ -123,6 +127,9 @@ __decorate([
 __decorate([
     Memoize()
 ], OptionType.prototype, "filterType", null);
+__decorate([
+    Memoize()
+], OptionType.prototype, "fromRdfResourceValuesFunction", null);
 __decorate([
     Memoize()
 ], OptionType.prototype, "graphqlType", null);

package/dist/generators/ts/RdfjsDatasetObjectSetType.js

@@ -87,10 +87,7 @@ async ${methodSignatures.objects.name}(${methodSignatures.objects.parameters}):
                     // objectsSync has per-object type logic, not just forwarding
                 ];
                 const runtimeObjectType = (filterFunction, namedObjectType) => {
-                    const fromRdfTypes = namedObjectType.fromRdfTypeVariable
-                        .toList()
-                        .concat(namedObjectType.descendantFromRdfTypeVariables);
-                    return code `{ filter: ${filterFunction}, fromRdfResource: ${namedObjectType.expression}.fromRdfResource, fromRdfTypes: ${fromRdfTypes.length > 0 ? code `[${joinCode(fromRdfTypes, { on: ", " })}]` : "[]"} }`;
+                    return code `{ filter: ${filterFunction}, fromRdfResource: ${namedObjectType.expression}.fromRdfResource, fromRdfTypes: ${namedObjectType.fromRdfTypeVariable.map((fromRdfTypeVariable) => code `[${fromRdfTypeVariable}]`).orDefault(code `[]`)} }`;
                 };
                 switch (namedObjectType.kind) {
                     case "Object": {

package/dist/generators/ts/SetType.d.ts

@@ -1,17 +1,32 @@
+import { Maybe } from "purify-ts";
 import { AbstractCollectionType } from "./AbstractCollectionType.js";
+import type { AbstractContainerType } from "./AbstractContainerType.js";
 import { type Code } from "./ts-poet-wrapper.js";
 export declare class SetType<ItemTypeT extends SetType.ItemType> extends AbstractCollectionType<ItemTypeT> {
     readonly graphqlArgs: AbstractCollectionType<ItemTypeT>["graphqlArgs"];
+    readonly jsTypes: readonly [{
+        readonly instanceof: "Array";
+        readonly typeof: "object";
+    }];
     readonly kind = "Set";
+    readonly minCount: bigint;
+    constructor({ minCount, ...superParameters }: {
+        minCount: bigint;
+    } & ConstructorParameters<typeof AbstractCollectionType<ItemTypeT>>[0]);
+    get conversionFunction(): Maybe<AbstractCollectionType.ConversionFunction>;
+    get fromRdfResourceValuesFunction(): Code;
+    get toRdfResourceValueTypes(): AbstractCollectionType<ItemTypeT>["toRdfResourceValueTypes"];
     get valueSparqlConstructTriplesFunction(): Code;
     get valueSparqlWherePatternsFunction(): Code;
-    fromRdfResourceValuesExpression(parameters: Parameters<AbstractCollectionType<ItemTypeT>["fromRdfResourceValuesExpression"]>[0]): Code;
+    protected get schemaInitializers(): readonly Code[];
+    fromJsonExpression({ variables, }: Parameters<AbstractContainerType<ItemTypeT>["fromJsonExpression"]>[0]): Code;
+    jsonSchema(parameters: Parameters<AbstractContainerType<ItemTypeT>["jsonSchema"]>[0]): Code;
     jsonType(): AbstractCollectionType.JsonType;
     toRdfResourceValuesExpression({ variables, }: Parameters<AbstractCollectionType<ItemTypeT>["toRdfResourceValuesExpression"]>[0]): Code;
     toStringExpression({ variables, }: Parameters<AbstractCollectionType<ItemTypeT>["toStringExpression"]>[0]): Code;
 }
 export declare namespace SetType {
     type ItemType = AbstractCollectionType.ItemType;
-    const isItemType: typeof import("./AbstractContainerType.js").AbstractContainerType.isItemType;
+    const isItemType: typeof AbstractContainerType.isItemType;
 }
 //# sourceMappingURL=SetType.d.ts.map

package/dist/generators/ts/SetType.js

@@ -5,28 +5,98 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
 import { Maybe } from "purify-ts";
+import { invariant } from "ts-invariant";
 import { Memoize } from "typescript-memoize";
 import { AbstractCollectionType } from "./AbstractCollectionType.js";
-import { code, joinCode } from "./ts-poet-wrapper.js";
+import { code, joinCode, literalOf } from "./ts-poet-wrapper.js";
 export class SetType extends AbstractCollectionType {
     graphqlArgs = Maybe.empty();
+    jsTypes = [
+        { instanceof: "Array", typeof: "object" },
+    ];
     kind = "Set";
+    minCount;
+    constructor({ minCount, ...superParameters }) {
+        super(superParameters);
+        this.minCount = minCount;
+        invariant(this.minCount >= 0n);
+        if (this._mutable) {
+            invariant(this.minCount === 0n);
+        }
+    }
+    get conversionFunction() {
+        const itemConversionFunction = this.itemType.conversionFunction.orDefault(this.itemConversionFunctionDefault);
+        let conversionFunction;
+        const sourceTypes = [];
+        if (itemConversionFunction.sourceTypes.some((sourceType) => sourceType.jsType.typeof === "object" &&
+            sourceType.jsType.instanceof === "Array")) {
+            conversionFunction = this.reusables.snippets.convertToArraySet;
+        }
+        else {
+            conversionFunction = this.reusables.snippets.convertToScalarSet;
+            // Convert from a single item
+            sourceTypes.push(...itemConversionFunction.sourceTypes);
+        }
+        // Convert from an array of items
+        sourceTypes.push({
+            expression: code `readonly (${joinCode(itemConversionFunction.sourceTypes.map((itemSourceType) => code `${itemSourceType.expression}`), { on: " | " })})[]`,
+            jsType: { instanceof: "Array", typeof: "object" },
+        });
+        // Convert from undefined to an empty array
+        if (this.minCount === 0n) {
+            sourceTypes.push({
+                expression: code `undefined`,
+                jsType: { typeof: "undefined" },
+            });
+        }
+        return Maybe.of({
+            code: code `${conversionFunction}(${itemConversionFunction.code}, ${literalOf(!this._mutable)})`,
+            sourceTypes,
+        });
+    }
+    get fromRdfResourceValuesFunction() {
+        return code `${this._mutable ? this.reusables.snippets.mutableSetFromRdfResourceValues : this.reusables.snippets.setFromRdfResourceValues}<${this.itemType.expression}, ${this.itemType.schemaType}>(${this.itemType.fromRdfResourceValuesFunction})`;
+    }
+    get toRdfResourceValueTypes() {
+        return this.itemType.toRdfResourceValueTypes;
+    }
     get valueSparqlConstructTriplesFunction() {
         return code `${this.reusables.snippets.setSparqlConstructTriples}<${this.itemType.filterType}, ${this.itemType.schemaType}>(${this.itemType.valueSparqlConstructTriplesFunction})`;
     }
     get valueSparqlWherePatternsFunction() {
         return code `${this.reusables.snippets.setSparqlWherePatterns}<${this.itemType.filterType}, ${this.itemType.schemaType}>(${this.itemType.valueSparqlWherePatternsFunction})`;
     }
-    fromRdfResourceValuesExpression(parameters) {
-        const { variables } = parameters;
-        return joinCode([
-            this.itemType.fromRdfResourceValuesExpression(parameters),
-            code `map(values => values.toArray()${this._mutable ? ".concat()" : ""})`,
-            code `map(valuesArray => ${this.reusables.imports.Resource}.Values.fromValue({ focusResource: ${variables.resource}, propertyPath: ${variables.propertyPath}, value: valuesArray }))`,
-        ], { on: "." });
+    get schemaInitializers() {
+        let schemaInitializers = super.schemaInitializers;
+        if (this.minCount > 0n) {
+            schemaInitializers = schemaInitializers.concat(code `minCount: ${Number(this.minCount)}`);
+        }
+        return schemaInitializers;
+    }
+    fromJsonExpression({ variables, }) {
+        let expression = variables.value;
+        if (this.minCount === 0n) {
+            expression = code `(${expression} ?? [])`;
+        }
+        return code `${this.reusables.imports.Either}.sequence<Error, ${this.itemType.expression}>(${expression}.map(item => (${this.itemType.fromJsonExpression({
+            variables: { value: code `item` },
+        })})))`;
+    }
+    jsonSchema(parameters) {
+        let schema = code `${this.itemType.jsonSchema(parameters)}.array()`;
+        if (this.minCount > 0n) {
+            schema = code `${schema}.nonempty().min(${this.minCount})`;
+        }
+        else {
+            schema = code `${schema}.optional()`;
+        }
+        if (!this._mutable) {
+            schema = code `${schema}.readonly()`;
+        }
+        return schema;
     }
     jsonType() {
-        const name = code `${!this.mutable ? "readonly " : ""}(${this.itemType.jsonType().name})[]`;
+        const name = code `${!this.mutable ? "readonly " : ""}(${this.itemType.jsonType().expression})[]`;
         if (this.minCount === 0n) {
             return new AbstractCollectionType.JsonType(name, { optional: true });
         }
@@ -41,6 +111,12 @@ export class SetType extends AbstractCollectionType {
         return code `(${variables.value}.length > 0 ? \`[\${${variables.value}.map(item => (${this.itemType.toStringExpression({ variables: { value: code `item` } })}))}]\` : undefined)`;
     }
 }
+__decorate([
+    Memoize()
+], SetType.prototype, "conversionFunction", null);
+__decorate([
+    Memoize()
+], SetType.prototype, "fromRdfResourceValuesFunction", null);
 __decorate([
     Memoize()
 ], SetType.prototype, "valueSparqlConstructTriplesFunction", null);

package/dist/generators/ts/Snippets.d.ts

@@ -34,9 +34,9 @@ export declare class Snippets {
     get IdentifierSet(): Snippet;
     get IriFilter(): Snippet;
     get IriSchema(): Snippet;
-    get LazyObject(): Snippet;
-    get LazyObjectOption(): Snippet;
-    get LazyObjectSet(): Snippet;
+    get Lazy(): Snippet;
+    get LazyOption(): Snippet;
+    get LazySet(): Snippet;
     get LiteralFilter(): Snippet;
     get LiteralSchema(): Snippet;
     get MaybeFilter(): Snippet;
@@ -63,29 +63,38 @@ export declare class Snippets {
     get _ToRdfResourceFunction(): Snippet;
     get arrayEquals(): Snippet;
     get arrayIntersection(): Snippet;
+    get bigDecimalFromRdfResourceValues(): Snippet;
     get bigDecimalLiteral(): Snippet;
     get bigDecimalSparqlWherePatterns(): Snippet;
+    get bigIntFromRdfResourceValues(): Snippet;
+    get blankNodeFromRdfResourceValues(): Snippet;
     get blankNodeSparqlWherePatterns(): Snippet;
     get booleanEquals(): Snippet;
+    get booleanFromRdfResourceValues(): Snippet;
     get booleanSparqlWherePatterns(): Snippet;
     get compactRecord(): Snippet;
-    get convertToArray(): Snippet;
+    get convertToArraySet(): Snippet;
     get convertToBlankNode(): Snippet;
     get convertToBlankNodeIdentifierProperty(): Snippet;
     get convertToIdentifier(): Snippet;
     get convertToIdentifierProperty(): Snippet;
     get convertToIri(): Snippet;
     get convertToIriIdentifierProperty(): Snippet;
-    get convertToLazyObject(): Snippet;
-    get convertToLazyObjectOption(): Snippet;
-    get convertToLazyObjectSet(): Snippet;
+    get convertToLazy(): Snippet;
+    get convertToLazyOption(): Snippet;
+    get convertToLazySet(): Snippet;
+    get convertToList(): Snippet;
     get convertToLiteral(): Snippet;
     get convertToMaybe(): Snippet;
+    get convertToScalarSet(): Snippet;
     get convertWithDefaultValue(): Snippet;
     get dateEquals(): Snippet;
+    get dateFromRdfResourceValues(): Snippet;
     get dateSparqlWherePatterns(): Snippet;
+    get dateTimeFromRdfResourceValues(): Snippet;
     get decodeBigDecimalLiteral(): Snippet;
     get deduplicateSparqlPatterns(): Snippet;
+    get defaultValueFromRdfResourceValues(): Snippet;
     get defaultValueSparqlWherePatterns(): Snippet;
     get ensureRdfResourceType(): Snippet;
     get filterArray(): Snippet;
@@ -100,8 +109,7 @@ export declare class Snippets {
     get filterNumeric(): Snippet;
     get filterString(): Snippet;
     get filterTerm(): Snippet;
-    get fromRdfLanguageIn(): Snippet;
-    get fromRdfPreferredLanguages(): Snippet;
+    get floatFromRdfResourceValues(): Snippet;
     get hashArray(): Snippet;
     get hashBigDecimal(): Snippet;
     get hashBoolean(): Snippet;
@@ -111,27 +119,36 @@ export declare class Snippets {
     get hashNumeric(): Snippet;
     get hashString(): Snippet;
     get hashTerm(): Snippet;
+    get identifierFromRdfResourceValues(): Snippet;
     get identifierSparqlWherePatterns(): Snippet;
     get identityConversionFunction(): Snippet;
     get identityValidationFunction(): Snippet;
     get ifUsed(): Code[];
+    get intFromRdfResourceValues(): Snippet;
+    get iriFromRdfResourceValues(): Snippet;
     get iriSparqlWherePatterns(): Snippet;
     get liftSparqlPatterns(): Snippet;
+    get listFromRdfResourceValues(): Snippet;
     get listSparqlConstructTriples(): Snippet;
     get listSparqlWherePatterns(): Snippet;
     get literalFactory(): Snippet;
+    get literalFromRdfResourceValues(): Snippet;
     get literalSchemaSparqlPatterns(): Snippet;
     get literalSparqlWherePatterns(): Snippet;
     get maybeEquals(): Snippet;
+    get maybeFromRdfResourceValues(): Snippet;
     get maybeSparqlConstructTriples(): Snippet;
     get maybeSparqlWherePatterns(): Snippet;
     get monkeyPatchObject(): Snippet;
+    get mutableListFromRdfResourceValues(): Snippet;
+    get mutableSetFromRdfResourceValues(): Snippet;
     get normalizeSparqlWherePatterns(): Snippet;
     get numericSparqlWherePatterns(): Snippet;
     get parseBlankNode(): Snippet;
     get parseIdentifier(): Snippet;
     get parseIri(): Snippet;
     get sequenceRecord(): Snippet;
+    get setFromRdfResourceValues(): Snippet;
     get setSparqlConstructTriples(): Snippet;
     get setSparqlWherePatterns(): Snippet;
     get shaclPropertyFromRdf(): Snippet;
@@ -142,8 +159,11 @@ export declare class Snippets {
     get sparqlPropertyPath(): Snippet;
     get sparqlValueInPattern(): Snippet;
     get strictEquals(): Snippet;
+    get stringFromRdfResourceValues(): Snippet;
     get stringSparqlWherePatterns(): Snippet;
     get termFilterSparqlPatterns(): Snippet;
+    get termFromRdfResourceValues(): Snippet;
+    get termLikeFromRdfResourceValues(): Snippet;
     get termSchemaSparqlPatterns(): Snippet;
     get termSparqlWherePatterns(): Snippet;
     get toIsoDateString(): Snippet;