ooxml-ui 0.30.1 → 1.0.0

package/dist/pptx/render/element-action-affordance.d.ts

@@ -0,0 +1,124 @@
+/**
+ * On-canvas affordances for an element that carries a PowerPoint Action Setting.
+ *
+ * PowerPoint's editing view tells the author, without a click, which shapes are
+ * wired up: an action shape gets a marker, and hovering one shows where it goes.
+ * The viewer mirrors that with two affordances:
+ *
+ *  - the **action indicator**, a small amber lightning badge pinned to the
+ *    element's top-right corner whenever it owns an `a:hlinkClick` (click) or
+ *    `a:hlinkHover` (mouse-over) action;
+ *  - the **link tooltip**, a popover under the element naming the destination
+ *    plus how to follow it.
+ *
+ * Both are AUTHORING chrome, so both are gated on the live editing canvas.
+ * Painting them during a slide show would be wrong twice over: the audience
+ * would see editor furniture, and the badge would sit on top of the very shape
+ * the presenter is trying to click. `presenting` is therefore a hard veto, not
+ * merely the absence of `canInteract`, because the four non-React bindings run
+ * their presentation stage through the same renderer as the editing one.
+ *
+ * Only React drew either of them; the tooltip additionally existed in Vue. That
+ * divergence was also the last residual noise in the cross-binding render
+ * fingerprints, since the badge contributes an `<svg>` and the tooltip
+ * contributes text to an otherwise textless element. The rule and the styling
+ * therefore both live here, so the five bindings cannot drift apart again: a
+ * binding supplies only the markup, never the decision or the look.
+ *
+ * @module render/element-action-affordance
+ */
+import type { PptxElement } from 'ooxml-core/pptx';
+/** Class on the element box that hosts a link tooltip (drives `:hover`). */
+export declare const LINK_TOOLTIP_HOST_CLASS = "pptx-link-host";
+/** Class on the tooltip's outer positioning box. */
+export declare const LINK_TOOLTIP_CLASS = "pptx-link-tooltip";
+/** Class on the tooltip's bordered panel. */
+export declare const LINK_TOOLTIP_PANEL_CLASS = "pptx-link-tooltip-panel";
+/** Class on the tooltip's destination line. */
+export declare const LINK_TOOLTIP_LABEL_CLASS = "pptx-link-tooltip-label";
+/** Class on the tooltip's "how to follow this" hint line. */
+export declare const LINK_TOOLTIP_HINT_CLASS = "pptx-link-tooltip-hint";
+/** Class on the amber action badge. */
+export declare const ACTION_INDICATOR_CLASS = "pptx-action-indicator";
+/**
+ * `d` of the lightning bolt inside the badge, on a `0 0 24 24` viewBox.
+ *
+ * Shared rather than restated per binding so the glyph cannot drift; it is the
+ * same path React has drawn since the badge was introduced.
+ */
+export declare const ACTION_INDICATOR_ICON_PATH = "M13 2L3 14h9l-1 8 10-12h-9l1-8z";
+/**
+ * Styling for both affordances, injected once per document by each binding.
+ *
+ * Written as plain CSS against the `--pptx-*` theme tokens (rather than as
+ * Tailwind utilities, which only React and Vue can use) so Angular, Vanilla and
+ * Svelte get the identical look for free, and so a theme override reaches all
+ * five.
+ *
+ * `font-family` is stated explicitly and deliberately. Left to inherit, the
+ * tooltip picks up whatever the host app happens to set, which is how React and
+ * Vue ended up rendering the same tooltip in two different stacks and put 80
+ * spurious entries into the render-parity fingerprints. Pinning it here makes
+ * the affordance's typography a property of the affordance.
+ */
+export declare const ACTION_AFFORDANCE_CSS = "\n.pptx-action-indicator {\n\tposition: absolute;\n\ttop: -4px;\n\tright: -4px;\n\tz-index: 20;\n\tdisplay: flex;\n\twidth: 16px;\n\theight: 16px;\n\talign-items: center;\n\tjustify-content: center;\n\tborder-radius: 9999px;\n\tbackground: #f59e0b;\n\t/* Left pointer-interactive on purpose: the badge's native title attribute is\n\t   the only place the deck's screen tip is readable, and a title on a\n\t   pointer-transparent node never fires. Clicks still reach the element\n\t   underneath by bubbling, so nothing is swallowed. */\n\tbox-shadow: 0 1px 3px 0 rgb(0 0 0 / 10%), 0 1px 2px -1px rgb(0 0 0 / 10%);\n}\n.pptx-action-indicator svg {\n\twidth: 10px;\n\theight: 10px;\n\tcolor: #fff;\n}\n.pptx-link-tooltip {\n\tposition: absolute;\n\ttop: 100%;\n\tleft: 4px;\n\tz-index: 9999;\n\tmax-width: 16rem;\n\tmargin-top: 4px;\n\topacity: 0;\n\ttransition: opacity 150ms;\n\tpointer-events: none;\n\tfont-family: system-ui, -apple-system, 'Segoe UI', Roboto, sans-serif;\n\ttext-align: left;\n}\n.pptx-link-host:hover > .pptx-link-tooltip {\n\topacity: 1;\n}\n.pptx-link-tooltip-panel {\n\tborder: 1px solid var(--pptx-border, #374151);\n\tborder-radius: 0.25rem;\n\tbackground: var(--pptx-popover, #111827);\n\tpadding: 6px 10px;\n\tbox-shadow: 0 10px 15px -3px rgb(0 0 0 / 10%), 0 4px 6px -4px rgb(0 0 0 / 10%);\n}\n.pptx-link-tooltip-label {\n\toverflow: hidden;\n\tcolor: var(--pptx-foreground, #f3f4f6);\n\tfont-size: 12px;\n\tfont-weight: 400;\n\tfont-style: normal;\n\tline-height: 16px;\n\tletter-spacing: normal;\n\ttext-decoration: none;\n\ttext-overflow: ellipsis;\n\ttext-transform: none;\n\twhite-space: nowrap;\n}\n.pptx-link-tooltip-hint {\n\tmargin-top: 2px;\n\tcolor: var(--pptx-muted-foreground, #9ca3af);\n\tfont-size: 10px;\n\tfont-weight: 400;\n\tfont-style: normal;\n\tline-height: 12px;\n\tletter-spacing: normal;\n\ttext-decoration: none;\n\ttext-transform: none;\n}\n";
+/**
+ * Inject {@link ACTION_AFFORDANCE_CSS} into a document exactly once.
+ *
+ * Every binding calls this from its viewer root rather than shipping the rules
+ * in its own stylesheet, because a per-package copy is precisely how the two
+ * existing implementations drifted. Idempotent, and a no-op under SSR.
+ */
+export declare function ensureActionAffordanceStyles(doc?: Document): void;
+/** Translated strings the affordances fall back to when the deck names none. */
+export interface ActionAffordanceLabels {
+    /** Badge title when neither action carries a screen tip ("Has action"). */
+    hasAction: string;
+    /** Tooltip label when the action names no destination ("Link"). */
+    link: string;
+    /** Hint for an action that opens a URL ("Ctrl+Click to follow link"). */
+    followLink: string;
+    /** Hint for a navigation/verb action ("Active in presentation mode"). */
+    presentationMode: string;
+}
+/**
+ * Build the label set from a binding's translator.
+ *
+ * The four dictionary keys are named once, here, so a binding cannot quietly
+ * hard-code English (which is how React's badge shipped an untranslated "Has
+ * action" while the key for it already existed).
+ */
+export declare function actionAffordanceLabels(translate: (key: string) => string): ActionAffordanceLabels;
+/** Where the affordances are being asked for. */
+export interface ActionAffordanceContext {
+    /**
+     * The live editing canvas is showing this element. Thumbnails, presenter
+     * previews, export rasters and read-only canvases pass `false`.
+     */
+    canInteract: boolean;
+    /** This stage is a running slide show; a hard veto (see the module note). */
+    presenting?: boolean;
+    labels: ActionAffordanceLabels;
+}
+/** What a binding should render for one element. */
+export interface ElementActionAffordance {
+    /** Draw the amber badge. */
+    showIndicator: boolean;
+    /** `title` for the badge: the deck's screen tip, else the generic label. */
+    indicatorTitle: string;
+    /** Draw the hover tooltip (and put {@link LINK_TOOLTIP_HOST_CLASS} on the box). */
+    showLinkTooltip: boolean;
+    /** Destination line: screen tip, else URL, else the `ppaction://` verb. */
+    linkTooltipLabel: string;
+    /** Hint line, already resolved to the URL / navigation wording. */
+    linkTooltipHint: string;
+}
+/**
+ * Decide which action affordances an element gets, and with what text.
+ *
+ * Kept a single call returning both affordances (rather than two predicates)
+ * because they share the same gate and the same fallback chain, and the one
+ * time they were derived separately per binding they immediately diverged.
+ */
+export declare function resolveElementActionAffordance(element: PptxElement, context: ActionAffordanceContext): ElementActionAffordance;
+//# sourceMappingURL=element-action-affordance.d.ts.map

