@jcoreio/zod-forms 1.0.0

package/reducers/setValue.mjs

@@ -0,0 +1,32 @@
+import { set } from "../util/set.mjs";
+import { invert } from 'zod-invertible';
+export const createSetValueReducer = ({
+  schema,
+  inverseSchema
+}) => function setValueReducer(state, action) {
+  const newValues = set(state.values, action.field.path, action.value);
+  try {
+    const newRawValues = inverseSchema.parse(newValues);
+    schema.parse(newRawValues);
+    return {
+      ...state,
+      submitError: undefined,
+      validationError: undefined,
+      rawValues: newRawValues,
+      values: newValues
+    };
+  } catch (error) {
+    const newRawParsed = invert(action.field.schema).safeParse(action.value);
+    const rawValues = newRawParsed.success ? set(state.rawValues, action.field.path, newRawParsed.data) : state.rawValues;
+    const newParsed = schema.safeParse(rawValues);
+    const result = {
+      ...state,
+      submitError: undefined,
+      validationError: !newRawParsed.success ? newRawParsed.error : newParsed.success ? undefined : newParsed.error,
+      rawValues,
+      values: newParsed.success ? newParsed.data : state.values
+    };
+    return result;
+  }
+};
+//# sourceMappingURL=setValue.mjs.map

package/reducers/setValue.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"setValue.mjs","names":["set","invert","createSetValueReducer","schema","inverseSchema","setValueReducer","state","action","newValues","values","field","path","value","newRawValues","parse","submitError","undefined","validationError","rawValues","error","newRawParsed","safeParse","success","data","newParsed","result"],"sources":["../../src/reducers/setValue.ts"],"sourcesContent":["import z from 'zod'\nimport { FormState } from '../FormState'\nimport { SetValueAction } from '../actions/setValue'\nimport { set } from '../util/set'\nimport { FieldPath } from '../FieldPath'\nimport { invert } from 'zod-invertible'\n\nexport const createSetValueReducer = <T extends z.ZodTypeAny>({\n  schema,\n  inverseSchema,\n}: {\n  schema: T\n  inverseSchema: z.ZodType<z.input<T>, any, z.output<T>>\n}) =>\n  function setValueReducer<Field extends FieldPath>(\n    state: FormState<T>,\n    action: SetValueAction<Field>\n  ) {\n    const newValues = set(state.values, action.field.path, action.value)\n    try {\n      const newRawValues = inverseSchema.parse(newValues)\n      schema.parse(newRawValues)\n      return {\n        ...state,\n        submitError: undefined,\n        validationError: undefined,\n        rawValues: newRawValues,\n        values: newValues,\n      }\n    } catch (error) {\n      const newRawParsed = invert(action.field.schema).safeParse(action.value)\n      const rawValues = newRawParsed.success\n        ? set(state.rawValues, action.field.path, newRawParsed.data)\n        : state.rawValues\n      const newParsed = schema.safeParse(rawValues)\n      const result = {\n        ...state,\n        submitError: undefined,\n        validationError: !newRawParsed.success\n          ? newRawParsed.error\n          : newParsed.success\n          ? undefined\n          : newParsed.error,\n        rawValues,\n        values: newParsed.success ? newParsed.data : state.values,\n      }\n      return result\n    }\n  }\n"],"mappings":"AAGA,SAASA,GAAG;AAEZ,SAASC,MAAM,QAAQ,gBAAgB;AAEvC,OAAO,MAAMC,qBAAqB,GAAGA,CAAyB;EAC5DC,MAAM;EACNC;AAIF,CAAC,KACC,SAASC,eAAeA,CACtBC,KAAmB,EACnBC,MAA6B,EAC7B;EACA,MAAMC,SAAS,GAAGR,GAAG,CAACM,KAAK,CAACG,MAAM,EAAEF,MAAM,CAACG,KAAK,CAACC,IAAI,EAAEJ,MAAM,CAACK,KAAK,CAAC;EACpE,IAAI;IACF,MAAMC,YAAY,GAAGT,aAAa,CAACU,KAAK,CAACN,SAAS,CAAC;IACnDL,MAAM,CAACW,KAAK,CAACD,YAAY,CAAC;IAC1B,OAAO;MACL,GAAGP,KAAK;MACRS,WAAW,EAAEC,SAAS;MACtBC,eAAe,EAAED,SAAS;MAC1BE,SAAS,EAAEL,YAAY;MACvBJ,MAAM,EAAED;IACV,CAAC;EACH,CAAC,CAAC,OAAOW,KAAK,EAAE;IACd,MAAMC,YAAY,GAAGnB,MAAM,CAACM,MAAM,CAACG,KAAK,CAACP,MAAM,CAAC,CAACkB,SAAS,CAACd,MAAM,CAACK,KAAK,CAAC;IACxE,MAAMM,SAAS,GAAGE,YAAY,CAACE,OAAO,GAClCtB,GAAG,CAACM,KAAK,CAACY,SAAS,EAAEX,MAAM,CAACG,KAAK,CAACC,IAAI,EAAES,YAAY,CAACG,IAAI,CAAC,GAC1DjB,KAAK,CAACY,SAAS;IACnB,MAAMM,SAAS,GAAGrB,MAAM,CAACkB,SAAS,CAACH,SAAS,CAAC;IAC7C,MAAMO,MAAM,GAAG;MACb,GAAGnB,KAAK;MACRS,WAAW,EAAEC,SAAS;MACtBC,eAAe,EAAE,CAACG,YAAY,CAACE,OAAO,GAClCF,YAAY,CAACD,KAAK,GAClBK,SAAS,CAACF,OAAO,GACjBN,SAAS,GACTQ,SAAS,CAACL,KAAK;MACnBD,SAAS;MACTT,MAAM,EAAEe,SAAS,CAACF,OAAO,GAAGE,SAAS,CAACD,IAAI,GAAGjB,KAAK,CAACG;IACrD,CAAC;IACD,OAAOgB,MAAM;EACf;AACF,CAAC","ignoreList":[]}

