@react-x11/components 0.1.0 → 0.2.0

package/dist/flow/node.d.ts

@@ -0,0 +1,429 @@
+import { Node } from 'react-x11/node';
+import type { A11ySceneAction, A11ySceneItem } from 'react-x11/node';
+import type { Context2D } from 'react-x11/node';
+import type { KeyboardEvent, MouseEvent, WheelEvent } from 'react-x11';
+import type { FitViewOptions, FlowNode, FlowNodeType, FlowRect, FlowInstance, HandleSpec, Viewport, XYPosition } from './types.js';
+/** Registration key, `kind` and JSX tag, one string — react-x11 rejects a
+ * node whose `kind` is not the name it was registered under, because `kind`
+ * is what paint order, the test queries and the DEV style assertion all
+ * match on. */
+export declare const ELEMENT = "flowgraph";
+type AnyNode = FlowNode<unknown>;
+type AnyType = FlowNodeType<unknown>;
+/** A node, resolved: its size and its handle specs, both of which only
+ * change when the graph does. Positions are *not* cached — a drag moves them
+ * between commits, and reading them through {@link FlowGraphNode.rectOf} is
+ * what keeps the two in step. */
+interface NodeEntry {
+    node: AnyNode;
+    width: number;
+    height: number;
+    specs: readonly HandleSpec[];
+    type: AnyType | undefined;
+}
+/**
+ * The props whose repaints this element claims for itself — everything
+ * `applyProps` below either diffs into a damage rect (`nodes`, `edges`…),
+ * repaints in full when it truly changed (the visual list), or that changes
+ * behaviour without touching a pixel (`snapToGrid`, the gesture switches).
+ * Declared to `registerElement` as `selfDamagedProps`, so core's per-commit
+ * `paintChanged` contributes no damage for them — without the declaration,
+ * every drag step is a full-pane repaint again, because the commit's new
+ * `nodes` array identity would damage the whole node.
+ */
+export declare const SELF_DAMAGED_PROPS: readonly string[];
+export declare class FlowGraphNode extends Node implements FlowInstance {
+    private _vp;
+    private _fitPending;
+    private _nodesSeen;
+    private _typesSeen;
+    private _edgesSeen;
+    private _edgeDefaultsSeen;
+    private _fontSeen;
+    private _entries;
+    private _byId;
+    private _edgesByNode;
+    /** The prop array the built edges came from, for the per-edge diff. */
+    private _edgesRaw;
+    /** Paint order: `zIndex`, then selection, so a selected node is not hidden
+     * under one it overlaps. Hit testing walks it backwards. */
+    private _order;
+    private _edges;
+    private _gesture;
+    private _hover;
+    /** Where a drag is putting each node it moves. Read in preference to
+     * `node.position`, so the pane is never a frame behind the pointer even
+     * when the app applies the changes it is being sent. Cleared on release,
+     * which is also how a refused drag snaps back. */
+    private _dragTo;
+    /** The box a resize is currently making, for the same reason. */
+    private _resizeTo;
+    /** What was last handed to `onNodeBodies`, so the React half is told only
+     * when something actually moved. */
+    private _bodiesKey;
+    private _dashPhase;
+    private _animTimer;
+    /** Inside `paint`, where an invalidation would only schedule a redraw of
+     * the frame being drawn. */
+    private _painting;
+    /** Inside a live input dispatch — what makes a body emission `sync`.
+     * Motion and the wheel run at continuous priority, whose React updates
+     * can trail the pane's own painting by frames; an emission made under
+     * this flag asks the receiver to commit before the dispatch returns. */
+    private _gestureSync;
+    /** The scene has been offered to assistive tech at least once — items
+     * only exist once layout has placed them, which no commit marks. */
+    private _sceneAnnounced;
+    /** The damage rect of the pass being painted, or null for a full one —
+     * what the drawing subroutines cull against. */
+    private _frameClip;
+    /** Where the animated edges were last frame, so the dash timer can
+     * invalidate that box instead of the whole pane. */
+    private _animBox;
+    private _textCache;
+    /** The grid's repeating tile: one surface for as long as the pitch
+     * holds, re-rendered in place when the phase or the colours move. */
+    private _gridTile;
+    constructor(props: Record<string, unknown>, app: unknown);
+    private _prop;
+    private _bool;
+    private _num;
+    private get _minZoom();
+    private get _maxZoom();
+    private _nodes;
+    private _rawEdges;
+    private _fonts;
+    private _themeString;
+    private _textOptions;
+    private _measure;
+    private _palette;
+    /**
+     * Rebuild the node index when — and only when — one of its inputs changed
+     * identity. Sizes come out of the font stack, so the face is an input too:
+     * a theme switch that changes it has to re-measure or every node keeps the
+     * width it had under the old one.
+     */
+    private _sync;
+    /**
+     * Fold a new `edges` array into the built list, the cheap way when that
+     * is honest — the `_applyNodes` treatment, for the other array.
+     *
+     * An app that writes `edges={[…]}` inline hands over a fresh array of
+     * fresh objects on every render, most of them value-identical to the
+     * last. Those keep their built entry (same object, so everything
+     * downstream that compares by identity stays quiet). An edge that truly
+     * changed is rebuilt alone and claims its own route, old and new. Adds,
+     * removes and reorders fall back to the full rebuild.
+     */
+    private _applyEdges;
+    /**
+     * Fold a new `nodes` array into the existing entries, the cheap way when
+     * that is honest.
+     *
+     * During a drag the array is rebuilt by the app on every pointer step, and
+     * the only thing in it that changed is one node's `position`. Re-measuring
+     * and re-sorting three hundred nodes per step — the full `_rebuildNodes` —
+     * was most of a drag frame's CPU. So: if every node differs from its entry
+     * in nothing but `position`, the entries are updated in place (same
+     * objects, same order, same measured sizes) and the return value is the
+     * screen box that actually changed — the moved nodes, old and new, plus
+     * every edge that touches them. Anything else — a label, a size, a
+     * selection, an add or remove — falls back to the full rebuild, because it
+     * can change measurement or paint order.
+     *
+     * Returns `'full'` after a rebuild, a damage rect after an in-place fold,
+     * and `null` when nothing visual changed at all.
+     */
+    private _applyNodes;
+    /**
+     * The screen box a node's redraw touches: its own rect and every edge on
+     * it — what a move must invalidate, before and after.
+     *
+     * Edge bounds come from the real routed geometry, not the coarse box: the
+     * coarse slack is sized for a bezier that *might* bulge, which in a dense
+     * graph sweeps dozens of neighbours into every drag step's damage. The
+     * exact path costs what drawing the edge costs, and a moved node's edges
+     * are about to be drawn anyway. Past a fan-out worth of edges the coarse
+     * box wins again — one huge union is one huge union either way, and the
+     * geometry walk stops being free.
+     */
+    private _nodeDamage;
+    private _rebuildNodes;
+    private _rebuildEdges;
+    /** who touches whom — what a moved node's damage has to include */
+    private _rebuildAdjacency;
+    private _viewport;
+    /**
+     * The pane proper: `abs` inset by border and padding, off core's own
+     * resolved layout (react-x11#254) — so a `<Flow style={{ borderWidth: 1,
+     * padding: 8 }}>` keeps its border, and its padding means what it does on
+     * a `<box>`.
+     */
+    private _pane;
+    /** Graph point to window pixels. */
+    private _toScreen;
+    /** Window pixels to graph point. */
+    private _toGraph;
+    /** Where a node is *now*: mid-drag that is not where its props say. */
+    private _positionOf;
+    /** A node's box in graph space — including whatever a gesture in flight
+     * is making of it, which is what keeps the pane from being a frame behind
+     * the pointer even when the app is applying the changes it is sent. */
+    rectOf(entry: NodeEntry): FlowRect;
+    /** The strip a `render` node keeps for its title and for dragging. Zero
+     * for a node whose body the pane draws itself. */
+    private _headerHeight;
+    private _resizable;
+    /** The grips a node offers right now: none unless it is selected and
+     * resizable, because eight dots on every node is a graph nobody can
+     * read. */
+    private _grips;
+    private _handlesOf;
+    /**
+     * A node's box on screen, **on whole pixels**.
+     *
+     * The rounding is not cosmetic. ntk draws a rounded box as cached corner
+     * glyphs plus `FillRectangles` when its geometry is integral, and
+     * rasterizes a mask it has to `PutImage` when it is not — and a zoom of
+     * 0.42 makes every one of them fractional. On a 300-node graph that was
+     * six hundred mask uploads a frame and about four megabytes on the wire;
+     * `react-x11/debug`'s trace names it as `fell back … fractional`.
+     *
+     * Hit testing reads the same rect, so what is drawn and what is clicked
+     * still agree to the pixel.
+     */
+    private _screenRect;
+    private _visible;
+    private _repaint;
+    private _applyViewport;
+    /**
+     * A pan is a scroll in every way but the bookkeeping, and react-x11#303
+     * made the bookkeeping public: `scrollContents` claims the pane, arms the
+     * frame to blit the surviving band, and narrows the claim to the strip
+     * the shift exposed — which `paintDamage()` then hands to `paint`, so the
+     * existing culling draws the sliver and nothing else.
+     *
+     * The furniture — minimap, zoom controls — is pinned to the pane while
+     * its pixels would ride the blit, so its bands are carved out of the
+     * region that shifts and claimed as ordinary damage. The blit gate tests
+     * foreign claims against the *rect* (react-x11#309/#310), so a claim
+     * sitting edge to edge with it leaves the frame a blit: the middle of
+     * the pane is copied, the strips repaint with the new viewport, and the
+     * panels repaint in place.
+     *
+     * Still a full repaint when:
+     *  - the zoom moved (scaling is not a blit) or the shift is fractional —
+     *    every real pan gesture is whole pixels;
+     *  - mounted node bodies exist: they are core-owned siblings whose
+     *    gesture-time commits claim *inside* the rect every step, which
+     *    declines the blit anyway — bailing early skips the churn;
+     *  - the furniture bands would eat the pane (a tiny pane, or panels on
+     *    both the top and the bottom of a short one).
+     */
+    private _blitPan;
+    /** Zoom about a point that must not move — the pointer under a wheel, the
+     * pane's centre for a keyboard zoom. */
+    private _zoomAbout;
+    private _fit;
+    getViewport(): Viewport;
+    setViewport(viewport: Partial<Viewport>): void;
+    zoomIn(step?: number): void;
+    zoomOut(step?: number): void;
+    zoomTo(zoom: number): void;
+    fitView(options?: FitViewOptions): void;
+    setCenter(x: number, y: number, options?: {
+        zoom?: number;
+    }): void;
+    screenToFlowPosition(point: XYPosition): XYPosition;
+    flowToScreenPosition(point: XYPosition): XYPosition;
+    getNodeBounds(id: string): FlowRect | null;
+    getNodesBounds(ids?: readonly string[]): FlowRect | null;
+    private _emitNodes;
+    private _emitEdges;
+    /** Make this the selection. `additive` toggles instead, which is what
+     * Shift and Ctrl do everywhere else. */
+    private _select;
+    private _selectedNodeIds;
+    /** The topmost node under a window point, or null. Walks paint order
+     * backwards, which is what "topmost" means. */
+    private _nodeAt;
+    private _handleAt;
+    /**
+     * A resize grip under the point, if any. Tested *after* the connection
+     * handles: the two families both live on the border and a side-centred
+     * handle sits exactly on a side-centred grip, so one of them has to give
+     * way, and it should be the one whose corners are still reachable.
+     */
+    private _gripAt;
+    private _edgeAt;
+    /**
+     * A box the edge cannot leave, from its two nodes alone — no path built.
+     * Hover runs this over every edge on every pointer step, and building the
+     * real geometry to reject it would make motion cost what drawing does.
+     *
+     * The slack covers the two ways a route leaves the span between its nodes:
+     * a step edge by a fixed offset, a bezier by its shoulder, which grows as
+     * the square root of the gap (see `paths.ts`) — `8` where the shoulder
+     * uses `6.25`, so the bound is generous rather than tight.
+     */
+    private _edgeCoarseBox;
+    /** The drawn handle, in screen pixels. Capped as well as floored: a dot
+     * that scaled all the way up would be a saucer at 2.5×, and the thing it
+     * marks — a point on the border — does not get bigger. */
+    private _handleRadius;
+    private _connectable;
+    private _draggable;
+    /** Pick the handle an edge attaches to: the one it names, else the only
+     * one of the right type, else the one facing the other end. */
+    private _endpoint;
+    /** An edge's polyline, in **screen** pixels, plus the two ends it joins.
+     * Null when either end is missing — an edge to a node that was removed is
+     * a normal state during an edit, not an error. */
+    private _edgeGeometry;
+    private _centre;
+    private _corner;
+    private _controlsOptions;
+    private _controlButtons;
+    private _miniMapOptions;
+    /** The minimap panel and the graph-to-panel transform, or null when there
+     * is no minimap or nothing to put in it. */
+    private _miniMap;
+    private _miniToGraph;
+    private _miniToScreen;
+    defaultMouseDown(ev: MouseEvent): void;
+    defaultMouseDrag(ev: MouseEvent): void;
+    private _dragDispatch;
+    defaultMouseUp(ev: MouseEvent): void;
+    defaultContextMenu(ev: MouseEvent): void;
+    private _clickNode;
+    private _dragStep;
+    /** The box a resize is making, reported as it goes. A grip that moves the
+     * top or the left edge moves the node too, so both changes go out — an
+     * app that applied only one would watch the node crawl. */
+    private _resizeStep;
+    private _connectStep;
+    /** The pending connection's polyline — one builder for the paint and for
+     * the damage it has to claim, so the two cannot disagree. */
+    private _connectionPath;
+    private _validConnection;
+    private _selectBox;
+    /** Wheel: zoom about the pointer, or pan when zooming is off. The seam
+     * runs it after the app's own `onWheel` and not at all if that vetoed;
+     * consuming it here is what keeps the scroll chain out of the pane. */
+    defaultWheel(ev: WheelEvent): void;
+    private _wheelDispatch;
+    /** Pointer motion with no button down: hover highlighting. The seam skips
+     * delivery while a capture is in force, so the gesture guard is belt to
+     * its braces. */
+    defaultMouseMove(ev: MouseEvent): void;
+    defaultMouseLeave(): void;
+    /** What a hover state lights up on screen: the node (whose border and
+     * handles restyle), or the edge. Null when it points at nothing. */
+    private _hoverDamage;
+    /**
+     * The graph, described: every visible node as an item a screen reader
+     * can reach, name and activate. Edges ride on each node's description
+     * rather than as items of their own — "what is this connected to" is the
+     * useful question, and a hundred unlabelled `link` items between the
+     * nodes would only bury them.
+     *
+     * Called once per question an AT asks, so it answers from the entries the
+     * pane already holds — no measuring, no layout.
+     */
+    a11yScene(): A11ySceneItem[];
+    /**
+     * An AT activated a node: select it, the way a click would — but by id
+     * rather than by synthesizing a pointer at its rect, which would also
+     * arm a drag.
+     */
+    a11ySceneAction(id: string, action: A11ySceneAction): boolean;
+    defaultKeyDown(ev: KeyboardEvent): void;
+    private _keyDispatch;
+    private _selectAll;
+    /**
+     * Remove what is selected — and, with the nodes, the edges that would
+     * otherwise dangle. Emitted as changes like everything else, so an app
+     * that wants a confirmation step simply does not apply them.
+     */
+    private _deleteSelection;
+    applyProps(nextProps: Record<string, unknown>, prevProps: Record<string, unknown>): void;
+    destroySubtree(): void;
+    private _startAnimation;
+    private _stopAnimation;
+    paint(ctx: Context2D): void;
+    /**
+     * Where every mounted node body belongs, relative to the pane's own
+     * top-left. Sent only when the list changed, so a repaint that moved
+     * nothing does not re-render React — but a pan does, once per frame,
+     * which is the cost `render` is documented to carry.
+     */
+    private _emitBodies;
+    /** The grid, drawn only inside `region` — the pass's damage on a partial
+     * repaint, the pane on a full one. Alignment stays anchored to the
+     * viewport origin, so the region never changes where a dot falls. */
+    private _paintGrid;
+    /**
+     * The grid as one repeating fill (ntk#263): a step-sized tile drawn once,
+     * a `createPattern('repeat')` over it, and one composite for the whole
+     * region — where the runs path pays a region-sized coverage mask.
+     *
+     * Two decisions with reasons:
+     *
+     * - **Integral device steps only.** The tile is a pixmap, so its size is
+     *   whole pixels; at a fractional step the pattern would drift against
+     *   the graph's own coordinates — against `snapToGrid`, against node
+     *   positions — by a fraction per tile, and a grid that slides under the
+     *   content it grids is worse than a slower exact one.
+     * - **The phase lives in the tile, not in a picture transform.** An
+     *   untransformed repeat is anchored to the window origin, so the grid's
+     *   alignment is baked in by drawing the mark at `origin mod tile` — and
+     *   re-baking when the origin moves. A `setTransform` translate says the
+     *   same thing in one request, but a *transformed* repeat forfeits the
+     *   server's untransformed fast path — on the in-process test server
+     *   that was ~180 ms a frame of per-pixel arithmetic, and re-rendering a
+     *   24px tile is a handful of requests on any server.
+     */
+    private _paintGridPattern;
+    private _makeGridSurface;
+    /** Draw one grid cell with the mark at the phase point, wrapped — a mark
+     * near an edge is drawn again a tile over, so the seam never cuts it. */
+    private _renderGridTile;
+    private _dropGridTile;
+    /** Draws every visible edge; answers whether any of them is animated, so
+     * the caller knows whether to keep a timer alive. */
+    private _paintEdges;
+    /** An arrowhead's three or four points, added to the pile for its colour
+     * rather than drawn — see {@link StrokeBuckets} for why. */
+    private _collectMarker;
+    private _paintNodes;
+    private _paintNode;
+    private _mounted;
+    private _paintGrips;
+    /** The built-in node: a card with a label, an optional second line and an
+     * optional accent stripe down its leading edge. */
+    /** The card itself: one rounded box, and the accent stripe if it has one.
+     * With a `batch` the box joins the pile for its appearance instead of
+     * being drawn on its own. */
+    private _paintCardShape;
+    /** The label and its second line — the half of a card that has to come
+     * after every card when they are batched. */
+    private _paintCardInk;
+    /**
+     * Handles are drawn one disc at a time, and that is the measured answer
+     * rather than the obvious one.
+     *
+     * Batching them into a single path halved the requests and made the frame
+     * *slower*: a path's mask is its bounding box, so forty dots scattered
+     * across the pane rasterize to a paneful of mask — three quarters of a
+     * megabyte — where forty small ones cost a kilobyte each. Batching pays
+     * for the edges because an edge already spans that box; it does not pay
+     * for anything small and scattered.
+     */
+    private _paintHandles;
+    private _paintConnection;
+    private _paintSelectionBox;
+    private _paintMiniMap;
+    private _paintControls;
+}
+export {};
+//# sourceMappingURL=node.d.ts.map

package/dist/flow/node.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"node.d.ts","sourceRoot":"","sources":["../../src/flow/node.ts"],"names":[],"mappings":"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"}