nuxt-ui-tools 1.0.1 → 1.2.0

package/dist/runtime/dashboard/utils/sparkline.js

@@ -0,0 +1,53 @@
+const WIDTH = 100;
+const HEIGHT = 32;
+const INSET = 2;
+export function resolveDashboardSparkline(values) {
+  const finite = values.filter((value) => Number.isFinite(value));
+  if (finite.length === 0) return null;
+  const min = Math.min(...finite);
+  const max = Math.max(...finite);
+  const step = values.length > 1 ? WIDTH / (values.length - 1) : 0;
+  const y = (value) => max === min ? HEIGHT / 2 : INSET + (1 - (value - min) / (max - min)) * (HEIGHT - INSET * 2);
+  const runs = [];
+  let run = [];
+  values.forEach((value, index) => {
+    if (value === null || value === void 0 || !Number.isFinite(value)) {
+      if (run.length) runs.push(run);
+      run = [];
+      return;
+    }
+    run.push([values.length > 1 ? index * step : WIDTH / 2, y(value)]);
+  });
+  if (run.length) runs.push(run);
+  const line = runs.map(toPath).join("");
+  const area = runs.filter((points) => points.length > 1).map((points) => {
+    const first = points[0];
+    const last = points.at(-1);
+    if (!first || !last) return "";
+    return `${toPath(points)}L${last[0].toFixed(2)},${HEIGHT}L${first[0].toFixed(2)},${HEIGHT}Z`;
+  }).join("");
+  return { area, line };
+}
+export function resolveDashboardSparkBars(values) {
+  const finite = values.filter((value) => Number.isFinite(value));
+  if (finite.length === 0) return null;
+  const max = Math.max(0, ...finite);
+  const slot = WIDTH / Math.max(1, values.length);
+  const width = Math.max(1, slot * 0.62);
+  return values.flatMap((value, index) => {
+    if (value === null || value === void 0 || !Number.isFinite(value)) return [];
+    const height = max > 0 ? Math.max(1.5, Math.max(0, value) / max * (HEIGHT - INSET)) : 1.5;
+    return [
+      {
+        height: Number(height.toFixed(2)),
+        last: index === values.length - 1,
+        width: Number(width.toFixed(2)),
+        x: Number((index * slot + (slot - width) / 2).toFixed(2)),
+        y: Number((HEIGHT - height).toFixed(2))
+      }
+    ];
+  });
+}
+function toPath(points) {
+  return points.map(([x, y], index) => `${index ? "L" : "M"}${x.toFixed(2)},${y.toFixed(2)}`).join("");
+}

package/dist/runtime/dashboard/utils/state.d.ts

@@ -0,0 +1,28 @@
+import type { DashboardResourceState } from '../types/index.js';
+/**
+ * Combines the states of several sources the way a dependent value experiences them: any error
+ * wins, then any pending source. Idle sources were not requested (gated by `requires`, or a
+ * deferred query nobody activated), so they do not hold the value back unless all are idle.
+ */
+export declare function combineDashboardStates(states: readonly DashboardResourceState[]): DashboardResourceState;
+/** Oldest defined timestamp of a set of sources: they are all at least this fresh. */
+export declare function resolveDashboardUpdatedAt(values: readonly (number | undefined)[]): number | undefined;
+/** Refreshes sources in parallel and reports every failure at once. */
+export declare function refreshDashboardSources(sources: readonly {
+    refresh: () => Promise<void>;
+}[]): Promise<void>;
+/** URL segment of the current view. A root param cannot use it while the dashboard has views. */
+export declare const DASHBOARD_VIEW_URL_KEY = "view";
+/** URL segment of the auto-refresh interval. A root param cannot use it. */
+export declare const DASHBOARD_REFRESH_URL_KEY = "refresh";
+/** URL key of the auto-refresh interval: `refresh`, or `<urlPrefix>.refresh`. */
+export declare function resolveDashboardRefreshKey(urlPrefix: string | undefined): string;
+/** Joins the non-empty segments of a URL key with dots. */
+export declare function joinDashboardUrlKey(...segments: readonly (string | undefined)[]): string;
+/**
+ * URL key prefix of one scope, named after what it holds: none for the root (`year`), the view
+ * key for a view (`consumption.currency`). `urlPrefix` namespaces both when set.
+ */
+export declare function resolveDashboardScopePrefix(urlPrefix: string | undefined, viewKey?: string): string;
+/** URL key of the current view: `view`, or `<urlPrefix>.view`. */
+export declare function resolveDashboardViewKey(urlPrefix: string | undefined): string;

