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

package/codemods/5.0/token-renames.js

@@ -0,0 +1,231 @@
+/**
+ * logician-ui 5.0 codemod — token-renames
+ *
+ * Renames deprecated 4.x colour token names inside string literals, JSX string
+ * attributes and template-literal quasis, using src/theme/deprecatedColorTokens.json
+ * — the same file the theme builds its aliases from and the
+ * `logician-ui/no-deprecated-tokens` ESLint rule warns with, and with the same
+ * token boundaries as that rule:
+ *
+ *   'primary.lightest'                → 'primary.wash'
+ *   'slate.800'                       → 'neutral.9'   ('slate.1000' is its own token)
+ *   'var(--chakra-colors-slate-300)'  → 'var(--chakra-colors-neutral-5)'
+ *   'gray.300'                        → 'neutral.5'   (removedPrimitives.gray)
+ *   'fg.accent'                       → 'primary.main', except `color` on a
+ *                                       <Link>/<a> element → 'fg.link'
+ *
+ * Not renamed, reported instead: the other removed raw primitives (blue.N,
+ * violet.N, rose.N, gold.N, green.N, grayDark.N, purple/red/yellow.N) — their
+ * replacement depends on what the colour is for — and token names used as
+ * object keys or computed member access (`theme.colors['slate.800']`) — theme
+ * definitions, where renaming changes what the key defines or reads.
+ * Type-level literals (`type T = 'slate.800'`) are skipped, as in the rule.
+ */
+'use strict';
+
+const data = require('../../src/theme/deprecatedColorTokens.json');
+const {
+  setStringLiteral,
+  lineOf,
+  textOf,
+  createReporter,
+} = require('./lib/shared');
+
+const NAME = 'token-renames';
+
+const ALIASES = data.aliases;
+const GRAY = data.removedPrimitives.gray;
+const FAMILIES = data.removedPrimitives.families;
+
+const esc = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+/**
+ * Token path → the name Chakra gives its CSS variable: dots become dashes and
+ * camelCase segments are kebab-cased (`primary.fillStrong` → `primary-fill-strong`,
+ * `grayDark.200` → `gray-dark-200`), as Chakra's own `dashCase` does. Used for
+ * both the names we match and the names we write — see src/theme/cssVarNames.test.ts.
+ */
+const kebab = (s) =>
+  s.replace(/\./g, '-').replace(/[A-Z]/g, (c) => `-${c.toLowerCase()}`);
+const keys = Object.keys(ALIASES).sort((a, b) => b.length - a.length);
+const dotted = keys.map(esc).join('|');
+const dashedToKey = new Map(keys.map((k) => [kebab(k), k]));
+const dashed = [...dashedToKey.keys()]
+  .sort((a, b) => b.length - a.length)
+  .map(esc)
+  .join('|');
+const fam = FAMILIES.map(esc).join('|');
+const famDashedToName = new Map(FAMILIES.map((f) => [kebab(f), f]));
+const famDashed = [...famDashedToName.keys()]
+  .sort((a, b) => b.length - a.length)
+  .map(esc)
+  .join('|');
+
+// Same boundaries as eslint/rules/no-deprecated-tokens.js. A dotted name must
+// not be part of a longer path (`foo.primary.light`, `primary.lighter`), with
+// one exception: Chakra's own token references spell the path with a
+// `colors.` prefix — `{colors.success.main}` in a value string,
+// `token('colors.success.main')`, or a string that is exactly
+// `'colors.success.main'`. So `colors.` is accepted (and kept) when it starts
+// the string or follows `{`, a quote or `token(`.
+const PREFIX = `(?:(?<=^|[{'"\`]|token\\()(colors\\.)|(?<![\\w.-]))`;
+const ALIAS_RE = new RegExp(
+  `${PREFIX}(${dotted})(?![\\w-])|--chakra-colors-(${dashed})(?![\\w-])`,
+  'g'
+);
+const PRIMITIVE_RE = new RegExp(
+  `${PREFIX}(${fam})\\.(\\d+)(?![\\w.-])|--chakra-colors-(${famDashed})-(\\d+)(?![\\w-])`,
+  'g'
+);
+
+const LINK_ELEMENTS = new Set(['Link', 'a']);
+
+/**
+ * Rewrite one string. `ctx.linkColor` = it is the `color` attribute of a
+ * <Link>/<a>. Returns { text, renamed: [[from,to]], primitives: [name] }.
+ */
+const rewrite = (text, ctx = {}) => {
+  const renamed = [];
+  const primitives = [];
+  let out = text.replace(ALIAS_RE, (m, prefix, dot, dash) => {
+    const key = dot || dashedToKey.get(dash);
+    let to = ALIASES[key];
+    if (key === 'fg.accent' && ctx.linkColor) to = 'fg.link';
+    const repl = dot ? `${prefix || ''}${to}` : `--chakra-colors-${kebab(to)}`;
+    renamed.push([m, repl]);
+    return repl;
+  });
+  out = out.replace(PRIMITIVE_RE, (m, prefix, f1, s1, f2, s2) => {
+    const family = f1 || famDashedToName.get(f2);
+    const step = s1 || s2;
+    if (family === 'gray' && GRAY[step]) {
+      const to = GRAY[step];
+      const repl = f1 ? `${prefix || ''}${to}` : `--chakra-colors-${kebab(to)}`;
+      renamed.push([m, repl]);
+      return repl;
+    }
+    primitives.push(m);
+    return m;
+  });
+  return { text: out, renamed, primitives };
+};
+
+const isTypeLevel = (path) => {
+  for (let p = path.parent; p; p = p.parent) {
+    const t = p.node.type;
+    if (t === 'TSLiteralType') return true;
+    if (!t.startsWith('TS') && t !== 'TemplateLiteral') return false;
+  }
+  return false;
+};
+
+/** JSX attribute name + element name around a string, if any. */
+const jsxContext = (path) => {
+  let p = path.parent;
+  if (p && p.node.type === 'JSXExpressionContainer') p = p.parent;
+  if (!p || p.node.type !== 'JSXAttribute') return null;
+  const attr = p.node.name && p.node.name.name;
+  const opening = p.parent && p.parent.node;
+  const el =
+    opening && opening.name && opening.name.type === 'JSXIdentifier'
+      ? opening.name.name
+      : null;
+  return { attr, el };
+};
+
+function transform(file, api, options) {
+  const j = api.jscodeshift;
+  const root = j(file.source);
+  const reporter =
+    (options && options.__reporter) || createReporter(api, file, NAME);
+  let renames = 0;
+
+  const reportPrimitives = (node, names) => {
+    for (const name of names) {
+      reporter.site({
+        line: lineOf(node),
+        component: '-',
+        prop: name,
+        kind: 'primitive',
+        note: 'raw 4.x primitive removed in 5.0 — pick primary.*/neutral.N/status/category by use',
+        source: textOf(j, file, node),
+      });
+    }
+  };
+
+  const handleString = (path, node, value, apply) => {
+    if (typeof value !== 'string' || !value) return;
+    if (isTypeLevel(path)) return;
+    const parent = path.parent && path.parent.node;
+    if (parent && parent.type === 'ImportDeclaration') return;
+    const isKey =
+      (parent &&
+        (parent.type === 'ObjectProperty' ||
+          parent.type === 'Property' ||
+          parent.type === 'TSPropertySignature' ||
+          parent.type === 'ClassProperty') &&
+        parent.key === node) ||
+      ((parent.type === 'MemberExpression' ||
+        parent.type === 'OptionalMemberExpression') &&
+        parent.computed &&
+        parent.property === node);
+    const ctx = jsxContext(path);
+    const linkColor = !!(
+      ctx &&
+      ctx.attr === 'color' &&
+      LINK_ELEMENTS.has(ctx.el)
+    );
+    const r = rewrite(value, { linkColor });
+    if (isKey) {
+      for (const [from, to] of r.renamed) {
+        reporter.site({
+          line: lineOf(node),
+          component: '-',
+          prop: from,
+          kind: 'key',
+          note: `object key / computed access not renamed (→ ${to}?)`,
+          source: textOf(j, file, parent),
+        });
+      }
+      reportPrimitives(node, r.primitives);
+      return;
+    }
+    reportPrimitives(node, r.primitives);
+    if (r.renamed.length) {
+      apply(r.text);
+      renames += r.renamed.length;
+    }
+  };
+
+  // Collect before mutating: setStringLiteral turns nodes into `Literal`s.
+  const babelStrings = root.find(j.StringLiteral).paths();
+  // Other parsers (babel with estree, flow) yield ESTree `Literal`.
+  const estreeStrings = root
+    .find(j.Literal)
+    .filter(
+      (p) => p.node.type === 'Literal' && typeof p.node.value === 'string'
+    )
+    .paths();
+  for (const path of [...babelStrings, ...estreeStrings]) {
+    handleString(path, path.node, path.node.value, (t) =>
+      setStringLiteral(path.node, t)
+    );
+  }
+  root.find(j.TemplateElement).forEach((path) => {
+    const node = path.node;
+    // Rewrite `raw` (what is printed); recompute `cooked` from the same edit.
+    const raw = node.value.raw;
+    handleString(path, node, raw, (t) => {
+      const cooked = rewrite(node.value.cooked || '', {}).text;
+      node.value = { raw: t, cooked };
+    });
+  });
+
+  if (!renames) return undefined;
+  reporter.count('tokens renamed', renames);
+  return root.toSource();
+}
+
+module.exports = transform;
+module.exports.parser = 'tsx';
+module.exports.rewrite = rewrite;
+module.exports.kebab = kebab;

