@shaclmate/compiler 2.0.18 → 2.0.19

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

@@ -0,0 +1,97 @@
+import { Scope, } from "ts-morph";
+import { ObjectType } from "../ObjectType.js";
+const hasherVariable = "_hasher";
+export const hasherTypeConstraint = "{ update: (message: string | number[] | ArrayBuffer | Uint8Array) => void; }";
+export function hashFunctionOrMethodDeclarations() {
+    if (!this.features.has("hash")) {
+        return [];
+    }
+    const hashOwnShaclPropertiesStatements = this.ownShaclProperties.flatMap((property) => property.hashStatements({
+        depth: 0,
+        variables: {
+            hasher: hasherVariable,
+            value: `${this.thisVariable}.${property.name}`,
+        },
+    }));
+    if (this.declarationType === "class" &&
+        this.parentObjectTypes.length > 0 &&
+        hashOwnShaclPropertiesStatements.length === 0) {
+        // If there's a parent class and no hash statements in this class, can skip overriding hash
+        return [];
+    }
+    const parameters = [];
+    if (this.declarationType === "interface") {
+        parameters.push({
+            name: this.thisVariable,
+            type: this.name,
+        });
+    }
+    parameters.push({
+        name: hasherVariable,
+        type: "HasherT",
+    });
+    const hashShaclPropertiesStatements = [];
+    let hasOverrideKeyword = false;
+    if (this.parentObjectTypes.length > 0) {
+        switch (this.declarationType) {
+            case "class": {
+                hashShaclPropertiesStatements.push(`super.hashShaclProperties(${hasherVariable});`);
+                hasOverrideKeyword = true;
+                break;
+            }
+            case "interface": {
+                for (const parentObjectType of this.parentObjectTypes) {
+                    hashShaclPropertiesStatements.push(`${parentObjectType.name}.${parentObjectType.hashShaclPropertiesFunctionName}(${this.thisVariable}, ${hasherVariable});`);
+                }
+                break;
+            }
+        }
+    }
+    hashShaclPropertiesStatements.push(...hashOwnShaclPropertiesStatements);
+    const returnType = "HasherT";
+    const typeParameters = [
+        {
+            name: "HasherT",
+            constraint: hasherTypeConstraint,
+        },
+    ];
+    return [
+        {
+            hasOverrideKeyword,
+            name: this.declarationType === "class" ? "hash" : this.hashFunctionName,
+            parameters,
+            returnType,
+            statements: [
+                ...this.ownProperties
+                    .filter((property) => !(property instanceof ObjectType.ShaclProperty))
+                    .flatMap((property) => property.hashStatements({
+                    depth: 0,
+                    variables: {
+                        hasher: hasherVariable,
+                        value: `${this.thisVariable}.${property.name}`,
+                    },
+                })),
+                this.declarationType === "class"
+                    ? `this.hashShaclProperties(${hasherVariable});`
+                    : `${this.name}.${this.hashShaclPropertiesFunctionName}(${this.thisVariable}, ${hasherVariable});`,
+                `return ${hasherVariable};`,
+            ],
+            typeParameters,
+        },
+        {
+            hasOverrideKeyword,
+            name: this.declarationType === "class"
+                ? "hashShaclProperties"
+                : this.hashShaclPropertiesFunctionName,
+            parameters,
+            returnType,
+            scope: this.declarationType === "class" ? Scope.Protected : undefined,
+            statements: [
+                ...hashShaclPropertiesStatements,
+                `return ${hasherVariable};`,
+            ],
+            typeParameters,
+        },
+    ];
+}
+//# sourceMappingURL=hashFunctionOrMethodDeclarations.js.map

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

@@ -4,7 +4,8 @@ export * from "./equalsFunctionDeclaration.js";
 export * from "./fromJsonFunctionDeclarations.js";
 export * from "./fromRdfFunctionDeclarations.js";
 export * from "./fromRdfTypeVariableStatement.js";
-export * from "./hashFunctionDeclaration.js";
+export * from "./hashFunctionDeclarations.js";
+export * from "./IdentifierPrefixProperty.js";
 export * from "./IdentifierProperty.js";
 export * from "./interfaceDeclaration.js";
 export * from "./jsonSchemaFunctionDeclaration.js";

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

@@ -4,7 +4,8 @@ export * from "./equalsFunctionDeclaration.js";
 export * from "./fromJsonFunctionDeclarations.js";
 export * from "./fromRdfFunctionDeclarations.js";
 export * from "./fromRdfTypeVariableStatement.js";
