@ui-manifest-json/core 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,8 @@
+export * from './types/dom.js';
+export * from './types/component.js';
+export * from './types/route.js';
+export * from './types/dependency-graph.js';
+export * from './types/manifest.js';
+export { resolveRouteDependencyTree } from './resolve-tree.js';
+export type { MatchFn } from './resolve-tree.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,gBAAgB,CAAC;AAC/B,cAAc,sBAAsB,CAAC;AACrC,cAAc,kBAAkB,CAAC;AACjC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,qBAAqB,CAAC;AACpC,OAAO,EAAE,0BAA0B,EAAE,MAAM,mBAAmB,CAAC;AAC/D,YAAY,EAAE,OAAO,EAAE,MAAM,mBAAmB,CAAC"}

package/dist/index.js

@@ -0,0 +1,6 @@
+export * from './types/dom.js';
+export * from './types/component.js';
+export * from './types/route.js';
+export * from './types/dependency-graph.js';
+export * from './types/manifest.js';
+export { resolveRouteDependencyTree } from './resolve-tree.js';

package/dist/resolve-tree.d.ts

@@ -0,0 +1,29 @@
+import type { ComponentNode } from './types/component.js';
+import type { RouteDependencyTree } from './types/dependency-graph.js';
+/**
+ * Given an element's tag (e.g. "app-app-flow-tab" or a JSX identifier like "UserCard") and the
+ * `ComponentNode` whose OWN template is currently being walked (i.e. the file-context that tag
+ * appeared in), return the `ComponentNode` it refers to, or undefined if the tag is a plain
+ * element / not a known component.
+ *
+ * The second argument matters: as resolution descends into a spliced child's own template, tags
+ * found there must be resolved against THAT child's file, not the route's root file. Angular can
+ * ignore it (a selector is a global namespace across the whole app, not file-relative) — React
+ * cannot: import bindings are inherently per-file, so a `matchFn` that only ever saw the route
+ * root's file would silently fail to resolve anything more than one splice deep. Framework-
+ * specific either way; core only calls it.
+ */
+export type MatchFn = (tag: string, currentComponent: ComponentNode) => ComponentNode | undefined;
+/**
+ * Resolve one route's dependency tree: starting from its root component's own template, replace
+ * every element whose tag matches a known component (via `matchFn`) with an annotated splice of
+ * that component's own (recursively resolved) template, in place.
+ *
+ * Cycle detection is path-scoped: a `Set` of component classNames currently on the active
+ * resolution stack, pushed on entering a splice and popped on leaving. The same component
+ * legitimately appears in multiple unrelated branches of a tree and must be expanded fresh each
+ * time — only a component reappearing in its own ancestor chain (direct or indirect
+ * self-inclusion) is a cycle, at which point a CycleMarkerNode is emitted instead of recursing.
+ */
+export declare function resolveRouteDependencyTree(routePath: string, rootComponent: ComponentNode, matchFn: MatchFn): RouteDependencyTree;
+//# sourceMappingURL=resolve-tree.d.ts.map

package/dist/resolve-tree.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolve-tree.d.ts","sourceRoot":"","sources":["../src/resolve-tree.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAE1D,OAAO,KAAK,EAAwD,mBAAmB,EAAE,MAAM,6BAA6B,CAAC;AAE7H;;;;;;;;;;;;GAYG;AACH,MAAM,MAAM,OAAO,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,gBAAgB,EAAE,aAAa,KAAK,aAAa,GAAG,SAAS,CAAC;AAElG;;;;;;;;;;GAUG;AACH,wBAAgB,0BAA0B,CACxC,SAAS,EAAE,MAAM,EACjB,aAAa,EAAE,aAAa,EAC5B,OAAO,EAAE,OAAO,GACf,mBAAmB,CAIrB"}

package/dist/resolve-tree.js

