@shaclmate/compiler 4.0.12 → 4.0.14

package/dist/input/NodeShape.js

@@ -1,154 +1,2 @@
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-import { NodeShape as ShaclAstNodeShape } from "@shaclmate/shacl-ast";
-import { rdf } from "@tpluscode/rdf-ns-builders";
-import { Either, List } from "purify-ts";
-import { invariant } from "ts-invariant";
-import { Memoize } from "typescript-memoize";
-export class NodeShape extends ShaclAstNodeShape {
-    ancestorClassIris;
-    childClassIris;
-    descendantClassIris;
-    generatedNodeShape;
-    parentClassIris;
-    isClass;
-    isList;
-    kind = "NodeShape";
-    constructor({ ancestorClassIris, childClassIris, descendantClassIris, generatedNodeShape, isClass, isList, parentClassIris, shapesGraph, }) {
-        super(generatedNodeShape, shapesGraph);
-        if (ancestorClassIris.length > 0 ||
-            childClassIris.length > 0 ||
-            descendantClassIris.length > 0 ||
-            isList ||
-            parentClassIris.length > 0) {
-            invariant(isClass);
-        }
-        this.ancestorClassIris = ancestorClassIris;
-        this.childClassIris = childClassIris;
-        this.descendantClassIris = descendantClassIris;
-        this.generatedNodeShape = generatedNodeShape;
-        this.isClass = isClass;
-        this.isList = isList;
-        this.parentClassIris = parentClassIris;
-    }
-    get abstract() {
-        return this.generatedNodeShape.abstract;
-    }
-    get ancestorNodeShapes() {
-        return Either.sequence(this.ancestorClassIris
-            .filter((classIri) => !classIri.equals(rdf.List))
-            .map((classIri) => this.shapesGraph.nodeShapeByIdentifier(classIri)));
-    }
-    get childNodeShapes() {
-        return Either.sequence(this.childClassIris.flatMap((classIri) => this.shapesGraph.nodeShapeByIdentifier(classIri)));
-    }
-    get comment() {
-        return List.head(this.comments);
-    }
-    get descendantNodeShapes() {
-        return Either.sequence(this.descendantClassIris.flatMap((classIri) => this.shapesGraph.nodeShapeByIdentifier(classIri)));
-    }
-    get discriminantValue() {
-        return this.generatedNodeShape.discriminantValue;
-    }
-    get extern() {
-        return this.generatedNodeShape.extern;
-    }
-    get fromRdfType() {
-        return this.generatedNodeShape.fromRdfType;
-    }
-    get identifierIn() {
-        return this.constraints.in_.filter((value) => value.termType === "NamedNode");
-    }
-    get identifierMintingStrategy() {
-        return this.generatedNodeShape.identifierMintingStrategy.map((iri) => {
-            switch (iri.value) {
-                case "http://purl.org/shaclmate/ontology#_IdentifierMintingStrategy_BlankNode":
-                    return "blankNode";
-                case "http://purl.org/shaclmate/ontology#_IdentifierMintingStrategy_SHA256":
-                    return "sha256";
-                case "http://purl.org/shaclmate/ontology#_IdentifierMintingStrategy_UUIDv4":
-                    return "uuidv4";
-                default:
-                    iri.value;
-                    throw new RangeError(iri.value);
-            }
-        });
-    }
-    get label() {
-        return List.head(this.labels);
-    }
-    get mutable() {
-        return this.generatedNodeShape.mutable;
-    }
-    get parentNodeShapes() {
-        return Either.sequence(this.parentClassIris
-            .filter((classIri) => !classIri.equals(rdf.List))
-            .map((classIri) => this.shapesGraph.nodeShapeByIdentifier(classIri)));
-    }
-    get rdfType() {
-        return this.generatedNodeShape.rdfType;
-    }
-    get shaclmateName() {
-        return this.generatedNodeShape.name;
-    }
-    get toRdfTypes() {
-        return this.generatedNodeShape.toRdfTypes;
-    }
-    get tsFeatureExcludes() {
-        return this.generatedNodeShape.tsFeatureExcludes;
-    }
-    get tsFeatureIncludes() {
-        return this.generatedNodeShape.tsFeatureIncludes;
-    }
-    get tsImports() {
-        return this.generatedNodeShape.tsImports;
-    }
-    get tsObjectDeclarationType() {
-        return this.generatedNodeShape.tsObjectDeclarationType.map((iri) => {
-            switch (iri.value) {
-                case "http://purl.org/shaclmate/ontology#_TsObjectDeclarationType_Class":
-                    return "class";
-                case "http://purl.org/shaclmate/ontology#_TsObjectDeclarationType_Interface":
-                    return "interface";
-                default:
-                    throw new RangeError(iri.value);
-            }
-        });
-    }
-}
-__decorate([
-    Memoize()
-], NodeShape.prototype, "ancestorNodeShapes", null);
-__decorate([
-    Memoize()
-], NodeShape.prototype, "childNodeShapes", null);
-__decorate([
-    Memoize()
-], NodeShape.prototype, "comment", null);
-__decorate([
-    Memoize()
-], NodeShape.prototype, "descendantNodeShapes", null);
-__decorate([
-    Memoize()
-], NodeShape.prototype, "identifierIn", null);
-__decorate([
-    Memoize()
-], NodeShape.prototype, "identifierMintingStrategy", null);
-__decorate([
-    Memoize()
-], NodeShape.prototype, "label", null);
-__decorate([
-    Memoize()
-], NodeShape.prototype, "parentNodeShapes", null);
-__decorate([
-    Memoize()
-], NodeShape.prototype, "rdfType", null);
-__decorate([
-    Memoize()
-], NodeShape.prototype, "tsObjectDeclarationType", null);
+export {};
 //# sourceMappingURL=NodeShape.js.map

