@esportsplus/ui 0.56.3 → 0.57.0

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

@@ -0,0 +1,91 @@
+const MARKERS = ['<<<<<<<', '|||||||', '=======', '>>>>>>>'];
+function marker(line) {
+    if (line.length < 7) {
+        return -1;
+    }
+    let kind = MARKERS.indexOf(line.slice(0, 7));
+    if (kind === -1 || line.length === 7) {
+        return kind;
+    }
+    if (kind === 2) {
+        return line.slice(7).trim() ? -1 : 2;
+    }
+    let next = line.charCodeAt(7);
+    return next === 32 || next === 9 ? kind : -1;
+}
+const conflictsOf = (text) => {
+    let out = [];
+    if (text.indexOf('<<<<<<<') === -1) {
+        return out;
+    }
+    let block = { base: -1, divider: -1, dividerAt: -1, from: -1, incoming: -1, line: -1, middle: -1, middleAt: -1, start: -1 }, stage = 0;
+    for (let at = 0, line = 1, n = text.length;; line++) {
+        let newline = text.indexOf('\n', at), stop = newline === -1 ? n : newline, next = newline === -1 ? n : newline + 1, kind = marker(text.slice(at, stop > at && text.charCodeAt(stop - 1) === 13 ? stop - 1 : stop));
+        if (kind === 0) {
+            block = { base: -1, divider: -1, dividerAt: -1, from: next, incoming: -1, line, middle: -1, middleAt: -1, start: at };
+            stage = 1;
+        }
+        else if (kind === 1 && stage === 1) {
+            block.base = next;
+            block.middle = line;
+            block.middleAt = at;
+            stage = 2;
+        }
+        else if (kind === 2 && (stage === 1 || stage === 2)) {
+            block.divider = line;
+            block.dividerAt = at;
+            block.incoming = next;
+            stage = 3;
+        }
+        else if (kind === 3 && stage === 3) {
+            out.push({
+                base: block.middle === -1 ? null : text.slice(block.base, block.dividerAt),
+                close: line,
+                current: text.slice(block.from, block.middle === -1 ? block.dividerAt : block.middleAt),
+                divider: block.divider,
+                end: next,
+                incoming: text.slice(block.incoming, at),
+                line: block.line,
+                middle: block.middle,
+                start: block.start
+            });
+            stage = 0;
+        }
+        if (newline === -1) {
+            break;
+        }
+        at = next;
+    }
+    return out;
+};
+const resolveConflict = (text, conflict, resolution) => {
+    let side = resolution === 'both' || resolution === 'current' || resolution === 'incoming', insert = resolution === 'current'
+        ? conflict.current
+        : resolution === 'incoming'
+            ? conflict.incoming
+            : resolution === 'both'
+                ? conflict.current + conflict.incoming
+                : resolution;
+    if (side && conflict.end === text.length && !/[\r\n]$/.test(text)) {
+        insert = insert.replace(/(?:\r\n|\r|\n)$/, '');
+    }
+    return { from: conflict.start, insert, to: conflict.end };
+};
+const tints = (blocks) => {
+    let out = new Map();
+    for (let i = 0, n = blocks.length; i < n; i++) {
+        let block = blocks[i], base = block.middle === -1 ? block.divider : block.middle;
+        for (let line = block.line; line < base; line++) {
+            out.set(line, 'current');
+        }
+        for (let line = base; line < block.divider; line++) {
+            out.set(line, 'base');
+        }
+        out.set(block.divider, 'divider');
+        for (let line = block.divider + 1; line <= block.close; line++) {
+            out.set(line, 'incoming');
+        }
+    }
+    return out;
+};
+export { conflictsOf, resolveConflict, tints };

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

