@shaclmate/compiler 4.0.59 → 4.0.61

package/dist/generators/ts/ObjectDiscriminatedUnionType.js

@@ -4,15 +4,21 @@ 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 { PropertyPath } from "@rdfx/resource";
-import { pascalCase } from "change-case";
 import { Memoize } from "typescript-memoize";
+import { ObjectDiscriminatedUnionType_focusSparqlConstructTriplesFunctionDeclaration } from "./_ObjectDiscriminatedUnionType/ObjectDiscriminatedUnionType_focusSparqlConstructTriplesFunctionDeclaration.js";
+import { ObjectDiscriminatedUnionType_focusSparqlWherePatternsFunctionDeclaration } from "./_ObjectDiscriminatedUnionType/ObjectDiscriminatedUnionType_focusSparqlWherePatternsFunctionDeclaration.js";
+import { ObjectDiscriminatedUnionType_fromRdfResourceFunctionDeclaration } from "./_ObjectDiscriminatedUnionType/ObjectDiscriminatedUnionType_fromRdfResourceFunctionDeclaration.js";
+import { ObjectDiscriminatedUnionType_graphqlTypeVariableStatement } from "./_ObjectDiscriminatedUnionType/ObjectDiscriminatedUnionType_graphqlTypeVariableStatement.js";
+import { ObjectDiscriminatedUnionType_identifierTypeDeclarations } from "./_ObjectDiscriminatedUnionType/ObjectDiscriminatedUnionType_identifierTypeDeclarations.js";
+import { ObjectDiscriminatedUnionType_isTypeFunctionDeclaration } from "./_ObjectDiscriminatedUnionType/ObjectDiscriminatedUnionType_isTypeFunctionDeclaration.js";
+import { ObjectDiscriminatedUnionType_schemaVariableStatement } from "./_ObjectDiscriminatedUnionType/ObjectDiscriminatedUnionType_schemaVariableStatement.js";
+import { ObjectDiscriminatedUnionType_toRdfResourceFunctionDeclaration } from "./_ObjectDiscriminatedUnionType/ObjectDiscriminatedUnionType_toRdfResourceFunctionDeclaration.js";
 import { ObjectType_objectSetMethodNames } from "./_ObjectType/ObjectType_objectSetMethodNames.js";
 import { ObjectType_sparqlConstructQueryFunctionDeclaration } from "./_ObjectType/ObjectType_sparqlConstructQueryFunctionDeclaration.js";
 import { ObjectType_sparqlConstructQueryStringFunctionDeclaration } from "./_ObjectType/ObjectType_sparqlConstructQueryStringFunctionDeclaration.js";
 import { DiscriminatedUnionType } from "./DiscriminatedUnionType.js";
 import { singleEntryRecord } from "./singleEntryRecord.js";
