@shaclmate/compiler 4.0.94 → 4.0.95

package/dist/generators/ts/BigIntType.js

@@ -8,15 +8,14 @@ import { LiteralDecoder } from "@rdfx/literal";
 import { Maybe } from "purify-ts";
 import { Memoize } from "typescript-memoize";
 import { AbstractNumericType } from "./AbstractNumericType.js";
-import { arrayOf, code, joinCode, literalOf, } from "./ts-poet-wrapper.js";
+import { ReferenceCallable } from "./ReferenceCallable.js";
+import { code } from "./ts-poet-wrapper.js";
 export class BigIntType extends AbstractNumericType {
+    decodedIn = this.in_.map((in_) => LiteralDecoder.decodeBigIntLiteral(in_).unsafeCoerce());
     jsTypes = [{ typeof: "bigint" }];
-    kind = "BigInt";
-    get conversionFunction() {
-        if (this.in_.length > 0) {
-            return Maybe.empty();
-        }
-        return Maybe.of({
+    conversionFunction = this.in_.length > 0
+        ? Maybe.empty()
+        : Maybe.of({
             code: code `${this.reusables.snippets.convertToBigInt}`,
             sourceTypes: [
                 {
@@ -33,49 +32,25 @@ export class BigIntType extends AbstractNumericType {
                 },
             ],
         });
+    graphqlType = new AbstractNumericType.GraphqlType(code `${this.reusables.imports.GraphQLBigInt}`, this.reusables);
+    jsonValueType = this.jsonTypeFactory.createJsonStringType({
+        in_: this.decodedIn.map((in_) => in_.toString()),
+    });
+    kind = "BigInt";
+    get fromJsonObjectFunction() {
+        return new ReferenceCallable(code `${this.reusables.snippets.bigIntFromJsonObject}<${this.expression}>`);
     }
-    get fromRdfResourceValuesFunction() {
-        return code `${this.reusables.snippets.bigIntFromRdfResourceValues}<${this.expression}>`;
-    }
-    get graphqlType() {
-        return new AbstractNumericType.GraphqlType(code `${this.reusables.imports.GraphQLBigInt}`, this.reusables);
-    }
-    get decodedIn() {
-        return this.in_.map((in_) => LiteralDecoder.decodeBigIntLiteral(in_).unsafeCoerce());
-    }
-    fromJsonExpression({ variables, }) {
-        let expression = code `BigInt(${variables.value}["@value"])`;
-        if (this.in_.length > 0) {
-            expression = code `${expression} as ${this.expression}`;
-        }
-        return code `${this.reusables.imports.Either}.encase<Error, ${this.expression}>(() => ${expression})`;
+    get fromJsonValueFunction() {
+        return new ReferenceCallable(code `${this.reusables.snippets.bigIntFromJsonString}<${this.jsonValueType.expression}, ${this.expression}>`);
     }
-    jsonSchema(_parameters) {
-        let valueJsonSchema;
-        switch (this.decodedIn.length) {
-            case 0:
-                valueJsonSchema = code `${this.reusables.imports.z}.string()`;
-                break;
-            case 1:
-                valueJsonSchema = code `${this.reusables.imports.z}.literal(${literalOf(this.decodedIn[0].toString())})`;
-                break;
-            default:
-                valueJsonSchema = code `${this.reusables.imports.z}.enum(${arrayOf(...this.decodedIn.map((value) => code `${literalOf(value.toString())}`))})`;
-                break;
-        }
-        return code `${this.reusables.imports.z}.object({ "@type": ${this.reusables.imports.z}.literal(${literalOf(this.datatype.value)}), "@value": ${valueJsonSchema} })`;
+    get fromRdfResourceValuesFunction() {
+        return new ReferenceCallable(code `${this.reusables.snippets.bigIntFromRdfResourceValues}<${this.expression}>`);
     }
-    jsonType() {
-        return new AbstractNumericType.JsonType(code `{ readonly "@type": ${literalOf(this.datatype.value)}, readonly "@value": ${this.decodedIn.length === 0
-            ? "string"
-            : joinCode(this.decodedIn.map((in_) => code `${literalOf(in_.toString())}`), { on: " | " })} }`);
+    get toJsonObjectFunction() {
+        return new ReferenceCallable(code `${this.reusables.snippets.bigIntToJsonObject}(${this.rdfjsTermExpression(this.datatype)})`);
     }
-    toJsonExpression({ variables, }) {
-        let valueExpression = code `${variables.value}.toString()`;
-        if (this.in_.length > 0) {
-            valueExpression = code `${valueExpression} as ${joinCode(this.decodedIn.map((in_) => code `${literalOf(in_.toString())}`), { on: " | " })}`;
-        }
-        return code `{ "@type": ${literalOf(this.datatype.value)} as const, "@value": ${valueExpression} }`;
+    get toJsonValueFunction() {
+        return new ReferenceCallable(code `${this.reusables.snippets.bigIntToJsonString}`);
     }
     valueExpression(literal) {
         return code `${typeof literal === "bigint" ? literal : LiteralDecoder.decodeBigIntLiteral(literal).unsafeCoerce()}n`;
@@ -83,17 +58,17 @@ export class BigIntType extends AbstractNumericType {
 }
 __decorate([
     Memoize()
-], BigIntType.prototype, "conversionFunction", null);
+], BigIntType.prototype, "fromJsonObjectFunction", null);
 __decorate([
     Memoize()
-], BigIntType.prototype, "fromRdfResourceValuesFunction", null);
+], BigIntType.prototype, "fromJsonValueFunction", null);
 __decorate([
     Memoize()
-], BigIntType.prototype, "graphqlType", null);
+], BigIntType.prototype, "fromRdfResourceValuesFunction", null);
 __decorate([
     Memoize()
-], BigIntType.prototype, "decodedIn", null);
+], BigIntType.prototype, "toJsonObjectFunction", null);
 __decorate([
     Memoize()
-], BigIntType.prototype, "jsonType", null);
+], BigIntType.prototype, "toJsonValueFunction", null);
 //# sourceMappingURL=BigIntType.js.map

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

