@forgeax/app-shell 0.42.0 → 0.44.0

package/dist/react.d.ts

@@ -51,6 +51,25 @@ interface PointerDragSessionOptions<Session> {
     readonly stopPropagation?: boolean;
     readonly draggingClassName?: string;
 }
+type ThresholdPointerDragFinishReason = 'pointerup' | 'pointercancel' | 'cancel' | 'dispose' | 'error';
+interface ThresholdPointerDragSessionOptions<Session> {
+    readonly target: Window;
+    readonly pointerId: number;
+    readonly startX: number;
+    readonly startY: number;
+    readonly threshold: number;
+    readonly begin: (event: globalThis.PointerEvent) => Session | null;
+    readonly move: (session: Session, event: globalThis.PointerEvent) => void;
+    readonly end?: (session: Session, reason: ThresholdPointerDragFinishReason) => void;
+    readonly onSettled?: (reason: ThresholdPointerDragFinishReason, started: boolean) => void;
+    readonly registerCancel?: (cancel: () => void) => void | (() => void);
+}
+interface ThresholdPointerDragSession {
+    cancel(): void;
+    dispose(): void;
+}
+/** Own one post-pointerdown threshold arm and its global listener lifecycle. */
+declare function installThresholdPointerDragSession<Session>(options: ThresholdPointerDragSessionOptions<Session>): ThresholdPointerDragSession;
 /** Own one imperative pointer-capture drag session and its balanced teardown. */
 declare function installPointerDragSession<Session>(options: PointerDragSessionOptions<Session>): () => void;
 type AnchoredResizeDirection = 'subtract' | 'add';
@@ -73,6 +92,23 @@ interface AnchoredResizeHandleProps extends Omit<ResizeHandleProps, 'onDrag' | '
 /** Product-neutral anchored resize session over the public pointer carrier. */
 declare function AnchoredResizeHandle({ readSize, writeSize, direction, resizingBodyClassName, ...handleProps }: AnchoredResizeHandleProps): react.JSX.Element;
 
+type PointerReorderFinishReason = 'pointerup' | 'pointercancel' | 'buttons-released' | 'replacement' | 'cancel' | 'dispose' | 'error';
+interface PointerReorderSessionOptions<Item> {
+    readonly element: HTMLElement;
+    readonly target: Window;
+    readonly resolveItem: (target: EventTarget | null) => Item | null;
+    readonly canStart?: (event: globalThis.PointerEvent, item: Item) => boolean;
+    readonly reorder: (dragged: Item, over: Item, event: globalThis.PointerEvent) => void;
+    readonly onDraggingChange?: (item: Item | null, reason?: PointerReorderFinishReason) => void;
+    readonly equals?: (left: Item, right: Item) => boolean;
+}
+interface PointerReorderSession {
+    cancel(): void;
+    dispose(): void;
+}
+/** Own one delegated pointer reorder lifecycle without owning item identity or mutation policy. */
+declare function installPointerReorderSession<Item>(options: PointerReorderSessionOptions<Item>): PointerReorderSession;
+
 type PanelContentPadding = 'none' | 'sm' | 'md';
 type PanelContentScroll = 'none' | 'auto';
 type PanelContentTone = 'default' | 'surface' | 'tool';