package/dist/pptx/render/element-action-affordance.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"element-action-affordance.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/element-action-affordance.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAEnD,4EAA4E;AAC5E,eAAO,MAAM,uBAAuB,mBAAmB,CAAC;AAExD,oDAAoD;AACpD,eAAO,MAAM,kBAAkB,sBAAsB,CAAC;AAEtD,6CAA6C;AAC7C,eAAO,MAAM,wBAAwB,4BAA4B,CAAC;AAElE,+CAA+C;AAC/C,eAAO,MAAM,wBAAwB,4BAA4B,CAAC;AAElE,6DAA6D;AAC7D,eAAO,MAAM,uBAAuB,2BAA2B,CAAC;AAEhE,uCAAuC;AACvC,eAAO,MAAM,sBAAsB,0BAA0B,CAAC;AAE9D;;;;;GAKG;AACH,eAAO,MAAM,0BAA0B,oCAAoC,CAAC;AAE5E;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,qBAAqB,62DAuEjC,CAAC;AAKF;;;;;;GAMG;AACH,wBAAgB,4BAA4B,CAAC,GAAG,CAAC,EAAE,QAAQ,GAAG,IAAI,CASjE;AAED,gFAAgF;AAChF,MAAM,WAAW,sBAAsB;IACtC,2EAA2E;IAC3E,SAAS,EAAE,MAAM,CAAC;IAClB,mEAAmE;IACnE,IAAI,EAAE,MAAM,CAAC;IACb,yEAAyE;IACzE,UAAU,EAAE,MAAM,CAAC;IACnB,yEAAyE;IACzE,gBAAgB,EAAE,MAAM,CAAC;CACzB;AAED;;;;;;GAMG;AACH,wBAAgB,sBAAsB,CAAC,SAAS,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,MAAM,GAAG,sBAAsB,CAOjG;AAED,iDAAiD;AACjD,MAAM,WAAW,uBAAuB;IACvC;;;OAGG;IACH,WAAW,EAAE,OAAO,CAAC;IACrB,6EAA6E;IAC7E,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,MAAM,EAAE,sBAAsB,CAAC;CAC/B;AAED,oDAAoD;AACpD,MAAM,WAAW,uBAAuB;IACvC,4BAA4B;IAC5B,aAAa,EAAE,OAAO,CAAC;IACvB,4EAA4E;IAC5E,cAAc,EAAE,MAAM,CAAC;IACvB,mFAAmF;IACnF,eAAe,EAAE,OAAO,CAAC;IACzB,2EAA2E;IAC3E,gBAAgB,EAAE,MAAM,CAAC;IACzB,mEAAmE;IACnE,eAAe,EAAE,MAAM,CAAC;CACxB;AAWD;;;;;;GAMG;AACH,wBAAgB,8BAA8B,CAC7C,OAAO,EAAE,WAAW,EACpB,OAAO,EAAE,uBAAuB,GAC9B,uBAAuB,CAiBzB"}

