@iris-ui-kit/react 0.1.0

package/dist/form.d.ts

@@ -0,0 +1,120 @@
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import * as React from 'react';
+import { FormValues, FormStore, FormState, FormConfig } from '@iris-ui-kit/core';
+
+interface IrisFormProps<V extends FormValues> extends Omit<React.FormHTMLAttributes<HTMLFormElement>, 'onSubmit'> {
+    /** The store from `useForm(...).form`. */
+    form: FormStore<V>;
+    children?: React.ReactNode;
+}
+/**
+ * Provides the form store to descendant `useField` calls and wires the native
+ * `<form>` submit to `handleSubmit` (with `preventDefault`).
+ *
+ * @example
+ *   const f = useForm({ initialValues: { email: '' }, onSubmit })
+ *   <IrisForm form={f.form}>
+ *     <IrisFormField label="Email"><EmailField /></IrisFormField>
+ *     <IrisButton type="submit" disabled={f.isSubmitting}>Save</IrisButton>
+ *   </IrisForm>
+ */
+declare function IrisForm<V extends FormValues>({ form, children, ...rest }: IrisFormProps<V>): react_jsx_runtime.JSX.Element;
+
+interface UseFormReturn<V extends FormValues> extends FormState<V> {
+    /** Underlying subscribable store. */
+    store: FormStore<V>['store'];
+    /** The form store itself — pass to `<IrisForm form={...}>`. */
+    form: FormStore<V>;
+    isValid: boolean;
+    setFieldValue: FormStore<V>['setFieldValue'];
+    setValues: FormStore<V>['setValues'];
+    setFieldTouched: FormStore<V>['setFieldTouched'];
+    setFieldError: FormStore<V>['setFieldError'];
+    setErrors: FormStore<V>['setErrors'];
+    validateField: FormStore<V>['validateField'];
+    validateForm: FormStore<V>['validateForm'];
+    handleSubmit: FormStore<V>['handleSubmit'];
+    reset: FormStore<V>['reset'];
+}
+/**
+ * React binding for the framework-agnostic form engine. Instantiates the store
+ * once (like `useState`'s lazy initializer) and bridges it into React via
+ * `useSyncExternalStore`. `initialValues` / `validators` / timing are captured
+ * on first render; `onSubmit` and `validate` are read through a ref each render
+ * so they always see the latest closures (no stale-callback footgun).
+ */
+declare function useForm<V extends FormValues>(config: FormConfig<V>): UseFormReturn<V>;
+
+interface FieldInputProps {
+    name: string;
+    value: string;
+    onChange: (event: React.ChangeEvent<HTMLInputElement | HTMLTextAreaElement>) => void;
+    onBlur: () => void;
+}
+interface UseFieldReturn<T> {
+    name: string;
+    value: T;
+    error: string | undefined;
+    touched: boolean;
+    dirty: boolean;
+    setValue: (value: T) => void;
+    setTouched: (touched?: boolean) => void;
+    /**
+     * Convenience bundle for a native text input / textarea. Spread onto
+     * `IrisInput` / `IrisTextarea`. Non-text controls (checkbox, select,
+     * number, custom) should wire `value` + `setValue` directly.
+     */
+    inputProps: FieldInputProps;
+}
+/**
+ * Binds a single field to the surrounding `<IrisForm>`. Re-renders only its
+ * host component when the form store changes. `T` is the value type at the
+ * call site (the context erases the form's generic).
+ *
+ * `name` may be a flat top-level key (`'email'`) OR a nested PATH
+ * (`'address.city'`, `'items[2].sku'`) — the form keys its per-field state by
+ * the canonical path, so a flat key is just a 1-segment path and stays 100%
+ * back-compatible (v3 R19).
+ */
+declare function useField<T = unknown>(name: string): UseFieldReturn<T>;
+
+interface UseFieldArrayReturn<T> {
+    name: string;
+    /** Current array value (reactive). */
+    fields: T[];
+    /** Append an item. */
+    push: (item: T) => void;
+    /** Remove the item at `index`. */
+    remove: (index: number) => void;
+    /** Insert `item` at `index` (shifting the rest right). */
+    insert: (index: number, item: T) => void;
+    /** Move the item from `from` to `to`. */
+    move: (from: number, to: number) => void;
+    /** Replace the whole array. */
+    replace: (items: T[]) => void;
+}
+/**
+ * Manage a dynamic array field (repeatable rows) inside an `<IrisForm>`. Mutators
+ * delegate to the core {@link FormStore} array helpers (`arrayPush`/`arrayInsert`/
+ * `arrayRemove`/`arrayMove`), which RE-KEY each element's error/touched/dirty/
+ * validating state across the mutation — so a row's per-element validation state
+ * FOLLOWS the row when rows are removed or reordered (removing `items[0]` shifts
+ * `items[2]`'s error down to `items[1]`). `replace` swaps the whole array.
+ *
+ * ```tsx
+ * const items = useFieldArray<{ sku: string }>('items')
+ * items.fields.map((_, i) => <SkuRow key={i} index={i} />)
+ * <button onClick={() => items.push({ sku: '' })}>Add</button>
+ * ```
+ */
+declare function useFieldArray<T = unknown>(name: string): UseFieldArrayReturn<T>;
+
+/**
+ * Carries the active form's {@link FormStore} down to descendant fields so
+ * `useField` can bind without prop drilling. The generic is erased at the
+ * context boundary; `useField<T>` re-applies the value type at the call site.
+ */
+declare const FormContext: React.Context<FormStore<FormValues> | null>;
+declare function useFormContext(): FormStore<FormValues>;
+
+export { type FieldInputProps, FormContext, IrisForm, type IrisFormProps, type UseFieldArrayReturn, type UseFieldReturn, type UseFormReturn, useField, useFieldArray, useForm, useFormContext };

