@_tc/template-core 0.0.1-bate.36 → 0.0.1-bate.38

package/fe/frontend/widgets/defaultPages/Schema/components/SchemaSearch/index.js

@@ -0,0 +1,63 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { getText } from '../../../../../widgets/common/language';
+import { filterEmpty } from '../../../../../../packages/common/index.js';
+import { TableSearch } from '../../../../../../packages/ui/react/components';
+import useInit from '../../../../../../packages/ui/react/hooks/useInit';
+import { memo, useState } from 'react';
+import { schemaEventBus } from '../../stores/schemaEventBus';
+import { useSchemaStore } from '../../stores/schemaStore';
+const generateSchemas = (config) => {
+    // TODO ? 是否需要缓存
+    // const { comSchemaCache } = schemaStore.getState()
+    // if (comSchemaCache.has(schemaKey)) {
+    // }
+    const keys = Object.keys(config);
+    const schemas = [];
+    let defaultValue = undefined;
+    keys.forEach((k) => {
+        const fieldInfo = config[k];
+        if (fieldInfo.option) {
+            const { comType = 'input', default: defaultFieldValue, ...fieldProps } = fieldInfo.option;
+            if (typeof defaultFieldValue !== 'undefined') {
+                if (!defaultValue) {
+                    defaultValue = {};
+                }
+                defaultValue[k] = defaultFieldValue;
+            }
+            schemas.push({
+                label: getText(fieldInfo.label),
+                key: k,
+                type: comType,
+                fieldProps,
+            });
+        }
+    });
+    return { schemas, defaultValue };
+};
+const SchemaSearch = memo(() => {
+    // 暂时没有 config
+    const schema = useSchemaStore((s) => s.searchSchema);
+    const [schemas, setSchemas] = useState([]);
+    const [defaultValue, setSchemaDefaultValue] = useState(undefined);
+    useInit(() => {
+        const { schemas, defaultValue } = generateSchemas(schema.properties);
+        setSchemas(schemas);
+        setSchemaDefaultValue(defaultValue);
+    });
+    const tsProps = {
+        schemas,
+        defaultValue,
+        onSearch(values) {
+            schemaEventBus.getState().emitSearch(filterEmpty(values));
+        },
+        onReset() {
+            schemaEventBus.getState().emitSearch(undefined);
+        },
+        renderActionBtnArea: () => {
+            return undefined;
+        },
+    };
+    return (_jsx("div", { className: "schema-search", children: _jsx(TableSearch, { ...tsProps }) }));
+});
+SchemaSearch.displayName = 'SchemaSearch';
+export default SchemaSearch;

package/fe/frontend/widgets/defaultPages/Schema/components/SchemaTable/index.d.ts

@@ -0,0 +1,11 @@
+import { Ref } from 'react';
+import { SchemaDefaultValue } from '../../schemaType';
+export type SchemaTableRef = {
+    initData: (query?: SchemaDefaultValue) => Promise<void>;
+};
+export interface SchemaTableProps {
+    ref?: Ref<SchemaTableRef>;
+}
+declare const SchemaTable: import("react").MemoExoticComponent<({ ref }: SchemaTableProps) => import("react/jsx-runtime").JSX.Element>;
+export default SchemaTable;
+//# sourceMappingURL=index.d.ts.map

package/fe/frontend/widgets/defaultPages/Schema/components/SchemaTable/index.js

