@datagrok-libraries/dock-spawn-dg 0.0.1

package/lib/TabHost.js

@@ -0,0 +1,238 @@
+import { TabPage } from "./TabPage.js";
+import { Utils } from "./Utils.js";
+import { TabHostDirection } from "./enums/TabHostDirection.js";
+import { EventHandler } from './EventHandler.js';
+/**
+ * Tab Host control contains tabs known as TabPages.
+ * The tab strip can be aligned in different orientations
+ */
+export class TabHost {
+    displayCloseButton;
+    dockManager;
+    tabStripDirection;
+    hostElement;
+    tabListElement;
+    separatorElement;
+    contentElement;
+    createTabPage;
+    tabHandleListener;
+    eventListeners;
+    pages;
+    activeTab;
+    _resizeRequested;
+    mouseDownHandler;
+    focusHandler;
+    constructor(dockManager, tabStripDirection, displayCloseButton) {
+        /**
+         * Create a tab host with the tab strip aligned in the [tabStripDirection] direciton
+         * Only TabHost.DIRECTION_BOTTOM and TabHost.DIRECTION_TOP are supported
+         */
+        if (tabStripDirection === undefined) {
+            tabStripDirection = TabHostDirection.BOTTOM;
+        }
+        if (displayCloseButton === undefined) {
+            displayCloseButton = false;
+        }
+        this.dockManager = dockManager;
+        this.tabStripDirection = tabStripDirection;
+        this.displayCloseButton = displayCloseButton; // Indicates if the close button next to the tab handle should be displayed
+        this.pages = [];
+        this.eventListeners = [];
+        this.tabHandleListener = {
+            onMoveTab: (e) => { this.onMoveTab(e); }
+        };
+        this.hostElement = document.createElement('div'); // The main tab host DOM element
+        this.tabListElement = document.createElement('div'); // Hosts the tab handles
+        this.separatorElement = document.createElement('div'); // A seperator line between the tabs and content
+        this.contentElement = document.createElement('div'); // Hosts the active tab content
+        this.contentElement.tabIndex = 0;
+        this.createTabPage = this._createDefaultTabPage; // Factory for creating tab pages
+        if (this.tabStripDirection === TabHostDirection.BOTTOM) {
+            this.hostElement.appendChild(this.contentElement);
+            this.hostElement.appendChild(this.separatorElement);
+            this.hostElement.appendChild(this.tabListElement);
+        }
+        else if (this.tabStripDirection === TabHostDirection.TOP) {
+            this.hostElement.appendChild(this.tabListElement);
+            this.hostElement.appendChild(this.separatorElement);
+            this.hostElement.appendChild(this.contentElement);
+        }
+        else {
+            throw new Error('Only top and bottom tab strip orientations are supported');
+        }
+        this.hostElement.classList.add('dockspan-tab-host');
+        this.tabListElement.classList.add('dockspan-tab-handle-list-container');
+        this.separatorElement.classList.add('dockspan-tab-handle-content-seperator');
+        this.contentElement.classList.add('dockspan-tab-content');
+        this.contentElement.tabIndex = 0;
+        this.focusHandler = new EventHandler(this.contentElement, 'focus', this.onFocus.bind(this), true);
+        this.mouseDownHandler = new EventHandler(this.contentElement, 'mousedown', this.onMousedown.bind(this), true);
+    }
+    onFocus() {
+        if (this.activeTab && this.dockManager.activePanel != this.activeTab.panel)
+            this.dockManager.activePanel = this.activeTab.panel;
+    }
+    setActive(isActive) {
+        if (isActive) {
+            this.separatorElement.classList.add('dockspan-tab-handle-content-seperator-active');
+        }
+        else {
+            this.separatorElement.classList.remove('dockspan-tab-handle-content-seperator-active');
+        }
+        if (this.activeTab) {
+            this.activeTab.handle.setActive(isActive);
+        }
+    }
+    onMousedown() {
+        if (this.activeTab && this.dockManager.activePanel != this.activeTab.panel)
+            this.dockManager.activePanel = this.activeTab.panel;
+    }
+    onMoveTab(e) {
+        let index = Array.prototype.slice.call(this.tabListElement.childNodes).indexOf(e.self.elementBase);
+        this.change(this, /*handle*/ e.self, e.state, index);
+    }
+    performTabsLayout(indexes) {
+        this.pages = Utils.orderByIndexes(this.pages, indexes);
+        let items = this.tabListElement.childNodes;
+        let itemsArr = [];
+        for (let i in items) {
+            if (items[i].nodeType === 1) { // get rid of the whitespace text nodes
+                itemsArr.push(items[i]);
+            }
+        }
+        itemsArr = Utils.orderByIndexes(itemsArr, indexes);
+        for (let i = 0; i < itemsArr.length; ++i) {
+            this.tabListElement.appendChild(itemsArr[i]);
+        }
+        if (this.activeTab)
+            this.onTabPageSelected(this.activeTab, false);
+    }
+    getActiveTab() {
+        return this.activeTab;
+    }
+    addListener(listener) {
+        this.eventListeners.push(listener);
+    }
+    removeListener(listener) {
+        this.eventListeners.splice(this.eventListeners.indexOf(listener), 1);
+    }
+    change(host, handle, state, index) {
+        this.eventListeners.forEach((listener) => {
+            if (listener.onChange) {
+                listener.onChange({ host: host, handle: handle, state: state, index: index });
+            }
+        });
+    }
+    _createDefaultTabPage(tabHost, container) {
+        return new TabPage(tabHost, container);
+    }
+    setActiveTab(container) {
+        let currentPage;
+        this.pages.forEach((itm) => {
+            if (itm.container === container) {
+                currentPage = itm;
+            }
+        });
+        if (this.pages.length > 0 && currentPage) {
+            this.onTabPageSelected(currentPage, true);
+            this.dockManager.activePanel = container;
+        }
+    }
+    resize(width, height) {
+        this.hostElement.style.width = width + 'px';
+        this.hostElement.style.height = height + 'px';
+        let tabHeight = this.tabListElement.clientHeight;
+        if (!this._resizeRequested)
+            requestAnimationFrame(() => this.resizeTabListElement(width, height));
+        this._resizeRequested = true;
+        let separatorHeight = this.separatorElement.clientHeight;
+        let contentHeight = height - tabHeight - separatorHeight;
+        this.contentElement.style.height = contentHeight + 'px';
+        if (this.activeTab)
+            this.activeTab.resize(width, contentHeight);
+    }
+    resizeTabListElement(width, height) {
+        this._resizeRequested = false;
+        if (this.pages.length === 0)
+            return;
+        let tabListWidth = 0;
+        this.pages.forEach((page) => {
+            let handle = page.handle;
+            if (handle.elementBase != null) {
+                handle.elementBase.style.width = ''; //clear
+                tabListWidth += handle.elementBase.clientWidth;
+            }
+        });
+        let scaleMultiplier = width / tabListWidth;
+        if (scaleMultiplier > 1.2)
+            return; //with a reserve
+        this.pages.forEach((page, index) => {
+            let handle = page.handle;
+            let newSize = scaleMultiplier * handle.elementBase.clientWidth;
+            if (index === this.pages.length - 1)
+                newSize = newSize - 5;
+            handle.elementBase.style.width = newSize + 'px';
+        });
+    }
+    performLayout(children) {
+        // Destroy all existing tab pages not in children
+        this.pages.forEach((tab) => {
+            if (!children.some((x) => x == tab.container)) {
+                tab.handle.removeListener(this.tabHandleListener);
+                tab.destroy();
+                let index = this.pages.indexOf(tab);
+                if (index > -1) {
+                    this.pages.splice(index, 1);
+                }
+            }
+        });
+        let oldActiveTab = this.activeTab;
+        delete this.activeTab;
+        let childPanels = children.filter((child) => {
+            return child.containerType === 'panel';
+        });
+        if (childPanels.length > 0) {
+            // Rebuild new tab pages
+            childPanels.forEach((child) => {
+                let page = null;
+                if (!this.pages.some((x) => {
+                    if (x.container == child) {
+                        page = x;
+                        return true;
+                    }
+                    return false;
+                })) {
+                    page = this.createTabPage(this, child);
+                    page.handle.addListener(this.tabHandleListener);
+                    this.pages.push(page);
+                }
+                // Restore the active selected tab
+                if (oldActiveTab && page.container === oldActiveTab.container)
+                    this.activeTab = page;
+            });
+            this._setTabHandlesVisible(true);
+        }
+        else
+            // Do not show an empty tab handle host with zero tabs
+            this._setTabHandlesVisible(false);
+        if (this.activeTab)
+            this.onTabPageSelected(this.activeTab, false);
+    }
+    _setTabHandlesVisible(visible) {
+        if (visible) {
+            this.tabListElement.classList.add('dockspan-tab-handle-list-container-visible');
+            this.separatorElement.classList.add('dockspan-tab-handle-content-seperator-visible');
+        }
+        else {
+            this.tabListElement.classList.remove('dockspan-tab-handle-list-container-visible');
+            this.separatorElement.classList.remove('dockspan-tab-handle-content-seperator-visible');
+        }
+    }
+    onTabPageSelected(page, active) {
+        this.activeTab = page;
+        this.pages.forEach((tabPage) => {
+            let selected = (tabPage === page);
+            tabPage.setSelected(selected, active);
+        });
+    }
+}

