amis-core 1.0.0-beta.0

package/dist/src/env.d.ts

@@ -0,0 +1,172 @@
+/**
+ * @file 组件 Env，包括如何发送 ajax，如何通知，如何跳转等等。。
+ */
+import React from 'react';
+import { RendererConfig } from './factory';
+import { ThemeInstance } from './theme';
+import { Action, Api, EventTrack, Payload, PlainObject, Schema, ToastConf, ToastLevel } from './types';
+import hoistNonReactStatic from 'hoist-non-react-statics';
+import { IScopedContext } from './Scoped';
+import { RendererEvent } from './utils/renderer-event';
+export interface wsObject {
+    url: string;
+    responseKey?: string;
+    body?: any;
+}
+export interface RendererEnv {
+    fetcher: (api: Api, data?: any, options?: object) => Promise<Payload>;
+    isCancel: (val: any) => boolean;
+    wsFetcher: (ws: wsObject, onMessage: (data: any) => void, onError: (error: any) => void) => void;
+    notify: (type: ToastLevel, msg: any, conf?: ToastConf) => void;
+    jumpTo: (to: string, action?: Action, ctx?: object) => void;
+    alert: (msg: string) => void;
+    confirm: (msg: string, title?: string) => Promise<boolean>;
+    updateLocation: (location: any, replace?: boolean) => void;
+    /**
+     * 阻止路由跳转，有时候 form 没有保存，但是路由跳转了，导致页面没有更新，
+     * 所以先让用户确认一下。
+     *
+     * 单页模式需要这个，如果非单页模式，不需要处理这个。
+     */
+    blockRouting?: (fn: (targetLocation: any) => void | string) => () => void;
+    isCurrentUrl: (link: string, ctx?: any) => boolean | {
+        params?: object;
+    };
+    /**
+     * 监控路由变化，如果 jssdk 需要做单页跳转需要实现这个。
+     */
+    watchRouteChange?: (fn: () => void) => () => void;
+    tracker: (eventTrack: EventTrack, props?: PlainObject) => void;
+    rendererResolver?: (path: string, schema: Schema, props: any) => null | RendererConfig;
+    copy?: (contents: string, format?: any) => void;
+    getModalContainer?: () => HTMLElement;
+    theme: ThemeInstance;
+    affixOffsetTop: number;
+    affixOffsetBottom: number;
+    richTextToken: string;
+    loadRenderer: (schema: Schema, path: string, reRender: Function) => Promise<React.ReactType> | React.ReactType | JSX.Element | void;
+    loadChartExtends?: () => void | Promise<void>;
+    useMobileUI?: boolean;
+    /**
+     * 过滤 html 标签，可用来添加 xss 保护逻辑
+     */
+    filterHtml: (input: string) => string;
+    beforeDispatchEvent: (e: string | React.ClipboardEvent<any> | React.DragEvent<any> | React.ChangeEvent<any> | React.KeyboardEvent<any> | React.TouchEvent<any> | React.WheelEvent<any> | React.AnimationEvent<any> | React.TransitionEvent<any> | React.MouseEvent<any>, context: any, scoped: IScopedContext, data: any, broadcast?: RendererEvent<any>) => void;
+    /**
+     * 是否开启 amis 调试
+     */
+    enableAMISDebug?: boolean;
+    /**
+     * 替换文本，用于实现 URL 替换、语言替换等
+     */
+    replaceText?: {
+        [propName: string]: any;
+    };
+    /**
+     * 文本替换的黑名单，因为属性太多了所以改成黑名单的 fangs
+     */
+    replaceTextIgnoreKeys?: String[];
+}
+export declare const EnvContext: React.Context<void | RendererEnv>;
+export interface EnvProps {
+    env: RendererEnv;
+}
+export declare function withRendererEnv<T extends React.ComponentType<React.ComponentProps<T> & EnvProps>>(ComposedComponent: T): {
+    new (props: (JSX.LibraryManagedAttributes<T, Omit<React.ComponentProps<T>, "env">> & {
+        env?: RendererEnv | undefined;
+    }) | Readonly<JSX.LibraryManagedAttributes<T, Omit<React.ComponentProps<T>, "env">> & {
+        env?: RendererEnv | undefined;
+    }>): {
+        render(): JSX.Element;
+        context: any;
+        setState<K extends never>(state: {} | ((prevState: Readonly<{}>, props: Readonly<JSX.LibraryManagedAttributes<T, Omit<React.ComponentProps<T>, "env">> & {
+            env?: RendererEnv | undefined;
+        }>) => {} | Pick<{}, K> | null) | Pick<{}, K> | null, callback?: (() => void) | undefined): void;
+        forceUpdate(callback?: (() => void) | undefined): void;
+        readonly props: Readonly<JSX.LibraryManagedAttributes<T, Omit<React.ComponentProps<T>, "env">> & {
+            env?: RendererEnv | undefined;
+        }> & Readonly<{
+            children?: React.ReactNode;
+        }>;
+        state: Readonly<{}>;
+        refs: {
+            [key: string]: React.ReactInstance;
+        };
+        componentDidMount?(): void;
+        shouldComponentUpdate?(nextProps: Readonly<JSX.LibraryManagedAttributes<T, Omit<React.ComponentProps<T>, "env">> & {
+            env?: RendererEnv | undefined;
+        }>, nextState: Readonly<{}>, nextContext: any): boolean;
+        componentWillUnmount?(): void;
+        componentDidCatch?(error: Error, errorInfo: React.ErrorInfo): void;
+        getSnapshotBeforeUpdate?(prevProps: Readonly<JSX.LibraryManagedAttributes<T, Omit<React.ComponentProps<T>, "env">> & {
+            env?: RendererEnv | undefined;
+        }>, prevState: Readonly<{}>): any;
+        componentDidUpdate?(prevProps: Readonly<JSX.LibraryManagedAttributes<T, Omit<React.ComponentProps<T>, "env">> & {
+            env?: RendererEnv | undefined;
+        }>, prevState: Readonly<{}>, snapshot?: any): void;
+        componentWillMount?(): void;
+        UNSAFE_componentWillMount?(): void;
+        componentWillReceiveProps?(nextProps: Readonly<JSX.LibraryManagedAttributes<T, Omit<React.ComponentProps<T>, "env">> & {
+            env?: RendererEnv | undefined;
+        }>, nextContext: any): void;
+        UNSAFE_componentWillReceiveProps?(nextProps: Readonly<JSX.LibraryManagedAttributes<T, Omit<React.ComponentProps<T>, "env">> & {
+            env?: RendererEnv | undefined;
+        }>, nextContext: any): void;
+        componentWillUpdate?(nextProps: Readonly<JSX.LibraryManagedAttributes<T, Omit<React.ComponentProps<T>, "env">> & {
+            env?: RendererEnv | undefined;
+        }>, nextState: Readonly<{}>, nextContext: any): void;
+        UNSAFE_componentWillUpdate?(nextProps: Readonly<JSX.LibraryManagedAttributes<T, Omit<React.ComponentProps<T>, "env">> & {
+            env?: RendererEnv | undefined;
+        }>, nextState: Readonly<{}>, nextContext: any): void;
+    };
+    new (props: JSX.LibraryManagedAttributes<T, Omit<React.ComponentProps<T>, "env">> & {
+        env?: RendererEnv | undefined;
+    }, context: any): {
+        render(): JSX.Element;
+        context: any;
+        setState<K extends never>(state: {} | ((prevState: Readonly<{}>, props: Readonly<JSX.LibraryManagedAttributes<T, Omit<React.ComponentProps<T>, "env">> & {
+            env?: RendererEnv | undefined;
+        }>) => {} | Pick<{}, K> | null) | Pick<{}, K> | null, callback?: (() => void) | undefined): void;
+        forceUpdate(callback?: (() => void) | undefined): void;
+        readonly props: Readonly<JSX.LibraryManagedAttributes<T, Omit<React.ComponentProps<T>, "env">> & {
+            env?: RendererEnv | undefined;
+        }> & Readonly<{
+            children?: React.ReactNode;
+        }>;
+        state: Readonly<{}>;
+        refs: {
+            [key: string]: React.ReactInstance;
+        };
+        componentDidMount?(): void;
+        shouldComponentUpdate?(nextProps: Readonly<JSX.LibraryManagedAttributes<T, Omit<React.ComponentProps<T>, "env">> & {
+            env?: RendererEnv | undefined;
+        }>, nextState: Readonly<{}>, nextContext: any): boolean;
+        componentWillUnmount?(): void;
+        componentDidCatch?(error: Error, errorInfo: React.ErrorInfo): void;
+        getSnapshotBeforeUpdate?(prevProps: Readonly<JSX.LibraryManagedAttributes<T, Omit<React.ComponentProps<T>, "env">> & {
+            env?: RendererEnv | undefined;
+        }>, prevState: Readonly<{}>): any;
+        componentDidUpdate?(prevProps: Readonly<JSX.LibraryManagedAttributes<T, Omit<React.ComponentProps<T>, "env">> & {
+            env?: RendererEnv | undefined;
+        }>, prevState: Readonly<{}>, snapshot?: any): void;
+        componentWillMount?(): void;
+        UNSAFE_componentWillMount?(): void;
+        componentWillReceiveProps?(nextProps: Readonly<JSX.LibraryManagedAttributes<T, Omit<React.ComponentProps<T>, "env">> & {
+            env?: RendererEnv | undefined;
+        }>, nextContext: any): void;
+        UNSAFE_componentWillReceiveProps?(nextProps: Readonly<JSX.LibraryManagedAttributes<T, Omit<React.ComponentProps<T>, "env">> & {
+            env?: RendererEnv | undefined;
+        }>, nextContext: any): void;
+        componentWillUpdate?(nextProps: Readonly<JSX.LibraryManagedAttributes<T, Omit<React.ComponentProps<T>, "env">> & {
+            env?: RendererEnv | undefined;
+        }>, nextState: Readonly<{}>, nextContext: any): void;
+        UNSAFE_componentWillUpdate?(nextProps: Readonly<JSX.LibraryManagedAttributes<T, Omit<React.ComponentProps<T>, "env">> & {
+            env?: RendererEnv | undefined;
+        }>, nextState: Readonly<{}>, nextContext: any): void;
+    };
+    displayName: string;
+    contextType: React.Context<void | RendererEnv>;
+    ComposedComponent: React.ComponentType<T>;
+} & hoistNonReactStatic.NonReactStatics<T, {}> & {
+    ComposedComponent: T;
+};

