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

package/dist/components/ColorMode/ColorModeToggle.mjs

@@ -1,7 +1,8 @@
 "use client";
-import { jsx } from 'react/jsx-runtime';
+import { jsx, jsxs } from 'react/jsx-runtime';
 import { useState, useEffect } from 'react';
-import { LuSun, LuMoon } from 'react-icons/lu';
+import { Box } from '@chakra-ui/react';
+import { SunIcon, MoonIcon } from '../Icon/index.mjs';
 import { IconButton } from '../IconButton/IconButton.mjs';
 import '../IconButton/IconButton.styles.mjs';
 import { useColorMode } from './useColorMode.mjs';
@@ -24,7 +25,8 @@ const ColorModeToggle = ({ 'aria-label': ariaLabel = 'Toggle color mode', ...res
     useEffect(() => {
         setMounted(true);
     }, []);
-    return (jsx(IconButton, { "aria-label": ariaLabel, onClick: toggleColorMode, ...rest, children: mounted && colorMode === 'dark' ? jsx(LuSun, {}) : jsx(LuMoon, {}) }));
+    const isDark = mounted && colorMode === 'dark';
+    return (jsx(IconButton, { "aria-label": ariaLabel, onClick: toggleColorMode, ...rest, children: jsxs(Box, { display: "grid", placeItems: "center", children: [jsx(Box, { gridArea: "1 / 1", display: "grid", placeItems: "center", opacity: isDark ? 1 : 0, transform: isDark ? undefined : 'rotate(-90deg) scale(0.5)', animationStyle: "spring", transitionProperty: "opacity, transform", children: jsx(SunIcon, {}) }), jsx(Box, { gridArea: "1 / 1", display: "grid", placeItems: "center", opacity: isDark ? 0 : 1, transform: isDark ? 'rotate(90deg) scale(0.5)' : undefined, animationStyle: "spring", transitionProperty: "opacity, transform", children: jsx(MoonIcon, {}) })] }) }));
 };
 ColorModeToggle.displayName = 'ColorModeToggle';
 

package/dist/components/ColorMode/ColorModeToggle.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"ColorModeToggle.mjs","sources":["../../../src/components/ColorMode/ColorModeToggle.tsx"],"sourcesContent":[null],"names":["_jsx"],"mappings":";;;;;;;;AAcA;;;;;;;;;;;AAWG;AACI,MAAM,eAAe,GAAmC,CAAC,EAC9D,YAAY,EAAE,SAAS,GAAG,mBAAmB,EAC7C,GAAG,IAAI,EACR,KAAI;IACH,MAAM,EAAE,SAAS,EAAE,eAAe,EAAE,GAAG,YAAY,EAAE;IACrD,MAAM,CAAC,OAAO,EAAE,UAAU,CAAC,GAAG,QAAQ,CAAC,KAAK,CAAC;IAE7C,SAAS,CAAC,MAAK;QACb,UAAU,CAAC,IAAI,CAAC;IAClB,CAAC,EAAE,EAAE,CAAC;AAEN,IAAA,QACEA,GAAA,CAAC,UAAU,EAAA,EAAA,YAAA,EAAa,SAAS,EAAE,OAAO,EAAE,eAAe,EAAA,GAAM,IAAI,EAAA,QAAA,EAClE,OAAO,IAAI,SAAS,KAAK,MAAM,GAAGA,GAAA,CAAC,KAAK,EAAA,EAAA,CAAG,GAAGA,GAAA,CAAC,MAAM,EAAA,EAAA,CAAG,EAAA,CAC9C;AAEjB;AAEA,eAAe,CAAC,WAAW,GAAG,iBAAiB;;;;"}
+{"version":3,"file":"ColorModeToggle.mjs","sources":["../../../src/components/ColorMode/ColorModeToggle.tsx"],"sourcesContent":[null],"names":["_jsx","_jsxs"],"mappings":";;;;;;;;;AAeA;;;;;;;;;;;AAWG;AACI,MAAM,eAAe,GAAmC,CAAC,EAC9D,YAAY,EAAE,SAAS,GAAG,mBAAmB,EAC7C,GAAG,IAAI,EACR,KAAI;IACH,MAAM,EAAE,SAAS,EAAE,eAAe,EAAE,GAAG,YAAY,EAAE;IACrD,MAAM,CAAC,OAAO,EAAE,UAAU,CAAC,GAAG,QAAQ,CAAC,KAAK,CAAC;IAE7C,SAAS,CAAC,MAAK;QACb,UAAU,CAAC,IAAI,CAAC;IAClB,CAAC,EAAE,EAAE,CAAC;AAEN,IAAA,MAAM,MAAM,GAAG,OAAO,IAAI,SAAS,KAAK,MAAM;AAE9C,IAAA,QACEA,GAAA,CAAC,UAAU,EAAA,EAAA,YAAA,EAAa,SAAS,EAAE,OAAO,EAAE,eAAe,EAAA,GAAM,IAAI,EAAA,QAAA,EAMnEC,IAAA,CAAC,GAAG,EAAA,EAAC,OAAO,EAAC,MAAM,EAAC,UAAU,EAAC,QAAQ,EAAA,QAAA,EAAA,CACrCD,GAAA,CAAC,GAAG,EAAA,EACF,QAAQ,EAAC,OAAO,EAChB,OAAO,EAAC,MAAM,EACd,UAAU,EAAC,QAAQ,EACnB,OAAO,EAAE,MAAM,GAAG,CAAC,GAAG,CAAC,EACvB,SAAS,EAAE,MAAM,GAAG,SAAS,GAAG,2BAA2B,EAC3D,cAAc,EAAC,QAAQ,EACvB,kBAAkB,EAAC,oBAAoB,EAAA,QAAA,EAEvCA,GAAA,CAAC,OAAO,EAAA,EAAA,CAAG,EAAA,CACP,EACNA,GAAA,CAAC,GAAG,EAAA,EACF,QAAQ,EAAC,OAAO,EAChB,OAAO,EAAC,MAAM,EACd,UAAU,EAAC,QAAQ,EACnB,OAAO,EAAE,MAAM,GAAG,CAAC,GAAG,CAAC,EACvB,SAAS,EAAE,MAAM,GAAG,0BAA0B,GAAG,SAAS,EAC1D,cAAc,EAAC,QAAQ,EACvB,kBAAkB,EAAC,oBAAoB,EAAA,QAAA,EAEvCA,GAAA,CAAC,QAAQ,EAAA,EAAA,CAAG,EAAA,CACR,CAAA,EAAA,CACF,EAAA,CACK;AAEjB;AAEA,eAAe,CAAC,WAAW,GAAG,iBAAiB;;;;"}

