@_tc/template-core 0.0.1 → 0.0.2

package/fe/frontend/apps/testPage/testPage.entry.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=testPage.entry.d.ts.map

package/fe/frontend/apps/testPage/testPage.entry.js

@@ -0,0 +1,6 @@
+import { initApp } from '../../src/main';
+import App from './index';
+initApp(App, {
+    initModeData: false,
+    modelType: 'preview-ui',
+});

package/fe/frontend/extended/SchemaForm/data.d.ts

@@ -0,0 +1,13 @@
+/**
+ * @type {SchemaFormComponentsMap}
+ */
+declare const frameComponentsMap: {
+    asyncSelect: import("react").LazyExoticComponent<(props: import("../../src/components/AsyncSelect").AsyncSelectProps) => import("react/jsx-runtime").JSX.Element>;
+};
+export type FrameComponentsMap = typeof frameComponentsMap;
+export type FrameComponentsMapKey = keyof FrameComponentsMap;
+export type FrameComponentPropsMap = {
+    [K in FrameComponentsMapKey]: FrameComponentsMap[K] extends React.ComponentType<infer P> ? P : never;
+};
+export default frameComponentsMap;
+//# sourceMappingURL=data.d.ts.map

package/fe/frontend/extended/SchemaForm/data.js

@@ -0,0 +1,8 @@
+import { lazy } from 'react';
+/**
+ * @type {SchemaFormComponentsMap}
+ */
+const frameComponentsMap = {
+    asyncSelect: lazy(async () => await import('../../src/components/AsyncSelect')),
+};
+export default frameComponentsMap;

package/fe/frontend/src/api/baseInfo.d.ts

@@ -0,0 +1,31 @@
+import type { ModeMenuType } from '../../../model/types/model';
+type ProjectMenuType = ModeMenuType;
+export type ModelInfo = {
+    model: {
+        key: string;
+        name: string;
+        desc: string;
+    };
+    project: {
+        [k: string]: {
+            key: string;
+            name: string;
+            desc: string;
+            homePage: string;
+        };
+    };
+};
+export declare const getModelList: () => Promise<ModelInfo[]>;
+export type ProjectInfo = {
+    mode: string;
+    homePage: string;
+    icon: string;
+    name: string;
+    desc: string;
+} & ProjectMenuType & {
+    key: string;
+    modelKey: string;
+};
+export declare const getProjectData: (key: string) => Promise<ProjectInfo | null>;
+export {};
+//# sourceMappingURL=baseInfo.d.ts.map

package/fe/frontend/src/api/baseInfo.js

@@ -0,0 +1,15 @@
+import { get } from '../common/request';
+export const getModelList = async () => {
+    const res = await get('/project/model_list');
+    if (res.data.code === 0) {
+        return res.data.data;
+    }
+    return [];
+};
+export const getProjectData = async (key) => {
+    const res = await get(`/project/${key}`);
+    if (res.data.code === 0) {
+        return res.data.data;
+    }
+    return null;
+};

package/fe/frontend/src/common/CRUD/CRUD.d.ts

@@ -0,0 +1,3 @@
+export { default } from '../../../../packages/common/http';
+export * from '../../../../packages/common/http';
+//# sourceMappingURL=CRUD.d.ts.map

package/fe/frontend/src/common/CRUD/CRUD.js

@@ -0,0 +1,2 @@
+export { default } from '../../../../packages/common/http';
+export * from '../../../../packages/common/http';

package/fe/frontend/src/common/CRUD/index.d.ts

@@ -0,0 +1,2 @@
+export * from './CRUD';
+//# sourceMappingURL=index.d.ts.map

package/fe/frontend/src/common/CRUD/index.js

@@ -0,0 +1 @@
+export * from './CRUD';

package/fe/frontend/src/common/auth/index.d.ts

@@ -0,0 +1,7 @@
+export declare const AUTH_HEADER_KEY = "Authorization";
+export declare function getAuthToken(): Promise<string | null>;
+export declare function clearAuthToken(): Promise<void>;
+export declare const API_AUTH_HEADER_KEY = "projk";
+export declare const getApiAuth: () => string;
+export declare const setApiAuth: (v: string) => void;
+//# sourceMappingURL=index.d.ts.map

package/fe/frontend/src/common/auth/index.js

