@shaclmate/compiler 3.0.4 → 4.0.0

package/dist/generators/ts/ObjectUnionType.js

@@ -4,630 +4,191 @@ 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 { camelCase, pascalCase } from "change-case";
-import { Maybe } from "purify-ts";
+import { camelCase } from "change-case";
+import { Maybe, NonEmptyList } from "purify-ts";
 import { invariant } from "ts-invariant";
-import { StructureKind, VariableDeclarationKind, } from "ts-morph";
 import { Memoize } from "typescript-memoize";
-import { DeclaredType } from "./DeclaredType.js";
-import { Type } from "./Type.js";
-import { hasherTypeConstraint } from "./_ObjectType/hashFunctionOrMethodDeclarations.js";
-import { objectSetMethodNames } from "./_ObjectType/objectSetMethodNames.js";
-import { sparqlConstructQueryFunctionDeclaration } from "./_ObjectType/sparqlConstructQueryFunctionDeclaration.js";
-import { sparqlConstructQueryStringFunctionDeclaration } from "./_ObjectType/sparqlConstructQueryStringFunctionDeclaration.js";
-import { objectInitializer } from "./objectInitializer.js";
+import { ObjectType_objectSetMethodNames } from "./_ObjectType/ObjectType_objectSetMethodNames.js";
+import { MemberType } from "./_ObjectUnionType/MemberType.js";
+import { ObjectUnionType_equalsFunctionDeclaration } from "./_ObjectUnionType/ObjectUnionType_equalsFunctionDeclaration.js";
+import { ObjectUnionType_filterFunctionDeclaration } from "./_ObjectUnionType/ObjectUnionType_filterFunctionDeclaration.js";
+import { ObjectUnionType_filterTypeDeclaration } from "./_ObjectUnionType/ObjectUnionType_filterTypeDeclaration.js";
+import { ObjectUnionType_graphqlTypeVariableStatement } from "./_ObjectUnionType/ObjectUnionType_graphqlTypeVariableStatement.js";
+import { ObjectUnionType_hashFunctionDeclaration } from "./_ObjectUnionType/ObjectUnionType_hashFunctionDeclaration.js";
+import { ObjectUnionType_identifierTypeDeclarations } from "./_ObjectUnionType/ObjectUnionType_identifierTypeDeclarations.js";
+import { ObjectUnionType_isTypeFunctionDeclaration } from "./_ObjectUnionType/ObjectUnionType_isTypeFunctionDeclaration.js";
+import { jsonFunctionDeclarations } from "./_ObjectUnionType/ObjectUnionType_jsonFunctionDeclarations.js";
+import { ObjectUnionType_jsonTypeAliasDeclaration } from "./_ObjectUnionType/ObjectUnionType_jsonTypeAliasDeclaration.js";
+import { rdfFunctionDeclarations } from "./_ObjectUnionType/ObjectUnionType_rdfFunctionDeclarations.js";
+import { ObjectUnionType_schemaVariableStatement } from "./_ObjectUnionType/ObjectUnionType_schemaVariableStatement.js";
+import { ObjectUnionType_sparqlFunctionDeclarations } from "./_ObjectUnionType/ObjectUnionType_sparqlFunctionDeclarations.js";
+import { ObjectUnionType_typeAliasDeclaration } from "./_ObjectUnionType/ObjectUnionType_typeAliasDeclaration.js";
+import { AbstractDeclaredType } from "./AbstractDeclaredType.js";
+import { imports } from "./imports.js";
+import { snippets } from "./snippets.js";
 import { syntheticNamePrefix } from "./syntheticNamePrefix.js";
