yahee-components 0.0.18 → 0.0.19

package/types/src/left-condition/left-condition.vue.d.ts

@@ -0,0 +1,68 @@
+import { Option } from '../static/CommonObject';
+import { DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+declare function clickAllSelected(): void;
+declare const _default: DefineComponent<{
+    multiSelectList?: Array<any>;
+    selectList: Array<Option>;
+    countList?: Array<any>;
+    totalCount?: number;
+    hasNum?: boolean;
+    displayRangeInput?: boolean;
+    rangeLabel?: string;
+    rangeStartKey?: string;
+    rangeEndKey?: string;
+    rangeDelimiter?: string;
+    allIsCheckbox?: boolean;
+    allIsEmpty?: boolean;
+    translateUserId?: boolean;
+    staticSearch?: boolean;
+    label?: string;
+    noNeedRefreshNumFilterName?: string;
+    filterKey: string;
+    defaultValues?: Array<string | number | boolean>;
+}, {
+    clickAllSelected: typeof clickAllSelected;
+}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+    filterChange: (...args: any[]) => void;
+    setNoNeedRefreshNumFilterName: (...args: any[]) => void;
+}, string, PublicProps, Readonly<{
+    multiSelectList?: Array<any>;
+    selectList: Array<Option>;
+    countList?: Array<any>;
+    totalCount?: number;
+    hasNum?: boolean;
+    displayRangeInput?: boolean;
+    rangeLabel?: string;
+    rangeStartKey?: string;
+    rangeEndKey?: string;
+    rangeDelimiter?: string;
+    allIsCheckbox?: boolean;
+    allIsEmpty?: boolean;
+    translateUserId?: boolean;
+    staticSearch?: boolean;
+    label?: string;
+    noNeedRefreshNumFilterName?: string;
+    filterKey: string;
+    defaultValues?: Array<string | number | boolean>;
+}> & Readonly<{
+    onFilterChange?: (...args: any[]) => any;
+    onSetNoNeedRefreshNumFilterName?: (...args: any[]) => any;
+}>, {
+    label: string;
+    filterKey: string;
+    multiSelectList: Array<any>;
+    countList: Array<any>;
+    hasNum: boolean;
+    selectList: Array<Option>;
+    totalCount: number;
+    displayRangeInput: boolean;
+    rangeLabel: string;
+    rangeStartKey: string;
+    rangeEndKey: string;
+    rangeDelimiter: string;
+    allIsEmpty: boolean;
+    staticSearch: boolean;
+    noNeedRefreshNumFilterName: string;
+    defaultValues: Array<string | number | boolean>;
+}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
+export default _default;

package/types/src/left-condition-enum/index.d.ts

