@12-apps/ui 6.24.7 → 6.25.0

package/src/components/form/CategorySelect/category-keyboard.ts

@@ -1,4 +1,4 @@
-import { isLeafCategory, type CategoryRowRef } from './category-tree';
+import { findGroup, type CategoryRowRef } from './category-tree';
 import type { CategoryGroup } from './CategorySelect.types';
 
 /** What a key handler is allowed to do to the panel. */
@@ -27,7 +27,7 @@ function activeRow(context: CategoryKeyContext): CategoryRowRef | undefined {
 }
 
 function groupOf(context: CategoryKeyContext, id: string): CategoryGroup | undefined {
-  return context.groups.find((group) => group.category.id === id);
+  return findGroup(context.groups, id);
 }
 
 function moveCursor(context: CategoryKeyContext, delta: number): void {
@@ -40,41 +40,37 @@ function moveCursor(context: CategoryKeyContext, delta: number): void {
   context.setActiveIndex(next);
 }
 
-/** → opens a category. On a subcategory it is a no-op: there is nothing deeper. */
+/** → opens a row that folds. On a leaf it is a no-op: there is nothing deeper. */
 function handleRight(context: CategoryKeyContext): void {
   const row = activeRow(context);
-  if (row?.kind === 'category') context.expand(row.id);
+  if (row?.branch) context.expand(row.id);
 }
 
-/** ← collapses a category, or walks a subcategory back up to its parent. */
+/** ← collapses a foldable row, or walks a leaf back up to its parent. */
 function handleLeft(context: CategoryKeyContext): void {
   const row = activeRow(context);
   if (!row) return;
-  if (row.kind === 'category') {
+  if (row.branch) {
     context.collapse(row.id);
     return;
   }
   if (!row.parentId) return;
   context.collapse(row.parentId);
-  const parentIndex = context.rows.findIndex(
-    (candidate) => candidate.kind === 'category' && candidate.id === row.parentId,
-  );
+  const parentIndex = context.rows.findIndex((candidate) => candidate.id === row.parentId);
   if (parentIndex >= 0) context.setActiveIndex(parentIndex);
 }
 
 /**
- * What a category row does when it is activated — the one answer the click, the
+ * What a FOLDABLE row does when it is activated — the one answer the click, the
  * Space key and (in single-select) Enter all take, so the three cannot disagree
  * about a row the way they did over a childless category.
  *
- * A category that is only a HEADING expands instead of marking: the row has no
- * control, so "mark" has nothing to mean there. A childless category is not a
- * heading — it is the leaf — so it marks.
+ * A row that is only a frame expands instead of marking: it has no control, so
+ * "mark" has nothing to mean there. A childless category is not a frame — it is
+ * the leaf — so it never reaches here.
  */
-function activateCategoryRow(context: CategoryKeyContext, categoryId: string): void {
-  const group = groupOf(context, categoryId);
-  if (!group) return;
-  if (!context.allowParentSelection && !isLeafCategory(group)) {
+function activateBranchRow(context: CategoryKeyContext, categoryId: string): void {
+  if (!context.allowParentSelection) {
     context.toggleExpanded(categoryId);
     return;
   }
@@ -82,19 +78,24 @@ function activateCategoryRow(context: CategoryKeyContext, categoryId: string): v
     context.pick(categoryId);
     return;
   }
-  context.toggleCategory(group);
+  const group = groupOf(context, categoryId);
+  if (group) context.toggleCategory(group);
+}
+
+/** Mark the row under the cursor — or fold it, when it is only a frame. */
+function activateRow(context: CategoryKeyContext, row: CategoryRowRef): void {
+  if (row.branch) {
+    activateBranchRow(context, row.id);
+    return;
+  }
+  if (context.single) context.pick(row.id);
+  else context.toggleSubcategory(row.id);
 }
 
 /** Space marks the row under the cursor. */
 function handleSpace(context: CategoryKeyContext): void {
   const row = activeRow(context);
-  if (!row) return;
-  if (row.kind === 'subcategory') {
-    if (context.single) context.pick(row.id);
-    else context.toggleSubcategory(row.id);
-    return;
-  }
-  activateCategoryRow(context, row.id);
+  if (row) activateRow(context, row);
 }
 
 function handleEnter(context: CategoryKeyContext): void {
@@ -103,12 +104,7 @@ function handleEnter(context: CategoryKeyContext): void {
     context.commit();
     return;
   }
-  if (!row) return;
-  if (row.kind === 'subcategory') {
-    context.pick(row.id);
-    return;
-  }
-  activateCategoryRow(context, row.id);
+  if (row) activateRow(context, row);
 }
 
 /** Key → behaviour. A map keeps this dispatch flat instead of a long if-chain. */

package/src/components/form/CategorySelect/category-tree.ts

@@ -15,40 +15,64 @@ import type {
 export function foldText(text: string): string {
   return text
     .normalize('NFD')
-    .replace(/[\u0300-\u036f]/g, '')
+    .replace(/[̀-ͯ]/g, '')
     .toLowerCase();
 }
 
 /**
- * Group a flat `parentId` list into top level + children, preserving input order.
+ * Whether following `parentId` up from `startId` ever comes back to a node it
+ * already passed.
  *
- * An option whose `parentId` names no top-level row is promoted to top level
- * rather than dropped — a category is never invisible just because its parent
- * was filtered out of the payload, or because the tree is deeper than two levels.
+ * Two levels made a cycle impossible by construction: a child was attached to a
+ * ROOT or promoted, so nothing could ever point back down. An arbitrary depth
+ * attaches every node to whichever node its `parentId` names, and a payload
+ * where two rows name each other would build a ring that every walk below —
+ * flattening, filtering, counting leaves — follows until the stack gives out. So
+ * the chain is checked rather than trusted, and a node on a ring is promoted to
+ * top level, which is what {@link buildCategoryGroups} already does with a
+ * parent it cannot resolve.
  */
-export function buildCategoryGroups(options: CategorySelectOption[]): CategoryGroup[] {
-  const roots = options.filter((option) => !option.parentId);
-  const rootIds = new Set(roots.map((root) => root.id));
-  const groups = new Map<string, CategoryGroup>(
-    roots.map((root) => [root.id, { category: root, subcategories: [] }]),
-  );
-  const orphans: CategoryGroup[] = [];
+function onParentCycle(startId: string, parents: ReadonlyMap<string, string>): boolean {
+  const seen = new Set<string>([startId]);
+  let current = parents.get(startId);
+  while (current !== undefined) {
+    if (seen.has(current)) return true;
+    seen.add(current);
+    current = parents.get(current);
+  }
+  return false;
+}
 
+/**
+ * Nest a flat `parentId` list into a tree of ANY depth, preserving input order
+ * at every level.
+ *
+ * An option whose `parentId` names nothing in the payload is promoted to top
+ * level rather than dropped — a category is never invisible just because its
+ * parent was filtered out of the response. A duplicate id keeps its first row,
+ * so a repeated payload cannot place the same node twice.
+ */
+export function buildCategoryGroups(options: CategorySelectOption[]): CategoryGroup[] {
+  const nodes = new Map<string, CategoryGroup>();
+  const parents = new Map<string, string>();
   options.forEach((option) => {
-    if (!option.parentId) return;
-    const parent = groups.get(option.parentId);
-    if (parent) {
-      parent.subcategories.push(option);
-      return;
-    }
-    if (!rootIds.has(option.id)) orphans.push({ category: option, subcategories: [] });
+    if (nodes.has(option.id)) return;
+    nodes.set(option.id, { category: option, subcategories: [] });
+    if (option.parentId && option.parentId !== option.id) parents.set(option.id, option.parentId);
   });
 
-  return [...groups.values(), ...orphans];
+  const roots: CategoryGroup[] = [];
+  nodes.forEach((node, id) => {
+    const parentId = parents.get(id);
+    const parent = parentId === undefined ? undefined : nodes.get(parentId);
+    if (parent && !onParentCycle(id, parents)) parent.subcategories.push(node);
+    else roots.push(node);
+  });
+  return roots;
 }
 
 /**
- * Whether this category IS the leaf, because nothing sits under it.
+ * Whether this node IS the leaf, because nothing sits under it.
  *
  * The leaf-only default makes a category a heading and the subcategory the thing
  * you pick — but a childless category has no subcategory to offer instead, so
@@ -62,14 +86,66 @@ export function isLeafCategory(group: CategoryGroup): boolean {
   return group.subcategories.length === 0;
 }
 
-/** Every selectable leaf id across all groups, in display order. */
+/** Every selectable leaf id across the whole tree, in display order. */
 export function collectLeafIds(groups: CategoryGroup[]): string[] {
   return groups.flatMap((group) => leavesOf(group));
 }
 
-/** The leaves a category stands for — its subcategories, or itself when childless. */
+/**
+ * The leaves a node stands for — every leaf BELOW it, or itself when childless.
+ *
+ * Recursive rather than one level down, so a category three levels deep still
+ * stands for the items at the bottom of it and not for the subcategories in
+ * between: the value a caller receives stays uniformly leaves, which is the
+ * property that lets a chip, a tri-state checkbox and `Marcar tudo` agree.
+ */
 export function leavesOf(group: CategoryGroup): string[] {
-  return isLeafCategory(group) ? [group.category.id] : group.subcategories.map((sub) => sub.id);
+  if (isLeafCategory(group)) return [group.category.id];
+  return group.subcategories.flatMap((sub) => leavesOf(sub));
+}
+
+/** Every node that can be unfolded, at any depth — what "Expandir tudo" opens. */
+export function collectBranchIds(groups: CategoryGroup[]): string[] {
+  return groups.flatMap((group) =>
+    isLeafCategory(group) ? [] : [group.category.id, ...collectBranchIds(group.subcategories)],
+  );
+}
+
+/** The node carrying `id`, searched at every depth. */
+export function findGroup(groups: CategoryGroup[], id: string): CategoryGroup | undefined {
+  for (const group of groups) {
+    if (group.category.id === id) return group;
+    const found = findGroup(group.subcategories, id);
+    if (found) return found;
+  }
+  return undefined;
+}
+
+/**
+ * The names from the top-level category down to `id`, or `null` when absent.
+ *
+ * The single-select trigger reads this back as `Pai › Filha › Item`, so a chosen
+ * row keeps the context that tells `Massas` (mercearia) from `Massas` (pratos
+ * principais) once the panel has closed over it.
+ */
+export function categoryPath(groups: CategoryGroup[], id: string): string[] | null {
+  for (const group of groups) {
+    if (group.category.id === id) return [group.category.name];
+    const below = categoryPath(group.subcategories, id);
+    if (below) return [group.category.name, ...below];
+  }
+  return null;
+}
+
+/**
+ * How many levels the deepest branch has. A flat list is 1, the classic
+ * category/subcategory tree is 2, anything more is a tree with items in it.
+ */
+export function treeDepth(groups: CategoryGroup[]): number {
+  return groups.reduce(
+    (deepest, group) => Math.max(deepest, 1 + treeDepth(group.subcategories)),
+    0,
+  );
 }
 
 export type CategoryCheckState = 'off' | 'partial' | 'on';
@@ -105,9 +181,12 @@ export function toggleLeaf(id: string, selected: ReadonlySet<string>): Set<strin
 }
 
 /**
- * Collapse a raw id set into the chips a human reads: a category that is fully
- * selected becomes ONE chip bearing the category's name, rather than one chip
- * per subcategory — "Bebidas" instead of six drinks.
+ * Collapse a raw id set into the chips a human reads: a node that is fully
+ * selected becomes ONE chip bearing its name, rather than one chip per leaf —
+ * "Bebidas" instead of six drinks.
+ *
+ * A partly-selected node hands the question down to its own children, so the
+ * chip that appears is always the DEEPEST node that is completely selected.
  */
 export function summarizeSelection(
   groups: CategoryGroup[],
@@ -117,17 +196,20 @@ export function summarizeSelection(
     const state = categoryCheckState(group, selected);
     if (state === 'off') return [];
     if (state === 'on') {
-      return [{ id: group.category.id, label: group.category.name, whole: true }];
+      // `whole` says the chip stands for MORE than itself, so it is the node
+      // having children that decides it — not the node being fully selected,
+      // which a leaf always is the moment it is picked at all.
+      return [
+        { id: group.category.id, label: group.category.name, whole: !isLeafCategory(group) },
+      ];
     }
-    return group.subcategories
-      .filter((sub) => selected.has(sub.id))
-      .map((sub) => ({ id: sub.id, label: sub.name, whole: false }));
+    return summarizeSelection(group.subcategories, selected);
   });
 }
 
 /**
- * Drop the leaves a chip stands for. A `whole` chip removes the whole category;
- * any other chip removes just that leaf.
+ * Drop the leaves a chip stands for. A chip naming a node removes everything
+ * under it; a chip naming nothing in the tree removes just that id.
  */
 export function removeChip(
   groups: CategoryGroup[],
@@ -135,7 +217,7 @@ export function removeChip(
   selected: ReadonlySet<string>,
 ): Set<string> {
   const next = new Set(selected);
-  const group = groups.find((candidate) => candidate.category.id === chipId);
+  const group = findGroup(groups, chipId);
   if (group) {
     leavesOf(group).forEach((id) => next.delete(id));
     return next;
@@ -145,23 +227,23 @@ export function removeChip(
 }
 
 /**
- * Search across BOTH levels, keeping every hit under its parent.
+ * Search every level, keeping each hit under its parents.
  *
- * A category that matches keeps all of its subcategories, so "Bebidas" shows the
- * whole group. A category that does not match keeps only the subcategories that
- * do — the hit still arrives with its parent visible above it, which is the
- * context that tells "Massas" (mercearia) from "Massas" (pratos principais).
+ * A node that matches keeps its whole subtree, so "Bebidas" shows the entire
+ * group. A node that does not match keeps only the descendants that do — the hit
+ * still arrives with its parents visible above it, which is the context that
+ * tells "Massas" (mercearia) from "Massas" (pratos principais).
  */
 export function filterCategoryGroups(groups: CategoryGroup[], query: string): CategoryGroup[] {
   const needle = foldText(query.trim());
   if (!needle) return groups;
-  return groups.flatMap((group) => {
-    if (foldText(group.category.name).includes(needle)) return [group];
-    const subcategories = group.subcategories.filter((sub) =>
-      foldText(sub.name).includes(needle),
-    );
-    return subcategories.length > 0 ? [{ category: group.category, subcategories }] : [];
-  });
+  const walk = (nodes: CategoryGroup[]): CategoryGroup[] =>
+    nodes.flatMap((node) => {
+      if (foldText(node.category.name).includes(needle)) return [node];
+      const subcategories = walk(node.subcategories);
+      return subcategories.length > 0 ? [{ category: node.category, subcategories }] : [];
+    });
+  return walk(groups);
 }
 
 /** A run of text, flagged when it is the part that matched the query. */
@@ -191,29 +273,27 @@ export function highlightSegments(text: string, query: string): HighlightSegment
 
 /** A flattened row, so keyboard navigation can walk what is actually on screen. */
 export interface CategoryRowRef {
-  kind: 'category' | 'subcategory';
   id: string;
-  /** Owning category id — lets ← jump from a subcategory back to its parent. */
+  /** 0 for a top-level category, one more for each level below it. */
+  depth: number;
+  /** True when the row has children to unfold — what → and ← act on. */
+  branch: boolean;
+  /** Owning node id — lets ← jump from a child back to its parent. */
   parentId?: string;
 }
 
-/** The visible rows, in order, honouring which categories are expanded. */
+/** The visible rows, in order, honouring which nodes are expanded. */
 export function flattenRows(
   groups: CategoryGroup[],
   isExpanded: (categoryId: string) => boolean,
 ): CategoryRowRef[] {
-  return groups.flatMap((group) => {
-    const head: CategoryRowRef = { kind: 'category', id: group.category.id };
-    if (!isExpanded(group.category.id)) return [head];
-    return [
-      head,
-      ...group.subcategories.map(
-        (sub): CategoryRowRef => ({
-          kind: 'subcategory',
-          id: sub.id,
-          parentId: group.category.id,
-        }),
-      ),
-    ];
-  });
+  const walk = (nodes: CategoryGroup[], depth: number, parentId?: string): CategoryRowRef[] =>
+    nodes.flatMap((node) => {
+      const id = node.category.id;
+      const branch = !isLeafCategory(node);
+      const row: CategoryRowRef = { id, depth, branch, ...(parentId ? { parentId } : {}) };
+      if (!branch || !isExpanded(id)) return [row];
+      return [row, ...walk(node.subcategories, depth + 1, id)];
+    });
+  return walk(groups, 0);
 }

package/src/components/form/CategorySelect/index.ts

@@ -11,9 +11,13 @@ export type {
 export {
   buildCategoryGroups,
   categoryCheckState,
+  categoryPath,
+  collectBranchIds,
   collectLeafIds,
   filterCategoryGroups,
+  findGroup,
   foldText,
   leavesOf,
   summarizeSelection,
+  treeDepth,
 } from './category-tree';

package/src/components/form/CategorySelect/useCategorySelect.ts

@@ -2,10 +2,12 @@ import { useCallback, useMemo, useRef, useState } from 'react';
 
 import {
   buildCategoryGroups,
+  collectBranchIds,
   filterCategoryGroups,
   flattenRows,
   toggleCategoryLeaves,
   toggleLeaf,
+  treeDepth,
   type CategoryRowRef,
 } from './category-tree';
 import type { CategoryGroup, CategorySelectOption } from './CategorySelect.types';
@@ -44,13 +46,20 @@ function useExpandedCategories(
     });
   }, []);
 
+  // Every foldable node at EVERY depth, so "Expandir tudo" opens the tree rather
+  // than only its first storey.
   const setAllExpanded = useCallback(
     (shouldExpand: boolean) => {
-      setExpanded(shouldExpand ? new Set(allGroups.map((g) => g.category.id)) : new Set());
+      setExpanded(shouldExpand ? new Set(collectBranchIds(allGroups)) : new Set());
     },
     [allGroups],
   );
 
+  // Opening unfolds the TOP level only. On a two-level tree that is the whole
+  // thing on show, which is what the panel has always done; on a deeper one it
+  // is the categories and their subcategories, with the items behind one more
+  // click — the alternative being the flat list the tree replaces. A search
+  // still reveals every hit: `searching` short-circuits the lookup above.
   const expandAll = useCallback((groups: CategoryGroup[]) => {
     setExpanded(new Set(groups.map((group) => group.category.id)));
   }, []);
@@ -90,6 +99,8 @@ export interface CategorySelectState extends ExpansionState, DraftState {
   visibleGroups: CategoryGroup[];
   /** All groups, unfiltered — the basis for chips and "select all". */
   allGroups: CategoryGroup[];
+  /** True when the tree runs deeper than category/subcategory. */
+  deepTree: boolean;
   rows: CategoryRowRef[];
   activeIndex: number;
   setQuery: (next: string) => void;
@@ -128,6 +139,8 @@ export function useCategorySelect({
     [allGroups, query],
   );
 
+  const deepTree = useMemo(() => treeDepth(allGroups) > 2, [allGroups]);
+
   const expansion = useExpandedCategories(allGroups, query.trim().length > 0);
   const selection = useDraftSelection(selected);
   const rows = useMemo(
@@ -161,6 +174,7 @@ export function useCategorySelect({
     query,
     visibleGroups,
     allGroups,
+    deepTree,
     rows,
     activeIndex,
     setQuery,

package/dist/chunk-2GB5CIN6.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/components/form/CategorySelect/useCategorySelect.ts"],"sourcesContent":["import { useCallback, useMemo, useRef, useState } from 'react';\n\nimport {\n  buildCategoryGroups,\n  filterCategoryGroups,\n  flattenRows,\n  toggleCategoryLeaves,\n  toggleLeaf,\n  type CategoryRowRef,\n} from './category-tree';\nimport type { CategoryGroup, CategorySelectOption } from './CategorySelect.types';\n\n/** Which categories are unfolded, and the ways that set changes. */\ninterface ExpansionState {\n  isExpanded: (categoryId: string) => boolean;\n  toggleExpanded: (categoryId: string) => void;\n  setAllExpanded: (expanded: boolean) => void;\n  expandAll: (groups: CategoryGroup[]) => void;\n}\n\n/**\n * The expanded set.\n *\n * `searching` short-circuits the lookup instead of mutating the set: a query must\n * reveal every hit, but clearing it has to restore whatever the admin had folded,\n * which an overwrite would have destroyed.\n */\nfunction useExpandedCategories(\n  allGroups: CategoryGroup[],\n  searching: boolean,\n): ExpansionState {\n  const [expanded, setExpanded] = useState<ReadonlySet<string>>(() => new Set());\n\n  const isExpanded = useCallback(\n    (categoryId: string) => searching || expanded.has(categoryId),\n    [searching, expanded],\n  );\n\n  const toggleExpanded = useCallback((categoryId: string) => {\n    setExpanded((current) => {\n      const next = new Set(current);\n      if (!next.delete(categoryId)) next.add(categoryId);\n      return next;\n    });\n  }, []);\n\n  const setAllExpanded = useCallback(\n    (shouldExpand: boolean) => {\n      setExpanded(shouldExpand ? new Set(allGroups.map((g) => g.category.id)) : new Set());\n    },\n    [allGroups],\n  );\n\n  const expandAll = useCallback((groups: CategoryGroup[]) => {\n    setExpanded(new Set(groups.map((group) => group.category.id)));\n  }, []);\n\n  return { isExpanded, toggleExpanded, setAllExpanded, expandAll };\n}\n\n/** The pending selection and the two ways a row changes it. */\ninterface DraftState {\n  draft: ReadonlySet<string>;\n  setDraft: (next: ReadonlySet<string>) => void;\n  toggleCategory: (group: CategoryGroup) => void;\n  toggleSubcategory: (id: string) => void;\n}\n\nfunction useDraftSelection(initial: readonly string[]): DraftState {\n  const [draft, setDraftState] = useState<ReadonlySet<string>>(() => new Set(initial));\n\n  const toggleCategory = useCallback((group: CategoryGroup) => {\n    setDraftState((current) => toggleCategoryLeaves(group, current));\n  }, []);\n\n  const toggleSubcategory = useCallback((id: string) => {\n    setDraftState((current) => toggleLeaf(id, current));\n  }, []);\n\n  const setDraft = useCallback((next: ReadonlySet<string>) => setDraftState(next), []);\n\n  return { draft, setDraft, toggleCategory, toggleSubcategory };\n}\n\n/** Everything the panel and trigger need to render and drive one select. */\nexport interface CategorySelectState extends ExpansionState, DraftState {\n  open: boolean;\n  query: string;\n  /** Groups after the search filter — what is actually on screen. */\n  visibleGroups: CategoryGroup[];\n  /** All groups, unfiltered — the basis for chips and \"select all\". */\n  allGroups: CategoryGroup[];\n  rows: CategoryRowRef[];\n  activeIndex: number;\n  setQuery: (next: string) => void;\n  setActiveIndex: (next: number) => void;\n  openPanel: () => void;\n  closePanel: () => void;\n  triggerRef: React.RefObject<HTMLButtonElement | null>;\n}\n\ninterface UseCategorySelectArgs {\n  options: CategorySelectOption[];\n  /** The applied selection to seed the draft from each time the panel opens. */\n  selected: readonly string[];\n}\n\n/**\n * Panel state for one CategorySelect.\n *\n * The DRAFT is the load-bearing idea. Ticks land here, not on the caller's\n * `value`, so the list behind the panel does not refetch on every click; Apply\n * publishes, dismissing discards. Opening re-seeds the draft from the applied\n * value, which is what makes \"cancel\" mean cancel.\n */\nexport function useCategorySelect({\n  options,\n  selected,\n}: UseCategorySelectArgs): CategorySelectState {\n  const [open, setOpen] = useState(false);\n  const [query, setQueryState] = useState('');\n  const [activeIndex, setActiveIndex] = useState(-1);\n  const triggerRef = useRef<HTMLButtonElement | null>(null);\n\n  const allGroups = useMemo(() => buildCategoryGroups(options), [options]);\n  const visibleGroups = useMemo(\n    () => filterCategoryGroups(allGroups, query),\n    [allGroups, query],\n  );\n\n  const expansion = useExpandedCategories(allGroups, query.trim().length > 0);\n  const selection = useDraftSelection(selected);\n  const rows = useMemo(\n    () => flattenRows(visibleGroups, expansion.isExpanded),\n    [visibleGroups, expansion.isExpanded],\n  );\n\n  const openPanel = useCallback(() => {\n    selection.setDraft(new Set(selected));\n    expansion.expandAll(allGroups);\n    setQueryState('');\n    setActiveIndex(-1);\n    setOpen(true);\n  }, [selected, allGroups, selection, expansion]);\n\n  const closePanel = useCallback(() => {\n    setOpen(false);\n    setQueryState('');\n    setActiveIndex(-1);\n  }, []);\n\n  const setQuery = useCallback((next: string) => {\n    setQueryState(next);\n    setActiveIndex(-1);\n  }, []);\n\n  return {\n    ...expansion,\n    ...selection,\n    open,\n    query,\n    visibleGroups,\n    allGroups,\n    rows,\n    activeIndex,\n    setQuery,\n    setActiveIndex,\n    openPanel,\n    closePanel,\n    triggerRef,\n  };\n}\n"],"mappings":"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","names":[]}

package/dist/chunk-ITGG5OKP.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/components/form/Button/Button.metrics.ts"],"sourcesContent":["import { darken, lighten } from '../../../tokens/color';\nimport type { ColorValue, SizeValue } from '../../../tokens/vocabulary';\nimport type { UiPaletteColor, UiTheme } from '../../../tokens/theme';\n\n/**\n * THE NUMBERS BOTH `Button` RENDERERS DRAW WITH.\n *\n * `Button.styles.ts` (web, emotion) and `Button.native.tsx` (React Native)\n * read this one table. The web turns the px into rem and the padding into a\n * shorthand string; native uses the numbers as they are. Neither restates a\n * value, which is what keeps a native `md` button 16px tall of padding and\n * 16px of type exactly like the web one.\n */\nexport interface ButtonSizeMetrics {\n  paddingVertical: number;\n  paddingHorizontal: number;\n  fontSize: number;\n}\n\nexport const BUTTON_SIZES: Record<SizeValue, ButtonSizeMetrics> = {\n  xs: { paddingVertical: 2, paddingHorizontal: 8, fontSize: 12 },\n  sm: { paddingVertical: 6, paddingHorizontal: 12, fontSize: 14 },\n  md: { paddingVertical: 8, paddingHorizontal: 16, fontSize: 16 },\n  lg: { paddingVertical: 10, paddingHorizontal: 20, fontSize: 18 },\n  xl: { paddingVertical: 12, paddingHorizontal: 24, fontSize: 20 },\n};\n\n/** A button that is only an icon is square: uniform padding, no min-width. */\nexport const ICON_ONLY_PADDING: Record<SizeValue, number> = {\n  xs: 2,\n  sm: 5,\n  md: 7,\n  lg: 9,\n  xl: 11,\n};\n\nexport const BUTTON_FONT_WEIGHT = 500;\n/** `theme.spacing(1)`. */\nexport const BUTTON_RADIUS_UNITS = 1;\n/** Between the icon and the label: `theme.spacing(0.5)`. */\nexport const BUTTON_ICON_GAP_UNITS = 0.5;\nexport const BUTTON_SPINNER_SIZE = 16;\n/** MUI's `line-height` for button text. */\nexport const BUTTON_LINE_HEIGHT = 1.75;\n\n/** The wash behind an outline, ghost or text button while it is hovered or pressed. */\nexport const BUTTON_WASH_ALPHA = 0.1;\nexport const GLASS_BACKGROUND_ALPHA = 0.1;\nexport const GLASS_BACKGROUND_ALPHA_PRESSED = 0.2;\nexport const GLASS_BORDER_ALPHA = 0.2;\nexport const GLOW_INNER_ALPHA = 0.6;\nexport const GLOW_OUTER_ALPHA = 0.3;\nexport const GLOW_RADIUS = 20;\nexport const PULSE_ALPHA = 0.3;\nexport const PULSE_DURATION_MS = 2000;\nexport const PULSE_SPREAD = 15;\n\n/**\n * `neutral` has no palette slot of its own in MUI, so `Button.styles.ts` has\n * always drawn it from three greys. Same three greys here.\n */\nexport function buttonPalette(theme: UiTheme, color: ColorValue): UiPaletteColor {\n  if (color === 'neutral') {\n    return {\n      main: theme.palette.grey[700],\n      dark: theme.palette.grey[800],\n      light: theme.palette.grey[500],\n      contrastText: '#fff',\n    };\n  }\n  return theme.palette[color];\n}\n\n/**\n * The label colour for `ghost` and `text`: one step darker than `main` in\n * light mode (lighter in dark), because `main` is chosen to sit UNDER white and\n * is not legible AS text on a tinted surface. See the web `quietInk`.\n */\nexport const quietInk = (theme: UiTheme, palette: UiPaletteColor): string =>\n  theme.mode === 'dark' ? lighten(palette.main, 0.35) : darken(palette.main, 0.3);\n\n/** Gradients run between two related hues; the named colours pick a specific pair. */\nexport function gradientStops(\n  theme: UiTheme,\n  color: ColorValue,\n  palette: UiPaletteColor,\n): [string, string] {\n  switch (color) {\n    case 'primary':\n      return [theme.palette.primary.main, theme.palette.secondary.main];\n    case 'secondary':\n      return [theme.palette.secondary.main, theme.palette.primary.main];\n    case 'success':\n    case 'warning':\n      return [theme.palette[color].light, theme.palette[color].dark];\n    case 'danger':\n      return [theme.palette.danger.light, theme.palette.danger.dark];\n    default:\n      return [palette.main, palette.dark];\n  }\n}\n"],"mappings":";;;;;;AAmBO,IAAM,eAAqD;AAAA,EAChE,IAAI,EAAE,iBAAiB,GAAG,mBAAmB,GAAG,UAAU,GAAG;AAAA,EAC7D,IAAI,EAAE,iBAAiB,GAAG,mBAAmB,IAAI,UAAU,GAAG;AAAA,EAC9D,IAAI,EAAE,iBAAiB,GAAG,mBAAmB,IAAI,UAAU,GAAG;AAAA,EAC9D,IAAI,EAAE,iBAAiB,IAAI,mBAAmB,IAAI,UAAU,GAAG;AAAA,EAC/D,IAAI,EAAE,iBAAiB,IAAI,mBAAmB,IAAI,UAAU,GAAG;AACjE;AAGO,IAAM,oBAA+C;AAAA,EAC1D,IAAI;AAAA,EACJ,IAAI;AAAA,EACJ,IAAI;AAAA,EACJ,IAAI;AAAA,EACJ,IAAI;AACN;AAEO,IAAM,qBAAqB;AAE3B,IAAM,sBAAsB;AAE5B,IAAM,wBAAwB;AAC9B,IAAM,sBAAsB;AAE5B,IAAM,qBAAqB;AAG3B,IAAM,oBAAoB;AAC1B,IAAM,yBAAyB;AAC/B,IAAM,iCAAiC;AACvC,IAAM,qBAAqB;AAC3B,IAAM,mBAAmB;AACzB,IAAM,mBAAmB;AACzB,IAAM,cAAc;AACpB,IAAM,cAAc;AACpB,IAAM,oBAAoB;AAC1B,IAAM,eAAe;AAMrB,SAAS,cAAc,OAAgB,OAAmC;AAC/E,MAAI,UAAU,WAAW;AACvB,WAAO;AAAA,MACL,MAAM,MAAM,QAAQ,KAAK,GAAG;AAAA,MAC5B,MAAM,MAAM,QAAQ,KAAK,GAAG;AAAA,MAC5B,OAAO,MAAM,QAAQ,KAAK,GAAG;AAAA,MAC7B,cAAc;AAAA,IAChB;AAAA,EACF;AACA,SAAO,MAAM,QAAQ,KAAK;AAC5B;AAOO,IAAM,WAAW,CAAC,OAAgB,YACvC,MAAM,SAAS,SAAS,QAAQ,QAAQ,MAAM,IAAI,IAAI,OAAO,QAAQ,MAAM,GAAG;AAGzE,SAAS,cACd,OACA,OACA,SACkB;AAClB,UAAQ,OAAO;AAAA,IACb,KAAK;AACH,aAAO,CAAC,MAAM,QAAQ,QAAQ,MAAM,MAAM,QAAQ,UAAU,IAAI;AAAA,IAClE,KAAK;AACH,aAAO,CAAC,MAAM,QAAQ,UAAU,MAAM,MAAM,QAAQ,QAAQ,IAAI;AAAA,IAClE,KAAK;AAAA,IACL,KAAK;AACH,aAAO,CAAC,MAAM,QAAQ,KAAK,EAAE,OAAO,MAAM,QAAQ,KAAK,EAAE,IAAI;AAAA,IAC/D,KAAK;AACH,aAAO,CAAC,MAAM,QAAQ,OAAO,OAAO,MAAM,QAAQ,OAAO,IAAI;AAAA,IAC/D;AACE,aAAO,CAAC,QAAQ,MAAM,QAAQ,IAAI;AAAA,EACtC;AACF;","names":[]}

package/dist/chunk-JM64OEU6.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/components/form/CategorySelect/CategorySelect.tsx"],"sourcesContent":["'use client';\n\nimport { useEffect, useMemo, useRef } from 'react';\nimport { useTheme } from '@mui/material/styles/index.js';\nimport useMediaQuery from '@mui/material/useMediaQuery/index.js';\n\nimport { summarizeSelection } from './category-tree';\nimport { CategoryPanel } from './CategoryPanel';\nimport { CategoryPanelSurface } from './CategoryPanelSurface';\nimport { CategoryTrigger } from './CategoryTrigger';\nimport { METRICS } from './CategorySelect.styles';\nimport type { CategoryGroup, CategorySelectProps } from './CategorySelect.types';\nimport { useCategoryCommit } from './useCategoryCommit';\nimport { useCategoryKeyHandler } from './useCategoryKeyHandler';\nimport { useCategorySelect } from './useCategorySelect';\nimport { FormControl, FormLabel, FormMessage } from '../Form';\n\n/** The applied selection, always as an array — the two modes differ in shape. */\nfunction appliedIds(props: CategorySelectProps): string[] {\n  if (props.mode === 'single') return props.value ? [props.value] : [];\n  return props.value;\n}\n\n/** True when the draft differs from what is already applied. */\nfunction draftChanged(draft: ReadonlySet<string>, applied: readonly string[]): boolean {\n  return draft.size !== applied.length || applied.some((id) => !draft.has(id));\n}\n\n/** \"Pai › Filha\" for a chosen id, so the trigger carries its context. */\nfunction singleLabel(groups: CategoryGroup[], value: string | null): string | undefined {\n  if (!value) return undefined;\n  const asCategory = groups.find((group) => group.category.id === value);\n  if (asCategory) return asCategory.category.name;\n  const owner = groups.find((group) => group.subcategories.some((sub) => sub.id === value));\n  const sub = owner?.subcategories.find((candidate) => candidate.id === value);\n  return sub && owner ? `${owner.category.name} › ${sub.name}` : undefined;\n}\n\n/** The optional props, resolved once so the component body stays branch-free. */\ninterface ResolvedConfig {\n  single: boolean;\n  placeholder: string;\n  disabled: boolean;\n  loading: boolean;\n  fullWidth: boolean;\n  showCounts: boolean;\n  allowParentSelection: boolean;\n  dataTestId: string;\n}\n\nfunction resolveConfig(props: CategorySelectProps): ResolvedConfig {\n  const single = props.mode === 'single';\n  return {\n    single,\n    placeholder: props.placeholder ?? (single ? props.copy.placeholderSingle : props.copy.placeholderMulti),\n    disabled: props.disabled ?? false,\n    loading: props.loading ?? false,\n    fullWidth: props.fullWidth ?? false,\n    showCounts: props.showCounts ?? false,\n    allowParentSelection: props.allowParentSelection ?? false,\n    dataTestId: props.dataTestId ?? 'category-select',\n  };\n}\n\n/** Focus the search box on open, and keep the keyboard cursor in view. */\nfunction usePanelFocus(\n  open: boolean,\n  activeIndex: number,\n  searchInputRef: React.RefObject<HTMLInputElement | null>,\n  listRef: React.RefObject<HTMLDivElement | null>,\n): void {\n  // The first thing an admin does with ten categories is type; focusing here\n  // saves the extra click every single time the panel opens.\n  useEffect(() => {\n    if (!open) return undefined;\n    const frame = requestAnimationFrame(() => searchInputRef.current?.focus());\n    return () => cancelAnimationFrame(frame);\n  }, [open, searchInputRef]);\n\n  useEffect(() => {\n    if (activeIndex < 0) return;\n    const rows = listRef.current?.querySelectorAll('[role=\"option\"], [role=\"button\"]');\n    rows?.[activeIndex]?.scrollIntoView({ block: 'nearest' });\n  }, [activeIndex, listRef]);\n}\n\n/**\n * A hierarchical category picker: categories as the frame, subcategories as the\n * thing you choose.\n *\n * Two modes off one component. `multi` is the FILTER — ticks accumulate in a\n * draft and reach `onChange` only on Apply, so the list behind the panel does not\n * reload on every click. `single` is the \"move to…\" picker, where choosing a row\n * commits immediately because there is nothing to batch.\n *\n * The tree opens fully expanded: nothing a search could match is hidden behind a\n * disclosure. Selected categories pin above the list so they survive scrolling\n * and searching, search is accent-insensitive (`agua` finds `Águas`), and the\n * whole tree is keyboard-drivable — ↑↓ to move, → to open, ← to close, Space to\n * mark, Enter to apply, Esc to cancel.\n *\n * Under {@link METRICS.sheetBreakpoint} the panel becomes a bottom sheet, which\n * is the only way a 290px-tall list stays usable one-handed.\n */\nexport function CategorySelect(props: CategorySelectProps): React.JSX.Element {\n  const { options, label, error, onCreateCategory, copy } = props;\n  const {\n    single,\n    placeholder,\n    disabled,\n    loading,\n    fullWidth,\n    showCounts,\n    allowParentSelection,\n    dataTestId,\n  } = resolveConfig(props);\n\n  const theme = useTheme();\n  const sheet = useMediaQuery(theme.breakpoints.down(METRICS.sheetBreakpoint));\n  const applied = appliedIds(props);\n\n  const state = useCategorySelect({ options, selected: applied });\n  const searchInputRef = useRef<HTMLInputElement | null>(null);\n  const listRef = useRef<HTMLDivElement | null>(null);\n  usePanelFocus(state.open, state.activeIndex, searchInputRef, listRef);\n\n  const chips = useMemo(\n    () => summarizeSelection(state.allGroups, state.draft),\n    [state.allGroups, state.draft],\n  );\n  const rowIds = useMemo(() => state.rows.map((row) => row.id), [state.rows]);\n\n  const actions = useCategoryCommit({ props, state, single, allowParentSelection });\n  const onKeyDown = useCategoryKeyHandler({ state, single, allowParentSelection, actions });\n\n  return (\n    <FormControl fullWidth={fullWidth} error={Boolean(error)}>\n      {label && <FormLabel error={Boolean(error)}>{label}</FormLabel>}\n      <CategoryTrigger copy={copy}\n        placeholder={placeholder}\n        selectionLabel={\n          props.mode === 'single' ? singleLabel(state.allGroups, props.value) : undefined\n        }\n        count={single ? undefined : applied.length}\n        open={state.open}\n        disabled={disabled}\n        fullWidth={fullWidth}\n        onOpen={state.openPanel}\n        onClear={applied.length > 0 ? actions.clearSelection : undefined}\n        triggerRef={state.triggerRef}\n        dataTestId={dataTestId}\n      />\n      <CategoryPanelSurface\n        open={state.open}\n        sheet={sheet}\n        anchorEl={state.triggerRef.current}\n        onClose={actions.cancel}\n      >\n        <CategoryPanel copy={copy}\n          state={state}\n          chips={chips}\n          rowIds={rowIds}\n          changed={draftChanged(state.draft, applied)}\n          single={single}\n          sheet={sheet}\n          loading={loading}\n          showCounts={showCounts}\n          allowParentSelection={allowParentSelection}\n          ariaLabel={label ?? placeholder}\n          onKeyDown={onKeyDown}\n          onActivateCategory={actions.activateCategory}\n          onActivateSubcategory={actions.activateSubcategory}\n          onApply={actions.commit}\n          onCancel={actions.cancel}\n          onCreateCategory={onCreateCategory}\n          searchInputRef={searchInputRef}\n          listRef={listRef}\n          dataTestId={dataTestId}\n        />\n      </CategoryPanelSurface>\n      {error && <FormMessage error dataTestId={`${dataTestId}-message`}>{error}</FormMessage>}\n    </FormControl>\n  );\n}\n"],"mappings":"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","names":["sub"]}