@shaclmate/compiler 4.0.93 → 4.0.95

package/dist/generators/ts/AbstractIntersectionType.js

@@ -0,0 +1,80 @@
+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 { invariant } from "ts-invariant";
+import { Memoize } from "typescript-memoize";
+import { AbstractIntersectionType_equalsFunctionExpression } from "./_AbstractIntersectionType/AbstractIntersectionType_equalsFunction.js";
+import { AbstractIntersectionType_filterFunctionExpression } from "./_AbstractIntersectionType/AbstractIntersectionType_filterFunction.js";
+import { AbstractIntersectionType_hashFunctionExpression } from "./_AbstractIntersectionType/AbstractIntersectionType_hashFunction.js";
+import { AbstractIntersectionType_toLoggableFunctionExpression } from "./_AbstractIntersectionType/AbstractIntersectionType_toLoggableFunction.js";
+import { AbstractIntersectionType_toStringFunctionExpression } from "./_AbstractIntersectionType/AbstractIntersectionType_toStringFunction.js";
+import { AbstractIntersectionType_valueSparqlConstructTriplesFunctionExpression } from "./_AbstractIntersectionType/AbstractIntersectionType_valueSparqlConstructTriplesFunction.js";
+import { AbstractIntersectionType_valueSparqlWherePatternsFunctionExpression } from "./_AbstractIntersectionType/AbstractIntersectionType_valueSparqlWherePatternsFunction.js";
+import { AbstractCompoundType } from "./AbstractCompoundType.js";
+import { code, joinCode } from "./ts-poet-wrapper.js";
+export class AbstractIntersectionType extends AbstractCompoundType {
+    equalsFunctionExpression = AbstractIntersectionType_equalsFunctionExpression;
+    filterFunctionExpression = AbstractIntersectionType_filterFunctionExpression;
+    hashFunctionExpression = AbstractIntersectionType_hashFunctionExpression;
+    toLoggableFunctionExpression = AbstractIntersectionType_toLoggableFunctionExpression;
+    toStringFunctionExpression = AbstractIntersectionType_toStringFunctionExpression;
+    valueSparqlConstructTriplesFunctionExpression = AbstractIntersectionType_valueSparqlConstructTriplesFunctionExpression;
+    valueSparqlWherePatternsFunctionExpression = AbstractIntersectionType_valueSparqlWherePatternsFunctionExpression;
+    conversionFunction = Maybe.empty();
+    graphqlArgs = Maybe.empty();
+    identifierProperty;
+    members;
+    recursive;
+    validationFunction = Maybe.empty();
+    constructor({ identifierProperty, members, recursive, ...superParameters }) {
+        super(superParameters);
+        this.identifierProperty = identifierProperty;
+        invariant(members.length >= 2);
+        this.members = members;
+        this.recursive = recursive;
+    }
+    get graphqlType() {
+        throw new Error("not implemented");
+    }
+    get jsTypes() {
+        const jsTypes = [];
+        for (const member of this.members) {
+            for (const memberJsType of member.type.jsTypes) {
+                if (!jsTypes.some((jsType) => AbstractCompoundType.JsType.equals(jsType, memberJsType))) {
+                    jsTypes.push(memberJsType);
+                }
+            }
+        }
+        invariant(jsTypes.length === 1);
+        return jsTypes;
+    }
+    get inlineExpression() {
+        return joinCode(this.members.map((member) => member.type.expression), { on: " & " });
+    }
+    get schemaInitializers() {
+        return super.schemaInitializers.concat(code `members: [${joinCode(this.members.map(({ type }) => type.schema), { on: "," })}] as const`);
+    }
+    filterTypeExpression() {
+        return joinCode(this.members.map(({ type }) => type.filterType), { on: " & " });
+    }
+    schemaTypeExpression() {
+        return code `${{
+            kind: this.kind,
+            members: code `[${joinCode(this.members.map(({ type }) => type.schemaType), { on: ", " })}]`,
+        }}`;
+    }
+}
+__decorate([
+    Memoize()
+], AbstractIntersectionType.prototype, "graphqlType", null);
+__decorate([
+    Memoize()
+], AbstractIntersectionType.prototype, "jsTypes", null);
+__decorate([
+    Memoize()
+], AbstractIntersectionType.prototype, "inlineExpression", null);
+//# sourceMappingURL=AbstractIntersectionType.js.map

package/dist/generators/ts/AbstractLazyType.d.ts

@@ -1,45 +1,57 @@
-import { Maybe } from "purify-ts";
 import { AbstractType } from "./AbstractType.js";
