ooxml-core 1.0.0 → 1.2.0

package/dist/diagram/layout/smartart-layout-interpreter-item-role-shared.d.ts

@@ -0,0 +1,102 @@
+/**
+ * SmartArt DiagramML interpreter - shared per-item-role primitives.
+ *
+ * Split out of `smartart-layout-interpreter-item-roles.ts` (the file-size
+ * budget) once `smartart-layout-interpreter-item-roles-recursive.ts` needed
+ * the SAME `dgm:presOf` axis resolution: both a flat (single-level) item
+ * template and a genuinely recursive one (a nested `layoutNode` with its own
+ * `dgm:forEach axis="ch"`) resolve a role to a set of data-node ids the same
+ * way. See both callers' module doc comments for the flat/recursive split
+ * itself; this module only holds the primitives neither wants to duplicate.
+ * A role bound to a TRANSITION point (a numbered-badge's ordinal text)
+ * resolves differently - see
+ * `smartart-layout-interpreter-item-role-transition.ts`. Turning resolved
+ * content into geometry is `smartart-layout-interpreter-item-role-stack.ts`
+ * - both split out separately for the same file-size reason.
+ */
+import type { DiagramLayoutNode, DiagramNode } from '../model/index.js';
+import type { ConstraintIndex } from './smartart-constraint-solver.js';
+/**
+ * DiagramML's own reserved role names for a TRANSITION point between two
+ * siblings/parent-child (ECMA-376's `dgm:pt/@type="sibTrans"`/`"parTrans"`
+ * enum, not an author-chosen name - `smartart-layout-interpreter-flow.ts`'s
+ * `NODE_POINT_TYPES` excludes the same two for the same reason). Such a
+ * layoutNode can still carry `presOf axis="self"` (Multidirectional Cycle's
+ * `sibTrans` wraps a `connectorText` label), but "self" there means the
+ * TRANSITION point's own text, a different data point the axis model below
+ * (scoped to the CURRENT arranged node) cannot resolve - so it must never be
+ * treated as one of the arranged node's own per-item roles.
+ */
+export declare const TRANSITION_ROLE_NAMES: Set<string>;
+/**
+ * True when `node` genuinely projects data-point text: a non-empty
+ * `dgm:presOf/@axis`, and an algorithm that is not DEFINITIVELY decorative.
+ * `dgm:alg type="tx"` is the norm, but `parseSmartArtLayoutAlgorithm` only
+ * reads a DIRECT `<dgm:alg>` child, so a real text role whose alg is itself
+ * `dgm:choose`-wrapped (List1's `parentText`, alternating LTR/RTL params)
+ * parses with `algorithm` undefined - treated permissively here (`undefined`
+ * passes) rather than excluded, since only a KNOWN decorative type
+ * (`sp`/`composite`/`conn`) can be excluded with confidence. False for a
+ * positioning/decoration wrapper with no `presOf` at all, or a bare
+ * `<dgm:presOf/>` with no `axis`.
+ */
+export declare function isTextRole(node: DiagramLayoutNode): boolean;
+/**
+ * True when `topLevelChildren` (an arranger's OWN `.children`, never a
+ * deeper level) has TWO OR MORE direct text roles that each target a
+ * descendant/children axis (`ch`/`des`/`desOrSelf` - as opposed to `self`,
+ * which always targets the SAME single point regardless of which role reads
+ * it). A genuine single coherent item template declares at most ONE such
+ * role (list/card layouts pair exactly one `self` role with at most one
+ * `ch`/`des` one); two or more is the signature of a `dgm:choose` whose
+ * MUTUALLY EXCLUSIVE branches were both flattened onto `.children` (`cycle3`
+ * "Continuous Cycle"'s `Name0` unions its 2-point branch's `node1`/`node2`
+ * -both `axis="ch desOrSelf"`- with its general-N branch's `cycle` sub-
+ * arranger, because `cycle`'s OWN algorithm is itself choose-wrapped so
+ * `discoverArrangement` falls back to `Name0` instead of unwrapping to
+ * `cycle`). Both the flat scan (`resolveItemTextRoles`) and the recursive
+ * walker (`hasRecursiveItemTemplate`) decline unwrapping/recursing past such
+ * an arranger rather than guess which branch is real, conflating the two
+ * branches' item counts - `dgm:choose` branch evaluation for children
+ * flattening (not just algorithm-type selection) is a bigger gap this narrow
+ * guard does not attempt to close.
+ */
+export declare function hasAmbiguousTopLevelRoles(topLevelChildren: DiagramLayoutNode[]): boolean;
+/**
+ * `id -> text` for every one of `node`'s descendants (any depth) - the SAME
+ * set {@link contentIds}'s `ch`/`des`/`desOrSelf` branches resolve ids from.
+ *
+ * Round 20: a `ch`/`des`-axis role (`childText` in "Vertical Bullet List":
+ * `presOf axis="des"`, the point's own CHILD's text, folded into a
+ * companion box beside the point's own `parentText`) resolved the right
+ * `nodeIds` all along, but `smartart-layout-interpreter-item-role-stack-
+ * fields.ts`'s `splitEntryFields` had no way to turn an id back into text -
+ * its `text: entry.literalText ?? original.text` fallback silently
+ * DUPLICATED the point's OWN text into the child's box instead (COM-
+ * verified against `vertical-bullet-list--hier8.pptx`: "Branch A Root"
+ * rendered under BOTH `parentText` AND `childText`, the second one wrong -
+ * the real child, "Branch A Child", never appeared at all). This map lets
+ * the stack/fields modules resolve the REAL text for any `nodeIds` a role
+ * carries, not just the transition-role `literalText` case.
+ */
+export declare function descendantTextById(node: DiagramNode, childrenOf: Map<string, DiagramNode[]>): Map<string, string>;
+/** The data-node id(s) a role's `presOf` axis resolves to for one point. */
+export declare function contentIds(role: DiagramLayoutNode, node: DiagramNode, childrenOf: Map<string, DiagramNode[]>): string[];
+/** A role's own declared preset (`dgm:shape/@type`), or plain `rect` when absent. */
+export declare function rolePreset(role: DiagramLayoutNode): string;
+/**
+ * Cross-axis weight for splitting the item cell across roles: the role's
+ * OWN arranger-declared `h` constraint when it resolves to a positive
+ * number (see `resolveConstraintDeclaredBy`), else an equal share.
+ */
+export declare function heightWeight(index: ConstraintIndex, arrangerRole: string, role: DiagramLayoutNode): number;
+/**
+ * Main-axis weight for splitting the item cell across roles SIDE BY SIDE
+ * (round 27's column role split, `smartart-layout-interpreter-item-role-
+ * stack-columns.ts`): the role's OWN declared `w` constraint, mirroring
+ * {@link heightWeight} exactly but for the cross axis a horizontally-nested
+ * item template ("Vertical Bracket List"'s `linNode`, `linDir="fromL"`)
+ * actually stacks its roles along.
+ */
+export declare function widthWeight(index: ConstraintIndex, declaringRole: string, role: DiagramLayoutNode): number;
+//# sourceMappingURL=smartart-layout-interpreter-item-role-shared.d.ts.map

