@motifx-community/ui 0.0.0-stage → 0.1.0-beta.0

package/dist/components/tabdocs/TabDrag.d.ts

@@ -0,0 +1,76 @@
+import type { TabDocumentManager } from './TabDocumentManager';
+import type { TabDragSubject } from './tab-drag-subject';
+import type { TabDropPlace } from './tab-drop-place';
+import type { TabDropTarget } from './tab-drop-target';
+/**
+ * Dragging in a manager: a tab, or a whole group by its empty bar, with the mouse, or after a long
+ * press on a touch screen or with a pen. A copy of the tab follows the pointer; the manager under it
+ * (this one, or one of the same `dragGroup`) shows where a drop would land. "Move to…" uses the same
+ * session from the keyboard. Inside a new browser window it works the same; the pointer stays with
+ * a drag that leaves its window, and the window under it there (its place on the screen says which)
+ * takes the drop, or past every window a new one opens there.
+ */
+export declare class TabDrag {
+    private readonly manager;
+    private press;
+    private session;
+    private readonly ghost;
+    private readonly stops;
+    constructor(manager: TabDocumentManager);
+    /** Drags start from the strips under `root`: the manager's element, or a new window's. Returns the function that stops it. */
+    listen(root: HTMLElement): () => void;
+    /** A touchmove in a bar: once a long press drags, the finger moves the tab, not the strip or the page. */
+    holdTouch(e: TouchEvent): void;
+    /** What is being dragged now. */
+    get subject(): TabDragSubject | null;
+    /** Starts a drag: `onDragStarting` may cancel it. */
+    begin(subject: TabDragSubject, pointerType: string, source: HTMLElement | null, x?: number, y?: number, pointerId?: number, space?: Document): boolean;
+    /** Aims at a place (from a target, or chosen by the keys): `onDragOver` may change or refuse it. */
+    aim(place: TabDropPlace | null, target: TabDropTarget | null): boolean;
+    /** Ends the drag: drops where it aims (`onDropping` may stop it), or puts everything back. */
+    finish(drop: boolean, quiet?: boolean): boolean;
+    /** Stops a drag (or a press that may become one); `quiet` says nothing. */
+    cancel(quiet?: boolean): void;
+    private pointerDown;
+    /** The document of a tab, or the group of an empty bar, that a press there would drag. */
+    private subjectAt;
+    private longPress;
+    /** The press became a drag: by moving past the threshold (`e`), or by a long press. */
+    private start;
+    private pointerMove;
+    private pointerUp;
+    private key;
+    /** The pointer moved, or the copy key changed: aim again, hover, scroll the strip. */
+    private track;
+    /**
+     * The place under the pointer: the targets of the manager it is over (or of the manager of the
+     * floating window it is over: windows lie above everything), else floating, else outside. Past
+     * the edge of its window, the point is looked for in the other windows, by its place on the
+     * screen; past every one, it is a new window there (or, from a new window, the main window).
+     */
+    private find;
+    /** The window whose viewport holds a point of the screen (the one focused last, where they lie on each other), and the point in it. */
+    private windowAt;
+    /** Past the edge of every window: into a new window there, or from a new window back to the main window. */
+    private outPlace;
+    /** The managers a drag may drop in: those of its `dragGroup`; a window moved stays with its own. */
+    private peers;
+    /** The manager under a point: the one of the front window there, else the one whose box holds it; in a new window, its manager. */
+    private managerAt;
+    private targetFor;
+    private args;
+    /** Shows the marks where the drag aims, in the manager it aims at, and what a drop would do. */
+    private paint;
+    /** Resting on a tab of another group activates it after `dragHoverDelay`. */
+    private hover;
+    private hoverActivate;
+    /** Near the ends of a strip that does not fit, the strip scrolls, faster the nearer the end. */
+    private autoScroll;
+    private rowAt;
+    /** Canceled: what hovering activated and the strips scrolling moved go back, and a window moved. */
+    private putBack;
+    private copyHeld;
+    /** The click that follows a drop is not a click on the tab; the next press is a press again. */
+    private swallowClick;
+    private release;
+}

