@1money/component-ui 0.0.95-alpha.1 → 0.0.95-alpha.10

package/es/components/ActionBar/constants.d.ts

@@ -22,6 +22,14 @@ export type ActionBarLayout = (typeof ACTION_BAR_LAYOUTS)[number];
  *   "Dialog Body" spec).
  */
 export declare const ACTION_BAR_BUTTON_SIZE: Record<ActionBarLayout, ButtonSize>;
+/**
+ * Footnote row alignment. The DS uses `center` for a prompt + action pair and
+ * `start` for a bare action link sitting under the buttons (the auth card's
+ * "Forgot your password?", Figma 39579:28516).
+ */
+export declare const ACTION_BAR_FOOTNOTE_ALIGNS: readonly ["center", "start"];
+export type ActionBarFootnoteAlign = (typeof ACTION_BAR_FOOTNOTE_ALIGNS)[number];
+export declare const ACTION_BAR_FOOTNOTE_DEFAULT_ALIGN: ActionBarFootnoteAlign;
 export declare const ACTION_BAR_SLOT: {
     readonly root: "root";
     readonly actions: "actions";

package/es/components/ActionBar/constants.js

@@ -22,9 +22,16 @@ export var ACTION_BAR_BUTTON_SIZE = {
   fill: 'large',
   compact: 'medium'
 };
+/**
+ * Footnote row alignment. The DS uses `center` for a prompt + action pair and
+ * `start` for a bare action link sitting under the buttons (the auth card's
+ * "Forgot your password?", Figma 39579:28516).
+ */
+export var ACTION_BAR_FOOTNOTE_ALIGNS = ['center', 'start'];
+export var ACTION_BAR_FOOTNOTE_DEFAULT_ALIGN = 'center';
 export var ACTION_BAR_SLOT = {
   root: 'root',
   actions: 'actions',
   footnote: 'footnote'
 };
-//# sourceMappingURL=data:application/json;charset=utf8;base64,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
+//# sourceMappingURL=data:application/json;charset=utf8;base64,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

package/es/components/ActionBar/interface.d.ts

@@ -1,7 +1,7 @@
 import type { ReactNode } from 'react';
 import type { ButtonColor, ButtonProps, ButtonSize } from "../Button";
-import type { ActionBarDirection, ActionBarLayout } from './constants';
-export type { ActionBarDirection, ActionBarLayout } from './constants';
+import type { ActionBarDirection, ActionBarFootnoteAlign, ActionBarLayout } from './constants';
+export type { ActionBarDirection, ActionBarFootnoteAlign, ActionBarLayout } from './constants';
 /**
  * One footer action. The bar owns size, order, and layout; consumers only
  * supply label, behavior, and (optionally) a color tone override.
@@ -48,7 +48,7 @@ export interface ActionBarAction {
  */
 export type ActionBarPrimarySlot = ReactNode;
 /**
- * Optional centered footnote row under the actions, e.g.
+ * Optional footnote row under the actions, e.g.
  * `"Don't have access to your 2FA?  Reset 2FA"`.
  */
 export interface ActionBarFootnote {
@@ -56,9 +56,32 @@ export interface ActionBarFootnote {
     prompt?: ReactNode;
     /** Trailing brand-colored action text. */
     action?: ReactNode;
+    /**
+     * Row alignment. Defaults to `center` (the prompt + action pair). Use
+     * `start` for a bare action link under the buttons — the auth card's
+     * "Forgot your password?" sits left-aligned while the passkey row below it
+     * stays centered.
+     */
+    align?: ActionBarFootnoteAlign;
+    /**
+     * Destination for an action that navigates. The action already renders as
+     * an anchor, so giving it the `href` is what makes it behave like the link
+     * it looks like — open-in-new-tab, middle click, copy address, and the
+     * status bar preview all come back. Handing it an `onClick` that navigates
+     * instead leaves an anchor with no destination, which none of those work on.
+     */
+    href?: string;
+    /** Anchor target, e.g. `_blank`. Only meaningful with `href`. */
+    target?: string;
+    /** Anchor rel, e.g. `noopener noreferrer`. Only meaningful with `href`. */
+    rel?: string;
     /** Fires when the action text is clicked or activated via keyboard. */
     onClick?: () => void;
-    /** Render a hairline divider above the row (matches the OTP dialog design). */
+    /**
+     * Render a hairline divider above the row (matches the OTP dialog design).
+     * The divider is a row of the bar in its own right, so the bar's uniform
+     * gap surrounds it — it carries no margin of its own.
+     */
     divided?: boolean;
 }
 export interface ActionBarProps {
@@ -69,8 +92,13 @@ export interface ActionBarProps {
      */
     layout?: ActionBarLayout;
     /**
-     * Arrangement: `horizontal` (default) or `vertical` (stacked, each button
-     * full-width — result-dialog style).
+     * Arrangement: `horizontal` (default — two actions split the row) or
+     * `vertical` (stacked, each button full-width).
+     *
+     * The default applies everywhere, result surfaces included: `PanelLayout`
+     * and `BaseDialog` pass this straight through and set no default of their
+     * own. `vertical` is opt-in, for flows that want the actions read
+     * top-to-bottom rather than weighed side by side.
      */
     direction?: ActionBarDirection;
     /**
@@ -81,8 +109,14 @@ export interface ActionBarProps {
     primarySlot?: ReactNode;
     /** Optional secondary (left) action. */
     secondary?: ActionBarAction;
-    /** Optional centered footnote row below the actions. */
-    footnote?: ActionBarFootnote;
+    /**
+     * Footnote row(s) below the actions. Pass an array for surfaces that stack
+     * more than one — the auth card (Figma 39579:28516) puts a left-aligned
+     * "Forgot your password?" directly under the buttons, then a divided,
+     * centered passkey row. Rows render in array order and are spaced by the
+     * bar's own gap.
+     */
+    footnote?: ActionBarFootnote | ActionBarFootnote[];
     /** CSS class prefix. */
     prefixCls?: string;
     /** Additional class on the root element. */

package/es/components/ActionBar/style/ActionBar.css

@@ -41,4 +41,7 @@
 }
 .om-component-ui-action-bar-footnote a {
   cursor: pointer;
+}
+.om-component-ui-action-bar > .om-component-ui-divider {
+  margin: 0;
 }

package/es/components/Dialog/interface.d.ts

@@ -15,10 +15,16 @@ export interface DialogProps extends Omit<HTMLAttributes<HTMLDivElement>, 'child
     fullWidth?: boolean;
     fixed?: boolean;
     /**
-     * Bare panel mode: keep the overlay machinery (portal, mask, Esc, close /
-     * back controls, viewport max-height, width presets) but render NO panel
-     * chrome and NO header/body/footer slots — children fill the panel
-     * directly. For surfaces that bring their own chrome (e.g. FormLayout).
+     * Bare panel mode: keep the overlay machinery (portal, mask, Esc, the close
+     * control, viewport max-height, width presets) but render NO panel chrome
+     * and NO header/body/footer slots — children fill the panel directly. For
+     * surfaces that bring their own chrome (e.g. FormLayout).
+     *
+     * `showBackIcon` is NOT honoured here. The close control is absolutely
+     * positioned overlay chrome and works in either mode, but the back arrow
+     * takes its own row in the content flow — and a bare panel has no content
+     * flow to put it in. A bare host that needs one renders it into its own
+     * surface instead (PanelLayout takes `showBackIcon`/`onBack` of its own).
      */
     bare?: boolean;
     width?: number | string;

package/es/components/FormLayout/config.d.ts

@@ -50,24 +50,28 @@ export type FormLayoutSize = (typeof FORM_LAYOUT_SIZES)[number];
 /**
  * Per-size density overrides on a variant's baseline (the baseline IS the
  * `large` size). Only `page/small` exists today — the compact auth-card
- * surface (448 wide, matching the app's sign-in card): a narrower panel with
- * 24 padding and a uniform 16 spacing (row gap, column gutter, AND the region
- * gap between header / fields / footer). It is tighter than the baseline in
- * width and padding, but its 16 row gap / column gutter are LOOSER than the
- * baseline's 12 — the auth card is deliberately airier between fields.
- * Only `actionGap` and `controlSize` fall back to the baseline. A variant/size with no entry
- * uses the baseline unchanged, so `large` never needs an entry. `modal`
- * intentionally has no `small`: the 380 confirm/result dialog is BaseDialog,
- * which is not a form surface and does not use FormLayout.
+ * surface: a narrower, less padded panel that keeps the page baseline's gap
+ * rhythm untouched (12 row gap / 12 column gutter / 16 region gap), so a field
+ * stack reads identically in the auth card and in the full-width page form.
+ * Width and padding are the ONLY deviations.
+ *
+ * Its 380 width is the SAME number `PanelLayout` uses, and deliberately so:
+ * an auth flow swaps a form card for a result panel in place (forgot-password
+ * → "we've sent a link"), so a different width would make the card jump.
+ * The two tables still hold it separately — they are different surfaces that
+ * happen to agree, not one value with two readers.
+ *
+ * Every gap (rowGap / colGutter / regionGap / actionGap) plus `controlSize`
+ * falls back to the baseline. A variant/size with no entry uses the baseline
+ * unchanged, so `large` never needs an entry. `modal` intentionally has no
+ * `small`: the confirm/result dialog is BaseDialog, which is not a form
+ * surface and does not use FormLayout.
  */
 export declare const FORM_LAYOUT_SIZE: {
     readonly page: {
         readonly small: {
-            readonly width: 448;
+            readonly width: 380;
             readonly padding: 24;
-            readonly rowGap: 16;
-            readonly colGutter: 16;
-            readonly regionGap: 16;
         };
     };
 };
@@ -77,18 +81,18 @@ export declare const FORM_LAYOUT_SIZE: {
  * (BaseProForm) read, so width / padding / gaps / control size never diverge.
  */
 export declare const resolveFormLayoutConfig: (variant: FormLayoutVariant, size?: FormLayoutSize) => {
-    width: 640 | 448;
+    width: 640 | 380;
     padding: 24;
-    rowGap: 16 | 12;
-    colGutter: 16 | 12;
+    rowGap: 12;
+    colGutter: 12;
     regionGap: 16;
     actionGap: 12;
     controlSize: "small";
 } | {
-    width: 738 | 448;
+    width: 738 | 380;
     padding: 32 | 24;
-    rowGap: 16 | 12;
-    colGutter: 16 | 12;
+    rowGap: 12;
+    colGutter: 12;
     regionGap: 16;
     actionGap: 12;
     controlSize: "large";

package/es/components/FormLayout/config.js

@@ -47,24 +47,28 @@ export var FORM_LAYOUT_SIZES = ['large', 'small'];
 /**
  * Per-size density overrides on a variant's baseline (the baseline IS the
  * `large` size). Only `page/small` exists today — the compact auth-card
- * surface (448 wide, matching the app's sign-in card): a narrower panel with
- * 24 padding and a uniform 16 spacing (row gap, column gutter, AND the region
- * gap between header / fields / footer). It is tighter than the baseline in
- * width and padding, but its 16 row gap / column gutter are LOOSER than the
- * baseline's 12 — the auth card is deliberately airier between fields.
- * Only `actionGap` and `controlSize` fall back to the baseline. A variant/size with no entry
- * uses the baseline unchanged, so `large` never needs an entry. `modal`
- * intentionally has no `small`: the 380 confirm/result dialog is BaseDialog,
- * which is not a form surface and does not use FormLayout.
+ * surface: a narrower, less padded panel that keeps the page baseline's gap
+ * rhythm untouched (12 row gap / 12 column gutter / 16 region gap), so a field
+ * stack reads identically in the auth card and in the full-width page form.
+ * Width and padding are the ONLY deviations.
+ *
+ * Its 380 width is the SAME number `PanelLayout` uses, and deliberately so:
+ * an auth flow swaps a form card for a result panel in place (forgot-password
+ * → "we've sent a link"), so a different width would make the card jump.
+ * The two tables still hold it separately — they are different surfaces that
+ * happen to agree, not one value with two readers.
+ *
+ * Every gap (rowGap / colGutter / regionGap / actionGap) plus `controlSize`
+ * falls back to the baseline. A variant/size with no entry uses the baseline
+ * unchanged, so `large` never needs an entry. `modal` intentionally has no
+ * `small`: the confirm/result dialog is BaseDialog, which is not a form
+ * surface and does not use FormLayout.
  */
 export var FORM_LAYOUT_SIZE = {
   page: {
     small: {
-      width: 448,
-      padding: 24,
-      rowGap: 16,
-      colGutter: 16,
-      regionGap: 16
+      width: 380,
+      padding: 24
     }
   }
 };
@@ -98,4 +102,4 @@ export var formLayoutCssVars = function formLayoutCssVars(variant) {
     '--form-layout-action-gap': "".concat(config.actionGap, "px")
   };
 };
-//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["components/src/components/FormLayout/config.ts","components/FormLayout/config.js"],"names":["FORM_LAYOUT_PREFIX","FORM_LAYOUT_CONFIG","modal","width","padding","rowGap","colGutter","regionGap","actionGap","controlSize","page","FORM_LAYOUT_VARIANTS","Object","keys","FORM_LAYOUT_SIZES","FORM_LAYOUT_SIZE","small","resolveFormLayoutConfig","variant","size","arguments","length","undefined","overrides","override","assign","FORM_LAYOUT_SLOT","header","title","extra","content","footer","formLayoutCssVars","config","concat"],"mappings":"AAEA,OAAO,IAAMA,kBAAkB,GAAG,aAAa;AAE/C;ACFA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;ADIA,OAAO,IAAMC,kBAAkB,GAAG;EAChC;EACAC,KAAK,EAAE;IACL;IACAC,KAAK,EAAE,GAAG;IACV;IACAC,OAAO,EAAE,EAAE;IACX;IACAC,MAAM,EAAE,EAAE;IACV;IACAC,SAAS,EAAE,EAAE;IACb;IACAC,SAAS,EAAE,EAAE;IACb;IACAC,SAAS,EAAE,EAAE;IACb;IACAC,WAAW,EAAE;ECFb,CDGD;EACD;ACFF;AACA;AACA;AACA;EDIEC,IAAI,EAAE;IACJP,KAAK,EAAE,GAAG;IACVC,OAAO,EAAE,EAAE;IACXC,MAAM,EAAE,EAAE;IACVC,SAAS,EAAE,EAAE;IACbC,SAAS,EAAE,EAAE;IACbC,SAAS,EAAE,EAAE;IACbC,WAAW,EAAE;ECFb;AACJ,CDGU;AAIV,OAAO,IAAME,oBAAoB,GAAGC,MAAM,CAACC,IAAI,CAACZ,kBAAkB,CAAwB;AAE1F,OAAO,IAAMa,iBAAiB,GAAG,CAAC,OAAO,EAAE,OAAO,CAAU;AAc5D;ACnBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;ADqBA,OAAO,IAAMC,gBAAgB,GAAG;EAC9BL,IAAI,EAAE;IACJM,KAAK,EAAE;MAAEb,KAAK,EAAE,GAAG;MAAEC,OAAO,EAAE,EAAE;MAAEC,MAAM,EAAE,EAAE;MAAEC,SAAS,EAAE,EAAE;MAAEC,SAAS,EAAE;IAAE;ECnB1E;AACJ,CDoB4G;AAE5G;ACpBA;AACA;AACA;AACA;ADsBA,OAAO,IAAMU,uBAAuB,GAAG,SAA1BA,uBAAuBA,CAAIC,OAA0B,EAAoC;EAAA,IAAlCC,IAAA,GAAAC,SAAA,CAAAC,MAAA,QAAAD,SAAA,QAAAE,SAAA,GAAAF,SAAA,MAAuB,OAAO;EAChG,IAAMG,SAAS,GAAGR,gBAAgB,CAACG,OAAwC,CAAC;EAC5E,IAAMM,QAAQ,GAAGD,SAAS,GAAGA,SAAS,CAACJ,IAA8B,CAAC,GAAGG,SAAS;EAClF,OAAAV,MAAA,CAAAa,MAAA,CAAAb,MAAA,CAAAa,MAAA,CAAA,CAAA,CAAA,EAAYxB,kBAAkB,CAACiB,OAAO,CAAC,CAAA,EAAKM,QAAQ,CAAA;AACtD,CAAC;AAED,OAAO,IAAME,gBAAgB,GAAG;EAC9BC,MAAM,EAAE,QAAQ;EAChBC,KAAK,EAAE,OAAO;EACdC,KAAK,EAAE,OAAO;EACdC,OAAO,EAAE,SAAS;EAClBC,MAAM,EAAE;ACrBV,CDsBU;AAEV;AACA,OAAO,IAAMC,iBAAiB,GAAG,SAApBA,iBAAiBA,CAC5Bd,OAA0B,EAET;EAAA,IADjBC,IAAA,GAAAC,SAAA,CAAAC,MAAA,QAAAD,SAAA,QAAAE,SAAA,GAAAF,SAAA,MAAuB,OAAO;EAE9B,IAAMa,MAAM,GAAGhB,uBAAuB,CAACC,OAAO,EAAEC,IAAI,CAAC;EACrD,OAAO;IACL,qBAAqB,KAAAe,MAAA,CAAKD,MAAM,CAAC9B,KAAK,OAAI;IAC1C,uBAAuB,KAAA+B,MAAA,CAAKD,MAAM,CAAC7B,OAAO,OAAI;IAC9C,uBAAuB,KAAA8B,MAAA,CAAKD,MAAM,CAAC5B,MAAM,OAAI;IAC7C,0BAA0B,KAAA6B,MAAA,CAAKD,MAAM,CAAC1B,SAAS,OAAI;IACnD,0BAA0B,KAAA2B,MAAA,CAAKD,MAAM,CAACzB,SAAS;ECzB/C,CD0BgB;AACpB,CAAC","file":"components/FormLayout/config.js","sourcesContent":[null,"export const FORM_LAYOUT_PREFIX = 'form-layout';\n/**\n * THE density table for form surfaces — the single thing to edit when the\n * design changes or a new density is added. Every value is consumed through\n * CSS custom properties (container spacing) or read by the form preset\n * (row gap / column gutter for ProForm), so adding a variant here is the\n * whole job.\n *\n * Source: 1Money Design System (Beta) — \"Dialog Body\" (node 39743-4634)\n * for `modal`; page usage (node 39956-9712) for `page`.\n */\nexport const FORM_LAYOUT_CONFIG = {\n    /** Inside a dialog: tighter density. */\n    modal: {\n        /** Default panel width (px); the `width` prop overrides. */\n        width: 640,\n        /** Panel padding (px). */\n        padding: 24,\n        /** Vertical gap between field rows (px). */\n        rowGap: 12,\n        /** Horizontal gutter between columns in a row (px). */\n        colGutter: 12,\n        /** Gap between the header / fields / footer regions (px). */\n        regionGap: 16,\n        /** Gap between footer action buttons (px); ActionBar reads it via var. */\n        actionGap: 12,\n        /** Control size cascaded to every field via ProForm `size`. */\n        controlSize: 'small',\n    },\n    /**\n     * Standalone on a page: a wider panel with roomier padding, but the SAME\n     * tight 12/16 gap rhythm as the dialog — only `width` (738) and `padding`\n     * (32) separate the two densities, plus the large control size.\n     */\n    page: {\n        width: 738,\n        padding: 32,\n        rowGap: 12,\n        colGutter: 12,\n        regionGap: 16,\n        actionGap: 12,\n        controlSize: 'large',\n    },\n};\nexport const FORM_LAYOUT_VARIANTS = Object.keys(FORM_LAYOUT_CONFIG);\nexport const FORM_LAYOUT_SIZES = ['large', 'small'];\n/**\n * Per-size density overrides on a variant's baseline (the baseline IS the\n * `large` size). Only `page/small` exists today — the compact auth-card\n * surface (448 wide, matching the app's sign-in card): a narrower panel with\n * 24 padding and a uniform 16 spacing (row gap, column gutter, AND the region\n * gap between header / fields / footer). It is tighter than the baseline in\n * width and padding, but its 16 row gap / column gutter are LOOSER than the\n * baseline's 12 — the auth card is deliberately airier between fields.\n * Only `actionGap` and `controlSize` fall back to the baseline. A variant/size with no entry\n * uses the baseline unchanged, so `large` never needs an entry. `modal`\n * intentionally has no `small`: the 380 confirm/result dialog is BaseDialog,\n * which is not a form surface and does not use FormLayout.\n */\nexport const FORM_LAYOUT_SIZE = {\n    page: {\n        small: { width: 448, padding: 24, rowGap: 16, colGutter: 16, regionGap: 16 },\n    },\n};\n/**\n * Baseline density for a variant merged with the requested size's deviations.\n * The single lookup both the surface (FormLayout) and the form preset\n * (BaseProForm) read, so width / padding / gaps / control size never diverge.\n */\nexport const resolveFormLayoutConfig = (variant, size = 'large') => {\n    const overrides = FORM_LAYOUT_SIZE[variant];\n    const override = overrides ? overrides[size] : undefined;\n    return Object.assign(Object.assign({}, FORM_LAYOUT_CONFIG[variant]), override);\n};\nexport const FORM_LAYOUT_SLOT = {\n    header: 'header',\n    title: 'title',\n    extra: 'extra',\n    content: 'content',\n    footer: 'footer',\n};\n/** Bridge the resolved (variant, size) numbers into CSS custom properties. */\nexport const formLayoutCssVars = (variant, size = 'large') => {\n    const config = resolveFormLayoutConfig(variant, size);\n    return {\n        '--form-layout-width': `${config.width}px`,\n        '--form-layout-padding': `${config.padding}px`,\n        '--form-layout-row-gap': `${config.rowGap}px`,\n        '--form-layout-region-gap': `${config.regionGap}px`,\n        '--form-layout-action-gap': `${config.actionGap}px`,\n    };\n};"],"sourceRoot":"../../../../../../../../src"}
+//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["components/src/components/FormLayout/config.ts","components/FormLayout/config.js"],"names":["FORM_LAYOUT_PREFIX","FORM_LAYOUT_CONFIG","modal","width","padding","rowGap","colGutter","regionGap","actionGap","controlSize","page","FORM_LAYOUT_VARIANTS","Object","keys","FORM_LAYOUT_SIZES","FORM_LAYOUT_SIZE","small","resolveFormLayoutConfig","variant","size","arguments","length","undefined","overrides","override","assign","FORM_LAYOUT_SLOT","header","title","extra","content","footer","formLayoutCssVars","config","concat"],"mappings":"AAEA,OAAO,IAAMA,kBAAkB,GAAG,aAAa;AAE/C;ACFA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;ADIA,OAAO,IAAMC,kBAAkB,GAAG;EAChC;EACAC,KAAK,EAAE;IACL;IACAC,KAAK,EAAE,GAAG;IACV;IACAC,OAAO,EAAE,EAAE;IACX;IACAC,MAAM,EAAE,EAAE;IACV;IACAC,SAAS,EAAE,EAAE;IACb;IACAC,SAAS,EAAE,EAAE;IACb;IACAC,SAAS,EAAE,EAAE;IACb;IACAC,WAAW,EAAE;ECFb,CDGD;EACD;ACFF;AACA;AACA;AACA;EDIEC,IAAI,EAAE;IACJP,KAAK,EAAE,GAAG;IACVC,OAAO,EAAE,EAAE;IACXC,MAAM,EAAE,EAAE;IACVC,SAAS,EAAE,EAAE;IACbC,SAAS,EAAE,EAAE;IACbC,SAAS,EAAE,EAAE;IACbC,WAAW,EAAE;ECFb;AACJ,CDGU;AAIV,OAAO,IAAME,oBAAoB,GAAGC,MAAM,CAACC,IAAI,CAACZ,kBAAkB,CAAwB;AAE1F,OAAO,IAAMa,iBAAiB,GAAG,CAAC,OAAO,EAAE,OAAO,CAAU;AAc5D;ACnBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;ADqBA,OAAO,IAAMC,gBAAgB,GAAG;EAC9BL,IAAI,EAAE;IACJM,KAAK,EAAE;MAAEb,KAAK,EAAE,GAAG;MAAEC,OAAO,EAAE;IAAE;ECnBhC;AACJ,CDoB4G;AAE5G;ACpBA;AACA;AACA;AACA;ADsBA,OAAO,IAAMa,uBAAuB,GAAG,SAA1BA,uBAAuBA,CAAIC,OAA0B,EAAoC;EAAA,IAAlCC,IAAA,GAAAC,SAAA,CAAAC,MAAA,QAAAD,SAAA,QAAAE,SAAA,GAAAF,SAAA,MAAuB,OAAO;EAChG,IAAMG,SAAS,GAAGR,gBAAgB,CAACG,OAAwC,CAAC;EAC5E,IAAMM,QAAQ,GAAGD,SAAS,GAAGA,SAAS,CAACJ,IAA8B,CAAC,GAAGG,SAAS;EAClF,OAAAV,MAAA,CAAAa,MAAA,CAAAb,MAAA,CAAAa,MAAA,CAAA,CAAA,CAAA,EAAYxB,kBAAkB,CAACiB,OAAO,CAAC,CAAA,EAAKM,QAAQ,CAAA;AACtD,CAAC;AAED,OAAO,IAAME,gBAAgB,GAAG;EAC9BC,MAAM,EAAE,QAAQ;EAChBC,KAAK,EAAE,OAAO;EACdC,KAAK,EAAE,OAAO;EACdC,OAAO,EAAE,SAAS;EAClBC,MAAM,EAAE;ACrBV,CDsBU;AAEV;AACA,OAAO,IAAMC,iBAAiB,GAAG,SAApBA,iBAAiBA,CAC5Bd,OAA0B,EAET;EAAA,IADjBC,IAAA,GAAAC,SAAA,CAAAC,MAAA,QAAAD,SAAA,QAAAE,SAAA,GAAAF,SAAA,MAAuB,OAAO;EAE9B,IAAMa,MAAM,GAAGhB,uBAAuB,CAACC,OAAO,EAAEC,IAAI,CAAC;EACrD,OAAO;IACL,qBAAqB,KAAAe,MAAA,CAAKD,MAAM,CAAC9B,KAAK,OAAI;IAC1C,uBAAuB,KAAA+B,MAAA,CAAKD,MAAM,CAAC7B,OAAO,OAAI;IAC9C,uBAAuB,KAAA8B,MAAA,CAAKD,MAAM,CAAC5B,MAAM,OAAI;IAC7C,0BAA0B,KAAA6B,MAAA,CAAKD,MAAM,CAAC1B,SAAS,OAAI;IACnD,0BAA0B,KAAA2B,MAAA,CAAKD,MAAM,CAACzB,SAAS;ECzB/C,CD0BgB;AACpB,CAAC","file":"components/FormLayout/config.js","sourcesContent":[null,"export const FORM_LAYOUT_PREFIX = 'form-layout';\n/**\n * THE density table for form surfaces — the single thing to edit when the\n * design changes or a new density is added. Every value is consumed through\n * CSS custom properties (container spacing) or read by the form preset\n * (row gap / column gutter for ProForm), so adding a variant here is the\n * whole job.\n *\n * Source: 1Money Design System (Beta) — \"Dialog Body\" (node 39743-4634)\n * for `modal`; page usage (node 39956-9712) for `page`.\n */\nexport const FORM_LAYOUT_CONFIG = {\n    /** Inside a dialog: tighter density. */\n    modal: {\n        /** Default panel width (px); the `width` prop overrides. */\n        width: 640,\n        /** Panel padding (px). */\n        padding: 24,\n        /** Vertical gap between field rows (px). */\n        rowGap: 12,\n        /** Horizontal gutter between columns in a row (px). */\n        colGutter: 12,\n        /** Gap between the header / fields / footer regions (px). */\n        regionGap: 16,\n        /** Gap between footer action buttons (px); ActionBar reads it via var. */\n        actionGap: 12,\n        /** Control size cascaded to every field via ProForm `size`. */\n        controlSize: 'small',\n    },\n    /**\n     * Standalone on a page: a wider panel with roomier padding, but the SAME\n     * tight 12/16 gap rhythm as the dialog — only `width` (738) and `padding`\n     * (32) separate the two densities, plus the large control size.\n     */\n    page: {\n        width: 738,\n        padding: 32,\n        rowGap: 12,\n        colGutter: 12,\n        regionGap: 16,\n        actionGap: 12,\n        controlSize: 'large',\n    },\n};\nexport const FORM_LAYOUT_VARIANTS = Object.keys(FORM_LAYOUT_CONFIG);\nexport const FORM_LAYOUT_SIZES = ['large', 'small'];\n/**\n * Per-size density overrides on a variant's baseline (the baseline IS the\n * `large` size). Only `page/small` exists today — the compact auth-card\n * surface: a narrower, less padded panel that keeps the page baseline's gap\n * rhythm untouched (12 row gap / 12 column gutter / 16 region gap), so a field\n * stack reads identically in the auth card and in the full-width page form.\n * Width and padding are the ONLY deviations.\n *\n * Its 380 width is the SAME number `PanelLayout` uses, and deliberately so:\n * an auth flow swaps a form card for a result panel in place (forgot-password\n * → \"we've sent a link\"), so a different width would make the card jump.\n * The two tables still hold it separately — they are different surfaces that\n * happen to agree, not one value with two readers.\n *\n * Every gap (rowGap / colGutter / regionGap / actionGap) plus `controlSize`\n * falls back to the baseline. A variant/size with no entry uses the baseline\n * unchanged, so `large` never needs an entry. `modal` intentionally has no\n * `small`: the confirm/result dialog is BaseDialog, which is not a form\n * surface and does not use FormLayout.\n */\nexport const FORM_LAYOUT_SIZE = {\n    page: {\n        small: { width: 380, padding: 24 },\n    },\n};\n/**\n * Baseline density for a variant merged with the requested size's deviations.\n * The single lookup both the surface (FormLayout) and the form preset\n * (BaseProForm) read, so width / padding / gaps / control size never diverge.\n */\nexport const resolveFormLayoutConfig = (variant, size = 'large') => {\n    const overrides = FORM_LAYOUT_SIZE[variant];\n    const override = overrides ? overrides[size] : undefined;\n    return Object.assign(Object.assign({}, FORM_LAYOUT_CONFIG[variant]), override);\n};\nexport const FORM_LAYOUT_SLOT = {\n    header: 'header',\n    title: 'title',\n    extra: 'extra',\n    content: 'content',\n    footer: 'footer',\n};\n/** Bridge the resolved (variant, size) numbers into CSS custom properties. */\nexport const formLayoutCssVars = (variant, size = 'large') => {\n    const config = resolveFormLayoutConfig(variant, size);\n    return {\n        '--form-layout-width': `${config.width}px`,\n        '--form-layout-padding': `${config.padding}px`,\n        '--form-layout-row-gap': `${config.rowGap}px`,\n        '--form-layout-region-gap': `${config.regionGap}px`,\n        '--form-layout-action-gap': `${config.actionGap}px`,\n    };\n};"],"sourceRoot":"../../../../../../../../src"}

package/es/components/FormLayout/interface.d.ts

@@ -17,7 +17,7 @@ export interface FormLayoutProps extends Omit<HTMLAttributes<HTMLDivElement>, 't
     /**
      * Panel size within the variant. `large` (default) is the variant baseline;
      * `small` layers a deviation. Only `page/small` deviates today — the compact
-     * auth-card surface (448 wide, 24 padding, 16 gaps); other variant/size
+     * auth-card surface (380 wide, 24 padding, 16 gaps); other variant/size
      * combos fall back to the baseline.
      */
     size?: FormLayoutSize;
@@ -27,7 +27,12 @@ export interface FormLayoutProps extends Omit<HTMLAttributes<HTMLDivElement>, 't
      * footer stay pinned); when `false` content always grows the panel.
      */
     scroll?: boolean;
-    /** Heading; a plain string renders as Headline/md (24px). */
+    /**
+     * Heading; a plain string renders as `Headline/sm` (24 / 28) regardless of
+     * variant or size. Pass a node to compose your own header block (e.g. a
+     * title with a description under it) — the automatic wrapping is skipped,
+     * so supply the `Headline/sm` typography yourself.
+     */
     title?: ReactNode;
     /** Trailing slot on the title row (e.g. an environment switcher). */
     extra?: ReactNode;

package/es/components/PanelLayout/PanelLayout.d.ts

@@ -0,0 +1,3 @@
+import type { PanelLayoutProps } from './interface';
+import './style';
+export declare const PanelLayout: import("react").NamedExoticComponent<PanelLayoutProps>;

package/es/components/PanelLayout/PanelLayout.js

@@ -0,0 +1,163 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { memo } from 'react';
+import { ActionBar } from '../ActionBar';
+import { FormLayout } from '../FormLayout';
+import { Icons } from '../Icons';
+import { Typography } from '../Typography';
+import { default as classnames, joinCls } from '../../utils/classnames';
+import { PANEL_LAYOUT_BACK_ICON_SIZE, PANEL_LAYOUT_BACK_LABEL, PANEL_LAYOUT_PREFIX, resolvePanelLayoutConfig } from './constants';
+import './style';
+/**
+ * The non-form content PANEL — the counterpart to `FormLayout`: that one
+ * holds fields, this one holds an illustration, copy and actions. ONE surface
+ * serving two hosts:
+ *
+ *   page host    <PanelLayout />                         used directly
+ *   dialog host  BaseDialog = Dialog(bare) + this(modal) only adds the overlay
+ *
+ * Deliberately NOT named for a scenario, because it carries several: a
+ * verification challenge, a stepped wizard (2FA setup — hence the back
+ * arrow), a terminal page with no action at all.
+ *
+ * On a page, ONE of those scenarios has a shell of its own and the rest do
+ * not — which decides where business code should reach:
+ *
+ *   a result (success / failure / expired / …)  → `ResultForm`, business/Form
+ *   anything else                               → this, directly
+ *
+ * So being used directly is the normal case here, not a fallback. Only add
+ * another shell on top when a scenario earns a name AND recurring copy (a
+ * `preset`); a shell that just re-exports this one buys nothing.
+ *
+ * Assembly:
+ *
+ *   FormLayout          card chrome (surface, hairline, radius) + the 24
+ *   │                   padding and 16 region gap. Its `page/small` width
+ *   │                   (448, the sign-in card) is NOT used — the panel width
+ *   │                   comes from the config table.
+ *   ├─ header slot      back / illustration / eyebrow / title / description as
+ *   │                   ONE block on 8px seams. It goes in the title slot, not
+ *   │                   the content region, because it is all header copy —
+ *   │                   that also keeps it pinned when the content scrolls.
+ *   ├─ content region   `children` — free-form (a QR code, an OTP input, rows)
+ *   └─ ActionBar(fill)  the actions.
+ *
+ * It owns no copy and no loose numbers: everything host-specific comes from
+ * `PANEL_LAYOUT_CONFIG`, so a divergence between page and dialog is a value
+ * change in that table and nothing else.
+ */
+var PanelLayoutBase = function PanelLayoutBase(_ref) {
+  var _ref$variant = _ref.variant,
+    variant = _ref$variant === void 0 ? 'page' : _ref$variant,
+    scroll = _ref.scroll,
+    width = _ref.width,
+    className = _ref.className,
+    showBackIcon = _ref.showBackIcon,
+    onBack = _ref.onBack,
+    backIcon = _ref.backIcon,
+    eyebrow = _ref.eyebrow,
+    title = _ref.title,
+    description = _ref.description,
+    _ref$descriptionStron = _ref.descriptionStrong,
+    descriptionStrong = _ref$descriptionStron === void 0 ? true : _ref$descriptionStron,
+    illustration = _ref.illustration,
+    primary = _ref.primary,
+    secondary = _ref.secondary,
+    direction = _ref.direction,
+    footnote = _ref.footnote,
+    children = _ref.children;
+  var classes = classnames(PANEL_LAYOUT_PREFIX);
+  var config = resolvePanelLayoutConfig(variant);
+  // A plain string becomes the family heading; a node passes through so
+  // callers can compose (e.g. a Tag above a two-line title).
+  var titleNode = typeof title === 'string' || typeof title === 'number' ? _jsx(Typography.Headline, {
+    size: 'sm',
+    as: 'h2',
+    color: 'default',
+    children: title
+  }) : title;
+  // Same contract as `title`: a plain string gets the family treatment (the
+  // muted label of "Step 2 of 3"), a node passes through so a Tag or a
+  // composed row still works. Without this every caller with a text eyebrow
+  // would hand-roll the same Typography.
+  //
+  // An EMPTY string counts as absent. Callers routinely hold the eyebrow in a
+  // state object that starts as `''`, and rendering an empty label would open
+  // an 8px seam above the title for nothing — so they can pass the value
+  // straight through instead of guarding it at every call site.
+  var eyebrowNode = eyebrow == null || eyebrow === '' ? null : typeof eyebrow === 'string' || typeof eyebrow === 'number' ? _jsx(Typography.Body, {
+    size: 'sm',
+    color: 'default-tertiary',
+    children: eyebrow
+  }) : eyebrow;
+  var illustrationNode = typeof illustration === 'string' ? _jsx(Icons, {
+    name: illustration,
+    size: config.illustrationSize
+  }) : illustration;
+  // Its own row above everything else, on the block's 8px seam — the shape
+  // stepped flows use in both hosts (2FA setup on a page, wizard dialogs).
+  var backNode = showBackIcon ? _jsx("button", {
+    type: 'button',
+    className: classes('back'),
+    "aria-label": PANEL_LAYOUT_BACK_LABEL,
+    onClick: onBack,
+    children: backIcon !== null && backIcon !== void 0 ? backIcon : _jsx(Icons, {
+      name: 'arrowLeft',
+      size: PANEL_LAYOUT_BACK_ICON_SIZE
+    })
+  }) : null;
+  var hasHeader = showBackIcon || illustration != null || eyebrowNode != null || title != null || description != null;
+  var header = hasHeader ? _jsxs("div", {
+    className: classes('header'),
+    children: [backNode, illustrationNode != null && _jsx("div", {
+      className: classes('illustration'),
+      children: illustrationNode
+    }), eyebrowNode, titleNode, description != null && _jsx(Typography.Body, {
+      as: 'p',
+      size: 'md',
+      strong: descriptionStrong,
+      color: 'default-secondary',
+      className: classes('description'),
+      children: description
+    })]
+  }) : undefined;
+  // The bar owns the button size, so the family size is applied per action
+  // rather than as a bar-level prop; an explicit per-action `size` still wins.
+  var withSize = function withSize(action) {
+    var _a;
+    return action && Object.assign(Object.assign({}, action), {
+      size: (_a = action.size) !== null && _a !== void 0 ? _a : config.buttonSize
+    });
+  };
+  var footer = primary || secondary || footnote ? _jsx(ActionBar, {
+    direction: direction,
+    primary: withSize(primary),
+    secondary: withSize(secondary),
+    footnote: footnote
+  }) : undefined;
+  return _jsx(FormLayout
+  // `page/small` is used for its 24 padding and 16 region gap, which are
+  // already the result family's numbers. Its 448 width is NOT — that is
+  // the sign-in card; the result panel is 380, from the config table.
+  , {
+    // `page/small` is used for its 24 padding and 16 region gap, which are
+    // already the result family's numbers. Its 448 width is NOT — that is
+    // the sign-in card; the result panel is 380, from the config table.
+    variant: 'page',
+    size: 'small',
+    scroll: scroll,
+    // In a dialog the Dialog panel carries the width (BaseDialog reads the
+    // same entry) and the layout fills it: sizing a bare panel from its
+    // child hits the shrink-to-fit percentage circularity.
+    width: width !== null && width !== void 0 ? width : variant === 'modal' ? '100%' : config.width,
+    className: joinCls(classes(), classes(variant), className),
+    style: {
+      '--form-layout-action-gap': "".concat(config.actionGap, "px")
+    },
+    title: header,
+    footer: footer,
+    children: children
+  });
+};
+export var PanelLayout = /*#__PURE__*/memo(PanelLayoutBase);
+//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["components/PanelLayout/PanelLayout.js","components/src/components/PanelLayout/PanelLayout.tsx"],"names":["jsx","_jsx","jsxs","_jsxs","memo","ActionBar","FormLayout","Icons","Typography","default","classnames","joinCls","PANEL_LAYOUT_BACK_ICON_SIZE","PANEL_LAYOUT_BACK_LABEL","PANEL_LAYOUT_PREFIX","resolvePanelLayoutConfig","PanelLayoutBase","_ref","_ref$variant","variant","scroll","width","className","showBackIcon","onBack","backIcon","eyebrow","title","description","_ref$descriptionStron","descriptionStrong","illustration","primary","secondary","direction","footnote","children","classes","config","titleNode","Headline","size","as","color","eyebrowNode","Body","illustrationNode","name","illustrationSize","backNode","type","onClick","hasHeader","header","strong","undefined","withSize","action","_a","Object","assign","buttonSize","footer","style","concat","actionGap","PanelLayout"],"mappings":"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","file":"components/PanelLayout/PanelLayout.js","sourcesContent":["import { jsx as _jsx, jsxs as _jsxs } from \"react/jsx-runtime\";\nimport { memo } from 'react';\nimport { ActionBar } from '../ActionBar';\nimport { FormLayout } from '../FormLayout';\nimport { Icons } from '../Icons';\nimport { Typography } from '../Typography';\nimport { default as classnames, joinCls } from '../../utils/classnames';\nimport { PANEL_LAYOUT_BACK_ICON_SIZE, PANEL_LAYOUT_BACK_LABEL, PANEL_LAYOUT_PREFIX, resolvePanelLayoutConfig, } from './constants';\nimport './style';\n/**\n * The non-form content PANEL — the counterpart to `FormLayout`: that one\n * holds fields, this one holds an illustration, copy and actions. ONE surface\n * serving two hosts:\n *\n *   page host    <PanelLayout />                         used directly\n *   dialog host  BaseDialog = Dialog(bare) + this(modal) only adds the overlay\n *\n * Deliberately NOT named for a scenario, because it carries several: a\n * verification challenge, a stepped wizard (2FA setup — hence the back\n * arrow), a terminal page with no action at all.\n *\n * On a page, ONE of those scenarios has a shell of its own and the rest do\n * not — which decides where business code should reach:\n *\n *   a result (success / failure / expired / …)  → `ResultForm`, business/Form\n *   anything else                               → this, directly\n *\n * So being used directly is the normal case here, not a fallback. Only add\n * another shell on top when a scenario earns a name AND recurring copy (a\n * `preset`); a shell that just re-exports this one buys nothing.\n *\n * Assembly:\n *\n *   FormLayout          card chrome (surface, hairline, radius) + the 24\n *   │                   padding and 16 region gap. Its `page/small` width\n *   │                   (448, the sign-in card) is NOT used — the panel width\n *   │                   comes from the config table.\n *   ├─ header slot      back / illustration / eyebrow / title / description as\n *   │                   ONE block on 8px seams. It goes in the title slot, not\n *   │                   the content region, because it is all header copy —\n *   │                   that also keeps it pinned when the content scrolls.\n *   ├─ content region   `children` — free-form (a QR code, an OTP input, rows)\n *   └─ ActionBar(fill)  the actions.\n *\n * It owns no copy and no loose numbers: everything host-specific comes from\n * `PANEL_LAYOUT_CONFIG`, so a divergence between page and dialog is a value\n * change in that table and nothing else.\n */\nconst PanelLayoutBase = ({ variant = 'page', scroll, width, className, showBackIcon, onBack, backIcon, eyebrow, title, description, descriptionStrong = true, illustration, primary, secondary, direction, footnote, children, }) => {\n    const classes = classnames(PANEL_LAYOUT_PREFIX);\n    const config = resolvePanelLayoutConfig(variant);\n    // A plain string becomes the family heading; a node passes through so\n    // callers can compose (e.g. a Tag above a two-line title).\n    const titleNode = typeof title === 'string' || typeof title === 'number' ? (_jsx(Typography.Headline, { size: 'sm', as: 'h2', color: 'default', children: title })) : (title);\n    // Same contract as `title`: a plain string gets the family treatment (the\n    // muted label of \"Step 2 of 3\"), a node passes through so a Tag or a\n    // composed row still works. Without this every caller with a text eyebrow\n    // would hand-roll the same Typography.\n    //\n    // An EMPTY string counts as absent. Callers routinely hold the eyebrow in a\n    // state object that starts as `''`, and rendering an empty label would open\n    // an 8px seam above the title for nothing — so they can pass the value\n    // straight through instead of guarding it at every call site.\n    const eyebrowNode = eyebrow == null || eyebrow === '' ? null\n        : typeof eyebrow === 'string' || typeof eyebrow === 'number' ? (_jsx(Typography.Body, { size: 'sm', color: 'default-tertiary', children: eyebrow })) : (eyebrow);\n    const illustrationNode = typeof illustration === 'string' ? (_jsx(Icons, { name: illustration, size: config.illustrationSize })) : (illustration);\n    // Its own row above everything else, on the block's 8px seam — the shape\n    // stepped flows use in both hosts (2FA setup on a page, wizard dialogs).\n    const backNode = showBackIcon ? (_jsx(\"button\", { type: 'button', className: classes('back'), \"aria-label\": PANEL_LAYOUT_BACK_LABEL, onClick: onBack, children: backIcon !== null && backIcon !== void 0 ? backIcon : _jsx(Icons, { name: 'arrowLeft', size: PANEL_LAYOUT_BACK_ICON_SIZE }) })) : null;\n    const hasHeader = showBackIcon ||\n        illustration != null ||\n        eyebrowNode != null ||\n        title != null ||\n        description != null;\n    const header = hasHeader ? (_jsxs(\"div\", { className: classes('header'), children: [backNode, illustrationNode != null && (_jsx(\"div\", { className: classes('illustration'), children: illustrationNode })), eyebrowNode, titleNode, description != null && (_jsx(Typography.Body, { as: 'p', size: 'md', strong: descriptionStrong, color: 'default-secondary', className: classes('description'), children: description }))] })) : undefined;\n    // The bar owns the button size, so the family size is applied per action\n    // rather than as a bar-level prop; an explicit per-action `size` still wins.\n    const withSize = (action) => { var _a; return action && Object.assign(Object.assign({}, action), { size: (_a = action.size) !== null && _a !== void 0 ? _a : config.buttonSize }); };\n    const footer = primary || secondary || footnote ? (_jsx(ActionBar, { direction: direction, primary: withSize(primary), secondary: withSize(secondary), footnote: footnote })) : undefined;\n    return (_jsx(FormLayout\n    // `page/small` is used for its 24 padding and 16 region gap, which are\n    // already the result family's numbers. Its 448 width is NOT — that is\n    // the sign-in card; the result panel is 380, from the config table.\n    , { \n        // `page/small` is used for its 24 padding and 16 region gap, which are\n        // already the result family's numbers. Its 448 width is NOT — that is\n        // the sign-in card; the result panel is 380, from the config table.\n        variant: 'page', size: 'small', scroll: scroll, \n        // In a dialog the Dialog panel carries the width (BaseDialog reads the\n        // same entry) and the layout fills it: sizing a bare panel from its\n        // child hits the shrink-to-fit percentage circularity.\n        width: width !== null && width !== void 0 ? width : (variant === 'modal' ? '100%' : config.width), className: joinCls(classes(), classes(variant), className), style: { '--form-layout-action-gap': `${config.actionGap}px` }, title: header, footer: footer, children: children }));\n};\nexport const PanelLayout = memo(PanelLayoutBase);",null],"sourceRoot":"../../../../../../../../src"}

package/es/components/PanelLayout/constants.d.ts

@@ -0,0 +1,60 @@
+export declare const PANEL_LAYOUT_PREFIX = "panel-layout";
+/** Back-arrow control: 24px icon, and its accessible name. */
+export declare const PANEL_LAYOUT_BACK_ICON_SIZE = 24;
+export declare const PANEL_LAYOUT_BACK_LABEL = "Go back";
+/**
+ * THE density table for content panels — the single thing to edit when the
+ * design changes. Same shape as `FORM_LAYOUT_CONFIG`: one entry per host, so
+ * a divergence between the two is a value change, never a structural one.
+ *
+ * The two entries are currently IDENTICAL, and that is the design: a panel
+ * renders the same on a page and in a dialog, the only difference being
+ * whether a `Dialog(bare)` is wrapped around it. They are still spelled out
+ * separately so that (a) the sameness reads as deliberate rather than as an
+ * oversight, and (b) a divergence later is a value change here and nothing
+ * else — no consumer passes these numbers, they only pass `variant`.
+ *
+ * `width` is the panel width used in BOTH hosts (380). It is NOT inherited
+ * from FormLayout's `page/small` density — that entry is 448, the app's
+ * sign-in card, a different surface. Only the padding (24) and the region gap
+ * (16) come from that density, and those already match. Inside a dialog the
+ * value goes on the Dialog panel and the layout fills at 100%: sizing a bare
+ * panel from its child hits the shrink-to-fit percentage circularity (the
+ * same reason FormDialog gives).
+ */
+export declare const PANEL_LAYOUT_CONFIG: {
+    /** Standalone on a page. */
+    readonly page: {
+        /** Panel width (px). */
+        readonly width: 380;
+        /** Illustration above the header copy (px). */
+        readonly illustrationSize: 52;
+        /** Footer action button size. */
+        readonly buttonSize: "medium";
+        /** Gap between footer action buttons (px); ActionBar reads it via var. */
+        readonly actionGap: 8;
+    };
+    /** Inside a dialog, wrapped by `BaseDialog` in a `Dialog(bare)`. */
+    readonly modal: {
+        readonly width: 380;
+        readonly illustrationSize: 52;
+        readonly buttonSize: "medium";
+        readonly actionGap: 8;
+    };
+};
+export type PanelLayoutVariant = keyof typeof PANEL_LAYOUT_CONFIG;
+export declare const resolvePanelLayoutConfig: (variant: PanelLayoutVariant) => {
+    /** Panel width (px). */
+    readonly width: 380;
+    /** Illustration above the header copy (px). */
+    readonly illustrationSize: 52;
+    /** Footer action button size. */
+    readonly buttonSize: "medium";
+    /** Gap between footer action buttons (px); ActionBar reads it via var. */
+    readonly actionGap: 8;
+} | {
+    readonly width: 380;
+    readonly illustrationSize: 52;
+    readonly buttonSize: "medium";
+    readonly actionGap: 8;
+};