package/dist/pptx/render/element-action-options.d.ts

@@ -0,0 +1,73 @@
+/**
+ * `element-action-options` - the option catalogue for an element's "Action
+ * Settings" inspector panel (PowerPoint's Insert > Action dialog).
+ *
+ * WHY shared: the mapping from `ElementActionType` to a translation key is
+ * plain data that every binding's action panel needs verbatim, and the three
+ * types that take an extra input before they can commit (`url`, `slide`,
+ * `customShow`) are a rule, not a rendering decision. Keeping the list here
+ * means adding a new action kind updates all five bindings at once instead of
+ * five hand-typed copies drifting apart.
+ *
+ * @module render/element-action-options
+ */
+import type { ElementActionType } from 'ooxml-core/pptx';
+/** One entry of the action-type select, with its dictionary key. */
+export interface ElementActionOption {
+    value: ElementActionType;
+    labelKey: string;
+}
+/** Action kinds selectable for an element's click / hover trigger. */
+export declare const ELEMENT_ACTION_TYPE_OPTIONS: readonly ElementActionOption[];
+/**
+ * Action kinds that stay unusable until the user supplies a target.
+ *
+ * WHY this is a shared rule rather than a per-binding `if`: `url` and `slide`
+ * serialise to an OOXML action that parses straight back as `none` while their
+ * target is missing, so the panel that just wrote one would immediately read it
+ * back as "no action". `customShow` does not have that particular failure mode
+ * (`ppaction://customshow?id=` with an empty id still parses back as
+ * `customShow`, just target-less), but committing it with no id would still
+ * write a custom-show action that names no show, so it is held back the same
+ * way. Every binding needs the same test to know when a picked type may be
+ * committed and when it must only be held in the panel.
+ */
+export declare function actionTypeNeedsTarget(type: ElementActionType): boolean;
+/**
+ * The action type an Action Settings trigger should show right now.
+ *
+ * WHY: a panel that derives its select purely from the committed element
+ * round-trips a freshly picked "Go to URL" back to "None" (see
+ * {@link actionTypeNeedsTarget}), so the input the user still has to fill in
+ * never appears and those two action kinds are unreachable. The locally picked
+ * ("pending") type therefore wins until the element really carries an action.
+ *
+ * @param pendingType - The type the user just picked, if any.
+ * @param committedType - The type read back off the element.
+ */
+export declare function resolveActionType(pendingType: ElementActionType | undefined, committedType: ElementActionType | undefined): ElementActionType;
+/**
+ * Whether a picked action type can be written to the element yet.
+ *
+ * Target-free kinds (navigation verbs, `none`) commit on the spot; `url`,
+ * `slide` and `customShow` wait for their target (see
+ * {@link actionTypeNeedsTarget}).
+ *
+ * @param target - The target values the panel currently holds.
+ */
+export declare function canCommitActionType(type: ElementActionType, target: {
+    url?: string;
+    slideIndex?: number;
+    customShowId?: string;
+}): boolean;
+/**
+ * Clamp a user-entered, 1-based slide number to a valid 0-based slide index.
+ *
+ * The inspector shows slide numbers the way the audience sees them (1-based),
+ * while `ElementAction.slideIndex` is 0-based; doing the conversion here keeps
+ * the off-by-one out of every binding's template.
+ *
+ * @returns The 0-based index, or `undefined` when the input is not a number.
+ */
+export declare function toSlideIndex(oneBased: number, slideCount: number): number | undefined;
+//# sourceMappingURL=element-action-options.d.ts.map

package/dist/pptx/render/element-action-options.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"element-action-options.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/element-action-options.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AAEzD,oEAAoE;AACpE,MAAM,WAAW,mBAAmB;IACnC,KAAK,EAAE,iBAAiB,CAAC;IACzB,QAAQ,EAAE,MAAM,CAAC;CACjB;AAED,sEAAsE;AACtE,eAAO,MAAM,2BAA2B,EAAE,SAAS,mBAAmB,EAgBrE,CAAC;AAEF;;;;;;;;;;;;GAYG;AACH,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,iBAAiB,GAAG,OAAO,CAEtE;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,iBAAiB,CAChC,WAAW,EAAE,iBAAiB,GAAG,SAAS,EAC1C,aAAa,EAAE,iBAAiB,GAAG,SAAS,GAC1C,iBAAiB,CAEnB;AAED;;;;;;;;GAQG;AACH,wBAAgB,mBAAmB,CAClC,IAAI,EAAE,iBAAiB,EACvB,MAAM,EAAE;IAAE,GAAG,CAAC,EAAE,MAAM,CAAC;IAAC,UAAU,CAAC,EAAE,MAAM,CAAC;IAAC,YAAY,CAAC,EAAE,MAAM,CAAA;CAAE,GAClE,OAAO,CAWT;AAED;;;;;;;;GAQG;AACH,wBAAgB,YAAY,CAAC,QAAQ,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAMrF"}

