najm-kit 2.9.0 → 2.11.0

package/dist/chunk-EEBLEDNI.mjs

@@ -0,0 +1,480 @@
+import { NajmDesignProvider, cn } from './chunk-KVZACF4G.mjs';
+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,
+  value
+}) {
+  return /* @__PURE__ */ jsx(NTableDefaultsContext.Provider, { value, children });
+}
+function useNTableDefaults() {
+  return React2__default.useContext(NTableDefaultsContext);
+}
+function useResolvedPaginationLabels(own) {
+  const defaults = useNTableDefaults();
+  const inherited = defaults.paginationLabels;
+  return React2__default.useMemo(
+    () => ({ ...inherited, ...own }),
+    [inherited, own]
+  );
+}
+var NajmPreferencesContext = React2.createContext(null);
+var DEFAULT_TIME_ZONE = "UTC";
+function isValidTimeZone(value) {
+  try {
+    new Intl.DateTimeFormat(void 0, { timeZone: value });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function defaultNormalizeTimeZone(value) {
+  return isValidTimeZone(value) ? value : DEFAULT_TIME_ZONE;
+}
+function applyTheme(theme) {
+  if (typeof document === "undefined") return;
+  document.documentElement.classList.toggle("dark", theme === "dark");
+}
+function applyTimeZone(timeZone) {
+  if (typeof document === "undefined") return;
+  document.documentElement.dataset.timeZone = timeZone;
+}
+function NajmPreferencesProvider({
+  children,
+  initialTheme = "light",
+  initialTimeZone = DEFAULT_TIME_ZONE,
+  onThemeChange,
+  onTimeZoneChange,
+  normalizeTimeZone = defaultNormalizeTimeZone
+}) {
+  const [theme, setThemeState] = React2.useState(initialTheme);
+  const [timeZone, setTimeZoneState] = React2.useState(
+    () => normalizeTimeZone(initialTimeZone)
+  );
+  const onThemeChangeRef = React2.useRef(onThemeChange);
+  const onTimeZoneChangeRef = React2.useRef(onTimeZoneChange);
+  const normalizeRef = React2.useRef(normalizeTimeZone);
+  React2.useEffect(() => {
+    onThemeChangeRef.current = onThemeChange;
+    onTimeZoneChangeRef.current = onTimeZoneChange;
+    normalizeRef.current = normalizeTimeZone;
+  });
+  React2.useEffect(() => {
+    applyTheme(theme);
+    applyTimeZone(timeZone);
+  }, []);
+  const setTheme = React2.useCallback(async (next) => {
+    setThemeState(next);
+    applyTheme(next);
+    await onThemeChangeRef.current?.(next);
+  }, []);
+  const setTimeZone = React2.useCallback(async (next) => {
+    const normalized = normalizeRef.current(next);
+    setTimeZoneState(normalized);
+    applyTimeZone(normalized);
+    await onTimeZoneChangeRef.current?.(normalized);
+  }, []);
+  const value = React2.useMemo(
+    () => ({ theme, setTheme, timeZone, setTimeZone }),
+    [theme, setTheme, timeZone, setTimeZone]
+  );
+  return /* @__PURE__ */ jsx(NajmPreferencesContext.Provider, { value, children });
+}
+function useNajmPreferencesContext() {
+  return React2.useContext(NajmPreferencesContext);
+}
+function usePreferencesOrThrow(hook) {
+  const value = React2.useContext(NajmPreferencesContext);
+  if (!value) {
+    throw new Error(
+      `${hook} must be rendered under a NajmUIProvider or NajmPreferencesProvider.`
+    );
+  }
+  return value;
+}
+function useNajmTheme() {
+  const { theme, setTheme } = usePreferencesOrThrow("useNajmTheme");
+  return React2.useMemo(() => ({ theme, setTheme }), [theme, setTheme]);
+}
+function useNajmTimeZone() {
+  const { timeZone, setTimeZone } = usePreferencesOrThrow("useNajmTimeZone");
+  return React2.useMemo(
+    () => ({ timeZone, setTimeZone }),
+    [timeZone, setTimeZone]
+  );
+}
+
+// src/providers/paginationLabels.ts
+var DEFAULT_PAGINATION_KEY_PREFIX = "common.pagination";
+function buildPaginationLabels(t, prefix = DEFAULT_PAGINATION_KEY_PREFIX) {
+  const key = (field) => `${prefix}.${field}`;
+  return {
+    rowsPerPage: t(key("rowsPerPage")),
+    pagination: t(key("pagination")),
+    firstPage: t(key("firstPage")),
+    previousPage: t(key("previousPage")),
+    nextPage: t(key("nextPage")),
+    lastPage: t(key("lastPage")),
+    goToPage: (page) => t(key("goToPage"), { page }),
+    currentPage: (page) => t(key("currentPage"), { page }),
+    pageOf: (page, pageCount) => t(key("pageOf"), { page, pageCount }),
+    pageOfUnknown: (page) => t(key("pageOfUnknown"), { page }),
+    rowsSelected: (selected, total) => t(key("rowsSelected"), { selected, total })
+  };
+}
+var EMPTY_DESIGN = Object.freeze({
+  version: 1,
+  theme: {},
+  components: {}
+});
+var NajmDesignEditorContext = React2.createContext(null);
+function useNajmDesignEditor() {
+  return React2.useContext(NajmDesignEditorContext);
+}
+function cloneDesign(design) {
+  return structuredClone(design);
+}
+function NajmDesignEditorProvider({
+  children,
+  design,
+  initialDesign
+}) {
+  const [state, setState] = React2.useState(() => ({
+    committed: initialDesign ?? design ?? EMPTY_DESIGN,
+    draft: null
+  }));
+  const beginDraft = React2.useCallback(() => {
+    setState(
+      (current) => current.draft ? current : { ...current, draft: cloneDesign(current.committed) }
+    );
+  }, []);
+  const setDraft = React2.useCallback((next) => {
+    setState((current) => ({ ...current, draft: cloneDesign(next) }));
+  }, []);
+  const cancelDraft = React2.useCallback(() => {
+    setState(
+      (current) => current.draft === null ? current : { ...current, draft: null }
+    );
+  }, []);
+  const setCommitted = React2.useCallback((next) => {
+    setState(
+      (current) => current.committed === next && current.draft === null ? current : { committed: next, draft: null }
+    );
+  }, []);
+  const value = React2.useMemo(() => {
+    if (design) {
+      return {
+        design,
+        committed: design,
+        draft: null,
+        hasDraft: false,
+        beginDraft: noop,
+        setDraft: noop,
+        cancelDraft: noop,
+        setCommitted: noop
+      };
+    }
+    return {
+      design: state.draft ?? state.committed,
+      committed: state.committed,
+      draft: state.draft,
+      hasDraft: state.draft !== null,
+      beginDraft,
+      setDraft,
+      cancelDraft,
+      setCommitted
+    };
+  }, [design, state, beginDraft, setDraft, cancelDraft, setCommitted]);
+  return /* @__PURE__ */ jsx(NajmDesignEditorContext.Provider, { value, children });
+}
+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 };
+}
+var ENGLISH_FEEDBACK_LABELS = {
+  loadingLabel: "Loading...",
+  emptyTitle: "No data",
+  errorTitle: "Something went wrong",
+  retryLabel: "Try again",
+  forbiddenTitle: "Access denied",
+  forbiddenDescription: "You do not have permission to view this page.",
+  notFoundTitle: "Page not found",
+  notFoundDescription: "The requested page could not be found."
+};
+var NFeedbackDefaultsContext = React2.createContext(null);
+function NFeedbackDefaultsProvider({
+  value,
+  children
+}) {
+  return /* @__PURE__ */ jsx(NFeedbackDefaultsContext.Provider, { value, children });
+}
+function useNFeedbackDefaults() {
+  return React2.useContext(NFeedbackDefaultsContext);
+}
+var DEFAULT_FEEDBACK_KEY_PREFIX = "common.feedback";
+function useResolvedFeedbackLabels() {
+  const ctx = useNFeedbackDefaults();
+  return React2.useMemo(() => resolveFeedbackLabels(ctx), [ctx]);
+}
+function resolveFeedbackLabels(ctx) {
+  const defaults = ctx?.defaults;
+  const t = ctx?.t;
+  const labels = defaults?.labels;
+  const labelKeys = defaults?.labelKeys;
+  defaults?.prefix ?? DEFAULT_FEEDBACK_KEY_PREFIX;
+  const pick = (field, hasFallback) => {
+    const literal = labels?.[field];
+    if (literal !== void 0) return literal;
+    const key = labelKeys?.[field];
+    if (key && t) return t(key);
+    if (hasFallback) return ENGLISH_FEEDBACK_LABELS[field];
+    return void 0;
+  };
+  return {
+    loadingLabel: pick("loadingLabel", true) ?? ENGLISH_FEEDBACK_LABELS.loadingLabel,
+    emptyTitle: pick("emptyTitle", true) ?? ENGLISH_FEEDBACK_LABELS.emptyTitle,
+    errorTitle: pick("errorTitle", true) ?? ENGLISH_FEEDBACK_LABELS.errorTitle,
+    errorMessage: pick("errorMessage", false),
+    retryLabel: pick("retryLabel", true) ?? ENGLISH_FEEDBACK_LABELS.retryLabel,
+    forbiddenTitle: pick("forbiddenTitle", true) ?? ENGLISH_FEEDBACK_LABELS.forbiddenTitle,
+    forbiddenDescription: pick("forbiddenDescription", true) ?? ENGLISH_FEEDBACK_LABELS.forbiddenDescription,
+    notFoundTitle: pick("notFoundTitle", true) ?? ENGLISH_FEEDBACK_LABELS.notFoundTitle,
+    notFoundDescription: pick("notFoundDescription", true) ?? ENGLISH_FEEDBACK_LABELS.notFoundDescription
+  };
+}
+function resolveFeedbackDefaultsValue(defaults, t) {
+  return { defaults: defaults ?? {}, t };
+}
+function NajmUICore({
+  children,
+  className,
+  t,
+  paginationKeyPrefix = DEFAULT_PAGINATION_KEY_PREFIX,
+  tableDefaults,
+  badgeDefaults,
+  feedbackDefaults
+}) {
+  const { theme } = useNajmTheme();
+  const design = useNajmDesignEditor()?.design ?? EMPTY_DESIGN;
+  const defaults = React2.useMemo(() => {
+    const translated = t ? buildPaginationLabels(t, paginationKeyPrefix) : void 0;
+    const overrides = tableDefaults?.paginationLabels;
+    const paginationLabels = translated || overrides ? { ...translated, ...overrides } : void 0;
+    return { ...tableDefaults, paginationLabels };
+  }, [t, paginationKeyPrefix, tableDefaults]);
+  const feedbackValue = React2.useMemo(
+    () => resolveFeedbackDefaultsValue(feedbackDefaults, t),
+    [feedbackDefaults, t]
+  );
+  return /* @__PURE__ */ jsx(
+    NajmDesignProvider,
+    {
+      config: design,
+      mode: theme,
+      className: cn("min-h-full", className),
+      children: /* @__PURE__ */ jsx(NTableDefaultsProvider, { value: defaults, children: /* @__PURE__ */ jsx(NBadgeDefaultsProvider, { defaults: badgeDefaults, t, children: /* @__PURE__ */ jsx(NFeedbackDefaultsProvider, { value: feedbackValue, children }) }) })
+    }
+  );
+}
+function NajmUIProvider({
+  children,
+  design,
+  initialDesign,
+  className,
+  t,
+  paginationKeyPrefix,
+  tableDefaults,
+  badgeDefaults,
+  feedbackDefaults,
+  initialTheme,
+  initialTimeZone,
+  onThemeChange,
+  onTimeZoneChange,
+  normalizeTimeZone
+}) {
+  const outerPreferences = useNajmPreferencesContext();
+  const core = /* @__PURE__ */ jsx(NajmDesignEditorProvider, { design, initialDesign, children: /* @__PURE__ */ jsx(
+    NajmUICore,
+    {
+      className,
+      t,
+      paginationKeyPrefix,
+      tableDefaults,
+      badgeDefaults,
+      feedbackDefaults,
+      children
+    }
+  ) });
+  if (outerPreferences) return core;
+  return /* @__PURE__ */ jsx(
+    NajmPreferencesProvider,
+    {
+      initialTheme,
+      initialTimeZone,
+      onThemeChange,
+      onTimeZoneChange,
+      normalizeTimeZone,
+      children: core
+    }
+  );
+}
+
+// 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, useResolvedFeedbackLabels, useResolvedPaginationLabels };

