@dynamix-layout/core 1.1.0 → 1.2.0

package/dist/types/index.d.ts

@@ -1,2 +1,522 @@
-export * from './app/index';
-export type * from './type';
+/** @deprecated Internal; removed in 2.0. See https://github.com/xcode-studio/dynamix-layout/blob/main/docs/migration-v1-to-v2.md */
+export declare function areNodeOptionsEqual(a: NodeOptions, b: NodeOptions): boolean;
+
+/** @deprecated Internal; removed in 2.0. See https://github.com/xcode-studio/dynamix-layout/blob/main/docs/migration-v1-to-v2.md */
+export declare function areNodeOptionsMapEqual(mapA: Map<string, NodeOptions>, mapB: Map<string, NodeOptions>): boolean;
+
+export declare interface BaseNode {
+    typNode: NodeTypeWithBond;
+    nodName: string;
+    uidNode: string;
+    nodPart: number;
+    nodeDir: boolean;
+    nodDims: Dimension;
+    nodOpen?: string | boolean;
+}
+
+/** @deprecated Internal; removed in 2.0. Splitters are `snapshot.splitters`. See https://github.com/xcode-studio/dynamix-layout/blob/main/docs/migration-v1-to-v2.md */
+export declare class Bond {
+    dims: Dimension;
+    unId: string;
+    next: Node_2 | null;
+    prev: Node_2 | null;
+    host: Node_2 | null;
+    constructor(parent?: Node_2 | null, next?: Node_2 | null, prev?: Node_2 | null);
+    toJSON(): LayoutTree;
+}
+
+export declare type ChangeListener<T> = (newValue: T) => void;
+
+/**
+ * Coalesces bursts of updates (pointer events can fire several times per
+ * frame) into at most one `onFlush` call per animation frame.
+ */
+export declare function createFrameScheduler<T>(onFlush: (value: T) => void): FrameScheduler<T>;
+
+/** @deprecated Internal; removed in 2.0. Use `layout.subscribe()`. See https://github.com/xcode-studio/dynamix-layout/blob/main/docs/migration-v1-to-v2.md */
+export declare function createReactiveState<T>(initialValue: T, comparator?: (a: T, b: T) => boolean): ReactiveValue<T>;
+
+/** @deprecated Replaced in 2.0 by `Rect { x, y, width, height }`. See https://github.com/xcode-studio/dynamix-layout/blob/main/docs/migration-v1-to-v2.md */
+export declare type Dimension = {
+    w: number;
+    h: number;
+    x: number;
+    y: number;
+};
+
+export declare type DropArea = 'top' | 'bottom' | 'left' | 'right' | 'contain';
+
+/** Where a dragged tab or tabset would land, in viewport coordinates. */
+export declare interface DropPreview {
+    area: DropArea;
+    left: number;
+    top: number;
+    width: number;
+    height: number;
+}
+
+/** @deprecated Replaced in 2.0 by `createLayout(options)`, which returns an independent instance (no static state). See https://github.com/xcode-studio/dynamix-layout/blob/main/docs/migration-v1-to-v2.md */
+export declare class DynamixLayoutCore {
+    static get _root(): Node_2;
+    static set _root(value: Node_2);
+    static get _tree(): LayoutTree | null;
+    static set _tree(value: LayoutTree | null);
+    static get _minW(): number;
+    static set _minW(value: number);
+    static get _minH(): number;
+    static set _minH(value: number);
+    static get _bond(): number;
+    static set _bond(value: number);
+    static get _inst(): DynamixLayoutCore | null;
+    static set _inst(value: DynamixLayoutCore | null);
+    nodeOps: ReactiveValue<Map<string, NodeOptions>>;
+    cntdown: ReturnType<typeof setTimeout> | null;
+    tabsIds: TabsIds;
+    constructor(options?: {
+        tabs?: string[];
+        tree?: LayoutTree | null;
+        minW?: number;
+        minH?: number;
+        bond?: number;
+        uqid?: string;
+        tabsIds?: TabsIds;
+        /** Generates ids for new nodes and bonds (default `crypto.randomUUID`). */
+        createId?: () => string;
+        /** Schedules deferred updates (default `setTimeout`/`clearTimeout`). */
+        timer?: Timer;
+        /** Size of a folded tabset along its row; pass the tab bar height. */
+        collapsedSize?: number;
+    });
+    JSONLayoutIterator(root: LayoutTree): IterableIterator<LayoutTree>;
+    NodeLayoutIterator(root: Node_2): IterableIterator<Node_2>;
+    NodeLayoutRecursiveIterator(root: Node_2): IterableIterator<Node_2>;
+    updateChildDirections(parent: Node_2): void;
+    createNodeLayout(root?: LayoutTree | null): void;
+    createNodeTreeFromJSONTree(json: LayoutTree, host: Node_2): void;
+    createBinaryNodeTreeFromQueue(queue: Queue<string>, host?: Node_2): void;
+    createNodeFromJSON(json: LayoutTree): Node_2;
+    calcTabsetCountAndMinDim(root?: Node_2, clear?: boolean): void;
+    pruneStaleDirections(): void;
+    calculateRootAdjustment(): RootAdjustment;
+    calcDimensions(root?: Node_2, supress?: boolean): void;
+    updateDimension(dim: Dimension, disableTimeout?: boolean, timeout?: number): void;
+    updateSlider(id: string, dim: {
+        x: number;
+        y: number;
+    }, disableTimeout?: boolean, timeout?: number): void;
+    updateSliderDimension(id: string, dim: {
+        x: number;
+        y: number;
+    }): void;
+    updateTree(src: string, des: string, layout: 'top' | 'bottom' | 'left' | 'right' | 'contain'): boolean;
+    isOnlyContent(node: Node_2): boolean;
+    moveNodeAsTab(src: Node_2, des: Node_2, layout: 'left' | 'right' | 'contain'): void;
+    moveRelativeToRoot(src: Node_2, des: Node_2, layout: 'top' | 'bottom' | 'left' | 'right'): void;
+    moveRelativeToTabset(src: Node_2, des: Node_2, layout: 'top' | 'bottom' | 'left' | 'right'): void;
+    insertNode(des: Node_2, src: Node_2, flag: boolean): void;
+    insertNodeWithNewParent(src: Node_2, des: Node_2, flag: boolean): void;
+    moveAdjacentNodeToGrandParent(src: Node_2): void;
+    removeRelation(src: Node_2, fix?: boolean): Node_2 | undefined;
+    removeNode(src: Node_2): void;
+    removeKid(kid: Node_2): void;
+    clearAllCache(): void;
+    /** Uid of the maximized tabset, or null. */
+    get maximizedId(): string | null;
+    /** Show one tabset over the whole layout; the others stay mounted. */
+    maximize(id: string): boolean;
+    /** Leave maximized mode; the previous split is restored exactly. */
+    restore(): boolean;
+    toggleMaximize(id: string): boolean;
+    /** Fold a tabset to a strip along its row (its tab bar). */
+    collapse(id: string): boolean;
+    /** Unfold a tabset; it returns to its previous size. */
+    expand(id: string): boolean;
+    toggleCollapse(id: string): boolean;
+}
+
+export declare interface FrameScheduler<T> {
+    /** Remember `value`; `onFlush` runs with the latest value on the next frame. */
+    schedule: (value: T) => void;
+    /** Run a pending flush now (e.g. on pointer up). */
+    flush: () => void;
+    /** Drop a pending flush (e.g. on unmount). */
+    cancel: () => void;
+}
+
+/**
+ * Insertion marker between the tabs of a tab bar. `index` is the tab the
+ * marker sits next to. Returns null when the pointer is above or below the bar.
+ * @deprecated Replaced in 2.0 by `layout.getDropTarget()` and `layout.getDropIndicatorRect()`. See https://github.com/xcode-studio/dynamix-layout/blob/main/docs/migration-v1-to-v2.md
+ */
+export declare function getNavbarDropPreview(navbarRect: PreviewRect, tabRects: PreviewRect[], clientX: number, clientY: number): (DropPreview & {
+    index: number;
+}) | null;
+
+/**
+ * The half of the whole layout a root-edge drop would take.
+ * @deprecated Replaced in 2.0 by `layout.getDropTarget()` and `layout.getDropIndicatorRect()`. See https://github.com/xcode-studio/dynamix-layout/blob/main/docs/migration-v1-to-v2.md
+ */
+export declare function getRootSplitPreview(container: Dimension, side: RootSide): DropPreview;
+
+/**
+ * Where a tabset's tab bar goes. A folded tabset in a side-by-side row shows
+ * its tab bar rotated 90 degrees: an element `h` wide and `w` tall, rotated
+ * around its top-left corner and placed at `x + w`, covers exactly the strip.
+ */
+export declare function getTabbarPlacement(tabset: Pick<NodeOptions, 'nodDims' | 'nodFold' | 'nodeDir'>, tabbarHeight: number): TabbarPlacement;
+
+/**
+ * Area of a tabset below its tab bar; never negative when squeezed.
+ * @deprecated Replaced in 2.0 by `getTabContentRect(tabsetRect, tabBarHeight)`. See https://github.com/xcode-studio/dynamix-layout/blob/main/docs/migration-v1-to-v2.md
+ */
+export declare function getTabBodyRect(tabset: Dimension, tabbarHeight: number): Dimension;
+
+/**
+ * Splits a tabset into thirds: the outer thirds drop beside it, the middle
+ * drops into it as a tab.
+ * @deprecated Replaced in 2.0 by `layout.getDropTarget()` and `layout.getDropIndicatorRect()`. See https://github.com/xcode-studio/dynamix-layout/blob/main/docs/migration-v1-to-v2.md
+ */
+export declare function getTabsetDropPreview(rect: PreviewRect, clientX: number, clientY: number): DropPreview;
+
+/** @deprecated Replaced in 2.0 by `layout.getDropTarget()` and `layout.getDropIndicatorRect()`. See https://github.com/xcode-studio/dynamix-layout/blob/main/docs/migration-v1-to-v2.md */
+export declare function isSameDropPreview(a: Partial<DropPreview>, b: DropPreview): boolean;
+
+/** @deprecated Replaced in 2.0 by `LayoutJSON` (v1 trees load automatically; `LayoutTreeV1` describes this shape). See https://github.com/xcode-studio/dynamix-layout/blob/main/docs/migration-v1-to-v2.md */
+export declare type LayoutTree = Omit<BaseNode, 'nodeDir' | 'nodDims'> & {
+    nodKids?: LayoutTree[];
+    /** Tabset only: folded to a strip along its parent row. */
+    nodFold?: boolean;
+    /** Root only: uid of the maximized tabset. */
+    nodMaxd?: string;
+};
+
+/** @deprecated Internal; removed in 2.0. Read layout state from `layout.getSnapshot()` / `subscribe()`. See https://github.com/xcode-studio/dynamix-layout/blob/main/docs/migration-v1-to-v2.md */
+declare class Node_2 {
+    static cache: NodeCache;
+    kids: Queue<Node_2>;
+    dims: Dimension;
+    unId: string;
+    next: Bond | null;
+    prev: Bond | null;
+    type: 'row' | 'tabset' | 'tab' | 'bond';
+    name: string;
+    part: number;
+    host: Node_2 | null;
+    open: string;
+    /** Tabset only: folded to a strip along its parent row. */
+    collapsed: boolean;
+    /** Fold order, used to pick which sibling to unfold. */
+    foldedAt: number;
+    constructor(options?: {
+        type?: 'row' | 'tabset' | 'tab' | 'bond';
+        host?: Node_2 | null;
+        name?: string;
+        part?: number;
+        dims?: Dimension;
+        unId?: string;
+        open?: string;
+    });
+    addBond(parent: Node_2 | null, prev?: Node_2 | null): void;
+    getReqDimension(): {
+        width: number;
+        height: number;
+    };
+    calcDimensions(): void;
+    toJSON(): LayoutTree;
+}
+export { Node_2 as Node }
+
+export declare interface NodeCache {
+    dimMins: Map<string, {
+        minWidth: number;
+        minHeight: number;
+    }>;
+    mapDirs: Map<string, boolean>;
+    tabCnts: Map<string, {
+        horizontal: number;
+        vertical: number;
+    }>;
+    mapElem: Map<string, Node_2 | Bond>;
+    nodOpts: ReactiveValue<Map<string, NodeOptions>>;
+    bndOpts: ReactiveValue<Map<string, NodeOptions>>;
+    tabOpts: ReactiveValue<Map<string, NodeOptions>>;
+}
+
+/** @deprecated Replaced in 2.0 by `TabsetState`, `SplitterState`, `TabState` and `snapshot.rects`. See https://github.com/xcode-studio/dynamix-layout/blob/main/docs/migration-v1-to-v2.md */
+export declare interface NodeOptions extends BaseNode {
+    nodKids?: BaseNode[];
+    /** Tabset: folded to a strip (ignored while it is maximized). */
+    nodFold?: boolean;
+    /** Tabset: currently maximized over the whole layout. */
+    nodMaxd?: boolean;
+    /** Hidden because another tabset is maximized (content stays mounted). */
+    nodHidden?: boolean;
+    /** Bond: next to a folded tabset, so it cannot be dragged. */
+    nodLocked?: boolean;
+    /** Tabset: can be folded (it has siblings in its row). */
+    nodFoldable?: boolean;
+    /** Tabset: can be maximized (the layout has more than one tabset). */
+    nodMaximizable?: boolean;
+}
+
+export declare type NodeType = 'row' | 'tabset' | 'tab';
+
+export declare type NodeTypeWithBond = NodeType | 'bond';
+
+export declare function placeTabbar(el: HTMLElement, placement: TabbarPlacement): void;
+
+export declare type PreviewRect = Pick<DOMRect, 'left' | 'top' | 'right' | 'bottom' | 'width' | 'height'>;
+
+/** @deprecated Internal; removed in 2.0. See https://github.com/xcode-studio/dynamix-layout/blob/main/docs/migration-v1-to-v2.md */
+export declare class Queue<T> {
+    private buffer;
+    private head;
+    private tail;
+    private count;
+    private capacity;
+    constructor(initialCapacity?: number, array?: T[]);
+    /**
+     * Add element to the back of the queue - O(1) amortized
+     * Used for FIFO and FILO patterns
+     */
+    enqueue(item: T): void;
+    /**
+     * Add element to the front of the queue - O(1) amortized
+     * Used for LIFO and LILO patterns
+     */
+    enqueueFront(item: T): void;
+    /**
+     * Insert element at specific logical index - O(n)
+     * All elements at and after the index are shifted right
+     * @param index - Logical index (0 = front of queue)
+     * @param item - Element to insert
+     * @returns true if insertion successful, false if index out of bounds
+     */
+    insert(index: number, item: T): boolean;
+    /**
+     * Insert array of elements at specific logical index - O(n + m) where n is elements to shift, m is array length
+     * All elements at and after the index are shifted right to make room for the entire array
+     * @param index - Logical index (0 = front of queue)
+     * @param items - Array of elements to insert
+     * @returns true if insertion successful, false if index out of bounds
+     */
+    insertArray(index: number, items: T[]): boolean;
+    /**
+     * Insert another queue at specific logical index - O(n + m) where n is elements to shift, m is queue size
+     * All elements at and after the index are shifted right to make room for the entire queue
+     * @param index - Logical index (0 = front of queue)
+     * @param queue - Queue to insert
+     * @returns true if insertion successful, false if index out of bounds
+     */
+    insertQueue(index: number, queue: Queue<T>): boolean;
+    /**
+     * Alias for enqueue (add to back)
+     */
+    push(item: T): void;
+    /**
+     * Alias for enqueueFront (add to front)
+     */
+    unshift(item: T): void;
+    /**
+     * Remove and return element from front of queue - O(1)
+     * Used for FIFO and LIFO patterns
+     */
+    dequeue(): T | undefined;
+    /**
+     * Remove and return element from back of queue - O(1)
+     * Used for FILO and LILO patterns
+     */
+    dequeueBack(): T | undefined;
+    indexOf(item: T): number;
+    remove(item: T): boolean;
+    /**
+     * Remove element at specific logical index - O(n)
+     * All elements after the index are shifted left
+     * @param index - Logical index (0 = front of queue)
+     * @returns The removed element, or undefined if index out of bounds
+     */
+    removeAt(index: number): T | undefined;
+    /**
+     * Alias for dequeue (remove from front)
+     */
+    shift(): T | undefined;
+    /**
+     * Alias for dequeueBack (remove from back)
+     */
+    pop(): T | undefined;
+    /**
+     * FIFO: First In, First Out
+     * Add to back, remove from front
+     */
+    fifoAdd(item: T): void;
+    fifoRemove(): T | undefined;
+    /**
+     * FILO: First In, Last Out
+     * Add to back, remove from back
+     */
+    filoAdd(item: T): void;
+    filoRemove(): T | undefined;
+    /**
+     * LIFO: Last In, First Out
+     * Add to front, remove from front
+     */
+    lifoAdd(item: T): void;
+    lifoRemove(): T | undefined;
+    /**
+     * LILO: Last In, Last Out
+     * Add to front, remove from back
+     */
+    liloAdd(item: T): void;
+    liloRemove(): T | undefined;
+    /**
+     * Get element at logical index (0 = front of queue) - O(1)
+     */
+    get(index: number): T | undefined;
+    /**
+     * Set element at logical index - O(1)
+     */
+    set(index: number, item: T): boolean;
+    /**
+     * Get the front element without removing it - O(1)
+     */
+    peek(): T | undefined;
+    /**
+     * Get the back element without removing it - O(1)
+     */
+    peekBack(): T | undefined;
+    /**
+     * Alias for peek (front element)
+     */
+    front(): T | undefined;
+    /**
+     * Alias for peekBack (back element)
+     */
+    back(): T | undefined;
+    /**
+     * Get current size of queue - O(1)
+     */
+    size(): number;
+    /**
+     * Get current capacity - O(1)
+     */
+    getCapacity(): number;
+    /**
+     * Check if queue is empty - O(1)
+     */
+    isEmpty(): boolean;
+    /**
+     * Check if queue is full - O(1)
+     */
+    isFull(): boolean;
+    /**
+     * Clear all elements from queue - O(1)
+     */
+    clear(): void;
+    /**
+     * Convert queue to array (maintains order from front to back) - O(n)
+     */
+    toArray(): T[];
+    /**
+     * Forward iterator support for for...of loops - O(n) total
+     * Iterates from front to back
+     */
+    [Symbol.iterator](): IterableIterator<T>;
+    /**
+     * Forward iterator (same as Symbol.iterator) - O(n) total
+     * Iterates from front to back
+     */
+    forward(): IterableIterator<T>;
+    /**
+     * Reverse iterator - O(n) total
+     * Iterates from back to front
+     */
+    reverse(): IterableIterator<T>;
+    /**
+     * Iterator with index information - O(n) total
+     * Returns [index, value] pairs from front to back
+     */
+    entries(): IterableIterator<[number, T]>;
+    /**
+     * Iterator for keys (indices) - O(n) total
+     */
+    keys(): IterableIterator<number>;
+    /**
+     * Iterator for values only - O(n) total
+     * Same as Symbol.iterator but more explicit
+     */
+    values(): IterableIterator<T>;
+    /**
+     * Get string representation - O(n)
+     */
+    toString(): string;
+    /**
+     * Private method to resize buffer when capacity is exceeded
+     */
+    private resize;
+    /**
+     * Shift elements left (towards head) to make room for insertion
+     * Used when inserting closer to head
+     */
+    private shiftLeft;
+    /**
+     * Shift elements right (towards tail) to make room for insertion
+     * Used when inserting closer to tail
+     */
+    private shiftRight;
+    /**
+     * Shift elements right (towards tail) to fill gap after removal
+     * Used when removing closer to head
+     */
+    private shiftRightForRemoval;
+    /**
+     * Shift elements left (towards head) to fill gap after removal
+     * Used when removing closer to tail
+     */
+    private shiftLeftForRemoval;
+    /**
+     * Shift elements left (towards head) to make room for array insertion
+     * Used when inserting array closer to head
+     */
+    private shiftLeftArray;
+    /**
+     * Shift elements right (towards tail) to make room for array insertion
+     * Used when inserting array closer to tail
+     */
+    private shiftRightArray;
+}
+
+export declare interface ReactiveValue<T> {
+    get: () => T;
+    set: (newValue: T, flag?: boolean) => void;
+    onChange: (listener: ChangeListener<T>) => () => void;
+    nextChange: () => Promise<T>;
+    onChangePromise: (listener: ChangeListener<T>) => () => void;
+    triggerChange: () => void;
+}
+
+export declare interface RootAdjustment {
+    adjustedW: number;
+    adjustedH: number;
+    wasAdjusted: boolean;
+}
+
+export declare type RootSide = Exclude<DropArea, 'contain'>;
+
+/** @deprecated Replaced in 2.0 by `applyRect(element, rect)`. See https://github.com/xcode-studio/dynamix-layout/blob/main/docs/migration-v1-to-v2.md */
+export declare function setElementRect(el: HTMLElement, { x, y, w, h }: Dimension): void;
+
+export declare interface TabbarPlacement {
+    /** Box to give the tab bar element before `rotated` is applied. */
+    rect: Dimension;
+    /** Folded tabset in a side-by-side row: the bar is drawn as a vertical strip. */
+    rotated: boolean;
+}
+
+export declare type TabsIds = Map<string, string>;
+
+declare type Timer = {
+    set: (callback: () => void, ms: number) => ReturnType<typeof setTimeout>;
+    clear: (handle: ReturnType<typeof setTimeout>) => void;
+};
+
+export { }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dynamix-layout/core",
-  "version": "1.1.0",
+  "version": "1.2.0",
   "description": "Dynamix Layout/Core is a JavaScript package for creating dynamic layouts with ease.",
   "keywords": [
     "dynamix-layout",
@@ -21,23 +21,27 @@
   ],
   "repository": {
     "type": "git",
-    "url": "https://github.com/xcode-studio/dynamix-layout.git",
+    "url": "git+https://github.com/xcode-studio/dynamix-layout.git",
     "directory": "packages/core"
   },
   "bugs": {
     "url": "https://github.com/xcode-studio/dynamix-layout/issues"
   },
   "homepage": "https://github.com/xcode-studio/dynamix-layout#readme",
-  "main": "./dist/core.cjs.js",
+  "main": "./dist/core.cjs",
   "module": "./dist/core.es.js",
-  "browser": "./dist/core.iife.js",
   "types": "./dist/types/index.d.ts",
   "typings": "./dist/types/index.d.ts",
   "exports": {
     ".": {
-      "types": "./dist/types/index.d.ts",
-      "import": "./dist/core.es.js",
-      "require": "./dist/core.cjs.js"
+      "import": {
+        "types": "./dist/types/index.d.ts",
+        "default": "./dist/core.es.js"
+      },
+      "require": {
+        "types": "./dist/types/index.d.cts",
+        "default": "./dist/core.cjs"
+      }
     }
   },
   "files": [
@@ -53,8 +57,7 @@
   },
   "type": "module",
   "engines": {
-    "node": ">=22.16.0",
-    "pnpm": ">=10.13.1"
+    "node": ">=18"
   },
   "devDependencies": {
     "@changesets/cli": "^2.31.1",