-import { code, joinCode, literalOf } from "./ts-poet-wrapper.js";
+import { code } from "./ts-poet-wrapper.js";
 export class ObjectDiscriminatedUnionType extends DiscriminatedUnionType {
     kind = "ObjectDiscriminatedUnion";
     get identifierTypeAlias() {
@@ -40,13 +46,13 @@ export class ObjectDiscriminatedUnionType extends DiscriminatedUnionType {
         const name = this.name.unsafeCoerce();
         return {
             ...super.staticModuleDeclarations,
-            ...this.identifierTypeDeclarations,
-            ...this.focusSparqlConstructTriplesFunctionDeclaration,
-            ...this.focusSparqlWherePatternsFunctionDeclaration,
-            ...this.fromRdfResourceFunctionDeclaration,
-            ...this.graphqlTypeVariableStatement,
-            ...this.isTypeFunctionDeclaration,
-            ...this.schemaVariableStatement,
+            ...ObjectDiscriminatedUnionType_identifierTypeDeclarations.call(this),
+            ...ObjectDiscriminatedUnionType_focusSparqlConstructTriplesFunctionDeclaration.call(this),
+            ...ObjectDiscriminatedUnionType_focusSparqlWherePatternsFunctionDeclaration.call(this),
+            ...ObjectDiscriminatedUnionType_fromRdfResourceFunctionDeclaration.call(this),
+            ...ObjectDiscriminatedUnionType_graphqlTypeVariableStatement.call(this),
+            ...ObjectDiscriminatedUnionType_isTypeFunctionDeclaration.call(this),
+            ...ObjectDiscriminatedUnionType_schemaVariableStatement.call(this),
             ...(this.configuration.features.has("Object.SPARQL")
                 ? {
                     ...singleEntryRecord("sparqlConstructQuery", ObjectType_sparqlConstructQueryFunctionDeclaration.call({
@@ -63,150 +69,9 @@ export class ObjectDiscriminatedUnionType extends DiscriminatedUnionType {
                     })),
                 }
                 : {}),
-            ...this.toRdfResourceFunctionDeclaration,
+            ...ObjectDiscriminatedUnionType_toRdfResourceFunctionDeclaration.call(this),
         };
     }
-    get focusSparqlConstructTriplesFunctionDeclaration() {
-        if (!this.configuration.features.has("Object.SPARQL")) {
-            return {};
-        }
-        return singleEntryRecord(`focusSparqlConstructTriples`, code `\
-export function focusSparqlConstructTriples({ filter, focusIdentifier, variablePrefix }: { filter: ${this.filterType} | undefined; focusIdentifier: ${this.reusables.imports.NamedNode} | ${this.reusables.imports.Variable}; ignoreRdfType: boolean; variablePrefix: string }): readonly ${this.reusables.imports.sparqljs}.Triple[] {
-  return [${joinCode(this.members.map((member) => code `...${member.type.name.unsafeCoerce()}.focusSparqlConstructTriples({ filter: filter?.on?.${member.type.name.unsafeCoerce()}, focusIdentifier, ignoreRdfType: false, variablePrefix: \`\${variablePrefix}${pascalCase(member.type.name.unsafeCoerce())}\` }).concat()`), { on: ", " })}];
-}`);
-    }
-    get focusSparqlWherePatternsFunctionDeclaration() {
-        if (!this.configuration.features.has("Object.SPARQL")) {
-            return {};
-        }
-        return singleEntryRecord(`focusSparqlWherePatterns`, code `\
-export function focusSparqlWherePatterns({ filter, focusIdentifier, preferredLanguages, variablePrefix }: { filter: ${this.filterType} | undefined; focusIdentifier: ${this.reusables.imports.NamedNode} | ${this.reusables.imports.Variable}; ignoreRdfType: boolean; preferredLanguages: readonly string[] | undefined; variablePrefix: string }): readonly ${this.reusables.snippets.SparqlPattern}[] {
-${joinCode([
-            code `let patterns: ${this.reusables.snippets.SparqlPattern}[] = [];`,
-            code `\
-if (focusIdentifier.termType === "Variable") {
-  patterns = patterns.concat(${this.identifierType.unsafeCoerce().valueSparqlWherePatternsFunction}({
-      filter: filter?.${this.configuration.syntheticNamePrefix}identifier,
-      ignoreRdfType: false,
-      preferredLanguages,
-      propertyPatterns: [],
-      schema: ${this.identifierType.unsafeCoerce().schema},
-      valueVariable: focusIdentifier,
-      variablePrefix,
-  }));
-}`,
-            code `patterns.push({ patterns: [${joinCode(this.members.map((member) => code `${{
-                patterns: code `${member.type.name.unsafeCoerce()}.focusSparqlWherePatterns({ filter: filter?.on?.${member.type.name.unsafeCoerce()}, focusIdentifier, ignoreRdfType: false, preferredLanguages, variablePrefix: \`\${variablePrefix}${pascalCase(member.type.name.unsafeCoerce())}\` }).concat()`,
-                type: literalOf("group"),
-            }}`), { on: ", " })}], type: "union" });`,
-            code `return patterns;`,
-        ])}
-}`);
-    }
-    get fromRdfResourceFunctionDeclaration() {
-        if (!this.configuration.features.has("Object.fromRdf")) {
-            return {};
-        }
-        const name = this.name.unsafeCoerce();
-        return singleEntryRecord(`fromRdfResource`, code `\
-export const fromRdfResource: ${this.reusables.snippets.FromRdfResourceFunction}<${name}> = (resource, options) => 
-  ${this.members.reduce((expression, member) => {
-            const memberTypeExpression = code `(${member.type.name.unsafeCoerce()}.fromRdfResource(resource, { ...options, ignoreRdfType: false }) as ${this.reusables.imports.Either}<Error, ${name}>)`;
-            return expression !== null
-                ? code `${expression}.altLazy(() => ${memberTypeExpression})`
-                : memberTypeExpression;
-        }, null)};`);
-    }
-    get graphqlTypeVariableStatement() {
-        if (!this.configuration.features.has("GraphQL")) {
-            return {};
-        }
-        if (this.synthetic) {
-            return {};
-        }
-        const name = this.name.unsafeCoerce();
-        return singleEntryRecord(`GraphQL`, code `\
-export const GraphQL = new ${this.reusables.imports.GraphQLUnionType}(${{
-            description: this.comment.map(JSON.stringify).extract(),
-            name: name,
-            resolveType: code `(value: ${name}) => value.${this.configuration.syntheticNamePrefix}type`,
-            types: code `[${joinCode(this.members.map((member) => member.type.graphqlType.nullableExpression), { on: ", " })}]`,
-        }});`);
-    }
-    get identifierTypeDeclarations() {
-        if (!this.configuration.features.has("Object.type")) {
-            return {};
-        }
-        return singleEntryRecord(`Identifier`, code `\
-export type Identifier = ${this.identifierType.unsafeCoerce().expression};
-export namespace Identifier {
-  export const parse = ${this.identifierType.unsafeCoerce().parseFunction};
-  export const stringify = ${this.identifierType.unsafeCoerce().stringifyFunction};
-}`);
-    }
-    get isTypeFunctionDeclaration() {
-        if (!this.configuration.features.has("Object.type")) {
-            return {};
-        }
-        const name = this.name.unsafeCoerce();
-        if (name === `${this.configuration.syntheticNamePrefix}Object`) {
-            return {};
-        }
-        return singleEntryRecord(`is${name}`, code `\
-    export function is${name}(object: ${this.configuration.syntheticNamePrefix}Object): object is ${name} {
-      return ${joinCode(this.members.map((member) => code `${member.type.name.unsafeCoerce()}.is${member.type.name.unsafeCoerce()}(object)`), { on: " || " })};
-    }`);
-    }
-    get schemaVariableStatement() {
-        if (!this.configuration.features.has("Object.schema")) {
-            return {};
-        }
-        const commonPropertiesByName = {};
-        this.members.forEach((member, memberI) => {
-            for (const memberTypeProperty of member.type.properties) {
-                if (memberTypeProperty.kind !== "Shacl") {
-                    continue;
-                }
-                let commonProperty = commonPropertiesByName[memberTypeProperty.name];
-                if (commonProperty) {
-                    if (PropertyPath.equals(commonProperty.property.path, memberTypeProperty.path)) {
-                        commonProperty.memberTypesWithProperty[memberI] = true;
-                    }
-                }
-                else {
-                    commonPropertiesByName[memberTypeProperty.name] = commonProperty = {
-                        memberTypesWithProperty: new Array(this.members.length).fill(false),
-                        property: memberTypeProperty,
-                    };
-                    commonProperty.memberTypesWithProperty[memberI] = true;
-                }
-            }
-        });
-        const propertiesObject = [];
-        for (const name of Object.keys(commonPropertiesByName).toSorted()) {
-            const { memberTypesWithProperty, property } = commonPropertiesByName[name];
-            if (!memberTypesWithProperty.every((value) => value)) {
-                continue;
-            }
-            property.schema.ifJust((propertySchema) => {
-                propertiesObject.push(code `${property.name}: ${propertySchema}`);
-            });
-        }
-        return singleEntryRecord(`schema`, code `\
-export const schema = { ${joinCode(super.schemaInitializers.concat(code `properties: { ${joinCode(propertiesObject, { on: ", " })} }`), { on: ", " })} } as const;`);
-    }
-    get toRdfResourceFunctionDeclaration() {
-        if (!this.configuration.features.has("Object.toRdf")) {
-            return {};
-        }
-        const name = this.name.unsafeCoerce();
-        return singleEntryRecord(`toRdfResource`, code `\
-export const toRdfResource: ${this.reusables.snippets.ToRdfResourceFunction}<${name}> = (object, options) => {
-${joinCode(this.members
-            .map((member) => code `if (${member.type.name.unsafeCoerce()}.is${member.type.name.unsafeCoerce()}(object)) { return ${member.type.name.unsafeCoerce()}.toRdfResource(object, options); }`)
-            .concat(code `throw new Error("unrecognized type");`))}
-};`);
-    }
 }
 __decorate([
     Memoize()

package/dist/generators/ts/TsGenerator.d.ts

@@ -20,6 +20,10 @@ export declare namespace TsGenerator {
     interface Configuration {
         readonly features: ReadonlySet<TsFeature>;
         readonly finalized: true;
+        readonly objectDiscriminantProperty: {
+            readonly jsonName: string;
+            readonly name: string;
+        };
         readonly syntheticNamePrefix: string;
     }
     namespace Configuration {

package/dist/generators/ts/TsGenerator.js

@@ -219,6 +219,10 @@ export class TsGenerator {
                 "JSON",
                 "RDF",
             ]),
+            objectDiscriminantProperty: {
+                jsonName: "$type",
+                name: "$type",
+            },
             syntheticNamePrefix: "$",
         };
         const featureDependenciesStatic = {
@@ -282,6 +286,8 @@ export class TsGenerator {
             return {
                 features: inferredFeatures,
                 finalized: true,
+                objectDiscriminantProperty: partialConfiguration?.objectDiscriminantProperty ??
+                    Configuration.default_.objectDiscriminantProperty,
                 syntheticNamePrefix: partialConfiguration?.syntheticNamePrefix ??
                     Configuration.default_.syntheticNamePrefix,
             };

package/dist/generators/ts/TypeFactory.js

@@ -53,7 +53,6 @@ export class TypeFactory {
         const discriminantProperty = astType.name.map((name) => new ObjectType.DiscriminantProperty({
             configuration: this.configuration,
             logger: this.logger,
-            name: `${this.configuration.syntheticNamePrefix}type`,
             objectType: { name: astType.name },
             reusables: this.reusables,
             value: name,

package/dist/generators/ts/_DiscriminatedUnionType/DiscriminatedUnionType_Discriminant.d.ts

@@ -0,0 +1,30 @@
+import type { AbstractType } from "../AbstractType.js";
+import type { Typeof } from "../Typeof.js";
+export type DiscriminatedUnionType_Discriminant = ExtrinsicDiscriminant | HybridDiscriminant | IntrinsicDiscriminant | TypeofDiscriminant;
+type ExtrinsicDiscriminant = {
+    readonly jsonName: string;
+    readonly kind: "Extrinsic";
+    readonly memberValues: readonly AbstractType.DiscriminantProperty.Value[];
+    readonly name: string;
+};
+type HybridDiscriminant = {
+    readonly jsonName: string;
+    readonly kind: "Hybrid";
+    readonly memberValues: readonly {
+        readonly kind: "Extrinsic" | "Intrinsic";
+        readonly values: readonly AbstractType.DiscriminantProperty.Value[];
+    }[];
+    readonly name: string;
+};
+type IntrinsicDiscriminant = {
+    readonly jsonName: string;
+    readonly kind: "Intrinsic";
+    readonly memberValues: readonly AbstractType.DiscriminantProperty.Value[];
+    readonly name: string;
+};
+type TypeofDiscriminant = {
+    readonly kind: "Typeof";
+    readonly memberValues: readonly Typeof[];
+};
+export {};
+//# sourceMappingURL=DiscriminatedUnionType_Discriminant.d.ts.map

package/dist/generators/ts/_DiscriminatedUnionType/DiscriminatedUnionType_Discriminant.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=DiscriminatedUnionType_Discriminant.js.map

package/dist/generators/ts/_DiscriminatedUnionType/DiscriminatedUnionType_equalsFunctionExpression.d.ts

@@ -0,0 +1,5 @@
+import type { DiscriminatedUnionType } from "../DiscriminatedUnionType.js";
+import type { Type } from "../Type.js";
+import { type Code } from "../ts-poet-wrapper.js";
+export declare function DiscriminatedUnionType_equalsFunctionExpression<MemberTypeT extends Type>(this: DiscriminatedUnionType<MemberTypeT>): Code;
+//# sourceMappingURL=DiscriminatedUnionType_equalsFunctionExpression.d.ts.map

package/dist/generators/ts/_DiscriminatedUnionType/DiscriminatedUnionType_equalsFunctionExpression.js

@@ -0,0 +1,12 @@
+import { code, joinCode } from "../ts-poet-wrapper.js";
+export function DiscriminatedUnionType_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 });
+})`;
+}
+//# sourceMappingURL=DiscriminatedUnionType_equalsFunctionExpression.js.map

package/dist/generators/ts/_DiscriminatedUnionType/DiscriminatedUnionType_filterFunctionExpression.d.ts

@@ -0,0 +1,5 @@
+import type { DiscriminatedUnionType } from "../DiscriminatedUnionType.js";
+import type { Type } from "../Type.js";
+import { type Code } from "../ts-poet-wrapper.js";
+export declare function DiscriminatedUnionType_filterFunctionExpression<MemberTypeT extends Type>(this: DiscriminatedUnionType<MemberTypeT>): Code;
+//# sourceMappingURL=DiscriminatedUnionType_filterFunctionExpression.d.ts.map

package/dist/generators/ts/_DiscriminatedUnionType/DiscriminatedUnionType_filterFunctionExpression.js

@@ -0,0 +1,24 @@
+import { code, joinCode, literalOf } from "../ts-poet-wrapper.js";
+export function DiscriminatedUnionType_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;
+})`;
+}
+//# sourceMappingURL=DiscriminatedUnionType_filterFunctionExpression.js.map

package/dist/generators/ts/_DiscriminatedUnionType/DiscriminatedUnionType_filterTypeExpression.d.ts

@@ -0,0 +1,5 @@
+import type { DiscriminatedUnionType } from "../DiscriminatedUnionType.js";
+import type { Type } from "../Type.js";
+import { type Code } from "../ts-poet-wrapper.js";
+export declare function DiscriminatedUnionType_filterTypeExpression<MemberTypeT extends Type>(this: DiscriminatedUnionType<MemberTypeT>): Code;
+//# sourceMappingURL=DiscriminatedUnionType_filterTypeExpression.d.ts.map

package/dist/generators/ts/_DiscriminatedUnionType/DiscriminatedUnionType_filterTypeExpression.js

@@ -0,0 +1,10 @@
+import { code, joinCode, literalOf } from "../ts-poet-wrapper.js";
+export function DiscriminatedUnionType_filterTypeExpression() {
+    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: ";" })} }
+  }`;
+}
+//# sourceMappingURL=DiscriminatedUnionType_filterTypeExpression.js.map

