@shaclmate/compiler 4.0.33 → 4.0.34

package/dist/generators/ts/AbstractPrimitiveType.js

@@ -7,7 +7,7 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 import { Maybe } from "purify-ts";
 import { Memoize } from "typescript-memoize";
 import { AbstractLiteralType } from "./AbstractLiteralType.js";
-import { code } from "./ts-poet-wrapper.js";
+import { code, joinCode } from "./ts-poet-wrapper.js";
 export class AbstractPrimitiveType extends AbstractLiteralType {
     datatype;
     equalsFunction = code `${this.reusables.snippets.strictEquals}`;
@@ -17,28 +17,23 @@ export class AbstractPrimitiveType extends AbstractLiteralType {
         this.datatype = datatype;
         this.primitiveIn = primitiveIn;
     }
-    get conversions() {
-        return [
-            {
-                conversionExpression: (value) => value,
-                sourceTypeCheckExpression: (value) => code `typeof ${value} === "${this.typeofs[0]}"`,
-                sourceTypeName: this.name,
-                sourceTypeof: this.typeofs[0],
-            },
-        ];
-    }
     get discriminantProperty() {
         return Maybe.empty();
     }
+    get schemaObject() {
+        return {
+            ...super.schemaObject,
+            in: this.primitiveIn.length > 0
+                ? code `[${joinCode(this.primitiveIn.map((in_) => this.literalExpression(in_)), { on: ", " })}] as const`
+                : undefined,
+        };
+    }
     fromJsonExpression({ variables, }) {
         return variables.value;
     }
     graphqlResolveExpression({ variables, }) {
         return variables.value;
     }
-    hashStatements({ variables, }) {
-        return [code `${variables.hasher}.update(${variables.value}.toString());`];
-    }
     jsonType() {
         return new AbstractLiteralType.JsonType(this.name);
     }
@@ -46,9 +41,6 @@ export class AbstractPrimitiveType extends AbstractLiteralType {
         return variables.value;
     }
 }
-__decorate([
-    Memoize()
-], AbstractPrimitiveType.prototype, "conversions", null);
 __decorate([
     Memoize()
 ], AbstractPrimitiveType.prototype, "jsonType", null);

package/dist/generators/ts/AbstractTermType.d.ts

@@ -3,6 +3,7 @@ import { NodeKind } from "@shaclmate/shacl-ast";
 import { Maybe } from "purify-ts";
 import { AbstractType } from "./AbstractType.js";
 import type { Type } from "./Type.js";
