@tachybase/schema 0.23.41 → 0.23.48

package/lib/core/models/BaseField.js

@@ -0,0 +1,285 @@
+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 BaseField_exports = {};
+__export(BaseField_exports, {
+  BaseField: () => BaseField
+});
+module.exports = __toCommonJS(BaseField_exports);
+var import_shared = require("../../shared");
+var import_internals = require("../shared/internals");
+var import_types = require("../types");
+var import_Query = require("./Query");
+const _BaseField = class _BaseField {
+  constructor() {
+    this.disposers = [];
+    this.actions = {};
+    this.setTitle = /* @__PURE__ */ __name((title) => {
+      this.title = title;
+    }, "setTitle");
+    this.setDescription = /* @__PURE__ */ __name((description) => {
+      this.description = description;
+    }, "setDescription");
+    this.setDisplay = /* @__PURE__ */ __name((type) => {
+      this.display = type;
+    }, "setDisplay");
+    this.setPattern = /* @__PURE__ */ __name((type) => {
+      this.pattern = type;
+    }, "setPattern");
+    this.setComponent = /* @__PURE__ */ __name((component, props) => {
+      if (component) {
+        this.componentType = component;
+      }
+      if (props) {
+        this.componentProps = this.componentProps || {};
+        Object.assign(this.componentProps, props);
+      }
+    }, "setComponent");
+    this.setComponentProps = /* @__PURE__ */ __name((props) => {
+      if (props) {
+        this.componentProps = this.componentProps || {};
+        Object.assign(this.componentProps, props);
+      }
+    }, "setComponentProps");
+    this.setDecorator = /* @__PURE__ */ __name((component, props) => {
+      if (component) {
+        this.decoratorType = component;
+      }
+      if (props) {
+        this.decoratorProps = this.decoratorProps || {};
+        Object.assign(this.decoratorProps, props);
+      }
+    }, "setDecorator");
+    this.setDecoratorProps = /* @__PURE__ */ __name((props) => {
+      if (props) {
+        this.decoratorProps = this.decoratorProps || {};
+        Object.assign(this.decoratorProps, props);
+      }
+    }, "setDecoratorProps");
+    this.setData = /* @__PURE__ */ __name((data) => {
+      this.data = data;
+    }, "setData");
+    this.setContent = /* @__PURE__ */ __name((content) => {
+      this.content = content;
+    }, "setContent");
+    this.onInit = /* @__PURE__ */ __name(() => {
+      this.initialized = true;
+      (0, import_internals.initFieldUpdate)(this);
+      this.notify(import_types.LifeCycleTypes.ON_FIELD_INIT);
+    }, "onInit");
+    this.onMount = /* @__PURE__ */ __name(() => {
+      this.mounted = true;
+      this.unmounted = false;
+      this.notify(import_types.LifeCycleTypes.ON_FIELD_MOUNT);
+    }, "onMount");
+    this.onUnmount = /* @__PURE__ */ __name(() => {
+      this.mounted = false;
+      this.unmounted = true;
+      this.notify(import_types.LifeCycleTypes.ON_FIELD_UNMOUNT);
+    }, "onUnmount");
+    this.query = /* @__PURE__ */ __name((pattern) => {
+      return new import_Query.Query({
+        pattern,
+        base: this.address,
+        form: this.form
+      });
+    }, "query");
+    this.notify = /* @__PURE__ */ __name((type, payload) => {
+      return this.form.notify(type, payload ?? this);
+    }, "notify");
+    this.dispose = /* @__PURE__ */ __name(() => {
+      this.disposers.forEach((dispose) => {
+        dispose();
+      });
+      this.form.removeEffects(this);
+    }, "dispose");
+    this.destroy = /* @__PURE__ */ __name((forceClear = true) => {
+      (0, import_internals.destroy)(this.form.fields, this.address.toString(), forceClear);
+    }, "destroy");
+    this.match = /* @__PURE__ */ __name((pattern) => {
+      return import_shared.FormPath.parse(pattern).matchAliasGroup(this.address, this.path);
+    }, "match");
+    this.inject = /* @__PURE__ */ __name((actions) => {
+      (0, import_shared.each)(actions, (action, key) => {
+        if ((0, import_shared.isFn)(action)) {
+          this.actions[key] = action;
+        }
+      });
+    }, "inject");
+    this.invoke = /* @__PURE__ */ __name((name, ...args) => {
+      var _a, _b;
+      return (_b = (_a = this.actions)[name]) == null ? void 0 : _b.call(_a, ...args);
+    }, "invoke");
+  }
+  locate(address) {
+    this.form.fields[address.toString()] = this;
+    (0, import_internals.locateNode)(this, address);
+  }
+  get indexes() {
+    return this.path.transform(/^\d+$/, (...args) => args.map((index) => Number(index)));
+  }
+  get index() {
+    return this.indexes[this.indexes.length - 1] ?? -1;
+  }
+  get records() {
+    const array = (0, import_internals.getArrayParent)(this);
+    return array == null ? void 0 : array.value;
+  }
+  get record() {
+    var _a;
+    const obj = (0, import_internals.getObjectParent)(this);
+    if (obj) {
+      return obj.value;
+    }
+    const index = this.index;
+    const array = (0, import_internals.getArrayParent)(this, index);
+    if (array) {
+      return (_a = array.value) == null ? void 0 : _a[index];
+    }
+    return this.form.values;
+  }
+  get component() {
+    return [this.componentType, this.componentProps];
+  }
+  set component(value) {
+    const component = (0, import_shared.toArr)(value);
+    this.componentType = component[0];
+    this.componentProps = component[1] || {};
+  }
+  get decorator() {
+    return [this.decoratorType, this.decoratorProps];
+  }
+  set decorator(value) {
+    const decorator = (0, import_shared.toArr)(value);
+    this.decoratorType = decorator[0];
+    this.decoratorProps = decorator[1] || {};
+  }
+  get parent() {
+    let parent = this.address.parent();
+    let identifier = parent.toString();
+    while (!this.form.fields[identifier]) {
+      parent = parent.parent();
+      identifier = parent.toString();
+      if (!identifier) return;
+    }
+    return this.form.fields[identifier];
+  }
+  get display() {
+    var _a;
+    const parentDisplay = (_a = this.parent) == null ? void 0 : _a.display;
+    if (parentDisplay && parentDisplay !== "visible") {
+      if (this.selfDisplay && this.selfDisplay !== "visible") return this.selfDisplay;
+      return parentDisplay;
+    }
+    if ((0, import_shared.isValid)(this.selfDisplay)) return this.selfDisplay;
+    return parentDisplay || this.form.display || "visible";
+  }
+  get pattern() {
+    var _a;
+    const parentPattern = ((_a = this.parent) == null ? void 0 : _a.pattern) || this.form.pattern || "editable";
+    const selfPattern = this.selfPattern;
+    if ((0, import_shared.isValid)(selfPattern)) {
+      if (parentPattern === "readPretty" && selfPattern !== "editable") {
+        return parentPattern;
+      }
+      return selfPattern;
+    }
+    return parentPattern;
+  }
+  get editable() {
+    return this.pattern === "editable";
+  }
+  get disabled() {
+    return this.pattern === "disabled";
+  }
+  get readOnly() {
+    return this.pattern === "readOnly";
+  }
+  get readPretty() {
+    return this.pattern === "readPretty";
+  }
+  get hidden() {
+    return this.display === "hidden";
+  }
+  get visible() {
+    return this.display === "visible";
+  }
+  get destroyed() {
+    return !this.form.fields[this.address.toString()];
+  }
+  set hidden(hidden) {
+    if (!(0, import_shared.isValid)(hidden)) return;
+    if (hidden) {
+      this.display = "hidden";
+    } else {
+      this.display = "visible";
+    }
+  }
+  set visible(visible) {
+    if (!(0, import_shared.isValid)(visible)) return;
+    if (visible) {
+      this.display = "visible";
+    } else {
+      this.display = "none";
+    }
+  }
+  set editable(editable) {
+    if (!(0, import_shared.isValid)(editable)) return;
+    if (editable) {
+      this.pattern = "editable";
+    } else {
+      this.pattern = "readPretty";
+    }
+  }
+  set readOnly(readOnly) {
+    if (!(0, import_shared.isValid)(readOnly)) return;
+    if (readOnly) {
+      this.pattern = "readOnly";
+    } else {
+      this.pattern = "editable";
+    }
+  }
+  set disabled(disabled) {
+    if (!(0, import_shared.isValid)(disabled)) return;
+    if (disabled) {
+      this.pattern = "disabled";
+    } else {
+      this.pattern = "editable";
+    }
+  }
+  set readPretty(readPretty) {
+    if (!(0, import_shared.isValid)(readPretty)) return;
+    if (readPretty) {
+      this.pattern = "readPretty";
+    } else {
+      this.pattern = "editable";
+    }
+  }
+  set pattern(pattern) {
+    this.selfPattern = pattern;
+  }
+  set display(display) {
+    this.selfDisplay = display;
+  }
+};
+__name(_BaseField, "BaseField");
+let BaseField = _BaseField;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BaseField
+});

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