package/codemods/vitest.config.ts

@@ -0,0 +1,22 @@
+import path from 'path';
+import { defineConfig } from 'vitest/config';
+
+/**
+ * Codemod and ESLint-rule tests only. The root vitest.config.ts covers
+ * `src/**` with jsdom and React; the codemods (run by jscodeshift) and the
+ * eslint/ rules are Node-only CommonJS, so they get their own small config:
+ *
+ *   npx vitest run --config codemods/vitest.config.ts
+ */
+export default defineConfig({
+  root: path.resolve(__dirname, '..'),
+  test: {
+    environment: 'node',
+    globals: false,
+    include: ['codemods/**/*.test.ts', 'eslint/**/*.test.ts'],
+    exclude: ['node_modules', 'dist', 'codemods/**/__testfixtures__/**'],
+    testTimeout: 30000,
+  },
+  // The parity tests import the runtime legacy mappers from src/.
+  resolve: { alias: { '@': path.resolve(__dirname, '../src') } },
+});

package/dist/components/Appear/Appear.d.ts

@@ -0,0 +1,45 @@
+import { AppearProps } from './Appear.types';
+/**
+ * Brings an element in on mount — a fade, plus an optional scale (a *stamp*
+ * landing on something) or vertical travel (content *arriving*).
+ *
+ * ## Which of the three entrances this is
+ *
+ * The library has three, and they are not interchangeable:
+ *
+ * - `animationStyle="presence"` — a part that **has both states**. Menus,
+ *   popovers, modals: the node stays mounted and Chakra flips `_open` /
+ *   `_closed`, so it can animate *out* as well as in.
+ * - `staggerProps(index)` — items of **one list**, where the index is the
+ *   cadence and the whole point is the rhythm between siblings.
+ * - `Appear` — a **single element entering once**, on its own schedule, usually
+ *   as a response to something the reader just did. The delay is hand-set per
+ *   call site because there is no list to derive it from.
+ *
+ * The rule of thumb: if the element can close, use `presence`; if it has
+ * siblings arriving with it, use `stagger`; otherwise this.
+ *
+ * ## What it does not do
+ *
+ * It does not animate out. CSS cannot animate an element that is being removed
+ * from the DOM, which is exactly the gap `presence` fills by keeping the node
+ * mounted. FactChat's version accepts an `exit` too, but only inside an
+ * `AnimatePresence` ancestor — standalone it is a no-op there as well, so
+ * nothing that actually ran is lost in the port.
+ *
+ * ## What it puts in the DOM
+ *
+ * **One `div` around `children`**, and layout props land on that wrapper rather
+ * than on the child. Usually the same result — but the child is no longer a
+ * *direct* child of what surrounds it, so animate the inner element instead of
+ * wrapping when the parent needs its children directly: a `<tr>` needs `<td>`s,
+ * and Ark parts (`Menu.List`, `Tree`) walk their own children for focus and
+ * typeahead.
+ *
+ * ```tsx
+ * <Appear scaleFrom={0.5}>✓</Appear>
+ * <Appear rise={6} delayMs={120}>정답입니다</Appear>
+ * ```
+ */
+export declare const Appear: import("react").ForwardRefExoticComponent<AppearProps & import("react").RefAttributes<HTMLDivElement>>;
+//# sourceMappingURL=Appear.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Appear.d.ts","sourceRoot":"","sources":["../../../src/components/Appear/Appear.tsx"],"names":[],"mappings":"AAMA,OAAO,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAE7C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AACH,eAAO,MAAM,MAAM,wGAgClB,CAAC"}

