dockview 0.0.28 → 1.0.0

package/dist/esm/dnd/dataTransfer.js

@@ -1,109 +1,109 @@
-import { tryParseJSON } from '../json';
-class TransferObject {
-    constructor() {
-        //
-    }
-}
-export class PanelTransfer extends TransferObject {
-    constructor(viewId, groupId, panelId) {
-        super();
-        this.viewId = viewId;
-        this.groupId = groupId;
-        this.panelId = panelId;
-    }
-}
-export class PaneTransfer extends TransferObject {
-    constructor(viewId, paneId) {
-        super();
-        this.viewId = viewId;
-        this.paneId = paneId;
-    }
-}
-export const DATA_KEY = 'splitview/transfer';
-export const isPanelTransferEvent = (event) => {
-    if (!event.dataTransfer) {
-        return false;
-    }
-    return event.dataTransfer.types.includes(DATA_KEY);
-};
-export var DragType;
-(function (DragType) {
-    DragType["DOCKVIEW_TAB"] = "dockview_tab";
-    DragType["EXTERNAL"] = "external_group_drag";
-})(DragType || (DragType = {}));
-/**
- * Determine whether this data belong to that of an event that was started by
- * dragging a tab component
- */
-export const isTabDragEvent = (data) => {
-    return data.type === DragType.DOCKVIEW_TAB;
-};
-/**
- * Determine whether this data belong to that of an event that was started by
- * a custom drag-enable component
- */
-export const isCustomDragEvent = (data) => {
-    return data.type === DragType.EXTERNAL;
-};
-export const extractData = (event) => {
-    if (!event.dataTransfer) {
-        return null;
-    }
-    const data = tryParseJSON(event.dataTransfer.getData(DATA_KEY));
-    if (!data) {
-        console.warn(`[dragEvent] ${DATA_KEY} data is missing`);
-    }
-    if (typeof data.type !== 'string') {
-        console.warn(`[dragEvent] invalid type ${data.type}`);
-    }
-    return data;
-};
-/**
- * A singleton to store transfer data during drag & drop operations that are only valid within the application.
- */
-export class LocalSelectionTransfer {
-    constructor() {
-        // protect against external instantiation
-    }
-    static getInstance() {
-        return LocalSelectionTransfer.INSTANCE;
-    }
-    hasData(proto) {
-        return proto && proto === this.proto;
-    }
-    clearData(proto) {
-        if (this.hasData(proto)) {
-            this.proto = undefined;
-            this.data = undefined;
-        }
-    }
-    getData(proto) {
-        if (this.hasData(proto)) {
-            return this.data;
-        }
-        return undefined;
-    }
-    setData(data, proto) {
-        if (proto) {
-            this.data = data;
-            this.proto = proto;
-        }
-    }
-}
-LocalSelectionTransfer.INSTANCE = new LocalSelectionTransfer();
-export function getPanelData() {
-    const panelTransfer = LocalSelectionTransfer.getInstance();
-    const isPanelEvent = panelTransfer.hasData(PanelTransfer.prototype);
-    if (!isPanelEvent) {
-        return undefined;
-    }
-    return panelTransfer.getData(PanelTransfer.prototype)[0];
-}
-export function getPaneData() {
-    const paneTransfer = LocalSelectionTransfer.getInstance();
-    const isPanelEvent = paneTransfer.hasData(PaneTransfer.prototype);
-    if (!isPanelEvent) {
-        return undefined;
-    }
-    return paneTransfer.getData(PaneTransfer.prototype)[0];
-}
+import { tryParseJSON } from '../json';
+class TransferObject {
+    constructor() {
+        //
+    }
+}
+export class PanelTransfer extends TransferObject {
+    constructor(viewId, groupId, panelId) {
+        super();
+        this.viewId = viewId;
+        this.groupId = groupId;
+        this.panelId = panelId;
+    }
+}
+export class PaneTransfer extends TransferObject {
+    constructor(viewId, paneId) {
+        super();
+        this.viewId = viewId;
+        this.paneId = paneId;
+    }
+}
+export const DATA_KEY = 'splitview/transfer';
+export const isPanelTransferEvent = (event) => {
+    if (!event.dataTransfer) {
+        return false;
+    }
+    return event.dataTransfer.types.includes(DATA_KEY);
+};
+export var DragType;
+(function (DragType) {
+    DragType["DOCKVIEW_TAB"] = "dockview_tab";
+    DragType["EXTERNAL"] = "external_group_drag";
+})(DragType || (DragType = {}));
+/**
+ * Determine whether this data belong to that of an event that was started by
+ * dragging a tab component
+ */
+export const isTabDragEvent = (data) => {
+    return data.type === DragType.DOCKVIEW_TAB;
+};
+/**
+ * Determine whether this data belong to that of an event that was started by
+ * a custom drag-enable component
+ */
+export const isCustomDragEvent = (data) => {
+    return data.type === DragType.EXTERNAL;
+};
+export const extractData = (event) => {
+    if (!event.dataTransfer) {
+        return null;
+    }
+    const data = tryParseJSON(event.dataTransfer.getData(DATA_KEY));
+    if (!data) {
+        console.warn(`[dragEvent] ${DATA_KEY} data is missing`);
+    }
+    if (typeof data.type !== 'string') {
+        console.warn(`[dragEvent] invalid type ${data.type}`);
+    }
+    return data;
+};
+/**
+ * A singleton to store transfer data during drag & drop operations that are only valid within the application.
+ */
+export class LocalSelectionTransfer {
+    constructor() {
+        // protect against external instantiation
+    }
+    static getInstance() {
+        return LocalSelectionTransfer.INSTANCE;
+    }
+    hasData(proto) {
+        return proto && proto === this.proto;
+    }
+    clearData(proto) {
+        if (this.hasData(proto)) {
+            this.proto = undefined;
+            this.data = undefined;
+        }
+    }
+    getData(proto) {
+        if (this.hasData(proto)) {
+            return this.data;
+        }
+        return undefined;
+    }
+    setData(data, proto) {
+        if (proto) {
+            this.data = data;
+            this.proto = proto;
+        }
+    }
+}
+LocalSelectionTransfer.INSTANCE = new LocalSelectionTransfer();
+export function getPanelData() {
+    const panelTransfer = LocalSelectionTransfer.getInstance();
+    const isPanelEvent = panelTransfer.hasData(PanelTransfer.prototype);
+    if (!isPanelEvent) {
+        return undefined;
+    }
+    return panelTransfer.getData(PanelTransfer.prototype)[0];
+}
+export function getPaneData() {
+    const paneTransfer = LocalSelectionTransfer.getInstance();
+    const isPanelEvent = paneTransfer.hasData(PaneTransfer.prototype);
+    if (!isPanelEvent) {
+        return undefined;
+    }
+    return paneTransfer.getData(PaneTransfer.prototype)[0];
+}