package/dist/diagram/layout/smartart-layout-interpreter-item-role-shared.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"smartart-layout-interpreter-item-role-shared.d.ts","sourceRoot":"","sources":["../../../diagram/layout/smartart-layout-interpreter-item-role-shared.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,KAAK,EAAE,iBAAiB,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AAE/D,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AAUpE;;;;;;;;;;GAUG;AACH,eAAO,MAAM,qBAAqB,aAAoC,CAAC;AAEvE;;;;;;;;;;;GAWG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,iBAAiB,GAAG,OAAO,CAS3D;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,yBAAyB,CAAC,gBAAgB,EAAE,iBAAiB,EAAE,GAAG,OAAO,CAwCxF;AAOD;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,kBAAkB,CACjC,IAAI,EAAE,WAAW,EACjB,UAAU,EAAE,GAAG,CAAC,MAAM,EAAE,WAAW,EAAE,CAAC,GACpC,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAMrB;AAED,4EAA4E;AAC5E,wBAAgB,UAAU,CACzB,IAAI,EAAE,iBAAiB,EACvB,IAAI,EAAE,WAAW,EACjB,UAAU,EAAE,GAAG,CAAC,MAAM,EAAE,WAAW,EAAE,CAAC,GACpC,MAAM,EAAE,CA6CV;AAED,qFAAqF;AACrF,wBAAgB,UAAU,CAAC,IAAI,EAAE,iBAAiB,GAAG,MAAM,CAE1D;AAED;;;;GAIG;AACH,wBAAgB,YAAY,CAC3B,KAAK,EAAE,eAAe,EACtB,YAAY,EAAE,MAAM,EACpB,IAAI,EAAE,iBAAiB,GACrB,MAAM,CAGR;AAED;;;;;;;GAOG;AACH,wBAAgB,WAAW,CAC1B,KAAK,EAAE,eAAe,EACtB,aAAa,EAAE,MAAM,EACrB,IAAI,EAAE,iBAAiB,GACrB,MAAM,CAGR"}

package/dist/diagram/layout/smartart-layout-interpreter-item-role-stack-columns.d.ts

@@ -0,0 +1,23 @@
+/**
+ * SmartArt DiagramML interpreter - per-item role COLUMN stacking.
+ *
+ * Round 27: sibling to `smartart-layout-interpreter-item-role-stack-rect.ts`'s
+ * `stackAsRect` - splits `content` roles SIDE BY SIDE (weighted by each
+ * role's own `w` share, `widthWeight`) instead of top-to-bottom, for an item
+ * template whose roles are nested inside their own explicitly horizontal
+ * `lin` sub-arranger (`smartart-layout-interpreter-item-role-orientation.ts`'s
+ * `resolveItemRoleLayoutScope`, `orientation: 'column'`) - "Vertical Bracket
+ * List"'s `parTx`/`desTx` pair, cached as a narrow left label column beside a
+ * wide right descendant column, never a vertical stack.
+ */
+import type { ConstraintIndex } from './smartart-constraint-solver.js';
+import type { ItemRoleContent } from './smartart-layout-interpreter-item-role-transition.js';
+import type { RenderedNode, RenderedRectNode } from './smartart-layout-types.js';
+/** Split `content` HORIZONTALLY within `box`, each column (plus any decorative gap between two content columns) weighted by {@link widthWeight}, left to right in `declaringRole`'s own declared order. */
+export declare function stackAsColumns(content: ItemRoleContent[], declaringRole: string, original: RenderedNode, box: {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}, index: ConstraintIndex, nodeTextById: Map<string, string> | undefined): RenderedRectNode[];
+//# sourceMappingURL=smartart-layout-interpreter-item-role-stack-columns.d.ts.map

package/dist/diagram/layout/smartart-layout-interpreter-item-role-stack-columns.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"smartart-layout-interpreter-item-role-stack-columns.d.ts","sourceRoot":"","sources":["../../../diagram/layout/smartart-layout-interpreter-item-role-stack-columns.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAGH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AAMpE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,oDAAoD,CAAC;AAE1F,OAAO,KAAK,EAAE,YAAY,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AA8B9E,2MAA2M;AAC3M,wBAAgB,cAAc,CAC7B,OAAO,EAAE,eAAe,EAAE,EAC1B,aAAa,EAAE,MAAM,EACrB,QAAQ,EAAE,YAAY,EACtB,GAAG,EAAE;IAAE,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,EAC5D,KAAK,EAAE,eAAe,EACtB,YAAY,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,SAAS,GAC3C,gBAAgB,EAAE,CA0CpB"}

package/dist/diagram/layout/smartart-layout-interpreter-item-role-stack-fields.d.ts

