@shaclmate/compiler 2.0.13 → 2.0.15

package/input/NodeShape.js

@@ -0,0 +1,165 @@
+import { NodeShape as ShaclCoreNodeShape } from "@shaclmate/shacl-ast";
+import { Maybe } from "purify-ts";
+import { tsFeatures } from "./tsFeatures.js";
+export class NodeShape extends ShaclCoreNodeShape {
+    constructor({ ancestorClassIris, childClassIris, descendantClassIris, generatedShaclmateNodeShape, isClass, isList, parentClassIris, shapesGraph, }) {
+        super(generatedShaclmateNodeShape, shapesGraph);
+        this.ancestorClassIris = ancestorClassIris;
+        this.childClassIris = childClassIris;
+        this.descendantClassIris = descendantClassIris;
+        this.generatedShaclmateNodeShape = generatedShaclmateNodeShape;
+        this.isClass = isClass;
+        this.isList = isList;
+        this.parentClassIris = parentClassIris;
+    }
+    get abstract() {
+        return this.generatedShaclmateNodeShape.abstract;
+    }
+    get ancestorNodeShapes() {
+        return this.isClass
+            ? this.ancestorClassIris.flatMap((classIri) => this.shapesGraph.nodeShapeByIdentifier(classIri).toList())
+            : [];
+    }
+    get childNodeShapes() {
+        return this.isClass
+            ? this.childClassIris.flatMap((classIri) => this.shapesGraph.nodeShapeByIdentifier(classIri).toList())
+            : [];
+    }
+    get descendantNodeShapes() {
+        return this.isClass
+            ? this.descendantClassIris.flatMap((classIri) => this.shapesGraph.nodeShapeByIdentifier(classIri).toList())
+            : [];
+    }
+    get export() {
+        return this.generatedShaclmateNodeShape.export_;
+    }
+    get extern() {
+        return this.generatedShaclmateNodeShape.extern;
+    }
+    get fromRdfType() {
+        // Check for an explicit shaclmate:fromRdfType
+        const fromRdfType = this.generatedShaclmateNodeShape.fromRdfType;
+        if (fromRdfType.isJust()) {
+            return fromRdfType;
+        }
+        // No explicit shaclmate:fromRdfType
+        // If the shape is a class, not abstract, and identified by an IRI then use the shape IRI as the fromRdfType.
+        if (!this.abstract.orDefault(false) &&
+            this.isClass &&
+            this.identifier.termType === "NamedNode") {
+            return Maybe.of(this.identifier);
+        }
+        return Maybe.empty();
+    }
+    get mintingStrategy() {
+        const thisMintingStrategy = this._mintingStrategy;
+        if (thisMintingStrategy.isNothing()) {
+            for (const ancestorNodeShape of this.ancestorNodeShapes) {
+                const ancestorMintingStrategy = ancestorNodeShape._mintingStrategy;
+                if (ancestorMintingStrategy.isJust()) {
+                    return ancestorMintingStrategy;
+                }
+            }
+        }
+        return thisMintingStrategy;
+    }
+    get mutable() {
+        return this.generatedShaclmateNodeShape.mutable;
+    }
+    get nodeKinds() {
+        const thisNodeKinds = new Set([...this.constraints.nodeKinds.orDefault(new Set())].filter((nodeKind) => nodeKind !== "Literal"));
+        const parentNodeKinds = new Set();
+        for (const parentNodeShape of this.parentNodeShapes) {
+            for (const parentNodeKind of parentNodeShape.nodeKinds) {
+                parentNodeKinds.add(parentNodeKind);
+            }
+        }
+        if (thisNodeKinds.size === 0 && parentNodeKinds.size > 0) {
+            // No node kinds on this shape, use the parent's
+            return parentNodeKinds;
+        }
+        if (thisNodeKinds.size > 0 && parentNodeKinds.size > 0) {
+            // Node kinds on this shape and the parent's shape
+            // This node kinds must be a subset of parent node kinds.
+            for (const thisNodeKind of thisNodeKinds) {
+                if (!parentNodeKinds.has(thisNodeKind)) {
+                    throw new Error(`${this} has a nodeKind ${thisNodeKind} that is not in its parent's node kinds`);
+                }
+            }
+        }
+        if (thisNodeKinds.size === 0) {
+            // Default: both node kinds
+            thisNodeKinds.add("BlankNode");
+            thisNodeKinds.add("NamedNode");
+        }
+        return thisNodeKinds;
+    }
+    get parentNodeShapes() {
+        return this.isClass
+            ? this.parentClassIris.flatMap((classIri) => this.shapesGraph.nodeShapeByIdentifier(classIri).toList())
+            : [];
+    }
+    get shaclmateName() {
+        return this.generatedShaclmateNodeShape.name;
+    }
+    get toRdfTypes() {
+        // Look for one or more explicit shaclmate:toRdfType's
+        const toRdfTypes = this.generatedShaclmateNodeShape.toRdfTypes.concat();
+        // Ensure the toRdfTypes includes the fromRdfType if there is one
+        this.fromRdfType.ifJust((fromRdfType) => {
+            if (!toRdfTypes.some((toRdfType) => toRdfType.equals(fromRdfType))) {
+                toRdfTypes.push(fromRdfType);
+            }
+        });
+        if (toRdfTypes.length === 0) {
+            // No explicit shaclmate:toRdfType's
+            // If the shape is a class, not abstract, and identified by an IRI then use the shape IRI as the fromRdfType.
+            if (!this.abstract.orDefault(false) &&
+                this.isClass &&
+                this.identifier.termType === "NamedNode") {
+                toRdfTypes.push(this.identifier);
+            }
+        }
+        return toRdfTypes;
+    }
+    get tsFeatures() {
+        return tsFeatures(this.generatedShaclmateNodeShape).altLazy(() => this.isDefinedBy.chain((ontology) => ontology.tsFeatures));
+    }
+    get tsImports() {
+        return this.generatedShaclmateNodeShape.tsImports;
+    }
+    get tsObjectDeclarationType() {
+        return this.generatedShaclmateNodeShape.tsObjectDeclarationType
+            .map((iri) => {
+            switch (iri.value) {
+                case "http://minorg.github.io/shaclmate/ns#_TsObjectDeclarationType_Class":
+                    return "class";
+                case "http://minorg.github.io/shaclmate/ns#_TsObjectDeclarationType_Interface":
+                    return "interface";
+                default:
+                    throw new RangeError(iri.value);
+            }
+        })
+            .altLazy(() => this.isDefinedBy.chain((ontology) => ontology.tsObjectDeclarationType));
+    }
+    get tsObjectIdentifierPropertyName() {
+        return this.generatedShaclmateNodeShape.tsObjectIdentifierPropertyName;
+    }
+    get tsObjectTypeDiscriminatorPropertyName() {
+        return this.generatedShaclmateNodeShape
+            .tsObjectTypeDiscriminatorPropertyName;
+    }
+    get _mintingStrategy() {
+        return this.generatedShaclmateNodeShape.mintingStrategy.map((iri) => {
+            switch (iri.value) {
+                case "http://minorg.github.io/shaclmate/ns#_MintingStrategy_SHA256":
+                    return "sha256";
+                case "http://minorg.github.io/shaclmate/ns#_MintingStrategy_UUIDv4":
+                    return "uuidv4";
+                default:
+                    throw new RangeError(iri.value);
+            }
+        });
+    }
+}
+//# sourceMappingURL=NodeShape.js.map

