@cyclone-ui/state 0.0.12 → 0.0.13

package/dist/form/molecules/field-molecule.mjs

@@ -1,2 +1,154 @@
-import{createMoleculeApi as e,use as t}from"../../base/utilities/create-molecule.mjs";import"../../base/index.mjs";import{atomWithFieldItems as n}from"../atoms/atom-with-field.mjs";import{atomWithFieldsMessageList as r,atomWithFieldsMessageTypes as i,atomWithMessages as ee,atomWithTheme as te}from"../atoms/atom-with-messages.mjs";import{requiredValidator as a}from"../utilities/validators.mjs";import{FormApi as o}from"./form-molecule.mjs";import{isFunction as ne}from"@stryke/type-checks/is-function";import{RESET as re,atomWithDefault as ie,splitAtom as s}from"jotai/utils";import{isEqual as c}from"@stryke/helpers/is-equal";import{atom as l}from"jotai";import{isString as ae}from"@stryke/type-checks/is-string";import{deepMerge as u}from"@stryke/helpers/deep-merge";import{getField as d}from"@stryke/helpers/get-field";import{toPath as f}from"@stryke/helpers/to-path";import{isSet as p}from"@stryke/type-checks/is-set";import{focusAtom as m}from"jotai-optics";const h={theme:`base`,size:`md`,debounceMs:100,isEqual:c,required:!1,disabled:!1,clearable:!1,initialValue:null},g=e(e=>{let c=t(o.Scope),g=l(()=>c),_=t(o.Molecule),v=l(h),y=l(e=>{let t=e(_.options),n=e(v),r=u(t.defaultFieldOptions,n);return u({validate:{onBlur:r.required?[a]:[]}},r)},(e,t,n)=>{let r={};r=ne(n)?n(e(v)):n===re?{}:n,t(v,u(h,r))}),b=`${c}-`,x=f(e.startsWith(b)?e.slice(b.length):e.includes(`-`)?e.slice(e.indexOf(`-`)+1):e),S=l(()=>x),C=l(e=>e(S).slice(-1)[0]),w=m(_.focusedFields,e=>e.path(...x)),T=m(_.requiredFields,e=>e.path(...x)),E=m(_.disabledFields,e=>e.path(...x)),oe=l(e=>e(T)??e(y).required,(e,t,n)=>{t(T,n)}),D=l(e=>e(E)??e(y).disabled,(e,t,n)=>{t(E,n)}),O=l(e=>e(y).clearable),k=m(_.touchedFields,e=>e.path(...x)),A=m(_.blurredFields,e=>e.path(...x)),j=m(_.validatingFields,e=>e.path(...x)),M=m(_.validationResultsFields,e=>e.path(...x)),N=m(_.tabIndexes,e=>e.path(...x)),P=m(_.refs,e=>e.path(...x)),F=m(_.initialValues,e=>e.path(...x)),I=m(_.values,e=>e.path(...x)),L=l(e=>e(y).isEqual(e(I),e(F))),R=i(M,`danger`),z=i(M,`warning`),B=i(M,`info`),V=i(M,`discovery`),H=i(M,`success`),U=i(M,`positive`),W=i(M,`negative`),G=r(M,`danger`),K=r(M,`warning`),q=r(M,`info`),J=r(M,`discovery`),Y=r(M,`success`),X=r(M,`positive`),Z=r(M,`negative`),Q=l(e=>e(G).length>0),se=l(e=>!e(Q)),ce=l(e=>{let t=e(y),n=e(I),r;return r=t?.format?t.format(n):n,p(r)?ae(r)?r:String(r):``}),$=n(y,I,D),le=s($),ue=ie(e=>e(y).size??`md`);return{options:y,form:g,name:C,path:S,initialValue:F,previousValue:l(e=>{let t=e(_.previousValues);return d(t,e(S).join(`.`))??null}),value:I,formattedValue:ce,focused:w,required:oe,disabled:D,clearable:O,touched:k,blurred:A,validating:j,validationResults:M,tabIndex:N,ref:P,pristine:l(e=>!e(L)),dirty:L,items:$,itemsAtoms:le,size:ue,errors:R,warnings:z,info:B,discovery:V,success:H,positive:U,negative:W,dangerMessages:G,warningMessages:K,infoMessages:q,discoveryMessages:J,successMessages:Y,positiveMessages:X,negativeMessages:Z,theme:te(y,G,K,q,J,Y,X,Z),messages:ee(G,K,q,J,Y,X,Z),invalid:Q,valid:se}},{type:`field`});export{h as DEFAULT_FIELD_OPTIONS,g as FieldApi};
+import { createMoleculeApi, use } from "../../base/utilities/create-molecule.mjs";
+import "../../base/index.mjs";
+import { atomWithFieldItems } from "../atoms/atom-with-field.mjs";
+import { atomWithFieldsMessageList, atomWithFieldsMessageTypes, atomWithMessages, atomWithTheme } from "../atoms/atom-with-messages.mjs";
+import { requiredValidator } from "../utilities/validators.mjs";
+import { FormApi } from "./form-molecule.mjs";
+import { isFunction } from "@stryke/type-checks/is-function";
+import { RESET, atomWithDefault, splitAtom } from "jotai/utils";
+import { isEqual } from "@stryke/helpers/is-equal";
+import { atom } from "jotai";
+import { isString } from "@stryke/type-checks/is-string";
+import { deepMerge } from "@stryke/helpers/deep-merge";
+import { getField } from "@stryke/helpers/get-field";
+import { toPath } from "@stryke/helpers/to-path";
+import { isSet } from "@stryke/type-checks/is-set";
+import { focusAtom } from "jotai-optics";
+
+//#region src/form/molecules/field-molecule.ts
+const DEFAULT_FIELD_OPTIONS = {
+	theme: "base",
+	size: "md",
+	debounceMs: 100,
+	isEqual,
+	required: false,
+	disabled: false,
+	clearable: false,
+	initialValue: null
+};
+const FieldApi = createMoleculeApi((scope) => {
+	const formScope = use(FormApi.Scope);
+	const formScopeAtom = atom(() => formScope);
+	const form = use(FormApi.Molecule);
+	const optionsBaseAtom = atom(DEFAULT_FIELD_OPTIONS);
+	const optionsAtom = atom((get) => {
+		const formOptions = get(form.options);
+		const options = get(optionsBaseAtom);
+		const result = deepMerge(formOptions.defaultFieldOptions, options);
+		return deepMerge({ validate: { onBlur: result.required ? [requiredValidator] : [] } }, result);
+	}, (get, set, update) => {
+		let nextValue = {};
+		if (isFunction(update)) nextValue = update(get(optionsBaseAtom));
+		else if (update === RESET) nextValue = {};
+		else nextValue = update;
+		set(optionsBaseAtom, deepMerge(DEFAULT_FIELD_OPTIONS, nextValue));
+	});
+	const formPrefix = `${formScope}-`;
+	const path = toPath(scope.startsWith(formPrefix) ? scope.slice(formPrefix.length) : scope.includes("-") ? scope.slice(scope.indexOf("-") + 1) : scope);
+	const pathAtom = atom(() => path);
+	const nameAtom = atom((get) => get(pathAtom).slice(-1)[0]);
+	const focusedAtom = focusAtom(form.focusedFields, (optic) => optic.path(...path));
+	const requiredStateAtom = focusAtom(form.requiredFields, (optic) => optic.path(...path));
+	const disabledStateAtom = focusAtom(form.disabledFields, (optic) => optic.path(...path));
+	const requiredAtom = atom((get) => get(requiredStateAtom) ?? get(optionsAtom).required, (_get, set, update) => {
+		set(requiredStateAtom, update);
+	});
+	const disabledAtom = atom((get) => get(disabledStateAtom) ?? get(optionsAtom).disabled, (_get, set, update) => {
+		set(disabledStateAtom, update);
+	});
+	const clearableAtom = atom((get) => get(optionsAtom).clearable);
+	const touchedAtom = focusAtom(form.touchedFields, (optic) => optic.path(...path));
+	const blurredAtom = focusAtom(form.blurredFields, (optic) => optic.path(...path));
+	const validatingAtom = focusAtom(form.validatingFields, (optic) => optic.path(...path));
+	const validationResultsAtom = focusAtom(form.validationResultsFields, (optic) => optic.path(...path));
+	const tabIndexAtom = focusAtom(form.tabIndexes, (optic) => optic.path(...path));
+	const refAtom = focusAtom(form.refs, (optic) => optic.path(...path));
+	const initialValueAtom = focusAtom(form.initialValues, (optic) => optic.path(...path));
+	const valueAtom = focusAtom(form.values, (optic) => optic.path(...path));
+	const dirtyAtom = atom((get) => {
+		return get(optionsAtom).isEqual(get(valueAtom), get(initialValueAtom));
+	});
+	const errorsAtom = atomWithFieldsMessageTypes(validationResultsAtom, "danger");
+	const warningsAtom = atomWithFieldsMessageTypes(validationResultsAtom, "warning");
+	const infoAtom = atomWithFieldsMessageTypes(validationResultsAtom, "info");
+	const discoveryAtom = atomWithFieldsMessageTypes(validationResultsAtom, "discovery");
+	const successesAtom = atomWithFieldsMessageTypes(validationResultsAtom, "success");
+	const positivesAtom = atomWithFieldsMessageTypes(validationResultsAtom, "positive");
+	const negativesAtom = atomWithFieldsMessageTypes(validationResultsAtom, "negative");
+	const errorMessagesAtom = atomWithFieldsMessageList(validationResultsAtom, "danger");
+	const warningMessagesAtom = atomWithFieldsMessageList(validationResultsAtom, "warning");
+	const infoMessagesAtom = atomWithFieldsMessageList(validationResultsAtom, "info");
+	const discoveryMessagesAtom = atomWithFieldsMessageList(validationResultsAtom, "discovery");
+	const successMessagesAtom = atomWithFieldsMessageList(validationResultsAtom, "success");
+	const positiveMessagesAtom = atomWithFieldsMessageList(validationResultsAtom, "positive");
+	const negativeMessagesAtom = atomWithFieldsMessageList(validationResultsAtom, "negative");
+	const invalidAtom = atom((get) => {
+		return get(errorMessagesAtom).length > 0;
+	});
+	const validAtom = atom((get) => !get(invalidAtom));
+	const formattedValueAtom = atom((get) => {
+		const options = get(optionsAtom);
+		const value = get(valueAtom);
+		let formattedValue;
+		if (options?.format) formattedValue = options.format(value);
+		else formattedValue = value;
+		if (!isSet(formattedValue)) return "";
+		else if (isString(formattedValue)) return formattedValue;
+		return String(formattedValue);
+	});
+	const itemsAtom = atomWithFieldItems(optionsAtom, valueAtom, disabledAtom);
+	const itemsAtomsAtom = splitAtom(itemsAtom);
+	const sizeAtom = atomWithDefault((get) => {
+		return get(optionsAtom).size ?? "md";
+	});
+	return {
+		options: optionsAtom,
+		form: formScopeAtom,
+		name: nameAtom,
+		path: pathAtom,
+		initialValue: initialValueAtom,
+		previousValue: atom((get) => {
+			const previousValues = get(form.previousValues);
+			return getField(previousValues, get(pathAtom).join(".")) ?? null;
+		}),
+		value: valueAtom,
+		formattedValue: formattedValueAtom,
+		focused: focusedAtom,
+		required: requiredAtom,
+		disabled: disabledAtom,
+		clearable: clearableAtom,
+		touched: touchedAtom,
+		blurred: blurredAtom,
+		validating: validatingAtom,
+		validationResults: validationResultsAtom,
+		tabIndex: tabIndexAtom,
+		ref: refAtom,
+		pristine: atom((get) => !get(dirtyAtom)),
+		dirty: dirtyAtom,
+		items: itemsAtom,
+		itemsAtoms: itemsAtomsAtom,
+		size: sizeAtom,
+		errors: errorsAtom,
+		warnings: warningsAtom,
+		info: infoAtom,
+		discovery: discoveryAtom,
+		success: successesAtom,
+		positive: positivesAtom,
+		negative: negativesAtom,
+		dangerMessages: errorMessagesAtom,
+		warningMessages: warningMessagesAtom,
+		infoMessages: infoMessagesAtom,
+		discoveryMessages: discoveryMessagesAtom,
+		successMessages: successMessagesAtom,
+		positiveMessages: positiveMessagesAtom,
+		negativeMessages: negativeMessagesAtom,
+		theme: atomWithTheme(optionsAtom, errorMessagesAtom, warningMessagesAtom, infoMessagesAtom, discoveryMessagesAtom, successMessagesAtom, positiveMessagesAtom, negativeMessagesAtom),
+		messages: atomWithMessages(errorMessagesAtom, warningMessagesAtom, infoMessagesAtom, discoveryMessagesAtom, successMessagesAtom, positiveMessagesAtom, negativeMessagesAtom),
+		invalid: invalidAtom,
+		valid: validAtom
+	};
+}, { type: "field" });
+
+//#endregion
+export { DEFAULT_FIELD_OPTIONS, FieldApi };
 //# sourceMappingURL=field-molecule.mjs.map