@@ -0,0 +1,77 @@
+/**
+ * SmartArt DiagramML interpreter - per-item role split-entry fields.
+ *
+ * Split out of `smartart-layout-interpreter-item-role-stack.ts` (the
+ * file-size budget): this half computes the fields shared by every split row
+ * `stackAsRect` produces (node id, preset, text) and the bounding box a
+ * non-rect `original` seeds a rect split from. Pure TypeScript - no
+ * framework code.
+ */
+import type { ItemRoleContent } from './smartart-layout-interpreter-item-role-transition.js';
+import type { RenderedNode } from './smartart-layout-types.js';
+/**
+ * A role's own RENDERED preset: its declared shape, UNLESS it is a
+ * `self`-axis role with no VISIBLE shape of its own (no `dgm:shape` element
+ * at all, or one marked `hideGeom`) - such a role is not a separate shape, it
+ * IS the arranger's own item box (`detailed-process--hier5.pptx`'s
+ * `parentNode`: `alg type="tx"`, no `dgm:shape` at all), so it must inherit
+ * the arranger's own MERGED preset (`original.presetOverride`, e.g.
+ * `bgRect`'s `roundRect`) instead of {@link rolePreset}'s bare "no shape ->
+ * rect" fallback, which otherwise wins over the composite-level decorative
+ * preset a non-split point at the SAME arranger correctly gets (measured:
+ * `detailed-process`/`grouped-list`/`accent-process--hier5.pptx`'s "Node
+ * One"/"Node Four" - the two points with a child, hence split - rendered
+ * `rect` where every unsplit point, and the cached drawing, has `roundRect`).
+ * Mirrors the identical, already-proven rule `stackRoleContent`'s `polygon`
+ * branch applies for the same reason (see its own doc comment on
+ * `isSelfRole`).
+ */
+export declare function roleRenderPreset(entry: ItemRoleContent, original: RenderedNode): string;
+/**
+ * `entry.nodeIds`' own text, joined `\n`-separated when there is more than
+ * one (matching the fold convention `smartart-interpreter-drawing-
+ * bridge.ts`'s `collectFoldedDescendants` already uses elsewhere) -
+ * `undefined` when `nodeTextById` is not supplied (a caller that has not
+ * been updated yet) or none of `nodeIds` resolves (a `self`-axis role: its
+ * OWN id is the point itself, never a descendant, so it is never IN
+ * `nodeTextById` - `original.text` is already correct for it).
+ */
+export declare function textFromNodeIds(nodeIds: string[], nodeTextById: Map<string, string> | undefined): string | undefined;
+/**
+ * Fields every split entry shares, regardless of `original.kind`: the role's
+ * own node id(s), preset, and text - see `stackRoleContent`'s doc comment
+ * for `itemRoleName`.
+ *
+ * @param nodeTextById - Round 20: `id -> text` for the point's own
+ *   descendants ({@link descendantTextById}), so a `ch`/`des`-axis role
+ *   (`childText`, "the point's own child's text") renders ITS real content
+ *   instead of silently duplicating `original.text` (the point's OWN text) -
+ *   see {@link descendantTextById}'s doc comment for the concrete bug this
+ *   closes. Omit to keep the pre-existing (duplicating) fallback, for a
+ *   caller not yet updated to supply it.
+ */
+export declare function splitEntryFields(entry: ItemRoleContent, key: string, original: RenderedNode, nodeTextById?: Map<string, string>): {
+    key: string;
+    nodeId: string | undefined;
+    foldedNodeIds: string[];
+    presetOverride: string;
+    itemRoleName: string | undefined;
+    literalText: string | undefined;
+    text: string;
+};
+/**
+ * `original`'s own bounding box, regardless of `kind` - a `circle` measures
+ * its `rx`/`ry` (or plain `r`) around `cx`/`cy`; a `polygon` measures its own
+ * `points`. Used only to seed a RECT split of a non-rect original
+ * (`stackRoleContent`): the arranger's own merged preset (e.g. a decorative
+ * photo circle preferred over the item's REAL text roles - see the round-3
+ * Track S/R handoff notes) is not what the per-item TEXT roles themselves
+ * declare, so this recovers a usable extent to stack them in.
+ */
+export declare function boundingBoxOf(node: RenderedNode): {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+};
+//# sourceMappingURL=smartart-layout-interpreter-item-role-stack-fields.d.ts.map

package/dist/diagram/layout/smartart-layout-interpreter-item-role-stack-fields.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"smartart-layout-interpreter-item-role-stack-fields.d.ts","sourceRoot":"","sources":["../../../diagram/layout/smartart-layout-interpreter-item-role-stack-fields.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAGH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,oDAAoD,CAAC;AAC1F,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAC;AAE5D;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,eAAe,EAAE,QAAQ,EAAE,YAAY,GAAG,MAAM,CAQvF;AAED;;;;;;;;GAQG;AACH,wBAAgB,eAAe,CAC9B,OAAO,EAAE,MAAM,EAAE,EACjB,YAAY,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,SAAS,GAC3C,MAAM,GAAG,SAAS,CAQpB;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,gBAAgB,CAC/B,KAAK,EAAE,eAAe,EACtB,GAAG,EAAE,MAAM,EACX,QAAQ,EAAE,YAAY,EACtB,YAAY,CAAC,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC;;;;;;;;EAsBlC;AAED;;;;;;;;GAQG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,YAAY,GAAG;IAClD,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;CACf,CA6BA"}

package/dist/diagram/layout/smartart-layout-interpreter-item-role-stack-rect.d.ts

@@ -0,0 +1,20 @@
+/**
+ * SmartArt DiagramML interpreter - per-item role rect stacking.
+ *
+ * Split out of `smartart-layout-interpreter-item-role-stack.ts` (the
+ * file-size budget): `stackRoleContent` there dispatches to `stackAsRect`
+ * here whenever a role split can be expressed as a plain vertical rect
+ * stack - see that module's own doc comment for the other (non-rect)
+ * splits it handles directly.
+ */
+import type { ConstraintIndex } from './smartart-constraint-solver.js';
+import type { ItemRoleContent } from './smartart-layout-interpreter-item-role-transition.js';
+import type { RenderedNode, RenderedRectNode } from './smartart-layout-types.js';
+/** Split `content` vertically within `box`, each row weighted by {@link heightWeight}. */
+export declare function stackAsRect(content: ItemRoleContent[], arrangerRole: string, original: RenderedNode, box: {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}, index: ConstraintIndex, nodeTextById: Map<string, string> | undefined): RenderedRectNode[];
+//# sourceMappingURL=smartart-layout-interpreter-item-role-stack-rect.d.ts.map

package/dist/diagram/layout/smartart-layout-interpreter-item-role-stack-rect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"smartart-layout-interpreter-item-role-stack-rect.d.ts","sourceRoot":"","sources":["../../../diagram/layout/smartart-layout-interpreter-item-role-stack-rect.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAQH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AAMpE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,oDAAoD,CAAC;AAE1F,OAAO,KAAK,EAAE,YAAY,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AA+C9E,0FAA0F;AAC1F,wBAAgB,WAAW,CAC1B,OAAO,EAAE,eAAe,EAAE,EAC1B,YAAY,EAAE,MAAM,EACpB,QAAQ,EAAE,YAAY,EACtB,GAAG,EAAE;IAAE,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,EAC5D,KAAK,EAAE,eAAe,EACtB,YAAY,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,SAAS,GAC3C,gBAAgB,EAAE,CAoDpB"}

package/dist/diagram/layout/smartart-layout-interpreter-item-role-stack.d.ts