package/dist/components/Appear/Appear.js

@@ -0,0 +1,61 @@
+"use client";
+'use strict';
+
+var jsxRuntime = require('react/jsx-runtime');
+var React = require('react');
+var react = require('@chakra-ui/react');
+var mergeCss = require('../../utils/mergeCss.js');
+var Appear_styles = require('./Appear.styles.js');
+
+/**
+ * Brings an element in on mount — a fade, plus an optional scale (a *stamp*
+ * landing on something) or vertical travel (content *arriving*).
+ *
+ * ## Which of the three entrances this is
+ *
+ * The library has three, and they are not interchangeable:
+ *
+ * - `animationStyle="presence"` — a part that **has both states**. Menus,
+ *   popovers, modals: the node stays mounted and Chakra flips `_open` /
+ *   `_closed`, so it can animate *out* as well as in.
+ * - `staggerProps(index)` — items of **one list**, where the index is the
+ *   cadence and the whole point is the rhythm between siblings.
+ * - `Appear` — a **single element entering once**, on its own schedule, usually
+ *   as a response to something the reader just did. The delay is hand-set per
+ *   call site because there is no list to derive it from.
+ *
+ * The rule of thumb: if the element can close, use `presence`; if it has
+ * siblings arriving with it, use `stagger`; otherwise this.
+ *
+ * ## What it does not do
+ *
+ * It does not animate out. CSS cannot animate an element that is being removed
+ * from the DOM, which is exactly the gap `presence` fills by keeping the node
+ * mounted. FactChat's version accepts an `exit` too, but only inside an
+ * `AnimatePresence` ancestor — standalone it is a no-op there as well, so
+ * nothing that actually ran is lost in the port.
+ *
+ * ## What it puts in the DOM
+ *
+ * **One `div` around `children`**, and layout props land on that wrapper rather
+ * than on the child. Usually the same result — but the child is no longer a
+ * *direct* child of what surrounds it, so animate the inner element instead of
+ * wrapping when the parent needs its children directly: a `<tr>` needs `<td>`s,
+ * and Ark parts (`Menu.List`, `Tree`) walk their own children for focus and
+ * typeahead.
+ *
+ * ```tsx
+ * <Appear scaleFrom={0.5}>✓</Appear>
+ * <Appear rise={6} delayMs={120}>정답입니다</Appear>
+ * ```
+ */
+const Appear = React.forwardRef(({ scaleFrom, rise, delayMs, durationMs, children, css, ...rest }, ref) => (jsxRuntime.jsx(react.Box, { ref: ref, ...rest, css: mergeCss.mergeCss(Appear_styles.appearIn, 
+    // Omitted props leave the keyframe's identity defaults in place, so one
+    // keyframe serves a plain fade, a stamp, an arrival, or all three.
+    scaleFrom === undefined ? undefined : { '--appear-scale': scaleFrom }, rise === undefined ? undefined : { '--appear-rise': `${rise}px` }, delayMs === undefined ? undefined : { animationDelay: `${delayMs}ms` }, durationMs === undefined
+        ? undefined
+        : { animationDuration: `${durationMs}ms` }, css), children: children })));
+Appear.displayName = 'Appear';
+
+exports.Appear = Appear;
+//# sourceMappingURL=Appear.js.map