package/dist/runtime/dashboard/utils/state.js

@@ -0,0 +1,32 @@
+export function combineDashboardStates(states) {
+  if (states.includes("error")) return "error";
+  if (states.includes("loading")) return "loading";
+  if (states.length > 0 && states.every((state) => state === "idle")) return "idle";
+  return "ready";
+}
+export function resolveDashboardUpdatedAt(values) {
+  let oldest;
+  for (const value of values) {
+    if (value !== void 0 && (oldest === void 0 || value < oldest)) oldest = value;
+  }
+  return oldest;
+}
+export async function refreshDashboardSources(sources) {
+  const results = await Promise.allSettled(sources.map((source) => source.refresh()));
+  const errors = results.flatMap((result) => result.status === "rejected" ? [result.reason] : []);
+  if (errors.length > 0) throw new AggregateError(errors, "Dashboard refresh failed");
+}
+export const DASHBOARD_VIEW_URL_KEY = "view";
+export const DASHBOARD_REFRESH_URL_KEY = "refresh";
+export function resolveDashboardRefreshKey(urlPrefix) {
+  return joinDashboardUrlKey(urlPrefix, DASHBOARD_REFRESH_URL_KEY);
+}
+export function joinDashboardUrlKey(...segments) {
+  return segments.filter(Boolean).join(".");
+}
+export function resolveDashboardScopePrefix(urlPrefix, viewKey) {
+  return joinDashboardUrlKey(urlPrefix, viewKey);
+}
+export function resolveDashboardViewKey(urlPrefix) {
+  return joinDashboardUrlKey(urlPrefix, DASHBOARD_VIEW_URL_KEY);
+}

package/dist/runtime/dashboard/utils/time.d.ts

@@ -0,0 +1,17 @@
+import type { DashboardTimeValue } from '../types/index.js';
+/** Epoch milliseconds of a time value; `NaN` when it cannot be parsed. */
+export declare function toDashboardTime(value: DashboardTimeValue): number;
+/**
+ * Short relative time: `now`, `3 min ago`, `2 hr ago`, `yesterday`, `4 days ago`, then the date
+ * itself from a week on (with the year when it differs from `now`).
+ */
+export declare function formatDashboardRelativeTime(time: number, now: number, locale: string): string;
+/** Full date and time, for tooltips next to a relative time. */
+export declare function formatDashboardDateTime(time: number, locale: string): string;
+/**
+ * Day heading of a feed group: `Today`, `Yesterday`, then the date. Capitalized, since it starts a
+ * line.
+ */
+export declare function formatDashboardDay(time: number, now: number, locale: string): string;
+/** Local start of the day of a time, used as a stable group key. */
+export declare function startOfDashboardDay(time: number): number;

package/dist/runtime/dashboard/utils/time.js