@@ -1,22 +1,22 @@
 import type { BlankNode } from "@rdfjs/types";
 import { Maybe } from "purify-ts";
 import { AbstractIdentifierType } from "./AbstractIdentifierType.js";
-import { type Code } from "./ts-poet-wrapper.js";
+import { ReferenceCallable } from "./ReferenceCallable.js";
 export declare class BlankNodeType extends AbstractIdentifierType<BlankNode> {
-    protected readonly inlineExpression: Code;
+    protected readonly inlineExpression: import("ts-poet/build/Code.js").Code;
     readonly conversionFunction: Maybe<AbstractIdentifierType.ConversionFunction>;
-    readonly filterFunction: Code;
-    readonly filterType: Code;
-    readonly fromRdfResourceValuesFunction: Code;
+    readonly filterFunction: ReferenceCallable;
+    readonly filterType: import("ts-poet/build/Code.js").Code;
+    readonly fromJsonValueFunction: ReferenceCallable;
+    readonly fromJsonObjectFunction: ReferenceCallable;
+    readonly fromRdfResourceValuesFunction: ReferenceCallable;
     readonly kind = "BlankNode";
     readonly nodeKinds: ReadonlySet<"BlankNode">;
-    readonly parseFunction: Code;
-    readonly schemaType: Code;
-    readonly valueSparqlWherePatternsFunction: Code;
+    readonly parseFunction: ReferenceCallable;
+    readonly schemaType: import("ts-poet/build/Code.js").Code;
+    readonly toJsonValueFunction: ReferenceCallable;
+    readonly toJsonObjectFunction: ReferenceCallable;
+    readonly valueSparqlWherePatternsFunction: ReferenceCallable;
     constructor(superParameters: Omit<ConstructorParameters<typeof AbstractIdentifierType<BlankNode>>[0], "hasValues" | "in_">);
-    fromJsonExpression({ variables, }: Parameters<AbstractIdentifierType<BlankNode>["fromJsonExpression"]>[0]): Code;
-    jsonSchema({ includeDiscriminantProperty, }: Parameters<AbstractIdentifierType<BlankNode>["jsonSchema"]>[0]): Code;
-    jsonType(parameters?: Parameters<AbstractIdentifierType<BlankNode>["jsonType"]>[0]): AbstractIdentifierType.JsonType;
-    toJsonExpression({ includeDiscriminantProperty, variables, }: Parameters<AbstractIdentifierType<BlankNode>["toJsonExpression"]>[0]): Code;
 }
 //# sourceMappingURL=BlankNodeType.d.ts.map