package/reducers/submitSucceeded.d.ts

@@ -0,0 +1,23 @@
+import z from 'zod';
+import { FormState } from '../FormState';
+export declare function submitSucceededReducer<T extends z.ZodTypeAny>(state: FormState<T>): {
+    submitting: boolean;
+    submitSucceeded: boolean;
+    submitFailed: boolean;
+    submitError: undefined;
+    submitPromise: undefined;
+    initialValues: z.output<T> | undefined;
+    rawInitialValues: z.input<T> | undefined;
+    mounted: boolean;
+    initialized: boolean;
+    fieldMeta: Record<string, import("../FormState").FieldMeta>;
+    rawValues?: unknown;
+    values?: z.output<T> | undefined;
+    submittedValues?: z.output<T> | undefined;
+    rawSubmittedValues?: z.input<T> | undefined;
+    validationError?: any;
+    onSubmit: Set<import("../FormState").SubmitHandler<T>>;
+    onSubmitSucceeded: Set<import("../FormState").SubmitSuccededHandler>;
+    onSubmitFailed: Set<import("../FormState").SubmitFailedHandler>;
+};
+//# sourceMappingURL=submitSucceeded.d.ts.map

package/reducers/submitSucceeded.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"submitSucceeded.d.ts","sourceRoot":"","sources":["../../src/reducers/submitSucceeded.ts"],"names":[],"mappings":"AAAA,OAAO,CAAC,MAAM,KAAK,CAAA;AACnB,OAAO,EAAE,SAAS,EAAE,MAAM,cAAc,CAAA;AAExC,wBAAgB,sBAAsB,CAAC,CAAC,SAAS,CAAC,CAAC,UAAU,EAC3D,KAAK,EAAE,SAAS,CAAC,CAAC,CAAC;;;;;;;;;;;;;;;;;;;EAYpB"}

package/reducers/submitSucceeded.js