package/dist/components/Confetti/Confetti.d.ts

@@ -0,0 +1,50 @@
+import { ConfettiProps } from './Confetti.types';
+/**
+ * A one-shot celebratory burst — the thing that plays when a reward lands or a
+ * purchase completes.
+ *
+ * Pure CSS, one class, one keyframe. Fifty pieces share `confetti-fall` and
+ * differ only in the three custom properties it reads, so the burst costs one
+ * style rule rather than fifty.
+ *
+ * **The token sets the pace; each piece scales it.** Where a piece starts, how
+ * far it drifts, which way it tumbles, what colour it is and *how fast it
+ * falls* are all per-piece — equal fall speed is the one thing debris never
+ * has, and fifty pieces at an identical rate read as one sheet. But the rate is
+ * a bounded multiple of `motion.celebrate.fall` rather than an open interval,
+ * so the burst still has a computable end. FactChat's version uses
+ * `2 + Math.random()` seconds with no ceiling, which is the part that makes a
+ * burst impossible to schedule anything after.
+ *
+ * The delay is random too, not indexed. An earlier pass here reused the
+ * `stagger` step, which was a mistake worth naming: a list has an order the eye
+ * follows, and a delay that grows with the index is a *rhythm*. Confetti has no
+ * order, so the same delay reads as a wave sweeping across the container —
+ * fifty pieces queueing rather than bursting.
+ *
+ * Under reduced motion the pieces mount and stay invisible rather than being
+ * branched away in JS — a burst carries no information, so removing it removes
+ * nothing, and doing it in CSS keeps the decision on the same media query as
+ * every other preset instead of on a hook that has to guess before hydration.
+ *
+ * **The default colours are literal hex, and this is the one place in the
+ * library deliberately off the palette.** Semantic tokens mean things, and
+ * raining `danger.main` over "payment complete" says something the screen does
+ * not — confetti is the one element on a page with nothing to communicate. The
+ * palette is also built for interface legibility on a light surface, so it runs
+ * dark and narrow (average lightness 47%, three of five in the blue range) and
+ * fifty pieces of it read as a chart legend falling. The cost is real and
+ * stated: these do not follow a re-theme and do not adapt to dark mode. `colors`
+ * is a prop for an app that needs its own.
+ *
+ * **Takes no children — it is an overlay, not a wrapper.** It renders absolutely
+ * against the nearest positioned ancestor, which is therefore the stage: give
+ * that element `position: relative`, or the burst resolves against the page and
+ * rains over everything.
+ *
+ * ```tsx
+ * {justPurchased && <Confetti />}
+ * ```
+ */
+export declare const Confetti: import("react").ForwardRefExoticComponent<ConfettiProps & import("react").RefAttributes<HTMLDivElement>>;
+//# sourceMappingURL=Confetti.d.ts.map

package/dist/components/Confetti/Confetti.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Confetti.d.ts","sourceRoot":"","sources":["../../../src/components/Confetti/Confetti.tsx"],"names":[],"mappings":"AAKA,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAkDjD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8CG;AACH,eAAO,MAAM,QAAQ,0GA6EpB,CAAC"}

package/dist/components/Confetti/Confetti.js

