dockview-core 7.0.3 → 8.0.0

package/dist/esm/dockview/liveRegionService.js

@@ -1,159 +0,0 @@
-import { CompositeDisposable } from '../lifecycle';
-import { resolveMessages } from './accessibilityMessages';
-import { defineModule } from './modules';
-/** Bulk transactions whose per-panel events should not each be announced. */
-const isBulk = (kind) => kind === 'load' || kind === 'clear';
-function createLiveRegion(politeness) {
-    const el = document.createElement('div');
-    el.className =
-        politeness === 'assertive'
-            ? 'dv-live-region-assertive'
-            : 'dv-live-region';
-    // assertive interrupts the SR (errors / cancellations); polite waits for a
-    // pause (routine status). `alert` implies assertive, `status` implies polite.
-    el.setAttribute('role', politeness === 'assertive' ? 'alert' : 'status');
-    el.setAttribute('aria-live', politeness);
-    el.setAttribute('aria-atomic', 'true');
-    // Visually hidden but kept in the accessibility tree (never display:none /
-    // visibility:hidden, which would drop it from AT). Standard clip pattern.
-    Object.assign(el.style, {
-        position: 'absolute',
-        width: '1px',
-        height: '1px',
-        margin: '-1px',
-        padding: '0',
-        overflow: 'hidden',
-        clip: 'rect(0 0 0 0)',
-        clipPath: 'inset(50%)',
-        whiteSpace: 'nowrap',
-        border: '0',
-    });
-    return el;
-}
-/**
- * Narrates layout state changes to screen readers via visually-hidden
- * `aria-live` regions. Free / core (WCAG 4.1.3). Announces panel open/close +
- * the shared `announce()` sink (the accessibility module narrates docking here too).
- * Two regions: a **polite** one for routine status and an **assertive** one
- * for errors/cancellations. The bulk load/clear burst is suppressed via the
- * mutation-transaction events, and an app can take over delivery entirely with
- * the `announcer` option.
- */
-export class LiveRegionService extends CompositeDisposable {
-    constructor(host) {
-        super();
-        this._suppressDepth = 0;
-        this._locationSubs = new Map();
-        this._host = host;
-        this._polite = createLiveRegion('polite');
-        this._assertive = createLiveRegion('assertive');
-        host.element.appendChild(this._polite);
-        host.element.appendChild(this._assertive);
-        this.addDisposables({ dispose: () => this._polite.remove() }, { dispose: () => this._assertive.remove() }, host.onDidAddPanel((panel) => this._announce(panel, 'open')), host.onDidRemovePanel((panel) => this._announce(panel, 'close')), 
-        // Bracket bulk transactions so a fromJSON / clear doesn't announce
-        // every nested add/remove.
-        host.onWillMutateLayout((e) => {
-            if (isBulk(e.kind)) {
-                this._suppressDepth++;
-            }
-        }), host.onDidMutateLayout((e) => {
-            if (isBulk(e.kind)) {
-                this._suppressDepth = Math.max(0, this._suppressDepth - 1);
-            }
-        }), host.onDidMaximizedGroupChange((e) => {
-            const panel = e.group.activePanel;
-            if (panel) {
-                this._announce(panel, e.isMaximized ? 'maximize' : 'restore');
-            }
-        }), 
-        // Narrate a group floating / docking back / popping out. A group is
-        // born in the grid then transitions, so track each group's previous
-        // location and ignore the no-op initial `-> grid`.
-        host.onDidAddGroup((group) => this._trackLocation(group)), host.onDidRemoveGroup((group) => {
-            var _a;
-            (_a = this._locationSubs.get(group.id)) === null || _a === void 0 ? void 0 : _a.dispose();
-            this._locationSubs.delete(group.id);
-        }), {
-            dispose: () => {
-                this._locationSubs.forEach((sub) => sub.dispose());
-                this._locationSubs.clear();
-            },
-        });
-    }
-    _trackLocation(group) {
-        let prev = group.api.location.type;
-        const sub = group.api.onDidLocationChange((e) => {
-            const next = e.location.type;
-            if (next === prev) {
-                return;
-            }
-            prev = next;
-            const panel = group.activePanel;
-            if (!panel) {
-                return;
-            }
-            const kind = next === 'floating'
-                ? 'float'
-                : next === 'popout'
-                    ? 'popout'
-                    : 'dock';
-            this._announce(panel, kind);
-        });
-        this._locationSubs.set(group.id, sub);
-    }
-    announce(message, politeness = 'polite') {
-        // Opt-out (read live so `updateOptions({ announcements })` applies).
-        if (this._host.options.announcements === false ||
-            this._suppressDepth > 0 ||
-            !message) {
-            return;
-        }
-        // Apps can route announcements into their own SR system instead of the
-        // built-in regions (e.g. a shared app-wide live region).
-        const announcer = this._host.options.announcer;
-        if (announcer) {
-            announcer({ message, politeness });
-            return;
-        }
-        // Clearing first forces SRs to re-announce an identical message.
-        const region = politeness === 'assertive' ? this._assertive : this._polite;
-        region.textContent = '';
-        region.textContent = message;
-    }
-    _announce(panel, kind) {
-        var _a, _b;
-        // The app may localise/override the message, suppress it (null / ''),
-        // or fall through to the default (undefined).
-        const custom = (_b = (_a = this._host.options).getAnnouncement) === null || _b === void 0 ? void 0 : _b.call(_a, { kind, panel });
-        if (custom === null || custom === '') {
-            return;
-        }
-        this.announce(custom !== null && custom !== void 0 ? custom : this._defaultMessage(panel, kind));
-    }
-    _defaultMessage(panel, kind) {
-        var _a;
-        const m = resolveMessages(this._host.options.messages);
-        const name = (_a = panel.title) !== null && _a !== void 0 ? _a : panel.id;
-        switch (kind) {
-            case 'open':
-                return m.panelOpened(name);
-            case 'close':
-                return m.panelClosed(name);
-            case 'maximize':
-                return m.groupMaximized(name);
-            case 'restore':
-                return m.groupRestored(name);
-            case 'float':
-                return m.groupFloated(name);
-            case 'dock':
-                return m.groupDocked(name);
-            case 'popout':
-                return m.groupPoppedOut(name);
-        }
-    }
-}
-export const LiveRegionModule = defineModule({
-    name: 'LiveRegion',
-    serviceKey: 'liveRegionService',
-    create: (host) => new LiveRegionService(host),
-});

