@celljs/ta-web 0.0.0-stage → 4.6.0

package/lib/browser/extension/web-extensions.spec.js

@@ -0,0 +1,617 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const bun_test_1 = require("bun:test");
+const React = __importStar(require("react"));
+const server_1 = require("react-dom/server");
+const notices_1 = require("../notices/notices");
+const web_extensions_1 = require("./web-extensions");
+const NOTES = `export default function (pi) {
+    pi.ui.setWidget('notes', () => 'notes', { title: 'Notes', placement: 'panel' });
+    pi.ui.setWidget('hint', () => 'hint');
+    pi.registerTool({ name: 'add_note', description: 'Adds a note.', parameters: { type: 'object' }, execute: () => 'added' });
+    pi.registerMessageRenderer('note', () => 'note');
+    pi.registerAvatar(() => 'face');
+    pi.registerOpener(link => link.type === 'file' && link.path.endsWith('.note'));
+    pi.on('agent_end', () => globalThis.ended = (globalThis.ended ?? 0) + 1);
+    return () => globalThis.disposed = (globalThis.disposed ?? 0) + 1;
+}`;
+function setup(builtins = []) {
+    const files = new Map([['notes', NOTES]]);
+    const info = (id) => { var _a; return ({
+        id,
+        name: id,
+        scope: 'user',
+        origin: 'directory',
+        enabled: true,
+        source: id,
+        entry: 'web.js',
+        hash: String((_a = files.get(id)) === null || _a === void 0 ? void 0 : _a.length),
+    }); };
+    const server = {
+        listWebExtensions: async () => [...files.keys()].map(info),
+        readWebExtension: async (id) => { var _a; return ({ id, hash: info(id).hash, code: (_a = files.get(id)) !== null && _a !== void 0 ? _a : '' }); },
+        removeWebExtension: async (id) => void files.delete(id),
+    };
+    const settings = { state: { settings: { builtinsOff: [] }, theme: 'dark', language: 'en-US' } };
+    const notices = new notices_1.TaNoticesImpl();
+    const extensions = new web_extensions_1.TaWebExtensionsImpl();
+    const kept = new Map();
+    const persisted = {
+        get: (spec) => { var _a; return (_a = kept.get(spec.key)) !== null && _a !== void 0 ? _a : spec.initial; },
+        load: async (spec) => { var _a; return (_a = kept.get(spec.key)) !== null && _a !== void 0 ? _a : spec.initial; },
+        set: (spec, value) => void kept.set(spec.key, value),
+    };
+    // One fake answers for every service of ta serve.
+    Object.assign(extensions, { workbench: { server, packages: server, workspace: server, terminals: server }, settings, builtins, notices, persisted });
+    Object.assign(globalThis, { ended: 0, disposed: 0 });
+    return { extensions, files, settings, notices, kept };
+}
+(0, bun_test_1.describe)('TaWebExtensionsImpl', () => {
+    (0, bun_test_1.it)('runs the web extensions of packages, with what they register', async () => {
+        const { extensions } = setup();
+        (0, bun_test_1.expect)(await extensions.refresh()).toBe(true);
+        const { state } = extensions;
+        (0, bun_test_1.expect)(state.extensions).toMatchObject([{ id: 'notes', name: 'notes' }]);
+        (0, bun_test_1.expect)(state.widgets).toMatchObject([
+            { id: 'notes/notes', placement: 'panel', title: 'Notes' },
+            { id: 'notes/hint', placement: 'aboveEditor' },
+        ]);
+        (0, bun_test_1.expect)(state.tools.map(tool => tool.name)).toEqual(['add_note']);
+        (0, bun_test_1.expect)(state.openers).toHaveLength(1);
+        (0, bun_test_1.expect)(await state.openers[0]({ type: 'file', cwd: '/w', path: 'a.note' })).toBe(true);
+        (0, bun_test_1.expect)(await state.openers[0]({ type: 'url', url: 'https://x.dev' })).toBe(false);
+        (0, bun_test_1.expect)(Object.keys(state.renderers)).toEqual(['note']);
+        // By the name of the extension: the group of the sessions of its package.
+        (0, bun_test_1.expect)(Object.keys(state.avatars)).toEqual(['notes']);
+        extensions.emit({ type: 'agent_end', messages: [] });
+        (0, bun_test_1.expect)(globalThis.ended).toBe(1);
+        (0, bun_test_1.expect)(await extensions.refresh()).toBe(false);
+    });
+    (0, bun_test_1.it)('does not run the web extension of a built-in package that is turned off', async () => {
+        const { extensions } = setup();
+        const server = extensions.workbench.server;
+        const list = server.listWebExtensions;
+        server.listWebExtensions = async () => (await list()).map(info => ({ ...info, origin: 'builtin', enabled: false }));
+        await extensions.refresh();
+        (0, bun_test_1.expect)(extensions.state.extensions).toEqual([]);
+        server.listWebExtensions = list;
+        (0, bun_test_1.expect)(await extensions.refresh()).toBe(true);
+        (0, bun_test_1.expect)(extensions.state.extensions.map(extension => extension.name)).toEqual(['notes']);
+    });
+    (0, bun_test_1.it)('runs a changed file again and stops a removed one', async () => {
+        const { extensions, files } = setup();
+        await extensions.refresh();
+        files.set('notes', NOTES.replace("'Notes'", "'My notes'"));
+        (0, bun_test_1.expect)(await extensions.refresh()).toBe(true);
+        (0, bun_test_1.expect)(globalThis.disposed).toBe(1);
+        (0, bun_test_1.expect)(extensions.state.widgets).toMatchObject([{ title: 'My notes' }, { id: 'notes/hint' }]);
+        await extensions.remove('notes');
+        (0, bun_test_1.expect)(globalThis.disposed).toBe(2);
+        (0, bun_test_1.expect)(extensions.state).toMatchObject({ extensions: [], widgets: [], tools: [], openers: [], renderers: {}, avatars: {} });
+    });
+    (0, bun_test_1.it)('keeps the error of an extension that fails, until its file changes', async () => {
+        const { extensions, files } = setup();
+        files.set('broken', 'export default function () { throw new Error("no luck"); }');
+        files.set('wrong', 'export const x = 1;');
+        await extensions.refresh();
+        (0, bun_test_1.expect)(extensions.state.extensions.map(({ name, error }) => [name, error])).toEqual([
+            ['notes', undefined],
+            ['broken', 'no luck'],
+            ['wrong', 'A web extension exports a function as its default export.'],
+        ]);
+        (0, bun_test_1.expect)(await extensions.refresh()).toBe(false);
+    });
+    (0, bun_test_1.it)('runs the built-ins the settings turn on', async () => {
+        let api;
+        const builtin = {
+            name: 'clock',
+            title: 'ta.settings',
+            description: 'ta.settings',
+            activate: pi => {
+                api = pi;
+                pi.registerView('clock', { title: 'Clock', render: () => null, icon: () => null });
+            },
+        };
+        const { extensions, settings } = setup([builtin]);
+        settings.state.settings.builtinsOff = ['clock'];
+        await extensions.refresh();
+        (0, bun_test_1.expect)(extensions.state.views).toEqual([]);
+        settings.state.settings.builtinsOff = [];
+        await extensions.refresh();
+        (0, bun_test_1.expect)(extensions.state.views).toMatchObject([{ id: 'clock/clock', title: 'Clock', icon: bun_test_1.expect.any(Function) }]);
+        (0, bun_test_1.expect)(api === null || api === void 0 ? void 0 : api.ui.theme).toBe('dark');
+        settings.state.settings.builtinsOff = ['clock'];
+        await extensions.refresh();
+        (0, bun_test_1.expect)(extensions.state.views).toEqual([]);
+        // An extension that stopped registers nothing more.
+        api === null || api === void 0 ? void 0 : api.ui.setWidget('late', () => null);
+        (0, bun_test_1.expect)(extensions.state.widgets.filter(widget => widget.id.includes('late'))).toEqual([]);
+    });
+    (0, bun_test_1.it)('sends to the conversation shown, and shows notices and questions on the page', async () => {
+        let api;
+        const { extensions, notices } = setup([
+            {
+                name: 'probe',
+                title: 'ta.settings',
+                description: 'ta.settings',
+                activate: pi => {
+                    api = pi;
+                },
+            },
+        ]);
+        Object.assign(extensions, { settings: { state: { settings: { builtinsOff: [] }, theme: 'light', language: 'zh-CN' } } });
+        await extensions.refresh();
+        await (0, bun_test_1.expect)(api.sendUserMessage('hi')).rejects.toThrow('No conversation');
+        // A new conversation has a directory, and nothing to send to until its first message.
+        extensions.connect({ cwd: '/work' });
+        (0, bun_test_1.expect)(extensions.state.cwd).toBe('/work');
+        await (0, bun_test_1.expect)(api.sendUserMessage('hi')).rejects.toThrow('No conversation');
+        (0, bun_test_1.expect)(api.ui.FolderPicker).toBeFunction();
+        const sent = [];
+        extensions.connect({ send: async (text) => void sent.push(text) });
+        await api.sendUserMessage('/notes add milk');
+        (0, bun_test_1.expect)(sent).toEqual(['/notes add milk']);
+        await (0, bun_test_1.expect)(api.switchSession('s2')).rejects.toThrow('cannot show');
+        const shown = [];
+        extensions.setSessionSwitcher(async (sessionId) => {
+            shown.push(sessionId);
+            extensions.connect({ send: async () => undefined, sessionId });
+        });
+        await api.switchSession('s2');
+        (0, bun_test_1.expect)(shown).toEqual(['s2']);
+        (0, bun_test_1.expect)(extensions.state.sessionId).toBe('s2');
+        api.ui.notify('saved');
+        api.ui.notify('failed', 'error');
+        (0, bun_test_1.expect)(notices.state.notices).toMatchObject([
+            { message: 'saved', level: 'info' },
+            { message: 'failed', level: 'error' },
+        ]);
+        const asked = api.ui.confirm('Delete it?', 'It cannot be undone.');
+        (0, bun_test_1.expect)(notices.state.confirm).toMatchObject({ title: 'Delete it?', message: 'It cannot be undone.' });
+        notices.answer(notices.state.confirm.id, true);
+        (0, bun_test_1.expect)(await asked).toBe(true);
+        const named = api.ui.input('Name', 'A name', { value: 'Ta' });
+        (0, bun_test_1.expect)(notices.state.input).toMatchObject({ title: 'Name', placeholder: 'A name', value: 'Ta' });
+        notices.answerInput(notices.state.input.id, 'Rex');
+        (0, bun_test_1.expect)(await named).toBe('Rex');
+        const role = api.ui.editor('Role', 'Writes tests.');
+        (0, bun_test_1.expect)(notices.state.input).toMatchObject({ title: 'Role', value: 'Writes tests.', multiline: true });
+        notices.answerInput(notices.state.input.id, undefined);
+        (0, bun_test_1.expect)(await role).toBeUndefined();
+    });
+    (0, bun_test_1.it)('sorts views by location and order, and keeps editors until their extension stops', async () => {
+        const closed = [];
+        const builtin = {
+            name: 'files',
+            title: 'ta.settings',
+            description: 'ta.settings',
+            activate: pi => {
+                pi.registerView('search', { title: 'Search', render: () => null, location: 'sidebar', order: 20 });
+                pi.registerView('explorer', { title: 'Explorer', render: () => null, location: 'sidebar', order: 10 });
+                pi.registerView('page', { title: 'Page', render: () => null });
+                pi.ui.openEditor({ id: 'a', title: 'a.ts', render: () => null, onClose: () => closed.push('a') });
+                pi.ui.openEditor({ id: 'b', title: 'b.ts', render: () => null, onClose: () => closed.push('b') });
+                pi.ui.openEditor({ id: 'a', title: 'a.ts', render: () => null, onClose: () => closed.push('a') });
+                return undefined;
+            },
+        };
+        const { extensions, settings } = setup([builtin]);
+        settings.state.settings.builtinsOff = [];
+        await extensions.refresh();
+        (0, bun_test_1.expect)(extensions.state.views.map(view => [view.id, view.location])).toEqual([
+            ['files/explorer', 'sidebar'],
+            ['files/search', 'sidebar'],
+            ['files/page', 'page'],
+        ]);
+        (0, bun_test_1.expect)(extensions.state.editors.map(editor => editor.id)).toEqual(['a', 'b']);
+        (0, bun_test_1.expect)(extensions.state.activeEditor).toBe('a');
+        extensions.showEditor('b');
+        extensions.closeEditor('b');
+        (0, bun_test_1.expect)(closed).toEqual(['b']);
+        (0, bun_test_1.expect)(extensions.state.activeEditor).toBe('a');
+        settings.state.settings.builtinsOff = ['files'];
+        await extensions.refresh();
+        (0, bun_test_1.expect)(extensions.state.editors).toEqual([]);
+        (0, bun_test_1.expect)(closed).toEqual(['b']);
+    });
+    (0, bun_test_1.it)('replaces a preview tab with the next one, keeps pinned and dirty tabs, and asks before closing a dirty one', async () => {
+        let api;
+        const closed = [];
+        const builtin = {
+            name: 'files',
+            title: 'ta.settings',
+            description: 'ta.settings',
+            activate: pi => {
+                api = pi;
+                return undefined;
+            },
+        };
+        const { extensions, settings } = setup([builtin]);
+        settings.state.settings.builtinsOff = [];
+        const answers = [];
+        Object.assign(extensions, { notices: { confirm: async () => { var _a; return (_a = answers.shift()) !== null && _a !== void 0 ? _a : false; } } });
+        await extensions.refresh();
+        const open = (id, preview) => api.ui.openEditor({ id, title: id, render: () => null, onClose: () => closed.push(id) }, { preview });
+        const tabs = () => extensions.state.editors.map(editor => `${editor.id}${editor.preview ? '~' : ''}${editor.dirty ? '*' : ''}`);
+        open('a', true);
+        open('b', true);
+        // The preview takes the place of the one before, which is closed.
+        (0, bun_test_1.expect)(tabs()).toEqual(['b~']);
+        (0, bun_test_1.expect)(closed).toEqual(['a']);
+        // Opened again without preview, or pinned: it stays.
+        open('b', false);
+        open('c', true);
+        (0, bun_test_1.expect)(tabs()).toEqual(['b', 'c~']);
+        extensions.pinEditor('c');
+        open('d', true);
+        (0, bun_test_1.expect)(tabs()).toEqual(['b', 'c', 'd~']);
+        // A dirty tab is pinned too.
+        api.ui.setEditorDirty('d', true);
+        open('e', true);
+        (0, bun_test_1.expect)(tabs()).toEqual(['b', 'c', 'd*', 'e~']);
+        const Probe = () => {
+            seen = api.ui.useActiveEditor();
+            return null;
+        };
+        let seen;
+        (0, server_1.renderToStaticMarkup)(React.createElement(Probe));
+        (0, bun_test_1.expect)(seen).toBe('e');
+        // Closing a dirty tab asks: no keeps it, yes closes it.
+        answers.push(false);
+        await extensions.closeEditor('d');
+        (0, bun_test_1.expect)(tabs()).toContain('d*');
+        answers.push(true);
+        await extensions.closeEditor('d');
+        (0, bun_test_1.expect)(tabs()).toEqual(['b', 'c', 'e~']);
+        (0, bun_test_1.expect)(closed).toEqual(['a', 'd']);
+        (0, bun_test_1.expect)(api.ui.DiffEditor).toBeFunction();
+    });
+    (0, bun_test_1.it)('closes tabs at once, asking once for those that are dirty', async () => {
+        let api;
+        const closed = [];
+        const builtin = {
+            name: 'files',
+            title: 'ta.settings',
+            description: 'ta.settings',
+            activate: pi => {
+                api = pi;
+                return undefined;
+            },
+        };
+        const { extensions } = setup([builtin]);
+        const asked = [];
+        const answers = [];
+        Object.assign(extensions, {
+            notices: {
+                confirm: async ({ title }) => {
+                    var _a;
+                    asked.push(title);
+                    return (_a = answers.shift()) !== null && _a !== void 0 ? _a : false;
+                },
+            },
+        });
+        await extensions.refresh();
+        for (const id of ['a', 'b', 'c', 'd']) {
+            api.ui.openEditor({ id, title: id, render: () => null, onClose: () => closed.push(id) });
+        }
+        const tabs = () => extensions.state.editors.map(editor => editor.id);
+        // None dirty: no question.
+        await extensions.closeEditors(['a']);
+        (0, bun_test_1.expect)(tabs()).toEqual(['b', 'c', 'd']);
+        (0, bun_test_1.expect)(asked).toEqual([]);
+        api.ui.setEditorDirty('b', true);
+        api.ui.setEditorDirty('c', true);
+        // One question for both; no keeps all of them.
+        answers.push(false);
+        await extensions.closeEditors(['b', 'c', 'd']);
+        (0, bun_test_1.expect)(asked).toEqual(['Close 2 tabs without saving?']);
+        (0, bun_test_1.expect)(tabs()).toEqual(['b', 'c', 'd']);
+        answers.push(true);
+        await extensions.closeEditors(['b', 'c', 'd', 'missing']);
+        (0, bun_test_1.expect)(tabs()).toEqual([]);
+        (0, bun_test_1.expect)(closed).toEqual(['a', 'b', 'c', 'd']);
+    });
+    (0, bun_test_1.it)('opens a panel view as a tab of the workbench, once', async () => {
+        const Terminal = () => null;
+        const builtin = {
+            name: 'tools',
+            title: 'ta.settings',
+            description: 'ta.settings',
+            activate: pi => {
+                pi.registerView('terminal', { title: 'Terminal', render: Terminal, location: 'panel' });
+                pi.registerView('page', { title: 'Page', render: () => null });
+                return undefined;
+            },
+        };
+        const { extensions, settings } = setup([builtin]);
+        settings.state.settings.builtinsOff = [];
+        await extensions.refresh();
+        extensions.openView('tools/page');
+        (0, bun_test_1.expect)(extensions.state.editors).toEqual([]);
+        extensions.openView('tools/terminal');
+        extensions.openView('tools/terminal');
+        (0, bun_test_1.expect)(extensions.state.editors).toMatchObject([{ id: 'view:tools/terminal', title: 'Terminal', render: Terminal, extension: 'builtin:tools' }]);
+        (0, bun_test_1.expect)(extensions.state.activeEditor).toBe('view:tools/terminal');
+        extensions.open({ id: 'view:ta/cards', extension: 'ta', title: 'Cards', render: () => null });
+        (0, bun_test_1.expect)(extensions.state.activeEditor).toBe('view:ta/cards');
+        settings.state.settings.builtinsOff = ['tools'];
+        await extensions.refresh();
+        (0, bun_test_1.expect)(extensions.state.editors.map(editor => editor.id)).toEqual(['view:ta/cards']);
+    });
+    (0, bun_test_1.it)('shows a view of another extension by its id, and tells whether it is shown', async () => {
+        var _a, _b, _c, _d;
+        let api;
+        const builtin = {
+            name: 'side',
+            title: 'ta.settings',
+            description: 'ta.settings',
+            activate: pi => {
+                api = pi;
+                pi.registerView('list', { title: 'List', render: () => null, location: 'sidebar', pages: ['side/room'] });
+                pi.registerView('room', {
+                    title: () => 'Room',
+                    render: () => null,
+                    head: () => null,
+                    menu: () => [[{ key: 'rename', label: 'Rename', run: () => undefined }]],
+                });
+                pi.registerView('tool', { title: 'Tool', render: () => null, location: 'panel' });
+                return undefined;
+            },
+        };
+        const { extensions, settings } = setup([builtin]);
+        settings.state.settings.builtinsOff = [];
+        await extensions.refresh();
+        (0, bun_test_1.expect)((_a = extensions.state.views.find(view => view.id === 'side/list')) === null || _a === void 0 ? void 0 : _a.pages).toEqual(['side/room']);
+        (0, bun_test_1.expect)((_b = extensions.state.views.find(view => view.id === 'side/room')) === null || _b === void 0 ? void 0 : _b.head).toBeFunction();
+        const shown = () => {
+            let seen;
+            const Probe = () => {
+                seen = api.ui.useView('side/room');
+                return null;
+            };
+            (0, server_1.renderToStaticMarkup)(React.createElement(Probe));
+            return seen;
+        };
+        (0, bun_test_1.expect)(shown()).toMatchObject({ title: 'Room', location: 'page', shown: false });
+        (0, bun_test_1.expect)((_d = (_c = shown()).menu) === null || _d === void 0 ? void 0 : _d.call(_c).map(section => section.map(item => item.key))).toEqual([['rename']]);
+        api.ui.showView('side/room');
+        (0, bun_test_1.expect)(extensions.state.page).toBe('side/room');
+        (0, bun_test_1.expect)(shown()).toMatchObject({ title: 'Room', location: 'page', shown: true });
+        api.ui.showView('side/tool');
+        (0, bun_test_1.expect)(extensions.state.activeEditor).toBe('view:side/tool');
+        api.ui.showView('nobody/nothing');
+        (0, bun_test_1.expect)(extensions.state.page).toBe('side/room');
+        api.ui.showView('');
+        (0, bun_test_1.expect)(extensions.state.page).toBe('');
+        api.ui.showView('side/room');
+        // Another conversation shown: the page goes.
+        extensions.setSessionSwitcher(async () => undefined);
+        await api.switchSession('s2');
+        (0, bun_test_1.expect)(extensions.state.page).toBe('');
+        (0, bun_test_1.expect)(api.ui.Composer).toBeFunction();
+        (0, bun_test_1.expect)(api.ui.Markdown).toBeFunction();
+        (0, bun_test_1.expect)(api.ui.Dialog).toBeFunction();
+    });
+    (0, bun_test_1.it)('keeps the data of a package on the server, under its name', async () => {
+        const { extensions } = setup();
+        const data = new Map();
+        const holder = {};
+        Object.assign(extensions.workbench.server, {
+            getExtensionData: async (name, key) => data.get(`${name}/${key}`),
+            setExtensionData: async (name, key, value) => void data.set(`${name}/${key}`, value),
+        });
+        Object.assign(extensions, {
+            builtins: [
+                {
+                    name: 'keeper',
+                    title: 'ta.settings',
+                    description: 'ta.settings',
+                    activate: (pi) => {
+                        holder.api = pi;
+                        return undefined;
+                    },
+                },
+            ],
+            settings: { state: { settings: { builtinsOff: [] }, theme: 'dark', language: 'en-US' } },
+        });
+        await extensions.refresh();
+        const api = holder.api;
+        await api.storage.set('channels', [{ name: 'general' }]);
+        (0, bun_test_1.expect)(await api.storage.get('channels')).toEqual([{ name: 'general' }]);
+        (0, bun_test_1.expect)([...data.keys()]).toEqual(['keeper/channels']);
+        (0, bun_test_1.expect)(Object.keys(api.ui.icons)).toContain('Files');
+    });
+    (0, bun_test_1.it)('passes the output of terminals to an extension until it unloads', async () => {
+        const { extensions, settings } = setup();
+        const listeners = new Set();
+        Object.assign(extensions.workbench, {
+            onTerminalData: (listener) => {
+                listeners.add(listener);
+                return () => listeners.delete(listener);
+            },
+        });
+        const seen = [];
+        Object.assign(extensions, {
+            builtins: [
+                {
+                    name: 'shell',
+                    title: 'ta.settings',
+                    description: 'ta.settings',
+                    activate: (pi) => {
+                        pi.onTerminalData((terminalId, data, exitCode) => seen.push(`${terminalId}:${data}:${exitCode}`));
+                        return undefined;
+                    },
+                },
+            ],
+        });
+        settings.state.settings.builtinsOff = [];
+        await extensions.refresh();
+        for (const listener of listeners) {
+            listener('t1', 'hi', undefined);
+            listener('t1', '', 0);
+        }
+        (0, bun_test_1.expect)(seen).toEqual(['t1:hi:undefined', 't1::0']);
+        settings.state.settings.builtinsOff = ['shell'];
+        await extensions.refresh();
+        (0, bun_test_1.expect)(listeners.size).toBe(0);
+    });
+    (0, bun_test_1.it)('opens again the tools of the workbench open before, behind what is shown, and keeps what opens or closes', async () => {
+        const { extensions, settings, kept } = setup();
+        kept.set('workbench', { views: ['tools/terminal', 'tools/gone'], active: 'file:a' });
+        let reopen;
+        Object.assign(extensions, {
+            builtins: [
+                {
+                    name: 'tools',
+                    title: 'ta.settings',
+                    description: 'ta.settings',
+                    activate: (pi) => {
+                        pi.registerView('explorer', { title: 'Files', render: () => null, location: 'panel' });
+                        pi.registerView('terminal', { title: 'Terminal', render: () => null, location: 'panel' });
+                        reopen = () => pi.ui.openEditor({ id: 'file:a', title: 'a.ts', render: () => null }, { preserveFocus: true });
+                        return undefined;
+                    },
+                },
+            ],
+        });
+        settings.state.settings.builtinsOff = [];
+        await extensions.refresh();
+        // Opened again without being put in front: the workbench is not revealed for it.
+        (0, bun_test_1.expect)(extensions.state.editors.map(editor => editor.id)).toEqual(['view:tools/terminal']);
+        (0, bun_test_1.expect)(extensions.state.focus).toBe(0);
+        (0, bun_test_1.expect)(kept.get('workbench')).toEqual({ views: ['tools/terminal'], active: 'file:a' });
+        // The tab shown before comes in front once its extension opens it again.
+        reopen === null || reopen === void 0 ? void 0 : reopen();
+        (0, bun_test_1.expect)(extensions.state.activeEditor).toBe('file:a');
+        (0, bun_test_1.expect)(extensions.state.focus).toBe(0);
+        extensions.openView('tools/explorer');
+        (0, bun_test_1.expect)(extensions.state.focus).toBe(1);
+        (0, bun_test_1.expect)(kept.get('workbench')).toEqual({ views: ['tools/terminal', 'tools/explorer'], active: 'view:tools/explorer' });
+        extensions.closeEditor('view:tools/terminal');
+        (0, bun_test_1.expect)(kept.get('workbench')).toEqual({ views: ['tools/explorer'], active: 'view:tools/explorer' });
+        // Loading again does not open again what was closed.
+        (0, bun_test_1.expect)(await extensions.refresh()).toBe(false);
+        (0, bun_test_1.expect)(extensions.state.editors.map(editor => editor.id)).toEqual(['file:a', 'view:tools/explorer']);
+    });
+    (0, bun_test_1.it)('keeps the data of a directory apart, and tells the extension only of its own', async () => {
+        const { extensions, settings } = setup();
+        const listeners = new Set();
+        const calls = [];
+        Object.assign(extensions.workbench.server, {
+            getExtensionData: async (...args) => {
+                calls.push(['get', ...args]);
+                return null;
+            },
+            setExtensionData: async (...args) => void calls.push(['set', ...args]),
+        });
+        Object.assign(extensions.workbench, {
+            onExtensionData: (listener) => {
+                listeners.add(listener);
+                return () => listeners.delete(listener);
+            },
+        });
+        const seen = [];
+        let api;
+        Object.assign(extensions, {
+            builtins: [
+                {
+                    name: 'keeper',
+                    title: 'ta.settings',
+                    description: 'ta.settings',
+                    activate: (pi) => {
+                        api = pi;
+                        pi.storage.onChange(keys => seen.push(`package:${keys}`));
+                        pi.storage.directory('/work').onChange(keys => seen.push(`/work:${keys}`));
+                        return undefined;
+                    },
+                },
+            ],
+        });
+        settings.state.settings.builtinsOff = [];
+        await extensions.refresh();
+        // None is undefined, as for any key never set.
+        (0, bun_test_1.expect)(await (api === null || api === void 0 ? void 0 : api.storage.directory('/work').get('open'))).toBeUndefined();
+        await (api === null || api === void 0 ? void 0 : api.storage.directory('/work').set('open', ['src']));
+        await (api === null || api === void 0 ? void 0 : api.storage.set('team', 1));
+        (0, bun_test_1.expect)(calls).toEqual([
+            ['get', 'keeper', 'open', '/work'],
+            ['set', 'keeper', 'open', ['src'], '/work'],
+            ['set', 'keeper', 'team', 1, undefined],
+        ]);
+        for (const listener of listeners) {
+            listener('keeper', ['open'], '/work');
+            listener('keeper', ['open'], '/else');
+            listener('keeper', ['team']);
+            listener('other', ['open'], '/work');
+        }
+        (0, bun_test_1.expect)(seen.sort()).toEqual(['/work:open', 'package:team']);
+    });
+    (0, bun_test_1.it)('tells an extension which keys of its data changed, until it unloads', async () => {
+        const { extensions, settings } = setup();
+        const listeners = new Set();
+        Object.assign(extensions.workbench, {
+            onExtensionData: (listener) => {
+                listeners.add(listener);
+                return () => listeners.delete(listener);
+            },
+        });
+        const seen = [];
+        Object.assign(extensions, {
+            builtins: [
+                {
+                    name: 'keeper',
+                    title: 'ta.settings',
+                    description: 'ta.settings',
+                    activate: (pi) => {
+                        pi.storage.onChange(keys => seen.push(keys));
+                        return undefined;
+                    },
+                },
+            ],
+        });
+        settings.state.settings.builtinsOff = [];
+        await extensions.refresh();
+        for (const listener of listeners) {
+            listener('keeper', ['team', 'messages/a']);
+            listener('other', ['team']);
+        }
+        (0, bun_test_1.expect)(seen).toEqual([['team', 'messages/a']]);
+        settings.state.settings.builtinsOff = ['keeper'];
+        await extensions.refresh();
+        (0, bun_test_1.expect)(listeners.size).toBe(0);
+    });
+});
+//# sourceMappingURL=web-extensions.spec.js.map