@@ -0,0 +1,149 @@
+"use client";
+'use strict';
+
+var jsxRuntime = require('react/jsx-runtime');
+var React = require('react');
+var react = require('@chakra-ui/react');
+var motion = require('../../theme/motion.js');
+var Confetti_styles = require('./Confetti.styles.js');
+
+/**
+ * Literal hex, and the one place in this library that is deliberately off the
+ * palette.
+ *
+ * The first version reached for `primary.main` / `success.main` /
+ * `warning.main` / `danger.main`, which was wrong twice over. **Semantically**,
+ * those colours mean things: raining the error red and the warning amber over
+ * "payment complete" says something the screen does not. Confetti is the one
+ * element on a page with nothing to communicate, so a colour that communicates
+ * is the wrong kind of colour.
+ *
+ * **And optically**, the palette is built for interface legibility — text and
+ * controls on a light surface — so it sits dark and desaturated: average
+ * lightness 47%, nothing above 80% saturation, and three of the five in the
+ * blue range. Fifty pieces of that read as a chart legend falling. These six
+ * average 56% lightness, four of them are fully saturated, and they span the
+ * whole wheel (9°–330°), which is what makes a burst read as a burst.
+ *
+ * The cost, stated rather than hidden: these do not follow a re-theme, and they
+ * do not adapt to dark mode — a bright hex on a dark surface is brighter still.
+ * That is acceptable for a burst that lasts two seconds and carries no
+ * information, and it is why `colors` is a prop: an app that needs its own
+ * festival palette passes one.
+ */
+const DEFAULT_COLORS = [
+    '#FFD700', // gold
+    '#FF69B4', // hot pink
+    '#00CED1', // turquoise
+    '#FF6347', // tomato
+    '#9370DB', // medium purple
+    '#32CD32', // lime
+];
+/**
+ * A seeded generator, so one burst is stable across re-renders.
+ *
+ * `Math.random()` per render would re-scatter every piece whenever the parent
+ * updated — and a parent that is showing a celebration is usually updating,
+ * because something just finished.
+ */
+const scatter = (seed) => {
+    let s = seed || 1;
+    return () => {
+        s = (s * 1664525 + 1013904223) % 4294967296;
+        return s / 4294967296;
+    };
+};
+/**
+ * A one-shot celebratory burst — the thing that plays when a reward lands or a
+ * purchase completes.
+ *
+ * Pure CSS, one class, one keyframe. Fifty pieces share `confetti-fall` and
+ * differ only in the three custom properties it reads, so the burst costs one
+ * style rule rather than fifty.
+ *
+ * **The token sets the pace; each piece scales it.** Where a piece starts, how
+ * far it drifts, which way it tumbles, what colour it is and *how fast it
+ * falls* are all per-piece — equal fall speed is the one thing debris never
+ * has, and fifty pieces at an identical rate read as one sheet. But the rate is
+ * a bounded multiple of `motion.celebrate.fall` rather than an open interval,
+ * so the burst still has a computable end. FactChat's version uses
+ * `2 + Math.random()` seconds with no ceiling, which is the part that makes a
+ * burst impossible to schedule anything after.
+ *
+ * The delay is random too, not indexed. An earlier pass here reused the
+ * `stagger` step, which was a mistake worth naming: a list has an order the eye
+ * follows, and a delay that grows with the index is a *rhythm*. Confetti has no
+ * order, so the same delay reads as a wave sweeping across the container —
+ * fifty pieces queueing rather than bursting.
+ *
+ * Under reduced motion the pieces mount and stay invisible rather than being
+ * branched away in JS — a burst carries no information, so removing it removes
+ * nothing, and doing it in CSS keeps the decision on the same media query as
+ * every other preset instead of on a hook that has to guess before hydration.
+ *
+ * **The default colours are literal hex, and this is the one place in the
+ * library deliberately off the palette.** Semantic tokens mean things, and
+ * raining `danger.main` over "payment complete" says something the screen does
+ * not — confetti is the one element on a page with nothing to communicate. The
+ * palette is also built for interface legibility on a light surface, so it runs
+ * dark and narrow (average lightness 47%, three of five in the blue range) and
+ * fifty pieces of it read as a chart legend falling. The cost is real and
+ * stated: these do not follow a re-theme and do not adapt to dark mode. `colors`
+ * is a prop for an app that needs its own.
+ *
+ * **Takes no children — it is an overlay, not a wrapper.** It renders absolutely
+ * against the nearest positioned ancestor, which is therefore the stage: give
+ * that element `position: relative`, or the burst resolves against the page and
+ * rains over everything.
+ *
+ * ```tsx
+ * {justPurchased && <Confetti />}
+ * ```
+ */
+const Confetti = React.forwardRef(({ pieceCount = 50, colors = DEFAULT_COLORS, seed = 1, ...rest }, ref) => {
+    const pieces = React.useMemo(() => {
+        const next = scatter(seed);
+        return Array.from({ length: pieceCount }, (_, i) => ({
+            id: i,
+            left: `${next() * 100}%`,
+            color: colors[Math.floor(next() * colors.length)],
+            // ± half a container width of lateral travel.
+            drift: `${Math.round(next() * 100 - 50)}px`,
+            // Two full turns, and only the direction is random. A magnitude that
+            // varies down to near zero gives some pieces no tumble at all, which is
+            // the difference between debris and a falling rectangle.
+            spin: next() < 0.5 ? '-720deg' : '720deg',
+            // Square, near enough. The first version varied width 6–10 and height
+            // 8–14 independently, which produced pieces 2.3× taller than wide —
+            // and with `radii.xs` on top of that (4px, because this theme
+            // overrides Chakra's 2px for buttons and cards) a 6px-wide piece is
+            // two-thirds round. A rounded oblong tumbling end over end is not a
+            // fragment of paper; the team's word for it was 애벌레, caterpillar.
+            width: `${8 + Math.round(next() * 4)}px`,
+            height: `${8 + Math.round(next() * 5)}px`,
+            // 0.85–1.3× the token. Anchored to the scale, and with a ceiling: the
+            // whole burst is over by `fall × 1.3 + base`, which is knowable without
+            // running it.
+            rate: (0.85 + next() * 0.45).toFixed(2),
+            // Random within `motion.base`, not stepped by index — see the note
+            // above about why a stagger is wrong here. 300ms is wide enough that no
+            // two pieces launch together and narrow enough that the burst still
+            // reads as one event.
+            delay: `${Math.round(next() * motion.MOTION_DURATION_MS.base)}ms`,
+        }));
+    }, [pieceCount, colors, seed]);
+    return (jsxRuntime.jsx(react.Box, { ref: ref, position: "absolute", inset: "0", overflow: "hidden", pointerEvents: "none", "aria-hidden": true, 
+        // Establishes the containing block the keyframe's `cqh` resolves
+        // against. Without it `110cqh` falls back to the small viewport and
+        // every piece leaves the screen in the first few frames.
+        containerType: "size", ...rest, children: pieces.map((p) => (jsxRuntime.jsx(react.Box, { css: Confetti_styles.confettiPiece, bg: p.color, left: p.left, w: p.width, h: p.height, style: {
+                '--confetti-drift': p.drift,
+                '--confetti-spin': p.spin,
+                '--confetti-rate': p.rate,
+                animationDelay: p.delay,
+            } }, p.id))) }));
+});
+Confetti.displayName = 'Confetti';
+
+exports.Confetti = Confetti;
+//# sourceMappingURL=Confetti.js.map