@@ -0,0 +1,60 @@
+import { isDate, isNumber } from "../../shared/utils/predicate.js";
+const MINUTE = 6e4;
+const HOUR = 60 * MINUTE;
+const DAY = 24 * HOUR;
+export function toDashboardTime(value) {
+  if (isNumber(value)) return value;
+  if (isDate(value)) return value.getTime();
+  return Date.parse(value);
+}
+const formatsByLocale = /* @__PURE__ */ new Map();
+function resolveTimeFormats(locale) {
+  const cached = formatsByLocale.get(locale);
+  if (cached) return cached;
+  const formats = {
+    date: new Intl.DateTimeFormat(locale, { day: "numeric", month: "short" }),
+    dateWithYear: new Intl.DateTimeFormat(locale, {
+      day: "numeric",
+      month: "short",
+      year: "numeric"
+    }),
+    full: new Intl.DateTimeFormat(locale, { dateStyle: "long", timeStyle: "short" }),
+    relative: new Intl.RelativeTimeFormat(locale, { numeric: "auto", style: "short" })
+  };
+  formatsByLocale.set(locale, formats);
+  return formats;
+}
+export function formatDashboardRelativeTime(time, now, locale) {
+  if (!Number.isFinite(time)) return "";
+  const formats = resolveTimeFormats(locale);
+  const elapsed = now - time;
+  const distance = Math.abs(elapsed);
+  const sign = elapsed >= 0 ? -1 : 1;
+  if (distance < 45e3) return formats.relative.format(0, "second");
+  if (distance < 45 * MINUTE)
+    return formats.relative.format(sign * Math.round(distance / MINUTE), "minute");
+  if (distance < 22 * HOUR)
+    return formats.relative.format(sign * Math.round(distance / HOUR), "hour");
+  if (distance < 7 * DAY) return formats.relative.format(sign * dayDistance(time, now), "day");
+  const sameYear = new Date(time).getFullYear() === new Date(now).getFullYear();
+  return (sameYear ? formats.date : formats.dateWithYear).format(time);
+}
+export function formatDashboardDateTime(time, locale) {
+  return Number.isFinite(time) ? resolveTimeFormats(locale).full.format(time) : "";
+}
+export function formatDashboardDay(time, now, locale) {
+  if (!Number.isFinite(time)) return "";
+  const formats = resolveTimeFormats(locale);
+  const days = dayDistance(time, now);
+  const sameYear = new Date(time).getFullYear() === new Date(now).getFullYear();
+  const text = days < 2 ? formats.relative.format(-days, "day") : (sameYear ? formats.date : formats.dateWithYear).format(time);
+  return text.charAt(0).toLocaleUpperCase(locale) + text.slice(1);
+}
+export function startOfDashboardDay(time) {
+  const day = new Date(time);
+  day.setHours(0, 0, 0, 0);
+  return day.getTime();
+}
+function dayDistance(time, now) {
+  return Math.round(Math.abs(startOfDashboardDay(now) - startOfDashboardDay(time)) / DAY);
+}

package/dist/runtime/dashboard/utils/tracker.d.ts

@@ -0,0 +1,12 @@
+import type { DashboardSourceLike } from '../types/index.js';
+/**
+ * Records which sources a derived value reads while it evaluates. One tracker is shared by the
+ * whole dashboard; evaluation is synchronous, so a single "current collector" slot is enough.
+ */
+export declare function createDashboardReadTracker(): {
+    record(source: DashboardSourceLike): void;
+    run<TResult>(reads: Set<DashboardSourceLike>, evaluate: () => TResult): TResult;
+};
+export type DashboardReadTracker = ReturnType<typeof createDashboardReadTracker>;
+/** The `data` object handed to `derive`: each property reads a source's data and records the read. */
+export declare function createDashboardTrackedData(sources: ReadonlyMap<string, DashboardSourceLike>, tracker: DashboardReadTracker): object;

package/dist/runtime/dashboard/utils/tracker.js

@@ -0,0 +1,31 @@
+import { markRaw } from "vue";
+export function createDashboardReadTracker() {
+  let current = null;
+  return {
+    record(source) {
+      current?.add(source);
+    },
+    run(reads, evaluate) {
+      const previous = current;
+      current = reads;
+      try {
+        return evaluate();
+      } finally {
+        current = previous;
+      }
+    }
+  };
+}
+export function createDashboardTrackedData(sources, tracker) {
+  const data = {};
+  for (const [key, source] of sources) {
+    Object.defineProperty(data, key, {
+      enumerable: true,
+      get() {
+        tracker.record(source);
+        return source.data;
+      }
+    });
+  }
+  return markRaw(data);
+}

package/dist/runtime/dashboard/utils/ui.d.ts