@@ -0,0 +1,22 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.submitSucceededReducer = submitSucceededReducer;
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { (0, _defineProperty2["default"])(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function submitSucceededReducer(state) {
+  return _objectSpread(_objectSpread({}, state), {}, {
+    submitting: false,
+    submitSucceeded: true,
+    submitFailed: false,
+    submitError: undefined,
+    submitPromise: undefined,
+    initialValues: state.submittedValues,
+    rawInitialValues: state.rawSubmittedValues
+  });
+}
+//# sourceMappingURL=submitSucceeded.js.map

package/reducers/submitSucceeded.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"submitSucceeded.js","names":["submitSucceededReducer","state","_objectSpread","submitting","submitSucceeded","submitFailed","submitError","undefined","submitPromise","initialValues","submittedValues","rawInitialValues","rawSubmittedValues"],"sources":["../../src/reducers/submitSucceeded.ts"],"sourcesContent":["import z from 'zod'\nimport { FormState } from '../FormState'\n\nexport function submitSucceededReducer<T extends z.ZodTypeAny>(\n  state: FormState<T>\n) {\n  return {\n    ...state,\n    submitting: false,\n    submitSucceeded: true,\n    submitFailed: false,\n    submitError: undefined,\n    submitPromise: undefined,\n    initialValues: state.submittedValues,\n    rawInitialValues: state.rawSubmittedValues,\n  }\n}\n"],"mappings":";;;;;;;;;;AAGO,SAASA,sBAAsBA,CACpCC,KAAmB,EACnB;EACA,OAAAC,aAAA,CAAAA,aAAA,KACKD,KAAK;IACRE,UAAU,EAAE,KAAK;IACjBC,eAAe,EAAE,IAAI;IACrBC,YAAY,EAAE,KAAK;IACnBC,WAAW,EAAEC,SAAS;IACtBC,aAAa,EAAED,SAAS;IACxBE,aAAa,EAAER,KAAK,CAACS,eAAe;IACpCC,gBAAgB,EAAEV,KAAK,CAACW;EAAkB;AAE9C","ignoreList":[]}

package/reducers/submitSucceeded.mjs

@@ -0,0 +1,13 @@
+export function submitSucceededReducer(state) {
+  return {
+    ...state,
+    submitting: false,
+    submitSucceeded: true,
+    submitFailed: false,
+    submitError: undefined,
+    submitPromise: undefined,
+    initialValues: state.submittedValues,
+    rawInitialValues: state.rawSubmittedValues
+  };
+}
+//# sourceMappingURL=submitSucceeded.mjs.map

package/reducers/submitSucceeded.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"submitSucceeded.mjs","names":["submitSucceededReducer","state","submitting","submitSucceeded","submitFailed","submitError","undefined","submitPromise","initialValues","submittedValues","rawInitialValues","rawSubmittedValues"],"sources":["../../src/reducers/submitSucceeded.ts"],"sourcesContent":["import z from 'zod'\nimport { FormState } from '../FormState'\n\nexport function submitSucceededReducer<T extends z.ZodTypeAny>(\n  state: FormState<T>\n) {\n  return {\n    ...state,\n    submitting: false,\n    submitSucceeded: true,\n    submitFailed: false,\n    submitError: undefined,\n    submitPromise: undefined,\n    initialValues: state.submittedValues,\n    rawInitialValues: state.rawSubmittedValues,\n  }\n}\n"],"mappings":"AAGA,OAAO,SAASA,sBAAsBA,CACpCC,KAAmB,EACnB;EACA,OAAO;IACL,GAAGA,KAAK;IACRC,UAAU,EAAE,KAAK;IACjBC,eAAe,EAAE,IAAI;IACrBC,YAAY,EAAE,KAAK;IACnBC,WAAW,EAAEC,SAAS;IACtBC,aAAa,EAAED,SAAS;IACxBE,aAAa,EAAEP,KAAK,CAACQ,eAAe;IACpCC,gBAAgB,EAAET,KAAK,CAACU;EAC1B,CAAC;AACH","ignoreList":[]}

package/reducers/util/getInverseArrayElementSchema.d.ts

@@ -0,0 +1,3 @@
+import z from 'zod';
+export declare function getInverseArrayElementSchema(schema: z.ZodTypeAny): z.ZodType<any, any, any>;
+//# sourceMappingURL=getInverseArrayElementSchema.d.ts.map

package/reducers/util/getInverseArrayElementSchema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getInverseArrayElementSchema.d.ts","sourceRoot":"","sources":["../../../src/reducers/util/getInverseArrayElementSchema.ts"],"names":[],"mappings":"AAAA,OAAO,CAAC,MAAM,KAAK,CAAA;AAInB,wBAAgB,4BAA4B,CAAC,MAAM,EAAE,CAAC,CAAC,UAAU,4BAIhE"}

package/reducers/util/getInverseArrayElementSchema.js

@@ -0,0 +1,14 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getInverseArrayElementSchema = getInverseArrayElementSchema;
+var _getArrayElementSchema = require("../../util/getArrayElementSchema.js");
+var _zodInvertible = require("zod-invertible");
+function getInverseArrayElementSchema(schema) {
+  var elemSchema = (0, _getArrayElementSchema.getArrayElementSchema)(schema);
+  if (!elemSchema) throw new Error('field is not an array');
+  return (0, _zodInvertible.invert)(elemSchema);
+}
+//# sourceMappingURL=getInverseArrayElementSchema.js.map

package/reducers/util/getInverseArrayElementSchema.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"getInverseArrayElementSchema.js","names":["_getArrayElementSchema","require","_zodInvertible","getInverseArrayElementSchema","schema","elemSchema","getArrayElementSchema","Error","invert"],"sources":["../../../src/reducers/util/getInverseArrayElementSchema.ts"],"sourcesContent":["import z from 'zod'\nimport { getArrayElementSchema } from '../../util/getArrayElementSchema'\nimport { invert } from 'zod-invertible'\n\nexport function getInverseArrayElementSchema(schema: z.ZodTypeAny) {\n  const elemSchema = getArrayElementSchema(schema)\n  if (!elemSchema) throw new Error('field is not an array')\n  return invert(elemSchema)\n}\n"],"mappings":";;;;;;AACA,IAAAA,sBAAA,GAAAC,OAAA;AACA,IAAAC,cAAA,GAAAD,OAAA;AAEO,SAASE,4BAA4BA,CAACC,MAAoB,EAAE;EACjE,IAAMC,UAAU,GAAG,IAAAC,4CAAqB,EAACF,MAAM,CAAC;EAChD,IAAI,CAACC,UAAU,EAAE,MAAM,IAAIE,KAAK,CAAC,uBAAuB,CAAC;EACzD,OAAO,IAAAC,qBAAM,EAACH,UAAU,CAAC;AAC3B","ignoreList":[]}

