@esportsplus/ui 0.57.0 → 0.58.0

package/build/components/editor/workspace/keybindings.d.ts

@@ -0,0 +1,37 @@
+import { type Command } from '../code/keymap.js';
+type KeybindingRow = {
+    builtin: string[];
+    chords: string[];
+    id: Command;
+    label: string;
+    user: boolean;
+};
+type Keybindings = Readonly<Record<string, Command | null>>;
+type SequenceKey = Pick<KeyboardEvent, 'altKey' | 'code' | 'ctrlKey' | 'isComposing' | 'key' | 'metaKey' | 'preventDefault' | 'shiftKey' | 'stopPropagation' | 'target'>;
+type SequenceOptions = {
+    accept: (e: SequenceKey) => boolean;
+    actions: Readonly<Record<string, VoidFunction>>;
+    apple: boolean;
+    onpending?: (pending: boolean) => void;
+    prefix: string;
+    timeout?: number;
+};
+declare const bind: (keybindings: Keybindings, apple: boolean, command: Command, keys: string) => Keybindings;
+declare const conflict: (keybindings: Keybindings, apple: boolean, command: Command, keys: string) => Command | null;
+declare const declare: (existing: string | null | undefined, keys: string) => string;
+declare const fromChord: (keys: string, apple: boolean) => string;
+declare const fromRecorder: (value: string, apple: boolean) => string | null;
+declare const label: (keys: string, apple: boolean) => string;
+declare const matches: (row: KeybindingRow, query: string, apple: boolean) => boolean;
+declare const merge: (base: Keybindings | undefined, user: Keybindings) => Readonly<Record<string, Command | null>>;
+declare const reset: (keybindings: Keybindings, apple: boolean, command: Command) => Keybindings;
+declare const rows: (keybindings: Keybindings, apple: boolean) => KeybindingRow[];
+declare const sanitize: (value: unknown) => Keybindings;
+declare const sequence: ({ accept, actions, apple, onpending, prefix, timeout }: SequenceOptions) => {
+    cancel: () => void;
+    keydown: (e: SequenceKey) => void;
+    pending: () => boolean;
+};
+declare const unassign: (keybindings: Keybindings, apple: boolean, command: Command) => Keybindings;
+export { bind, conflict, declare, fromChord, fromRecorder, label, matches, merge, reset, rows, sanitize, sequence, unassign };
+export type { KeybindingRow, Keybindings, SequenceKey, SequenceOptions };

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