@@ -0,0 +1,69 @@
+/**
+ * Resolve one route's dependency tree: starting from its root component's own template, replace
+ * every element whose tag matches a known component (via `matchFn`) with an annotated splice of
+ * that component's own (recursively resolved) template, in place.
+ *
+ * Cycle detection is path-scoped: a `Set` of component classNames currently on the active
+ * resolution stack, pushed on entering a splice and popped on leaving. The same component
+ * legitimately appears in multiple unrelated branches of a tree and must be expanded fresh each
+ * time — only a component reappearing in its own ancestor chain (direct or indirect
+ * self-inclusion) is a cycle, at which point a CycleMarkerNode is emitted instead of recursing.
+ */
+export function resolveRouteDependencyTree(routePath, rootComponent, matchFn) {
+    const path = [rootComponent.className];
+    const tree = (rootComponent.dom ?? []).map(node => resolveNode(node, matchFn, path, rootComponent));
+    return { routePath, rootComponent: rootComponent.className, tree };
+}
+function resolveNode(node, matchFn, path, currentComponent) {
+    switch (node.type) {
+        case 'element': {
+            const matched = matchFn(node.el, currentComponent);
+            if (!matched) {
+                // Plain element (or an unresolvable tag) — keep as-is, but still recurse into children
+                // so descendant components further down get spliced. Still within currentComponent's own
+                // template, so the context doesn't change.
+                return {
+                    ...node,
+                    children: node.children.map(child => resolveNode(child, matchFn, path, currentComponent)),
+                };
+            }
+            if (path.includes(matched.className)) {
+                const marker = {
+                    type: 'cycle-detected',
+                    extraction: 'compiler',
+                    tag: node.el,
+                    componentClassName: matched.className,
+                    cyclePath: [...path],
+                };
+                return marker;
+            }
+            path.push(matched.className);
+            // Descending into the matched component's OWN template: it becomes the new context, so
+            // any tag found within it resolves against ITS file, not the caller's.
+            const children = (matched.dom ?? []).map(child => resolveNode(child, matchFn, path, matched));
+            path.pop();
+            const boundary = {
+                type: 'component-boundary',
+                extraction: node.extraction,
+                tag: node.el,
+                componentClassName: matched.className,
+                children,
+            };
+            return boundary;
+        }
+        case 'template': {
+            // Still the same component's own template (an @if/@for/ternary/etc. block doesn't cross a
+            // component boundary) — context is unchanged.
+            const children = node.children.map(child => resolveNode(child, matchFn, path, currentComponent));
+            const branches = node.branches?.map(branch => ({
+                ...branch,
+                children: branch.children.map(child => resolveNode(child, matchFn, path, currentComponent)),
+            }));
+            return { ...node, children, ...(branches ? { branches } : {}) };
+        }
+        case 'text':
+        case 'interpolation':
+            // Leaf nodes — nothing to splice into.
+            return node;
+    }
+}

package/dist/types/component.d.ts

@@ -0,0 +1,40 @@
+import type { DomNode } from './dom.js';
+export type PropertyBindingKind = 'decorator' | 'signal';
+/** An Angular @Input()/@Output() or input()/output() signal. */
+export interface PropertyBinding {
+    name: string;
+    type?: string;
+    required?: boolean;
+    kind: PropertyBindingKind;
+    alias?: string;
+}
+export type PropSource = 'ts-type' | 'prop-types' | 'unknown';
+/** A React component prop. */
+export interface PropDefinition {
+    name: string;
+    type?: string;
+    required: boolean;
+    source: PropSource;
+    isEventHandler?: boolean;
+}
+export interface ComponentNode {
+    className: string;
+    /** Repo-relative path to the file the component is defined in. */
+    filePath: string;
+    /** Angular only. */
+    selector?: string;
+    /** Angular only. */
+    standalone?: boolean;
+    templateUrl?: string;
+    inlineTemplate?: boolean;
+    styleUrls?: string[];
+    /** Angular only; always [] for React components. */
+    inputs: PropertyBinding[];
+    /** Angular only; always [] for React components. */
+    outputs: PropertyBinding[];
+    /** React only; undefined for Angular components. */
+    props?: PropDefinition[];
+    /** Present only when the extractor was run with template/JSX parsing enabled. */
+    dom?: DomNode[];
+}
+//# sourceMappingURL=component.d.ts.map

