mobx-formkit 1.0.0

package/src/models/OptionsModel.ts

@@ -0,0 +1,100 @@
+export enum OptionsEnum {
+  uniqueId = 'uniqueId',
+  fallback = 'fallback',
+  fallbackValue = 'fallbackValue',
+  defaultGenericError = 'defaultGenericError',
+  submitThrowsError = 'submitThrowsError',
+  showErrorsOnInit = 'showErrorsOnInit',
+  showErrorsOnSubmit = 'showErrorsOnSubmit',
+  showErrorsOnBlur = 'showErrorsOnBlur',
+  showErrorsOnChange = 'showErrorsOnChange',
+  showErrorsOnClear = 'showErrorsOnClear',
+  showErrorsOnReset = 'showErrorsOnReset',
+  validateOnInit = 'validateOnInit',
+  validateOnSubmit = 'validateOnSubmit',
+  validateOnBlur = 'validateOnBlur',
+  validateOnChange = 'validateOnChange',
+  validateOnChangeAfterInitialBlur = 'validateOnChangeAfterInitialBlur',
+  validateOnChangeAfterSubmit = 'validateOnChangeAfterSubmit',
+  validateDisabledFields = 'validateDisabledFields',
+  validateDeletedFields = 'validateDeletedFields',
+  validatePristineFields = 'validatePristineFields',
+  validateTrimmedValue = 'validateTrimmedValue',
+  validateOnClear = 'validateOnClear',
+  validateOnReset = 'validateOnReset',
+  strictSet = 'strictSet',
+  strictUpdate = 'strictUpdate',
+  strictDelete = 'strictDelete',
+  strictSelect = 'strictSelect',
+  softDelete = 'softDelete',
+  retrieveOnlyDirtyFieldsValues = 'retrieveOnlyDirtyFieldsValues',
+  retrieveOnlyEnabledFieldsValues = 'retrieveOnlyEnabledFieldsValues',
+  retrieveOnlyEnabledFieldsErrors = 'retrieveOnlyEnabledFieldsErrors',
+  retrieveNullifiedEmptyStrings = 'retrieveNullifiedEmptyStrings',
+  removeNullishValuesInArrays = 'removeNullishValuesInArrays',
+  preserveDeletedFieldsValues = 'preserveDeletedFieldsValues',
+  autoTrimValue = 'autoTrimValue',
+  autoParseNumbers = 'autoParseNumbers',
+  validationDebounceWait = 'validationDebounceWait',
+  validationDebounceOptions = 'validationDebounceOptions',
+  stopValidationOnError = 'stopValidationOnError',
+  validationPluginsOrder = 'validationPluginsOrder',
+  resetValidationBeforeValidate = 'resetValidationBeforeValidate',
+  applyInputConverterOnInit = 'applyInputConverterOnInit',
+  applyInputConverterOnSet = 'applyInputConverterOnSet',
+  applyInputConverterOnUpdate = 'applyInputConverterOnUpdate',
+  bubbleUpErrorMessages = 'bubbleUpErrorMessages',
+}
+
+export interface OptionsModel {
+  [OptionsEnum.uniqueId]?: (field: any) => string | undefined;
+  [OptionsEnum.fallback]?: boolean;
+  [OptionsEnum.fallbackValue]?: any;
+  [OptionsEnum.defaultGenericError]?: null | string;
+  [OptionsEnum.submitThrowsError]?: boolean;
+  [OptionsEnum.showErrorsOnInit]?: boolean;
+  [OptionsEnum.showErrorsOnSubmit]?: boolean;
+  [OptionsEnum.showErrorsOnBlur]?: boolean;
+  [OptionsEnum.showErrorsOnChange]?: boolean;
+  [OptionsEnum.showErrorsOnClear]?: boolean;
+  [OptionsEnum.showErrorsOnReset]?: boolean;
+  [OptionsEnum.validateOnInit]?: boolean;
+  [OptionsEnum.validateOnSubmit]?: boolean;
+  [OptionsEnum.validateOnBlur]?: boolean;
+  [OptionsEnum.validateOnChange]?: boolean;
+  [OptionsEnum.validateOnChangeAfterInitialBlur]?: boolean;
+  [OptionsEnum.validateOnChangeAfterSubmit]?: boolean;
+  [OptionsEnum.validateOnClear]?: boolean;
+  [OptionsEnum.validateOnReset]?: boolean;
+  [OptionsEnum.validateDisabledFields]?: boolean;
+  [OptionsEnum.validateDeletedFields]?: boolean;
+  [OptionsEnum.validatePristineFields]?: boolean;
+  [OptionsEnum.validateTrimmedValue]?: boolean;
+  [OptionsEnum.strictSet]?: boolean;
+  [OptionsEnum.strictUpdate]?: boolean;
+  [OptionsEnum.strictDelete]?: boolean;
+  [OptionsEnum.strictSelect]?: boolean;
+  [OptionsEnum.softDelete]?: boolean;
+  [OptionsEnum.retrieveOnlyDirtyFieldsValues]?: boolean;
+  [OptionsEnum.retrieveOnlyEnabledFieldsValues]?: boolean;
+  [OptionsEnum.retrieveOnlyEnabledFieldsErrors]?: boolean;
+  [OptionsEnum.retrieveNullifiedEmptyStrings]?: boolean;
+  [OptionsEnum.removeNullishValuesInArrays]?: boolean;
+  [OptionsEnum.preserveDeletedFieldsValues]?: boolean;
+  [OptionsEnum.autoTrimValue]?: boolean;
+  [OptionsEnum.autoParseNumbers]?: boolean;
+  [OptionsEnum.validationDebounceWait]?: number;
+  [OptionsEnum.validationDebounceOptions]?: {
+    leading?: boolean;
+    trailing?: boolean;
+  };
+  [OptionsEnum.stopValidationOnError]?: boolean;
+  [OptionsEnum.validationPluginsOrder]?: undefined | string[];
+  [OptionsEnum.resetValidationBeforeValidate]?: boolean;
+  [OptionsEnum.applyInputConverterOnInit]?: boolean,
+  [OptionsEnum.applyInputConverterOnSet]?: boolean,
+  [OptionsEnum.applyInputConverterOnUpdate]?: boolean,
+  [OptionsEnum.bubbleUpErrorMessages]?: boolean,
+}
+
+export default OptionsModel;

