@atmos.build/ui 0.1.0

package/dist/flow/presence-motion.js

@@ -0,0 +1,88 @@
+'use client';
+import { useCallback, useEffect, useRef, useState } from 'react';
+const smoothingMs = 55;
+const coastAfterMs = 70;
+const coastForMs = 280;
+const maxCoastMs = 160;
+export function useSmoothedFlowPoints(targets) {
+    const statesRef = useRef(new Map());
+    const frameRef = useRef(null);
+    const [points, setPoints] = useState(() => new Map());
+    const publish = useCallback(() => {
+        const next = new Map();
+        for (const [id, state] of statesRef.current)
+            next.set(id, { ...state.current });
+        setPoints(next);
+    }, []);
+    const start = useCallback(() => {
+        if (frameRef.current !== null || typeof requestAnimationFrame === 'undefined')
+            return;
+        const tick = (now) => {
+            frameRef.current = null;
+            let active = false;
+            for (const state of statesRef.current.values()) {
+                const frameDeltaMs = Math.max(0, now - state.lastFrameAt);
+                state.lastFrameAt = now;
+                const sinceTargetMs = Math.max(0, now - state.lastTargetAt);
+                const coastMs = Math.min(maxCoastMs, Math.max(0, sinceTargetMs - coastAfterMs));
+                const decay = sinceTargetMs >= coastAfterMs + coastForMs ? 0 : 1 - coastMs / maxCoastMs;
+                const predicted = sinceTargetMs <= coastAfterMs
+                    ? state.target
+                    : {
+                        x: state.target.x + state.velocity.x * (coastMs / 1000) * decay,
+                        y: state.target.y + state.velocity.y * (coastMs / 1000) * decay,
+                    };
+                const alpha = 1 - Math.exp(-frameDeltaMs / smoothingMs);
+                state.current = {
+                    x: state.current.x + (predicted.x - state.current.x) * alpha,
+                    y: state.current.y + (predicted.y - state.current.y) * alpha,
+                };
+                if (Math.hypot(predicted.x - state.current.x, predicted.y - state.current.y) > 0.25 ||
+                    sinceTargetMs < coastAfterMs + coastForMs)
+                    active = true;
+            }
+            publish();
+            if (active)
+                frameRef.current = requestAnimationFrame(tick);
+        };
+        frameRef.current = requestAnimationFrame(tick);
+    }, [publish]);
+    useEffect(() => {
+        const now = typeof performance === 'undefined' ? Date.now() : performance.now();
+        const seen = new Set();
+        for (const target of targets) {
+            if (!target.point)
+                continue;
+            seen.add(target.id);
+            const state = statesRef.current.get(target.id);
+            if (!state) {
+                statesRef.current.set(target.id, {
+                    current: { ...target.point },
+                    target: { ...target.point },
+                    velocity: { x: 0, y: 0 },
+                    lastTargetAt: now,
+                    lastFrameAt: now,
+                });
+                continue;
+            }
+            const elapsedSeconds = Math.max(0.016, (now - state.lastTargetAt) / 1000);
+            state.velocity = {
+                x: (target.point.x - state.target.x) / elapsedSeconds,
+                y: (target.point.y - state.target.y) / elapsedSeconds,
+            };
+            state.target = { ...target.point };
+            state.lastTargetAt = now;
+        }
+        for (const id of statesRef.current.keys()) {
+            if (!seen.has(id))
+                statesRef.current.delete(id);
+        }
+        start();
+        return () => {
+            if (frameRef.current !== null && typeof cancelAnimationFrame !== 'undefined')
+                cancelAnimationFrame(frameRef.current);
+            frameRef.current = null;
+        };
+    }, [publish, start, targets]);
+    return points;
+}

package/dist/flow/styles.css

@@ -0,0 +1 @@
+@import 'reactflow/dist/style.css';

package/dist/flow/use-collaborative-graph.d.ts

