@shaclmate/compiler 4.0.7 → 4.0.9

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

@@ -0,0 +1,80 @@
+import { Maybe } from "purify-ts";
+import { AbstractType } from "./AbstractType.js";
+import type { BlankNodeType } from "./BlankNodeType.js";
+import type { IdentifierType } from "./IdentifierType.js";
+import type { IriType } from "./IriType.js";
+import type { Type } from "./Type.js";
+import { type Code } from "./ts-poet-wrapper.js";
+export declare abstract class AbstractUnionType<MemberTypeT extends Type> extends AbstractType {
+    private readonly discriminant;
+    private readonly identifierType;
+    readonly abstract = false;
+    private readonly lazyMembers;
+    readonly recursive: boolean;
+    constructor({ identifierType, members, recursive, ...superParameters }: {
+        identifierType: Maybe<BlankNodeType | IdentifierType | IriType>;
+        members: readonly (Pick<AbstractUnionType.Member<MemberTypeT>, "type"> & {
+            readonly discriminantValue: Maybe<number | string>;
+        })[];
+        recursive: boolean;
+    } & ConstructorParameters<typeof AbstractType>[0]);
+    get conversions(): readonly AbstractType.Conversion[];
+    get discriminantProperty(): Maybe<AbstractType.DiscriminantProperty>;
+    get members(): readonly AbstractUnionType.Member<MemberTypeT>[];
+    get mutable(): boolean;
+    get schema(): Code;
+    get schemaType(): Code;
+    get typeofs(): AbstractType["typeofs"];
+    protected get concreteMembers(): readonly AbstractUnionType.ConcreteMember<MemberTypeT>[];
+    protected get inlineEqualsFunction(): Code;
+    protected get inlineFilterFunction(): Code;
+    protected get inlineFilterType(): Code;
+    protected get inlineFromJsonFunction(): Code;
+    protected get inlineFromRdfResourceValuesFunction(): Code;
+    protected get inlineJsonType(): AbstractType.JsonType;
+    protected get inlineJsonZodSchema(): Code;
+    protected get inlineName(): Code;
+    protected get inlineValueSparqlConstructTriplesFunction(): Code;
+    protected get inlineValueSparqlWherePatternsFunction(): Code;
+    protected get inlineToJsonFunction(): Code;
+    protected get inlineToRdfResourceValuesFunction(): Code;
+    protected get schemaObject(): {
+        kind: Code;
+        members: Code;
+    };
+    jsonUiSchemaElement(): Maybe<Code>;
+    protected inlineHashStatements({ depth, variables, }: Parameters<AbstractType["hashStatements"]>[0]): readonly Code[];
+}
+type Discriminant = EnvelopeDiscriminant | InlineDiscriminant | TypeofDiscriminant;
+type EnvelopeDiscriminant = {
+    kind: "envelope";
+} & AbstractType.DiscriminantProperty;
+type InlineDiscriminant = {
+    kind: "inline";
+} & AbstractType.DiscriminantProperty;
+type TypeofDiscriminant = {
+    kind: "typeof";
+};
+export declare namespace Discriminant {
+    function infer(memberTypes: readonly Type[]): Discriminant;
+}
+export declare namespace AbstractUnionType {
+    interface AbstractMember<TypeT extends Type> {
+        readonly abstract: true;
+        readonly discriminantValues: readonly AbstractType.DiscriminantProperty.Value[];
+        readonly type: TypeT;
+    }
+    interface ConcreteMember<TypeT extends Type> {
+        readonly abstract: false;
+        readonly discriminantValues: readonly AbstractType.DiscriminantProperty.Value[];
+        readonly jsonTypeCheck: (instance: Code) => Code;
+        readonly primaryDiscriminantValue: AbstractType.DiscriminantProperty.Value;
+        readonly type: TypeT;
+        readonly typeCheck: (instance: Code) => Code;
+        readonly unwrap: (instance: Code) => Code;
+        readonly wrap: (instance: Code) => Code;
+    }
+    type Member<TypeT extends Type> = AbstractMember<TypeT> | ConcreteMember<TypeT>;
+}
+export {};
+//# sourceMappingURL=AbstractUnionType.d.ts.map

