@apliteni/apliteni-ui 0.58.2 → 0.60.0

package/src/components/command-palette.js

@@ -1,3 +1,5 @@
+import { SCORE, scoreCommand, rankCommands, rankGroups, paletteHotkey, norm } from '../logic/command-palette.js';
+export { SCORE, scoreCommand, rankCommands, rankGroups, paletteHotkey } from '../logic/command-palette.js';
 // Command palette — one overlay, a text box and a ranked list of things to run
 // or go to.
 //
@@ -16,134 +18,6 @@ const cx = (...a) => a.filter(Boolean).join(' ');
 let _uid = 0;
 const nextId = (p = 'cmdk') => `${p}-${++_uid}`;
 
-/**
- * How a match is worth more than another match.
- *
- * Six ways a query can meet an item, scored so that the whole beats the part
- * and the name beats the note. The numbers are a ladder and not a measurement —
- * what matters is the order, which is why src/components/command-palette.test.js
- * asserts the ORDER of the results rather than any of these values.
- *
- * cmdk's command-score is the other published answer: one continuous score
- * built out of SCORE_CONTINUE_MATCH 1, SCORE_SPACE_WORD_JUMP 0.9,
- * SCORE_NON_SPACE_WORD_JUMP 0.8 and SCORE_CHARACTER_JUMP 0.17. It ranks
- * beautifully and cannot be explained to a reader who asks why their item is
- * third. A ladder can: the kit's palettes hold tens of items, not thousands.
- */
-export const SCORE = {
-  exact: 100,
-  prefix: 90,
-  wordStart: 80,
-  contains: 70,
-  keyword: 60,
-  description: 40,
-  subsequence: 20,
-};
-
-const norm = (s) => String(s == null ? '' : s).toLowerCase().replace(/\s+/g, ' ').trim();
-
-// Every character of `q`, in order, somewhere in `s` — "nc" finding "New
-// campaign". The weakest match the kit accepts, and the only one that can pair
-// a two-letter query with a twenty-letter label.
-function subsequence(s, q) {
-  let at = 0;
-  for (const ch of q) {
-    at = s.indexOf(ch, at);
-    if (at === -1) return false;
-    at += 1;
-  }
-  return true;
-}
-
-// A word here starts after a space or one of the separators a product name uses,
-// so "camp" reaches the second word of "New campaign" and the "utm" in
-// "url-utm_source".
-const wordStarts = (s) => s.split(/[\s/\-_.:,]+/).filter(Boolean);
-
-function scoreField({ label, description, keywords }, q) {
-  const name = norm(label);
-  if (!name && !description && !(keywords || []).length) return 0;
-  if (name === q) return SCORE.exact;
-  if (name.startsWith(q)) return SCORE.prefix;
-  if (wordStarts(name).some((w) => w.startsWith(q))) return SCORE.wordStart;
-  if (name.includes(q)) return SCORE.contains;
-  for (const k of keywords || []) {
-    const key = norm(k);
-    if (key === q || key.startsWith(q)) return SCORE.keyword;
-  }
-  if (norm(description).includes(q)) return SCORE.description;
-  if (subsequence(name, q)) return SCORE.subsequence;
-  return 0;
-}
-
-/**
- * What one item is worth against one query. 0 means it is not a result.
- *
- * An empty query scores everything the same, so a palette nobody has typed into
- * shows what the caller passed, in the caller's order — which is where a
- * product puts the four things somebody actually does here.
- *
- * A query with a space in it has to match as a whole OR token by token, every
- * token landing somewhere: "new camp" reaches "New campaign" as a whole, and
- * "camp new" reaches it one token at a time. The weakest token decides, because
- * a result is only as good as the part of the query it answers worst.
- */
-export function scoreCommand(item, query) {
-  const q = norm(query);
-  if (!q) return 1;
-  const whole = scoreField(item, q);
-  const tokens = q.split(' ');
-  if (tokens.length < 2) return whole;
-  let weakest = Infinity;
-  for (const t of tokens) {
-    const s = scoreField(item, t);
-    if (!s) { weakest = 0; break; }
-    weakest = Math.min(weakest, s);
-  }
-  return Math.max(whole, weakest === Infinity ? 0 : weakest);
-}
-
-/**
- * The items that answer `query`, best first.
- *
- * Ties keep the caller's order — that is the whole of the kit's ordering
- * opinion, and it is what lets a product put its four most-used commands at the
- * top of the list it passes and have them stay there.
- */
-export function rankCommands(items, query) {
-  return (items || [])
-    .map((item, i) => ({ item, i, score: scoreCommand(item, query) }))
-    .filter((r) => r.score > 0)
-    .sort((a, b) => b.score - a.score || a.i - b.i)
-    .map((r) => r.item);
-}
-
-/**
- * The groups that answer `query`, best group first, each holding its own ranked
- * rows and nothing that scored zero.
- *
- * A group is carried by its best row, and the caller's order breaks the tie at
- * both levels — so a palette nobody has typed into is exactly the list that was
- * passed in. cmdk ranks groups the same way; the tie-break is the kit's, and it
- * is what keeps a heading from moving under a reader who has typed nothing.
- */
-export function rankGroups(groups, query) {
-  return (groups || [])
-    .map((g, i) => {
-      const items = rankCommands(g.items || [], query);
-      const best = items.length ? scoreCommand(items[0], query) : 0;
-      return { group: { ...g, items }, i, best };
-    })
-    .filter((g) => g.group.items.length > 0)
-    .sort((a, b) => b.best - a.best || a.i - b.i)
-    .map((g) => g.group);
-}
-
-/** The label for the key that opens it, on the platform the caller is on. */
-export function paletteHotkey(platform = typeof navigator === 'undefined' ? '' : navigator.platform) {
-  return /mac|iphone|ipad|ipod/i.test(String(platform || '')) ? '⌘K' : 'Ctrl K';
-}
-
 // The three fields a query is matched against, written onto the row so the
 // wiring can re-rank what is already rendered without being handed the data a
 // second time. Three attributes and not one blob: the ranking weighs a name

