@lablup/ui-common 0.1.0-alpha.8 → 0.2.0-alpha.15

package/dist/components/Form/List.js

@@ -0,0 +1,65 @@
+import { FieldContext as e, ListContext as t } from "./context.js";
+import { getNamePath as n } from "./namePath.js";
+import r from "./Field.js";
+import * as i from "react";
+import { jsx as a } from "react/jsx-runtime";
+//#region src/components/Form/List.tsx
+var o = ({ name: o, initialValue: s, children: c, rules: l, validateTrigger: u, isListField: d }) => {
+	let f = i.useContext(e), p = i.useContext(t), m = i.useRef({
+		keys: [],
+		id: 0
+	}).current, h = i.useMemo(() => [...n(f.prefixName) || [], ...n(o)], [f.prefixName, o]), g = i.useMemo(() => ({
+		...f,
+		prefixName: h
+	}), [f, h]), _ = i.useMemo(() => ({ getKey: (e) => {
+		let t = h.length, n = e[t];
+		return [m.keys[n], e.slice(t + 1)];
+	} }), [m, h]);
+	return typeof c == "function" ? /* @__PURE__ */ a(t.Provider, {
+		value: _,
+		children: /* @__PURE__ */ a(e.Provider, {
+			value: g,
+			children: /* @__PURE__ */ a(r, {
+				name: [],
+				shouldUpdate: (e, t, { source: n }) => n !== "internal" && e !== t,
+				rules: l,
+				validateTrigger: u,
+				initialValue: s,
+				isList: !0,
+				isListField: d ?? !!p,
+				children: ({ value: e = [], onChange: t }, n) => {
+					let { getFieldValue: r } = f, i = () => r(h || []) || [], a = {
+						add: (e, n) => {
+							let r = i();
+							n !== void 0 && n >= 0 && n <= r.length ? (m.keys = [
+								...m.keys.slice(0, n),
+								m.id,
+								...m.keys.slice(n)
+							], t([
+								...r.slice(0, n),
+								e,
+								...r.slice(n)
+							])) : (m.keys = [...m.keys, m.id], t([...r, e])), m.id += 1;
+						},
+						remove: (e) => {
+							let n = i(), r = new Set(Array.isArray(e) ? e : [e]);
+							r.size <= 0 || (m.keys = m.keys.filter((e, t) => !r.has(t)), t(n.filter((e, t) => !r.has(t))));
+						}
+					}, o = e || [];
+					return Array.isArray(o) || (o = []), c(o.map((e, t) => {
+						let n = m.keys[t];
+						return n === void 0 && (m.keys[t] = m.id, n = m.keys[t], m.id += 1), {
+							name: t,
+							key: n,
+							isListField: !0
+						};
+					}), a, n);
+				}
+			})
+		})
+	}) : (process.env.NODE_ENV !== "production" && console.warn("[Form] Form.List only accepts a function as children."), null);
+};
+//#endregion
+export { o as default };
+
+//# sourceMappingURL=List.js.map

package/dist/components/Form/List.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"List.js","names":[],"sources":["../../../src/components/Form/List.tsx"],"sourcesContent":["/**\n * `Form.List`: repeated field groups. `move` is not implemented.\n *\n * Row identity is not the array index: `keyManager.keys` holds a stable id per\n * row and is spliced in lockstep with the value array, so `remove(index)`\n * does not move the removed row's errors onto its neighbour.\n * `listContext.getKey` maps an absolute field path back to\n * `[stableRowKey, restPath]`; `FormItem` uses it to key bubbled `noStyle`\n * metas by row identity too.\n */\nimport Field from \"./Field\";\nimport { FieldContext, ListContext, type ListContextValue } from \"./context\";\nimport type { Meta, Rule, StoreValue } from \"./interface\";\nimport { getNamePath, type InternalNamePath, type NamePath } from \"./namePath\";\nimport * as React from \"react\";\n\nexport interface ListField {\n  name: number;\n  key: number;\n  isListField: boolean;\n}\n\nexport interface ListOperations {\n  add: (defaultValue?: StoreValue, insertIndex?: number) => void;\n  remove: (index: number | number[]) => void;\n}\n\nexport interface ListProps {\n  name: NamePath;\n  rules?: Rule[];\n  validateTrigger?: string | string[] | false;\n  initialValue?: any[];\n  isListField?: boolean;\n  children: (\n    fields: ListField[],\n    operations: ListOperations,\n    meta: Meta,\n  ) => React.ReactNode;\n}\n\nconst List: React.FC<ListProps> = ({\n  name,\n  initialValue,\n  children,\n  rules,\n  validateTrigger,\n  isListField,\n}) => {\n  const context = React.useContext(FieldContext);\n  const wrapperListContext = React.useContext(ListContext);\n  const keyRef = React.useRef<{ keys: number[]; id: number }>({\n    keys: [],\n    id: 0,\n  });\n  const keyManager = keyRef.current;\n\n  // Nested lists compose: the inner list's prefix is the outer prefix plus\n  // its own (relative) name — `AdminDeploymentPresetModelConfigItem` nests\n  // `preStartActions` inside `modelDefinition.models[N].service`.\n  const prefixName: InternalNamePath = React.useMemo(() => {\n    const parentPrefixName = getNamePath(context.prefixName) || [];\n    return [...parentPrefixName, ...getNamePath(name)];\n  }, [context.prefixName, name]);\n\n  const fieldContext = React.useMemo(\n    () => ({ ...context, prefixName }),\n    [context, prefixName],\n  );\n\n  const listContext: ListContextValue = React.useMemo(\n    () => ({\n      getKey: (namePath) => {\n        const len = prefixName.length;\n        const pathName = namePath[len] as number;\n        return [keyManager.keys[pathName]!, namePath.slice(len + 1)];\n      },\n    }),\n    [keyManager, prefixName],\n  );\n\n  if (typeof children !== \"function\") {\n    if (process.env.NODE_ENV !== \"production\") {\n      console.warn(\"[Form] Form.List only accepts a function as children.\");\n    }\n    return null;\n  }\n\n  /**\n   * The list container re-renders on EXTERNAL changes only. An internal\n   * `onChange` (add/remove) already re-renders through the value it wrote;\n   * returning true here as well would double-render every mutation.\n   */\n  const shouldUpdate = (\n    prevValue: any,\n    nextValue: any,\n    { source }: { source?: string },\n  ) => {\n    if (source === \"internal\") {\n      return false;\n    }\n    return prevValue !== nextValue;\n  };\n\n  return (\n    <ListContext.Provider value={listContext}>\n      <FieldContext.Provider value={fieldContext}>\n        <Field\n          name={[]}\n          shouldUpdate={shouldUpdate}\n          rules={rules}\n          validateTrigger={validateTrigger}\n          initialValue={initialValue}\n          isList\n          isListField={isListField ?? !!wrapperListContext}\n        >\n          {({ value = [], onChange }: any, meta: Meta) => {\n            const { getFieldValue } = context;\n            // Always read the live value: the app may have replaced the whole\n            // list through `form.setFieldsValue` since the last render.\n            const getNewValue = (): any[] => getFieldValue(prefixName || []) || [];\n\n            const operations: ListOperations = {\n              add: (defaultValue, index) => {\n                const newValue = getNewValue();\n                if (index !== undefined && index >= 0 && index <= newValue.length) {\n                  keyManager.keys = [\n                    ...keyManager.keys.slice(0, index),\n                    keyManager.id,\n                    ...keyManager.keys.slice(index),\n                  ];\n                  onChange([\n                    ...newValue.slice(0, index),\n                    defaultValue,\n                    ...newValue.slice(index),\n                  ]);\n                } else {\n                  keyManager.keys = [...keyManager.keys, keyManager.id];\n                  onChange([...newValue, defaultValue]);\n                }\n                keyManager.id += 1;\n              },\n              remove: (index) => {\n                const newValue = getNewValue();\n                const indexSet = new Set(Array.isArray(index) ? index : [index]);\n                if (indexSet.size <= 0) {\n                  return;\n                }\n                keyManager.keys = keyManager.keys.filter(\n                  (_, keysIndex) => !indexSet.has(keysIndex),\n                );\n                onChange(newValue.filter((_, valueIndex) => !indexSet.has(valueIndex)));\n              },\n            };\n\n            let listValue: any[] = value || [];\n            if (!Array.isArray(listValue)) {\n              listValue = [];\n            }\n\n            return children(\n              listValue.map((__, index) => {\n                let key = keyManager.keys[index];\n                if (key === undefined) {\n                  keyManager.keys[index] = keyManager.id;\n                  key = keyManager.keys[index];\n                  keyManager.id += 1;\n                }\n                return { name: index, key, isListField: true };\n              }),\n              operations,\n              meta,\n            );\n          }}\n        </Field>\n      </FieldContext.Provider>\n    </ListContext.Provider>\n  );\n};\n\nexport default List;\n"],"mappings":";;;;;;AAwCA,IAAM,KAA6B,EACjC,SACA,iBACA,aACA,UACA,oBACA,qBACI;CACJ,IAAM,IAAU,EAAM,WAAW,CAAY,GACvC,IAAqB,EAAM,WAAW,CAAW,GAKjD,IAJS,EAAM,OAAuC;EAC1D,MAAM,CAAC;EACP,IAAI;CACN,CACmB,CAAA,CAAO,SAKpB,IAA+B,EAAM,cAElC,CAAC,GADiB,EAAY,EAAQ,UAAU,KAAK,CAAC,GAChC,GAAG,EAAY,CAAI,CAAC,GAChD,CAAC,EAAQ,YAAY,CAAI,CAAC,GAEvB,IAAe,EAAM,eAClB;EAAE,GAAG;EAAS;CAAW,IAChC,CAAC,GAAS,CAAU,CACtB,GAEM,IAAgC,EAAM,eACnC,EACL,SAAS,MAAa;EACpB,IAAM,IAAM,EAAW,QACjB,IAAW,EAAS;EAC1B,OAAO,CAAC,EAAW,KAAK,IAAY,EAAS,MAAM,IAAM,CAAC,CAAC;CAC7D,EACF,IACA,CAAC,GAAY,CAAU,CACzB;CAyBA,OAvBI,OAAO,KAAa,aAwBtB,kBAAC,EAAY,UAAb;EAAsB,OAAO;EAC3B,UAAA,kBAAC,EAAa,UAAd;GAAuB,OAAO;GAC5B,UAAA,kBAAC,GAAD;IACE,MAAM,CAAC;IACO,eAfpB,GACA,GACA,EAAE,gBAEE,MAAW,cAGR,MAAc;IASR;IACU;IACH;IACd,QAAA;IACA,aAAa,KAAe,CAAC,CAAC;IAE5B,WAAA,EAAE,WAAQ,CAAC,GAAG,eAAiB,MAAe;KAC9C,IAAM,EAAE,qBAAkB,GAGpB,UAA2B,EAAc,KAAc,CAAC,CAAC,KAAK,CAAC,GAE/D,IAA6B;MACjC,MAAM,GAAc,MAAU;OAC5B,IAAM,IAAW,EAAY;OAgB7B,AAfI,MAAU,KAAA,KAAa,KAAS,KAAK,KAAS,EAAS,UACzD,EAAW,OAAO;QAChB,GAAG,EAAW,KAAK,MAAM,GAAG,CAAK;QACjC,EAAW;QACX,GAAG,EAAW,KAAK,MAAM,CAAK;OAChC,GACA,EAAS;QACP,GAAG,EAAS,MAAM,GAAG,CAAK;QAC1B;QACA,GAAG,EAAS,MAAM,CAAK;OACzB,CAAC,MAED,EAAW,OAAO,CAAC,GAAG,EAAW,MAAM,EAAW,EAAE,GACpD,EAAS,CAAC,GAAG,GAAU,CAAY,CAAC,IAEtC,EAAW,MAAM;MACnB;MACA,SAAS,MAAU;OACjB,IAAM,IAAW,EAAY,GACvB,IAAW,IAAI,IAAI,MAAM,QAAQ,CAAK,IAAI,IAAQ,CAAC,CAAK,CAAC;OAC3D,EAAS,QAAQ,MAGrB,EAAW,OAAO,EAAW,KAAK,QAC/B,GAAG,MAAc,CAAC,EAAS,IAAI,CAAS,CAC3C,GACA,EAAS,EAAS,QAAQ,GAAG,MAAe,CAAC,EAAS,IAAI,CAAU,CAAC,CAAC;MACxE;KACF,GAEI,IAAmB,KAAS,CAAC;KAKjC,OAJK,MAAM,QAAQ,CAAS,MAC1B,IAAY,CAAC,IAGR,EACL,EAAU,KAAK,GAAI,MAAU;MAC3B,IAAI,IAAM,EAAW,KAAK;MAM1B,OALI,MAAQ,KAAA,MACV,EAAW,KAAK,KAAS,EAAW,IACpC,IAAM,EAAW,KAAK,IACtB,EAAW,MAAM,IAEZ;OAAE,MAAM;OAAO;OAAK,aAAa;MAAK;KAC/C,CAAC,GACD,GACA,CACF;IACF;GACK,CAAA;EACc,CAAA;CACH,CAAA,KA9FtB,QAAA,IAAA,aAA6B,gBAC3B,QAAQ,KAAK,uDAAuD,GAE/D;AA6FX"}

