@esportsplus/ui 0.56.3 → 0.57.0

package/build/components/editor/code/commands.js

@@ -0,0 +1,556 @@
+import { clamp } from '../../../shared/clamp.js';
+import { floorIndex, sameSelections, selection } from './document.js';
+import { openBracket } from './folding.js';
+import { stepCharacter } from './selection.js';
+import { syntaxCache } from './syntax.js';
+const BLANK = /\s/;
+const CLOSE_BRACKETS = ')]}';
+const CLOSERS = ')]}"\'`';
+const HTML_CLOSE = /<\//;
+const HTML_OPEN = /<[\w:-]+[^>]*>$/;
+const INDENT = /^[\t ]*/;
+const LINE_BREAK = /[\r\n]/;
+const NEEDS_SPACE = /[\s)\]}>,;:]/;
+const OPENERS = '([{';
+const PAIRS = {
+    '"': '"',
+    "'": "'",
+    '(': ')',
+    '[': ']',
+    '`': '`',
+    '{': '}'
+};
+const PROTECTED = new Set(['comment', 'regexp', 'string']);
+const SPACES = /^ */;
+const WHITESPACE = /^[\t ]+$/;
+const WORD = /[\w$]/;
+function classOf(character) {
+    return BLANK.test(character) ? 0 : WORD.test(character) ? 1 : 2;
+}
+function eachRange(doc, source, run) {
+    let destinations = [], edits = [], ranges = doc.selections;
+    for (let index = 0, n = ranges.length; index < n; index++) {
+        let edit, range = ranges[index], next = range;
+        let local = {
+            eol: doc.eol,
+            replace(from, to, insert, options = {}) {
+                let length = doc.value.length + insert.length - (to - from);
+                edit = { from, insert, to };
+                next = selection(options.selection ?? { start: from + insert.length }, length);
+                return true;
+            },
+            select(value) {
+                next = selection(value, doc.value.length);
+            },
+            get selection() {
+                return next;
+            },
+            starts: doc.starts,
+            value: doc.value
+        };
+        if (!run(local, index)) {
+            return false;
+        }
+        if (edit && doc.value.slice(edit.from, edit.to) !== edit.insert) {
+            edits.push(edit);
+        }
+        destinations.push({ from: edit?.from ?? range.start, range: next });
+    }
+    let sorted = [...edits].sort((a, b) => a.from - b.from);
+    if (source === 'delete') {
+        let merged = [];
+        for (let i = 0, n = sorted.length; i < n; i++) {
+            let edit = sorted[i], last = merged[merged.length - 1];
+            if (last && edit.from <= last.to) {
+                merged[merged.length - 1] = { from: last.from, insert: '', to: Math.max(last.to, edit.to) };
+            }
+            else {
+                merged.push(edit);
+            }
+        }
+        sorted = merged;
+    }
+    let shifts = [0];
+    for (let i = 0, n = sorted.length; i < n; i++) {
+        if (i && sorted[i].from < sorted[i - 1].to) {
+            return false;
+        }
+        shifts.push(shifts[i] + sorted[i].insert.length - (sorted[i].to - sorted[i].from));
+    }
+    let next = destinations.map(({ from, range }) => {
+        if (source !== 'delete') {
+            let shift = shifts[search(sorted, from, false)];
+            return { ...range, end: range.end + shift, start: range.start + shift };
+        }
+        let map = (position) => {
+            let index = search(sorted, position, true), edit = sorted[index];
+            return edit && edit.from <= position ? edit.from + shifts[index] : position + shifts[index];
+        };
+        return { ...range, end: map(range.end), start: map(range.start) };
+    });
+    if (!edits.length) {
+        let changed = !sameSelections(doc.selections, next);
+        doc.selectMany(next);
+        return source === 'bracket' && changed;
+    }
+    return doc.transact(sorted, {
+        group: source === 'input' ? 'insertText' : undefined,
+        selections: next,
+        source
+    }).changed;
+}
+function groupsOf(lines) {
+    let groups = [];
+    for (let i = 0, n = lines.length; i < n; i++) {
+        let group = groups[groups.length - 1];
+        if (group && group[group.length - 1] === lines[i] - 1) {
+            group.push(lines[i]);
+        }
+        else {
+            groups.push([lines[i]]);
+        }
+    }
+    return groups;
+}
+function lineStart(doc, offset) {
+    return doc.starts[floorIndex(doc.starts, offset)];
+}
+function linesForSelections(doc) {
+    let lines = new Set(), ranges = doc.selections;
+    for (let i = 0, n = ranges.length; i < n; i++) {
+        let range = ranges[i], first = doc.lineAt(range.start), last = doc.lineAt(range.end);
+        if (range.end > range.start && doc.lineStart(last) === range.end) {
+            last--;
+        }
+        for (let line = first; line <= last; line++) {
+            lines.add(line);
+        }
+    }
+    return [...lines].sort((a, b) => a - b);
+}
+function protectedAt(doc, language, offset) {
+    if (language === 'plain') {
+        return false;
+    }
+    let token = syntaxCache(doc, language).tokenAt(offset);
+    return !!token && PROTECTED.has(token.kind);
+}
+function search(edits, position, inclusive) {
+    let hi = edits.length, lo = 0;
+    while (lo < hi) {
+        let mid = (lo + hi) >>> 1;
+        if ((inclusive ? edits[mid].to : edits[mid].from) < position) {
+            lo = mid + 1;
+        }
+        else {
+            hi = mid;
+        }
+    }
+    return lo;
+}
+function singleBracket(doc, character) {
+    let { direction, end, start } = doc.selection, after = doc.value[end] ?? '', before = doc.value[start - 1] ?? '', close = PAIRS[character];
+    if (start === end && CLOSERS.includes(character) && after === character && before !== '\\') {
+        doc.select({ end: start + 1, start: start + 1 });
+        return true;
+    }
+    if (!close || before === '\\') {
+        return false;
+    }
+    if (start === end && (('"\'`'.includes(character) && WORD.test(before)) || (after && !NEEDS_SPACE.test(after)))) {
+        return false;
+    }
+    doc.replace(start, end, character + doc.value.slice(start, end) + close, {
+        selection: { direction, end: end + 1, start: start + 1 },
+        source: 'bracket'
+    });
+    return true;
+}
+function singleDeletePair(doc) {
+    let { end, start } = doc.selection, close = PAIRS[doc.value[start - 1]];
+    if (start !== end || !close || close !== doc.value[start]) {
+        return false;
+    }
+    return doc.replace(start - 1, start + 1, '', { selection: { start: start - 1 }, source: 'deletePair' });
+}
+function singleInsertText(doc, text, source = 'insert') {
+    let { end, start } = doc.selection, caret = start + text.length;
+    return doc.replace(start, end, text, { selection: { end: caret, start: caret }, source });
+}
+function singleNewline(doc, unit, language) {
+    let { end, start } = doc.selection, prefix = doc.value.slice(lineStart(doc, start), start), padding = INDENT.exec(prefix)[0], left = prefix.trimEnd().at(-1) ?? '', opens = (left !== '' && OPENERS.includes(left)) ||
+        (language === 'python' && left === ':') ||
+        (language === 'html' && HTML_OPEN.test(prefix) && !HTML_CLOSE.test(prefix)), close = PAIRS[left], inner = padding + (opens ? unit : ''), text = doc.eol + inner;
+    if (opens && close && doc.value.startsWith(close, end)) {
+        text += doc.eol + padding;
+    }
+    let caret = start + doc.eol.length + inner.length;
+    return doc.replace(start, end, text, { selection: { end: caret, start: caret }, source: 'newline' });
+}
+function wordEnd(text, offset) {
+    if (offset >= text.length) {
+        return offset;
+    }
+    let kind = classOf(text[offset]);
+    while (offset < text.length && classOf(text[offset]) === kind) {
+        offset++;
+    }
+    return offset;
+}
+function wordStart(text, offset) {
+    if (offset <= 0) {
+        return offset;
+    }
+    let kind = classOf(text[offset - 1]);
+    while (offset > 0 && classOf(text[offset - 1]) === kind) {
+        offset--;
+    }
+    return offset;
+}
+const addNextOccurrence = (doc, all = false) => {
+    let primary = doc.selection, text = doc.value.slice(primary.start, primary.end), value = doc.value;
+    if (!text) {
+        let end = primary.end, start = primary.start;
+        while (start > 0 && WORD.test(value[start - 1])) {
+            start--;
+        }
+        while (end < value.length && WORD.test(value[end])) {
+            end++;
+        }
+        if (start === primary.start && end === primary.end) {
+            return false;
+        }
+        doc.select({ end, start });
+        return true;
+    }
+    let found = [...doc.selections], offset = all ? 0 : Math.max(...found.map((range) => range.end)), wrapped = false;
+    while (found.length < 1000) {
+        let at = value.indexOf(text, offset);
+        if (at < 0) {
+            if (all || wrapped) {
+                break;
+            }
+            offset = 0;
+            wrapped = true;
+            continue;
+        }
+        if (wrapped && at >= primary.start) {
+            break;
+        }
+        if (!found.some((range) => at < range.end && at + text.length > range.start)) {
+            found.push({ direction: 'none', end: at + text.length, start: at });
+            if (!all) {
+                break;
+            }
+        }
+        offset = at + Math.max(1, text.length);
+    }
+    doc.selectMany(found);
+    return true;
+};
+const bracket = (doc, character, language = 'plain') => {
+    if (!PAIRS[character] && !CLOSERS.includes(character)) {
+        return false;
+    }
+    return eachRange(doc, 'bracket', (local) => {
+        let closer = CLOSERS.includes(character) && local.value[local.selection.end] === character;
+        return (((closer || !protectedAt(doc, language, local.selection.start)) && singleBracket(local, character)) ||
+            (doc.selections.length > 1 && singleInsertText(local, character, 'bracket')));
+    });
+};
+const closeIndent = (doc, character, language) => {
+    if (character.length !== 1 || !CLOSE_BRACKETS.includes(character)) {
+        return false;
+    }
+    let cache = language === 'plain' ? null : syntaxCache(doc, language);
+    return eachRange(doc, 'closeIndent', (local) => {
+        let { end, start } = local.selection, from = lineStart(local, start), prefix = local.value.slice(from, start);
+        if (start !== end || !WHITESPACE.test(prefix) || !cache || cache.tokenAt(start)) {
+            return false;
+        }
+        let open = openBracket(cache, start);
+        if (!open || PAIRS[open.name] !== character) {
+            return false;
+        }
+        let padding = INDENT.exec(local.value.slice(lineStart(local, open.from), open.from))[0];
+        return local.replace(from, start, padding + character, { selection: { start: from + padding.length + 1 } });
+    });
+};
+const deleteCharacter = (doc, backwards = true, word = false) => {
+    return eachRange(doc, 'delete', (local) => {
+        let { end, start } = local.selection;
+        if (start === end) {
+            if (word) {
+                if (backwards) {
+                    start = wordStart(local.value, start);
+                }
+                else {
+                    end = wordEnd(local.value, end);
+                }
+            }
+            else if (backwards) {
+                start = stepCharacter(local.value, start, true);
+            }
+            else {
+                end = stepCharacter(local.value, end);
+            }
+        }
+        if (start === end) {
+            return true;
+        }
+        return local.replace(start, end, '', { selection: { start }, source: 'delete' });
+    });
+};
+const deletePair = (doc) => {
+    return eachRange(doc, 'deletePair', singleDeletePair);
+};
+const detectIndent = (text) => {
+    let counts = [], previous = 0, spaces = 0, tabs = 0;
+    for (let at = 0, line = 0, n = text.length; at < n && line < 2000; line++) {
+        let next = text.indexOf('\n', at), stop = next === -1 ? n : next, width = 0;
+        while (at + width < stop && text.charCodeAt(at + width) === 32) {
+            width++;
+        }
+        let code = text.charCodeAt(at + width);
+        if (at + width < stop && code !== 13) {
+            if (code === 9 && width === 0) {
+                tabs++;
+            }
+            else if (code !== 42) {
+                if (width) {
+                    spaces++;
+                }
+                let step = Math.abs(width - previous);
+                if (step > 0 && step <= 8) {
+                    counts[step] = (counts[step] ?? 0) + 1;
+                }
+                previous = width;
+            }
+        }
+        at = stop + 1;
+    }
+    if (tabs > spaces) {
+        return { size: 0, tabs: true };
+    }
+    if (!spaces) {
+        return null;
+    }
+    let size = 0;
+    for (let step = 1; step < counts.length; step++) {
+        if ((counts[step] ?? 0) > (counts[size] ?? 0)) {
+            size = step;
+        }
+    }
+    return size ? { size, tabs: false } : null;
+};
+const indent = (doc, unit = '    ', outdent = false) => {
+    if (!WHITESPACE.test(unit)) {
+        return false;
+    }
+    if (!outdent && doc.selections.every((range) => range.start === range.end)) {
+        return insertText(doc, unit, 'indent');
+    }
+    let edits = linesForSelections(doc).map((line) => {
+        let from = doc.lineStart(line), text = doc.lineText(line), count = 0;
+        if (outdent) {
+            count = text.startsWith('\t') ? 1 : Math.min(SPACES.exec(text)[0].length, unit === '\t' ? 4 : unit.length);
+        }
+        return { from, insert: outdent ? '' : unit, to: from + count };
+    });
+    return doc.transact(edits, { source: outdent ? 'outdent' : 'indent' }).changed;
+};
+const insertText = (doc, text, source = 'insert') => {
+    return eachRange(doc, source, (local, index) => singleInsertText(local, typeof text === 'string' ? text : (text[index % text.length] ?? ''), source));
+};
+const lineCommand = (doc, command) => {
+    let groups = groupsOf(linesForSelections(doc)), first = Math.max(0, groups[0][0] - 1), last = Math.min(doc.lineCount - 1, groups[groups.length - 1].at(-1) + 1), endings = [], rows = [], selected = new Set(groups.flat());
+    for (let line = first; line <= last; line++) {
+        rows.push({ id: line, text: doc.lineText(line) });
+        if (line < last) {
+            endings.push(doc.value.slice(doc.lineEnd(line), doc.lineStart(line + 1)));
+        }
+    }
+    for (let i = groups.length - 1; i >= 0; i--) {
+        let group = groups[i], from = group[0] - first, to = group[group.length - 1] - first;
+        switch (command) {
+            case 'blank':
+                rows.splice(to + 1, 0, { id: -1, text: '' });
+                break;
+            case 'copyDown':
+            case 'copyUp':
+                rows.splice(command === 'copyUp' ? from : to + 1, 0, ...rows.slice(from, to + 1).map((row) => ({ ...row })));
+                break;
+            case 'delete':
+                rows.splice(from, to - from + 1);
+                break;
+            case 'moveDown':
+                if (to + 1 < rows.length) {
+                    rows.splice(from, 0, rows.splice(to + 1, 1)[0]);
+                }
+                break;
+            case 'moveUp':
+                if (group[0] > 0) {
+                    rows.splice(to, 0, rows.splice(from - 1, 1)[0]);
+                }
+                break;
+        }
+    }
+    if (!rows.length) {
+        rows = [{ id: -1, text: '' }];
+    }
+    let begin = doc.lineStart(first), finish = doc.lineEnd(last), starts = [], value = '';
+    for (let i = 0, n = rows.length; i < n; i++) {
+        starts.push(value.length);
+        value += rows[i].text;
+        if (i < n - 1) {
+            value += endings[i] ?? doc.eol;
+        }
+    }
+    let delta = value.length - (finish - begin);
+    let map = (offset) => {
+        if (offset < begin) {
+            return offset;
+        }
+        if (offset > finish) {
+            return offset + delta;
+        }
+        let position = doc.position(offset), id = position.line - 1, index = command === 'copyDown'
+            ? rows.findLastIndex((row) => row.id === id)
+            : rows.findIndex((row) => row.id === id);
+        if (index < 0) {
+            index = Math.min(Math.max(0, id - first), rows.length - 1);
+        }
+        if (command === 'blank' && selected.has(id)) {
+            let blank = rows.findIndex((row, i) => row.id === id && rows[i + 1]?.id === -1);
+            if (blank >= 0) {
+                return begin + starts[blank + 1];
+            }
+        }
+        return begin + starts[index] + Math.min(position.column - 1, rows[index].text.length);
+    };
+    let end = begin + value.length, from = begin, ranges = doc.selections.map((range) => ({
+        direction: range.direction,
+        end: map(range.end),
+        start: map(range.start)
+    })), source = doc.value, to = finish;
+    while (from < Math.min(to, end) && source[from] === value[from - begin]) {
+        from++;
+    }
+    while (to > from && end > from && source[to - 1] === value[end - 1 - begin]) {
+        to--;
+        end--;
+    }
+    return doc.transact([{ from, insert: value.slice(from - begin, end - begin), to }], {
+        selections: ranges,
+        source: command
+    }).changed;
+};
+const newline = (doc, unit = '    ', language = 'plain') => {
+    return eachRange(doc, 'newline', (local) => {
+        if (!protectedAt(doc, language, local.selection.start)) {
+            return singleNewline(local, unit, language);
+        }
+        let start = local.selection.start, padding = INDENT.exec(local.value.slice(lineStart(local, start), start))[0];
+        return singleInsertText(local, local.eol + padding, 'newline');
+    });
+};
+const reindent = (doc, language, unit = '    ') => {
+    let cache = language === 'plain' ? null : syntaxCache(doc, language), depth = 0, edits = [], selected = new Set(linesForSelections(doc));
+    for (let index = 0, n = doc.lineCount; index < n; index++) {
+        let closing = -1, k = 0, start = depth, text = doc.lineText(index), tokens = cache ? cache.lineTokens(index) : [];
+        for (let i = 0, m = text.length; i < m; i++) {
+            while (k < tokens.length && tokens[k].to <= i) {
+                k++;
+            }
+            if (tokens[k] && tokens[k].from <= i && PROTECTED.has(tokens[k].kind)) {
+                continue;
+            }
+            let character = text[i], close = CLOSE_BRACKETS.includes(character);
+            if (closing < 0 && !BLANK.test(character)) {
+                closing = close ? 1 : 0;
+            }
+            if (OPENERS.includes(character)) {
+                depth++;
+            }
+            else if (close) {
+                depth = Math.max(0, depth - 1);
+            }
+        }
+        if (selected.has(index) && text.trim()) {
+            let from = doc.lineStart(index);
+            edits.push({
+                from,
+                insert: unit.repeat(clamp(start - Math.max(0, closing), 0, 100)),
+                to: from + INDENT.exec(text)[0].length
+            });
+        }
+    }
+    return doc.transact(edits, { source: 'reindent' }).changed;
+};
+const selectLine = (doc) => {
+    doc.selectMany(doc.selections.map((range) => {
+        let last = doc.lineAt(range.end);
+        return {
+            end: last + 1 < doc.lineCount ? doc.lineStart(last + 1) : doc.value.length,
+            start: doc.lineStart(doc.lineAt(range.start))
+        };
+    }));
+};
+const toggleComment = (doc, marker, block) => {
+    let edits = [], lines = linesForSelections(doc);
+    if (marker) {
+        let candidates = [];
+        for (let i = 0, n = lines.length; i < n; i++) {
+            let text = doc.lineText(lines[i]), padding = INDENT.exec(text)[0].length;
+            if (text.trim()) {
+                candidates.push({ from: doc.lineStart(lines[i]) + padding, text: text.slice(padding) });
+            }
+        }
+        let remove = candidates.length > 0 && candidates.every((line) => line.text.startsWith(marker));
+        for (let i = 0, n = candidates.length; i < n; i++) {
+            let { from, text } = candidates[i];
+            edits.push({
+                from,
+                insert: remove ? '' : marker + ' ',
+                to: from + (remove ? marker.length + (text[marker.length] === ' ' ? 1 : 0) : 0)
+            });
+        }
+    }
+    else {
+        if (!block?.[0] || !block[1]) {
+            return false;
+        }
+        let [open, close] = block, groups = groupsOf(lines);
+        for (let i = 0, n = groups.length; i < n; i++) {
+            let from = doc.lineStart(groups[i][0]), to = doc.lineEnd(groups[i][groups[i].length - 1]), text = doc.value.slice(from, to);
+            if (text.startsWith(open) && text.endsWith(close) && text.length >= open.length + close.length) {
+                edits.push({ from, insert: '', to: from + open.length }, { from: to - close.length, insert: '', to });
+            }
+            else {
+                edits.push({ from, insert: open, to: from }, { from: to, insert: close, to });
+            }
+        }
+    }
+    return doc.transact(edits, { source: 'comment' }).changed;
+};
+const transpose = (doc) => {
+    return eachRange(doc, 'transpose', (local) => {
+        let { end, start } = local.selection;
+        if (start !== end || start === 0) {
+            return false;
+        }
+        let at = start === local.value.length ? stepCharacter(local.value, start, true) : start;
+        if (at === 0) {
+            return false;
+        }
+        let left = stepCharacter(local.value, at, true), right = stepCharacter(local.value, at);
+        if (LINE_BREAK.test(local.value.slice(left, right))) {
+            return false;
+        }
+        return local.replace(left, right, local.value.slice(at, right) + local.value.slice(left, at), {
+            selection: { start: right },
+            source: 'transpose'
+        });
+    });
+};
+export { addNextOccurrence, bracket, closeIndent, deleteCharacter, deletePair, detectIndent, indent, insertText, lineCommand, newline, reindent, selectLine, toggleComment, transpose };

