@esportsplus/ui 0.56.3 → 0.57.0

package/build/components/editor/tree/clipboard.d.ts

@@ -0,0 +1,12 @@
+import Selection from './selection.js';
+declare class Clipboard<T extends {
+    id: string;
+}> {
+    private held;
+    readonly marked: Selection;
+    cancel(): boolean;
+    hold(items: T[], cut: boolean): void;
+    paste(fn: (items: T[], cut: boolean) => unknown): Promise<void>;
+    retain(find: (id: string) => T | undefined): void;
+}
+export default Clipboard;

package/build/components/editor/tree/clipboard.js

@@ -0,0 +1,48 @@
+import Selection from './selection.js';
+class Clipboard {
+    held = null;
+    marked = new Selection();
+    cancel() {
+        if (!this.held?.cut) {
+            return false;
+        }
+        this.held = null;
+        this.marked.replace([]);
+        return true;
+    }
+    hold(items, cut) {
+        this.held = { cut, items };
+        this.marked.replace(cut ? items.map((item) => item.id) : []);
+    }
+    async paste(fn) {
+        let held = this.held;
+        if (!held) {
+            return;
+        }
+        await fn(held.items, held.cut);
+        if (held.cut && this.held === held) {
+            this.held = null;
+            this.marked.replace([]);
+        }
+    }
+    retain(find) {
+        let held = this.held;
+        if (!held) {
+            return;
+        }
+        let items = [];
+        for (let i = 0, n = held.items.length; i < n; i++) {
+            let item = find(held.items[i].id);
+            if (item !== undefined) {
+                items.push(item);
+            }
+        }
+        if (items.length === held.items.length) {
+            held.items = items;
+            return;
+        }
+        this.held = items.length ? { cut: held.cut, items } : null;
+        this.marked.replace(this.held?.cut ? items.map((item) => item.id) : []);
+    }
+}
+export default Clipboard;

package/build/components/editor/tree/compact.d.ts

@@ -0,0 +1,23 @@
+import { type Attributes, type Renderable } from '@esportsplus/template';
+import type { FileTreeElement as Element } from './index.js';
+type Node<T> = {
+    element: Element;
+    host?: T;
+    id: string;
+    parent: T | null;
+    segments?: T[];
+};
+type Segment<T> = HTMLElement & {
+    [SEGMENT]: T;
+};
+declare const SEGMENT: unique symbol;
+declare function ancestors<T extends Node<T>>(row: T): T[];
+declare function caption<T extends Node<T>>(row: T): string;
+declare function holds<T extends Node<T>>(row: T, test: (id: string) => boolean): boolean;
+declare function lineage<T extends Node<T>>(row: T): T[];
+declare function same<T extends Node<T>>(a: T[] | undefined, b: T[] | undefined): boolean;
+declare function sole(element: Element, hidden: Set<string>, folder: (element: Element) => boolean): Element | null;
+export default _default;
+declare function _default<T extends Node<T>>(row: T, part: (node: T) => Attributes[], name: (node: T) => Renderable<unknown>): DocumentFragment | Text;
+export { ancestors, caption, holds, lineage, same, SEGMENT, sole };
+export type { Segment };

package/build/components/editor/tree/compact.js

