amis-core 1.0.0-beta.0

package/dist/src/WithStore.d.ts

@@ -0,0 +1,5 @@
+export declare function HocStoreFactory(renderer: {
+    storeType: string;
+    extendsData?: boolean | ((props: any) => boolean);
+    shouldSyncSuperStore?: (store: any, props: any, prevProps: any) => boolean | undefined;
+}): any;

package/dist/src/actions/Action.d.ts

@@ -0,0 +1,38 @@
+/// <reference types="react" />
+import { RendererProps } from '../factory';
+import { RendererEvent } from '../utils/renderer-event';
+import { IBreakAction } from './BreakAction';
+import { IContinueAction } from './ContinueAction';
+import { ILoopAction } from './LoopAction';
+import { IParallelAction } from './ParallelAction';
+import { ISwitchAction } from './SwitchAction';
+export declare enum LoopStatus {
+    NORMAL = 0,
+    BREAK = 1,
+    CONTINUE = 2
+}
+export interface ListenerAction {
+    actionType: string;
+    description?: string;
+    componentId?: string;
+    args?: Record<string, any>;
+    outputVar?: string;
+    preventDefault?: boolean;
+    stopPropagation?: boolean;
+    expression?: string;
+    execOn?: string;
+}
+export interface ILogicAction extends ListenerAction {
+    children?: ListenerAction[];
+}
+export declare type LogicAction = IParallelAction | ISwitchAction | ILoopAction | IContinueAction | IBreakAction;
+export interface ListenerContext extends React.Component<RendererProps> {
+    [propName: string]: any;
+}
+export interface RendererAction {
+    run: (action: ListenerAction, renderer: ListenerContext, event: RendererEvent<any>, mergeData?: any) => Promise<RendererEvent<any> | void>;
+}
+export declare const registerAction: (type: string, action: RendererAction) => void;
+export declare const getActionByType: (type: string) => RendererAction;
+export declare const runActions: (actions: ListenerAction | ListenerAction[], renderer: ListenerContext, event: any) => Promise<void>;
+export declare const runAction: (actionInstrance: RendererAction, actionConfig: ListenerAction, renderer: ListenerContext, event: any) => Promise<void>;

package/dist/src/actions/AjaxAction.d.ts

@@ -0,0 +1,25 @@
+import { Api } from '../types';
+import { RendererEvent } from '../utils/renderer-event';
+import { RendererAction, ListenerAction, ListenerContext } from './Action';
+export interface IAjaxAction extends ListenerAction {
+    action: 'ajax';
+    args: {
+        api: Api;
+        messages?: {
+            success: string;
+            failed: string;
+        };
+        options?: Record<string, any>;
+        [propName: string]: any;
+    };
+}
+/**
+ * 发送请求动作
+ *
+ * @export
+ * @class AjaxAction
+ * @implements {Action}
+ */
+export declare class AjaxAction implements RendererAction {
+    run(action: IAjaxAction, renderer: ListenerContext, event: RendererEvent<any>): Promise<any>;
+}

package/dist/src/actions/BreakAction.d.ts

@@ -0,0 +1,15 @@
+import { RendererEvent } from '../utils/renderer-event';
+import { RendererAction, ListenerContext, ILogicAction } from './Action';
+export interface IBreakAction extends ILogicAction {
+    actionType: 'break';
+}
+/**
+ * breach
+ *
+ * @export
+ * @class BreakAction
+ * @implements {Action}
+ */
+export declare class BreakAction implements RendererAction {
+    run(action: IBreakAction, renderer: ListenerContext, event: RendererEvent<any>): Promise<void>;
+}

package/dist/src/actions/BroadcastAction.d.ts

@@ -0,0 +1,16 @@
+import { RendererEvent } from '../utils/renderer-event';
+import { RendererAction, ListenerAction, ListenerContext } from './Action';
+export interface IBroadcastAction extends ListenerAction {
+    actionType: 'broadcast';
+    eventName: string;
+}
+/**
+ * broadcast
+ *
+ * @export
+ * @class BroadcastAction
+ * @implements {Action}
+ */
+export declare class BroadcastAction implements RendererAction {
+    run(action: IBroadcastAction, renderer: ListenerContext, event: RendererEvent<any>): Promise<void | RendererEvent<any, any>>;
+}

package/dist/src/actions/CmptAction.d.ts