package/dist/components/Confetti/Confetti.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Confetti.js","sources":["../../../src/components/Confetti/Confetti.tsx"],"sourcesContent":[null],"names":["forwardRef","useMemo","MOTION_DURATION_MS","_jsx","Box","confettiPiece"],"mappings":"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"}

package/dist/components/Confetti/Confetti.mjs

@@ -0,0 +1,147 @@
+"use client";
+import { jsx } from 'react/jsx-runtime';
+import { forwardRef, useMemo } from 'react';
+import { Box } from '@chakra-ui/react';
+import { MOTION_DURATION_MS } from '../../theme/motion.mjs';
+import { confettiPiece } from './Confetti.styles.mjs';
+
+/**
+ * Literal hex, and the one place in this library that is deliberately off the
+ * palette.
+ *
+ * The first version reached for `primary.main` / `success.main` /
+ * `warning.main` / `danger.main`, which was wrong twice over. **Semantically**,
+ * those colours mean things: raining the error red and the warning amber over
+ * "payment complete" says something the screen does not. Confetti is the one
+ * element on a page with nothing to communicate, so a colour that communicates
+ * is the wrong kind of colour.
+ *
+ * **And optically**, the palette is built for interface legibility — text and
+ * controls on a light surface — so it sits dark and desaturated: average
+ * lightness 47%, nothing above 80% saturation, and three of the five in the
+ * blue range. Fifty pieces of that read as a chart legend falling. These six
+ * average 56% lightness, four of them are fully saturated, and they span the
+ * whole wheel (9°–330°), which is what makes a burst read as a burst.
+ *
+ * The cost, stated rather than hidden: these do not follow a re-theme, and they
+ * do not adapt to dark mode — a bright hex on a dark surface is brighter still.
+ * That is acceptable for a burst that lasts two seconds and carries no
+ * information, and it is why `colors` is a prop: an app that needs its own
+ * festival palette passes one.
+ */
+const DEFAULT_COLORS = [
+    '#FFD700', // gold
+    '#FF69B4', // hot pink
+    '#00CED1', // turquoise
+    '#FF6347', // tomato
+    '#9370DB', // medium purple
+    '#32CD32', // lime
+];
+/**
+ * A seeded generator, so one burst is stable across re-renders.
+ *
+ * `Math.random()` per render would re-scatter every piece whenever the parent
+ * updated — and a parent that is showing a celebration is usually updating,
+ * because something just finished.
+ */
+const scatter = (seed) => {
+    let s = seed || 1;
+    return () => {
+        s = (s * 1664525 + 1013904223) % 4294967296;
+        return s / 4294967296;
+    };
+};
+/**
+ * A one-shot celebratory burst — the thing that plays when a reward lands or a
+ * purchase completes.
+ *
+ * Pure CSS, one class, one keyframe. Fifty pieces share `confetti-fall` and
+ * differ only in the three custom properties it reads, so the burst costs one
+ * style rule rather than fifty.
+ *
+ * **The token sets the pace; each piece scales it.** Where a piece starts, how
+ * far it drifts, which way it tumbles, what colour it is and *how fast it
+ * falls* are all per-piece — equal fall speed is the one thing debris never
+ * has, and fifty pieces at an identical rate read as one sheet. But the rate is
+ * a bounded multiple of `motion.celebrate.fall` rather than an open interval,
+ * so the burst still has a computable end. FactChat's version uses
+ * `2 + Math.random()` seconds with no ceiling, which is the part that makes a
+ * burst impossible to schedule anything after.
+ *
+ * The delay is random too, not indexed. An earlier pass here reused the
+ * `stagger` step, which was a mistake worth naming: a list has an order the eye
+ * follows, and a delay that grows with the index is a *rhythm*. Confetti has no
+ * order, so the same delay reads as a wave sweeping across the container —
+ * fifty pieces queueing rather than bursting.
+ *
+ * Under reduced motion the pieces mount and stay invisible rather than being
+ * branched away in JS — a burst carries no information, so removing it removes
+ * nothing, and doing it in CSS keeps the decision on the same media query as
+ * every other preset instead of on a hook that has to guess before hydration.
+ *
+ * **The default colours are literal hex, and this is the one place in the
+ * library deliberately off the palette.** Semantic tokens mean things, and
+ * raining `danger.main` over "payment complete" says something the screen does
+ * not — confetti is the one element on a page with nothing to communicate. The
+ * palette is also built for interface legibility on a light surface, so it runs
+ * dark and narrow (average lightness 47%, three of five in the blue range) and
+ * fifty pieces of it read as a chart legend falling. The cost is real and
+ * stated: these do not follow a re-theme and do not adapt to dark mode. `colors`
+ * is a prop for an app that needs its own.
+ *
+ * **Takes no children — it is an overlay, not a wrapper.** It renders absolutely
+ * against the nearest positioned ancestor, which is therefore the stage: give
+ * that element `position: relative`, or the burst resolves against the page and
+ * rains over everything.
+ *
+ * ```tsx
+ * {justPurchased && <Confetti />}
+ * ```
+ */
+const Confetti = forwardRef(({ pieceCount = 50, colors = DEFAULT_COLORS, seed = 1, ...rest }, ref) => {
+    const pieces = useMemo(() => {
+        const next = scatter(seed);
+        return Array.from({ length: pieceCount }, (_, i) => ({
+            id: i,
+            left: `${next() * 100}%`,
+            color: colors[Math.floor(next() * colors.length)],
+            // ± half a container width of lateral travel.
+            drift: `${Math.round(next() * 100 - 50)}px`,
+            // Two full turns, and only the direction is random. A magnitude that
+            // varies down to near zero gives some pieces no tumble at all, which is
+            // the difference between debris and a falling rectangle.
+            spin: next() < 0.5 ? '-720deg' : '720deg',
+            // Square, near enough. The first version varied width 6–10 and height
+            // 8–14 independently, which produced pieces 2.3× taller than wide —
+            // and with `radii.xs` on top of that (4px, because this theme
+            // overrides Chakra's 2px for buttons and cards) a 6px-wide piece is
+            // two-thirds round. A rounded oblong tumbling end over end is not a
+            // fragment of paper; the team's word for it was 애벌레, caterpillar.
+            width: `${8 + Math.round(next() * 4)}px`,
+            height: `${8 + Math.round(next() * 5)}px`,
+            // 0.85–1.3× the token. Anchored to the scale, and with a ceiling: the
+            // whole burst is over by `fall × 1.3 + base`, which is knowable without
+            // running it.
+            rate: (0.85 + next() * 0.45).toFixed(2),
+            // Random within `motion.base`, not stepped by index — see the note
+            // above about why a stagger is wrong here. 300ms is wide enough that no
+            // two pieces launch together and narrow enough that the burst still
+            // reads as one event.
+            delay: `${Math.round(next() * MOTION_DURATION_MS.base)}ms`,
+        }));
+    }, [pieceCount, colors, seed]);
+    return (jsx(Box, { ref: ref, position: "absolute", inset: "0", overflow: "hidden", pointerEvents: "none", "aria-hidden": true, 
+        // Establishes the containing block the keyframe's `cqh` resolves
+        // against. Without it `110cqh` falls back to the small viewport and
+        // every piece leaves the screen in the first few frames.
+        containerType: "size", ...rest, children: pieces.map((p) => (jsx(Box, { css: confettiPiece, bg: p.color, left: p.left, w: p.width, h: p.height, style: {
+                '--confetti-drift': p.drift,
+                '--confetti-spin': p.spin,
+                '--confetti-rate': p.rate,
+                animationDelay: p.delay,
+            } }, p.id))) }));
+});
+Confetti.displayName = 'Confetti';
+
+export { Confetti };
+//# sourceMappingURL=Confetti.mjs.map