@@ -0,0 +1,61 @@
+import type { Edge, Node } from 'reactflow';
+import { type CollaborativeGraphPatch, type CollaborativeGraphSnapshot, type CollaborativeYDoc } from './collaborative-graph-sync.js';
+import { type CollaborativeConnectionStatus, type CollaborativeGraphDrag, type CollaborativeGraphPeer } from './collaborative-graph-presence.js';
+import type { RemoteGraphPhase } from './editor/use-dag-editor.js';
+export interface CollaborativeGraphSurface {
+    readonly status: CollaborativeConnectionStatus;
+    readonly synced: boolean;
+    readonly document: unknown;
+    readonly peers: readonly {
+        connectionId: string;
+        state: unknown;
+    }[];
+    readonly updatePresence: (patch: Readonly<Record<string, unknown>>) => void;
+}
+export interface CollaborativeGraphVersion {
+    readonly key: string;
+    readonly local: string;
+    readonly shouldUseRemote: (remote: string | null, local: string) => boolean;
+}
+export interface CollaborativeGraphMetadata<TMetadata> {
+    readonly key: string;
+    readonly value: TMetadata;
+    readonly serialize: (value: TMetadata) => string;
+    readonly coerce: (value: unknown) => TMetadata;
+    readonly onRemoteChange: (value: TMetadata) => void;
+}
+export interface CollaborativeGraphOptions<TNodeData, TEdgeData, TMetadata = never> {
+    readonly enabled: boolean;
+    readonly surface: CollaborativeGraphSurface | null;
+    readonly nodes: Node<TNodeData>[];
+    readonly edges: Edge<TEdgeData>[];
+    readonly selectedNodeIds: string[];
+    readonly mapNames: {
+        nodes: string;
+        edges: string;
+    };
+    readonly stateMapName?: string;
+    readonly version?: CollaborativeGraphVersion;
+    readonly metadata?: CollaborativeGraphMetadata<TMetadata>;
+    readonly applyRemoteGraph: (snapshot: CollaborativeGraphSnapshot<TNodeData, TEdgeData>, phase: RemoteGraphPhase) => void;
+    readonly applyRemotePatch: (patch: CollaborativeGraphPatch<TNodeData, TEdgeData>, phase: RemoteGraphPhase) => void;
+    readonly graphWriteDelayMs?: number;
+    readonly deferGraphWriteUntilIdle?: boolean;
+    readonly pointerThrottleMs?: number;
+    readonly statusGraceMs?: number;
+}
+export interface CollaborativeGraphState {
+    readonly status: CollaborativeConnectionStatus;
+    readonly collaborators: CollaborativeGraphPeer[];
+    readonly publishPointer: (pointer: {
+        x: number;
+        y: number;
+    } | null) => void;
+    readonly publishDrag: (drag: CollaborativeGraphDrag | null) => void;
+}
+export declare function useCollaborativeGraph<TNodeData, TEdgeData, TMetadata = never>(options: CollaborativeGraphOptions<TNodeData, TEdgeData, TMetadata>): CollaborativeGraphState;
+export declare function readCollaborativeGraph<TNodeData, TEdgeData>(doc: CollaborativeYDoc, mapNames: {
+    nodes: string;
+    edges: string;
+}): CollaborativeGraphSnapshot<TNodeData, TEdgeData>;
+export declare function coerceCollaborativeGraph<TNodeData, TEdgeData>(value: unknown): CollaborativeGraphSnapshot<TNodeData, TEdgeData> | undefined;

package/dist/flow/use-collaborative-graph.js

