@1agh/maude 0.29.0 → 0.31.0

package/apps/studio/use-annotation-selection.tsx

@@ -10,7 +10,15 @@
  * selection resets (the strokes themselves persist via `.annotations.svg`).
  */
 
-import { createContext, type ReactNode, useCallback, useContext, useMemo, useState } from 'react';
+import {
+  createContext,
+  type ReactNode,
+  useCallback,
+  useContext,
+  useMemo,
+  useRef,
+  useState,
+} from 'react';
 
 export interface AnnotationSelectionValue {
   selectedIds: string[];
@@ -57,10 +65,14 @@ export function AnnotationSelectionProvider({ children }: { children: ReactNode
 
   // Read live from state at call time so multi-step flows in the same tick
   // (e.g. a router callback that adds then asks `contains`) see the staged
-  // result instead of a stale closure capture.
-  const containsRef = { current: selectedIds };
+  // result instead of a stale closure capture. MUST be a real useRef — the
+  // pre-FigJam-v3 code created a fresh `{ current }` object literal every
+  // render, so the stable useCallback closure kept reading the FIRST render's
+  // (empty) selection forever: `contains()` always returned false, which
+  // silently broke hull/multi-drag and click-keeps-selection (user-gate
+  // finding, 2026-06-11).
+  const containsRef = useRef<string[]>(selectedIds);
   containsRef.current = selectedIds;
-  // biome-ignore lint/correctness/useExhaustiveDependencies: ref read intentionally
   const contains = useCallback((id: string) => containsRef.current.includes(id), []);
 
   const value = useMemo<AnnotationSelectionValue>(

package/apps/studio/use-canvas-activity.tsx

@@ -132,7 +132,7 @@ function readActivitySeed(): ActivityMap {
   const out: ActivityMap = {};
   for (const file of Object.keys(seed)) {
     const e = seed[file];
-    if (!e || e.status !== 'active') continue; // only resurrect active overlays
+    if (e?.status !== 'active') continue; // only resurrect active overlays
     out[file] = {
       status: 'active',
       artboardIds: Array.isArray(e.artboardIds) ? e.artboardIds : null,
@@ -199,7 +199,7 @@ export function CanvasActivityProvider({
           setMap((prev) => {
             const entry = prev[detail.file];
             // Only remove if it's still the same idle entry (not re-activated).
-            if (!entry || entry.status !== 'idle' || entry.ts !== ts) return prev;
+            if (entry?.status !== 'idle' || entry.ts !== ts) return prev;
             const { [detail.file]: _drop, ...rest } = prev;
             return rest;
           });

package/apps/studio/use-chrome-visibility.tsx

@@ -0,0 +1,66 @@
+/**
+ * @file       use-chrome-visibility.tsx — canvas-chrome visibility store
+ * @scope      apps/studio/use-chrome-visibility.tsx
+ * @purpose    Tiny store shared by the in-canvas floating chrome — DCMiniMap +
+ *             DCZoomToolbar (canvas-lib), ToolPalette, and AnnotationsLayer —
+ *             so the dev-server menubar can hide/show the minimap and zoom
+ *             controls, and drive a non-destructive "Presentation Mode" that
+ *             overlays-hides ALL chrome (minimap, zoom, tool palette,
+ *             annotations) without mutating the user's individual toggles.
+ *             Mounted by CanvasShell (next to AnnotationsVisibilityProvider) so
+ *             the user canvas (which renders the minimap/zoom) AND its overlay
+ *             siblings under CanvasRouter all consume the same value. Updated
+ *             by the `dgn:'view-chrome'` postMessage handler in CanvasRouter.
+ *
+ *             `present` is a master overlay-hide that supersedes `minimap`/
+ *             `zoom`: while it is on, every chrome consumer renders nothing,
+ *             and exiting restores whatever the individual toggles were.
+ */
+
+import { createContext, type ReactNode, useCallback, useContext, useMemo, useState } from 'react';
+
+export interface ChromeVisibilityState {
+  /** Floating world mini-map (DCMiniMap). */
+  minimap: boolean;
+  /** Bottom zoom pill (DCZoomToolbar). */
+  zoom: boolean;
+  /** Presentation Mode — hides ALL chrome regardless of the two above. */
+  present: boolean;
+}
+
+export interface ChromeVisibilityValue extends ChromeVisibilityState {
+  /** Merge a partial patch (only the provided keys change). */
+  setChrome: (patch: Partial<ChromeVisibilityState>) => void;
+}
+
+const ChromeVisibilityContext = createContext<ChromeVisibilityValue | null>(null);
+
+export function ChromeVisibilityProvider({
+  children,
+  initial,
+}: {
+  children: ReactNode;
+  initial?: Partial<ChromeVisibilityState>;
+}) {
+  const [state, setState] = useState<ChromeVisibilityState>({
+    minimap: initial?.minimap ?? true,
+    zoom: initial?.zoom ?? true,
+    present: initial?.present ?? false,
+  });
+  const setChrome = useCallback((patch: Partial<ChromeVisibilityState>) => {
+    setState((prev) => ({ ...prev, ...patch }));
+  }, []);
+  const value = useMemo<ChromeVisibilityValue>(() => ({ ...state, setChrome }), [state, setChrome]);
+  return (
+    <ChromeVisibilityContext.Provider value={value}>{children}</ChromeVisibilityContext.Provider>
+  );
+}
+
+/**
+ * Returns the chrome-visibility value, or null when rendered outside a
+ * provider (e.g. a bare DS specimen). Consumers treat null as "all visible"
+ * so the default behaviour is unchanged.
+ */
+export function useChromeVisibility(): ChromeVisibilityValue | null {
+  return useContext(ChromeVisibilityContext);
+}