@@ -0,0 +1,53 @@
+/**
+ * SmartArt DiagramML interpreter - per-item role geometry stacking.
+ *
+ * Split out of `smartart-layout-interpreter-item-role-shared.ts` (the
+ * file-size budget): once role CONTENT is resolved (`contentIds`/
+ * `resolveRoleContent`), this module turns it into actual `RenderedNode`
+ * geometry, shared by the flat item-roles expander
+ * (`smartart-layout-interpreter-item-roles.ts`) and the recursive
+ * item-template expander (`-item-roles-recursive.ts`) so both split
+ * identically.
+ */
+import type { ConstraintIndex } from './smartart-constraint-solver.js';
+import type { ItemRoleLayoutScope } from './smartart-layout-interpreter-item-role-orientation.js';
+import type { ItemRoleContent } from './smartart-layout-interpreter-item-role-transition.js';
+import type { RenderedNode } from './smartart-layout-types.js';
+/**
+ * Stack already-resolved role `content` within `original`'s box. Returns
+ * `undefined` when there is nothing to do: EXACTLY one role whose own kind
+ * already matches `original.kind` (the common "single text box" case, no
+ * correction needed). Shared by the flat item-roles expander and the
+ * recursive item-template expander so both split identically.
+ *
+ * When EVERY role's own declared preset resolves to a plain rect-family
+ * shape ({@link resolvePresetRenderKind}), the role(s) are laid out as
+ * rect(s) within `original`'s bounding box - stacked vertically in content
+ * order (weighted by `heightWeight`) when there are 2+, or the FULL box
+ * re-kinded to `rect` for a lone one - regardless of what `kind` the
+ * arranger's own MERGED per-item shape happened to resolve to. This is what
+ * makes "Meet the Team" work (and every gallery layout sharing its shape:
+ * `Small Dots Horizontal/Vertical`, `Bullet Timeline`, `Circle Accent
+ * Timeline`, ...): a leaf point (no child, exactly one resolved role) is
+ * JUST as affected as a point with a child (2+ roles) - `compNode` collapses
+ * to `kind: 'circle'` for EVERY point because `findCompositeItemShape`
+ * prefers the decorative `photoCircle`'s `ellipse` (no separate box of its
+ * own - a genuinely decorative accent, never a text role) over `nameText`/
+ * `roleText`'s OWN declared `rect` shapes, but the cached drawing renders
+ * `nameText`/`roleText` as real rect text boxes regardless, leaf or not. A
+ * rendered item node's `kind` is only ITS OWN merged-shape choice, never
+ * binding on what its per-item TEXT roles declare - each role becomes its
+ * own shape with its own declared preset.
+ *
+ * Otherwise (a pyramid row's `trapezoid`/`nonIsoscelesTrapezoid` parent+
+ * child accent, `arrangePyramid`) there is no generic way to split
+ * `original`'s OWN geometry the way a rect splits by height - see the
+ * round-3 Track S/R handoff notes. So each role's entry starts as an
+ * UNCHANGED copy of `original`'s geometry (kind included), tagged with
+ * `itemRoleName` (the role's own `dgm:layoutNode` name) so an
+ * arranger-specific geometry pass can reposition/resize each entry by that
+ * name afterwards; this function itself only guarantees the right per-role
+ * TEXT and COUNT exist as separate points.
+ */
+export declare function stackRoleContent(content: ItemRoleContent[], arrangerRole: string, original: RenderedNode, index: ConstraintIndex, nodeTextById?: Map<string, string>, layoutScope?: ItemRoleLayoutScope): RenderedNode[] | undefined;
+//# sourceMappingURL=smartart-layout-interpreter-item-role-stack.d.ts.map

package/dist/diagram/layout/smartart-layout-interpreter-item-role-stack.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"smartart-layout-interpreter-item-role-stack.d.ts","sourceRoot":"","sources":["../../../diagram/layout/smartart-layout-interpreter-item-role-stack.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AACpE,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,qDAAqD,CAAC;AAO/F,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,oDAAoD,CAAC;AAE1F,OAAO,KAAK,EAAE,YAAY,EAAoB,MAAM,yBAAyB,CAAC;AAE9E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,wBAAgB,gBAAgB,CAC/B,OAAO,EAAE,eAAe,EAAE,EAC1B,YAAY,EAAE,MAAM,EACpB,QAAQ,EAAE,YAAY,EACtB,KAAK,EAAE,eAAe,EACtB,YAAY,CAAC,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,EAClC,WAAW,CAAC,EAAE,mBAAmB,GAC/B,YAAY,EAAE,GAAG,SAAS,CA2J5B"}

package/dist/diagram/layout/smartart-layout-interpreter-item-role-transition.d.ts

@@ -0,0 +1,50 @@
+/**
+ * SmartArt DiagramML interpreter - per-item role content bound to a
+ * TRANSITION point instead of a data node.
+ *
+ * Split out of `smartart-layout-interpreter-item-role-shared.ts` (the
+ * file-size budget). A layout can declare a per-item role whose `dgm:presOf`
+ * targets a `sibTrans`/`parTrans` point rather than a content node - the
+ * shape ECMA-376 layouts use for a per-item ordinal/position badge
+ * (`NumberedDotsHorizontal`'s `numCircle`: `presOf axis="self"
+ * ptType="sibTrans"`, whose "1"/"2"/"3" text lives on the item's own `parOf`
+ * edge's `sibTrans` point, read via `DiagramConnection.label` -
+ * `PptxHandlerRuntimeSmartArtParsing.ts`'s `parseSmartArtConnections`
+ * already resolves whichever of the edge's `parTrans`/`sibTrans` points
+ * actually carries text). Such a role has no `DiagramNode` id to join
+ * back to, so it resolves to a LITERAL string instead of node ids - see
+ * `ItemRoleContent.literalText`.
+ */
+import type { DiagramLayoutNode, DiagramNode } from '../model/index.js';
+import type { DiagramConnection } from '../types.js';
+/** One resolved role, with the actual data-node ids supplying its text. */
+export interface ItemRoleContent {
+    role: DiagramLayoutNode;
+    nodeIds: string[];
+    /**
+     * Verbatim display text for a role bound to a TRANSITION point instead of
+     * a data node (see {@link resolveRoleContent}). `nodeIds` is empty
+     * whenever this is set: a transition point's text has no `DiagramNode`
+     * id to join back to.
+     */
+    literalText?: string;
+}
+/**
+ * Resolve ONE role's content for `node`: a transition-bound role
+ * ({@link isTransitionRole}) resolves to its edge's {@link transitionLabel}
+ * (no node ids at all - see {@link ItemRoleContent.literalText}); everything
+ * else resolves via `contentIds` as before. Returns `undefined` when the
+ * role has no content to contribute (dropped by the caller, matching the
+ * pre-existing "empty ids" behaviour).
+ */
+export declare function resolveRoleContent(role: DiagramLayoutNode, node: DiagramNode, childrenOf: Map<string, DiagramNode[]>, connections: DiagramConnection[] | undefined): ItemRoleContent | undefined;
+/**
+ * Fold `resolved` into `out`, deduplicating against `used` (a data-node id
+ * already claimed by an earlier role, per `resolveItemRoleContent`'s doc
+ * comment) - a `literalText` entry (empty `nodeIds`) has nothing to dedupe
+ * against and always survives. Shared by the flat scan
+ * (`resolveItemRoleContent`) and the recursive walker's `visitOne` so both
+ * apply the exact same mutual-exclusion rule.
+ */
+export declare function pushRoleContent(resolved: ItemRoleContent | undefined, used: Set<string>, out: ItemRoleContent[]): void;
+//# sourceMappingURL=smartart-layout-interpreter-item-role-transition.d.ts.map

