@activecollab/components 2.0.372 → 2.0.373

package/dist/esm/components/StackedCard/resizePolicy.d.ts

@@ -0,0 +1,111 @@
+/**
+ * StackedCard resize policy — pure math.
+ *
+ * The card reports intent; the HOST applies a resize policy (spec §7). This
+ * module is that policy, packaged as pure functions so the SAME code path
+ * serves the pointer drag and the keyboard resize. Nothing here touches the
+ * DOM, React or the card's content: it takes a start size, a delta and a
+ * policy, and returns a clamped size. `useStackedCardResize` wires events to
+ * it; the card's intrinsic content minimum is measured by the host and passed
+ * in as `contentMin`, so this module knows nothing about heroes or footers.
+ *
+ * The policy has four parts:
+ *  - bounds        — optional min/max per axis; unset means unbounded.
+ *  - proportional  — lock the aspect ratio captured at the start of the gesture;
+ *                    the scale is clamped by the BINDING axis so the ratio never
+ *                    distorts at a bound.
+ *  - step          — optional grid snap; proportion wins over the grid.
+ *  - content min   — the effective min is max(policyMin, contentMin) per axis,
+ *                    so a card can never be crushed below what its content needs.
+ */
+export interface StackedCardSize {
+    w: number;
+    h: number;
+}
+/** The card's intrinsic minimum, measured from its real content. */
+export interface StackedCardContentMin {
+    w: number;
+    h: number;
+}
+export interface StackedCardResizePolicy {
+    minW?: number;
+    maxW?: number;
+    minH?: number;
+    maxH?: number;
+    /** Lock the aspect ratio for the whole gesture. */
+    proportional: boolean;
+    /** Grid snap increment in px; omitted / 0 means continuous. */
+    step?: number;
+}
+/** The size captured at the start of a gesture (pointer down or a key press). */
+export interface StackedCardResizeStart {
+    w: number;
+    h: number;
+    contentMin: StackedCardContentMin;
+}
+export interface StackedCardResizeDelta {
+    dx: number;
+    dy: number;
+}
+export interface StackedCardResizeBounds {
+    wMin: number;
+    wMax: number;
+    hMin: number;
+    hMax: number;
+}
+/**
+ * `width` locks the vertical axis: an auto-height card takes a width and lets
+ * its rows set the height, so the gesture's vertical component is ignored.
+ */
+export type StackedCardResizeAxis = "both" | "width";
+/** Which input drove a resize event. Hosts log undo entries per source. */
+export type StackedCardResizeSource = "pointer" | "keyboard";
+/** Keyboard resize nudges by the policy step, or this when no step is set. */
+export declare const DEFAULT_KEYBOARD_STEP = 8;
+/** Shift + arrow resizes by a larger increment (the familiar coarse nudge). */
+export declare const SHIFT_STEP_MULTIPLIER = 4;
+/** Keys the separator handles; everything else falls through to the browser. */
+export declare const RESIZE_KEYS: ReadonlyArray<string>;
+export declare const isResizeKey: (key: string) => boolean;
+export declare const clamp: (v: number, lo: number, hi?: number) => number;
+export declare const snap: (v: number, step?: number) => number;
+export declare const makeStart: (size: StackedCardSize, contentMin: StackedCardContentMin) => StackedCardResizeStart;
+/**
+ * The effective bounds a size is clamped to: the policy min floored by the
+ * content min, and the policy max (unbounded when unset). Independent of any
+ * live gesture, so a host can also use it for the aria value and Home/End.
+ */
+export declare const effectiveBounds: (policy: StackedCardResizePolicy, contentMin: StackedCardContentMin) => StackedCardResizeBounds;
+/**
+ * Apply a delta to the start size under the policy — the single path for both
+ * inputs.
+ *
+ * `constrain` is the transient Shift-to-constrain lock: a free-form policy
+ * behaves proportionally for that one gesture; a proportional policy is already
+ * locked and ignores it. `axis: "width"` drops the gesture's vertical component;
+ * the height then holds still in free-form mode, and still follows the ratio in
+ * proportional mode (that is what proportional means).
+ */
+export declare const applyResize: (start: StackedCardResizeStart, delta: StackedCardResizeDelta, policy: StackedCardResizePolicy, opts?: {
+    constrain?: boolean;
+    axis?: StackedCardResizeAxis;
+}) => StackedCardSize;
+/**
+ * Translate a resize key into the next size, reusing `applyResize` so the
+ * keyboard clamps exactly like the pointer. Arrows nudge by the step (Shift ×4);
+ * Home/End jump to the min/max of the allowed range, leaving any axis without
+ * that bound where it is. Returns null for a key the handle does not own, and
+ * for a vertical key on a width-only card.
+ */
+export declare const keyboardResize: (key: string, size: StackedCardSize, policy: StackedCardResizePolicy, contentMin: StackedCardContentMin, opts?: {
+    shiftKey?: boolean;
+    axis?: StackedCardResizeAxis;
+}) => StackedCardSize | null;
+/**
+ * The handle's `aria-valuenow`: the current size as a percent (0–100) of its
+ * allowed range. The corner resizes both axes, but the value must be a single
+ * number, so it reports the WIDTH axis — the one axis the fixed-box and the
+ * width-only cards share. Returns 0 when the range isn't finite (no max bound).
+ */
+export declare const measurePercent: (size: StackedCardSize, policy: StackedCardResizePolicy, contentMin: StackedCardContentMin) => number;
+//# sourceMappingURL=resizePolicy.d.ts.map

