simview 3.2__py3-none-any.whl

simview/static/js/utils/bodyTransforms.js

@@ -0,0 +1,151 @@
+import * as THREE from "three";
+
+// Resolves parent-relative body transforms (see README.md "Model (Static
+// Data)" / "States (Dynamic Data)") into ordinary absolute-world transforms,
+// so the rest of the viewer (Body.js, InteractionController.js, trails, ...)
+// never has to know a body was parented -- it only ever sees the same
+// `bodyTransform` shape it always has.
+
+// Builds a `name -> {parent, localTransform}` lookup from `model.bodies`.
+// `parent`/`localTransform` are null for an ordinary absolute-world body.
+export function buildBodyMeta(modelBodies) {
+    const meta = new Map();
+    (modelBodies || []).forEach((b) => {
+        meta.set(b.name, {
+            parent: b.parent ?? null,
+            localTransform: b.localTransform ?? null,
+        });
+    });
+    return meta;
+}
+
+// Orders body names so every parent precedes its children. Each body has at
+// most one parent (a forest, not a general DAG), so a plain DFS post-order
+// walk suffices -- no need for a full topological-sort algorithm. Throws on
+// a self-referencing, unknown, or cyclic parent chain, mirroring the
+// SimViewModel.add_body/from_dict validation on the Python side (this exists
+// on the client because loaded JSON has no equivalent insertion-order
+// guarantee -- it may have been hand-edited or produced by another tool).
+export function topoSortBodies(bodyMeta) {
+    const order = [];
+    const status = new Map(); // name -> "visiting" | "done"
+
+    function visit(name) {
+        if (status.get(name) === "done") return;
+        if (status.get(name) === "visiting") {
+            throw new Error(`Cycle detected in body parent chain involving '${name}'`);
+        }
+        const meta = bodyMeta.get(name);
+        if (meta.parent != null) {
+            if (meta.parent === name) {
+                throw new Error(`Body '${name}' cannot be its own parent`);
+            }
+            if (!bodyMeta.has(meta.parent)) {
+                throw new Error(
+                    `Body '${name}' references unknown parent '${meta.parent}'`
+                );
+            }
+            status.set(name, "visiting");
+            visit(meta.parent);
+        }
+        status.set(name, "done");
+        order.push(name);
+    }
+
+    for (const name of bodyMeta.keys()) {
+        visit(name);
+    }
+    return order;
+}
+
+function posFromWire(t) {
+    return new THREE.Vector3(t[0], t[1], t[2]);
+}
+
+// Wire order is [x, y, z, w, qx, qy, qz]; THREE.Quaternion.set() takes (x, y, z, w).
+function quatFromWire(t) {
+    return new THREE.Quaternion(t[4], t[5], t[6], t[3]);
+}
+
+function wireFromPosQuat(pos, quat) {
+    return [pos.x, pos.y, pos.z, quat.w, quat.x, quat.y, quat.z];
+}
+
+// Normalizes a bodyTransform field (flat array[7] for a single batch, or
+// array[array[7]] for multiple) into a plain array of rows, matching the
+// same convention Body.js already uses when consuming raw state data.
+function toRows(bodyTransform) {
+    return Array.isArray(bodyTransform[0]) ? bodyTransform : [bodyTransform];
+}
+
+// Builds a `name -> rawStateEntry` lookup for one state's `bodies` array,
+// expanding any grouped (list) `name` entries so each individual body name
+// maps to the (shared) entry describing it.
+function expandRawBodies(rawBodies) {
+    const map = new Map();
+    (rawBodies || []).forEach((entry) => {
+        const names = Array.isArray(entry.name) ? entry.name : [entry.name];
+        names.forEach((n) => map.set(n, entry));
+    });
+    return map;
+}
+
+// Resolves one state's raw `bodies` array into a `name -> resolvedBodyState`
+// Map where every body's `bodyTransform` is absolute-world, ready to feed
+// straight into Body.updateState / appendHistoryPointAt / setHistoryPointAt
+// unchanged. A body absent from the result simply keeps whatever pose it
+// already had (identical to today's behavior when a body is omitted from a
+// state). `bodyMeta`/`topoOrder` come from `buildBodyMeta`/`topoSortBodies`,
+// computed once at model load.
+export function resolveStateBodies(bodyMeta, topoOrder, simBatches, rawBodies) {
+    const rawByName = expandRawBodies(rawBodies);
+    const resolved = new Map();
+
+    for (const name of topoOrder) {
+        const meta = bodyMeta.get(name);
+        const raw = rawByName.get(name);
+
+        if (meta.parent == null) {
+            // Root body: bodyTransform, if present this frame, is already
+            // absolute-world -- nothing to resolve.
+            if (raw && raw.bodyTransform) {
+                resolved.set(name, raw);
+            }
+            continue;
+        }
+
+        const parentResolved = resolved.get(meta.parent);
+        if (!parentResolved || !parentResolved.bodyTransform) {
+            // Parent has no resolved pose this frame; nothing sensible to
+            // compose this child against.
+            continue;
+        }
+        const parentRows = toRows(parentResolved.bodyTransform);
+
+        let localRows;
+        if (meta.localTransform) {
+            // Rigid attachment: same constant local offset for every batch.
+            localRows = [meta.localTransform];
+        } else if (raw && raw.bodyTransform) {
+            // Articulated attachment: per-frame local transform, as usual.
+            localRows = toRows(raw.bodyTransform);
+        } else {
+            continue; // no data to resolve this body this frame
+        }
+
+        const worldRows = [];
+        for (let i = 0; i < simBatches; i++) {
+            const parentRow = parentRows[Math.min(i, parentRows.length - 1)];
+            const localRow = localRows[Math.min(i, localRows.length - 1)];
+            const worldPos = posFromWire(localRow)
+                .applyQuaternion(quatFromWire(parentRow))
+                .add(posFromWire(parentRow));
+            const worldQuat = quatFromWire(parentRow).multiply(quatFromWire(localRow));
+            worldRows.push(wireFromPosQuat(worldPos, worldQuat));
+        }
+
+        resolved.set(name, { ...(raw || {}), bodyTransform: worldRows });
+    }
+
+    return resolved;
+}