@@ -0,0 +1,188 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { getText } from '../../../../../widgets/common/language';
+import { del, get } from '../../../../../widgets/common/request';
+import { Button, DataTable, modal, } from '../../../../../../packages/ui/react/components';
+import useExecuteOnce from '../../../../../../packages/ui/react/hooks/useExecuteOnce';
+import useInit from '../../../../../../packages/ui/react/hooks/useInit';
+import useRefState from '../../../../../../packages/ui/react/hooks/useRefState';
+import useWatch from '../../../../../../packages/ui/react/hooks/useWatch';
+import { produce } from 'immer';
+import { memo, useCallback, useImperativeHandle, useMemo, useState } from 'react';
+import { useShallow } from 'zustand/react/shallow';
+import { eventsInfo } from '../../data/eventInfo';
+import { schemaEventBus } from '../../stores/schemaEventBus';
+import { useSchemaStore } from '../../stores/schemaStore';
+import { handlingRequestErrors } from '../../utils/fetchErrorShow';
+import { merge } from '../../utils/permissions';
+const VALUE_KEY = 'schema::';
+const generateColumns = (config) => {
+    const keys = Object.keys(config);
+    const columns = [];
+    keys.forEach((k) => {
+        const fieldInfo = config[k];
+        if (fieldInfo?.option) {
+            const { 
+            // comType = 'input', default: defaultFieldValue,
+            ...fieldProps } = fieldInfo.option;
+            columns.push({
+                title: getText(fieldInfo.label),
+                key: k,
+                ...fieldProps,
+                // fieldProps,
+            });
+        }
+    });
+    return columns;
+};
+const generateRowActions = (btnConfigs, rowData, api) => {
+    const handleRowAction = (btnConfig) => {
+        const { eventKey, eventOption } = btnConfig;
+        switch (eventKey) {
+            case 'callComponent':
+                // 与  schemaPage通信
+                const { emitTable } = schemaEventBus.getState();
+                emitTable({ ...rowData, comName: eventOption.comName });
+                break;
+            case 'remove':
+                // 调用api
+                if (api) {
+                    const apiParams = Object.entries(eventOption.params).reduce((o, [k, v]) => {
+                        // 使用当前行的某个数据
+                        if (('' + v).includes(VALUE_KEY)) {
+                            const valueKey = ('' + v).split(VALUE_KEY)[1];
+                            o[k] = rowData[valueKey];
+                        }
+                        else {
+                            o[k] = v;
+                        }
+                        return o;
+                    }, {});
+                    modal.confirm({
+                        content: `确认删除？`,
+                        async onOk() {
+                            await handlingRequestErrors(del(api, apiParams));
+                            schemaEventBus.getState().emitCom({ type: merge(eventsInfo.initTable) });
+                            return true;
+                        },
+                    });
+                }
+                break;
+            default:
+                break;
+        }
+    };
+    return btnConfigs.map((rb, index) => {
+        const label = getText(rb.label ?? '');
+        const bState = rb.eventKey === 'remove' ? 'danger' : undefined;
+        return {
+            render: (_item, { close }) => (_jsx("div", { className: " p-2.5", children: _jsx(Button, { state: bState, variant: "link", onClick: () => {
+                        handleRowAction(rb);
+                        close();
+                    }, children: label }, `${rb.eventKey}-${rb.label ?? index}`) })),
+        };
+    });
+};
+const SchemaTable = memo(({ ref }) => {
+    const params = useSchemaStore(useShallow((s) => ({ config: s.tableConfig, schema: s.tableSchema, api: s.api })));
+    const [data, uData] = useState([]);
+    const [columns, uColumns] = useState([]);
+    const [loading, uLoading, loadingRef] = useRefState(false);
+    const [pagination, setPagination, paginationRef] = useRefState({
+        current: 1,
+        pageSize: 10,
+        total: 0,
+    });
+    const [handleBtn, setHandleBtn] = useState([]);
+    const init = useCallback(async (query) => {
+        if (loadingRef.current.data)
+            return;
+        uLoading(true);
+        try {
+            const res = await handlingRequestErrors(get(params.api ? `${params.api}/list` : '', { ...query, ...paginationRef.current.data }));
+            if (res.data.code === 0) {
+                uData(res.data.data.data);
+                setPagination(produce((nextState) => {
+                    nextState.total = res.data.data.total;
+                }));
+            }
+        }
+        finally {
+            uLoading(false);
+        }
+    }, [loadingRef, paginationRef, params.api, setPagination, uLoading]);
+    useImperativeHandle(ref, () => {
+        return {
+            initData: init,
+        };
+    }, [init]);
+    useInit(() => {
+        const contextColumns = generateColumns(params.schema.properties);
+        const actionColumn = [];
+        if (params.config) {
+            const { rowButtons, headerButtons } = params.config;
+            // 处理row交互
+            if (rowButtons) {
+                actionColumn.push({
+                    key: 'action',
+                    title: getText('操作'),
+                    actions: (_value, _record, index) => [
+                        ...generateRowActions(rowButtons, _record, params.api),
+                        // { key: `text-${index}`, label: 'text' },
+                        // { key: `link-${index}`, label: 'link' },
+                    ],
+                });
+            }
+            // 处理page 交互
+            setHandleBtn(headerButtons?.map((c) => {
+                const { label, eventKey, eventOption, ...props } = c;
+                return {
+                    children: getText(label ?? ''),
+                    onClick: () => {
+                        if ('comName' in eventOption) {
+                            schemaEventBus.getState().emitTable(eventOption);
+                        }
+                        else {
+                            // 不存在这种用法
+                        }
+                    },
+                    ...props,
+                };
+                // }
+            }) ?? []);
+        }
+        uColumns(contextColumns.concat(actionColumn));
+    });
+    useExecuteOnce(() => {
+        init();
+    }, { executionPhase: 'mount' });
+    const daProps = useMemo(() => {
+        return {
+            columns,
+            data,
+            loading,
+            pagination: {
+                ...pagination,
+                onPageSizeChange(pageSize) {
+                    setPagination(produce((ns) => {
+                        ns.pageSize = pageSize;
+                    }));
+                },
+                onChange(page) {
+                    setPagination(produce((ns) => {
+                        ns.current = page;
+                    }));
+                },
+            },
+        };
+    }, [columns, data, loading, pagination, setPagination]);
+    useWatch([pagination.current, pagination.pageSize], () => {
+        init();
+    }, {
+        compare: 'shallow',
+    });
+    return (_jsxs("div", { className: "schema-table", children: [_jsx("div", { className: "schema-table flex items-end", children: handleBtn.map((bc) => {
+                    return _jsx(Button, { ...bc });
+                }) }), _jsx(DataTable, { ...daProps })] }));
+});
+SchemaTable.displayName = 'SchemaTable';
+export default SchemaTable;

