@ng-org/shex-orm 0.1.2-alpha.2 → 0.1.2-alpha.4

package/dist/schema-converter/__tests__/typingTransformer.test.js

@@ -55,8 +55,69 @@ function buildSchema() {
                     },
                 },
             },
+            {
+                type: "ShapeDecl",
+                id: "http://example.org/CollisionTest",
+                shapeExpr: {
+                    type: "Shape",
+                    extra: [TYPE_IRI],
+                    expression: {
+                        type: "EachOf",
+                        expressions: [
+                            {
+                                type: "TripleConstraint",
+                                predicate: "http://example.org/collide1/foo",
+                                valueExpr: {
+                                    type: "NodeConstraint",
+                                    datatype: "http://www.w3.org/2001/XMLSchema#string",
+                                },
+                            },
+                            {
+                                type: "TripleConstraint",
+                                predicate: "http://example.org/collide2/foo",
+                                valueExpr: {
+                                    type: "NodeConstraint",
+                                    datatype: "http://www.w3.org/2001/XMLSchema#string",
+                                },
+                            },
+                            {
+                                type: "TripleConstraint",
+                                predicate: "http://example.org/collide3/foo",
+                                valueExpr: {
+                                    type: "NodeConstraint",
+                                    datatype: "http://www.w3.org/2001/XMLSchema#string",
+                                },
+                            },
+                            {
+                                type: "TripleConstraint",
+                                predicate: "http://example.org2/collide3/foo",
+                                valueExpr: {
+                                    type: "NodeConstraint",
+                                    datatype: "http://www.w3.org/2001/XMLSchema#string",
+                                },
+                            },
+                            {
+                                type: "TripleConstraint",
+                                predicate: "http://example.org:collide4/foo",
+                                valueExpr: {
+                                    type: "NodeConstraint",
+                                    datatype: "http://www.w3.org/2001/XMLSchema#string",
+                                },
+                            },
+                            {
+                                type: "TripleConstraint",
+                                predicate: "http://example.org/collide4/foo",
+                                valueExpr: {
+                                    type: "NodeConstraint",
+                                    datatype: "http://www.w3.org/2001/XMLSchema#string",
+                                },
+                            },
+                        ],
+                    },
+                },
+            },
         ],
-    };
+    }; // satisfies Schema;
 }
 async function buildTypingsText() {
     const schema = buildSchema();
@@ -71,6 +132,15 @@ describe("ShexJTypingTransformer", () => {
     });
     it("treats EXTRA rdf:type predicates as plural", async () => {
         const typings = await buildTypingsText();
-        expect(typings).toMatch(/interface ExpenseCategory[\s\S]*?"@type": Set<"http:\/\/example\.org\/ExpenseCategory" \|[\s]*\(?string[\s]*&[\s]*\{[\s]*\}\)?>;/);
+        expect(typings).toMatch(/\"@type\": Set<\"http:\/\/example\.org\/ExpenseCategory\" | IRI & {}>;/);
+    });
+    it("handles property name collisions", async () => {
+        const typings = await buildTypingsText();
+        expect(typings).toMatch(/ collide1_foo: string/);
+        expect(typings).toMatch(/ collide2_foo: string/);
+        expect(typings).toMatch(/ org_collide3_foo: string/);
+        expect(typings).toMatch(/ org2_collide3_foo: string/);
+        expect(typings).toMatch(/ "0__http_example_org_collide4_foo"\: string/);
+        expect(typings).toMatch(/ "1__http_example_org_collide4_foo"\: string/);
     });
 });

package/dist/schema-converter/transformers/ShexJSchemaTransformer.d.ts