package/dist/types/component.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"component.d.ts","sourceRoot":"","sources":["../../src/types/component.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,UAAU,CAAC;AAExC,MAAM,MAAM,mBAAmB,GAAG,WAAW,GAAG,QAAQ,CAAC;AAEzD,gEAAgE;AAChE,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,IAAI,EAAE,mBAAmB,CAAC;IAC1B,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,MAAM,UAAU,GAAG,SAAS,GAAG,YAAY,GAAG,SAAS,CAAC;AAE9D,8BAA8B;AAC9B,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,OAAO,CAAC;IAClB,MAAM,EAAE,UAAU,CAAC;IACnB,cAAc,CAAC,EAAE,OAAO,CAAC;CAC1B;AAED,MAAM,WAAW,aAAa;IAC5B,SAAS,EAAE,MAAM,CAAC;IAClB,kEAAkE;IAClE,QAAQ,EAAE,MAAM,CAAC;IACjB,oBAAoB;IACpB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,oBAAoB;IACpB,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,SAAS,CAAC,EAAE,MAAM,EAAE,CAAC;IACrB,oDAAoD;IACpD,MAAM,EAAE,eAAe,EAAE,CAAC;IAC1B,oDAAoD;IACpD,OAAO,EAAE,eAAe,EAAE,CAAC;IAC3B,oDAAoD;IACpD,KAAK,CAAC,EAAE,cAAc,EAAE,CAAC;IACzB,iFAAiF;IACjF,GAAG,CAAC,EAAE,OAAO,EAAE,CAAC;CACjB"}

package/dist/types/component.js

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

package/dist/types/dependency-graph.d.ts

@@ -0,0 +1,45 @@
+import type { BaseNode, DomNode, ElementNode, InterpolationNode, TemplateNode, TextNode } from './dom.js';
+/**
+ * An annotated splice point: the subtree of a descendant component, spliced in where its
+ * custom-element tag appeared in the parent's template, wrapped with provenance so consumers
+ * (including a future diff engine) can tell a component boundary was crossed without
+ * re-running resolution. Deliberately NOT a silently-flattened inline — see docs/schema.md.
+ *
+ * `children` is `ResolvedNode[]`, not `DomNode[]`: the spliced-in subtree is itself recursively
+ * resolved, so it can contain further component-boundary splices and cycle markers, not just
+ * raw template nodes.
+ */
+export interface ComponentBoundaryNode extends BaseNode {
+    type: 'component-boundary';
+    /** The tag that was matched, e.g. "app-app-flow-tab" or a React component identifier. */
+    tag: string;
+    componentClassName: string;
+    children: ResolvedNode[];
+}
+/**
+ * Emitted instead of recursing when a component reappears in its own ancestor chain
+ * (direct or indirect self-inclusion). Never a global "already seen anywhere" cutoff —
+ * the same component legitimately appears in multiple unrelated branches and must be
+ * expanded each time; only a cycle back to an ancestor is cut off.
+ */
+export interface CycleMarkerNode extends BaseNode {
+    type: 'cycle-detected';
+    tag: string;
+    componentClassName: string;
+    /** The ancestor className chain (root-first) that produced the cycle. */
+    cyclePath: string[];
+}
+/**
+ * The resolved-tree counterpart to DomNode: every DomNode variant, but element/template nodes
+ * are parameterized so their `children` can also hold component-boundary splices and cycle
+ * markers, plus the two new leaf kinds themselves.
+ */
+export type ResolvedNode = ElementNode<ResolvedNode> | TextNode | InterpolationNode | TemplateNode<ResolvedNode> | ComponentBoundaryNode | CycleMarkerNode;
+export interface RouteDependencyTree {
+    /** Matches RouteNode.path of the route this tree was resolved for. */
+    routePath: string;
+    rootComponent: string;
+    tree: ResolvedNode[];
+}
+export type { DomNode };
+//# sourceMappingURL=dependency-graph.d.ts.map

