@joewinke/jatui 0.2.12 → 0.2.13

package/dist/dnd/createDndBoard.test.js

@@ -1,261 +0,0 @@
-var __assign = (this && this.__assign) || function () {
-    __assign = Object.assign || function(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
-                t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
-};
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __generator = (this && this.__generator) || function (thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
-    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (g && (g = 0, op[0] && (_ = 0)), _) try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [op[0] & 2, t.value];
-            switch (op[0]) {
-                case 0: case 1: t = op; break;
-                case 4: _.label++; return { value: op[1], done: false };
-                case 5: _.label++; y = op[1]; op = [0]; continue;
-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop(); continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
-    }
-};
-var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
-    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
-        if (ar || !(i in from)) {
-            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
-            ar[i] = from[i];
-        }
-    }
-    return to.concat(ar || Array.prototype.slice.call(from));
-};
-// @vitest-environment jsdom
-/**
- * Unit tests for createDndBoard internals.
- *
- * We can't exercise $effect/$state directly in vitest (no Svelte compiler context),
- * so these tests validate the pure-logic layer: sequence-token rollback ordering
- * and reseed suppression. They work by extracting the board logic functions
- * that don't depend on runes and driving them directly.
- */
-import { describe, it, expect } from 'vitest';
-import { makeItemData, isItemData } from './types';
-// ---- makeItemData / isItemData -------------------------------------------
-describe('makeItemData / isItemData', function () {
-    it('round-trips through the Symbol brand', function () {
-        var data = makeItemData({ type: 'card', key: 'a', item: { id: 'a' }, container: 'col1', index: 0 });
-        expect(isItemData(data)).toBe(true);
-        expect(isItemData(data, 'card')).toBe(true);
-        expect(isItemData(data, 'other')).toBe(false);
-    });
-    it('rejects plain objects without the brand', function () {
-        expect(isItemData({ type: 'card', key: 'a' })).toBe(false);
-    });
-    it('preserves all fields', function () {
-        var item = { id: 'x', name: 'Item X' };
-        var data = makeItemData({ type: 'board', key: 'x', item: item, container: 'c1', index: 2 });
-        expect(data.key).toBe('x');
-        expect(data.item).toBe(item);
-        expect(data.container).toBe('c1');
-        expect(data.index).toBe(2);
-    });
-});
-function makeMirror(initial) {
-    var m = new Map();
-    for (var _i = 0, _a = Object.entries(initial); _i < _a.length; _i++) {
-        var _b = _a[_i], k = _b[0], v = _b[1];
-        m.set(k, __spreadArray([], v, true));
-    }
-    return m;
-}
-function applyToMirror(mirror, move, key) {
-    var _a, _b;
-    var fromList = __spreadArray([], ((_a = mirror.get(move.from.container)) !== null && _a !== void 0 ? _a : []), true);
-    var toList = move.from.container === move.to.container
-        ? fromList
-        : __spreadArray([], ((_b = mirror.get(move.to.container)) !== null && _b !== void 0 ? _b : []), true);
-    var srcIdx = fromList.findIndex(function (it) { return key(it) === key(move.item); });
-    if (srcIdx === -1)
-        return;
-    fromList.splice(srcIdx, 1);
-    var destIdx = move.to.index;
-    if (move.from.container === move.to.container && move.to.index > move.from.index) {
-        destIdx = Math.max(0, destIdx - 1);
-    }
-    toList.splice(Math.min(destIdx, toList.length), 0, move.item);
-    mirror.set(move.from.container, fromList);
-    if (move.from.container !== move.to.container) {
-        mirror.set(move.to.container, toList);
-    }
-}
-function rollback(mirror, move, key) {
-    var _a;
-    for (var _i = 0, mirror_1 = mirror; _i < mirror_1.length; _i++) {
-        var _b = mirror_1[_i], cid = _b[0], list = _b[1];
-        var idx = list.findIndex(function (it) { return key(it) === key(move.item); });
-        if (idx !== -1) {
-            list.splice(idx, 1);
-            mirror.set(cid, list);
-            break;
-        }
-    }
-    var fromList = __spreadArray([], ((_a = mirror.get(move.from.container)) !== null && _a !== void 0 ? _a : []), true);
-    fromList.splice(Math.min(move.from.index, fromList.length), 0, move.item);
-    mirror.set(move.from.container, fromList);
-}
-var key = function (i) { return i.id; };
-var a = { id: 'a', name: 'A' };
-var b = { id: 'b', name: 'B' };
-var c = { id: 'c', name: 'C' };
-describe('applyToMirror', function () {
-    it('moves item within same container (downward)', function () {
-        var _a;
-        var mirror = makeMirror({ col: [a, b, c] });
-        applyToMirror(mirror, { item: a, from: { container: 'col', index: 0 }, to: { container: 'col', index: 2 } }, key);
-        expect((_a = mirror.get('col')) === null || _a === void 0 ? void 0 : _a.map(key)).toEqual(['b', 'a', 'c']);
-    });
-    it('moves item within same container (upward)', function () {
-        var _a;
-        var mirror = makeMirror({ col: [a, b, c] });
-        applyToMirror(mirror, { item: c, from: { container: 'col', index: 2 }, to: { container: 'col', index: 0 } }, key);
-        expect((_a = mirror.get('col')) === null || _a === void 0 ? void 0 : _a.map(key)).toEqual(['c', 'a', 'b']);
-    });
-    it('moves item across containers', function () {
-        var _a, _b;
-        var mirror = makeMirror({ col1: [a, b], col2: [c] });
-        applyToMirror(mirror, { item: b, from: { container: 'col1', index: 1 }, to: { container: 'col2', index: 0 } }, key);
-        expect((_a = mirror.get('col1')) === null || _a === void 0 ? void 0 : _a.map(key)).toEqual(['a']);
-        expect((_b = mirror.get('col2')) === null || _b === void 0 ? void 0 : _b.map(key)).toEqual(['b', 'c']);
-    });
-});
-describe('rollback', function () {
-    it('restores item to its original position', function () {
-        var _a;
-        var mirror = makeMirror({ col: [b, c, a] });
-        rollback(mirror, { item: a, from: { container: 'col', index: 0 } }, key);
-        expect((_a = mirror.get('col')) === null || _a === void 0 ? void 0 : _a.map(key)).toEqual(['a', 'b', 'c']);
-    });
-    it('restores item from a different container', function () {
-        var _a, _b;
-        var mirror = makeMirror({ col1: [b], col2: [a, c] });
-        rollback(mirror, { item: a, from: { container: 'col1', index: 0 } }, key);
-        expect((_a = mirror.get('col1')) === null || _a === void 0 ? void 0 : _a.map(key)).toEqual(['a', 'b']);
-        expect((_b = mirror.get('col2')) === null || _b === void 0 ? void 0 : _b.map(key)).toEqual(['c']);
-    });
-});
-describe('sequence-token rollback ordering', function () {
-    it('does not rollback when a newer commit has already completed', function () { return __awaiter(void 0, void 0, void 0, function () {
-        var seq, mirror, move1, move2, token1, token2, shouldRollbackMove1, shouldRollbackMove2;
-        var _a, _b;
-        return __generator(this, function (_c) {
-            seq = new Map();
-            mirror = makeMirror({ col1: [a, b], col2: [c] });
-            move1 = { item: a, from: { container: 'col1', index: 0 }, to: { container: 'col2', index: 0 } };
-            move2 = { item: a, from: { container: 'col2', index: 0 }, to: { container: 'col1', index: 0 } };
-            token1 = ((_a = seq.get('a')) !== null && _a !== void 0 ? _a : 0) + 1;
-            seq.set('a', token1);
-            applyToMirror(mirror, move1, key);
-            token2 = ((_b = seq.get('a')) !== null && _b !== void 0 ? _b : 0) + 1;
-            seq.set('a', token2);
-            applyToMirror(mirror, __assign(__assign({}, move2), { from: { container: 'col2', index: 0 } }), key);
-            shouldRollbackMove1 = seq.get('a') === token1;
-            expect(shouldRollbackMove1).toBe(false);
-            shouldRollbackMove2 = seq.get('a') === token2;
-            expect(shouldRollbackMove2).toBe(true);
-            return [2 /*return*/];
-        });
-    }); });
-    it('does rollback when this is the newest commit of the item', function () { return __awaiter(void 0, void 0, void 0, function () {
-        var seq, mirror, move1, token1, shouldRollback;
-        var _a, _b, _c;
-        return __generator(this, function (_d) {
-            seq = new Map();
-            mirror = makeMirror({ col1: [a, b], col2: [c] });
-            move1 = { item: a, from: { container: 'col1', index: 0 }, to: { container: 'col2', index: 0 } };
-            token1 = ((_a = seq.get('a')) !== null && _a !== void 0 ? _a : 0) + 1;
-            seq.set('a', token1);
-            applyToMirror(mirror, move1, key);
-            shouldRollback = seq.get('a') === token1;
-            expect(shouldRollback).toBe(true);
-            if (shouldRollback) {
-                rollback(mirror, move1, key);
-            }
-            expect((_b = mirror.get('col1')) === null || _b === void 0 ? void 0 : _b.map(key)).toContain('a');
-            expect((_c = mirror.get('col2')) === null || _c === void 0 ? void 0 : _c.map(key)).not.toContain('a');
-            return [2 /*return*/];
-        });
-    }); });
-});
-describe('reseed suppression', function () {
-    it('suppresses reseed while dragging and applies it after', function () {
-        var seedCalled = 0;
-        var dragging = true;
-        var inFlight = 0;
-        var seedQueued = false;
-        function maybeSeed() {
-            if (dragging || inFlight > 0) {
-                seedQueued = true;
-                return;
-            }
-            seedCalled++;
-            seedQueued = false;
-        }
-        maybeSeed();
-        expect(seedCalled).toBe(0);
-        expect(seedQueued).toBe(true);
-        dragging = false;
-        if (inFlight === 0 && seedQueued && !dragging) {
-            seedCalled++;
-            seedQueued = false;
-        }
-        expect(seedCalled).toBe(1);
-        expect(seedQueued).toBe(false);
-    });
-    it('suppresses reseed while commits in-flight and applies after all settle', function () {
-        var seedCalled = 0;
-        var dragging = false;
-        var inFlight = 2;
-        var seedQueued = false;
-        function tryFlush() {
-            if (inFlight === 0 && seedQueued && !dragging) {
-                seedCalled++;
-                seedQueued = false;
-            }
-        }
-        if (dragging || inFlight > 0) {
-            seedQueued = true;
-        }
-        expect(seedQueued).toBe(true);
-        inFlight--;
-        tryFlush();
-        expect(seedCalled).toBe(0);
-        inFlight--;
-        tryFlush();
-        expect(seedCalled).toBe(1);
-    });
-});