package/dist/diagram/layout/smartart-layout-interpreter-item-role-transition.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"smartart-layout-interpreter-item-role-transition.d.ts","sourceRoot":"","sources":["../../../diagram/layout/smartart-layout-interpreter-item-role-transition.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,OAAO,KAAK,EAAE,iBAAiB,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AAC/D,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAC;AAGlD,2EAA2E;AAC3E,MAAM,WAAW,eAAe;IAC/B,IAAI,EAAE,iBAAiB,CAAC;IACxB,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB;;;;;OAKG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;CACrB;AAoCD;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CACjC,IAAI,EAAE,iBAAiB,EACvB,IAAI,EAAE,WAAW,EACjB,UAAU,EAAE,GAAG,CAAC,MAAM,EAAE,WAAW,EAAE,CAAC,EACtC,WAAW,EAAE,iBAAiB,EAAE,GAAG,SAAS,GAC1C,eAAe,GAAG,SAAS,CAO7B;AAED;;;;;;;GAOG;AACH,wBAAgB,eAAe,CAC9B,QAAQ,EAAE,eAAe,GAAG,SAAS,EACrC,IAAI,EAAE,GAAG,CAAC,MAAM,CAAC,EACjB,GAAG,EAAE,eAAe,EAAE,GACpB,IAAI,CAgBN"}

package/dist/diagram/layout/smartart-layout-interpreter-item-roles-recursive.d.ts

@@ -0,0 +1,87 @@
+/**
+ * SmartArt DiagramML interpreter - RECURSIVE per-item template expansion.
+ *
+ * ECMA-376 21.4's `dgm:forEach` is not limited to the single top-level
+ * iteration an arranger (`lin`/`snake`/`cycle`/`pyra`) already performs over
+ * its own point list (handled by the arranger algorithms themselves, and by
+ * the single-level role splitting in `smartart-layout-interpreter-item-
+ * roles.ts`): a `layoutNode` INSIDE an item template can carry its OWN
+ * `dgm:forEach axis="ch"`, meaning "repeat everything nested under me once
+ * per CHILD of the point currently being rendered" - a genuinely recursive
+ * per-item template. `LinedList` is the canonical case: each top-level
+ * item's box (`horz1`/`tx1`) nests a `vert1` sub-arranger whose `dgm:forEach
+ * axis="ch"` repeats `horz2`/`tx2` once per child of THAT item, and `vert2`
+ * nests exactly the same pattern one level deeper again (`horz3`/`tx3`,
+ * `horz4`/`tx4`), so an item with a grandchild gets three text-bearing
+ * boxes, one with no children gets one.
+ *
+ * `smartart-layout-definition.ts` already preserves what this needs: a
+ * layoutNode reached by walking through a `dgm:forEach` wrapper carries that
+ * forEach's iterator attributes on its OWN `.forEachOrigin` (`undefined` for
+ * a direct child, or one reached only through a `dgm:choose` - a condition,
+ * not an iteration). A layoutNode can have MULTIPLE forEach children with
+ * different axes (`lProcess1`'s `vertFlow` has a `ptType="parTrans" cnt="1"`
+ * one for its connector AND a SEPARATE `axis="ch"` one for its repeated
+ * `child` item), so this must be checked PER CHILD via `.forEachOrigin`, not
+ * by asking the PARENT "do you have `.forEach` entries wrapping ANY axis" -
+ * an earlier version of this module did the latter and treated `vertFlow`
+ * itself as the recursion boundary (because ONE of its forEach children
+ * happened to be `axis="ch"`), which silently swallowed `lProcess1`'s
+ * `header` role - the regression this comment now guards against. A
+ * layoutNode whose OWN `.forEachOrigin` is `axis="ch"` (with no `ptType` or
+ * an explicit `"node"`) is the recursion boundary this module walks;
+ * everything else (`followSib`, a `ptType="parTrans"`/`"sibTrans"`
+ * transition, a direct child) is left as a static, once-only template, its
+ * pre-existing treatment.
+ *
+ * Deliberately separate from `smartart-layout-interpreter-item-roles.ts`'s
+ * flat role splitting (a single level, template-only, data-free scan)
+ * rather than folded into it: the flat scan's role ORDER (a wrapper's own
+ * children appended AFTER its flat siblings - see that module's List1 doc
+ * comment) is deliberately tuned to real fixtures with no `axis="ch"`
+ * forEach anywhere in the item template, and changing that walk to a
+ * natural document-order recursive descent would silently reorder those
+ * layouts' stacked roles. This module only activates when
+ * {@link hasRecursiveItemTemplate} finds the genuinely new construct, so
+ * neither path can regress the other's fixtures.
+ */
+import type { DiagramLayoutNode, DiagramNode } from '../model/index.js';
+import type { DiagramConnection } from '../types.js';
+import type { ConstraintIndex } from './smartart-constraint-solver.js';
+import type { ItemRoleContent } from './smartart-layout-interpreter-item-role-transition.js';
+import type { RenderedNode } from './smartart-layout-types.js';
+/**
+ * True when ANY node BELOW `arranger`'s own item-template level (i.e. not
+ * `arranger.children` themselves, but something reachable from one of
+ * them) was produced by a `ch`-axis `dgm:forEach` - the marker this whole
+ * module exists to walk. `arranger.children` are deliberately excluded at
+ * this top level: they were already produced by the OUTER forEach the
+ * ARRANGER itself consumes (one item template per already-rendered point),
+ * which is typically the very same `axis="ch" ptType="node"` shape a nested
+ * recursion boundary uses, so checking `arranger.children`'s OWN
+ * `.forEachOrigin` here would treat EVERY multi-node item template as
+ * "recursive". Cheap existence scan, no data involved.
+ */
+export declare function hasRecursiveItemTemplate(arranger: DiagramLayoutNode): boolean;
+/**
+ * Resolve `arranger`'s (possibly recursive) item template against `node`,
+ * the specific point being rendered - the recursive counterpart of the flat
+ * scan's `resolveItemTextRoles` + `resolveItemRoleContent` combined, since a
+ * recursive template's roles are inseparable from the data node each one
+ * resolves against (a `ch`-axis forEach's descendants belong to a DIFFERENT
+ * context node than its own siblings). `arranger.children` are visited with
+ * `node` itself as context, ignoring their OWN `.forEachOrigin` (see
+ * {@link hasRecursiveItemTemplate}'s doc comment): the arranger's OUTER
+ * forEach already produced one item template per rendered point, so this is
+ * that SAME point, not a fresh iteration.
+ */
+export declare function resolveRecursiveItemRoleContent(arranger: DiagramLayoutNode, node: DiagramNode, childrenOf: Map<string, DiagramNode[]>, connections?: DiagramConnection[]): ItemRoleContent[];
+/**
+ * Expand ONE arranger-computed box for a single arranged point into its
+ * recursive per-item text roles, stacking them within the SAME box
+ * vertically in template order (see `stackRoleContent`). Returns
+ * `undefined` when this point resolves to at most one role (no qualifying
+ * children at any depth), so the caller keeps its original single box.
+ */
+export declare function expandRecursiveItemRoles(arranger: DiagramLayoutNode, arrangerRole: string, original: RenderedNode, node: DiagramNode, childrenOf: Map<string, DiagramNode[]>, index: ConstraintIndex, connections?: DiagramConnection[]): RenderedNode[] | undefined;
+//# sourceMappingURL=smartart-layout-interpreter-item-roles-recursive.d.ts.map