package/dist/esm/components/StackedCard/resizePolicy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resizePolicy.d.ts","sourceRoot":"","sources":["../../../../src/components/StackedCard/resizePolicy.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,MAAM,WAAW,eAAe;IAC9B,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX;AAED,oEAAoE;AACpE,MAAM,WAAW,qBAAqB;IACpC,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX;AAED,MAAM,WAAW,uBAAuB;IACtC,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,mDAAmD;IACnD,YAAY,EAAE,OAAO,CAAC;IACtB,+DAA+D;IAC/D,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED,iFAAiF;AACjF,MAAM,WAAW,sBAAsB;IACrC,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,UAAU,EAAE,qBAAqB,CAAC;CACnC;AAED,MAAM,WAAW,sBAAsB;IACrC,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;CACZ;AAED,MAAM,WAAW,uBAAuB;IACtC,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;CACd;AAED;;;GAGG;AACH,MAAM,MAAM,qBAAqB,GAAG,MAAM,GAAG,OAAO,CAAC;AAErD,2EAA2E;AAC3E,MAAM,MAAM,uBAAuB,GAAG,SAAS,GAAG,UAAU,CAAC;AAE7D,8EAA8E;AAC9E,eAAO,MAAM,qBAAqB,IAAI,CAAC;AAEvC,+EAA+E;AAC/E,eAAO,MAAM,qBAAqB,IAAI,CAAC;AAEvC,gFAAgF;AAChF,eAAO,MAAM,WAAW,EAAE,aAAa,CAAC,MAAM,CAO7C,CAAC;AAEF,eAAO,MAAM,WAAW,GAAI,KAAK,MAAM,KAAG,OAAoC,CAAC;AAE/E,eAAO,MAAM,KAAK,GAAI,GAAG,MAAM,EAAE,IAAI,MAAM,EAAE,KAAK,MAAM,KAAG,MACA,CAAC;AAE5D,eAAO,MAAM,IAAI,GAAI,GAAG,MAAM,EAAE,OAAO,MAAM,KAAG,MACI,CAAC;AAErD,eAAO,MAAM,SAAS,GACpB,MAAM,eAAe,EACrB,YAAY,qBAAqB,KAChC,sBAID,CAAC;AAEH;;;;GAIG;AACH,eAAO,MAAM,eAAe,GAC1B,QAAQ,uBAAuB,EAC/B,YAAY,qBAAqB,KAChC,uBAKD,CAAC;AAUH;;;;;;;;;GASG;AACH,eAAO,MAAM,WAAW,GACtB,OAAO,sBAAsB,EAC7B,OAAO,sBAAsB,EAC7B,QAAQ,uBAAuB,EAC/B,OAAM;IAAE,SAAS,CAAC,EAAE,OAAO,CAAC;IAAC,IAAI,CAAC,EAAE,qBAAqB,CAAA;CAAO,KAC/D,eAiDF,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,cAAc,GACzB,KAAK,MAAM,EACX,MAAM,eAAe,EACrB,QAAQ,uBAAuB,EAC/B,YAAY,qBAAqB,EACjC,OAAM;IAAE,QAAQ,CAAC,EAAE,OAAO,CAAC;IAAC,IAAI,CAAC,EAAE,qBAAqB,CAAA;CAAO,KAC9D,eAAe,GAAG,IAgDpB,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,cAAc,GACzB,MAAM,eAAe,EACrB,QAAQ,uBAAuB,EAC/B,YAAY,qBAAqB,KAChC,MAIF,CAAC"}