@@ -0,0 +1,396 @@
+'use client';
+import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
+import { collaborativeEdgeKey, collaborativePatchFromMapEvent, coerceCollaborativeEdge, coerceCollaborativeNode, createCollaborativeCollectionHashes, resetCollaborativeGraphHashes, serializeCollaborativeEdge, serializeCollaborativeNode, writeCollaborativeGraph, } from './collaborative-graph-sync.js';
+import { parseCollaborativeGraphPeer, } from './collaborative-graph-presence.js';
+const GRAPH_INITIALIZED_KEY = 'atmos.graph.initialized';
+export function useCollaborativeGraph(options) {
+    const { enabled, surface, nodes, edges, selectedNodeIds, mapNames, stateMapName, version, metadata, applyRemoteGraph, applyRemotePatch, graphWriteDelayMs = 0, deferGraphWriteUntilIdle = false, pointerThrottleMs = 0, statusGraceMs = 0, } = options;
+    const nodesMapName = mapNames.nodes;
+    const edgesMapName = mapNames.edges;
+    const [status, setStatusState] = useState('connecting');
+    const rawStatusRef = useRef('connecting');
+    const statusTimerRef = useRef(null);
+    const docRef = useRef(null);
+    const surfaceRef = useRef(null);
+    const graphRef = useRef({ nodes, edges });
+    const metadataRef = useRef(metadata);
+    const versionRef = useRef(version);
+    const selectedNodeIdsRef = useRef(selectedNodeIds);
+    const applyRemoteGraphRef = useRef(applyRemoteGraph);
+    const applyRemotePatchRef = useRef(applyRemotePatch);
+    const applyingRemoteRef = useRef(false);
+    const applyingLocalRef = useRef(false);
+    const bootstrappedRef = useRef(false);
+    const graphWriteTimerRef = useRef(null);
+    const graphIdleWriteRef = useRef(null);
+    const pointerTimerRef = useRef(null);
+    const pendingPointerRef = useRef(null);
+    const dragTimerRef = useRef(null);
+    const pendingDragRef = useRef(null);
+    const hashesRef = useRef(createCollaborativeCollectionHashes());
+    const lastGraphRef = useRef('');
+    const lastMetadataRef = useRef('');
+    const committedVersionRef = useRef(null);
+    const setStatus = useCallback((next) => {
+        rawStatusRef.current = next;
+        if (next === 'connected' || statusGraceMs === 0) {
+            if (statusTimerRef.current)
+                clearTimeout(statusTimerRef.current);
+            statusTimerRef.current = null;
+            setStatusState(next);
+            return;
+        }
+        if (statusTimerRef.current)
+            return;
+        statusTimerRef.current = setTimeout(() => {
+            statusTimerRef.current = null;
+            setStatusState(rawStatusRef.current);
+        }, statusGraceMs);
+    }, [statusGraceMs]);
+    useEffect(() => {
+        graphRef.current = { nodes, edges };
+        metadataRef.current = metadata;
+        versionRef.current = version;
+        selectedNodeIdsRef.current = selectedNodeIds;
+        applyRemoteGraphRef.current = applyRemoteGraph;
+        applyRemotePatchRef.current = applyRemotePatch;
+        surfaceRef.current = surface;
+    }, [
+        applyRemoteGraph,
+        applyRemotePatch,
+        edges,
+        metadata,
+        nodes,
+        selectedNodeIds,
+        surface,
+        version,
+    ]);
+    useEffect(() => {
+        const timer = setTimeout(() => setStatus(surface?.status ?? 'connecting'), 0);
+        return () => clearTimeout(timer);
+    }, [setStatus, surface?.status]);
+    useEffect(() => () => {
+        if (statusTimerRef.current)
+            clearTimeout(statusTimerRef.current);
+    }, []);
+    const collaborators = useMemo(() => (surface?.peers ?? [])
+        .map((peer) => parseCollaborativeGraphPeer(peer.connectionId, peer.state))
+        .filter((peer) => peer !== null), [surface?.peers]);
+    useEffect(() => {
+        const activeSurface = surfaceRef.current;
+        if (!enabled || !activeSurface?.synced)
+            return;
+        const activeVersion = versionRef.current;
+        const doc = activeSurface.document;
+        const activeMapNames = { nodes: nodesMapName, edges: edgesMapName };
+        const nodesMap = doc.getMap(nodesMapName);
+        const edgesMap = doc.getMap(edgesMapName);
+        const resolvedStateMapName = stateMapName ?? `${nodesMapName}.state`;
+        const stateMap = doc.getMap(resolvedStateMapName);
+        const hashes = createCollaborativeCollectionHashes();
+        const initialGraph = collaborativeSnapshot(graphRef.current);
+        const initialSerialized = JSON.stringify(initialGraph);
+        const initialMetadata = metadataRef.current;
+        const initialMetadataSerialized = initialMetadata
+            ? initialMetadata.serialize(initialMetadata.value)
+            : '';
+        docRef.current = doc;
+        hashesRef.current = hashes;
+        bootstrappedRef.current = false;
+        lastGraphRef.current = '';
+        lastMetadataRef.current = initialMetadataSerialized;
+        committedVersionRef.current = activeVersion?.local ?? null;
+        activeSurface.updatePresence({
+            pointer: null,
+            selectedNodeIds: selectedNodeIdsRef.current,
+            drag: null,
+        });
+        const applyGraph = (snapshot, phase) => {
+            const serialized = JSON.stringify(snapshot);
+            if (serialized === lastGraphRef.current)
+                return;
+            applyingRemoteRef.current = true;
+            lastGraphRef.current = serialized;
+            resetCollaborativeGraphHashes(snapshot, hashes);
+            applyRemoteGraphRef.current(snapshot, phase);
+            queueMicrotask(() => {
+                applyingRemoteRef.current = false;
+            });
+        };
+        const applyPatch = (patch, phase) => {
+            if (!collaborativePatchHasChanges(patch))
+                return;
+            applyingRemoteRef.current = true;
+            applyRemotePatchRef.current(patch, phase);
+            queueMicrotask(() => {
+                applyingRemoteRef.current = false;
+            });
+        };
+        const applyMetadata = (value) => {
+            const current = metadataRef.current;
+            if (!current)
+                return;
+            const next = current.coerce(value);
+            const serialized = current.serialize(next);
+            if (serialized === lastMetadataRef.current)
+                return;
+            applyingRemoteRef.current = true;
+            lastMetadataRef.current = serialized;
+            current.onRemoteChange(next);
+            queueMicrotask(() => {
+                applyingRemoteRef.current = false;
+            });
+        };
+        const onNodesUpdate = (event) => {
+            if (applyingLocalRef.current)
+                return;
+            applyPatch({
+                nodes: collaborativePatchFromMapEvent(event, nodesMap, hashes.nodes, (coerceCollaborativeNode), (node) => node.id),
+            }, 'peer');
+        };
+        const onEdgesUpdate = (event) => {
+            if (applyingLocalRef.current)
+                return;
+            applyPatch({
+                edges: collaborativePatchFromMapEvent(event, edgesMap, hashes.edges, (coerceCollaborativeEdge), collaborativeEdgeKey),
+            }, 'peer');
+        };
+        const onStateUpdate = (event) => {
+            if (applyingLocalRef.current || !stateMap)
+                return;
+            const currentMetadata = metadataRef.current;
+            if (currentMetadata && event.keysChanged.has(currentMetadata.key)) {
+                applyMetadata(stateMap.get(currentMetadata.key));
+            }
+        };
+        nodesMap.observe(onNodesUpdate);
+        edgesMap.observe(onEdgesUpdate);
+        stateMap?.observe(onStateUpdate);
+        const remoteGraph = readCollaborativeGraph(doc, activeMapNames);
+        const remoteInitialized = stateMap.get(GRAPH_INITIALIZED_KEY) === true;
+        const remoteVersion = activeVersion && stateMap ? collaborativeString(stateMap.get(activeVersion.key)) : null;
+        const useRemote = Boolean(remoteInitialized &&
+            (activeVersion ? activeVersion.shouldUseRemote(remoteVersion, activeVersion.local) : true));
+        if (useRemote) {
+            const remoteSerialized = JSON.stringify(remoteGraph);
+            if (remoteSerialized !== initialSerialized) {
+                applyGraph(remoteGraph, 'bootstrap');
+            }
+            else {
+                lastGraphRef.current = remoteSerialized;
+                resetCollaborativeGraphHashes(remoteGraph, hashes);
+            }
+            const currentMetadata = metadataRef.current;
+            if (currentMetadata && stateMap)
+                applyMetadata(stateMap.get(currentMetadata.key));
+        }
+        else {
+            lastGraphRef.current = initialSerialized;
+            doc.transact(() => {
+                applyingLocalRef.current = true;
+                writeCollaborativeGraph(doc, initialGraph, activeMapNames, hashes);
+                if (stateMap.get(GRAPH_INITIALIZED_KEY) !== true) {
+                    stateMap.set(GRAPH_INITIALIZED_KEY, true);
+                }
+                if (activeVersion)
+                    stateMap.set(activeVersion.key, activeVersion.local);
+                const currentMetadata = metadataRef.current;
+                if (currentMetadata)
+                    stateMap.set(currentMetadata.key, currentMetadata.value);
+            });
+            queueMicrotask(() => {
+                applyingLocalRef.current = false;
+            });
+        }
+        bootstrappedRef.current = true;
+        return () => {
+            if (graphWriteTimerRef.current)
+                clearTimeout(graphWriteTimerRef.current);
+            if (graphIdleWriteRef.current)
+                cancelCollaborativeIdle(graphIdleWriteRef.current);
+            if (pointerTimerRef.current)
+                clearTimeout(pointerTimerRef.current);
+            if (dragTimerRef.current)
+                clearTimeout(dragTimerRef.current);
+            nodesMap.unobserve(onNodesUpdate);
+            edgesMap.unobserve(onEdgesUpdate);
+            stateMap?.unobserve(onStateUpdate);
+            docRef.current = null;
+            bootstrappedRef.current = false;
+        };
+    }, [
+        enabled,
+        edgesMapName,
+        nodesMapName,
+        stateMapName,
+        surface?.document,
+        surface?.synced,
+        surface?.updatePresence,
+    ]);
+    useEffect(() => {
+        const doc = docRef.current;
+        if (!doc || !bootstrappedRef.current || applyingRemoteRef.current)
+            return;
+        const resolvedStateMapName = stateMapName ?? `${nodesMapName}.state`;
+        const stateMap = doc.getMap(resolvedStateMapName);
+        const currentVersion = versionRef.current;
+        const activeMapNames = { nodes: nodesMapName, edges: edgesMapName };
+        const versionChanged = currentVersion && committedVersionRef.current !== currentVersion.local;
+        const write = () => {
+            const currentDoc = docRef.current;
+            if (!currentDoc || applyingRemoteRef.current)
+                return;
+            currentDoc.transact(() => {
+                applyingLocalRef.current = true;
+                writeCollaborativeGraph(currentDoc, graphRef.current, activeMapNames, hashesRef.current);
+                if (stateMap.get(GRAPH_INITIALIZED_KEY) !== true) {
+                    stateMap.set(GRAPH_INITIALIZED_KEY, true);
+                }
+                if (versionChanged && currentVersion) {
+                    stateMap.set(currentVersion.key, currentVersion.local);
+                }
+            });
+            if (versionChanged && currentVersion)
+                committedVersionRef.current = currentVersion.local;
+            queueMicrotask(() => {
+                applyingLocalRef.current = false;
+            });
+        };
+        if (versionChanged || graphWriteDelayMs === 0) {
+            write();
+            return;
+        }
+        if (graphWriteTimerRef.current)
+            clearTimeout(graphWriteTimerRef.current);
+        if (graphIdleWriteRef.current)
+            cancelCollaborativeIdle(graphIdleWriteRef.current);
+        graphWriteTimerRef.current = setTimeout(() => {
+            graphWriteTimerRef.current = null;
+            if (deferGraphWriteUntilIdle) {
+                graphIdleWriteRef.current = scheduleCollaborativeIdle(() => {
+                    graphIdleWriteRef.current = null;
+                    write();
+                });
+            }
+            else {
+                write();
+            }
+        }, graphWriteDelayMs);
+    }, [
+        deferGraphWriteUntilIdle,
+        edges,
+        graphWriteDelayMs,
+        edgesMapName,
+        nodesMapName,
+        nodes,
+        stateMapName,
+        version?.key,
+        version?.local,
+    ]);
+    useEffect(() => {
+        const doc = docRef.current;
+        if (!doc || !stateMapName || !metadata || !bootstrappedRef.current || applyingRemoteRef.current)
+            return;
+        const serialized = metadata.serialize(metadata.value);
+        if (serialized === lastMetadataRef.current)
+            return;
+        lastMetadataRef.current = serialized;
+        doc.transact(() => {
+            applyingLocalRef.current = true;
+            doc.getMap(stateMapName).set(metadata.key, metadata.value);
+        });
+        queueMicrotask(() => {
+            applyingLocalRef.current = false;
+        });
+    }, [metadata, stateMapName]);
+    useEffect(() => {
+        surfaceRef.current?.updatePresence({ selectedNodeIds });
+    }, [selectedNodeIds]);
+    const publishPointer = useCallback((pointer) => {
+        pendingPointerRef.current = pointer;
+        if (pointerThrottleMs === 0) {
+            surfaceRef.current?.updatePresence({ pointer });
+            return;
+        }
+        if (pointerTimerRef.current)
+            return;
+        pointerTimerRef.current = setTimeout(() => {
+            pointerTimerRef.current = null;
+            surfaceRef.current?.updatePresence({ pointer: pendingPointerRef.current });
+        }, pointerThrottleMs);
+    }, [pointerThrottleMs]);
+    const publishDrag = useCallback((drag) => {
+        pendingDragRef.current = drag;
+        // Drag end (null) must land immediately so a stale ghost never lingers.
+        if (drag === null || pointerThrottleMs === 0) {
+            if (dragTimerRef.current) {
+                clearTimeout(dragTimerRef.current);
+                dragTimerRef.current = null;
+            }
+            surfaceRef.current?.updatePresence({ drag });
+            return;
+        }
+        if (dragTimerRef.current)
+            return;
+        dragTimerRef.current = setTimeout(() => {
+            dragTimerRef.current = null;
+            surfaceRef.current?.updatePresence({ drag: pendingDragRef.current });
+        }, pointerThrottleMs);
+    }, [pointerThrottleMs]);
+    return { status, collaborators, publishPointer, publishDrag };
+}
+export function readCollaborativeGraph(doc, mapNames) {
+    const nodesMap = doc.getMap(mapNames.nodes);
+    const edgesMap = doc.getMap(mapNames.edges);
+    return (coerceCollaborativeGraph({
+        nodes: Array.from(nodesMap.values()),
+        edges: Array.from(edgesMap.values()),
+    }) ?? { nodes: [], edges: [] });
+}
+export function coerceCollaborativeGraph(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return undefined;
+    const record = value;
+    if (!Array.isArray(record.nodes) || !Array.isArray(record.edges))
+        return undefined;
+    return {
+        nodes: record.nodes
+            .map((coerceCollaborativeNode))
+            .filter((node) => node !== null),
+        edges: record.edges
+            .map((coerceCollaborativeEdge))
+            .filter((edge) => edge !== null),
+    };
+}
+function collaborativeSnapshot(graph) {
+    return {
+        nodes: graph.nodes.map(serializeCollaborativeNode),
+        edges: graph.edges.map(serializeCollaborativeEdge),
+    };
+}
+function collaborativePatchHasChanges(patch) {
+    return Boolean(patch.nodes?.upsert?.length ||
+        patch.nodes?.deleteIds?.length ||
+        patch.edges?.upsert?.length ||
+        patch.edges?.deleteIds?.length);
+}
+function collaborativeString(value) {
+    return typeof value === 'string' && value.trim() ? value : null;
+}
+function scheduleCollaborativeIdle(callback) {
+    if (typeof window !== 'undefined' && 'requestIdleCallback' in window) {
+        const request = window
+            .requestIdleCallback;
+        return { kind: 'idle', id: request(callback) };
+    }
+    return { kind: 'timer', id: setTimeout(callback, 0) };
+}
+function cancelCollaborativeIdle(handle) {
+    if (handle.kind === 'idle' && typeof window !== 'undefined' && 'cancelIdleCallback' in window) {
+        ;
+        window.cancelIdleCallback(handle.id);
+        return;
+    }
+    if (handle.kind === 'timer')
+        clearTimeout(handle.id);
+}