package/dist/components/Confetti/Confetti.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Confetti.mjs","sources":["../../../src/components/Confetti/Confetti.tsx"],"sourcesContent":[null],"names":["_jsx"],"mappings":"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"}

package/dist/components/Confetti/Confetti.styles.d.ts

@@ -0,0 +1,32 @@
+import type { SystemStyleObject } from '@chakra-ui/react';
+/**
+ * One falling piece.
+ *
+ * ## Why the duration is a token *times a factor*
+ *
+ * The first pass of this pinned every piece to `motion.celebrate.fall` exactly,
+ * on the reasoning that randomising a clock leaves a burst with no known
+ * length. That reasoning was right about sequencing and wrong about confetti:
+ * fifty pieces falling at *identical* speed do not read as fifty pieces. They
+ * read as one sheet, because equal speed is the one thing debris never has —
+ * real pieces differ in mass and in how much air they catch, and that
+ * difference is most of what makes a burst look like a burst.
+ *
+ * So the rate varies, but as a bounded multiple of the token rather than an
+ * open `2 + Math.random()`. The scale still sets the pace, the burst still has
+ * a computable ceiling (`fall × 1.3`, plus the delay spread), and the pieces
+ * still fall at different speeds. What the original had that mattered is kept;
+ * what it had that made the burst unschedulable is not.
+ *
+ * `linear`, and this is one of two places in the library where the curve is not
+ * a preference. The other is the spinner, where easing would put a seam in a
+ * loop; here it is gravity — a piece that decelerates on the way down reads as
+ * being lowered rather than dropped. None of the three house curves is right,
+ * and inventing a fourth for confetti alone would be a preset with one call
+ * site.
+ *
+ * `forwards`, so a piece stays gone. Without it every piece snaps back to the
+ * top of the container on the final frame.
+ */
+export declare const confettiPiece: SystemStyleObject;
+//# sourceMappingURL=Confetti.styles.d.ts.map