@@ -0,0 +1,38 @@
+import type { AppConfig } from 'nuxt/schema';
+import type { DashboardUiConfig } from '../types/index.js';
+/**
+ * Resolves the classes of one block part: library defaults, then each override layer
+ * (app config, then the `ui` prop), merged with tailwind-merge so later layers win.
+ */
+export declare function resolveDashboardClasses<TKey extends string>(defaults: Record<TKey, string>, ...layers: (Partial<Record<NoInfer<TKey>, string>> | undefined)[]): Record<TKey, string>;
+/** Default classes of `UiDashboardTable`, also used by the card's "view as table" action. */
+export declare const DASHBOARD_TABLE_CLASSES: {
+    bar: string;
+    head: string;
+    row: string;
+    table: string;
+    td: string;
+    th: string;
+    wrapper: string;
+};
+/**
+ * A row with a `select` listener: highlighted on hover and keyboard focus of its button. The row box
+ * never moves, so its divider stays aligned with the card content; the highlight is a pseudo-element
+ * reaching 8px past both edges, behind the content (`isolate` keeps it inside the row).
+ */
+export declare const DASHBOARD_SELECTABLE_ROW = "relative isolate before:pointer-events-none before:absolute before:inset-y-0 before:-inset-x-2 before:-z-10 before:rounded-md before:transition-colors has-[>button:hover]:before:bg-elevated/60 has-[>button:focus-visible]:before:bg-elevated/60";
+/**
+ * A row shown as selected (`selected` prop): the same tint as the hover, stronger, and an accent
+ * on its start edge, both drawn around the row box.
+ */
+export declare const DASHBOARD_SELECTED_ROW = "relative isolate before:pointer-events-none before:absolute before:inset-y-0 before:-inset-x-2 before:-z-10 before:rounded-md before:bg-elevated after:pointer-events-none after:absolute after:inset-y-2 after:-start-2 after:w-0.5 after:rounded-full after:bg-primary";
+/**
+ * Button stretched over a selectable row, and over its highlight. It is the row's only interactive
+ * element, so the row keeps its list semantics and its content stays plain text; controls inside
+ * the row sit above it.
+ */
+export declare const DASHBOARD_ROW_BUTTON = "absolute inset-y-0 -inset-x-2 cursor-pointer rounded-md outline-none focus-visible:ring-2 focus-visible:ring-primary focus-visible:ring-inset";
+/** Button stretched over a table row. It stays inside the row: the table may scroll sideways. */
+export declare const DASHBOARD_TABLE_ROW_BUTTON = "absolute inset-0 cursor-pointer outline-none focus-visible:ring-2 focus-visible:ring-primary focus-visible:ring-inset";
+/** Reads `appConfig.nuxtUiTools.dashboard`; apps that do not declare it get no overrides. */
+export declare function resolveAppDashboardUi(config: Pick<AppConfig, 'nuxtUiTools'>): DashboardUiConfig;

package/dist/runtime/dashboard/utils/ui.js

@@ -0,0 +1,24 @@
+import { twMerge } from "tailwind-merge";
+export function resolveDashboardClasses(defaults, ...layers) {
+  const resolved = { ...defaults };
+  for (const key in defaults) {
+    resolved[key] = twMerge(defaults[key], ...layers.map((layer) => layer?.[key]));
+  }
+  return resolved;
+}
+export const DASHBOARD_TABLE_CLASSES = {
+  bar: "h-1.5 overflow-hidden rounded-full bg-[var(--nut-dash-track)]",
+  head: "sticky top-0 z-[1] bg-default",
+  row: "border-t border-[var(--nut-dash-grid)]",
+  table: "w-full border-collapse text-[13px]",
+  td: "px-2.5 py-2 text-muted first:ps-0 last:pe-0",
+  th: "px-2.5 pt-0.5 pb-2 text-xs font-medium whitespace-nowrap text-dimmed first:ps-0 last:pe-0",
+  wrapper: "min-w-0 overflow-auto"
+};
+export const DASHBOARD_SELECTABLE_ROW = "relative isolate before:pointer-events-none before:absolute before:inset-y-0 before:-inset-x-2 before:-z-10 before:rounded-md before:transition-colors has-[>button:hover]:before:bg-elevated/60 has-[>button:focus-visible]:before:bg-elevated/60";
+export const DASHBOARD_SELECTED_ROW = "relative isolate before:pointer-events-none before:absolute before:inset-y-0 before:-inset-x-2 before:-z-10 before:rounded-md before:bg-elevated after:pointer-events-none after:absolute after:inset-y-2 after:-start-2 after:w-0.5 after:rounded-full after:bg-primary";
+export const DASHBOARD_ROW_BUTTON = "absolute inset-y-0 -inset-x-2 cursor-pointer rounded-md outline-none focus-visible:ring-2 focus-visible:ring-primary focus-visible:ring-inset";
+export const DASHBOARD_TABLE_ROW_BUTTON = "absolute inset-0 cursor-pointer outline-none focus-visible:ring-2 focus-visible:ring-primary focus-visible:ring-inset";
+export function resolveAppDashboardUi(config) {
+  return config.nuxtUiTools?.dashboard ?? {};
+}

package/dist/runtime/dashboard/utils/visibility.d.ts

@@ -0,0 +1,2 @@
+/** Runs `callback` once, when `element` first nears the viewport. Returns a stop function. */
+export declare function observeDashboardVisibility(element: Element, callback: () => void): () => void;

package/dist/runtime/dashboard/utils/visibility.js

