@shaclmate/compiler 2.0.12 → 2.0.14

package/generators/ts/PrimitiveType.js

@@ -1,41 +1,32 @@
 import { Maybe } from "purify-ts";
-import { fromRdf } from "rdf-literal";
 import { LiteralType } from "./LiteralType.js";
 export class PrimitiveType extends LiteralType {
-    get conversions() {
-        const conversions = [
-            {
-                conversionExpression: (value) => value,
-                sourceTypeName: this.name,
-            },
-        ];
-        this.defaultValue.ifJust((defaultValue) => {
-            conversions.push({
-                conversionExpression: () => fromRdf(defaultValue, true),
-                sourceTypeName: "undefined",
-            });
-        });
-        return conversions;
+    constructor({ primitiveDefaultValue, primitiveIn, ...superParameters }) {
+        super(superParameters);
+        this.equalsFunction = "purifyHelpers.Equatable.strictEquals";
+        this.primitiveDefaultValue = primitiveDefaultValue;
+        this.primitiveIn = primitiveIn;
     }
     get discriminatorProperty() {
         return Maybe.empty();
     }
-    get importStatements() {
+    get jsonName() {
+        return this.name;
+    }
+    get useImports() {
         return [];
     }
-    equalsFunction() {
-        return "purifyHelpers.Equatable.strictEquals";
-    }
-    toRdfExpression({ variables, }) {
-        return this.defaultValue
-            .map((defaultValue) => {
-            let primitiveDefaultValue = fromRdf(defaultValue, true);
-            if (typeof primitiveDefaultValue === "string") {
-                primitiveDefaultValue = `"${primitiveDefaultValue}"`;
-            }
-            return `${variables.value} !== ${primitiveDefaultValue} ? ${variables.value} : undefined`;
-        })
-            .orDefault(variables.value);
+    fromJsonExpression({ variables, }) {
+        return variables.value;
+    }
+    hashStatements({ variables, }) {
+        return [`${variables.hasher}.update(${variables.value}.toString());`];
+    }
+    toJsonExpression({ variables, }) {
+        return variables.value;
+    }
+    propertyFilterRdfResourceValuesExpression({ variables, }) {
+        return variables.resourceValues;
     }
 }
 //# sourceMappingURL=PrimitiveType.js.map

package/generators/ts/SetType.d.ts

@@ -1,3 +1,4 @@
+import type { Import } from "./Import.js";
 import { Type } from "./Type.js";
 export declare class SetType extends Type {
     readonly itemType: Type;
@@ -8,12 +9,19 @@ export declare class SetType extends Type {
         minCount: number;
     });
     get conversions(): readonly Type.Conversion[];
+    get equalsFunction(): string;
+    get jsonName(): string;
+    get mutable(): boolean;
     get name(): string;
-    chainSparqlGraphPatternExpression(parameters: Parameters<Type["chainSparqlGraphPatternExpression"]>[0]): ReturnType<Type["chainSparqlGraphPatternExpression"]>;
-    equalsFunction(): string;
+    get useImports(): readonly Import[];
+    fromJsonExpression({ variables, }: Parameters<Type["fromJsonExpression"]>[0]): string;
     fromRdfExpression({ variables, }: Parameters<Type["fromRdfExpression"]>[0]): string;
-    hashStatements({ variables, }: Parameters<Type["hashStatements"]>[0]): readonly string[];
-    propertySparqlGraphPatternExpression(parameters: Parameters<Type["propertySparqlGraphPatternExpression"]>[0]): Type.SparqlGraphPatternExpression | Type.SparqlGraphPatternsExpression;
+    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"]>;
+    sparqlConstructTemplateTriples({ context, variables, }: Parameters<Type["sparqlConstructTemplateTriples"]>[0]): readonly string[];
+    sparqlWherePatterns({ context, variables, }: Parameters<Type["sparqlWherePatterns"]>[0]): readonly string[];
+    toJsonExpression({ variables, }: Parameters<Type["toJsonExpression"]>[0]): string;
     toRdfExpression({ variables, }: Parameters<Type["toRdfExpression"]>[0]): string;
 }
 //# sourceMappingURL=SetType.d.ts.map

package/generators/ts/SetType.js

@@ -4,70 +4,144 @@ 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 { invariant } from "ts-invariant";
 import { Memoize } from "typescript-memoize";
 import { Type } from "./Type.js";
+import { objectInitializer } from "./objectInitializer.js";
 export class SetType extends Type {
     constructor({ itemType, minCount, ...superParameters }) {
         super(superParameters);
         this.kind = "SetType";
         this.itemType = itemType;
         this.minCount = minCount;
+        invariant(this.minCount >= 0);
     }
     get conversions() {
-        return [
-            {
+        const conversions = [];
+        if (this.minCount === 0) {
+            conversions.push({
                 conversionExpression: () => "[]",
+                sourceTypeCheckExpression: (value) => `typeof ${value} === "undefined"`,
                 sourceTypeName: "undefined",
-            },
-            {
+            });
+            conversions.push({
                 conversionExpression: (value) => value,
                 sourceTypeCheckExpression: (value) => `Array.isArray(${value})`,
+                sourceTypeName: `readonly (${this.itemType.name})[]`,
+            });
+        }
+        else {
+            conversions.push({
+                conversionExpression: (value) => value,
+                sourceTypeCheckExpression: (value) => `purify.NonEmptyList.isNonEmpty(${value})`,
                 sourceTypeName: this.name,
-            },
-        ];
-    }
-    get name() {
-        return `readonly (${this.itemType.name})[]`;
-    }
-    chainSparqlGraphPatternExpression(parameters) {
-        return this.itemType.chainSparqlGraphPatternExpression(parameters);
+            });
+        }
+        return conversions;
     }
-    equalsFunction() {
-        const itemTypeEqualsFunction = this.itemType.equalsFunction();
+    get equalsFunction() {
+        const itemTypeEqualsFunction = this.itemType.equalsFunction;
         if (itemTypeEqualsFunction === "purifyHelpers.Equatable.equals") {
             return "purifyHelpers.Equatable.arrayEquals";
         }
         return `(left, right) => purifyHelpers.Arrays.equals(left, right, ${itemTypeEqualsFunction})`;
     }
+    get jsonName() {
+        if (this.minCount === 0) {
+            return `readonly (${this.itemType.jsonName})[]`;
+        }
+        return `purify.NonEmptyList<${this.itemType.jsonName}>`;
+    }
+    get mutable() {
+        return this.itemType.mutable;
+    }
+    get name() {
+        if (this.minCount === 0) {
+            return `readonly (${this.itemType.name})[]`;
+        }
+        return `purify.NonEmptyList<${this.itemType.name}>`;
+    }
+    get useImports() {
+        return this.itemType.useImports;
+    }
+    fromJsonExpression({ variables, }) {
+        let expression = variables.value;
+        if (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}))`;
+    }
     fromRdfExpression({ variables, }) {
-        return `purify.Either.of([...${variables.resourceValues}.flatMap(value => ${this.itemType.fromRdfExpression({ variables: { ...variables, resourceValues: "value.toValues()" } })}.toMaybe().toList())])`;
+        const itemFromRdfExpression = this.itemType.fromRdfExpression({
+            variables: { ...variables, resourceValues: "_item.toValues()" },
+        });
+        if (this.minCount === 0) {
+            return `purify.Either.of([...${variables.resourceValues}.flatMap(_item => ${itemFromRdfExpression}.toMaybe().toList())])`;
+        }
+        return `purify.NonEmptyList.fromArray([...${variables.resourceValues}.flatMap(_item => ${itemFromRdfExpression}.toMaybe().toList())]).toEither(new rdfjsResource.Resource.ValueError(${objectInitializer({ focusResource: variables.resource, message: `\`\${rdfjsResource.Resource.Identifier.toString(${variables.resource}.identifier)} is empty\``, predicate: variables.predicate })}))`;
     }
-    hashStatements({ variables, }) {
+    hashStatements({ depth, variables, }) {
         return [
-            `for (const element of ${variables.value}) { ${this.itemType
+            `for (const _item${depth} of ${variables.value}) { ${this.itemType
                 .hashStatements({
+                depth: depth + 1,
                 variables: {
                     hasher: variables.hasher,
-                    value: "element",
+                    value: `_item${depth}`,
                 },
             })
                 .join("\n")} }`,
         ];
     }
-    propertySparqlGraphPatternExpression(parameters) {
-        if (this.minCount === 0) {
-            return new Type.SparqlGraphPatternExpression(`sparqlBuilder.GraphPattern.optional(${this.itemType.propertySparqlGraphPatternExpression(parameters).toSparqlGraphPatternExpression()})`);
+    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})`;
         }
-        return this.itemType.propertySparqlGraphPatternExpression(parameters);
+        return schema;
     }
-    toRdfExpression({ variables, }) {
-        const itemTypeToRdfExpression = this.itemType.toRdfExpression({
-            variables: { ...variables, value: "value" },
-        });
-        if (itemTypeToRdfExpression === "value") {
-            return variables.value;
+    sparqlConstructTemplateTriples({ context, variables, }) {
+        switch (context) {
+            case "property":
+                return super.sparqlConstructTemplateTriples({ context, variables });
+            case "type":
+                return this.itemType.sparqlConstructTemplateTriples({
+                    context,
+                    variables,
+                });
+        }
+    }
+    sparqlWherePatterns({ context, variables, }) {
+        switch (context) {
+            case "property": {
+                const patterns = super.sparqlWherePatterns({ context, variables });
+                if (patterns.length === 0) {
+                    return [];
+                }
+                return this.minCount > 0
+                    ? patterns
+                    : [`{ patterns: [${patterns.join(", ")}], type: "optional" }`];
+            }
+            case "type": {
+                return this.itemType.sparqlWherePatterns({ context, variables });
+            }
         }
-        return `${variables.value}.map((value) => ${itemTypeToRdfExpression})`;
+    }
+    toJsonExpression({ variables, }) {
+        return `${variables.value}.map(_item => (${this.itemType.toJsonExpression({ variables: { value: "_item" } })}))`;
+    }
+    toRdfExpression({ variables, }) {
+        return `${variables.value}.map((_item) => ${this.itemType.toRdfExpression({
+            variables: { ...variables, value: "_item" },
+        })})`;
     }
 }
 __decorate([

package/generators/ts/StringType.d.ts

@@ -1,7 +1,12 @@
 import { PrimitiveType } from "./PrimitiveType.js";
-export declare class StringType extends PrimitiveType {
+import type { Type } from "./Type.js";
+export declare class StringType extends PrimitiveType<string> {
+    readonly kind = "StringType";
+    get conversions(): readonly Type.Conversion[];
     get name(): string;
-    fromRdfResourceValueExpression({ variables, }: Parameters<PrimitiveType["fromRdfResourceValueExpression"]>[0]): string;
-    hashStatements({ variables, }: Parameters<PrimitiveType["hashStatements"]>[0]): readonly string[];
+    hashStatements({ variables, }: Parameters<Type["hashStatements"]>[0]): readonly string[];
+    jsonZodSchema({ variables, }: Parameters<Type["jsonZodSchema"]>[0]): ReturnType<Type["jsonZodSchema"]>;
+    propertyFromRdfResourceValueExpression({ variables, }: Parameters<PrimitiveType<string>["propertyFromRdfResourceValueExpression"]>[0]): string;
+    toRdfExpression({ variables, }: Parameters<PrimitiveType<string>["toRdfExpression"]>[0]): string;
 }
 //# sourceMappingURL=StringType.d.ts.map

package/generators/ts/StringType.js

@@ -1,13 +1,67 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    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 { PrimitiveType } from "./PrimitiveType.js";
+import { objectInitializer } from "./objectInitializer.js";
 export class StringType extends PrimitiveType {
+    constructor() {
+        super(...arguments);
+        this.kind = "StringType";
+    }
+    get conversions() {
+        const conversions = [
+            {
+                conversionExpression: (value) => value,
+                sourceTypeCheckExpression: (value) => `typeof ${value} === "string"`,
+                sourceTypeName: this.name,
+            },
+        ];
+        this.primitiveDefaultValue.ifJust((defaultValue) => {
+            conversions.push({
+                conversionExpression: () => `"${defaultValue}"`,
+                sourceTypeCheckExpression: (value) => `typeof ${value} === "undefined"`,
+                sourceTypeName: "undefined",
+            });
+        });
+        return conversions;
+    }
     get name() {
+        if (this.primitiveIn.length > 0) {
+            return this.primitiveIn.map((value) => `"${value}"`).join(" | ");
+        }
         return "string";
     }
-    fromRdfResourceValueExpression({ variables, }) {
-        return `${variables.resourceValue}.toString()`;
-    }
     hashStatements({ variables, }) {
         return [`${variables.hasher}.update(${variables.value});`];
     }
+    jsonZodSchema({ variables, }) {
+        switch (this.primitiveIn.length) {
+            case 0:
+                return `${variables.zod}.string()`;
+            case 1:
+                return `${variables.zod}.literal(${this.primitiveIn[0]})`;
+            default:
+                return `${variables.zod}.enum(${JSON.stringify(this.primitiveIn)})`;
+        }
+    }
+    propertyFromRdfResourceValueExpression({ variables, }) {
+        let expression = `${variables.resourceValue}.toString()`;
+        if (this.primitiveIn.length > 0) {
+            expression = `${expression}.chain(value => { switch (value) { ${this.primitiveIn.map((value) => `case "${value}":`).join(" ")} return purify.Either.of(value); default: return purify.Left(new rdfjsResource.Resource.MistypedValueError(${objectInitializer({ actualValue: "rdfLiteral.toRdf(value)", expectedValueType: JSON.stringify(this.name), focusResource: variables.resource, predicate: variables.predicate })})); } })`;
+        }
+        return expression;
+    }
+    toRdfExpression({ variables, }) {
+        return this.primitiveDefaultValue
+            .map((defaultValue) => `${variables.value} !== "${defaultValue}" ? ${variables.value} : undefined`)
+            .orDefault(variables.value);
+    }
 }
+__decorate([
+    Memoize()
+], StringType.prototype, "name", null);
 //# sourceMappingURL=StringType.js.map

package/generators/ts/TermType.d.ts

@@ -0,0 +1,52 @@
+import type { BlankNode, Literal, NamedNode } from "@rdfjs/types";
+import { Maybe } from "purify-ts";
+import { Import } from "./Import.js";
+import { Type } from "./Type.js";
+/**
+ * Abstract base class for IdentifierType and LiteralType.
+ */
+export declare class TermType<TermT extends BlankNode | Literal | NamedNode> extends Type {
+    readonly defaultValue: Maybe<TermT>;
+    readonly equalsFunction: string;
+    readonly hasValues: readonly TermT[];
+    readonly in_: readonly TermT[];
+    readonly mutable: boolean;
+    readonly nodeKinds: Set<TermT["termType"]>;
+    constructor({ defaultValue, hasValues, in_, nodeKinds, ...superParameters }: {
+        defaultValue: Maybe<TermT>;
+        hasValues: readonly TermT[];
+        in_: readonly TermT[];
+        nodeKinds: Set<TermT["termType"]>;
+    } & ConstructorParameters<typeof Type>[0]);
+    get conversions(): readonly Type.Conversion[];
+    get discriminatorProperty(): Maybe<Type.DiscriminatorProperty>;
+    get jsonName(): string;
+    get name(): string;
+    get useImports(): readonly Import[];
+    fromJsonExpression({ variables, }: Parameters<Type["fromJsonExpression"]>[0]): string;
+    fromRdfExpression({ variables, }: Parameters<Type["fromRdfExpression"]>[0]): string;
+    hashStatements({ variables, }: Parameters<Type["hashStatements"]>[0]): readonly string[];
+    jsonZodSchema({ variables, }: Parameters<Type["jsonZodSchema"]>[0]): ReturnType<Type["jsonZodSchema"]>;
+    sparqlWherePatterns(parameters: Parameters<Type["sparqlWherePatterns"]>[0]): readonly string[];
+    toJsonExpression({ variables, }: Parameters<Type["toJsonExpression"]>[0]): string;
+    toRdfExpression({ variables, }: Parameters<Type["toRdfExpression"]>[0]): string;
+    /**
+     * Filter the rdfjsResource.Resource.Values to those that are relevant to the type.
+     *
+     * This is done before
+     */
+    protected propertyFilterRdfResourceValuesExpression({ variables, }: Parameters<Type["fromRdfExpression"]>[0]): string;
+    /**
+     * Convert an rdfjsResource.Resource.Value to a value of this type.
+     * @param variables
+     * @protected
+     */
+    protected propertyFromRdfResourceValueExpression({ variables, }: {
+        variables: {
+            predicate: string;
+            resource: string;
+            resourceValue: string;
+        };
+    }): string;
+}
+//# sourceMappingURL=TermType.d.ts.map

package/generators/ts/TermType.js

@@ -0,0 +1,234 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    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 { xsd } from "@tpluscode/rdf-ns-builders";
+import { Maybe } from "purify-ts";
+import { invariant } from "ts-invariant";
+import { Memoize } from "typescript-memoize";
+import { Import } from "./Import.js";
+import { Type } from "./Type.js";
+import { objectInitializer } from "./objectInitializer.js";
+/**
+ * Abstract base class for IdentifierType and LiteralType.
+ */
+export class TermType extends Type {
+    constructor({ defaultValue, hasValues, in_, nodeKinds, ...superParameters }) {
+        super(superParameters);
+        this.equalsFunction = "purifyHelpers.Equatable.booleanEquals";
+        this.mutable = false;
+        this.defaultValue = defaultValue;
+        this.hasValues = hasValues;
+        this.in_ = in_;
+        this.nodeKinds = new Set([...nodeKinds]);
+        invariant(this.nodeKinds.size > 0);
+    }
+    get conversions() {
+        const conversions = [];
+        if (this.nodeKinds.has("Literal")) {
+            conversions.push({
+                conversionExpression: (value) => `rdfLiteral.toRdf(${value})`,
+                sourceTypeCheckExpression: (value) => `typeof ${value} === "boolean"`,
+                sourceTypeName: "boolean",
+            }, {
+                conversionExpression: (value) => `rdfLiteral.toRdf(${value})`,
+                sourceTypeCheckExpression: (value) => `typeof ${value} === "object" && ${value} instanceof Date`,
+                sourceTypeName: "Date",
+            }, {
+                conversionExpression: (value) => `rdfLiteral.toRdf(${value})`,
+                sourceTypeCheckExpression: (value) => `typeof ${value} === "number"`,
+                sourceTypeName: "number",
+            }, {
+                conversionExpression: (value) => `${this.dataFactoryVariable}.literal(${value})`,
+                sourceTypeCheckExpression: (value) => `typeof ${value} === "string"`,
+                sourceTypeName: "string",
+            });
+        }
+        this.defaultValue.ifJust((defaultValue) => {
+            conversions.push({
+                conversionExpression: () => this.rdfjsTermExpression(defaultValue),
+                sourceTypeCheckExpression: (value) => `typeof ${value} === "undefined"`,
+                sourceTypeName: "undefined",
+            });
+        });
+        conversions.push({
+            conversionExpression: (value) => value,
+            sourceTypeCheckExpression: (value) => `typeof ${value} === "object"`,
+            sourceTypeName: this.name,
+        });
+        return conversions;
+    }
+    get discriminatorProperty() {
+        return Maybe.of({
+            name: "termType",
+            type: "string",
+            values: [...this.nodeKinds],
+        });
+    }
+    get jsonName() {
+        invariant(this.nodeKinds.has("Literal") &&
+            (this.nodeKinds.has("BlankNode") || this.nodeKinds.has("NamedNode")), "IdentifierType and LiteralType should override");
+        return `{ readonly "@id": string, readonly termType: ${[...this.nodeKinds]
+            .filter((nodeKind) => nodeKind !== "Literal")
+            .map((nodeKind) => `"${nodeKind}"`)
+            .join(" | ")} } | { readonly "@language": string | undefined, readonly "@type": string | undefined, readonly "@value": string, readonly termType: "Literal" }`;
+    }
+    get name() {
+        return `(${[...this.nodeKinds]
+            .map((nodeKind) => `rdfjs.${nodeKind}`)
+            .join(" | ")})`;
+    }
+    get useImports() {
+        const imports = [Import.RDFJS_TYPES];
+        if (this.nodeKinds.has("Literal")) {
+            imports.push(Import.RDF_LITERAL);
+        }
+        return imports;
+    }
+    fromJsonExpression({ variables, }) {
+        invariant(this.nodeKinds.has("Literal") &&
+            (this.nodeKinds.has("BlankNode") || this.nodeKinds.has("NamedNode")), "IdentifierType and LiteralType should override");
+        return [...this.nodeKinds].reduce((expression, nodeKind) => {
+            let valueToNodeKind;
+            switch (nodeKind) {
+                case "BlankNode":
+                    valueToNodeKind = `${this.dataFactoryVariable}.blankNode(${variables.value}["@id"].substring(2))`;
+                    break;
+                case "Literal":
+                    valueToNodeKind = `${this.dataFactoryVariable}.literal(${variables.value}["@value"], typeof ${variables.value}["@language"] !== "undefined" ? ${variables.value}["@language"] : (typeof ${variables.value}["@type"] !== "undefined" ? dataFactory.namedNode(${variables.value}["@type"]) : undefined))`;
+                    break;
+                case "NamedNode":
+                    valueToNodeKind = `${this.dataFactoryVariable}.namedNode(${variables.value}["@id"])`;
+                    break;
+                default:
+                    throw new RangeError(nodeKind);
+            }
+            return expression.length === 0
+                ? valueToNodeKind
+                : `((${variables.value}.termType === "${nodeKind}") ? (${valueToNodeKind}) : (${expression}))`;
+        }, "");
+    }
+    fromRdfExpression({ variables, }) {
+        const chain = [
+            this.propertyFilterRdfResourceValuesExpression({ variables }),
+        ];
+        // Have an rdfjsResource.Resource.Values here
+        if (this.hasValues.length === 1) {
+            chain.push(`find(_value => _value.toTerm().equals(${this.rdfjsTermExpression(this.hasValues[0])}))`);
+        }
+        else {
+            chain.push("head()");
+        }
+        // Have an rdfjsResource.Resource.Value here
+        this.defaultValue.ifJust((defaultValue) => {
+            // alt the default value before trying to convert the rdfjsResource.Resource.Value to the type
+            chain.push(`alt(purify.Either.of(new rdfjsResource.Resource.Value(${objectInitializer({ subject: variables.resource, predicate: variables.predicate, object: this.rdfjsTermExpression(defaultValue) })})))`);
+        });
+        // Last step: convert the rdfjsResource.Resource.Value to the type
+        chain.push(`chain(_value => ${this.propertyFromRdfResourceValueExpression({
+            variables: {
+                predicate: variables.predicate,
+                resource: variables.resource,
+                resourceValue: "_value",
+            },
+        })})`);
+        return chain.join(".");
+    }
+    hashStatements({ variables, }) {
+        return [
+            `${variables.hasher}.update(${variables.value}.termType);`,
+            `${variables.hasher}.update(${variables.value}.value);`,
+        ];
+    }
+    jsonZodSchema({ variables, }) {
+        invariant(this.nodeKinds.has("Literal") &&
+            (this.nodeKinds.has("BlankNode") || this.nodeKinds.has("NamedNode")), "IdentifierType and LiteralType should override");
+        return `${variables.zod}.discriminatedUnion("termType", [${[
+            ...this.nodeKinds,
+        ]
+            .map((nodeKind) => {
+            switch (nodeKind) {
+                case "BlankNode":
+                case "NamedNode":
+                    return `${variables.zod}.object({ "@id": ${variables.zod}.string().min(1), termType: ${variables.zod}.literal("${nodeKind}") })`;
+                case "Literal":
+                    return `${variables.zod}.object({ "@language": ${variables.zod}.string().optional(), "@type": ${variables.zod}.string().optional(), "@value": ${variables.zod}.string(), termType: ${variables.zod}.literal("Literal") })`;
+                default:
+                    throw new RangeError(nodeKind);
+            }
+        })
+            .join(", ")}])`;
+    }
+    sparqlWherePatterns(parameters) {
+        switch (parameters.context) {
+            case "property":
+                return this.defaultValue
+                    .map(() => [
+                    `{ patterns: [${super.sparqlWherePatterns(parameters).join(", ")}], type: "optional" }`,
+                ])
+                    .orDefault(super.sparqlWherePatterns(parameters));
+            case "type":
+                return super.sparqlWherePatterns(parameters);
+        }
+    }
+    toJsonExpression({ variables, }) {
+        invariant(this.nodeKinds.has("Literal") &&
+            (this.nodeKinds.has("BlankNode") || this.nodeKinds.has("NamedNode")), "IdentifierType and LiteralType should override");
+        return [...this.nodeKinds].reduce((expression, nodeKind) => {
+            let valueToNodeKind;
+            switch (nodeKind) {
+                case "BlankNode":
+                    valueToNodeKind = `{ "@id": \`_:\${${variables.value}.value}\`, termType: "${nodeKind}" as const }`;
+                    break;
+                case "Literal":
+                    valueToNodeKind = `{ "@language": ${variables.value}.language.length > 0 ? ${variables.value}.language : undefined, "@type": ${variables.value}.datatype.value !== "${xsd.string.value}" ? ${variables.value}.datatype.value : undefined, "@value": ${variables.value}.value, termType: "${nodeKind}" as const }`;
+                    break;
+                case "NamedNode":
+                    valueToNodeKind = `{ "@id": ${variables.value}.value, termType: "${nodeKind}" as const }`;
+                    break;
+                default:
+                    throw new RangeError(nodeKind);
+            }
+            return expression.length === 0
+                ? valueToNodeKind
+                : `(${variables.value}.termType === "${nodeKind}") ? ${valueToNodeKind} : ${expression}`;
+        }, "");
+    }
+    toRdfExpression({ variables, }) {
+        return this.defaultValue
+            .map((defaultValue) => `!${variables.value}.equals(${this.rdfjsTermExpression(defaultValue)}) ? ${variables.value} : undefined`)
+            .orDefault(variables.value);
+    }
+    /**
+     * Filter the rdfjsResource.Resource.Values to those that are relevant to the type.
+     *
+     * This is done before
+     */
+    propertyFilterRdfResourceValuesExpression({ variables, }) {
+        return variables.resourceValues;
+    }
+    /**
+     * Convert an rdfjsResource.Resource.Value to a value of this type.
+     * @param variables
+     * @protected
+     */
+    propertyFromRdfResourceValueExpression({ variables, }) {
+        invariant(this.nodeKinds.has("Literal") &&
+            (this.nodeKinds.has("BlankNode") || this.nodeKinds.has("NamedNode")), "IdentifierType and LiteralType should override");
+        let expression = `purify.Either.of(${variables.resourceValue}.toTerm())`;
+        if (this.nodeKinds.size < 3) {
+            expression = `${expression}.chain(term => {
+  switch (term.termType) {
+  ${[...this.nodeKinds].map((nodeKind) => `case "${nodeKind}":`).join("\n")} return purify.Either.of(term);
+  default: return purify.Left(new rdfjsResource.Resource.MistypedValueError(${objectInitializer({ actualValue: "term", expectedValueType: JSON.stringify(this.name), focusResource: variables.resource, predicate: variables.predicate })}));         
+}})`;
+        }
+        return expression;
+    }
+}
+__decorate([
+    Memoize()
+], TermType.prototype, "name", null);
+//# sourceMappingURL=TermType.js.map

package/generators/ts/TsGenerator.d.ts

@@ -1,15 +1,7 @@
-import type * as ast from "../../ast";
-import { Configuration as GlobalConfiguration } from "./Configuration.js";
-export declare class TsGenerator {
-    private ast;
-    protected readonly configuration: TsGenerator.Configuration;
-    constructor(ast: ast.Ast, configuration?: TsGenerator.Configuration);
-    generate(): string;
+import * as ast from "../../ast/index.js";
+import type { Generator } from "../Generator.js";
+export declare class TsGenerator implements Generator {
+    generate(ast_: ast.Ast): string;
     private addDeclarations;
-    private addImportDeclarations;
-}
-export declare namespace TsGenerator {
-    const Configuration: typeof GlobalConfiguration;
-    type Configuration = GlobalConfiguration;
 }
 //# sourceMappingURL=TsGenerator.d.ts.map