@tachybase/schema 0.23.41 → 0.23.47

package/lib/core/shared/checkers.js

@@ -0,0 +1,109 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+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);
+var checkers_exports = {};
+__export(checkers_exports, {
+  isArrayField: () => isArrayField,
+  isArrayFieldState: () => isArrayFieldState,
+  isDataField: () => isDataField,
+  isDataFieldState: () => isDataFieldState,
+  isField: () => isField,
+  isFieldState: () => isFieldState,
+  isForm: () => isForm,
+  isFormState: () => isFormState,
+  isGeneralField: () => isGeneralField,
+  isGeneralFieldState: () => isGeneralFieldState,
+  isObjectField: () => isObjectField,
+  isObjectFieldState: () => isObjectFieldState,
+  isQuery: () => isQuery,
+  isVoidField: () => isVoidField,
+  isVoidFieldState: () => isVoidFieldState
+});
+module.exports = __toCommonJS(checkers_exports);
+var import_shared = require("../../shared");
+var import_models = require("../models");
+const isForm = /* @__PURE__ */ __name((node) => {
+  return node instanceof import_models.Form;
+}, "isForm");
+const isGeneralField = /* @__PURE__ */ __name((node) => {
+  return node instanceof import_models.Field || node instanceof import_models.VoidField;
+}, "isGeneralField");
+const isField = /* @__PURE__ */ __name((node) => {
+  return node instanceof import_models.Field;
+}, "isField");
+const isArrayField = /* @__PURE__ */ __name((node) => {
+  return node instanceof import_models.ArrayField;
+}, "isArrayField");
+const isObjectField = /* @__PURE__ */ __name((node) => {
+  return node instanceof import_models.ObjectField;
+}, "isObjectField");
+const isVoidField = /* @__PURE__ */ __name((node) => {
+  return node instanceof import_models.VoidField;
+}, "isVoidField");
+const isFormState = /* @__PURE__ */ __name((state) => {
+  if ((0, import_shared.isFn)(state == null ? void 0 : state.initialize)) return false;
+  return (state == null ? void 0 : state.displayName) === "Form";
+}, "isFormState");
+const isFieldState = /* @__PURE__ */ __name((state) => {
+  if ((0, import_shared.isFn)(state == null ? void 0 : state.initialize)) return false;
+  return (state == null ? void 0 : state.displayName) === "Field";
+}, "isFieldState");
+const isGeneralFieldState = /* @__PURE__ */ __name((node) => {
+  var _a;
+  if ((0, import_shared.isFn)(node == null ? void 0 : node.initialize)) return false;
+  return ((_a = node == null ? void 0 : node.displayName) == null ? void 0 : _a.indexOf("Field")) > -1;
+}, "isGeneralFieldState");
+const isArrayFieldState = /* @__PURE__ */ __name((state) => {
+  if ((0, import_shared.isFn)(state == null ? void 0 : state.initialize)) return false;
+  return (state == null ? void 0 : state.displayName) === "ArrayField";
+}, "isArrayFieldState");
+const isDataField = /* @__PURE__ */ __name((node) => {
+  return isField(node) || isArrayField(node) || isObjectField(node);
+}, "isDataField");
+const isDataFieldState = /* @__PURE__ */ __name((node) => {
+  return isFieldState(node) || isObjectFieldState(node) || isArrayFieldState(node);
+}, "isDataFieldState");
+const isObjectFieldState = /* @__PURE__ */ __name((state) => {
+  if ((0, import_shared.isFn)(state == null ? void 0 : state.initialize)) return false;
+  return (state == null ? void 0 : state.displayName) === "ObjectField";
+}, "isObjectFieldState");
+const isVoidFieldState = /* @__PURE__ */ __name((state) => {
+  if ((0, import_shared.isFn)(state == null ? void 0 : state.initialize)) return false;
+  return (state == null ? void 0 : state.displayName) === "VoidField";
+}, "isVoidFieldState");
+const isQuery = /* @__PURE__ */ __name((query) => {
+  return query && query instanceof import_models.Query;
+}, "isQuery");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  isArrayField,
+  isArrayFieldState,
+  isDataField,
+  isDataFieldState,
+  isField,
+  isFieldState,
+  isForm,
+  isFormState,
+  isGeneralField,
+  isGeneralFieldState,
+  isObjectField,
+  isObjectFieldState,
+  isQuery,
+  isVoidField,
+  isVoidFieldState
+});