@@ -330,7 +330,7 @@ export declare const ShexJSchemaTransformerCompact: import("@ldo/type-traverser"
         return: Predicate;
     };
     NodeConstraint: {
-        return: DataType;
+        return: DataType | DataType[];
     };
     ShapeOr: {
         return: DataType[];

package/dist/schema-converter/transformers/ShexJSchemaTransformer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ShexJSchemaTransformer.d.ts","sourceRoot":"","sources":["../../../src/schema-converter/transformers/ShexJSchemaTransformer.ts"],"names":[],"mappings":"AAWA,OAAO,KAAK,EAAE,SAAS,EAAE,QAAQ,EAAE,KAAK,EAAE,MAAM,gBAAgB,CAAC;AA0DjE,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YAE1B;QAAE,MAAM,EAAE,KAAK,EAAE,CAAA;KAAE;eAChB;QAAE,MAAM,EAAE,KAAK,CAAA;KAAE;WACrB;QAAE,MAAM,EAAE,KAAK,CAAA;KAAE;YAChB;QAAE,MAAM,EAAE,KAAK,CAAA;KAAE;sBACP;QAAE,MAAM,EAAE,SAAS,CAAA;KAAE;oBACvB;QAAE,MAAM,EAAE,QAAQ,CAAA;KAAE;aAC3B;QAAE,MAAM,EAAE,QAAQ,EAAE,CAAA;KAAE;cACrB;QAAE,MAAM,EAAE,KAAK,CAAA;KAAE;cACjB;QAAE,MAAM,EAAE,KAAK,CAAA;KAAE;mBACZ;QAAE,MAAM,EAAE,KAAK,CAAA;KAAE;QAiNtC,CAAC"}
+{"version":3,"file":"ShexJSchemaTransformer.d.ts","sourceRoot":"","sources":["../../../src/schema-converter/transformers/ShexJSchemaTransformer.ts"],"names":[],"mappings":"AAWA,OAAO,KAAK,EAAE,SAAS,EAAE,QAAQ,EAAE,KAAK,EAAE,MAAM,gBAAgB,CAAC;AAyDjE,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YAE1B;QAAE,MAAM,EAAE,KAAK,EAAE,CAAA;KAAE;eAChB;QAAE,MAAM,EAAE,KAAK,CAAA;KAAE;WACrB;QAAE,MAAM,EAAE,KAAK,CAAA;KAAE;YAChB;QAAE,MAAM,EAAE,KAAK,CAAA;KAAE;sBACP;QAAE,MAAM,EAAE,SAAS,CAAA;KAAE;oBACvB;QAAE,MAAM,EAAE,QAAQ,GAAG,QAAQ,EAAE,CAAA;KAAE;aACxC;QAAE,MAAM,EAAE,QAAQ,EAAE,CAAA;KAAE;cACrB;QAAE,MAAM,EAAE,KAAK,CAAA;KAAE;cACjB;QAAE,MAAM,EAAE,KAAK,CAAA;KAAE;mBACZ;QAAE,MAAM,EAAE,KAAK,CAAA;KAAE;QA+OtC,CAAC"}

package/dist/schema-converter/transformers/ShexJSchemaTransformer.js

@@ -140,26 +140,17 @@ export const ShexJSchemaTransformerCompact = ShexJTraverser.createTransformer({
                 };
             }
             else if (Array.isArray(transformedChildren.valueExpr)) {
+                // DataType[] from ShapeOr or NodeConstraint with mixed types.
                 return {
                     dataTypes: transformedChildren.valueExpr, // DataType[]
                     ...commonProperties,
                 };
             }
             else {
-                // type or literal
+                // Single DataType from NodeConstraint.
                 const nodeConstraint = transformedChildren.valueExpr;
                 return {
-                    dataTypes: !Array.isArray(nodeConstraint.literals)
-                        ? [
-                            {
-                                valType: nodeConstraint.valType,
-                                literals: nodeConstraint.literals,
-                            },
-                        ]
-                        : nodeConstraint.literals.map((lit) => ({
-                            valType: nodeConstraint.valType,
-                            literals: [lit],
-                        })),
+                    dataTypes: [nodeConstraint],
                     ...commonProperties,
                 };
             }
@@ -177,36 +168,70 @@ export const ShexJSchemaTransformerCompact = ShexJTraverser.createTransformer({
                 return { valType: "iri" };
             }
             if (nodeConstraint.values) {
-                return {
-                    valType: "literal",
-                    literals: nodeConstraint.values.map(
-                    // TODO: We do not convert them to number or boolean or lang tag.
-                    // And we don't have an annotation of the literal's type.
-                    (valueRecord) => {
-                        // If valueRecord is a string (IRIREF), return it directly
-                        if (typeof valueRecord === "string") {
-                            return valueRecord;
-                        }
-                        // Handle ObjectLiteral (has .value property)
-                        if ("value" in valueRecord) {
-                            return valueRecord.value;
+                // In ShEx, [val1 val2 val3] means "one of these values" (OR semantics).
+                // Each literal value becomes a separate DataType entry.
+                const dataTypes = nodeConstraint.values.map((valueRecord) => {
+                    // If valueRecord is an IRIREF...
+                    if (typeof valueRecord === "string") {
+                        return {
+                            valType: "iri",
+                            literals: [valueRecord],
+                        };
+                    }
+                    // Handle ObjectLiteral (has .value property).
+                    if ("value" in valueRecord) {
+                        const val = valueRecord.value;
+                        // Determine type from datatype if available.
+                        if ("type" in valueRecord && valueRecord.type) {
+                            return {
+                                valType: rdfDataTypeToBasic(valueRecord.type),
+                                literals: [val],
+                            };
                         }
-                        // Handle other types with .id property (if any)
-                        if ("id" in valueRecord) {
-                            return valueRecord.id;
+                        if (typeof val === "number") {
+                            return {
+                                valType: "number",
+                                literals: [val],
+                            };
                         }
-                        // Handle Language type (has .languageTag)
-                        if ("languageTag" in valueRecord) {
-                            return valueRecord.languageTag;
+                        if (typeof val === "boolean") {
+                            return {
+                                valType: "boolean",
+                                literals: [val],
+                            };
                         }
-                        // Handle stem-based types (IriStem, LiteralStem, LanguageStem)
-                        if ("stem" in valueRecord) {
-                            return valueRecord.stem;
-                        }
-                        // Fallback - should not happen in well-formed ShEx
-                        return undefined;
-                    }),
-                };
+                        return {
+                            valType: "string",
+                            literals: [val],
+                        };
+                    }
+                    // Handle other types with .id property (if any).
+                    if ("id" in valueRecord) {
+                        return {
+                            valType: "iri",
+                            literals: [valueRecord.id],
+                        };
+                    }
+                    // Handle language-tagged strings.
+                    if ("languageTag" in valueRecord) {
+                        return {
+                            valType: "string",
+                            literals: [valueRecord.languageTag],
+                        };
+                    }
+                    // Handle stem-based types (IriStem, LiteralStem, LanguageStem).
+                    if ("stem" in valueRecord) {
+                        return {
+                            valType: "string",
+                            literals: [valueRecord.stem],
+                        };
+                    }
+                    // Fallback - should not happen in well-formed ShEx
+                    return {
+                        valType: "string",
+                    };
+                });
+                return dataTypes;
             }
             // Maybe we should throw instead...
             throw {
@@ -219,8 +244,11 @@ export const ShexJSchemaTransformerCompact = ShexJTraverser.createTransformer({
     ShapeOr: {
         transformer: async (shapeOr, getTransformedChildren) => {
             const { shapeExprs } = await getTransformedChildren();
-            // Either a shape IRI, a nested shape or a node CompactSchemaValue (node constraint).
-            return (Array.isArray(shapeExprs) ? shapeExprs : [shapeExprs]);
+            // Each shapeExpr can be a shape IRI (string), a nested Shape, a DataType,
+            // or a DataType[] (from NodeConstraint with multiple types).
+            // We need to flatten arrays to get a single DataType[].
+            const exprs = Array.isArray(shapeExprs) ? shapeExprs : [shapeExprs];
+            return exprs.flatMap((expr) => Array.isArray(expr) ? expr : [expr]);
         },
     },
     // Transformer from ShapeAnd

package/dist/schema-converter/util/annotateReadablePredicates.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"annotateReadablePredicates.d.ts","sourceRoot":"","sources":["../../../src/schema-converter/util/annotateReadablePredicates.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAAE,MAAM,EAA8C,MAAM,OAAO,CAAC;AAUhF;;;;GAIG;AACH,MAAM,CAAC,OAAO,UAAU,0BAA0B,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAmJvE"}
+{"version":3,"file":"annotateReadablePredicates.d.ts","sourceRoot":"","sources":["../../../src/schema-converter/util/annotateReadablePredicates.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAAE,MAAM,EAA8C,MAAM,OAAO,CAAC;AAUhF;;;;GAIG;AACH,MAAM,CAAC,OAAO,UAAU,0BAA0B,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CA0MvE"}

package/dist/schema-converter/util/annotateReadablePredicates.js

@@ -8,9 +8,9 @@
 // according to those terms.
 // SPDX-License-Identifier: Apache-2.0 OR MIT
 // Split IRI by colon, slash and hash; drop empties
-const splitIriTokens = (iri) => iri.split(/[:/#]+/).filter(Boolean);
+const splitIriTokens = (iri) => iri.split(/[:/#.]+/).filter(Boolean);
 // Keep dots and dashes (so 0.1 stays as 0.1) but sanitize everything else
-const sanitize = (s) => s.replace(/[^\w.\-]/g, "_");
+const sanitize = (s) => s.replace(/[^\w.\-@]/g, "_");
 /**
  * Annotate EachOf-level TripleConstraints with a collision-free readablePredicate.
  * Rule: for any group that shares the same local token, rename all members using
@@ -23,73 +23,102 @@ export default function annotateReadablePredicates(schema) {
             eachOf.type !== "EachOf" ||
             !Array.isArray(eachOf.expressions))
             return;
-        const tcs = eachOf.expressions.filter((e) => typeof e === "object" &&
+        const tripleConstraints = eachOf.expressions.filter((e) => typeof e === "object" &&
             e !== null &&
             e.type === "TripleConstraint");
-        if (tcs.length > 0) {
-            // Group by local token (last segment of IRI) and set a base readablePredicate for all
-            const readableNameToPredicatesMap = new Map();
-            for (const tripleConstraint of tcs) {
-                // Use the name based on the IRI ending.
-                let readableName;
-                // Special case rdfs:type => @type
-                if (tripleConstraint.predicate ===
-                    "http://www.w3.org/1999/02/22-rdf-syntax-ns#type") {
-                    readableName = "@type";
+        if (tripleConstraints.length > 0) {
+            // Add a triple constraint (tc) to parent tree node.
+            // The tree branches on name collisions.
+            const addToPreds = (depth, parent, iriElements, tc) => {
+                // Get the name of the next IRI part (e.g. the foaf from foaf_name).
+                // It can be that we are out of bounds. In that case we use "".
+                // That way the final name remains the same, unless we still collisions.
+                // In that case, we enumerate.
+                const key = iriElements[depth] ?? "";
+                // Case no collision: Add triple constraint as leaf.
+                if (!parent.children[key]) {
+                    parent.children[key] = {
+                        leaf: { tc, iriElements },
+                        children: {},
+                    };
                 }
-                else {
-                    const tokens = splitIriTokens(tripleConstraint.predicate);
-                    readableName = tokens.length
-                        ? tokens[tokens.length - 1]
-                        : tripleConstraint.predicate;
-                }
-                // default base name for non-colliders
-                tripleConstraint.readablePredicate = readableName;
-                const groupMembers = readableNameToPredicatesMap.get(readableName) ?? [];
-                groupMembers.push(tripleConstraint);
-                readableNameToPredicatesMap.set(readableName, groupMembers);
-            }
-            // Resolve each group (rename all in collisions)
-            for (const [, groupMembers] of readableNameToPredicatesMap) {
-                if (groupMembers.length <= 1)
-                    continue;
-                const used = new Set();
-                const local = splitIriTokens(groupMembers[0].predicate).slice(-1)[0] ??
-                    "";
-                for (const tc of groupMembers) {
-                    const tokens = splitIriTokens(tc.predicate);
-                    let localIdx = tokens.lastIndexOf(local);
-                    if (localIdx === -1)
-                        localIdx = Math.max(tokens.length - 1, 0);
-                    let prefixIdx = localIdx - 1;
-                    let assigned = false;
-                    while (prefixIdx >= 0) {
-                        const cand = `${sanitize(tokens[prefixIdx])}_${sanitize(tokens[localIdx])}`;
-                        if (!used.has(cand)) {
-                            tc.readablePredicate = cand;
-                            used.add(cand);
-                            assigned = true;
-                            break;
-                        }
-                        prefixIdx -= 1;
+                else if (key === "") {
+                    // Case out of bounds but not the only one
+                    // Add a counter prefix
+                    const node = parent.children[key];
+                    if (node.leaf) {
+                        // If this child has a leaf, that means it didn't have children before.
+                        // Add a __counter prefix__ now.
+                        node.children = {
+                            ["0"]: {
+                                leaf: node.leaf,
+                                children: {},
+                            },
+                        };
+                        // Remove moved leaf from old node.
+                        node.leaf = false;
                     }
-                    if (!assigned) {
-                        const iriNoProto = tc.predicate.replace(/^[a-z]+:\/\//i, "");
-                        const composite = sanitize(iriNoProto
-                            .split(/[:/#]+/)
-                            .slice(0, -1)
-                            .join("_") || "iri");
-                        let cand = `${composite}_${sanitize(tokens[localIdx] || local)}`;
-                        let n = 1;
-                        while (used.has(cand))
-                            cand = `${cand}_${n++}`;
-                        tc.readablePredicate = cand;
-                        used.add(cand);
+                    // Add counter to iriElements -> will be picked up by recursion call.
+                    iriElements[depth + 1] = Object.keys(node.children).length.toString();
+                    addToPreds(depth + 1, node, iriElements, tc);
+                }
+                else {
+                    // Case collision: create a new child
+                    const node = parent.children[key];
+                    if (node.leaf) {
+                        // If this child has a leaf, that means it didn't have children before.
+                        // Move the leaf to the new children.
+                        const childKey = node.leaf.iriElements[depth + 1] ?? "";
+                        node.children = {
+                            [childKey]: {
+                                leaf: node.leaf,
+                                children: {},
+                            },
+                        };
+                        // Remove moved leaf from old node.
+                        node.leaf = false;
                     }
+                    addToPreds(depth + 1, node, iriElements, tc);
+                }
+            };
+            // Root structure to keep names for triple constraints.
+            // Keys are the readable names of the predicates
+            const rootPredTree = {
+                leaf: false,
+                children: {},
+            };
+            // Add all triple constraints to root tree.
+            for (const tripleConstraint of tripleConstraints) {
+                const iri = tripleConstraint.predicate;
+                if (iri === "http://www.w3.org/1999/02/22-rdf-syntax-ns#type") {
+                    // Special case: convert type predicate to @type
+                    addToPreds(0, rootPredTree, ["@type"], tripleConstraint);
+                }
+                else {
+                    addToPreds(0, rootPredTree, 
+                    // Divide IRI in sanitized parts, start from end (property name)
+                    splitIriTokens(iri).map(sanitize).reverse(), tripleConstraint);
                 }
             }
+            // Traverse tree and annotate
+            const annotatePreds = (parentTree, accumulatedName) => {
+                // If we reached the leaf, annotate with name
+                if (parentTree?.leaf) {
+                    parentTree.leaf.tc.readablePredicate = accumulatedName;
+                    return;
+                }
+                // Recurse for all children.
+                for (const key of Object.keys(parentTree.children ?? {})) {
+                    const name = accumulatedName === ""
+                        ? key // Just use name
+                        : `${key}_${accumulatedName}`; // Make composite.
+                    // Annotate children
+                    annotatePreds(parentTree.children[key], name);
+                }
+            };
+            annotatePreds(rootPredTree, "");
             // Recurse into nested valueExpr shapes of each TC
-            for (const tc of tcs) {
+            for (const tc of tripleConstraints) {
                 const ve = tc.valueExpr;
                 if (ve && typeof ve === "object") {
                     const t = ve.type;

package/dist/types.d.ts

@@ -1,3 +1,6 @@
+/**
+ * TODO: Short documentation on schema generation
+ */
 export interface ShapeType<T extends BaseType> {
     schema: Schema;
     shape: string;
@@ -13,12 +16,12 @@ export interface Shape {
     predicates: Predicate[];
 }
 export type DataType = {
-    /** The required literal value(s), if type is `literal`. Others are allowed, if `extra` is true. */
+    /** The required literal value(s). Additional values are allowed, if `extra` is true. */
     literals?: number[] | string[] | boolean;
     /** If `valType` is `"shape"`, the nested shape or its reference. Use reference for serialization. */
     shape?: string | Shape;
     /** The type of object value for a triple constraint. */
-    valType: "number" | "string" | "boolean" | "iri" | "literal" | "shape";
+    valType: "number" | "string" | "boolean" | "iri" | "shape";
 };
 export interface Predicate {
     /** Allowed type of object. If more than one is present, either of them is allowed. */

package/dist/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAUA,MAAM,WAAW,SAAS,CAAC,CAAC,SAAS,QAAQ;IACzC,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,QAAS,SAAQ,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;IACjD,KAAK,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,MAAM,MAAM,GAAG;IACjB,CAAC,EAAE,EAAE,MAAM,GAAG,KAAK,CAAC;CACvB,CAAC;AAEF,MAAM,WAAW,KAAK;IAClB,GAAG,EAAE,MAAM,CAAC;IACZ,UAAU,EAAE,SAAS,EAAE,CAAC;CAC3B;AAED,MAAM,MAAM,QAAQ,GAAG;IACnB,mGAAmG;IACnG,QAAQ,CAAC,EAAE,MAAM,EAAE,GAAG,MAAM,EAAE,GAAG,OAAO,CAAC;IACzC,qGAAqG;IACrG,KAAK,CAAC,EAAE,MAAM,GAAG,KAAK,CAAC;IACvB,wDAAwD;IACxD,OAAO,EAAE,QAAQ,GAAG,QAAQ,GAAG,SAAS,GAAG,KAAK,GAAG,SAAS,GAAG,OAAO,CAAC;CAC1E,CAAC;AAEF,MAAM,WAAW,SAAS;IACtB,sFAAsF;IACtF,SAAS,EAAE,QAAQ,EAAE,CAAC;IACtB,6BAA6B;IAC7B,GAAG,EAAE,MAAM,CAAC;IACZ,wEAAwE;IACxE,iBAAiB,EAAE,MAAM,CAAC;IAC1B,6DAA6D;IAC7D,cAAc,EAAE,MAAM,CAAC;IACvB,wCAAwC;IACxC,cAAc,EAAE,MAAM,CAAC;IACvB,uEAAuE;IACvE,KAAK,CAAC,EAAE,OAAO,CAAC;CACnB"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAUA;;GAEG;AACH,MAAM,WAAW,SAAS,CAAC,CAAC,SAAS,QAAQ;IACzC,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,QAAS,SAAQ,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;IACjD,KAAK,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,MAAM,MAAM,GAAG;IACjB,CAAC,EAAE,EAAE,MAAM,GAAG,KAAK,CAAC;CACvB,CAAC;AAEF,MAAM,WAAW,KAAK;IAClB,GAAG,EAAE,MAAM,CAAC;IACZ,UAAU,EAAE,SAAS,EAAE,CAAC;CAC3B;AAED,MAAM,MAAM,QAAQ,GAAG;IACnB,wFAAwF;IACxF,QAAQ,CAAC,EAAE,MAAM,EAAE,GAAG,MAAM,EAAE,GAAG,OAAO,CAAC;IACzC,qGAAqG;IACrG,KAAK,CAAC,EAAE,MAAM,GAAG,KAAK,CAAC;IACvB,wDAAwD;IACxD,OAAO,EAAE,QAAQ,GAAG,QAAQ,GAAG,SAAS,GAAG,KAAK,GAAG,OAAO,CAAC;CAC9D,CAAC;AAEF,MAAM,WAAW,SAAS;IACtB,sFAAsF;IACtF,SAAS,EAAE,QAAQ,EAAE,CAAC;IACtB,6BAA6B;IAC7B,GAAG,EAAE,MAAM,CAAC;IACZ,wEAAwE;IACxE,iBAAiB,EAAE,MAAM,CAAC;IAC1B,6DAA6D;IAC7D,cAAc,EAAE,MAAM,CAAC;IACvB,wCAAwC;IACxC,cAAc,EAAE,MAAM,CAAC;IACvB,uEAAuE;IACvE,KAAK,CAAC,EAAE,OAAO,CAAC;CACnB"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ng-org/shex-orm",
-  "version": "0.1.2-alpha.2",
+  "version": "0.1.2-alpha.4",
   "description": "",
   "type": "module",
   "main": "./dist/index.js",
@@ -17,29 +17,21 @@
     "@types/ejs": "^3.1.1",
     "@types/fs-extra": "^9.0.13",
     "@types/jsonld": "^1.5.15",
-    "@types/prompts": "^2.4.9",
     "@types/shexj": "^2.1.4",
     "typescript": "^5.9.2",
     "vitest": "^3.2.4"
   },
   "dependencies": {
-    "@jeswr/shacl2shex": "^1.1.0",
     "@ldo/traverser-shexj": "1.0.0-alpha.28",
     "@ldo/type-traverser": "1.0.0-alpha.28",
     "@shexjs/parser": "^1.0.0-alpha.24",
-    "child-process-promise": "^2.2.1",
     "commander": "^14.0.1",
     "dts-dom": "~3.6.0",
     "ejs": "^3.1.8",
     "fs-extra": "^10.1.0",
     "jsonld2graphobject": "^0.0.5",
     "loading-cli": "^1.1.0",
-    "prettier": "^3.0.3",
-    "prompts": "^2.4.2",
-    "rdf-dereference-store": "^1.4.0",
-    "rdf-namespaces": "^1.13.1",
-    "ts-morph": "^24.0.0",
-    "type-fest": "^2.19.0"
+    "prettier": "^3.0.3"
   },
   "files": [
     "dist"