@shaclmate/compiler 2.0.14 → 2.0.16

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

@@ -214,8 +214,8 @@ export class TypeFactory {
             dataFactoryVariable: this.dataFactoryVariable,
             defaultValue: Maybe.empty(),
             hasValues: [],
-            in_: [],
-            nodeKinds: astType.nodeKinds,
+            in_: astType.identifierIn,
+            nodeKinds: astType.identifierKinds,
         });
         const objectType = new ObjectType({
             abstract: astType.abstract,
@@ -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.
@@ -253,10 +253,13 @@ export class TypeFactory {
                     abstract: astType.abstract,
                     classDeclarationVisibility: identifierPropertyClassDeclarationVisibility,
                     dataFactoryVariable: this.dataFactoryVariable,
-                    mintingStrategy: astType.mintingStrategy,
+                    identifierMintingStrategy: astType.identifierMintingStrategy,
                     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,
@@ -289,14 +295,14 @@ export class TypeFactory {
                 }
                 return properties.sort((left, right) => left.name.localeCompare(right.name));
             },
-            mintingStrategy: astType.mintingStrategy,
+            mintingStrategy: astType.identifierMintingStrategy,
             name: tsName(astType.name),
             toRdfTypes: astType.toRdfTypes,
         });
         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 { IdentifierMintingStrategy, 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 identifierMintingStrategy;
     private readonly lazyObjectTypeMutable;
-    private readonly mintingStrategy;
-    private readonly objectTypeDeclarationType;
     private readonly override;
-    constructor({ abstract, classDeclarationVisibility, lazyObjectTypeMutable, mintingStrategy, objectTypeDeclarationType, override, ...superParameters }: {
+    constructor({ abstract, classDeclarationVisibility, lazyObjectTypeMutable, identifierMintingStrategy, override, ...superParameters }: {
         abstract: boolean;
         classDeclarationVisibility: Maybe<PropertyVisibility>;
         lazyObjectTypeMutable: () => boolean;
-        mintingStrategy: Maybe<MintingStrategy>;
-        objectTypeDeclarationType: TsObjectDeclarationType;
+        identifierMintingStrategy: Maybe<IdentifierMintingStrategy>;
         override: boolean;
         type: IdentifierType;
     } & ConstructorParameters<typeof Property>[0]);
@@ -28,10 +26,11 @@ 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[];
-    hashStatements(): readonly string[];
+    hashStatements({ variables, }: Parameters<Property<IdentifierType>["hashStatements"]>[0]): readonly string[];
     interfaceConstructorStatements({ variables, }: Parameters<Property<IdentifierType>["interfaceConstructorStatements"]>[0]): readonly string[];
     jsonUiSchemaElement({ variables, }: Parameters<Property<IdentifierType>["jsonUiSchemaElement"]>[0]): Maybe<string>;
     jsonZodSchema({ variables, }: Parameters<Property<IdentifierType>["jsonZodSchema"]>[0]): ReturnType<Property<IdentifierType>["jsonZodSchema"]>;

package/generators/ts/_ObjectType/IdentifierProperty.js

@@ -1,25 +1,26 @@
+import { rdf } from "@tpluscode/rdf-ns-builders";
 import { Maybe } from "purify-ts";
 import { invariant } from "ts-invariant";
 import { Import } from "../Import.js";
+import { SnippetDeclarations } from "../SnippetDeclarations.js";
 import { Property } from "./Property.js";
 export class IdentifierProperty extends Property {
-    constructor({ abstract, classDeclarationVisibility, lazyObjectTypeMutable, mintingStrategy, objectTypeDeclarationType, override, ...superParameters }) {
+    constructor({ abstract, classDeclarationVisibility, lazyObjectTypeMutable, identifierMintingStrategy, override, ...superParameters }) {
         super(superParameters);
-        this.equalsFunction = "purifyHelpers.Equatable.booleanEquals";
+        this.equalsFunction = "booleanEquals";
         this.mutable = false;
         invariant(this.visibility === "public");
         this.abstract = abstract;
         this.classDeclarationVisibility = classDeclarationVisibility;
-        if (mintingStrategy.isJust()) {
-            this.mintingStrategy = mintingStrategy.unsafeCoerce();
+        if (identifierMintingStrategy.isJust()) {
+            this.identifierMintingStrategy = identifierMintingStrategy.unsafeCoerce();
         }
         else if (this.type.nodeKinds.has("BlankNode")) {
-            this.mintingStrategy = "blankNode";
+            this.identifierMintingStrategy = "blankNode";
         }
         else {
-            this.mintingStrategy = "none";
+            this.identifierMintingStrategy = "none";
         }
-        this.objectTypeDeclarationType = objectTypeDeclarationType;
         this.lazyObjectTypeMutable = lazyObjectTypeMutable;
         this.override = override;
     }
@@ -28,7 +29,7 @@ export class IdentifierProperty extends Property {
             return Maybe.empty();
         }
         let mintIdentifier;
-        switch (this.mintingStrategy) {
+        switch (this.identifierMintingStrategy) {
             case "blankNode":
                 mintIdentifier = "dataFactory.blankNode()";
                 break;
@@ -72,10 +73,11 @@ export class IdentifierProperty extends Property {
         if (!this.classDeclarationVisibility.isJust()) {
             return Maybe.empty();
         }
-        switch (this.mintingStrategy) {
+        switch (this.identifierMintingStrategy) {
             case "none":
                 // Immutable, public identifier property, no getter
                 return Maybe.of({
+                    isReadonly: true,
                     name: this.name,
                     type: this.type.name,
                 });
@@ -91,21 +93,28 @@ export class IdentifierProperty extends Property {
         }
     }
     get constructorParametersPropertySignature() {
-        if (this.objectTypeDeclarationType === "class" && this.abstract) {
+        if (this.objectType.declarationType === "class" && this.abstract) {
             return Maybe.empty();
         }
+        const typeNames = new Set(); // Remove duplicates with a set
+        for (const conversion of this.type.conversions) {
+            if (conversion.sourceTypeName !== "undefined") {
+                typeNames.add(conversion.sourceTypeName);
+            }
+        }
         return Maybe.of({
-            hasQuestionToken: this.objectTypeDeclarationType === "class" &&
-                this.mintingStrategy !== "none",
+            hasQuestionToken: this.objectType.declarationType === "class" &&
+                this.identifierMintingStrategy !== "none",
             isReadonly: true,
             name: this.name,
-            type: this.type.name,
+            type: [...typeNames].sort().join(" | "),
         });
     }
     get declarationImports() {
-        const imports = this.type.useImports.concat();
-        if (this.objectTypeDeclarationType === "class") {
-            switch (this.mintingStrategy) {
+        const imports = this.type.useImports().concat();
+        if (this.objectType.features.has("hash") &&
+            this.objectType.declarationType === "class") {
+            switch (this.identifierMintingStrategy) {
                 case "sha256":
                     imports.push(Import.SHA256);
                     break;
@@ -130,15 +139,38 @@ export class IdentifierProperty extends Property {
             type: "string",
         };
     }
+    get snippetDeclarations() {
+        const snippetDeclarations = [];
+        if (this.objectType.features.has("equals")) {
+            snippetDeclarations.push(SnippetDeclarations.booleanEquals);
+        }
+        return snippetDeclarations;
+    }
     classConstructorStatements({ variables, }) {
         if (this.abstract) {
             return [];
         }
-        return this.classPropertyDeclaration
-            .map((classPropertyDeclaration) => [
-            `this.${classPropertyDeclaration.name} = ${variables.parameter};`,
-        ])
-            .orDefault([]);
+        if (this.classPropertyDeclaration.isNothing()) {
+            return [];
+        }
+        const classPropertyDeclaration = this.classPropertyDeclaration.unsafeCoerce();
+        const typeConversions = this.type.conversions;
+        if (typeConversions.length === 1) {
+            return [
+                `this.${classPropertyDeclaration.name} = ${variables.parameter};`,
+            ];
+        }
+        const statements = [];
+        for (const conversion of this.type.conversions) {
+            if (conversion.sourceTypeName !== "undefined") {
+                statements.push(`if (${conversion.sourceTypeCheckExpression(variables.parameter)}) { this.${classPropertyDeclaration.name} = ${conversion.conversionExpression(variables.parameter)}; }`);
+            }
+        }
+        if (!classPropertyDeclaration.hasQuestionToken) {
+            // We shouldn't need this else, since the parameter now has the never type, but have to add it to appease the TypeScript compiler
+            statements.push(`{ this.${classPropertyDeclaration.name} =( ${variables.parameter}) as never;\n }`);
+        }
+        return [statements.join(" else ")];
     }
     fromJsonStatements({ variables, }) {
         return [
@@ -146,21 +178,63 @@ export class IdentifierProperty extends Property {
         ];
     }
     fromRdfStatements({ variables, }) {
+        if (this.type.in_.length > 0 && this.type.isNamedNodeKind) {
+            // Treat sh:in as a union of the IRIs
+            // rdfjs.NamedNode<"http://example.com/1" | "http://example.com/2">
+            return [
+                `let ${this.name}: ${this.type.name};`,
+                `switch (${variables.resource}.identifier.value) { ${this.type.in_.map((iri) => `case "${iri.value}": ${this.name} = ${this.rdfjsTermExpression(iri)}; break;`).join(" ")} default: return purify.Left(new rdfjsResource.Resource.MistypedValueError({ actualValue: ${variables.resource}.identifier, expectedValueType: ${JSON.stringify(this.type.name)}, focusResource: ${variables.resource}, predicate: ${this.rdfjsTermExpression(rdf.subject)} })); }`,
+            ];
+        }
         return [`const ${this.name} = ${variables.resource}.identifier`];
     }
-    hashStatements() {
-        return [];
+    hashStatements({ variables, }) {
+        if (this.abstract) {
+            // Identifier will only be hashed by a concrete class.
+            return [];
+        }
+        switch (this.identifierMintingStrategy) {
+            case "blankNode":
+            case "none":
+            case "uuidv4":
+                // The identifier minting won't call hash, so we should hash the identifier.
+                return [`${variables.hasher}.update(${variables.value}.value);`];
+            case "sha256":
+                // The identifier minting will call hash, so we can't hash the identifier.
+                return [];
+        }
     }
     interfaceConstructorStatements({ variables, }) {
-        return [`const ${this.name} = ${variables.parameter}`];
+        const typeConversions = this.type.conversions;
+        if (typeConversions.length === 1) {
+            return [`const ${this.name} = ${variables.parameter};`];
+        }
+        const statements = [`let ${this.name}: ${this.type.name};`];
+        const conversionBranches = [];
+        for (const conversion of this.type.conversions) {
+            conversionBranches.push(`if (${conversion.sourceTypeCheckExpression(variables.parameter)}) { ${this.name} = ${conversion.conversionExpression(variables.parameter)}; }`);
+        }
+        // We shouldn't need this else, since the parameter now has the never type, but have to add it to appease the TypeScript compiler
+        conversionBranches.push(`{ ${this.name} =( ${variables.parameter}) as never;\n }`);
+        statements.push(conversionBranches.join(" else "));
+        return statements;
     }
     jsonUiSchemaElement({ variables, }) {
         return Maybe.of(`{ label: "Identifier", scope: \`\${${variables.scopePrefix}}/properties/${this.jsonPropertySignature.name}\`, type: "Control" }`);
     }
     jsonZodSchema({ variables, }) {
+        let schema;
+        if (this.type.in_.length > 0 && this.type.isNamedNodeKind) {
+            // Treat sh:in as a union of the IRIs
+            // rdfjs.NamedNode<"http://example.com/1" | "http://example.com/2">
+            schema = `${variables.zod}.enum(${JSON.stringify(this.type.in_.map((iri) => iri.value))})`;
+        }
+        else {
+            schema = `${variables.zod}.string().min(1)`;
+        }
         return {
             key: this.jsonPropertySignature.name,
-            schema: `${variables.zod}.string().min(1)`,
+            schema,
         };
     }
     sparqlConstructTemplateTriples() {

package/generators/ts/_ObjectType/Property.d.ts

@@ -1,7 +1,7 @@
 import type { BlankNode, Literal, NamedNode, Variable } from "@rdfjs/types";
 import type { Maybe } from "purify-ts";
 import { type GetAccessorDeclarationStructure, type OptionalKind, type PropertyDeclarationStructure, type PropertySignatureStructure, Scope } from "ts-morph";
-import type { PropertyVisibility } from "../../../enums/index.js";
+import type { PropertyVisibility, TsFeature, TsObjectDeclarationType } from "../../../enums/index.js";
 import type { Import } from "../Import.js";
 import type { Type } from "../Type.js";
 export declare abstract class Property<TypeT extends {
@@ -21,7 +21,7 @@ export declare abstract class Property<TypeT extends {
      */
     abstract readonly constructorParametersPropertySignature: Maybe<OptionalKind<PropertySignatureStructure>>;
     /**
-     * Function declaration that takes two values of the property and compares them, returning and purifyHelpers.Equatable.EqualsResult.
+     * Function declaration that takes two values of the property and compares them, returning and EqualsResult.
      */
     abstract readonly equalsFunction: string;
     /**
@@ -40,6 +40,15 @@ export declare abstract class Property<TypeT extends {
      * TypeScript identifier-safe name of the property.
      */
     readonly name: string;
+    /**
+     * Reusable function, type, and other declarations that are not particular to this property but that property-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.
+     */
+    abstract readonly snippetDeclarations: readonly string[];
     /**
      * Property type
   .   */
@@ -49,9 +58,14 @@ export declare abstract class Property<TypeT extends {
      */
     readonly visibility: PropertyVisibility;
     protected readonly dataFactoryVariable: string;
-    constructor({ dataFactoryVariable, name, type, visibility, }: {
+    protected readonly objectType: {
+        readonly declarationType: TsObjectDeclarationType;
+        readonly features: Set<TsFeature>;
+    };
+    constructor({ dataFactoryVariable, name, objectType, type, visibility, }: {
         dataFactoryVariable: string;
         name: string;
+        objectType: Property<TypeT>["objectType"];
         type: TypeT;
         visibility: PropertyVisibility;
     });

package/generators/ts/_ObjectType/Property.js

@@ -1,9 +1,10 @@
 import { Scope, } from "ts-morph";
 import { rdfjsTermExpression } from "./rdfjsTermExpression.js";
 export class Property {
-    constructor({ dataFactoryVariable, name, type, visibility, }) {
+    constructor({ dataFactoryVariable, name, objectType, type, visibility, }) {
         this.dataFactoryVariable = dataFactoryVariable;
         this.name = name;
+        this.objectType = objectType;
         this.type = type;
         this.visibility = visibility;
     }

package/generators/ts/_ObjectType/ShaclProperty.d.ts

@@ -26,6 +26,7 @@ export declare class ShaclProperty extends Property<Type> {
     get equalsFunction(): string;
     get interfacePropertySignature(): OptionalKind<PropertySignatureStructure>;
     get jsonPropertySignature(): OptionalKind<PropertySignatureStructure>;
+    get snippetDeclarations(): readonly string[];
     private get declarationComment();
     private get pathExpression();
     classConstructorStatements({ variables, }: Parameters<Property<Type>["classConstructorStatements"]>[0]): readonly string[];

package/generators/ts/_ObjectType/ShaclProperty.js

@@ -50,7 +50,7 @@ export class ShaclProperty extends Property {
         });
     }
     get declarationImports() {
-        return this.type.useImports;
+        return this.type.useImports(this.objectType.features);
     }
     get equalsFunction() {
         return this.type.equalsFunction;
@@ -70,6 +70,9 @@ export class ShaclProperty extends Property {
             type: this.type.jsonName,
         };
     }
+    get snippetDeclarations() {
+        return this.type.snippetDeclarations(this.objectType.features);
+    }
     get declarationComment() {
         return this.comment
             .alt(this.description)

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

@@ -1,17 +1,14 @@
 import { Maybe } from "purify-ts";
 import type { GetAccessorDeclarationStructure, OptionalKind, PropertyDeclarationStructure, PropertySignatureStructure } from "ts-morph";
-import type { TsObjectDeclarationType } from "../../../enums/index.js";
 import { Property } from "./Property.js";
 export declare class TypeDiscriminatorProperty extends Property<TypeDiscriminatorProperty.Type> {
-    readonly equalsFunction = "purifyHelpers.Equatable.strictEquals";
+    readonly equalsFunction = "strictEquals";
     readonly mutable = false;
     readonly value: string;
     private readonly abstract;
-    private readonly objectTypeDeclarationType;
     private readonly override;
-    constructor({ abstract, objectTypeDeclarationType, override, type, value, ...superParameters }: {
+    constructor({ abstract, override, type, value, ...superParameters }: {
         abstract: boolean;
-        objectTypeDeclarationType: TsObjectDeclarationType;
         override: boolean;
         type: TypeDiscriminatorProperty.Type;
         value: string;
@@ -21,6 +18,7 @@ export declare class TypeDiscriminatorProperty extends Property<TypeDiscriminato
     get constructorParametersPropertySignature(): Maybe<OptionalKind<PropertySignatureStructure>>;
     get interfacePropertySignature(): OptionalKind<PropertySignatureStructure>;
     get jsonPropertySignature(): OptionalKind<PropertySignatureStructure>;
+    get snippetDeclarations(): readonly string[];
     classConstructorStatements(): readonly string[];
     fromJsonStatements(): readonly string[];
     fromRdfStatements(): readonly string[];