package/dist/components/tabdocs/TabGroup.d.ts

@@ -0,0 +1,156 @@
+import { type Bind } from '@motifx/core';
+import { FocusContainer } from '../../core/container';
+import type { MenuItem } from '../../parts/menu/menu-item';
+import type { DocumentTab } from './DocumentTab';
+import type { SplitDirection } from './split-direction';
+import type { TabBrowserWindow } from './TabBrowserWindow';
+import type { TabDockArea } from './TabDockArea';
+import type { TabDocument } from './TabDocument';
+import type { TabDocumentManager } from './TabDocumentManager';
+import type { TabDropSide } from './tab-drop-side';
+import type { TabOpenOptions } from './tab-open-options';
+import type { TabSplit } from './TabSplit';
+import type { TabWindow } from './TabWindow';
+/**
+ * A group of a `TabDocumentManager`: a strip of tabs and the active document's content under it.
+ * The manager makes and closes groups (`split`, `closeGroup`); a group is a container, so focus
+ * comes back to where it was when the group is focused again. Pinned tabs come first, in a row of
+ * their own when the manager says so.
+ */
+export declare class TabGroup extends FocusContainer<HTMLDivElement> {
+    constructor(manager: TabDocumentManager);
+    get manager(): TabDocumentManager;
+    /** The documents, in strip order: the pinned ones first. Reactive. */
+    get documents(): readonly TabDocument[];
+    /** Reactive. */
+    get activeDocument(): TabDocument | null;
+    /** The documents, the one used last first. Reactive. */
+    get recentDocuments(): readonly TabDocument[];
+    /** The preview document, if the group has one. Reactive. */
+    get previewDocument(): TabDocument | null;
+    /**
+     * A locked group takes no documents opened without naming it. Set it through `lock()` and
+     * `unlock()` to be asked and told. Reactive.
+     */
+    get locked(): boolean;
+    set locked(value: Bind<boolean>);
+    /** Dragged documents and groups may be dropped into it and beside it. Default `true`. Reactive. */
+    get allowDrop(): boolean;
+    set allowDrop(value: Bind<boolean>);
+    /** Where a drop on its content may go, over the manager's `dropSides`; `null` follows the manager. Reactive. */
+    get dropSides(): readonly TabDropSide[] | null;
+    set dropSides(value: Bind<readonly TabDropSide[] | null>);
+    /** Whether it is the manager's active group. Reactive. */
+    get isActive(): boolean;
+    /** Reactive. */
+    get isMaximized(): boolean;
+    get isEmpty(): boolean;
+    /** The floating window it is in, `null` elsewhere. Reactive. */
+    get window(): TabWindow | null;
+    /** The dock area it is in, `null` elsewhere. Reactive. */
+    get dockArea(): TabDockArea | null;
+    /** The new browser window it is in, `null` in the main window. Reactive. */
+    get browserWindow(): TabBrowserWindow | null;
+    /** Its place in the manager's `groups`, from 0. Reactive. */
+    get index(): number;
+    /** How many of its tabs are not fully in sight in the strip now. Reactive. */
+    get hiddenTabCount(): number;
+    open(document: TabDocument, options?: Omit<TabOpenOptions, 'group'>): TabDocument | null;
+    activate(document: TabDocument, focus?: boolean): boolean;
+    closeAll(): Promise<boolean>;
+    /** Closes its documents, then the group. */
+    close(): Promise<boolean>;
+    split(direction: SplitDirection, document?: TabDocument): TabGroup | null;
+    maximize(): boolean;
+    lock(): boolean;
+    unlock(): boolean;
+    /** Makes it the active group and focuses what had focus in it last. */
+    focus(): boolean;
+    protected get focusElement(): HTMLElement;
+    /** @internal */
+    get tabs(): readonly DocumentTab[];
+    /** @internal */
+    get activeTab(): DocumentTab | null;
+    /** @internal */
+    get recentTabs(): readonly DocumentTab[];
+    /** @internal */
+    get parentSplit(): TabSplit | null;
+    set parentSplit(split: TabSplit | null);
+    /** @internal The tab list. */
+    get listElement(): HTMLDivElement;
+    /** @internal The strip and the toolbar. */
+    get barElement(): HTMLDivElement;
+    /** @internal The row of the tabs that are not pinned: it scrolls. */
+    get rowElement(): HTMLDivElement;
+    /** @internal Where the content shows. */
+    get panelsElement(): HTMLDivElement;
+    /** @internal Whether its bar keeps only some buttons and has one "…" menu for the rest and the documents. Reactive. */
+    get isCompact(): boolean;
+    /** @internal In a compact bar: the buttons not in the toolbar, as items of the "…" menu; the built-in ones first. */
+    foldedItems(): MenuItem[];
+    /** @internal Whether drops are allowed now. */
+    get acceptsDrop(): boolean;
+    /** @internal The sides a drop on the content may take now: the group's own, else the manager's. */
+    get dropSidesNow(): readonly TabDropSide[];
+    /** @internal The "…" button, while it is shown (not folded into the toolbar's menu). */
+    get moreButton(): HTMLElement | null;
+    /** @internal Puts a tab (and its panel) in at `index`; pinned tabs stay first. */
+    addTab(tab: DocumentTab, index: number): void;
+    /** @internal Takes a tab out without disposing it; the manager has chosen the next active one. */
+    removeTab(tab: DocumentTab): void;
+    /** @internal Moves a tab to `index` in the strip; pinned tabs stay first. */
+    moveTab(tab: DocumentTab, index: number): void;
+    /** @internal How many tabs are pinned (they are the first ones). */
+    pinnedCount(): number;
+    /** @internal Puts the pinned tabs first, keeping each side's order, and the headers where they belong. */
+    arrange(): void;
+    /**
+     * @internal The headers where they belong: the pinned ones in their row, the others in theirs. On
+     * a tablet a group shown for others folded into it holds their headers too, before and after its own.
+     */
+    placeHeaders(): void;
+    /** @internal Shows a tab's panel and hides the one shown before. */
+    showTab(tab: DocumentTab | null): void;
+    /** @internal Where the manager has put it: a floating window, a dock area, a new window, or among the documents; `title`: its strip is the floating window's title. */
+    placeIn(window: TabWindow | null, area: TabDockArea | null, title: boolean, browser?: TabBrowserWindow | null): void;
+    /** @internal */
+    markActive(on: boolean): void;
+    /** @internal */
+    markMaximized(on: boolean): void;
+    /** @internal The texts that carry the group's number. */
+    renderTexts(number: number): void;
+    /** @internal The tab whose header holds `target`. */
+    tabOf(target: EventTarget | null): DocumentTab | undefined;
+    /** @internal Whether `target` is on the group's drag handle. */
+    isGrip(target: EventTarget | null): boolean;
+    /** @internal Whether `target` is the strip's empty room: in the bar, not on a tab or a toolbar button. */
+    isStripSpace(target: EventTarget | null): boolean;
+    /** @internal Scrolls the strip, not the page, so that a tab is in sight. */
+    reveal(tab: DocumentTab): void;
+    /** @internal The roving tab stop: the active tab. */
+    renderRoving(): void;
+    /** @internal Puts the recently used order back, as `saveLayout` wrote it. */
+    restoreRecent(order: readonly number[]): void;
+    /** @internal */
+    disposeTabs(): void;
+    /** @internal Shows the scroll buttons when the tabs do not fit, each dimmed at its end. */
+    queueOverflow(): void;
+    private renderOverflow;
+    /** The thin scrollbar: along the tabs that scroll, its thumb as long as the share in sight. */
+    private placeThumb;
+    /** The thumb is dragged: the strip follows, as far as the tabs go for each pixel of the track. */
+    private dragThumb;
+    /** What its bar follows now: its dock area's or window's own settings, else the manager's (`compact…` there). Reactive. */
+    private look;
+    /** `close`: the bar has a close button of its own, so a title shows none. */
+    private renderLook;
+    /** The name of the "…" button: the documents, or the documents and the commands, and how many tabs are out of sight. */
+    private moreText;
+    private scrollBy;
+    /** The app's buttons, made again only when `toolbarItems` is another function. */
+    private appItems;
+    private changed;
+    private get parts();
+    private createParts;
+    private listen;
+}

