@shaclmate/compiler 4.0.33 → 4.0.34

package/dist/generators/ts/IdentifierType.js

@@ -7,9 +7,29 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 import { NodeKind } from "@shaclmate/shacl-ast";
 import { Memoize } from "typescript-memoize";
 import { AbstractIdentifierType } from "./AbstractIdentifierType.js";
-import { AbstractTermType } from "./AbstractTermType.js";
 import { arrayOf, code } from "./ts-poet-wrapper.js";
 export class IdentifierType extends AbstractIdentifierType {
+    conversionFunction = {
+        code: code `${this.reusables.snippets.convertToIdentifier}`,
+        sourceTypes: [
+            {
+                name: code `${this.reusables.imports.BlankNode}`,
+                typeof: "object",
+            },
+            {
+                name: code `${this.reusables.imports.NamedNode}`,
+                typeof: "object",
+            },
+            {
+                name: "string",
+                typeof: "string",
+            },
+            {
+                name: "undefined",
+                typeof: "undefined",
+            },
+        ],
+    };
     filterFunction = code `${this.reusables.snippets.filterIdentifier}`;
     filterType = code `${this.reusables.snippets.IdentifierFilter}`;
     parseFunction = code `${this.reusables.snippets.parseIdentifier};`;
@@ -32,7 +52,7 @@ export class IdentifierType extends AbstractIdentifierType {
         const discriminantProperty = parameters?.includeDiscriminantProperty
             ? `, readonly termType: "BlankNode" | "NamedNode"`
             : "";
-        return new AbstractTermType.JsonType(code `{ readonly "@id": string${discriminantProperty} }`);
+        return new AbstractIdentifierType.JsonType(code `{ readonly "@id": string${discriminantProperty} }`);
     }
     jsonSchema({ includeDiscriminantProperty, }) {
         const discriminantProperty = includeDiscriminantProperty

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

@@ -1,11 +1,11 @@
-import { NonEmptyList } from "purify-ts";
+import type { Literal } from "@rdfjs/types";
 import { AbstractNumericType } from "./AbstractNumericType.js";
 import { type Code } from "./ts-poet-wrapper.js";
 export declare class IntType extends AbstractNumericType<number> {
     readonly kind = "IntType";
-    readonly typeofs: NonEmptyList<"number">;
+    readonly typeofs: "number"[];
     get graphqlType(): import("./AbstractType.js").AbstractType.GraphqlType;
+    literalExpression(literal: Literal | number): Code;
     protected fromRdfResourceValueExpression({ variables, }: Parameters<AbstractNumericType<number>["fromRdfResourceValueExpression"]>[0]): Code;
-    protected literalOf(value: number): string;
 }
 //# sourceMappingURL=IntType.d.ts.map

package/dist/generators/ts/IntType.js

@@ -4,22 +4,22 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
-import { NonEmptyList } from "purify-ts";
+import { LiteralDecoder } from "@rdfx/literal";
 import { Memoize } from "typescript-memoize";
 import { AbstractNumericType } from "./AbstractNumericType.js";
 import { code } from "./ts-poet-wrapper.js";
 export class IntType extends AbstractNumericType {
     kind = "IntType";
-    typeofs = NonEmptyList(["number"]);
+    typeofs = ["number"];
     get graphqlType() {
         return new AbstractNumericType.GraphqlType(code `${this.reusables.imports.GraphQLInt}`, this.reusables);
     }
+    literalExpression(literal) {
+        return code `${typeof literal === "number" ? literal : LiteralDecoder.decodeIntLiteral(literal).unsafeCoerce()}`;
+    }
     fromRdfResourceValueExpression({ variables, }) {
         return code `${variables.value}.toInt(${this.primitiveIn.length > 0 ? `${JSON.stringify(this.primitiveIn)} as const` : ""})`;
     }
-    literalOf(value) {
-        return value.toString();
-    }
 }
 __decorate([
     Memoize()

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

@@ -1,6 +1,5 @@
-import type { BlankNode, NamedNode } from "@rdfjs/types";
+import type { NamedNode } from "@rdfjs/types";
 import { AbstractIdentifierType } from "./AbstractIdentifierType.js";
-import { AbstractTermType } from "./AbstractTermType.js";
 import { type Code } from "./ts-poet-wrapper.js";
 export declare class IriType extends AbstractIdentifierType<NamedNode> {
     readonly filterFunction: Code;
@@ -9,16 +8,22 @@ export declare class IriType extends AbstractIdentifierType<NamedNode> {
     readonly nodeKinds: ReadonlySet<"IRI">;
     readonly schemaType: Code;
     readonly valueSparqlWherePatternsFunction: Code;
-    get parseFunction(): Code;
-    get name(): Code;
-    protected get schemaObject(): {
-        in: Code[] | undefined;
-        kind: Code;
+    get conversionFunction(): {
+        code: Code;
+        sourceTypes: ({
+            name: Code;
+            typeof: "string";
+        } | {
+            name: Code;
+            typeof: "object";
+        })[];
     };
-    fromJsonExpression({ variables, }: Parameters<AbstractTermType<NamedNode, BlankNode | NamedNode>["fromJsonExpression"]>[0]): Code;
-    jsonType(parameters?: Parameters<AbstractTermType["jsonType"]>[0]): AbstractTermType.JsonType;
-    jsonSchema({ includeDiscriminantProperty, }: Parameters<AbstractTermType<NamedNode, BlankNode | NamedNode>["jsonSchema"]>[0]): Code;
-    toJsonExpression({ includeDiscriminantProperty, variables, }: Parameters<AbstractTermType<NamedNode, BlankNode | NamedNode>["toJsonExpression"]>[0]): Code;
-    protected fromRdfExpressionChain({ variables, }: Parameters<AbstractTermType["fromRdfExpressionChain"]>[0]): ReturnType<AbstractTermType["fromRdfExpressionChain"]>;
+    get name(): Code;
+    get parseFunction(): Code;
+    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;
+    protected fromRdfExpressionChain({ variables, }: Parameters<AbstractIdentifierType<NamedNode>["fromRdfExpressionChain"]>[0]): ReturnType<AbstractIdentifierType<NamedNode>["fromRdfExpressionChain"]>;
 }
 //# sourceMappingURL=IriType.d.ts.map

package/dist/generators/ts/IriType.js

@@ -6,8 +6,7 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 };
 import { Memoize } from "typescript-memoize";
 import { AbstractIdentifierType } from "./AbstractIdentifierType.js";
-import { AbstractTermType } from "./AbstractTermType.js";
-import { arrayOf, code, joinCode } from "./ts-poet-wrapper.js";
+import { arrayOf, code, joinCode, literalOf, } from "./ts-poet-wrapper.js";
 export class IriType extends AbstractIdentifierType {
     filterFunction = code `${this.reusables.snippets.filterIri}`;
     filterType = code `${this.reusables.snippets.IriFilter}`;
@@ -15,44 +14,41 @@ export class IriType extends AbstractIdentifierType {
     nodeKinds = nodeKinds;
     schemaType = code `${this.reusables.snippets.IriSchema}`;
     valueSparqlWherePatternsFunction = code `${this.reusables.snippets.iriSparqlWherePatterns}`;
-    get parseFunction() {
-        if (this.in_.length > 0) {
-            return code `(identifier: string) => ${this.reusables.snippets.parseIri}(identifier).chain((identifier) => { switch (identifier.value) { ${joinCode(this.in_.map((iri) => code `case "${iri.value}": return ${this.reusables.imports.Right}(identifier as ${this.name});`))} default: return ${this.reusables.imports.Left}(new Error("expected NamedNode identifier to be one of ${this.in_.map((iri) => iri.value).join(" ")}")); } })`;
-        }
-        return code `${this.reusables.snippets.parseIri}`;
+    get conversionFunction() {
+        const IriT = this.in_.length > 0
+            ? code `${joinCode(this.in_.map((iri) => code `${literalOf(iri.value)}`), { on: "| " })}`
+            : code `string`;
+        return {
+            code: code `${this.reusables.snippets.convertToIri}<${IriT}>`,
+            sourceTypes: [
+                {
+                    name: IriT,
+                    typeof: "string",
+                },
+                {
+                    name: this.name,
+                    typeof: "object",
+                },
+            ],
+        };
     }
     get name() {
         if (this.in_.length > 0) {
             // Treat sh:in as a union of the IRIs
             // rdfjs.NamedNode<"http://example.com/1" | "http://example.com/2">
-            return code `${this.reusables.imports.NamedNode}<${this.in_
-                .map((iri) => `"${iri.value}"`)
-                .join(" | ")}>`;
+            return code `${this.reusables.imports.NamedNode}<${joinCode(this.in_.map((iri) => code `${literalOf(iri.value)}`), { on: "| " })}>`;
         }
         return code `${this.reusables.imports.NamedNode}`;
     }
-    get schemaObject() {
-        return {
-            ...super.schemaObject,
-            in: this.in_.length > 0
-                ? this.in_.map((in_) => this.rdfjsTermExpression(in_)).concat()
-                : undefined,
-        };
+    get parseFunction() {
+        if (this.in_.length > 0) {
+            return code `(identifier: string) => ${this.reusables.snippets.parseIri}(identifier).chain((identifier) => { switch (identifier.value) { ${joinCode(this.in_.map((iri) => code `case "${iri.value}": return ${this.reusables.imports.Right}(identifier as ${this.name});`))} default: return ${this.reusables.imports.Left}(new Error("expected NamedNode identifier to be one of ${this.in_.map((iri) => iri.value).join(" ")}")); } })`;
+        }
+        return code `${this.reusables.snippets.parseIri}`;
     }
     fromJsonExpression({ variables, }) {
         return code `${this.reusables.imports.dataFactory}.namedNode(${variables.value}["@id"])`;
     }
-    jsonType(parameters) {
-        const discriminantProperty = parameters?.includeDiscriminantProperty
-            ? `, readonly termType: "NamedNode"`
-            : "";
-        if (this.in_.length > 0) {
-            // Treat sh:in as a union of the IRIs
-            // rdfjs.NamedNode<"http://example.com/1" | "http://example.com/2">
-            return new AbstractTermType.JsonType(code `{ readonly "@id": ${this.in_.map((iri) => `"${iri.value}"`).join(" | ")}${discriminantProperty} }`);
-        }
-        return new AbstractTermType.JsonType(code `{ readonly "@id": string${discriminantProperty} }`);
-    }
     jsonSchema({ includeDiscriminantProperty, }) {
         let idSchema;
         if (this.in_.length > 0) {
@@ -68,6 +64,17 @@ export class IriType extends AbstractIdentifierType {
             : "";
         return code `${this.reusables.imports.z}.object({ "@id": ${idSchema}${discriminantProperty} })`;
     }
+    jsonType(parameters) {
+        const discriminantProperty = parameters?.includeDiscriminantProperty
+            ? `, readonly termType: "NamedNode"`
+            : "";
+        if (this.in_.length > 0) {
+            // Treat sh:in as a union of the IRIs
+            // rdfjs.NamedNode<"http://example.com/1" | "http://example.com/2">
+            return new AbstractIdentifierType.JsonType(code `{ readonly "@id": ${this.in_.map((iri) => `"${iri.value}"`).join(" | ")}${discriminantProperty} }`);
+        }
+        return new AbstractIdentifierType.JsonType(code `{ readonly "@id": string${discriminantProperty} }`);
+    }
     toJsonExpression({ includeDiscriminantProperty, variables, }) {
         const discriminantProperty = includeDiscriminantProperty
             ? code `, termType: ${variables.value}.termType`
@@ -85,10 +92,13 @@ export class IriType extends AbstractIdentifierType {
 }
 __decorate([
     Memoize()
-], IriType.prototype, "parseFunction", null);
+], IriType.prototype, "conversionFunction", null);
 __decorate([
     Memoize()
 ], IriType.prototype, "name", null);
+__decorate([
+    Memoize()
+], IriType.prototype, "parseFunction", null);
 __decorate([
     Memoize()
 ], IriType.prototype, "jsonType", null);

package/dist/generators/ts/LazyObjectOptionType.d.ts

@@ -8,6 +8,7 @@ declare const Super: (abstract new ({ partialType, resolveType, ...superParamete
     resolveType: OptionType<AbstractLazyObjectType.ObjectTypeConstraint>;
 } & {
     comment: Maybe<string>;
+    configuration: import("./TsGenerator.js").TsGenerator.Configuration;
     label: Maybe<string>;
     logger: import("ts-log").Logger;
     reusables: import("./Reusables.js").Reusables;
@@ -18,7 +19,7 @@ declare const Super: (abstract new ({ partialType, resolveType, ...superParamete
 export declare class LazyObjectOptionType extends Super {
     readonly graphqlArgs: Super["graphqlArgs"];
     readonly kind = "LazyObjectOptionType";
-    get conversions(): readonly AbstractLazyObjectType.Conversion[];
+    get conversionFunction(): AbstractLazyObjectType.ConversionFunction;
     protected get runtimeClass(): {
         name: Code;
         partialPropertyName: string;

package/dist/generators/ts/LazyObjectOptionType.js

@@ -12,49 +12,28 @@ const Super = (AbstractLazyObjectType);
 export class LazyObjectOptionType extends Super {
     graphqlArgs = Maybe.empty();
     kind = "LazyObjectOptionType";
-    get conversions() {
-        const conversions = super.conversions.concat();
-        if (this.partialType.itemType.kind === "NamedObjectType") {
-            conversions.push({
-                conversionExpression: (value) => code `new ${this.runtimeClass.name}({ ${this.runtimeClass.partialPropertyName}: ${value}.map(${this.partialType.itemType.name}.create), resolver: async () => ${this.reusables.imports.Right}((${value} as ${this.reusables.imports.Maybe}<${this.resolveType.itemType.name}>).unsafeCoerce()) })`,
-                sourceTypeCheckExpression: (value) => code `${this.reusables.imports.Maybe}.isMaybe(${value})`,
-                sourceTypeName: code `${this.reusables.imports.Maybe}<${this.resolveType.itemType.name}>`,
-                sourceTypeof: "object",
-            }, {
-                conversionExpression: (value) => code `new ${this.runtimeClass.name}({ ${this.runtimeClass.partialPropertyName}: ${this.reusables.imports.Maybe}.of(${this.partialType.itemType.name}.create(${value})), resolver: async () => ${this.reusables.imports.Right}(${value} as ${this.resolveType.itemType.name}) })`,
-                // Don't check instanceof value since the NamedObjectUnionType may be an interface
-                // Rely on the fact that this will be the last type check on an object
-                sourceTypeCheckExpression: (value) => code `typeof ${value} === "object"`,
-                sourceTypeName: this.resolveType.itemType.name,
-                sourceTypeof: "object",
-            });
-        }
-        else if (this.resolveType.itemType.kind === "NamedObjectUnionType" &&
-            this.partialType.itemType.kind === "NamedObjectUnionType" &&
-            this.resolveType.itemType.members.length ===
-                this.partialType.itemType.members.length) {
-            const maybeMap = code `.map(object => { ${this.resolvedNamedObjectUnionTypeToPartialNamedObjectUnionTypeConversion({ resolvedNamedObjectUnionType: this.resolveType.itemType, partialNamedObjectUnionType: this.partialType.itemType, variables: { resolvedObjectUnion: code `object` } })} })`;
-            conversions.push({
-                conversionExpression: (value) => code `new ${this.runtimeClass.name}({ ${this.runtimeClass.partialPropertyName}: ${value}${maybeMap}, resolver: async () => ${this.reusables.imports.Right}((${value} as ${this.reusables.imports.Maybe}<${this.resolveType.itemType.name}>).unsafeCoerce()) })`,
-                sourceTypeCheckExpression: (value) => code `${this.reusables.imports.Maybe}.isMaybe(${value})`,
-                sourceTypeName: code `${this.reusables.imports.Maybe}<${this.resolveType.itemType.name}>`,
-                sourceTypeof: "object",
-            }, {
-                conversionExpression: (value) => code `new ${this.runtimeClass.name}({ ${this.runtimeClass.partialPropertyName}: ${this.reusables.imports.Maybe}.of(${value})${maybeMap}, resolver: async () => ${this.reusables.imports.Right}(${value} as ${this.resolveType.itemType.name}) })`,
-                // Don't check instanceof value since the NamedObjectUnionType may be an interface
-                // Rely on the fact that this will be the last type check on an object
-                sourceTypeCheckExpression: (value) => code `typeof ${value} === "object"`,
-                sourceTypeName: this.resolveType.itemType.name,
-                sourceTypeof: "object",
-            });
-        }
-        conversions.push({
-            conversionExpression: () => code `new ${this.runtimeClass.name}({ ${this.runtimeClass.partialPropertyName}: ${this.reusables.imports.Maybe}.empty(), resolver: async () => { throw new Error("should never be called"); } })`,
-            sourceTypeCheckExpression: (value) => code `${value} === undefined`,
-            sourceTypeName: code `undefined`,
-            sourceTypeof: "undefined",
-        });
-        return conversions;
+    get conversionFunction() {
+        return {
+            code: code `${this.reusables.snippets.convertToLazyObjectOption}<${this.resolveType.itemType.identifierTypeAlias}, ${this.partialType.itemType.name}, ${this.resolveType.itemType.name}>(${this.resolveToPartialFunction({ partialType: this.partialType.itemType, resolveType: this.resolveType.itemType })})`,
+            sourceTypes: [
+                {
+                    name: this.name,
+                    typeof: "object",
+                },
+                {
+                    name: this.resolveType.name,
+                    typeof: "object",
+                },
+                {
+                    name: this.resolveType.itemType.name,
+                    typeof: "object",
+                },
+                {
+                    name: "undefined",
+                    typeof: "undefined",
+                },
+            ],
+        };
     }
     get runtimeClass() {
         return {
@@ -76,7 +55,7 @@ export class LazyObjectOptionType extends Super {
 }
 __decorate([
     Memoize()
-], LazyObjectOptionType.prototype, "conversions", null);
+], LazyObjectOptionType.prototype, "conversionFunction", null);
 __decorate([
     Memoize()
 ], LazyObjectOptionType.prototype, "runtimeClass", null);

package/dist/generators/ts/LazyObjectSetType.d.ts

@@ -4,7 +4,7 @@ import { type Code } from "./ts-poet-wrapper.js";
 export declare class LazyObjectSetType extends AbstractLazyObjectType<SetType<AbstractLazyObjectType.ObjectTypeConstraint>, SetType<AbstractLazyObjectType.ObjectTypeConstraint>> {
     readonly graphqlArgs: Super["graphqlArgs"];
     readonly kind = "LazyObjectSetType";
-    get conversions(): readonly AbstractLazyObjectType.Conversion[];
+    get conversionFunction(): AbstractLazyObjectType.ConversionFunction;
     protected get runtimeClass(): {
         name: Code;
         partialPropertyName: string;

package/dist/generators/ts/LazyObjectSetType.js

@@ -18,34 +18,24 @@ export class LazyObjectSetType extends AbstractLazyObjectType {
         },
     });
     kind = "LazyObjectSetType";
-    get conversions() {
-        const conversions = super.conversions.concat();
-        if (this.partialType.itemType.kind === "NamedObjectType") {
-            conversions.push({
-                conversionExpression: (value) => code `new ${this.runtimeClass.name}({ ${this.runtimeClass.partialPropertyName}: ${value}.map(${this.partialType.itemType.name}.create), resolver: async () => ${this.reusables.imports.Right}(${value} as readonly ${this.resolveType.itemType.name}[]) })`,
-                sourceTypeCheckExpression: (value) => code `typeof ${value} === "object"`,
-                sourceTypeName: code `readonly ${this.resolveType.itemType.name}[]`,
-                sourceTypeof: "object",
-            });
-        }
-        else if (this.resolveType.itemType.kind === "NamedObjectUnionType" &&
-            this.partialType.itemType.kind === "NamedObjectUnionType" &&
-            this.resolveType.itemType.members.length ===
-                this.partialType.itemType.members.length) {
-            conversions.push({
-                conversionExpression: (value) => code `new ${this.runtimeClass.name}({ ${this.runtimeClass.partialPropertyName}: ${value}.map(object => { ${this.resolvedNamedObjectUnionTypeToPartialNamedObjectUnionTypeConversion({ resolvedNamedObjectUnionType: this.resolveType.itemType, partialNamedObjectUnionType: this.partialType.itemType, variables: { resolvedObjectUnion: code `object` } })} }), resolver: async () => ${this.reusables.imports.Right}(${value} as readonly ${this.resolveType.itemType.name}[]) })`,
-                sourceTypeCheckExpression: (value) => code `typeof ${value} === "object"`,
-                sourceTypeName: code `readonly ${this.resolveType.itemType.name}[]`,
-                sourceTypeof: "object",
-            });
-        }
-        conversions.push({
-            conversionExpression: () => code `new ${this.runtimeClass.name}({ ${this.runtimeClass.partialPropertyName}: [], resolver: async () => { throw new Error("should never be called"); } })`,
-            sourceTypeCheckExpression: (value) => code `${value} === undefined`,
-            sourceTypeName: code `undefined`,
-            sourceTypeof: "undefined",
-        });
-        return conversions;
+    get conversionFunction() {
+        return {
+            code: code `${this.reusables.snippets.convertToLazyObjectSet}<${this.resolveType.itemType.identifierTypeAlias}, ${this.partialType.itemType.name}, ${this.resolveType.itemType.name}>(${this.resolveToPartialFunction({ partialType: this.partialType.itemType, resolveType: this.resolveType.itemType })})`,
+            sourceTypes: [
+                {
+                    name: this.name,
+                    typeof: "object",
+                },
+                {
+                    name: this.resolveType.name,
+                    typeof: "object",
+                },
+                {
+                    name: "undefined",
+                    typeof: "undefined",
+                },
+            ],
+        };
     }
     get runtimeClass() {
         return {
@@ -67,5 +57,5 @@ export class LazyObjectSetType extends AbstractLazyObjectType {
 }
 __decorate([
     Memoize()
-], LazyObjectSetType.prototype, "conversions", null);
+], LazyObjectSetType.prototype, "conversionFunction", null);
 //# sourceMappingURL=LazyObjectSetType.js.map

package/dist/generators/ts/LazyObjectType.d.ts

@@ -3,7 +3,7 @@ import { type Code } from "./ts-poet-wrapper.js";
 export declare class LazyObjectType extends AbstractLazyObjectType<AbstractLazyObjectType.ObjectTypeConstraint, AbstractLazyObjectType.ObjectTypeConstraint> {
     readonly graphqlArgs: Super["graphqlArgs"];
     readonly kind = "LazyObjectType";
-    get conversions(): readonly AbstractLazyObjectType.Conversion[];
+    get conversionFunction(): AbstractLazyObjectType.ConversionFunction;
     protected get runtimeClass(): {
         name: Code;
         partialPropertyName: string;

package/dist/generators/ts/LazyObjectType.js

@@ -11,31 +11,20 @@ import { code } from "./ts-poet-wrapper.js";
 export class LazyObjectType extends AbstractLazyObjectType {
     graphqlArgs = Maybe.empty();
     kind = "LazyObjectType";
-    get conversions() {
-        const conversions = super.conversions.concat();
-        if (this.partialType.kind === "NamedObjectType") {
-            conversions.push({
-                conversionExpression: (value) => code `new ${this.runtimeClass.name}({ ${this.runtimeClass.partialPropertyName}: ${this.partialType.name}.create(${value}), resolver: async () => ${this.reusables.imports.Right}(${value} as ${this.resolveType.name}) })`,
-                // Don't check instanceof value since the NamedObjectType may be an interface
-                // Rely on the fact that this will be the last type check on an object
-                sourceTypeCheckExpression: (value) => code `typeof ${value} === "object"`,
-                sourceTypeName: this.resolveType.name,
-                sourceTypeof: "object",
-            });
-        }
-        else if (this.resolveType.kind === "NamedObjectUnionType" &&
-            this.partialType.kind === "NamedObjectUnionType" &&
-            this.resolveType.members.length === this.partialType.members.length) {
-            conversions.push({
-                conversionExpression: (value) => code `new ${this.runtimeClass.name}({ ${this.runtimeClass.partialPropertyName}: ((object: ${this.resolveType.name}) => { ${this.resolvedNamedObjectUnionTypeToPartialNamedObjectUnionTypeConversion({ resolvedNamedObjectUnionType: this.resolveType, partialNamedObjectUnionType: this.partialType, variables: { resolvedObjectUnion: code `object` } })} })(${value}), resolver: async () => ${this.reusables.imports.Right}(${value} as ${this.resolveType.name}) })`,
-                // Don't check instanceof value since the NamedObjectUnionType may be an interface
-                // Rely on the fact that this will be the last type check on an object
-                sourceTypeCheckExpression: (value) => code `typeof ${value} === "object"`,
-                sourceTypeName: this.resolveType.name,
-                sourceTypeof: "object",
-            });
-        }
-        return conversions;
+    get conversionFunction() {
+        return {
+            code: code `${this.reusables.snippets.convertToLazyObject}<${this.resolveType.identifierTypeAlias}, ${this.partialType.name}, ${this.resolveType.name}>(${this.resolveToPartialFunction({ partialType: this.partialType, resolveType: this.resolveType })})`,
+            sourceTypes: [
+                {
+                    name: this.name,
+                    typeof: "object",
+                },
+                {
+                    name: this.resolveType.name,
+                    typeof: "object",
+                },
+            ],
+        };
     }
     get runtimeClass() {
         return {
@@ -55,6 +44,9 @@ export class LazyObjectType extends AbstractLazyObjectType {
         return code `${variables.value}.resolve().then(either => either.unsafeCoerce())`;
     }
 }
+__decorate([
+    Memoize()
+], LazyObjectType.prototype, "conversionFunction", null);
 __decorate([
     Memoize()
 ], LazyObjectType.prototype, "runtimeClass", null);

package/dist/generators/ts/LiteralType.d.ts

@@ -1,18 +1,20 @@
+import type { Literal } from "@rdfjs/types";
 import { AbstractLiteralType } from "./AbstractLiteralType.js";
 import { type Code } from "./ts-poet-wrapper.js";
 export declare class LiteralType extends AbstractLiteralType {
+    readonly name: Code;
+    readonly conversionFunction: AbstractLiteralType.ConversionFunction;
     readonly filterFunction: Code;
     readonly filterType: Code;
     readonly kind = "LiteralType";
-    readonly name: Code;
     readonly schemaType: Code;
     readonly valueSparqlWherePatternsFunction: Code;
     get graphqlType(): AbstractLiteralType.GraphqlType;
     fromJsonExpression({ variables, }: Parameters<AbstractLiteralType["fromJsonExpression"]>[0]): Code;
     graphqlResolveExpression(_parameters: Parameters<AbstractLiteralType["graphqlResolveExpression"]>[0]): Code;
-    hashStatements({ depth, variables, }: Parameters<AbstractLiteralType["hashStatements"]>[0]): readonly Code[];
-    jsonType(parameters?: Parameters<AbstractLiteralType["jsonType"]>[0]): AbstractLiteralType.JsonType;
     jsonSchema({ includeDiscriminantProperty, }: Parameters<AbstractLiteralType["jsonSchema"]>[0]): Code;
+    jsonType(parameters?: Parameters<AbstractLiteralType["jsonType"]>[0]): AbstractLiteralType.JsonType;
+    literalExpression(literal: Literal): Code;
     toJsonExpression({ includeDiscriminantProperty, variables, }: Parameters<AbstractLiteralType["toJsonExpression"]>[0]): Code;
 }
 //# sourceMappingURL=LiteralType.d.ts.map

package/dist/generators/ts/LiteralType.js

@@ -2,10 +2,27 @@ import { xsd } from "@tpluscode/rdf-ns-builders";
 import { AbstractLiteralType } from "./AbstractLiteralType.js";
 import { code } from "./ts-poet-wrapper.js";
 export class LiteralType extends AbstractLiteralType {
+    name = code `${this.reusables.imports.Literal}`;
+    conversionFunction = {
+        code: code `${this.reusables.snippets.convertToLiteral}`,
+        sourceTypes: [
+            ...["bigint", "boolean", "number", "string"].map((typeof_) => ({
+                name: typeof_,
+                typeof: typeof_,
+            })),
+            {
+                name: "Date",
+                typeof: "object",
+            },
+            {
+                name: code `${this.reusables.imports.Literal}`,
+                typeof: "object",
+            },
+        ],
+    };
     filterFunction = code `${this.reusables.snippets.filterLiteral}`;
     filterType = code `${this.reusables.snippets.LiteralFilter}`;
     kind = "LiteralType";
-    name = code `${this.reusables.imports.Literal}`;
     schemaType = code `${this.reusables.snippets.LiteralSchema}`;
     valueSparqlWherePatternsFunction = code `${this.reusables.snippets.literalSparqlWherePatterns}`;
     get graphqlType() {
@@ -17,12 +34,11 @@ export class LiteralType extends AbstractLiteralType {
     graphqlResolveExpression(_parameters) {
         throw new Error("not implemented");
     }
-    hashStatements({ depth, variables, }) {
-        return [
-            ...super.hashStatements({ depth, variables }),
-            code `${variables.hasher}.update(${variables.value}.datatype.value);`,
-            code `${variables.hasher}.update(${variables.value}.language);`,
-        ];
+    jsonSchema({ includeDiscriminantProperty, }) {
+        const discriminantProperty = includeDiscriminantProperty
+            ? code `, termType: ${this.reusables.imports.z}.literal("Literal")`
+            : "";
+        return code `${this.reusables.imports.z}.object({ "@language": ${this.reusables.imports.z}.string().optional()${discriminantProperty}, "@type": ${this.reusables.imports.z}.string().optional(), "@value": ${this.reusables.imports.z}.string() })`;
     }
     jsonType(parameters) {
         const discriminantProperty = parameters?.includeDiscriminantProperty
@@ -30,11 +46,8 @@ export class LiteralType extends AbstractLiteralType {
             : "";
         return new AbstractLiteralType.JsonType(code `{ readonly "@language"?: string${discriminantProperty}, readonly "@type"?: string, readonly "@value": string }`);
     }
-    jsonSchema({ includeDiscriminantProperty, }) {
-        const discriminantProperty = includeDiscriminantProperty
-            ? code `, termType: ${this.reusables.imports.z}.literal("Literal")`
-            : "";
-        return code `${this.reusables.imports.z}.object({ "@language": ${this.reusables.imports.z}.string().optional()${discriminantProperty}, "@type": ${this.reusables.imports.z}.string().optional(), "@value": ${this.reusables.imports.z}.string() })`;
+    literalExpression(literal) {
+        return this.rdfjsTermExpression(literal);
     }
     toJsonExpression({ includeDiscriminantProperty, variables, }) {
         return code `{ "@language": ${variables.value}.language.length > 0 ? ${variables.value}.language : undefined${includeDiscriminantProperty ? `, "termType": "Literal" as const` : ""}, "@type": ${variables.value}.datatype.value !== "${xsd.string.value}" ? ${variables.value}.datatype.value : undefined, "@value": ${variables.value}.value }`;

package/dist/generators/ts/NamedObjectType.d.ts

@@ -1,5 +1,5 @@
 import type { NamedNode } from "@rdfjs/types";
-import { Maybe, NonEmptyList } from "purify-ts";
+import { Maybe } from "purify-ts";
 import { DiscriminantProperty as _DiscriminantProperty } from "./_NamedObjectType/DiscriminantProperty.js";
 import { IdentifierProperty as _IdentifierProperty } from "./_NamedObjectType/IdentifierProperty.js";
 import type { Property as _Property } from "./_NamedObjectType/Property.js";
@@ -8,13 +8,11 @@ import { AbstractType } from "./AbstractType.js";
 import type { BlankNodeType } from "./BlankNodeType.js";
 import type { IdentifierType } from "./IdentifierType.js";
 import type { IriType } from "./IriType.js";
-import type { TsFeature } from "./TsFeature.js";
 import type { Type } from "./Type.js";
 import { type Code } from "./ts-poet-wrapper.js";
 export declare class NamedObjectType extends AbstractType {
     protected readonly toRdfTypes: readonly NamedNode[];
     readonly extern: boolean;
-    readonly features: ReadonlySet<TsFeature>;
     readonly fromRdfType: Maybe<NamedNode>;
     readonly graphqlArgs: AbstractType["graphqlArgs"];
     readonly identifierType: BlankNodeType | IdentifierType | IriType;
@@ -22,11 +20,10 @@ export declare class NamedObjectType extends AbstractType {
     readonly name: string;
     readonly recursive: boolean;
     readonly synthetic: boolean;
-    readonly typeofs: NonEmptyList<"object">;
-    constructor({ extern, features, fromRdfType, identifierType, lazyAncestorObjectTypes, lazyChildObjectTypes, lazyDescendantObjectTypes, lazyDiscriminantProperty, lazyParentObjectTypes, lazyProperties, name, recursive, synthetic, toRdfTypes, ...superParameters }: {
+    readonly typeofs: "object"[];
+    constructor({ extern, fromRdfType, identifierType, lazyAncestorObjectTypes, lazyChildObjectTypes, lazyDescendantObjectTypes, lazyDiscriminantProperty, lazyParentObjectTypes, lazyProperties, name, recursive, synthetic, toRdfTypes, ...superParameters }: {
         comment: Maybe<string>;
         extern: boolean;
-        features: ReadonlySet<TsFeature>;
         fromRdfType: Maybe<NamedNode>;
         identifierType: BlankNodeType | IdentifierType | IriType;
         label: Maybe<string>;
@@ -44,7 +41,7 @@ export declare class NamedObjectType extends AbstractType {
     get _discriminantProperty(): NamedObjectType.DiscriminantProperty;
     get ancestorObjectTypes(): readonly NamedObjectType[];
     get childObjectTypes(): readonly NamedObjectType[];
-    get conversions(): readonly AbstractType.Conversion[];
+    get conversionFunction(): AbstractType.ConversionFunction;
     get declaration(): Maybe<Code>;
     get descendantFromRdfTypeVariables(): readonly Code[];
     get descendantFromRdfTypes(): readonly NamedNode[];
@@ -56,6 +53,7 @@ export declare class NamedObjectType extends AbstractType {
     get filterType(): Code;
     get fromRdfTypeVariable(): Maybe<Code>;
     get graphqlType(): AbstractType.GraphqlType;
+    get hashFunction(): Code;
     get identifierTypeAlias(): Code;
     get mutable(): boolean;
     get objectSetMethodNames(): NamedObjectType.ObjectSetMethodNames;
@@ -75,13 +73,12 @@ export declare class NamedObjectType extends AbstractType {
             value: Code;
         };
     }): Code;
-    hashStatements({ variables, }: Parameters<AbstractType["hashStatements"]>[0]): readonly Code[];
     jsonSchema({ context, }: Parameters<AbstractType["jsonSchema"]>[0]): Code;
     jsonType(): AbstractType.JsonType;
     jsonUiSchemaElement({ variables, }: Parameters<AbstractType["jsonUiSchemaElement"]>[0]): Maybe<Code>;
     toJsonExpression({ variables, }: Parameters<AbstractType["toJsonExpression"]>[0]): Code;
-    toStringExpression({ variables, }: Parameters<AbstractType["toStringExpression"]>[0]): Code;
     toRdfResourceValuesExpression({ variables, }: Parameters<AbstractType["toRdfResourceValuesExpression"]>[0]): Code;
+    toStringExpression({ variables, }: Parameters<AbstractType["toStringExpression"]>[0]): Code;
     private readonly lazyAncestorObjectTypes;
     private readonly lazyChildObjectTypes;
     private readonly lazyDescendantObjectTypes;