package/lib/TabPage.d.ts

@@ -0,0 +1,20 @@
+import { TabHandle } from "./TabHandle.js";
+import { PanelContainer } from "./PanelContainer.js";
+import { IDockContainer } from "./interfaces/IDockContainer.js";
+import { TabHost } from "./TabHost.js";
+export declare class TabPage {
+    selected: boolean;
+    host: TabHost;
+    container: IDockContainer;
+    panel?: PanelContainer;
+    handle: TabHandle;
+    containerElement: HTMLElement;
+    _initContent: boolean;
+    constructor(host: TabHost, container: IDockContainer);
+    onTitleChanged(): void;
+    destroy(): void;
+    onSelected(): void;
+    setSelected(flag: boolean, isActive: boolean): void;
+    resize(width: number, height: number): void;
+}
+//# sourceMappingURL=TabPage.d.ts.map

package/lib/TabPage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TabPage.d.ts","sourceRoot":"","sources":["../src/TabPage.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAC3C,OAAO,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AACrD,OAAO,EAAE,cAAc,EAAE,MAAM,gCAAgC,CAAC;AAChE,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAGvC,qBAAa,OAAO;IAChB,QAAQ,EAAE,OAAO,CAAC;IAClB,IAAI,EAAE,OAAO,CAAC;IACd,SAAS,EAAE,cAAc,CAAC;IAC1B,KAAK,CAAC,EAAE,cAAc,CAAC;IACvB,MAAM,EAAE,SAAS,CAAC;IAClB,gBAAgB,EAAE,WAAW,CAAC;IAC9B,YAAY,EAAE,OAAO,CAAC;gBAEV,IAAI,EAAE,OAAO,EAAE,SAAS,EAAE,cAAc;IAqBpD,cAAc;IAWd,OAAO;IAgBP,UAAU;IAQV,WAAW,CAAC,IAAI,EAAE,OAAO,EAAE,QAAQ,EAAE,OAAO;IAuB5C,MAAM,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM;CAGvC"}

