@tachybase/schema 0.23.41 → 0.23.47

package/lib/core/effects/index.d.ts

@@ -0,0 +1,2 @@
+export * from './onFormEffects';
+export * from './onFieldEffects';

package/lib/core/effects/index.js

@@ -0,0 +1,23 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var effects_exports = {};
+module.exports = __toCommonJS(effects_exports);
+__reExport(effects_exports, require("./onFormEffects"), module.exports);
+__reExport(effects_exports, require("./onFieldEffects"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require("./onFormEffects"),
+  ...require("./onFieldEffects")
+});

package/lib/core/effects/onFieldEffects.d.ts

@@ -0,0 +1,27 @@
+import { Form } from '../models';
+import { DataField, FormPathPattern, GeneralField, IFieldState } from '../types';
+export declare const onFieldMount: (pattern: FormPathPattern, callback: (field: GeneralField, form: Form) => void) => void;
+export declare const onFieldUnmount: (pattern: FormPathPattern, callback: (field: GeneralField, form: Form) => void) => void;
+export declare const onFieldValueChange: (pattern: FormPathPattern, callback: (field: DataField, form: Form) => void) => void;
+export declare const onFieldInitialValueChange: (pattern: FormPathPattern, callback: (field: DataField, form: Form) => void) => void;
+export declare const onFieldInputValueChange: (pattern: FormPathPattern, callback: (field: DataField, form: Form) => void) => void;
+export declare const onFieldValidateStart: (pattern: FormPathPattern, callback: (field: DataField, form: Form) => void) => void;
+export declare const onFieldValidateEnd: (pattern: FormPathPattern, callback: (field: DataField, form: Form) => void) => void;
+export declare const onFieldValidating: (pattern: FormPathPattern, callback: (field: DataField, form: Form) => void) => void;
+export declare const onFieldValidateFailed: (pattern: FormPathPattern, callback: (field: DataField, form: Form) => void) => void;
+export declare const onFieldValidateSuccess: (pattern: FormPathPattern, callback: (field: DataField, form: Form) => void) => void;
+export declare const onFieldSubmit: (pattern: FormPathPattern, callback: (field: DataField, form: Form) => void) => void;
+export declare const onFieldSubmitStart: (pattern: FormPathPattern, callback: (field: DataField, form: Form) => void) => void;
+export declare const onFieldSubmitEnd: (pattern: FormPathPattern, callback: (field: DataField, form: Form) => void) => void;
+export declare const onFieldSubmitValidateStart: (pattern: FormPathPattern, callback: (field: DataField, form: Form) => void) => void;
+export declare const onFieldSubmitValidateEnd: (pattern: FormPathPattern, callback: (field: DataField, form: Form) => void) => void;
+export declare const onFieldSubmitSuccess: (pattern: FormPathPattern, callback: (field: DataField, form: Form) => void) => void;
+export declare const onFieldSubmitFailed: (pattern: FormPathPattern, callback: (field: DataField, form: Form) => void) => void;
+export declare const onFieldSubmitValidateSuccess: (pattern: FormPathPattern, callback: (field: DataField, form: Form) => void) => void;
+export declare const onFieldSubmitValidateFailed: (pattern: FormPathPattern, callback: (field: DataField, form: Form) => void) => void;
+export declare const onFieldReset: (pattern: FormPathPattern, callback: (field: DataField, form: Form) => void) => void;
+export declare const onFieldLoading: (pattern: FormPathPattern, callback: (field: DataField, form: Form) => void) => void;
+export declare function onFieldInit(pattern: FormPathPattern, callback?: (field: GeneralField, form: Form) => void): void;
+export declare function onFieldReact(pattern: FormPathPattern, callback?: (field: GeneralField, form: Form) => void): void;
+export declare function onFieldChange(pattern: FormPathPattern, callback?: (field: GeneralField, form: Form) => void): void;
+export declare function onFieldChange(pattern: FormPathPattern, watches: (keyof IFieldState)[], callback?: (field: GeneralField, form: Form) => void): void;

package/lib/core/effects/onFieldEffects.js

