@esportsplus/ui 0.56.4 → 0.57.0

package/build/components/editor/workspace/model.js

@@ -0,0 +1,690 @@
+import { EditorDocument } from '../code/document.js';
+const DEFAULTS = {
+    explorerOpen: true,
+    explorerSide: 'right',
+    showWhitespace: false,
+    wrapText: false
+};
+const ERROR_PREFIX = /^Workspace: /;
+function message(error) {
+    return (error instanceof Error ? error.message : String(error)).replace(ERROR_PREFIX, '');
+}
+function workspacePath(value, cwd = '') {
+    let base = cwd.replace(/\\/g, '/').replace(/\/+$/, ''), path = value.replace(/\\/g, '/');
+    if (/^(?:[a-z]:|\/)/i.test(path)) {
+        let windows = /^[a-z]:/i.test(base), a = windows ? path.toLowerCase() : path, b = windows ? base.toLowerCase() : base;
+        if (!base || !a.startsWith(`${b}/`)) {
+            throw new Error('Workspace: path is outside this workspace');
+        }
+        path = path.slice(base.length + 1);
+    }
+    let parts = path.replace(/\/+$/, '').split('/');
+    if (!parts.length || parts.some((part) => !part || part === '.' || part === '..' || /[\x00-\x1f]/.test(part))) {
+        throw new Error('Workspace: a valid workspace-relative path is required');
+    }
+    return parts.join('/');
+}
+const containsPath = (parent, path) => path === parent || path.startsWith(`${parent}/`);
+const dirty = (tab) => tab.document.value !== tab.saved;
+class EditorWorkspaceModel {
+    host;
+    active;
+    busy = 0;
+    closed = new Map();
+    confirm;
+    cwd;
+    dirty = new Map();
+    disposed = false;
+    documents = new Map();
+    entries = [];
+    epoch = 0;
+    error = '';
+    history = [];
+    lastTarget;
+    listeners = new Set();
+    loaded = false;
+    loading = false;
+    mutation = 0;
+    openIntent = 0;
+    opening = new Map();
+    operations = Promise.resolve();
+    overlay = new Map();
+    preferenceRevision = 0;
+    preferences = { ...DEFAULTS };
+    preferenceWrite = Promise.resolve();
+    refreshIntent = 0;
+    requestedPath = '';
+    revealed;
+    revealRequest = 0;
+    revision = 0;
+    running = false;
+    starting;
+    statusKind = 'info';
+    statusText = '';
+    tabId = 0;
+    tabs = [];
+    unwatch;
+    watchWork = Promise.resolve();
+    constructor(host, cwd = '', preferences = {}) {
+        this.cwd = cwd;
+        this.host = host;
+        this.applyPreferences(preferences);
+    }
+    applyPreferences(preferences) {
+        for (let key of ['explorerOpen', 'showWhitespace', 'wrapText']) {
+            if (typeof preferences[key] === 'boolean') {
+                this.preferences[key] = preferences[key];
+            }
+        }
+        if (preferences.explorerSide === 'left' || preferences.explorerSide === 'right') {
+            this.preferences.explorerSide = preferences.explorerSide;
+        }
+    }
+    async authorize(kind, tabs, paths) {
+        let changed = tabs.filter(dirty), revisions = new Map(tabs.map((tab) => [tab.id, tab.document.state.revision]));
+        if (!changed.length) {
+            return revisions;
+        }
+        let confirm = this.host.confirm ?? this.confirm;
+        if (!confirm) {
+            this.status('Unsaved changes require confirmation.', true);
+            return;
+        }
+        let decision;
+        try {
+            decision = await confirm({ dirty: changed.map((tab) => tab.path), kind, paths });
+        }
+        catch (error) {
+            this.status(`Confirmation failed: ${message(error)}`, true);
+            return;
+        }
+        if (decision === 'cancel') {
+            return;
+        }
+        if (decision === 'save') {
+            for (let tab of changed) {
+                if (!(await this.save(tab)) || dirty(tab)) {
+                    this.status('Changes made during saving remain open.', true);
+                    return;
+                }
+            }
+        }
+        for (let tab of tabs) {
+            if (tab.document.state.revision !== revisions.get(tab.id)) {
+                this.status('The draft changed while confirmation was open; try again.', true);
+                return;
+            }
+        }
+        return revisions;
+    }
+    desire(before, after) {
+        for (let entry of before) {
+            this.overlay.set(entry.path, null);
+        }
+        for (let entry of after) {
+            this.overlay.set(entry.path, entry);
+        }
+        let removed = new Set(before.map((entry) => entry.path));
+        this.entries = [...this.entries.filter((entry) => !removed.has(entry.path)), ...after];
+        this.mutation++;
+        this.emit();
+    }
+    emit() {
+        if (this.disposed) {
+            return;
+        }
+        this.revision++;
+        for (let i = 0, n = this.tabs.length; i < n; i++) {
+            this.dirty.set(this.tabs[i].id, dirty(this.tabs[i]));
+        }
+        let state = this.state;
+        for (let listener of [...this.listeners]) {
+            listener(state);
+        }
+    }
+    queue(label, task) {
+        let epoch = this.epoch, result = this.operations.then(async () => {
+            if (this.disposed || epoch !== this.epoch) {
+                return undefined;
+            }
+            this.busy++;
+            this.emit();
+            try {
+                return await task();
+            }
+            catch (error) {
+                if (epoch === this.epoch) {
+                    this.status(`${label} failed: ${message(error)}`, true);
+                }
+                return undefined;
+            }
+            finally {
+                this.busy--;
+                this.emit();
+            }
+        });
+        this.operations = result.then(() => undefined);
+        return result;
+    }
+    removeTab(tab) {
+        let at = this.tabs.indexOf(tab);
+        if (at < 0) {
+            return;
+        }
+        this.tabs.splice(at, 1);
+        this.documents.get(tab.id)?.();
+        this.documents.delete(tab.id);
+        this.dirty.delete(tab.id);
+        if (this.active === tab.id) {
+            this.active = (this.tabs[at] ?? this.tabs[at - 1])?.id;
+        }
+    }
+    get state() {
+        let active;
+        for (let i = 0, n = this.tabs.length; i < n; i++) {
+            if (this.tabs[i].id === this.active) {
+                active = this.tabs[i];
+                break;
+            }
+        }
+        return {
+            active,
+            busy: this.busy,
+            canUndoFiles: this.history.length > 0,
+            cwd: this.cwd,
+            entries: this.entries,
+            error: this.error,
+            loaded: this.loaded,
+            loading: this.loading,
+            opening: [...this.opening.keys()],
+            preferences: this.preferences,
+            reveal: this.revealed,
+            revision: this.revision,
+            status: this.statusText,
+            statusKind: this.statusKind,
+            tabs: this.tabs
+        };
+    }
+    activate(tab) {
+        let found = typeof tab === 'string' ? this.tabs.find((item) => item.path === tab) : tab;
+        if (!found || !this.tabs.includes(found)) {
+            return;
+        }
+        this.openIntent++;
+        this.requestedPath = found.path;
+        this.active = found.id;
+        this.emit();
+    }
+    async close(path = this.state.active?.path) {
+        if (!path) {
+            return false;
+        }
+        this.closed.set(path, (this.closed.get(path) ?? 0) + 1);
+        let tab = this.tabs.find((tab) => tab.path === path);
+        if (!tab) {
+            return true;
+        }
+        if (!(await this.authorize('close', [tab], [path]))) {
+            return false;
+        }
+        this.removeTab(tab);
+        this.emit();
+        return true;
+    }
+    async copyPath(path) {
+        try {
+            await this.host.copyPath(this.cwd, workspacePath(path, this.cwd));
+            this.status('Path copied');
+        }
+        catch (error) {
+            this.status(`Copy Path failed: ${message(error)}`, true);
+        }
+    }
+    async delete(paths) {
+        let normalized;
+        try {
+            normalized = [...new Set(paths.map((path) => workspacePath(path, this.cwd)))];
+        }
+        catch (error) {
+            this.status(`Delete failed: ${message(error)}`, true);
+            return false;
+        }
+        if (!normalized.length) {
+            return false;
+        }
+        let tabs = this.tabs.filter((tab) => normalized.some((path) => containsPath(path, tab.path))), revisions = await this.authorize('delete', tabs, normalized);
+        if (!revisions) {
+            return false;
+        }
+        return this.queue('Delete', async () => {
+            let before = this.entries.filter((entry) => normalized.some((path) => containsPath(path, entry.path))), epoch = this.epoch;
+            this.mutation++;
+            let result = await this.host.delete(this.cwd, normalized);
+            if (epoch !== this.epoch) {
+                return false;
+            }
+            this.history.push({ after: [], before, id: result.operationId, kind: 'delete' });
+            this.desire(before, []);
+            for (let tab of this.tabs.slice()) {
+                if (!normalized.some((path) => containsPath(path, tab.path))) {
+                    continue;
+                }
+                if (tab.document.state.revision === revisions.get(tab.id)) {
+                    this.removeTab(tab);
+                }
+                else {
+                    tab.missing = true;
+                }
+            }
+            this.status(`Deleted ${normalized.length === 1 ? normalized[0] : `${normalized.length} paths`}`);
+            await this.refresh();
+            return true;
+        });
+    }
+    dispose() {
+        if (this.disposed) {
+            return;
+        }
+        this.stop();
+        this.disposed = true;
+        for (let stop of this.documents.values()) {
+            stop();
+        }
+        this.documents.clear();
+        this.listeners.clear();
+    }
+    async open(value, line, column = 1) {
+        if (this.disposed) {
+            return;
+        }
+        let path;
+        try {
+            path = workspacePath(value, this.cwd);
+        }
+        catch (error) {
+            this.status(`Open failed: ${message(error)}`, true);
+            return;
+        }
+        let cwd = this.cwd, epoch = this.epoch, intent = ++this.openIntent;
+        this.requestedPath = path;
+        let existing = this.tabs.find((tab) => tab.path === path), pending = this.opening.get(path);
+        if (!existing && !pending) {
+            let closed = this.closed.get(path) ?? 0;
+            pending = (async () => {
+                try {
+                    let content = await this.host.read(cwd, path);
+                    if (epoch !== this.epoch || this.disposed || closed !== (this.closed.get(path) ?? 0) || this.overlay.get(path) === null) {
+                        return;
+                    }
+                    let tab = {
+                        document: new EditorDocument(content),
+                        id: ++this.tabId,
+                        missing: false,
+                        path,
+                        saved: content,
+                        scroll: { left: 0, top: 0 }
+                    };
+                    this.tabs.push(tab);
+                    this.documents.set(tab.id, tab.document.subscribe((_, change) => {
+                        if (change.textChanged && dirty(tab) !== this.dirty.get(tab.id)) {
+                            this.emit();
+                        }
+                    }));
+                    return tab;
+                }
+                catch (error) {
+                    if (epoch === this.epoch && this.requestedPath === path && closed === (this.closed.get(path) ?? 0)) {
+                        this.status(`Open failed: ${message(error)}`, true);
+                    }
+                }
+                finally {
+                    if (epoch === this.epoch) {
+                        this.opening.delete(path);
+                        this.emit();
+                    }
+                }
+            })();
+            this.opening.set(path, pending);
+            this.emit();
+        }
+        let tab = existing ?? (await pending);
+        if (!tab || epoch !== this.epoch || !this.tabs.includes(tab)) {
+            return;
+        }
+        if (intent === this.openIntent) {
+            this.active = tab.id;
+            if (line !== undefined) {
+                let safeColumn = Number.isFinite(column) ? Math.max(1, Math.trunc(column)) : 1, safeLine = Number.isFinite(line) ? Math.max(1, Math.trunc(line)) : 1, offset = tab.document.offset(safeLine, safeColumn);
+                tab.document.select({ end: offset, start: offset });
+                this.revealed = { column: safeColumn, line: safeLine, request: ++this.revealRequest, tabId: tab.id };
+            }
+            this.statusText = '';
+            this.statusKind = 'info';
+            this.emit();
+        }
+        return tab;
+    }
+    async openTarget(target) {
+        if (!target || !target.path || (target.requestId !== undefined && target.requestId === this.lastTarget)) {
+            return;
+        }
+        this.lastTarget = target.requestId;
+        return this.open(target.path, target.line, target.column);
+    }
+    async refresh(_paths) {
+        if (this.disposed || !this.cwd) {
+            return;
+        }
+        let cwd = this.cwd, epoch = this.epoch, intent = ++this.refreshIntent, mutation = this.mutation;
+        this.loading = true;
+        this.emit();
+        try {
+            let listed = await this.host.list(cwd);
+            if (epoch !== this.epoch || intent !== this.refreshIntent || mutation !== this.mutation) {
+                return;
+            }
+            let entries = new Map();
+            for (let i = 0, n = listed.length; i < n; i++) {
+                let path = workspacePath(listed[i].path, cwd);
+                entries.set(path, { kind: listed[i].kind, path });
+            }
+            for (let [path, desired] of this.overlay) {
+                let found = entries.get(path);
+                if (desired ? found?.kind === desired.kind : !found) {
+                    this.overlay.delete(path);
+                }
+                else if (desired) {
+                    entries.set(path, desired);
+                }
+                else {
+                    entries.delete(path);
+                }
+            }
+            this.entries = [...entries.values()];
+            this.error = '';
+            this.loaded = true;
+            this.loading = false;
+            this.emit();
+            for (let tab of [...this.tabs]) {
+                if (epoch !== this.epoch || intent !== this.refreshIntent || mutation !== this.mutation) {
+                    return;
+                }
+                tab.missing = !entries.has(tab.path);
+                if (dirty(tab) || tab.missing) {
+                    this.emit();
+                    continue;
+                }
+                let path = tab.path, revision = tab.document.state.revision;
+                try {
+                    let content = await this.host.read(cwd, path);
+                    if (epoch !== this.epoch ||
+                        intent !== this.refreshIntent ||
+                        mutation !== this.mutation ||
+                        !this.tabs.includes(tab) ||
+                        tab.path !== path ||
+                        dirty(tab) ||
+                        tab.document.state.revision !== revision) {
+                        continue;
+                    }
+                    tab.saved = content;
+                    if (content !== tab.document.value) {
+                        tab.document.reset(content, tab.document.selection);
+                    }
+                    this.emit();
+                }
+                catch (error) {
+                    if (epoch === this.epoch && this.tabs.includes(tab)) {
+                        this.status(`Refresh failed for ${path}: ${message(error)}`, true);
+                    }
+                }
+            }
+        }
+        catch (error) {
+            if (epoch === this.epoch && intent === this.refreshIntent) {
+                this.error = message(error);
+                this.emit();
+            }
+        }
+        finally {
+            if (epoch === this.epoch && intent === this.refreshIntent) {
+                this.loading = false;
+                this.emit();
+            }
+        }
+    }
+    rename(source, destination) {
+        return this.queue('Rename', async () => {
+            let epoch = this.epoch, from = workspacePath(source, this.cwd), to = workspacePath(destination, this.cwd);
+            if (from === to) {
+                return true;
+            }
+            if (containsPath(from, to)) {
+                throw new Error('Workspace: cannot move a directory inside itself');
+            }
+            if (this.entries.some((entry) => entry.path === to)) {
+                throw new Error('Workspace: destination already exists');
+            }
+            let before = this.entries.filter((entry) => containsPath(from, entry.path));
+            if (!before.length) {
+                throw new Error('Workspace: source does not exist');
+            }
+            this.mutation++;
+            let result = await this.host.rename(this.cwd, from, to);
+            if (epoch !== this.epoch) {
+                return false;
+            }
+            let after = before.map((entry) => ({ ...entry, path: to + entry.path.slice(from.length) }));
+            this.history.push({ after, before, destination: to, id: result.operationId, kind: 'rename', source: from });
+            for (let tab of this.tabs) {
+                if (containsPath(from, tab.path)) {
+                    tab.path = to + tab.path.slice(from.length);
+                }
+            }
+            this.desire(before, after);
+            this.status(`Renamed ${from}`);
+            await this.refresh();
+            return true;
+        });
+    }
+    async run(action, paths) {
+        try {
+            await action.run(this.cwd, paths.map((path) => workspacePath(path, this.cwd)));
+        }
+        catch (error) {
+            this.status(`${action.label} failed: ${message(error)}`, true);
+        }
+    }
+    save(tab = this.state.active) {
+        return this.queue('Save', async () => {
+            if (!tab || !this.tabs.includes(tab)) {
+                return false;
+            }
+            if (!dirty(tab) && !tab.missing) {
+                return true;
+            }
+            let content = tab.document.value, epoch = this.epoch, path = tab.path;
+            this.mutation++;
+            await this.host.write(this.cwd, path, content);
+            if (epoch !== this.epoch || !this.tabs.includes(tab) || tab.path !== path) {
+                return false;
+            }
+            tab.missing = false;
+            tab.saved = content;
+            if (tab.document.value === content) {
+                tab.document.markSaved();
+            }
+            let entry = { kind: 'file', path };
+            this.overlay.set(path, entry);
+            if (!this.entries.some((item) => item.path === path)) {
+                this.entries = [...this.entries, entry];
+            }
+            this.mutation++;
+            this.status(`Saved ${path}`);
+            await this.refresh();
+            return true;
+        });
+    }
+    setConfirmation(confirm) {
+        this.confirm = confirm;
+    }
+    setPreferences(preferences) {
+        this.preferences = { ...this.preferences };
+        this.applyPreferences(preferences);
+        this.preferenceRevision++;
+        this.emit();
+        let epoch = this.epoch, snapshot = { ...this.preferences };
+        this.preferenceWrite = this.preferenceWrite.then(async () => {
+            if (this.disposed) {
+                return;
+            }
+            try {
+                await this.host.preferences?.set(snapshot);
+            }
+            catch (error) {
+                if (epoch === this.epoch) {
+                    this.status(`Could not save editor preferences: ${message(error)}`, true);
+                }
+            }
+        });
+    }
+    async setWorkspace(cwd) {
+        if (cwd === this.cwd) {
+            return true;
+        }
+        if (!(await this.authorize('workspace', this.tabs, this.tabs.map((tab) => tab.path)))) {
+            return false;
+        }
+        this.stop();
+        for (let tab of this.tabs.slice()) {
+            this.removeTab(tab);
+        }
+        this.closed.clear();
+        this.cwd = cwd;
+        this.entries = [];
+        this.error = '';
+        this.history = [];
+        this.lastTarget = undefined;
+        this.loaded = false;
+        this.overlay.clear();
+        this.revealed = undefined;
+        this.statusText = '';
+        this.emit();
+        await this.start();
+        return true;
+    }
+    async start() {
+        if (this.disposed) {
+            return;
+        }
+        if (this.running) {
+            return this.starting;
+        }
+        this.running = true;
+        let epoch = ++this.epoch, revision = this.preferenceRevision;
+        this.starting = (async () => {
+            if (!this.cwd) {
+                this.error = 'No workspace open.';
+                this.emit();
+                return;
+            }
+            let preferences = (async () => {
+                try {
+                    await this.preferenceWrite;
+                    let result = await this.host.preferences?.get();
+                    if (epoch === this.epoch && result && revision === this.preferenceRevision) {
+                        this.preferences = { ...this.preferences };
+                        this.applyPreferences(result);
+                        this.emit();
+                    }
+                }
+                catch (error) {
+                    if (epoch === this.epoch) {
+                        this.status(`Could not load editor preferences: ${message(error)}`, true);
+                    }
+                }
+            })();
+            try {
+                let stop = await this.host.watch(this.cwd, (event) => {
+                    if (epoch === this.epoch) {
+                        this.watchWork = this.refresh(event.paths);
+                    }
+                });
+                if (epoch !== this.epoch) {
+                    stop();
+                }
+                else {
+                    this.unwatch = stop;
+                }
+            }
+            catch (error) {
+                if (epoch === this.epoch) {
+                    this.status(`Watch failed: ${message(error)}`, true);
+                }
+            }
+            if (epoch === this.epoch) {
+                await this.refresh();
+            }
+            await preferences;
+        })();
+        return this.starting;
+    }
+    status(text, error = false) {
+        this.statusText = text;
+        this.statusKind = error ? 'error' : 'info';
+        this.emit();
+    }
+    stop() {
+        this.unwatch?.();
+        this.unwatch = undefined;
+        this.epoch++;
+        this.loading = false;
+        this.openIntent++;
+        this.opening.clear();
+        this.refreshIntent++;
+        this.running = false;
+        this.emit();
+    }
+    subscribe(listener) {
+        this.listeners.add(listener);
+        return () => {
+            this.listeners.delete(listener);
+        };
+    }
+    undoFiles() {
+        return this.queue('Undo', async () => {
+            let epoch = this.epoch, operation = this.history.at(-1);
+            if (!operation) {
+                return false;
+            }
+            this.mutation++;
+            await this.host.undo(this.cwd, operation.id);
+            if (epoch !== this.epoch) {
+                return false;
+            }
+            this.history.pop();
+            if (operation.kind === 'rename') {
+                for (let tab of this.tabs) {
+                    if (containsPath(operation.destination, tab.path)) {
+                        tab.path = operation.source + tab.path.slice(operation.destination.length);
+                    }
+                }
+            }
+            this.desire(operation.after, operation.before);
+            this.status(operation.kind === 'delete' ? 'Restored deleted files' : `Restored ${operation.source}`);
+            await this.refresh();
+            return true;
+        });
+    }
+    async whenIdle() {
+        for (;;) {
+            let operations = this.operations, preferences = this.preferenceWrite, watch = this.watchWork;
+            await operations;
+            await watch;
+            await preferences;
+            if (operations === this.operations && watch === this.watchWork && preferences === this.preferenceWrite) {
+                return;
+            }
+        }
+    }
+}
+export { containsPath, DEFAULTS, dirty, EditorWorkspaceModel, workspacePath };