ooxml-ui 0.30.1 → 1.0.0

package/dist/pptx/render/edit-points/edit-points-frame.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Mapping between an element's local pixel frame and slide space.
+ *
+ * Every binding paints an element as a box at `(x, y, width, height)` with
+ * `transform: rotate(θ) scaleX(±1) scaleY(±1)` about its centre (OOXML flips
+ * first, then rotates; see `element-style-transform.ts`). A local point `p`
+ * therefore lands on the slide at `C + R·F·(p - c)`, where `C` is the box
+ * centre on the slide, `c` the centre in local coordinates, `R` the rotation
+ * and `F` the flip. The Edit Points overlay is drawn in plain slide space, so
+ * it needs this in both directions: forward to place a handle, inverse to turn
+ * a pointer position back into a local vertex position.
+ *
+ * @module render/edit-points/edit-points-frame
+ */
+import type { PptxElement } from 'ooxml-core/pptx';
+import type { EditFrame, EditPoint } from './edit-points-types.js';
+/** The frame `element` is painted in right now. */
+export declare function editFrameFromElement(element: PptxElement): EditFrame;
+/** Local frame point to slide space. */
+export declare function editLocalToSlide(frame: EditFrame, point: EditPoint): EditPoint;
+/** Slide space point to the local frame. */
+export declare function editSlideToLocal(frame: EditFrame, point: EditPoint): EditPoint;
+/**
+ * The slide-space box that keeps every local point where it is on screen once
+ * the element is re-anchored to the local bounds `[minX, maxX] x [minY, maxY]`.
+ *
+ * Re-anchoring moves the box centre from `c` to `c'` (the bounds' centre), so
+ * the new top-left must be shifted by `R·F·(c' - c)` for the rotated, flipped
+ * outline to stay put; without it a rotated shape would jump every time an
+ * edit grew or shrank its bounds.
+ */
+export declare function reanchorEditFrame(frame: EditFrame, bounds: {
+    minX: number;
+    minY: number;
+    maxX: number;
+    maxY: number;
+}): {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+};
+//# sourceMappingURL=edit-points-frame.d.ts.map

package/dist/pptx/render/edit-points/edit-points-frame.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"edit-points-frame.d.ts","sourceRoot":"","sources":["../../../../src/pptx/render/edit-points/edit-points-frame.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AACH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAEnD,OAAO,KAAK,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAC;AAEhE,mDAAmD;AACnD,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,WAAW,GAAG,SAAS,CAUpE;AAuBD,wCAAwC;AACxC,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,SAAS,EAAE,KAAK,EAAE,SAAS,GAAG,SAAS,CAK9E;AAED,4CAA4C;AAC5C,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,SAAS,EAAE,KAAK,EAAE,SAAS,GAAG,SAAS,CAK9E;AAED;;;;;;;;GAQG;AACH,wBAAgB,iBAAiB,CAChC,KAAK,EAAE,SAAS,EAChB,MAAM,EAAE;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GAChE;IAAE,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAWzD"}

package/dist/pptx/render/edit-points/edit-points-geometry-utils.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Small shared utilities for the Edit Points operations: cloning, addressing
+ * and the vector arithmetic every op repeats.
+ *
+ * @module render/edit-points/edit-points-geometry-utils
+ */
+import type { CubicBezier } from './edit-points-bezier.js';
+import type { EditGeometry, EditNodeRef, EditPoint, EditSegment, EditSegmentRef, EditSubpath } from './edit-points-types.js';
+export declare function cloneSegment(seg: EditSegment): EditSegment;
+export declare function cloneSubpath(sub: EditSubpath): EditSubpath;
+export declare function cloneGeometry(geometry: EditGeometry): EditGeometry;
+/** The index of the node a segment ends on. */
+export declare function segmentEndIndex(sub: EditSubpath, segment: number): number;
+/** Whether `ref` addresses a real node. */
+export declare function hasNode(geometry: EditGeometry, ref: EditNodeRef): boolean;
+/** Whether `ref` addresses a real segment. */
+export declare function hasSegment(geometry: EditGeometry, ref: EditSegmentRef): boolean;
+/** The segment as a cubic (a line becomes the equivalent straight cubic). */
+export declare function segmentAsCubic(sub: EditSubpath, segment: number): CubicBezier;
+export declare function thirdPoint(a: EditPoint, b: EditPoint, t: number): EditPoint;
+/** Turn a line segment into a (still straight-looking) curve in place. */
+export declare function ensureCurve(sub: EditSubpath, segment: number): void;
+/** The control handles either side of a node, when those segments are curves. */
+export declare function nodeHandles(sub: EditSubpath, node: number): {
+    inSeg?: number;
+    outSeg?: number;
+    inHandle?: EditPoint;
+    outHandle?: EditPoint;
+};
+/**
+ * Re-impose a smooth / straight node's constraint after one of its handles
+ * moved: the OTHER handle swings to stay collinear through the node, keeping
+ * its own length (straight) or matching the moved one (smooth).
+ */
+export declare function constrainOppositeHandle(sub: EditSubpath, node: number, moved: 'in' | 'out'): void;
+//# sourceMappingURL=edit-points-geometry-utils.d.ts.map

