@forgeax/app-shell 0.1.1 → 0.3.0

package/dist/dock.d.ts

@@ -0,0 +1,65 @@
+declare const REGIONS: readonly ["DockShell", "AuxBar", "ChatDock", "StatusBar"];
+type Region = typeof REGIONS[number];
+declare const DOCK_REGIONS: readonly ["DockShell", "AuxBar", "ChatDock"];
+type DockRegion = typeof DOCK_REGIONS[number];
+declare function isDockRegion(value: string): value is DockRegion;
+interface PanelDescriptorLite {
+    defaultRegion?: DockRegion;
+}
+declare function resolveRegion(id: string, descriptor: PanelDescriptorLite, overrides: Readonly<Record<string, DockRegion>>): DockRegion;
+interface DockviewApiLike {
+    readonly id: string;
+    getPanel(id: string): {
+        readonly api: {
+            close(): void;
+        };
+    } | undefined;
+}
+declare function registerDockviewApi(api: DockviewApiLike): () => void;
+declare function getDockviewApi(viewId: string): DockviewApiLike | undefined;
+interface DockRegionEntry {
+    readonly viewId: string;
+    readonly region: string;
+    readonly api: unknown;
+    readonly wrapEl: HTMLElement;
+}
+declare function registerDockRegion(entry: DockRegionEntry): () => void;
+declare function getDockRegions(): DockRegionEntry[];
+type SideEdge = 'left' | 'right';
+interface RectLike {
+    left: number;
+    right: number;
+}
+declare function isOnSideEdge(location: {
+    type: string;
+    position?: string;
+}): boolean;
+declare function nearerSideEdge(panel: RectLike, shell: RectLike): SideEdge;
+type DropPosition = 'top' | 'bottom' | 'left' | 'right' | 'center';
+type Direction = 'left' | 'right' | 'above' | 'below' | 'within';
+interface AddPanelPosition {
+    referenceGroup?: unknown;
+    direction?: Direction;
+}
+interface CrossInstanceDropEvent {
+    readonly api: DockviewApiLike & {
+        addPanel(options: {
+            id: string;
+            component: string;
+            title?: string;
+            position?: AddPanelPosition;
+        }): unknown;
+    };
+    readonly position?: DropPosition;
+    readonly group?: unknown;
+    getData(): {
+        readonly viewId: string;
+        readonly panelId: string | null;
+    } | undefined;
+}
+declare function handleCrossInstanceDrop(event: CrossInstanceDropEvent, targetRegion: DockRegion, moveTo: (panelId: string, region: DockRegion) => void, options?: {
+    componentFor?: (panelId: string) => string;
+    titleFor?: (panelId: string) => string | undefined;
+}): void;
+
+export { type CrossInstanceDropEvent, DOCK_REGIONS, type DockRegion, type DockRegionEntry, type DockviewApiLike, type PanelDescriptorLite, REGIONS, type RectLike, type Region, type SideEdge, getDockRegions, getDockviewApi, handleCrossInstanceDrop, isDockRegion, isOnSideEdge, nearerSideEdge, registerDockRegion, registerDockviewApi, resolveRegion };

package/dist/dock.js

@@ -0,0 +1,93 @@
+// src/dock.ts
+var REGIONS = ["DockShell", "AuxBar", "ChatDock", "StatusBar"];
+var DOCK_REGIONS = ["DockShell", "AuxBar", "ChatDock"];
+function isDockRegion(value) {
+  return DOCK_REGIONS.includes(value);
+}
+function resolveRegion(id, descriptor, overrides) {
+  return overrides[id] ?? descriptor.defaultRegion ?? "DockShell";
+}
+var dockviewApis = /* @__PURE__ */ new Map();
+function registerDockviewApi(api) {
+  dockviewApis.set(api.id, api);
+  return () => {
+    if (dockviewApis.get(api.id) === api) dockviewApis.delete(api.id);
+  };
+}
+function getDockviewApi(viewId) {
+  return dockviewApis.get(viewId);
+}
+var dockRegions = /* @__PURE__ */ new Map();
+function registerDockRegion(entry) {
+  dockRegions.set(entry.viewId, entry);
+  return () => {
+    if (dockRegions.get(entry.viewId) === entry) dockRegions.delete(entry.viewId);
+  };
+}
+function getDockRegions() {
+  return [...dockRegions.values()];
+}
+function isOnSideEdge(location) {
+  return location.type === "edge" && (location.position === "left" || location.position === "right");
+}
+function nearerSideEdge(panel, shell) {
+  const middle = (panel.left + panel.right) / 2;
+  return middle - shell.left <= shell.right - middle ? "left" : "right";
+}
+function toDirection(position) {
+  switch (position) {
+    case "top":
+      return "above";
+    case "bottom":
+      return "below";
+    case "left":
+      return "left";
+    case "right":
+      return "right";
+    case "center":
+      return "within";
+    default:
+      return void 0;
+  }
+}
+function handleCrossInstanceDrop(event, targetRegion, moveTo, options) {
+  const transfer = event.getData();
+  if (!transfer?.panelId || transfer.viewId === event.api.id) return;
+  const sourceApi = getDockviewApi(transfer.viewId);
+  if (sourceApi) {
+    try {
+      sourceApi.getPanel(transfer.panelId)?.api.close();
+    } catch {
+    }
+  }
+  const direction = toDirection(event.position);
+  let position;
+  if (event.group && direction) {
+    position = { referenceGroup: event.group, direction };
+  } else if (direction && direction !== "within") {
+    position = { direction };
+  }
+  try {
+    event.api.addPanel({
+      id: transfer.panelId,
+      component: options?.componentFor?.(transfer.panelId) ?? transfer.panelId,
+      title: options?.titleFor?.(transfer.panelId),
+      ...position ? { position } : {}
+    });
+  } catch {
+  }
+  moveTo(transfer.panelId, targetRegion);
+}
+export {
+  DOCK_REGIONS,
+  REGIONS,
+  getDockRegions,
+  getDockviewApi,
+  handleCrossInstanceDrop,
+  isDockRegion,
+  isOnSideEdge,
+  nearerSideEdge,
+  registerDockRegion,
+  registerDockviewApi,
+  resolveRegion
+};