package/lib/TabPage.js

@@ -0,0 +1,81 @@
+import { TabHandle } from "./TabHandle.js";
+import { PanelContainer } from "./PanelContainer.js";
+import { Utils } from "./Utils.js";
+export class TabPage {
+    selected;
+    host;
+    container;
+    panel;
+    handle;
+    containerElement;
+    _initContent;
+    constructor(host, container) {
+        if (arguments.length === 0) {
+            return;
+        }
+        this.selected = false;
+        this.host = host;
+        this.container = container;
+        this.handle = new TabHandle(this);
+        this.containerElement = container.containerElement;
+        if (container instanceof PanelContainer) {
+            this.panel = container;
+            this.panel.onTitleChanged = this.onTitleChanged.bind(this);
+            this.onTitleChanged();
+        }
+        container.tabPage = this;
+    }
+    onTitleChanged() {
+        this.handle.updateTitle();
+        if (this.panel) {
+            if (this.panel.hasChanges) {
+                this.handle.elementText.classList.add('panel-has-changes');
+            }
+            else {
+                this.handle.elementText.classList.remove('panel-has-changes');
+            }
+        }
+    }
+    destroy() {
+        this.handle.destroy();
+        if (this.container instanceof PanelContainer) {
+            let panel = this.container;
+            delete panel.onTitleChanged;
+        }
+        if (this.host.dockManager.activePanel == this.panel)
+            this.host.dockManager.activePanel = null;
+        this.container.tabPage = null;
+        Utils.removeNode(this.containerElement);
+    }
+    onSelected() {
+        this.host.onTabPageSelected(this, true);
+        if (this.container instanceof PanelContainer) {
+            let panel = this.container;
+            panel.dockManager.notifyOnTabChange(this);
+        }
+    }
+    setSelected(flag, isActive) {
+        this.selected = flag;
+        this.handle.setSelected(flag);
+        if (!this._initContent)
+            this.host.contentElement.appendChild(this.containerElement);
+        this._initContent = true;
+        if (this.selected) {
+            this.containerElement.style.display = 'block';
+            this.panel.setVisible(true);
+            // force a resize again
+            let width = this.host.contentElement.clientWidth;
+            let height = this.host.contentElement.clientHeight;
+            this.container.resize(width, height);
+            if (isActive)
+                this.host.dockManager.activePanel = this.container;
+        }
+        else {
+            this.containerElement.style.display = 'none';
+            this.panel.setVisible(false);
+        }
+    }
+    resize(width, height) {
+        this.container.resize(width, height);
+    }
+}

