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

package/dist/theme/recipes/accordion.js

@@ -0,0 +1,25 @@
+"use client";
+'use strict';
+
+var react = require('@chakra-ui/react');
+var motion = require('../motion.js');
+
+/**
+ * Logician overrides for Chakra's `accordion` slot recipe.
+ *
+ * Only the clock. Chakra opens and closes the item content over a symmetric
+ * 200 / 200, while `Collapsible` — the same height animation — already runs on
+ * the house `presence` policy (300 in, 150 out). Consumers render
+ * `Accordion.ItemContent` straight from Chakra, so a component prop cannot
+ * reach it; the recipe can. The recipe's own `expand-height` /
+ * `collapse-height` names are untouched and still decide what moves.
+ */
+const accordionSlotRecipe = react.defineSlotRecipe({
+    slots: ['itemContent'],
+    base: {
+        itemContent: { ...motion.PRESENCE_TIMING },
+    },
+});
+
+exports.accordionSlotRecipe = accordionSlotRecipe;
+//# sourceMappingURL=accordion.js.map

package/dist/theme/recipes/accordion.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"accordion.js","sources":["../../../src/theme/recipes/accordion.ts"],"sourcesContent":[null],"names":["defineSlotRecipe","PRESENCE_TIMING"],"mappings":";;;;;;AAIA;;;;;;;;;AASG;AACI,MAAM,mBAAmB,GAAGA,sBAAgB,CAAC;IAClD,KAAK,EAAE,CAAC,aAAa,CAAC;AACtB,IAAA,IAAI,EAAE;AACJ,QAAA,WAAW,EAAE,EAAE,GAAGC,sBAAe,EAAE;AACpC,KAAA;AACF,CAAA;;;;"}

package/dist/theme/recipes/accordion.mjs

@@ -0,0 +1,23 @@
+"use client";
+import { defineSlotRecipe } from '@chakra-ui/react';
+import { PRESENCE_TIMING } from '../motion.mjs';
+
+/**
+ * Logician overrides for Chakra's `accordion` slot recipe.
+ *
+ * Only the clock. Chakra opens and closes the item content over a symmetric
+ * 200 / 200, while `Collapsible` — the same height animation — already runs on
+ * the house `presence` policy (300 in, 150 out). Consumers render
+ * `Accordion.ItemContent` straight from Chakra, so a component prop cannot
+ * reach it; the recipe can. The recipe's own `expand-height` /
+ * `collapse-height` names are untouched and still decide what moves.
+ */
+const accordionSlotRecipe = defineSlotRecipe({
+    slots: ['itemContent'],
+    base: {
+        itemContent: { ...PRESENCE_TIMING },
+    },
+});
+
+export { accordionSlotRecipe };
+//# sourceMappingURL=accordion.mjs.map

package/dist/theme/recipes/accordion.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"accordion.mjs","sources":["../../../src/theme/recipes/accordion.ts"],"sourcesContent":[null],"names":[],"mappings":";;;;AAIA;;;;;;;;;AASG;AACI,MAAM,mBAAmB,GAAG,gBAAgB,CAAC;IAClD,KAAK,EAAE,CAAC,aAAa,CAAC;AACtB,IAAA,IAAI,EAAE;AACJ,QAAA,WAAW,EAAE,EAAE,GAAG,eAAe,EAAE;AACpC,KAAA;AACF,CAAA;;;;"}

package/dist/translations/Defaults.translations.json.js

@@ -227,6 +227,13 @@ var deleting = {
 	ja: "削除中",
 	es: "Eliminando"
 };
+var close = {
+	ko: "닫기",
+	en: "Close",
+	zh: "关闭",
+	ja: "閉じる",
+	es: "Cerrar"
+};
 var defaultTranslations = {
 	get_started: get_started,
 	next: next,
@@ -266,11 +273,13 @@ var defaultTranslations = {
 	es: "Eliminar"
 },
 	downloading: downloading,
-	deleting: deleting
+	deleting: deleting,
+	close: close
 };
 
 exports.anonymous = anonymous;
 exports.clear = clear;
+exports.close = close;
 exports.component = component;
 exports.copied = copied;
 exports.copy = copy;

package/dist/translations/Defaults.translations.json.js.map