package/dist/components/tabdocs/TabMenus.d.ts

@@ -0,0 +1,34 @@
+import type { MenuItem } from '../../parts/menu/menu-item';
+import { ContextMenu } from '../contextmenu/ContextMenu';
+import type { TabDocument } from './TabDocument';
+import type { TabDocumentManager } from './TabDocumentManager';
+import type { TabGroup } from './TabGroup';
+/**
+ * The context menus of a manager: one for a tab, one for the empty strip. Built each time one
+ * opens, for that document and group; the manager's `onContextMenuOpening` may change them. A new
+ * browser window has a menu of its own: its events do not reach the manager's element.
+ */
+export declare class TabMenus {
+    private readonly manager;
+    readonly menu: ContextMenu;
+    private readonly others;
+    /** The action sheet a phone shows a document's commands in (from its title, or its row in the list). */
+    private sheet;
+    constructor(manager: TabDocumentManager);
+    /** Gives the strips under `root` (a new window's) the menus; returns the function that takes them off. */
+    attach(root: HTMLElement): () => void;
+    /** The menu that opens on `el`. */
+    menuFor(el: Element): ContextMenu;
+    private create;
+    /** The items of a tab's menu. */
+    forTab(doc: TabDocument, group: TabGroup): MenuItem[];
+    /** Float, dock back, dock to each side, auto hide: for a document, a group or (in a window) the window. */
+    private dockEntries;
+    /** The items of the empty strip's menu. */
+    forStrip(group: TabGroup): MenuItem[];
+    /** A document's commands in an action sheet, asking `onContextMenuOpening` first as a tab's menu does. */
+    openSheet(doc: TabDocument, group: TabGroup, byKeyboard: boolean, returnFocus: HTMLElement | null): boolean;
+    dispose(): void;
+    private build;
+    private opening;
+}