package/dist/src/envOverwrite.d.ts

@@ -0,0 +1,4 @@
+/**
+ * @file 用于在移动端或不同语言环境下使用不同配置
+ */
+export declare const envOverwrite: (schema: any, locale?: string | undefined) => void;

package/dist/src/factory.d.ts

@@ -0,0 +1,78 @@
+import React from 'react';
+import { IRendererStore, IIRendererStore } from './store/index';
+import { fetcherResult, SchemaNode, Schema, PlainObject } from './types';
+import { ThemeProps } from './theme';
+import { LocaleProps } from './locale';
+import { RendererEnv } from './env';
+import { OnEventProps } from './utils/renderer-event';
+export interface TestFunc {
+    (path: string, schema?: Schema, resolveRenderer?: (path: string, schema?: Schema, props?: any) => null | RendererConfig): boolean;
+}
+export interface RendererBasicConfig {
+    test?: RegExp | TestFunc;
+    type?: string;
+    name?: string;
+    storeType?: string;
+    shouldSyncSuperStore?: (store: any, props: any, prevProps: any) => boolean | undefined;
+    storeExtendsData?: boolean | ((props: any) => boolean);
+    weight?: number;
+    isolateScope?: boolean;
+    isFormItem?: boolean;
+    autoVar?: boolean;
+}
+export interface RendererProps extends ThemeProps, LocaleProps, OnEventProps {
+    render: (region: string, node: SchemaNode, props?: PlainObject) => JSX.Element;
+    env: RendererEnv;
+    $path: string;
+    $schema: any;
+    store?: IIRendererStore;
+    syncSuperStore?: boolean;
+    data: {
+        [propName: string]: any;
+    };
+    defaultData?: object;
+    className?: any;
+    [propName: string]: any;
+}
+export declare type RendererComponent = React.ComponentType<RendererProps> & {
+    propsList?: Array<any>;
+};
+export interface RendererConfig extends RendererBasicConfig {
+    component: RendererComponent;
+    Renderer?: RendererComponent;
+}
+export interface RenderSchemaFilter {
+    (schema: Schema, renderer: RendererConfig, props?: any): Schema;
+}
+export interface wsObject {
+    url: string;
+    responseKey?: string;
+    body?: any;
+}
+export interface RenderOptions extends Partial<Omit<RendererEnv, 'fetcher' | 'theme'>> {
+    session?: string;
+    theme?: string;
+    fetcher?: (config: fetcherConfig) => Promise<fetcherResult>;
+}
+export interface fetcherConfig {
+    url: string;
+    method?: 'get' | 'post' | 'put' | 'patch' | 'delete' | 'jsonp';
+    data?: any;
+    config?: any;
+}
+export declare function addSchemaFilter(fn: RenderSchemaFilter): void;
+export declare function filterSchema(schema: Schema, render: RendererConfig, props?: any): Schema;
+export declare function Renderer(config: RendererBasicConfig): <T extends RendererComponent>(component: T) => T;
+export declare function registerRenderer(config: RendererConfig): RendererConfig;
+export declare function unRegisterRenderer(config: RendererConfig | string): void;
+export declare function loadRenderer(schema: Schema, path: string): JSX.Element;
+export declare const defaultOptions: RenderOptions;
+export declare const stores: {
+    [propName: string]: IRendererStore;
+};
+export declare function clearStoresCache(sessions?: Array<string> | string): void;
+export declare function updateEnv(options: Partial<RenderOptions>, session?: string): void;
+export declare function resolveRenderer(path: string, schema?: Schema): null | RendererConfig;
+export declare function getRenderers(): RendererConfig[];
+export declare function getRendererByName(name: string): RendererConfig | undefined;
+export { RendererEnv };