@@ -0,0 +1,20 @@
+const AUTH_LOCAL_KEY = 'auth_token';
+const API_AUTH_LOCAL_KEY = 'p_J_k';
+export const AUTH_HEADER_KEY = 'Authorization';
+export async function getAuthToken() {
+    if (typeof localStorage === 'undefined')
+        return null;
+    return localStorage.getItem(AUTH_LOCAL_KEY);
+}
+export async function clearAuthToken() {
+    if (typeof localStorage === 'undefined')
+        return;
+    localStorage.removeItem(AUTH_LOCAL_KEY);
+}
+export const API_AUTH_HEADER_KEY = 'projk';
+export const getApiAuth = () => {
+    return localStorage.getItem(API_AUTH_LOCAL_KEY) ?? '';
+};
+export const setApiAuth = (v) => {
+    return localStorage.setItem(API_AUTH_LOCAL_KEY, v);
+};

package/fe/frontend/src/common/fetchErrorShow.d.ts

@@ -0,0 +1,3 @@
+import type { BaseResponse, ResponseConfig } from '../common/request';
+export declare const handlingRequestErrors: <D>(data: Promise<ResponseConfig<BaseResponse<D>, any>>) => Promise<ResponseConfig<BaseResponse<D>, any>>;
+//# sourceMappingURL=fetchErrorShow.d.ts.map

package/fe/frontend/src/common/fetchErrorShow.js

@@ -0,0 +1,8 @@
+import { message } from '../../../packages/ui/react/components';
+export const handlingRequestErrors = async (data) => {
+    const res = await data;
+    if (res.data.code !== 0) {
+        message.error(res.data.message);
+    }
+    return res;
+};

package/fe/frontend/src/common/generateMenuData.d.ts

@@ -0,0 +1,4 @@
+import type { ProjectInfo } from '../api/baseInfo';
+import type { MenuItemData } from '../../../packages/ui/react/components';
+export declare const generateMenuItemData: (data: ProjectInfo["menu"]) => MenuItemData[];
+//# sourceMappingURL=generateMenuData.d.ts.map

package/fe/frontend/src/common/generateMenuData.js

@@ -0,0 +1,12 @@
+export const generateMenuItemData = (data) => {
+    return data.map((m) => {
+        const children = (m.menuType === 'group' && m.subMenu.length ? generateMenuItemData(m.subMenu) : undefined);
+        return {
+            key: m.key,
+            label: m.name,
+            icon: m.icon,
+            children: children,
+            minWidth: 100,
+        };
+    });
+};

package/fe/frontend/src/common/importComponent.d.ts

@@ -0,0 +1,5 @@
+import { ComponentType, ReactNode } from 'react';
+export declare const renderImportComponent: (c: Promise<{
+    default: ComponentType<any>;
+}>, fallback?: ReactNode) => import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=importComponent.d.ts.map

package/fe/frontend/src/common/importComponent.js

@@ -0,0 +1,8 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { lazy, Suspense } from 'react';
+export const renderImportComponent = (c, fallback) => {
+    const Component = lazy(() => c);
+    // TODO 加上页面级 loading
+    const showFallback = typeof fallback !== 'undefined' ? fallback : 'loading';
+    return (_jsx(Suspense, { fallback: showFallback, children: _jsx(Component, {}) }));
+};

package/fe/frontend/src/common/language.d.ts

@@ -0,0 +1,2 @@
+export declare const getText: (key: string) => string;
+//# sourceMappingURL=language.d.ts.map

package/fe/frontend/src/common/language.js

@@ -0,0 +1,9 @@
+import { i18n } from '../../../packages/ui/react/i18n';
+const useI18nKey = '$i18n_';
+export const getText = (key) => {
+    // 如果有占位符号
+    if (key.includes(useI18nKey)) {
+        return i18n(key);
+    }
+    return key;
+};

package/fe/frontend/src/common/logFn/index.d.ts

@@ -0,0 +1,5 @@
+export declare const logPageNotFound: () => void;
+export declare const logIllegalComponentCallback: (comName: string) => void;
+export declare const logSubscriptionError: () => void;
+export declare const logApiTamper: () => void;
+//# sourceMappingURL=index.d.ts.map

package/fe/frontend/src/common/logFn/index.js

