@danxbot/ui 6.3.8 → 6.4.0

package/dist/types/components/AppShell.d.ts

@@ -120,7 +120,37 @@ export interface AppShellProps {
      * box itself.
      */
     scrollResetKey?: string | number;
+    /**
+     * Remembers whether the sidebar is collapsed, under `danxbot-<persistId>`.
+     * `false` stops it being remembered at all.
+     *
+     * COLLAPSING IS THE ONE GESTURE ON THIS SHELL THAT ONLY MAKES SENSE KEPT.
+     * Its entire purpose is to give the content the sidebar's width back, and it
+     * was plain `useState` — so every refresh handed the width straight back to
+     * the navigation. Somebody who wants a narrow sidebar wants it on every load;
+     * re-collapsing it on each one is the app forgetting a decision that was
+     * never provisional.
+     *
+     * NOTE THE DIFFERENCE FROM `PanelGroup`'s `persistId`, which is undefined by
+     * default and persists nothing until a caller names it. That is right there
+     * and wrong here: a page can hold any number of panel groups, so none of them
+     * can claim a default key without colliding with the next one, whereas an
+     * application has exactly ONE shell and can safely name itself. Two shells on
+     * one origin — a shell previewed inside a shell — give the inner one its own
+     * id, which is what the test for that case pins.
+     *
+     * It is the ONLY thing this component stores, and it is the only KIND of
+     * thing it should: a per-viewer arrangement that can come back empty with no
+     * consequence. Every read and write goes through `lib/persist`, which
+     * swallows the throw `localStorage` raises in a private window or wherever
+     * storage is blocked by policy — the read happens in a `useState`
+     * initializer, where an unhandled throw unmounts the whole tree. A blocked
+     * browser gets an expanded sidebar and a working app, never a blank page.
+     *
+     * @default "app-shell-sidebar"
+     */
+    persistId?: string | false;
     children: ReactNode;
     className?: string;
 }
-export declare function AppShell({ brand, sections, activeId, sidebarFooter, header, contentLandmark, navLabel, scroll, scrollResetKey, children, className, }: AppShellProps): import("react").JSX.Element;
+export declare function AppShell({ brand, sections, activeId, sidebarFooter, header, contentLandmark, navLabel, scroll, scrollResetKey, persistId, children, className, }: AppShellProps): import("react").JSX.Element;

package/dist/types/components/Tabs.d.ts

@@ -14,6 +14,12 @@ declare const tabs: import("tailwind-variants").TVReturnType<{
             indicator: string;
         };
     };
+    fill: {
+        true: {
+            root: string;
+            panel: string;
+        };
+    };
 }, {
     root: string;
     list: string;
@@ -33,6 +39,12 @@ declare const tabs: import("tailwind-variants").TVReturnType<{
             indicator: string;
         };
     };
+    fill: {
+        true: {
+            root: string;
+            panel: string;
+        };
+    };
 }, {
     root: string;
     list: string;
@@ -52,6 +64,12 @@ declare const tabs: import("tailwind-variants").TVReturnType<{
             indicator: string;
         };
     };
+    fill: {
+        true: {
+            root: string;
+            panel: string;
+        };
+    };
 }, {
     root: string;
     list: string;
@@ -60,10 +78,37 @@ declare const tabs: import("tailwind-variants").TVReturnType<{
     panel: string;
 }>>;
 export interface TabsProps extends Omit<BaseTabs.Root.Props, "className">, VariantProps<typeof tabs> {
+    /**
+     * Fill the height this group was given, instead of sizing to the content of
+     * whichever panel is open.
+     *
+     * THIS IS THE SHAPE `AppShell` ASKS FOR AND A TABBED SCREEN COULD NOT GIVE.
+     * The shell bounds the viewport and hands its content column a real height;
+     * its own instruction to a screen that wants to use it is "write `flex-1
+     * min-h-0`, and never name a viewport unit". A tabbed screen was the one
+     * arrangement where that could not be honoured — the root here passes a
+     * height DOWN (it is already a flex column) but claims none of its own, and
+     * the panel below it is a plain block, so the two together are an
+     * auto-height gap in the middle of an otherwise sound chain. The only way
+     * through was for the content inside to name a fraction of the viewport,
+     * which is precisely the arithmetic the shell exists to have ended.
+     *
+     * OPT-IN, AND THAT IS THE DESIGN RATHER THAN CAUTION. A tab group inside a
+     * card is the ordinary case and must keep sizing to its content. It also
+     * cannot be a default safely: a consumer rendering SEVERAL panels at once
+     * (Base UI also keeps an OUTGOING panel mounted for the length of its exit
+     * transition, so even a one-panel group briefly has two) would have them
+     * split the same free space between them. Filling is a claim about the box
+     * this group was handed, so the caller who knows that box is the one who
+     * makes it.
+     *
+     * @default false
+     */
+    fill?: boolean;
     className?: string;
     ref?: Ref<HTMLDivElement>;
 }
-export declare function Tabs({ variant, className, children, ref, ...props }: TabsProps): import("react").JSX.Element;
+export declare function Tabs({ variant, fill, className, children, ref, ...props }: TabsProps): import("react").JSX.Element;
 export interface TabListProps {
     className?: string;
     children: ReactNode;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@danxbot/ui",
-  "version": "6.3.8",
+  "version": "6.4.0",
   "type": "module",
   "description": "Danxbot — a domain-agnostic React design system with motion as a first-class primitive.",
   "license": "MIT",