@shaclmate/compiler 4.0.94 → 4.0.96

package/dist/generators/ts/DefaultValueType.js

@@ -8,14 +8,31 @@ import { Maybe } from "purify-ts";
 import { invariant } from "ts-invariant";
 import { Memoize } from "typescript-memoize";
 import { AbstractContainerType } from "./AbstractContainerType.js";
+import { InlineCallable } from "./InlineCallable.js";
+import { ReferenceCallable } from "./ReferenceCallable.js";
 import { code } from "./ts-poet-wrapper.js";
 export class DefaultValueType extends AbstractContainerType {
     defaultValue;
-    discriminantProperty = Maybe.empty();
+    equalsFunction = this.itemType.equalsFunction;
+    filterFunction = this.itemType.filterFunction;
+    filterType = this.itemType.filterType;
+    schemaType = code `${this.reusables.snippets.DefaultValueSchema}<${this.itemType.schemaType}>`;
+    fromRdfResourceValuesFunction = new InlineCallable(code `${this.reusables.snippets.defaultValueFromRdfResourceValues}<${this.itemType.expression}, ${this.itemType.schemaType}>(${this.itemType.fromRdfResourceValuesFunction.unannotatedUsage})`);
     graphqlArgs = Maybe.empty();
+    graphqlType = this.itemType.graphqlType;
+    hashFunction = this.itemType.hashFunction;
+    inlineExpression = this.itemType.expression;
     jsTypes = this.itemType.jsTypes;
+    jsonObjectType = this.itemType.jsonObjectType;
+    jsonValueType = this.itemType.jsonValueType;
     kind = "DefaultValue";
+    mutable = this.itemType.mutable;
+    toJsonObjectFunction = this.itemType.toJsonObjectFunction;
+    toJsonValueFunction = this.itemType.toJsonValueFunction;
+    toRdfResourceValueTypes = this.itemType.toRdfResourceValueTypes;
     validationFunction = this.itemType.validationFunction;
+    valueSparqlConstructTriplesFunction = this.itemType.valueSparqlConstructTriplesFunction;
+    valueSparqlWherePatternsFunction = new InlineCallable(code `${this.reusables.snippets.defaultValueSparqlWherePatterns}<${this.itemType.filterType}, ${this.itemType.schemaType}>(${this.itemType.valueSparqlWherePatternsFunction.unannotatedUsage})`);
     constructor({ defaultValue, ...superParameters }) {
         super(superParameters);
         this.defaultValue = defaultValue;
@@ -32,41 +49,11 @@ export class DefaultValueType extends AbstractContainerType {
             }),
         });
     }