package/dist/pptx/render/edit-points/edit-points-geometry-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"edit-points-geometry-utils.d.ts","sourceRoot":"","sources":["../../../../src/pptx/render/edit-points/edit-points-geometry-utils.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AAExD,OAAO,KAAK,EACX,YAAY,EACZ,WAAW,EACX,SAAS,EACT,WAAW,EACX,cAAc,EACd,WAAW,EACX,MAAM,qBAAqB,CAAC;AAE7B,wBAAgB,YAAY,CAAC,GAAG,EAAE,WAAW,GAAG,WAAW,CAI1D;AAED,wBAAgB,YAAY,CAAC,GAAG,EAAE,WAAW,GAAG,WAAW,CAM1D;AAED,wBAAgB,aAAa,CAAC,QAAQ,EAAE,YAAY,GAAG,YAAY,CAKlE;AAED,+CAA+C;AAC/C,wBAAgB,eAAe,CAAC,GAAG,EAAE,WAAW,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,CAEzE;AAED,2CAA2C;AAC3C,wBAAgB,OAAO,CAAC,QAAQ,EAAE,YAAY,EAAE,GAAG,EAAE,WAAW,GAAG,OAAO,CAGzE;AAED,8CAA8C;AAC9C,wBAAgB,UAAU,CAAC,QAAQ,EAAE,YAAY,EAAE,GAAG,EAAE,cAAc,GAAG,OAAO,CAG/E;AAED,6EAA6E;AAC7E,wBAAgB,cAAc,CAAC,GAAG,EAAE,WAAW,EAAE,OAAO,EAAE,MAAM,GAAG,WAAW,CAQ7E;AAED,wBAAgB,UAAU,CAAC,CAAC,EAAE,SAAS,EAAE,CAAC,EAAE,SAAS,EAAE,CAAC,EAAE,MAAM,GAAG,SAAS,CAE3E;AAED,0EAA0E;AAC1E,wBAAgB,WAAW,CAAC,GAAG,EAAE,WAAW,EAAE,OAAO,EAAE,MAAM,GAAG,IAAI,CAOnE;AAED,iFAAiF;AACjF,wBAAgB,WAAW,CAC1B,GAAG,EAAE,WAAW,EAChB,IAAI,EAAE,MAAM,GACV;IAAE,KAAK,CAAC,EAAE,MAAM,CAAC;IAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,EAAE,SAAS,CAAC;IAAC,SAAS,CAAC,EAAE,SAAS,CAAA;CAAE,CAWlF;AAED;;;;GAIG;AACH,wBAAgB,uBAAuB,CAAC,GAAG,EAAE,WAAW,EAAE,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,IAAI,GAAG,KAAK,GAAG,IAAI,CAoBjG"}

package/dist/pptx/render/edit-points/edit-points-import.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Element to editable points: the "convert to freeform" step PowerPoint runs
+ * the moment Edit Points is chosen.
+ *
+ * Three sources, in priority order:
+ *
+ *  1. structured `a:custGeom` paths (`customGeometryPaths`), re-evaluated
+ *     against the current `shapeAdjustments` when raw guide XML survived parse;
+ *  2. a freeform's aggregate SVG `pathData` when no structured paths exist;
+ *  3. the preset geometry, evaluated by core's ECMA-376 engine
+ *     (`evaluatePresetShape`) at the element's current size and adjustments.
+ *
+ * Every source is mapped from its own coordinate space onto the element's
+ * local pixel box, so the model is always in `0..width x 0..height`.
+ *
+ * @module render/edit-points/edit-points-import
+ */
+import type { PptxElement } from 'ooxml-core/pptx';
+import type { EditGeometry } from './edit-points-types.js';
+/**
+ * Whether `element` is a shape Edit Points can work on at all (lock state is a
+ * separate question; see `canEditElementPoints`).
+ */
+export declare function isEditPointsCandidate(element: PptxElement | null | undefined): boolean;
+/** The element's outline as editable points, or `undefined` when it has none. */
+export declare function editGeometryFromElement(element: PptxElement): EditGeometry | undefined;
+//# sourceMappingURL=edit-points-import.d.ts.map

package/dist/pptx/render/edit-points/edit-points-import.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"edit-points-import.d.ts","sourceRoot":"","sources":["../../../../src/pptx/render/edit-points/edit-points-import.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AACH,OAAO,KAAK,EAAsB,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAMvE,OAAO,KAAK,EAAE,YAAY,EAA2B,MAAM,qBAAqB,CAAC;AAyHjF;;;GAGG;AACH,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,WAAW,GAAG,IAAI,GAAG,SAAS,GAAG,OAAO,CAKtF;AAED,iFAAiF;AACjF,wBAAgB,uBAAuB,CAAC,OAAO,EAAE,WAAW,GAAG,YAAY,GAAG,SAAS,CAwCtF"}

package/dist/pptx/render/edit-points/edit-points-menu.d.ts

@@ -0,0 +1,41 @@
+import type { EditGeometry, EditHandleRef, EditNodeRef, EditSegmentRef } from './edit-points-types.js';
+/** What a pointer event landed on. */
+export type EditPointsTarget = {
+    kind: 'node';
+    ref: EditNodeRef;
+} | {
+    kind: 'handle';
+    ref: EditHandleRef;
+} | {
+    kind: 'segment';
+    ref: EditSegmentRef;
+} | {
+    kind: 'background';
+};
+/** DOM attribute a binding puts the target id on. */
+export declare const EDIT_POINTS_TARGET_ATTR = "data-pptx-edit-points-target";
+/** The target id string for `target`. */
+export declare function formatEditPointsTarget(target: EditPointsTarget): string;
+/** Parse a target id (anything unrecognised is the background). */
+export declare function parseEditPointsTarget(id: string | null | undefined): EditPointsTarget;
+/** Every command the Edit Points right-click menu can offer. */
+export type EditPointsCommandId = 'add-point' | 'delete-point' | 'delete-segment' | 'open-path' | 'close-path' | 'smooth-point' | 'straight-point' | 'corner-point' | 'straight-segment' | 'curved-segment' | 'exit';
+/** Every command id, in menu order (the customisation catalogue reads this). */
+export declare const EDIT_POINTS_COMMAND_IDS: readonly EditPointsCommandId[];
+/** The i18n key for a command. */
+export declare function editPointsCommandLabelKey(id: EditPointsCommandId): string;
+/** One rendered menu entry. */
+export interface EditPointsMenuEntry {
+    id: EditPointsCommandId;
+    labelKey: string;
+    separatorBefore?: boolean;
+    disabled?: boolean;
+    /** Radio-style check (the vertex's current type, the segment's kind). */
+    checked?: boolean;
+}
+/**
+ * The menu for a right-click on `target`, or `null` when it opens no menu
+ * (the background, a handle). `hidden` removes host-hidden commands.
+ */
+export declare function buildEditPointsMenu(geometry: EditGeometry, target: EditPointsTarget, hidden?: ReadonlySet<EditPointsCommandId>): EditPointsMenuEntry[] | null;
+//# sourceMappingURL=edit-points-menu.d.ts.map