@@ -0,0 +1,25 @@
+const callbacks = /* @__PURE__ */ new WeakMap();
+let observer = null;
+function getVisibilityObserver() {
+  observer ??= new IntersectionObserver(
+    (entries) => {
+      for (const entry of entries) {
+        if (!entry.isIntersecting) continue;
+        const callback = callbacks.get(entry.target);
+        unobserveDashboardVisibility(entry.target);
+        callback?.();
+      }
+    },
+    { rootMargin: "200px" }
+  );
+  return observer;
+}
+function unobserveDashboardVisibility(element) {
+  callbacks.delete(element);
+  observer?.unobserve(element);
+}
+export function observeDashboardVisibility(element, callback) {
+  callbacks.set(element, callback);
+  getVisibilityObserver().observe(element);
+  return () => unobserveDashboardVisibility(element);
+}

package/dist/runtime/form/types/options.d.ts

@@ -1,3 +1,4 @@
+import type { RemoteCursorOptionsPage, RemoteOptionsPage, RemoteOptionsPageRequest, RemoteOptionsPagination, RemoteOptionsResult, RemoteOptionsSearch } from '../../shared/types/remote-options.js';
 import type { FormValue } from './/index.js';
 import type { FormFieldCallback, FormFieldCallbackParams } from './callbacks.js';
 import type { FormQueryOptions } from './context.js';
@@ -67,30 +68,17 @@ export interface FormOptionConfig<TOption, TContext = NonNullable<unknown>, TDep
     /** Disable the field while its option source has no usable data yet. */
     disableOnLoading?: boolean;
 }
-/**
- * Page envelope returned by an index-paginated remote option source.
- */
-export interface FormRemoteOptionsPage<TOption> {
-    options: readonly TOption[];
-    hasMore: boolean;
-}
-/**
- * Page envelope returned by a cursor-paginated remote option source.
- */
-export interface FormRemoteCursorOptionsPage<TOption> {
-    options: readonly TOption[];
-    nextCursor: string | null;
-}
-export type FormRemoteOptionsResult<TOption> = FormRemoteOptionsPage<TOption> | FormRemoteCursorOptionsPage<TOption>;
+/** @deprecated Use `RemoteOptionsPage` from `#ui-tools/shared`. Kept for public type compatibility. */
+export type FormRemoteOptionsPage<TOption> = RemoteOptionsPage<TOption>;
+/** @deprecated Use `RemoteCursorOptionsPage` from `#ui-tools/shared`. Kept for public type compatibility. */
+export type FormRemoteCursorOptionsPage<TOption> = RemoteCursorOptionsPage<TOption>;
+/** @deprecated Use `RemoteOptionsResult` from `#ui-tools/shared`. Kept for public type compatibility. */
+export type FormRemoteOptionsResult<TOption> = RemoteOptionsResult<TOption>;
 export interface FormRemoteOptionsRequest<TContext = NonNullable<unknown>, TDeps = NonNullable<unknown>, TValue = FormValue, TOption = FormValue> extends FormFieldCallbackParams<TContext, TDeps, TValue, TOption> {
     /** Current debounced search term. Empty when the menu lists unfiltered options. */
     search: string;
     /** Requested page. `cursor` is set for cursor pagination and `index` for page pagination. */
-    page: {
-        index: number;
-        cursor: string | null;
-        size: number;
-    };
+    page: RemoteOptionsPageRequest;
     /** Parent option whose direct children are requested. Undefined for root pages. */
     parent?: NoInfer<TOption>;
 }
@@ -99,30 +87,21 @@ export interface FormRemoteSelectedRequest<TContext = NonNullable<unknown>, TDep
     values: readonly FormOptionValue[];
 }
 export type FormRemoteSource<TResult> = FormQueryOptions<TResult> | Promise<TResult>;