+import type { Callable } from "./Callable.js";
 import type { ObjectDiscriminatedUnionType } from "./ObjectDiscriminatedUnionType.js";
 import type { ObjectType } from "./ObjectType.js";
 import type { OptionType } from "./OptionType.js";
 import type { SetType } from "./SetType.js";
 import { type Code } from "./ts-poet-wrapper.js";
 export declare abstract class AbstractLazyType<PartialTypeT extends AbstractLazyType.PartialTypeConstraint, ResolveTypeT extends AbstractLazyType.ResolveTypeConstraint> extends AbstractType {
-    protected readonly partialType: PartialTypeT;
-    protected readonly resolveType: ResolveTypeT;
+    protected abstract readonly partialItemType: AbstractLazyType.ItemTypeConstraint;
+    protected abstract readonly resolveItemType: AbstractLazyType.ItemTypeConstraint;
     protected abstract readonly runtimeClass: {
         readonly name: Code;
         readonly partialPropertyName: string;
         readonly rawName: Code;
     };
-    readonly discriminantProperty: AbstractType["discriminantProperty"];
+    readonly discriminatedType: AbstractType["discriminatedType"];
+    abstract readonly kind: "Lazy" | "LazyOption" | "LazySet";
     readonly mutable = false;
-    readonly validationFunction: Maybe<Code>;
+    readonly partialType: PartialTypeT;
+    readonly resolveType: ResolveTypeT;
+    readonly validationFunction: AbstractType["validationFunction"];
     constructor({ partialType, resolveType, ...superParameters }: {
         partialType: PartialTypeT;
         resolveType: ResolveTypeT;
     } & ConstructorParameters<typeof AbstractType>[0]);
-    get equalsFunction(): Code;
-    get inlineExpression(): Code;
-    get filterFunction(): Code;
+    get jsonValueType(): AbstractType["jsonValueType"];
+    get equalsFunction(): Callable;
+    get jsonObjectType(): AbstractType["jsonObjectType"];
+    get filterFunction(): Callable;
     get filterType(): Code;
+    get fromJsonValueFunction(): AbstractType["fromJsonValueFunction"];
+    get fromJsonObjectFunction(): AbstractType["fromJsonObjectFunction"];
+    get fromRdfResourceValuesFunction(): Callable;
     get graphqlType(): AbstractType.GraphqlType;
-    get hashFunction(): Code;
+    get hashFunction(): Callable;
+    get inlineExpression(): Code;
     get jsTypes(): readonly AbstractType.JsType[];
     get recursive(): boolean;
     get referencesNamedType(): boolean;
     get schemaType(): Code;
+    get toJsonValueFunction(): AbstractType["toJsonValueFunction"];
+    get toJsonObjectFunction(): AbstractType["toJsonObjectFunction"];
     get toRdfResourceValueTypes(): AbstractType["toRdfResourceValueTypes"];
-    get valueSparqlConstructTriplesFunction(): Code;
-    get valueSparqlWherePatternsFunction(): Code;
+    get valueSparqlConstructTriplesFunction(): Callable;
+    get valueSparqlWherePatternsFunction(): Callable;
     protected get schemaInitializers(): readonly Code[];
-    jsonSchema(parameters: Parameters<AbstractType["jsonSchema"]>[0]): Code;
-    jsonType(parameters?: Parameters<AbstractType["jsonType"]>[0]): AbstractType.JsonType;
-    jsonUiSchemaElement(parameters: Parameters<AbstractType["jsonUiSchemaElement"]>[0]): Maybe<Code>;
-    toJsonExpression({ variables, }: Parameters<AbstractType["toJsonExpression"]>[0]): Code;
+    toLoggableExpression({ variables, }: Parameters<AbstractType["toLoggableExpression"]>[0]): Code;
     toRdfResourceValuesExpression({ variables, }: Parameters<AbstractType["toRdfResourceValuesExpression"]>[0]): Code;
     toStringExpression({ variables, }: Parameters<AbstractType["toStringExpression"]>[0]): Code;
+    protected abstract objectSetResolverFunctionExpressions(parameters: {
+        variables: {
+            objectSet: Code;
+        };
+    }): Code;
     protected resolveToPartialFunction<ObjectTypeT extends AbstractLazyType.ItemTypeConstraint>({ partialType, resolveType, }: {
         partialType: ObjectTypeT;
         resolveType: ObjectTypeT;
@@ -57,10 +69,9 @@ export declare namespace AbstractLazyType {
     type PartialTypeConstraint = ItemTypeConstraint | OptionType<ItemTypeConstraint> | SetType<ItemTypeConstraint>;
     type ResolveTypeConstraint = PartialTypeConstraint;
     type ConversionFunction = AbstractType.ConversionFunction;
-    type DiscriminantProperty = AbstractType.DiscriminantProperty;
+    type DiscriminatedType = AbstractType.DiscriminatedType;
     const GraphqlType: typeof import("./_AbstractType/AbstractType_GraphqlType.js").AbstractType_GraphqlType;
     type GraphqlType = AbstractType.GraphqlType;
-    const JsonType: typeof import("./_AbstractType/AbstractType_JsonType.js").AbstractType_JsonType;
     type JsonType = AbstractType.JsonType;
 }
 //# sourceMappingURL=AbstractLazyType.d.ts.map

package/dist/generators/ts/AbstractLazyType.js

@@ -8,35 +8,66 @@ import { Maybe } from "purify-ts";
 import { invariant } from "ts-invariant";
 import { Memoize } from "typescript-memoize";
 import { AbstractType } from "./AbstractType.js";
+import { InlineCallable } from "./InlineCallable.js";
 import { code, joinCode } from "./ts-poet-wrapper.js";
 export class AbstractLazyType extends AbstractType {
+    discriminatedType = Maybe.empty();
+    mutable = false;
     partialType;
     resolveType;
-    discriminantProperty = Maybe.empty();
-    mutable = false;
     validationFunction = Maybe.empty();
     constructor({ partialType, resolveType, ...superParameters }) {
         super(superParameters);
         this.partialType = partialType;
         this.resolveType = resolveType;
     }
+    get jsonValueType() {
+        return this.partialType.jsonValueType;
+    }
     get equalsFunction() {
-        return code `((left, right) => ${this.partialType.equalsFunction}(left.${this.runtimeClass.partialPropertyName}, right.${this.runtimeClass.partialPropertyName}))`;
+        return new InlineCallable(code `(left, right) => ${this.partialType.equalsFunction.annotatedUsage}(left.${this.runtimeClass.partialPropertyName}, right.${this.runtimeClass.partialPropertyName})`, {
+            type: code `${this.reusables.snippets.EqualsFunction}<${this.expression}>`,
+        });
     }
-    get inlineExpression() {
-        return this.runtimeClass.name;
+    get jsonObjectType() {
+        return this.partialType.jsonObjectType;
     }
     get filterFunction() {
-        return code `((filter: ${this.filterType}, value: ${this.expression}) => ${this.partialType.filterFunction}(filter, value.${this.runtimeClass.partialPropertyName}))`;
+        return new InlineCallable(code `(filter, value) => ${this.partialType.filterFunction.annotatedUsage}(filter, value.${this.runtimeClass.partialPropertyName})`, {
+            type: code `${this.reusables.snippets.FilterFunction}<${this.filterType}, ${this.expression}>`,
+        });
     }
     get filterType() {
         return this.partialType.filterType;
     }
+    get fromJsonValueFunction() {
+        return new InlineCallable(code `(jsonValue, { objectSet, schema, ...otherOptions }) => ${this.partialType.fromJsonValueFunction.annotatedUsage}(jsonValue, { objectSet, schema: schema.partialType, ...otherOptions })
+        .map(${this.runtimeClass.partialPropertyName} => new ${this.runtimeClass.name}({ ${this.runtimeClass.partialPropertyName}, resolver: objectSet ? ${this.objectSetResolverFunctionExpressions({ variables: { objectSet: code `objectSet` } })} : ${this.reusables.snippets.missingResolver} }))`, {
+            type: code `${this.reusables.snippets.FromJsonValueFunction}<${this.jsonValueType.expression}, ${this.expression}, ${this.schema}>`,
+        });
+    }
+    get fromJsonObjectFunction() {
+        return new InlineCallable(code `(jsonObject, { objectSet, schema, ...otherOptions }) => ${this.partialType.fromJsonObjectFunction.annotatedUsage}(jsonObject, { objectSet, schema: schema.partialType, ...otherOptions })
+        .map(${this.runtimeClass.partialPropertyName} => new ${this.runtimeClass.name}({ ${this.runtimeClass.partialPropertyName}, resolver: objectSet ? ${this.objectSetResolverFunctionExpressions({ variables: { objectSet: code `objectSet` } })} : ${this.reusables.snippets.missingResolver} }))`, {
+            type: code `${this.reusables.snippets.FromJsonObjectFunction}<${this.jsonObjectType.expression}, ${this.expression}, ${this.schema}>`,
+        });
+    }
+    get fromRdfResourceValuesFunction() {
+        return new InlineCallable(code `\
+  (values, { objectSet, schema, ...otherOptions }) =>
+    ${this.partialType.fromRdfResourceValuesFunction.annotatedUsage}(values, { objectSet, schema: schema.partialType, ...otherOptions })
+      .map(values => values.map(${this.runtimeClass.partialPropertyName} => new ${this.runtimeClass.name}({ ${this.runtimeClass.partialPropertyName}, resolver: ${this.objectSetResolverFunctionExpressions({ variables: { objectSet: code `objectSet` } })} })))`, {
+            type: code `${this.reusables.snippets.FromRdfResourceValuesFunction}<${this.expression}, ${this.schemaType}>`,
+        });
+    }
     get graphqlType() {
         return this.resolveType.graphqlType;
     }
     get hashFunction() {
-        return code `((hasher, value) => ${this.partialType.hashFunction}(hasher, value.${this.runtimeClass.partialPropertyName}))`;
+        return new InlineCallable(code `(hasher, value) => ${this.partialType.hashFunction.annotatedUsage}(hasher, value.${this.runtimeClass.partialPropertyName})`);
+    }
+    get inlineExpression() {
+        return this.runtimeClass.name;
     }
     get jsTypes() {
         return [
@@ -59,29 +90,34 @@ export class AbstractLazyType extends AbstractType {
             partialType: this.partialType.schemaType,
         }}`;
     }
+    get toJsonValueFunction() {
+        return new InlineCallable(code `(value) => ${this.partialType.toJsonValueFunction.unannotatedUsage}(value.${this.runtimeClass.partialPropertyName})`, {
+            type: code `${this.reusables.snippets.ToJsonValueFunction}<${this.expression}, ${this.jsonValueType.expression}>`,
+        });
+    }
+    get toJsonObjectFunction() {
+        return new InlineCallable(code `(value) => ${this.partialType.toJsonObjectFunction.unannotatedUsage}(value.${this.runtimeClass.partialPropertyName})`, {
+            type: code `${this.reusables.snippets.ToJsonObjectFunction}<${this.expression}, ${this.jsonValueType.expression}>`,
+        });
+    }
     get toRdfResourceValueTypes() {
         return this.partialType.toRdfResourceValueTypes;
     }
     get valueSparqlConstructTriplesFunction() {
-        return code `(({ schema, ...otherParameters }) => ${this.partialType.valueSparqlConstructTriplesFunction}({ ...otherParameters, schema: schema.partialType }))`;
+        return new InlineCallable(code `(({ schema, ...otherParameters }) => ${this.partialType.valueSparqlConstructTriplesFunction.annotatedUsage}({ ...otherParameters, schema: schema.partialType }))`, {
+            type: code `${this.reusables.snippets.ValueSparqlConstructTriplesFunction}<${this.filterType}, ${this.schemaType}>`,
+        });
     }
     get valueSparqlWherePatternsFunction() {
-        return code `(({ schema, ...otherParameters }) => ${this.partialType.valueSparqlWherePatternsFunction}({ ...otherParameters, schema: schema.partialType }))`;
+        return new InlineCallable(code `(({ schema, ...otherParameters }) => ${this.partialType.valueSparqlWherePatternsFunction.annotatedUsage}({ ...otherParameters, schema: schema.partialType }))`, {
+            type: code `${this.reusables.snippets.ValueSparqlWherePatternsFunction}<${this.filterType}, ${this.schemaType}>`,
+        });
     }
     get schemaInitializers() {
         return super.schemaInitializers.concat(code `get partialType() { return ${this.partialType.schema}; }`);
     }
-    jsonSchema(parameters) {
-        return this.partialType.jsonSchema(parameters);
-    }
-    jsonType(parameters) {
-        return this.partialType.jsonType(parameters);
-    }
-    jsonUiSchemaElement(parameters) {
-        return this.partialType.jsonUiSchemaElement(parameters);
-    }
-    toJsonExpression({ variables, }) {
-        return this.partialType.toJsonExpression({
+    toLoggableExpression({ variables, }) {
+        return this.partialType.toLoggableExpression({
             variables: {
                 value: code `${variables.value}.${this.runtimeClass.partialPropertyName}`,
             },
@@ -113,7 +149,7 @@ export class AbstractLazyType extends AbstractType {
             return code `${discriminantValues.map((discriminantPropertyValue) => `case "${discriminantPropertyValue}":`).join("\n")} return ${partialType.members[memberI].type.name.unsafeCoerce()}.createUnsafe(resolved);`;
         });
         caseBlocks.push(code `default: resolved satisfies never; throw new Error("unrecognized type");`);
-        return code `((resolved: ${resolveType.expression}) => { switch (resolved.${resolveType.discriminantProperty.unsafeCoerce().name}) { ${joinCode(caseBlocks)} } })`;
+        return code `((resolved: ${resolveType.expression}) => { switch (resolved.${resolveType.discriminatedType.unsafeCoerce().discriminantProperty.name}) { ${joinCode(caseBlocks)} } })`;
     }
     resolvedObjectDiscriminatedUnionTypeToPartialObjectDiscriminatedUnionTypeConversion({ resolvedObjectDiscriminatedUnionType, partialObjectDiscriminatedUnionType, variables, }) {
         invariant(resolvedObjectDiscriminatedUnionType.members.length ===
@@ -122,7 +158,7 @@ export class AbstractLazyType extends AbstractType {
             return code `${discriminantValues.map((discriminantPropertyValue) => `case "${discriminantPropertyValue}":`).join("\n")} return ${partialObjectDiscriminatedUnionType.members[memberI].type.name.unsafeCoerce()}.create(${variables.resolvedObjectDiscriminatedUnion});`;
         });
         caseBlocks.push(code `default: ${variables.resolvedObjectDiscriminatedUnion} satisfies never; throw new Error("unrecognized type");`);
-        return code `switch (${variables.resolvedObjectDiscriminatedUnion}.${resolvedObjectDiscriminatedUnionType.discriminantProperty.unsafeCoerce().name}) { ${joinCode(caseBlocks)} }`;
+        return code `switch (${variables.resolvedObjectDiscriminatedUnion}.${resolvedObjectDiscriminatedUnionType.discriminatedType.unsafeCoerce().discriminantProperty.name}) { ${joinCode(caseBlocks)} }`;
     }
 }
 __decorate([
@@ -131,6 +167,9 @@ __decorate([
 __decorate([
     Memoize()
 ], AbstractLazyType.prototype, "filterFunction", null);
+__decorate([
+    Memoize()
+], AbstractLazyType.prototype, "fromRdfResourceValuesFunction", null);
 __decorate([
     Memoize()
 ], AbstractLazyType.prototype, "hashFunction", null);
@@ -148,6 +187,5 @@ __decorate([
 ], AbstractLazyType.prototype, "valueSparqlWherePatternsFunction", null);
 (function (AbstractLazyType) {
     AbstractLazyType.GraphqlType = AbstractType.GraphqlType;
-    AbstractLazyType.JsonType = AbstractType.JsonType;
 })(AbstractLazyType || (AbstractLazyType = {}));
 //# sourceMappingURL=AbstractLazyType.js.map

package/dist/generators/ts/AbstractLiteralType.d.ts

@@ -4,15 +4,15 @@ import { AbstractTermType } from "./AbstractTermType.js";
  * Abstract base class of all types that are literals in RDF.
  */
 export declare abstract class AbstractLiteralType extends AbstractTermType<Literal, Literal> {
+    readonly jsonObjectType: AbstractTermType<Literal, Literal>["jsonObjectType"];
     readonly nodeKinds: ReadonlySet<"Literal">;
 }
 export declare namespace AbstractLiteralType {
     type ConversionFunction = AbstractTermType.ConversionFunction;
-    type DiscriminantProperty = AbstractTermType.DiscriminantProperty;
+    type DiscriminatedType = AbstractTermType.DiscriminatedType;
     const GraphqlType: typeof import("./_AbstractType/AbstractType_GraphqlType.js").AbstractType_GraphqlType;
     type GraphqlType = AbstractTermType.GraphqlType;
     type JsType = AbstractTermType.JsType;
-    const JsonType: typeof import("./_AbstractType/AbstractType_JsonType.js").AbstractType_JsonType;
     type JsonType = AbstractTermType.JsonType;
 }
 //# sourceMappingURL=AbstractLiteralType.d.ts.map

package/dist/generators/ts/AbstractLiteralType.js

@@ -3,11 +3,25 @@ import { AbstractTermType } from "./AbstractTermType.js";
  * Abstract base class of all types that are literals in RDF.
  */
 export class AbstractLiteralType extends AbstractTermType {
+    jsonObjectType = this.jsonTypeFactory.createJsonObjectType({
+        "@language": {
+            optional: true,
+            type: this.jsonTypeFactory.createJsonStringType(),
+        },
+        "@type": {
+            optional: true,
+            type: this.jsonTypeFactory.createJsonStringType(),
+        },
+        "@value": {
+            type: this.jsonTypeFactory.createJsonStringType(),
+        },
+    }, {
+        snippet: this.reusables.snippets.LiteralJsonObject,
+    });
     nodeKinds = nodeKinds;
 }
 (function (AbstractLiteralType) {
     AbstractLiteralType.GraphqlType = AbstractTermType.GraphqlType;
-    AbstractLiteralType.JsonType = AbstractTermType.JsonType;
 })(AbstractLiteralType || (AbstractLiteralType = {}));
 const nodeKinds = new Set(["Literal"]);
 //# sourceMappingURL=AbstractLiteralType.js.map

package/dist/generators/ts/AbstractNumericType.d.ts

@@ -1,20 +1,21 @@
 import { AbstractPrimitiveType } from "./AbstractPrimitiveType.js";
+import type { Callable } from "./Callable.js";
+import { ReferenceCallable } from "./ReferenceCallable.js";
 import { type Code } from "./ts-poet-wrapper.js";
 /**
  * Abstract base class for TypeScript numeric types (bigint | number).
  */
 export declare abstract class AbstractNumericType<ValueT extends bigint | number> extends AbstractPrimitiveType<ValueT> {
-    readonly hashFunction: Code;
+    readonly hashFunction: ReferenceCallable;
     abstract readonly kind: "BigInt" | "Float" | "Int";
-    get filterFunction(): Code;
+    get filterFunction(): Callable;
     get filterType(): Code;
     get schemaType(): Code;
-    get valueSparqlWherePatternsFunction(): Code;
+    get valueSparqlWherePatternsFunction(): Callable;
     toRdfResourceValuesExpression({ variables, }: Parameters<AbstractPrimitiveType<string>["toRdfResourceValuesExpression"]>[0]): Code;
 }
 export declare namespace AbstractNumericType {
     type ConversionFunction = AbstractPrimitiveType.ConversionFunction;
-    const JsonType: typeof import("./_AbstractType/AbstractType_JsonType.js").AbstractType_JsonType;
     type JsonType = AbstractPrimitiveType.JsonType;
 }
 //# sourceMappingURL=AbstractNumericType.d.ts.map

package/dist/generators/ts/AbstractNumericType.js

@@ -6,14 +6,15 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 };
 import { Memoize } from "typescript-memoize";
 import { AbstractPrimitiveType } from "./AbstractPrimitiveType.js";
+import { ReferenceCallable } from "./ReferenceCallable.js";
 import { code } from "./ts-poet-wrapper.js";
 /**
  * Abstract base class for TypeScript numeric types (bigint | number).
  */
 export class AbstractNumericType extends AbstractPrimitiveType {
-    hashFunction = code `${this.reusables.snippets.hashNumeric}`;
+    hashFunction = new ReferenceCallable(this.reusables.snippets.hashNumeric);
     get filterFunction() {
-        return code `${this.reusables.snippets.filterNumeric}<${this.expression}>`;
+        return new ReferenceCallable(code `${this.reusables.snippets.filterNumeric}<${this.expression}>`);
     }
     get filterType() {
         return code `${this.reusables.snippets.NumericFilter}<${this.expression}>`;
@@ -22,7 +23,7 @@ export class AbstractNumericType extends AbstractPrimitiveType {
         return code `${this.reusables.snippets.NumericSchema}<${this.expression}>`;
     }
     get valueSparqlWherePatternsFunction() {
-        return code `${this.reusables.snippets.numericSparqlWherePatterns}<${this.expression}>`;
+        return new ReferenceCallable(code `${this.reusables.snippets.numericSparqlWherePatterns}<${this.expression}>`);
     }
     toRdfResourceValuesExpression({ variables, }) {
         return code `[${this.reusables.snippets.literalFactory}.${this.jsTypes[0].typeof}(${variables.value}, ${this.rdfjsTermExpression(this.datatype)})]`;
@@ -40,7 +41,4 @@ __decorate([
 __decorate([
     Memoize()
 ], AbstractNumericType.prototype, "valueSparqlWherePatternsFunction", null);
-(function (AbstractNumericType) {
-    AbstractNumericType.JsonType = AbstractPrimitiveType.JsonType;
-})(AbstractNumericType || (AbstractNumericType = {}));
 //# sourceMappingURL=AbstractNumericType.js.map

package/dist/generators/ts/AbstractObjectSetType.d.ts

@@ -1,6 +1,7 @@
 import type { Logger } from "@rdfx/logger";
 import type { Maybe } from "purify-ts";
 import type { ObjectDiscriminatedUnionType } from "./ObjectDiscriminatedUnionType.js";
+import type { ObjectIntersectionType } from "./ObjectIntersectionType.js";
 import type { ObjectType } from "./ObjectType.js";
 import type { Reusables } from "./Reusables.js";
 import type { TsGenerator } from "./TsGenerator.js";
@@ -9,17 +10,15 @@ export declare abstract class AbstractObjectSetType {
     protected readonly configuration: TsGenerator.Configuration;
     protected readonly logger: Logger;
     protected readonly reusables: Reusables;
-    protected readonly namedObjectTypes: readonly ObjectType[];
-    protected readonly namedObjectDiscriminatedUnionTypes: readonly ObjectDiscriminatedUnionType[];
-    constructor({ configuration, logger, namedObjectTypes, namedObjectDiscriminatedUnionTypes, reusables, }: {
+    protected readonly namedObjectTypes: readonly (ObjectDiscriminatedUnionType | ObjectIntersectionType | ObjectType)[];
+    constructor({ configuration, logger, namedObjectTypes, reusables, }: {
         configuration: TsGenerator.Configuration;
         logger: Logger;
-        namedObjectTypes: readonly ObjectType[];
-        namedObjectDiscriminatedUnionTypes: readonly ObjectDiscriminatedUnionType[];
+        namedObjectTypes: readonly (ObjectDiscriminatedUnionType | ObjectIntersectionType | ObjectType)[];
         reusables: Reusables;
     });
     abstract readonly declaration: Code;
-    protected methodSignatures(namedObjectType: {
+    protected methodSignatures(objectType: {
         readonly filterType: Code;
         readonly identifierTypeAlias: Code;
         readonly name: Maybe<string>;

package/dist/generators/ts/AbstractObjectSetType.js

@@ -4,40 +4,37 @@ export class AbstractObjectSetType {
     logger;
     reusables;
     namedObjectTypes;
-    namedObjectDiscriminatedUnionTypes;
-    constructor({ configuration, logger, namedObjectTypes, namedObjectDiscriminatedUnionTypes, reusables, }) {
+    constructor({ configuration, logger, namedObjectTypes, reusables, }) {
         this.configuration = configuration;
         this.logger = logger;
         this.namedObjectTypes = namedObjectTypes;
-        this.namedObjectDiscriminatedUnionTypes =
-            namedObjectDiscriminatedUnionTypes;
         this.reusables = reusables;
     }
-    methodSignatures(namedObjectType, options) {
+    methodSignatures(objectType, options) {
         const parameterNamePrefix = options?.parameterNamePrefix ?? "";
         const queryT = options?.queryT ??
             `${this.configuration.syntheticNamePrefix}ObjectSet.Query`;
-        const methodNames = namedObjectType.objectSetMethodNames;
+        const methodNames = objectType.objectSetMethodNames;
         return {
             object: {
                 name: methodNames.object,
-                parameters: code `${parameterNamePrefix}identifier: ${namedObjectType.identifierTypeAlias}, options?: { preferredLanguages?: readonly string[]; }`,
-                returnType: code `Promise<${this.reusables.imports.Either}<Error, ${namedObjectType.name.unsafeCoerce()}>>`,
+                parameters: code `${parameterNamePrefix}identifier: ${objectType.identifierTypeAlias}, options?: { preferredLanguages?: readonly string[]; }`,
+                returnType: code `Promise<${this.reusables.imports.Either}<Error, ${objectType.name.unsafeCoerce()}>>`,
             },
             objectCount: {
                 name: methodNames.objectCount,
-                parameters: code `${parameterNamePrefix}query?: Pick<${queryT}<${namedObjectType.filterType}, ${namedObjectType.identifierTypeAlias}>, "filter">`,
+                parameters: code `${parameterNamePrefix}query?: Pick<${queryT}<${objectType.filterType}, ${objectType.identifierTypeAlias}>, "filter">`,
                 returnType: code `Promise<${this.reusables.imports.Either}<Error, number>>`,
             },
             objectIdentifiers: {
                 name: methodNames.objectIdentifiers,
-                parameters: code `${parameterNamePrefix}query?: ${queryT}<${namedObjectType.filterType}, ${namedObjectType.identifierTypeAlias}>`,
-                returnType: code `Promise<${this.reusables.imports.Either}<Error, readonly ${namedObjectType.identifierTypeAlias}[]>>`,
+                parameters: code `${parameterNamePrefix}query?: ${queryT}<${objectType.filterType}, ${objectType.identifierTypeAlias}>`,
+                returnType: code `Promise<${this.reusables.imports.Either}<Error, readonly ${objectType.identifierTypeAlias}[]>>`,
             },
             objects: {
                 name: methodNames.objects,
-                parameters: code `${parameterNamePrefix}query?: ${queryT}<${namedObjectType.filterType}, ${namedObjectType.identifierTypeAlias}>`,
-                returnType: code `Promise<${this.reusables.imports.Either}<Error, readonly ${namedObjectType.name.unsafeCoerce()}[]>>`,
+                parameters: code `${parameterNamePrefix}query?: ${queryT}<${objectType.filterType}, ${objectType.identifierTypeAlias}>`,
+                returnType: code `Promise<${this.reusables.imports.Either}<Error, readonly ${objectType.name.unsafeCoerce()}[]>>`,
             },
         };
     }

package/dist/generators/ts/AbstractPrimitiveType.d.ts

@@ -1,25 +1,25 @@
 import type { Primitive } from "@rdfx/literal";
 import { AbstractLiteralType } from "./AbstractLiteralType.js";
 import { AbstractTypedLiteralType } from "./AbstractTypedLiteralType.js";
+import { ReferenceCallable } from "./ReferenceCallable.js";
 import { type Code } from "./ts-poet-wrapper.js";
 /**
  * Abstract base class of typed literals whose datatype corresponds to a JavaScript primitive type.
  */
 export declare abstract class AbstractPrimitiveType<ValueT extends Primitive> extends AbstractTypedLiteralType<ValueT> {
-    readonly equalsFunction: Code;
+    protected abstract readonly decodedIn: readonly ValueT[];
+    readonly equalsFunction: ReferenceCallable;
+    get toJsonObjectFunction(): AbstractTypedLiteralType<ValueT>["toJsonObjectFunction"];
+    get toJsonValueFunction(): AbstractTypedLiteralType<ValueT>["toJsonValueFunction"];
     protected get inlineExpression(): Code;
-    fromJsonExpression({ variables, }: Parameters<AbstractLiteralType["fromJsonExpression"]>[0]): Code;
-    jsonSchema(_parameters: Parameters<AbstractTypedLiteralType<ValueT>["jsonSchema"]>[0]): Code;
-    jsonType(): AbstractLiteralType.JsonType;
-    toJsonExpression({ variables, }: Parameters<AbstractLiteralType["toJsonExpression"]>[0]): Code;
+    toLoggableExpression({ variables, }: Parameters<AbstractLiteralType["toLoggableExpression"]>[0]): Code;
 }
 export declare namespace AbstractPrimitiveType {
     type ConversionFunction = AbstractLiteralType.ConversionFunction;
-    type DiscriminantProperty = AbstractLiteralType.DiscriminantProperty;
+    type DiscriminatedType = AbstractLiteralType.DiscriminatedType;
     type JsType = AbstractLiteralType.JsType;
     const GraphqlType: typeof import("./_AbstractType/AbstractType_GraphqlType.js").AbstractType_GraphqlType;
     type GraphqlType = AbstractLiteralType.GraphqlType;
-    const JsonType: typeof import("./_AbstractType/AbstractType_JsonType.js").AbstractType_JsonType;
     type JsonType = AbstractLiteralType.JsonType;
 }
 //# sourceMappingURL=AbstractPrimitiveType.d.ts.map

package/dist/generators/ts/AbstractPrimitiveType.js

@@ -7,59 +7,41 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 import { Memoize } from "typescript-memoize";
 import { AbstractLiteralType } from "./AbstractLiteralType.js";
 import { AbstractTypedLiteralType } from "./AbstractTypedLiteralType.js";
-import { arrayOf, code, joinCode } from "./ts-poet-wrapper.js";
+import { ReferenceCallable } from "./ReferenceCallable.js";
+import { code, joinCode } from "./ts-poet-wrapper.js";
 /**
  * Abstract base class of typed literals whose datatype corresponds to a JavaScript primitive type.
  */
 export class AbstractPrimitiveType extends AbstractTypedLiteralType {
-    equalsFunction = code `${this.reusables.snippets.strictEquals}`;
+    equalsFunction = new ReferenceCallable(this.reusables.snippets.strictEquals);
+    get toJsonObjectFunction() {
+        return new ReferenceCallable(code `${this.reusables.snippets.primitiveToJsonObject}<${this.expression}>(${this.rdfjsTermExpression(this.datatype)})`);
+    }
+    get toJsonValueFunction() {
+        return new ReferenceCallable(code `${this.reusables.snippets.primitiveToJsonValue}<${this.expression}>`);
+    }
     get inlineExpression() {
         if (this.in_.length > 0) {
-            const name = this.name.extract();
-            if (name && this.configuration.features.has("Object.schema")) {
-                // Reuse the type from schema to cut down code
-                return code `(typeof ${name}.schema)["in"][number]`;
-            }
-            return code `${joinCode(this.in_.map((value) => this.valueExpression(value)), { on: " | " })}`;
+            return this.name
+                .map((name) => code `${name}.Schema["in"][number]`)
+                .orDefault(code `${joinCode(this.in_.map((value) => this.valueExpression(value)), { on: " | " })}`);
         }
         return code `${this.jsTypes[0].typeof}`;
     }
-    fromJsonExpression({ variables, }) {
-        return code `${this.reusables.imports.Either}.of<Error, ${this.expression}>(${variables.value})`;
-    }
-    jsonSchema(_parameters) {
-        switch (this.in_.length) {
-            case 0:
-                return code `${this.reusables.imports.z}.${this.jsTypes[0].typeof}()`;
-            case 1:
-                return code `${this.reusables.imports.z}.literal(${this.valueExpression(this.in_[0])})`;
-            default: {
-                const name = this.name.extract();
-                if (name && this.configuration.features.has("Object.schema")) {
-                    // Reuse the type from schema to cut down code
-                    return code `${this.reusables.imports.z}.union(${name}.schema.in.map(_ => ${this.reusables.imports.z}.literal(_)))`;
-                }
-                else {
-                    return code `${this.reusables.imports.z}.union(${arrayOf(...this.in_.map((value) => code `${this.reusables.imports.z}.literal(${this.valueExpression(value)})`))})`;
-                }
-            }
-        }
-    }
-    jsonType() {
-        return new AbstractLiteralType.JsonType(this.expression);
-    }
-    toJsonExpression({ variables, }) {
+    toLoggableExpression({ variables, }) {
         return variables.value;
     }
 }
 __decorate([
     Memoize()
-], AbstractPrimitiveType.prototype, "inlineExpression", null);
+], AbstractPrimitiveType.prototype, "toJsonObjectFunction", null);
 __decorate([
     Memoize()
-], AbstractPrimitiveType.prototype, "jsonType", null);
+], AbstractPrimitiveType.prototype, "toJsonValueFunction", null);
+__decorate([
+    Memoize()
+], AbstractPrimitiveType.prototype, "inlineExpression", null);
 (function (AbstractPrimitiveType) {
     AbstractPrimitiveType.GraphqlType = AbstractLiteralType.GraphqlType;
-    AbstractPrimitiveType.JsonType = AbstractLiteralType.JsonType;
 })(AbstractPrimitiveType || (AbstractPrimitiveType = {}));
 //# sourceMappingURL=AbstractPrimitiveType.js.map