@joewinke/jatui 0.1.31 → 0.1.33

package/dist/dnd/createDndBoard.test.js

@@ -1,3 +1,59 @@
+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.
@@ -7,22 +63,22 @@
  * 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, vi, beforeEach } from 'vitest';
+import { describe, it, expect } from 'vitest';
 import { makeItemData, isItemData } from './types';
 // ---- makeItemData / isItemData -------------------------------------------
-describe('makeItemData / isItemData', () => {
-    it('round-trips through the Symbol brand', () => {
-        const data = makeItemData({ type: 'card', key: 'a', item: { id: 'a' }, container: 'col1', index: 0 });
+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', () => {
+    it('rejects plain objects without the brand', function () {
         expect(isItemData({ type: 'card', key: 'a' })).toBe(false);
     });
-    it('preserves all fields', () => {
-        const item = { id: 'x', name: 'Item X' };
-        const data = makeItemData({ type: 'board', key: 'x', item, container: 'c1', index: 2 });
+    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');
@@ -30,21 +86,24 @@ describe('makeItemData / isItemData', () => {
     });
 });
 function makeMirror(initial) {
-    const m = new Map();
-    for (const [k, v] of Object.entries(initial))
-        m.set(k, [...v]);
+    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) {
-    const fromList = [...(mirror.get(move.from.container) ?? [])];
-    const toList = move.from.container === move.to.container
+    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
-        : [...(mirror.get(move.to.container) ?? [])];
-    const srcIdx = fromList.findIndex((it) => key(it) === key(move.item));
+        : __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);
-    let destIdx = move.to.index;
+    var destIdx = move.to.index;
     if (move.from.container === move.to.container && move.to.index > move.from.index) {
         destIdx = Math.max(0, destIdx - 1);
     }
@@ -55,92 +114,109 @@ function applyToMirror(mirror, move, key) {
     }
 }
 function rollback(mirror, move, key) {
-    for (const [cid, list] of mirror) {
-        const idx = list.findIndex((it) => key(it) === key(move.item));
+    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;
         }
     }
-    const fromList = [...(mirror.get(move.from.container) ?? [])];
+    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);
 }
-const key = (i) => i.id;
-const a = { id: 'a', name: 'A' };
-const b = { id: 'b', name: 'B' };
-const c = { id: 'c', name: 'C' };
-describe('applyToMirror', () => {
-    it('moves item within same container (downward)', () => {
-        const mirror = makeMirror({ col: [a, b, c] });
+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(mirror.get('col')?.map(key)).toEqual(['b', 'a', 'c']);
+        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)', () => {
-        const mirror = makeMirror({ col: [a, b, 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(mirror.get('col')?.map(key)).toEqual(['c', 'a', 'b']);
+        expect((_a = mirror.get('col')) === null || _a === void 0 ? void 0 : _a.map(key)).toEqual(['c', 'a', 'b']);
     });
-    it('moves item across containers', () => {
-        const mirror = makeMirror({ col1: [a, b], col2: [c] });
+    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(mirror.get('col1')?.map(key)).toEqual(['a']);
-        expect(mirror.get('col2')?.map(key)).toEqual(['b', 'c']);
+        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', () => {
-    it('restores item to its original position', () => {
-        const mirror = makeMirror({ col: [b, c, a] });
+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(mirror.get('col')?.map(key)).toEqual(['a', 'b', 'c']);
+        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', () => {
-        const mirror = makeMirror({ col1: [b], col2: [a, 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(mirror.get('col1')?.map(key)).toEqual(['a', 'b']);
-        expect(mirror.get('col2')?.map(key)).toEqual(['c']);
+        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', () => {
-    it('does not rollback when a newer commit has already completed', async () => {
-        const seq = new Map();
-        const mirror = makeMirror({ col1: [a, b], col2: [c] });
-        const move1 = { item: a, from: { container: 'col1', index: 0 }, to: { container: 'col2', index: 0 } };
-        const move2 = { item: a, from: { container: 'col2', index: 0 }, to: { container: 'col1', index: 0 } };
-        const token1 = (seq.get('a') ?? 0) + 1;
-        seq.set('a', token1);
-        applyToMirror(mirror, move1, key);
-        const token2 = (seq.get('a') ?? 0) + 1;
-        seq.set('a', token2);
-        applyToMirror(mirror, { ...move2, from: { container: 'col2', index: 0 } }, key);
-        const shouldRollbackMove1 = seq.get('a') === token1;
-        expect(shouldRollbackMove1).toBe(false);
-        const shouldRollbackMove2 = seq.get('a') === token2;
-        expect(shouldRollbackMove2).toBe(true);
-    });
-    it('does rollback when this is the newest commit of the item', async () => {
-        const seq = new Map();
-        const mirror = makeMirror({ col1: [a, b], col2: [c] });
-        const move1 = { item: a, from: { container: 'col1', index: 0 }, to: { container: 'col2', index: 0 } };
-        const token1 = (seq.get('a') ?? 0) + 1;
-        seq.set('a', token1);
-        applyToMirror(mirror, move1, key);
-        const shouldRollback = seq.get('a') === token1;
-        expect(shouldRollback).toBe(true);
-        if (shouldRollback) {
-            rollback(mirror, move1, key);
-        }
-        expect(mirror.get('col1')?.map(key)).toContain('a');
-        expect(mirror.get('col2')?.map(key)).not.toContain('a');
-    });
+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', () => {
-    it('suppresses reseed while dragging and applies it after', () => {
-        let seedCalled = 0;
-        let dragging = true;
-        let inFlight = 0;
-        let seedQueued = false;
+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;
@@ -160,11 +236,11 @@ describe('reseed suppression', () => {
         expect(seedCalled).toBe(1);
         expect(seedQueued).toBe(false);
     });
-    it('suppresses reseed while commits in-flight and applies after all settle', () => {
-        let seedCalled = 0;
-        let dragging = false;
-        let inFlight = 2;
-        let seedQueued = 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++;

package/dist/dnd/draggable.js

@@ -1,42 +1,50 @@
 import { draggable as registerDraggable } from '@atlaskit/pragmatic-drag-and-drop/element/adapter';
 import { setCustomNativeDragPreview } from '@atlaskit/pragmatic-drag-and-drop/element/set-custom-native-drag-preview';
-export const draggable = ((node, params) => {
-    let current = params;
-    let cleanup;
+export var draggable = (function (node, params) {
+    var current = params;
+    var cleanup;
     function register() {
         cleanup = registerDraggable({
             element: node,
             dragHandle: current.dragHandle,
-            canDrag: () => !(current.disabled?.() ?? false),
-            getInitialData: () => current.data(),
-            onGenerateDragPreview({ source, nativeSetDragImage }) {
+            canDrag: function () { var _a, _b; return !((_b = (_a = current.disabled) === null || _a === void 0 ? void 0 : _a.call(current)) !== null && _b !== void 0 ? _b : false); },
+            getInitialData: function () { return current.data(); },
+            onGenerateDragPreview: function (_a) {
+                var source = _a.source, nativeSetDragImage = _a.nativeSetDragImage;
                 if (!current.preview)
                     return;
                 setCustomNativeDragPreview({
-                    render: ({ container }) => current.preview(container, source.data),
-                    nativeSetDragImage,
+                    render: function (_a) {
+                        var container = _a.container;
+                        return current.preview(container, source.data);
+                    },
+                    nativeSetDragImage: nativeSetDragImage,
                 });
             },
-            onDragStart({ source }) {
+            onDragStart: function (_a) {
+                var _b;
+                var source = _a.source;
                 node.dataset.dragging = 'true';
-                current.onDragStart?.(source.data);
+                (_b = current.onDragStart) === null || _b === void 0 ? void 0 : _b.call(current, source.data);
             },
-            onDrop({ source }) {
+            onDrop: function (_a) {
+                var _b;
+                var source = _a.source;
                 delete node.dataset.dragging;
-                current.onDrop?.(source.data);
+                (_b = current.onDrop) === null || _b === void 0 ? void 0 : _b.call(current, source.data);
             },
         });
     }
     register();
     return {
-        update(next) {
-            const handleChanged = next.dragHandle !== current.dragHandle;
+        update: function (next) {
+            var handleChanged = next.dragHandle !== current.dragHandle;
             current = next;
             if (handleChanged) {
                 cleanup();
                 register();
             }
         },
-        destroy: () => cleanup(),
+        destroy: function () { return cleanup(); },
     };
 });

package/dist/dnd/dropTarget.js

@@ -1,29 +1,43 @@
 import { dropTargetForElements } from '@atlaskit/pragmatic-drag-and-drop/element/adapter';
-export const dropTarget = ((node, params) => {
-    let current = params;
-    const cleanup = dropTargetForElements({
+export var dropTarget = (function (node, params) {
+    var current = params;
+    var cleanup = dropTargetForElements({
         element: node,
-        getData: ({ input, element, source }) => current.data({ input, element, source }),
-        canDrop: ({ source }) => current.accepts?.(source.data) ?? true,
-        getIsSticky: () => current.sticky ?? false,
-        onDragEnter({ source }) {
+        getData: function (_a) {
+            var input = _a.input, element = _a.element, source = _a.source;
+            return current.data({ input: input, element: element, source: source });
+        },
+        canDrop: function (_a) {
+            var _b, _c;
+            var source = _a.source;
+            return (_c = (_b = current.accepts) === null || _b === void 0 ? void 0 : _b.call(current, source.data)) !== null && _c !== void 0 ? _c : true;
+        },
+        getIsSticky: function () { var _a; return (_a = current.sticky) !== null && _a !== void 0 ? _a : false; },
+        onDragEnter: function (_a) {
+            var _b;
+            var source = _a.source;
             node.dataset.dropOver = 'true';
-            current.onEnter?.(source.data);
+            (_b = current.onEnter) === null || _b === void 0 ? void 0 : _b.call(current, source.data);
         },
-        onDragLeave() {
+        onDragLeave: function () {
+            var _a;
             delete node.dataset.dropOver;
-            current.onLeave?.();
+            (_a = current.onLeave) === null || _a === void 0 ? void 0 : _a.call(current);
         },
-        onDrag({ self, source }) {
-            current.onMove?.(self.data, source.data);
+        onDrag: function (_a) {
+            var _b;
+            var self = _a.self, source = _a.source;
+            (_b = current.onMove) === null || _b === void 0 ? void 0 : _b.call(current, self.data, source.data);
         },
-        onDrop({ self, source }) {
+        onDrop: function (_a) {
+            var _b;
+            var self = _a.self, source = _a.source;
             delete node.dataset.dropOver;
-            current.onDropped?.(self.data, source.data);
+            (_b = current.onDropped) === null || _b === void 0 ? void 0 : _b.call(current, self.data, source.data);
         },
     });
     return {
-        update(next) {
+        update: function (next) {
             current = next;
         },
         destroy: cleanup,

package/dist/dnd/index.d.ts

@@ -11,4 +11,3 @@ export { announce, cleanupAnnouncements } from './announce';
 export { makeItemData, isItemData } from './types';
 export type { DragData, ItemDragData, ContainerDropData, TargetFeedback, Edge } from './types';
 export { monitorForElements } from '@atlaskit/pragmatic-drag-and-drop/element/adapter';
-export { attachClosestEdge, extractClosestEdge, } from '@atlaskit/pragmatic-drag-and-drop-hitbox/closest-edge';

package/dist/dnd/index.js

@@ -7,4 +7,3 @@ export { announce, cleanupAnnouncements } from './announce';
 export { makeItemData, isItemData } from './types';
 // Low-level pdnd primitives re-exported to let host code avoid direct @atlaskit imports
 export { monitorForElements } from '@atlaskit/pragmatic-drag-and-drop/element/adapter';
-export { attachClosestEdge, extractClosestEdge, } from '@atlaskit/pragmatic-drag-and-drop-hitbox/closest-edge';

package/dist/dnd/types.d.ts

@@ -2,16 +2,7 @@ import type { Input } from '@atlaskit/pragmatic-drag-and-drop/types';
 export interface DragData extends Record<string | symbol, unknown> {
     readonly type: string;
 }
-/**
- * Module-scoped Symbol brand for board-managed items.
- * ⚠ Symbol identity = module identity. Two copies of this module on one page makes
- * isItemData() return false across the boundary — dnd/ must exist EXACTLY ONCE.
- * Declare all @atlaskit/pragmatic-drag-and-drop* packages as peerDependencies in
- * the host app (host owns the single instance).
- */
-declare const ITEM: unique symbol;
 export interface ItemDragData<TItem = unknown> extends DragData {
-    readonly [ITEM]: true;
     readonly key: string;
     readonly item: TItem;
     readonly container: string;

package/dist/dnd/types.js

@@ -1,3 +1,14 @@
+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);
+};
 /**
  * Module-scoped Symbol brand for board-managed items.
  * ⚠ Symbol identity = module identity. Two copies of this module on one page makes
@@ -5,9 +16,10 @@
  * Declare all @atlaskit/pragmatic-drag-and-drop* packages as peerDependencies in
  * the host app (host owns the single instance).
  */
-const ITEM = Symbol('jatui-dnd-item');
+var ITEM = Symbol('jatui-dnd-item');
 export function makeItemData(args) {
-    return { ...args, [ITEM]: true };
+    var _a;
+    return __assign(__assign({}, args), (_a = {}, _a[ITEM] = true, _a));
 }
 export function isItemData(data, type) {
     return data[ITEM] === true && (type === undefined || data.type === type);

package/dist/index.d.ts

@@ -91,7 +91,7 @@ export type { Milestone, MilestoneStatus } from './types/milestone';
 export type { LocationType, BookingStatus, OverrideType, Host, EventType, WeeklyAvailability, DateOverride, Booking, BookingAttendee, TimeSlot, BookingFormData, AvailabilityCounts } from './types/booking';
 export { DAYS_OF_WEEK, DAYS_SHORT, LOCATION_LABELS, LOCATION_ICONS } from './types/booking';
 export type { ImageVariantSpec, ImageProcessingSpec, VariantResult, VariantState, } from './types/smartImageEditor';
-export { normalizeTimestamp, parseTimestamp, formatRelativeTime, formatFullDate, formatShortDate, formatLastActivity, formatDate, getTimeSinceMs, getTimeSinceMinutes, isWithinMinutes, formatDateTime, taskAge, } from './utils/dateFormatters';
+export { normalizeTimestamp, parseTimestamp, formatRelativeTime, formatFullDate, formatShortDate, formatLastActivity, formatDate, getTimeSinceMs, getTimeSinceMinutes, isWithinMinutes, formatDateTime, taskAge, pacingColor, type PacingLevel, type PacingResult, } from './utils/dateFormatters';
 export { statusColor, priorityColor, typeIcon, statusLabel, } from './utils/taskUtils';
 export { stripPhoneNumber, formatPhoneNumber, isCompletePhoneNumber, isValidPhoneNumber, updatePhoneInput } from './utils/phoneFormat';
 export { toE164, formatPhoneForDisplay, isValidPhone, listCountries, DEFAULT_COUNTRY, PRIORITY_COUNTRIES, type CountryOption, } from './utils/phone';
@@ -142,8 +142,3 @@ export { default as LocationMap } from './components/LocationMap.svelte';
 export { default as GPSTracker } from './components/GPSTracker.svelte';
 export type { MapJob, MapAgent } from './types/maps';
 export { loadGoogleMapsAPI, isGoogleMapsLoaded, isPlacesLoaded, isGeometryLoaded, } from './utils/googleMapsLoader';
-export { draggable, dropTarget, autoScroll, announce, cleanupAnnouncements, monitorForElements, attachClosestEdge, extractClosestEdge, } from './dnd/index';
-export { createDndBoard } from './dnd/createDndBoard.svelte';
-export { default as DropIndicator } from './dnd/DropIndicator.svelte';
-export { makeItemData, isItemData } from './dnd/types';
-export type { DragData, ItemDragData, ContainerDropData, TargetFeedback, Edge, DraggableParams, DropTargetParams, AutoScrollParams, BoardMove, DndBoardOptions, } from './dnd/index';

package/dist/index.js

@@ -82,7 +82,7 @@ export { default as AvailabilityModal } from './components/AvailabilityModal.sve
 export { default as BookingForm } from './components/BookingForm.svelte';
 export { DAYS_OF_WEEK, DAYS_SHORT, LOCATION_LABELS, LOCATION_ICONS } from './types/booking';
 // Utilities — date formatting
-export { normalizeTimestamp, parseTimestamp, formatRelativeTime, formatFullDate, formatShortDate, formatLastActivity, formatDate, getTimeSinceMs, getTimeSinceMinutes, isWithinMinutes, formatDateTime, taskAge, } from './utils/dateFormatters';
+export { normalizeTimestamp, parseTimestamp, formatRelativeTime, formatFullDate, formatShortDate, formatLastActivity, formatDate, getTimeSinceMs, getTimeSinceMinutes, isWithinMinutes, formatDateTime, taskAge, pacingColor, } from './utils/dateFormatters';
 // Utilities — task display helpers
 export { statusColor, priorityColor, typeIcon, statusLabel, } from './utils/taskUtils';
 // Utilities — phone formatting (legacy US-only)
@@ -141,8 +141,8 @@ export { default as LocationMap } from './components/LocationMap.svelte';
 export { default as GPSTracker } from './components/GPSTracker.svelte';
 // Utilities — Google Maps loader
 export { loadGoogleMapsAPI, isGoogleMapsLoaded, isPlacesLoaded, isGeometryLoaded, } from './utils/googleMapsLoader';
-// DnD — pragmatic-drag-and-drop wrappers (peerDep: @atlaskit/pragmatic-drag-and-drop*)
-export { draggable, dropTarget, autoScroll, announce, cleanupAnnouncements, monitorForElements, attachClosestEdge, extractClosestEdge, } from './dnd/index';
-export { createDndBoard } from './dnd/createDndBoard.svelte';
-export { default as DropIndicator } from './dnd/DropIndicator.svelte';
-export { makeItemData, isItemData } from './dnd/types';
+// DnD — pragmatic-drag-and-drop wrappers live behind the `@joewinke/jatui/dnd`
+// subpath export, NOT this barrel. Re-exporting them here forced every barrel
+// consumer to install the optional @atlaskit/pragmatic-drag-and-drop* peer deps
+// (and broke bundlers that stub the unresolved optional peer). Import DnD via:
+//   import { draggable, DropIndicator } from '@joewinke/jatui/dnd';

package/dist/stores/confirmDialog.svelte.js

@@ -2,7 +2,7 @@
  * Global promise-based confirm dialog.
  * Usage: const ok = await showConfirm({ title: '...', body: '...' })
  */
-let pending = $state(null);
+var pending = $state(null);
 export function getPending() {
     return pending;
 }
@@ -11,21 +11,21 @@ export function showConfirm(options) {
     if (pending) {
         pending.resolve(false);
     }
-    return new Promise((resolve) => {
-        pending = { options, resolve };
+    return new Promise(function (resolve) {
+        pending = { options: options, resolve: resolve };
     });
 }
 export function confirmDialog() {
     if (!pending)
         return;
-    const p = pending;
+    var p = pending;
     pending = null;
     p.resolve(true);
 }
 export function cancelDialog() {
     if (!pending)
         return;
-    const p = pending;
+    var p = pending;
     pending = null;
     p.resolve(false);
 }

package/dist/stores/inputDialog.svelte.js

@@ -3,7 +3,7 @@
  * Usage: const value = await showInput({ title: '...', placeholder: '...' })
  * Returns the typed string if confirmed, null if cancelled.
  */
-let pending = $state(null);
+var pending = $state(null);
 export function getPendingInput() {
     return pending;
 }
@@ -12,21 +12,21 @@ export function showInput(options) {
     if (pending) {
         pending.resolve(null);
     }
-    return new Promise((resolve) => {
-        pending = { options, resolve };
+    return new Promise(function (resolve) {
+        pending = { options: options, resolve: resolve };
     });
 }
 export function submitInput(value) {
     if (!pending)
         return;
-    const p = pending;
+    var p = pending;
     pending = null;
     p.resolve(value);
 }
 export function cancelInput() {
     if (!pending)
         return;
-    const p = pending;
+    var p = pending;
     pending = null;
     p.resolve(null);
 }