@@ -0,0 +1,9 @@
+const logJoin = (...logs) => logs.join(`
+    ---------
+    `);
+export const logPageNotFound = () => {
+    console.error(logJoin('url有问题 或者 自定义页面未在路由器注册', 'The URL is incorrect, or the custom page is not registered with the router.'));
+};
+export const logIllegalComponentCallback = (comName) => console.error(logJoin(`非法的组件回调 - ${comName}`, `Illegal component callback - ${comName}`));
+export const logSubscriptionError = () => console.error(logJoin('不曾订阅过，请检查代码，关注函数与取消函数必须为同一个', "You haven't subscribed. Please check your code; the follow function and unsubscribe function must be the same."));
+export const logApiTamper = () => console.error(logJoin('api属性不允许篡改', 'API attributes cannot be tampered with'));

package/fe/frontend/src/common/menu.d.ts

@@ -0,0 +1,34 @@
+import type { ProjectInfo } from '../api/baseInfo';
+type MenuItem = {
+    key: string;
+    name: string;
+    path: Partial<{
+        pathname: string;
+        search: string;
+        hash: string;
+    }>;
+};
+export declare const enum QK {
+    /**
+     * project key
+     */
+    pk = "projk",
+    /**
+     * key topMenu key
+     */
+    k = "key",
+    /**
+     * sidebar key leftMenu key
+     */
+    sk = "sidek",
+    /**
+     * 自定义 页面的key
+     */
+    ck = "custk"
+}
+export declare const leftSidebarBasePath = "_sidebar_";
+export declare const deserializationUrlSearch: <T = Record<string, string>>(url?: string) => T;
+export declare const serializationUrl: (url: string, data: Record<string, string>) => string;
+export declare const findMenuItem: <T = Record<string, any>>(menuData: ProjectInfo["menu"], key?: string) => MenuItem & T;
+export {};
+//# sourceMappingURL=menu.d.ts.map

package/fe/frontend/src/common/menu.js

@@ -0,0 +1,101 @@
+import { modeStore } from '../stores/mode';
+export var QK;
+(function (QK) {
+    /**
+     * project key
+     */
+    QK["pk"] = "projk";
+    /**
+     * key topMenu key
+     */
+    QK["k"] = "key";
+    /**
+     * sidebar key leftMenu key
+     */
+    QK["sk"] = "sidek";
+    /**
+     * 自定义 页面的key
+     */
+    QK["ck"] = "custk";
+})(QK || (QK = {}));
+export const leftSidebarBasePath = '_sidebar_';
+export const deserializationUrlSearch = (url = window.location.search) => {
+    const urls = new URLSearchParams(url);
+    const data = {};
+    for (const [k, v] of urls.entries()) {
+        data[k] = v;
+    }
+    return data;
+};
+export const serializationUrl = (url, data) => `${url}?${new URLSearchParams(data).toString()}`;
+const generateMenuItem = (item) => {
+    let data = undefined;
+    if (item.menuType === 'module') {
+        const pk = modeStore.getState().projectInfo?.key;
+        const query = {
+            [QK.pk]: pk,
+        };
+        switch (item.moduleType) {
+            case 'custom':
+                query[QK.ck] = item.key;
+                data = {
+                    ...item,
+                    path: {
+                        pathname: item.customConfig.path,
+                        search: new URLSearchParams(query).toString(),
+                    },
+                };
+                break;
+            case 'iframe':
+            case 'schema':
+            case 'sidebar':
+                let path = `/${item.key}`;
+                let search = new URLSearchParams(query).toString();
+                if (item.moduleType === 'sidebar') {
+                    // query[QK.sk] = item.sidebarConfig.menu[0].key;
+                    const sfMenu = findMenuItem(item.sidebarConfig.menu, item.sidebarConfig.menu[0]?.key);
+                    path += `${sfMenu.path.pathname}`;
+                    search = sfMenu.path.search ?? '';
+                    // path += `/pending`;
+                }
+                data = {
+                    ...item,
+                    path: {
+                        pathname: path,
+                        search,
+                    },
+                };
+                break;
+            default:
+                break;
+        }
+    }
+    return data;
+};
+export const findMenuItem = (menuData, key) => {
+    let data = undefined;
+    const useFirstAvailableMenu = typeof key === 'undefined';
+    /**
+     *  url query 分为
+     *
+     *  projk 为项目key
+     *  key  当前选择的top菜单key
+     *  sidek 为侧边栏选中的key
+     */
+    for (const item of menuData) {
+        if (item.menuType === 'module') {
+            if (useFirstAvailableMenu || item.key === key) {
+                data = generateMenuItem(item);
+                break;
+            }
+        }
+        if (item.menuType === 'group') {
+            const result = findMenuItem(item.subMenu, key);
+            if (result) {
+                data = { ...result };
+                break;
+            }
+        }
+    }
+    return data;
+};

