dockview-core 7.0.4 → 8.0.0

package/dist/esm/paneview/paneviewPanel.js

@@ -1,192 +0,0 @@
-import { PaneviewPanelApiImpl } from '../api/paneviewPanelApi';
-import { addClasses, removeClasses } from '../dom';
-import { addDisposableListener, Emitter } from '../events';
-import { BasePanelView, } from '../gridview/basePanelView';
-import { Orientation } from '../splitview/splitview';
-export class PaneviewPanel extends BasePanelView {
-    set orientation(value) {
-        this._orientation = value;
-    }
-    get orientation() {
-        return this._orientation;
-    }
-    get minimumSize() {
-        const headerSize = this.headerSize;
-        const expanded = this.isExpanded();
-        const minimumBodySize = expanded ? this._minimumBodySize : 0;
-        return headerSize + minimumBodySize;
-    }
-    get maximumSize() {
-        const headerSize = this.headerSize;
-        const expanded = this.isExpanded();
-        const maximumBodySize = expanded ? this._maximumBodySize : 0;
-        return headerSize + maximumBodySize;
-    }
-    get size() {
-        return this._size;
-    }
-    get orthogonalSize() {
-        return this._orthogonalSize;
-    }
-    set orthogonalSize(size) {
-        this._orthogonalSize = size;
-    }
-    get minimumBodySize() {
-        return this._minimumBodySize;
-    }
-    set minimumBodySize(value) {
-        this._minimumBodySize = typeof value === 'number' ? value : 0;
-    }
-    get maximumBodySize() {
-        return this._maximumBodySize;
-    }
-    set maximumBodySize(value) {
-        this._maximumBodySize =
-            typeof value === 'number' ? value : Number.POSITIVE_INFINITY;
-    }
-    get headerVisible() {
-        return this._headerVisible;
-    }
-    set headerVisible(value) {
-        this._headerVisible = value;
-        this.header.style.display = value ? '' : 'none';
-    }
-    constructor(options) {
-        super(options.id, options.component, new PaneviewPanelApiImpl(options.id, options.component));
-        this._onDidChangeExpansionState = new Emitter({ replay: true });
-        this.onDidChangeExpansionState = this._onDidChangeExpansionState.event;
-        this._onDidChange = new Emitter();
-        this.onDidChange = this._onDidChange.event;
-        this._orthogonalSize = 0;
-        this._size = 0;
-        this._isExpanded = false;
-        this.api.pane = this; // TODO cannot use 'this' before 'super'
-        this.api.initialize(this);
-        this.headerSize = options.headerSize;
-        this.headerComponent = options.headerComponent;
-        this._minimumBodySize = options.minimumBodySize;
-        this._maximumBodySize = options.maximumBodySize;
-        this._isExpanded = options.isExpanded;
-        this._headerVisible = options.isHeaderVisible;
-        this._onDidChangeExpansionState.fire(this.isExpanded()); // initialize value
-        this._orientation = options.orientation;
-        this.element.classList.add('dv-pane');
-        this.addDisposables(this.api.onWillVisibilityChange((event) => {
-            const { isVisible } = event;
-            const { accessor } = this._params;
-            accessor.setVisible(this, isVisible);
-        }), this.api.onDidSizeChange((event) => {
-            this._onDidChange.fire({ size: event.size });
-        }), addDisposableListener(this.element, 'mouseenter', (ev) => {
-            this.api._onMouseEnter.fire(ev);
-        }), addDisposableListener(this.element, 'mouseleave', (ev) => {
-            this.api._onMouseLeave.fire(ev);
-        }));
-        this.addDisposables(this._onDidChangeExpansionState, this.onDidChangeExpansionState((isPanelExpanded) => {
-            this.api._onDidExpansionChange.fire({
-                isExpanded: isPanelExpanded,
-            });
-        }), this.api.onDidFocusChange((e) => {
-            if (!this.header) {
-                return;
-            }
-            if (e.isFocused) {
-                addClasses(this.header, 'focused');
-            }
-            else {
-                removeClasses(this.header, 'focused');
-            }
-        }));
-        this.renderOnce();
-    }
-    setVisible(isVisible) {
-        this.api._onDidVisibilityChange.fire({ isVisible });
-    }
-    setActive(isActive) {
-        this.api._onDidActiveChange.fire({ isActive });
-    }
-    isExpanded() {
-        return this._isExpanded;
-    }
-    setExpanded(expanded) {
-        if (this._isExpanded === expanded) {
-            return;
-        }
-        this._isExpanded = expanded;
-        if (expanded) {
-            if (this.animationTimer) {
-                clearTimeout(this.animationTimer);
-            }
-            if (this.body) {
-                this.element.appendChild(this.body);
-            }
-        }
-        else {
-            this.animationTimer = setTimeout(() => {
-                var _a;
-                (_a = this.body) === null || _a === void 0 ? void 0 : _a.remove();
-            }, 200);
-        }
-        this._onDidChange.fire(expanded ? { size: this.width } : {});
-        this._onDidChangeExpansionState.fire(expanded);
-    }
-    layout(size, orthogonalSize) {
-        this._size = size;
-        this._orthogonalSize = orthogonalSize;
-        const [width, height] = this.orientation === Orientation.HORIZONTAL
-            ? [size, orthogonalSize]
-            : [orthogonalSize, size];
-        super.layout(width, height);
-    }
-    init(parameters) {
-        var _a, _b;
-        super.init(parameters);
-        if (typeof parameters.minimumBodySize === 'number') {
-            this.minimumBodySize = parameters.minimumBodySize;
-        }
-        if (typeof parameters.maximumBodySize === 'number') {
-            this.maximumBodySize = parameters.maximumBodySize;
-        }
-        this.bodyPart = this.getBodyComponent();
-        this.headerPart = this.getHeaderComponent();
-        this.bodyPart.init(Object.assign(Object.assign({}, parameters), { api: this.api }));
-        this.headerPart.init(Object.assign(Object.assign({}, parameters), { api: this.api }));
-        (_a = this.body) === null || _a === void 0 ? void 0 : _a.append(this.bodyPart.element);
-        (_b = this.header) === null || _b === void 0 ? void 0 : _b.append(this.headerPart.element);
-        if (typeof parameters.isExpanded === 'boolean') {
-            this.setExpanded(parameters.isExpanded);
-        }
-    }
-    toJSON() {
-        const params = this._params;
-        return Object.assign(Object.assign({}, super.toJSON()), { headerComponent: this.headerComponent, title: params.title });
-    }
-    renderOnce() {
-        this.header = document.createElement('div');
-        this.header.tabIndex = 0;
-        this.header.className = 'dv-pane-header';
-        this.header.style.height = `${this.headerSize}px`;
-        this.header.style.lineHeight = `${this.headerSize}px`;
-        this.header.style.minHeight = `${this.headerSize}px`;
-        this.header.style.maxHeight = `${this.headerSize}px`;
-        this.element.appendChild(this.header);
-        this.body = document.createElement('div');
-        this.body.className = 'dv-pane-body';
-        this.element.appendChild(this.body);
-    }
-    // TODO slightly hacky by-pass of the component to create a body and header component
-    getComponent() {
-        return {
-            update: (params) => {
-                var _a, _b;
-                (_a = this.bodyPart) === null || _a === void 0 ? void 0 : _a.update({ params });
-                (_b = this.headerPart) === null || _b === void 0 ? void 0 : _b.update({ params });
-            },
-            dispose: () => {
-                var _a, _b;
-                (_a = this.bodyPart) === null || _a === void 0 ? void 0 : _a.dispose();
-                (_b = this.headerPart) === null || _b === void 0 ? void 0 : _b.dispose();
-            },
-        };
-    }
-}