@@ -214,4 +250,4 @@ interface ShellSlotProps extends HTMLAttributes<HTMLElement> {
 /** Structural shell marker that preserves the caller's semantic element. */
 declare function ShellSlot({ as, name, ...props }: ShellSlotProps): ReactElement;
 
-export { type AnchoredResizeDirection, AnchoredResizeHandle, type AnchoredResizeHandleProps, type AnchoredResizeSession, DetachedPanelBoundary, type DetachedPanelBoundaryProps, DetachedSurfaceFrame, type DetachedSurfaceFrameProps, DetachedSurfaceStatus, type DetachedSurfaceStatusProps, type DetachedSurfaceStatusTone, type DockLayoutControlBinding, type DockLayoutControlBindingOptions, DockLayoutMenu, type DockLayoutMenuPanel, type DockLayoutMenuProps, FloatingMenu, type FloatingMenuAnchor, type FloatingMenuPoint, type FloatingMenuProps, type PanelContentPadding, type PanelContentPolicy, type PanelContentScroll, type PanelContentTone, PanelEmptyState, type PanelEmptyStateProps, PanelSurface, type PanelSurfaceProps, type PersistentSizeStorage, type PersistentSizeStore, type PersistentSizeStoreOptions, type PersistentSizeUpdate, type PointerDragFinishReason, type PointerDragSessionOptions, ResizeHandle, type ResizeHandleProps, ShellSlot, type ShellSlotElement, type ShellSlotProps, SlotDebugOverlay, SurfacePlaceholder, type SurfacePlaceholderProps, SurfaceRegion, type SurfaceRegionProps, applyAnchoredResizeDelta, beginAnchoredResize, createPersistentSizeStore, hashSlotHue, installPointerDragSession, isSlotDebugEnabled, useDockLayoutControlBinding, useLocalSize, usePersistentSizeStore };
+export { type AnchoredResizeDirection, AnchoredResizeHandle, type AnchoredResizeHandleProps, type AnchoredResizeSession, DetachedPanelBoundary, type DetachedPanelBoundaryProps, DetachedSurfaceFrame, type DetachedSurfaceFrameProps, DetachedSurfaceStatus, type DetachedSurfaceStatusProps, type DetachedSurfaceStatusTone, type DockLayoutControlBinding, type DockLayoutControlBindingOptions, DockLayoutMenu, type DockLayoutMenuPanel, type DockLayoutMenuProps, FloatingMenu, type FloatingMenuAnchor, type FloatingMenuPoint, type FloatingMenuProps, type PanelContentPadding, type PanelContentPolicy, type PanelContentScroll, type PanelContentTone, PanelEmptyState, type PanelEmptyStateProps, PanelSurface, type PanelSurfaceProps, type PersistentSizeStorage, type PersistentSizeStore, type PersistentSizeStoreOptions, type PersistentSizeUpdate, type PointerDragFinishReason, type PointerDragSessionOptions, type PointerReorderFinishReason, type PointerReorderSession, type PointerReorderSessionOptions, ResizeHandle, type ResizeHandleProps, ShellSlot, type ShellSlotElement, type ShellSlotProps, SlotDebugOverlay, SurfacePlaceholder, type SurfacePlaceholderProps, SurfaceRegion, type SurfaceRegionProps, type ThresholdPointerDragFinishReason, type ThresholdPointerDragSession, type ThresholdPointerDragSessionOptions, applyAnchoredResizeDelta, beginAnchoredResize, createPersistentSizeStore, hashSlotHue, installPointerDragSession, installPointerReorderSession, installThresholdPointerDragSession, isSlotDebugEnabled, useDockLayoutControlBinding, useLocalSize, usePersistentSizeStore };

package/dist/react.js

@@ -723,6 +723,117 @@ function acquireElementClassLease(element, tokens) {
     if (records?.size === 0) elementClassLeases.delete(element);
   };
 }