package/dist/esm/dnd/dnd.d.ts

@@ -1,40 +1,40 @@
-import { CompositeDisposable, IDisposable } from '../lifecycle';
-export interface IDragAndDropObserverCallbacks {
-    onDragEnter: (e: DragEvent) => void;
-    onDragLeave: (e: DragEvent) => void;
-    onDrop: (e: DragEvent) => void;
-    onDragEnd: (e: DragEvent) => void;
-    onDragOver?: (e: DragEvent) => void;
-}
-export declare class DragAndDropObserver extends CompositeDisposable {
-    private element;
-    private callbacks;
-    private counter;
-    constructor(element: HTMLElement, callbacks: IDragAndDropObserverCallbacks);
-    private registerListeners;
-}
-export interface IDraggedCompositeData {
-    eventData: DragEvent;
-    dragAndDropData: any;
-}
-export interface ICompositeDragAndDropObserverCallbacks {
-    onDragEnter?: (e: IDraggedCompositeData) => void;
-    onDragLeave?: (e: IDraggedCompositeData) => void;
-    onDrop?: (e: IDraggedCompositeData) => void;
-    onDragOver?: (e: IDraggedCompositeData) => void;
-    onDragStart?: (e: IDraggedCompositeData) => void;
-    onDragEnd?: (e: IDraggedCompositeData) => void;
-}
-export declare class DragAndDrop extends CompositeDisposable {
-    private _onDragStart;
-    private _onDragEnd;
-    private static _instance;
-    static get INSTANCE(): DragAndDrop;
-    private transferData;
-    private constructor();
-    registerTarget(element: HTMLElement, callbacks: ICompositeDragAndDropObserverCallbacks): IDisposable;
-    registerDraggable(element: HTMLElement, draggedItemProvider: () => {
-        type: string;
-        id: string;
-    }, callbacks: ICompositeDragAndDropObserverCallbacks): IDisposable;
-}
+import { CompositeDisposable, IDisposable } from '../lifecycle';
+export interface IDragAndDropObserverCallbacks {
+    onDragEnter: (e: DragEvent) => void;
+    onDragLeave: (e: DragEvent) => void;
+    onDrop: (e: DragEvent) => void;
+    onDragEnd: (e: DragEvent) => void;
+    onDragOver?: (e: DragEvent) => void;
+}
+export declare class DragAndDropObserver extends CompositeDisposable {
+    private element;
+    private callbacks;
+    private counter;
+    constructor(element: HTMLElement, callbacks: IDragAndDropObserverCallbacks);
+    private registerListeners;
+}
+export interface IDraggedCompositeData {
+    eventData: DragEvent;
+    dragAndDropData: any;
+}
+export interface ICompositeDragAndDropObserverCallbacks {
+    onDragEnter?: (e: IDraggedCompositeData) => void;
+    onDragLeave?: (e: IDraggedCompositeData) => void;
+    onDrop?: (e: IDraggedCompositeData) => void;
+    onDragOver?: (e: IDraggedCompositeData) => void;
+    onDragStart?: (e: IDraggedCompositeData) => void;
+    onDragEnd?: (e: IDraggedCompositeData) => void;
+}
+export declare class DragAndDrop extends CompositeDisposable {
+    private _onDragStart;
+    private _onDragEnd;
+    private static _instance;
+    static get INSTANCE(): DragAndDrop;
+    private transferData;
+    private constructor();
+    registerTarget(element: HTMLElement, callbacks: ICompositeDragAndDropObserverCallbacks): IDisposable;
+    registerDraggable(element: HTMLElement, draggedItemProvider: () => {
+        type: string;
+        id: string;
+    }, callbacks: ICompositeDragAndDropObserverCallbacks): IDisposable;
+}

