@miadi/stateloom-web 0.3.3 → 0.3.5

package/server/src/lib/markRequest.ts

@@ -0,0 +1,24 @@
+"use client";
+
+/**
+ * "Open that mark": something outside the board (the Talk dock's list of marks) asks the
+ * board showing `doc` to open the thread of mark `id`. The request waits here until that
+ * board has read its marks — the drawing may still be opening — and is taken once.
+ */
+export const MARK_REQUEST_EVENT = "stateloom:mark-request";
+
+let pending: { doc: string; id: string } | null = null;
+
+export function requestMark(doc: string, id: string): void {
+  pending = { doc, id };
+  window.dispatchEvent(new Event(MARK_REQUEST_EVENT));
+}
+
+/** The mark asked for on `doc`, if any; it stays asked until `clearMarkRequest`. */
+export function markRequested(doc: string | null): string | null {
+  return doc && pending?.doc === doc ? pending.id : null;
+}
+
+export function clearMarkRequest(): void {
+  pending = null;
+}

package/server/src/lib/systemOf.ts

@@ -0,0 +1,80 @@
+import { readFileSync, readdirSync, realpathSync } from "fs";
+import { dirname, join, sep } from "path";
+import { isSysdfPath, isSystemDefinition, resolveMemberPath } from "@miadi/stateloom-protocol";
+import { allowedDocRoots, chronicleRoot, resolveDocPath } from "./projectFile";
+
+/** How many folders above the document are searched. */
+const SEARCH_DEPTH = 8;
+
+const realOr = (path: string): string => {
+  try {
+    return realpathSync(path);
+  } catch {
+    return path;
+  }
+};
+
+/** Could the file API serve something in `dir`, or in a folder below it? */
+function underAnAdmittedRoot(dir: string): boolean {
+  const roots = allowedDocRoots();
+  const chronicle = chronicleRoot();
+  if (chronicle) roots.push(chronicle);
+  return roots.some((root) => dir === root || dir.startsWith(root + sep));
+}
+
+export type SystemOfResult = { ok: true; doc: string; system: string | null } | { ok: false; error: string };
+
+/** The admitted, readable system at `path` lists `target`: its resolved path, else null. */
+function listing(path: string, target: string): string | null {
+  const candidate = resolveDocPath(path);
+  if (!candidate.ok || !isSysdfPath(candidate.path)) return null;
+  let def: unknown;
+  try {
+    def = JSON.parse(readFileSync(candidate.path, "utf8"));
+  } catch {
+    return null;
+  }
+  if (!isSystemDefinition(def)) return null;
+  const listed = def.members.some((m) => !!m?.path && realOr(resolveMemberPath(candidate.path, m.path)) === target);
+  return listed ? candidate.path : null;
+}
+
+/**
+ * The system that lists `doc` (Spec 82), so a drawing opened alone (`?doc=`
+ * with no `system=`, the link an agent prints) is still read as a member of its
+ * system and the strip can lead back to the map and to the other drawings.
+ *
+ * `preferred` (the `system=` already in the URL) answers when it lists the
+ * document: a drawing two systems share stays in the one the person came from.
+ * Otherwise the rule is the MCP's (`systemFor` in mcp/src/system.ts): the first
+ * `.sysdf.json`, in name order, in the document's own folder and then in each
+ * parent folder, that names the document as a member. Every candidate goes
+ * through `resolveDocPath`, so this reads only systems the file API would serve
+ * and never names a path it refuses. The walk stops at the admitted roots.
+ */
+export function systemOfDoc(doc: string, preferred?: string | null): SystemOfResult {
+  const resolution = resolveDocPath(doc);
+  if (!resolution.ok) return { ok: false, error: resolution.error };
+  const target = resolution.path;
+  if (isSysdfPath(target)) return { ok: true, doc: target, system: null };
+  const kept = preferred ? listing(preferred, target) : null;
+  if (kept) return { ok: true, doc: target, system: kept };
+
+  let dir = dirname(target);
+  for (let depth = 0; depth <= SEARCH_DEPTH && underAnAdmittedRoot(dir); depth += 1) {
+    let names: string[] = [];
+    try {
+      names = readdirSync(dir).filter((f) => !f.startsWith(".") && isSysdfPath(f)).sort();
+    } catch {
+      // An unreadable folder lists nothing.
+    }
+    for (const name of names) {
+      const system = listing(join(dir, name), target);
+      if (system) return { ok: true, doc: target, system };
+    }
+    const parent = dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return { ok: true, doc: target, system: null };
+}

package/server/src/lib/systemParam.ts

@@ -15,13 +15,17 @@
  *   the strip can list its links.
  * - `stateloom:system-changed`: a member or the system file was written; every
  *   holder of a loaded system reloads it.
+ * - `stateloom:system-found`: `system=` was written for the document already
+ *   open (`useSystemOfDoc`); nothing else moved.
  */
 import { useEffect, useState } from "react";
+import { isSysdfPath } from "@miadi/stateloom-protocol";
 import { DOC_CHANGE_EVENT } from "./docParam";
 
 export const FOCUS_EVENT = "stateloom:focus";
 export const FOCUS_REQUEST_EVENT = "stateloom:focus-request";
 export const SYSTEM_CHANGED_EVENT = "stateloom:system-changed";
+export const SYSTEM_FOUND_EVENT = "stateloom:system-found";
 /** A one-line note for the system strip: `{ detail: { text, origin? } }`. */
 export const STRIP_NOTE_EVENT = "stateloom:strip-note";
 
@@ -36,7 +40,7 @@ export function useUrlParam(name: string): string | null {
   useEffect(() => {
     const update = () => setValue(urlParam(name));
     update();
-    const events = ["popstate", DOC_CHANGE_EVENT, FOCUS_EVENT, FOCUS_REQUEST_EVENT];
+    const events = ["popstate", DOC_CHANGE_EVENT, FOCUS_EVENT, FOCUS_REQUEST_EVENT, SYSTEM_FOUND_EVENT];
     for (const e of events) window.addEventListener(e, update);
     return () => {
       for (const e of events) window.removeEventListener(e, update);
@@ -45,6 +49,47 @@ export function useUrlParam(name: string): string | null {
   return value;
 }
 
+/**
+ * Read the open drawing as a member of the system that lists it. A drawing
+ * opened alone (`?doc=` and no `system=`, the link an agent prints) had no
+ * strip, so nothing led back to the map or on to the other drawings. And a
+ * drawing reached by the document switcher kept the strip of the system it was
+ * left from, even when another system lists it.
+ *
+ * The server answers (`/api/system-of`, lib/systemOf.ts): the system already in
+ * the URL when it lists the drawing, else the nearest one that does. When it
+ * names another system, `system=` is rewritten in place, without a history
+ * entry: the person did not move, the view learned where it is. When no system
+ * lists the drawing, the URL is left as it is, and a strip already on screen
+ * stays while the person browses.
+ */
+export function useSystemOfDoc(doc: string | null, system: string | null): void {
+  useEffect(() => {
+    if (!doc || isSysdfPath(doc)) return;
+    let live = true;
+    const query = new URLSearchParams({ doc });
+    if (system) query.set("system", system);
+    fetch(`/api/system-of?${query.toString()}`, { cache: "no-store" })
+      .then((r) => (r.ok ? r.json() : null))
+      .then((body: { system?: string | null } | null) => {
+        const found = body?.system;
+        if (!live || !found || found === system) return;
+        // The person moved on while the server looked: this answer is for a view that is gone.
+        if (urlParam("doc") !== doc || urlParam("system") !== system) return;
+        const url = new URL(window.location.href);
+        url.searchParams.set("system", found);
+        window.history.replaceState(window.history.state, "", url);
+        window.dispatchEvent(new Event(SYSTEM_FOUND_EVENT));
+      })
+      .catch(() => {
+        // An older server has no /api/system-of: the drawing opens alone, as before.
+      });
+    return () => {
+      live = false;
+    };
+  }, [doc, system]);
+}
+
 /** The query string for a member opened inside a system, focused on one element. */
 export function systemQuery(target: { doc: string; system?: string | null; focus?: string | null }): string {
   const params = new URLSearchParams();

package/server/src/lib/useNarrow.ts

@@ -0,0 +1,30 @@
+"use client";
+
+import { useEffect, useState } from "react";
+
+/**
+ * A phone held upright: below 600 px the stage's caption, a mark's card and the Talk
+ * conversation share one sheet at the bottom of the board (Spec 83, lane U finding U2).
+ */
+export const NARROW_QUERY = "(max-width: 599px)";
+
+function matches(query: string): boolean {
+  try {
+    return typeof window !== "undefined" && typeof window.matchMedia === "function" && window.matchMedia(query).matches;
+  } catch {
+    return false;
+  }
+}
+
+export function useNarrow(query = NARROW_QUERY): boolean {
+  const [narrow, setNarrow] = useState(() => matches(query));
+  useEffect(() => {
+    if (typeof window.matchMedia !== "function") return;
+    const mq = window.matchMedia(query);
+    const update = () => setNarrow(mq.matches);
+    update();
+    mq.addEventListener("change", update);
+    return () => mq.removeEventListener("change", update);
+  }, [query]);
+  return narrow;
+}

package/server/stateloom-web.json

@@ -1,5 +1,5 @@
 {
-  "package": "0.3.3",
-  "designer": "0.3.3",
+  "package": "0.3.5",
+  "designer": "0.3.5",
   "next": "16.1.6"
 }