package/dist/components/Form/context.d.ts

@@ -0,0 +1,91 @@
+import { FieldData, FormInstance, InternalFormInstance, InternalHooks, Meta, ValidateMessages } from './interface';
+import { InternalNamePath } from './namePath';
+import * as React from "react";
+/** Guard for `getInternalHooks`; keeps the engine-private API out of reach. */
+export declare const HOOK_MARK = "UIC_FORM_INTERNAL_HOOKS";
+/**
+ * Carries the live `FormInstance` down to every `Field`. Also carries
+ * `prefixName`, which is what makes `Form.List` children address their fields
+ * RELATIVELY while `dependencies` and `useWatch` stay ABSOLUTE.
+ */
+export declare const FieldContext: React.Context<InternalFormInstance>;
+export interface ListContextValue {
+    /** Map an absolute field path to `[stableKey, restPath]` for the row it belongs to. */
+    getKey: (namePath: InternalNamePath) => [React.Key, InternalNamePath];
+}
+export declare const ListContext: React.Context<ListContextValue | null>;
+export interface FormProviderContextValue {
+    validateMessages?: ValidateMessages;
+    triggerFormChange: (name: string | undefined, changedFields: FieldData[]) => void;
+    triggerFormFinish: (name: string | undefined, values: any) => void;
+    registerForm: (name: string | undefined, form: FormInstance) => void;
+    unregisterForm: (name: string | undefined) => void;
+}
+export declare const FormProviderContext: React.Context<FormProviderContextValue>;
+export type RequiredMark = boolean | "optional" | ((label: React.ReactNode, info: {
+    required: boolean;
+}) => React.ReactNode);
+export interface FormConfig {
+    /**
+     * Message templates, `${label}`-based. Every `<Form>` already defaults them
+     * to ui-common's catalog in the active locale; these win over that.
+     */
+    validateMessages?: ValidateMessages;
+    requiredMark?: RequiredMark;
+    /**
+     * The suffix `requiredMark="optional"` appends. Defaults to the catalog's
+     * `uic.Form.optional`.
+     */
+    optionalLabel?: React.ReactNode;
+}
+/** What antd sourced from `<ConfigProvider form={{...}}>`. */
+export declare const FormConfigContext: React.Context<FormConfig>;
+/**
+ * What antd carries on its own `FormContext` — the per-form visual settings a
+ * `Form.Item` inherits unless it states its own. antd's `feedbackIcons`,
+ * `classNames`, `styles` and `variant` are not supported.
+ */
+export interface FormItemLayoutContextValue {
+    form?: FormInstance;
+    layout: FormLayout;
+    requiredMark?: RequiredMark;
+    disabled?: boolean;
+    name?: string;
+    size?: FormSize;
+    colon?: boolean;
+    labelAlign?: "left" | "right";
+    labelCol?: FormItemCol;
+    wrapperCol?: FormItemCol;
+    labelWrap?: boolean;
+}
+export type FormLayout = "vertical" | "horizontal" | "inline";
+export type FormSize = "small" | "middle" | "large";
+/** antd `Col` props, reduced to `span`, `offset`, `flex`, `className` and `style`. */
+export interface FormItemCol {
+    span?: number;
+    offset?: number;
+    flex?: string | number;
+    className?: string;
+    style?: React.CSSProperties;
+}
+export declare const FormItemLayoutContext: React.Context<FormItemLayoutContextValue>;
+export interface FormItemStatusContextValue {
+    status?: "success" | "warning" | "error" | "validating" | "";
+    errors?: React.ReactNode[];
+    warnings?: React.ReactNode[];
+    hasFeedback?: boolean;
+    isFormItemInput?: boolean;
+}
+/** Read by `Form.Item.useStatus()` and by controls that paint the item's status. */
+export declare const FormItemInputContext: React.Context<FormItemStatusContextValue>;
+export type SubItemMeta = Partial<Meta> & {
+    name: InternalNamePath;
+    destroy?: boolean;
+};
+/**
+ * How a rendering `Form.Item` collects the errors of the `noStyle` items
+ * nested inside it. Without it, a layout-only item loses its children's
+ * messages.
+ */
+export declare const NoStyleItemContext: React.Context<((meta: SubItemMeta, uniqueKeys: React.Key[]) => void) | null>;
+export type { InternalHooks };

