@shaclmate/compiler 4.0.49 → 4.0.50

package/dist/generators/ts/UnionType.js

@@ -1,850 +0,0 @@
-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