@adea-ai/ui 0.61.0 → 0.61.1

package/dist/r/src/lib/utils.ts

@@ -0,0 +1,76 @@
+import { type ClassValue, clsx } from 'clsx'
+import { extendTailwindMerge } from 'tailwind-merge'
+
+/**
+ * `twMerge` needs to be told about the utilities this design system adds.
+ *
+ * Every token-derived utility (`h-control-md`, `w-rail`, `p-control-lg`, …)
+ * is an unknown name to a default `tailwind-merge` instance. Left
+ * unregistered, `cn('h-control-md', 'h-control-sm')` keeps both classes and
+ * the winner is decided by stylesheet order rather than by the caller — a bug
+ * that only shows up as a control that ignores its `size` prop, long after the
+ * line that caused it was written.
+ *
+ * Registering the families here is what makes "the last class wins" true for
+ * the whole system, including for consumers overriding a component's default.
+ */
+export const twMergeConfig = extendTailwindMerge<'ds-height' | 'ds-width' | 'ds-size'>({
+  extend: {
+    classGroups: {
+      'ds-height': [
+        {
+          h: [
+            'control-2xs',
+            'control-xs',
+            'control-sm',
+            'control-md',
+            'control-lg',
+            'control-xl',
+            'row-sm',
+            'row-md',
+            'row-lg',
+            'rail-item',
+            'topbar',
+            'statusbar',
+          ],
+        },
+      ],
+      'ds-width': [
+        {
+          w: ['rail', 'rail-expanded', 'sidebar', 'sidebar-compact'],
+        },
+      ],
+      // `size-*` is a real Tailwind group, but the token-derived values are
+      // not, so they need the same treatment as height and width.
+      'ds-size': [
+        {
+          size: [
+            'control-2xs',
+            'control-xs',
+            'control-sm',
+            'control-md',
+            'control-lg',
+            'control-xl',
+            'rail-item',
+          ],
+        },
+      ],
+    },
+  },
+})
+
+/**
+ * Merge conditional class values, letting the last conflicting utility win.
+ *
+ * Accepts an object whose keys are classes and whose values enable them, which
+ * is the form the design-system linter can read statically:
+ *
+ *   cn('base', { 'is-open': open(), 'is-disabled': disabled() })
+ *
+ * A template literal (`cn(`base--${value}`)`) is invisible to the linter and
+ * will be reported, because a class the linter cannot read is a class it
+ * cannot check against the theme.
+ */
+export function cn(...inputs: ClassValue[]): string {
+  return twMergeConfig(clsx(inputs))
+}

package/dist/r/src/lib/variants.ts

@@ -0,0 +1,62 @@
+/**
+ * The component variant vocabulary.
+ *
+ * Every component's appearance is declared with `cva`, and `@shadcn/lint`
+ * reads those definitions: it is how the linter can tell a caller "use the
+ * `destructive` variant" instead of only "this class is not allowed here".
+ * That is the whole reason variants live in the open rather than in a
+ * component's head.
+ *
+ * Three axes recur across the system, and components must reuse these names
+ * rather than inventing synonyms:
+ *
+ *   variant  what the control *is for*  — primary, secondary, destructive, …
+ *   size     how much room it takes     — 2xs, xs, sm, md, lg, xl
+ *   tone     what it *communicates*     — neutral, success, warning, …
+ *
+ * A component that needs a fourth axis is usually two components.
+ */
+export { cva, type VariantProps } from 'class-variance-authority'
+
+/**
+ * The shared control-size ladder, in Tailwind height utilities.
+ *
+ * Spread into a `size` axis so every interactive control in the system steps
+ * through the same heights. A button and a select at `size="sm"` are both 28px
+ * because they read the same token, not because two authors agreed.
+ */
+export const controlSize = {
+  '2xs': 'h-control-2xs px-control-2xs text-2xs gap-1',
+  xs: 'h-control-xs px-control-xs text-xs gap-1',
+  sm: 'h-control-sm px-control-sm text-xs gap-1.5',
+  md: 'h-control-md px-control-md text-sm gap-2',
+  lg: 'h-control-lg px-control-lg text-sm gap-2',
+  xl: 'h-control-xl px-control-xl text-base gap-2.5',
+} as const
+
+/** Square counterparts for icon-only controls: the height, with equal width. */
+export const controlSizeIcon = {
+  '2xs': 'size-control-2xs p-0',
+  xs: 'size-control-xs p-0',
+  sm: 'size-control-sm p-0',
+  md: 'size-control-md p-0',
+  lg: 'size-control-lg p-0',
+  xl: 'size-control-xl p-0',
+} as const
+
+export const controlSizes = ['2xs', 'xs', 'sm', 'md', 'lg', 'xl'] as const
+export type ControlSize = (typeof controlSizes)[number]
+
+/**
+ * The tactile half of every interactive control.
+ *
+ * Kept in one place so hover, active, focus and disabled read identically on a
+ * button, a toggle, a menu row and a tab. The `active:` step is only one
+ * lightness rung below hover — enough to feel pressed, not enough to look like
+ * a different state.
+ */
+export const controlInteractive =
+  'transition-colors ease-out outline-none focus-visible:border-ring focus-visible:ring-3 focus-visible:ring-primary-subtle disabled:pointer-events-none disabled:opacity-50 aria-disabled:pointer-events-none aria-disabled:opacity-50'
+
+/** The shared focus treatment for surfaces that are not focusable controls. */
+export const surfaceInteractive = 'transition-colors ease-out outline-none'