package/lib/core/shared/constants.d.ts

@@ -0,0 +1,48 @@
+export declare const ReservedProperties: {
+    form: boolean;
+    parent: boolean;
+    props: boolean;
+    caches: boolean;
+    requests: boolean;
+    disposers: boolean;
+    heart: boolean;
+    graph: boolean;
+    indexes: boolean;
+    fields: boolean;
+    lifecycles: boolean;
+    componentType: boolean;
+    componentProps: boolean;
+    decoratorType: boolean;
+    decoratorProps: boolean;
+};
+export declare const ReadOnlyProperties: {
+    address: boolean;
+    path: boolean;
+    valid: boolean;
+    invalid: boolean;
+    selfValid: boolean;
+    selfInvalid: boolean;
+    errors: boolean;
+    successes: boolean;
+    warnings: boolean;
+    validateStatus: boolean;
+};
+export declare const MutuallyExclusiveProperties: {
+    pattern: string;
+    editable: string;
+    readOnly: string;
+    readPretty: string;
+    disabled: string;
+    display: string;
+    hidden: string;
+    visible: string;
+};
+export declare const RESPONSE_REQUEST_DURATION = 100;
+export declare const GlobalState: {
+    lifecycles: any[];
+    context: any[];
+    effectStart: boolean;
+    effectEnd: boolean;
+    initializing: boolean;
+};
+export declare const NumberIndexReg: RegExp;

package/lib/core/shared/constants.js

@@ -0,0 +1,86 @@
+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);
+var constants_exports = {};
+__export(constants_exports, {
+  GlobalState: () => GlobalState,
+  MutuallyExclusiveProperties: () => MutuallyExclusiveProperties,
+  NumberIndexReg: () => NumberIndexReg,
+  RESPONSE_REQUEST_DURATION: () => RESPONSE_REQUEST_DURATION,
+  ReadOnlyProperties: () => ReadOnlyProperties,
+  ReservedProperties: () => ReservedProperties
+});
+module.exports = __toCommonJS(constants_exports);
+const ReservedProperties = {
+  form: true,
+  parent: true,
+  props: true,
+  caches: true,
+  requests: true,
+  disposers: true,
+  heart: true,
+  graph: true,
+  indexes: true,
+  fields: true,
+  lifecycles: true,
+  componentType: true,
+  componentProps: true,
+  decoratorType: true,
+  decoratorProps: true
+};
+const ReadOnlyProperties = {
+  address: true,
+  path: true,
+  valid: true,
+  invalid: true,
+  selfValid: true,
+  selfInvalid: true,
+  errors: true,
+  successes: true,
+  warnings: true,
+  validateStatus: true
+};
+const SELF_DISPLAY = "selfDisplay";
+const SELF_PATTERN = "selfPattern";
+const MutuallyExclusiveProperties = {
+  pattern: SELF_PATTERN,
+  editable: SELF_PATTERN,
+  readOnly: SELF_PATTERN,
+  readPretty: SELF_PATTERN,
+  disabled: SELF_PATTERN,
+  display: SELF_DISPLAY,
+  hidden: SELF_DISPLAY,
+  visible: SELF_DISPLAY
+};
+const RESPONSE_REQUEST_DURATION = 100;
+const GlobalState = {
+  lifecycles: [],
+  context: [],
+  effectStart: false,
+  effectEnd: false,
+  initializing: false
+};
+const NumberIndexReg = /^\.(\d+)/;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  GlobalState,
+  MutuallyExclusiveProperties,
+  NumberIndexReg,
+  RESPONSE_REQUEST_DURATION,
+  ReadOnlyProperties,
+  ReservedProperties
+});

package/lib/core/shared/effective.d.ts