package/reducers/util/getInverseArrayElementSchema.mjs

@@ -0,0 +1,8 @@
+import { getArrayElementSchema } from "../../util/getArrayElementSchema.mjs";
+import { invert } from 'zod-invertible';
+export function getInverseArrayElementSchema(schema) {
+  const elemSchema = getArrayElementSchema(schema);
+  if (!elemSchema) throw new Error('field is not an array');
+  return invert(elemSchema);
+}
+//# sourceMappingURL=getInverseArrayElementSchema.mjs.map

package/reducers/util/getInverseArrayElementSchema.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"getInverseArrayElementSchema.mjs","names":["getArrayElementSchema","invert","getInverseArrayElementSchema","schema","elemSchema","Error"],"sources":["../../../src/reducers/util/getInverseArrayElementSchema.ts"],"sourcesContent":["import z from 'zod'\nimport { getArrayElementSchema } from '../../util/getArrayElementSchema'\nimport { invert } from 'zod-invertible'\n\nexport function getInverseArrayElementSchema(schema: z.ZodTypeAny) {\n  const elemSchema = getArrayElementSchema(schema)\n  if (!elemSchema) throw new Error('field is not an array')\n  return invert(elemSchema)\n}\n"],"mappings":"AACA,SAASA,qBAAqB;AAC9B,SAASC,MAAM,QAAQ,gBAAgB;AAEvC,OAAO,SAASC,4BAA4BA,CAACC,MAAoB,EAAE;EACjE,MAAMC,UAAU,GAAGJ,qBAAqB,CAACG,MAAM,CAAC;EAChD,IAAI,CAACC,UAAU,EAAE,MAAM,IAAIC,KAAK,CAAC,uBAAuB,CAAC;EACzD,OAAOJ,MAAM,CAACG,UAAU,CAAC;AAC3B","ignoreList":[]}

package/reducers/util/updateRawArray.d.ts

@@ -0,0 +1,7 @@
+import z from 'zod';
+import { Reducer } from 'react';
+import { FieldPath, FieldPathForRawValue } from '../../FieldPath';
+import { FormState } from '../../FormState';
+import { FormAction } from '../../FormAction';
+export declare function updateRawArray<T extends z.ZodTypeAny, Field extends FieldPathForRawValue<any[]>>(reducer: Reducer<FormState<T>, FormAction<T>>, state: FormState<T>, field: FieldPath, updater: (array: z.input<Field['schema']> | undefined) => z.input<Field['schema']> | undefined): FormState<T>;
+//# sourceMappingURL=updateRawArray.d.ts.map

package/reducers/util/updateRawArray.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"updateRawArray.d.ts","sourceRoot":"","sources":["../../../src/reducers/util/updateRawArray.ts"],"names":[],"mappings":"AAAA,OAAO,CAAC,MAAM,KAAK,CAAA;AACnB,OAAO,EAAE,OAAO,EAAE,MAAM,OAAO,CAAA;AAC/B,OAAO,EAAE,SAAS,EAAE,oBAAoB,EAAE,MAAM,iBAAiB,CAAA;AACjE,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAA;AAC3C,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAA;AAI7C,wBAAgB,cAAc,CAC5B,CAAC,SAAS,CAAC,CAAC,UAAU,EACtB,KAAK,SAAS,oBAAoB,CAAC,GAAG,EAAE,CAAC,EAEzC,OAAO,EAAE,OAAO,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE,UAAU,CAAC,CAAC,CAAC,CAAC,EAC7C,KAAK,EAAE,SAAS,CAAC,CAAC,CAAC,EACnB,KAAK,EAAE,SAAS,EAChB,OAAO,EAAE,CACP,KAAK,EAAE,CAAC,CAAC,KAAK,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC,GAAG,SAAS,KACxC,CAAC,CAAC,KAAK,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC,GAAG,SAAS,gBAO1C"}

package/reducers/util/updateRawArray.js

@@ -0,0 +1,14 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.updateRawArray = updateRawArray;
+var _get = require("../../util/get.js");
+var _setRawValue = require("../../actions/setRawValue.js");
+function updateRawArray(reducer, state, field, updater) {
+  var oldValue = (0, _get.get)(state.rawValues, field.path);
+  var newValue = updater(oldValue);
+  return newValue === oldValue ? state : reducer(state, (0, _setRawValue.setRawValue)(field, newValue));
+}
+//# sourceMappingURL=updateRawArray.js.map

