@esportsplus/ui 0.56.3 → 0.57.0

package/scripts/css-variables.test.mjs

@@ -3,7 +3,7 @@ import { fileURLToPath } from 'node:url';
 import { test } from 'node:test';
 import { compileString } from 'sass';
 
-const loadPaths = [fileURLToPath(new URL('../src/lib/scss/', import.meta.url))];
+const loadPaths = [fileURLToPath(new URL('../src/shared/scss/', import.meta.url))];
 const compile = source => compileString(`@use 'css-variables' as lib; ${source}`, {
     loadPaths,
     style: 'compressed'

package/scripts/deadline.test.mjs

@@ -0,0 +1,191 @@
+import assert from 'node:assert/strict';
+import { mock, test } from 'node:test';
+
+
+// Counts the timers the queue holds, through the mocked setTimeout.
+let errors = [],
+    pending = new Set(),
+    real = { clearTimeout: globalThis.clearTimeout, setTimeout: globalThis.setTimeout };
+
+mock.timers.enable({ apis: ['Date', 'setTimeout'], now: 0 });
+
+let mocked = { clearTimeout: globalThis.clearTimeout, setTimeout: globalThis.setTimeout };
+
+Object.assign(globalThis, {
+    clearTimeout: (id) => {
+        pending.delete(id);
+        mocked.clearTimeout(id);
+    },
+    reportError: (error) => errors.push(error),
+    setTimeout: (callback, delay) => {
+        let id = mocked.setTimeout(() => {
+            pending.delete(id);
+            callback();
+        }, delay);
+
+        pending.add(id);
+        return id;
+    }
+});
+
+let { deadline } = await import('../src/shared/deadline.ts');
+
+
+// The mock runs every timer a tick passes with the clock already at the tick's end, so short spans step a millisecond
+// at a time to let each callback read its own time.
+function at(ms) {
+    if (ms - Date.now() > 10_000) {
+        mock.timers.tick(ms - Date.now());
+        return;
+    }
+
+    while (Date.now() < ms) {
+        mock.timers.tick(1);
+    }
+
+    mock.timers.tick(0);
+}
+
+
+test('many deadlines share one timer, each running once its time comes, in order', () => {
+    let heard = [],
+        cancels = [];
+
+    for (let ms of [5000, 1000, 3000, 1000, 2000]) {
+        cancels.push(deadline(ms, () => heard.push([ms, Date.now()])));
+    }
+
+    assert.equal(pending.size, 1);
+
+    at(999);
+    assert.deepEqual(heard, []);
+
+    at(1000);
+    assert.deepEqual(heard, [[1000, 1000], [1000, 1000]]);
+    assert.equal(pending.size, 1);
+
+    at(5000);
+    assert.deepEqual(heard, [[1000, 1000], [1000, 1000], [2000, 2000], [3000, 3000], [5000, 5000]]);
+    assert.equal(pending.size, 0);
+});
+
+test('callbacks rescheduling in a flush set the timer once, for the earliest', () => {
+    let base = Date.now(),
+        armed = 0,
+        heard = [],
+        set = globalThis.setTimeout;
+
+    globalThis.setTimeout = (callback, delay) => {
+        armed++;
+        return set(callback, delay);
+    };
+
+    // Rows whose labels change at their own 'value + n * unit', not on a shared wall-clock boundary.
+    for (let value of [base - 400, base - 700, base - 100]) {
+        let next = () => {
+            let now = Date.now(),
+                change = now + 1000 - ((now - value) % 1000);
+
+            heard.push([value - base, now - base]);
+
+            if (change < base + 3000) {
+                deadline(change, next);
+            }
+        };
+
+        deadline(base + 1000 - ((base - value) % 1000), next);
+    }
+
+    armed = 0;
+    at(base + 3000);
+    globalThis.setTimeout = set;
+
+    assert.deepEqual(heard, [
+        [-700, 300], [-400, 600], [-100, 900],
+        [-700, 1300], [-400, 1600], [-100, 1900],
+        [-700, 2300], [-400, 2600], [-100, 2900]
+    ]);
+    // Once per flush: nine flushes, and nothing armed after the last since no row rescheduled.
+    assert.equal(armed, 8);
+    assert.equal(pending.size, 0);
+});
+
+test('cancelling removes a deadline and re-arms for the next; the last cancel clears the timer', () => {
+    let base = Date.now(),
+        heard = [],
+        first = deadline(base + 100, () => heard.push('first')),
+        second = deadline(base + 200, () => heard.push('second')),
+        third = deadline(base + 300, () => heard.push('third'));
+
+    first();
+    first();
+    third();
+    at(base + 150);
+    assert.deepEqual(heard, []);
+    at(base + 200);
+    assert.deepEqual(heard, ['second']);
+    second();
+    assert.equal(pending.size, 0);
+});
+
+test('a deadline cancelled by an earlier callback in the same flush does not run', () => {
+    let base = Date.now(),
+        heard = [],
+        second,
+        first = deadline(base + 100, () => {
+            heard.push('first');
+            second();
+        });
+
+    second = deadline(base + 100, () => heard.push('second'));
+    at(base + 100);
+
+    assert.deepEqual(heard, ['first']);
+    first();
+    assert.equal(pending.size, 0);
+});
+
+test('one callback throwing does not stop the rest of its flush', () => {
+    let base = Date.now(),
+        failure = new Error('row failed'),
+        heard = [];
+
+    deadline(base + 10, () => {
+        throw failure;
+    });
+    deadline(base + 10, () => heard.push('after'));
+    at(base + 10);
+
+    assert.deepEqual(heard, ['after']);
+    assert.deepEqual(errors, [failure]);
+    errors.length = 0;
+});
+
+test('a deadline past the longest timeout waits through it instead of firing at once', () => {
+    let base = Date.now(),
+        heard = 0,
+        far = base + 2 ** 31 + 5000;
+
+    deadline(far, () => heard++);
+    at(base + 2 ** 31 - 1);
+    assert.equal(heard, 0);
+    assert.equal(pending.size, 1);
+
+    at(far);
+    assert.equal(heard, 1);
+    assert.equal(pending.size, 0);
+});
+
+test('a deadline already past runs on the next timer turn', () => {
+    let heard = 0;
+
+    deadline(Date.now() - 1000, () => heard++);
+    assert.equal(heard, 0);
+    at(Date.now());
+    assert.equal(heard, 1);
+});
+
+test.after(() => {
+    Object.assign(globalThis, real);
+    mock.timers.reset();
+});

package/scripts/diffs.test.mjs

@@ -0,0 +1,189 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import './resolve.mjs';
+
+
+const { conflictMarkers, diff3, resolveMarker } = await import('../src/components/editor/diffs/diff3.ts');
+const { diffLines, diffSequences } = await import('../src/components/editor/diffs/engine.ts');
+const { acceptChange, diffTexts, hunks, revertChange } = await import('../src/components/editor/diffs/hunks.ts');
+const { words } = await import('../src/components/editor/diffs/words.ts');
+
+
+const numbered = (count, edit = {}) => Array.from({ length: count }, (_, i) => edit[i] ?? `line ${i + 1}`).join('\n');
+
+
+test('diffLines reports nothing for equal texts', () => {
+    assert.deepEqual(diffLines('a\nb', 'a\nb'), []);
+});
+
+test('diffLines finds insertions, deletions and replacements', () => {
+    assert.deepEqual(diffLines('a\nb\nc', 'a\nx\nb\nc'), [{ modified: { from: 1, to: 2 }, original: { from: 1, to: 1 } }]);
+    assert.deepEqual(diffLines('a\nb\nc', 'a\nc'), [{ modified: { from: 1, to: 1 }, original: { from: 1, to: 2 } }]);
+    assert.deepEqual(diffLines('a\nb\nc', 'a\ny\nc'), [{ modified: { from: 1, to: 2 }, original: { from: 1, to: 2 } }]);
+});
+
+test('diffLines ignores line endings', () => {
+    assert.deepEqual(diffLines('a\r\nb', 'a\nb'), []);
+});
+
+test('diffSequences aligns every element', () => {
+    let ops = diffSequences([...'abcabba'], [...'cbabac']);
+
+    assert.equal(ops.filter((op) => op.type !== 'insert').length, 7);
+    assert.equal(ops.filter((op) => op.type !== 'delete').length, 6);
+});
+
+test('diffSequences stays exact on long inputs with scattered edits', () => {
+    let changes = diffLines(numbered(5000), numbered(5000, { 10: 'x', 2500: 'y', 4990: 'z' }));
+
+    assert.deepEqual(changes.map((change) => change.original.from), [10, 2500, 4990]);
+});
+
+test('diffTexts aligns rows and counts additions and deletions', () => {
+    let diff = diffTexts('a\nb\nc', 'a\nx\nc\nd');
+
+    assert.equal(diff.additions, 2);
+    assert.equal(diff.deletions, 1);
+    assert.deepEqual(diff.rows.map((row) => row.type), ['equal', 'delete', 'insert', 'equal', 'insert']);
+    assert.deepEqual(diff.changes, [
+        { index: 0, modified: { from: 1, to: 2 }, modifiedText: 'x', original: { from: 1, to: 2 }, originalText: 'b', rows: { from: 1, to: 3 } },
+        { index: 1, modified: { from: 3, to: 4 }, modifiedText: 'd', original: { from: 3, to: 3 }, originalText: '', rows: { from: 4, to: 5 } }
+    ]);
+});
+
+test('diffTexts can ignore leading and trailing whitespace', () => {
+    assert.equal(diffTexts('a\n  b', 'a\nb  ').changes.length, 1);
+    assert.equal(diffTexts('a\n  b', 'a\nb  ', { ignoreWhitespace: true }).changes.length, 0);
+});
+
+test('hunks keep context around changes and hide the rest as gaps', () => {
+    let diff = diffTexts(numbered(20), numbered(20, { 4: 'five', 15: 'sixteen' })),
+        { gaps, hunks: list } = hunks(diff, 2);
+
+    assert.equal(list.length, 2);
+    assert.deepEqual(list[0].original, { from: 2, to: 7 });
+    assert.deepEqual(list[0].modified, { from: 2, to: 7 });
+    assert.deepEqual(list[1].original, { from: 13, to: 18 });
+    // Leading, between and trailing unchanged rows.
+    assert.deepEqual(gaps.map(({ from, to }) => to - from), [2, 6, 2]);
+});
+
+test('hunks merge changes whose context touches', () => {
+    let diff = diffTexts(numbered(20), numbered(20, { 4: 'five', 9: 'ten' }));
+
+    assert.equal(hunks(diff, 3).hunks.length, 1);
+    assert.deepEqual(hunks(diff, 3).hunks[0].changes, { from: 0, to: 2 });
+    assert.equal(hunks(diff, 1).hunks.length, 2);
+    assert.deepEqual(hunks(diff, 0).gaps.map(({ from, to }) => to - from), [4, 4, 10]);
+});
+
+test('hunks treat identical texts as one gap and an unlimited context as none', () => {
+    let same = diffTexts(numbered(5), numbered(5));
+
+    assert.deepEqual(hunks(same).hunks, []);
+    assert.deepEqual(hunks(same).gaps, [{ from: 0, to: 5 }]);
+    assert.deepEqual(hunks(diffTexts(numbered(9), numbered(9, { 4: 'x' })), Infinity).gaps, []);
+});
+
+test('hunks count pure insertions and deletions from their change', () => {
+    let diff = diffTexts('a\nb\nc', 'a\nb\nx\nc'),
+        [hunk] = hunks(diff, 0).hunks;
+
+    assert.deepEqual(hunk.original, { from: 2, to: 2 });
+    assert.deepEqual(hunk.modified, { from: 2, to: 3 });
+});
+
+test('acceptChange and revertChange apply one change to either side', () => {
+    let original = 'a\nb\nc\nd',
+        modified = 'a\nB\nc\nd\ne',
+        diff = diffTexts(original, modified);
+
+    assert.equal(revertChange(modified, diff.changes[0]), 'a\nb\nc\nd\ne');
+    assert.equal(revertChange(modified, diff.changes[1]), 'a\nB\nc\nd');
+    assert.equal(acceptChange(original, diff.changes[0]), 'a\nB\nc\nd');
+    assert.equal(acceptChange(original, diff.changes[1]), 'a\nb\nc\nd\ne');
+    assert.equal(revertChange('a\r\nB', diffTexts('a\r\nb', 'a\r\nB').changes[0]), 'a\r\nb');
+});
+
+test('words marks only the changed words of a line pair', () => {
+    let result = words('let total = count + 1;', 'let total = amount + 2;');
+
+    assert.deepEqual(result.original, [{ from: 12, to: 17 }, { from: 20, to: 21 }]);
+    assert.deepEqual(result.modified, [{ from: 12, to: 18 }, { from: 21, to: 22 }]);
+});
+
+test('words joins changes separated only by whitespace', () => {
+    assert.deepEqual(words('keep one two', 'keep three four'), {
+        modified: [{ from: 5, to: 15 }],
+        original: [{ from: 5, to: 12 }]
+    });
+});
+
+test('words gives up on unrelated or very long lines', () => {
+    assert.equal(words('alpha beta', 'gamma delta'), null);
+    assert.equal(words('x'.repeat(3000), 'y'.repeat(3000)), null);
+});
+
+test('words can ignore whitespace changes', () => {
+    assert.deepEqual(words('a  b', 'a b', true), { modified: [], original: [] });
+    assert.deepEqual(words('a  b', 'a b').original, [{ from: 1, to: 3 }]);
+});
+
+test('diff3 takes changes made on one side only', () => {
+    let result = diff3('a\nb\nc\nd\ne', 'A\nb\nc\nd\ne', 'a\nb\nc\nd\nE');
+
+    assert.equal(result.conflicts, 0);
+    assert.equal(result.text, 'A\nb\nc\nd\nE');
+    assert.deepEqual(result.regions.map((region) => region.kind), ['current', 'equal', 'incoming']);
+});
+
+test('diff3 accepts identical changes and conflicts on different ones', () => {
+    assert.equal(diff3('a\nb\nc', 'a\nX\nc', 'a\nX\nc').text, 'a\nX\nc');
+
+    let result = diff3('a\nb\nc', 'a\nours\nc', 'a\ntheirs\nc');
+
+    assert.equal(result.conflicts, 1);
+    assert.equal(result.text, 'a\n<<<<<<< current\nours\n||||||| base\nb\n=======\ntheirs\n>>>>>>> incoming\nc');
+});
+
+test('diff3 handles insertions, deletions and a missing base', () => {
+    assert.equal(diff3('a\nb\nc\nd\ne', 'a\nb\nb2\nc\nd\ne', 'a\nb\nc\nd').text, 'a\nb\nb2\nc\nd');
+    assert.equal(diff3('a\nb\nc\nd\ne\nf', 'a\nb\nc\nd\ne\nf\ng', 'z\na\nb\nc\nd\ne\nf').text, 'z\na\nb\nc\nd\ne\nf\ng');
+
+    let result = diff3(null, 'a\nb\nc', 'a\nx\nc');
+
+    assert.equal(result.conflicts, 1);
+    assert.equal(result.text, 'a\n<<<<<<< current\nb\n=======\nx\n>>>>>>> incoming\nc');
+});
+
+test('diff3 keeps the line endings of the current side', () => {
+    assert.equal(diff3('a\r\nb', 'a\r\nB', 'a\r\nb').text, 'a\r\nB');
+});
+
+test('conflictMarkers finds blocks with and without a base section', () => {
+    let text = diff3('a\nb\nc', 'a\nours\nc', 'a\ntheirs\nc').text + '\n<<<<<<< x\n1\n=======\n2\n>>>>>>> y',
+        list = conflictMarkers(text);
+
+    assert.equal(list.length, 2);
+    assert.deepEqual({ ...list[0], from: 0, to: 0 }, { base: 'b\n', current: 'ours\n', from: 0, incoming: 'theirs\n', line: 1, to: 0 });
+    assert.equal(text.slice(list[0].from, list[0].to), '<<<<<<< current\nours\n||||||| base\nb\n=======\ntheirs\n>>>>>>> incoming\n');
+    assert.equal(list[1].base, null);
+    assert.equal(list[1].line, 9);
+    assert.equal(list[1].to, text.length);
+    assert.deepEqual(conflictMarkers('<<<<<<< a\nx\n=======\n'), []);
+});
+
+test('resolveMarker replaces a block with the chosen side', () => {
+    let text = 'a\n<<<<<<< current\nours\n=======\ntheirs\n>>>>>>> incoming\nc',
+        [marker] = conflictMarkers(text),
+        apply = (choice) => text.slice(0, marker.from) + resolveMarker(text, marker, choice) + text.slice(marker.to);
+
+    assert.equal(apply('current'), 'a\nours\nc');
+    assert.equal(apply('incoming'), 'a\ntheirs\nc');
+    assert.equal(apply('both'), 'a\nours\ntheirs\nc');
+
+    let last = 'a\n<<<<<<< current\nours\n=======\ntheirs\n>>>>>>> incoming',
+        [end] = conflictMarkers(last);
+
+    assert.equal(last.slice(0, end.from) + resolveMarker(last, end, 'both'), 'a\nours\ntheirs');
+});

package/scripts/file-tree-features.test.mjs

@@ -0,0 +1,137 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import './resolve.mjs';
+
+
+const { enclosing, flagged, order, seek } = await import('../src/components/editor/tree/jump.ts');
+const { attach, collect, flatten } = await import('../src/components/editor/tree/transfer.ts');
+
+
+// A FileSystemEntry tree, with each folder read back in batches of 'size' as browsers do.
+const directory = (name, children, size = 100) => ({
+    createReader: () => {
+        let at = 0;
+
+        return {
+            readEntries: (resolve) => {
+                let batch = children.slice(at, at + size);
+
+                at += batch.length;
+                queueMicrotask(() => resolve(batch));
+            }
+        };
+    },
+    isDirectory: true,
+    isFile: false,
+    name
+});
+
+const entry = (name, fail = false) => ({
+    file: (resolve, reject) => queueMicrotask(() => fail ? reject(new Error('denied')) : resolve(new File([name], name))),
+    isDirectory: false,
+    isFile: true,
+    name
+});
+
+const paths = (entries) => entries.map((value) => value.file ? value.path : `${value.path}/`);
+
+
+test('places sort in tree order, a folder before what it holds', () => {
+    let places = [[1, 2], [0], [1], [0, 3], [1, 0, 1]];
+
+    places.sort(order);
+
+    assert.deepEqual(places, [[0], [0, 3], [1], [1, 0, 1], [1, 2]]);
+});
+
+test('seek moves past the cursor either way and wraps round', () => {
+    let places = [[0, 1], [1], [2, 0], [2, 4]];
+
+    assert.equal(seek(places, [0], 1), 0);
+    assert.equal(seek(places, [0, 1], 1), 1);
+    assert.equal(seek(places, [2, 1], 1), 3);
+    assert.equal(seek(places, [2, 4], 1), 0);
+    assert.equal(seek(places, [2, 4], -1), 2);
+    assert.equal(seek(places, [0, 1], -1), 3);
+    assert.equal(seek(places, [3], -1), 3);
+});
+
+test('seek without a cursor starts at either end, and finds nothing in nothing', () => {
+    assert.equal(seek([[0], [1]], null, 1), 0);
+    assert.equal(seek([[0], [1]], null, -1), 1);
+    assert.equal(seek([], [0], 1), -1);
+});
+
+test('changes are git statuses, staged or not; problems are errors and warnings', () => {
+    assert.equal(flagged({ status: 'modified' }, 'change'), true);
+    assert.equal(flagged({ staged: 'added' }, 'change'), true);
+    assert.equal(flagged({ status: 'ignored' }, 'change'), false);
+    assert.equal(flagged({ errors: 1 }, 'change'), false);
+    assert.equal(flagged({ errors: 1 }, 'problem'), true);
+    assert.equal(flagged({ warnings: 2 }, 'problem'), true);
+    assert.equal(flagged({ errors: 0, status: 'modified' }, 'problem'), false);
+    assert.equal(flagged(undefined, 'problem'), false);
+});
+
+test('enclosing lists the folders a path id sits in, nearest first', () => {
+    assert.deepEqual(enclosing('src/lib/index.ts'), ['src/lib', 'src']);
+    assert.deepEqual(enclosing('/home/dev/a.ts'), ['/home/dev', '/home']);
+    assert.deepEqual(enclosing('C:\\code\\app\\main.rs'), ['C:\\code\\app', 'C:\\code', 'C:']);
+    assert.deepEqual(enclosing('README.md'), []);
+});
+
+test('dropped folders flatten depth first, each folder ahead of its contents', async () => {
+    let dropped = [
+        directory('photos', [entry('cat.png'), directory('raw', [entry('cat.raw')]), directory('empty', [])]),
+        entry('notes.txt')
+    ];
+
+    assert.deepEqual(paths(await flatten(dropped)), ['photos/', 'photos/cat.png', 'photos/raw/', 'photos/raw/cat.raw', 'photos/empty/', 'notes.txt']);
+});
+
+test('a folder is read to the end across batches', async () => {
+    let children = Array.from({ length: 7 }, (_, i) => entry(`${i}.txt`)),
+        out = await flatten([directory('many', children, 3)]);
+
+    assert.equal(out.length, 8);
+    assert.equal(out[7].path, 'many/6.txt');
+    assert.equal(await out[1].file.text(), '0.txt');
+});
+
+test('unreadable files are left out rather than failing the drop', async () => {
+    assert.deepEqual(paths(await flatten([directory('a', [entry('locked', true), entry('open')])])), ['a/', 'a/open']);
+});
+
+test('collect walks entries and falls back to plain files, in the order dropped', async () => {
+    let plain = new File(['x'], 'plain.txt'),
+        items = [
+            { getAsFile: () => null, kind: 'file', webkitGetAsEntry: () => directory('docs', [entry('a.md')]) },
+            { getAsFile: () => plain, kind: 'file', webkitGetAsEntry: () => null },
+            { getAsFile: () => null, kind: 'string', webkitGetAsEntry: () => null }
+        ];
+
+    assert.deepEqual(paths(await collect({ items })), ['docs/', 'docs/a.md', 'plain.txt']);
+});
+
+test('one exported file carries a download, any number carry links and text', () => {
+    let data = new Map(),
+        transfer = { setData: (type, value) => data.set(type, value) };
+
+    attach(transfer, [{ name: 'a.txt', text: 'hello', type: 'text/plain', url: 'data:text/plain,hello' }]);
+
+    assert.equal(data.get('DownloadURL'), 'text/plain:a.txt:data:text/plain,hello');
+    assert.equal(data.get('text/uri-list'), 'data:text/plain,hello');
+    assert.equal(data.get('text/plain'), 'hello');
+
+    data.clear();
+    attach(transfer, [{ name: 'a.bin', url: 'https://x/a' }, { name: 'b.bin', url: 'https://x/b' }, { name: 'c' }]);
+
+    assert.equal(data.has('DownloadURL'), false);
+    assert.equal(data.get('text/uri-list'), 'https://x/a\r\nhttps://x/b');
+    assert.equal(data.get('text/plain'), 'https://x/a\nhttps://x/b\nc');
+
+    data.clear();
+    attach(transfer, [{ name: 'd.bin', url: 'blob:x' }]);
+
+    assert.equal(data.get('DownloadURL'), 'application/octet-stream:d.bin:blob:x');
+});