package/dist/esm/popoutWindow.d.ts

@@ -1,38 +0,0 @@
-import { CspNonceProvider } from './dom';
-import { CompositeDisposable } from './lifecycle';
-import { Box } from './types';
-export type PopoutWindowOptions = {
-    url: string;
-    onDidOpen?: (event: {
-        id: string;
-        window: Window;
-    }) => void;
-    onWillClose?: (event: {
-        id: string;
-        window: Window;
-    }) => void;
-    nonce?: CspNonceProvider;
-} & Box;
-/**
- * Reject popout URLs that aren't same-origin http(s). Blocks `javascript:`,
- * `data:`, `blob:`, `vbscript:`, and cross-origin URLs that would otherwise
- * execute in a context the browser still associates with the opener via
- * `window.opener`.
- */
-export declare function assertSameOriginPopoutUrl(url: string): void;
-export declare class PopoutWindow extends CompositeDisposable {
-    private readonly target;
-    private readonly className;
-    private readonly options;
-    private readonly _onWillClose;
-    readonly onWillClose: import("./events").Event<void>;
-    private readonly _onDidClose;
-    readonly onDidClose: import("./events").Event<void>;
-    private _window;
-    get window(): Window | null;
-    constructor(target: string, className: string, options: PopoutWindowOptions);
-    dimensions(): Box | null;
-    close(): void;
-    open(): Promise<HTMLElement | null>;
-    private createPopoutWindowContainer;
-}

