@joewinke/jatui 0.1.28 → 0.1.30

package/dist/components/session-nav/transcriptModel.js

@@ -22,17 +22,6 @@
  *                 transcript shows just the headline by default and the body is
  *                 a drill-down. This is what keeps the left column readable.
  */
-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);
-};
 export function rawTypeToState(raw) {
     switch (raw) {
         case 'needs_input':
@@ -48,28 +37,27 @@ export function rawTypeToState(raw) {
 }
 /** Detect a `jat-signal <type> '<json>'` invocation in a tool-call body. */
 function parseSignalBody(body) {
-    var m = body.match(/jat-signal\s+(starting|working|needs_input|review|completing|complete|completed|paused|idle)\b/);
+    const m = body.match(/jat-signal\s+(starting|working|needs_input|review|completing|complete|completed|paused|idle)\b/);
     if (!m)
         return null;
-    var label = '';
-    var pick = body.match(/"(?:approach|question|reviewFocus|currentStep|summary|reason|taskTitle)"\s*:\s*"([^"]{3,90})/);
+    let label = '';
+    const pick = body.match(/"(?:approach|question|reviewFocus|currentStep|summary|reason|taskTitle)"\s*:\s*"([^"]{3,90})/);
     if (pick)
         label = pick[1];
-    return { rawType: m[1], label: label };
+    return { rawType: m[1], label };
 }
 /** Build the linked model from rendered transcript lines. */
 export function buildLinkedSession(lines) {
-    var items = [];
-    var emits = [];
-    var cur = null;
-    var flush = function () {
+    const items = [];
+    const emits = [];
+    let cur = null;
+    const flush = () => {
         if (cur) {
-            items.push(__assign(__assign({ id: items.length }, cur), { signalId: null }));
+            items.push({ id: items.length, ...cur, signalId: null });
             cur = null;
         }
     };
-    for (var _i = 0, lines_1 = lines; _i < lines_1.length; _i++) {
-        var line = lines_1[_i];
+    for (const line of lines) {
         if (!line.trim()) {
             flush();
             continue;
@@ -80,8 +68,8 @@ export function buildLinkedSession(lines) {
             continue;
         }
         if (line.startsWith('⏺ ')) {
-            var body = line.slice(2);
-            var sig = parseSignalBody(body);
+            const body = line.slice(2);
+            const sig = parseSignalBody(body);
             if (sig) {
                 // signal emission = boundary; consume it, don't render as an item
                 flush();
@@ -93,7 +81,7 @@ export function buildLinkedSession(lines) {
             continue;
         }
         if (line.startsWith('  ⎿ ')) {
-            var body = line.slice(4);
+            const body = line.slice(4);
             if (cur) {
                 cur.detail.push(body);
                 cur.srcLines++;
@@ -102,7 +90,7 @@ export function buildLinkedSession(lines) {
         }
         if (line.startsWith('   ')) {
             // continuation: tool detail for actions, prose for prompt/assistant
-            var body = line.trimStart();
+            const body = line.trimStart();
             if (cur && cur.kind === 'action') {
                 cur.detail.push(body);
                 cur.srcLines++;
@@ -125,21 +113,21 @@ export function buildLinkedSession(lines) {
     }
     flush();
     // Build signal nodes from emission boundaries.
-    var signals = [];
-    var prevBoundary = -1;
-    emits.forEach(function (e, i) {
-        var rowStart = Math.max(0, prevBoundary + 1);
-        var rowEnd = Math.max(rowStart, e.afterIdx);
-        var lineCount = 0;
-        for (var k = rowStart; k <= rowEnd && k < items.length; k++)
+    const signals = [];
+    let prevBoundary = -1;
+    emits.forEach((e, i) => {
+        const rowStart = Math.max(0, prevBoundary + 1);
+        const rowEnd = Math.max(rowStart, e.afterIdx);
+        let lineCount = 0;
+        for (let k = rowStart; k <= rowEnd && k < items.length; k++)
             lineCount += items[k].srcLines;
         signals.push({
-            id: "sig-".concat(i),
+            id: `sig-${i}`,
             state: rawTypeToState(e.rawType),
             rawType: e.rawType,
             label: e.label,
-            rowStart: rowStart,
-            rowEnd: rowEnd,
+            rowStart,
+            rowEnd,
             lineCount: Math.max(1, lineCount),
             // No WorkBlock substrate data in the raw-lines path
             blockId: null,
@@ -151,13 +139,12 @@ export function buildLinkedSession(lines) {
         });
         prevBoundary = e.afterIdx;
     });
-    for (var _a = 0, signals_1 = signals; _a < signals_1.length; _a++) {
-        var sig = signals_1[_a];
-        for (var k = sig.rowStart; k <= sig.rowEnd && k < items.length; k++) {
+    for (const sig of signals) {
+        for (let k = sig.rowStart; k <= sig.rowEnd && k < items.length; k++) {
             items[k].signalId = sig.id;
         }
     }
-    return { items: items, signals: signals };
+    return { items, signals };
 }
 /**
  * Build a LinkedSession from the WorkBlock substrate (B1).
@@ -175,49 +162,45 @@ export function buildLinkedSession(lines) {
  */
 export function buildLinkedSessionFromWork(blocks, items) {
     // Map WorkTranscriptItem → TranscriptItem (blockId → signalId mapping happens after)
-    var transcriptItems = items.map(function (it) { return ({
+    const transcriptItems = items.map((it) => ({
         id: it.id,
         kind: it.kind,
         headline: it.headline,
         detail: it.detail,
         srcLines: it.srcLines,
         signalId: null // filled in below
-    }); });
+    }));
     // Map WorkBlock → SignalNode
-    var signals = blocks.map(function (blk) {
-        var _a, _b, _c;
-        return ({
-            id: blk.id,
-            state: rawTypeToState(blk.signal.type),
-            rawType: blk.signal.type,
-            label: blk.signal.label,
-            rowStart: blk.itemRange.start,
-            rowEnd: blk.itemRange.end,
-            lineCount: blk.lineCount,
-            // WorkBlock substrate fields
-            blockId: blk.id,
-            summary: blk.summary,
-            filesTouched: blk.filesTouched,
-            commits: (_a = blk.commits) !== null && _a !== void 0 ? _a : [],
-            linesAdded: (_b = blk.linesAdded) !== null && _b !== void 0 ? _b : 0,
-            linesRemoved: (_c = blk.linesRemoved) !== null && _c !== void 0 ? _c : 0
-        });
-    });
+    const signals = blocks.map((blk) => ({
+        id: blk.id,
+        state: rawTypeToState(blk.signal.type),
+        rawType: blk.signal.type,
+        label: blk.signal.label,
+        rowStart: blk.itemRange.start,
+        rowEnd: blk.itemRange.end,
+        lineCount: blk.lineCount,
+        // WorkBlock substrate fields
+        blockId: blk.id,
+        summary: blk.summary,
+        filesTouched: blk.filesTouched,
+        commits: blk.commits ?? [],
+        linesAdded: blk.linesAdded ?? 0,
+        linesRemoved: blk.linesRemoved ?? 0
+    }));
     // Assign signalId to transcript items via block ownership
-    for (var _i = 0, signals_2 = signals; _i < signals_2.length; _i++) {
-        var sig = signals_2[_i];
-        for (var k = sig.rowStart; k <= sig.rowEnd && k < transcriptItems.length; k++) {
+    for (const sig of signals) {
+        for (let k = sig.rowStart; k <= sig.rowEnd && k < transcriptItems.length; k++) {
             transcriptItems[k].signalId = sig.id;
         }
     }
-    return { items: transcriptItems, signals: signals };
+    return { items: transcriptItems, signals };
 }
 /**
  * A baked, realistic sample so /sankey always demos beautifully even with no live
  * session. Authored as raw transcript lines with real `jat-signal` calls, so it
  * flows through the EXACT same parser as live data.
  */
-export var SAMPLE_TRANSCRIPT_LINES = [
+export const SAMPLE_TRANSCRIPT_LINES = [
     '',
     '› /jat:start GentleCoast jat-7h2k',
     '⏺ Bash(get-current-session-id)',

package/dist/data/emojis.js

@@ -3,7 +3,7 @@
  * Each emoji has a character and searchable name.
  * Based on Unicode CLDR emoji ordering, minus most flags.
  */
-export var EMOJI_DATA = [
+export const EMOJI_DATA = [
     {
         label: 'Smileys & Emotion',
         emojis: [
@@ -1186,11 +1186,11 @@ export var EMOJI_DATA = [
     },
 ];
 /** Flat array of all emojis for search */
-export var ALL_EMOJIS = EMOJI_DATA.flatMap(function (g) { return g.emojis; });
+export const ALL_EMOJIS = EMOJI_DATA.flatMap((g) => g.emojis);
 /** Search emojis by name, returns matching entries */
 export function searchEmojis(query) {
     if (!query.trim())
         return [];
-    var terms = query.toLowerCase().split(/\s+/);
-    return ALL_EMOJIS.filter(function (e) { return terms.every(function (t) { return e.name.includes(t); }); });
+    const terms = query.toLowerCase().split(/\s+/);
+    return ALL_EMOJIS.filter((e) => terms.every((t) => e.name.includes(t)));
 }

package/dist/dnd/DropIndicator.svelte

@@ -0,0 +1,119 @@
+<script lang="ts">
+	/**
+	 * Drop-edge indicator — Svelte port of pdnd's react-drop-indicator Line.
+	 * Render conditionally: {#if closestEdge}<DropIndicator edge={closestEdge} gap="0.5rem" />{/if}
+	 * Host item wrapper MUST be `position: relative`.
+	 */
+	import type { Edge } from './types';
+
+	let {
+		edge,
+		gap = '0px',
+		indent = '0px',
+		type = 'terminal',
+		appearance = 'default',
+	}: {
+		edge: Edge;
+		gap?: string;
+		indent?: string;
+		type?: 'terminal' | 'no-terminal' | 'terminal-no-bleed';
+		appearance?: 'default' | 'warning';
+	} = $props();
+
+	const orientation = $derived(edge === 'top' || edge === 'bottom' ? 'horizontal' : 'vertical');
+
+	const lineMainAxisStart = $derived(
+		type === 'terminal'
+			? `calc(var(--terminal-radius) + ${indent})`
+			: type === 'terminal-no-bleed'
+				? `calc(var(--terminal-diameter) + ${indent})`
+				: indent,
+	);
+</script>
+
+<div
+	class="drop-indicator {orientation} edge-{edge}"
+	style:--stroke-color={appearance === 'warning' ? 'var(--color-warning)' : 'var(--color-primary)'}
+	style:--main-axis-offset="calc(-0.5 * ({gap} + var(--stroke-width)))"
+	style:--line-main-axis-start={lineMainAxisStart}
+	style:--terminal-display={type === 'no-terminal' ? 'none' : 'block'}
+></div>
+
+<style>
+	.drop-indicator {
+		--stroke-width: 2px;
+		--terminal-diameter: calc(var(--stroke-width) * 4);
+		--terminal-radius: calc(var(--terminal-diameter) / 2);
+		--terminal-main-axis-start: calc(-1 * var(--terminal-diameter));
+		--terminal-cross-axis-offset: calc((var(--stroke-width) - var(--terminal-diameter)) / 2);
+
+		display: block;
+		position: absolute;
+		z-index: 1;
+		pointer-events: none;
+		background: var(--stroke-color);
+	}
+
+	.drop-indicator::before {
+		display: var(--terminal-display);
+		content: '';
+		position: absolute;
+		box-sizing: border-box;
+		width: var(--terminal-diameter);
+		height: var(--terminal-diameter);
+		border: var(--stroke-width) solid var(--stroke-color);
+		border-radius: 50%;
+	}
+
+	.horizontal {
+		height: var(--stroke-width);
+		inset-inline-start: var(--line-main-axis-start);
+		inset-inline-end: 0;
+	}
+
+	.horizontal::before {
+		inset-inline-start: var(--terminal-main-axis-start);
+	}
+
+	.vertical {
+		width: var(--stroke-width);
+		top: var(--line-main-axis-start);
+		bottom: 0;
+	}
+
+	.vertical::before {
+		top: var(--terminal-main-axis-start);
+	}
+
+	.edge-top {
+		top: var(--main-axis-offset);
+	}
+
+	.edge-top::before {
+		top: var(--terminal-cross-axis-offset);
+	}
+
+	.edge-bottom {
+		bottom: var(--main-axis-offset);
+	}
+
+	.edge-bottom::before {
+		bottom: var(--terminal-cross-axis-offset);
+	}
+
+	.edge-left {
+		left: var(--main-axis-offset);
+	}
+
+	.edge-left::before {
+		left: var(--terminal-cross-axis-offset);
+	}
+
+	.edge-right {
+		right: var(--main-axis-offset);
+	}
+
+	.edge-right::before {
+		right: var(--terminal-cross-axis-offset);
+	}
+</style>

package/dist/dnd/DropIndicator.svelte.d.ts

@@ -0,0 +1,16 @@
+/**
+     * Drop-edge indicator — Svelte port of pdnd's react-drop-indicator Line.
+     * Render conditionally: {#if closestEdge}<DropIndicator edge={closestEdge} gap="0.5rem" />{/if}
+     * Host item wrapper MUST be `position: relative`.
+     */
+import type { Edge } from './types';
+type $$ComponentProps = {
+    edge: Edge;
+    gap?: string;
+    indent?: string;
+    type?: 'terminal' | 'no-terminal' | 'terminal-no-bleed';
+    appearance?: 'default' | 'warning';
+};
+declare const DropIndicator: import("svelte").Component<$$ComponentProps, {}, "">;
+type DropIndicator = ReturnType<typeof DropIndicator>;
+export default DropIndicator;

package/dist/dnd/announce.d.ts

@@ -0,0 +1 @@
+export { announce, cleanup as cleanupAnnouncements } from '@atlaskit/pragmatic-drag-and-drop-live-region';

package/dist/dnd/announce.js

@@ -0,0 +1 @@
+export { announce, cleanup as cleanupAnnouncements } from '@atlaskit/pragmatic-drag-and-drop-live-region';

package/dist/dnd/autoScroll.d.ts

@@ -0,0 +1,7 @@
+import type { Action } from 'svelte/action';
+export interface AutoScrollParams {
+    types?: string[];
+    axis?: 'vertical' | 'horizontal' | 'all';
+    speed?: 'standard' | 'fast';
+}
+export declare const autoScroll: Action<HTMLElement, AutoScrollParams | undefined>;

package/dist/dnd/autoScroll.js

@@ -0,0 +1,25 @@
+import { autoScrollForElements } from '@atlaskit/pragmatic-drag-and-drop-auto-scroll/element';
+export const autoScroll = (node, params) => {
+    let current = params ?? {};
+    function register() {
+        return autoScrollForElements({
+            element: node,
+            canScroll: ({ source }) => {
+                if (!current.types?.length)
+                    return true;
+                return current.types.includes(source.data.type);
+            },
+            getAllowedAxis: () => current.axis ?? 'all',
+            getConfiguration: () => ({ maxScrollSpeed: current.speed ?? 'standard' }),
+        });
+    }
+    let cleanup = register();
+    return {
+        update(next) {
+            current = next ?? {};
+            cleanup();
+            cleanup = register();
+        },
+        destroy: () => cleanup(),
+    };
+};

package/dist/dnd/createDndBoard.svelte.d.ts

@@ -0,0 +1,43 @@
+import type { Edge } from '@atlaskit/pragmatic-drag-and-drop-hitbox/closest-edge';
+import { type ItemDragData, type ContainerDropData } from './types';
+import type { DraggableParams } from './draggable';
+import type { DropTargetParams } from './dropTarget';
+export interface BoardMove<TItem> {
+    item: TItem;
+    from: {
+        container: string;
+        index: number;
+    };
+    to: {
+        container: string;
+        index: number;
+    };
+}
+export interface DndBoardOptions<TItem> {
+    type: string;
+    items: () => ReadonlyMap<string, readonly TItem[]> | Record<string, readonly TItem[]>;
+    key: (item: TItem) => string;
+    commit: (move: BoardMove<TItem>) => Promise<void>;
+    onError?: (error: unknown, move: BoardMove<TItem>) => void;
+    announce?: (move: BoardMove<TItem>) => string;
+    hover?: 'indicator' | 'shadow';
+    edges?: Edge[];
+}
+export declare function createDndBoard<TItem>(opts: DndBoardOptions<TItem>): {
+    get: (container: string) => readonly TItem[];
+    containers: () => string[];
+    readonly dragging: {
+        key: string;
+        item: TItem;
+        from: BoardMove<TItem>["from"];
+    } | null;
+    readonly proposal: {
+        container: string;
+        index: number;
+    } | null;
+    isSource: (item: TItem) => boolean;
+    isShadow: (item: TItem) => boolean;
+    item: (item: TItem, container: string, index: number) => DraggableParams<ItemDragData<TItem>>;
+    itemTarget: (container: string, index: number) => DropTargetParams<ContainerDropData>;
+    containerTarget: (container: string) => DropTargetParams<ContainerDropData>;
+};

package/dist/dnd/createDndBoard.svelte.js

@@ -0,0 +1,183 @@
+import { monitorForElements } from '@atlaskit/pragmatic-drag-and-drop/element/adapter';
+import { extractClosestEdge, attachClosestEdge, } from '@atlaskit/pragmatic-drag-and-drop-hitbox/closest-edge';
+import { SvelteMap } from 'svelte/reactivity';
+import { announce } from './announce';
+import { makeItemData, isItemData, } from './types';
+const SHADOW_KEY = '__dnd-shadow__';
+export function createDndBoard(opts) {
+    const edges = opts.edges ?? ['top', 'bottom'];
+    const hover = opts.hover ?? 'indicator';
+    const mirror = new SvelteMap();
+    let dragging = $state(null);
+    let proposal = $state(null);
+    const seq = new Map();
+    let inFlight = 0;
+    let seedQueued = false;
+    function seed() {
+        mirror.clear();
+        const src = opts.items();
+        const entries = src instanceof Map
+            ? src
+            : new Map(Object.entries(src));
+        for (const [id, list] of entries)
+            mirror.set(id, [...list]);
+    }
+    $effect(() => {
+        opts.items();
+        if (dragging || inFlight > 0) {
+            seedQueued = true;
+            return;
+        }
+        seed();
+    });
+    function placementFrom(dropTargets) {
+        const inner = dropTargets[0];
+        if (!inner)
+            return null;
+        const d = inner.data;
+        if (typeof d.container !== 'string')
+            return null;
+        const list = mirror.get(d.container) ?? [];
+        if (typeof d.index !== 'number')
+            return { container: d.container, index: list.length };
+        const edge = extractClosestEdge(d);
+        const after = edge === 'bottom' || edge === 'right';
+        return { container: d.container, index: d.index + (after ? 1 : 0) };
+    }
+    function syncShadow(next) {
+        for (const [cid, list] of mirror) {
+            const idx = list.findIndex((item) => item[SHADOW_KEY]);
+            if (idx !== -1) {
+                list.splice(idx, 1);
+                mirror.set(cid, list);
+                break;
+            }
+        }
+        if (!next || !dragging)
+            return;
+        const list = [...(mirror.get(next.container) ?? [])];
+        const shadowItem = { [SHADOW_KEY]: true, key: `${SHADOW_KEY}-${dragging.key}` };
+        list.splice(Math.min(next.index, list.length), 0, shadowItem);
+        mirror.set(next.container, list);
+    }
+    function consider(next) {
+        if (next?.container === proposal?.container && next?.index === proposal?.index)
+            return;
+        proposal = next;
+        if (hover === 'shadow')
+            syncShadow(next);
+    }
+    function applyToMirror(move) {
+        const fromList = [...(mirror.get(move.from.container) ?? [])];
+        const toList = move.from.container === move.to.container
+            ? fromList
+            : [...(mirror.get(move.to.container) ?? [])];
+        const srcIdx = fromList.findIndex((it) => opts.key(it) === opts.key(move.item));
+        if (srcIdx === -1)
+            return;
+        fromList.splice(srcIdx, 1);
+        let 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(move) {
+        for (const [cid, list] of mirror) {
+            const idx = list.findIndex((it) => opts.key(it) === opts.key(move.item));
+            if (idx !== -1) {
+                list.splice(idx, 1);
+                mirror.set(cid, list);
+                break;
+            }
+        }
+        const fromList = [...(mirror.get(move.from.container) ?? [])];
+        fromList.splice(Math.min(move.from.index, fromList.length), 0, move.item);
+        mirror.set(move.from.container, fromList);
+    }
+    function finalize(dropped) {
+        const drag = dragging;
+        const to = dropped ? proposal : null;
+        dragging = null;
+        consider(null);
+        if (!drag)
+            return;
+        if (!to ||
+            (to.container === drag.from.container && to.index === drag.from.index)) {
+            if (seedQueued && inFlight === 0) {
+                seedQueued = false;
+                seed();
+            }
+            return;
+        }
+        const move = { item: drag.item, from: drag.from, to };
+        applyToMirror(move);
+        if (opts.announce)
+            announce(opts.announce(move));
+        const token = (seq.get(drag.key) ?? 0) + 1;
+        seq.set(drag.key, token);
+        inFlight++;
+        opts
+            .commit(move)
+            .catch((error) => {
+            if (seq.get(drag.key) === token)
+                rollback(move);
+            opts.onError?.(error, move);
+        })
+            .finally(() => {
+            inFlight--;
+            if (inFlight === 0 && seedQueued && !dragging) {
+                seedQueued = false;
+                seed();
+            }
+        });
+    }
+    $effect(() => monitorForElements({
+        canMonitor: ({ source }) => isItemData(source.data, opts.type),
+        onDragStart({ source }) {
+            const d = source.data;
+            dragging = {
+                key: d.key,
+                item: d.item,
+                from: { container: d.container, index: d.index },
+            };
+        },
+        onDropTargetChange({ location }) {
+            consider(placementFrom(location.current.dropTargets));
+        },
+        onDrag({ location }) {
+            consider(placementFrom(location.current.dropTargets));
+        },
+        onDrop({ location }) {
+            finalize(location.current.dropTargets.length > 0);
+        },
+    }));
+    return {
+        get: (container) => mirror.get(container) ?? [],
+        containers: () => [...mirror.keys()],
+        get dragging() {
+            return dragging;
+        },
+        get proposal() {
+            return proposal;
+        },
+        isSource: (item) => dragging?.key === opts.key(item),
+        isShadow: (item) => !!item[SHADOW_KEY],
+        item: (item, container, index) => ({
+            data: () => makeItemData({ type: opts.type, key: opts.key(item), item, container, index }),
+        }),
+        itemTarget: (container, index) => ({
+            data: (feedback) => attachClosestEdge({ type: `${opts.type}-target`, container, index }, { input: feedback.input, element: feedback.element, allowedEdges: edges }),
+            accepts: (d) => isItemData(d, opts.type),
+            sticky: true,
+        }),
+        containerTarget: (container) => ({
+            data: () => ({ type: `${opts.type}-target`, container }),
+            accepts: (d) => isItemData(d, opts.type),
+        }),
+    };
+}

package/dist/dnd/createDndBoard.test.d.ts

@@ -0,0 +1 @@
+export {};