@shaclmate/compiler 4.0.50 → 4.0.52

package/dist/generators/ts/rdfjsTermExpression.js

@@ -0,0 +1,72 @@
+import { rdf, rdfs, xsd } from "@tpluscode/rdf-ns-builders";
+import { code, literalOf } from "./ts-poet-wrapper.js";
+export function rdfjsTermExpression(rdfjsTerm) {
+    switch (rdfjsTerm.termType) {
+        case "BlankNode":
+            return code `${this.imports.dataFactory}.blankNode(${literalOf(rdfjsTerm.value)})`;
+        case "Literal":
+            if (rdfjsTerm.datatype.equals(xsd.string)) {
+                if (rdfjsTerm.language.length === 0) {
+                    return code `${this.imports.dataFactory}.literal(${literalOf(rdfjsTerm.value)})`;
+                }
+                return code `${this.imports.dataFactory}.literal(${literalOf(rdfjsTerm.value)}, ${literalOf(rdfjsTerm.language)})`;
+            }
+            return code `${this.imports.dataFactory}.literal(${literalOf(rdfjsTerm.value)}, ${rdfjsTermExpression.call(this, rdfjsTerm.datatype)})`;
+        case "NamedNode": {
+            if (rdfjsTerm.value.startsWith(rdf[""].value)) {
+                const unqualifiedName = rdfjsTerm.value.substring(rdf[""].value.length);
+                switch (unqualifiedName) {
+                    case "first":
+                    case "nil":
+                    case "rest":
+                    case "subject":
+                    case "type":
+                        return code `${this.snippets.RdfVocabularies}.rdf.${unqualifiedName}`;
+                    default:
+                        this.logger.warn("unrecognized rdf IRI: %s", rdfjsTerm.value);
+                }
+            }
+            else if (rdfjsTerm.value.startsWith(rdfs[""].value)) {
+                const unqualifiedName = rdfjsTerm.value.substring(rdfs[""].value.length);
+                switch (unqualifiedName) {
+                    case "subClassOf":
+                        return code `${this.snippets.RdfVocabularies}.rdfs.${unqualifiedName}`;
+                    default:
+                        this.logger.warn("unrecognized rdfs IRI: %s", rdfjsTerm.value);
+                }
+            }
+            else if (rdfjsTerm.value.startsWith(xsd[""].value)) {
+                const unqualifiedName = rdfjsTerm.value.substring(xsd[""].value.length);
+                switch (unqualifiedName) {
+                    case "boolean":
+                    case "byte":
+                    case "float":
+                    case "date":
+                    case "dateTime":
+                    case "decimal":
+                    case "double":
+                    case "int":
+                    case "integer":
+                    case "long":
+                    case "negativeInteger":
+                    case "nonNegativeInteger":
+                    case "nonPositiveInteger":
+                    case "positiveInteger":
+                    case "short":
+                    case "string":
+                    case "unsignedByte":
+                    case "unsignedInt":
+                    case "unsignedLong":
+                    case "unsignedShort":
+                        return code `${this.snippets.RdfVocabularies}.xsd.${unqualifiedName}`;
+                    default:
+                        this.logger.warn("unrecognized xsd IRI: %s", rdfjsTerm.value);
+                }
+            }
+            return code `${this.imports.dataFactory}.namedNode(${literalOf(rdfjsTerm.value)})`;
+        }
+        case "Variable":
+            return code `${this.imports.dataFactory}.variable!(${literalOf(rdfjsTerm.value)})`;
+    }
+}
+//# sourceMappingURL=rdfjsTermExpression.js.map

package/dist/generators/ts/singleEntryRecord.d.ts

@@ -0,0 +1,2 @@
+export declare function singleEntryRecord<T>(key: string, value: T): Record<string, T>;
+//# sourceMappingURL=singleEntryRecord.d.ts.map

package/dist/generators/ts/singleEntryRecord.js

@@ -0,0 +1,6 @@
+export function singleEntryRecord(key, value) {
+    const record = {};
+    record[key] = value;
+    return record;
+}
+//# sourceMappingURL=singleEntryRecord.js.map

package/dist/generators/ts/ts-poet-wrapper.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Wrapper around ts-poet, enabled during debugging to throw errors on Code.toString.
+ */
+export * from "ts-poet";
+//# sourceMappingURL=ts-poet-wrapper.d.ts.map

package/dist/generators/ts/ts-poet-wrapper.js

@@ -0,0 +1,13 @@
+/**
+ * Wrapper around ts-poet, enabled during debugging to throw errors on Code.toString.
+ */
+export * from "ts-poet";
+import { Code } from "ts-poet";
+const originalCodeToString = Code.prototype.toString;
+Code.prototype.toString = function (opts) {
+    if (!opts) {
+        throw new Error("Code.toString should not be called without opts");
+    }
+    return originalCodeToString.call(this, opts);
+};
+//# sourceMappingURL=ts-poet-wrapper.js.map

package/dist/generators/ts/tsComment.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Prefix a comment with multiline comment delimiters.
+ */
+export declare function tsComment(comment: string): string;
+//# sourceMappingURL=tsComment.d.ts.map

package/dist/generators/ts/tsComment.js