package/dist/components/Confetti/Confetti.styles.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Confetti.styles.d.ts","sourceRoot":"","sources":["../../../src/components/Confetti/Confetti.styles.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAC;AAE1D;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,eAAO,MAAM,aAAa,EAAE,iBAyB3B,CAAC"}

package/dist/components/Confetti/Confetti.styles.js

@@ -0,0 +1,60 @@
+"use client";
+'use strict';
+
+/**
+ * One falling piece.
+ *
+ * ## Why the duration is a token *times a factor*
+ *
+ * The first pass of this pinned every piece to `motion.celebrate.fall` exactly,
+ * on the reasoning that randomising a clock leaves a burst with no known
+ * length. That reasoning was right about sequencing and wrong about confetti:
+ * fifty pieces falling at *identical* speed do not read as fifty pieces. They
+ * read as one sheet, because equal speed is the one thing debris never has —
+ * real pieces differ in mass and in how much air they catch, and that
+ * difference is most of what makes a burst look like a burst.
+ *
+ * So the rate varies, but as a bounded multiple of the token rather than an
+ * open `2 + Math.random()`. The scale still sets the pace, the burst still has
+ * a computable ceiling (`fall × 1.3`, plus the delay spread), and the pieces
+ * still fall at different speeds. What the original had that mattered is kept;
+ * what it had that made the burst unschedulable is not.
+ *
+ * `linear`, and this is one of two places in the library where the curve is not
+ * a preference. The other is the spinner, where easing would put a seam in a
+ * loop; here it is gravity — a piece that decelerates on the way down reads as
+ * being lowered rather than dropped. None of the three house curves is right,
+ * and inventing a fourth for confetti alone would be a preset with one call
+ * site.
+ *
+ * `forwards`, so a piece stays gone. Without it every piece snaps back to the
+ * top of the container on the final frame.
+ */
+const confettiPiece = {
+    position: 'absolute',
+    top: '0',
+    // No radius, and not a token. `radii.xs` is 4px in this theme — a value
+    // chosen for buttons and cards, which is most of the width of a 10px piece.
+    // The radius scale exists for things a finger touches; a fragment is not one,
+    // and a corner is what makes it read as torn paper rather than a pill.
+    borderRadius: '0',
+    animationName: 'confetti-fall',
+    animationDuration: 'calc(var(--chakra-durations-motion-celebrate-fall) * var(--confetti-rate, 1))',
+    animationTimingFunction: 'linear',
+    // `both`, not `forwards`. Each piece waits out a delay of up to
+    // `motion.base`, and with `forwards` alone the element renders in its *own*
+    // CSS state during that wait — parked at `top: 0`, which is the top edge of
+    // the container and fully visible. Forty pieces then sit in a row along the
+    // rim and drop when their delay expires: hanging, not falling. The backwards
+    // half of `both` applies the 0% frame during the delay instead, which is
+    // above the edge and clipped away.
+    animationFillMode: 'both',
+    // Nothing to soften: a burst carries no information, so under reduced motion
+    // the pieces stay where they are and invisible. Done in CSS rather than by
+    // branching in JS so the decision sits on the same media query as every
+    // preset, instead of on a hook that has to guess before hydration.
+    _motionReduce: { animationName: 'none', opacity: 0 },
+};
+
+exports.confettiPiece = confettiPiece;
+//# sourceMappingURL=Confetti.styles.js.map

package/dist/components/Confetti/Confetti.styles.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Confetti.styles.js","sources":["../../../src/components/Confetti/Confetti.styles.ts"],"sourcesContent":[null],"names":[],"mappings":";;;AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4BG;AACI,MAAM,aAAa,GAAsB;AAC9C,IAAA,QAAQ,EAAE,UAAU;AACpB,IAAA,GAAG,EAAE,GAAG;;;;;AAKR,IAAA,YAAY,EAAE,GAAG;AACjB,IAAA,aAAa,EAAE,eAAe;AAC9B,IAAA,iBAAiB,EACf,+EAA+E;AACjF,IAAA,uBAAuB,EAAE,QAAQ;;;;;;;;AAQjC,IAAA,iBAAiB,EAAE,MAAM;;;;;IAKzB,aAAa,EAAE,EAAE,aAAa,EAAE,MAAM,EAAE,OAAO,EAAE,CAAC,EAAE;;;;;"}