@@ -1 +1 @@
-{"version":3,"file":"Defaults.translations.json.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"Defaults.translations.json.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/translations/Defaults.translations.json.mjs

@@ -223,6 +223,13 @@ var deleting = {
 	ja: "削除中",
 	es: "Eliminando"
 };
+var close = {
+	ko: "닫기",
+	en: "Close",
+	zh: "关闭",
+	ja: "閉じる",
+	es: "Cerrar"
+};
 var defaultTranslations = {
 	get_started: get_started,
 	next: next,
@@ -262,8 +269,9 @@ var defaultTranslations = {
 	es: "Eliminar"
 },
 	downloading: downloading,
-	deleting: deleting
+	deleting: deleting,
+	close: close
 };
 
-export { anonymous, clear, component, copied, copy, copy_error_details, defaultTranslations as default, deleting, download, downloading, error_boundary_default_message, error_boundary_subtitle, error_boundary_title, error_details_copied, error_id, get_started, go_next_page_button, month_range_placeholder, next, page, pagination_items_per_page, pagination_range_text, previous, refresh_page, see_less, see_more, support_help_text, support_information, time, try_again, unknown, upload_your_file, user_id };
+export { anonymous, clear, close, component, copied, copy, copy_error_details, defaultTranslations as default, deleting, download, downloading, error_boundary_default_message, error_boundary_subtitle, error_boundary_title, error_details_copied, error_id, get_started, go_next_page_button, month_range_placeholder, next, page, pagination_items_per_page, pagination_range_text, previous, refresh_page, see_less, see_more, support_help_text, support_information, time, try_again, unknown, upload_your_file, user_id };
 //# sourceMappingURL=Defaults.translations.json.mjs.map

package/dist/translations/Defaults.translations.json.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"Defaults.translations.json.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"Defaults.translations.json.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/types/polymorphic.d.ts

@@ -0,0 +1,101 @@
+import type { ComponentPropsWithoutRef, ComponentPropsWithRef, ElementType, ReactElement } from 'react';
+/**
+ * Types for a component whose rendered element can be swapped with `as`.
+ *
+ * ## Why this exists
+ *
+ * Chakra v3's prop types are bound to one element: `ButtonProps` extends
+ * `HTMLChakraProps<"button">`, so `as={Link}` swaps what RENDERS without
+ * swapping what type-checks. v2's polymorphic `ComponentWithAs` is gone, and
+ * Chakra's own answer is `asChild` — which is the right tool when you control
+ * the markup, because the child types itself.
+ *
+ * It is the wrong tool for a component library's consumers. `asChild` requires
+ * restructuring the call site to nest exactly one child, and a consuming app
+ * that just wants a link-shaped button ends up writing
+ * `href` under a `@ts-expect-error` instead. FactChat had **51 of those across
+ * 41 files** before this existed.
+ *
+ * ## What it does
+ *
+ * `as` picks the element; the element's own props join the component's own.
+ * Where they collide the component wins — `color` is a Chakra style prop here,
+ * not `<a>`'s deprecated presentational attribute — so a component's contract
+ * is never silently widened by the element it happens to render.
+ *
+ * ```tsx
+ * <Button as="a" href="/docs" target="_blank">문서</Button>
+ * <Button as={Link} href="/admin" prefetch={false}>관리자</Button>
+ * <Button onClick={save}>저장</Button>   // still a <button>, unchanged
+ * ```
+ */
+export type PolymorphicProps<TElement extends ElementType, TOwn> = TOwn & {
+    /** The element or component to render. Defaults to the component's own. */
+    as?: TElement;
+} & Omit<ComponentPropsWithoutRef<TElement>, keyof TOwn | 'as'>;
+/**
+ * The `ref` a polymorphic component takes, typed for the element `as` picked.
+ *
+ * Without this an `as="a"` call site still gets a `Ref<HTMLButtonElement>` and
+ * has to cast — the same defect one prop over.
+ */
+export type PolymorphicRef<TElement extends ElementType> = ComponentPropsWithRef<TElement>['ref'];
+/**
+ * The public type of a polymorphic component: a generic call signature whose
+ * props follow whatever `as` renders, defaulting to `TDefault`.
+ */
+export type PolymorphicComponent<TOwn, TDefault extends ElementType> = (<TElement extends ElementType = TDefault>(props: PolymorphicProps<TElement, TOwn> & {
+    ref?: PolymorphicRef<TElement>;
+}) => ReactElement) & {
+    displayName?: string;
+};
+/**
+ * Give a component the generic call signature above. **Type-level only** — the
+ * implementation, its behaviour and its rendered markup are untouched.
+ *
+ * ```tsx
+ * const ButtonImpl = forwardRef<HTMLButtonElement, ButtonOwnProps>(…);
+ * ButtonImpl.displayName = 'Button';
+ * export const Button = polymorphic<ButtonOwnProps>(ButtonImpl);
+ *
+ * const CardImpl = forwardRef<HTMLDivElement, CardOwnProps>(…);
+ * CardImpl.displayName = 'Card';
+ * export const Card = polymorphic<CardOwnProps, 'div'>(CardImpl);
+ * ```
+ *
+ * ## Why a cast, and why a helper
+ *
+ * `forwardRef` erases generics: its signature is fixed at the type it was
+ * instantiated with, so a generic component cannot be expressed through it.
+ * Re-declaring the call signature is the standard way around that. Doing it
+ * inline costs a dozen lines per component, which is how a design system ends
+ * up polymorphic in two places and not the other seventy-nine — so it lives
+ * here once, and each component spends one line.
+ *
+ * The `Impl` parameter is `unknown` on purpose. It is the erased signature we
+ * are replacing; accepting it as a typed component would only re-assert the
+ * type this function exists to discard.
+ *
+ * `displayName` stays on the implementation, where `react/display-name` can
+ * see it — the lint rule is the thing that stops a component shipping without
+ * one, and it cannot follow a name through this call.
+ *
+ * ## Consumers wrapping these components
+ *
+ * Call this the same way the components above do — a wrapper that pins the
+ * element back to its default undoes the polymorphism one layer up:
+ *
+ * ```ts
+ * export const ClickableCard = polymorphic<ClickableCardOwnProps, 'div'>(ClickableCardImpl);
+ * ```
+ *
+ * One thing to know: this is a runtime export, so a test that mocks
+ * `@mindlogic-ai/logician-ui` wholesale has to include it or the wrapper's
+ * module throws on import. The mock is `<T,>(Impl: T) => Impl` — this function
+ * is a type-level identity, so that IS the implementation. Casting against
+ * `PolymorphicComponent` instead works and needs no mock, but it costs the call
+ * site an `as unknown as` double cast, which is the kind of escape hatch a
+ * wrapper should not have to write.
+ */
+export declare function polymorphic<TOwn, TDefault extends ElementType = 'button'>(Impl: unknown): PolymorphicComponent<TOwn, TDefault>;
+//# sourceMappingURL=polymorphic.d.ts.map

package/dist/types/polymorphic.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"polymorphic.d.ts","sourceRoot":"","sources":["../../src/types/polymorphic.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,wBAAwB,EACxB,qBAAqB,EACrB,WAAW,EACX,YAAY,EACb,MAAM,OAAO,CAAC;AAEf;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,MAAM,MAAM,gBAAgB,CAAC,QAAQ,SAAS,WAAW,EAAE,IAAI,IAAI,IAAI,GAAG;IACxE,2EAA2E;IAC3E,EAAE,CAAC,EAAE,QAAQ,CAAC;CACf,GAAG,IAAI,CAAC,wBAAwB,CAAC,QAAQ,CAAC,EAAE,MAAM,IAAI,GAAG,IAAI,CAAC,CAAC;AAEhE;;;;;GAKG;AACH,MAAM,MAAM,cAAc,CAAC,QAAQ,SAAS,WAAW,IACrD,qBAAqB,CAAC,QAAQ,CAAC,CAAC,KAAK,CAAC,CAAC;AAEzC;;;GAGG;AACH,MAAM,MAAM,oBAAoB,CAAC,IAAI,EAAE,QAAQ,SAAS,WAAW,IAAI,CAAC,CACtE,QAAQ,SAAS,WAAW,GAAG,QAAQ,EAEvC,KAAK,EAAE,gBAAgB,CAAC,QAAQ,EAAE,IAAI,CAAC,GAAG;IAAE,GAAG,CAAC,EAAE,cAAc,CAAC,QAAQ,CAAC,CAAA;CAAE,KACzE,YAAY,CAAC,GAAG;IAAE,WAAW,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC;AAE9C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+CG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE,QAAQ,SAAS,WAAW,GAAG,QAAQ,EACvE,IAAI,EAAE,OAAO,GACZ,oBAAoB,CAAC,IAAI,EAAE,QAAQ,CAAC,CAEtC"}

package/dist/types/polymorphic.js

@@ -0,0 +1,57 @@
+"use client";
+'use strict';
+
+/**
+ * Give a component the generic call signature above. **Type-level only** — the
+ * implementation, its behaviour and its rendered markup are untouched.
+ *
+ * ```tsx
+ * const ButtonImpl = forwardRef<HTMLButtonElement, ButtonOwnProps>(…);
+ * ButtonImpl.displayName = 'Button';
+ * export const Button = polymorphic<ButtonOwnProps>(ButtonImpl);
+ *
+ * const CardImpl = forwardRef<HTMLDivElement, CardOwnProps>(…);
+ * CardImpl.displayName = 'Card';
+ * export const Card = polymorphic<CardOwnProps, 'div'>(CardImpl);
+ * ```
+ *
+ * ## Why a cast, and why a helper
+ *
+ * `forwardRef` erases generics: its signature is fixed at the type it was
+ * instantiated with, so a generic component cannot be expressed through it.
+ * Re-declaring the call signature is the standard way around that. Doing it
+ * inline costs a dozen lines per component, which is how a design system ends
+ * up polymorphic in two places and not the other seventy-nine — so it lives
+ * here once, and each component spends one line.
+ *
+ * The `Impl` parameter is `unknown` on purpose. It is the erased signature we
+ * are replacing; accepting it as a typed component would only re-assert the
+ * type this function exists to discard.
+ *
+ * `displayName` stays on the implementation, where `react/display-name` can
+ * see it — the lint rule is the thing that stops a component shipping without
+ * one, and it cannot follow a name through this call.
+ *
+ * ## Consumers wrapping these components
+ *
+ * Call this the same way the components above do — a wrapper that pins the
+ * element back to its default undoes the polymorphism one layer up:
+ *
+ * ```ts
+ * export const ClickableCard = polymorphic<ClickableCardOwnProps, 'div'>(ClickableCardImpl);
+ * ```
+ *
+ * One thing to know: this is a runtime export, so a test that mocks
+ * `@mindlogic-ai/logician-ui` wholesale has to include it or the wrapper's
+ * module throws on import. The mock is `<T,>(Impl: T) => Impl` — this function
+ * is a type-level identity, so that IS the implementation. Casting against
+ * `PolymorphicComponent` instead works and needs no mock, but it costs the call
+ * site an `as unknown as` double cast, which is the kind of escape hatch a
+ * wrapper should not have to write.
+ */
+function polymorphic(Impl) {
+    return Impl;
+}
+
+exports.polymorphic = polymorphic;
+//# sourceMappingURL=polymorphic.js.map

package/dist/types/polymorphic.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"polymorphic.js","sources":["../../src/types/polymorphic.ts"],"sourcesContent":[null],"names":[],"mappings":";;;AA6DA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+CG;AACG,SAAU,WAAW,CACzB,IAAa,EAAA;AAEb,IAAA,OAAO,IAA4C;AACrD;;;;"}

