@weaveui/web 0.0.1

package/dist/business/monitor/types.d.ts

@@ -0,0 +1,221 @@
+import { App } from 'vue';
+export type MonitorLevel = 'debug' | 'info' | 'warning' | 'error' | 'fatal';
+export type MonitorContext = Record<string, unknown>;
+export type MonitorTags = Record<string, string | number | boolean>;
+export interface MonitorExceptionData {
+    name: string;
+    message: string;
+    stack?: string;
+    source?: 'manual' | 'window.error' | 'vue' | 'unhandledrejection';
+    filename?: string;
+    line?: number;
+    column?: number;
+}
+export interface MonitorMessageData {
+    message: string;
+}
+export interface MonitorResourceData {
+    element: string;
+    url: string;
+}
+export interface MonitorNavigationData {
+    source: 'history' | 'hashchange' | 'popstate';
+    method?: 'pushState' | 'replaceState';
+    from: string;
+    to: string;
+    duration: number;
+}
+export interface MonitorPerformanceData {
+    navigationType?: string;
+    duration: number;
+    redirect: number;
+    dns: number;
+    connection: number;
+    request: number;
+    response: number;
+    domInteractive: number;
+    domContentLoaded: number;
+    load: number;
+}
+export interface MonitorRequestData {
+    kind: 'fetch' | 'xhr';
+    method: string;
+    url: string;
+    status?: number;
+    duration: number;
+    ok: boolean;
+    error?: string;
+}
+interface MonitorEventBase<TType extends string, TData> {
+    type: TType;
+    level: MonitorLevel;
+    timestamp: number;
+    url: string;
+    context: MonitorContext;
+    tags: MonitorTags;
+    data: TData;
+}
+export type MonitorEvent = MonitorEventBase<'exception', MonitorExceptionData> | MonitorEventBase<'message', MonitorMessageData> | MonitorEventBase<'resource', MonitorResourceData> | MonitorEventBase<'unhandledrejection', MonitorExceptionData> | MonitorEventBase<'navigation', MonitorNavigationData> | MonitorEventBase<'performance', MonitorPerformanceData> | MonitorEventBase<'request', MonitorRequestData>;
+export interface MonitorTransportContext {
+    fetch: (input: RequestInfo | URL, init?: RequestInit) => Promise<Response>;
+    createXMLHttpRequest: () => XMLHttpRequest;
+}
+export interface MonitorRedactionOptions {
+    keys?: readonly (string | RegExp)[];
+    queryParams?: readonly (string | RegExp)[];
+    replacement?: string;
+}
+export interface MonitorVuePluginOptions {
+    startOnInstall?: boolean;
+}
+export interface MonitorVuePlugin {
+    install: (app: App) => void;
+}
+export interface MonitorClient {
+    readonly started: boolean;
+    start: () => boolean;
+    stop: () => void;
+    destroy: () => void;
+    captureException: (exception: unknown, context?: MonitorContext) => void;
+    captureMessage: (message: string, level?: MonitorLevel, context?: MonitorContext) => void;
+    createVuePlugin: (options?: MonitorVuePluginOptions) => MonitorVuePlugin;
+}
+/**
+ * The report shape exposed by the historical `monitor-jiniu` package.
+ *
+ * The adapter intentionally keeps this extensible because old applications
+ * commonly passed business fields directly to `log()`.
+ */
+export interface LegacyMonitorReport {
+    moduleId?: string;
+    type: string;
+    status?: string;
+    time: number;
+    pageUrl?: string;
+    appChannelId?: string;
+    dataChannelId?: string;
+    version?: string;
+    userId?: string | number;
+    message?: unknown;
+    data?: Record<string, unknown>;
+    [key: string]: unknown;
+}
+export type LegacyMonitorLogPayload = string | Record<string, unknown>;
+export type LegacyBeforeDataReport = (report: LegacyMonitorReport) => LegacyMonitorReport | false | void | Promise<LegacyMonitorReport | false | void>;
+/**
+ * Receives a legacy-shaped report before the built-in `dsn` transport runs.
+ * Use the supplied context for network reporting so the request bypasses all
+ * CustomUI monitor request instrumentation on the page.
+ */
+export type LegacyMonitorTransport = (report: LegacyMonitorReport, event: MonitorEvent, context: MonitorTransportContext) => void | Promise<void>;
+export type LegacyUnsupportedOption = 'silentWhiteScreen' | 'whiteBoxElements' | 'skeletonProject' | 'silentRecordScreen' | 'recordScreentime' | 'recordScreenTypeList' | 'useImgUpload' | 'silentClick' | 'throttleDelayTime' | 'maxBreadcrumbs' | 'beforePushBreadcrumb' | 'overTime' | 'handleHttpStatus' | 'defHttp' | 'router' | 'recordScreenPlugin';
+export interface LegacyUnsupportedOptionNotice {
+    option: LegacyUnsupportedOption;
+    value: unknown;
+    message: string;
+}
+export type LegacyUnsupportedOptionHandler = (notice: LegacyUnsupportedOptionNotice) => void;
+/**
+ * Options accepted by the old `monitor-jiniu` entrypoint, mapped onto the
+ * internal CustomUI monitor runtime.
+ *
+ * Historical `silent*` names are preserved as implemented by the old package:
+ * passing `true` enables the corresponding collector.
+ */
+export interface LegacyMonitorOptions {
+    /** Historical report endpoint. Required unless `transport` is supplied. */
+    dsn?: string;
+    version?: string;
+    appChannelId?: string;
+    dataChannelId?: string;
+    userId?: string | number;
+    getUserId?: () => string | number | null | undefined;
+    disabled?: boolean;
+    silentXhr?: boolean;
+    silentFetch?: boolean;
+    silentClick?: boolean;
+    silentError?: boolean;
+    silentUnhandledrejection?: boolean;
+    silentHashchange?: boolean;
+    silentHistory?: boolean;
+    silentPerformance?: boolean;
+    filterXhrUrlRegExp?: RegExp;
+    beforeDataReport?: LegacyBeforeDataReport;
+    repeatCodeError?: boolean;
+    /**
+     * Optional custom report sender. It replaces the built-in `dsn` request.
+     * Always use `context.fetch()` or `context.createXMLHttpRequest()` inside it.
+     */
+    transport?: LegacyMonitorTransport;
+    onUnsupportedOption?: LegacyUnsupportedOptionHandler;
+    /** Browser/test customization forwarded to the underlying monitor. */
+    window?: Window;
+    sampleRate?: number;
+    redact?: MonitorRedactionOptions;
+    tags?: MonitorTags;
+    context?: MonitorContext;
+    environment?: string;
+    random?: () => number;
+    now?: () => number;
+    silentWhiteScreen?: boolean;
+    skeletonProject?: boolean;
+    whiteBoxElements?: string | readonly string[];
+    silentRecordScreen?: boolean;
+    recordScreentime?: number;
+    recordScreenTypeList?: readonly string[];
+    useImgUpload?: boolean;
+    throttleDelayTime?: number;
+    overTime?: number;
+    maxBreadcrumbs?: number;
+    beforePushBreadcrumb?: (data: unknown) => unknown;
+    handleHttpStatus?: (data: unknown) => boolean;
+    defHttp?: unknown;
+    router?: unknown;
+}
+/** A small subset of the old plugin contract that can run safely in the adapter. */
+export interface LegacyMonitorPlugin {
+    type?: string;
+    transform?: (report: LegacyMonitorReport) => void;
+    core?: (context: LegacyMonitorPluginContext) => void;
+}
+export interface LegacyMonitorPluginConstructor<TOptions = unknown> {
+    new (options: TOptions): LegacyMonitorPlugin;
+}
+export interface LegacyMonitorPluginContext {
+    readonly options: Readonly<LegacyMonitorOptions>;
+    readonly transportData: {
+        send: (payload: LegacyMonitorLogPayload) => boolean;
+    };
+    readonly breadcrumb: {
+        push: (payload: LegacyMonitorLogPayload) => boolean;
+    };
+    readonly notify: (type: string, payload?: LegacyMonitorLogPayload) => boolean;
+}
+export interface LegacyMonitorClient {
+    readonly monitor: MonitorClient | undefined;
+    readonly started: boolean;
+    readonly options: Readonly<LegacyMonitorOptions> | undefined;
+    init: (options?: LegacyMonitorOptions) => LegacyMonitorClient;
+    install: (app: App, options?: LegacyMonitorOptions) => void;
+    log: (payload: LegacyMonitorLogPayload) => boolean;
+    errorBoundary: (error: unknown) => boolean;
+    use: <TOptions>(plugin: LegacyMonitorPluginConstructor<TOptions>, options?: TOptions) => LegacyMonitorPlugin | undefined;
+    stop: () => void;
+    destroy: () => void;
+}
+export interface LegacyMonitorMapping {
+    captureRequests: {
+        xhr: boolean;
+        fetch: boolean;
+    };
+    captureGlobalErrors: boolean;
+    captureUnhandledRejections: boolean;
+    captureNavigation: boolean;
+    capturePerformance: boolean;
+    ignoredUrls: readonly (string | RegExp)[];
+}
+export interface LegacyMonitorRuntime {
+    readonly monitor: MonitorClient | undefined;
+    readonly mapping: LegacyMonitorMapping | undefined;
+}
+export {};