package/dist/components/Form/context.js

@@ -0,0 +1,34 @@
+import * as e from "react";
+//#region src/components/Form/context.ts
+var t = "UIC_FORM_INTERNAL_HOOKS", n = () => {
+	process.env.NODE_ENV !== "production" && console.warn("[Form] Field used outside of a <Form>. Wrap it in a Form, or pass an explicit `form` instance.");
+}, r = e.createContext({
+	getFieldValue: n,
+	getFieldsValue: n,
+	getFieldError: n,
+	getFieldWarning: n,
+	getFieldsError: n,
+	isFieldsTouched: n,
+	isFieldTouched: n,
+	isFieldValidating: n,
+	isFieldsValidating: n,
+	resetFields: n,
+	setFields: n,
+	setFieldValue: n,
+	setFieldsValue: n,
+	validateFields: n,
+	submit: n,
+	scrollToField: n,
+	focusField: n,
+	getFieldInstance: n,
+	getInternalHooks: () => null
+}), i = e.createContext(null), a = e.createContext({
+	triggerFormChange: () => {},
+	triggerFormFinish: () => {},
+	registerForm: () => {},
+	unregisterForm: () => {}
+}), o = e.createContext({}), s = e.createContext({ layout: "horizontal" }), c = e.createContext({}), l = e.createContext(null);
+//#endregion
+export { r as FieldContext, o as FormConfigContext, c as FormItemInputContext, s as FormItemLayoutContext, a as FormProviderContext, t as HOOK_MARK, i as ListContext, l as NoStyleItemContext };
+
+//# sourceMappingURL=context.js.map

package/dist/components/Form/context.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"context.js","names":[],"sources":["../../../src/components/Form/context.ts"],"sourcesContent":["/**\n * React contexts of the form engine. Collapses what upstream splits across\n * rc-field-form's `FieldContext` / `FormContext` / `ListContext` and antd's\n * `form/context` into one module.\n */\nimport type {\n  FieldData,\n  FormInstance,\n  InternalFormInstance,\n  InternalHooks,\n  Meta,\n  ValidateMessages,\n} from \"./interface\";\nimport type { InternalNamePath } from \"./namePath\";\nimport * as React from \"react\";\n\n/** Guard for `getInternalHooks`; keeps the engine-private API out of reach. */\nexport const HOOK_MARK = \"UIC_FORM_INTERNAL_HOOKS\";\n\nconst noop = () => {\n  if (process.env.NODE_ENV !== \"production\") {\n    console.warn(\n      \"[Form] Field used outside of a <Form>. Wrap it in a Form, or pass an explicit `form` instance.\",\n    );\n  }\n  return undefined as any;\n};\n\n/**\n * Carries the live `FormInstance` down to every `Field`. Also carries\n * `prefixName`, which is what makes `Form.List` children address their fields\n * RELATIVELY while `dependencies` and `useWatch` stay ABSOLUTE.\n */\nexport const FieldContext = React.createContext<InternalFormInstance>({\n  getFieldValue: noop,\n  getFieldsValue: noop,\n  getFieldError: noop,\n  getFieldWarning: noop,\n  getFieldsError: noop,\n  isFieldsTouched: noop,\n  isFieldTouched: noop,\n  isFieldValidating: noop,\n  isFieldsValidating: noop,\n  resetFields: noop,\n  setFields: noop,\n  setFieldValue: noop,\n  setFieldsValue: noop,\n  validateFields: noop,\n  submit: noop,\n  scrollToField: noop,\n  focusField: noop,\n  getFieldInstance: noop,\n  getInternalHooks: () => null,\n} as unknown as InternalFormInstance);\n\nexport interface ListContextValue {\n  /** Map an absolute field path to `[stableKey, restPath]` for the row it belongs to. */\n  getKey: (namePath: InternalNamePath) => [React.Key, InternalNamePath];\n}\n\nexport const ListContext = React.createContext<ListContextValue | null>(null);\n\n// ============================== Form.Provider ===============================\n\nexport interface FormProviderContextValue {\n  validateMessages?: ValidateMessages;\n  triggerFormChange: (name: string | undefined, changedFields: FieldData[]) => void;\n  triggerFormFinish: (name: string | undefined, values: any) => void;\n  registerForm: (name: string | undefined, form: FormInstance) => void;\n  unregisterForm: (name: string | undefined) => void;\n}\n\nexport const FormProviderContext = React.createContext<FormProviderContextValue>({\n  triggerFormChange: () => {},\n  triggerFormFinish: () => {},\n  registerForm: () => {},\n  unregisterForm: () => {},\n});\n\n// ========================= App-level form configuration =====================\n\nexport type RequiredMark =\n  | boolean\n  | \"optional\"\n  | ((label: React.ReactNode, info: { required: boolean }) => React.ReactNode);\n\nexport interface FormConfig {\n  /**\n   * Message templates, `${label}`-based. Every `<Form>` already defaults them\n   * to ui-common's catalog in the active locale; these win over that.\n   */\n  validateMessages?: ValidateMessages;\n  requiredMark?: RequiredMark;\n  /**\n   * The suffix `requiredMark=\"optional\"` appends. Defaults to the catalog's\n   * `uic.Form.optional`.\n   */\n  optionalLabel?: React.ReactNode;\n}\n\n/** What antd sourced from `<ConfigProvider form={{...}}>`. */\nexport const FormConfigContext = React.createContext<FormConfig>({});\n\n// The provider lives in `./FormConfigProvider.tsx`: this module is engine\n// core, and stays free of anything heavier than React.\n\n// ============================ Per-form UI context ===========================\n\n/**\n * What antd carries on its own `FormContext` — the per-form visual settings a\n * `Form.Item` inherits unless it states its own. antd's `feedbackIcons`,\n * `classNames`, `styles` and `variant` are not supported.\n */\nexport interface FormItemLayoutContextValue {\n  form?: FormInstance;\n  layout: FormLayout;\n  requiredMark?: RequiredMark;\n  disabled?: boolean;\n  name?: string;\n  size?: FormSize;\n  colon?: boolean;\n  labelAlign?: \"left\" | \"right\";\n  labelCol?: FormItemCol;\n  wrapperCol?: FormItemCol;\n  labelWrap?: boolean;\n}\n\nexport type FormLayout = \"vertical\" | \"horizontal\" | \"inline\";\nexport type FormSize = \"small\" | \"middle\" | \"large\";\n\n/** antd `Col` props, reduced to `span`, `offset`, `flex`, `className` and `style`. */\nexport interface FormItemCol {\n  span?: number;\n  offset?: number;\n  flex?: string | number;\n  className?: string;\n  style?: React.CSSProperties;\n}\n\nexport const FormItemLayoutContext = React.createContext<FormItemLayoutContextValue>({\n  // antd's default: a form that states no layout is horizontal.\n  layout: \"horizontal\",\n});\n\n// ========================== Item status / bubbling ===========================\n\nexport interface FormItemStatusContextValue {\n  status?: \"success\" | \"warning\" | \"error\" | \"validating\" | \"\";\n  errors?: React.ReactNode[];\n  warnings?: React.ReactNode[];\n  hasFeedback?: boolean;\n  isFormItemInput?: boolean;\n}\n\n/** Read by `Form.Item.useStatus()` and by controls that paint the item's status. */\nexport const FormItemInputContext = React.createContext<FormItemStatusContextValue>({});\n\nexport type SubItemMeta = Partial<Meta> & {\n  name: InternalNamePath;\n  destroy?: boolean;\n};\n\n/**\n * How a rendering `Form.Item` collects the errors of the `noStyle` items\n * nested inside it. Without it, a layout-only item loses its children's\n * messages.\n */\nexport const NoStyleItemContext = React.createContext<\n  ((meta: SubItemMeta, uniqueKeys: React.Key[]) => void) | null\n>(null);\n\nexport type { InternalHooks };\n"],"mappings":";;AAiBA,IAAa,IAAY,2BAEnB,UAAa;CACjB,AAAA,QAAA,IAAA,aAA6B,gBAC3B,QAAQ,KACN,gGACF;AAGJ,GAOa,IAAe,EAAM,cAAoC;CACpE,eAAe;CACf,gBAAgB;CAChB,eAAe;CACf,iBAAiB;CACjB,gBAAgB;CAChB,iBAAiB;CACjB,gBAAgB;CAChB,mBAAmB;CACnB,oBAAoB;CACpB,aAAa;CACb,WAAW;CACX,eAAe;CACf,gBAAgB;CAChB,gBAAgB;CAChB,QAAQ;CACR,eAAe;CACf,YAAY;CACZ,kBAAkB;CAClB,wBAAwB;AAC1B,CAAoC,GAOvB,IAAc,EAAM,cAAuC,IAAI,GAY/D,IAAsB,EAAM,cAAwC;CAC/E,yBAAyB,CAAC;CAC1B,yBAAyB,CAAC;CAC1B,oBAAoB,CAAC;CACrB,sBAAsB,CAAC;AACzB,CAAC,GAwBY,IAAoB,EAAM,cAA0B,CAAC,CAAC,GAsCtD,IAAwB,EAAM,cAA0C,EAEnF,QAAQ,aACV,CAAC,GAaY,IAAuB,EAAM,cAA0C,CAAC,CAAC,GAYzE,IAAqB,EAAM,cAEtC,IAAI"}