package/src/models/SharedActionsInterface.ts

@@ -0,0 +1,30 @@
+import { ValidateOptions } from "./ValidatorInterface";
+
+export interface SubmitOptions {
+  execOnSubmitHook: boolean,
+  execValidationHooks: boolean,
+  validate: boolean
+};
+
+export interface SubmitHooks {
+  onSubmit?(instance: any): void
+  onSuccess?(instance: any): void
+  onError?(instance: any): void
+}
+
+export interface SharedActionsInterface {
+  validate(opt?: ValidateOptions, obj?: ValidateOptions): Promise<any>;
+  submit(hooks?: SubmitHooks, opt?: SubmitOptions): Promise<any>;
+  check(prop: string, deep?: boolean): boolean;
+  deepCheck(type: string, prop: string, fields: any): any;
+  update(fields: any): void;
+  deepUpdate(fields: any, path: string, recursion: boolean): void;
+  get(prop?: any, strict?: boolean): any;
+  deepGet(prop: any, fields: any): any;
+  set(prop: any, data?: any): void;
+  deepSet(prop: any, data: any, path: string, recursion: boolean): void;
+  add(obj?: any): any;
+  del(path?: string): any;
+}
+
+export default SharedActionsInterface;

package/src/models/SharedEventsInterface.ts

@@ -0,0 +1,8 @@
+export interface SharedEventsInterface {
+  MOBXEvent(config: any): void;
+  dispose(config: any): void;
+  disposeAll(): void;
+  disposeSingle(config: any): void;
+}
+
+export default SharedEventsInterface;