@@ -0,0 +1,20 @@
+import { RendererEvent } from '../utils/renderer-event';
+import { RendererAction, ListenerAction, ListenerContext } from './Action';
+export interface ICmptAction extends ListenerAction {
+    actionType: 'setValue' | 'show' | 'hidden' | 'enabled' | 'disabled' | 'reload';
+    args: {
+        value?: string | {
+            [key: string]: string;
+        };
+    };
+}
+/**
+ * 组件动作
+ *
+ * @export
+ * @class CmptAction
+ * @implements {Action}
+ */
+export declare class CmptAction implements RendererAction {
+    run(action: ICmptAction, renderer: ListenerContext, event: RendererEvent<any>): Promise<any>;
+}

package/dist/src/actions/ContinueAction.d.ts

@@ -0,0 +1,15 @@
+import { RendererEvent } from '../utils/renderer-event';
+import { RendererAction, ListenerContext, ILogicAction } from './Action';
+export interface IContinueAction extends ILogicAction {
+    actionType: 'continue';
+}
+/**
+ * continue
+ *
+ * @export
+ * @class ContinueAction
+ * @implements {Action}
+ */
+export declare class ContinueAction implements RendererAction {
+    run(action: IContinueAction, renderer: ListenerContext, event: RendererEvent<any>): Promise<void>;
+}

package/dist/src/actions/CopyAction.d.ts

@@ -0,0 +1,20 @@
+import { RendererEvent } from '../utils/renderer-event';
+import { RendererAction, ListenerAction, ListenerContext } from './Action';
+export interface ICopyAction extends ListenerAction {
+    actionType: 'copy';
+    args: {
+        content: string;
+        copyFormat?: string;
+        [propName: string]: any;
+    };
+}
+/**
+ * 复制动作
+ *
+ * @export
+ * @class CopyAction
+ * @implements {Action}
+ */
+export declare class CopyAction implements RendererAction {
+    run(action: ICopyAction, renderer: ListenerContext, event: RendererEvent<any>): Promise<void>;
+}

package/dist/src/actions/CustomAction.d.ts

@@ -0,0 +1,17 @@
+import { Action } from '../types';
+import { RendererEvent } from '../utils/renderer-event';
+import { RendererAction, ListenerAction, ListenerContext } from './Action';
+export interface ICustomAction extends ListenerAction {
+    actionType: 'custom';
+    script: string | ((renderer: any, doAction: (action: Action, data: Record<string, any>) => void, event: RendererEvent<any>, action: ListenerAction) => void);
+}
+/**
+ * 自定义动作，JS脚本
+ *
+ * @export
+ * @class CustomAction
+ * @implements {Action}
+ */
+export declare class CustomAction implements RendererAction {
+    run(action: ICustomAction, renderer: ListenerContext, event: RendererEvent<any>): Promise<void>;
+}

package/dist/src/actions/Decorators.d.ts

@@ -0,0 +1,25 @@
+import { FormControlProps } from '../renderers/Item';
+import type { RendererEvent } from '../utils/renderer-event';
+/**
+ * 渲染器事件派发
+ *
+ * @param props 组件props
+ * @param e 事件类型
+ * @param ctx 上下文数据
+ */
+export declare function rendererEventDispatcher<T extends FormControlProps, E = any>(props: T, e: E, ctx?: Record<string, any>): Promise<RendererEvent<any> | undefined>;
+/**
+ * 渲染器事件方法装饰器
+ *
+ * @param event 事件类型
+ * @param ctx 上下文数据
+ * @returns {Function}
+ */
+export declare function bindRendererEvent<T extends FormControlProps, E = any>(event: E, ctx?: Record<string, any>): (target: any, propertyKey: string, descriptor: TypedPropertyDescriptor<any>) => {
+    value: (...params: any[]) => Promise<any>;
+    enumerable?: boolean | undefined;
+    configurable?: boolean | undefined;
+    writable?: boolean | undefined;
+    get?: (() => any) | undefined;
+    set?: ((value: any) => void) | undefined;
+};

package/dist/src/actions/DialogAction.d.ts