package/input/Ontology.d.ts

@@ -0,0 +1,13 @@
+import { Ontology as OwlOntology } from "@shaclmate/shacl-ast";
+import type { Maybe } from "purify-ts";
+import type { TsFeature, TsObjectDeclarationType } from "../enums/index.js";
+import type * as generated from "./generated.js";
+export declare class Ontology extends OwlOntology {
+    private readonly generatedShaclmateOntology;
+    constructor(generatedShaclmateOntology: generated.ShaclmateOntology);
+    get tsDataFactoryVariable(): Maybe<string>;
+    get tsFeatures(): Maybe<Set<TsFeature>>;
+    get tsImports(): readonly string[];
+    get tsObjectDeclarationType(): Maybe<TsObjectDeclarationType>;
+}
+//# sourceMappingURL=Ontology.d.ts.map

package/input/Ontology.js

@@ -0,0 +1,30 @@
+import { Ontology as OwlOntology } from "@shaclmate/shacl-ast";
+import { tsFeatures } from "./tsFeatures.js";
+export class Ontology extends OwlOntology {
+    constructor(generatedShaclmateOntology) {
+        super(generatedShaclmateOntology);
+        this.generatedShaclmateOntology = generatedShaclmateOntology;
+    }
+    get tsDataFactoryVariable() {
+        return this.generatedShaclmateOntology.tsDataFactoryVariable;
+    }
+    get tsFeatures() {
+        return tsFeatures(this.generatedShaclmateOntology);
+    }
+    get tsImports() {
+        return this.generatedShaclmateOntology.tsImports;
+    }
+    get tsObjectDeclarationType() {
+        return this.generatedShaclmateOntology.tsObjectDeclarationType.map((iri) => {
+            switch (iri.value) {
+                case "http://minorg.github.io/shaclmate/ns#_TsObjectDeclarationType_Class":
+                    return "class";
+                case "http://minorg.github.io/shaclmate/ns#_TsObjectDeclarationType_Interface":
+                    return "interface";
+                default:
+                    throw new RangeError(iri.value);
+            }
+        });
+    }
+}
+//# sourceMappingURL=Ontology.js.map