package/dist/components/Form/feedbackIcons.d.ts

@@ -0,0 +1,13 @@
+/**
+ * The four validation feedback glyphs `hasFeedback` paints. The path data is
+ * Ant Design Icons' CheckCircleFilled, CloseCircleFilled,
+ * ExclamationCircleFilled and LoadingOutlined (MIT, see NOTICE). They draw in
+ * `currentColor`; the item shell sets the status colour.
+ */
+import * as React from "react";
+/**
+ * The glyph for a validation status, or `null` for the neutral state (antd
+ * draws nothing when `mergedValidateStatus` is empty).
+ */
+export declare const getFeedbackIcon: (status: string | undefined) => React.ReactNode;
+export default getFeedbackIcon;

package/dist/components/Form/feedbackIcons.js

@@ -0,0 +1,45 @@
+import "react";
+import { jsx as e } from "react/jsx-runtime";
+//#region src/components/Form/feedbackIcons.tsx
+var t = {
+	width: "1em",
+	height: "1em",
+	fill: "currentColor",
+	"aria-hidden": !0,
+	focusable: "false"
+}, n = {
+	success: {
+		viewBox: "64 64 896 896",
+		d: "M512 64C264.6 64 64 264.6 64 512s200.6 448 448 448 448-200.6 448-448S759.4 64 512 64zm193.5 301.7l-210.6 292a31.8 31.8 0 01-51.7 0L318.5 484.9c-3.8-5.3 0-12.7 6.5-12.7h46.9c10.2 0 19.9 4.9 25.9 13.3l71.2 98.8 157.2-218c6-8.3 15.6-13.3 25.9-13.3H699c6.5 0 10.3 7.4 6.5 12.7z"
+	},
+	error: {
+		viewBox: "64 64 896 896",
+		fillRule: "evenodd",
+		d: "M512 64c247.4 0 448 200.6 448 448S759.4 960 512 960 64 759.4 64 512 264.6 64 512 64zm127.98 274.82h-.04l-.08.06L512 466.75 384.14 338.88c-.04-.05-.06-.06-.08-.06a.12.12 0 00-.07 0c-.03 0-.05.01-.09.05l-45.02 45.02a.2.2 0 00-.05.09.12.12 0 000 .07v.02a.27.27 0 00.06.06L466.75 512 338.88 639.86c-.05.04-.06.06-.06.08a.12.12 0 000 .07c0 .03.01.05.05.09l45.02 45.02a.2.2 0 00.09.05.12.12 0 00.07 0c.02 0 .04-.01.08-.05L512 557.25l127.86 127.87c.04.04.06.05.08.05a.12.12 0 00.07 0c.03 0 .05-.01.09-.05l45.02-45.02a.2.2 0 00.05-.09.12.12 0 000-.07v-.02a.27.27 0 00-.05-.06L557.25 512l127.87-127.86c.04-.04.05-.06.05-.08a.12.12 0 000-.07c0-.03-.01-.05-.05-.09l-45.02-45.02a.2.2 0 00-.09-.05.12.12 0 00-.07 0z"
+	},
+	warning: {
+		viewBox: "64 64 896 896",
+		d: "M512 64C264.6 64 64 264.6 64 512s200.6 448 448 448 448-200.6 448-448S759.4 64 512 64zm-32 232c0-4.4 3.6-8 8-8h48c4.4 0 8 3.6 8 8v272c0 4.4-3.6 8-8 8h-48c-4.4 0-8-3.6-8-8V296zm32 440a48.01 48.01 0 010-96 48.01 48.01 0 010 96z"
+	},
+	validating: {
+		viewBox: "0 0 1024 1024",
+		d: "M988 548c-19.9 0-36-16.1-36-36 0-59.4-11.6-117-34.6-171.3a440.45 440.45 0 00-94.3-139.9 437.71 437.71 0 00-139.9-94.3C629 83.6 571.4 72 512 72c-19.9 0-36-16.1-36-36s16.1-36 36-36c69.1 0 136.2 13.5 199.3 40.3C772.3 66 827 103 874 150c47 47 83.9 101.8 109.7 162.7 26.7 63.1 40.2 130.2 40.2 199.3.1 19.9-16 36-35.9 36z"
+	}
+}, r = (r) => {
+	if (!r || !(r in n)) return null;
+	let i = n[r];
+	return /* @__PURE__ */ e("svg", {
+		...t,
+		viewBox: i.viewBox,
+		className: "uic-form-item__feedback-glyph",
+		"data-status": r,
+		children: /* @__PURE__ */ e("path", {
+			d: i.d,
+			fillRule: i.fillRule
+		})
+	});
+};
+//#endregion
+export { r as default, r as getFeedbackIcon };
+
+//# sourceMappingURL=feedbackIcons.js.map

