@shaclmate/compiler 4.0.17 → 4.0.19

package/dist/ast/ObjectType.js

@@ -166,8 +166,20 @@ export class ObjectType extends AbstractType {
             return 0;
         });
     }
-    toString() {
-        return `${this.kind}(shapeIdentifier=${Resource.Identifier.toString(this.shapeIdentifier)})`;
+    toJSON() {
+        return {
+            ...super.toJSON(),
+            fromRdfType: this.fromRdfType.map(Resource.Identifier.toString).extract(),
+            identifierMintingStrategy: this.identifierMintingStrategy.extract(),
+            identifierType: this.identifierType.toJSON(),
+            parentObjectTypes: this.parentObjectTypes.length > 0
+                ? this.parentObjectTypes.map((parentObjectType) => parentObjectType.name.orDefault(Resource.Identifier.toString(parentObjectType.shapeIdentifier)))
+                : undefined,
+            synthetic: this.synthetic ? true : undefined,
+            toRdfTypes: this.toRdfTypes.length > 0
+                ? this.toRdfTypes.map(Resource.Identifier.toString)
+                : undefined,
+        };
     }
 }
 const nodeKinds = new Set(["BlankNode", "IRI"]);
@@ -350,8 +362,23 @@ const nodeKinds = new Set(["BlankNode", "IRI"]);
             }
             return helper([{ objectType: rootObjectType, property: rootProperty }]);
         }
+        toJSON() {
+            return {
+                comment: this.comment.extract(),
+                description: this.description.extract(),
+                label: this.label.extract(),
+                mutable: this.mutable ? true : undefined,
+                name: this.name,
+                order: this.order,
+                path: PropertyPath.toString(this.path),
+                recursive: this.recursive ? true : undefined,
+                shapeIdentifier: Resource.Identifier.toString(this.shapeIdentifier),
+                type: this.type.toJSON(),
+                visibility: this.visibility,
+            };
+        }
         toString() {
-            return `${this.name}(path=${PropertyPath.toString(this.path)})`;
+            return JSON.stringify(this.toJSON());
         }
     }
     __decorate([

package/dist/ast/SetType.d.ts

@@ -12,6 +12,17 @@ export declare class SetType<ItemTypeT extends SetType.ItemType = SetType.ItemTy
         minCount: number;
     } & Pick<ConstructorParameters<typeof AbstractCollectionType<ItemTypeT>>[0], "itemType" | "mutable">);
     equals(other: SetType<ItemTypeT>): boolean;
+    toJSON(): {
+        minCount: number;
+        mutable: boolean | undefined;
+        itemType: any;
+        comment: string | undefined;
+        kind: string;
+        label: string | undefined;
+        name: string | undefined;
+        recursive: boolean | undefined;
+        shapeIdentifier: string;
+    };
 }
 export declare namespace SetType {
     type ItemType = AbstractCollectionType.ItemType;

package/dist/ast/SetType.js

@@ -28,6 +28,12 @@ export class SetType extends AbstractCollectionType {
         }
         return true;
     }