package/lib/UndockInitiator.d.ts

@@ -0,0 +1,32 @@
+import { EventHandler } from "./EventHandler.js";
+import { Point } from "./Point.js";
+import { Dialog } from "./Dialog.js";
+import { IMouseOrTouchEvent } from "./interfaces/IMouseOrTouchEvent.js";
+/**
+ * Listens for events on the [element] and notifies the [listener]
+ * if an undock event has been invoked.  An undock event is invoked
+ * when the user clicks on the event and drags is beyond the
+ * specified [thresholdPixels]
+ */
+export declare class UndockInitiator {
+    mouseUpHandler: EventHandler;
+    touchUpHandler: EventHandler;
+    mouseMoveHandler: EventHandler;
+    touchMoveHandler: EventHandler;
+    dragStartPosition: Point;
+    thresholdPixels: number;
+    _enabled: boolean;
+    mouseDownHandler: EventHandler;
+    touchDownHandler: EventHandler;
+    element: HTMLElement;
+    _undockededCallback: (e: MouseEvent, dragOffset: Point) => Dialog;
+    touchDownUndockedHandler: EventHandler;
+    constructor(element: Element, undockededCallback: (e: MouseEvent, dragOffset: Point) => Dialog, thresholdPixels?: number);
+    get enabled(): boolean;
+    set enabled(value: boolean);
+    onMouseDown(e: any): void;
+    onMouseUp(): void;
+    onMouseMove(e: IMouseOrTouchEvent): void;
+    _requestUndock(e: any): void;
+}
+//# sourceMappingURL=UndockInitiator.d.ts.map

package/lib/UndockInitiator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"UndockInitiator.d.ts","sourceRoot":"","sources":["../src/UndockInitiator.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AACjD,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AACnC,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AACrC,OAAO,EAAE,kBAAkB,EAAE,MAAM,oCAAoC,CAAC;AAExE;;;;;GAKG;AACH,qBAAa,eAAe;IACxB,cAAc,EAAE,YAAY,CAAC;IAC7B,cAAc,EAAE,YAAY,CAAC;IAC7B,gBAAgB,EAAE,YAAY,CAAC;IAC/B,gBAAgB,EAAE,YAAY,CAAC;IAC/B,iBAAiB,EAAE,KAAK,CAAC;IACzB,eAAe,EAAE,MAAM,CAAC;IACxB,QAAQ,EAAE,OAAO,CAAC;IAClB,gBAAgB,EAAE,YAAY,CAAC;IAC/B,gBAAgB,EAAE,YAAY,CAAC;IAC/B,OAAO,EAAE,WAAW,CAAC;IACrB,mBAAmB,EAAE,CAAC,CAAC,EAAE,UAAU,EAAE,UAAU,EAAE,KAAK,KAAK,MAAM,CAAC;IAClE,wBAAwB,EAAE,YAAY,CAAC;gBAE3B,OAAO,EAAE,OAAO,EAAE,kBAAkB,EAAE,CAAC,CAAC,EAAE,UAAU,EAAE,UAAU,EAAE,KAAK,KAAK,MAAM,EAAE,eAAe,CAAC,EAAE,MAAM;IAWxH,IAAI,OAAO,IAAI,OAAO,CAErB;IACD,IAAI,OAAO,CAAC,KAAK,EAAE,OAAO,EA8CzB;IAED,WAAW,CAAC,CAAC,KAAA;IAuCb,SAAS;IAsBT,WAAW,CAAC,CAAC,EAAE,kBAAkB;IAgBjC,cAAc,CAAC,CAAC,KAAA;CAgBnB"}