-export * from "./hashFunctionDeclaration.js";
+export * from "./hashFunctionDeclarations.js";
+export * from "./IdentifierPrefixProperty.js";
 export * from "./IdentifierProperty.js";
 export * from "./interfaceDeclaration.js";
 export * from "./jsonSchemaFunctionDeclaration.js";

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

@@ -8,7 +8,7 @@ export function interfaceDeclaration() {
     if (this.extern) {
         return Maybe.empty();
     }
-    const properties = this.properties.map((property) => property.interfacePropertySignature);
+    const properties = this.properties.flatMap((property) => property.interfacePropertySignature.toList());
     return Maybe.of({
         extends: this.parentObjectTypes.map((parentObjectType) => parentObjectType.name),
         isExported: true,

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

@@ -14,7 +14,7 @@ export function jsonZodSchemaFunctionDeclaration() {
     }
     if (this.properties.length > 0) {
         mergeZodObjectSchemas.push(`${variables.zod}.object({ ${this.properties
-            .map((property) => property.jsonZodSchema({ variables }))
+            .flatMap((property) => property.jsonZodSchema({ variables }).toList())
             .map(({ key, schema }) => `"${key}": ${schema}`)
             .join(",")} })`);
     }

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

@@ -28,11 +28,11 @@ export function toJsonFunctionOrMethodDeclaration() {
             break;
     }
     if (this.ownProperties.length > 0) {
-        for (const property of this.ownProperties) {
-            jsonObjectMembers.push(property.toJsonObjectMember({
-                variables: { value: `${this.thisVariable}.${property.name}` },
-            }));
-        }
+        jsonObjectMembers.push(...this.ownProperties.flatMap((property) => property
+            .toJsonObjectMember({
+            variables: { value: `${this.thisVariable}.${property.name}` },
+        })
+            .toList()));
     }
     // 20241220: don't add @type until we're doing JSON-LD
     // switch (this.toRdfTypes.length) {

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

@@ -2,10 +2,8 @@ export function toJsonReturnType() {
     const typeMembers = [];
     if (this.ownProperties.length > 0) {
         typeMembers.push(`{ ${this.ownProperties
-            .map((property) => {
-            const propertySignature = property.jsonPropertySignature;
-            return `readonly "${propertySignature.name}": ${propertySignature.type}`;
-        })
+            .flatMap((property) => property.jsonPropertySignature.toList())
+            .map((propertySignature) => `readonly "${propertySignature.name}": ${propertySignature.type}`)
             .join("; ")} }`);
     }
     for (const parentObjectType of this.parentObjectTypes) {

package/dist/input/NodeShape.d.ts

@@ -39,6 +39,7 @@ export declare class NodeShape extends ShaclCoreNodeShape<any, Ontology, Propert
     get tsFeatures(): Maybe<Set<TsFeature>>;
     get tsImports(): readonly string[];
     get tsObjectDeclarationType(): Maybe<TsObjectDeclarationType>;
+    get tsObjectIdentifierPrefixPropertyName(): Maybe<string>;
     get tsObjectIdentifierPropertyName(): Maybe<string>;
     get tsObjectTypeDiscriminatorPropertyName(): Maybe<string>;
     private get _mintingStrategy();

package/dist/input/NodeShape.js

@@ -68,7 +68,7 @@ export class NodeShape extends ShaclCoreNodeShape {
                 }
             }
         }
-        return thisMintingStrategy;
+        return thisMintingStrategy.altLazy(() => this.nodeKinds.has("BlankNode") ? Maybe.of("blankNode") : Maybe.empty());
     }
     get mutable() {
         return this.generatedShaclmateNodeShape.mutable;
@@ -139,9 +139,9 @@ export class NodeShape extends ShaclCoreNodeShape {
         return this.generatedShaclmateNodeShape.tsObjectDeclarationType
             .map((iri) => {
             switch (iri.value) {
-                case "http://minorg.github.io/shaclmate/ns#_TsObjectDeclarationType_Class":
+                case "http://purl.org/shaclmate/ontology#_TsObjectDeclarationType_Class":
                     return "class";
-                case "http://minorg.github.io/shaclmate/ns#_TsObjectDeclarationType_Interface":
+                case "http://purl.org/shaclmate/ontology#_TsObjectDeclarationType_Interface":
                     return "interface";
                 default:
                     throw new RangeError(iri.value);
@@ -149,8 +149,11 @@ export class NodeShape extends ShaclCoreNodeShape {
         })
             .altLazy(() => this.isDefinedBy.chain((ontology) => ontology.tsObjectDeclarationType));
     }
+    get tsObjectIdentifierPrefixPropertyName() {
+        return this.generatedShaclmateNodeShape.tsObjectIdentifierPrefixPropertyName.altLazy(() => this.isDefinedBy.chain((ontology) => ontology.tsObjectIdentifierPrefixPropertyName));
+    }
     get tsObjectIdentifierPropertyName() {
-        return this.generatedShaclmateNodeShape.tsObjectIdentifierPropertyName;
+        return this.generatedShaclmateNodeShape.tsObjectIdentifierPrefixPropertyName.altLazy(() => this.isDefinedBy.chain((ontology) => ontology.tsObjectIdentifierPropertyName));
     }
     get tsObjectTypeDiscriminatorPropertyName() {
         return this.generatedShaclmateNodeShape
@@ -159,12 +162,12 @@ export class NodeShape extends ShaclCoreNodeShape {
     get _mintingStrategy() {
         return this.generatedShaclmateNodeShape.identifierMintingStrategy.map((iri) => {
             switch (iri.value) {
-                case "http://minorg.github.io/shaclmate/ns#_IdentifierMintingStrategy_SHA256":
+                case "http://purl.org/shaclmate/ontology#_IdentifierMintingStrategy_BlankNode":
+                    return "blankNode";
+                case "http://purl.org/shaclmate/ontology#_IdentifierMintingStrategy_SHA256":
                     return "sha256";
-                case "http://minorg.github.io/shaclmate/ns#_IdentifierMintingStrategy_UUIDv4":
+                case "http://purl.org/shaclmate/ontology#_IdentifierMintingStrategy_UUIDv4":
                     return "uuidv4";
-                default:
-                    throw new RangeError(iri.value);
             }
         });
     }

package/dist/input/Ontology.d.ts

@@ -9,5 +9,7 @@ export declare class Ontology extends OwlOntology {
     get tsFeatures(): Maybe<Set<TsFeature>>;
     get tsImports(): readonly string[];
     get tsObjectDeclarationType(): Maybe<TsObjectDeclarationType>;
+    get tsObjectIdentifierPrefixPropertyName(): Maybe<string>;
+    get tsObjectIdentifierPropertyName(): Maybe<string>;
 }
 //# sourceMappingURL=Ontology.d.ts.map

package/dist/input/Ontology.js

@@ -18,14 +18,20 @@ export class Ontology extends OwlOntology {
     get tsObjectDeclarationType() {
         return this.generatedShaclmateOntology.tsObjectDeclarationType.map((iri) => {
             switch (iri.value) {
-                case "http://minorg.github.io/shaclmate/ns#_TsObjectDeclarationType_Class":
+                case "http://purl.org/shaclmate/ontology#_TsObjectDeclarationType_Class":
                     return "class";
-                case "http://minorg.github.io/shaclmate/ns#_TsObjectDeclarationType_Interface":
+                case "http://purl.org/shaclmate/ontology#_TsObjectDeclarationType_Interface":
                     return "interface";
                 default:
                     throw new RangeError(iri.value);
             }
         });
     }
+    get tsObjectIdentifierPrefixPropertyName() {
+        return this.generatedShaclmateOntology.tsObjectIdentifierPrefixPropertyName;
+    }
+    get tsObjectIdentifierPropertyName() {
+        return this.generatedShaclmateOntology.tsObjectIdentifierPropertyName;
+    }
 }
 //# sourceMappingURL=Ontology.js.map

package/dist/input/PropertyShape.js

@@ -19,11 +19,11 @@ export class PropertyShape extends ShaclCorePropertyShape {
         return this.generatedShaclmatePropertyShape.visibility
             .map((iri) => {
             switch (iri.value) {
-                case "http://minorg.github.io/shaclmate/ns#_Visibility_Private":
+                case "http://purl.org/shaclmate/ontology#_Visibility_Private":
                     return "private";
-                case "http://minorg.github.io/shaclmate/ns#_Visibility_Protected":
+                case "http://purl.org/shaclmate/ontology#_Visibility_Protected":
                     return "protected";
-                case "http://minorg.github.io/shaclmate/ns#_Visibility_Public":
+                case "http://purl.org/shaclmate/ontology#_Visibility_Public":
                     return "public";
                 default:
                     throw new RangeError(iri.value);