package/fe/frontend/widgets/defaultPages/Schema/data/eventInfo.d.ts

@@ -0,0 +1,8 @@
+export declare const eventsInfo: {
+    readonly none: 0;
+    readonly closeCom: 1;
+    readonly initTable: 2;
+    readonly resetSearch: 2;
+};
+export type EventInfoKey = keyof typeof eventsInfo;
+//# sourceMappingURL=eventInfo.d.ts.map

package/fe/frontend/widgets/defaultPages/Schema/data/eventInfo.js

@@ -0,0 +1,6 @@
+export const eventsInfo = {
+    none: /**      */ 0b00000000000000,
+    closeCom: /**     */ 0b00000000000001,
+    initTable: /** */ 0b00000000000010,
+    resetSearch: /** */ 0b00000000000010,
+};

package/fe/frontend/widgets/defaultPages/Schema/data/index.d.ts

@@ -0,0 +1,3 @@
+export declare const suffixKey = "Option";
+export type SuffixKey = typeof suffixKey;
+//# sourceMappingURL=index.d.ts.map

package/fe/frontend/widgets/defaultPages/Schema/data/index.js

@@ -0,0 +1 @@
+export const suffixKey = "Option";

package/fe/frontend/widgets/defaultPages/Schema/hooks/useComConfig.d.ts

@@ -0,0 +1,10 @@
+import type { CallComNames, NamedComponentConfig, NamedSchemaType } from '../schemaType';
+declare const useComConfig: <CN extends CallComNames>({ comName }: {
+    comName: CallComNames;
+}) => {
+    config: NamedComponentConfig<CN>;
+    schema: NamedSchemaType<`${CN}Option`>;
+    api: string | undefined;
+};
+export default useComConfig;
+//# sourceMappingURL=useComConfig.d.ts.map

