nexus-shell 0.2.8 → 0.2.10

package/dist/components/widgets/TerminalPane.d.ts

@@ -12,8 +12,22 @@ export interface TerminalPaneProps {
     onCommand?: (command: string) => void;
     /** Called when the collapse or close button is pressed. */
     onClose?: () => void;
-    /** Height of the pane, as a CSS length. Defaults to `"250px"`. */
+    /**
+     * Height of the pane, as a CSS length.
+     *
+     * Leave it unset inside a host that sizes its own children — a side pane or a
+     * dockable tab — and the terminal fills the space instead. Defaults to
+     * `"250px"` only when standalone.
+     */
     height?: string;
+    /**
+     * Draw the title bar.
+     *
+     * Left unset, this follows the host: inside a `SidebarPane` or a dockable tab
+     * the title is already drawn, so the pane omits its own. Set it explicitly to
+     * force either way.
+     */
+    chrome?: boolean;
     /** Prompt string shown before the input. Defaults to `"$"`. */
     prompt?: string;
     /** Title shown in the pane header. Defaults to `"Terminal"`. */
@@ -22,14 +36,17 @@ export interface TerminalPaneProps {
     className?: string;
 }
 /**
- * A bottom-docked terminal pane: a scrolling output log over a single-line
- * input.
+ * A terminal pane: a scrolling output log over a single-line input.
  *
  * Presentational and fully controlled — it owns only the in-progress input
  * text. Visibility, history and command execution all belong to the caller.
  * For the store-backed variant with built-in `clear`/`help` handling, see
  * `ConnectedTerminalPane`.
  *
+ * **It fills whatever hosts it.** Bottom of the workspace, a side pane, or a
+ * dockable tab — register it wherever it belongs. Inside a host that draws a
+ * title bar it omits its own header and its own fixed height.
+ *
  * @example
  * ```tsx
  * const [history, setHistory] = useState<string[]>([]);
@@ -40,4 +57,4 @@ export interface TerminalPaneProps {
  * />
  * ```
  */
-export declare const TerminalPane: ({ history, onCommand, onClose, height, prompt, title, className, }: TerminalPaneProps) => import("react/jsx-runtime").JSX.Element;
+export declare const TerminalPane: ({ history, onCommand, onClose, height, prompt, title, chrome, className, }: TerminalPaneProps) => import("react/jsx-runtime").JSX.Element;

package/dist/connected/ConnectedActivityBar.d.ts

@@ -2,9 +2,20 @@ import { ActivityBarProps } from '../components/widgets/ActivityBar';
 
 export type ConnectedActivityBarProps = Omit<ActivityBarProps, 'items' | 'activeId' | 'onSelect'>;
 /**
- * {@link ActivityBar} bound to `useSidebarStore`.
+ * {@link ActivityBar} bound to `useSidebarStore`, docked left.
  *
  * Derives its items from the registered sidebar panels and toggles the active
  * panel on click — clicking the already-active item closes the sidebar.
  */
 export declare const ConnectedActivityBar: (props: ConnectedActivityBarProps) => import("react/jsx-runtime").JSX.Element;
+/**
+ * {@link ActivityBar} bound to `useInspectorStore`, docked right.
+ *
+ * Rendered only when inspector panels are registered — an empty rail is a
+ * twelve-pixel strip of nothing, and a shell that grows one the moment you
+ * register a panel is easier to reason about than one you must switch on.
+ *
+ * It also defaults to no bottom group: settings live on the left rail, and two
+ * settings buttons would be a puzzle.
+ */
+export declare const ConnectedInspectorBar: (props: ConnectedActivityBarProps) => import("react/jsx-runtime").JSX.Element | null;

package/dist/connected/ConnectedChatPane.d.ts

@@ -9,10 +9,13 @@ export type ConnectedChatPaneProps = Omit<ChatPaneProps, 'messages' | 'slashComm
     onSend?: (text: string) => void;
 };
 /**
- * {@link ChatPane} bound to `useChatStore` and `useRightSidebarStore`.
+ * {@link ChatPane} bound to `useChatStore` and `useChatVisibilityStore`.
  *
- * Renders nothing while the right sidebar reports chat closed. Appends each
- * submission to the transcript, then either dispatches a registered slash
- * command's `execute` or hands the text to `onSend`.
+ * Appends each submission to the transcript, then either dispatches a
+ * registered slash command's `execute` or hands the text to `onSend`.
+ *
+ * Visibility belongs to whatever hosts it — a pane closes by closing the pane,
+ * a tab by closing the tab. Register it with `chatPanel()`, or as a tab
+ * component, and put it wherever it belongs.
  */
