@shaclmate/compiler 2.0.14 → 2.0.15

package/_ShapesGraphToAstTransformer/transformNodeShapeToAstType.js

@@ -1,7 +1,7 @@
 import { rdf } from "@tpluscode/rdf-ns-builders";
 import { Either, Left } from "purify-ts";
 import { invariant } from "ts-invariant";
-import { TsFeature } from "../enums/TsFeature.js";
+import { TsFeature } from "../enums/index.js";
 import * as input from "../input/index.js";
 import { logger } from "../logger.js";
 import { pickLiteral } from "./pickLiteral.js";
@@ -106,9 +106,22 @@ export function transformNodeShapeToAstType(nodeShape) {
             tsFeatures: nodeShape.tsFeatures.orDefault(new Set(TsFeature.MEMBERS)),
         };
         this.nodeShapeAstTypesByIdentifier.set(nodeShape.identifier, compositeType);
-        compositeType.memberTypes.push(...Either.rights(compositeTypeNodeShapes.map((nodeShape) => this.transformNodeShapeToAstType(nodeShape))).filter((nodeShapeAstType) => nodeShapeAstType.kind === "ObjectType"));
-        if (compositeType.memberTypes.length < compositeTypeNodeShapes.length) {
-            return Left(new Error(`${nodeShape} has one or more non-ObjectType node shapes in its logical constraint`));
+        for (const memberNodeShape of compositeTypeNodeShapes) {
+            const memberAstTypeEither = this.transformNodeShapeToAstType(memberNodeShape);
+            if (memberAstTypeEither.isLeft()) {
+                return memberAstTypeEither;
+            }
+            const memberAstType = memberAstTypeEither.unsafeCoerce();
+            switch (memberAstType.kind) {
+                case "ObjectType":
+                    compositeType.memberTypes.push(memberAstType);
+                    break;
+                case "ObjectUnionType":
+                    compositeType.memberTypes.push(...memberAstType.memberTypes);
+                    break;
+                default:
+                    return Left(new Error(`${nodeShape} has one or more non-ObjectType node shapes in its logical constraint`));
+            }
         }
         return Either.of(compositeType);
     }

package/_ShapesGraphToAstTransformer/transformPropertyShapeToAstCompositeType.js

