@shaclmate/compiler 4.0.60 → 4.0.62

package/dist/generators/ts/DiscriminatedUnionType.js

@@ -7,6 +7,22 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 import { Maybe } from "purify-ts";
 import { invariant } from "ts-invariant";
 import { Memoize } from "typescript-memoize";
+import { DiscriminatedUnionType_equalsFunctionExpression } from "./_DiscriminatedUnionType/DiscriminatedUnionType_equalsFunctionExpression.js";
+import { DiscriminatedUnionType_filterFunctionExpression } from "./_DiscriminatedUnionType/DiscriminatedUnionType_filterFunctionExpression.js";
+import { DiscriminatedUnionType_filterTypeExpression } from "./_DiscriminatedUnionType/DiscriminatedUnionType_filterTypeExpression.js";
+import { DiscriminatedUnionType_fromJsonFunctionExpression } from "./_DiscriminatedUnionType/DiscriminatedUnionType_fromJsonFunctionExpression.js";
+import { DiscriminatedUnionType_fromRdfResourceValuesFunctionExpression } from "./_DiscriminatedUnionType/DiscriminatedUnionType_fromRdfResourceValuesFunctionExpression.js";
+import { DiscriminatedUnionType_hashFunctionExpression } from "./_DiscriminatedUnionType/DiscriminatedUnionType_hashFunctionExpression.js";
+import { DiscriminatedUnionType_inferDiscriminant } from "./_DiscriminatedUnionType/DiscriminatedUnionType_inferDiscriminant.js";
+import { DiscriminatedUnionType_inlineExpression } from "./_DiscriminatedUnionType/DiscriminatedUnionType_inlineExpression.js";
+import { DiscriminatedUnionType_jsonSchemaExpression } from "./_DiscriminatedUnionType/DiscriminatedUnionType_jsonSchemaExpression.js";
+import { DiscriminatedUnionType_jsonTypeLiteral } from "./_DiscriminatedUnionType/DiscriminatedUnionType_jsonTypeLiteral.js";
+import { DiscriminatedUnionType_schemaTypeExpression } from "./_DiscriminatedUnionType/DiscriminatedUnionType_schemaTypeExpression.js";
+import { DiscriminatedUnionType_toJsonFunctionExpression } from "./_DiscriminatedUnionType/DiscriminatedUnionType_toJsonFunctionExpression.js";
+import { DiscriminatedUnionType_toRdfResourceValuesFunctionExpression } from "./_DiscriminatedUnionType/DiscriminatedUnionType_toRdfResourceValuesFunctionExpression.js";
+import { DiscriminatedUnionType_toStringFunctionExpression } from "./_DiscriminatedUnionType/DiscriminatedUnionType_toStringFunctionExpression.js";
+import { DiscriminatedUnionType_valueSparqlConstructTriplesFunctionExpression } from "./_DiscriminatedUnionType/DiscriminatedUnionType_valueSparqlConstructTriplesFunctionExpression.js";
+import { DiscriminatedUnionType_valueSparqlWherePatternsFunctionExpression } from "./_DiscriminatedUnionType/DiscriminatedUnionType_valueSparqlWherePatternsFunctionExpression.js";
 import { AbstractType } from "./AbstractType.js";
 import { code, def, joinCode, literalOf, } from "./ts-poet-wrapper.js";
 export class DiscriminatedUnionType extends AbstractType {
@@ -22,11 +38,10 @@ export class DiscriminatedUnionType extends AbstractType {
         this.identifierType = identifierType;
         invariant(members.length >= 2);
         this.recursive = recursive;
-        this.discriminant = Discriminant.infer(members);
+        this.discriminant = DiscriminatedUnionType_inferDiscriminant.call(this, members);
         this.synthetic = synthetic;
         this.lazyMembers = () => members.map((member, memberI) => {
             let discriminantValues;
-            invariant(this.discriminant.memberValues.length === members.length);
             switch (this.discriminant.kind) {
                 case "Extrinsic":
                     discriminantValues = [this.discriminant.memberValues[memberI]];
@@ -137,7 +152,7 @@ export class DiscriminatedUnionType extends AbstractType {
         }
         const declarations = [];
         if (this.configuration.features.has("Object.type")) {
-            declarations.push(code `export type ${def(name)} = ${this.inlineExpression};`);
+            declarations.push(code `export type ${def(name)} = ${DiscriminatedUnionType_inlineExpression.call(this)};`);
         }
         const staticModuleDeclarations = Object.entries(this.staticModuleDeclarations);
         if (staticModuleDeclarations.length > 0) {
@@ -179,27 +194,27 @@ ${joinCode(staticModuleDeclarations
     get equalsFunction() {
         return this.name
             .map((name) => code `${name}.equals`)
-            .orDefault(this.equalsFunctionExpression);
+            .orDefault(DiscriminatedUnionType_equalsFunctionExpression.call(this));
     }
     get expression() {
         return this.name
             .map((name) => code `${name}`)
-            .orDefault(this.inlineExpression);
+            .orDefault(DiscriminatedUnionType_inlineExpression.call(this));
     }
     get filterFunction() {
         return this.name
             .map((name) => code `${name}.filter`)
-            .orDefault(this.filterFunctionExpression);
+            .orDefault(DiscriminatedUnionType_filterFunctionExpression.call(this));
     }
     get filterType() {
         return this.name
             .map((name) => code `${name}.Filter`)
-            .orDefault(this.filterTypeLiteral);
+            .orDefault(DiscriminatedUnionType_filterTypeExpression.call(this));
     }
     get fromRdfResourceValuesFunction() {
         return this.name
             .map((name) => code `${name}.fromRdfResourceValues`)
-            .orDefault(this.fromRdfResourceValuesFunctionExpression);
+            .orDefault(DiscriminatedUnionType_fromRdfResourceValuesFunctionExpression.call(this));
     }
     get graphqlType() {
         const name = this.name.extract();
@@ -212,7 +227,7 @@ ${joinCode(staticModuleDeclarations
     get hashFunction() {
         return this.name
             .map((name) => code `${name}.hash`)
-            .orDefault(this.hashFunctionExpression);
+            .orDefault(DiscriminatedUnionType_hashFunctionExpression.call(this));
     }
     get jsTypes() {
         const jsTypes = [];
@@ -226,7 +241,7 @@ ${joinCode(staticModuleDeclarations
         return jsTypes;
     }
     get jsonSchemaFunctionDeclaration() {
-        let expression = this.jsonSchemaExpression;
+        let expression = DiscriminatedUnionType_jsonSchemaExpression.call(this);
         const meta = {
         // id: this.name,
         };
@@ -242,7 +257,7 @@ ${joinCode(staticModuleDeclarations
         return code `export const schema = () => ${expression};`;
     }
     get jsonTypeAliasDeclaration() {
-        return code `export type Json = ${this.jsonTypeLiteral.expression}`;
+        return code `export type Json = ${DiscriminatedUnionType_jsonTypeLiteral.call(this).expression}`;
     }
     get members() {
         return this.lazyMembers();
@@ -262,7 +277,7 @@ ${joinCode(staticModuleDeclarations
     get schemaType() {
         return this.name
             .map(() => code `typeof ${this.schema}`)
-            .orDefault(this.schemaTypeExpression);
+            .orDefault(DiscriminatedUnionType_schemaTypeExpression.call(this));
     }
     get toRdfResourceValueTypes() {
         const set = new Set();
@@ -276,12 +291,12 @@ ${joinCode(staticModuleDeclarations
     get valueSparqlConstructTriplesFunction() {
         return this.name
             .map((name) => code `${name}.valueSparqlConstructTriples`)
-            .orDefault(this.valueSparqlConstructTriplesFunctionExpression);
+            .orDefault(DiscriminatedUnionType_valueSparqlConstructTriplesFunctionExpression.call(this));
     }
     get valueSparqlWherePatternsFunction() {
         return this.name
             .map((name) => code `${name}.valueSparqlWherePatterns`)
-            .orDefault(this.valueSparqlWherePatternsFunctionExpression);
+            .orDefault(DiscriminatedUnionType_valueSparqlWherePatternsFunctionExpression.call(this));
     }
     get schemaInitializers() {
         return super.schemaInitializers.concat(code `members: { ${joinCode(this.members.map(({ discriminantValues, type, primaryDiscriminantValue }) => code `${literalOf(primaryDiscriminantValue)}: ${{
@@ -289,31 +304,22 @@ ${joinCode(staticModuleDeclarations
             type: type.schema,
         }}`), { on: "," })} }`);
     }
-    get schemaTypeExpression() {
-        return code `${{
-            kind: this.kind,
-            members: code `{ ${joinCode(this.members.map(({ type, primaryDiscriminantValue }) => code `readonly ${literalOf(primaryDiscriminantValue)}: ${{
-                discriminantValues: code `readonly (number | string)[]`,
-                type: type.schemaType,
-            }}`), { on: ";" })} }`,
-        }}`;
-    }
     get staticModuleDeclarations() {
         const name = this.name.unsafeCoerce();
         const staticModuleDeclarations = {};
         if (this.configuration.features.has("Object.equals")) {
             staticModuleDeclarations[`equals`] =
-                code `export const equals = ${this.equalsFunctionExpression};`;
+                code `export const equals = ${DiscriminatedUnionType_equalsFunctionExpression.call(this)};`;
         }
         if (this.configuration.features.has("Object.filter")) {
             staticModuleDeclarations[`Filter`] =
-                code `export type Filter = ${this.filterTypeLiteral};`;
+                code `export type Filter = ${DiscriminatedUnionType_filterTypeExpression.call(this)};`;
             staticModuleDeclarations[`filter`] =
-                code `export const filter = ${this.filterFunctionExpression};`;
+                code `export const filter = ${DiscriminatedUnionType_filterFunctionExpression.call(this)};`;
         }
         if (this.configuration.features.has("Object.hash")) {
             staticModuleDeclarations[`hash`] =
-                code `export const hash = ${this.hashFunctionExpression};`;
+                code `export const hash = ${DiscriminatedUnionType_hashFunctionExpression.call(this)};`;
         }
         if (this.configuration.features.has("Object.JSON.type")) {
             staticModuleDeclarations[`Json.type`] =
@@ -333,11 +339,11 @@ export namespace Json {
         }
         if (this.configuration.features.has("Object.fromJson")) {
             staticModuleDeclarations[`fromJson`] =
-                code `export const fromJson = ${this.fromJsonFunctionExpression};`;
+                code `export const fromJson = ${DiscriminatedUnionType_fromJsonFunctionExpression.call(this)};`;
         }
         if (this.configuration.features.has("Object.fromRdf")) {
             staticModuleDeclarations[`fromRdfResourceValues`] =
-                code `export const fromRdfResourceValues: ${this.reusables.snippets.FromRdfResourceValuesFunction}<${name}, ${this.schemaType}> = ${this.fromRdfResourceValuesFunctionExpression};`;
+                code `export const fromRdfResourceValues: ${this.reusables.snippets.FromRdfResourceValuesFunction}<${name}, ${this.schemaType}> = ${DiscriminatedUnionType_fromRdfResourceValuesFunctionExpression.call(this)};`;
         }
         if (this.configuration.features.has("Object.schema")) {
             staticModuleDeclarations["schema"] =
@@ -345,259 +351,27 @@ export namespace Json {
         }
         if (this.configuration.features.has("Object.toJson")) {
             staticModuleDeclarations[`toJson`] =
-                code `export const toJson = ${this.toJsonFunctionExpression};`;
+                code `export const toJson = ${DiscriminatedUnionType_toJsonFunctionExpression.call(this)};`;
         }
         if (this.configuration.features.has("Object.toRdf")) {
             staticModuleDeclarations[`toRdfResourceValues`] =
-                code `export const toRdfResourceValues = ${this.toRdfResourceValuesFunctionExpression};`;
+                code `export const toRdfResourceValues = ${DiscriminatedUnionType_toRdfResourceValuesFunctionExpression.call(this)};`;
         }
         if (this.configuration.features.has("Object.SPARQL")) {
             staticModuleDeclarations[`valueSparqlConstructTriples`] =
-                code `export const valueSparqlConstructTriples: ${this.reusables.snippets.ValueSparqlConstructTriplesFunction}<${this.filterType}, ${this.schemaType}> = ${this.valueSparqlConstructTriplesFunctionExpression};`;
+                code `export const valueSparqlConstructTriples: ${this.reusables.snippets.ValueSparqlConstructTriplesFunction}<${this.filterType}, ${this.schemaType}> = ${DiscriminatedUnionType_valueSparqlConstructTriplesFunctionExpression.call(this)};`;
             staticModuleDeclarations[`valueSparqlWherePatterns`] =
-                code `export const valueSparqlWherePatterns: ${this.reusables.snippets.ValueSparqlWherePatternsFunction}<${this.filterType}, ${this.schemaType}> = ${this.valueSparqlWherePatternsFunctionExpression};`;
+                code `export const valueSparqlWherePatterns: ${this.reusables.snippets.ValueSparqlWherePatternsFunction}<${this.filterType}, ${this.schemaType}> = ${DiscriminatedUnionType_valueSparqlWherePatternsFunctionExpression.call(this)};`;
         }
         if (this.configuration.features.has("Object.toString")) {
             const syntheticNamePrefix = this.configuration.syntheticNamePrefix;
             staticModuleDeclarations[`${syntheticNamePrefix}toString`] =
-                code `export const ${syntheticNamePrefix}toString = ${this.toStringFunctionExpression};`;
+                code `export const ${syntheticNamePrefix}toString = ${DiscriminatedUnionType_toStringFunctionExpression.call(this)};`;
         }
         return staticModuleDeclarations;
     }
-    get equalsFunctionExpression() {
-        return code `\
-((left: ${this.expression}, right: ${this.expression}) => {
-${joinCode(this.members.map(({ type, typeCheck, unwrap }) => code `if (${typeCheck(code `left`)} && ${typeCheck(code `right`)}) {
-  return ${type.equalsFunction}(${unwrap(code `left`)} as ${type.expression}, ${unwrap(code `right`)} as ${type.expression});
-}`))}
-
-  return ${this.reusables.imports.Left}({ left, right, propertyName: "type", propertyValuesUnequal: { left: typeof left, right: typeof right, type: "boolean" as const }, type: "property" as const });
-})`;
-    }
-    get filterFunctionExpression() {
-        const syntheticNamePrefix = this.configuration.syntheticNamePrefix;
-        return code `\
-((filter: ${this.filterType}, value: ${this.expression}) => {
-${joinCode([
-            ...this.identifierType
-                .map((identifierType) => code `\
-if (filter.${syntheticNamePrefix}identifier !== undefined && !${identifierType.filterFunction}(filter.${syntheticNamePrefix}identifier, value.${syntheticNamePrefix}identifier())) {
-  return false;
-}`)
-                .toList(),
-            ...this.members.map(({ primaryDiscriminantValue, type, typeCheck, unwrap }) => code `\
-if (filter.on?.[${literalOf(primaryDiscriminantValue)}] !== undefined && ${typeCheck(code `value`)}) {
-  if (!${type.filterFunction}(filter.on[${literalOf(primaryDiscriminantValue)}], ${unwrap(code `value`)})) {
-    return false;
-  }
-}`),
-        ])}
-
-  return true;
-})`;
-    }
-    get filterTypeLiteral() {
-        const syntheticNamePrefix = this.configuration.syntheticNamePrefix;
-        return code `\
-  {
-   ${this.identifierType.map((identifierType) => code `readonly ${syntheticNamePrefix}identifier?: ${identifierType.filterType};`).orDefault(code ``)}
-   readonly on?: { ${joinCode(this.members.map(({ type, primaryDiscriminantValue }) => code `readonly ${literalOf(primaryDiscriminantValue)}?: ${type.filterType}`), { on: ";" })} }
-  }`;
-    }
-    get fromJsonFunctionExpression() {
-        return code `\
-((value: ${this.jsonType().expression}): ${this.reusables.imports.Either}<Error, ${this.expression}> => {
-${joinCode(this.members.map(({ jsonType, jsonTypeCheck, type, unwrap, wrap }) => code `if (${jsonTypeCheck(code `value`)}) { return ${type.fromJsonExpression({
-            variables: {
-                value: code `(${unwrap(code `value`)} as ${jsonType})`,
-            },
-        })}.map(value => (${wrap(code `value`)})); }`))}
-
-  throw new Error("unable to deserialize JSON");
-})`;
-    }
-    get fromRdfResourceValuesFunctionExpression() {
-        return code `\
-(((values, options) =>
-  values.chainMap(value => {
-    const valueAsValues = value.toValues();
-    return ${this.members.reduce((expression, { type, primaryDiscriminantValue }, memberI) => {
-            let typeExpression = code `${type.fromRdfResourceValuesFunction}(valueAsValues, { ...options, schema: options.schema.members[${literalOf(primaryDiscriminantValue)}].type })`;
-            if (this.discriminant.kind === "Extrinsic" ||
-                (this.discriminant.kind === "Hybrid" &&
-                    this.discriminant.memberValues[memberI].kind === "Extrinsic")) {
-                typeExpression = code `${typeExpression}.map(values => values.map(value => ({ ${this.discriminant.name}: ${literalOf(primaryDiscriminantValue)} as const, value }) as (${this.expression})))`;
-            }
-            typeExpression = code `(${typeExpression} as ${this.reusables.imports.Either}<Error, ${this.reusables.imports.Resource}.Values<${this.expression}>>)`;
-            return expression !== null
-                ? code `${expression}.altLazy(() => ${typeExpression})`
-                : typeExpression;
-        }, null)}.chain(values => values.head());
-  })
-) satisfies ${this.reusables.snippets.FromRdfResourceValuesFunction}<${this.expression}, ${this.schemaType}>)`;
-    }
-    get hashFunctionExpression() {
-        return code `\
-(<HasherT extends ${this.reusables.snippets.Hasher}>(hasher: HasherT, value: ${this.expression}): HasherT => {
-${joinCode(this.members.map(({ type, typeCheck, unwrap }) => code `if (${typeCheck(code `value`)}) { return ${type.hashFunction}(hasher, ${unwrap(code `value`)}); }`))}
-  return hasher;
-})`;
-    }
-    /**
-     * An inline expression of this type rather than a type reference/name.
-     */
-    get inlineExpression() {
-        const discriminant = this.discriminant; // To get type narrowing to work
-        switch (discriminant.kind) {
-            case "Extrinsic":
-                return code `(${joinCode(this.members.map(({ type, primaryDiscriminantValue }) => code `{ ${discriminant.name}: ${literalOf(primaryDiscriminantValue)}, value: ${type.expression} }`), { on: "|" })})`;
-            case "Hybrid":
-                return code `(${joinCode(this.members.map(({ primaryDiscriminantValue, type }, memberI) => {
-                    switch (discriminant.memberValues[memberI].kind) {
-                        case "Extrinsic":
-                            return code `{ ${discriminant.name}: ${literalOf(primaryDiscriminantValue)}, value: ${type.expression} }`;
-                        case "Intrinsic":
-                            return code `${type.expression}`;
-                        default:
-                            throw new Error();
-                    }
-                }), { on: "|" })})`;
-            case "Intrinsic":
-                // If every type shares a discriminant (e.g., RDF/JS "termType" or generated ObjectType "type"),
-                // just join their names with "|"
-                return code `(${joinCode(this.members.map(({ type }) => code `${type.expression}`), { on: "|" })})`;
-            case "Typeof":
-                // The type.name may include literal values, but they should still be unambiguous with other member types since the typeofs
-                // of the different member types are known to be different.
-                return code `(${joinCode(this.members.map(({ type }) => code `${type.expression}`), { on: "|" })})`;
-            default:
-                discriminant;
-                throw new Error("should never reach this point");
-        }
-    }
-    get jsonSchemaExpression() {
-        const discriminant = this.discriminant; // To get type narrowing to work
-        switch (discriminant.kind) {
-            case "Extrinsic":
-                return code `${this.reusables.imports.z}.discriminatedUnion("${discriminant.name}", [${joinCode(this.members.map(({ type, primaryDiscriminantValue }) => code `${this.reusables.imports.z}.object({ ${discriminant.name}: ${this.reusables.imports.z}.literal(${literalOf(primaryDiscriminantValue)}), value: ${type.jsonSchema({ context: "type" })} })`), { on: "," })}]).readonly()`;
-            case "Hybrid":
-                return code `${this.reusables.imports.z}.discriminatedUnion("${discriminant.name}", [${joinCode(this.members.map(({ primaryDiscriminantValue, type }, memberI) => {
-                    switch (discriminant.memberValues[memberI].kind) {
-                        case "Extrinsic":
-                            return code `${this.reusables.imports.z}.object({ ${discriminant.name}: ${this.reusables.imports.z}.literal(${literalOf(primaryDiscriminantValue)}), value: ${type.jsonSchema({ context: "type" })} })`;
-                        case "Intrinsic":
-                            return type.jsonSchema({
-                                includeDiscriminantProperty: true,
-                                context: "type",
-                            });
-                        default:
-                            throw new Error();
-                    }
-                }), { on: "," })}]).readonly()`;
-            case "Intrinsic":
-                return code `${this.reusables.imports.z}.discriminatedUnion("${discriminant.name}", [${joinCode(this.members.map(({ type }) => type.jsonSchema({
-                    includeDiscriminantProperty: true,
-                    context: "type",
-                })), { on: "," })}]).readonly()`;
-            case "Typeof":
-                return code `${this.reusables.imports.z}.union([${joinCode(this.members.map(({ type }) => type.jsonSchema({ context: "type" })), { on: "," })}]).readonly()`;
-            default:
-                throw discriminant;
-        }
-    }
-    get jsonTypeLiteral() {
-        const discriminant = this.discriminant; // To get type narrowing to work
-        switch (discriminant.kind) {
-            case "Extrinsic":
-                return new AbstractType.JsonType(code `(${joinCode(this.members.map(({ jsonType, primaryDiscriminantValue }) => code `{ ${discriminant.name}: ${literalOf(primaryDiscriminantValue)}, value: ${jsonType} }`), { on: "|" })})`);
-            case "Hybrid":
-                return new AbstractType.JsonType(code `(${joinCode(this.members.map(({ jsonType, primaryDiscriminantValue }, memberI) => {
-                    switch (discriminant.memberValues[memberI].kind) {
-                        case "Extrinsic":
-                            return code `{ ${discriminant.name}: ${literalOf(primaryDiscriminantValue)}, value: ${jsonType} }`;
-                        case "Intrinsic":
-                            return code `${jsonType}`;
-                        default:
-                            throw new Error();
-                    }
-                }), { on: "|" })})`);
-            case "Intrinsic":
-            case "Typeof":
-                return new AbstractType.JsonType(joinCode(this.members.map(({ jsonType }) => code `${jsonType}`), { on: "|" }));
-            default:
-                throw discriminant;
-        }
-    }
-    get toJsonFunctionExpression() {
-        return code `\
-((value: ${this.expression}): ${this.jsonType().expression} => {
-${joinCode(this.members.map(({ typeCheck, typeToJsonExpression, unwrap, wrap }) => code `if (${typeCheck(code `value`)}) { return ${wrap(typeToJsonExpression(unwrap(code `value`)))}; }`))}
-
-  throw new Error("unable to serialize to JSON");
-})`;
-    }
-    get toRdfResourceValuesFunctionExpression() {
-        return code `\
-(((value, _options): (${joinCode([...this.toRdfResourceValueTypes].map((toRdfResourceValueType) => {
-            switch (toRdfResourceValueType) {
-                case "BlankNode":
-                    return code `${this.reusables.imports.BlankNode}`;
-                case "Literal":
-                    return code `${this.reusables.imports.Literal}`;
-                case "NamedNode":
-                    return code `${this.reusables.imports.NamedNode}`;
-                default:
-                    toRdfResourceValueType;
-                    throw new Error();
-            }
-        }), { on: " | " })})[] => {
-${joinCode(this.members.map(({ type, unwrap, typeCheck }) => code `if (${typeCheck(code `value`)}) { return ${type.toRdfResourceValuesExpression({
-            variables: {
-                graph: code `_options.graph`,
-                propertyPath: code `_options.propertyPath`,
-                resource: code `_options.resource`,
-                resourceSet: code `_options.resourceSet`,
-                value: unwrap(code `value`),
-            },
-        })}; }`))}
-
-  throw new Error("unable to serialize to RDF");
-}) satisfies ${this.reusables.snippets.ToRdfResourceValuesFunction}<${this.expression}>)`;
-    }
-    get toStringFunctionExpression() {
-        return code `\
-((value: ${this.expression}): string => {
-${joinCode(this.members.map(({ type, typeCheck, unwrap }) => code `if (${typeCheck(code `value`)}) { return ${type.toStringExpression({
-            variables: { value: unwrap(code `value`) },
-        })}; }`))}
-
-  throw new Error("unable to serialize to string");
-})`;
-    }
-    get valueSparqlConstructTriplesFunctionExpression() {
-        return code `\
-((({ ignoreRdfType, filter, schema, ...otherParameters }) => {
-  let triples: ${this.reusables.imports.sparqljs}.Triple[] = [];
-
-  ${joinCode(this.members.map(({ type, primaryDiscriminantValue }) => code `\
-triples = triples.concat(${type.valueSparqlConstructTriplesFunction}({ ...otherParameters, filter: filter?.on?.[${literalOf(primaryDiscriminantValue)}], ignoreRdfType: false, schema: schema.members[${literalOf(primaryDiscriminantValue)}].type }));`))}
-  
-  return triples;
-}) satisfies ${this.reusables.snippets.ValueSparqlConstructTriplesFunction}<${this.filterType}, ${this.schemaType}>)`;
-    }
-    get valueSparqlWherePatternsFunctionExpression() {
-        return code `\
-((({ filter, schema, ...otherParameters }) => {
-  const unionPatterns: ${this.reusables.imports.sparqljs}.GroupPattern[] = [];
-
-  ${joinCode(this.members.map(({ type, primaryDiscriminantValue }) => code `\
-unionPatterns.push({ patterns: ${type.valueSparqlWherePatternsFunction}({ ...otherParameters, filter: filter?.on?.[${literalOf(primaryDiscriminantValue)}], ignoreRdfType: false, schema: schema.members[${literalOf(primaryDiscriminantValue)}].type }).concat(), type: "group" });`))}
-  
-  return [{ patterns: unionPatterns, type: "union" }];
-}) satisfies ${this.reusables.snippets.ValueSparqlWherePatternsFunction}<${this.filterType}, ${this.schemaType}>)`;
-    }
     fromJsonExpression({ variables, }) {
-        return code `${this.name.map((name) => code `${name}.fromJson`).orDefault(this.fromJsonFunctionExpression)}(${variables.value})`;
+        return code `${this.name.map((name) => code `${name}.fromJson`).orDefault(DiscriminatedUnionType_fromJsonFunctionExpression.call(this))}(${variables.value})`;
     }
     graphqlResolveExpression({ variables, }) {
         return variables.value;
@@ -605,7 +379,7 @@ unionPatterns.push({ patterns: ${type.valueSparqlWherePatternsFunction}({ ...oth
     jsonSchema({ context, }) {
         const expression = this.name
             .map((name) => code `${name}.Json.schema()`)
-            .orDefault(this.jsonSchemaExpression);
+            .orDefault(DiscriminatedUnionType_jsonSchemaExpression.call(this));
         if (context === "property" && this.recursive) {
             return code `${this.reusables.imports.z}.lazy((): ${this.reusables.imports.z}.ZodType<${this.jsonType().expression}> => ${expression})`;
         }
@@ -614,20 +388,20 @@ unionPatterns.push({ patterns: ${type.valueSparqlWherePatternsFunction}({ ...oth
     jsonType() {
         return this.name
             .map((name) => new AbstractType.JsonType(code `${name}.Json`))
-            .orDefault(this.jsonTypeLiteral);
+            .orDefault(DiscriminatedUnionType_jsonTypeLiteral.call(this));
     }
     jsonUiSchemaElement() {
         return Maybe.empty();
     }
     toJsonExpression({ variables, }) {
-        return code `${this.name.map((name) => code `${name}.toJson`).orDefault(this.toJsonFunctionExpression)}(${variables.value})`;
+        return code `${this.name.map((name) => code `${name}.toJson`).orDefault(DiscriminatedUnionType_toJsonFunctionExpression.call(this))}(${variables.value})`;
     }
     toRdfResourceValuesExpression({ variables, }) {
         const { value: valueVariable, ...otherVariables } = variables;
-        return code `${this.name.map((name) => code `${name}.toRdfResourceValues`).orDefault(this.toRdfResourceValuesFunctionExpression)}(${valueVariable}, ${otherVariables})`;
+        return code `${this.name.map((name) => code `${name}.toRdfResourceValues`).orDefault(DiscriminatedUnionType_toRdfResourceValuesFunctionExpression.call(this))}(${valueVariable}, ${otherVariables})`;
     }
     toStringExpression({ variables, }) {
-        return code `${this.name.map((name) => code `${name}.${this.configuration.syntheticNamePrefix}toString`).orDefault(this.toStringFunctionExpression)}(${variables.value})`;
+        return code `${this.name.map((name) => code `${name}.${this.configuration.syntheticNamePrefix}toString`).orDefault(DiscriminatedUnionType_toStringFunctionExpression.call(this))}(${variables.value})`;
     }
     lazyMembers;
 }
@@ -685,166 +459,7 @@ __decorate([
 __decorate([
     Memoize()
 ], DiscriminatedUnionType.prototype, "valueSparqlWherePatternsFunction", null);
-__decorate([
-    Memoize()
-], DiscriminatedUnionType.prototype, "schemaTypeExpression", null);
-__decorate([
-    Memoize()
-], DiscriminatedUnionType.prototype, "equalsFunctionExpression", null);
-__decorate([
-    Memoize()
-], DiscriminatedUnionType.prototype, "filterFunctionExpression", null);
-__decorate([
-    Memoize()
-], DiscriminatedUnionType.prototype, "filterTypeLiteral", null);
-__decorate([
-    Memoize()
-], DiscriminatedUnionType.prototype, "inlineExpression", null);
-__decorate([
-    Memoize()
-], DiscriminatedUnionType.prototype, "jsonTypeLiteral", null);
-__decorate([
-    Memoize()
-], DiscriminatedUnionType.prototype, "valueSparqlConstructTriplesFunctionExpression", null);
-__decorate([
-    Memoize()
-], DiscriminatedUnionType.prototype, "valueSparqlWherePatternsFunctionExpression", null);
 __decorate([
     Memoize()
 ], DiscriminatedUnionType.prototype, "jsonType", null);
-function termTypes(type) {
-    switch (type.kind) {
-        case "BlankNode":
-        case "Iri":
-        case "Identifier":
-        case "Literal":
-        case "Term":
-            return type.termTypes;
-        default:
-            return emptyTermTypesSet;
-    }
-}
-const emptyTermTypesSet = new Set();
-export var Discriminant;
-(function (Discriminant) {
-    function infer(members) {
-        // extrinsic with user-specified values
-        if (members.some((member) => member.discriminantValue.isJust())) {
-            return {
-                jsonName: "type",
-                kind: "Extrinsic",
-                memberValues: members.map((member, memberI) => member.discriminantValue.orDefault(memberI)),
-                name: "type",
-            };
-        }
-        const memberTypes = members.map((member) => member.type);
-        // intrinsic
-        {
-            let inlineDiscriminantProperty;
-            let memberValues = [];
-            for (const memberType of memberTypes) {
-                const memberTypeDiscriminantProperty = memberType.discriminantProperty.extract();
-                if (!memberTypeDiscriminantProperty) {
-                    inlineDiscriminantProperty = undefined;
-                    break;
-                }
-                if (!inlineDiscriminantProperty) {
-                    inlineDiscriminantProperty = memberTypeDiscriminantProperty;
-                }
-                else if (memberTypeDiscriminantProperty.name !==
-                    inlineDiscriminantProperty.name) {
-                    inlineDiscriminantProperty = undefined;
-                    break;
-                }
-                memberValues = memberValues.concat(memberTypeDiscriminantProperty.values);
-            }
-            if (inlineDiscriminantProperty) {
-                return {
-                    jsonName: inlineDiscriminantProperty.jsonName,
-                    kind: "Intrinsic",
-                    memberValues,
-                    name: inlineDiscriminantProperty.name,
-                };
-            }
-        }
-        // typeof
-        {
-            const memberTypeofs = [];
-            const memberTypeofsSet = new Set();
-            for (const memberType of memberTypes) {
-                for (const memberJsType of memberType.jsTypes) {
-                    memberTypeofs.push(memberJsType.typeof);
-                    memberTypeofsSet.add(memberJsType.typeof);
-                }
-            }
-            if (memberTypeofsSet.size === memberTypes.length) {
-                return {
-                    memberValues: memberTypeofs,
-                    kind: "Typeof",
-                };
-            }
-        }
-        // hybrid
-        // If some member type is an RDF/JS term then reuse "termType" as the discriminant.
-        if (memberTypes.some((memberType) => termTypes(memberType).size > 0)) {
-            const extrinsicMemberTypeAliasesSet = new Set();
-            let extrinsicMemberTypeCount = 0;
-            for (const memberType of memberTypes) {
-                if (termTypes(memberType).size > 0) {
-                    continue;
-                }
-                extrinsicMemberTypeCount++;
-                if (memberType.name.isJust()) {
-                    extrinsicMemberTypeAliasesSet.add(memberType.name.extract());
-                }
-                else {
-                    break;
-                }
-            }
-            return {
-                jsonName: "termType",
-                kind: "Hybrid",
-                memberValues: memberTypes.map((memberType, memberTypeI) => {
-                    const memberTermTypes = termTypes(memberType);
-                    if (memberTermTypes.size > 0) {
-                        return {
-                            kind: "Intrinsic",
-                            values: [...memberTermTypes],
-                        };
-                    }
-                    return {
-                        kind: "Extrinsic",
-                        values: extrinsicMemberTypeAliasesSet.size === extrinsicMemberTypeCount
-                            ? [memberType.name.unsafeCoerce()]
-                            : [memberTypeI.toString()],
-                    };
-                }),
-                name: "termType",
-            };
-        }
-        // extrinsic with inferred values
-        {
-            let memberValues;
-            {
-                const memberTypeNames = memberTypes.map((memberType) => memberType.name.orDefault(memberType.jsTypes[0].typeof));
-                const memberTypeNamesSet = new Set(memberTypeNames);
-                if (memberTypeNamesSet.size === memberTypeNames.length) {
-                    memberValues = memberTypeNames;
-                }
-                else {
-                    // Otherwise prefix the non-unique strings with an index and use those as the discriminant values.
-                    memberValues = memberTypeNames.map((memberTypeName, memberTypeI) => `${memberTypeI}-${memberTypeName}`);
-                }
-            }
-            invariant(memberValues.length === memberTypes.length);
-            return {
-                jsonName: "type",
-                kind: "Extrinsic",
-                name: "type",
-                memberValues,
-            };
-        }
-    }
-    Discriminant.infer = infer;
-})(Discriminant || (Discriminant = {}));
 //# sourceMappingURL=DiscriminatedUnionType.js.map

package/dist/generators/ts/IdentifierType.js

@@ -54,7 +54,7 @@ export class IdentifierType extends AbstractIdentifierType {
     }
     jsonSchema({ includeDiscriminantProperty, }) {
         const discriminantProperty = includeDiscriminantProperty
-            ? code `, termType: ${this.reusables.imports.z}.enum(${arrayOf(...this.nodeKinds)})`
+            ? code `, termType: ${this.reusables.imports.z}.enum(${arrayOf(...[...this.nodeKinds].map(NodeKind.toTermType))})`
             : "";
         return code `${this.reusables.imports.z}.object({ "@id": ${this.reusables.imports.z}.string().min(1)${discriminantProperty} })`;
     }

package/dist/generators/ts/ObjectDiscriminatedUnionType.d.ts

@@ -8,13 +8,5 @@ export declare class ObjectDiscriminatedUnionType extends DiscriminatedUnionType
     get schema(): Code;
     get schemaType(): Code;
     protected get staticModuleDeclarations(): Record<string, Code>;
-    private get focusSparqlConstructTriplesFunctionDeclaration();
-    private get focusSparqlWherePatternsFunctionDeclaration();
-    private get fromRdfResourceFunctionDeclaration();
-    private get graphqlTypeVariableStatement();
-    private get identifierTypeDeclarations();
-    private get isTypeFunctionDeclaration();
-    private get schemaVariableStatement();
-    private get toRdfResourceFunctionDeclaration();
 }
 //# sourceMappingURL=ObjectDiscriminatedUnionType.d.ts.map