package/input/PropertyShape.d.ts

@@ -0,0 +1,15 @@
+import { PropertyShape as ShaclCorePropertyShape } from "@shaclmate/shacl-ast";
+import { Maybe } from "purify-ts";
+import type { PropertyVisibility } from "../enums/index.js";
+import type { Shape } from "./Shape.js";
+import type * as generated from "./generated.js";
+import type { NodeShape, Ontology, PropertyGroup, ShapesGraph } from "./index.js";
+export declare class PropertyShape extends ShaclCorePropertyShape<NodeShape, Ontology, PropertyGroup, any, Shape> {
+    private readonly generatedShaclmatePropertyShape;
+    constructor(generatedShaclmatePropertyShape: generated.ShaclmatePropertyShape, shapesGraph: ShapesGraph);
+    get extern(): Maybe<boolean>;
+    get mutable(): Maybe<boolean>;
+    get shaclmateName(): Maybe<string>;
+    get visibility(): PropertyVisibility;
+}
+//# sourceMappingURL=PropertyShape.d.ts.map

package/input/PropertyShape.js

@@ -0,0 +1,34 @@
+import { PropertyShape as ShaclCorePropertyShape } from "@shaclmate/shacl-ast";
+import { Maybe } from "purify-ts";
+export class PropertyShape extends ShaclCorePropertyShape {
+    constructor(generatedShaclmatePropertyShape, shapesGraph) {
+        super({ ...generatedShaclmatePropertyShape, uniqueLang: Maybe.empty() }, shapesGraph);
+        this.generatedShaclmatePropertyShape = generatedShaclmatePropertyShape;
+    }
+    get extern() {
+        return this.generatedShaclmatePropertyShape.extern;
+    }
+    get mutable() {
+        return this.generatedShaclmatePropertyShape.mutable;
+    }
+    get shaclmateName() {
+        return this.generatedShaclmatePropertyShape.name;
+    }
+    get visibility() {
+        return this.generatedShaclmatePropertyShape.visibility
+            .map((iri) => {
+            switch (iri.value) {
+                case "http://minorg.github.io/shaclmate/ns#_Visibility_Private":
+                    return "private";
+                case "http://minorg.github.io/shaclmate/ns#_Visibility_Protected":
+                    return "protected";
+                case "http://minorg.github.io/shaclmate/ns#_Visibility_Public":
+                    return "public";
+                default:
+                    throw new RangeError(iri.value);
+            }
+        })
+            .orDefault("public");
+    }
+}
+//# sourceMappingURL=PropertyShape.js.map

package/input/Shape.d.ts

@@ -0,0 +1,4 @@
+import type { NodeShape } from "./NodeShape.js";
+import type { PropertyShape } from "./PropertyShape.js";
+export type Shape = NodeShape | PropertyShape;
+//# sourceMappingURL=Shape.d.ts.map

package/input/Shape.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=Shape.js.map

package/input/ShapesGraph.d.ts

@@ -0,0 +1,9 @@
+import type { DatasetCore } from "@rdfjs/types";
+import { RdfjsShapesGraph } from "@shaclmate/shacl-ast";
+import { NodeShape, Ontology, PropertyGroup, PropertyShape, type Shape } from "./index.js";
+export declare class ShapesGraph extends RdfjsShapesGraph<NodeShape, Ontology, PropertyGroup, PropertyShape, Shape> {
+    constructor({ dataset }: {
+        dataset: DatasetCore;
+    });
+}
+//# sourceMappingURL=ShapesGraph.d.ts.map

package/input/ShapesGraph.js