@@ -0,0 +1,57 @@
+import { SchemaNode } from '../types';
+import { RendererEvent } from '../utils/renderer-event';
+import { RendererAction, ListenerAction, ListenerContext } from './Action';
+export interface IAlertAction extends ListenerAction {
+    actionType: 'alert';
+    args: {
+        msg: string;
+        [propName: string]: any;
+    };
+}
+export interface IConfirmAction extends ListenerAction {
+    actionType: 'confirm';
+    args: {
+        title: string;
+        msg: string;
+        [propName: string]: any;
+    };
+}
+export interface IDialogAction extends ListenerAction {
+    actionType: 'dialog';
+    dialog: SchemaNode;
+}
+/**
+ * 打开弹窗动作
+ *
+ * @export
+ * @class DialogAction
+ * @implements {Action}
+ */
+export declare class DialogAction implements RendererAction {
+    run(action: IDialogAction, renderer: ListenerContext, event: RendererEvent<any>): Promise<void>;
+}
+export interface ICloseDialogAction extends ListenerAction {
+    actionType: 'closeDialog';
+}
+/**
+ * 关闭弹窗动作
+ *
+ * @export
+ * @class CloseDialogAction
+ * @implements {Action}
+ */
+export declare class CloseDialogAction implements RendererAction {
+    run(action: ListenerAction, renderer: ListenerContext, event: RendererEvent<any>): Promise<void>;
+}
+/**
+ * alert提示动作
+ */
+export declare class AlertAction implements RendererAction {
+    run(action: IAlertAction, renderer: ListenerContext, event: RendererEvent<any>): Promise<void>;
+}
+/**
+ * confirm确认提示动作
+ */
+export declare class ConfirmAction implements RendererAction {
+    run(action: IConfirmAction, renderer: ListenerContext, event: RendererEvent<any>): Promise<void>;
+}

package/dist/src/actions/DrawerAction.d.ts

@@ -0,0 +1,30 @@
+import { SchemaNode } from '../types';
+import { RendererEvent } from '../utils/renderer-event';
+import { RendererAction, ListenerAction, ListenerContext } from './Action';
+export interface IDrawerAction extends ListenerAction {
+    actionType: 'drawer';
+    drawer: SchemaNode;
+}
+/**
+ * 打开抽屉动作
+ *
+ * @export
+ * @class DrawerAction
+ * @implements {Action}
+ */
+export declare class DrawerAction implements RendererAction {
+    run(action: IDrawerAction, renderer: ListenerContext, event: RendererEvent<any>): Promise<void>;
+}
+export interface ICloseDrawerAction extends ListenerAction {
+    actionType: 'closeDrawer';
+}
+/**
+ * 关闭抽屉动作
+ *
+ * @export
+ * @class CloseDrawerAction
+ * @implements {Action}
+ */
+export declare class CloseDrawerAction implements RendererAction {
+    run(action: ListenerAction, renderer: ListenerContext, event: RendererEvent<any>): Promise<void>;
+}

package/dist/src/actions/EmailAction.d.ts

@@ -0,0 +1,23 @@
+import { RendererEvent } from '../utils/renderer-event';
+import { RendererAction, ListenerContext, ListenerAction } from './Action';
+export interface IEmailAction extends ListenerAction {
+    actionType: 'email';
+    args: {
+        to: string;
+        cc: string;
+        bcc: string;
+        subject: string;
+        body: string;
+        [propName: string]: any;
+    };
+}
+/**
+ * 邮件动作
+ *
+ * @export
+ * @class EmailAction
+ * @implements {Action}
+ */
+export declare class EmailAction implements RendererAction {
+    run(action: IEmailAction, renderer: ListenerContext, event: RendererEvent<any>): Promise<void>;
+}

package/dist/src/actions/LinkAction.d.ts

@@ -0,0 +1,24 @@
+import { RendererEvent } from '../utils/renderer-event';
+import { RendererAction, ListenerContext, ListenerAction } from './Action';
+export interface ILinkAction extends ListenerAction {
+    actionType: 'link' | 'url' | 'jump';
+    args: {
+        link?: string;
+        url?: string;
+        blank?: boolean;
+        params?: {
+            [key: string]: string;
+        };
+        [propName: string]: any;
+    };
+}
+/**
+ * 打开页面动作
+ *
+ * @export
+ * @class LinkAction
+ * @implements {Action}
+ */
+export declare class LinkAction implements RendererAction {
+    run(action: ILinkAction, renderer: ListenerContext, event: RendererEvent<any>): Promise<void>;
+}

package/dist/src/actions/LoopAction.d.ts

@@ -0,0 +1,19 @@
+import { RendererEvent } from '../utils/renderer-event';
+import { RendererAction, ListenerContext, ILogicAction } from './Action';
+export interface ILoopAction extends ILogicAction {
+    actionType: 'loop';
+    args: {
+        loopName: string;
+        [propName: string]: any;
+    };
+}
+/**
+ * 循环动作
+ *
+ * @export
+ * @class LoopAction
+ * @implements {Action}
+ */
+export declare class LoopAction implements RendererAction {
+    run(action: ILoopAction, renderer: ListenerContext, event: RendererEvent<any>, mergeData: any): Promise<void>;
+}

package/dist/src/actions/PageAction.d.ts

