@tachybase/plugin-form-design 1.3.22

package/dist/client/initializers/EditableDataBlockInitializer.d.ts

@@ -0,0 +1,2 @@
+import { DataBlockInitializerProps } from '@tachybase/client';
+export declare const EditableDataBlockInitializer: (props: DataBlockInitializerProps) => import("react/jsx-runtime").JSX.Element;

package/dist/client/initializers/EditableFormBlockInitialzer.d.ts

@@ -0,0 +1,152 @@
+import { Collection, CollectionFieldOptions } from '@tachybase/client';
+export declare const EditableFormBlockInitializer: ({ filterCollections, onlyCurrentDataSource, hideSearch, createBlockSchema, componentType, templateWrap: customizeTemplateWrap, showAssociationFields, hideChildrenIfSingleCollection, hideOtherRecordsInPopup, currentText, otherText, }: {
+    filterCollections: (options: {
+        collection?: Collection;
+        associationField?: CollectionFieldOptions;
+    }) => boolean;
+    onlyCurrentDataSource: boolean;
+    hideSearch?: boolean;
+    createBlockSchema?: (options: any) => any;
+    componentType?: "FormItem";
+    templateWrap?: (templateSchema: any, { item, }: {
+        item: any;
+    }) => any;
+    showAssociationFields?: boolean;
+    hideChildrenIfSingleCollection?: boolean;
+    hideOtherRecordsInPopup?: boolean;
+    currentText?: string;
+    otherText?: string;
+}) => import("react/jsx-runtime").JSX.Element;
+export declare const useCreateEditableFormBlock: () => {
+    templateWrap: (templateSchema: any, { item }: {
+        item: any;
+    }) => import("@tachybase/schema").Stringify<{
+        [key: symbol]: any;
+        [key: `x-${string}`]: any;
+        [key: `x-${number}`]: any;
+        version?: string;
+        name?: import("@tachybase/schema").SchemaKey;
+        title?: any;
+        description?: any;
+        default?: any;
+        readOnly?: boolean;
+        writeOnly?: boolean;
+        type?: import("@tachybase/schema").SchemaTypes;
+        enum?: import("@tachybase/schema").SchemaEnum<any>;
+        const?: any;
+        multipleOf?: number;
+        maximum?: number;
+        exclusiveMaximum?: number;
+        minimum?: number;
+        exclusiveMinimum?: number;
+        maxLength?: number;
+        minLength?: number;
+        pattern?: string | RegExp;
+        maxItems?: number;
+        minItems?: number;
+        uniqueItems?: boolean;
+        maxProperties?: number;
+        minProperties?: number;
+        required?: string[] | boolean | string;
+        format?: string;
+        $ref?: string;
+        $namespace?: string;
+        definitions?: import("@tachybase/schema").SchemaProperties<any, any, any, any, any, any, any, any>;
+        properties?: import("@tachybase/schema").SchemaProperties<any, any, any, any, any, any, any, any>;
+        items?: import("@tachybase/schema").SchemaItems<any, any, any, any, any, any, any, any>;
+        additionalItems?: import("@tachybase/schema").Stringify</*elided*/ any>;
+        patternProperties?: import("@tachybase/schema").SchemaProperties<any, any, any, any, any, any, any, any>;
+        additionalProperties?: import("@tachybase/schema").Stringify</*elided*/ any>;
+        "x-value"?: any;
+        "x-index"?: number;
+        "x-pattern"?: any;
+        "x-display"?: any;
+        "x-validator"?: any;
+        "x-decorator"?: any;
+        "x-decorator-props"?: any;
+        "x-component"?: any;
+        "x-component-props"?: any;
+        "x-reactions"?: import("@tachybase/schema").SchemaReactions<any>;
+        "x-content"?: any;
+        "x-data"?: any;
+        "x-visible"?: boolean;
+        "x-hidden"?: boolean;
+        "x-disabled"?: boolean;
+        "x-editable"?: boolean;
+        "x-read-only"?: boolean;
+        "x-read-pretty"?: boolean;
+        "x-compile-omitted"?: string[];
+    }>;
+    createEditFormBlock: ({ item, fromOthersInPopup }: {
+        item: any;
+        fromOthersInPopup: any;
+    }) => {
+        type: string;
+        'x-component': string;
+        properties: {
+            [x: string]: {
+                type: string;
+                'x-component': string;
+                properties: {
+                    [x: string]: import("@tachybase/schema").Stringify<{
+                        [key: symbol]: any;
+                        [key: `x-${string}`]: any;
+                        [key: `x-${number}`]: any;
+                        version?: string;
+                        name?: import("@tachybase/schema").SchemaKey;
+                        title?: any;
+                        description?: any;
+                        default?: any;
+                        readOnly?: boolean;
+                        writeOnly?: boolean;
+                        type?: import("@tachybase/schema").SchemaTypes;
+                        enum?: import("@tachybase/schema").SchemaEnum<any>;
+                        const?: any;
+                        multipleOf?: number;
+                        maximum?: number;
+                        exclusiveMaximum?: number;
+                        minimum?: number;
+                        exclusiveMinimum?: number;
+                        maxLength?: number;
+                        minLength?: number;
+                        pattern?: string | RegExp;
+                        maxItems?: number;
+                        minItems?: number;
+                        uniqueItems?: boolean;
+                        maxProperties?: number;
+                        minProperties?: number;
+                        required?: string[] | boolean | string;
+                        format?: string;
+                        $ref?: string;
+                        $namespace?: string;
+                        definitions?: import("@tachybase/schema").SchemaProperties<any, any, any, any, any, any, any, any>;
+                        properties?: import("@tachybase/schema").SchemaProperties<any, any, any, any, any, any, any, any>;
+                        items?: import("@tachybase/schema").SchemaItems<any, any, any, any, any, any, any, any>;
+                        additionalItems?: import("@tachybase/schema").Stringify</*elided*/ any>;
+                        patternProperties?: import("@tachybase/schema").SchemaProperties<any, any, any, any, any, any, any, any>;
+                        additionalProperties?: import("@tachybase/schema").Stringify</*elided*/ any>;
+                        "x-value"?: any;
+                        "x-index"?: number;
+                        "x-pattern"?: any;
+                        "x-display"?: any;
+                        "x-validator"?: any;
+                        "x-decorator"?: any;
+                        "x-decorator-props"?: any;
+                        "x-component"?: any;
+                        "x-component-props"?: any;
+                        "x-reactions"?: import("@tachybase/schema").SchemaReactions<any>;
+                        "x-content"?: any;
+                        "x-data"?: any;
+                        "x-visible"?: boolean;
+                        "x-hidden"?: boolean;
+                        "x-disabled"?: boolean;
+                        "x-editable"?: boolean;
+                        "x-read-only"?: boolean;
+                        "x-read-pretty"?: boolean;
+                        "x-compile-omitted"?: string[];
+                    }>;
+                };
+            };
+        };
+    };
+};

