npm - @ng-org/shex-orm - Versions diffs - 0.1.2-alpha.7 → 0.1.2-alpha.8 - Mend

@ng-org/shex-orm 0.1.2-alpha.7 → 0.1.2-alpha.8

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (12) hide show

package/dist/schema-converter/__tests__/schemaTransformer.test.d.ts ADDED Viewed

	@@ -0,0 +1,2 @@
1	+ export {};
2	+ //# sourceMappingURL=schemaTransformer.test.d.ts.map

package/dist/schema-converter/__tests__/schemaTransformer.test.d.ts.map ADDED Viewed

	@@ -0,0 +1 @@
1	+ {"version":3,"file":"schemaTransformer.test.d.ts","sourceRoot":"","sources":["../../../src/schema-converter/__tests__/schemaTransformer.test.ts"],"names":[],"mappings":""}

package/dist/schema-converter/__tests__/schemaTransformer.test.js ADDED Viewed

@@ -0,0 +1,209 @@
+import { describe, it, expect } from "vitest";
+import parser from "@shexjs/parser";
+import annotateReadablePredicates from "../util/annotateReadablePredicates.js";
+import { shexJConverter } from "../converter.js";
+// Generated with Claude Opus 4.6
+const TYPE_IRI = "http://www.w3.org/1999/02/22-rdf-syntax-ns#type";
+const BASE_IRI = "http://example.org/";
+/** Parse ShEx text → ShExJ → annotate → convert → return flattened schema. */
+async function buildSchema(shex) {
+    // @ts-ignore
+    const shexJ = parser.construct(BASE_IRI).parse(shex);
+    // @ts-ignore
+    annotateReadablePredicates(shexJ);
+    const [, schema] = await shexJConverter(shexJ);
+    return schema;
+}
+/** Find a predicate by its IRI in a shape. */
+function findPredicate(shape, predicateIri) {
+    return shape.predicates.find((p) => p.iri === predicateIri);
+}
+// ---------------------------------------------------------------------------
+// Common prefixes used in all test schemas
+// ---------------------------------------------------------------------------
+const PREFIXES = `
+PREFIX ex: <http://example.org/>
+PREFIX xsd: <http://www.w3.org/2001/XMLSchema#>
+`;
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+describe("ShexJSchemaTransformer", () => {
+    // Single shape reference via @
+    it("converts a single @-prefixed shape reference to valType 'shape'", async () => {
+        const schema = await buildSchema(`
+            ${PREFIXES}
+            ex:ItemShape {
+                ex:name xsd:string ;
+                ex:category @ex:CategoryShape ;
+            }
+            ex:CategoryShape EXTRA a {
+                a [ ex:Category ] ;
+                ex:name xsd:string ;
+            }
+        `);
+        const item = schema["http://example.org/ItemShape"];
+        const pred = findPredicate(item, "http://example.org/category");
+        expect(pred).toBeDefined();
+        expect(pred.dataTypes).toHaveLength(1);
+        expect(pred.dataTypes[0]).toEqual({
+            valType: "shape",
+            shape: "http://example.org/CategoryShape",
+        });
+    });
+    // Shape reference without @ (datatype-like IRI) → valType "iri"
+    it("converts an unrecognized datatype IRI to valType 'iri'", async () => {
+        const schema = await buildSchema(`
+            ${PREFIXES}
+            ex:ItemShape {
+                ex:name xsd:string ;
+                ex:category ex:CategoryShape ;
+            }
+            ex:CategoryShape EXTRA a {
+                a [ ex:Category ] ;
+                ex:name xsd:string ;
+            }
+        `);
+        const item = schema["http://example.org/ItemShape"];
+        const pred = findPredicate(item, "http://example.org/category");
+        expect(pred).toBeDefined();
+        expect(pred.dataTypes).toHaveLength(1);
+        expect(pred.dataTypes[0].valType).toBe("iri");
+    });
+    // ShapeOr with multiple shape references
+    it("converts ShapeOr with two shape references to two shape DataTypes", async () => {
+        const schema = await buildSchema(`
+            ${PREFIXES}
+            ex:ItemShape {
+                ex:name xsd:string ;
+                ex:category (@ex:CategoryShape OR @ex:TagShape) ;
+            }
+            ex:CategoryShape EXTRA a {
+                a [ ex:Category ] ;
+                ex:name xsd:string ;
+            }
+            ex:TagShape EXTRA a {
+                a [ ex:Tag ] ;
+                ex:label xsd:string ;
+            }
+        `);
+        const item = schema["http://example.org/ItemShape"];
+        const pred = findPredicate(item, "http://example.org/category");
+        expect(pred).toBeDefined();
+        expect(pred.dataTypes).toHaveLength(2);
+        expect(pred.dataTypes[0]).toEqual({
+            valType: "shape",
+            shape: "http://example.org/CategoryShape",
+        });
+        expect(pred.dataTypes[1]).toEqual({
+            valType: "shape",
+            shape: "http://example.org/TagShape",
+        });
+    });
+    // ShapeOr mixing primitive and shape reference
+    it("converts ShapeOr mixing a primitive and a shape reference", async () => {
+        const schema = await buildSchema(`
+            ${PREFIXES}
+            ex:ItemShape {
+                ex:name xsd:string ;
+                ex:catOrString xsd:string OR @ex:CategoryShape ;
+            }
+            ex:CategoryShape EXTRA a {
+                a [ ex:Category ] ;
+                ex:name xsd:string ;
+            }
+        `);
+        const item = schema["http://example.org/ItemShape"];
+        const pred = findPredicate(item, "http://example.org/catOrString");
+        expect(pred).toBeDefined();
+        expect(pred.dataTypes).toHaveLength(2);
+        const types = pred.dataTypes.map((d) => d.valType);
+        expect(types).toContain("string");
+        expect(types).toContain("shape");
+        const shapeDt = pred.dataTypes.find((d) => d.valType === "shape");
+        expect(shapeDt.shape).toBe("http://example.org/CategoryShape");
+    });
+    // Anonymous inline shape → flattened to root with derived IRI
+    it("flattens anonymous inline shapes to root with a derived IRI", async () => {
+        const schema = await buildSchema(`
+            ${PREFIXES}
+            ex:ItemShape {
+                ex:name xsd:string ;
+                ex:category EXTRA a {
+                    a [ ex:Category ] ;
+                    ex:name xsd:string ;
+                } ;
+            }
+        `);
+        const derivedIri = "http://example.org/ItemShape||http://example.org/category";
+        // The parent predicate should reference the derived IRI
+        const item = schema["http://example.org/ItemShape"];
+        const pred = findPredicate(item, "http://example.org/category");
+        expect(pred).toBeDefined();
+        expect(pred.dataTypes).toHaveLength(1);
+        expect(pred.dataTypes[0]).toEqual({
+            valType: "shape",
+            shape: derivedIri,
+        });
+        // The anonymous shape should exist as a root-level entry
+        const flattenedShape = schema[derivedIri];
+        expect(flattenedShape).toBeDefined();
+        expect(flattenedShape.iri).toBe(derivedIri);
+        const namePred = findPredicate(flattenedShape, "http://example.org/name");
+        expect(namePred).toBeDefined();
+    });
+    // IRI value set (enumeration)
+    it("converts IRI value sets to multiple iri DataTypes with literals", async () => {
+        const schema = await buildSchema(`
+            ${PREFIXES}
+            ex:ItemShape {
+                ex:name xsd:string ;
+                ex:status [ex:Active ex:Archived ex:Deleted] ;
+            }
+        `);
+        const item = schema["http://example.org/ItemShape"];
+        const pred = findPredicate(item, "http://example.org/status");
+        expect(pred).toBeDefined();
+        expect(pred.dataTypes).toHaveLength(3);
+        expect(pred.dataTypes[0]).toEqual({
+            valType: "iri",
+            literals: ["http://example.org/Active"],
+        });
+        expect(pred.dataTypes[1]).toEqual({
+            valType: "iri",
+            literals: ["http://example.org/Archived"],
+        });
+        expect(pred.dataTypes[2]).toEqual({
+            valType: "iri",
+            literals: ["http://example.org/Deleted"],
+        });
+    });
+    // Single-predicate shape (no EachOf wrapper)
+    it("handles shapes with only one predicate", async () => {
+        const schema = await buildSchema(`
+            ${PREFIXES}
+            ex:ItemShape {
+                ex:name xsd:string ;
+            }
+        `);
+        const item = schema["http://example.org/ItemShape"];
+        expect(item).toBeDefined();
+        expect(item.predicates).toHaveLength(1);
+        expect(item.predicates[0].iri).toBe("http://example.org/name");
+        expect(item.predicates[0].dataTypes[0].valType).toBe("string");
+    });
+    // EXTRA predicate
+    it("marks EXTRA predicates with extra: true", async () => {
+        const schema = await buildSchema(`
+            ${PREFIXES}
+            ex:CategoryShape EXTRA a {
+                a [ ex:Category ] ;
+                ex:name xsd:string ;
+            }
+        `);
+        const cat = schema["http://example.org/CategoryShape"];
+        const typePred = findPredicate(cat, TYPE_IRI);
+        expect(typePred).toBeDefined();
+        expect(typePred.extra).toBe(true);
+    });
+});