+function installThresholdPointerDragSession(options) {
+  const threshold = Number.isFinite(options.threshold) ? Math.max(0, options.threshold) : 0;
+  let disposed = false;
+  let settled = false;
+  let settledReason = null;
+  let starting = false;
+  let active = null;
+  let unregisterCancel = null;
+  const removeListeners = () => {
+    options.target.removeEventListener("pointermove", onPointerMove, true);
+    options.target.removeEventListener("pointerup", onPointerFinish, true);
+    options.target.removeEventListener("pointercancel", onPointerFinish, true);
+  };
+  const releaseCancelRegistration = () => {
+    const unregister = unregisterCancel;
+    unregisterCancel = null;
+    try {
+      unregister?.();
+    } catch {
+    }
+  };
+  const settle = (reason) => {
+    if (settled) return;
+    settled = true;
+    settledReason = reason;
+    removeListeners();
+    releaseCancelRegistration();
+    const current = active;
+    active = null;
+    if (current !== null) {
+      try {
+        options.end?.(current, reason);
+      } catch {
+      }
+    }
+    try {
+      options.onSettled?.(reason, current !== null);
+    } catch {
+    }
+  };
+  function onPointerMove(event) {
+    if (settled || event.pointerId !== options.pointerId) return;
+    if (active === null) {
+      if (starting) return;
+      if (Math.hypot(event.clientX - options.startX, event.clientY - options.startY) < threshold) return;
+      starting = true;
+      let candidate;
+      try {
+        candidate = options.begin(event);
+      } catch {
+        starting = false;
+        settle("error");
+        return;
+      }
+      starting = false;
+      if (candidate === null) {
+        settle("cancel");
+        return;
+      }
+      if (settled) {
+        try {
+          options.end?.(candidate, settledReason ?? "dispose");
+        } catch {
+        }
+        return;
+      }
+      active = candidate;
+    }
+    const current = active;
+    if (current === null) return;
+    try {
+      options.move(current, event);
+    } catch {
+      settle("error");
+    }
+  }
+  function onPointerFinish(event) {
+    if (settled || event.pointerId !== options.pointerId) return;
+    settle(event.type === "pointercancel" ? "pointercancel" : "pointerup");
+  }
+  options.target.addEventListener("pointermove", onPointerMove, true);
+  options.target.addEventListener("pointerup", onPointerFinish, true);
+  options.target.addEventListener("pointercancel", onPointerFinish, true);
+  if (options.registerCancel) {
+    let registered;
+    try {
+      registered = options.registerCancel(() => settle("cancel"));
+    } catch {
+      settle("error");
+      registered = void 0;
+    }
+    if (registered) {
+      if (settled) {
+        try {
+          registered();
+        } catch {
+        }
+      } else {
+        unregisterCancel = registered;
+      }
+    }
+  }
+  return {
+    cancel: () => settle("cancel"),
+    dispose: () => {
+      if (disposed) return;
+      disposed = true;
+      settle("dispose");
+    }
+  };
+}
 function installPointerDragSession(options) {
   const { element } = options;
   let disposed = false;
@@ -956,6 +1067,114 @@ function AnchoredResizeHandle({
   );
 }
 
+// src/pointer-reorder.ts
+function installPointerReorderSession(options) {
+  const equals = options.equals ?? Object.is;
+  let disposed = false;
+  let generation = 0;
+  let active = null;
+  const publishDragging = (item, reason) => {
+    try {
+      options.onDraggingChange?.(item, reason);
+    } catch {
+    }
+  };
+  const settle = (reason) => {
+    const current = active;
+    if (current === null) return;
+    active = null;
+    if (current.dragging) publishDragging(null, reason);
+  };
+  const onPointerDown = (event) => {
+    if (disposed || event.button !== 0 || event.isPrimary === false) return;
+    let item;
+    try {
+      item = options.resolveItem(event.target);
+      if (item === null || options.canStart?.(event, item) === false) return;
+    } catch {
+      return;
+    }
+    const nextGeneration = ++generation;
+    settle("replacement");
+    if (disposed || generation !== nextGeneration) return;
+    active = {
+      generation: nextGeneration,
+      pointerId: event.pointerId,
+      item,
+      dragging: false,
+      lastOver: null
+    };
+  };
+  const onPointerMove = (event) => {
+    const current = active;
+    if (disposed || current === null || event.pointerId !== current.pointerId) return;
+    if ((event.buttons & 1) !== 1) {
+      settle("buttons-released");
+      return;
+    }
+    let over;
+    try {
+      over = options.resolveItem(event.target);
+    } catch {
+      settle("error");
+      return;
+    }
+    if (active !== current || current.generation !== generation) return;
+    if (over === null) return;
+    let sameItem;
+    try {
+      sameItem = equals(over, current.item);
+    } catch {
+      if (active === current) settle("error");
+      return;
+    }
+    if (active !== current || current.generation !== generation || sameItem) return;
+    if (current.lastOver !== null) {
+      let sameTarget;
+      try {
+        sameTarget = equals(over, current.lastOver);
+      } catch {
+        if (active === current) settle("error");
+        return;
+      }
+      if (active !== current || current.generation !== generation || sameTarget) return;
+    }
+    current.lastOver = over;
+    if (!current.dragging) {
+      current.dragging = true;
+      publishDragging(current.item);
+      if (active !== current || current.generation !== generation) return;
+    }
+    try {
+      options.reorder(current.item, over, event);
+    } catch {
+      settle("error");
+    }
+  };
+  const onPointerFinish = (event) => {
+    const current = active;
+    if (disposed || current === null || event.pointerId !== current.pointerId) return;
+    settle(event.type === "pointercancel" ? "pointercancel" : "pointerup");
+  };
+  options.element.addEventListener("pointerdown", onPointerDown);
+  options.element.addEventListener("pointermove", onPointerMove);
+  options.target.addEventListener("pointerup", onPointerFinish, true);
+  options.target.addEventListener("pointercancel", onPointerFinish, true);
+  return {
+    cancel: () => settle("cancel"),
+    dispose: () => {
+      if (disposed) return;
+      disposed = true;
+      generation += 1;
+      options.element.removeEventListener("pointerdown", onPointerDown);
+      options.element.removeEventListener("pointermove", onPointerMove);
+      options.target.removeEventListener("pointerup", onPointerFinish, true);
+      options.target.removeEventListener("pointercancel", onPointerFinish, true);
+      settle("dispose");
+    }
+  };
+}
+
 // src/panel.tsx
 import { jsx as jsx3, jsxs } from "react/jsx-runtime";
 function PanelEmptyState({
@@ -1324,6 +1543,8 @@ export {
   createPersistentSizeStore,
   hashSlotHue,
   installPointerDragSession,
+  installPointerReorderSession,
+  installThresholdPointerDragSession,
   isSlotDebugEnabled,
   useDockLayoutControlBinding,
   useLocalSize,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@forgeax/app-shell",
-  "version": "0.42.0",
+  "version": "0.44.0",
   "description": "Generic Dock, Panel, Window, and Slot composition primitives",
   "license": "Apache-2.0",
   "type": "module",