stitchkit 0.100.2 → 0.101.0

package/dist/entrypoints/react/keyboard.js

@@ -0,0 +1,397 @@
+// src/react/keyboard/hooks.ts
+import { useEffect, useRef, useState, useSyncExternalStore } from "react";
+
+// src/react/keyboard/layers.ts
+var RANK = {
+  overlay: 4,
+  local: 3,
+  route: 2,
+  zone: 1,
+  global: 0
+};
+var KEY_FIELD_SELECTOR = [
+  "input:not([type=button],[type=submit],[type=reset],[type=checkbox],[type=image])",
+  "textarea",
+  "select",
+  "[contenteditable]:not([contenteditable=false])",
+  "[role=textbox]",
+  "[role=combobox]",
+  "[role=slider]",
+  "[role=spinbutton]",
+  "[data-local-keys]"
+].join(",");
+function hasClosest(target) {
+  return typeof target === "object" && target !== null && "closest" in target && typeof target.closest === "function";
+}
+function closestFromTarget(target, selectors) {
+  return hasClosest(target) ? target.closest(selectors) : null;
+}
+function isKeyFieldTarget(target) {
+  const field = closestFromTarget(target, KEY_FIELD_SELECTOR);
+  return field !== null && field !== undefined;
+}
+function liveScope(entry) {
+  const read = entry.state.scope;
+  if (read === undefined)
+    return "unscoped";
+  const element = read();
+  if (element === null || !element.isConnected)
+    return null;
+  const inert = element.closest("[inert]");
+  if (inert !== null && inert !== undefined)
+    return null;
+  if (element.checkVisibility !== undefined && !element.checkVisibility())
+    return null;
+  return element;
+}
+function askingOrder(entries) {
+  const live = [];
+  for (const entry of entries) {
+    if (entry.state.active === false)
+      continue;
+    const scope = liveScope(entry);
+    if (scope !== null)
+      live.push({ entry, scope, depth: 0 });
+  }
+  for (const layer of live) {
+    const own = layer.scope;
+    if (own === "unscoped")
+      continue;
+    layer.depth = live.filter((other) => other !== layer && other.entry.state.kind === layer.entry.state.kind && other.scope !== "unscoped" && other.scope !== own && other.scope.contains(own)).length;
+  }
+  return live.sort((left, right) => RANK[right.entry.state.kind] - RANK[left.entry.state.kind] || right.depth - left.depth || right.entry.order - left.entry.order);
+}
+function createKeyLayerStack(target) {
+  const entries = new Set;
+  let activations = 0;
+  const listener = (event) => {
+    dispatch(event);
+  };
+  function dispatch(event) {
+    if (event.defaultPrevented || event.isComposing)
+      return false;
+    const isEscape = event.key === "Escape";
+    if (isEscape && event.repeat)
+      return false;
+    const inField = !isEscape && isKeyFieldTarget(event.target);
+    let behindOverlay = false;
+    for (const { entry } of askingOrder(entries)) {
+      const { kind } = entry.state;
+      if (behindOverlay && kind !== "overlay")
+        break;
+      if (kind === "overlay")
+        behindOverlay = true;
+      if (inField && entry.state.fields !== "include")
+        continue;
+      if (entry.state.onKey(event)) {
+        event.preventDefault();
+        return true;
+      }
+    }
+    return false;
+  }
+  function add(state) {
+    const entry = { state, order: ++activations };
+    if (entries.size === 0)
+      target.addEventListener("keydown", listener);
+    entries.add(entry);
+    return {
+      update(next) {
+        const reactivated = entry.state.active === false && next.active !== false;
+        entry.state = next;
+        if (reactivated)
+          entry.order = ++activations;
+      },
+      remove() {
+        if (!entries.delete(entry))
+          return;
+        if (entries.size === 0)
+          target.removeEventListener("keydown", listener);
+      }
+    };
+  }
+  return { add, dispatch };
+}
+
+// src/react/keyboard/zone.ts
+var ZONE_ATTRIBUTE = "data-keyboard-zone";
+function nextZoneIndex({
+  length,
+  index,
+  move,
+  loop
+}) {
+  if (length <= 0)
+    return move === "previous" || move === "first" ? "before-start" : "after-end";
+  if (move === "first")
+    return 0;
+  if (move === "last")
+    return length - 1;
+  if (index < 0 || index >= length)
+    return move === "next" ? 0 : length - 1;
+  const target = move === "next" ? index + 1 : index - 1;
+  if (target >= 0 && target < length)
+    return target;
+  if (loop)
+    return target < 0 ? length - 1 : 0;
+  return target < 0 ? "before-start" : "after-end";
+}
+function zoneIntent(event, orientation) {
+  if (event.altKey || event.ctrlKey || event.metaKey || event.shiftKey)
+    return null;
+  const vertical = orientation === "vertical";
+  switch (event.key) {
+    case (vertical ? "ArrowDown" : "ArrowRight"):
+      return { type: "move", move: "next" };
+    case (vertical ? "ArrowUp" : "ArrowLeft"):
+      return { type: "move", move: "previous" };
+    case (vertical ? "ArrowRight" : "ArrowDown"):
+      return { type: "enter" };
+    case (vertical ? "ArrowLeft" : "ArrowUp"):
+      return { type: "exit" };
+    case "Home":
+      return { type: "move", move: "first" };
+    case "End":
+      return { type: "move", move: "last" };
+    case "Enter":
+      return { type: "confirm" };
+    default:
+      return null;
+  }
+}
+function createNavZone(initial) {
+  let options = initial;
+  let pointed = null;
+  let awaiting = null;
+  const elements = new Map;
+  const listeners = new Set;
+  const point = (id) => {
+    if (pointed === id)
+      return;
+    pointed = id;
+    for (const listener of listeners)
+      listener();
+  };
+  function current() {
+    const { items, value } = options;
+    if (pointed !== null && items.includes(pointed))
+      return pointed;
+    if (value !== null && items.includes(value))
+      return value;
+    return items[0] ?? null;
+  }
+  function focusElement(element) {
+    element.focus({ preventScroll: true });
+    element.scrollIntoView?.({ block: "nearest", inline: "nearest" });
+  }
+  function focus(id) {
+    const target = id ?? current();
+    if (target === null)
+      return false;
+    point(target);
+    const element = elements.get(target);
+    if (element === undefined) {
+      awaiting = target;
+      options.onReveal?.(target);
+      return true;
+    }
+    awaiting = null;
+    focusElement(element);
+    return true;
+  }
+  const taken = (answer) => answer !== false;
+  function apply(intent) {
+    const { items, mode = "select", loop = false } = options;
+    const id = current();
+    switch (intent.type) {
+      case "move": {
+        const index = id === null ? -1 : items.indexOf(id);
+        const landed = nextZoneIndex({ length: items.length, index, move: intent.move, loop });
+        if (typeof landed !== "number") {
+          if (options.onBoundary === undefined)
+            return false;
+          return taken(options.onBoundary(landed === "before-start" ? "start" : "end"));
+        }
+        const next = items[landed];
+        if (next === undefined)
+          return false;
+        focus(next);
+        if (mode === "select" && next !== options.value)
+          options.onChange(next, "arrow");
+        return true;
+      }
+      case "enter":
+        return id !== null && options.onEnter !== undefined && taken(options.onEnter(id));
+      case "exit":
+        return options.onExit !== undefined && taken(options.onExit());
+      case "confirm":
+        if (id === null)
+          return false;
+        if (mode === "highlight") {
+          options.onChange(id, "confirm");
+          return true;
+        }
+        return options.onEnter !== undefined && taken(options.onEnter(id));
+    }
+  }
+  return {
+    update(next) {
+      if (next.value !== options.value)
+        pointed = null;
+      options = next;
+    },
+    get options() {
+      return options;
+    },
+    current,
+    keyDown(event, zone) {
+      if (event.defaultPrevented || event.isComposing || isKeyFieldTarget(event.target)) {
+        return false;
+      }
+      if (closestFromTarget(event.target, `[${ZONE_ATTRIBUTE}]`) !== zone)
+        return false;
+      const intent = zoneIntent(event, options.orientation ?? "vertical");
+      if (intent === null || !apply(intent))
+        return false;
+      event.preventDefault();
+      return true;
+    },
+    keyFromOutside(event) {
+      if (closestFromTarget(event.target, `[${ZONE_ATTRIBUTE}]`) !== null)
+        return false;
+      const intent = zoneIntent(event, options.orientation ?? "vertical");
+      if (intent?.type !== "move" || intent.move !== "next" && intent.move !== "previous") {
+        return false;
+      }
+      return focus();
+    },
+    focused(id) {
+      if (!options.items.includes(id))
+        return;
+      awaiting = null;
+      point(id);
+    },
+    focus,
+    setItemElement(id, element) {
+      if (element === null) {
+        elements.delete(id);
+        return;
+      }
+      elements.set(id, element);
+      if (id === awaiting) {
+        awaiting = null;
+        focusElement(element);
+      }
+    },
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    }
+  };
+}
+
+// src/react/keyboard/hooks.ts
+var stacks = new WeakMap;
+function stackOf(view) {
+  const existing = stacks.get(view);
+  if (existing !== undefined)
+    return existing;
+  const created = createKeyLayerStack(view);
+  stacks.set(view, created);
+  return created;
+}
+function layerState(options) {
+  const { scope } = options;
+  return {
+    kind: options.kind,
+    active: options.active,
+    fields: options.fields,
+    scope: scope === undefined ? undefined : () => scope.current,
+    onKey: (event) => options.onKey(event)
+  };
+}
+function useKeyLayer(options) {
+  const handle = useRef(null);
+  const initial = useRef(options);
+  useEffect(() => {
+    const added = stackOf(window).add(layerState(initial.current));
+    handle.current = added;
+    return () => {
+      added.remove();
+      handle.current = null;
+    };
+  }, []);
+  useEffect(() => {
+    handle.current?.update(layerState(options));
+  });
+}
+function useEscapeLayer(options) {
+  useKeyLayer({
+    kind: options.kind,
+    active: options.active,
+    scope: options.scope,
+    onKey: (event) => event.key === "Escape" && options.onEscape() !== false
+  });
+}
+function useNavZone(options) {
+  const [zone] = useState(() => createNavZone(options));
+  zone.update(options);
+  const current = useSyncExternalStore(zone.subscribe, zone.current, zone.current);
+  const element = useRef(null);
+  const [zoneRef] = useState(() => (node) => {
+    element.current = node;
+  });
+  const itemRefs = useRef(new Map);
+  useKeyLayer({
+    kind: "zone",
+    active: options.active,
+    scope: element,
+    onKey: (event) => zone.keyFromOutside(event)
+  });
+  const role = options.role ?? "listbox";
+  const itemRef = (id) => {
+    const cached = itemRefs.current.get(id);
+    if (cached !== undefined)
+      return cached;
+    const created = (node) => {
+      zone.setItemElement(id, node);
+    };
+    itemRefs.current.set(id, created);
+    return created;
+  };
+  return {
+    zoneProps: {
+      ref: zoneRef,
+      role: role === "none" ? undefined : role,
+      "aria-orientation": options.orientation ?? "vertical",
+      "aria-label": options.label,
+      [ZONE_ATTRIBUTE]: "",
+      onKeyDown: (event) => {
+        zone.keyDown(event.nativeEvent, element.current);
+      }
+    },
+    itemProps: (id) => {
+      const chosen = id === options.value;
+      return {
+        ref: itemRef(id),
+        tabIndex: id === current ? 0 : -1,
+        role: role === "listbox" ? "option" : role === "tablist" ? "tab" : undefined,
+        "aria-selected": role === "none" ? undefined : chosen,
+        "aria-current": role === "none" && chosen ? "true" : undefined,
+        onFocus: () => zone.focused(id)
+      };
+    },
+    element,
+    current,
+    focus: (id) => zone.focus(id)
+  };
+}
+export {
+  isKeyFieldTarget,
+  nextZoneIndex,
+  useEscapeLayer,
+  useKeyLayer,
+  useNavZone
+};