package/dist/generators/ts/BlankNodeType.js

@@ -1,12 +1,6 @@
-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 { AbstractIdentifierType } from "./AbstractIdentifierType.js";
+import { ReferenceCallable } from "./ReferenceCallable.js";
 import { code } from "./ts-poet-wrapper.js";
 export class BlankNodeType extends AbstractIdentifierType {
     inlineExpression = code `${this.reusables.imports.BlankNode}`;
@@ -23,14 +17,18 @@ export class BlankNodeType extends AbstractIdentifierType {
             },
         ],
     });
-    filterFunction = code `${this.reusables.snippets.filterBlankNode}`;
+    filterFunction = new ReferenceCallable(this.reusables.snippets.filterBlankNode);
     filterType = code `${this.reusables.snippets.BlankNodeFilter}`;
-    fromRdfResourceValuesFunction = code `${this.reusables.snippets.blankNodeFromRdfResourceValues}`;
+    fromJsonValueFunction = new ReferenceCallable(this.reusables.snippets.blankNodeFromJsonString);
+    fromJsonObjectFunction = new ReferenceCallable(this.reusables.snippets.blankNodeFromJsonObject);
+    fromRdfResourceValuesFunction = new ReferenceCallable(this.reusables.snippets.blankNodeFromRdfResourceValues);
     kind = "BlankNode";
     nodeKinds = nodeKinds;
-    parseFunction = code `${this.reusables.snippets.parseBlankNode};`;
+    parseFunction = new ReferenceCallable(this.reusables.snippets.parseBlankNode);
     schemaType = code `${this.reusables.snippets.BlankNodeSchema}`;
-    valueSparqlWherePatternsFunction = code `${this.reusables.snippets.blankNodeSparqlWherePatterns}`;
+    toJsonValueFunction = new ReferenceCallable(this.reusables.snippets.blankNodeToJsonString);
+    toJsonObjectFunction = new ReferenceCallable(this.reusables.snippets.blankNodeToJsonObject);
+    valueSparqlWherePatternsFunction = new ReferenceCallable(this.reusables.snippets.blankNodeSparqlWherePatterns);
     constructor(superParameters) {
         super({
             ...superParameters,
@@ -38,30 +36,6 @@ export class BlankNodeType extends AbstractIdentifierType {
             in_: [],
         });
     }
-    fromJsonExpression({ variables, }) {
-        return code `${this.reusables.imports.Either}.of<Error, ${this.expression}>(${this.reusables.imports.dataFactory}.blankNode(${variables.value}["@id"].substring(2)))`;
-    }
-    jsonSchema({ includeDiscriminantProperty, }) {
-        const discriminantProperty = includeDiscriminantProperty
-            ? code `, termType: ${this.reusables.imports.z}.literal("BlankNode")`
-            : "";
-        return code `${this.reusables.imports.z}.object({ "@id": ${this.reusables.imports.z}.string().min(1)${discriminantProperty} })`;
-    }
-    jsonType(parameters) {
-        const discriminantProperty = parameters?.includeDiscriminantProperty
-            ? `, readonly termType: "BlankNode"`
-            : "";
-        return new AbstractIdentifierType.JsonType(code `{ readonly "@id": string${discriminantProperty} }`);
-    }
-    toJsonExpression({ includeDiscriminantProperty, variables, }) {
-        const discriminantProperty = includeDiscriminantProperty
-            ? code `, termType: ${variables.value}.termType`
-            : "";
-        return code `{ "@id": \`_:\${${variables.value}.value}\`${discriminantProperty} }`;
-    }
 }
-__decorate([
-    Memoize()
-], BlankNodeType.prototype, "jsonType", null);
 const nodeKinds = new Set(["BlankNode"]);
 //# sourceMappingURL=BlankNodeType.js.map

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

@@ -1,21 +1,27 @@
 import type { Literal } from "@rdfjs/types";
 import { Maybe } from "purify-ts";
 import { AbstractPrimitiveType } from "./AbstractPrimitiveType.js";