package/fe/frontend/widgets/defaultPages/Schema/hooks/useComConfig.js

@@ -0,0 +1,14 @@
+import { useShallow } from 'zustand/react/shallow';
+import { useSchemaStore } from '../stores/schemaStore';
+const useComConfig = ({ comName }) => {
+    const params = useSchemaStore(useShallow((s) => ({ comConfig: s.components, api: s.api })));
+    const comConfig = params.comConfig?.[comName];
+    const config = comConfig?.config;
+    const schema = comConfig?.schema;
+    return {
+        config,
+        schema,
+        api: params.api,
+    };
+};
+export default useComConfig;

package/fe/frontend/widgets/defaultPages/Schema/index.d.ts

@@ -0,0 +1,3 @@
+declare const Schema: import("react").MemoExoticComponent<() => import("react/jsx-runtime").JSX.Element>;
+export default Schema;
+//# sourceMappingURL=index.d.ts.map

package/fe/frontend/widgets/defaultPages/Schema/index.js

@@ -0,0 +1,74 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { logIllegalComponentCallback } from '../../../widgets/common/logFn';
+import useCurrentMenuData from '../../../widgets/hooks/useCurrentMenuData';
+import useExecuteOnce, { executionPhaseType } from '../../../../packages/ui/react/hooks/useExecuteOnce';
+import useInit from '../../../../packages/ui/react/hooks/useInit';
+import { memo, Suspense, useCallback, useMemo, useRef, useState } from 'react';
+import { components } from './components/CallCom/data';
+import SchemaSearch from './components/SchemaSearch';
+import SchemaTable from './components/SchemaTable';
+import { eventsInfo } from './data/eventInfo';
+import { schemaEventBus } from './stores/schemaEventBus';
+import { useSchemaStore } from './stores/schemaStore';
+import { isAllowed } from './utils/permissions';
+import { schemaConversion } from './utils/schemaConversion';
+const Schema = memo(() => {
+    const { menu } = useCurrentMenuData();
+    const [showCompoentKey, setShowCompoentKey] = useState();
+    const [comProps, setComProps] = useState({});
+    const schemaStoreAvailable = useSchemaStore((s) => s.schemaStoreAvailable);
+    const TableRef = useRef(null);
+    const onSearch = useCallback((v) => {
+        TableRef.current?.initData(v);
+    }, []);
+    const callCom = useCallback((v) => {
+        const { comName, ...params } = v;
+        setComProps({ data: params, comName });
+        setShowCompoentKey(comName);
+    }, []);
+    const comDone = useCallback(({ type }) => {
+        /**
+         * 解析出需要执行的操作
+         */
+        if (isAllowed(type, eventsInfo.closeCom)) {
+            setShowCompoentKey(undefined);
+            setComProps(undefined);
+        }
+        if (isAllowed(type, eventsInfo.initTable)) {
+            TableRef.current?.initData();
+        }
+        if (isAllowed(type, eventsInfo.resetSearch)) {
+        }
+    }, []);
+    useInit(() => {
+        // schema数据分离
+        schemaConversion(menu.schemaConfig, menu.key);
+    });
+    useExecuteOnce(() => {
+        // 关联search
+        schemaEventBus.getState().subscribeSearch(onSearch);
+        // 订阅组件消息
+        schemaEventBus.getState().subscribeCom(comDone);
+        // 关联table
+        schemaEventBus.getState().subscribeTable(callCom);
+    }, { executionPhase: executionPhaseType.mount });
+    useExecuteOnce(() => {
+        schemaEventBus.getState().unSubscribeSearch(onSearch);
+        schemaEventBus.getState().unSubscribeTable(callCom);
+        schemaEventBus.getState().unSubscribeCom(comDone);
+    }, { executionPhase: executionPhaseType.unMount });
+    const dom = useMemo(() => {
+        if (schemaStoreAvailable) {
+            const CallCom = components[showCompoentKey];
+            if (!CallCom && showCompoentKey) {
+                logIllegalComponentCallback(showCompoentKey);
+            }
+            return (_jsxs("div", { className: "schema-container gap-3 flex-col flex h-full", children: [_jsx(SchemaSearch, {}), _jsx(SchemaTable, { ref: TableRef }), _jsx(Suspense, { children: CallCom && _jsx(CallCom, { ...comProps }) })] }));
+        }
+        else
+            return _jsx("div", { children: "loading" });
+    }, [comProps, schemaStoreAvailable, showCompoentKey]);
+    return dom;
+});
+Schema.displayName = 'SchemaPage';
+export default Schema;

