@shaclmate/compiler 4.0.40 → 4.0.42

package/dist/generators/ts/UnionType.js

@@ -32,32 +32,11 @@ export class UnionType extends AbstractType {
                     discriminantValues = [this.discriminant.memberValues[memberI]];
                     break;
                 case "Hybrid":
-                    discriminantValues =
-                        this.discriminant.memberValues[memberI].ownValues;
+                    discriminantValues = this.discriminant.memberValues[memberI].values;
                     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
-                    // A has
-                    //   own discriminant property values: ["A"]
-                    //   descendant discriminant property values: ["B"]
-                    // and B has
-                    //  own discriminant property values: ["B"]
-                    //  descendant discriminant property values ["B"]
-                    // In this case A shouldn't have "B" as a combined discriminant property value since it's "claimed" by B.
-                    const memberOwnDiscriminantPropertyValues = new Set();
-                    for (const member of members) {
-                        for (const ownDiscriminantPropertyValue of member.type.discriminantProperty.unsafeCoerce()
-                            .ownValues) {
-                            memberOwnDiscriminantPropertyValues.add(ownDiscriminantPropertyValue);
-                        }
-                    }
-                    discriminantValues = member.type.discriminantProperty
-                        .unsafeCoerce()
-                        .ownValues.concat(member.type.discriminantProperty
-                        .unsafeCoerce()
-                        .descendantValues.filter((value) => !memberOwnDiscriminantPropertyValues.has(value)));
+                    discriminantValues =
+                        member.type.discriminantProperty.unsafeCoerce().values;
                     break;
                 }
                 case "Typeof":
@@ -76,7 +55,7 @@ export class UnionType extends AbstractType {
                     switch (member.type.kind) {
                         case "Object":
                         case "ObjectUnion":
-                            return code `${member.type.alias.unsafeCoerce()}.is${member.type.alias.unsafeCoerce()}(${instance})`;
+                            return code `${member.type.name.unsafeCoerce()}.is${member.type.name.unsafeCoerce()}(${instance})`;
                     }
                 }
                 const discriminantName = json
@@ -90,7 +69,7 @@ export class UnionType extends AbstractType {
                     includeDiscriminantProperty: this.discriminant.kind === "Intrinsic" ||
                         (this.discriminant.kind === "Hybrid" &&
                             this.discriminant.memberValues[memberI].kind === "Intrinsic"),
-                }).name,
+                }).expression,
                 jsonTypeCheck: typeCheck(true),
                 primaryDiscriminantValue: discriminantValues[0],
                 type: member.type,