package/dist/flow/use-debounced-value.d.ts

@@ -0,0 +1 @@
+export declare function useDebouncedValue<T>(value: T, delay?: number): T;

package/dist/flow/use-debounced-value.js

@@ -0,0 +1,10 @@
+'use client';
+import { useEffect, useState } from 'react';
+export function useDebouncedValue(value, delay = 200) {
+    const [debounced, setDebounced] = useState(value);
+    useEffect(() => {
+        const id = window.setTimeout(() => setDebounced(value), delay);
+        return () => window.clearTimeout(id);
+    }, [delay, value]);
+    return debounced;
+}

package/dist/hooks/use-detail-nav.d.ts

@@ -0,0 +1,11 @@
+export type DetailNavIntent = 'next' | 'previous' | 'back';
+export interface DetailNavOptions {
+    onNext?: () => void;
+    onPrevious?: () => void;
+    onBack?: () => void;
+    enabled?: boolean;
+    isActive?: () => boolean;
+    backEscapesFrom?: string;
+}
+export declare function matchDetailNavIntent(event: KeyboardEvent): DetailNavIntent | null;
+export declare function useDetailNav(options: DetailNavOptions): void;

package/dist/hooks/use-detail-nav.js

@@ -0,0 +1,49 @@
+'use client';
+import { useEffect, useRef } from 'react';
+const TYPING_TARGET_SELECTOR = 'input, textarea, [contenteditable="true"], .ProseMirror, [role="dialog"], [role="listbox"], [data-slot="popover-content"]';
+export function matchDetailNavIntent(event) {
+    if (event.metaKey || event.ctrlKey || event.altKey || event.shiftKey)
+        return null;
+    switch (event.key) {
+        case 'j':
+        case 'ArrowDown':
+            return 'next';
+        case 'k':
+        case 'ArrowUp':
+            return 'previous';
+        case 'Escape':
+            return 'back';
+        default:
+            return null;
+    }
+}
+export function useDetailNav(options) {
+    const enabled = options.enabled !== false;
+    const latest = useRef(options);
+    useEffect(() => {
+        latest.current = options;
+    });
+    useEffect(() => {
+        if (!enabled || typeof document === 'undefined')
+            return;
+        const onKeyDown = (event) => {
+            const { onNext, onPrevious, onBack, isActive, backEscapesFrom } = latest.current;
+            if (isActive && !isActive())
+                return;
+            const intent = matchDetailNavIntent(event);
+            if (!intent)
+                return;
+            const target = event.target instanceof HTMLElement ? event.target : null;
+            const escapesFromTyping = Boolean(intent === 'back' && backEscapesFrom && target?.closest(backEscapesFrom));
+            if (!escapesFromTyping && target?.closest(TYPING_TARGET_SELECTOR))
+                return;
+            const handler = intent === 'next' ? onNext : intent === 'previous' ? onPrevious : onBack;
+            if (!handler)
+                return;
+            event.preventDefault();
+            handler();
+        };
+        document.addEventListener('keydown', onKeyDown);
+        return () => document.removeEventListener('keydown', onKeyDown);
+    }, [enabled]);
+}

