@tachybase/schema 0.23.41 → 0.23.47

package/lib/core/types.d.ts

@@ -0,0 +1,275 @@
+import { FormPath } from '../shared';
+import { IValidatorRules, Validator, ValidatorTriggerType } from '../validator';
+import { ArrayField, Field, Form, LifeCycle, ObjectField, Query, VoidField } from './models';
+export type NonFunctionPropertyNames<T> = {
+    [K in keyof T]: T[K] extends (...args: any) => any ? never : K;
+}[keyof T];
+export type NonFunctionProperties<T> = Pick<T, NonFunctionPropertyNames<T>>;
+export type AnyFunction = (...args: any[]) => any;
+export type JSXComponent = any;
+export type LifeCycleHandler<T> = (payload: T, context: any) => void;
+export type LifeCyclePayload<T> = (params: {
+    type: string;
+    payload: T;
+}, context: any) => void;
+export declare enum LifeCycleTypes {
+    /**
+     * Form LifeCycle
+     **/
+    ON_FORM_INIT = "onFormInit",
+    ON_FORM_MOUNT = "onFormMount",
+    ON_FORM_UNMOUNT = "onFormUnmount",
+    ON_FORM_INPUT_CHANGE = "onFormInputChange",
+    ON_FORM_VALUES_CHANGE = "onFormValuesChange",
+    ON_FORM_INITIAL_VALUES_CHANGE = "onFormInitialValuesChange",
+    ON_FORM_SUBMIT = "onFormSubmit",
+    ON_FORM_RESET = "onFormReset",
+    ON_FORM_SUBMIT_START = "onFormSubmitStart",
+    ON_FORM_SUBMITTING = "onFormSubmitting",
+    ON_FORM_SUBMIT_END = "onFormSubmitEnd",
+    ON_FORM_SUBMIT_VALIDATE_START = "onFormSubmitValidateStart",
+    ON_FORM_SUBMIT_VALIDATE_SUCCESS = "onFormSubmitValidateSuccess",
+    ON_FORM_SUBMIT_VALIDATE_FAILED = "onFormSubmitValidateFailed",
+    ON_FORM_SUBMIT_VALIDATE_END = "onFormSubmitValidateEnd",
+    ON_FORM_SUBMIT_SUCCESS = "onFormSubmitSuccess",
+    ON_FORM_SUBMIT_FAILED = "onFormSubmitFailed",
+    ON_FORM_VALIDATE_START = "onFormValidateStart",
+    ON_FORM_VALIDATING = "onFormValidating",
+    ON_FORM_VALIDATE_SUCCESS = "onFormValidateSuccess",
+    ON_FORM_VALIDATE_FAILED = "onFormValidateFailed",
+    ON_FORM_VALIDATE_END = "onFormValidateEnd",
+    ON_FORM_GRAPH_CHANGE = "onFormGraphChange",
+    ON_FORM_LOADING = "onFormLoading",
+    /**
+     * Field LifeCycle
+     **/
+    ON_FIELD_INIT = "onFieldInit",
+    ON_FIELD_INPUT_VALUE_CHANGE = "onFieldInputValueChange",
+    ON_FIELD_VALUE_CHANGE = "onFieldValueChange",
+    ON_FIELD_INITIAL_VALUE_CHANGE = "onFieldInitialValueChange",
+    ON_FIELD_SUBMIT = "onFieldSubmit",
+    ON_FIELD_SUBMIT_START = "onFieldSubmitStart",
+    ON_FIELD_SUBMITTING = "onFieldSubmitting",
+    ON_FIELD_SUBMIT_END = "onFieldSubmitEnd",
+    ON_FIELD_SUBMIT_VALIDATE_START = "onFieldSubmitValidateStart",
+    ON_FIELD_SUBMIT_VALIDATE_SUCCESS = "onFieldSubmitValidateSuccess",
+    ON_FIELD_SUBMIT_VALIDATE_FAILED = "onFieldSubmitValidateFailed",
+    ON_FIELD_SUBMIT_VALIDATE_END = "onFieldSubmitValidateEnd",
+    ON_FIELD_SUBMIT_SUCCESS = "onFieldSubmitSuccess",
+    ON_FIELD_SUBMIT_FAILED = "onFieldSubmitFailed",
+    ON_FIELD_VALIDATE_START = "onFieldValidateStart",
+    ON_FIELD_VALIDATING = "onFieldValidating",
+    ON_FIELD_VALIDATE_SUCCESS = "onFieldValidateSuccess",
+    ON_FIELD_VALIDATE_FAILED = "onFieldValidateFailed",
+    ON_FIELD_VALIDATE_END = "onFieldValidateEnd",
+    ON_FIELD_LOADING = "onFieldLoading",
+    ON_FIELD_RESET = "onFieldReset",
+    ON_FIELD_MOUNT = "onFieldMount",
+    ON_FIELD_UNMOUNT = "onFieldUnmount"
+}
+export type HeartSubscriber = ({ type, payload }: {
+    type: string;
+    payload: any;
+}) => void;
+export interface INodePatch<T> {
+    type: 'remove' | 'update';
+    address: string;
+    oldAddress?: string;
+    payload?: T;
+}
+export interface IHeartProps<Context> {
+    lifecycles?: LifeCycle[];
+    context?: Context;
+}
+export interface IFieldFeedback {
+    triggerType?: FieldFeedbackTriggerTypes;
+    type?: FieldFeedbackTypes;
+    code?: FieldFeedbackCodeTypes;
+    messages?: FeedbackMessage;
+}
+export type IFormFeedback = IFieldFeedback & {
+    path?: string;
+    address?: string;
+};
+export interface ISearchFeedback {
+    triggerType?: FieldFeedbackTriggerTypes;
+    type?: FieldFeedbackTypes;
+    code?: FieldFeedbackCodeTypes;
+    address?: FormPathPattern;
+    path?: FormPathPattern;
+    messages?: FeedbackMessage;
+}
+export type FeedbackMessage = any[];
+export type IFieldUpdate = {
+    pattern: FormPath;
+    callbacks: ((...args: any[]) => any)[];
+};
+export interface IFormRequests {
+    validate?: ReturnType<typeof setTimeout>;
+    submit?: ReturnType<typeof setTimeout>;
+    loading?: ReturnType<typeof setTimeout>;
+    updates?: IFieldUpdate[];
+    updateIndexes?: Record<string, number>;
+}
+export type IFormFields = Record<string, GeneralField>;
+export type FieldFeedbackTypes = 'error' | 'success' | 'warning';
+export type FieldFeedbackTriggerTypes = ValidatorTriggerType;
+export type FieldFeedbackCodeTypes = 'ValidateError' | 'ValidateSuccess' | 'ValidateWarning' | 'EffectError' | 'EffectSuccess' | 'EffectWarning' | (string & {});
+export type FormPatternTypes = 'editable' | 'readOnly' | 'disabled' | 'readPretty' | ({} & string);
+export type FormDisplayTypes = 'none' | 'hidden' | 'visible' | ({} & string);
+export type FormPathPattern = string | number | Array<string | number> | FormPath | RegExp | (((address: Array<string | number>) => boolean) & {
+    path: FormPath;
+});
+type OmitState<P> = Omit<P, 'selfDisplay' | 'selfPattern' | 'originValues' | 'originInitialValues' | 'id' | 'address' | 'path' | 'lifecycles' | 'disposers' | 'requests' | 'fields' | 'graph' | 'heart' | 'indexes' | 'props' | 'displayName' | 'setState' | 'getState' | 'getFormGraph' | 'setFormGraph' | 'setFormState' | 'getFormState'>;
+export type IFieldState = Partial<Pick<Field, NonFunctionPropertyNames<OmitState<Field<any, any, string, string>>>>>;
+export type IVoidFieldState = Partial<Pick<VoidField, NonFunctionPropertyNames<OmitState<VoidField<any, any, string>>>>>;
+export type IFormState<T extends Record<any, any> = any> = Pick<Form<T>, NonFunctionPropertyNames<OmitState<Form<{
+    [key: string]: any;
+}>>>>;
+export type IFormGraph = Record<string, IGeneralFieldState | IFormState>;
+export interface IFormProps<T extends object = any> {
+    values?: Partial<T>;
+    initialValues?: Partial<T>;
+    pattern?: FormPatternTypes;
+    display?: FormDisplayTypes;
+    hidden?: boolean;
+    visible?: boolean;
+    editable?: boolean;
+    disabled?: boolean;
+    readOnly?: boolean;
+    readPretty?: boolean;
+    effects?: (form: Form<T>) => void;
+    validateFirst?: boolean;
+    validatePattern?: FormPatternTypes[];
+    validateDisplay?: FormDisplayTypes[];
+    designable?: boolean;
+}
+export type IFormMergeStrategy = 'overwrite' | 'merge' | 'deepMerge' | 'shallowMerge';
+export interface IFieldFactoryProps<Decorator extends JSXComponent, Component extends JSXComponent, TextType = any, ValueType = any> extends IFieldProps<Decorator, Component, TextType, ValueType> {
+    name: FormPathPattern;
+    basePath?: FormPathPattern;
+}
+export interface IVoidFieldFactoryProps<Decorator extends JSXComponent, Component extends JSXComponent, TextType = any> extends IVoidFieldProps<Decorator, Component, TextType> {
+    name: FormPathPattern;
+    basePath?: FormPathPattern;
+}
+export interface IFieldRequests {
+    validate?: ReturnType<typeof setTimeout>;
+    submit?: ReturnType<typeof setTimeout>;
+    loading?: ReturnType<typeof setTimeout>;
+    batch?: () => void;
+}
+export interface IFieldCaches {
+    value?: any;
+    initialValue?: any;
+    inputting?: boolean;
+}
+export type FieldDisplayTypes = 'none' | 'hidden' | 'visible' | ({} & string);
+export type FieldPatternTypes = 'editable' | 'readOnly' | 'disabled' | 'readPretty' | ({} & string);
+export type FieldValidatorContext = IValidatorRules & {
+    field?: Field;
+    form?: Form;
+    value?: any;
+};
+export type FieldValidator = Validator<FieldValidatorContext>;
+export type FieldDataSource = {
+    label?: any;
+    value?: any;
+    title?: any;
+    key?: any;
+    text?: any;
+    children?: FieldDataSource;
+    [key: string]: any;
+}[];
+export type FieldComponent<Component extends JSXComponent, ComponentProps = any> = [Component] | [Component, ComponentProps] | boolean | any[];
+export type FieldDecorator<Decorator extends JSXComponent, ComponentProps = any> = [Decorator] | [Decorator, ComponentProps] | boolean | any[];
+export type FieldReaction = (field: Field) => void;
+export interface IFieldProps<Decorator extends JSXComponent = any, Component extends JSXComponent = any, TextType = any, ValueType = any> {
+    name: FormPathPattern;
+    basePath?: FormPathPattern;
+    title?: TextType;
+    description?: TextType;
+    value?: ValueType;
+    initialValue?: ValueType;
+    required?: boolean;
+    display?: FieldDisplayTypes;
+    pattern?: FieldPatternTypes;
+    hidden?: boolean;
+    visible?: boolean;
+    editable?: boolean;
+    disabled?: boolean;
+    readOnly?: boolean;
+    readPretty?: boolean;
+    dataSource?: FieldDataSource;
+    validateFirst?: boolean;
+    validatePattern?: FieldPatternTypes[];
+    validateDisplay?: FieldDisplayTypes[];
+    validator?: FieldValidator;
+    decorator?: FieldDecorator<Decorator>;
+    component?: FieldComponent<Component>;
+    reactions?: FieldReaction[] | FieldReaction;
+    content?: any;
+    data?: any;
+}
+export interface IVoidFieldProps<Decorator extends JSXComponent = any, Component extends JSXComponent = any, TextType = any> {
+    name: FormPathPattern;
+    basePath?: FormPathPattern;
+    title?: TextType;
+    description?: TextType;
+    display?: FieldDisplayTypes;
+    pattern?: FieldPatternTypes;
+    hidden?: boolean;
+    visible?: boolean;
+    editable?: boolean;
+    disabled?: boolean;
+    readOnly?: boolean;
+    readPretty?: boolean;
+    decorator?: FieldDecorator<Decorator>;
+    component?: FieldComponent<Component>;
+    reactions?: FieldReaction[] | FieldReaction;
+    content?: any;
+    data?: any;
+}
+export interface IFieldResetOptions {
+    forceClear?: boolean;
+    validate?: boolean;
+}
+export type IGeneralFieldState = IFieldState & IVoidFieldState;
+export type GeneralField = Field | VoidField | ArrayField | ObjectField;
+export type DataField = Field | ArrayField | ObjectField;
+export interface ISpliceArrayStateProps {
+    startIndex?: number;
+    deleteCount?: number;
+    insertCount?: number;
+}
+export interface IExchangeArrayStateProps {
+    fromIndex?: number;
+    toIndex?: number;
+}
+export interface IQueryProps {
+    pattern: FormPathPattern;
+    base: FormPathPattern;
+    form: Form;
+}
+export interface IModelSetter<P = any> {
+    (setter: (state: P) => void): void;
+    (setter: Partial<P>): void;
+    (): void;
+}
+export interface IModelGetter<P = any> {
+    <Getter extends (state: P) => any>(getter: Getter): ReturnType<Getter>;
+    (): P;
+}
+export type FieldMatchPattern = FormPathPattern | Query | GeneralField;
+export interface IFieldStateSetter {
+    (pattern: FieldMatchPattern, setter: (state: IFieldState) => void): void;
+    (pattern: FieldMatchPattern, setter: Partial<IFieldState>): void;
+}
+export interface IFieldStateGetter {
+    <Getter extends (state: IGeneralFieldState) => any>(pattern: FieldMatchPattern, getter: Getter): ReturnType<Getter>;
+    (pattern: FieldMatchPattern): IGeneralFieldState;
+}
+export interface IFieldActions {
+    [key: string]: (...args: any[]) => any;
+}
+export {};