@@ -0,0 +1,11 @@
+/**
+ * Prefix a comment with multiline comment delimiters.
+ */
+export function tsComment(comment) {
+    return `/**\n${comment
+        .trim()
+        .split(/\r?\n|\r|\n/g)
+        .map((line) => ` * ${line}`)
+        .join("\n")}\n **/\n`;
+}
+//# sourceMappingURL=tsComment.js.map

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+export * as ast from "./ast/index.js";
+export * from "./Compiler.js";
+export * from "./generators/index.js";
+export * from "./input/index.js";
+export * from "./ShapesGraphToAstTransformer.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -0,0 +1,6 @@
+export * as ast from "./ast/index.js";
+export * from "./Compiler.js";
+export * from "./generators/index.js";
+export * from "./input/index.js";
+export * from "./ShapesGraphToAstTransformer.js";
+//# sourceMappingURL=index.js.map

package/dist/input/ShapesGraph.d.ts

@@ -0,0 +1,44 @@
+import { AbstractShapesGraph } from "@shaclmate/shacl-ast";
+import type { Either } from "purify-ts";
+import type { Logger } from "ts-log";
+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> {
+    protected readonly typeFunctions: {
+        readonly NodeShape: typeof generated.NodeShape;
+        readonly Ontology: typeof generated.Ontology;
+        readonly PropertyGroup: typeof generated.PropertyGroup;
+        readonly PropertyShape: typeof generated.PropertyShape;
+    };
+    /**
+     * Compile the shapes graph using the given generator and return the generator's output.
+     */
+    compile(parameters: {
+        generator: Generator;
+        logger: Logger;
+    }): Either<Error, string>;
+    static builder(): ShapesGraph.Builder;
+    /**
+     * Transform the shapes graph to an AST.
+     */
+    toAst({ logger }: {
+        logger: Logger;
+    }): Either<Error, Ast>;
+}
+export declare namespace ShapesGraph {
+    class Builder extends AbstractShapesGraph.AbstractBuilder<generated.NodeShape, generated.Ontology, generated.PropertyGroup, generated.PropertyShape> {
+        protected readonly typeFunctions: {
+            readonly NodeShape: typeof generated.NodeShape;
+            readonly Ontology: typeof generated.Ontology;
+            readonly PropertyGroup: typeof generated.PropertyGroup;
+            readonly PropertyShape: typeof generated.PropertyShape;
+        };
+        build(): ShapesGraph;
+        nodeShape(parameters?: Parameters<typeof generated.NodeShape.createUnsafe>[0]): generated.NodeShape;
+        ontology(parameters?: Parameters<typeof generated.Ontology.createUnsafe>[0]): generated.Ontology;
+        propertyGroup(parameters?: Parameters<typeof generated.PropertyGroup.createUnsafe>[0]): generated.PropertyGroup;
+        propertyShape(parameters: Parameters<typeof generated.PropertyShape.createUnsafe>[0]): generated.PropertyShape;
+    }
+}
+//# sourceMappingURL=ShapesGraph.d.ts.map

package/dist/input/ShapesGraph.js

@@ -0,0 +1,66 @@
+import { AbstractShapesGraph } from "@shaclmate/shacl-ast";
+import { Compiler } from "../Compiler.js";
+import { ShapesGraphToAstTransformer } from "../ShapesGraphToAstTransformer.js";
+import * as generated from "./input.shaclmate.js";
+const typeFunctions = {
+    NodeShape: generated.NodeShape,
+    Ontology: generated.Ontology,
+    PropertyGroup: generated.PropertyGroup,
+    PropertyShape: generated.PropertyShape,
+};
+export class ShapesGraph extends AbstractShapesGraph {
+    typeFunctions = typeFunctions;
+    /**
+     * Compile the shapes graph using the given generator and return the generator's output.
+     */
+    compile(parameters) {
+        return new Compiler(parameters).compile(this);
+    }
+    static builder() {
+        return new ShapesGraph.Builder();
+    }
+    /**
+     * Transform the shapes graph to an AST.
+     */
+    toAst({ logger }) {
+        return new ShapesGraphToAstTransformer({
+            logger,
+            shapesGraph: this,
+        }).transform();
+    }
+}
+(function (ShapesGraph) {
+    class Builder extends AbstractShapesGraph.AbstractBuilder {
+        typeFunctions = typeFunctions;
+        build() {
+            return new ShapesGraph({
+                nodeShapesByIdentifier: this.nodeShapesByIdentifier,
+                ontologiesByIdentifier: this.ontologiesByIdentifier,
+                propertyGroupsByIdentifier: this.propertyGroupsByIdentifier,
+                propertyShapesByIdentifier: this.propertyShapesByIdentifier,
+            });
+        }
+        nodeShape(parameters) {
+            const nodeShape = generated.NodeShape.createUnsafe(parameters);
+            this.add(nodeShape);
+            return nodeShape;
+        }
+        ontology(parameters) {
+            const ontology = generated.Ontology.createUnsafe(parameters);
+            this.add(ontology);
+            return ontology;
+        }
+        propertyGroup(parameters) {
+            const propertyGroup = generated.PropertyGroup.createUnsafe(parameters);
+            this.add(propertyGroup);
+            return propertyGroup;
+        }
+        propertyShape(parameters) {
+            const propertyShape = generated.PropertyShape.createUnsafe(parameters);
+            this.add(propertyShape);
+            return propertyShape;
+        }
+    }
+    ShapesGraph.Builder = Builder;
+})(ShapesGraph || (ShapesGraph = {}));
+//# sourceMappingURL=ShapesGraph.js.map

package/dist/input/index.d.ts

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

package/dist/input/index.js

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