@tmagic/data-source/types/index.d.ts

import EventEmitter from 'events';
import TMagicApp, { HttpOptions, DataSourceSchema, RequestFunction, Method, DataSchema, CodeBlockContent, MNode, Id, NODE_CONDS_KEY, DisplayCond, NODE_CONDS_RESULT_KEY, NODE_DISABLE_DATA_SOURCE_KEY, DisplayCondItem, MApp, DepData } from '@tmagic/core';
import State from 'deep-state-observer';

/**
 * Http 数据源
 * @description 通过 http 请求获取数据
 */
declare class HttpDataSource extends DataSource<HttpDataSourceSchema> {
    #private;
    /** 是否正在发起请求 */
    isLoading: boolean;
    error?: {
        msg?: string;
        code?: string | number;
    };
    /** 请求配置 */
    httpOptions: HttpOptionsSchema;
    constructor(options: DataSourceOptions<HttpDataSourceSchema>);
    get type(): string;
    init(): Promise<void>;
    request(options?: Partial<HttpOptions>): Promise<void>;
    get(options: Partial<HttpOptions> & {
        url: string;
    }): Promise<void>;
    post(options: Partial<HttpOptions> & {
        url: string;
    }): Promise<void>;
}

declare abstract class ObservedData {
    abstract update(data: any, path?: string): void;
    abstract on(path: string, callback: (newVal: any) => void, options?: {
        immediate?: boolean;
    }): void;
    abstract off(path: string, callback: (newVal: any) => void): void;
    abstract getData(path: string): any;
    abstract destroy(): void;
}

type ObservedDataClass = new (...args: any[]) => ObservedData;
interface DataSourceOptions<T extends DataSourceSchema = DataSourceSchema> {
    schema: T;
    app: TMagicApp;
    initialData?: Record<string, any>;
    useMock?: boolean;
    request?: RequestFunction;
    ObservedDataClass?: ObservedDataClass;
    [key: string]: any;
}
interface HttpOptionsSchema {
    /** 请求链接 */
    url: string | ((data: {
        app: TMagicApp;
        dataSource: HttpDataSource;
    }) => string);
    /** query参数 */
    params?: Record<string, string> | ((data: {
        app: TMagicApp;
        dataSource: HttpDataSource;
    }) => Record<string, string>);
    /** body数据 */
    data?: Record<string, any> | ((data: {
        app: TMagicApp;
        dataSource: HttpDataSource;
    }) => Record<string, string>);
    /** 请求头 */
    headers?: Record<string, string> | ((data: {
        app: TMagicApp;
        dataSource: HttpDataSource;
    }) => Record<string, string>);
    /** 请求方法 GET/POST */
    method?: Method;
    [key: string]: any;
}
interface HttpDataSourceSchema extends DataSourceSchema {
    type: 'http';
    options: HttpOptionsSchema;
    responseOptions?: {
        dataPath?: string;
    };
    autoFetch?: boolean;
    beforeRequest: string | ((options: HttpOptions, content: {
        app: TMagicApp;
        dataSource: HttpDataSource;
    }) => HttpOptions);
    afterResponse: string | ((response: any, content: {
        app: TMagicApp;
        dataSource: HttpDataSource;
        options: Partial<HttpOptions>;
    }) => any);
}
interface DataSourceManagerOptions {
    app: TMagicApp;
    /** 初始化数据，ssr数据可以由此传入 */
    initialData?: DataSourceManagerData;
    /** 是否使用mock数据 */
    useMock?: boolean;
}
interface DataSourceManagerData {
    [key: string]: Record<string, any>;
}
interface ChangeEvent {
    path?: string;
    updateData: any;
}
type AsyncDataSourceResolveResult<T = typeof DataSource> = {
    default: T;
};
interface SchemaListMap {
    [key: string]: DataSourceSchema[];
}

/**
 * 静态数据源
 */