package/fe/frontend/widgets/defaultPages/Schema/schemaType.d.ts

@@ -0,0 +1,50 @@
+import type { ComponentConfig } from '../../../../model/types/data/component';
+import type { BaseOption, ConfigSchema, SchemaDataType, SearchConfig, TableConfig, UsedConfigSchema } from '../../../../model/types/data/schema';
+import type { SuffixKey } from './data';
+export type { ComponentConfig, SearchConfig, TableConfig };
+export type FieldType = ConfigSchema['properties'][''];
+export type SchemaType = Required<SchemaDataType>['schema'];
+export type AllFieldKeys = keyof FieldType;
+export type AllOptionsPreNames = {
+    [K in AllFieldKeys]: K extends `${infer Name}${SuffixKey}` ? Name : never;
+}[AllFieldKeys];
+export type NonOptionKey = {
+    [K in AllFieldKeys]: K extends `${string}${SuffixKey}` ? never : K;
+}[AllFieldKeys];
+export type StoreSchemaType = UsedConfigSchema<BaseOption<FieldType[`${AllOptionsPreNames}${SuffixKey}`]>>;
+export type NamedSchemaType<N extends `${AllOptionsPreNames}${SuffixKey}`> = UsedConfigSchema<BaseOption<FieldType[N]>>;
+/**
+ * 获取具体名称的 components options 配置
+ */
+export type NamedComOption<N extends CallComNames> = ComponentType<ComponentConfig>[N];
+/**
+ * 获取具名 组件配置
+ */
+export type NamedComponentConfig<N extends CallComNames> = ComponentConfig[N];
+type ComponentC<C extends ComponentConfig> = {
+    [K in keyof C]: {
+        schema: StoreSchemaType;
+        config: C[K];
+    };
+}[keyof C];
+export type ComponentType<C extends ComponentConfig> = {
+    [K in keyof C]: ComponentC<C>;
+};
+export type CallComNames = keyof ComponentConfig;
+export type SchemaDefaultValue = Record<string, any>;
+export type SchemaTableEmitData = SchemaDefaultValue & {
+    comName: CallComNames;
+};
+export declare const enum ComEventType {
+    close = 0
+}
+export type SchemaComEventInfo = {
+    /**
+     * 操作权限合集
+     */
+    type: number;
+};
+export type CallComponent<T> = {
+    [K in CallComNames]: T;
+};
+//# sourceMappingURL=schemaType.d.ts.map

package/fe/frontend/widgets/defaultPages/Schema/schemaType.js

@@ -0,0 +1,4 @@
+export var ComEventType;
+(function (ComEventType) {
+    ComEventType[ComEventType["close"] = 0] = "close";
+})(ComEventType || (ComEventType = {}));

package/fe/frontend/widgets/defaultPages/Schema/stores/schemaEventBus.d.ts