@@ -0,0 +1,127 @@
+type Change = Readonly<{
+    editBatches?: readonly (readonly Edit[])[];
+    selectionChanged: boolean;
+    source: string;
+    textChanged: boolean;
+}>;
+type Delta = Readonly<{
+    edits: readonly Edit[];
+    inserted: number;
+    line: number;
+    removed: number;
+}>;
+type Edit = Readonly<{
+    from: number;
+    insert: string;
+    to: number;
+}>;
+type History = {
+    bytes?: number;
+    limit?: number;
+};
+type Listener = (state: Snapshot, change: Change) => void;
+type Selection = Readonly<{
+    direction: 'backward' | 'forward' | 'none';
+    end: number;
+    start: number;
+}>;
+type Snapshot = Readonly<{
+    canRedo: boolean;
+    canUndo: boolean;
+    dirty: boolean;
+    lineCount: number;
+    revision: number;
+    selection: Selection;
+    selections: readonly Selection[];
+    value: string;
+}>;
+type TransactionOptions = {
+    group?: string;
+    selection?: Partial<Selection>;
+    selections?: readonly Partial<Selection>[];
+    source?: string;
+    time?: number;
+};
+type TransactionResult = Readonly<{
+    accepted: true;
+    changed: boolean;
+} | {
+    accepted: false;
+    changed: false;
+    index: number;
+    reason: 'invalid-insert' | 'invalid-range' | 'overlap';
+}>;
+declare const floorIndex: (starts: readonly number[], offset: number) => number;
+declare const lineEnd: (text: string, starts: readonly number[], index: number) => number;
+declare const lineStarts: (text: string) => number[];
+declare const preferredEol: (text: string) => string;
+declare const sameSelection: (a: Selection, b: Selection) => boolean;
+declare const sameSelections: (a: readonly Selection[], b: readonly Selection[]) => boolean;
+declare const selection: (value: Partial<Selection>, length: number) => Selection;
+declare const normalizeSelections: (ranges: readonly Partial<Selection>[], length: number) => readonly Selection[];
+declare class EditorDocument {
+    private boundary;
+    private byteLimit;
+    private bytes;
+    private dropped;
+    private future;
+    private index;
+    private limit;
+    private listeners;
+    private log;
+    private past;
+    private primary;
+    private ranges;
+    private saved;
+    private selectionFuture;
+    private selectionPast;
+    private text;
+    private version;
+    constructor(value?: string, history?: History);
+    private assign;
+    private emit;
+    private record;
+    private travel;
+    private travelSelection;
+    get eol(): "\n" | "\r" | "\r\n";
+    get lineCount(): number;
+    get revision(): number;
+    get selection(): Readonly<{
+        direction: 'backward' | 'forward' | 'none';
+        end: number;
+        start: number;
+    }>;
+    get selections(): readonly Readonly<{
+        direction: 'backward' | 'forward' | 'none';
+        end: number;
+        start: number;
+    }>[];
+    get starts(): readonly number[];
+    get state(): Snapshot;
+    get value(): string;
+    breakHistory(): void;
+    deltas(since: number): readonly Delta[] | null;
+    lineAt(offset: number): number;
+    lineEnd(line: number): number;
+    lineStart(line: number): number;
+    lineText(line: number): string;
+    markSaved(): void;
+    offset(line: number, column?: number): number;
+    position(offset?: number): {
+        column: number;
+        line: number;
+    };
+    redo(): boolean;
+    redoSelection(): boolean;
+    replace(from: number, to: number, insert: string, options?: TransactionOptions): boolean;
+    reset(value?: string, next?: Partial<Selection>): void;
+    select(next: Partial<Selection>, source?: string): void;
+    selectMany(next: readonly Partial<Selection>[], source?: string): void;
+    setValue(value: string, options?: TransactionOptions): boolean;
+    subscribe(listener: Listener): () => void;
+    transact(batch: readonly Edit[], options?: TransactionOptions): TransactionResult;
+    undo(): boolean;
+    undoSelection(): boolean;
+}
+export { EditorDocument, floorIndex, lineEnd, lineStarts, normalizeSelections, preferredEol, sameSelection, sameSelections, selection };
+export type { Change, Delta, Edit, Selection, Snapshot, TransactionOptions, TransactionResult };

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