@@ -0,0 +1,158 @@
+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 onFieldEffects_exports = {};
+__export(onFieldEffects_exports, {
+  onFieldChange: () => onFieldChange,
+  onFieldInit: () => onFieldInit,
+  onFieldInitialValueChange: () => onFieldInitialValueChange,
+  onFieldInputValueChange: () => onFieldInputValueChange,
+  onFieldLoading: () => onFieldLoading,
+  onFieldMount: () => onFieldMount,
+  onFieldReact: () => onFieldReact,
+  onFieldReset: () => onFieldReset,
+  onFieldSubmit: () => onFieldSubmit,
+  onFieldSubmitEnd: () => onFieldSubmitEnd,
+  onFieldSubmitFailed: () => onFieldSubmitFailed,
+  onFieldSubmitStart: () => onFieldSubmitStart,
+  onFieldSubmitSuccess: () => onFieldSubmitSuccess,
+  onFieldSubmitValidateEnd: () => onFieldSubmitValidateEnd,
+  onFieldSubmitValidateFailed: () => onFieldSubmitValidateFailed,
+  onFieldSubmitValidateStart: () => onFieldSubmitValidateStart,
+  onFieldSubmitValidateSuccess: () => onFieldSubmitValidateSuccess,
+  onFieldUnmount: () => onFieldUnmount,
+  onFieldValidateEnd: () => onFieldValidateEnd,
+  onFieldValidateFailed: () => onFieldValidateFailed,
+  onFieldValidateStart: () => onFieldValidateStart,
+  onFieldValidateSuccess: () => onFieldValidateSuccess,
+  onFieldValidating: () => onFieldValidating,
+  onFieldValueChange: () => onFieldValueChange
+});
+module.exports = __toCommonJS(onFieldEffects_exports);
+var import_reactive = require("../../reactive");
+var import_shared = require("../../shared");
+var import_effective = require("../shared/effective");
+var import_types = require("../types");
+function createFieldEffect(type) {
+  return (0, import_effective.createEffectHook)(
+    type,
+    (field, form) => (pattern, callback) => {
+      if (import_shared.FormPath.parse(pattern).matchAliasGroup(field.address, field.path)) {
+        (0, import_reactive.batch)(() => {
+          callback(field, form);
+        });
+      }
+    }
+  );
+}
+__name(createFieldEffect, "createFieldEffect");
+const _onFieldInit = createFieldEffect(import_types.LifeCycleTypes.ON_FIELD_INIT);
+const onFieldMount = createFieldEffect(import_types.LifeCycleTypes.ON_FIELD_MOUNT);
+const onFieldUnmount = createFieldEffect(import_types.LifeCycleTypes.ON_FIELD_UNMOUNT);
+const onFieldValueChange = createFieldEffect(import_types.LifeCycleTypes.ON_FIELD_VALUE_CHANGE);
+const onFieldInitialValueChange = createFieldEffect(import_types.LifeCycleTypes.ON_FIELD_INITIAL_VALUE_CHANGE);
+const onFieldInputValueChange = createFieldEffect(import_types.LifeCycleTypes.ON_FIELD_INPUT_VALUE_CHANGE);
+const onFieldValidateStart = createFieldEffect(import_types.LifeCycleTypes.ON_FIELD_VALIDATE_START);
+const onFieldValidateEnd = createFieldEffect(import_types.LifeCycleTypes.ON_FIELD_VALIDATE_END);
+const onFieldValidating = createFieldEffect(import_types.LifeCycleTypes.ON_FIELD_VALIDATING);
+const onFieldValidateFailed = createFieldEffect(import_types.LifeCycleTypes.ON_FIELD_VALIDATE_FAILED);
+const onFieldValidateSuccess = createFieldEffect(import_types.LifeCycleTypes.ON_FIELD_VALIDATE_SUCCESS);
+const onFieldSubmit = createFieldEffect(import_types.LifeCycleTypes.ON_FIELD_SUBMIT);
+const onFieldSubmitStart = createFieldEffect(import_types.LifeCycleTypes.ON_FIELD_SUBMIT_START);
+const onFieldSubmitEnd = createFieldEffect(import_types.LifeCycleTypes.ON_FIELD_SUBMIT_END);
+const onFieldSubmitValidateStart = createFieldEffect(import_types.LifeCycleTypes.ON_FIELD_SUBMIT_VALIDATE_START);
+const onFieldSubmitValidateEnd = createFieldEffect(import_types.LifeCycleTypes.ON_FIELD_SUBMIT_VALIDATE_END);
+const onFieldSubmitSuccess = createFieldEffect(import_types.LifeCycleTypes.ON_FIELD_SUBMIT_SUCCESS);
+const onFieldSubmitFailed = createFieldEffect(import_types.LifeCycleTypes.ON_FIELD_SUBMIT_FAILED);
+const onFieldSubmitValidateSuccess = createFieldEffect(
+  import_types.LifeCycleTypes.ON_FIELD_SUBMIT_VALIDATE_SUCCESS
+);
+const onFieldSubmitValidateFailed = createFieldEffect(import_types.LifeCycleTypes.ON_FIELD_SUBMIT_VALIDATE_FAILED);
+const onFieldReset = createFieldEffect(import_types.LifeCycleTypes.ON_FIELD_RESET);
+const onFieldLoading = createFieldEffect(import_types.LifeCycleTypes.ON_FIELD_LOADING);
+function onFieldInit(pattern, callback) {
+  const form = (0, import_effective.useEffectForm)();
+  const count = form.query(pattern).reduce((count2, field) => {
+    callback(field, form);
+    return count2 + 1;
+  }, 0);
+  if (count === 0) {
+    _onFieldInit(pattern, callback);
+  }
+}
+__name(onFieldInit, "onFieldInit");
+function onFieldReact(pattern, callback) {
+  onFieldInit(pattern, (field, form) => {
+    field.disposers.push(
+      (0, import_reactive.autorun)(() => {
+        if ((0, import_shared.isFn)(callback)) callback(field, form);
+      })
+    );
+  });
+}
+__name(onFieldReact, "onFieldReact");
+function onFieldChange(pattern, watches, callback) {
+  if ((0, import_shared.isFn)(watches)) {
+    callback = watches;
+    watches = ["value"];
+  } else {
+    watches = watches || ["value"];
+  }
+  onFieldInit(pattern, (field, form) => {
+    if ((0, import_shared.isFn)(callback)) callback(field, form);
+    const dispose = (0, import_reactive.reaction)(
+      () => {
+        return (0, import_shared.toArr)(watches).map((key) => {
+          return field[key];
+        });
+      },
+      () => {
+        if ((0, import_shared.isFn)(callback)) callback(field, form);
+      }
+    );
+    field.disposers.push(dispose);
+  });
+}
+__name(onFieldChange, "onFieldChange");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  onFieldChange,
+  onFieldInit,
+  onFieldInitialValueChange,
+  onFieldInputValueChange,
+  onFieldLoading,
+  onFieldMount,
+  onFieldReact,
+  onFieldReset,
+  onFieldSubmit,
+  onFieldSubmitEnd,
+  onFieldSubmitFailed,
+  onFieldSubmitStart,
+  onFieldSubmitSuccess,
+  onFieldSubmitValidateEnd,
+  onFieldSubmitValidateFailed,
+  onFieldSubmitValidateStart,
+  onFieldSubmitValidateSuccess,
+  onFieldUnmount,
+  onFieldValidateEnd,
+  onFieldValidateFailed,
+  onFieldValidateStart,
+  onFieldValidateSuccess,
+  onFieldValidating,
+  onFieldValueChange
+});