@@ -0,0 +1,162 @@
+import { SFCWithInstall } from '../utils/typescript';
+import { DefineComponent, ExtractPropTypes, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+import { Option } from '../static/CommonObject';
+export declare const YaheeLeftConditionEnum: SFCWithInstall<DefineComponent<ExtractPropTypes<{
+    selectList: {
+        type: {
+            (arrayLength: number): Option[];
+            (...items: Option[]): Option[];
+            new (arrayLength: number): Option[];
+            new (...items: Option[]): Option[];
+            isArray(arg: any): arg is any[];
+            readonly prototype: any[];
+            from<T>(arrayLike: ArrayLike<T>): T[];
+            from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+            from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+            from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+            of<T>(...items: T[]): T[];
+            fromAsync<T>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T | PromiseLike<T>> | ArrayLike<T | PromiseLike<T>>): Promise<T[]>;
+            fromAsync<T, U>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T> | ArrayLike<T>, mapFn: (value: Awaited<T>) => U, thisArg?: any): Promise<Awaited<U>[]>;
+            readonly [Symbol.species]: ArrayConstructor;
+        };
+        default: () => Option[];
+    };
+    baseUrl: {
+        type: StringConstructor;
+        default: string;
+    };
+    countList: {
+        type: {
+            (arrayLength: number): any[];
+            (...items: any[]): any[];
+            new (arrayLength: number): any[];
+            new (...items: any[]): any[];
+            isArray(arg: any): arg is any[];
+            readonly prototype: any[];
+            from<T>(arrayLike: ArrayLike<T>): T[];
+            from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+            from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+            from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+            of<T>(...items: T[]): T[];
+            fromAsync<T>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T | PromiseLike<T>> | ArrayLike<T | PromiseLike<T>>): Promise<T[]>;
+            fromAsync<T, U>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T> | ArrayLike<T>, mapFn: (value: Awaited<T>) => U, thisArg?: any): Promise<Awaited<U>[]>;
+            readonly [Symbol.species]: ArrayConstructor;
+        };
+        required: false;
+    };
+    enumEntity: {
+        type: StringConstructor;
+        default: string;
+    };
+    filterKey: {
+        type: StringConstructor;
+        default: string;
+    };
+    totalCount: {
+        type: NumberConstructor;
+        required: false;
+    };
+    noNeedRefreshNumFilterName: {
+        type: StringConstructor;
+        required: false;
+    };
+    allIsCheckbox: {
+        type: BooleanConstructor;
+        required: false;
+    };
+    allIsEmpty: {
+        type: BooleanConstructor;
+        required: false;
+    };
+    translateUserId: {
+        type: BooleanConstructor;
+        required: false;
+    };
+}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+    filterChange: (...args: any[]) => void;
+    setNoNeedRefreshNumFilterName: (...args: any[]) => void;
+}, string, PublicProps, Readonly< ExtractPropTypes<{
+    selectList: {
+        type: {
+            (arrayLength: number): Option[];
+            (...items: Option[]): Option[];
+            new (arrayLength: number): Option[];
+            new (...items: Option[]): Option[];
+            isArray(arg: any): arg is any[];
+            readonly prototype: any[];
+            from<T>(arrayLike: ArrayLike<T>): T[];
+            from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+            from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+            from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+            of<T>(...items: T[]): T[];
+            fromAsync<T>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T | PromiseLike<T>> | ArrayLike<T | PromiseLike<T>>): Promise<T[]>;
+            fromAsync<T, U>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T> | ArrayLike<T>, mapFn: (value: Awaited<T>) => U, thisArg?: any): Promise<Awaited<U>[]>;
+            readonly [Symbol.species]: ArrayConstructor;
+        };
+        default: () => Option[];
+    };
+    baseUrl: {
+        type: StringConstructor;
+        default: string;
+    };
+    countList: {
+        type: {
+            (arrayLength: number): any[];
+            (...items: any[]): any[];
+            new (arrayLength: number): any[];
+            new (...items: any[]): any[];
+            isArray(arg: any): arg is any[];
+            readonly prototype: any[];
+            from<T>(arrayLike: ArrayLike<T>): T[];
+            from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+            from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+            from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+            of<T>(...items: T[]): T[];
+            fromAsync<T>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T | PromiseLike<T>> | ArrayLike<T | PromiseLike<T>>): Promise<T[]>;
+            fromAsync<T, U>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T> | ArrayLike<T>, mapFn: (value: Awaited<T>) => U, thisArg?: any): Promise<Awaited<U>[]>;
+            readonly [Symbol.species]: ArrayConstructor;
+        };
+        required: false;
+    };
+    enumEntity: {
+        type: StringConstructor;
+        default: string;
+    };
+    filterKey: {
+        type: StringConstructor;
+        default: string;
+    };
+    totalCount: {
+        type: NumberConstructor;
+        required: false;
+    };
+    noNeedRefreshNumFilterName: {
+        type: StringConstructor;
+        required: false;
+    };
+    allIsCheckbox: {
+        type: BooleanConstructor;
+        required: false;
+    };
+    allIsEmpty: {
+        type: BooleanConstructor;
+        required: false;
+    };
+    translateUserId: {
+        type: BooleanConstructor;
+        required: false;
+    };
+}>> & Readonly<{
+    onFilterChange?: (...args: any[]) => any;
+    onSetNoNeedRefreshNumFilterName?: (...args: any[]) => any;
+}>, {
+    filterKey: string;
+    allIsCheckbox: boolean;
+    translateUserId: boolean;
+    selectList: Option[];
+    allIsEmpty: boolean;
+    baseUrl: string;
+    enumEntity: string;
+}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>> & Record<string, any>;
+export default YaheeLeftConditionEnum;
+export * from './left-condition-enum.vue';