package/dist/esm/dnd/dnd.js

@@ -1,109 +1,109 @@
-import { addDisposableListener, Emitter } from '../events';
-import { CompositeDisposable } from '../lifecycle';
-import { LocalSelectionTransfer } from './dataTransfer';
-export class DragAndDropObserver extends CompositeDisposable {
-    constructor(element, callbacks) {
-        super();
-        this.element = element;
-        this.callbacks = callbacks;
-        // A helper to fix issues with repeated DRAG_ENTER / DRAG_LEAVE
-        // calls see https://github.com/microsoft/vscode/issues/14470
-        // when the element has child elements where the events are fired
-        // repeadedly.
-        this.counter = 0;
-        this.registerListeners();
-    }
-    registerListeners() {
-        this.addDisposables(addDisposableListener(this.element, 'dragenter', (e) => {
-            this.counter++;
-            this.callbacks.onDragEnter(e);
-        }));
-        this.addDisposables(addDisposableListener(this.element, 'dragover', (e) => {
-            e.preventDefault(); // needed so that the drop event fires (https://stackoverflow.com/questions/21339924/drop-event-not-firing-in-chrome)
-            if (this.callbacks.onDragOver) {
-                this.callbacks.onDragOver(e);
-            }
-        }));
-        this.addDisposables(addDisposableListener(this.element, 'dragleave', (e) => {
-            this.counter--;
-            if (this.counter === 0) {
-                this.callbacks.onDragLeave(e);
-            }
-        }));
-        this.addDisposables(addDisposableListener(this.element, 'dragend', (e) => {
-            this.counter = 0;
-            this.callbacks.onDragEnd(e);
-        }));
-        this.addDisposables(addDisposableListener(this.element, 'drop', (e) => {
-            this.counter = 0;
-            this.callbacks.onDrop(e);
-        }));
-    }
-}
-class DockviewIdentifier {
-    constructor(data) {
-        this.data = data;
-        //
-    }
-}
-export class DragAndDrop extends CompositeDisposable {
-    constructor() {
-        super();
-        this._onDragStart = new Emitter();
-        this._onDragEnd = new Emitter();
-        this.transferData = LocalSelectionTransfer.getInstance();
-        this.addDisposables(this._onDragStart, this._onDragEnd);
-    }
-    static get INSTANCE() {
-        if (!DragAndDrop._instance) {
-            DragAndDrop._instance = new DragAndDrop();
-        }
-        return DragAndDrop._instance;
-    }
-    registerTarget(element, callbacks) {
-        const disposables = new CompositeDisposable();
-        disposables.addDisposables(new DragAndDropObserver(element, {
-            onDragEnd: (e) => {
-                // no-op
-            },
-            onDragEnter: (e) => {
-                e.preventDefault();
-            },
-            onDragLeave: (e) => {
-                //
-            },
-            onDrop: (e) => {
-                //
-            },
-            onDragOver: (e) => {
-                //
-            },
-        }));
-        return disposables;
-    }
-    registerDraggable(element, draggedItemProvider, callbacks) {
-        element.draggable = true;
-        const disposables = new CompositeDisposable();
-        disposables.addDisposables(addDisposableListener(element, 'dragstart', (e) => {
-            this._onDragStart.fire({ event: e });
-        }));
-        disposables.addDisposables(new DragAndDropObserver(element, {
-            onDragEnd: (e) => {
-                // no-op
-            },
-            onDragEnter: (e) => {
-                //
-            },
-            onDragLeave: (e) => {
-                //
-            },
-            onDrop: (e) => {
-                //
-            },
-            onDragOver: (e) => {
-                //
-            },
-        }));
-        return disposables;
-    }
-}
+import { addDisposableListener, Emitter } from '../events';
+import { CompositeDisposable } from '../lifecycle';
+import { LocalSelectionTransfer } from './dataTransfer';
+export class DragAndDropObserver extends CompositeDisposable {
+    constructor(element, callbacks) {
+        super();
+        this.element = element;
+        this.callbacks = callbacks;
+        // A helper to fix issues with repeated DRAG_ENTER / DRAG_LEAVE
+        // calls see https://github.com/microsoft/vscode/issues/14470
+        // when the element has child elements where the events are fired
+        // repeadedly.
+        this.counter = 0;
+        this.registerListeners();
+    }
+    registerListeners() {
+        this.addDisposables(addDisposableListener(this.element, 'dragenter', (e) => {
+            this.counter++;
+            this.callbacks.onDragEnter(e);
+        }));
+        this.addDisposables(addDisposableListener(this.element, 'dragover', (e) => {
+            e.preventDefault(); // needed so that the drop event fires (https://stackoverflow.com/questions/21339924/drop-event-not-firing-in-chrome)
+            if (this.callbacks.onDragOver) {
+                this.callbacks.onDragOver(e);
+            }
+        }));
+        this.addDisposables(addDisposableListener(this.element, 'dragleave', (e) => {
+            this.counter--;
+            if (this.counter === 0) {
+                this.callbacks.onDragLeave(e);
+            }
+        }));
+        this.addDisposables(addDisposableListener(this.element, 'dragend', (e) => {
+            this.counter = 0;
+            this.callbacks.onDragEnd(e);
+        }));
+        this.addDisposables(addDisposableListener(this.element, 'drop', (e) => {
+            this.counter = 0;
+            this.callbacks.onDrop(e);
+        }));
+    }
+}
+class DockviewIdentifier {
+    constructor(data) {
+        this.data = data;
+        //
+    }
+}
+export class DragAndDrop extends CompositeDisposable {
+    constructor() {
+        super();
+        this._onDragStart = new Emitter();
+        this._onDragEnd = new Emitter();
+        this.transferData = LocalSelectionTransfer.getInstance();
+        this.addDisposables(this._onDragStart, this._onDragEnd);
+    }
+    static get INSTANCE() {
+        if (!DragAndDrop._instance) {
+            DragAndDrop._instance = new DragAndDrop();
+        }
+        return DragAndDrop._instance;
+    }
+    registerTarget(element, callbacks) {
+        const disposables = new CompositeDisposable();
+        disposables.addDisposables(new DragAndDropObserver(element, {
+            onDragEnd: (e) => {
+                // no-op
+            },
+            onDragEnter: (e) => {
+                e.preventDefault();
+            },
+            onDragLeave: (e) => {
+                //
+            },
+            onDrop: (e) => {
+                //
+            },
+            onDragOver: (e) => {
+                //
+            },
+        }));
+        return disposables;
+    }
+    registerDraggable(element, draggedItemProvider, callbacks) {
+        element.draggable = true;
+        const disposables = new CompositeDisposable();
+        disposables.addDisposables(addDisposableListener(element, 'dragstart', (e) => {
+            this._onDragStart.fire({ event: e });
+        }));
+        disposables.addDisposables(new DragAndDropObserver(element, {
+            onDragEnd: (e) => {
+                // no-op
+            },
+            onDragEnter: (e) => {
+                //
+            },
+            onDragLeave: (e) => {
+                //
+            },
+            onDrop: (e) => {
+                //
+            },
+            onDragOver: (e) => {
+                //
+            },
+        }));
+        return disposables;
+    }
+}

