@mindlogic-ai/logician-ui 4.0.0-alpha.9 → 5.0.0-alpha.0

package/dist/utils/cubicBezier.mjs

@@ -0,0 +1,65 @@
+"use client";
+import { MOTION_EASE } from '../theme/motion.mjs';
+
+/**
+ * Turns one of the house curves into a function of progress, for motion that
+ * JavaScript has to drive frame by frame.
+ *
+ * Most motion never needs this: CSS reads `--chakra-easings-*` and
+ * framer-motion takes the `MOTION_EASE` tuples directly. What is left is the
+ * handful of things neither can animate — a *number* counting up, a canvas, a
+ * scroll position — where the value is interpolated in JS and the curve has to
+ * be evaluated rather than declared.
+ *
+ * Without this, that code reaches for `easeOutCubic` off the internet, and the
+ * count-up next to a card ends up on a different curve from the card. The point
+ * of a scale is that the exceptions stay on it.
+ *
+ * **Shared rather than local, even though `CountUp` is its only caller in this
+ * library.** The rule that sends a one-caller motion down next to its component
+ * (`spin` → `Spinner.styles.ts`) is about compositions the library owns; this is
+ * a reader of the scale, and its real audience is app code driving motion the
+ * library never sees — a framer-motion `animate`, an `Element.animate`, a rAF
+ * loop. Filing it under `CountUp/` would mean reaching into a component folder
+ * for a curve, which is the wrong shape for the thing it is.
+ *
+ * ```ts
+ * const ease = cubicBezier('emphasized');
+ * const value = from + (to - from) * ease(elapsed / duration);
+ * ```
+ */
+const cubicBezier = (curve) => {
+    const [x1, y1, x2, y2] = typeof curve === 'string' ? MOTION_EASE[curve] : curve;
+    // The classic 1-D cubic Bézier basis with P0 = 0 and P3 = 1, so only the two
+    // control coordinates vary. Written as the Horner form the browsers use.
+    const a = (c1, c2) => 1 - 3 * c2 + 3 * c1;
+    const b = (c1, c2) => 3 * c2 - 6 * c1;
+    const c = (c1) => 3 * c1;
+    const at = (t, c1, c2) => ((a(c1, c2) * t + b(c1, c2)) * t + c(c1)) * t;
+    const slope = (t, c1, c2) => 3 * a(c1, c2) * t * t + 2 * b(c1, c2) * t + c(c1);
+    return (progress) => {
+        // Clamp rather than extrapolate: a caller that overshoots its own clock by
+        // a frame should land on the end value, not past it.
+        const t = progress <= 0 ? 0 : progress >= 1 ? 1 : progress;
+        // `t` is time along the curve's *x* axis, which is not the same as the
+        // parameter — solve for the parameter, then read `y`. Newton-Raphson from
+        // `t` itself converges in three or four steps for every curve here; the
+        // guard is for the flat-slope case, where the derivative gives no direction.
+        let u = t;
+        for (let i = 0; i < 6; i += 1) {
+            const dx = slope(u, x1, x2);
+            if (Math.abs(dx) < 1e-6)
+                break;
+            const error = at(u, x1, x2) - t;
+            if (Math.abs(error) < 1e-6)
+                break;
+            u -= error / dx;
+        }
+        // `overshoot` deliberately leaves [0, 1] in the middle — that is the whole
+        // point of it — so this is not clamped.
+        return at(u, y1, y2);
+    };
+};
+
+export { cubicBezier };
+//# sourceMappingURL=cubicBezier.mjs.map

package/dist/utils/cubicBezier.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"cubicBezier.mjs","sources":["../../src/utils/cubicBezier.ts"],"sourcesContent":[null],"names":[],"mappings":";;;AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;AA0BG;AACI,MAAM,WAAW,GAAG,CACzB,KAAkE,KACvC;IAC3B,MAAM,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,GACpB,OAAO,KAAK,KAAK,QAAQ,GAAG,WAAW,CAAC,KAAK,CAAC,GAAG,KAAK;;;AAIxD,IAAA,MAAM,CAAC,GAAG,CAAC,EAAU,EAAE,EAAU,KAAK,CAAC,GAAG,CAAC,GAAG,EAAE,GAAG,CAAC,GAAG,EAAE;AACzD,IAAA,MAAM,CAAC,GAAG,CAAC,EAAU,EAAE,EAAU,KAAK,CAAC,GAAG,EAAE,GAAG,CAAC,GAAG,EAAE;IACrD,MAAM,CAAC,GAAG,CAAC,EAAU,KAAK,CAAC,GAAG,EAAE;AAEhC,IAAA,MAAM,EAAE,GAAG,CAAC,CAAS,EAAE,EAAU,EAAE,EAAU,KAC3C,CAAC,CAAC,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC;AAC/C,IAAA,MAAM,KAAK,GAAG,CAAC,CAAS,EAAE,EAAU,EAAE,EAAU,KAC9C,CAAC,GAAG,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC;IAEnD,OAAO,CAAC,QAAgB,KAAI;;;QAG1B,MAAM,CAAC,GAAG,QAAQ,IAAI,CAAC,GAAG,CAAC,GAAG,QAAQ,IAAI,CAAC,GAAG,CAAC,GAAG,QAAQ;;;;;QAM1D,IAAI,CAAC,GAAG,CAAC;AACT,QAAA,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC,IAAI,CAAC,EAAE;YAC7B,MAAM,EAAE,GAAG,KAAK,CAAC,CAAC,EAAE,EAAE,EAAE,EAAE,CAAC;AAC3B,YAAA,IAAI,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI;gBAAE;AACzB,YAAA,MAAM,KAAK,GAAG,EAAE,CAAC,CAAC,EAAE,EAAE,EAAE,EAAE,CAAC,GAAG,CAAC;AAC/B,YAAA,IAAI,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,GAAG,IAAI;gBAAE;AAC5B,YAAA,CAAC,IAAI,KAAK,GAAG,EAAE;QACjB;;;QAIA,OAAO,EAAE,CAAC,CAAC,EAAE,EAAE,EAAE,EAAE,CAAC;AACtB,IAAA,CAAC;AACH;;;;"}