package/dist/components/tabdocs/TabPresenter.d.ts

@@ -0,0 +1,105 @@
+import type { DocumentTab } from './DocumentTab';
+import type { TabDockArea } from './TabDockArea';
+import type { TabDocument } from './TabDocument';
+import type { TabDocumentManager } from './TabDocumentManager';
+import type { TabGroup } from './TabGroup';
+import type { TabPresentationKind } from './tab-presentation-kind';
+/**
+ * How a manager shows its layout on a tablet and a phone; on a desktop it does nothing. The layout
+ * (groups, splits, dock areas, windows) stays as it is and saves the same: only where things are
+ * shown changes, and content is moved, never made again.
+ *
+ * - Tablet: at most two groups side by side, the others folded as tabs into the group beside them;
+ *   dock areas in drawers from their edge (the bottom one in a sheet), opened from the titles along
+ *   that edge; floating windows in large sheets.
+ * - Phone: one document, full screen, with its title, its close button and the number of open
+ *   documents above it (a full-screen list of them); dock tools in a bar at the bottom that opens
+ *   them in sheets; floating windows in full-screen sheets; the browser's back closes what is open,
+ *   then goes back through the documents.
+ */
+export declare class TabPresenter {
+    private readonly manager;
+    kind: TabPresentationKind;
+    private slots;
+    /** For each group shown on a tablet: the headers of the groups folded into it, before and after its own. */
+    private guests;
+    private readonly overlays;
+    private bar;
+    private tools;
+    private list;
+    /** The browser's back going back through the documents, on a phone. */
+    private releaseBack;
+    /** The manager's events this presentation follows while it is not a desktop. */
+    private listening;
+    private rendering;
+    /** Going back through the documents: the tools passed on the way do not come up. */
+    private travelling;
+    /** A drawing asked for, or under way: more asks are not needed. */
+    busy: boolean;
+    /** Counts the changes of the folded groups, for readers that follow them. */
+    private readonly folding;
+    constructor(manager: TabDocumentManager);
+    /** The document a phone shows: the active one among the documents, else the last one used there. */
+    get phoneDocument(): TabDocument | null;
+    /** The documents a phone's list and title swipes go through, in layout order: the documents' groups, then each window's. */
+    listDocuments(): TabDocument[];
+    /** The groups of the phone's list: the documents' first, then the floating windows'. */
+    listGroups(): TabGroup[];
+    /** Shows the layout the way `kind` says; what the one before had moved goes back first. */
+    apply(kind: TabPresentationKind): void;
+    /** Puts everything where this presentation shows it; called whenever the layout or the active document changes. */
+    render(): void;
+    /** Whether a group's strip shows the tabs of groups folded into it. Reactive. */
+    hasGuests(group: TabGroup): boolean;
+    /** Whether a group is folded into the one shown beside it on a tablet. */
+    isFolded(group: TabGroup): boolean;
+    /** Draws again once what is going on now is over (a microtask later); asks made meanwhile make one drawing. */
+    renderSoon(): void;
+    /** Every change of documents and layout draws the presentation again. */
+    private listen;
+    /** The headers shown in a group's strip besides its own, on a tablet. */
+    guestsOf(group: TabGroup): {
+        before: HTMLElement[];
+        after: HTMLElement[];
+    } | null;
+    /** The tabs of the strip `tab` is shown in, in their order there (on a tablet, with those folded in). */
+    stripOrder(tab: DocumentTab): DocumentTab[];
+    /** A document was activated: on a tablet or a phone, the drawer, the sheet or the window it is in opens. */
+    reveal(doc: TabDocument): boolean;
+    /** The drawer or sheet a dock area or a floating window is shown in now (made when it is first needed). */
+    private overlayOf;
+    /** Opens a dock area's tool (from its title on a tablet's edge, from the phone's tool bar). */
+    showTool(doc: TabDocument): boolean;
+    /** Closes a dock area's drawer or sheet. */
+    hideTool(area: TabDockArea): boolean;
+    /** Whether a dock area's drawer or sheet is open now. */
+    isToolOpen(area: TabDockArea): boolean;
+    /** How a dock area shows in this presentation. */
+    dockMode(area: TabDockArea): 'sheet' | 'drawer' | 'hidden';
+    /** How a dock area shows on a tablet or a phone: its own setting, else the manager's. */
+    dockModeFor(area: TabDockArea, kind: 'tablet' | 'phone'): 'sheet' | 'drawer' | 'hidden';
+    /** Opens the phone's list of documents. */
+    showList(): boolean;
+    hideList(): boolean;
+    get listOpen(): boolean;
+    /** The manager is going away: what this presentation made goes too; nothing is put back. */
+    dispose(): void;
+    private renderMain;
+    private renderAreas;
+    private makeAreaOverlay;
+    private renderWindows;
+    private dropOverlay;
+    /** A dock area back among the manager's parts. */
+    private home;
+    private homeWindow;
+    private renderPhone;
+    /** While there is a document to go back to, the browser's back goes back to it. */
+    holdBack(): void;
+    /**
+     * The back button with nothing open: back to the document shown before, past the tools used in
+     * between (they are in sheets of their own, not what the phone shows).
+     */
+    private goBack;
+    /** Takes down what this presentation put up: everything goes back where the desktop has it. */
+    private takeDown;
+}