package/reducers/util/updateRawArray.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"updateRawArray.js","names":["_get","require","_setRawValue","updateRawArray","reducer","state","field","updater","oldValue","get","rawValues","path","newValue","setRawValue"],"sources":["../../../src/reducers/util/updateRawArray.ts"],"sourcesContent":["import z from 'zod'\nimport { Reducer } from 'react'\nimport { FieldPath, FieldPathForRawValue } from '../../FieldPath'\nimport { FormState } from '../../FormState'\nimport { FormAction } from '../../FormAction'\nimport { get } from '../../util/get'\nimport { setRawValue } from '../../actions/setRawValue'\n\nexport function updateRawArray<\n  T extends z.ZodTypeAny,\n  Field extends FieldPathForRawValue<any[]>\n>(\n  reducer: Reducer<FormState<T>, FormAction<T>>,\n  state: FormState<T>,\n  field: FieldPath,\n  updater: (\n    array: z.input<Field['schema']> | undefined\n  ) => z.input<Field['schema']> | undefined\n) {\n  const oldValue = get(state.rawValues, field.path)\n  const newValue = updater(oldValue as any)\n  return newValue === oldValue\n    ? state\n    : reducer(state, setRawValue(field, newValue))\n}\n"],"mappings":";;;;;;AAKA,IAAAA,IAAA,GAAAC,OAAA;AACA,IAAAC,YAAA,GAAAD,OAAA;AAEO,SAASE,cAAcA,CAI5BC,OAA6C,EAC7CC,KAAmB,EACnBC,KAAgB,EAChBC,OAEyC,EACzC;EACA,IAAMC,QAAQ,GAAG,IAAAC,QAAG,EAACJ,KAAK,CAACK,SAAS,EAAEJ,KAAK,CAACK,IAAI,CAAC;EACjD,IAAMC,QAAQ,GAAGL,OAAO,CAACC,QAAe,CAAC;EACzC,OAAOI,QAAQ,KAAKJ,QAAQ,GACxBH,KAAK,GACLD,OAAO,CAACC,KAAK,EAAE,IAAAQ,wBAAW,EAACP,KAAK,EAAEM,QAAQ,CAAC,CAAC;AAClD","ignoreList":[]}

package/reducers/util/updateRawArray.mjs

@@ -0,0 +1,8 @@
+import { get } from "../../util/get.mjs";
+import { setRawValue } from "../../actions/setRawValue.mjs";
+export function updateRawArray(reducer, state, field, updater) {
+  const oldValue = get(state.rawValues, field.path);
+  const newValue = updater(oldValue);
+  return newValue === oldValue ? state : reducer(state, setRawValue(field, newValue));
+}
+//# sourceMappingURL=updateRawArray.mjs.map

package/reducers/util/updateRawArray.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"updateRawArray.mjs","names":["get","setRawValue","updateRawArray","reducer","state","field","updater","oldValue","rawValues","path","newValue"],"sources":["../../../src/reducers/util/updateRawArray.ts"],"sourcesContent":["import z from 'zod'\nimport { Reducer } from 'react'\nimport { FieldPath, FieldPathForRawValue } from '../../FieldPath'\nimport { FormState } from '../../FormState'\nimport { FormAction } from '../../FormAction'\nimport { get } from '../../util/get'\nimport { setRawValue } from '../../actions/setRawValue'\n\nexport function updateRawArray<\n  T extends z.ZodTypeAny,\n  Field extends FieldPathForRawValue<any[]>\n>(\n  reducer: Reducer<FormState<T>, FormAction<T>>,\n  state: FormState<T>,\n  field: FieldPath,\n  updater: (\n    array: z.input<Field['schema']> | undefined\n  ) => z.input<Field['schema']> | undefined\n) {\n  const oldValue = get(state.rawValues, field.path)\n  const newValue = updater(oldValue as any)\n  return newValue === oldValue\n    ? state\n    : reducer(state, setRawValue(field, newValue))\n}\n"],"mappings":"AAKA,SAASA,GAAG;AACZ,SAASC,WAAW;AAEpB,OAAO,SAASC,cAAcA,CAI5BC,OAA6C,EAC7CC,KAAmB,EACnBC,KAAgB,EAChBC,OAEyC,EACzC;EACA,MAAMC,QAAQ,GAAGP,GAAG,CAACI,KAAK,CAACI,SAAS,EAAEH,KAAK,CAACI,IAAI,CAAC;EACjD,MAAMC,QAAQ,GAAGJ,OAAO,CAACC,QAAe,CAAC;EACzC,OAAOG,QAAQ,KAAKH,QAAQ,GACxBH,KAAK,GACLD,OAAO,CAACC,KAAK,EAAEH,WAAW,CAACI,KAAK,EAAEK,QAAQ,CAAC,CAAC;AAClD","ignoreList":[]}