package/dist/types/dependency-graph.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dependency-graph.d.ts","sourceRoot":"","sources":["../../src/types/dependency-graph.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,OAAO,EAAE,WAAW,EAAE,iBAAiB,EAAE,YAAY,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAC;AAE1G;;;;;;;;;GASG;AACH,MAAM,WAAW,qBAAsB,SAAQ,QAAQ;IACrD,IAAI,EAAE,oBAAoB,CAAC;IAC3B,yFAAyF;IACzF,GAAG,EAAE,MAAM,CAAC;IACZ,kBAAkB,EAAE,MAAM,CAAC;IAC3B,QAAQ,EAAE,YAAY,EAAE,CAAC;CAC1B;AAED;;;;;GAKG;AACH,MAAM,WAAW,eAAgB,SAAQ,QAAQ;IAC/C,IAAI,EAAE,gBAAgB,CAAC;IACvB,GAAG,EAAE,MAAM,CAAC;IACZ,kBAAkB,EAAE,MAAM,CAAC;IAC3B,yEAAyE;IACzE,SAAS,EAAE,MAAM,EAAE,CAAC;CACrB;AAED;;;;GAIG;AACH,MAAM,MAAM,YAAY,GACpB,WAAW,CAAC,YAAY,CAAC,GACzB,QAAQ,GACR,iBAAiB,GACjB,YAAY,CAAC,YAAY,CAAC,GAC1B,qBAAqB,GACrB,eAAe,CAAC;AAEpB,MAAM,WAAW,mBAAmB;IAClC,sEAAsE;IACtE,SAAS,EAAE,MAAM,CAAC;IAClB,aAAa,EAAE,MAAM,CAAC;IACtB,IAAI,EAAE,YAAY,EAAE,CAAC;CACtB;AAID,YAAY,EAAE,OAAO,EAAE,CAAC"}

package/dist/types/dependency-graph.js

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

package/dist/types/dom.d.ts

@@ -0,0 +1,66 @@
+/**
+ * The template/JSX element tree shape both extractors emit.
+ *
+ * `extraction` is a per-node honesty marker, not a single blended confidence score:
+ * - "compiler": produced by a real parser (Angular's Ivy `parseTemplate()`, or TypeScript's
+ *   JSX AST) that either understands the construct completely or fails loudly. Unconditionally
+ *   trustworthy.
+ * - "heuristic": produced by pattern-matching arbitrary code (React's ternary/`&&`/`.map()`
+ *   control-flow detection) rather than a grammar built for the purpose. Best-effort — the
+ *   underlying JS could always route around the pattern in a way that isn't detected.
+ */
+export type Extraction = 'compiler' | 'heuristic';
+export interface BaseNode {
+    extraction: Extraction;
+}
+/** A bound property/event: e.g. {name: "class.active", expr: "isActive"} or {name: "click", expr: "onClick()"}. */
+export interface BoundExpr {
+    name: string;
+    expr: string;
+}
+/**
+ * `Child` is generic so the resolved dependency-graph tree (packages/core/src/types/
+ * dependency-graph.ts) can reuse this exact shape with a wider child type (one that also
+ * allows ComponentBoundaryNode/CycleMarkerNode) instead of duplicating every field.
+ */
+export interface ElementNode<Child = DomNode> extends BaseNode {
+    type: 'element';
+    /** Tag name, e.g. "div" or a custom element/component tag like "app-app-flow-tab". */
+    el: string;
+    /** Static attributes (string-literal values only). */
+    attrs: Record<string, string>;
+    /** Bound properties, e.g. [value], [class.active], JSX {expr} props. */
+    props: BoundExpr[];
+    /** Bound events, e.g. (click), JSX onClick={...}. */
+    events: BoundExpr[];
+    /** Template reference variables (#ref). Angular only. */
+    refs?: string[];
+    children: Child[];
+}
+export interface TextNode extends BaseNode {
+    type: 'text';
+    value: string;
+}
+export interface InterpolationNode extends BaseNode {
+    type: 'interpolation';
+    /** Raw source of the interpolation, e.g. "Hello {{ name }}" or the JSX {expr} source text. */
+    interpolation: string;
+}
+export type StructuralKind = '*ngIf' | '*ngFor' | '@if' | '@for' | '@switch' | '@defer' | 'ternary' | '&&' | '.map()';
+export interface TemplateBranch<Child = DomNode> {
+    label: string;
+    condition?: string;
+    children: Child[];
+}
+export interface TemplateNode<Child = DomNode> extends BaseNode {
+    type: 'template';
+    structural: StructuralKind;
+    /** The raw guiding expression: @if condition, ternary test, && LHS, .map() source array, etc. */
+    condition?: string;
+    /** Present for multi-branch constructs (@if/@else chains, @switch cases, ternaries). */
+    branches?: TemplateBranch<Child>[];
+    /** The primary/consequent branch's children, kept so every DomNode has a `children` array. */
+    children: Child[];
+}
+export type DomNode = ElementNode | TextNode | InterpolationNode | TemplateNode;
+//# sourceMappingURL=dom.d.ts.map

