najm-kit 2.9.0 → 2.10.0

package/dist/{NajmUIProvider-CI_73GEp.d.ts → NajmUIProvider-BnReyojl.d.ts}

@@ -3,6 +3,8 @@ import * as React from 'react';
 import React__default from 'react';
 import { e as NajmMode, a as NajmDesignConfig } from './design-types-Rkpt8Pg1.js';
 import { b as NTablePaginationLabels, N as NajmTranslate } from './paginationLabels-dZLSNxfo.js';
+import * as class_variance_authority_types from 'class-variance-authority/types';
+import { VariantProps } from 'class-variance-authority';
 
 /**
  * Defaults every `NTable` beneath the provider inherits.
@@ -28,6 +30,89 @@ declare function NTableDefaultsProvider({ children, value, }: {
 }): react_jsx_runtime.JSX.Element;
 declare function useNTableDefaults(): NTableDefaults;
 
+type NIconSource = React__default.ReactElement | React__default.ComponentType<any> | React__default.ExoticComponent<any> | string | {
+    src: string;
+    alt?: string;
+};
+type NIconProps = Omit<React__default.HTMLAttributes<HTMLElement>, "children"> & {
+    size?: string | number;
+    icon: NIconSource;
+    alt?: string;
+    color?: string;
+    className?: string;
+    strokeWidth?: number;
+    stroke?: string;
+    fill?: string;
+    onClick?: React__default.MouseEventHandler<HTMLElement>;
+    style?: React__default.CSSProperties;
+};
+declare const NIcon: React__default.FC<NIconProps>;
+
+declare const badgeVariants: (props?: {
+    variant?: "secondary" | "destructive" | "default" | "outline" | "success" | "warning";
+} & class_variance_authority_types.ClassProp) => string;
+declare const badgeColorVariants: (props?: {
+    color?: "neutral" | "primary" | "accent" | "secondary" | "destructive" | "success" | "warning" | "info";
+    look?: "solid" | "outline" | "soft" | "dash";
+    size?: "sm" | "md" | "lg";
+    shape?: "default" | "square" | "pill";
+} & class_variance_authority_types.ClassProp) => string;
+type BadgeVariantProps = VariantProps<typeof badgeVariants>;
+type BadgeColorVariantProps = VariantProps<typeof badgeColorVariants>;
+type BadgeColor = NonNullable<BadgeColorVariantProps["color"]>;
+type BadgeLook = NonNullable<BadgeColorVariantProps["look"]>;
+type BadgeDisplayLook = BadgeLook | "minimal" | "text";
+type BadgeSize = NonNullable<BadgeColorVariantProps["size"]>;
+type BadgeShape = NonNullable<BadgeColorVariantProps["shape"]>;
+type BadgeVariant = NonNullable<BadgeVariantProps["variant"]>;
+type BadgeIcon = NIconSource;
+type BadgeProps = React.ComponentProps<"span"> & {
+    asChild?: boolean;
+    variant?: BadgeVariantProps["variant"];
+    status?: string;
+    statusMap?: Record<string, BadgeColor>;
+    label?: string;
+    showIcon?: boolean;
+    color?: BadgeColor;
+    look?: BadgeDisplayLook;
+    size?: BadgeSize;
+    shape?: BadgeShape;
+    icon?: BadgeIcon;
+    iconMap?: Record<string, BadgeIcon>;
+    iconPosition?: "left" | "right";
+};
+declare function Badge({ className, variant, status, statusMap, label, showIcon, color, look, size, shape, icon, iconMap, iconPosition, asChild, children, style, ...props }: BadgeProps): react_jsx_runtime.JSX.Element;
+declare const NBadge: typeof Badge;
+type NBadgeLook = BadgeDisplayLook;
+type NBadgeProps = BadgeProps;
+
+/**
+ * Application-wide presentation policy for `<NBadge status="…" />`.
+ *
+ * This is the whole reason a project ends up with a `StatusBadge` wrapper: the
+ * badge itself is already correct, but every call site has to repeat the same
+ * look, the same shape, and the same translation lookup. Declared once on the
+ * provider, none of that reaches a call site.
+ *
+ * What stays in the application: the vocabulary and the catalog. `statusMap`
+ * and `statusLabelKeys` take *its* status tokens and *its* catalog keys — this
+ * package ships neither.
+ */
+interface NBadgeDefaults {
+    look?: NBadgeLook;
+    shape?: BadgeShape;
+    size?: BadgeSize;
+    showIcon?: boolean;
+    /** Status token to badge color. Merged over the packaged vocabulary. */
+    statusMap?: Record<string, BadgeColor>;
+    /** Badge color to icon, used when `showIcon` is on. */
+    iconMap?: Record<string, BadgeIcon>;
+    /** Status token to finished label text. Wins over `statusLabelKeys`. */
+    statusLabels?: Record<string, string>;
+    /** Status token to catalog key, resolved through the provider's `t`. */
+    statusLabelKeys?: Record<string, string>;
+}
+
 /**
  * Theme and time zone, the two preferences that outlive a render.
  *
@@ -136,6 +221,14 @@ interface NajmUIProviderProps extends Omit<NajmPreferencesProviderProps, "childr
      * same reason as `t`.
      */
     tableDefaults?: NTableDefaults;
