@tachybase/schema 0.23.41 → 0.23.48

package/lib/core/models/Field.js

@@ -0,0 +1,426 @@
+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 Field_exports = {};
+__export(Field_exports, {
+  Field: () => Field
+});
+module.exports = __toCommonJS(Field_exports);
+var import_reactive = require("../../reactive");
+var import_shared = require("../../shared");
+var import_validator = require("../../validator");
+var import_internals = require("../shared/internals");
+var import_types = require("../types");
+var import_BaseField = require("./BaseField");
+const _Field = class _Field extends import_BaseField.BaseField {
+  constructor(address, props, form, designable) {
+    super();
+    this.displayName = "Field";
+    this.caches = {};
+    this.requests = {};
+    this.setDataSource = /* @__PURE__ */ __name((dataSource) => {
+      this.dataSource = dataSource;
+    }, "setDataSource");
+    this.setFeedback = /* @__PURE__ */ __name((feedback) => {
+      (0, import_internals.updateFeedback)(this, feedback);
+    }, "setFeedback");
+    this.setSelfErrors = /* @__PURE__ */ __name((messages) => {
+      this.selfErrors = messages;
+    }, "setSelfErrors");
+    this.setSelfWarnings = /* @__PURE__ */ __name((messages) => {
+      this.selfWarnings = messages;
+    }, "setSelfWarnings");
+    this.setSelfSuccesses = /* @__PURE__ */ __name((messages) => {
+      this.selfSuccesses = messages;
+    }, "setSelfSuccesses");
+    this.setValidator = /* @__PURE__ */ __name((validator) => {
+      this.validator = validator;
+    }, "setValidator");
+    this.setValidatorRule = /* @__PURE__ */ __name((name, value) => {
+      (0, import_internals.setValidatorRule)(this, name, value);
+    }, "setValidatorRule");
+    this.setRequired = /* @__PURE__ */ __name((required) => {
+      this.required = required;
+    }, "setRequired");
+    this.setValue = /* @__PURE__ */ __name((value) => {
+      if (this.destroyed) return;
+      if (!this.initialized) {
+        if (this.display === "none") {
+          this.caches.value = value;
+          return;
+        }
+        value = (0, import_internals.getValidFieldDefaultValue)(value, this.initialValue);
+        if (!(0, import_internals.allowAssignDefaultValue)(this.value, value) && !this.designable) {
+          return;
+        }
+      }
+      this.form.setValuesIn(this.path, value);
+    }, "setValue");
+    this.setInitialValue = /* @__PURE__ */ __name((initialValue) => {
+      if (this.destroyed) return;
+      if (!this.initialized) {
+        if (!(0, import_internals.allowAssignDefaultValue)(this.initialValue, initialValue) && !this.designable) {
+          return;
+        }
+      }
+      this.form.setInitialValuesIn(this.path, initialValue);
+    }, "setInitialValue");
+    this.setLoading = /* @__PURE__ */ __name((loading) => {
+      (0, import_internals.setLoading)(this, loading);
+    }, "setLoading");
+    this.setValidating = /* @__PURE__ */ __name((validating) => {
+      (0, import_internals.setValidating)(this, validating);
+    }, "setValidating");
+    this.setSubmitting = /* @__PURE__ */ __name((submitting) => {
+      (0, import_internals.setSubmitting)(this, submitting);
+    }, "setSubmitting");
+    this.setState = (0, import_internals.createStateSetter)(this);
+    this.getState = (0, import_internals.createStateGetter)(this);
+    this.onInput = /* @__PURE__ */ __name(async (...args) => {
+      const isHTMLInputEventFromSelf = /* @__PURE__ */ __name((args2) => {
+        var _a, _b;
+        return (0, import_internals.isHTMLInputEvent)(args2[0]) && "currentTarget" in args2[0] ? ((_a = args2[0]) == null ? void 0 : _a.target) === ((_b = args2[0]) == null ? void 0 : _b.currentTarget) : true;
+      }, "isHTMLInputEventFromSelf");
+      const getValues = /* @__PURE__ */ __name((args2) => {
+        var _a;
+        if ((_a = args2[0]) == null ? void 0 : _a.target) {
+          if (!(0, import_internals.isHTMLInputEvent)(args2[0])) return args2;
+        }
+        return (0, import_internals.getValuesFromEvent)(args2);
+      }, "getValues");
+      if (!isHTMLInputEventFromSelf(args)) return;
+      const values = getValues(args);
+      const value = values[0];
+      this.caches.inputting = true;
+      this.inputValue = value;
+      this.inputValues = values;
+      this.value = value;
+      this.modify();
+      this.notify(import_types.LifeCycleTypes.ON_FIELD_INPUT_VALUE_CHANGE);
+      this.notify(import_types.LifeCycleTypes.ON_FORM_INPUT_CHANGE, this.form);
+      await (0, import_internals.validateSelf)(this, "onInput");
+      this.caches.inputting = false;
+    }, "onInput");
+    this.onFocus = /* @__PURE__ */ __name(async (...args) => {
+      var _a;
+      if ((_a = args[0]) == null ? void 0 : _a.target) {
+        if (!(0, import_internals.isHTMLInputEvent)(args[0], false)) return;
+      }
+      this.active = true;
+      this.visited = true;
+      await (0, import_internals.validateSelf)(this, "onFocus");
+    }, "onFocus");
+    this.onBlur = /* @__PURE__ */ __name(async (...args) => {
+      var _a;
+      if ((_a = args[0]) == null ? void 0 : _a.target) {
+        if (!(0, import_internals.isHTMLInputEvent)(args[0], false)) return;
+      }
+      this.active = false;
+      await (0, import_internals.validateSelf)(this, "onBlur");
+    }, "onBlur");
+    this.validate = /* @__PURE__ */ __name((triggerType) => {
+      return (0, import_internals.batchValidate)(this, `${this.address}.**`, triggerType);
+    }, "validate");
+    this.submit = /* @__PURE__ */ __name((onSubmit) => {
+      return (0, import_internals.batchSubmit)(this, onSubmit);
+    }, "submit");
+    this.reset = /* @__PURE__ */ __name((options) => {
+      return (0, import_internals.batchReset)(this, `${this.address}.**`, options);
+    }, "reset");
+    this.queryFeedbacks = /* @__PURE__ */ __name((search) => {
+      return (0, import_internals.queryFeedbacks)(this, search);
+    }, "queryFeedbacks");
+    this.modify = /* @__PURE__ */ __name(() => (0, import_internals.modifySelf)(this), "modify");
+    this.form = form;
+    this.props = props;
+    this.designable = designable;
+    (0, import_internals.initializeStart)();
+    this.locate(address);
+    this.initialize();
+    this.makeObservable();
+    this.makeReactive();
+    this.onInit();
+    (0, import_internals.initializeEnd)();
+  }
+  initialize() {
+    this.initialized = false;
+    this.loading = false;
+    this.validating = false;
+    this.submitting = false;
+    this.selfModified = false;
+    this.active = false;
+    this.visited = false;
+    this.mounted = false;
+    this.unmounted = false;
+    this.inputValues = [];
+    this.inputValue = null;
+    this.feedbacks = [];
+    this.title = this.props.title;
+    this.description = this.props.description;
+    this.display = this.props.display;
+    this.pattern = this.props.pattern;
+    this.editable = this.props.editable;
+    this.disabled = this.props.disabled;
+    this.readOnly = this.props.readOnly;
+    this.readPretty = this.props.readPretty;
+    this.visible = this.props.visible;
+    this.hidden = this.props.hidden;
+    this.dataSource = this.props.dataSource;
+    this.validator = this.props.validator;
+    this.required = this.props.required;
+    this.content = this.props.content;
+    this.initialValue = this.props.initialValue;
+    this.value = this.props.value;
+    this.data = this.props.data;
+    this.decorator = (0, import_shared.toArr)(this.props.decorator);
+    this.component = (0, import_shared.toArr)(this.props.component);
+  }
+  makeObservable() {
+    if (this.designable) return;
+    (0, import_reactive.define)(this, {
+      path: import_reactive.observable.ref,
+      title: import_reactive.observable.ref,
+      description: import_reactive.observable.ref,
+      dataSource: import_reactive.observable.ref,
+      selfDisplay: import_reactive.observable.ref,
+      selfPattern: import_reactive.observable.ref,
+      loading: import_reactive.observable.ref,
+      validating: import_reactive.observable.ref,
+      submitting: import_reactive.observable.ref,
+      selfModified: import_reactive.observable.ref,
+      modified: import_reactive.observable.ref,
+      active: import_reactive.observable.ref,
+      visited: import_reactive.observable.ref,
+      initialized: import_reactive.observable.ref,
+      mounted: import_reactive.observable.ref,
+      unmounted: import_reactive.observable.ref,
+      inputValue: import_reactive.observable.ref,
+      inputValues: import_reactive.observable.ref,
+      decoratorType: import_reactive.observable.ref,
+      componentType: import_reactive.observable.ref,
+      content: import_reactive.observable.ref,
+      feedbacks: import_reactive.observable.ref,
+      decoratorProps: import_reactive.observable,
+      componentProps: import_reactive.observable,
+      validator: import_reactive.observable.shallow,
+      data: import_reactive.observable.shallow,
+      component: import_reactive.observable.computed,
+      decorator: import_reactive.observable.computed,
+      errors: import_reactive.observable.computed,
+      warnings: import_reactive.observable.computed,
+      successes: import_reactive.observable.computed,
+      valid: import_reactive.observable.computed,
+      invalid: import_reactive.observable.computed,
+      selfErrors: import_reactive.observable.computed,
+      selfWarnings: import_reactive.observable.computed,
+      selfSuccesses: import_reactive.observable.computed,
+      selfValid: import_reactive.observable.computed,
+      selfInvalid: import_reactive.observable.computed,
+      validateStatus: import_reactive.observable.computed,
+      value: import_reactive.observable.computed,
+      initialValue: import_reactive.observable.computed,
+      display: import_reactive.observable.computed,
+      pattern: import_reactive.observable.computed,
+      required: import_reactive.observable.computed,
+      hidden: import_reactive.observable.computed,
+      visible: import_reactive.observable.computed,
+      disabled: import_reactive.observable.computed,
+      readOnly: import_reactive.observable.computed,
+      readPretty: import_reactive.observable.computed,
+      editable: import_reactive.observable.computed,
+      indexes: import_reactive.observable.computed,
+      setDisplay: import_reactive.action,
+      setTitle: import_reactive.action,
+      setDescription: import_reactive.action,
+      setDataSource: import_reactive.action,
+      setValue: import_reactive.action,
+      setPattern: import_reactive.action,
+      setInitialValue: import_reactive.action,
+      setLoading: import_reactive.action,
+      setValidating: import_reactive.action,
+      setFeedback: import_reactive.action,
+      setSelfErrors: import_reactive.action,
+      setSelfWarnings: import_reactive.action,
+      setSelfSuccesses: import_reactive.action,
+      setValidator: import_reactive.action,
+      setRequired: import_reactive.action,
+      setComponent: import_reactive.action,
+      setComponentProps: import_reactive.action,
+      setDecorator: import_reactive.action,
+      setDecoratorProps: import_reactive.action,
+      setData: import_reactive.action,
+      setContent: import_reactive.action,
+      validate: import_reactive.action,
+      reset: import_reactive.action,
+      onInit: import_reactive.batch,
+      onInput: import_reactive.batch,
+      onMount: import_reactive.batch,
+      onUnmount: import_reactive.batch,
+      onFocus: import_reactive.batch,
+      onBlur: import_reactive.batch
+    });
+  }
+  makeReactive() {
+    if (this.designable) return;
+    this.disposers.push(
+      (0, import_internals.createReaction)(
+        () => this.value,
+        (value) => {
+          this.notify(import_types.LifeCycleTypes.ON_FIELD_VALUE_CHANGE);
+          if ((0, import_shared.isValid)(value)) {
+            if (this.selfModified && !this.caches.inputting) {
+              (0, import_internals.validateSelf)(this);
+            }
+            if (!(0, import_shared.isEmpty)(value) && this.display === "none") {
+              this.caches.value = (0, import_reactive.toJS)(value);
+              this.form.deleteValuesIn(this.path);
+            }
+          }
+        }
+      ),
+      (0, import_internals.createReaction)(
+        () => this.initialValue,
+        () => {
+          this.notify(import_types.LifeCycleTypes.ON_FIELD_INITIAL_VALUE_CHANGE);
+        }
+      ),
+      (0, import_internals.createReaction)(
+        () => this.display,
+        (display) => {
+          const value = this.value;
+          if (display !== "none") {
+            if (value === void 0 && this.caches.value !== void 0) {
+              this.setValue(this.caches.value);
+              this.caches.value = void 0;
+            }
+          } else {
+            this.caches.value = (0, import_reactive.toJS)(value) ?? (0, import_reactive.toJS)(this.initialValue);
+            this.form.deleteValuesIn(this.path);
+          }
+          if (display === "none" || display === "hidden") {
+            this.setFeedback({
+              type: "error",
+              messages: []
+            });
+          }
+        }
+      ),
+      (0, import_internals.createReaction)(
+        () => this.pattern,
+        (pattern) => {
+          if (pattern !== "editable") {
+            this.setFeedback({
+              type: "error",
+              messages: []
+            });
+          }
+        }
+      )
+    );
+    (0, import_internals.createReactions)(this);
+  }
+  get selfErrors() {
+    return (0, import_internals.queryFeedbackMessages)(this, {
+      type: "error"
+    });
+  }
+  get errors() {
+    return this.form.errors.filter((0, import_internals.createChildrenFeedbackFilter)(this));
+  }
+  get selfWarnings() {
+    return (0, import_internals.queryFeedbackMessages)(this, {
+      type: "warning"
+    });
+  }
+  get warnings() {
+    return this.form.warnings.filter((0, import_internals.createChildrenFeedbackFilter)(this));
+  }
+  get selfSuccesses() {
+    return (0, import_internals.queryFeedbackMessages)(this, {
+      type: "success"
+    });
+  }
+  get successes() {
+    return this.form.successes.filter((0, import_internals.createChildrenFeedbackFilter)(this));
+  }
+  get selfValid() {
+    return !this.selfErrors.length;
+  }
+  get valid() {
+    return !this.errors.length;
+  }
+  get selfInvalid() {
+    return !this.selfValid;
+  }
+  get invalid() {
+    return !this.valid;
+  }
+  get value() {
+    return this.form.getValuesIn(this.path);
+  }
+  get initialValue() {
+    return this.form.getInitialValuesIn(this.path);
+  }
+  get required() {
+    const validators = (0, import_shared.isArr)(this.validator) ? this.validator : (0, import_validator.parseValidatorDescriptions)(this.validator);
+    return validators.some((desc) => !!(desc == null ? void 0 : desc["required"]));
+  }
+  get validateStatus() {
+    if (this.validating) return "validating";
+    if (this.selfInvalid) return "error";
+    if (this.selfWarnings.length) return "warning";
+    if (this.selfSuccesses.length) return "success";
+  }
+  set required(required) {
+    if (this.required === required) return;
+    this.setValidatorRule("required", required);
+  }
+  set value(value) {
+    this.setValue(value);
+  }
+  set initialValue(initialValue) {
+    this.setInitialValue(initialValue);
+  }
+  set selfErrors(messages) {
+    this.setFeedback({
+      type: "error",
+      code: "EffectError",
+      messages
+    });
+  }
+  set selfWarnings(messages) {
+    this.setFeedback({
+      type: "warning",
+      code: "EffectWarning",
+      messages
+    });
+  }
+  set selfSuccesses(messages) {
+    this.setFeedback({
+      type: "success",
+      code: "EffectSuccess",
+      messages
+    });
+  }
+};
+__name(_Field, "Field");
+let Field = _Field;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Field
+});

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

