@shaclmate/compiler 4.0.32 → 4.0.34

package/dist/generators/ts/AbstractDateType.js

@@ -4,10 +4,9 @@ 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 { Memoize } from "typescript-memoize";
 import { AbstractPrimitiveType } from "./AbstractPrimitiveType.js";
-import { code, literalOf } from "./ts-poet-wrapper.js";
+import { code } from "./ts-poet-wrapper.js";
 export class AbstractDateType extends AbstractPrimitiveType {
     equalsFunction = code `${this.reusables.snippets.dateEquals}`;
     filterFunction = code `${this.reusables.snippets.filterDate}`;
@@ -16,33 +15,10 @@ export class AbstractDateType extends AbstractPrimitiveType {
     name = "Date";
     schemaType = code `${this.reusables.snippets.DateSchema}`;
     valueSparqlWherePatternsFunction = code `${this.reusables.snippets.dateSparqlWherePatterns}`;
-    typeofs = NonEmptyList(["object"]);
-    get conversions() {
-        return [
-            {
-                conversionExpression: (value) => value,
-                sourceTypeCheckExpression: (value) => code `typeof ${value} === "object" && ${value} instanceof Date`,
-                sourceTypeName: this.name,
-                sourceTypeof: "object",
-            },
-        ];
-    }
-    get schemaObject() {
-        return {
-            ...super.schemaObject,
-            in: this.primitiveIn.length > 0
-                ? this.primitiveIn.map((inValue) => code `new Date(${literalOf(inValue.toISOString())})`)
-                : undefined,
-        };
-    }
+    typeofs = ["object"];
     fromJsonExpression({ variables, }) {
         return code `new Date(${variables.value})`;
     }
-    hashStatements({ variables, }) {
-        return [
-            code `${variables.hasher}.update(${variables.value}.toISOString());`,
-        ];
-    }
     jsonType() {
         return new AbstractPrimitiveType.JsonType(code `string`);
     }
@@ -60,9 +36,6 @@ export class AbstractDateType extends AbstractPrimitiveType {
         };
     }
 }
-__decorate([
-    Memoize()
-], AbstractDateType.prototype, "conversions", null);
 __decorate([
     Memoize()
 ], AbstractDateType.prototype, "jsonType", null);

package/dist/generators/ts/AbstractIdentifierType.d.ts

@@ -7,8 +7,11 @@ export declare abstract class AbstractIdentifierType<IdentifierT extends BlankNo
     abstract readonly nodeKinds: ReadonlySet<IdentifierNodeKind>;
     abstract readonly parseFunction: Code;
     readonly stringifyFunction: Code;
-    get conversions(): readonly AbstractTermType.Conversion[];
     get graphqlType(): import("./AbstractType.js").AbstractType.GraphqlType;
     graphqlResolveExpression({ variables: { value }, }: Parameters<AbstractTermType["graphqlResolveExpression"]>[0]): Code;
 }
+export declare namespace AbstractIdentifierType {
+    type ConversionFunction = AbstractTermType.ConversionFunction;
+    type JsonType = AbstractTermType.JsonType;
+}
 //# sourceMappingURL=AbstractIdentifierType.d.ts.map

package/dist/generators/ts/AbstractIdentifierType.js

@@ -9,20 +9,6 @@ import { AbstractTermType } from "./AbstractTermType.js";
 import { code } from "./ts-poet-wrapper.js";
 export class AbstractIdentifierType extends AbstractTermType {
     stringifyFunction = code `${this.reusables.imports.NTriplesTerm}.stringify`;
-    get conversions() {
-        const conversions = super.conversions.concat();
-        if (this.nodeKinds.has("IRI")) {
-            conversions.push({
-                conversionExpression: (value) => code `${this.reusables.imports.dataFactory}.namedNode(${value})`,
-                sourceTypeCheckExpression: (value) => code `typeof ${value} === "string"`,
-                sourceTypeName: this.in_.length > 0
-                    ? code `${this.in_.map((iri) => `"${iri.value}"`).join(" | ")}`
-                    : code `string`,
-                sourceTypeof: "string",
-            });
-        }
-        return conversions;
-    }
     get graphqlType() {
         return new AbstractTermType.GraphqlType(code `${this.reusables.imports.GraphQLString}`, this.reusables);
     }
@@ -30,9 +16,6 @@ export class AbstractIdentifierType extends AbstractTermType {
         return code `${this.reusables.imports.NTriplesTerm}.stringify(${value})`;
     }
 }