package/dist/esm/popoutWindow.js

@@ -1,170 +0,0 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-import { addStyles } from './dom';
-import { Emitter, addDisposableListener } from './events';
-import { CompositeDisposable, Disposable } from './lifecycle';
-/**
- * Reject popout URLs that aren't same-origin http(s). Blocks `javascript:`,
- * `data:`, `blob:`, `vbscript:`, and cross-origin URLs that would otherwise
- * execute in a context the browser still associates with the opener via
- * `window.opener`.
- */
-export function assertSameOriginPopoutUrl(url) {
-    let resolved;
-    try {
-        resolved = new URL(url, globalThis.location.href);
-    }
-    catch (_a) {
-        throw new Error(`dockview: invalid popout URL: ${url}`);
-    }
-    const protocolOk = resolved.protocol === 'http:' || resolved.protocol === 'https:';
-    if (!protocolOk || resolved.origin !== globalThis.location.origin) {
-        throw new Error(`dockview: popout URL must be same-origin http(s); got: ${url}`);
-    }
-}
-export class PopoutWindow extends CompositeDisposable {
-    get window() {
-        var _a, _b;
-        return (_b = (_a = this._window) === null || _a === void 0 ? void 0 : _a.value) !== null && _b !== void 0 ? _b : null;
-    }
-    constructor(target, className, options) {
-        super();
-        this.target = target;
-        this.className = className;
-        this.options = options;
-        this._onWillClose = new Emitter();
-        this.onWillClose = this._onWillClose.event;
-        this._onDidClose = new Emitter();
-        this.onDidClose = this._onDidClose.event;
-        this._window = null;
-        this.addDisposables(this._onWillClose, this._onDidClose, {
-            dispose: () => {
-                this.close();
-            },
-        });
-    }
-    dimensions() {
-        if (!this._window) {
-            return null;
-        }
-        const left = this._window.value.screenX;
-        const top = this._window.value.screenY;
-        const width = this._window.value.innerWidth;
-        const height = this._window.value.innerHeight;
-        return { top, left, width, height };
-    }
-    close() {
-        var _a, _b;
-        if (this._window) {
-            this._onWillClose.fire();
-            (_b = (_a = this.options).onWillClose) === null || _b === void 0 ? void 0 : _b.call(_a, {
-                id: this.target,
-                window: this._window.value,
-            });
-            this._window.disposable.dispose();
-            this._window = null;
-            this._onDidClose.fire();
-        }
-    }
-    open() {
-        return __awaiter(this, void 0, void 0, function* () {
-            var _a, _b;
-            if (this._window) {
-                throw new Error('instance of popout window is already open');
-            }
-            const url = `${this.options.url}`;
-            assertSameOriginPopoutUrl(url);
-            const features = Object.entries({
-                top: this.options.top,
-                left: this.options.left,
-                width: this.options.width,
-                height: this.options.height,
-            })
-                .map(([key, value]) => `${key}=${value}`)
-                .join(',');
-            /**
-             * @see https://developer.mozilla.org/en-US/docs/Web/API/Window/open
-             */
-            const externalWindow = window.open(url, this.target, features);
-            if (!externalWindow) {
-                /**
-                 * Popup blocked
-                 */
-                return null;
-            }
-            const disposable = new CompositeDisposable();
-            this._window = { value: externalWindow, disposable };
-            disposable.addDisposables(Disposable.from(() => {
-                externalWindow.close();
-            }), addDisposableListener(globalThis.window, 'beforeunload', () => {
-                /**
-                 * before the main window closes we should close this popup too
-                 * to be good citizens
-                 *
-                 * @see https://developer.mozilla.org/en-US/docs/Web/API/Window/beforeunload_event
-                 */
-                this.close();
-            }));
-            const container = this.createPopoutWindowContainer();
-            if (this.className) {
-                container.classList.add(this.className);
-            }
-            (_b = (_a = this.options).onDidOpen) === null || _b === void 0 ? void 0 : _b.call(_a, {
-                id: this.target,
-                window: externalWindow,
-            });
-            return new Promise((resolve, reject) => {
-                externalWindow.addEventListener('unload', (e) => {
-                    // if page fails to load before unloading
-                    // this.close();
-                });
-                externalWindow.addEventListener('load', () => {
-                    /**
-                     * @see https://developer.mozilla.org/en-US/docs/Web/API/Window/load_event
-                     */
-                    try {
-                        const externalDocument = externalWindow.document;
-                        externalDocument.title = document.title;
-                        externalDocument.body.appendChild(container);
-                        addStyles(externalDocument, globalThis.document.styleSheets, {
-                            nonce: this.options.nonce,
-                        });
-                        /**
-                         * beforeunload must be registered after load for reasons I could not determine
-                         * otherwise the beforeunload event will not fire when the window is closed
-                         */
-                        addDisposableListener(externalWindow, 'beforeunload', () => {
-                            /**
-                             * @see https://developer.mozilla.org/en-US/docs/Web/API/Window/beforeunload_event
-                             */
-                            this.close();
-                        });
-                        resolve(container);
-                    }
-                    catch (err) {
-                        // only except this is the DOM isn't setup. e.g. in a in correctly configured test
-                        reject(err);
-                    }
-                });
-            });
-        });
-    }
-    createPopoutWindowContainer() {
-        const el = document.createElement('div');
-        el.classList.add('dv-popout-window');
-        el.id = 'dv-popout-window';
-        el.style.position = 'absolute';
-        el.style.width = '100%';
-        el.style.height = '100%';
-        el.style.top = '0px';
-        el.style.left = '0px';
-        return el;
-    }
-}