package/dist/pptx/render/edit-points/edit-points-menu.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"edit-points-menu.d.ts","sourceRoot":"","sources":["../../../../src/pptx/render/edit-points/edit-points-menu.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EAAE,YAAY,EAAE,aAAa,EAAE,WAAW,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAEpG,sCAAsC;AACtC,MAAM,MAAM,gBAAgB,GACzB;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,WAAW,CAAA;CAAE,GAClC;IAAE,IAAI,EAAE,QAAQ,CAAC;IAAC,GAAG,EAAE,aAAa,CAAA;CAAE,GACtC;IAAE,IAAI,EAAE,SAAS,CAAC;IAAC,GAAG,EAAE,cAAc,CAAA;CAAE,GACxC;IAAE,IAAI,EAAE,YAAY,CAAA;CAAE,CAAC;AAE1B,qDAAqD;AACrD,eAAO,MAAM,uBAAuB,iCAAiC,CAAC;AAEtE,yCAAyC;AACzC,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,gBAAgB,GAAG,MAAM,CAWvE;AAED,mEAAmE;AACnE,wBAAgB,qBAAqB,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GAAG,gBAAgB,CAmBrF;AAED,gEAAgE;AAChE,MAAM,MAAM,mBAAmB,GAC5B,WAAW,GACX,cAAc,GACd,gBAAgB,GAChB,WAAW,GACX,YAAY,GACZ,cAAc,GACd,gBAAgB,GAChB,cAAc,GACd,kBAAkB,GAClB,gBAAgB,GAChB,MAAM,CAAC;AAEV,gFAAgF;AAChF,eAAO,MAAM,uBAAuB,EAAE,SAAS,mBAAmB,EAYjE,CAAC;AAgBF,kCAAkC;AAClC,wBAAgB,yBAAyB,CAAC,EAAE,EAAE,mBAAmB,GAAG,MAAM,CAEzE;AAED,+BAA+B;AAC/B,MAAM,WAAW,mBAAmB;IACnC,EAAE,EAAE,mBAAmB,CAAC;IACxB,QAAQ,EAAE,MAAM,CAAC;IACjB,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,yEAAyE;IACzE,OAAO,CAAC,EAAE,OAAO,CAAC;CAClB;AAaD;;;GAGG;AACH,wBAAgB,mBAAmB,CAClC,QAAQ,EAAE,YAAY,EACtB,MAAM,EAAE,gBAAgB,EACxB,MAAM,GAAE,WAAW,CAAC,mBAAmB,CAAa,GAClD,mBAAmB,EAAE,GAAG,IAAI,CA8C9B"}

package/dist/pptx/render/edit-points/edit-points-pen.d.ts

@@ -0,0 +1,43 @@
+/**
+ * A pen that turns a stream of path commands into the vertex-centric
+ * {@link EditGeometry}, shared by every importer (structured `a:custGeom`
+ * paths, SVG path strings from the preset engine, freeform drawing tools).
+ *
+ * @module render/edit-points/edit-points-pen
+ */
+import type { EditGeometry, EditPoint, EditSubpath, EditSubpathFillMode } from './edit-points-types.js';
+/** Two points closer than this (local px) are the same vertex. */
+export declare const EDIT_POINT_COINCIDENT_EPSILON = 0.01;
+/** Accumulates sub-paths from pen commands. */
+export declare class EditGeometryPen {
+    private readonly subpaths;
+    private current;
+    private startPoint;
+    private pen;
+    private fillMode;
+    private stroke;
+    /** Paint flags applied to every sub-path started from now on. */
+    setPaint(fillMode: EditSubpathFillMode | undefined, stroke: boolean | undefined): void;
+    /** The current pen position. */
+    get position(): EditPoint;
+    moveTo(point: EditPoint): void;
+    private ensureOpen;
+    lineTo(point: EditPoint): void;
+    curveTo(c1: EditPoint, c2: EditPoint, point: EditPoint): void;
+    private push;
+    close(): void;
+    /** The finished geometry, with lone `moveTo`s dropped and node types inferred. */
+    finish(): EditGeometry;
+}
+/** The segment arriving at node `i` (or undefined at an open start). */
+export declare function incomingSegmentIndex(sub: EditSubpath, node: number): number | undefined;
+/** The segment leaving node `i` (or undefined at an open end). */
+export declare function outgoingSegmentIndex(sub: EditSubpath, node: number): number | undefined;
+/**
+ * Classify each vertex from its handles: a vertex whose in and out handles are
+ * collinear through it is `smooth` when they are equally long and `straight`
+ * otherwise; everything else (including a vertex between two lines) is a
+ * `corner`, which is what PowerPoint reports for a converted preset.
+ */
+export declare function inferNodeTypes(sub: EditSubpath): void;
+//# sourceMappingURL=edit-points-pen.d.ts.map

package/dist/pptx/render/edit-points/edit-points-pen.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"edit-points-pen.d.ts","sourceRoot":"","sources":["../../../../src/pptx/render/edit-points/edit-points-pen.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,OAAO,KAAK,EACX,YAAY,EAEZ,SAAS,EAGT,WAAW,EACX,mBAAmB,EACnB,MAAM,qBAAqB,CAAC;AAE7B,kEAAkE;AAClE,eAAO,MAAM,6BAA6B,OAAO,CAAC;AASlD,+CAA+C;AAC/C,qBAAa,eAAe;IAC3B,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAqB;IAC9C,OAAO,CAAC,OAAO,CAA4B;IAC3C,OAAO,CAAC,UAAU,CAA6B;IAC/C,OAAO,CAAC,GAAG,CAA6B;IACxC,OAAO,CAAC,QAAQ,CAAkC;IAClD,OAAO,CAAC,MAAM,CAAsB;IAEpC,iEAAiE;IACjE,QAAQ,CAAC,QAAQ,EAAE,mBAAmB,GAAG,SAAS,EAAE,MAAM,EAAE,OAAO,GAAG,SAAS,GAAG,IAAI,CAGrF;IAED,gCAAgC;IAChC,IAAI,QAAQ,IAAI,SAAS,CAExB;IAED,MAAM,CAAC,KAAK,EAAE,SAAS,GAAG,IAAI,CAW7B;IAED,OAAO,CAAC,UAAU;IASlB,MAAM,CAAC,KAAK,EAAE,SAAS,GAAG,IAAI,CAE7B;IAED,OAAO,CAAC,EAAE,EAAE,SAAS,EAAE,EAAE,EAAE,SAAS,EAAE,KAAK,EAAE,SAAS,GAAG,IAAI,CAE5D;IAED,OAAO,CAAC,IAAI;IAOZ,KAAK,IAAI,IAAI,CAgBZ;IAED,kFAAkF;IAClF,MAAM,IAAI,YAAY,CAQrB;CACD;AAED,wEAAwE;AACxE,wBAAgB,oBAAoB,CAAC,GAAG,EAAE,WAAW,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAKvF;AAED,kEAAkE;AAClE,wBAAgB,oBAAoB,CAAC,GAAG,EAAE,WAAW,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAKvF;AAED;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,GAAG,EAAE,WAAW,GAAG,IAAI,CAIrD"}