package/fe/frontend/src/common/request.d.ts

@@ -0,0 +1,37 @@
+import type { AxiosError, RequestConfig, ResponseConfig } from '../../../packages/common/http';
+import { FetchAxios } from '../../../packages/common/http';
+declare const api: FetchAxios;
+export interface PageParams {
+    page?: number;
+    pageSize?: number;
+    [key: string]: string | number | boolean | undefined | null;
+}
+export type PageResponse<T> = {
+    data: T[];
+    total: number;
+    page: number;
+    pageSize: number;
+};
+export interface BaseResponse<T> {
+    data: T;
+    code: number;
+    message: string;
+}
+/**
+ * GET/DELETE 不发送 body；统一把 data 转到 params。
+ *  */
+export declare const get: <T = unknown, D = unknown>(url: string, data?: D, config?: RequestConfig<D>) => Promise<ResponseConfig<BaseResponse<T>, D>>;
+export declare const post: <T = unknown, D = unknown>(url: string, data?: D, config?: RequestConfig<D>) => Promise<ResponseConfig<BaseResponse<T>, D>>;
+export declare const put: <T = unknown, D = unknown>(url: string, data?: D, config?: RequestConfig<D>) => Promise<ResponseConfig<BaseResponse<T>, D>>;
+export declare const patch: <T = unknown, D = unknown>(url: string, data?: D, config?: RequestConfig<D>) => Promise<ResponseConfig<BaseResponse<T>, D>>;
+export declare const del: <T = unknown, D = unknown>(url: string, data?: D, config?: RequestConfig<D>) => Promise<ResponseConfig<BaseResponse<T>, D>>;
+export { api, FetchAxios };
+export type { AxiosError, RequestConfig, ResponseConfig };
+export declare const request: {
+    get: <T = unknown, D = unknown>(url: string, data?: D, config?: RequestConfig<D>) => Promise<ResponseConfig<BaseResponse<T>, D>>;
+    put: <T = unknown, D = unknown>(url: string, data?: D, config?: RequestConfig<D>) => Promise<ResponseConfig<BaseResponse<T>, D>>;
+    post: <T = unknown, D = unknown>(url: string, data?: D, config?: RequestConfig<D>) => Promise<ResponseConfig<BaseResponse<T>, D>>;
+    del: <T = unknown, D = unknown>(url: string, data?: D, config?: RequestConfig<D>) => Promise<ResponseConfig<BaseResponse<T>, D>>;
+    patch: <T = unknown, D = unknown>(url: string, data?: D, config?: RequestConfig<D>) => Promise<ResponseConfig<BaseResponse<T>, D>>;
+};
+//# sourceMappingURL=request.d.ts.map

package/fe/frontend/src/common/request.js