package/dist/esm/resizable.d.ts

@@ -1,12 +0,0 @@
-import { CompositeDisposable } from './lifecycle';
-export declare abstract class Resizable extends CompositeDisposable {
-    private readonly _element;
-    private _disableResizing;
-    private _lastWidth;
-    private _lastHeight;
-    get element(): HTMLElement;
-    get disableResizing(): boolean;
-    set disableResizing(value: boolean);
-    constructor(parentElement: HTMLElement, disableResizing?: boolean);
-    abstract layout(width: number, height: number): void;
-}

package/dist/esm/resizable.js

@@ -1,66 +0,0 @@
-import { isInDocument, watchElementResize } from './dom';
-import { CompositeDisposable } from './lifecycle';
-export class Resizable extends CompositeDisposable {
-    get element() {
-        return this._element;
-    }
-    get disableResizing() {
-        return this._disableResizing;
-    }
-    set disableResizing(value) {
-        this._disableResizing = value;
-    }
-    constructor(parentElement, disableResizing = false) {
-        super();
-        this._lastWidth = -1;
-        this._lastHeight = -1;
-        this._disableResizing = disableResizing;
-        this._element = parentElement;
-        this.addDisposables(watchElementResize(this._element, (entry) => {
-            if (this.isDisposed) {
-                /**
-                 * resize is delayed through requestAnimationFrame so there is a small chance
-                 * the component has already been disposed of
-                 */
-                return;
-            }
-            if (this.disableResizing) {
-                return;
-            }
-            if (!this._element.offsetParent) {
-                /**
-                 * offsetParent === null is equivalent to display: none being set on the element or one
-                 * of it's parents. In the display: none case the size will become (0, 0) which we do
-                 * not want to propagate.
-                 *
-                 * @see https://developer.mozilla.org/en-US/docs/Web/API/HTMLElement/offsetParent
-                 *
-                 * You could use checkVisibility() but at the time of writing it's not supported across
-                 * all Browsers
-                 *
-                 * @see https://developer.mozilla.org/en-US/docs/Web/API/Element/checkVisibility
-                 */
-                return;
-            }
-            if (!isInDocument(this._element)) {
-                /**
-                 * since the event is dispatched through requestAnimationFrame there is a small chance
-                 * the component is no longer attached to the DOM, if that is the case the dimensions
-                 * are mostly likely all zero and meaningless. we should skip this case.
-                 */
-                return;
-            }
-            // Round to integers to absorb sub-pixel jitter from
-            // fractional devicePixelRatio (e.g. multi-monitor setups),
-            // which would otherwise re-fire layout in a feedback loop.
-            const width = Math.round(entry.contentRect.width);
-            const height = Math.round(entry.contentRect.height);
-            if (width === this._lastWidth && height === this._lastHeight) {
-                return;
-            }
-            this._lastWidth = width;
-            this._lastHeight = height;
-            this.layout(width, height);
-        }));
-    }
-}