package/dist/pptx/render/edit-points/edit-points-session-types.d.ts

@@ -0,0 +1,67 @@
+/**
+ * Types and helpers of `EditPointsSession`: the event inputs a binding
+ * forwards, the session options, the in-flight drag state and the element
+ * fingerprint used to tell the session's own commits from outside changes.
+ *
+ * @module render/edit-points/edit-points-session-types
+ */
+import type { EditPointsElementPatch } from './edit-points-export.js';
+import type { EditPointsCommandId } from './edit-points-menu.js';
+import type { EditGeometry, EditHandleRef, EditNodeRef, EditSegmentRef } from './edit-points-types.js';
+/** A pointer event forwarded by a binding. */
+export interface EditPointsPointerInput {
+    /** Pointer position in slide pixels. */
+    x: number;
+    y: number;
+    /** The hit shape's target id (`data-pptx-edit-points-target`), if any. */
+    target?: string | null;
+    button?: number;
+    ctrlKey?: boolean;
+    metaKey?: boolean;
+}
+/** A context-menu event forwarded by a binding. */
+export interface EditPointsContextMenuInput extends EditPointsPointerInput {
+    clientX: number;
+    clientY: number;
+}
+export interface EditPointsSessionOptions {
+    /** Apply an edit to the element (one undo step per call). */
+    onCommit: (patch: EditPointsElementPatch) => void;
+    /** The session ended (Escape, click away, Exit Edit Points). */
+    onExit: () => void;
+    /** The view changed; re-render. */
+    onChange?: () => void;
+    /** Menu commands the host hid. */
+    hiddenCommands?: ReadonlySet<EditPointsCommandId>;
+}
+export interface DragBase {
+    origin: EditGeometry;
+    /** Press position (slide px), to tell a click from a drag. */
+    startX: number;
+    startY: number;
+    moved: boolean;
+}
+export type EditPointsDrag = (DragBase & {
+    kind: 'node';
+    ref: EditNodeRef;
+}) | (DragBase & {
+    kind: 'handle';
+    ref: EditHandleRef;
+}) | (DragBase & {
+    kind: 'segment';
+    ref: EditSegmentRef;
+    t: number;
+});
+/** Pointer travel (slide px) below which a press is a click, not a drag. */
+export declare const EDIT_POINTS_DRAG_THRESHOLD_PX = 1;
+/** A cheap fingerprint of the geometry-bearing fields of an element. */
+export declare function editPointsElementSignature(element: {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    shapeType?: string;
+    pathData?: string;
+    shapeAdjustments?: Record<string, number>;
+}): string;
+//# sourceMappingURL=edit-points-session-types.d.ts.map

package/dist/pptx/render/edit-points/edit-points-session-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"edit-points-session-types.d.ts","sourceRoot":"","sources":["../../../../src/pptx/render/edit-points/edit-points-session-types.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,sBAAsB,CAAC;AACnE,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,oBAAoB,CAAC;AAC9D,OAAO,KAAK,EAAE,YAAY,EAAE,aAAa,EAAE,WAAW,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAEpG,8CAA8C;AAC9C,MAAM,WAAW,sBAAsB;IACtC,wCAAwC;IACxC,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,0EAA0E;IAC1E,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACvB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,OAAO,CAAC,EAAE,OAAO,CAAC;CAClB;AAED,mDAAmD;AACnD,MAAM,WAAW,0BAA2B,SAAQ,sBAAsB;IACzE,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,wBAAwB;IACxC,6DAA6D;IAC7D,QAAQ,EAAE,CAAC,KAAK,EAAE,sBAAsB,KAAK,IAAI,CAAC;IAClD,gEAAgE;IAChE,MAAM,EAAE,MAAM,IAAI,CAAC;IACnB,mCAAmC;IACnC,QAAQ,CAAC,EAAE,MAAM,IAAI,CAAC;IACtB,kCAAkC;IAClC,cAAc,CAAC,EAAE,WAAW,CAAC,mBAAmB,CAAC,CAAC;CAClD;AAED,MAAM,WAAW,QAAQ;IACxB,MAAM,EAAE,YAAY,CAAC;IACrB,8DAA8D;IAC9D,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,OAAO,CAAC;CACf;AAED,MAAM,MAAM,cAAc,GACvB,CAAC,QAAQ,GAAG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,WAAW,CAAA;CAAE,CAAC,GAC/C,CAAC,QAAQ,GAAG;IAAE,IAAI,EAAE,QAAQ,CAAC;IAAC,GAAG,EAAE,aAAa,CAAA;CAAE,CAAC,GACnD,CAAC,QAAQ,GAAG;IAAE,IAAI,EAAE,SAAS,CAAC;IAAC,GAAG,EAAE,cAAc,CAAC;IAAC,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC,CAAC;AAEpE,4EAA4E;AAC5E,eAAO,MAAM,6BAA6B,IAAI,CAAC;AAM/C,wEAAwE;AACxE,wBAAgB,0BAA0B,CAAC,OAAO,EAAE;IACnD,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,gBAAgB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAC1C,GAAG,MAAM,CAUT"}

package/dist/pptx/render/edit-points/edit-points-session.d.ts