package/dist/esm/{presentation/stackedCard → components/StackedCard}/resizePolicy.js

@@ -1,28 +1,36 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
 /**
- * StackedCard resize policy — pure math (story-local, presentation-only).
+ * StackedCard resize policy — pure math.
  *
- * The card only reports deltas; the HOST applies a resize policy (note 52097
- * §7). This module is that policy, packaged as pure functions so the SAME code
- * path serves both the pointer drag and the keyboard resize (task 5/8). Nothing
- * here touches the DOM, React, or the content — it takes a start size, a delta,
- * and a policy, and returns a clamped size. The story wires events to it; the
- * card's intrinsic content minimum is measured story-side and passed in as
- * `contentMin`, so this module knows nothing about heroes or footers.
+ * The card reports intent; the HOST applies a resize policy (spec §7). This
+ * module is that policy, packaged as pure functions so the SAME code path
+ * serves the pointer drag and the keyboard resize. Nothing here touches the
+ * DOM, React or the card's content: it takes a start size, a delta and a
+ * policy, and returns a clamped size. `useStackedCardResize` wires events to
+ * it; the card's intrinsic content minimum is measured by the host and passed
+ * in as `contentMin`, so this module knows nothing about heroes or footers.
  *
- * The policy has four parts, all preserved from the concept:
+ * The policy has four parts:
  *  - bounds        — optional min/max per axis; unset means unbounded.
  *  - proportional  — lock the aspect ratio captured at the start of the gesture;
  *                    the scale is clamped by the BINDING axis so the ratio never
  *                    distorts at a bound.
  *  - step          — optional grid snap; proportion wins over the grid.
  *  - content min   — the effective min is max(policyMin, contentMin) per axis,
- *                    so the card can never be crushed below what its content needs.
+ *                    so a card can never be crushed below what its content needs.
  */
 
 /** The card's intrinsic minimum, measured from its real content. */
 
 /** The size captured at the start of a gesture (pointer down or a key press). */
 
+/**
+ * `width` locks the vertical axis: an auto-height card takes a width and lets
+ * its rows set the height, so the gesture's vertical component is ignored.
+ */
+
+/** Which input drove a resize event. Hosts log undo entries per source. */
+
 /** Keyboard resize nudges by the policy step, or this when no step is set. */
 export const DEFAULT_KEYBOARD_STEP = 8;
 
