@shaclmate/compiler 3.0.4 → 4.0.0

package/dist/generators/ts/StringType.js

@@ -4,79 +4,59 @@ 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 { xsd } from "@tpluscode/rdf-ns-builders";
+import { NonEmptyList } from "purify-ts";
 import { Memoize } from "typescript-memoize";
-import { PrimitiveType } from "./PrimitiveType.js";
-import { Type } from "./Type.js";
-import { objectInitializer } from "./objectInitializer.js";
-export class StringType extends PrimitiveType {
+import { AbstractPrimitiveType } from "./AbstractPrimitiveType.js";
+import { imports } from "./imports.js";
+import { rdfjsTermExpression } from "./rdfjsTermExpression.js";
+import { snippets } from "./snippets.js";
+import { arrayOf, code, literalOf } from "./ts-poet-wrapper.js";
+export class StringType extends AbstractPrimitiveType {
+    filterFunction = code `${snippets.filterString}`;
+    filterType = code `${snippets.StringFilter}`;
+    graphqlType = new AbstractPrimitiveType.GraphqlType(code `${imports.GraphQLString}`);
     kind = "StringType";
-    typeof = "string";
-    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 graphqlName() {
-        return new Type.GraphqlName("graphql.GraphQLString");
-    }
+    schemaType = code `${snippets.StringSchema}`;
+    sparqlWherePatternsFunction = code `${snippets.stringSparqlWherePatterns}`;
+    typeofs = NonEmptyList(["string"]);
     get name() {
         if (this.primitiveIn.length > 0) {
-            return this.primitiveIn.map((value) => `"${value}"`).join(" | ");
+            return `${this.primitiveIn.map((value) => `"${value}"`).join(" | ")}`;
         }
-        return this.typeof;
+        return `string`;
     }
-    fromRdfExpressionChain({ variables, }) {
-        const inChain = this.primitiveIn.length > 0
-            ? `.chain(string_ => { switch (string_) { ${this.primitiveIn.map((value) => `case "${value}":`).join(" ")} return purify.Either.of<Error, ${this.name}>(string_); default: return purify.Left<Error, ${this.name}>(new rdfjsResource.Resource.MistypedValueError(${objectInitializer({ actualValue: "value.toTerm()", expectedValueType: JSON.stringify(this.name), focusResource: variables.resource, predicate: variables.predicate })})); } })`
-            : "";
+    get schemaObject() {
         return {
-            ...super.fromRdfExpressionChain({ variables }),
-            valueTo: `chain(values => values.chainMap(value => value.toString()${inChain}))`,
+            ...super.schemaObject,
+            in: this.primitiveIn.length > 0
+                ? this.primitiveIn.map(literalOf).concat()
+                : undefined,
         };
     }
     hashStatements({ variables, }) {
-        return [`${variables.hasher}.update(${variables.value});`];
+        return [code `${variables.hasher}.update(${variables.value});`];
     }
-    jsonZodSchema({ variables, }) {
+    jsonZodSchema(_parameters) {
         switch (this.primitiveIn.length) {
             case 0:
-                return `${variables.zod}.string()`;
+                return code `${imports.z}.string()`;
             case 1:
-                return `${variables.zod}.literal(${this.primitiveIn[0]})`;
+                return code `${imports.z}.literal(${this.primitiveIn[0]})`;
             default:
-                return `${variables.zod}.enum(${JSON.stringify(this.primitiveIn)})`;
+                return code `${imports.z}.enum(${arrayOf(...this.primitiveIn)})`;
         }
     }
-    sparqlWherePatterns(parameters) {
-        return super.sparqlWherePatterns({
-            ...parameters,
-            ignoreLiteralLanguage: false,
-        });
-    }
     toRdfExpression({ variables, }) {
-        return this.primitiveDefaultValue
-            .map((defaultValue) => `(${variables.value} !== "${defaultValue}" ? [${variables.value}] : [])`)
-            .orDefault(`[${variables.value}]`);
+        return code `[${snippets.literalFactory}.string(${variables.value}${!this.datatype.equals(xsd.string) ? `, ${rdfjsTermExpression(this.datatype)}` : ""})]`;
+    }
+    fromRdfExpressionChain({ variables, }) {
+        return {
+            ...super.fromRdfExpressionChain({ variables }),
+            valueTo: code `chain(values => values.chainMap(value => value.toString(${this.primitiveIn.length > 0 ? `${JSON.stringify(this.primitiveIn)} as const` : ""})))`,
+        };
     }
 }
-__decorate([
-    Memoize()
-], StringType.prototype, "conversions", null);
-__decorate([
-    Memoize()
-], StringType.prototype, "graphqlName", null);
 __decorate([
     Memoize()
 ], StringType.prototype, "name", null);

package/dist/generators/ts/TermType.d.ts

@@ -1,61 +1,27 @@
 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.
- *
- * ConstantTermT is the type of sh:defaultValue, sh:hasValue, and sh:in.
- * RuntimeTermT is the type of values at runtime.
- *
- * The two are differentiated because identifiers can have BlankNode or NamedNode values at runtime but only NamedNode values for sh:defaultValue et al.
- */
-export declare class TermType<ConstantTermT extends Literal | NamedNode = Literal | NamedNode, RuntimeTermT extends BlankNode | Literal | NamedNode = BlankNode | Literal | NamedNode> extends Type {
-    readonly defaultValue: Maybe<ConstantTermT>;
-    readonly equalsFunction: string;
-    readonly hasValues: readonly ConstantTermT[];
-    readonly in_: readonly ConstantTermT[];
-    readonly mutable: boolean;
-    readonly nodeKinds: Set<RuntimeTermT["termType"]>;
-    readonly typeof: "boolean" | "number" | "object" | "string";
-    constructor({ defaultValue, hasValues, in_, nodeKinds, }: {
-        defaultValue: Maybe<ConstantTermT>;
-        hasValues: readonly ConstantTermT[];
-        in_: readonly ConstantTermT[];
-        nodeKinds: Set<RuntimeTermT["termType"]>;
+import { NodeKind } from "@shaclmate/shacl-ast";
+import { AbstractTermType } from "./AbstractTermType.js";
+import { type Code } from "./ts-poet-wrapper.js";
+export declare class TermType<ConstantTermT extends Literal | NamedNode = Literal | NamedNode, RuntimeTermT extends BlankNode | Literal | NamedNode = BlankNode | Literal | NamedNode> extends AbstractTermType {
+    readonly filterFunction: Code;
+    readonly filterType: Code;
+    readonly kind = "TermType";
+    readonly nodeKinds: ReadonlySet<NodeKind>;
+    readonly schemaType: Code;
+    readonly sparqlWherePatternsFunction: Code;
+    constructor({ nodeKinds, ...superParameters }: ConstructorParameters<typeof AbstractTermType<ConstantTermT, RuntimeTermT>>[0] & {
+        nodeKinds: ReadonlySet<NodeKind>;
     });
-    get conversions(): readonly Type.Conversion[];
-    get discriminatorProperty(): Maybe<Type.DiscriminatorProperty>;
-    get graphqlName(): Type.GraphqlName;
-    get jsonName(): Type.JsonName;
-    get name(): string;
-    fromJsonExpression({ variables, }: Parameters<Type["fromJsonExpression"]>[0]): string;
-    fromRdfExpression(parameters: Parameters<Type["fromRdfExpression"]>[0]): string;
-    /**
-     * The fromRdfExpression for a term type can be decomposed into multiple sub-expressions with different purposes:
-     *
-     * defaultValues: add the default value to the values sequence if the latter doesn't contain values already
-     * hasValues: test whether the values sequence has sh:hasValue values
-     * languageIn: filter the values sequence to literals with the right sh:languageIn (or runtime languageIn)
-     * valueTo: convert values in the values sequence to the appropriate term type/sub-type (literal, string, etc.)
-     *
-     * Considering the sub-expressions as a record instead of an array allows them to be selectively overridden by subclasses.
-     */
-    protected fromRdfExpressionChain({ variables, }: Parameters<Type["fromRdfExpression"]>[0]): {
-        defaultValue?: string;
-        hasValues?: string;
-        languageIn?: string;
-        preferredLanguages?: string;
-        valueTo: string;
+    get graphqlType(): AbstractTermType.GraphqlType;
+    get name(): Code;
+    protected get schemaObject(): {
+        in: Code[] | undefined;
+        kind: Code;
     };
-    graphqlResolveExpression(_parameters: Parameters<Type["graphqlResolveExpression"]>[0]): string;
-    hashStatements({ variables, }: Parameters<Type["hashStatements"]>[0]): readonly string[];
-    jsonUiSchemaElement(): Maybe<string>;
-    jsonZodSchema({ variables, }: Parameters<Type["jsonZodSchema"]>[0]): ReturnType<Type["jsonZodSchema"]>;
-    snippetDeclarations({ features, }: Parameters<Type["snippetDeclarations"]>[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(): readonly Import[];
+    fromJsonExpression({ variables, }: Parameters<AbstractTermType["fromJsonExpression"]>[0]): Code;
+    graphqlResolveExpression(_parameters: Parameters<AbstractTermType["graphqlResolveExpression"]>[0]): Code;
+    jsonType(): AbstractTermType.JsonType;
+    jsonZodSchema(_parameters: Parameters<AbstractTermType["jsonZodSchema"]>[0]): Code;
+    toJsonExpression({ variables, }: Parameters<AbstractTermType["toJsonExpression"]>[0]): Code;
 }
 //# sourceMappingURL=TermType.d.ts.map

package/dist/generators/ts/TermType.js

@@ -4,275 +4,123 @@ 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 { NodeKind } from "@shaclmate/shacl-ast";
 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 { SnippetDeclarations } from "./SnippetDeclarations.js";
-import { Type } from "./Type.js";
-import { objectInitializer } from "./objectInitializer.js";
+import { AbstractTermType } from "./AbstractTermType.js";
+import { imports } from "./imports.js";
 import { rdfjsTermExpression } from "./rdfjsTermExpression.js";
-import { syntheticNamePrefix } from "./syntheticNamePrefix.js";
-/**
- * Abstract base class for IdentifierType and LiteralType.
- *
- * ConstantTermT is the type of sh:defaultValue, sh:hasValue, and sh:in.
- * RuntimeTermT is the type of values at runtime.
- *
- * The two are differentiated because identifiers can have BlankNode or NamedNode values at runtime but only NamedNode values for sh:defaultValue et al.
- */
-export class TermType extends Type {
-    defaultValue;
-    equalsFunction = `${syntheticNamePrefix}booleanEquals`;
-    hasValues;
-    in_;
-    mutable = false;
+import { snippets } from "./snippets.js";
+import { code, joinCode } from "./ts-poet-wrapper.js";
+export class TermType extends AbstractTermType {
+    filterFunction = code `${snippets.filterTerm}`;
+    filterType = code `${snippets.TermFilter}`;
+    kind = "TermType";
     nodeKinds;
-    typeof = "object";
-    constructor({ defaultValue, hasValues, in_, nodeKinds, }) {
-        super();
-        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}, ${objectInitializer({ dataFactory: "dataFactory" })})`,
-                sourceTypeCheckExpression: (value) => `typeof ${value} === "boolean"`,
-                sourceTypeName: "boolean",
-            }, {
-                conversionExpression: (value) => `rdfLiteral.toRdf(${value}, ${objectInitializer({ dataFactory: "dataFactory" })})`,
-                sourceTypeCheckExpression: (value) => `typeof ${value} === "object" && ${value} instanceof Date`,
-                sourceTypeName: "Date",
-            }, {
-                conversionExpression: (value) => `rdfLiteral.toRdf(${value}, ${objectInitializer({ dataFactory: "dataFactory" })})`,
-                sourceTypeCheckExpression: (value) => `typeof ${value} === "number"`,
-                sourceTypeName: "number",
-            }, {
-                conversionExpression: (value) => `dataFactory.literal(${value})`,
-                sourceTypeCheckExpression: (value) => `typeof ${value} === "string"`,
-                sourceTypeName: "string",
-            });
-        }
-        this.defaultValue.ifJust((defaultValue) => {
-            conversions.push({
-                conversionExpression: () => 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",
-            ownValues: [...this.nodeKinds],
-            descendantValues: [],
-            type: "string",
-        });
+    schemaType = code `${snippets.TermSchema}`;
+    sparqlWherePatternsFunction = code `${snippets.termSparqlWherePatterns}`;
+    constructor({ nodeKinds, ...superParameters }) {
+        super(superParameters);
+        this.nodeKinds = nodeKinds;
+        invariant(this.nodeKinds.has("Literal") &&
+            (this.nodeKinds.has("BlankNode") || this.nodeKinds.has("IRI")), "should be IdentifierType or LiteralType");
     }
-    get graphqlName() {
+    get graphqlType() {
         throw new Error("not implemented");
     }
-    get jsonName() {
-        invariant(this.nodeKinds.has("Literal") &&
-            (this.nodeKinds.has("BlankNode") || this.nodeKinds.has("NamedNode")), "IdentifierType and LiteralType should override");
-        return new Type.JsonName(`{ readonly "@id": string, readonly termType: ${[...this.nodeKinds]
-            .filter((nodeKind) => nodeKind !== "Literal")
-            .map((nodeKind) => `"${nodeKind}"`)
-            .join(" | ")} } | { readonly "@language"?: string, readonly "@type"?: string, readonly "@value": string, readonly termType: "Literal" }`);
-    }
     get name() {
-        return `(${[...this.nodeKinds]
-            .map((nodeKind) => `rdfjs.${nodeKind}`)
-            .join(" | ")})`;
+        return code `(${joinCode([...this.nodeKinds]
+            .map((nodeKind) => {
+            switch (nodeKind) {
+                case "BlankNode":
+                    return imports.BlankNode;
+                case "IRI":
+                    return imports.NamedNode;
+                case "Literal":
+                    return imports.Literal;
+                default:
+                    nodeKind;
+                    throw new RangeError(nodeKind);
+            }
+        })
+            .map((import_) => code `${import_}`), { on: " | " })})`;
+    }
+    get schemaObject() {
+        return {
+            ...super.schemaObject,
+            in: this.in_.length > 0 ? this.in_.map(rdfjsTermExpression) : undefined,
+        };
     }
     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 = `dataFactory.blankNode(${variables.value}["@id"].substring(2))`;
+                    valueToNodeKind = code `${imports.dataFactory}.blankNode(${variables.value}["@id"].substring(2))`;
                     break;
-                case "Literal":
-                    valueToNodeKind = `dataFactory.literal(${variables.value}["@value"], typeof ${variables.value}["@language"] !== "undefined" ? ${variables.value}["@language"] : (typeof ${variables.value}["@type"] !== "undefined" ? dataFactory.namedNode(${variables.value}["@type"]) : undefined))`;
+                case "IRI":
+                    valueToNodeKind = code `${imports.dataFactory}.namedNode(${variables.value}["@id"])`;
                     break;
-                case "NamedNode":
-                    valueToNodeKind = `dataFactory.namedNode(${variables.value}["@id"])`;
+                case "Literal":
+                    valueToNodeKind = code `${imports.dataFactory}.literal(${variables.value}["@value"], ${variables.value}["@language"] !== undefined ? ${variables.value}["@language"] : (${variables.value}["@type"] !== undefined ? ${imports.dataFactory}.namedNode(${variables.value}["@type"]) : undefined))`;
                     break;
                 default:
                     throw new RangeError(nodeKind);
             }
-            return expression.length === 0
+            return expression == null
                 ? valueToNodeKind
-                : `((${variables.value}.termType === "${nodeKind}") ? (${valueToNodeKind}) : (${expression}))`;
-        }, "");
-    }
-    fromRdfExpression(parameters) {
-        // invariant(
-        //   this.nodeKinds.has("Literal") &&
-        //     (this.nodeKinds.has("BlankNode") || this.nodeKinds.has("NamedNode")),
-        //   "IdentifierType and LiteralType should override",
-        // );
-        const chain = this.fromRdfExpressionChain(parameters);
-        const { variables } = parameters;
-        return [
-            variables.resourceValues,
-            chain.defaultValue,
-            chain.hasValues,
-            chain.languageIn,
-            chain.preferredLanguages,
-            chain.valueTo,
-        ]
-            .filter((_) => typeof _ !== "undefined")
-            .join(".");
-    }
-    /**
-     * The fromRdfExpression for a term type can be decomposed into multiple sub-expressions with different purposes:
-     *
-     * defaultValues: add the default value to the values sequence if the latter doesn't contain values already
-     * hasValues: test whether the values sequence has sh:hasValue values
-     * languageIn: filter the values sequence to literals with the right sh:languageIn (or runtime languageIn)
-     * valueTo: convert values in the values sequence to the appropriate term type/sub-type (literal, string, etc.)
-     *
-     * Considering the sub-expressions as a record instead of an array allows them to be selectively overridden by subclasses.
-     */
-    fromRdfExpressionChain({ variables, }) {
-        let valueToExpression = "purify.Either.of<Error, rdfjs.BlankNode | rdfjs.Literal | rdfjs.NamedNode>(value.toTerm())";
-        if (this.nodeKinds.size < 3) {
-            const eitherTypeParameters = `<Error, ${this.name}>`;
-            valueToExpression = `${valueToExpression}.chain(term => {
-  switch (term.termType) {
-  ${[...this.nodeKinds].map((nodeKind) => `case "${nodeKind}":`).join("\n")} return purify.Either.of${eitherTypeParameters}(term);
-  default: return purify.Left${eitherTypeParameters}(new rdfjsResource.Resource.MistypedValueError(${objectInitializer({ actualValue: "term", expectedValueType: JSON.stringify(this.name), focusResource: variables.resource, predicate: variables.predicate })}));         
-}})`;
-        }
-        return {
-            defaultValue: this.defaultValue
-                .map((defaultValue) => `map(values => values.length > 0 ? values : new rdfjsResource.Resource.Value(${objectInitializer({ subject: variables.resource, predicate: variables.predicate, object: rdfjsTermExpression(defaultValue) })}).toValues())`)
-                .extract(),
-            hasValues: this.hasValues.length > 0
-                ? `chain(values => {
-  for (const hasValue of [${this.hasValues.map(rdfjsTermExpression).join(", ")}]) {
-    const findResult = values.find(value => value.toTerm().equals(hasValue));
-    if (findResult.isLeft()) {
-      return findResult;
-    }
-  }
-  return purify.Either.of<Error, rdfjsResource.Resource.Values<rdfjsResource.Resource.Value>>(values);
-})`
-                : undefined,
-            valueTo: `chain(values => values.chainMap(value => ${valueToExpression}))`,
-        };
+                : code `((${variables.value}.termType === "${NodeKind.toTermType(nodeKind)}") ? (${valueToNodeKind}) : (${expression}))`;
+        }, null);
     }
     graphqlResolveExpression(_parameters) {
         throw new Error("not implemented");
     }
-    hashStatements({ variables, }) {
-        return [
-            `${variables.hasher}.update(${variables.value}.termType);`,
-            `${variables.hasher}.update(${variables.value}.value);`,
-        ];
-    }
-    jsonUiSchemaElement() {
-        return Maybe.empty();
+    jsonType() {
+        return new AbstractTermType.JsonType(code `{ readonly "@id": string, readonly termType: ${[...this.nodeKinds]
+            .filter((nodeKind) => nodeKind !== "Literal")
+            .map((nodeKind) => `"${NodeKind.toTermType(nodeKind)}"`)
+            .join(" | ")} } | { readonly "@language"?: string, readonly "@type"?: string, readonly "@value": string, readonly termType: "Literal" }`);
     }
-    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) => {
+    jsonZodSchema(_parameters) {
+        return code `${imports.z}.discriminatedUnion("termType", [${joinCode([...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 "IRI":
+                    return code `${imports.z}.object({ "@id": ${imports.z}.string().min(1), termType: ${imports.z}.literal("${NodeKind.toTermType(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") })`;
+                    return code `${imports.z}.object({ "@language": ${imports.z}.string().optional(), "@type": ${imports.z}.string().optional(), "@value": ${imports.z}.string(), termType: ${imports.z}.literal("Literal") })`;
                 default:
                     throw new RangeError(nodeKind);
             }
-        })
-            .join(", ")}])`;
-    }
-    snippetDeclarations({ features, }) {
-        const snippetDeclarations = [];
-        if (features.has("equals")) {
-            snippetDeclarations.push(SnippetDeclarations.booleanEquals);
-        }
-        return snippetDeclarations;
-    }
-    sparqlWherePatterns(parameters) {
-        switch (parameters.context) {
-            case "object":
-                return this.defaultValue
-                    .map(() => [
-                    `{ patterns: [${super.sparqlWherePatterns(parameters).join(", ")}], type: "optional" }`,
-                ])
-                    .orDefault(super.sparqlWherePatterns(parameters));
-            case "subject":
-                return super.sparqlWherePatterns(parameters);
-        }
+        }), { on: "," })}])`;
     }
     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 }`;
+                    valueToNodeKind = code `{ "@id": \`_:\${${variables.value}.value}\`, termType: "${NodeKind.toTermType(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 }`;
+                case "IRI":
+                    valueToNodeKind = code `{ "@id": ${variables.value}.value, termType: "${NodeKind.toTermType(nodeKind)}" as const }`;
                     break;
-                case "NamedNode":
-                    valueToNodeKind = `{ "@id": ${variables.value}.value, termType: "${nodeKind}" as const }`;
+                case "Literal":
+                    valueToNodeKind = code `{ "@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.toTermType(nodeKind)}" as const }`;
                     break;
                 default:
                     throw new RangeError(nodeKind);
             }
-            return expression.length === 0
+            return expression === null
                 ? valueToNodeKind
-                : `(${variables.value}.termType === "${nodeKind}") ? ${valueToNodeKind} : ${expression}`;
-        }, "");
-    }
-    toRdfExpression({ variables, }) {
-        return this.defaultValue
-            .map((defaultValue) => `(!${variables.value}.equals(${rdfjsTermExpression(defaultValue)}) ? [${variables.value}] : [])`)
-            .orDefault(`[${variables.value}]`);
-    }
-    useImports() {
-        const imports = [Import.RDFJS_TYPES];
-        if (this.nodeKinds.has("Literal")) {
-            imports.push(Import.RDF_LITERAL);
-        }
-        return imports;
+                : code `(${variables.value}.termType === "${NodeKind.toTermType(nodeKind)}") ? ${valueToNodeKind} : ${expression}`;
+        }, null);
     }
 }
 __decorate([
     Memoize()
-], TermType.prototype, "conversions", null);
-__decorate([
-    Memoize()
-], TermType.prototype, "discriminatorProperty", null);
-__decorate([
-    Memoize()
-], TermType.prototype, "jsonName", null);
+], TermType.prototype, "name", null);
 __decorate([
     Memoize()
-], TermType.prototype, "name", null);
+], TermType.prototype, "jsonType", null);
 //# sourceMappingURL=TermType.js.map

package/dist/generators/ts/TsGenerator.d.ts

@@ -3,6 +3,5 @@ import type { Generator } from "../Generator.js";
 export declare class TsGenerator implements Generator {
     private readonly typeFactory;
     generate(ast_: ast.Ast): string;
-    private addStatements;
 }
 //# sourceMappingURL=TsGenerator.d.ts.map