package/src/models/SharedHelpersInterface.ts

@@ -0,0 +1,12 @@
+export interface SharedHelpersInterface<F extends Record<string, any> = Record<string, any>> {
+  $(key: keyof F & (string | number)): any;
+  values(): { [K in keyof F]?: F[K] };
+  errors(): { [K in keyof F]?: any };
+  labels(): { [K in keyof F]?: any };
+  placeholders(): { [K in keyof F]?: any };
+  defaults(): { [K in keyof F]?: any };
+  initials(): { [K in keyof F]?: any };
+  types(): { [K in keyof F]?: any };
+}
+
+export default SharedHelpersInterface;

package/src/models/SharedInitializerInterface.ts

@@ -0,0 +1,6 @@
+export interface SharedInitializerInterface {
+  initFields(initial: any, update: boolean): void;
+  initField(key: string, path: string, data: any, update: boolean): any;
+}
+
+export default SharedInitializerInterface;

package/src/models/SharedUtilsInterface.ts

@@ -0,0 +1,10 @@
+export interface SharedUtilsInferface {
+  select(path: string|number, fields?: any, isStrict?: boolean): any;
+  container(path?: string | null): any;
+  has(path: string): boolean;
+  map(cb: any): any;
+  each(iteratee: any, fields?: any, depth?: number): any;
+  reduce(iteratee: any, acc: any): any;
+}
+
+export default SharedUtilsInferface;

package/src/models/StateInterface.ts

@@ -0,0 +1,44 @@
+import {BindingsInterface} from "./BindingsInterface";
+import {FormInterface} from "./FormInterface";
+import {OptionsInterface} from "./OptionsInterface";
+
+export enum RuntimeMode {
+  mixed = "mixed",
+  unified = "unified",
+  separated = "separated",
+}
+
+export interface StateInterface {
+  mode: RuntimeMode;
+  strict: boolean;
+  form: FormInterface;
+  options: OptionsInterface;
+  bindings: BindingsInterface;
+
+  $struct: string[];
+  $extra: any;
+
+  disposers: {
+    interceptor: any;
+    observer: any;
+  };
+
+  initial: {
+    props: any;
+    fields: any;
+  };
+
+  current: {
+    props: any;
+    fields: any;
+  };
+
+  initProps(initial: any): void;
+  struct(data?: string[]): string[];
+  get(type: any, subtype: any): any;
+  set(type: string, subtype: string, state: any): void;
+  extra(data?: any): any | null;
+  observeOptions(): void;
+}
+
+export default StateInterface;

package/src/models/ValidatorInterface.ts