package/types/src/left-condition-enum/left-condition-enum.d.ts

@@ -0,0 +1,5 @@
+export type SelectStatus = {
+    label: string;
+    value: any;
+    selected: boolean;
+};

package/types/src/left-condition-enum/left-condition-enum.vue.d.ts

@@ -0,0 +1,160 @@
+import { Option } from '../static/CommonObject';
+import { DefineComponent, ExtractPropTypes, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+declare const _default: DefineComponent<ExtractPropTypes<{
+    selectList: {
+        type: {
+            (arrayLength: number): Option[];
+            (...items: Option[]): Option[];
+            new (arrayLength: number): Option[];
+            new (...items: Option[]): Option[];
+            isArray(arg: any): arg is any[];
+            readonly prototype: any[];
+            from<T>(arrayLike: ArrayLike<T>): T[];
+            from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+            from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+            from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+            of<T>(...items: T[]): T[];
+            fromAsync<T>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T | PromiseLike<T>> | ArrayLike<T | PromiseLike<T>>): Promise<T[]>;
+            fromAsync<T, U>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T> | ArrayLike<T>, mapFn: (value: Awaited<T>) => U, thisArg?: any): Promise<Awaited<U>[]>;
+            readonly [Symbol.species]: ArrayConstructor;
+        };
+        default: () => Option[];
+    };
+    baseUrl: {
+        type: StringConstructor;
+        default: string;
+    };
+    countList: {
+        type: {
+            (arrayLength: number): any[];
+            (...items: any[]): any[];
+            new (arrayLength: number): any[];
+            new (...items: any[]): any[];
+            isArray(arg: any): arg is any[];
+            readonly prototype: any[];
+            from<T>(arrayLike: ArrayLike<T>): T[];
+            from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+            from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+            from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+            of<T>(...items: T[]): T[];
+            fromAsync<T>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T | PromiseLike<T>> | ArrayLike<T | PromiseLike<T>>): Promise<T[]>;
+            fromAsync<T, U>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T> | ArrayLike<T>, mapFn: (value: Awaited<T>) => U, thisArg?: any): Promise<Awaited<U>[]>;
+            readonly [Symbol.species]: ArrayConstructor;
+        };
+        required: false;
+    };
+    enumEntity: {
+        type: StringConstructor;
+        default: string;
+    };
+    filterKey: {
+        type: StringConstructor;
+        default: string;
+    };
+    totalCount: {
+        type: NumberConstructor;
+        required: false;
+    };
+    noNeedRefreshNumFilterName: {
+        type: StringConstructor;
+        required: false;
+    };
+    allIsCheckbox: {
+        type: BooleanConstructor;
+        required: false;
+    };
+    allIsEmpty: {
+        type: BooleanConstructor;
+        required: false;
+    };
+    translateUserId: {
+        type: BooleanConstructor;
+        required: false;
+    };
+}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+    filterChange: (...args: any[]) => void;
+    setNoNeedRefreshNumFilterName: (...args: any[]) => void;
+}, string, PublicProps, Readonly< ExtractPropTypes<{
+    selectList: {
+        type: {
+            (arrayLength: number): Option[];
+            (...items: Option[]): Option[];
+            new (arrayLength: number): Option[];
+            new (...items: Option[]): Option[];
+            isArray(arg: any): arg is any[];
+            readonly prototype: any[];
+            from<T>(arrayLike: ArrayLike<T>): T[];
+            from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+            from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+            from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+            of<T>(...items: T[]): T[];
+            fromAsync<T>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T | PromiseLike<T>> | ArrayLike<T | PromiseLike<T>>): Promise<T[]>;
+            fromAsync<T, U>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T> | ArrayLike<T>, mapFn: (value: Awaited<T>) => U, thisArg?: any): Promise<Awaited<U>[]>;
+            readonly [Symbol.species]: ArrayConstructor;
+        };
+        default: () => Option[];
+    };
+    baseUrl: {
+        type: StringConstructor;
+        default: string;
+    };
+    countList: {
+        type: {
+            (arrayLength: number): any[];
+            (...items: any[]): any[];
+            new (arrayLength: number): any[];
+            new (...items: any[]): any[];
+            isArray(arg: any): arg is any[];
+            readonly prototype: any[];
+            from<T>(arrayLike: ArrayLike<T>): T[];
+            from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+            from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+            from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+            of<T>(...items: T[]): T[];
+            fromAsync<T>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T | PromiseLike<T>> | ArrayLike<T | PromiseLike<T>>): Promise<T[]>;
+            fromAsync<T, U>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T> | ArrayLike<T>, mapFn: (value: Awaited<T>) => U, thisArg?: any): Promise<Awaited<U>[]>;
+            readonly [Symbol.species]: ArrayConstructor;
+        };
+        required: false;
+    };
+    enumEntity: {
+        type: StringConstructor;
+        default: string;
+    };
+    filterKey: {
+        type: StringConstructor;
+        default: string;
+    };
+    totalCount: {
+        type: NumberConstructor;
+        required: false;
+    };
+    noNeedRefreshNumFilterName: {
+        type: StringConstructor;
+        required: false;
+    };
+    allIsCheckbox: {
+        type: BooleanConstructor;
+        required: false;
+    };
+    allIsEmpty: {
+        type: BooleanConstructor;
+        required: false;
+    };
+    translateUserId: {
+        type: BooleanConstructor;
+        required: false;
+    };
+}>> & Readonly<{
+    onFilterChange?: (...args: any[]) => any;
+    onSetNoNeedRefreshNumFilterName?: (...args: any[]) => any;
+}>, {
+    filterKey: string;
+    allIsCheckbox: boolean;
+    translateUserId: boolean;
+    selectList: Option[];
+    allIsEmpty: boolean;
+    baseUrl: string;
+    enumEntity: string;
+}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
+export default _default;