+import type { Callable } from "./Callable.js";
+import { ReferenceCallable } from "./ReferenceCallable.js";
 import { type Code } from "./ts-poet-wrapper.js";
 export declare class BooleanType extends AbstractPrimitiveType<boolean> {
+    protected readonly decodedIn: boolean[];
     readonly conversionFunction: Maybe<AbstractPrimitiveType.ConversionFunction>;
-    readonly filterFunction: Code;
+    readonly filterFunction: ReferenceCallable;
     readonly filterType: Code;
     readonly graphqlType: import("./_AbstractType/AbstractType_GraphqlType.js").AbstractType_GraphqlType;
-    readonly hashFunction: Code;
+    readonly hashFunction: ReferenceCallable;
     readonly jsTypes: readonly [{
         readonly typeof: "boolean";
     }];
+    readonly jsonValueType: AbstractPrimitiveType.JsonType;
     readonly kind = "Boolean";
-    readonly valueSparqlWherePatternsFunction: Code;
-    get fromRdfResourceValuesFunction(): Code;
-    get schemaType(): Code;
-    valueExpression(literal: boolean | Literal): Code;
+    readonly schemaType: Code;
+    readonly valueSparqlWherePatternsFunction: ReferenceCallable;
+    get fromJsonObjectFunction(): Callable;
+    get fromJsonValueFunction(): Callable;
+    get fromRdfResourceValuesFunction(): Callable;
     toRdfResourceValuesExpression({ variables, }: Parameters<AbstractPrimitiveType<boolean>["toRdfResourceValuesExpression"]>[0]): Code;
+    valueExpression(literal: boolean | Literal): Code;
 }
 //# sourceMappingURL=BooleanType.d.ts.map

package/dist/generators/ts/BooleanType.js

@@ -8,33 +8,43 @@ import { LiteralDecoder } from "@rdfx/literal";
 import { Maybe } from "purify-ts";
 import { Memoize } from "typescript-memoize";
 import { AbstractPrimitiveType } from "./AbstractPrimitiveType.js";