package/dist/generators/ts/_DiscriminatedUnionType/DiscriminatedUnionType_fromJsonFunctionExpression.d.ts

@@ -0,0 +1,5 @@
+import type { DiscriminatedUnionType } from "../DiscriminatedUnionType.js";
+import type { Type } from "../Type.js";
+import { type Code } from "../ts-poet-wrapper.js";
+export declare function DiscriminatedUnionType_fromJsonFunctionExpression<MemberTypeT extends Type>(this: DiscriminatedUnionType<MemberTypeT>): Code;
+//# sourceMappingURL=DiscriminatedUnionType_fromJsonFunctionExpression.d.ts.map

package/dist/generators/ts/_DiscriminatedUnionType/DiscriminatedUnionType_fromJsonFunctionExpression.js

@@ -0,0 +1,14 @@
+import { code, joinCode } from "../ts-poet-wrapper.js";
+export function DiscriminatedUnionType_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");
+})`;
+}
+//# sourceMappingURL=DiscriminatedUnionType_fromJsonFunctionExpression.js.map

package/dist/generators/ts/_DiscriminatedUnionType/DiscriminatedUnionType_fromRdfResourceValuesFunctionExpression.d.ts

@@ -0,0 +1,5 @@
+import type { DiscriminatedUnionType } from "../DiscriminatedUnionType.js";
+import type { Type } from "../Type.js";
+import { type Code } from "../ts-poet-wrapper.js";
+export declare function DiscriminatedUnionType_fromRdfResourceValuesFunctionExpression<MemberTypeT extends Type>(this: DiscriminatedUnionType<MemberTypeT>): Code;
+//# sourceMappingURL=DiscriminatedUnionType_fromRdfResourceValuesFunctionExpression.d.ts.map

package/dist/generators/ts/_DiscriminatedUnionType/DiscriminatedUnionType_fromRdfResourceValuesFunctionExpression.js

@@ -0,0 +1,22 @@
+import { code, literalOf } from "../ts-poet-wrapper.js";
+export function DiscriminatedUnionType_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}>)`;
+}
+//# sourceMappingURL=DiscriminatedUnionType_fromRdfResourceValuesFunctionExpression.js.map

