@shaclmate/compiler 2.0.12 → 2.0.14

package/generators/ts/_ObjectType/TypeDiscriminatorProperty.d.ts

@@ -1,29 +1,47 @@
 import { Maybe } from "purify-ts";
 import type { GetAccessorDeclarationStructure, OptionalKind, PropertyDeclarationStructure, PropertySignatureStructure } from "ts-morph";
+import type { TsObjectDeclarationType } from "../../../enums/index.js";
 import { Property } from "./Property.js";
 export declare class TypeDiscriminatorProperty extends Property<TypeDiscriminatorProperty.Type> {
     readonly equalsFunction = "purifyHelpers.Equatable.strictEquals";
+    readonly mutable = false;
     readonly value: string;
     private readonly abstract;
+    private readonly objectTypeDeclarationType;
     private readonly override;
-    constructor({ abstract, override, value, ...superParameters }: {
+    constructor({ abstract, objectTypeDeclarationType, override, type, value, ...superParameters }: {
         abstract: boolean;
+        objectTypeDeclarationType: TsObjectDeclarationType;
         override: boolean;
+        type: TypeDiscriminatorProperty.Type;
         value: string;
     } & ConstructorParameters<typeof Property>[0]);
-    get classConstructorParametersPropertySignature(): Maybe<OptionalKind<PropertySignatureStructure>>;
     get classGetAccessorDeclaration(): Maybe<OptionalKind<GetAccessorDeclarationStructure>>;
-    get classPropertyDeclaration(): OptionalKind<PropertyDeclarationStructure>;
+    get classPropertyDeclaration(): Maybe<OptionalKind<PropertyDeclarationStructure>>;
+    get constructorParametersPropertySignature(): Maybe<OptionalKind<PropertySignatureStructure>>;
     get interfacePropertySignature(): OptionalKind<PropertySignatureStructure>;
+    get jsonPropertySignature(): OptionalKind<PropertySignatureStructure>;
     classConstructorStatements(): readonly string[];
+    fromJsonStatements(): readonly string[];
     fromRdfStatements(): readonly string[];
     hashStatements(): readonly string[];
-    sparqlGraphPatternExpression(): Maybe<string>;
+    interfaceConstructorStatements(): readonly string[];
+    jsonUiSchemaElement({ variables, }: Parameters<Property<TypeDiscriminatorProperty.Type>["jsonUiSchemaElement"]>[0]): Maybe<string>;
+    jsonZodSchema({ variables, }: Parameters<Property<TypeDiscriminatorProperty.Type>["jsonZodSchema"]>[0]): ReturnType<Property<TypeDiscriminatorProperty.Type>["jsonZodSchema"]>;
+    sparqlConstructTemplateTriples(): readonly string[];
+    sparqlWherePatterns(): readonly string[];
+    toJsonObjectMember({ variables, }: Parameters<Property<TypeDiscriminatorProperty.Type>["toJsonObjectMember"]>[0]): string;
     toRdfStatements(): readonly string[];
 }
 export declare namespace TypeDiscriminatorProperty {
-    interface Type {
-        readonly name: string;
+    class Type {
+        readonly mutable: boolean;
+        readonly values: readonly string[];
+        constructor({ mutable, values, }: {
+            mutable: boolean;
+            values: readonly string[];
+        });
+        get name(): string;
     }
 }
 //# sourceMappingURL=TypeDiscriminatorProperty.d.ts.map

package/generators/ts/_ObjectType/TypeDiscriminatorProperty.js

@@ -1,30 +1,52 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
 import { Maybe } from "purify-ts";
+import { invariant } from "ts-invariant";
+import { Memoize } from "typescript-memoize";
 import { Property } from "./Property.js";
 export class TypeDiscriminatorProperty extends Property {
-    constructor({ abstract, override, value, ...superParameters }) {
-        super(superParameters);
+    constructor({ abstract, objectTypeDeclarationType, override, type, value, ...superParameters }) {
+        super({ ...superParameters, type });
         this.equalsFunction = "purifyHelpers.Equatable.strictEquals";
+        this.mutable = false;
+        invariant(this.visibility === "public");
         this.abstract = abstract;
+        this.objectTypeDeclarationType = objectTypeDeclarationType;
         this.override = override;
         this.value = value;
     }
-    get classConstructorParametersPropertySignature() {
-        return Maybe.empty();
-    }
     get classGetAccessorDeclaration() {
         return Maybe.empty();
     }
     get classPropertyDeclaration() {
-        return {
-            isAbstract: this.abstract,
-            hasOverrideKeyword: this.override,
+        return Maybe.of({
+            // Work around a ts-morph bug that puts the override keyword before the abstract keyword
+            isAbstract: this.abstract && this.override ? undefined : this.abstract,
+            hasOverrideKeyword: this.abstract && this.override ? undefined : this.override,
             initializer: !this.abstract ? `"${this.value}"` : undefined,
+            isReadonly: true,
+            leadingTrivia: this.abstract && this.override ? "abstract override " : undefined,
+            name: this.name,
+            type: !this.abstract && this.type.name === `"${this.value}"`
+                ? undefined
+                : this.type.name,
+        });
+    }
+    get constructorParametersPropertySignature() {
+        return Maybe.empty();
+    }
+    get interfacePropertySignature() {
+        return {
             isReadonly: true,
             name: this.name,
             type: this.type.name,
         };
     }
-    get interfacePropertySignature() {
+    get jsonPropertySignature() {
         return {
             isReadonly: true,
             name: this.name,
@@ -34,20 +56,60 @@ export class TypeDiscriminatorProperty extends Property {
     classConstructorStatements() {
         return [];
     }
+    fromJsonStatements() {
+        return this.fromRdfStatements();
+    }
     fromRdfStatements() {
-        return !this.abstract &&
-            this.configuration.objectTypeDeclarationType === "interface"
+        return !this.abstract && this.objectTypeDeclarationType === "interface"
             ? [`const ${this.name} = "${this.value}" as const`]
             : [];
     }
     hashStatements() {
         return [];
     }
-    sparqlGraphPatternExpression() {
-        return Maybe.empty();
+    interfaceConstructorStatements() {
+        return !this.abstract
+            ? [`const ${this.name} = "${this.value}" as const`]
+            : [];
+    }
+    jsonUiSchemaElement({ variables, }) {
+        const scope = `\`\${${variables.scopePrefix}}/properties/${this.name}\``;
+        return Maybe.of(`{ rule: { condition: { schema: { const: "${this.value}" }, scope: ${scope} }, effect: "HIDE" }, scope: ${scope}, type: "Control" }`);
+    }
+    jsonZodSchema({ variables, }) {
+        return {
+            key: this.name,
+            schema: this.type.values.length > 1
+                ? `${variables.zod}.enum(${JSON.stringify(this.type.values)})`
+                : `${variables.zod}.literal("${this.type.values[0]}")`,
+        };
+    }
+    sparqlConstructTemplateTriples() {
+        return [];
+    }
+    sparqlWherePatterns() {
+        return [];
+    }
+    toJsonObjectMember({ variables, }) {
+        return `${this.name}: ${variables.value}`;
     }
     toRdfStatements() {
         return [];
     }
 }
+(function (TypeDiscriminatorProperty) {
+    class Type {
+        constructor({ mutable, values, }) {
+            this.mutable = mutable;
+            this.values = values;
+        }
+        get name() {
+            return this.values.map((name) => `"${name}"`).join(" | ");
+        }
+    }
+    __decorate([
+        Memoize()
+    ], Type.prototype, "name", null);
+    TypeDiscriminatorProperty.Type = Type;
+})(TypeDiscriminatorProperty || (TypeDiscriminatorProperty = {}));
 //# sourceMappingURL=TypeDiscriminatorProperty.js.map

package/generators/ts/_ObjectType/classDeclaration.d.ts

@@ -1,4 +1,5 @@
+import { Maybe } from "purify-ts";
 import { type ClassDeclarationStructure } from "ts-morph";
 import type { ObjectType } from "../ObjectType.js";
-export declare function classDeclaration(this: ObjectType): ClassDeclarationStructure;
+export declare function classDeclaration(this: ObjectType): Maybe<ClassDeclarationStructure>;
 //# sourceMappingURL=classDeclaration.d.ts.map

package/generators/ts/_ObjectType/classDeclaration.js

@@ -1,154 +1,122 @@
-import { rdf } from "@tpluscode/rdf-ns-builders";
+import { Maybe } from "purify-ts";
 import { StructureKind, } from "ts-morph";
-import { hasherTypeConstraint } from "./hashFunctionDeclaration.js";
+import { tsComment } from "../tsComment.js";
+import { equalsFunctionOrMethodDeclaration } from "./equalsFunctionOrMethodDeclaration.js";
+import { hashFunctionOrMethodDeclaration } from "./hashFunctionOrMethodDeclaration.js";
+import { toJsonFunctionOrMethodDeclaration } from "./toJsonFunctionOrMethodDeclaration.js";
+import { toRdfFunctionOrMethodDeclaration } from "./toRdfFunctionOrMethodDeclaration.js";
 function constructorDeclaration() {
-    if (this.properties.length === 0) {
-        return null;
+    const parametersPropertySignatures = this.properties.flatMap((property) => property.constructorParametersPropertySignature
+        .map((propertySignature) => `readonly ${propertySignature.name}${propertySignature.hasQuestionToken ? "?" : ""}: ${propertySignature.type}`)
+        .toList());
+    let parametersType;
+    if (parametersPropertySignatures.length > 0) {
+        parametersType = `{ ${parametersPropertySignatures.join(", ")} }`;
+    }
+    else {
+        parametersType = "";
     }
-    const statements = [];
     if (this.parentObjectTypes.length > 0) {
-        statements.push("super(parameters);");
+        // Pass up parameters
+        parametersType = `${parametersType}${parametersType.length > 0 ? " & " : ""}ConstructorParameters<typeof ${this.parentObjectTypes[0].name}>[0]`;
     }
-    for (const property of this.properties) {
-        for (const statement of property.classConstructorStatements({
-            variables: { parameter: `parameters.${property.name}` },
-        })) {
-            statements.push(statement);
-        }
+    if (parametersType.length === 0) {
+        parametersType = "object";
     }
-    const constructorParameterPropertySignatures = this.properties.flatMap((property) => property.classConstructorParametersPropertySignature
-        .map((propertySignature) => `readonly ${propertySignature.name}${propertySignature.hasQuestionToken ? "?" : ""}: ${propertySignature.type}`)
-        .toList());
-    if (constructorParameterPropertySignatures.length === 0) {
-        return null;
-    }
-    let constructorParametersType = `{ ${constructorParameterPropertySignatures.join(", ")} }`;
+    const statements = [];
     if (this.parentObjectTypes.length > 0) {
-        constructorParametersType = `${constructorParametersType} & ConstructorParameters<typeof ${this.parentObjectTypes[0].name}>[0]`;
+        // An ancestor object type may be extern so we always have a constructor and always pass up parameters instead
+        // of trying to sense whether we need to or not.
+        statements.push("super(parameters);");
     }
+    const propertyStatements = this.properties.flatMap((property) => property.classConstructorStatements({
+        variables: { parameter: `parameters.${property.name}` },
+    }));
+    statements.push(...propertyStatements);
     return {
+        leadingTrivia: propertyStatements.length === 0
+            ? "// biome-ignore lint/complexity/noUselessConstructor: Always have a constructor\n"
+            : undefined,
         parameters: [
             {
-                name: "parameters",
-                type: constructorParametersType,
+                name: statements.length > 0 ? "parameters" : "_parameters",
+                type: parametersType,
             },
         ],
         statements,
     };
 }
 export function classDeclaration() {
-    this.ensureAtMostOneSuperObjectType();
-    const constructorDeclaration_ = constructorDeclaration.bind(this)();
-    const methods = [];
-    if (this.configuration.features.has("equals")) {
-        methods.push(equalsMethodDeclaration.bind(this)());
-    }
-    if (this.configuration.features.has("hash")) {
-        methods.push(hashMethodDeclaration.bind(this)());
+    if (this.declarationType !== "class") {
+        return Maybe.empty();
     }
-    if (this.configuration.features.has("toRdf")) {
-        methods.push(toRdfMethodDeclaration.bind(this)());
+    if (this.extern) {
+        return Maybe.empty();
     }
+    this.ensureAtMostOneSuperObjectType();
     const getAccessors = [];
     const properties = [];
     for (const property of this.properties) {
-        properties.push(property.classPropertyDeclaration);
+        property.classPropertyDeclaration.ifJust((propertyDeclaration) => properties.push(propertyDeclaration));
         property.classGetAccessorDeclaration.ifJust((getAccessor) => getAccessors.push(getAccessor));
     }
-    return {
-        ctors: constructorDeclaration_ !== null ? [constructorDeclaration_] : undefined,
+    return Maybe.of({
+        ctors: [constructorDeclaration.bind(this)()],
         extends: this.parentObjectTypes.length > 0
             ? this.parentObjectTypes[0].name
             : undefined,
         getAccessors,
         isAbstract: this.abstract,
+        isExported: this.export,
         kind: StructureKind.Class,
-        isExported: this.export_,
-        methods,
+        leadingTrivia: this.comment.alt(this.label).map(tsComment).extract(),
+        methods: [
+            ...equalsMethodDeclaration.bind(this)().toList(),
+            ...hashMethodDeclaration.bind(this)().toList(),
+            ...toJsonMethodDeclaration.bind(this)().toList(),
+            ...toRdfMethodDeclaration.bind(this)().toList(),
+            ...toStringMethodDeclaration.bind(this)().toList(),
+        ],
         name: this.name,
         properties,
-    };
+    });
 }
 function equalsMethodDeclaration() {
-    let expression = `purifyHelpers.Equatable.objectEquals(this, other, { ${this.properties
-        .map((property) => `${property.name}: ${property.equalsFunction}`)
-        .join()} })`;
-    if (this.parentObjectTypes.length > 0) {
-        expression = `super.equals(other).chain(() => ${expression})`;
-    }
-    return {
-        hasOverrideKeyword: this.parentObjectTypes.length > 0,
-        name: "equals",
-        parameters: [
-            {
-                name: "other",
-                type: this.name,
-            },
-        ],
-        statements: [`return ${expression};`],
-        returnType: "purifyHelpers.Equatable.EqualsResult",
-    };
+    return equalsFunctionOrMethodDeclaration.bind(this)();
 }
 function hashMethodDeclaration() {
-    return {
-        hasOverrideKeyword: this.parentObjectTypes.length > 0,
+    return hashFunctionOrMethodDeclaration
+        .bind(this)()
+        .map((hashFunctionOrMethodDeclaration) => ({
+        ...hashFunctionOrMethodDeclaration,
         name: "hash",
-        parameters: [
-            {
-                name: "hasher",
-                type: "HasherT",
-            },
-        ],
-        returnType: "HasherT",
-        statements: [`return ${this.name}.${this.hashFunctionName}(this, hasher);`],
-        typeParameters: [
-            {
-                name: "HasherT",
-                constraint: hasherTypeConstraint,
-            },
-        ],
-    };
+    }));
+}
+function toJsonMethodDeclaration() {
+    return toJsonFunctionOrMethodDeclaration
+        .bind(this)()
+        .map((toJsonFunctionOrMethodDeclaration) => ({
+        ...toJsonFunctionOrMethodDeclaration,
+        hasOverrideKeyword: this.parentObjectTypes.length > 0,
+    }));
 }
 function toRdfMethodDeclaration() {
-    const variables = {
-        ignoreRdfType: "ignoreRdfType",
-        mutateGraph: "mutateGraph",
-        resource: "resource",
-        resourceSet: "resourceSet",
-    };
-    let usedIgnoreRdfTypeVariable = false;
-    const statements = [];
-    if (this.parentObjectTypes.length > 0) {
-        statements.push(`const ${variables.resource} = super.toRdf({ ${variables.mutateGraph}, ${variables.ignoreRdfType}: true, ${variables.resourceSet} });`);
-        usedIgnoreRdfTypeVariable = true;
-    }
-    else if (this.identifierType.isNamedNodeKind) {
-        statements.push(`const ${variables.resource} = ${variables.resourceSet}.mutableNamedResource({ identifier: this.${this.configuration.objectTypeIdentifierPropertyName}, ${variables.mutateGraph} });`);
-    }
-    else {
-        statements.push(`const ${variables.resource} = ${variables.resourceSet}.mutableResource({ identifier: this.${this.configuration.objectTypeIdentifierPropertyName}, ${variables.mutateGraph} });`);
-    }
-    this.rdfType.ifJust((rdfType) => {
-        statements.push(`if (!${variables.ignoreRdfType}) { ${variables.resource}.add(${variables.resource}.dataFactory.namedNode("${rdf.type.value}"), ${variables.resource}.dataFactory.namedNode("${rdfType.value}")); }`);
-        usedIgnoreRdfTypeVariable = true;
-    });
-    for (const property of this.properties) {
-        statements.push(...property.toRdfStatements({
-            variables: { ...variables, value: `this.${property.name}` },
-        }));
+    return toRdfFunctionOrMethodDeclaration
+        .bind(this)()
+        .map((toRdfFunctionOrMethodDeclaration) => ({
+        ...toRdfFunctionOrMethodDeclaration,
+        hasOverrideKeyword: this.parentObjectTypes.length > 0,
+    }));
+}
+function toStringMethodDeclaration() {
+    if (!this.features.has("toJson")) {
+        return Maybe.empty();
     }
-    statements.push(`return ${variables.resource};`);
-    return {
+    return Maybe.of({
         hasOverrideKeyword: this.parentObjectTypes.length > 0,
-        name: "toRdf",
-        parameters: [
-            {
-                name: `{ ${usedIgnoreRdfTypeVariable ? `${variables.ignoreRdfType},` : ""} ${variables.mutateGraph}, ${variables.resourceSet} }`,
-                type: `{ ${variables.ignoreRdfType}?: boolean; ${variables.mutateGraph}: rdfjsResource.MutableResource.MutateGraph, ${variables.resourceSet}: rdfjsResource.MutableResourceSet }`,
-            },
-        ],
-        returnType: this.rdfjsResourceType({ mutable: true }).name,
-        statements,
-    };
+        name: "toString",
+        returnType: "string",
+        statements: ["return JSON.stringify(this.toJson());"],
+    });
 }
 //# sourceMappingURL=classDeclaration.js.map

package/generators/ts/_ObjectType/createFunctionDeclaration.d.ts

@@ -0,0 +1,5 @@
+import { Maybe } from "purify-ts";
+import { type FunctionDeclarationStructure } from "ts-morph";
+import type { ObjectType } from "../ObjectType.js";
+export declare function createFunctionDeclaration(this: ObjectType): Maybe<FunctionDeclarationStructure>;
+//# sourceMappingURL=createFunctionDeclaration.d.ts.map

package/generators/ts/_ObjectType/createFunctionDeclaration.js

@@ -0,0 +1,60 @@
+import { Maybe } from "purify-ts";
+import { invariant } from "ts-invariant";
+import { StructureKind } from "ts-morph";
+export function createFunctionDeclaration() {
+    if (!this.features.has("create")) {
+        return Maybe.empty();
+    }
+    if (this.declarationType !== "interface") {
+        return Maybe.empty();
+    }
+    if (this.extern) {
+        return Maybe.empty();
+    }
+    const parametersPropertySignatures = this.properties.flatMap((property) => property.constructorParametersPropertySignature
+        .map((propertySignature) => `readonly ${propertySignature.name}${propertySignature.hasQuestionToken ? "?" : ""}: ${propertySignature.type}`)
+        .toList());
+    // Should always have at least an identifier
+    invariant(parametersPropertySignatures.length > 0);
+    const parametersType = [`{ ${parametersPropertySignatures.join(", ")} }`]
+        .concat(this.parentObjectTypes.map((parentObjectType) => `Parameters<typeof ${parentObjectType.name}.create>[0]`))
+        .join(" & ");
+    const propertyInitializers = [];
+    const omitPropertyNames = [];
+    const propertyStatements = [];
+    for (const parentObjectType of this.parentObjectTypes) {
+        propertyInitializers.push(`...${parentObjectType.name}.create(parameters)`);
+    }
+    for (const property of this.properties) {
+        const thisPropertyStatements = property.interfaceConstructorStatements({
+            variables: { parameter: `parameters.${property.name}` },
+        });
+        if (thisPropertyStatements.length > 0) {
+            propertyInitializers.push(property.name);
+            propertyStatements.push(...thisPropertyStatements);
+        }
+        else {
+            omitPropertyNames.push(property.name);
+        }
+    }
+    invariant(propertyInitializers.length > 0);
+    invariant(propertyStatements.length > 0);
+    return Maybe.of({
+        isExported: true,
+        kind: StructureKind.Function,
+        name: "create",
+        parameters: [
+            {
+                name: "parameters",
+                type: parametersType,
+            },
+        ],
+        returnType: omitPropertyNames.length === 0
+            ? this.name
+            : `Omit<${this.name}, ${omitPropertyNames.map((omitPropertyName) => `"${omitPropertyName}"`).join(" | ")}>`,
+        statements: propertyStatements.concat([
+            `return { ${propertyInitializers.join(", ")} }`,
+        ]),
+    });
+}
+//# sourceMappingURL=createFunctionDeclaration.js.map

package/generators/ts/_ObjectType/equalsFunctionDeclaration.d.ts

@@ -1,4 +1,5 @@
+import { Maybe } from "purify-ts";
 import { type FunctionDeclarationStructure } from "ts-morph";
 import type { ObjectType } from "../ObjectType.js";
-export declare function equalsFunctionDeclaration(this: ObjectType): FunctionDeclarationStructure;
+export declare function equalsFunctionDeclaration(this: ObjectType): Maybe<FunctionDeclarationStructure>;
 //# sourceMappingURL=equalsFunctionDeclaration.d.ts.map

package/generators/ts/_ObjectType/equalsFunctionDeclaration.js

@@ -1,27 +1,19 @@
+import { Maybe } from "purify-ts";
 import { StructureKind } from "ts-morph";
+import { equalsFunctionOrMethodDeclaration } from "./equalsFunctionOrMethodDeclaration.js";
 export function equalsFunctionDeclaration() {
-    let expression = `purifyHelpers.Equatable.objectEquals(left, right, { ${this.properties
-        .map((property) => `${property.name}: ${property.equalsFunction}`)
-        .join()} })`;
-    for (const parentObjectType of this.parentObjectTypes) {
-        expression = `${parentObjectType.name}.equals(left, right).chain(() => ${expression})`;
+    if (this.declarationType !== "interface") {
+        return Maybe.empty();
     }
-    return {
+    if (this.extern) {
+        return Maybe.empty();
+    }
+    return equalsFunctionOrMethodDeclaration
+        .bind(this)()
+        .map((equalsFunctionOrMethodDeclaration) => ({
+        ...equalsFunctionOrMethodDeclaration,
         isExported: true,
         kind: StructureKind.Function,
-        name: "equals",
-        parameters: [
-            {
-                name: "left",
-                type: this.name,
-            },
-            {
-                name: "right",
-                type: this.name,
-            },
-        ],
-        statements: [`return ${expression};`],
-        returnType: "purifyHelpers.Equatable.EqualsResult",
-    };
+    }));
 }
 //# sourceMappingURL=equalsFunctionDeclaration.js.map

package/generators/ts/_ObjectType/equalsFunctionOrMethodDeclaration.d.ts

@@ -0,0 +1,11 @@
+import { Maybe } from "purify-ts";
+import type { OptionalKind, ParameterDeclarationStructure } from "ts-morph";
+import type { ObjectType } from "../ObjectType.js";
+export declare function equalsFunctionOrMethodDeclaration(this: ObjectType): Maybe<{
+    hasOverrideKeyword: boolean;
+    name: string;
+    parameters: OptionalKind<ParameterDeclarationStructure>[];
+    returnType: string;
+    statements: string[];
+}>;
+//# sourceMappingURL=equalsFunctionOrMethodDeclaration.d.ts.map

package/generators/ts/_ObjectType/equalsFunctionOrMethodDeclaration.js

@@ -0,0 +1,70 @@
+import { Maybe } from "purify-ts";
+export function equalsFunctionOrMethodDeclaration() {
+    if (!this.features.has("equals")) {
+        return Maybe.empty();
+    }
+    if (this.declarationType === "class" && this.ownProperties.length === 0) {
+        // If there's a parent class and no properties in this class, can skip overriding equals
+        return Maybe.empty();
+    }
+    let leftVariable;
+    let rightVariable;
+    switch (this.declarationType) {
+        case "class":
+            leftVariable = "this";
+            rightVariable = "other";
+            break;
+        case "interface":
+            leftVariable = "left";
+            rightVariable = "right";
+    }
+    const chain = [];
+    let hasOverrideKeyword = false;
+    if (this.parentObjectTypes.length > 0) {
+        switch (this.declarationType) {
+            case "class": {
+                chain.push("super.equals(other)");
+                hasOverrideKeyword = true;
+                break;
+            }
+            case "interface": {
+                // For every parent, find the nearest equals implementation
+                for (const parentObjectType of this.parentObjectTypes) {
+                    chain.push(`${parentObjectType.name}.equals(left, right)`);
+                }
+                break;
+            }
+        }
+    }
+    for (const property of this.ownProperties) {
+        chain.push(`(${property.equalsFunction})(${leftVariable}.${property.name}, ${rightVariable}.${property.name}).mapLeft(propertyValuesUnequal => ({ left: ${leftVariable}, right: ${rightVariable}, propertyName: "${property.name}", propertyValuesUnequal, type: "Property" as const }))`);
+    }
+    return Maybe.of({
+        hasOverrideKeyword,
+        name: "equals",
+        parameters: this.declarationType === "interface"
+            ? [
+                {
+                    name: "left",
+                    type: this.name,
+                },
+                {
+                    name: "right",
+                    type: this.name,
+                },
+            ]
+            : [
+                {
+                    name: "other",
+                    type: this.name,
+                },
+            ],
+        returnType: "purifyHelpers.Equatable.EqualsResult",
+        statements: [
+            `return ${chain
+                .map((chainPart, chainPartI) => chainPartI === 0 ? chainPart : `chain(() => ${chainPart})`)
+                .join(".")};`,
+        ],
+    });
+}
+//# sourceMappingURL=equalsFunctionOrMethodDeclaration.js.map

package/generators/ts/_ObjectType/fromJsonFunctionDeclarations.d.ts

@@ -0,0 +1,4 @@
+import { type FunctionDeclarationStructure } from "ts-morph";
+import type { ObjectType } from "../ObjectType.js";
+export declare function fromJsonFunctionDeclarations(this: ObjectType): readonly FunctionDeclarationStructure[];
+//# sourceMappingURL=fromJsonFunctionDeclarations.d.ts.map