-export interface FormRemotePagination {
-    type: 'page' | 'cursor';
-    /** Page size forwarded to the source. */
-    size: number;
-    /** Distance from the list end that triggers the next page: pixels, or `'viewport'` for three viewport heights. Defaults to `'viewport'`. */
-    prefetchDistance?: number | 'viewport';
-}
-export interface FormRemoteSearch {
-    /** Debounce applied to typed search terms, in milliseconds. Defaults to 250. */
-    debounce?: number;
-    /** Minimum term length before a search request runs. Defaults to 0. */
-    minLength?: number;
-}
+/** @deprecated Use `RemoteOptionsPagination` from `#ui-tools/shared`. Kept for public type compatibility. */
+export type FormRemotePagination = RemoteOptionsPagination;
+/** @deprecated Use `RemoteOptionsSearch` from `#ui-tools/shared`. Kept for public type compatibility. */
+export type FormRemoteSearch = RemoteOptionsSearch;
 /**
  * Remote option configuration: server-side search, pagination, and selected-value hydration.
  */
 export interface FormRemoteOptionConfig<TOption, TContext = NonNullable<unknown>, TDeps = NonNullable<unknown>, TValue = FormValue> {
     mode: 'remote';
     /** Loads one page of options for the current search, page, and optional parent. */
-    source: (request: FormRemoteOptionsRequest<TContext, TDeps, TValue, TOption>) => FormRemoteSource<FormRemoteOptionsResult<TOption>>;
+    source: (request: FormRemoteOptionsRequest<TContext, TDeps, TValue, TOption>) => FormRemoteSource<RemoteOptionsResult<TOption>>;
     /** Hydrates selected values that the loaded pages do not contain. */
     resolveSelected?: (request: FormRemoteSelectedRequest<TContext, TDeps, TValue, TOption>) => FormRemoteSource<readonly TOption[]>;
-    pagination: FormRemotePagination;
-    search?: FormRemoteSearch;
+    pagination: RemoteOptionsPagination;
+    search?: RemoteOptionsSearch;
     /** Dependency aliases whose changes reset the loaded pages and re-run selected hydration. */
     refreshOn?: readonly string[];
     /** Clears selected values the latest successful selected hydration did not return. Defaults to `false`. */

package/dist/runtime/i18n/locales/en.js

@@ -2,6 +2,68 @@ import { defineUiToolsLocale } from "#ui-tools/i18n/define-locale";
 export default defineUiToolsLocale({
   code: "en",
   messages: {
+    dashboard: {
+      alerts: {
+        empty: "Nothing needs attention",
+        severity: {
+          error: "Critical",
+          info: "Info",
+          success: "Resolved",
+          warning: "Warning"
+        }
+      },
+      compare: {
+        caption: "vs {value} previous period",
+        none: "No comparison",
+        previous: "Previous period",
+        series: "{label} (previous period)",
+        year: "Previous year"
+      },
+      freshness: {
+        prefix: "Updated",
+        updated: "Updated {time}"
+      },
+      funnel: {
+        base: "base 100%",
+        fromPrevious: "{value} of the previous step"
+      },
+      menu: {
+        download: "Download CSV",
+        expand: "Expand",
+        hideTable: "Hide table",
+        label: "Card actions",
+        showTable: "View as table"
+      },
+      refresh: {
+        auto: "Auto-refresh",
+        label: "Refresh",
+        off: "Off"
+      },
+      rowActions: "Actions for {label}",
+      stat: {
+        goal: "Goal {value}"
+      },
+      table: {
+        actions: "Actions",
+        category: "Category",
+        change: "Change",
+        description: "Details",
+        label: "Label",
+        severity: "Severity",
+        share: "Share",
+        time: "Time",
+        total: "Total",
+        value: "Value"
+      },
+      states: {
+        empty: "No data for this period",
+        error: "This data could not be loaded",
+        errorDescription: "The rest of the dashboard is unaffected. Try again in a moment.",
+        loading: "Loading\u2026",
+        refreshing: "Refreshing\u2026",
+        retry: "Retry"
+      }
+    },
     form: {
       actions: {
         cancelButton: "Cancel",
@@ -290,7 +352,9 @@ export default defineUiToolsLocale({
           lte: "at most"
         },
         options: {
-          empty: "No matching options."
+          empty: "No matching options.",
+          loadError: "Options could not be loaded.",
+          retry: "Retry"
         },
         panel: {
           apply: "Apply",

package/dist/runtime/i18n/locales/fr.js

@@ -2,6 +2,68 @@ import { defineUiToolsLocale } from "#ui-tools/i18n/define-locale";
 export default defineUiToolsLocale({
   code: "fr",
   messages: {
+    dashboard: {
+      alerts: {
+        empty: "Rien \xE0 signaler",
+        severity: {
+          error: "Critique",
+          info: "Information",
+          success: "R\xE9solu",
+          warning: "\xC0 surveiller"
+        }
+      },
+      compare: {
+        caption: "vs {value} sur la p\xE9riode pr\xE9c\xE9dente",
+        none: "Sans comparaison",
+        previous: "P\xE9riode pr\xE9c\xE9dente",
+        series: "{label} (p\xE9riode pr\xE9c\xE9dente)",
+        year: "Ann\xE9e pr\xE9c\xE9dente"
+      },
+      freshness: {
+        prefix: "Mis \xE0 jour",
+        updated: "Mis \xE0 jour {time}"
+      },
+      funnel: {
+        base: "base 100 %",
+        fromPrevious: "{value} de l\u2019\xE9tape pr\xE9c\xE9dente"
+      },
+      menu: {
+        download: "T\xE9l\xE9charger en CSV",
+        expand: "Agrandir",
+        hideTable: "Masquer le tableau",
+        label: "Actions de la carte",
+        showTable: "Afficher en tableau"
+      },
+      refresh: {
+        auto: "Actualisation automatique",
+        label: "Actualiser",
+        off: "D\xE9sactiv\xE9e"
+      },
+      rowActions: "Actions pour {label}",
+      stat: {
+        goal: "Objectif {value}"
+      },
+      table: {
+        actions: "Actions",
+        category: "Cat\xE9gorie",
+        change: "\xC9volution",
+        description: "D\xE9tail",
+        label: "Libell\xE9",
+        severity: "Niveau",
+        share: "Part",
+        time: "Date",
+        total: "Total",
+        value: "Valeur"
+      },
+      states: {
+        empty: "Aucune donn\xE9e sur la p\xE9riode",
+        error: "Impossible de charger ces donn\xE9es",
+        errorDescription: "Le reste du tableau de bord n\u2019est pas affect\xE9. R\xE9essayez dans un instant.",
+        loading: "Chargement\u2026",
+        refreshing: "Actualisation\u2026",
+        retry: "R\xE9essayer"
+      }
+    },
     form: {
       actions: {
         cancelButton: "Annuler",
@@ -290,7 +352,9 @@ export default defineUiToolsLocale({
           lte: "au plus"
         },
         options: {
-          empty: "Aucune option correspondante."
+          empty: "Aucune option correspondante.",
+          loadError: "Impossible de charger les options.",
+          retry: "R\xE9essayer"
         },
         panel: {
           apply: "Appliquer",

package/dist/runtime/i18n/types.d.ts

@@ -78,6 +78,9 @@ export interface UiToolsTableMessages {
         };
         options: {
             empty: string;
+            /** Remote option pages failed to load. */
+            loadError: string;
+            retry: string;
         };
         booleans: {
             true: string;
@@ -362,7 +365,74 @@ export interface UiToolsFormMessages {
         };
     };
 }
+export interface UiToolsDashboardMessages {
+    states: {
+        loading: string;
+        refreshing: string;
+        empty: string;
+        error: string;
+        errorDescription: string;
+        retry: string;
+    };
+    funnel: {
+        base: string;
+        fromPrevious: string;
+    };
+    menu: {
+        label: string;
+        showTable: string;
+        hideTable: string;
+        download: string;
+        expand: string;
+    };
+    table: {
+        category: string;
+        label: string;
+        value: string;
+        total: string;
+        share: string;
+        change: string;
+        severity: string;
+        time: string;
+        description: string;
+        actions: string;
+    };
+    freshness: {
+        updated: string;
+        /** Label before a relative time ("Updated" · 3 min ago). */
+        prefix: string;
+    };
+    stat: {
+        goal: string;
+    };
+    compare: {
+        previous: string;
+        year: string;
+        none: string;
+        /** Stat caption with `compare`: "vs {value} previous period". */
+        caption: string;
+        /** Legend label of a series' comparison: "{label} (previous period)". */
+        series: string;
+    };
+    refresh: {
+        label: string;
+        auto: string;
+        off: string;
+    };
+    /** Accessible name of a row's `⋮` menu. */
+    rowActions: string;
+    alerts: {
+        empty: string;
+        severity: {
+            error: string;
+            warning: string;
+            info: string;
+            success: string;
+        };
+    };
+}
 export interface Messages {
+    dashboard: UiToolsDashboardMessages;
     form: UiToolsFormMessages;
     table: UiToolsTableMessages;
     spreadsheet: UiToolsSpreadsheetMessages;

package/dist/runtime/shared/index.d.ts

@@ -8,3 +8,5 @@ export * from './utils/predicate.js';
 export * from './utils/responsive.js';
 export * from './utils/registry.js';
 export * from './utils/render.js';
+export type * from './types/query';
+export type * from './types/remote-options';