@shaclmate/compiler 3.0.4 → 4.0.0

package/dist/generators/ts/UnionType.js

@@ -4,61 +4,67 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
-import { Maybe } from "purify-ts";
+import { Maybe, NonEmptyList } from "purify-ts";
 import { invariant } from "ts-invariant";
 import { Memoize } from "typescript-memoize";
-import { Type } from "./Type.js";
-import { objectInitializer } from "./objectInitializer.js";
+import { AbstractType } from "./AbstractType.js";
+import { codeEquals } from "./codeEquals.js";
+import { imports } from "./imports.js";
+import { snippets } from "./snippets.js";
+import { code, joinCode, literalOf } from "./ts-poet-wrapper.js";
 class MemberType {
     delegate;
     delegateIndex;
-    discriminatorKind;
+    discriminant;
     universe;
-    constructor({ delegate, delegateIndex, discriminatorKind, universe, }) {
+    constructor({ delegate, delegateIndex, discriminant, universe, }) {
         this.delegate = delegate;
         this.delegateIndex = delegateIndex;
-        this.discriminatorKind = discriminatorKind;
+        this.discriminant = discriminant;
         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
+    get discriminantValues() {
+        switch (this.discriminant.kind) {
+            case "envelope":
+                return [this.discriminant.ownValues[this.delegateIndex]];
+            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 discriminator property values: ["A"]
-                //   descendant discriminator property values: ["B"]
+                //   own discriminant property values: ["A"]
+                //   descendant discriminant 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();
+                //  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 memberType of this.universe) {
-                    for (const ownDiscriminatorPropertyValue of memberType.discriminatorProperty.unsafeCoerce()
+                    for (const ownDiscriminantPropertyValue of memberType.discriminantProperty.unsafeCoerce()
                         .ownValues) {
-                        memberOwnDiscriminatorPropertyValues.add(ownDiscriminatorPropertyValue);
+                        memberOwnDiscriminantPropertyValues.add(ownDiscriminantPropertyValue);
                     }
                 }
-                return this.delegate.discriminatorProperty
+                return this.delegate.discriminantProperty
                     .unsafeCoerce()
-                    .ownValues.concat(this.delegate.discriminatorProperty
+                    .ownValues.concat(this.delegate.discriminantProperty
                     .unsafeCoerce()
-                    .descendantValues.filter((value) => !memberOwnDiscriminatorPropertyValues.has(value)));
+                    .descendantValues.filter((value) => !memberOwnDiscriminantPropertyValues.has(value)));
             }
-            case "syntheticProperty":
-                return [`${this.delegateIndex}-${this.delegate.name}`];
             case "typeof":
-                return [this.delegate.typeof];
+                return this.delegate.typeofs;
             default:
-                throw this.discriminatorKind;
+                throw this.discriminant;
         }
     }
     get equalsFunction() {
         return this.delegate.equalsFunction;
     }
-    get jsonName() {
-        return this.delegate.jsonName;
+    get filterFunction() {
+        return this.delegate.filterFunction;
+    }
+    get filterType() {
+        return this.delegate.filterType;
     }
     get mutable() {
         return this.delegate.mutable;
@@ -66,6 +72,21 @@ class MemberType {
     get name() {
         return this.delegate.name;
     }
+    get schema() {
+        return this.delegate.schema;
+    }
+    get schemaType() {
+        return this.delegate.schemaType;
+    }
+    get sparqlConstructTriplesFunction() {
+        return this.delegate.sparqlConstructTriplesFunction;
+    }
+    get sparqlWherePatternsFunction() {
+        return this.delegate.sparqlWherePatternsFunction;
+    }
+    get typeofs() {
+        return this.delegate.typeofs;
+    }
     fromJsonExpression(parameters) {
         return this.delegate.fromJsonExpression(parameters);
     }
@@ -75,163 +96,222 @@ class MemberType {
     hashStatements(parameters) {
         return this.delegate.hashStatements(parameters);
     }
+    jsonType(parameters) {
+        return this.delegate.jsonType(parameters);
+    }
     jsonZodSchema(parameters) {
         return this.delegate.jsonZodSchema(parameters);
     }
     payload(instance) {
-        switch (this.discriminatorKind) {
-            case "sharedProperty":
+        switch (this.discriminant.kind) {
+            case "envelope":
+                return code `${instance}.value`;
+            case "inline":
             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 {
-    _discriminator;
+], MemberType.prototype, "discriminantValues", null);
+export class UnionType extends AbstractType {
+    discriminant;
     memberTypes;
-    _name;
+    #name;
+    graphqlArgs = Maybe.empty();
     kind = "UnionType";
-    typeof = "object";
-    constructor({ memberTypes, name, }) {
-        super();
+    constructor({ memberDiscriminantValues, memberTypes, ...superParameters }) {
+        super(superParameters);
         invariant(memberTypes.length >= 2);
-        this._name = name;
-        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",
+        invariant(memberDiscriminantValues.length === 0 ||
+            memberDiscriminantValues.length === memberTypes.length);
+        let discriminant;
+        if (memberDiscriminantValues.length === 0) {
+            // Infer the discriminant kind
+            const inlineDiscriminantProperty_ = inlineDiscriminantProperty(memberTypes);
+            if (inlineDiscriminantProperty_) {
+                discriminant = {
+                    ...inlineDiscriminantProperty_,
+                    kind: "inline",
                 };
             }
             else {
-                this._discriminator = {
-                    descendantValues: [],
-                    kind: "syntheticProperty",
-                    name: "type",
-                    ownValues: memberTypes.map((memberType, memberTypeIndex) => `${memberTypeIndex}-${memberType.name}`),
-                };
+                const memberTypeofs = new Set();
+                for (const memberType of memberTypes) {
+                    for (const typeof_ of memberType.typeofs) {
+                        memberTypeofs.add(typeof_);
+                    }
+                }
+                if (memberTypeofs.size === memberTypes.length) {
+                    discriminant = {
+                        kind: "typeof",
+                    };
+                }
             }
         }
+        if (!discriminant) {
+            discriminant = {
+                descendantValues: [],
+                kind: "envelope",
+                name: "type",
+                ownValues: memberDiscriminantValues.length > 0
+                    ? memberDiscriminantValues
+                    : memberTypes.map((memberType, memberTypeIndex) => `${memberTypeIndex}-${memberType.name}`),
+            };
+        }
+        this.discriminant = discriminant;
         this.memberTypes = memberTypes.map((memberType, memberTypeIndex) => new MemberType({
             delegate: memberType,
             delegateIndex: memberTypeIndex,
-            discriminatorKind: this._discriminator.kind,
+            discriminant: this.discriminant,
             universe: memberTypes,
         }));
     }
     get conversions() {
-        switch (this._discriminator.kind) {
-            case "sharedProperty":
-            case "syntheticProperty":
+        switch (this.discriminant.kind) {
+            case "envelope":
+            case "inline":
                 return [
                     {
                         conversionExpression: (value) => value,
-                        sourceTypeCheckExpression: (value) => `typeof ${value} === "object"`,
+                        sourceTypeCheckExpression: (value) => code `typeof ${value} === "object"`,
                         sourceTypeName: this.name,
+                        sourceTypeof: "object",
                     },
                 ];
             case "typeof":
                 return this.memberTypes.map((memberType) => ({
                     conversionExpression: (value) => value,
-                    sourceTypeCheckExpression: (value) => `typeof ${value} === "${memberType.discriminatorValues[0]}"`,
+                    sourceTypeCheckExpression: (value) => code `typeof ${value} === "${memberType.discriminantValues[0]}"`,
                     sourceTypeName: memberType.name,
+                    sourceTypeof: memberType.discriminantValues[0],
                 }));
             default:
-                throw this._discriminator;
+                throw this.discriminant;
         }
     }
-    get discriminatorProperty() {
-        switch (this._discriminator.kind) {
-            case "sharedProperty":
-            case "syntheticProperty":
-                return Maybe.of(this._discriminator);
+    get discriminantProperty() {
+        switch (this.discriminant.kind) {
+            case "envelope":
+            case "inline":
+                return Maybe.of(this.discriminant);
             case "typeof":
                 return Maybe.empty();
             default:
-                throw this._discriminator;
+                throw this.discriminant;
         }
     }
     get equalsFunction() {
-        return `
-(left: ${this.name}, right: ${this.name}) => {
-${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 code `\
+((left: ${this.name}, right: ${this.name}) => {
+${joinCode(this.memberTypes.flatMap((memberType) => memberType.discriminantValues.map((value) => code `if (${this.discriminantVariable(code `left`)} === "${value}" && ${this.discriminantVariable(code `right`)} === "${value}") {
+  return ${memberType.equalsFunction}(${memberType.payload(code `left`)}, ${memberType.payload(code `right`)});
+}`)))}
 
-  return purify.Left({ left, right, propertyName: "type", propertyValuesUnequal: { left: typeof left, right: typeof right, type: "BooleanEquals" as const }, type: "Property" as const });
-}`;
+  return ${imports.Left}({ left, right, propertyName: "type", propertyValuesUnequal: { left: typeof left, right: typeof right, type: "boolean" as const }, type: "property" as const });
+})`;
+    }
+    get filterFunction() {
+        return code `\
+((filter: ${this.filterType}, value: ${this.name}) => {
+${joinCode(this.memberTypes.map((memberType) => code `\
+if (filter.on?.["${memberType.discriminantValues[0]}"] !== undefined) {
+  switch (${this.discriminantVariable(code `value`)}) {
+${memberType.discriminantValues.map((discriminantValue) => `case "${discriminantValue}":`)}
+    if (!${memberType.filterFunction}(filter.on["${memberType.discriminantValues[0]}"], ${memberType.payload(code `value`)})) {
+      return false;
+    }
+    break;
+  }
+}`))}
+
+  return true;
+})`;
     }
-    get graphqlName() {
-        throw new Error("not implemented");
+    get filterType() {
+        return code `{ readonly on?: { ${joinCode(this.memberTypes.map((memberType) => code `readonly "${memberType.discriminantValues[0]}"?: ${memberType.filterType}`), { on: ";" })} } }`;
     }
-    get jsonName() {
-        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 this._discriminator;
-        }
+    get graphqlType() {
+        throw new Error("GraphQL doesn't support scalar unions");
     }
     get mutable() {
         return this.memberTypes.some((memberType) => memberType.mutable);
     }
     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(" | ")})`;
+        if (this.#name === undefined) {
+            switch (this.discriminant.kind) {
+                case "envelope":
+                    this.#name = code `(${joinCode(this.memberTypes.map((memberType) => code `{ ${this.discriminant.name}: ${literalOf(memberType.discriminantValues[0])}, value: ${memberType.name} }`), { on: "|" })})`;
                     break;
-                case "syntheticProperty":
-                    this._name = `(${this.memberTypes.map((memberType) => `{ ${this._discriminator.name}: "${memberType.discriminatorValues[0]}", value: ${memberType.name} }`).join(" | ")})`;
+                case "inline":
+                    // If every type shares a discriminant (e.g., RDF/JS "termType" or generated ObjectType "type"),
+                    // just join their names with "|"
+                    this.#name = code `(${joinCode(this.memberTypes.map((memberType) => code `${memberType.name}`), { on: "|" })})`;
                     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(" | ")})`;
+                    this.#name = code `(${joinCode(this.memberTypes.map((memberType) => code `${memberType.name}`), { on: "|" })})`;
                     break;
             }
         }
-        return this._name;
+        return this.#name;
+    }
+    get schema() {
+        return code `${{
+            // discriminant: {
+            //   kind: `${JSON.stringify(this.discriminant.kind)} as const`,
+            // },
+            kind: code `${literalOf("Union")} as const`,
+            members: code `{ ${joinCode(this.memberTypes.map((memberType) => code `"${memberType.discriminantValues[0]}": ${{
+                discriminantValues: memberType.discriminantValues,
+                type: memberType.schema,
+            }}`), { on: "," })} }`,
+        }}`;
+    }
+    get schemaType() {
+        return code `${{
+            // discriminant: {
+            //   kind: '"envelope" | "inline" | "typeof"',
+            // },
+            kind: literalOf("Union"),
+            members: code `{ ${joinCode(this.memberTypes.map((memberType) => code `readonly "${memberType.discriminantValues[0]}": ${{
+                discriminantValues: code `readonly string[]`,
+                type: memberType.schemaType,
+            }}`), { on: ";" })} }`,
+        }}`;
+    }
+    get sparqlConstructTriplesFunction() {
+        return code `\
+(({ ignoreRdfType, filter, schema, ...otherParameters }: ${snippets.SparqlConstructTriplesFunctionParameters}<${this.filterType}, ${this.schemaType}>) => {
+  let triples: ${imports.sparqljs}.Triple[] = [];
+
+  ${joinCode(this.memberTypes.map((memberType) => code `\
+triples = triples.concat(${memberType.sparqlConstructTriplesFunction}({ filter: filter?.on?.["${memberType.discriminantValues[0]}"], ignoreRdfType: false, schema: schema.members["${memberType.discriminantValues[0]}"].type, ...otherParameters }));`))}
+  
+  return triples;
+})`;
+    }
+    get sparqlWherePatternsFunction() {
+        return code `\
+(({ filter, schema, ...otherParameters }: ${snippets.SparqlWherePatternsFunctionParameters}<${this.filterType}, ${this.schemaType}>) => {
+  const unionPatterns: ${imports.sparqljs}.GroupPattern[] = [];
+
+  ${joinCode(this.memberTypes.map((memberType) => code `\
+unionPatterns.push({ patterns: ${memberType.sparqlWherePatternsFunction}({ filter: filter?.on?.["${memberType.discriminantValues[0]}"], ignoreRdfType: false, schema: schema.members["${memberType.discriminantValues[0]}"].type, ...otherParameters }).concat(), type: "group" });`))}
+  
+  return [{ patterns: unionPatterns, type: "union" }];
+})`;
+    }
+    get typeofs() {
+        return NonEmptyList.fromArray(this.memberTypes.flatMap((memberType) => memberType.typeofs)).unsafeCoerce();
     }
     fromJsonExpression({ variables, }) {
         return this.ternaryExpression({
@@ -241,8 +321,8 @@ ${this.memberTypes
                         value: memberType.payload(variables.value),
                     },
                 });
-                if (this._discriminator.kind === "syntheticProperty") {
-                    typeExpression = `{ ${this._discriminator.name}: "${memberType.discriminatorValues[0]}" as const, value: ${typeExpression} }`;
+                if (this.discriminant.kind === "envelope") {
+                    typeExpression = code `{ ${this.discriminant.name}: "${memberType.discriminantValues[0]}" as const, value: ${typeExpression} }`;
                 }
                 return typeExpression;
             },
@@ -250,18 +330,25 @@ ${this.memberTypes
         });
     }
     fromRdfExpression({ variables, }) {
-        return this.memberTypes.reduce((expression, memberType) => {
+        return code `${variables.resourceValues}.chain(values => values.chainMap(value => {
+      const valueAsValues = ${imports.Right}(value.toValues());
+      return ${this.memberTypes.reduce((expression, memberType) => {
             let typeExpression = memberType.fromRdfExpression({
-                variables: { ...variables, ignoreRdfType: false },
+                variables: {
+                    ...variables,
+                    ignoreRdfType: false,
+                    resourceValues: code `valueAsValues`,
+                },
             });
-            if (this._discriminator.kind === "syntheticProperty") {
-                typeExpression = `${typeExpression}.map(value => ({ ${this._discriminator.name}: "${memberType.discriminatorValues[0]}" as const, value }) as (${this.name}))`;
+            if (this.discriminant.kind === "envelope") {
+                typeExpression = code `${typeExpression}.map(values => values.map(value => ({ ${this.discriminant.name}: "${memberType.discriminantValues[0]}" as const, value }) as (${this.name})))`;
             }
-            typeExpression = `(${typeExpression} as purify.Either<Error, rdfjsResource.Resource.Values<${this.name}>>)`;
-            return expression.length > 0
-                ? `${expression}.altLazy(() => ${typeExpression})`
+            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());
+      }))`;
     }
     graphqlResolveExpression(_parameters) {
         throw new Error("not implemented");
@@ -269,145 +356,109 @@ ${this.memberTypes
     hashStatements({ depth, variables, }) {
         const caseBlocks = [];
         for (const memberType of this.memberTypes) {
-            caseBlocks.push(`${memberType.discriminatorValues.map((discriminatorPropertyValue) => `case "${discriminatorPropertyValue}":`).join("\n")} { ${memberType
+            caseBlocks.push(code `${memberType.discriminantValues.map((discriminantPropertyValue) => `case "${discriminantPropertyValue}":`).join()} { ${joinCode(memberType
                 .hashStatements({
                 depth: depth + 1,
                 variables: {
                     hasher: variables.hasher,
-                    value: `${memberType.payload(variables.value)}`,
+                    value: memberType.payload(variables.value),
                 },
             })
-                .join("\n")}; break; }`);
+                .concat())}; break; }`);
         }
-        caseBlocks.push(`default: ${variables.value} satisfies never; throw new Error("unrecognized type");`);
+        caseBlocks.push(code `default: ${variables.value} satisfies never; throw new Error("unrecognized type");`);
         return [
-            `switch (${this.discriminatorVariable(variables.value)}) { ${caseBlocks.join("\n")} }`,
+            code `switch (${this.discriminantVariable(variables.value)}) { ${joinCode(caseBlocks)} }`,
         ];
     }
+    jsonType() {
+        switch (this.discriminant.kind) {
+            case "envelope":
+                return new AbstractType.JsonType(code `(${joinCode(this.memberTypes.map((memberType) => code `{ ${this.discriminant.name}: "${memberType.discriminantValues[0]}", value: ${memberType.jsonType().name} }`), { on: "|" })})`);
+            case "inline":
+            case "typeof":
+                return new AbstractType.JsonType(joinCode(this.memberTypes.map((memberType) => code `${memberType.jsonType({
+                    includeDiscriminantProperty: this.discriminant.kind === "inline",
+                }).name}`), { on: "|" }));
+            default:
+                throw this.discriminant;
+        }
+    }
     jsonUiSchemaElement() {
         return Maybe.empty();
     }
-    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 "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(", ")}])`;
+    jsonZodSchema(_parameters) {
+        switch (this.discriminant.kind) {
+            case "envelope":
+                return code `${imports.z}.discriminatedUnion("${this.discriminant.name}", [${joinCode(this.memberTypes.map((memberType) => code `${imports.z}.object({ ${this.discriminant.name}: ${imports.z}.literal("${memberType.discriminantValues[0]}"), value: ${memberType.jsonZodSchema({ context: "type" })} })`), { on: "," })}])`;
+            case "inline":
+                return code `${imports.z}.discriminatedUnion("${this.discriminant.name}", [${joinCode(this.memberTypes.map((memberType) => memberType.jsonZodSchema({
+                    includeDiscriminantProperty: true,
+                    context: "type",
+                })), { on: "," })}])`;
             case "typeof":
-                return `${variables.zod}.union([${this.memberTypes
-                    .map((memberType) => memberType.jsonZodSchema({ context: "type", variables }))
-                    .join(", ")}])`;
+                return code `${imports.z}.union([${joinCode(this.memberTypes.map((memberType) => memberType.jsonZodSchema({ context: "type" })), { on: "," })}])`;
             default:
-                throw this._discriminator;
+                throw this.discriminant;
         }
     }
-    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,
-            allowIgnoreRdfType: false,
-        })), []);
-    }
-    sparqlWherePatterns(parameters) {
-        let haveEmptyGroup = false; // Only need one empty group
-        return [
-            `{ patterns: [${this.memberTypes
-                .flatMap((memberType) => {
-                const groupPatterns = memberType.sparqlWherePatterns({
-                    ...parameters,
-                    allowIgnoreRdfType: false,
-                });
-                if (groupPatterns.length === 0) {
-                    if (haveEmptyGroup) {
-                        return [];
-                    }
-                    haveEmptyGroup = true;
-                    return [objectInitializer({ patterns: "[]", type: '"group"' })];
-                }
-                return [
-                    objectInitializer({
-                        patterns: `[${groupPatterns.join(", ")}]`,
-                        type: '"group"',
-                    }),
-                ];
-            })
-                .join(", ")}], type: "union" }`,
-        ];
-    }
     toJsonExpression({ variables, }) {
-        switch (this._discriminator.kind) {
-            case "sharedProperty":
-            case "typeof":
+        switch (this.discriminant.kind) {
+            case "envelope":
                 return this.ternaryExpression({
-                    memberTypeExpression: (memberType) => memberType.toJsonExpression({
+                    memberTypeExpression: (memberType) => code `{ ${this.discriminant.name}: "${memberType.discriminantValues[0]}" as const, value: ${memberType.toJsonExpression({
                         variables: {
                             ...variables,
                             value: memberType.payload(variables.value),
                         },
-                    }),
+                    })} }`,
                     variables,
                 });
-            case "syntheticProperty":
+            case "inline":
+            case "typeof":
                 return this.ternaryExpression({
-                    memberTypeExpression: (memberType) => `{ ${this._discriminator.name}: "${memberType.discriminatorValues[0]}" as const, value: ${memberType.toJsonExpression({
+                    memberTypeExpression: (memberType) => memberType.toJsonExpression({
+                        includeDiscriminantProperty: this.discriminant.kind === "inline",
                         variables: {
                             ...variables,
                             value: memberType.payload(variables.value),
                         },
-                    })} }`,
+                    }),
                     variables,
                 });
         }
     }
     toRdfExpression({ variables, }) {
         return this.ternaryExpression({
-            memberTypeExpression: (memberType) => `(${memberType.toRdfExpression({
+            memberTypeExpression: (memberType) => code `(${memberType.toRdfExpression({
                 variables: {
                     ...variables,
                     value: memberType.payload(variables.value),
                 },
-            })} as readonly Parameters<rdfjsResource.MutableResource["add"]>[1][])`,
+            })} as (bigint | boolean | number | string | ${imports.BlankNode} | ${imports.Literal} | ${imports.NamedNode})[])`,
             variables,
         });
     }
-    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}`;
+    discriminantVariable(variableValue) {
+        switch (this.discriminant.kind) {
+            case "envelope":
+            case "inline":
+                return code `${variableValue}.${this.discriminant.name}`;
             case "typeof":
-                return `(typeof ${variableValue})`;
+                return code `(typeof ${variableValue})`;
         }
     }
     ternaryExpression({ memberTypeExpression, variables, }) {
         return this.memberTypes.reduce((expression, memberType) => {
-            if (expression.length === 0) {
+            if (expression === null) {
                 return memberTypeExpression(memberType);
             }
             const memberTypeExpression_ = memberTypeExpression(memberType);
-            if (memberTypeExpression_ === expression) {
+            if (codeEquals(memberTypeExpression_, expression)) {
                 return expression;
             }
-            return `(${memberType.discriminatorValues
-                .map((value) => `${this.discriminatorVariable(variables.value)} === "${value}"`)
-                .join(" || ")}) ? ${memberTypeExpression_} : ${expression}`;
-        }, "");
+            return code `(${joinCode(memberType.discriminantValues.map((value) => code `${this.discriminantVariable(variables.value)} === "${value}"`), { on: "||" })}) ? ${memberTypeExpression_} : ${expression}`;
+        }, null);
     }
 }
 __decorate([
@@ -415,44 +466,62 @@ __decorate([
 ], UnionType.prototype, "conversions", null);
 __decorate([
     Memoize()
-], UnionType.prototype, "discriminatorProperty", null);
+], UnionType.prototype, "discriminantProperty", null);
 __decorate([
     Memoize()
 ], UnionType.prototype, "equalsFunction", null);
 __decorate([
     Memoize()
-], UnionType.prototype, "jsonName", null);
+], UnionType.prototype, "filterFunction", null);
+__decorate([
+    Memoize()
+], UnionType.prototype, "filterType", null);
 __decorate([
     Memoize()
 ], UnionType.prototype, "mutable", null);
 __decorate([
     Memoize()
 ], UnionType.prototype, "name", null);
-function sharedDiscriminatorProperty(memberTypes) {
-    let sharedDiscriminatorProperty;
+__decorate([
+    Memoize()
+], UnionType.prototype, "schema", null);
+__decorate([
+    Memoize()
+], UnionType.prototype, "sparqlConstructTriplesFunction", null);
+__decorate([
+    Memoize()
+], UnionType.prototype, "sparqlWherePatternsFunction", null);
+__decorate([
+    Memoize()
+], UnionType.prototype, "typeofs", null);
+__decorate([
+    Memoize()
+], UnionType.prototype, "jsonType", null);
+function inlineDiscriminantProperty(memberTypes) {
+    let inlineDiscriminantProperty;
     for (const memberType of memberTypes) {
-        const memberTypeDiscriminatorProperty = memberType.discriminatorProperty.extract();
-        if (!memberTypeDiscriminatorProperty) {
-            sharedDiscriminatorProperty = undefined;
+        const memberTypeDiscriminantProperty = memberType.discriminantProperty.extract();
+        if (!memberTypeDiscriminantProperty) {
+            inlineDiscriminantProperty = undefined;
             break;
         }
-        if (!sharedDiscriminatorProperty) {
-            sharedDiscriminatorProperty = {
-                name: memberTypeDiscriminatorProperty.name,
-                ownValues: memberTypeDiscriminatorProperty.ownValues.concat(),
-                descendantValues: memberTypeDiscriminatorProperty.descendantValues.concat(),
+        if (!inlineDiscriminantProperty) {
+            inlineDiscriminantProperty = {
+                name: memberTypeDiscriminantProperty.name,
+                ownValues: memberTypeDiscriminantProperty.ownValues.concat(),
+                descendantValues: memberTypeDiscriminantProperty.descendantValues.concat(),
             };
         }
-        else if (memberTypeDiscriminatorProperty.name === sharedDiscriminatorProperty.name) {
-            sharedDiscriminatorProperty.descendantValues =
-                sharedDiscriminatorProperty.descendantValues.concat(memberTypeDiscriminatorProperty.descendantValues);
-            sharedDiscriminatorProperty.ownValues =
-                sharedDiscriminatorProperty.ownValues.concat(memberTypeDiscriminatorProperty.ownValues);
+        else if (memberTypeDiscriminantProperty.name === inlineDiscriminantProperty.name) {
+            inlineDiscriminantProperty.descendantValues =
+                inlineDiscriminantProperty.descendantValues.concat(memberTypeDiscriminantProperty.descendantValues);
+            inlineDiscriminantProperty.ownValues =
+                inlineDiscriminantProperty.ownValues.concat(memberTypeDiscriminantProperty.ownValues);
         }
         else {
             return undefined;
         }
     }
-    return sharedDiscriminatorProperty;
+    return inlineDiscriminantProperty;
 }
 //# sourceMappingURL=UnionType.js.map