package/dist/generators/ts/AbstractUnionType.js

@@ -0,0 +1,514 @@
+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, NonEmptyList } from "purify-ts";
+import { invariant } from "ts-invariant";
+import { Memoize } from "typescript-memoize";
+import { AbstractType } from "./AbstractType.js";
+import { imports } from "./imports.js";
+import { removeUndefined } from "./removeUndefined.js";
+import { snippets } from "./snippets.js";
+import { syntheticNamePrefix } from "./syntheticNamePrefix.js";
+import { code, joinCode, literalOf } from "./ts-poet-wrapper.js";
+export class AbstractUnionType extends AbstractType {
+    discriminant;
+    identifierType;
+    abstract = false;
+    lazyMembers;
+    recursive;
+    constructor({ identifierType, members, recursive, ...superParameters }) {
+        super(superParameters);
+        this.identifierType = identifierType;
+        invariant(members.length >= 2);
+        this.recursive = recursive;
+        if (members.some((member) => member.discriminantValue.isJust())) {
+            this.discriminant = {
+                descendantValues: [],
+                kind: "envelope",
+                name: "type",
+                ownValues: members.map((member, memberI) => member.discriminantValue.orDefault(memberI)),
+            };
+        }
+        else {
+            this.discriminant = Discriminant.infer(members.map((member) => member.type));
+        }
+        this.lazyMembers = () => members.map((member, memberI) => {
+            if (member.type.abstract) {
+                return { abstract: true, discriminantValues: [], type: member.type };
+            }
+            let discriminantValues;
+            switch (this.discriminant.kind) {
+                case "envelope":
+                    discriminantValues = [this.discriminant.ownValues[memberI]];
+                    break;
+                case "inline": {
+                    // A member type's combined discriminant property values are its "own" values plus any descendant values that are
+                    // not the "own" values of some other member type.
+                    // So if you have type A, type B, and B inherits A, then
+                    // A has
+                    //   own discriminant property values: ["A"]
+                    //   descendant discriminant property values: ["B"]
+                    // and B has
+                    //  own discriminant property values: ["B"]
+                    //  descendant discriminant property values ["B"]
+                    // In this case A shouldn't have "B" as a combined discriminant property value since it's "claimed" by B.
+                    const memberOwnDiscriminantPropertyValues = new Set();
+                    for (const member of members) {
+                        for (const ownDiscriminantPropertyValue of member.type.discriminantProperty.unsafeCoerce()
+                            .ownValues) {
+                            memberOwnDiscriminantPropertyValues.add(ownDiscriminantPropertyValue);
+                        }
+                    }
+                    discriminantValues = member.type.discriminantProperty
+                        .unsafeCoerce()
+                        .ownValues.concat(member.type.discriminantProperty
+                        .unsafeCoerce()
+                        .descendantValues.filter((value) => !memberOwnDiscriminantPropertyValues.has(value)));
+                    break;
+                }
+                case "typeof":
+                    discriminantValues = member.type.typeofs;
+                    break;
+                default:
+                    throw this.discriminant;
+            }
+            if (discriminantValues.length === 0) {
+                return { abstract: true, discriminantValues: [], type: member.type };
+            }
+            const typeCheck = (json) => (instance) => {
+                switch (this.discriminant.kind) {
+                    case "envelope":
+                        return code `(${joinCode(discriminantValues.map((discriminantValue) => code `${instance}.${this.discriminant.name} === ${literalOf(discriminantValue)}`), { on: " || " })})`;
+                    case "inline": {
+                        if (!json) {
+                            switch (member.type.kind) {
+                                case "NamedObjectUnionType":
+                                case "NamedUnionType":
+                                case "ObjectType":
+                                    return code `${member.type.staticModuleName}.is${member.type.name}(${instance})`;
+                            }
+                        }
+                        return code `(${joinCode(discriminantValues.map((discriminantValue) => code `${instance}.${this.discriminant.name} === ${literalOf(discriminantValue)}`), { on: " || " })})`;
+                    }
+                    case "typeof":
+                        return code `(${joinCode(discriminantValues.map((discriminantValue) => code `typeof ${instance} === ${literalOf(discriminantValue)}`), { on: " || " })})`;
+                }
+            };
+            return {
+                abstract: false,
+                discriminantValues,
+                jsonTypeCheck: typeCheck(true),
+                primaryDiscriminantValue: discriminantValues[0],
+                type: member.type,
+                typeCheck: typeCheck(false),
+                unwrap: (instance) => {
+                    switch (this.discriminant.kind) {
+                        case "envelope":
+                            return code `${instance}.value`;
+                        case "inline":
+                        case "typeof":
+                            return instance;
+                    }
+                },
+                wrap: (instance) => {
+                    switch (this.discriminant.kind) {
+                        case "envelope":
+                            return code `{ ${this.discriminant.name}: "${discriminantValues[0]}" as const, value: ${instance} }`;
+                        case "inline":
+                        case "typeof":
+                            return instance;
+                    }
+                },
+            };
+        });
+    }
+    get conversions() {
+        switch (this.discriminant.kind) {
+            case "envelope":
+            case "inline":
+                return [
+                    {
+                        conversionExpression: (value) => value,
+                        sourceTypeCheckExpression: (value) => code `typeof ${value} === "object"`,
+                        sourceTypeName: this.name,
+                        sourceTypeof: "object",
+                    },
+                ];
+            case "typeof":
+                return this.concreteMembers.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) {
+            case "envelope":
+            case "inline":
+                return Maybe.of(this.discriminant);
+            case "typeof":
+                return Maybe.empty();
+            default:
+                throw this.discriminant;
+        }
+    }
+    get members() {
+        return this.lazyMembers();
+    }
+    get mutable() {
+        return this.members.some((member) => member.type.mutable);
+    }
+    get schema() {
+        return code `${removeUndefined(this.schemaObject)}`;
+    }
+    get schemaType() {
+        invariant(this.kind.endsWith("Type"));
+        return code `${{
+            // discriminant: {
+            //   kind: '"envelope" | "inline" | "typeof"',
+            // },
+            kind: code `${literalOf(this.kind.substring(0, this.kind.length - "Type".length))}`,
+            members: code `{ ${joinCode(this.concreteMembers.map(({ type, primaryDiscriminantValue }) => code `readonly ${literalOf(primaryDiscriminantValue)}: ${{
+                discriminantValues: code `readonly (number | string)[]`,
+                type: type.schemaType,
+            }}`), { on: ";" })} }`,
+        }}`;
+    }
+    get typeofs() {
+        return NonEmptyList.fromArray(this.concreteMembers.flatMap((member) => member.type.typeofs)).unsafeCoerce();
+    }
+    get concreteMembers() {
+        return this.members.filter((member) => !member.abstract);
+    }
+    get inlineEqualsFunction() {
+        return code `\
+((left: ${this.name}, right: ${this.name}) => {
+${joinCode(this.concreteMembers.map(({ type, typeCheck, unwrap }) => code `if (${typeCheck(code `left`)} && ${typeCheck(code `right`)}) {
+  return ${type.equalsFunction}(${unwrap(code `left`)} as ${type.name}, ${unwrap(code `right`)} as ${type.name});
+}`))}
+
+  return ${imports.Left}({ left, right, propertyName: "type", propertyValuesUnequal: { left: typeof left, right: typeof right, type: "boolean" as const }, type: "property" as const });
+})`;
+    }
+    get inlineFilterFunction() {
+        return code `\
+((filter: ${this.filterType}, value: ${this.name}) => {
+${joinCode([
+            ...this.identifierType
+                .map((identifierType) => code `\
+if (filter.${syntheticNamePrefix}identifier !== undefined && !${identifierType.filterFunction}(filter.${syntheticNamePrefix}identifier, value.${syntheticNamePrefix}identifier)) {
+  return false;
+}`)
+                .toList(),
+            ...this.concreteMembers.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 inlineFilterType() {
+        return code `\
+  {
+   ${this.identifierType.map((identifierType) => code `readonly ${syntheticNamePrefix}identifier?: ${identifierType.filterType};`).orDefault(code ``)}
+   readonly on?: { ${joinCode(this.concreteMembers.map(({ type, primaryDiscriminantValue }) => code `readonly ${literalOf(primaryDiscriminantValue)}?: ${type.filterType}`), { on: ";" })} }
+  }`;
+    }
+    get inlineFromJsonFunction() {
+        return code `\
+((value: ${this.jsonType().name}): ${this.name} => {
+${joinCode(this.concreteMembers.map(({ jsonTypeCheck, type, unwrap, wrap }) => code `if (${jsonTypeCheck(code `value`)}) { return ${wrap(type.fromJsonExpression({
+            variables: {
+                value: code `(${unwrap(code `value`)} as ${type.jsonType().name})`,
+            },
+        }))}; }`))}
+
+  throw new Error("unable to deserialize JSON");
+})`;
+    }
+    get inlineFromRdfResourceValuesFunction() {
+        const variables = {
+            context: code `_options.context`,
+            graph: code `_options.graph`,
+            ignoreRdfType: false,
+            objectSet: code `_options.objectSet`,
+            preferredLanguages: code `_options.preferredLanguages`,
+            propertyPath: code `_options.propertyPath`,
+            resource: code `_options.resource`,
+        };
+        return code `\
+(((values, _options) =>
+    values.chain(values => values.chainMap(value => {
+      const valueAsValues = ${imports.Right}(value.toValues());
+      return ${this.concreteMembers.reduce((expression, { type, primaryDiscriminantValue }) => {
+            let typeExpression = type.fromRdfResourceValuesExpression({
+                variables: {
+                    context: variables.context,
+                    graph: variables.graph,
+                    ignoreRdfType: false,
+                    objectSet: variables.objectSet,
+                    preferredLanguages: variables.preferredLanguages,
+                    propertyPath: variables.propertyPath,
+                    resource: variables.resource,
+                    resourceValues: code `valueAsValues`,
+                },
+            });
+            if (this.discriminant.kind === "envelope") {
+                typeExpression = code `${typeExpression}.map(values => values.map(value => ({ ${this.discriminant.name}: ${literalOf(primaryDiscriminantValue)} as const, value }) as (${this.name})))`;
+            }
+            typeExpression = code `(${typeExpression} as ${imports.Either}<Error, ${imports.Resource}.Values<${this.name}>>)`;
+            return expression !== null
+                ? code `${expression}.altLazy(() => ${typeExpression})`
+                : typeExpression;
+        }, null)}.chain(values => values.head());
+    }))
+) satisfies ${snippets.FromRdfResourceValuesFunction}<${this.name}>)`;
+    }
+    get inlineJsonType() {
+        switch (this.discriminant.kind) {
+            case "envelope":
+                return new AbstractType.JsonType(code `(${joinCode(this.concreteMembers.map(({ type, primaryDiscriminantValue }) => code `{ ${this.discriminant.name}: ${literalOf(primaryDiscriminantValue)}, value: ${type.jsonType().name} }`), { on: "|" })})`);
+            case "inline":
+            case "typeof":
+                return new AbstractType.JsonType(joinCode(this.concreteMembers.map(({ type }) => code `${type.jsonType({
+                    includeDiscriminantProperty: this.discriminant.kind === "inline",
+                }).name}`), { on: "|" }));
+            default:
+                throw this.discriminant;
+        }
+    }
+    get inlineJsonZodSchema() {
+        switch (this.discriminant.kind) {
+            case "envelope":
+                return code `${imports.z}.discriminatedUnion("${this.discriminant.name}", [${joinCode(this.concreteMembers.map(({ type, primaryDiscriminantValue }) => code `${imports.z}.object({ ${this.discriminant.name}: ${imports.z}.literal(${literalOf(primaryDiscriminantValue)}), value: ${type.jsonZodSchema({ context: "type" })} })`), { on: "," })}])`;
+            case "inline":
+                return code `${imports.z}.discriminatedUnion("${this.discriminant.name}", [${joinCode(this.concreteMembers.map(({ type }) => type.jsonZodSchema({
+                    includeDiscriminantProperty: true,
+                    context: "type",
+                })), { on: "," })}])`;
+            case "typeof":
+                return code `${imports.z}.union([${joinCode(this.concreteMembers.map(({ type }) => type.jsonZodSchema({ context: "type" })), { on: "," })}])`;
+            default:
+                throw this.discriminant;
+        }
+    }
+    get inlineName() {
+        switch (this.discriminant.kind) {
+            case "envelope":
+                return code `(${joinCode(this.concreteMembers.map(({ type, primaryDiscriminantValue }) => code `{ ${this.discriminant.name}: ${literalOf(primaryDiscriminantValue)}, value: ${type.name} }`), { on: "|" })})`;
+            case "inline":
+                // 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.name}`), { 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.name}`), { on: "|" })})`;
+            default:
+                this.discriminant;
+                throw new Error("should never reach this point");
+        }
+    }
+    get inlineValueSparqlConstructTriplesFunction() {
+        return code `\
+((({ ignoreRdfType, filter, schema, ...otherParameters }) => {
+  let triples: ${imports.sparqljs}.Triple[] = [];
+
+  ${joinCode(this.concreteMembers.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 ${snippets.ValueSparqlConstructTriplesFunction}<${this.filterType}, ${this.schemaType}>)`;
+    }
+    get inlineValueSparqlWherePatternsFunction() {
+        return code `\
+((({ filter, schema, ...otherParameters }) => {
+  const unionPatterns: ${imports.sparqljs}.GroupPattern[] = [];
+
+  ${joinCode(this.concreteMembers.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 ${snippets.ValueSparqlWherePatternsFunction}<${this.filterType}, ${this.schemaType}>)`;
+    }
+    get inlineToJsonFunction() {
+        return code `\
+((value: ${this.name}): ${this.jsonType().name} => {
+${joinCode(this.concreteMembers.map(({ type, typeCheck, unwrap, wrap }) => code `if (${typeCheck(code `value`)}) { return ${wrap(type.toJsonExpression({
+            includeDiscriminantProperty: this.discriminant.kind === "inline",
+            variables: { value: unwrap(code `value`) },
+        }))}; }`))}
+
+  throw new Error("unable to serialize to JSON");
+})`;
+    }
+    get inlineToRdfResourceValuesFunction() {
+        return code `\
+(((value, _options) => {
+${joinCode(this.concreteMembers.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");
+}) as ${snippets.ToRdfResourceValuesFunction}<${this.name}>)`;
+    }
+    get schemaObject() {
+        return {
+            ...super.schemaObject,
+            members: code `{ ${joinCode(this.concreteMembers.map(({ discriminantValues, type, primaryDiscriminantValue }) => code `${literalOf(primaryDiscriminantValue)}: ${{
+                discriminantValues: discriminantValues,
+                type: type.schema,
+            }}`), { on: "," })} }`,
+        };
+    }
+    jsonUiSchemaElement() {
+        return Maybe.empty();
+    }
+    inlineHashStatements({ depth, variables, }) {
+        return this.concreteMembers.map(({ type, unwrap, typeCheck }) => code `if (${typeCheck(variables.value)}) { ${joinCode(type
+            .hashStatements({
+            depth: depth + 1,
+            variables: {
+                hasher: variables.hasher,
+                value: unwrap(variables.value),
+            },
+        })
+            .concat())} }`);
+    }
+}
+__decorate([
+    Memoize()
+], AbstractUnionType.prototype, "conversions", null);
+__decorate([
+    Memoize()
+], AbstractUnionType.prototype, "discriminantProperty", null);
+__decorate([
+    Memoize()
+], AbstractUnionType.prototype, "members", null);
+__decorate([
+    Memoize()
+], AbstractUnionType.prototype, "mutable", null);
+__decorate([
+    Memoize()
+], AbstractUnionType.prototype, "schema", null);
+__decorate([
+    Memoize()
+], AbstractUnionType.prototype, "typeofs", null);
+__decorate([
+    Memoize()
+], AbstractUnionType.prototype, "concreteMembers", null);
+__decorate([
+    Memoize()
+], AbstractUnionType.prototype, "inlineEqualsFunction", null);
+__decorate([
+    Memoize()
+], AbstractUnionType.prototype, "inlineFilterFunction", null);
+__decorate([
+    Memoize()
+], AbstractUnionType.prototype, "inlineFilterType", null);
+__decorate([
+    Memoize()
+], AbstractUnionType.prototype, "inlineJsonType", null);
+__decorate([
+    Memoize()
+], AbstractUnionType.prototype, "inlineName", null);
+__decorate([
+    Memoize()
+], AbstractUnionType.prototype, "inlineValueSparqlConstructTriplesFunction", null);
+__decorate([
+    Memoize()
+], AbstractUnionType.prototype, "inlineValueSparqlWherePatternsFunction", null);
+export var Discriminant;
+(function (Discriminant) {
+    function inlineDiscriminantProperty(memberTypes) {
+        let inlineDiscriminantProperty;
+        for (const memberType of memberTypes) {
+            const memberTypeDiscriminantProperty = memberType.discriminantProperty.extract();
+            if (!memberTypeDiscriminantProperty) {
+                inlineDiscriminantProperty = undefined;
+                break;
+            }
+            if (!inlineDiscriminantProperty) {
+                inlineDiscriminantProperty = {
+                    name: memberTypeDiscriminantProperty.name,
+                    ownValues: memberTypeDiscriminantProperty.ownValues.concat(),
+                    descendantValues: memberTypeDiscriminantProperty.descendantValues.concat(),
+                };
+            }
+            else if (memberTypeDiscriminantProperty.name === inlineDiscriminantProperty.name) {
+                inlineDiscriminantProperty.descendantValues =
+                    inlineDiscriminantProperty.descendantValues.concat(memberTypeDiscriminantProperty.descendantValues);
+                inlineDiscriminantProperty.ownValues =
+                    inlineDiscriminantProperty.ownValues.concat(memberTypeDiscriminantProperty.ownValues);
+            }
+            else {
+                return undefined;
+            }
+        }
+        return inlineDiscriminantProperty;
+    }
+    function infer(memberTypes) {
+        // Infer the discriminant kind
+        const inlineDiscriminantProperty_ = inlineDiscriminantProperty(memberTypes);
+        if (inlineDiscriminantProperty_) {
+            return {
+                ...inlineDiscriminantProperty_,
+                kind: "inline",
+            };
+        }
+        const memberTypeofs = new Set();
+        for (const memberType of memberTypes) {
+            for (const typeof_ of memberType.typeofs) {
+                memberTypeofs.add(typeof_);
+            }
+        }
+        if (memberTypeofs.size === memberTypes.length) {
+            return {
+                kind: "typeof",
+            };
+        }
+        let ownValues;
+        const memberTypeNames = memberTypes.map((memberType) => memberType.name);
+        if (memberTypeNames.every((memberTypeName) => typeof memberTypeName === "string")) {
+            const memberTypeNamesSet = new Set(memberTypeNames);
+            if (memberTypeNamesSet.size === memberTypeNames.length) {
+                // If every member type name is a unique string, use those strings as the discriminant values.
+                ownValues = memberTypeNames;
+            }
+            else {
+                // Otherwise prefix the non-unique strings with an index and use those as the discriminant values.
+                ownValues = memberTypeNames.map((memberTypeName, memberTypeIndex) => `${memberTypeIndex}-${memberTypeName}`);
+            }
+        }
+        else {
+            // At least one member type name is Code
+            // Use member type indices as the discriminant values.
+            ownValues = memberTypes.map((_, memberTypeIndex) => memberTypeIndex);
+        }
+        return {
+            descendantValues: [],
+            kind: "envelope",
+            name: "type",
+            ownValues,
+        };
+    }
+    Discriminant.infer = infer;
+})(Discriminant || (Discriminant = {}));
+//# sourceMappingURL=AbstractUnionType.js.map

