@shaclmate/compiler 4.0.93 → 4.0.95

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

@@ -1,30 +1,25 @@
 import type { BlankNode, NamedNode } from "@rdfjs/types";
-import type { Logger } from "@rdfx/logger";
 import { Maybe } from "purify-ts";
 import { AbstractType_ConversionFunction } from "./_AbstractType/AbstractType_ConversionFunction.js";
-import type { AbstractType_DiscriminantProperty } from "./_AbstractType/AbstractType_DiscriminantProperty.js";
+import type { AbstractType_DiscriminatedType } from "./_AbstractType/AbstractType_DiscriminatedType.js";
 import { AbstractType_GraphqlType } from "./_AbstractType/AbstractType_GraphqlType.js";
-import { AbstractType_JsonType } from "./_AbstractType/AbstractType_JsonType.js";
+import type { AbstractType_JsonType, AbstractType_JsonTypeFactory } from "./_AbstractType/AbstractType_JsonType.js";
 import { AbstractType_JsType } from "./_AbstractType/AbstractType_JsType.js";
-import type { Reusables } from "./Reusables.js";
-import { rdfjsTermExpression } from "./rdfjsTermExpression.js";
-import type { TsGenerator } from "./TsGenerator.js";
+import { AbstractConstruct } from "./AbstractConstruct.js";
+import type { Callable } from "./Callable.js";
 import { type Code } from "./ts-poet-wrapper.js";
 /**
  * Abstract base class all types.
  */