package/dist/types/polymorphic.mjs

@@ -0,0 +1,55 @@
+"use client";
+/**
+ * Give a component the generic call signature above. **Type-level only** — the
+ * implementation, its behaviour and its rendered markup are untouched.
+ *
+ * ```tsx
+ * const ButtonImpl = forwardRef<HTMLButtonElement, ButtonOwnProps>(…);
+ * ButtonImpl.displayName = 'Button';
+ * export const Button = polymorphic<ButtonOwnProps>(ButtonImpl);
+ *
+ * const CardImpl = forwardRef<HTMLDivElement, CardOwnProps>(…);
+ * CardImpl.displayName = 'Card';
+ * export const Card = polymorphic<CardOwnProps, 'div'>(CardImpl);
+ * ```
+ *
+ * ## Why a cast, and why a helper
+ *
+ * `forwardRef` erases generics: its signature is fixed at the type it was
+ * instantiated with, so a generic component cannot be expressed through it.
+ * Re-declaring the call signature is the standard way around that. Doing it
+ * inline costs a dozen lines per component, which is how a design system ends
+ * up polymorphic in two places and not the other seventy-nine — so it lives
+ * here once, and each component spends one line.
+ *
+ * The `Impl` parameter is `unknown` on purpose. It is the erased signature we
+ * are replacing; accepting it as a typed component would only re-assert the
+ * type this function exists to discard.
+ *
+ * `displayName` stays on the implementation, where `react/display-name` can
+ * see it — the lint rule is the thing that stops a component shipping without
+ * one, and it cannot follow a name through this call.
+ *
+ * ## Consumers wrapping these components
+ *
+ * Call this the same way the components above do — a wrapper that pins the
+ * element back to its default undoes the polymorphism one layer up:
+ *
+ * ```ts
+ * export const ClickableCard = polymorphic<ClickableCardOwnProps, 'div'>(ClickableCardImpl);
+ * ```
+ *
+ * One thing to know: this is a runtime export, so a test that mocks
+ * `@mindlogic-ai/logician-ui` wholesale has to include it or the wrapper's
+ * module throws on import. The mock is `<T,>(Impl: T) => Impl` — this function
+ * is a type-level identity, so that IS the implementation. Casting against
+ * `PolymorphicComponent` instead works and needs no mock, but it costs the call
+ * site an `as unknown as` double cast, which is the kind of escape hatch a
+ * wrapper should not have to write.
+ */
+function polymorphic(Impl) {
+    return Impl;
+}
+
+export { polymorphic };
+//# sourceMappingURL=polymorphic.mjs.map