package/dist/form/molecules/field-molecule.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"field-molecule.mjs","names":["DEFAULT_FIELD_OPTIONS","FieldApi","createMoleculeApi","formScope","use","FormApi","formScopeAtom","atom","form","optionsBaseAtom","optionsAtom","formOptions","get","options","result","deepMerge","requiredValidator","nextValue","isFunction","update","RESET","set","formPrefix","path","toPath","scope","pathAtom","nameAtom","focusedAtom","focusAtom","optic","requiredStateAtom","disabledStateAtom","requiredAtom","disabledAtom","clearableAtom","touchedAtom","blurredAtom","validatingAtom","validationResultsAtom","tabIndexAtom","refAtom","initialValueAtom","valueAtom","dirtyAtom","errorsAtom","atomWithFieldsMessageTypes","warningsAtom","infoAtom","discoveryAtom","successesAtom","positivesAtom","negativesAtom","errorMessagesAtom","atomWithFieldsMessageList","warningMessagesAtom","infoMessagesAtom","discoveryMessagesAtom","successMessagesAtom","positiveMessagesAtom","negativeMessagesAtom","invalidAtom","validAtom","formattedValueAtom","value","formattedValue","isSet","isString","itemsAtom","atomWithFieldItems","itemsAtomsAtom","splitAtom","sizeAtom","atomWithDefault","previousValues","getField","atomWithTheme","atomWithMessages"],"sources":[],"mappings":""}
+{"version":3,"file":"field-molecule.mjs","names":[],"sources":[],"mappings":""}