package/dist/pptx/render/element-actionability.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Is a rendered slide element *actionable*: does activating it do something?
+ *
+ * PowerPoint lets a shape carry a click action (`a:hlinkClick` on `p:cNvPr`,
+ * including the `ppaction://` verbs), a hover action (`a:hlinkHover`), a
+ * run-level text hyperlink, or be a slide/section zoom tile. Such an element is
+ * a control, not a graphic, so the viewer must expose it to assistive
+ * technology as `role="button"` rather than as the `img` / `group` its element
+ * type would otherwise get.
+ *
+ * The rule lives here, in shared, because all five bindings have to agree on it
+ * by construction: React derived it inside its own `ElementRenderer` while the
+ * other four never derived it at all, so the same deck advertised 37 buttons in
+ * React and none anywhere else.
+ *
+ * @module render/element-actionability
+ */
+import type { PptxElement } from 'ooxml-core/pptx';
+/**
+ * Whether the element actually carries a run-level text hyperlink
+ * (`a:hlinkClick` on any text run).
+ *
+ * This must reflect the ELEMENT's data, not the presence of a hyperlink
+ * handler: the handler is always supplied by the canvas, so keying off it alone
+ * would make every element (including inert layout/master template shapes)
+ * report as actionable and defeat the `editTemplateMode` interaction gate.
+ */
+export declare function elementHasTextHyperlink(element: PptxElement): boolean;
+/**
+ * Which of the host canvas's activation handlers are wired up.
+ *
+ * A binding that cannot follow an action should not advertise the element as a
+ * button. Every flag defaults to `true` so a caller with no handler plumbing of
+ * its own (for example the post-render DOM pass the non-React bindings use)
+ * classifies purely from the element's own data.
+ */
+export interface ElementActionabilityOptions {
+    /** The canvas can follow a shape-level click action (`actionClick`). */
+    hasActionHandler?: boolean;
+    /** The canvas can follow a run-level text hyperlink. */
+    hasHyperlinkHandler?: boolean;
+    /** The canvas can follow a slide/section zoom tile. */
+    hasZoomHandler?: boolean;
+}
+/**
+ * True when activating this element navigates, plays, or otherwise acts.
+ *
+ * Hover actions need no handler flag: PowerPoint fires them from the element's
+ * own data, so an element carrying one is actionable in every binding.
+ */
+export declare function isElementActionable(element: PptxElement, options?: ElementActionabilityOptions): boolean;
+//# sourceMappingURL=element-actionability.d.ts.map

package/dist/pptx/render/element-actionability.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"element-actionability.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/element-actionability.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAKnD;;;;;;;;GAQG;AACH,wBAAgB,uBAAuB,CAAC,OAAO,EAAE,WAAW,GAAG,OAAO,CAKrE;AAED;;;;;;;GAOG;AACH,MAAM,WAAW,2BAA2B;IAC3C,wEAAwE;IACxE,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B,wDAAwD;IACxD,mBAAmB,CAAC,EAAE,OAAO,CAAC;IAC9B,uDAAuD;IACvD,cAAc,CAAC,EAAE,OAAO,CAAC;CACzB;AAED;;;;;GAKG;AACH,wBAAgB,mBAAmB,CAClC,OAAO,EAAE,WAAW,EACpB,OAAO,GAAE,2BAAgC,GACvC,OAAO,CAgBT"}

package/dist/pptx/render/element-align.d.ts

@@ -0,0 +1,4 @@
+/** Compatibility entry: the implementation lives in ooxml-core/geometry (`align-distribute.ts`). */
+export { usesSlideReference, resolveAlignReferenceBox, alignElements, distributeElements, computeAlign, computeDistribute, } from 'ooxml-core/geometry';
+export type { AlignEdge, DistributeAxis, AlignReference, AlignSlideSize, AlignOptions, ElementPosition, BoundingBoxElement, AlignReferenceBox, AlignMode, DistributeMode, AlignBox, PositionUpdate, } from 'ooxml-core/geometry';
+//# sourceMappingURL=element-align.d.ts.map

package/dist/pptx/render/element-align.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"element-align.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/element-align.ts"],"names":[],"mappings":"AAAA,oGAAoG;AACpG,OAAO,EACN,kBAAkB,EAClB,wBAAwB,EACxB,aAAa,EACb,kBAAkB,EAClB,YAAY,EACZ,iBAAiB,GACjB,MAAM,qBAAqB,CAAC;AAC7B,YAAY,EACX,SAAS,EACT,cAAc,EACd,cAAc,EACd,cAAc,EACd,YAAY,EACZ,eAAe,EACf,kBAAkB,EAClB,iBAAiB,EACjB,SAAS,EACT,cAAc,EACd,QAAQ,EACR,cAAc,GACd,MAAM,qBAAqB,CAAC"}

package/dist/pptx/render/element-aria-attributes.d.ts

@@ -0,0 +1,36 @@
+import type { PptxElement } from 'ooxml-core/pptx';
+import type { ElementActionabilityOptions } from './element-actionability.js';
+/**
+ * The accessibility attributes one rendered element wrapper carries.
+ *
+ * A pure descriptor: `applyRenderedElementAccessibility` stamps it onto the DOM
+ * for the four bindings that render first and annotate afterwards, and React
+ * maps it straight onto its wrapper's props. Both paths therefore agree on the
+ * one rule that used to drift (a decorative picture is `aria-hidden` in four
+ * bindings and announced in the fifth).
+ */
+export interface ElementAriaAttributes {
+    /** Click/hover action, text hyperlink or zoom tile: announced as a control. */
+    readonly actionable: boolean;
+    /** `role`, or undefined when the element should carry none. */
+    readonly role: string | undefined;
+    /** `aria-label`; empty for a decorative element that is not actionable. */
+    readonly label: string;
+    /** `aria-roledescription`, or undefined when there is nothing to add. */
+    readonly roleDescription: string | undefined;
+    /**
+     * "Mark as decorative" (issue G16): skip the element entirely for
+     * assistive tech, matching PowerPoint's own behaviour. Actionable wins
+     * (PowerPoint disables the decorative flag once an action is attached), so
+     * a decorative-but-clickable shape stays announced.
+     */
+    readonly hidden: boolean;
+}
+/**
+ * Resolve the ARIA attributes a rendered element wrapper must carry.
+ *
+ * @param options - Which action handlers the host wired up; an action with no
+ *   handler is not actionable (see {@link isElementActionable}).
+ */
+export declare function resolveElementAriaAttributes(element: PptxElement, options?: ElementActionabilityOptions): ElementAriaAttributes;
+//# sourceMappingURL=element-aria-attributes.d.ts.map