package/dist/client/initializers/FormDesignModalProvider.d.ts

@@ -0,0 +1,3 @@
+export declare const FormDesignModalProvider: (props: {
+    children: React.ReactNode;
+}) => import("react/jsx-runtime").JSX.Element;

package/dist/client/initializers/components/form-editor/EditableDesignable.d.ts

@@ -0,0 +1,94 @@
+import { APIClient } from '@tachybase/client';
+import { GeneralField, ISchema, Query, Schema } from '@tachybase/schema';
+interface CreateDesignableProps {
+    current: Schema;
+    model?: GeneralField;
+    query?: Query;
+    api?: APIClient;
+    refresh?: () => void;
+    onSuccess?: any;
+    t?: any;
+}
+export declare function createEditableDesignable(options: CreateDesignableProps): EditableDesignable;
+/**
+ *
+ */
+type Position = 'beforeBegin' | 'afterBegin' | 'beforeEnd' | 'afterEnd';
+interface InsertAdjacentOptions {
+    wrap?: (s: ISchema) => ISchema;
+    removeParentsIfNoChildren?: boolean;
+    breakRemoveOn?: ISchema | BreakFn;
+    onSuccess?: any;
+}
+type BreakFn = (s: ISchema) => boolean;
+interface RemoveOptions {
+    removeParentsIfNoChildren?: boolean;
+    breakRemoveOn?: ISchema | BreakFn;
+}
+interface RecursiveRemoveOptions {
+    breakRemoveOn?: ISchema | BreakFn;
+}
+declare class EditableDesignable {
+    current: Schema;
+    options: CreateDesignableProps;
+    events: {};
+    constructor(options: CreateDesignableProps);
+    get model(): GeneralField;
+    get query(): Query;
+    loadClientSchemaEvents(): void;
+    prepareProperty(schema: ISchema): void;
+    on(name: 'insertAdjacent' | 'remove' | 'error' | 'patch' | 'batchPatch', listener: any): void;
+    emit(name: 'insertAdjacent' | 'remove' | 'error' | 'patch' | 'batchPatch', ...args: any[]): Promise<any>;
+    parentsIn(schema: Schema): boolean;
+    refresh(): void;
+    deepMerge(schema: ISchema): void;
+    getSchemaAttribute(key: string | string[], defaultValue?: any): any;
+    shallowMerge(schema: ISchema): void;
+    updateModel(key: any, value: any): void;
+    insertAdjacent(position: Position, schema: ISchema, options?: InsertAdjacentOptions): void;
+    recursiveRemoveIfNoChildren(schema?: Schema, options?: RecursiveRemoveOptions): Schema<any, any, any, any, any, any, any, any, any>;
+    remove(schema?: Schema, options?: RemoveOptions): void;
+    removeWithoutEmit(schema?: Schema, options?: RemoveOptions): Schema<any, any, any, any, any, any, any, any, any>;
+    insertBeforeBeginOrAfterEnd(schema: ISchema, options?: InsertAdjacentOptions): void;
+    /**
+     * Before the current schema itself.
+     */
+    insertBeforeBegin(schema: ISchema, options?: InsertAdjacentOptions): void;
+    /**
+     * Just inside the current schema, before its first child.
+     *
+     * @param schema
+     * @returns
+     */
+    insertAfterBegin(schema: ISchema, options?: InsertAdjacentOptions): void;
+    /**
+     * Just inside the targetElement, after its last child.
+     *
+     * @param schema
+     * @returns
+     */
+    insertBeforeEnd(schema: ISchema, options?: InsertAdjacentOptions): void;
+    /**
+     * After the current schema itself.
+     */
+    insertAfterEnd(schema: ISchema, options?: InsertAdjacentOptions): void;
+}
+export declare function useEditableDesignable(): {
+    dn: EditableDesignable;
+    designable: boolean;
+    reset: () => void;
+    refresh: () => void;
+    setDesignable: (value: boolean) => void;
+    DesignableBar: () => import("react/jsx-runtime").JSX.Element;
+    findComponent: (component: any) => any;
+    patch: (key: ISchema | string, value?: any) => void;
+    shallowMerge: (schema: ISchema) => void;
+    deepMerge: (schema: ISchema) => void;
+    remove: (schema?: any, options?: RemoveOptions) => void;
+    insertAdjacent: (position: Position, schema: ISchema, options?: InsertAdjacentOptions) => void;
+    insertBeforeBegin: (schema: ISchema) => void;
+    insertAfterBegin: (schema: ISchema) => void;
+    insertBeforeEnd: (schema: ISchema) => void;
+    insertAfterEnd: (schema: ISchema) => void;
+};
+export {};