-    get equalsFunction() {
-        return this.itemType.equalsFunction;
+    get fromJsonObjectFunction() {
+        return new ReferenceCallable(code `${this.reusables.snippets.defaultValueFromJsonObject}(${this.itemType.fromJsonObjectFunction.annotatedUsage})`);
     }
-    get filterFunction() {
-        return this.itemType.filterFunction;
-    }
-    get filterType() {
-        return this.itemType.filterType;
-    }
-    get fromRdfResourceValuesFunction() {
-        return code `${this.reusables.snippets.defaultValueFromRdfResourceValues}<${this.itemType.expression}, ${this.itemType.schemaType}>(${this.itemType.fromRdfResourceValuesFunction})`;
-    }
-    get graphqlType() {
-        return this.itemType.graphqlType;
-    }
-    get hashFunction() {
-        return this.itemType.hashFunction;
-    }
-    get mutable() {
-        return this.itemType.mutable;
-    }
-    get schemaType() {
-        return code `${this.reusables.snippets.DefaultValueSchema}<${this.itemType.schemaType}>`;
-    }
-    get toRdfResourceValueTypes() {
-        return this.itemType.toRdfResourceValueTypes;
-    }
-    get valueSparqlConstructTriplesFunction() {
-        return this.itemType.valueSparqlConstructTriplesFunction;
-    }
-    get valueSparqlWherePatternsFunction() {
-        return code `${this.reusables.snippets.defaultValueSparqlWherePatterns}<${this.itemType.filterType}, ${this.itemType.schemaType}>(${this.itemType.valueSparqlWherePatternsFunction})`;
-    }
-    get inlineExpression() {
-        return this.itemType.expression;
+    get fromJsonValueFunction() {
+        return new ReferenceCallable(code `${this.reusables.snippets.defaultValueFromJsonValue}(${this.itemType.fromJsonValueFunction.annotatedUsage})`);
     }
     get schemaInitializers() {
         return super.schemaInitializers.concat(code `defaultValue: ${this.rdfjsTermExpression(this.defaultValue)}`);
@@ -78,36 +65,25 @@ export class DefaultValueType extends AbstractContainerType {
             case "Literal":
             case "Term":
                 return this.rdfjsTermExpression(this.defaultValue);
+            case "DiscriminatedUnion":
             case "List":
             case "Object":
             case "ObjectDiscriminatedUnion":
-            case "DiscriminatedUnion":
+            case "ObjectIntersection":
                 throw new RangeError(`not implemented ${this.itemType.kind}`);
         }
         invariant(this.defaultValue.termType === "Literal");
         return this.itemType.valueExpression(this.defaultValue);
     }
-    fromJsonExpression(parameters) {
-        return this.itemType.fromJsonExpression(parameters);
-    }
     graphqlResolveExpression(parameters) {
         return this.itemType.graphqlResolveExpression(parameters);
     }
-    jsonSchema(parameters) {
-        return this.itemType.jsonSchema(parameters);
-    }
-    jsonType(parameters) {
-        return this.itemType.jsonType(parameters);
-    }
-    jsonUiSchemaElement(parameters) {
-        return this.itemType.jsonUiSchemaElement(parameters);
-    }
-    toJsonExpression(parameters) {
-        return this.itemType.toJsonExpression(parameters);
+    toLoggableExpression(parameters) {
+        return this.itemType.toLoggableExpression(parameters);
     }
     toRdfResourceValuesExpression(parameters) {
         const { variables } = parameters;
-        return code `${this.itemType.equalsFunction}(${variables.value}, ${this.defaultValueExpression}).isLeft() ? ${this.itemType.toRdfResourceValuesExpression(parameters)} : []`;
+        return code `${this.itemType.equalsFunction.annotatedUsage}(${variables.value}, ${this.defaultValueExpression}).isLeft() ? ${this.itemType.toRdfResourceValuesExpression(parameters)} : []`;
     }
     toStringExpression(parameters) {
         return this.itemType.toStringExpression(parameters);
@@ -118,16 +94,10 @@ __decorate([
 ], DefaultValueType.prototype, "conversionFunction", null);
 __decorate([
     Memoize()
-], DefaultValueType.prototype, "fromRdfResourceValuesFunction", null);
-__decorate([
-    Memoize()
-], DefaultValueType.prototype, "schemaType", null);
-__decorate([
-    Memoize()
-], DefaultValueType.prototype, "valueSparqlConstructTriplesFunction", null);
+], DefaultValueType.prototype, "fromJsonObjectFunction", null);
 __decorate([
     Memoize()
-], DefaultValueType.prototype, "valueSparqlWherePatternsFunction", null);
+], DefaultValueType.prototype, "fromJsonValueFunction", null);
 __decorate([
     Memoize()
 ], DefaultValueType.prototype, "defaultValueExpression", null);

package/dist/generators/ts/FloatType.d.ts