package/lib/core/effects/onFormEffects.d.ts

@@ -0,0 +1,24 @@
+import { Form } from '../models';
+export declare const onFormInit: (callback: (form: Form) => void) => void;
+export declare const onFormMount: (callback: (form: Form) => void) => void;
+export declare const onFormUnmount: (callback: (form: Form) => void) => void;
+export declare const onFormValuesChange: (callback: (form: Form) => void) => void;
+export declare const onFormInitialValuesChange: (callback: (form: Form) => void) => void;
+export declare const onFormInputChange: (callback: (form: Form) => void) => void;
+export declare const onFormSubmit: (callback: (form: Form) => void) => void;
+export declare const onFormReset: (callback: (form: Form) => void) => void;
+export declare const onFormSubmitStart: (callback: (form: Form) => void) => void;
+export declare const onFormSubmitEnd: (callback: (form: Form) => void) => void;
+export declare const onFormSubmitSuccess: (callback: (form: Form) => void) => void;
+export declare const onFormSubmitFailed: (callback: (form: Form) => void) => void;
+export declare const onFormSubmitValidateStart: (callback: (form: Form) => void) => void;
+export declare const onFormSubmitValidateSuccess: (callback: (form: Form) => void) => void;
+export declare const onFormSubmitValidateFailed: (callback: (form: Form) => void) => void;
+export declare const onFormSubmitValidateEnd: (callback: (form: Form) => void) => void;
+export declare const onFormValidateStart: (callback: (form: Form) => void) => void;
+export declare const onFormValidateSuccess: (callback: (form: Form) => void) => void;
+export declare const onFormValidateFailed: (callback: (form: Form) => void) => void;
+export declare const onFormValidateEnd: (callback: (form: Form) => void) => void;
+export declare const onFormGraphChange: (callback: (form: Form) => void) => void;
+export declare const onFormLoading: (callback: (form: Form) => void) => void;
+export declare function onFormReact(callback?: (form: Form) => void): void;