package/dist/types/dom.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dom.d.ts","sourceRoot":"","sources":["../../src/types/dom.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,MAAM,MAAM,UAAU,GAAG,UAAU,GAAG,WAAW,CAAC;AAElD,MAAM,WAAW,QAAQ;IACvB,UAAU,EAAE,UAAU,CAAC;CACxB;AAED,mHAAmH;AACnH,MAAM,WAAW,SAAS;IACxB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;CACd;AAED;;;;GAIG;AACH,MAAM,WAAW,WAAW,CAAC,KAAK,GAAG,OAAO,CAAE,SAAQ,QAAQ;IAC5D,IAAI,EAAE,SAAS,CAAC;IAChB,sFAAsF;IACtF,EAAE,EAAE,MAAM,CAAC;IACX,sDAAsD;IACtD,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC9B,wEAAwE;IACxE,KAAK,EAAE,SAAS,EAAE,CAAC;IACnB,qDAAqD;IACrD,MAAM,EAAE,SAAS,EAAE,CAAC;IACpB,yDAAyD;IACzD,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;IAChB,QAAQ,EAAE,KAAK,EAAE,CAAC;CACnB;AAED,MAAM,WAAW,QAAS,SAAQ,QAAQ;IACxC,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,iBAAkB,SAAQ,QAAQ;IACjD,IAAI,EAAE,eAAe,CAAC;IACtB,8FAA8F;IAC9F,aAAa,EAAE,MAAM,CAAC;CACvB;AAED,MAAM,MAAM,cAAc,GACtB,OAAO,GACP,QAAQ,GACR,KAAK,GACL,MAAM,GACN,SAAS,GACT,QAAQ,GACR,SAAS,GACT,IAAI,GACJ,QAAQ,CAAC;AAEb,MAAM,WAAW,cAAc,CAAC,KAAK,GAAG,OAAO;IAC7C,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,QAAQ,EAAE,KAAK,EAAE,CAAC;CACnB;AAED,MAAM,WAAW,YAAY,CAAC,KAAK,GAAG,OAAO,CAAE,SAAQ,QAAQ;IAC7D,IAAI,EAAE,UAAU,CAAC;IACjB,UAAU,EAAE,cAAc,CAAC;IAC3B,iGAAiG;IACjG,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,wFAAwF;IACxF,QAAQ,CAAC,EAAE,cAAc,CAAC,KAAK,CAAC,EAAE,CAAC;IACnC,8FAA8F;IAC9F,QAAQ,EAAE,KAAK,EAAE,CAAC;CACnB;AAED,MAAM,MAAM,OAAO,GAAG,WAAW,GAAG,QAAQ,GAAG,iBAAiB,GAAG,YAAY,CAAC"}

package/dist/types/dom.js

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

package/dist/types/manifest.d.ts