@@ -1,15 +1,20 @@
 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 FloatType extends AbstractNumericType<number> {
+    protected readonly decodedIn: number[];
     readonly conversionFunction: Maybe<AbstractNumericType.ConversionFunction>;
+    readonly graphqlType: import("./_AbstractType/AbstractType_GraphqlType.js").AbstractType_GraphqlType;
     readonly jsTypes: readonly [{
         readonly typeof: "number";
     }];
+    readonly jsonValueType: AbstractNumericType.JsonType;
     readonly kind = "Float";
-    get fromRdfResourceValuesFunction(): Code;
-    get graphqlType(): import("./_AbstractType/AbstractType_GraphqlType.js").AbstractType_GraphqlType;
+    get fromJsonObjectFunction(): Callable;
+    get fromJsonValueFunction(): Callable;
+    get fromRdfResourceValuesFunction(): Callable;
     valueExpression(literal: Literal | number): Code;
 }
 //# sourceMappingURL=FloatType.d.ts.map

package/dist/generators/ts/FloatType.js

@@ -8,16 +8,23 @@ import { LiteralDecoder } from "@rdfx/literal";
 import { Maybe } from "purify-ts";
 import { Memoize } from "typescript-memoize";
 import { AbstractNumericType } from "./AbstractNumericType.js";
+import { ReferenceCallable } from "./ReferenceCallable.js";
 import { code } from "./ts-poet-wrapper.js";
 export class FloatType extends AbstractNumericType {
+    decodedIn = this.in_.map((in_) => LiteralDecoder.decodeFloatLiteral(in_).unsafeCoerce());
     conversionFunction = Maybe.empty();
+    graphqlType = new AbstractNumericType.GraphqlType(code `${this.reusables.imports.GraphQLFloat}`, this.reusables);
     jsTypes = [{ typeof: "number" }];
+    jsonValueType = this.jsonTypeFactory.createJsonNumberType({ in_: this.decodedIn });
     kind = "Float";
-    get fromRdfResourceValuesFunction() {
-        return code `${this.reusables.snippets.floatFromRdfResourceValues}<${this.expression}>`;
+    get fromJsonObjectFunction() {
+        return new ReferenceCallable(code `${this.reusables.snippets.floatFromJsonObject}<${this.expression}>`);
+    }
+    get fromJsonValueFunction() {
+        return new ReferenceCallable(code `${this.reusables.snippets.floatFromJsonNumber}<${this.expression}>`);
     }
-    get graphqlType() {
-        return new AbstractNumericType.GraphqlType(code `${this.reusables.imports.GraphQLFloat}`, this.reusables);
+    get fromRdfResourceValuesFunction() {
+        return new ReferenceCallable(code `${this.reusables.snippets.floatFromRdfResourceValues}<${this.expression}>`);
     }
     valueExpression(literal) {
         return code `${typeof literal === "number" ? literal : LiteralDecoder.decodeFloatLiteral(literal).unsafeCoerce()}`;
@@ -25,8 +32,11 @@ export class FloatType extends AbstractNumericType {
 }
 __decorate([
     Memoize()
-], FloatType.prototype, "fromRdfResourceValuesFunction", null);
+], FloatType.prototype, "fromJsonObjectFunction", null);
 __decorate([
     Memoize()
-], FloatType.prototype, "graphqlType", null);
+], FloatType.prototype, "fromJsonValueFunction", null);
+__decorate([
+    Memoize()
+], FloatType.prototype, "fromRdfResourceValuesFunction", null);
 //# sourceMappingURL=FloatType.js.map

package/dist/generators/ts/GraphqlSchema.js