-import { tsComment } from "./tsComment.js";
-class MemberType {
-    delegate;
-    universe;
-    constructor({ delegate, universe, }) {
-        this.delegate = delegate;
-        this.universe = universe;
-    }
-    get declarationType() {
-        return this.delegate.declarationType;
-    }
-    get descendantFromRdfTypeVariables() {
-        return this.delegate.descendantFromRdfTypeVariables;
-    }
-    get discriminatorPropertyValues() {
-        // 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.ownValues.concat(this.delegate._discriminatorProperty.descendantValues.filter((value) => !memberOwnDiscriminatorPropertyValues.has(value)));
-    }
-    get features() {
-        return this.delegate.features;
-    }
-    get fromRdfType() {
-        return this.delegate.fromRdfType;
-    }
-    get fromRdfTypeVariable() {
-        return this.delegate.fromRdfTypeVariable;
-    }
-    get graphqlName() {
-        return this.delegate.graphqlName;
-    }
-    get identifierTypeAlias() {
-        return this.delegate.identifierTypeAlias;
-    }
-    get jsonName() {
-        return this.delegate.jsonName;
-    }
-    get mutable() {
-        return this.delegate.mutable;
-    }
-    get name() {
-        return this.delegate.name;
-    }
-    get staticModuleName() {
-        return this.delegate.staticModuleName;
-    }
-    get toRdfjsResourceType() {
-        return this.delegate.toRdfjsResourceType;
-    }
-    jsonZodSchema(parameters) {
-        return this.delegate.jsonZodSchema(parameters);
-    }
-    newExpression(parameters) {
-        return this.delegate.newExpression(parameters);
-    }
-    snippetDeclarations(parameters) {
-        return this.delegate.snippetDeclarations(parameters);
-    }
-    useImports() {
-        return this.delegate.useImports();
-    }
-}
-__decorate([
-    Memoize()
-], MemberType.prototype, "discriminatorPropertyValues", null);
+import { code, def, joinCode } from "./ts-poet-wrapper.js";
 /**
  * A union of object types, generated as a type alias
  *
  *   type SomeUnion = Member1 | Member2 | ...
  *
- * with associated functions that switch on the type discriminator property and delegate to the appropriate
+ * with associated functions that switch on the type discriminant property and delegate to the appropriate
  * member type code.
  *
  * It also generates SPARQL graph patterns that UNION the member object types.
  */