package/dist/pptx/render/element-aria-attributes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"element-aria-attributes.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/element-aria-attributes.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAQnD,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,yBAAyB,CAAC;AAG3E;;;;;;;;GAQG;AACH,MAAM,WAAW,qBAAqB;IACrC,+EAA+E;IAC/E,QAAQ,CAAC,UAAU,EAAE,OAAO,CAAC;IAC7B,+DAA+D;IAC/D,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,CAAC;IAClC,2EAA2E;IAC3E,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,yEAAyE;IACzE,QAAQ,CAAC,eAAe,EAAE,MAAM,GAAG,SAAS,CAAC;IAC7C;;;;;OAKG;IACH,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC;CACzB;AAED;;;;;GAKG;AACH,wBAAgB,4BAA4B,CAC3C,OAAO,EAAE,WAAW,EACpB,OAAO,CAAC,EAAE,2BAA2B,GACnC,qBAAqB,CASvB"}

package/dist/pptx/render/element-clipboard.d.ts

@@ -0,0 +1,118 @@
+/**
+ * element-clipboard.ts: framework-agnostic cut/copy/paste codec for slide
+ * elements.
+ *
+ * Two layers, shared by every binding's clipboard handlers:
+ *
+ * 1. In-memory payload: {@link buildElementClipboardPayload} deep-clones the
+ *    copied element (so later edits never mutate the clipboard) and
+ *    {@link cloneElementForPaste} produces the pasted clone with a fresh id
+ *    (template-prefix aware, see {@link makeCloneId}) and the standard
+ *    {@link PASTE_OFFSET_PX} cascade offset.
+ * 2. String codec: {@link serializeElementClipboard} /
+ *    {@link deserializeElementClipboard} convert elements to/from a marked,
+ *    versioned JSON string so bindings can round-trip elements through the
+ *    system clipboard (or postMessage). Binary fields (e.g. an embedded chart
+ *    workbook `Uint8Array`) are base64-tagged so they survive the round trip;
+ *    unknown or foreign clipboard text is rejected with `null`.
+ *
+ * @module render/element-clipboard
+ */
+import type { PptxElement } from 'ooxml-core/pptx';
+import { makeStoreAwareId, reassignDescendantIds } from 'ooxml-core/pptx';
+/** MIME type bindings should use when writing the payload as a custom clipboard format. */
+export declare const ELEMENT_CLIPBOARD_MIME_TYPE = "application/x-pptx-viewer-elements+json";
+/** Marker identifying a serialized element-clipboard payload. */
+export declare const ELEMENT_CLIPBOARD_MARKER = "pptx-viewer/elements";
+/** Current codec version; {@link deserializeElementClipboard} rejects others. */
+export declare const ELEMENT_CLIPBOARD_VERSION = 1;
+/** Standard paste/duplicate cascade offset in px (applied to both axes). */
+export declare const PASTE_OFFSET_PX = 20;
+/** In-memory clipboard payload stored when an element is copied or cut. */
+export interface ElementClipboardPayload {
+    element: PptxElement;
+    isTemplate: boolean;
+}
+/** Decoded multi-element clipboard data produced by the string codec. */
+export interface ElementClipboardData {
+    elements: PptxElement[];
+    isTemplate: boolean;
+}
+/** Options for {@link cloneElementForPaste} / {@link prepareElementsForPaste}. */
+export interface PasteCloneOptions {
+    /**
+     * Whether the clone is inserted into the template (master/layout) store, so
+     * its fresh id must keep a template prefix (see {@link makeCloneId}).
+     */
+    intoTemplate?: boolean;
+    /** Horizontal paste offset in px (default {@link PASTE_OFFSET_PX}). */
+    offsetX?: number;
+    /** Vertical paste offset in px (default {@link PASTE_OFFSET_PX}). */
+    offsetY?: number;
+}
+/** Generate a unique element id (`el-<timestamp>-<random>`). */
+export declare function generateElementId(): string;
+/**
+ * Build the id for a pasted / duplicated clone so that it routes to the same
+ * store it is inserted into.
+ *
+ * In edit-template mode the clone lands in the template store, so it must keep
+ * a template (`master-` / `layout-`) prefix; otherwise later edits (which route
+ * by id prefix) would target the wrong store and be lost. Outside template mode
+ * a normal id is generated.
+ *
+ * This is core's `makeStoreAwareId` under the name the bindings already import.
+ * The clipboard used to carry its own copy of the rule, so a paste and an
+ * ungroup could drift apart in how they mint ids; both now mint the same way.
+ */
+export declare const makeCloneId: typeof makeStoreAwareId;
+/**
+ * Re-id the DESCENDANTS of an already-cloned element, in place. Re-exported
+ * from core (`utils/group-ops`), which owns the canonical implementation that
+ * paste, duplicate and ungroup all share.
+ *
+ * Only the root of a pasted or promoted subtree used to be re-ided, which was
+ * invisible while a group could hold nothing but leaves and is not once a group
+ * can hold a group. Two things go wrong when the inside of a subtree keeps its
+ * original ids:
+ *
+ * - **Paste duplicates them.** Element ids are written back out as
+ *   `p:cNvPr/@id`, and an animation's `p:spTgt/@spid` then names two shapes at
+ *   once, so the deck animates the wrong one. Selection, hit testing and
+ *   collaboration reconcile are keyed by element id as well.
+ * - **Ungroup strands them in the wrong store.** Edits route by id prefix
+ *   (`master-` / `layout-` = the template store), so a promoted nested group
+ *   whose descendants kept plain ids has its inside silently edited into the
+ *   slide store and lost on save.
+ */
+export { reassignDescendantIds };
+/**
+ * Snapshot a copied/cut element into the in-memory clipboard payload.
+ * Deep-clones so later canvas edits never mutate the clipboard content.
+ */
+export declare function buildElementClipboardPayload(element: PptxElement, isTemplate: boolean): ElementClipboardPayload;
+/**
+ * Produce the clone inserted by paste/duplicate: a deep copy with a fresh
+ * (template-prefix aware) id and the standard cascade offset applied.
+ *
+ * Every element INSIDE a pasted group is re-ided too (see
+ * {@link reassignDescendantIds}); only the root used to be, which put a
+ * duplicate of every grouped shape's id on the slide.
+ */
+export declare function cloneElementForPaste(element: PptxElement, options?: PasteCloneOptions): PptxElement;
+/** Clone every element in decoded clipboard data for insertion (fresh ids + offset). */
+export declare function prepareElementsForPaste(data: ElementClipboardData, options?: PasteCloneOptions): PptxElement[];
+/**
+ * Serialize elements to the marked, versioned JSON clipboard string.
+ * `Uint8Array` fields anywhere in the element tree (embedded workbooks, raw
+ * part bytes) are base64-tagged so they survive the text round trip.
+ */
+export declare function serializeElementClipboard(elements: PptxElement[], isTemplate?: boolean): string;
+/**
+ * Decode a clipboard string produced by {@link serializeElementClipboard}.
+ * Returns `null` for anything else (foreign clipboard text, malformed JSON,
+ * wrong marker/version, or structurally invalid elements), so callers can fall
+ * back to their plain-text paste path.
+ */
+export declare function deserializeElementClipboard(text: string): ElementClipboardData | null;
+//# sourceMappingURL=element-clipboard.d.ts.map