-__decorate([
-    Memoize()
-], AbstractIdentifierType.prototype, "conversions", null);
 __decorate([
     Memoize()
 ], AbstractIdentifierType.prototype, "graphqlType", null);

package/dist/generators/ts/AbstractLazyObjectType.d.ts

@@ -1,4 +1,4 @@
-import { Maybe, NonEmptyList } from "purify-ts";
+import { Maybe } from "purify-ts";
 import { AbstractType } from "./AbstractType.js";
 import type { NamedObjectType } from "./NamedObjectType.js";
 import type { NamedObjectUnionType } from "./NamedObjectUnionType.js";
@@ -16,13 +16,13 @@ export declare abstract class AbstractLazyObjectType<PartialTypeT extends Abstra
     readonly declaration: Maybe<Code>;
     readonly discriminantProperty: AbstractType["discriminantProperty"];
     readonly mutable = false;
-    readonly typeofs: NonEmptyList<"object">;
+    readonly typeofs: "object"[];
     constructor({ partialType, resolveType, ...superParameters }: {
         partialType: PartialTypeT;
         resolveType: ResolveTypeT;
     } & ConstructorParameters<typeof AbstractType>[0]);
-    get conversions(): readonly AbstractType.Conversion[];
     get equalsFunction(): Code;
+    get hashFunction(): Code;
     get filterFunction(): Code;
     get filterType(): Code;
     get graphqlType(): AbstractType.GraphqlType;
@@ -37,7 +37,6 @@ export declare abstract class AbstractLazyObjectType<PartialTypeT extends Abstra
         partial: Code;
         kind: Code;
     };
-    hashStatements({ depth, variables, }: Parameters<AbstractType["hashStatements"]>[0]): readonly Code[];
     jsonSchema(parameters: Parameters<AbstractType["jsonSchema"]>[0]): Code;
     jsonType(parameters?: Parameters<AbstractType["jsonType"]>[0]): AbstractType.JsonType;
     jsonUiSchemaElement(parameters: Parameters<AbstractType["jsonUiSchemaElement"]>[0]): Maybe<Code>;
@@ -51,12 +50,16 @@ export declare abstract class AbstractLazyObjectType<PartialTypeT extends Abstra
             resolvedObjectUnion: Code;
         };
     }): Code;
+    protected resolveToPartialFunction<ObjectTypeT extends AbstractLazyObjectType.ObjectTypeConstraint>({ partialType, resolveType, }: {
+        partialType: ObjectTypeT;
+        resolveType: ObjectTypeT;
+    }): Code;
 }
 export declare namespace AbstractLazyObjectType {
     type ObjectTypeConstraint = NamedObjectType | NamedObjectUnionType;
     type PartialTypeConstraint = ObjectTypeConstraint | OptionType<ObjectTypeConstraint> | SetType<ObjectTypeConstraint>;
     type ResolveTypeConstraint = PartialTypeConstraint;
-    type Conversion = AbstractType.Conversion;
+    type ConversionFunction = AbstractType.ConversionFunction;
     type DiscriminantProperty = AbstractType.DiscriminantProperty;
     const GraphqlType: typeof AbstractType.GraphqlType;
     type GraphqlType = AbstractType.GraphqlType;

package/dist/generators/ts/AbstractLazyObjectType.js

@@ -4,7 +4,7 @@ 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, NonEmptyList } from "purify-ts";
+import { Maybe } from "purify-ts";
 import { invariant } from "ts-invariant";
 import { Memoize } from "typescript-memoize";
 import { AbstractType } from "./AbstractType.js";
