edytor 1.0.0-rc.2 → 1.0.0

package/dist/plugins/blockHandles/BlockHandleController.svelte.d.ts

@@ -1,10 +1,10 @@
 import type { Block } from '../../block/block.svelte.js';
 import type { Edytor } from '../../edytor.svelte.js';
-import { type BlockHandlesLabels } from '../../labels.js';
 import type { Popup, PopupOpener } from '../../surface/popups.svelte.js';
+import type { Attachment } from 'svelte/attachments';
 /**
- * The DOM event a handle click dispatches on the editor when no `onActivate`
- * is set. A menu that takes the keyboard answers it with `preventDefault()`
+ * The DOM event a grip click dispatches on the editor (the one way to
+ * answer it: the block menu's, or your own). A menu that takes the keyboard answers it with `preventDefault()`
  * (the block menu does); unanswered, the editor takes the focus, so the keys
  * act on the selected block (Backspace deletes it, Shift+arrows extend it).
  */
@@ -36,10 +36,9 @@ export type BlockAddition = {
 };
 type BlockHandleControllerOptions = {
     draggable: boolean;
-    onActivate?: (activation: BlockActivation) => void;
-    labels?: BlockHandlesLabels;
 };
 export declare class BlockHandleController {
+    #private;
     private edytor;
     private options;
     private readonly owner;
@@ -63,8 +62,6 @@ export declare class BlockHandleController {
     constructor(edytor: Edytor, options?: BlockHandleControllerOptions);
     get readonly(): boolean;
     get draggable(): boolean;
-    /** The words the handles say (the plugin's `labels`): read them in a custom `handle`. */
-    get labels(): BlockHandlesLabels;
     /**
      * The block's kind as people read it (`kindLabel`: "Heading 1"), its
      * handle's name; reactive through the block's cell (a Turn into renames it).
@@ -73,18 +70,17 @@ export declare class BlockHandleController {
     /** The popup the `+` or the grip of `block` opened, while it is open (`edytor.popups`). */
     opened: (block: Block, control: PopupOpener["control"]) => Popup | undefined;
     /**
-     * Make `node` the block's grip: dragging (when draggable), a click that
-     * selects the block and opens its menu, and the Alt+arrow moves.
+     * The block's grip (`{@attach handle.grip}`): dragging (when draggable),
+     * a click that selects the block and opens its menu, the Alt+arrow moves
+     * (`aria-keyshortcuts`), and the ARIA of the menu it opened.
      */
-    grip: (block: Block) => (node: HTMLElement) => {
-        destroy: () => void;
-    };
+    grip: (block: Block) => Attachment<HTMLElement>;
     /**
-     * Select the block — a block selection holding it stays; over a text
-     * range across blocks, the blocks it covers (`select`) — and open its
-     * menu.
+     * The block's `+` (`{@attach handle.plus}`): a click offers what to add
+     * below (Alt+click above, or a column beside: `addBlock`) under it; a
+     * press keeps the editor's focus; the ARIA of the menu it opened.
      */
-    activateBlock(block: Block, anchor: HTMLElement): void;
+    plus: (block: Block) => Attachment<HTMLElement>;
     /**
      * Whether the `+`'s Alt+click on `block` adds a column right of its
      * column (a block directly in a layout's column, as Notion) rather than a
@@ -101,86 +97,64 @@ export declare class BlockHandleController {
      * (`moveBlocks`, `right`: `layout.place-beside`), in the same transaction.
      */
     addBlock(block: Block, alt?: boolean, anchor?: HTMLElement | null): void;
-    /**
-     * A `+` while the block selection a grip click made still stands (its
-     * menu open, or closed leaving it, a divider's): that selection was the
-     * menu's, so the selection held before the grip comes back — for none,
-     * or a caret whose place is gone, a caret at the start of the grip
-     * block's first line — and the `+` holds that one (its menu's Escape
-     * gives it back).
-     */
-    private ungrip;
-    registerHandle(element: HTMLElement, block: Block): import("@atlaskit/pragmatic-drag-and-drop/dist/types/internal-types.js").CleanupFn;
+    registerHandle(element: HTMLElement, block: Block): () => void;
     /** A candidate drop target; registered at once when our drag is in progress. */
     addDropTarget(node: HTMLElement, target: Block): () => void;
-    private registerDropTarget;
-    /**
-     * The editor's margins (Notion): during our drag, the page (`body`) is a
-     * drop target only where `margin` gives a placement — the handle column
-     * left of the blocks (a reorder of the row there), the page margin beyond
-     * it and the one right of the editor (beside bands), within a row's
-     * height — so a row is reached from outside it too, row after row;
-     * anywhere else the block targets (and their stickiness) stand.
-     */
-    private registerMarginTarget;
     /**
-     * The editor's left gutter: where its blocks' text starts (the root's
-     * content box), and the width of the handle column left of it (the drag's
-     * handle, measured: `+`, grip and the gap to the block).
+     * The editor's content column (`start`…`end`, the root's content box:
+     * where its blocks' boxes start and end), the width of the handle column
+     * left of it (the drag's handle, measured: `+`, grip and the gap to the
+     * block) and how far the drag reaches past them (`dropReach`, the
+     * `--edytor-drop-reach` the root inherits).
      */
     private gutter;
-    /** Whether `x` is in the handle column left of the editor's blocks (`gutter`): the page target's. */
-    private inHandleColumn;
     /**
-     * A placement in the editor's margins at the pointer, for the row the
-     * editor's near edge shows at the pointer's height (`rowAt`: a column's
-     * block, a nested block's own row):
-     * - in the handle column left of the blocks (`gutter`), that row's
-     *   reorder (`reorder`): a drag straight down the handles reorders, row
-     *   after row, gaps included (never a beside band);
-     * - beyond it (up to `MARGIN_X`), the band left of that row;
-     * - right of the editor (up to `MARGIN_X`), the band right of it;
-     * the bands are `beside`'s, as if the pointer were at that edge, only
-     * when the document has a layout kind. `undefined` elsewhere.
+     * A placement in the editor's margins at the pointer (`dnd.reach`), within
+     * the editor's height, for the row the content's near edge shows at the
+     * pointer's height (`rowAt`: a nested block's own row; over a layout, the
+     * row of its first column on the left, of its last on the right, never
+     * another), by the zone the pointer is in (`marginAt`):
+     * - the handle column left of the blocks (`gutter`): that row's reorder
+     *   (`reorder`): a drag straight down the handles reorders, row after
+     *   row, gaps included (never a beside band);
+     * - the first `BESIDE_MARGIN` px past it on the left, and past the
+     *   content's right edge: the beside band of that side (`beside`, as if
+     *   the pointer were at that edge) when the document has a layout kind
+     *   and the row offers one (a refused band shows nothing);
+     * - elsewhere within the reach (and there without a band): the reorder,
+     *   on the left the handle column's, on the right the one the row's
+     *   right edge offers (its halves as just inside the content, so nothing
+     *   jumps as the pointer leaves it).
+     * `undefined` past the reach, above or below the editor, and inside the
+     * content (the blocks' own targets answer there).
      */
     private margin;
     /**
-     * The handle column's reorder over `row` at the pointer: the hitbox's
-     * halves as its own drop target gives them (`zones`, the pointer's x
-     * picking the level), its own row's top half before, the bottom half
-     * after, only before or after a block — never inside one; `null` when
-     * neither half fits. Over an item of a container the dragged blocks do not
-     * fit in (a paragraph over a list's item: the document refuses every
-     * placement at the item's level), the container is the row: its whole box,
-     * the upper half before it, the lower half after it (round 4), so a drag
-     * down the handles meets the list as one row it can pass.
+     * The halves of `row` (`zones`) at the pointer, the one it is in first:
+     * the top half of `rect` (its own row by default) before, the bottom one
+     * after; with `plain`, only before or after a block — never inside one.
      */
-    private reorder;
+    private halves;
     /**
-     * Alt+arrow: one step for the blocks a drag of this handle moves. A text
-     * range over them stays, as Mod+Shift+arrow keeps it; else they end
-     * selected as after a drop (`moveAndSelect`).
+     * The first placement of `halves` the document takes (a refused one gives
+     * way to the next, then to the other half's), `blocked` when the first
+     * half took none; `null` when none fits.
      */
-    handleKeyDown(event: KeyboardEvent, block: Block): void;
+    private pick;
     /**
-     * Move, then select what moved — the drag's rule (`onDragStart`): a group
-     * the block selection holds keeps it (a moved block's selected children
-     * too); any other group ends selected alone.
+     * The handle column's reorder over `row` at the pointer: its plain halves
+     * (`halves`, the pointer's x picking the level); `null` when neither half
+     * fits. Over an item of a container the dragged blocks do not fit in (a
+     * paragraph over a list's item: the document refuses every placement at
+     * the item's level), the container is the row: its whole box, the upper
+     * half before it, the lower half after it (round 4), so a drag down the
+     * handles meets the list as one row it can pass.
      */
-    private moveAndSelect;
-    private canDrop;
+    private reorder;
     /** The blocks a drop of `source` moves: the drag's own group, fixed when it started. */
     private moving;
-    /**
-     * The blocks the selection covers — a block selection's blocks as
-     * clicked (a selected list is one block: its item's handle drags the
-     * item), or the blocks a text range spans (`getSelectionBlocks`, the
-     * resolver Tab and Turn into read), a code line as its code block
-     * (`movable`) — when `source` is one of them; else `source` alone.
-     */
+    /** The blocks the selection covers when `source` is one of them, else `source` alone. */
     private covered;
-    /** Whether a text range (no block selection) covers `source` (`covered`). */
-    private inRange;
     /**
      * The blocks a drag (or an Alt+arrow) from `source`'s handle moves
      * (Notion): the outermost of those the selection covers (`covered`), in
@@ -196,12 +170,6 @@ export declare class BlockHandleController {
     private select;
     /** Whether the drag of `source` may land at a placement. */
     private fits;
-    /**
-     * The hitbox's operations over `row` for our drag: reorder-before and
-     * reorder-after, each `blocked` when the document refuses every
-     * placement of that half (`zones`), none outside our drag.
-     */
-    private operations;
     /**
      * The block whose row the pointer is on over `node`: the last shown drop
      * target in it whose row starts at or above the pointer (beside a nested
@@ -221,11 +189,6 @@ export declare class BlockHandleController {
     private besideOf;
     /** The item (and its layout) a beside placement at `outer` (`besideOf`) adds a column beside. */
     private layoutOf;
-    /**
-     * Whether `x` is over a column other than one holding `block`: a sticky
-     * target never holds the pointer across a column boundary.
-     */
-    private overOtherColumn;
     /**
      * Notion's beside bands over `row` (`docs/columns-plan.md`, "View layer"), only while the
      * pointer is within its own row's height, the document has a layout kind
@@ -269,17 +232,20 @@ export declare class BlockHandleController {
      *   moves only its children (they would stay where they are).
      * None over a dragged block's own row or its subtree: released there, the
      * drag changes nothing (its levels would outdent it) — unless it empties
-     * its parent's shown children (`emptied`): that parent's row.
+     * its parent's shown children (`emptied`): that parent's row. Over the
+     * hint of the row's empty body (`body.hint`: an open toggle's, a
+     * callout's), inside it first, either half.
      */
     private zones;
     /**
-     * The placement a drop target record offers: a beside band of the row
-     * first (`beside`; `false` when the document refuses it: nothing shows),
-     * else the row and the half the hitbox attached (kept while the target is
-     * sticky), the pointer live.
+     * The placement a drop target record offers: the page's margins
+     * (`margin`), else a beside band of the row first (`beside`; `false` when
+     * the document refuses it: nothing shows), else the row's halves, the one
+     * the record took first (held while the target is sticky), the pointer
+     * live.
      */
     private placement;
-    private getDragSource;
-    private showIndicator;
+    /** The dragged block that is `row` or holds it: its row offers nothing (it moves with the drag). */
+    private carrier;
 }
 export {};