package/dist/chunk-K7T7X6PX.mjs

@@ -0,0 +1,117 @@
+import { cn } from './chunk-KVZACF4G.mjs';
+import * as React from 'react';
+import { createContext, useContext } from 'react';
+import { OverlayScrollbars } from 'overlayscrollbars';
+import { OverlayScrollbarsComponent } from 'overlayscrollbars-react';
+import { jsx } from 'react/jsx-runtime';
+
+function assignRef(ref, node) {
+  if (!ref) return;
+  if (typeof ref === "function") ref(node);
+  else ref.current = node;
+}
+function applyViewportLayout(node, axis) {
+  node.style.width = "100%";
+  node.style.height = "100%";
+  node.style.minWidth = "0";
+  node.style.minHeight = "0";
+  node.style.overflowX = axis === "x" || axis === "both" ? "auto" : "hidden";
+  node.style.overflowY = axis === "y" || axis === "both" ? "auto" : "hidden";
+}
+function najmScrollOptions(axis, autoHide, options) {
+  return {
+    scrollbars: { theme: "os-theme-najm", autoHide, autoHideDelay: 500, clickScroll: true },
+    overflow: {
+      x: axis === "x" || axis === "both" ? "scroll" : "hidden",
+      y: axis === "y" || axis === "both" ? "scroll" : "hidden"
+    },
+    ...options
+  };
+}
+function useNajmScrollViewport({
+  axis = "y",
+  autoHide = "never",
+  options
+} = {}) {
+  const hostRef = React.useRef(null);
+  const viewportRef = React.useRef(null);
+  React.useEffect(() => {
+    const target = hostRef.current;
+    const viewport = viewportRef.current;
+    if (!target || !viewport) return;
+    const instance = OverlayScrollbars(
+      { target, elements: { viewport } },
+      najmScrollOptions(axis, autoHide, options)
+    );
+    const containWheel = (event) => event.stopPropagation();
+    viewport.addEventListener("wheel", containWheel, { passive: true });
+    return () => {
+      viewport.removeEventListener("wheel", containWheel);
+      instance.destroy();
+    };
+  }, [axis, autoHide, options]);
+  return { hostRef, viewportRef };
+}
+function NajmScroll({ className, axis = "y", autoHide = "never", viewportRef, events, options, element, children, style, ...props }) {
+  return /* @__PURE__ */ jsx(
+    OverlayScrollbarsComponent,
+    {
+      className: cn(className),
+      style: {
+        ...style,
+        overflow: "hidden",
+        minHeight: 0,
+        minWidth: 0
+      },
+      element,
+      defer: true,
+      options: najmScrollOptions(axis, autoHide, options || void 0),
+      events: {
+        ...events,
+        initialized: (instance, ...rest) => {
+          const viewport = instance.elements().viewport;
+          applyViewportLayout(viewport, axis);
+          assignRef(viewportRef, viewport);
+          events?.initialized?.(instance, ...rest);
+        },
+        updated: (instance, ...rest) => {
+          applyViewportLayout(instance.elements().viewport, axis);
+          events?.updated?.(instance, ...rest);
+        },
+        destroyed: (instance, ...rest) => {
+          assignRef(viewportRef, null);
+          events?.destroyed?.(instance, ...rest);
+        }
+      },
+      ...props,
+      children
+    }
+  );
+}
+var TableStoreContext = createContext(null);
+var useTableStore = { use: {} };
+var handler = {
+  get: (_, prop) => () => {
+    const store = useContext(TableStoreContext);
+    if (!store) throw new Error("useTableStore must be used within NTable");
+    return store.use[prop]();
+  }
+};
+useTableStore.use = new Proxy({}, handler);
+function formatJsonValue(value) {
+  if (typeof value === "string") return value;
+  try {
+    return JSON.stringify(value ?? null, null, 2) ?? String(value);
+  } catch {
+    return String(value);
+  }
+}
+function NTableJson() {
+  const viewMode = useTableStore.use.viewMode();
+  const renderJson = useTableStore.use.renderJson();
+  const jsonValue = useTableStore.use.jsonValue();
+  if (viewMode !== "json") return null;
+  return /* @__PURE__ */ jsx("div", { className: "flex-1 flex flex-col min-h-0 overflow-hidden", children: renderJson?.() ?? /* @__PURE__ */ jsx(NajmScroll, { axis: "both", className: "h-full min-h-0 rounded-md border border-border bg-muted/40", children: /* @__PURE__ */ jsx("pre", { className: "p-4 font-mono text-xs leading-relaxed text-foreground", children: formatJsonValue(jsonValue) }) }) });
+}
+
+export { NTableJson, NajmScroll, TableStoreContext, useNajmScrollViewport, useTableStore };