@shaclmate/compiler 4.0.13 → 4.0.15

package/dist/generators/ts/AbstractUnionType.d.ts

@@ -4,6 +4,7 @@ import type { BlankNodeType } from "./BlankNodeType.js";
 import type { IdentifierType } from "./IdentifierType.js";
 import type { IriType } from "./IriType.js";
 import type { Type } from "./Type.js";
+import type { Typeof } from "./Typeof.js";
 import { type Code } from "./ts-poet-wrapper.js";
 export declare abstract class AbstractUnionType<MemberTypeT extends Type> extends AbstractType {
     private readonly discriminant;
@@ -45,18 +46,37 @@ export declare abstract class AbstractUnionType<MemberTypeT extends Type> extend
     jsonUiSchemaElement(): Maybe<Code>;
     protected inlineHashStatements({ depth, variables, }: Parameters<AbstractType["hashStatements"]>[0]): readonly Code[];
 }
-type Discriminant = EnvelopeDiscriminant | InlineDiscriminant | TypeofDiscriminant;
-type EnvelopeDiscriminant = {
-    kind: "envelope";
-} & AbstractType.DiscriminantProperty;
-type InlineDiscriminant = {
-    kind: "inline";
-} & AbstractType.DiscriminantProperty;
+type Discriminant = ExtrinsicDiscriminant | HybridDiscriminant | IntrinsicDiscriminant | TypeofDiscriminant;
+type ExtrinsicDiscriminant = {
+    readonly kind: "extrinsic";
+    readonly memberValues: readonly AbstractType.DiscriminantProperty.Value[];
+    readonly name: string;
+};
+type HybridDiscriminant = {
+    readonly kind: "hybrid";
+    readonly memberValues: readonly {
+        readonly kind: "extrinsic" | "intrinsic";
+        readonly ownValues: readonly AbstractType.DiscriminantProperty.Value[];
+    }[];
+    readonly name: string;
+};
+type IntrinsicDiscriminant = {
+    readonly kind: "intrinsic";
+    readonly memberValues: readonly {
+        readonly descendantValues: readonly AbstractType.DiscriminantProperty.Value[];
+        readonly ownValues: readonly AbstractType.DiscriminantProperty.Value[];
+    }[];
+    readonly name: string;
+};
 type TypeofDiscriminant = {
-    kind: "typeof";
+    readonly kind: "typeof";
+    readonly memberValues: readonly Typeof[];
 };
 export declare namespace Discriminant {
-    function infer(memberTypes: readonly Type[]): Discriminant;
+    function infer(members: readonly {
+        readonly discriminantValue: Maybe<number | string>;
+        readonly type: Type;
+    }[]): Discriminant;
 }
 export declare namespace AbstractUnionType {
     interface AbstractMember<TypeT extends Type> {
@@ -67,10 +87,12 @@ export declare namespace AbstractUnionType {
     interface ConcreteMember<TypeT extends Type> {
         readonly abstract: false;
         readonly discriminantValues: readonly AbstractType.DiscriminantProperty.Value[];
+        readonly jsonType: Code | string;
         readonly jsonTypeCheck: (instance: Code) => Code;
         readonly primaryDiscriminantValue: AbstractType.DiscriminantProperty.Value;
         readonly type: TypeT;
         readonly typeCheck: (instance: Code) => Code;
+        readonly typeToJsonExpression: (valueVariable: Code) => Code;
         readonly unwrap: (instance: Code) => Code;
         readonly wrap: (instance: Code) => Code;
     }

package/dist/generators/ts/AbstractUnionType.js

@@ -13,6 +13,19 @@ import { removeUndefined } from "./removeUndefined.js";
 import { snippets } from "./snippets.js";
 import { syntheticNamePrefix } from "./syntheticNamePrefix.js";
 import { code, joinCode, literalOf } from "./ts-poet-wrapper.js";
+const emptyTermTypesSet = new Set();
+function termTypes(type) {
+    switch (type.kind) {
+        case "BlankNodeType":
+        case "IriType":
+        case "IdentifierType":
+        case "LiteralType":
+        case "TermType":
+            return type.termTypes;
+        default:
+            return emptyTermTypesSet;
+    }
+}
 export class AbstractUnionType extends AbstractType {
     discriminant;
     identifierType;
@@ -24,27 +37,22 @@ export class AbstractUnionType extends AbstractType {
         this.identifierType = identifierType;
         invariant(members.length >= 2);
         this.recursive = recursive;
-        if (members.some((member) => member.discriminantValue.isJust())) {
-            this.discriminant = {
-                descendantValues: [],
-                kind: "envelope",
-                name: "type",
-                ownValues: members.map((member, memberI) => member.discriminantValue.orDefault(memberI)),
-            };
-        }
-        else {
-            this.discriminant = Discriminant.infer(members.map((member) => member.type));
-        }
+        this.discriminant = Discriminant.infer(members);
         this.lazyMembers = () => members.map((member, memberI) => {
             if (member.type.abstract) {
                 return { abstract: true, discriminantValues: [], type: member.type };
             }
             let discriminantValues;
+            invariant(this.discriminant.memberValues.length === members.length);
             switch (this.discriminant.kind) {
-                case "envelope":
-                    discriminantValues = [this.discriminant.ownValues[memberI]];
+                case "extrinsic":
+                    discriminantValues = [this.discriminant.memberValues[memberI]];
                     break;
-                case "inline": {
+                case "hybrid":
+                    discriminantValues =
+                        this.discriminant.memberValues[memberI].ownValues;
+                    break;
+                case "intrinsic": {
                     // A member type's combined discriminant property values are its "own" values plus any descendant values that are
                     // not the "own" values of some other member type.
                     // So if you have type A, type B, and B inherits A, then
@@ -70,7 +78,7 @@ export class AbstractUnionType extends AbstractType {
                     break;
                 }
                 case "typeof":
-                    discriminantValues = member.type.typeofs;
+                    discriminantValues = [this.discriminant.memberValues[memberI]];
                     break;
                 default:
                     throw this.discriminant;
@@ -79,45 +87,62 @@ export class AbstractUnionType extends AbstractType {
                 return { abstract: true, discriminantValues: [], type: member.type };
             }
             const typeCheck = (json) => (instance) => {
-                switch (this.discriminant.kind) {
-                    case "envelope":
-                        return code `(${joinCode(discriminantValues.map((discriminantValue) => code `${instance}.${this.discriminant.name} === ${literalOf(discriminantValue)}`), { on: " || " })})`;
-                    case "inline": {
-                        if (!json) {
-                            switch (member.type.kind) {
-                                case "NamedObjectUnionType":
-                                case "NamedUnionType":
-                                case "NamedObjectType":
-                                    return code `${member.type.staticModuleName}.is${member.type.name}(${instance})`;
-                            }
-                        }
-                        return code `(${joinCode(discriminantValues.map((discriminantValue) => code `${instance}.${this.discriminant.name} === ${literalOf(discriminantValue)}`), { on: " || " })})`;
+                const discriminant = this.discriminant; // To get type narrowing to work
+                if (discriminant.kind === "typeof") {
+                    return code `(${joinCode(discriminantValues.map((discriminantValue) => code `typeof ${instance} === ${literalOf(discriminantValue)}`), { on: " || " })})`;
+                }
+                if (discriminant.kind === "intrinsic" && !json) {
+                    switch (member.type.kind) {
+                        case "NamedObjectUnionType":
+                        case "NamedUnionType":
+                        case "NamedObjectType":
+                            return code `${member.type.staticModuleName}.is${member.type.name}(${instance})`;
                     }
-                    case "typeof":
-                        return code `(${joinCode(discriminantValues.map((discriminantValue) => code `typeof ${instance} === ${literalOf(discriminantValue)}`), { on: " || " })})`;
                 }
+                return code `(${joinCode(discriminantValues.map((discriminantValue) => code `${instance}.${discriminant.name} === ${literalOf(discriminantValue)}`), { on: " || " })})`;
             };
             return {
                 abstract: false,
                 discriminantValues,
+                jsonType: member.type.jsonType({
+                    includeDiscriminantProperty: this.discriminant.kind === "intrinsic" ||
+                        (this.discriminant.kind === "hybrid" &&
+                            this.discriminant.memberValues[memberI].kind === "intrinsic"),
+                }).name,
                 jsonTypeCheck: typeCheck(true),
                 primaryDiscriminantValue: discriminantValues[0],
                 type: member.type,
                 typeCheck: typeCheck(false),
+                typeToJsonExpression: (valueVariable) => member.type.toJsonExpression({
+                    includeDiscriminantProperty: this.discriminant.kind === "intrinsic" ||
+                        (this.discriminant.kind === "hybrid" &&
+                            this.discriminant.memberValues[memberI].kind === "intrinsic"),
+                    variables: { value: valueVariable },
+                }),
                 unwrap: (instance) => {
                     switch (this.discriminant.kind) {
-                        case "envelope":
+                        case "extrinsic":
                             return code `${instance}.value`;
-                        case "inline":
+                        case "hybrid":
+                            return this.discriminant.memberValues[memberI].kind ===
+                                "intrinsic"
+                                ? instance
+                                : code `${instance}.value`;
+                        case "intrinsic":
                         case "typeof":
                             return instance;
                     }
                 },
                 wrap: (instance) => {
                     switch (this.discriminant.kind) {
-                        case "envelope":
-                            return code `{ ${this.discriminant.name}: "${discriminantValues[0]}" as const, value: ${instance} }`;
-                        case "inline":
+                        case "extrinsic":
+                            return code `{ ${this.discriminant.name}: ${literalOf(discriminantValues[0])} as const, value: ${instance} }`;
+                        case "hybrid":
+                            return this.discriminant.memberValues[memberI].kind ===
+                                "intrinsic"
+                                ? instance
+                                : code `{ ${this.discriminant.name}: ${literalOf(discriminantValues[0])} as const, value: ${instance} }`;
+                        case "intrinsic":
                         case "typeof":
                             return instance;
                     }
@@ -127,8 +152,9 @@ export class AbstractUnionType extends AbstractType {
     }
     get conversions() {
         switch (this.discriminant.kind) {
-            case "envelope":
-            case "inline":
+            case "extrinsic":
+            case "hybrid":
+            case "intrinsic":
                 return [
                     {
                         conversionExpression: (value) => value,
@@ -150,9 +176,24 @@ export class AbstractUnionType extends AbstractType {
     }
     get discriminantProperty() {
         switch (this.discriminant.kind) {
-            case "envelope":
-            case "inline":
-                return Maybe.of(this.discriminant);
+            case "extrinsic":
+                return Maybe.of({
+                    descendantValues: [],
+                    ownValues: this.discriminant.memberValues,
+                    name: this.discriminant.name,
+                });
+            case "hybrid":
+                return Maybe.of({
+                    descendantValues: [],
+                    ownValues: this.discriminant.memberValues.flatMap((_) => _.ownValues),
+                    name: "termType",
+                });
+            case "intrinsic":
+                return Maybe.of({
+                    descendantValues: this.discriminant.memberValues.flatMap((_) => _.descendantValues),
+                    name: this.discriminant.name,
+                    ownValues: this.discriminant.memberValues.flatMap((_) => _.ownValues),
+                });
             case "typeof":
                 return Maybe.empty();
             default:
@@ -172,7 +213,7 @@ export class AbstractUnionType extends AbstractType {
         invariant(this.kind.endsWith("Type"));
         return code `${{
             // discriminant: {
-            //   kind: '"envelope" | "inline" | "typeof"',
+            //   kind: '"extrinsic" | "intrinsic" | "typeof"',
             // },
             kind: code `${literalOf(this.kind.substring(0, this.kind.length - "Type".length))}`,
             members: code `{ ${joinCode(this.concreteMembers.map(({ type, primaryDiscriminantValue }) => code `readonly ${literalOf(primaryDiscriminantValue)}: ${{
@@ -228,9 +269,9 @@ if (filter.on?.[${literalOf(primaryDiscriminantValue)}] !== undefined && ${typeC
     get inlineFromJsonFunction() {
         return code `\
 ((value: ${this.jsonType().name}): ${this.name} => {
-${joinCode(this.concreteMembers.map(({ jsonTypeCheck, type, unwrap, wrap }) => code `if (${jsonTypeCheck(code `value`)}) { return ${wrap(type.fromJsonExpression({
+${joinCode(this.concreteMembers.map(({ jsonType, jsonTypeCheck, type, unwrap, wrap }) => code `if (${jsonTypeCheck(code `value`)}) { return ${wrap(type.fromJsonExpression({
             variables: {
-                value: code `(${unwrap(code `value`)} as ${type.jsonType().name})`,
+                value: code `(${unwrap(code `value`)} as ${jsonType})`,
             },
         }))}; }`))}
 
@@ -251,7 +292,7 @@ ${joinCode(this.concreteMembers.map(({ jsonTypeCheck, type, unwrap, wrap }) => c
 (((values, _options) =>
     values.chain(values => values.chainMap(value => {
       const valueAsValues = ${imports.Right}(value.toValues());
-      return ${this.concreteMembers.reduce((expression, { type, primaryDiscriminantValue }) => {
+      return ${this.concreteMembers.reduce((expression, { type, primaryDiscriminantValue }, memberI) => {
             let typeExpression = type.fromRdfResourceValuesExpression({
                 variables: {
                     context: variables.context,
@@ -264,7 +305,9 @@ ${joinCode(this.concreteMembers.map(({ jsonTypeCheck, type, unwrap, wrap }) => c
                     resourceValues: code `valueAsValues`,
                 },
             });
-            if (this.discriminant.kind === "envelope") {
+            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.name})))`;
             }
             typeExpression = code `(${typeExpression} as ${imports.Either}<Error, ${imports.Resource}.Values<${this.name}>>)`;
@@ -276,38 +319,75 @@ ${joinCode(this.concreteMembers.map(({ jsonTypeCheck, type, unwrap, wrap }) => c
 ) satisfies ${snippets.FromRdfResourceValuesFunction}<${this.name}>)`;
     }
     get inlineJsonType() {
-        switch (this.discriminant.kind) {
-            case "envelope":
-                return new AbstractType.JsonType(code `(${joinCode(this.concreteMembers.map(({ type, primaryDiscriminantValue }) => code `{ ${this.discriminant.name}: ${literalOf(primaryDiscriminantValue)}, value: ${type.jsonType().name} }`), { on: "|" })})`);
-            case "inline":
+        const discriminant = this.discriminant; // To get type narrowing to work
+        switch (discriminant.kind) {
+            case "extrinsic":
+                return new AbstractType.JsonType(code `(${joinCode(this.concreteMembers.map(({ jsonType, primaryDiscriminantValue }) => code `{ ${discriminant.name}: ${literalOf(primaryDiscriminantValue)}, value: ${jsonType} }`), { on: "|" })})`);
+            case "hybrid":
+                return new AbstractType.JsonType(code `(${joinCode(this.concreteMembers.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.concreteMembers.map(({ type }) => code `${type.jsonType({
-                    includeDiscriminantProperty: this.discriminant.kind === "inline",
-                }).name}`), { on: "|" }));
+                return new AbstractType.JsonType(joinCode(this.concreteMembers.map(({ jsonType }) => code `${jsonType}`), { on: "|" }));
             default:
-                throw this.discriminant;
+                throw discriminant;
         }
     }
     get inlineJsonSchema() {
-        switch (this.discriminant.kind) {
-            case "envelope":
-                return code `${imports.z}.discriminatedUnion("${this.discriminant.name}", [${joinCode(this.concreteMembers.map(({ type, primaryDiscriminantValue }) => code `${imports.z}.object({ ${this.discriminant.name}: ${imports.z}.literal(${literalOf(primaryDiscriminantValue)}), value: ${type.jsonSchema({ context: "type" })} })`), { on: "," })}])`;
-            case "inline":
-                return code `${imports.z}.discriminatedUnion("${this.discriminant.name}", [${joinCode(this.concreteMembers.map(({ type }) => type.jsonSchema({
+        const discriminant = this.discriminant; // To get type narrowing to work
+        switch (discriminant.kind) {
+            case "extrinsic":
+                return code `${imports.z}.discriminatedUnion("${discriminant.name}", [${joinCode(this.concreteMembers.map(({ type, primaryDiscriminantValue }) => code `${imports.z}.object({ ${discriminant.name}: ${imports.z}.literal(${literalOf(primaryDiscriminantValue)}), value: ${type.jsonSchema({ context: "type" })} })`), { on: "," })}]).readonly()`;
+            case "hybrid":
+                return code `${imports.z}.discriminatedUnion("${discriminant.name}", [${joinCode(this.concreteMembers.map(({ primaryDiscriminantValue, type }, memberI) => {
+                    switch (discriminant.memberValues[memberI].kind) {
+                        case "extrinsic":
+                            return code `${imports.z}.object({ ${discriminant.name}: ${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 `${imports.z}.discriminatedUnion("${discriminant.name}", [${joinCode(this.concreteMembers.map(({ type }) => type.jsonSchema({
                     includeDiscriminantProperty: true,
                     context: "type",
                 })), { on: "," })}]).readonly()`;
             case "typeof":
                 return code `${imports.z}.union([${joinCode(this.concreteMembers.map(({ type }) => type.jsonSchema({ context: "type" })), { on: "," })}]).readonly()`;
             default:
-                throw this.discriminant;
+                throw discriminant;
         }
     }
     get inlineName() {
-        switch (this.discriminant.kind) {
-            case "envelope":
-                return code `(${joinCode(this.concreteMembers.map(({ type, primaryDiscriminantValue }) => code `{ ${this.discriminant.name}: ${literalOf(primaryDiscriminantValue)}, value: ${type.name} }`), { on: "|" })})`;
-            case "inline":
+        const discriminant = this.discriminant; // To get type narrowing to work
+        switch (discriminant.kind) {
+            case "extrinsic":
+                return code `(${joinCode(this.concreteMembers.map(({ type, primaryDiscriminantValue }) => code `{ ${discriminant.name}: ${literalOf(primaryDiscriminantValue)}, value: ${type.name} }`), { on: "|" })})`;
+            case "hybrid":
+                return code `(${joinCode(this.concreteMembers.map(({ primaryDiscriminantValue, type }, memberI) => {
+                    switch (discriminant.memberValues[memberI].kind) {
+                        case "extrinsic":
+                            return code `{ ${discriminant.name}: ${literalOf(primaryDiscriminantValue)}, value: ${type.name} }`;
+                        case "intrinsic":
+                            return code `${type.name}`;
+                        default:
+                            throw new Error();
+                    }
+                }), { on: "|" })})`;
+            case "intrinsic":
                 // If every type shares a discriminant (e.g., RDF/JS "termType" or generated NamedObjectType "type"),
                 // just join their names with "|"
                 return code `(${joinCode(this.members.map(({ type }) => code `${type.name}`), { on: "|" })})`;
@@ -316,7 +396,7 @@ ${joinCode(this.concreteMembers.map(({ jsonTypeCheck, type, unwrap, wrap }) => c
                 // of the different member types are known to be different.
                 return code `(${joinCode(this.members.map(({ type }) => code `${type.name}`), { on: "|" })})`;
             default:
-                this.discriminant;
+                discriminant;
                 throw new Error("should never reach this point");
         }
     }
@@ -345,10 +425,7 @@ unionPatterns.push({ patterns: ${type.valueSparqlWherePatternsFunction}({ ...oth
     get inlineToJsonFunction() {
         return code `\
 ((value: ${this.name}): ${this.jsonType().name} => {
-${joinCode(this.concreteMembers.map(({ type, typeCheck, unwrap, wrap }) => code `if (${typeCheck(code `value`)}) { return ${wrap(type.toJsonExpression({
-            includeDiscriminantProperty: this.discriminant.kind === "inline",
-            variables: { value: unwrap(code `value`) },
-        }))}; }`))}
+${joinCode(this.concreteMembers.map(({ typeCheck, typeToJsonExpression, unwrap, wrap }) => code `if (${typeCheck(code `value`)}) { return ${wrap(typeToJsonExpression(unwrap(code `value`)))}; }`))}
 
   throw new Error("unable to serialize to JSON");
 })`;
@@ -437,77 +514,126 @@ __decorate([
 ], AbstractUnionType.prototype, "inlineValueSparqlWherePatternsFunction", null);
 export var Discriminant;
 (function (Discriminant) {
-    function inlineDiscriminantProperty(memberTypes) {
-        let inlineDiscriminantProperty;
-        for (const memberType of memberTypes) {
-            const memberTypeDiscriminantProperty = memberType.discriminantProperty.extract();
-            if (!memberTypeDiscriminantProperty) {
-                inlineDiscriminantProperty = undefined;
-                break;
+    function infer(members) {
+        // extrinsic with user-specified values
+        if (members.some((member) => member.discriminantValue.isJust())) {
+            return {
+                kind: "extrinsic",
+                memberValues: members.map((member, memberI) => member.discriminantValue.orDefault(memberI)),
+                name: "type",
+            };
+        }
+        const memberTypes = members.map((member) => member.type);
+        // intrinsic
+        {
+            let inlineDiscriminantPropertyName;
+            const memberValues = [];
+            for (const memberType of memberTypes) {
+                const memberTypeDiscriminantProperty = memberType.discriminantProperty.extract();
+                if (!memberTypeDiscriminantProperty) {
+                    inlineDiscriminantPropertyName = undefined;
+                    break;
+                }
+                if (!inlineDiscriminantPropertyName) {
+                    inlineDiscriminantPropertyName = memberTypeDiscriminantProperty.name;
+                }
+                else if (memberTypeDiscriminantProperty.name !== inlineDiscriminantPropertyName) {
+                    inlineDiscriminantPropertyName = undefined;
+                    break;
+                }
+                memberValues.push({
+                    descendantValues: memberTypeDiscriminantProperty.descendantValues,
+                    ownValues: memberTypeDiscriminantProperty.ownValues,
+                });
             }
-            if (!inlineDiscriminantProperty) {
-                inlineDiscriminantProperty = {
-                    name: memberTypeDiscriminantProperty.name,
-                    ownValues: memberTypeDiscriminantProperty.ownValues.concat(),
-                    descendantValues: memberTypeDiscriminantProperty.descendantValues.concat(),
+            if (inlineDiscriminantPropertyName) {
+                return {
+                    kind: "intrinsic",
+                    memberValues,
+                    name: inlineDiscriminantPropertyName,
                 };
             }
-            else if (memberTypeDiscriminantProperty.name === inlineDiscriminantProperty.name) {
-                inlineDiscriminantProperty.descendantValues =
-                    inlineDiscriminantProperty.descendantValues.concat(memberTypeDiscriminantProperty.descendantValues);
-                inlineDiscriminantProperty.ownValues =
-                    inlineDiscriminantProperty.ownValues.concat(memberTypeDiscriminantProperty.ownValues);
+        }
+        // typeof
+        {
+            const memberTypeofsSet = new Set();
+            for (const memberType of memberTypes) {
+                for (const memberTypeof of memberType.typeofs) {
+                    memberTypeofsSet.add(memberTypeof);
+                }
             }
-            else {
-                return undefined;
+            if (memberTypeofsSet.size === memberTypes.length) {
+                return {
+                    memberValues: memberTypes.flatMap((memberType) => memberType.typeofs),
+                    kind: "typeof",
+                };
             }
         }
-        return inlineDiscriminantProperty;
-    }
-    function infer(memberTypes) {
-        // Infer the discriminant kind
-        const inlineDiscriminantProperty_ = inlineDiscriminantProperty(memberTypes);
-        if (inlineDiscriminantProperty_) {
+        // 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 extrinsicMemberTypeNamesSet = new Set();
+            let extrinsicMemberTypeCount = 0;
+            for (const memberType of memberTypes) {
+                if (termTypes(memberType).size > 0) {
+                    continue;
+                }
+                extrinsicMemberTypeCount++;
+                if (typeof memberType.name === "string") {
+                    extrinsicMemberTypeNamesSet.add(memberType.name);
+                }
+                else {
+                    break;
+                }
+            }
             return {
-                ...inlineDiscriminantProperty_,
-                kind: "inline",
+                kind: "hybrid",
+                memberValues: memberTypes.map((memberType, memberTypeI) => {
+                    const memberTermTypes = termTypes(memberType);
+                    if (memberTermTypes.size > 0) {
+                        return {
+                            kind: "intrinsic",
+                            ownValues: [...memberTermTypes],
+                        };
+                    }
+                    return {
+                        kind: "extrinsic",
+                        ownValues: extrinsicMemberTypeNamesSet.size === extrinsicMemberTypeCount
+                            ? [memberType.name]
+                            : [memberTypeI.toString()],
+                    };
+                }),
+                name: "termType",
             };
         }
-        const memberTypeofs = new Set();
-        for (const memberType of memberTypes) {
-            for (const typeof_ of memberType.typeofs) {
-                memberTypeofs.add(typeof_);
+        // extrinsic with inferred values
+        {
+            let memberValues;
+            {
+                const memberTypeNames = memberTypes.map((memberType) => memberType.name);
+                if (memberTypeNames.every((memberTypeName) => typeof memberTypeName === "string")) {
+                    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}`);
+                    }
+                }
+                else {
+                    // At least one member type name is Code
+                    // Use member type indices as the discriminant values.
+                    memberValues = memberTypes.map((_, memberTypeI) => memberTypeI);
+                }
             }
-        }
-        if (memberTypeofs.size === memberTypes.length) {
+            invariant(memberValues.length === memberTypes.length);
             return {
-                kind: "typeof",
+                kind: "extrinsic",
+                name: "type",
+                memberValues: memberValues,
             };
         }
-        let ownValues;
-        const memberTypeNames = memberTypes.map((memberType) => memberType.name);
-        if (memberTypeNames.every((memberTypeName) => typeof memberTypeName === "string")) {
-            const memberTypeNamesSet = new Set(memberTypeNames);
-            if (memberTypeNamesSet.size === memberTypeNames.length) {
-                // If every member type name is a unique string, use those strings as the discriminant values.
-                ownValues = memberTypeNames;
-            }
-            else {
-                // Otherwise prefix the non-unique strings with an index and use those as the discriminant values.
-                ownValues = memberTypeNames.map((memberTypeName, memberTypeIndex) => `${memberTypeIndex}-${memberTypeName}`);
-            }
-        }
-        else {
-            // At least one member type name is Code
-            // Use member type indices as the discriminant values.
-            ownValues = memberTypes.map((_, memberTypeIndex) => memberTypeIndex);
-        }
-        return {
-            descendantValues: [],
-            kind: "envelope",
-            name: "type",
-            ownValues,
-        };
     }
     Discriminant.infer = infer;
 })(Discriminant || (Discriminant = {}));

package/dist/generators/ts/SetType.d.ts

@@ -3,6 +3,7 @@ import { type Code } from "./ts-poet-wrapper.js";
 export declare class SetType<ItemTypeT extends SetType.ItemType> extends AbstractCollectionType<ItemTypeT> {
     readonly graphqlArgs: AbstractCollectionType<ItemTypeT>["graphqlArgs"];
     readonly kind = "SetType";
+    get conversions(): readonly AbstractCollectionType.Conversion[];
     get valueSparqlConstructTriplesFunction(): Code;
     get valueSparqlWherePatternsFunction(): Code;
     fromRdfResourceValuesExpression(parameters: Parameters<AbstractCollectionType<ItemTypeT>["fromRdfResourceValuesExpression"]>[0]): Code;

package/dist/generators/ts/SetType.js

@@ -13,6 +13,18 @@ import { code, joinCode } from "./ts-poet-wrapper.js";
 export class SetType extends AbstractCollectionType {
     graphqlArgs = Maybe.empty();
     kind = "SetType";
+    get conversions() {
+        const conversions = [];
+        if (this.minCount === 0) {
+            conversions.push({
+                conversionExpression: () => code `[]`,
+                sourceTypeCheckExpression: (value) => code `${value} === undefined`,
+                sourceTypeName: code `undefined`,
+                sourceTypeof: "undefined",
+            });
+        }
+        return conversions.concat(super.conversions);
+    }
     get valueSparqlConstructTriplesFunction() {
         return code `${snippets.setSparqlConstructTriples}<${this.itemType.filterType}, ${this.itemType.schemaType}>(${this.itemType.valueSparqlConstructTriplesFunction})`;
     }

package/dist/generators/ts/_NamedObjectType/AbstractProperty.d.ts

@@ -1,5 +1,5 @@
 import type { Maybe } from "purify-ts";
-import type { PropertyVisibility } from "../../../enums/PropertyVisibility.js";
+import type { Visibility } from "../../../enums/Visibility.js";
 import type { NamedObjectType } from "../NamedObjectType.js";
 import type { Type } from "../Type.js";
 import { type Code } from "../ts-poet-wrapper.js";
@@ -74,12 +74,12 @@ export declare abstract class AbstractProperty<TypeT extends Pick<Type, "filterF
     /**
      * Property visibility: private, protected, public.
      */
-    readonly visibility: PropertyVisibility;
+    readonly visibility: Visibility;
     constructor({ name, namedObjectType, type, visibility, }: {
         name: string;
         namedObjectType: NamedObjectType;
         type: TypeT;
-        visibility: PropertyVisibility;
+        visibility: Visibility;
     });
     /**
      * TypeScript object describing this type, for runtime use.