package/dist/utils/disabledControl.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Disabled look for filled controls (Button, IconButton, Tag, …).
+ *
+ * Fixed `disabled.bg` / `disabled.fg` colours instead of `opacity: 0.5`: a
+ * half-transparent control takes on whatever is behind it, so the same
+ * disabled button read differently on every layer (and a disabled primary
+ * still looked "primary"). WCAG exempts disabled controls from contrast, so
+ * these are not in the contrast audit. No hover/press change while disabled.
+ *
+ * Spread under `_disabled`. Ghost-style controls that have no fill use
+ * `disabledText` instead so they do not suddenly grow a grey box.
+ */
+export declare const disabledControl: {
+    readonly bg: "disabled.bg";
+    readonly color: "disabled.fg";
+    readonly borderColor: "transparent";
+    readonly opacity: 1;
+    readonly boxShadow: "none";
+};
+export declare const disabledText: {
+    readonly bg: "transparent";
+    readonly color: "disabled.fg";
+    readonly borderColor: "transparent";
+    readonly opacity: 1;
+    readonly boxShadow: "none";
+};
+//# sourceMappingURL=disabledControl.d.ts.map

package/dist/utils/disabledControl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"disabledControl.d.ts","sourceRoot":"","sources":["../../src/utils/disabledControl.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,eAAe;;;;;;CAMlB,CAAC;AAEX,eAAO,MAAM,YAAY;;;;;;CAMf,CAAC"}

package/dist/utils/disabledControl.js

@@ -0,0 +1,33 @@
+"use client";
+'use strict';
+
+/**
+ * Disabled look for filled controls (Button, IconButton, Tag, …).
+ *
+ * Fixed `disabled.bg` / `disabled.fg` colours instead of `opacity: 0.5`: a
+ * half-transparent control takes on whatever is behind it, so the same
+ * disabled button read differently on every layer (and a disabled primary
+ * still looked "primary"). WCAG exempts disabled controls from contrast, so
+ * these are not in the contrast audit. No hover/press change while disabled.
+ *
+ * Spread under `_disabled`. Ghost-style controls that have no fill use
+ * `disabledText` instead so they do not suddenly grow a grey box.
+ */
+const disabledControl = {
+    bg: 'disabled.bg',
+    color: 'disabled.fg',
+    borderColor: 'transparent',
+    opacity: 1,
+    boxShadow: 'none',
+};
+const disabledText = {
+    bg: 'transparent',
+    color: 'disabled.fg',
+    borderColor: 'transparent',
+    opacity: 1,
+    boxShadow: 'none',
+};
+
+exports.disabledControl = disabledControl;
+exports.disabledText = disabledText;
+//# sourceMappingURL=disabledControl.js.map

package/dist/utils/disabledControl.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"disabledControl.js","sources":["../../src/utils/disabledControl.ts"],"sourcesContent":[null],"names":[],"mappings":";;;AAAA;;;;;;;;;;;AAWG;AACI,MAAM,eAAe,GAAG;AAC7B,IAAA,EAAE,EAAE,aAAa;AACjB,IAAA,KAAK,EAAE,aAAa;AACpB,IAAA,WAAW,EAAE,aAAa;AAC1B,IAAA,OAAO,EAAE,CAAC;AACV,IAAA,SAAS,EAAE,MAAM;;AAGZ,MAAM,YAAY,GAAG;AAC1B,IAAA,EAAE,EAAE,aAAa;AACjB,IAAA,KAAK,EAAE,aAAa;AACpB,IAAA,WAAW,EAAE,aAAa;AAC1B,IAAA,OAAO,EAAE,CAAC;AACV,IAAA,SAAS,EAAE,MAAM;;;;;;"}

package/dist/utils/disabledControl.mjs