package/dist/esm/scrollbar.d.ts

@@ -1,15 +0,0 @@
-import { CompositeDisposable } from './lifecycle';
-export declare class Scrollbar extends CompositeDisposable {
-    private readonly scrollableElement;
-    private readonly _element;
-    private readonly _scrollbar;
-    private _scrollOffset;
-    private _animationTimer;
-    private _orientation;
-    static readonly MouseWheelSpeed = 1;
-    get element(): HTMLElement;
-    get orientation(): 'horizontal' | 'vertical';
-    set orientation(value: 'horizontal' | 'vertical');
-    constructor(scrollableElement: HTMLElement);
-    private calculateScrollbarStyles;
-}

package/dist/esm/scrollbar.js

@@ -1,139 +0,0 @@
-import { addClasses, removeClasses, toggleClass, watchElementResize, } from './dom';
-import { addDisposableListener } from './events';
-import { CompositeDisposable } from './lifecycle';
-import { clamp } from './math';
-export class Scrollbar extends CompositeDisposable {
-    get element() {
-        return this._element;
-    }
-    get orientation() {
-        return this._orientation;
-    }
-    set orientation(value) {
-        if (this._orientation === value) {
-            return;
-        }
-        this._scrollOffset = 0;
-        this._orientation = value;
-        removeClasses(this._scrollbar, 'dv-scrollbar-vertical', 'dv-scrollbar-horizontal');
-        if (value === 'vertical') {
-            addClasses(this._scrollbar, 'dv-scrollbar-vertical');
-        }
-        else {
-            addClasses(this._scrollbar, 'dv-scrollbar-horizontal');
-        }
-    }
-    constructor(scrollableElement) {
-        super();
-        this.scrollableElement = scrollableElement;
-        this._scrollOffset = 0;
-        this._orientation = 'horizontal';
-        this._element = document.createElement('div');
-        this._element.className = 'dv-scrollable';
-        this._scrollbar = document.createElement('div');
-        this._scrollbar.className = 'dv-scrollbar dv-scrollbar-horizontal';
-        this.element.appendChild(scrollableElement);
-        this.element.appendChild(this._scrollbar);
-        this.addDisposables(addDisposableListener(this.element, 'wheel', (event) => {
-            this._scrollOffset += event.deltaY * Scrollbar.MouseWheelSpeed;
-            this.calculateScrollbarStyles();
-        }), addDisposableListener(this._scrollbar, 'pointerdown', (event) => {
-            event.preventDefault();
-            toggleClass(this.element, 'dv-scrollable-scrolling', true);
-            const originalClient = this._orientation === 'horizontal'
-                ? event.clientX
-                : event.clientY;
-            const originalScrollOffset = this._scrollOffset;
-            const onPointerMove = (event) => {
-                const delta = this._orientation === 'horizontal'
-                    ? event.clientX - originalClient
-                    : event.clientY - originalClient;
-                const clientSize = this._orientation === 'horizontal'
-                    ? this.element.clientWidth
-                    : this.element.clientHeight;
-                const scrollSize = this._orientation === 'horizontal'
-                    ? this.scrollableElement.scrollWidth
-                    : this.scrollableElement.scrollHeight;
-                const p = clientSize / scrollSize;
-                this._scrollOffset = originalScrollOffset + delta / p;
-                this.calculateScrollbarStyles();
-            };
-            const doc = this.element.ownerDocument;
-            const onEnd = () => {
-                toggleClass(this.element, 'dv-scrollable-scrolling', false);
-                doc.removeEventListener('pointermove', onPointerMove);
-                doc.removeEventListener('pointerup', onEnd);
-                doc.removeEventListener('pointercancel', onEnd);
-            };
-            doc.addEventListener('pointermove', onPointerMove);
-            doc.addEventListener('pointerup', onEnd);
-            doc.addEventListener('pointercancel', onEnd);
-        }), addDisposableListener(this.element, 'scroll', () => {
-            this.calculateScrollbarStyles();
-        }), addDisposableListener(this.scrollableElement, 'scroll', () => {
-            this._scrollOffset =
-                this._orientation === 'horizontal'
-                    ? this.scrollableElement.scrollLeft
-                    : this.scrollableElement.scrollTop;
-            this.calculateScrollbarStyles();
-        }), watchElementResize(this.element, () => {
-            toggleClass(this.element, 'dv-scrollable-resizing', true);
-            if (this._animationTimer) {
-                clearTimeout(this._animationTimer);
-            }
-            this._animationTimer = setTimeout(() => {
-                clearTimeout(this._animationTimer);
-                toggleClass(this.element, 'dv-scrollable-resizing', false);
-            }, 500);
-            this.calculateScrollbarStyles();
-        }));
-    }
-    calculateScrollbarStyles() {
-        const clientSize = this._orientation === 'horizontal'
-            ? this.element.clientWidth
-            : this.element.clientHeight;
-        const scrollSize = this._orientation === 'horizontal'
-            ? this.scrollableElement.scrollWidth
-            : this.scrollableElement.scrollHeight;
-        const hasScrollbar = scrollSize > clientSize;
-        if (hasScrollbar) {
-            const px = clientSize * (clientSize / scrollSize);
-            if (this._orientation === 'horizontal') {
-                this._scrollbar.style.width = `${px}px`;
-                this._scrollbar.style.height = '';
-            }
-            else {
-                this._scrollbar.style.height = `${px}px`;
-                this._scrollbar.style.width = '';
-            }
-            this._scrollOffset = clamp(this._scrollOffset, 0, scrollSize - clientSize);
-            if (this._orientation === 'horizontal') {
-                this.scrollableElement.scrollLeft = this._scrollOffset;
-            }
-            else {
-                this.scrollableElement.scrollTop = this._scrollOffset;
-            }
-            const percentageComplete = this._scrollOffset / (scrollSize - clientSize);
-            if (this._orientation === 'horizontal') {
-                this._scrollbar.style.left = `${(clientSize - px) * percentageComplete}px`;
-                this._scrollbar.style.top = '';
-            }
-            else {
-                this._scrollbar.style.top = `${(clientSize - px) * percentageComplete}px`;
-                this._scrollbar.style.left = '';
-            }
-        }
-        else {
-            if (this._orientation === 'horizontal') {
-                this._scrollbar.style.width = '0px';
-                this._scrollbar.style.left = '0px';
-            }
-            else {
-                this._scrollbar.style.height = '0px';
-                this._scrollbar.style.top = '0px';
-            }
-            this._scrollOffset = 0;
-        }
-    }
-}
-Scrollbar.MouseWheelSpeed = 1;