@@ -0,0 +1,42 @@
+import { SchemaComEventInfo, SchemaDefaultValue, SchemaTableEmitData } from '../schemaType';
+/**
+ * 消费方 subscribeSearch(fn)
+ *      unSubscribeSearch(fn)
+ *
+ * 通知方 emitSearch (value)
+ *
+ */
+type WatchFn<V = SchemaDefaultValue | undefined> = (value: V) => void;
+declare const enum SubscribeEnum {
+    search = "search",
+    table = "table",
+    com = "com"
+}
+interface SchemaEventBusStore {
+    readonly Subscribers: Map<WatchFn, SubscribeEnum>;
+    /**
+     * 订阅 Search 变化
+     */
+    subscribeSearch: (fn: WatchFn) => void;
+    unSubscribeSearch: (fn: WatchFn) => void;
+    emitSearch: (v: SchemaDefaultValue | undefined) => void;
+    /**
+     * 订阅 Table 变化
+     */
+    subscribeTable: (fn: WatchFn<SchemaTableEmitData>) => void;
+    unSubscribeTable: (fn: WatchFn<SchemaTableEmitData>) => void;
+    emitTable: (v: SchemaTableEmitData) => void;
+    /**
+     * 通用 call
+     */
+    emitCall: (v: SchemaDefaultValue | undefined, type: SubscribeEnum) => void;
+    /**
+     * 订阅组件变化
+     */
+    subscribeCom: (fn: WatchFn<SchemaComEventInfo>) => void;
+    unSubscribeCom: (fn: WatchFn<SchemaComEventInfo>) => void;
+    emitCom: (v: SchemaComEventInfo) => void;
+}
+export declare const schemaEventBus: import("zustand").StoreApi<SchemaEventBusStore>;
+export {};
+//# sourceMappingURL=schemaEventBus.d.ts.map

package/fe/frontend/widgets/defaultPages/Schema/stores/schemaEventBus.js

@@ -0,0 +1,70 @@
+import { logSubscriptionError } from '../../../../widgets/common/logFn';
+import { createStore } from 'zustand';
+var SubscribeEnum;
+(function (SubscribeEnum) {
+    SubscribeEnum["search"] = "search";
+    SubscribeEnum["table"] = "table";
+    SubscribeEnum["com"] = "com";
+})(SubscribeEnum || (SubscribeEnum = {}));
+export const schemaEventBus = createStore((set, get) => {
+    return {
+        Subscribers: new Map(),
+        // com
+        subscribeCom(fn) {
+            get().Subscribers.set(fn, SubscribeEnum.com);
+        },
+        unSubscribeCom(fn) {
+            const { Subscribers } = get();
+            if (Subscribers.has(fn)) {
+                Subscribers.delete(fn);
+            }
+            else {
+                logSubscriptionError();
+            }
+        },
+        emitCom(v) {
+            get().emitCall(v, SubscribeEnum.com);
+        },
+        // table
+        subscribeTable(fn) {
+            get().Subscribers.set(fn, SubscribeEnum.table);
+        },
+        unSubscribeTable(fn) {
+            const { Subscribers } = get();
+            if (Subscribers.has(fn)) {
+                Subscribers.delete(fn);
+            }
+            else {
+                logSubscriptionError();
+            }
+        },
+        emitTable(v) {
+            get().emitCall(v, SubscribeEnum.table);
+        },
+        emitCall(v, calType) {
+            const { Subscribers } = get();
+            for (const [fn, type] of Subscribers.entries()) {
+                if (calType === type) {
+                    fn(v);
+                }
+            }
+        },
+        // search
+        subscribeSearch(fn) {
+            get().Subscribers.set(fn, SubscribeEnum.search);
+        },
+        unSubscribeSearch(fn) {
+            const { Subscribers } = get();
+            if (Subscribers.has(fn)) {
+                Subscribers.delete(fn);
+            }
+            else {
+                logSubscriptionError();
+            }
+        },
+        emitSearch(v) {
+            get().emitCall(v, SubscribeEnum.search);
+        },
+        //
+    };
+});

package/fe/frontend/widgets/defaultPages/Schema/stores/schemaStore.d.ts

