@shaclmate/compiler 4.0.50 → 4.0.51

package/dist/generators/ts/UnionType.js

@@ -0,0 +1,850 @@
+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 { AbstractType } from "./AbstractType.js";
+import { code, def, joinCode, literalOf, } from "./ts-poet-wrapper.js";
+export class UnionType extends AbstractType {
+    discriminant;
+    graphqlArgs = Maybe.empty();
+    identifierType;
+    kind = "Union";
+    recursive;
+    synthetic;
+    validationFunction = Maybe.empty();
+    constructor({ identifierType, members, recursive, synthetic, ...superParameters }) {
+        super(superParameters);
+        this.identifierType = identifierType;
+        invariant(members.length >= 2);
+        this.recursive = recursive;
+        this.discriminant = Discriminant.infer(members);
+        this.synthetic = synthetic;
+        this.lazyMembers = () => members.map((member, memberI) => {
+            let discriminantValues;
+            invariant(this.discriminant.memberValues.length === members.length);
+            switch (this.discriminant.kind) {
+                case "Extrinsic":
+                    discriminantValues = [this.discriminant.memberValues[memberI]];
+                    break;
+                case "Hybrid":
+                    discriminantValues = this.discriminant.memberValues[memberI].values;
+                    break;
+                case "Intrinsic": {
+                    discriminantValues =
+                        member.type.discriminantProperty.unsafeCoerce().values;
+                    break;
+                }
+                case "Typeof":
+                    discriminantValues = [this.discriminant.memberValues[memberI]];
+                    break;
+                default:
+                    throw this.discriminant;
+            }
+            invariant(discriminantValues.length > 0);
+            const typeCheck = (json) => (instance) => {
+                const discriminant = this.discriminant; // To get type narrowing to work
+                if (discriminant.kind === "Typeof") {
+                    return code `(${joinCode(discriminantValues.map((discriminantValue) => code `typeof ${instance} === ${literalOf(discriminantValue)}`), { on: " || " })})`;
+                }
+                if (discriminant.kind === "Intrinsic" && !json) {
+                    switch (member.type.kind) {
+                        case "Object":
+                        case "ObjectUnion":
+                            return code `${member.type.name.unsafeCoerce()}.is${member.type.name.unsafeCoerce()}(${instance})`;
+                    }
+                }
+                const discriminantName = json
+                    ? discriminant.jsonName
+                    : discriminant.name;
+                return code `(${joinCode(discriminantValues.map((discriminantValue) => code `${instance}["${discriminantName}"] === ${literalOf(discriminantValue)}`), { on: " || " })})`;
+            };
+            return {
+                discriminantValues,
+                jsonType: member.type.jsonType({
+                    includeDiscriminantProperty: this.discriminant.kind === "Intrinsic" ||
+                        (this.discriminant.kind === "Hybrid" &&
+                            this.discriminant.memberValues[memberI].kind === "Intrinsic"),
+                }).expression,
+                jsonTypeCheck: typeCheck(true),
+                primaryDiscriminantValue: discriminantValues[0],
+                type: member.type,
+                typeCheck: typeCheck(false),
+                typeToJsonExpression: (valueVariable) => member.type.toJsonExpression({
+                    includeDiscriminantProperty: this.discriminant.kind === "Intrinsic" ||
+                        (this.discriminant.kind === "Hybrid" &&
+                            this.discriminant.memberValues[memberI].kind === "Intrinsic"),
+                    variables: { value: valueVariable },
+                }),
+                unwrap: (instance) => {
+                    switch (this.discriminant.kind) {
+                        case "Extrinsic":
+                            return code `${instance}.value`;
+                        case "Hybrid":
+                            return this.discriminant.memberValues[memberI].kind ===
+                                "Intrinsic"
+                                ? instance
+                                : code `${instance}.value`;
+                        case "Intrinsic":
+                        case "Typeof":
+                            return instance;
+                    }
+                },
+                wrap: (instance) => {
+                    switch (this.discriminant.kind) {
+                        case "Extrinsic":
+                            return code `{ ${this.discriminant.name}: ${literalOf(discriminantValues[0])} as const, value: ${instance} }`;
+                        case "Hybrid":
+                            return this.discriminant.memberValues[memberI].kind ===
+                                "Intrinsic"
+                                ? instance
+                                : code `{ ${this.discriminant.name}: ${literalOf(discriminantValues[0])} as const, value: ${instance} }`;
+                        case "Intrinsic":
+                        case "Typeof":
+                            return instance;
+                    }
+                },
+            };
+        });
+    }
+    get conversionFunction() {
+        return Maybe.of({
+            code: code `${this.reusables.snippets.identityConversionFunction}`,
+            sourceTypes: this.discriminant.kind === "Typeof"
+                ? this.members.flatMap(({ type }) => type.jsTypes.map((jsType) => ({
+                    expression: type.expression,
+                    jsType,
+                })))
+                : [
+                    {
+                        expression: this.expression,
+                        jsType: {
+                            instanceof: "Object",
+                            typeof: "object",
+                        },
+                    },
+                ],
+        });
+    }
+    get declaration() {
+        const name = this.name.extract();
+        if (!name) {
+            return Maybe.empty();
+        }
+        const declarations = [];
+        if (this.configuration.features.has("Object.type")) {
+            declarations.push(code `export type ${def(name)} = ${this.inlineExpression};`);
+        }
+        const staticModuleDeclarations = Object.entries(this.staticModuleDeclarations);
+        if (staticModuleDeclarations.length > 0) {
+            declarations.push(code `\
+export namespace ${def(name)} {
+${joinCode(staticModuleDeclarations
+                .sort((left, right) => left[0].localeCompare(right[0]))
+                .map((_) => _[1]), { on: "\n\n" })}
+}`);
+        }
+        return Maybe.of(joinCode(declarations, { on: "\n\n" }));
+    }
+    get discriminantProperty() {
+        switch (this.discriminant.kind) {
+            case "Extrinsic":
+                return Maybe.of({
+                    jsonName: this.discriminant.jsonName,
+                    name: this.discriminant.name,
+                    values: this.discriminant.memberValues,
+                });
+            case "Hybrid":
+                return Maybe.of({
+                    jsonName: this.discriminant.jsonName,
+                    name: "termType",
+                    values: this.discriminant.memberValues.flatMap((_) => _.values),
+                });
+            case "Intrinsic":
+                return Maybe.of({
+                    jsonName: this.discriminant.jsonName,
+                    name: this.discriminant.name,
+                    values: this.discriminant.memberValues,
+                });
+            case "Typeof":
+                return Maybe.empty();
+            default:
+                throw this.discriminant;
+        }
+    }
+    get equalsFunction() {
+        return this.name
+            .map((name) => code `${name}.equals`)
+            .orDefault(this.equalsFunctionExpression);
+    }
+    get expression() {
+        return this.name
+            .map((name) => code `${name}`)
+            .orDefault(this.inlineExpression);
+    }
+    get filterFunction() {
+        return this.name
+            .map((name) => code `${name}.filter`)
+            .orDefault(this.filterFunctionExpression);
+    }
+    get filterType() {
+        return this.name
+            .map((name) => code `${name}.Filter`)
+            .orDefault(this.filterTypeLiteral);
+    }
+    get fromRdfResourceValuesFunction() {
+        return this.name
+            .map((name) => code `${name}.fromRdfResourceValues`)
+            .orDefault(this.fromRdfResourceValuesFunctionExpression);
+    }
+    get graphqlType() {
+        const name = this.name.extract();
+        if (!name ||
+            !this.members.every((member) => member.type.kind === "Object")) {
+            throw new Error("not implemented");
+        }
+        return new AbstractType.GraphqlType(code `${name}.GraphQL`, this.reusables);
+    }
+    get hashFunction() {
+        return this.name
+            .map((name) => code `${name}.hash`)
+            .orDefault(this.hashFunctionExpression);
+    }
+    get jsTypes() {
+        const jsTypes = [];
+        for (const member of this.members) {
+            for (const memberJsType of member.type.jsTypes) {
+                if (!jsTypes.some((jsType) => AbstractType.JsType.equals(jsType, memberJsType))) {
+                    jsTypes.push(memberJsType);
+                }
+            }
+        }
+        return jsTypes;
+    }
+    get jsonSchemaFunctionDeclaration() {
+        let expression = this.jsonSchemaExpression;
+        const meta = {
+        // id: this.name,
+        };
+        this.comment.ifJust((description) => {
+            meta["description"] = description;
+        });
+        this.label.ifJust((label) => {
+            meta["title"] = label;
+        });
+        if (Object.keys(meta).length > 0) {
+            expression = code `${expression}.meta(${meta})`;
+        }
+        return code `export const schema = () => ${expression};`;
+    }
+    get jsonTypeAliasDeclaration() {
+        return code `export type Json = ${this.jsonTypeLiteral.expression}`;
+    }
+    get members() {
+        return this.lazyMembers();
+    }
+    get mutable() {
+        return this.members.some((member) => member.type.mutable);
+    }
+    get referencesNamedType() {
+        return (this.name.isJust() ||
+            this.members.some((member) => member.type.referencesNamedType));
+    }
+    get schema() {
+        return this.name
+            .map((name) => code `${name}.schema`)
+            .orDefault(this.schemaExpression);
+    }
+    get schemaType() {
+        return this.name
+            .map(() => code `typeof ${this.schema}`)
+            .orDefault(this.schemaTypeExpression);
+    }
+    get toRdfResourceValueTypes() {
+        const set = new Set();
+        for (const member of this.members) {
+            for (const value of member.type.toRdfResourceValueTypes) {
+                set.add(value);
+            }
+        }
+        return set;
+    }
+    get valueSparqlConstructTriplesFunction() {
+        return this.name
+            .map((name) => code `${name}.valueSparqlConstructTriples`)
+            .orDefault(this.valueSparqlConstructTriplesFunctionExpression);
+    }
+    get valueSparqlWherePatternsFunction() {
+        return this.name
+            .map((name) => code `${name}.valueSparqlWherePatterns`)
+            .orDefault(this.valueSparqlWherePatternsFunctionExpression);
+    }
+    get schemaInitializers() {
+        return super.schemaInitializers.concat(code `members: { ${joinCode(this.members.map(({ discriminantValues, type, primaryDiscriminantValue }) => code `${literalOf(primaryDiscriminantValue)}: ${{
+            discriminantValues: discriminantValues,
+            type: type.schema,
+        }}`), { on: "," })} }`);
+    }
+    get schemaTypeExpression() {
+        return code `${{
+            kind: this.kind,
+            members: code `{ ${joinCode(this.members.map(({ type, primaryDiscriminantValue }) => code `readonly ${literalOf(primaryDiscriminantValue)}: ${{
+                discriminantValues: code `readonly (number | string)[]`,
+                type: type.schemaType,
+            }}`), { on: ";" })} }`,
+        }}`;
+    }
+    get staticModuleDeclarations() {
+        const name = this.name.unsafeCoerce();
+        const staticModuleDeclarations = {};
+        if (this.configuration.features.has("Object.equals")) {
+            staticModuleDeclarations[`equals`] =
+                code `export const equals = ${this.equalsFunctionExpression};`;
+        }
+        if (this.configuration.features.has("Object.filter")) {
+            staticModuleDeclarations[`Filter`] =
+                code `export type Filter = ${this.filterTypeLiteral};`;
+            staticModuleDeclarations[`filter`] =
+                code `export const filter = ${this.filterFunctionExpression};`;
+        }
+        if (this.configuration.features.has("Object.hash")) {
+            staticModuleDeclarations[`hash`] =
+                code `export const hash = ${this.hashFunctionExpression};`;
+        }
+        if (this.configuration.features.has("Object.JSON.type")) {
+            staticModuleDeclarations[`Json.type`] =
+                code `${this.jsonTypeAliasDeclaration}`;
+        }
+        if (this.configuration.features.has("Object.JSON.schema")) {
+            staticModuleDeclarations[`Json.namespace`] = code `\
+export namespace Json {
+  ${this.jsonSchemaFunctionDeclaration}
+
+  export function parse(json: unknown): ${this.reusables.imports.Either}<Error, Json> {
+    const jsonSafeParseResult = schema().safeParse(json);
+    if (!jsonSafeParseResult.success) { return ${this.reusables.imports.Left}(jsonSafeParseResult.error); }
+    return ${this.reusables.imports.Right}(jsonSafeParseResult.data);
+  }
+}`;
+        }
+        if (this.configuration.features.has("Object.fromJson")) {
+            staticModuleDeclarations[`fromJson`] =
+                code `export const fromJson = ${this.fromJsonFunctionExpression};`;
+        }
+        if (this.configuration.features.has("Object.fromRdf")) {
+            staticModuleDeclarations[`fromRdfResourceValues`] =
+                code `export const fromRdfResourceValues: ${this.reusables.snippets.FromRdfResourceValuesFunction}<${name}, ${this.schemaType}> = ${this.fromRdfResourceValuesFunctionExpression};`;
+        }
+        if (this.configuration.features.has("Object.schema")) {
+            staticModuleDeclarations["schema"] =
+                code `export const schema = ${this.schemaExpression}`;
+        }
+        if (this.configuration.features.has("Object.toJson")) {
+            staticModuleDeclarations[`toJson`] =
+                code `export const toJson = ${this.toJsonFunctionExpression};`;
+        }
+        if (this.configuration.features.has("Object.toRdf")) {
+            staticModuleDeclarations[`toRdfResourceValues`] =
+                code `export const toRdfResourceValues = ${this.toRdfResourceValuesFunctionExpression};`;
+        }
+        if (this.configuration.features.has("Object.SPARQL")) {
+            staticModuleDeclarations[`valueSparqlConstructTriples`] =
+                code `export const valueSparqlConstructTriples: ${this.reusables.snippets.ValueSparqlConstructTriplesFunction}<${this.filterType}, ${this.schemaType}> = ${this.valueSparqlConstructTriplesFunctionExpression};`;
+            staticModuleDeclarations[`valueSparqlWherePatterns`] =
+                code `export const valueSparqlWherePatterns: ${this.reusables.snippets.ValueSparqlWherePatternsFunction}<${this.filterType}, ${this.schemaType}> = ${this.valueSparqlWherePatternsFunctionExpression};`;
+        }
+        if (this.configuration.features.has("Object.toString")) {
+            const syntheticNamePrefix = this.configuration.syntheticNamePrefix;
+            staticModuleDeclarations[`${syntheticNamePrefix}toString`] =
+                code `export const ${syntheticNamePrefix}toString = ${this.toStringFunctionExpression};`;
+        }
+        return staticModuleDeclarations;
+    }
+    get equalsFunctionExpression() {
+        return code `\
+((left: ${this.expression}, right: ${this.expression}) => {
+${joinCode(this.members.map(({ type, typeCheck, unwrap }) => code `if (${typeCheck(code `left`)} && ${typeCheck(code `right`)}) {
+  return ${type.equalsFunction}(${unwrap(code `left`)} as ${type.expression}, ${unwrap(code `right`)} as ${type.expression});
+}`))}
+
+  return ${this.reusables.imports.Left}({ left, right, propertyName: "type", propertyValuesUnequal: { left: typeof left, right: typeof right, type: "boolean" as const }, type: "property" as const });
+})`;
+    }
+    get filterFunctionExpression() {
+        const syntheticNamePrefix = this.configuration.syntheticNamePrefix;
+        return code `\
+((filter: ${this.filterType}, value: ${this.expression}) => {
+${joinCode([
+            ...this.identifierType
+                .map((identifierType) => code `\
+if (filter.${syntheticNamePrefix}identifier !== undefined && !${identifierType.filterFunction}(filter.${syntheticNamePrefix}identifier, value.${syntheticNamePrefix}identifier())) {
+  return false;
+}`)
+                .toList(),
+            ...this.members.map(({ primaryDiscriminantValue, type, typeCheck, unwrap }) => code `\
+if (filter.on?.[${literalOf(primaryDiscriminantValue)}] !== undefined && ${typeCheck(code `value`)}) {
+  if (!${type.filterFunction}(filter.on[${literalOf(primaryDiscriminantValue)}], ${unwrap(code `value`)})) {
+    return false;
+  }
+}`),
+        ])}
+
+  return true;
+})`;
+    }
+    get filterTypeLiteral() {
+        const syntheticNamePrefix = this.configuration.syntheticNamePrefix;
+        return code `\
+  {
+   ${this.identifierType.map((identifierType) => code `readonly ${syntheticNamePrefix}identifier?: ${identifierType.filterType};`).orDefault(code ``)}
+   readonly on?: { ${joinCode(this.members.map(({ type, primaryDiscriminantValue }) => code `readonly ${literalOf(primaryDiscriminantValue)}?: ${type.filterType}`), { on: ";" })} }
+  }`;
+    }
+    get fromJsonFunctionExpression() {
+        return code `\
+((value: ${this.jsonType().expression}): ${this.reusables.imports.Either}<Error, ${this.expression}> => {
+${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");
+})`;
+    }
+    get fromRdfResourceValuesFunctionExpression() {
+        return code `\
+(((values, options) =>
+  values.chainMap(value => {
+    const valueAsValues = value.toValues();
+    return ${this.members.reduce((expression, { type, primaryDiscriminantValue }, memberI) => {
+            let typeExpression = code `${type.fromRdfResourceValuesFunction}(valueAsValues, { ...options, schema: options.schema.members[${literalOf(primaryDiscriminantValue)}].type })`;
+            if (this.discriminant.kind === "Extrinsic" ||
+                (this.discriminant.kind === "Hybrid" &&
+                    this.discriminant.memberValues[memberI].kind === "Extrinsic")) {
+                typeExpression = code `${typeExpression}.map(values => values.map(value => ({ ${this.discriminant.name}: ${literalOf(primaryDiscriminantValue)} as const, value }) as (${this.expression})))`;
+            }
+            typeExpression = code `(${typeExpression} as ${this.reusables.imports.Either}<Error, ${this.reusables.imports.Resource}.Values<${this.expression}>>)`;
+            return expression !== null
+                ? code `${expression}.altLazy(() => ${typeExpression})`
+                : typeExpression;
+        }, null)}.chain(values => values.head());
+  })
+) satisfies ${this.reusables.snippets.FromRdfResourceValuesFunction}<${this.expression}, ${this.schemaType}>)`;
+    }
+    get hashFunctionExpression() {
+        return code `\
+(<HasherT extends ${this.reusables.snippets.Hasher}>(hasher: HasherT, value: ${this.expression}): HasherT => {
+${joinCode(this.members.map(({ type, typeCheck, unwrap }) => code `if (${typeCheck(code `value`)}) { return ${type.hashFunction}(hasher, ${unwrap(code `value`)}); }`))}
+  return hasher;
+})`;
+    }
+    /**
+     * An inline expression of this type rather than a type reference/name.
+     */
+    get inlineExpression() {
+        const discriminant = this.discriminant; // To get type narrowing to work
+        switch (discriminant.kind) {
+            case "Extrinsic":
+                return code `(${joinCode(this.members.map(({ type, primaryDiscriminantValue }) => code `{ ${discriminant.name}: ${literalOf(primaryDiscriminantValue)}, value: ${type.expression} }`), { on: "|" })})`;
+            case "Hybrid":
+                return code `(${joinCode(this.members.map(({ primaryDiscriminantValue, type }, memberI) => {
+                    switch (discriminant.memberValues[memberI].kind) {
+                        case "Extrinsic":
+                            return code `{ ${discriminant.name}: ${literalOf(primaryDiscriminantValue)}, value: ${type.expression} }`;
+                        case "Intrinsic":
+                            return code `${type.expression}`;
+                        default:
+                            throw new Error();
+                    }
+                }), { on: "|" })})`;
+            case "Intrinsic":
+                // If every type shares a discriminant (e.g., RDF/JS "termType" or generated ObjectType "type"),
+                // just join their names with "|"
+                return code `(${joinCode(this.members.map(({ type }) => code `${type.expression}`), { on: "|" })})`;
+            case "Typeof":
+                // The type.name may include literal values, but they should still be unambiguous with other member types since the typeofs
+                // of the different member types are known to be different.
+                return code `(${joinCode(this.members.map(({ type }) => code `${type.expression}`), { on: "|" })})`;
+            default:
+                discriminant;
+                throw new Error("should never reach this point");
+        }
+    }
+    get jsonSchemaExpression() {
+        const discriminant = this.discriminant; // To get type narrowing to work
+        switch (discriminant.kind) {
+            case "Extrinsic":
+                return code `${this.reusables.imports.z}.discriminatedUnion("${discriminant.name}", [${joinCode(this.members.map(({ type, primaryDiscriminantValue }) => code `${this.reusables.imports.z}.object({ ${discriminant.name}: ${this.reusables.imports.z}.literal(${literalOf(primaryDiscriminantValue)}), value: ${type.jsonSchema({ context: "type" })} })`), { on: "," })}]).readonly()`;
+            case "Hybrid":
+                return code `${this.reusables.imports.z}.discriminatedUnion("${discriminant.name}", [${joinCode(this.members.map(({ primaryDiscriminantValue, type }, memberI) => {
+                    switch (discriminant.memberValues[memberI].kind) {
+                        case "Extrinsic":
+                            return code `${this.reusables.imports.z}.object({ ${discriminant.name}: ${this.reusables.imports.z}.literal(${literalOf(primaryDiscriminantValue)}), value: ${type.jsonSchema({ context: "type" })} })`;
+                        case "Intrinsic":
+                            return type.jsonSchema({
+                                includeDiscriminantProperty: true,
+                                context: "type",
+                            });
+                        default:
+                            throw new Error();
+                    }
+                }), { on: "," })}]).readonly()`;
+            case "Intrinsic":
+                return code `${this.reusables.imports.z}.discriminatedUnion("${discriminant.name}", [${joinCode(this.members.map(({ type }) => type.jsonSchema({
+                    includeDiscriminantProperty: true,
+                    context: "type",
+                })), { on: "," })}]).readonly()`;
+            case "Typeof":
+                return code `${this.reusables.imports.z}.union([${joinCode(this.members.map(({ type }) => type.jsonSchema({ context: "type" })), { on: "," })}]).readonly()`;
+            default:
+                throw discriminant;
+        }
+    }
+    get jsonTypeLiteral() {
+        const discriminant = this.discriminant; // To get type narrowing to work
+        switch (discriminant.kind) {
+            case "Extrinsic":
+                return new AbstractType.JsonType(code `(${joinCode(this.members.map(({ jsonType, primaryDiscriminantValue }) => code `{ ${discriminant.name}: ${literalOf(primaryDiscriminantValue)}, value: ${jsonType} }`), { on: "|" })})`);
+            case "Hybrid":
+                return new AbstractType.JsonType(code `(${joinCode(this.members.map(({ jsonType, primaryDiscriminantValue }, memberI) => {
+                    switch (discriminant.memberValues[memberI].kind) {
+                        case "Extrinsic":
+                            return code `{ ${discriminant.name}: ${literalOf(primaryDiscriminantValue)}, value: ${jsonType} }`;
+                        case "Intrinsic":
+                            return code `${jsonType}`;
+                        default:
+                            throw new Error();
+                    }
+                }), { on: "|" })})`);
+            case "Intrinsic":
+            case "Typeof":
+                return new AbstractType.JsonType(joinCode(this.members.map(({ jsonType }) => code `${jsonType}`), { on: "|" }));
+            default:
+                throw discriminant;
+        }
+    }
+    get toJsonFunctionExpression() {
+        return code `\
+((value: ${this.expression}): ${this.jsonType().expression} => {
+${joinCode(this.members.map(({ typeCheck, typeToJsonExpression, unwrap, wrap }) => code `if (${typeCheck(code `value`)}) { return ${wrap(typeToJsonExpression(unwrap(code `value`)))}; }`))}
+
+  throw new Error("unable to serialize to JSON");
+})`;
+    }
+    get toRdfResourceValuesFunctionExpression() {
+        return code `\
+(((value, _options): (${joinCode([...this.toRdfResourceValueTypes].map((toRdfResourceValueType) => {
+            switch (toRdfResourceValueType) {
+                case "BlankNode":
+                    return code `${this.reusables.imports.BlankNode}`;
+                case "Literal":
+                    return code `${this.reusables.imports.Literal}`;
+                case "NamedNode":
+                    return code `${this.reusables.imports.NamedNode}`;
+                default:
+                    toRdfResourceValueType;
+                    throw new Error();
+            }
+        }), { on: " | " })})[] => {
+${joinCode(this.members.map(({ type, unwrap, typeCheck }) => code `if (${typeCheck(code `value`)}) { return ${type.toRdfResourceValuesExpression({
+            variables: {
+                graph: code `_options.graph`,
+                propertyPath: code `_options.propertyPath`,
+                resource: code `_options.resource`,
+                resourceSet: code `_options.resourceSet`,
+                value: unwrap(code `value`),
+            },
+        })}; }`))}
+
+  throw new Error("unable to serialize to RDF");
+}) satisfies ${this.reusables.snippets.ToRdfResourceValuesFunction}<${this.expression}>)`;
+    }
+    get toStringFunctionExpression() {
+        return code `\
+((value: ${this.expression}): string => {
+${joinCode(this.members.map(({ type, typeCheck, unwrap }) => code `if (${typeCheck(code `value`)}) { return ${type.toStringExpression({
+            variables: { value: unwrap(code `value`) },
+        })}; }`))}
+
+  throw new Error("unable to serialize to string");
+})`;
+    }
+    get valueSparqlConstructTriplesFunctionExpression() {
+        return code `\
+((({ ignoreRdfType, filter, schema, ...otherParameters }) => {
+  let triples: ${this.reusables.imports.sparqljs}.Triple[] = [];
+
+  ${joinCode(this.members.map(({ type, primaryDiscriminantValue }) => code `\
+triples = triples.concat(${type.valueSparqlConstructTriplesFunction}({ ...otherParameters, filter: filter?.on?.[${literalOf(primaryDiscriminantValue)}], ignoreRdfType: false, schema: schema.members[${literalOf(primaryDiscriminantValue)}].type }));`))}
+  
+  return triples;
+}) satisfies ${this.reusables.snippets.ValueSparqlConstructTriplesFunction}<${this.filterType}, ${this.schemaType}>)`;
+    }
+    get valueSparqlWherePatternsFunctionExpression() {
+        return code `\
+((({ filter, schema, ...otherParameters }) => {
+  const unionPatterns: ${this.reusables.imports.sparqljs}.GroupPattern[] = [];
+
+  ${joinCode(this.members.map(({ type, primaryDiscriminantValue }) => code `\
+unionPatterns.push({ patterns: ${type.valueSparqlWherePatternsFunction}({ ...otherParameters, filter: filter?.on?.[${literalOf(primaryDiscriminantValue)}], ignoreRdfType: false, schema: schema.members[${literalOf(primaryDiscriminantValue)}].type }).concat(), type: "group" });`))}
+  
+  return [{ patterns: unionPatterns, type: "union" }];
+}) satisfies ${this.reusables.snippets.ValueSparqlWherePatternsFunction}<${this.filterType}, ${this.schemaType}>)`;
+    }
+    fromJsonExpression({ variables, }) {
+        return code `${this.name.map((name) => code `${name}.fromJson`).orDefault(this.fromJsonFunctionExpression)}(${variables.value})`;
+    }
+    graphqlResolveExpression({ variables, }) {
+        return variables.value;
+    }
+    jsonSchema({ context, }) {
+        const expression = this.name
+            .map((name) => code `${name}.Json.schema()`)
+            .orDefault(this.jsonSchemaExpression);
+        if (context === "property" && this.recursive) {
+            return code `${this.reusables.imports.z}.lazy((): ${this.reusables.imports.z}.ZodType<${this.jsonType().expression}> => ${expression})`;
+        }
+        return expression;
+    }
+    jsonType() {
+        return this.name
+            .map((name) => new AbstractType.JsonType(code `${name}.Json`))
+            .orDefault(this.jsonTypeLiteral);
+    }
+    jsonUiSchemaElement() {
+        return Maybe.empty();
+    }
+    toJsonExpression({ variables, }) {
+        return code `${this.name.map((name) => code `${name}.toJson`).orDefault(this.toJsonFunctionExpression)}(${variables.value})`;
+    }
+    toRdfResourceValuesExpression({ variables, }) {
+        const { value: valueVariable, ...otherVariables } = variables;
+        return code `${this.name.map((name) => code `${name}.toRdfResourceValues`).orDefault(this.toRdfResourceValuesFunctionExpression)}(${valueVariable}, ${otherVariables})`;
+    }
+    toStringExpression({ variables, }) {
+        return code `${this.name.map((name) => code `${name}.${this.configuration.syntheticNamePrefix}toString`).orDefault(this.toStringFunctionExpression)}(${variables.value})`;
+    }
+    lazyMembers;
+}
+__decorate([
+    Memoize()
+], UnionType.prototype, "conversionFunction", null);
+__decorate([
+    Memoize()
+], UnionType.prototype, "declaration", null);
+__decorate([
+    Memoize()
+], UnionType.prototype, "discriminantProperty", null);
+__decorate([
+    Memoize()
+], UnionType.prototype, "equalsFunction", null);
+__decorate([
+    Memoize()
+], UnionType.prototype, "expression", null);
+__decorate([
+    Memoize()
+], UnionType.prototype, "filterFunction", null);
+__decorate([
+    Memoize()
+], UnionType.prototype, "filterType", null);
+__decorate([
+    Memoize()
+], UnionType.prototype, "fromRdfResourceValuesFunction", null);
+__decorate([
+    Memoize()
+], UnionType.prototype, "graphqlType", null);
+__decorate([
+    Memoize()
+], UnionType.prototype, "hashFunction", null);
+__decorate([
+    Memoize()
+], UnionType.prototype, "jsTypes", null);
+__decorate([
+    Memoize()
+], UnionType.prototype, "members", null);
+__decorate([
+    Memoize()
+], UnionType.prototype, "mutable", null);
+__decorate([
+    Memoize()
+], UnionType.prototype, "schema", null);
+__decorate([
+    Memoize()
+], UnionType.prototype, "schemaType", null);
+__decorate([
+    Memoize()
+], UnionType.prototype, "toRdfResourceValueTypes", null);
+__decorate([
+    Memoize()
+], UnionType.prototype, "valueSparqlConstructTriplesFunction", null);
+__decorate([
+    Memoize()
+], UnionType.prototype, "valueSparqlWherePatternsFunction", null);
+__decorate([
+    Memoize()
+], UnionType.prototype, "schemaTypeExpression", null);
+__decorate([
+    Memoize()
+], UnionType.prototype, "equalsFunctionExpression", null);
+__decorate([
+    Memoize()
+], UnionType.prototype, "filterFunctionExpression", null);
+__decorate([
+    Memoize()
+], UnionType.prototype, "filterTypeLiteral", null);
+__decorate([
+    Memoize()
+], UnionType.prototype, "inlineExpression", null);
+__decorate([
+    Memoize()
+], UnionType.prototype, "jsonTypeLiteral", null);
+__decorate([
+    Memoize()
+], UnionType.prototype, "valueSparqlConstructTriplesFunctionExpression", null);
+__decorate([
+    Memoize()
+], UnionType.prototype, "valueSparqlWherePatternsFunctionExpression", null);
+__decorate([
+    Memoize()
+], UnionType.prototype, "jsonType", null);
+function termTypes(type) {
+    switch (type.kind) {
+        case "BlankNode":
+        case "Iri":
+        case "Identifier":
+        case "Literal":
+        case "Term":
+            return type.termTypes;
+        default:
+            return emptyTermTypesSet;
+    }
+}
+const emptyTermTypesSet = new Set();
+export var Discriminant;
+(function (Discriminant) {
+    function infer(members) {
+        // extrinsic with user-specified values
+        if (members.some((member) => member.discriminantValue.isJust())) {
+            return {
+                jsonName: "type",
+                kind: "Extrinsic",
+                memberValues: members.map((member, memberI) => member.discriminantValue.orDefault(memberI)),
+                name: "type",
+            };
+        }
+        const memberTypes = members.map((member) => member.type);
+        // intrinsic
+        {
+            let inlineDiscriminantProperty;
+            let memberValues = [];
+            for (const memberType of memberTypes) {
+                const memberTypeDiscriminantProperty = memberType.discriminantProperty.extract();
+                if (!memberTypeDiscriminantProperty) {
+                    inlineDiscriminantProperty = undefined;
+                    break;
+                }
+                if (!inlineDiscriminantProperty) {
+                    inlineDiscriminantProperty = memberTypeDiscriminantProperty;
+                }
+                else if (memberTypeDiscriminantProperty.name !==
+                    inlineDiscriminantProperty.name) {
+                    inlineDiscriminantProperty = undefined;
+                    break;
+                }
+                memberValues = memberValues.concat(memberTypeDiscriminantProperty.values);
+            }
+            if (inlineDiscriminantProperty) {
+                return {
+                    jsonName: inlineDiscriminantProperty.jsonName,
+                    kind: "Intrinsic",
+                    memberValues,
+                    name: inlineDiscriminantProperty.name,
+                };
+            }
+        }
+        // typeof
+        {
+            const memberTypeofs = [];
+            const memberTypeofsSet = new Set();
+            for (const memberType of memberTypes) {
+                for (const memberJsType of memberType.jsTypes) {
+                    memberTypeofs.push(memberJsType.typeof);
+                    memberTypeofsSet.add(memberJsType.typeof);
+                }
+            }
+            if (memberTypeofsSet.size === memberTypes.length) {
+                return {
+                    memberValues: memberTypeofs,
+                    kind: "Typeof",
+                };
+            }
+        }
+        // hybrid
+        // If some member type is an RDF/JS term then reuse "termType" as the discriminant.
+        if (memberTypes.some((memberType) => termTypes(memberType).size > 0)) {
+            const extrinsicMemberTypeAliasesSet = new Set();
+            let extrinsicMemberTypeCount = 0;
+            for (const memberType of memberTypes) {
+                if (termTypes(memberType).size > 0) {
+                    continue;
+                }
+                extrinsicMemberTypeCount++;
+                if (memberType.name.isJust()) {
+                    extrinsicMemberTypeAliasesSet.add(memberType.name.extract());
+                }
+                else {
+                    break;
+                }
+            }
+            return {
+                jsonName: "termType",
+                kind: "Hybrid",
+                memberValues: memberTypes.map((memberType, memberTypeI) => {
+                    const memberTermTypes = termTypes(memberType);
+                    if (memberTermTypes.size > 0) {
+                        return {
+                            kind: "Intrinsic",
+                            values: [...memberTermTypes],
+                        };
+                    }
+                    return {
+                        kind: "Extrinsic",
+                        values: extrinsicMemberTypeAliasesSet.size === extrinsicMemberTypeCount
+                            ? [memberType.name.unsafeCoerce()]
+                            : [memberTypeI.toString()],
+                    };
+                }),
+                name: "termType",
+            };
+        }
+        // extrinsic with inferred values
+        {
+            let memberValues;
+            {
+                const memberTypeNames = memberTypes.map((memberType) => memberType.name.orDefault(memberType.jsTypes[0].typeof));
+                const memberTypeNamesSet = new Set(memberTypeNames);
+                if (memberTypeNamesSet.size === memberTypeNames.length) {
+                    memberValues = memberTypeNames;
+                }
+                else {
+                    // Otherwise prefix the non-unique strings with an index and use those as the discriminant values.
+                    memberValues = memberTypeNames.map((memberTypeName, memberTypeI) => `${memberTypeI}-${memberTypeName}`);
+                }
+            }
+            invariant(memberValues.length === memberTypes.length);
+            return {
+                jsonName: "type",
+                kind: "Extrinsic",
+                name: "type",
+                memberValues,
+            };
+        }
+    }
+    Discriminant.infer = infer;
+})(Discriminant || (Discriminant = {}));
+//# sourceMappingURL=UnionType.js.map