package/dist/entrypoints/react.js

@@ -1,11 +1,11 @@
+import"../index-hby4qhax.js";
 import {
-  ApiError,
+  ApiError2,
   isAbortLikeError
-} from "../index-v260df89.js";
-import"../index-zcgf3gqf.js";
+} from "../index-qjeggp8w.js";
 import {
   isRecord
-} from "../index-hffjpmq9.js";
+} from "../index-9jfdm5tg.js";
 
 // src/react/cache-bridge.ts
 function createCacheBridge(config) {
@@ -391,7 +391,7 @@ function apiErrorRetry(config = {}) {
       return false;
     if (isAbortLikeError(error))
       return false;
-    if (!ApiError.is(error))
+    if (!ApiError2.is(error))
       return config.network ?? true;
     if (never.has(error.code))
       return false;
@@ -437,10 +437,10 @@ function createQueryClientFactory(config = {}) {
   };
 }
 export {
-  createRealtimeCacheBridge,
-  createQueryClientFactory,
-  createEntityCacheHandlers,
-  createCursorQuery,
+  apiErrorRetry,
   createCacheBridge,
-  apiErrorRetry
+  createCursorQuery,
+  createEntityCacheHandlers,
+  createQueryClientFactory,
+  createRealtimeCacheBridge
 };

package/dist/entrypoints/release.js

@@ -1,6 +1,6 @@
 import {
-  RELEASE_HEADER
-} from "../index-y91ry9h2.js";
+  RELEASE_HEADER2
+} from "../index-n15jny5b.js";
 // src/release/marker.ts
 var BUILD_ID = /^[!-~]{1,200}$/;
 function createReleaseMarker(config) {
@@ -187,10 +187,10 @@ function createReleaseWatcher(config) {
   };
 }
 export {
-  observeReleaseFromSocket,
-  createReleaseWatcher,
-  createReleaseMarker,
-  browserReleaseHost,
+  RELEASE_HEADER2 as RELEASE_HEADER,
   bindReleaseToSocketServer,
-  RELEASE_HEADER
+  browserReleaseHost,
+  createReleaseMarker,
+  createReleaseWatcher,
+  observeReleaseFromSocket
 };