package/dist/components/Appear/Appear.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Appear.js","sources":["../../../src/components/Appear/Appear.tsx"],"sourcesContent":[null],"names":["forwardRef","_jsx","Box","mergeCss","appearIn"],"mappings":";;;;;;;;;AAQA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAyCG;AACI,MAAM,MAAM,GAAGA,gBAAU,CAC9B,CACE,EACE,SAAS,EACT,IAAI,EACJ,OAAO,EACP,UAAU,EACV,QAAQ,EACR,GAAG,EACH,GAAG,IAAI,EACK,EACd,GAAkC,MAElCC,eAACC,SAAG,EAAA,EACF,GAAG,EAAE,GAAG,KACJ,IAAI,EACR,GAAG,EAAEC,iBAAQ,CACXC,sBAAQ;;;IAGR,SAAS,KAAK,SAAS,GAAG,SAAS,GAAG,EAAE,gBAAgB,EAAE,SAAS,EAAE,EACrE,IAAI,KAAK,SAAS,GAAG,SAAS,GAAG,EAAE,eAAe,EAAE,CAAA,EAAG,IAAI,CAAA,EAAA,CAAI,EAAE,EACjE,OAAO,KAAK,SAAS,GAAG,SAAS,GAAG,EAAE,cAAc,EAAE,CAAA,EAAG,OAAO,CAAA,EAAA,CAAI,EAAE,EACtE,UAAU,KAAK;AACb,UAAE;AACF,UAAE,EAAE,iBAAiB,EAAE,CAAA,EAAG,UAAU,CAAA,EAAA,CAAI,EAAE,EAC5C,GAAG,CACJ,EAAA,QAAA,EAEA,QAAQ,EAAA,CACL,CACP;AAGH,MAAM,CAAC,WAAW,GAAG,QAAQ;;;;"}

