@celljs/ta-web 0.0.0-stage → 4.6.0

package/esm/browser/extension/web-extensions.js

@@ -0,0 +1,654 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { Autowired, Component, Optional, PostConstruct } from '@celljs/core';
+import * as React from 'react';
+import { CodeEditor } from '../components/code-editor.js';
+import { DiffEditor } from '../components/diff-editor.js';
+import { FolderPicker } from '../components/folder-picker.js';
+import { Markdown } from '../components/markdown.js';
+import { TaAvatar } from '../components/ta-avatar.js';
+import { WebComposer } from '../components/web-composer.js';
+import { WebDialog } from '../components/web-dialog.js';
+import { message as messageOf } from '../i18n/messages.js';
+import { TaNotices } from '../notices/notices-protocol.js';
+import { TaSettings } from '../settings/settings-protocol.js';
+import { StateUtil, TaState } from '../state/state-protocol.js';
+import { TaWorkbench } from '../workbench-protocol.js';
+import { WEB_ICONS } from './icons.js';
+import { BuiltinWebExtension, TaWebExtensions, WebLabelUtil, } from './web-extension-protocol.js';
+const DEFAULT_ORDER = 100;
+export var WebExtensionUtil;
+(function (WebExtensionUtil) {
+    function builtinId(name) {
+        return `builtin:${name}`;
+    }
+    WebExtensionUtil.builtinId = builtinId;
+    /** The default export of a module of source code. */
+    async function load(code) {
+        const url = URL.createObjectURL(new Blob([code], { type: 'text/javascript' }));
+        try {
+            const module = await import(/* @vite-ignore */ url);
+            if (typeof module.default !== 'function') {
+                throw new Error('A web extension exports a function as its default export.');
+            }
+            return module.default;
+        }
+        finally {
+            URL.revokeObjectURL(url);
+        }
+    }
+    WebExtensionUtil.load = load;
+    function message(error) {
+        return error instanceof Error ? error.message : String(error);
+    }
+    WebExtensionUtil.message = message;
+})(WebExtensionUtil || (WebExtensionUtil = {}));
+export var WebViewUtil;
+(function (WebViewUtil) {
+    /** The tab a `panel` view opens as. */
+    function editorId(viewId) {
+        return `view:${viewId}`;
+    }
+    WebViewUtil.editorId = editorId;
+    /** The page shown last in this tab of the browser: another tab may show another. */
+    WebViewUtil.PAGE = { key: 'page', tier: 'tab', initial: '', parse: StateUtil.string };
+    /** The tools open in the workbench, for the user in any browser: the workbench is one for the whole page. */
+    WebViewUtil.TABS = {
+        key: 'workbench',
+        tier: 'user',
+        initial: { views: [] },
+        parse: value => {
+            const kept = value;
+            if (!kept || typeof kept !== 'object' || !Array.isArray(kept.views)) {
+                return undefined;
+            }
+            const views = kept.views.filter((id) => typeof id === 'string');
+            return typeof kept.active === 'string' ? { views, active: kept.active } : { views };
+        },
+    };
+    /** What to keep of the tabs: the views open, and the one shown, or the one still to open again. */
+    function tabs(editors, active) {
+        const prefix = editorId('');
+        const views = editors.filter(editor => editor.id.startsWith(prefix)).map(editor => editor.id.slice(prefix.length));
+        return active ? { views, active } : { views };
+    }
+    WebViewUtil.tabs = tabs;
+})(WebViewUtil || (WebViewUtil = {}));
+let TaWebExtensionsImpl = class TaWebExtensionsImpl {
+    constructor() {
+        this.builtins = [];
+        this.current = {
+            extensions: [],
+            views: [],
+            widgets: [],
+            renderers: {},
+            avatars: {},
+            tools: [],
+            openers: [],
+            editors: [],
+            focus: 0,
+            page: '',
+        };
+        this.running = new Map();
+        this.listeners = new Set();
+        this.refreshing = Promise.resolve(false);
+        /** The tabs of before are open again: from now on, what is open is kept. */
+        this.restored = false;
+        /** The API of one extension: what it registers is its own and goes when it stops. */
+        /** Monaco in the theme and language of the settings, the same component for every extension. */
+        this.codeEditor = (props) => React.createElement(CodeEditor, { ...props, settings: this.settings });
+        this.diffEditor = (props) => React.createElement(DiffEditor, { ...props, settings: this.settings });
+        this.listDirectory = (directory) => this.workbench.workspace.listDirectory('.', directory);
+        /** The message box, whose button of the directory lists those of the server. */
+        this.composer = (props) => { var _a; return React.createElement(WebComposer, { ...props, notices: this.notices, listDirectory: this.listDirectory, serverCwd: (_a = this.workbench.state.server) === null || _a === void 0 ? void 0 : _a.cwd }); };
+        this.folderPicker = ({ initial, onPick, onClose }) => { var _a; return React.createElement(FolderPicker, {
+            list: this.listDirectory,
+            initial: initial || ((_a = this.workbench.state.server) === null || _a === void 0 ? void 0 : _a.cwd) || '.',
+            onPick: async (path) => onPick(path),
+            onClose,
+        }); };
+    }
+    get state() {
+        return this.current;
+    }
+    init() {
+        this.current = { ...this.current, page: this.persisted.get(WebViewUtil.PAGE) };
+    }
+    subscribe(listener) {
+        this.listeners.add(listener);
+        return () => this.listeners.delete(listener);
+    }
+    /** One at a time: a refresh while one runs follows it. */
+    refresh() {
+        const next = this.refreshing.then(() => this.reconcile(), () => this.reconcile());
+        this.refreshing = next;
+        return next;
+    }
+    async remove(id) {
+        await this.workbench.packages.removeWebExtension(id);
+        await this.refresh();
+    }
+    showEditor(id) {
+        if (this.current.editors.some(editor => editor.id === id)) {
+            this.pendingActive = undefined;
+            this.update({ activeEditor: id, focus: this.current.focus + 1 });
+            this.keepTabs();
+        }
+    }
+    openView(id, preserveFocus = false) {
+        const view = this.current.views.find(candidate => candidate.id === id && candidate.location === 'panel');
+        const run = view && this.running.get(view.extension);
+        if (view && run) {
+            this.openEditor(run, { id: WebViewUtil.editorId(view.id), title: view.title, icon: view.icon, render: view.component }, preserveFocus);
+        }
+    }
+    showPage(id) {
+        this.persisted.set(WebViewUtil.PAGE, id);
+        if (this.current.page !== id) {
+            this.update({ page: id });
+        }
+    }
+    showView(id) {
+        if (id === '') {
+            this.showPage('');
+            return;
+        }
+        const view = this.current.views.find(candidate => candidate.id === id);
+        if ((view === null || view === void 0 ? void 0 : view.location) === 'page') {
+            this.showPage(id);
+        }
+        else if ((view === null || view === void 0 ? void 0 : view.location) === 'panel') {
+            this.openView(id);
+        }
+    }
+    isShown(id) {
+        return this.current.page === id || this.current.activeEditor === WebViewUtil.editorId(id);
+    }
+    closeEditor(id) {
+        return this.closeEditors([id]);
+    }
+    async closeEditors(ids) {
+        const editors = this.current.editors.filter(candidate => ids.includes(candidate.id));
+        const dirty = editors.filter(editor => editor.dirty);
+        if (dirty.length > 0) {
+            const language = this.settings.state.language;
+            const title = dirty.length === 1
+                ? messageOf(language, 'ta.editor.unsavedTitle').replace('{title}', WebLabelUtil.text(dirty[0].title))
+                : messageOf(language, 'ta.editor.unsavedManyTitle').replace('{count}', String(dirty.length));
+            const confirmed = await this.notices.confirm({
+                title,
+                message: messageOf(language, 'ta.editor.unsavedMessage'),
+                confirmLabel: messageOf(language, 'ta.editor.discardClose'),
+                danger: true,
+            });
+            if (!confirmed) {
+                return;
+            }
+        }
+        // Those closed meanwhile are not closed twice.
+        for (const editor of editors) {
+            if (this.current.editors.includes(editor)) {
+                this.dropEditor(editor);
+            }
+        }
+    }
+    pinEditor(id) {
+        if (this.current.editors.some(editor => editor.id === id && editor.preview)) {
+            this.update({ editors: this.current.editors.map(editor => (editor.id === id ? { ...editor, preview: false } : editor)) });
+        }
+    }
+    /** Removes a tab and tells the extension that opened it. */
+    dropEditor(editor) {
+        this.removeEditors(candidate => candidate === editor);
+        const run = this.running.get(editor.extension);
+        if (editor.onClose && run) {
+            this.guard(run, editor.onClose);
+        }
+    }
+    setDirty(run, id, dirty) {
+        const found = this.current.editors.find(editor => editor.id === id && editor.extension === run.loaded.id);
+        if (found && !!found.dirty !== dirty) {
+            this.update({
+                editors: this.current.editors.map(editor => (editor === found ? { ...editor, dirty, preview: dirty ? false : editor.preview } : editor)),
+            });
+        }
+    }
+    connect(conversation) {
+        this.conversation = conversation;
+        if (this.current.cwd !== (conversation === null || conversation === void 0 ? void 0 : conversation.cwd) || this.current.sessionId !== (conversation === null || conversation === void 0 ? void 0 : conversation.sessionId)) {
+            this.update({ cwd: conversation === null || conversation === void 0 ? void 0 : conversation.cwd, sessionId: conversation === null || conversation === void 0 ? void 0 : conversation.sessionId });
+        }
+    }
+    setSessionSwitcher(switcher) {
+        this.switcher = switcher;
+    }
+    emit(event) {
+        for (const run of this.running.values()) {
+            for (const { type, handler } of run.handlers) {
+                if (type === event.type) {
+                    this.guard(run, () => handler(event));
+                }
+            }
+        }
+    }
+    async reconcile() {
+        const off = new Set(this.settings.state.settings.builtinsOff);
+        const builtins = this.builtins.filter(builtin => !off.has(builtin.name));
+        // A built-in package turned off stays in the list, for its switch in the settings.
+        const infos = (await this.workbench.packages.listWebExtensions()).filter(info => info.enabled !== false);
+        const wanted = new Map([
+            ...builtins.map(builtin => [WebExtensionUtil.builtinId(builtin.name), undefined]),
+            ...infos.map(info => [info.id, info.hash]),
+        ]);
+        let changed = false;
+        for (const [id, run] of this.running) {
+            if (!wanted.has(id) || wanted.get(id) !== run.hash) {
+                this.stop(run);
+                this.running.delete(id);
+                changed = true;
+            }
+        }
+        for (const builtin of builtins) {
+            const id = WebExtensionUtil.builtinId(builtin.name);
+            if (!this.running.has(id)) {
+                this.start({ id, name: builtin.name }, builtin.activate);
+                changed = true;
+            }
+        }
+        for (const info of infos) {
+            if (!this.running.has(info.id)) {
+                await this.startPackage(info);
+                changed = true;
+            }
+        }
+        if (changed) {
+            this.publish();
+        }
+        if (!this.restored) {
+            await this.restoreTabs();
+        }
+        return changed;
+    }
+    /** The tools open before, behind what is shown; the tab shown before, once it is open again. */
+    async restoreTabs() {
+        const kept = await this.persisted.load(WebViewUtil.TABS);
+        this.restored = true;
+        this.pendingActive = this.current.editors.some(editor => editor.id === kept.active) ? undefined : kept.active;
+        for (const id of kept.views) {
+            this.openView(id, true);
+        }
+        if (kept.active && this.current.editors.some(editor => editor.id === kept.active)) {
+            this.update({ activeEditor: kept.active });
+        }
+        this.keepTabs();
+    }
+    keepTabs() {
+        var _a;
+        if (this.restored) {
+            this.persisted.set(WebViewUtil.TABS, WebViewUtil.tabs(this.current.editors, (_a = this.pendingActive) !== null && _a !== void 0 ? _a : this.current.activeEditor));
+        }
+    }
+    async startPackage(info) {
+        const loaded = { id: info.id, name: info.name, info };
+        try {
+            const { code, hash } = await this.workbench.packages.readWebExtension(info.id);
+            this.start(loaded, await WebExtensionUtil.load(code), hash);
+        }
+        catch (error) {
+            this.running.set(info.id, { ...this.record(loaded, info.hash), loaded: { ...loaded, error: WebExtensionUtil.message(error) } });
+        }
+    }
+    start(loaded, factory, hash) {
+        const run = this.record(loaded, hash);
+        this.running.set(loaded.id, run);
+        try {
+            const dispose = factory(this.api(run));
+            run.dispose = typeof dispose === 'function' ? dispose : undefined;
+            run.started = true;
+        }
+        catch (error) {
+            this.stop(run);
+            run.loaded = { ...loaded, error: WebExtensionUtil.message(error) };
+        }
+    }
+    stop(run) {
+        run.stopped = true;
+        if (run.dispose) {
+            this.guard(run, run.dispose);
+        }
+        run.views.clear();
+        run.widgets.clear();
+        run.renderers.clear();
+        run.avatar = undefined;
+        run.tools = [];
+        run.openers = [];
+        run.handlers = [];
+        for (const unsubscribe of run.unsubscribes.splice(0)) {
+            unsubscribe();
+        }
+        this.removeEditors(editor => editor.extension === run.loaded.id);
+    }
+    openEditor(run, editor, preserveFocus = false, preview = false) {
+        if (!run.stopped) {
+            this.open({ ...editor, extension: run.loaded.id, preview }, preserveFocus);
+        }
+    }
+    open(editor, preserveFocus = false) {
+        let editors = [...this.current.editors];
+        const index = editors.findIndex(candidate => candidate.id === editor.id);
+        if (index >= 0) {
+            const open = editors[index];
+            // A tab kept stays kept; one dirty stays dirty.
+            editors[index] = { ...editor, preview: !!editor.preview && !!open.preview && !open.dirty, dirty: open.dirty };
+        }
+        else {
+            // A preview takes the place of the preview open, as a single click does in an IDE.
+            const replaced = editor.preview ? editors.find(candidate => candidate.preview && !candidate.dirty) : undefined;
+            if (replaced) {
+                editors[editors.indexOf(replaced)] = editor;
+                const run = this.running.get(replaced.extension);
+                if (replaced.onClose && run) {
+                    this.guard(run, replaced.onClose);
+                }
+            }
+            else {
+                editors = [...editors, editor];
+            }
+        }
+        if (!preserveFocus) {
+            this.pendingActive = undefined;
+            this.update({ editors, activeEditor: editor.id, focus: this.current.focus + 1 });
+        }
+        else if (editor.id === this.pendingActive || this.current.activeEditor === undefined) {
+            if (editor.id === this.pendingActive) {
+                this.pendingActive = undefined;
+            }
+            this.update({ editors, activeEditor: editor.id });
+        }
+        else {
+            this.update({ editors });
+        }
+        this.keepTabs();
+    }
+    removeEditors(match) {
+        var _a;
+        const editors = this.current.editors.filter(editor => !match(editor));
+        if (editors.length === this.current.editors.length) {
+            return;
+        }
+        const active = editors.some(editor => editor.id === this.current.activeEditor) ? this.current.activeEditor : (_a = editors[editors.length - 1]) === null || _a === void 0 ? void 0 : _a.id;
+        this.update({ editors, activeEditor: active });
+        this.keepTabs();
+    }
+    record(loaded, hash) {
+        return {
+            loaded,
+            hash,
+            started: false,
+            stopped: false,
+            views: new Map(),
+            widgets: new Map(),
+            renderers: new Map(),
+            tools: [],
+            openers: [],
+            handlers: [],
+            unsubscribes: [],
+        };
+    }
+    api(run) {
+        const { workbench, settings } = this;
+        const subscribe = (listener) => this.subscribe(listener);
+        const register = (change) => {
+            if (!run.stopped) {
+                change();
+                if (run.started) {
+                    this.publish();
+                }
+            }
+        };
+        return {
+            React,
+            get server() {
+                return workbench.server;
+            },
+            get workspace() {
+                return workbench.workspace;
+            },
+            get terminals() {
+                return workbench.terminals;
+            },
+            get packages() {
+                return workbench.packages;
+            },
+            ui: {
+                setWidget: (key, component, options = {}) => register(() => (component ? run.widgets.set(key, { component, options }) : run.widgets.delete(key))),
+                notify: (message, type = 'info') => {
+                    if (!run.stopped) {
+                        this.notices.notify(message, { level: type });
+                    }
+                },
+                confirm: (title, message, options) => (run.stopped ? Promise.resolve(false) : this.notices.confirm({ title, message, ...options })),
+                input: (title, placeholder, options) => run.stopped ? Promise.resolve(undefined) : this.notices.input({ title, placeholder, value: options === null || options === void 0 ? void 0 : options.value }),
+                editor: (title, prefill) => (run.stopped ? Promise.resolve(undefined) : this.notices.input({ title, value: prefill, multiline: true })),
+                get theme() {
+                    return settings.state.theme;
+                },
+                get language() {
+                    return settings.state.language;
+                },
+                openEditor: (editor, options) => this.openEditor(run, editor, (options === null || options === void 0 ? void 0 : options.preserveFocus) === true, (options === null || options === void 0 ? void 0 : options.preview) === true),
+                closeEditor: id => this.removeEditors(editor => editor.id === id && editor.extension === run.loaded.id),
+                pinEditor: id => {
+                    if (this.current.editors.some(editor => editor.id === id && editor.extension === run.loaded.id)) {
+                        this.pinEditor(id);
+                    }
+                },
+                setEditorDirty: (id, dirty) => this.setDirty(run, id, dirty),
+                useActiveEditor: () => {
+                    const active = () => this.current.activeEditor;
+                    return React.useSyncExternalStore(subscribe, active, active);
+                },
+                useCwd: () => {
+                    var _a;
+                    const cwd = React.useSyncExternalStore(subscribe, () => this.current.cwd);
+                    const fallback = React.useSyncExternalStore(listener => workbench.subscribe(listener), () => { var _a; return (_a = workbench.state.server) === null || _a === void 0 ? void 0 : _a.cwd; });
+                    return (_a = cwd !== null && cwd !== void 0 ? cwd : fallback) !== null && _a !== void 0 ? _a : '.';
+                },
+                useSessionId: () => React.useSyncExternalStore(subscribe, () => this.current.sessionId),
+                showView: id => !run.stopped && this.showView(id),
+                useView: id => {
+                    const find = () => this.current.views.find(candidate => candidate.id === id);
+                    const isShown = () => this.isShown(id);
+                    const view = React.useSyncExternalStore(subscribe, find, find);
+                    const shown = React.useSyncExternalStore(subscribe, isShown, isShown);
+                    // The title is read again in another language: a string, so that the same words stay the same value.
+                    const title = view ? WebLabelUtil.text(view.title) : undefined;
+                    return React.useMemo(() => (view && title !== undefined ? { title, location: view.location, shown, menu: view.menu } : undefined), [view, title, shown]);
+                },
+                Avatar: TaAvatar,
+                icons: WEB_ICONS,
+                CodeEditor: this.codeEditor,
+                DiffEditor: this.diffEditor,
+                Composer: this.composer,
+                Markdown,
+                Dialog: WebDialog,
+                FolderPicker: this.folderPicker,
+            },
+            onTerminalData: listener => {
+                if (run.stopped) {
+                    return () => undefined;
+                }
+                const unsubscribe = workbench.onTerminalData((terminalId, data, exitCode) => this.guard(run, () => listener(terminalId, data, exitCode)));
+                run.unsubscribes.push(unsubscribe);
+                return () => {
+                    unsubscribe();
+                    run.unsubscribes = run.unsubscribes.filter(other => other !== unsubscribe);
+                };
+            },
+            storage: { ...this.storage(run), directory: cwd => this.storage(run, cwd) },
+            registerView: (name, view) => register(() => run.views.set(name, view)),
+            registerMessageRenderer: (customType, renderer) => register(() => run.renderers.set(customType, renderer)),
+            registerAvatar: avatar => register(() => {
+                run.avatar = avatar;
+            }),
+            registerTool: tool => register(() => run.tools.push(tool)),
+            registerOpener: opener => register(() => run.openers.push(async (link) => {
+                // An opener that fails, or of an extension that stopped, leaves the link to the next one.
+                try {
+                    return !run.stopped && (await opener(link)) === true;
+                }
+                catch (error) {
+                    console.error(`The web extension ${run.loaded.name} failed:`, error);
+                    return false;
+                }
+            })),
+            on: (type, handler) => register(() => run.handlers.push({ type, handler: handler })),
+            sendUserMessage: async (text) => {
+                var _a;
+                if (!((_a = this.conversation) === null || _a === void 0 ? void 0 : _a.send)) {
+                    throw new Error('No conversation is shown yet.');
+                }
+                await this.conversation.send(text);
+            },
+            switchSession: async (sessionId) => {
+                if (!this.switcher) {
+                    throw new Error('The page cannot show another conversation yet.');
+                }
+                await this.switcher(sessionId);
+                this.showPage('');
+            },
+            callHost: (method, ...params) => workbench.packages.callPackageHost(run.loaded.name, method, params),
+            reloadExtensions: async () => {
+                var _a, _b;
+                await this.refresh();
+                await ((_b = (_a = this.conversation) === null || _a === void 0 ? void 0 : _a.reload) === null || _b === void 0 ? void 0 : _b.call(_a));
+            },
+        };
+    }
+    /** The data of the package of an extension on the server; of a directory with `cwd`. */
+    storage(run, cwd) {
+        const { workbench } = this;
+        const { name } = run.loaded;
+        return {
+            // JSON has no undefined: none comes as null.
+            get: async (key) => { var _a; return ((_a = (await workbench.packages.getExtensionData(name, key, cwd))) !== null && _a !== void 0 ? _a : undefined); },
+            set: (key, value) => workbench.packages.setExtensionData(name, key, value, cwd),
+            onChange: listener => {
+                if (run.stopped) {
+                    return () => undefined;
+                }
+                const unsubscribe = workbench.onExtensionData((changed, keys, directory) => {
+                    if (changed === name && directory === cwd) {
+                        this.guard(run, () => listener(keys));
+                    }
+                });
+                run.unsubscribes.push(unsubscribe);
+                return () => {
+                    unsubscribe();
+                    run.unsubscribes = run.unsubscribes.filter(other => other !== unsubscribe);
+                };
+            },
+        };
+    }
+    guard(run, action) {
+        try {
+            action();
+        }
+        catch (error) {
+            console.error(`The web extension ${run.loaded.name} failed:`, error);
+        }
+    }
+    publish() {
+        var _a;
+        const runs = [...this.running.values()];
+        const renderers = {};
+        const avatars = {};
+        const tools = [];
+        for (const run of runs) {
+            if (run.avatar) {
+                avatars[run.loaded.name] = run.avatar;
+            }
+            for (const [type, renderer] of run.renderers) {
+                (_a = renderers[type]) !== null && _a !== void 0 ? _a : (renderers[type] = renderer);
+            }
+            for (const tool of run.tools) {
+                if (!tools.some(other => other.name === tool.name)) {
+                    tools.push(tool);
+                }
+            }
+        }
+        this.update({
+            openers: runs.flatMap(run => run.openers),
+            extensions: runs.map(run => run.loaded),
+            views: runs
+                .flatMap(run => [...run.views].map(([name, view]) => { var _a; var _b, _c; return ({
+                id: `${run.loaded.name}/${name}`,
+                extension: run.loaded.id,
+                title: view.title,
+                component: view.render,
+                icon: view.icon,
+                location: (_b = view.location) !== null && _b !== void 0 ? _b : 'page',
+                order: (_c = view.order) !== null && _c !== void 0 ? _c : DEFAULT_ORDER,
+                head: view.head,
+                pages: view.pages,
+                menu: (_a = view.menu) === null || _a === void 0 ? void 0 : _a.bind(view),
+            }); }))
+                .sort((a, b) => a.order - b.order),
+            widgets: runs.flatMap(run => [...run.widgets].map(([key, { component, options }]) => { var _a; return ({
+                id: `${run.loaded.id}/${key}`,
+                extension: run.loaded.id,
+                placement: (_a = options.placement) !== null && _a !== void 0 ? _a : 'aboveEditor',
+                title: options.title,
+                component,
+            }); })),
+            renderers,
+            avatars,
+            tools,
+        });
+    }
+    update(change) {
+        this.current = { ...this.current, ...change };
+        for (const listener of this.listeners) {
+            listener(this.current);
+        }
+    }
+};
+__decorate([
+    Autowired(TaWorkbench),
+    __metadata("design:type", Object)
+], TaWebExtensionsImpl.prototype, "workbench", void 0);
+__decorate([
+    Autowired(TaSettings),
+    __metadata("design:type", Object)
+], TaWebExtensionsImpl.prototype, "settings", void 0);
+__decorate([
+    Autowired(TaNotices),
+    __metadata("design:type", Object)
+], TaWebExtensionsImpl.prototype, "notices", void 0);
+__decorate([
+    Autowired(TaState),
+    __metadata("design:type", Object)
+], TaWebExtensionsImpl.prototype, "persisted", void 0);
+__decorate([
+    Autowired(BuiltinWebExtension),
+    Optional(),
+    __metadata("design:type", Array)
+], TaWebExtensionsImpl.prototype, "builtins", void 0);
+__decorate([
+    PostConstruct(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", void 0)
+], TaWebExtensionsImpl.prototype, "init", null);
+TaWebExtensionsImpl = __decorate([
+    Component(TaWebExtensions)
+], TaWebExtensionsImpl);
+export { TaWebExtensionsImpl };
+//# sourceMappingURL=web-extensions.js.map