@@ -0,0 +1,68 @@
+/**
+ * `EditPointsSession`: the whole Edit Points interaction as a framework-free
+ * state machine. A binding creates one when the user picks Edit Points,
+ * forwards pointer / context-menu / key events to it in SLIDE coordinates with
+ * the target string it read off the hit shape, draws `view()`, and applies the
+ * element patches it receives through `onCommit` (each is one undo step).
+ *
+ * Gestures (matching PowerPoint):
+ *  - drag a vertex to move it; drag a handle to reshape the curve; drag a
+ *    segment to bend it (a straight segment becomes a curve);
+ *  - Ctrl+click a segment to add a point, Ctrl+click a vertex to delete it;
+ *  - right-click a vertex or segment for the command menu;
+ *  - Delete / Backspace removes the selected vertex;
+ *  - Escape (or a click away from the shape) leaves the mode.
+ *
+ * The session keeps its own local frame (the element box when it began) for
+ * its whole life, so repeated commits that re-anchor the element never make
+ * the geometry drift. If the element changes underneath it (undo, a remote
+ * edit), `reconcile` reloads from the element.
+ *
+ * @module render/edit-points/edit-points-session
+ */
+import type { PptxElement } from 'ooxml-core/pptx';
+import type { EditPointsCommandId } from './edit-points-menu.js';
+import type { EditPointsContextMenuInput, EditPointsPointerInput, EditPointsSessionOptions } from './edit-points-session-types.js';
+import type { EditGeometry } from './edit-points-types.js';
+import type { EditPointsView } from './edit-points-view.js';
+export declare class EditPointsSession {
+    private readonly options;
+    readonly elementId: string;
+    private frame;
+    private geometry;
+    private selected;
+    private drag;
+    private menu;
+    private signature;
+    private ended;
+    /** Where on the right-clicked segment the menu was opened (for Add Point). */
+    private menuParam;
+    constructor(element: PptxElement, options: EditPointsSessionOptions);
+    /** The current geometry (local frame). Exposed for tests and previews. */
+    get currentGeometry(): EditGeometry;
+    /** Whether the session has ended. */
+    get isEnded(): boolean;
+    /** The descriptor to draw at editor zoom `scale`. */
+    view(scale?: number): EditPointsView;
+    /** Reload from `element` when it changed other than through this session. */
+    reconcile(element: PptxElement): void;
+    private changed;
+    private local;
+    /** Returns `false` when the press ended the session (a click away). */
+    pointerDown(input: EditPointsPointerInput): boolean;
+    pointerMove(input: EditPointsPointerInput): void;
+    pointerUp(input?: EditPointsPointerInput): void;
+    /** Open the menu for a right-click. Returns whether a menu opened. */
+    contextMenu(input: EditPointsContextMenuInput): boolean;
+    /** Close the menu without running anything. */
+    closeMenu(): void;
+    /** Run a menu command against the target the menu was opened on. */
+    runCommand(id: EditPointsCommandId): void;
+    private apply;
+    /** Returns whether the key was consumed. */
+    keyDown(key: string): boolean;
+    /** End the session, committing a drag still in flight. */
+    exit(): void;
+    private commit;
+}
+//# sourceMappingURL=edit-points-session.d.ts.map

package/dist/pptx/render/edit-points/edit-points-session.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"edit-points-session.d.ts","sourceRoot":"","sources":["../../../../src/pptx/render/edit-points/edit-points-session.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AASnD,OAAO,KAAK,EAAE,mBAAmB,EAAoB,MAAM,oBAAoB,CAAC;AAEhF,OAAO,KAAK,EACX,0BAA0B,EAE1B,sBAAsB,EACtB,wBAAwB,EACxB,MAAM,6BAA6B,CAAC;AAKrC,OAAO,KAAK,EAAa,YAAY,EAA0B,MAAM,qBAAqB,CAAC;AAC3F,OAAO,KAAK,EAAsB,cAAc,EAAE,MAAM,oBAAoB,CAAC;AAG7E,qBAAa,iBAAiB;IAe5B,OAAO,CAAC,QAAQ,CAAC,OAAO;IAdzB,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,OAAO,CAAC,KAAK,CAAY;IACzB,OAAO,CAAC,QAAQ,CAAe;IAC/B,OAAO,CAAC,QAAQ,CAA4B;IAC5C,OAAO,CAAC,IAAI,CAA+B;IAC3C,OAAO,CAAC,IAAI,CACN;IACN,OAAO,CAAC,SAAS,CAAS;IAC1B,OAAO,CAAC,KAAK,CAAS;IACtB,8EAA8E;IAC9E,OAAO,CAAC,SAAS,CAAO;IAExB,YACC,OAAO,EAAE,WAAW,EACH,OAAO,EAAE,wBAAwB,EAMlD;IAED,0EAA0E;IAC1E,IAAI,eAAe,IAAI,YAAY,CAElC;IAED,qCAAqC;IACrC,IAAI,OAAO,IAAI,OAAO,CAErB;IAED,qDAAqD;IACrD,IAAI,CAAC,KAAK,SAAI,GAAG,cAAc,CAW9B;IAED,6EAA6E;IAC7E,SAAS,CAAC,OAAO,EAAE,WAAW,GAAG,IAAI,CAapC;IAED,OAAO,CAAC,OAAO;IAIf,OAAO,CAAC,KAAK;IAIb,uEAAuE;IACvE,WAAW,CAAC,KAAK,EAAE,sBAAsB,GAAG,OAAO,CA8ClD;IAED,WAAW,CAAC,KAAK,EAAE,sBAAsB,GAAG,IAAI,CAqB/C;IAED,SAAS,CAAC,KAAK,CAAC,EAAE,sBAAsB,GAAG,IAAI,CAa9C;IAED,sEAAsE;IACtE,WAAW,CAAC,KAAK,EAAE,0BAA0B,GAAG,OAAO,CAqBtD;IAED,+CAA+C;IAC/C,SAAS,IAAI,IAAI,CAKhB;IAED,oEAAoE;IACpE,UAAU,CAAC,EAAE,EAAE,mBAAmB,GAAG,IAAI,CASxC;IAED,OAAO,CAAC,KAAK;IAcb,4CAA4C;IAC5C,OAAO,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAiB5B;IAED,0DAA0D;IAC1D,IAAI,IAAI,IAAI,CAQX;IAED,OAAO,CAAC,MAAM;CASd"}

package/dist/pptx/render/edit-points/edit-points-structure-ops.d.ts

