@motionstudies/web 0.1.0-alpha.3 → 0.1.0-alpha.30

package/use-pattern-network-day.js

@@ -0,0 +1,41 @@
+import { useMemo } from 'react';
+import { adjacentDayChunks, dayChunkForTime, networkSnapshotForDayChunk } from '@motionstudies/core/domain/network-day';
+import { useProgressiveChunks } from './use-progressive-chunks.js';
+export async function verifiedPatternNetworkChunk(response, descriptor, options = {}) {
+    const bytes = await response.arrayBuffer();
+    if (!Number.isSafeInteger(descriptor.bytes) || bytes.byteLength !== descriptor.bytes || !/^[a-f0-9]{64}$/.test(descriptor.sha256 ?? ''))
+        throw new Error('Pattern chunk integrity metadata missing or size mismatch');
+    const hash = [...new Uint8Array(await crypto.subtle.digest('SHA-256', bytes))].map(byte => byte.toString(16).padStart(2, '0')).join('');
+    if (hash !== descriptor.sha256)
+        throw new Error('Pattern chunk integrity mismatch');
+    const { decodeNetworkPatterns } = await import('@motionstudies/core/domain/network-patterns');
+    const chunk = decodeNetworkPatterns(JSON.parse(new TextDecoder().decode(bytes)), options);
+    if (chunk.windowStart !== descriptor.windowStart || chunk.windowEnd !== descriptor.windowEnd || chunk.trains.length !== descriptor.tripCount)
+        throw new Error('Pattern chunk descriptor mismatch');
+    return chunk;
+}
+/** Fetch and decode only the current and adjacent chunks; keep the manifest independent. */
+export function usePatternNetworkDay(manifestFile, active, time, resolveAssetUrl, options = {}) {
+    const format = options.format ?? 'network-patterns-v1', categories = options.categories;
+    const adapter = useMemo(() => ({
+        chunkForTime: dayChunkForTime, adjacentChunks: adjacentDayChunks, retainAdjacentOnly: true,
+        validateManifest(manifest) {
+            if (manifest.format !== format || !manifest.metadata || !Array.isArray(manifest.stops) || !Array.isArray(manifest.edges))
+                throw new Error('Invalid pattern manifest');
+            const ids = new Set();
+            let previous = -Infinity;
+            for (const chunk of manifest.chunks) {
+                if (!chunk.id || ids.has(chunk.id) || !chunk.path || !Number.isFinite(chunk.windowStart) || !Number.isFinite(chunk.windowEnd) ||
+                    chunk.windowStart < previous || chunk.windowEnd <= chunk.windowStart || !Number.isSafeInteger(chunk.tripCount) || chunk.tripCount < 0 ||
+                    !Number.isSafeInteger(chunk.bytes) || chunk.bytes < 1 || !/^[a-f0-9]{64}$/.test(chunk.sha256 ?? ''))
+                    throw new Error('Invalid pattern descriptor');
+                ids.add(chunk.id);
+                previous = chunk.windowEnd;
+            }
+        },
+        readChunk: (response, descriptor) => verifiedPatternNetworkChunk(response, descriptor, { format, categories }),
+    }), [format, categories]);
+    const { chunk, ...state } = useProgressiveChunks(manifestFile, active, time, resolveAssetUrl, adapter);
+    const network = useMemo(() => state.manifest ? networkSnapshotForDayChunk(state.manifest, chunk) : undefined, [state.manifest, chunk]);
+    return { ...state, network };
+}

package/use-progressive-air-day.d.ts

@@ -6,5 +6,6 @@ export declare function useProgressiveAirDay(manifestFile: string, active: boole
     loading: boolean;
     unavailable: boolean;
     error: boolean;
+    retry: () => void;
     snapshot: import("@motionstudies/core/domain/air").AirSnapshot | undefined;
 };

package/use-progressive-chunks.d.ts

@@ -11,6 +11,8 @@ export interface ProgressiveChunkAdapter<Manifest, Descriptor, Chunk> {
     readonly adjacentChunks: (manifest: Manifest, current: Descriptor) => readonly Descriptor[];
     readonly readChunk: (response: Response, descriptor: Descriptor) => Promise<Chunk>;
     readonly optional?: boolean;
+    readonly validateManifest?: (manifest: Manifest) => void;
+    readonly retainAdjacentOnly?: boolean;
 }
 /** Internal lifecycle shared by the network, aircraft and road loaders. */
 export declare function useProgressiveChunks<Descriptor extends ChunkDescriptor, Manifest extends ChunkManifest<Descriptor>, Chunk>(manifestFile: string, active: boolean, time: number, resolveAssetUrl: DataUrlResolver, adapter: ProgressiveChunkAdapter<Manifest, Descriptor, Chunk>): {
@@ -20,5 +22,6 @@ export declare function useProgressiveChunks<Descriptor extends ChunkDescriptor,
     loading: boolean;
     unavailable: boolean;
     error: boolean;
+    retry: () => void;
 };
 export {};

package/use-progressive-chunks.js