package/dist/form.js

@@ -0,0 +1,5 @@
+'use client'
+export { FormContext, IrisForm, useField, useFieldArray, useForm, useFormContext } from './chunk-DE6V6NOI.js';
+import './chunk-RZNYIFV2.js';
+//# sourceMappingURL=form.js.map
+//# sourceMappingURL=form.js.map

package/dist/form.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":";","file":"form.js"}

package/dist/i18n.cjs

@@ -0,0 +1,100 @@
+'use client'
+'use strict';
+
+var React2 = require('react');
+var core = require('@iris-ui-kit/core');
+var theme = require('@iris-ui-kit/theme');
+var jsxRuntime = require('react/jsx-runtime');
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var React2__namespace = /*#__PURE__*/_interopNamespace(React2);
+
+// src/i18n/I18nProvider.tsx
+var I18nContext = React2__namespace.createContext(null);
+function IrisI18nProvider({
+  locale,
+  messages,
+  i18n,
+  autoDirection,
+  directionTarget,
+  children
+}) {
+  const ref = React2__namespace.useRef(null);
+  if (ref.current === null) {
+    ref.current = i18n ?? core.createI18n({ locale, messages });
+  }
+  const instance = ref.current;
+  React2__namespace.useEffect(() => {
+    if (i18n || !locale) return;
+    instance.setLocale(locale);
+  }, [locale, i18n, instance]);
+  React2__namespace.useEffect(() => {
+    if (i18n || !messages) return;
+    instance.setMessages(messages);
+  }, [messages, i18n, instance]);
+  React2__namespace.useEffect(() => {
+    if (!autoDirection || !locale || typeof document === "undefined") return;
+    const el = directionTarget ?? document.documentElement;
+    const applied = theme.applyDirection(core.localeDirection(locale), el);
+    const prevLang = el.getAttribute("lang");
+    el.setAttribute("lang", locale);
+    return () => {
+      applied.revert();
+      if (prevLang === null) el.removeAttribute("lang");
+      else el.setAttribute("lang", prevLang);
+    };
+  }, [autoDirection, locale, directionTarget]);
+  return /* @__PURE__ */ jsxRuntime.jsx(I18nContext.Provider, { value: instance, children });
+}
+function useStore(store) {
+  return React2.useSyncExternalStore(
+    store.subscribe,
+    store.getState,
+    store.getState
+    // SSR fallback — same as client snapshot in our case.
+  );
+}
+
+// src/i18n/useI18n.ts
+var fallbackI18n = null;
+function getFallback() {
+  if (fallbackI18n === null) fallbackI18n = core.createI18n();
+  return fallbackI18n;
+}
+function useI18n() {
+  const ctx = React2__namespace.useContext(I18nContext);
+  const i18n = ctx ?? getFallback();
+  const state = useStore(i18n.store);
+  return {
+    locale: state.locale,
+    t: i18n.t,
+    formatDate: i18n.formatDate,
+    formatNumber: i18n.formatNumber,
+    formatRelativeTime: i18n.formatRelativeTime,
+    setLocale: i18n.setLocale,
+    setMessages: i18n.setMessages
+  };
+}
+
+exports.I18nContext = I18nContext;
+exports.IrisI18nProvider = IrisI18nProvider;
+exports.useI18n = useI18n;
+//# sourceMappingURL=i18n.cjs.map
+//# sourceMappingURL=i18n.cjs.map