package/dist/components/tabdocs/TabSplit.d.ts

@@ -0,0 +1,40 @@
+import type { LayoutOrientation } from '../layout/layout-orientation';
+import type { LayoutItem } from './layout-item';
+import type { SashOwner } from './sash-owner';
+import { SplitSash } from './SplitSash';
+import type { TabDocumentManager } from './TabDocumentManager';
+/**
+ * A branch of the layout: groups or other splits side by side (`horizontal`) or one under the
+ * other, each with its share of the room, a splitter between each two.
+ */
+export declare class TabSplit implements SashOwner {
+    private readonly manager;
+    orientation: LayoutOrientation;
+    readonly element: HTMLDivElement;
+    parentSplit: TabSplit | null;
+    children: LayoutItem[];
+    /** One share per child, adding up to 1. */
+    sizes: number[];
+    private readonly sashes;
+    constructor(manager: TabDocumentManager, orientation: LayoutOrientation);
+    get rtl(): boolean;
+    sashIndex(sash: SplitSash): number;
+    insert(child: LayoutItem, index: number, share?: number): void;
+    /** Takes a child out; its room goes to the neighbour before it (after it, for the first). */
+    remove(child: LayoutItem): void;
+    replace(child: LayoutItem, next: LayoutItem): void;
+    even(): void;
+    /** A double click on a splitter evens this split. */
+    resetSizes(): void;
+    /** Moves the splitter after child `index` by `delta` pixels, within the smallest sizes. */
+    resizeBy(index: number, delta: number): boolean;
+    /** The pixels the children share; 0 when not laid out. */
+    room(): number;
+    /** The smallest size of a child along this split. */
+    minSize(item: LayoutItem): number;
+    /** Puts the children and splitters in place and gives each child its share. */
+    render(): void;
+    /** The splitters' names and values. */
+    renderSashes(): void;
+    dispose(): void;
+}

