@shaclmate/compiler 4.0.33 → 4.0.35

package/dist/generators/ts/AbstractNumericType.js

@@ -11,6 +11,7 @@ import { code, joinCode } 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}`;
     get filterFunction() {
         return code `${this.reusables.snippets.filterNumeric}<${this.typeofs[0]}>`;
     }
@@ -19,7 +20,7 @@ export class AbstractNumericType extends AbstractPrimitiveType {
     }
     get name() {
         if (this.primitiveIn.length > 0) {
-            return `${this.primitiveIn.map((value) => this.literalOf(value)).join(" | ")}`;
+            return code `${joinCode(this.primitiveIn.map((value) => this.literalExpression(value)), { on: " | " })}`;
         }
         return this.typeofs[0];
     }
@@ -29,30 +30,22 @@ export class AbstractNumericType extends AbstractPrimitiveType {
     get valueSparqlWherePatternsFunction() {
         return code `${this.reusables.snippets.numericSparqlWherePatterns}<${this.typeofs[0]}>`;
     }
-    get schemaObject() {
-        return {
-            ...super.schemaObject,
-            in: this.primitiveIn.length > 0
-                ? this.primitiveIn.map((_) => code `${this.literalOf(_)}`)
-                : undefined,
-        };
-    }
     jsonSchema(_parameters) {
         switch (this.primitiveIn.length) {
             case 0:
                 return code `${this.reusables.imports.z}.${this.typeofs[0]}()`;
             case 1:
-                return code `${this.reusables.imports.z}.literal(${this.literalOf(this.primitiveIn[0])})`;
+                return code `${this.reusables.imports.z}.literal(${this.literalExpression(this.primitiveIn[0])})`;
             default:
-                return code `${this.reusables.imports.z}.union([${joinCode(this.primitiveIn.map((value) => code `${this.reusables.imports.z}.literal(${this.literalOf(value)})`), { on: "," })}])`;
+                return code `${this.reusables.imports.z}.union([${joinCode(this.primitiveIn.map((value) => code `${this.reusables.imports.z}.literal(${this.literalExpression(value)})`), { on: "," })}])`;
         }
     }
     toRdfResourceValuesExpression({ variables, }) {
         return code `[${this.reusables.snippets.literalFactory}.${this.typeofs[0]}(${variables.value}, ${this.rdfjsTermExpression(this.datatype)})]`;
     }
-    fromRdfExpressionChain({ variables, }) {
+    fromRdfResourceValuesExpressionChain({ variables, }) {
         return {
-            ...super.fromRdfExpressionChain({ variables }),
+            ...super.fromRdfResourceValuesExpressionChain({ variables }),
             languageIn: undefined,
             preferredLanguages: undefined,
             valueTo: code `chain(values => values.chainMap(value => ${this.fromRdfResourceValueExpression({

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

@@ -1,9 +1,10 @@
-import type { NamedNode } from "@rdfjs/types";
+import type { Literal, NamedNode } from "@rdfjs/types";
 import { Maybe } from "purify-ts";
 import { AbstractLiteralType } from "./AbstractLiteralType.js";
 import { type Code } from "./ts-poet-wrapper.js";
 export declare abstract class AbstractPrimitiveType<ValueT extends bigint | boolean | Date | string | number> extends AbstractLiteralType {
     protected readonly datatype: NamedNode;
+    readonly conversionFunction: Maybe<AbstractLiteralType.ConversionFunction>;
     readonly equalsFunction: Code;
     abstract readonly kind: "BigIntType" | "BooleanType" | "DateTimeType" | "DateType" | "FloatType" | "IntType" | "NumberType" | "StringType";
     readonly primitiveIn: readonly ValueT[];
@@ -11,16 +12,20 @@ export declare abstract class AbstractPrimitiveType<ValueT extends bigint | bool
         datatype: NamedNode;
         primitiveIn: readonly ValueT[];
     } & ConstructorParameters<typeof AbstractLiteralType>[0]);
-    get conversions(): readonly AbstractPrimitiveType.Conversion[];
     get discriminantProperty(): Maybe<AbstractLiteralType.DiscriminantProperty>;
+    protected get schemaObject(): {
+        in: Code | undefined;
+        languageIn: import("ts-poet/build/Node.js").Node[] | undefined;
+        kind: Code;
+    };
     fromJsonExpression({ variables, }: Parameters<AbstractLiteralType["fromJsonExpression"]>[0]): Code;
     graphqlResolveExpression({ variables, }: Parameters<AbstractLiteralType["graphqlResolveExpression"]>[0]): Code;
-    hashStatements({ variables, }: Parameters<AbstractLiteralType["hashStatements"]>[0]): readonly Code[];
     jsonType(): AbstractLiteralType.JsonType;
+    abstract literalExpression(literal: Literal | ValueT): Code;
     toJsonExpression({ variables, }: Parameters<AbstractLiteralType["toJsonExpression"]>[0]): Code;
 }
 export declare namespace AbstractPrimitiveType {
-    type Conversion = AbstractLiteralType.Conversion;
+    type ConversionFunction = AbstractLiteralType.ConversionFunction;
     type DiscriminantProperty = AbstractLiteralType.DiscriminantProperty;
     const GraphqlType: typeof import("./AbstractType.js").AbstractType.GraphqlType;
     type GraphqlType = AbstractLiteralType.GraphqlType;

package/dist/generators/ts/AbstractPrimitiveType.js

@@ -7,9 +7,10 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 import { Maybe } from "purify-ts";
 import { Memoize } from "typescript-memoize";
 import { AbstractLiteralType } from "./AbstractLiteralType.js";
-import { code } from "./ts-poet-wrapper.js";
+import { code, joinCode } from "./ts-poet-wrapper.js";
 export class AbstractPrimitiveType extends AbstractLiteralType {
     datatype;
+    conversionFunction = Maybe.empty();
     equalsFunction = code `${this.reusables.snippets.strictEquals}`;
     primitiveIn;
     constructor({ datatype, primitiveIn, ...superParameters }) {
@@ -17,28 +18,23 @@ export class AbstractPrimitiveType extends AbstractLiteralType {
         this.datatype = datatype;
         this.primitiveIn = primitiveIn;
     }
-    get conversions() {
-        return [
-            {
-                conversionExpression: (value) => value,
-                sourceTypeCheckExpression: (value) => code `typeof ${value} === "${this.typeofs[0]}"`,
-                sourceTypeName: this.name,
-                sourceTypeof: this.typeofs[0],
-            },
-        ];
-    }
     get discriminantProperty() {
         return Maybe.empty();
     }
+    get schemaObject() {
+        return {
+            ...super.schemaObject,
+            in: this.primitiveIn.length > 0
+                ? code `[${joinCode(this.primitiveIn.map((in_) => this.literalExpression(in_)), { on: ", " })}] as const`
+                : undefined,
+        };
+    }
     fromJsonExpression({ variables, }) {
-        return variables.value;
+        return code `${this.reusables.imports.Either}.of<Error, ${this.name}>(${variables.value})`;
     }
     graphqlResolveExpression({ variables, }) {
         return variables.value;
     }
-    hashStatements({ variables, }) {
-        return [code `${variables.hasher}.update(${variables.value}.toString());`];
-    }
     jsonType() {
         return new AbstractLiteralType.JsonType(this.name);
     }
@@ -46,9 +42,6 @@ export class AbstractPrimitiveType extends AbstractLiteralType {
         return variables.value;
     }
 }
-__decorate([
-    Memoize()
-], AbstractPrimitiveType.prototype, "conversions", null);
 __decorate([
     Memoize()
 ], AbstractPrimitiveType.prototype, "jsonType", null);

package/dist/generators/ts/AbstractTermType.d.ts

@@ -3,6 +3,7 @@ import { NodeKind } from "@shaclmate/shacl-ast";
 import { Maybe } from "purify-ts";
 import { AbstractType } from "./AbstractType.js";
 import type { Type } from "./Type.js";
+import type { Typeof } from "./Typeof.js";
 import { type Code } from "./ts-poet-wrapper.js";
 /**
  * Abstract base class for IdentifierType and LiteralType.
@@ -17,24 +18,28 @@ export declare abstract class AbstractTermType<ConstantTermT extends Literal | N
     readonly equalsFunction: Code;
     readonly graphqlArgs: AbstractType["graphqlArgs"];
     readonly hasValues: readonly ConstantTermT[];
+    readonly hashFunction: Code;
     readonly in_: readonly ConstantTermT[];
     readonly mutable: boolean;
     abstract readonly nodeKinds: ReadonlySet<NodeKind>;
     readonly recursive = false;
-    readonly typeofs: AbstractType["typeofs"];
+    readonly typeofs: readonly Typeof[];
+    readonly validationFunction: Maybe<Code>;
     constructor({ hasValues, in_, ...superParameters }: {
         hasValues: readonly ConstantTermT[];
         in_: readonly ConstantTermT[];
     } & ConstructorParameters<typeof AbstractType>[0]);
     get constrained(): boolean;
-    get conversions(): readonly AbstractType.Conversion[];
     get discriminantProperty(): Maybe<AbstractType.DiscriminantProperty>;
     get schema(): Code;
+    protected get schemaObject(): {
+        in: Code | undefined;
+        kind: Code;
+    };
     get termTypes(): ReadonlySet<"BlankNode" | "Literal" | "NamedNode">;
     get toRdfResourceValueTypes(): Set<"BlankNode" | "Literal" | "NamedNode">;
     get valueSparqlConstructTriplesFunction(): Code;
     fromRdfResourceValuesExpression(parameters: Parameters<AbstractType["fromRdfResourceValuesExpression"]>[0]): Code;
-    hashStatements({ variables, }: Parameters<AbstractType["hashStatements"]>[0]): readonly Code[];
     jsonUiSchemaElement(): Maybe<Code>;
     toRdfResourceValuesExpression({ variables, }: Parameters<AbstractType["toRdfResourceValuesExpression"]>[0]): Code;
     toStringExpression({ variables, }: Parameters<AbstractType["toStringExpression"]>[0]): Code;
@@ -47,7 +52,7 @@ export declare abstract class AbstractTermType<ConstantTermT extends Literal | N
      *
      * Considering the sub-expressions as a record instead of an array allows them to be selectively overridden by subclasses.
      */
-    protected fromRdfExpressionChain({ variables, }: Parameters<Type["fromRdfResourceValuesExpression"]>[0]): {
+    protected fromRdfResourceValuesExpressionChain({ variables, }: Parameters<Type["fromRdfResourceValuesExpression"]>[0]): {
         hasValues?: Code;
         languageIn?: Code;
         preferredLanguages?: Code;
@@ -55,7 +60,7 @@ export declare abstract class AbstractTermType<ConstantTermT extends Literal | N
     };
 }
 export declare namespace AbstractTermType {
-    type Conversion = AbstractType.Conversion;
+    type ConversionFunction = AbstractType.ConversionFunction;
     type DiscriminantProperty = AbstractType.DiscriminantProperty;
     const GraphqlType: typeof AbstractType.GraphqlType;
     type GraphqlType = AbstractType.GraphqlType;

package/dist/generators/ts/AbstractTermType.js

@@ -5,7 +5,7 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
 import { NodeKind } from "@shaclmate/shacl-ast";
-import { Maybe, NonEmptyList } from "purify-ts";
+import { Maybe } from "purify-ts";
 import { Memoize } from "typescript-memoize";
 import { AbstractType } from "./AbstractType.js";
 import { removeUndefined } from "./removeUndefined.js";
@@ -23,12 +23,12 @@ export class AbstractTermType extends AbstractType {
     equalsFunction = code `${this.reusables.snippets.booleanEquals}`;
     graphqlArgs = Maybe.empty();
     hasValues;
+    hashFunction = code `${this.reusables.snippets.hashTerm}`;
     in_;
     mutable = false;
     recursive = false;
-    typeofs = NonEmptyList([
-        "object",
-    ]);
+    typeofs = ["object"];
+    validationFunction = Maybe.empty();
     constructor({ hasValues, in_, ...superParameters }) {
         super(superParameters);
         this.hasValues = hasValues;
@@ -37,44 +37,6 @@ export class AbstractTermType extends AbstractType {
     get constrained() {
         return this.hasValues.length > 0 || this.in_.length > 0;
     }
-    get conversions() {
-        const conversions = [];
-        if (this.nodeKinds.has("Literal")) {
-            conversions.push({
-                conversionExpression: (value) => code `${this.reusables.snippets.literalFactory}.bigint(${value})`,
-                sourceTypeCheckExpression: (value) => code `typeof ${value} === "bigint"`,
-                sourceTypeName: code `bigint`,
-                sourceTypeof: "bigint",
-            }, {
-                conversionExpression: (value) => code `${this.reusables.snippets.literalFactory}.boolean(${value})`,
-                sourceTypeCheckExpression: (value) => code `typeof ${value} === "boolean"`,
-                sourceTypeName: code `boolean`,
-                sourceTypeof: "boolean",
-            }, {
-                conversionExpression: (value) => code `${this.reusables.snippets.literalFactory}.date(${value})`,
-                sourceTypeCheckExpression: (value) => code `typeof ${value} === "object" && ${value} instanceof Date`,
-                sourceTypeName: code `Date`,
-                sourceTypeof: "object",
-            }, {
-                conversionExpression: (value) => code `${this.reusables.snippets.literalFactory}.number(${value})`,
-                sourceTypeCheckExpression: (value) => code `typeof ${value} === "number"`,
-                sourceTypeName: code `number`,
-                sourceTypeof: "number",
-            }, {
-                conversionExpression: (value) => code `${this.reusables.snippets.literalFactory}.string(${value})`,
-                sourceTypeCheckExpression: (value) => code `typeof ${value} === "string"`,
-                sourceTypeName: code `string`,
-                sourceTypeof: "string",
-            });
-        }
-        conversions.push({
-            conversionExpression: (value) => value,
-            sourceTypeCheckExpression: (value) => code `typeof ${value} === "object"`,
-            sourceTypeName: this.name,
-            sourceTypeof: "object",
-        });
-        return conversions;
-    }
     get discriminantProperty() {
         return Maybe.of({
             descendantValues: [],
@@ -87,6 +49,14 @@ export class AbstractTermType extends AbstractType {
     get schema() {
         return code `${removeUndefined(this.schemaObject)}`;
     }
+    get schemaObject() {
+        return {
+            ...super.schemaObject,
+            in: this.in_.length > 0
+                ? code `[${joinCode(this.in_.map((in_) => this.rdfjsTermExpression(in_)), { on: ", " })}] as const`
+                : undefined,
+        };
+    }
     get termTypes() {
         return new Set([...this.nodeKinds].map(NodeKind.toTermType));
     }
@@ -102,7 +72,7 @@ export class AbstractTermType extends AbstractType {
         //     (this.nodeKinds.has("BlankNode") || this.nodeKinds.has("NamedNode")),
         //   "IdentifierType and LiteralType should override",
         // );
-        const chain = this.fromRdfExpressionChain(parameters);
+        const chain = this.fromRdfResourceValuesExpressionChain(parameters);
         const { variables } = parameters;
         return joinCode([
             variables.resourceValues,
@@ -112,12 +82,6 @@ export class AbstractTermType extends AbstractType {
             chain.valueTo,
         ].filter((_) => _ !== undefined), { on: "." });
     }
-    hashStatements({ variables, }) {
-        return [
-            code `${variables.hasher}.update(${variables.value}.termType);`,
-            code `${variables.hasher}.update(${variables.value}.value);`,
-        ];
-    }
     jsonUiSchemaElement() {
         return Maybe.empty();
     }
@@ -136,7 +100,7 @@ export class AbstractTermType extends AbstractType {
      *
      * Considering the sub-expressions as a record instead of an array allows them to be selectively overridden by subclasses.
      */
-    fromRdfExpressionChain({ variables, }) {
+    fromRdfResourceValuesExpressionChain({ variables, }) {
         let valueToExpression;
         if (this.in_.length > 0) {
             valueToExpression = code `value.toTerm([${joinCode(this.in_.map((in_) => this.rdfjsTermExpression(in_)), { on: ", " })}])`;
@@ -161,9 +125,6 @@ chain(values => ${this.reusables.imports.Either}.sequence([${joinCode(this.hasVa
         };
     }
 }
-__decorate([
-    Memoize()
-], AbstractTermType.prototype, "conversions", null);
 __decorate([
     Memoize()
 ], AbstractTermType.prototype, "discriminantProperty", null);

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

@@ -1,24 +1,31 @@
-import type { Maybe, NonEmptyList } from "purify-ts";
+import type { Maybe } from "purify-ts";
 import type { Logger } from "ts-log";
 import type { Reusables } from "./Reusables.js";
 import { rdfjsTermExpression } from "./rdfjsTermExpression.js";
+import type { TsGenerator } from "./TsGenerator.js";
 import type { Typeof } from "./Typeof.js";
 import { type Code } from "./ts-poet-wrapper.js";
 /**
  * Abstract base class all types.
  */
 export declare abstract class AbstractType {
+    protected readonly configuration: TsGenerator.Configuration;
     protected readonly logger: Logger;
     protected readonly reusables: Reusables;
-    protected readonly rdfjsTermExpression: (parameters: Parameters<typeof rdfjsTermExpression>[0]) => Code;
     /**
      * Comment from rdfs:comment.
      */
     readonly comment: Maybe<string>;
     /**
-     * Expressions that convert a source type or types to this type. It should include the type itself.
+     * Function that takes a value of one or more source types to this type and returns Either<Error, ThisType>.
+     *
+     * The source types should include this type.
+     *
+     * The function should not perform validation (e.g., checking array lengths). That will be done by validationFunction in conjunction with this function.
+     *
+     * If unspecified, uses an identity function (i.e., function identity(value: ThisType): Either<Error, ThisType>).
      */
-    abstract readonly conversions: readonly AbstractType.Conversion[];
+    abstract readonly conversionFunction: Maybe<AbstractType.ConversionFunction>;
     /**
      * The declaration of named types.
      */
@@ -52,7 +59,11 @@ export declare abstract class AbstractType {
      */
     abstract readonly graphqlType: AbstractType.GraphqlType;
     /**
-     * Type discriminator.
+     * A function (reference or declaration) that takes a  Hasher and a value of this type, calls hasher.update on the value, and returns the Hasher.
+     */
+    abstract readonly hashFunction: Code;
+    /**
+     * Type discriminant.
      */
     abstract readonly kind: string;
     /**
@@ -86,7 +97,19 @@ export declare abstract class AbstractType {
     /**
      * JavaScript typeof(s) the type.
      */
-    abstract readonly typeofs: NonEmptyList<Typeof>;
+    abstract readonly typeofs: readonly Typeof[];
+    /**
+     * Function that takes
+     * - a schema of this.schemaType
+     * - a value of this.type
+     *
+     * and validates the value against the schema, returning
+     * - Left(Error) if validation fails or
+     * - Right(the value) if validatios succeeds
+     *
+     * If unspecified, uses an identity function (i.e., function identity(schema: unknown, value: ThisType): Either<Error, ThisType>).
+     */
+    abstract readonly validationFunction: Maybe<Code>;
     /**
      * A ValueSparqlConstructTriplesFunction (reference or declaration) that returns an array of sparqljs.Triple's for a property value of this type.
      *
@@ -110,8 +133,9 @@ export declare abstract class AbstractType {
      * - variablePrefix: string prefix to use for new variables
      */
     abstract readonly valueSparqlWherePatternsFunction: Code;
-    constructor({ comment, label, logger, reusables, }: {
+    constructor({ comment, configuration, label, logger, reusables, }: {
         comment: Maybe<string>;
+        configuration: TsGenerator.Configuration;
         label: Maybe<string>;
         logger: Logger;
         reusables: Reusables;
@@ -123,8 +147,7 @@ export declare abstract class AbstractType {
         kind: Code;
     };
     /**
-     * An expression that converts this type's JSON type to a value of this type. It doesn't return a Either because the JSON has
-     * already been validated and converted to the expected JSON type with Zod.
+     * An expression that converts this type's JSON type to an Either<Error, ThisType>.
      */
     abstract fromJsonExpression(parameters: {
         variables: {
@@ -175,16 +198,6 @@ export declare abstract class AbstractType {
             value: Code;
         };
     }): Code;
-    /**
-     * Statements that use hasher.update to hash a property value of this type.
-     */
-    abstract hashStatements(parameters: {
-        depth: number;
-        variables: {
-            hasher: Code;
-            value: Code;
-        };
-    }): readonly Code[];
     /**
      * Zod schema for the JSON type of this type.
      *
@@ -250,13 +263,15 @@ export declare abstract class AbstractType {
             value: Code;
         };
     }): Code;
+    protected readonly rdfjsTermExpression: (parameters: Parameters<typeof rdfjsTermExpression>[0]) => Code;
 }
 export declare namespace AbstractType {
-    interface Conversion {
-        readonly conversionExpression: (value: Code) => Code;
-        readonly sourceTypeCheckExpression: (value: Code) => Code;
-        readonly sourceTypeName: Code | string;
-        readonly sourceTypeof: Typeof;
+    interface ConversionFunction {
+        readonly code: Code;
+        readonly sourceTypes: {
+            readonly name: Code | string;
+            readonly typeof: Typeof;
+        }[];
     }
     interface DiscriminantProperty {
         readonly descendantValues: readonly DiscriminantProperty.Value[];

package/dist/generators/ts/AbstractType.js

@@ -12,9 +12,9 @@ import { code, literalOf } from "./ts-poet-wrapper.js";
  * Abstract base class all types.
  */
 export class AbstractType {
+    configuration;
     logger;
     reusables;
-    rdfjsTermExpression;
     /**
      * Comment from rdfs:comment.
      */
@@ -23,8 +23,9 @@ export class AbstractType {
      * Label from rdfs:label.
      */
     label;
-    constructor({ comment, label, logger, reusables, }) {
+    constructor({ comment, configuration, label, logger, reusables, }) {
         this.comment = comment;
+        this.configuration = configuration;
         this.label = label;
         this.logger = logger;
         this.reusables = reusables;
@@ -43,6 +44,7 @@ export class AbstractType {
             kind: code `${literalOf(this.kind.substring(0, this.kind.length - "Type".length))} as const`,
         };
     }
+    rdfjsTermExpression;
 }
 (function (AbstractType) {
     class GraphqlType {

package/dist/generators/ts/AbstractUnionType.d.ts

@@ -10,6 +10,7 @@ export declare abstract class AbstractUnionType<MemberTypeT extends Type> extend
     private readonly discriminant;
     private readonly identifierType;
     readonly recursive: boolean;
+    readonly validationFunction: Maybe<Code>;
     constructor({ identifierType, members, recursive, ...superParameters }: {
         identifierType: Maybe<BlankNodeType | IdentifierType | IriType>;
         members: readonly (Pick<AbstractUnionType.Member<MemberTypeT>, "type"> & {
@@ -17,7 +18,7 @@ export declare abstract class AbstractUnionType<MemberTypeT extends Type> extend
         })[];
         recursive: boolean;
     } & ConstructorParameters<typeof AbstractType>[0]);
-    get conversions(): readonly AbstractType.Conversion[];
+    get conversionFunction(): Maybe<AbstractType.ConversionFunction>;
     get discriminantProperty(): Maybe<AbstractType.DiscriminantProperty>;
     get members(): readonly AbstractUnionType.Member<MemberTypeT>[];
     get mutable(): boolean;
@@ -30,6 +31,7 @@ export declare abstract class AbstractUnionType<MemberTypeT extends Type> extend
     protected get inlineFilterType(): Code;
     protected get inlineFromJsonFunction(): Code;
     protected get inlineFromRdfResourceValuesFunction(): Code;
+    protected get inlineHashFunction(): Code;
     protected get inlineJsonSchema(): Code;
     protected get inlineJsonType(): AbstractType.JsonType;
     protected get inlineName(): Code;
@@ -43,7 +45,6 @@ export declare abstract class AbstractUnionType<MemberTypeT extends Type> extend
         members: Code;
     };
     jsonUiSchemaElement(): Maybe<Code>;
-    protected inlineHashStatements({ depth, variables, }: Parameters<AbstractType["hashStatements"]>[0]): readonly Code[];
     private readonly lazyMembers;
 }
 type Discriminant = ExtrinsicDiscriminant | HybridDiscriminant | IntrinsicDiscriminant | TypeofDiscriminant;

package/dist/generators/ts/AbstractUnionType.js

@@ -4,17 +4,17 @@ 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 { Maybe, NonEmptyList } from "purify-ts";
+import { Maybe } from "purify-ts";
 import { invariant } from "ts-invariant";
 import { Memoize } from "typescript-memoize";
 import { AbstractType } from "./AbstractType.js";
 import { removeUndefined } from "./removeUndefined.js";
-import { syntheticNamePrefix } from "./syntheticNamePrefix.js";
 import { code, joinCode, literalOf } from "./ts-poet-wrapper.js";
 export class AbstractUnionType extends AbstractType {
     discriminant;
     identifierType;
     recursive;
+    validationFunction = Maybe.empty();
     constructor({ identifierType, members, recursive, ...superParameters }) {
         super(superParameters);
         this.identifierType = identifierType;
@@ -130,29 +130,21 @@ export class AbstractUnionType extends AbstractType {
             };
         });
     }
-    get conversions() {
-        switch (this.discriminant.kind) {
-            case "extrinsic":
-            case "hybrid":
-            case "intrinsic":
-                return [
+    get conversionFunction() {
+        return Maybe.of({
+            code: code `${this.reusables.snippets.identityConversionFunction}`,
+            sourceTypes: this.discriminant.kind === "typeof"
+                ? this.members.map(({ primaryDiscriminantValue, type }) => ({
+                    name: type.name,
+                    typeof: primaryDiscriminantValue,
+                }))
+                : [
                     {
-                        conversionExpression: (value) => value,
-                        sourceTypeCheckExpression: (value) => code `typeof ${value} === "object"`,
-                        sourceTypeName: this.name,
-                        sourceTypeof: "object",
+                        name: this.name,
+                        typeof: "object",
                     },
-                ];
-            case "typeof":
-                return this.members.map(({ primaryDiscriminantValue, type, typeCheck }) => ({
-                    conversionExpression: (value) => value,
-                    sourceTypeCheckExpression: (value) => typeCheck(value),
-                    sourceTypeName: type.name,
-                    sourceTypeof: primaryDiscriminantValue,
-                }));
-            default:
-                throw this.discriminant;
-        }
+                ],
+        });
     }
     get discriminantProperty() {
         switch (this.discriminant.kind) {
@@ -215,7 +207,7 @@ export class AbstractUnionType extends AbstractType {
         return set;
     }
     get typeofs() {
-        return NonEmptyList.fromArray(this.members.flatMap((member) => member.type.typeofs)).unsafeCoerce();
+        return [...new Set(this.members.flatMap((member) => member.type.typeofs))];
     }
     get inlineEqualsFunction() {
         return code `\
@@ -228,6 +220,7 @@ ${joinCode(this.members.map(({ type, typeCheck, unwrap }) => code `if (${typeChe
 })`;
     }
     get inlineFilterFunction() {
+        const syntheticNamePrefix = this.configuration.syntheticNamePrefix;
         return code `\
 ((filter: ${this.filterType}, value: ${this.name}) => {
 ${joinCode([
@@ -249,6 +242,7 @@ if (filter.on?.[${literalOf(primaryDiscriminantValue)}] !== undefined && ${typeC
 })`;
     }
     get inlineFilterType() {
+        const syntheticNamePrefix = this.configuration.syntheticNamePrefix;
         return code `\
   {
    ${this.identifierType.map((identifierType) => code `readonly ${syntheticNamePrefix}identifier?: ${identifierType.filterType};`).orDefault(code ``)}
@@ -257,12 +251,12 @@ if (filter.on?.[${literalOf(primaryDiscriminantValue)}] !== undefined && ${typeC
     }
     get inlineFromJsonFunction() {
         return code `\
-((value: ${this.jsonType().name}): ${this.name} => {
-${joinCode(this.members.map(({ jsonType, jsonTypeCheck, type, unwrap, wrap }) => code `if (${jsonTypeCheck(code `value`)}) { return ${wrap(type.fromJsonExpression({
+((value: ${this.jsonType().name}): ${this.reusables.imports.Either}<Error, ${this.name}> => {
+${joinCode(this.members.map(({ jsonType, jsonTypeCheck, type, unwrap, wrap }) => code `if (${jsonTypeCheck(code `value`)}) { return ${type.fromJsonExpression({
             variables: {
                 value: code `(${unwrap(code `value`)} as ${jsonType})`,
             },
-        }))}; }`))}
+        })}.map(value => (${wrap(code `value`)})); }`))}
 
   throw new Error("unable to deserialize JSON");
 })`;
@@ -306,6 +300,13 @@ ${joinCode(this.members.map(({ jsonType, jsonTypeCheck, type, unwrap, wrap }) =>
         }, null)}.chain(values => values.head());
     }))
 ) satisfies ${this.reusables.snippets.FromRdfResourceValuesFunction}<${this.name}>)`;
+    }
+    get inlineHashFunction() {
+        return code `\
+(<HasherT extends ${this.reusables.snippets.Hasher}>(hasher: HasherT, value: ${this.name}): HasherT => {
+${joinCode(this.members.map(({ type, typeCheck, unwrap }) => code `if (${typeCheck(code `value`)}) { return ${type.hashFunction}(hasher, ${unwrap(code `value`)}); }`))}
+  return hasher;
+})`;
     }
     get inlineJsonSchema() {
         const discriminant = this.discriminant; // To get type narrowing to work
@@ -469,22 +470,11 @@ unionPatterns.push({ patterns: ${type.valueSparqlWherePatternsFunction}({ ...oth
     jsonUiSchemaElement() {
         return Maybe.empty();
     }
-    inlineHashStatements({ depth, variables, }) {
-        return this.members.map(({ type, unwrap, typeCheck }) => code `if (${typeCheck(variables.value)}) { ${joinCode(type
-            .hashStatements({
-            depth: depth + 1,
-            variables: {
-                hasher: variables.hasher,
-                value: unwrap(variables.value),
-            },
-        })
-            .concat())} }`);
-    }
     lazyMembers;
 }
 __decorate([
     Memoize()
-], AbstractUnionType.prototype, "conversions", null);
+], AbstractUnionType.prototype, "conversionFunction", null);
 __decorate([
     Memoize()
 ], AbstractUnionType.prototype, "discriminantProperty", null);