package/types/src/operation-log/index.d.ts

@@ -0,0 +1,9 @@
+import { SFCWithInstall } from '../utils/typescript';
+import { DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+import { OperationLogProps } from './operation-log';
+export declare const YaheeOperationLog: SFCWithInstall<DefineComponent<OperationLogProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly< OperationLogProps> & Readonly<{}>, {
+    projectId: string;
+}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>> & Record<string, any>;
+export default YaheeOperationLog;
+export * from './operation-log.vue';
+export * from './operation-log';

package/types/src/operation-log/operation-log-content.vue.d.ts

@@ -0,0 +1,24 @@
+import { DefineComponent, ExtractPropTypes, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+declare const _default: DefineComponent<ExtractPropTypes<{
+    info: {
+        type: ObjectConstructor;
+        default: () => void;
+    };
+    id: {
+        type: NumberConstructor;
+        default: number;
+    };
+}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly< ExtractPropTypes<{
+    info: {
+        type: ObjectConstructor;
+        default: () => void;
+    };
+    id: {
+        type: NumberConstructor;
+        default: number;
+    };
+}>> & Readonly<{}>, {
+    id: number;
+    info: Record<string, any>;
+}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
+export default _default;

package/types/src/operation-log/operation-log-dialog.vue.d.ts

@@ -0,0 +1,39 @@
+import { PropType, DefineComponent, ExtractPropTypes, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+declare const _default: DefineComponent<ExtractPropTypes<{
+    modelValue: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    docInfo: {
+        type: PropType<{
+            fileUrl: string;
+            fileName: string;
+        }>;
+        default: () => void;
+    };
+}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+    "update:modelValue": (...args: any[]) => void;
+    confirmUpload: (...args: any[]) => void;
+}, string, PublicProps, Readonly< ExtractPropTypes<{
+    modelValue: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    docInfo: {
+        type: PropType<{
+            fileUrl: string;
+            fileName: string;
+        }>;
+        default: () => void;
+    };
+}>> & Readonly<{
+    "onUpdate:modelValue"?: (...args: any[]) => any;
+    onConfirmUpload?: (...args: any[]) => any;
+}>, {
+    modelValue: boolean;
+    docInfo: {
+        fileUrl: string;
+        fileName: string;
+    };
+}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
+export default _default;

package/types/src/operation-log/operation-log-form.vue.d.ts

@@ -0,0 +1,19 @@
+import { DefineComponent, ExtractPropTypes, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+declare const _default: DefineComponent<ExtractPropTypes<{
+    projectId: {
+        type: StringConstructor;
+        default: string;
+    };
+}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+    filterChange: (...args: any[]) => void;
+}, string, PublicProps, Readonly< ExtractPropTypes<{
+    projectId: {
+        type: StringConstructor;
+        default: string;
+    };
+}>> & Readonly<{
+    onFilterChange?: (...args: any[]) => any;
+}>, {
+    projectId: string;
+}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
+export default _default;

package/types/src/operation-log/operation-log.d.ts

@@ -0,0 +1,11 @@
+import { default as OperationLog } from './operation-log.vue';
+/**
+ * 定义props类型
+ */
+export interface OperationLogProps {
+    projectId: string;
+}
+/**
+ * 定义instance类型
+ */
+export type OperationLogInstance = InstanceType<typeof OperationLog>;

package/types/src/operation-log/operation-log.vue.d.ts

@@ -0,0 +1,6 @@
+import { OperationLogProps } from './operation-log';
+import { DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+declare const _default: DefineComponent<OperationLogProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<OperationLogProps> & Readonly<{}>, {
+    projectId: string;
+}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
+export default _default;

package/types/src/static/CommonObject.d.ts

@@ -0,0 +1,18 @@
+export interface Option {
+    label: string;
+    value: string;
+}
+export interface RangeDate {
+    BeginTime: string;
+    EndTime: string;
+}
+export declare enum DateTimeType {
+    Month = "M",
+    Day = "d",
+    Hour = "h",
+    Minute = "m"
+}
+export declare enum i18nType {
+    EN = "en",
+    CN = "zh-CN"
+}

package/types/src/static/CommonVariables.d.ts

@@ -0,0 +1,4 @@
+export declare const defaultDateTimeFormat = "yyyy-MM-dd HH:mm:ss";
+export declare const defaultDatePickerTimeFormat = "YYYY-MM-DD HH:mm:ss";
+export declare const datePickerHourFormat = "YYYY-MM-DD HH:mm";
+export declare const defaultDateFormat = "yyyy-MM-dd";

package/types/src/utils/config.d.ts

@@ -0,0 +1,8 @@
+interface globalConfigType {
+    apiEnv: string;
+}
+export declare function config(): {
+    setConfig: (userConfig: any) => void;
+    globalConfig: globalConfigType;
+};
+export {};

package/types/src/utils/const.d.ts

@@ -0,0 +1,19 @@
+/**
+ * TODO:添加权限文档地址
+ */
+export declare enum PERMISSIONS_CODE {
+    SaveAutoTransfer = "Yahee.ERP.TOOL.TransferManage.SaveAutoTransfer",// 产品开发-分配认证负责人权限
+    SaveAutoTransferFlag = "Yahee.ERP.TOOL.TransferManage.SaveAutoTransferFlag"
+}
+export declare const apiUrl: {
+    development: {
+        VITE_APP_API_BASEURL: string;
+        VITE_APP_API_TOOLS: string;
+        VITE_APP_API_REMARK: string;
+    };
+    production: {
+        VITE_APP_API_BASEURL: string;
+        VITE_APP_API_TOOLS: string;
+        VITE_APP_API_REMARK: string;
+    };
+};

package/types/src/utils/functions.d.ts

@@ -0,0 +1 @@
+export { NOOP, toRawType } from '@vue/shared';

package/types/src/utils/install.d.ts

@@ -0,0 +1,8 @@
+import { App, Directive, Plugin } from 'vue';
+import { SFCInstallWithContext, SFCWithInstall } from './typescript';
+export declare const withInstall: <T, E extends Record<string, any>>(main: T, extra?: E) => SFCWithInstall<T> & E;
+export declare const withInstallFunction: <T>(fn: T, name: string) => SFCInstallWithContext<T>;
+export declare const withInstallDirective: <T extends Directive>(directive: T, name: string) => SFCWithInstall<T>;
+export declare const makeInstaller: (components?: Plugin[]) => {
+    install: (app: App) => void;
+};

package/types/src/utils/storage.d.ts

@@ -0,0 +1,18 @@
+/**
+ * 封装操作localstorage本地存储的方法
+ */
+export declare const storage: {
+    set(key: string, value: any): void;
+    get<T>(key: string): T;
+    remove(key: string): void;
+    setWithExpireTime(key: string, value: any, expireTime: number): void;
+    getWithExpireTime<T>(key: string): T;
+};
+/**
+ * 封装操作sessionStorage本地存储的方法
+ */
+export declare const sessionStorageProxy: {
+    set(key: string, value: any): void;
+    get<T>(key: string): T;
+    remove(key: string): void;
+};

package/types/src/utils/style.d.ts

@@ -0,0 +1,19 @@
+declare function getBackgroundColor(value: boolean): {
+    backgroundColor: string;
+    color: string;
+    borderColor: string;
+} | {
+    backgroundColor?: undefined;
+    color?: undefined;
+    borderColor?: undefined;
+};
+declare function getPriorityColor(priority: string): {
+    backgroundColor: string;
+    color: string;
+    borderColor: string;
+};
+export declare const stylesUtils: {
+    getBackgroundColor: typeof getBackgroundColor;
+    getPriorityColor: typeof getPriorityColor;
+};
+export {};

package/types/src/utils/to-kebab-case.d.ts

@@ -0,0 +1 @@
+export declare function toKebabCase(str: string): string;

package/types/src/utils/translate.d.ts

@@ -0,0 +1,5 @@
+export declare const M2: (str: string) => string;
+export declare const getAllTranslate: () => Promise<void>;
+export declare function translateEmployeeName(employeeId: string, name?: string): string;
+export declare const initTranslate: () => Promise<void>;
+export declare const isNeedTranslate: () => boolean;

package/types/src/utils/typescript.d.ts

@@ -0,0 +1,5 @@
+import { AppContext, Plugin } from 'vue';
+export type SFCWithInstall<T> = T & Plugin;
+export type SFCInstallWithContext<T> = SFCWithInstall<T> & {
+    _context: AppContext | null;
+};

package/es/hooks/useClipboard.js

@@ -1,28 +0,0 @@
-import { ref as s, unref as u } from "vue";
-function f(c = {}) {
-  const n = s(!1), { navigator: t = window.navigator, source: r, copiedDuring: a = 1500 } = c, i = !!(t && "clipboard" in t);
-  async function l(e = u(r)) {
-    if (e != null) {
-      if (i)
-        await t.clipboard.writeText(e);
-      else
-        return;
-      n.value = !0, setTimeout(() => {
-        n.value = !1;
-      }, a);
-    }
-  }
-  function p(e = u(r)) {
-    let d = e, o = document.createElement("input");
-    o.value = d, document.body.appendChild(o), o.select(), document.execCommand("Copy"), o.remove();
-  }
-  return {
-    isSupported: i,
-    copied: n,
-    copy: l,
-    copyUrl: p
-  };
-}
-export {
-  f as useClipboard
-};

package/lib/_virtual/_commonjsHelpers.js

@@ -1 +0,0 @@
-"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});var o=typeof globalThis<"u"?globalThis:typeof window<"u"?window:typeof global<"u"?global:typeof self<"u"?self:{};function l(e){return e&&e.__esModule&&Object.prototype.hasOwnProperty.call(e,"default")?e.default:e}exports.commonjsGlobal=o;exports.getDefaultExportFromCjs=l;