@@ -0,0 +1,88 @@
+import Form from "../Form";
+import Field from "../Field";
+import { FieldInterface } from "./FieldInterface";
+import { FormInterface } from "./FormInterface";
+import { StateInterface } from "./StateInterface";
+
+export interface ValidatorConstructor {
+  form: FormInterface | null;
+  plugins: ValidationPlugins;
+}
+
+export interface ValidateOptionsInterface {
+  showErrors?: boolean;
+  related?: boolean;
+  field?: FieldInterface;
+  path?: string;
+}
+
+export type ValidateOptions = string | ValidateOptionsInterface | Form | Field;
+
+export interface ValidatorInterface {
+  promises: Promise<any>[];
+  form: FormInterface | null;
+  drivers: any;
+  plugins: ValidationPlugins;
+  error: string | null;
+  initDrivers(): void;
+  validate(opt?: ValidateOptions, obj?: ValidateOptions): Promise<any>;
+  validateField(opt: ValidateOptionsInterface): void;
+  validateRelatedFields(field: any, showErrors: boolean): void;
+}
+
+export type ValidationPackage = any;
+
+export type ExtendPlugin<TValidator = ValidationPackage> = (args: {
+  validator: TValidator;
+  form: FormInterface;
+}) => void;
+
+export interface ValidationPluginConfig<TValidator = ValidationPackage> {
+  package?: TValidator;
+  schema?: any;
+  options?: any;
+  extend?: ExtendPlugin<TValidator>;
+}
+
+export interface ValidationPluginConstructor<TValidator = ValidationPackage> {
+  config: ValidationPluginConfig<TValidator>;
+  state: StateInterface | null;
+  promises: Promise<unknown>[];
+}
+
+export interface ValidationPluginInterface<TValidator = ValidationPackage>
+  extends ValidationPluginConstructor<TValidator> {
+  validator: TValidator;
+  schema?: any;
+  extend?: ExtendPlugin<TValidator>;
+  validate(field: FieldInterface): void;
+  class?(constructor: ValidationPluginConstructor<TValidator>): void;
+}
+
+export type ValidationPlugin<TValidator = ValidationPackage> = {
+  class: any;
+  config?: ValidationPluginConfig<TValidator>;
+};
+
+export interface ValidationPlugins {
+  [key: string]: ValidationPlugin | undefined;
+  vjf?: ValidationPlugin;
+  dvr?: ValidationPlugin;
+  ajv?: ValidationPlugin;
+  yup?: ValidationPlugin;
+  zod?: ValidationPlugin;
+  joi?: ValidationPlugin;
+  valibot?: ValidationPlugin;
+  vinejs?: ValidationPlugin;
+}
+
+export type DriversMap = {
+  [key in keyof ValidationPlugins]: ValidationPluginInterface;
+}
+
+export enum ValidationHooks {
+  onSuccess = 'onSuccess',
+  onError = 'onError',
+}
+
+export default ValidatorInterface;

package/src/parser.ts