package/dist/generators/ts/AnonymousUnionType.d.ts

@@ -0,0 +1,26 @@
+import { Maybe } from "purify-ts";
+import type { AbstractType } from "./AbstractType.js";
+import { AbstractUnionType } from "./AbstractUnionType.js";
+import type { Type } from "./Type.js";
+import { type Code } from "./ts-poet-wrapper.js";
+export declare class AnonymousUnionType extends AbstractUnionType<Type> {
+    readonly declaration: Maybe<Code>;
+    readonly graphqlArgs: AbstractType["graphqlArgs"];
+    readonly kind = "AnonymousUnionType";
+    get equalsFunction(): Code;
+    get filterFunction(): Code;
+    get filterType(): Code;
+    get graphqlType(): AbstractType.GraphqlType;
+    get name(): Code;
+    get valueSparqlConstructTriplesFunction(): Code;
+    get valueSparqlWherePatternsFunction(): Code;
+    fromJsonExpression({ variables, }: Parameters<AbstractType["fromJsonExpression"]>[0]): Code;
+    fromRdfResourceValuesExpression({ variables, }: Parameters<AbstractType["fromRdfResourceValuesExpression"]>[0]): Code;
+    graphqlResolveExpression(_parameters: Parameters<AbstractType["graphqlResolveExpression"]>[0]): Code;
+    hashStatements(parameters: Parameters<AbstractType["hashStatements"]>[0]): readonly Code[];
+    jsonType(): AbstractType.JsonType;
+    jsonZodSchema(_parameters: Parameters<AbstractType["jsonZodSchema"]>[0]): Code;
+    toJsonExpression({ variables, }: Parameters<AbstractType["toJsonExpression"]>[0]): Code;
+    toRdfResourceValuesExpression({ variables, }: Parameters<AbstractType["toRdfResourceValuesExpression"]>[0]): Code;
+}
+//# sourceMappingURL=AnonymousUnionType.d.ts.map