@@ -0,0 +1,39 @@
+import { RendererEvent } from '../utils/renderer-event';
+import { RendererAction, ListenerAction, ListenerContext } from './Action';
+export interface IPageGoAction extends ListenerAction {
+    actionType: 'goBack' | 'refresh' | 'goPage';
+    args: {
+        delta?: number;
+        [propName: string]: any;
+    };
+}
+/**
+ * 返回上个页面
+ *
+ * @export
+ * @class PageGoBackAction
+ * @implements {Action}
+ */
+export declare class PageGoBackAction implements RendererAction {
+    run(action: IPageGoAction, renderer: ListenerContext, event: RendererEvent<any>): Promise<void>;
+}
+/**
+ * 到指定页面
+ *
+ * @export
+ * @class PageGoAction
+ * @implements {Action}
+ */
+export declare class PageGoAction implements RendererAction {
+    run(action: IPageGoAction, renderer: ListenerContext, event: RendererEvent<any>): Promise<void>;
+}
+/**
+ * 浏览器刷新
+ *
+ * @export
+ * @class PageRefreshAction
+ * @implements {Action}
+ */
+export declare class PageRefreshAction implements RendererAction {
+    run(action: IPageGoAction, renderer: ListenerContext, event: RendererEvent<any>): Promise<void>;
+}

package/dist/src/actions/ParallelAction.d.ts

@@ -0,0 +1,8 @@
+import { RendererEvent } from '../utils/renderer-event';
+import { RendererAction, ListenerContext, ILogicAction } from './Action';
+export interface IParallelAction extends ILogicAction {
+    actionType: 'parallel';
+}
+export declare class ParallelAction implements RendererAction {
+    run(action: IParallelAction, renderer: ListenerContext, event: RendererEvent<any>): Promise<void>;
+}

package/dist/src/actions/SwitchAction.d.ts

@@ -0,0 +1,11 @@
+import { RendererEvent } from '../utils/renderer-event';
+import { RendererAction, ListenerContext, ILogicAction } from './Action';
+export interface ISwitchAction extends ILogicAction {
+    actionType: 'switch';
+}
+/**
+ * 排他动作
+ */
+export declare class SwitchAction implements RendererAction {
+    run(action: ISwitchAction, renderer: ListenerContext, event: RendererEvent<any>, mergeData: any): Promise<void>;
+}

package/dist/src/actions/ToastAction.d.ts

@@ -0,0 +1,19 @@
+import { RendererEvent } from '../utils/renderer-event';
+import { RendererAction, ListenerContext, ListenerAction } from './Action';
+export interface IToastAction extends ListenerAction {
+    actionType: 'toast';
+    args: {
+        msg: string;
+        msgType?: string;
+        position?: 'top-right' | 'top-center' | 'top-left' | 'bottom-center' | 'bottom-left' | 'bottom-right' | 'center';
+        closeButton?: boolean;
+        showIcon?: boolean;
+        timeout?: number;
+    };
+}
+/**
+ * 全局toast
+ */
+export declare class ToastAction implements RendererAction {
+    run(action: IToastAction, renderer: ListenerContext, event: RendererEvent<any>): Promise<void>;
+}

package/dist/src/actions/index.d.ts

@@ -0,0 +1,21 @@
+/**
+ * @file 导入所有动作
+ */
+import './LoopAction';
+import './BreakAction';
+import './ContinueAction';
+import './SwitchAction';
+import './ParallelAction';
+import './CustomAction';
+import './BroadcastAction';
+import './CmptAction';
+import './AjaxAction';
+import './CopyAction';
+import './DialogAction';
+import './DrawerAction';
+import './EmailAction';
+import './LinkAction';
+import './ToastAction';
+import './PageAction';
+import './Decorators';
+export * from './Action';

package/dist/src/components/LazyComponent.d.ts

@@ -0,0 +1,32 @@
+/**
+ * @file LazyComponent
+ * @description
+ * @author fex
+ */
+import React from 'react';
+export interface LazyComponentProps {
+    component?: React.ReactType;
+    getComponent?: () => Promise<React.ReactType>;
+    placeholder?: React.ReactNode;
+    unMountOnHidden?: boolean;
+    childProps?: object;
+    visiblilityProps?: object;
+    [propName: string]: any;
+}
+export interface LazyComponentState {
+    visible: boolean;
+    component?: React.ReactType;
+}
+export default class LazyComponent extends React.Component<LazyComponentProps, LazyComponentState> {
+    static defaultProps: {
+        placeholder: JSX.Element;
+        unMountOnHidden: boolean;
+        partialVisibility: boolean;
+    };
+    mounted: boolean;
+    constructor(props: LazyComponentProps);
+    componentDidMount(): void;
+    componentWillUnmount(): void;
+    handleVisibleChange(visible: boolean): void;
+    render(): {};
+}