-export declare abstract class AbstractType {
-    protected readonly configuration: TsGenerator.Configuration;
+export declare abstract class AbstractType extends AbstractConstruct {
     /**
      * Inline TypeScript type expression.
      */
     protected abstract readonly inlineExpression: Code;
-    protected readonly logger: Logger;
-    protected readonly reusables: Reusables;
     /**
-     * Comment from rdfs:comment.
+     * Factory for AbstractType.JsonType.
      */
-    readonly comment: Maybe<string>;
+    protected readonly jsonTypeFactory: AbstractType.JsonTypeFactory;
     /**
      * Function that takes a value of one or more source types to this type and returns Either<Error, ThisType>.
      *
@@ -36,23 +31,31 @@ export declare abstract class AbstractType {
      */
     abstract readonly conversionFunction: Maybe<AbstractType.ConversionFunction>;
     /**
-     * A property that discriminates sub-types of this type e.g., termType on RDF/JS terms.
+     * A version of this type with an intrinsic discriminant property.
      */
-    abstract readonly discriminantProperty: Maybe<AbstractType.DiscriminantProperty>;
+    abstract readonly discriminatedType: Maybe<AbstractType.DiscriminatedType>;
     /**
      * A function (reference or literal) that compares two property values of this type, returning a
      * $EqualsResult.
      */
-    abstract readonly equalsFunction: Code;
+    abstract readonly equalsFunction: Callable;
     /**
      * A function (reference or literal) that takes a filter of filterType (below) and a value of this type
      * and returns true if the value passes the filter.
      */
-    abstract readonly filterFunction: Code;
+    abstract readonly filterFunction: Callable;
     /**
      * Composite type for filtering instances of this type e.g., SomeObject.Filter with filters for each property.
      */
     abstract readonly filterType: Code;
+    /**
+     * A function (reference or literal) that converts an instance of jsonObjectType to an Either<Error, ThisType>.
+     */
+    abstract readonly fromJsonObjectFunction: Callable;
+    /**
+     * A function (reference or literal) that converts an instance of jsonValueType to an Either<Error, ThisType>.
+     */
+    abstract readonly fromJsonValueFunction: Callable;
     /**
      * A FromRdfResourceValuesFunction (reference or literal) that converts a Either<Error, rdfjsResource.Resource.Values> to a
      * Either<Error, rdfjsResource.Resource.Values<this type>>.
@@ -73,7 +76,7 @@ export declare abstract class AbstractType {
      *   preferredLanguages: the preferred languages array (e.g., ["en"]) passed to Object.fromRdf
      *   propertyPath: the PropertyPath of the object's property
      */
-    abstract readonly fromRdfResourceValuesFunction: Code;
+    abstract readonly fromRdfResourceValuesFunction: Callable;
     /**
      * Declarations for GraphQL arguments to pass to this the graphqlResolveExpression.
      */
@@ -87,19 +90,25 @@ export declare abstract class AbstractType {
     /**
      * A function (reference or literal) that takes a  Hasher and a value of this type, calls hasher.update on the value, and returns the Hasher.
      */
-    abstract readonly hashFunction: Code;
+    abstract readonly hashFunction: Callable;
     /**
      * JavaScript type(s) the type.
      */
     abstract readonly jsTypes: readonly AbstractType.JsType[];
     /**
-     * Type discriminant.
+     * JSON object form of this type.
      */
-    abstract readonly kind: string;
+    abstract readonly jsonObjectType: AbstractType.JsonType & {
+        readonly kind: "JsonDiscriminatedUnion" | "JsonIntersection" | "JsonObject";
+    };
     /**
-     * Label from rdfs:label.
+     * JSON value form of this type. May be the same as the JSON object form.
      */
-    readonly label: Maybe<string>;
+    abstract readonly jsonValueType: AbstractType.JsonType;
+    /**
+     * Type discriminant.
+     */
+    abstract readonly kind: string;
     /**
      * Is a value of this type mutable?
      */
@@ -124,6 +133,14 @@ export declare abstract class AbstractType {
      * Identifier of the shape this type was derived from.
      */
     readonly shapeIdentifier: BlankNode | NamedNode;
+    /**
+     * A function (reference or literal) that converts an instance of this type to the jsonObjectType.
+     */
+    abstract readonly toJsonObjectFunction: Callable;
+    /**
+     * A function (reference or literal) that converts an instance of this type to the jsonValueType.
+     */
+    abstract readonly toJsonValueFunction: Callable;
     /**
      * The type(s) of the array elements produced by the toRdfResourceValuesExpression.
      */
@@ -139,7 +156,7 @@ export declare abstract class AbstractType {
      *
      * If unspecified, uses an identity function (i.e., function identity(schema: unknown, value: ThisType): Either<Error, ThisType>).
      */
-    abstract readonly validationFunction: Maybe<Code>;
+    abstract readonly validationFunction: Maybe<Callable>;
     /**
      * A ValueSparqlConstructTriplesFunction (reference or literal) that returns an array of sparqljs.Triple's for a property value of this type.
      *
@@ -150,7 +167,7 @@ export declare abstract class AbstractType {
      * - valueVariable: rdfjs.Variable of the value of this type
      * - variablePrefix: string prefix to use for new variables
      */
-    abstract readonly valueSparqlConstructTriplesFunction: Code;
+    abstract readonly valueSparqlConstructTriplesFunction: Callable;
     /**
      * A ValueSparqlWherePatternsFunction (reference or literal) that returns an array of SparqlPattern's for a property value of this type.
      *
@@ -162,38 +179,29 @@ export declare abstract class AbstractType {
      * - valueVariable: rdfjs.Variable of the value of this type
      * - variablePrefix: string prefix to use for new variables
      */
-    abstract readonly valueSparqlWherePatternsFunction: Code;
-    constructor({ comment, configuration, label, logger, name, reusables, shapeIdentifier, }: {
+    abstract readonly valueSparqlWherePatternsFunction: Callable;
+    constructor({ jsonTypeFactory, name, shapeIdentifier, ...superParameters }: {
+        jsonTypeFactory: AbstractType.JsonTypeFactory;
         name: Maybe<string>;
-        comment: Maybe<string>;
-        configuration: TsGenerator.Configuration;
-        label: Maybe<string>;
-        logger: Logger;
-        reusables: Reusables;
         shapeIdentifier: BlankNode | NamedNode;
-    });
+    } & ConstructorParameters<typeof AbstractConstruct>[0]);
     /**
      * The declaration of named types.
      */
     get declaration(): Maybe<Code>;
+    /**
+     * Expression of this type. If the type has a name it will be that name (a reference). Otherwise it will be the .inlineExpression.
+     */
     get expression(): Code;
     /**
      * TypeScript object describing this type, for runtime use.
      */
     get schema(): Code;
-    protected get schemaExpression(): Code;
+    get schemaVariable(): Maybe<Code>;
     /**
      * Helper to compose the result of schema along the type hierarchy.
      */
     protected get schemaInitializers(): readonly Code[];
-    /**
-     * An expression that converts this type's JSON type to an Either<Error, ThisType>.
-     */
-    abstract fromJsonExpression(parameters: {
-        variables: {
-            value: Code;
-        };
-    }): Code;
     /**
      * An expression that resolves a value of this type in the GraphQL server.
      */
@@ -204,38 +212,9 @@ export declare abstract class AbstractType {
         };
     }): Code;
     /**
-     * Zod schema for the JSON type of this type.
-     *
-     * This method is called in two contexts:
-     * "property": from a ShaclProperty, while generating the z.object properties of an ObjectType
-     * "type": from another Type e.g., an OptionType or DiscriminatedUnionType
-     *
-     * z.lazy() should only be returned for "property".
+     * An expression that converts a value of this type to a value that can be logged.
      */
-    abstract jsonSchema(parameters: {
-        includeDiscriminantProperty?: boolean;
-        context: "property" | "type";
-    }): Code;
-    /**
-     * JSON-compatible version of the type.
-     */
-    abstract jsonType(parameters?: {
-        includeDiscriminantProperty?: boolean;
-    }): AbstractType.JsonType;
-    /**
-     * Element object for a JSON Forms UI schema.
-     */
-    abstract jsonUiSchemaElement(parameters: {
-        variables: {
-            scopePrefix: Code;
-        };
-    }): Maybe<Code>;
-    /**
-     * An expression that converts a value of this type to a JSON-LD compatible value. It can assume the presence
-     * of the correct JSON-LD context.
-     */
-    abstract toJsonExpression(parameters: {
-        includeDiscriminantProperty?: boolean;
+    abstract toLoggableExpression(parameters: {
         variables: {
             value: Code;
         };
@@ -268,7 +247,7 @@ export declare abstract class AbstractType {
             value: Code;
         };
     }): Code;
-    protected readonly rdfjsTermExpression: (parameters: Parameters<typeof rdfjsTermExpression>[0]) => Code;
+    protected schemaExpression(): Code;
     protected staticModuleDeclarations(_name: string): Record<string, Code>;
 }
 export declare namespace AbstractType {
@@ -277,15 +256,12 @@ export declare namespace AbstractType {
         const SourceType: typeof AbstractType_ConversionFunction.SourceType;
         type SourceType = AbstractType_ConversionFunction.SourceType;
     }
-    type DiscriminantProperty = AbstractType_DiscriminantProperty;
-    namespace DiscriminantProperty {
-        type Value = AbstractType_DiscriminantProperty.Value;
-    }
+    type DiscriminatedType = AbstractType_DiscriminatedType;
     const GraphqlType: typeof AbstractType_GraphqlType;
     type GraphqlType = AbstractType_GraphqlType;
     type JsType = AbstractType_JsType;
     const JsType: typeof AbstractType_JsType;
-    const JsonType: typeof AbstractType_JsonType;
     type JsonType = AbstractType_JsonType;
+    type JsonTypeFactory = AbstractType_JsonTypeFactory;
 }
 //# sourceMappingURL=AbstractType.d.ts.map

package/dist/generators/ts/AbstractType.js

@@ -8,26 +8,18 @@ import { Maybe } from "purify-ts";
 import { Memoize } from "typescript-memoize";
 import { AbstractType_ConversionFunction } from "./_AbstractType/AbstractType_ConversionFunction.js";
 import { AbstractType_GraphqlType } from "./_AbstractType/AbstractType_GraphqlType.js";
-import { AbstractType_JsonType } from "./_AbstractType/AbstractType_JsonType.js";
 import { AbstractType_JsType } from "./_AbstractType/AbstractType_JsType.js";
-import { rdfjsTermExpression } from "./rdfjsTermExpression.js";
+import { AbstractConstruct } from "./AbstractConstruct.js";
 import { code, def, joinCode, literalOf, } from "./ts-poet-wrapper.js";
 import { tsComment } from "./tsComment.js";
 /**
  * Abstract base class all types.
  */
-export class AbstractType {
-    configuration;
-    logger;
-    reusables;
+export class AbstractType extends AbstractConstruct {
     /**
-     * Comment from rdfs:comment.
+     * Factory for AbstractType.JsonType.
      */
-    comment;
-    /**
-     * Label from rdfs:label.
-     */
-    label;
+    jsonTypeFactory;
     /**
      * Name for this type.
      */
@@ -36,18 +28,10 @@ export class AbstractType {
      * Identifier of the shape this type was derived from.
      */
     shapeIdentifier;
-    constructor({ comment, configuration, label, logger, name, reusables, shapeIdentifier, }) {
-        this.comment = comment;
-        this.configuration = configuration;
-        this.label = label;
-        this.logger = logger;
+    constructor({ jsonTypeFactory, name, shapeIdentifier, ...superParameters }) {
+        super(superParameters);
+        this.jsonTypeFactory = jsonTypeFactory;
         this.name = name;
-        this.reusables = reusables;
-        this.rdfjsTermExpression = rdfjsTermExpression.bind({
-            imports: this.reusables.imports,
-            logger: this.logger,
-            snippets: this.reusables.snippets,
-        });
         this.shapeIdentifier = shapeIdentifier;
     }
     /**
@@ -76,6 +60,9 @@ ${joinCode(staticModuleDeclarations
         }
         return Maybe.of(joinCode(declarations, { on: "\n\n" }));
     }
+    /**
+     * Expression of this type. If the type has a name it will be that name (a reference). Otherwise it will be the .inlineExpression.
+     */
     get expression() {
         return this.name
             .map((name) => code `${name}`)
@@ -87,10 +74,13 @@ ${joinCode(staticModuleDeclarations
     get schema() {
         return this.name
             .map((name) => code `${name}.schema`)
-            .orDefaultLazy(() => this.schemaExpression);
+            .orDefaultLazy(() => this.schemaExpression());
     }
-    get schemaExpression() {
-        return code `{ ${joinCode(this.schemaInitializers.concat(), { on: ", " })} }`;
+    get schemaVariable() {
+        if (!this.configuration.features.has("Object.schema")) {
+            return Maybe.empty();
+        }
+        return this.name.map((name) => code `${name}.schema`);
     }
     /**
      * Helper to compose the result of schema along the type hierarchy.
@@ -98,12 +88,16 @@ ${joinCode(staticModuleDeclarations
     get schemaInitializers() {
         return [code `kind: ${literalOf(this.kind)} as const`];
     }
-    rdfjsTermExpression;
+    schemaExpression() {
+        return code `{ ${joinCode(this.schemaInitializers.concat(), { on: ", " })} }`;
+    }
     staticModuleDeclarations(_name) {
         const staticModuleDeclarations = {};
         if (this.configuration.features.has("Object.schema")) {
             staticModuleDeclarations["schema"] =
-                code `export const schema = ${this.schemaExpression}`;
+                code `export const schema = ${this.schemaExpression()}`;
+            staticModuleDeclarations["Schema"] =
+                code `export type Schema = typeof schema;`;
         }
         return staticModuleDeclarations;
     }
@@ -117,6 +111,9 @@ __decorate([
 __decorate([
     Memoize()
 ], AbstractType.prototype, "schema", null);
+__decorate([
+    Memoize()
+], AbstractType.prototype, "schemaVariable", null);
 __decorate([
     Memoize()
 ], AbstractType.prototype, "schemaExpression", null);
@@ -127,6 +124,5 @@ __decorate([
     })(ConversionFunction = AbstractType.ConversionFunction || (AbstractType.ConversionFunction = {}));
     AbstractType.GraphqlType = AbstractType_GraphqlType;
     AbstractType.JsType = AbstractType_JsType;
-    AbstractType.JsonType = AbstractType_JsonType;
 })(AbstractType || (AbstractType = {}));
 //# sourceMappingURL=AbstractType.js.map

package/dist/generators/ts/AbstractTypedLiteralType.d.ts

@@ -2,7 +2,7 @@ import type { Literal, NamedNode } from "@rdfjs/types";
 import { Maybe } from "purify-ts";
 import { AbstractLiteralType } from "./AbstractLiteralType.js";
 import { AbstractTermType } from "./AbstractTermType.js";
-import type { Code } from "./ts-poet-wrapper.js";
+import { type Code } from "./ts-poet-wrapper.js";
 /**
  * Abstract base class of all types that are typed literals in RDF. In RDF every literal is either
  *  - a language-tagged string literal (datatype = rdf:langString, language = not empty)
@@ -10,20 +10,21 @@ import type { Code } from "./ts-poet-wrapper.js";
  */
 export declare abstract class AbstractTypedLiteralType<ValueT> extends AbstractLiteralType {
     readonly datatype: NamedNode;
+    readonly discriminatedType: Maybe<AbstractTypedLiteralType.DiscriminatedType>;
+    readonly jsonObjectType: AbstractTermType<Literal, Literal>["jsonObjectType"];
     constructor({ datatype, ...superParameters }: {
         datatype: NamedNode;
     } & ConstructorParameters<typeof AbstractLiteralType>[0]);
-    get discriminantProperty(): Maybe<AbstractLiteralType.DiscriminantProperty>;
+    protected get schemaInitializers(): readonly Code[];
     graphqlResolveExpression({ variables, }: Parameters<AbstractLiteralType["graphqlResolveExpression"]>[0]): Code;
     abstract valueExpression(literal: Literal | ValueT): Code;
 }
 export declare namespace AbstractTypedLiteralType {
     type ConversionFunction = AbstractTermType.ConversionFunction;
-    type DiscriminantProperty = AbstractTermType.DiscriminantProperty;
+    type DiscriminatedType = AbstractTermType.DiscriminatedType;
     const GraphqlType: typeof import("./_AbstractType/AbstractType_GraphqlType.js").AbstractType_GraphqlType;
     type GraphqlType = AbstractTermType.GraphqlType;
     type JsType = AbstractTermType.JsType;
-    const JsonType: typeof import("./_AbstractType/AbstractType_JsonType.js").AbstractType_JsonType;
     type JsonType = AbstractTermType.JsonType;
 }
 //# sourceMappingURL=AbstractTypedLiteralType.d.ts.map

package/dist/generators/ts/AbstractTypedLiteralType.js

@@ -1,6 +1,7 @@
 import { Maybe } from "purify-ts";
 import { AbstractLiteralType } from "./AbstractLiteralType.js";
 import { AbstractTermType } from "./AbstractTermType.js";
+import { code } from "./ts-poet-wrapper.js";
 /**
  * Abstract base class of all types that are typed literals in RDF. In RDF every literal is either
  *  - a language-tagged string literal (datatype = rdf:langString, language = not empty)
@@ -8,12 +9,23 @@ import { AbstractTermType } from "./AbstractTermType.js";
  */
 export class AbstractTypedLiteralType extends AbstractLiteralType {
     datatype;
+    discriminatedType = Maybe.empty();
+    jsonObjectType = this.jsonTypeFactory.createJsonObjectType({
+        "@type": {
+            type: this.jsonTypeFactory.createJsonStringType(),
+        },
+        "@value": {
+            type: this.jsonTypeFactory.createJsonStringType(),
+        },
+    }, {
+        snippet: this.reusables.snippets.TypedLiteralJsonObject,
+    });
     constructor({ datatype, ...superParameters }) {
         super(superParameters);
         this.datatype = datatype;
     }
-    get discriminantProperty() {
-        return Maybe.empty();
+    get schemaInitializers() {
+        return super.schemaInitializers.concat(code `datatype: ${this.rdfjsTermExpression(this.datatype)}`);
     }
     graphqlResolveExpression({ variables, }) {
         return variables.value;
@@ -21,6 +33,5 @@ export class AbstractTypedLiteralType extends AbstractLiteralType {
 }
 (function (AbstractTypedLiteralType) {
     AbstractTypedLiteralType.GraphqlType = AbstractTermType.GraphqlType;
-    AbstractTypedLiteralType.JsonType = AbstractTermType.JsonType;
 })(AbstractTypedLiteralType || (AbstractTypedLiteralType = {}));
 //# sourceMappingURL=AbstractTypedLiteralType.js.map

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

@@ -1,31 +1,33 @@
 import type { Literal } from "@rdfjs/types";
 import type { Decimal } from "decimal.js";
 import { Maybe } from "purify-ts";
-import { AbstractLiteralType } from "./AbstractLiteralType.js";
 import { AbstractTypedLiteralType } from "./AbstractTypedLiteralType.js";
+import { ReferenceCallable } from "./ReferenceCallable.js";
 import { type Code } from "./ts-poet-wrapper.js";
 export declare class BigDecimalType extends AbstractTypedLiteralType<Decimal> {
     protected readonly inlineExpression: Code;
+    readonly jsonValueType: AbstractTypedLiteralType.JsonType;
     readonly jsTypes: readonly [{
         readonly className: Code;
         readonly instanceof: "class";
         readonly typeof: "object";
     }];
-    readonly conversionFunction: Maybe<AbstractLiteralType.ConversionFunction>;
-    readonly filterFunction: Code;
+    readonly conversionFunction: Maybe<AbstractTypedLiteralType.ConversionFunction>;
+    readonly filterFunction: ReferenceCallable;
     readonly filterType: Code;
-    readonly fromRdfResourceValuesFunction: Code;
-    readonly hashFunction: Code;
+    readonly fromJsonValueFunction: ReferenceCallable;
+    readonly fromJsonObjectFunction: ReferenceCallable;
+    readonly fromRdfResourceValuesFunction: ReferenceCallable;
+    readonly graphqlType: import("./_AbstractType/AbstractType_GraphqlType.js").AbstractType_GraphqlType;
+    readonly hashFunction: ReferenceCallable;
     readonly kind = "BigDecimal";
     readonly schemaType: Code;
-    readonly valueSparqlWherePatternsFunction: Code;
-    get graphqlType(): import("./_AbstractType/AbstractType_GraphqlType.js").AbstractType_GraphqlType;
-    fromJsonExpression({ variables, }: Parameters<AbstractLiteralType["fromJsonExpression"]>[0]): Code;
-    graphqlResolveExpression({ variables, }: Parameters<AbstractLiteralType["graphqlResolveExpression"]>[0]): Code;
-    jsonSchema(): Code;
-    jsonType(): AbstractLiteralType.JsonType;
-    toJsonExpression({ variables, }: Parameters<AbstractTypedLiteralType<Decimal>["toJsonExpression"]>[0]): Code;
-    toRdfResourceValuesExpression({ variables, }: Parameters<AbstractLiteralType["toRdfResourceValuesExpression"]>[0]): Code;
+    readonly toJsonValueFunction: ReferenceCallable;
+    readonly toJsonObjectFunction: ReferenceCallable;
+    readonly valueSparqlWherePatternsFunction: ReferenceCallable;
+    graphqlResolveExpression({ variables, }: Parameters<AbstractTypedLiteralType<Decimal>["graphqlResolveExpression"]>[0]): Code;
+    toLoggableExpression({ variables, }: Parameters<AbstractTypedLiteralType<Decimal>["toLoggableExpression"]>[0]): Code;
+    toRdfResourceValuesExpression({ variables, }: Parameters<AbstractTypedLiteralType<Decimal>["toRdfResourceValuesExpression"]>[0]): Code;
     valueExpression(literal: Literal): Code;
 }
 //# sourceMappingURL=BigDecimalType.d.ts.map

package/dist/generators/ts/BigDecimalType.js

@@ -1,16 +1,10 @@
-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 { Maybe } from "purify-ts";
-import { Memoize } from "typescript-memoize";
-import { AbstractLiteralType } from "./AbstractLiteralType.js";
 import { AbstractTypedLiteralType } from "./AbstractTypedLiteralType.js";
+import { ReferenceCallable } from "./ReferenceCallable.js";
 import { code, literalOf } from "./ts-poet-wrapper.js";
 export class BigDecimalType extends AbstractTypedLiteralType {
     inlineExpression = code `${this.reusables.imports.BigDecimal}`;
+    jsonValueType = this.jsonTypeFactory.createJsonStringType();
     jsTypes = [
         {
             className: code `${this.reusables.imports.BigDecimal}`,
@@ -35,30 +29,23 @@ export class BigDecimalType extends AbstractTypedLiteralType {
             },
         ],
     });
-    filterFunction = code `${this.reusables.snippets.filterBigDecimal}`;
+    filterFunction = new ReferenceCallable(this.reusables.snippets.filterBigDecimal);
     filterType = code `${this.reusables.snippets.NumericFilter}<${this.reusables.imports.BigDecimal}>`;
-    fromRdfResourceValuesFunction = code `${this.reusables.snippets.bigDecimalFromRdfResourceValues}`;
-    hashFunction = code `${this.reusables.snippets.hashBigDecimal}`;
+    fromJsonValueFunction = new ReferenceCallable(this.reusables.snippets.bigDecimalFromJsonString);
+    fromJsonObjectFunction = new ReferenceCallable(this.reusables.snippets.bigDecimalFromJsonObject);
+    fromRdfResourceValuesFunction = new ReferenceCallable(this.reusables.snippets.bigDecimalFromRdfResourceValues);
+    graphqlType = new AbstractTypedLiteralType.GraphqlType(code `${this.reusables.imports.GraphQLString}`, this.reusables);
+    hashFunction = new ReferenceCallable(this.reusables.snippets.hashBigDecimal);
     kind = "BigDecimal";
     schemaType = code `${this.reusables.snippets.NumericSchema}<${this.reusables.imports.BigDecimal}>`;
-    valueSparqlWherePatternsFunction = code `${this.reusables.snippets.bigDecimalSparqlWherePatterns}`;
-    get graphqlType() {
-        return new AbstractLiteralType.GraphqlType(code `${this.reusables.imports.GraphQLString}`, this.reusables);
-    }
-    fromJsonExpression({ variables, }) {
-        return code `${this.reusables.imports.Either}.encase<Error, ${this.expression}>(() => new ${this.expression}(${variables.value}["@value"]))`;
-    }
+    toJsonValueFunction = new ReferenceCallable(this.reusables.snippets.bigDecimalToJsonString);
+    toJsonObjectFunction = new ReferenceCallable(code `${this.reusables.snippets.bigDecimalToJsonObject}(${this.rdfjsTermExpression(this.datatype)})`);
+    valueSparqlWherePatternsFunction = new ReferenceCallable(this.reusables.snippets.bigDecimalSparqlWherePatterns);
     graphqlResolveExpression({ variables, }) {
         return code `${variables.value}.toFixed()`;
     }
-    jsonSchema() {
-        return code `${this.reusables.imports.z}.object({ "@type": ${this.reusables.imports.z}.literal(${literalOf(this.datatype.value)}), "@value": ${this.reusables.imports.z}.string() })`;
-    }
-    jsonType() {
-        return new AbstractLiteralType.JsonType(code `{ readonly "@type": ${literalOf(this.datatype.value)}, readonly "@value": string }`);
-    }
-    toJsonExpression({ variables, }) {
-        return code `{ "@type": ${literalOf(this.datatype.value)} as const, "@value": ${variables.value}.toFixed() }`;
+    toLoggableExpression({ variables, }) {
+        return code `${variables.value}.toFixed()`;
     }
     toRdfResourceValuesExpression({ variables, }) {
         return code `[${this.reusables.snippets.bigDecimalLiteral}(${variables.value})]`;
@@ -67,7 +54,4 @@ export class BigDecimalType extends AbstractTypedLiteralType {
         return code `new ${this.reusables.imports.BigDecimal}(${literalOf(literal.value)})`;
     }
 }
-__decorate([
-    Memoize()
-], BigDecimalType.prototype, "graphqlType", null);
 //# sourceMappingURL=BigDecimalType.js.map

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

@@ -1,20 +1,22 @@
 import type { Literal } from "@rdfjs/types";
 import { Maybe } from "purify-ts";
 import { AbstractNumericType } from "./AbstractNumericType.js";
+import type { Callable } from "./Callable.js";
 import { type Code } from "./ts-poet-wrapper.js";
 export declare class BigIntType extends AbstractNumericType<bigint> {
+    protected readonly decodedIn: bigint[];
     readonly jsTypes: {
         readonly typeof: "bigint";
     }[];
+    readonly conversionFunction: Maybe<AbstractNumericType.ConversionFunction>;
+    readonly graphqlType: import("./_AbstractType/AbstractType_GraphqlType.js").AbstractType_GraphqlType;
+    readonly jsonValueType: AbstractNumericType.JsonType;
     readonly kind = "BigInt";
-    get conversionFunction(): Maybe<AbstractNumericType.ConversionFunction>;
-    get fromRdfResourceValuesFunction(): Code;
-    get graphqlType(): import("./_AbstractType/AbstractType_GraphqlType.js").AbstractType_GraphqlType;
-    private get decodedIn();
-    fromJsonExpression({ variables, }: Parameters<AbstractNumericType<bigint>["fromJsonExpression"]>[0]): Code;
-    jsonSchema(_parameters: Parameters<AbstractNumericType<bigint>["jsonSchema"]>[0]): Code;
-    jsonType(): AbstractNumericType.JsonType;
-    toJsonExpression({ variables, }: Parameters<AbstractNumericType<bigint>["toJsonExpression"]>[0]): Code;
+    get fromJsonObjectFunction(): Callable;
+    get fromJsonValueFunction(): Callable;
+    get fromRdfResourceValuesFunction(): Callable;
+    get toJsonObjectFunction(): Callable;
+    get toJsonValueFunction(): Callable;
     valueExpression(literal: bigint | Literal): Code;
 }
 //# sourceMappingURL=BigIntType.d.ts.map