edytor 1.0.0-rc.3 → 2.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;
@@ -54,6 +53,8 @@ export declare class BlockHandleController {
     private group;
     /** The drop bar and the nest backdrop in the overlay, while our drag runs. */
     private readonly indicator;
+    /** Where a drop lands (the one resolution a file drag reads too). */
+    private readonly drop;
     /** The selection the drag in progress replaced when it started: its undo step restores it. */
     private held;
     /** The handle the drag in progress started from: its width is the handle column's. */
@@ -63,8 +64,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 +72,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,105 +99,13 @@ 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, `dnd.reach`): during our drag, the page
-     * (`body`) is a drop target only where `margin` gives a placement — the
-     * handle column left of the blocks, the page margin past it and the one
-     * right of the content, up to the drop reach, within the editor's height
-     * (a beside band nearest the content, else the row's reorder) — so a row
-     * is reached from outside it too, row after row; anywhere else the block
-     * targets (and their stickiness) stand, and a block target holding the
-     * pointer (its sticky slop) answers before the page.
-     */
-    private registerMarginTarget;
-    /**
-     * 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 (`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 (`atRightEdge`).
-     * `undefined` past the reach, above or below the editor, and inside the
-     * content (the blocks' own targets answer there).
-     */
-    private margin;
-    /**
-     * Right of the content, the placement the row offers at its own right
-     * edge (`zones` there, by its own row's halves, as its drop target's
-     * hitbox splits it): the same before, after or inside as just inside the
-     * content, so nothing jumps as the pointer leaves it; `null` when no
-     * placement fits.
-     */
-    private atRightEdge;
-    /**
-     * 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.
-     */
-    private reorder;
-    /**
-     * 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`).
-     */
-    handleKeyDown(event: KeyboardEvent, block: Block): void;
-    /**
-     * 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.
-     */
-    private moveAndSelect;
-    private canDrop;
     /** 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
@@ -213,94 +119,13 @@ export declare class BlockHandleController {
      * else `source`.
      */
     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
-     * block, over its ancestors' indent, the pointer is on that block's
-     * row), else `target`, over its own row (`emptied`). A layout's columns
-     * sit side by side: only the one under the pointer is measured (between
-     * two of them, the layout is the row: its gap).
-     */
-    private rowAt;
-    /** Whether the document has a layout kind: only then are there beside placements. */
-    private get layouts();
-    /**
-     * The block a beside placement over `block` stands beside: the document's
-     * own resolution (`facade.besideAt`, `placeBeside`'s): a list item's list,
-     * a code line's code block, a toggle's child itself, an item itself.
-     */
-    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
-     * and the layout the drop makes or grows does not stack (`stacks`):
-     * - right: the row's last 15% (at least 32px), and the slop past it;
-     * - left: the slop left of the row (its sticky margin, left of its text
-     *   column), only for a row whose parent is the root or a column (a
-     *   list's item: its list's) — a nested row keeps the pointer's x for its
-     *   levels (`zones`) — and only
-     *   inside the editor (a column's gap): left of the editor's blocks is the
-     *   handle column, which reorders (`margin`);
-     * - over a layout's gap (the row is the layout): right of the column
-     *   before it, a new column between.
-     * `undefined` outside the bands (the hitbox's halves stand), else the
-     * placement, or `null` when the document refuses it: a refused band shows
-     * nothing.
-     */
-    private beside;
-    /** Where the editor's blocks start (`gutter`), or `fallback` without a host. */
-    private inside;
-    /** The children a block shows: none for a closed toggle's, or a container's items. */
-    private shown;
-    /**
-     * Over a dragged block, the parent it leaves when that parent shows no
-     * other child: the gap under the parent's own row, which reparents as
-     * the parent's lower half does (`zones`). Else `row`.
-     */
-    private emptied;
-    /**
-     * The placements over `row`, each half's in preference order (a refused
-     * one gives way to the next, then to the other half's):
-     * - the top half: before it;
-     * - the bottom half of a block whose children show (not a closed toggle):
-     *   its first child's slot. Pragmatic drag and drop's tree rule: an
-     *   expanded item offers no "after" on its own row;
-     * - else, after it at the level whose text column is nearest the pointer:
-     *   the last block of a nested group reparents to any ancestor it ends,
-     *   down to the root. Past one nesting step right of its text start,
-     *   inside it (its last child) first. A block every shown child of which
-     *   is dragged is not expanded: its levels, never inside it when the drag
-     *   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. 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;
 }
 export {};