@@ -0,0 +1,33 @@
+import type { EditGeometry, EditNodeRef, EditPointNodeType, EditSegmentRef } from './edit-points-types.js';
+/** Insert a vertex on a segment at parameter `t` without changing the outline. */
+export declare function addEditPoint(geometry: EditGeometry, ref: EditSegmentRef, t: number): {
+    geometry: EditGeometry;
+    node: EditNodeRef;
+} | undefined;
+/**
+ * Remove a vertex, joining its two neighbours with one segment (a line when
+ * both sides were lines, otherwise a curve keeping the outer handles).
+ * Refused when it would leave nothing to draw.
+ */
+export declare function deleteEditPoint(geometry: EditGeometry, ref: EditNodeRef): EditGeometry | undefined;
+/** Open a closed path at a vertex: the vertex becomes both its start and end. */
+export declare function openEditPathAtNode(geometry: EditGeometry, ref: EditNodeRef): EditGeometry | undefined;
+/**
+ * Remove a segment. A closed path opens there; an open path splits in two
+ * (dropping any piece left with a single vertex).
+ */
+export declare function deleteEditSegment(geometry: EditGeometry, ref: EditSegmentRef): EditGeometry | undefined;
+/**
+ * Close an open path: a straight segment joins its end back to its start, or
+ * the two ends merge when they already coincide.
+ */
+export declare function closeEditPath(geometry: EditGeometry, subpath: number): EditGeometry | undefined;
+/** Make a segment straight or curved. */
+export declare function setEditSegmentKind(geometry: EditGeometry, ref: EditSegmentRef, kind: 'line' | 'curve'): EditGeometry | undefined;
+/**
+ * Set a vertex's type. Smooth and Straight turn the adjoining segments into
+ * curves and align both handles along the line through the neighbouring
+ * vertices (Smooth also equalises their lengths); Corner only relabels.
+ */
+export declare function setEditNodeType(geometry: EditGeometry, ref: EditNodeRef, type: EditPointNodeType): EditGeometry | undefined;
+//# sourceMappingURL=edit-points-structure-ops.d.ts.map

package/dist/pptx/render/edit-points/edit-points-structure-ops.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"edit-points-structure-ops.d.ts","sourceRoot":"","sources":["../../../../src/pptx/render/edit-points/edit-points-structure-ops.ts"],"names":[],"mappings":"AAuBA,OAAO,KAAK,EACX,YAAY,EACZ,WAAW,EACX,iBAAiB,EAEjB,cAAc,EAEd,MAAM,qBAAqB,CAAC;AAE7B,kFAAkF;AAClF,wBAAgB,YAAY,CAC3B,QAAQ,EAAE,YAAY,EACtB,GAAG,EAAE,cAAc,EACnB,CAAC,EAAE,MAAM,GACP;IAAE,QAAQ,EAAE,YAAY,CAAC;IAAC,IAAI,EAAE,WAAW,CAAA;CAAE,GAAG,SAAS,CA+B3D;AAOD;;;;GAIG;AACH,wBAAgB,eAAe,CAC9B,QAAQ,EAAE,YAAY,EACtB,GAAG,EAAE,WAAW,GACd,YAAY,GAAG,SAAS,CAkC1B;AAMD,iFAAiF;AACjF,wBAAgB,kBAAkB,CACjC,QAAQ,EAAE,YAAY,EACtB,GAAG,EAAE,WAAW,GACd,YAAY,GAAG,SAAS,CAa1B;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,CAChC,QAAQ,EAAE,YAAY,EACtB,GAAG,EAAE,cAAc,GACjB,YAAY,GAAG,SAAS,CA0B1B;AAED;;;GAGG;AACH,wBAAgB,aAAa,CAAC,QAAQ,EAAE,YAAY,EAAE,OAAO,EAAE,MAAM,GAAG,YAAY,GAAG,SAAS,CAgB/F;AAED,yCAAyC;AACzC,wBAAgB,kBAAkB,CACjC,QAAQ,EAAE,YAAY,EACtB,GAAG,EAAE,cAAc,EACnB,IAAI,EAAE,MAAM,GAAG,OAAO,GACpB,YAAY,GAAG,SAAS,CAe1B;AAED;;;;GAIG;AACH,wBAAgB,eAAe,CAC9B,QAAQ,EAAE,YAAY,EACtB,GAAG,EAAE,WAAW,EAChB,IAAI,EAAE,iBAAiB,GACrB,YAAY,GAAG,SAAS,CA8C1B"}

package/dist/pptx/render/edit-points/edit-points-svg.d.ts

@@ -0,0 +1,8 @@
+import type { EditGeometryPen } from './edit-points-pen.js';
+import type { EditPoint } from './edit-points-types.js';
+/**
+ * Feed `d` into `pen`, mapping every coordinate through `map` (for scaling a
+ * path's own coordinate space onto the element box).
+ */
+export declare function feedSvgPath(pen: EditGeometryPen, d: string, map?: (point: EditPoint) => EditPoint): void;
+//# sourceMappingURL=edit-points-svg.d.ts.map

package/dist/pptx/render/edit-points/edit-points-svg.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"edit-points-svg.d.ts","sourceRoot":"","sources":["../../../../src/pptx/render/edit-points/edit-points-svg.ts"],"names":[],"mappings":"AAWA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AACzD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAC;AA4IrD;;;GAGG;AACH,wBAAgB,WAAW,CAC1B,GAAG,EAAE,eAAe,EACpB,CAAC,EAAE,MAAM,EACT,GAAG,GAAE,CAAC,KAAK,EAAE,SAAS,KAAK,SAAoB,GAC7C,IAAI,CAoBN"}

package/dist/pptx/render/edit-points/edit-points-types.d.ts