@@ -0,0 +1,288 @@
+import { chord, combo, COMMANDS } from '../code/keymap.js';
+const APPLE_ORDER = ['Ctrl', 'Alt', 'Shift', 'Mod'];
+const ARROWS = {
+    ArrowDown: '↓',
+    ArrowLeft: '←',
+    ArrowRight: '→',
+    ArrowUp: '↑'
+};
+const BUILTIN = [
+    ['Alt+Backspace', 'deleteWordBackward', true],
+    ['Alt+Delete', 'deleteWordForward', true],
+    ['Alt+`', 'autocomplete', true],
+    ['Alt+i', 'autocomplete', true],
+    ['Alt+v', 'pageUp', true],
+    ['ArrowDown', 'moveDown'],
+    ['ArrowLeft', 'moveLeft'],
+    ['ArrowRight', 'moveRight'],
+    ['ArrowUp', 'moveUp'],
+    ['Backspace', 'deleteCharacterBackward'],
+    ['Ctrl+a', 'lineStart', true],
+    ['Ctrl+Alt+d', 'deleteWordForward', true],
+    ['Ctrl+Alt+h', 'deleteWordBackward', true],
+    ['Ctrl+b', 'moveLeft', true],
+    ['Ctrl+d', 'deleteCharacterForward', true],
+    ['Ctrl+e', 'lineEnd', true],
+    ['Ctrl+f', 'moveRight', true],
+    ['Ctrl+h', 'deleteCharacterBackward', true],
+    ['Ctrl+k', 'deleteLineEnd', true],
+    ['Ctrl+n', 'moveDown', true],
+    ['Ctrl+o', 'splitLine', true],
+    ['Ctrl+p', 'moveUp', true],
+    ['Ctrl+t', 'transpose', true],
+    ['Ctrl+v', 'pageDown', true],
+    ['Delete', 'deleteCharacterForward'],
+    ['End', 'lineEnd'],
+    ['Home', 'lineStart'],
+    ['Mod+ArrowLeft', 'lineStart', true],
+    ['Mod+ArrowRight', 'lineEnd', true],
+    ['Mod+Backspace', 'deleteWordBackward', false],
+    ['Mod+Delete', 'deleteWordForward', false],
+    ['Mod+Space', 'autocomplete'],
+    ['PageDown', 'pageDown'],
+    ['PageUp', 'pageUp']
+];
+const GLYPHS = {
+    Alt: '⌥',
+    Ctrl: '⌃',
+    Mod: '⌘',
+    Shift: '⇧'
+};
+const IDS = new Set(COMMANDS.map((command) => command.id));
+const MODIFIER_KEYS = new Set(['Alt', 'AltGraph', 'Control', 'Meta', 'OS', 'Shift']);
+const ORDER = ['Mod', 'Ctrl', 'Meta', 'Alt', 'Shift'];
+const SEQUENCE_TIMEOUT = 1500;
+const SHIFTED = {
+    '?': '/',
+    '{': '[',
+    '|': '\\',
+    '}': ']',
+    '~': '`'
+};
+const TOKEN = /[^+]+|\+/g;
+function builtins(apple) {
+    let map = new Map();
+    for (let i = 0, n = BUILTIN.length; i < n; i++) {
+        let [keys, command, platform] = BUILTIN[i], normalized = chord(keys, apple);
+        if (normalized && (platform === undefined || platform === apple)) {
+            map.set(normalized, command);
+        }
+    }
+    return map;
+}
+function defaults(apple) {
+    let map = new Map();
+    for (let i = 0, n = COMMANDS.length; i < n; i++) {
+        let { id, keys } = COMMANDS[i];
+        for (let j = 0, m = keys.length; j < m; j++) {
+            let normalized = chord(keys[j], apple);
+            if (normalized) {
+                map.set(normalized, id);
+            }
+        }
+    }
+    return map;
+}
+function normalize(keybindings, apple) {
+    let out = {};
+    for (let keys in keybindings) {
+        let command = keybindings[keys], normalized = chord(keys, apple);
+        if (normalized && (command === null || IDS.has(command))) {
+            out[normalized] = command;
+        }
+    }
+    return out;
+}
+function simplify(keybindings, base) {
+    for (let keys in keybindings) {
+        if (keybindings[keys] === (base.get(keys) ?? null)) {
+            delete keybindings[keys];
+        }
+    }
+    return keybindings;
+}
+function split(keys) {
+    return (keys.match(TOKEN) ?? []).filter((_, i) => i % 2 === 0);
+}
+function table(keybindings, apple) {
+    let map = new Map(defaults(apple)), user = normalize(keybindings, apple);
+    for (let keys in user) {
+        map.set(keys, user[keys]);
+    }
+    return map;
+}
+function unbind(keybindings, base, current, command) {
+    for (let [keys, owner] of current) {
+        if (owner !== command) {
+            continue;
+        }
+        if (base.has(keys)) {
+            keybindings[keys] = null;
+        }
+        else {
+            delete keybindings[keys];
+        }
+    }
+}
+const bind = (keybindings, apple, command, keys) => {
+    let base = defaults(apple), normalized = chord(keys, apple), next = normalize(keybindings, apple);
+    if (!normalized) {
+        return keybindings;
+    }
+    unbind(next, base, table(keybindings, apple), command);
+    next[normalized] = command;
+    return simplify(next, base);
+};
+const conflict = (keybindings, apple, command, keys) => {
+    let normalized = chord(keys, apple);
+    if (!normalized) {
+        return null;
+    }
+    let current = table(keybindings, apple), owner = current.has(normalized) ? current.get(normalized) : builtins(apple).get(normalized);
+    return owner && owner !== command ? owner : null;
+};
+const declare = (existing, keys) => {
+    let tokens = (existing ?? '').split(/\s+/).filter(Boolean), names = split(fromChord(keys, false));
+    for (let mod of ['Control', 'Meta']) {
+        let token = names.map((name) => (name === 'Mod' ? mod : name)).join('+');
+        if (!tokens.some((other) => other.toLowerCase() === token.toLowerCase())) {
+            tokens.push(token);
+        }
+    }
+    return tokens.join(' ');
+};
+const fromChord = (keys, apple) => {
+    let tokens = split(keys), key = tokens.pop() ?? '', order = apple ? APPLE_ORDER : ORDER;
+    if (key === ' ') {
+        key = 'Space';
+    }
+    else if (key === 'Enter') {
+        key = '↵';
+    }
+    else {
+        key = ARROWS[key] ?? (key.length === 1 ? key.toUpperCase() : key);
+    }
+    return [...order.filter((name) => tokens.includes(name)), key].join('+');
+};
+const fromRecorder = (value, apple) => {
+    let tokens = split(value), key = tokens.pop();
+    if (!key) {
+        return null;
+    }
+    for (let name in ARROWS) {
+        if (ARROWS[name] === key) {
+            key = name;
+        }
+    }
+    if (key === '↵') {
+        key = 'Enter';
+    }
+    return chord([...tokens, SHIFTED[key] ?? key].join('+'), apple);
+};
+const label = (keys, apple) => {
+    let tokens = fromChord(keys, apple).split(/\+(?!$)/);
+    if (!apple) {
+        return tokens.map((token) => (token === 'Mod' ? 'Ctrl' : token)).join('+');
+    }
+    return tokens.map((token) => GLYPHS[token] ?? token).join('');
+};
+const matches = (row, query, apple) => {
+    let needle = query.trim().toLowerCase();
+    if (!needle) {
+        return true;
+    }
+    if (row.label.toLowerCase().includes(needle) || row.id.toLowerCase().includes(needle)) {
+        return true;
+    }
+    for (let keys of [...row.chords, ...row.builtin]) {
+        for (let text of [keys, fromChord(keys, apple), label(keys, apple)]) {
+            if (text.toLowerCase().includes(needle)) {
+                return true;
+            }
+        }
+    }
+    return false;
+};
+const merge = (base, user) => {
+    if (!base) {
+        return user;
+    }
+    return { ...base, ...user };
+};
+const reset = (keybindings, apple, command) => {
+    let base = defaults(apple), next = normalize(keybindings, apple);
+    for (let keys in next) {
+        if (next[keys] === command || (next[keys] === null && base.get(keys) === command)) {
+            delete next[keys];
+        }
+    }
+    return next;
+};
+const rows = (keybindings, apple) => {
+    let base = defaults(apple), current = table(keybindings, apple), native = [...builtins(apple)], user = normalize(keybindings, apple), changed = new Set();
+    for (let keys in user) {
+        let before = base.get(keys), after = user[keys];
+        if (before && before !== after) {
+            changed.add(before);
+        }
+        if (after && after !== before) {
+            changed.add(after);
+        }
+    }
+    return COMMANDS.map(({ id, label }) => ({
+        builtin: native.filter(([keys, command]) => command === id && !current.get(keys)).map(([keys]) => keys),
+        chords: [...current].filter(([, command]) => command === id).map(([keys]) => keys),
+        id,
+        label,
+        user: changed.has(id)
+    }));
+};
+const sanitize = (value) => {
+    let out = {};
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        return out;
+    }
+    for (let [keys, command] of Object.entries(value)) {
+        if (chord(keys, false) && (command === null || (typeof command === 'string' && IDS.has(command)))) {
+            out[keys] = command;
+        }
+    }
+    return out;
+};
+const sequence = ({ accept, actions, apple, onpending, prefix, timeout = SEQUENCE_TIMEOUT }) => {
+    let timer;
+    function cancel() {
+        if (timer === undefined) {
+            return;
+        }
+        clearTimeout(timer);
+        timer = undefined;
+        onpending?.(false);
+    }
+    function keydown(e) {
+        if (e.isComposing || MODIFIER_KEYS.has(e.key)) {
+            return;
+        }
+        let keys = combo(e, apple);
+        if (timer !== undefined) {
+            e.preventDefault();
+            e.stopPropagation();
+            cancel();
+            actions[keys]?.();
+            return;
+        }
+        if (keys === prefix && accept(e)) {
+            e.preventDefault();
+            e.stopPropagation();
+            timer = setTimeout(cancel, timeout);
+            onpending?.(true);
+        }
+    }
+    return { cancel, keydown, pending: () => timer !== undefined };
+};
+const unassign = (keybindings, apple, command) => {
+    let base = defaults(apple), next = normalize(keybindings, apple);
+    unbind(next, base, table(keybindings, apple), command);
+    return simplify(next, base);
+};
+export { bind, conflict, declare, fromChord, fromRecorder, label, matches, merge, reset, rows, sanitize, sequence, unassign };