@@ -16,25 +16,18 @@ export class AbstractLazyObjectType extends AbstractType {
     declaration = Maybe.empty();
     discriminantProperty = Maybe.empty();
     mutable = false;
-    typeofs = NonEmptyList(["object"]);
+    typeofs = ["object"];
     constructor({ partialType, resolveType, ...superParameters }) {
         super(superParameters);
         this.partialType = partialType;
         this.resolveType = resolveType;
     }
-    get conversions() {
-        return [
-            {
-                conversionExpression: (value) => value,
-                sourceTypeCheckExpression: (value) => code `typeof ${value} === "object" && ${value} instanceof ${this.runtimeClass.rawName}`,
-                sourceTypeName: this.name,
-                sourceTypeof: "object",
-            },
-        ];
-    }
     get equalsFunction() {
         return code `((left, right) => ${this.partialType.equalsFunction}(left.${this.runtimeClass.partialPropertyName}, right.${this.runtimeClass.partialPropertyName}))`;
     }
+    get hashFunction() {
+        return code `((hasher, value) => ${this.partialType.hashFunction}(hasher, value.${this.runtimeClass.partialPropertyName}))`;
+    }
     get filterFunction() {
         return code `((filter: ${this.filterType}, value: ${this.name}) => ${this.partialType.filterFunction}(filter, value.${this.runtimeClass.partialPropertyName}))`;
     }
@@ -77,15 +70,6 @@ export class AbstractLazyObjectType extends AbstractType {
             // resolved: code`() => (${this.resolveType.schema})`,
         };
     }
-    hashStatements({ depth, variables, }) {
-        return this.partialType.hashStatements({
-            depth: depth + 1,
-            variables: {
-                ...variables,
-                value: code `${variables.value}.${this.runtimeClass.partialPropertyName}`,
-            },
-        });
-    }
     jsonSchema(parameters) {
         return this.partialType.jsonSchema(parameters);
     }
@@ -126,10 +110,26 @@ export class AbstractLazyObjectType extends AbstractType {
         caseBlocks.push(code `default: ${variables.resolvedObjectUnion} satisfies never; throw new Error("unrecognized type");`);
         return code `switch (${variables.resolvedObjectUnion}.${resolvedNamedObjectUnionType.discriminantProperty.unsafeCoerce().name}) { ${joinCode(caseBlocks)} }`;
     }
+    resolveToPartialFunction({ partialType, resolveType, }) {
+        if (partialType.kind === "NamedObjectType") {
+            return code `${partialType.name}.createUnsafe`;
+        }
+        invariant(partialType.kind === "NamedObjectUnionType");
+        invariant(resolveType.kind === "NamedObjectUnionType");
+        invariant(partialType.members.length === resolveType.members.length);
+        const caseBlocks = resolveType.members.map(({ discriminantValues }, memberI) => {
+            return code `${discriminantValues.map((discriminantPropertyValue) => `case "${discriminantPropertyValue}":`).join("\n")} return ${partialType.members[memberI].type.name}.createUnsafe(resolved);`;
+        });
+        caseBlocks.push(code `default: resolved satisfies never; throw new Error("unrecognized type");`);
+        return code `((resolved: ${resolveType.name}) => { switch (resolved.${resolveType.discriminantProperty.unsafeCoerce().name}) { ${joinCode(caseBlocks)} } })`;
+    }
 }
 __decorate([
     Memoize()
 ], AbstractLazyObjectType.prototype, "equalsFunction", null);
+__decorate([
+    Memoize()
+], AbstractLazyObjectType.prototype, "hashFunction", null);
 __decorate([
     Memoize()
 ], AbstractLazyObjectType.prototype, "filterFunction", null);

package/dist/generators/ts/AbstractLiteralType.d.ts

@@ -1,20 +1,28 @@
 import type { Literal } from "@rdfjs/types";
 import { AbstractTermType } from "./AbstractTermType.js";