@@ -0,0 +1,70 @@
+import { FormPathPattern } from '../../shared';
+import { ValidatorTriggerType } from '../../validator';
+import { FeedbackMessage, FieldDataSource, FieldValidator, IFieldCaches, IFieldFeedback, IFieldProps, IFieldRequests, IFieldResetOptions, IFieldState, IFormFeedback, IModelGetter, IModelSetter, ISearchFeedback, JSXComponent } from '../types';
+import { BaseField } from './BaseField';
+import { Form } from './Form';
+export declare class Field<Decorator extends JSXComponent = any, Component extends JSXComponent = any, TextType = any, ValueType = any> extends BaseField<Decorator, Component, TextType> {
+    displayName: string;
+    props: IFieldProps<Decorator, Component, TextType, ValueType>;
+    loading: boolean;
+    validating: boolean;
+    submitting: boolean;
+    active: boolean;
+    visited: boolean;
+    selfModified: boolean;
+    modified: boolean;
+    inputValue: ValueType;
+    inputValues: any[];
+    dataSource: FieldDataSource;
+    validator: FieldValidator;
+    feedbacks: IFieldFeedback[];
+    caches: IFieldCaches;
+    requests: IFieldRequests;
+    constructor(address: FormPathPattern, props: IFieldProps<Decorator, Component, TextType, ValueType>, form: Form, designable: boolean);
+    protected initialize(): void;
+    protected makeObservable(): void;
+    protected makeReactive(): void;
+    get selfErrors(): FeedbackMessage;
+    get errors(): IFormFeedback[];
+    get selfWarnings(): FeedbackMessage;
+    get warnings(): IFormFeedback[];
+    get selfSuccesses(): FeedbackMessage;
+    get successes(): IFormFeedback[];
+    get selfValid(): boolean;
+    get valid(): boolean;
+    get selfInvalid(): boolean;
+    get invalid(): boolean;
+    get value(): ValueType;
+    get initialValue(): ValueType;
+    get required(): boolean;
+    get validateStatus(): "error" | "warning" | "success" | "validating";
+    set required(required: boolean);
+    set value(value: ValueType);
+    set initialValue(initialValue: ValueType);
+    set selfErrors(messages: FeedbackMessage);
+    set selfWarnings(messages: FeedbackMessage);
+    set selfSuccesses(messages: FeedbackMessage);
+    setDataSource: (dataSource?: FieldDataSource) => void;
+    setFeedback: (feedback?: IFieldFeedback) => void;
+    setSelfErrors: (messages?: FeedbackMessage) => void;
+    setSelfWarnings: (messages?: FeedbackMessage) => void;
+    setSelfSuccesses: (messages?: FeedbackMessage) => void;
+    setValidator: (validator?: FieldValidator) => void;
+    setValidatorRule: (name: string, value: any) => void;
+    setRequired: (required?: boolean) => void;
+    setValue: (value?: ValueType) => void;
+    setInitialValue: (initialValue?: ValueType) => void;
+    setLoading: (loading?: boolean) => void;
+    setValidating: (validating?: boolean) => void;
+    setSubmitting: (submitting?: boolean) => void;
+    setState: IModelSetter<IFieldState>;
+    getState: IModelGetter<IFieldState>;
+    onInput: (...args: any[]) => Promise<void>;
+    onFocus: (...args: any[]) => Promise<void>;
+    onBlur: (...args: any[]) => Promise<void>;
+    validate: (triggerType?: ValidatorTriggerType) => Promise<void>;
+    submit: <T>(onSubmit?: (values: any) => Promise<T> | void) => Promise<T>;
+    reset: (options?: IFieldResetOptions) => Promise<void>;
+    queryFeedbacks: (search?: ISearchFeedback) => IFieldFeedback[];
+    modify: () => void;
+}