@shaclmate/compiler 2.0.14 → 2.0.15

package/generators/ts/SetType.js

@@ -6,6 +6,7 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 };
 import { invariant } from "ts-invariant";
 import { Memoize } from "typescript-memoize";
+import { SnippetDeclarations } from "./SnippetDeclarations.js";
 import { Type } from "./Type.js";
 import { objectInitializer } from "./objectInitializer.js";
 export class SetType extends Type {
@@ -40,11 +41,7 @@ export class SetType extends Type {
         return conversions;
     }
     get equalsFunction() {
-        const itemTypeEqualsFunction = this.itemType.equalsFunction;
-        if (itemTypeEqualsFunction === "purifyHelpers.Equatable.equals") {
-            return "purifyHelpers.Equatable.arrayEquals";
-        }
-        return `(left, right) => purifyHelpers.Arrays.equals(left, right, ${itemTypeEqualsFunction})`;
+        return `((left, right) => arrayEquals(left, right, ${this.itemType.equalsFunction}))`;
     }
     get jsonName() {
         if (this.minCount === 0) {
@@ -61,9 +58,6 @@ export class SetType extends Type {
         }
         return `purify.NonEmptyList<${this.itemType.name}>`;
     }
-    get useImports() {
-        return this.itemType.useImports;
-    }
     fromJsonExpression({ variables, }) {
         let expression = variables.value;
         if (this.minCount > 0) {
@@ -108,6 +102,13 @@ export class SetType extends Type {
         }
         return schema;
     }
+    snippetDeclarations(features) {
+        const snippetDeclarations = [];
+        if (features.has("equals")) {
+            snippetDeclarations.push(SnippetDeclarations.arrayEquals);
+        }
+        return snippetDeclarations;
+    }
     sparqlConstructTemplateTriples({ context, variables, }) {
         switch (context) {
             case "property":
@@ -143,6 +144,9 @@ export class SetType extends Type {
             variables: { ...variables, value: "_item" },
         })})`;
     }
+    useImports(features) {
+        return this.itemType.useImports(features);
+    }
 }
 __decorate([
     Memoize()

package/generators/ts/SnippetDeclarations.d.ts

@@ -0,0 +1,11 @@
+export declare namespace SnippetDeclarations {
+    const arrayEquals = "export function arrayEquals<T>(\n  leftArray: readonly T[],\n  rightArray: readonly T[],\n  elementEquals: (left: T, right: T) => boolean | EqualsResult,\n): EqualsResult {\n  if (leftArray.length !== rightArray.length) {\n    return purify.Left({\n      left: leftArray,\n      right: rightArray,\n      type: \"ArrayLength\",\n    });\n  }\n\n  for (\n    let leftElementIndex = 0;\n    leftElementIndex < leftArray.length;\n    leftElementIndex++\n  ) {\n    const leftElement = leftArray[leftElementIndex];\n\n    const rightUnequals: EqualsResult.Unequal[] = [];\n    for (\n      let rightElementIndex = 0;\n      rightElementIndex < rightArray.length;\n      rightElementIndex++\n    ) {\n      const rightElement = rightArray[rightElementIndex];\n\n      const leftElementEqualsRightElement =\n        EqualsResult.fromBooleanEqualsResult(\n          leftElement,\n          rightElement,\n          elementEquals(leftElement, rightElement),\n        );\n      if (leftElementEqualsRightElement.isRight()) {\n        break; // left element === right element, break out of the right iteration\n      }\n      rightUnequals.push(\n        leftElementEqualsRightElement.extract() as EqualsResult.Unequal,\n      );\n    }\n\n    if (rightUnequals.length === rightArray.length) {\n      // All right elements were unequal to the left element\n      return purify.Left({\n        left: {\n          array: leftArray,\n          element: leftElement,\n          elementIndex: leftElementIndex,\n        },\n        right: {\n          array: rightArray,\n          unequals: rightUnequals,\n        },\n        type: \"ArrayElement\",\n      });\n    }\n    // Else there was a right element equal to the left element, continue to the next left element\n  }\n\n  return EqualsResult.Equal;\n}\n";
+    const booleanEquals = "/**\n * Compare two objects with equals(other: T): boolean methods and return an EqualsResult.\n */\nexport function booleanEquals<T extends { equals: (other: T) => boolean }>(\n  left: T,\n  right: T,\n): EqualsResult {\n  return EqualsResult.fromBooleanEqualsResult(\n    left,\n    right,\n    left.equals(right),\n  );\n}";
+    const dateEquals = "/**\n * Compare two Dates and return an EqualsResult.\n */\nexport function dateEquals(left: Date, right: Date): EqualsResult {\n  return EqualsResult.fromBooleanEqualsResult(\n    left,\n    right,\n    left.getTime() === right.getTime(),\n  );\n}";
+    const EqualsResult = "export type EqualsResult = purify.Either<EqualsResult.Unequal, true>;\n\nexport namespace EqualsResult {\n    export const Equal: EqualsResult = purify.Either.of<Unequal, true>(true);\n\n    export function fromBooleanEqualsResult(\n      left: any,\n      right: any,\n      equalsResult: boolean | EqualsResult,\n    ): EqualsResult {\n      if (typeof equalsResult !== \"boolean\") {\n        return equalsResult;\n      }\n\n      if (equalsResult) {\n        return Equal;\n      }\n      return purify.Left({\n        left,\n        right,\n        type: \"BooleanEquals\",\n      });\n    }\n\n    export type Unequal =\n      | {\n          readonly left: {\n            readonly array: readonly any[];\n            readonly element: any;\n            readonly elementIndex: number;\n          };\n          readonly right: {\n            readonly array: readonly any[];\n            readonly unequals: readonly Unequal[];\n          };\n          readonly type: \"ArrayElement\";\n        }\n      | {\n          readonly left: readonly any[];\n          readonly right: readonly any[];\n          readonly type: \"ArrayLength\";\n        }\n      | {\n          readonly left: any;\n          readonly right: any;\n          readonly type: \"BooleanEquals\";\n        }\n      | {\n          readonly left: any;\n          readonly right: any;\n          readonly type: \"LeftError\";\n        }\n      | {\n          readonly right: any;\n          readonly type: \"LeftNull\";\n        }\n      | {\n          readonly left: bigint | boolean | number | string;\n          readonly right: bigint | boolean | number | string;\n          readonly type: \"Primitive\";\n        }\n      | {\n          readonly left: object;\n          readonly right: object;\n          readonly propertyName: string;\n          readonly propertyValuesUnequal: Unequal;\n          readonly type: \"Property\";\n        }\n      | {\n          readonly left: any;\n          readonly right: any;\n          readonly type: \"RightError\";\n        }\n      | {\n          readonly left: any;\n          readonly type: \"RightNull\";\n        };\n}    \n";
+    const maybeEquals = "export function maybeEquals<T>(\n  leftMaybe: purify.Maybe<T>,\n  rightMaybe: purify.Maybe<T>,\n  valueEquals: (left: T, right: T) => boolean | EqualsResult,\n): EqualsResult {\n  if (leftMaybe.isJust()) {\n    if (rightMaybe.isJust()) {\n      return EqualsResult.fromBooleanEqualsResult(\n        leftMaybe,\n        rightMaybe,\n        valueEquals(leftMaybe.unsafeCoerce(), rightMaybe.unsafeCoerce()),\n      );\n    }\n    return purify.Left({\n      left: leftMaybe.unsafeCoerce(),\n      type: \"RightNull\",\n    });\n  }\n\n  if (rightMaybe.isJust()) {\n    return purify.Left({\n      right: rightMaybe.unsafeCoerce(),\n      type: \"LeftNull\",\n    });\n  }\n\n  return EqualsResult.Equal;\n}\n";
+    const strictEquals = "/**\n * Compare two values for strict equality (===), returning an EqualsResult rather than a boolean.\n */\nexport function strictEquals<T extends bigint | boolean | number | string>(\n  left: T,\n  right: T,\n): EqualsResult {\n  return EqualsResult.fromBooleanEqualsResult(left, right, left === right);\n}";
+    const UnwrapL = "type UnwrapL<T> = T extends purify.Either<infer L, any> ? L : never";
+    const UnwrapR = "type UnwrapR<T> = T extends purify.Either<any, infer R> ? R : never";
+}
+//# sourceMappingURL=SnippetDeclarations.d.ts.map

package/generators/ts/SnippetDeclarations.js

@@ -0,0 +1,215 @@
+export var SnippetDeclarations;
+(function (SnippetDeclarations) {
+    SnippetDeclarations.arrayEquals = `\
+export function arrayEquals<T>(
+  leftArray: readonly T[],
+  rightArray: readonly T[],
+  elementEquals: (left: T, right: T) => boolean | EqualsResult,
+): EqualsResult {
+  if (leftArray.length !== rightArray.length) {
+    return purify.Left({
+      left: leftArray,
+      right: rightArray,
+      type: "ArrayLength",
+    });
+  }
+
+  for (
+    let leftElementIndex = 0;
+    leftElementIndex < leftArray.length;
+    leftElementIndex++
+  ) {
+    const leftElement = leftArray[leftElementIndex];
+
+    const rightUnequals: EqualsResult.Unequal[] = [];
+    for (
+      let rightElementIndex = 0;
+      rightElementIndex < rightArray.length;
+      rightElementIndex++
+    ) {
+      const rightElement = rightArray[rightElementIndex];
+
+      const leftElementEqualsRightElement =
+        EqualsResult.fromBooleanEqualsResult(
+          leftElement,
+          rightElement,
+          elementEquals(leftElement, rightElement),
+        );
+      if (leftElementEqualsRightElement.isRight()) {
+        break; // left element === right element, break out of the right iteration
+      }
+      rightUnequals.push(
+        leftElementEqualsRightElement.extract() as EqualsResult.Unequal,
+      );
+    }
+
+    if (rightUnequals.length === rightArray.length) {
+      // All right elements were unequal to the left element
+      return purify.Left({
+        left: {
+          array: leftArray,
+          element: leftElement,
+          elementIndex: leftElementIndex,
+        },
+        right: {
+          array: rightArray,
+          unequals: rightUnequals,
+        },
+        type: "ArrayElement",
+      });
+    }
+    // Else there was a right element equal to the left element, continue to the next left element
+  }
+
+  return EqualsResult.Equal;
+}
+`;
+    SnippetDeclarations.booleanEquals = `\
+/**
+ * Compare two objects with equals(other: T): boolean methods and return an EqualsResult.
+ */
+export function booleanEquals<T extends { equals: (other: T) => boolean }>(
+  left: T,
+  right: T,
+): EqualsResult {
+  return EqualsResult.fromBooleanEqualsResult(
+    left,
+    right,
+    left.equals(right),
+  );
+}`;
+    SnippetDeclarations.dateEquals = `\
+/**
+ * Compare two Dates and return an EqualsResult.
+ */
+export function dateEquals(left: Date, right: Date): EqualsResult {
+  return EqualsResult.fromBooleanEqualsResult(
+    left,
+    right,
+    left.getTime() === right.getTime(),
+  );
+}`;
+    SnippetDeclarations.EqualsResult = `\
+export type EqualsResult = purify.Either<EqualsResult.Unequal, true>;
+
+export namespace EqualsResult {
+    export const Equal: EqualsResult = purify.Either.of<Unequal, true>(true);
+
+    export function fromBooleanEqualsResult(
+      left: any,
+      right: any,
+      equalsResult: boolean | EqualsResult,
+    ): EqualsResult {
+      if (typeof equalsResult !== "boolean") {
+        return equalsResult;
+      }
+
+      if (equalsResult) {
+        return Equal;
+      }
+      return purify.Left({
+        left,
+        right,
+        type: "BooleanEquals",
+      });
+    }
+
+    export type Unequal =
+      | {
+          readonly left: {
+            readonly array: readonly any[];
+            readonly element: any;
+            readonly elementIndex: number;
+          };
+          readonly right: {
+            readonly array: readonly any[];
+            readonly unequals: readonly Unequal[];
+          };
+          readonly type: "ArrayElement";
+        }
+      | {
+          readonly left: readonly any[];
+          readonly right: readonly any[];
+          readonly type: "ArrayLength";
+        }
+      | {
+          readonly left: any;
+          readonly right: any;
+          readonly type: "BooleanEquals";
+        }
+      | {
+          readonly left: any;
+          readonly right: any;
+          readonly type: "LeftError";
+        }
+      | {
+          readonly right: any;
+          readonly type: "LeftNull";
+        }
+      | {
+          readonly left: bigint | boolean | number | string;
+          readonly right: bigint | boolean | number | string;
+          readonly type: "Primitive";
+        }
+      | {
+          readonly left: object;
+          readonly right: object;
+          readonly propertyName: string;
+          readonly propertyValuesUnequal: Unequal;
+          readonly type: "Property";
+        }
+      | {
+          readonly left: any;
+          readonly right: any;
+          readonly type: "RightError";
+        }
+      | {
+          readonly left: any;
+          readonly type: "RightNull";
+        };
+}    
+`;
+    SnippetDeclarations.maybeEquals = `\
+export function maybeEquals<T>(
+  leftMaybe: purify.Maybe<T>,
+  rightMaybe: purify.Maybe<T>,
+  valueEquals: (left: T, right: T) => boolean | EqualsResult,
+): EqualsResult {
+  if (leftMaybe.isJust()) {
+    if (rightMaybe.isJust()) {
+      return EqualsResult.fromBooleanEqualsResult(
+        leftMaybe,
+        rightMaybe,
+        valueEquals(leftMaybe.unsafeCoerce(), rightMaybe.unsafeCoerce()),
+      );
+    }
+    return purify.Left({
+      left: leftMaybe.unsafeCoerce(),
+      type: "RightNull",
+    });
+  }
+
+  if (rightMaybe.isJust()) {
+    return purify.Left({
+      right: rightMaybe.unsafeCoerce(),
+      type: "LeftNull",
+    });
+  }
+
+  return EqualsResult.Equal;
+}
+`;
+    SnippetDeclarations.strictEquals = `\
+/**
+ * Compare two values for strict equality (===), returning an EqualsResult rather than a boolean.
+ */
+export function strictEquals<T extends bigint | boolean | number | string>(
+  left: T,
+  right: T,
+): EqualsResult {
+  return EqualsResult.fromBooleanEqualsResult(left, right, left === right);
+}`;
+    SnippetDeclarations.UnwrapL = "type UnwrapL<T> = T extends purify.Either<infer L, any> ? L : never";
+    SnippetDeclarations.UnwrapR = "type UnwrapR<T> = T extends purify.Either<any, infer R> ? R : never";
+})(SnippetDeclarations || (SnippetDeclarations = {}));
+//# sourceMappingURL=SnippetDeclarations.js.map

package/generators/ts/TermType.d.ts

@@ -1,5 +1,6 @@
 import type { BlankNode, Literal, NamedNode } from "@rdfjs/types";
 import { Maybe } from "purify-ts";
+import type { TsFeature } from "../../enums/index.js";
 import { Import } from "./Import.js";
 import { Type } from "./Type.js";
 /**
@@ -22,14 +23,15 @@ export declare class TermType<TermT extends BlankNode | Literal | NamedNode> ext
     get discriminatorProperty(): Maybe<Type.DiscriminatorProperty>;
     get jsonName(): string;
     get name(): string;
-    get useImports(): readonly Import[];
     fromJsonExpression({ variables, }: Parameters<Type["fromJsonExpression"]>[0]): string;
     fromRdfExpression({ variables, }: Parameters<Type["fromRdfExpression"]>[0]): string;
     hashStatements({ variables, }: Parameters<Type["hashStatements"]>[0]): readonly string[];
     jsonZodSchema({ variables, }: Parameters<Type["jsonZodSchema"]>[0]): ReturnType<Type["jsonZodSchema"]>;
+    snippetDeclarations(features: Set<TsFeature>): readonly string[];
     sparqlWherePatterns(parameters: Parameters<Type["sparqlWherePatterns"]>[0]): readonly string[];
     toJsonExpression({ variables, }: Parameters<Type["toJsonExpression"]>[0]): string;
     toRdfExpression({ variables, }: Parameters<Type["toRdfExpression"]>[0]): string;
+    useImports(): readonly Import[];
     /**
      * Filter the rdfjsResource.Resource.Values to those that are relevant to the type.
      *

package/generators/ts/TermType.js

@@ -9,6 +9,7 @@ import { Maybe } from "purify-ts";
 import { invariant } from "ts-invariant";
 import { Memoize } from "typescript-memoize";
 import { Import } from "./Import.js";
+import { SnippetDeclarations } from "./SnippetDeclarations.js";
 import { Type } from "./Type.js";
 import { objectInitializer } from "./objectInitializer.js";
 /**
@@ -17,7 +18,7 @@ import { objectInitializer } from "./objectInitializer.js";
 export class TermType extends Type {
     constructor({ defaultValue, hasValues, in_, nodeKinds, ...superParameters }) {
         super(superParameters);
-        this.equalsFunction = "purifyHelpers.Equatable.booleanEquals";
+        this.equalsFunction = "booleanEquals";
         this.mutable = false;
         this.defaultValue = defaultValue;
         this.hasValues = hasValues;
@@ -80,13 +81,6 @@ export class TermType extends Type {
             .map((nodeKind) => `rdfjs.${nodeKind}`)
             .join(" | ")})`;
     }
-    get useImports() {
-        const imports = [Import.RDFJS_TYPES];
-        if (this.nodeKinds.has("Literal")) {
-            imports.push(Import.RDF_LITERAL);
-        }
-        return imports;
-    }
     fromJsonExpression({ variables, }) {
         invariant(this.nodeKinds.has("Literal") &&
             (this.nodeKinds.has("BlankNode") || this.nodeKinds.has("NamedNode")), "IdentifierType and LiteralType should override");
@@ -161,6 +155,13 @@ export class TermType extends Type {
         })
             .join(", ")}])`;
     }
+    snippetDeclarations(features) {
+        const snippetDeclarations = [];
+        if (features.has("equals")) {
+            snippetDeclarations.push(SnippetDeclarations.booleanEquals);
+        }
+        return snippetDeclarations;
+    }
     sparqlWherePatterns(parameters) {
         switch (parameters.context) {
             case "property":
@@ -201,6 +202,13 @@ export class TermType extends Type {
             .map((defaultValue) => `!${variables.value}.equals(${this.rdfjsTermExpression(defaultValue)}) ? ${variables.value} : undefined`)
             .orDefault(variables.value);
     }
+    useImports() {
+        const imports = [Import.RDFJS_TYPES];
+        if (this.nodeKinds.has("Literal")) {
+            imports.push(Import.RDF_LITERAL);
+        }
+        return imports;
+    }
     /**
      * Filter the rdfjsResource.Resource.Values to those that are relevant to the type.
      *

package/generators/ts/TsGenerator.js

@@ -30,9 +30,13 @@ export class TsGenerator {
     addDeclarations({ objectTypes, objectUnionTypes, sourceFile, }) {
         // sourceFile.addStatements(this.configuration.dataFactoryImport);
         sourceFile.addStatements('import { DataFactory as dataFactory } from "n3"');
+        const declaredTypes = [
+            ...objectTypes,
+            ...objectUnionTypes,
+        ];
         // Gather imports
         const imports = [];
-        for (const declaredType of [...objectTypes, ...objectUnionTypes]) {
+        for (const declaredType of declaredTypes) {
             imports.push(...declaredType.declarationImports);
         }
         // Deduplicate and add imports
@@ -51,6 +55,16 @@ export class TsGenerator {
                 addedStructureImports.push(import_);
             }
         }
+        // Deduplicate and add snippet declarations
+        const addedSnippetDeclarations = new Set();
+        for (const declaredType of declaredTypes) {
+            for (const snippetDeclaration of declaredType.snippetDeclarations(declaredType.features)) {
+                if (!addedSnippetDeclarations.has(snippetDeclaration)) {
+                    sourceFile.addStatements([snippetDeclaration]);
+                    addedSnippetDeclarations.add(snippetDeclaration);
+                }
+            }
+        }
         // Add type declarations
         for (const objectType of objectTypes) {
             sourceFile.addStatements(objectType.declarations);

package/generators/ts/Type.d.ts

@@ -1,5 +1,6 @@
 import type { BlankNode, Literal, NamedNode, Variable } from "@rdfjs/types";
 import { Maybe } from "purify-ts";
+import type { TsFeature } from "../../enums/index.js";
 import type { Import } from "./Import.js";
 /**
  * Abstract base class for generating TypeScript expressions and statemenst in the TypeScript generator.
@@ -13,7 +14,7 @@ export declare abstract class Type {
     abstract readonly conversions: readonly Type.Conversion[];
     /**
      * A function (reference or declaration) that compares two property values of this type, returning a
-     * purifyHelpers.Equatable.EqualsResult.
+     * EqualsResult.
      */
     abstract readonly equalsFunction: string;
     /**
@@ -28,10 +29,6 @@ export declare abstract class Type {
      * Name of the type.
      */
     abstract readonly name: string;
-    /**
-     * Imports necessary to use this type.
-     */
-    abstract readonly useImports: readonly Import[];
     protected readonly dataFactoryVariable: string;
     constructor({ dataFactoryVariable, }: {
         dataFactoryVariable: string;
@@ -87,6 +84,15 @@ export declare abstract class Type {
             zod: string;
         };
     }): string;
+    /**
+     * Reusable function, type, and other declarations that are not particular to this type but that type-specific code
+     * relies on. For example, the equals function/method of ObjectType has a custom return type that's the same across all
+     * ObjectType's. Instead of re-declaring the return type anonymously on every equals function, declare a named type
+     * as a snippet and reference it.
+     *
+     * The generator deduplicates snippet declarations across all types before adding them to the source.
+     */
+    snippetDeclarations(_features: Set<TsFeature>): readonly string[];
     /**
      * An array of SPARQL.js CONSTRUCT template triples for a value of this type, as strings (so they can incorporate runtime calls).
      *
@@ -153,6 +159,10 @@ export declare abstract class Type {
             value: string;
         };
     }): string;
+    /**
+     * Imports necessary to use this type.
+     */
+    useImports(_features: Set<TsFeature>): readonly Import[];
     protected rdfjsTermExpression(rdfjsTerm: Omit<BlankNode, "equals"> | Omit<Literal, "equals"> | Omit<NamedNode, "equals"> | Omit<Variable, "equals">): string;
 }
 export declare namespace Type {

package/generators/ts/Type.js

@@ -23,6 +23,17 @@ export class Type {
     jsonUiSchemaElement(_parameters) {
         return Maybe.empty();
     }
+    /**
+     * Reusable function, type, and other declarations that are not particular to this type but that type-specific code
+     * relies on. For example, the equals function/method of ObjectType has a custom return type that's the same across all
+     * ObjectType's. Instead of re-declaring the return type anonymously on every equals function, declare a named type
+     * as a snippet and reference it.
+     *
+     * The generator deduplicates snippet declarations across all types before adding them to the source.
+     */
+    snippetDeclarations(_features) {
+        return [];
+    }
     /**
      * An array of SPARQL.js CONSTRUCT template triples for a value of this type, as strings (so they can incorporate runtime calls).
      *
@@ -90,6 +101,12 @@ export class Type {
                 return [];
         }
     }
+    /**
+     * Imports necessary to use this type.
+     */
+    useImports(_features) {
+        return [];
+    }
     rdfjsTermExpression(rdfjsTerm) {
         return rdfjsTermExpression({
             dataFactoryVariable: this.dataFactoryVariable,

package/generators/ts/TypeFactory.js

@@ -232,7 +232,7 @@ export class TypeFactory {
             lazyDescendantObjectTypes: () => astType.descendantObjectTypes.map((astType) => this.createObjectTypeFromAstType(astType)),
             lazyParentObjectTypes: () => astType.parentObjectTypes.map((astType) => this.createObjectTypeFromAstType(astType)),
             lazyProperties: () => {
-                const properties = astType.properties.map((astProperty) => this.createObjectTypePropertyFromAstProperty(astProperty));
+                const properties = astType.properties.map((astProperty) => this.createObjectTypePropertyFromAstProperty(astType, astProperty));
                 let identifierPropertyClassDeclarationVisibility;
                 if (astType.abstract) {
                     // If the type is abstract, don't declare a property.
@@ -256,7 +256,10 @@ export class TypeFactory {
                     mintingStrategy: astType.mintingStrategy,
                     name: astType.tsIdentifierPropertyName,
                     lazyObjectTypeMutable: () => properties.some((property) => property.mutable || property.type.mutable),
-                    objectTypeDeclarationType: astType.tsObjectDeclarationType,
+                    objectType: {
+                        declarationType: astType.tsObjectDeclarationType,
+                        features: astType.tsFeatures,
+                    },
                     override: astType.parentObjectTypes.length > 0,
                     type: identifierType,
                     visibility: "public",
@@ -277,7 +280,10 @@ export class TypeFactory {
                         abstract: astType.abstract,
                         dataFactoryVariable: this.dataFactoryVariable,
                         name: astType.tsTypeDiscriminatorPropertyName,
-                        objectTypeDeclarationType: objectType.declarationType,
+                        objectType: {
+                            declarationType: astType.tsObjectDeclarationType,
+                            features: astType.tsFeatures,
+                        },
                         override: objectType.parentObjectTypes.length > 0,
                         type: new ObjectType.TypeDiscriminatorProperty.Type({
                             mutable: false,
@@ -296,7 +302,7 @@ export class TypeFactory {
         this.cachedObjectTypesByIdentifier.set(astType.name.identifier, objectType);
         return objectType;
     }
-    createObjectTypePropertyFromAstProperty(astObjectTypeProperty) {
+    createObjectTypePropertyFromAstProperty(astObjectType, astObjectTypeProperty) {
         {
             const cachedProperty = this.cachedObjectTypePropertiesByIdentifier.get(astObjectTypeProperty.name.identifier);
             if (cachedProperty) {
@@ -309,6 +315,10 @@ export class TypeFactory {
             description: astObjectTypeProperty.description,
             label: astObjectTypeProperty.label,
             mutable: astObjectTypeProperty.mutable.orDefault(false),
+            objectType: {
+                declarationType: astObjectType.tsObjectDeclarationType,
+                features: astObjectType.tsFeatures,
+            },
             name: tsName(astObjectTypeProperty.name),
             path: astObjectTypeProperty.path.iri,
             type: this.createTypeFromAstType(astObjectTypeProperty.type),

package/generators/ts/UnionType.d.ts

@@ -1,4 +1,5 @@
 import { Maybe } from "purify-ts";
+import type { TsFeature } from "../../enums/index.js";
 import type { Import } from "./Import.js";
 import { Type } from "./Type.js";
 export declare class UnionType extends Type {
@@ -15,7 +16,6 @@ export declare class UnionType extends Type {
     get equalsFunction(): string;
     get jsonName(): string;
     get mutable(): boolean;
-    get useImports(): readonly Import[];
     private get _discriminatorProperty();
     private get memberTypeTraits();
     fromJsonExpression({ variables, }: Parameters<Type["fromJsonExpression"]>[0]): string;
@@ -26,6 +26,7 @@ export declare class UnionType extends Type {
     sparqlWherePatterns(parameters: Parameters<Type["sparqlWherePatterns"]>[0]): readonly string[];
     toJsonExpression({ variables, }: Parameters<Type["toJsonExpression"]>[0]): string;
     toRdfExpression({ variables, }: Parameters<Type["toRdfExpression"]>[0]): string;
+    useImports(features: Set<TsFeature>): readonly Import[];
     private ternaryExpression;
 }
 //# sourceMappingURL=UnionType.d.ts.map

package/generators/ts/UnionType.js

@@ -71,9 +71,6 @@ ${this.memberTypeTraits
     get mutable() {
         return this.memberTypes.some((memberType) => memberType.mutable);
     }
-    get useImports() {
-        return this.memberTypes.flatMap((memberType) => memberType.useImports);
-    }
     get _discriminatorProperty() {
         let sharedDiscriminatorProperty;
         for (const memberType of this.memberTypes) {
@@ -252,6 +249,9 @@ ${this.memberTypeTraits
             variables,
         });
     }
+    useImports(features) {
+        return this.memberTypes.flatMap((memberType) => memberType.useImports(features));
+    }
     ternaryExpression({ memberTypeExpression, variables, }) {
         return this.memberTypeTraits.reduce((expression, memberTypeTraits) => {
             if (expression.length === 0) {

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

@@ -1,24 +1,22 @@
 import { Maybe } from "purify-ts";
 import type { GetAccessorDeclarationStructure, OptionalKind, PropertyDeclarationStructure, PropertySignatureStructure } from "ts-morph";
-import type { MintingStrategy, PropertyVisibility, TsObjectDeclarationType } from "../../../enums/index.js";
+import type { MintingStrategy, PropertyVisibility } from "../../../enums/index.js";
 import type { IdentifierType } from "../IdentifierType.js";
 import { Import } from "../Import.js";
 import { Property } from "./Property.js";
 export declare class IdentifierProperty extends Property<IdentifierType> {
     readonly abstract: boolean;
-    readonly equalsFunction = "purifyHelpers.Equatable.booleanEquals";
+    readonly equalsFunction = "booleanEquals";
     readonly mutable = false;
     private readonly classDeclarationVisibility;
     private readonly lazyObjectTypeMutable;
     private readonly mintingStrategy;
-    private readonly objectTypeDeclarationType;
     private readonly override;
-    constructor({ abstract, classDeclarationVisibility, lazyObjectTypeMutable, mintingStrategy, objectTypeDeclarationType, override, ...superParameters }: {
+    constructor({ abstract, classDeclarationVisibility, lazyObjectTypeMutable, mintingStrategy, override, ...superParameters }: {
         abstract: boolean;
         classDeclarationVisibility: Maybe<PropertyVisibility>;
         lazyObjectTypeMutable: () => boolean;
         mintingStrategy: Maybe<MintingStrategy>;
-        objectTypeDeclarationType: TsObjectDeclarationType;
         override: boolean;
         type: IdentifierType;
     } & ConstructorParameters<typeof Property>[0]);
@@ -28,6 +26,7 @@ export declare class IdentifierProperty extends Property<IdentifierType> {
     get declarationImports(): readonly Import[];
     get interfacePropertySignature(): OptionalKind<PropertySignatureStructure>;
     get jsonPropertySignature(): OptionalKind<PropertySignatureStructure>;
+    get snippetDeclarations(): readonly string[];
     classConstructorStatements({ variables, }: Parameters<Property<IdentifierType>["classConstructorStatements"]>[0]): readonly string[];
     fromJsonStatements({ variables, }: Parameters<Property<IdentifierType>["fromJsonStatements"]>[0]): readonly string[];
     fromRdfStatements({ variables, }: Parameters<Property<IdentifierType>["fromRdfStatements"]>[0]): readonly string[];