package/dist/components/Form/feedbackIcons.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"feedbackIcons.js","names":[],"sources":["../../../src/components/Form/feedbackIcons.tsx"],"sourcesContent":["/**\n * The four validation feedback glyphs `hasFeedback` paints. The path data is\n * Ant Design Icons' CheckCircleFilled, CloseCircleFilled,\n * ExclamationCircleFilled and LoadingOutlined (MIT, see NOTICE). They draw in\n * `currentColor`; the item shell sets the status colour.\n */\nimport * as React from \"react\";\n\ntype Status = \"success\" | \"warning\" | \"error\" | \"validating\";\n\n/** antd icons draw on a 1024 grid with a 64-unit bleed; `1em` sizes to font. */\nconst BASE = {\n  width: \"1em\",\n  height: \"1em\",\n  fill: \"currentColor\",\n  \"aria-hidden\": true,\n  focusable: \"false\",\n} as const;\n\nconst PATHS: Record<Status, { viewBox: string; d: string; fillRule?: \"evenodd\" }> = {\n  success: {\n    viewBox: \"64 64 896 896\",\n    d: \"M512 64C264.6 64 64 264.6 64 512s200.6 448 448 448 448-200.6 448-448S759.4 64 512 64zm193.5 301.7l-210.6 292a31.8 31.8 0 01-51.7 0L318.5 484.9c-3.8-5.3 0-12.7 6.5-12.7h46.9c10.2 0 19.9 4.9 25.9 13.3l71.2 98.8 157.2-218c6-8.3 15.6-13.3 25.9-13.3H699c6.5 0 10.3 7.4 6.5 12.7z\",\n  },\n  error: {\n    viewBox: \"64 64 896 896\",\n    fillRule: \"evenodd\",\n    d: \"M512 64c247.4 0 448 200.6 448 448S759.4 960 512 960 64 759.4 64 512 264.6 64 512 64zm127.98 274.82h-.04l-.08.06L512 466.75 384.14 338.88c-.04-.05-.06-.06-.08-.06a.12.12 0 00-.07 0c-.03 0-.05.01-.09.05l-45.02 45.02a.2.2 0 00-.05.09.12.12 0 000 .07v.02a.27.27 0 00.06.06L466.75 512 338.88 639.86c-.05.04-.06.06-.06.08a.12.12 0 000 .07c0 .03.01.05.05.09l45.02 45.02a.2.2 0 00.09.05.12.12 0 00.07 0c.02 0 .04-.01.08-.05L512 557.25l127.86 127.87c.04.04.06.05.08.05a.12.12 0 00.07 0c.03 0 .05-.01.09-.05l45.02-45.02a.2.2 0 00.05-.09.12.12 0 000-.07v-.02a.27.27 0 00-.05-.06L557.25 512l127.87-127.86c.04-.04.05-.06.05-.08a.12.12 0 000-.07c0-.03-.01-.05-.05-.09l-45.02-45.02a.2.2 0 00-.09-.05.12.12 0 00-.07 0z\",\n  },\n  warning: {\n    viewBox: \"64 64 896 896\",\n    d: \"M512 64C264.6 64 64 264.6 64 512s200.6 448 448 448 448-200.6 448-448S759.4 64 512 64zm-32 232c0-4.4 3.6-8 8-8h48c4.4 0 8 3.6 8 8v272c0 4.4-3.6 8-8 8h-48c-4.4 0-8-3.6-8-8V296zm32 440a48.01 48.01 0 010-96 48.01 48.01 0 010 96z\",\n  },\n  validating: {\n    viewBox: \"0 0 1024 1024\",\n    d: \"M988 548c-19.9 0-36-16.1-36-36 0-59.4-11.6-117-34.6-171.3a440.45 440.45 0 00-94.3-139.9 437.71 437.71 0 00-139.9-94.3C629 83.6 571.4 72 512 72c-19.9 0-36-16.1-36-36s16.1-36 36-36c69.1 0 136.2 13.5 199.3 40.3C772.3 66 827 103 874 150c47 47 83.9 101.8 109.7 162.7 26.7 63.1 40.2 130.2 40.2 199.3.1 19.9-16 36-35.9 36z\",\n  },\n};\n\n/**\n * The glyph for a validation status, or `null` for the neutral state (antd\n * draws nothing when `mergedValidateStatus` is empty).\n */\nexport const getFeedbackIcon = (status: string | undefined): React.ReactNode => {\n  if (!status || !(status in PATHS)) return null;\n  const spec = PATHS[status as Status];\n  return (\n    <svg\n      {...BASE}\n      viewBox={spec.viewBox}\n      className=\"uic-form-item__feedback-glyph\"\n      data-status={status}\n    >\n      <path d={spec.d} fillRule={spec.fillRule} />\n    </svg>\n  );\n};\n\nexport default getFeedbackIcon;\n"],"mappings":";;;AAWA,IAAM,IAAO;CACX,OAAO;CACP,QAAQ;CACR,MAAM;CACN,eAAe;CACf,WAAW;AACb,GAEM,IAA8E;CAClF,SAAS;EACP,SAAS;EACT,GAAG;CACL;CACA,OAAO;EACL,SAAS;EACT,UAAU;EACV,GAAG;CACL;CACA,SAAS;EACP,SAAS;EACT,GAAG;CACL;CACA,YAAY;EACV,SAAS;EACT,GAAG;CACL;AACF,GAMa,KAAmB,MAAgD;CAC9E,IAAI,CAAC,KAAU,EAAE,KAAU,IAAQ,OAAO;CAC1C,IAAM,IAAO,EAAM;CACnB,OACE,kBAAC,OAAD;EACE,GAAI;EACJ,SAAS,EAAK;EACd,WAAU;EACV,eAAa;EAEb,UAAA,kBAAC,QAAD;GAAM,GAAG,EAAK;GAAG,UAAU,EAAK;EAAW,CAAA;CACxC,CAAA;AAET"}

package/dist/components/Form/index.d.ts

@@ -0,0 +1,30 @@
+import { default as ErrorList } from './ErrorList';
+import { default as InternalForm, FormProvider, useForm } from './Form';
+import { default as FormItem } from './FormItem';
+import { default as List } from './List';
+import { default as useWatch, useFormInstance } from './useWatch';
+type InternalFormType = typeof InternalForm;
+interface FormInterface extends InternalFormType {
+    Item: typeof FormItem;
+    List: typeof List;
+    ErrorList: typeof ErrorList;
+    useForm: typeof useForm;
+    useFormInstance: typeof useFormInstance;
+    useWatch: typeof useWatch;
+    Provider: typeof FormProvider;
+}
+declare const Form: FormInterface;
+export default Form;
+export { Form };
+export { FormItem, List as FormList, ErrorList, FormProvider, useForm, useWatch, useFormInstance, };
+export { FormItemVisual, type FormItemVisualProps } from './FormItemVisual';
+export { FormItemInputContext, NoStyleItemContext, FormConfigContext, type FormConfig, type FormItemStatusContextValue, type RequiredMark, } from './context';
+export { FormConfigProvider, useFormValidateMessages } from './FormConfigProvider';
+export { FormStore } from './FormStore';
+export { defaultValidateMessages } from './messages';
+export type { FormProps, FormRef } from './Form';
+export type { FormItemProps } from './FormItem';
+export type { ListProps as FormListProps, ListField, ListOperations } from './List';
+export type { ErrorListProps } from './ErrorList';
+export type { WatchOptions } from './useWatch';
+export type { FormInstance, FieldData, FieldError, Meta, NamePath, InternalNamePath, Rule, RuleObject, RuleRender, RuleType, Store, StoreValue, ValidateErrorEntity, ValidateMessages, ValidatorRule, } from './interface';

package/dist/components/Form/index.js

@@ -0,0 +1,18 @@
+import e from "./ErrorList.js";
+import { FormConfigContext as t, FormItemInputContext as n, NoStyleItemContext as r } from "./context.js";
+import { defaultValidateMessages as i } from "./messages.js";
+import a, { FormStore as o } from "./FormStore.js";
+import { FormConfigProvider as s, useFormValidateMessages as c } from "./FormConfigProvider.js";
+import l, { FormProvider as u } from "./Form.js";
+import { FormItemVisual as d } from "./FormItemVisual2.js";
+import f, { useFormItemStatus as p } from "./FormItem.js";
+import m from "./List.js";
+import h, { useFormInstance as g } from "./useWatch.js";
+//#region src/components/Form/index.ts
+f.useStatus = p;
+var _ = l;
+_.Item = f, _.List = m, _.ErrorList = e, _.useForm = a, _.useFormInstance = g, _.useWatch = h, _.Provider = u;
+//#endregion
+export { e as ErrorList, _ as Form, _ as default, t as FormConfigContext, s as FormConfigProvider, f as FormItem, n as FormItemInputContext, d as FormItemVisual, m as FormList, u as FormProvider, o as FormStore, r as NoStyleItemContext, i as defaultValidateMessages, a as useForm, g as useFormInstance, c as useFormValidateMessages, h as useWatch };
+
+//# sourceMappingURL=index.js.map

