@shaclmate/compiler 4.0.93 → 4.0.95

package/dist/input/ShapesGraph.d.ts

@@ -1,23 +1,27 @@
 import type { DatasetCore } from "@rdfjs/types";
-import type { PrefixMap } from "@rdfx/collection";
+import { type PrefixMap } from "@rdfx/collection";
 import type { Logger } from "@rdfx/logger";
 import { AbstractShapesGraph } from "@shaclmate/shacl-ast";
-import type { Either } from "purify-ts";
+import { Either } from "purify-ts";
 import type { Ast } from "../ast/Ast.js";
 import type { Generator } from "../generators/Generator.js";
 import * as generated from "./input.shaclmate.js";
 export declare class ShapesGraph extends AbstractShapesGraph<generated.NodeShape, generated.Ontology, generated.PropertyGroup, generated.PropertyShape> {
+    #private;
+    private readonly servicesByIdentifier;
     protected readonly typeFunctions: {
         readonly NodeShape: typeof generated.NodeShape;
         readonly Ontology: typeof generated.Ontology;
         readonly PropertyGroup: typeof generated.PropertyGroup;
         readonly PropertyShape: typeof generated.PropertyShape;
     };
+    get uniqueCurieReferences(): ReadonlySet<string>;
+    get services(): readonly generated.Service[];
     static fromDataset(dataset: DatasetCore, options?: {
         ignoreUndefinedShapes?: boolean;
         prefixMap?: PrefixMap;
     }): Either<Error, ShapesGraph>;
-    static fromShapes(...objects: readonly (generated.NodeShape | generated.Ontology | generated.PropertyGroup | generated.PropertyShape)[]): ShapesGraph;
+    static fromObjects(...objects: readonly (generated.NodeShape.Discriminated | generated.Ontology.Discriminated | generated.PropertyGroup.Discriminated | generated.PropertyShape.Discriminated | generated.Service.Discriminated)[]): ShapesGraph;
     /**
      * Compile the shapes graph using the given generator and return the generator's output.
      */

package/dist/input/ShapesGraph.js

@@ -1,14 +1,85 @@
+import { datasetFactory, TermMap } from "@rdfx/collection";
+import { Curie } from "@rdfx/curie";
+import dataFactory from "@rdfx/data-factory";
+import { ResourceSet } from "@rdfx/resource";
 import { AbstractShapesGraph } from "@shaclmate/shacl-ast";
+import { Either } from "purify-ts";
 import { Compiler } from "../Compiler.js";
 import { ShapesGraphToAstTransformer } from "../ShapesGraphToAstTransformer.js";
 import * as generated from "./input.shaclmate.js";
 export class ShapesGraph extends AbstractShapesGraph {
+    #uniqueCurieReferences = new Set();
+    servicesByIdentifier = new TermMap();
     typeFunctions = typeFunctions;
+    get uniqueCurieReferences() {
+        return this.#uniqueCurieReferences;
+    }
+    get services() {
+        return [...this.servicesByIdentifier.values()];
+    }
     static fromDataset(dataset, options) {
-        return AbstractShapesGraph._fromDataset(dataset, options, new ShapesGraph());
+        const shapesGraph = new ShapesGraph();
+        if (options?.prefixMap) {
+            const curieCache = new Map();
+            const curieDataset = datasetFactory.dataset();
+            const curieReferenceCounts = {};
+            const shrinkTerm = (term) => {
+                if (term.termType !== "NamedNode") {
+                    return term;
+                }
+                const cachedCurie = curieCache.get(term.value);
+                if (cachedCurie) {
+                    return cachedCurie;
+                }
+                const curie = Curie.fromIri(term, {
+                    prefixMap: options.prefixMap,
+                }).extract();
+                if (curie) {
+                    curieReferenceCounts[curie.reference] =
+                        (curieReferenceCounts[curie.reference] ?? 0) + 1;
+                }
+                curieCache.set(term.value, curie ?? term);
+                return (curie ?? term);
+            };
+            for (const quad of dataset) {
+                curieDataset.add(dataFactory.quad(shrinkTerm(quad.subject), quad.predicate, shrinkTerm(quad.object), quad.graph));
+            }
+            for (const [reference, count] of Object.entries(curieReferenceCounts)) {
+                if (count === 1) {
+                    shapesGraph.#uniqueCurieReferences.add(reference);
+                }
+            }
+            dataset = curieDataset;
+        }
+        return AbstractShapesGraph._fromDataset(dataset, options, shapesGraph).chain((shapesGraph) => {
+            const resourceSet = new ResourceSet({ dataFactory, dataset });
+            for (const resource of resourceSet.instancesOf(generated.Service.schema.properties.$rdfType.fromRdfType)) {
+                const serviceEither = generated.Service.fromRdfResource(resource);
+                if (serviceEither.isLeft()) {
+                    return serviceEither;
+                }
+                const service = serviceEither.extract();
+                shapesGraph.servicesByIdentifier.set(service.$identifier(), service);
+            }
+            return Either.of(shapesGraph);
+        });
     }
-    static fromShapes(...objects) {
-        return AbstractShapesGraph._fromShapes(new ShapesGraph(), ...objects);
+    static fromObjects(...objects) {
+        const otherObjects = [];
+        const services = [];
+        for (const object of objects) {
+            if (generated.Service.isService(object)) {
+                services.push(object);
+            }
+            else {
+                otherObjects.push(object);
+            }
+        }
+        const shapesGraph = AbstractShapesGraph._fromObjects(new ShapesGraph(), ...otherObjects);
+        for (const service of services) {
+            shapesGraph.servicesByIdentifier.set(service.$identifier(), service);
+        }
+        return shapesGraph;
     }
     /**
      * Compile the shapes graph using the given generator and return the generator's output.

package/dist/input/index.d.ts

@@ -1,3 +1,5 @@
-export { NodeShape, Ontology, PropertyGroup, PropertyShape, Shape, } from "./input.shaclmate.js";
+export { NodeShape, Ontology, Operation, PropertyGroup, PropertyShape, Service, Shape as DiscriminatedShape, } from "./input.shaclmate.js";
+import type { Shape as DiscriminatedShape } from "./input.shaclmate.js";
+export type UndiscriminatedShape = Omit<DiscriminatedShape, "$type">;
 export * from "./ShapesGraph.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/input/index.js

@@ -1,3 +1,3 @@
-export { NodeShape, Ontology, PropertyGroup, PropertyShape, Shape, } from "./input.shaclmate.js";
+export { NodeShape, Ontology, Operation, PropertyGroup, PropertyShape, Service, Shape as DiscriminatedShape, } from "./input.shaclmate.js";
 export * from "./ShapesGraph.js";
 //# sourceMappingURL=index.js.map