package/dist/business/permission/Permission.d.ts

@@ -0,0 +1,18 @@
+import { PropType } from 'vue';
+import { LegacyPermissionSign } from './types';
+/** Vue 3 replacement for the legacy `<Permission :sign="...">` component. */
+export declare const Permission: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    sign: {
+        type: PropType<LegacyPermissionSign>;
+        default: string;
+    };
+}>, () => import('vue').VNode<import('vue').RendererNode, import('vue').RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    sign: {
+        type: PropType<LegacyPermissionSign>;
+        default: string;
+    };
+}>> & Readonly<{}>, {
+    sign: LegacyPermissionSign;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;

package/dist/business/permission/PermissionPluginClass.d.ts

@@ -0,0 +1,40 @@
+import { LegacyPermissionApiConfig, LegacyPermissionId, LegacyPermissionPageEvent, LegacyPermissionPluginClass as LegacyPermissionPluginClassContract, LegacyPermissionPluginConfig, LegacyPermissionPluginOptions, LegacyPermissionRoute, LegacyPermissionSign } from './types';
+/**
+ * Vue 3-compatible implementation of the legacy permissionPluginClass API.
+ * It owns only page-event persistence and data projection; route registration
+ * and application authentication remain the responsibility of the host app.
+ */
+export declare class PermissionPluginClass implements LegacyPermissionPluginClassContract {
+    readonly ifSupportIndexDb: boolean;
+    readonly pluginCfg: LegacyPermissionPluginConfig;
+    readonly revision: import('vue').Ref<number, number>;
+    private readonly fetcher;
+    private readonly storage;
+    private readonly initialization;
+    constructor(options?: LegacyPermissionPluginOptions);
+    whenReady(): Promise<void>;
+    /** Legacy spelling retained for callers that invoked the old IndexedDB setup method. */
+    excuteDbLogic(): Promise<void>;
+    /** Legacy spelling retained for callers that invoked the old storage setup method. */
+    excuteLocalStorageLogic(): Promise<void>;
+    loopApiCfgListForGetData(): Promise<void>;
+    getDataFromApi(apiCfgItem: LegacyPermissionApiConfig): Promise<LegacyPermissionPageEvent[]>;
+    parseStorage(jsonString: string): unknown;
+    generateSaveToStorageDataAndSave(appChannelId: string, pageEventData: readonly LegacyPermissionPageEvent[]): Promise<void>;
+    getPageEventDataFromApiNew(): Promise<void>;
+    getPageEventDataFromApiSync(apiCfg: LegacyPermissionApiConfig): Promise<LegacyPermissionPageEvent[]>;
+    getData<T = unknown>(appChannelId: string | undefined, tableName: string, property?: string): Promise<T | []>;
+    setData(appChannelId: string | undefined, tableName: string, newData: unknown, property?: string): Promise<void>;
+    getPageEventDataFromDbOrLocal(appChannelId?: string): Promise<LegacyPermissionPageEvent[]>;
+    getHorizontalPageEventData(appChannelId?: string): Promise<LegacyPermissionPageEvent[]>;
+    setEventIdSync(appChannelId: string, newData: unknown): Promise<void>;
+    getNeedCacheRouter(appChannelId?: string): Promise<LegacyPermissionPageEvent[]>;
+    generateRouterNew(appChannelId?: string): Promise<LegacyPermissionRoute[]>;
+    generatePermissionMgTree(appChannelId?: string): Promise<LegacyPermissionPageEvent[]>;
+    generatePermissionMgTreeForShop(appChannelId?: string, _pageEventIdList?: readonly LegacyPermissionId[]): Promise<LegacyPermissionPageEvent[]>;
+    getApiEventList(appChannelId?: string, pageEventIdList?: readonly LegacyPermissionId[] | readonly LegacyPermissionPageEvent[]): Promise<string[]>;
+    getNoPmPageTree(appChannelId?: string): Promise<LegacyPermissionPageEvent[]>;
+    checkPermission(sign: LegacyPermissionSign): Promise<boolean>;
+    private initialize;
+    private bumpRevision;
+}

package/dist/business/permission/directive.d.ts

@@ -0,0 +1,7 @@
+import { ObjectDirective } from 'vue';
+import { LegacyPermissionPluginClass, LegacyPermissionSign } from './types';
+/**
+ * The old directive physically removed a denied element. Retaining that
+ * behavior avoids changing legacy templates that expect the node to disappear.
+ */
+export declare function createLegacyPermissionDirective(permissionPluginClass: LegacyPermissionPluginClass): ObjectDirective<HTMLElement, LegacyPermissionSign>;

package/dist/business/permission/index.d.ts

@@ -0,0 +1,35 @@
+import { App } from 'vue';
+import { LegacyPermissionApiConfig, LegacyPermissionExtraContent, LegacyPermissionId, LegacyPermissionPageEvent, LegacyPermissionPluginClass, LegacyPermissionPluginConfig, LegacyPermissionRoute, LegacyPermissionSign } from './types';
+export type PermissionId = LegacyPermissionId;
+export type PermissionSign = LegacyPermissionSign;
+export interface PermissionApiConfig extends LegacyPermissionApiConfig {
+}
+export interface PermissionExtraContent extends LegacyPermissionExtraContent {
+}
+export interface PermissionPageEvent extends LegacyPermissionPageEvent {
+}
+export interface PermissionRoute extends LegacyPermissionRoute {
+}
+export interface PermissionPluginConfig extends LegacyPermissionPluginConfig {
+}
+export interface PermissionPluginClass extends LegacyPermissionPluginClass {
+}
+export interface PermissionPluginOptions {
+    apiCfg?: PermissionApiConfig | readonly PermissionApiConfig[];
+    dbName?: string;
+    projectAppChannelId?: string;
+    updateStrategy?: {
+        development?: {
+            updateTime?: number | string;
+        };
+    };
+}
+export interface PermissionPluginClassConstructor {
+    new (options?: PermissionPluginOptions): PermissionPluginClass;
+}
+export interface PermissionPlugin {
+    install: (app: App, options?: PermissionPluginOptions) => void;
+    PermissionPluginClass: PermissionPluginClassConstructor;
+}
+declare const _default: PermissionPlugin;
+export default _default;

package/dist/business/permission/permission-plugin.d.ts

@@ -0,0 +1,16 @@
+import { App } from 'vue';
+import { Permission } from './Permission';
+import { PermissionPluginClass } from './PermissionPluginClass';
+import { LEGACY_PERMISSION_INJECTION_KEY, LegacyPermissionPlugin, LegacyPermissionPluginClass, LegacyPermissionPluginInstallOptions } from './types';
+type LegacyPermissionPluginWithClass = LegacyPermissionPlugin & {
+    PermissionPluginClass: typeof PermissionPluginClass;
+};
+type LegacyPermissionPluginFactoryResult = LegacyPermissionPluginWithClass & {
+    permissionPluginClass: LegacyPermissionPluginClass;
+};
+export declare function installLegacyPermission(app: App, options?: LegacyPermissionPluginInstallOptions): LegacyPermissionPluginClass;
+export declare function createLegacyPermissionPlugin(options?: LegacyPermissionPluginInstallOptions): LegacyPermissionPluginFactoryResult;
+declare const LegacyPermissionPlugin: LegacyPermissionPluginWithClass;
+export default LegacyPermissionPlugin;
+export { Permission, PermissionPluginClass, LEGACY_PERMISSION_INJECTION_KEY };
+export type { LegacyPermissionApiConfig, LegacyPermissionExtraContent, LegacyPermissionId, LegacyPermissionPageEvent, LegacyPermissionPlugin, LegacyPermissionPluginClass, LegacyPermissionPluginConfig, LegacyPermissionPluginInstallOptions, LegacyPermissionPluginOptions, LegacyPermissionRoute, LegacyPermissionSign } from './types';

package/dist/business/permission/storage.d.ts

@@ -0,0 +1,30 @@
+import { LegacyPermissionStorageLike } from './types';
+export type LegacyPermissionStoreName = 'cfg' | 'data';
+export interface LegacyStoredRecord {
+    appChannelId: string;
+    [key: string]: unknown;
+}
+/**
+ * Keeps the legacy cfg/data stores when IndexedDB works and falls back to the
+ * original permissionPluginData localStorage shape, then to in-memory storage
+ * for SSR or privacy-restricted browser contexts.
+ */
+export declare class LegacyPermissionStorage {
+    private readonly dbName;
+    private readonly memoryPayload;
+    private readonly storage;
+    private readonly indexedDb;
+    private readonly dbPromise;
+    constructor(dbName: string, options?: {
+        storage?: LegacyPermissionStorageLike | null;
+        indexedDB?: IDBFactory | null;
+    });
+    get supportsIndexedDb(): boolean;
+    ready(): Promise<void>;
+    read(storeName: LegacyPermissionStoreName, appChannelId: string): Promise<LegacyStoredRecord | null>;
+    write(storeName: LegacyPermissionStoreName, record: LegacyStoredRecord): Promise<void>;
+    private openDatabase;
+    private readFallback;
+    private writeFallback;
+    private getFallbackPayload;
+}

package/dist/business/permission/tree.d.ts

@@ -0,0 +1,19 @@
+import { LegacyPermissionId, LegacyPermissionPageEvent, LegacyPermissionRoute } from './types';
+export declare function normalizePermissionId(value: LegacyPermissionId | undefined): string;
+export declare function normalizePermissionIds(value: unknown): string[];
+export declare function isEnabled(value: unknown): boolean;
+export declare function isPermissionManaged(node: LegacyPermissionPageEvent): boolean;
+export declare function cloneLegacyPageEvent(node: LegacyPermissionPageEvent): LegacyPermissionPageEvent;
+export declare function sortLegacyNodes<T extends {
+    sort?: number | string;
+    createTime?: string;
+}>(nodes: T[]): T[];
+/** Matches the old flattening behavior without mutating its persisted source tree. */
+export declare function flattenLegacyPageEventData(tree: readonly LegacyPermissionPageEvent[]): LegacyPermissionPageEvent[];
+/** Derives the legacy route records but deliberately leaves router registration to the host. */
+export declare function generateLegacyRoutes(tree: readonly LegacyPermissionPageEvent[], eventIds: readonly string[]): LegacyPermissionRoute[];
+export declare function generatePermissionManagementTree(tree: readonly LegacyPermissionPageEvent[]): LegacyPermissionPageEvent[];
+export declare function generateShopPermissionManagementTree(tree: readonly LegacyPermissionPageEvent[]): LegacyPermissionPageEvent[];
+export declare function getUnmanagedPageTree(tree: readonly LegacyPermissionPageEvent[]): LegacyPermissionPageEvent[];
+export declare function getCacheableLegacyRoutes(tree: readonly LegacyPermissionPageEvent[]): LegacyPermissionPageEvent[];
+export declare function getApiEventIds(tree: readonly LegacyPermissionPageEvent[], pageEventIds: ReadonlySet<string>): string[];

package/dist/business/permission/types.d.ts

@@ -0,0 +1,115 @@
+import { App } from 'vue';
+export declare const LEGACY_PERMISSION_INJECTION_KEY = "permissionPluginClass";
+export type LegacyPermissionId = string | number;
+export type LegacyPermissionSign = LegacyPermissionId | readonly LegacyPermissionId[] | boolean | (() => boolean) | null | undefined;
+export interface LegacyPermissionApiConfig {
+    appChannelId: string;
+    dataChannelId: string;
+    prefixUrl: string;
+}
+export interface LegacyPermissionExtraContent {
+    assemblyAddress?: string;
+    assemblyName?: string;
+    eventNameList?: readonly string[];
+    isBigScreen?: boolean | number | string;
+    isCache?: boolean | number | string;
+    isPsMg?: boolean | number | string;
+    isRelateParent?: boolean | number | string;
+    isSingle?: boolean | number | string;
+    menuStatus?: boolean | number | string;
+    onlyShowPageContent?: boolean | number | string;
+    openNewTab?: boolean | number | string;
+    productId?: string;
+    productName?: string;
+    showSubmenu?: boolean | number | string;
+    [key: string]: unknown;
+}
+/** Legacy page-event records are intentionally open because deployed projects add fields. */
+export interface LegacyPermissionPageEvent {
+    appChannelId?: string;
+    children?: readonly LegacyPermissionPageEvent[];
+    createTime?: string;
+    eventIdList?: readonly LegacyPermissionId[];
+    extraContent?: LegacyPermissionExtraContent;
+    icon?: string;
+    isShow?: boolean | number | string;
+    pageId?: LegacyPermissionId;
+    pageName?: string;
+    parentId?: LegacyPermissionId;
+    routingAddress?: string;
+    sort?: number | string;
+    type?: number | string;
+    updateTime?: string;
+    parentIds?: readonly string[];
+    [key: string]: unknown;
+}
+export interface LegacyPermissionRoute {
+    path: string;
+    name: string;
+    component: string;
+    meta: {
+        title: string;
+        icon: string;
+    };
+    id: string;
+    createTime?: string;
+    eventIdList: readonly LegacyPermissionId[];
+    isShow?: boolean | number | string;
+    sort?: number | string;
+    type?: number | string;
+    updateTime?: string;
+    children: LegacyPermissionRoute[];
+    [key: string]: unknown;
+}
+export interface LegacyPermissionStorageLike {
+    getItem: (key: string) => string | null;
+    setItem: (key: string, value: string) => void;
+    removeItem?: (key: string) => void;
+}
+export type LegacyPermissionFetch = (input: RequestInfo | URL, init?: RequestInit) => Promise<Response>;
+export interface LegacyPermissionPluginConfig {
+    apiCfg: readonly LegacyPermissionApiConfig[];
+    dbName: string;
+    projectAppChannelId: string;
+}
+export interface LegacyPermissionPluginOptions {
+    apiCfg?: LegacyPermissionApiConfig | readonly LegacyPermissionApiConfig[];
+    dbName?: string;
+    projectAppChannelId?: string;
+    /** Optional request implementation; defaults to browser fetch when available. */
+    fetcher?: LegacyPermissionFetch;
+    /** Optional localStorage replacement for tests, SSR adapters, or private storage. */
+    storage?: LegacyPermissionStorageLike | null;
+    /** Optional IndexedDB factory replacement. Pass null to force the storage fallback. */
+    indexedDB?: IDBFactory | null;
+    /** Defaults to true to match the old plugin's constructor-time synchronization. */
+    autoSync?: boolean;
+}
+export interface LegacyPermissionPluginInstallOptions extends LegacyPermissionPluginOptions {
+    permissionPluginClass?: LegacyPermissionPluginClass;
+}
+export interface LegacyPermissionPluginClass {
+    readonly ifSupportIndexDb: boolean;
+    readonly pluginCfg: LegacyPermissionPluginConfig;
+    readonly revision: Readonly<{
+        value: number;
+    }>;
+    getPageEventDataFromDbOrLocal: (appChannelId?: string) => Promise<LegacyPermissionPageEvent[]>;
+    getHorizontalPageEventData: (appChannelId?: string) => Promise<LegacyPermissionPageEvent[]>;
+    setEventIdSync: (appChannelId: string, newData: unknown) => Promise<void>;
+    getNeedCacheRouter: (appChannelId?: string) => Promise<LegacyPermissionPageEvent[]>;
+    generateRouterNew: (appChannelId: string) => Promise<LegacyPermissionRoute[]>;
+    generatePermissionMgTree: (appChannelId: string) => Promise<LegacyPermissionPageEvent[]>;
+    generatePermissionMgTreeForShop: (appChannelId: string, pageEventIdList?: readonly LegacyPermissionId[]) => Promise<LegacyPermissionPageEvent[]>;
+    getApiEventList: (appChannelId: string, pageEventIdList?: readonly LegacyPermissionId[] | readonly LegacyPermissionPageEvent[]) => Promise<string[]>;
+    getNoPmPageTree: (appChannelId?: string) => Promise<LegacyPermissionPageEvent[]>;
+    checkPermission: (sign: LegacyPermissionSign) => Promise<boolean>;
+}
+export interface LegacyPermissionPlugin {
+    install: (app: App, options?: LegacyPermissionPluginInstallOptions) => void;
+}
+declare module 'vue' {
+    interface ComponentCustomProperties {
+        permissionPluginClass: LegacyPermissionPluginClass;
+    }
+}

package/dist/business/upload-cos/index.d.ts

@@ -0,0 +1,117 @@
+export declare const UploadCos: import('../../utils').SFCWithInstall<{
+    new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('.').UploadCosProps> & Readonly<{
+        onUploadfiles?: ((file: import('.').UploadCosFile) => any) | undefined;
+        onErrorUpLoad?: ((error: unknown, response?: unknown) => any) | undefined;
+        onOverLimitTips?: (() => any) | undefined;
+        "onUpdate:overLoaderList"?: ((files: import('.').UploadCosFile[]) => any) | undefined;
+        "onUpload-progress"?: ((file: File, percent: number) => any) | undefined;
+    }>, {
+        triggerUpload: () => void;
+        handleSingleFileUpload: (file: File, credential?: import('.').UploadCosCredential) => Promise<import('.').UploadCosFile>;
+        uploadDefault: (file: File) => Promise<import('.').UploadCosFile>;
+        formatFileSize: (sizeInBytes: number) => string;
+    }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+        uploadfiles: (file: import('.').UploadCosFile) => any;
+        errorUpLoad: (error: unknown, response?: unknown) => any;
+        overLimitTips: () => any;
+        "update:overLoaderList": (files: import('.').UploadCosFile[]) => any;
+        "upload-progress": (file: File, percent: number) => any;
+    }, import('vue').PublicProps, {
+        appChanneId: string;
+        multiple: boolean;
+        accept: string;
+        baseUrl: string;
+        limit: number;
+        overLoaderList: readonly import('.').UploadCosFile[];
+        fileType: string;
+        appName: string;
+        isUseCos: boolean;
+        defaultUploadConfig: import('.').UploadCosDefaultUploadConfig;
+    }, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {
+        fileInput: HTMLInputElement;
+    }, HTMLDivElement, import('vue').ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<import('.').UploadCosProps> & Readonly<{
+        onUploadfiles?: ((file: import('.').UploadCosFile) => any) | undefined;
+        onErrorUpLoad?: ((error: unknown, response?: unknown) => any) | undefined;
+        onOverLimitTips?: (() => any) | undefined;
+        "onUpdate:overLoaderList"?: ((files: import('.').UploadCosFile[]) => any) | undefined;
+        "onUpload-progress"?: ((file: File, percent: number) => any) | undefined;
+    }>, {
+        triggerUpload: () => void;
+        handleSingleFileUpload: (file: File, credential?: import('.').UploadCosCredential) => Promise<import('.').UploadCosFile>;
+        uploadDefault: (file: File) => Promise<import('.').UploadCosFile>;
+        formatFileSize: (sizeInBytes: number) => string;
+    }, {}, {}, {}, {
+        appChanneId: string;
+        multiple: boolean;
+        accept: string;
+        baseUrl: string;
+        limit: number;
+        overLoaderList: readonly import('.').UploadCosFile[];
+        fileType: string;
+        appName: string;
+        isUseCos: boolean;
+        defaultUploadConfig: import('.').UploadCosDefaultUploadConfig;
+    }>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import('vue').ComponentOptionsBase<Readonly<import('.').UploadCosProps> & Readonly<{
+    onUploadfiles?: ((file: import('.').UploadCosFile) => any) | undefined;
+    onErrorUpLoad?: ((error: unknown, response?: unknown) => any) | undefined;
+    onOverLimitTips?: (() => any) | undefined;
+    "onUpdate:overLoaderList"?: ((files: import('.').UploadCosFile[]) => any) | undefined;
+    "onUpload-progress"?: ((file: File, percent: number) => any) | undefined;
+}>, {
+    triggerUpload: () => void;
+    handleSingleFileUpload: (file: File, credential?: import('.').UploadCosCredential) => Promise<import('.').UploadCosFile>;
+    uploadDefault: (file: File) => Promise<import('.').UploadCosFile>;
+    formatFileSize: (sizeInBytes: number) => string;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    uploadfiles: (file: import('.').UploadCosFile) => any;
+    errorUpLoad: (error: unknown, response?: unknown) => any;
+    overLimitTips: () => any;
+    "update:overLoaderList": (files: import('.').UploadCosFile[]) => any;
+    "upload-progress": (file: File, percent: number) => any;
+}, string, {
+    appChanneId: string;
+    multiple: boolean;
+    accept: string;
+    baseUrl: string;
+    limit: number;
+    overLoaderList: readonly import('.').UploadCosFile[];
+    fileType: string;
+    appName: string;
+    isUseCos: boolean;
+    defaultUploadConfig: import('.').UploadCosDefaultUploadConfig;
+}, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
+    $slots: {
+        'upload-button'?(_: {
+            triggerUpload: () => void;
+            isUploading: boolean;
+        }): any;
+        'file-list'?(_: {
+            uploadedFiles: {
+                [x: string]: unknown;
+                name?: string | undefined;
+                origin_name?: string | undefined;
+                url?: string | undefined;
+                size?: number | undefined;
+                width?: number | undefined;
+                height?: number | undefined;
+                ext?: string | undefined;
+                path?: string | undefined;
+            }[];
+            openFile: (file: import('.').UploadCosFile) => void;
+            progressMap: Record<string, number>;
+        }): any;
+    };
+})>;
+export default UploadCos;
+export type { UploadCosCredential, UploadCosDefaultUploadConfig, UploadCosEmits, UploadCosExposed, UploadCosFile, UploadCosFileListSlotProps, UploadCosImageDimensions, UploadCosProgressReporter, UploadCosProps, UploadCosUploadButtonSlotProps } from './src/types';