package/dist/generators/ts/AnonymousUnionType.js

@@ -0,0 +1,56 @@
+import { Maybe } from "purify-ts";
+import { AbstractUnionType } from "./AbstractUnionType.js";
+import { code } from "./ts-poet-wrapper.js";
+export class AnonymousUnionType extends AbstractUnionType {
+    declaration = Maybe.empty();
+    graphqlArgs = Maybe.empty();
+    kind = "AnonymousUnionType";
+    get equalsFunction() {
+        return this.inlineEqualsFunction;
+    }
+    get filterFunction() {
+        return this.inlineFilterFunction;
+    }
+    get filterType() {
+        return this.inlineFilterType;
+    }
+    get graphqlType() {
+        throw new Error("GraphQL doesn't support scalar unions");
+    }
+    get name() {
+        return this.inlineName;
+    }
+    get valueSparqlConstructTriplesFunction() {
+        return this.inlineValueSparqlConstructTriplesFunction;
+    }
+    get valueSparqlWherePatternsFunction() {
+        return this.inlineValueSparqlWherePatternsFunction;
+    }
+    fromJsonExpression({ variables, }) {
+        return code `${this.inlineFromJsonFunction}(${variables.value})`;
+    }
+    fromRdfResourceValuesExpression({ variables, }) {
+        const { resourceValues: resourceValuesVariable, ...otherVariables } = variables;
+        return code `${this.inlineFromRdfResourceValuesFunction}(${resourceValuesVariable}, ${otherVariables})`;
+    }
+    graphqlResolveExpression(_parameters) {
+        throw new Error("not implemented");
+    }
+    hashStatements(parameters) {
+        return this.inlineHashStatements(parameters);
+    }
+    jsonType() {
+        return this.inlineJsonType;
+    }
+    jsonZodSchema(_parameters) {
+        return this.inlineJsonZodSchema;
+    }
+    toJsonExpression({ variables, }) {
+        return code `${this.inlineToJsonFunction}(${variables.value})`;
+    }
+    toRdfResourceValuesExpression({ variables, }) {
+        const { value: valueVariable, ...otherVariables } = variables;
+        return code `${this.inlineToRdfResourceValuesFunction}(${valueVariable}, ${otherVariables})`;
+    }
+}
+//# sourceMappingURL=AnonymousUnionType.js.map