@@ -0,0 +1,30 @@
+"use client";
+/**
+ * Disabled look for filled controls (Button, IconButton, Tag, …).
+ *
+ * Fixed `disabled.bg` / `disabled.fg` colours instead of `opacity: 0.5`: a
+ * half-transparent control takes on whatever is behind it, so the same
+ * disabled button read differently on every layer (and a disabled primary
+ * still looked "primary"). WCAG exempts disabled controls from contrast, so
+ * these are not in the contrast audit. No hover/press change while disabled.
+ *
+ * Spread under `_disabled`. Ghost-style controls that have no fill use
+ * `disabledText` instead so they do not suddenly grow a grey box.
+ */
+const disabledControl = {
+    bg: 'disabled.bg',
+    color: 'disabled.fg',
+    borderColor: 'transparent',
+    opacity: 1,
+    boxShadow: 'none',
+};
+const disabledText = {
+    bg: 'transparent',
+    color: 'disabled.fg',
+    borderColor: 'transparent',
+    opacity: 1,
+    boxShadow: 'none',
+};
+
+export { disabledControl, disabledText };
+//# sourceMappingURL=disabledControl.mjs.map

package/dist/utils/disabledControl.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"disabledControl.mjs","sources":["../../src/utils/disabledControl.ts"],"sourcesContent":[null],"names":[],"mappings":";AAAA;;;;;;;;;;;AAWG;AACI,MAAM,eAAe,GAAG;AAC7B,IAAA,EAAE,EAAE,aAAa;AACjB,IAAA,KAAK,EAAE,aAAa;AACpB,IAAA,WAAW,EAAE,aAAa;AAC1B,IAAA,OAAO,EAAE,CAAC;AACV,IAAA,SAAS,EAAE,MAAM;;AAGZ,MAAM,YAAY,GAAG;AAC1B,IAAA,EAAE,EAAE,aAAa;AACjB,IAAA,KAAK,EAAE,aAAa;AACpB,IAAA,WAAW,EAAE,aAAa;AAC1B,IAAA,OAAO,EAAE,CAAC;AACV,IAAA,SAAS,EAAE,MAAM;;;;;"}

package/dist/utils/focusRing.d.ts

@@ -2,20 +2,27 @@
  * Standard focus ring styles for interactive components.
  *
  * - _focus: suppresses the browser's default outline on all focus events (including mouse)
- * - _focusVisible: shows the ring only on keyboard focus (CSS :focus-visible),
- *   with a 0.15s ease-out transition on box-shadow
+ * - _focusVisible: shows the ring only on keyboard focus (CSS :focus-visible)
+ *
+ * Two rings: an inner 2px band in `bg.canvas` that separates the ring from the
+ * control (so a black ring on a black button still reads), and an outer 2px in
+ * `focus.ring`. The inner band used to be a hardcoded `rgb(255,255,255)`,
+ * which drew a white halo in dark mode; it now follows the canvas token.
+ *
+ * No transition, on purpose. The ring answers a key press, and keyboard
+ * actions should land instantly — Tab is pressed hundreds of times a day. It
+ * also used to be a `transition` *shorthand* under `:focus-visible`, which
+ * replaced the element's whole transition list while focused, so a
+ * keyboard-focused Switch or Checkbox snapped its fill instead of fading it.
  */
+export declare const FOCUS_RING_SHADOW = "var(--chakra-colors-bg-canvas) 0px 0px 0px 2px, var(--chakra-colors-focus-ring) 0px 0px 0px 4px";
 export declare const focusRing: {
     readonly _focus: {
         readonly outline: "none";
     };
     readonly _focusVisible: {
         readonly outline: "none";
-        readonly boxShadow: "rgb(255, 255, 255) 0px 0px 0px 2px, var(--chakra-colors-primary-main) 0px 0px 0px 4px";
-        readonly transition: "box-shadow 0.15s ease-out";
-        readonly _motionReduce: {
-            readonly transition: "none";
-        };
+        readonly boxShadow: "var(--chakra-colors-bg-canvas) 0px 0px 0px 2px, var(--chakra-colors-focus-ring) 0px 0px 0px 4px";
     };
 };
 //# sourceMappingURL=focusRing.d.ts.map

