@shaclmate/compiler 2.0.14 → 2.0.16

package/generators/ts/ObjectUnionType.js

@@ -11,6 +11,8 @@ import { StructureKind, } from "ts-morph";
 import { Memoize } from "typescript-memoize";
 import { DeclaredType } from "./DeclaredType.js";
 import { hasherTypeConstraint } from "./_ObjectType/hashFunctionOrMethodDeclaration.js";
+import { sparqlConstructQueryFunctionDeclaration } from "./_ObjectType/sparqlConstructQueryFunctionDeclaration.js";
+import { sparqlConstructQueryStringFunctionDeclaration } from "./_ObjectType/sparqlConstructQueryStringFunctionDeclaration.js";
 import { objectInitializer } from "./objectInitializer.js";
 import { tsComment } from "./tsComment.js";
 /**
@@ -53,7 +55,7 @@ export class ObjectUnionType extends DeclaredType {
         ];
     }
     get declarationImports() {
-        return this.memberTypes.flatMap((memberType) => memberType.useImports);
+        return this.memberTypes.flatMap((memberType) => memberType.useImports(this.features));
     }
     get declarations() {
         const declarations = [this.typeAliasDeclaration];
@@ -91,9 +93,6 @@ export class ObjectUnionType extends DeclaredType {
     get mutable() {
         return this.memberTypes.some((memberType) => memberType.mutable);
     }
-    get useImports() {
-        return [];
-    }
     get thisVariable() {
         return `_${camelCase(this.name)}`;
     }
@@ -127,9 +126,9 @@ export class ObjectUnionType extends DeclaredType {
                     type: this.name,
                 },
             ],
-            returnType: "purifyHelpers.Equatable.EqualsResult",
+            returnType: "EqualsResult",
             statements: `\
-return purifyHelpers.Equatable.strictEquals(left.type, right.type).chain(() => {
+return strictEquals(left.type, right.type).chain(() => {
   switch (left.${this._discriminatorProperty.name}) {
    ${caseBlocks.join(" ")}
   }
@@ -171,14 +170,14 @@ return purifyHelpers.Equatable.strictEquals(left.type, right.type).chain(() => {
             name: "fromRdf",
             parameters: [
                 {
-                    name: "parameters",
+                    name: "{ ignoreRdfType, resource, ...context }",
                     type: `{ [_index: string]: any; ignoreRdfType?: boolean; resource: ${this.rdfjsResourceType().name}; }`,
                 },
             ],
             returnType: `purify.Either<rdfjsResource.Resource.ValueError, ${this.name}>`,
             statements: [
                 `return ${this.memberTypes.reduce((expression, memberType) => {
-                    const memberTypeExpression = `(${memberType.name}.fromRdf(parameters) as purify.Either<rdfjsResource.Resource.ValueError, ${this.name}>)`;
+                    const memberTypeExpression = `(${memberType.name}.fromRdf({ ...context, resource }) as purify.Either<rdfjsResource.Resource.ValueError, ${this.name}>)`;
                     return expression.length > 0
                         ? `${expression}.altLazy(() => ${memberTypeExpression})`
                         : memberTypeExpression;
@@ -244,54 +243,23 @@ return purifyHelpers.Equatable.strictEquals(left.type, right.type).chain(() => {
             return [];
         }
         return [
-            {
-                isExported: true,
-                kind: StructureKind.Function,
-                name: "sparqlConstructQuery",
-                parameters: [
-                    {
-                        hasQuestionToken: true,
-                        name: "parameters",
-                        type: '{ prefixes?: { [prefix: string]: string }; subject: rdfjs.Variable } & Omit<sparqljs.ConstructQuery, "prefixes" | "queryType" | "template" | "where">',
-                    },
-                ],
-                returnType: "sparqljs.ConstructQuery",
-                statements: [
-                    `const subject = parameters?.subject ?? ${this.dataFactoryVariable}.variable!("${camelCase(this.name)}");`,
-                    `return { ...parameters, prefixes: parameters?.prefixes ?? {}, queryType: "CONSTRUCT", template: ${this.name}.sparqlConstructTemplateTriples({ subject }).concat(), type: "query", where: ${this.name}.sparqlWherePatterns({ subject }).concat() };`,
-                ],
-            },
-            {
-                isExported: true,
-                kind: StructureKind.Function,
-                name: "sparqlConstructQueryString",
-                parameters: [
-                    {
-                        hasQuestionToken: true,
-                        name: "parameters",
-                        type: '{ subject: rdfjs.Variable } & Omit<sparqljs.ConstructQuery, "prefixes" | "queryType" | "template" | "where"> & sparqljs.GeneratorOptions',
-                    },
-                ],
-                returnType: "string",
-                statements: [
-                    `return new sparqljs.Generator(parameters).stringify(${this.name}.sparqlConstructQuery(parameters));`,
-                ],
-            },
+            sparqlConstructQueryFunctionDeclaration.bind(this)(),
+            sparqlConstructQueryStringFunctionDeclaration.bind(this)(),
             {
                 isExported: true,
                 kind: StructureKind.Function,
                 name: "sparqlConstructTemplateTriples",
+                // Accept ignoreRdfType in order to reuse code but don't pass it through, since deserialization may depend on it
                 parameters: [
                     {
-                        name: "{ subject, variablePrefix: variablePrefixParameter }",
-                        type: "{ subject: rdfjs.Variable, variablePrefix?: string }",
+                        name: "parameters",
+                        type: '{ ignoreRdfType?: boolean, subject?: sparqljs.Triple["subject"], variablePrefix?: string }',
                     },
                 ],
                 returnType: "readonly sparqljs.Triple[]",
                 statements: [
-                    "const variablePrefix = variablePrefixParameter ?? subject.value;",
                     `return [${this.memberTypes
-                        .map((memberType) => `...${memberType.name}.sparqlConstructTemplateTriples({ subject, variablePrefix: \`\${variablePrefix}${pascalCase(memberType.name)}\` }).concat()`)
+                        .map((memberType) => `...${memberType.name}.sparqlConstructTemplateTriples({ subject: parameters.subject ?? ${this.dataFactoryVariable}.variable!("${camelCase(this.name)}${pascalCase(memberType.name)}"), variablePrefix: parameters?.variablePrefix ? \`\${parameters.variablePrefix}${pascalCase(memberType.name)}\` : "${camelCase(this.name)}${pascalCase(memberType.name)}" }).concat()`)
                         .join(", ")}];`,
                 ],
             },
@@ -299,18 +267,18 @@ return purifyHelpers.Equatable.strictEquals(left.type, right.type).chain(() => {
                 isExported: true,
                 kind: StructureKind.Function,
                 name: "sparqlWherePatterns",
+                // Accept ignoreRdfType in order to reuse code but don't pass it through, since deserialization may depend on it
                 parameters: [
                     {
-                        name: "{ subject, variablePrefix: variablePrefixParameter }",
-                        type: "{ subject: rdfjs.Variable, variablePrefix?: string }",
+                        name: "parameters",
+                        type: '{ ignoreRdfType?: boolean; subject?: sparqljs.Triple["subject"], variablePrefix?: string }',
                     },
                 ],
                 returnType: "readonly sparqljs.Pattern[]",
                 statements: [
-                    "const variablePrefix = variablePrefixParameter ?? subject.value;",
                     `return [{ patterns: [${this.memberTypes
                         .map((memberType) => objectInitializer({
-                        patterns: `${memberType.name}.sparqlWherePatterns({ subject, variablePrefix: \`\${variablePrefix}${pascalCase(memberType.name)}\` }).concat()`,
+                        patterns: `${memberType.name}.sparqlWherePatterns({ subject: parameters.subject ?? ${this.dataFactoryVariable}.variable!("${camelCase(this.name)}${pascalCase(memberType.name)}"), variablePrefix: parameters?.variablePrefix ? \`\${parameters.variablePrefix}${pascalCase(memberType.name)}\` : "${camelCase(this.name)}${pascalCase(memberType.name)}" }).concat()`,
                         type: '"group"',
                     }))
                         .join(", ")}], type: "union" }];`,
@@ -397,7 +365,8 @@ return purifyHelpers.Equatable.strictEquals(left.type, right.type).chain(() => {
         return `${this.name}.fromJson(${variables.value}).unsafeCoerce()`;
     }
     fromRdfExpression({ variables, }) {
-        return `${variables.resourceValues}.head().chain(value => value.to${this.rdfjsResourceType().named ? "Named" : ""}Resource()).chain(_resource => ${this.name}.fromRdf({ ...${variables.context}, resource: _resource }))`;
+        // Don't ignoreRdfType, we may need it to distinguish the union members
+        return `${variables.resourceValues}.head().chain(value => value.to${this.rdfjsResourceType().named ? "Named" : ""}Resource()).chain(_resource => ${this.name}.fromRdf({ ...${variables.context}, languageIn: ${variables.languageIn}, resource: _resource }))`;
     }
     hashStatements({ variables, }) {
         switch (this.memberTypes[0].declarationType) {
@@ -417,7 +386,6 @@ return purifyHelpers.Equatable.strictEquals(left.type, right.type).chain(() => {
             case "type":
                 return [
                     `...${this.name}.sparqlConstructTemplateTriples(${objectInitializer({
-                        ignoreRdfType: true,
                         subject: variables.subject,
                         variablePrefix: variables.variablePrefix,
                     })})`,
@@ -431,7 +399,6 @@ return purifyHelpers.Equatable.strictEquals(left.type, right.type).chain(() => {
             case "type":
                 return [
                     `...${this.name}.sparqlWherePatterns(${objectInitializer({
-                        ignoreRdfType: true,
                         subject: variables.subject,
                         variablePrefix: variables.variablePrefix,
                     })})`,
@@ -456,6 +423,9 @@ return purifyHelpers.Equatable.strictEquals(left.type, right.type).chain(() => {
                 return `${this.name}.toRdf(${variables.value}, ${options})`;
         }
     }
+    useImports() {
+        return [];
+    }
     rdfjsResourceType(options) {
         const memberRdfjsResourceTypes = [];
         for (const memberType of this.memberTypes) {

package/generators/ts/OptionType.d.ts

@@ -1,3 +1,4 @@
+import type { TsFeature } from "../../enums/index.js";
 import { Import } from "./Import.js";
 import { Type } from "./Type.js";
 export declare class OptionType extends Type {
@@ -11,15 +12,16 @@ export declare class OptionType extends Type {
     get jsonName(): string;
     get mutable(): boolean;
     get name(): string;
-    get useImports(): readonly Import[];
     fromJsonExpression({ variables, }: Parameters<Type["fromJsonExpression"]>[0]): string;
     fromRdfExpression(parameters: Parameters<Type["fromRdfExpression"]>[0]): string;
     hashStatements({ depth, variables, }: Parameters<Type["hashStatements"]>[0]): readonly string[];
     jsonUiSchemaElement(parameters: Parameters<Type["jsonUiSchemaElement"]>[0]): ReturnType<Type["jsonUiSchemaElement"]>;
     jsonZodSchema(parameters: Parameters<Type["jsonZodSchema"]>[0]): ReturnType<Type["jsonZodSchema"]>;
+    snippetDeclarations(features: Set<TsFeature>): readonly string[];
     sparqlConstructTemplateTriples({ context, variables, }: Parameters<Type["sparqlConstructTemplateTriples"]>[0]): readonly string[];
     sparqlWherePatterns({ context, variables, }: 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[];
 }
 //# sourceMappingURL=OptionType.d.ts.map

package/generators/ts/OptionType.js

@@ -6,6 +6,7 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 };
 import { Memoize } from "typescript-memoize";
 import { Import } from "./Import.js";
+import { SnippetDeclarations } from "./SnippetDeclarations.js";
 import { Type } from "./Type.js";
 export class OptionType extends Type {
     constructor({ itemType, ...superParameters }) {
@@ -36,14 +37,7 @@ export class OptionType extends Type {
         return conversions;
     }
     get equalsFunction() {
-        const itemTypeEqualsFunction = this.itemType.equalsFunction;
-        if (itemTypeEqualsFunction === "purifyHelpers.Equatable.equals") {
-            return "purifyHelpers.Equatable.maybeEquals";
-        }
-        if (itemTypeEqualsFunction === "purifyHelpers.Equatable.strictEquals") {
-            return "purifyHelpers.Equatable.booleanEquals"; // Use Maybe.equals
-        }
-        return `(left, right) => purifyHelpers.Maybes.equals(left, right, ${itemTypeEqualsFunction})`;
+        return `((left, right) => maybeEquals(left, right, ${this.itemType.equalsFunction}))`;
     }
     get jsonName() {
         return `(${this.itemType.jsonName}) | undefined`;
@@ -54,9 +48,6 @@ export class OptionType extends Type {
     get name() {
         return `purify.Maybe<${this.itemType.name}>`;
     }
-    get useImports() {
-        return [...this.itemType.useImports, Import.PURIFY];
-    }
     fromJsonExpression({ variables, }) {
         const expression = `purify.Maybe.fromNullable(${variables.value})`;
         const itemFromJsonExpression = this.itemType.fromJsonExpression({
@@ -88,6 +79,13 @@ export class OptionType extends Type {
     jsonZodSchema(parameters) {
         return `${this.itemType.jsonZodSchema(parameters)}.optional()`;
     }
+    snippetDeclarations(features) {
+        const snippetDeclarations = [];
+        if (features.has("equals")) {
+            snippetDeclarations.push(SnippetDeclarations.maybeEquals);
+        }
+        return snippetDeclarations;
+    }
     sparqlConstructTemplateTriples({ context, variables, }) {
         switch (context) {
             case "property":
@@ -125,6 +123,9 @@ export class OptionType extends Type {
         }
         return `${variables.value}.map((_value) => ${itemTypeToRdfExpression})`;
     }
+    useImports(features) {
+        return [...this.itemType.useImports(features), Import.PURIFY];
+    }
 }
 __decorate([
     Memoize()

package/generators/ts/PrimitiveType.d.ts

@@ -1,5 +1,5 @@
 import { Maybe } from "purify-ts";
-import type { Import } from "./Import.js";
+import type { TsFeature } from "../../enums/index.js";
 import { LiteralType } from "./LiteralType.js";
 import type { Type } from "./Type.js";
 export declare abstract class PrimitiveType<ValueT extends boolean | Date | string | number> extends LiteralType {
@@ -12,9 +12,9 @@ export declare abstract class PrimitiveType<ValueT extends boolean | Date | stri
     } & ConstructorParameters<typeof LiteralType>[0]);
     get discriminatorProperty(): Maybe<Type.DiscriminatorProperty>;
     get jsonName(): string;
-    get useImports(): readonly Import[];
     fromJsonExpression({ variables, }: Parameters<Type["fromJsonExpression"]>[0]): string;
     hashStatements({ variables, }: Parameters<Type["hashStatements"]>[0]): readonly string[];
+    snippetDeclarations(features: Set<TsFeature>): readonly string[];
     toJsonExpression({ variables, }: Parameters<Type["toJsonExpression"]>[0]): string;
     protected propertyFilterRdfResourceValuesExpression({ variables, }: Parameters<LiteralType["propertyFilterRdfResourceValuesExpression"]>[0]): string;
 }

package/generators/ts/PrimitiveType.js

@@ -1,9 +1,10 @@
 import { Maybe } from "purify-ts";
 import { LiteralType } from "./LiteralType.js";
+import { SnippetDeclarations } from "./SnippetDeclarations.js";
 export class PrimitiveType extends LiteralType {
     constructor({ primitiveDefaultValue, primitiveIn, ...superParameters }) {
         super(superParameters);
-        this.equalsFunction = "purifyHelpers.Equatable.strictEquals";
+        this.equalsFunction = "strictEquals";
         this.primitiveDefaultValue = primitiveDefaultValue;
         this.primitiveIn = primitiveIn;
     }
@@ -13,15 +14,19 @@ export class PrimitiveType extends LiteralType {
     get jsonName() {
         return this.name;
     }
-    get useImports() {
-        return [];
-    }
     fromJsonExpression({ variables, }) {
         return variables.value;
     }
     hashStatements({ variables, }) {
         return [`${variables.hasher}.update(${variables.value}.toString());`];
     }
+    snippetDeclarations(features) {
+        const snippetDeclarations = [];
+        if (features.has("equals")) {
+            snippetDeclarations.push(SnippetDeclarations.strictEquals);
+        }
+        return snippetDeclarations;
+    }
     toJsonExpression({ variables, }) {
         return variables.value;
     }

package/generators/ts/SetType.d.ts

@@ -1,3 +1,4 @@
+import type { TsFeature } from "../../enums/index.js";
 import type { Import } from "./Import.js";
 import { Type } from "./Type.js";
 export declare class SetType extends Type {
@@ -13,15 +14,16 @@ export declare class SetType extends Type {
     get jsonName(): string;
     get mutable(): boolean;
     get name(): string;
-    get useImports(): readonly Import[];
     fromJsonExpression({ variables, }: Parameters<Type["fromJsonExpression"]>[0]): string;
     fromRdfExpression({ variables, }: Parameters<Type["fromRdfExpression"]>[0]): string;
     hashStatements({ depth, variables, }: Parameters<Type["hashStatements"]>[0]): readonly string[];
     jsonUiSchemaElement(parameters: Parameters<Type["jsonUiSchemaElement"]>[0]): ReturnType<Type["jsonUiSchemaElement"]>;
     jsonZodSchema(parameters: Parameters<Type["jsonZodSchema"]>[0]): ReturnType<Type["jsonZodSchema"]>;
+    snippetDeclarations(features: Set<TsFeature>): readonly string[];
     sparqlConstructTemplateTriples({ context, variables, }: Parameters<Type["sparqlConstructTemplateTriples"]>[0]): readonly string[];
     sparqlWherePatterns({ context, variables, }: 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[];
 }
 //# sourceMappingURL=SetType.d.ts.map

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.
      *