@shaclmate/compiler 4.0.32 → 4.0.34

package/dist/generators/ts/BigIntType.js

@@ -4,27 +4,16 @@ 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 { NonEmptyList } from "purify-ts";
+import { LiteralDecoder } from "@rdfx/literal";
 import { Memoize } from "typescript-memoize";
 import { AbstractNumericType } from "./AbstractNumericType.js";
 import { code, joinCode, literalOf } from "./ts-poet-wrapper.js";
 export class BigIntType extends AbstractNumericType {
     kind = "BigIntType";
-    typeofs = NonEmptyList(["bigint"]);
+    typeofs = ["bigint"];
     get graphqlType() {
         return new AbstractNumericType.GraphqlType(code `${this.reusables.imports.GraphQLBigInt}`, this.reusables);
     }
-    get conversions() {
-        if (this.in_.length > 0) {
-            return super.conversions;
-        }
-        return super.conversions.concat({
-            conversionExpression: (value) => code `BigInt(${value})`,
-            sourceTypeCheckExpression: (value) => code `typeof ${value} === "number"`,
-            sourceTypeName: "number",
-            sourceTypeof: "number",
-        });
-    }
     fromJsonExpression({ variables, }) {
         let expression = code `BigInt(${variables.value})`;
         if (this.primitiveIn.length > 0) {
@@ -45,15 +34,15 @@ export class BigIntType extends AbstractNumericType {
     jsonType() {
         return new AbstractNumericType.JsonType(code `string`);
     }
+    literalExpression(literal) {
+        return code `${typeof literal === "bigint" ? literal : LiteralDecoder.decodeBigIntLiteral(literal).unsafeCoerce()}n`;
+    }
     toJsonExpression({ variables, }) {
         return code `${variables.value}.toString()`;
     }
     fromRdfResourceValueExpression({ variables, }) {
         return code `${variables.value}.toBigInt(${this.primitiveIn.length > 0 ? `[${this.primitiveIn.map((_) => `${_}n`).join(", ")}] as const` : ""})`;
     }
-    literalOf(value) {
-        return `${value.toString()}n`;
-    }
 }
 __decorate([
     Memoize()

package/dist/generators/ts/BlankNodeType.d.ts

@@ -1,8 +1,8 @@
-import type { BlankNode, NamedNode } from "@rdfjs/types";
+import type { BlankNode } from "@rdfjs/types";
 import { AbstractIdentifierType } from "./AbstractIdentifierType.js";
-import { AbstractTermType } from "./AbstractTermType.js";
 import { type Code } from "./ts-poet-wrapper.js";
 export declare class BlankNodeType extends AbstractIdentifierType<BlankNode> {
+    readonly conversionFunction: AbstractIdentifierType.ConversionFunction;
     readonly filterFunction: Code;
     readonly filterType: Code;
     readonly parseFunction: Code;
@@ -12,11 +12,11 @@ export declare class BlankNodeType extends AbstractIdentifierType<BlankNode> {
     readonly schemaType: Code;
     readonly valueSparqlWherePatternsFunction: Code;
     constructor(superParameters: Omit<ConstructorParameters<typeof AbstractIdentifierType<BlankNode>>[0], "hasValues" | "in_">);
-    fromJsonExpression({ variables, }: Parameters<AbstractTermType<NamedNode, BlankNode | NamedNode>["fromJsonExpression"]>[0]): Code;
-    jsonType(parameters?: Parameters<AbstractTermType["jsonType"]>[0]): AbstractTermType.JsonType;
-    jsonSchema({ includeDiscriminantProperty, }: Parameters<AbstractTermType<NamedNode, BlankNode | NamedNode>["jsonSchema"]>[0]): Code;
-    toJsonExpression({ includeDiscriminantProperty, variables, }: Parameters<AbstractTermType<NamedNode, BlankNode | NamedNode>["toJsonExpression"]>[0]): Code;
-    protected fromRdfExpressionChain({ variables, }: Parameters<AbstractTermType["fromRdfExpressionChain"]>[0]): {
+    fromJsonExpression({ variables, }: Parameters<AbstractIdentifierType<BlankNode>["fromJsonExpression"]>[0]): Code;
+    jsonType(parameters?: Parameters<AbstractIdentifierType<BlankNode>["jsonType"]>[0]): AbstractIdentifierType.JsonType;
+    jsonSchema({ includeDiscriminantProperty, }: Parameters<AbstractIdentifierType<BlankNode>["jsonSchema"]>[0]): Code;
+    toJsonExpression({ includeDiscriminantProperty, variables, }: Parameters<AbstractIdentifierType<BlankNode>["toJsonExpression"]>[0]): Code;
+    protected fromRdfExpressionChain({ variables, }: Parameters<AbstractIdentifierType<BlankNode>["fromRdfExpressionChain"]>[0]): {
         valueTo: Code;
         hasValues?: Code;
         languageIn?: Code;

package/dist/generators/ts/BlankNodeType.js

@@ -6,9 +6,21 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 };
 import { Memoize } from "typescript-memoize";
 import { AbstractIdentifierType } from "./AbstractIdentifierType.js";
-import { AbstractTermType } from "./AbstractTermType.js";
 import { code } from "./ts-poet-wrapper.js";
 export class BlankNodeType extends AbstractIdentifierType {
+    conversionFunction = {
+        code: code `${this.reusables.snippets.convertToBlankNode}`,
+        sourceTypes: [
+            {
+                name: code `${this.reusables.imports.BlankNode}`,
+                typeof: "object",
+            },
+            {
+                name: "undefined",
+                typeof: "undefined",
+            },
+        ],
+    };
     filterFunction = code `${this.reusables.snippets.filterBlankNode}`;
     filterType = code `${this.reusables.snippets.BlankNodeFilter}`;
     parseFunction = code `${this.reusables.snippets.parseBlankNode};`;
@@ -31,7 +43,7 @@ export class BlankNodeType extends AbstractIdentifierType {
         const discriminantProperty = parameters?.includeDiscriminantProperty
             ? `, readonly termType: "BlankNode"`
             : "";
-        return new AbstractTermType.JsonType(code `{ readonly "@id": string${discriminantProperty} }`);
+        return new AbstractIdentifierType.JsonType(code `{ readonly "@id": string${discriminantProperty} }`);
     }
     jsonSchema({ includeDiscriminantProperty, }) {
         const discriminantProperty = includeDiscriminantProperty

package/dist/generators/ts/BooleanType.d.ts

@@ -1,21 +1,19 @@
-import { NonEmptyList } from "purify-ts";
+import type { Literal } from "@rdfjs/types";
 import { AbstractPrimitiveType } from "./AbstractPrimitiveType.js";
 import { type Code } from "./ts-poet-wrapper.js";
 export declare class BooleanType extends AbstractPrimitiveType<boolean> {
     readonly filterFunction: Code;
     readonly filterType: Code;
+    readonly graphqlType: import("./AbstractType.js").AbstractType.GraphqlType;
+    readonly hashFunction: Code;
     readonly kind = "BooleanType";
     readonly schemaType: Code;
+    readonly typeofs: "boolean"[];
     readonly valueSparqlWherePatternsFunction: Code;
-    readonly typeofs: NonEmptyList<"boolean">;
-    get graphqlType(): import("./AbstractType.js").AbstractType.GraphqlType;
+    get conversionFunction(): AbstractPrimitiveType.ConversionFunction;
     get name(): string;
-    protected get schemaObject(): {
-        in: boolean[] | undefined;
-        languageIn: import("ts-poet/build/Node.js").Node[] | undefined;
-        kind: Code;
-    };
     jsonSchema(_parameters: Parameters<AbstractPrimitiveType<number>["jsonSchema"]>[0]): Code;
+    literalExpression(literal: boolean | Literal): Code;
     toRdfResourceValuesExpression({ variables, }: Parameters<AbstractPrimitiveType<boolean>["toRdfResourceValuesExpression"]>[0]): Code;
     protected fromRdfExpressionChain({ variables, }: Parameters<AbstractPrimitiveType<boolean>["fromRdfExpressionChain"]>[0]): ReturnType<AbstractPrimitiveType<boolean>["fromRdfExpressionChain"]>;
 }

package/dist/generators/ts/BooleanType.js

@@ -4,19 +4,29 @@ 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 { NonEmptyList } from "purify-ts";
+import { LiteralDecoder } from "@rdfx/literal";
 import { Memoize } from "typescript-memoize";
 import { AbstractPrimitiveType } from "./AbstractPrimitiveType.js";
 import { code } from "./ts-poet-wrapper.js";
 export class BooleanType extends AbstractPrimitiveType {
     filterFunction = code `${this.reusables.snippets.filterBoolean}`;
     filterType = code `${this.reusables.snippets.BooleanFilter}`;
+    graphqlType = new AbstractPrimitiveType.GraphqlType(code `${this.reusables.imports.GraphQLBoolean}`, this.reusables);
+    hashFunction = code `${this.reusables.snippets.hashBoolean}`;
     kind = "BooleanType";
     schemaType = code `${this.reusables.snippets.BooleanSchema}`;
+    typeofs = ["boolean"];
     valueSparqlWherePatternsFunction = code `${this.reusables.snippets.booleanSparqlWherePatterns}`;
-    typeofs = NonEmptyList(["boolean"]);
-    get graphqlType() {
-        return new AbstractPrimitiveType.GraphqlType(code `${this.reusables.imports.GraphQLBoolean}`, this.reusables);
+    get conversionFunction() {
+        return {
+            code: code `${this.reusables.snippets.convertToBoolean}<${this.name}>`,
+            sourceTypes: [
+                {
+                    name: this.name,
+                    typeof: "boolean",
+                },
+            ],
+        };
     }
     get name() {
         if (this.primitiveIn.length > 0) {
@@ -24,18 +34,15 @@ export class BooleanType extends AbstractPrimitiveType {
         }
         return `boolean`;
     }
-    get schemaObject() {
-        return {
-            ...super.schemaObject,
-            in: this.primitiveIn.length > 0 ? this.primitiveIn.concat() : undefined,
-        };
-    }
     jsonSchema(_parameters) {
         if (this.primitiveIn.length === 1) {
             return code `${this.reusables.imports.z}.literal(${this.primitiveIn[0]})`;
         }
         return code `${this.reusables.imports.z}.boolean()`;
     }
+    literalExpression(literal) {
+        return code `${typeof literal === "boolean" ? literal : LiteralDecoder.decodeBooleanLiteral(literal).unsafeCoerce()}`;
+    }
     toRdfResourceValuesExpression({ variables, }) {
         return code `[${this.reusables.snippets.literalFactory}.boolean(${variables.value}, ${this.rdfjsTermExpression(this.datatype)})]`;
     }
@@ -50,7 +57,7 @@ export class BooleanType extends AbstractPrimitiveType {
 }
 __decorate([
     Memoize()
-], BooleanType.prototype, "graphqlType", null);
+], BooleanType.prototype, "conversionFunction", null);
 __decorate([
     Memoize()
 ], BooleanType.prototype, "name", null);

package/dist/generators/ts/DateTimeType.d.ts

@@ -1,9 +1,13 @@
+import type { Literal } from "@rdfjs/types";
 import { AbstractDateType } from "./AbstractDateType.js";
 import { type Code } from "./ts-poet-wrapper.js";
 export declare class DateTimeType extends AbstractDateType {
+    readonly conversionFunction: AbstractDateType.ConversionFunction;
+    readonly graphqlType: import("./AbstractType.js").AbstractType.GraphqlType;
+    readonly hashFunction: Code;
     readonly kind = "DateTimeType";
-    get graphqlType(): import("./AbstractType.js").AbstractType.GraphqlType;
     jsonSchema(_parameters: Parameters<AbstractDateType["jsonSchema"]>[0]): Code;
+    literalExpression(literal: Date | Literal): Code;
     toJsonExpression({ variables, }: Parameters<AbstractDateType["toJsonExpression"]>[0]): Code;
     protected fromRdfResourceValueExpression({ variables, }: Parameters<AbstractDateType["fromRdfResourceValueExpression"]>[0]): Code;
 }

package/dist/generators/ts/DateTimeType.js

@@ -1,20 +1,25 @@
-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 { LiteralDecoder } from "@rdfx/literal";
 import { AbstractDateType } from "./AbstractDateType.js";
 import { code } from "./ts-poet-wrapper.js";
 export class DateTimeType extends AbstractDateType {
+    conversionFunction = {
+        code: code `${this.reusables.snippets.convertToDateTime}`,
+        sourceTypes: [
+            {
+                name: "Date",
+                typeof: "object",
+            },
+        ],
+    };
+    graphqlType = new DateTimeType.GraphqlType(code `${this.reusables.imports.GraphQLDateTime}`, this.reusables);
+    hashFunction = code `${this.reusables.snippets.hashDateTime}`;
     kind = "DateTimeType";
-    get graphqlType() {
-        return new DateTimeType.GraphqlType(code `${this.reusables.imports.GraphQLDateTime}`, this.reusables);
-    }
     jsonSchema(_parameters) {
         return code `${this.reusables.imports.z}.iso.datetime()`;
     }
+    literalExpression(literal) {
+        return code `new Date("${(literal instanceof Date ? literal : LiteralDecoder.decodeDateTimeLiteral(literal).unsafeCoerce()).toISOString()}")`;
+    }
     toJsonExpression({ variables, }) {
         return code `${variables.value}.toISOString()`;
     }
@@ -22,7 +27,4 @@ export class DateTimeType extends AbstractDateType {
         return code `${variables.value}.toDateTime(${this.primitiveIn.length > 0 ? `[${this.primitiveIn.map((_) => `new Date(${_.getTime()})`).join(", ")}]` : ""})`;
     }
 }
-__decorate([
-    Memoize()
-], DateTimeType.prototype, "graphqlType", null);
 //# sourceMappingURL=DateTimeType.js.map

package/dist/generators/ts/DateType.d.ts

@@ -1,10 +1,14 @@
+import type { Literal } from "@rdfjs/types";
 import { AbstractDateType } from "./AbstractDateType.js";
 import { DateTimeType } from "./DateTimeType.js";
 import { type Code } from "./ts-poet-wrapper.js";
 export declare class DateType extends AbstractDateType {
+    readonly conversionFunction: AbstractDateType.ConversionFunction;
+    readonly graphqlType: import("./AbstractType.js").AbstractType.GraphqlType;
+    readonly hashFunction: Code;
     readonly kind = "DateType";
-    get graphqlType(): import("./AbstractType.js").AbstractType.GraphqlType;
     jsonSchema(_parameters: Parameters<DateTimeType["jsonSchema"]>[0]): Code;
+    literalExpression(literal: Date | Literal): Code;
     toJsonExpression({ variables, }: Parameters<AbstractDateType["toJsonExpression"]>[0]): Code;
     protected fromRdfResourceValueExpression({ variables, }: Parameters<AbstractDateType["fromRdfResourceValueExpression"]>[0]): Code;
 }

package/dist/generators/ts/DateType.js

@@ -1,29 +1,31 @@
-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 { LiteralDecoder } from "@rdfx/literal";
 import { AbstractDateType } from "./AbstractDateType.js";
 import { DateTimeType } from "./DateTimeType.js";
 import { code } from "./ts-poet-wrapper.js";
 export class DateType extends AbstractDateType {
+    conversionFunction = {
+        code: code `${this.reusables.snippets.convertToDate}`,
+        sourceTypes: [
+            {
+                name: "Date",
+                typeof: "object",
+            },
+        ],
+    };
+    graphqlType = new DateTimeType.GraphqlType(code `${this.reusables.imports.GraphQLDate}`, this.reusables);
+    hashFunction = code `${this.reusables.snippets.hashDate}`;
     kind = "DateType";
-    get graphqlType() {
-        return new DateTimeType.GraphqlType(code `${this.reusables.imports.GraphQLDate}`, this.reusables);
-    }
     jsonSchema(_parameters) {
         return code `${this.reusables.imports.z}.iso.date()`;
     }
+    literalExpression(literal) {
+        return code `new Date("${(literal instanceof Date ? literal : LiteralDecoder.decodeDateLiteral(literal).unsafeCoerce()).toISOString()}")`;
+    }
     toJsonExpression({ variables, }) {
-        return code `${variables.value}.toISOString().replace(/T.*$/, '')`;
+        return code `${this.reusables.snippets.toIsoDateString}(${variables.value})`;
     }
     fromRdfResourceValueExpression({ variables, }) {
         return code `${variables.value}.toDate(${this.primitiveIn.length > 0 ? `[${this.primitiveIn.map((_) => `new Date(${_.getTime()})`).join(", ")}]` : ""})`;
     }
 }
-__decorate([
-    Memoize()
-], DateType.prototype, "graphqlType", null);
 //# sourceMappingURL=DateType.js.map

package/dist/generators/ts/DefaultValueType.d.ts

@@ -1,5 +1,5 @@
 import type { Literal, NamedNode } from "@rdfjs/types";
-import { Maybe, NonEmptyList } from "purify-ts";
+import { Maybe } from "purify-ts";
 import { AbstractContainerType } from "./AbstractContainerType.js";
 import type { AbstractType } from "./AbstractType.js";
 import type { BlankNodeType } from "./BlankNodeType.js";
@@ -10,15 +10,16 @@ export declare class DefaultValueType<ItemTypeT extends DefaultValueType.ItemTyp
     readonly discriminantProperty: Maybe<AbstractType.DiscriminantProperty>;
     readonly graphqlArgs: AbstractType["graphqlArgs"];
     readonly kind = "DefaultValueType";
-    readonly typeofs: NonEmptyList<"object">;
+    readonly typeofs: "object"[];
     constructor({ defaultValue, ...superParameters }: {
         defaultValue: Literal | NamedNode;
     } & ConstructorParameters<typeof AbstractContainerType<ItemTypeT>>[0]);
-    get conversions(): readonly AbstractContainerType.Conversion[];
+    get conversionFunction(): AbstractContainerType.ConversionFunction;
     get equalsFunction(): Code;
     get filterFunction(): Code;
     get filterType(): Code;
     get graphqlType(): AbstractContainerType.GraphqlType;
+    get hashFunction(): Code;
     get mutable(): boolean;
     get name(): Code | string;
     get schemaType(): Code;
@@ -29,12 +30,10 @@ export declare class DefaultValueType<ItemTypeT extends DefaultValueType.ItemTyp
         item: Code;
         kind: Code;
     };
-    private get defaultValuePrimitiveExpression();
-    private get defaultValueTermExpression();
+    private get defaultValueExpression();
     fromJsonExpression(parameters: Parameters<AbstractType["fromJsonExpression"]>[0]): Code;
     fromRdfResourceValuesExpression({ variables, }: Parameters<AbstractContainerType<ItemTypeT>["fromRdfResourceValuesExpression"]>[0]): Code;
     graphqlResolveExpression(parameters: Parameters<AbstractContainerType<ItemTypeT>["graphqlResolveExpression"]>[0]): Code;
-    hashStatements(parameters: Parameters<AbstractContainerType<ItemTypeT>["hashStatements"]>[0]): readonly Code[];
     jsonSchema(parameters: Parameters<AbstractContainerType<ItemTypeT>["jsonSchema"]>[0]): Code;
     jsonType(parameters?: Parameters<AbstractContainerType<ItemTypeT>["jsonType"]>[0]): AbstractType.JsonType;
     jsonUiSchemaElement(parameters: Parameters<AbstractContainerType<ItemTypeT>["jsonUiSchemaElement"]>[0]): Maybe<Code>;

package/dist/generators/ts/DefaultValueType.js

@@ -4,33 +4,32 @@ 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 { LiteralDecoder } from "@rdfx/literal";
-import { Maybe, NonEmptyList } from "purify-ts";
+import { Maybe } from "purify-ts";
 import { invariant } from "ts-invariant";
 import { Memoize } from "typescript-memoize";
 import { AbstractContainerType } from "./AbstractContainerType.js";
-import { code, literalOf } from "./ts-poet-wrapper.js";
+import { code } from "./ts-poet-wrapper.js";
 export class DefaultValueType extends AbstractContainerType {
     defaultValue;
     discriminantProperty = Maybe.empty();
     graphqlArgs = Maybe.empty();
     kind = "DefaultValueType";
-    typeofs = NonEmptyList(["object"]);
+    typeofs = ["object"];
     constructor({ defaultValue, ...superParameters }) {
         super(superParameters);
         this.defaultValue = defaultValue;
     }
-    get conversions() {
-        let conversions = this.itemType.conversions;
-        this.defaultValuePrimitiveExpression.ifJust((defaultValue) => {
-            conversions = conversions.concat({
-                conversionExpression: () => code `${defaultValue}`,
-                sourceTypeCheckExpression: (value) => code `${value} === undefined`,
-                sourceTypeName: code `undefined`,
-                sourceTypeof: "undefined",
-            });
-        });
-        return conversions;
+    get conversionFunction() {
+        const itemConversionFunction = this.itemType.conversionFunction;
+        return {
+            code: code `${this.reusables.snippets.convertWithDefaultValue}(${itemConversionFunction.code})`,
+            sourceTypes: itemConversionFunction.sourceTypes
+                .filter((sourceType) => sourceType.typeof !== "undefined")
+                .concat({
+                name: "undefined",
+                typeof: "undefined",
+            }),
+        };
     }
     get equalsFunction() {
         return this.itemType.equalsFunction;
@@ -44,6 +43,9 @@ export class DefaultValueType extends AbstractContainerType {
     get graphqlType() {
         return this.itemType.graphqlType;
     }
+    get hashFunction() {
+        return this.itemType.hashFunction;
+    }
     get mutable() {
         return this.itemType.mutable;
     }
@@ -51,7 +53,7 @@ export class DefaultValueType extends AbstractContainerType {
         return this.itemType.name;
     }
     get schemaType() {
-        return code `${this.reusables.snippets.DefaultValueSchema}`;
+        return code `${this.reusables.snippets.DefaultValueSchema}<${this.itemType.name}, ${this.itemType.schemaType}>`;
     }
     get valueSparqlConstructTriplesFunction() {
         return this.itemType.valueSparqlConstructTriplesFunction;
@@ -62,56 +64,25 @@ export class DefaultValueType extends AbstractContainerType {
     get schemaObject() {
         return {
             ...super.schemaObject,
-            defaultValue: this.defaultValueTermExpression,
+            defaultValue: this.defaultValueExpression,
         };
     }
-    get defaultValuePrimitiveExpression() {
+    get defaultValueExpression() {
         switch (this.itemType.kind) {
-            case "BigDecimalType":
-                invariant(this.defaultValue.termType === "Literal");
-                return Maybe.of(code `new ${this.reusables.imports.BigDecimal}(${literalOf(this.defaultValue.value)})`);
-            case "BigIntType":
-                invariant(this.defaultValue.termType === "Literal");
-                return Maybe.of(code `${LiteralDecoder.decodeBigIntLiteral(this.defaultValue).unsafeCoerce()}n`);
-            case "BooleanType":
-                invariant(this.defaultValue.termType === "Literal");
-                return Maybe.of(code `${LiteralDecoder.decodeBooleanLiteral(this.defaultValue).unsafeCoerce()}`);
-            case "DateType":
-                invariant(this.defaultValue.termType === "Literal");
-                return Maybe.of(code `new Date("${LiteralDecoder.decodeDateLiteral(this.defaultValue).unsafeCoerce().toISOString()}")`);
-            case "DateTimeType":
-                invariant(this.defaultValue.termType === "Literal");
-                return Maybe.of(code `new Date("${LiteralDecoder.decodeDateTimeLiteral(this.defaultValue).unsafeCoerce().toISOString()}")`);
-            case "FloatType":
-                invariant(this.defaultValue.termType === "Literal");
-                return Maybe.of(code `${LiteralDecoder.decodeFloatLiteral(this.defaultValue).unsafeCoerce()}`);
-            case "IntType":
-                invariant(this.defaultValue.termType === "Literal");
-                return Maybe.of(code `${LiteralDecoder.decodeIntLiteral(this.defaultValue).unsafeCoerce()}`);
-            case "StringType":
-                invariant(this.defaultValue.termType === "Literal");
-                return Maybe.of(code `${literalOf(this.defaultValue.value)}`);
             case "IdentifierType":
             case "IriType":
-                invariant(this.defaultValue.termType === "NamedNode");
-                return Maybe.of(this.defaultValueTermExpression);
             case "LiteralType":
             case "TermType":
-                invariant(this.defaultValue.termType === "Literal");
-                return Maybe.of(this.defaultValueTermExpression);
+                return this.rdfjsTermExpression(this.defaultValue);
             case "AnonymousUnionType":
             case "ListType":
             case "NamedObjectType":
             case "NamedObjectUnionType":
             case "NamedUnionType":
-                return Maybe.empty();
-            default:
-                this.itemType;
-                throw new Error("should never reach this point");
+                throw new RangeError(`not implemented ${this.itemType.kind}`);
         }
-    }
-    get defaultValueTermExpression() {
-        return this.rdfjsTermExpression(this.defaultValue);
+        invariant(this.defaultValue.termType === "Literal");
+        return this.itemType.literalExpression(this.defaultValue);
     }
     fromJsonExpression(parameters) {
         return this.itemType.fromJsonExpression(parameters);
@@ -120,16 +91,13 @@ export class DefaultValueType extends AbstractContainerType {
         return this.itemType.fromRdfResourceValuesExpression({
             variables: {
                 ...variables,
-                resourceValues: code `${variables.resourceValues}.map(values => values.length > 0 ? values : new ${this.reusables.imports.Resource}.Value(${{ dataFactory: this.reusables.imports.dataFactory, focusResource: variables.resource, propertyPath: variables.propertyPath, term: this.defaultValueTermExpression }}).toValues())`,
+                resourceValues: code `${variables.resourceValues}.map(values => values.length > 0 ? values : new ${this.reusables.imports.Resource}.Value(${{ dataFactory: this.reusables.imports.dataFactory, focusResource: variables.resource, propertyPath: variables.propertyPath, term: this.rdfjsTermExpression(this.defaultValue) }}).toValues())`,
             },
         });
     }
     graphqlResolveExpression(parameters) {
         return this.itemType.graphqlResolveExpression(parameters);
     }
-    hashStatements(parameters) {
-        return this.itemType.hashStatements(parameters);
-    }
     jsonSchema(parameters) {
         return this.itemType.jsonSchema(parameters);
     }
@@ -144,14 +112,15 @@ export class DefaultValueType extends AbstractContainerType {
     }
     toRdfResourceValuesExpression(parameters) {
         const { variables } = parameters;
-        return this.defaultValuePrimitiveExpression
-            .map((defaultValuePrimitiveExpression) => code `${this.itemType.equalsFunction}(${variables.value}, ${defaultValuePrimitiveExpression}).isLeft() ? ${this.itemType.toRdfResourceValuesExpression(parameters)} : []`)
-            .orDefault(code `${this.itemType.toRdfResourceValuesExpression(parameters)}.filter(value => !value.equals(${this.defaultValueTermExpression}))`);
+        return code `${this.itemType.equalsFunction}(${variables.value}, ${this.defaultValueExpression}).isLeft() ? ${this.itemType.toRdfResourceValuesExpression(parameters)} : []`;
     }
     toStringExpression(parameters) {
         return this.itemType.toStringExpression(parameters);
     }
 }
+__decorate([
+    Memoize()
+], DefaultValueType.prototype, "conversionFunction", null);
 __decorate([
     Memoize()
 ], DefaultValueType.prototype, "schemaType", null);
@@ -163,10 +132,7 @@ __decorate([
 ], DefaultValueType.prototype, "valueSparqlWherePatternsFunction", null);
 __decorate([
     Memoize()
-], DefaultValueType.prototype, "defaultValuePrimitiveExpression", null);
-__decorate([
-    Memoize()
-], DefaultValueType.prototype, "defaultValueTermExpression", null);
+], DefaultValueType.prototype, "defaultValueExpression", null);
 (function (DefaultValueType) {
     function isItemType(type) {
         if (type.kind === "BlankNodeType") {

package/dist/generators/ts/FloatType.d.ts

@@ -1,11 +1,11 @@
-import { NonEmptyList } from "purify-ts";
+import type { Literal } from "@rdfjs/types";
 import { AbstractNumericType } from "./AbstractNumericType.js";
 import { type Code } from "./ts-poet-wrapper.js";
 export declare class FloatType extends AbstractNumericType<number> {
     readonly kind = "FloatType";
-    readonly typeofs: NonEmptyList<"number">;
+    readonly typeofs: "number"[];
     get graphqlType(): import("./AbstractType.js").AbstractType.GraphqlType;
+    literalExpression(literal: Literal | number): Code;
     protected fromRdfResourceValueExpression({ variables, }: Parameters<AbstractNumericType<number>["fromRdfResourceValueExpression"]>[0]): Code;
-    protected literalOf(value: number): string;
 }
 //# sourceMappingURL=FloatType.d.ts.map

package/dist/generators/ts/FloatType.js

@@ -4,22 +4,22 @@ 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 { NonEmptyList } from "purify-ts";
+import { LiteralDecoder } from "@rdfx/literal";
 import { Memoize } from "typescript-memoize";
 import { AbstractNumericType } from "./AbstractNumericType.js";
 import { code } from "./ts-poet-wrapper.js";
 export class FloatType extends AbstractNumericType {
     kind = "FloatType";
-    typeofs = NonEmptyList(["number"]);
+    typeofs = ["number"];
     get graphqlType() {
         return new AbstractNumericType.GraphqlType(code `${this.reusables.imports.GraphQLFloat}`, this.reusables);
     }
+    literalExpression(literal) {
+        return code `${typeof literal === "number" ? literal : LiteralDecoder.decodeFloatLiteral(literal).unsafeCoerce()}`;
+    }
     fromRdfResourceValueExpression({ variables, }) {
         return code `${variables.value}.toFloat(${this.primitiveIn.length > 0 ? `${JSON.stringify(this.primitiveIn)} as const` : ""})`;
     }
-    literalOf(value) {
-        return value.toString();
-    }
 }
 __decorate([
     Memoize()

package/dist/generators/ts/IdentifierType.d.ts

@@ -1,9 +1,9 @@
 import type { BlankNode, NamedNode } from "@rdfjs/types";
 import { type IdentifierNodeKind } from "@shaclmate/shacl-ast";
 import { AbstractIdentifierType } from "./AbstractIdentifierType.js";
-import { AbstractTermType } from "./AbstractTermType.js";
 import { type Code } from "./ts-poet-wrapper.js";
 export declare class IdentifierType extends AbstractIdentifierType<BlankNode | NamedNode> {
+    readonly conversionFunction: AbstractIdentifierType.ConversionFunction;
     readonly filterFunction: Code;
     readonly filterType: Code;
     readonly parseFunction: Code;
@@ -13,10 +13,10 @@ export declare class IdentifierType extends AbstractIdentifierType<BlankNode | N
     readonly schemaType: Code;
     readonly valueSparqlWherePatternsFunction: Code;
     constructor(parameters: Omit<ConstructorParameters<typeof AbstractIdentifierType<BlankNode | NamedNode>>[0], "hasValues" | "in_">);
-    fromJsonExpression({ variables, }: Parameters<AbstractTermType<NamedNode, BlankNode | NamedNode>["fromJsonExpression"]>[0]): Code;
-    jsonType(parameters?: Parameters<AbstractTermType["jsonType"]>[0]): AbstractTermType.JsonType;
-    jsonSchema({ includeDiscriminantProperty, }: Parameters<AbstractTermType<NamedNode, BlankNode | NamedNode>["jsonSchema"]>[0]): Code;
-    toJsonExpression({ includeDiscriminantProperty, variables, }: Parameters<AbstractTermType<NamedNode, BlankNode | NamedNode>["toJsonExpression"]>[0]): Code;
-    protected fromRdfExpressionChain({ variables, }: Parameters<AbstractTermType["fromRdfExpressionChain"]>[0]): ReturnType<AbstractTermType["fromRdfExpressionChain"]>;
+    fromJsonExpression({ variables, }: Parameters<AbstractIdentifierType<BlankNode | NamedNode>["fromJsonExpression"]>[0]): Code;
+    jsonType(parameters?: Parameters<AbstractIdentifierType<BlankNode | NamedNode>["jsonType"]>[0]): AbstractIdentifierType.JsonType;
+    jsonSchema({ includeDiscriminantProperty, }: Parameters<AbstractIdentifierType<BlankNode | NamedNode>["jsonSchema"]>[0]): Code;
+    toJsonExpression({ includeDiscriminantProperty, variables, }: Parameters<AbstractIdentifierType<BlankNode | NamedNode>["toJsonExpression"]>[0]): Code;
+    protected fromRdfExpressionChain({ variables, }: Parameters<AbstractIdentifierType<BlankNode | NamedNode>["fromRdfExpressionChain"]>[0]): ReturnType<AbstractIdentifierType<BlankNode | NamedNode>["fromRdfExpressionChain"]>;
 }
 //# sourceMappingURL=IdentifierType.d.ts.map