package/dist/form/molecules/form-molecule.cjs

@@ -1 +1,180 @@
-const e=require("../../base/utilities/create-molecule.cjs"),t=require("../atoms/atom-with-messages.cjs");let n=require("@stryke/type-checks/is-function"),r=require("jotai/utils"),i=require("@stryke/helpers/is-equal"),a=require("jotai"),o=require("@stryke/type-checks/is-string"),s=require("@stryke/helpers/deep-merge"),c=require("@stryke/helpers/flatten-object"),l=require("@stryke/helpers/set-field"),u=require("@stryke/type-checks/is-number");const d={theme:`base`,debounceMs:100,isEqual:i.isEqual,disabled:!1,initialValues:{},defaultFieldOptions:{}},f=e.createMoleculeApi(e=>{let i=(0,r.atomWithReset)(d),f=(0,a.atom)(e=>e(i),(e,t,a)=>{let o={};o=(0,n.isFunction)(a)?a(e(i)):a===r.RESET?{}:a,t(i,(0,s.deepMerge)(d,o))}),p=(0,a.atom)(e),m=(0,r.atomWithDefault)(e=>!!e(f).disabled),h=(0,r.atomWithReset)(!1),g=(0,r.atomWithReset)({}),_=(0,a.atom)(e=>e(g),(e,t,n)=>{}),v=(0,r.atomWithDefault)(e=>e(f).initialValues),y=(0,r.atomWithDefault)(e=>e(f).initialValues),b=(0,a.atom)(e=>e(y),(e,t,r)=>{let i={};r&&(i=(0,n.isFunction)(r)?r(e(y)):r),t(g,e(y)),t(y,i)}),x=(0,r.atomWithReset)({initialize:[],change:[],blur:[],submit:[],server:[]}),S=(0,r.atomWithReset)(!1),C=(0,r.atomWithReset)(!1),w=(0,r.atomWithReset)(0),T=(0,r.atomWithReset)({}),E=(0,r.atomWithReset)({}),D=(0,r.atomWithReset)({}),O=(0,r.atomWithReset)({}),k=(0,r.atomWithReset)({}),A=(0,r.atomWithReset)({}),j=(0,r.atomWithReset)({}),M=(0,r.atomWithReset)({}),N=(0,r.atomWithReset)({}),P=(0,a.atom)(e=>e(N),(e,t,i)=>{let a={};if((0,n.isFunction)(i))a=i(e(N));else if(i===r.RESET)a={};else{let t=e(N);if(`field`in i&&i.field&&(0,o.isString)(i.field)){let e=i.tabIndex;if(!(0,u.isNumber)(e)||e>-1){let n=(0,c.flattenObject)(t),r=-1;for(let e in n)(0,u.isNumber)(n[e])&&n[e]>r&&(r=n[e]);e=r+1}a=(0,l.setField)(t,i.field,e)}else a=i}t(N,a)}),F=(0,a.atom)(e=>e(f).isEqual(e(b),e(v))),ee=(0,a.atom)(e=>!e(F)),te=(0,a.atom)(e=>{let t=(0,c.flattenObject)(e(k));return Object.keys(t).some(e=>t[e])}),I=(0,a.atom)(e=>{let t=(0,c.flattenObject)(e(O));return Object.keys(t).some(e=>t[e])}),L=(0,a.atom)(e=>{if(e(h))return!0;let t=(0,c.flattenObject)(e(A));return Object.keys(t).some(e=>t[e])}),R=t.atomWithMessageTypes(x,`danger`),z=t.atomWithMessageTypes(x,`warning`),B=t.atomWithMessageTypes(x,`info`),V=t.atomWithMessageTypes(x,`discovery`),H=t.atomWithMessageTypes(x,`success`),U=t.atomWithMessageTypes(x,`positive`),W=t.atomWithMessageTypes(x,`negative`),G=(0,a.atom)(e=>e(R).length>0),K=t.atomWithFieldsMessageTypes(j,`danger`),q=t.atomWithFieldsMessageTypes(j,`warning`),J=t.atomWithFieldsMessageTypes(j,`info`),Y=t.atomWithFieldsMessageTypes(j,`discovery`),X=t.atomWithFieldsMessageTypes(j,`success`),Z=t.atomWithFieldsMessageList(j,`danger`),ne=t.atomWithFieldsMessageList(j,`warning`),re=t.atomWithFieldsMessageList(j,`info`),ie=t.atomWithFieldsMessageList(j,`discovery`),ae=t.atomWithFieldsMessageList(j,`success`),Q=(0,a.atom)(e=>e(Z).length>0||e(G)),$=(0,a.atom)(e=>!e(Q)),oe=(0,a.atom)(e=>e($)&&!e(L)&&!e(S)&&!e(m));return{options:f,name:p,disabled:m,formValidating:h,validationResults:x,submitting:S,submitted:C,submitAttempts:w,focusedFields:T,requiredFields:E,disabledFields:D,touchedFields:O,blurredFields:k,validatingFields:A,validationResultsFields:j,tabIndexes:P,refs:M,dirty:F,pristine:ee,blurred:te,touched:I,validating:L,previousValues:_,initialValues:v,values:b,dangerMessages:R,warningMessages:z,infoMessages:B,discoveryMessages:V,successMessages:H,positiveMessages:U,negativeMessages:W,messages:t.atomWithMessages(R,z,B,V,H,U,W),dangerFields:K,warningFields:q,infoFields:J,discoveryFields:Y,successFields:X,fieldDangerMessages:Z,fieldWarningMessages:ne,fieldInfoMessages:re,fieldHelpMessages:ie,fieldsSuccessMessages:ae,valid:$,invalid:Q,theme:t.atomWithTheme(f,R,z,B,V,H,U,W),canSubmit:oe}},{type:`form`});exports.DEFAULT_FORM_OPTIONS=d,exports.FormApi=f;
+const require_create_molecule = require("../../base/utilities/create-molecule.cjs");
+const require_atom_with_messages = require("../atoms/atom-with-messages.cjs");
+let _stryke_type_checks_is_function = require("@stryke/type-checks/is-function");
+let jotai_utils = require("jotai/utils");
+let _stryke_helpers_is_equal = require("@stryke/helpers/is-equal");
+let jotai = require("jotai");
+let _stryke_type_checks_is_string = require("@stryke/type-checks/is-string");
+let _stryke_helpers_deep_merge = require("@stryke/helpers/deep-merge");
+let _stryke_helpers_flatten_object = require("@stryke/helpers/flatten-object");
+let _stryke_helpers_set_field = require("@stryke/helpers/set-field");
+let _stryke_type_checks_is_number = require("@stryke/type-checks/is-number");
+
+//#region src/form/molecules/form-molecule.ts
+const DEFAULT_FORM_OPTIONS = {
+	theme: "base",
+	debounceMs: 100,
+	isEqual: _stryke_helpers_is_equal.isEqual,
+	disabled: false,
+	initialValues: {},
+	defaultFieldOptions: {}
+};
+const FormApi = require_create_molecule.createMoleculeApi((scope) => {
+	const optionsBaseAtom = (0, jotai_utils.atomWithReset)(DEFAULT_FORM_OPTIONS);
+	const optionsAtom = (0, jotai.atom)((get) => get(optionsBaseAtom), (get, set, update) => {
+		let nextValue = {};
+		if ((0, _stryke_type_checks_is_function.isFunction)(update)) nextValue = update(get(optionsBaseAtom));
+		else if (update === jotai_utils.RESET) nextValue = {};
+		else nextValue = update;
+		set(optionsBaseAtom, (0, _stryke_helpers_deep_merge.deepMerge)(DEFAULT_FORM_OPTIONS, nextValue));
+	});
+	const nameAtom = (0, jotai.atom)(scope);
+	const disabledAtom = (0, jotai_utils.atomWithDefault)((get) => Boolean(get(optionsAtom).disabled));
+	const formValidatingAtom = (0, jotai_utils.atomWithReset)(false);
+	const previousValuesBaseAtom = (0, jotai_utils.atomWithReset)({});
+	const previousValuesAtom = (0, jotai.atom)((get) => get(previousValuesBaseAtom), (_get, _set, _update) => {});
+	const initialValuesAtom = (0, jotai_utils.atomWithDefault)((get) => get(optionsAtom).initialValues);
+	const valuesBaseAtom = (0, jotai_utils.atomWithDefault)((get) => get(optionsAtom).initialValues);
+	const valuesAtom = (0, jotai.atom)((get) => get(valuesBaseAtom), (get, set, update) => {
+		let nextValue = {};
+		if (update) {
+			if ((0, _stryke_type_checks_is_function.isFunction)(update)) nextValue = update(get(valuesBaseAtom));
+			else nextValue = update;
+		}
+		set(previousValuesBaseAtom, get(valuesBaseAtom));
+		set(valuesBaseAtom, nextValue);
+	});
+	const validationResultsAtom = (0, jotai_utils.atomWithReset)({
+		initialize: [],
+		change: [],
+		blur: [],
+		submit: [],
+		server: []
+	});
+	const submittingAtom = (0, jotai_utils.atomWithReset)(false);
+	const submittedAtom = (0, jotai_utils.atomWithReset)(false);
+	const submitAttemptsAtom = (0, jotai_utils.atomWithReset)(0);
+	const focusedFieldsAtom = (0, jotai_utils.atomWithReset)({});
+	const requiredFieldsAtom = (0, jotai_utils.atomWithReset)({});
+	const disabledFieldsAtom = (0, jotai_utils.atomWithReset)({});
+	const touchedFieldsAtom = (0, jotai_utils.atomWithReset)({});
+	const blurredFieldsAtom = (0, jotai_utils.atomWithReset)({});
+	const validatingFieldsAtom = (0, jotai_utils.atomWithReset)({});
+	const validationResultsFieldsAtom = (0, jotai_utils.atomWithReset)({});
+	const refsAtom = (0, jotai_utils.atomWithReset)({});
+	const tabIndexesBaseAtom = (0, jotai_utils.atomWithReset)({});
+	const tabIndexesAtom = (0, jotai.atom)((get) => get(tabIndexesBaseAtom), (get, set, update) => {
+		let nextValue = {};
+		if ((0, _stryke_type_checks_is_function.isFunction)(update)) nextValue = update(get(tabIndexesBaseAtom));
+		else if (update === jotai_utils.RESET) nextValue = {};
+		else {
+			const tabIndexes = get(tabIndexesBaseAtom);
+			if ("field" in update && update.field && (0, _stryke_type_checks_is_string.isString)(update.field)) {
+				let tabIndex = update.tabIndex;
+				if (!(0, _stryke_type_checks_is_number.isNumber)(tabIndex) || tabIndex > -1) {
+					const flat = (0, _stryke_helpers_flatten_object.flattenObject)(tabIndexes);
+					let lastIndex = -1;
+					for (const key in flat) if ((0, _stryke_type_checks_is_number.isNumber)(flat[key]) && flat[key] > lastIndex) lastIndex = flat[key];
+					tabIndex = lastIndex + 1;
+				}
+				nextValue = (0, _stryke_helpers_set_field.setField)(tabIndexes, update.field, tabIndex);
+			} else nextValue = update;
+		}
+		set(tabIndexesBaseAtom, nextValue);
+	});
+	const dirtyAtom = (0, jotai.atom)((get) => {
+		return get(optionsAtom).isEqual(get(valuesAtom), get(initialValuesAtom));
+	});
+	const pristineAtom = (0, jotai.atom)((get) => !get(dirtyAtom));
+	const blurredAtom = (0, jotai.atom)((get) => {
+		const blurredFields = (0, _stryke_helpers_flatten_object.flattenObject)(get(blurredFieldsAtom));
+		return Object.keys(blurredFields).some((key) => blurredFields[key]);
+	});
+	const touchedAtom = (0, jotai.atom)((get) => {
+		const touchedFields = (0, _stryke_helpers_flatten_object.flattenObject)(get(touchedFieldsAtom));
+		return Object.keys(touchedFields).some((key) => touchedFields[key]);
+	});
+	const validatingAtom = (0, jotai.atom)((get) => {
+		if (get(formValidatingAtom)) return true;
+		const validatingFields = (0, _stryke_helpers_flatten_object.flattenObject)(get(validatingFieldsAtom));
+		return Object.keys(validatingFields).some((key) => validatingFields[key]);
+	});
+	const formErrorsAtom = require_atom_with_messages.atomWithMessageTypes(validationResultsAtom, "danger");
+	const formWarningsAtom = require_atom_with_messages.atomWithMessageTypes(validationResultsAtom, "warning");
+	const formInfoAtom = require_atom_with_messages.atomWithMessageTypes(validationResultsAtom, "info");
+	const formHelpAtom = require_atom_with_messages.atomWithMessageTypes(validationResultsAtom, "discovery");
+	const formSuccessesAtom = require_atom_with_messages.atomWithMessageTypes(validationResultsAtom, "success");
+	const formPositivesAtom = require_atom_with_messages.atomWithMessageTypes(validationResultsAtom, "positive");
+	const formNegativesAtom = require_atom_with_messages.atomWithMessageTypes(validationResultsAtom, "negative");
+	const isFormInvalidAtom = (0, jotai.atom)((get) => {
+		return get(formErrorsAtom).length > 0;
+	});
+	const errorFieldsAtom = require_atom_with_messages.atomWithFieldsMessageTypes(validationResultsFieldsAtom, "danger");
+	const warningFieldsAtom = require_atom_with_messages.atomWithFieldsMessageTypes(validationResultsFieldsAtom, "warning");
+	const infoFieldsAtom = require_atom_with_messages.atomWithFieldsMessageTypes(validationResultsFieldsAtom, "info");
+	const helpFieldsAtom = require_atom_with_messages.atomWithFieldsMessageTypes(validationResultsFieldsAtom, "discovery");
+	const successFieldsAtom = require_atom_with_messages.atomWithFieldsMessageTypes(validationResultsFieldsAtom, "success");
+	const fieldErrorMessagesAtom = require_atom_with_messages.atomWithFieldsMessageList(validationResultsFieldsAtom, "danger");
+	const fieldWarningMessagesAtom = require_atom_with_messages.atomWithFieldsMessageList(validationResultsFieldsAtom, "warning");
+	const fieldInfoMessagesAtom = require_atom_with_messages.atomWithFieldsMessageList(validationResultsFieldsAtom, "info");
+	const fieldHelpMessagesAtom = require_atom_with_messages.atomWithFieldsMessageList(validationResultsFieldsAtom, "discovery");
+	const fieldsSuccessMessagesAtom = require_atom_with_messages.atomWithFieldsMessageList(validationResultsFieldsAtom, "success");
+	const invalidAtom = (0, jotai.atom)((get) => {
+		return get(fieldErrorMessagesAtom).length > 0 || get(isFormInvalidAtom);
+	});
+	const validAtom = (0, jotai.atom)((get) => !get(invalidAtom));
+	const canSubmitAtom = (0, jotai.atom)((get) => get(validAtom) && !get(validatingAtom) && !get(submittingAtom) && !get(disabledAtom));
+	return {
+		options: optionsAtom,
+		name: nameAtom,
+		disabled: disabledAtom,
+		formValidating: formValidatingAtom,
+		validationResults: validationResultsAtom,
+		submitting: submittingAtom,
+		submitted: submittedAtom,
+		submitAttempts: submitAttemptsAtom,
+		focusedFields: focusedFieldsAtom,
+		requiredFields: requiredFieldsAtom,
+		disabledFields: disabledFieldsAtom,
+		touchedFields: touchedFieldsAtom,
+		blurredFields: blurredFieldsAtom,
+		validatingFields: validatingFieldsAtom,
+		validationResultsFields: validationResultsFieldsAtom,
+		tabIndexes: tabIndexesAtom,
+		refs: refsAtom,
+		dirty: dirtyAtom,
+		pristine: pristineAtom,
+		blurred: blurredAtom,
+		touched: touchedAtom,
+		validating: validatingAtom,
+		previousValues: previousValuesAtom,
+		initialValues: initialValuesAtom,
+		values: valuesAtom,
+		dangerMessages: formErrorsAtom,
+		warningMessages: formWarningsAtom,
+		infoMessages: formInfoAtom,
+		discoveryMessages: formHelpAtom,
+		successMessages: formSuccessesAtom,
+		positiveMessages: formPositivesAtom,
+		negativeMessages: formNegativesAtom,
+		messages: require_atom_with_messages.atomWithMessages(formErrorsAtom, formWarningsAtom, formInfoAtom, formHelpAtom, formSuccessesAtom, formPositivesAtom, formNegativesAtom),
+		dangerFields: errorFieldsAtom,
+		warningFields: warningFieldsAtom,
+		infoFields: infoFieldsAtom,
+		discoveryFields: helpFieldsAtom,
+		successFields: successFieldsAtom,
+		fieldDangerMessages: fieldErrorMessagesAtom,
+		fieldWarningMessages: fieldWarningMessagesAtom,
+		fieldInfoMessages: fieldInfoMessagesAtom,
+		fieldHelpMessages: fieldHelpMessagesAtom,
+		fieldsSuccessMessages: fieldsSuccessMessagesAtom,
+		valid: validAtom,
+		invalid: invalidAtom,
+		theme: require_atom_with_messages.atomWithTheme(optionsAtom, formErrorsAtom, formWarningsAtom, formInfoAtom, formHelpAtom, formSuccessesAtom, formPositivesAtom, formNegativesAtom),
+		canSubmit: canSubmitAtom
+	};
+}, { type: "form" });
+
+//#endregion
+exports.DEFAULT_FORM_OPTIONS = DEFAULT_FORM_OPTIONS;
+exports.FormApi = FormApi;