package/dist/input/Shape.d.ts

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

package/dist/input/ShapesGraph.d.ts

@@ -1,25 +1,25 @@
 import { ShapesGraph as _ShapesGraph, type CurieFactory } from "@shaclmate/shacl-ast";
 import type { Either } from "purify-ts";
 import type { Resource } from "rdfjs-resource";
-import { NodeShape, Ontology, PropertyGroup, PropertyShape, type Shape } from "./index.js";
-export type ShapesGraph = _ShapesGraph<NodeShape, Ontology, PropertyGroup, PropertyShape, Shape>;
+import * as generated from "./generated.js";
+import type { NodeShape } from "./NodeShape.js";
+import type { Shape } from "./Shape.js";
+export type ShapesGraph = _ShapesGraph<NodeShape, generated.Ontology, generated.PropertyGroup, generated.PropertyShape, Shape>;
 export declare namespace ShapesGraph {
-    class Factory extends _ShapesGraph.Factory<NodeShape, Ontology, PropertyGroup, PropertyShape, Shape> {
-        protected createNodeShape({ resource, shapesGraph, }: {
+    class Factory extends _ShapesGraph.Factory<NodeShape, generated.Ontology, generated.PropertyGroup, generated.PropertyShape, Shape> {
+        protected createNodeShape({ resource, }: {
             resource: Resource;
-            shapesGraph: ShapesGraph;
         }): Either<Error, NodeShape>;
         protected createOntology({ resource, }: {
             resource: Resource;
-        }): Either<Error, Ontology>;
+        }): Either<Error, generated.Ontology>;
         protected createPropertyGroup({ resource, }: {
             resource: Resource;
-        }): Either<Error, PropertyGroup>;
-        protected createPropertyShape({ curieFactory, resource, shapesGraph, }: {
+        }): Either<Error, generated.PropertyGroup>;
+        protected createPropertyShape({ curieFactory, resource, }: {
             curieFactory: CurieFactory;
             resource: Resource;
-            shapesGraph: ShapesGraph;
-        }): Either<Error, PropertyShape>;
+        }): Either<Error, generated.PropertyShape>;
     }
     export function create(parameters: Parameters<Factory["createShapesGraph"]>[0]): Either<Error, ShapesGraph>;
     export {};

package/dist/input/ShapesGraph.js

@@ -3,11 +3,10 @@ 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 var ShapesGraph;
 (function (ShapesGraph) {
     class Factory extends _ShapesGraph.Factory {
-        createNodeShape({ resource, shapesGraph, }) {
+        createNodeShape({ resource, }) {
             return generated.NodeShape.$fromRdfResource(resource, {
                 ignoreRdfType: true,
                 preferredLanguages: this.preferredLanguages,
@@ -17,7 +16,7 @@ export var ShapesGraph;
                 if (isList) {
                     isClass = true; // RDFS entailment: if A rdfs:subClassOf rdf:List then A is an rdfs:Class
                 }
-                const ancestorClassIris_ = ancestorClassIris(resource, Number.MAX_SAFE_INTEGER);
+                const ancestorClassIris_ = ancestorClassIris(resource, Number.MAX_SAFE_INTEGER).filter((ancestorClassIri) => !ancestorClassIri.equals(rdf.List));
                 if (ancestorClassIris_.length > 0) {
                     isClass = true; // RDFS entailment: if A rdfs:subClassOf B then both A and B are rdfs:Class's
                 }
@@ -25,40 +24,39 @@ export var ShapesGraph;
                 if (descendantClassIris_.length > 0) {
                     isClass = true; // RDFS entailment, see above
                 }
-                return new NodeShape({
+                return {
+                    ...generatedShape,
                     ancestorClassIris: ancestorClassIris_,
                     childClassIris: descendantClassIris(resource, 1),
                     descendantClassIris: descendantClassIris_,
-                    generatedNodeShape: generatedShape,
                     isClass,
                     isList,
-                    parentClassIris: ancestorClassIris(resource, 1),
-                    shapesGraph,
-                });
+                    parentClassIris: ancestorClassIris(resource, 1).filter((ancestorClassIri) => !ancestorClassIri.equals(rdf.List)),
+                };
             });
         }
         createOntology({ resource, }) {
             return generated.Ontology.$fromRdfResource(resource, {
                 ignoreRdfType: true,
                 preferredLanguages: this.preferredLanguages,
-            }).map((generatedOntology) => new Ontology(generatedOntology));
+            });
         }
         createPropertyGroup({ resource, }) {
             return generated.PropertyGroup.$fromRdfResource(resource, {
                 ignoreRdfType: true,
                 preferredLanguages: this.preferredLanguages,
-            }).map((generatedPropertyGroup) => new PropertyGroup(generatedPropertyGroup));
+            });
         }
-        createPropertyShape({ curieFactory, resource, shapesGraph, }) {
+        createPropertyShape({ curieFactory, resource, }) {
             return generated.PropertyShape.$fromRdfResource(resource, {
                 ignoreRdfType: true,
                 preferredLanguages: this.preferredLanguages,
-            }).map((generatedShape) => new PropertyShape({
+            }).map((generatedShape) => ({
                 ...generatedShape,
                 path: (generatedShape.path.termType === "NamedNode"
                     ? curieFactory.create(generatedShape.path).extract()
                     : undefined) ?? generatedShape.path,
-            }, shapesGraph));
+            }));
         }
     }
     const factory = new Factory();