@shaclmate/compiler 2.0.22 → 2.0.24

package/dist/generators/ts/UnionType.d.ts

@@ -1,32 +1,36 @@
 import { Maybe } from "purify-ts";
-import type { TsFeature } from "../../enums/index.js";
 import type { Import } from "./Import.js";
 import { Type } from "./Type.js";
 export declare class UnionType extends Type {
+    private readonly _discriminator;
+    private readonly memberTypes;
+    private _name?;
     readonly kind = "UnionType";
-    readonly memberTypes: readonly Type[];
-    constructor({ memberTypes, name, ...superParameters }: ConstructorParameters<typeof Type>[0] & {
+    readonly typeof = "object";
+    constructor({ memberTypes, name, }: {
         memberTypes: readonly Type[];
         name?: string;
     });
-    private _name?;
-    get name(): string;
     get conversions(): readonly Type.Conversion[];
     get discriminatorProperty(): Maybe<Type.DiscriminatorProperty>;
     get equalsFunction(): string;
-    get jsonName(): string;
+    get graphqlName(): Type.GraphqlName;
+    get jsonName(): Type.JsonName;
     get mutable(): boolean;
-    private get _discriminatorProperty();
-    private get memberTypeTraits();
+    get name(): string;
     fromJsonExpression({ variables, }: Parameters<Type["fromJsonExpression"]>[0]): string;
-    fromRdfExpression(parameters: Parameters<Type["fromRdfExpression"]>[0]): string;
+    fromRdfExpression({ variables, }: Parameters<Type["fromRdfExpression"]>[0]): string;
+    graphqlResolveExpression(_parameters: Parameters<Type["graphqlResolveExpression"]>[0]): string;
     hashStatements({ depth, variables, }: Parameters<Type["hashStatements"]>[0]): readonly string[];
+    jsonUiSchemaElement(): Maybe<string>;
     jsonZodSchema({ variables, }: Parameters<Type["jsonZodSchema"]>[0]): ReturnType<Type["jsonZodSchema"]>;
+    snippetDeclarations(parameters: Parameters<Type["snippetDeclarations"]>[0]): readonly string[];
     sparqlConstructTemplateTriples(parameters: Parameters<Type["sparqlConstructTemplateTriples"]>[0]): readonly string[];
     sparqlWherePatterns(parameters: Parameters<Type["sparqlWherePatterns"]>[0]): readonly string[];
     toJsonExpression({ variables, }: Parameters<Type["toJsonExpression"]>[0]): string;
     toRdfExpression({ variables, }: Parameters<Type["toRdfExpression"]>[0]): string;
-    useImports(features: Set<TsFeature>): readonly Import[];
+    useImports(parameters: Parameters<Type["useImports"]>[0]): readonly Import[];
+    private discriminatorVariable;
     private ternaryExpression;
 }
 //# sourceMappingURL=UnionType.d.ts.map

package/dist/generators/ts/UnionType.js

@@ -9,196 +9,327 @@ import { invariant } from "ts-invariant";
 import { Memoize } from "typescript-memoize";
 import { Type } from "./Type.js";
 import { objectInitializer } from "./objectInitializer.js";
+class MemberType {
+    delegate;
+    delegateIndex;
+    discriminatorKind;
+    universe;
+    constructor({ delegate, delegateIndex, discriminatorKind, universe, }) {
+        this.delegate = delegate;
+        this.delegateIndex = delegateIndex;
+        this.discriminatorKind = discriminatorKind;
+        this.universe = universe;
+    }
+    get discriminatorValues() {
+        switch (this.discriminatorKind) {
+            case "sharedProperty": {
+                // A member type's combined discriminator 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 discriminator property values: ["A"]
+                //   descendant discriminator property values: ["B"]
+                // and B has
+                //  own discriminator property values: ["B"]
+                //  descendant discriminator property values ["B"]
+                // In this case A shouldn't have "B" as a combined discriminator property value since it's "claimed" by B.
+                const memberOwnDiscriminatorPropertyValues = new Set();
+                for (const memberType of this.universe) {
+                    for (const ownDiscriminatorPropertyValue of memberType.discriminatorProperty.unsafeCoerce()
+                        .ownValues) {
+                        memberOwnDiscriminatorPropertyValues.add(ownDiscriminatorPropertyValue);
+                    }
+                }
+                return this.delegate.discriminatorProperty
+                    .unsafeCoerce()
+                    .ownValues.concat(this.delegate.discriminatorProperty
+                    .unsafeCoerce()
+                    .descendantValues.filter((value) => !memberOwnDiscriminatorPropertyValues.has(value)));
+            }
+            case "syntheticProperty":
+                return [`${this.delegateIndex}-${this.delegate.name}`];
+            case "typeof":
+                return [this.delegate.typeof];
+            default:
+                throw this.discriminatorKind;
+        }
+    }
+    get equalsFunction() {
+        return this.delegate.equalsFunction;
+    }
+    get jsonName() {
+        return this.delegate.jsonName;
+    }
+    get mutable() {
+        return this.delegate.mutable;
+    }
+    get name() {
+        return this.delegate.name;
+    }
+    fromJsonExpression(parameters) {
+        return this.delegate.fromJsonExpression(parameters);
+    }
+    fromRdfExpression(parameters) {
+        return this.delegate.fromRdfExpression(parameters);
+    }
+    hashStatements(parameters) {
+        return this.delegate.hashStatements(parameters);
+    }
+    jsonZodSchema(parameters) {
+        return this.delegate.jsonZodSchema(parameters);
+    }
+    payload(instance) {
+        switch (this.discriminatorKind) {
+            case "sharedProperty":
+            case "typeof":
+                return instance;
+            case "syntheticProperty":
+                return `${instance}.value`;
+        }
+    }
+    snippetDeclarations(parameters) {
+        return this.delegate.snippetDeclarations(parameters);
+    }
+    sparqlConstructTemplateTriples(parameters) {
+        return this.delegate.sparqlConstructTemplateTriples(parameters);
+    }
+    sparqlWherePatterns(parameters) {
+        return this.delegate.sparqlWherePatterns(parameters);
+    }
+    toJsonExpression(parameters) {
+        return this.delegate.toJsonExpression(parameters);
+    }
+    toRdfExpression(parameters) {
+        return this.delegate.toRdfExpression(parameters);
+    }
+    useImports(parameters) {
+        return this.delegate.useImports(parameters);
+    }
+}
+__decorate([
+    Memoize()
+], MemberType.prototype, "discriminatorValues", null);
 export class UnionType extends Type {
-    kind = "UnionType";
+    _discriminator;
     memberTypes;
-    constructor({ memberTypes, name, ...superParameters }) {
-        super(superParameters);
+    _name;
+    kind = "UnionType";
+    typeof = "object";
+    constructor({ memberTypes, name, }) {
+        super();
         invariant(memberTypes.length >= 2);
-        this.memberTypes = memberTypes;
         this._name = name;
-    }
-    _name;
-    get name() {
-        if (typeof this._name === "undefined") {
-            switch (this._discriminatorProperty.kind) {
-                case "shared":
-                    // If every type shares a discriminator (e.g., RDF/JS "termType" or generated ObjectType "type"),
-                    // just join their names with "|"
-                    this._name = `(${this.memberTypes.map((memberType) => memberType.name).join(" | ")})`;
-                    break;
-                case "synthetic":
-                    this._name = `(${this.memberTypeTraits.map((memberTypeTraits) => `{ ${this._discriminatorProperty.name}: "${memberTypeTraits.discriminatorPropertyValues[0]}", value: ${memberTypeTraits.memberType.name} }`).join(" | ")})`;
-                    break;
+        const sharedDiscriminatorProperty_ = sharedDiscriminatorProperty(memberTypes);
+        if (sharedDiscriminatorProperty_) {
+            this._discriminator = {
+                ...sharedDiscriminatorProperty_,
+                kind: "sharedProperty",
+            };
+        }
+        else {
+            const memberTypeofs = new Set();
+            for (const memberType of memberTypes) {
+                memberTypeofs.add(memberType.typeof);
+            }
+            if (memberTypeofs.size === memberTypes.length) {
+                this._discriminator = {
+                    kind: "typeof",
+                };
+            }
+            else {
+                this._discriminator = {
+                    descendantValues: [],
+                    kind: "syntheticProperty",
+                    name: "type",
+                    ownValues: memberTypes.map((memberType, memberTypeIndex) => `${memberTypeIndex}-${memberType.name}`),
+                };
             }
         }
-        return this._name;
+        this.memberTypes = memberTypes.map((memberType, memberTypeIndex) => new MemberType({
+            delegate: memberType,
+            delegateIndex: memberTypeIndex,
+            discriminatorKind: this._discriminator.kind,
+            universe: memberTypes,
+        }));
     }
     get conversions() {
-        return [
-            {
-                conversionExpression: (value) => value,
-                sourceTypeCheckExpression: (value) => `typeof ${value} === "object"`,
-                sourceTypeName: this.name,
-            },
-        ];
+        switch (this._discriminator.kind) {
+            case "sharedProperty":
+            case "syntheticProperty":
+                return [
+                    {
+                        conversionExpression: (value) => value,
+                        sourceTypeCheckExpression: (value) => `typeof ${value} === "object"`,
+                        sourceTypeName: this.name,
+                    },
+                ];
+            case "typeof":
+                return this.memberTypes.map((memberType) => ({
+                    conversionExpression: (value) => value,
+                    sourceTypeCheckExpression: (value) => `typeof ${value} === "${memberType.discriminatorValues[0]}"`,
+                    sourceTypeName: memberType.name,
+                }));
+            default:
+                throw this._discriminator;
+        }
     }
     get discriminatorProperty() {
-        return Maybe.of(this._discriminatorProperty);
+        switch (this._discriminator.kind) {
+            case "sharedProperty":
+            case "syntheticProperty":
+                return Maybe.of(this._discriminator);
+            case "typeof":
+                return Maybe.empty();
+            default:
+                throw this._discriminator;
+        }
     }
     get equalsFunction() {
         return `
 (left: ${this.name}, right: ${this.name}) => {
-${this.memberTypeTraits
-            .flatMap((memberTypeTraits) => memberTypeTraits.discriminatorPropertyValues.map((value) => `if (left.${this._discriminatorProperty.name} === "${value}" && right.${this._discriminatorProperty.name} === "${value}") {
-  return ${memberTypeTraits.memberType.equalsFunction}(${memberTypeTraits.payload("left")}, ${memberTypeTraits.payload("right")});
+${this.memberTypes
+            .flatMap((memberType) => memberType.discriminatorValues.map((value) => `if (${this.discriminatorVariable("left")} === "${value}" && ${this.discriminatorVariable("right")} === "${value}") {
+  return ${memberType.equalsFunction}(${memberType.payload("left")}, ${memberType.payload("right")});
 }`))
             .join("\n")}
 
   return purify.Left({ left, right, propertyName: "type", propertyValuesUnequal: { left: typeof left, right: typeof right, type: "BooleanEquals" as const }, type: "Property" as const });
 }`;
     }
+    get graphqlName() {
+        throw new Error("not implemented");
+    }
     get jsonName() {
-        switch (this._discriminatorProperty.kind) {
-            case "shared":
-                return this.memberTypes
-                    .map((memberType) => memberType.jsonName)
-                    .join(" | ");
-            case "synthetic":
-                return `(${this.memberTypeTraits.map((memberTypeTraits) => `{ ${this._discriminatorProperty.name}: "${memberTypeTraits.discriminatorPropertyValues[0]}", value: ${memberTypeTraits.memberType.jsonName} }`).join(" | ")})`;
+        switch (this._discriminator.kind) {
+            case "sharedProperty":
+            case "typeof":
+                return new Type.JsonName(this.memberTypes.map((memberType) => memberType.jsonName).join(" | "));
+            case "syntheticProperty":
+                return new Type.JsonName(`(${this.memberTypes.map((memberType) => `{ ${this._discriminator.name}: "${memberType.discriminatorValues[0]}", value: ${memberType.jsonName} }`).join(" | ")})`);
             default:
-                throw new RangeError(this._discriminatorProperty.kind);
+                throw this._discriminator;
         }
     }
     get mutable() {
         return this.memberTypes.some((memberType) => memberType.mutable);
     }
-    get _discriminatorProperty() {
-        let sharedDiscriminatorProperty;
-        for (const memberType of this.memberTypes) {
-            const memberTypeDiscriminatorProperty = memberType.discriminatorProperty.extract();
-            if (!memberTypeDiscriminatorProperty) {
-                sharedDiscriminatorProperty = undefined;
-                break;
-            }
-            if (!sharedDiscriminatorProperty) {
-                sharedDiscriminatorProperty = {
-                    name: memberTypeDiscriminatorProperty.name,
-                    values: memberTypeDiscriminatorProperty.values.concat(),
-                };
-            }
-            else if (memberTypeDiscriminatorProperty.name ===
-                sharedDiscriminatorProperty.name) {
-                sharedDiscriminatorProperty.values =
-                    sharedDiscriminatorProperty.values.concat(memberTypeDiscriminatorProperty.values);
-            }
-            else {
-                sharedDiscriminatorProperty = undefined;
-                break;
+    get name() {
+        if (typeof this._name === "undefined") {
+            switch (this._discriminator.kind) {
+                case "sharedProperty":
+                    // If every type shares a discriminator (e.g., RDF/JS "termType" or generated ObjectType "type"),
+                    // just join their names with "|"
+                    this._name = `(${this.memberTypes.map((memberType) => memberType.name).join(" | ")})`;
+                    break;
+                case "syntheticProperty":
+                    this._name = `(${this.memberTypes.map((memberType) => `{ ${this._discriminator.name}: "${memberType.discriminatorValues[0]}", value: ${memberType.name} }`).join(" | ")})`;
+                    break;
+                case "typeof":
+                    // The memberType.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.
+                    this._name = `(${this.memberTypes.map((memberType) => memberType.name).join(" | ")})`;
+                    break;
             }
         }
-        if (sharedDiscriminatorProperty) {
-            return {
-                ...sharedDiscriminatorProperty,
-                kind: "shared",
-            };
-        }
-        return {
-            kind: "synthetic",
-            name: "type",
-            values: this.memberTypes.map((memberType, memberTypeIndex) => `${memberTypeIndex}-${memberType.name}`),
-        };
-    }
-    get memberTypeTraits() {
-        switch (this._discriminatorProperty.kind) {
-            case "shared":
-                return this.memberTypes.map((memberType) => ({
-                    discriminatorPropertyValues: memberType.discriminatorProperty.unsafeCoerce().values,
-                    memberType,
-                    payload: (instance) => instance,
-                }));
-            case "synthetic":
-                return this.memberTypes.map((memberType, memberTypeIndex) => ({
-                    discriminatorPropertyValues: [
-                        `${memberTypeIndex}-${memberType.name}`,
-                    ],
-                    memberType,
-                    payload: (instance) => `${instance}.value`,
-                }));
-            default:
-                throw new RangeError(this._discriminatorProperty.kind);
-        }
+        return this._name;
     }
     fromJsonExpression({ variables, }) {
         return this.ternaryExpression({
-            memberTypeExpression: (memberTypeTraits) => {
-                let typeExpression = memberTypeTraits.memberType.fromJsonExpression({
+            memberTypeExpression: (memberType) => {
+                let typeExpression = memberType.fromJsonExpression({
                     variables: {
-                        value: memberTypeTraits.payload(variables.value),
+                        value: memberType.payload(variables.value),
                     },
                 });
-                if (this._discriminatorProperty.kind === "synthetic") {
-                    typeExpression = `{ ${this._discriminatorProperty.name}: "${memberTypeTraits.discriminatorPropertyValues[0]}" as const, value: ${typeExpression} }`;
+                if (this._discriminator.kind === "syntheticProperty") {
+                    typeExpression = `{ ${this._discriminator.name}: "${memberType.discriminatorValues[0]}" as const, value: ${typeExpression} }`;
                 }
                 return typeExpression;
             },
             variables,
         });
     }
-    fromRdfExpression(parameters) {
-        return this.memberTypeTraits.reduce((expression, memberTypeTraits) => {
-            let typeExpression = memberTypeTraits.memberType.fromRdfExpression(parameters);
-            if (this._discriminatorProperty.kind === "synthetic") {
-                typeExpression = `${typeExpression}.map(value => ({ ${this._discriminatorProperty.name}: "${memberTypeTraits.discriminatorPropertyValues[0]}" as const, value }) as (${this.name}))`;
+    fromRdfExpression({ variables, }) {
+        return this.memberTypes.reduce((expression, memberType) => {
+            let typeExpression = memberType.fromRdfExpression({
+                variables: { ...variables, ignoreRdfType: false },
+            });
+            if (this._discriminator.kind === "syntheticProperty") {
+                typeExpression = `${typeExpression}.map(value => ({ ${this._discriminator.name}: "${memberType.discriminatorValues[0]}" as const, value }) as (${this.name}))`;
             }
-            typeExpression = `(${typeExpression} as purify.Either<rdfjsResource.Resource.ValueError, ${this.name}>)`;
+            typeExpression = `(${typeExpression} as purify.Either<Error, rdfjsResource.Resource.Values<${this.name}>>)`;
             return expression.length > 0
                 ? `${expression}.altLazy(() => ${typeExpression})`
                 : typeExpression;
         }, "");
     }
+    graphqlResolveExpression(_parameters) {
+        throw new Error("not implemented");
+    }
     hashStatements({ depth, variables, }) {
         const caseBlocks = [];
-        for (const memberTypeTraits of this.memberTypeTraits) {
-            for (const discriminatorPropertyValue of memberTypeTraits.discriminatorPropertyValues) {
-                caseBlocks.push(`case "${discriminatorPropertyValue}": { ${memberTypeTraits.memberType
-                    .hashStatements({
-                    depth: depth + 1,
-                    variables: {
-                        hasher: variables.hasher,
-                        value: `${memberTypeTraits.payload(variables.value)}`,
-                    },
-                })
-                    .join("\n")}; break; }`);
-            }
+        for (const memberType of this.memberTypes) {
+            caseBlocks.push(`${memberType.discriminatorValues.map((discriminatorPropertyValue) => `case "${discriminatorPropertyValue}":`).join("\n")} { ${memberType
+                .hashStatements({
+                depth: depth + 1,
+                variables: {
+                    hasher: variables.hasher,
+                    value: `${memberType.payload(variables.value)}`,
+                },
+            })
+                .join("\n")}; break; }`);
         }
+        caseBlocks.push(`default: ${variables.value} satisfies never; throw new Error("unrecognized type");`);
         return [
-            `switch (${variables.value}.${this._discriminatorProperty.name}) { ${caseBlocks.join("\n")} }`,
+            `switch (${this.discriminatorVariable(variables.value)}) { ${caseBlocks.join("\n")} }`,
         ];
     }
+    jsonUiSchemaElement() {
+        return Maybe.empty();
+    }
     jsonZodSchema({ variables, }) {
-        switch (this._discriminatorProperty.kind) {
-            case "shared":
-                return `${variables.zod}.discriminatedUnion("${this._discriminatorProperty.name}", [${this.memberTypes
-                    .map((memberType) => memberType.jsonZodSchema({ variables }))
+        switch (this._discriminator.kind) {
+            case "sharedProperty":
+                return `${variables.zod}.discriminatedUnion("${this._discriminator.name}", [${this.memberTypes
+                    .map((memberType) => memberType.jsonZodSchema({ context: "type", variables }))
                     .join(", ")}])`;
-            case "synthetic":
-                return `${variables.zod}.discriminatedUnion("${this._discriminatorProperty.name}", [${this.memberTypeTraits
-                    .map((memberTypeTraits) => `${variables.zod}.object({ ${this._discriminatorProperty.name}: ${variables.zod}.literal("${memberTypeTraits.discriminatorPropertyValues[0]}"), value: ${memberTypeTraits.memberType.jsonZodSchema({ variables })} })`)
+            case "syntheticProperty":
+                return `${variables.zod}.discriminatedUnion("${this._discriminator.name}", [${this.memberTypes
+                    .map((memberType) => `${variables.zod}.object({ ${this._discriminator.name}: ${variables.zod}.literal("${memberType.discriminatorValues[0]}"), value: ${memberType.jsonZodSchema({ context: "type", variables })} })`)
+                    .join(", ")}])`;
+            case "typeof":
+                return `${variables.zod}.union([${this.memberTypes
+                    .map((memberType) => memberType.jsonZodSchema({ context: "type", variables }))
                     .join(", ")}])`;
             default:
-                throw new RangeError(this._discriminatorProperty.kind);
+                throw this._discriminator;
         }
     }
+    snippetDeclarations(parameters) {
+        const { recursionStack } = parameters;
+        if (recursionStack.some((type) => Object.is(type, this))) {
+            return [];
+        }
+        recursionStack.push(this);
+        const result = this.memberTypes.flatMap((memberType) => memberType.snippetDeclarations(parameters));
+        invariant(Object.is(recursionStack.pop(), this));
+        return result;
+    }
     sparqlConstructTemplateTriples(parameters) {
-        return this.memberTypes.reduce((array, memberType) => array.concat(memberType.sparqlConstructTemplateTriples(parameters)), []);
+        return this.memberTypes.reduce((array, memberType) => array.concat(memberType.sparqlConstructTemplateTriples({
+            ...parameters,
+            allowIgnoreRdfType: false,
+        })), []);
     }
     sparqlWherePatterns(parameters) {
         let haveEmptyGroup = false; // Only need one empty group
         return [
             `{ patterns: [${this.memberTypes
                 .flatMap((memberType) => {
-                const groupPatterns = memberType.sparqlWherePatterns(parameters);
+                const groupPatterns = memberType.sparqlWherePatterns({
+                    ...parameters,
+                    allowIgnoreRdfType: false,
+                });
                 if (groupPatterns.length === 0) {
                     if (haveEmptyGroup) {
                         return [];
@@ -217,23 +348,24 @@ ${this.memberTypeTraits
         ];
     }
     toJsonExpression({ variables, }) {
-        switch (this._discriminatorProperty.kind) {
-            case "shared":
+        switch (this._discriminator.kind) {
+            case "sharedProperty":
+            case "typeof":
                 return this.ternaryExpression({
-                    memberTypeExpression: (memberTypeTraits) => memberTypeTraits.memberType.toJsonExpression({
+                    memberTypeExpression: (memberType) => memberType.toJsonExpression({
                         variables: {
                             ...variables,
-                            value: memberTypeTraits.payload(variables.value),
+                            value: memberType.payload(variables.value),
                         },
                     }),
                     variables,
                 });
-            case "synthetic":
+            case "syntheticProperty":
                 return this.ternaryExpression({
-                    memberTypeExpression: (memberTypeTraits) => `{ ${this._discriminatorProperty.name}: "${memberTypeTraits.discriminatorPropertyValues[0]}" as const, value: ${memberTypeTraits.memberType.toJsonExpression({
+                    memberTypeExpression: (memberType) => `{ ${this._discriminator.name}: "${memberType.discriminatorValues[0]}" as const, value: ${memberType.toJsonExpression({
                         variables: {
                             ...variables,
-                            value: memberTypeTraits.payload(variables.value),
+                            value: memberType.payload(variables.value),
                         },
                     })} }`,
                     variables,
@@ -242,36 +374,81 @@ ${this.memberTypeTraits
     }
     toRdfExpression({ variables, }) {
         return this.ternaryExpression({
-            memberTypeExpression: (memberTypeTraits) => memberTypeTraits.memberType.toRdfExpression({
+            memberTypeExpression: (memberType) => memberType.toRdfExpression({
                 variables: {
                     ...variables,
-                    value: memberTypeTraits.payload(variables.value),
+                    value: memberType.payload(variables.value),
                 },
             }),
             variables,
         });
     }
-    useImports(features) {
-        return this.memberTypes.flatMap((memberType) => memberType.useImports(features));
+    useImports(parameters) {
+        return this.memberTypes.flatMap((memberType) => memberType.useImports(parameters));
+    }
+    discriminatorVariable(variableValue) {
+        switch (this._discriminator.kind) {
+            case "sharedProperty":
+            case "syntheticProperty":
+                return `${variableValue}.${this._discriminator.name}`;
+            case "typeof":
+                return `(typeof ${variableValue})`;
+        }
     }
     ternaryExpression({ memberTypeExpression, variables, }) {
-        return this.memberTypeTraits.reduce((expression, memberTypeTraits) => {
+        return this.memberTypes.reduce((expression, memberType) => {
             if (expression.length === 0) {
-                return memberTypeExpression(memberTypeTraits);
+                return memberTypeExpression(memberType);
             }
-            return `(${memberTypeTraits.discriminatorPropertyValues
-                .map((value) => `${variables.value}.${this._discriminatorProperty.name} === "${value}"`)
-                .join(" || ")}) ? ${memberTypeExpression(memberTypeTraits)} : ${expression}`;
+            return `(${memberType.discriminatorValues
+                .map((value) => `${this.discriminatorVariable(variables.value)} === "${value}"`)
+                .join(" || ")}) ? ${memberTypeExpression(memberType)} : ${expression}`;
         }, "");
     }
 }
+__decorate([
+    Memoize()
+], UnionType.prototype, "conversions", null);
 __decorate([
     Memoize()
 ], UnionType.prototype, "discriminatorProperty", null);
 __decorate([
     Memoize()
-], UnionType.prototype, "_discriminatorProperty", null);
+], UnionType.prototype, "equalsFunction", null);
+__decorate([
+    Memoize()
+], UnionType.prototype, "jsonName", null);
+__decorate([
+    Memoize()
+], UnionType.prototype, "mutable", null);
 __decorate([
     Memoize()
-], UnionType.prototype, "memberTypeTraits", null);
+], UnionType.prototype, "name", null);
+function sharedDiscriminatorProperty(memberTypes) {
+    let sharedDiscriminatorProperty;
+    for (const memberType of memberTypes) {
+        const memberTypeDiscriminatorProperty = memberType.discriminatorProperty.extract();
+        if (!memberTypeDiscriminatorProperty) {
+            sharedDiscriminatorProperty = undefined;
+            break;
+        }
+        if (!sharedDiscriminatorProperty) {
+            sharedDiscriminatorProperty = {
+                name: memberTypeDiscriminatorProperty.name,
+                ownValues: memberTypeDiscriminatorProperty.ownValues.concat(),
+                descendantValues: memberTypeDiscriminatorProperty.descendantValues.concat(),
+            };
+        }
+        else if (memberTypeDiscriminatorProperty.name === sharedDiscriminatorProperty.name) {
+            sharedDiscriminatorProperty.descendantValues =
+                sharedDiscriminatorProperty.descendantValues.concat(memberTypeDiscriminatorProperty.descendantValues);
+            sharedDiscriminatorProperty.ownValues =
+                sharedDiscriminatorProperty.ownValues.concat(memberTypeDiscriminatorProperty.ownValues);
+        }
+        else {
+            return undefined;
+        }
+    }
+    return sharedDiscriminatorProperty;
+}
 //# sourceMappingURL=UnionType.js.map

package/dist/generators/ts/_ObjectType/EagerShaclProperty.d.ts

@@ -0,0 +1,12 @@
+import type { Type } from "../Type.js";
+import { ShaclProperty } from "./ShaclProperty.js";
+export declare class EagerShaclProperty<TypeT extends Type> extends ShaclProperty<TypeT> {
+    readonly mutable: boolean;
+    readonly recursive: boolean;
+    constructor({ mutable, recursive, ...superParameters }: {
+        mutable: boolean;
+        recursive: boolean;
+    } & ConstructorParameters<typeof ShaclProperty<TypeT>>[0]);
+    get graphqlField(): ShaclProperty<TypeT>["graphqlField"];
+}
+//# sourceMappingURL=EagerShaclProperty.d.ts.map