package/dist/entrypoints/remote.js

@@ -1,23 +1,21 @@
+import"../index-hby4qhax.js";
 import {
-  createClient
-} from "../index-ham5sz8m.js";
-import"../index-48ffdxgk.js";
-import"../index-wqgjfstn.js";
+  ApiError2
+} from "../index-qjeggp8w.js";
+import"../index-m38ej7e5.js";
+import"../index-r5c4fedv.js";
 import {
-  ApiError
-} from "../index-v260df89.js";
+  createClient2
+} from "../index-aaj97r4y.js";
 import {
-  contractMethodFields
-} from "../index-2bxbyab0.js";
-import"../index-4gcnakhx.js";
-import"../index-zcgf3gqf.js";
+  AppError2
+} from "../index-n53mswt3.js";
 import {
-  AppError
-} from "../index-2vtcmrj9.js";
-import"../index-kzfs85xp.js";
+  contractMethodFields
+} from "../index-1bx1xv1k.js";
 import {
   isRecord
-} from "../index-hffjpmq9.js";
+} from "../index-9jfdm5tg.js";
 
 // src/tools/remote.ts
 function toArgs(ctx) {
@@ -28,7 +26,7 @@ function toArgs(ctx) {
   };
 }
 function implementRemote(contract, http, options) {
-  const client = createClient(contract, http);
+  const client = createClient2(contract, http);
   const groupScope = contract.meta.scope ?? "public";
   const methods = {};
   for (const [key, endpoint] of Object.entries(contract.endpoints)) {
@@ -46,8 +44,8 @@ function implementRemote(contract, http, options) {
           const finalArgs = options?.transformArgs ? await options.transformArgs(key, args) : args;
           return await call(finalArgs);
         } catch (err) {
-          if (ApiError.is(err)) {
-            throw new AppError(err.code, err.message, err.status, isRecord(err.details) ? err.details : undefined, err.hint, err.traceId);
+          if (ApiError2.is(err)) {
+            throw new AppError2(err.code, err.message, err.status, isRecord(err.details) ? err.details : undefined, err.hint, err.traceId);
           }
           throw err;
         }