package/dist/components/Form/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":[],"sources":["../../../src/components/Form/index.ts"],"sourcesContent":["/**\n * `@lablup/ui-common/Form`: a form engine with antd's form API (`Form`,\n * `Form.Item`, `Form.List`, `Form.ErrorList`, `Form.Provider`,\n * `Form.useForm`, `Form.useWatch`, `Form.useFormInstance`,\n * `Form.Item.useStatus`), so code written against antd's form moves onto it\n * with an import rewrite. The state half is a behavioural port of\n * rc-field-form; the item shell renders on Astryx.\n *\n * The API is a form-state API, not an Astryx-shaped component: it keeps\n * antd's names and shapes on purpose.\n */\nimport ErrorList from \"./ErrorList\";\nimport InternalForm, { FormProvider, useForm } from \"./Form\";\nimport FormItem, { useFormItemStatus } from \"./FormItem\";\nimport List from \"./List\";\nimport useWatch, { useFormInstance } from \"./useWatch\";\n\ntype InternalFormType = typeof InternalForm;\n\ninterface FormInterface extends InternalFormType {\n  Item: typeof FormItem;\n  List: typeof List;\n  ErrorList: typeof ErrorList;\n  useForm: typeof useForm;\n  useFormInstance: typeof useFormInstance;\n  useWatch: typeof useWatch;\n  Provider: typeof FormProvider;\n}\n\ntype FormItemWithStatus = typeof FormItem & {\n  useStatus: typeof useFormItemStatus;\n};\n\n(FormItem as FormItemWithStatus).useStatus = useFormItemStatus;\n\nconst Form = InternalForm as FormInterface;\nForm.Item = FormItem;\nForm.List = List;\nForm.ErrorList = ErrorList;\nForm.useForm = useForm;\nForm.useFormInstance = useFormInstance;\nForm.useWatch = useWatch;\nForm.Provider = FormProvider;\n\nexport default Form;\nexport { Form };\n\nexport {\n  FormItem,\n  List as FormList,\n  ErrorList,\n  FormProvider,\n  useForm,\n  useWatch,\n  useFormInstance,\n};\nexport { FormItemVisual, type FormItemVisualProps } from \"./FormItemVisual\";\nexport {\n  // Read by controls that paint their item's validation status, and by\n  // custom item shells that publish sub-item metas.\n  FormItemInputContext,\n  NoStyleItemContext,\n  FormConfigContext,\n  type FormConfig,\n  type FormItemStatusContextValue,\n  type RequiredMark,\n} from \"./context\";\nexport { FormConfigProvider, useFormValidateMessages } from \"./FormConfigProvider\";\nexport { FormStore } from \"./FormStore\";\nexport { defaultValidateMessages } from \"./messages\";\n\nexport type { FormProps, FormRef } from \"./Form\";\nexport type { FormItemProps } from \"./FormItem\";\nexport type { ListProps as FormListProps, ListField, ListOperations } from \"./List\";\nexport type { ErrorListProps } from \"./ErrorList\";\nexport type { WatchOptions } from \"./useWatch\";\nexport type {\n  FormInstance,\n  FieldData,\n  FieldError,\n  Meta,\n  NamePath,\n  InternalNamePath,\n  Rule,\n  RuleObject,\n  RuleRender,\n  RuleType,\n  Store,\n  StoreValue,\n  ValidateErrorEntity,\n  ValidateMessages,\n  ValidatorRule,\n} from \"./interface\";\n"],"mappings":";;;;;;;;;;;AAiCA,EAAiC,YAAY;AAE7C,IAAM,IAAO;AACb,EAAK,OAAO,GACZ,EAAK,OAAO,GACZ,EAAK,YAAY,GACjB,EAAK,UAAU,GACf,EAAK,kBAAkB,GACvB,EAAK,WAAW,GAChB,EAAK,WAAW"}

package/dist/components/Form/interface.d.ts

@@ -0,0 +1,212 @@
+import { InternalNamePath, NamePath, Store } from './namePath';
+import type * as React from "react";
+export type { NamePath, InternalNamePath, Store, NamePathSegment } from './namePath';
+export type StoreValue = any;
+/** The supported `type` values. */
+export type RuleType = "string" | "number" | "email" | "url" | "object";
+export type ValidatorRule = {
+    warningOnly?: boolean;
+    message?: React.ReactNode;
+    validator: (rule: RuleObject, value: StoreValue, callback: (error?: string) => void) => Promise<void | any> | void;
+};
+export interface BaseRule {
+    warningOnly?: boolean;
+    /**
+     * `undefined` means "generate the default message"; an EMPTY STRING means
+     * "this rule intentionally shows no text", so the engine must not treat
+     * `''` as absent.
+     */
+    message?: React.ReactNode;
+    required?: boolean;
+    type?: RuleType;
+    max?: number;
+    min?: number;
+    pattern?: RegExp;
+    whitespace?: boolean;
+    /** Per-rule trigger filter; the field-level `validateTrigger` is the default. */
+    validateTrigger?: string | string[];
+}
+export interface RuleObject extends BaseRule {
+    validator?: ValidatorRule["validator"];
+}
+export type RuleRender = (form: FormInstance) => RuleObject;
+export type Rule = RuleObject | RuleRender;
+export interface FieldError {
+    name: InternalNamePath;
+    errors: string[];
+    warnings: string[];
+}
+export interface Meta {
+    touched: boolean;
+    validating: boolean;
+    errors: string[];
+    warnings: string[];
+    name: InternalNamePath;
+    validated: boolean;
+}
+export interface FieldData extends Partial<Omit<Meta, "name">> {
+    name: NamePath;
+    value?: StoreValue;
+}
+export interface ValidateErrorEntity<Values = any> {
+    values: Values;
+    errorFields: {
+        name: InternalNamePath;
+        errors: string[];
+    }[];
+    outOfDate: boolean;
+}
+export interface ValidateOptions {
+    triggerName?: string;
+    validateMessages?: ValidateMessages;
+    /** Also validate every field NESTED under a requested path. */
+    recursive?: boolean;
+    /** Only validate fields the user has touched / that have been validated. */
+    dirty?: boolean;
+}
+/**
+ * A template is normally a `${label}`-style string, but antd's locale bundles
+ * also allow a thunk (some locales build the sentence at call time). `format`
+ * invokes the thunk; only strings go through `${}` substitution.
+ */
+export type ValidateMessage = string | (() => string);
+type RangeMessages = {
+    min?: ValidateMessage;
+    max?: ValidateMessage;
+    range?: ValidateMessage;
+    len?: ValidateMessage;
+};
+export interface ValidateMessages {
+    default?: ValidateMessage;
+    required?: ValidateMessage;
+    whitespace?: ValidateMessage;
+    types?: Partial<Record<RuleType, ValidateMessage>>;
+    string?: RangeMessages;
+    number?: RangeMessages;
+    array?: RangeMessages;
+    pattern?: {
+        mismatch?: ValidateMessage;
+    };
+    [key: string]: any;
+}
+export interface FormInstance<Values = any> {
+    getFieldValue: (name: NamePath) => StoreValue;
+    getFieldsValue: ((nameList?: NamePath[]) => Values) & ((nameList: true, filterFunc?: (meta: Meta) => boolean) => Values) & ((config: {
+        strict?: boolean;
+        filter?: (meta: Meta) => boolean;
+    }) => Values);
+    getFieldError: (name: NamePath) => string[];
+    getFieldWarning: (name: NamePath) => string[];
+    getFieldsError: (nameList?: NamePath[]) => FieldError[];
+    isFieldsTouched: ((nameList?: NamePath[], allFieldsTouched?: boolean) => boolean) & ((allFieldsTouched?: boolean) => boolean);
+    isFieldTouched: (name: NamePath) => boolean;
+    isFieldValidating: (name: NamePath) => boolean;
+    isFieldsValidating: (nameList?: NamePath[]) => boolean;
+    resetFields: (fields?: NamePath[]) => void;
+    setFields: (fields: FieldData[]) => void;
+    setFieldValue: (name: NamePath, value: StoreValue) => void;
+    setFieldsValue: (values: RecursivePartial<Values>) => void;
+    validateFields: ValidateFields<Values>;
+    submit: () => void;
+    /** Thin implementation — see `FormStore.scrollToField` for the caveat. */
+    scrollToField: (name: NamePath, options?: ScrollOptions) => void;
+    focusField: (name: NamePath) => void;
+    getFieldInstance: (name: NamePath) => any;
+}
+export interface ScrollOptions extends ScrollIntoViewOptions {
+    focus?: boolean;
+}
+export type RecursivePartial<T> = T extends object ? {
+    [K in keyof T]?: RecursivePartial<T[K]>;
+} : T;
+type ValidateFields<Values = any> = ((nameList?: NamePath[], options?: ValidateOptions) => Promise<Values>) & ((options?: ValidateOptions) => Promise<Values>);
+/** Engine-internal view of a mounted `Field`. */
+export interface FieldEntity {
+    onStoreChange: (store: Store, namePathList: InternalNamePath[] | null, info: NotifyInfo) => void;
+    isFieldTouched: () => boolean;
+    isFieldDirty: () => boolean;
+    isFieldValidating: () => boolean;
+    isListField: () => boolean | undefined;
+    isList: () => boolean | undefined;
+    isPreserve: () => boolean | undefined;
+    validateRules: (options?: InternalValidateOptions) => Promise<RuleError[]>;
+    getMeta: () => Meta;
+    getNamePath: () => InternalNamePath;
+    getErrors: () => string[];
+    getWarnings: () => string[];
+    props: {
+        name?: NamePath;
+        rules?: Rule[];
+        dependencies?: NamePath[];
+        initialValue?: any;
+    };
+}
+export interface InternalValidateOptions extends ValidateOptions {
+    validateOnly?: boolean;
+    /** Wait a frame so `useWatch`-derived rules see the latest value. */
+    delayFrame?: boolean;
+}
+export interface RuleError {
+    errors: string[];
+    rule: RuleObject;
+}
+/** `Omit` that distributes over a union instead of collapsing it. */
+export type DistributiveOmit<T, K extends PropertyKey> = T extends any ? Omit<T, K> : never;
+export type NotifyInfo = {
+    type: "valueUpdate";
+    source: "internal" | "external";
+    store: Store;
+} | {
+    type: "validateFinish";
+    store: Store;
+} | {
+    type: "reset";
+    store: Store;
+} | {
+    type: "remove";
+    store: Store;
+} | {
+    type: "setField";
+    data: FieldData;
+    store: Store;
+} | {
+    type: "dependenciesUpdate";
+    relatedFields: InternalNamePath[];
+    store: Store;
+};
+export interface Callbacks<Values = any> {
+    onValuesChange?: (changedValues: any, values: Values) => void;
+    onFieldsChange?: (changedFields: FieldData[], allFields: FieldData[]) => void;
+    onFinish?: (values: Values) => void;
+    onFinishFailed?: (errorInfo: ValidateErrorEntity<Values>) => void;
+}
+export interface InternalHooks {
+    dispatch: (action: ReducerAction) => void;
+    initEntityValue: (entity: FieldEntity) => void;
+    registerField: (entity: FieldEntity) => (isListField?: boolean, preserve?: boolean, subNamePath?: InternalNamePath) => void;
+    useSubscribe: (subscribable: boolean) => void;
+    setInitialValues: (values: Store | undefined, init: boolean) => void;
+    destroyForm: (clearOnDestroy?: boolean) => void;
+    setCallbacks: (callbacks: Callbacks) => void;
+    setValidateMessages: (validateMessages: ValidateMessages) => void;
+    getFields: () => FieldData[];
+    setPreserve: (preserve?: boolean) => void;
+    getInitialValue: (namePath: InternalNamePath) => StoreValue;
+    registerWatch: (callback: WatchCallBack) => () => void;
+}
+export type WatchCallBack = (values: Store, allValues: Store) => void;
+export type ReducerAction = {
+    type: "updateValue";
+    namePath: InternalNamePath;
+    value: StoreValue;
+} | {
+    type: "validateField";
+    namePath: InternalNamePath;
+    triggerName: string;
+};
+export interface InternalFormInstance extends FormInstance {
+    prefixName?: InternalNamePath;
+    validateTrigger?: string | string[] | false;
+    getInternalHooks: (secret: string) => InternalHooks | null;
+    _init?: boolean;
+}