@@ -43,7 +51,7 @@ export const makeStart = (size, contentMin) => ({
 /**
  * The effective bounds a size is clamped to: the policy min floored by the
  * content min, and the policy max (unbounded when unset). Independent of any
- * live gesture, so the story can also use it for the aria value and Home/End.
+ * live gesture, so a host can also use it for the aria value and Home/End.
  */
 export const effectiveBounds = (policy, contentMin) => {
   var _policy$minW, _policy$minH, _policy$maxW, _policy$maxH;
@@ -55,11 +63,22 @@ export const effectiveBounds = (policy, contentMin) => {
   };
 };
 
+/**
+ * Whether an axis has a floor anyone asked for. `effectiveBounds` reports 0 for
+ * an unset minimum — correct as a clamp, but not something Home should jump to:
+ * an axis nobody gave a minimum must not collapse to nothing.
+ */
+const hasFloor = (policyMin, contentMin) => policyMin !== undefined || contentMin > 0;
+
 /**
  * Apply a delta to the start size under the policy — the single path for both
- * inputs. `constrain` is the transient Shift-to-constrain lock: a free-form
- * policy behaves proportionally for that one gesture; a proportional policy is
- * already locked and ignores it.
+ * inputs.
+ *
+ * `constrain` is the transient Shift-to-constrain lock: a free-form policy
+ * behaves proportionally for that one gesture; a proportional policy is already
+ * locked and ignores it. `axis: "width"` drops the gesture's vertical component;
+ * the height then holds still in free-form mode, and still follows the ratio in
+ * proportional mode (that is what proportional means).
  */
 export const applyResize = function (start, delta, policy, opts) {
   if (opts === void 0) {
@@ -70,34 +89,42 @@ export const applyResize = function (start, delta, policy, opts) {
     hMin = _effectiveBounds.hMin,
     wMax = _effectiveBounds.wMax,
     hMax = _effectiveBounds.hMax;
-  const proportional = policy.proportional || opts.constrain === true;
+  const widthOnly = opts.axis === "width";
+  const dx = delta.dx;
+  const dy = widthOnly ? 0 : delta.dy;
+
+  // A ratio needs two non-zero sides to be a ratio at all; a width-only card
+  // parks a placeholder height, so fall back to free-form rather than dividing
+  // by zero.
+  const proportional = (policy.proportional || opts.constrain === true) && start.w > 0 && start.h > 0;
   let w;
   let h;
   if (proportional) {
     // one scale drives both axes; the corner's dominant direction wins, so a
     // vertical drag is as effective as a horizontal one
-    const sW = (start.w + delta.dx) / start.w;
-    const sH = (start.h + delta.dy) / start.h;
+    const sW = (start.w + dx) / start.w;
+    const sH = (start.h + dy) / start.h;
     let scale = Math.abs(sW - 1) >= Math.abs(sH - 1) ? sW : sH;
 
-    // clamp the SCALE so both axes stay in bounds (binding constraint): the
-    // ratio can never break at a bound — whichever edge is limiting stops both
+    // step: proportion wins over the grid. Snap through the SCALE (driven off
+    // the width edge) so both axes move together and the ratio survives; the
+    // grid yields whenever honouring it would cost the ratio.
+    if (policy.step) {
+      scale = snap(start.w * scale, policy.step) / start.w;
+    }
+
+    // Then clamp the scale so both axes stay in bounds (the binding constraint):
+    // the ratio can never break at a bound — whichever edge is limiting stops
+    // both. The clamp comes last on purpose: a bound is a hard stop, so the card
+    // sits exactly on it rather than at the nearest grid line inside it.
     const scaleMin = Math.max(wMin / start.w, hMin / start.h);
     const scaleMax = Math.min(wMax / start.w, hMax / start.h);
     scale = clamp(scale, scaleMin, Math.max(scaleMin, scaleMax));
-
-    // step: proportion wins. Snap via the scale (driven off the width edge) and
-    // re-clamp, so ratio and bounds always hold; the grid yields when honoring
-    // it would cost the ratio
-    if (policy.step) {
-      const snappedScale = snap(start.w * scale, policy.step) / start.w;
-      scale = clamp(snappedScale, scaleMin, Math.max(scaleMin, scaleMax));
-    }
     w = start.w * scale;
     h = start.h * scale;
   } else {
-    w = clamp(snap(start.w + delta.dx, policy.step), wMin, wMax);
-    h = clamp(snap(start.h + delta.dy, policy.step), hMin, hMax);
+    w = clamp(snap(start.w + dx, policy.step), wMin, wMax);
+    h = widthOnly ? start.h : clamp(snap(start.h + dy, policy.step), hMin, hMax);
   }
   return {
     w: Math.round(w),
@@ -108,50 +135,68 @@ export const applyResize = function (start, delta, policy, opts) {
 /**
  * Translate a resize key into the next size, reusing `applyResize` so the
  * keyboard clamps exactly like the pointer. Arrows nudge by the step (Shift ×4);
- * Home/End jump to the min/max of the allowed range. Returns null for any key
- * the handle does not own.
+ * Home/End jump to the min/max of the allowed range, leaving any axis without
+ * that bound where it is. Returns null for a key the handle does not own, and
+ * for a vertical key on a width-only card.
  */
 export const keyboardResize = function (key, size, policy, contentMin, opts) {
   if (opts === void 0) {
     opts = {};
   }
+  const widthOnly = opts.axis === "width";
+  if (widthOnly && (key === "ArrowUp" || key === "ArrowDown")) return null;
   const base = policy.step && policy.step > 0 ? policy.step : DEFAULT_KEYBOARD_STEP;
   const step = base * (opts.shiftKey ? SHIFT_STEP_MULTIPLIER : 1);
   const start = makeStart(size, contentMin);
   const b = effectiveBounds(policy, contentMin);
+  const apply = delta => applyResize(start, delta, policy, {
+    axis: opts.axis
+  });
+
+  /**
+   * Home and End are absolute jumps to a bound, not nudges, so they ignore the
+   * grid: landing 4px off the minimum because that is where the nearest grid
+   * line fell would mean the keyboard could never reach the bound the pointer
+   * stops at.
+   */
+  const jump = delta => applyResize(start, delta, _extends({}, policy, {
+    step: 0
+  }), {
+    axis: opts.axis
+  });
   switch (key) {
     case "ArrowRight":
-      return applyResize(start, {
+      return apply({
         dx: step,
         dy: 0
-      }, policy);
+      });
     case "ArrowLeft":
-      return applyResize(start, {
+      return apply({
         dx: -step,
         dy: 0
-      }, policy);
+      });
     case "ArrowDown":
-      return applyResize(start, {
+      return apply({
         dx: 0,
         dy: step
-      }, policy);
+      });
     case "ArrowUp":
-      return applyResize(start, {
+      return apply({
         dx: 0,
         dy: -step
-      }, policy);
+      });
     case "Home":
-      // jump to the min corner (a huge negative delta clamps to the floor)
-      return applyResize(start, {
-        dx: b.wMin - size.w,
-        dy: b.hMin - size.h
-      }, policy);
+      // jump to the min corner; an axis with no floor of its own stays put
+      return jump({
+        dx: hasFloor(policy.minW, contentMin.w) ? b.wMin - size.w : 0,
+        dy: !widthOnly && hasFloor(policy.minH, contentMin.h) ? b.hMin - size.h : 0
+      });
     case "End":
       // jump to the max corner; an unbounded axis simply doesn't move
-      return applyResize(start, {
+      return jump({
         dx: Number.isFinite(b.wMax) ? b.wMax - size.w : 0,
-        dy: Number.isFinite(b.hMax) ? b.hMax - size.h : 0
-      }, policy);
+        dy: !widthOnly && Number.isFinite(b.hMax) ? b.hMax - size.h : 0
+      });
     default:
       return null;
   }
@@ -160,7 +205,7 @@ export const keyboardResize = function (key, size, policy, contentMin, opts) {
 /**
  * The handle's `aria-valuenow`: the current size as a percent (0–100) of its
  * allowed range. The corner resizes both axes, but the value must be a single
- * number, so it reports the WIDTH axis — the one axis both the fixed-box and the
+ * number, so it reports the WIDTH axis — the one axis the fixed-box and the
  * width-only cards share. Returns 0 when the range isn't finite (no max bound).
  */
 export const measurePercent = (size, policy, contentMin) => {

package/dist/esm/components/StackedCard/resizePolicy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"resizePolicy.js","names":["DEFAULT_KEYBOARD_STEP","SHIFT_STEP_MULTIPLIER","RESIZE_KEYS","isResizeKey","key","includes","clamp","v","lo","hi","Math","min","Number","POSITIVE_INFINITY","max","snap","step","round","makeStart","size","contentMin","w","h","effectiveBounds","policy","_policy$minW","_policy$minH","_policy$maxW","_policy$maxH","wMin","minW","hMin","minH","wMax","maxW","hMax","maxH","hasFloor","policyMin","undefined","applyResize","start","delta","opts","_effectiveBounds","widthOnly","axis","dx","dy","proportional","constrain","sW","sH","scale","abs","scaleMin","scaleMax","keyboardResize","base","shiftKey","b","apply","jump","_extends","isFinite","measurePercent","_effectiveBounds2"],"sources":["../../../../src/components/StackedCard/resizePolicy.ts"],"sourcesContent":["/**\n * StackedCard resize policy — pure math.\n *\n * The card reports intent; the HOST applies a resize policy (spec §7). This\n * module is that policy, packaged as pure functions so the SAME code path\n * serves the pointer drag and the keyboard resize. Nothing here touches the\n * DOM, React or the card's content: it takes a start size, a delta and a\n * policy, and returns a clamped size. `useStackedCardResize` wires events to\n * it; the card's intrinsic content minimum is measured by the host and passed\n * in as `contentMin`, so this module knows nothing about heroes or footers.\n *\n * The policy has four parts:\n *  - bounds        — optional min/max per axis; unset means unbounded.\n *  - proportional  — lock the aspect ratio captured at the start of the gesture;\n *                    the scale is clamped by the BINDING axis so the ratio never\n *                    distorts at a bound.\n *  - step          — optional grid snap; proportion wins over the grid.\n *  - content min   — the effective min is max(policyMin, contentMin) per axis,\n *                    so a card can never be crushed below what its content needs.\n */\n\nexport interface StackedCardSize {\n  w: number;\n  h: number;\n}\n\n/** The card's intrinsic minimum, measured from its real content. */\nexport interface StackedCardContentMin {\n  w: number;\n  h: number;\n}\n\nexport interface StackedCardResizePolicy {\n  minW?: number;\n  maxW?: number;\n  minH?: number;\n  maxH?: number;\n  /** Lock the aspect ratio for the whole gesture. */\n  proportional: boolean;\n  /** Grid snap increment in px; omitted / 0 means continuous. */\n  step?: number;\n}\n\n/** The size captured at the start of a gesture (pointer down or a key press). */\nexport interface StackedCardResizeStart {\n  w: number;\n  h: number;\n  contentMin: StackedCardContentMin;\n}\n\nexport interface StackedCardResizeDelta {\n  dx: number;\n  dy: number;\n}\n\nexport interface StackedCardResizeBounds {\n  wMin: number;\n  wMax: number;\n  hMin: number;\n  hMax: number;\n}\n\n/**\n * `width` locks the vertical axis: an auto-height card takes a width and lets\n * its rows set the height, so the gesture's vertical component is ignored.\n */\nexport type StackedCardResizeAxis = \"both\" | \"width\";\n\n/** Which input drove a resize event. Hosts log undo entries per source. */\nexport type StackedCardResizeSource = \"pointer\" | \"keyboard\";\n\n/** Keyboard resize nudges by the policy step, or this when no step is set. */\nexport const DEFAULT_KEYBOARD_STEP = 8;\n\n/** Shift + arrow resizes by a larger increment (the familiar coarse nudge). */\nexport const SHIFT_STEP_MULTIPLIER = 4;\n\n/** Keys the separator handles; everything else falls through to the browser. */\nexport const RESIZE_KEYS: ReadonlyArray<string> = [\n  \"ArrowLeft\",\n  \"ArrowRight\",\n  \"ArrowUp\",\n  \"ArrowDown\",\n  \"Home\",\n  \"End\",\n];\n\nexport const isResizeKey = (key: string): boolean => RESIZE_KEYS.includes(key);\n\nexport const clamp = (v: number, lo: number, hi?: number): number =>\n  Math.min(hi ?? Number.POSITIVE_INFINITY, Math.max(lo, v));\n\nexport const snap = (v: number, step?: number): number =>\n  step && step > 0 ? Math.round(v / step) * step : v;\n\nexport const makeStart = (\n  size: StackedCardSize,\n  contentMin: StackedCardContentMin\n): StackedCardResizeStart => ({\n  w: size.w,\n  h: size.h,\n  contentMin,\n});\n\n/**\n * The effective bounds a size is clamped to: the policy min floored by the\n * content min, and the policy max (unbounded when unset). Independent of any\n * live gesture, so a host can also use it for the aria value and Home/End.\n */\nexport const effectiveBounds = (\n  policy: StackedCardResizePolicy,\n  contentMin: StackedCardContentMin\n): StackedCardResizeBounds => ({\n  wMin: Math.max(policy.minW ?? 0, contentMin.w),\n  hMin: Math.max(policy.minH ?? 0, contentMin.h),\n  wMax: policy.maxW ?? Number.POSITIVE_INFINITY,\n  hMax: policy.maxH ?? Number.POSITIVE_INFINITY,\n});\n\n/**\n * Whether an axis has a floor anyone asked for. `effectiveBounds` reports 0 for\n * an unset minimum — correct as a clamp, but not something Home should jump to:\n * an axis nobody gave a minimum must not collapse to nothing.\n */\nconst hasFloor = (policyMin: number | undefined, contentMin: number): boolean =>\n  policyMin !== undefined || contentMin > 0;\n\n/**\n * Apply a delta to the start size under the policy — the single path for both\n * inputs.\n *\n * `constrain` is the transient Shift-to-constrain lock: a free-form policy\n * behaves proportionally for that one gesture; a proportional policy is already\n * locked and ignores it. `axis: \"width\"` drops the gesture's vertical component;\n * the height then holds still in free-form mode, and still follows the ratio in\n * proportional mode (that is what proportional means).\n */\nexport const applyResize = (\n  start: StackedCardResizeStart,\n  delta: StackedCardResizeDelta,\n  policy: StackedCardResizePolicy,\n  opts: { constrain?: boolean; axis?: StackedCardResizeAxis } = {}\n): StackedCardSize => {\n  const { wMin, hMin, wMax, hMax } = effectiveBounds(policy, start.contentMin);\n  const widthOnly = opts.axis === \"width\";\n  const dx = delta.dx;\n  const dy = widthOnly ? 0 : delta.dy;\n\n  // A ratio needs two non-zero sides to be a ratio at all; a width-only card\n  // parks a placeholder height, so fall back to free-form rather than dividing\n  // by zero.\n  const proportional =\n    (policy.proportional || opts.constrain === true) &&\n    start.w > 0 &&\n    start.h > 0;\n\n  let w: number;\n  let h: number;\n\n  if (proportional) {\n    // one scale drives both axes; the corner's dominant direction wins, so a\n    // vertical drag is as effective as a horizontal one\n    const sW = (start.w + dx) / start.w;\n    const sH = (start.h + dy) / start.h;\n    let scale = Math.abs(sW - 1) >= Math.abs(sH - 1) ? sW : sH;\n\n    // step: proportion wins over the grid. Snap through the SCALE (driven off\n    // the width edge) so both axes move together and the ratio survives; the\n    // grid yields whenever honouring it would cost the ratio.\n    if (policy.step) {\n      scale = snap(start.w * scale, policy.step) / start.w;\n    }\n\n    // Then clamp the scale so both axes stay in bounds (the binding constraint):\n    // the ratio can never break at a bound — whichever edge is limiting stops\n    // both. The clamp comes last on purpose: a bound is a hard stop, so the card\n    // sits exactly on it rather than at the nearest grid line inside it.\n    const scaleMin = Math.max(wMin / start.w, hMin / start.h);\n    const scaleMax = Math.min(wMax / start.w, hMax / start.h);\n    scale = clamp(scale, scaleMin, Math.max(scaleMin, scaleMax));\n\n    w = start.w * scale;\n    h = start.h * scale;\n  } else {\n    w = clamp(snap(start.w + dx, policy.step), wMin, wMax);\n    h = widthOnly\n      ? start.h\n      : clamp(snap(start.h + dy, policy.step), hMin, hMax);\n  }\n\n  return { w: Math.round(w), h: Math.round(h) };\n};\n\n/**\n * Translate a resize key into the next size, reusing `applyResize` so the\n * keyboard clamps exactly like the pointer. Arrows nudge by the step (Shift ×4);\n * Home/End jump to the min/max of the allowed range, leaving any axis without\n * that bound where it is. Returns null for a key the handle does not own, and\n * for a vertical key on a width-only card.\n */\nexport const keyboardResize = (\n  key: string,\n  size: StackedCardSize,\n  policy: StackedCardResizePolicy,\n  contentMin: StackedCardContentMin,\n  opts: { shiftKey?: boolean; axis?: StackedCardResizeAxis } = {}\n): StackedCardSize | null => {\n  const widthOnly = opts.axis === \"width\";\n  if (widthOnly && (key === \"ArrowUp\" || key === \"ArrowDown\")) return null;\n\n  const base =\n    policy.step && policy.step > 0 ? policy.step : DEFAULT_KEYBOARD_STEP;\n  const step = base * (opts.shiftKey ? SHIFT_STEP_MULTIPLIER : 1);\n  const start = makeStart(size, contentMin);\n  const b = effectiveBounds(policy, contentMin);\n  const apply = (delta: StackedCardResizeDelta): StackedCardSize =>\n    applyResize(start, delta, policy, { axis: opts.axis });\n\n  /**\n   * Home and End are absolute jumps to a bound, not nudges, so they ignore the\n   * grid: landing 4px off the minimum because that is where the nearest grid\n   * line fell would mean the keyboard could never reach the bound the pointer\n   * stops at.\n   */\n  const jump = (delta: StackedCardResizeDelta): StackedCardSize =>\n    applyResize(start, delta, { ...policy, step: 0 }, { axis: opts.axis });\n\n  switch (key) {\n    case \"ArrowRight\":\n      return apply({ dx: step, dy: 0 });\n    case \"ArrowLeft\":\n      return apply({ dx: -step, dy: 0 });\n    case \"ArrowDown\":\n      return apply({ dx: 0, dy: step });\n    case \"ArrowUp\":\n      return apply({ dx: 0, dy: -step });\n    case \"Home\":\n      // jump to the min corner; an axis with no floor of its own stays put\n      return jump({\n        dx: hasFloor(policy.minW, contentMin.w) ? b.wMin - size.w : 0,\n        dy:\n          !widthOnly && hasFloor(policy.minH, contentMin.h)\n            ? b.hMin - size.h\n            : 0,\n      });\n    case \"End\":\n      // jump to the max corner; an unbounded axis simply doesn't move\n      return jump({\n        dx: Number.isFinite(b.wMax) ? b.wMax - size.w : 0,\n        dy: !widthOnly && Number.isFinite(b.hMax) ? b.hMax - size.h : 0,\n      });\n    default:\n      return null;\n  }\n};\n\n/**\n * The handle's `aria-valuenow`: the current size as a percent (0–100) of its\n * allowed range. The corner resizes both axes, but the value must be a single\n * number, so it reports the WIDTH axis — the one axis the fixed-box and the\n * width-only cards share. Returns 0 when the range isn't finite (no max bound).\n */\nexport const measurePercent = (\n  size: StackedCardSize,\n  policy: StackedCardResizePolicy,\n  contentMin: StackedCardContentMin\n): number => {\n  const { wMin, wMax } = effectiveBounds(policy, contentMin);\n  if (!Number.isFinite(wMax) || wMax <= wMin) return 0;\n  return Math.round(clamp(((size.w - wMin) / (wMax - wMin)) * 100, 0, 100));\n};\n"],"mappings":"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","ignoreList":[]}

package/dist/esm/components/StackedCard/resizePolicy.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=resizePolicy.test.d.ts.map

package/dist/esm/components/StackedCard/resizePolicy.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resizePolicy.test.d.ts","sourceRoot":"","sources":["../../../../src/components/StackedCard/resizePolicy.test.ts"],"names":[],"mappings":""}