package/dist/components/Appear/Appear.mjs

@@ -0,0 +1,59 @@
+"use client";
+import { jsx } from 'react/jsx-runtime';
+import { forwardRef } from 'react';
+import { Box } from '@chakra-ui/react';
+import { mergeCss } from '../../utils/mergeCss.mjs';
+import { appearIn } from './Appear.styles.mjs';
+
+/**
+ * Brings an element in on mount — a fade, plus an optional scale (a *stamp*
+ * landing on something) or vertical travel (content *arriving*).
+ *
+ * ## Which of the three entrances this is
+ *
+ * The library has three, and they are not interchangeable:
+ *
+ * - `animationStyle="presence"` — a part that **has both states**. Menus,
+ *   popovers, modals: the node stays mounted and Chakra flips `_open` /
+ *   `_closed`, so it can animate *out* as well as in.
+ * - `staggerProps(index)` — items of **one list**, where the index is the
+ *   cadence and the whole point is the rhythm between siblings.
+ * - `Appear` — a **single element entering once**, on its own schedule, usually
+ *   as a response to something the reader just did. The delay is hand-set per
+ *   call site because there is no list to derive it from.
+ *
+ * The rule of thumb: if the element can close, use `presence`; if it has
+ * siblings arriving with it, use `stagger`; otherwise this.
+ *
+ * ## What it does not do
+ *
+ * It does not animate out. CSS cannot animate an element that is being removed
+ * from the DOM, which is exactly the gap `presence` fills by keeping the node
+ * mounted. FactChat's version accepts an `exit` too, but only inside an
+ * `AnimatePresence` ancestor — standalone it is a no-op there as well, so
+ * nothing that actually ran is lost in the port.
+ *
+ * ## What it puts in the DOM
+ *
+ * **One `div` around `children`**, and layout props land on that wrapper rather
+ * than on the child. Usually the same result — but the child is no longer a
+ * *direct* child of what surrounds it, so animate the inner element instead of
+ * wrapping when the parent needs its children directly: a `<tr>` needs `<td>`s,
+ * and Ark parts (`Menu.List`, `Tree`) walk their own children for focus and
+ * typeahead.
+ *
+ * ```tsx
+ * <Appear scaleFrom={0.5}>✓</Appear>
+ * <Appear rise={6} delayMs={120}>정답입니다</Appear>
+ * ```
+ */
+const Appear = forwardRef(({ scaleFrom, rise, delayMs, durationMs, children, css, ...rest }, ref) => (jsx(Box, { ref: ref, ...rest, css: mergeCss(appearIn, 
+    // Omitted props leave the keyframe's identity defaults in place, so one
+    // keyframe serves a plain fade, a stamp, an arrival, or all three.
+    scaleFrom === undefined ? undefined : { '--appear-scale': scaleFrom }, rise === undefined ? undefined : { '--appear-rise': `${rise}px` }, delayMs === undefined ? undefined : { animationDelay: `${delayMs}ms` }, durationMs === undefined
+        ? undefined
+        : { animationDuration: `${durationMs}ms` }, css), children: children })));
+Appear.displayName = 'Appear';
+
+export { Appear };
+//# sourceMappingURL=Appear.mjs.map