package/dist/utils/focusRing.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"focusRing.d.ts","sourceRoot":"","sources":["../../src/utils/focusRing.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,eAAO,MAAM,SAAS;;;;;;;;;;;;CASZ,CAAC"}
+{"version":3,"file":"focusRing.d.ts","sourceRoot":"","sources":["../../src/utils/focusRing.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,iBAAiB,oGACqE,CAAC;AAEpG,eAAO,MAAM,SAAS;;;;;;;;CAMZ,CAAC"}

package/dist/utils/focusRing.js

@@ -5,18 +5,28 @@
  * Standard focus ring styles for interactive components.
  *
  * - _focus: suppresses the browser's default outline on all focus events (including mouse)
- * - _focusVisible: shows the ring only on keyboard focus (CSS :focus-visible),
- *   with a 0.15s ease-out transition on box-shadow
+ * - _focusVisible: shows the ring only on keyboard focus (CSS :focus-visible)
+ *
+ * Two rings: an inner 2px band in `bg.canvas` that separates the ring from the
+ * control (so a black ring on a black button still reads), and an outer 2px in
+ * `focus.ring`. The inner band used to be a hardcoded `rgb(255,255,255)`,
+ * which drew a white halo in dark mode; it now follows the canvas token.
+ *
+ * No transition, on purpose. The ring answers a key press, and keyboard
+ * actions should land instantly — Tab is pressed hundreds of times a day. It
+ * also used to be a `transition` *shorthand* under `:focus-visible`, which
+ * replaced the element's whole transition list while focused, so a
+ * keyboard-focused Switch or Checkbox snapped its fill instead of fading it.
  */
+const FOCUS_RING_SHADOW = 'var(--chakra-colors-bg-canvas) 0px 0px 0px 2px, var(--chakra-colors-focus-ring) 0px 0px 0px 4px';
 const focusRing = {
     _focus: { outline: 'none' },
     _focusVisible: {
         outline: 'none',
-        boxShadow: 'rgb(255, 255, 255) 0px 0px 0px 2px, var(--chakra-colors-primary-main) 0px 0px 0px 4px',
-        transition: 'box-shadow 0.15s ease-out',
-        _motionReduce: { transition: 'none' },
+        boxShadow: FOCUS_RING_SHADOW,
     },
 };
 
+exports.FOCUS_RING_SHADOW = FOCUS_RING_SHADOW;
 exports.focusRing = focusRing;
 //# sourceMappingURL=focusRing.js.map

package/dist/utils/focusRing.js.map

@@ -1 +1 @@
-{"version":3,"file":"focusRing.js","sources":["../../src/utils/focusRing.ts"],"sourcesContent":[null],"names":[],"mappings":";;;AAAA;;;;;;AAMG;AACI,MAAM,SAAS,GAAG;AACvB,IAAA,MAAM,EAAE,EAAE,OAAO,EAAE,MAAM,EAAE;AAC3B,IAAA,aAAa,EAAE;AACb,QAAA,OAAO,EAAE,MAAM;AACf,QAAA,SAAS,EACP,uFAAuF;AACzF,QAAA,UAAU,EAAE,2BAA2B;AACvC,QAAA,aAAa,EAAE,EAAE,UAAU,EAAE,MAAM,EAAE;AACtC,KAAA;;;;;"}
+{"version":3,"file":"focusRing.js","sources":["../../src/utils/focusRing.ts"],"sourcesContent":[null],"names":[],"mappings":";;;AAAA;;;;;;;;;;;;;;;;AAgBG;AACI,MAAM,iBAAiB,GAC5B;AAEK,MAAM,SAAS,GAAG;AACvB,IAAA,MAAM,EAAE,EAAE,OAAO,EAAE,MAAM,EAAE;AAC3B,IAAA,aAAa,EAAE;AACb,QAAA,OAAO,EAAE,MAAM;AACf,QAAA,SAAS,EAAE,iBAAiB;AAC7B,KAAA;;;;;;"}

package/dist/utils/focusRing.mjs

@@ -3,18 +3,27 @@
  * Standard focus ring styles for interactive components.
  *
  * - _focus: suppresses the browser's default outline on all focus events (including mouse)
- * - _focusVisible: shows the ring only on keyboard focus (CSS :focus-visible),
- *   with a 0.15s ease-out transition on box-shadow
+ * - _focusVisible: shows the ring only on keyboard focus (CSS :focus-visible)
+ *
+ * Two rings: an inner 2px band in `bg.canvas` that separates the ring from the
+ * control (so a black ring on a black button still reads), and an outer 2px in
+ * `focus.ring`. The inner band used to be a hardcoded `rgb(255,255,255)`,
+ * which drew a white halo in dark mode; it now follows the canvas token.
+ *
+ * No transition, on purpose. The ring answers a key press, and keyboard
+ * actions should land instantly — Tab is pressed hundreds of times a day. It
+ * also used to be a `transition` *shorthand* under `:focus-visible`, which
+ * replaced the element's whole transition list while focused, so a
+ * keyboard-focused Switch or Checkbox snapped its fill instead of fading it.
  */
+const FOCUS_RING_SHADOW = 'var(--chakra-colors-bg-canvas) 0px 0px 0px 2px, var(--chakra-colors-focus-ring) 0px 0px 0px 4px';
 const focusRing = {
     _focus: { outline: 'none' },
     _focusVisible: {
         outline: 'none',
-        boxShadow: 'rgb(255, 255, 255) 0px 0px 0px 2px, var(--chakra-colors-primary-main) 0px 0px 0px 4px',
-        transition: 'box-shadow 0.15s ease-out',
-        _motionReduce: { transition: 'none' },
+        boxShadow: FOCUS_RING_SHADOW,
     },
 };
 
-export { focusRing };
+export { FOCUS_RING_SHADOW, focusRing };
 //# sourceMappingURL=focusRing.mjs.map

package/dist/utils/focusRing.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"focusRing.mjs","sources":["../../src/utils/focusRing.ts"],"sourcesContent":[null],"names":[],"mappings":";AAAA;;;;;;AAMG;AACI,MAAM,SAAS,GAAG;AACvB,IAAA,MAAM,EAAE,EAAE,OAAO,EAAE,MAAM,EAAE;AAC3B,IAAA,aAAa,EAAE;AACb,QAAA,OAAO,EAAE,MAAM;AACf,QAAA,SAAS,EACP,uFAAuF;AACzF,QAAA,UAAU,EAAE,2BAA2B;AACvC,QAAA,aAAa,EAAE,EAAE,UAAU,EAAE,MAAM,EAAE;AACtC,KAAA;;;;;"}
+{"version":3,"file":"focusRing.mjs","sources":["../../src/utils/focusRing.ts"],"sourcesContent":[null],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;AAgBG;AACI,MAAM,iBAAiB,GAC5B;AAEK,MAAM,SAAS,GAAG;AACvB,IAAA,MAAM,EAAE,EAAE,OAAO,EAAE,MAAM,EAAE;AAC3B,IAAA,aAAa,EAAE;AACb,QAAA,OAAO,EAAE,MAAM;AACf,QAAA,SAAS,EAAE,iBAAiB;AAC7B,KAAA;;;;;"}

package/dist/utils/isDev.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Whether the library is running in a development build, for dev-only
+ * warnings (deprecated props, 4.x mappings).
+ *
+ * Written as the bare `process.env.NODE_ENV` expression on purpose: that exact
+ * text is what bundlers replace at build time (Vite `define`, webpack
+ * `DefinePlugin`, esbuild, Next.js), so a production build folds this to
+ * `false` and the warning code around it is dropped. Two "safer" spellings
+ * break that and must not come back:
+ *
+ * - `typeof process !== 'undefined' && …` — under Vite there is no `process`
+ *   global at runtime, so the guard is false and the warning never fires in
+ *   development either.
+ * - `process.env?.NODE_ENV` — optional chaining is a different expression, so
+ *   `DefinePlugin` no longer matches it.
+ *
+ * The `try` only covers a raw, unbundled browser (no bundler, no `process`):
+ * there the reference throws, and we report "not dev" instead of crashing.
+ * It does not stop the bundler from replacing the expression inside it.
+ */
+export declare const isDev: () => boolean;
+//# sourceMappingURL=isDev.d.ts.map

package/dist/utils/isDev.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"isDev.d.ts","sourceRoot":"","sources":["../../src/utils/isDev.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,KAAK,QAAO,OAMxB,CAAC"}

package/dist/utils/isDev.js

@@ -0,0 +1,34 @@
+"use client";
+'use strict';
+
+/**
+ * Whether the library is running in a development build, for dev-only
+ * warnings (deprecated props, 4.x mappings).
+ *
+ * Written as the bare `process.env.NODE_ENV` expression on purpose: that exact
+ * text is what bundlers replace at build time (Vite `define`, webpack
+ * `DefinePlugin`, esbuild, Next.js), so a production build folds this to
+ * `false` and the warning code around it is dropped. Two "safer" spellings
+ * break that and must not come back:
+ *
+ * - `typeof process !== 'undefined' && …` — under Vite there is no `process`
+ *   global at runtime, so the guard is false and the warning never fires in
+ *   development either.
+ * - `process.env?.NODE_ENV` — optional chaining is a different expression, so
+ *   `DefinePlugin` no longer matches it.
+ *
+ * The `try` only covers a raw, unbundled browser (no bundler, no `process`):
+ * there the reference throws, and we report "not dev" instead of crashing.
+ * It does not stop the bundler from replacing the expression inside it.
+ */
+const isDev = () => {
+    try {
+        return process.env.NODE_ENV !== 'production';
+    }
+    catch {
+        return false;
+    }
+};
+
+exports.isDev = isDev;
+//# sourceMappingURL=isDev.js.map

package/dist/utils/isDev.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"isDev.js","sources":["../../src/utils/isDev.ts"],"sourcesContent":[null],"names":[],"mappings":";;;AAAA;;;;;;;;;;;;;;;;;;;AAmBG;AACI,MAAM,KAAK,GAAG,MAAc;AACjC,IAAA,IAAI;AACF,QAAA,OAAO,OAAO,CAAC,GAAG,CAAC,QAAQ,KAAK,YAAY;IAC9C;AAAE,IAAA,MAAM;AACN,QAAA,OAAO,KAAK;IACd;AACF;;;;"}

