@shaclmate/compiler 3.0.3 → 4.0.0

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

@@ -1,31 +1,37 @@
-import { Maybe } from "purify-ts";
-import { Import } from "./Import.js";
-import { Type } from "./Type.js";
-export declare class OptionType<ItemTypeT extends Type> extends Type {
-    readonly discriminatorProperty: Maybe<Type.DiscriminatorProperty>;
-    readonly itemType: ItemTypeT;
+import { Maybe, NonEmptyList } from "purify-ts";
+import { AbstractContainerType } from "./AbstractContainerType.js";
+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 kind = "OptionType";
-    readonly typeof = "object";
-    constructor({ itemType }: {
-        itemType: ItemTypeT;
-    });
-    get conversions(): readonly Type.Conversion[];
-    get equalsFunction(): string;
-    get graphqlName(): Type.GraphqlName;
-    get jsonName(): Type.JsonName;
+    readonly typeofs: NonEmptyList<"object">;
+    get conversions(): readonly AbstractContainerType.Conversion[];
+    get equalsFunction(): Code;
+    get filterFunction(): Code;
+    get filterType(): Code;
+    get graphqlType(): AbstractContainerType.GraphqlType;
     get mutable(): boolean;
-    get name(): string;
-    fromJsonExpression({ variables, }: Parameters<Type["fromJsonExpression"]>[0]): string;
-    fromRdfExpression(parameters: Parameters<Type["fromRdfExpression"]>[0]): string;
-    graphqlResolveExpression(parameters: Parameters<Type["graphqlResolveExpression"]>[0]): string;
-    hashStatements({ depth, variables, }: Parameters<Type["hashStatements"]>[0]): readonly string[];
-    jsonUiSchemaElement(parameters: Parameters<Type["jsonUiSchemaElement"]>[0]): ReturnType<Type["jsonUiSchemaElement"]>;
-    jsonZodSchema(parameters: Parameters<Type["jsonZodSchema"]>[0]): ReturnType<Type["jsonZodSchema"]>;
-    snippetDeclarations(parameters: Parameters<Type["snippetDeclarations"]>[0]): readonly string[];
-    sparqlConstructTemplateTriples(parameters: Parameters<Type["sparqlConstructTemplateTriples"]>[0]): readonly string[];
-    sparqlWherePatterns(parameters: Parameters<Type["sparqlWherePatterns"]>[0]): readonly string[];
-    toJsonExpression({ variables, }: Parameters<Type["toJsonExpression"]>[0]): string;
-    toRdfExpression({ variables, }: Parameters<Type["toRdfExpression"]>[0]): string;
-    useImports(parameters: Parameters<Type["useImports"]>[0]): readonly Import[];
+    get name(): Code;
+    get schemaType(): Code;
+    get sparqlConstructTriplesFunction(): Code;
+    get sparqlWherePatternsFunction(): Code;
+    protected get schemaObject(): {
+        kind: Code;
+        item: Code;
+    };
+    fromJsonExpression({ variables, }: Parameters<AbstractContainerType<ItemTypeT>["fromJsonExpression"]>[0]): Code;
+    fromRdfExpression(parameters: Parameters<AbstractContainerType<ItemTypeT>["fromRdfExpression"]>[0]): Code;
+    graphqlResolveExpression(parameters: Parameters<AbstractContainerType<ItemTypeT>["graphqlResolveExpression"]>[0]): Code;
+    hashStatements({ depth, variables, }: Parameters<AbstractContainerType<ItemTypeT>["hashStatements"]>[0]): readonly Code[];
+    jsonType(parameters?: Parameters<AbstractContainerType<ItemTypeT>["jsonType"]>[0]): AbstractContainerType.JsonType;
+    jsonUiSchemaElement(parameters: Parameters<AbstractContainerType<ItemTypeT>["jsonUiSchemaElement"]>[0]): Maybe<Code>;
+    jsonZodSchema(parameters: Parameters<AbstractContainerType<ItemTypeT>["jsonZodSchema"]>[0]): Code;
+    toJsonExpression({ variables, }: Parameters<AbstractContainerType<ItemTypeT>["toJsonExpression"]>[0]): Code;
+    toRdfExpression({ variables, }: Parameters<AbstractContainerType<ItemTypeT>["toRdfExpression"]>[0]): Code;
+}
+export declare namespace OptionType {
+    type ItemType = AbstractContainerType.ItemType;
+    const isItemType: typeof AbstractContainerType.isItemType;
 }
 //# sourceMappingURL=OptionType.d.ts.map