package/lib/core/effects/onFormEffects.js

@@ -0,0 +1,117 @@
+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 onFormEffects_exports = {};
+__export(onFormEffects_exports, {
+  onFormGraphChange: () => onFormGraphChange,
+  onFormInit: () => onFormInit,
+  onFormInitialValuesChange: () => onFormInitialValuesChange,
+  onFormInputChange: () => onFormInputChange,
+  onFormLoading: () => onFormLoading,
+  onFormMount: () => onFormMount,
+  onFormReact: () => onFormReact,
+  onFormReset: () => onFormReset,
+  onFormSubmit: () => onFormSubmit,
+  onFormSubmitEnd: () => onFormSubmitEnd,
+  onFormSubmitFailed: () => onFormSubmitFailed,
+  onFormSubmitStart: () => onFormSubmitStart,
+  onFormSubmitSuccess: () => onFormSubmitSuccess,
+  onFormSubmitValidateEnd: () => onFormSubmitValidateEnd,
+  onFormSubmitValidateFailed: () => onFormSubmitValidateFailed,
+  onFormSubmitValidateStart: () => onFormSubmitValidateStart,
+  onFormSubmitValidateSuccess: () => onFormSubmitValidateSuccess,
+  onFormUnmount: () => onFormUnmount,
+  onFormValidateEnd: () => onFormValidateEnd,
+  onFormValidateFailed: () => onFormValidateFailed,
+  onFormValidateStart: () => onFormValidateStart,
+  onFormValidateSuccess: () => onFormValidateSuccess,
+  onFormValuesChange: () => onFormValuesChange
+});
+module.exports = __toCommonJS(onFormEffects_exports);
+var import_reactive = require("../../reactive");
+var import_shared = require("../../shared");
+var import_effective = require("../shared/effective");
+var import_types = require("../types");
+function createFormEffect(type) {
+  return (0, import_effective.createEffectHook)(type, (form) => (callback) => {
+    (0, import_reactive.batch)(() => {
+      callback(form);
+    });
+  });
+}
+__name(createFormEffect, "createFormEffect");
+const onFormInit = createFormEffect(import_types.LifeCycleTypes.ON_FORM_INIT);
+const onFormMount = createFormEffect(import_types.LifeCycleTypes.ON_FORM_MOUNT);
+const onFormUnmount = createFormEffect(import_types.LifeCycleTypes.ON_FORM_UNMOUNT);
+const onFormValuesChange = createFormEffect(import_types.LifeCycleTypes.ON_FORM_VALUES_CHANGE);
+const onFormInitialValuesChange = createFormEffect(import_types.LifeCycleTypes.ON_FORM_INITIAL_VALUES_CHANGE);
+const onFormInputChange = createFormEffect(import_types.LifeCycleTypes.ON_FORM_INPUT_CHANGE);
+const onFormSubmit = createFormEffect(import_types.LifeCycleTypes.ON_FORM_SUBMIT);
+const onFormReset = createFormEffect(import_types.LifeCycleTypes.ON_FORM_RESET);
+const onFormSubmitStart = createFormEffect(import_types.LifeCycleTypes.ON_FORM_SUBMIT_START);
+const onFormSubmitEnd = createFormEffect(import_types.LifeCycleTypes.ON_FORM_SUBMIT_END);
+const onFormSubmitSuccess = createFormEffect(import_types.LifeCycleTypes.ON_FORM_SUBMIT_SUCCESS);
+const onFormSubmitFailed = createFormEffect(import_types.LifeCycleTypes.ON_FORM_SUBMIT_FAILED);
+const onFormSubmitValidateStart = createFormEffect(import_types.LifeCycleTypes.ON_FORM_SUBMIT_VALIDATE_START);
+const onFormSubmitValidateSuccess = createFormEffect(import_types.LifeCycleTypes.ON_FORM_SUBMIT_VALIDATE_SUCCESS);
+const onFormSubmitValidateFailed = createFormEffect(import_types.LifeCycleTypes.ON_FORM_SUBMIT_VALIDATE_FAILED);
+const onFormSubmitValidateEnd = createFormEffect(import_types.LifeCycleTypes.ON_FORM_SUBMIT_VALIDATE_END);
+const onFormValidateStart = createFormEffect(import_types.LifeCycleTypes.ON_FORM_VALIDATE_START);
+const onFormValidateSuccess = createFormEffect(import_types.LifeCycleTypes.ON_FORM_VALIDATE_SUCCESS);
+const onFormValidateFailed = createFormEffect(import_types.LifeCycleTypes.ON_FORM_VALIDATE_FAILED);
+const onFormValidateEnd = createFormEffect(import_types.LifeCycleTypes.ON_FORM_VALIDATE_END);
+const onFormGraphChange = createFormEffect(import_types.LifeCycleTypes.ON_FORM_GRAPH_CHANGE);
+const onFormLoading = createFormEffect(import_types.LifeCycleTypes.ON_FORM_LOADING);
+function onFormReact(callback) {
+  let dispose = null;
+  onFormInit((form) => {
+    dispose = (0, import_reactive.autorun)(() => {
+      if ((0, import_shared.isFn)(callback)) callback(form);
+    });
+  });
+  onFormUnmount(() => {
+    dispose();
+  });
+}
+__name(onFormReact, "onFormReact");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  onFormGraphChange,
+  onFormInit,
+  onFormInitialValuesChange,
+  onFormInputChange,
+  onFormLoading,
+  onFormMount,
+  onFormReact,
+  onFormReset,
+  onFormSubmit,
+  onFormSubmitEnd,
+  onFormSubmitFailed,
+  onFormSubmitStart,
+  onFormSubmitSuccess,
+  onFormSubmitValidateEnd,
+  onFormSubmitValidateFailed,
+  onFormSubmitValidateStart,
+  onFormSubmitValidateSuccess,
+  onFormUnmount,
+  onFormValidateEnd,
+  onFormValidateFailed,
+  onFormValidateStart,
+  onFormValidateSuccess,
+  onFormValuesChange
+});

