najm-kit 2.8.0 → 2.8.2

package/CHANGELOG.md

@@ -1,4 +1,23 @@
-# Changelog
+# Changelog
+
+## 2.8.2 - 2026-08-08
+
+- Added the framework-neutral `najm-kit/person-images` subpath. It ships a
+  built-in resolver for `child`, `adult`, `parent`, and `family` roles with
+  the seven WebP illustrations embedded as base64 data URLs, plus
+  `createPersonImageResolver` so an application can declare its own role
+  names (`teacher`, `student`, `doctor`, `driver`, …) and TypeScript catches
+  unknown role strings at the call site. The root `najm-kit` entry stays
+  unchanged and does not pull in the person images.
+
+## 2.8.1 - 2026-08-08
+
+- Added schema-driven form development tools to `NajmAppProvider`. Passing
+  `formDevTools` enables F8 filling for every `NForm` and `WizardForm` without
+  an application helper or additional provider.
+- Added built-in Zod 4 form-value generation with per-form overrides for
+  relation fields and other application-owned values. Existing explicit
+  `devTools.enabled` and `devTools.fill` usage remains supported.
 
 ## 2.8.0 - 2026-08-08
 

package/README.md

@@ -123,7 +123,7 @@ Changing the state updates the complete theme immediately. Use
 `stringifyNajmThemeConfig(theme)` when persisting it, and parse settings loaded
 from an API or local storage with `parseNajmThemeConfig` before applying them.
 
-## Components
+## Components
 
 Import from `najm-kit`:
 
@@ -145,7 +145,42 @@ import { Form, FormInput, useNForm } from 'najm-kit';
 | Feedback | Alert, Badge, Progress, Spinner, Toast |
 | Layout | Card, Sheet, Dialog, Popover, DropdownMenu, Tabs |
 | Data | Table (NTable), StatCard, DetailList |
-| Overlays | Command palette, Tooltip, Toast |
+| Overlays | Command palette, Tooltip, Toast |
+
+## Global form development tools
+
+Enable schema-driven test values once on the full application provider. Every
+`NForm` and `WizardForm` below it then fills from its Zod schema when F8 is
+pressed; applications do not need a second provider or a form-fill helper.
+
+```tsx
+import { NajmAppProvider } from "najm-kit/app";
+
+<NajmAppProvider formDevTools>
+  <App />
+</NajmAppProvider>;
+```
+
+Pass a boolean to control it from application settings:
+
+```tsx
+<NajmAppProvider formDevTools={formFillEnabled}>
+  <App />
+</NajmAppProvider>
+```
+
+Forms with live relation options can override only those fields. The provider
+still owns enablement and Najm Kit still owns schema traversal and generation.
+
+```tsx
+<NForm
+  schema={orderSchema}
+  devTools={{ overrides: { customerId: customerOptions } }}
+  onSubmit={saveOrder}
+>
+  {/* fields */}
+</NForm>
+```
 
 ## ImageInput and AvatarInput
 