@@ -0,0 +1,9 @@
+import { Form, LifeCycle } from '../models';
+import { AnyFunction } from '../types';
+export declare const createEffectHook: <F extends (payload: any, ...ctxs: any[]) => AnyFunction>(type: string, callback?: F) => (...args: Parameters<ReturnType<F>>) => void;
+export declare const createEffectContext: <T = any>(defaultValue?: T) => {
+    provide(value?: T): void;
+    consume(): T;
+};
+export declare const useEffectForm: () => Form<any>;
+export declare const runEffects: <Context>(context?: Context, ...args: ((context: Context) => void)[]) => LifeCycle[];

package/lib/core/shared/effective.js

@@ -0,0 +1,91 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+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);
+var effective_exports = {};
+__export(effective_exports, {
+  createEffectContext: () => createEffectContext,
+  createEffectHook: () => createEffectHook,
+  runEffects: () => runEffects,
+  useEffectForm: () => useEffectForm
+});
+module.exports = __toCommonJS(effective_exports);
+var import_shared = require("../../shared");
+var import_models = require("../models");
+var import_checkers = require("./checkers");
+var import_constants = require("./constants");
+const createEffectHook = /* @__PURE__ */ __name((type, callback) => {
+  return (...args) => {
+    if (import_constants.GlobalState.effectStart) {
+      import_constants.GlobalState.lifecycles.push(
+        new import_models.LifeCycle(type, (payload, ctx) => {
+          if ((0, import_shared.isFn)(callback)) {
+            callback(payload, ctx, ...import_constants.GlobalState.context)(...args);
+          }
+        })
+      );
+    } else {
+      throw new Error("Effect hooks cannot be used in asynchronous function body");
+    }
+  };
+}, "createEffectHook");
+const createEffectContext = /* @__PURE__ */ __name((defaultValue) => {
+  let index;
+  return {
+    provide(value) {
+      if (import_constants.GlobalState.effectStart) {
+        index = import_constants.GlobalState.context.length;
+        import_constants.GlobalState.context[index] = (0, import_shared.isValid)(value) ? value : defaultValue;
+      } else {
+        throw new Error("Provide method cannot be used in asynchronous function body");
+      }
+    },
+    consume() {
+      if (!import_constants.GlobalState.effectStart) {
+        throw new Error("Consume method cannot be used in asynchronous function body");
+      }
+      return import_constants.GlobalState.context[index];
+    }
+  };
+}, "createEffectContext");
+const FormEffectContext = createEffectContext();
+const useEffectForm = FormEffectContext.consume;
+const runEffects = /* @__PURE__ */ __name((context, ...args) => {
+  import_constants.GlobalState.lifecycles = [];
+  import_constants.GlobalState.context = [];
+  import_constants.GlobalState.effectStart = true;
+  import_constants.GlobalState.effectEnd = false;
+  if ((0, import_checkers.isForm)(context)) {
+    FormEffectContext.provide(context);
+  }
+  args.forEach((effects) => {
+    if ((0, import_shared.isFn)(effects)) {
+      effects(context);
+    }
+  });
+  import_constants.GlobalState.context = [];
+  import_constants.GlobalState.effectStart = false;
+  import_constants.GlobalState.effectEnd = true;
+  return import_constants.GlobalState.lifecycles;
+}, "runEffects");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createEffectContext,
+  createEffectHook,
+  runEffects,
+  useEffectForm
+});

package/lib/core/shared/externals.d.ts

@@ -0,0 +1,8 @@
+import { FormPath } from '../../shared';
+import { getLocaleByPath, getValidateLocaleIOSCode, registerValidateFormats, registerValidateLocale, registerValidateMessageTemplateEngine, registerValidateRules, setValidateLanguage } from '../../validator';
+import { Form } from '../models';
+import { IFormProps } from '../types';
+import { isArrayField, isArrayFieldState, isDataField, isDataFieldState, isField, isFieldState, isForm, isFormState, isGeneralField, isGeneralFieldState, isObjectField, isObjectFieldState, isQuery, isVoidField, isVoidFieldState } from './checkers';
+import { createEffectContext, createEffectHook, useEffectForm } from './effective';
+declare const createForm: <T extends object = any>(options?: IFormProps<T>) => Form<T>;
+export { FormPath, createForm, isArrayField, isArrayFieldState, isDataField, isDataFieldState, isField, isFieldState, isForm, isFormState, isGeneralField, isGeneralFieldState, isObjectField, isObjectFieldState, isQuery, isVoidField, isVoidFieldState, getValidateLocaleIOSCode, getLocaleByPath, setValidateLanguage, registerValidateFormats, registerValidateLocale, registerValidateMessageTemplateEngine, registerValidateRules, createEffectHook, createEffectContext, useEffectForm, };