package/lib/core/index.d.ts

@@ -0,0 +1,4 @@
+export * from './shared/externals';
+export * from './models/types';
+export * from './effects';
+export * from './types';

package/lib/core/index.js

@@ -0,0 +1,27 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var core_exports = {};
+module.exports = __toCommonJS(core_exports);
+__reExport(core_exports, require("./shared/externals"), module.exports);
+__reExport(core_exports, require("./models/types"), module.exports);
+__reExport(core_exports, require("./effects"), module.exports);
+__reExport(core_exports, require("./types"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require("./shared/externals"),
+  ...require("./models/types"),
+  ...require("./effects"),
+  ...require("./types")
+});

package/lib/core/models/ArrayField.d.ts

@@ -0,0 +1,17 @@
+import { FormPathPattern, IFieldProps, JSXComponent } from '../types';
+import { Field } from './Field';
+import { Form } from './Form';
+export declare class ArrayField<Decorator extends JSXComponent = any, Component extends JSXComponent = any> extends Field<Decorator, Component, any, any[]> {
+    displayName: string;
+    constructor(address: FormPathPattern, props: IFieldProps<Decorator, Component>, form: Form, designable: boolean);
+    protected makeAutoCleanable(): void;
+    push: (...items: any[]) => Promise<void>;
+    pop: () => Promise<void>;
+    insert: (index: number, ...items: any[]) => Promise<void>;
+    remove: (index: number) => Promise<void>;
+    shift: () => Promise<void>;
+    unshift: (...items: any[]) => Promise<void>;
+    move: (fromIndex: number, toIndex: number) => Promise<void>;
+    moveUp: (index: number) => Promise<void>;
+    moveDown: (index: number) => Promise<void>;
+}