package/dist/form/molecules/form-molecule.mjs

@@ -1,2 +1,180 @@
-import{createMoleculeApi as e}from"../../base/utilities/create-molecule.mjs";import{atomWithFieldsMessageList as t,atomWithFieldsMessageTypes as n,atomWithMessageTypes as r,atomWithMessages as i,atomWithTheme as a}from"../atoms/atom-with-messages.mjs";import{isFunction as o}from"@stryke/type-checks/is-function";import{RESET as s,atomWithDefault as c,atomWithReset as l}from"jotai/utils";import{isEqual as u}from"@stryke/helpers/is-equal";import{atom as d}from"jotai";import{isString as f}from"@stryke/type-checks/is-string";import{deepMerge as p}from"@stryke/helpers/deep-merge";import{flattenObject as m}from"@stryke/helpers/flatten-object";import{setField as ee}from"@stryke/helpers/set-field";import{isNumber as h}from"@stryke/type-checks/is-number";const g={theme:`base`,debounceMs:100,isEqual:u,disabled:!1,initialValues:{},defaultFieldOptions:{}},_=e(e=>{let u=l(g),_=d(e=>e(u),(e,t,n)=>{let r={};r=o(n)?n(e(u)):n===s?{}:n,t(u,p(g,r))}),v=d(e),y=c(e=>!!e(_).disabled),b=l(!1),x=l({}),S=d(e=>e(x),(e,t,n)=>{}),C=c(e=>e(_).initialValues),w=c(e=>e(_).initialValues),T=d(e=>e(w),(e,t,n)=>{let r={};n&&(r=o(n)?n(e(w)):n),t(x,e(w)),t(w,r)}),E=l({initialize:[],change:[],blur:[],submit:[],server:[]}),D=l(!1),O=l(!1),k=l(0),te=l({}),A=l({}),j=l({}),M=l({}),N=l({}),P=l({}),F=l({}),ne=l({}),I=l({}),L=d(e=>e(I),(e,t,n)=>{let r={};if(o(n))r=n(e(I));else if(n===s)r={};else{let t=e(I);if(`field`in n&&n.field&&f(n.field)){let e=n.tabIndex;if(!h(e)||e>-1){let n=m(t),r=-1;for(let e in n)h(n[e])&&n[e]>r&&(r=n[e]);e=r+1}r=ee(t,n.field,e)}else r=n}t(I,r)}),R=d(e=>e(_).isEqual(e(T),e(C))),z=d(e=>!e(R)),B=d(e=>{let t=m(e(N));return Object.keys(t).some(e=>t[e])}),V=d(e=>{let t=m(e(M));return Object.keys(t).some(e=>t[e])}),H=d(e=>{if(e(b))return!0;let t=m(e(P));return Object.keys(t).some(e=>t[e])}),U=r(E,`danger`),W=r(E,`warning`),G=r(E,`info`),K=r(E,`discovery`),q=r(E,`success`),J=r(E,`positive`),Y=r(E,`negative`),X=d(e=>e(U).length>0),re=n(F,`danger`),ie=n(F,`warning`),ae=n(F,`info`),oe=n(F,`discovery`),se=n(F,`success`),Z=t(F,`danger`),ce=t(F,`warning`),le=t(F,`info`),ue=t(F,`discovery`),de=t(F,`success`),Q=d(e=>e(Z).length>0||e(X)),$=d(e=>!e(Q)),fe=d(e=>e($)&&!e(H)&&!e(D)&&!e(y));return{options:_,name:v,disabled:y,formValidating:b,validationResults:E,submitting:D,submitted:O,submitAttempts:k,focusedFields:te,requiredFields:A,disabledFields:j,touchedFields:M,blurredFields:N,validatingFields:P,validationResultsFields:F,tabIndexes:L,refs:ne,dirty:R,pristine:z,blurred:B,touched:V,validating:H,previousValues:S,initialValues:C,values:T,dangerMessages:U,warningMessages:W,infoMessages:G,discoveryMessages:K,successMessages:q,positiveMessages:J,negativeMessages:Y,messages:i(U,W,G,K,q,J,Y),dangerFields:re,warningFields:ie,infoFields:ae,discoveryFields:oe,successFields:se,fieldDangerMessages:Z,fieldWarningMessages:ce,fieldInfoMessages:le,fieldHelpMessages:ue,fieldsSuccessMessages:de,valid:$,invalid:Q,theme:a(_,U,W,G,K,q,J,Y),canSubmit:fe}},{type:`form`});export{g as DEFAULT_FORM_OPTIONS,_ as FormApi};
+import { createMoleculeApi } from "../../base/utilities/create-molecule.mjs";
+import { atomWithFieldsMessageList, atomWithFieldsMessageTypes, atomWithMessageTypes, atomWithMessages, atomWithTheme } from "../atoms/atom-with-messages.mjs";
+import { isFunction } from "@stryke/type-checks/is-function";
+import { RESET, atomWithDefault, atomWithReset } from "jotai/utils";
+import { isEqual } from "@stryke/helpers/is-equal";
+import { atom } from "jotai";
+import { isString } from "@stryke/type-checks/is-string";
+import { deepMerge } from "@stryke/helpers/deep-merge";
+import { flattenObject } from "@stryke/helpers/flatten-object";
+import { setField } from "@stryke/helpers/set-field";
+import { isNumber } from "@stryke/type-checks/is-number";
+
+//#region src/form/molecules/form-molecule.ts
+const DEFAULT_FORM_OPTIONS = {
+	theme: "base",
+	debounceMs: 100,
+	isEqual,
+	disabled: false,
+	initialValues: {},
+	defaultFieldOptions: {}
+};
+const FormApi = createMoleculeApi((scope) => {
+	const optionsBaseAtom = atomWithReset(DEFAULT_FORM_OPTIONS);
+	const optionsAtom = atom((get) => get(optionsBaseAtom), (get, set, update) => {
+		let nextValue = {};
+		if (isFunction(update)) nextValue = update(get(optionsBaseAtom));
+		else if (update === RESET) nextValue = {};
+		else nextValue = update;
+		set(optionsBaseAtom, deepMerge(DEFAULT_FORM_OPTIONS, nextValue));
+	});
+	const nameAtom = atom(scope);
+	const disabledAtom = atomWithDefault((get) => Boolean(get(optionsAtom).disabled));
+	const formValidatingAtom = atomWithReset(false);
+	const previousValuesBaseAtom = atomWithReset({});
+	const previousValuesAtom = atom((get) => get(previousValuesBaseAtom), (_get, _set, _update) => {});
+	const initialValuesAtom = atomWithDefault((get) => get(optionsAtom).initialValues);
+	const valuesBaseAtom = atomWithDefault((get) => get(optionsAtom).initialValues);
+	const valuesAtom = atom((get) => get(valuesBaseAtom), (get, set, update) => {
+		let nextValue = {};
+		if (update) {
+			if (isFunction(update)) nextValue = update(get(valuesBaseAtom));
+			else nextValue = update;
+		}
+		set(previousValuesBaseAtom, get(valuesBaseAtom));
+		set(valuesBaseAtom, nextValue);
+	});
+	const validationResultsAtom = atomWithReset({
+		initialize: [],
+		change: [],
+		blur: [],
+		submit: [],
+		server: []
+	});
+	const submittingAtom = atomWithReset(false);
+	const submittedAtom = atomWithReset(false);
+	const submitAttemptsAtom = atomWithReset(0);
+	const focusedFieldsAtom = atomWithReset({});
+	const requiredFieldsAtom = atomWithReset({});
+	const disabledFieldsAtom = atomWithReset({});
+	const touchedFieldsAtom = atomWithReset({});
+	const blurredFieldsAtom = atomWithReset({});
+	const validatingFieldsAtom = atomWithReset({});
+	const validationResultsFieldsAtom = atomWithReset({});
+	const refsAtom = atomWithReset({});
+	const tabIndexesBaseAtom = atomWithReset({});
+	const tabIndexesAtom = atom((get) => get(tabIndexesBaseAtom), (get, set, update) => {
+		let nextValue = {};
+		if (isFunction(update)) nextValue = update(get(tabIndexesBaseAtom));
+		else if (update === RESET) nextValue = {};
+		else {
+			const tabIndexes = get(tabIndexesBaseAtom);
+			if ("field" in update && update.field && isString(update.field)) {
+				let tabIndex = update.tabIndex;
+				if (!isNumber(tabIndex) || tabIndex > -1) {
+					const flat = flattenObject(tabIndexes);
+					let lastIndex = -1;
+					for (const key in flat) if (isNumber(flat[key]) && flat[key] > lastIndex) lastIndex = flat[key];
+					tabIndex = lastIndex + 1;
+				}
+				nextValue = setField(tabIndexes, update.field, tabIndex);
+			} else nextValue = update;
+		}
+		set(tabIndexesBaseAtom, nextValue);
+	});
+	const dirtyAtom = atom((get) => {
+		return get(optionsAtom).isEqual(get(valuesAtom), get(initialValuesAtom));
+	});
+	const pristineAtom = atom((get) => !get(dirtyAtom));
+	const blurredAtom = atom((get) => {
+		const blurredFields = flattenObject(get(blurredFieldsAtom));
+		return Object.keys(blurredFields).some((key) => blurredFields[key]);
+	});
+	const touchedAtom = atom((get) => {
+		const touchedFields = flattenObject(get(touchedFieldsAtom));
+		return Object.keys(touchedFields).some((key) => touchedFields[key]);
+	});
+	const validatingAtom = atom((get) => {
+		if (get(formValidatingAtom)) return true;
+		const validatingFields = flattenObject(get(validatingFieldsAtom));
+		return Object.keys(validatingFields).some((key) => validatingFields[key]);
+	});
+	const formErrorsAtom = atomWithMessageTypes(validationResultsAtom, "danger");
+	const formWarningsAtom = atomWithMessageTypes(validationResultsAtom, "warning");
+	const formInfoAtom = atomWithMessageTypes(validationResultsAtom, "info");
+	const formHelpAtom = atomWithMessageTypes(validationResultsAtom, "discovery");
+	const formSuccessesAtom = atomWithMessageTypes(validationResultsAtom, "success");
+	const formPositivesAtom = atomWithMessageTypes(validationResultsAtom, "positive");
+	const formNegativesAtom = atomWithMessageTypes(validationResultsAtom, "negative");
+	const isFormInvalidAtom = atom((get) => {
+		return get(formErrorsAtom).length > 0;
+	});
+	const errorFieldsAtom = atomWithFieldsMessageTypes(validationResultsFieldsAtom, "danger");
+	const warningFieldsAtom = atomWithFieldsMessageTypes(validationResultsFieldsAtom, "warning");
+	const infoFieldsAtom = atomWithFieldsMessageTypes(validationResultsFieldsAtom, "info");
+	const helpFieldsAtom = atomWithFieldsMessageTypes(validationResultsFieldsAtom, "discovery");
+	const successFieldsAtom = atomWithFieldsMessageTypes(validationResultsFieldsAtom, "success");
+	const fieldErrorMessagesAtom = atomWithFieldsMessageList(validationResultsFieldsAtom, "danger");
+	const fieldWarningMessagesAtom = atomWithFieldsMessageList(validationResultsFieldsAtom, "warning");
+	const fieldInfoMessagesAtom = atomWithFieldsMessageList(validationResultsFieldsAtom, "info");
+	const fieldHelpMessagesAtom = atomWithFieldsMessageList(validationResultsFieldsAtom, "discovery");
+	const fieldsSuccessMessagesAtom = atomWithFieldsMessageList(validationResultsFieldsAtom, "success");
+	const invalidAtom = atom((get) => {
+		return get(fieldErrorMessagesAtom).length > 0 || get(isFormInvalidAtom);
+	});
+	const validAtom = atom((get) => !get(invalidAtom));
+	const canSubmitAtom = atom((get) => get(validAtom) && !get(validatingAtom) && !get(submittingAtom) && !get(disabledAtom));
+	return {
+		options: optionsAtom,
+		name: nameAtom,
+		disabled: disabledAtom,
+		formValidating: formValidatingAtom,
+		validationResults: validationResultsAtom,
+		submitting: submittingAtom,
+		submitted: submittedAtom,
+		submitAttempts: submitAttemptsAtom,
+		focusedFields: focusedFieldsAtom,
+		requiredFields: requiredFieldsAtom,
+		disabledFields: disabledFieldsAtom,
+		touchedFields: touchedFieldsAtom,
+		blurredFields: blurredFieldsAtom,
+		validatingFields: validatingFieldsAtom,
+		validationResultsFields: validationResultsFieldsAtom,
+		tabIndexes: tabIndexesAtom,
+		refs: refsAtom,
+		dirty: dirtyAtom,
+		pristine: pristineAtom,
+		blurred: blurredAtom,
+		touched: touchedAtom,
+		validating: validatingAtom,
+		previousValues: previousValuesAtom,
+		initialValues: initialValuesAtom,
+		values: valuesAtom,
+		dangerMessages: formErrorsAtom,
+		warningMessages: formWarningsAtom,
+		infoMessages: formInfoAtom,
+		discoveryMessages: formHelpAtom,
+		successMessages: formSuccessesAtom,
+		positiveMessages: formPositivesAtom,
+		negativeMessages: formNegativesAtom,
+		messages: atomWithMessages(formErrorsAtom, formWarningsAtom, formInfoAtom, formHelpAtom, formSuccessesAtom, formPositivesAtom, formNegativesAtom),
+		dangerFields: errorFieldsAtom,
+		warningFields: warningFieldsAtom,
+		infoFields: infoFieldsAtom,
+		discoveryFields: helpFieldsAtom,
+		successFields: successFieldsAtom,
+		fieldDangerMessages: fieldErrorMessagesAtom,
+		fieldWarningMessages: fieldWarningMessagesAtom,
+		fieldInfoMessages: fieldInfoMessagesAtom,
+		fieldHelpMessages: fieldHelpMessagesAtom,
+		fieldsSuccessMessages: fieldsSuccessMessagesAtom,
+		valid: validAtom,
+		invalid: invalidAtom,
+		theme: atomWithTheme(optionsAtom, formErrorsAtom, formWarningsAtom, formInfoAtom, formHelpAtom, formSuccessesAtom, formPositivesAtom, formNegativesAtom),
+		canSubmit: canSubmitAtom
+	};
+}, { type: "form" });
+
+//#endregion
+export { DEFAULT_FORM_OPTIONS, FormApi };
 //# sourceMappingURL=form-molecule.mjs.map