package/dist/schema-converter/templates/schema.ejs CHANGED Viewed

@@ -5,4 +5,4 @@ import type { Schema } from "@ng-org/shex-orm";
 * <%- fileName %>Schema: Schema for <%- fileName %>
                 * =============================================================================
                 */
-                export const <%- fileName %>Schema: Schema = <%- compactSchema %>;
+                export const <%- fileName %>Schema = <%- compactSchema %> as const satisfies Schema;

package/dist/schema-converter/templates/shapeTypes.ejs CHANGED Viewed

@@ -1,14 +1,15 @@
 import type { ShapeType } from "@ng-org/shex-orm";
-import { <%- fileName %>Schema } from "./<%- fileName %>.schema";
+import { <%- fileName %>Schema } from "./<%- fileName %>.schema.ts";
     import type {
     <% typings.forEach((typing)=> { if (!/Id$/.test(typing.dts.name)) { -%>
       <%- typing.dts.name %>,
-        <% } }); -%>} from "./<%- fileName %>.typings";
+        <% } }); -%>} from "./<%- fileName %>.typings.ts";
             // ShapeTypes for <%- fileName %>
               <% typings.forEach((typing)=> { if (!/Id$/.test(typing.dts.name)) { -%>
-                export const <%- typing.dts.name %>ShapeType: ShapeType<<%- typing.dts.name %>> = {
-                    schema: <%- fileName %>Schema,
-                      shape: "<%- typing.dts.shapeId %>",
-                        };
+                export const <%- typing.dts.name %>ShapeType = {
+                  schema: <%- fileName %>Schema,
+                    shape: "<%- typing.dts.shapeId %>",
+                      } as const satisfies ShapeType<<%- typing.dts.name %>>;
                         <% } }); -%>

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

	@@ -1 +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;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"}
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;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;QAgRtC,CAAC"}

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