package/dist/esm/dnd/droptarget.d.ts

@@ -1,37 +1,37 @@
-import { Event } from '../events';
-import { CompositeDisposable } from '../lifecycle';
-export interface DroptargetEvent {
-    position: Position;
-    event: DragEvent;
-}
-export declare enum Position {
-    Top = "Top",
-    Left = "Left",
-    Bottom = "Bottom",
-    Right = "Right",
-    Center = "Center"
-}
-export interface DroptargetEvent {
-    position: Position;
-    event: DragEvent;
-}
-export declare type DropTargetDirections = 'vertical' | 'horizontal' | 'all' | 'none';
-export declare type CanDisplayOverlay = boolean | ((dragEvent: DragEvent) => boolean);
-export declare class Droptarget extends CompositeDisposable {
-    private readonly element;
-    private readonly options;
-    private target;
-    private overlay;
-    private _state;
-    private readonly _onDrop;
-    readonly onDrop: Event<DroptargetEvent>;
-    get state(): Position | undefined;
-    set validOverlays(value: DropTargetDirections);
-    set canDisplayOverlay(value: CanDisplayOverlay);
-    constructor(element: HTMLElement, options: {
-        canDisplayOverlay: CanDisplayOverlay;
-        validOverlays: DropTargetDirections;
-    });
-    dispose(): void;
-    private removeDropTarget;
-}
+import { Event } from '../events';
+import { CompositeDisposable } from '../lifecycle';
+export interface DroptargetEvent {
+    position: Position;
+    event: DragEvent;
+}
+export declare enum Position {
+    Top = "Top",
+    Left = "Left",
+    Bottom = "Bottom",
+    Right = "Right",
+    Center = "Center"
+}
+export interface DroptargetEvent {
+    position: Position;
+    event: DragEvent;
+}
+export declare type DropTargetDirections = 'vertical' | 'horizontal' | 'all' | 'none';
+export declare type CanDisplayOverlay = boolean | ((dragEvent: DragEvent) => boolean);
+export declare class Droptarget extends CompositeDisposable {
+    private readonly element;
+    private readonly options;
+    private target;
+    private overlay;
+    private _state;
+    private readonly _onDrop;
+    readonly onDrop: Event<DroptargetEvent>;
+    get state(): Position | undefined;
+    set validOverlays(value: DropTargetDirections);
+    set canDisplayOverlay(value: CanDisplayOverlay);
+    constructor(element: HTMLElement, options: {
+        canDisplayOverlay: CanDisplayOverlay;
+        validOverlays: DropTargetDirections;
+    });
+    dispose(): void;
+    private removeDropTarget;
+}