package/dist/generators/ts/_DiscriminatedUnionType/DiscriminatedUnionType_hashFunctionExpression.d.ts

@@ -0,0 +1,5 @@
+import type { DiscriminatedUnionType } from "../DiscriminatedUnionType.js";
+import type { Type } from "../Type.js";
+import { type Code } from "../ts-poet-wrapper.js";
+export declare function DiscriminatedUnionType_hashFunctionExpression<MemberTypeT extends Type>(this: DiscriminatedUnionType<MemberTypeT>): Code;
+//# sourceMappingURL=DiscriminatedUnionType_hashFunctionExpression.d.ts.map

package/dist/generators/ts/_DiscriminatedUnionType/DiscriminatedUnionType_hashFunctionExpression.js

@@ -0,0 +1,9 @@
+import { code, joinCode } from "../ts-poet-wrapper.js";
+export function DiscriminatedUnionType_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;
+})`;
+}
+//# sourceMappingURL=DiscriminatedUnionType_hashFunctionExpression.js.map

package/dist/generators/ts/_DiscriminatedUnionType/DiscriminatedUnionType_inferDiscriminant.d.ts

@@ -0,0 +1,8 @@
+import type { Maybe } from "purify-ts";
+import type { DiscriminatedUnionType } from "../DiscriminatedUnionType.js";
+import type { Type } from "../Type.js";
+export declare function DiscriminatedUnionType_inferDiscriminant<MemberTypeT extends Type>(this: DiscriminatedUnionType<MemberTypeT>, members: readonly {
+    readonly discriminantValue: Maybe<number | string>;
+    readonly type: Type;
+}[]): DiscriminatedUnionType.Discriminant;
+//# sourceMappingURL=DiscriminatedUnionType_inferDiscriminant.d.ts.map

package/dist/generators/ts/_DiscriminatedUnionType/DiscriminatedUnionType_inferDiscriminant.js

@@ -0,0 +1,133 @@
+import { invariant } from "ts-invariant";
+function termTypes(type) {
+    switch (type.kind) {
+        case "BlankNode":
+        case "Iri":
+        case "Identifier":
+        case "Literal":
+        case "Term":
+            return type.termTypes;
+        default:
+            return emptyTermTypesSet;
+    }
+}
+export function DiscriminatedUnionType_inferDiscriminant(members) {
+    // extrinsic with user-specified values
+    if (members.some((member) => member.discriminantValue.isJust())) {
+        return {
+            jsonName: this.configuration.objectDiscriminantProperty.jsonName,
+            kind: "Extrinsic",
+            memberValues: members.map((member, memberI) => member.discriminantValue.orDefault(memberI)),
+            name: this.configuration.objectDiscriminantProperty.name,
+        };
+    }
+    const memberTypes = members.map((member) => member.type);
+    // intrinsic
+    {
+        let intrinsicDiscriminantProperty;
+        let memberValues = [];
+        for (const memberType of memberTypes) {
+            const memberTypeDiscriminantProperty = memberType.discriminantProperty.extract();
+            if (!memberTypeDiscriminantProperty) {
+                intrinsicDiscriminantProperty = undefined;
+                break;
+            }
+            if (!intrinsicDiscriminantProperty) {
+                intrinsicDiscriminantProperty = memberTypeDiscriminantProperty;
+            }
+            else if (memberTypeDiscriminantProperty.name !==
+                intrinsicDiscriminantProperty.name) {
+                intrinsicDiscriminantProperty = undefined;
+                break;
+            }
+            memberValues = memberValues.concat(memberTypeDiscriminantProperty.values);
+        }
+        if (intrinsicDiscriminantProperty) {
+            return {
+                jsonName: intrinsicDiscriminantProperty.jsonName,
+                kind: "Intrinsic",
+                memberValues,
+                name: intrinsicDiscriminantProperty.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: this.configuration.objectDiscriminantProperty.jsonName,
+            kind: "Extrinsic",
+            memberValues,
+            name: this.configuration.objectDiscriminantProperty.name,
+        };
+    }
+}
+const emptyTermTypesSet = new Set();
+//# sourceMappingURL=DiscriminatedUnionType_inferDiscriminant.js.map

package/dist/generators/ts/_DiscriminatedUnionType/DiscriminatedUnionType_inlineExpression.d.ts

@@ -0,0 +1,5 @@
+import type { DiscriminatedUnionType } from "../DiscriminatedUnionType.js";
+import type { Type } from "../Type.js";
+import { type Code } from "../ts-poet-wrapper.js";
+export declare function DiscriminatedUnionType_inlineExpression<MemberTypeT extends Type>(this: DiscriminatedUnionType<MemberTypeT>): Code;
+//# sourceMappingURL=DiscriminatedUnionType_inlineExpression.d.ts.map

package/dist/generators/ts/_DiscriminatedUnionType/DiscriminatedUnionType_inlineExpression.js

@@ -0,0 +1,31 @@
+import { code, joinCode, literalOf } from "../ts-poet-wrapper.js";
+export function DiscriminatedUnionType_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");
+    }
+}
+//# sourceMappingURL=DiscriminatedUnionType_inlineExpression.js.map

package/dist/generators/ts/_DiscriminatedUnionType/DiscriminatedUnionType_jsonSchemaExpression.d.ts

@@ -0,0 +1,5 @@
+import type { DiscriminatedUnionType } from "../DiscriminatedUnionType.js";
+import type { Type } from "../Type.js";
+import { type Code } from "../ts-poet-wrapper.js";
+export declare function DiscriminatedUnionType_jsonSchemaExpression<MemberTypeT extends Type>(this: DiscriminatedUnionType<MemberTypeT>): Code;
+//# sourceMappingURL=DiscriminatedUnionType_jsonSchemaExpression.d.ts.map

package/dist/generators/ts/_DiscriminatedUnionType/DiscriminatedUnionType_jsonSchemaExpression.js

@@ -0,0 +1,32 @@
+import { code, joinCode, literalOf } from "../ts-poet-wrapper.js";
+export function DiscriminatedUnionType_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;
+    }
+}
+//# sourceMappingURL=DiscriminatedUnionType_jsonSchemaExpression.js.map