@@ -0,0 +1,217 @@
+import { apiFreezerStore, FreezeState } from '../stores/apiFreezer';
+import { FetchAxios } from '../../../packages/common/http';
+import md5 from 'md5';
+import { API_AUTH_HEADER_KEY, AUTH_HEADER_KEY, clearAuthToken, getApiAuth, getAuthToken } from './auth';
+const BASE_URL = '/api';
+const NumberConcurrentCalls = 4;
+const isRequestWhitelisted = (api, params) => {
+    const { requestWhitelist } = apiFreezerStore.getState();
+    return requestWhitelist.some((matcher) => {
+        if (typeof matcher === 'string')
+            return matcher === api;
+        if (matcher instanceof RegExp)
+            return matcher.test(api);
+        return matcher(api, params);
+    });
+};
+/**
+ * 处理解冻
+ * 冻结流程  4～9
+ */
+apiFreezerStore.subscribe((newState) => {
+    if (newState.state === FreezeState.Thawing) {
+        console.time('Thawing');
+        const { freezeQueue } = newState;
+        const queues = [...freezeQueue.values()];
+        // 清空冻结队列
+        freezeQueue.clear();
+        (async () => {
+            /**
+             *  生成 并发队列
+             *  每个队列从头取一个任务
+             *  当所有任务执行完后 这个 Promise.all 才会结束
+             */
+            await Promise.all(Array.from({ length: Math.min(NumberConcurrentCalls, queues.length) }, async () => {
+                while (queues.length) {
+                    const task = queues.shift();
+                    // 异常数据跳过
+                    if (!task)
+                        continue;
+                    const { originFn, callBackFns } = task;
+                    try {
+                        const res = await originFn();
+                        callBackFns.forEach(({ resolve }) => {
+                            resolve(res);
+                        });
+                    }
+                    catch (error) {
+                        callBackFns.forEach(({ reject }) => {
+                            reject(error);
+                        });
+                    }
+                }
+            }));
+            // 标记完成
+            apiFreezerStore.setState({ state: FreezeState.Hibernation });
+            console.timeEnd('Thawing');
+        })();
+    }
+});
+/**
+ * 冻结流程 1～3
+ */
+function hijackingFn(fn) {
+    return function (...params) {
+        const { state, freezeQueue } = apiFreezerStore.getState();
+        const [api] = params;
+        // 不等于冻结状态 | 在接口白名单内
+        // 直接放行
+        if (state !== FreezeState.Freeze || isRequestWhitelisted(api, params)) {
+            return fn(...params);
+        }
+        // 请求拦截
+        else {
+            const key = md5(JSON.stringify(params));
+            if (!freezeQueue.has(key)) {
+                freezeQueue.set(key, {
+                    originFn: () => fn(...params),
+                    // result: null,
+                    callBackFns: [],
+                });
+            }
+            const { callBackFns } = freezeQueue.get(key);
+            return new Promise((resolve, reject) => {
+                callBackFns.push({ reject, resolve });
+            });
+        }
+    };
+}
+const api = new FetchAxios({
+    baseURL: BASE_URL,
+    timeout: 15000,
+    credentials: 'include',
+    validateStatus: (status) => status >= 200 && status < 300,
+});
+const removeBaseurlFromURL = (config) => {
+    const { baseURL, url } = config;
+    if (!baseURL || !url)
+        return;
+    const origin = typeof window === 'undefined' ? 'http://localhost' : window.location.origin;
+    const baseURLObject = new URL(baseURL, origin);
+    const basePath = baseURLObject.pathname.replace(/\/+$/, '');
+    const requestURL = new URL(url, baseURLObject.origin);
+    if (requestURL.origin !== baseURLObject.origin || !basePath)
+        return;
+    const normalizedPathname = requestURL.pathname.replace(/\/+$/, '');
+    if (normalizedPathname !== basePath && !requestURL.pathname.startsWith(`${basePath}/`))
+        return;
+    const pathname = requestURL.pathname.slice(basePath.length) || '/';
+    config.url = `${pathname}${requestURL.search}${requestURL.hash}`;
+};
+// ---- Request Interceptors ----
+api.interceptors.request.use(async (config) => {
+    removeBaseurlFromURL(config);
+    const token = await getAuthToken();
+    const aauto = getApiAuth();
+    const time = new Date().getTime();
+    config.headers = {
+        ...config.headers,
+        s_t: time + '',
+        s_sign: md5(`sakjdfnkjwjfnfkjkjldljksndf_${time}`),
+        [API_AUTH_HEADER_KEY]: aauto,
+    };
+    if (token) {
+        config.headers = {
+            ...config.headers,
+            [AUTH_HEADER_KEY]: `Bearer ${token}`,
+        };
+    }
+    return config;
+});
+api.interceptors.request.use((config) => {
+    console.debug(`[API] ${config.method?.toUpperCase()} ${config.url}`);
+    return config;
+});
+// ---- Response Interceptors ----
+api.interceptors.response.use((res) => res, async (err) => {
+    const axiosErr = err;
+    if (axiosErr.response?.status === 401) {
+        await clearAuthToken();
+        if (typeof window !== 'undefined') {
+            window.location.href = '/login';
+        }
+    }
+    const message = extractErrorMessage(err);
+    console.error(`[API Error] ${message}`, {
+        url: err.config.url,
+        status: err.response?.status,
+    });
+    return Promise.reject(err);
+});
+// ---- Helpers ----
+function extractErrorMessage(err) {
+    if (!(err instanceof Error))
+        return 'Unknown error';
+    const axiosErr = err;
+    if (axiosErr.response?.data && typeof axiosErr.response.data === 'object' && axiosErr.response.data !== null) {
+        const data = axiosErr.response.data;
+        if (typeof data.message === 'string')
+            return data.message;
+        if (typeof data.msg === 'string')
+            return data.msg;
+        if (Array.isArray(data.errors) && data.errors.length > 0) {
+            return String(data.errors[0]);
+        }
+    }
+    if (axiosErr.message)
+        return axiosErr.message;
+    if (axiosErr.code === 'ECONNABORTED')
+        return 'Request timed out';
+    return 'Network error';
+}
+/**
+ * GET/DELETE 不发送 body；统一把 data 转到 params。
+ *  */
+export const get = hijackingFn((url, data, config) => {
+    const hasDataParams = data !== undefined && data !== null && typeof data === 'object';
+    const getConfig = hasDataParams
+        ? {
+            ...config,
+            params: {
+                ...config?.params,
+                ...data,
+            },
+        }
+        : config;
+    return api.get(url, getConfig);
+});
+export const post = hijackingFn((url, data, config) => {
+    return api.post(url, data, config);
+});
+export const put = hijackingFn((url, data, config) => {
+    return api.put(url, data, config);
+});
+export const patch = hijackingFn((url, data, config) => {
+    return api.patch(url, data, config);
+});
+export const del = hijackingFn((url, data, config) => {
+    const hasDataParams = data !== undefined && data !== null && typeof data === 'object';
+    const delConfig = hasDataParams
+        ? {
+            ...config,
+            params: {
+                ...config?.params,
+                ...data,
+            },
+        }
+        : config;
+    return api.delete(url, delConfig);
+});
+export { api, FetchAxios };
+export const request = {
+    get,
+    put,
+    post,
+    del,
+    patch,
+};