@@ -0,0 +1,116 @@
+/**
+ * The editable path model behind PowerPoint's Edit Points mode.
+ *
+ * `a:custGeom` stores a shape outline as a list of pen commands (`moveTo`,
+ * `lnTo`, `cubicBezTo`, `quadBezTo`, `arcTo`, `close`). That list is awkward to
+ * edit directly: a vertex has no identity of its own (it is the end point of one
+ * command and the implicit start of the next), and a Bezier's control points
+ * belong to the segment, not to the vertex a user drags. This model is the
+ * vertex-centric view PowerPoint shows instead:
+ *
+ *  - a {@link EditSubpath} is one `moveTo`-started run of the pen;
+ *  - its `nodes` are the vertices, each with a PowerPoint point type
+ *    (corner / smooth / straight);
+ *  - `segments[i]` joins `nodes[i]` to `nodes[i + 1]` (wrapping to `nodes[0]`
+ *    when the sub-path is closed), and is either a straight line or a cubic
+ *    Bezier carrying its two control points.
+ *
+ * Quadratic Beziers and elliptical arcs are converted to cubics on the way in,
+ * exactly as PowerPoint itself does the first time a shape's points are
+ * edited, so every operation only ever has two segment kinds to handle.
+ *
+ * Coordinates are in the element's LOCAL pixel frame: `(0, 0)` is the top-left
+ * of the unrotated, unflipped box the session started from (see
+ * `edit-points-frame.ts`).
+ *
+ * @module render/edit-points/edit-points-types
+ */
+/** A 2D point in the element's local pixel frame. */
+export interface EditPoint {
+    x: number;
+    y: number;
+}
+/**
+ * PowerPoint's three vertex types (right-click a point in Edit Points mode):
+ *
+ *  - `corner`: the two control handles move independently;
+ *  - `smooth`: the handles stay collinear AND equally long;
+ *  - `straight`: the handles stay collinear but keep their own lengths.
+ */
+export type EditPointNodeType = 'corner' | 'smooth' | 'straight';
+/** One vertex of a sub-path. */
+export interface EditNode extends EditPoint {
+    type: EditPointNodeType;
+}
+/** The segment joining two consecutive nodes. */
+export type EditSegment = {
+    kind: 'line';
+} | {
+    kind: 'curve';
+    /** Control point leaving the segment's start node. */
+    c1: EditPoint;
+    /** Control point arriving at the segment's end node. */
+    c2: EditPoint;
+};
+/** OOXML `a:path/@fill` values preserved per sub-path. */
+export type EditSubpathFillMode = 'norm' | 'lighten' | 'lightenLess' | 'darken' | 'darkenLess' | 'none';
+/** One `moveTo`-started run of the pen. */
+export interface EditSubpath {
+    nodes: EditNode[];
+    /**
+     * `segments[i]` joins `nodes[i]` to `nodes[i + 1]`; a closed sub-path has
+     * one more, joining the last node back to the first. So the length is
+     * `nodes.length` when closed and `nodes.length - 1` when open.
+     */
+    segments: EditSegment[];
+    closed: boolean;
+    /** `a:path/@fill`, carried through unchanged. */
+    fillMode?: EditSubpathFillMode;
+    /** `a:path/@stroke`, carried through unchanged. */
+    stroke?: boolean;
+}
+/** A whole editable outline: every sub-path of the shape. */
+export interface EditGeometry {
+    subpaths: EditSubpath[];
+    /**
+     * The text rectangle (local px) the shape had when editing began: a
+     * converted preset keeps its own text box (a star's text stays in the
+     * star's centre) instead of spreading over the new bounding box.
+     */
+    textRect?: EditTextRect;
+}
+/** A text rectangle as absolute left / top / right / bottom edges. */
+export interface EditTextRect {
+    l: number;
+    t: number;
+    r: number;
+    b: number;
+}
+/** Address of one node. */
+export interface EditNodeRef {
+    subpath: number;
+    node: number;
+}
+/** Address of one segment. */
+export interface EditSegmentRef {
+    subpath: number;
+    segment: number;
+}
+/** Address of one Bezier control handle: `c1` or `c2` of a curve segment. */
+export interface EditHandleRef extends EditSegmentRef {
+    which: 'c1' | 'c2';
+}
+/**
+ * The box the local frame is anchored to: the element's position, size,
+ * rotation (degrees clockwise) and flips when the session began.
+ */
+export interface EditFrame {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    rotation: number;
+    flipH: boolean;
+    flipV: boolean;
+}
+//# sourceMappingURL=edit-points-types.d.ts.map

package/dist/pptx/render/edit-points/edit-points-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"edit-points-types.d.ts","sourceRoot":"","sources":["../../../../src/pptx/render/edit-points/edit-points-types.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAEH,qDAAqD;AACrD,MAAM,WAAW,SAAS;IACzB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACV;AAED;;;;;;GAMG;AACH,MAAM,MAAM,iBAAiB,GAAG,QAAQ,GAAG,QAAQ,GAAG,UAAU,CAAC;AAEjE,gCAAgC;AAChC,MAAM,WAAW,QAAS,SAAQ,SAAS;IAC1C,IAAI,EAAE,iBAAiB,CAAC;CACxB;AAED,iDAAiD;AACjD,MAAM,MAAM,WAAW,GACpB;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,GAChB;IACA,IAAI,EAAE,OAAO,CAAC;IACd,sDAAsD;IACtD,EAAE,EAAE,SAAS,CAAC;IACd,wDAAwD;IACxD,EAAE,EAAE,SAAS,CAAC;CACb,CAAC;AAEL,0DAA0D;AAC1D,MAAM,MAAM,mBAAmB,GAC5B,MAAM,GACN,SAAS,GACT,aAAa,GACb,QAAQ,GACR,YAAY,GACZ,MAAM,CAAC;AAEV,2CAA2C;AAC3C,MAAM,WAAW,WAAW;IAC3B,KAAK,EAAE,QAAQ,EAAE,CAAC;IAClB;;;;OAIG;IACH,QAAQ,EAAE,WAAW,EAAE,CAAC;IACxB,MAAM,EAAE,OAAO,CAAC;IAChB,iDAAiD;IACjD,QAAQ,CAAC,EAAE,mBAAmB,CAAC;IAC/B,mDAAmD;IACnD,MAAM,CAAC,EAAE,OAAO,CAAC;CACjB;AAED,6DAA6D;AAC7D,MAAM,WAAW,YAAY;IAC5B,QAAQ,EAAE,WAAW,EAAE,CAAC;IACxB;;;;OAIG;IACH,QAAQ,CAAC,EAAE,YAAY,CAAC;CACxB;AAED,sEAAsE;AACtE,MAAM,WAAW,YAAY;IAC5B,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACV;AAED,2BAA2B;AAC3B,MAAM,WAAW,WAAW;IAC3B,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,MAAM,CAAC;CACb;AAED,8BAA8B;AAC9B,MAAM,WAAW,cAAc;IAC9B,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;CAChB;AAED,6EAA6E;AAC7E,MAAM,WAAW,aAAc,SAAQ,cAAc;IACpD,KAAK,EAAE,IAAI,GAAG,IAAI,CAAC;CACnB;AAED;;;GAGG;AACH,MAAM,WAAW,SAAS;IACzB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,OAAO,CAAC;IACf,KAAK,EAAE,OAAO,CAAC;CACf"}