+    toJSON() {
+        return {
+            ...super.toJSON(),
+            minCount: this.minCount,
+        };
+    }
 }
 (function (SetType) {
     SetType.isItemType = AbstractCollectionType.isItemType;

package/dist/ast/UnionType.d.ts

@@ -7,6 +7,18 @@ import type { ObjectUnionType } from "./ObjectUnionType.js";
 export declare class UnionType<MemberTypeT extends UnionType.MemberType = UnionType.MemberType> extends AbstractCompoundType<UnionType.Member<MemberTypeT>, MemberTypeT> {
     readonly kind = "UnionType";
     isObjectUnionType(): this is ObjectUnionType;
+    toJSON(): {
+        members: {
+            discriminantValue: string | number | undefined;
+            type: any;
+        }[] | undefined;
+        comment: string | undefined;
+        kind: string;
+        label: string | undefined;
+        name: string | undefined;
+        recursive: boolean | undefined;
+        shapeIdentifier: string;
+    };
 }
 export declare namespace UnionType {
     interface Member<TypeT extends UnionType.MemberType> extends AbstractCompoundType.Member<TypeT> {

package/dist/ast/UnionType.js

@@ -9,6 +9,17 @@ export class UnionType extends AbstractCompoundType {
             this.members.every((member) => member.type.kind === "ObjectType" ||
                 (member.type.kind === "UnionType" && member.type.isObjectUnionType())));
     }
+    toJSON() {
+        return {
+            ...super.toJSON(),
+            members: !this.recursive
+                ? this.members.map((member) => ({
+                    discriminantValue: member.discriminantValue.extract(),
+                    type: member.type.toJSON(),
+                }))
+                : undefined,
+        };
+    }
 }
 (function (UnionType) {
     UnionType.isMemberType = AbstractCompoundType.isMemberType;

package/dist/ast/termToJson.d.ts

@@ -0,0 +1,18 @@
+import type { Term } from "@rdfjs/types";
+export declare function termToJson(term: Term): {
+    termType: "BlankNode";
+    value: string;
+    datatype?: undefined;
+    language?: undefined;
+} | {
+    datatype: string;
+    language: string;
+    termType: "Literal";
+    value: string;
+} | {
+    termType: "NamedNode";
+    value: string;
+    datatype?: undefined;
+    language?: undefined;
+};
+//# sourceMappingURL=termToJson.d.ts.map

package/dist/ast/termToJson.js

@@ -0,0 +1,18 @@
+export function termToJson(term) {
+    switch (term.termType) {
+        case "BlankNode":
+            return { termType: term.termType, value: term.value };
+        case "Literal":
+            return {
+                datatype: term.datatype.value,
+                language: term.language,
+                termType: term.termType,
+                value: term.value,
+            };
+        case "NamedNode":
+            return { termType: term.termType, value: term.value };
+        default:
+            throw new Error(`unsupported term type: ${term.termType}`);
+    }
+}
+//# sourceMappingURL=termToJson.js.map

package/dist/generators/AstJsonGenerator.d.ts

@@ -0,0 +1,6 @@
+import type * as ast from "../ast/index.js";
+import type { Generator } from "./Generator.js";
+export declare class AstJsonGenerator implements Generator {
+    generate(ast: ast.Ast): string;
+}
+//# sourceMappingURL=AstJsonGenerator.d.ts.map

package/dist/generators/AstJsonGenerator.js

@@ -0,0 +1,11 @@
+export class AstJsonGenerator {
+    generate(ast) {
+        return JSON.stringify({
+            objectTypes: ast.namedObjectTypes.map((objectType) => ({
+                ...objectType.toJSON(),
+                properties: objectType.properties.map((property) => property.toJSON()),
+            })),
+        }, undefined, 2);
+    }
+}
+//# sourceMappingURL=AstJsonGenerator.js.map

package/dist/generators/Cx2Generator.d.ts

@@ -0,0 +1,10 @@
+import type { Ast } from "../ast/Ast.js";
+import type { Generator } from "./Generator.js";
+export declare class Cx2Generator implements Generator {
+    private readonly visualProperties;
+    constructor(options?: {
+        visualProperties?: Record<string, unknown>;
+    });
+    generate(ast: Ast): string;
+}
+//# sourceMappingURL=Cx2Generator.d.ts.map

package/dist/generators/Cx2Generator.js

@@ -0,0 +1,140 @@
+import { transformAstToLabeledPropertyGraph } from "./transformAstToLabeledPropertyGraph.js";
+export class Cx2Generator {
+    visualProperties;
+    constructor(options) {
+        this.visualProperties = options?.visualProperties;
+    }
+    generate(ast) {
+        const labeledPropertyGraph = transformAstToLabeledPropertyGraph(ast);
+        const edgeAttributeDeclarations = {
+            interaction: { d: "string" },
+        };
+        const edgeIdMap = {};
+        const edges = [];
+        const nodeAttributeDeclarations = {
+            name: { d: "string" },
+        };
+        const nodeIdMap = {};
+        const nodes = [];
+        function attributeDeclaration(lpgPropertyValue) {
+            switch (lpgPropertyValue.type) {
+                case "boolean":
+                case "double":
+                case "integer":
+                case "long":
+                case "string":
+                    return { d: lpgPropertyValue.type };
+                case "boolean[]":
+                case "double[]":
+                case "integer[]":
+                case "long[]":
+                case "string[]":
+                    return {
+                        d: `list_of_${lpgPropertyValue.type.substring(0, lpgPropertyValue.type.length - 2)}`,
+                    };
+            }
+        }
+        for (const lpgNode of labeledPropertyGraph.nodes) {
+            let id = nodeIdMap[lpgNode.id];
+            if (id === undefined) {
+                id = Object.keys(nodeIdMap).length + 1;
+                nodeIdMap[lpgNode.id] = id;
+            }
+            const v = {
+                name: lpgNode.label,
+            };
+            for (const [lpgNodePropertyName, lpgNodePropertyValue] of Object.entries(lpgNode.properties)) {
+                if (lpgNodePropertyName === "name") {
+                    continue;
+                }
+                if (!nodeAttributeDeclarations[lpgNodePropertyName]) {
+                    nodeAttributeDeclarations[lpgNodePropertyName] =
+                        attributeDeclaration(lpgNodePropertyValue);
+                }
+                v[lpgNodePropertyName] = lpgNodePropertyValue.value;
+            }
+            nodes.push({
+                id,
+                v,
+            });
+        }
+        for (const lpgRelationship of labeledPropertyGraph.relationships) {
+            let id = edgeIdMap[lpgRelationship.id];
+            if (id === undefined) {
+                id = Object.keys(edgeIdMap).length + 1;
+                edgeIdMap[lpgRelationship.id] = id;
+            }
+            edges.push({
+                id,
+                s: nodeIdMap[lpgRelationship.sourceNodeId],
+                t: nodeIdMap[lpgRelationship.targetNodeId],
+                v: lpgRelationship.label
+                    .map((label) => ({ interaction: label }))
+                    .orDefault({}),
+            });
+        }
+        let visualProperties = this.visualProperties ?? {};
+        visualProperties = {
+            ...visualProperties,
+            default: {
+                edge: {
+                    ...visualProperties?.default?.edge,
+                    EDGE_LABEL: "interaction",
+                },
+            },
+            edgeMapping: {
+                ...visualProperties?.edgeMapping,
+                EDGE_LABEL: {
+                    type: "PASSTHROUGH",
+                    definition: {
+                        attribute: "interaction",
+                        type: "string",
+                    },
+                },
+            },
+        };
+        return JSON.stringify([
+            {
+                CXVersion: "2.0",
+                hasFragments: false,
+            },
+            {
+                metaData: [
+                    {
+                        elementCount: edges.length,
+                        name: "edges",
+                    },
+                    {
+                        elementCount: nodes.length,
+                        name: "nodes",
+                    },
+                ],
+            },
+            {
+                attributeDeclarations: [
+                    {
+                        edges: edgeAttributeDeclarations,
+                        nodes: nodeAttributeDeclarations,
+                    },
+                ],
+            },
+            {
+                nodes,
+            },
+            {
+                edges,
+            },
+            {
+                visualProperties: [visualProperties],
+            },
+            {
+                status: [
+                    {
+                        success: true,
+                    },
+                ],
+            },
+        ], undefined, 2);
+    }
+}
+//# sourceMappingURL=Cx2Generator.js.map

package/dist/generators/LabeledPropertyGraph.d.ts

@@ -0,0 +1,42 @@
+import type { Maybe } from "purify-ts";
+export interface LabeledPropertyGraph {
+    readonly nodes: readonly LabeledPropertyGraph.Node[];
+    readonly relationships: readonly LabeledPropertyGraph.Relationship[];
+}
+export declare namespace LabeledPropertyGraph {
+    export type Id = string;
+    export interface Node {
+        readonly id: Id;
+        readonly label: string;
+        readonly properties: Record<PropertyName, PropertyValue>;
+    }
+    export type PropertyName = string;
+    type PropertyTypeValueMap = {
+        boolean: boolean;
+        "boolean[]": readonly boolean[];
+        double: number;
+        "double[]": readonly number[];
+        integer: bigint;
+        "integer[]": readonly bigint[];
+        long: bigint;
+        "long[]": readonly bigint[];
+        string: string;
+        "string[]": readonly string[];
+    };
+    export type PropertyType = keyof PropertyTypeValueMap;
+    export type PropertyValue = {
+        [K in PropertyType]: {
+            type: K;
+            value: PropertyTypeValueMap[K];
+        };
+    }[PropertyType];
+    export interface Relationship {
+        readonly id: Id;
+        readonly label: Maybe<string>;
+        readonly properties: Record<PropertyName, PropertyValue>;
+        readonly sourceNodeId: Id;
+        readonly targetNodeId: Id;
+    }
+    export {};
+}
+//# sourceMappingURL=LabeledPropertyGraph.d.ts.map

package/dist/generators/LabeledPropertyGraph.js

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

package/dist/generators/index.d.ts

@@ -1,4 +1,6 @@
+export * from "./AstJsonGenerator.js";
+export * from "./Cx2Generator.js";
 export * from "./Generator.js";
-export * as json from "./json/index.js";
-export * as ts from "./ts/index.js";
+export { TsGenerator } from "./ts/TsGenerator.js";
+export { ZodGenerator } from "./ts/ZodGenerator.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/generators/index.js

@@ -1,4 +1,6 @@
+export * from "./AstJsonGenerator.js";
+export * from "./Cx2Generator.js";
 export * from "./Generator.js";
-export * as json from "./json/index.js";
-export * as ts from "./ts/index.js";
+export { TsGenerator } from "./ts/TsGenerator.js";
+export { ZodGenerator } from "./ts/ZodGenerator.js";
 //# sourceMappingURL=index.js.map

package/dist/generators/transformAstToLabeledPropertyGraph.d.ts

@@ -0,0 +1,4 @@
+import type * as ast from "../ast/index.js";
+import type { LabeledPropertyGraph } from "./LabeledPropertyGraph.js";
+export declare function transformAstToLabeledPropertyGraph(ast: ast.Ast): LabeledPropertyGraph;
+//# sourceMappingURL=transformAstToLabeledPropertyGraph.d.ts.map

package/dist/generators/transformAstToLabeledPropertyGraph.js

@@ -0,0 +1,76 @@
+import { Resource } from "@rdfx/resource";
+import { Maybe } from "purify-ts";
+export function transformAstToLabeledPropertyGraph(ast) {
+    const nodes = [];
+    const relationships = [];
+    for (const namedObjectType of ast.namedObjectTypes) {
+        const id = typeId(namedObjectType);
+        const properties = {
+            name: { type: "string", value: typeName(namedObjectType) },
+        };
+        for (const namedObjectTypeProperty of namedObjectType.properties) {
+            let itemType;
+            switch (namedObjectTypeProperty.type.kind) {
+                case "DefaultValueType":
+                case "ListType":
+                case "OptionType":
+                case "SetType":
+                    itemType = namedObjectTypeProperty.type.itemType;
+                    break;
+                case "LazyObjectType":
+                    itemType = namedObjectTypeProperty.type.resolveType;
+                    break;
+                case "LazyObjectOptionType":
+                case "LazyObjectSetType":
+                    itemType = namedObjectTypeProperty.type.resolveType.itemType;
+                    break;
+                default:
+                    itemType = namedObjectTypeProperty.type;
+                    break;
+            }
+            switch (itemType.kind) {
+                case "IntersectionType":
+                case "ObjectType":
+                case "UnionType":
+                    if (itemType.name.isJust()) {
+                        relationships.push({
+                            id: Resource.Identifier.toString(namedObjectTypeProperty.shapeIdentifier),
+                            label: Maybe.of(namedObjectTypeProperty.name),
+                            properties: {},
+                            sourceNodeId: id,
+                            targetNodeId: typeId(itemType),
+                        });
+                    }
+                    break;
+                default:
+                    properties[namedObjectTypeProperty.name] = {
+                        type: "string",
+                        value: namedObjectTypeProperty.toString(),
+                    };
+            }
+        }
+        nodes.push({
+            id,
+            label: typeName(namedObjectType),
+            properties: properties,
+        });
+    }
+    for (const namedUnionType of ast.namedUnionTypes) {
+        nodes.push({
+            id: typeId(namedUnionType),
+            label: typeName(namedUnionType),
+            properties: {},
+        });
+    }
+    return {
+        nodes,
+        relationships,
+    };
+}
+function typeId(type) {
+    return type.name.orDefault(Resource.Identifier.toString(type.shapeIdentifier));
+}
+function typeName(type) {
+    return type.name.orDefault(Resource.Identifier.toString(type.shapeIdentifier));
+}
+//# sourceMappingURL=transformAstToLabeledPropertyGraph.js.map

package/dist/index.d.ts

@@ -1,9 +1,6 @@
 export * as ast from "./ast/index.js";
 export * from "./Compiler.js";
-export type { Generator } from "./generators/Generator.js";
-export { AstJsonGenerator } from "./generators/json/AstJsonGenerator.js";
-export { TsGenerator } from "./generators/ts/TsGenerator.js";
-export { ZodGenerator } from "./generators/ts/ZodGenerator.js";
+export * from "./generators/index.js";
 export * from "./input/ShapesGraph.js";
 export * from "./ShapesGraphToAstTransformer.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -1,8 +1,6 @@
 export * as ast from "./ast/index.js";
 export * from "./Compiler.js";
-export { AstJsonGenerator } from "./generators/json/AstJsonGenerator.js";
-export { TsGenerator } from "./generators/ts/TsGenerator.js";
-export { ZodGenerator } from "./generators/ts/ZodGenerator.js";
+export * from "./generators/index.js";
 export * from "./input/ShapesGraph.js";
 export * from "./ShapesGraphToAstTransformer.js";
 //# sourceMappingURL=index.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "dependencies": {
-    "@shaclmate/shacl-ast": "4.0.17",
+    "@shaclmate/shacl-ast": "4.0.19",
     "@rdfjs/data-model": "~2.1.1",
     "@rdfjs/dataset": "~2.0.2",
     "@rdfjs/prefix-map": "~0.1.2",
@@ -42,8 +42,6 @@
     "dist/enums/*.js",
     "dist/generators/*.d.ts",
     "dist/generators/*.js",
-    "dist/generators/json/*.d.ts",
-    "dist/generators/json/*.js",
     "dist/generators/ts/*.d.ts",
     "dist/generators/ts/*.js",
     "dist/generators/ts/_NamedObjectType/*.d.ts",
@@ -73,5 +71,5 @@
   },
   "type": "module",
   "types": "./dist/index.d.ts",
-  "version": "4.0.17"
+  "version": "4.0.19"
 }

package/dist/generators/json/AstJsonGenerator.d.ts

@@ -1,6 +0,0 @@
-import type * as ast from "../../ast/index.js";
-import type { Generator } from "../Generator.js";
-export declare class AstJsonGenerator implements Generator {
-    generate(ast: ast.Ast): string;
-}
-//# sourceMappingURL=AstJsonGenerator.d.ts.map