@codingame/monaco-vscode-view-common-service-override 4.5.0-improve-code-splitting.1

package/vscode/src/vs/workbench/services/views/common/viewContainerModel.js

@@ -0,0 +1,603 @@
+import { __decorate, __param } from 'vscode/external/tslib/tslib.es6.js';
+import { VIEWS_LOG_ID, VIEWS_LOG_NAME, Extensions, defaultViewIcon } from 'vscode/vscode/vs/workbench/common/views';
+import { IContextKeyService } from 'vscode/vscode/vs/platform/contextkey/common/contextkey.service';
+import { IStorageService } from 'vscode/vscode/vs/platform/storage/common/storage.service';
+import { Registry } from 'vscode/vscode/vs/platform/registry/common/platform';
+import { Disposable, DisposableStore } from 'vscode/vscode/vs/base/common/lifecycle';
+import { Emitter, Event } from 'vscode/vscode/vs/base/common/event';
+import { IInstantiationService } from 'vscode/vscode/vs/platform/instantiation/common/instantiation';
+import { URI } from 'vscode/vscode/vs/base/common/uri';
+import { coalesce, move } from 'vscode/vscode/vs/base/common/arrays';
+import { isUndefined, isUndefinedOrNull } from 'vscode/vscode/vs/base/common/types';
+import { isEqual } from 'vscode/vscode/vs/base/common/resources';
+import { ThemeIcon } from 'vscode/vscode/vs/base/common/themables';
+import { ILoggerService } from 'vscode/vscode/vs/platform/log/common/log.service';
+import { registerAction2, Action2 } from 'vscode/vscode/vs/platform/actions/common/actions';
+import { Categories } from 'vscode/vscode/vs/platform/action/common/actionCommonCategories';
+import { IOutputService } from 'vscode/vscode/vs/workbench/services/output/common/output.service';
+import { CounterSet } from 'vscode/vscode/vs/base/common/map';
+import { localize2WithPath } from 'vscode/vscode/vs/nls';
+
+registerAction2(class extends Action2 {
+    constructor() {
+        super({
+            id: '_workbench.output.showViewsLog',
+            title: ( localize2WithPath(
+                'vs/workbench/services/views/common/viewContainerModel',
+                'showViewsLog',
+                "Show Views Log"
+            )),
+            category: Categories.Developer,
+            f1: true
+        });
+    }
+    async run(servicesAccessor) {
+        const loggerService = servicesAccessor.get(ILoggerService);
+        const outputService = servicesAccessor.get(IOutputService);
+        loggerService.setVisibility(VIEWS_LOG_ID, true);
+        outputService.showChannel(VIEWS_LOG_ID);
+    }
+});
+function getViewsStateStorageId(viewContainerStorageId) { return `${viewContainerStorageId}.hidden`; }
+let ViewDescriptorsState = class ViewDescriptorsState extends Disposable {
+    constructor(viewContainerStorageId, viewContainerName, storageService, loggerService) {
+        super();
+        this.viewContainerName = viewContainerName;
+        this.storageService = storageService;
+        this._onDidChangeStoredState = this._register(( new Emitter()));
+        this.onDidChangeStoredState = this._onDidChangeStoredState.event;
+        this.logger = loggerService.createLogger(VIEWS_LOG_ID, { name: VIEWS_LOG_NAME, hidden: true });
+        this.globalViewsStateStorageId = getViewsStateStorageId(viewContainerStorageId);
+        this.workspaceViewsStateStorageId = viewContainerStorageId;
+        this._register(this.storageService.onDidChangeValue(0 , this.globalViewsStateStorageId, this._register(( new DisposableStore())))(() => this.onDidStorageChange()));
+        this.state = this.initialize();
+    }
+    set(id, state) {
+        this.state.set(id, state);
+    }
+    get(id) {
+        return this.state.get(id);
+    }
+    updateState(viewDescriptors) {
+        this.updateWorkspaceState(viewDescriptors);
+        this.updateGlobalState(viewDescriptors);
+    }
+    updateWorkspaceState(viewDescriptors) {
+        const storedViewsStates = this.getStoredWorkspaceState();
+        for (const viewDescriptor of viewDescriptors) {
+            const viewState = this.get(viewDescriptor.id);
+            if (viewState) {
+                storedViewsStates[viewDescriptor.id] = {
+                    collapsed: !!viewState.collapsed,
+                    isHidden: !viewState.visibleWorkspace,
+                    size: viewState.size,
+                    order: viewDescriptor.workspace && viewState ? viewState.order : undefined
+                };
+            }
+        }
+        if (( Object.keys(storedViewsStates)).length > 0) {
+            this.storageService.store(this.workspaceViewsStateStorageId, JSON.stringify(storedViewsStates), 1 , 1 );
+        }
+        else {
+            this.storageService.remove(this.workspaceViewsStateStorageId, 1 );
+        }
+    }
+    updateGlobalState(viewDescriptors) {
+        const storedGlobalState = this.getStoredGlobalState();
+        for (const viewDescriptor of viewDescriptors) {
+            const state = this.get(viewDescriptor.id);
+            storedGlobalState.set(viewDescriptor.id, {
+                id: viewDescriptor.id,
+                isHidden: state && viewDescriptor.canToggleVisibility ? !state.visibleGlobal : false,
+                order: !viewDescriptor.workspace && state ? state.order : undefined
+            });
+        }
+        this.setStoredGlobalState(storedGlobalState);
+    }
+    onDidStorageChange() {
+        if (this.globalViewsStatesValue !== this.getStoredGlobalViewsStatesValue() ) {
+            this._globalViewsStatesValue = undefined;
+            const storedViewsVisibilityStates = this.getStoredGlobalState();
+            const storedWorkspaceViewsStates = this.getStoredWorkspaceState();
+            const changedStates = [];
+            for (const [id, storedState] of storedViewsVisibilityStates) {
+                const state = this.get(id);
+                if (state) {
+                    if (state.visibleGlobal !== !storedState.isHidden) {
+                        if (!storedState.isHidden) {
+                            this.logger.info(`View visibility state changed: ${id} is now visible`, this.viewContainerName);
+                        }
+                        changedStates.push({ id, visible: !storedState.isHidden });
+                    }
+                }
+                else {
+                    const workspaceViewState = storedWorkspaceViewsStates[id];
+                    this.set(id, {
+                        active: false,
+                        visibleGlobal: !storedState.isHidden,
+                        visibleWorkspace: isUndefined(workspaceViewState?.isHidden) ? undefined : !workspaceViewState?.isHidden,
+                        collapsed: workspaceViewState?.collapsed,
+                        order: workspaceViewState?.order,
+                        size: workspaceViewState?.size,
+                    });
+                }
+            }
+            if (changedStates.length) {
+                this._onDidChangeStoredState.fire(changedStates);
+                for (const changedState of changedStates) {
+                    const state = this.get(changedState.id);
+                    if (state) {
+                        state.visibleGlobal = changedState.visible;
+                    }
+                }
+            }
+        }
+    }
+    initialize() {
+        const viewStates = ( new Map());
+        const workspaceViewsStates = this.getStoredWorkspaceState();
+        for (const id of ( Object.keys(workspaceViewsStates))) {
+            const workspaceViewState = workspaceViewsStates[id];
+            viewStates.set(id, {
+                active: false,
+                visibleGlobal: undefined,
+                visibleWorkspace: isUndefined(workspaceViewState.isHidden) ? undefined : !workspaceViewState.isHidden,
+                collapsed: workspaceViewState.collapsed,
+                order: workspaceViewState.order,
+                size: workspaceViewState.size,
+            });
+        }
+        const value = this.storageService.get(this.globalViewsStateStorageId, 1 , '[]');
+        const { state: workspaceVisibilityStates } = this.parseStoredGlobalState(value);
+        if (workspaceVisibilityStates.size > 0) {
+            for (const { id, isHidden } of ( workspaceVisibilityStates.values())) {
+                const viewState = viewStates.get(id);
+                if (viewState) {
+                    if (isUndefined(viewState.visibleWorkspace)) {
+                        viewState.visibleWorkspace = !isHidden;
+                    }
+                }
+                else {
+                    viewStates.set(id, {
+                        active: false,
+                        collapsed: undefined,
+                        visibleGlobal: undefined,
+                        visibleWorkspace: !isHidden,
+                    });
+                }
+            }
+            this.storageService.remove(this.globalViewsStateStorageId, 1 );
+        }
+        const { state, hasDuplicates } = this.parseStoredGlobalState(this.globalViewsStatesValue);
+        if (hasDuplicates) {
+            this.setStoredGlobalState(state);
+        }
+        for (const { id, isHidden, order } of ( state.values())) {
+            const viewState = viewStates.get(id);
+            if (viewState) {
+                viewState.visibleGlobal = !isHidden;
+                if (!isUndefined(order)) {
+                    viewState.order = order;
+                }
+            }
+            else {
+                viewStates.set(id, {
+                    active: false,
+                    visibleGlobal: !isHidden,
+                    order,
+                    collapsed: undefined,
+                    visibleWorkspace: undefined,
+                });
+            }
+        }
+        return viewStates;
+    }
+    getStoredWorkspaceState() {
+        return JSON.parse(this.storageService.get(this.workspaceViewsStateStorageId, 1 , '{}'));
+    }
+    getStoredGlobalState() {
+        return this.parseStoredGlobalState(this.globalViewsStatesValue).state;
+    }
+    setStoredGlobalState(storedGlobalState) {
+        this.globalViewsStatesValue = JSON.stringify([...( storedGlobalState.values())]);
+    }
+    parseStoredGlobalState(value) {
+        const storedValue = JSON.parse(value);
+        let hasDuplicates = false;
+        const state = storedValue.reduce((result, storedState) => {
+            if (typeof storedState === 'string' ) {
+                hasDuplicates = hasDuplicates || ( result.has(storedState));
+                result.set(storedState, { id: storedState, isHidden: true });
+            }
+            else {
+                hasDuplicates = hasDuplicates || ( result.has(storedState.id));
+                result.set(storedState.id, storedState);
+            }
+            return result;
+        }, ( new Map()));
+        return { state, hasDuplicates };
+    }
+    get globalViewsStatesValue() {
+        if (!this._globalViewsStatesValue) {
+            this._globalViewsStatesValue = this.getStoredGlobalViewsStatesValue();
+        }
+        return this._globalViewsStatesValue;
+    }
+    set globalViewsStatesValue(globalViewsStatesValue) {
+        if (this.globalViewsStatesValue !== globalViewsStatesValue) {
+            this._globalViewsStatesValue = globalViewsStatesValue;
+            this.setStoredGlobalViewsStatesValue(globalViewsStatesValue);
+        }
+    }
+    getStoredGlobalViewsStatesValue() {
+        return this.storageService.get(this.globalViewsStateStorageId, 0 , '[]');
+    }
+    setStoredGlobalViewsStatesValue(value) {
+        this.storageService.store(this.globalViewsStateStorageId, value, 0 , 0 );
+    }
+};
+ViewDescriptorsState = ( __decorate([
+    ( __param(2, IStorageService)),
+    ( __param(3, ILoggerService))
+], ViewDescriptorsState));
+let ViewContainerModel = class ViewContainerModel extends Disposable {
+    get title() { return this._title; }
+    get icon() { return this._icon; }
+    get keybindingId() { return this._keybindingId; }
+    get allViewDescriptors() { return ( this.viewDescriptorItems.map(item => item.viewDescriptor)); }
+    get activeViewDescriptors() { return ( this.viewDescriptorItems.filter(item => item.state.active).map(item => item.viewDescriptor)); }
+    get visibleViewDescriptors() { return ( this.viewDescriptorItems.filter(item => this.isViewDescriptorVisible(item)).map(item => item.viewDescriptor)); }
+    constructor(viewContainer, instantiationService, contextKeyService, loggerService) {
+        super();
+        this.viewContainer = viewContainer;
+        this.contextKeyService = contextKeyService;
+        this.contextKeys = ( new CounterSet());
+        this.viewDescriptorItems = [];
+        this._onDidChangeContainerInfo = this._register(( new Emitter()));
+        this.onDidChangeContainerInfo = this._onDidChangeContainerInfo.event;
+        this._onDidChangeAllViewDescriptors = this._register(( new Emitter()));
+        this.onDidChangeAllViewDescriptors = this._onDidChangeAllViewDescriptors.event;
+        this._onDidChangeActiveViewDescriptors = this._register(( new Emitter()));
+        this.onDidChangeActiveViewDescriptors = this._onDidChangeActiveViewDescriptors.event;
+        this._onDidAddVisibleViewDescriptors = this._register(( new Emitter()));
+        this.onDidAddVisibleViewDescriptors = this._onDidAddVisibleViewDescriptors.event;
+        this._onDidRemoveVisibleViewDescriptors = this._register(( new Emitter()));
+        this.onDidRemoveVisibleViewDescriptors = this._onDidRemoveVisibleViewDescriptors.event;
+        this._onDidMoveVisibleViewDescriptors = this._register(( new Emitter()));
+        this.onDidMoveVisibleViewDescriptors = this._onDidMoveVisibleViewDescriptors.event;
+        this.logger = loggerService.createLogger(VIEWS_LOG_ID, { name: VIEWS_LOG_NAME, hidden: true });
+        this._register(Event.filter(contextKeyService.onDidChangeContext, e => e.affectsSome(this.contextKeys))(() => this.onDidChangeContext()));
+        this.viewDescriptorsState = this._register(instantiationService.createInstance(ViewDescriptorsState, viewContainer.storageId || `${viewContainer.id}.state`, typeof viewContainer.title === 'string' ? viewContainer.title : viewContainer.title.original));
+        this._register(this.viewDescriptorsState.onDidChangeStoredState(items => this.updateVisibility(items)));
+        this.updateContainerInfo();
+    }
+    updateContainerInfo() {
+        const useDefaultContainerInfo = this.viewContainer.alwaysUseContainerInfo || this.visibleViewDescriptors.length === 0 || ( this.visibleViewDescriptors.some(v => ( Registry.as(Extensions.ViewsRegistry)).getViewContainer(v.id) === this.viewContainer));
+        const title = useDefaultContainerInfo ? (typeof this.viewContainer.title === 'string' ? this.viewContainer.title : this.viewContainer.title.value) : this.visibleViewDescriptors[0]?.containerTitle || this.visibleViewDescriptors[0]?.name?.value || '';
+        let titleChanged = false;
+        if (this._title !== title) {
+            this._title = title;
+            titleChanged = true;
+        }
+        const icon = useDefaultContainerInfo ? this.viewContainer.icon : this.visibleViewDescriptors[0]?.containerIcon || defaultViewIcon;
+        let iconChanged = false;
+        if (!this.isEqualIcon(icon)) {
+            this._icon = icon;
+            iconChanged = true;
+        }
+        const keybindingId = this.viewContainer.openCommandActionDescriptor?.id ?? this.activeViewDescriptors.find(v => v.openCommandActionDescriptor)?.openCommandActionDescriptor?.id;
+        let keybindingIdChanged = false;
+        if (this._keybindingId !== keybindingId) {
+            this._keybindingId = keybindingId;
+            keybindingIdChanged = true;
+        }
+        if (titleChanged || iconChanged || keybindingIdChanged) {
+            this._onDidChangeContainerInfo.fire({ title: titleChanged, icon: iconChanged, keybindingId: keybindingIdChanged });
+        }
+    }
+    isEqualIcon(icon) {
+        if (URI.isUri(icon)) {
+            return URI.isUri(this._icon) && isEqual(icon, this._icon);
+        }
+        else if (ThemeIcon.isThemeIcon(icon)) {
+            return ThemeIcon.isThemeIcon(this._icon) && ThemeIcon.isEqual(icon, this._icon);
+        }
+        return icon === this._icon;
+    }
+    isVisible(id) {
+        const viewDescriptorItem = this.viewDescriptorItems.find(v => v.viewDescriptor.id === id);
+        if (!viewDescriptorItem) {
+            throw new Error(`Unknown view ${id}`);
+        }
+        return this.isViewDescriptorVisible(viewDescriptorItem);
+    }
+    setVisible(id, visible) {
+        this.updateVisibility([{ id, visible }]);
+    }
+    updateVisibility(viewDescriptors) {
+        const viewDescriptorItemsToHide = coalesce(( viewDescriptors.filter(({ visible }) => !visible)
+            .map(({ id }) => this.findAndIgnoreIfNotFound(id))));
+        const removed = [];
+        for (const { viewDescriptorItem, visibleIndex } of viewDescriptorItemsToHide) {
+            if (this.updateViewDescriptorItemVisibility(viewDescriptorItem, false)) {
+                removed.push({ viewDescriptor: viewDescriptorItem.viewDescriptor, index: visibleIndex });
+            }
+        }
+        if (removed.length) {
+            this.broadCastRemovedVisibleViewDescriptors(removed);
+        }
+        const added = [];
+        for (const { id, visible } of viewDescriptors) {
+            if (!visible) {
+                continue;
+            }
+            const foundViewDescriptor = this.findAndIgnoreIfNotFound(id);
+            if (!foundViewDescriptor) {
+                continue;
+            }
+            const { viewDescriptorItem, visibleIndex } = foundViewDescriptor;
+            if (this.updateViewDescriptorItemVisibility(viewDescriptorItem, true)) {
+                added.push({ index: visibleIndex, viewDescriptor: viewDescriptorItem.viewDescriptor, size: viewDescriptorItem.state.size, collapsed: !!viewDescriptorItem.state.collapsed });
+            }
+        }
+        if (added.length) {
+            this.broadCastAddedVisibleViewDescriptors(added);
+        }
+    }
+    updateViewDescriptorItemVisibility(viewDescriptorItem, visible) {
+        if (!viewDescriptorItem.viewDescriptor.canToggleVisibility) {
+            return false;
+        }
+        if (this.isViewDescriptorVisibleWhenActive(viewDescriptorItem) === visible) {
+            return false;
+        }
+        if (viewDescriptorItem.viewDescriptor.workspace) {
+            viewDescriptorItem.state.visibleWorkspace = visible;
+        }
+        else {
+            viewDescriptorItem.state.visibleGlobal = visible;
+            if (visible) {
+                this.logger.info(`Showing view ${viewDescriptorItem.viewDescriptor.id} in the container ${this.viewContainer.id}`);
+            }
+        }
+        return this.isViewDescriptorVisible(viewDescriptorItem) === visible;
+    }
+    isCollapsed(id) {
+        return !!this.find(id).viewDescriptorItem.state.collapsed;
+    }
+    setCollapsed(id, collapsed) {
+        const { viewDescriptorItem } = this.find(id);
+        if (viewDescriptorItem.state.collapsed !== collapsed) {
+            viewDescriptorItem.state.collapsed = collapsed;
+        }
+        this.viewDescriptorsState.updateState(this.allViewDescriptors);
+    }
+    getSize(id) {
+        return this.find(id).viewDescriptorItem.state.size;
+    }
+    setSizes(newSizes) {
+        for (const { id, size } of newSizes) {
+            const { viewDescriptorItem } = this.find(id);
+            if (viewDescriptorItem.state.size !== size) {
+                viewDescriptorItem.state.size = size;
+            }
+        }
+        this.viewDescriptorsState.updateState(this.allViewDescriptors);
+    }
+    move(from, to) {
+        const fromIndex = this.viewDescriptorItems.findIndex(v => v.viewDescriptor.id === from);
+        const toIndex = this.viewDescriptorItems.findIndex(v => v.viewDescriptor.id === to);
+        const fromViewDescriptor = this.viewDescriptorItems[fromIndex];
+        const toViewDescriptor = this.viewDescriptorItems[toIndex];
+        move(this.viewDescriptorItems, fromIndex, toIndex);
+        for (let index = 0; index < this.viewDescriptorItems.length; index++) {
+            this.viewDescriptorItems[index].state.order = index;
+        }
+        this.broadCastMovedViewDescriptors({ index: fromIndex, viewDescriptor: fromViewDescriptor.viewDescriptor }, { index: toIndex, viewDescriptor: toViewDescriptor.viewDescriptor });
+    }
+    add(addedViewDescriptorStates) {
+        const addedItems = [];
+        for (const addedViewDescriptorState of addedViewDescriptorStates) {
+            const viewDescriptor = addedViewDescriptorState.viewDescriptor;
+            if (viewDescriptor.when) {
+                for (const key of ( viewDescriptor.when.keys())) {
+                    this.contextKeys.add(key);
+                }
+            }
+            let state = this.viewDescriptorsState.get(viewDescriptor.id);
+            if (state) {
+                if (viewDescriptor.workspace) {
+                    state.visibleWorkspace = isUndefinedOrNull(addedViewDescriptorState.visible) ? (isUndefinedOrNull(state.visibleWorkspace) ? !viewDescriptor.hideByDefault : state.visibleWorkspace) : addedViewDescriptorState.visible;
+                }
+                else {
+                    const isVisible = state.visibleGlobal;
+                    state.visibleGlobal = isUndefinedOrNull(addedViewDescriptorState.visible) ? (isUndefinedOrNull(state.visibleGlobal) ? !viewDescriptor.hideByDefault : state.visibleGlobal) : addedViewDescriptorState.visible;
+                    if (state.visibleGlobal && !isVisible) {
+                        this.logger.info(`Added view ${viewDescriptor.id} in the container ${this.viewContainer.id} and showing it.`, `${isVisible}`, `${viewDescriptor.hideByDefault}`, `${addedViewDescriptorState.visible}`);
+                    }
+                }
+                state.collapsed = isUndefinedOrNull(addedViewDescriptorState.collapsed) ? (isUndefinedOrNull(state.collapsed) ? !!viewDescriptor.collapsed : state.collapsed) : addedViewDescriptorState.collapsed;
+            }
+            else {
+                state = {
+                    active: false,
+                    visibleGlobal: isUndefinedOrNull(addedViewDescriptorState.visible) ? !viewDescriptor.hideByDefault : addedViewDescriptorState.visible,
+                    visibleWorkspace: isUndefinedOrNull(addedViewDescriptorState.visible) ? !viewDescriptor.hideByDefault : addedViewDescriptorState.visible,
+                    collapsed: isUndefinedOrNull(addedViewDescriptorState.collapsed) ? !!viewDescriptor.collapsed : addedViewDescriptorState.collapsed,
+                };
+            }
+            this.viewDescriptorsState.set(viewDescriptor.id, state);
+            state.active = this.contextKeyService.contextMatchesRules(viewDescriptor.when);
+            addedItems.push({ viewDescriptor, state });
+        }
+        this.viewDescriptorItems.push(...addedItems);
+        this.viewDescriptorItems.sort(this.compareViewDescriptors.bind(this));
+        this._onDidChangeAllViewDescriptors.fire({ added: ( addedItems.map(({ viewDescriptor }) => viewDescriptor)), removed: [] });
+        const addedActiveItems = [];
+        for (const viewDescriptorItem of addedItems) {
+            if (viewDescriptorItem.state.active) {
+                addedActiveItems.push({ viewDescriptorItem, visible: this.isViewDescriptorVisible(viewDescriptorItem) });
+            }
+        }
+        if (addedActiveItems.length) {
+            this._onDidChangeActiveViewDescriptors.fire(({ added: ( addedActiveItems.map(({ viewDescriptorItem }) => viewDescriptorItem.viewDescriptor)), removed: [] }));
+        }
+        const addedVisibleDescriptors = [];
+        for (const { viewDescriptorItem, visible } of addedActiveItems) {
+            if (visible && this.isViewDescriptorVisible(viewDescriptorItem)) {
+                const { visibleIndex } = this.find(viewDescriptorItem.viewDescriptor.id);
+                addedVisibleDescriptors.push({ index: visibleIndex, viewDescriptor: viewDescriptorItem.viewDescriptor, size: viewDescriptorItem.state.size, collapsed: !!viewDescriptorItem.state.collapsed });
+            }
+        }
+        this.broadCastAddedVisibleViewDescriptors(addedVisibleDescriptors);
+    }
+    remove(viewDescriptors) {
+        const removed = [];
+        const removedItems = [];
+        const removedActiveDescriptors = [];
+        const removedVisibleDescriptors = [];
+        for (const viewDescriptor of viewDescriptors) {
+            if (viewDescriptor.when) {
+                for (const key of ( viewDescriptor.when.keys())) {
+                    this.contextKeys.delete(key);
+                }
+            }
+            const index = this.viewDescriptorItems.findIndex(i => i.viewDescriptor.id === viewDescriptor.id);
+            if (index !== -1) {
+                removed.push(viewDescriptor);
+                const viewDescriptorItem = this.viewDescriptorItems[index];
+                if (viewDescriptorItem.state.active) {
+                    removedActiveDescriptors.push(viewDescriptorItem.viewDescriptor);
+                }
+                if (this.isViewDescriptorVisible(viewDescriptorItem)) {
+                    const { visibleIndex } = this.find(viewDescriptorItem.viewDescriptor.id);
+                    removedVisibleDescriptors.push({ index: visibleIndex, viewDescriptor: viewDescriptorItem.viewDescriptor });
+                }
+                removedItems.push(viewDescriptorItem);
+            }
+        }
+        removedItems.forEach(item => this.viewDescriptorItems.splice(this.viewDescriptorItems.indexOf(item), 1));
+        this.broadCastRemovedVisibleViewDescriptors(removedVisibleDescriptors);
+        if (removedActiveDescriptors.length) {
+            this._onDidChangeActiveViewDescriptors.fire(({ added: [], removed: removedActiveDescriptors }));
+        }
+        if (removed.length) {
+            this._onDidChangeAllViewDescriptors.fire({ added: [], removed });
+        }
+    }
+    onDidChangeContext() {
+        const addedActiveItems = [];
+        const removedActiveItems = [];
+        for (const item of this.viewDescriptorItems) {
+            const wasActive = item.state.active;
+            const isActive = this.contextKeyService.contextMatchesRules(item.viewDescriptor.when);
+            if (wasActive !== isActive) {
+                if (isActive) {
+                    addedActiveItems.push({ item, visibleWhenActive: this.isViewDescriptorVisibleWhenActive(item) });
+                }
+                else {
+                    removedActiveItems.push(item);
+                }
+            }
+        }
+        const removedVisibleDescriptors = [];
+        for (const item of removedActiveItems) {
+            if (this.isViewDescriptorVisible(item)) {
+                const { visibleIndex } = this.find(item.viewDescriptor.id);
+                removedVisibleDescriptors.push({ index: visibleIndex, viewDescriptor: item.viewDescriptor });
+            }
+        }
+        removedActiveItems.forEach(item => item.state.active = false);
+        addedActiveItems.forEach(({ item }) => item.state.active = true);
+        this.broadCastRemovedVisibleViewDescriptors(removedVisibleDescriptors);
+        if (addedActiveItems.length || removedActiveItems.length) {
+            this._onDidChangeActiveViewDescriptors.fire(({ added: ( addedActiveItems.map(({ item }) => item.viewDescriptor)), removed: ( removedActiveItems.map(item => item.viewDescriptor)) }));
+        }
+        const addedVisibleDescriptors = [];
+        for (const { item, visibleWhenActive } of addedActiveItems) {
+            if (visibleWhenActive && this.isViewDescriptorVisible(item)) {
+                const { visibleIndex } = this.find(item.viewDescriptor.id);
+                addedVisibleDescriptors.push({ index: visibleIndex, viewDescriptor: item.viewDescriptor, size: item.state.size, collapsed: !!item.state.collapsed });
+            }
+        }
+        this.broadCastAddedVisibleViewDescriptors(addedVisibleDescriptors);
+    }
+    broadCastAddedVisibleViewDescriptors(added) {
+        if (added.length) {
+            this._onDidAddVisibleViewDescriptors.fire(added.sort((a, b) => a.index - b.index));
+            this.updateState(`Added views:${( added.map(v => v.viewDescriptor.id)).join(',')} in ${this.viewContainer.id}`);
+        }
+    }
+    broadCastRemovedVisibleViewDescriptors(removed) {
+        if (removed.length) {
+            this._onDidRemoveVisibleViewDescriptors.fire(removed.sort((a, b) => b.index - a.index));
+            this.updateState(`Removed views:${( removed.map(v => v.viewDescriptor.id)).join(',')} from ${this.viewContainer.id}`);
+        }
+    }
+    broadCastMovedViewDescriptors(from, to) {
+        this._onDidMoveVisibleViewDescriptors.fire({ from, to });
+        this.updateState(`Moved view ${from.viewDescriptor.id} to ${to.viewDescriptor.id} in ${this.viewContainer.id}`);
+    }
+    updateState(reason) {
+        this.logger.info(reason);
+        this.viewDescriptorsState.updateState(this.allViewDescriptors);
+        this.updateContainerInfo();
+    }
+    isViewDescriptorVisible(viewDescriptorItem) {
+        if (!viewDescriptorItem.state.active) {
+            return false;
+        }
+        return this.isViewDescriptorVisibleWhenActive(viewDescriptorItem);
+    }
+    isViewDescriptorVisibleWhenActive(viewDescriptorItem) {
+        if (viewDescriptorItem.viewDescriptor.workspace) {
+            return !!viewDescriptorItem.state.visibleWorkspace;
+        }
+        return !!viewDescriptorItem.state.visibleGlobal;
+    }
+    find(id) {
+        const result = this.findAndIgnoreIfNotFound(id);
+        if (result) {
+            return result;
+        }
+        throw new Error(`view descriptor ${id} not found`);
+    }
+    findAndIgnoreIfNotFound(id) {
+        for (let i = 0, visibleIndex = 0; i < this.viewDescriptorItems.length; i++) {
+            const viewDescriptorItem = this.viewDescriptorItems[i];
+            if (viewDescriptorItem.viewDescriptor.id === id) {
+                return { index: i, visibleIndex, viewDescriptorItem: viewDescriptorItem };
+            }
+            if (this.isViewDescriptorVisible(viewDescriptorItem)) {
+                visibleIndex++;
+            }
+        }
+        return undefined;
+    }
+    compareViewDescriptors(a, b) {
+        if (a.viewDescriptor.id === b.viewDescriptor.id) {
+            return 0;
+        }
+        return (this.getViewOrder(a) - this.getViewOrder(b)) || this.getGroupOrderResult(a.viewDescriptor, b.viewDescriptor);
+    }
+    getViewOrder(viewDescriptorItem) {
+        const viewOrder = typeof viewDescriptorItem.state.order === 'number' ? viewDescriptorItem.state.order : viewDescriptorItem.viewDescriptor.order;
+        return typeof viewOrder === 'number' ? viewOrder : Number.MAX_VALUE;
+    }
+    getGroupOrderResult(a, b) {
+        if (!a.group || !b.group) {
+            return 0;
+        }
+        if (a.group === b.group) {
+            return 0;
+        }
+        return a.group < b.group ? -1 : 1;
+    }
+};
+ViewContainerModel = ( __decorate([
+    ( __param(1, IInstantiationService)),
+    ( __param(2, IContextKeyService)),
+    ( __param(3, ILoggerService))
+], ViewContainerModel));
+
+export { ViewContainerModel, getViewsStateStorageId };