package/lib/core/types.js

@@ -0,0 +1,76 @@
+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 types_exports = {};
+__export(types_exports, {
+  LifeCycleTypes: () => LifeCycleTypes
+});
+module.exports = __toCommonJS(types_exports);
+var LifeCycleTypes = /* @__PURE__ */ ((LifeCycleTypes2) => {
+  LifeCycleTypes2["ON_FORM_INIT"] = "onFormInit";
+  LifeCycleTypes2["ON_FORM_MOUNT"] = "onFormMount";
+  LifeCycleTypes2["ON_FORM_UNMOUNT"] = "onFormUnmount";
+  LifeCycleTypes2["ON_FORM_INPUT_CHANGE"] = "onFormInputChange";
+  LifeCycleTypes2["ON_FORM_VALUES_CHANGE"] = "onFormValuesChange";
+  LifeCycleTypes2["ON_FORM_INITIAL_VALUES_CHANGE"] = "onFormInitialValuesChange";
+  LifeCycleTypes2["ON_FORM_SUBMIT"] = "onFormSubmit";
+  LifeCycleTypes2["ON_FORM_RESET"] = "onFormReset";
+  LifeCycleTypes2["ON_FORM_SUBMIT_START"] = "onFormSubmitStart";
+  LifeCycleTypes2["ON_FORM_SUBMITTING"] = "onFormSubmitting";
+  LifeCycleTypes2["ON_FORM_SUBMIT_END"] = "onFormSubmitEnd";
+  LifeCycleTypes2["ON_FORM_SUBMIT_VALIDATE_START"] = "onFormSubmitValidateStart";
+  LifeCycleTypes2["ON_FORM_SUBMIT_VALIDATE_SUCCESS"] = "onFormSubmitValidateSuccess";
+  LifeCycleTypes2["ON_FORM_SUBMIT_VALIDATE_FAILED"] = "onFormSubmitValidateFailed";
+  LifeCycleTypes2["ON_FORM_SUBMIT_VALIDATE_END"] = "onFormSubmitValidateEnd";
+  LifeCycleTypes2["ON_FORM_SUBMIT_SUCCESS"] = "onFormSubmitSuccess";
+  LifeCycleTypes2["ON_FORM_SUBMIT_FAILED"] = "onFormSubmitFailed";
+  LifeCycleTypes2["ON_FORM_VALIDATE_START"] = "onFormValidateStart";
+  LifeCycleTypes2["ON_FORM_VALIDATING"] = "onFormValidating";
+  LifeCycleTypes2["ON_FORM_VALIDATE_SUCCESS"] = "onFormValidateSuccess";
+  LifeCycleTypes2["ON_FORM_VALIDATE_FAILED"] = "onFormValidateFailed";
+  LifeCycleTypes2["ON_FORM_VALIDATE_END"] = "onFormValidateEnd";
+  LifeCycleTypes2["ON_FORM_GRAPH_CHANGE"] = "onFormGraphChange";
+  LifeCycleTypes2["ON_FORM_LOADING"] = "onFormLoading";
+  LifeCycleTypes2["ON_FIELD_INIT"] = "onFieldInit";
+  LifeCycleTypes2["ON_FIELD_INPUT_VALUE_CHANGE"] = "onFieldInputValueChange";
+  LifeCycleTypes2["ON_FIELD_VALUE_CHANGE"] = "onFieldValueChange";
+  LifeCycleTypes2["ON_FIELD_INITIAL_VALUE_CHANGE"] = "onFieldInitialValueChange";
+  LifeCycleTypes2["ON_FIELD_SUBMIT"] = "onFieldSubmit";
+  LifeCycleTypes2["ON_FIELD_SUBMIT_START"] = "onFieldSubmitStart";
+  LifeCycleTypes2["ON_FIELD_SUBMITTING"] = "onFieldSubmitting";
+  LifeCycleTypes2["ON_FIELD_SUBMIT_END"] = "onFieldSubmitEnd";
+  LifeCycleTypes2["ON_FIELD_SUBMIT_VALIDATE_START"] = "onFieldSubmitValidateStart";
+  LifeCycleTypes2["ON_FIELD_SUBMIT_VALIDATE_SUCCESS"] = "onFieldSubmitValidateSuccess";
+  LifeCycleTypes2["ON_FIELD_SUBMIT_VALIDATE_FAILED"] = "onFieldSubmitValidateFailed";
+  LifeCycleTypes2["ON_FIELD_SUBMIT_VALIDATE_END"] = "onFieldSubmitValidateEnd";
+  LifeCycleTypes2["ON_FIELD_SUBMIT_SUCCESS"] = "onFieldSubmitSuccess";
+  LifeCycleTypes2["ON_FIELD_SUBMIT_FAILED"] = "onFieldSubmitFailed";
+  LifeCycleTypes2["ON_FIELD_VALIDATE_START"] = "onFieldValidateStart";
+  LifeCycleTypes2["ON_FIELD_VALIDATING"] = "onFieldValidating";
+  LifeCycleTypes2["ON_FIELD_VALIDATE_SUCCESS"] = "onFieldValidateSuccess";
+  LifeCycleTypes2["ON_FIELD_VALIDATE_FAILED"] = "onFieldValidateFailed";
+  LifeCycleTypes2["ON_FIELD_VALIDATE_END"] = "onFieldValidateEnd";
+  LifeCycleTypes2["ON_FIELD_LOADING"] = "onFieldLoading";
+  LifeCycleTypes2["ON_FIELD_RESET"] = "onFieldReset";
+  LifeCycleTypes2["ON_FIELD_MOUNT"] = "onFieldMount";
+  LifeCycleTypes2["ON_FIELD_UNMOUNT"] = "onFieldUnmount";
+  return LifeCycleTypes2;
+})(LifeCycleTypes || {});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  LifeCycleTypes
+});