package/dist/src/index.d.ts

@@ -0,0 +1,25 @@
+/// <reference types="react" />
+/** @license amis v@version
+ *
+ * Copyright Baidu
+ *
+ * This source code is licensed under the Apache license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+import { Renderer, getRendererByName, getRenderers, registerRenderer, unRegisterRenderer, resolveRenderer, filterSchema, clearStoresCache, updateEnv, RenderOptions } from './factory';
+import './renderers/builtin';
+export * from './utils/index';
+import * as utils from './utils/helper';
+import { RegisterStore } from './store';
+import { setDefaultLocale, getDefaultLocale, makeTranslator, register as registerLocale, extendLocale, localeable, LocaleProps, TranslateFn } from './locale';
+import Scoped, { ScopedContext } from './Scoped';
+import { classnames, getClassPrefix, setDefaultTheme, theme, getTheme, ThemeProps } from './theme';
+declare const classPrefix: string | undefined;
+import './actions';
+import FormItem, { FormItemWrap, registerFormItem } from './renderers/Item';
+import { OptionsControl, registerOptionsControl } from './renderers/Options';
+import { Schema } from './types';
+import { RootRenderProps } from './Root';
+import { autobind } from './utils/helper';
+export { clearStoresCache, updateEnv, Renderer, RegisterStore, FormItem, FormItemWrap, OptionsControl, utils, getRendererByName, registerRenderer, unRegisterRenderer, getRenderers, registerFormItem, registerOptionsControl, resolveRenderer, filterSchema, Scoped, ScopedContext, setDefaultTheme, theme, ThemeProps, getTheme, classPrefix, getClassPrefix, classnames, getDefaultLocale, setDefaultLocale, registerLocale, makeTranslator, extendLocale, localeable, LocaleProps, TranslateFn, autobind };
+export declare function render(schema: Schema, props?: RootRenderProps, options?: RenderOptions, pathPrefix?: string): JSX.Element;

package/dist/src/locale.d.ts

@@ -0,0 +1,82 @@
+import React from 'react';
+import hoistNonReactStatic from 'hoist-non-react-statics';
+export declare type TranslateFn<T = any> = (str: T, data?: object) => T;
+interface LocaleConfig {
+    [propsName: string]: string;
+}
+export declare function register(name: string, config: LocaleConfig): void;
+export declare function extendLocale(name: string, config: LocaleConfig): void;
+export declare function makeTranslator(locale?: string): TranslateFn;
+export declare function getDefaultLocale(): string;
+export declare function setDefaultLocale(loacle: string): void;
+export interface LocaleProps {
+    locale: string;
+    translate: TranslateFn;
+}
+export declare const LocaleContext: React.Context<string>;
+export declare function localeable<T extends React.ComponentType<React.ComponentProps<T> & LocaleProps>>(ComposedComponent: T): {
+    new (props: JSX.LibraryManagedAttributes<T, Omit<React.ComponentProps<T>, keyof LocaleProps>> & {
+        locale?: string | undefined;
+        translate?: ((str: string, ...args: any[]) => string) | undefined;
+    }): {
+        ref: any;
+        childRef(ref: any): void;
+        getWrappedInstance(): any;
+        render(): JSX.Element;
+        context: any;
+        setState<K extends never>(state: {} | ((prevState: Readonly<{}>, props: Readonly<JSX.LibraryManagedAttributes<T, Omit<React.ComponentProps<T>, keyof LocaleProps>> & {
+            locale?: string | undefined;
+            translate?: ((str: string, ...args: any[]) => string) | undefined;
+        }>) => {} | Pick<{}, K> | null) | Pick<{}, K> | null, callback?: (() => void) | undefined): void;
+        forceUpdate(callback?: (() => void) | undefined): void;
+        readonly props: Readonly<JSX.LibraryManagedAttributes<T, Omit<React.ComponentProps<T>, keyof LocaleProps>> & {
+            locale?: string | undefined;
+            translate?: ((str: string, ...args: any[]) => string) | undefined;
+        }> & Readonly<{
+            children?: React.ReactNode;
+        }>;
+        state: Readonly<{}>;
+        refs: {
+            [key: string]: React.ReactInstance;
+        };
+        componentDidMount?(): void;
+        shouldComponentUpdate?(nextProps: Readonly<JSX.LibraryManagedAttributes<T, Omit<React.ComponentProps<T>, keyof LocaleProps>> & {
+            locale?: string | undefined;
+            translate?: ((str: string, ...args: any[]) => string) | undefined;
+        }>, nextState: Readonly<{}>, nextContext: any): boolean;
+        componentWillUnmount?(): void;
+        componentDidCatch?(error: Error, errorInfo: React.ErrorInfo): void;
+        getSnapshotBeforeUpdate?(prevProps: Readonly<JSX.LibraryManagedAttributes<T, Omit<React.ComponentProps<T>, keyof LocaleProps>> & {
+            locale?: string | undefined;
+            translate?: ((str: string, ...args: any[]) => string) | undefined;
+        }>, prevState: Readonly<{}>): any;
+        componentDidUpdate?(prevProps: Readonly<JSX.LibraryManagedAttributes<T, Omit<React.ComponentProps<T>, keyof LocaleProps>> & {
+            locale?: string | undefined;
+            translate?: ((str: string, ...args: any[]) => string) | undefined;
+        }>, prevState: Readonly<{}>, snapshot?: any): void;
+        componentWillMount?(): void;
+        UNSAFE_componentWillMount?(): void;
+        componentWillReceiveProps?(nextProps: Readonly<JSX.LibraryManagedAttributes<T, Omit<React.ComponentProps<T>, keyof LocaleProps>> & {
+            locale?: string | undefined;
+            translate?: ((str: string, ...args: any[]) => string) | undefined;
+        }>, nextContext: any): void;
+        UNSAFE_componentWillReceiveProps?(nextProps: Readonly<JSX.LibraryManagedAttributes<T, Omit<React.ComponentProps<T>, keyof LocaleProps>> & {
+            locale?: string | undefined;
+            translate?: ((str: string, ...args: any[]) => string) | undefined;
+        }>, nextContext: any): void;
+        componentWillUpdate?(nextProps: Readonly<JSX.LibraryManagedAttributes<T, Omit<React.ComponentProps<T>, keyof LocaleProps>> & {
+            locale?: string | undefined;
+            translate?: ((str: string, ...args: any[]) => string) | undefined;
+        }>, nextState: Readonly<{}>, nextContext: any): void;
+        UNSAFE_componentWillUpdate?(nextProps: Readonly<JSX.LibraryManagedAttributes<T, Omit<React.ComponentProps<T>, keyof LocaleProps>> & {
+            locale?: string | undefined;
+            translate?: ((str: string, ...args: any[]) => string) | undefined;
+        }>, nextState: Readonly<{}>, nextContext: any): void;
+    };
+    displayName: string;
+    contextType: React.Context<string>;
+    ComposedComponent: React.ComponentType<T>;
+} & hoistNonReactStatic.NonReactStatics<T, {}> & {
+    ComposedComponent: T;
+};
+export {};