@@ -1,8 +1,13 @@
-import { useEffect, useMemo, useState } from 'react';
+import { useCallback, useEffect, useMemo, useState } from 'react';
 /** Internal lifecycle shared by the network, aircraft and road loaders. */
 export function useProgressiveChunks(manifestFile, active, time, resolveAssetUrl, adapter) {
     const key = resolveAssetUrl(manifestFile);
     const [stored, setStored] = useState({ key, chunks: {} });
+    const [attempt, setAttempt] = useState(0);
+    const retry = useCallback(() => {
+        setStored(current => current.key === key ? { ...current, manifestError: false, failedChunk: undefined, unavailable: false } : current);
+        setAttempt(value => value + 1);
+    }, [key]);
     // Reset during render so no effect (or consumer) sees another source's data.
     // Late responses are also rejected below, independently of fetch cancellation.
     const state = stored.key === key ? stored : { key, chunks: {} };
@@ -32,6 +37,7 @@ export function useProgressiveChunks(manifestFile, active, time, resolveAssetUrl
                 if (!Array.isArray(next.chunks) || !next.chunks.length) {
                     throw new Error('Day manifest has no chunks');
                 }
+                adapter.validateManifest?.(next);
                 if (!controller.signal.aborted) {
                     setStored((current) => current.key === key
                         ? { ...current, manifest: next, manifestError: false }
@@ -45,7 +51,7 @@ export function useProgressiveChunks(manifestFile, active, time, resolveAssetUrl
             }
         })();
         return () => controller.abort();
-    }, [active, adapter, key, manifest, unavailable]);
+    }, [active, adapter, attempt, key, manifest, unavailable]);
     useEffect(() => {
         if (!active || !manifest || !descriptor)
             return;
@@ -66,7 +72,9 @@ export function useProgressiveChunks(manifestFile, active, time, resolveAssetUrl
                     const next = await adapter.readChunk(response, candidate);
                     if (!controller.signal.aborted) {
                         setStored((current) => current.key === key
-                            ? { ...current, chunks: { ...current.chunks, [candidate.id]: next },
+                            ? { ...current, chunks: { ...(adapter.retainAdjacentOnly
+                                        ? Object.fromEntries(Object.entries(current.chunks).filter(([id]) => adapter.adjacentChunks(manifest, descriptor).some(item => item.id === id)))
+                                        : current.chunks), [candidate.id]: next },
                                 failedChunk: current.failedChunk === candidate.id ? undefined : current.failedChunk }
                             : current);
                     }
@@ -79,7 +87,7 @@ export function useProgressiveChunks(manifestFile, active, time, resolveAssetUrl
             })();
         }
         return () => controller.abort();
-    }, [active, adapter, chunks, descriptor, key, manifest, resolveAssetUrl]);
+    }, [active, adapter, attempt, chunks, descriptor, key, manifest, resolveAssetUrl]);
     return {
         manifest,
         chunk,
@@ -87,5 +95,6 @@ export function useProgressiveChunks(manifestFile, active, time, resolveAssetUrl
         loading: active && !unavailable && !error && (!manifest || !chunkReady),
         unavailable: Boolean(unavailable),
         error,
+        retry,
     };
 }

package/use-progressive-network-day.d.ts

@@ -7,5 +7,6 @@ export declare function useProgressiveNetworkDay(manifestFile: string, active: b
     loading: boolean;
     unavailable: boolean;
     error: boolean;
+    retry: () => void;
     network: import("@motionstudies/core/domain/network").NetworkSnapshot | undefined;
 };

package/use-progressive-road-study.d.ts

@@ -6,5 +6,6 @@ export declare function useProgressiveRoadStudy(manifestFile: string, active: bo
     loading: boolean;
     unavailable: boolean;
     error: boolean;
+    retry: () => void;
     snapshot: import("@motionstudies/core/domain/road-day").NationalRoadStudySnapshot | undefined;
 };

package/use-transition-value.d.ts

@@ -0,0 +1,12 @@
+export declare const smoothTransition: (progress: number) => number;
+export declare const cosineTransition: (progress: number) => number;
+/** Animate a scalar from its current value; interruptions reverse from the last frame.
+ * Reduced-motion changes settle immediately, including during an active transition. */
+export declare function useTransitionValue(target: number, { durationMs, easing, steps, }?: {
+    readonly durationMs?: number;
+    readonly easing?: (progress: number) => number;
+    readonly steps?: number;
+}): {
+    value: number;
+    transitioning: boolean;
+};

package/use-transition-value.js

@@ -0,0 +1,46 @@
+import { useEffect, useRef, useState } from 'react';
+export const smoothTransition = (progress) => progress * progress * (3 - 2 * progress);
+export const cosineTransition = (progress) => 0.5 - Math.cos(progress * Math.PI) / 2;
+/** Animate a scalar from its current value; interruptions reverse from the last frame.
+ * Reduced-motion changes settle immediately, including during an active transition. */
+export function useTransitionValue(target, { durationMs = 1600, easing = smoothTransition, steps, } = {}) {
+    const current = useRef(target);
+    const [value, setValue] = useState(target);
+    const [transitioning, setTransitioning] = useState(false);
+    useEffect(() => {
+        const from = current.current;
+        const motion = matchMedia('(prefers-reduced-motion: reduce)');
+        let frame = 0;
+        const finish = () => {
+            cancelAnimationFrame(frame);
+            current.current = target;
+            setValue(target);
+            setTransitioning(false);
+        };
+        if (!Number.isFinite(target) || !Number.isFinite(from))
+            return;
+        if (motion.matches || from === target || !(durationMs > 0) || !Number.isFinite(durationMs)) {
+            finish();
+            return;
+        }
+        const started = performance.now();
+        setTransitioning(true);
+        const tick = (now) => {
+            const progress = Math.min(1, (now - started) / durationMs);
+            const eased = easing(progress);
+            const fraction = steps && Number.isFinite(steps) && steps > 0 ? Math.round(eased * steps) / steps : eased;
+            current.current = from + (target - from) * fraction;
+            setValue(current.current);
+            if (progress < 1)
+                frame = requestAnimationFrame(tick);
+            else
+                finish();
+        };
+        frame = requestAnimationFrame(tick);
+        const changed = () => { if (motion.matches)
+            finish(); };
+        motion.addEventListener('change', changed);
+        return () => { cancelAnimationFrame(frame); motion.removeEventListener('change', changed); };
+    }, [target, durationMs, easing, steps]);
+    return { value, transitioning };
+}