package/dist/esm/dockview/moduleContracts.d.ts

@@ -1,119 +0,0 @@
-/**
- * Service + host interfaces for the pluggable feature modules. Core references
- * only these interfaces — never a module's implementation — so each module is
- * decoupled from core and independently testable / removable. Keep this file
- * implementation-free.
- */
-import { IDisposable } from '../lifecycle';
-import { Event } from '../events';
-import { DroptargetOverlayModel, Position } from '../dnd/droptarget';
-import { IDragGhostSpec } from '../dnd/backend';
-import { DockviewApi } from '../api/component.api';
-import { DockviewGroupPanel } from './dockviewGroupPanel';
-import { IDockviewPanel } from './dockviewPanel';
-import { ITabGroup } from './tabGroup';
-import { TabGroupColorPalette } from './tabGroupAccent';
-import { PopupService } from './components/popupService';
-import { DockviewComponentOptions } from './options';
-import { DockviewLayoutMutationEvent, GroupNavigationDirection } from './dockviewComponent';
-import { DockviewWillDropEvent } from './dockviewGroupPanelModel';
-import { GroupDragEvent, TabDragEvent } from './components/titlebar/tabsContainer';
-import { DockviewGroupDropLocation, DockviewTabGroupChangeEvent, DockviewTabGroupPanelChangeEvent, DockviewTabGroupCollapsedChangeEvent, DockviewWillShowOverlayLocationEvent } from './events';
-export interface IContextMenuHost {
-    readonly options: DockviewComponentOptions;
-    readonly api: DockviewApi;
-    readonly tabGroupColorPalette: TabGroupColorPalette;
-    getPopupServiceForGroup(group: DockviewGroupPanel): PopupService;
-}
-export interface IContextMenuService {
-    show(panel: IDockviewPanel, group: DockviewGroupPanel, event: MouseEvent): void;
-    showForChip(tabGroup: ITabGroup, group: DockviewGroupPanel, event: MouseEvent): void;
-}
-export interface ITabGroupChipsHost {
-    readonly onDidAddGroup: Event<DockviewGroupPanel>;
-    readonly onDidRemoveGroup: Event<DockviewGroupPanel>;
-    fireDidCreateTabGroup(event: DockviewTabGroupChangeEvent): void;
-    fireDidDestroyTabGroup(event: DockviewTabGroupChangeEvent): void;
-    fireDidAddPanelToTabGroup(event: DockviewTabGroupPanelChangeEvent): void;
-    fireDidRemovePanelFromTabGroup(event: DockviewTabGroupPanelChangeEvent): void;
-    fireDidTabGroupChange(event: DockviewTabGroupChangeEvent): void;
-    fireDidTabGroupCollapsedChange(event: DockviewTabGroupCollapsedChangeEvent): void;
-}
-export interface ITabGroupChipsService extends IDisposable {
-    /**
-     * Subscribe to the per-group tab-group events on the given group and
-     * re-fire them on the host's component-level emitters. Returns a
-     * disposable that detaches the subscriptions; intended to be bundled
-     * into the per-group CompositeDisposable so cleanup happens when the
-     * group is removed.
-     */
-    attachToGroup(group: DockviewGroupPanel): IDisposable;
-}
-export interface IAccessibilityHost {
-    /**
-     * The outermost dockview element (the shell, which also contains edge
-     * groups). A getter — it must resolve to the shell once that exists, not
-     * the inner gridview, or keydowns from edge groups are missed.
-     */
-    readonly rootElement: HTMLElement;
-    readonly options: DockviewComponentOptions;
-    readonly groups: DockviewGroupPanel[];
-    readonly activeGroup: DockviewGroupPanel | undefined;
-    readonly activePanel: IDockviewPanel | undefined;
-    /**
-     * The next / previous group in gridview (spatial) order, wrapping round —
-     * the one piece of navigation that needs the grid internals. All other
-     * focus logic lives in the service, using the public group API.
-     */
-    adjacentGroup(group: DockviewGroupPanel, reverse: boolean): DockviewGroupPanel | undefined;
-    /** The nearest grid group in a spatial direction — drives Alt+Arrow nav. */
-    adjacentGroupInDirection(group: DockviewGroupPanel, direction: GroupNavigationDirection): DockviewGroupPanel | undefined;
-    /** Fires before / after a structural layout change — used to restore focus on close. */
-    readonly onWillMutateLayout: Event<DockviewLayoutMutationEvent>;
-    readonly onDidMutateLayout: Event<DockviewLayoutMutationEvent>;
-    showDropPreview(group: DockviewGroupPanel, position: Position): IDisposable;
-    announce(message: string): void;
-    dockPanel(panel: IDockviewPanel, group: DockviewGroupPanel, position: Position): void;
-}
-export interface IAccessibilityService extends IDisposable {
-}
-/**
- * Marker for the advanced keyboard docking service (spatial group focus +
- * keyboard move mode). Self-driven; the component never calls into it.
- */
-export interface IKeyboardDockingService extends IDisposable {
-}
-export interface IAdvancedDnDHost {
-    readonly options: DockviewComponentOptions;
-    readonly api: DockviewApi;
-    fireWillDragPanel(event: TabDragEvent): void;
-    fireWillDragGroup(event: GroupDragEvent): void;
-    fireWillDrop(event: DockviewWillDropEvent): void;
-    fireWillShowOverlay(event: DockviewWillShowOverlayLocationEvent): void;
-}
-export interface IAdvancedDnDService extends IDisposable {
-    dispatchWillDragPanel(event: TabDragEvent): void;
-    dispatchWillDragGroup(event: GroupDragEvent): void;
-    dispatchWillDrop(event: DockviewWillDropEvent): void;
-    dispatchWillShowOverlay(event: DockviewWillShowOverlayLocationEvent): void;
-    /**
-     * Resolve the custom group drag ghost from
-     * `createGroupDragGhostComponent`, or `undefined` when no factory is
-     * configured (the caller then renders the default chip). Returning
-     * `undefined` is also what happens when this module is absent.
-     */
-    buildGroupDragGhost(group: DockviewGroupPanel): IDragGhostSpec | undefined;
-    /**
-     * Resolve the app-supplied overlay model for a group drop target via the
-     * `dropOverlayModel` option, or `undefined` to keep the target's default.
-     */
-    resolveOverlayModel(location: DockviewGroupDropLocation, group?: DockviewGroupPanel): DroptargetOverlayModel | undefined;
-    /**
-     * Render the drop-preview overlay on a group at `position` — the same
-     * overlay a mouse drag shows — without a live drag. Returns a disposable
-     * that clears it. Used by keyboard docking so keyboard and mouse previews
-     * are identical (single source of truth). Commit the move via the public
-     * `api.moveGroupOrPanel({ to: { group, position } })`.
-     */
-    showPreviewOverlay(group: DockviewGroupPanel, position: Position): IDisposable;
-}