+import { ReferenceCallable } from "./ReferenceCallable.js";
 import { code } from "./ts-poet-wrapper.js";
 export class BooleanType extends AbstractPrimitiveType {
+    decodedIn = this.in_.map((in_) => LiteralDecoder.decodeBooleanLiteral(in_).unsafeCoerce());
     conversionFunction = Maybe.empty();
-    filterFunction = code `${this.reusables.snippets.filterBoolean}`;
+    filterFunction = new ReferenceCallable(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}`;
+    hashFunction = new ReferenceCallable(this.reusables.snippets.hashBoolean);
     jsTypes = [{ typeof: "boolean" }];
+    jsonValueType = this.jsonTypeFactory.createJsonBooleanType({ in_: this.decodedIn });
     kind = "Boolean";
-    valueSparqlWherePatternsFunction = code `${this.reusables.snippets.booleanSparqlWherePatterns}`;
-    get fromRdfResourceValuesFunction() {
-        return code `${this.reusables.snippets.booleanFromRdfResourceValues}<${this.expression}>`;
+    schemaType = code `${this.reusables.snippets.BooleanSchema}<${this.expression}>`;
+    valueSparqlWherePatternsFunction = new ReferenceCallable(this.reusables.snippets.booleanSparqlWherePatterns);
+    get fromJsonObjectFunction() {
+        return new ReferenceCallable(code `${this.reusables.snippets.booleanFromJsonObject}<${this.expression}>`);
     }
-    get schemaType() {
-        return code `${this.reusables.snippets.BooleanSchema}<${this.expression}>`;
+    get fromJsonValueFunction() {
+        return new ReferenceCallable(code `${this.reusables.snippets.booleanFromJsonBoolean}<${this.expression}>`);
     }
-    valueExpression(literal) {
-        return code `${typeof literal === "boolean" ? literal : LiteralDecoder.decodeBooleanLiteral(literal).unsafeCoerce()}`;
+    get fromRdfResourceValuesFunction() {
+        return new ReferenceCallable(code `${this.reusables.snippets.booleanFromRdfResourceValues}<${this.expression}>`);
     }
     toRdfResourceValuesExpression({ variables, }) {
         return code `[${this.reusables.snippets.literalFactory}.boolean(${variables.value}, ${this.rdfjsTermExpression(this.datatype)})]`;
     }
+    valueExpression(literal) {
+        return code `${typeof literal === "boolean" ? literal : LiteralDecoder.decodeBooleanLiteral(literal).unsafeCoerce()}`;
+    }
 }
 __decorate([
     Memoize()
-], BooleanType.prototype, "fromRdfResourceValuesFunction", null);
+], BooleanType.prototype, "fromJsonObjectFunction", null);
 __decorate([
     Memoize()
-], BooleanType.prototype, "schemaType", null);
+], BooleanType.prototype, "fromJsonValueFunction", null);
+__decorate([
+    Memoize()
+], BooleanType.prototype, "fromRdfResourceValuesFunction", null);
 //# sourceMappingURL=BooleanType.js.map

package/dist/generators/ts/Callable.d.ts

@@ -0,0 +1,5 @@
+import type { DeclaredCallable } from "./DeclaredCallable.js";
+import type { InlineCallable } from "./InlineCallable.js";
+import type { ReferenceCallable } from "./ReferenceCallable.js";
+export type Callable = InlineCallable | DeclaredCallable | ReferenceCallable;
+//# sourceMappingURL=Callable.d.ts.map

package/dist/generators/ts/Callable.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=Callable.js.map

package/dist/generators/ts/CodeThunk.d.ts

@@ -0,0 +1,6 @@
+import type { Code } from "./ts-poet-wrapper.js";
+export type CodeThunk = Code | (() => Code);
+export declare namespace CodeThunk {
+    function evaluate(codeThunk: CodeThunk): Code;
+}
+//# sourceMappingURL=CodeThunk.d.ts.map

package/dist/generators/ts/CodeThunk.js

@@ -0,0 +1,8 @@
+export var CodeThunk;
+(function (CodeThunk) {
+    function evaluate(codeThunk) {
+        return typeof codeThunk === "function" ? codeThunk() : codeThunk;
+    }
+    CodeThunk.evaluate = evaluate;
+})(CodeThunk || (CodeThunk = {}));
+//# sourceMappingURL=CodeThunk.js.map

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

@@ -1,13 +1,16 @@
 import type { Literal } from "@rdfjs/types";
 import { AbstractDateType } from "./AbstractDateType.js";
+import { ReferenceCallable } from "./ReferenceCallable.js";
 import { type Code } from "./ts-poet-wrapper.js";
 export declare class DateTimeType extends AbstractDateType {
+    readonly fromJsonObjectFunction: ReferenceCallable;
+    readonly fromRdfResourceValuesFunction: ReferenceCallable;
     readonly graphqlType: import("./_AbstractType/AbstractType_GraphqlType.js").AbstractType_GraphqlType;
-    readonly hashFunction: Code;
+    protected readonly jsonStringFormat = "datetime";
+    readonly hashFunction: ReferenceCallable;
     readonly kind = "DateTime";
-    get fromRdfResourceValuesFunction(): Code;
-    jsonSchema(): Code;
+    readonly toJsonValueFunction: ReferenceCallable;
+    readonly toJsonObjectFunction: ReferenceCallable;
     valueExpression(literal: Date | Literal): Code;
-    toJsonExpression({ variables, }: Parameters<AbstractDateType["toJsonExpression"]>[0]): Code;
 }
 //# sourceMappingURL=DateTimeType.d.ts.map

package/dist/generators/ts/DateTimeType.js

@@ -1,31 +1,18 @@
-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 { LiteralDecoder } from "@rdfx/literal";
-import { Memoize } from "typescript-memoize";
 import { AbstractDateType } from "./AbstractDateType.js";
-import { code, literalOf } from "./ts-poet-wrapper.js";
+import { ReferenceCallable } from "./ReferenceCallable.js";
+import { code } from "./ts-poet-wrapper.js";
 export class DateTimeType extends AbstractDateType {
+    fromJsonObjectFunction = new ReferenceCallable(this.reusables.snippets.dateTimeFromJsonObject);
+    fromRdfResourceValuesFunction = new ReferenceCallable(this.reusables.snippets.dateTimeFromRdfResourceValues);
     graphqlType = new DateTimeType.GraphqlType(code `${this.reusables.imports.GraphQLDateTime}`, this.reusables);
-    hashFunction = code `${this.reusables.snippets.hashDateTime}`;
+    jsonStringFormat = "datetime";
+    hashFunction = new ReferenceCallable(this.reusables.snippets.hashDateTime);
     kind = "DateTime";
-    get fromRdfResourceValuesFunction() {
-        return code `${this.reusables.snippets.dateTimeFromRdfResourceValues}`;
-    }
-    jsonSchema() {
-        return code `${this.reusables.imports.z}.object({ "@type": ${this.reusables.imports.z}.literal(${literalOf(this.datatype.value)}), "@value": ${this.reusables.imports.z}.iso.datetime() })`;
-    }
+    toJsonValueFunction = new ReferenceCallable(this.reusables.snippets.dateTimeToJsonString);
+    toJsonObjectFunction = new ReferenceCallable(code `${this.reusables.snippets.dateToJsonObject}(${this.rdfjsTermExpression(this.datatype)})`);
     valueExpression(literal) {
         return code `new Date("${(literal instanceof Date ? literal : LiteralDecoder.decodeDateTimeLiteral(literal).unsafeCoerce()).toISOString()}")`;
     }
-    toJsonExpression({ variables, }) {
-        return code `{ "@type": ${literalOf(this.datatype.value)} as const, "@value": ${variables.value}.toISOString() }`;
-    }
 }
-__decorate([
-    Memoize()
-], DateTimeType.prototype, "fromRdfResourceValuesFunction", null);
 //# sourceMappingURL=DateTimeType.js.map

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

@@ -1,13 +1,16 @@
 import type { Literal } from "@rdfjs/types";
 import { AbstractDateType } from "./AbstractDateType.js";
+import { ReferenceCallable } from "./ReferenceCallable.js";
 import { type Code } from "./ts-poet-wrapper.js";
 export declare class DateType extends AbstractDateType {
+    readonly fromJsonObjectFunction: ReferenceCallable;
+    readonly fromRdfResourceValuesFunction: ReferenceCallable;
     readonly graphqlType: import("./_AbstractType/AbstractType_GraphqlType.js").AbstractType_GraphqlType;
-    readonly hashFunction: Code;
+    readonly hashFunction: ReferenceCallable;
     readonly kind = "Date";
-    get fromRdfResourceValuesFunction(): Code;
-    jsonSchema(): Code;
+    protected readonly jsonStringFormat = "date";
+    readonly toJsonValueFunction: ReferenceCallable;
+    readonly toJsonObjectFunction: ReferenceCallable;
     valueExpression(literal: Date | Literal): Code;
-    toJsonExpression({ variables, }: Parameters<AbstractDateType["toJsonExpression"]>[0]): Code;
 }
 //# sourceMappingURL=DateType.d.ts.map

package/dist/generators/ts/DateType.js

@@ -1,32 +1,19 @@
-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 { LiteralDecoder } from "@rdfx/literal";
-import { Memoize } from "typescript-memoize";
 import { AbstractDateType } from "./AbstractDateType.js";
 import { DateTimeType } from "./DateTimeType.js";
-import { code, literalOf } from "./ts-poet-wrapper.js";
+import { ReferenceCallable } from "./ReferenceCallable.js";
+import { code } from "./ts-poet-wrapper.js";
 export class DateType extends AbstractDateType {
+    fromJsonObjectFunction = new ReferenceCallable(this.reusables.snippets.dateFromJsonObject);
+    fromRdfResourceValuesFunction = new ReferenceCallable(this.reusables.snippets.dateFromRdfResourceValues);
     graphqlType = new DateTimeType.GraphqlType(code `${this.reusables.imports.GraphQLDate}`, this.reusables);
-    hashFunction = code `${this.reusables.snippets.hashDate}`;
+    hashFunction = new ReferenceCallable(this.reusables.snippets.hashDate);
     kind = "Date";
-    get fromRdfResourceValuesFunction() {
-        return code `${this.reusables.snippets.dateFromRdfResourceValues}`;
-    }
-    jsonSchema() {
-        return code `${this.reusables.imports.z}.object({ "@type": ${this.reusables.imports.z}.literal(${literalOf(this.datatype.value)}), "@value": ${this.reusables.imports.z}.iso.date() })`;
-    }
+    jsonStringFormat = "date";
+    toJsonValueFunction = new ReferenceCallable(this.reusables.snippets.dateToJsonString);
+    toJsonObjectFunction = new ReferenceCallable(code `${this.reusables.snippets.dateToJsonObject}(${this.rdfjsTermExpression(this.datatype)})`);
     valueExpression(literal) {
         return code `new Date("${(literal instanceof Date ? literal : LiteralDecoder.decodeDateLiteral(literal).unsafeCoerce()).toISOString()}")`;
     }
-    toJsonExpression({ variables, }) {
-        return code `{ "@type": ${literalOf(this.datatype.value)} as const, "@value": ${this.reusables.snippets.toIsoDateString}(${variables.value}) }`;
-    }
 }
-__decorate([
-    Memoize()
-], DateType.prototype, "fromRdfResourceValuesFunction", null);
 //# sourceMappingURL=DateType.js.map

package/dist/generators/ts/DeclaredCallable.d.ts

@@ -0,0 +1,23 @@
+import { AbstractCallable } from "./AbstractCallable.js";
+import { CodeThunk } from "./CodeThunk.js";
+import { type Code } from "./ts-poet-wrapper.js";
+/**
+ * A callable that is bound to an annotated variable. Consumers reference the variable, so there's no distinction
+ * between annotated and unannotated usage.
+ */
+export declare class DeclaredCallable extends AbstractCallable {
+    #private;
+    private readonly qualifiedName;
+    constructor({ qualifiedName, type, unannotatedExpression, }: {
+        qualifiedName: readonly string[];
+        type: CodeThunk;
+        unannotatedExpression: CodeThunk;
+    });
+    get annotatedUsage(): Code;
+    get declaration(): Code;
+    get type(): Code;
+    get unannotatedExpression(): Code;
+    get unannotatedUsage(): Code;
+    get unqualifiedName(): string;
+}
+//# sourceMappingURL=DeclaredCallable.d.ts.map

package/dist/generators/ts/DeclaredCallable.js

@@ -0,0 +1,59 @@
+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 { AbstractCallable } from "./AbstractCallable.js";
+import { CodeThunk } from "./CodeThunk.js";
+import { code } from "./ts-poet-wrapper.js";
+/**
+ * A callable that is bound to an annotated variable. Consumers reference the variable, so there's no distinction
+ * between annotated and unannotated usage.
+ */
+export class DeclaredCallable extends AbstractCallable {
+    qualifiedName;
+    #type;
+    #unannotatedExpression;
+    constructor({ qualifiedName, type, unannotatedExpression, }) {
+        super();
+        this.#unannotatedExpression = unannotatedExpression;
+        this.qualifiedName = qualifiedName;
+        this.#type = type;
+    }
+    get annotatedUsage() {
+        return code `${this.qualifiedName.join(".")}`;
+    }
+    get declaration() {
+        return code `const ${this.unqualifiedName}: ${this.type} = ${this.unannotatedExpression};`;
+    }
+    get type() {
+        return CodeThunk.evaluate(this.#type);
+    }
+    get unannotatedExpression() {
+        return CodeThunk.evaluate(this.#unannotatedExpression);
+    }
+    get unannotatedUsage() {
+        return code `${this.qualifiedName.join(".")}`;
+    }
+    get unqualifiedName() {
+        return this.qualifiedName.at(-1);
+    }
+}
+__decorate([
+    Memoize()
+], DeclaredCallable.prototype, "annotatedUsage", null);
+__decorate([
+    Memoize()
+], DeclaredCallable.prototype, "declaration", null);
+__decorate([
+    Memoize()
+], DeclaredCallable.prototype, "type", null);
+__decorate([
+    Memoize()
+], DeclaredCallable.prototype, "unannotatedExpression", null);
+__decorate([
+    Memoize()
+], DeclaredCallable.prototype, "unannotatedUsage", null);
+//# sourceMappingURL=DeclaredCallable.js.map

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

@@ -1,14 +1,21 @@
 import type { Literal, NamedNode } from "@rdfjs/types";
 import { Maybe } from "purify-ts";
 import { AbstractContainerType } from "./AbstractContainerType.js";
-import type { AbstractType } from "./AbstractType.js";
 import type { BlankNodeType } from "./BlankNodeType.js";
+import { InlineCallable } from "./InlineCallable.js";
 import type { Type } from "./Type.js";
 import { type Code } from "./ts-poet-wrapper.js";
 export declare class DefaultValueType<ItemTypeT extends DefaultValueType.ItemType> extends AbstractContainerType<ItemTypeT> {
     readonly defaultValue: Literal | NamedNode;
-    readonly discriminantProperty: Maybe<AbstractType.DiscriminantProperty>;
-    readonly graphqlArgs: AbstractType["graphqlArgs"];
+    readonly equalsFunction: import("./Callable.js").Callable;
+    readonly filterFunction: import("./Callable.js").Callable;
+    readonly filterType: Code;
+    readonly schemaType: Code;
+    readonly fromRdfResourceValuesFunction: InlineCallable;
+    readonly graphqlArgs: AbstractContainerType<ItemTypeT>["graphqlArgs"];
+    readonly graphqlType: import("./_AbstractType/AbstractType_GraphqlType.js").AbstractType_GraphqlType;
+    readonly hashFunction: import("./Callable.js").Callable;
+    readonly inlineExpression: Code;
     readonly jsTypes: readonly import("./_AbstractType/AbstractType_JsType.js").AbstractType_JsType[] | readonly [{
         readonly instanceof: "Object";
         readonly typeof: "object";
@@ -51,34 +58,28 @@ export declare class DefaultValueType<ItemTypeT extends DefaultValueType.ItemTyp
         readonly instanceof: "Object";
         readonly typeof: "object";
     }];
+    readonly jsonObjectType: AbstractContainerType<ItemTypeT>["jsonObjectType"];
+    readonly jsonValueType: AbstractContainerType<ItemTypeT>["jsonValueType"];
     readonly kind = "DefaultValue";
-    readonly validationFunction: Maybe<Code>;
+    readonly mutable: boolean;
+    readonly toJsonObjectFunction: import("./Callable.js").Callable;
+    readonly toJsonValueFunction: import("./Callable.js").Callable;
+    readonly toRdfResourceValueTypes: ReadonlySet<"BlankNode" | "Literal" | "NamedNode">;
+    readonly validationFunction: AbstractContainerType<ItemTypeT>["validationFunction"];
+    readonly valueSparqlConstructTriplesFunction: import("./Callable.js").Callable;
+    readonly valueSparqlWherePatternsFunction: InlineCallable;
     constructor({ defaultValue, ...superParameters }: {
         defaultValue: Literal | NamedNode;
     } & ConstructorParameters<typeof AbstractContainerType<ItemTypeT>>[0]);
     get conversionFunction(): Maybe<AbstractContainerType.ConversionFunction>;
-    get equalsFunction(): Code;
-    get filterFunction(): Code;
-    get filterType(): Code;
-    get fromRdfResourceValuesFunction(): Code;
-    get graphqlType(): AbstractContainerType.GraphqlType;
-    get hashFunction(): Code;
-    get mutable(): boolean;
-    get schemaType(): Code;
-    get toRdfResourceValueTypes(): AbstractContainerType<ItemTypeT>["toRdfResourceValueTypes"];
-    get valueSparqlConstructTriplesFunction(): Code;
-    get valueSparqlWherePatternsFunction(): Code;
-    protected get inlineExpression(): Code;
+    get fromJsonObjectFunction(): AbstractContainerType<ItemTypeT>["fromJsonObjectFunction"];
+    get fromJsonValueFunction(): AbstractContainerType<ItemTypeT>["fromJsonValueFunction"];
     protected get schemaInitializers(): Code[];
     private get defaultValueExpression();
-    fromJsonExpression(parameters: Parameters<AbstractType["fromJsonExpression"]>[0]): Code;
     graphqlResolveExpression(parameters: Parameters<AbstractContainerType<ItemTypeT>["graphqlResolveExpression"]>[0]): 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>;
-    toJsonExpression(parameters: Parameters<AbstractType["toJsonExpression"]>[0]): Code;
-    toRdfResourceValuesExpression(parameters: Parameters<AbstractType["toRdfResourceValuesExpression"]>[0]): Code;
-    toStringExpression(parameters: Parameters<AbstractType["toStringExpression"]>[0]): Code;
+    toLoggableExpression(parameters: Parameters<AbstractContainerType<ItemTypeT>["toLoggableExpression"]>[0]): Code;
+    toRdfResourceValuesExpression(parameters: Parameters<AbstractContainerType<ItemTypeT>["toRdfResourceValuesExpression"]>[0]): Code;
+    toStringExpression(parameters: Parameters<AbstractContainerType<ItemTypeT>["toStringExpression"]>[0]): Code;
 }
 export declare namespace DefaultValueType {
     type ItemType = Exclude<AbstractContainerType.ItemType, BlankNodeType>;