@@ -0,0 +1,327 @@
+import { each, get, has, isEmpty, isPlainObject, merge, set, transform } from "lodash";
+import { FieldPropsEnum, SeparatedPropsMode } from "./models/FieldProps";
+import {
+  $try,
+  isArrayOfStrings,
+  isArrayOfObjects,
+  hasUnifiedProps,
+  allowNested,
+  pathToStruct,
+  isEmptyArray,
+} from "./utils";
+
+const defaultValue = ({
+  type = undefined,
+  value = undefined,
+  nullable = undefined,
+  isEmptyArray = false,
+  fallbackValueOption = "",
+}: any): null | false | 0 | [] | "" => {
+  if (Array.isArray(value) || isEmptyArray) return [];
+  if (nullable || value instanceof Date || type === "date" || type === "datetime-local") return null;
+  if (typeof value === 'number' || type === "number") return 0;
+  if (typeof value === 'boolean' || type === "checkbox") return false;
+  if (typeof value === 'string' || type === "file") return "";
+  return fallbackValueOption;
+};
+
+const parsePath = (path: any): string => {
+  let $path = String(path ?? '');
+  $path = $path.replace(/\[/g, ".");
+  $path = $path.replace(/\]/g, "");
+  return $path;
+};
+
+const parseInput = (
+  input: (...args: any[]) => any,
+  { fallbackValueOption = "", type, isEmptyArray, separated, unified, fallback }: any
+) =>
+  input(
+    $try(
+      separated,
+      unified,
+      fallback,
+      defaultValue({
+        fallbackValueOption,
+        type,
+        isEmptyArray,
+      })
+    )
+  );
+
+const parseArrayProp = (val: any, prop: string, removeNullishValuesInArrays: boolean): any => {
+  const values = Object.values(val);
+  const isValProp: boolean = ([
+    FieldPropsEnum.value,
+    FieldPropsEnum.initial,
+    FieldPropsEnum.default,
+  ] as string[]).includes(prop)
+
+  if (removeNullishValuesInArrays && isValProp) {
+    return values.filter(v => v !== null && v !== undefined && v !== "");
+  }
+
+  return values;
+};
+
+const parseCheckArray = (field: any, value: any, prop: string, removeNullishValuesInArrays: boolean) => {
+  if (field.incremental && value !== null && typeof value === 'object' && isEmpty(value)) return [];
+  return field.hasIncrementalKeys ? parseArrayProp(value, prop, removeNullishValuesInArrays) : value;
+}
+
+const parseCheckOutput = (field: any, prop: string, retrieveNullifiedEmptyStrings = false) => {
+  if (prop === FieldPropsEnum.value || prop.startsWith("value.")) {
+    const base = field.$output ? field.$output(field[FieldPropsEnum.value]) : field[FieldPropsEnum.value]
+    const value = prop.startsWith("value.") ? get(base, prop.substring(6)) : base
+    if (typeof value === 'string' && isEmpty(value) && retrieveNullifiedEmptyStrings) return null
+    return value;
+  }
+  return field[prop];
+}
+
+const defineFieldsFromStruct = (struct: string[], add: boolean = false) =>
+  struct.reduceRight(
+    ($, name) => {
+      const obj: any = {};
+      if (name.endsWith("[]")) {
+        const val = add ? [$] : [];
+        obj[name.replace(/\[\]$/, "")] = val;
+        return obj;
+      }
+      // no brakets
+      const prev = struct[struct.indexOf(name) - 1];
+      const stop = !!prev && prev.endsWith("[]") && struct[struct.length - 1] === name;
+      if (!add && stop) return obj;
+      obj[name] = $;
+      return obj;
+    },
+    {}
+  );
+
+const handleFieldsArrayOfStrings = ($fields: any, add = false) => {
+  let fields = $fields;
+  // handle array with field struct (strings)
+  if (isArrayOfStrings(fields)) {
+    fields = transform(
+      fields,
+      ($obj, $) => {
+        const pathStruct = $.split(".");
+        // as array of strings (with empty values)
+        if (!pathStruct.length) return Object.assign($obj, { [$]: "" });
+        // define flat or nested fields from pathStruct
+        return merge($obj, defineFieldsFromStruct(pathStruct, add));
+      },
+      {}
+    );
+  }
+  return fields;
+};
+
+const handleFieldsArrayOfObjects = ($fields: any) => {
+  let fields = $fields;
+  // handle array of objects (with unified props)
+  if (isArrayOfObjects(fields)) {
+    fields = transform(
+      fields,
+      ($obj, field) => {
+        if (hasUnifiedProps({ fields: { field } }) && !has(field, FieldPropsEnum.name)) return undefined;
+        return Object.assign($obj, { [field.name]: field });
+      },
+      {}
+    );
+  }
+  return fields;
+};
+
+const handleFieldsNested = (fields: any, strictProps: boolean = true): any =>
+  transform(
+    fields,
+    (obj, field, key) => {
+      if (allowNested(field, strictProps)) {
+        // define nested field
+        return Object.assign(obj, {
+          [key]: {
+            fields: isEmptyArray(field) ? [] : handleFieldsNested(field),
+          },
+        });
+      }
+      return Object.assign(obj, { [key]: field });
+    },
+    {}
+  );
+
+/* mapNestedValuesToUnifiedValues
+
+FROM:
+
+{
+  street: '123 Fake St.',
+  zip: '12345',
+}
+
+TO:
+
+[{
+  name: 'street'
+  value: '123 Fake St.',
+}, {
+  name: 'zip'
+  value: '12345',
+}]
+
+*/
+const mapNestedValuesToUnifiedValues = (data: Record<string, any>): any =>
+  isPlainObject(data)
+    ? Object.entries(data).map(([name, value]) => ({ value, name }))
+    : undefined;
+
+/* reduceValuesToUnifiedFields
+
+FROM:
+
+{
+  name: 'fatty',
+  address: {
+    street: '123 Fake St.',
+    zip: '12345',
+  },
+};
+
+TO:
+
+{
+  name: {
+    value: 'fatty',
+    fields: undefined
+  },
+  address: {
+    value: {
+      street: '123 Fake St.',
+      zip: '12345'
+    },
+    fields: [ ... ]
+  },
+};
+
+*/
+const reduceValuesToUnifiedFields = (values: Record<string, any>): Record<string, any> =>
+  transform(
+    values,
+    (obj, value, key) =>
+      Object.assign(obj, {
+        [key]: {
+          value,
+          fields: mapNestedValuesToUnifiedValues(value),
+        },
+      }),
+    {}
+  );
+
+/*
+  Fallback Unified Props to Separated Mode
+*/
+const handleFieldsPropsFallback = (
+  fields: any,
+  initial: any,
+  fallback: any
+) => {
+  if (!has(initial, SeparatedPropsMode.values)) return fields;
+  // if the 'values' object is passed in constructor
+  // then update the fields definitions
+  let { values } = initial;
+  if (hasUnifiedProps({ fields: initial.fields })) {
+    values = reduceValuesToUnifiedFields(values);
+  }
+  return merge(
+    fields,
+    transform(
+      values,
+      (result: any, v, k) => {
+        if (Array.isArray(fields[k])) result[k] = v;
+        if (!(k in fields) && (!isNaN(Number(k)) || fallback)) result[k] = v;
+      },
+      {}
+    )
+  );
+};
+
+const mergeSchemaDefaults = (fields: any, validator: any) => {
+  if (validator) {
+    const schema = get(validator.plugins, "ajv.config.schema");
+    if (isEmpty(fields) && schema && !!schema.properties) {
+      each(schema.properties, (prop, key) => {
+        set(fields, key, {
+          value: prop.default,
+          label: prop.title,
+        });
+      });
+    }
+  }
+  return fields;
+};
+
+const prepareFieldsData = (
+  initial: any,
+  strictProps: boolean = true,
+  fallback: boolean = true,
+) => {
+  let fields = merge(
+    handleFieldsArrayOfStrings(initial.fields, false),
+    handleFieldsArrayOfStrings(initial.struct, false)
+  );
+
+  fields = handleFieldsArrayOfObjects(fields);
+  fields = handleFieldsPropsFallback(fields, initial, fallback);
+  fields = handleFieldsNested(fields, strictProps);
+
+  return fields;
+};
+
+const pathToFieldsTree = (
+  struct: any,
+  path: string,
+  n: number = 0,
+  add: boolean = false
+) => {
+  const $struct = (Array.isArray(struct) ? struct : Object.values(struct)).filter((item: any) => typeof item === 'string');
+  const structPath = pathToStruct(path);
+  const structArray = $struct.filter((item) =>
+    item.startsWith(structPath)
+  );
+  const $tree = handleFieldsArrayOfStrings(structArray, add);
+  const $structPath = structPath.replace(/\[\]/g, `[${n}]`);
+  const fields = handleFieldsNested(get($tree, $structPath));
+
+  // fix issues #614 & #615
+  $struct.length && $struct
+    .filter(s => s.startsWith(path + '[]'))
+    .map(s => s.substring((path + '[].').length))
+    .filter(s => s.endsWith('[]'))
+    .map(s => s.substring(0, s.length - 2))
+    .forEach(s => {
+      const ss = s.split('.')
+      let t = fields[0]?.fields
+      for (let i = 0; i < ss.length; i++) {
+        t = t?.[ss[i]]?.[FieldPropsEnum.fields]
+        if (!t) break;
+      }
+      if (t)
+        delete t[0]
+    });
+
+  return fields;
+};
+
+export {
+  defaultValue,
+  parseInput,
+  parsePath,
+  parseArrayProp,
+  parseCheckArray,
+  parseCheckOutput,
+  mergeSchemaDefaults,
+  handleFieldsNested,
+  handleFieldsArrayOfStrings,
+  prepareFieldsData,
+  pathToFieldsTree,
+};