package/dist/utils/isDev.mjs

@@ -0,0 +1,32 @@
+"use client";
+/**
+ * Whether the library is running in a development build, for dev-only
+ * warnings (deprecated props, 4.x mappings).
+ *
+ * Written as the bare `process.env.NODE_ENV` expression on purpose: that exact
+ * text is what bundlers replace at build time (Vite `define`, webpack
+ * `DefinePlugin`, esbuild, Next.js), so a production build folds this to
+ * `false` and the warning code around it is dropped. Two "safer" spellings
+ * break that and must not come back:
+ *
+ * - `typeof process !== 'undefined' && …` — under Vite there is no `process`
+ *   global at runtime, so the guard is false and the warning never fires in
+ *   development either.
+ * - `process.env?.NODE_ENV` — optional chaining is a different expression, so
+ *   `DefinePlugin` no longer matches it.
+ *
+ * The `try` only covers a raw, unbundled browser (no bundler, no `process`):
+ * there the reference throws, and we report "not dev" instead of crashing.
+ * It does not stop the bundler from replacing the expression inside it.
+ */
+const isDev = () => {
+    try {
+        return process.env.NODE_ENV !== 'production';
+    }
+    catch {
+        return false;
+    }
+};
+
+export { isDev };
+//# sourceMappingURL=isDev.mjs.map