package/lib/UndockInitiator.js

@@ -0,0 +1,152 @@
+import { EventHandler } from "./EventHandler.js";
+import { Point } from "./Point.js";
+/**
+ * Listens for events on the [element] and notifies the [listener]
+ * if an undock event has been invoked.  An undock event is invoked
+ * when the user clicks on the event and drags is beyond the
+ * specified [thresholdPixels]
+ */
+export class UndockInitiator {
+    mouseUpHandler;
+    touchUpHandler;
+    mouseMoveHandler;
+    touchMoveHandler;
+    dragStartPosition;
+    thresholdPixels;
+    _enabled;
+    mouseDownHandler;
+    touchDownHandler;
+    element;
+    _undockededCallback;
+    touchDownUndockedHandler;
+    constructor(element, undockededCallback, thresholdPixels) {
+        if (!thresholdPixels) {
+            thresholdPixels = 7;
+        }
+        this.element = element;
+        this._undockededCallback = undockededCallback;
+        this.thresholdPixels = thresholdPixels;
+        this._enabled = false;
+    }
+    get enabled() {
+        return this._enabled;
+    }
+    set enabled(value) {
+        this._enabled = value;
+        if (this._enabled) {
+            if (this.mouseDownHandler) {
+                this.mouseDownHandler.cancel();
+                delete this.mouseDownHandler;
+            }
+            if (this.touchDownHandler) {
+                this.touchDownHandler.cancel();
+                delete this.touchDownHandler;
+            }
+            this.mouseDownHandler = new EventHandler(this.element, 'mousedown', this.onMouseDown.bind(this));
+            this.touchDownHandler = new EventHandler(this.element, 'touchstart', this.onMouseDown.bind(this), { passive: false });
+        }
+        else {
+            if (this.mouseDownHandler) {
+                this.mouseDownHandler.cancel();
+                delete this.mouseDownHandler;
+            }
+            if (this.touchDownHandler) {
+                this.touchDownHandler.cancel();
+                delete this.touchDownHandler;
+            }
+            if (this.mouseUpHandler) {
+                this.mouseUpHandler.cancel();
+                delete this.mouseUpHandler;
+            }
+            if (this.touchUpHandler) {
+                this.touchUpHandler.cancel();
+                delete this.touchUpHandler;
+            }
+            if (this.mouseMoveHandler) {
+                this.mouseMoveHandler.cancel();
+                delete this.mouseMoveHandler;
+            }
+            if (this.touchMoveHandler) {
+                this.touchMoveHandler.cancel();
+                delete this.touchMoveHandler;
+            }
+        }
+    }
+    onMouseDown(e) {
+        e.preventDefault();
+        // Make sure we dont do this on floating dialogs
+        if (this.enabled) {
+            if (e.touches) {
+                if (e.touches.length > 1)
+                    return;
+                e = e.touches[0];
+            }
+            if (this.mouseUpHandler) {
+                this.mouseUpHandler.cancel();
+                delete this.mouseUpHandler;
+            }
+            if (this.touchUpHandler) {
+                this.touchUpHandler.cancel();
+                delete this.touchUpHandler;
+            }
+            if (this.mouseMoveHandler) {
+                this.mouseMoveHandler.cancel();
+                delete this.mouseMoveHandler;
+            }
+            if (this.touchMoveHandler) {
+                this.touchMoveHandler.cancel();
+                delete this.touchMoveHandler;
+            }
+            this.mouseUpHandler = new EventHandler(window, 'mouseup', this.onMouseUp.bind(this));
+            this.touchUpHandler = new EventHandler(window, 'touchend', this.onMouseUp.bind(this));
+            this.mouseMoveHandler = new EventHandler(window, 'mousemove', this.onMouseMove.bind(this));
+            this.touchMoveHandler = new EventHandler(window, 'touchmove', this.onMouseMove.bind(this));
+            this.dragStartPosition = new Point(e.clientX, e.clientY);
+        }
+    }
+    onMouseUp() {
+        if (this.mouseUpHandler) {
+            this.mouseUpHandler.cancel();
+            delete this.mouseUpHandler;
+        }
+        if (this.touchUpHandler) {
+            this.touchUpHandler.cancel();
+            delete this.touchUpHandler;
+        }
+        if (this.mouseMoveHandler) {
+            this.mouseMoveHandler.cancel();
+            delete this.mouseMoveHandler;
+        }
+        if (this.touchMoveHandler) {
+            this.touchMoveHandler.cancel();
+            delete this.touchMoveHandler;
+        }
+    }
+    onMouseMove(e) {
+        if (e.touches) {
+            if (e.touches.length > 1)
+                return;
+            e = e.touches[0];
+        }
+        let position = new Point(e.clientX, e.clientY);
+        let dy = position.y - this.dragStartPosition.y;
+        if (dy > this.thresholdPixels || dy < -this.thresholdPixels) {
+            this.enabled = false;
+            this._requestUndock(e);
+        }
+    }
+    _requestUndock(e) {
+        let top = 0;
+        let left = 0;
+        let currentElement = this.element;
+        do {
+            top += currentElement.offsetTop || 0;
+            left += currentElement.offsetLeft || 0;
+            currentElement = currentElement.offsetParent;
+        } while (currentElement);
+        let dragOffsetX = this.dragStartPosition.x - left;
+        let dragOffsetY = this.dragStartPosition.y - top;
+        let dragOffset = new Point(dragOffsetX, dragOffsetY);
+        this._undockededCallback(e, dragOffset);
+    }
+}