package/dist/generators/ts/OptionType.js

@@ -4,148 +4,140 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
-import { Memoize } from "typescript-memoize";
-import { Maybe } from "purify-ts";
+import { Maybe, NonEmptyList } from "purify-ts";
 import { invariant } from "ts-invariant";
-import { Import } from "./Import.js";
-import { SnippetDeclarations } from "./SnippetDeclarations.js";
-import { Type } from "./Type.js";
-import { syntheticNamePrefix } from "./syntheticNamePrefix.js";
-export class OptionType extends Type {
-    discriminatorProperty = Maybe.empty();
-    itemType;
+import { Memoize } from "typescript-memoize";
+import { AbstractCollectionType } from "./AbstractCollectionType.js";
+import { AbstractContainerType } from "./AbstractContainerType.js";
+import { codeEquals } from "./codeEquals.js";
+import { imports } from "./imports.js";
+import { snippets } from "./snippets.js";
+import { code, joinCode, literalOf } from "./ts-poet-wrapper.js";
+export class OptionType extends AbstractContainerType {
+    discriminantProperty = Maybe.empty();
+    graphqlArgs = Maybe.empty();
     kind = "OptionType";
-    typeof = "object";
-    constructor({ itemType }) {
-        super();
-        this.itemType = itemType;
-    }
+    typeofs = NonEmptyList(["object"]);
     get conversions() {
         const conversions = [];
         conversions.push({
             conversionExpression: (value) => value,
-            sourceTypeCheckExpression: (value) => `purify.Maybe.isMaybe(${value})`,
+            sourceTypeCheckExpression: (value) => code `${imports.Maybe}.isMaybe(${value})`,
             sourceTypeName: this.name,
+            sourceTypeof: "object",
         });
         for (const itemTypeConversion of this.itemType.conversions) {
             conversions.push({
                 ...itemTypeConversion,
-                conversionExpression: (value) => `purify.Maybe.of(${itemTypeConversion.conversionExpression(value)})`,
+                conversionExpression: (value) => code `${imports.Maybe}.of(${itemTypeConversion.conversionExpression(value)})`,
             });
         }
-        if (!conversions.some((conversion) => conversion.sourceTypeName === "undefined")) {
+        // Unless itemType is a list, it should only have a conversion from undefined if it has a
+        // defaultValue. Per the CST->AST transformation logic, a type with a defaultValue
+        // should never be wrapped in an OptionType.
+        invariant(!conversions.some((conversion) => conversion.sourceTypeof === "undefined") || this.itemType instanceof AbstractCollectionType);
+        if (!conversions.some((conversion) => conversion.sourceTypeof === "undefined")) {
             conversions.push({
-                conversionExpression: () => "purify.Maybe.empty()",
-                sourceTypeCheckExpression: (value) => `typeof ${value} === "undefined"`,
-                sourceTypeName: "undefined",
+                conversionExpression: () => code `${imports.Maybe}.empty()`,
+                sourceTypeCheckExpression: (value) => code `${value} === undefined`,
+                sourceTypeName: code `undefined`,
+                sourceTypeof: "undefined",
             });
         }
         return conversions;
     }
     get equalsFunction() {
-        return `((left, right) => ${syntheticNamePrefix}maybeEquals(left, right, ${this.itemType.equalsFunction}))`;
+        return code `((left, right) => ${snippets.maybeEquals}(left, right, ${this.itemType.equalsFunction}))`;
     }
-    get graphqlName() {
-        invariant(!this.itemType.graphqlName.nullable);
-        return new Type.GraphqlName(this.itemType.graphqlName.toString(), {
-            nullable: true,
-        });
+    get filterFunction() {
+        return code `${snippets.filterMaybe}<${this.itemType.name}, ${this.itemType.filterType}>(${this.itemType.filterFunction})`;
     }
-    get jsonName() {
-        invariant(!this.itemType.jsonName.optional);
-        return new Type.JsonName(this.itemType.jsonName.toString(), {
-            optional: true,
+    get filterType() {
+        return code `${snippets.MaybeFilter}<${this.itemType.filterType}>`;
+    }
+    get graphqlType() {
+        invariant(!this.itemType.graphqlType.nullable);
+        return new AbstractContainerType.GraphqlType(this.itemType.graphqlType.name, {
+            nullable: true,
         });
     }
     get mutable() {
         return this.itemType.mutable;
     }
     get name() {
-        return `purify.Maybe<${this.itemType.name}>`;
+        return code `${imports.Maybe}<${this.itemType.name}>`;
+    }
+    get schemaType() {
+        return code `${snippets.MaybeSchema}<${this.itemType.schemaType}>`;
+    }
+    get sparqlConstructTriplesFunction() {
+        return code `${snippets.maybeSparqlConstructTriples}<${this.itemType.filterType}, ${this.itemType.schemaType}>(${this.itemType.sparqlConstructTriplesFunction})`;
+    }
+    get sparqlWherePatternsFunction() {
+        return code `${snippets.maybeSparqlWherePatterns}<${this.itemType.filterType}, ${this.itemType.schemaType}>(${this.itemType.sparqlWherePatternsFunction})`;
+    }
+    get schemaObject() {
+        return {
+            ...super.schemaObject,
+            kind: code `${literalOf("Maybe")} as const`,
+        };
     }
     fromJsonExpression({ variables, }) {
-        const expression = `purify.Maybe.fromNullable(${variables.value})`;
+        const expression = code `${imports.Maybe}.fromNullable(${variables.value})`;
+        const valueVariable = code `item`;
         const itemFromJsonExpression = this.itemType.fromJsonExpression({
-            variables: { value: "item" },
+            variables: { value: valueVariable },
         });
-        return itemFromJsonExpression === "item"
+        return codeEquals(itemFromJsonExpression, valueVariable)
             ? expression
-            : `${expression}.map(item => (${itemFromJsonExpression}))`;
+            : code `${expression}.map(item => (${itemFromJsonExpression}))`;
     }
     fromRdfExpression(parameters) {
         const { variables } = parameters;
-        return `${this.itemType.fromRdfExpression(parameters)}.map(values => values.length > 0 ? values.map(value => purify.Maybe.of(value)) : rdfjsResource.Resource.Values.fromValue<purify.Maybe<${this.itemType.name}>>({ object: purify.Maybe.empty(), predicate: ${variables.predicate}, subject: ${variables.resource} }))`;
+        return code `${this.itemType.fromRdfExpression(parameters)}.map(values => values.length > 0 ? values.map(value => ${imports.Maybe}.of(value)) : ${imports.Resource}.Values.fromValue<${imports.Maybe}<${this.itemType.name}>>({ focusResource: ${variables.resource}, propertyPath: ${variables.propertyPath}, value: ${imports.Maybe}.empty() }))`;
     }
     graphqlResolveExpression(parameters) {
-        return `${this.itemType.graphqlResolveExpression(parameters)}.extractNullable()`;
+        return code `${this.itemType.graphqlResolveExpression(parameters)}.extractNullable()`;
     }
     hashStatements({ depth, variables, }) {
         return [
-            `${variables.value}.ifJust((value${depth}) => { ${this.itemType
+            code `${variables.value}.ifJust((value${depth}) => { ${joinCode(this.itemType
                 .hashStatements({
                 depth: depth + 1,
                 variables: {
                     hasher: variables.hasher,
-                    value: `value${depth}`,
+                    value: code `value${depth}`,
                 },
             })
-                .join("\n")} })`,
+                .concat())} });`,
         ];
     }
+    jsonType(parameters) {
+        const itemTypeJsonType = this.itemType.jsonType(parameters);
+        invariant(!itemTypeJsonType.optional);
+        return new AbstractContainerType.JsonType(itemTypeJsonType.name, {
+            optional: true,
+        });
+    }
     jsonUiSchemaElement(parameters) {
         return this.itemType.jsonUiSchemaElement(parameters);
     }
     jsonZodSchema(parameters) {
-        return `${this.itemType.jsonZodSchema(parameters)}.optional()`;
-    }
-    snippetDeclarations(parameters) {
-        const snippetDeclarations = this.itemType
-            .snippetDeclarations(parameters)
-            .concat();
-        if (parameters.features.has("equals")) {
-            snippetDeclarations.push(SnippetDeclarations.maybeEquals);
-        }
-        return snippetDeclarations;
-    }
-    sparqlConstructTemplateTriples(parameters) {
-        switch (parameters.context) {
-            case "object":
-                return super.sparqlConstructTemplateTriples(parameters);
-            case "subject":
-                return this.itemType.sparqlConstructTemplateTriples(parameters);
-        }
-    }
-    sparqlWherePatterns(parameters) {
-        switch (parameters.context) {
-            case "object": {
-                const patterns = this.itemType.sparqlWherePatterns(parameters);
-                if (patterns.length === 0) {
-                    return [];
-                }
-                return [`{ patterns: [${patterns.join(", ")}], type: "optional" }`];
-            }
-            case "subject": {
-                throw new Error("should never be called");
-                // return this.itemType.sparqlWherePatterns(parameters);
-            }
-        }
+        return code `${this.itemType.jsonZodSchema(parameters)}.optional()`;
     }
     toJsonExpression({ variables, }) {
-        return `${variables.value}.map(item => (${this.itemType.toJsonExpression({ variables: { value: "item" } })})).extract()`;
+        return code `${variables.value}.map(item => (${this.itemType.toJsonExpression({ variables: { value: code `item` } })})).extract()`;
     }
     toRdfExpression({ variables, }) {
         const itemTypeToRdfExpression = this.itemType.toRdfExpression({
-            variables: { ...variables, value: "value" },
+            variables: { ...variables, value: code `value` },
         });
-        let toRdfExpression = `${variables.value}.toList()`;
-        if (itemTypeToRdfExpression !== "[value]") {
-            toRdfExpression = `${toRdfExpression}.flatMap((value) => ${itemTypeToRdfExpression})`;
+        let toRdfExpression = code `${variables.value}.toList()`;
+        if (!codeEquals(itemTypeToRdfExpression, code `[value]`)) {
+            toRdfExpression = code `${toRdfExpression}.flatMap((value) => ${itemTypeToRdfExpression})`;
         }
         return toRdfExpression;
     }
-    useImports(parameters) {
-        return [...this.itemType.useImports(parameters), Import.PURIFY];
-    }
 }
 __decorate([
     Memoize()
@@ -155,11 +147,29 @@ __decorate([
 ], OptionType.prototype, "equalsFunction", null);
 __decorate([
     Memoize()
-], OptionType.prototype, "graphqlName", null);
+], OptionType.prototype, "filterFunction", null);
+__decorate([
+    Memoize()
+], OptionType.prototype, "filterType", null);
 __decorate([
     Memoize()
-], OptionType.prototype, "jsonName", null);
+], OptionType.prototype, "graphqlType", null);
 __decorate([
     Memoize()
 ], OptionType.prototype, "name", null);
+__decorate([
+    Memoize()
+], OptionType.prototype, "schemaType", null);
+__decorate([
+    Memoize()
+], OptionType.prototype, "sparqlConstructTriplesFunction", null);
+__decorate([
+    Memoize()
+], OptionType.prototype, "sparqlWherePatternsFunction", null);
+__decorate([
+    Memoize()
+], OptionType.prototype, "jsonType", null);
+(function (OptionType) {
+    OptionType.isItemType = AbstractContainerType.isItemType;
+})(OptionType || (OptionType = {}));
 //# sourceMappingURL=OptionType.js.map

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

@@ -1,35 +1,16 @@
-import { Maybe } from "purify-ts";
-import type { Import } from "./Import.js";
-import { Type } from "./Type.js";
-export declare class SetType<ItemTypeT extends Type> extends Type {
-    readonly discriminatorProperty: Maybe<Type.DiscriminatorProperty>;
-    readonly itemType: ItemTypeT;
-    private readonly _mutable;
-    private readonly minCount;
+import { AbstractCollectionType } from "./AbstractCollectionType.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 kind = "SetType";
-    readonly typeof = "object";
-    constructor({ itemType, minCount, mutable, }: {
-        itemType: ItemTypeT;
-        mutable: boolean;
-        minCount: number;
-    });
-    get conversions(): readonly Type.Conversion[];
-    get equalsFunction(): string;
-    get graphqlName(): Type.GraphqlName;
-    get jsonName(): Type.JsonName;
-    get mutable(): boolean;
-    get name(): string;
-    fromJsonExpression({ variables, }: Parameters<Type["fromJsonExpression"]>[0]): string;
-    fromRdfExpression(parameters: Parameters<Type["fromRdfExpression"]>[0]): string;
-    graphqlResolveExpression({ variables, }: Parameters<Type["graphqlResolveExpression"]>[0]): string;
-    hashStatements({ depth, variables, }: Parameters<Type["hashStatements"]>[0]): readonly string[];
-    jsonUiSchemaElement(parameters: Parameters<Type["jsonUiSchemaElement"]>[0]): ReturnType<Type["jsonUiSchemaElement"]>;
-    jsonZodSchema(parameters: Parameters<Type["jsonZodSchema"]>[0]): ReturnType<Type["jsonZodSchema"]>;
-    snippetDeclarations(parameters: Parameters<Type["snippetDeclarations"]>[0]): readonly string[];
-    sparqlConstructTemplateTriples(parameters: Parameters<Type["sparqlConstructTemplateTriples"]>[0]): readonly string[];
-    sparqlWherePatterns(parameters: Parameters<Type["sparqlWherePatterns"]>[0]): readonly string[];
-    toJsonExpression({ variables, }: Parameters<Type["toJsonExpression"]>[0]): string;
-    toRdfExpression({ variables, }: Parameters<Type["toRdfExpression"]>[0]): string;
-    useImports(parameters: Parameters<Type["useImports"]>[0]): readonly Import[];
+    get sparqlConstructTriplesFunction(): Code;
+    get sparqlWherePatternsFunction(): Code;
+    fromRdfExpression(parameters: Parameters<AbstractCollectionType<ItemTypeT>["fromRdfExpression"]>[0]): Code;
+    jsonType(): AbstractCollectionType.JsonType;
+    toRdfExpression({ variables, }: Parameters<AbstractCollectionType<ItemTypeT>["toRdfExpression"]>[0]): Code;
+}
+export declare namespace SetType {
+    type ItemType = AbstractCollectionType.ItemType;
+    const isItemType: typeof import("./AbstractContainerType.js").AbstractContainerType.isItemType;
 }
 //# sourceMappingURL=SetType.d.ts.map

package/dist/generators/ts/SetType.js

@@ -5,188 +5,55 @@ 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 { SnippetDeclarations } from "./SnippetDeclarations.js";
-import { Type } from "./Type.js";
-import { syntheticNamePrefix } from "./syntheticNamePrefix.js";
-export class SetType extends Type {
-    discriminatorProperty = Maybe.empty();
-    itemType;
-    _mutable;
-    minCount;
+import { AbstractCollectionType } from "./AbstractCollectionType.js";
+import { imports } from "./imports.js";
+import { snippets } from "./snippets.js";
+import { code, joinCode } from "./ts-poet-wrapper.js";
+export class SetType extends AbstractCollectionType {
+    graphqlArgs = Maybe.empty();
     kind = "SetType";
-    typeof = "object";
-    constructor({ itemType, minCount, mutable, }) {
-        super();
-        this.itemType = itemType;
-        this.minCount = minCount;
-        invariant(this.minCount >= 0);
-        this._mutable = mutable;
+    get sparqlConstructTriplesFunction() {
+        return code `${snippets.setSparqlConstructTriples}<${this.itemType.filterType}, ${this.itemType.schemaType}>(${this.itemType.sparqlConstructTriplesFunction})`;
     }
-    get conversions() {
-        const conversions = [];
-        if (this.minCount === 0) {
-            conversions.push({
-                conversionExpression: () => "[]",
-                sourceTypeCheckExpression: (value) => `typeof ${value} === "undefined"`,
-                sourceTypeName: "undefined",
-            });
-            conversions.push({
-                // Defensive copy
-                conversionExpression: (value) => `${value}${this.mutable ? ".concat()" : ""}`,
-                // Array.isArray doesn't narrow correctly
-                // sourceTypeCheckExpression: (value) => `Array.isArray(${value})`,
-                sourceTypeCheckExpression: (value) => `typeof ${value} === "object"`,
-                sourceTypeName: `readonly (${this.itemType.name})[]`,
-            });
-        }
-        else {
-            conversions.push({
-                conversionExpression: (value) => value,
-                sourceTypeCheckExpression: (value) => `purify.NonEmptyList.isNonEmpty(${value})`,
-                sourceTypeName: this.name,
-            });
-        }
-        return conversions;
-    }
-    get equalsFunction() {
-        return `((left, right) => ${syntheticNamePrefix}arrayEquals(left, right, ${this.itemType.equalsFunction}))`;
-    }
-    get graphqlName() {
-        return new Type.GraphqlName(`new graphql.GraphQLList(${this.itemType.graphqlName})`);
-    }
-    get jsonName() {
-        const name = `readonly (${this.itemType.jsonName})[]`;
-        if (this.minCount === 0) {
-            return new Type.JsonName(name, { optional: true });
-        }
-        return new Type.JsonName(name);
-    }
-    get mutable() {
-        return this._mutable || this.itemType.mutable;
-    }
-    get name() {
-        if (this._mutable) {
-            return `(${this.itemType.name})[]`;
-        }
-        if (this.minCount === 0) {
-            return `readonly (${this.itemType.name})[]`;
-        }
-        return `purify.NonEmptyList<${this.itemType.name}>`;
-    }
-    fromJsonExpression({ variables, }) {
-        let expression = variables.value;
-        if (!this._mutable && this.minCount > 0) {
-            expression = `purify.NonEmptyList.fromArray(${expression}).unsafeCoerce()`;
-        }
-        const itemFromJsonExpression = this.itemType.fromJsonExpression({
-            variables: { value: "item" },
-        });
-        return itemFromJsonExpression === "item"
-            ? expression
-            : `${expression}.map(item => (${itemFromJsonExpression}))`;
+    get sparqlWherePatternsFunction() {
+        return code `${snippets.setSparqlWherePatterns}<${this.itemType.filterType}, ${this.itemType.schemaType}>(${this.itemType.sparqlWherePatternsFunction})`;
     }
     fromRdfExpression(parameters) {
         const { variables } = parameters;
         const chain = [this.itemType.fromRdfExpression(parameters)];
         if (this.minCount === 0 || this._mutable) {
-            chain.push(`map(values => values.toArray()${this._mutable ? ".concat()" : ""})`);
-        }
-        else {
-            chain.push(`chain(values => purify.NonEmptyList.fromArray(values.toArray()).toEither(new Error(\`\${rdfjsResource.Resource.Identifier.toString(${variables.resource}.identifier)} is an empty set\`)))`);
-        }
-        chain.push(`map(valuesArray => rdfjsResource.Resource.Values.fromValue({ object: valuesArray , predicate: ${variables.predicate}, subject: ${variables.resource} }))`);
-        return chain.join(".");
-    }
-    graphqlResolveExpression({ variables, }) {
-        return variables.value;
-    }
-    hashStatements({ depth, variables, }) {
-        return [
-            `for (const item${depth} of ${variables.value}) { ${this.itemType
-                .hashStatements({
-                depth: depth + 1,
-                variables: {
-                    hasher: variables.hasher,
-                    value: `item${depth}`,
-                },
-            })
-                .join("\n")} }`,
-        ];
-    }
-    jsonUiSchemaElement(parameters) {
-        return this.itemType.jsonUiSchemaElement(parameters);
-    }
-    jsonZodSchema(parameters) {
-        let schema = `${this.itemType.jsonZodSchema(parameters)}.array()`;
-        if (this.minCount > 0) {
-            schema = `${schema}.nonempty().min(${this.minCount})`;
+            chain.push(code `map(values => values.toArray()${this._mutable ? ".concat()" : ""})`);
         }
         else {
-            schema = `${schema}.default(() => [])`;
-        }
-        return schema;
-    }
-    snippetDeclarations(parameters) {
-        const snippetDeclarations = this.itemType
-            .snippetDeclarations(parameters)
-            .concat();
-        if (parameters.features.has("equals")) {
-            snippetDeclarations.push(SnippetDeclarations.arrayEquals);
+            chain.push(code `chain(values => ${imports.NonEmptyList}.fromArray(values.toArray()).toEither(new Error(\`\${${imports.Resource}.Identifier.toString(${variables.resource}.identifier)} is an empty set\`)))`);
         }
-        return snippetDeclarations;
+        chain.push(code `map(valuesArray => ${imports.Resource}.Values.fromValue({ focusResource: ${variables.resource}, propertyPath: ${variables.propertyPath}, value: valuesArray }))`);
+        return joinCode(chain, { on: "." });
     }
-    sparqlConstructTemplateTriples(parameters) {
-        switch (parameters.context) {
-            case "object":
-                return super.sparqlConstructTemplateTriples(parameters);
-            case "subject":
-                return this.itemType.sparqlConstructTemplateTriples(parameters);
-        }
-    }
-    sparqlWherePatterns(parameters) {
-        switch (parameters.context) {
-            case "object": {
-                const patterns = this.itemType.sparqlWherePatterns(parameters);
-                if (patterns.length === 0) {
-                    return [];
-                }
-                return this.minCount > 0
-                    ? patterns
-                    : [`{ patterns: [${patterns.join(", ")}], type: "optional" }`];
-            }
-            case "subject": {
-                throw new Error("should never be called");
-                // return this.itemType.sparqlWherePatterns(parameters);
-            }
+    jsonType() {
+        const name = code `readonly (${this.itemType.jsonType().name})[]`;
+        if (this.minCount === 0) {
+            return new AbstractCollectionType.JsonType(name, { optional: true });
         }
-    }
-    toJsonExpression({ variables, }) {
-        return `${variables.value}.map(item => (${this.itemType.toJsonExpression({ variables: { value: "item" } })}))`;
+        return new AbstractCollectionType.JsonType(name);
     }
     toRdfExpression({ variables, }) {
-        return `${variables.value}.flatMap((item) => ${this.itemType.toRdfExpression({
-            variables: { ...variables, value: "item" },
+        return code `${variables.value}.flatMap((item) => ${this.itemType.toRdfExpression({
+            variables: { ...variables, value: code `item` },
         })})`;
     }
-    useImports(parameters) {
-        return this.itemType.useImports(parameters);
-    }
 }
 __decorate([
     Memoize()
-], SetType.prototype, "conversions", null);
-__decorate([
-    Memoize()
-], SetType.prototype, "equalsFunction", null);
-__decorate([
-    Memoize()
-], SetType.prototype, "graphqlName", null);
+], SetType.prototype, "sparqlConstructTriplesFunction", null);
 __decorate([
     Memoize()
-], SetType.prototype, "jsonName", null);
+], SetType.prototype, "sparqlWherePatternsFunction", null);
 __decorate([
     Memoize()
-], SetType.prototype, "name", null);
+], SetType.prototype, "jsonType", null);
+(function (SetType) {
+    SetType.isItemType = AbstractCollectionType.isItemType;
+})(SetType || (SetType = {}));
 //# sourceMappingURL=SetType.js.map

package/dist/generators/ts/StringType.d.ts

@@ -1,15 +1,23 @@
-import { PrimitiveType } from "./PrimitiveType.js";
-import { Type } from "./Type.js";
-export declare class StringType extends PrimitiveType<string> {
+import { NonEmptyList } from "purify-ts";
+import { AbstractPrimitiveType } from "./AbstractPrimitiveType.js";
+import { type Code } from "./ts-poet-wrapper.js";
+export declare class StringType extends AbstractPrimitiveType<string> {
+    readonly filterFunction: Code;
+    readonly filterType: Code;
+    readonly graphqlType: import("./AbstractType.js").AbstractType.GraphqlType;
     readonly kind = "StringType";
-    readonly typeof = "string";
-    get conversions(): readonly Type.Conversion[];
-    get graphqlName(): Type.GraphqlName;
+    readonly schemaType: Code;
+    readonly sparqlWherePatternsFunction: Code;
+    readonly typeofs: NonEmptyList<"string">;
     get name(): string;
-    protected fromRdfExpressionChain({ variables, }: Parameters<PrimitiveType<string>["fromRdfExpressionChain"]>[0]): ReturnType<PrimitiveType<string>["fromRdfExpressionChain"]>;
-    hashStatements({ variables, }: Parameters<Type["hashStatements"]>[0]): readonly string[];
-    jsonZodSchema({ variables, }: Parameters<Type["jsonZodSchema"]>[0]): ReturnType<Type["jsonZodSchema"]>;
-    sparqlWherePatterns(parameters: Parameters<PrimitiveType<string>["sparqlWherePatterns"]>[0]): readonly string[];
-    toRdfExpression({ variables, }: Parameters<PrimitiveType<string>["toRdfExpression"]>[0]): string;
+    protected get schemaObject(): {
+        in: import("ts-poet/build/Node.js").Node[] | undefined;
+        languageIn: import("ts-poet/build/Node.js").Node[] | undefined;
+        kind: Code;
+    };
+    hashStatements({ variables, }: Parameters<AbstractPrimitiveType<string>["hashStatements"]>[0]): readonly Code[];
+    jsonZodSchema(_parameters: Parameters<AbstractPrimitiveType<string>["jsonZodSchema"]>[0]): Code;
+    toRdfExpression({ variables, }: Parameters<AbstractPrimitiveType<string>["toRdfExpression"]>[0]): Code;
+    protected fromRdfExpressionChain({ variables, }: Parameters<AbstractPrimitiveType<string>["fromRdfExpressionChain"]>[0]): ReturnType<AbstractPrimitiveType<string>["fromRdfExpressionChain"]>;
 }
 //# sourceMappingURL=StringType.d.ts.map