package/dist/form/molecules/form-molecule.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"form-molecule.mjs","names":["DEFAULT_FORM_OPTIONS","FormApi","createMoleculeApi","optionsBaseAtom","atomWithReset","optionsAtom","atom","get","nextValue","isFunction","update","RESET","set","deepMerge","nameAtom","scope","disabledAtom","atomWithDefault","formValidatingAtom","previousValuesBaseAtom","previousValuesAtom","initialValuesAtom","valuesBaseAtom","valuesAtom","validationResultsAtom","submittingAtom","submittedAtom","submitAttemptsAtom","focusedFieldsAtom","requiredFieldsAtom","disabledFieldsAtom","touchedFieldsAtom","blurredFieldsAtom","validatingFieldsAtom","validationResultsFieldsAtom","refsAtom","tabIndexesBaseAtom","tabIndexesAtom","tabIndexes","isString","tabIndex","isNumber","flat","flattenObject","lastIndex","key","setField","dirtyAtom","pristineAtom","blurredAtom","blurredFields","touchedAtom","touchedFields","validatingAtom","validatingFields","formErrorsAtom","atomWithMessageTypes","formWarningsAtom","formInfoAtom","formHelpAtom","formSuccessesAtom","formPositivesAtom","formNegativesAtom","isFormInvalidAtom","errorFieldsAtom","atomWithFieldsMessageTypes","warningFieldsAtom","infoFieldsAtom","helpFieldsAtom","successFieldsAtom","fieldErrorMessagesAtom","atomWithFieldsMessageList","fieldWarningMessagesAtom","fieldInfoMessagesAtom","fieldHelpMessagesAtom","fieldsSuccessMessagesAtom","invalidAtom","validAtom","canSubmitAtom","atomWithMessages","atomWithTheme"],"sources":[],"mappings":""}
+{"version":3,"file":"form-molecule.mjs","names":[],"sources":[],"mappings":""}