package/build/components/editor/workspace/model.d.ts

@@ -1,4 +1,6 @@
+import type { Command } from '../code/keymap.js';
 import { EditorDocument } from '../code/document.js';
+import type { FileTreeExport, FileTreeImportEntry } from '../tree/index.js';
 type WorkspaceAction = {
     danger?: boolean;
     icon?: string;
@@ -10,6 +12,11 @@ type WorkspaceAction = {
 type WorkspaceChange = {
     paths?: readonly string[];
 };
+type WorkspaceCompare = Readonly<{
+    modified: string;
+    original: string;
+    paths: readonly [string, string];
+}>;
 type WorkspaceConfirmation = {
     dirty: readonly string[];
     kind: 'close' | 'delete' | 'workspace';
@@ -22,11 +29,14 @@ type WorkspaceEntry = Readonly<{
 }>;
 type WorkspaceHost = {
     actions?: readonly WorkspaceAction[];
+    baseline?: (cwd: string, path: string) => Promise<string | null>;
     confirm?: (request: WorkspaceConfirmation) => WorkspaceDecision | Promise<WorkspaceDecision>;
     copyPath(cwd: string, path: string): void | Promise<void>;
     delete(cwd: string, paths: readonly string[]): Promise<{
         operationId: string;
     }>;
+    export?: (cwd: string, path: string) => FileTreeExport | null;
+    import?: (cwd: string, target: string, entries: readonly FileTreeImportEntry[]) => Promise<void>;
     list(cwd: string): Promise<readonly WorkspaceEntry[]>;
     preferences?: {
         get(): Promise<Partial<WorkspacePreferences>>;
@@ -36,16 +46,46 @@ type WorkspaceHost = {
     rename(cwd: string, source: string, destination: string): Promise<{
         operationId: string;
     }>;
+    session?: {
+        get(): Promise<WorkspaceSession | null>;
+        set(session: WorkspaceSession): Promise<void>;
+    };
     undo(cwd: string, operationId: string): Promise<void>;
     watch(cwd: string, changed: (event: WorkspaceChange) => void): VoidFunction | Promise<VoidFunction>;
     write(cwd: string, path: string, content: string): Promise<void>;
 };
 type WorkspacePreferences = {
+    autoSave: 'delay' | 'focus' | 'off';
+    autoSaveDelay: number;
     explorerOpen: boolean;
     explorerSide: 'left' | 'right';
+    keybindings: Readonly<Record<string, Command | null>>;
     showWhitespace: boolean;
     wrapText: boolean;
 };
+type WorkspaceSession = {
+    active: string | null;
+    explorer: {
+        expanded: string[];
+        scroll: number;
+    };
+    tabs: WorkspaceSessionTab[];
+};
+type WorkspaceSessionTab = {
+    draft?: string;
+    folds: number[];
+    path: string;
+    pinned: boolean;
+    preview: boolean;
+    scroll: {
+        left: number;
+        top: number;
+    };
+    selection: {
+        anchor: number;
+        head: number;
+    };
+};
 type WorkspaceState = Readonly<{
     active: WorkspaceTab | undefined;
     busy: number;
@@ -69,10 +109,13 @@ type WorkspaceState = Readonly<{
     tabs: readonly WorkspaceTab[];
 }>;
 type WorkspaceTab = {
+    readonly compare?: WorkspaceCompare;
     readonly document: EditorDocument;
     readonly id: number;
     missing: boolean;
     path: string;
+    pinned: boolean;
+    preview: boolean;
     saved: string;
     scroll: {
         left: number;
@@ -127,22 +170,31 @@ declare class EditorWorkspaceModel {
     private tabId;
     private tabs;
     private unwatch;
+    private watchers;
     private watchWork;
     constructor(host: WorkspaceHost, cwd?: string, preferences?: Partial<WorkspacePreferences>);
     private applyPreferences;
     private authorize;
+    private closeTabs;
     private desire;
     private emit;
     private queue;
     private removeTab;
     get state(): WorkspaceState;
     activate(tab: WorkspaceTab | string): void;
+    adopt(path: string, content: string, saved: string, missing?: boolean): WorkspaceTab | undefined;
     close(path?: string | undefined): Promise<boolean>;
+    closeOthers(path?: string | undefined): Promise<boolean>;
+    closeRight(path?: string | undefined): Promise<boolean>;
+    closeSaved(): Promise<boolean>;
+    compare(original: string, modified: string): Promise<WorkspaceTab | undefined>;
     copyPath(path: string): Promise<void>;
     delete(paths: readonly string[]): Promise<boolean | undefined>;
     dispose(): void;
-    open(value: string, line?: number, column?: number): Promise<WorkspaceTab | undefined>;
+    onWatch(listener: (event: WorkspaceChange) => void): () => void;
+    open(value: string, line?: number, column?: number, preview?: boolean): Promise<WorkspaceTab | undefined>;
     openTarget(target?: WorkspaceTarget): Promise<WorkspaceTab | undefined>;
+    pin(path: string, pinned?: boolean): void;
     refresh(_paths?: readonly string[]): Promise<void>;
     rename(source: string, destination: string): Promise<boolean | undefined>;
     run(action: WorkspaceAction, paths: readonly string[]): Promise<void>;
@@ -155,7 +207,8 @@ declare class EditorWorkspaceModel {
     stop(): void;
     subscribe(listener: (state: WorkspaceState) => void): () => void;
     undoFiles(): Promise<boolean | undefined>;
+    unpin(path: string): void;
     whenIdle(): Promise<void>;
 }
 export { containsPath, DEFAULTS, dirty, EditorWorkspaceModel, workspacePath };
-export type { WorkspaceAction, WorkspaceChange, WorkspaceConfirmation, WorkspaceDecision, WorkspaceEntry, WorkspaceHost, WorkspacePreferences, WorkspaceState, WorkspaceTab, WorkspaceTarget };
+export type { WorkspaceAction, WorkspaceChange, WorkspaceCompare, WorkspaceConfirmation, WorkspaceDecision, WorkspaceEntry, WorkspaceHost, WorkspacePreferences, WorkspaceSession, WorkspaceSessionTab, WorkspaceState, WorkspaceTab, WorkspaceTarget };