@shaclmate/compiler 2.0.17 → 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/PropertyPath.d.ts

@@ -0,0 +1,41 @@
+import type { NamedNode } from "@rdfjs/types";
+import type * as purify from "purify-ts";
+import type * as rdfjsResource from "rdfjs-resource";
+export interface AlternativePath {
+    readonly kind: "AlternativePath";
+    readonly members: readonly PropertyPath[];
+}
+export interface InversePath {
+    readonly kind: "InversePath";
+    readonly path: PropertyPath;
+}
+export interface OneOrMorePath {
+    readonly kind: "OneOrMorePath";
+    readonly path: PropertyPath;
+}
+export interface PredicatePath {
+    readonly iri: NamedNode;
+    readonly kind: "PredicatePath";
+}
+export interface SequencePath {
+    readonly kind: "SequencePath";
+    readonly members: readonly PropertyPath[];
+}
+export interface ZeroOrMorePath {
+    readonly kind: "ZeroOrMorePath";
+    readonly path: PropertyPath;
+}
+export interface ZeroOrOnePath {
+    readonly kind: "ZeroOrOnePath";
+    readonly path: PropertyPath;
+}
+export type PropertyPath = AlternativePath | InversePath | OneOrMorePath | PredicatePath | SequencePath | ZeroOrMorePath | ZeroOrOnePath;
+export declare namespace PropertyPath {
+    function fromRdf({ resource, }: {
+        [_index: string]: any;
+        ignoreRdfType?: boolean;
+        languageIn?: readonly string[];
+        resource: rdfjsResource.Resource;
+    }): purify.Either<rdfjsResource.Resource.ValueError, PropertyPath>;
+}
+//# sourceMappingURL=PropertyPath.d.ts.map

package/dist/input/PropertyPath.js

@@ -0,0 +1,105 @@
+import { rdf, sh } from "@tpluscode/rdf-ns-builders";
+import { Either, Left } from "purify-ts";
+import { Resource } from "rdfjs-resource";
+export var PropertyPath;
+(function (PropertyPath) {
+    function fromRdf({ resource, }) {
+        // Predicate path
+        // sh:path ex:parent
+        if (resource.identifier.termType === "NamedNode") {
+            return Either.of({ iri: resource.identifier, kind: "PredicatePath" });
+        }
+        // The other property path types are BlankNodes
+        const getPropertyPathList = (listResource) => {
+            return listResource.toList().chain((values) => {
+                const members = [];
+                for (const value of values) {
+                    const memberResource = value.toResource().toMaybe();
+                    if (memberResource.isNothing()) {
+                        return Left(new Resource.ValueError({
+                            focusResource: resource,
+                            message: "non-identifier in property path list",
+                            predicate: rdf.subject,
+                        }));
+                    }
+                    const member = PropertyPath.fromRdf({
+                        resource: memberResource.unsafeCoerce(),
+                    });
+                    if (member.isLeft()) {
+                        return member;
+                    }
+                    members.push(member.unsafeCoerce());
+                }
+                return Either.of(members);
+            });
+        };
+        for (const quad of resource.dataset.match(resource.identifier, null, null, null)) {
+            switch (quad.object.termType) {
+                case "BlankNode":
+                case "NamedNode":
+                    break;
+                default:
+                    return Left(new Resource.ValueError({
+                        focusResource: resource,
+                        message: `non-BlankNode/NamedNode property path object on path ${resource.identifier.value}: ${quad.object.termType} ${quad.object.value}`,
+                        predicate: quad.predicate,
+                    }));
+            }
+            const objectResource = new Resource({
+                dataset: resource.dataset,
+                identifier: quad.object,
+            });
+            // Alternative path
+            // sh:path: [ sh:alternativePath ( ex:father ex:mother  ) ]
+            if (quad.predicate.equals(sh.alternativePath)) {
+                return getPropertyPathList(objectResource).map((members) => ({
+                    kind: "AlternativePath",
+                    members,
+                }));
+            }
+            // Inverse path
+            // sh:path: [ sh:inversePath ex:parent ]
+            if (quad.predicate.equals(sh.inversePath)) {
+                return PropertyPath.fromRdf({ resource: objectResource }).map((path) => ({
+                    kind: "InversePath",
+                    path,
+                }));
+            }
+            // One or more path
+            if (quad.predicate.equals(sh.oneOrMorePath)) {
+                return PropertyPath.fromRdf({ resource: objectResource }).map((path) => ({
+                    kind: "OneOrMorePath",
+                    path,
+                }));
+            }
+            // Sequence path
+            // sh:path ( ex:parent ex:firstName )
+            if (quad.predicate.equals(rdf.first)) {
+                return getPropertyPathList(objectResource).map((members) => ({
+                    kind: "SequencePath",
+                    members,
+                }));
+            }
+            // Zero or more path
+            if (quad.predicate.equals(sh.zeroOrMorePath)) {
+                return PropertyPath.fromRdf({ resource: objectResource }).map((path) => ({
+                    kind: "ZeroOrMorePath",
+                    path,
+                }));
+            }
+            if (quad.predicate.equals(sh.zeroOrOnePath)) {
+                return PropertyPath.fromRdf({ resource: objectResource }).map((path) => ({
+                    kind: "ZeroOrOnePath",
+                    path,
+                }));
+            }
+        }
+        return Left(new Resource.ValueError({
+            focusResource: resource,
+            message: `unrecognized or ill-formed SHACL property path ${resource.identifier.value}`,
+            predicate: rdf.subject,
+        }));
+    }
+    PropertyPath.fromRdf = fromRdf;
+})(PropertyPath || (PropertyPath = {}));
+//# sourceMappingURL=PropertyPath.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);