@shaclmate/compiler 4.0.40 → 4.0.41

package/dist/generators/ts/_ObjectType/ObjectType_focusSparqlWherePatternsFunctionDeclaration.js

@@ -15,30 +15,11 @@ export function ObjectType_focusSparqlWherePatternsFunctionDeclaration() {
     const rdfTypeVariable = code `${this.reusables.imports.dataFactory}.variable!(\`\${${variables.variablePrefix}}RdfType\`)`;
     let patternsVariableDeclarationKeyword = "const";
     const statements = [];
-    for (const parentObjectType of this.parentObjectTypes) {
-        statements.push(code `\
-patterns = patterns.concat(${parentObjectType.alias.unsafeCoerce()}.focusSparqlWherePatterns(${{ filter: variables.filter, focusIdentifier: variables.focusIdentifier, ignoreRdfType: true, preferredLanguages: variables.preferredLanguages, variablePrefix: variables.variablePrefix }}));`);
-        patternsVariableDeclarationKeyword = "let";
-    }
-    if (this.fromRdfType.isJust()) {
-        const fromRdfTypeVariables = this.fromRdfTypeVariable
-            .toList()
-            .concat(this.descendantFromRdfTypeVariables);
+    this.fromRdfTypeVariable.ifJust((fromRdfTypeVariable) => {
         statements.push(code `const rdfTypeVariable = ${rdfTypeVariable};`, code `\
 if (!parameters?.ignoreRdfType) {
   patterns.push(
-    ${fromRdfTypeVariables.length > 1
-            ? code `\
-    {
-      type: "values" as const,
-      values: [${joinCode(fromRdfTypeVariables, { on: "," })}].map((identifier) => {
-        const valuePatternRow: ${this.reusables.imports.sparqljs}.ValuePatternRow = {};
-        valuePatternRow[\`?\${${variables.variablePrefix}}FromRdfType\`] = identifier as ${this.reusables.imports.NamedNode};
-        return valuePatternRow;
-      }),
-    },
-    ${this.reusables.snippets.sparqlInstancesOfPattern}({ rdfType: ${this.reusables.imports.dataFactory}.variable!(\`\${${variables.variablePrefix}}FromRdfType\`), subject: ${variables.focusIdentifier} }),`
-            : code `${this.reusables.snippets.sparqlInstancesOfPattern}({ rdfType: ${fromRdfTypeVariables[0]}, subject: ${variables.focusIdentifier} }),`}
+    ${code `${this.reusables.snippets.sparqlInstancesOfPattern}({ rdfType: ${fromRdfTypeVariable}, subject: ${variables.focusIdentifier} }),`}
     {
       triples: [
         {
@@ -70,7 +51,7 @@ if (!parameters?.ignoreRdfType) {
     }
   );
 }`);
-    }
+    });
     for (const property of this.properties) {
         if (property.recursive) {
             continue;

package/dist/generators/ts/_ObjectType/ObjectType_fromJsonFunctionDeclaration.js

@@ -1,4 +1,5 @@
 import { Maybe } from "purify-ts";
+import { invariant } from "ts-invariant";
 import { code, joinCode } from "../ts-poet-wrapper.js";
 export function ObjectType_fromJsonFunctionDeclaration() {
     if (!this.configuration.features.has("Object.fromJson")) {
@@ -7,37 +8,11 @@ export function ObjectType_fromJsonFunctionDeclaration() {
     const variables = {
         jsonObject: code `${this.configuration.syntheticNamePrefix}json`,
     };
-    const chains = [];
-    this.parentObjectTypes.forEach((parentObjectType, parentObjectTypeI) => {
-        chains.push({
-            expression: code `${parentObjectType.alias.unsafeCoerce()}.fromJson(${variables.jsonObject})`,
-            variable: `super${parentObjectTypeI}`,
-        });
-    });
     const propertyInitializers = this.properties.flatMap((property) => property.fromJsonInitializer({ variables }).toList());
-    if (propertyInitializers.length > 0) {
-        chains.push({
-            expression: code `${this.reusables.snippets.sequenceRecord}({ ${joinCode(propertyInitializers, { on: "," })} })`,
-            variable: "properties",
-        });
-    }
-    let returnExpression;
-    switch (chains.length) {
-        case 0:
-            returnExpression = code `create({})`;
-            break;
-        case 1:
-            returnExpression = code `(${chains[0].expression}).chain(create)`;
-            break;
-        default:
-            returnExpression = code `${chains
-                .reverse()
-                .reduce((acc, { expression, variable }) => code `(${expression}).chain(${variable} => ${acc})`, code `(create({ ${chains.map((chain) => `...${chain.variable}`).join(", ")} }))`)}`;
-            break;
-    }
+    invariant(propertyInitializers.length > 0);
     return Maybe.of(code `\
-export function fromJson(${variables.jsonObject}: ${this.jsonType().name}): ${this.reusables.imports.Either}<Error, ${this.expression}> {
-  return ${returnExpression};
+export function fromJson(${variables.jsonObject}: ${this.jsonType().expression}): ${this.reusables.imports.Either}<Error, ${this.expression}> {
+  return ${this.reusables.snippets.sequenceRecord}({ ${joinCode(propertyInitializers, { on: "," })} }).chain(create);
 }`);
 }
 //# sourceMappingURL=ObjectType_fromJsonFunctionDeclaration.js.map

package/dist/generators/ts/_ObjectType/ObjectType_fromRdfResourceFunctionDeclaration.js

@@ -1,4 +1,5 @@
 import { Maybe } from "purify-ts";
+import { invariant } from "ts-invariant";
 import { arrayOf, code, joinCode } from "../ts-poet-wrapper.js";
 export function ObjectType_fromRdfResourceFunctionDeclaration() {
     if (!this.configuration.features.has("Object.fromRdf")) {
@@ -22,17 +23,9 @@ export function ObjectType_fromRdfResourceFunctionDeclaration() {
         resource: variables.resource,
     };
     const chains = [];
-    const partials = [];
-    this.parentObjectTypes.forEach((parentObjectType, parentObjectTypeI) => {
-        chains.push({
-            expression: code `${parentObjectType.alias.unsafeCoerce()}._fromRdfResource(${variables.resource}, { ...${optionsVariable}, ignoreRdfType: true })`,
-            variable: `super${parentObjectTypeI}`,
-        });
-        partials.push(`super${parentObjectTypeI}`);
-    });
     this.fromRdfTypeVariable.ifJust((fromRdfTypeVariable) => {
         chains.push({
-            expression: code `!${variables.ignoreRdfType} ? ${this.reusables.snippets.ensureRdfResourceType}(${variables.resource}, ${arrayOf(fromRdfTypeVariable, ...this.descendantFromRdfTypeVariables)}, ${{ graph: variables.graph }}) : ${this.reusables.imports.Right}(true as const)`,
+            expression: code `!${variables.ignoreRdfType} ? ${this.reusables.snippets.ensureRdfResourceType}(${variables.resource}, ${arrayOf(fromRdfTypeVariable)}, ${{ graph: variables.graph }}) : ${this.reusables.imports.Right}(true as const)`,
             variable: `_rdfTypeCheck`,
         });
     });
@@ -41,38 +34,16 @@ export function ObjectType_fromRdfResourceFunctionDeclaration() {
         variables: propertyFromRdfResourceValuesExpressionVariable,
     })
         .toList());
-    if (Object.keys(propertyFromRdfResourceValuesInitializers).length > 0) {
-        chains.push({
-            expression: code `${this.reusables.snippets.sequenceRecord}({ ${joinCode(propertyFromRdfResourceValuesInitializers, { on: ", " })} })`,
-            variable: "properties",
-        });
-        partials.push("properties");
-    }
-    let partialsJoined;
-    switch (partials.length) {
-        case 0:
-            partialsJoined = code `{}`;
-            break;
-        case 1:
-            partialsJoined = code `${partials[0]}`;
-            break;
-        default:
-            partialsJoined = code `{ ${partials.map((partial) => `...${partial}`).join(", ")} }`;
-            break;
-    }
-    let returnExpression;
-    const resultExpression = code `create(${partialsJoined})`;
-    if (chains.length === 0) {
-        returnExpression = code `${this.reusables.imports.Right}(${resultExpression})`;
-    }
-    else {
-        returnExpression = code `${chains
-            .reverse()
-            .reduce((acc, { expression, variable }) => code `(${expression}).chain(${variable} => ${acc})`, code `(${resultExpression})`)}`;
-    }
+    invariant(Object.keys(propertyFromRdfResourceValuesInitializers).length > 0);
+    chains.push({
+        expression: code `${this.reusables.snippets.sequenceRecord}({ ${joinCode(propertyFromRdfResourceValuesInitializers, { on: ", " })} })`,
+        variable: "properties",
+    });
     return Maybe.of(code `\
 export const _fromRdfResource: ${this.reusables.snippets._FromRdfResourceFunction}<${this.expression}> = (${variables.resource}, ${optionsVariable}) => {
-  return ${returnExpression};
+  return ${chains
+        .reverse()
+        .reduce((acc, { expression, variable }) => code `(${expression}).chain(${variable} => ${acc})`, code `(create(properties))`)};
 }
 
 export const fromRdfResource = ${this.reusables.snippets.wrap_FromRdfResourceFunction}(_fromRdfResource);`);

package/dist/generators/ts/_ObjectType/ObjectType_hashFunctionDeclarations.js

@@ -4,41 +4,37 @@ export function ObjectType_hashFunctionDeclarations() {
     if (!this.configuration.features.has("Object.hash")) {
         return [];
     }
-    const hashOwnShaclPropertiesStatements = this.properties.flatMap((property) => property.kind === "Shacl"
-        ? property.hashStatements({
-            variables: {
-                hasher: hasherVariable,
-                value: property.accessExpression({
-                    variables: { object: this.thisVariable },
-                }),
-            },
-        })
-        : []);
-    const hashShaclPropertiesStatements = [];
-    const hashStatements = [];
-    for (const parentObjectType of this.parentObjectTypes) {
-        hashShaclPropertiesStatements.push(code `${parentObjectType.alias.unsafeCoerce()}.hashShaclProperties(${hasherVariable}, ${this.thisVariable});`);
-    }
-    hashStatements.push(code `${this.alias.unsafeCoerce()}.hashShaclProperties(${hasherVariable}, ${this.thisVariable});`);
-    hashShaclPropertiesStatements.push(...hashOwnShaclPropertiesStatements);
-    hashShaclPropertiesStatements.push(code `return ${hasherVariable};`);
-    hashStatements.push(...this.properties
-        .filter((property) => property.kind !== "Shacl")
-        .flatMap((property) => property.hashStatements({
-        variables: {
-            hasher: hasherVariable,
-            value: code `${property.accessExpression({ variables: { object: this.thisVariable } })}`,
-        },
-    })));
-    hashStatements.push(code `return ${hasherVariable};`);
     return [
         code `\
 export function hash<HasherT extends ${this.reusables.snippets.Hasher}>(${hasherVariable}: HasherT, ${this.thisVariable}: ${this.expression}): HasherT {
-  ${joinCode(hashStatements)}
+  ${joinCode([
+            code `${this.alias.unsafeCoerce()}.hashShaclProperties(${hasherVariable}, ${this.thisVariable});`,
+            ...this.properties
+                .filter((property) => property.kind !== "Shacl")
+                .flatMap((property) => property.hashStatements({
+                variables: {
+                    hasher: hasherVariable,
+                    value: code `${property.accessExpression({ variables: { object: this.thisVariable } })}`,
+                },
+            })),
+            code `return ${hasherVariable};`,
+        ])}
 }`,
         code `\
 export function hashShaclProperties<HasherT extends ${this.reusables.snippets.Hasher}>(${hasherVariable}: HasherT, ${this.thisVariable}: ${this.expression}): HasherT {
-  ${joinCode(hashShaclPropertiesStatements)}
+  ${joinCode([
+            ...this.properties.flatMap((property) => property.kind === "Shacl"
+                ? property.hashStatements({
+                    variables: {
+                        hasher: hasherVariable,
+                        value: property.accessExpression({
+                            variables: { object: this.thisVariable },
+                        }),
+                    },
+                })
+                : []),
+            code `return ${hasherVariable};`,
+        ])}
 }`,
     ];
 }

package/dist/generators/ts/_ObjectType/ObjectType_interfaceDeclaration.js

@@ -5,11 +5,7 @@ export function ObjectType_interfaceDeclaration() {
 ${this.comment
         .alt(this.label)
         .map(tsComment)
-        .orDefault("")}export interface ${this.alias.unsafeCoerce()}${this.parentObjectTypes.length > 0
-        ? ` extends ${this.parentObjectTypes
-            .map((parentObjectType) => parentObjectType.alias.unsafeCoerce())
-            .join(", ")}`
-        : ""} {
+        .orDefault("")}export interface ${this.alias.unsafeCoerce()} {
   ${joinCode(this.properties.map((property) => property.declaration), { on: "\n\n" })}
 }`;
 }

package/dist/generators/ts/_ObjectType/ObjectType_isTypeFunctionDeclaration.js

@@ -1,17 +1,20 @@
 import { Maybe } from "purify-ts";
-import { code } from "../ts-poet-wrapper.js";
+import { code, literalOf } from "../ts-poet-wrapper.js";
 export function ObjectType_isTypeFunctionDeclaration() {
     if (!this.configuration.features.has("Object.type")) {
         return Maybe.empty();
     }
+    if (this.synthetic) {
+        return Maybe.empty();
+    }
+    const alias = this.alias.extract();
+    const discriminantProperty = this.discriminantProperty.extract();
+    if (!alias || !discriminantProperty) {
+        return Maybe.empty();
+    }
     return Maybe.of(code `\
-export function is${this.alias.unsafeCoerce()}(object: ${this.configuration.syntheticNamePrefix}Object): object is ${this.alias.unsafeCoerce()} {
-  switch (object.${this._discriminantProperty.name}) {
-    ${this._discriminantProperty.type.descendantValues
-        .concat(this._discriminantProperty.type.ownValues)
-        .map((value) => `case "${value}":`)
-        .join("\n")} return true; default: return false;
-  }
+export function is${alias}(object: ${this.configuration.syntheticNamePrefix}Object): object is ${alias} {
+  return object.${discriminantProperty.name} === ${literalOf(discriminantProperty.value)};
 }`);
 }
 //# sourceMappingURL=ObjectType_isTypeFunctionDeclaration.js.map

package/dist/generators/ts/_ObjectType/ObjectType_jsonSchemaFunctionDeclaration.js

@@ -4,15 +4,9 @@ export function ObjectType_jsonSchemaFunctionDeclaration() {
     if (!this.configuration.features.has("Object.JSON.schema")) {
         return Maybe.empty();
     }
-    let properties = [];
-    for (const parentObjectType of this.parentObjectTypes) {
-        properties.push(code `...${parentObjectType.jsonSchema({ context: "type" })}.shape`);
-    }
-    if (this.properties.length > 0) {
-        properties = properties.concat(this.properties
-            .flatMap((property) => property.jsonSchema.toList())
-            .map(({ key, schema }) => code `"${key}": ${schema}`));
-    }
+    const properties = this.properties
+        .flatMap((property) => property.jsonSchema.toList())
+        .map(({ key, schema }) => code `"${key}": ${schema}`);
     const meta = {
     // id: this.name,
     };

package/dist/generators/ts/_ObjectType/ObjectType_jsonTypeAliasDeclaration.js

@@ -4,13 +4,6 @@ export function ObjectType_jsonTypeAliasDeclaration() {
     if (!this.configuration.features.has("Object.JSON.type")) {
         return Maybe.empty();
     }
-    const members = [];
-    if (this.properties.length > 0) {
-        members.push(code `{ ${joinCode(this.properties.flatMap((property) => property.jsonSignature.toList()), { on: ";" })} }`);
-    }
-    for (const parentObjectType of this.parentObjectTypes) {
-        members.push(code `${parentObjectType.jsonType().name}`);
-    }
-    return Maybe.of(code `export type Json = ${members.length > 0 ? joinCode(members, { on: " & " }) : "object"};`);
+    return Maybe.of(code `export type Json = { ${joinCode(this.properties.flatMap((property) => property.jsonSignature.toList()), { on: ";" })} }`);
 }
 //# sourceMappingURL=ObjectType_jsonTypeAliasDeclaration.js.map

package/dist/generators/ts/_ObjectType/ObjectType_jsonUiSchemaFunctionDeclaration.js

@@ -5,9 +5,7 @@ export function ObjectType_jsonUiSchemaFunctionDeclaration() {
         return Maybe.empty();
     }
     const variables = { scopePrefix: code `scopePrefix` };
-    const elements = this.parentObjectTypes
-        .map((parentObjectType) => code `${parentObjectType.alias.unsafeCoerce()}.Json.uiSchema({ scopePrefix })`)
-        .concat(this.properties.flatMap((property) => property.jsonUiSchemaElement({ variables }).toList()));
+    const elements = this.properties.flatMap((property) => property.jsonUiSchemaElement({ variables }).toList());
     return Maybe.of(code `\
 export function uiSchema(parameters?: { scopePrefix?: string }): any {
   const scopePrefix = parameters?.scopePrefix ?? "#";

package/dist/generators/ts/_ObjectType/ObjectType_schemaVariableStatement.js

@@ -5,10 +5,8 @@ export function ObjectType_schemaVariableStatement() {
         return Maybe.empty();
     }
     return Maybe.of(code `\
-export const schema = { properties: { ${joinCode(this.parentObjectTypes
-        .map((parentObjectType) => code `...${parentObjectType.alias.unsafeCoerce()}.schema.properties`)
-        .concat(this.properties.flatMap((property) => property.schema
+export const schema = { properties: { ${joinCode(this.properties.flatMap((property) => property.schema
         .toList()
-        .map((propertySchema) => code `${property.name}: ${propertySchema}`))), { on: ", " })} } } as const;`);
+        .map((propertySchema) => code `${property.name}: ${propertySchema}`)), { on: ", " })} } } as const;`);
 }
 //# sourceMappingURL=ObjectType_schemaVariableStatement.js.map

package/dist/generators/ts/_ObjectType/ObjectType_toJsonFunctionDeclaration.js

@@ -4,38 +4,17 @@ export function ObjectType_toJsonFunctionDeclaration() {
     if (!this.configuration.features.has("Object.toJson")) {
         return Maybe.empty();
     }
-    const jsonObjectMembers = [];
-    for (const parentObjectType of this.parentObjectTypes) {
-        jsonObjectMembers.push(code `...${parentObjectType.alias.unsafeCoerce()}.toJson(${this.thisVariable})`);
-    }
-    if (this.properties.length > 0) {
-        jsonObjectMembers.push(...this.properties.flatMap((property) => property
-            .toJsonInitializer({
-            variables: {
-                value: property.accessExpression({
-                    variables: { object: this.thisVariable },
-                }),
-            },
-        })
-            .toList()));
-    }
-    const returnType = this.jsonType().name;
-    // 20241220: don't add @type until we're doing JSON-LD
-    // switch (this.toRdfTypes.length) {
-    //   case 0:
-    //     break;
-    //   case 1:
-    //     jsonObjectMembers.push(`"@type": "${this.toRdfTypes[0].value}"`);
-    //     break;
-    //   default:
-    //     jsonObjectMembers.push(
-    //       `"@type": ${JSON.stringify(this.toRdfTypes.map((rdfType) => rdfType.value))}`,
-    //     );
-    //     break;
-    // }
     return Maybe.of(code `\
-export function toJson(${this.thisVariable}: ${this.expression}): ${returnType} {
-  return JSON.parse(JSON.stringify({ ${joinCode(jsonObjectMembers, { on: "," })} } satisfies ${this.jsonType().name}));
+export function toJson(${this.thisVariable}: ${this.expression}): ${this.jsonType().expression} {
+  return JSON.parse(JSON.stringify({ ${joinCode(this.properties.flatMap((property) => property
+        .toJsonInitializer({
+        variables: {
+            value: property.accessExpression({
+                variables: { object: this.thisVariable },
+            }),
+        },
+    })
+        .toList()), { on: "," })} } satisfies ${this.jsonType().expression}));
 }`);
 }
 //# sourceMappingURL=ObjectType_toJsonFunctionDeclaration.js.map

package/dist/generators/ts/_ObjectType/ObjectType_toRdfResourceFunctionDeclaration.js

@@ -5,7 +5,7 @@ export function ObjectType_toRdfResourceFunctionDeclaration() {
     if (!this.configuration.features.has("Object.toRdf")) {
         return Maybe.empty();
     }
-    const statements = this.parentObjectTypes.map((parentObjectType) => code `${parentObjectType.alias.unsafeCoerce()}._toRdfResource({ ...parameters, ignoreRdfType: true });`);
+    const statements = [];
     if (this.toRdfTypes.length > 0) {
         statements.push(code `if (!${variables.ignoreRdfType}) { ${joinCode(this.toRdfTypes.map((toRdfType) => code `${variables.resource}.add(${this.rdfjsTermExpression(rdf.type)}, ${this.reusables.imports.dataFactory}.namedNode("${toRdfType.value}"), ${variables.graph});`), { on: " " })} }`);
     }

package/dist/generators/ts/_ObjectType/ObjectType_toStringFunctionDeclarations.js

@@ -3,13 +3,7 @@ export function ObjectType_toStringFunctionDeclarations() {
     if (!this.configuration.features.has("Object.toString")) {
         return [];
     }
-    let propertiesToStringInitializers = [];
-    if (this.parentObjectTypes.length > 0) {
-        for (const parentObjectType of this.parentObjectTypes) {
-            propertiesToStringInitializers.push(code `...${parentObjectType.alias.unsafeCoerce()}._propertiesToStrings(${this.thisVariable})`);
-        }
-    }
-    propertiesToStringInitializers = propertiesToStringInitializers.concat(this.properties.flatMap((property) => property
+    const propertiesToStringsReturnExpression = code `${this.reusables.snippets.compactRecord}({${joinCode(this.properties.flatMap((property) => property
         .toStringInitializer({
         variables: {
             value: property.accessExpression({
@@ -17,8 +11,7 @@ export function ObjectType_toStringFunctionDeclarations() {
             }),
         },
     })
-        .toList()));
-    const propertiesToStringsReturnExpression = code `${this.reusables.snippets.compactRecord}({${joinCode(propertiesToStringInitializers, { on: "," })}})`;
+        .toList()), { on: "," })}})`;
     const toStringReturnExpression = (propertiesToStrings) => code `\`${this.alias.unsafeCoerce()}(\${JSON.stringify(${propertiesToStrings})})\``;
     const syntheticNamePrefix = this.configuration.syntheticNamePrefix;
     return [

package/dist/generators/ts/_ObjectType/ShaclProperty.js

@@ -34,16 +34,16 @@ export class ShaclProperty extends AbstractProperty {
             return Maybe.of(code `readonly ${this.name}: ${this.type.expression};`);
         }
         let hasQuestionToken = false;
-        const typeNames = [];
+        const typeExpressions = [];
         for (const type of conversionFunction.sourceTypes) {
-            if (type.typeof === "undefined") {
+            if (type.jsType.typeof === "undefined") {
                 hasQuestionToken = true;
             }
             else {
-                typeNames.push(code `${type.expression}`);
+                typeExpressions.push(code `${type.expression}`);
             }
         }
-        return Maybe.of(code `readonly ${this.name}${hasQuestionToken ? "?" : ""}: ${joinCode(typeNames, { on: "|" })};`);
+        return Maybe.of(code `readonly ${this.name}${hasQuestionToken ? "?" : ""}: ${joinCode(typeExpressions, { on: "|" })};`);
     }
     get declaration() {
         const lhs = [];
@@ -71,7 +71,7 @@ export class ShaclProperty extends AbstractProperty {
             description: this.comment.map(JSON.stringify),
             name: this.name,
             resolve: code `(source, ${argsVariable}) => ${this.type.graphqlResolveExpression({ variables: { args: argsVariable, value: code `source.${this.name}` } })}`,
-            type: this.type.graphqlType.name,
+            type: this.type.graphqlType.expression,
         });
     }
     get jsonSchema() {
@@ -95,7 +95,7 @@ export class ShaclProperty extends AbstractProperty {
     }
     get jsonSignature() {
         const typeJsonType = this.type.jsonType();
-        return Maybe.of(code `${!this.mutable ? "readonly " : ""}${this.name}${typeJsonType.optional ? "?" : ""}: ${typeJsonType.requiredName}`);
+        return Maybe.of(code `${!this.mutable ? "readonly " : ""}${this.name}${typeJsonType.optional ? "?" : ""}: ${typeJsonType.requiredExpression}`);
     }
     get schemaInitializers() {
         const initializers = super.schemaInitializers.concat();

package/dist/generators/ts/_ObjectType/identifierTypeDeclarations.js

@@ -1,19 +1,8 @@
-import { codeEquals } from "../codeEquals.js";
 import { code } from "../ts-poet-wrapper.js";
 export function identifierTypeDeclarations() {
     if (!this.configuration.features.has("Object.type")) {
         return [];
     }
-    const ancestorObjectTypeWithSameIdentifierType = this.ancestorObjectTypes.find((ancestorObjectType) => ancestorObjectType.identifierType.kind === this.identifierType.kind &&
-        codeEquals(ancestorObjectType.identifierType.expression, this.identifierType.expression));
-    if (ancestorObjectTypeWithSameIdentifierType) {
-        // This object type's identifier type has the same identifier type as an ancestor object type,
-        // so just reuse the latter.
-        return [
-            code `export type Identifier = ${ancestorObjectTypeWithSameIdentifierType.identifierTypeAlias};`,
-            code `export const Identifier = ${ancestorObjectTypeWithSameIdentifierType.identifierTypeAlias};`,
-        ];
-    }
     // Bespoke identifier type and associated functions
     return [
         code `export type Identifier = ${this.identifierType.expression};`,

package/dist/generators/ts/_snippets/snippets_convertToArraySet.d.ts

@@ -0,0 +1,3 @@
+import type { SnippetFactory } from "../SnippetFactory.js";
+export declare const snippets_convertToArraySet: SnippetFactory;
+//# sourceMappingURL=snippets_convertToArraySet.d.ts.map

package/dist/generators/ts/_snippets/snippets_convertToArraySet.js

@@ -0,0 +1,8 @@
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+export const snippets_convertToArraySet = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}convertToArraySet`, code `\
+function ${syntheticNamePrefix}convertToArraySet<ItemSourceT, ItemTargetT, Readonly extends boolean>(convertToItem: ${snippets.ConversionFunction}<ItemSourceT, ItemTargetT>, _readonly: Readonly) {
+  type ItemTargetArrayT = Readonly extends true ? ReadonlyArray<ItemTargetT> : Array<ItemTargetT>;
+  return (value: readonly ItemSourceT[] | undefined): ${imports.Either}<Error, ItemTargetArrayT> => 
+    (typeof value === "undefined" ? ${imports.Either}.of([]) : ${imports.Either}.sequence(value.map(convertToItem))) as ${imports.Either}<Error, ItemTargetArrayT>;
+}`);
+//# sourceMappingURL=snippets_convertToArraySet.js.map

package/dist/generators/ts/_snippets/snippets_convertToList.d.ts

@@ -0,0 +1,3 @@
+import type { SnippetFactory } from "../SnippetFactory.js";
+export declare const snippets_convertToList: SnippetFactory;
+//# sourceMappingURL=snippets_convertToList.d.ts.map

package/dist/generators/ts/_snippets/snippets_convertToList.js

@@ -0,0 +1,7 @@
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+export const snippets_convertToList = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}convertToList`, code `\
+function ${syntheticNamePrefix}convertToList<ItemSourceT, ItemTargetT, Readonly extends boolean>(convertToItem: ${snippets.ConversionFunction}<ItemSourceT, ItemTargetT>, _readonly: Readonly) {
+  type ItemTargetArrayT = Readonly extends true ? ReadonlyArray<ItemTargetT> : Array<ItemTargetT>;
+  return (value: readonly ItemSourceT[]): ${imports.Either}<Error, ItemTargetArrayT> => ${imports.Either}.sequence(value.map(convertToItem)) as ${imports.Either}<Error, ItemTargetArrayT>;
+}`);
+//# sourceMappingURL=snippets_convertToList.js.map

package/dist/generators/ts/_snippets/snippets_convertToScalarSet.d.ts

@@ -0,0 +1,3 @@
+import type { SnippetFactory } from "../SnippetFactory.js";
+export declare const snippets_convertToScalarSet: SnippetFactory;
+//# sourceMappingURL=snippets_convertToScalarSet.d.ts.map

package/dist/generators/ts/_snippets/snippets_convertToScalarSet.js

@@ -0,0 +1,15 @@
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+export const snippets_convertToScalarSet = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}convertToScalarSet`, code `\
+function ${syntheticNamePrefix}convertToScalarSet<ItemSourceT, ItemTargetT, Readonly extends boolean>(convertToItem: ${snippets.ConversionFunction}<ItemSourceT, ItemTargetT>, _readonly: Readonly) {
+  type ItemTargetArrayT = Readonly extends true ? ReadonlyArray<ItemTargetT> : Array<ItemTargetT>;
+  return (value: ItemSourceT | readonly ItemSourceT[] | undefined): ${imports.Either}<Error, ItemTargetArrayT> => {
+    if (typeof value === "undefined") {
+      return ${imports.Either}.of<Error, ItemTargetArrayT>([] as unknown as ItemTargetArrayT);
+    }
+    if (Array.isArray(value)) {
+      return ${imports.Either}.sequence(value.map(convertToItem)) as ${imports.Either}<Error, ItemTargetArrayT>;
+    }
+    return convertToItem(value as ItemSourceT).map(value => [value]) as ${imports.Either}<Error, ItemTargetArrayT>;
+  };
+}`);
+//# sourceMappingURL=snippets_convertToScalarSet.js.map