+import { type Code } from "./ts-poet-wrapper.js";
 export declare abstract class AbstractLiteralType extends AbstractTermType<Literal, Literal> {
-    readonly nodeKinds: ReadonlySet<"Literal">;
     protected readonly languageIn: readonly string[];
+    readonly nodeKinds: ReadonlySet<"Literal">;
     constructor({ languageIn, ...superParameters }: {
         languageIn: readonly string[];
     } & ConstructorParameters<typeof AbstractTermType<Literal, Literal>>[0]);
     get constrained(): boolean;
     protected get schemaObject(): {
         languageIn: import("ts-poet/build/Node.js").Node[] | undefined;
-        kind: import("ts-poet/build/Code.js").Code;
+        in: Code | undefined;
+        kind: Code;
     };
+    /**
+     * An expression that converts a compile-time RDF/JS Literal into a runtime TypeScript literal.
+     *
+     * For example, a string would be converted to "thestring".
+     */
+    abstract literalExpression(literal: Literal): Code;
     protected fromRdfExpressionChain({ variables, }: Parameters<AbstractTermType<Literal, Literal>["fromRdfExpressionChain"]>[0]): ReturnType<AbstractTermType<Literal, Literal>["fromRdfExpressionChain"]>;
 }
 export declare namespace AbstractLiteralType {
-    type Conversion = AbstractTermType.Conversion;
+    type ConversionFunction = AbstractTermType.ConversionFunction;
     type DiscriminantProperty = AbstractTermType.DiscriminantProperty;
     const GraphqlType: typeof import("./AbstractType.js").AbstractType.GraphqlType;
     type GraphqlType = AbstractTermType.GraphqlType;

package/dist/generators/ts/AbstractLiteralType.js

@@ -1,8 +1,8 @@
 import { AbstractTermType } from "./AbstractTermType.js";
 import { code, literalOf } from "./ts-poet-wrapper.js";
 export class AbstractLiteralType extends AbstractTermType {
-    nodeKinds = nodeKinds;
     languageIn;
+    nodeKinds = nodeKinds;
     constructor({ languageIn, ...superParameters }) {
         super(superParameters);
         this.languageIn = languageIn;

package/dist/generators/ts/AbstractNamedUnionType.d.ts

@@ -1,20 +1,18 @@
 import { Maybe } from "purify-ts";
 import { AbstractType } from "./AbstractType.js";
 import { AbstractUnionType } from "./AbstractUnionType.js";
-import type { TsFeature } from "./TsFeature.js";
 import type { Type } from "./Type.js";
 import { type Code } from "./ts-poet-wrapper.js";
 export declare abstract class AbstractNamedUnionType<MemberTypeT extends Type> extends AbstractUnionType<MemberTypeT> {
     protected readonly _name: string;
-    readonly features: ReadonlySet<TsFeature>;
-    constructor({ features, name, ...superParameters }: {
-        features: ReadonlySet<TsFeature>;
+    constructor({ name, ...superParameters }: {
         name: string;
     } & ConstructorParameters<typeof AbstractUnionType<MemberTypeT>>[0]);
     get declaration(): Maybe<Code>;
     get equalsFunction(): Code;
     get filterFunction(): Code;
     get filterType(): Code;
+    get hashFunction(): Code;
     get jsonSchemaFunctionDeclaration(): Code;
     get jsonTypeAliasDeclaration(): Code;
     get name(): string;
@@ -23,7 +21,6 @@ export declare abstract class AbstractNamedUnionType<MemberTypeT extends Type> e
     protected get staticModuleDeclarations(): Record<string, Code>;
     fromJsonExpression({ variables, }: Parameters<AbstractType["fromJsonExpression"]>[0]): Code;
     fromRdfResourceValuesExpression({ variables, }: Parameters<AbstractType["fromRdfResourceValuesExpression"]>[0]): Code;
-    hashStatements({ depth, variables, }: Parameters<AbstractType["hashStatements"]>[0]): readonly Code[];
     jsonSchema({ context, }: Parameters<AbstractType["jsonSchema"]>[0]): Code;
     jsonType(): AbstractType.JsonType;
     toJsonExpression({ variables, }: Parameters<AbstractType["toJsonExpression"]>[0]): Code;

package/dist/generators/ts/AbstractNamedUnionType.js

@@ -8,14 +8,11 @@ import { Maybe } from "purify-ts";
 import { Memoize } from "typescript-memoize";
 import { AbstractType } from "./AbstractType.js";
 import { AbstractUnionType } from "./AbstractUnionType.js";
-import { syntheticNamePrefix } from "./syntheticNamePrefix.js";
 import { code, def, joinCode } from "./ts-poet-wrapper.js";
 export class AbstractNamedUnionType extends AbstractUnionType {
     _name;
-    features;
-    constructor({ features, name, ...superParameters }) {
+    constructor({ name, ...superParameters }) {
         super(superParameters);
-        this.features = features;
         this._name = name;
     }
     get declaration() {
@@ -34,10 +31,7 @@ ${joinCode(staticModuleDeclarations
         return Maybe.of(joinCode(declarations, { on: "\n\n" }));
     }
     get equalsFunction() {
-        if (this.features.has("equals")) {
-            return code `${this.name}.equals`;
-        }
-        return this.inlineEqualsFunction;
+        return code `${this.name}.equals`;
     }
     get filterFunction() {
         return code `${this.name}.filter`;
@@ -45,6 +39,9 @@ ${joinCode(staticModuleDeclarations
     get filterType() {
         return code `${this.name}.Filter`;
     }
+    get hashFunction() {
+        return code `${this.name}.hash`;
+    }
     get jsonSchemaFunctionDeclaration() {
         const meta = {
         // id: this.name,
@@ -64,20 +61,14 @@ ${joinCode(staticModuleDeclarations
         return this._name;
     }
     get valueSparqlConstructTriplesFunction() {
-        if (this.features.has("sparql")) {
-            return code `${this.name}.valueSparqlConstructTriples`;
-        }
-        return this.inlineValueSparqlConstructTriplesFunction;
+        return code `${this.name}.valueSparqlConstructTriples`;
     }
     get valueSparqlWherePatternsFunction() {
-        if (this.features.has("sparql")) {
-            return code `${this.name}.valueSparqlWherePatterns`;
-        }
-        return this.inlineValueSparqlWherePatternsFunction;
+        return code `${this.name}.valueSparqlWherePatterns`;
     }
     get staticModuleDeclarations() {
         const staticModuleDeclarations = {};
-        if (this.features.has("equals")) {
+        if (this.configuration.features.has("equals")) {
             staticModuleDeclarations[`equals`] =
                 code `export const equals = ${this.inlineEqualsFunction};`;
         }
@@ -85,11 +76,11 @@ ${joinCode(staticModuleDeclarations
             code `export type Filter = ${this.inlineFilterType};`;
         staticModuleDeclarations[`filter`] =
             code `export const filter = ${this.inlineFilterFunction};`;
-        if (this.features.has("hash")) {
+        if (this.configuration.features.has("hash")) {
             staticModuleDeclarations[`hash`] =
-                code `export function hash<HasherT extends ${this.reusables.snippets.Hasher}>(value: ${this._name}, hasher: HasherT): HasherT { ${this.inlineHashStatements({ depth: 0, variables: { hasher: code `hasher`, value: code `value` } })} return hasher; }`;
+                code `export const hash = ${this.inlineHashFunction};`;
         }
-        if (this.features.has("json")) {
+        if (this.configuration.features.has("json")) {
             staticModuleDeclarations[`Json`] = code `\
 ${this.jsonTypeAliasDeclaration}
 
@@ -107,74 +98,49 @@ export namespace Json {
             staticModuleDeclarations[`toJson`] =
                 code `export const toJson = ${this.inlineToJsonFunction};`;
         }
-        if (this.features.has("rdf")) {
+        if (this.configuration.features.has("rdf")) {
             staticModuleDeclarations[`fromRdfResourceValues`] =
                 code `export const fromRdfResourceValues: ${this.reusables.snippets.FromRdfResourceValuesFunction}<${this.name}> = ${this.inlineFromRdfResourceValuesFunction};`;
             staticModuleDeclarations[`toRdfResourceValues`] =
                 code `export const toRdfResourceValues = ${this.inlineToRdfResourceValuesFunction};`;
         }
-        if (this.features.has("sparql")) {
+        if (this.configuration.features.has("sparql")) {
             staticModuleDeclarations[`valueSparqlConstructTriples`] =
                 code `export const valueSparqlConstructTriples: ${this.reusables.snippets.ValueSparqlConstructTriplesFunction}<${this.filterType}, ${this.schemaType}> = ${this.inlineValueSparqlConstructTriplesFunction};`;
             staticModuleDeclarations[`valueSparqlWherePatterns`] =
                 code `export const valueSparqlWherePatterns: ${this.reusables.snippets.ValueSparqlWherePatternsFunction}<${this.filterType}, ${this.schemaType}> = ${this.inlineValueSparqlWherePatternsFunction};`;
         }
+        const syntheticNamePrefix = this.configuration.syntheticNamePrefix;
         staticModuleDeclarations[`${syntheticNamePrefix}toString`] =
             code `export const ${syntheticNamePrefix}toString = ${this.inlineToStringFunction};`;
         return staticModuleDeclarations;
     }
     fromJsonExpression({ variables, }) {
-        if (this.features.has("json")) {
-            return code `${this.name}.fromJson(${variables.value})`;
-        }
-        return code `${this.inlineFromJsonFunction}(${variables.value})`;
+        return code `${this.name}.fromJson(${variables.value})`;
     }
     fromRdfResourceValuesExpression({ variables, }) {
         const { resourceValues: resourceValuesVariable, ...otherVariables } = variables;
-        if (this.features.has("rdf")) {
-            return code `${this.name}.fromRdfResourceValues(${resourceValuesVariable}, ${otherVariables})`;
-        }
-        return code `${this.inlineFromRdfResourceValuesFunction}(${resourceValuesVariable}, ${otherVariables})`;
-    }
-    hashStatements({ depth, variables, }) {
-        if (this.features.has("hash")) {
-            return [
-                code `${this.name}.hash(${variables.value}, ${variables.hasher});`,
-            ];
-        }
-        return this.inlineHashStatements({ depth, variables });
+        return code `${this.name}.fromRdfResourceValues(${resourceValuesVariable}, ${otherVariables})`;
     }
     jsonSchema({ context, }) {
-        if (this.features.has("json")) {
-            const expression = code `${this.name}.Json.schema()`;
-            if (context === "property" && this.recursive) {
-                return code `${this.reusables.imports.z}.lazy((): ${this.reusables.imports.z}.ZodType<${this.name}.Json> => ${expression})`;
-            }
-            return expression;
+        const expression = code `${this.name}.Json.schema()`;
+        if (context === "property" && this.recursive) {
+            return code `${this.reusables.imports.z}.lazy((): ${this.reusables.imports.z}.ZodType<${this.name}.Json> => ${expression})`;
         }
-        return this.inlineJsonSchema;
+        return expression;
     }
     jsonType() {
-        if (this.features.has("json")) {
-            return new AbstractType.JsonType(`${this.name}.Json`);
-        }
-        return this.inlineJsonType;
+        return new AbstractType.JsonType(`${this.name}.Json`);
     }
     toJsonExpression({ variables, }) {
-        if (this.features.has("json")) {
-            return code `${this.name}.toJson(${variables.value})`;
-        }
-        return code `${this.inlineToJsonFunction}(${variables.value})`;
+        return code `${this.name}.toJson(${variables.value})`;
     }
     toRdfResourceValuesExpression({ variables, }) {
         const { value: valueVariable, ...otherVariables } = variables;
-        if (this.features.has("rdf")) {
-            return code `${this.name}.toRdfResourceValues(${valueVariable}, ${otherVariables})`;
-        }
-        return code `${this.inlineToRdfResourceValuesFunction}(${valueVariable}, ${otherVariables})`;
+        return code `${this.name}.toRdfResourceValues(${valueVariable}, ${otherVariables})`;
     }
     toStringExpression({ variables, }) {
-        return code `${this.name}.${syntheticNamePrefix}toString(${variables.value})`;
+        return code `${this.name}.${this.configuration.syntheticNamePrefix}toString(${variables.value})`;
     }
 }
 __decorate([
@@ -189,6 +155,9 @@ __decorate([
 __decorate([
     Memoize()
 ], AbstractNamedUnionType.prototype, "filterType", null);
+__decorate([
+    Memoize()
+], AbstractNamedUnionType.prototype, "hashFunction", null);
 __decorate([
     Memoize()
 ], AbstractNamedUnionType.prototype, "name", null);

package/dist/generators/ts/AbstractNumericType.d.ts

@@ -4,17 +4,20 @@ import { type Code } from "./ts-poet-wrapper.js";
  * Abstract base class for TypeScript numeric types (bigint | number).
  */
 export declare abstract class AbstractNumericType<ValueT extends bigint | number> extends AbstractPrimitiveType<ValueT> {
+    readonly hashFunction: Code;
     abstract readonly kind: "BigIntType" | "FloatType" | "IntType";
+    get conversionFunction(): {
+        code: Code;
+        sourceTypes: {
+            name: string | Code;
+            typeof: import("./Typeof.js").Typeof;
+        }[];
+    };
     get filterFunction(): Code;
     get filterType(): Code;
-    get name(): string;
+    get name(): Code | string;
     get schemaType(): Code;
     get valueSparqlWherePatternsFunction(): Code;
-    protected get schemaObject(): {
-        in: Code[] | undefined;
-        languageIn: import("ts-poet/build/Node.js").Node[] | undefined;
-        kind: Code;
-    };
     jsonSchema(_parameters: Parameters<AbstractPrimitiveType<ValueT>["jsonSchema"]>[0]): Code;
     toRdfResourceValuesExpression({ variables, }: Parameters<AbstractPrimitiveType<string>["toRdfResourceValuesExpression"]>[0]): Code;
     protected fromRdfExpressionChain({ variables, }: Parameters<AbstractPrimitiveType<ValueT>["fromRdfExpressionChain"]>[0]): ReturnType<AbstractPrimitiveType<ValueT>["fromRdfExpressionChain"]>;
@@ -23,10 +26,8 @@ export declare abstract class AbstractNumericType<ValueT extends bigint | number
             value: Code;
         };
     }): Code;
-    protected abstract literalOf(value: ValueT): string;
 }
 export declare namespace AbstractNumericType {
-    type Conversion = AbstractPrimitiveType.Conversion;
     const JsonType: typeof import("./AbstractType.js").AbstractType.JsonType;
     type JsonType = AbstractPrimitiveType.JsonType;
 }

package/dist/generators/ts/AbstractNumericType.js

@@ -11,6 +11,18 @@ import { code, joinCode } from "./ts-poet-wrapper.js";
  * Abstract base class for TypeScript numeric types (bigint | number).
  */
 export class AbstractNumericType extends AbstractPrimitiveType {
+    hashFunction = code `${this.reusables.snippets.hashNumeric}`;
+    get conversionFunction() {
+        return {
+            code: code `${this.reusables.snippets.convertToNumeric}<${this.name}>`,
+            sourceTypes: [
+                {
+                    name: this.name,
+                    typeof: this.typeofs[0],
+                },
+            ],
+        };
+    }
     get filterFunction() {
         return code `${this.reusables.snippets.filterNumeric}<${this.typeofs[0]}>`;
     }
@@ -19,7 +31,7 @@ export class AbstractNumericType extends AbstractPrimitiveType {
     }
     get name() {
         if (this.primitiveIn.length > 0) {
-            return `${this.primitiveIn.map((value) => this.literalOf(value)).join(" | ")}`;
+            return code `${joinCode(this.primitiveIn.map((value) => this.literalExpression(value)), { on: " | " })}`;
         }
         return this.typeofs[0];
     }
@@ -29,22 +41,14 @@ export class AbstractNumericType extends AbstractPrimitiveType {
     get valueSparqlWherePatternsFunction() {
         return code `${this.reusables.snippets.numericSparqlWherePatterns}<${this.typeofs[0]}>`;
     }
-    get schemaObject() {
-        return {
-            ...super.schemaObject,
-            in: this.primitiveIn.length > 0
-                ? this.primitiveIn.map((_) => code `${this.literalOf(_)}`)
-                : undefined,
-        };
-    }
     jsonSchema(_parameters) {
         switch (this.primitiveIn.length) {
             case 0:
                 return code `${this.reusables.imports.z}.${this.typeofs[0]}()`;
             case 1:
-                return code `${this.reusables.imports.z}.literal(${this.literalOf(this.primitiveIn[0])})`;
+                return code `${this.reusables.imports.z}.literal(${this.literalExpression(this.primitiveIn[0])})`;
             default:
-                return code `${this.reusables.imports.z}.union([${joinCode(this.primitiveIn.map((value) => code `${this.reusables.imports.z}.literal(${this.literalOf(value)})`), { on: "," })}])`;
+                return code `${this.reusables.imports.z}.union([${joinCode(this.primitiveIn.map((value) => code `${this.reusables.imports.z}.literal(${this.literalExpression(value)})`), { on: "," })}])`;
         }
     }
     toRdfResourceValuesExpression({ variables, }) {
@@ -61,6 +65,9 @@ export class AbstractNumericType extends AbstractPrimitiveType {
         };
     }
 }
+__decorate([
+    Memoize()
+], AbstractNumericType.prototype, "conversionFunction", null);
 __decorate([
     Memoize()
 ], AbstractNumericType.prototype, "filterFunction", null);

package/dist/generators/ts/AbstractPrimitiveType.d.ts

@@ -1,4 +1,4 @@
-import type { NamedNode } from "@rdfjs/types";
+import type { Literal, NamedNode } from "@rdfjs/types";
 import { Maybe } from "purify-ts";
 import { AbstractLiteralType } from "./AbstractLiteralType.js";
 import { type Code } from "./ts-poet-wrapper.js";
@@ -11,16 +11,20 @@ export declare abstract class AbstractPrimitiveType<ValueT extends bigint | bool
         datatype: NamedNode;
         primitiveIn: readonly ValueT[];
     } & ConstructorParameters<typeof AbstractLiteralType>[0]);
-    get conversions(): readonly AbstractPrimitiveType.Conversion[];
     get discriminantProperty(): Maybe<AbstractLiteralType.DiscriminantProperty>;
+    protected get schemaObject(): {
+        in: Code | undefined;
+        languageIn: import("ts-poet/build/Node.js").Node[] | undefined;
+        kind: Code;
+    };
     fromJsonExpression({ variables, }: Parameters<AbstractLiteralType["fromJsonExpression"]>[0]): Code;
     graphqlResolveExpression({ variables, }: Parameters<AbstractLiteralType["graphqlResolveExpression"]>[0]): Code;
-    hashStatements({ variables, }: Parameters<AbstractLiteralType["hashStatements"]>[0]): readonly Code[];
     jsonType(): AbstractLiteralType.JsonType;
+    abstract literalExpression(literal: Literal | ValueT): Code;
     toJsonExpression({ variables, }: Parameters<AbstractLiteralType["toJsonExpression"]>[0]): Code;
 }
 export declare namespace AbstractPrimitiveType {
-    type Conversion = AbstractLiteralType.Conversion;
+    type ConversionFunction = AbstractLiteralType.ConversionFunction;
     type DiscriminantProperty = AbstractLiteralType.DiscriminantProperty;
     const GraphqlType: typeof import("./AbstractType.js").AbstractType.GraphqlType;
     type GraphqlType = AbstractLiteralType.GraphqlType;