package/dist/components/Form/isEqual.d.ts

@@ -0,0 +1 @@
+export declare function isEqual(a: unknown, b: unknown): boolean;

package/dist/components/Form/isEqual.js

@@ -0,0 +1,61 @@
+//#region src/components/Form/isEqual.ts
+var e = (e) => Object.prototype.toString.call(e), t = (e, t) => Object.prototype.hasOwnProperty.call(e, t);
+function n(e) {
+	return [...Object.keys(e), ...Object.getOwnPropertySymbols(e).filter((t) => Object.prototype.propertyIsEnumerable.call(e, t))];
+}
+function r(e, t, n) {
+	if (e.length !== t.length) return !1;
+	let r = /* @__PURE__ */ new Set();
+	return e.every((e) => {
+		let i = t.findIndex((t, i) => !r.has(i) && o(e, t, n));
+		return i !== -1 && (r.add(i), !0);
+	});
+}
+function i(e, t, n) {
+	if (e.length !== t.length) return !1;
+	for (let r = 0; r < e.length; r += 1) if (!o(e[r], t[r], n)) return !1;
+	return !0;
+}
+function a(e, r, i) {
+	let a = n(e);
+	if (a.length !== n(r).length) return !1;
+	for (let n of a) if (!t(r, n) || !o(e[n], r[n], i)) return !1;
+	let s = e.constructor, c = r.constructor;
+	return !(s !== c && "constructor" in e && "constructor" in r && !(typeof s == "function" && s instanceof s && typeof c == "function" && c instanceof c));
+}
+function o(t, n, o) {
+	if (t === n) return !0;
+	if (t == null || n == null || typeof t != "object" || typeof n != "object") return t !== t && n !== n;
+	let s = e(t);
+	if (s !== e(n)) return !1;
+	for (let [e, r] of o) if (e === t) return r === n;
+	o.push([t, n]);
+	try {
+		switch (s) {
+			case "[object Array]": return i(t, n, o);
+			case "[object Object]":
+			case "[object Arguments]": return a(t, n, o);
+			case "[object Date]":
+			case "[object Number]":
+			case "[object Boolean]": {
+				let e = Number(t), r = Number(n);
+				return e === r || e !== e && r !== r;
+			}
+			case "[object RegExp]":
+			case "[object String]": return String(t) === String(n);
+			case "[object Error]": return t.name === n.name && t.message === n.message;
+			case "[object Map]": return r([...t], [...n], o);
+			case "[object Set]": return r([...t], [...n], o);
+			default: return ArrayBuffer.isView(t) && ArrayBuffer.isView(n) ? i(t, n, o) : !1;
+		}
+	} finally {
+		o.pop();
+	}
+}
+function s(e, t) {
+	return o(e, t, []);
+}
+//#endregion
+export { s as isEqual };
+
+//# sourceMappingURL=isEqual.js.map