package/dist/components/Confetti/Confetti.styles.mjs

@@ -0,0 +1,58 @@
+"use client";
+/**
+ * One falling piece.
+ *
+ * ## Why the duration is a token *times a factor*
+ *
+ * The first pass of this pinned every piece to `motion.celebrate.fall` exactly,
+ * on the reasoning that randomising a clock leaves a burst with no known
+ * length. That reasoning was right about sequencing and wrong about confetti:
+ * fifty pieces falling at *identical* speed do not read as fifty pieces. They
+ * read as one sheet, because equal speed is the one thing debris never has —
+ * real pieces differ in mass and in how much air they catch, and that
+ * difference is most of what makes a burst look like a burst.
+ *
+ * So the rate varies, but as a bounded multiple of the token rather than an
+ * open `2 + Math.random()`. The scale still sets the pace, the burst still has
+ * a computable ceiling (`fall × 1.3`, plus the delay spread), and the pieces
+ * still fall at different speeds. What the original had that mattered is kept;
+ * what it had that made the burst unschedulable is not.
+ *
+ * `linear`, and this is one of two places in the library where the curve is not
+ * a preference. The other is the spinner, where easing would put a seam in a
+ * loop; here it is gravity — a piece that decelerates on the way down reads as
+ * being lowered rather than dropped. None of the three house curves is right,
+ * and inventing a fourth for confetti alone would be a preset with one call
+ * site.
+ *
+ * `forwards`, so a piece stays gone. Without it every piece snaps back to the
+ * top of the container on the final frame.
+ */
+const confettiPiece = {
+    position: 'absolute',
+    top: '0',
+    // No radius, and not a token. `radii.xs` is 4px in this theme — a value
+    // chosen for buttons and cards, which is most of the width of a 10px piece.
+    // The radius scale exists for things a finger touches; a fragment is not one,
+    // and a corner is what makes it read as torn paper rather than a pill.
+    borderRadius: '0',
+    animationName: 'confetti-fall',
+    animationDuration: 'calc(var(--chakra-durations-motion-celebrate-fall) * var(--confetti-rate, 1))',
+    animationTimingFunction: 'linear',
+    // `both`, not `forwards`. Each piece waits out a delay of up to
+    // `motion.base`, and with `forwards` alone the element renders in its *own*
+    // CSS state during that wait — parked at `top: 0`, which is the top edge of
+    // the container and fully visible. Forty pieces then sit in a row along the
+    // rim and drop when their delay expires: hanging, not falling. The backwards
+    // half of `both` applies the 0% frame during the delay instead, which is
+    // above the edge and clipped away.
+    animationFillMode: 'both',
+    // Nothing to soften: a burst carries no information, so under reduced motion
+    // the pieces stay where they are and invisible. Done in CSS rather than by
+    // branching in JS so the decision sits on the same media query as every
+    // preset, instead of on a hook that has to guess before hydration.
+    _motionReduce: { animationName: 'none', opacity: 0 },
+};
+
+export { confettiPiece };
+//# sourceMappingURL=Confetti.styles.mjs.map

package/dist/components/Confetti/Confetti.styles.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Confetti.styles.mjs","sources":["../../../src/components/Confetti/Confetti.styles.ts"],"sourcesContent":[null],"names":[],"mappings":";AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4BG;AACI,MAAM,aAAa,GAAsB;AAC9C,IAAA,QAAQ,EAAE,UAAU;AACpB,IAAA,GAAG,EAAE,GAAG;;;;;AAKR,IAAA,YAAY,EAAE,GAAG;AACjB,IAAA,aAAa,EAAE,eAAe;AAC9B,IAAA,iBAAiB,EACf,+EAA+E;AACjF,IAAA,uBAAuB,EAAE,QAAQ;;;;;;;;AAQjC,IAAA,iBAAiB,EAAE,MAAM;;;;;IAKzB,aAAa,EAAE,EAAE,aAAa,EAAE,MAAM,EAAE,OAAO,EAAE,CAAC,EAAE;;;;;"}

package/dist/components/Confetti/Confetti.types.d.ts

@@ -0,0 +1,13 @@
+import type { BoxProps } from '@chakra-ui/react';
+export interface ConfettiProps extends BoxProps {
+    /** How many pieces. Defaults to 50. */
+    pieceCount?: number;
+    /** Colour token names to pick from. Defaults to the palette's five accents. */
+    colors?: string[];
+    /**
+     * Changes the scatter. The generator is seeded rather than `Math.random()` so
+     * one burst holds still across re-renders; pass a new seed to re-scatter.
+     */
+    seed?: number;
+}
+//# sourceMappingURL=Confetti.types.d.ts.map