@@ -0,0 +1,57 @@
+import * as template_u1 from '@esportsplus/template';
+const template_05h7g901 = template_u1.template(`<span class='file-tree-name'>`);
+const template_05h7g904 = template_u1.template(`<!--$--><span class='file-tree-segment'>`);
+const template_05h7g907 = template_u1.template(`<span aria-hidden='true' class='file-tree-separator'>/`);
+const SEGMENT = Symbol();
+function ancestors(row) {
+    let out = lineage(row).slice(0, -1);
+    for (let node = (row.host ?? row).parent; node; node = node.parent) {
+        out.unshift(...lineage(node));
+    }
+    return out;
+}
+function caption(row) {
+    return row.segments ? lineage(row).map((node) => node.element.name).join('/') : row.element.name;
+}
+function holds(row, test) {
+    return test(row.id) || !!row.segments?.some((node) => test(node.id));
+}
+function lineage(row) {
+    let host = row.host ?? row, out = host.segments ? [...host.segments, host] : [host];
+    return out.slice(0, out.indexOf(row) + 1);
+}
+function same(a, b) {
+    if (!a || !b) {
+        return a === b;
+    }
+    return a.length === b.length && a.every((node, i) => node.element === b[i].element);
+}
+function sole(element, hidden, folder) {
+    let children = element.children, only = null;
+    if (!children || element.selectable === false) {
+        return null;
+    }
+    for (let i = 0, n = children.length; i < n; i++) {
+        if (hidden.has(children[i].id)) {
+            continue;
+        }
+        if (only) {
+            return null;
+        }
+        only = children[i];
+    }
+    return only && folder(only) && only.selectable !== false ? only : null;
+}
+export default (row, part, name) => {
+    let root_05h7g900 = template_05h7g901(), element_05h7g902 = root_05h7g900.firstChild;
+    template_u1.slot(element_05h7g902, lineage(row).map((node, i) => {
+        let root_05h7g903 = template_05h7g904(), element_05h7g905 = root_05h7g903.firstChild, element_05h7g906 = element_05h7g905.nextSibling;
+        template_u1.slot(element_05h7g905, i > 0 && template_05h7g907());
+        template_u1.slot(element_05h7g906, name(node), 1);
+        template_u1.setProperties(element_05h7g906, part(node));
+        template_u1.onconnect(element_05h7g906, (element) => { element[SEGMENT] = node; });
+        return root_05h7g903;
+    }), 1);
+    return root_05h7g900;
+};
+export { ancestors, caption, holds, lineage, same, SEGMENT, sole };

package/build/components/editor/tree/decorations.d.ts

@@ -0,0 +1,39 @@
+type Badge = {
+    color?: string;
+    text: string;
+    tooltip?: string;
+};
+type Decoration = {
+    additions?: number;
+    badges?: Badge[];
+    deletions?: number;
+    editor?: Editor;
+    errors?: number;
+    staged?: Status;
+    status?: Status;
+    submodule?: boolean;
+    warnings?: number;
+};
+type Editor = {
+    open?: boolean;
+    unsaved?: boolean;
+};
+type Listener = (ids: string[]) => void;
+type Source = Pick<Decorations, 'get' | 'keys' | 'subscribe'>;
+type Status = 'added' | 'conflict' | 'deleted' | 'ignored' | 'modified' | 'renamed' | 'untracked';
+type Tone = 'added' | 'conflict' | 'deleted' | 'error' | 'ignored' | 'modified' | 'warning';
+declare function merge(stores: Decorations[]): Source;
+declare class Decorations {
+    private listeners;
+    private values;
+    private notify;
+    private write;
+    get(id: string): Decoration | undefined;
+    keys(): MapIterator<string>;
+    replace(entries: Iterable<[string, Decoration]>): void;
+    subscribe(listener: Listener): () => void;
+    update(entries: Iterable<[string, Decoration | null]>): void;
+}
+export default Decorations;
+export { merge };
+export type { Badge, Decoration, Editor, Source, Status, Tone };

package/build/components/editor/tree/decorations.js