package/dist/utils/isDev.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"isDev.mjs","sources":["../../src/utils/isDev.ts"],"sourcesContent":[null],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;;AAmBG;AACI,MAAM,KAAK,GAAG,MAAc;AACjC,IAAA,IAAI;AACF,QAAA,OAAO,OAAO,CAAC,GAAG,CAAC,QAAQ,KAAK,YAAY;IAC9C;AAAE,IAAA,MAAM;AACN,QAAA,OAAO,KAAK;IACd;AACF;;;;"}

package/dist/utils/mergeCss.js

@@ -1,11 +1,11 @@
 "use client";
 'use strict';
 
-var lodash = require('lodash');
+var merge = require('lodash/merge');
 
 const mergeCss = (...styles) => styles.reduce((acc, style) => {
     if (style && typeof style === 'object') {
-        lodash.merge(acc, style);
+        merge(acc, style);
     }
     return acc;
 }, {});

package/dist/utils/mergeCss.js.map

@@ -1 +1 @@
-{"version":3,"file":"mergeCss.js","sources":["../../src/utils/mergeCss.ts"],"sourcesContent":[null],"names":["merge"],"mappings":";;;;;AAGO,MAAM,QAAQ,GAAG,CACtB,GAAG,MAAwD,KAE3D,MAAM,CAAC,MAAM,CAAoB,CAAC,GAAG,EAAE,KAAK,KAAI;AAC9C,IAAA,IAAI,KAAK,IAAI,OAAO,KAAK,KAAK,QAAQ,EAAE;AACtC,QAAAA,YAAK,CAAC,GAAG,EAAE,KAAK,CAAC;IACnB;AACA,IAAA,OAAO,GAAG;AACZ,CAAC,EAAE,EAAuB;;;;"}
+{"version":3,"file":"mergeCss.js","sources":["../../src/utils/mergeCss.ts"],"sourcesContent":[null],"names":[],"mappings":";;;;;AAGO,MAAM,QAAQ,GAAG,CACtB,GAAG,MAAwD,KAE3D,MAAM,CAAC,MAAM,CAAoB,CAAC,GAAG,EAAE,KAAK,KAAI;AAC9C,IAAA,IAAI,KAAK,IAAI,OAAO,KAAK,KAAK,QAAQ,EAAE;AACtC,QAAA,KAAK,CAAC,GAAG,EAAE,KAAK,CAAC;IACnB;AACA,IAAA,OAAO,GAAG;AACZ,CAAC,EAAE,EAAuB;;;;"}

package/dist/utils/mergeCss.mjs

@@ -1,5 +1,5 @@
 "use client";