-export declare const ConnectedChatPane: ({ onSend, ...props }: ConnectedChatPaneProps) => import("react/jsx-runtime").JSX.Element | null;
+export declare const ConnectedChatPane: ({ onSend, ...props }: ConnectedChatPaneProps) => import("react/jsx-runtime").JSX.Element;

package/dist/connected/ConnectedSidebarPane.d.ts

@@ -2,11 +2,32 @@ import { SidebarPaneProps } from '../components/widgets/SidebarPane';
 
 export type ConnectedSidebarPaneProps = Omit<SidebarPaneProps, 'title' | 'children' | 'onClose'>;
 /**
- * {@link SidebarPane} bound to `useSidebarStore`.
+ * {@link SidebarPane} bound to `useSidebarStore`, docked left.
  *
  * Renders whichever panel is active, or nothing when the sidebar is closed. The
  * reserved `"settings"` panel id renders the built-in {@link SettingsPanel}
  * wired to `useThemeStore`; every other id resolves against the panels
  * registered in the store.
  */
-export declare const ConnectedSidebarPane: (props: ConnectedSidebarPaneProps) => import("react/jsx-runtime").JSX.Element | null;
+export declare const ConnectedSidebarPane: (props: ConnectedSidebarPaneProps) => import("react/jsx-runtime").JSX.Element;
+/**
+ * {@link SidebarPane} bound to `useInspectorStore`, docked right.
+ *
+ * The same pane on the other edge, resolving against a separate panel registry
+ * — so an inspector opens and closes independently of the explorer, which is
+ * how anyone actually works: file tree open on the left, properties on the
+ * right, both at once.
+ *
+ * Unlike the left pane there is no reserved `"settings"` id here; settings are
+ * navigation, and navigation belongs on the left.
+ *
+ * @example
+ * ```tsx
+ * <ShellLayout
+ *   inspectorPanels={[
+ *     { id: 'properties', label: 'Properties', icon: Sliders, component: Inspector },
+ *   ]}
+ * />
+ * ```
+ */
+export declare const ConnectedInspectorPane: (props: ConnectedSidebarPaneProps) => import("react/jsx-runtime").JSX.Element;

package/dist/connected/ConnectedTerminalPane.d.ts

@@ -11,8 +11,11 @@ export type ConnectedTerminalPaneProps = Omit<TerminalPaneProps, 'history' | 'on
 /**
  * {@link TerminalPane} bound to `useTerminalStore`.
  *
- * Renders nothing while the store reports the terminal closed. Echoes each
- * command into history and handles `help` and `clear` internally; anything else
- * is offered to `onCommand` before falling back to a not-found message.
+ * Echoes each command into history and handles `help` and `clear` internally;
+ * anything else is offered to `onCommand` before falling back to a not-found
+ * message.
+ *
+ * Visibility belongs to whatever hosts it. Register it with `terminalPanel()`
+ * for a side pane, or as a tab component for the docking area.
  */
-export declare const ConnectedTerminalPane: ({ onCommand, ...props }: ConnectedTerminalPaneProps) => import("react/jsx-runtime").JSX.Element | null;
+export declare const ConnectedTerminalPane: ({ onCommand, ...props }: ConnectedTerminalPaneProps) => import("react/jsx-runtime").JSX.Element;

package/dist/connected/index.d.ts

@@ -9,12 +9,13 @@
  * Reach for these when you want the shell's behavior. Reach for the plain
  * components when you want control.
  */
-export { ConnectedActivityBar, type ConnectedActivityBarProps } from './ConnectedActivityBar';
+export { chatPanel, terminalPanel } from './panels';
+export { ConnectedActivityBar, ConnectedInspectorBar, type ConnectedActivityBarProps, } from './ConnectedActivityBar';
 export { ConnectedChatPane, type ConnectedChatPaneProps } from './ConnectedChatPane';
 export { ConnectedCommandPalette, type ConnectedCommandPaletteProps } from './ConnectedCommandPalette';
 export { ConnectedMenuBar, type ConnectedMenuBarProps } from './ConnectedMenuBar';
 export { ConnectedModal, type ConnectedModalProps } from './ConnectedModal';