package/dist/client/initializers/components/form-editor/EditableDndContext.d.ts

@@ -0,0 +1,2 @@
+import { Props } from '@dnd-kit/core/dist/components/DndContext/DndContext';
+export declare const EditableGridDndContext: import("react").MemoExoticComponent<import("@tachybase/schema").ReactFC<Props>>;

package/dist/client/initializers/components/form-editor/EditableFormItemSchemaToolbar.d.ts

@@ -0,0 +1,4 @@
+import { FC } from 'react';
+import { SchemaToolbarProps } from '@tachybase/client';
+export declare const EditableFormItemSchemaToolbar: (props: any) => import("react/jsx-runtime").JSX.Element;
+export declare const EditableSchemaToolbar: FC<SchemaToolbarProps>;

package/dist/client/initializers/components/form-editor/EditableFormSchemaToolbar.d.ts

@@ -0,0 +1 @@
+export declare const EditableFormToolbar: () => any;

package/dist/client/initializers/components/form-editor/EditableGrid.d.ts

@@ -0,0 +1 @@
+export declare const EditableGrid: any;

package/dist/client/initializers/components/form-editor/EditableGrid.style.d.ts

@@ -0,0 +1,4 @@
+declare const useStyles: (props?: unknown) => import("antd-style").ReturnStyles<{
+    editableGrid: import("antd-style").SerializedStyles;
+}>;
+export default useStyles;

package/dist/client/initializers/components/form-editor/EditableSelectedFieldContext.d.ts

@@ -0,0 +1,19 @@
+import React from 'react';
+import { Form, GeneralField, ISchemaFieldReactFactoryOptions, Schema, SchemaReactComponents } from '@tachybase/schema';
+interface EditableFieldInfo {
+    field: GeneralField | null;
+    fieldSchema: Schema | null;
+    schemaMarkup: Schema | null;
+    expressionScope: any;
+    schemaComponents: SchemaReactComponents | null;
+    schemaOptions: ISchemaFieldReactFactoryOptions | null;
+    form: Form | null;
+    formBlockValue: any;
+    setEditableField: (info: EditableFieldInfoPartial) => void;
+}
+type EditableFieldInfoPartial = Partial<Omit<EditableFieldInfo, 'setEditableField'>>;
+export declare const EditableSelectedFieldProvider: React.FC<{
+    children: React.ReactNode;
+}>;
+export declare const useEditableSelectedField: () => EditableFieldInfo;
+export {};

package/dist/client/initializers/components/form-editor/EditableSelectedFormContent.d.ts

