dockview-core/dist/cjs/dockview/headerActionsService.js

Zero dependency layout manager supporting tabs, groups, grids and splitviews for vanilla TypeScript

"use strict";
var __values = (this && this.__values) || function(o) {
    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
    if (m) return m.call(o);
    if (o && typeof o.length === "number") return {
        next: function () {
            if (o && i >= o.length) o = void 0;
            return { value: o && o[i++], done: !o };
        }
    };
    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
};
var __read = (this && this.__read) || function (o, n) {
    var m = typeof Symbol === "function" && o[Symbol.iterator];
    if (!m) return o;
    var i = m.call(o), r, ar = [], e;
    try {
        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
    }
    catch (error) { e = { error: error }; }
    finally {
        try {
            if (r && !r.done && (m = i["return"])) m.call(i);
        }
        finally { if (e) throw e.error; }
    }
    return ar;
};
var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
        if (ar || !(i in from)) {
            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
            ar[i] = from[i];
        }
    }
    return to.concat(ar || Array.prototype.slice.call(from));
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.HeaderActionsModule = exports.HeaderActionsService = void 0;
var lifecycle_1 = require("../lifecycle");
var modules_1 = require("./modules");
var SLOT_OPTION_KEY = {
    left: 'createLeftHeaderActionComponent',
    right: 'createRightHeaderActionComponent',
    prefix: 'createPrefixHeaderActionComponent',
};
var HeaderActionsService = /** @class */ (function () {
    function HeaderActionsService(host) {
        this._perGroup = new Map();
        this._host = host;
    }
    HeaderActionsService.prototype.refresh = function (group) {
        // The headerPosition setter on DockviewGroupPanelModel fires inside
        // the model's constructor — before the parent DockviewGroupPanel has
        // assigned its `_model` field, and in tests where the parent panel
        // may be null. Skip; DockviewGroupPanel.initialize() will refresh
        // once construction completes for real groups.
        if (!(group === null || group === void 0 ? void 0 : group.model)) {
            return;
        }
        var state = this._ensureState(group);
        this._refreshSlot('left', group, state.left);
        this._refreshSlot('right', group, state.right);
        this._refreshSlot('prefix', group, state.prefix);
    };
    HeaderActionsService.prototype.refreshAll = function () {
        var e_1, _a;
        try {
            for (var _b = __values(this._host.groups), _c = _b.next(); !_c.done; _c = _b.next()) {
                var group = _c.value;
                this.refresh(group);
            }
        }
        catch (e_1_1) { e_1 = { error: e_1_1 }; }
        finally {
            try {
                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
            }
            finally { if (e_1) throw e_1.error; }
        }
    };
    HeaderActionsService.prototype.disposeGroup = function (group) {
        var state = this._perGroup.get(group);
        if (!state) {
            return;
        }
        state.left.dispose();
        state.right.dispose();
        state.prefix.dispose();
        this._perGroup.delete(group);
    };
    HeaderActionsService.prototype.dispose = function () {
        var e_2, _a;
        try {
            for (var _b = __values(__spreadArray([], __read(this._perGroup.keys()), false)), _c = _b.next(); !_c.done; _c = _b.next()) {
                var group = _c.value;
                this.disposeGroup(group);
            }
        }
        catch (e_2_1) { e_2 = { error: e_2_1 }; }
        finally {
            try {
                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
            }
            finally { if (e_2) throw e_2.error; }
        }
    };
    HeaderActionsService.prototype._ensureState = function (group) {
        var state = this._perGroup.get(group);
        if (!state) {
            state = {
                left: new lifecycle_1.MutableDisposable(),
                right: new lifecycle_1.MutableDisposable(),
                prefix: new lifecycle_1.MutableDisposable(),
            };
            this._perGroup.set(group, state);
        }
        return state;
    };
    HeaderActionsService.prototype._refreshSlot = function (slot, group, disposable) {
        var factory = this._host.options[SLOT_OPTION_KEY[slot]];
        if (factory) {
            var renderer = factory(group);
            disposable.value = renderer;
            renderer.init({
                containerApi: this._host.api,
                api: group.api,
                group: group,
            });
            group.model.attachHeaderAction(slot, renderer.element);
        }
        else {
            disposable.dispose();
            group.model.attachHeaderAction(slot, undefined);
        }
    };
    return HeaderActionsService;
}());
exports.HeaderActionsService = HeaderActionsService;
exports.HeaderActionsModule = (0, modules_1.defineModule)({
    name: 'HeaderActions',
    serviceKey: 'headerActionsService',
    create: function (host) { return new HeaderActionsService(host); },
    init: function (host, service) {
        return new lifecycle_1.CompositeDisposable(host.onDidRemoveGroup(function (group) {
            service.disposeGroup(group);
        }));
    },
});