package/fe/frontend/src/components/AsyncSelect/AsyncSelect.d.ts

@@ -0,0 +1,8 @@
+import type { MergeType, MOmit } from '../../../../typings/type';
+import { FetchInfo } from '../../../../model/types/data/fetchInfo';
+import { SelectProps } from '../../../../packages/ui/react';
+export interface AsyncSelectProps extends MergeType<[MOmit<FetchInfo, 'fetchKey'>, MOmit<SelectProps, 'options'>]> {
+}
+declare const AsyncSelect: (props: AsyncSelectProps) => import("react/jsx-runtime").JSX.Element;
+export default AsyncSelect;
+//# sourceMappingURL=AsyncSelect.d.ts.map

package/fe/frontend/src/components/AsyncSelect/AsyncSelect.js

@@ -0,0 +1,32 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { handlingRequestErrors } from '../../common/fetchErrorShow';
+import { request } from '../../common/request';
+import { Select } from '../../../../packages/ui/react';
+import useExecuteOnce from '../../../../packages/ui/react/hooks/useExecuteOnce';
+import { useState } from 'react';
+const AsyncSelect = (props) => {
+    const { fetchConfig, ...params } = props;
+    const [options, setOptions] = useState([]);
+    const [loading, setLoading] = useState(false);
+    useExecuteOnce(async () => {
+        if (fetchConfig) {
+            setLoading(true);
+            const { method = 'get', url } = fetchConfig;
+            try {
+                const res = await handlingRequestErrors(request[method](url));
+                if (res.data.code === 0) {
+                    setOptions(res.data.data.map((i) => {
+                        i.searchText = i.label;
+                        return i;
+                    }));
+                }
+            }
+            finally {
+                setLoading(false);
+            }
+        }
+    }, { executionPhase: 'mount' });
+    // @ts-ignore
+    return _jsx(Select, { loading: loading, options: options, ...params });
+};
+export default AsyncSelect;

package/fe/frontend/src/components/AsyncSelect/index.d.ts

@@ -0,0 +1,4 @@
+import AsyncSelect from './AsyncSelect';
+export * from './AsyncSelect';
+export default AsyncSelect;
+//# sourceMappingURL=index.d.ts.map

package/fe/frontend/src/components/AsyncSelect/index.js

@@ -0,0 +1,3 @@
+import AsyncSelect from './AsyncSelect';
+export * from './AsyncSelect';
+export default AsyncSelect;