package/dist/esm/dockview/moduleContracts.js

@@ -1 +0,0 @@
-export {};

package/dist/esm/dockview/modules.d.ts

@@ -1,110 +0,0 @@
-/**
- * Internal module system for dockview.
- *
- * Modules are feature bundles that register services into the dockview
- * component. `registerModules(...)` is the one public entry point — it lets a
- * sibling package contribute modules that `DockviewComponent` picks up at
- * construction. The richer opt-in surface (a per-component `modules` option,
- * framework wrappers) is still reserved for a future version; the module
- * authoring API (`defineModule`, the service contracts) remains internal.
- */
-import { IDisposable } from '../lifecycle';
-import { IFloatingGroupService } from './floatingGroupService';
-import { IPopoutWindowService } from './popoutWindowService';
-import { IWatermarkService } from './watermarkService';
-import { IEdgeGroupService } from './edgeGroupService';
-import { IRootDropTargetService } from './rootDropTargetService';
-import { IHeaderActionsService } from './headerActionsService';
-import { ILiveRegionService } from './liveRegionService';
-import { IAccessibilityService, IAdvancedDnDService, IContextMenuService, IKeyboardDockingService, ITabGroupChipsService } from './moduleContracts';
-export interface ServiceCollection {
-    floatingGroupService?: IFloatingGroupService;
-    popoutWindowService?: IPopoutWindowService;
-    watermarkService?: IWatermarkService;
-    edgeGroupService?: IEdgeGroupService;
-    tabGroupChipsService?: ITabGroupChipsService;
-    contextMenuService?: IContextMenuService;
-    rootDropTargetService?: IRootDropTargetService;
-    headerActionsService?: IHeaderActionsService;
-    advancedDnDService?: IAdvancedDnDService;
-    liveRegionService?: ILiveRegionService;
-    accessibilityService?: IAccessibilityService;
-    keyboardDockingService?: IKeyboardDockingService;
-}
-export interface DockviewModule<THost = unknown> {
-    moduleName: string;
-    services?: Record<string, (host: THost) => unknown>;
-    /**
-     * Optional post-construct hook called once after the host is fully
-     * constructed and all module services are instantiated. Use this to
-     * subscribe to host events — the returned disposable runs at host
-     * teardown. Components don't need to call into the service from event
-     * handlers; the module owns its own reactivity.
-     */
-    init?: (host: THost, services: ServiceCollection) => IDisposable;
-    dependsOn?: DockviewModule<any>[];
-}
-/**
- * Typed helper for defining a module. Enforces that the factory's return
- * type matches the slot in ServiceCollection at compile time, replacing
- * the manual cast each module file would otherwise need.
- */
-export declare function defineModule<K extends keyof ServiceCollection, THost>(config: {
-    name: string;
-    serviceKey: K;
-    create: (host: THost) => NonNullable<ServiceCollection[K]>;
-    init?: (host: THost, service: NonNullable<ServiceCollection[K]>) => IDisposable;
-    dependsOn?: DockviewModule<any>[];
-}): DockviewModule<THost>;
-/**
- * For tests — clears the once-per-key dedup cache used by `assertModule`.
- */
-export declare function _resetMissingModuleWarnings(): void;
-/**
- * Returns the service if its module is registered, otherwise logs a
- * deduplicated console error and returns `undefined`. Modelled on AG Grid's
- * `assertModuleRegistered`: missing modules never throw — they degrade the
- * affected feature to a no-op so consuming applications don't crash in
- * production.
- *
- * Use at public-API entry points where the caller wants to surface which
- * module is missing. For internal/lifecycle paths, plain `?.` chaining on
- * the service slot is preferred — no log, just a silent no-op.
- */
-export declare function assertModule<T>(service: T | undefined, moduleName: string, context?: string): T | undefined;
-export declare class ModuleRegistry<THost> implements IDisposable {
-    private readonly _modules;
-    private readonly _services;
-    private readonly _initDisposables;
-    get services(): ServiceCollection;
-    register<H>(module: DockviewModule<H>): void;
-    initialize(host: THost): void;
-    postConstruct(host: THost): void;
-    has(moduleName: string): boolean;
-    dispose(): void;
-}
-/**
- * Register modules globally. Idempotent per `moduleName` — registering the
- * same module twice is a no-op. Intended to be called once at import time by
- * the package that bundles a given set of modules.
- */
-export declare function registerModules(modules: DockviewModule<any>[]): void;
-/**
- * Returns the globally-registered modules (a copy). `DockviewComponent` reads
- * this to extend its built-in module set.
- */
-export declare function getRegisteredModules(): DockviewModule<any>[];
-/**
- * For tests — clears the global module registry.
- */
-export declare function clearRegisteredModules(): void;
-/**
- * Called once by the `dockview` package on import, solely so `dockview-core`
- * can warn when it is used directly (see above). Not used for anything else.
- */
-export declare function markDockviewPackageLoaded(): void;
-/**
- * Whether the `dockview` package has been loaded in this process. Used only to
- * gate the "don't use dockview-core directly" developer warning.
- */
-export declare function isDockviewPackageLoaded(): boolean;