package/dist/form/molecules/index.cjs

@@ -1 +1,7 @@
-const e=require("./form-molecule.cjs"),t=require("./field-molecule.cjs");exports.DEFAULT_FIELD_OPTIONS=t.DEFAULT_FIELD_OPTIONS,exports.DEFAULT_FORM_OPTIONS=e.DEFAULT_FORM_OPTIONS,exports.FieldApi=t.FieldApi,exports.FormApi=e.FormApi;
+const require_form_molecule = require("./form-molecule.cjs");
+const require_field_molecule = require("./field-molecule.cjs");
+
+exports.DEFAULT_FIELD_OPTIONS = require_field_molecule.DEFAULT_FIELD_OPTIONS;
+exports.DEFAULT_FORM_OPTIONS = require_form_molecule.DEFAULT_FORM_OPTIONS;
+exports.FieldApi = require_field_molecule.FieldApi;
+exports.FormApi = require_form_molecule.FormApi;

package/dist/form/molecules/index.mjs

@@ -1 +1,4 @@
-import{DEFAULT_FORM_OPTIONS as e,FormApi as t}from"./form-molecule.mjs";import{DEFAULT_FIELD_OPTIONS as n,FieldApi as r}from"./field-molecule.mjs";export{n as DEFAULT_FIELD_OPTIONS,e as DEFAULT_FORM_OPTIONS,r as FieldApi,t as FormApi};
+import { DEFAULT_FORM_OPTIONS, FormApi } from "./form-molecule.mjs";
+import { DEFAULT_FIELD_OPTIONS, FieldApi } from "./field-molecule.mjs";
+
+export { DEFAULT_FIELD_OPTIONS, DEFAULT_FORM_OPTIONS, FieldApi, FormApi };