@dynamix-layout/core 1.1.0 → 1.1.1

package/dist/types/app/node.d.ts

@@ -1,40 +0,0 @@
-import { Queue } from './queue';
-import { Dimension, LayoutTree, NodeCache } from '../type';
-export declare class Node {
-    static cache: NodeCache;
-    kids: Queue<Node>;
-    dims: Dimension;
-    unId: string;
-    next: Bond | null;
-    prev: Bond | null;
-    type: 'row' | 'tabset' | 'tab' | 'bond';
-    name: string;
-    part: number;
-    host: Node | null;
-    open: string;
-    constructor(options?: {
-        type?: 'row' | 'tabset' | 'tab' | 'bond';
-        host?: Node | null;
-        name?: string;
-        part?: number;
-        dims?: Dimension;
-        unId?: string;
-        open?: string;
-    });
-    addBond(parent: Node | null, prev?: Node | null): void;
-    getReqDimension(): {
-        width: number;
-        height: number;
-    };
-    calcDimensions(): void;
-    toJSON(): LayoutTree;
-}
-export declare class Bond {
-    dims: Dimension;
-    unId: string;
-    next: Node | null;
-    prev: Node | null;
-    host: Node | null;
-    constructor(parent?: Node | null, next?: Node | null, prev?: Node | null);
-    toJSON(): LayoutTree;
-}

package/dist/types/app/queue.d.ts

@@ -1,217 +0,0 @@
-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 { Queue };

package/dist/types/app/reactive-state.d.ts

@@ -1,3 +0,0 @@
-import { ReactiveValue } from '../type';
-declare function createReactiveState<T>(initialValue: T, comparator?: (a: T, b: T) => boolean): ReactiveValue<T>;
-export { createReactiveState };

package/dist/types/app/slider.d.ts

@@ -1,10 +0,0 @@
-import { DynamixLayoutCore as Layout } from './dynamix';
-/** Moving a bond (slider) between two siblings. */
-export declare function updateSlider(engine: Layout, id: string, dim: {
-    x: number;
-    y: number;
-}, disableTimeout?: boolean, timeout?: number): void;
-export declare function updateSliderDimension(engine: Layout, id: string, dim: {
-    x: number;
-    y: number;
-}): void;

package/dist/types/app/state.d.ts

@@ -1,20 +0,0 @@
-import { Node } from './node';
-import { DynamixLayoutCore } from './dynamix';
-import { LayoutTree } from '../type';
-export type Timer = {
-    set: (callback: () => void, ms: number) => ReturnType<typeof setTimeout>;
-    clear: (handle: ReturnType<typeof setTimeout>) => void;
-};
-export declare const defaultCreateId: () => string;
-export declare const defaultTimer: Timer;
-/** Shared layout settings and the current root, used by every layout module. */
-export declare const layoutState: {
-    createId: () => string;
-    timer: Timer;
-    root: Node;
-    tree: LayoutTree | null;
-    minW: number;
-    minH: number;
-    bond: number;
-    inst: DynamixLayoutCore | null;
-};

package/dist/types/app/tree-builder.d.ts

@@ -1,13 +0,0 @@
-import { Queue } from './queue';
-import { Node } from './node';
-import { LayoutTree } from '../type';
-import { DynamixLayoutCore as Layout } from './dynamix';
-/** Building the node tree from a saved layout or a list of tabs, and walking it. */
-export declare function JSONLayoutIterator(root: LayoutTree): IterableIterator<LayoutTree>;
-export declare function NodeLayoutIterator(root: Node): IterableIterator<Node>;
-export declare function NodeLayoutRecursiveIterator(engine: Layout, root: Node): IterableIterator<Node>;
-export declare function updateChildDirections(engine: Layout, parent: Node): void;
-export declare function createNodeLayout(engine: Layout, root?: LayoutTree | null): void;
-export declare function createNodeTreeFromJSONTree(engine: Layout, json: LayoutTree, host: Node): void;
-export declare function createBinaryNodeTreeFromQueue(engine: Layout, queue: Queue<string>, host?: Node): void;
-export declare function createNodeFromJSON(engine: Layout, json: LayoutTree): Node;

package/dist/types/app/tree-mutations.d.ts

@@ -1,17 +0,0 @@
-import { Node } from './node';
-import { DynamixLayoutCore as Layout } from './dynamix';
-/** Drag and drop: moving tabs/tabsets and keeping bonds and caches consistent. */
-export declare function updateTree(engine: Layout, src: string, des: string, layout: 'top' | 'bottom' | 'left' | 'right' | 'contain'): boolean;
-export declare function isOnlyContent(engine: Layout, node: Node): boolean;
-export declare function moveNodeAsTab(engine: Layout, src: Node, des: Node, layout: 'left' | 'right' | 'contain'): void;
-type Side = 'top' | 'bottom' | 'left' | 'right';
-export declare function moveRelativeToRoot(engine: Layout, src: Node, des: Node, layout: Side): void;
-export declare function moveRelativeToTabset(engine: Layout, src: Node, des: Node, layout: Side): void;
-export declare function insertNode(engine: Layout, des: Node, src: Node, flag: boolean): void;
-export declare function insertNodeWithNewParent(engine: Layout, src: Node, des: Node, flag: boolean): void;
-export declare function moveAdjacentNodeToGrandParent(engine: Layout, src: Node): void;
-export declare function removeRelation(src: Node, fix?: boolean): Node | undefined;
-export declare function removeNode(engine: Layout, src: Node): void;
-export declare function removeKid(kid: Node): void;
-export declare function clearAllCache(): void;
-export {};

package/dist/types/type/index.d.ts

@@ -1,54 +0,0 @@
-import { Node, Bond } from '../app/dynamix';
-export type Dimension = {
-    w: number;
-    h: number;
-    x: number;
-    y: number;
-};
-export interface NodeCache {
-    dimMins: Map<string, {
-        minWidth: number;
-        minHeight: number;
-    }>;
-    mapDirs: Map<string, boolean>;
-    tabCnts: Map<string, {
-        horizontal: number;
-        vertical: number;
-    }>;
-    mapElem: Map<string, Node | Bond>;
-    nodOpts: ReactiveValue<Map<string, NodeOptions>>;
-    bndOpts: ReactiveValue<Map<string, NodeOptions>>;
-    tabOpts: ReactiveValue<Map<string, NodeOptions>>;
-}
-export type NodeType = 'row' | 'tabset' | 'tab';
-export type NodeTypeWithBond = NodeType | 'bond';
-export type TabsIds = Map<string, string>;
-export interface BaseNode {
-    typNode: NodeTypeWithBond;
-    nodName: string;
-    uidNode: string;
-    nodPart: number;
-    nodeDir: boolean;
-    nodDims: Dimension;
-    nodOpen?: string | boolean;
-}
-export type LayoutTree = Omit<BaseNode, 'nodeDir' | 'nodDims'> & {
-    nodKids?: LayoutTree[];
-};
-export interface NodeOptions extends BaseNode {
-    nodKids?: BaseNode[];
-}
-export interface RootAdjustment {
-    adjustedW: number;
-    adjustedH: number;
-    wasAdjusted: boolean;
-}
-export type ChangeListener<T> = (newValue: T) => void;
-export 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;
-}