+    /**
+     * Presentation policy for `<NBadge status="…" />`: the look, the shape, and
+     * the map from the application's status tokens to its catalog keys.
+     *
+     * This is the prop that deletes a project's `StatusBadge` wrapper. Memoize it
+     * for the same reason as `t`.
+     */
+    badgeDefaults?: NBadgeDefaults;
 }
 /**
  * The one provider a Najm application mounts for UI concerns.
@@ -156,6 +249,6 @@ interface NajmUIProviderProps extends Omit<NajmPreferencesProviderProps, "childr
  * an application with a runtime theme editor hoist preferences above its
  * design context without forking this component.
  */
-declare function NajmUIProvider({ children, design, initialDesign, className, t, paginationKeyPrefix, tableDefaults, initialTheme, initialTimeZone, onThemeChange, onTimeZoneChange, normalizeTimeZone, }: NajmUIProviderProps): react_jsx_runtime.JSX.Element;
+declare function NajmUIProvider({ children, design, initialDesign, className, t, paginationKeyPrefix, tableDefaults, badgeDefaults, initialTheme, initialTimeZone, onThemeChange, onTimeZoneChange, normalizeTimeZone, }: NajmUIProviderProps): react_jsx_runtime.JSX.Element;
 
-export { DEFAULT_TIME_ZONE as D, type NajmUIProviderProps as N, type NTableDefaults as a, NTableDefaultsProvider as b, type NajmPreferencesContextValue as c, NajmPreferencesProvider as d, type NajmPreferencesProviderProps as e, NajmUIProvider as f, useNajmPreferencesContext as g, useNajmTheme as h, useNajmTimeZone as i, useNTableDefaults as u };
+export { type BadgeColor as B, DEFAULT_TIME_ZONE as D, type NajmUIProviderProps as N, type NIconSource as a, type BadgeShape as b, Badge as c, type BadgeIcon as d, type BadgeLook as e, type BadgeProps as f, type BadgeSize as g, type BadgeVariant as h, NBadge as i, type NBadgeDefaults as j, type NBadgeLook as k, type NBadgeProps as l, NIcon as m, type NIconProps as n, type NTableDefaults as o, NTableDefaultsProvider as p, type NajmPreferencesContextValue as q, NajmPreferencesProvider as r, type NajmPreferencesProviderProps as s, NajmUIProvider as t, badgeColorVariants as u, badgeVariants as v, useNTableDefaults as w, useNajmPreferencesContext as x, useNajmTheme as y, useNajmTimeZone as z };

package/dist/adapters/app.d.ts

