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

Generate JSON-based forms with react

"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/utils.ts
var utils_exports = {};
__export(utils_exports, {
  defaultFieldTests: () => defaultFieldTests,
  getDefValueForItem: () => getDefValueForItem,
  getDefValueForScheme: () => getDefValueForScheme,
  getFieldsScheme: () => getFieldsScheme,
  isEmail: () => isEmail,
  isEmailOrPhone: () => isEmailOrPhone,
  isNotRegexp: () => isNotRegexp,
  isNumeric: () => isNumeric,
  isPhone: () => isPhone,
  isRegexp: () => isRegexp,
  isString: () => isString,
  isStringMaxLength: () => isStringMaxLength,
  isStringMinLength: () => isStringMinLength,
  isStringMinMaxLength: () => isStringMinMaxLength,
  nonFieldTypes: () => nonFieldTypes,
  useDefSchemeValue: () => useDefSchemeValue,
  useFieldsScheme: () => useFieldsScheme,
  useSafeValue: () => useSafeValue,
  useSchemeToForm: () => useSchemeToForm
});
module.exports = __toCommonJS(utils_exports);
var import_react = require("react");
var import_underscore = require("underscore");
var import_types = require("./types.js");
var nonFieldTypes = [
  import_types.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 = import_types.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 == import_types.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 (0, import_react.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 (0, import_react.useMemo)(() => {
    return getDefValueForScheme(scheme);
  }, [scheme]);
};
var useSafeValue = (unsafeValue, defValue, multiple = false, fillArrayDefault = true) => {
  return (0, import_react.useMemo)(() => {
    if (unsafeValue === void 0 || !multiple && Object.keys(unsafeValue).length === 0 || multiple && (!(0, import_underscore.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 (0, import_react.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]);
};
// Annotate the CommonJS export names for ESM import in node:
0 && (module.exports = {
  defaultFieldTests,
  getDefValueForItem,
  getDefValueForScheme,
  getFieldsScheme,
  isEmail,
  isEmailOrPhone,
  isNotRegexp,
  isNumeric,
  isPhone,
  isRegexp,
  isString,
  isStringMaxLength,
  isStringMinLength,
  isStringMinMaxLength,
  nonFieldTypes,
  useDefSchemeValue,
  useFieldsScheme,
  useSafeValue,
  useSchemeToForm
});