@shaclmate/compiler 2.0.23 → 3.0.0

package/dist/generators/ts/TermType.js

@@ -120,31 +120,62 @@ export class TermType extends Type {
                 : `((${variables.value}.termType === "${nodeKind}") ? (${valueToNodeKind}) : (${expression}))`;
         }, "");
     }
-    fromRdfExpression({ variables, }) {
-        const chain = [
-            this.propertyFilterRdfResourceValuesExpression({ variables }),
-        ];
-        // Have an rdfjsResource.Resource.Values here
-        if (this.hasValues.length === 1) {
-            chain.push(`find(value => value.toTerm().equals(${rdfjsTermExpression(this.hasValues[0])}))`);
-        }
-        else {
-            chain.push("head()");
+    fromRdfExpression(parameters) {
+        // invariant(
+        //   this.nodeKinds.has("Literal") &&
+        //     (this.nodeKinds.has("BlankNode") || this.nodeKinds.has("NamedNode")),
+        //   "IdentifierType and LiteralType should override",
+        // );
+        const chain = this.fromRdfExpressionChain(parameters);
+        const { variables } = parameters;
+        return [
+            variables.resourceValues,
+            chain.defaultValue,
+            chain.hasValues,
+            chain.languageIn,
+            chain.preferredLanguages,
+            chain.valueTo,
+        ]
+            .filter((_) => typeof _ !== "undefined")
+            .join(".");
+    }
+    /**
+     * The fromRdfExpression for a term type can be decomposed into multiple sub-expressions with different purposes:
+     *
+     * defaultValues: add the default value to the values sequence if the latter doesn't contain values already
+     * hasValues: test whether the values sequence has sh:hasValue values
+     * languageIn: filter the values sequence to literals with the right sh:languageIn (or runtime languageIn)
+     * valueTo: convert values in the values sequence to the appropriate term type/sub-type (literal, string, etc.)
+     *
+     * Considering the sub-expressions as a record instead of an array allows them to be selectively overridden by subclasses.
+     */
+    fromRdfExpressionChain({ variables, }) {
+        let valueToExpression = "purify.Either.of<Error, rdfjs.BlankNode | rdfjs.Literal | rdfjs.NamedNode>(value.toTerm())";
+        if (this.nodeKinds.size < 3) {
+            const eitherTypeParameters = `<Error, ${this.name}>`;
+            valueToExpression = `${valueToExpression}.chain(term => {
+  switch (term.termType) {
+  ${[...this.nodeKinds].map((nodeKind) => `case "${nodeKind}":`).join("\n")} return purify.Either.of${eitherTypeParameters}(term);
+  default: return purify.Left${eitherTypeParameters}(new rdfjsResource.Resource.MistypedValueError(${objectInitializer({ actualValue: "term", expectedValueType: JSON.stringify(this.name), focusResource: variables.resource, predicate: variables.predicate })}));         
+}})`;
         }
-        // Have an rdfjsResource.Resource.Value here
-        this.defaultValue.ifJust((defaultValue) => {
-            // alt the default value before trying to convert the rdfjsResource.Resource.Value to the type
-            chain.push(`alt(purify.Either.of(new rdfjsResource.Resource.Value(${objectInitializer({ subject: variables.resource, predicate: variables.predicate, object: rdfjsTermExpression(defaultValue) })})))`);
-        });
-        // Last step: convert the rdfjsResource.Resource.Value to the type
-        chain.push(`chain(value => ${this.propertyFromRdfResourceValueExpression({
-            variables: {
-                predicate: variables.predicate,
-                resource: variables.resource,
-                resourceValue: "value",
-            },
-        })})`);
-        return chain.join(".");
+        return {
+            defaultValue: this.defaultValue
+                .map((defaultValue) => `map(values => values.length > 0 ? values : new rdfjsResource.Resource.Value(${objectInitializer({ subject: variables.resource, predicate: variables.predicate, object: rdfjsTermExpression(defaultValue) })}).toValues())`)
+                .extract(),
+            hasValues: this.hasValues.length > 0
+                ? `chain(values => {
+  for (const hasValue of [${this.hasValues.map(rdfjsTermExpression).join(", ")}]) {
+    const findResult = values.find(value => value.toTerm().equals(hasValue));
+    if (findResult.isLeft()) {
+      return findResult;
+    }
+  }
+  return purify.Either.of<Error, rdfjsResource.Resource.Values<rdfjsResource.Resource.Value>>(values);
+})`
+                : undefined,
+            valueTo: `chain(values => values.chainMap(value => ${valueToExpression}))`,
+        };
     }
     graphqlResolveExpression(_parameters) {
         throw new Error("not implemented");
@@ -231,33 +262,6 @@ export class TermType extends Type {
         }
         return imports;
     }
-    /**
-     * Filter the rdfjsResource.Resource.Values to those that are relevant to the type.
-     *
-     * This is done before
-     */
-    propertyFilterRdfResourceValuesExpression({ variables, }) {
-        return variables.resourceValues;
-    }
-    /**
-     * Convert an rdfjsResource.Resource.Value to a value of this type.
-     * @param variables
-     * @protected
-     */
-    propertyFromRdfResourceValueExpression({ variables, }) {
-        invariant(this.nodeKinds.has("Literal") &&
-            (this.nodeKinds.has("BlankNode") || this.nodeKinds.has("NamedNode")), "IdentifierType and LiteralType should override");
-        let expression = `purify.Either.of<Error, rdfjs.BlankNode | rdfjs.Literal | rdfjs.NamedNode>(${variables.resourceValue}.toTerm())`;
-        if (this.nodeKinds.size < 3) {
-            const eitherTypeParameters = `<Error, ${this.name}>`;
-            expression = `${expression}.chain(term => {
-  switch (term.termType) {
-  ${[...this.nodeKinds].map((nodeKind) => `case "${nodeKind}":`).join("\n")} return purify.Either.of${eitherTypeParameters}(term);
-  default: return purify.Left${eitherTypeParameters}(new rdfjsResource.Resource.MistypedValueError(${objectInitializer({ actualValue: "term", expectedValueType: JSON.stringify(this.name), focusResource: variables.resource, predicate: variables.predicate })}));         
-}})`;
-        }
-        return expression;
-    }
 }
 __decorate([
     Memoize()

package/dist/generators/ts/TsGenerator.js

@@ -1,5 +1,7 @@
+import { invariant } from "ts-invariant";
 import { Project, } from "ts-morph";
 import * as ast from "../../ast/index.js";
+import { Import } from "./Import.js";
 import { ObjectType } from "./ObjectType.js";
 import { ObjectUnionType } from "./ObjectUnionType.js";
 import { TypeFactory } from "./TypeFactory.js";
@@ -27,33 +29,43 @@ export class TsGenerator {
         return project.getFileSystem().readFileSync(sourceFile.getFilePath());
     }
     addStatements({ objectTypes, objectUnionTypes, sourceFile, }) {
-        // sourceFile.addStatements(this.configuration.dataFactoryImport);
-        sourceFile.addStatements('import N3, { DataFactory as dataFactory } from "n3"');
         const declaredTypes = [
             ...objectTypes,
             ...objectUnionTypes,
         ];
         // Gather imports
-        const imports = [];
+        const imports = [Import.DATA_FACTORY, Import.DATASET_FACTORY];
         for (const declaredType of declaredTypes) {
             imports.push(...declaredType.declarationImports);
         }
         // Deduplicate and add imports
-        const addedStringImports = new Set();
-        const addedStructureImports = [];
+        const stringImports = new Set();
+        const structureImports = [];
         for (const import_ of imports) {
             if (typeof import_ === "string") {
-                if (!addedStringImports.has(import_)) {
-                    sourceFile.addStatements([import_]);
-                }
-                addedStringImports.add(import_);
+                stringImports.add(import_);
+                continue;
+            }
+            const importWithSameModuleSpecifier = structureImports.find((structureImport) => structureImport.moduleSpecifier === import_.moduleSpecifier);
+            if (!importWithSameModuleSpecifier) {
+                structureImports.push(import_);
                 continue;
             }
-            if (!addedStructureImports.find((addedStructureImport) => addedStructureImport.moduleSpecifier === import_.moduleSpecifier)) {
-                sourceFile.addStatements([import_]);
-                addedStructureImports.push(import_);
+            // Merge named imports
+            invariant(!import_.namespaceImport);
+            invariant(Array.isArray(import_.namedImports) &&
+                import_.namedImports.every((value) => typeof value === "string"));
+            invariant(!importWithSameModuleSpecifier.namespaceImport);
+            invariant(Array.isArray(importWithSameModuleSpecifier.namedImports) &&
+                importWithSameModuleSpecifier.namedImports.every((value) => typeof value === "string"));
+            for (const newNamedImport of import_.namedImports) {
+                if (!importWithSameModuleSpecifier.namedImports.includes(newNamedImport)) {
+                    importWithSameModuleSpecifier.namedImports.push(newNamedImport);
+                }
             }
         }
+        sourceFile.addStatements([...stringImports]);
+        sourceFile.addStatements(structureImports);
         // Deduplicate and add snippet declarations
         const addedSnippetDeclarations = new Set();
         for (const declaredType of declaredTypes) {

package/dist/generators/ts/Type.d.ts

@@ -50,15 +50,21 @@ export declare abstract class Type {
         };
     }): string;
     /**
-     * An expression that converts a rdfjsResource.Resource.Values to a purify.Either of value/values
-     * of this type for a property.
+     * An expression that converts a purify.Either<Error, rdfjsResource.Resource.Values<rdfjsResource.Resource.Value>> to a
+     * purify.Either<Error, rdfjsResource.Resource.Values<this type>>.
+     *
+     * Some types need to filter on the set of all objects/values of a (subject, predicate). For example, all sh:hasValue values must be present in the set for any values
+     * to be considered valid. Similar
+     *
+     * Values may also need to be sorted. For example, specifying preferredLanguages should sort the values in the order of the specified languages so that the first value
+     * (if it exists) is always of the first preferred language.
      */
     abstract fromRdfExpression(parameters: {
         variables: {
             context: string;
             ignoreRdfType?: boolean;
-            languageIn: string;
             objectSet: string;
+            preferredLanguages: string;
             predicate: string;
             resource: string;
             resourceValues: string;
@@ -69,6 +75,7 @@ export declare abstract class Type {
      */
     abstract graphqlResolveExpression(parameters: {
         variables: {
+            args: string;
             value: string;
         };
     }): string;
@@ -154,6 +161,7 @@ export declare abstract class Type {
         variables: {
             object: string;
             predicate: string;
+            preferredLanguages: string;
             subject: string;
             variablePrefix: string;
         };
@@ -161,6 +169,7 @@ export declare abstract class Type {
         allowIgnoreRdfType: boolean;
         context: "subject";
         variables: {
+            preferredLanguages: string;
             subject: string;
             variablePrefix: string;
         };

package/dist/generators/ts/Type.js

@@ -66,6 +66,7 @@ export class Type {
                     allowIgnoreRdfType,
                     context: "subject",
                     variables: {
+                        preferredLanguages: variables.preferredLanguages,
                         subject: variables.object,
                         variablePrefix: variables.object.substring(objectPrefix.length, variables.object.length - objectSuffix.length),
                     },

package/dist/generators/ts/TypeFactory.d.ts

@@ -2,9 +2,17 @@ import type * as ast from "../../ast/index.js";
 import { ObjectType } from "./ObjectType.js";
 import type { Type } from "./Type.js";
 export declare class TypeFactory {
+    private cachedBooleanType;
+    private cachedDateType;
+    private cachedDateTimeType;
+    private cachedFloatType;
+    private cachedIdentifierType;
+    private cachedIntType;
+    private cachedNamedIdentifierType;
     private cachedObjectTypePropertiesByIdentifier;
     private cachedObjectTypesByIdentifier;
     private cachedObjectUnionTypesByIdentifier;
+    private cachedStringType;
     createObjectTypeFromAstType(astType: ast.ObjectType): ObjectType;
     createTypeFromAstType(astType: ast.Type): Type;
     private createObjectTypePropertyFromAstProperty;

package/dist/generators/ts/TypeFactory.js

@@ -24,9 +24,69 @@ import { UnionType } from "./UnionType.js";
 import { syntheticNamePrefix } from "./syntheticNamePrefix.js";
 import { tsName } from "./tsName.js";
 export class TypeFactory {
+    cachedBooleanType = new BooleanType({
+        defaultValue: Maybe.empty(),
+        hasValues: [],
+        in_: [],
+        languageIn: [],
+        primitiveDefaultValue: Maybe.empty(),
+        primitiveIn: [],
+    });
+    cachedDateType = new DateType({
+        defaultValue: Maybe.empty(),
+        hasValues: [],
+        in_: [],
+        languageIn: [],
+        primitiveDefaultValue: Maybe.empty(),
+        primitiveIn: [],
+    });
+    cachedDateTimeType = new DateTimeType({
+        defaultValue: Maybe.empty(),
+        hasValues: [],
+        in_: [],
+        languageIn: [],
+        primitiveDefaultValue: Maybe.empty(),
+        primitiveIn: [],
+    });
+    cachedFloatType = new FloatType({
+        defaultValue: Maybe.empty(),
+        hasValues: [],
+        in_: [],
+        languageIn: [],
+        primitiveDefaultValue: Maybe.empty(),
+        primitiveIn: [],
+    });
+    cachedIdentifierType = new IdentifierType({
+        defaultValue: Maybe.empty(),
+        hasValues: [],
+        in_: [],
+        nodeKinds: new Set(["BlankNode", "NamedNode"]),
+    });
+    cachedIntType = new IntType({
+        defaultValue: Maybe.empty(),
+        hasValues: [],
+        in_: [],
+        languageIn: [],
+        primitiveDefaultValue: Maybe.empty(),
+        primitiveIn: [],
+    });
+    cachedNamedIdentifierType = new IdentifierType({
+        defaultValue: Maybe.empty(),
+        hasValues: [],
+        in_: [],
+        nodeKinds: new Set(["NamedNode"]),
+    });
     cachedObjectTypePropertiesByIdentifier = new TermMap();
     cachedObjectTypesByIdentifier = new TermMap();
     cachedObjectUnionTypesByIdentifier = new TermMap();
+    cachedStringType = new StringType({
+        defaultValue: Maybe.empty(),
+        hasValues: [],
+        in_: [],
+        languageIn: [],
+        primitiveDefaultValue: Maybe.empty(),
+        primitiveIn: [],
+    });
     createObjectTypeFromAstType(astType) {
         {
             const cachedObjectType = this.cachedObjectTypesByIdentifier.get(astType.name.identifier);
@@ -106,21 +166,14 @@ export class TypeFactory {
                         own: !astType.ancestorObjectTypes.some(objectTypeNeedsIdentifierPrefixProperty),
                         name: `${syntheticNamePrefix}identifierPrefix`,
                         objectType,
-                        type: new StringType({
-                            defaultValue: Maybe.empty(),
-                            hasValues: [],
-                            in_: [],
-                            languageIn: [],
-                            primitiveDefaultValue: Maybe.empty(),
-                            primitiveIn: [],
-                        }),
+                        type: this.cachedStringType,
                         visibility: "protected",
                     }));
                 }
                 // Every ObjectType has an identifier property. Some are abstract.
                 properties.splice(0, 0, new ObjectType.IdentifierProperty({
                     abstract: astType.abstract,
-                    classGetAccessorScope: (() => {
+                    getAccessorScope: (() => {
                         if (astType.abstract) {
                             return Maybe.empty();
                         }
@@ -130,7 +183,12 @@ export class TypeFactory {
                         }
                         return Maybe.empty();
                     })(),
-                    classPropertyDeclarationVisibility: (() => {
+                    identifierMintingStrategy: astType.identifierMintingStrategy,
+                    identifierPrefixPropertyName: `${syntheticNamePrefix}identifierPrefix`,
+                    name: `${syntheticNamePrefix}identifier`,
+                    objectType,
+                    override: astType.parentObjectTypes.length > 0,
+                    propertyDeclarationVisibility: (() => {
                         if (astType.abstract) {
                             // If the type is abstract, don't declare an identifier property.
                             return Maybe.empty();
@@ -145,11 +203,6 @@ export class TypeFactory {
                         }
                         return Maybe.of("private");
                     })(),
-                    identifierMintingStrategy: astType.identifierMintingStrategy,
-                    identifierPrefixPropertyName: `${syntheticNamePrefix}identifierPrefix`,
-                    name: `${syntheticNamePrefix}identifier`,
-                    objectType,
-                    override: astType.parentObjectTypes.length > 0,
                     type: identifierType,
                     typeAlias: `${staticModuleName}.${syntheticNamePrefix}Identifier`,
                     visibility: "public",
@@ -168,6 +221,17 @@ export class TypeFactory {
     createTypeFromAstType(astType) {
         switch (astType.kind) {
             case "IdentifierType":
+                if (astType.defaultValue.isNothing() &&
+                    astType.hasValues.length === 0 &&
+                    astType.in_.length === 0) {
+                    if (astType.nodeKinds.size === 2) {
+                        return this.cachedIdentifierType;
+                    }
+                    if (astType.nodeKinds.size === 1 &&
+                        astType.nodeKinds.has("NamedNode")) {
+                        return this.cachedNamedIdentifierType;
+                    }
+                }
                 return new IdentifierType({
                     defaultValue: astType.defaultValue,
                     hasValues: astType.hasValues,
@@ -201,6 +265,11 @@ export class TypeFactory {
                 if (datatypes.size === 1) {
                     const datatype = [...datatypes][0];
                     if (datatype.equals(xsd.boolean)) {
+                        if (astType.defaultValue.isNothing() &&
+                            astType.hasValues.length === 0 &&
+                            astType.in_.length === 0) {
+                            return this.cachedBooleanType;
+                        }
                         return new BooleanType({
                             defaultValue: astType.defaultValue,
                             hasValues: astType.hasValues,
@@ -215,6 +284,13 @@ export class TypeFactory {
                         });
                     }
                     if (datatype.equals(xsd.date) || datatype.equals(xsd.dateTime)) {
+                        if (astType.defaultValue.isNothing() &&
+                            astType.hasValues.length === 0 &&
+                            astType.in_.length === 0) {
+                            return datatype.equals(xsd.date)
+                                ? this.cachedDateType
+                                : this.cachedDateTimeType;
+                        }
                         return new (datatype.equals(xsd.date) ? DateType : DateTimeType)({
                             defaultValue: astType.defaultValue,
                             hasValues: astType.hasValues,
@@ -231,6 +307,13 @@ export class TypeFactory {
                     for (const [floatOrInt, numberDatatypes_] of Object.entries(numberDatatypes)) {
                         for (const numberDatatype of numberDatatypes_) {
                             if (datatype.equals(numberDatatype)) {
+                                if (astType.defaultValue.isNothing() &&
+                                    astType.hasValues.length === 0 &&
+                                    astType.in_.length === 0) {
+                                    return floatOrInt === "float"
+                                        ? this.cachedFloatType
+                                        : this.cachedIntType;
+                                }
                                 return new (floatOrInt === "float" ? FloatType : IntType)({
                                     defaultValue: astType.defaultValue,
                                     hasValues: astType.hasValues,
@@ -247,10 +330,16 @@ export class TypeFactory {
                         }
                     }
                     if (datatype.equals(xsd.anyURI) || datatype.equals(xsd.string)) {
+                        if (astType.defaultValue.isNothing() &&
+                            astType.hasValues.length === 0 &&
+                            astType.in_.length === 0 &&
+                            astType.languageIn.length === 0) {
+                            return this.cachedStringType;
+                        }
                         return new StringType({
                             defaultValue: astType.defaultValue,
                             hasValues: astType.hasValues,
-                            languageIn: [],
+                            languageIn: astType.languageIn,
                             in_: astType.in_,
                             primitiveDefaultValue: astType.defaultValue.map((value) => value.value),
                             primitiveIn: astType.in_.map((value) => value.value),
@@ -329,6 +418,14 @@ export class TypeFactory {
                     stubType,
                 });
             }
+            else if (resolvedType instanceof ObjectType ||
+                resolvedType instanceof ObjectUnionType) {
+                invariant(stubType instanceof ObjectType || stubType instanceof ObjectUnionType, `lazy property ${name} on ${objectType.name} has ${stubType.kind} stubs`);
+                lazyType = new ObjectType.LazyShaclProperty.RequiredObjectType({
+                    resolvedType: resolvedType,
+                    stubType: stubType,
+                });
+            }
             else if (resolvedType instanceof SetType) {
                 invariant(resolvedType.itemType instanceof ObjectType ||
                     resolvedType.itemType instanceof ObjectUnionType, `lazy property ${name} on ${objectType.name} has ${resolvedType.kind} ${resolvedType.itemType.kind} items`);
@@ -339,13 +436,7 @@ export class TypeFactory {
                 });
             }
             else {
-                invariant(resolvedType instanceof ObjectType ||
-                    resolvedType instanceof ObjectUnionType, `lazy property ${name} on ${objectType.name} has ${resolvedType.kind}`);
-                invariant(stubType instanceof ObjectType || stubType instanceof ObjectUnionType, `lazy property ${name} on ${objectType.name} has ${stubType.kind} stubs`);
-                lazyType = new ObjectType.LazyShaclProperty.RequiredObjectType({
-                    resolvedType,
-                    stubType,
-                });
+                throw new Error(`lazy property ${name} on ${objectType.name} has ${resolvedType.kind}`);
             }
             property = new ObjectType.LazyShaclProperty({
                 comment: astObjectTypeProperty.comment,

package/dist/generators/ts/UnionType.js

@@ -257,7 +257,7 @@ ${this.memberTypes
             if (this._discriminator.kind === "syntheticProperty") {
                 typeExpression = `${typeExpression}.map(value => ({ ${this._discriminator.name}: "${memberType.discriminatorValues[0]}" as const, value }) as (${this.name}))`;
             }
-            typeExpression = `(${typeExpression} as purify.Either<Error, ${this.name}>)`;
+            typeExpression = `(${typeExpression} as purify.Either<Error, rdfjsResource.Resource.Values<${this.name}>>)`;
             return expression.length > 0
                 ? `${expression}.altLazy(() => ${typeExpression})`
                 : typeExpression;

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

@@ -17,9 +17,10 @@ export class EagerShaclProperty extends ShaclProperty {
     }
     get graphqlField() {
         return Maybe.of({
-            description: this.comment.map(JSON.stringify).extract(),
+            args: Maybe.empty(),
+            description: this.comment.map(JSON.stringify),
             name: this.name,
-            resolve: `(source) => ${this.type.graphqlResolveExpression({ variables: { value: `source.${this.name}` } })}`,
+            resolve: `(source, _args) => ${this.type.graphqlResolveExpression({ variables: { args: "_args", value: `source.${this.name}` } })}`,
             type: this.type.graphqlName.toString(),
         });
     }

package/dist/generators/ts/_ObjectType/IdentifierPrefixProperty.d.ts

@@ -7,7 +7,6 @@ import { Property } from "./Property.js";
 export declare class IdentifierPrefixProperty extends Property<StringType> {
     private readonly own;
     readonly declarationImports: readonly Import[];
-    readonly equalsFunction = "$strictEquals";
     readonly graphqlField: Property<StringType>["graphqlField"];
     readonly propertySignature: Maybe<OptionalKind<PropertySignatureStructure>>;
     readonly jsonPropertySignature: Maybe<OptionalKind<PropertySignatureStructure>>;
@@ -18,6 +17,7 @@ export declare class IdentifierPrefixProperty extends Property<StringType> {
         type: StringType;
     } & ConstructorParameters<typeof Property>[0]);
     get constructorParametersPropertySignature(): Maybe<OptionalKind<PropertySignatureStructure>>;
+    get equalsFunction(): Maybe<string>;
     constructorStatements({ variables, }: Parameters<Property<IdentifierType>["constructorStatements"]>[0]): readonly string[];
     fromJsonStatements(): readonly string[];
     fromRdfStatements(): readonly string[];

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

@@ -1,13 +1,19 @@
+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 { Scope, } from "ts-morph";
+import { Memoize } from "typescript-memoize";
 import { SnippetDeclarations } from "../SnippetDeclarations.js";
 import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
 import { Property } from "./Property.js";
 export class IdentifierPrefixProperty extends Property {
     own;
     declarationImports = [];
-    equalsFunction = `${syntheticNamePrefix}strictEquals`;
     graphqlField = Maybe.empty();
     propertySignature = Maybe.empty();
     jsonPropertySignature = Maybe.empty();
@@ -26,6 +32,11 @@ export class IdentifierPrefixProperty extends Property {
             type: this.type.name,
         });
     }
+    get equalsFunction() {
+        return this.objectType.declarationType === "class"
+            ? Maybe.of(`${syntheticNamePrefix}strictEquals`)
+            : Maybe.empty();
+    }
     constructorStatements({ variables, }) {
         switch (this.objectType.declarationType) {
             case "class":
@@ -94,4 +105,7 @@ export class IdentifierPrefixProperty extends Property {
         return [];
     }
 }
+__decorate([
+    Memoize()
+], IdentifierPrefixProperty.prototype, "equalsFunction", null);
 //# sourceMappingURL=IdentifierPrefixProperty.js.map

package/dist/generators/ts/_ObjectType/IdentifierProperty.d.ts

@@ -5,20 +5,20 @@ import type { IdentifierType } from "../IdentifierType.js";
 import { Import } from "../Import.js";
 import { Property } from "./Property.js";
 export declare class IdentifierProperty extends Property<IdentifierType> {
-    private readonly classGetAccessorScope;
-    private readonly classPropertyDeclarationVisibility;
+    private readonly getAccessorScope;
     private readonly identifierMintingStrategy;
     private readonly identifierPrefixPropertyName;
     private readonly override;
+    private readonly propertyDeclarationVisibility;
     private readonly typeAlias;
     readonly abstract: boolean;
-    readonly equalsFunction = "$booleanEquals";
+    readonly equalsFunction: Maybe<string>;
     readonly mutable = false;
     readonly recursive = false;
-    constructor({ abstract, classGetAccessorScope, classPropertyDeclarationVisibility, identifierMintingStrategy, identifierPrefixPropertyName, override, typeAlias, ...superParameters }: {
+    constructor({ abstract, getAccessorScope, identifierMintingStrategy, identifierPrefixPropertyName, override, propertyDeclarationVisibility, typeAlias, ...superParameters }: {
         abstract: boolean;
-        classGetAccessorScope: Maybe<Scope>;
-        classPropertyDeclarationVisibility: Maybe<PropertyVisibility>;
+        getAccessorScope: Maybe<Scope>;
+        propertyDeclarationVisibility: Maybe<PropertyVisibility>;
         identifierMintingStrategy: Maybe<IdentifierMintingStrategy>;
         identifierPrefixPropertyName: string;
         override: boolean;