package/lib/grid/index.d.ts

@@ -0,0 +1,67 @@
+export interface IGridOptions {
+    maxRows?: number;
+    maxColumns?: number | number[];
+    minColumns?: number | number[];
+    maxWidth?: number | number[];
+    minWidth?: number | number[];
+    breakpoints?: number[];
+    columnGap?: number;
+    rowGap?: number;
+    colWrap?: boolean;
+    strictAutoFit?: boolean;
+    shouldVisible?: (node: GridNode, grid: Grid<HTMLElement>) => boolean;
+    onDigest?: (grid: Grid<HTMLElement>) => void;
+    onInitialized?: (grid: Grid<HTMLElement>) => void;
+}
+export type GridNode = {
+    index?: number;
+    visible?: boolean;
+    column?: number;
+    shadowColumn?: number;
+    row?: number;
+    shadowRow?: number;
+    span?: number;
+    originSpan?: number;
+    element?: HTMLElement;
+};
+export declare class Grid<Container extends HTMLElement> {
+    options: IGridOptions;
+    width: number;
+    height: number;
+    container: Container;
+    children: GridNode[];
+    childTotalColumns: number;
+    shadowChildTotalColumns: number;
+    childOriginTotalColumns: number;
+    shadowChildOriginTotalColumns: number;
+    ready: boolean;
+    constructor(options?: IGridOptions);
+    set breakpoints(breakpoints: number[]);
+    get breakpoints(): number[];
+    get breakpoint(): number;
+    set maxWidth(maxWidth: number);
+    get maxWidth(): number;
+    set minWidth(minWidth: number);
+    get minWidth(): number;
+    set maxColumns(maxColumns: number);
+    get maxColumns(): number;
+    set maxRows(maxRows: number);
+    get maxRows(): number;
+    set minColumns(minColumns: number);
+    get minColumns(): number;
+    set rowGap(rowGap: number);
+    get rowGap(): number;
+    set columnGap(columnGap: number);
+    get columnGap(): number;
+    set colWrap(colWrap: boolean);
+    get colWrap(): boolean;
+    get columns(): number;
+    get rows(): number;
+    get shadowRows(): number;
+    get templateColumns(): string;
+    get gap(): string;
+    get childSize(): number;
+    get fullnessLastColumn(): boolean;
+    connect: (container: Container) => () => void;
+    static id: (options?: IGridOptions) => string;
+}