@ng-org/shex-orm 0.1.2-alpha.1

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

@@ -0,0 +1,623 @@
+// Copyright (c) 2025 Laurin Weger, Par le Peuple, NextGraph.org developers
+// All rights reserved.
+// Copyright (c) 2023 Jackson Morgan
+// Licensed under the Apache License, Version 2.0
+// <LICENSE-APACHE2 or http://www.apache.org/licenses/LICENSE-2.0>
+// or the MIT license <LICENSE-MIT or http://opensource.org/licenses/MIT>,
+// at your option. All files in the project carrying such
+// notice may not be copied, modified, or distributed except
+// according to those terms.
+// SPDX-License-Identifier: Apache-2.0 OR MIT
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import ShexJTraverser from "@ldo/traverser-shexj";
+import * as dom from "dts-dom";
+// Collected enum alias names (e.g., AuthenticatedAgentId) to emit at end
+export const additionalCompactEnumAliases = new Set();
+function commentFromAnnotations(annotations) {
+    const commentAnnotationObject = annotations?.find((annotation) => annotation.predicate ===
+        "http://www.w3.org/2000/01/rdf-schema#comment")?.object;
+    if (typeof commentAnnotationObject === "string")
+        return commentAnnotationObject;
+    return commentAnnotationObject?.value;
+}
+export function toCamelCase(text) {
+    return text
+        .replace(/([-_ ]){1,}/g, " ")
+        .split(/[-_ ]/)
+        .reduce((cur, acc) => {
+        return cur + acc[0].toUpperCase() + acc.substring(1);
+    });
+}
+/**
+ * Name functions
+ */
+export function iriToName(iri) {
+    try {
+        const url = new URL(iri);
+        let name;
+        if (url.hash) {
+            name = url.hash.slice(1);
+        }
+        else {
+            const splitPathname = url.pathname.split("/");
+            name = splitPathname[splitPathname.length - 1];
+        }
+        return name.replace(/(?<!^)Shape$/, "");
+    }
+    catch (err) {
+        return iri;
+    }
+}
+export function nameFromAnnotationOrId(obj) {
+    const labelAnnotationObject = obj.annotations?.find((annotation) => annotation.predicate ===
+        "http://www.w3.org/2000/01/rdf-schema#label")?.object;
+    if (labelAnnotationObject && typeof labelAnnotationObject === "string") {
+        return toCamelCase(iriToName(labelAnnotationObject));
+    }
+    else if (labelAnnotationObject &&
+        typeof labelAnnotationObject !== "string") {
+        return toCamelCase(labelAnnotationObject.value);
+    }
+    else if (obj.id) {
+        return toCamelCase(iriToName(obj.id));
+    }
+}
+// Helper: classify a dom.Type into categories we care about.
+function isObjectLike(t) {
+    return (t.kind === "object" ||
+        t.kind === "interface");
+}
+function isPrimitiveLike(t) {
+    const kind = t?.kind;
+    if (kind === "name")
+        return true; // named references and intrinsic tokens
+    if (kind === "union") {
+        return t.members.every(isPrimitiveLike);
+    }
+    if (kind === "type-parameter")
+        return true;
+    // Fallback: treat scalar intrinsic tokens as primitive
+    const intrinsicKinds = new Set([
+        "string",
+        "number",
+        "boolean",
+        "undefined",
+    ]);
+    return intrinsicKinds.has(kind || "");
+}
+// Small helpers for unions and alias naming
+function isUnionType(t) {
+    return t?.kind === "union";
+}
+function unionOf(types) {
+    const flat = [];
+    const collect = (tt) => {
+        if (isUnionType(tt))
+            tt.members.forEach(collect);
+        else
+            flat.push(tt);
+    };
+    types.forEach(collect);
+    const seen = new Set();
+    const unique = [];
+    flat.forEach((m) => {
+        const key = m.name ||
+            m.value ||
+            m.kind + JSON.stringify(m);
+        if (!seen.has(key)) {
+            seen.add(key);
+            unique.push(m);
+        }
+    });
+    if (unique.length === 0)
+        return dom.type.any;
+    if (unique.length === 1)
+        return unique[0];
+    return dom.create.union(unique);
+}
+function setOf(inner) {
+    return {
+        kind: "name",
+        name: "Set",
+        typeArguments: [inner],
+    };
+}
+function recordOf(key, value) {
+    return {
+        kind: "name",
+        name: "Record",
+        typeArguments: [key, value],
+    };
+}
+function literalFromValueSetValue(value) {
+    if (typeof value === "string")
+        return value;
+    if (value && typeof value === "object") {
+        const candidate = value;
+        if (typeof candidate.value === "string")
+            return candidate.value;
+        if (typeof candidate.id === "string")
+            return candidate.id;
+        if (typeof candidate.languageTag === "string")
+            return candidate.languageTag;
+        if (typeof candidate.stem === "string")
+            return candidate.stem;
+    }
+    return undefined;
+}
+const extraTripleConstraints = new WeakSet();
+function tagExtraPredicatesFromExpression(expression, extras) {
+    if (!expression || typeof expression !== "object")
+        return;
+    const exprType = expression.type;
+    if (exprType === "TripleConstraint") {
+        if (extras.has(expression.predicate)) {
+            extraTripleConstraints.add(expression);
+        }
+        return;
+    }
+    if (exprType === "EachOf" || exprType === "OneOf") {
+        (expression.expressions || []).forEach((child) => tagExtraPredicatesFromExpression(child, extras));
+        return;
+    }
+    if (exprType === "Shape") {
+        tagExtraPredicatesFromExpression(expression.expression, extras);
+    }
+}
+// Note: aliasing helpers previously used in earlier versions were removed.
+// Property name collision resolution using predicate IRI mapping
+const predicateIriByProp = new WeakMap();
+// Note: collisions are handled by annotateReadablePredicates pre-pass.
+// Merge duplicate properties without introducing LdSet. If a property appears multiple
+// times (e.g., via EXTENDS or grouped expressions) we:
+//  - union the types (flattening existing unions)
+//  - if one side is Set<T> and the other is plain U, produce Set<T|U>
+//  - if both are Set<A>, Set<B> -> Set<A|B>
+//  - preserve optional flag if any occurrence optional
+function dedupeCompactProperties(props) {
+    const isSetRef = (t) => t.kind === "name" && t.name === "Set";
+    const getSetInner = (t) => isSetRef(t) ? t.typeArguments[0] : t;
+    // Group by composite key (name + predicate IRI)
+    const groups = new Map();
+    for (const p of props) {
+        const pred = predicateIriByProp.get(p) || "";
+        const key = `${p.name}\u0000${pred}`;
+        if (!groups.has(key))
+            groups.set(key, []);
+        groups.get(key).push(p);
+    }
+    const merged = [];
+    for (const [, group] of groups) {
+        if (group.length === 1) {
+            merged.push(group[0]);
+            continue;
+        }
+        let acc = group[0];
+        for (let i = 1; i < group.length; i++) {
+            const next = group[i];
+            const accSet = isSetRef(acc.type);
+            const nextSet = isSetRef(next.type);
+            let mergedType;
+            if (accSet && nextSet) {
+                mergedType = setOf(unionOf([getSetInner(acc.type), getSetInner(next.type)]));
+            }
+            else if (accSet && !nextSet) {
+                mergedType = setOf(unionOf([getSetInner(acc.type), next.type]));
+            }
+            else if (!accSet && nextSet) {
+                mergedType = setOf(unionOf([acc.type, getSetInner(next.type)]));
+            }
+            else {
+                mergedType = unionOf([acc.type, next.type]);
+            }
+            const optional = acc.flags === dom.DeclarationFlags.Optional ||
+                next.flags === dom.DeclarationFlags.Optional
+                ? dom.DeclarationFlags.Optional
+                : dom.DeclarationFlags.None;
+            const mergedProp = dom.create.property(acc.name, mergedType, optional);
+            mergedProp.jsDocComment =
+                acc.jsDocComment && next.jsDocComment
+                    ? `${acc.jsDocComment} | ${next.jsDocComment}`
+                    : acc.jsDocComment || next.jsDocComment;
+            const pred = predicateIriByProp.get(acc) || predicateIriByProp.get(next);
+            if (pred)
+                predicateIriByProp.set(mergedProp, pred);
+            acc = mergedProp;
+        }
+        merged.push(acc);
+    }
+    return merged;
+}
+/** Add `@id` and `@graph` optional readonly props for nested objects */
+function addIdAndGraphProperties(t) {
+    if (t?.kind === "object") {
+        const members = t.members;
+        if (!members)
+            return t;
+        const props = (members.filter?.((m) => m?.kind === "property") ||
+            []);
+        if (!props.some((m) => m.name === "@id")) {
+            members.unshift(dom.create.property("@id", dom.create.namedTypeReference("IRI"), dom.DeclarationFlags.Optional |
+                dom.DeclarationFlags.ReadOnly), dom.create.property("@graph", dom.create.namedTypeReference("IRI"), dom.DeclarationFlags.Optional |
+                dom.DeclarationFlags.ReadOnly));
+        }
+    }
+    return t;
+}
+function addIdAndGraphIriToUnionObjects(t) {
+    if (!isUnionType(t))
+        return t;
+    const members = t.members.map((m) => m?.kind === "object" ? addIdAndGraphProperties(m) : m);
+    return dom.create.union(members);
+}
+// Create property and attach predicate IRI and annotations consistently
+function createProperty(name, type, flags, predicateIri, annotations) {
+    const prop = dom.create.property(name, type, flags);
+    if (predicateIri)
+        predicateIriByProp.set(prop, predicateIri);
+    const cmt = commentFromAnnotations(annotations) || "";
+    prop.jsDocComment = cmt
+        ? `${cmt}\n\nOriginal IRI: ${predicateIri ?? ""}`.trim()
+        : `Original IRI: ${predicateIri ?? ""}`;
+    return prop;
+}
+export const ShexJTypingTransformerCompact = ShexJTraverser.createTransformer({
+    // Transformer from Schema to interfaces
+    Schema: {
+        transformer: async (_schema, getTransformedChildren) => {
+            const transformedChildren = await getTransformedChildren();
+            const interfaces = [];
+            transformedChildren.shapes?.forEach((shape) => {
+                if (typeof shape !== "string" &&
+                    shape.kind === "interface") {
+                    interfaces.push(shape);
+                }
+            });
+            return interfaces;
+        },
+    },
+    // Transformer from ShapeDecl to interface
+    ShapeDecl: {
+        transformer: async (shapeDecl, getTransformedChildren) => {
+            const shapeName = nameFromAnnotationOrId(shapeDecl) || "Shape";
+            const { shapeExpr } = await getTransformedChildren();
+            if (shapeExpr.kind === "interface") {
+                const shapeInterface = shapeExpr;
+                shapeInterface.name = shapeName;
+                // Preserve shape id for downstream shapeTypes generation
+                shapeInterface.shapeId = shapeDecl.id;
+                // Ensure root-level @id and @graph are present as readonly (mandatory)
+                const hasId = shapeInterface.members.find((m) => m.kind === "property" && m.name === "@id");
+                const hasGraph = shapeInterface.members.find((m) => m.kind === "property" && m.name === "@graph");
+                if (!hasId || !hasGraph) {
+                    const propsToAdd = [];
+                    if (!hasGraph) {
+                        const graphProp = dom.create.property("@graph", dom.create.namedTypeReference("IRI"), dom.DeclarationFlags.ReadOnly);
+                        graphProp.jsDocComment = "The graph IRI.";
+                        propsToAdd.push(graphProp);
+                    }
+                    if (!hasId) {
+                        const idProp = dom.create.property("@id", dom.create.namedTypeReference("IRI"), dom.DeclarationFlags.ReadOnly);
+                        idProp.jsDocComment = "The subject IRI.";
+                        propsToAdd.push(idProp);
+                    }
+                    shapeInterface.members.unshift(...propsToAdd);
+                }
+                return shapeInterface;
+            }
+            throw new Error("Unsupported direct shape expression on ShapeDecl for compact format.");
+        },
+    },
+    // Transformer from Shape to interface
+    Shape: {
+        transformer: async (_shape, getTransformedChildren, setReturnPointer) => {
+            const newInterface = dom.create.interface("");
+            setReturnPointer(newInterface);
+            if (_shape.extra?.length ?? 0 > 0) {
+                tagExtraPredicatesFromExpression(_shape.expression, new Set(_shape.extra));
+            }
+            const transformedChildren = await getTransformedChildren();
+            if (typeof transformedChildren.expression !== "string" &&
+                transformedChildren.expression &&
+                (transformedChildren.expression.kind ===
+                    "object" ||
+                    transformedChildren.expression
+                        .kind === "interface")) {
+                newInterface.members.push(...transformedChildren.expression
+                    .members);
+            }
+            else if (transformedChildren.expression
+                ?.kind === "property") {
+                newInterface.members.push(transformedChildren.expression);
+            }
+            if (transformedChildren.extends) {
+                transformedChildren.extends.forEach((ext) => {
+                    const extInt = ext;
+                    if (extInt.kind === "interface") {
+                        const merged = [
+                            ...extInt.members.filter((m) => !(m.kind === "property" && m.name === "@id")),
+                            ...newInterface.members,
+                        ].filter((m) => m.kind === "property");
+                        newInterface.members = dedupeCompactProperties(merged);
+                    }
+                });
+            }
+            // Final pass: ensure only a single @id and a single @graph property, normalize to readonly
+            const idSeen = new Set();
+            const graphSeen = new Set();
+            newInterface.members = newInterface.members.filter((m, idx) => {
+                if (m.kind !== "property")
+                    return true;
+                if (m.name === "@id") {
+                    if (idSeen.size === 0) {
+                        idSeen.add(idx);
+                        // normalize id type to IRI and make readonly
+                        m.type = dom.create.namedTypeReference("IRI");
+                        m.flags = dom.DeclarationFlags.ReadOnly;
+                        return true;
+                    }
+                    return false;
+                }
+                if (m.name === "@graph") {
+                    if (graphSeen.size === 0) {
+                        graphSeen.add(idx);
+                        // normalize graph type to IRI and make readonly
+                        m.type = dom.create.namedTypeReference("IRI");
+                        m.flags = dom.DeclarationFlags.ReadOnly;
+                        return true;
+                    }
+                    return false;
+                }
+                return true;
+            });
+            return newInterface;
+        },
+    },
+    // Transformer from EachOf to object type. EachOf contains the `expressions` array of properties (TripleConstraint)
+    EachOf: {
+        transformer: async (eachOf, getTransformedChildren, setReturnPointer) => {
+            const transformedChildren = await getTransformedChildren();
+            const name = nameFromAnnotationOrId(eachOf);
+            const objectType = name
+                ? dom.create.interface(name)
+                : dom.create.objectType([]);
+            setReturnPointer(objectType);
+            const inputProps = [];
+            transformedChildren.expressions.forEach((expr) => {
+                if (!expr || typeof expr === "string")
+                    return;
+                const kind = expr.kind;
+                if (kind === "property") {
+                    inputProps.push(expr);
+                }
+                else if (kind === "object" || kind === "interface") {
+                    const mlist = expr.members;
+                    mlist.forEach((m) => {
+                        if (m.kind === "property") {
+                            inputProps.push(m);
+                        }
+                    });
+                }
+            });
+            const deduped = dedupeCompactProperties(inputProps);
+            objectType.members.push(...deduped);
+            return objectType;
+        },
+    },
+    // Transformer from triple constraints to type properties.
+    TripleConstraint: {
+        transformer: async (tripleConstraint, getTransformedChildren, _setReturnPointer, _node) => {
+            const transformedChildren = await getTransformedChildren();
+            const baseName = tripleConstraint
+                .readablePredicate;
+            const max = tripleConstraint.max;
+            const isExtra = extraTripleConstraints.has(tripleConstraint);
+            const isPlural = isExtra || max === -1 || (max !== undefined && max !== 1);
+            const isOptional = tripleConstraint.min === 0 && tripleConstraint.max == 1;
+            let valueType = dom.type.any;
+            if (transformedChildren.valueExpr)
+                valueType = transformedChildren.valueExpr;
+            // Generic: If valueExpr is a NodeConstraint with concrete `values`,
+            // build a union of named alias references derived from those values.
+            // Works for any predicate (not only rdf:type).
+            const originalValueExpr = tripleConstraint?.valueExpr;
+            if (originalValueExpr &&
+                typeof originalValueExpr === "object" &&
+                originalValueExpr.type === "NodeConstraint" &&
+                Array.isArray(originalValueExpr.values) &&
+                originalValueExpr.values.length > 0) {
+                const aliasRefs = [];
+                for (const v of originalValueExpr.values) {
+                    const literalVal = literalFromValueSetValue(v);
+                    if (literalVal !== undefined) {
+                        aliasRefs.push(dom.type.stringLiteral(literalVal));
+                    }
+                }
+                if (aliasRefs.length > 0) {
+                    let union = unionOf(aliasRefs);
+                    if (isExtra) {
+                        // Type like (string & {}), to preserve literal values.
+                        const intersectedString = dom.create.intersection([
+                            dom.create.namedTypeReference("IRI"),
+                            dom.create.objectType([]),
+                        ]);
+                        union = unionOf([union, intersectedString]);
+                    }
+                    const final = isPlural ? setOf(union) : union;
+                    return createProperty(baseName, final, isOptional
+                        ? dom.DeclarationFlags.Optional
+                        : dom.DeclarationFlags.None, tripleConstraint.predicate, tripleConstraint.annotations);
+                }
+            }
+            if (valueType.kind === "interface" &&
+                !valueType.name) {
+                valueType = dom.create.objectType(valueType
+                    .members);
+            }
+            // Normalize NodeConstraint returned object forms for IRIs into IRI
+            // Heuristic: existing transformer (compact) returns string/number/boolean OR object/interface.
+            // We treat any simple string/number/boolean/name as primitive.
+            // Determine category
+            const objLike = isObjectLike(valueType);
+            const isUnion = valueType?.kind === "union";
+            const unionMembers = isUnion
+                ? valueType.members
+                : [];
+            const unionAllObjLike = isUnion &&
+                unionMembers.length > 0 &&
+                unionMembers.every(isObjectLike);
+            const primLike = isPrimitiveLike(valueType);
+            if (!primLike &&
+                !objLike &&
+                valueType.kind === "union") {
+                const u = valueType;
+                const hasObj = u.members.some(isObjectLike);
+                const hasPrim = u.members.some(isPrimitiveLike);
+                if (isPlural && hasObj && hasPrim) {
+                    throw new Error(`Mixed plural union (object + primitive) not supported for predicate ${tripleConstraint.predicate}`);
+                }
+            }
+            let finalType;
+            if (isPlural) {
+                if (objLike || unionAllObjLike) {
+                    if (valueType.kind ===
+                        "interface" &&
+                        valueType.name) {
+                        const ifaceName = valueType.name;
+                        // Set of full object instances
+                        finalType = setOf(dom.create.namedTypeReference(ifaceName));
+                    }
+                    else {
+                        // Anonymous object or union of anonymous/interface objects
+                        let valueForSet = valueType;
+                        if (unionAllObjLike) {
+                            // Ensure each union member has @id and @graph as optional readonly
+                            valueForSet =
+                                addIdAndGraphIriToUnionObjects(valueType);
+                        }
+                        else {
+                            valueForSet = addIdAndGraphProperties(valueType);
+                        }
+                        finalType = setOf(valueForSet);
+                    }
+                }
+                else {
+                    finalType = setOf(valueType);
+                }
+            }
+            else {
+                // Singular
+                // If anonymous object or union of object-like types, ensure id: IRI is present (mandatory)
+                if (objLike) {
+                    if (valueType.kind === "object") {
+                        valueType = addIdAndGraphProperties(valueType);
+                    }
+                }
+                else if (isUnion && unionAllObjLike) {
+                    valueType = addIdAndGraphIriToUnionObjects(valueType);
+                }
+                // Singular: always the interface/object type itself (never Id union)
+                if (valueType.kind ===
+                    "interface" &&
+                    valueType.name) {
+                    finalType = dom.create.namedTypeReference(valueType.name);
+                }
+                else {
+                    finalType = valueType;
+                }
+            }
+            return createProperty(baseName, finalType, isOptional
+                ? dom.DeclarationFlags.Optional
+                : dom.DeclarationFlags.None, tripleConstraint.predicate, tripleConstraint.annotations);
+        },
+    },
+    // Transformer from node constraint to type
+    NodeConstraint: {
+        transformer: async (nodeConstraint) => {
+            if (nodeConstraint.datatype) {
+                switch (nodeConstraint.datatype) {
+                    case "http://www.w3.org/2001/XMLSchema#boolean":
+                        return dom.type.boolean;
+                    case "http://www.w3.org/2001/XMLSchema#byte":
+                    case "http://www.w3.org/2001/XMLSchema#decimal":
+                    case "http://www.w3.org/2001/XMLSchema#double":
+                    case "http://www.w3.org/2001/XMLSchema#float":
+                    case "http://www.w3.org/2001/XMLSchema#int":
+                    case "http://www.w3.org/2001/XMLSchema#integer":
+                    case "http://www.w3.org/2001/XMLSchema#long":
+                    case "http://www.w3.org/2001/XMLSchema#negativeInteger":
+                    case "http://www.w3.org/2001/XMLSchema#nonNegativeInteger":
+                    case "http://www.w3.org/2001/XMLSchema#nonPositiveInteger":
+                    case "http://www.w3.org/2001/XMLSchema#positiveInteger":
+                    case "http://www.w3.org/2001/XMLSchema#short":
+                    case "http://www.w3.org/2001/XMLSchema#unsignedLong":
+                    case "http://www.w3.org/2001/XMLSchema#unsignedInt":
+                    case "http://www.w3.org/2001/XMLSchema#unsignedShort":
+                    case "http://www.w3.org/2001/XMLSchema#unsignedByte":
+                        return dom.type.number;
+                    default:
+                        return dom.type.string; // treat most as string
+                }
+            }
+            if (nodeConstraint.nodeKind) {
+                switch (nodeConstraint.nodeKind) {
+                    case "iri":
+                        return dom.create.namedTypeReference("IRI");
+                    case "bnode":
+                        return dom.type.string; // opaque id as string
+                    case "nonliteral":
+                        return dom.create.namedTypeReference("IRI");
+                    case "literal":
+                    default:
+                        return dom.type.string;
+                }
+            }
+            if (nodeConstraint.values) {
+                const union = dom.create.union([]);
+                nodeConstraint.values.forEach((v) => {
+                    const literalVal = literalFromValueSetValue(v);
+                    if (literalVal !== undefined) {
+                        union.members.push(dom.type.stringLiteral(literalVal));
+                    }
+                });
+                if (!union.members.length)
+                    return dom.type.string;
+                if (union.members.length === 1)
+                    return union.members[0];
+                return union;
+            }
+            return dom.type.any;
+        },
+    },
+    // Transformer from ShapeOr to union type
+    ShapeOr: {
+        transformer: async (_shapeOr, getTransformedChildren) => {
+            const tc = await getTransformedChildren();
+            return dom.create.union(tc.shapeExprs);
+        },
+    },
+    // Transformer from ShapeAnd to intersection type
+    ShapeAnd: {
+        transformer: async (_shapeAnd, getTransformedChildren) => {
+            const tc = await getTransformedChildren();
+            const valid = [];
+            tc.shapeExprs.forEach((t) => {
+                if (typeof t === "object")
+                    valid.push(t);
+            });
+            return dom.create.intersection(valid);
+        },
+    },
+    // Transformer from ShapeNot to type - not supported.
+    ShapeNot: {
+        transformer: async () => {
+            throw new Error("ShapeNot not supported (compact)");
+        },
+    },
+    // Transformer from ShapeExternal to type - not supported.
+    ShapeExternal: {
+        transformer: async () => {
+            throw new Error("ShapeExternal not supported (compact)");
+        },
+    },
+});

package/dist/schema-converter/util/ShapeInterfaceDeclaration.d.ts

@@ -0,0 +1,5 @@
+import type { InterfaceDeclaration } from "dts-dom";
+export interface ShapeInterfaceDeclaration extends InterfaceDeclaration {
+    shapeId?: string;
+}
+//# sourceMappingURL=ShapeInterfaceDeclaration.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ShapeInterfaceDeclaration.d.ts","sourceRoot":"","sources":["../../../src/schema-converter/util/ShapeInterfaceDeclaration.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,SAAS,CAAC;AAEpD,MAAM,WAAW,yBAA0B,SAAQ,oBAAoB;IACrE,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB"}

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,8 @@
+import type { Schema } from "shexj";
+/**
+ * Annotate EachOf-level TripleConstraints with a collision-free readablePredicate.
+ * Rule: for any group that shares the same local token, rename all members using
+ * prefix-first `${prefix}_${local}` from right to left; fallback to composite.
+ */
+export default function annotateReadablePredicates(schema: Schema): void;
+//# sourceMappingURL=annotateReadablePredicates.d.ts.map

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

@@ -0,0 +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"}