package/dist/components/Appear/Appear.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Appear.mjs","sources":["../../../src/components/Appear/Appear.tsx"],"sourcesContent":[null],"names":["_jsx"],"mappings":";;;;;;;AAQA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAyCG;AACI,MAAM,MAAM,GAAG,UAAU,CAC9B,CACE,EACE,SAAS,EACT,IAAI,EACJ,OAAO,EACP,UAAU,EACV,QAAQ,EACR,GAAG,EACH,GAAG,IAAI,EACK,EACd,GAAkC,MAElCA,IAAC,GAAG,EAAA,EACF,GAAG,EAAE,GAAG,KACJ,IAAI,EACR,GAAG,EAAE,QAAQ,CACX,QAAQ;;;IAGR,SAAS,KAAK,SAAS,GAAG,SAAS,GAAG,EAAE,gBAAgB,EAAE,SAAS,EAAE,EACrE,IAAI,KAAK,SAAS,GAAG,SAAS,GAAG,EAAE,eAAe,EAAE,CAAA,EAAG,IAAI,CAAA,EAAA,CAAI,EAAE,EACjE,OAAO,KAAK,SAAS,GAAG,SAAS,GAAG,EAAE,cAAc,EAAE,CAAA,EAAG,OAAO,CAAA,EAAA,CAAI,EAAE,EACtE,UAAU,KAAK;AACb,UAAE;AACF,UAAE,EAAE,iBAAiB,EAAE,CAAA,EAAG,UAAU,CAAA,EAAA,CAAI,EAAE,EAC5C,GAAG,CACJ,EAAA,QAAA,EAEA,QAAQ,EAAA,CACL,CACP;AAGH,MAAM,CAAC,WAAW,GAAG,QAAQ;;;;"}

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

@@ -0,0 +1,18 @@
+import type { SystemStyleObject } from '@chakra-ui/react';
+/**
+ * A mount entrance.
+ *
+ * `overshoot`, and that is the whole reason this is not just a fade: an entrance
+ * that settles slightly past its resting state reads as something *landing*,
+ * which is what a stamp is. On `standard` the same scale reads as a rendering
+ * hiccup — the curve is doing more work here than the amplitude.
+ *
+ * `motion.base`, the default for anything arriving.
+ *
+ * Under reduced motion the fade stays and the movement goes. The element still
+ * has to become visible — it was not there a moment ago — but neither the scale
+ * nor the travel carries information, so both are dropped by resetting their
+ * custom properties to identity rather than by killing the animation.
+ */
+export declare const appearIn: SystemStyleObject;
+//# sourceMappingURL=Appear.styles.d.ts.map

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

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

package/dist/components/Appear/Appear.styles.js

@@ -0,0 +1,32 @@
+"use client";
+'use strict';
+
+/**
+ * A mount entrance.
+ *
+ * `overshoot`, and that is the whole reason this is not just a fade: an entrance
+ * that settles slightly past its resting state reads as something *landing*,
+ * which is what a stamp is. On `standard` the same scale reads as a rendering
+ * hiccup — the curve is doing more work here than the amplitude.
+ *
+ * `motion.base`, the default for anything arriving.
+ *
+ * Under reduced motion the fade stays and the movement goes. The element still
+ * has to become visible — it was not there a moment ago — but neither the scale
+ * nor the travel carries information, so both are dropped by resetting their
+ * custom properties to identity rather than by killing the animation.
+ */
+const appearIn = {
+    animationName: 'appear-in',
+    animationDuration: 'motion.base',
+    animationTimingFunction: 'overshoot',
+    animationFillMode: 'both',
+    _motionReduce: {
+        '--appear-scale': '1',
+        '--appear-rise': '0px',
+        animationTimingFunction: 'standard',
+    },
+};
+
+exports.appearIn = appearIn;
+//# sourceMappingURL=Appear.styles.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Appear.styles.js","sources":["../../../src/components/Appear/Appear.styles.ts"],"sourcesContent":[null],"names":[],"mappings":";;;AAEA;;;;;;;;;;;;;;AAcG;AACI,MAAM,QAAQ,GAAsB;AACzC,IAAA,aAAa,EAAE,WAAW;AAC1B,IAAA,iBAAiB,EAAE,aAAa;AAChC,IAAA,uBAAuB,EAAE,WAAW;AACpC,IAAA,iBAAiB,EAAE,MAAM;AACzB,IAAA,aAAa,EAAE;AACb,QAAA,gBAAgB,EAAE,GAAG;AACrB,QAAA,eAAe,EAAE,KAAK;AACtB,QAAA,uBAAuB,EAAE,UAAU;AACpC,KAAA;;;;;"}