@@ -0,0 +1,47 @@
+import { LRUCache } from '../../../../../packages/common/index.js';
+import { TableSearchSchema } from '../../../../../packages/ui/react/components/TableSearch/TableSearch';
+import type { MOmit } from '../../../../../typings/type';
+import type { ComponentConfig, ComponentType, SearchConfig, StoreSchemaType, TableConfig } from '../schemaType';
+interface FunctionalData {
+    api: string;
+    components: ComponentType<ComponentConfig>;
+    tableSchema: StoreSchemaType;
+    tableConfig: TableConfig;
+    searchSchema: StoreSchemaType;
+    searchConfig: SearchConfig;
+}
+interface ComSchemaCache {
+    searchSchema: TableSearchSchema<Record<string, any>>[];
+}
+interface SchemaStoreState extends Partial<FunctionalData> {
+    readonly schemaStoreAvailable: boolean;
+    /**
+     *  页面schema 配置
+     */
+    readonly schemaCache: LRUCache<FunctionalData>;
+    /**
+     *  组件schema缓存配置
+     */
+    readonly comSchemaCache: LRUCache<ComSchemaCache>;
+}
+interface SchemaStoreActions {
+    setSchemaState: (data: Partial<MOmit<SchemaStoreState, 'schemaStoreAvailable' | 'schemaCache'>>) => void;
+    /**
+     *
+     * 更新 key schema 缓存
+     */
+    updateSchemaCache: (data: FunctionalData & {
+        schemaKey: string;
+    }) => void;
+    /**
+     *
+     * 更新 组件 配置
+     */
+    updateComSchemaCache: (data: ComSchemaCache & {
+        schemaKey: string;
+    }) => void;
+}
+export declare const schemaStore: import("zustand").StoreApi<SchemaStoreState & SchemaStoreActions>;
+export declare const useSchemaStore: import("../../../../../packages/ui/react/index").StoreHook<import("zustand").StoreApi<SchemaStoreState & SchemaStoreActions>>;
+export {};
+//# sourceMappingURL=schemaStore.d.ts.map

package/fe/frontend/widgets/defaultPages/Schema/stores/schemaStore.js

@@ -0,0 +1,26 @@
+import { LRUCache } from '../../../../../packages/common/index.js';
+import { createStoreHook } from '../../../../../packages/ui/react/index';
+import { createStore } from 'zustand';
+export const schemaStore = createStore((set, get) => ({
+    api: '',
+    schemaStoreAvailable: false,
+    schemaCache: new LRUCache(5),
+    comSchemaCache: new LRUCache(5),
+    setSchemaState: (state) => {
+        set({ ...state });
+        set({ schemaStoreAvailable: !!get().api });
+    },
+    updateSchemaCache: (data) => {
+        // 直接设置值
+        const { schemaKey, ...params } = data;
+        const { schemaCache } = get();
+        schemaCache.set(schemaKey, params);
+    },
+    updateComSchemaCache: (data) => {
+        // 直接设置值
+        const { schemaKey, ...params } = data;
+        const { comSchemaCache } = get();
+        comSchemaCache.set(schemaKey, params);
+    },
+}));
+export const useSchemaStore = createStoreHook(schemaStore);

package/fe/frontend/widgets/defaultPages/Schema/utils/fetchErrorShow.d.ts

@@ -0,0 +1,3 @@
+import type { BaseResponse, ResponseConfig } from '../../../../widgets/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/widgets/defaultPages/Schema/utils/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/widgets/defaultPages/Schema/utils/permissions.d.ts

@@ -0,0 +1,3 @@
+export declare const merge: (...params: number[]) => number;
+export declare const isAllowed: (key1: number, key2: number) => boolean;
+//# sourceMappingURL=permissions.d.ts.map

package/fe/frontend/widgets/defaultPages/Schema/utils/permissions.js

@@ -0,0 +1,3 @@
+import { eventsInfo } from '../data/eventInfo';
+export const merge = (...params) => params.reduce((o, n) => o | n, eventsInfo.none);
+export const isAllowed = (key1, key2) => (key1 & key2) !== eventsInfo.none;