package/dist/components/tabdocs/TabWindow.d.ts

@@ -0,0 +1,82 @@
+import type { LayoutItem } from './layout-item';
+import { TabBarSettings } from './TabBarSettings';
+import type { TabDockSide } from './tab-dock-side';
+import type { TabDocument } from './TabDocument';
+import type { TabDocumentManager } from './TabDocumentManager';
+import type { TabGroup } from './TabGroup';
+import type { TabRect } from './tab-rect';
+/**
+ * A floating window of a `TabDocumentManager`, in the page: it holds groups as the documents' area
+ * does (split and resized the same way) and moves by the empty part of its strips. It resizes from
+ * its edges and corners, comes to the front when pressed, and maximizes within the page. The
+ * manager makes and closes windows (`float`, `closeWindow`); the methods here go through it, with
+ * its events. Its strips are compact by default (the manager's `compact…` props); its own
+ * settings (`scrollButtons`, `tabSize`, `tabMinWidth`, `singleTabTitle`, `barButtons`) win.
+ */
+export declare class TabWindow extends TabBarSettings {
+    private readonly owner;
+    readonly element: HTMLDivElement;
+    /** @internal Where its layout goes. */
+    readonly body: HTMLDivElement;
+    /** @internal The top of its layout. */
+    root: LayoutItem | null;
+    /** @internal Where "Dock" puts it back: a dock area, or a group among the documents (or in an area). */
+    lastDock: {
+        side: TabDockSide | null;
+        group: TabGroup | null;
+    };
+    private readonly box;
+    private readonly maximized;
+    private readonly active;
+    private readonly entry;
+    private readonly stops;
+    constructor(owner: TabDocumentManager, rect: TabRect);
+    get manager(): TabDocumentManager;
+    /** Its place and size in the viewport, in pixels (as it is when restored). Reactive. */
+    get rect(): TabRect;
+    /** Reactive. */
+    get isMaximized(): boolean;
+    /** The front window of the page. Reactive. */
+    get isActive(): boolean;
+    /** Its groups, in layout order. Reactive. */
+    get groups(): readonly TabGroup[];
+    /** Reactive. */
+    get documents(): readonly TabDocument[];
+    /** Its place among the manager's `floatingWindows`, the one at the back first. Reactive. */
+    get index(): number;
+    /** Moves it: `x` from the left of the viewport, `y` from the top. */
+    move(x: number, y: number): boolean;
+    resize(width: number, height: number): boolean;
+    maximize(): boolean;
+    restore(): boolean;
+    /** Closes it with its documents; resolves `false` when one stays open. */
+    close(): Promise<boolean>;
+    /** Docks it with everything in it: into the dock area of `side`, or back where it was docked. */
+    dock(side?: TabDockSide, size?: number | string): boolean;
+    /** Brings it to the front and focuses what had focus in it last. */
+    focus(): boolean;
+    /** @internal Puts it where `rect` says (kept as the place it is restored to). */
+    place(rect: TabRect): void;
+    /** @internal */
+    markMaximized(on: boolean): void;
+    /** @internal Shows it on top of the others. */
+    bringToFront(): void;
+    /** @internal While it is moved by the pointer: drops under it are seen through it. */
+    markMoving(on: boolean): void;
+    /** @internal The smallest size the window's style allows. */
+    minSize(): {
+        w: number;
+        h: number;
+    };
+    /** @internal The room it moves in: the viewport. */
+    room(): {
+        w: number;
+        h: number;
+    };
+    /** @internal */
+    dispose(): void;
+    private markActive;
+    private get rtl();
+    /** A press on an edge or a corner: the window follows it until it is let go. */
+    private resizeStart;
+}