declare class DataSource<T extends DataSourceSchema = DataSourceSchema> extends EventEmitter {
    #private;
    isInit: boolean;
    /** @tmagic/core 实例 */
    app: TMagicApp;
    protected mockData?: Record<string | number, any>;
    constructor(options: DataSourceOptions<T>);
    get id(): string;
    get type(): string;
    get schema(): T;
    get fields(): DataSchema[];
    get methods(): CodeBlockContent[];
    setFields(fields: DataSchema[]): void;
    setMethods(methods: CodeBlockContent[]): void;
    get data(): any;
    setData(data: any, path?: string): void;
    setValue(path: string, data: any): void;
    onDataChange(path: string, callback: (newVal: any) => void): void;
    offDataChange(path: string, callback: (newVal: any) => void): void;
    getDefaultData(): Record<string, any>;
    init(): Promise<void>;
    destroy(): void;
}

declare class DataSourceManager extends EventEmitter {
    private static dataSourceClassMap;
    private static ObservedDataClass;
    private static waitInitSchemaList;
    static register<T extends typeof DataSource = typeof DataSource>(type: string, dataSource: T): void;
    static getDataSourceClass(type: string): any;
    static clearDataSourceClass(): void;
    static registerObservedData(ObservedDataClass: ObservedDataClass): void;
    app: TMagicApp;
    dataSourceMap: Map<string, DataSource<DataSourceSchema> & Record<string, any>>;
    data: DataSourceManagerData;
    initialData: DataSourceManagerData;
    useMock?: boolean;
    constructor({ app, useMock, initialData }: DataSourceManagerOptions);
    init(ds: DataSource): Promise<void>;
    get(id: string): (DataSource<DataSourceSchema> & Record<string, any>) | undefined;
    addDataSource(config?: DataSourceSchema): any;
    setData(ds: DataSource, changeEvent: ChangeEvent): void;
    removeDataSource(id: string): void;
    /**
     * 更新数据源dsl，在编辑器中修改配置后需要更新，一般在其他环境下不需要更新dsl
     * @param {DataSourceSchema[]} schemas 所有数据源配置
     */
    updateSchema(schemas: DataSourceSchema[]): void;
    /**
     * 将组件dsl中所有key中数据源相关的配置编译成对应的值
     * @param {MNode} node 组件dsl
     * @param {string | number} sourceId 数据源ID
     * @param {boolean} deep 是否编译子项（items)，默认为false
     * @returns {MNode} 编译后的组件dsl
     */
    compiledNode(n: MNode, sourceId?: Id, deep?: boolean): MNode;
    /**
     * 编译组件条件组配置（用于配置组件显示时机）
     * @param {{ [NODE_CONDS_KEY]?: DisplayCond[] }} node 显示条件组配置
     * @returns {boolean} 是否显示
     */
    compliedConds(node: {
        [NODE_CONDS_KEY]?: DisplayCond[];
        [NODE_CONDS_RESULT_KEY]?: boolean;
        [NODE_DISABLE_DATA_SOURCE_KEY]?: boolean;
    }, data?: DataSourceManagerData): boolean;
    /**
     * 编译迭代器容器的迭代项的显示条件
     * @param {any[]} itemData 迭代数据
     * @param {{ [NODE_CONDS_KEY]?: DisplayCond[] }} node 显示条件组配置
     * @param {string[]} dataSourceField 迭代数据在数据源中的字段，格式如['dsId', 'key1', 'key2']
     * @returns {boolean}是否显示
     */
    compliedIteratorItemConds(itemData: any, node: {
        [NODE_CONDS_KEY]?: DisplayCond[];
        [NODE_CONDS_RESULT_KEY]?: boolean;
        [NODE_DISABLE_DATA_SOURCE_KEY]?: boolean;
    }, dataSourceField?: string[]): boolean;
    compliedIteratorItems(itemData: any, nodes: MNode[], dataSourceField?: string[]): MNode[];
    isAllDataSourceRegistered(): boolean;
    destroy(): void;
    onDataChange(id: string, path: string, callback: (newVal: any) => void): void | undefined;
    offDataChange(id: string, path: string, callback: (newVal: any) => void): void | undefined;
    private callDsInit;
}

/**
 * 创建数据源管理器
 * @param {TMagicApp} app
 * @param {boolean} useMock 是否使用mock数据
 * @param {DataSourceManagerData} initialData 初始化数据，ssr数据可以由此传入
 * @returns {DataSourceManager | undefined}
 */