package/dist/diagram/layout/smartart-layout-interpreter-item-roles-recursive.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"smartart-layout-interpreter-item-roles-recursive.d.ts","sourceRoot":"","sources":["../../../diagram/layout/smartart-layout-interpreter-item-roles-recursive.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8CG;AAEH,OAAO,KAAK,EAAE,iBAAiB,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AAC/D,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAC;AAClD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AAQpE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,oDAAoD,CAAC;AAK1F,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAC;AAgB5D;;;;;;;;;;;GAWG;AACH,wBAAgB,wBAAwB,CAAC,QAAQ,EAAE,iBAAiB,GAAG,OAAO,CAO7E;AA6DD;;;;;;;;;;;GAWG;AACH,wBAAgB,+BAA+B,CAC9C,QAAQ,EAAE,iBAAiB,EAC3B,IAAI,EAAE,WAAW,EACjB,UAAU,EAAE,GAAG,CAAC,MAAM,EAAE,WAAW,EAAE,CAAC,EACtC,WAAW,CAAC,EAAE,iBAAiB,EAAE,GAC/B,eAAe,EAAE,CAOnB;AAED;;;;;;GAMG;AACH,wBAAgB,wBAAwB,CACvC,QAAQ,EAAE,iBAAiB,EAC3B,YAAY,EAAE,MAAM,EACpB,QAAQ,EAAE,YAAY,EACtB,IAAI,EAAE,WAAW,EACjB,UAAU,EAAE,GAAG,CAAC,MAAM,EAAE,WAAW,EAAE,CAAC,EACtC,KAAK,EAAE,eAAe,EACtB,WAAW,CAAC,EAAE,iBAAiB,EAAE,GAC/B,YAAY,EAAE,GAAG,SAAS,CAS5B"}

package/dist/diagram/layout/smartart-layout-interpreter-item-roles-unwrap.d.ts

@@ -0,0 +1,57 @@
+/**
+ * SmartArt DiagramML interpreter - non-text wrapper drilling + parity-
+ * alternating wrapper resolution.
+ *
+ * Split out of `smartart-layout-interpreter-item-roles.ts` (the repo's
+ * per-file line budget): this half handles reaching THROUGH a non-text
+ * wrapper layoutNode to its real text roles, and the "two or more wrappers
+ * alternate by forEach parity, but declare content-compatible roles" case.
+ * Pure TypeScript - no framework code, no DOM.
+ */
+import type { DiagramLayoutNode } from '../model/index.js';
+/**
+ * Every text-role DESCENDANT of `node` reachable by drilling through
+ * non-text wrapper layoutNodes (composite item templates, nested composites
+ * inside composites), depth-first document order. Stops descending as soon
+ * as it reaches a node that is itself a text role (nothing further to
+ * unwrap) or a reserved TRANSITION role name (`sibTrans`/`parTrans`, e.g.
+ * Multidirectional Cycle's `sibTrans` wrapping a `connectorText` label) -
+ * its "self" means the transition point's own text, not the arranged node's,
+ * so its children must never surface as one of the arranged node's own
+ * roles. `CaptionedPictures`' shape needs the recursion: `composite` wraps
+ * `ChildComposite`, which is itself the ONLY node with the real `Child`
+ * (`des`)/`Parent` (`self`) text roles - two wrapper levels deep.
+ */
+export declare function unwrapTextRoles(node: DiagramLayoutNode): DiagramLayoutNode[];
+/**
+ * True when `node` was reached through a forEach that covers only PART of
+ * the point set - either a transition-only iterator ({@link
+ * isTransitionOnlyChild}) or a genuine `axis="ch"` iterator with `step > 1`
+ * (`Alternating Flow`'s `composite1`, `step="2"`, every OTHER point). A
+ * wrapper reached this way is one of several PARITY-ALTERNATING templates,
+ * never a role that applies to every arranged point on its own.
+ */
+export declare function isPartialForEachOrigin(node: DiagramLayoutNode): boolean;
+/**
+ * Resolve `resolveItemTextRoles`'s decision when 2+ contributing wrappers
+ * exist and at least one is reached through a {@link isPartialForEachOrigin}
+ * iterator - `Alternating Flow`'s `composite1`/`composite2` (parity-
+ * alternating). `smartart-layout-interpreter-flow.ts`'s `selectArrangedNodes`
+ * resolves the UNION of both iterators (every point, not just one parity
+ * half), so every point renders through the SAME base geometry
+ * (`itemNode(arranger)`, the FIRST wrapper's) regardless of which template
+ * its own position would visually pick - only the TEXT CONTENT split still
+ * needs a role list. When every wrapper resolves the SAME SET of role axis
+ * kinds ({@link roleAxisSignature} - both `composite1`/`composite2` are a
+ * `self`+`des` pair here, just styled/positioned differently for the
+ * alternating visual), the wrappers are content-INTERCHANGEABLE: use the one
+ * reached through the diagram's OWN primary iterator (not partial) for every
+ * point, since `self`/`des` resolve identically against ANY point regardless
+ * of which wrapper's name happened to declare them. Only when the axis SETS
+ * genuinely differ (a real ambiguity, not just a styling alternative -
+ * unmeasured against any gallery fixture so far, but plausible for a
+ * hypothetical arranger whose two templates' roles do not correspond) does
+ * this decline entirely (`undefined`), like `hasAmbiguousTopLevelRoles`.
+ */
+export declare function resolvePartialForEachRoles(contributingWrappers: DiagramLayoutNode[]): DiagramLayoutNode[] | undefined;
+//# sourceMappingURL=smartart-layout-interpreter-item-roles-unwrap.d.ts.map