package/dist/pptx/render/edit-points/edit-points-view.d.ts

@@ -0,0 +1,69 @@
+import type { EditPointsMenuEntry } from './edit-points-menu.js';
+import type { EditFrame, EditGeometry, EditNodeRef, EditPointNodeType } from './edit-points-types.js';
+/** Colours and on-screen sizes (CSS px at 100% zoom) of the overlay. */
+export declare const EDIT_POINTS_STYLE: {
+    readonly outlineColor: '#c00000';
+    readonly outlineWidth: 1;
+    readonly nodeFill: '#000000';
+    readonly nodeStroke: '#ffffff';
+    readonly selectedNodeFill: '#ffffff';
+    readonly selectedNodeStroke: '#000000';
+    readonly nodeSize: 8;
+    readonly handleFill: '#ffffff';
+    readonly handleStroke: '#2f5597';
+    readonly handleLineColor: '#2f5597';
+    readonly handleSize: 7;
+    readonly hitStrokeWidth: 10;
+};
+/** One vertex square. */
+export interface EditPointsNodeView {
+    target: string;
+    x: number;
+    y: number;
+    size: number;
+    selected: boolean;
+    type: EditPointNodeType;
+}
+/** One Bezier handle square plus the line back to its vertex. */
+export interface EditPointsHandleView {
+    target: string;
+    x: number;
+    y: number;
+    anchorX: number;
+    anchorY: number;
+    size: number;
+}
+/** One segment's hit stroke. */
+export interface EditPointsSegmentView {
+    target: string;
+    d: string;
+}
+/**
+ * The right-click menu. `x`/`y` place it in slide pixels (inside the scaled
+ * stage, drawn at `transform: scale(inverseScale)` from its top-left so it
+ * stays screen-sized at any zoom); `clientX`/`clientY` are the same spot in
+ * viewport pixels for a binding that renders it outside the stage instead.
+ */
+export interface EditPointsMenuView {
+    x: number;
+    y: number;
+    inverseScale: number;
+    clientX: number;
+    clientY: number;
+    entries: EditPointsMenuEntry[];
+}
+/** Everything a binding draws for an Edit Points session. */
+export interface EditPointsView {
+    outlineD: string;
+    outlineWidth: number;
+    segments: EditPointsSegmentView[];
+    nodes: EditPointsNodeView[];
+    handles: EditPointsHandleView[];
+    hitStrokeWidth: number;
+    menu: EditPointsMenuView | null;
+}
+/** The whole outline in slide space. */
+export declare function editGeometryToSlidePath(frame: EditFrame, geometry: EditGeometry): string;
+/** Build the descriptor for `geometry` at editor zoom `scale`. */
+export declare function buildEditPointsView(frame: EditFrame, geometry: EditGeometry, selected: EditNodeRef | null, scale: number, menu: Omit<EditPointsMenuView, 'inverseScale'> | null): EditPointsView;
+//# sourceMappingURL=edit-points-view.d.ts.map

package/dist/pptx/render/edit-points/edit-points-view.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"edit-points-view.d.ts","sourceRoot":"","sources":["../../../../src/pptx/render/edit-points/edit-points-view.ts"],"names":[],"mappings":"AAeA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,oBAAoB,CAAC;AAE9D,OAAO,KAAK,EACX,SAAS,EACT,YAAY,EACZ,WAAW,EAEX,iBAAiB,EACjB,MAAM,qBAAqB,CAAC;AAE7B,wEAAwE;AACxE,eAAO,MAAM,iBAAiB;aAC7B,YAAY,EAAE,SAAS;aACvB,YAAY,EAAE,CAAC;aACf,QAAQ,EAAE,SAAS;aACnB,UAAU,EAAE,SAAS;aACrB,gBAAgB,EAAE,SAAS;aAC3B,kBAAkB,EAAE,SAAS;aAC7B,QAAQ,EAAE,CAAC;aACX,UAAU,EAAE,SAAS;aACrB,YAAY,EAAE,SAAS;aACvB,eAAe,EAAE,SAAS;aAC1B,UAAU,EAAE,CAAC;aACb,cAAc,EAAE,EAAE;CACT,CAAC;AAEX,yBAAyB;AACzB,MAAM,WAAW,kBAAkB;IAClC,MAAM,EAAE,MAAM,CAAC;IACf,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,OAAO,CAAC;IAClB,IAAI,EAAE,iBAAiB,CAAC;CACxB;AAED,iEAAiE;AACjE,MAAM,WAAW,oBAAoB;IACpC,MAAM,EAAE,MAAM,CAAC;IACf,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,MAAM,CAAC;CACb;AAED,gCAAgC;AAChC,MAAM,WAAW,qBAAqB;IACrC,MAAM,EAAE,MAAM,CAAC;IACf,CAAC,EAAE,MAAM,CAAC;CACV;AAED;;;;;GAKG;AACH,MAAM,WAAW,kBAAkB;IAClC,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,YAAY,EAAE,MAAM,CAAC;IACrB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,mBAAmB,EAAE,CAAC;CAC/B;AAED,6DAA6D;AAC7D,MAAM,WAAW,cAAc;IAC9B,QAAQ,EAAE,MAAM,CAAC;IACjB,YAAY,EAAE,MAAM,CAAC;IACrB,QAAQ,EAAE,qBAAqB,EAAE,CAAC;IAClC,KAAK,EAAE,kBAAkB,EAAE,CAAC;IAC5B,OAAO,EAAE,oBAAoB,EAAE,CAAC;IAChC,cAAc,EAAE,MAAM,CAAC;IACvB,IAAI,EAAE,kBAAkB,GAAG,IAAI,CAAC;CAChC;AAmBD,wCAAwC;AACxC,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,SAAS,EAAE,QAAQ,EAAE,YAAY,GAAG,MAAM,CAoBxF;AAED,kEAAkE;AAClE,wBAAgB,mBAAmB,CAClC,KAAK,EAAE,SAAS,EAChB,QAAQ,EAAE,YAAY,EACtB,QAAQ,EAAE,WAAW,GAAG,IAAI,EAC5B,KAAK,EAAE,MAAM,EACb,IAAI,EAAE,IAAI,CAAC,kBAAkB,EAAE,cAAc,CAAC,GAAG,IAAI,GACnD,cAAc,CA0DhB"}