package/src/components/dropdown.js

@@ -1,3 +1,5 @@
+import { dropdownMatch, dropdownFiltering } from '../logic/dropdown.js';
+export { dropdownMatch, dropdownFiltering } from '../logic/dropdown.js';
 // Dropdown — the kit's one popover-list primitive. A trigger opens a panel of
 // item rows; two flavours share the same panel and the same open/close JS:
 //
@@ -79,22 +81,6 @@ function ddBody({ items, sections }, listbox, sx) {
 // why: docs/specification.md#a-dropdown-with-a-search-field
 // NFD takes the mark off é or ö; ł, ø, đ and the rest are letters of their own
 // with nothing to take off, so they are mapped by hand.
-const FOLD = { ł: 'l', ø: 'o', đ: 'd', ð: 'd', ß: 'ss', æ: 'ae', œ: 'oe', ı: 'i', þ: 'th' };
-const fold = (s) => String(s == null ? '' : s).normalize('NFD').replace(/\p{M}/gu, '').toLowerCase()
-  .replace(/[łøđðßæœıþ]/g, (c) => FOLD[c]);
-
-/**
- * Is this query narrowing anything? A query of spaces, or of marks with no letter
- * under them, is not — it leaves every row showing, and the separators with them.
- *
- * Public because a second implementation of this dropdown cannot write its own: the
- * React <Dropdown> asks these two, the way <CommandPalette> asks rankGroups(), so a
- * list a server rendered and the same list after a keystroke hide the same rows.
- */
-export const dropdownFiltering = (query) => fold(query).trim() !== '';
-
-/** Does `label` match `query`? A substring, anywhere, ignoring case and accents. */
-export const dropdownMatch = (label, query) => fold(label).includes(fold(query).trim());
 const ddIsRow = (it) => it && it !== '---' && !it.separator;
 
 let _ddSeq = 0;

package/src/components/index.js

@@ -1,3 +1,5 @@
+import { calloutIcons } from '../logic/callout.js';
+export { calloutIcons } from '../logic/callout.js';
 // apliteni-ui component factories — each returns an HTML string, matching the
 // viz/ server-render idiom so the portal can adopt them with no framework.
 import { icon } from '../assets/icons.js';
@@ -218,7 +220,7 @@ export function switchToggle({ checked = false, disabled = false, name, label =
 }
 
 // ---- Callout / toast / success ------------------------------------------
-export const calloutIcons = { info: 'info', success: 'check', warn: 'alert', danger: 'alert', neutral: 'info' };
+
 
 export function callout({ variant, icon: ic = calloutIcons[variant] || 'info', body, actions } = {}) {
   return `<div class="${esc(cx('ui-callout', variant && variant !== 'neutral' && `ui-callout--${variant}`))}"><span class="ui-callout__icon">${icon(ic)}</span><div class="ui-callout__body">${body}${actions != null ? `<div class="ui-toolbar ui-callout__actions">${actions}</div>` : ''}</div></div>`;

package/src/components/pagination.js

@@ -1,3 +1,5 @@
+import { PAGE_SIZES, DEFAULT_PAGE_SIZE } from '../logic/pagination.js';
+export { PAGE_SIZES, DEFAULT_PAGE_SIZE } from '../logic/pagination.js';
 // Pagination — the strip under a table or a list, as an HTML string.
 //
 // It renders a page the CALLER computed. Rows never come in here: `page`,
@@ -15,8 +17,7 @@ import { safeUrl } from '../html.js';
 // AG Grid defaults to 100, and the finance portal's two data-heavy surfaces
 // already page at 100. A 250 step was in the first draft of this component and
 // no surveyed kit offers one, so it went rather than being invented.
-export const PAGE_SIZES = [25, 50, 100];
-export const DEFAULT_PAGE_SIZE = 100;
+
 
 // The classes button({ variant: 'ghost', size: 'sm' }) emits, written out because
 // button() takes no extra class and every control here needs one of its own for

package/src/components/segmented.js

@@ -1,12 +1,5 @@
-export function segmentedNextIndex(key, index, length) {
-  if (!length) return null;
-  if (key === 'ArrowRight' || key === 'ArrowDown') return (index + 1) % length;
-  if (key === 'ArrowLeft' || key === 'ArrowUp') return (index - 1 + length) % length;
-  if (key === 'Home') return 0;
-  if (key === 'End') return length - 1;
-  return null;
-}
-
+import { segmentedNextIndex } from '../logic/segmented.js';
+export { segmentedNextIndex } from '../logic/segmented.js';
 export function initSegmented(root = document) {
   const cleanups = [];
   root.querySelectorAll('[data-seg]').forEach(group => {

package/src/components/table-values.js

@@ -1,14 +1,14 @@
+import { formatNumericValue, formatDeltaValue } from '../logic/table-values.js';
 import { esc } from './index.js';
 import { safeUrl } from '../html.js';
-export function numericValue({ value, unit = '', missing = 'Not available' } = {}) {
-  if (value == null || value === '') return `<span class="ui-value" aria-label="${esc(missing)}">—</span>`;
-  return `<span class="ui-value">${esc(value)}${unit ? `<span class="ui-value__unit">${esc(unit)}</span>` : ''}</span>`;
+export function numericValue(options = {}) {
+  const value = formatNumericValue(options);
+  return `<span class="ui-value"${value.missing !== undefined ? ` aria-label="${esc(value.missing)}"` : ''}>${esc(value.text)}${value.unit ? `<span class="ui-value__unit">${esc(value.unit)}</span>` : ''}</span>`;
 }
 
-export function deltaValue({ value, tone = 'neutral', basisId, missing = 'No earlier figure' } = {}) {
-  const present = value != null && value !== '';
-  const judged = present && ['success', 'danger'].includes(tone) && !/^[+−-]?0+(?:[.,]0+)?(?:[^\d.,].*)?$/.test(String(value).replace(/\s/g, ''));
-  return `<span class="ui-delta${judged ? ` ui-delta--${tone}` : ''}"${basisId ? ` aria-describedby="${esc(basisId)}"` : ''}>${esc(present ? value : missing)}</span>`;
+export function deltaValue(options = {}) {
+  const value = formatDeltaValue(options);
+  return `<span class="${value.className}"${value.basisId ? ` aria-describedby="${esc(value.basisId)}"` : ''}>${esc(value.text)}</span>`;
 }
 
 export function rowIdentity({ symbol = '', name = '', logo, href } = {}) {

package/src/index.d.ts

@@ -0,0 +1,128 @@
+export declare function esc(value: unknown): string;
+export declare function field(opts?: Record<string, unknown>): string;
+export declare function input(opts?: Record<string, unknown>): string;
+export declare function textarea(opts?: Record<string, unknown>): string;
+export declare function select(opts?: Record<string, unknown>): string;
+export declare function numericValue(opts?: Record<string, unknown>): string;
+export declare function deltaValue(opts?: Record<string, unknown>): string;
+export declare function filterBar(opts?: Record<string, unknown>): string;
+export declare function initFilterBar(host: Element, opts?: Record<string, unknown>): { update: (opts: Record<string, unknown>) => void; destroy: () => void };
+export declare function segmentedNextIndex(key: string, index: number, length: number): number | null;
+export declare function icon(name: string, className?: string): string;
+export declare function snippet(opts?: Record<string, unknown>): string;
+export declare function button(opts?: Record<string, unknown>): string;
+export declare function badge(label: string, variant?: string): string;
+export declare const calloutIcons: Record<'neutral' | 'info' | 'success' | 'warn' | 'danger', string>;
+export declare function callout(opts?: Record<string, unknown>): string;
+export declare function card(opts?: Record<string, unknown>): string;
+export declare function pagination(opts?: Record<string, unknown>): string;
+export declare function drawerSection(opts?: Record<string, unknown>): string;
+export declare function drawer(opts?: Record<string, unknown>): string;
+export declare function dropdown(opts?: Record<string, unknown>): string;
+export declare function wireDropdown(root?: Document | Element): void;
+/** The kit's own match, asked rather than re-implemented by <Dropdown>. */
+export declare function dropdownMatch(label: unknown, query: unknown): boolean;
+export declare function dropdownFiltering(query: unknown): boolean;
+export declare function backLink(opts?: Record<string, unknown>): string;
+export declare function statBand(opts?: Record<string, unknown>): string;
+export declare function commandPalette(opts?: Record<string, unknown>): string;
+export declare function rankGroups<G>(groups: readonly G[], query: string): G[];
+export declare function rankCommands<I>(items: readonly I[], query: string): I[];
+export declare function scoreCommand(item: Record<string, unknown>, query: string): number;
+export declare function paletteHotkey(platform?: string): string;
+export declare const PAGE_SIZES: number[];
+export declare const DEFAULT_PAGE_SIZE: number;
+export type NumericValueOptions = { value?: string | number | null; unit?: string; missing?: string };
+export type DeltaValueOptions = { value?: string | null; tone?: 'success' | 'danger' | 'neutral'; basisId?: string; missing?: string };
+export declare function formatNumericValue(options?: NumericValueOptions): { text: string; unit: string; missing: string | undefined };
+export declare function formatDeltaValue(options?: DeltaValueOptions): { text: string; className: string; basisId: string | undefined };
+export declare const SCORE: Record<'exact' | 'prefix' | 'wordStart' | 'contains' | 'keyword' | 'description' | 'subsequence', number>;
+export declare const iconNames: string[];
+export declare const iconCategories: { name: string; names: string[] }[];
+export declare const iconOnlyAllowed: Record<string, string>;
+export declare const iconMeanings: Record<string, string>;
+export declare const sun: string;
+export declare const moon: string;
+export declare function prism(prefix?: string, size?: number): string;
+export declare function seedling(prefix?: string, size?: number): string;
+export declare function brand(options?: { p?: string; word?: string; size?: number; href?: string }): string;
+export declare function illo(name: string): string;
+export * from './motion.js';
+export declare const illoNames: string[];
+
+// Vanilla factories accept their existing option bags and return HTML.
+export declare function accentPicker(opts?: Record<string, unknown>): string;
+export declare function accountMenu(opts?: Record<string, unknown>): string;
+export declare function accountShell(opts?: Record<string, unknown>): string;
+export declare function appShell(opts?: Record<string, unknown>): string;
+export declare function breadcrumbs(opts?: Record<string, unknown>): string;
+export declare function busyRegion(opts?: Record<string, unknown>): string;
+export declare function checkbox(opts?: Record<string, unknown>): string;
+export declare function confirm(opts?: Record<string, unknown>): string;
+export declare function deniedState(opts?: Record<string, unknown>): string;
+export declare function emptyState(opts?: Record<string, unknown>): string;
+export declare function feedbackWidget(opts?: Record<string, unknown>): string;
+export declare function footer(opts?: Record<string, unknown>): string;
+export declare function nav(opts?: Record<string, unknown>): string;
+export declare function navTabs(opts?: Record<string, unknown>): string;
+export declare function rowIdentity(opts?: Record<string, unknown>): string;
+export declare function segmented(opts?: Record<string, unknown>): string;
+export declare function sidebarNav(opts?: Record<string, unknown>): string;
+export declare function skeleton(opts?: Record<string, unknown>): string;
+export declare function skeletonTable(opts?: Record<string, unknown>): string;
+export declare function success(opts?: Record<string, unknown>): string;
+export declare function successPanel(opts?: Record<string, unknown>): string;
+export declare function switchToggle(opts?: Record<string, unknown>): string;
+export declare function tabs(opts?: Record<string, unknown>): string;
+export declare function toast(opts?: Record<string, unknown>): string;
+export declare function tooltip(opts?: Record<string, unknown>): string;
+export declare function topbar(opts?: Record<string, unknown>): string;
+export declare function commandPaletteList(groups?: readonly Record<string, unknown>[], opts?: { uid?: string; from?: number }): string;
+export declare function deckTextSwitch(active?: string): string;
+export declare function hlShell(raw: string): string;
+export declare function pill(label: string, variant?: string): string;
+export declare function statusDot(live?: boolean): string;
+export declare function successCheck(): string;
+export declare function themeIcon(theme: string): string;
+export declare function themeName(theme: string): string;
+export declare function themeToggle(theme?: string): string;
+export declare function versionSwitcher(versions?: { label: string; meta?: string; badge?: string }[], activeIdx?: number): string;
+
+export declare const ACCENTS: string[];
+export declare const ACCOUNT_NAV: { id: string; icon: string; label: string }[];
+export declare const RAIL_COOKIE: 'apliteni-ui-rail';
+export declare const STAT_TONES: string[];
+export declare const STAT_VARIANTS: string[];
+
+export declare function applyAccent(name: string, root?: HTMLElement): void;
+export declare function applyTheme(theme: string, root?: HTMLElement): void;
+export declare function railCollapsed(cookies?: string): boolean | null;
+export declare function closeCommandPalette(root: Element | null): void;
+export declare function closeConfirm(root: Element | null): void;
+export declare function closeDrawer(root: Element | null): void;
+export declare function openCommandPalette(root: Element | null, returnFocusTo?: HTMLElement | null): void;
+export declare function openConfirm(root: Element | null, returnFocusTo?: HTMLElement | null): void;
+export declare function openDrawer(root: Element | null, returnFocusTo?: HTMLElement | null): void;
+export declare function setPaletteResults(root: HTMLElement, groups: readonly Record<string, unknown>[]): void;
+export declare function hideTooltip(host: HTMLElement): void;
+export declare function showTooltip(host: HTMLElement, mark: Element): void;
+export declare function initRowIdentity(root?: Document | Element): void;
+export declare function initSegmented(root?: Document | Element): () => void;
+export declare function initTabs(root?: Document | Element): void;
+export declare function wireCommandPalette(root?: Document | Element): void;
+export declare function wireConfirm(root?: Document | Element): void;
+export declare function wireDrawer(root?: Document | Element): void;
+export declare function wireFeedback(opts?: Record<string, unknown>): void;
+export declare function wireNav(root?: Document | Element): void;
+export declare function wireShell(root?: Document | Element, opts?: { persist?: boolean }): void;
+export declare function wireTooltip(root?: Document | Element): void;
+export declare function wireTopbar(root?: Document | Element): void;
+export declare function wireSuccess(root: Element, opts?: { onDone?: () => void }): () => void;
+export declare function wirePagination(root?: Document | Element | string | null, opts?: { onPage?: (page: number) => void; onPageSize?: (size: number) => void }): () => void;
+export declare function nearestSection(node: Node | null, root?: Element | null): Element | null;
+export declare function dismissToast(element: HTMLElement): void;
+export declare function wireToastStack(container: Element | string | null): Element | null;
+export declare function pushToast(container: Element | string | null, opts?: Record<string, unknown>): Element | null;
+export declare function setBusy(root: Element | string | null, opts?: { busy?: boolean; message?: string; body?: string }): Element | null;
+export declare function setButtonBusy(element: HTMLElement, opts?: { busy?: boolean }): void;
+export declare function setPagerStatus(root: Element | string | null, text: string): Element | null;

package/src/index.js

@@ -26,3 +26,10 @@ export { setButtonBusy } from './components/button-busy.js';
 export * from './components/table-values.js';
 export * from './components/segmented.js';
 export * from './components/filter-bar.js';
+
+export { dropdownMatch, dropdownFiltering } from './logic/dropdown.js';
+export { SCORE, rankGroups, rankCommands, scoreCommand, paletteHotkey } from './logic/command-palette.js';
+export { segmentedNextIndex } from './logic/segmented.js';
+export { PAGE_SIZES, DEFAULT_PAGE_SIZE } from './logic/pagination.js';
+export { calloutIcons } from './logic/callout.js';
+export { formatNumericValue, formatDeltaValue } from './logic/table-values.js';

package/src/logic/callout.js

@@ -0,0 +1 @@
+export const calloutIcons = { info: 'info', success: 'check', warn: 'alert', danger: 'alert', neutral: 'info' };

package/src/logic/command-palette.js

@@ -0,0 +1,127 @@
+/**
+ * How a match is worth more than another match.
+ *
+ * Six ways a query can meet an item, scored so that the whole beats the part
+ * and the name beats the note. The numbers are a ladder and not a measurement —
+ * what matters is the order, which is why src/components/command-palette.test.js
+ * asserts the ORDER of the results rather than any of these values.
+ *
+ * cmdk's command-score is the other published answer: one continuous score
+ * built out of SCORE_CONTINUE_MATCH 1, SCORE_SPACE_WORD_JUMP 0.9,
+ * SCORE_NON_SPACE_WORD_JUMP 0.8 and SCORE_CHARACTER_JUMP 0.17. It ranks
+ * beautifully and cannot be explained to a reader who asks why their item is
+ * third. A ladder can: the kit's palettes hold tens of items, not thousands.
+ */
+export const SCORE = {
+  exact: 100,
+  prefix: 90,
+  wordStart: 80,
+  contains: 70,
+  keyword: 60,
+  description: 40,
+  subsequence: 20,
+};
+
+export const norm = (s) => String(s == null ? '' : s).toLowerCase().replace(/\s+/g, ' ').trim();
+
+// Every character of `q`, in order, somewhere in `s` — "nc" finding "New
+// campaign". The weakest match the kit accepts, and the only one that can pair
+// a two-letter query with a twenty-letter label.
+function subsequence(s, q) {
+  let at = 0;
+  for (const ch of q) {
+    at = s.indexOf(ch, at);
+    if (at === -1) return false;
+    at += 1;
+  }
+  return true;
+}
+
+// A word here starts after a space or one of the separators a product name uses,
+// so "camp" reaches the second word of "New campaign" and the "utm" in
+// "url-utm_source".
+const wordStarts = (s) => s.split(/[\s/\-_.:,]+/).filter(Boolean);
+
+function scoreField({ label, description, keywords }, q) {
+  const name = norm(label);
+  if (!name && !description && !(keywords || []).length) return 0;
+  if (name === q) return SCORE.exact;
+  if (name.startsWith(q)) return SCORE.prefix;
+  if (wordStarts(name).some((w) => w.startsWith(q))) return SCORE.wordStart;
+  if (name.includes(q)) return SCORE.contains;
+  for (const k of keywords || []) {
+    const key = norm(k);
+    if (key === q || key.startsWith(q)) return SCORE.keyword;
+  }
+  if (norm(description).includes(q)) return SCORE.description;
+  if (subsequence(name, q)) return SCORE.subsequence;
+  return 0;
+}
+
+/**
+ * What one item is worth against one query. 0 means it is not a result.
+ *
+ * An empty query scores everything the same, so a palette nobody has typed into
+ * shows what the caller passed, in the caller's order — which is where a
+ * product puts the four things somebody actually does here.
+ *
+ * A query with a space in it has to match as a whole OR token by token, every
+ * token landing somewhere: "new camp" reaches "New campaign" as a whole, and
+ * "camp new" reaches it one token at a time. The weakest token decides, because
+ * a result is only as good as the part of the query it answers worst.
+ */
+export function scoreCommand(item, query) {
+  const q = norm(query);
+  if (!q) return 1;
+  const whole = scoreField(item, q);
+  const tokens = q.split(' ');
+  if (tokens.length < 2) return whole;
+  let weakest = Infinity;
+  for (const t of tokens) {
+    const s = scoreField(item, t);
+    if (!s) { weakest = 0; break; }
+    weakest = Math.min(weakest, s);
+  }
+  return Math.max(whole, weakest === Infinity ? 0 : weakest);
+}
+
+/**
+ * The items that answer `query`, best first.
+ *
+ * Ties keep the caller's order — that is the whole of the kit's ordering
+ * opinion, and it is what lets a product put its four most-used commands at the
+ * top of the list it passes and have them stay there.
+ */
+export function rankCommands(items, query) {
+  return (items || [])
+    .map((item, i) => ({ item, i, score: scoreCommand(item, query) }))
+    .filter((r) => r.score > 0)
+    .sort((a, b) => b.score - a.score || a.i - b.i)
+    .map((r) => r.item);
+}
+
+/**
+ * The groups that answer `query`, best group first, each holding its own ranked
+ * rows and nothing that scored zero.
+ *
+ * A group is carried by its best row, and the caller's order breaks the tie at
+ * both levels — so a palette nobody has typed into is exactly the list that was
+ * passed in. cmdk ranks groups the same way; the tie-break is the kit's, and it
+ * is what keeps a heading from moving under a reader who has typed nothing.
+ */
+export function rankGroups(groups, query) {
+  return (groups || [])
+    .map((g, i) => {
+      const items = rankCommands(g.items || [], query);
+      const best = items.length ? scoreCommand(items[0], query) : 0;
+      return { group: { ...g, items }, i, best };
+    })
+    .filter((g) => g.group.items.length > 0)
+    .sort((a, b) => b.best - a.best || a.i - b.i)
+    .map((g) => g.group);
+}
+
+/** The label for the key that opens it, on the platform the caller is on. */
+export function paletteHotkey(platform = typeof navigator === 'undefined' ? '' : navigator.platform) {
+  return /mac|iphone|ipad|ipod/i.test(String(platform || '')) ? '⌘K' : 'Ctrl K';
+}

package/src/logic/dropdown.js

@@ -0,0 +1,16 @@
+const FOLD = { ł: 'l', ø: 'o', đ: 'd', ð: 'd', ß: 'ss', æ: 'ae', œ: 'oe', ı: 'i', þ: 'th' };
+const fold = (s) => String(s == null ? '' : s).normalize('NFD').replace(/\p{M}/gu, '').toLowerCase()
+  .replace(/[łøđðßæœıþ]/g, (c) => FOLD[c]);
+
+/**
+ * Is this query narrowing anything? A query of spaces, or of marks with no letter
+ * under them, is not — it leaves every row showing, and the separators with them.
+ *
+ * Public because a second implementation of this dropdown cannot write its own: the
+ * React <Dropdown> asks these two, the way <CommandPalette> asks rankGroups(), so a
+ * list a server rendered and the same list after a keystroke hide the same rows.
+ */
+export const dropdownFiltering = (query) => fold(query).trim() !== '';
+
+/** Does `label` match `query`? A substring, anywhere, ignoring case and accents. */
+export const dropdownMatch = (label, query) => fold(label).includes(fold(query).trim());

package/src/logic/pagination.js

@@ -0,0 +1,2 @@
+export const PAGE_SIZES = [25, 50, 100];
+export const DEFAULT_PAGE_SIZE = 100;

package/src/logic/segmented.js

@@ -0,0 +1,8 @@
+export function segmentedNextIndex(key, index, length) {
+  if (!length) return null;
+  if (key === 'ArrowRight' || key === 'ArrowDown') return (index + 1) % length;
+  if (key === 'ArrowLeft' || key === 'ArrowUp') return (index - 1 + length) % length;
+  if (key === 'Home') return 0;
+  if (key === 'End') return length - 1;
+  return null;
+}

package/src/logic/table-values.js

@@ -0,0 +1,10 @@
+export function formatNumericValue({ value, unit = '', missing = 'Not available' } = {}) {
+  const present = value != null && value !== '';
+  return { text: present ? String(value) : '—', unit: present ? unit : '', missing: present ? undefined : missing };
+}
+
+export function formatDeltaValue({ value, tone = 'neutral', basisId, missing = 'No earlier figure' } = {}) {
+  const present = value != null && value !== '';
+  const judged = present && ['success', 'danger'].includes(tone) && !/^[+−-]?0+(?:[.,]0+)?(?:[^\d.,].*)?$/.test(String(value).replace(/\s/g, ''));
+  return { text: String(present ? value : missing), className: `ui-delta${judged ? ` ui-delta--${tone}` : ''}`, basisId };
+}

package/src/motion.d.ts

@@ -0,0 +1,6 @@
+export declare function prefersReducedMotion(): boolean;
+export declare function staggerDelay(index: number, stepMs?: number): number;
+export declare function initReveal(root?: Document | Element): IntersectionObserver | undefined;
+export declare const ENTRANCE_FALLBACK_MS: number;
+export declare function playEntrance(element: Element | null, className?: string): void;
+export declare function replay(element: HTMLElement | null): void;