package/lib/Utils.d.ts

@@ -0,0 +1,15 @@
+import { DockNode } from "./DockNode";
+export declare class Utils {
+    private static _counter;
+    static getPixels(pixels: string): number;
+    static disableGlobalTextSelection(element: HTMLElement): void;
+    static enableGlobalTextSelection(element: HTMLElement): void;
+    static isPointInsideNode(px: number, py: number, node: DockNode): boolean;
+    static getNextId(prefix: string): string;
+    static removeNode(node: Node): boolean;
+    static orderByIndexes<T>(array: T[], indexes: number[]): any[];
+    static arrayRemove<T>(array: T[], value: any): T[] | false;
+    static arrayContains<T>(array: T[], value: T): boolean;
+    static arrayEqual<T>(a: T[], b: T[]): boolean;
+}
+//# sourceMappingURL=Utils.d.ts.map

package/lib/Utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Utils.d.ts","sourceRoot":"","sources":["../src/Utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAEtC,qBAAa,KAAK;IAEd,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAa;IAEpC,MAAM,CAAC,SAAS,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM;IAQxC,MAAM,CAAC,0BAA0B,CAAC,OAAO,EAAE,WAAW;IAItD,MAAM,CAAC,yBAAyB,CAAC,OAAO,EAAE,WAAW;IAIrD,MAAM,CAAC,iBAAiB,CAAC,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,IAAI,EAAE,QAAQ,GAAG,OAAO;IAYzE,MAAM,CAAC,SAAS,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM;IAIxC,MAAM,CAAC,UAAU,CAAC,IAAI,EAAE,IAAI,GAAG,OAAO;IAUtC,MAAM,CAAC,cAAc,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,EAAE,OAAO,EAAE,MAAM,EAAE;IAQtD,MAAM,CAAC,WAAW,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,EAAE,KAAK,EAAE,GAAG,GAAG,CAAC,EAAE,GAAG,KAAK;IAQ1D,MAAM,CAAC,aAAa,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,EAAE,KAAK,EAAE,CAAC,GAAG,OAAO;IAUtD,MAAM,CAAC,UAAU,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,EAAE,CAAC,EAAE,GAAG,OAAO;CAUhD"}

package/lib/Utils.js