simview/static/js/utils/csv.js

@@ -0,0 +1,46 @@
+// Pure CSV assembly (rows -> escaped CSV string) shared by ScalarPlotter and
+// ErrorMetrics CSV export buttons, plus a small browser-only download helper.
+
+// Escapes a single CSV field per RFC 4180: wraps in double quotes if it
+// contains a comma, double quote, or newline, doubling any embedded quotes.
+export function escapeCsvField(field) {
+    const str = field === null || field === undefined ? "" : String(field);
+    if (/[",\n\r]/.test(str)) {
+        return `"${str.replace(/"/g, '""')}"`;
+    }
+    return str;
+}
+
+// Builds a CSV string (CRLF line endings, per RFC 4180) from a header array
+// and an array of rows (each row an array of values, same length as header).
+export function rowsToCsv(header, rows) {
+    const lines = [header, ...rows].map((row) =>
+        row.map(escapeCsvField).join(",")
+    );
+    return lines.join("\r\n") + "\r\n";
+}
+
+// Sanitizes a string (e.g. a body or batch name) for safe use inside a
+// downloaded filename: replaces anything but letters, digits, dot, dash, and
+// underscore with underscores, so names containing spaces, slashes, etc.
+// don't break the filename or path.
+export function sanitizeForFilename(name) {
+    const str = name === null || name === undefined ? "" : String(name);
+    return str.replace(/[^a-zA-Z0-9._-]+/g, "_");
+}
+
+// Triggers a browser download of `content` as a file named `filename`. No-op
+// outside a browser environment (e.g. under vitest/node), so this module
+// stays importable from tests without a DOM.
+export function downloadCsv(filename, content) {
+    if (typeof document === "undefined" || typeof Blob === "undefined") return;
+    const blob = new Blob([content], { type: "text/csv;charset=utf-8;" });
+    const url = URL.createObjectURL(blob);
+    const link = document.createElement("a");
+    link.href = url;
+    link.download = filename;
+    document.body.appendChild(link);
+    link.click();
+    document.body.removeChild(link);
+    URL.revokeObjectURL(url);
+}

simview/static/js/utils/errorMath.js

@@ -0,0 +1,69 @@
+// Pure error-metric math shared by ErrorMetrics.js: per-frame Euclidean
+// position error (combined and per-axis signed) and quaternion geodesic
+// angle error between two batches of the same body.
+
+// Signed per-axis difference (posA - posB) for one frame, given flat
+// position arrays (3 floats per frame) and a frame index.
+export function positionAxisError(posA, posB, frameIndex) {
+    const base = frameIndex * 3;
+    return {
+        dx: posA[base] - posB[base],
+        dy: posA[base + 1] - posB[base + 1],
+        dz: posA[base + 2] - posB[base + 2],
+    };
+}
+
+// Combined Euclidean position error for one frame.
+export function positionError(posA, posB, frameIndex) {
+    const { dx, dy, dz } = positionAxisError(posA, posB, frameIndex);
+    return Math.sqrt(dx * dx + dy * dy + dz * dz);
+}
+
+// Geodesic angle (radians) between two quaternions, given flat [w,x,y,z]
+// arrays (4 floats per frame) and a frame index. Uses |dot| to collapse the
+// q/-q double cover (both represent the same rotation), so the result is
+// always in [0, pi/2] measured this way -- doubled by callers that want the
+// full [0, pi] rotation-angle convention (see below).
+function quatDot(quatA, quatB, frameIndex) {
+    const base = frameIndex * 4;
+    return (
+        quatA[base] * quatB[base] +
+        quatA[base + 1] * quatB[base + 1] +
+        quatA[base + 2] * quatB[base + 2] +
+        quatA[base + 3] * quatB[base + 3]
+    );
+}
+
+// Full geodesic rotation angle (radians) between two quaternions for one
+// frame: 2*acos(|dot|), robust to floating-point dot products drifting
+// slightly outside [-1, 1] and to either quaternion's sign (q and -q encode
+// the same rotation).
+export function quaternionAngleError(quatA, quatB, frameIndex) {
+    const dot = quatDot(quatA, quatB, frameIndex);
+    const clamped = Math.min(1, Math.max(-1, Math.abs(dot)));
+    return 2 * Math.acos(clamped);
+}
+
+// Root-mean-square of a plain numeric array. Returns 0 for an empty series
+// (rather than NaN), so callers can display it without a special case.
+export function rmse(values) {
+    if (!values || values.length === 0) return 0;
+    let sumSq = 0;
+    for (const v of values) sumSq += v * v;
+    return Math.sqrt(sumSq / values.length);
+}
+
+// Finds the maximum value in a plain numeric array and the index at which it
+// occurs. Returns { value: 0, index: -1 } for an empty series.
+export function maxWithIndex(values) {
+    if (!values || values.length === 0) return { value: 0, index: -1 };
+    let bestValue = values[0];
+    let bestIndex = 0;
+    for (let i = 1; i < values.length; i++) {
+        if (values[i] > bestValue) {
+            bestValue = values[i];
+            bestIndex = i;
+        }
+    }
+    return { value: bestValue, index: bestIndex };
+}

simview/static/js/utils/injectStyles.js

@@ -0,0 +1,16 @@
+const injectedStyleIds = new Set();
+
+// Injects a <style> block into <head> exactly once per styleId, even across
+// multiple instances of the same component. Cheap to call from a
+// constructor every time -- repeat calls with an already-seen id are no-ops.
+export function injectStyles(styleId, css) {
+    if (injectedStyleIds.has(styleId) || document.getElementById(styleId)) {
+        injectedStyleIds.add(styleId);
+        return;
+    }
+    const styleElement = document.createElement("style");
+    styleElement.id = styleId;
+    styleElement.textContent = css;
+    document.head.appendChild(styleElement);
+    injectedStyleIds.add(styleId);
+}

simview/static/js/utils/interpolate.js

@@ -0,0 +1,65 @@
+import * as THREE from "three";
+
+// Pure helpers for smooth interpolated playback (see AnimationController.js).
+// Every function here takes two arrays of per-batch rows (row shape depends
+// on the field -- 7-wide [x,y,z,w,qx,qy,qz] for bodyTransform, 3-wide for
+// plain vector attributes like velocity) plus alpha in [0, 1], and returns a
+// new array of interpolated rows. Row counts of `rowsA`/`rowsB` may differ
+// (e.g. a body only present in one of the two bracketing frames); rows
+// beyond the shorter array's length pass through unchanged from the longer
+// one, matching how the rest of the viewer already clamps batch indices.
+
+const _qa = new THREE.Quaternion();
+const _qb = new THREE.Quaternion();
+
+// Linearly interpolates a single 3-vector row: [x, y, z].
+export function lerpVector3Row(a, b, alpha) {
+    return [
+        a[0] + (b[0] - a[0]) * alpha,
+        a[1] + (b[1] - a[1]) * alpha,
+        a[2] + (b[2] - a[2]) * alpha,
+    ];
+}
+
+// Interpolates an array of 3-vector rows (one per batch) by plain lerp.
+export function lerpVectorRows(rowsA, rowsB, alpha) {
+    if (!rowsA || !rowsB) return rowsA || rowsB;
+    const n = Math.min(rowsA.length, rowsB.length);
+    const out = new Array(rowsA.length);
+    for (let i = 0; i < n; i++) {
+        out[i] = lerpVector3Row(rowsA[i], rowsB[i], alpha);
+    }
+    for (let i = n; i < rowsA.length; i++) out[i] = rowsA[i];
+    return out;
+}
+
+// Interpolates a single bodyTransform row [x, y, z, w, qx, qy, qz]: position
+// lerp, quaternion slerp with shortest-path handling (negate one quaternion
+// when the dot product is negative, since q and -q represent the same
+// rotation but naive slerp between them takes the long way around).
+export function interpolateTransformRow(a, b, alpha) {
+    const px = a[0] + (b[0] - a[0]) * alpha;
+    const py = a[1] + (b[1] - a[1]) * alpha;
+    const pz = a[2] + (b[2] - a[2]) * alpha;
+
+    _qa.set(a[4], a[5], a[6], a[3]); // THREE.Quaternion.set(x, y, z, w)
+    _qb.set(b[4], b[5], b[6], b[3]);
+    if (_qa.dot(_qb) < 0) {
+        _qb.set(-b[4], -b[5], -b[6], -b[3]);
+    }
+    _qa.slerp(_qb, alpha);
+
+    return [px, py, pz, _qa.w, _qa.x, _qa.y, _qa.z];
+}
+
+// Interpolates an array of bodyTransform rows (one per batch).
+export function interpolateTransformRows(rowsA, rowsB, alpha) {
+    if (!rowsA || !rowsB) return rowsA || rowsB;
+    const n = Math.min(rowsA.length, rowsB.length);
+    const out = new Array(rowsA.length);
+    for (let i = 0; i < n; i++) {
+        out[i] = interpolateTransformRow(rowsA[i], rowsB[i], alpha);
+    }
+    for (let i = n; i < rowsA.length; i++) out[i] = rowsA[i];
+    return out;
+}

simview/static/js/utils/liveFollow.js

@@ -0,0 +1,17 @@
+// Decides whether a newly-arrived live-streaming chunk (see
+// simview.live.LiveViewer / SimView.startLiveStream) should pull playback
+// forward to the new last frame.
+//
+// Kept as a small pure function (rather than inline in SimView.processStatesChunk)
+// so it can be unit-tested without instantiating a full SimView/AnimationController.
+//
+// True (follow) when nothing has played yet, or the viewer was parked exactly
+// on the (previous) last frame and isn't mid-playback. False when the user
+// scrubbed back to look at history, or is actively playing/looping -- either
+// way a new chunk arriving shouldn't yank the view forward.
+export function shouldFollowLive(animationController) {
+    const ac = animationController;
+    if (!ac || !ac.store || ac.store.length === 0) return true;
+    if (ac.isPlaying) return false;
+    return ac.currentStateIndex >= ac.store.length - 1;
+}

simview/static/js/utils/loadRecordingLibs.js

@@ -0,0 +1,34 @@
+// tar.js and download.js are only needed for the PNG-sequence recording
+// format (each rendered frame is captured as a PNG blob and packed into a
+// .tar via Tar.append()/Tar.save(), then saved with download()). The WEBM
+// format needs no extra libraries at all -- it's captured natively via
+// canvas.captureStream() + MediaRecorder and saved via a temporary <a
+// download> link (see AnimationController.js). Both tar.js and download.js
+// are UMD/global-style scripts (not ES modules), so loading them lazily
+// means injecting <script> tags rather than dynamic import().
+const RECORDING_LIB_PATHS = ["../../lib/tar.js", "../../lib/download.js"];
+
+let loadPromise = null;
+
+function loadScript(url) {
+    return new Promise((resolve, reject) => {
+        const script = document.createElement("script");
+        script.src = url;
+        script.onload = () => resolve();
+        script.onerror = () => reject(new Error(`Failed to load script: ${url}`));
+        document.head.appendChild(script);
+    });
+}
+
+// Loads the PNG-sequence recording libraries once (in order, since they
+// attach to global scope) and caches the promise so repeat calls are no-ops.
+export function loadRecordingLibs() {
+    if (!loadPromise) {
+        loadPromise = RECORDING_LIB_PATHS.reduce(
+            (chain, path) =>
+                chain.then(() => loadScript(new URL(path, import.meta.url).href)),
+            Promise.resolve()
+        );
+    }
+    return loadPromise;
+}

simview/static/js/utils/viewState.js

@@ -0,0 +1,226 @@
+// Shareable-view-link encode/decode (see ui/Controls.js's "Copy view link"
+// button and SimView.js's apply-on-load hook). Pure functions, no DOM/THREE
+// dependencies, so they're unit-testable in isolation.
+//
+// Format (v=1): a compact `#key=value&key=value...` hash fragment, e.g.
+//   #v=1&t=1.25&cam=1.5,2,3&tgt=0,0,0&fov=50&b=1&bvm=mesh&tcm=height&flags=5
+// `flags` is a bitmask over the boolean toggles listed in BOOLEAN_FLAG_KEYS
+// below (bit order fixed by that array's order) -- new booleans get appended
+// at the end of the array in future versions so old links keep decoding
+// sanely (their bits just default off for the new flag).
+//
+// Versioned via `v` so future formats can add/rename fields; parseViewState
+// only understands v=1 today and returns null for anything else.
+
+export const VIEW_STATE_VERSION = 1;
+
+// Fixed bit order for the `flags` bitmask -- append-only across versions.
+const BOOLEAN_FLAG_KEYS = [
+    "axesVisible",
+    "trailsVisible",
+    "smoothInterpolation",
+    "terrainProbe",
+    "attributeVisible.contacts",
+    "attributeVisible.velocity",
+    "attributeVisible.angularVelocity",
+    "attributeVisible.force",
+    "attributeVisible.torque",
+    "terrainVisualizationModes.surface",
+    "terrainVisualizationModes.wireframe",
+    "terrainVisualizationModes.normals",
+];
+
+function getPath(obj, path) {
+    return path.split(".").reduce((o, k) => (o && typeof o === "object" ? o[k] : undefined), obj);
+}
+
+function setPath(obj, path, value) {
+    const keys = path.split(".");
+    let node = obj;
+    for (let i = 0; i < keys.length - 1; i++) {
+        const k = keys[i];
+        if (typeof node[k] !== "object" || node[k] === null) node[k] = {};
+        node = node[k];
+    }
+    node[keys[keys.length - 1]] = value;
+}
+
+function fmtNum(n) {
+    // Trim to a sane precision so the hash stays compact/human-tolerable,
+    // while still round-tripping to full float precision for practical
+    // view-restoration purposes (6 significant decimals).
+    if (!Number.isFinite(n)) return "0";
+    return Number(n.toFixed(6)).toString();
+}
+
+function fmtVec3(v) {
+    return [fmtNum(v.x), fmtNum(v.y), fmtNum(v.z)].join(",");
+}
+
+function parseVec3(str) {
+    if (typeof str !== "string") return null;
+    const parts = str.split(",");
+    if (parts.length !== 3) return null;
+    const nums = parts.map(Number);
+    if (nums.some((n) => !Number.isFinite(n))) return null;
+    return { x: nums[0], y: nums[1], z: nums[2] };
+}
+
+// Builds the bitmask for `state.toggles` (a flat map of BOOLEAN_FLAG_KEYS ->
+// boolean, see serializeViewState's `state` shape below).
+function encodeFlags(toggles) {
+    let mask = 0;
+    BOOLEAN_FLAG_KEYS.forEach((key, i) => {
+        if (toggles && toggles[key]) mask |= 1 << i;
+    });
+    return mask;
+}
+
+function decodeFlags(mask) {
+    const toggles = {};
+    BOOLEAN_FLAG_KEYS.forEach((key, i) => {
+        toggles[key] = (mask & (1 << i)) !== 0;
+    });
+    return toggles;
+}
+
+// state shape (all fields optional):
+// {
+//   time: number,
+//   camera: { position: {x,y,z}, target: {x,y,z}, fov: number },
+//   batchIndex: number,
+//   bodyVisualizationMode: string,
+//   terrainColorMode: string,
+//   toggles: { [key in BOOLEAN_FLAG_KEYS]?: boolean },
+// }
+export function serializeViewState(state) {
+    if (!state || typeof state !== "object") return "";
+    const params = [`v=${VIEW_STATE_VERSION}`];
+
+    if (Number.isFinite(state.time)) {
+        params.push(`t=${fmtNum(state.time)}`);
+    }
+    if (state.camera && state.camera.position) {
+        params.push(`cam=${fmtVec3(state.camera.position)}`);
+    }
+    if (state.camera && state.camera.target) {
+        params.push(`tgt=${fmtVec3(state.camera.target)}`);
+    }
+    if (state.camera && Number.isFinite(state.camera.fov)) {
+        params.push(`fov=${fmtNum(state.camera.fov)}`);
+    }
+    if (Number.isInteger(state.batchIndex)) {
+        params.push(`b=${state.batchIndex}`);
+    }
+    if (typeof state.bodyVisualizationMode === "string" && state.bodyVisualizationMode) {
+        params.push(`bvm=${encodeURIComponent(state.bodyVisualizationMode)}`);
+    }
+    if (typeof state.terrainColorMode === "string" && state.terrainColorMode) {
+        params.push(`tcm=${encodeURIComponent(state.terrainColorMode)}`);
+    }
+    if (state.toggles && typeof state.toggles === "object") {
+        params.push(`flags=${encodeFlags(state.toggles)}`);
+    }
+
+    return `#${params.join("&")}`;
+}
+
+// Tolerant parser: malformed/unknown input never throws -- worst case it
+// returns null (nothing to apply) or an object missing some keys (whatever
+// could be salvaged). A bad hash must never break page load.
+export function parseViewState(hash) {
+    try {
+        if (typeof hash !== "string") return null;
+        const trimmed = hash.startsWith("#") ? hash.slice(1) : hash;
+        if (!trimmed) return null;
+
+        const raw = {};
+        for (const pair of trimmed.split("&")) {
+            if (!pair) continue;
+            const eq = pair.indexOf("=");
+            if (eq === -1) continue;
+            const key = pair.slice(0, eq);
+            const value = pair.slice(eq + 1);
+            if (key) raw[key] = value;
+        }
+
+        if (!("v" in raw)) return null;
+        const version = parseInt(raw.v, 10);
+        if (version !== VIEW_STATE_VERSION) return null; // unknown/unsupported version
+
+        const state = {};
+
+        if ("t" in raw) {
+            const t = Number(raw.t);
+            if (Number.isFinite(t)) state.time = t;
+        }
+
+        const camPos = "cam" in raw ? parseVec3(raw.cam) : null;
+        const camTgt = "tgt" in raw ? parseVec3(raw.tgt) : null;
+        const fov = "fov" in raw ? Number(raw.fov) : null;
+        if (camPos || camTgt || (fov !== null && Number.isFinite(fov))) {
+            state.camera = {};
+            if (camPos) state.camera.position = camPos;
+            if (camTgt) state.camera.target = camTgt;
+            if (fov !== null && Number.isFinite(fov)) state.camera.fov = fov;
+        }
+
+        if ("b" in raw) {
+            const b = parseInt(raw.b, 10);
+            if (Number.isInteger(b) && b >= 0) state.batchIndex = b;
+        }
+
+        if ("bvm" in raw) {
+            try {
+                const bvm = decodeURIComponent(raw.bvm);
+                if (bvm) state.bodyVisualizationMode = bvm;
+            } catch {
+                /* malformed percent-encoding: ignore this field */
+            }
+        }
+
+        if ("tcm" in raw) {
+            try {
+                const tcm = decodeURIComponent(raw.tcm);
+                if (tcm) state.terrainColorMode = tcm;
+            } catch {
+                /* malformed percent-encoding: ignore this field */
+            }
+        }
+
+        if ("flags" in raw) {
+            const mask = parseInt(raw.flags, 10);
+            if (Number.isInteger(mask)) {
+                state.toggles = decodeFlags(mask);
+            }
+        }
+
+        return state;
+    } catch {
+        // Never let a malformed hash break page load.
+        return null;
+    }
+}
+
+// Helper for callers building the `toggles` map from a live uiState object
+// (see ui/Controls.js) -- flat-keyed via getPath/setPath so nested paths
+// like "attributeVisible.contacts" work without callers reimplementing the
+// dotted-path walk.
+export function toggleMapFromUiState(uiState) {
+    const toggles = {};
+    BOOLEAN_FLAG_KEYS.forEach((key) => {
+        toggles[key] = !!getPath(uiState, key);
+    });
+    return toggles;
+}
+
+// Applies a decoded `toggles` map (as produced by decodeFlags/parseViewState)
+// onto a target uiState-shaped object in place.
+export function applyToggleMapToUiState(uiState, toggles) {
+    if (!toggles) return;
+    BOOLEAN_FLAG_KEYS.forEach((key) => {
+        if (key in toggles) setPath(uiState, key, !!toggles[key]);
+    });
+}
+
+export { BOOLEAN_FLAG_KEYS };

simview/static/lib/chroma-js-3.1.2/index.min.js

@@ -0,0 +1,8 @@
+/**
+ * Minified by jsDelivr using Terser v5.39.0.
+ * Original file: /npm/chroma-js@3.1.2/index.js
+ *
+ * Do NOT use SRI with dynamically generated files! More information: https://www.jsdelivr.com/using-sri-with-dynamic-files
+ */
+import chroma from"./src/chroma.js";import"./src/io/named/index.js";import"./src/ops/alpha.js";import"./src/ops/clipped.js";import"./src/ops/darken.js";import"./src/ops/get.js";import"./src/ops/luminance.js";import"./src/ops/mix.js";import"./src/ops/premultiply.js";import"./src/ops/saturate.js";import"./src/ops/set.js";import"./src/ops/shade.js";import"./src/interpolator/rgb.js";import"./src/interpolator/lrgb.js";import"./src/interpolator/lab.js";import"./src/interpolator/lch.js";import"./src/interpolator/num.js";import"./src/interpolator/hcg.js";import"./src/interpolator/hsi.js";import"./src/interpolator/hsl.js";import"./src/interpolator/hsv.js";import"./src/interpolator/oklab.js";import"./src/interpolator/oklch.js";import average from"./src/generator/average.js";import bezier from"./src/generator/bezier.js";import blend from"./src/generator/blend.js";import cubehelix from"./src/generator/cubehelix.js";import mix from"./src/generator/mix.js";import random from"./src/generator/random.js";import scale from"./src/generator/scale.js";import{analyze}from"./src/utils/analyze.js";import contrast from"./src/utils/contrast.js";import contrastAPCA from"./src/utils/contrastAPCA.js";import deltaE from"./src/utils/delta-e.js";import distance from"./src/utils/distance.js";import{limits}from"./src/utils/analyze.js";import valid from"./src/utils/valid.js";import input from"./src/io/input.js";import scales from"./src/utils/scales.js";import colors from"./src/colors/w3cx11.js";import brewer from"./src/colors/colorbrewer.js";import Color from"./src/Color.js";Object.assign(chroma,{analyze:analyze,average:average,bezier:bezier,blend:blend,brewer:brewer,Color:Color,colors:colors,contrast:contrast,contrastAPCA:contrastAPCA,cubehelix:cubehelix,deltaE:deltaE,distance:distance,input:input,interpolate:mix,limits:limits,mix:mix,random:random,scale:scale,scales:scales,valid:valid});export default chroma;export{analyze,average,bezier,blend,brewer,Color,colors,contrast,contrastAPCA,cubehelix,deltaE,distance,input,limits,mix,mix as interpolate,random,scale,scales,valid};export*from"./src/io/cmyk/index.js";export*from"./src/io/css/index.js";export*from"./src/io/gl/index.js";export*from"./src/io/hcg/index.js";export*from"./src/io/hex/index.js";export*from"./src/io/hsi/index.js";export*from"./src/io/hsl/index.js";export*from"./src/io/hsv/index.js";export*from"./src/io/lab/index.js";export*from"./src/io/lch/index.js";export*from"./src/io/num/index.js";export*from"./src/io/rgb/index.js";export*from"./src/io/temp/index.js";export*from"./src/io/oklab/index.js";export*from"./src/io/oklch/index.js";
+//# sourceMappingURL=/sm/d1d6f482c381dd513a8673b799d59dde187296efa5ac5889bc30b3834aa7ff07.map