@activecollab/components 2.0.371 → 2.0.373

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@activecollab/components",
-  "version": "2.0.371",
+  "version": "2.0.373",
   "description": "ActiveCollab Components",
   "main": "dist/cjs/index.js",
   "module": "dist/esm/index.js",

package/dist/cjs/presentation/stackedCard/resizePolicy.js

@@ -1,183 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.snap = exports.measurePercent = exports.makeStart = exports.keyboardResize = exports.isResizeKey = exports.effectiveBounds = exports.clamp = exports.applyResize = exports.SHIFT_STEP_MULTIPLIER = exports.RESIZE_KEYS = exports.DEFAULT_KEYBOARD_STEP = void 0;
-/**
- * StackedCard resize policy — pure math (story-local, presentation-only).
- *
- * 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 policy has four parts, all preserved from the concept:
- *  - 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.
- */
-
-/** 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). */
-
-/** Keyboard resize nudges by the policy step, or this when no step is set. */
-var DEFAULT_KEYBOARD_STEP = exports.DEFAULT_KEYBOARD_STEP = 8;
-
-/** Shift + arrow resizes by a larger increment (the familiar coarse nudge). */
-var SHIFT_STEP_MULTIPLIER = exports.SHIFT_STEP_MULTIPLIER = 4;
-
-/** Keys the separator handles; everything else falls through to the browser. */
-var RESIZE_KEYS = exports.RESIZE_KEYS = ["ArrowLeft", "ArrowRight", "ArrowUp", "ArrowDown", "Home", "End"];
-var isResizeKey = exports.isResizeKey = function isResizeKey(key) {
-  return RESIZE_KEYS.includes(key);
-};
-var clamp = exports.clamp = function clamp(v, lo, hi) {
-  return Math.min(hi !== null && hi !== void 0 ? hi : Number.POSITIVE_INFINITY, Math.max(lo, v));
-};
-var snap = exports.snap = function snap(v, step) {
-  return step && step > 0 ? Math.round(v / step) * step : v;
-};
-var makeStart = exports.makeStart = function makeStart(size, contentMin) {
-  return {
-    w: size.w,
-    h: size.h,
-    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.
- */
-var effectiveBounds = exports.effectiveBounds = function effectiveBounds(policy, contentMin) {
-  var _policy$minW, _policy$minH, _policy$maxW, _policy$maxH;
-  return {
-    wMin: Math.max((_policy$minW = policy.minW) !== null && _policy$minW !== void 0 ? _policy$minW : 0, contentMin.w),
-    hMin: Math.max((_policy$minH = policy.minH) !== null && _policy$minH !== void 0 ? _policy$minH : 0, contentMin.h),
-    wMax: (_policy$maxW = policy.maxW) !== null && _policy$maxW !== void 0 ? _policy$maxW : Number.POSITIVE_INFINITY,
-    hMax: (_policy$maxH = policy.maxH) !== null && _policy$maxH !== void 0 ? _policy$maxH : Number.POSITIVE_INFINITY
-  };
-};
-
-/**
- * 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.
- */
-var applyResize = exports.applyResize = function applyResize(start, delta, policy) {
-  var opts = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};
-  var _effectiveBounds = effectiveBounds(policy, start.contentMin),
-    wMin = _effectiveBounds.wMin,
-    hMin = _effectiveBounds.hMin,
-    wMax = _effectiveBounds.wMax,
-    hMax = _effectiveBounds.hMax;
-  var proportional = policy.proportional || opts.constrain === true;
-  var w;
-  var 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
-    var sW = (start.w + delta.dx) / start.w;
-    var sH = (start.h + delta.dy) / start.h;
-    var 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
-    var scaleMin = Math.max(wMin / start.w, hMin / start.h);
-    var 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) {
-      var 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);
-  }
-  return {
-    w: Math.round(w),
-    h: Math.round(h)
-  };
-};
-
-/**
- * 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.
- */
-var keyboardResize = exports.keyboardResize = function keyboardResize(key, size, policy, contentMin) {
-  var opts = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : {};
-  var base = policy.step && policy.step > 0 ? policy.step : DEFAULT_KEYBOARD_STEP;
-  var step = base * (opts.shiftKey ? SHIFT_STEP_MULTIPLIER : 1);
-  var start = makeStart(size, contentMin);
-  var b = effectiveBounds(policy, contentMin);
-  switch (key) {
-    case "ArrowRight":
-      return applyResize(start, {
-        dx: step,
-        dy: 0
-      }, policy);
-    case "ArrowLeft":
-      return applyResize(start, {
-        dx: -step,
-        dy: 0
-      }, policy);
-    case "ArrowDown":
-      return applyResize(start, {
-        dx: 0,
-        dy: step
-      }, policy);
-    case "ArrowUp":
-      return applyResize(start, {
-        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);
-    case "End":
-      // jump to the max corner; an unbounded axis simply doesn't move
-      return applyResize(start, {
-        dx: Number.isFinite(b.wMax) ? b.wMax - size.w : 0,
-        dy: Number.isFinite(b.hMax) ? b.hMax - size.h : 0
-      }, policy);
-    default:
-      return 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 both the fixed-box and the
- * width-only cards share. Returns 0 when the range isn't finite (no max bound).
- */
-var measurePercent = exports.measurePercent = function measurePercent(size, policy, contentMin) {
-  var _effectiveBounds2 = effectiveBounds(policy, contentMin),
-    wMin = _effectiveBounds2.wMin,
-    wMax = _effectiveBounds2.wMax;
-  if (!Number.isFinite(wMax) || wMax <= wMin) return 0;
-  return Math.round(clamp((size.w - wMin) / (wMax - wMin) * 100, 0, 100));
-};
-//# sourceMappingURL=resizePolicy.js.map

package/dist/cjs/presentation/stackedCard/resizePolicy.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"resizePolicy.js","names":["DEFAULT_KEYBOARD_STEP","exports","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","applyResize","start","delta","opts","arguments","length","undefined","_effectiveBounds","proportional","constrain","sW","dx","sH","dy","scale","abs","scaleMin","scaleMax","snappedScale","keyboardResize","base","shiftKey","b","isFinite","measurePercent","_effectiveBounds2"],"sources":["../../../../src/presentation/stackedCard/resizePolicy.ts"],"sourcesContent":["/**\n * StackedCard resize policy — pure math (story-local, presentation-only).\n *\n * The card only reports deltas; the HOST applies a resize policy (note 52097\n * §7). This module is that policy, packaged as pure functions so the SAME code\n * path serves both the pointer drag and the keyboard resize (task 5/8). Nothing\n * here touches the DOM, React, or the content — it takes a start size, a delta,\n * and a policy, and returns a clamped size. The story wires events to it; the\n * card's intrinsic content minimum is measured story-side and passed in as\n * `contentMin`, so this module knows nothing about heroes or footers.\n *\n * The policy has four parts, all preserved from the concept:\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 the card can never be crushed below what its content needs.\n */\n\nexport interface Size {\n  w: number;\n  h: number;\n}\n\n/** The card's intrinsic minimum, measured from its real content. */\nexport interface ContentMin {\n  w: number;\n  h: number;\n}\n\nexport interface Policy {\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 ResizeStart {\n  w: number;\n  h: number;\n  contentMin: ContentMin;\n}\n\nexport interface ResizeDelta {\n  dx: number;\n  dy: number;\n}\n\nexport interface EffectiveBounds {\n  wMin: number;\n  wMax: number;\n  hMin: number;\n  hMax: number;\n}\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 = (size: Size, contentMin: ContentMin): ResizeStart => ({\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 the story can also use it for the aria value and Home/End.\n */\nexport const effectiveBounds = (\n  policy: Policy,\n  contentMin: ContentMin\n): EffectiveBounds => ({\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 * Apply a delta to the start size under the policy — the single path for both\n * inputs. `constrain` is the transient Shift-to-constrain lock: a free-form\n * policy behaves proportionally for that one gesture; a proportional policy is\n * already locked and ignores it.\n */\nexport const applyResize = (\n  start: ResizeStart,\n  delta: ResizeDelta,\n  policy: Policy,\n  opts: { constrain?: boolean } = {}\n): Size => {\n  const { wMin, hMin, wMax, hMax } = effectiveBounds(policy, start.contentMin);\n  const proportional = policy.proportional || opts.constrain === true;\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 + delta.dx) / start.w;\n    const sH = (start.h + delta.dy) / start.h;\n    let scale = Math.abs(sW - 1) >= Math.abs(sH - 1) ? sW : sH;\n\n    // clamp the SCALE so both axes stay in bounds (binding constraint): the\n    // ratio can never break at a bound — whichever edge is limiting stops both\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    // step: proportion wins. Snap via the scale (driven off the width edge) and\n    // re-clamp, so ratio and bounds always hold; the grid yields when honoring\n    // it would cost the ratio\n    if (policy.step) {\n      const snappedScale = snap(start.w * scale, policy.step) / start.w;\n      scale = clamp(snappedScale, scaleMin, Math.max(scaleMin, scaleMax));\n    }\n\n    w = start.w * scale;\n    h = start.h * scale;\n  } else {\n    w = clamp(snap(start.w + delta.dx, policy.step), wMin, wMax);\n    h = clamp(snap(start.h + delta.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. Returns null for any key\n * the handle does not own.\n */\nexport const keyboardResize = (\n  key: string,\n  size: Size,\n  policy: Policy,\n  contentMin: ContentMin,\n  opts: { shiftKey?: boolean } = {}\n): Size | null => {\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\n  switch (key) {\n    case \"ArrowRight\":\n      return applyResize(start, { dx: step, dy: 0 }, policy);\n    case \"ArrowLeft\":\n      return applyResize(start, { dx: -step, dy: 0 }, policy);\n    case \"ArrowDown\":\n      return applyResize(start, { dx: 0, dy: step }, policy);\n    case \"ArrowUp\":\n      return applyResize(start, { dx: 0, dy: -step }, policy);\n    case \"Home\":\n      // jump to the min corner (a huge negative delta clamps to the floor)\n      return applyResize(\n        start,\n        { dx: b.wMin - size.w, dy: b.hMin - size.h },\n        policy\n      );\n    case \"End\":\n      // jump to the max corner; an unbounded axis simply doesn't move\n      return applyResize(\n        start,\n        {\n          dx: Number.isFinite(b.wMax) ? b.wMax - size.w : 0,\n          dy: Number.isFinite(b.hMax) ? b.hMax - size.h : 0,\n        },\n        policy\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 both 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: Size,\n  policy: Policy,\n  contentMin: ContentMin\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/presentation/stackedCard/resizePolicy.d.ts

@@ -1,97 +0,0 @@
-/**
- * StackedCard resize policy — pure math (story-local, presentation-only).
- *
- * 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 policy has four parts, all preserved from the concept:
- *  - 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.
- */
-export interface Size {
-    w: number;
-    h: number;
-}
-/** The card's intrinsic minimum, measured from its real content. */
-export interface ContentMin {
-    w: number;
-    h: number;
-}
-export interface Policy {
-    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 ResizeStart {
-    w: number;
-    h: number;
-    contentMin: ContentMin;
-}
-export interface ResizeDelta {
-    dx: number;
-    dy: number;
-}
-export interface EffectiveBounds {
-    wMin: number;
-    wMax: number;
-    hMin: number;
-    hMax: number;
-}
-/** 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: Size, contentMin: ContentMin) => ResizeStart;
-/**
- * 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.
- */
-export declare const effectiveBounds: (policy: Policy, contentMin: ContentMin) => EffectiveBounds;
-/**
- * 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.
- */
-export declare const applyResize: (start: ResizeStart, delta: ResizeDelta, policy: Policy, opts?: {
-    constrain?: boolean;
-}) => Size;
-/**
- * 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.
- */
-export declare const keyboardResize: (key: string, size: Size, policy: Policy, contentMin: ContentMin, opts?: {
-    shiftKey?: boolean;
-}) => Size | 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 both 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: Size, policy: Policy, contentMin: ContentMin) => number;
-//# sourceMappingURL=resizePolicy.d.ts.map

package/dist/esm/presentation/stackedCard/resizePolicy.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"resizePolicy.d.ts","sourceRoot":"","sources":["../../../../src/presentation/stackedCard/resizePolicy.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,MAAM,WAAW,IAAI;IACnB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX;AAED,oEAAoE;AACpE,MAAM,WAAW,UAAU;IACzB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX;AAED,MAAM,WAAW,MAAM;IACrB,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,WAAW;IAC1B,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,UAAU,EAAE,UAAU,CAAC;CACxB;AAED,MAAM,WAAW,WAAW;IAC1B,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;CACZ;AAED,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;CACd;AAED,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,GAAI,MAAM,IAAI,EAAE,YAAY,UAAU,KAAG,WAI7D,CAAC;AAEH;;;;GAIG;AACH,eAAO,MAAM,eAAe,GAC1B,QAAQ,MAAM,EACd,YAAY,UAAU,KACrB,eAKD,CAAC;AAEH;;;;;GAKG;AACH,eAAO,MAAM,WAAW,GACtB,OAAO,WAAW,EAClB,OAAO,WAAW,EAClB,QAAQ,MAAM,EACd,OAAM;IAAE,SAAS,CAAC,EAAE,OAAO,CAAA;CAAO,KACjC,IAoCF,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,cAAc,GACzB,KAAK,MAAM,EACX,MAAM,IAAI,EACV,QAAQ,MAAM,EACd,YAAY,UAAU,EACtB,OAAM;IAAE,QAAQ,CAAC,EAAE,OAAO,CAAA;CAAO,KAChC,IAAI,GAAG,IAoCT,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,cAAc,GACzB,MAAM,IAAI,EACV,QAAQ,MAAM,EACd,YAAY,UAAU,KACrB,MAIF,CAAC"}

package/dist/esm/presentation/stackedCard/resizePolicy.js.map

@@ -1 +0,0 @@
-{"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","applyResize","start","delta","opts","_effectiveBounds","proportional","constrain","sW","dx","sH","dy","scale","abs","scaleMin","scaleMax","snappedScale","keyboardResize","base","shiftKey","b","isFinite","measurePercent","_effectiveBounds2"],"sources":["../../../../src/presentation/stackedCard/resizePolicy.ts"],"sourcesContent":["/**\n * StackedCard resize policy — pure math (story-local, presentation-only).\n *\n * The card only reports deltas; the HOST applies a resize policy (note 52097\n * §7). This module is that policy, packaged as pure functions so the SAME code\n * path serves both the pointer drag and the keyboard resize (task 5/8). Nothing\n * here touches the DOM, React, or the content — it takes a start size, a delta,\n * and a policy, and returns a clamped size. The story wires events to it; the\n * card's intrinsic content minimum is measured story-side and passed in as\n * `contentMin`, so this module knows nothing about heroes or footers.\n *\n * The policy has four parts, all preserved from the concept:\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 the card can never be crushed below what its content needs.\n */\n\nexport interface Size {\n  w: number;\n  h: number;\n}\n\n/** The card's intrinsic minimum, measured from its real content. */\nexport interface ContentMin {\n  w: number;\n  h: number;\n}\n\nexport interface Policy {\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 ResizeStart {\n  w: number;\n  h: number;\n  contentMin: ContentMin;\n}\n\nexport interface ResizeDelta {\n  dx: number;\n  dy: number;\n}\n\nexport interface EffectiveBounds {\n  wMin: number;\n  wMax: number;\n  hMin: number;\n  hMax: number;\n}\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 = (size: Size, contentMin: ContentMin): ResizeStart => ({\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 the story can also use it for the aria value and Home/End.\n */\nexport const effectiveBounds = (\n  policy: Policy,\n  contentMin: ContentMin\n): EffectiveBounds => ({\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 * Apply a delta to the start size under the policy — the single path for both\n * inputs. `constrain` is the transient Shift-to-constrain lock: a free-form\n * policy behaves proportionally for that one gesture; a proportional policy is\n * already locked and ignores it.\n */\nexport const applyResize = (\n  start: ResizeStart,\n  delta: ResizeDelta,\n  policy: Policy,\n  opts: { constrain?: boolean } = {}\n): Size => {\n  const { wMin, hMin, wMax, hMax } = effectiveBounds(policy, start.contentMin);\n  const proportional = policy.proportional || opts.constrain === true;\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 + delta.dx) / start.w;\n    const sH = (start.h + delta.dy) / start.h;\n    let scale = Math.abs(sW - 1) >= Math.abs(sH - 1) ? sW : sH;\n\n    // clamp the SCALE so both axes stay in bounds (binding constraint): the\n    // ratio can never break at a bound — whichever edge is limiting stops both\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    // step: proportion wins. Snap via the scale (driven off the width edge) and\n    // re-clamp, so ratio and bounds always hold; the grid yields when honoring\n    // it would cost the ratio\n    if (policy.step) {\n      const snappedScale = snap(start.w * scale, policy.step) / start.w;\n      scale = clamp(snappedScale, scaleMin, Math.max(scaleMin, scaleMax));\n    }\n\n    w = start.w * scale;\n    h = start.h * scale;\n  } else {\n    w = clamp(snap(start.w + delta.dx, policy.step), wMin, wMax);\n    h = clamp(snap(start.h + delta.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. Returns null for any key\n * the handle does not own.\n */\nexport const keyboardResize = (\n  key: string,\n  size: Size,\n  policy: Policy,\n  contentMin: ContentMin,\n  opts: { shiftKey?: boolean } = {}\n): Size | null => {\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\n  switch (key) {\n    case \"ArrowRight\":\n      return applyResize(start, { dx: step, dy: 0 }, policy);\n    case \"ArrowLeft\":\n      return applyResize(start, { dx: -step, dy: 0 }, policy);\n    case \"ArrowDown\":\n      return applyResize(start, { dx: 0, dy: step }, policy);\n    case \"ArrowUp\":\n      return applyResize(start, { dx: 0, dy: -step }, policy);\n    case \"Home\":\n      // jump to the min corner (a huge negative delta clamps to the floor)\n      return applyResize(\n        start,\n        { dx: b.wMin - size.w, dy: b.hMin - size.h },\n        policy\n      );\n    case \"End\":\n      // jump to the max corner; an unbounded axis simply doesn't move\n      return applyResize(\n        start,\n        {\n          dx: Number.isFinite(b.wMax) ? b.wMax - size.w : 0,\n          dy: Number.isFinite(b.hMax) ? b.hMax - size.h : 0,\n        },\n        policy\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 both 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: Size,\n  policy: Policy,\n  contentMin: ContentMin\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":[]}