package/dist/i18n.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/i18n/context.ts","../src/i18n/I18nProvider.tsx","../src/useStore.ts","../src/i18n/useI18n.ts"],"names":["React","React2","createI18n","applyDirection","localeDirection","useSyncExternalStore","React4"],"mappings":"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","file":"i18n.cjs","sourcesContent":["import * as React from 'react'\nimport type { I18n } from '@iris-ui-kit/core'\n\n/** Carries the active {@link I18n} instance to descendants via `useI18n`. */\nexport const I18nContext = React.createContext<I18n | null>(null)\n","import * as React from 'react'\nimport { createI18n, localeDirection, type I18n, type I18nMessages } from '@iris-ui-kit/core'\nimport { applyDirection } from '@iris-ui-kit/theme'\nimport { I18nContext } from './context'\n\nexport interface IrisI18nProviderProps {\n  /** BCP-47 locale. Changes are synced to the live instance. */\n  locale?: string\n  /** Message overrides. Changes are merged into the live instance. */\n  messages?: I18nMessages\n  /** Provide a pre-created instance instead of `locale` / `messages`. */\n  i18n?: I18n\n  /**\n   * When set, the locale's writing direction ({@link localeDirection}) is\n   * applied to `directionTarget` (`dir` + `data-iris-dir`) and `<html lang>` is\n   * set whenever `locale` changes — so \"set locale → flip direction + announce\n   * language\" needs no manual wiring. Off by default so it never fights an\n   * explicit `<ThemeProvider dir>`. Reverts on unmount.\n   */\n  autoDirection?: boolean\n  /** Element to receive dir/lang when `autoDirection` is set. Defaults to `document.documentElement`. */\n  directionTarget?: HTMLElement | null\n  children?: React.ReactNode\n}\n\n/**\n * Makes a locale + message dictionary available to descendant components via\n * `useI18n`. Either pass `locale` / `messages` (an instance is created and\n * kept in sync) or a pre-built `i18n` instance you control externally.\n */\nexport function IrisI18nProvider({\n  locale,\n  messages,\n  i18n,\n  autoDirection,\n  directionTarget,\n  children,\n}: IrisI18nProviderProps) {\n  const ref = React.useRef<I18n | null>(null)\n  if (ref.current === null) {\n    ref.current = i18n ?? createI18n({ locale, messages })\n  }\n  const instance = ref.current\n\n  React.useEffect(() => {\n    if (i18n || !locale) return\n    instance.setLocale(locale)\n  }, [locale, i18n, instance])\n\n  React.useEffect(() => {\n    if (i18n || !messages) return\n    instance.setMessages(messages)\n  }, [messages, i18n, instance])\n\n  // Auto-apply writing direction + `lang` from the active locale (opt-in).\n  React.useEffect(() => {\n    if (!autoDirection || !locale || typeof document === 'undefined') return\n    const el = directionTarget ?? document.documentElement\n    const applied = applyDirection(localeDirection(locale), el)\n    const prevLang = el.getAttribute('lang')\n    el.setAttribute('lang', locale)\n    return () => {\n      applied.revert()\n      if (prevLang === null) el.removeAttribute('lang')\n      else el.setAttribute('lang', prevLang)\n    }\n  }, [autoDirection, locale, directionTarget])\n\n  return <I18nContext.Provider value={instance}>{children}</I18nContext.Provider>\n}\n","import * as React from 'react'\nimport { useSyncExternalStore } from 'react'\nimport type { ReadonlyStore, Store } from '@iris-ui-kit/core'\n\n/**\n * Bridge a framework-agnostic `@iris-ui-kit/core` store into React reactivity.\n * Uses React 18's `useSyncExternalStore` — the contract is identical to the\n * one Vue uses via `ref + onMounted` and Solid uses via `createSignal`. The\n * **same** store can power Button, Popover, Dialog, etc. on any framework.\n */\nexport function useStore<T>(store: ReadonlyStore<T>): T {\n  return useSyncExternalStore(\n    store.subscribe,\n    store.getState,\n    store.getState, // SSR fallback — same as client snapshot in our case.\n  )\n}\n\n/**\n * Subscribe to a DERIVED slice of a core store — the component re-renders only\n * when `selector(state)` changes per `isEqual` (default `Object.is`), not on\n * every store emission. Built on {@link Store.subscribeWith}. Inline closures\n * for `selector`/`isEqual` are fine (captured via refs; the subscription is not\n * re-created between renders).\n */\nexport function useStoreSelector<T, U>(\n  store: Store<T>,\n  selector: (state: T) => U,\n  isEqual?: (a: U, b: U) => boolean,\n): U {\n  const [slice, setSlice] = React.useState(() => selector(store.getState()))\n  const selRef = React.useRef(selector)\n  selRef.current = selector\n  const eqRef = React.useRef(isEqual)\n  eqRef.current = isEqual\n  React.useEffect(() => {\n    const read = (s: T): U => selRef.current(s)\n    const eq = (a: U, b: U): boolean => (eqRef.current ?? Object.is)(a, b)\n    // Re-sync in case the store moved between render and this effect.\n    setSlice((prev) => {\n      const next = read(store.getState())\n      return eq(prev, next) ? prev : next\n    })\n    return store.subscribeWith(read, setSlice, eq)\n  }, [store])\n  return slice\n}\n","import * as React from 'react'\nimport { createI18n, type I18n } from '@iris-ui-kit/core'\nimport { useStore } from '../useStore'\nimport { I18nContext } from './context'\n\nexport interface UseI18nReturn {\n  locale: string\n  t: I18n['t']\n  formatDate: I18n['formatDate']\n  formatNumber: I18n['formatNumber']\n  formatRelativeTime: I18n['formatRelativeTime']\n  setLocale: I18n['setLocale']\n  setMessages: I18n['setMessages']\n}\n\n// Shared fallback so components can call `useI18n()` without an enclosing\n// provider — they get English defaults rather than throwing.\nlet fallbackI18n: I18n | null = null\nfunction getFallback(): I18n {\n  if (fallbackI18n === null) fallbackI18n = createI18n()\n  return fallbackI18n\n}\n\n/**\n * Reactive access to the active locale + translation/formatting helpers.\n * Re-renders the host when the locale or messages change. Works with or\n * without an `<IrisI18nProvider>` (falls back to English defaults).\n */\nexport function useI18n(): UseI18nReturn {\n  const ctx = React.useContext(I18nContext)\n  const i18n = ctx ?? getFallback()\n  const state = useStore(i18n.store)\n\n  return {\n    locale: state.locale,\n    t: i18n.t,\n    formatDate: i18n.formatDate,\n    formatNumber: i18n.formatNumber,\n    formatRelativeTime: i18n.formatRelativeTime,\n    setLocale: i18n.setLocale,\n    setMessages: i18n.setMessages,\n  }\n}\n"]}

package/dist/i18n.d.cts

@@ -0,0 +1,50 @@
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import * as React from 'react';
+import { I18nMessages, I18n } from '@iris-ui-kit/core';
+
+interface IrisI18nProviderProps {
+    /** BCP-47 locale. Changes are synced to the live instance. */
+    locale?: string;
+    /** Message overrides. Changes are merged into the live instance. */
+    messages?: I18nMessages;
+    /** Provide a pre-created instance instead of `locale` / `messages`. */
+    i18n?: I18n;
+    /**
+     * When set, the locale's writing direction ({@link localeDirection}) is
+     * applied to `directionTarget` (`dir` + `data-iris-dir`) and `<html lang>` is
+     * set whenever `locale` changes — so "set locale → flip direction + announce
+     * language" needs no manual wiring. Off by default so it never fights an
+     * explicit `<ThemeProvider dir>`. Reverts on unmount.
+     */
+    autoDirection?: boolean;
+    /** Element to receive dir/lang when `autoDirection` is set. Defaults to `document.documentElement`. */
+    directionTarget?: HTMLElement | null;
+    children?: React.ReactNode;
+}
+/**
+ * Makes a locale + message dictionary available to descendant components via
+ * `useI18n`. Either pass `locale` / `messages` (an instance is created and
+ * kept in sync) or a pre-built `i18n` instance you control externally.
+ */
+declare function IrisI18nProvider({ locale, messages, i18n, autoDirection, directionTarget, children, }: IrisI18nProviderProps): react_jsx_runtime.JSX.Element;
+
+interface UseI18nReturn {
+    locale: string;
+    t: I18n['t'];
+    formatDate: I18n['formatDate'];
+    formatNumber: I18n['formatNumber'];
+    formatRelativeTime: I18n['formatRelativeTime'];
+    setLocale: I18n['setLocale'];
+    setMessages: I18n['setMessages'];
+}
+/**
+ * Reactive access to the active locale + translation/formatting helpers.
+ * Re-renders the host when the locale or messages change. Works with or
+ * without an `<IrisI18nProvider>` (falls back to English defaults).
+ */
+declare function useI18n(): UseI18nReturn;
+
+/** Carries the active {@link I18n} instance to descendants via `useI18n`. */
+declare const I18nContext: React.Context<I18n | null>;
+
+export { I18nContext, IrisI18nProvider, type IrisI18nProviderProps, type UseI18nReturn, useI18n };

package/dist/i18n.d.ts

@@ -0,0 +1,50 @@
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import * as React from 'react';
+import { I18nMessages, I18n } from '@iris-ui-kit/core';
+
+interface IrisI18nProviderProps {
+    /** BCP-47 locale. Changes are synced to the live instance. */
+    locale?: string;
+    /** Message overrides. Changes are merged into the live instance. */
+    messages?: I18nMessages;
+    /** Provide a pre-created instance instead of `locale` / `messages`. */
+    i18n?: I18n;
+    /**
+     * When set, the locale's writing direction ({@link localeDirection}) is
+     * applied to `directionTarget` (`dir` + `data-iris-dir`) and `<html lang>` is
+     * set whenever `locale` changes — so "set locale → flip direction + announce
+     * language" needs no manual wiring. Off by default so it never fights an
+     * explicit `<ThemeProvider dir>`. Reverts on unmount.
+     */
+    autoDirection?: boolean;
+    /** Element to receive dir/lang when `autoDirection` is set. Defaults to `document.documentElement`. */
+    directionTarget?: HTMLElement | null;
+    children?: React.ReactNode;
+}
+/**
+ * Makes a locale + message dictionary available to descendant components via
+ * `useI18n`. Either pass `locale` / `messages` (an instance is created and
+ * kept in sync) or a pre-built `i18n` instance you control externally.
+ */
+declare function IrisI18nProvider({ locale, messages, i18n, autoDirection, directionTarget, children, }: IrisI18nProviderProps): react_jsx_runtime.JSX.Element;
+
+interface UseI18nReturn {
+    locale: string;
+    t: I18n['t'];
+    formatDate: I18n['formatDate'];
+    formatNumber: I18n['formatNumber'];
+    formatRelativeTime: I18n['formatRelativeTime'];
+    setLocale: I18n['setLocale'];
+    setMessages: I18n['setMessages'];
+}
+/**
+ * Reactive access to the active locale + translation/formatting helpers.
+ * Re-renders the host when the locale or messages change. Works with or
+ * without an `<IrisI18nProvider>` (falls back to English defaults).
+ */
+declare function useI18n(): UseI18nReturn;
+
+/** Carries the active {@link I18n} instance to descendants via `useI18n`. */
+declare const I18nContext: React.Context<I18n | null>;
+
+export { I18nContext, IrisI18nProvider, type IrisI18nProviderProps, type UseI18nReturn, useI18n };

package/dist/i18n.js

@@ -0,0 +1,5 @@
+'use client'
+export { I18nContext, IrisI18nProvider, useI18n } from './chunk-OMOTUHYI.js';
+import './chunk-RZNYIFV2.js';
+//# sourceMappingURL=i18n.js.map
+//# sourceMappingURL=i18n.js.map

package/dist/i18n.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":";","file":"i18n.js"}