@@ -0,0 +1,477 @@
+import { clamp } from '../../../shared/clamp.js';
+const EOL = /\r\n|\r|\n/;
+const GROUP_WINDOW = 750;
+const LINE_BREAK = /[\r\n]/;
+const LOG_LIMIT = 64;
+const SELECTION_HISTORY = 200;
+function applyPatches(value, patches) {
+    let chunks = [], cursor = 0;
+    for (let i = 0, n = patches.length; i < n; i++) {
+        let patch = patches[i];
+        chunks.push(value.slice(cursor, patch.from), patch.insert);
+        cursor = patch.from + patch.removed.length;
+    }
+    chunks.push(value.slice(cursor));
+    return chunks.join('');
+}
+function clampOffset(value, max) {
+    return clamp(Number.isFinite(value) ? Math.trunc(value) : 0, 0, max);
+}
+function edits(patches) {
+    return patches.map((patch) => ({ from: patch.from, insert: patch.insert, to: patch.from + patch.removed.length }));
+}
+function isLineStart(text, offset) {
+    let previous = text.charCodeAt(offset - 1);
+    return previous === 10 || (previous === 13 && text.charCodeAt(offset) !== 10);
+}
+function reindex(starts, text, patches) {
+    let cursor = 0, first = 0, next = [], shift = 0;
+    for (let k = 0, n = patches.length; k < n; k++) {
+        let { from, insert, removed } = patches[k], to = from + removed.length;
+        while (cursor < starts.length && (cursor === 0 || starts[cursor] < from)) {
+            next.push(starts[cursor++] + shift);
+        }
+        if (k === 0) {
+            first = starts[cursor] === from ? cursor : cursor - 1;
+        }
+        let at = from + shift;
+        for (let p = Math.max(at, next[next.length - 1] + 1), end = at + insert.length; p <= end; p++) {
+            if (isLineStart(text, p)) {
+                next.push(p);
+            }
+        }
+        while (cursor < starts.length && starts[cursor] <= to) {
+            cursor++;
+        }
+        shift += insert.length - removed.length;
+    }
+    let line = Math.max(0, first), removed = cursor - line, inserted = next.length - line;
+    for (let n = starts.length; cursor < n; cursor++) {
+        next.push(starts[cursor] + shift);
+    }
+    return { delta: { edits: edits(patches), inserted, line, removed }, starts: next };
+}
+const floorIndex = (starts, offset) => {
+    let hi = starts.length, lo = 0;
+    while (lo < hi) {
+        let mid = (lo + hi) >>> 1;
+        if (starts[mid] <= offset) {
+            lo = mid + 1;
+        }
+        else {
+            hi = mid;
+        }
+    }
+    return lo - 1;
+};
+const lineEnd = (text, starts, index) => {
+    let end = starts[index + 1] ?? text.length, start = starts[index];
+    if (end > start && text.charCodeAt(end - 1) === 10) {
+        end--;
+    }
+    if (end > start && text.charCodeAt(end - 1) === 13) {
+        end--;
+    }
+    return end;
+};
+const lineStarts = (text) => {
+    let starts = [0];
+    for (let i = 0, n = text.length; i < n; i++) {
+        let code = text.charCodeAt(i);
+        if (code === 13) {
+            if (text.charCodeAt(i + 1) === 10) {
+                i++;
+            }
+            starts.push(i + 1);
+        }
+        else if (code === 10) {
+            starts.push(i + 1);
+        }
+    }
+    return starts;
+};
+const preferredEol = (text) => {
+    return EOL.exec(text)?.[0] ?? '\n';
+};
+const sameSelection = (a, b) => {
+    return a.start === b.start && a.end === b.end && a.direction === b.direction;
+};
+const sameSelections = (a, b) => {
+    if (a.length !== b.length) {
+        return false;
+    }
+    for (let i = 0, n = a.length; i < n; i++) {
+        if (!sameSelection(a[i], b[i])) {
+            return false;
+        }
+    }
+    return true;
+};
+const selection = (value, length) => {
+    let start = clampOffset(value.start ?? 0, length), end = clampOffset(value.end ?? start, length);
+    return Object.freeze({
+        direction: value.direction ?? 'none',
+        end: Math.max(start, end),
+        start: Math.min(start, end)
+    });
+};
+const normalizeSelections = (ranges, length) => {
+    let merged = [], original = ranges.length ? ranges.map((range) => selection(range, length)) : [selection({}, length)], primary = original[0], sorted = original.length > 1 ? [...original].sort((a, b) => a.start - b.start || a.end - b.end) : original;
+    for (let i = 0, n = sorted.length; i < n; i++) {
+        let last = merged[merged.length - 1], range = sorted[i];
+        if (last && (range.start < last.end || (range.start === last.start && range.end === last.end))) {
+            merged[merged.length - 1] = selection({ direction: last.direction, end: Math.max(last.end, range.end), start: last.start }, length);
+        }
+        else {
+            merged.push(range);
+        }
+    }
+    let index = merged.findIndex((range) => range.start <= primary.start && range.end >= primary.end);
+    if (index > 0) {
+        merged.unshift(...merged.splice(index, 1));
+    }
+    return Object.freeze(merged);
+};
+class EditorDocument {
+    boundary = false;
+    byteLimit;
+    bytes = 0;
+    dropped = 0;
+    future = [];
+    index;
+    limit;
+    listeners = new Set();
+    log = [];
+    past = [];
+    primary = selection({}, 0);
+    ranges = Object.freeze([this.primary]);
+    saved;
+    selectionFuture = [];
+    selectionPast = [];
+    text;
+    version = 0;
+    constructor(value = '', history = {}) {
+        this.byteLimit = clampOffset(history.bytes ?? 8_000_000, Number.MAX_SAFE_INTEGER);
+        this.index = lineStarts(value);
+        this.limit = clampOffset(history.limit ?? 200, 10000);
+        this.saved = this.text = value;
+    }
+    assign(next, length) {
+        this.ranges = normalizeSelections(next, length);
+        this.primary = this.ranges[0];
+    }
+    emit(source, textChanged, before, editBatches) {
+        let change = Object.freeze({
+            editBatches,
+            selectionChanged: !sameSelections(before, this.ranges),
+            source,
+            textChanged
+        }), state = this.state;
+        for (let listener of [...this.listeners]) {
+            listener(state, change);
+        }
+    }
+    record(delta) {
+        this.log.push({ delta, revision: this.version });
+        if (this.log.length > LOG_LIMIT) {
+            this.dropped = this.log.shift().revision;
+        }
+    }
+    travel(redo) {
+        let entry = (redo ? this.future : this.past).pop();
+        if (!entry) {
+            return false;
+        }
+        let batches = redo ? entry.patches : [...entry.patches].reverse(), before = this.ranges, editBatches = [];
+        this.version++;
+        for (let i = 0, n = batches.length; i < n; i++) {
+            let delta = 0, ranges = [];
+            for (let j = 0, m = batches[i].length; j < m; j++) {
+                let patch = batches[i][j];
+                ranges.push({
+                    from: patch.from + (redo ? 0 : delta),
+                    insert: redo ? patch.insert : patch.removed,
+                    removed: redo ? patch.removed : patch.insert
+                });
+                delta += patch.insert.length - patch.removed.length;
+            }
+            let text = applyPatches(this.text, ranges), next = reindex(this.index, text, ranges);
+            editBatches.push(next.delta.edits);
+            this.index = next.starts;
+            this.text = text;
+            this.record(next.delta);
+        }
+        this.selectionFuture = [];
+        this.selectionPast = [];
+        this.assign(redo ? entry.after : entry.before, this.text.length);
+        (redo ? this.past : this.future).push(entry);
+        this.boundary = true;
+        this.emit(redo ? 'redo' : 'undo', true, before, editBatches);
+        return true;
+    }
+    travelSelection(redo) {
+        let next = (redo ? this.selectionFuture : this.selectionPast).pop();
+        if (!next) {
+            return false;
+        }
+        let before = this.ranges;
+        (redo ? this.selectionPast : this.selectionFuture).push(before);
+        this.assign(next, this.text.length);
+        this.boundary = true;
+        this.emit(redo ? 'redoSelection' : 'undoSelection', false, before);
+        return true;
+    }
+    get eol() {
+        let end = this.index[1];
+        if (end === undefined) {
+            return '\n';
+        }
+        if (this.text.charCodeAt(end - 1) === 13) {
+            return '\r';
+        }
+        return this.text.charCodeAt(end - 2) === 13 ? '\r\n' : '\n';
+    }
+    get lineCount() {
+        return this.index.length;
+    }
+    get revision() {
+        return this.version;
+    }
+    get selection() {
+        return this.primary;
+    }
+    get selections() {
+        return this.ranges;
+    }
+    get starts() {
+        return this.index;
+    }
+    get state() {
+        return Object.freeze({
+            canRedo: this.future.length > 0,
+            canUndo: this.past.length > 0,
+            dirty: this.text !== this.saved,
+            lineCount: this.index.length,
+            revision: this.version,
+            selection: this.primary,
+            selections: this.ranges,
+            value: this.text
+        });
+    }
+    get value() {
+        return this.text;
+    }
+    breakHistory() {
+        this.boundary = true;
+    }
+    deltas(since) {
+        if (since === this.version) {
+            return [];
+        }
+        let log = this.log, out = [];
+        if (since > this.version || since < this.dropped) {
+            return null;
+        }
+        for (let i = 0, n = log.length; i < n; i++) {
+            let entry = log[i];
+            if (entry.revision <= since) {
+                continue;
+            }
+            if (!entry.delta) {
+                return null;
+            }
+            out.push(entry.delta);
+        }
+        return out;
+    }
+    lineAt(offset) {
+        return floorIndex(this.index, clampOffset(offset, this.text.length));
+    }
+    lineEnd(line) {
+        return lineEnd(this.text, this.index, clampOffset(line, this.index.length - 1));
+    }
+    lineStart(line) {
+        return this.index[clampOffset(line, this.index.length - 1)];
+    }
+    lineText(line) {
+        line = clampOffset(line, this.index.length - 1);
+        return this.text.slice(this.index[line], lineEnd(this.text, this.index, line));
+    }
+    markSaved() {
+        this.saved = this.text;
+        this.boundary = true;
+        this.emit('saved', false, this.ranges);
+    }
+    offset(line, column = 1) {
+        let index = clampOffset(line - 1, this.index.length - 1), start = this.index[index];
+        return start + clampOffset(column - 1, lineEnd(this.text, this.index, index) - start);
+    }
+    position(offset = this.primary.direction === 'backward' ? this.primary.start : this.primary.end) {
+        offset = clampOffset(offset, this.text.length);
+        let index = floorIndex(this.index, offset);
+        return {
+            column: Math.min(offset, lineEnd(this.text, this.index, index)) - this.index[index] + 1,
+            line: index + 1
+        };
+    }
+    redo() {
+        return this.travel(true);
+    }
+    redoSelection() {
+        return this.travelSelection(true);
+    }
+    replace(from, to, insert, options = {}) {
+        return this.transact([{ from, insert, to }], options).changed;
+    }
+    reset(value = '', next = {}) {
+        let before = this.ranges, changed = value !== this.text;
+        this.saved = this.text = value;
+        this.index = lineStarts(value);
+        this.assign([next], value.length);
+        this.selectionFuture = [];
+        this.selectionPast = [];
+        this.future = [];
+        this.past = [];
+        this.bytes = 0;
+        this.boundary = true;
+        if (changed) {
+            this.version++;
+            this.record(null);
+        }
+        this.emit('reset', changed, before);
+    }
+    select(next, source = 'selection') {
+        this.selectMany([next], source);
+    }
+    selectMany(next, source = 'selection') {
+        let before = this.ranges;
+        this.assign(next, this.text.length);
+        if (sameSelections(before, this.ranges)) {
+            return;
+        }
+        this.selectionPast.push(before);
+        if (this.selectionPast.length > SELECTION_HISTORY) {
+            this.selectionPast.shift();
+        }
+        this.selectionFuture = [];
+        this.boundary = true;
+        this.emit(source, false, before);
+    }
+    setValue(value, options = {}) {
+        return this.replace(0, this.text.length, value, { selections: this.ranges, source: 'setValue', ...options });
+    }
+    subscribe(listener) {
+        this.listeners.add(listener);
+        return () => {
+            this.listeners.delete(listener);
+        };
+    }
+    transact(batch, options = {}) {
+        let length = this.text.length, previous = -1, sorted = batch.map((edit, index) => ({ edit, index })).sort((a, b) => a.edit.from - b.edit.from);
+        for (let i = 0, n = sorted.length; i < n; i++) {
+            let { edit, index } = sorted[i];
+            if (!Number.isInteger(edit.from) ||
+                !Number.isInteger(edit.to) ||
+                edit.from < 0 ||
+                edit.to < edit.from ||
+                edit.to > length) {
+                return { accepted: false, changed: false, index, reason: 'invalid-range' };
+            }
+            if (typeof edit.insert !== 'string') {
+                return { accepted: false, changed: false, index, reason: 'invalid-insert' };
+            }
+            if (edit.from < previous) {
+                return { accepted: false, changed: false, index, reason: 'overlap' };
+            }
+            previous = edit.to;
+        }
+        let before = this.ranges, patches = [], shifts = [], total = 0;
+        for (let i = 0, n = sorted.length; i < n; i++) {
+            let { from, insert, to } = sorted[i].edit, removed = this.text.slice(from, to);
+            if (removed !== insert) {
+                patches.push({ from, insert, removed });
+                shifts.push(total);
+                total += insert.length - removed.length;
+            }
+        }
+        let text = patches.length ? applyPatches(this.text, patches) : this.text;
+        shifts.push(total);
+        let map = (position) => {
+            let hi = patches.length, lo = 0;
+            while (lo < hi) {
+                let mid = (lo + hi) >>> 1;
+                if (patches[mid].from + patches[mid].removed.length < position) {
+                    lo = mid + 1;
+                }
+                else {
+                    hi = mid;
+                }
+            }
+            let patch = patches[lo];
+            if (patch && patch.from <= position) {
+                return patch.from + shifts[lo] + patch.insert.length;
+            }
+            return position + shifts[lo];
+        };
+        this.assign(options.selections ??
+            (options.selection
+                ? [options.selection]
+                : before.map((range) => ({
+                    direction: range.direction,
+                    end: map(range.end),
+                    start: map(range.start)
+                }))), text.length);
+        if (!patches.length) {
+            if (!sameSelections(before, this.ranges)) {
+                this.emit(options.source ?? 'command', false, before);
+            }
+            return { accepted: true, changed: false };
+        }
+        let next = reindex(this.index, text, patches);
+        this.selectionFuture = [];
+        this.selectionPast = [];
+        this.text = text;
+        this.index = next.starts;
+        this.version++;
+        this.record(next.delta);
+        let bytes = 0, group = options.group, last = this.past[this.past.length - 1], multiline = false, time = options.time ?? Date.now();
+        for (let i = 0, n = patches.length; i < n; i++) {
+            let patch = patches[i];
+            bytes += 2 * (patch.insert.length + patch.removed.length);
+            multiline ||= LINE_BREAK.test(patch.insert) || LINE_BREAK.test(patch.removed);
+        }
+        for (let i = 0, n = this.future.length; i < n; i++) {
+            this.bytes -= this.future[i].bytes;
+        }
+        this.future = [];
+        if (!this.boundary &&
+            group &&
+            last?.group === group &&
+            time - last.time >= 0 &&
+            time - last.time < GROUP_WINDOW &&
+            sameSelections(before, last.after) &&
+            !multiline) {
+            last.after = this.ranges;
+            last.bytes += bytes;
+            last.patches.push(patches);
+            last.time = time;
+        }
+        else {
+            this.past.push({ after: this.ranges, before, bytes, group, patches: [patches], time });
+        }
+        this.boundary = false;
+        this.bytes += bytes;
+        while (this.past.length > this.limit || this.bytes > this.byteLimit) {
+            this.bytes -= this.past.shift().bytes;
+        }
+        this.emit(options.source ?? 'command', true, before, [next.delta.edits]);
+        return { accepted: true, changed: true };
+    }
+    undo() {
+        return this.travel(false);
+    }
+    undoSelection() {
+        return this.travelSelection(false);
+    }
+}
+export { EditorDocument, floorIndex, lineEnd, lineStarts, normalizeSelections, preferredEol, sameSelection, sameSelections, selection };