package/dist/esm/dockview/modules.js

@@ -1,170 +0,0 @@
-/**
- * Internal module system for dockview.
- *
- * Modules are feature bundles that register services into the dockview
- * component. `registerModules(...)` is the one public entry point — it lets a
- * sibling package contribute modules that `DockviewComponent` picks up at
- * construction. The richer opt-in surface (a per-component `modules` option,
- * framework wrappers) is still reserved for a future version; the module
- * authoring API (`defineModule`, the service contracts) remains internal.
- */
-/**
- * Typed helper for defining a module. Enforces that the factory's return
- * type matches the slot in ServiceCollection at compile time, replacing
- * the manual cast each module file would otherwise need.
- */
-export function defineModule(config) {
-    return {
-        moduleName: config.name,
-        services: {
-            [config.serviceKey]: config.create,
-        },
-        init: config.init
-            ? (host, services) => config.init(host, services[config.serviceKey])
-            : undefined,
-        dependsOn: config.dependsOn,
-    };
-}
-const _warnedMissingModule = new Set();
-/**
- * For tests — clears the once-per-key dedup cache used by `assertModule`.
- */
-export function _resetMissingModuleWarnings() {
-    _warnedMissingModule.clear();
-}
-/**
- * Returns the service if its module is registered, otherwise logs a
- * deduplicated console error and returns `undefined`. Modelled on AG Grid's
- * `assertModuleRegistered`: missing modules never throw — they degrade the
- * affected feature to a no-op so consuming applications don't crash in
- * production.
- *
- * Use at public-API entry points where the caller wants to surface which
- * module is missing. For internal/lifecycle paths, plain `?.` chaining on
- * the service slot is preferred — no log, just a silent no-op.
- */
-export function assertModule(service, moduleName, context) {
-    if (service !== undefined) {
-        return service;
-    }
-    const key = `${moduleName}|${context !== null && context !== void 0 ? context : ''}`;
-    if (_warnedMissingModule.has(key)) {
-        return undefined;
-    }
-    _warnedMissingModule.add(key);
-    const where = context ? ` for ${context}` : '';
-    // eslint-disable-next-line no-console
-    console.error(`dockview: module "${moduleName}" is not registered${where}.`);
-    return undefined;
-}
-export class ModuleRegistry {
-    constructor() {
-        this._modules = new Map();
-        this._services = {};
-        this._initDisposables = [];
-    }
-    get services() {
-        return this._services;
-    }
-    register(module) {
-        if (this._modules.has(module.moduleName)) {
-            return;
-        }
-        if (module.dependsOn) {
-            for (const dep of module.dependsOn) {
-                this.register(dep);
-            }
-        }
-        this._modules.set(module.moduleName, module);
-    }
-    initialize(host) {
-        for (const module of this._modules.values()) {
-            if (!module.services) {
-                continue;
-            }
-            for (const [name, factory] of Object.entries(module.services)) {
-                this._services[name] = factory(host);
-            }
-        }
-    }
-    postConstruct(host) {
-        for (const module of this._modules.values()) {
-            if (module.init) {
-                this._initDisposables.push(module.init(host, this._services));
-            }
-        }
-    }
-    has(moduleName) {
-        return this._modules.has(moduleName);
-    }
-    dispose() {
-        // Tear down init() subscriptions first so they stop firing into
-        // services that are about to be disposed.
-        for (const disposable of this._initDisposables) {
-            disposable.dispose();
-        }
-        this._initDisposables.length = 0;
-        for (const service of Object.values(this._services)) {
-            if (service !== undefined &&
-                typeof service.dispose === 'function') {
-                service.dispose();
-            }
-        }
-    }
-}
-/**
- * Process-global list of modules registered via {@link registerModules}.
- * `DockviewComponent` appends these to its built-in set at construction, so
- * importing a package that calls `registerModules(...)` (e.g. `dockview`)
- * makes those modules available to every component in the process —
- * modelled on AG Grid's `ModuleRegistry.registerModules`.
- */
-const _globalModules = [];
-/**
- * Register modules globally. Idempotent per `moduleName` — registering the
- * same module twice is a no-op. Intended to be called once at import time by
- * the package that bundles a given set of modules.
- */
-export function registerModules(modules) {
-    for (const module of modules) {
-        if (_globalModules.some((m) => m.moduleName === module.moduleName)) {
-            continue;
-        }
-        _globalModules.push(module);
-    }
-}
-/**
- * Returns the globally-registered modules (a copy). `DockviewComponent` reads
- * this to extend its built-in module set.
- */
-export function getRegisteredModules() {
-    return [..._globalModules];
-}
-/**
- * For tests — clears the global module registry.
- */
-export function clearRegisteredModules() {
-    _globalModules.length = 0;
-}
-/**
- * This marker exists for ONE purpose: a developer warning about the v7 package
- * renames. It has no functional effect on dockview's behaviour. Following the
- * renames, `dockview-core` is internal and `dockview` is the public JavaScript
- * package; `dockview` calls {@link markDockviewPackageLoaded} on import so that
- * `dockview-core` can detect — and warn about — being used directly.
- */
-let _dockviewPackageLoaded = false;
-/**
- * Called once by the `dockview` package on import, solely so `dockview-core`
- * can warn when it is used directly (see above). Not used for anything else.
- */
-export function markDockviewPackageLoaded() {
-    _dockviewPackageLoaded = true;
-}
-/**
- * Whether the `dockview` package has been loaded in this process. Used only to
- * gate the "don't use dockview-core directly" developer warning.
- */
-export function isDockviewPackageLoaded() {
-    return _dockviewPackageLoaded;
-}