-export { ConnectedSidebarPane, type ConnectedSidebarPaneProps } from './ConnectedSidebarPane';
+export { ConnectedInspectorPane, ConnectedSidebarPane, type ConnectedSidebarPaneProps, } from './ConnectedSidebarPane';
 export { ConnectedStatusBar, type ConnectedStatusBarProps } from './ConnectedStatusBar';
 export { ConnectedTerminalPane, type ConnectedTerminalPaneProps } from './ConnectedTerminalPane';
 export { ConnectedThemeSwitcher, type ConnectedThemeSwitcherProps } from './ConnectedThemeSwitcher';

package/dist/connected/panels.d.ts

@@ -0,0 +1,28 @@
+import { CHAT_PANEL_ID, TERMINAL_PANEL_ID, ISidebarPanel } from '../core/services/SidebarService';
+
+/**
+ * Ready-made panel descriptors for the shell's own pieces.
+ *
+ * Chat and terminal used to be nailed into fixed slots — chat on the right,
+ * terminal along the bottom — and there was no way to put them anywhere else.
+ * They are now ordinary registrations, so they go wherever you register them:
+ *
+ * ```tsx
+ * initializeShell({
+ *   panels: [terminalPanel()],            // left rail
+ *   inspectorPanels: [chatPanel()],       // right rail
+ * });
+ *
+ * // …or as a dockable tab, alongside everything else:
+ * componentRegistry.register('terminal', ConnectedTerminalPane);
+ * useLayoutStore.getState().addTab('terminal', 'Terminal');
+ * ```
+ *
+ * Each takes overrides, so the id, label or icon can be changed without
+ * rebuilding the descriptor by hand.
+ */
+/** The chat pane, as a registerable panel. */
+export declare const chatPanel: (overrides?: Partial<ISidebarPanel>) => ISidebarPanel;
+/** The terminal, as a registerable panel. */
+export declare const terminalPanel: (overrides?: Partial<ISidebarPanel>) => ISidebarPanel;
+export { CHAT_PANEL_ID, TERMINAL_PANEL_ID };

package/dist/core/Boot.d.ts

