@undermuz/react-json-form/dist/utils.mjs

Generate JSON-based forms with react

// src/utils.ts
import { useMemo } from "react";
import { isArray } from "underscore";
import { EnumSchemeItemType } from "./types.mjs";
var nonFieldTypes = [
  EnumSchemeItemType.Submit
];
var isNumeric = (v) => !isNaN(parseInt(v));
var isEmail = (value) => !value || value + "" == "" || value.indexOf("@") > -1;
var isPhone = (value) => {
  if (!value)
    return true;
  const phoneFilterExp = /[^\+\d]/gim;
  const phoneValidateExp = /^\+\d{7,}/gim;
  value = value.replace(phoneFilterExp, "");
  if (value[0] == "8" || value[0] == "7") {
    value = `+7${value.substring(1)}`;
  }
  return phoneValidateExp.test(value);
};
var isEmailOrPhone = (value) => {
  if (isEmail(value)) {
    return true;
  }
  if (isPhone(value)) {
    return true;
  }
  return false;
};
var isRegexp = (regexp) => (value) => regexp.test(`${value}`);
var isNotRegexp = (regexp) => (value) => !regexp.test(`${value}`);
var isString = (value) => typeof value === "string";
var isStringMaxLength = (length) => (value) => isString(value) && value.length <= length;
var isStringMinLength = (length) => (value) => isString(value) && value.length >= length;
var isStringMinMaxLength = (min_length, max_length) => (value) => isString(value) && value.length >= min_length && value.length <= max_length;
var defaultFieldTests = {
  isNumeric,
  isEmail,
  isPhone,
  isEmailOrPhone,
  Boolean,
  isRegexp,
  isNotRegexp,
  isString,
  isStringMaxLength,
  isStringMinLength,
  isStringMinMaxLength
};
var getDefValueForItem = (item) => {
  const {
    def_value = "",
    type = EnumSchemeItemType.Text,
    settings = {},
    multiple = false
  } = item;
  if (def_value) {
    return def_value;
  }
  if (type == "checkbox")
    return false;
  if (type == "files" && settings?.multiple)
    return [];
  if (type == "files" && !settings?.multiple)
    return null;
  if (type == "widget") {
    if (multiple) {
      return [];
    }
    return {};
  }
  if (type == EnumSchemeItemType.GeoCoordinates)
    return {
      address: "",
      lat: 0,
      lng: 0
    };
  if (type == "select") {
    if (settings.multiple) {
      return [];
    }
    if (settings.options && settings.options.length) {
    } else {
      return 0;
    }
  }
  return def_value;
};
var getFieldsScheme = (scheme) => {
  return scheme.filter(
    (item) => item.type && !nonFieldTypes.includes(item.type)
  );
};
var useFieldsScheme = (scheme) => {
  return useMemo(() => {
    return getFieldsScheme(scheme);
  }, [scheme]);
};
var getDefValueForScheme = (scheme) => {
  return getFieldsScheme(scheme).reduce(
    (new_value, current) => ({
      ...new_value,
      [current.name]: current.def_value
    }),
    {}
  );
};
var useDefSchemeValue = (scheme) => {
  return useMemo(() => {
    return getDefValueForScheme(scheme);
  }, [scheme]);
};
var useSafeValue = (unsafeValue, defValue, multiple = false, fillArrayDefault = true) => {
  return useMemo(() => {
    if (unsafeValue === void 0 || !multiple && Object.keys(unsafeValue).length === 0 || multiple && (!isArray(unsafeValue) || unsafeValue.length == 0)) {
      if (multiple) {
        if (!fillArrayDefault) {
          return [];
        }
        return [{ ...defValue, id: 1 }];
      }
      return { ...defValue };
    }
    return unsafeValue;
  }, [unsafeValue, multiple, defValue]);
};
var getRules = (rules, tests = defaultFieldTests) => {
  if (!rules)
    return [];
  const newRules = [];
  for (const rule of rules) {
    const [funcs, text] = rule;
    const newFuncs = [];
    for (let index = 0; index < funcs.length; index++) {
      const func = funcs[index];
      if (typeof func !== "string") {
        newFuncs.push(func);
        continue;
      }
      const [funcName, funcArgs] = func.split(":");
      if (!tests[funcName]) {
        throw new Error(`Cannot find test by name: ${funcName}`);
      }
      if (funcArgs) {
        const fn = tests[funcName];
        newFuncs.push(fn(...JSON.parse(funcArgs)));
      } else {
        const fn = tests[funcName];
        newFuncs.push(fn);
      }
    }
    newRules.push([newFuncs, text]);
  }
  return newRules;
};
var useSchemeToForm = (props) => {
  const { scheme, value, tests, onChange, onError } = props;
  return useMemo(() => {
    const config = {
      fields: {},
      // options: {
      //     debug: true,
      // },
      value,
      onChange,
      onError
    };
    for (const item of scheme) {
      const rules = getRules(item.rules, tests);
      config.fields[item.name] = {
        label: item.title,
        rules,
        initialValue: item.def_value
      };
    }
    return config;
  }, [scheme, value, onChange, onError]);
};
export {
  defaultFieldTests,
  getDefValueForItem,
  getDefValueForScheme,
  getFieldsScheme,
  isEmail,
  isEmailOrPhone,
  isNotRegexp,
  isNumeric,
  isPhone,
  isRegexp,
  isString,
  isStringMaxLength,
  isStringMinLength,
  isStringMinMaxLength,
  nonFieldTypes,
  useDefSchemeValue,
  useFieldsScheme,
  useSafeValue,
  useSchemeToForm
};