@@ -0,0 +1,69 @@
+export class Utils {
+    static _counter = 0;
+    static getPixels(pixels) {
+        if (pixels === null) {
+            return 0;
+        }
+        return parseInt(pixels.replace('px', ''));
+    }
+    static disableGlobalTextSelection(element) {
+        element.classList.add('disable-selection');
+    }
+    static enableGlobalTextSelection(element) {
+        element.classList.remove('disable-selection');
+    }
+    static isPointInsideNode(px, py, node) {
+        let element = node.container.containerElement;
+        let rect = element.getBoundingClientRect();
+        return (px >= rect.left &&
+            px <= rect.left + rect.width &&
+            py >= rect.top &&
+            py <= rect.top + rect.height);
+    }
+    static getNextId(prefix) {
+        return prefix + Utils._counter++;
+    }
+    static removeNode(node) {
+        if (node.parentNode === null) {
+            return false;
+        }
+        node.parentNode.removeChild(node);
+        return true;
+    }
+    static orderByIndexes(array, indexes) {
+        let sortedArray = [];
+        for (let i = 0; i < indexes.length; i++) {
+            sortedArray.push(array[indexes[i]]);
+        }
+        return sortedArray;
+    }
+    static arrayRemove(array, value) {
+        let idx = array.indexOf(value);
+        if (idx !== -1) {
+            return array.splice(idx, 1);
+        }
+        return false;
+    }
+    static arrayContains(array, value) {
+        let i = array.length;
+        while (i--) {
+            if (array[i] === value) {
+                return true;
+            }
+        }
+        return false;
+    }
+    static arrayEqual(a, b) {
+        if (a === b)
+            return true;
+        if (a == null || b == null)
+            return false;
+        if (a.length != b.length)
+            return false;
+        for (let i = 0; i < a.length; ++i) {
+            if (a[i] !== b[i])
+                return false;
+        }
+        return true;
+    }
+}

package/lib/VerticalDockContainer.d.ts

@@ -0,0 +1,7 @@
+import { SplitterDockContainer } from "./SplitterDockContainer.js";
+import { DockManager } from "./DockManager.js";
+import { IDockContainer } from "./interfaces/IDockContainer.js";
+export declare class VerticalDockContainer extends SplitterDockContainer {
+    constructor(dockManager: DockManager, childContainers: IDockContainer[]);
+}
+//# sourceMappingURL=VerticalDockContainer.d.ts.map

package/lib/VerticalDockContainer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"VerticalDockContainer.d.ts","sourceRoot":"","sources":["../src/VerticalDockContainer.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,qBAAqB,EAAE,MAAM,4BAA4B,CAAC;AAGnE,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAC/C,OAAO,EAAE,cAAc,EAAE,MAAM,gCAAgC,CAAC;AAEhE,qBAAa,qBAAsB,SAAQ,qBAAqB;gBAEhD,WAAW,EAAE,WAAW,EAAE,eAAe,EAAE,cAAc,EAAE;CAI1E"}

package/lib/VerticalDockContainer.js

@@ -0,0 +1,9 @@
+import { SplitterDockContainer } from "./SplitterDockContainer.js";
+import { Utils } from "./Utils.js";
+import { ContainerType } from "./ContainerType.js";
+export class VerticalDockContainer extends SplitterDockContainer {
+    constructor(dockManager, childContainers) {
+        super(Utils.getNextId('vertical_splitter_'), dockManager, childContainers, true);
+        this.containerType = ContainerType.vertical;
+    }
+}

package/lib/enums/PanelType.d.ts

@@ -0,0 +1,5 @@
+export declare enum PanelType {
+    'document' = "document",
+    'panel' = "panel"
+}
+//# sourceMappingURL=PanelType.d.ts.map

package/lib/enums/PanelType.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PanelType.d.ts","sourceRoot":"","sources":["../../src/enums/PanelType.ts"],"names":[],"mappings":"AAAA,oBAAY,SAAS;IACjB,UAAU,aAAa;IACvB,OAAO,UAAU;CACpB"}

package/lib/enums/PanelType.js

@@ -0,0 +1,5 @@
+export var PanelType;
+(function (PanelType) {
+    PanelType["document"] = "document";
+    PanelType["panel"] = "panel";
+})(PanelType || (PanelType = {}));

package/lib/enums/TabHostDirection.d.ts

@@ -0,0 +1,7 @@
+export declare enum TabHostDirection {
+    TOP = 0,
+    BOTTOM = 1,
+    LEFT = 2,
+    RIGHT = 3
+}
+//# sourceMappingURL=TabHostDirection.d.ts.map

package/lib/enums/TabHostDirection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TabHostDirection.d.ts","sourceRoot":"","sources":["../../src/enums/TabHostDirection.ts"],"names":[],"mappings":"AAAA,oBAAY,gBAAgB;IACxB,GAAG,IAAI;IACP,MAAM,IAAI;IACV,IAAI,IAAI;IACR,KAAK,IAAI;CACZ"}