@@ -4,9 +4,12 @@ import { F as FormDevToolsOptions, N as NBrandingInput } from '../formFill-BcH-m
 import { NajmNextUIProviderProps } from './next.js';
 import 'react';
 import 'zod';
-import '../NajmUIProvider-CI_73GEp.js';
+import 'next/image';
+import '../NajmUIProvider-BnReyojl.js';
 import '../design-types-Rkpt8Pg1.js';
 import '../paginationLabels-dZLSNxfo.js';
+import 'class-variance-authority/types';
+import 'class-variance-authority';
 
 /** Branding shown by the kit's chrome. Purely presentational values. */
 interface NajmAppBranding {

package/dist/adapters/app.mjs

@@ -1,7 +1,7 @@
 'use client';
-import { FormDevToolsProvider, NBrandingStateProvider, NajmFormatProvider } from '../chunk-GHMR45H3.mjs';
-import { NajmNextUIProvider } from '../chunk-IRFFSAO2.mjs';
-import '../chunk-USZUOJMK.mjs';
+import { FormDevToolsProvider, NBrandingStateProvider, NajmFormatProvider } from '../chunk-HML2JZXT.mjs';
+import { NajmNextUIProvider } from '../chunk-EUQOTPLV.mjs';
+import '../chunk-FDONJASN.mjs';
 import '../chunk-KVZACF4G.mjs';
 import '../chunk-JABLSOQN.mjs';
 import * as React from 'react';

package/dist/adapters/next.d.ts

@@ -1,8 +1,11 @@
 import * as react_jsx_runtime from 'react/jsx-runtime';
 import React__default from 'react';
-import { N as NajmUIProviderProps } from '../NajmUIProvider-CI_73GEp.js';
+import { ImageProps } from 'next/image';
+import { N as NajmUIProviderProps } from '../NajmUIProvider-BnReyojl.js';
 import '../design-types-Rkpt8Pg1.js';
 import '../paginationLabels-dZLSNxfo.js';
+import 'class-variance-authority/types';
+import 'class-variance-authority';
 
 interface NextLinkAdapterProps extends Record<string, any> {
     href: string;
@@ -20,6 +23,28 @@ declare function useNextNavigationAdapter(): {
     push: (path: string) => void;
     replace: (path: string) => void;
 };
+interface NNextImageProps extends Omit<ImageProps, 'src' | 'onError'> {
+    src: string;
+    /** Swapped in once `src` fails to load. Tried exactly once. */
+    fallbackSrc?: string;
+    onError?: ImageProps['onError'];
+}
+/**
+ * `next/image` with the fallback behavior of `NImage`, for applications that
+ * want the optimizer, the layout reservation, and `fill`/`sizes`.
+ *
+ * Lives only in `najm-kit/next`. The root entry must stay installable without
+ * Next, which is why this cannot be a prop on `NImage`.
+ *
+ * It classifies nothing. An application that serves an asset from a route the
+ * browser must reach directly — an authenticated one, say — passes
+ * `unoptimized` at the call site, because whether a route is protected is the
+ * application's fact and not something a URL shape can be read for. Note also
+ * what `unoptimized` is not: it changes delivery mechanics only. Session
+ * validation, permissions, and what bytes come back remain entirely the
+ * backend's.
+ */
+declare function NNextImage({ src, fallbackSrc, loading, priority, onError, ...props }: NNextImageProps): react_jsx_runtime.JSX.Element;
 /** Where `NajmNextUIProvider` POSTs each preference. */
 interface NajmNextUIEndpoints {
     /** Defaults to `/api/ui-theme`. Receives `{ theme }`. */
@@ -50,4 +75,4 @@ interface NajmNextUIProviderProps extends Omit<NajmUIProviderProps, 'onThemeChan
  */
 declare function NajmNextUIProvider({ endpoints, refreshOnChange, ...props }: NajmNextUIProviderProps): react_jsx_runtime.JSX.Element;
 
-export { type NajmNextUIEndpoints, NajmNextUIProvider, type NajmNextUIProviderProps, NextLinkAdapter, type NextLinkAdapterProps, useNextNavigationAdapter };
+export { NNextImage, type NNextImageProps, type NajmNextUIEndpoints, NajmNextUIProvider, type NajmNextUIProviderProps, NextLinkAdapter, type NextLinkAdapterProps, useNextNavigationAdapter };

package/dist/adapters/next.mjs

@@ -1,3 +1,3 @@
-export { NajmNextUIProvider, NextLinkAdapter, useNextNavigationAdapter } from '../chunk-IRFFSAO2.mjs';
-import '../chunk-USZUOJMK.mjs';
+export { NNextImage, NajmNextUIProvider, NextLinkAdapter, useNextNavigationAdapter } from '../chunk-EUQOTPLV.mjs';
+import '../chunk-FDONJASN.mjs';
 import '../chunk-KVZACF4G.mjs';

package/dist/{chunk-IRFFSAO2.mjs → chunk-EUQOTPLV.mjs}

@@ -1,6 +1,7 @@
-import { NajmUIProvider } from './chunk-USZUOJMK.mjs';
+import { useImageChain, normalizeImageSources, NajmUIProvider } from './chunk-FDONJASN.mjs';
 import React from 'react';
 import { useRouter } from 'next/navigation';
+import NextImage from 'next/image';
 import { jsx } from 'react/jsx-runtime';
 
 function NextLinkAdapter({ children, ...props }) {
@@ -21,6 +22,29 @@ function useNextNavigationAdapter() {
     }
   };
 }
+function NNextImage({
+  src,
+  fallbackSrc,
+  loading,
+  priority,
+  onError,
+  ...props
+}) {
+  const chain = useImageChain(normalizeImageSources([src, fallbackSrc]));
+  return /* @__PURE__ */ jsx(
+    NextImage,
+    {
+      ...props,
+      priority,
+      loading: loading ?? (priority ? void 0 : "lazy"),
+      src: chain.src ?? src,
+      onError: (event) => {
+        chain.markFailed();
+        onError?.(event);
+      }
+    }
+  );
+}
 var DEFAULT_THEME_ENDPOINT = "/api/ui-theme";
 var DEFAULT_TIME_ZONE_ENDPOINT = "/api/ui-timezone";
 async function postPreference(endpoint, body) {
@@ -68,4 +92,4 @@ function NajmNextUIProvider({
   );
 }
 
-export { NajmNextUIProvider, NextLinkAdapter, useNextNavigationAdapter };
+export { NNextImage, NajmNextUIProvider, NextLinkAdapter, useNextNavigationAdapter };

package/dist/{chunk-USZUOJMK.mjs → chunk-FDONJASN.mjs}

@@ -3,6 +3,76 @@ import * as React2 from 'react';
 import React2__default from 'react';
 import { jsx } from 'react/jsx-runtime';
 
+// src/components/Badge/status.ts
+var NAJM_STATUS_COLORS = {
+  active: "success",
+  approved: "success",
+  completed: "success",
+  confirmed: "success",
+  delivered: "success",
+  paid: "success",
+  published: "success",
+  succeeded: "success",
+  validated: "success",
+  verified: "success",
+  in_preparation: "warning",
+  in_progress: "warning",
+  out_for_delivery: "warning",
+  pending: "warning",
+  pending_email_verification: "warning",
+  pending_review: "warning",
+  processing: "warning",
+  submitted: "warning",
+  paused: "info",
+  purchased: "info",
+  scheduled: "info",
+  archived: "neutral",
+  cancelled: "neutral",
+  canceled: "neutral",
+  closed: "neutral",
+  draft: "neutral",
+  inactive: "neutral",
+  stopped: "neutral",
+  unknown: "neutral",
+  blocked: "destructive",
+  expired: "destructive",
+  failed: "destructive",
+  refunded: "destructive",
+  rejected: "destructive",
+  suspended: "destructive"
+};
+var NAJM_COLOR_TEXT_CLASSES = {
+  primary: "text-primary",
+  secondary: "text-secondary-foreground",
+  accent: "text-accent-foreground",
+  neutral: "text-muted-foreground",
+  info: "text-info",
+  success: "text-success",
+  warning: "text-warning",
+  destructive: "text-destructive"
+};
+function normalizeStatusToken(status) {
+  return status.trim().toLowerCase().replace(/[\s-]+/g, "_");
+}
+function lookup(map, status, normalized) {
+  if (!map) return void 0;
+  return map[status] ?? map[normalized];
+}
+function findStatusColor(status, statusMap) {
+  if (!status) return void 0;
+  const normalized = normalizeStatusToken(status);
+  return lookup(statusMap, status, normalized) ?? lookup(NAJM_STATUS_COLORS, status, normalized);
+}
+function resolveStatusColor(status, statusMap, fallback = "neutral") {
+  return findStatusColor(status, statusMap) ?? fallback;
+}
+function colorTextClass(color) {
+  return NAJM_COLOR_TEXT_CLASSES[color] ?? "text-foreground";
+}
+function statusTextClass(status, statusMap, fallback) {
+  const color = findStatusColor(status, statusMap) ?? fallback;
+  return color ? colorTextClass(color) : "";
+}
 var NTableDefaultsContext = React2__default.createContext({});
 function NTableDefaultsProvider({
   children,
@@ -190,12 +260,41 @@ function NajmDesignEditorProvider({
 }
 function noop() {
 }
+var NBadgeDefaultsContext = React2.createContext(null);
+function NBadgeDefaultsProvider({
+  defaults,
+  t,
+  children
+}) {
+  const value = React2.useMemo(
+    () => ({ defaults, t }),
+    [defaults, t]
+  );
+  return /* @__PURE__ */ jsx(NBadgeDefaultsContext.Provider, { value, children });
+}
+function useNBadgeDefaults() {
+  return React2.useContext(NBadgeDefaultsContext);
+}
+function resolveBadgeStatusLabel(status, defaults, t) {
+  if (!defaults) return void 0;
+  const normalized = normalizeStatusToken(status);
+  const literal = defaults.statusLabels?.[status] ?? defaults.statusLabels?.[normalized];
+  if (literal !== void 0) return literal;
+  const key = defaults.statusLabelKeys?.[status] ?? defaults.statusLabelKeys?.[normalized];
+  return key !== void 0 && t ? t(key) : void 0;
+}
+function mergeBadgeMaps(base, overrides) {
+  if (!base) return overrides;
+  if (!overrides) return base;
+  return { ...base, ...overrides };
+}
 function NajmUICore({
   children,
   className,
   t,
   paginationKeyPrefix = DEFAULT_PAGINATION_KEY_PREFIX,
-  tableDefaults
+  tableDefaults,
+  badgeDefaults
 }) {
   const { theme } = useNajmTheme();
   const design = useNajmDesignEditor()?.design ?? EMPTY_DESIGN;
@@ -211,7 +310,7 @@ function NajmUICore({
       config: design,
       mode: theme,
       className: cn("min-h-full", className),
-      children: /* @__PURE__ */ jsx(NTableDefaultsProvider, { value: defaults, children })
+      children: /* @__PURE__ */ jsx(NTableDefaultsProvider, { value: defaults, children: /* @__PURE__ */ jsx(NBadgeDefaultsProvider, { defaults: badgeDefaults, t, children }) })
     }
   );
 }
@@ -223,6 +322,7 @@ function NajmUIProvider({
   t,
   paginationKeyPrefix,
   tableDefaults,
+  badgeDefaults,
   initialTheme,
   initialTimeZone,
   onThemeChange,
@@ -237,6 +337,7 @@ function NajmUIProvider({
       t,
       paginationKeyPrefix,
       tableDefaults,
+      badgeDefaults,
       children
     }
   ) });
@@ -254,4 +355,63 @@ function NajmUIProvider({
   );
 }
 
-export { DEFAULT_PAGINATION_KEY_PREFIX, DEFAULT_TIME_ZONE, EMPTY_DESIGN, NTableDefaultsProvider, NajmDesignEditorProvider, NajmPreferencesProvider, NajmUIProvider, buildPaginationLabels, useNTableDefaults, useNajmDesignEditor, useNajmPreferencesContext, useNajmTheme, useNajmTimeZone, useResolvedPaginationLabels };
+// src/lib/imageSource.ts
+var INLINE_SOURCE = /^(?:data|blob):/i;
+function withSrcVersion(src, version) {
+  if (version === null || version === void 0 || version === "") return src;
+  if (INLINE_SOURCE.test(src)) return src;
+  const separator = src.includes("?") ? "&" : "?";
+  return `${src}${separator}v=${encodeURIComponent(String(version))}`;
+}
+function normalizeImageSources(candidates, version) {
+  const sources = [];
+  for (const candidate of candidates) {
+    const trimmed = candidate?.trim();
+    if (!trimmed) continue;
+    const stamped = withSrcVersion(trimmed, version);
+    if (!sources.includes(stamped)) sources.push(stamped);
+  }
+  return sources;
+}
+function selectImageSource(sources, failed) {
+  return sources.find((source) => !failed.includes(source));
+}
+var NO_FAILURES = [];
+function useImageChain(sources) {
+  const key = JSON.stringify(sources);
+  const [state, setState] = React2.useState(() => ({
+    key,
+    failed: NO_FAILURES,
+    loaded: null
+  }));
+  const fresh = { key, failed: NO_FAILURES, loaded: null };
+  const current = state.key === key ? state : fresh;
+  if (state.key !== key) setState(fresh);
+  const active = selectImageSource(sources, current.failed);
+  const markLoaded = React2.useCallback(() => {
+    if (active === void 0) return;
+    setState(
+      (prev) => prev.key !== key || prev.loaded === active ? prev : { ...prev, loaded: active }
+    );
+  }, [key, active]);
+  const markFailed = React2.useCallback(() => {
+    if (active === void 0) return;
+    setState((prev) => {
+      if (prev.key !== key || prev.failed.includes(active)) return prev;
+      return {
+        ...prev,
+        failed: [...prev.failed, active],
+        loaded: prev.loaded === active ? null : prev.loaded
+      };
+    });
+  }, [key, active]);
+  return {
+    src: active ?? sources[sources.length - 1],
+    exhausted: sources.length > 0 && active === void 0,
+    loaded: active !== void 0 && current.loaded === active,
+    markLoaded,
+    markFailed
+  };
+}
+
+export { DEFAULT_PAGINATION_KEY_PREFIX, DEFAULT_TIME_ZONE, EMPTY_DESIGN, NAJM_COLOR_TEXT_CLASSES, NAJM_STATUS_COLORS, NTableDefaultsProvider, NajmDesignEditorProvider, NajmPreferencesProvider, NajmUIProvider, buildPaginationLabels, colorTextClass, findStatusColor, mergeBadgeMaps, normalizeImageSources, normalizeStatusToken, resolveBadgeStatusLabel, resolveStatusColor, statusTextClass, useImageChain, useNBadgeDefaults, useNTableDefaults, useNajmDesignEditor, useNajmPreferencesContext, useNajmTheme, useNajmTimeZone, useResolvedPaginationLabels };

package/dist/{chunk-GHMR45H3.mjs → chunk-HML2JZXT.mjs}

@@ -1,4 +1,4 @@
-import { useNajmPreferencesContext } from './chunk-USZUOJMK.mjs';
+import { useNajmPreferencesContext } from './chunk-FDONJASN.mjs';
 import { humanizeToken, DEFAULT_PLACEHOLDER, formatRelativeTime, formatTime, formatDateTime, formatDate, formatPercent, formatNumber, formatCurrency } from './chunk-JABLSOQN.mjs';
 import * as React2 from 'react';
 import { createContext, useContext, useMemo, useState, useCallback } from 'react';