package/dist/components/tabdocs/WindowByKeys.d.ts

@@ -0,0 +1,18 @@
+import type { TabDocumentManager } from './TabDocumentManager';
+import type { TabWindow } from './TabWindow';
+/**
+ * A floating window moved and resized from the keyboard: the arrow keys move it, with Shift they
+ * make it narrower, wider, shorter or taller, a step (`resizeStep`) at a time. Enter keeps it
+ * there, Escape puts it back; a press anywhere keeps it too.
+ */
+export declare class WindowByKeys {
+    private readonly manager;
+    private current;
+    constructor(manager: TabDocumentManager);
+    /** The window being moved, `null` when none is. */
+    get window(): TabWindow | null;
+    start(w: TabWindow): boolean;
+    /** Keeps the window where it is now (`keep`), or puts it back. */
+    end(keep: boolean): boolean;
+    private key;
+}

package/dist/components/tabdocs/content-lifetime.d.ts

@@ -0,0 +1,6 @@
+/**
+ * When a document's content is built and how long it lives: `keep` builds it on open and keeps it
+ * while the document is open; `lazy` builds it when first shown, then keeps it; `dispose` builds it
+ * when shown and disposes it when hidden (it comes back from the factory, with the document's `state`).
+ */
+export type ContentLifetime = 'keep' | 'lazy' | 'dispose';

package/dist/components/tabdocs/dock-guide-hit.d.ts

@@ -0,0 +1,10 @@
+import type { TabDockSide } from './tab-dock-side';
+import type { TabDropSide } from './tab-drop-side';
+import type { TabGroup } from './TabGroup';
+/** What a dock guide stands for: a side of a group (or its middle), or a dock area of the manager. */
+export type DockGuideHit = {
+    group: TabGroup;
+    side: TabDropSide;
+} | {
+    dock: TabDockSide;
+};

package/dist/components/tabdocs/document-activated-event-args.d.ts

@@ -0,0 +1,11 @@
+import type { TabDocument } from './TabDocument';
+import type { TabDocumentManager } from './TabDocumentManager';
+import type { TabGroup } from './TabGroup';
+/** The manager's active document changed: another tab, or another group. */
+export interface DocumentActivatedEventArgs {
+    document: TabDocument | null;
+    previous: TabDocument | null;
+    group: TabGroup;
+    byUser: boolean;
+    source: TabDocumentManager;
+}

package/dist/components/tabdocs/document-activating-event-args.d.ts

@@ -0,0 +1,12 @@
+import type { EventArgs } from '@motifx/core';
+import type { TabDocument } from './TabDocument';
+import type { TabDocumentManager } from './TabDocumentManager';
+import type { TabGroup } from './TabGroup';
+/** A tab is about to become its group's active one; `cancel = true` keeps the current one. */
+export interface DocumentActivatingEventArgs extends EventArgs {
+    document: TabDocument;
+    previous: TabDocument | null;
+    group: TabGroup;
+    byUser: boolean;
+    source: TabDocumentManager;
+}

package/dist/components/tabdocs/document-changed-event-args.d.ts

