@jax-data-science/sci-image-visualizer 0.8.2 → 0.9.0

package/esm2022/lib/store/class-color.util.mjs

@@ -1,3 +1,4 @@
+import { withRegionPatch } from '../models/region-clone';
 export function normalizeLabel(s) {
     return (s ?? '').trim().toLowerCase();
 }
@@ -10,14 +11,24 @@ export function hashString(s) {
     // Fold to non-negative without the Math.abs(INT_MIN) overflow pitfall.
     return h < 0 ? ~h : h;
 }
-function hslToHex(hDeg, sPct, lPct) {
+/**
+ * The key two class names are compared by under the set's match mode: the name
+ * itself for `exact`, trimmed and lower-cased for `normalized`.
+ */
+export function presetKey(set, label) {
+    return set?.matchMode === 'normalized' ? normalizeLabel(label) : label;
+}
+/** `#RRGGBB` (upper-case) for an HSL colour: hue in degrees, saturation and lightness in %. */
+export function hslToHex(hDeg, sPct, lPct) {
     const s = sPct / 100;
     const l = lPct / 100;
     const k = (n) => (n + hDeg / 30) % 12;
     const a = s * Math.min(l, 1 - l);
     const channel = (n) => {
         const v = l - a * Math.max(-1, Math.min(k(n) - 3, 9 - k(n), 1));
-        return Math.round(255 * v).toString(16).padStart(2, '0');
+        return Math.round(255 * v)
+            .toString(16)
+            .padStart(2, '0');
     };
     return `#${channel(0)}${channel(8)}${channel(4)}`.toUpperCase();
 }
@@ -49,4 +60,36 @@ export function colorForLabel(label, set) {
     const preset = findPreset(label, set);
     return preset ? preset.color : fallbackColorFor(label, set.fallbackPalette);
 }
-//# sourceMappingURL=data:application/json;base64,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
+/**
+ * Resolve each labelled region's colour from the preset set (jit-ui#70). The
+ * presets are the source of truth: a matching preset gives the class colour,
+ * an unknown class its deterministic fallback, **overriding any colour already
+ * on the region** (e.g. embedded in imported GeoJSON). Unlabelled regions and
+ * ones the user recoloured (`colorOverridden`) are left untouched. Unknown
+ * classes are reported through `onPromote` when `autoPromote` is on.
+ *
+ * Returns a new array; regions whose colour is already right are the same
+ * instances.
+ */
+export function applyPresetColors(regions, set, opts = {}) {
+    const known = new Set(set.classes.map((c) => presetKey(set, c.name)));
+    return regions.map((region) => {
+        if (!region.label || region.colorOverridden)
+            return region;
+        const color = colorForLabel(region.label, set);
+        if (set.autoPromote && !known.has(presetKey(set, region.label))) {
+            known.add(presetKey(set, region.label));
+            // In normalized mode, trim the promoted name so leading/trailing
+            // whitespace doesn't create invisible duplicates or odd display names.
+            const name = set.matchMode === 'normalized' ? region.label.trim() : region.label;
+            opts.onPromote?.({ name, color, source: 'auto' });
+        }
+        if (region.color === color)
+            return region;
+        if (!opts.inPlace?.(region))
+            return withRegionPatch(region, { color });
+        region.color = color;
+        return region;
+    });
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"class-color.util.js","sourceRoot":"","sources":["../../../../src/lib/store/class-color.util.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Deterministic colour engine for preset annotation classes (jit-ui#70).\n *\n * Resolution order for a region `label`:\n *   1. a matching preset (exact by default, or normalized if the set's matchMode says so)\n *      -> the preset's colour;\n *   2. otherwise a deterministic fallback colour derived from a stable hash of the name,\n *      so the same unknown class always gets the same colour with no stored state.\n *\n * These functions are pure (no mutation); opt-in promotion of unknown classes into the\n * set is reported to the caller (see {@link applyPresetColors}), which owns persistence.\n */\nimport { ClassPreset, PresetSet } from '../models/class-preset';\nimport { Region } from '../models/region';\nimport { withRegionPatch } from '../models/region-clone';\n\nexport function normalizeLabel(s: string): string {\n  return (s ?? '').trim().toLowerCase();\n}\n\n/** Stable, non-negative 32-bit string hash (identical across runs and machines). */\nexport function hashString(s: string): number {\n  let h = 0;\n  for (let i = 0; i < s.length; i++) {\n    h = (Math.imul(31, h) + s.charCodeAt(i)) | 0;\n  }\n  // Fold to non-negative without the Math.abs(INT_MIN) overflow pitfall.\n  return h < 0 ? ~h : h;\n}\n\n/**\n * The key two class names are compared by under the set's match mode: the name\n * itself for `exact`, trimmed and lower-cased for `normalized`.\n */\nexport function presetKey(set: Pick<PresetSet, 'matchMode'>, label: string): string {\n  return set?.matchMode === 'normalized' ? normalizeLabel(label) : label;\n}\n\n/** `#RRGGBB` (upper-case) for an HSL colour: hue in degrees, saturation and lightness in %. */\nexport function hslToHex(hDeg: number, sPct: number, lPct: number): string {\n  const s = sPct / 100;\n  const l = lPct / 100;\n  const k = (n: number) => (n + hDeg / 30) % 12;\n  const a = s * Math.min(l, 1 - l);\n  const channel = (n: number) => {\n    const v = l - a * Math.max(-1, Math.min(k(n) - 3, 9 - k(n), 1));\n    return Math.round(255 * v)\n      .toString(16)\n      .padStart(2, '0');\n  };\n  return `#${channel(0)}${channel(8)}${channel(4)}`.toUpperCase();\n}\n\n/** Find the preset matching `label` under the set's match mode. */\nexport function findPreset(label: string, set: PresetSet): ClassPreset | undefined {\n  if (!label || !set?.classes) return undefined;\n  if (set.matchMode === 'normalized') {\n    const n = normalizeLabel(label);\n    return set.classes.find((c) => normalizeLabel(c.name) === n);\n  }\n  return set.classes.find((c) => c.name === label);\n}\n\n/**\n * Deterministic fallback colour for an unknown class name: index into the palette by a\n * stable hash of the (normalized) name; if the palette is empty, generate a golden-angle\n * HSL hue. Same name -> same colour, every run.\n */\nexport function fallbackColorFor(label: string, palette: string[]): string {\n  const key = normalizeLabel(label);\n  if (palette && palette.length > 0) {\n    return palette[hashString(key) % palette.length];\n  }\n  const hue = (hashString(key) * 137.508) % 360;\n  return hslToHex(hue, 65, 50);\n}\n\n/** Resolve a colour for `label`: a matching preset's colour, else the deterministic fallback. */\nexport function colorForLabel(label: string, set: PresetSet): string {\n  const preset = findPreset(label, set);\n  return preset ? preset.color : fallbackColorFor(label, set.fallbackPalette);\n}\n\n/** Options for {@link applyPresetColors}. */\nexport interface ApplyPresetColorsOptions {\n  /**\n   * True for a region the caller owns outright (fresh, not yet stored, so in no\n   * undo snapshot): its colour is set in place. Every other region whose\n   * colour changes is copied. Default: never in place.\n   */\n  inPlace?: (r: Region) => boolean;\n  /**\n   * Called once per unknown class when `set.autoPromote` is on, with the\n   * preset to add (name trimmed in `normalized` match mode, `source: 'auto'`).\n   */\n  onPromote?: (preset: ClassPreset) => void;\n}\n\n/**\n * Resolve each labelled region's colour from the preset set (jit-ui#70). The\n * presets are the source of truth: a matching preset gives the class colour,\n * an unknown class its deterministic fallback, **overriding any colour already\n * on the region** (e.g. embedded in imported GeoJSON). Unlabelled regions and\n * ones the user recoloured (`colorOverridden`) are left untouched. Unknown\n * classes are reported through `onPromote` when `autoPromote` is on.\n *\n * Returns a new array; regions whose colour is already right are the same\n * instances.\n */\nexport function applyPresetColors(\n  regions: Region[],\n  set: PresetSet,\n  opts: ApplyPresetColorsOptions = {},\n): Region[] {\n  const known = new Set(set.classes.map((c) => presetKey(set, c.name)));\n  return regions.map((region) => {\n    if (!region.label || region.colorOverridden) return region;\n    const color = colorForLabel(region.label, set);\n    if (set.autoPromote && !known.has(presetKey(set, region.label))) {\n      known.add(presetKey(set, region.label));\n      // In normalized mode, trim the promoted name so leading/trailing\n      // whitespace doesn't create invisible duplicates or odd display names.\n      const name = set.matchMode === 'normalized' ? region.label.trim() : region.label;\n      opts.onPromote?.({ name, color, source: 'auto' });\n    }\n    if (region.color === color) return region;\n    if (!opts.inPlace?.(region)) return withRegionPatch(region, { color });\n    region.color = color;\n    return region;\n  });\n}\n"]}

package/esm2022/lib/store/region-history.mjs

@@ -0,0 +1,146 @@
+import { BehaviorSubject } from 'rxjs';
+/**
+ * Bounded undo/redo history of immutable snapshots (review RT-13, RegionStore
+ * split "RegionHistory").
+ *
+ * Holds snapshots by reference. That is only sound because the store never
+ * changes a snapshot after recording it — `RegionStore` is copy-on-write: each
+ * edit replaces the edited region (and the array) rather than mutating them —
+ * so a snapshot costs one array of pointers, not a deep clone of every vertex.
+ *
+ * Recording: call {@link record} with the state just BEFORE a change. Commits
+ * coalesce into one step:
+ *  - between {@link beginGesture} and {@link endGesture} every commit folds into
+ *    the step its first commit opened, however long the pauses, and a gesture
+ *    never merges with a commit before or after it (RT-12);
+ *  - outside a gesture, each commit within `coalesceMs` of the previous one
+ *    folds into the same step.
+ * A fresh step drops the redo future. Up to `limit` steps are kept each way.
+ */
+export class RegionHistory {
+    constructor(limit = 10, coalesceMs = 250) {
+        this.limit = limit;
+        this.coalesceMs = coalesceMs;
+        this.undoStack = [];
+        this.redoStack = [];
+        /** True while a coalescing burst is open (further commits fold into it). */
+        this.burstOpen = false;
+        /** Open gestures (nested begin/end); while > 0 the burst stays open with no timer. */
+        this.gestureDepth = 0;
+        this.burstTimer = null;
+        /** True while a snapshot is being restored, so the restore records nothing. */
+        this.restoring = false;
+        this.canUndoSubject = new BehaviorSubject(false);
+        this.canRedoSubject = new BehaviorSubject(false);
+        /** Whether an undo step is available (drives the toolbar's Undo button). */
+        this.canUndo$ = this.canUndoSubject.asObservable();
+        /** Whether a redo step is available. */
+        this.canRedo$ = this.canRedoSubject.asObservable();
+    }
+    canUndo() {
+        return this.undoStack.length > 0;
+    }
+    canRedo() {
+        return this.redoStack.length > 0;
+    }
+    /**
+     * Record `before` — the state just before a change — unless the change
+     * folds into the step already open, or a restore is in progress.
+     */
+    record(before) {
+        if (this.restoring)
+            return;
+        const startsBurst = !this.burstOpen;
+        if (this.gestureDepth > 0)
+            this.burstOpen = true; // closed by endGesture()
+        else
+            this.armBurst();
+        if (!startsBurst)
+            return;
+        this.push(this.undoStack, before);
+        this.redoStack = [];
+        this.emit();
+    }
+    /**
+     * Step back: returns the state to restore (and keeps `current` for redo), or
+     * undefined when there is nothing to undo. Restore it inside {@link restore}.
+     */
+    undo(current) {
+        const snapshot = this.undoStack.pop();
+        if (snapshot === undefined)
+            return undefined;
+        this.push(this.redoStack, current);
+        this.closeBurst();
+        this.emit();
+        return snapshot;
+    }
+    /** Step forward again: the mirror of {@link undo}. */
+    redo(current) {
+        const snapshot = this.redoStack.pop();
+        if (snapshot === undefined)
+            return undefined;
+        this.push(this.undoStack, current);
+        this.closeBurst();
+        this.emit();
+        return snapshot;
+    }
+    /** Run `fn` (applying an undo/redo snapshot) without recording anything it triggers. */
+    restore(fn) {
+        this.restoring = true;
+        try {
+            fn();
+        }
+        finally {
+            this.restoring = false;
+        }
+    }
+    /** Forget every step (an image load/switch: history never crosses images). */
+    reset() {
+        this.undoStack = [];
+        this.redoStack = [];
+        this.closeBurst();
+        this.emit();
+    }
+    /** Start one user gesture: every commit until the matching {@link endGesture} is one step. Nests. */
+    beginGesture() {
+        if (this.gestureDepth++ === 0)
+            this.closeBurst();
+    }
+    /** End the gesture opened by {@link beginGesture}; the next commit starts a new step. */
+    endGesture() {
+        if (this.gestureDepth === 0)
+            return;
+        if (--this.gestureDepth === 0)
+            this.closeBurst();
+    }
+    push(stack, state) {
+        stack.push(state);
+        if (stack.length > this.limit)
+            stack.shift();
+    }
+    /** (Re)arm the idle timer that closes the current coalescing burst. */
+    armBurst() {
+        this.burstOpen = true;
+        if (this.burstTimer)
+            clearTimeout(this.burstTimer);
+        this.burstTimer = setTimeout(() => {
+            this.burstOpen = false;
+            this.burstTimer = null;
+        }, this.coalesceMs);
+    }
+    closeBurst() {
+        this.burstOpen = false;
+        if (this.burstTimer) {
+            clearTimeout(this.burstTimer);
+            this.burstTimer = null;
+        }
+    }
+    emit() {
+        const canUndo = this.canUndo(), canRedo = this.canRedo();
+        if (this.canUndoSubject.value !== canUndo)
+            this.canUndoSubject.next(canUndo);
+        if (this.canRedoSubject.value !== canRedo)
+            this.canRedoSubject.next(canRedo);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"region-history.js","sourceRoot":"","sources":["../../../../src/lib/store/region-history.ts"],"names":[],"mappings":"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","sourcesContent":["import { BehaviorSubject, Observable } from 'rxjs';\n\n/**\n * Bounded undo/redo history of immutable snapshots (review RT-13, RegionStore\n * split \"RegionHistory\").\n *\n * Holds snapshots by reference. That is only sound because the store never\n * changes a snapshot after recording it — `RegionStore` is copy-on-write: each\n * edit replaces the edited region (and the array) rather than mutating them —\n * so a snapshot costs one array of pointers, not a deep clone of every vertex.\n *\n * Recording: call {@link record} with the state just BEFORE a change. Commits\n * coalesce into one step:\n *  - between {@link beginGesture} and {@link endGesture} every commit folds into\n *    the step its first commit opened, however long the pauses, and a gesture\n *    never merges with a commit before or after it (RT-12);\n *  - outside a gesture, each commit within `coalesceMs` of the previous one\n *    folds into the same step.\n * A fresh step drops the redo future. Up to `limit` steps are kept each way.\n */\nexport class RegionHistory<T> {\n  private undoStack: T[] = [];\n  private redoStack: T[] = [];\n  /** True while a coalescing burst is open (further commits fold into it). */\n  private burstOpen = false;\n  /** Open gestures (nested begin/end); while > 0 the burst stays open with no timer. */\n  private gestureDepth = 0;\n  private burstTimer: ReturnType<typeof setTimeout> | null = null;\n  /** True while a snapshot is being restored, so the restore records nothing. */\n  private restoring = false;\n  private readonly canUndoSubject = new BehaviorSubject<boolean>(false);\n  private readonly canRedoSubject = new BehaviorSubject<boolean>(false);\n\n  constructor(\n    private readonly limit = 10,\n    private readonly coalesceMs = 250,\n  ) {}\n\n  /** Whether an undo step is available (drives the toolbar's Undo button). */\n  readonly canUndo$: Observable<boolean> = this.canUndoSubject.asObservable();\n  /** Whether a redo step is available. */\n  readonly canRedo$: Observable<boolean> = this.canRedoSubject.asObservable();\n\n  canUndo(): boolean {\n    return this.undoStack.length > 0;\n  }\n\n  canRedo(): boolean {\n    return this.redoStack.length > 0;\n  }\n\n  /**\n   * Record `before` — the state just before a change — unless the change\n   * folds into the step already open, or a restore is in progress.\n   */\n  record(before: T): void {\n    if (this.restoring) return;\n    const startsBurst = !this.burstOpen;\n    if (this.gestureDepth > 0)\n      this.burstOpen = true; // closed by endGesture()\n    else this.armBurst();\n    if (!startsBurst) return;\n    this.push(this.undoStack, before);\n    this.redoStack = [];\n    this.emit();\n  }\n\n  /**\n   * Step back: returns the state to restore (and keeps `current` for redo), or\n   * undefined when there is nothing to undo. Restore it inside {@link restore}.\n   */\n  undo(current: T): T | undefined {\n    const snapshot = this.undoStack.pop();\n    if (snapshot === undefined) return undefined;\n    this.push(this.redoStack, current);\n    this.closeBurst();\n    this.emit();\n    return snapshot;\n  }\n\n  /** Step forward again: the mirror of {@link undo}. */\n  redo(current: T): T | undefined {\n    const snapshot = this.redoStack.pop();\n    if (snapshot === undefined) return undefined;\n    this.push(this.undoStack, current);\n    this.closeBurst();\n    this.emit();\n    return snapshot;\n  }\n\n  /** Run `fn` (applying an undo/redo snapshot) without recording anything it triggers. */\n  restore(fn: () => void): void {\n    this.restoring = true;\n    try {\n      fn();\n    } finally {\n      this.restoring = false;\n    }\n  }\n\n  /** Forget every step (an image load/switch: history never crosses images). */\n  reset(): void {\n    this.undoStack = [];\n    this.redoStack = [];\n    this.closeBurst();\n    this.emit();\n  }\n\n  /** Start one user gesture: every commit until the matching {@link endGesture} is one step. Nests. */\n  beginGesture(): void {\n    if (this.gestureDepth++ === 0) this.closeBurst();\n  }\n\n  /** End the gesture opened by {@link beginGesture}; the next commit starts a new step. */\n  endGesture(): void {\n    if (this.gestureDepth === 0) return;\n    if (--this.gestureDepth === 0) this.closeBurst();\n  }\n\n  private push(stack: T[], state: T): void {\n    stack.push(state);\n    if (stack.length > this.limit) stack.shift();\n  }\n\n  /** (Re)arm the idle timer that closes the current coalescing burst. */\n  private armBurst(): void {\n    this.burstOpen = true;\n    if (this.burstTimer) clearTimeout(this.burstTimer);\n    this.burstTimer = setTimeout(() => {\n      this.burstOpen = false;\n      this.burstTimer = null;\n    }, this.coalesceMs);\n  }\n\n  private closeBurst(): void {\n    this.burstOpen = false;\n    if (this.burstTimer) {\n      clearTimeout(this.burstTimer);\n      this.burstTimer = null;\n    }\n  }\n\n  private emit(): void {\n    const canUndo = this.canUndo(),\n      canRedo = this.canRedo();\n    if (this.canUndoSubject.value !== canUndo) this.canUndoSubject.next(canUndo);\n    if (this.canRedoSubject.value !== canRedo) this.canRedoSubject.next(canRedo);\n  }\n}\n"]}

package/esm2022/lib/store/region-scope-cache.mjs

@@ -0,0 +1,140 @@
+import { withRegionZ } from '../models/region-clone';
+/**
+ * Where the region store's *live* set comes from and goes back to: a per-image
+ * cache (keyed by the image's first URL, else its file name) and, while a
+ * z-stack is loaded, a per-slice map for the current image (jit-ui#93).
+ *
+ * The owner holds the live array; every method that can change scope takes
+ * the current live array (to capture its edits) and returns the incoming
+ * live set, or null when nothing changes. It never changes a region: slice
+ * tags are applied to copies ({@link withRegionZ}).
+ */
+export class RegionScopeCache {
+    constructor() {
+        this.byImage = new Map();
+        this.bySlice = new Map();
+        this.stack = false;
+        this.sliceZ = 0;
+        this.layout = 'combined';
+        /** Slices loaded with regions: a per-slice-file save re-writes them even when
+         *  now empty, so clearing a slice and saving removes its geojson. */
+        this.initialNonEmpty = new Set();
+    }
+    /** The cache key for an image: its first URL, else its file name. */
+    static imageKey(imageInfo) {
+        if (!imageInfo)
+            return undefined;
+        if (imageInfo.urls && imageInfo.urls.length > 0 && imageInfo.urls[0]) {
+            return imageInfo.urls[0];
+        }
+        return imageInfo.fileName || undefined;
+    }
+    /** True while a z-stack is loaded and regions are held per slice. */
+    get stackMode() {
+        return this.stack;
+    }
+    /** The current display slice (zero-based; 0 outside stack mode unless set). */
+    get displaySlice() {
+        return this.sliceZ;
+    }
+    /** How the current stack persists; meaningless outside stack mode. */
+    get saveLayout() {
+        return this.layout;
+    }
+    /** Record `live` as the current image's regions. */
+    sync(live) {
+        if (this.imageKey)
+            this.byImage.set(this.imageKey, live.slice());
+    }
+    /**
+     * Make `key` the active image: ends stack mode, caches `live` under the
+     * outgoing image, and returns the incoming image's regions (or []). Null when
+     * `key` already is the active image (repeated replots keep their regions).
+     */
+    switchImage(key, live) {
+        if (this.imageKey === key)
+            return null;
+        // The loader re-enters stack mode afterwards if the new image is a z-stack.
+        this.exitStack();
+        if (this.imageKey)
+            this.byImage.set(this.imageKey, live.slice());
+        this.imageKey = key;
+        const cached = key ? this.byImage.get(key) : undefined;
+        return cached ? cached.slice() : [];
+    }
+    /**
+     * Enter per-slice mode with `slices` (already admitted by the store, each
+     * region tagged with its slice) and return `initialZ`'s slice as the live set.
+     */
+    enterStack(slices, initialZ, layout) {
+        this.stack = true;
+        this.layout = layout;
+        this.sliceZ = initialZ || 0;
+        this.bySlice = new Map();
+        this.initialNonEmpty = new Set();
+        for (const [z, regs] of slices) {
+            this.bySlice.set(z, regs);
+            if (regs.length)
+                this.initialNonEmpty.add(z);
+        }
+        return (this.bySlice.get(this.sliceZ) ?? []).slice();
+    }
+    /** Leave stack mode; a no-op outside it. */
+    exitStack() {
+        if (!this.stack)
+            return;
+        this.stack = false;
+        this.sliceZ = 0;
+        this.bySlice = new Map();
+        this.initialNonEmpty = new Set();
+    }
+    /**
+     * Show slice `z`: capture `live` into the current slice and return slice
+     * `z`'s regions. Null when nothing swaps — the same slice, or outside stack
+     * mode (where the index is only recorded).
+     */
+    showSlice(z, live) {
+        const next = z || 0;
+        if (!this.stack) {
+            this.sliceZ = next;
+            return null;
+        }
+        if (this.sliceZ === next)
+            return null;
+        this.bySlice.set(this.sliceZ, live.slice());
+        this.sliceZ = next;
+        return (this.bySlice.get(next) ?? []).slice();
+    }
+    /** Every slice's regions (current one from `live`), each tagged with its z,
+     *  in slice order; `live` itself outside stack mode. */
+    sliceRegions(live) {
+        if (!this.stack)
+            return live.slice();
+        this.bySlice.set(this.sliceZ, live.slice());
+        const out = [];
+        const zs = Array.from(this.bySlice.keys()).sort((a, b) => a - b);
+        for (const z of zs) {
+            for (const r of this.bySlice.get(z))
+                out.push(withRegionZ(r, z));
+        }
+        return out;
+    }
+    /** Slices to write on a per-slice-file save: every slice with regions plus
+     *  every slice loaded non-empty (re-written empty when cleared). Empty
+     *  outside stack mode. */
+    stackSaveSlices(live) {
+        const out = new Map();
+        if (!this.stack)
+            return out;
+        this.bySlice.set(this.sliceZ, live.slice());
+        const zs = new Set(this.initialNonEmpty);
+        for (const [z, regs] of this.bySlice)
+            if (regs.length)
+                zs.add(z);
+        for (const z of Array.from(zs).sort((a, b) => a - b)) {
+            out.set(z, (this.bySlice.get(z) ?? []).map((r) => withRegionZ(r, z)));
+        }
+        return out;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"region-scope-cache.js","sourceRoot":"","sources":["../../../../src/lib/store/region-scope-cache.ts"],"names":[],"mappings":"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","sourcesContent":["import { IImageInfo } from '../contracts/image.contract';\nimport { Region } from '../models/region';\nimport { withRegionZ } from '../models/region-clone';\n\n/** How a stack's regions round-trip to disk (jit-ui#93): `combined` writes one\n *  z-indexed geojson (single-file z-stack, QuPath schema); `per-slice-file`\n *  writes one geojson per slice-file (a folder of numbered images). */\nexport type StackSaveLayout = 'combined' | 'per-slice-file';\n\n/**\n * Where the region store's *live* set comes from and goes back to: a per-image\n * cache (keyed by the image's first URL, else its file name) and, while a\n * z-stack is loaded, a per-slice map for the current image (jit-ui#93).\n *\n * The owner holds the live array; every method that can change scope takes\n * the current live array (to capture its edits) and returns the incoming\n * live set, or null when nothing changes. It never changes a region: slice\n * tags are applied to copies ({@link withRegionZ}).\n */\nexport class RegionScopeCache {\n  private byImage = new Map<string, Region[]>();\n  private imageKey: string | undefined;\n\n  private bySlice = new Map<number, Region[]>();\n  private stack = false;\n  private sliceZ = 0;\n  private layout: StackSaveLayout = 'combined';\n  /** Slices loaded with regions: a per-slice-file save re-writes them even when\n   *  now empty, so clearing a slice and saving removes its geojson. */\n  private initialNonEmpty = new Set<number>();\n\n  /** The cache key for an image: its first URL, else its file name. */\n  static imageKey(imageInfo: IImageInfo | undefined): string | undefined {\n    if (!imageInfo) return undefined;\n    if (imageInfo.urls && imageInfo.urls.length > 0 && imageInfo.urls[0]) {\n      return imageInfo.urls[0];\n    }\n    return imageInfo.fileName || undefined;\n  }\n\n  /** True while a z-stack is loaded and regions are held per slice. */\n  get stackMode(): boolean {\n    return this.stack;\n  }\n\n  /** The current display slice (zero-based; 0 outside stack mode unless set). */\n  get displaySlice(): number {\n    return this.sliceZ;\n  }\n\n  /** How the current stack persists; meaningless outside stack mode. */\n  get saveLayout(): StackSaveLayout {\n    return this.layout;\n  }\n\n  /** Record `live` as the current image's regions. */\n  sync(live: Region[]): void {\n    if (this.imageKey) this.byImage.set(this.imageKey, live.slice());\n  }\n\n  /**\n   * Make `key` the active image: ends stack mode, caches `live` under the\n   * outgoing image, and returns the incoming image's regions (or []). Null when\n   * `key` already is the active image (repeated replots keep their regions).\n   */\n  switchImage(key: string | undefined, live: Region[]): Region[] | null {\n    if (this.imageKey === key) return null;\n    // The loader re-enters stack mode afterwards if the new image is a z-stack.\n    this.exitStack();\n    if (this.imageKey) this.byImage.set(this.imageKey, live.slice());\n    this.imageKey = key;\n    const cached = key ? this.byImage.get(key) : undefined;\n    return cached ? cached.slice() : [];\n  }\n\n  /**\n   * Enter per-slice mode with `slices` (already admitted by the store, each\n   * region tagged with its slice) and return `initialZ`'s slice as the live set.\n   */\n  enterStack(slices: Map<number, Region[]>, initialZ: number, layout: StackSaveLayout): Region[] {\n    this.stack = true;\n    this.layout = layout;\n    this.sliceZ = initialZ || 0;\n    this.bySlice = new Map<number, Region[]>();\n    this.initialNonEmpty = new Set<number>();\n    for (const [z, regs] of slices) {\n      this.bySlice.set(z, regs);\n      if (regs.length) this.initialNonEmpty.add(z);\n    }\n    return (this.bySlice.get(this.sliceZ) ?? []).slice();\n  }\n\n  /** Leave stack mode; a no-op outside it. */\n  exitStack(): void {\n    if (!this.stack) return;\n    this.stack = false;\n    this.sliceZ = 0;\n    this.bySlice = new Map<number, Region[]>();\n    this.initialNonEmpty = new Set<number>();\n  }\n\n  /**\n   * Show slice `z`: capture `live` into the current slice and return slice\n   * `z`'s regions. Null when nothing swaps — the same slice, or outside stack\n   * mode (where the index is only recorded).\n   */\n  showSlice(z: number, live: Region[]): Region[] | null {\n    const next = z || 0;\n    if (!this.stack) {\n      this.sliceZ = next;\n      return null;\n    }\n    if (this.sliceZ === next) return null;\n    this.bySlice.set(this.sliceZ, live.slice());\n    this.sliceZ = next;\n    return (this.bySlice.get(next) ?? []).slice();\n  }\n\n  /** Every slice's regions (current one from `live`), each tagged with its z,\n   *  in slice order; `live` itself outside stack mode. */\n  sliceRegions(live: Region[]): Region[] {\n    if (!this.stack) return live.slice();\n    this.bySlice.set(this.sliceZ, live.slice());\n    const out: Region[] = [];\n    const zs = Array.from(this.bySlice.keys()).sort((a, b) => a - b);\n    for (const z of zs) {\n      for (const r of this.bySlice.get(z) as Region[]) out.push(withRegionZ(r, z));\n    }\n    return out;\n  }\n\n  /** Slices to write on a per-slice-file save: every slice with regions plus\n   *  every slice loaded non-empty (re-written empty when cleared). Empty\n   *  outside stack mode. */\n  stackSaveSlices(live: Region[]): Map<number, Region[]> {\n    const out = new Map<number, Region[]>();\n    if (!this.stack) return out;\n    this.bySlice.set(this.sliceZ, live.slice());\n    const zs = new Set<number>(this.initialNonEmpty);\n    for (const [z, regs] of this.bySlice) if (regs.length) zs.add(z);\n    for (const z of Array.from(zs).sort((a, b) => a - b)) {\n      out.set(\n        z,\n        (this.bySlice.get(z) ?? []).map((r) => withRegionZ(r, z)),\n      );\n    }\n    return out;\n  }\n}\n"]}

package/esm2022/lib/store/region-selection.mjs

@@ -0,0 +1,82 @@
+import { BehaviorSubject } from 'rxjs';
+/**
+ * Region selection, held by region *id* (stable across edits, reorders and
+ * delete/add cycles) and projected to array indices for the IRegionStore
+ * boundary. Changing the ids ({@link replace}, {@link retain}) is silent; the
+ * owner calls {@link sync} once the region array it projects onto is final,
+ * which prunes ids that no longer exist and emits {@link indices$} only when
+ * the index set changed.
+ */
+export class RegionSelection {
+    constructor() {
+        this.selected = [];
+        this.indicesSubject = new BehaviorSubject([]);
+        /** The selected regions' current array indices (emits on change only). */
+        this.indices$ = this.indicesSubject.asObservable();
+    }
+    /** The selected indices as last projected by {@link sync}. */
+    get indices() {
+        return this.indicesSubject.value;
+    }
+    /** The selected ids, in selection order. */
+    get ids() {
+        return this.selected;
+    }
+    /** Replace the selected ids (no emit until {@link sync}). */
+    replace(ids) {
+        this.selected = ids.slice();
+    }
+    /** Keep only the ids `keep` accepts (no emit until {@link sync}). */
+    retain(keep) {
+        this.selected = this.selected.filter(keep);
+    }
+    /**
+     * Select by array index into `regions`: invalid and duplicate indices are
+     * dropped, the given order is kept. Projects and emits.
+     */
+    selectIndices(indices, regions) {
+        const ids = [];
+        const seen = new Set();
+        for (const i of indices || []) {
+            if (!Number.isFinite(i) || i < 0 || i >= regions.length)
+                continue;
+            const id = regions[i].id;
+            if (!seen.has(id)) {
+                seen.add(id);
+                ids.push(id);
+            }
+        }
+        this.selected = ids;
+        this.sync(regions);
+    }
+    /** Project the selected ids onto `regions`, pruning ids it no longer holds,
+     *  and emit if the index set changed. */
+    sync(regions) {
+        const indexOf = new Map();
+        regions.forEach((r, i) => {
+            if (!indexOf.has(r.id))
+                indexOf.set(r.id, i);
+        });
+        const indices = [];
+        const live = [];
+        for (const id of this.selected) {
+            const idx = indexOf.get(id);
+            if (idx !== undefined) {
+                indices.push(idx);
+                live.push(id);
+            }
+        }
+        this.selected = live;
+        if (!sameIndices(this.indicesSubject.value, indices))
+            this.indicesSubject.next(indices);
+    }
+}
+function sameIndices(a, b) {
+    if (a.length !== b.length)
+        return false;
+    for (let i = 0; i < a.length; i++)
+        if (a[i] !== b[i])
+            return false;
+    return true;
+}
+//# sourceMappingURL=data:application/json;base64,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