@undermuz/use-form/dist/useForm/reducer.cjs

React library for build forms

"use strict";
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __export = (target, all) => {
  for (var name in all)
    __defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
  if (from && typeof from === "object" || typeof from === "function") {
    for (let key of __getOwnPropNames(from))
      if (!__hasOwnProp.call(to, key) && key !== except)
        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
  }
  return to;
};
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);

// src/useForm/reducer.ts
var reducer_exports = {};
__export(reducer_exports, {
  EnumFormStatus: () => EnumFormStatus,
  FORM_ACTIONS: () => FORM_ACTIONS,
  customErrorsReducer: () => customErrorsReducer,
  errorsReducer: () => errorsReducer,
  fieldsReducer: () => fieldsReducer,
  formReducer: () => formReducer,
  isCancelingReducer: () => isCancelingReducer,
  isSendingReducer: () => isSendingReducer,
  isSuccessReducer: () => isSuccessReducer,
  sendErrorReducer: () => sendErrorReducer,
  testsReducer: () => testsReducer,
  touchedReducer: () => touchedReducer,
  validateReducer: () => validateReducer,
  valuesReducer: () => valuesReducer
});
module.exports = __toCommonJS(reducer_exports);
var import_validate = require("./middlewares/validate.cjs");
var IsFunction = (value) => Boolean(value) && ["[object Function]", "[object AsyncFunction]"].includes(
  {}.toString.call(value)
);
var SET_VALUES = "set_values";
var SET_VALUE = "set_value";
var SET_TESTS = "set_tests";
var SET_TOUCHED_FIELD = "set_touched_field";
var SET_TOUCHED = "set_touched";
var SET_ERRORS = "set_errors";
var SET_CUSTOM_ERRORS = "set_custom_errors";
var SET_CUSTOM_ERROR_FIELD = "set_custom_error_field";
var SET_FIELDS = "set_fields";
var SET_VALIDATE = "set_validate";
var SET_IS_SENDING = "set_is_sending";
var SET_IS_CANCELING = "set_is_canceling";
var SET_IS_SUCCESS = "set_is_success";
var SET_SEND_ERROR = "set_send_error";
var VALIDATE_FORM = "validate_form";
var SEND_FORM = "send_form";
var FORM_ACTIONS = {
  SET_ERRORS,
  SET_VALUES,
  SET_VALUE,
  SET_TESTS,
  SET_TOUCHED_FIELD,
  SET_TOUCHED,
  SET_CUSTOM_ERRORS,
  SET_CUSTOM_ERROR_FIELD,
  SET_FIELDS,
  SET_VALIDATE,
  SET_IS_SENDING,
  SET_IS_CANCELING,
  SET_IS_SUCCESS,
  SET_SEND_ERROR,
  VALIDATE_FORM,
  SEND_FORM
};
var EnumFormStatus = /* @__PURE__ */ ((EnumFormStatus2) => {
  EnumFormStatus2["Initial"] = "initial";
  return EnumFormStatus2;
})(EnumFormStatus || {});
var valuesReducer = (state, action) => {
  switch (action.type) {
    case FORM_ACTIONS.SET_VALUES:
      if (IsFunction(action.payload.values)) {
        return action.payload.values(state);
      }
      return action.payload.values;
    case FORM_ACTIONS.SET_VALUE:
      if (IsFunction(action.payload.value)) {
        return {
          ...state,
          [action.payload.name]: action.payload.value(
            state[action.payload.name]
          )
        };
      }
      return {
        ...state,
        [action.payload.name]: action.payload.value
      };
    default:
      return state;
  }
};
var testsReducer = (state, action) => {
  switch (action.type) {
    case FORM_ACTIONS.SET_TESTS:
      if (IsFunction(action.payload.tests)) {
        return action.payload.tests(state);
      }
      return action.payload.tests;
    default:
      return state;
  }
};
var touchedReducer = (state, action) => {
  switch (action.type) {
    case FORM_ACTIONS.SET_TOUCHED:
      if (IsFunction(action.payload.touched)) {
        return action.payload.touched(state);
      }
      return action.payload.touched;
    case FORM_ACTIONS.SET_TOUCHED_FIELD: {
      const { name, value = true } = action.payload;
      let newTouched = state;
      if (value && state.indexOf(name) === -1) {
        newTouched = [...state, name];
      } else if (!value && state.indexOf(name) > -1) {
        newTouched = state.filter((_n) => _n !== name);
      }
      return newTouched;
    }
    default:
      return state;
  }
};
var errorsReducer = (state, action) => {
  switch (action.type) {
    case FORM_ACTIONS.SET_ERRORS:
      if (IsFunction(action.payload.errors)) {
        return action.payload.errors(state);
      }
      return action.payload.errors;
    default:
      return state;
  }
};
var customErrorsReducer = (state, action) => {
  switch (action.type) {
    case FORM_ACTIONS.SET_CUSTOM_ERRORS:
      if (IsFunction(action.payload.errors)) {
        return action.payload.errors(state);
      }
      return action.payload.errors;
    case FORM_ACTIONS.SET_CUSTOM_ERROR_FIELD: {
      const { name, value } = action.payload;
      return { ...state, [name]: value };
    }
    default:
      return state;
  }
};
var fieldsReducer = (state, action) => {
  switch (action.type) {
    case FORM_ACTIONS.SET_FIELDS:
      if (IsFunction(action.payload.fields)) {
        return action.payload.fields(state);
      }
      return action.payload.fields;
    default:
      return state;
  }
};
var validateReducer = (state, action) => {
  switch (action.type) {
    case FORM_ACTIONS.SET_VALIDATE:
      if (!action.payload.validate) {
        return import_validate.getFormErrors;
      }
      return action.payload.validate;
    default:
      return state;
  }
};
var isSendingReducer = (state, action) => {
  switch (action.type) {
    case FORM_ACTIONS.SET_IS_SENDING:
      return Boolean(action.payload);
    default:
      return state;
  }
};
var isCancelingReducer = (state, action) => {
  switch (action.type) {
    case FORM_ACTIONS.SET_IS_CANCELING:
      return Boolean(action.payload);
    default:
      return state;
  }
};
var isSuccessReducer = (state, action) => {
  switch (action.type) {
    case FORM_ACTIONS.SET_IS_SUCCESS:
      return Boolean(action.payload);
    default:
      return state;
  }
};
var sendErrorReducer = (state, action) => {
  switch (action.type) {
    case FORM_ACTIONS.SET_SEND_ERROR:
      return action.payload || null;
    default:
      return state;
  }
};
var formReducer = (state, action) => {
  const nextState = {
    ...state,
    values: valuesReducer(state.values, action),
    fields: fieldsReducer(state.fields, action),
    tests: testsReducer(state.tests, action),
    touched: touchedReducer(state.touched, action),
    errors: errorsReducer(state.errors, action),
    customErrors: customErrorsReducer(state.customErrors, action),
    validate: validateReducer(state.validate, action),
    isSending: isSendingReducer(state.isSending, action),
    isCanceling: isCancelingReducer(state.isCanceling, action),
    isSuccess: isSuccessReducer(state.isSuccess, action),
    sendError: sendErrorReducer(state.sendError, action)
  };
  return nextState;
};
// Annotate the CommonJS export names for ESM import in node:
0 && (module.exports = {
  EnumFormStatus,
  FORM_ACTIONS,
  customErrorsReducer,
  errorsReducer,
  fieldsReducer,
  formReducer,
  isCancelingReducer,
  isSendingReducer,
  isSuccessReducer,
  sendErrorReducer,
  testsReducer,
  touchedReducer,
  validateReducer,
  valuesReducer
});