@@ -0,0 +1,10 @@
+import type { TabDocument } from './TabDocument';
+import type { TabDocumentManager } from './TabDocumentManager';
+import type { TabGroup } from './TabGroup';
+/** A document was kept open, pinned, unpinned or hidden (`group`: the one it was hidden from). */
+export interface DocumentChangedEventArgs {
+    document: TabDocument;
+    group: TabGroup;
+    byUser: boolean;
+    source: TabDocumentManager;
+}

package/dist/components/tabdocs/document-changing-event-args.d.ts

@@ -0,0 +1,11 @@
+import type { EventArgs } from '@motifx/core';
+import type { TabDocument } from './TabDocument';
+import type { TabDocumentManager } from './TabDocumentManager';
+import type { TabGroup } from './TabGroup';
+/** A document is about to be kept open, pinned, unpinned or hidden; `cancel = true` leaves it as it is. */
+export interface DocumentChangingEventArgs extends EventArgs {
+    document: TabDocument;
+    group: TabGroup;
+    byUser: boolean;
+    source: TabDocumentManager;
+}

package/dist/components/tabdocs/document-closed-event-args.d.ts

@@ -0,0 +1,10 @@
+import type { TabDocument } from './TabDocument';
+import type { TabDocumentManager } from './TabDocumentManager';
+import type { TabGroup } from './TabGroup';
+export interface DocumentClosedEventArgs {
+    document: TabDocument;
+    group: TabGroup;
+    index: number;
+    byUser: boolean;
+    source: TabDocumentManager;
+}

package/dist/components/tabdocs/document-closing-event-args.d.ts

@@ -0,0 +1,18 @@
+import type { EventArgs } from '@motifx/core';
+import type { TabDocument } from './TabDocument';
+import type { TabDocumentManager } from './TabDocumentManager';
+import type { TabGroup } from './TabGroup';
+/**
+ * A document is about to close. `cancel = true` keeps it; `promise` may be set to ask first (save
+ * the changes?): the document closes when it resolves to `true`.
+ */
+export interface DocumentClosingEventArgs extends EventArgs {
+    document: TabDocument;
+    group: TabGroup;
+    index: number;
+    byUser: boolean;
+    /** No other copy of the document stays open (see `allowDuplicate`): ask about unsaved changes only then. */
+    lastCopy: boolean;
+    promise?: Promise<boolean>;
+    source: TabDocumentManager;
+}

package/dist/components/tabdocs/document-moved-event-args.d.ts

@@ -0,0 +1,12 @@
+import type { TabDocument } from './TabDocument';
+import type { TabDocumentManager } from './TabDocumentManager';
+import type { TabGroup } from './TabGroup';
+export interface DocumentMovedEventArgs {
+    document: TabDocument;
+    from: TabGroup;
+    fromIndex: number;
+    to: TabGroup;
+    toIndex: number;
+    byUser: boolean;
+    source: TabDocumentManager;
+}

package/dist/components/tabdocs/document-moving-event-args.d.ts

@@ -0,0 +1,14 @@
+import type { EventArgs } from '@motifx/core';
+import type { TabDocument } from './TabDocument';
+import type { TabDocumentManager } from './TabDocumentManager';
+import type { TabGroup } from './TabGroup';
+/** A document is about to move, in its group or to another one; `cancel = true` keeps it where it is. */
+export interface DocumentMovingEventArgs extends EventArgs {
+    document: TabDocument;
+    from: TabGroup;
+    fromIndex: number;
+    to: TabGroup;
+    toIndex: number;
+    byUser: boolean;
+    source: TabDocumentManager;
+}

package/dist/components/tabdocs/document-opened-event-args.d.ts

@@ -0,0 +1,10 @@
+import type { TabDocument } from './TabDocument';
+import type { TabDocumentManager } from './TabDocumentManager';
+import type { TabGroup } from './TabGroup';
+export interface DocumentOpenedEventArgs {
+    document: TabDocument;
+    group: TabGroup;
+    index: number;
+    byUser: boolean;
+    source: TabDocumentManager;
+}