package/src/FieldPath.ts

@@ -0,0 +1,215 @@
+import z from 'zod'
+import { pathstring } from './util/pathstring'
+import { SchemaAt } from './util/SchemaAt'
+import { PathInSchema, PathstringInSchema } from './util/PathInSchema'
+import { parsePathstring } from './util/parsePathstring'
+
+export type FieldPathForValue<Value, RawValue = any> = FieldPath<
+  z.ZodType<Value, any, RawValue>
+>
+export type FieldPathForRawValue<RawValue> = FieldPath<
+  z.ZodType<any, any, RawValue>
+>
+
+export class FieldPath<T extends z.ZodTypeAny = z.ZodTypeAny> {
+  readonly path: BasePath
+  readonly pathstring: string
+  readonly schema: T
+
+  private subfields: Map<SubpathKey<T>, FieldPath> | undefined
+
+  private constructor({ schema, path }: { schema: T; path: BasePath }) {
+    this.path = path
+    this.schema = schema
+    this.pathstring = pathstring(path)
+  }
+
+  static root<T extends z.ZodTypeAny>(schema: T) {
+    return new FieldPath({ schema, path: [] })
+  }
+
+  get<Path extends PathInSchema<T>>(
+    path: Path
+  ): SchemaAt<T, Path> extends never ? never : FieldPath<SchemaAt<T, Path>>
+  get<Pathstring extends PathstringInSchema<T>>(
+    path: Pathstring
+  ): FieldPath<SchemaAt<T, parsePathstring<Pathstring>>>
+  get(path: any): FieldPath {
+    if (typeof path === 'string') path = parsePathstring(path)
+    if (!Array.isArray(path)) throw new Error(`invalid path: ${path}`)
+    return path.reduce((field, key) => field.subfield(key), this)
+  }
+
+  subfield<K extends SubpathKey<T>>(key: K): FieldPath<SchemaAt<T, [K]>> {
+    const cached = this.subfields?.get(key)
+    if (cached) return cached as any
+    const schema = subschema(this.schema, key)
+    if (!schema) throw new Error(`invalid subschema key: ${key}`)
+    const subfield = new FieldPath({
+      path: [...this.path, key] as any,
+      schema: schema as any,
+    })
+    if (this.subfields == null) this.subfields = new Map()
+    this.subfields.set(key, subfield)
+    return subfield
+  }
+}
+
+export type BasePath = (string | number)[]
+
+export type SubpathKey<T extends z.ZodTypeAny> = 0 extends 1 & T
+  ? any
+  : 0 extends 1 & z.input<T>
+  ? any
+  : T extends z.ZodObject<infer Shape, infer UnknownKeys>
+  ? UnknownKeys extends 'passthrough'
+    ? string
+    : keyof Shape
+  : T extends z.ZodRecord<infer Key, any>
+  ? z.input<Key>
+  : T extends z.ZodMap<infer Key, any>
+  ? z.input<Key>
+  : T extends z.ZodArray<any>
+  ? number
+  : T extends z.ZodTuple<any, any>
+  ? number
+  : T extends z.ZodLazy<infer U>
+  ? SubpathKey<U>
+  : T extends z.ZodUnion<infer Options>
+  ? SubpathKey<Options[number]>
+  : T extends z.ZodDiscriminatedUnion<any, infer Options>
+  ? SubpathKey<Options[number]>
+  : T extends z.ZodOptional<infer U>
+  ? SubpathKey<U>
+  : T extends z.ZodNullable<infer U>
+  ? SubpathKey<U>
+  : T extends z.ZodDefault<infer U>
+  ? SubpathKey<U>
+  : T extends z.ZodCatch<infer U>
+  ? SubpathKey<U>
+  : T extends z.ZodEffects<infer U, any>
+  ? SubpathKey<U>
+  : T extends z.ZodBranded<infer U, any>
+  ? SubpathKey<U>
+  : never
+
+export type AllPaths<T extends z.ZodTypeAny> = SubpathKey<T> extends never
+  ? []
+  : [] | ValuesOf<SubpathKeyMap<T>>
+
+type ValuesOf<O> = O[keyof O]
+
+export type SubpathKeyMap<T extends z.ZodTypeAny> = {
+  [K in SubpathKey<T>]: [K, ...AllPaths<SchemaAt<T, [K]>>]
+}
+
+function subschema(
+  schema: z.ZodTypeAny,
+  key: string
+): z.ZodTypeAny | undefined {
+  switch (schema._def.typeName) {
+    case z.ZodFirstPartyTypeKind.ZodAny:
+    case 'ZodArray':
+      if (typeof key === 'number') return (schema as z.ZodArray<any>).element
+      break
+    case 'ZodObject': {
+      const {
+        shape,
+        _def: { unknownKeys, catchall },
+      } = schema as z.AnyZodObject
+      if (key in shape) return shape[key]
+      if (unknownKeys === 'passthrough') return catchall
+      break
+    }
+    case 'ZodUnion': {
+      const options = (
+        schema as z.ZodUnion<[z.ZodTypeAny, ...z.ZodTypeAny[]]>
+      ).options
+        .map((opt) => subschema(opt, key))
+        .filter((opt): opt is z.ZodTypeAny => opt != null)
+      return options.length > 1
+        ? z.union(options as any)
+        : options.length === 1
+        ? options[0]
+        : undefined
+    }
+    case 'ZodDiscriminatedUnion': {
+      const discUnion = schema as z.ZodDiscriminatedUnion<
+        any,
+        [z.AnyZodObject, ...z.AnyZodObject[]]
+      >
+      const options = discUnion.options
+        .map((opt) => subschema(opt, key))
+        .filter((opt): opt is z.ZodTypeAny => opt != null)
+      return options.length > 1
+        ? z.discriminatedUnion(discUnion.discriminator, options as any)
+        : options.length === 1
+        ? options[0]
+        : undefined
+      break
+    }
+    case 'ZodIntersection':
+      break
+    case 'ZodTuple': {
+      const {
+        items,
+        _def: { rest },
+      } = schema as z.ZodTuple<any, any>
+      if (typeof key === 'number' && key > 0 && key < items.length) {
+        return items[key]
+      }
+      if (rest) return rest
+      break
+    }
+    case 'ZodRecord': {
+      const { keySchema, valueSchema } = schema as z.ZodRecord<
+        z.ZodTypeAny,
+        z.ZodTypeAny
+      >
+      if (keySchema.safeParse(key).success) return valueSchema
+      break
+    }
+    case 'ZodMap': {
+      const { keySchema, valueSchema } = schema as z.ZodMap<
+        z.ZodTypeAny,
+        z.ZodTypeAny
+      >
+      if (keySchema.safeParse(key).success) return valueSchema
+      break
+    }
+    case 'ZodLazy':
+      return subschema((schema as z.ZodLazy<z.ZodTypeAny>).schema, key)
+    case 'ZodEffects': {
+      const {
+        _def: {
+          effect: { type },
+          schema: innerSchema,
+        },
+      } = schema as z.ZodEffects<z.ZodTypeAny, any>
+      if (type === 'refinement') return subschema(innerSchema, key)
+      break
+    }
+    case 'ZodOptional':
+      return subschema((schema as z.ZodOptional<z.ZodTypeAny>).unwrap(), key)
+    case 'ZodNullable':
+      return subschema((schema as z.ZodNullable<z.ZodTypeAny>).unwrap(), key)
+    case 'ZodDefault':
+      return subschema(
+        (schema as z.ZodDefault<z.ZodTypeAny>).removeDefault(),
+        key
+      )
+    case 'ZodCatch':
+      return subschema((schema as z.ZodCatch<z.ZodTypeAny>).removeCatch(), key)
+    case 'ZodBranded':
+      return subschema(
+        (schema as z.ZodBranded<z.ZodTypeAny, any>)._def.type,
+        key
+      )
+    case 'ZodPipeline':
+      return subschema(
+        (schema as z.ZodPipeline<z.ZodTypeAny, z.ZodTypeAny>)._def.out,
+        key
+      )
+  }
+  return undefined
+}