@@ -46,7 +46,7 @@ export const graphqlSchema = new ${this.reusables.imports.GraphQLSchema}({ query
                 },
                 resolve: code `\
    async (_source, args: { limit: number | null; offset: number | null; }, { objectSet }): Promise<readonly string[]> =>
-    (await objectSet.${namedObjectType.objectSetMethodNames.objectIdentifiers}({ limit: args.limit !== null ? args.limit : undefined, offset: args.offset !== null ? args.offset : undefined })).unsafeCoerce().map(${namedObjectType.identifierTypeAlias}.stringify)`,
+    (await objectSet.${namedObjectType.objectSetMethodNames.objectIdentifiers}({ limit: args.limit !== null ? args.limit : undefined, offset: args.offset !== null ? args.offset : undefined })).unsafeCoerce().map(${this.reusables.imports.NTriplesIdentifier}.stringify)`,
                 type: code `new ${this.reusables.imports.GraphQLNonNull}(new ${this.reusables.imports.GraphQLList}(${this.reusables.imports.GraphQLString}))`,
             };
             fields[namedObjectType.objectSetMethodNames.objects] = {

package/dist/generators/ts/IdentifierType.d.ts

@@ -1,23 +1,23 @@
 import type { BlankNode, NamedNode } from "@rdfjs/types";
-import { type IdentifierNodeKind } from "@shaclmate/shacl-ast";
+import type { IdentifierNodeKind } from "@shaclmate/shacl-ast";
 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 IdentifierType extends AbstractIdentifierType<BlankNode | NamedNode> {
-    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 fromJsonValueFunction: ReferenceCallable;
+    readonly fromJsonObjectFunction: ReferenceCallable;
+    readonly filterType: import("ts-poet/build/Code.js").Code;
+    readonly fromRdfResourceValuesFunction: ReferenceCallable;
     readonly kind = "Identifier";
     readonly nodeKinds: ReadonlySet<IdentifierNodeKind>;
-    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(parameters: Omit<ConstructorParameters<typeof AbstractIdentifierType<BlankNode | NamedNode>>[0], "hasValues" | "in_">);
-    fromJsonExpression({ variables, }: Parameters<AbstractIdentifierType<BlankNode | NamedNode>["fromJsonExpression"]>[0]): Code;
-    jsonSchema({ includeDiscriminantProperty, }: Parameters<AbstractIdentifierType<BlankNode | NamedNode>["jsonSchema"]>[0]): Code;
-    jsonType(parameters?: Parameters<AbstractIdentifierType<BlankNode | NamedNode>["jsonType"]>[0]): AbstractIdentifierType.JsonType;
-    toJsonExpression({ includeDiscriminantProperty, variables, }: Parameters<AbstractIdentifierType<BlankNode | NamedNode>["toJsonExpression"]>[0]): Code;
 }
 //# sourceMappingURL=IdentifierType.d.ts.map

package/dist/generators/ts/IdentifierType.js

@@ -1,14 +1,7 @@
-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 { NodeKind } from "@shaclmate/shacl-ast";
 import { Maybe } from "purify-ts";
-import { Memoize } from "typescript-memoize";
 import { AbstractIdentifierType } from "./AbstractIdentifierType.js";
-import { arrayOf, code } from "./ts-poet-wrapper.js";
+import { ReferenceCallable } from "./ReferenceCallable.js";
+import { code } from "./ts-poet-wrapper.js";
 export class IdentifierType extends AbstractIdentifierType {
     inlineExpression = code `(${this.reusables.imports.BlankNode} | ${this.reusables.imports.NamedNode})`;
     conversionFunction = Maybe.of({
@@ -34,14 +27,18 @@ export class IdentifierType extends AbstractIdentifierType {
             },
         ],
     });
-    filterFunction = code `${this.reusables.snippets.filterIdentifier}`;
+    filterFunction = new ReferenceCallable(this.reusables.snippets.filterIdentifier);
+    fromJsonValueFunction = new ReferenceCallable(this.reusables.snippets.identifierFromJsonString);
+    fromJsonObjectFunction = new ReferenceCallable(this.reusables.snippets.identifierFromJsonObject);
     filterType = code `${this.reusables.snippets.IdentifierFilter}`;
-    fromRdfResourceValuesFunction = code `${this.reusables.snippets.identifierFromRdfResourceValues}`;
+    fromRdfResourceValuesFunction = new ReferenceCallable(this.reusables.snippets.identifierFromRdfResourceValues);
     kind = "Identifier";
     nodeKinds = nodeKinds;
-    parseFunction = code `${this.reusables.snippets.parseIdentifier};`;
+    parseFunction = new ReferenceCallable(this.reusables.snippets.parseIdentifier);
     schemaType = code `${this.reusables.snippets.IdentifierSchema}`;
-    valueSparqlWherePatternsFunction = code `${this.reusables.snippets.identifierSparqlWherePatterns}`;
+    toJsonValueFunction = new ReferenceCallable(this.reusables.snippets.identifierToJsonString);
+    toJsonObjectFunction = new ReferenceCallable(this.reusables.snippets.identifierToJsonObject);
+    valueSparqlWherePatternsFunction = new ReferenceCallable(this.reusables.snippets.identifierSparqlWherePatterns);
     constructor(parameters) {
         super({
             ...parameters,
@@ -49,33 +46,7 @@ export class IdentifierType extends AbstractIdentifierType {
             in_: [],
         });
     }
-    fromJsonExpression({ variables, }) {
-        return code `${this.reusables.imports.Either}.of<Error, ${this.expression}>((${variables.value}["@id"].startsWith("_:") ? ${this.reusables.imports.dataFactory}.blankNode(${variables.value}["@id"].substring(2)) : ${this.reusables.imports.dataFactory}.namedNode(${variables.value}["@id"])))`;
-    }
-    jsonSchema({ includeDiscriminantProperty, }) {
-        const discriminantProperty = includeDiscriminantProperty
-            ? code `, termType: ${this.reusables.imports.z}.enum(${arrayOf(...[...this.nodeKinds].map(NodeKind.toTermType))})`
-            : "";
-        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" | "NamedNode"`
-            : "";
-        return new AbstractIdentifierType.JsonType(code `{ readonly "@id": string${discriminantProperty} }`);
-    }
-    toJsonExpression({ includeDiscriminantProperty, variables, }) {
-        const discriminantProperty = includeDiscriminantProperty
-            ? code `, termType: ${variables.value}.termType as ${[...this.nodeKinds].map((nodeKind) => `"${NodeKind.toTermType(nodeKind)}"`).join(" | ")}`
-            : "";
-        const valueToBlankNode = code `{ "@id": \`_:\${${variables.value}.value}\`${discriminantProperty} }`;
-        const valueToNamedNode = code `{ "@id": ${variables.value}.value${discriminantProperty} }`;
-        return code `(${variables.value}.termType === "BlankNode" ? ${valueToBlankNode} : ${valueToNamedNode})`;
-    }
 }