package/lib/core/shared/externals.js

@@ -0,0 +1,87 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+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);
+var externals_exports = {};
+__export(externals_exports, {
+  FormPath: () => import_shared.FormPath,
+  createEffectContext: () => import_effective.createEffectContext,
+  createEffectHook: () => import_effective.createEffectHook,
+  createForm: () => createForm,
+  getLocaleByPath: () => import_validator.getLocaleByPath,
+  getValidateLocaleIOSCode: () => import_validator.getValidateLocaleIOSCode,
+  isArrayField: () => import_checkers.isArrayField,
+  isArrayFieldState: () => import_checkers.isArrayFieldState,
+  isDataField: () => import_checkers.isDataField,
+  isDataFieldState: () => import_checkers.isDataFieldState,
+  isField: () => import_checkers.isField,
+  isFieldState: () => import_checkers.isFieldState,
+  isForm: () => import_checkers.isForm,
+  isFormState: () => import_checkers.isFormState,
+  isGeneralField: () => import_checkers.isGeneralField,
+  isGeneralFieldState: () => import_checkers.isGeneralFieldState,
+  isObjectField: () => import_checkers.isObjectField,
+  isObjectFieldState: () => import_checkers.isObjectFieldState,
+  isQuery: () => import_checkers.isQuery,
+  isVoidField: () => import_checkers.isVoidField,
+  isVoidFieldState: () => import_checkers.isVoidFieldState,
+  registerValidateFormats: () => import_validator.registerValidateFormats,
+  registerValidateLocale: () => import_validator.registerValidateLocale,
+  registerValidateMessageTemplateEngine: () => import_validator.registerValidateMessageTemplateEngine,
+  registerValidateRules: () => import_validator.registerValidateRules,
+  setValidateLanguage: () => import_validator.setValidateLanguage,
+  useEffectForm: () => import_effective.useEffectForm
+});
+module.exports = __toCommonJS(externals_exports);
+var import_shared = require("../../shared");
+var import_validator = require("../../validator");
+var import_models = require("../models");
+var import_checkers = require("./checkers");
+var import_effective = require("./effective");
+const createForm = /* @__PURE__ */ __name((options) => {
+  return new import_models.Form(options);
+}, "createForm");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  FormPath,
+  createEffectContext,
+  createEffectHook,
+  createForm,
+  getLocaleByPath,
+  getValidateLocaleIOSCode,
+  isArrayField,
+  isArrayFieldState,
+  isDataField,
+  isDataFieldState,
+  isField,
+  isFieldState,
+  isForm,
+  isFormState,
+  isGeneralField,
+  isGeneralFieldState,
+  isObjectField,
+  isObjectFieldState,
+  isQuery,
+  isVoidField,
+  isVoidFieldState,
+  registerValidateFormats,
+  registerValidateLocale,
+  registerValidateMessageTemplateEngine,
+  registerValidateRules,
+  setValidateLanguage,
+  useEffectForm
+});

package/lib/core/shared/internals.d.ts