package/dist/pptx/render/element-clipboard.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"element-clipboard.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/element-clipboard.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AACnD,OAAO,EAAkB,gBAAgB,EAAE,qBAAqB,EAAE,MAAM,iBAAiB,CAAC;AAE1F,2FAA2F;AAC3F,eAAO,MAAM,2BAA2B,4CAA4C,CAAC;AAErF,iEAAiE;AACjE,eAAO,MAAM,wBAAwB,yBAAyB,CAAC;AAE/D,iFAAiF;AACjF,eAAO,MAAM,yBAAyB,IAAI,CAAC;AAE3C,4EAA4E;AAC5E,eAAO,MAAM,eAAe,KAAK,CAAC;AAElC,2EAA2E;AAC3E,MAAM,WAAW,uBAAuB;IACvC,OAAO,EAAE,WAAW,CAAC;IACrB,UAAU,EAAE,OAAO,CAAC;CACpB;AAED,yEAAyE;AACzE,MAAM,WAAW,oBAAoB;IACpC,QAAQ,EAAE,WAAW,EAAE,CAAC;IACxB,UAAU,EAAE,OAAO,CAAC;CACpB;AAED,kFAAkF;AAClF,MAAM,WAAW,iBAAiB;IACjC;;;OAGG;IACH,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,uEAAuE;IACvE,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,qEAAqE;IACrE,OAAO,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,gEAAgE;AAChE,wBAAgB,iBAAiB,IAAI,MAAM,CAE1C;AAED;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,WAAW,yBAAmB,CAAC;AAE5C;;;;;;;;;;;;;;;;;;GAkBG;AACH,OAAO,EAAE,qBAAqB,EAAE,CAAC;AAEjC;;;GAGG;AACH,wBAAgB,4BAA4B,CAC3C,OAAO,EAAE,WAAW,EACpB,UAAU,EAAE,OAAO,GACjB,uBAAuB,CAEzB;AAED;;;;;;;GAOG;AACH,wBAAgB,oBAAoB,CACnC,OAAO,EAAE,WAAW,EACpB,OAAO,GAAE,iBAAsB,GAC7B,WAAW,CAwCb;AAED,wFAAwF;AACxF,wBAAgB,uBAAuB,CACtC,IAAI,EAAE,oBAAoB,EAC1B,OAAO,GAAE,iBAAsB,GAC7B,WAAW,EAAE,CAEf;AAsBD;;;;GAIG;AACH,wBAAgB,yBAAyB,CACxC,QAAQ,EAAE,WAAW,EAAE,EACvB,UAAU,GAAE,OAAe,GACzB,MAAM,CAeR;AAiBD;;;;;GAKG;AACH,wBAAgB,2BAA2B,CAAC,IAAI,EAAE,MAAM,GAAG,oBAAoB,GAAG,IAAI,CAgCrF"}

package/dist/pptx/render/element-decorative.d.ts

@@ -0,0 +1,20 @@
+/**
+ * element-decorative.ts - PowerPoint's "Mark as decorative" flag (issue G16).
+ *
+ * Extracted from `accessibility.ts` (already over this repo's 300-line file
+ * budget) so this addition doesn't grow that file further.
+ */
+import type { PptxElement } from 'ooxml-core/pptx';
+/**
+ * Whether an element carries PowerPoint's "Mark as decorative" flag
+ * (`p:cNvPr/a:extLst`'s `adec:decorative` vendor extension).
+ *
+ * A decorative element should be skipped entirely by assistive technology
+ * (empty accessible name, no semantic role, `aria-hidden`), the same way
+ * PowerPoint's own screen-reader and exporter behaviour treats it. An
+ * actionable element (a click/hover action attached) still wins: PowerPoint's
+ * own Alt Text pane disables "Mark as decorative" once an action is
+ * attached, since a clickable object cannot be purely decorative.
+ */
+export declare function isElementMarkedDecorative(element: PptxElement): boolean;
+//# sourceMappingURL=element-decorative.d.ts.map