package/dist/diagram/layout/smartart-layout-interpreter-item-roles-unwrap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"smartart-layout-interpreter-item-roles-unwrap.d.ts","sourceRoot":"","sources":["../../../diagram/layout/smartart-layout-interpreter-item-roles-unwrap.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAC;AAIlD;;;;;;;;;;;;GAYG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,iBAAiB,GAAG,iBAAiB,EAAE,CAa5E;AAED;;;;;;;GAOG;AACH,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,iBAAiB,GAAG,OAAO,CAEvE;AAUD;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,0BAA0B,CACzC,oBAAoB,EAAE,iBAAiB,EAAE,GACvC,iBAAiB,EAAE,GAAG,SAAS,CAUjC"}

package/dist/diagram/layout/smartart-layout-interpreter-item-roles.d.ts

@@ -0,0 +1,109 @@
+/**
+ * SmartArt DiagramML interpreter - per-item text-role expansion.
+ *
+ * A `forEach axis="ch" ptType="node"`-driven arranger (linear/snake/cycle/
+ * pyramid) gives every top-level data point ONE box via its arranger's
+ * primary item template. Many real built-in layouts declare a SECOND (or
+ * more) per-item text role alongside that primary one, in one of three
+ * shapes:
+ *
+ *  - flat siblings directly under the forEach - e.g. Vertical Bullet List's
+ *    `parentText` (self) plus a `dgm:choose`-guarded `childText` (`des`,
+ *    when the point has children) or `spacer` (no text). Both choose
+ *    branches are already flattened onto `.children` by
+ *    `smartart-layout-definition.ts`'s `nestedLayoutNodes`.
+ *  - a composite item WRAPPER - e.g. Meet the Team's `compNode`: the item
+ *    itself paints no text, and its OWN children (`nameText`/`roleText`,
+ *    ...) are the real per-item roles.
+ *  - TWO (or more) PARALLEL composite wrappers, each its own top-level
+ *    child of the arranger, each driven by its OWN separate `dgm:forEach
+ *    axis="ch"` over the SAME point set - e.g. `CircleAccentTimeline`'s
+ *    `parComposite` (self text) and `desComposite` (the point's own CHILD
+ *    text), two independent forEach blocks flattened onto `.children` as
+ *    siblings. {@link resolveItemTextRoles} drills into EVERY non-text
+ *    wrapper at the arranger's own level, not only the first, or the second
+ *    wrapper's roles are invisible.
+ *
+ * A FOURTH shape - a nested `layoutNode` with its OWN `dgm:forEach
+ * axis="ch"`, repeating a whole sub-template once per child of the point
+ * being rendered (Lined List's `vert1`/`vert2`/`vert3`) - is handled by
+ * `smartart-layout-interpreter-item-roles-recursive.ts` instead: see that
+ * module's doc comment for why it is a separate walker rather than a case
+ * here. {@link expandResultItemRoles} dispatches to whichever applies.
+ *
+ * Before this module, the interpreter rendered ONLY the primary item's own
+ * text and folded every other descendant into that SAME box as extra
+ * paragraphs (`collectFoldedDescendants` in
+ * `smartart-interpreter-drawing-bridge.ts`) - correct for a node added a
+ * level deeper via the text pane's Tab/"Add Bullet", but wrong whenever the
+ * layoutDef declares a REAL second box for that descendant text (the
+ * majority case for list/card layouts).
+ *
+ * This is a partial, general fix: it uses `dgm:presOf`'s `axis` (`self`/
+ * `ch`/`des`/`desOrSelf`) to decide which data lands in which role box, and
+ * does NOT evaluate the guarding `dgm:choose`/`dgm:if` condition - see
+ * {@link resolveItemRoleContent}'s doc comment for how mutually exclusive
+ * alternatives are told apart without it. Geometry is a starting
+ * approximation (roles stacked vertically, weighted by an
+ * arranger-declared `h` constraint when one resolves): a composite-wrapped
+ * item's TRUE per-role layout (can be side-by-side) is left to the
+ * arranger-specific geometry work this module does not attempt.
+ *
+ * Also exports {@link expandResultItemRoles}, the one caller
+ * (`smartart-layout-interpreter.ts`) needs to apply role-splitting across a
+ * whole arrangement result. See `smartart-layout-interpreter-hub.ts` for the
+ * related but distinct "hub + satellites" detection.
+ */
+import type { DiagramLayoutNode, DiagramNode, DiagramPresLayoutVars } from '../model/index.js';
+import type { DiagramConnection } from '../types.js';
+import type { ConstraintIndex } from './smartart-constraint-solver.js';
+import type { ItemRoleLayoutScope } from './smartart-layout-interpreter-item-role-orientation.js';
+import type { ItemRoleContent } from './smartart-layout-interpreter-item-role-transition.js';
+import type { RenderedNode, SmartArtLayoutResult } from './smartart-layout-types.js';
+import type { RawXmlView } from './smartart-choose-xml.js';
+export { contentIds, isTextRole, rolePreset, TRANSITION_ROLE_NAMES, } from './smartart-layout-interpreter-item-role-shared.js';
+export type { ItemRoleContent } from './smartart-layout-interpreter-item-role-transition.js';
+/**
+ * The per-item text-role templates for one arranged point, beyond the
+ * single box the caller's existing arranger already produces. Returns
+ * `undefined` when the item is (or reduces to) a single plain text box -
+ * the common case, where the caller keeps its pre-existing behaviour.
+ */
+export declare function resolveItemTextRoles(arranger: DiagramLayoutNode): DiagramLayoutNode[] | undefined;
+/**
+ * Resolve each of `roles`' actual content for `node`, in template order.
+ * Two roles can target the SAME axis as mutually exclusive `dgm:choose`
+ * alternatives both surviving flattening (Step Down Process's LAST-point
+ * `FinalChildText` vs every other point's `ChildText`, both `des`, chosen by
+ * a `followSib` count this module does not evaluate) - a role whose
+ * resolved ids are already fully claimed by an earlier role is dropped
+ * rather than rendering the same descendant text twice. `connections`
+ * (optional) resolves a role bound to a TRANSITION point instead of a data
+ * node (see `resolveRoleContent`'s doc comment) - a numbered-badge layout's
+ * ordinal text, read from the item's own `parOf` edge's `sibTrans`/`parTrans`
+ * point.
+ */
+export declare function resolveItemRoleContent(roles: DiagramLayoutNode[], node: DiagramNode, childrenOf: Map<string, DiagramNode[]>, connections?: DiagramConnection[]): ItemRoleContent[];
+/**
+ * Expand ONE arranger-computed box for a single arranged point into its
+ * per-item text roles (`roles`, from {@link resolveItemTextRoles}), stacking
+ * them within the SAME box vertically in template order. Returns
+ * `undefined` when this particular point has no secondary role content (no
+ * qualifying descendants), so the caller keeps its original single box.
+ */
+export declare function expandItemRoles(roles: DiagramLayoutNode[], arrangerRole: string, original: RenderedNode, node: DiagramNode, childrenOf: Map<string, DiagramNode[]>, index: ConstraintIndex, connections?: DiagramConnection[], layoutScope?: ItemRoleLayoutScope): RenderedNode[] | undefined;
+/**
+ * Expand every arranged point's box in `result` into its per-item text
+ * roles, when `arranger`'s item template declares more than one (see
+ * {@link resolveItemTextRoles}), or is a genuinely RECURSIVE item template
+ * (a nested `layoutNode` with its own `dgm:forEach axis="ch"`, repeating a
+ * whole sub-template once per child of the point being rendered - Lined
+ * List's `vert1`/`vert2`/`vert3`; see `smartart-layout-interpreter-item-
+ * roles-recursive.ts`'s module doc comment for why that is a dedicated
+ * walker rather than a case here). A no-op (returns `result` unchanged) for
+ * the common single-text-box item template. The one entry point
+ * `smartart-layout-interpreter.ts` needs. `connections`, when supplied, lets
+ * a transition-bound role (a numbered-badge's ordinal text) resolve too.
+ */
+export declare function expandResultItemRoles(view: RawXmlView<unknown>, arranger: DiagramLayoutNode, result: SmartArtLayoutResult, nodes: DiagramNode[], childrenOf: Map<string, DiagramNode[]>, index: ConstraintIndex, connections?: DiagramConnection[], presLayoutVars?: DiagramPresLayoutVars): SmartArtLayoutResult;
+//# sourceMappingURL=smartart-layout-interpreter-item-roles.d.ts.map