@@ -0,0 +1,102 @@
+import { FormPathPattern } from '../../shared';
+import { FormDisplayTypes, FormPatternTypes, HeartSubscriber, IFieldFactoryProps, IFieldResetOptions, IFieldStateGetter, IFieldStateSetter, IFormFeedback, IFormFields, IFormGraph, IFormMergeStrategy, IFormProps, IFormRequests, IFormState, IModelGetter, IModelSetter, ISearchFeedback, IVoidFieldFactoryProps, JSXComponent } from '../types';
+import { ArrayField } from './ArrayField';
+import { Field } from './Field';
+import { Graph } from './Graph';
+import { Heart } from './Heart';
+import { ObjectField } from './ObjectField';
+import { Query } from './Query';
+import { VoidField } from './VoidField';
+export declare class Form<ValueType extends object = any> {
+    displayName: string;
+    id: string;
+    initialized: boolean;
+    validating: boolean;
+    submitting: boolean;
+    loading: boolean;
+    modified: boolean;
+    pattern: FormPatternTypes;
+    display: FormDisplayTypes;
+    values: ValueType;
+    initialValues: ValueType;
+    mounted: boolean;
+    unmounted: boolean;
+    props: IFormProps<ValueType>;
+    heart: Heart;
+    graph: Graph;
+    fields: IFormFields;
+    requests: IFormRequests;
+    indexes: Record<string, string>;
+    disposers: (() => void)[];
+    constructor(props: IFormProps<ValueType>);
+    protected initialize(props: IFormProps<ValueType>): void;
+    protected makeValues(): void;
+    protected makeObservable(): void;
+    protected makeReactive(): void;
+    get valid(): boolean;
+    get invalid(): boolean;
+    get errors(): IFormFeedback[];
+    get warnings(): IFormFeedback[];
+    get successes(): IFormFeedback[];
+    get lifecycles(): import("./LifeCycle").LifeCycle<any>[];
+    get hidden(): boolean;
+    get visible(): boolean;
+    set hidden(hidden: boolean);
+    set visible(visible: boolean);
+    get editable(): boolean;
+    set editable(editable: boolean);
+    get readOnly(): boolean;
+    set readOnly(readOnly: boolean);
+    get disabled(): boolean;
+    set disabled(disabled: boolean);
+    get readPretty(): boolean;
+    set readPretty(readPretty: boolean);
+    /** 创建字段 **/
+    createField: <Decorator extends unknown, Component extends unknown>(props: IFieldFactoryProps<Decorator, Component>) => Field<Decorator, Component>;
+    createArrayField: <Decorator extends unknown, Component extends unknown>(props: IFieldFactoryProps<Decorator, Component>) => ArrayField<Decorator, Component>;
+    createObjectField: <Decorator extends unknown, Component extends unknown>(props: IFieldFactoryProps<Decorator, Component>) => ObjectField<Decorator, Component>;
+    createVoidField: <Decorator extends unknown, Component extends unknown>(props: IVoidFieldFactoryProps<Decorator, Component>) => VoidField<Decorator, Component>;
+    /** 状态操作模型 **/
+    setValues: (values: any, strategy?: IFormMergeStrategy) => void;
+    setInitialValues: (initialValues: any, strategy?: IFormMergeStrategy) => void;
+    setValuesIn: (pattern: FormPathPattern, value: any) => void;
+    deleteValuesIn: (pattern: FormPathPattern) => void;
+    existValuesIn: (pattern: FormPathPattern) => any;
+    getValuesIn: (pattern: FormPathPattern) => any;
+    setInitialValuesIn: (pattern: FormPathPattern, initialValue: any) => void;
+    deleteInitialValuesIn: (pattern: FormPathPattern) => void;
+    existInitialValuesIn: (pattern: FormPathPattern) => any;
+    getInitialValuesIn: (pattern: FormPathPattern) => any;
+    setLoading: (loading: boolean) => void;
+    setSubmitting: (submitting: boolean) => void;
+    setValidating: (validating: boolean) => void;
+    setDisplay: (display: FormDisplayTypes) => void;
+    setPattern: (pattern: FormPatternTypes) => void;
+    addEffects: (id: any, effects: IFormProps["effects"]) => void;
+    removeEffects: (id: any) => void;
+    setEffects: (effects: IFormProps["effects"]) => void;
+    clearErrors: (pattern?: FormPathPattern) => void;
+    clearWarnings: (pattern?: FormPathPattern) => void;
+    clearSuccesses: (pattern?: FormPathPattern) => void;
+    query: (pattern: FormPathPattern) => Query;
+    queryFeedbacks: (search: ISearchFeedback) => IFormFeedback[];
+    notify: (type: string, payload?: any) => void;
+    subscribe: (subscriber?: HeartSubscriber) => number;
+    unsubscribe: (id: number) => void;
+    /**事件钩子**/
+    onInit: () => void;
+    onMount: () => void;
+    onUnmount: () => void;
+    setState: IModelSetter<IFormState<ValueType>>;
+    getState: IModelGetter<IFormState<ValueType>>;
+    setFormState: IModelSetter<IFormState<ValueType>>;
+    getFormState: IModelGetter<IFormState<ValueType>>;
+    setFieldState: IFieldStateSetter;
+    getFieldState: IFieldStateGetter;
+    getFormGraph: () => IFormGraph;
+    setFormGraph: (graph: IFormGraph) => void;
+    clearFormGraph: (pattern?: FormPathPattern, forceClear?: boolean) => void;
+    validate: (pattern?: FormPathPattern) => Promise<void>;
+    submit: <T>(onSubmit?: (values: ValueType) => Promise<T> | void) => Promise<T>;
+    reset: (pattern?: FormPathPattern, options?: IFieldResetOptions) => Promise<void>;
+}