package/dist/pptx/render/element-decorative.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"element-decorative.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/element-decorative.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAEnD;;;;;;;;;;GAUG;AACH,wBAAgB,yBAAyB,CAAC,OAAO,EAAE,WAAW,GAAG,OAAO,CAEvE"}

package/dist/pptx/render/element-height-observer.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Live height of a DOM element, for layout that has to clear a strip whose
+ * height is not a constant (the docked "Speaker notes" bar is a different
+ * height in every binding and grows when its pane expands).
+ *
+ * Framework-neutral on purpose: every binding wraps this in its own reactive
+ * primitive (a React state setter, a Vue ref, an Angular signal, a Svelte
+ * rune, a plain callback in vanilla) instead of re-implementing the observer,
+ * so the measurement rules cannot drift between them.
+ */
+/**
+ * Report `el`'s rendered height in CSS px now and again on every resize.
+ *
+ * A `display: none` element reports `0`, which is exactly what a consumer
+ * clearing the element wants (nothing to clear). Returns a disposer; it does
+ * NOT report `0` on dispose, so a caller whose element is going away resets
+ * its own state (it usually does that in the same cleanup).
+ *
+ * Falls back to a single initial measurement where `ResizeObserver` does not
+ * exist (SSR, very old browsers, some test DOMs).
+ */
+export declare function observeElementHeight(el: Element, onHeight: (height: number) => void): () => void;
+//# sourceMappingURL=element-height-observer.d.ts.map

package/dist/pptx/render/element-height-observer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"element-height-observer.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/element-height-observer.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH;;;;;;;;;;GAUG;AACH,wBAAgB,oBAAoB,CAAC,EAAE,EAAE,OAAO,EAAE,QAAQ,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,IAAI,GAAG,MAAM,IAAI,CAgBhG"}

package/dist/pptx/render/element-highlight-click.d.ts

@@ -0,0 +1,92 @@
+/**
+ * `@highlightClick` (`a:hlinkClick`/`a:hlinkHover`'s "Highlight click" flag in
+ * PowerPoint's Action Settings dialog): a brief brightness+outline flash on
+ * the shape, independent of whatever navigation the action performs.
+ *
+ * Before this module the flash existed only in React
+ * (`element-interaction-props.ts`), hand-rolled inline; Vue, Angular, Svelte
+ * and Vanilla parsed and round-tripped the flag but never rendered it. This is
+ * the single decision (which two inline style properties, what values, for
+ * how long) every binding's click/hover handler now maps onto its own DOM
+ * write.
+ *
+ * @module render/element-highlight-click
+ */
+import type { PptxAction, PptxSlide } from 'ooxml-core/pptx';
+/** The two inline style properties the flash toggles. */
+export interface HighlightClickStyle {
+    filter: string;
+    outline: string;
+}
+/** How long a click flash holds before it auto-clears (React's original value). */
+export declare const HIGHLIGHT_CLICK_FLASH_DURATION_MS = 320;
+/** Style applied for the ~320ms click flash. */
+export declare const HIGHLIGHT_CLICK_STYLE: HighlightClickStyle;
+/** Style applied for the duration of a hover (cleared on pointer-leave). */
+export declare const HIGHLIGHT_HOVER_STYLE: HighlightClickStyle;
+/** The style that clears either flash: empty values reset to the CSS default. */
+export declare const HIGHLIGHT_CLEAR_STYLE: HighlightClickStyle;
+/** What a binding should do on click, or `null` when the action doesn't ask for a flash. */
+export interface HighlightClickAction {
+    style: HighlightClickStyle;
+    clearStyle: HighlightClickStyle;
+    durationMs: number;
+}
+/** What a binding should do on hover enter/leave, or `null` when hover doesn't ask for a flash. */
+export interface HighlightHoverAction {
+    enterStyle: HighlightClickStyle;
+    leaveStyle: HighlightClickStyle;
+}
+/** The full highlight-click descriptor for one element's click + hover actions. */
+export interface ElementHighlightClickDescriptor {
+    click: HighlightClickAction | null;
+    hover: HighlightHoverAction | null;
+}
+/**
+ * Decide the highlight-click flash for an element carrying `actionClick`
+ * and/or `actionHover`.
+ *
+ * Only the `highlightClick` flag is read from each action (not the whole
+ * `PptxAction`, so a caller resolving hover/click from a differently-shaped
+ * lookup - e.g. Vue/Angular/Svelte/Vanilla's delegated stage click, which
+ * finds the element by id first - can pass just the two flags it already has).
+ */
+export declare function resolveElementHighlightClick(actionClick: Pick<PptxAction, 'highlightClick'> | undefined, actionHover: Pick<PptxAction, 'highlightClick'> | undefined): ElementHighlightClickDescriptor;
+/** Write `style`'s `filter`/`outline` onto `el`'s inline style. */
+export declare function applyHighlightClickStyle(el: HTMLElement, style: HighlightClickStyle): void;
+/**
+ * The highlight-click descriptor for whichever element on `slide` carries
+ * `elementId`, group children included.
+ *
+ * The four bindings that resolve a presentation click through a single
+ * delegated stage listener (Vue, Angular, Svelte, Vanilla; see
+ * `presentation-action.ts`'s `findPresentationActionTarget`) only ever learn
+ * an element's id from that lookup, not the element object itself, so this is
+ * the one extra step they need to reuse {@link resolveElementHighlightClick}
+ * instead of re-deriving it. React already has the element object at its
+ * per-element handler and can call {@link resolveElementHighlightClick}
+ * directly.
+ */
+export declare function resolveHighlightClickForElementId(slide: PptxSlide | undefined, elementId: string | undefined): ElementHighlightClickDescriptor;
+/** The DOM node to flash, and what to flash it with. */
+export interface HighlightClickTarget {
+    element: HTMLElement;
+    descriptor: ElementHighlightClickDescriptor;
+}
+/**
+ * Walk up from a click/hover DOM target to the nearest ancestor whose slide
+ * data carries a highlightClick-triggering action (click OR hover), and
+ * resolve what to flash it with.
+ *
+ * Mirrors `presentation-action.ts`'s `findPresentationActionTarget` walk (the
+ * same `data-element-id` ancestor-scan every binding's stage already stamps),
+ * but checks BOTH `actionClick` and `actionHover` rather than click alone,
+ * since a hover-only flash (`a:hlinkHover/@highlightClick` with no
+ * `a:hlinkClick` at all) is legal and must still be found on `mouseenter`.
+ * This is the single primitive Vue/Angular/Svelte/Vanilla's delegated
+ * stage-level click and hover listeners both call; React already owns its
+ * DOM node directly at its per-element handler and calls
+ * {@link resolveElementHighlightClick} there instead.
+ */
+export declare function findHighlightClickTarget(target: unknown, slide: PptxSlide | undefined): HighlightClickTarget | undefined;
+//# sourceMappingURL=element-highlight-click.d.ts.map