package/dist/diagram/layout/smartart-layout-interpreter-item-roles.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"smartart-layout-interpreter-item-roles.d.ts","sourceRoot":"","sources":["../../../diagram/layout/smartart-layout-interpreter-item-roles.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuDG;AAEH,OAAO,KAAK,EAAE,iBAAiB,EAAE,WAAW,EAAE,qBAAqB,EAAE,MAAM,UAAU,CAAC;AACtF,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAC;AAClD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AAEpE,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,qDAAqD,CAAC;AAQ/F,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,oDAAoD,CAAC;AAc1F,OAAO,KAAK,EAAE,YAAY,EAAE,oBAAoB,EAAE,MAAM,yBAAyB,CAAC;AAClF,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,uBAAuB,CAAC;AAExD,OAAO,EACN,UAAU,EACV,UAAU,EACV,UAAU,EACV,qBAAqB,GACrB,MAAM,gDAAgD,CAAC;AACxD,YAAY,EAAE,eAAe,EAAE,MAAM,oDAAoD,CAAC;AAE1F;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAAC,QAAQ,EAAE,iBAAiB,GAAG,iBAAiB,EAAE,GAAG,SAAS,CAgDjG;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,sBAAsB,CACrC,KAAK,EAAE,iBAAiB,EAAE,EAC1B,IAAI,EAAE,WAAW,EACjB,UAAU,EAAE,GAAG,CAAC,MAAM,EAAE,WAAW,EAAE,CAAC,EACtC,WAAW,CAAC,EAAE,iBAAiB,EAAE,GAC/B,eAAe,EAAE,CAOnB;AAED;;;;;;GAMG;AACH,wBAAgB,eAAe,CAC9B,KAAK,EAAE,iBAAiB,EAAE,EAC1B,YAAY,EAAE,MAAM,EACpB,QAAQ,EAAE,YAAY,EACtB,IAAI,EAAE,WAAW,EACjB,UAAU,EAAE,GAAG,CAAC,MAAM,EAAE,WAAW,EAAE,CAAC,EACtC,KAAK,EAAE,eAAe,EACtB,WAAW,CAAC,EAAE,iBAAiB,EAAE,EACjC,WAAW,CAAC,EAAE,mBAAmB,GAC/B,YAAY,EAAE,GAAG,SAAS,CAU5B;AAkBD;;;;;;;;;;;;GAYG;AACH,wBAAgB,qBAAqB,CACpC,IAAI,EAAE,UAAU,CAAC,OAAO,CAAC,EACzB,QAAQ,EAAE,iBAAiB,EAC3B,MAAM,EAAE,oBAAoB,EAC5B,KAAK,EAAE,WAAW,EAAE,EACpB,UAAU,EAAE,GAAG,CAAC,MAAM,EAAE,WAAW,EAAE,CAAC,EACtC,KAAK,EAAE,eAAe,EACtB,WAAW,CAAC,EAAE,iBAAiB,EAAE,EACjC,cAAc,CAAC,EAAE,qBAAqB,GACpC,oBAAoB,CAuCtB"}