package/dist/esm/splitview/options.d.ts

@@ -1,21 +0,0 @@
-import { PanelInitParameters } from '../panel/types';
-import { SplitViewOptions, LayoutPriority } from './splitview';
-import { SplitviewPanel } from './splitviewPanel';
-import { SplitviewComponent } from './splitviewComponent';
-import { CreateComponentOptions } from '../dockview/options';
-export interface PanelViewInitParameters extends PanelInitParameters {
-    minimumSize?: number;
-    maximumSize?: number;
-    snap?: boolean;
-    priority?: LayoutPriority;
-    accessor: SplitviewComponent;
-}
-export interface SplitviewOptions extends SplitViewOptions {
-    disableAutoResizing?: boolean;
-    className?: string;
-}
-export interface SplitviewFrameworkOptions {
-    createComponent: (options: CreateComponentOptions) => SplitviewPanel;
-}
-export type SplitviewComponentOptions = SplitviewOptions & SplitviewFrameworkOptions;
-export declare const PROPERTY_KEYS_SPLITVIEW: (keyof SplitviewOptions)[];

package/dist/esm/splitview/options.js

@@ -1,16 +0,0 @@
-export const PROPERTY_KEYS_SPLITVIEW = (() => {
-    /**
-     * by readong the keys from an empty value object TypeScript will error
-     * when we add or remove new properties to `DockviewOptions`
-     */
-    const properties = {
-        orientation: undefined,
-        descriptor: undefined,
-        proportionalLayout: undefined,
-        styles: undefined,
-        margin: undefined,
-        disableAutoResizing: undefined,
-        className: undefined,
-    };
-    return Object.keys(properties);
-})();