package/build/components/editor/code/composition.d.ts

@@ -0,0 +1,23 @@
+import * as reactivity_u0 from '@esportsplus/reactivity';
+declare class ReactiveObject_1jnsvu20 extends reactivity_u0.ReactiveObject<any> {
+    #private;
+    constructor();
+    get composing(): boolean;
+    set composing(_v0: boolean);
+}
+type Handlers = {
+    begin: VoidFunction;
+    commit: (conflict: boolean) => void;
+};
+declare const composition: ({ begin, commit }: Handlers) => {
+    attributes: {
+        oncompositionend: () => void;
+        oncompositionstart: () => void;
+    };
+    busy: () => boolean;
+    conflict: () => void;
+    flush: () => void;
+    input: (e: InputEvent) => boolean;
+    state: ReactiveObject_1jnsvu20;
+};
+export { composition };

package/build/components/editor/code/composition.js

@@ -0,0 +1,67 @@
+import * as reactivity_u0 from '@esportsplus/reactivity';
+class ReactiveObject_1jnsvu20 extends reactivity_u0.ReactiveObject {
+    #composing = this[reactivity_u0.SIGNAL](false);
+    constructor() {
+        super(null);
+    }
+    get composing() {
+        return reactivity_u0.read(this.#composing);
+    }
+    set composing(_v0) {
+        reactivity_u0.write(this.#composing, _v0);
+    }
+}
+const composition = ({ begin, commit }) => {
+    let conflict = false, pending = false, state = new ReactiveObject_1jnsvu20(), timer;
+    function finish() {
+        if (state.composing || !pending) {
+            return;
+        }
+        clearTimeout(timer);
+        pending = false;
+        timer = undefined;
+        let conflicted = conflict;
+        conflict = false;
+        commit(conflicted);
+    }
+    return {
+        attributes: {
+            oncompositionend: () => {
+                pending = true;
+                state.composing = false;
+                timer = setTimeout(finish, 0);
+            },
+            oncompositionstart: () => {
+                finish();
+                begin();
+                conflict = false;
+                state.composing = true;
+            }
+        },
+        busy: () => state.composing || pending,
+        conflict: () => {
+            if (state.composing || pending) {
+                conflict = true;
+            }
+        },
+        flush: () => {
+            if (state.composing) {
+                pending = true;
+                state.composing = false;
+            }
+            finish();
+        },
+        input: (e) => {
+            if (state.composing || e.isComposing) {
+                return true;
+            }
+            if (pending) {
+                finish();
+                return true;
+            }
+            return false;
+        },
+        state
+    };
+};
+export { composition };

package/build/components/editor/code/conflicts.d.ts

@@ -0,0 +1,21 @@
+import type { Edit } from './document.js';
+type Conflict = {
+    base: string | null;
+    current: string;
+    end: number;
+    incoming: string;
+    line: number;
+    start: number;
+};
+type Block = Conflict & {
+    close: number;
+    divider: number;
+    middle: number;
+};
+type Resolution = 'both' | 'current' | 'incoming' | (string & {});
+type Tint = 'base' | 'current' | 'divider' | 'incoming';
+declare const conflictsOf: (text: string) => Block[];
+declare const resolveConflict: (text: string, conflict: Conflict, resolution: Resolution) => Edit;
+declare const tints: (blocks: readonly Block[]) => Map<number, Tint>;
+export { conflictsOf, resolveConflict, tints };
+export type { Block, Conflict, Resolution, Tint };