package/lib/core/models/ArrayField.js

@@ -0,0 +1,145 @@
+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 ArrayField_exports = {};
+__export(ArrayField_exports, {
+  ArrayField: () => ArrayField
+});
+module.exports = __toCommonJS(ArrayField_exports);
+var import_reactive = require("../../reactive");
+var import_shared = require("../../shared");
+var import_internals = require("../shared/internals");
+var import_Field = require("./Field");
+const _ArrayField = class _ArrayField extends import_Field.Field {
+  constructor(address, props, form, designable) {
+    super(address, props, form, designable);
+    this.displayName = "ArrayField";
+    this.push = /* @__PURE__ */ __name((...items) => {
+      return (0, import_reactive.action)(() => {
+        if (!(0, import_shared.isArr)(this.value)) {
+          this.value = [];
+        }
+        this.value.push(...items);
+        return this.onInput(this.value);
+      });
+    }, "push");
+    this.pop = /* @__PURE__ */ __name(() => {
+      if (!(0, import_shared.isArr)(this.value)) return;
+      return (0, import_reactive.action)(() => {
+        const index = this.value.length - 1;
+        (0, import_internals.spliceArrayState)(this, {
+          startIndex: index,
+          deleteCount: 1
+        });
+        this.value.pop();
+        return this.onInput(this.value);
+      });
+    }, "pop");
+    this.insert = /* @__PURE__ */ __name((index, ...items) => {
+      return (0, import_reactive.action)(() => {
+        if (!(0, import_shared.isArr)(this.value)) {
+          this.value = [];
+        }
+        if (items.length === 0) {
+          return;
+        }
+        (0, import_internals.spliceArrayState)(this, {
+          startIndex: index,
+          insertCount: items.length
+        });
+        this.value.splice(index, 0, ...items);
+        return this.onInput(this.value);
+      });
+    }, "insert");
+    this.remove = /* @__PURE__ */ __name((index) => {
+      if (!(0, import_shared.isArr)(this.value)) return;
+      return (0, import_reactive.action)(() => {
+        (0, import_internals.spliceArrayState)(this, {
+          startIndex: index,
+          deleteCount: 1
+        });
+        this.value.splice(index, 1);
+        return this.onInput(this.value);
+      });
+    }, "remove");
+    this.shift = /* @__PURE__ */ __name(() => {
+      if (!(0, import_shared.isArr)(this.value)) return;
+      return (0, import_reactive.action)(() => {
+        this.value.shift();
+        return this.onInput(this.value);
+      });
+    }, "shift");
+    this.unshift = /* @__PURE__ */ __name((...items) => {
+      return (0, import_reactive.action)(() => {
+        if (!(0, import_shared.isArr)(this.value)) {
+          this.value = [];
+        }
+        (0, import_internals.spliceArrayState)(this, {
+          startIndex: 0,
+          insertCount: items.length
+        });
+        this.value.unshift(...items);
+        return this.onInput(this.value);
+      });
+    }, "unshift");
+    this.move = /* @__PURE__ */ __name((fromIndex, toIndex) => {
+      if (!(0, import_shared.isArr)(this.value)) return;
+      if (fromIndex === toIndex) return;
+      return (0, import_reactive.action)(() => {
+        (0, import_shared.move)(this.value, fromIndex, toIndex);
+        (0, import_internals.exchangeArrayState)(this, {
+          fromIndex,
+          toIndex
+        });
+        return this.onInput(this.value);
+      });
+    }, "move");
+    this.moveUp = /* @__PURE__ */ __name((index) => {
+      if (!(0, import_shared.isArr)(this.value)) return;
+      return this.move(index, index - 1 < 0 ? this.value.length - 1 : index - 1);
+    }, "moveUp");
+    this.moveDown = /* @__PURE__ */ __name((index) => {
+      if (!(0, import_shared.isArr)(this.value)) return;
+      return this.move(index, index + 1 >= this.value.length ? 0 : index + 1);
+    }, "moveDown");
+    this.makeAutoCleanable();
+  }
+  makeAutoCleanable() {
+    this.disposers.push(
+      (0, import_reactive.reaction)(
+        () => {
+          var _a;
+          return (_a = this.value) == null ? void 0 : _a.length;
+        },
+        (newLength, oldLength) => {
+          if (oldLength && !newLength) {
+            (0, import_internals.cleanupArrayChildren)(this, 0);
+          } else if (newLength < oldLength) {
+            (0, import_internals.cleanupArrayChildren)(this, newLength);
+          }
+        }
+      )
+    );
+  }
+};
+__name(_ArrayField, "ArrayField");
+let ArrayField = _ArrayField;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ArrayField
+});