package/dist/pptx/render/element-highlight-click.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"element-highlight-click.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/element-highlight-click.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AACH,OAAO,KAAK,EAAE,UAAU,EAAe,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAI1E,yDAAyD;AACzD,MAAM,WAAW,mBAAmB;IACnC,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;CAChB;AAED,mFAAmF;AACnF,eAAO,MAAM,iCAAiC,MAAM,CAAC;AAErD,gDAAgD;AAChD,eAAO,MAAM,qBAAqB,EAAE,mBAGnC,CAAC;AAEF,4EAA4E;AAC5E,eAAO,MAAM,qBAAqB,EAAE,mBAGnC,CAAC;AAEF,iFAAiF;AACjF,eAAO,MAAM,qBAAqB,EAAE,mBAAiD,CAAC;AAEtF,4FAA4F;AAC5F,MAAM,WAAW,oBAAoB;IACpC,KAAK,EAAE,mBAAmB,CAAC;IAC3B,UAAU,EAAE,mBAAmB,CAAC;IAChC,UAAU,EAAE,MAAM,CAAC;CACnB;AAED,mGAAmG;AACnG,MAAM,WAAW,oBAAoB;IACpC,UAAU,EAAE,mBAAmB,CAAC;IAChC,UAAU,EAAE,mBAAmB,CAAC;CAChC;AAED,mFAAmF;AACnF,MAAM,WAAW,+BAA+B;IAC/C,KAAK,EAAE,oBAAoB,GAAG,IAAI,CAAC;IACnC,KAAK,EAAE,oBAAoB,GAAG,IAAI,CAAC;CACnC;AAKD;;;;;;;;GAQG;AACH,wBAAgB,4BAA4B,CAC3C,WAAW,EAAE,IAAI,CAAC,UAAU,EAAE,gBAAgB,CAAC,GAAG,SAAS,EAC3D,WAAW,EAAE,IAAI,CAAC,UAAU,EAAE,gBAAgB,CAAC,GAAG,SAAS,GACzD,+BAA+B,CAgBjC;AAED,mEAAmE;AACnE,wBAAgB,wBAAwB,CAAC,EAAE,EAAE,WAAW,EAAE,KAAK,EAAE,mBAAmB,GAAG,IAAI,CAG1F;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,iCAAiC,CAChD,KAAK,EAAE,SAAS,GAAG,SAAS,EAC5B,SAAS,EAAE,MAAM,GAAG,SAAS,GAC3B,+BAA+B,CAMjC;AAED,wDAAwD;AACxD,MAAM,WAAW,oBAAoB;IACpC,OAAO,EAAE,WAAW,CAAC;IACrB,UAAU,EAAE,+BAA+B,CAAC;CAC5C;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,wBAAwB,CACvC,MAAM,EAAE,OAAO,EACf,KAAK,EAAE,SAAS,GAAG,SAAS,GAC1B,oBAAoB,GAAG,SAAS,CAuBlC"}

package/dist/pptx/render/element-hit-test.cjs

@@ -0,0 +1,30 @@
+'use strict';
+
+var chunkP27CIE4O_cjs = require('../chunk-P27CIE4O.cjs');
+
+
+
+Object.defineProperty(exports, "ELEMENT_ID_SELECTOR", {
+  enumerable: true,
+  get: function () { return chunkP27CIE4O_cjs.ELEMENT_ID_SELECTOR; }
+});
+Object.defineProperty(exports, "SELECTION_OVERLAY_SELECTOR", {
+  enumerable: true,
+  get: function () { return chunkP27CIE4O_cjs.SELECTION_OVERLAY_SELECTOR; }
+});
+Object.defineProperty(exports, "resolveEditTargetElementId", {
+  enumerable: true,
+  get: function () { return chunkP27CIE4O_cjs.resolveEditTargetElementId; }
+});
+Object.defineProperty(exports, "resolveElementIdChain", {
+  enumerable: true,
+  get: function () { return chunkP27CIE4O_cjs.resolveElementIdChain; }
+});
+Object.defineProperty(exports, "resolveHitElementId", {
+  enumerable: true,
+  get: function () { return chunkP27CIE4O_cjs.resolveHitElementId; }
+});
+Object.defineProperty(exports, "resolveTopLevelElementId", {
+  enumerable: true,
+  get: function () { return chunkP27CIE4O_cjs.resolveTopLevelElementId; }
+});