@@ -59,7 +59,7 @@ const rdfDataTypeToBasic = (dataType) => {
         case "http://www.w3.org/2001/XMLSchema#anyURI":
             return "iri";
         default:
-            return "string";
+            return "iri";
     }
 };
 export const ShexJSchemaTransformerCompact = ShexJTraverser.createTransformer({
@@ -81,7 +81,12 @@ export const ShexJSchemaTransformerCompact = ShexJTraverser.createTransformer({
             // TODO: We don't handles those
             _shape.closed;
             const transformedChildren = await getTransformedChildren();
-            const compactShape = transformedChildren.expression;
+            const expr = transformedChildren.expression;
+            // EachOf returns a Shape ({ iri, predicates }), but a single
+            // TripleConstraint returns a bare Predicate. Normalize both.
+            const compactShape = expr && "predicates" in expr
+                ? expr
+                : { iri: "", predicates: [expr] };
             for (const extra of _shape.extra || []) {
                 const extraPredicate = compactShape.predicates.find((p) => p.iri === extra);
                 if (extraPredicate)
@@ -128,12 +133,25 @@ export const ShexJSchemaTransformerCompact = ShexJTraverser.createTransformer({
             }
             else if (transformedChildren.valueExpr &&
                 transformedChildren.valueExpr.predicates) {
-                // Nested object
+                const resolvedShape = transformedChildren.valueExpr;
+                if (resolvedShape.iri) {
+                    // Named shape reference: Use the IRI string.
+                    return {
+                        dataTypes: [
+                            {
+                                valType: "shape",
+                                shape: resolvedShape.iri,
+                            },
+                        ],
+                        ...commonProperties,
+                    };
+                }
+                // Anonymous inline shape: Pass as shape object for flattenSchema to convert.
                 return {
                     dataTypes: [
                         {
                             valType: "shape",
-                            shape: transformedChildren.valueExpr,
+                            shape: resolvedShape, // Make type fit as any (object will be flattened).
                         },
                     ],
                     ...commonProperties,
@@ -248,7 +266,24 @@ export const ShexJSchemaTransformerCompact = ShexJTraverser.createTransformer({
             // 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]);
+            return exprs.flatMap((expr) => {
+                if (Array.isArray(expr))
+                    return expr;
+                // Resolved shape reference: Convert to DataType with shape IRI.
+                if (expr && typeof expr === "object" && "predicates" in expr) {
+                    return [
+                        {
+                            valType: "shape",
+                            shape: expr.iri,
+                        },
+                    ];
+                }
+                // String shape reference
+                if (typeof expr === "string") {
+                    return [{ valType: "shape", shape: expr }];
+                }
+                return [expr];
+            });
         },
     },
     // Transformer from ShapeAnd

package/dist/schema-converter/transformers/ShexJTypingTransformer.d.ts.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"ShexJTypingTransformer.d.ts","sourceRoot":"","sources":["../../../src/schema-converter/transformers/ShexJTypingTransformer.ts"],"names":[],"mappings":"AAcA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,OAAO,CAAC;AACxC,OAAO,KAAK,GAAG,MAAM,SAAS,CAAC;AAC/B,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,SAAS,CAAC;AAEpD,MAAM,WAAW,yBAA0B,SAAQ,oBAAoB;IACnE,OAAO,CAAC,EAAE,MAAM,CAAC;CACpB;AAGD,eAAO,MAAM,4BAA4B,aAAoB,CAAC;AAE9D,MAAM,WAAW,yBAAyB;IACtC,cAAc,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,KAAK,MAAM,CAAC;CAC7D;AAeD,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,UAOvC;AAED;;GAEG;AACH,wBAAgB,SAAS,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAI7C;AAED,wBAAgB,sBAAsB,CAAC,GAAG,EAAE;IACxC,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,WAAW,CAAC,EAAE,UAAU,EAAE,CAAC;CAC9B,GAAG,MAAM,GAAG,SAAS,CAgBrB;AAyPD,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YAE1B;QAAE,MAAM,EAAE,GAAG,CAAC,mBAAmB,EAAE,CAAA;KAAE;eAClC;QAAE,MAAM,EAAE,GAAG,CAAC,oBAAoB,CAAA;KAAE;WACxC;QAAE,MAAM,EAAE,GAAG,CAAC,oBAAoB,CAAA;KAAE;YACnC;QAAE,MAAM,EAAE,GAAG,CAAC,UAAU,GAAG,GAAG,CAAC,oBAAoB,CAAA;KAAE;sBAC3C;QAAE,MAAM,EAAE,GAAG,CAAC,mBAAmB,CAAA;KAAE;oBACrC;QAAE,MAAM,EAAE,GAAG,CAAC,IAAI,CAAA;KAAE;aAC3B;QAAE,MAAM,EAAE,GAAG,CAAC,SAAS,CAAA;KAAE;cACxB;QAAE,MAAM,EAAE,GAAG,CAAC,gBAAgB,CAAA;KAAE;cAChC;QAAE,MAAM,EAAE,KAAK,CAAA;KAAE;mBACZ;QAAE,MAAM,EAAE,KAAK,CAAA;KAAE;~~QAwctC~~,CAAC"}
1	+ {"version":3,"file":"ShexJTypingTransformer.d.ts","sourceRoot":"","sources":["../../../src/schema-converter/transformers/ShexJTypingTransformer.ts"],"names":[],"mappings":"AAcA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,OAAO,CAAC;AACxC,OAAO,KAAK,GAAG,MAAM,SAAS,CAAC;AAC/B,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,SAAS,CAAC;AAEpD,MAAM,WAAW,yBAA0B,SAAQ,oBAAoB;IACnE,OAAO,CAAC,EAAE,MAAM,CAAC;CACpB;AAGD,eAAO,MAAM,4BAA4B,aAAoB,CAAC;AAE9D,MAAM,WAAW,yBAAyB;IACtC,cAAc,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,KAAK,MAAM,CAAC;CAC7D;AAeD,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,UAOvC;AAED;;GAEG;AACH,wBAAgB,SAAS,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAI7C;AAED,wBAAgB,sBAAsB,CAAC,GAAG,EAAE;IACxC,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,WAAW,CAAC,EAAE,UAAU,EAAE,CAAC;CAC9B,GAAG,MAAM,GAAG,SAAS,CAgBrB;AAyPD,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YAE1B;QAAE,MAAM,EAAE,GAAG,CAAC,mBAAmB,EAAE,CAAA;KAAE;eAClC;QAAE,MAAM,EAAE,GAAG,CAAC,oBAAoB,CAAA;KAAE;WACxC;QAAE,MAAM,EAAE,GAAG,CAAC,oBAAoB,CAAA;KAAE;YACnC;QAAE,MAAM,EAAE,GAAG,CAAC,UAAU,GAAG,GAAG,CAAC,oBAAoB,CAAA;KAAE;sBAC3C;QAAE,MAAM,EAAE,GAAG,CAAC,mBAAmB,CAAA;KAAE;oBACrC;QAAE,MAAM,EAAE,GAAG,CAAC,IAAI,CAAA;KAAE;aAC3B;QAAE,MAAM,EAAE,GAAG,CAAC,SAAS,CAAA;KAAE;cACxB;QAAE,MAAM,EAAE,GAAG,CAAC,gBAAgB,CAAA;KAAE;cAChC;QAAE,MAAM,EAAE,KAAK,CAAA;KAAE;mBACZ;QAAE,MAAM,EAAE,KAAK,CAAA;KAAE;QAketC,CAAC"}

package/dist/schema-converter/transformers/ShexJTypingTransformer.js CHANGED Viewed

@@ -524,6 +524,31 @@ export const ShexJTypingTransformerCompact = ShexJTraverser.createTransformer({
         transformer: async (nodeConstraint) => {
             if (nodeConstraint.datatype) {
                 switch (nodeConstraint.datatype) {
+                    case "http://www.w3.org/2001/XMLSchema#string":
+                    case "http://www.w3.org/2001/XMLSchema#ENTITIES":
+                    case "http://www.w3.org/2001/XMLSchema#ENTITY":
+                    case "http://www.w3.org/2001/XMLSchema#ID":
+                    case "http://www.w3.org/2001/XMLSchema#IDREF":
+                    case "http://www.w3.org/2001/XMLSchema#IDREFS":
+                    case "http://www.w3.org/2001/XMLSchema#language":
+                    case "http://www.w3.org/2001/XMLSchema#Name":
+                    case "http://www.w3.org/2001/XMLSchema#NCName":
+                    case "http://www.w3.org/2001/XMLSchema#NMTOKEN":
+                    case "http://www.w3.org/2001/XMLSchema#NMTOKENS":
+                    case "http://www.w3.org/2001/XMLSchema#normalizedString":
+                    case "http://www.w3.org/2001/XMLSchema#QName":
+                    case "http://www.w3.org/2001/XMLSchema#token":
+                    case "http://www.w3.org/2001/XMLSchema#date":
+                    case "http://www.w3.org/2001/XMLSchema#dateTime":
+                    case "http://www.w3.org/2001/XMLSchema#duration":
+                    case "http://www.w3.org/2001/XMLSchema#gDay":
+                    case "http://www.w3.org/2001/XMLSchema#gMonth":
+                    case "http://www.w3.org/2001/XMLSchema#gMonthDay":
+                    case "http://www.w3.org/2001/XMLSchema#gYear":
+                    case "http://www.w3.org/2001/XMLSchema#gYearMonth":
+                    case "http://www.w3.org/2001/XMLSchema#time":
+                    case "http://www.w3.org/2001/XMLSchema#hexBinary":
+                        return dom.type.string;
                     case "http://www.w3.org/2001/XMLSchema#boolean":
                         return dom.type.boolean;
                     case "http://www.w3.org/2001/XMLSchema#byte":
@@ -544,7 +569,7 @@ export const ShexJTypingTransformerCompact = ShexJTraverser.createTransformer({
                     case "http://www.w3.org/2001/XMLSchema#unsignedByte":
                         return dom.type.number;
                     default:
-                        return dom.type.string; // treat most as string
+                        return dom.create.namedTypeReference("IRI"); // treat others / references as IRI
                 }
             }
             if (nodeConstraint.nodeKind) {

package/dist/types.d.ts CHANGED Viewed

@@ -26,9 +26,9 @@ export interface Shape {
 /** An allowed data type or literal. */
 export type DataType = {
     /** 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;
+    literals?: number[] | string[] | boolean[];
+    /** If `valType` is `"shape"`, the IRI of the nested shape. */
+    shape?: string;
     /** The type of object value for a triple constraint. */
     valType: "number" | "string" | "boolean" | "iri" | "shape";
 };

package/dist/types.d.ts.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAUA;;;GAGG;AACH,MAAM,WAAW,SAAS,CAAC,CAAC,SAAS,QAAQ;IACzC,sCAAsC;IACtC,MAAM,EAAE,MAAM,CAAC;IACf,iCAAiC;IACjC,KAAK,EAAE,MAAM,CAAC;CACjB;AAED,6DAA6D;AAC7D,MAAM,WAAW,QAAS,SAAQ,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;IACjD,8BAA8B;IAC9B,KAAK,EAAE,MAAM,CAAC;CAIjB;AAED,MAAM,MAAM,MAAM,GAAG;IACjB,CAAC,EAAE,EAAE,MAAM,GAAG,KAAK,CAAC;CACvB,CAAC;AAEF,0BAA0B;AAC1B,MAAM,WAAW,KAAK;IAClB,iCAAiC;IACjC,GAAG,EAAE,MAAM,CAAC;IACZ,gDAAgD;IAChD,UAAU,EAAE,SAAS,EAAE,CAAC;CAC3B;AAED,uCAAuC;AACvC,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,gCAAgC;AAChC,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,yCAAyC;IACzC,cAAc,EAAE,MAAM,CAAC;IACvB,uEAAuE;IACvE,KAAK,CAAC,EAAE,OAAO,CAAC;CACnB"}
1	+ {"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAUA;;;GAGG;AACH,MAAM,WAAW,SAAS,CAAC,CAAC,SAAS,QAAQ;IACzC,sCAAsC;IACtC,MAAM,EAAE,MAAM,CAAC;IACf,iCAAiC;IACjC,KAAK,EAAE,MAAM,CAAC;CACjB;AAED,6DAA6D;AAC7D,MAAM,WAAW,QAAS,SAAQ,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;IACjD,8BAA8B;IAC9B,KAAK,EAAE,MAAM,CAAC;CAIjB;AAED,MAAM,MAAM,MAAM,GAAG;IACjB,CAAC,EAAE,EAAE,MAAM,GAAG,KAAK,CAAC;CACvB,CAAC;AAEF,0BAA0B;AAC1B,MAAM,WAAW,KAAK;IAClB,iCAAiC;IACjC,GAAG,EAAE,MAAM,CAAC;IACZ,gDAAgD;IAChD,UAAU,EAAE,SAAS,EAAE,CAAC;CAC3B;AAED,uCAAuC;AACvC,MAAM,MAAM,QAAQ,GAAG;IACnB,wFAAwF;IACxF,QAAQ,CAAC,EAAE,MAAM,EAAE,GAAG,MAAM,EAAE,GAAG,OAAO,EAAE,CAAC;IAC3C,8DAA8D;IAC9D,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,wDAAwD;IACxD,OAAO,EAAE,QAAQ,GAAG,QAAQ,GAAG,SAAS,GAAG,KAAK,GAAG,OAAO,CAAC;CAC9D,CAAC;AAEF,gCAAgC;AAChC,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,yCAAyC;IACzC,cAAc,EAAE,MAAM,CAAC;IACvB,uEAAuE;IACvE,KAAK,CAAC,EAAE,OAAO,CAAC;CACnB"}

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "@ng-org/shex-orm",
-  "version": "0.1.2-alpha.7",
+  "version": "0.1.2-alpha.8",
   "description": "",
   "type": "module",
   "main": "./dist/index.js",
@@ -18,9 +18,12 @@
     "@types/fs-extra": "^9.0.13",
     "@types/jsonld": "^1.5.15",
     "@types/shexj": "^2.1.4",
-    "typescript": "^5.9.2",
+    "typescript": "^5.9.3",
     "vitest": "^3.2.4"
   },
+  "peerDependencies": {
+    "typescript": "^4.9.0 || ^5.0.0 || ^6.0.0"
+  },
   "dependencies": {
     "@ldo/traverser-shexj": "1.0.0-alpha.28",
     "@ldo/type-traverser": "1.0.0-alpha.28",