package/src/FormAction.ts

@@ -0,0 +1,26 @@
+import z from 'zod'
+import { SetMountedAction } from './actions/setMounted'
+import { InitializeAction } from './actions/initialize'
+import { SetValueAction } from './actions/setValue'
+import { SetRawValueAction } from './actions/setRawValue'
+import { SetMetaAction } from './actions/setMeta'
+import { FieldPath } from './FieldPath'
+import { SubmitAction } from './actions/submit'
+import { SubmitSucceededAction } from './actions/submitSucceeded'
+import { SetSubmitStatusAction } from './actions/setSubmitStatus'
+import { AddHandlersAction } from './actions/addHandlers'
+import { RemoveHandlersAction } from './actions/removeHandlers'
+import { ArrayAction } from './actions/arrayActions'
+
+export type FormAction<T extends z.ZodTypeAny> =
+  | SetMountedAction
+  | InitializeAction<T>
+  | SetValueAction<FieldPath>
+  | SetRawValueAction<FieldPath>
+  | SetMetaAction<FieldPath>
+  | AddHandlersAction<T>
+  | RemoveHandlersAction<T>
+  | SubmitAction
+  | SubmitSucceededAction
+  | SetSubmitStatusAction<T>
+  | ArrayAction

package/src/FormContext.ts