-import { merge } from 'lodash';
+import merge from 'lodash/merge';
 
 const mergeCss = (...styles) => styles.reduce((acc, style) => {
     if (style && typeof style === 'object') {

package/dist/utils/staggerProps.d.ts

@@ -0,0 +1,52 @@
+/** What `staggerProps` hands back — spreadable onto any Chakra element. */
+export interface StaggerProps {
+    animationStyle: 'stagger';
+    style: Record<string, string | number>;
+}
+/**
+ * Makes one list item arrive `index` beats after the first.
+ *
+ * ```tsx
+ * {options.map((option, i) => (
+ *   <Select.Item key={option.value} item={option} {...staggerProps(i)}>
+ * ))}
+ * ```
+ *
+ * A function rather than a `<Stagger>` wrapper. A wrapper has to render
+ * something to hold the index, and an extra node inside a `Menu.Content` or a
+ * `Select.Content` is not free: Ark walks those children to build its typeahead
+ * and roving-focus collections, and a grid or flex list would gain a layout box
+ * between the container and every row. This adds no DOM at all, and it composes
+ * with a list that is already being mapped rather than asking for the list to be
+ * restructured around it.
+ *
+ * The index rides an inline custom property rather than the `css` prop on
+ * purpose: `css` would compile one class per index and grow the stylesheet with
+ * the length of the longest list ever rendered, while the *only* thing that
+ * varies per item is this one number. Everything else — the keyframe, the
+ * duration, the curve, the cap — lives in the `stagger` preset, which is one
+ * class shared by every item on the page.
+ *
+ * Where **not** to use it, and why the list is short: stagger costs the reader
+ * time in exchange for rhythm, so it is worth it only where the list is short,
+ * arrives once, and is looked at as a whole. `Masonry` and `Table` are the
+ * explicit exclusions — both are long, both are candidates for virtualization
+ * (where "index" means position in a window that scrolls, so items would
+ * re-stagger as they scroll into view), and a sortable table re-orders its rows
+ * on click, which would deal the whole grid out again on every header press.
+ *
+ * @param index - The item's position in its list, from 0.
+ * @returns Props to spread onto the item. Merge `style` by hand if the call
+ *   site already sets one.
+ */
+export declare const staggerProps: (index: number) => StaggerProps;
+/**
+ * The delay `staggerProps(index)` resolves to, in milliseconds.
+ *
+ * Exists for the two callers that cannot read a CSS variable — a test asserting
+ * the cap holds, and JS animation tech sequencing alongside a staggered list.
+ * It has to mirror the `calc()` in the `stagger` preset exactly, which is why
+ * both read the same two constants.
+ */
+export declare const staggerDelayMs: (index: number) => number;
+//# sourceMappingURL=staggerProps.d.ts.map

package/dist/utils/staggerProps.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"staggerProps.d.ts","sourceRoot":"","sources":["../../src/utils/staggerProps.ts"],"names":[],"mappings":"AAEA,2EAA2E;AAC3E,MAAM,WAAW,YAAY;IAC3B,cAAc,EAAE,SAAS,CAAC;IAC1B,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAAC,CAAC;CACxC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,eAAO,MAAM,YAAY,GAAI,OAAO,MAAM,KAAG,YAM3C,CAAC;AAEH;;;;;;;GAOG;AACH,eAAO,MAAM,cAAc,GAAI,OAAO,MAAM,KAAG,MAEf,CAAC"}

package/dist/utils/staggerProps.js

@@ -0,0 +1,62 @@
+"use client";
+'use strict';
+
+var motion = require('../theme/motion.js');
+
+/**
+ * Makes one list item arrive `index` beats after the first.
+ *
+ * ```tsx
+ * {options.map((option, i) => (
+ *   <Select.Item key={option.value} item={option} {...staggerProps(i)}>
+ * ))}
+ * ```
+ *
+ * A function rather than a `<Stagger>` wrapper. A wrapper has to render
+ * something to hold the index, and an extra node inside a `Menu.Content` or a
+ * `Select.Content` is not free: Ark walks those children to build its typeahead
+ * and roving-focus collections, and a grid or flex list would gain a layout box
+ * between the container and every row. This adds no DOM at all, and it composes
+ * with a list that is already being mapped rather than asking for the list to be
+ * restructured around it.
+ *
+ * The index rides an inline custom property rather than the `css` prop on
+ * purpose: `css` would compile one class per index and grow the stylesheet with
+ * the length of the longest list ever rendered, while the *only* thing that
+ * varies per item is this one number. Everything else — the keyframe, the
+ * duration, the curve, the cap — lives in the `stagger` preset, which is one
+ * class shared by every item on the page.
+ *
+ * Where **not** to use it, and why the list is short: stagger costs the reader
+ * time in exchange for rhythm, so it is worth it only where the list is short,
+ * arrives once, and is looked at as a whole. `Masonry` and `Table` are the
+ * explicit exclusions — both are long, both are candidates for virtualization
+ * (where "index" means position in a window that scrolls, so items would
+ * re-stagger as they scroll into view), and a sortable table re-orders its rows
+ * on click, which would deal the whole grid out again on every header press.
+ *
+ * @param index - The item's position in its list, from 0.
+ * @returns Props to spread onto the item. Merge `style` by hand if the call
+ *   site already sets one.
+ */
+const staggerProps = (index) => ({
+    animationStyle: 'stagger',
+    // Not clamped here even though the preset's `min()` makes it redundant in
+    // CSS: an out-of-range value passed straight through is what makes a wrong
+    // index visible in the DOM instead of silently flattened.
+    style: { '--stagger-index': index },
+});
+/**
+ * The delay `staggerProps(index)` resolves to, in milliseconds.
+ *
+ * Exists for the two callers that cannot read a CSS variable — a test asserting
+ * the cap holds, and JS animation tech sequencing alongside a staggered list.
+ * It has to mirror the `calc()` in the `stagger` preset exactly, which is why
+ * both read the same two constants.
+ */
+const staggerDelayMs = (index) => Math.min(Math.max(index, 0), motion.MOTION_STAGGER_MAX) *
+    motion.MOTION_DURATION_MS.staggerStep;
+
+exports.staggerDelayMs = staggerDelayMs;
+exports.staggerProps = staggerProps;
+//# sourceMappingURL=staggerProps.js.map

package/dist/utils/staggerProps.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"staggerProps.js","sources":["../../src/utils/staggerProps.ts"],"sourcesContent":[null],"names":["MOTION_STAGGER_MAX","MOTION_DURATION_MS"],"mappings":";;;;;AAQA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAmCG;MACU,YAAY,GAAG,CAAC,KAAa,MAAoB;AAC5D,IAAA,cAAc,EAAE,SAAS;;;;AAIzB,IAAA,KAAK,EAAE,EAAE,iBAAiB,EAAE,KAAK,EAAE;AACpC,CAAA;AAED;;;;;;;AAOG;MACU,cAAc,GAAG,CAAC,KAAa,KAC1C,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,GAAG,CAAC,KAAK,EAAE,CAAC,CAAC,EAAEA,yBAAkB,CAAC;IAChDC,yBAAkB,CAAC;;;;;"}

package/dist/utils/staggerProps.mjs

@@ -0,0 +1,59 @@
+"use client";
+import { MOTION_STAGGER_MAX, MOTION_DURATION_MS } from '../theme/motion.mjs';
+
+/**
+ * Makes one list item arrive `index` beats after the first.
+ *
+ * ```tsx
+ * {options.map((option, i) => (
+ *   <Select.Item key={option.value} item={option} {...staggerProps(i)}>
+ * ))}
+ * ```
+ *
+ * A function rather than a `<Stagger>` wrapper. A wrapper has to render
+ * something to hold the index, and an extra node inside a `Menu.Content` or a
+ * `Select.Content` is not free: Ark walks those children to build its typeahead
+ * and roving-focus collections, and a grid or flex list would gain a layout box
+ * between the container and every row. This adds no DOM at all, and it composes
+ * with a list that is already being mapped rather than asking for the list to be
+ * restructured around it.
+ *
+ * The index rides an inline custom property rather than the `css` prop on
+ * purpose: `css` would compile one class per index and grow the stylesheet with
+ * the length of the longest list ever rendered, while the *only* thing that
+ * varies per item is this one number. Everything else — the keyframe, the
+ * duration, the curve, the cap — lives in the `stagger` preset, which is one
+ * class shared by every item on the page.
+ *
+ * Where **not** to use it, and why the list is short: stagger costs the reader
+ * time in exchange for rhythm, so it is worth it only where the list is short,
+ * arrives once, and is looked at as a whole. `Masonry` and `Table` are the
+ * explicit exclusions — both are long, both are candidates for virtualization
+ * (where "index" means position in a window that scrolls, so items would
+ * re-stagger as they scroll into view), and a sortable table re-orders its rows
+ * on click, which would deal the whole grid out again on every header press.
+ *
+ * @param index - The item's position in its list, from 0.
+ * @returns Props to spread onto the item. Merge `style` by hand if the call
+ *   site already sets one.
+ */
+const staggerProps = (index) => ({
+    animationStyle: 'stagger',
+    // Not clamped here even though the preset's `min()` makes it redundant in
+    // CSS: an out-of-range value passed straight through is what makes a wrong
+    // index visible in the DOM instead of silently flattened.
+    style: { '--stagger-index': index },
+});
+/**
+ * The delay `staggerProps(index)` resolves to, in milliseconds.
+ *
+ * Exists for the two callers that cannot read a CSS variable — a test asserting
+ * the cap holds, and JS animation tech sequencing alongside a staggered list.
+ * It has to mirror the `calc()` in the `stagger` preset exactly, which is why
+ * both read the same two constants.
+ */
+const staggerDelayMs = (index) => Math.min(Math.max(index, 0), MOTION_STAGGER_MAX) *
+    MOTION_DURATION_MS.staggerStep;
+
+export { staggerDelayMs, staggerProps };
+//# sourceMappingURL=staggerProps.mjs.map

package/dist/utils/staggerProps.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"staggerProps.mjs","sources":["../../src/utils/staggerProps.ts"],"sourcesContent":[null],"names":[],"mappings":";;;AAQA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAmCG;MACU,YAAY,GAAG,CAAC,KAAa,MAAoB;AAC5D,IAAA,cAAc,EAAE,SAAS;;;;AAIzB,IAAA,KAAK,EAAE,EAAE,iBAAiB,EAAE,KAAK,EAAE;AACpC,CAAA;AAED;;;;;;;AAOG;MACU,cAAc,GAAG,CAAC,KAAa,KAC1C,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,GAAG,CAAC,KAAK,EAAE,CAAC,CAAC,EAAE,kBAAkB,CAAC;IAChD,kBAAkB,CAAC;;;;"}

package/eslint/index.js

@@ -0,0 +1,28 @@
+/**
+ * ESLint plugin shipped with @mindlogic-ai/logician-ui.
+ *
+ * Flat config (eslint.config.js):
+ *   const logician = require('@mindlogic-ai/logician-ui/eslint');
+ *   module.exports = [{ plugins: { logician }, rules: { 'logician/no-deprecated-tokens': 'warn' } }];
+ *   // or: module.exports = [logician.configs.recommended];
+ *
+ * Legacy .eslintrc (ESLint 8): load the rule directory instead —
+ *   eslint --rulesdir node_modules/@mindlogic-ai/logician-ui/eslint/rules …
+ *   rules: { 'no-deprecated-tokens': 'warn' }
+ */
+'use strict';
+
+const noDeprecatedTokens = require('./rules/no-deprecated-tokens');
+
+const plugin = {
+  meta: { name: '@mindlogic-ai/logician-ui/eslint' },
+  rules: { 'no-deprecated-tokens': noDeprecatedTokens },
+};
+plugin.configs = {
+  recommended: {
+    plugins: { logician: plugin },
+    rules: { 'logician/no-deprecated-tokens': 'warn' },
+  },
+};
+
+module.exports = plugin;