declare const createDataSourceManager: (app: TMagicApp, useMock?: boolean, initialData?: DataSourceManagerData) => DataSourceManager | undefined;

declare class DeepObservedData extends ObservedData {
    state?: State;
    subscribers: Map<string, Map<Function, () => void>>;
    constructor(initialData: Record<string, any>);
    update: (data: any, path?: string) => void;
    on: (path: string, callback: (newVal: any) => void, options?: {
        immediate?: boolean;
    }) => void;
    off: (path: string, callback: (newVal: any) => void) => void;
    getData: (path: string) => any;
    destroy: () => void;
}

declare class SimpleObservedData extends ObservedData {
    data: Record<string, any>;
    private event;
    constructor(initialData: Record<string, any>);
    update(data: any, path?: string): void;
    on(path: string, callback: (newVal: any) => void, options?: {
        immediate?: boolean;
    }): void;
    off(path: string, callback: (newVal: any) => void): void;
    getData(path: string): any;
    destroy(): void;
}

/**
 * 编译显示条件
 * @param cond 条件配置
 * @param data 上下文数据（数据源数据）
 * @returns boolean
 */
declare const compiledCondition: (cond: DisplayCondItem[], data: DataSourceManagerData) => boolean;
/**
 * 编译数据源条件组
 * @param node dsl节点
 * @param data 数据源数据
 * @returns boolean
 */
declare const compliedConditions: (node: {
    [NODE_CONDS_KEY]?: DisplayCond[];
}, data: DataSourceManagerData) => boolean;
declare const updateNode: (node: MNode, dsl: MApp) => void;
/**
 * 创建迭代器容器编译的数据上下文
 * @param itemData 迭代数据
 * @param dsId 数据源id
 * @param fields dsl节点字段，如a.b.c
 * @returns 数据上下文
 */
declare const createIteratorContentData: (itemData: any, dsId: string, fields?: string[], dsData?: DataSourceManagerData) => DataSourceManagerData;
/**
 * 编译通过tmagic-editor的数据源源选择器配(data-source-field-select)
 * 格式为 [`${DATA_SOURCE_FIELDS_SELECT_VALUE_PREFIX}${id}`, 'field']
 * DATA_SOURCE_FIELDS_SELECT_VALUE_PREFIX常量可通过@tmagic/utils获取
 *
 * @param value dsl节点中的数据源配置
 * @param data 数据源数据
 * @returns 编译好的配置
 */
declare const compliedDataSourceField: (value: any, data: DataSourceManagerData) => any;
declare const template: (value: string, data?: DataSourceManagerData) => string;
/**
 * 编译通过tmagic-editor的数据源源选择器（data-source-input，data-source-select，data-source-field-select）配置出来的数据，或者其他符合规范的配置
 * @param value dsl节点中的数据源配置
 * @param data 数据源数据
 * @returns 编译好的配置
 */
declare const compiledNodeField: (value: any, data: DataSourceManagerData) => any;
declare const compliedIteratorItem: ({ compile, dsId, item, deps, condDeps, inEditor, ctxData, }: {
    compile: (value: any) => any;
    dsId: string;
    item: MNode;
    deps: DepData;
    condDeps: DepData;
    inEditor: boolean;
    ctxData: DataSourceManagerData;
}) => MNode;
/**
 * 按需加载数据源
 */
declare const registerDataSourceOnDemand: (dsl: MApp, dataSourceModules: Record<string, () => Promise<AsyncDataSourceResolveResult>>) => Promise<Record<string, any>>;

export { DataSource, DataSourceManager, DeepObservedData, HttpDataSource, ObservedData, SimpleObservedData, compiledCondition, compiledNodeField, compliedConditions, compliedDataSourceField, compliedIteratorItem, createDataSourceManager, createIteratorContentData, registerDataSourceOnDemand, template, updateNode };
export type { AsyncDataSourceResolveResult, ChangeEvent, DataSourceManagerData, DataSourceManagerOptions, DataSourceOptions, HttpDataSourceSchema, HttpOptionsSchema, ObservedDataClass, SchemaListMap };