package/dist/types/polymorphic.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"polymorphic.mjs","sources":["../../src/types/polymorphic.ts"],"sourcesContent":[null],"names":[],"mappings":";AA6DA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+CG;AACG,SAAU,WAAW,CACzB,IAAa,EAAA;AAEb,IAAA,OAAO,IAA4C;AACrD;;;;"}

package/dist/utils/cubicBezier.d.ts

@@ -0,0 +1,30 @@
+import { type MotionEaseToken } from '@/theme/motion';
+/**
+ * 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);
+ * ```
+ */
+export declare const cubicBezier: (curve: MotionEaseToken | readonly [number, number, number, number]) => ((t: number) => number);
+//# sourceMappingURL=cubicBezier.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"cubicBezier.d.ts","sourceRoot":"","sources":["../../src/utils/cubicBezier.ts"],"names":[],"mappings":"AAAA,OAAO,EAAe,KAAK,eAAe,EAAE,MAAM,gBAAgB,CAAC;AAEnE;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,eAAO,MAAM,WAAW,GACtB,OAAO,eAAe,GAAG,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,KACjE,CAAC,CAAC,CAAC,EAAE,MAAM,KAAK,MAAM,CAqCxB,CAAC"}

package/dist/utils/cubicBezier.js

@@ -0,0 +1,67 @@
+"use client";
+'use strict';
+
+var motion = require('../theme/motion.js');
+
+/**
+ * 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.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);
+    };
+};
+
+exports.cubicBezier = cubicBezier;
+//# sourceMappingURL=cubicBezier.js.map

package/dist/utils/cubicBezier.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cubicBezier.js","sources":["../../src/utils/cubicBezier.ts"],"sourcesContent":[null],"names":["MOTION_EASE"],"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,GAAGA,kBAAW,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/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/focusRing.d.ts

@@ -2,8 +2,13 @@
  * 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)
+ *
+ * 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 focusRing: {
     readonly _focus: {
@@ -12,10 +17,6 @@ export declare const focusRing: {
     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";
-        };
     };
 };
 //# 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;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,SAAS;;;;;;;;CAOZ,CAAC"}

package/dist/utils/focusRing.js

@@ -5,16 +5,19 @@
  * 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)
+ *
+ * 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 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' },
     },
 };
 

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;;;;;;;;;;;AAWG;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;AAC1F,KAAA;;;;;"}

package/dist/utils/focusRing.mjs

@@ -3,16 +3,19 @@
  * 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)
+ *
+ * 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 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' },
     },
 };
 

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;;;;;;;;;;;AAWG;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;AAC1F,KAAA;;;;;"}

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;;;;"}