package/lib/core/models/BaseField.d.ts

@@ -0,0 +1,72 @@
+import { FormPath, FormPathPattern } from '../../shared';
+import { FieldComponent, FieldDecorator, FieldDisplayTypes, FieldPatternTypes, IFieldActions, JSXComponent, LifeCycleTypes } from '../types';
+import { Form } from './Form';
+import { Query } from './Query';
+export declare class BaseField<Decorator = any, Component = any, TextType = any> {
+    title: TextType;
+    description: TextType;
+    selfDisplay: FieldDisplayTypes;
+    selfPattern: FieldPatternTypes;
+    initialized: boolean;
+    mounted: boolean;
+    unmounted: boolean;
+    content: any;
+    data: any;
+    decoratorType: Decorator;
+    decoratorProps: Record<string, any>;
+    componentType: Component;
+    componentProps: Record<string, any>;
+    designable: boolean;
+    address: FormPath;
+    path: FormPath;
+    form: Form;
+    disposers: (() => void)[];
+    actions: IFieldActions;
+    locate(address: FormPathPattern): void;
+    get indexes(): number[];
+    get index(): number;
+    get records(): any[];
+    get record(): any;
+    get component(): FieldComponent<Component>;
+    set component(value: FieldComponent<Component>);
+    get decorator(): FieldDecorator<Decorator>;
+    set decorator(value: FieldDecorator<Decorator>);
+    get parent(): import("..").GeneralField;
+    get display(): FieldDisplayTypes;
+    get pattern(): FieldPatternTypes;
+    get editable(): boolean;
+    get disabled(): boolean;
+    get readOnly(): boolean;
+    get readPretty(): boolean;
+    get hidden(): boolean;
+    get visible(): boolean;
+    get destroyed(): boolean;
+    set hidden(hidden: boolean);
+    set visible(visible: boolean);
+    set editable(editable: boolean);
+    set readOnly(readOnly: boolean);
+    set disabled(disabled: boolean);
+    set readPretty(readPretty: boolean);
+    set pattern(pattern: FieldPatternTypes);
+    set display(display: FieldDisplayTypes);
+    setTitle: (title?: TextType) => void;
+    setDescription: (description?: TextType) => void;
+    setDisplay: (type?: FieldDisplayTypes) => void;
+    setPattern: (type?: FieldPatternTypes) => void;
+    setComponent: <C extends unknown, ComponentProps extends object = {}>(component?: C, props?: ComponentProps) => void;
+    setComponentProps: <ComponentProps extends object = {}>(props?: ComponentProps) => void;
+    setDecorator: <D extends unknown, ComponentProps extends object = {}>(component?: D, props?: ComponentProps) => void;
+    setDecoratorProps: <ComponentProps extends object = {}>(props?: ComponentProps) => void;
+    setData: (data: any) => void;
+    setContent: (content: any) => void;
+    onInit: () => void;
+    onMount: () => void;
+    onUnmount: () => void;
+    query: (pattern: FormPathPattern | RegExp) => Query;
+    notify: (type: LifeCycleTypes, payload?: any) => void;
+    dispose: () => void;
+    destroy: (forceClear?: boolean) => void;
+    match: (pattern: FormPathPattern) => boolean;
+    inject: (actions: IFieldActions) => void;
+    invoke: (name: string, ...args: any[]) => any;
+}