-__decorate([
-    Memoize()
-], IdentifierType.prototype, "jsonType", null);
 const nodeKinds = new Set([
     "BlankNode",
     "IRI",

package/dist/generators/ts/Imports.d.ts

@@ -19,12 +19,19 @@ export declare class Imports {
     readonly GraphQLSchema: import("ts-poet/build/Import.js").Import;
     readonly GraphQLString: import("ts-poet/build/Import.js").Import;
     readonly GraphQLUnionType: import("ts-poet/build/Import.js").Import;
+    readonly Hono: import("ts-poet/build/Import.js").Import;
+    readonly HonoEnv: import("ts-poet/build/Import.js").Import;
+    readonly HonoValidationTargets: import("ts-poet/build/Import.js").Import;
+    readonly honoZodValidator: import("ts-poet/build/Import.js").Import;
     readonly Left: import("ts-poet/build/Import.js").Import;
     readonly Literal: import("ts-poet/build/Import.js").Import;
+    readonly LiteralDecoder: import("ts-poet/build/Import.js").Import;
     readonly LiteralFactory: import("ts-poet/build/Import.js").Import;
+    readonly Logger: import("ts-poet/build/Import.js").Import;
     readonly Maybe: import("ts-poet/build/Import.js").Import;
     readonly NamedNode: import("ts-poet/build/Import.js").Import;
     readonly NonEmptyList: import("ts-poet/build/Import.js").Import;
+    readonly nopLogger: import("ts-poet/build/Import.js").Import;
     readonly NTriplesIdentifier: import("ts-poet/build/Import.js").Import;
     readonly NTriplesTerm: import("ts-poet/build/Import.js").Import;
     readonly Quad: import("ts-poet/build/Import.js").Import;
@@ -36,5 +43,6 @@ export declare class Imports {
     readonly sparqljs: import("ts-poet/build/Import.js").Import;
     readonly Variable: import("ts-poet/build/Import.js").Import;
     readonly z: import("ts-poet/build/Import.js").Import;
+    readonly ZodType: import("ts-poet/build/Import.js").Import;
 }
 //# sourceMappingURL=Imports.d.ts.map

package/dist/generators/ts/Imports.js

@@ -1,9 +1,9 @@
 import { imp } from "./ts-poet-wrapper.js";
 export class Imports {
     BigDecimal = imp("Decimal:BigDecimal@decimal.js");
-    BlankNode = imp("BlankNode@@rdfjs/types");
+    BlankNode = imp("t:BlankNode@@rdfjs/types");
     dataFactory = imp("dataFactory=@rdfx/data-factory");
-    DatasetCore = imp("DatasetCore@@rdfjs/types");
+    DatasetCore = imp("t:DatasetCore@@rdfjs/types");
     datasetFactory = imp("datasetFactory@@rdfx/collection");
     Either = imp("Either@purify-ts");
     EitherAsync = imp("EitherAsync@purify-ts");
@@ -20,22 +20,30 @@ export class Imports {
     GraphQLSchema = imp("GraphQLSchema@graphql");
     GraphQLString = imp("GraphQLString@graphql");
     GraphQLUnionType = imp("GraphQLUnionType@graphql");
+    Hono = imp("Hono@hono");
+    HonoEnv = imp("t:Env@hono");
+    HonoValidationTargets = imp("t:ValidationTargets:HonoValidationTargets@hono");
+    honoZodValidator = imp("zValidator:honoZodValidator@@hono/zod-validator");
     Left = imp("Left@purify-ts");
-    Literal = imp("Literal@@rdfjs/types");
+    Literal = imp("t:Literal@@rdfjs/types");
+    LiteralDecoder = imp("LiteralDecoder@@rdfx/literal");
     LiteralFactory = imp("LiteralFactory@@rdfx/literal");
+    Logger = imp("t:Logger@@rdfx/logger");
     Maybe = imp("Maybe@purify-ts");
-    NamedNode = imp("NamedNode@@rdfjs/types");
+    NamedNode = imp("t:NamedNode@@rdfjs/types");
     NonEmptyList = imp("NonEmptyList@purify-ts");
+    nopLogger = imp("nopLogger@@rdfx/logger");
     NTriplesIdentifier = imp("NTriplesIdentifier@@rdfx/string");
     NTriplesTerm = imp("NTriplesTerm@@rdfx/string");
-    Quad = imp("Quad@@rdfjs/types");
-    Quad_Graph = imp("Quad_Graph@@rdfjs/types");
+    Quad = imp("t:Quad@@rdfjs/types");
+    Quad_Graph = imp("t:Quad_Graph@@rdfjs/types");
     RdfxResourcePropertyPath = imp("PropertyPath:RdfxResourcePropertyPath@@rdfx/resource");
     Resource = imp("Resource@@rdfx/resource");
     ResourceSet = imp("ResourceSet@@rdfx/resource");
     Right = imp("Right@purify-ts");
     sparqljs = imp("sparqljs*sparqljs");
-    Variable = imp("Variable@@rdfjs/types");
+    Variable = imp("t:Variable@@rdfjs/types");
     z = imp("z@zod");
+    ZodType = imp("t:ZodType@zod");
 }
 //# sourceMappingURL=Imports.js.map

package/dist/generators/ts/InlineCallable.d.ts

@@ -0,0 +1,18 @@
+import { AbstractCallable } from "./AbstractCallable.js";
+import { CodeThunk } from "./CodeThunk.js";
+import { type Code } from "./ts-poet-wrapper.js";
+/**
+ * A callable that isn't bound to a variable but always used inline. Annotated and unannotated usage differ in the inclusion of
+ * an optional "satisfies" type annotation on the unannotated expression.
+ */
+export declare class InlineCallable extends AbstractCallable {
+    #private;
+    constructor(unannotatedExpression: CodeThunk, options?: {
+        type?: CodeThunk;
+    });
+    get annotatedUsage(): Code;
+    private get type();
+    get unannotatedUsage(): Code;
+    private get unannotatedExpression();
+}
+//# sourceMappingURL=InlineCallable.d.ts.map

package/dist/generators/ts/InlineCallable.js

@@ -0,0 +1,51 @@
+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 { AbstractCallable } from "./AbstractCallable.js";
+import { CodeThunk } from "./CodeThunk.js";
+import { code } from "./ts-poet-wrapper.js";
+/**
+ * A callable that isn't bound to a variable but always used inline. Annotated and unannotated usage differ in the inclusion of
+ * an optional "satisfies" type annotation on the unannotated expression.
+ */
+export class InlineCallable extends AbstractCallable {
+    #unannotatedExpression;
+    #type;
+    constructor(unannotatedExpression, options) {
+        super();
+        this.#unannotatedExpression = unannotatedExpression;
+        this.#type = Maybe.fromNullable(options?.type);
+    }
+    get annotatedUsage() {
+        return this.type
+            .map((type) => code `((${this.unannotatedExpression}) satisfies ${type})`)
+            .orDefault(this.unannotatedUsage);
+    }
+    get type() {
+        return this.#type.map(CodeThunk.evaluate);
+    }
+    get unannotatedUsage() {
+        return code `(${this.unannotatedExpression})`;
+    }
+    get unannotatedExpression() {
+        return CodeThunk.evaluate(this.#unannotatedExpression);
+    }
+}
+__decorate([
+    Memoize()
+], InlineCallable.prototype, "annotatedUsage", null);
+__decorate([
+    Memoize()
+], InlineCallable.prototype, "type", null);
+__decorate([
+    Memoize()
+], InlineCallable.prototype, "unannotatedUsage", null);
+__decorate([
+    Memoize()
+], InlineCallable.prototype, "unannotatedExpression", null);
+//# sourceMappingURL=InlineCallable.js.map

package/dist/generators/ts/IntType.d.ts

@@ -1,14 +1,19 @@
 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 IntType extends AbstractNumericType<number> {
+    protected readonly decodedIn: number[];
     readonly conversionFunction: Maybe<AbstractNumericType.ConversionFunction>;
     readonly jsTypes: readonly [{
         readonly typeof: "number";
     }];
+    readonly jsonValueType: AbstractNumericType.JsonType;
     readonly kind = "Int";
-    get fromRdfResourceValuesFunction(): Code;
+    get fromJsonObjectFunction(): Callable;
+    get fromJsonValueFunction(): Callable;
+    get fromRdfResourceValuesFunction(): Callable;
     get graphqlType(): import("./_AbstractType/AbstractType_GraphqlType.js").AbstractType_GraphqlType;
     valueExpression(literal: Literal | number): Code;
 }

package/dist/generators/ts/IntType.js

@@ -8,13 +8,22 @@ import { LiteralDecoder } from "@rdfx/literal";
 import { Maybe } from "purify-ts";
 import { Memoize } from "typescript-memoize";
 import { AbstractNumericType } from "./AbstractNumericType.js";
+import { ReferenceCallable } from "./ReferenceCallable.js";
 import { code } from "./ts-poet-wrapper.js";
 export class IntType extends AbstractNumericType {
+    decodedIn = this.in_.map((in_) => LiteralDecoder.decodeFloatLiteral(in_).unsafeCoerce());
     conversionFunction = Maybe.empty();
     jsTypes = [{ typeof: "number" }];
+    jsonValueType = this.jsonTypeFactory.createJsonNumberType({ in_: this.decodedIn });
     kind = "Int";
+    get fromJsonObjectFunction() {
+        return new ReferenceCallable(code `${this.reusables.snippets.intFromJsonObject}<${this.expression}>`);
+    }
+    get fromJsonValueFunction() {
+        return new ReferenceCallable(code `${this.reusables.snippets.intFromJsonNumber}<${this.expression}>`);
+    }
     get fromRdfResourceValuesFunction() {
-        return code `${this.reusables.snippets.intFromRdfResourceValues}<${this.expression}>`;
+        return new ReferenceCallable(code `${this.reusables.snippets.intFromRdfResourceValues}<${this.expression}>`);
     }
     get graphqlType() {
         return new AbstractNumericType.GraphqlType(code `${this.reusables.imports.GraphQLInt}`, this.reusables);
@@ -23,6 +32,12 @@ export class IntType extends AbstractNumericType {
         return code `${typeof literal === "number" ? literal : LiteralDecoder.decodeIntLiteral(literal).unsafeCoerce()}`;
     }
 }
+__decorate([
+    Memoize()
+], IntType.prototype, "fromJsonObjectFunction", null);
+__decorate([
+    Memoize()
+], IntType.prototype, "fromJsonValueFunction", null);
 __decorate([
     Memoize()
 ], IntType.prototype, "fromRdfResourceValuesFunction", null);

package/dist/generators/ts/IriType.d.ts

@@ -1,25 +1,29 @@
 import type { NamedNode } from "@rdfjs/types";
 import { Maybe } from "purify-ts";
 import { AbstractIdentifierType } from "./AbstractIdentifierType.js";
+import type { Callable } from "./Callable.js";
+import { ReferenceCallable } from "./ReferenceCallable.js";
 import { type Code } from "./ts-poet-wrapper.js";
 export declare class IriType extends AbstractIdentifierType<NamedNode> {
-    readonly filterFunction: Code;
+    readonly filterFunction: ReferenceCallable;
     readonly filterType: Code;
     readonly kind = "Iri";
     readonly nodeKinds: ReadonlySet<"IRI">;
     readonly schemaType: Code;
-    readonly valueSparqlWherePatternsFunction: Code;
+    readonly valueSparqlWherePatternsFunction: ReferenceCallable;
+    get fromJsonValueFunction(): AbstractIdentifierType<NamedNode>["fromJsonValueFunction"];
+    get fromJsonObjectFunction(): AbstractIdentifierType<NamedNode>["fromJsonObjectFunction"];
+    get toJsonValueFunction(): AbstractIdentifierType<NamedNode>["toJsonValueFunction"];
+    get toJsonObjectFunction(): AbstractIdentifierType<NamedNode>["toJsonObjectFunction"];
+    get jsonValueType(): AbstractIdentifierType<NamedNode>["jsonValueType"];
+    get jsonObjectType(): AbstractIdentifierType<NamedNode>["jsonObjectType"];
     get conversionFunction(): Maybe<AbstractIdentifierType.ConversionFunction>;
-    get fromRdfResourceValuesFunction(): Code;
-    get parseFunction(): Code;
+    get fromRdfResourceValuesFunction(): Callable;
+    get parseFunction(): Callable;
     protected get inlineExpression(): Code;
     protected staticModuleDeclarations(name: string): Record<string, Code>;
     protected get schemaInitializers(): readonly Code[];
     protected get inlineValueTypeExpression(): Code;
     private get valueTypeExpression();
-    fromJsonExpression({ variables, }: Parameters<AbstractIdentifierType<NamedNode>["fromJsonExpression"]>[0]): Code;
-    jsonSchema({ includeDiscriminantProperty, }: Parameters<AbstractIdentifierType<NamedNode>["jsonSchema"]>[0]): Code;
-    jsonType(parameters?: Parameters<AbstractIdentifierType<NamedNode>["jsonType"]>[0]): AbstractIdentifierType.JsonType;
-    toJsonExpression({ includeDiscriminantProperty, variables, }: Parameters<AbstractIdentifierType<NamedNode>["toJsonExpression"]>[0]): Code;
 }
 //# sourceMappingURL=IriType.d.ts.map