package/dist/components/Appear/Appear.styles.mjs

@@ -0,0 +1,30 @@
+"use client";
+/**
+ * A mount entrance.
+ *
+ * `overshoot`, and that is the whole reason this is not just a fade: an entrance
+ * that settles slightly past its resting state reads as something *landing*,
+ * which is what a stamp is. On `standard` the same scale reads as a rendering
+ * hiccup — the curve is doing more work here than the amplitude.
+ *
+ * `motion.base`, the default for anything arriving.
+ *
+ * Under reduced motion the fade stays and the movement goes. The element still
+ * has to become visible — it was not there a moment ago — but neither the scale
+ * nor the travel carries information, so both are dropped by resetting their
+ * custom properties to identity rather than by killing the animation.
+ */
+const appearIn = {
+    animationName: 'appear-in',
+    animationDuration: 'motion.base',
+    animationTimingFunction: 'overshoot',
+    animationFillMode: 'both',
+    _motionReduce: {
+        '--appear-scale': '1',
+        '--appear-rise': '0px',
+        animationTimingFunction: 'standard',
+    },
+};
+
+export { appearIn };
+//# sourceMappingURL=Appear.styles.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Appear.styles.mjs","sources":["../../../src/components/Appear/Appear.styles.ts"],"sourcesContent":[null],"names":[],"mappings":";AAEA;;;;;;;;;;;;;;AAcG;AACI,MAAM,QAAQ,GAAsB;AACzC,IAAA,aAAa,EAAE,WAAW;AAC1B,IAAA,iBAAiB,EAAE,aAAa;AAChC,IAAA,uBAAuB,EAAE,WAAW;AACpC,IAAA,iBAAiB,EAAE,MAAM;AACzB,IAAA,aAAa,EAAE;AACb,QAAA,gBAAgB,EAAE,GAAG;AACrB,QAAA,eAAe,EAAE,KAAK;AACtB,QAAA,uBAAuB,EAAE,UAAU;AACpC,KAAA;;;;;"}

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

@@ -0,0 +1,18 @@
+import type { BoxProps } from '@chakra-ui/react';
+export interface AppearProps extends Omit<BoxProps, 'scale' | 'translate'> {
+    /**
+     * Scale to grow from — for a **stamp**: a mark that lands on something, like a
+     * ✓ on a correct answer or a reward medallion. Omit for a plain fade.
+     */
+    scaleFrom?: number;
+    /**
+     * Vertical travel in px — for content **arriving**: a row, a card, a banner.
+     * Positive values rise from below.
+     */
+    rise?: number;
+    /** Delay before it appears. */
+    delayMs?: number;
+    /** Defaults to `motion.base` (300ms). */
+    durationMs?: number;
+}
+//# sourceMappingURL=Appear.types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Appear.types.d.ts","sourceRoot":"","sources":["../../../src/components/Appear/Appear.types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AAEjD,MAAM,WAAW,WAAY,SAAQ,IAAI,CAAC,QAAQ,EAAE,OAAO,GAAG,WAAW,CAAC;IACxE;;;OAGG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB;;;OAGG;IACH,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,+BAA+B;IAC/B,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,yCAAyC;IACzC,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB"}

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/components/Appear/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AAClC,YAAY,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC"}

package/dist/components/Avatar/Avatar.d.ts

@@ -1,12 +1,49 @@
 import { Avatar as ChakraAvatar, AvatarRootProps as ChakraAvatarRootProps } from '@chakra-ui/react';