package/dist/r/src/lib/version-notes.ts

@@ -0,0 +1,65 @@
+/**
+ * Version notes, as text.
+ *
+ * A release changelog arrives as markdown and is shown to a reader who wants to
+ * know what changed, not to a renderer. Rendering it would mean a markdown
+ * dependency, a sanitiser, and a typographic result that competes with the
+ * dialog's own type scale — so the markup is stripped to its words instead.
+ *
+ * The order matters: images and links are unwrapped to their alt text and label
+ * *before* the emphasis rules run, because `[a](b)` contains brackets and
+ * parentheses that the later patterns would otherwise trip on.
+ */
+export function plainTextFromMarkdown(markdown: string): string {
+  return markdown
+    .replace(/\r\n/g, '\n')
+    .replace(/!\[([^\]]*)\]\([^)]*\)/g, '$1')
+    .replace(/\[([^\]]+)\]\([^)]*\)/g, '$1')
+    .replace(/^[ \t]*#{1,6}[ \t]*/gm, '')
+    .replace(/^[ \t]*>[ \t]?/gm, '')
+    .replace(/^[ \t]*---+[ \t]*$/gm, '')
+    .replace(/^[ \t]*[-*+][ \t]+/gm, '• ')
+    .replace(/^[ \t]*\d+\.[ \t]+/gm, '')
+    .replace(/```[^\n]*\n?/g, '')
+    .replace(/`([^`]+)`/g, '$1')
+    .replace(/\*\*([^*]+)\*\*/g, '$1')
+    .replace(/__([^_]+)__/g, '$1')
+    .replace(/\*([^*]+)\*/g, '$1')
+    .replace(/_([^_]+)_/g, '$1')
+    .replace(/\n{3,}/g, '\n\n')
+    .trim()
+}
+
+/**
+ * A release date, formatted for a reader. Returns the input when it cannot be
+ * parsed — a date a build tool wrote in an unusual format is still better shown
+ * verbatim than dropped.
+ */
+export function formatReleaseDate(value: string | null): string | null {
+  if (!value) return null
+  const date = new Date(value)
+  if (Number.isNaN(date.getTime())) return value
+  return new Intl.DateTimeFormat(undefined, {
+    day: 'numeric',
+    month: 'short',
+    year: 'numeric',
+  }).format(date)
+}
+
+/**
+ * Bytes as a reader-facing size. Used by the update dialog's progress readout,
+ * where the number is reassurance rather than data — "12.4 MB of 48.1 MB" says
+ * the download is moving, which a percentage alone does not.
+ */
+export function formatBytes(bytes: number): string {
+  if (!Number.isFinite(bytes) || bytes < 0) return '—'
+  if (bytes < 1024) return `${bytes} B`
+  const units = ['kB', 'MB', 'GB']
+  let value = bytes / 1024
+  let unit = 0
+  while (value >= 1024 && unit < units.length - 1) {
+    value /= 1024
+    unit += 1
+  }
+  return `${value.toFixed(value >= 10 ? 0 : 1)} ${units[unit]}`
+}