-export class ObjectUnionType extends DeclaredType {
-    _discriminatorProperty;
-    comment;
-    label;
+export class ObjectUnionType extends AbstractDeclaredType {
+    graphqlArgs = Maybe.empty();
     identifierType;
     kind = "ObjectUnionType";
     memberTypes;
-    typeof = "object";
-    constructor({ comment, identifierType, label, memberTypes, ...superParameters }) {
+    typeofs = NonEmptyList(["object"]);
+    constructor({ identifierType, memberTypes, ...superParameters }) {
         super(superParameters);
-        this.comment = comment;
         this.identifierType = identifierType;
-        this.label = label;
         invariant(memberTypes.length > 0);
-        const discriminatorPropertyDescendantValues = [];
-        const discriminatorPropertyName = memberTypes[0].discriminatorProperty.unsafeCoerce().name;
-        const discriminatorPropertyOwnValues = [];
-        for (const memberType of memberTypes) {
-            invariant(memberType.declarationType === memberTypes[0].declarationType);
-            invariant(memberType._discriminatorProperty.name === discriminatorPropertyName);
-            discriminatorPropertyDescendantValues.push(...memberType._discriminatorProperty.descendantValues);
-            discriminatorPropertyOwnValues.push(...memberType._discriminatorProperty.ownValues);
-        }
-        this._discriminatorProperty = {
-            descendantValues: discriminatorPropertyDescendantValues,
-            name: discriminatorPropertyName,
-            ownValues: discriminatorPropertyOwnValues,
-        };
-        this.memberTypes = memberTypes.map((memberType) => new MemberType({ delegate: memberType, universe: memberTypes }));
+        this.memberTypes = memberTypes.map((memberType) => new MemberType({
+            delegate: memberType,
+            universe: memberTypes,
+        }));
     }
     get conversions() {
         return [
             {
                 conversionExpression: (value) => value,
-                sourceTypeCheckExpression: (value) => `typeof ${value} === "object"`,
+                sourceTypeCheckExpression: (value) => code `typeof ${value} === "object"`,
                 sourceTypeName: this.name,
+                sourceTypeof: "object",
             },
         ];
     }
-    get declarationImports() {
-        return this.memberTypes.flatMap((memberType) => memberType.useImports());
-    }
-    get declarations() {
-        const declarations = [this.typeAliasDeclaration];
-        const staticModuleStatements = [
-            ...this.equalsFunctionDeclaration.toList(),
-            ...this.fromJsonFunctionDeclaration.toList(),
-            ...this.fromRdfFunctionDeclaration.toList(),
-            ...this.graphqlTypeVariableStatement.toList(),
-            ...this.hashFunctionDeclaration.toList(),
-            ...this.jsonTypeAliasDeclaration.toList(),
-            ...this.jsonZodSchemaFunctionDeclaration.toList(),
-            ...this.identifierTypeDeclarations,
-            ...this.sparqlFunctionDeclarations,
-            ...this.toJsonFunctionDeclaration.toList(),
-            ...this.toRdfFunctionDeclaration.toList(),
+    get declaration() {
+        const declarations = [
+            ObjectUnionType_typeAliasDeclaration.bind(this)(),
         ];
-        if (staticModuleStatements.length > 0) {
-            declarations.push({
-                isExported: this.export,
-                kind: StructureKind.Module,
-                name: this.staticModuleName,
-                statements: staticModuleStatements,
-            });
+        const staticModuleDeclarations = [
+            ...ObjectUnionType_equalsFunctionDeclaration.bind(this)().toList(),
+            ObjectUnionType_filterFunctionDeclaration.bind(this)(),
+            ObjectUnionType_filterTypeDeclaration.bind(this)(),
+            ...ObjectUnionType_graphqlTypeVariableStatement.bind(this)().toList(),
+            ...ObjectUnionType_hashFunctionDeclaration.bind(this)().toList(),
+            ...ObjectUnionType_identifierTypeDeclarations.bind(this)(),
+            ...jsonFunctionDeclarations.bind(this)(),
+            ...ObjectUnionType_jsonTypeAliasDeclaration.bind(this)().toList(),
+            ...ObjectUnionType_isTypeFunctionDeclaration.bind(this)().toList(),
+            ObjectUnionType_schemaVariableStatement.bind(this)(),
+            ...rdfFunctionDeclarations.bind(this)(),
+            ...ObjectUnionType_sparqlFunctionDeclarations.bind(this)(),
+        ];
+        if (staticModuleDeclarations.length > 0) {
+            declarations.push(code `\
+export namespace ${def(this.staticModuleName)} {
+${joinCode(staticModuleDeclarations, { on: "\n\n" })}
+}`);
         }
-        return declarations;
+        return joinCode(declarations, { on: "\n\n" });
     }
-    get discriminatorProperty() {
-        return Maybe.of(this._discriminatorProperty);
+    get discriminantProperty() {
+        return Maybe.of(this._discriminantProperty);
     }
     get equalsFunction() {
-        return `${this.staticModuleName}.${syntheticNamePrefix}equals`;
+        return code `${this.staticModuleName}.${syntheticNamePrefix}equals`;
     }
-    get graphqlName() {
-        return new Type.GraphqlName(`${this.staticModuleName}.${syntheticNamePrefix}GraphQL`);
+    get filterFunction() {
+        return code `${this.staticModuleName}.${syntheticNamePrefix}filter`;
     }
-    get identifierTypeAlias() {
-        return `${this.staticModuleName}.${syntheticNamePrefix}Identifier`;
+    get filterType() {
+        return code `${this.staticModuleName}.${syntheticNamePrefix}Filter`;
     }
-    get jsonName() {
-        return new Type.JsonName(this.memberTypes.map((memberType) => memberType.jsonName).join(" | "));
+    get graphqlType() {
+        return new AbstractDeclaredType.GraphqlType(code `${this.staticModuleName}.${syntheticNamePrefix}GraphQL`);
+    }
+    get identifierTypeAlias() {
+        return code `${this.staticModuleName}.${syntheticNamePrefix}Identifier`;
     }
     get mutable() {
         return this.memberTypes.some((memberType) => memberType.mutable);
     }
     get objectSetMethodNames() {
-        return objectSetMethodNames.bind(this)();
-    }
-    get staticModuleName() {
-        return this.name;
-    }
-    get thisVariable() {
-        return `_${camelCase(this.name)}`;
-    }
-    get equalsFunctionDeclaration() {
-        if (!this.features.has("equals")) {
-            return Maybe.empty();
-        }
-        const caseBlocks = this.memberTypes.map((memberType) => {
-            let returnExpression;
-            switch (memberType.declarationType) {
-                case "class":
-                    returnExpression = `left.${syntheticNamePrefix}equals(right as unknown as ${memberType.name})`;
-                    break;
-                case "interface":
-                    returnExpression = `${memberType.staticModuleName}.${syntheticNamePrefix}equals(left, right as unknown as ${memberType.name})`;
-                    break;
-            }
-            return `${memberType.discriminatorPropertyValues.map((discriminatorPropertyValue) => `case "${discriminatorPropertyValue}":`).join("\n")} return ${returnExpression};`;
-        });
-        caseBlocks.push('default: left satisfies never; throw new Error("unrecognized type");');
-        return Maybe.of({
-            isExported: true,
-            kind: StructureKind.Function,
-            name: `${syntheticNamePrefix}equals`,
-            parameters: [
-                {
-                    name: "left",
-                    type: this.name,
-                },
-                {
-                    name: "right",
-                    type: this.name,
-                },
-            ],
-            returnType: `${syntheticNamePrefix}EqualsResult`,
-            statements: `\
-return ${syntheticNamePrefix}strictEquals(left.${syntheticNamePrefix}type, right.${syntheticNamePrefix}type).chain(() => {
-  switch (left.${this._discriminatorProperty.name}) {
-   ${caseBlocks.join(" ")}
-  }
-})`,
-        });
+        return ObjectType_objectSetMethodNames.bind(this)();
     }
-    get fromJsonFunctionDeclaration() {
-        if (!this.features.has("json")) {
-            return Maybe.empty();
-        }
-        return Maybe.of({
-            isExported: true,
-            kind: StructureKind.Function,
-            name: `${syntheticNamePrefix}fromJson`,
-            parameters: [
-                {
-                    name: "json",
-                    type: "unknown",
-                },
-            ],
-            returnType: `purify.Either<zod.ZodError, ${this.name}>`,
-            statements: [
-                `return ${this.memberTypes.reduce((expression, memberType) => {
-                    const memberTypeExpression = `(${memberType.staticModuleName}.${syntheticNamePrefix}fromJson(json) as purify.Either<zod.ZodError, ${this.name}>)`;
-                    return expression.length > 0
-                        ? `${expression}.altLazy(() => ${memberTypeExpression})`
-                        : memberTypeExpression;
-                }, "")};`,
-            ],
-        });
+    get schema() {
+        return code `${this.staticModuleName}.${syntheticNamePrefix}schema`;
     }
-    get fromRdfFunctionDeclaration() {
-        if (!this.features.has("rdf")) {
-            return Maybe.empty();
-        }
-        return Maybe.of({
-            isExported: true,
-            kind: StructureKind.Function,
-            name: `${syntheticNamePrefix}fromRdf`,
-            parameters: [
-                {
-                    name: "resource",
-                    type: "rdfjsResource.Resource",
-                },
-                {
-                    hasQuestionToken: true,
-                    name: "options",
-                    type: `{ [_index: string]: any; ignoreRdfType?: boolean; objectSet?: ${syntheticNamePrefix}ObjectSet; preferredLanguages?: readonly string[] }`,
-                },
-            ],
-            returnType: `purify.Either<Error, ${this.name}>`,
-            statements: [
-                `return ${this.memberTypes.reduce((expression, memberType) => {
-                    const memberTypeExpression = `(${memberType.staticModuleName}.${syntheticNamePrefix}fromRdf(resource, { ...options, ignoreRdfType: false }) as purify.Either<Error, ${this.name}>)`;
-                    return expression.length > 0
-                        ? `${expression}.altLazy(() => ${memberTypeExpression})`
-                        : memberTypeExpression;
-                }, "")};`,
-            ],
-        });
+    get schemaType() {
+        return code `typeof ${this.schema}`;
     }
-    get graphqlTypeVariableStatement() {
-        if (!this.features.has("graphql")) {
-            return Maybe.empty();
-        }
-        return Maybe.of({
-            declarationKind: VariableDeclarationKind.Const,
-            kind: StructureKind.VariableStatement,
-            declarations: [
-                {
-                    name: `${syntheticNamePrefix}GraphQL`,
-                    initializer: `new graphql.GraphQLUnionType(${objectInitializer({
-                        description: this.comment.map(JSON.stringify).extract(),
-                        name: `"${this.name}"`,
-                        resolveType: `(value: ${this.name}) => value.${syntheticNamePrefix}type`,
-                        types: `[${this.memberTypes.map((memberType) => memberType.graphqlName.nullableName).join(", ")}]`,
-                    })})`,
-                },
-            ],
-            isExported: true,
-        });
-    }
-    get hashFunctionDeclaration() {
-        if (!this.features.has("hash")) {
-            return Maybe.empty();
-        }
-        const hasherVariable = "_hasher";
-        const caseBlocks = this.memberTypes.map((memberType) => {
-            let returnExpression;
-            switch (memberType.declarationType) {
-                case "class":
-                    returnExpression = `${this.thisVariable}.${syntheticNamePrefix}hash(${hasherVariable})`;
-                    break;
-                case "interface":
-                    returnExpression = `${memberType.staticModuleName}.${syntheticNamePrefix}hash(${this.thisVariable}, ${hasherVariable})`;
-                    break;
-            }
-            return `${memberType.discriminatorPropertyValues.map((discriminatorPropertyValue) => `case "${discriminatorPropertyValue}":`).join("\n")} return ${returnExpression};`;
-        });
-        caseBlocks.push(`default: ${this.thisVariable} satisfies never; throw new Error("unrecognized type");`);
-        return Maybe.of({
-            isExported: true,
-            kind: StructureKind.Function,
-            name: `${syntheticNamePrefix}hash`,
-            parameters: [
-                {
-                    name: this.thisVariable,
-                    type: this.name,
-                },
-                {
-                    name: hasherVariable,
-                    type: "HasherT",
-                },
-            ],
-            returnType: "HasherT",
-            statements: `switch (${this.thisVariable}.${this._discriminatorProperty.name}) { ${caseBlocks.join(" ")} }`,
-            typeParameters: [
-                {
-                    name: "HasherT",
-                    constraint: hasherTypeConstraint,
-                },
-            ],
-        });
+    get sparqlConstructTriplesFunction() {
+        return code `(({ ignoreRdfType, schema, ...otherParameters }: ${snippets.SparqlConstructTriplesFunctionParameters}<${this.filterType}, ${this.schemaType}>) => ${this.staticModuleName}.${syntheticNamePrefix}sparqlConstructTriples(otherParameters))`;
     }
-    get identifierTypeDeclarations() {
-        return [
-            {
-                isExported: true,
-                kind: StructureKind.TypeAlias,
-                name: `${syntheticNamePrefix}Identifier`,
-                type: this.identifierType.name,
-            },
-            {
-                isExported: true,
-                kind: StructureKind.Module,
-                name: `${syntheticNamePrefix}Identifier`,
-                statements: [
-                    this.identifierType.fromStringFunctionDeclaration,
-                    this.identifierType.toStringFunctionDeclaration,
-                ],
-            },
-        ];
+    get sparqlWherePatternsFunction() {
+        return code `(({ ignoreRdfType, propertyPatterns, schema, valueVariable, ...otherParameters }: ${snippets.SparqlWherePatternsFunctionParameters}<${this.filterType}, ${this.schemaType}>) => (propertyPatterns as readonly ${snippets.SparqlPattern}[]).concat(${this.staticModuleName}.${syntheticNamePrefix}sparqlWherePatterns({ focusIdentifier: valueVariable, ...otherParameters })))`;
     }
-    get jsonTypeAliasDeclaration() {
-        if (!this.features.has("json")) {
-            return Maybe.empty();
-        }
-        return Maybe.of({
-            isExported: true,
-            kind: StructureKind.TypeAlias,
-            name: `${syntheticNamePrefix}Json`,
-            type: this.memberTypes
-                .map((memberType) => memberType.jsonName)
-                .join(" | "),
-        });
-    }
-    get jsonZodSchemaFunctionDeclaration() {
-        if (!this.features.has("json")) {
-            return Maybe.empty();
-        }
-        const variables = { zod: "zod" };
-        return Maybe.of({
-            isExported: true,
-            kind: StructureKind.Function,
-            name: `${syntheticNamePrefix}jsonZodSchema`,
-            statements: `return ${variables.zod}.discriminatedUnion("${this._discriminatorProperty.name}", [${this.memberTypes.map((memberType) => memberType.jsonZodSchema({ context: "type", variables })).join(", ")}]);`,
-        });
-    }
-    get sparqlFunctionDeclarations() {
-        if (!this.features.has("sparql")) {
-            return [];
-        }
-        return [
-            sparqlConstructQueryFunctionDeclaration.bind(this)(),
-            sparqlConstructQueryStringFunctionDeclaration.bind(this)(),
-            {
-                isExported: true,
-                kind: StructureKind.Function,
-                name: `${syntheticNamePrefix}sparqlConstructTemplateTriples`,
-                // Accept ignoreRdfType in order to reuse code but don't pass it through, since deserialization may depend on it
-                parameters: [
-                    {
-                        hasQuestionToken: true,
-                        name: "parameters",
-                        type: '{ ignoreRdfType?: boolean, subject?: sparqljs.Triple["subject"], variablePrefix?: string }',
-                    },
-                ],
-                returnType: "readonly sparqljs.Triple[]",
-                statements: [
-                    `return [${this.memberTypes
-                        .map((memberType) => `...${memberType.staticModuleName}.${syntheticNamePrefix}sparqlConstructTemplateTriples({ subject: parameters?.subject ?? dataFactory.variable!("${camelCase(this.name)}${pascalCase(memberType.name)}"), variablePrefix: parameters?.variablePrefix ? \`\${parameters.variablePrefix}${pascalCase(memberType.name)}\` : "${camelCase(this.name)}${pascalCase(memberType.name)}" }).concat()`)
-                        .join(", ")}];`,
-                ],
-            },
-            {
-                isExported: true,
-                kind: StructureKind.Function,
-                name: `${syntheticNamePrefix}sparqlWherePatterns`,
-                // Accept ignoreRdfType in order to reuse code but don't pass it through, since deserialization may depend on it
-                parameters: [
-                    {
-                        hasQuestionToken: true,
-                        name: "parameters",
-                        type: '{ ignoreRdfType?: boolean; preferredLanguages?: readonly string[]; subject?: sparqljs.Triple["subject"], variablePrefix?: string }',
-                    },
-                ],
-                returnType: "readonly sparqljs.Pattern[]",
-                statements: [
-                    `return [{ patterns: [${this.memberTypes
-                        .map((memberType) => objectInitializer({
-                        patterns: `${memberType.staticModuleName}.${syntheticNamePrefix}sparqlWherePatterns({ subject: parameters?.subject ?? dataFactory.variable!("${camelCase(this.name)}${pascalCase(memberType.name)}"), variablePrefix: parameters?.variablePrefix ? \`\${parameters.variablePrefix}${pascalCase(memberType.name)}\` : "${camelCase(this.name)}${pascalCase(memberType.name)}" }).concat()`,
-                        type: '"group"',
-                    }))
-                        .join(", ")}], type: "union" }];`,
-                ],
-            },
-        ];
-    }
-    get toJsonFunctionDeclaration() {
-        if (!this.features.has("json")) {
-            return Maybe.empty();
-        }
-        const caseBlocks = this.memberTypes.map((memberType) => {
-            let returnExpression;
-            switch (memberType.declarationType) {
-                case "class":
-                    returnExpression = `${this.thisVariable}.${syntheticNamePrefix}toJson()`;
-                    break;
-                case "interface":
-                    returnExpression = `${memberType.staticModuleName}.${syntheticNamePrefix}toJson(${this.thisVariable})`;
-                    break;
-            }
-            return `${memberType.discriminatorPropertyValues.map((discriminatorPropertyValue) => `case "${discriminatorPropertyValue}":`).join("\n")} return ${returnExpression};`;
-        });
-        caseBlocks.push(`default: ${this.thisVariable} satisfies never; throw new Error("unrecognized type");`);
-        return Maybe.of({
-            isExported: true,
-            kind: StructureKind.Function,
-            name: `${syntheticNamePrefix}toJson`,
-            parameters: [
-                {
-                    name: this.thisVariable,
-                    type: this.name,
-                },
-            ],
-            returnType: this.jsonName.toString(),
-            statements: `switch (${this.thisVariable}.${this._discriminatorProperty.name}) { ${caseBlocks.join(" ")} }`,
-        });
+    get staticModuleName() {
+        return this.name;
     }
-    get toRdfFunctionDeclaration() {
-        if (!this.features.has("rdf")) {
-            return Maybe.empty();
+    get _discriminantProperty() {
+        const discriminantPropertyDescendantValues = [];
+        const discriminantPropertyName = this.memberTypes[0]._discriminantProperty.name;
+        const discriminantPropertyOwnValues = [];
+        for (const memberType of this.memberTypes) {
+            // invariant(
+            //   memberType.declarationType === this.memberTypes[0].declarationType,
+            // );
+            invariant(memberType._discriminantProperty.name === discriminantPropertyName);
+            discriminantPropertyDescendantValues.push(...memberType._discriminantProperty.descendantValues);
+            discriminantPropertyOwnValues.push(...memberType._discriminantProperty.ownValues);
         }
-        const parametersVariable = "_parameters";
-        const caseBlocks = this.memberTypes.map((memberType) => {
-            let returnExpression;
-            switch (memberType.declarationType) {
-                case "class":
-                    returnExpression = `${this.thisVariable}.${syntheticNamePrefix}toRdf(${parametersVariable})`;
-                    break;
-                case "interface":
-                    returnExpression = `${memberType.staticModuleName}.${syntheticNamePrefix}toRdf(${this.thisVariable}, ${parametersVariable})`;
-                    break;
-            }
-            return `${memberType.discriminatorPropertyValues.map((discriminatorPropertyValue) => `case "${discriminatorPropertyValue}":`).join("\n")} return ${returnExpression};`;
-        });
-        caseBlocks.push(`default: ${this.thisVariable} satisfies never; throw new Error("unrecognized type");`);
-        return Maybe.of({
-            isExported: true,
-            kind: StructureKind.Function,
-            name: `${syntheticNamePrefix}toRdf`,
-            parameters: [
-                {
-                    name: this.thisVariable,
-                    type: this.name,
-                },
-                {
-                    hasQuestionToken: true,
-                    name: parametersVariable,
-                    type: "{ mutateGraph?: rdfjsResource.MutableResource.MutateGraph, resourceSet?: rdfjsResource.MutableResourceSet }",
-                },
-            ],
-            returnType: (() => {
-                let returnType;
-                for (const memberType of this.memberTypes) {
-                    const memberRdfjsResourceType = memberType.toRdfjsResourceType;
-                    if (typeof returnType === "undefined") {
-                        returnType = memberRdfjsResourceType;
-                    }
-                    else if (memberRdfjsResourceType !== returnType) {
-                        return "rdfjsResource.Resource";
-                    }
-                }
-                // The types agree
-                return returnType;
-            })(),
-            statements: `switch (${this.thisVariable}.${this._discriminatorProperty.name}) { ${caseBlocks.join(" ")} }`,
-        });
-    }
-    get typeAliasDeclaration() {
         return {
-            isExported: true,
-            leadingTrivia: this.comment.alt(this.label).map(tsComment).extract(),
-            kind: StructureKind.TypeAlias,
-            name: this.name,
-            type: this.memberTypes.map((memberType) => memberType.name).join(" | "),
+            descendantValues: discriminantPropertyDescendantValues,
+            name: discriminantPropertyName,
+            ownValues: discriminantPropertyOwnValues,
         };
     }
+    get concreteMemberTypes() {
+        return this.memberTypes.filter((memberType) => !memberType.abstract);
+    }
+    get thisVariable() {
+        return code `_${camelCase(this.name)}`;
+    }
     fromJsonExpression({ variables, }) {
         // Assumes the JSON object has been recursively validated already.
-        return `${this.staticModuleName}.${syntheticNamePrefix}fromJson(${variables.value}).unsafeCoerce()`;
+        return code `${this.staticModuleName}.${syntheticNamePrefix}fromJson(${variables.value}).unsafeCoerce()`;
     }
     fromRdfExpression({ variables, }) {
         // Don't ignoreRdfType, we may need it to distinguish the union members
-        return `${variables.resourceValues}.chain(values => values.chainMap(value => value.toResource().chain(resource => ${this.staticModuleName}.${syntheticNamePrefix}fromRdf(resource, { ...${variables.context}, ignoreRdfType: false, objectSet: ${variables.objectSet}, preferredLanguages: ${variables.preferredLanguages} }))))`;
+        return code `${variables.resourceValues}.chain(values => values.chainMap(value => value.toResource().chain(resource => ${this.staticModuleName}.${syntheticNamePrefix}fromRdf(resource, { context: ${variables.context}, ignoreRdfType: false, objectSet: ${variables.objectSet}, preferredLanguages: ${variables.preferredLanguages} }))))`;
     }
     graphqlResolveExpression({ variables, }) {
         return variables.value;
     }
     hashStatements({ variables, }) {
-        switch (this.memberTypes[0].declarationType) {
-            case "class":
-                return [
-                    `${variables.value}.${syntheticNamePrefix}hash(${variables.hasher});`,
-                ];
-            case "interface":
-                return [
-                    `${this.staticModuleName}.${syntheticNamePrefix}hash(${variables.value}, ${variables.hasher});`,
-                ];
-        }
+        return [
+            code `${this.staticModuleName}.${syntheticNamePrefix}hash(${variables.value}, ${variables.hasher});`,
+        ];
+    }
+    jsonType() {
+        return new AbstractDeclaredType.JsonType(joinCode(this.memberTypes.map((memberType) => code `${memberType.jsonType().name}`), { on: "|" }));
     }
     jsonUiSchemaElement() {
         return Maybe.empty();
     }
-    jsonZodSchema() {
-        return `${this.staticModuleName}.${syntheticNamePrefix}jsonZodSchema()`;
-    }
-    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) {
-        switch (parameters.context) {
-            case "object":
-                return super.sparqlConstructTemplateTriples(parameters);
-            case "subject":
-                return [
-                    `...${this.staticModuleName}.${syntheticNamePrefix}sparqlConstructTemplateTriples(${objectInitializer({
-                        subject: parameters.variables.subject,
-                        variablePrefix: parameters.variables.variablePrefix,
-                    })})`,
-                ];
-        }
-    }
-    sparqlWherePatterns(parameters) {
-        switch (parameters.context) {
-            case "object":
-                return super.sparqlWherePatterns(parameters);
-            case "subject":
-                return [
-                    `...${this.staticModuleName}.${syntheticNamePrefix}sparqlWherePatterns(${objectInitializer({
-                        preferredLanguages: parameters.variables.preferredLanguages,
-                        subject: parameters.variables.subject,
-                        variablePrefix: parameters.variables.variablePrefix,
-                    })})`,
-                ];
+    jsonZodSchema({ context, }) {
+        const expression = code `${this.staticModuleName}.${syntheticNamePrefix}jsonZodSchema()`;
+        for (const memberType of this.memberTypes) {
+            if (context === "property" &&
+                memberType.properties.some((property) => property.recursive)) {
+                return code `${imports.z}.lazy((): ${imports.z}.ZodType<${this.staticModuleName}.${syntheticNamePrefix}Json> => ${expression})`;
+            }
         }
+        return expression;
     }
     toJsonExpression({ variables, }) {
-        switch (this.memberTypes[0].declarationType) {
-            case "class":
-                return `${variables.value}.${syntheticNamePrefix}toJson()`;
-            case "interface":
-                return `${this.staticModuleName}.${syntheticNamePrefix}toJson(${variables.value})`;
-        }
+        return code `${this.staticModuleName}.${syntheticNamePrefix}toJson(${variables.value})`;
     }
     toRdfExpression({ variables, }) {
-        const options = `{ mutateGraph: ${variables.mutateGraph}, resourceSet: ${variables.resourceSet} }`;
-        switch (this.memberTypes[0].declarationType) {
-            case "class":
-                return `[${variables.value}.${syntheticNamePrefix}toRdf(${options}).identifier]`;
-            case "interface":
-                return `[${this.staticModuleName}.${syntheticNamePrefix}toRdf(${variables.value}, ${options}).identifier]`;
-        }
-    }
-    useImports() {
-        return [];
+        return code `[${this.staticModuleName}.${syntheticNamePrefix}toRdf(${variables.value}, ${{ graph: variables.graph, resourceSet: variables.resourceSet }}).identifier]`;
     }
 }
 __decorate([
@@ -635,26 +196,50 @@ __decorate([
 ], ObjectUnionType.prototype, "conversions", null);
 __decorate([
     Memoize()
-], ObjectUnionType.prototype, "discriminatorProperty", null);
+], ObjectUnionType.prototype, "discriminantProperty", null);
 __decorate([
     Memoize()
 ], ObjectUnionType.prototype, "equalsFunction", null);
 __decorate([
     Memoize()
-], ObjectUnionType.prototype, "graphqlName", null);
+], ObjectUnionType.prototype, "filterFunction", null);
 __decorate([
     Memoize()
-], ObjectUnionType.prototype, "identifierTypeAlias", null);
+], ObjectUnionType.prototype, "filterType", null);
+__decorate([
+    Memoize()
+], ObjectUnionType.prototype, "graphqlType", null);
 __decorate([
     Memoize()
-], ObjectUnionType.prototype, "jsonName", null);
+], ObjectUnionType.prototype, "identifierTypeAlias", null);
 __decorate([
     Memoize()
 ], ObjectUnionType.prototype, "mutable", null);
 __decorate([
     Memoize()
 ], ObjectUnionType.prototype, "objectSetMethodNames", null);
+__decorate([
+    Memoize()
+], ObjectUnionType.prototype, "schema", null);
+__decorate([
+    Memoize()
+], ObjectUnionType.prototype, "schemaType", null);
+__decorate([
+    Memoize()
+], ObjectUnionType.prototype, "sparqlConstructTriplesFunction", null);
+__decorate([
+    Memoize()
+], ObjectUnionType.prototype, "sparqlWherePatternsFunction", null);
+__decorate([
+    Memoize()
+], ObjectUnionType.prototype, "_discriminantProperty", null);
+__decorate([
+    Memoize()
+], ObjectUnionType.prototype, "concreteMemberTypes", null);
 __decorate([
     Memoize()
 ], ObjectUnionType.prototype, "thisVariable", null);
+__decorate([
+    Memoize()
+], ObjectUnionType.prototype, "jsonType", null);
 //# sourceMappingURL=ObjectUnionType.js.map