package/dist/hooks/use-flush-on-hide.d.ts

@@ -0,0 +1 @@
+export declare function useFlushOnHide(flush: () => void): void;

package/dist/hooks/use-flush-on-hide.js

@@ -0,0 +1,21 @@
+'use client';
+import { useEffect, useRef } from 'react';
+export function useFlushOnHide(flush) {
+    const flushRef = useRef(flush);
+    useEffect(() => {
+        flushRef.current = flush;
+    });
+    useEffect(() => {
+        const onPageHide = () => flushRef.current();
+        const onVisibility = () => {
+            if (document.visibilityState === 'hidden')
+                flushRef.current();
+        };
+        window.addEventListener('pagehide', onPageHide);
+        document.addEventListener('visibilitychange', onVisibility);
+        return () => {
+            window.removeEventListener('pagehide', onPageHide);
+            document.removeEventListener('visibilitychange', onVisibility);
+        };
+    }, []);
+}

package/dist/hooks/use-media-query.d.ts

@@ -0,0 +1 @@
+export declare function useMediaQuery(query: string): boolean;

package/dist/hooks/use-media-query.js

@@ -0,0 +1,20 @@
+import { useCallback, useSyncExternalStore } from 'react';
+function matches(query) {
+    if (typeof window === 'undefined' || typeof window.matchMedia !== 'function')
+        return false;
+    return window.matchMedia(query).matches;
+}
+export function useMediaQuery(query) {
+    const subscribe = useCallback((onChange) => {
+        if (typeof window === 'undefined' || typeof window.matchMedia !== 'function')
+            return () => { };
+        const mql = window.matchMedia(query);
+        if (typeof mql.addEventListener === 'function') {
+            mql.addEventListener('change', onChange);
+            return () => mql.removeEventListener('change', onChange);
+        }
+        mql.addListener(onChange);
+        return () => mql.removeListener(onChange);
+    }, [query]);
+    return useSyncExternalStore(subscribe, () => matches(query), () => false);
+}

package/dist/hooks/use-virtualizer.d.ts

@@ -0,0 +1 @@
+export { useVirtualizer, type ReactVirtualizerOptions, type VirtualItem, type Virtualizer, } from '@tanstack/react-virtual';

package/dist/hooks/use-virtualizer.js

@@ -0,0 +1 @@
+export { useVirtualizer, } from '@tanstack/react-virtual';