@@ -0,0 +1,50 @@
+import { RdfjsShapesGraph } from "@shaclmate/shacl-ast";
+import { owl, rdf, rdfs } from "@tpluscode/rdf-ns-builders";
+import { ancestorClassIris } from "./ancestorClassIris.js";
+import { descendantClassIris } from "./descendantClassIris.js";
+import * as generated from "./generated.js";
+import { NodeShape, Ontology, PropertyGroup, PropertyShape, } from "./index.js";
+export class ShapesGraph extends RdfjsShapesGraph {
+    constructor({ dataset }) {
+        super({
+            dataset,
+            factory: {
+                nodeShapeFromRdf({ resource, shapesGraph, }) {
+                    return generated.ShaclmateNodeShape.fromRdf({
+                        ignoreRdfType: true,
+                        resource,
+                    }).map((generatedShape) => new NodeShape({
+                        ancestorClassIris: ancestorClassIris(resource, Number.MAX_SAFE_INTEGER),
+                        childClassIris: descendantClassIris(resource, 1),
+                        descendantClassIris: descendantClassIris(resource, Number.MAX_SAFE_INTEGER),
+                        generatedShaclmateNodeShape: generatedShape,
+                        isClass: resource.isInstanceOf(owl.Class) ||
+                            resource.isInstanceOf(rdfs.Class),
+                        isList: resource.isSubClassOf(rdf.List),
+                        parentClassIris: ancestorClassIris(resource, 1),
+                        shapesGraph,
+                    }));
+                },
+                ontologyFromRdf({ resource, }) {
+                    return generated.ShaclmateOntology.fromRdf({
+                        ignoreRdfType: true,
+                        resource,
+                    }).map((generatedOntology) => new Ontology(generatedOntology));
+                },
+                propertyGroupFromRdf({ resource, }) {
+                    return generated.ShaclCorePropertyGroup.fromRdf({
+                        ignoreRdfType: true,
+                        resource,
+                    }).map((generatedPropertyGroup) => new PropertyGroup(generatedPropertyGroup));
+                },
+                propertyShapeFromRdf({ resource, shapesGraph, }) {
+                    return generated.ShaclmatePropertyShape.fromRdf({
+                        ignoreRdfType: true,
+                        resource,
+                    }).map((generatedShape) => new PropertyShape(generatedShape, shapesGraph));
+                },
+            },
+        });
+    }
+}
+//# sourceMappingURL=ShapesGraph.js.map

package/input/ancestorClassIris.d.ts

@@ -0,0 +1,4 @@
+import type { NamedNode } from "@rdfjs/types";
+import type { Resource } from "rdfjs-resource";
+export declare function ancestorClassIris(classResource: Resource, maxDepth: number): readonly NamedNode[];
+//# sourceMappingURL=ancestorClassIris.d.ts.map

package/input/ancestorClassIris.js

@@ -0,0 +1,21 @@
+import TermSet from "@rdfjs/term-set";
+import { rdfs } from "@tpluscode/rdf-ns-builders";
+export function ancestorClassIris(classResource, maxDepth) {
+    const ancestorClassIris = new TermSet();
+    function ancestorClassIrisRecursive(classResource, depth) {
+        for (const parentClassValue of classResource.values(rdfs.subClassOf)) {
+            parentClassValue.toNamedResource().ifRight((parentClassResource) => {
+                if (ancestorClassIris.has(parentClassResource.identifier)) {
+                    return;
+                }
+                ancestorClassIris.add(parentClassResource.identifier);
+                if (depth < maxDepth) {
+                    ancestorClassIrisRecursive(parentClassResource, depth + 1);
+                }
+            });
+        }
+    }
+    ancestorClassIrisRecursive(classResource, 1);
+    return [...ancestorClassIris];
+}
+//# sourceMappingURL=ancestorClassIris.js.map

package/input/descendantClassIris.d.ts

@@ -0,0 +1,4 @@
+import type { NamedNode } from "@rdfjs/types";
+import type { Resource } from "rdfjs-resource";
+export declare function descendantClassIris(classResource: Resource, maxDepth: number): readonly NamedNode[];
+//# sourceMappingURL=descendantClassIris.d.ts.map

package/input/descendantClassIris.js

@@ -0,0 +1,21 @@
+import TermSet from "@rdfjs/term-set";
+import { rdfs } from "@tpluscode/rdf-ns-builders";
+export function descendantClassIris(classResource, maxDepth) {
+    const descendantClassIris = new TermSet();
+    function descendantClassIrisRecursive(classResource, depth) {
+        for (const childClassValue of classResource.valuesOf(rdfs.subClassOf)) {
+            childClassValue.toNamedResource().ifRight((childClassResource) => {
+                if (descendantClassIris.has(childClassResource.identifier)) {
+                    return;
+                }
+                descendantClassIris.add(childClassResource.identifier);
+                if (depth < maxDepth) {
+                    descendantClassIrisRecursive(childClassResource, depth + 1);
+                }
+            });
+        }
+    }
+    descendantClassIrisRecursive(classResource, 1);
+    return [...descendantClassIris];
+}
+//# sourceMappingURL=descendantClassIris.js.map