@@ -95,7 +95,9 @@ export function transformPropertyShapeToAstCompositeType(shape, inherited) {
     invariant(memberTypeEithers.length > 0);
     const memberTypes = Either.rights(memberTypeEithers);
     if (memberTypes.length !== memberTypeEithers.length) {
-        logger.warn("shape %s composition did not map all member types successfully", shape);
+        logger.warn("shape %s composition did not map all member types successfully: %s", shape, Either.lefts(memberTypeEithers)
+            .map((left) => left.message)
+            .join("; "));
         return memberTypeEithers[0];
     }
     invariant(memberTypes.length > 0);

package/generators/ts/DateTimeType.d.ts

@@ -1,7 +1,8 @@
+import type { TsFeature } from "../../enums/index.js";
 import { PrimitiveType } from "./PrimitiveType.js";
 import type { Type } from "./Type.js";
 export declare class DateTimeType extends PrimitiveType<Date> {
-    readonly equalsFunction = "(left, right) => purifyHelpers.Equatable.EqualsResult.fromBooleanEqualsResult(left, right, left.getTime() === right.getTime())";
+    readonly equalsFunction = "dateEquals";
     readonly kind = "DateTimeType";
     readonly mutable = true;
     get conversions(): readonly Type.Conversion[];
@@ -11,6 +12,7 @@ export declare class DateTimeType extends PrimitiveType<Date> {
     hashStatements({ variables, }: Parameters<Type["hashStatements"]>[0]): readonly string[];
     jsonZodSchema({ variables, }: Parameters<Type["jsonZodSchema"]>[0]): ReturnType<Type["jsonZodSchema"]>;
     propertyFromRdfResourceValueExpression({ variables, }: Parameters<PrimitiveType<number>["propertyFromRdfResourceValueExpression"]>[0]): string;
+    snippetDeclarations(features: Set<TsFeature>): readonly string[];
     toJsonExpression({ variables, }: Parameters<PrimitiveType<Date>["toJsonExpression"]>[0]): string;
     toRdfExpression({ variables, }: Parameters<PrimitiveType<Date>["toRdfExpression"]>[0]): string;
 }

package/generators/ts/DateTimeType.js

@@ -1,9 +1,10 @@
 import { PrimitiveType } from "./PrimitiveType.js";
+import { SnippetDeclarations } from "./SnippetDeclarations.js";
 import { objectInitializer } from "./objectInitializer.js";
 export class DateTimeType extends PrimitiveType {
     constructor() {
         super(...arguments);
-        this.equalsFunction = "(left, right) => purifyHelpers.Equatable.EqualsResult.fromBooleanEqualsResult(left, right, left.getTime() === right.getTime())";
+        this.equalsFunction = "dateEquals";
         this.kind = "DateTimeType";
         this.mutable = true;
     }
@@ -46,6 +47,13 @@ export class DateTimeType extends PrimitiveType {
         }
         return expression;
     }
+    snippetDeclarations(features) {
+        const snippetDeclarations = [];
+        if (features.has("equals")) {
+            snippetDeclarations.push(SnippetDeclarations.dateEquals);
+        }
+        return snippetDeclarations;
+    }
     toJsonExpression({ variables, }) {
         return `${variables.value}.toISOString()`;
     }

package/generators/ts/Import.d.ts

@@ -5,7 +5,6 @@ export type Import = ImportDeclarationStructure | string;
  */
 export declare namespace Import {
     const PURIFY: Import;
-    const PURIFY_HELPERS: Import;
     const RDF_LITERAL: Import;
     const RDFJS_RESOURCE: Import;
     const RDFJS_TYPES: Import;

package/generators/ts/Import.js

@@ -9,11 +9,6 @@ export var Import;
         moduleSpecifier: "purify-ts",
         namespaceImport: "purify",
     };
-    Import.PURIFY_HELPERS = {
-        kind: StructureKind.ImportDeclaration,
-        moduleSpecifier: "purify-ts-helpers",
-        namespaceImport: "purifyHelpers",
-    };
     Import.RDF_LITERAL = {
         kind: StructureKind.ImportDeclaration,
         moduleSpecifier: "rdf-literal",

package/generators/ts/ListType.d.ts

@@ -1,6 +1,6 @@
 import type { NamedNode } from "@rdfjs/types";
 import { Maybe } from "purify-ts";
-import type { MintingStrategy } from "../../enums/index.js";
+import type { MintingStrategy, TsFeature } from "../../enums/index.js";
 import { Import } from "./Import.js";
 import { Type } from "./Type.js";
 export declare class ListType extends Type {
@@ -22,15 +22,16 @@ export declare class ListType extends Type {
     get equalsFunction(): string;
     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({ 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({ variables, context, }: Parameters<Type["sparqlConstructTemplateTriples"]>[0]): readonly string[];
     sparqlWherePatterns({ variables, context, }: 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=ListType.d.ts.map

package/generators/ts/ListType.js

@@ -1,6 +1,7 @@
 import { rdf } from "@tpluscode/rdf-ns-builders";
 import { Maybe } from "purify-ts";
 import { Import } from "./Import.js";
+import { SnippetDeclarations } from "./SnippetDeclarations.js";
 import { Type } from "./Type.js";
 import { objectInitializer } from "./objectInitializer.js";
 export class ListType extends Type {
@@ -26,7 +27,7 @@ export class ListType extends Type {
         return Maybe.empty();
     }
     get equalsFunction() {
-        return `((left, right) => purifyHelpers.Arrays.equals(left, right, ${this.itemType.equalsFunction}))`;
+        return `((left, right) => arrayEquals(left, right, ${this.itemType.equalsFunction}))`;
     }
     get jsonName() {
         return `readonly (${this.itemType.jsonName})[]`;
@@ -34,13 +35,6 @@ export class ListType extends Type {
     get name() {
         return `${this.mutable ? "" : "readonly "}${this.itemType.name}[]`;
     }
-    get useImports() {
-        const imports = this.itemType.useImports.concat();
-        if (this.identifierNodeKind === "NamedNode") {
-            imports.push(Import.SHA256);
-        }
-        return imports;
-    }
     fromJsonExpression({ variables, }) {
         return `${variables.value}.map(_item => (${this.itemType.fromJsonExpression({ variables: { value: "_item" } })}))`;
     }
@@ -62,6 +56,13 @@ export class ListType extends Type {
     jsonZodSchema(parameters) {
         return `${this.itemType.jsonZodSchema(parameters)}.array()`;
     }
+    snippetDeclarations(features) {
+        const snippetDeclarations = [];
+        if (features.has("equals")) {
+            snippetDeclarations.push(SnippetDeclarations.arrayEquals);
+        }
+        return snippetDeclarations;
+    }
     sparqlConstructTemplateTriples({ variables, context, }) {
         switch (context) {
             case "property":
@@ -170,7 +171,7 @@ export class ListType extends Type {
                         subject: restNVariable,
                         predicate: this.rdfjsTermExpression(rdf.first),
                         object: itemNVariable,
-                    })}] }`, ...this.itemType.sparqlConstructTemplateTriples({
+                    })}] }`, ...this.itemType.sparqlWherePatterns({
                         context: "type",
                         variables: {
                             subject: itemNVariable,
@@ -269,5 +270,12 @@ export class ListType extends Type {
   },
 ).listResource.identifier`;
     }
+    useImports(features) {
+        const imports = this.itemType.useImports(features).concat();
+        if (features.has("hash") && this.identifierNodeKind === "NamedNode") {
+            imports.push(Import.SHA256);
+        }
+        return imports;
+    }
 }
 //# sourceMappingURL=ListType.js.map

package/generators/ts/ObjectType.d.ts

@@ -1,7 +1,7 @@
 import type { NamedNode } from "@rdfjs/types";
 import { Maybe } from "purify-ts";
 import { type ClassDeclarationStructure, type InterfaceDeclarationStructure, type ModuleDeclarationStructure } from "ts-morph";
-import type { MintingStrategy, TsObjectDeclarationType } from "../../enums/index.js";
+import type { MintingStrategy, TsFeature, TsObjectDeclarationType } from "../../enums/index.js";
 import { DeclaredType } from "./DeclaredType.js";
 import type { IdentifierType } from "./IdentifierType.js";
 import { Import } from "./Import.js";
@@ -56,7 +56,6 @@ export declare class ObjectType extends DeclaredType {
     get ownProperties(): readonly ObjectType.Property[];
     get parentObjectTypes(): readonly ObjectType[];
     get properties(): readonly ObjectType.Property[];
-    get useImports(): readonly Import[];
     protected get thisVariable(): string;
     fromJsonExpression({ variables, }: Parameters<Type["fromJsonExpression"]>[0]): string;
     fromRdfExpression({ variables, }: Parameters<Type["fromRdfExpression"]>[0]): string;
@@ -74,10 +73,12 @@ export declare class ObjectType extends DeclaredType {
         readonly name: string;
         readonly named: boolean;
     };
+    snippetDeclarations(): 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[];
     protected ensureAtMostOneSuperObjectType(): void;
 }
 export declare namespace ObjectType {

package/generators/ts/ObjectType.js

@@ -11,6 +11,7 @@ import { StructureKind, } from "ts-morph";
 import { Memoize } from "typescript-memoize";
 import { DeclaredType } from "./DeclaredType.js";
 import { Import } from "./Import.js";
+import { SnippetDeclarations } from "./SnippetDeclarations.js";
 import * as _ObjectType from "./_ObjectType/index.js";
 import { IdentifierProperty, TypeDiscriminatorProperty, } from "./_ObjectType/index.js";
 import { objectInitializer } from "./objectInitializer.js";
@@ -58,9 +59,6 @@ export class ObjectType extends DeclaredType {
             return [];
         }
         const imports = this.properties.flatMap((property) => property.declarationImports);
-        if (this.features.has("equals")) {
-            imports.push(Import.PURIFY_HELPERS);
-        }
         if (this.features.has("fromJson") || this.features.has("jsonSchema")) {
             imports.push(Import.ZOD);
         }
@@ -69,7 +67,6 @@ export class ObjectType extends DeclaredType {
         }
         if (this.features.has("fromRdf") || this.features.has("toRdf")) {
             imports.push(Import.PURIFY);
-            imports.push(Import.PURIFY_HELPERS);
             imports.push(Import.RDFJS_RESOURCE);
         }
         if (this.features.has("sparql")) {
@@ -117,7 +114,7 @@ export class ObjectType extends DeclaredType {
     get equalsFunction() {
         switch (this.declarationType) {
             case "class":
-                return "purifyHelpers.Equatable.equals";
+                return "((left, right) => left.equals(right))";
             case "interface":
                 return `${this.name}.equals`;
             default:
@@ -152,7 +149,7 @@ export class ObjectType extends DeclaredType {
         if (this.features.has("fromJson")) {
             return `Parameters<typeof ${this.name}.fromJson>[0]`;
         }
-        throw new RangeError("jsonName called when neither fromJson nor toJson features are enabled");
+        throw new RangeError(`${this.name}: jsonName called when neither fromJson nor toJson features are enabled`);
     }
     get jsonUiSchemaFunctionName() {
         if (this.ancestorObjectTypes.length > 0 ||
@@ -194,9 +191,6 @@ export class ObjectType extends DeclaredType {
         }
         return properties;
     }
-    get useImports() {
-        return this.imports;
-    }
     get thisVariable() {
         switch (this.declarationType) {
             case "class":
@@ -244,6 +238,20 @@ export class ObjectType extends DeclaredType {
             named: this.identifierType.isNamedNodeKind,
         };
     }
+    snippetDeclarations() {
+        const snippetDeclarations = [];
+        if (this.features.has("equals")) {
+            snippetDeclarations.push(SnippetDeclarations.EqualsResult);
+        }
+        if ((this.features.has("fromJson") || this.features.has("fromRdf")) &&
+            this.parentObjectTypes.length > 0) {
+            snippetDeclarations.push(SnippetDeclarations.UnwrapR);
+        }
+        for (const property of this.ownProperties) {
+            snippetDeclarations.push(...property.snippetDeclarations);
+        }
+        return snippetDeclarations;
+    }
     sparqlConstructTemplateTriples({ context, variables, }) {
         switch (context) {
             case "property":
@@ -288,6 +296,9 @@ export class ObjectType extends DeclaredType {
                 return `${this.name}.toRdf(${variables.value}, { mutateGraph: ${variables.mutateGraph}, resourceSet: ${variables.resourceSet} })`;
         }
     }
+    useImports(_features) {
+        return this.imports;
+    }
     ensureAtMostOneSuperObjectType() {
         if (this.parentObjectTypes.length > 1) {
             throw new RangeError(`object type '${this.name}' has multiple super object types`);

package/generators/ts/ObjectUnionType.d.ts

@@ -34,7 +34,6 @@ export declare class ObjectUnionType extends DeclaredType {
     get equalsFunction(): string;
     get jsonName(): string;
     get mutable(): boolean;
-    get useImports(): readonly Import[];
     protected get thisVariable(): string;
     private get equalsFunctionDeclaration();
     private get fromJsonFunctionDeclaration();
@@ -53,6 +52,7 @@ export declare class ObjectUnionType extends DeclaredType {
     sparqlWherePatterns({ context, variables, }: Parameters<Type["sparqlWherePatterns"]>[0]): readonly string[];
     toJsonExpression({ variables, }: Parameters<Type["toJsonExpression"]>[0]): string;
     toRdfExpression({ variables, }: Parameters<Type["toRdfExpression"]>[0]): string;
+    useImports(): readonly Import[];
     private rdfjsResourceType;
 }
 //# sourceMappingURL=ObjectUnionType.d.ts.map

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(" ")}
   }
@@ -244,54 +243,22 @@ 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",
                 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({ ignoreRdfType: parameters?.ignoreRdfType, 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(", ")}];`,
                 ],
             },
@@ -301,16 +268,15 @@ return purifyHelpers.Equatable.strictEquals(left.type, right.type).chain(() => {
                 name: "sparqlWherePatterns",
                 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({ ignoreRdfType: parameters?.ignoreRdfType, 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" }];`,
@@ -456,6 +422,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