+import type { Typeof } from "./Typeof.js";
 import { type Code } from "./ts-poet-wrapper.js";
 /**
  * Abstract base class for IdentifierType and LiteralType.
@@ -17,24 +18,27 @@ export declare abstract class AbstractTermType<ConstantTermT extends Literal | N
     readonly equalsFunction: Code;
     readonly graphqlArgs: AbstractType["graphqlArgs"];
     readonly hasValues: readonly ConstantTermT[];
+    readonly hashFunction: Code;
     readonly in_: readonly ConstantTermT[];
     readonly mutable: boolean;
     abstract readonly nodeKinds: ReadonlySet<NodeKind>;
     readonly recursive = false;
-    readonly typeofs: AbstractType["typeofs"];
+    readonly typeofs: readonly Typeof[];
     constructor({ hasValues, in_, ...superParameters }: {
         hasValues: readonly ConstantTermT[];
         in_: readonly ConstantTermT[];
     } & ConstructorParameters<typeof AbstractType>[0]);
     get constrained(): boolean;
-    get conversions(): readonly AbstractType.Conversion[];
     get discriminantProperty(): Maybe<AbstractType.DiscriminantProperty>;
     get schema(): Code;
+    protected get schemaObject(): {
+        in: Code | undefined;
+        kind: Code;
+    };
     get termTypes(): ReadonlySet<"BlankNode" | "Literal" | "NamedNode">;
     get toRdfResourceValueTypes(): Set<"BlankNode" | "Literal" | "NamedNode">;
     get valueSparqlConstructTriplesFunction(): Code;
     fromRdfResourceValuesExpression(parameters: Parameters<AbstractType["fromRdfResourceValuesExpression"]>[0]): Code;
-    hashStatements({ variables, }: Parameters<AbstractType["hashStatements"]>[0]): readonly Code[];
     jsonUiSchemaElement(): Maybe<Code>;
     toRdfResourceValuesExpression({ variables, }: Parameters<AbstractType["toRdfResourceValuesExpression"]>[0]): Code;
     toStringExpression({ variables, }: Parameters<AbstractType["toStringExpression"]>[0]): Code;
@@ -55,7 +59,7 @@ export declare abstract class AbstractTermType<ConstantTermT extends Literal | N
     };
 }
 export declare namespace AbstractTermType {
-    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/AbstractTermType.js

@@ -5,7 +5,7 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
 import { NodeKind } from "@shaclmate/shacl-ast";
-import { Maybe, NonEmptyList } from "purify-ts";
+import { Maybe } from "purify-ts";
 import { Memoize } from "typescript-memoize";
 import { AbstractType } from "./AbstractType.js";
 import { removeUndefined } from "./removeUndefined.js";
@@ -23,12 +23,11 @@ export class AbstractTermType extends AbstractType {
     equalsFunction = code `${this.reusables.snippets.booleanEquals}`;
     graphqlArgs = Maybe.empty();
     hasValues;
+    hashFunction = code `${this.reusables.snippets.hashTerm}`;
     in_;
     mutable = false;
     recursive = false;
-    typeofs = NonEmptyList([
-        "object",
-    ]);
+    typeofs = ["object"];
     constructor({ hasValues, in_, ...superParameters }) {
         super(superParameters);
         this.hasValues = hasValues;
@@ -37,44 +36,6 @@ export class AbstractTermType extends AbstractType {
     get constrained() {
         return this.hasValues.length > 0 || this.in_.length > 0;
     }
-    get conversions() {
-        const conversions = [];
-        if (this.nodeKinds.has("Literal")) {
-            conversions.push({
-                conversionExpression: (value) => code `${this.reusables.snippets.literalFactory}.bigint(${value})`,
-                sourceTypeCheckExpression: (value) => code `typeof ${value} === "bigint"`,
-                sourceTypeName: code `bigint`,
-                sourceTypeof: "bigint",
-            }, {
-                conversionExpression: (value) => code `${this.reusables.snippets.literalFactory}.boolean(${value})`,
-                sourceTypeCheckExpression: (value) => code `typeof ${value} === "boolean"`,
-                sourceTypeName: code `boolean`,
-                sourceTypeof: "boolean",
-            }, {
-                conversionExpression: (value) => code `${this.reusables.snippets.literalFactory}.date(${value})`,
-                sourceTypeCheckExpression: (value) => code `typeof ${value} === "object" && ${value} instanceof Date`,
-                sourceTypeName: code `Date`,
-                sourceTypeof: "object",
-            }, {
-                conversionExpression: (value) => code `${this.reusables.snippets.literalFactory}.number(${value})`,
-                sourceTypeCheckExpression: (value) => code `typeof ${value} === "number"`,
-                sourceTypeName: code `number`,
-                sourceTypeof: "number",
-            }, {
-                conversionExpression: (value) => code `${this.reusables.snippets.literalFactory}.string(${value})`,
-                sourceTypeCheckExpression: (value) => code `typeof ${value} === "string"`,
-                sourceTypeName: code `string`,
-                sourceTypeof: "string",
-            });
-        }
-        conversions.push({
-            conversionExpression: (value) => value,
-            sourceTypeCheckExpression: (value) => code `typeof ${value} === "object"`,
-            sourceTypeName: this.name,
-            sourceTypeof: "object",
-        });
-        return conversions;
-    }
     get discriminantProperty() {
         return Maybe.of({
             descendantValues: [],
@@ -87,6 +48,14 @@ export class AbstractTermType extends AbstractType {
     get schema() {
         return code `${removeUndefined(this.schemaObject)}`;
     }
+    get schemaObject() {
+        return {
+            ...super.schemaObject,
+            in: this.in_.length > 0
+                ? code `[${joinCode(this.in_.map((in_) => this.rdfjsTermExpression(in_)), { on: ", " })}] as const`
+                : undefined,
+        };
+    }
     get termTypes() {
         return new Set([...this.nodeKinds].map(NodeKind.toTermType));
     }
@@ -112,12 +81,6 @@ export class AbstractTermType extends AbstractType {
             chain.valueTo,
         ].filter((_) => _ !== undefined), { on: "." });
     }
-    hashStatements({ variables, }) {
-        return [
-            code `${variables.hasher}.update(${variables.value}.termType);`,
-            code `${variables.hasher}.update(${variables.value}.value);`,
-        ];
-    }
     jsonUiSchemaElement() {
         return Maybe.empty();
     }
@@ -161,9 +124,6 @@ chain(values => ${this.reusables.imports.Either}.sequence([${joinCode(this.hasVa
         };
     }
 }
-__decorate([
-    Memoize()
-], AbstractTermType.prototype, "conversions", null);
 __decorate([
     Memoize()
 ], AbstractTermType.prototype, "discriminantProperty", null);

package/dist/generators/ts/AbstractType.d.ts

@@ -1,24 +1,31 @@
-import type { Maybe, NonEmptyList } from "purify-ts";
+import type { Maybe } from "purify-ts";
 import type { Logger } from "ts-log";
 import type { Reusables } from "./Reusables.js";
 import { rdfjsTermExpression } from "./rdfjsTermExpression.js";
+import type { TsGenerator } from "./TsGenerator.js";
 import type { Typeof } from "./Typeof.js";
 import { type Code } from "./ts-poet-wrapper.js";
 /**
  * Abstract base class all types.
  */
 export declare abstract class AbstractType {
+    protected readonly configuration: TsGenerator.Configuration;
     protected readonly logger: Logger;
     protected readonly reusables: Reusables;
-    protected readonly rdfjsTermExpression: (parameters: Parameters<typeof rdfjsTermExpression>[0]) => Code;
     /**
      * Comment from rdfs:comment.
      */
     readonly comment: Maybe<string>;
     /**
-     * Expressions that convert a source type or types to this type. It should include the type itself.
+     * Function that converts one or more source types to this type and returns Either<Error, ThisType>.
+     *
+     * The function takes two parameters:
+     *  - an instance of this.schemaType
+     *  - a value with one of the source types
+     *
+     * The source types should include this type.
      */
-    abstract readonly conversions: readonly AbstractType.Conversion[];
+    abstract readonly conversionFunction: AbstractType.ConversionFunction;
     /**
      * The declaration of named types.
      */
@@ -52,7 +59,11 @@ export declare abstract class AbstractType {
      */
     abstract readonly graphqlType: AbstractType.GraphqlType;
     /**
-     * Type discriminator.
+     * A function (reference or declaration) that takes a  Hasher and a value of this type, calls hasher.update on the value, and returns the Hasher.
+     */
+    abstract readonly hashFunction: Code;
+    /**
+     * Type discriminant.
      */
     abstract readonly kind: string;
     /**
@@ -86,7 +97,7 @@ export declare abstract class AbstractType {
     /**
      * JavaScript typeof(s) the type.
      */
-    abstract readonly typeofs: NonEmptyList<Typeof>;
+    abstract readonly typeofs: readonly Typeof[];
     /**
      * A ValueSparqlConstructTriplesFunction (reference or declaration) that returns an array of sparqljs.Triple's for a property value of this type.
      *
@@ -110,8 +121,9 @@ export declare abstract class AbstractType {
      * - variablePrefix: string prefix to use for new variables
      */
     abstract readonly valueSparqlWherePatternsFunction: Code;
-    constructor({ comment, label, logger, reusables, }: {
+    constructor({ comment, configuration, label, logger, reusables, }: {
         comment: Maybe<string>;
+        configuration: TsGenerator.Configuration;
         label: Maybe<string>;
         logger: Logger;
         reusables: Reusables;
@@ -175,16 +187,6 @@ export declare abstract class AbstractType {
             value: Code;
         };
     }): Code;
-    /**
-     * Statements that use hasher.update to hash a property value of this type.
-     */
-    abstract hashStatements(parameters: {
-        depth: number;
-        variables: {
-            hasher: Code;
-            value: Code;
-        };
-    }): readonly Code[];
     /**
      * Zod schema for the JSON type of this type.
      *
@@ -250,13 +252,15 @@ export declare abstract class AbstractType {
             value: Code;
         };
     }): Code;
+    protected readonly rdfjsTermExpression: (parameters: Parameters<typeof rdfjsTermExpression>[0]) => Code;
 }
 export declare namespace AbstractType {
-    interface Conversion {
-        readonly conversionExpression: (value: Code) => Code;
-        readonly sourceTypeCheckExpression: (value: Code) => Code;
-        readonly sourceTypeName: Code | string;
-        readonly sourceTypeof: Typeof;
+    interface ConversionFunction {
+        readonly code: Code;
+        readonly sourceTypes: {
+            readonly name: Code | string;
+            readonly typeof: Typeof;
+        }[];
     }
     interface DiscriminantProperty {
         readonly descendantValues: readonly DiscriminantProperty.Value[];

package/dist/generators/ts/AbstractType.js

@@ -12,9 +12,9 @@ import { code, literalOf } from "./ts-poet-wrapper.js";
  * Abstract base class all types.
  */
 export class AbstractType {
+    configuration;
     logger;
     reusables;
-    rdfjsTermExpression;
     /**
      * Comment from rdfs:comment.
      */
@@ -23,8 +23,9 @@ export class AbstractType {
      * Label from rdfs:label.
      */
     label;
-    constructor({ comment, label, logger, reusables, }) {
+    constructor({ comment, configuration, label, logger, reusables, }) {
         this.comment = comment;
+        this.configuration = configuration;
         this.label = label;
         this.logger = logger;
         this.reusables = reusables;
@@ -43,6 +44,7 @@ export class AbstractType {
             kind: code `${literalOf(this.kind.substring(0, this.kind.length - "Type".length))} as const`,
         };
     }
+    rdfjsTermExpression;
 }
 (function (AbstractType) {
     class GraphqlType {

package/dist/generators/ts/AbstractUnionType.d.ts

@@ -17,7 +17,7 @@ export declare abstract class AbstractUnionType<MemberTypeT extends Type> extend
         })[];
         recursive: boolean;
     } & ConstructorParameters<typeof AbstractType>[0]);
-    get conversions(): readonly AbstractType.Conversion[];
+    get conversionFunction(): AbstractType.ConversionFunction;
     get discriminantProperty(): Maybe<AbstractType.DiscriminantProperty>;
     get members(): readonly AbstractUnionType.Member<MemberTypeT>[];
     get mutable(): boolean;
@@ -34,6 +34,7 @@ export declare abstract class AbstractUnionType<MemberTypeT extends Type> extend
     protected get inlineJsonType(): AbstractType.JsonType;
     protected get inlineName(): Code;
     protected get inlineToJsonFunction(): Code;
+    protected get inlineHashFunction(): Code;
     protected get inlineToRdfResourceValuesFunction(): Code;
     protected get inlineToStringFunction(): Code;
     protected get inlineValueSparqlConstructTriplesFunction(): Code;
@@ -43,7 +44,6 @@ export declare abstract class AbstractUnionType<MemberTypeT extends Type> extend
         members: Code;
     };
     jsonUiSchemaElement(): Maybe<Code>;
-    protected inlineHashStatements({ depth, variables, }: Parameters<AbstractType["hashStatements"]>[0]): readonly Code[];
     private readonly lazyMembers;
 }
 type Discriminant = ExtrinsicDiscriminant | HybridDiscriminant | IntrinsicDiscriminant | TypeofDiscriminant;

package/dist/generators/ts/AbstractUnionType.js

@@ -4,12 +4,11 @@ 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";
 import { removeUndefined } from "./removeUndefined.js";
-import { syntheticNamePrefix } from "./syntheticNamePrefix.js";
 import { code, joinCode, literalOf } from "./ts-poet-wrapper.js";
 export class AbstractUnionType extends AbstractType {
     discriminant;
@@ -130,29 +129,21 @@ export class AbstractUnionType extends AbstractType {
             };
         });
     }
-    get conversions() {
-        switch (this.discriminant.kind) {
-            case "extrinsic":
-            case "hybrid":
-            case "intrinsic":
-                return [
+    get conversionFunction() {
+        return {
+            code: code `${this.reusables.snippets.convertToUnion}`,
+            sourceTypes: this.discriminant.kind === "typeof"
+                ? this.members.map(({ primaryDiscriminantValue, type }) => ({
+                    name: type.name,
+                    typeof: primaryDiscriminantValue,
+                }))
+                : [
                     {
-                        conversionExpression: (value) => value,
-                        sourceTypeCheckExpression: (value) => code `typeof ${value} === "object"`,
-                        sourceTypeName: this.name,
-                        sourceTypeof: "object",
+                        name: this.name,
+                        typeof: "object",
                     },
-                ];
-            case "typeof":
-                return this.members.map(({ primaryDiscriminantValue, type, typeCheck }) => ({
-                    conversionExpression: (value) => value,
-                    sourceTypeCheckExpression: (value) => typeCheck(value),
-                    sourceTypeName: type.name,
-                    sourceTypeof: primaryDiscriminantValue,
-                }));
-            default:
-                throw this.discriminant;
-        }
+                ],
+        };
     }
     get discriminantProperty() {
         switch (this.discriminant.kind) {
@@ -215,7 +206,7 @@ export class AbstractUnionType extends AbstractType {
         return set;
     }
     get typeofs() {
-        return NonEmptyList.fromArray(this.members.flatMap((member) => member.type.typeofs)).unsafeCoerce();
+        return [...new Set(this.members.flatMap((member) => member.type.typeofs))];
     }
     get inlineEqualsFunction() {
         return code `\
@@ -228,6 +219,7 @@ ${joinCode(this.members.map(({ type, typeCheck, unwrap }) => code `if (${typeChe
 })`;
     }
     get inlineFilterFunction() {
+        const syntheticNamePrefix = this.configuration.syntheticNamePrefix;
         return code `\
 ((filter: ${this.filterType}, value: ${this.name}) => {
 ${joinCode([
@@ -249,6 +241,7 @@ if (filter.on?.[${literalOf(primaryDiscriminantValue)}] !== undefined && ${typeC
 })`;
     }
     get inlineFilterType() {
+        const syntheticNamePrefix = this.configuration.syntheticNamePrefix;
         return code `\
   {
    ${this.identifierType.map((identifierType) => code `readonly ${syntheticNamePrefix}identifier?: ${identifierType.filterType};`).orDefault(code ``)}
@@ -395,6 +388,13 @@ ${joinCode(this.members.map(({ jsonType, jsonTypeCheck, type, unwrap, wrap }) =>
 ${joinCode(this.members.map(({ typeCheck, typeToJsonExpression, unwrap, wrap }) => code `if (${typeCheck(code `value`)}) { return ${wrap(typeToJsonExpression(unwrap(code `value`)))}; }`))}
 
   throw new Error("unable to serialize to JSON");
+})`;
+    }
+    get inlineHashFunction() {
+        return code `\
+(<HasherT extends ${this.reusables.snippets.Hasher}>(hasher: HasherT, value: ${this.name}): HasherT => {
+${joinCode(this.members.map(({ type, typeCheck, unwrap }) => code `if (${typeCheck(code `value`)}) { return ${type.hashFunction}(hasher, ${unwrap(code `value`)}); }`))}
+  return hasher;
 })`;
     }
     get inlineToRdfResourceValuesFunction() {
@@ -469,22 +469,11 @@ unionPatterns.push({ patterns: ${type.valueSparqlWherePatternsFunction}({ ...oth
     jsonUiSchemaElement() {
         return Maybe.empty();
     }
-    inlineHashStatements({ depth, variables, }) {
-        return this.members.map(({ type, unwrap, typeCheck }) => code `if (${typeCheck(variables.value)}) { ${joinCode(type
-            .hashStatements({
-            depth: depth + 1,
-            variables: {
-                hasher: variables.hasher,
-                value: unwrap(variables.value),
-            },
-        })
-            .concat())} }`);
-    }
     lazyMembers;
 }
 __decorate([
     Memoize()
-], AbstractUnionType.prototype, "conversions", null);
+], AbstractUnionType.prototype, "conversionFunction", null);
 __decorate([
     Memoize()
 ], AbstractUnionType.prototype, "discriminantProperty", null);

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,19 +1,21 @@
+import type { Literal } from "@rdfjs/types";
 import { AbstractLiteralType } from "./AbstractLiteralType.js";
 import { type Code } from "./ts-poet-wrapper.js";
 export declare class BigDecimalType extends AbstractLiteralType {
+    readonly name: Code;
+    readonly conversionFunction: 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"]>;

package/dist/generators/ts/BigDecimalType.js

@@ -6,48 +6,24 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 };
 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 = {
+        code: code `${this.reusables.snippets.convertToBigDecimal}`,
+        sourceTypes: [
+            {
+                name: code `${this.reusables.imports.BigDecimal}`,
+                typeof: "object",
+            },
+        ],
+    };
     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);
     }
@@ -57,15 +33,15 @@ export class BigDecimalType extends AbstractLiteralType {
     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()`;
     }
@@ -79,9 +55,6 @@ export class BigDecimalType extends AbstractLiteralType {
         };
     }
 }
-__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