@@ -10,6 +10,12 @@ export interface InitializeShellOptions {
      * renders its `component` in the sidebar when selected.
      */
     panels?: ISidebarPanel[];
+    /**
+     * Right-hand panels — inspectors and properties, as opposed to navigation.
+     * Registered against `useInspectorStore`, so they open and close
+     * independently of the left-hand sidebar.
+     */
+    inspectorPanels?: ISidebarPanel[];
     /** Menus keyed by top-level name. Items dispatch through their `commandId`. */
     menus?: Record<string, IMenuItemConfig[]>;
     /** Commands available to the palette, menus and keybindings. */
@@ -32,6 +38,18 @@ export interface InitializeShellOptions {
 }
 /** The command ids `initializeShell` registers unless told not to. */
 export declare const DEFAULT_COMMAND_IDS: readonly ["view.toggleTerminal", "view.toggleChat", "view.toggleSidebar", ...string[]];
+/**
+ * Toggle a panel wherever it happens to be registered.
+ *
+ * Chat and terminal are no longer nailed to one edge, so a command that toggled
+ * a fixed slot would be wrong the moment you moved them. This looks the id up
+ * in the left rail, then the right, and finally opens it as a tab — which is
+ * also what makes `Control+\`` keep working when the terminal is a tab.
+ *
+ * Returns `false` when the id is registered nowhere, so a caller can tell the
+ * difference between "toggled" and "nothing to toggle".
+ */
+export declare const togglePanel: (id: string) => boolean;
 /**
  * Boot the shell: register commands, menus, panels and status bar items into
  * the shell registries and stores.

package/dist/core/services/SidebarService.d.ts

@@ -1,17 +1,48 @@
+import { StoreApi, UseBoundStore } from 'zustand';
 import { LucideIcon } from 'lucide-react';
 
+/**
+ * The docked side panels, one store per edge of the shell.
+ *
+ * Both edges behave identically — a registry of panels, one of which is active,
+ * remembered across reloads — so they share an implementation rather than two
+ * that drift.
+ */
+/**
+ * Ids the shell's own panels use by default.
+ *
+ * Declared here rather than beside the descriptors so `core` can resolve them
+ * without depending on `connected` — the dependency runs the other way.
+ */
+export declare const CHAT_PANEL_ID = "chat";
+export declare const TERMINAL_PANEL_ID = "terminal";
 export interface ISidebarPanel {
     id: string;
     label: string;
     icon: LucideIcon;
     component: React.ComponentType<any> | React.ReactNode;
 }
-interface SidebarState {
+export interface SidebarState {
+    /** Id of the open panel, or `null` when the pane is collapsed. */
     activeSidebar: string | null;
     panels: ISidebarPanel[];
     setActiveSidebar: (id: string | null) => void;
+    /** Open the panel, or close it if it is already open. */
     toggleSidebar: (id: string) => void;
     setPanels: (panels: ISidebarPanel[]) => void;
 }
-export declare const useSidebarStore: import('zustand').UseBoundStore<import('zustand').StoreApi<SidebarState>>;
-export {};
+export type SidebarStore = UseBoundStore<StoreApi<SidebarState>>;
+/**
+ * A panel store bound to one storage key.
+ *
+ * Exported so an application with a third docked region — a bottom drawer, say
+ * — gets the same behaviour without copying it.
+ */
+export declare const createSidebarStore: (storageKey: string) => SidebarStore;
+/** The left-hand pane, beside the activity bar. */
+export declare const useSidebarStore: SidebarStore;
+/**
+ * The right-hand pane: inspectors, properties, chat transcripts — anything
+ * about the current selection rather than about navigation.
+ */
+export declare const useInspectorStore: SidebarStore;

package/dist/core/services/TerminalService.d.ts

@@ -1,8 +1,13 @@
+/**
+ * The terminal's scrollback.
+ *
+ * Visibility used to live here too, back when the terminal had exactly one
+ * place it could be. It is now registered like any other panel, so whatever
+ * hosts it owns whether it is showing — see `terminalPanel()` and
+ * `togglePanel()`.
+ */
 interface TerminalState {
-    isOpen: boolean;
     history: string[];
-    setOpen: (open: boolean) => void;
-    toggle: () => void;
     addHistory: (line: string) => void;
     clearHistory: () => void;
 }

package/dist/index.d.ts

@@ -23,7 +23,8 @@
  * to.
  */
 export { ShellLayout, ShellLayout as NexusWorkspaceShell, type ShellLayoutProps } from './components/layout/ShellLayout';
-export { initializeShell, DEFAULT_COMMAND_IDS, type InitializeShellOptions, } from './core/Boot';
+export { initializeShell, togglePanel, DEFAULT_COMMAND_IDS, type InitializeShellOptions, } from './core/Boot';
+export { PaneHostProvider, usePaneHost, useHostChrome, type IPaneHost, type PaneHostProviderProps, } from './components/layout/PaneHost';
 export { commandRegistry, CommandRegistry, type ICommand } from './core/registry/CommandRegistry';
 export { menuRegistry, MenuRegistry, type IMenuItemConfig } from './core/registry/MenuRegistry';
 export { pluginRegistry, type IPlugin, type PluginStatus } from './core/registry/PluginRegistry';
@@ -31,8 +32,7 @@ export { componentRegistry, type ComponentConstructor } from './core/registry/Co
 export { useChatStore, type ISlashCommandConfig } from './core/services/ChatService';
 export { useLayoutStore } from './core/services/LayoutService';
 export { useModalStore, type ModalType as ModalStoreType } from './core/services/ModalStoreService';
-export { useRightSidebarStore } from './core/services/RightSidebarService';
-export { useSidebarStore, type ISidebarPanel } from './core/services/SidebarService';
+export { useSidebarStore, useInspectorStore, createSidebarStore, CHAT_PANEL_ID, TERMINAL_PANEL_ID, type ISidebarPanel, type SidebarState, type SidebarStore, } from './core/services/SidebarService';
 export { useStatusBarStore, type IStatusBarWidgetConfig } from './core/services/StatusBarService';
 export { useTerminalStore } from './core/services/TerminalService';
 export { useThemeStore, type ThemeType } from './core/services/ThemeService';
@@ -50,7 +50,7 @@ export { Modal, type ModalProps, type ModalType } from './components/widgets/Mod
 export { QuickSearch, type QuickSearchProps, type IQuickSearchResult } from './components/widgets/QuickSearch';
 export { SearchWidget, type SearchWidgetProps, type ISearchResult } from './components/widgets/SearchWidget';
 export { SettingsPanel, type SettingsPanelProps, type ISettingsThemeOption, DEFAULT_SETTINGS_THEMES } from './components/widgets/SettingsPanel';
-export { SidebarPane, type SidebarPaneProps } from './components/widgets/SidebarPane';
+export { SidebarPane, type SidebarPaneProps, type PaneSide } from './components/widgets/SidebarPane';
 export { StatusBar, type StatusBarProps, type IStatusBarWidget } from './components/widgets/StatusBar';
 export { TerminalPane, type TerminalPaneProps } from './components/widgets/TerminalPane';
 export { ThemeSwitcher, type ThemeSwitcherProps, type IThemeOption, DEFAULT_THEME_OPTIONS } from './components/widgets/ThemeSwitcher';
@@ -59,5 +59,7 @@ export { UserProfile, type UserProfileProps, type IUserProfile, type IUserProfil
 export * from './components/graph';
 export { BUILT_IN_LAYOUTS, gridLayout, layeredLayout, type GraphLayout, type GridLayoutOptions, type LayeredLayoutOptions, type LayoutDirection, } from './lib/layout';
 export { DEFAULT_NODE_SIZE, IDENTITY_VIEWPORT, clampScale, edgesOf, findNeighbour, fitViewport, graphBounds, isConnected, nextId, nodeRect, placeRelativeTo, portPoint, rectCenter, removeNode, resolvePorts, toGraphSpace, toScreenSpace, unionRect, viewportRect, centerOn, zoomAt, type Direction, type GraphPort, type IGraphEdge, type IGraphNode, type IPoint, type IRect, type IViewport, } from './lib/graph';
+export * from './components/properties';
+export { getPath, setPath, readValue, readValues, writeValue, writeValues, type IPropertyAccessor, type IPropertyValue, } from './lib/properties';
 export { cn } from './lib/cn';
 export { BUNDLED_THEMES, BUNDLED_THEME_CLASSES, themeClass, type IBundledTheme, type BundledThemeId, } from './lib/themes';

package/dist/lib/properties.d.ts

@@ -0,0 +1,67 @@
+/**
+ * Reading and writing property values across one or many subjects.
+ *
+ * The awkward parts of a property panel are not the inputs — they are knowing
+ * what to show when several things are selected and their values disagree, and
+ * writing a nested value back without mutating anything. Both live here, as
+ * pure functions, so they can be tested without rendering.
+ */
+/** A value shared by every selected subject, or a marker that they differ. */
+export interface IPropertyValue<T = unknown> {
+    /** The common value, or `undefined` when subjects disagree or none are selected. */
+    value: T | undefined;
+    /**
+     * Subjects hold different values for this property.
+     *
+     * A field showing `mixed` must not display one subject's value as if it were
+     * everyone's — that is how a multi-selection edit silently flattens data.
+     */
+    mixed: boolean;
+}
+/**
+ * Read a dot-separated path, e.g. `"data.label"`.
+ *
+ * Returns `undefined` for a missing path rather than throwing, because a
+ * property panel routinely renders objects that don't have every field yet.
+ */
+export declare const getPath: (subject: unknown, path: string) => unknown;
+/**
+ * Return a copy of `subject` with `path` set to `value`.
+ *
+ * Every object along the path is cloned, so the original is untouched and React
+ * sees a new reference at each level it needs to. Missing intermediate objects
+ * are created.
+ */
+export declare const setPath: <T>(subject: T, path: string, value: unknown) => T;
+/** How a property is read from and written to a subject. */
+export interface IPropertyAccessor<S = unknown, V = unknown> {
+    /** Dot path, used for both reading and writing unless overridden. */
+    key: string;
+    /** Custom read. Defaults to `getPath(subject, key)`. */
+    get?: (subject: S) => V;
+    /** Custom write, returning a new subject. Defaults to `setPath`. */
+    set?: (subject: S, value: V) => S;
+}
+/** Read a property from one subject, honouring a custom accessor. */
+export declare const readValue: <S, V>(subject: S, accessor: IPropertyAccessor<S, V>) => V;
+/** Write a property to one subject, honouring a custom accessor. */
+export declare const writeValue: <S, V>(subject: S, accessor: IPropertyAccessor<S, V>, value: V) => S;
+/**
+ * Read a property across a selection.
+ *
+ * With one subject this is just its value. With several, it is the shared value
+ * — or `mixed`, if they disagree. With none, it is empty and not mixed.
+ *
+ * Comparison is by `Object.is`, so two structurally equal objects at the same
+ * path read as mixed. That is deliberate: a panel cannot know whether deep
+ * equality is meaningful for an arbitrary payload, and claiming agreement it
+ * hasn't verified is the more damaging error.
+ */
+export declare const readValues: <S, V>(subjects: S[], accessor: IPropertyAccessor<S, V>) => IPropertyValue<V>;
+/**
+ * Apply a value to every subject, returning new copies.
+ *
+ * Subjects that already hold the value are returned unchanged by identity, so
+ * an edit across a large selection only invalidates what actually moved.
+ */
+export declare const writeValues: <S, V>(subjects: S[], accessor: IPropertyAccessor<S, V>, value: V) => S[];