@@ -472,9 +507,97 @@ const data = [
 />
 ```
 
-### Server-backed combobox search
+### Server-backed combobox search
+
+`ComboboxInput` and `FormInput type="combobox"` can delegate filtering to a
+server by setting `shouldFilter={false}` and handling `onSearchChange`. Use
+`loading` and `loadingMessage` while replacement options are being fetched.
+Client-side filtering remains the default.
+
+## Person image fallbacks (`najm-kit/person-images`)
+
+A framework-neutral, React-free subpath that resolves person-image fallbacks
+for any application. The seven WebP illustrations are embedded as base64 data
+URLs in the published bundle, so consumers do not need to copy package files
+into `public/` or wire an asset server.
+
+```ts
+import { getPersonImage } from "najm-kit/person-images";
+
+const childSrc = getPersonImage({
+  image: child.image,
+  role: "child",
+  gender: child.gender,
+});
+```
+
+Built-in roles:
+
+| Role     | Default          | Female          | Male            |
+| -------- | ---------------- | --------------- | --------------- |
+| `child`  | male child art   | female child    | male child      |
+| `adult`  | male adult art   | female adult    | male adult      |
+| `parent` | male parent art  | female parent   | male parent     |
+| `family` | neutral family   | neutral family  | neutral family  |
+
+Resolution precedence, for every call:
+
+1. A real `image` (anything that survives `resolveAvatarSrc`).
+2. A per-call `fallback` that is not blank and is not the `noavatar.png`
+   sentinel.
+3. The configured role's gender variant, or the role's required `default`
+   when the variant or the gender is missing.
+
+The per-call `fallback` is treated like a real source: an empty string, a
+blank trimmed value, or any `noavatar.png` path falls through to the role
+default. The Kafil data is a worked example: children use `role: "child"`,
+households use `role: "family"`, sponsors, staff, applicants, and delivery
+staff use `role: "adult"`, and a household parent uses `role: "parent"`
+after the family dashboard maps its relationship value (`mother`, `mère`,
+`madre`, `أم`, …) to `F`, `M`, or `null` at the feature boundary.
+
+### Custom roles
+
+`createPersonImageResolver` returns a typed resolver that accepts the
+application's own role names. Unknown role strings fail type checking:
+
+```ts
+import { createPersonImageResolver } from "najm-kit/person-images";
+
+const getSmsPersonImage = createPersonImageResolver({
+  teacher: {
+    default: "/images/teachers/default.webp",
+    female: "/images/teachers/female.webp",
+    male: "/images/teachers/male.webp",
+  },
+  student: {
+    default: "/images/students/default.webp",
+    female: "/images/students/female.webp",
+    male: "/images/students/male.webp",
+  },
+});
+
+const teacherSrc = getSmsPersonImage({
+  image: teacher.image,
+  role: "teacher",
+  gender: teacher.gender,
+});
+```
+
+The factory merges custom definitions over the built-in map. A custom `child`
+override replaces the built-in child art for that application alone — the
+package itself is untouched, and other consumers keep their built-in
+fallbacks.
+
+Custom paths may be application-relative URLs, managed API URLs, CDN URLs,
+or data URLs. najm-kit does not fetch, upload, authorize, or persist them.
+
+### Per-call fallback override
+
+Every call accepts a `fallback`. It overrides the role default for that call
+only, after a real `image` and before the role's gender variant:
+
+```ts
+getPersonImage({ image: child.image, role: "child", gender: child.gender, fallback: child.placeholder });
+```
 
-`ComboboxInput` and `FormInput type="combobox"` can delegate filtering to a
-server by setting `shouldFilter={false}` and handling `onSearchChange`. Use
-`loading` and `loadingMessage` while replacement options are being fetched.
-Client-side filtering remains the default.

package/dist/adapters/app.d.ts

@@ -1,8 +1,9 @@
 import * as react_jsx_runtime from 'react/jsx-runtime';
 import { Translations } from 'najm-i18n';
-import { N as NBrandingInput } from '../NBrandingContext-dkADu8JS.js';
+import { F as FormDevToolsOptions, N as NBrandingInput } from '../formFill-BcH-m9Kf.js';
 import { NajmNextUIProviderProps } from './next.js';
 import 'react';
+import 'zod';
 import '../NajmUIProvider-BSbXaqak.js';
 import '../paginationLabels-dZLSNxfo.js';
 
@@ -13,6 +14,11 @@ interface NajmAppBranding {
     logoCollapsed?: string | null;
 }
 interface NajmAppProviderProps extends Omit<NajmNextUIProviderProps, 't'> {
+    /**
+     * Enables schema-driven form filling for every `NForm` and `WizardForm`.
+     * `true` uses F8; an options object can choose another shortcut.
+     */
+    formDevTools?: boolean | FormDevToolsOptions;
     /**
      * Catalog for `najm-i18n`. Supplying it mounts an `I18nProvider` and derives
      * the pagination labels from it, so `t` is not a prop here — the provider
@@ -99,6 +105,6 @@ interface NajmAppProviderProps extends Omit<NajmNextUIProviderProps, 't'> {
  * state machine of its own above this provider. The controlled `design` and
  * `branding` props still work for applications that already do.
  */
-declare function NajmAppProvider({ translations, initialLanguage, defaultLanguage, languageEndpoint, appName, initialBranding, ...props }: NajmAppProviderProps): react_jsx_runtime.JSX.Element;
+declare function NajmAppProvider({ translations, initialLanguage, defaultLanguage, languageEndpoint, appName, initialBranding, formDevTools, ...props }: NajmAppProviderProps): react_jsx_runtime.JSX.Element;
 
 export { type NajmAppBranding, NajmAppProvider, type NajmAppProviderProps };

package/dist/adapters/app.mjs

@@ -1,5 +1,5 @@
 'use client';
-import { NBrandingStateProvider, NajmFormatProvider } from '../chunk-PCPMAEKP.mjs';
+import { FormDevToolsProvider, NBrandingStateProvider, NajmFormatProvider } from '../chunk-GHMR45H3.mjs';
 import { NajmNextUIProvider } from '../chunk-IRFFSAO2.mjs';
 import '../chunk-USZUOJMK.mjs';
 import '../chunk-KVZACF4G.mjs';
@@ -72,6 +72,7 @@ function NajmAppProvider({
   languageEndpoint = DEFAULT_LANGUAGE_ENDPOINT,
   appName,
   initialBranding,
+  formDevTools,
   ...props
 }) {
   const persistLanguage = React.useCallback(
@@ -91,8 +92,10 @@ function NajmAppProvider({
     [languageEndpoint]
   );
   const seeded = appName ? { appName, ...initialBranding } : initialBranding;
-  if (!translations) return /* @__PURE__ */ jsx(NajmAppNoI18n, { ...props, initialBranding: seeded });
-  return /* @__PURE__ */ jsx(
+  if (!translations) {
+    return /* @__PURE__ */ jsx(FormDevToolsProvider, { value: formDevTools, children: /* @__PURE__ */ jsx(NajmAppNoI18n, { ...props, initialBranding: seeded }) });
+  }
+  return /* @__PURE__ */ jsx(FormDevToolsProvider, { value: formDevTools, children: /* @__PURE__ */ jsx(
     I18nProvider,
     {
       translations,
@@ -101,7 +104,7 @@ function NajmAppProvider({
       onLanguageChange: persistLanguage,
       children: /* @__PURE__ */ jsx(NajmAppUI, { ...props, initialBranding: seeded })
     }
-  );
+  ) });
 }
 
 export { NajmAppProvider };

package/dist/chunk-BEGOH366.mjs

@@ -0,0 +1,12 @@
+// src/lib/avatar.ts
+var PLACEHOLDER_AVATAR = /(^|\/)noavatar\.png(?:$|[?#])/i;
+function isPlaceholderAvatar(src) {
+  const trimmed = src?.trim() ?? "";
+  return !trimmed || PLACEHOLDER_AVATAR.test(trimmed);
+}
+function resolveAvatarSrc(src, fallback) {
+  const trimmed = src?.trim() ?? "";
+  return trimmed && !PLACEHOLDER_AVATAR.test(trimmed) ? trimmed : fallback;
+}
+
+export { isPlaceholderAvatar, resolveAvatarSrc };

package/dist/chunk-GHMR45H3.mjs

@@ -0,0 +1,333 @@
+import { useNajmPreferencesContext } from './chunk-USZUOJMK.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';
+import { jsx } from 'react/jsx-runtime';
+
+function normalizeBranding(input) {
+  if (!input) return {};
+  const value = {};
+  const expanded = input.logoExpanded ?? input.sidebarLogoExpandedPath;
+  const collapsed = input.logoCollapsed ?? input.sidebarLogoCollapsedPath;
+  if (input.appName !== void 0) value.appName = input.appName;
+  if (input.logoFallback !== void 0) value.logoFallback = input.logoFallback;
+  if (input.logoHref !== void 0) value.logoHref = input.logoHref;
+  if (expanded !== void 0) value.logoExpanded = expanded;
+  if (collapsed !== void 0) value.logoCollapsed = collapsed;
+  return value;
+}
+var NBrandingContext = createContext(null);
+function useNBranding() {
+  return useContext(NBrandingContext);
+}
+function NBrandingProvider({
+  children,
+  appName,
+  logoExpanded,
+  logoCollapsed,
+  logoFallback,
+  logoHref
+}) {
+  const value = useMemo(
+    () => ({ appName, logoExpanded, logoCollapsed, logoFallback, logoHref }),
+    [appName, logoExpanded, logoCollapsed, logoFallback, logoHref]
+  );
+  return /* @__PURE__ */ jsx(NBrandingContext.Provider, { value, children });
+}
+var NBrandingEditorContext = createContext(null);
+function useNBrandingEditor() {
+  return useContext(NBrandingEditorContext);
+}
+function NBrandingStateProvider({
+  children,
+  branding,
+  initialBranding
+}) {
+  const [state, setState] = useState(
+    () => normalizeBranding(initialBranding ?? branding)
+  );
+  const setBranding = useCallback((patch) => {
+    const marks = normalizeBranding(patch);
+    setState((current) => ({ ...current, ...marks }));
+  }, []);
+  const controlled = useMemo(
+    () => branding ? normalizeBranding(branding) : void 0,
+    [branding]
+  );
+  const resolved = controlled ?? state;
+  const editor = useMemo(
+    () => ({ branding: resolved, setBranding: branding ? noop : setBranding }),
+    [resolved, branding, setBranding]
+  );
+  return /* @__PURE__ */ jsx(NBrandingEditorContext.Provider, { value: editor, children: /* @__PURE__ */ jsx(NBrandingProvider, { ...resolved, children }) });
+}
+function noop() {
+}
+
+// src/components/form/formFill.ts
+var CITIES = ["Casablanca", "Rabat", "Marrakesh", "Tangier"];
+var SCHOOL_LEVELS = ["Primary", "Middle school", "Secondary school"];
+var CLOTHING_SIZES = ["6 years", "8 years", "10 years", "12 years"];
+function pick(values) {
+  if (values.length === 0) return void 0;
+  return values[Math.floor(Math.random() * values.length)];
+}
+function randomDigits(length) {
+  return Array.from({ length }, () => Math.floor(Math.random() * 10)).join("");
+}
+function randomToken(length = 8) {
+  const alphabet = "abcdefghijklmnopqrstuvwxyz0123456789";
+  return Array.from(
+    { length },
+    () => alphabet[Math.floor(Math.random() * alphabet.length)]
+  ).join("");
+}
+function asZodLike(schema) {
+  return schema && typeof schema === "object" ? schema : void 0;
+}
+function definition(schema) {
+  const current = asZodLike(schema);
+  return current?._def ?? current?.def ?? {};
+}
+function schemaKind(schema) {
+  const currentDefinition = definition(schema);
+  const raw = currentDefinition.typeName ?? currentDefinition.type;
+  if (typeof raw !== "string") return "";
+  return raw.replace(/^Zod/, "").toLowerCase();
+}
+function unwrap(schema) {
+  const seen = /* @__PURE__ */ new Set();
+  let current = asZodLike(schema);
+  while (current && !seen.has(current)) {
+    seen.add(current);
+    const kind = schemaKind(current);
+    const currentDefinition = definition(current);
+    const inner = currentDefinition.innerType ?? currentDefinition.schema ?? (kind === "pipe" ? currentDefinition.out ?? currentDefinition.in : void 0);
+    if (!inner || typeof inner !== "object") break;
+    current = inner;
+  }
+  return current;
+}
+function objectShape(schema) {
+  const current = unwrap(schema);
+  if (schemaKind(current) !== "object") return null;
+  const shape = current?.shape ?? definition(current).shape;
+  return typeof shape === "function" ? shape() : shape ?? null;
+}
+function arrayElement(schema) {
+  const current = unwrap(schema);
+  if (schemaKind(current) !== "array") return null;
+  const currentDefinition = definition(current);
+  const element = current?.element ?? currentDefinition.element ?? currentDefinition.type;
+  return element && typeof element === "object" ? element : null;
+}
+function enumValues(schema) {
+  const current = unwrap(schema);
+  const currentDefinition = definition(current);
+  const kind = schemaKind(current);
+  if (kind === "literal") {
+    const values2 = currentDefinition.values;
+    if (Array.isArray(values2)) return values2;
+    return "value" in currentDefinition ? [currentDefinition.value] : [];
+  }
+  if (kind !== "enum" && kind !== "nativeenum") return [];
+  const entries = currentDefinition.entries;
+  if (entries && typeof entries === "object") return Object.values(entries);
+  const values = currentDefinition.values;
+  if (Array.isArray(values)) return values;
+  return Array.isArray(current?.options) ? [...current.options] : [];
+}
+function stringFormat(schema) {
+  const currentDefinition = definition(unwrap(schema));
+  if (typeof currentDefinition.format === "string") return currentDefinition.format;
+  const checks = Array.isArray(currentDefinition.checks) ? currentDefinition.checks : [];
+  for (const check of checks) {
+    if (!check || typeof check !== "object") continue;
+    const value = check;
+    const format = value.format ?? value.kind;
+    if (typeof format === "string") return format;
+  }
+  return "";
+}
+function resolveOverride(override, fieldName) {
+  if (typeof override === "function") return override(fieldName);
+  if (Array.isArray(override)) {
+    const value = pick(override);
+    if (value && typeof value === "object" && "value" in value) {
+      return value.value;
+    }
+    return value;
+  }
+  return override;
+}
+function localDateInput(date = /* @__PURE__ */ new Date()) {
+  return `${date.getFullYear()}-${String(date.getMonth() + 1).padStart(2, "0")}-${String(date.getDate()).padStart(2, "0")}`;
+}
+function birthDate(child) {
+  const date = /* @__PURE__ */ new Date();
+  date.setFullYear(date.getFullYear() - (child ? 10 : 35));
+  return localDateInput(date);
+}
+function fieldValue(fieldName, schema, siblingFields) {
+  const key = fieldName.toLowerCase();
+  const current = unwrap(schema);
+  const kind = schemaKind(current);
+  const format = stringFormat(current);
+  const values = enumValues(current);
+  if (values.length) return pick(values);
+  if (kind === "boolean") return true;
+  if (kind === "number" || kind === "bigint") {
+    if (key.includes("sortorder")) return 1;
+    if (key.includes("quantity")) return 5;
+    return 10;
+  }
+  if (format === "uuid" || key.endsWith("uuid")) {
+    return "9cc2c93f-f545-4e07-9f77-f79f08a71dd5";
+  }
+  if (format === "email" || key.includes("email")) {
+    return `test-${randomToken()}@example.com`;
+  }
+  if (format === "url" || key === "image" || key.includes("imageurl") || key.endsWith("url")) {
+    return `https://picsum.photos/seed/${randomToken()}/800/600`;
+  }
+  if (key === "month") return `${localDateInput().slice(0, 7)}-01`;
+  if (key === "registrationdate") return localDateInput();
+  if (format === "date" || key.includes("dateofbirth")) {
+    const child = siblingFields.has("schoolLevel") || siblingFields.has("clothingSize");
+    return birthDate(child);
+  }
+  if (key.endsWith("id") || key.endsWith("by")) return "";
+  if (key === "name") {
+    if (siblingFields.has("sku")) return `Test product ${randomToken(4)}`;
+    if (siblingFields.has("slug")) return `Test category ${randomToken(4)}`;
+    return "Test User";
+  }
+  if (key.includes("legalname")) return "Test User";
+  if (key.includes("phone")) return `+2126${randomDigits(8)}`;
+  if (key.endsWith("cin")) return `AB${randomDigits(6)}`;
+  if (key.includes("address")) return `10 Test Street, ${pick(CITIES)}`;
+  if (key.includes("schoollevel")) return pick(SCHOOL_LEVELS);
+  if (key.includes("clothingsize")) return pick(CLOTHING_SIZES);
+  if (key.includes("shoesize")) return "36";
+  if (key.includes("relationship")) return "Legal guardian";
+  if (key.includes("activationtargetmad")) return "7500";
+  if (key === "slug") return `test-${randomToken(6)}`;
+  if (key === "sku") return `TEST-${randomToken(8).toUpperCase()}`;
+  if (key.includes("amountmad") || key.includes("pricemad") || key.includes("limitmad") || key.includes("targetmad")) {
+    return "100.00";
+  }
+  if (key.includes("reason")) return "Generated for form testing.";
+  if (key.includes("notes")) return "Generated form testing note.";
+  if (key.includes("description")) return "Generated description for form testing.";
+  if (key.includes("code")) return randomToken(8).toUpperCase();
+  return `Test ${fieldName}`;
+}
+function buildFormFill(schema, overrides = {}) {
+  const shape = objectShape(schema) ?? {};
+  const siblingFields = new Set(Object.keys(shape));
+  const output = {};
+  for (const [fieldName, fieldSchema] of Object.entries(shape)) {
+    if (Object.prototype.hasOwnProperty.call(overrides, fieldName)) {
+      output[fieldName] = resolveOverride(overrides[fieldName], fieldName);
+      continue;
+    }
+    const nestedShape = objectShape(fieldSchema);
+    if (nestedShape) {
+      output[fieldName] = buildFormFill(fieldSchema);
+      continue;
+    }
+    const element = arrayElement(fieldSchema);
+    if (element) {
+      output[fieldName] = objectShape(element) ? [buildFormFill(element)] : [fieldValue(fieldName, element, siblingFields)];
+      continue;
+    }
+    output[fieldName] = fieldValue(fieldName, fieldSchema, siblingFields);
+  }
+  return output;
+}
+var DEFAULT_FORM_DEV_TOOLS = {
+  enabled: false,
+  shortcut: "F8"
+};
+var FormDevToolsContext = createContext(
+  DEFAULT_FORM_DEV_TOOLS
+);
+function normalizeFormDevTools(value) {
+  if (typeof value === "boolean") {
+    return { ...DEFAULT_FORM_DEV_TOOLS, enabled: value };
+  }
+  if (!value) return DEFAULT_FORM_DEV_TOOLS;
+  return {
+    enabled: value.enabled ?? true,
+    shortcut: value.shortcut ?? DEFAULT_FORM_DEV_TOOLS.shortcut
+  };
+}
+function FormDevToolsProvider({
+  children,
+  value
+}) {
+  const resolved = useMemo(
+    () => normalizeFormDevTools(value),
+    [value]
+  );
+  return /* @__PURE__ */ jsx(FormDevToolsContext.Provider, { value: resolved, children });
+}
+function useResolvedFormDevTools(schema, local) {
+  const global = useContext(FormDevToolsContext);
+  const options = typeof local === "object" ? local : void 0;
+  const enabled = typeof local === "boolean" ? local : options?.enabled ?? global.enabled;
+  const shortcut = options?.shortcut ?? global.shortcut;
+  const fill = options?.fill ?? (schema ? () => buildFormFill(schema, options?.overrides) : void 0);
+  return { enabled, shortcut, fill };
+}
+var NajmFormatContext = React2.createContext(
+  null
+);
+function NajmFormatProvider({
+  children,
+  locale,
+  currency,
+  timeZone,
+  placeholder = DEFAULT_PLACEHOLDER
+}) {
+  const preferences = useNajmPreferencesContext();
+  const resolvedTimeZone = timeZone ?? preferences?.timeZone ?? Intl.DateTimeFormat().resolvedOptions().timeZone;
+  const value = React2.useMemo(() => {
+    const config = {
+      locale,
+      timeZone: resolvedTimeZone,
+      currency,
+      placeholder
+    };
+    return {
+      locale,
+      timeZone: resolvedTimeZone,
+      currency,
+      placeholder,
+      config,
+      money: (minorUnits) => formatCurrency(minorUnits, config),
+      number: (value_, options) => formatNumber(value_, config, options),
+      percent: (value_, digits) => formatPercent(value_, config, digits),
+      date: (value_, options) => formatDate(value_, config, options),
+      dateTime: (value_) => formatDateTime(value_, config),
+      time: (value_) => formatTime(value_, config),
+      relativeTime: (value_) => formatRelativeTime(value_, config),
+      humanize: humanizeToken
+    };
+  }, [locale, resolvedTimeZone, currency, placeholder]);
+  return /* @__PURE__ */ jsx(NajmFormatContext.Provider, { value, children });
+}
+function useNajmFormatContext() {
+  return React2.useContext(NajmFormatContext);
+}
+function useNajmFormat() {
+  const value = React2.useContext(NajmFormatContext);
+  if (!value) {
+    throw new Error(
+      "useNajmFormat must be rendered under a NajmFormatProvider or NajmAppProvider."
+    );
+  }
+  return value;
+}
+
+export { FormDevToolsProvider, NBrandingProvider, NBrandingStateProvider, NajmFormatProvider, buildFormFill, normalizeBranding, useNBranding, useNBrandingEditor, useNajmFormat, useNajmFormatContext, useResolvedFormDevTools };