package/dist/components/Confetti/Confetti.types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Confetti.types.d.ts","sourceRoot":"","sources":["../../../src/components/Confetti/Confetti.types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AAEjD,MAAM,WAAW,aAAc,SAAQ,QAAQ;IAC7C,uCAAuC;IACvC,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,+EAA+E;IAC/E,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC;IAClB;;;OAGG;IACH,IAAI,CAAC,EAAE,MAAM,CAAC;CACf"}

package/dist/components/Confetti/index.d.ts

@@ -0,0 +1,3 @@
+export { Confetti } from './Confetti';
+export type { ConfettiProps } from './Confetti.types';
+//# sourceMappingURL=index.d.ts.map

package/dist/components/Confetti/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/components/Confetti/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AACtC,YAAY,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC"}

package/dist/components/Container/Container.d.ts

@@ -1,5 +1,4 @@
-import { ContainerProps } from '@chakra-ui/react';
-export declare const Container: ({ style, disableResponsive, ...rest }: ContainerProps & {
-    disableResponsive?: boolean;
-}) => import("react/jsx-runtime").JSX.Element;
+import { ContainerOwnProps } from './Container.types';
+/** Type-level polymorphism over the same runtime — see `polymorphic`. */
+export declare const Container: import("../..").PolymorphicComponent<ContainerOwnProps, "div">;
 //# sourceMappingURL=Container.d.ts.map

package/dist/components/Container/Container.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Container.d.ts","sourceRoot":"","sources":["../../../src/components/Container/Container.tsx"],"names":[],"mappings":"AACA,OAAO,EAAgC,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAIhF,eAAO,MAAM,SAAS,GAAI,uCAIvB,cAAc,GAAG;IAAE,iBAAiB,CAAC,EAAE,OAAO,CAAA;CAAE,4CAWlD,CAAC"}
+{"version":3,"file":"Container.d.ts","sourceRoot":"","sources":["../../../src/components/Container/Container.tsx"],"names":[],"mappings":"AAIA,OAAO,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAC;AAsBtD,yEAAyE;AACzE,eAAO,MAAM,SAAS,gEAAuD,CAAC"}

package/dist/components/Container/Container.js

@@ -3,15 +3,19 @@
 
 var jsxRuntime = require('react/jsx-runtime');
 var react = require('@chakra-ui/react');
+var polymorphic = require('../../types/polymorphic.js');
 var useContainerSize = require('./useContainerSize.js');
 
-const Container = ({ style, disableResponsive, ...rest }) => {
+const ContainerImpl = ({ style, disableResponsive, ...rest }) => {
     const containerSize = useContainerSize.default();
     return (jsxRuntime.jsx(react.Container, { style: {
             ...style,
             ...(disableResponsive ? {} : { minWidth: `${containerSize}px` }),
         }, ...rest }));
 };
+ContainerImpl.displayName = 'Container';
+/** Type-level polymorphism over the same runtime — see `polymorphic`. */
+const Container = polymorphic.polymorphic(ContainerImpl);
 
 exports.Container = Container;
 //# sourceMappingURL=Container.js.map

package/dist/components/Container/Container.js.map

@@ -1 +1 @@
-{"version":3,"file":"Container.js","sources":["../../../src/components/Container/Container.tsx"],"sourcesContent":[null],"names":["useContainerSize","_jsx","ChakraContainer"],"mappings":";;;;;;;AAKO,MAAM,SAAS,GAAG,CAAC,EACxB,KAAK,EACL,iBAAiB,EACjB,GAAG,IAAI,EAC0C,KAAI;AACrD,IAAA,MAAM,aAAa,GAAGA,wBAAgB,EAAE;AACxC,IAAA,QACEC,cAAA,CAACC,eAAe,EAAA,EACd,KAAK,EAAE;AACL,YAAA,GAAG,KAAK;AACR,YAAA,IAAI,iBAAiB,GAAG,EAAE,GAAG,EAAE,QAAQ,EAAE,CAAA,EAAG,aAAa,CAAA,EAAA,CAAI,EAAE,CAAC;SACjE,EAAA,GACG,IAAI,EAAA,CACR;AAEN;;;;"}
+{"version":3,"file":"Container.js","sources":["../../../src/components/Container/Container.tsx"],"sourcesContent":[null],"names":["useContainerSize","_jsx","ChakraContainer","polymorphic"],"mappings":";;;;;;;;AAOA,MAAM,aAAa,GAAG,CAAC,EACrB,KAAK,EACL,iBAAiB,EACjB,GAAG,IAAI,EACW,KAAI;AACtB,IAAA,MAAM,aAAa,GAAGA,wBAAgB,EAAE;AACxC,IAAA,QACEC,cAAA,CAACC,eAAe,EAAA,EACd,KAAK,EAAE;AACL,YAAA,GAAG,KAAK;AACR,YAAA,IAAI,iBAAiB,GAAG,EAAE,GAAG,EAAE,QAAQ,EAAE,CAAA,EAAG,aAAa,CAAA,EAAA,CAAI,EAAE,CAAC;SACjE,EAAA,GACG,IAAI,EAAA,CACR;AAEN,CAAC;AAED,aAAa,CAAC,WAAW,GAAG,WAAW;AAEvC;MACa,SAAS,GAAGC,uBAAW,CAA2B,aAAa;;;;"}