@dynamix-layout/core 1.0.1 → 1.1.1

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

@@ -1,97 +0,0 @@
-import { Queue } from './queue';
-import { Dimension, LayoutTree, NodeCache, NodeOptions, RootAdjustment, ReactiveValue, TabsIds } 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;
-}
-declare class Layout {
-    static _root: Node;
-    static _tree: LayoutTree;
-    static _minW: number;
-    static _minH: number;
-    static _bond: number;
-    static _inst: Layout | 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;
-    });
-    JSONLayoutIterator(root: LayoutTree): IterableIterator<LayoutTree>;
-    NodeLayoutIterator(root: Node): IterableIterator<Node>;
-    NodeLayoutRecursiveIterator(root: Node): IterableIterator<Node>;
-    updateChildDirections(parent: Node): void;
-    createNodeLayout(root?: LayoutTree): void;
-    createNodeTreeFromJSONTree(json: LayoutTree, host: Node): void;
-    /**
-     * Create binary tree
-     * @param queue
-     * @param host
-     */
-    createBinaryNodeTreeFromQueue(queue: Queue<string>, host?: Node): void;
-    createNodeFromJSON(json: LayoutTree): Node;
-    calcTabsetCountAndMinDim(root?: Node, clear?: boolean): void;
-    calculateRootAdjustment(): RootAdjustment;
-    calcDimensions(root?: Node, 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;
-    moveNodeAsTab(src: Node, des: Node, layout: 'left' | 'right' | 'contain'): void;
-    moveRelativeToRoot(src: Node, des: Node, layout: 'top' | 'bottom' | 'left' | 'right'): void;
-    moveRelativeToTabset(src: Node, des: Node, layout: 'top' | 'bottom' | 'left' | 'right'): void;
-    insertNode(des: Node, src: Node, flag: boolean): void;
-    insertNodeWithNewParent(src: Node, des: Node, flag: boolean): void;
-    moveAdjacentNodeToGrandParent(src: Node): void;
-    removeRelation(src: Node, fix?: boolean): Node | undefined;
-    removeNode(src: Node): void;
-    removeKid(kid: Node): void;
-    clearAllCache(): void;
-}
-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;
-}
-export { Layout as DynamixLayoutCore };

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

@@ -1,4 +0,0 @@
-export * from './dynamix';
-export * from './comparator';
-export * from './queue';
-export * from './reactive-state';

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/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;
-}