@@ -0,0 +1,126 @@
+function equal(a, b) {
+    return a === b || (a !== undefined &&
+        b !== undefined &&
+        (a.additions ?? 0) === (b.additions ?? 0) &&
+        same(a.badges ?? [], b.badges ?? []) &&
+        (a.deletions ?? 0) === (b.deletions ?? 0) &&
+        !!a.editor?.open === !!b.editor?.open &&
+        !!a.editor?.unsaved === !!b.editor?.unsaved &&
+        (a.errors ?? 0) === (b.errors ?? 0) &&
+        a.staged === b.staged &&
+        a.status === b.status &&
+        !!a.submodule === !!b.submodule &&
+        (a.warnings ?? 0) === (b.warnings ?? 0));
+}
+function merge(stores) {
+    if (stores.length === 1) {
+        return stores[0];
+    }
+    return {
+        get(id) {
+            let out;
+            for (let i = 0, n = stores.length; i < n; i++) {
+                let decoration = stores[i].get(id);
+                if (!decoration) {
+                    continue;
+                }
+                if (!out) {
+                    out = decoration;
+                    continue;
+                }
+                out = {
+                    ...out,
+                    ...decoration,
+                    badges: out.badges && decoration.badges ? [...out.badges, ...decoration.badges] : (decoration.badges ?? out.badges)
+                };
+            }
+            return out;
+        },
+        keys() {
+            return new Set(stores.flatMap((store) => [...store.keys()])).values();
+        },
+        subscribe(listener) {
+            let unsubscribe = stores.map((store) => store.subscribe(listener));
+            return () => {
+                for (let i = 0, n = unsubscribe.length; i < n; i++) {
+                    unsubscribe[i]();
+                }
+            };
+        }
+    };
+}
+function same(a, b) {
+    if (a.length !== b.length) {
+        return false;
+    }
+    for (let i = 0, n = a.length; i < n; i++) {
+        if (a[i].color !== b[i].color || a[i].text !== b[i].text || a[i].tooltip !== b[i].tooltip) {
+            return false;
+        }
+    }
+    return true;
+}
+class Decorations {
+    listeners = [];
+    values = new Map();
+    notify(ids) {
+        if (!ids.length) {
+            return;
+        }
+        for (let i = 0, n = this.listeners.length; i < n; i++) {
+            this.listeners[i](ids);
+        }
+    }
+    write(id, decoration, changed) {
+        let previous = this.values.get(id);
+        if (decoration === null) {
+            if (previous !== undefined) {
+                this.values.delete(id);
+                changed.push(id);
+            }
+            return;
+        }
+        if (!equal(previous, decoration)) {
+            this.values.set(id, decoration);
+            changed.push(id);
+        }
+    }
+    get(id) {
+        return this.values.get(id);
+    }
+    keys() {
+        return this.values.keys();
+    }
+    replace(entries) {
+        let changed = [], seen = new Set();
+        for (let [id, decoration] of entries) {
+            seen.add(id);
+            this.write(id, decoration, changed);
+        }
+        for (let id of this.values.keys()) {
+            if (!seen.has(id)) {
+                this.values.delete(id);
+                changed.push(id);
+            }
+        }
+        this.notify(changed);
+    }
+    subscribe(listener) {
+        this.listeners.push(listener);
+        return () => {
+            let i = this.listeners.indexOf(listener);
+            if (i !== -1) {
+                this.listeners.splice(i, 1);
+            }
+        };
+    }
+    update(entries) {
+        let changed = [];
+        for (let [id, decoration] of entries) {
+            this.write(id, decoration, changed);
+        }
+        this.notify(changed);
+    }
+}
+export default Decorations;
+export { merge };

package/build/components/editor/tree/drag.d.ts

@@ -0,0 +1,45 @@
+import { type Signal } from '@esportsplus/reactivity';
+import { type Attributes } from '@esportsplus/template';
+import { type Export, type ImportEntry } from './transfer.js';
+type Drag<E> = {
+    confirm?: (drop: Drop<E>) => boolean | Promise<boolean>;
+    drop: (drop: Drop<E>) => void;
+};
+type Drop<E> = {
+    copy: boolean;
+    elements: E[];
+    target: E | null;
+};
+type Handlers<E> = {
+    drag?: Drag<E>;
+    export?: (element: E) => Export | null;
+    import?: (target: E | null, entries: readonly ImportEntry[]) => void | Promise<void>;
+};
+type Row<T> = {
+    depth: number;
+    element: {
+        name: string;
+    };
+    key: number;
+    locked: boolean;
+    open: Signal<boolean> | null;
+    parent: T | null;
+};
+type Tree<T> = {
+    grab: (row: T) => T[];
+    host: (row: T) => T;
+    last: (row: T) => T;
+    open: (row: T) => void;
+    row: (element: HTMLElement) => T | undefined;
+    top: boolean;
+    viewport: () => HTMLElement | undefined;
+};
+export default _default;
+declare function _default<T extends Row<T>>({ drag, export: give, import: take }: Handlers<T['element']>, tree: Tree<T>): {
+    ghost: DocumentFragment | Text;
+    root: Attributes;
+    row: (row: T) => Attributes;
+    segment: (row: T) => Attributes;
+    viewport: Attributes;
+};
+export type { Drag, Drop, Handlers };