package/dist/{NBrandingContext-dkADu8JS.d.ts → formFill-BcH-m9Kf.d.ts}

@@ -1,5 +1,6 @@
 import * as react_jsx_runtime from 'react/jsx-runtime';
 import { ReactNode } from 'react';
+import { ZodTypeAny, TypeOf } from 'zod';
 
 interface NBrandingValue {
     /** Used as the logo's `alt` when the logo does not set one. */
@@ -79,4 +80,18 @@ interface NBrandingStateProviderProps {
 /** `NBrandingProvider` with the marks held as state an editor can write. */
 declare function NBrandingStateProvider({ children, branding, initialBranding, }: Readonly<NBrandingStateProviderProps>): react_jsx_runtime.JSX.Element;
 
-export { type NBrandingInput as N, type NBrandingEditorValue as a, type NBrandingPayload as b, NBrandingProvider as c, NBrandingStateProvider as d, type NBrandingStateProviderProps as e, type NBrandingValue as f, useNBrandingEditor as g, normalizeBranding as n, useNBranding as u };
+type FormFillOverride = unknown | readonly unknown[] | ((fieldName: string) => unknown);
+type FormFillOverrides = Record<string, FormFillOverride>;
+interface FormDevToolsOptions {
+    enabled?: boolean;
+    shortcut?: string;
+}
+interface FormDevToolsConfig<T extends ZodTypeAny = ZodTypeAny> extends FormDevToolsOptions {
+    fill?: () => Partial<TypeOf<T>>;
+    overrides?: FormFillOverrides;
+}
+type FormDevTools<T extends ZodTypeAny = ZodTypeAny> = boolean | FormDevToolsConfig<T>;
+/** Build form-shaped test values from a Zod object schema. */
+declare function buildFormFill<TSchema extends ZodTypeAny>(schema: TSchema, overrides?: FormFillOverrides): Partial<TypeOf<TSchema>>;
+
+export { type FormDevToolsOptions as F, type NBrandingInput as N, type FormDevTools as a, type FormDevToolsConfig as b, type FormFillOverride as c, type FormFillOverrides as d, type NBrandingEditorValue as e, type NBrandingPayload as f, NBrandingProvider as g, NBrandingStateProvider as h, type NBrandingStateProviderProps as i, type NBrandingValue as j, buildFormFill as k, useNBrandingEditor as l, normalizeBranding as n, useNBranding as u };