package/dist/components/Form/isEqual.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"isEqual.js","names":[],"sources":["../../../src/components/Form/isEqual.ts"],"sourcesContent":["/**\n * Deep equality for form values and field metas, with lodash `isEqual`'s\n * semantics for the shapes a form holds: primitives (`NaN` equals `NaN`),\n * arrays and typed arrays, plain and class-instance objects (own enumerable\n * keys, then a constructor check), `Date`, `RegExp`, boxed primitives,\n * `Error`, `Map` and `Set` (order-insensitive), and cycles. Any other\n * built-in tag (`File`, `Blob`, DOM nodes, …) is equal only by reference, as\n * in lodash.\n *\n * It differs from lodash only for `ArrayBuffer` (by reference here, by bytes\n * in lodash), `DataView` (keys only here, so views over different bytes are\n * equal; by bytes in lodash) and a boxed primitive against its primitive\n * (`Object(1)` vs `1`: unequal here, equal in lodash).\n */\nconst toTag = (value: unknown) => Object.prototype.toString.call(value);\nconst hasOwn = (value: object, key: PropertyKey) =>\n  Object.prototype.hasOwnProperty.call(value, key);\n\ntype Stack = Array<[unknown, unknown]>;\n\nfunction ownKeys(value: object): PropertyKey[] {\n  return [\n    ...Object.keys(value),\n    ...Object.getOwnPropertySymbols(value).filter((s) =>\n      Object.prototype.propertyIsEnumerable.call(value, s),\n    ),\n  ];\n}\n\nfunction equalUnordered(a: unknown[], b: unknown[], stack: Stack): boolean {\n  if (a.length !== b.length) return false;\n  const used = new Set<number>();\n  return a.every((item) => {\n    const index = b.findIndex((other, i) => !used.has(i) && equal(item, other, stack));\n    if (index === -1) return false;\n    used.add(index);\n    return true;\n  });\n}\n\nfunction equalSequence(a: ArrayLike<unknown>, b: ArrayLike<unknown>, stack: Stack) {\n  if (a.length !== b.length) return false;\n  for (let i = 0; i < a.length; i += 1) {\n    if (!equal(a[i], b[i], stack)) return false;\n  }\n  return true;\n}\n\nfunction equalObjects(a: object, b: object, stack: Stack): boolean {\n  const keys = ownKeys(a);\n  if (keys.length !== ownKeys(b).length) return false;\n  for (const key of keys) {\n    if (!hasOwn(b, key)) return false;\n    if (\n      !equal(\n        (a as Record<PropertyKey, unknown>)[key],\n        (b as Record<PropertyKey, unknown>)[key],\n        stack,\n      )\n    )\n      return false;\n  }\n  const ctorA = (a as { constructor?: unknown }).constructor;\n  const ctorB = (b as { constructor?: unknown }).constructor;\n  if (\n    ctorA !== ctorB &&\n    \"constructor\" in a &&\n    \"constructor\" in b &&\n    !(\n      typeof ctorA === \"function\" &&\n      ctorA instanceof ctorA &&\n      typeof ctorB === \"function\" &&\n      ctorB instanceof ctorB\n    )\n  ) {\n    return false;\n  }\n  return true;\n}\n\nfunction equal(a: unknown, b: unknown, stack: Stack): boolean {\n  if (a === b) return true;\n  if (a == null || b == null || typeof a !== \"object\" || typeof b !== \"object\") {\n    // Only NaN is unequal to itself; functions compare by reference.\n    return a !== a && b !== b;\n  }\n  const tag = toTag(a);\n  if (tag !== toTag(b)) return false;\n\n  for (const [x, y] of stack) {\n    if (x === a) return y === b;\n  }\n  stack.push([a, b]);\n  try {\n    switch (tag) {\n      case \"[object Array]\":\n        return equalSequence(a as unknown[], b as unknown[], stack);\n      case \"[object Object]\":\n      case \"[object Arguments]\":\n        return equalObjects(a, b, stack);\n      case \"[object Date]\":\n      case \"[object Number]\":\n      case \"[object Boolean]\": {\n        const x = Number(a);\n        const y = Number(b);\n        return x === y || (x !== x && y !== y);\n      }\n      case \"[object RegExp]\":\n      case \"[object String]\":\n        return String(a) === String(b);\n      case \"[object Error]\":\n        return (\n          (a as Error).name === (b as Error).name &&\n          (a as Error).message === (b as Error).message\n        );\n      case \"[object Map]\":\n        return equalUnordered(\n          [...(a as Map<unknown, unknown>)],\n          [...(b as Map<unknown, unknown>)],\n          stack,\n        );\n      case \"[object Set]\":\n        return equalUnordered(\n          [...(a as Set<unknown>)],\n          [...(b as Set<unknown>)],\n          stack,\n        );\n      default:\n        if (ArrayBuffer.isView(a) && ArrayBuffer.isView(b)) {\n          return equalSequence(\n            a as unknown as ArrayLike<unknown>,\n            b as unknown as ArrayLike<unknown>,\n            stack,\n          );\n        }\n        return false;\n    }\n  } finally {\n    stack.pop();\n  }\n}\n\nexport function isEqual(a: unknown, b: unknown): boolean {\n  return equal(a, b, []);\n}\n"],"mappings":";AAcA,IAAM,KAAS,MAAmB,OAAO,UAAU,SAAS,KAAK,CAAK,GAChE,KAAU,GAAe,MAC7B,OAAO,UAAU,eAAe,KAAK,GAAO,CAAG;AAIjD,SAAS,EAAQ,GAA8B;CAC7C,OAAO,CACL,GAAG,OAAO,KAAK,CAAK,GACpB,GAAG,OAAO,sBAAsB,CAAK,CAAC,CAAC,QAAQ,MAC7C,OAAO,UAAU,qBAAqB,KAAK,GAAO,CAAC,CACrD,CACF;AACF;AAEA,SAAS,EAAe,GAAc,GAAc,GAAuB;CACzE,IAAI,EAAE,WAAW,EAAE,QAAQ,OAAO;CAClC,IAAM,oBAAO,IAAI,IAAY;CAC7B,OAAO,EAAE,OAAO,MAAS;EACvB,IAAM,IAAQ,EAAE,WAAW,GAAO,MAAM,CAAC,EAAK,IAAI,CAAC,KAAK,EAAM,GAAM,GAAO,CAAK,CAAC;EAGjF,OAFI,MAAU,OACd,EAAK,IAAI,CAAK,GACP;CACT,CAAC;AACH;AAEA,SAAS,EAAc,GAAuB,GAAuB,GAAc;CACjF,IAAI,EAAE,WAAW,EAAE,QAAQ,OAAO;CAClC,KAAK,IAAI,IAAI,GAAG,IAAI,EAAE,QAAQ,KAAK,GACjC,IAAI,CAAC,EAAM,EAAE,IAAI,EAAE,IAAI,CAAK,GAAG,OAAO;CAExC,OAAO;AACT;AAEA,SAAS,EAAa,GAAW,GAAW,GAAuB;CACjE,IAAM,IAAO,EAAQ,CAAC;CACtB,IAAI,EAAK,WAAW,EAAQ,CAAC,CAAC,CAAC,QAAQ,OAAO;CAC9C,KAAK,IAAM,KAAO,GAEhB,IADI,CAAC,EAAO,GAAG,CAAG,KAEhB,CAAC,EACE,EAAmC,IACnC,EAAmC,IACpC,CACF,GAEA,OAAO;CAEX,IAAM,IAAS,EAAgC,aACzC,IAAS,EAAgC;CAc/C,OAbA,EACE,MAAU,KACV,iBAAiB,KACjB,iBAAiB,KACjB,EACE,OAAO,KAAU,cACjB,aAAiB,KACjB,OAAO,KAAU,cACjB,aAAiB;AAMvB;AAEA,SAAS,EAAM,GAAY,GAAY,GAAuB;CAC5D,IAAI,MAAM,GAAG,OAAO;CACpB,IAAI,KAAK,QAAQ,KAAK,QAAQ,OAAO,KAAM,YAAY,OAAO,KAAM,UAElE,OAAO,MAAM,KAAK,MAAM;CAE1B,IAAM,IAAM,EAAM,CAAC;CACnB,IAAI,MAAQ,EAAM,CAAC,GAAG,OAAO;CAE7B,KAAK,IAAM,CAAC,GAAG,MAAM,GACnB,IAAI,MAAM,GAAG,OAAO,MAAM;CAE5B,EAAM,KAAK,CAAC,GAAG,CAAC,CAAC;CACjB,IAAI;EACF,QAAQ,GAAR;GACE,KAAK,kBACH,OAAO,EAAc,GAAgB,GAAgB,CAAK;GAC5D,KAAK;GACL,KAAK,sBACH,OAAO,EAAa,GAAG,GAAG,CAAK;GACjC,KAAK;GACL,KAAK;GACL,KAAK,oBAAoB;IACvB,IAAM,IAAI,OAAO,CAAC,GACZ,IAAI,OAAO,CAAC;IAClB,OAAO,MAAM,KAAM,MAAM,KAAK,MAAM;GACtC;GACA,KAAK;GACL,KAAK,mBACH,OAAO,OAAO,CAAC,MAAM,OAAO,CAAC;GAC/B,KAAK,kBACH,OACG,EAAY,SAAU,EAAY,QAClC,EAAY,YAAa,EAAY;GAE1C,KAAK,gBACH,OAAO,EACL,CAAC,GAAI,CAA2B,GAChC,CAAC,GAAI,CAA2B,GAChC,CACF;GACF,KAAK,gBACH,OAAO,EACL,CAAC,GAAI,CAAkB,GACvB,CAAC,GAAI,CAAkB,GACvB,CACF;GACF,SAQE,OAPI,YAAY,OAAO,CAAC,KAAK,YAAY,OAAO,CAAC,IACxC,EACL,GACA,GACA,CACF,IAEK;EACX;CACF,UAAU;EACR,EAAM,IAAI;CACZ;AACF;AAEA,SAAgB,EAAQ,GAAY,GAAqB;CACvD,OAAO,EAAM,GAAG,GAAG,CAAC,CAAC;AACvB"}