@@ -0,0 +1,20 @@
+import type { ComponentNode } from './component.js';
+import type { RouteNode } from './route.js';
+import type { RouteDependencyTree } from './dependency-graph.js';
+export declare const SCHEMA_VERSION = "1.0";
+export type Framework = 'angular' | 'react';
+export interface UiManifest {
+    schemaVersion: typeof SCHEMA_VERSION;
+    framework: Framework;
+    /** ISO timestamp of generation. Not diff-relevant on its own — consumers diffing two
+     *  manifests should ignore this field, since it changes on every run even with no UI change. */
+    generatedAt: string;
+    routes: RouteNode[];
+    components: ComponentNode[];
+    /** Present only when the extractor was run with dependency-graph resolution enabled. */
+    dependencyGraph?: RouteDependencyTree[];
+    /** Soft-failure notices, e.g. "routing pattern unresolved for src/App.tsx". Never used in
+     *  place of throwing for a hard failure — this is for partial, recoverable extraction gaps. */
+    diagnostics?: string[];
+}
+//# sourceMappingURL=manifest.d.ts.map

package/dist/types/manifest.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"manifest.d.ts","sourceRoot":"","sources":["../../src/types/manifest.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AACpD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAC5C,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAC;AAEjE,eAAO,MAAM,cAAc,QAAQ,CAAC;AAEpC,MAAM,MAAM,SAAS,GAAG,SAAS,GAAG,OAAO,CAAC;AAE5C,MAAM,WAAW,UAAU;IACzB,aAAa,EAAE,OAAO,cAAc,CAAC;IACrC,SAAS,EAAE,SAAS,CAAC;IACrB;oGACgG;IAChG,WAAW,EAAE,MAAM,CAAC;IACpB,MAAM,EAAE,SAAS,EAAE,CAAC;IACpB,UAAU,EAAE,aAAa,EAAE,CAAC;IAC5B,wFAAwF;IACxF,eAAe,CAAC,EAAE,mBAAmB,EAAE,CAAC;IACxC;mGAC+F;IAC/F,WAAW,CAAC,EAAE,MAAM,EAAE,CAAC;CACxB"}

package/dist/types/manifest.js

@@ -0,0 +1 @@
+export const SCHEMA_VERSION = '1.0';

package/dist/types/route.d.ts

@@ -0,0 +1,20 @@
+export interface RouteGuards {
+    canActivate?: string[];
+    canDeactivate?: string[];
+}
+export type ReactRoutingPattern = 'jsx-routes' | 'router-config' | 'file-based';
+export interface RouteNode {
+    path: string;
+    /** The resolved lazy-loaded target, e.g. Angular's loadComponent or a React <Route element>. */
+    component?: {
+        module: string;
+        export: string;
+    };
+    redirectTo?: string;
+    pathMatch?: string;
+    guards?: RouteGuards;
+    children?: RouteNode[];
+    /** React only, set at the tree root: which detection strategy produced this tree. */
+    routingPattern?: ReactRoutingPattern;
+}
+//# sourceMappingURL=route.d.ts.map

package/dist/types/route.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"route.d.ts","sourceRoot":"","sources":["../../src/types/route.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,WAAW;IAC1B,WAAW,CAAC,EAAE,MAAM,EAAE,CAAC;IACvB,aAAa,CAAC,EAAE,MAAM,EAAE,CAAC;CAC1B;AAED,MAAM,MAAM,mBAAmB,GAAG,YAAY,GAAG,eAAe,GAAG,YAAY,CAAC;AAEhF,MAAM,WAAW,SAAS;IACxB,IAAI,EAAE,MAAM,CAAC;IACb,gGAAgG;IAChG,SAAS,CAAC,EAAE;QACV,MAAM,EAAE,MAAM,CAAC;QACf,MAAM,EAAE,MAAM,CAAC;KAChB,CAAC;IACF,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,MAAM,CAAC,EAAE,WAAW,CAAC;IACrB,QAAQ,CAAC,EAAE,SAAS,EAAE,CAAC;IACvB,qFAAqF;IACrF,cAAc,CAAC,EAAE,mBAAmB,CAAC;CACtC"}

package/dist/types/route.js

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

package/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "@ui-manifest-json/core",
+  "version": "0.1.0",
+  "description": "Shared JSON schema types and dependency-tree resolver for ui-manifest extractors.",
+  "type": "module",
+  "license": "MIT",
+  "engines": {
+    "node": ">=20.6.0"
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc -b",
+    "test": "vitest run"
+  }
+}