@shaclmate/compiler 2.0.17 → 2.0.19

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

@@ -10,44 +10,39 @@ export class IdentifierProperty extends Property {
     mutable = false;
     classDeclarationVisibility;
     identifierMintingStrategy;
-    lazyObjectTypeMutable;
     override;
-    constructor({ abstract, classDeclarationVisibility, lazyObjectTypeMutable, identifierMintingStrategy, override, ...superParameters }) {
+    constructor({ abstract, classDeclarationVisibility, identifierMintingStrategy, override, ...superParameters }) {
         super(superParameters);
         invariant(this.visibility === "public");
         this.abstract = abstract;
         this.classDeclarationVisibility = classDeclarationVisibility;
-        if (identifierMintingStrategy.isJust()) {
-            this.identifierMintingStrategy = identifierMintingStrategy.unsafeCoerce();
-        }
-        else if (this.type.nodeKinds.has("BlankNode")) {
-            this.identifierMintingStrategy = "blankNode";
-        }
-        else {
-            this.identifierMintingStrategy = "none";
-        }
-        this.lazyObjectTypeMutable = lazyObjectTypeMutable;
+        this.identifierMintingStrategy = identifierMintingStrategy;
         this.override = override;
     }
     get classGetAccessorDeclaration() {
         if (this.abstract) {
             return Maybe.empty();
         }
+        if (this.identifierMintingStrategy.isNothing()) {
+            return Maybe.empty();
+        }
+        let memoizeMintedIdentifier;
         let mintIdentifier;
-        switch (this.identifierMintingStrategy) {
+        switch (this.identifierMintingStrategy.unsafeCoerce()) {
             case "blankNode":
+                memoizeMintedIdentifier = true;
                 mintIdentifier = "dataFactory.blankNode()";
                 break;
-            case "none":
-                // If there's no minting strategy the identifier will be required by the constructor and assigned to a public property.
-                return Maybe.empty();
             case "sha256":
+                // If the object is mutable don't memoize the minted identifier, since the hash will change if the object mutates.
+                memoizeMintedIdentifier = !this.objectType.mutable();
                 mintIdentifier =
-                    "dataFactory.namedNode(`urn:shaclmate:object:${this.type}:${this.hash(sha256.create())}`)";
+                    "dataFactory.namedNode(`${this.identifierPrefix}${this.hashShaclProperties(sha256.create())}`)";
                 break;
             case "uuidv4":
+                memoizeMintedIdentifier = true;
                 mintIdentifier =
-                    "dataFactory.namedNode(`urn:shaclmate:object:${this.type}:${uuid.v4()}`)";
+                    "dataFactory.namedNode(`${this.identifierPrefix}${uuid.v4()}`)";
                 break;
         }
         return Maybe.of({
@@ -55,9 +50,9 @@ export class IdentifierProperty extends Property {
             name: this.name,
             returnType: this.type.name,
             statements: [
-                this.lazyObjectTypeMutable()
-                    ? `return (typeof this._${this.name} !== "undefined") ? this._${this.name} : ${mintIdentifier}`
-                    : `if (typeof this._${this.name} === "undefined") { this._${this.name} = ${mintIdentifier}; } return this._${this.name};`,
+                memoizeMintedIdentifier
+                    ? `if (typeof this._${this.name} === "undefined") { this._${this.name} = ${mintIdentifier}; } return this._${this.name};`
+                    : `return (typeof this._${this.name} !== "undefined") ? this._${this.name} : ${mintIdentifier}`,
             ],
         });
     }
@@ -78,24 +73,22 @@ export class IdentifierProperty extends Property {
         if (!this.classDeclarationVisibility.isJust()) {
             return Maybe.empty();
         }
-        switch (this.identifierMintingStrategy) {
-            case "none":
-                // Immutable, public identifier property, no getter
-                return Maybe.of({
-                    isReadonly: true,
-                    name: this.name,
-                    type: this.type.name,
-                });
-            default:
-                // Mutable _identifier property that will be lazily initialized by the getter to mint the identifier
-                return Maybe.of({
-                    name: `_${this.name}`,
-                    scope: this.classDeclarationVisibility
-                        .map(Property.visibilityToScope)
-                        .unsafeCoerce(),
-                    type: `${this.type.name} | undefined`,
-                });
+        if (this.identifierMintingStrategy.isJust()) {
+            // Mutable _identifier property that will be lazily initialized by the getter to mint the identifier
+            return Maybe.of({
+                name: `_${this.name}`,
+                scope: this.classDeclarationVisibility
+                    .map(Property.visibilityToScope)
+                    .unsafeCoerce(),
+                type: `${this.type.name} | undefined`,
+            });
         }
+        // Immutable, public identifier property, no getter
+        return Maybe.of({
+            isReadonly: true,
+            name: this.name,
+            type: this.type.name,
+        });
     }
     get constructorParametersPropertySignature() {
         if (this.objectType.declarationType === "class" && this.abstract) {
@@ -109,7 +102,7 @@ export class IdentifierProperty extends Property {
         }
         return Maybe.of({
             hasQuestionToken: this.objectType.declarationType === "class" &&
-                this.identifierMintingStrategy !== "none",
+                this.identifierMintingStrategy.isJust(),
             isReadonly: true,
             name: this.name,
             type: [...typeNames].sort().join(" | "),
@@ -119,30 +112,32 @@ export class IdentifierProperty extends Property {
         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;
-                case "uuidv4":
-                    imports.push(Import.UUID);
-                    break;
-            }
+            this.identifierMintingStrategy.ifJust((identifierMintingStrategy) => {
+                switch (identifierMintingStrategy) {
+                    case "sha256":
+                        imports.push(Import.SHA256);
+                        break;
+                    case "uuidv4":
+                        imports.push(Import.UUID);
+                        break;
+                }
+            });
         }
         return imports;
     }
     get interfacePropertySignature() {
-        return {
+        return Maybe.of({
             isReadonly: true,
             name: this.name,
             type: this.type.name,
-        };
+        });
     }
     get jsonPropertySignature() {
-        return {
+        return Maybe.of({
             isReadonly: true,
             name: "@id",
             type: "string",
-        };
+        });
     }
     get snippetDeclarations() {
         const snippetDeclarations = [];
@@ -194,20 +189,7 @@ export class IdentifierProperty extends Property {
         return [`const ${this.name} = ${variables.resource}.identifier`];
     }
     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 [];
-        }
+        return [`${variables.hasher}.update(${variables.value}.value);`];
     }
     interfaceConstructorStatements({ variables, }) {
         const typeConversions = this.type.conversions;
@@ -225,7 +207,7 @@ export class IdentifierProperty extends Property {
         return statements;
     }
     jsonUiSchemaElement({ variables, }) {
-        return Maybe.of(`{ label: "Identifier", scope: \`\${${variables.scopePrefix}}/properties/${this.jsonPropertySignature.name}\`, type: "Control" }`);
+        return Maybe.of(`{ label: "Identifier", scope: \`\${${variables.scopePrefix}}/properties/${this.jsonPropertySignature.unsafeCoerce().name}\`, type: "Control" }`);
     }
     jsonZodSchema({ variables, }) {
         let schema;
@@ -237,10 +219,10 @@ export class IdentifierProperty extends Property {
         else {
             schema = `${variables.zod}.string().min(1)`;
         }
-        return {
-            key: this.jsonPropertySignature.name,
+        return Maybe.of({
+            key: this.jsonPropertySignature.unsafeCoerce().name,
             schema,
-        };
+        });
     }
     sparqlConstructTemplateTriples() {
         return [];
@@ -261,10 +243,10 @@ export class IdentifierProperty extends Property {
             }
         });
         if (valueToNodeKinds.length === 1) {
-            return `"@id": ${valueToNodeKinds[0]}`;
+            return Maybe.of(`"@id": ${valueToNodeKinds[0]}`);
         }
         invariant(valueToNodeKinds.length === 2);
-        return `"@id": ${variables.value}.termType === "${nodeKinds[0]}" ? ${valueToNodeKinds[0]} : ${valueToNodeKinds[1]}`;
+        return Maybe.of(`"@id": ${variables.value}.termType === "${nodeKinds[0]}" ? ${valueToNodeKinds[0]} : ${valueToNodeKinds[1]}`);
     }
     toRdfStatements() {
         return [];

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

@@ -27,11 +27,11 @@ export declare abstract class Property<TypeT extends {
     /**
      * Signature of the property in an interface version of the object.
      */
-    abstract readonly interfacePropertySignature: OptionalKind<PropertySignatureStructure>;
+    abstract readonly interfacePropertySignature: Maybe<OptionalKind<PropertySignatureStructure>>;
     /**
      * Signature of the property when serialized to JSON (the type of toJsonObjectMember).
      */
-    abstract readonly jsonPropertySignature: OptionalKind<PropertySignatureStructure>;
+    abstract readonly jsonPropertySignature: Maybe<OptionalKind<PropertySignatureStructure>>;
     /**
      * Is the property reassignable?
      */
@@ -61,6 +61,7 @@ export declare abstract class Property<TypeT extends {
     protected readonly objectType: {
         readonly declarationType: TsObjectDeclarationType;
         readonly features: Set<TsFeature>;
+        readonly mutable: () => boolean;
     };
     constructor({ dataFactoryVariable, name, objectType, type, visibility, }: {
         dataFactoryVariable: string;
@@ -72,7 +73,7 @@ export declare abstract class Property<TypeT extends {
     /**
      * Imports this property requires when declared in an object.
      */
-    get declarationImports(): readonly Import[];
+    abstract get declarationImports(): readonly Import[];
     protected static visibilityToScope(visibility: PropertyVisibility): Scope | undefined;
     /**
      * Statements to assign the parameter of described by constructorParametersPropertySignature to a class member.
@@ -127,10 +128,10 @@ export declare abstract class Property<TypeT extends {
         variables: {
             zod: string;
         };
-    }): {
+    }): Maybe<{
         readonly key: string;
         readonly schema: string;
-    };
+    }>;
     /**
      * An array of SPARQL.js CONSTRUCT template triples for this property as strings (so they can incorporate runtime calls).
      */
@@ -156,7 +157,7 @@ export declare abstract class Property<TypeT extends {
         variables: {
             value: string;
         };
-    }): string;
+    }): Maybe<string>;
     /**
      * Statements to serialize this property to an RDF resource.
      */

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

@@ -22,12 +22,6 @@ export class Property {
         this.type = type;
         this.visibility = visibility;
     }
-    /**
-     * Imports this property requires when declared in an object.
-     */
-    get declarationImports() {
-        return [];
-    }
     static visibilityToScope(visibility) {
         switch (visibility) {
             case "private":

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

@@ -24,8 +24,8 @@ export declare class ShaclProperty extends Property<Type> {
     get constructorParametersPropertySignature(): Maybe<OptionalKind<PropertySignatureStructure>>;
     get declarationImports(): readonly Import[];
     get equalsFunction(): string;
-    get interfacePropertySignature(): OptionalKind<PropertySignatureStructure>;
-    get jsonPropertySignature(): OptionalKind<PropertySignatureStructure>;
+    get interfacePropertySignature(): Maybe<OptionalKind<PropertySignatureStructure>>;
+    get jsonPropertySignature(): Maybe<OptionalKind<PropertySignatureStructure>>;
     get snippetDeclarations(): readonly string[];
     private get declarationComment();
     private get pathExpression();
@@ -38,7 +38,7 @@ export declare class ShaclProperty extends Property<Type> {
     jsonZodSchema(parameters: Parameters<Property<Type>["jsonZodSchema"]>[0]): ReturnType<Property<Type>["jsonZodSchema"]>;
     sparqlConstructTemplateTriples({ variables, }: Parameters<Property<Type>["sparqlConstructTemplateTriples"]>[0]): readonly string[];
     sparqlWherePatterns({ variables, }: Parameters<Property<Type>["sparqlWherePatterns"]>[0]): readonly string[];
-    toJsonObjectMember(parameters: Parameters<Property<Type>["toJsonObjectMember"]>[0]): string;
+    toJsonObjectMember(parameters: Parameters<Property<Type>["toJsonObjectMember"]>[0]): Maybe<string>;
     toRdfStatements({ variables, }: Parameters<Property<Type>["toRdfStatements"]>[0]): readonly string[];
 }
 //# sourceMappingURL=ShaclProperty.d.ts.map

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

@@ -61,19 +61,19 @@ export class ShaclProperty extends Property {
         return this.type.equalsFunction;
     }
     get interfacePropertySignature() {
-        return {
+        return Maybe.of({
             isReadonly: !this.mutable,
             leadingTrivia: this.declarationComment,
             name: this.name,
             type: this.type.name,
-        };
+        });
     }
     get jsonPropertySignature() {
-        return {
+        return Maybe.of({
             isReadonly: true,
             name: this.name,
             type: this.type.jsonName,
-        };
+        });
     }
     get snippetDeclarations() {
         return this.type.snippetDeclarations(this.objectType.features);
@@ -142,10 +142,10 @@ export class ShaclProperty extends Property {
         this.comment.alt(this.description).ifJust((description) => {
             schema = `${schema}.describe(${JSON.stringify(description)})`;
         });
-        return {
+        return Maybe.of({
             key: this.name,
             schema,
-        };
+        });
     }
     sparqlConstructTemplateTriples({ variables, }) {
         const objectString = `\`\${${variables.variablePrefix}}${pascalCase(this.name)}\``;
@@ -172,7 +172,7 @@ export class ShaclProperty extends Property {
         });
     }
     toJsonObjectMember(parameters) {
-        return `${this.name}: ${this.type.toJsonExpression(parameters)}`;
+        return Maybe.of(`${this.name}: ${this.type.toJsonExpression(parameters)}`);
     }
     toRdfStatements({ variables, }) {
         return [

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

@@ -1,3 +1,4 @@
+import type { Import } from "generators/ts/Import.js";
 import { Maybe } from "purify-ts";
 import type { GetAccessorDeclarationStructure, OptionalKind, PropertyDeclarationStructure, PropertySignatureStructure } from "ts-morph";
 import { Property } from "./Property.js";
@@ -16,19 +17,20 @@ export declare class TypeDiscriminatorProperty extends Property<TypeDiscriminato
     get classGetAccessorDeclaration(): Maybe<OptionalKind<GetAccessorDeclarationStructure>>;
     get classPropertyDeclaration(): Maybe<OptionalKind<PropertyDeclarationStructure>>;
     get constructorParametersPropertySignature(): Maybe<OptionalKind<PropertySignatureStructure>>;
-    get interfacePropertySignature(): OptionalKind<PropertySignatureStructure>;
-    get jsonPropertySignature(): OptionalKind<PropertySignatureStructure>;
+    get declarationImports(): readonly Import[];
+    get interfacePropertySignature(): Maybe<OptionalKind<PropertySignatureStructure>>;
+    get jsonPropertySignature(): Maybe<OptionalKind<PropertySignatureStructure>>;
     get snippetDeclarations(): readonly string[];
     classConstructorStatements(): readonly string[];
     fromJsonStatements(): readonly string[];
     fromRdfStatements(): readonly string[];
-    hashStatements(): readonly string[];
+    hashStatements({ variables, }: Parameters<Property<TypeDiscriminatorProperty>["hashStatements"]>[0]): readonly string[];
     interfaceConstructorStatements(): readonly string[];
     jsonUiSchemaElement({ variables, }: Parameters<Property<TypeDiscriminatorProperty.Type>["jsonUiSchemaElement"]>[0]): Maybe<string>;
     jsonZodSchema({ variables, }: Parameters<Property<TypeDiscriminatorProperty.Type>["jsonZodSchema"]>[0]): ReturnType<Property<TypeDiscriminatorProperty.Type>["jsonZodSchema"]>;
     sparqlConstructTemplateTriples(): readonly string[];
     sparqlWherePatterns(): readonly string[];
-    toJsonObjectMember({ variables, }: Parameters<Property<TypeDiscriminatorProperty.Type>["toJsonObjectMember"]>[0]): string;
+    toJsonObjectMember({ variables, }: Parameters<Property<TypeDiscriminatorProperty.Type>["toJsonObjectMember"]>[0]): Maybe<string>;
     toRdfStatements(): readonly string[];
 }
 export declare namespace TypeDiscriminatorProperty {

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

@@ -42,19 +42,22 @@ export class TypeDiscriminatorProperty extends Property {
     get constructorParametersPropertySignature() {
         return Maybe.empty();
     }
+    get declarationImports() {
+        return [];
+    }
     get interfacePropertySignature() {
-        return {
+        return Maybe.of({
             isReadonly: true,
             name: this.name,
             type: this.type.name,
-        };
+        });
     }
     get jsonPropertySignature() {
-        return {
+        return Maybe.of({
             isReadonly: true,
             name: this.name,
             type: this.type.name,
-        };
+        });
     }
     get snippetDeclarations() {
         const snippetDeclarations = [];
@@ -74,8 +77,8 @@ export class TypeDiscriminatorProperty extends Property {
             ? [`const ${this.name} = "${this.value}" as const`]
             : [];
     }
-    hashStatements() {
-        return [];
+    hashStatements({ variables, }) {
+        return [`${variables.hasher}.update(${variables.value});`];
     }
     interfaceConstructorStatements() {
         return !this.abstract
@@ -87,12 +90,12 @@ export class TypeDiscriminatorProperty extends Property {
         return Maybe.of(`{ rule: { condition: { schema: { const: "${this.value}" }, scope: ${scope} }, effect: "HIDE" }, scope: ${scope}, type: "Control" }`);
     }
     jsonZodSchema({ variables, }) {
-        return {
+        return Maybe.of({
             key: this.name,
             schema: this.type.values.length > 1
                 ? `${variables.zod}.enum(${JSON.stringify(this.type.values)})`
                 : `${variables.zod}.literal("${this.type.values[0]}")`,
-        };
+        });
     }
     sparqlConstructTemplateTriples() {
         return [];
@@ -101,7 +104,7 @@ export class TypeDiscriminatorProperty extends Property {
         return [];
     }
     toJsonObjectMember({ variables, }) {
-        return `${this.name}: ${variables.value}`;
+        return Maybe.of(`${this.name}: ${variables.value}`);
     }
     toRdfStatements() {
         return [];

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

@@ -2,7 +2,7 @@ import { Maybe } from "purify-ts";
 import { StructureKind, } from "ts-morph";
 import { tsComment } from "../tsComment.js";
 import { equalsFunctionOrMethodDeclaration } from "./equalsFunctionOrMethodDeclaration.js";
-import { hashFunctionOrMethodDeclaration } from "./hashFunctionOrMethodDeclaration.js";
+import { hashFunctionOrMethodDeclarations } from "./hashFunctionOrMethodDeclarations.js";
 import { toJsonFunctionOrMethodDeclaration } from "./toJsonFunctionOrMethodDeclaration.js";
 import { toRdfFunctionOrMethodDeclaration } from "./toRdfFunctionOrMethodDeclaration.js";
 function constructorDeclaration() {
@@ -72,7 +72,7 @@ export function classDeclaration() {
         leadingTrivia: this.comment.alt(this.label).map(tsComment).extract(),
         methods: [
             ...equalsMethodDeclaration.bind(this)().toList(),
-            ...hashMethodDeclaration.bind(this)().toList(),
+            ...hashMethodDeclarations.bind(this)(),
             ...toJsonMethodDeclaration.bind(this)().toList(),
             ...toRdfMethodDeclaration.bind(this)().toList(),
             ...toStringMethodDeclaration.bind(this)().toList(),
@@ -84,13 +84,8 @@ export function classDeclaration() {
 function equalsMethodDeclaration() {
     return equalsFunctionOrMethodDeclaration.bind(this)();
 }
-function hashMethodDeclaration() {
-    return hashFunctionOrMethodDeclaration
-        .bind(this)()
-        .map((hashFunctionOrMethodDeclaration) => ({
-        ...hashFunctionOrMethodDeclaration,
-        name: "hash",
-    }));
+function hashMethodDeclarations() {
+    return hashFunctionOrMethodDeclarations.bind(this)();
 }
 function toJsonMethodDeclaration() {
     return toJsonFunctionOrMethodDeclaration

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

@@ -15,9 +15,9 @@ export function fromJsonFunctionDeclarations() {
     const propertiesFromJsonFunctionStatements = [];
     propertiesFromJsonFunctionStatements.push(`const _jsonSafeParseResult = ${this.jsonZodSchemaFunctionName}().safeParse(_json);`, "if (!_jsonSafeParseResult.success) { return purify.Left(_jsonSafeParseResult.error); }", `const ${variables.jsonObject} = _jsonSafeParseResult.data;`);
     this.parentObjectTypes.forEach((parentObjectType, parentObjectTypeI) => {
-        propertiesFromJsonFunctionStatements.push(`const _super${parentObjectTypeI}Either = ${parentObjectType.name}.propertiesFromJson(${variables.jsonObject});`, `if (_super${parentObjectTypeI}Either.isLeft()) { return _super${parentObjectTypeI}Either; }`, `const _super${parentObjectTypeI} = _super${parentObjectTypeI}Either.unsafeCoerce()`);
+        propertiesFromJsonFunctionStatements.push(`const _super${parentObjectTypeI}Either = ${parentObjectType.name}._propertiesFromJson(${variables.jsonObject});`, `if (_super${parentObjectTypeI}Either.isLeft()) { return _super${parentObjectTypeI}Either; }`, `const _super${parentObjectTypeI} = _super${parentObjectTypeI}Either.unsafeCoerce()`);
         initializers.push(`..._super${parentObjectTypeI}`);
-        propertiesFromJsonFunctionReturnType.push(`UnwrapR<ReturnType<typeof ${parentObjectType.name}.propertiesFromJson>>`);
+        propertiesFromJsonFunctionReturnType.push(`UnwrapR<ReturnType<typeof ${parentObjectType.name}._propertiesFromJson>>`);
     });
     for (const property of this.properties) {
         const propertyFromJsonStatements = property.fromJsonStatements({
@@ -37,7 +37,7 @@ export function fromJsonFunctionDeclarations() {
     fromJsonFunctionDeclarations.push({
         isExported: true,
         kind: StructureKind.Function,
-        name: "propertiesFromJson",
+        name: "_propertiesFromJson",
         parameters: [
             {
                 name: "_json",
@@ -52,11 +52,11 @@ export function fromJsonFunctionDeclarations() {
         switch (this.declarationType) {
             case "class":
                 fromJsonStatements = [
-                    `return ${this.name}.propertiesFromJson(json).map(properties => new ${this.name}(properties));`,
+                    `return ${this.name}._propertiesFromJson(json).map(properties => new ${this.name}(properties));`,
                 ];
                 break;
             case "interface":
-                fromJsonStatements = [`return ${this.name}.propertiesFromJson(json);`];
+                fromJsonStatements = [`return ${this.name}._propertiesFromJson(json);`];
                 break;
         }
         fromJsonFunctionDeclarations.push({

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

@@ -18,9 +18,9 @@ export function fromRdfFunctionDeclarations() {
     const propertiesFromRdfFunctionReturnType = [];
     const propertiesFromRdfFunctionStatements = [];
     this.parentObjectTypes.forEach((parentObjectType, parentObjectTypeI) => {
-        propertiesFromRdfFunctionStatements.push(`const _super${parentObjectTypeI}Either = ${parentObjectType.name}.propertiesFromRdf({ ...${variables.context}, ignoreRdfType: true, languageIn: ${variables.languageIn}, resource: ${variables.resource} });`, `if (_super${parentObjectTypeI}Either.isLeft()) { return _super${parentObjectTypeI}Either; }`, `const _super${parentObjectTypeI} = _super${parentObjectTypeI}Either.unsafeCoerce()`);
+        propertiesFromRdfFunctionStatements.push(`const _super${parentObjectTypeI}Either = ${parentObjectType.name}._propertiesFromRdf({ ...${variables.context}, ignoreRdfType: true, languageIn: ${variables.languageIn}, resource: ${variables.resource} });`, `if (_super${parentObjectTypeI}Either.isLeft()) { return _super${parentObjectTypeI}Either; }`, `const _super${parentObjectTypeI} = _super${parentObjectTypeI}Either.unsafeCoerce()`);
         initializers.push(`..._super${parentObjectTypeI}`);
-        propertiesFromRdfFunctionReturnType.push(`UnwrapR<ReturnType<typeof ${parentObjectType.name}.propertiesFromRdf>>`);
+        propertiesFromRdfFunctionReturnType.push(`UnwrapR<ReturnType<typeof ${parentObjectType.name}._propertiesFromRdf>>`);
     });
     this.fromRdfType.ifJust((rdfType) => {
         propertiesFromRdfFunctionStatements.push(`if (!${variables.ignoreRdfType} && !${variables.resource}.isInstanceOf(${this.rdfjsTermExpression(rdfType)})) { return purify.Left(new rdfjsResource.Resource.ValueError(${objectInitializer({ focusResource: variables.resource, message: `\`\${rdfjsResource.Resource.Identifier.toString(${variables.resource}.identifier)} has unexpected RDF type\``, predicate: this.rdfjsTermExpression(rdfType) })})); }`);
@@ -48,7 +48,7 @@ export function fromRdfFunctionDeclarations() {
     fromRdfFunctionDeclarations.push({
         isExported: true,
         kind: StructureKind.Function,
-        name: "propertiesFromRdf",
+        name: "_propertiesFromRdf",
         parameters: [
             {
                 name: `{ ignoreRdfType: ${variables.ignoreRdfType}, languageIn: ${variables.languageIn}, resource: ${variables.resource},\n// @ts-ignore\n...${variables.context} }`,
@@ -63,12 +63,12 @@ export function fromRdfFunctionDeclarations() {
         switch (this.declarationType) {
             case "class":
                 fromRdfStatements = [
-                    `return ${this.name}.propertiesFromRdf(parameters).map(properties => new ${this.name}(properties));`,
+                    `return ${this.name}._propertiesFromRdf(parameters).map(properties => new ${this.name}(properties));`,
                 ];
                 break;
             case "interface":
                 fromRdfStatements = [
-                    `return ${this.name}.propertiesFromRdf(parameters);`,
+                    `return ${this.name}._propertiesFromRdf(parameters);`,
                 ];
                 break;
         }
@@ -79,7 +79,7 @@ export function fromRdfFunctionDeclarations() {
             parameters: [
                 {
                     name: "parameters",
-                    type: `Parameters<typeof ${this.name}.propertiesFromRdf>[0]`,
+                    type: `Parameters<typeof ${this.name}._propertiesFromRdf>[0]`,
                 },
             ],
             returnType: `purify.Either<rdfjsResource.Resource.ValueError, ${this.name}>`,

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

@@ -0,0 +1,4 @@
+import { type FunctionDeclarationStructure } from "ts-morph";
+import type { ObjectType } from "../ObjectType.js";
+export declare function hashFunctionDeclarations(this: ObjectType): readonly FunctionDeclarationStructure[];
+//# sourceMappingURL=hashFunctionDeclarations.d.ts.map

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

@@ -0,0 +1,18 @@
+import { StructureKind } from "ts-morph";
+import { hashFunctionOrMethodDeclarations } from "./hashFunctionOrMethodDeclarations.js";
+export function hashFunctionDeclarations() {
+    if (this.declarationType !== "interface") {
+        return [];
+    }
+    if (this.extern) {
+        return [];
+    }
+    return hashFunctionOrMethodDeclarations
+        .bind(this)()
+        .map((hashFunctionOrMethodDeclaration) => ({
+        ...hashFunctionOrMethodDeclaration,
+        isExported: true,
+        kind: StructureKind.Function,
+    }));
+}
+//# sourceMappingURL=hashFunctionDeclarations.js.map

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

@@ -0,0 +1,13 @@
+import { type OptionalKind, type ParameterDeclarationStructure, Scope, type TypeParameterDeclarationStructure } from "ts-morph";
+import { ObjectType } from "../ObjectType.js";
+export declare const hasherTypeConstraint = "{ update: (message: string | number[] | ArrayBuffer | Uint8Array) => void; }";
+export declare function hashFunctionOrMethodDeclarations(this: ObjectType): readonly {
+    hasOverrideKeyword?: boolean;
+    name: string;
+    parameters: OptionalKind<ParameterDeclarationStructure>[];
+    returnType: string;
+    scope?: Scope;
+    statements: string[];
+    typeParameters: OptionalKind<TypeParameterDeclarationStructure>[];
+}[];
+//# sourceMappingURL=hashFunctionOrMethodDeclarations.d.ts.map