@@ -136,31 +115,34 @@ export class UnionType extends AbstractType {
         return Maybe.of({
             code: code `${this.reusables.snippets.identityConversionFunction}`,
             sourceTypes: this.discriminant.kind === "Typeof"
-                ? this.members.map(({ primaryDiscriminantValue, type }) => ({
+                ? this.members.flatMap(({ type }) => type.jsTypes.map((jsType) => ({
                     expression: type.expression,
-                    typeof: primaryDiscriminantValue,
-                }))
+                    jsType,
+                })))
                 : [
                     {
                         expression: this.expression,
-                        typeof: "object",
+                        jsType: {
+                            instanceof: "Object",
+                            typeof: "object",
+                        },
                     },
                 ],
         });
     }
     get declaration() {
-        const alias = this.alias.extract();
-        if (!alias) {
+        const name = this.name.extract();
+        if (!name) {
             return Maybe.empty();
         }
         const declarations = [];
         if (this.configuration.features.has("Object.type")) {
-            declarations.push(code `export type ${def(alias)} = ${this.inlineExpression};`);
+            declarations.push(code `export type ${def(name)} = ${this.inlineExpression};`);
         }
         const staticModuleDeclarations = Object.entries(this.staticModuleDeclarations);
         if (staticModuleDeclarations.length > 0) {
             declarations.push(code `\
-export namespace ${def(alias)} {
+export namespace ${def(name)} {
 ${joinCode(staticModuleDeclarations
                 .sort((left, right) => left[0].localeCompare(right[0]))
                 .map((_) => _[1]), { on: "\n\n" })}
@@ -172,24 +154,21 @@ ${joinCode(staticModuleDeclarations
         switch (this.discriminant.kind) {
             case "Extrinsic":
                 return Maybe.of({
-                    descendantValues: [],
                     jsonName: this.discriminant.jsonName,
-                    ownValues: this.discriminant.memberValues,
                     name: this.discriminant.name,
+                    values: this.discriminant.memberValues,
                 });
             case "Hybrid":
                 return Maybe.of({
-                    descendantValues: [],
                     jsonName: this.discriminant.jsonName,
-                    ownValues: this.discriminant.memberValues.flatMap((_) => _.ownValues),
                     name: "termType",
+                    values: this.discriminant.memberValues.flatMap((_) => _.values),
                 });
             case "Intrinsic":
                 return Maybe.of({
-                    descendantValues: this.discriminant.memberValues.flatMap((_) => _.descendantValues),
                     jsonName: this.discriminant.jsonName,
                     name: this.discriminant.name,
-                    ownValues: this.discriminant.memberValues.flatMap((_) => _.ownValues),
+                    values: this.discriminant.memberValues,
                 });
             case "Typeof":
                 return Maybe.empty();
@@ -198,32 +177,53 @@ ${joinCode(staticModuleDeclarations
         }
     }
     get equalsFunction() {
-        return this.alias
-            .map((alias) => code `${alias}.equals`)
-            .orDefault(this.inlineEqualsFunction);
+        return this.name
+            .map((name) => code `${name}.equals`)
+            .orDefault(this.equalsFunctionExpression);
+    }
+    get expression() {
+        return this.name
+            .map((name) => code `${name}`)
+            .orDefault(this.inlineExpression);
     }
     get filterFunction() {
-        return this.alias
-            .map((alias) => code `${alias}.filter`)
-            .orDefault(this.inlineFilterFunction);
+        return this.name
+            .map((name) => code `${name}.filter`)
+            .orDefault(this.filterFunctionExpression);
     }
     get filterType() {
-        return this.alias
-            .map((alias) => code `${alias}.Filter`)
-            .orDefault(this.inlineFilterType);
+        return this.name
+            .map((name) => code `${name}.Filter`)
+            .orDefault(this.filterTypeLiteral);
+    }
+    get fromRdfResourceValuesFunction() {
+        return this.name
+            .map((name) => code `${name}.fromRdfResourceValues`)
+            .orDefault(this.fromRdfResourceValuesFunctionExpression);
     }
     get graphqlType() {
-        const alias = this.alias.extract();
-        if (!alias ||
+        const name = this.name.extract();
+        if (!name ||
             !this.members.every((member) => member.type.kind === "Object")) {
             throw new Error("not implemented");
         }
-        return new AbstractType.GraphqlType(code `${alias}.GraphQL`, this.reusables);
+        return new AbstractType.GraphqlType(code `${name}.GraphQL`, this.reusables);
     }
     get hashFunction() {
-        return this.alias
-            .map((alias) => code `${alias}.hash`)
-            .orDefault(this.inlineHashFunction);
+        return this.name
+            .map((name) => code `${name}.hash`)
+            .orDefault(this.hashFunctionExpression);
+    }
+    get jsTypes() {
+        const jsTypes = [];
+        for (const member of this.members) {
+            for (const memberJsType of member.type.jsTypes) {
+                if (!jsTypes.some((jsType) => AbstractType.JsType.equals(jsType, memberJsType))) {
+                    jsTypes.push(memberJsType);
+                }
+            }
+        }
+        return jsTypes;
     }
     get jsonSchemaFunctionDeclaration() {
         const meta = {
@@ -235,10 +235,10 @@ ${joinCode(staticModuleDeclarations
         this.label.ifJust((label) => {
             meta["title"] = label;
         });
-        return code `export const schema = () => ${this.inlineJsonSchema}.meta(${meta});`;
+        return code `export const schema = () => ${this.jsonSchemaExpression}.meta(${meta});`;
     }
     get jsonTypeAliasDeclaration() {
-        return code `export type Json = ${this.inlineJsonType.name}`;
+        return code `export type Json = ${this.jsonTypeLiteral.expression}`;
     }
     get members() {
         return this.lazyMembers();
@@ -246,22 +246,19 @@ ${joinCode(staticModuleDeclarations
     get mutable() {
         return this.members.some((member) => member.type.mutable);
     }
-    get expression() {
-        return this.alias
-            .map((alias) => code `${alias}`)
-            .orDefault(this.inlineExpression);
+    get referencesNamedType() {
+        return (this.name.isJust() ||
+            this.members.some((member) => member.type.referencesNamedType));
     }
-    get referencesObjectType() {
-        return this.members.some((member) => member.type.referencesObjectType);
+    get schema() {
+        return this.name
+            .map((name) => code `${name}.schema`)
+            .orDefault(this.schemaExpression);
     }
     get schemaType() {
-        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: ";" })} }`,
-        }}`;
+        return this.name
+            .map(() => code `typeof ${this.schema}`)
+            .orDefault(this.schemaTypeExpression);
     }
     get toRdfResourceValueTypes() {
         const set = new Set();
@@ -272,20 +269,98 @@ ${joinCode(staticModuleDeclarations
         }
         return set;
     }
-    get typeofs() {
-        return [...new Set(this.members.flatMap((member) => member.type.typeofs))];
-    }
     get valueSparqlConstructTriplesFunction() {
-        return this.alias
-            .map((alias) => code `${alias}.valueSparqlConstructTriples`)
-            .orDefault(this.inlineValueSparqlConstructTriplesFunction);
+        return this.name
+            .map((name) => code `${name}.valueSparqlConstructTriples`)
+            .orDefault(this.valueSparqlConstructTriplesFunctionExpression);
     }
     get valueSparqlWherePatternsFunction() {
-        return this.alias
-            .map((alias) => code `${alias}.valueSparqlWherePatterns`)
-            .orDefault(this.inlineValueSparqlWherePatternsFunction);
+        return this.name
+            .map((name) => code `${name}.valueSparqlWherePatterns`)
+            .orDefault(this.valueSparqlWherePatternsFunctionExpression);
+    }
+    get schemaInitializers() {
+        return super.schemaInitializers.concat(code `members: { ${joinCode(this.members.map(({ discriminantValues, type, primaryDiscriminantValue }) => code `${literalOf(primaryDiscriminantValue)}: ${{
+            discriminantValues: discriminantValues,
+            type: type.schema,
+        }}`), { on: "," })} }`);
     }
-    get inlineEqualsFunction() {
+    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};`;
+        }
+        if (this.configuration.features.has("Object.filter")) {
+            staticModuleDeclarations[`Filter`] =
+                code `export type Filter = ${this.filterTypeLiteral};`;
+            staticModuleDeclarations[`filter`] =
+                code `export const filter = ${this.filterFunctionExpression};`;
+        }
+        if (this.configuration.features.has("Object.hash")) {
+            staticModuleDeclarations[`hash`] =
+                code `export const hash = ${this.hashFunctionExpression};`;
+        }
+        if (this.configuration.features.has("Object.JSON.type")) {
+            staticModuleDeclarations[`Json.type`] =
+                code `${this.jsonTypeAliasDeclaration}`;
+        }
+        if (this.configuration.features.has("Object.JSON.schema")) {
+            staticModuleDeclarations[`Json.namespace`] = code `\
+export namespace Json {
+  ${this.jsonSchemaFunctionDeclaration}
+
+  export function parse(json: unknown): ${this.reusables.imports.Either}<Error, Json> {
+    const jsonSafeParseResult = schema().safeParse(json);
+    if (!jsonSafeParseResult.success) { return ${this.reusables.imports.Left}(jsonSafeParseResult.error); }
+    return ${this.reusables.imports.Right}(jsonSafeParseResult.data);
+  }
+}`;
+        }
+        if (this.configuration.features.has("Object.fromJson")) {
+            staticModuleDeclarations[`fromJson`] =
+                code `export const fromJson = ${this.fromJsonFunctionExpression};`;
+        }
+        if (this.configuration.features.has("Object.fromRdf")) {
+            staticModuleDeclarations[`fromRdfResourceValues`] =
+                code `export const fromRdfResourceValues: ${this.reusables.snippets.FromRdfResourceValuesFunction}<${name}, ${this.schemaType}> = ${this.fromRdfResourceValuesFunctionExpression};`;
+        }
+        if (this.configuration.features.has("Object.schema")) {
+            staticModuleDeclarations["schema"] =
+                code `export const schema = ${this.schemaExpression}`;
+        }
+        if (this.configuration.features.has("Object.toJson")) {
+            staticModuleDeclarations[`toJson`] =
+                code `export const toJson = ${this.toJsonFunctionExpression};`;
+        }
+        if (this.configuration.features.has("Object.toRdf")) {
+            staticModuleDeclarations[`toRdfResourceValues`] =
+                code `export const toRdfResourceValues = ${this.toRdfResourceValuesFunctionExpression};`;
+        }
+        if (this.configuration.features.has("Object.SPARQL")) {
+            staticModuleDeclarations[`valueSparqlConstructTriples`] =
+                code `export const valueSparqlConstructTriples: ${this.reusables.snippets.ValueSparqlConstructTriplesFunction}<${this.filterType}, ${this.schemaType}> = ${this.valueSparqlConstructTriplesFunctionExpression};`;
+            staticModuleDeclarations[`valueSparqlWherePatterns`] =
+                code `export const valueSparqlWherePatterns: ${this.reusables.snippets.ValueSparqlWherePatternsFunction}<${this.filterType}, ${this.schemaType}> = ${this.valueSparqlWherePatternsFunctionExpression};`;
+        }
+        if (this.configuration.features.has("Object.toString")) {
+            const syntheticNamePrefix = this.configuration.syntheticNamePrefix;
+            staticModuleDeclarations[`${syntheticNamePrefix}toString`] =
+                code `export const ${syntheticNamePrefix}toString = ${this.toStringFunctionExpression};`;
+        }
+        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`)}) {
@@ -295,7 +370,7 @@ ${joinCode(this.members.map(({ type, typeCheck, unwrap }) => code `if (${typeChe
   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 inlineFilterFunction() {
+    get filterFunctionExpression() {
         const syntheticNamePrefix = this.configuration.syntheticNamePrefix;
         return code `\
 ((filter: ${this.filterType}, value: ${this.expression}) => {
@@ -317,7 +392,7 @@ if (filter.on?.[${literalOf(primaryDiscriminantValue)}] !== undefined && ${typeC
   return true;
 })`;
     }
-    get inlineFilterType() {
+    get filterTypeLiteral() {
         const syntheticNamePrefix = this.configuration.syntheticNamePrefix;
         return code `\
   {
@@ -325,9 +400,9 @@ if (filter.on?.[${literalOf(primaryDiscriminantValue)}] !== undefined && ${typeC
    readonly on?: { ${joinCode(this.members.map(({ type, primaryDiscriminantValue }) => code `readonly ${literalOf(primaryDiscriminantValue)}?: ${type.filterType}`), { on: ";" })} }
   }`;
     }
-    get inlineFromJsonFunction() {
+    get fromJsonFunctionExpression() {
         return code `\
-((value: ${this.jsonType().name}): ${this.reusables.imports.Either}<Error, ${this.expression}> => {
+((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})`,
@@ -337,33 +412,13 @@ ${joinCode(this.members.map(({ jsonType, jsonTypeCheck, type, unwrap, wrap }) =>
   throw new Error("unable to deserialize JSON");
 })`;
     }
-    get inlineFromRdfResourceValuesFunction() {
-        const variables = {
-            context: code `_options.context`,
-            graph: code `_options.graph`,
-            ignoreRdfType: false,
-            objectSet: code `_options.objectSet`,
-            preferredLanguages: code `_options.preferredLanguages`,
-            propertyPath: code `_options.propertyPath`,
-            resource: code `_options.resource`,
-        };
+    get fromRdfResourceValuesFunctionExpression() {
         return code `\
-(((values, _options) =>
-    values.chain(values => values.chainMap(value => {
-      const valueAsValues = ${this.reusables.imports.Right}(value.toValues());
-      return ${this.members.reduce((expression, { type, primaryDiscriminantValue }, memberI) => {
-            let typeExpression = type.fromRdfResourceValuesExpression({
-                variables: {
-                    context: variables.context,
-                    graph: variables.graph,
-                    ignoreRdfType: false,
-                    objectSet: variables.objectSet,
-                    preferredLanguages: variables.preferredLanguages,
-                    propertyPath: variables.propertyPath,
-                    resource: variables.resource,
-                    resourceValues: code `valueAsValues`,
-                },
-            });
+(((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")) {
@@ -374,17 +429,49 @@ ${joinCode(this.members.map(({ jsonType, jsonTypeCheck, type, unwrap, wrap }) =>
                 ? code `${expression}.altLazy(() => ${typeExpression})`
                 : typeExpression;
         }, null)}.chain(values => values.head());
-    }))
-) satisfies ${this.reusables.snippets.FromRdfResourceValuesFunction}<${this.expression}>)`;
+  })
+) satisfies ${this.reusables.snippets.FromRdfResourceValuesFunction}<${this.expression}, ${this.schemaType}>)`;
     }
-    get inlineHashFunction() {
+    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;
 })`;
     }
-    get inlineJsonSchema() {
+    /**
+     * 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":
@@ -414,7 +501,7 @@ ${joinCode(this.members.map(({ type, typeCheck, unwrap }) => code `if (${typeChe
                 throw discriminant;
         }
     }
-    get inlineJsonType() {
+    get jsonTypeLiteral() {
         const discriminant = this.discriminant; // To get type narrowing to work
         switch (discriminant.kind) {
             case "Extrinsic":
@@ -437,44 +524,15 @@ ${joinCode(this.members.map(({ type, typeCheck, unwrap }) => code `if (${typeChe
                 throw discriminant;
         }
     }
-    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 inlineToJsonFunction() {
+    get toJsonFunctionExpression() {
         return code `\
-((value: ${this.expression}): ${this.jsonType().name} => {
+((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 inlineToRdfResourceValuesFunction() {
+    get toRdfResourceValuesFunctionExpression() {
         return code `\
 (((value, _options): (${joinCode([...this.toRdfResourceValueTypes].map((toRdfResourceValueType) => {
             switch (toRdfResourceValueType) {
@@ -502,7 +560,7 @@ ${joinCode(this.members.map(({ type, unwrap, typeCheck }) => code `if (${typeChe
   throw new Error("unable to serialize to RDF");
 }) satisfies ${this.reusables.snippets.ToRdfResourceValuesFunction}<${this.expression}>)`;
     }
-    get inlineToStringFunction() {
+    get toStringFunctionExpression() {
         return code `\
 ((value: ${this.expression}): string => {
 ${joinCode(this.members.map(({ type, typeCheck, unwrap }) => code `if (${typeCheck(code `value`)}) { return ${type.toStringExpression({
@@ -512,7 +570,7 @@ ${joinCode(this.members.map(({ type, typeCheck, unwrap }) => code `if (${typeChe
   throw new Error("unable to serialize to string");
 })`;
     }
-    get inlineValueSparqlConstructTriplesFunction() {
+    get valueSparqlConstructTriplesFunctionExpression() {
         return code `\
 ((({ ignoreRdfType, filter, schema, ...otherParameters }) => {
   let triples: ${this.reusables.imports.sparqljs}.Triple[] = [];
@@ -523,7 +581,7 @@ triples = triples.concat(${type.valueSparqlConstructTriplesFunction}({ ...otherP
   return triples;
 }) satisfies ${this.reusables.snippets.ValueSparqlConstructTriplesFunction}<${this.filterType}, ${this.schemaType}>)`;
     }
-    get inlineValueSparqlWherePatternsFunction() {
+    get valueSparqlWherePatternsFunctionExpression() {
         return code `\
 ((({ filter, schema, ...otherParameters }) => {
   const unionPatterns: ${this.reusables.imports.sparqljs}.GroupPattern[] = [];
@@ -534,114 +592,38 @@ unionPatterns.push({ patterns: ${type.valueSparqlWherePatternsFunction}({ ...oth
   return [{ patterns: unionPatterns, type: "union" }];
 }) satisfies ${this.reusables.snippets.ValueSparqlWherePatternsFunction}<${this.filterType}, ${this.schemaType}>)`;
     }
-    get schemaInitializers() {
-        return super.schemaInitializers.concat(code `members: { ${joinCode(this.members.map(({ discriminantValues, type, primaryDiscriminantValue }) => code `${literalOf(primaryDiscriminantValue)}: ${{
-            discriminantValues: discriminantValues,
-            type: type.schema,
-        }}`), { on: "," })} }`);
-    }
-    get staticModuleDeclarations() {
-        const alias = this.alias.unsafeCoerce();
-        const staticModuleDeclarations = {};
-        if (this.configuration.features.has("Object.equals")) {
-            staticModuleDeclarations[`equals`] =
-                code `export const equals = ${this.inlineEqualsFunction};`;
-        }
-        if (this.configuration.features.has("Object.filter")) {
-            staticModuleDeclarations[`Filter`] =
-                code `export type Filter = ${this.inlineFilterType};`;
-            staticModuleDeclarations[`filter`] =
-                code `export const filter = ${this.inlineFilterFunction};`;
-        }
-        if (this.configuration.features.has("Object.hash")) {
-            staticModuleDeclarations[`hash`] =
-                code `export const hash = ${this.inlineHashFunction};`;
-        }
-        if (this.configuration.features.has("Object.JSON.type")) {
-            staticModuleDeclarations[`Json.type`] =
-                code `${this.jsonTypeAliasDeclaration}`;
-        }
-        if (this.configuration.features.has("Object.JSON.schema")) {
-            staticModuleDeclarations[`Json.namespace`] = code `\
-export namespace Json {
-  ${this.jsonSchemaFunctionDeclaration}
-
-  export function parse(json: unknown): ${this.reusables.imports.Either}<Error, Json> {
-    const jsonSafeParseResult = schema().safeParse(json);
-    if (!jsonSafeParseResult.success) { return ${this.reusables.imports.Left}(jsonSafeParseResult.error); }
-    return ${this.reusables.imports.Right}(jsonSafeParseResult.data);
-  }
-}`;
-        }
-        if (this.configuration.features.has("Object.fromJson")) {
-            staticModuleDeclarations[`fromJson`] =
-                code `export const fromJson = ${this.inlineFromJsonFunction};`;
-        }
-        if (this.configuration.features.has("Object.fromRdf")) {
-            staticModuleDeclarations[`fromRdfResourceValues`] =
-                code `export const fromRdfResourceValues: ${this.reusables.snippets.FromRdfResourceValuesFunction}<${alias}> = ${this.inlineFromRdfResourceValuesFunction};`;
-        }
-        if (this.configuration.features.has("Object.toJson")) {
-            staticModuleDeclarations[`toJson`] =
-                code `export const toJson = ${this.inlineToJsonFunction};`;
-        }
-        if (this.configuration.features.has("Object.toRdf")) {
-            staticModuleDeclarations[`toRdfResourceValues`] =
-                code `export const toRdfResourceValues = ${this.inlineToRdfResourceValuesFunction};`;
-        }
-        if (this.configuration.features.has("Object.SPARQL")) {
-            staticModuleDeclarations[`valueSparqlConstructTriples`] =
-                code `export const valueSparqlConstructTriples: ${this.reusables.snippets.ValueSparqlConstructTriplesFunction}<${this.filterType}, ${this.schemaType}> = ${this.inlineValueSparqlConstructTriplesFunction};`;
-            staticModuleDeclarations[`valueSparqlWherePatterns`] =
-                code `export const valueSparqlWherePatterns: ${this.reusables.snippets.ValueSparqlWherePatternsFunction}<${this.filterType}, ${this.schemaType}> = ${this.inlineValueSparqlWherePatternsFunction};`;
-        }
-        if (this.configuration.features.has("Object.toString")) {
-            const syntheticNamePrefix = this.configuration.syntheticNamePrefix;
-            staticModuleDeclarations[`${syntheticNamePrefix}toString`] =
-                code `export const ${syntheticNamePrefix}toString = ${this.inlineToStringFunction};`;
-        }
-        return staticModuleDeclarations;
-    }
     fromJsonExpression({ variables, }) {
-        return code `${this.alias.map((alias) => code `${alias}.fromJson`).orDefault(this.inlineFromJsonFunction)}(${variables.value})`;
-    }
-    fromRdfResourceValuesExpression({ variables, }) {
-        const { resourceValues: resourceValuesVariable, ...fromRdfResourceValuesOptionsTemp } = variables;
-        const fromRdfResourceValuesOptions = fromRdfResourceValuesOptionsTemp;
-        if (!this.configuration.features.has("ObjectSet")) {
-            delete fromRdfResourceValuesOptions["objectSet"];
-        }
-        return code `${this.alias.map((alias) => code `${alias}.fromRdfResourceValues`).orDefault(this.inlineFromRdfResourceValuesFunction)}(${resourceValuesVariable}, ${fromRdfResourceValuesOptions})`;
+        return code `${this.name.map((name) => code `${name}.fromJson`).orDefault(this.fromJsonFunctionExpression)}(${variables.value})`;
     }
     graphqlResolveExpression({ variables, }) {
         return variables.value;
     }
     jsonSchema({ context, }) {
-        const expression = this.alias
-            .map((alias) => code `${alias}.Json.schema()`)
-            .orDefault(this.inlineJsonSchema);
+        const expression = this.name
+            .map((name) => code `${name}.Json.schema()`)
+            .orDefault(this.jsonSchemaExpression);
         if (context === "property" && this.recursive) {
-            return code `${this.reusables.imports.z}.lazy((): ${this.reusables.imports.z}.ZodType<${this.jsonType().name}> => ${expression})`;
+            return code `${this.reusables.imports.z}.lazy((): ${this.reusables.imports.z}.ZodType<${this.jsonType().expression}> => ${expression})`;
         }
         return expression;
     }
     jsonType() {
-        return this.alias
-            .map((alias) => new AbstractType.JsonType(`${alias}.Json`))
-            .orDefault(this.inlineJsonType);
+        return this.name
+            .map((name) => new AbstractType.JsonType(code `${name}.Json`))
+            .orDefault(this.jsonTypeLiteral);
     }
     jsonUiSchemaElement() {
         return Maybe.empty();
     }
     toJsonExpression({ variables, }) {
-        return code `${this.alias.map((alias) => code `${alias}.toJson`).orDefault(this.inlineToJsonFunction)}(${variables.value})`;
+        return code `${this.name.map((name) => code `${name}.toJson`).orDefault(this.toJsonFunctionExpression)}(${variables.value})`;
     }
     toRdfResourceValuesExpression({ variables, }) {
         const { value: valueVariable, ...otherVariables } = variables;
-        return code `${this.alias.map((alias) => code `${alias}.toRdfResourceValues`).orDefault(this.inlineToRdfResourceValuesFunction)}(${valueVariable}, ${otherVariables})`;
+        return code `${this.name.map((name) => code `${name}.toRdfResourceValues`).orDefault(this.toRdfResourceValuesFunctionExpression)}(${valueVariable}, ${otherVariables})`;
     }
     toStringExpression({ variables, }) {
-        return code `${this.alias.map((alias) => code `${alias}.${this.configuration.syntheticNamePrefix}toString`).orDefault(this.inlineToStringFunction)}(${variables.value})`;
+        return code `${this.name.map((name) => code `${name}.${this.configuration.syntheticNamePrefix}toString`).orDefault(this.toStringFunctionExpression)}(${variables.value})`;
     }
     lazyMembers;
 }
@@ -657,18 +639,27 @@ __decorate([
 __decorate([
     Memoize()
 ], UnionType.prototype, "equalsFunction", null);
+__decorate([
+    Memoize()
+], UnionType.prototype, "expression", null);
 __decorate([
     Memoize()
 ], UnionType.prototype, "filterFunction", null);
 __decorate([
     Memoize()
 ], UnionType.prototype, "filterType", null);
+__decorate([
+    Memoize()
+], UnionType.prototype, "fromRdfResourceValuesFunction", null);
 __decorate([
     Memoize()
 ], UnionType.prototype, "graphqlType", null);
 __decorate([
     Memoize()
 ], UnionType.prototype, "hashFunction", null);
+__decorate([
+    Memoize()
+], UnionType.prototype, "jsTypes", null);
 __decorate([
     Memoize()
 ], UnionType.prototype, "members", null);
@@ -677,13 +668,13 @@ __decorate([
 ], UnionType.prototype, "mutable", null);
 __decorate([
     Memoize()
-], UnionType.prototype, "expression", null);
+], UnionType.prototype, "schema", null);
 __decorate([
     Memoize()
-], UnionType.prototype, "toRdfResourceValueTypes", null);
+], UnionType.prototype, "schemaType", null);
 __decorate([
     Memoize()
-], UnionType.prototype, "typeofs", null);
+], UnionType.prototype, "toRdfResourceValueTypes", null);
 __decorate([
     Memoize()
 ], UnionType.prototype, "valueSparqlConstructTriplesFunction", null);
@@ -692,25 +683,28 @@ __decorate([
 ], UnionType.prototype, "valueSparqlWherePatternsFunction", null);
 __decorate([
     Memoize()
-], UnionType.prototype, "inlineEqualsFunction", null);
+], UnionType.prototype, "schemaTypeExpression", null);
 __decorate([
     Memoize()
-], UnionType.prototype, "inlineFilterFunction", null);
+], UnionType.prototype, "equalsFunctionExpression", null);
 __decorate([
     Memoize()
-], UnionType.prototype, "inlineFilterType", null);
+], UnionType.prototype, "filterFunctionExpression", null);
 __decorate([
     Memoize()
-], UnionType.prototype, "inlineJsonType", null);
+], UnionType.prototype, "filterTypeLiteral", null);
 __decorate([
     Memoize()
 ], UnionType.prototype, "inlineExpression", null);
 __decorate([
     Memoize()
-], UnionType.prototype, "inlineValueSparqlConstructTriplesFunction", null);
+], UnionType.prototype, "jsonTypeLiteral", null);
 __decorate([
     Memoize()
-], UnionType.prototype, "inlineValueSparqlWherePatternsFunction", null);
+], UnionType.prototype, "valueSparqlConstructTriplesFunctionExpression", null);
+__decorate([
+    Memoize()
+], UnionType.prototype, "valueSparqlWherePatternsFunctionExpression", null);
 __decorate([
     Memoize()
 ], UnionType.prototype, "jsonType", null);
@@ -743,7 +737,7 @@ export var Discriminant;
         // intrinsic
         {
             let inlineDiscriminantProperty;
-            const memberValues = [];
+            let memberValues = [];
             for (const memberType of memberTypes) {
                 const memberTypeDiscriminantProperty = memberType.discriminantProperty.extract();
                 if (!memberTypeDiscriminantProperty) {
@@ -758,10 +752,7 @@ export var Discriminant;
                     inlineDiscriminantProperty = undefined;
                     break;
                 }
-                memberValues.push({
-                    descendantValues: memberTypeDiscriminantProperty.descendantValues,
-                    ownValues: memberTypeDiscriminantProperty.ownValues,
-                });
+                memberValues = memberValues.concat(memberTypeDiscriminantProperty.values);
             }
             if (inlineDiscriminantProperty) {
                 return {
@@ -774,15 +765,17 @@ export var Discriminant;
         }
         // typeof
         {
+            const memberTypeofs = [];
             const memberTypeofsSet = new Set();
             for (const memberType of memberTypes) {
-                for (const memberTypeof of memberType.typeofs) {
-                    memberTypeofsSet.add(memberTypeof);
+                for (const memberJsType of memberType.jsTypes) {
+                    memberTypeofs.push(memberJsType.typeof);
+                    memberTypeofsSet.add(memberJsType.typeof);
                 }
             }
             if (memberTypeofsSet.size === memberTypes.length) {
                 return {
-                    memberValues: memberTypes.flatMap((memberType) => memberType.typeofs),
+                    memberValues: memberTypeofs,
                     kind: "Typeof",
                 };
             }
@@ -790,15 +783,15 @@ export var Discriminant;
         // 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();
+            const extrinsicMemberTypeAliasesSet = new Set();
             let extrinsicMemberTypeCount = 0;
             for (const memberType of memberTypes) {
                 if (termTypes(memberType).size > 0) {
                     continue;
                 }
                 extrinsicMemberTypeCount++;
-                if (memberType.alias.isJust()) {
-                    extrinsicMemberTypeNamesSet.add(memberType.alias.extract());
+                if (memberType.name.isJust()) {
+                    extrinsicMemberTypeAliasesSet.add(memberType.name.extract());
                 }
                 else {
                     break;
@@ -812,13 +805,13 @@ export var Discriminant;
                     if (memberTermTypes.size > 0) {
                         return {
                             kind: "Intrinsic",
-                            ownValues: [...memberTermTypes],
+                            values: [...memberTermTypes],
                         };
                     }
                     return {
                         kind: "Extrinsic",
-                        ownValues: extrinsicMemberTypeNamesSet.size === extrinsicMemberTypeCount
-                            ? [memberType.alias.unsafeCoerce()]
+                        values: extrinsicMemberTypeAliasesSet.size === extrinsicMemberTypeCount
+                            ? [memberType.name.unsafeCoerce()]
                             : [memberTypeI.toString()],
                     };
                 }),
@@ -829,7 +822,7 @@ export var Discriminant;
         {
             let memberValues;
             {
-                const memberTypeNames = memberTypes.map((memberType) => memberType.alias.orDefault(memberType.typeofs[0]));
+                const memberTypeNames = memberTypes.map((memberType) => memberType.name.orDefault(memberType.jsTypes[0].typeof));
                 const memberTypeNamesSet = new Set(memberTypeNames);
                 if (memberTypeNamesSet.size === memberTypeNames.length) {
                     memberValues = memberTypeNames;