@@ -0,0 +1,54 @@
+import { DataChange } from '../../reactive';
+import { FormPath, FormPathPattern } from '../../shared';
+import { ValidatorTriggerType } from '../../validator';
+import { ArrayField, Field, Form, ObjectField } from '../models';
+import { BaseField } from '../models/BaseField';
+import { FieldMatchPattern, GeneralField, IExchangeArrayStateProps, IFieldFeedback, IFieldResetOptions, IFormFeedback, INodePatch, ISearchFeedback, ISpliceArrayStateProps } from '../types';
+export declare const isHTMLInputEvent: (event: any, stopPropagation?: boolean) => boolean;
+export declare const getValuesFromEvent: (args: any[]) => any[];
+export declare const getTypedDefaultValue: (field: Field) => {};
+export declare const buildFieldPath: (field: GeneralField) => FormPath;
+export declare const buildDataPath: (fields: Record<string, GeneralField>, pattern: FormPath) => FormPath;
+export declare const locateNode: (field: GeneralField, address: FormPathPattern) => GeneralField;
+export declare const patchFieldStates: (target: Record<string, GeneralField>, patches: INodePatch<GeneralField>[]) => void;
+export declare const destroy: (target: Record<string, GeneralField>, address: string, forceClear?: boolean) => void;
+export declare const patchFormValues: (form: Form, path: Array<string | number>, source: any) => void;
+export declare const matchFeedback: (search?: ISearchFeedback, feedback?: IFormFeedback) => boolean;
+export declare const queryFeedbacks: (field: Field, search?: ISearchFeedback) => IFieldFeedback[];
+export declare const queryFeedbackMessages: (field: Field, search: ISearchFeedback) => any[];
+export declare const updateFeedback: (field: Field, feedback?: IFieldFeedback) => void;
+export declare const validateToFeedbacks: (field: Field, triggerType?: ValidatorTriggerType) => Promise<import("../..").IValidateResults>;
+export declare const setValidatorRule: (field: Field, name: string, value: any) => void;
+export declare const spliceArrayState: (field: ArrayField, props?: ISpliceArrayStateProps) => void;
+export declare const exchangeArrayState: (field: ArrayField, props: IExchangeArrayStateProps) => void;
+export declare const cleanupArrayChildren: (field: ArrayField, start: number) => void;
+export declare const cleanupObjectChildren: (field: ObjectField, keys: string[]) => void;
+export declare const initFieldUpdate: (field: GeneralField) => void;
+export declare const subscribeUpdate: (form: Form, pattern: FormPath, callback: (...args: any[]) => void) => void;
+export declare const deserialize: (model: any, setter: any) => any;
+export declare const serialize: (model: any, getter?: any) => any;
+export declare const createChildrenFeedbackFilter: (field: Field) => ({ address }: IFormFeedback) => boolean;
+export declare const createStateSetter: (model: any) => (setter?: any) => any;
+export declare const createStateGetter: (model: any) => (getter?: any) => any;
+export declare const createBatchStateSetter: (form: Form) => (pattern: FieldMatchPattern, payload?: any) => void;
+export declare const createBatchStateGetter: (form: Form) => (pattern: FieldMatchPattern, payload?: any) => any;
+export declare const triggerFormInitialValuesChange: (form: Form, change: DataChange) => void;
+export declare const triggerFormValuesChange: (form: Form, change: DataChange) => void;
+export declare const setValidating: (target: Form | Field, validating: boolean) => void;
+export declare const setSubmitting: (target: Form | Field, submitting: boolean) => void;
+export declare const setLoading: (target: Form | Field, loading: boolean) => void;
+export declare const batchSubmit: <T>(target: Form | Field, onSubmit?: (values: any) => Promise<T> | void) => Promise<T>;
+export declare const batchValidate: (target: Form | Field, pattern: FormPathPattern, triggerType?: ValidatorTriggerType) => Promise<void>;
+export declare const batchReset: (target: Form | Field, pattern: FormPathPattern, options?: IFieldResetOptions) => Promise<void>;
+export declare const validateSelf: (target: Field, triggerType?: ValidatorTriggerType, noEmit?: any) => Promise<import("../..").IValidateResults>;
+export declare const resetSelf: (target: Field, options?: IFieldResetOptions, noEmit?: any) => Promise<import("../..").IValidateResults>;
+export declare const modifySelf: (target: Field) => void;
+export declare const getValidFormValues: (values: any) => any;
+export declare const getValidFieldDefaultValue: (value: any, initialValue: any) => any;
+export declare const allowAssignDefaultValue: (target: any, source: any) => boolean;
+export declare const createReactions: (field: GeneralField) => void;
+export declare const createReaction: <T>(tracker: () => T, scheduler?: (value: T) => void) => () => void;
+export declare const initializeStart: () => void;
+export declare const initializeEnd: () => void;
+export declare const getArrayParent: (field: BaseField, index?: number) => ArrayField<any, any>;
+export declare const getObjectParent: (field: BaseField) => ObjectField<any, any>;