+import { SystemHue } from '@/theme/colors';
 export type { AvatarFallbackProps, AvatarGroupProps, AvatarIconProps, AvatarImageProps, AvatarRootProps, } from '@chakra-ui/react';
 export type AvatarProps = ChakraAvatarRootProps & {
     src?: string;
     name?: string;
+    /**
+     * Overrides the hue the fallback initials are tinted — by default a stable
+     * hash of `name` picks one of the 12 `category.*` hues (see
+     * {@link hueForName}), so the same person reads as the same colour
+     * everywhere without a colour being stored anywhere. With no `name` and no
+     * `colorHue` the fallback is the neutral pair
+     * (`bg.muted` / `secondary.fgStrong`), not a hue.
+     */
+    colorHue?: SystemHue;
+};
+/**
+ * A stable hash of `name` into one of `SYSTEM_HUE_NAMES`, so a given name
+ * always lands on the same hue (no lookup table, nothing to keep in sync) and
+ * different names spread across the 12-hue wheel instead of clustering on
+ * one. Decorative only — `category.*` carries no status meaning — so a
+ * collision between two people's initials is a cosmetic coincidence, not a
+ * data bug.
+ */
+export declare function hueForName(name: string): SystemHue;
+export declare function hueForName(name: string | undefined): SystemHue | undefined;
+/**
+ * Fallback (initials / icon) colours: the person's hue when there is one,
+ * otherwise the neutral pair Badge `neutral` uses.
+ */
+export declare function avatarFallbackColors(name: string | undefined, colorHue?: SystemHue): {
+    bg: string;
+    color: string;
 };
 export declare const Avatar: import("react").ForwardRefExoticComponent<ChakraAvatar.RootProps & {
     src?: string;
     name?: string;
+    /**
+     * Overrides the hue the fallback initials are tinted — by default a stable
+     * hash of `name` picks one of the 12 `category.*` hues (see
+     * {@link hueForName}), so the same person reads as the same colour
+     * everywhere without a colour being stored anywhere. With no `name` and no
+     * `colorHue` the fallback is the neutral pair
+     * (`bg.muted` / `secondary.fgStrong`), not a hue.
+     */
+    colorHue?: SystemHue;
 } & import("react").RefAttributes<HTMLDivElement>> & {
     Root: import("react").ForwardRefExoticComponent<ChakraAvatar.RootProps & import("react").RefAttributes<HTMLDivElement>>;
     RootProvider: import("react").ForwardRefExoticComponent<import("node_modules/@chakra-ui/react/dist/types/components/avatar/avatar").AvatarRootProviderProps & import("react").RefAttributes<HTMLDivElement>>;

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

@@ -1 +1 @@
-{"version":3,"file":"Avatar.d.ts","sourceRoot":"","sources":["../../../src/components/Avatar/Avatar.tsx"],"names":[],"mappings":"AACA,OAAO,EACL,MAAM,IAAI,YAAY,EAOtB,eAAe,IAAI,qBAAqB,EAEzC,MAAM,kBAAkB,CAAC;AAE1B,YAAY,EACV,mBAAmB,EACnB,gBAAgB,EAChB,eAAe,EACf,gBAAgB,EAChB,eAAe,GAChB,MAAM,kBAAkB,CAAC;AAE1B,MAAM,MAAM,WAAW,GAAG,qBAAqB,GAAG;IAChD,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,IAAI,CAAC,EAAE,MAAM,CAAC;CACf,CAAC;AAuBF,eAAO,MAAM,MAAM;UAzBX,MAAM;WACL,MAAM;;;;;;;;;CAgCb,CAAC"}
+{"version":3,"file":"Avatar.d.ts","sourceRoot":"","sources":["../../../src/components/Avatar/Avatar.tsx"],"names":[],"mappings":"AACA,OAAO,EACL,MAAM,IAAI,YAAY,EAOtB,eAAe,IAAI,qBAAqB,EAEzC,MAAM,kBAAkB,CAAC;AAE1B,OAAO,EAAoB,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAE7D,YAAY,EACV,mBAAmB,EACnB,gBAAgB,EAChB,eAAe,EACf,gBAAgB,EAChB,eAAe,GAChB,MAAM,kBAAkB,CAAC;AAE1B,MAAM,MAAM,WAAW,GAAG,qBAAqB,GAAG;IAChD,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,IAAI,CAAC,EAAE,MAAM,CAAC;IACd;;;;;;;OAOG;IACH,QAAQ,CAAC,EAAE,SAAS,CAAC;CACtB,CAAC;AAEF;;;;;;;GAOG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,CAAC;AACpD,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,GAAG,SAAS,GAAG,SAAS,CAAC;AAgB5E;;;GAGG;AACH,wBAAgB,oBAAoB,CAClC,IAAI,EAAE,MAAM,GAAG,SAAS,EACxB,QAAQ,CAAC,EAAE,SAAS,GACnB;IAAE,EAAE,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAI/B;AA4BD,eAAO,MAAM,MAAM;UA7EX,MAAM;WACL,MAAM;IACb;;;;;;;OAOG;eACQ,SAAS;;;;;;;;;CA2EpB,CAAC"}