@@ -0,0 +1,19 @@
+import React from 'react';
+import { Form, GeneralField, ISchemaFieldReactFactoryOptions, Schema, SchemaReactComponents } from '@tachybase/schema';
+interface EditableFormInfo {
+    field: GeneralField | null;
+    fieldSchema: Schema | null;
+    schemaMarkup: Schema | null;
+    expressionScope: any;
+    schemaComponents: SchemaReactComponents | null;
+    schemaOptions: ISchemaFieldReactFactoryOptions | null;
+    form: Form | null;
+    formBlockValue: any;
+    setEditableForm: (info: EditableFormInfoPartial) => void;
+}
+type EditableFormInfoPartial = Partial<Omit<EditableFormInfo, 'setEditableForm'>>;
+export declare const EditableSelectedFormProvider: React.FC<{
+    children: React.ReactNode;
+}>;
+export declare const useEditableSelectedForm: () => EditableFormInfo;
+export {};

package/dist/client/initializers/components/form-editor/EditorContent.d.ts

@@ -0,0 +1,6 @@
+import { Schema } from '@tachybase/schema';
+interface EditorContentProps {
+    schema: Schema;
+}
+export declare const EditorContent: import("react").MemoExoticComponent<import("@tachybase/schema").ReactFC<EditorContentProps>>;
+export {};

package/dist/client/initializers/components/form-editor/EditorFieldFormProperty.d.ts

@@ -0,0 +1,5 @@
+export declare const EditorFieldFormProperty: ({ schema, setSchemakey, eddn }: {
+    schema: any;
+    setSchemakey: any;
+    eddn: any;
+}) => import("react/jsx-runtime").JSX.Element;

package/dist/client/initializers/components/form-editor/EditorFieldsSider.d.ts

@@ -0,0 +1,5 @@
+export declare const EditorFieldsSider: ({ schema, setSchemakey, eddn }: {
+    schema: any;
+    setSchemakey: any;
+    eddn: any;
+}) => import("react/jsx-runtime").JSX.Element;

package/dist/client/initializers/components/form-editor/EditorHeader.d.ts

@@ -0,0 +1,4 @@
+export declare const EditorHeader: ({ onCancel, schema }: {
+    onCancel: any;
+    schema: any;
+}) => import("react/jsx-runtime").JSX.Element;

package/dist/client/initializers/components/form-editor/FormSchemaEditor.d.ts

@@ -0,0 +1,15 @@
+import { ISchema } from '@tachybase/schema';
+interface CreateFormBlockUISchemaOptions {
+    dataSource: string;
+    collectionName?: string;
+    association?: string;
+    templateSchema?: ISchema;
+    isCusomeizeCreate?: boolean;
+}
+export declare const FormSchemaEditor: ({ open, onCancel, options }: {
+    open: any;
+    onCancel: any;
+    options: any;
+}) => import("react/jsx-runtime").JSX.Element;
+export declare function createCreateFormEditUISchema(options: CreateFormBlockUISchemaOptions): ISchema;
+export {};

package/dist/client/initializers/components/form-editor/createFormBlockEditableSettings.d.ts

@@ -0,0 +1,2 @@
+import { EditableSchemaSettings } from '../../../editable-schema-settings/EditableSchemaSettings';
+export declare const createFormBlockEditableSettings: EditableSchemaSettings<{}>;

package/dist/client/initializers/components/form-editor/fieldsInterfaceEditableSettings.d.ts

@@ -0,0 +1,3 @@
+import { EditableSchemaSettings } from '../../../editable-schema-settings/EditableSchemaSettings';
+export declare const fieldInterfaceEditableSettings: EditableSchemaSettings<{}>;
+export declare const SetCollectionFieldModalWrapper: (props: any) => import("react/jsx-runtime").JSX.Element;

package/dist/client/initializers/components/form-editor/formItemFieldEditableSettings.d.ts

@@ -0,0 +1,18 @@
+import { Schema } from '@tachybase/schema';
+import { EditableSchemaSettings } from '../../../editable-schema-settings/EditableSchemaSettings';
+export interface FieldOption {
+    name?: string;
+    type?: string;
+    target?: string;
+    title?: string;
+    schema?: Schema;
+    interface?: string;
+    operators?: Operator[];
+    children?: FieldOption[];
+}
+interface Operator {
+    label: string;
+    value: string;
+}
+export declare const formItemFieldEditableSettings: EditableSchemaSettings<{}>;
+export {};

package/dist/client/initializers/components/form-editor/index.d.ts

@@ -0,0 +1,4 @@
+export * from './FormSchemaEditor';
+export * from './EditableFormSchemaToolbar';
+export * from './EditableFormItemSchemaToolbar';
+export * from './EditableSelectedFieldContext';