@shaclmate/compiler 4.0.33 → 4.0.35

package/dist/generators/ts/AnonymousUnionType.d.ts

@@ -11,13 +11,13 @@ export declare class AnonymousUnionType extends AbstractUnionType<Type> {
     get filterFunction(): Code;
     get filterType(): Code;
     get graphqlType(): AbstractType.GraphqlType;
+    get hashFunction(): Code;
     get name(): Code;
     get valueSparqlConstructTriplesFunction(): Code;
     get valueSparqlWherePatternsFunction(): Code;
     fromJsonExpression({ variables, }: Parameters<AbstractType["fromJsonExpression"]>[0]): Code;
     fromRdfResourceValuesExpression({ variables, }: Parameters<AbstractType["fromRdfResourceValuesExpression"]>[0]): Code;
     graphqlResolveExpression(_parameters: Parameters<AbstractType["graphqlResolveExpression"]>[0]): Code;
-    hashStatements(parameters: Parameters<AbstractType["hashStatements"]>[0]): readonly Code[];
     jsonSchema(_parameters: Parameters<AbstractType["jsonSchema"]>[0]): Code;
     jsonType(): AbstractType.JsonType;
     toJsonExpression({ variables, }: Parameters<AbstractType["toJsonExpression"]>[0]): Code;

package/dist/generators/ts/AnonymousUnionType.js

@@ -17,6 +17,9 @@ export class AnonymousUnionType extends AbstractUnionType {
     get graphqlType() {
         throw new Error("GraphQL doesn't support scalar unions");
     }
+    get hashFunction() {
+        return this.inlineHashFunction;
+    }
     get name() {
         return this.inlineName;
     }
@@ -36,9 +39,6 @@ export class AnonymousUnionType extends AbstractUnionType {
     graphqlResolveExpression(_parameters) {
         throw new Error("not implemented");
     }
-    hashStatements(parameters) {
-        return this.inlineHashStatements(parameters);
-    }
     jsonSchema(_parameters) {
         return this.inlineJsonSchema;
     }

package/dist/generators/ts/BigDecimalType.d.ts

@@ -1,21 +1,24 @@
+import type { Literal } from "@rdfjs/types";
+import { Maybe } from "purify-ts";
 import { AbstractLiteralType } from "./AbstractLiteralType.js";
 import { type Code } from "./ts-poet-wrapper.js";
 export declare class BigDecimalType extends AbstractLiteralType {
+    readonly name: Code;
+    readonly conversionFunction: Maybe<AbstractLiteralType.ConversionFunction>;
     readonly filterFunction: Code;
     readonly filterType: Code;
+    readonly hashFunction: Code;
     readonly kind = "BigDecimalType";
-    readonly name: Code;
     readonly schemaType: Code;
     readonly valueSparqlWherePatternsFunction: Code;
-    get conversions(): readonly AbstractLiteralType.Conversion[];
     get graphqlType(): import("./AbstractType.js").AbstractType.GraphqlType;
     fromJsonExpression({ variables, }: Parameters<AbstractLiteralType["fromJsonExpression"]>[0]): Code;
     graphqlResolveExpression({ variables, }: Parameters<AbstractLiteralType["graphqlResolveExpression"]>[0]): Code;
-    hashStatements({ variables, }: Parameters<AbstractLiteralType["hashStatements"]>[0]): readonly Code[];
     jsonSchema(): Code;
     jsonType(): AbstractLiteralType.JsonType;
+    literalExpression(literal: Literal): Code;
     toJsonExpression({ variables, }: Parameters<AbstractLiteralType["toJsonExpression"]>[0]): Code;
     toRdfResourceValuesExpression({ variables, }: Parameters<AbstractLiteralType["toRdfResourceValuesExpression"]>[0]): Code;
-    protected fromRdfExpressionChain({ variables, }: Parameters<AbstractLiteralType["fromRdfExpressionChain"]>[0]): ReturnType<AbstractLiteralType["fromRdfExpressionChain"]>;
+    protected fromRdfResourceValuesExpressionChain({ variables, }: Parameters<AbstractLiteralType["fromRdfResourceValuesExpressionChain"]>[0]): ReturnType<AbstractLiteralType["fromRdfResourceValuesExpressionChain"]>;
 }
 //# sourceMappingURL=BigDecimalType.d.ts.map

package/dist/generators/ts/BigDecimalType.js

@@ -4,84 +4,50 @@ 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 { Maybe } from "purify-ts";
 import { Memoize } from "typescript-memoize";
 import { AbstractLiteralType } from "./AbstractLiteralType.js";
-import { code } from "./ts-poet-wrapper.js";
+import { code, literalOf } from "./ts-poet-wrapper.js";
 export class BigDecimalType extends AbstractLiteralType {
+    name = code `${this.reusables.imports.BigDecimal}`;
+    conversionFunction = Maybe.empty();
     filterFunction = code `${this.reusables.snippets.filterBigDecimal}`;
     filterType = code `${this.reusables.snippets.NumericFilter}<${this.reusables.imports.BigDecimal}>`;
+    hashFunction = code `${this.reusables.snippets.hashBigDecimal}`;
     kind = "BigDecimalType";
-    name = code `${this.reusables.imports.BigDecimal}`;
     schemaType = code `${this.reusables.snippets.NumericSchema}<${this.reusables.imports.BigDecimal}>`;
     valueSparqlWherePatternsFunction = code `${this.reusables.snippets.bigDecimalSparqlWherePatterns}`;
-    get conversions() {
-        return [
-            // {
-            //   conversionExpression: (value) =>
-            //     code`new ${this.reusables.imports.BigDecimal}(${value}.toString())`,
-            //   sourceTypeCheckExpression: (value) =>
-            //     code`typeof ${value} === "bigint"`,
-            //   sourceTypeName: code`bigint`,
-            //   sourceTypeof: "bigint",
-            // },
-            {
-                conversionExpression: (value) => value,
-                sourceTypeCheckExpression: (value) => code `typeof ${value} === "object"`,
-                sourceTypeName: code `${this.reusables.imports.BigDecimal}`,
-                sourceTypeof: "object",
-            },
-            // {
-            //   conversionExpression: (value) =>
-            //     code`new ${this.reusables.imports.BigDecimal}(${value})`,
-            //   sourceTypeCheckExpression: (value) =>
-            //     code`typeof ${value} === "number"`,
-            //   sourceTypeName: code`number`,
-            //   sourceTypeof: "number",
-            // },
-            // {
-            //   conversionExpression: (value) =>
-            //     code`new ${this.reusables.imports.BigDecimal}(${value})`,
-            //   sourceTypeCheckExpression: (value) =>
-            //     code`typeof ${value} === "string"`,
-            //   sourceTypeName: code`string`,
-            //   sourceTypeof: "string",
-            // },
-        ];
-    }
     get graphqlType() {
         return new AbstractLiteralType.GraphqlType(code `${this.reusables.imports.GraphQLString}`, this.reusables);
     }
     fromJsonExpression({ variables, }) {
-        return code `new ${this.reusables.imports.BigDecimal}(${variables.value})`;
+        return code `${this.reusables.imports.Either}.encase<Error, ${this.name}>(() => new ${this.name}(${variables.value}))`;
     }
     graphqlResolveExpression({ variables, }) {
         return code `${variables.value}.toFixed()`;
     }
-    hashStatements({ variables, }) {
-        return [code `${variables.hasher}.update(${variables.value}.toFixed());`];
-    }
     jsonSchema() {
         return code `${this.reusables.imports.z}.string()`;
     }
     jsonType() {
         return new AbstractLiteralType.JsonType("string");
     }
+    literalExpression(literal) {
+        return code `new ${this.reusables.imports.BigDecimal}(${literalOf(literal.value)})`;
+    }
     toJsonExpression({ variables, }) {
         return code `${variables.value}.toFixed()`;
     }
     toRdfResourceValuesExpression({ variables, }) {
         return code `[${this.reusables.snippets.bigDecimalLiteral}(${variables.value})]`;
     }
-    fromRdfExpressionChain({ variables, }) {
+    fromRdfResourceValuesExpressionChain({ variables, }) {
         return {
-            ...super.fromRdfExpressionChain({ variables }),
+            ...super.fromRdfResourceValuesExpressionChain({ variables }),
             valueTo: code `chain(values => values.chainMap(value => value.toLiteral().chain(${this.reusables.snippets.decodeBigDecimalLiteral})))`,
         };
     }
 }
-__decorate([
-    Memoize()
-], BigDecimalType.prototype, "conversions", null);
 __decorate([
     Memoize()
 ], BigDecimalType.prototype, "graphqlType", null);

package/dist/generators/ts/BigIntType.d.ts

@@ -1,16 +1,15 @@
-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 BigIntType extends AbstractNumericType<bigint> {
     readonly kind = "BigIntType";
-    readonly typeofs: NonEmptyList<"bigint">;
+    readonly typeofs: "bigint"[];
     get graphqlType(): import("./AbstractType.js").AbstractType.GraphqlType;
-    get conversions(): readonly AbstractNumericType.Conversion[];
     fromJsonExpression({ variables, }: Parameters<AbstractNumericType<bigint>["fromJsonExpression"]>[0]): Code;
     jsonSchema(_parameters: Parameters<AbstractNumericType<bigint>["jsonSchema"]>[0]): Code;
     jsonType(): AbstractNumericType.JsonType;
+    literalExpression(literal: bigint | Literal): Code;
     toJsonExpression({ variables, }: Parameters<AbstractNumericType<bigint>["toJsonExpression"]>[0]): Code;
     protected fromRdfResourceValueExpression({ variables, }: Parameters<AbstractNumericType<bigint>["fromRdfResourceValueExpression"]>[0]): Code;
-    protected literalOf(value: bigint): string;
 }
 //# sourceMappingURL=BigIntType.d.ts.map

package/dist/generators/ts/BigIntType.js

@@ -4,33 +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, 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) {
             expression = code `${expression} as ${this.name}`;
         }
-        return expression;
+        return code `${this.reusables.imports.Either}.encase<Error, ${this.name}>(() => ${expression})`;
     }
     jsonSchema(_parameters) {
         switch (this.primitiveIn.length) {
@@ -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,9 @@
-import type { BlankNode, NamedNode } from "@rdfjs/types";
+import type { BlankNode } from "@rdfjs/types";
+import { Maybe } from "purify-ts";
 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: Maybe<AbstractIdentifierType.ConversionFunction>;
     readonly filterFunction: Code;
     readonly filterType: Code;
     readonly parseFunction: Code;
@@ -12,11 +13,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 fromRdfResourceValuesExpressionChain({ variables, }: Parameters<AbstractIdentifierType<BlankNode>["fromRdfResourceValuesExpressionChain"]>[0]): {
         valueTo: Code;
         hasValues?: Code;
         languageIn?: Code;

package/dist/generators/ts/BlankNodeType.js

@@ -4,11 +4,24 @@ 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 { Maybe } from "purify-ts";
 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 = Maybe.of({
+        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};`;
@@ -25,13 +38,13 @@ export class BlankNodeType extends AbstractIdentifierType {
         });
     }
     fromJsonExpression({ variables, }) {
-        return code `${this.reusables.imports.dataFactory}.blankNode(${variables.value}["@id"].substring(2))`;
+        return code `${this.reusables.imports.Either}.of<Error, ${this.name}>(${this.reusables.imports.dataFactory}.blankNode(${variables.value}["@id"].substring(2)))`;
     }
     jsonType(parameters) {
         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
@@ -45,9 +58,9 @@ export class BlankNodeType extends AbstractIdentifierType {
             : "";
         return code `{ "@id": \`_:\${${variables.value}.value}\`${discriminantProperty} }`;
     }
-    fromRdfExpressionChain({ variables, }) {
+    fromRdfResourceValuesExpressionChain({ variables, }) {
         return {
-            ...super.fromRdfExpressionChain({ variables }),
+            ...super.fromRdfResourceValuesExpressionChain({ variables }),
             valueTo: code `chain(values => values.chainMap(value => value.toBlankNode()))`,
         };
     }

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

@@ -1,22 +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 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"]>;
+    protected fromRdfResourceValuesExpressionChain({ variables, }: Parameters<AbstractPrimitiveType<boolean>["fromRdfResourceValuesExpressionChain"]>[0]): ReturnType<AbstractPrimitiveType<boolean>["fromRdfResourceValuesExpressionChain"]>;
 }
 //# sourceMappingURL=BooleanType.d.ts.map

package/dist/generators/ts/BooleanType.js

@@ -4,53 +4,46 @@ 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 name() {
         if (this.primitiveIn.length > 0) {
             return `${this.primitiveIn.map((value) => value.toString()).join(" | ")}`;
         }
         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)})]`;
     }
-    fromRdfExpressionChain({ variables, }) {
+    fromRdfResourceValuesExpressionChain({ variables, }) {
         return {
-            ...super.fromRdfExpressionChain({ variables }),
+            ...super.fromRdfResourceValuesExpressionChain({ variables }),
             languageIn: undefined,
             preferredLanguages: undefined,
             valueTo: code `chain(values => values.chainMap(value => value.toBoolean(${this.primitiveIn.length === 1 ? `[${this.primitiveIn[0]}] as const` : ""})))`,
         };
     }
 }
-__decorate([
-    Memoize()
-], BooleanType.prototype, "graphqlType", null);
 __decorate([
     Memoize()
 ], BooleanType.prototype, "name", null);

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

@@ -1,9 +1,12 @@
+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 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,16 @@
-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 {
+    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 +18,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,13 @@
+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 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,22 @@
-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 {
+    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,17 @@ 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"[];
+    readonly validationFunction: Maybe<Code>;
     constructor({ defaultValue, ...superParameters }: {
         defaultValue: Literal | NamedNode;
     } & ConstructorParameters<typeof AbstractContainerType<ItemTypeT>>[0]);
-    get conversions(): readonly AbstractContainerType.Conversion[];
+    get conversionFunction(): Maybe<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 +31,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>;