package/dist/index.d.ts

@@ -15,5 +15,14 @@ declare class AppShellRegistry {
 declare function createShellContribution(input: Omit<ShellContribution, 'contribution'> & {
     contribution: ContributionDeclaration;
 }): ShellContribution;
+type ShellSnapshotPatch<T extends Record<string, unknown>> = {
+    readonly [K in keyof T]?: T[K] extends readonly unknown[] ? T[K] : T[K] extends Record<string, unknown> ? Partial<T[K]> : T[K];
+};
+/**
+ * Folds ordered shell contributions into an immutable derived snapshot.
+ * Object-valued fields merge one level; arrays and scalar values replace the
+ * previous value. Undefined fields do not contribute.
+ */
+declare function deriveShellSnapshot<T extends Record<string, unknown>>(base: T, patches: ReadonlyArray<ShellSnapshotPatch<T>>): T;
 
-export { AppShellRegistry, type ShellContribution, type ShellSlot, createShellContribution };
+export { AppShellRegistry, type ShellContribution, type ShellSlot, type ShellSnapshotPatch, createShellContribution, deriveShellSnapshot };

package/dist/index.js

@@ -15,7 +15,25 @@ var AppShellRegistry = class {
 function createShellContribution(input) {
   return { ...input };
 }
+function deriveShellSnapshot(base, patches) {
+  const output = { ...base };
+  for (const patch of patches) {
+    for (const [key, value] of Object.entries(patch)) {
+      if (value === void 0) continue;
+      if (typeof value === "object" && value !== null && !Array.isArray(value)) {
+        output[key] = {
+          ...output[key],
+          ...value
+        };
+      } else {
+        output[key] = value;
+      }
+    }
+  }
+  return output;
+}
 export {
   AppShellRegistry,
-  createShellContribution
+  createShellContribution,
+  deriveShellSnapshot
 };

package/dist/react.d.ts

@@ -0,0 +1,11 @@
+import { HTMLAttributes, ReactElement } from 'react';
+
+type ShellSlotElement = 'aside' | 'div' | 'main' | 'section';
+interface ShellSlotProps extends HTMLAttributes<HTMLElement> {
+    as?: ShellSlotElement;
+    name: string;
+}
+/** Structural shell marker that preserves the caller's semantic element. */
+declare function ShellSlot({ as, name, ...props }: ShellSlotProps): ReactElement;
+
+export { ShellSlot, type ShellSlotElement, type ShellSlotProps };

package/dist/react.js

@@ -0,0 +1,12 @@
+// src/react.tsx
+import { createElement } from "react";
+function ShellSlot({
+  as = "div",
+  name,
+  ...props
+}) {
+  return createElement(as, { ...props, "data-fx-slot": name });
+}
+export {
+  ShellSlot
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@forgeax/app-shell",
-  "version": "0.1.1",
+  "version": "0.3.0",
   "description": "Generic Dock, Panel, Window, and Slot composition primitives",
   "license": "Apache-2.0",
   "type": "module",
@@ -12,20 +12,35 @@
     ".": {
       "types": "./dist/index.d.ts",
       "import": "./dist/index.js"
+    },
+    "./dock": {
+      "types": "./dist/dock.d.ts",
+      "import": "./dist/dock.js"
+    },
+    "./react": {
+      "types": "./dist/react.d.ts",
+      "import": "./dist/react.js"
     }
   },
   "scripts": {
     "typecheck": "tsc --noEmit",
-    "test": "bun test test/*.test.ts",
-    "build": "tsup src/index.ts --format esm --dts --outDir dist",
+    "test": "bun test test",
+    "build": "tsup src/index.ts src/dock.ts src/react.tsx --format esm --dts --outDir dist",
     "check": "bun run typecheck && bun run test && bun run build",
     "release:preflight": "bun run scripts/release-preflight.ts"
   },
   "dependencies": {
     "@forgeax/extension-contracts": "^0.1.0"
   },
+  "peerDependencies": {
+    "react": "^19.0.0"
+  },
   "devDependencies": {
+    "@types/react": "^19.0.0",
+    "@types/react-dom": "^19.0.0",
     "bun-types": "^1.3.14",
+    "react": "^19.0.0",
+    "react-dom": "^19.0.0",
     "tsup": "^8.5.0",
     "typescript": "^5.9.2"
   },