@@ -0,0 +1,44 @@
+import React from 'react'
+import z from 'zod'
+import { FieldPath } from './FieldPath'
+import { initialize } from './actions/initialize'
+import { setRawValue } from './actions/setRawValue'
+import { setValue } from './actions/setValue'
+import { submit } from './actions/submit'
+import { setSubmitStatus } from './actions/setSubmitStatus'
+import { SelectFormValues } from './createSelectFormValues'
+import { SelectFieldErrorMap } from './createSelectFieldErrorMap'
+import {
+  createSelectFormStatus,
+  SelectFormStatus,
+} from './createSelectFormStatus'
+import { setMeta } from './actions/setMeta'
+import { addHandlers } from './actions/addHandlers'
+import { removeHandlers } from './actions/removeHandlers'
+import { arrayActions } from './actions/arrayActions'
+
+export const FormContext =
+  React.createContext<FormContextProps<z.ZodTypeAny> | null>(null)
+
+export type FormContextProps<T extends z.ZodTypeAny> = {
+  schema: T
+  inverseSchema: z.ZodType<z.input<T>, any, z.output<T>>
+  root: FieldPath<T>
+  initialize: typeof initialize<T>
+  addHandlers: typeof addHandlers<T>
+  removeHandlers: typeof removeHandlers<T>
+  setMeta: typeof setMeta
+  setRawValue: typeof setRawValue
+  setValue: typeof setValue
+  submit: typeof submit
+  setSubmitStatus: typeof setSubmitStatus<T>
+  arrayActions: typeof arrayActions
+  selectFormStatus: SelectFormStatus
+  selectFieldErrorMap: SelectFieldErrorMap
+  selectFormValues: SelectFormValues<T>
+  getValues: () => z.output<T> | undefined
+  getRawValues: () => unknown
+  getInitialValues: () => z.output<T> | undefined
+  getRawInitialValues: () => unknown
+  getStatus: () => ReturnType<ReturnType<typeof createSelectFormStatus>>
+}

package/src/FormState.ts

@@ -0,0 +1,36 @@
+import z from 'zod'
+
+export type FieldMeta = {
+  touched: boolean
+  visited: boolean
+}
+
+export type SubmitHandler<T extends z.ZodTypeAny> = (
+  values: z.output<T>,
+  options: { initialValues: z.output<T> }
+) => void | Promise<void>
+
+export type SubmitSuccededHandler = () => void
+
+export type SubmitFailedHandler = (error: Error) => void
+
+export type FormState<T extends z.ZodTypeAny> = {
+  mounted: boolean
+  initialized: boolean
+  fieldMeta: Record<string, FieldMeta>
+  rawValues?: unknown
+  values?: z.output<T>
+  submittedValues?: z.output<T>
+  rawSubmittedValues?: z.input<T>
+  rawInitialValues?: unknown
+  initialValues?: z.output<T>
+  validationError?: any
+  submitPromise?: Promise<void>
+  onSubmit: Set<SubmitHandler<T>>
+  onSubmitSucceeded: Set<SubmitSuccededHandler>
+  onSubmitFailed: Set<SubmitFailedHandler>
+  submitting: boolean
+  submitSucceeded: boolean
+  submitFailed: boolean
+  submitError?: Error
+}

package/src/FormStateContext.ts

@@ -0,0 +1,13 @@
+import z from 'zod'
+import React from 'react'
+import { ReactReduxContextValue } from 'react-redux'
+import { FormState } from './FormState'
+import { FormAction } from './FormAction'
+
+export const FormStateContext = React.createContext<ReactReduxContextValue<
+  FormState<z.ZodTypeAny>,
+  FormAction<z.ZodTypeAny>
+> | null>(null)
+
+export type FormStateContext<T extends z.ZodTypeAny> =
+  React.Context<ReactReduxContextValue<FormState<T>, FormAction<T>> | null>

package/src/actions/addHandlers.ts

@@ -0,0 +1,23 @@
+import z from 'zod'
+import {
+  SubmitFailedHandler,
+  SubmitHandler,
+  SubmitSuccededHandler,
+} from '../FormState'
+
+export type Handlers<T extends z.ZodTypeAny> = {
+  onSubmit?: SubmitHandler<T>
+  onSubmitSucceeded?: SubmitSuccededHandler
+  onSubmitFailed?: SubmitFailedHandler
+}
+
+export type AddHandlersAction<T extends z.ZodTypeAny> = ReturnType<
+  typeof addHandlers<T>
+>
+
+export function addHandlers<T extends z.ZodTypeAny>(handlers: Handlers<T>) {
+  return {
+    type: 'addHandlers',
+    ...handlers,
+  } as const
+}