@kengic/vue 0.30.1-beta.82 → 0.30.1-beta.85

package/project/src/utils/is.ts

@@ -0,0 +1,85 @@
+const toString = Object.prototype.toString;
+
+export function is(val: unknown, type: string) {
+    return toString.call(val) === `[object ${type}]`;
+}
+
+export function isDef<T = unknown>(val?: T): val is T {
+    return typeof val !== 'undefined';
+}
+
+export function isUnDef<T = unknown>(val?: T): val is T {
+    return !isDef(val);
+}
+
+export function isObject(val: any): val is Record<any, any> {
+    return val !== null && is(val, 'Object');
+}
+
+export function isEmpty<T = unknown>(val: T): val is T {
+    if (isArray(val) || isString(val)) {
+        return val.length === 0;
+    }
+
+    if (val instanceof Map || val instanceof Set) {
+        return val.size === 0;
+    }
+
+    if (isObject(val)) {
+        return Object.keys(val).length === 0;
+    }
+
+    return false;
+}
+
+export function isNull(val: unknown): val is null {
+    return val === null;
+}
+
+export function isNullAndUnDef(val: unknown): val is null | undefined {
+    return isUnDef(val) && isNull(val);
+}
+
+export function isNullOrUnDef(val: unknown): val is null | undefined {
+    return isUnDef(val) || isNull(val);
+}
+
+export function isNumber(val: unknown): val is number {
+    return is(val, 'Number');
+}
+
+export function isPromise<T = any>(val: any): val is Promise<T> {
+    return is(val, 'Promise') && isFunction(val.then) && isFunction(val.catch);
+}
+
+export function isString(val: unknown): val is string {
+    return is(val, 'String');
+}
+
+export function isJsonObjectString(val: string): val is string {
+    if (!val) {
+        return false;
+    }
+    return val.startsWith('{') && val.endsWith('}');
+}
+
+export function isFunction(val: unknown): val is Function {
+    return typeof val === 'function';
+}
+
+export function isBoolean(val: unknown): val is boolean {
+    return is(val, 'Boolean');
+}
+
+export function isArray(val: any): val is Array<any> {
+    return val && Array.isArray(val);
+}
+
+export function isMap(val: unknown): val is Map<any, any> {
+    return is(val, 'Map');
+}
+
+export function isUrl(path: string): boolean {
+    const reg = /(((^https?:(?:\/\/)?)(?:[-;:&=\+\$,\w]+@)?[A-Za-z0-9.-]+(?::\d+)?|(?:www.|[-;:&=\+\$,\w]+@)[A-Za-z0-9.-]+)((?:\/[\+~%\/.\w-_]*)?\??(?:[-\+=&;%@.\w_]*)#?(?:[\w]*))?)$/;
+    return reg.test(path);
+}

package/project/src/utils/mitt.ts

@@ -0,0 +1,101 @@
+/**
+ * copy to https://github.com/developit/mitt
+ * Expand clear method
+ */
+
+export type EventType = string | symbol;
+
+// An event handler can take an optional event argument
+// and should not return a value
+export type Handler<T = any> = (event?: T) => void;
+export type WildcardHandler = (type: EventType, event?: any) => void;
+
+// An array of all currently registered event handlers for a type
+export type EventHandlerList = Array<Handler>;
+export type WildCardEventHandlerList = Array<WildcardHandler>;
+
+// A map of event types and their corresponding event handlers.
+export type EventHandlerMap = Map<EventType, EventHandlerList | WildCardEventHandlerList>;
+
+export interface Emitter {
+    all: EventHandlerMap;
+
+    on<T = any>(type: EventType, handler: Handler<T>): void;
+    on(type: '*', handler: WildcardHandler): void;
+
+    off<T = any>(type: EventType, handler: Handler<T>): void;
+    off(type: '*', handler: WildcardHandler): void;
+
+    emit<T = any>(type: EventType, event?: T): void;
+    emit(type: '*', event?: any): void;
+    clear(): void;
+}
+
+/**
+ * Mitt: Tiny (~200b) functional event emitter / pubsub.
+ * @name mitt
+ * @returns {Mitt}
+ */
+export function mitt(all?: EventHandlerMap): Emitter {
+    all = all || new Map();
+
+    return {
+        /**
+         * A Map of event names to registered handler functions.
+         */
+        all,
+
+        /**
+         * Register an event handler for the given type.
+         * @param {string|symbol} type Type of event to listen for, or `"*"` for all events
+         * @param {Function} handler Function to call in response to given event
+         * @memberOf mitt
+         */
+        on<T = any>(type: EventType, handler: Handler<T>) {
+            const handlers = all?.get(type);
+            const added = handlers && handlers.push(handler);
+            if (!added) {
+                all?.set(type, [handler]);
+            }
+        },
+
+        /**
+         * Remove an event handler for the given type.
+         * @param {string|symbol} type Type of event to unregister `handler` from, or `"*"`
+         * @param {Function} handler Handler function to remove
+         * @memberOf mitt
+         */
+        off<T = any>(type: EventType, handler: Handler<T>) {
+            const handlers = all?.get(type);
+            if (handlers) {
+                handlers.splice(handlers.indexOf(handler) >>> 0, 1);
+            }
+        },
+
+        /**
+         * Invoke all handlers for the given type.
+         * If present, `"*"` handlers are invoked after type-matched handlers.
+         *
+         * Note: Manually firing "*" handlers is not supported.
+         *
+         * @param {string|symbol} type The event type to invoke
+         * @param {Any} [evt] Any value (object is recommended and powerful), passed to each handler
+         * @memberOf mitt
+         */
+        emit<T = any>(type: EventType, evt: T) {
+            ((all?.get(type) || []) as EventHandlerList).slice().map((handler) => {
+                handler(evt);
+            });
+            ((all?.get('*') || []) as WildCardEventHandlerList).slice().map((handler) => {
+                handler(type, evt);
+            });
+        },
+
+        /**
+         * Clear all
+         */
+        clear() {
+            this.all.clear();
+        },
+    };
+}

package/project/src/utils/propTypes.ts

@@ -0,0 +1,34 @@
+import { CSSProperties, VNodeChild } from 'vue';
+import { createTypes, VueTypesInterface, VueTypeValidableDef } from 'vue-types';
+
+export type VueNode = VNodeChild | JSX.Element;
+
+type PropTypes = VueTypesInterface & {
+    readonly style: VueTypeValidableDef<CSSProperties>;
+    readonly VNodeChild: VueTypeValidableDef<VueNode>;
+};
+
+const propTypes = createTypes({
+    func: undefined,
+    bool: undefined,
+    string: undefined,
+    number: undefined,
+    object: undefined,
+    integer: undefined,
+}) as PropTypes;
+
+propTypes.extend([
+    {
+        name: 'style',
+        getter: true,
+        type: [String, Object],
+        default: undefined,
+    },
+    {
+        name: 'VNodeChild',
+        getter: true,
+        type: undefined,
+    },
+]);
+
+export { propTypes };

package/project/src/utils/props.ts

@@ -0,0 +1,139 @@
+// copy from element-plus
+
+import { fromPairs } from 'lodash-es';
+import { ExtractPropTypes, PropType, warn } from 'vue';
+import { isObject } from './is';
+
+const wrapperKey = Symbol();
+export type PropWrapper<T> = { [wrapperKey]: T };
+
+export const propKey = Symbol();
+
+type ResolveProp<T> = ExtractPropTypes<{
+    key: { type: T; required: true };
+}>['key'];
+type ResolvePropType<T> = ResolveProp<T> extends { type: infer V } ? V : ResolveProp<T>;
+type ResolvePropTypeWithReadonly<T> = Readonly<T> extends Readonly<Array<infer A>> ? ResolvePropType<A[]> : ResolvePropType<T>;
+
+type IfUnknown<T, V> = [unknown] extends [T] ? V : T;
+
+export type BuildPropOption<T, D extends BuildPropType<T, V, C>, R, V, C> = {
+    type?: T;
+    values?: readonly V[];
+    required?: R;
+    default?: R extends true ? never : D extends Record<string, unknown> | Array<any> ? () => D : (() => D) | D;
+    validator?: ((val: any) => val is C) | ((val: any) => boolean);
+};
+
+type _BuildPropType<T, V, C> = (T extends PropWrapper<unknown> ? T[typeof wrapperKey] : [V] extends [never] ? ResolvePropTypeWithReadonly<T> : never) | V | C;
+export type BuildPropType<T, V, C> = _BuildPropType<IfUnknown<T, never>, IfUnknown<V, never>, IfUnknown<C, never>>;
+
+type _BuildPropDefault<T, D> = [T] extends [
+    // eslint-disable-next-line @typescript-eslint/ban-types
+    Record<string, unknown> | Array<any> | Function,
+]
+    ? D
+    : D extends () => T
+      ? ReturnType<D>
+      : D;
+
+export type BuildPropDefault<T, D, R> = R extends true
+    ? { readonly default?: undefined }
+    : {
+          readonly default: Exclude<D, undefined> extends never ? undefined : Exclude<_BuildPropDefault<T, D>, undefined>;
+      };
+export type BuildPropReturn<T, D, R, V, C> = {
+    readonly type: PropType<BuildPropType<T, V, C>>;
+    readonly required: IfUnknown<R, false>;
+    readonly validator: ((val: unknown) => boolean) | undefined;
+    [propKey]: true;
+} & BuildPropDefault<BuildPropType<T, V, C>, IfUnknown<D, never>, IfUnknown<R, false>>;
+
+/**
+ * @description Build prop. It can better optimize prop types
+ * @description 生成 prop，能更好地优化类型
+ * @example
+  // limited options
+  // the type will be PropType<'light' | 'dark'>
+  buildProp({
+    type: String,
+    values: ['light', 'dark'],
+  } as const)
+  * @example
+  // limited options and other types
+  // the type will be PropType<'small' | 'medium' | number>
+  buildProp({
+    type: [String, Number],
+    values: ['small', 'medium'],
+    validator: (val: unknown): val is number => typeof val === 'number',
+  } as const)
+  @link see more: https://github.com/element-plus/element-plus/pull/3341
+ */
+export function buildProp<T = never, D extends BuildPropType<T, V, C> = never, R extends boolean = false, V = never, C = never>(option: BuildPropOption<T, D, R, V, C>, key?: string): BuildPropReturn<T, D, R, V, C> {
+    // filter native prop type and nested prop, e.g `null`, `undefined` (from `buildProps`)
+    if (!isObject(option) || !!(option as any)[propKey as any]) return option as any;
+
+    const { values, required, default: defaultValue, type, validator } = option;
+
+    const _validator =
+        values || validator
+            ? (val: unknown) => {
+                  let valid = false;
+                  let allowedValues: unknown[] = [];
+
+                  if (values) {
+                      allowedValues = [...values, defaultValue];
+                      valid ||= allowedValues.includes(val);
+                  }
+                  if (validator) valid ||= validator(val);
+
+                  if (!valid && allowedValues.length > 0) {
+                      const allowValuesText = [...new Set(allowedValues)].map((value) => JSON.stringify(value)).join(', ');
+                      warn(`Invalid prop: validation failed${key ? ` for prop "${key}"` : ''}. Expected one of [${allowValuesText}], got value ${JSON.stringify(val)}.`);
+                  }
+                  return valid;
+              }
+            : undefined;
+
+    return {
+        type: typeof type === 'object' && Object.getOwnPropertySymbols(type).includes(wrapperKey) ? (type as any)?.[wrapperKey as any] : type,
+        required: !!required,
+        default: defaultValue,
+        validator: _validator,
+        [propKey]: true,
+    } as unknown as BuildPropReturn<T, D, R, V, C>;
+}
+
+type NativePropType = [((...args: any) => any) | { new (...args: any): any } | undefined | null];
+
+export const buildProps = <
+    O extends {
+        [K in keyof O]: O[K] extends BuildPropReturn<any, any, any, any, any>
+            ? O[K]
+            : [O[K]] extends NativePropType
+              ? O[K]
+              : O[K] extends BuildPropOption<infer T, infer D, infer R, infer V, infer C>
+                ? D extends BuildPropType<T, V, C>
+                    ? BuildPropOption<T, D, R, V, C>
+                    : never
+                : never;
+    },
+>(
+    props: O,
+) =>
+    fromPairs(Object.entries(props).map(([key, option]) => [key, buildProp(option as any, key)])) as unknown as {
+        [K in keyof O]: O[K] extends { [propKey]: boolean }
+            ? O[K]
+            : [O[K]] extends NativePropType
+              ? O[K]
+              : O[K] extends BuildPropOption<
+                      infer T,
+                      // eslint-disable-next-line @typescript-eslint/no-unused-vars
+                      infer _D,
+                      infer R,
+                      infer V,
+                      infer C
+                  >
+                ? BuildPropReturn<T, O[K]['default'], R, V, C>
+                : never;
+    };

package/project/src/utils/uuid.ts

@@ -0,0 +1,29 @@
+const hexList: string[] = [];
+
+for (let i = 0; i <= 15; i++) {
+    hexList[i] = i.toString(16);
+}
+
+export function buildUUID(): string {
+    let uuid = '';
+    for (let i = 1; i <= 36; i++) {
+        if (i === 9 || i === 14 || i === 19 || i === 24) {
+            uuid += '-';
+        } else if (i === 15) {
+            uuid += 4;
+        } else if (i === 20) {
+            uuid += hexList[(Math.random() * 4) | 8];
+        } else {
+            uuid += hexList[(Math.random() * 16) | 0];
+        }
+    }
+    return uuid.replace(/-/g, '');
+}
+
+let unique = 0;
+export function buildShortUUID(prefix = ''): string {
+    const time = Date.now();
+    const random = Math.floor(Math.random() * 1000000000);
+    unique++;
+    return prefix + '_' + random + unique + String(time);
+}

package/project/types/axios.ts

@@ -0,0 +1,57 @@
+export type ErrorMessageMode = 'none' | 'modal' | 'message' | undefined;
+export type SuccessMessageMode = 'none' | 'success' | 'error' | undefined;
+
+export interface RequestOptions {
+    // 将请求参数拼接到url
+    joinParamsToUrl?: boolean;
+    // 格式化请求参数时间
+    formatDate?: boolean;
+    // 是否处理请求结果
+    isTransformResponse?: boolean;
+    // 是否返回本地响应头,需要获取响应头时使用此属性
+    isReturnNativeResponse?: boolean;
+    // Whether to join url
+    joinPrefix?: boolean;
+    // 接口地址，如果保留为空，则使用默认值
+    apiUrl?: string;
+    // 请求拼接路径
+    urlPrefix?: string;
+    // 错误消息提示类型
+    errorMessageMode?: ErrorMessageMode;
+    // 成功消息提示类型
+    successMessageMode?: SuccessMessageMode;
+    // 是否添加时间戳
+    joinTime?: boolean;
+    ignoreCancelToken?: boolean;
+    //是否在标头中发送令牌
+    withToken?: boolean;
+}
+
+export interface Result<T = any> {
+    code: number;
+    type: 'success' | 'error' | 'warning';
+    message: string;
+    success?: boolean | null;
+    timestamp?: number | null;
+    result: T;
+}
+
+//文件上传参数
+export interface UploadFileParams {
+    // 其他参数
+    data?: Recordable;
+    // 文件参数接口字段名
+    name?: string;
+    // 文件
+    file: File | Blob;
+    // 文件名
+    filename?: string;
+    [key: string]: any;
+}
+//文件返回参数
+export interface UploadFileCallBack {
+    // 成功回调方法
+    success?: any;
+    // 是否返回响应头,需要获取响应头时使用此属性
+    isReturnResponse?: boolean;
+}

package/project/types/config.ts

@@ -0,0 +1,180 @@
+import { ContentEnum, PermissionModeEnum, RouterTransitionEnum, SessionTimeoutProcessingEnum, SettingButtonPositionEnum, ThemeEnum } from '../src/enums/appEnum';
+import { CacheTypeEnum } from '../src/enums/cacheEnum';
+import { MenuModeEnum, MenuTypeEnum, MixSidebarTriggerEnum, TriggerEnum } from '../src/enums/menuEnum';
+
+/**
+ * <p>已支持的语言.</p>
+ * <ul>
+ *     <li>cs_CZ: 捷克语_捷克</li>
+ *     <li>   en: 英语</li>
+ *     <li>es_ES: 西班牙语_西班牙</li>
+ *     <li>fr_FR: 法语_法国</li>
+ *     <li>km_KH: 高棉语_柬埔寨</li>
+ *     <li>ko_KR: 韩语_韩国</li>
+ *     <li>vi_VN: 越南语_越南</li>
+ *     <li>zh_CN: 汉语_中国</li>
+ * </ul>
+ */
+export type LocaleType = 'cs_CZ' | 'en' | 'es_ES' | 'fr_FR' | 'km_KH' | 'ko_KR' | 'vi_VN' | 'zh_CN';
+
+export interface MenuSetting {
+    bgColor: string;
+    fixed: boolean;
+    collapsed: boolean;
+    canDrag: boolean;
+    show: boolean;
+    hidden: boolean;
+    split: boolean;
+    menuWidth: number;
+    mode: MenuModeEnum;
+    type: MenuTypeEnum;
+    theme: ThemeEnum;
+    topMenuAlign: 'start' | 'center' | 'end';
+    trigger: TriggerEnum;
+    accordion: boolean;
+    closeMixSidebarOnChange: boolean;
+    collapsedShowTitle: boolean;
+    mixSideTrigger: MixSidebarTriggerEnum;
+    mixSideFixed: boolean;
+}
+
+export interface MultiTabsSetting {
+    cache: boolean;
+    show: boolean;
+    showQuick: boolean;
+    canDrag: boolean;
+    showRedo: boolean;
+    showFold: boolean;
+    theme: string;
+}
+
+export interface HeaderSetting {
+    bgColor: string;
+    fixed: boolean;
+    show: boolean;
+    theme: ThemeEnum;
+    // Turn on full screen
+    showFullScreen: boolean;
+    // Whether to show the lock screen
+    useLockPage: boolean;
+    // Show document button
+    showDoc: boolean;
+    // Show message center button
+    showNotice: boolean;
+    showSearch: boolean;
+}
+
+export interface LocaleSetting {
+    showPicker: boolean;
+    // Current language
+    locale: LocaleType;
+    // default language
+    fallback: LocaleType;
+    // available Locales
+    availableLocales: LocaleType[];
+}
+
+export interface TransitionSetting {
+    //  Whether to open the page switching animation
+    enable: boolean;
+    // Route basic switching animation
+    basicTransition: RouterTransitionEnum;
+    // Whether to open page switching loading
+    openPageLoading: boolean;
+    // Whether to open the top progress bar
+    openNProgress: boolean;
+}
+
+export interface ProjectConfig {
+    // Storage location of permission related information
+    permissionCacheType: CacheTypeEnum;
+    // Whether to show the configuration button
+    showSettingButton: boolean;
+    // Whether to show the theme switch button
+    showDarkModeToggle: boolean;
+    // Configure where the button is displayed
+    settingButtonPosition: SettingButtonPositionEnum;
+    // Permission mode
+    permissionMode: PermissionModeEnum;
+    // Session timeout processing
+    sessionTimeoutProcessing: SessionTimeoutProcessingEnum;
+    // Website gray mode, open for possible mourning dates
+    grayMode: boolean;
+    // Whether to turn on the color weak mode
+    colorWeak: boolean;
+    // Theme color
+    themeColor: string;
+
+    // The main interface is displayed in full screen, the menu is not displayed, and the top
+    fullContent: boolean;
+    // content width
+    contentMode: ContentEnum;
+    // Whether to display the logo
+    showLogo: boolean;
+    // Whether to show the global footer
+    showFooter: boolean;
+    // menuType: MenuTypeEnum;
+    headerSetting: HeaderSetting;
+    // menuSetting
+    menuSetting: MenuSetting;
+    // Multi-tab settings
+    multiTabsSetting: MultiTabsSetting;
+    // Animation configuration
+    transitionSetting: TransitionSetting;
+    // pageLayout whether to enable keep-alive
+    openKeepAlive: boolean;
+    // Lock screen time
+    lockTime: number;
+    // Show breadcrumbs
+    showBreadCrumb: boolean;
+    // Show breadcrumb icon
+    showBreadCrumbIcon: boolean;
+    // Use error-handler-plugin
+    useErrorHandle: boolean;
+    // Whether to open back to top
+    useOpenBackTop: boolean;
+    // Is it possible to embed iframe pages
+    canEmbedIFramePage: boolean;
+    // Whether to delete unclosed messages and notify when switching the interface
+    closeMessageOnSwitch: boolean;
+    // Whether to cancel the http request that has been sent but not responded when switching the interface.
+    removeAllHttpPending: boolean;
+}
+
+export interface GlobConfig {
+    // Site title
+    title: string;
+    // Service interface url
+    apiUrl: string;
+    domainUrl: string;
+    // Upload url (作废)
+    uploadUrl?: string;
+    openSso?: string;
+    casBaseUrl?: string;
+    // onlineview url
+    viewUrl?: string;
+    //  Service interface url prefix
+    urlPrefix?: string;
+    // Project abbreviation
+    shortName: string;
+}
+
+export interface GlobEnvConfig {
+    // Site title
+    VITE_GLOB_APP_TITLE: string;
+    // Service interface url
+    VITE_GLOB_API_URL: string;
+    // Service interface url prefix
+    VITE_GLOB_API_URL_PREFIX?: string;
+    // Project abbreviation
+    VITE_GLOB_APP_SHORT_NAME: string;
+    //是否开启单点登录
+    VITE_GLOB_APP_OPEN_SSO: string;
+    //单点服务端地址
+    VITE_GLOB_APP_CAS_BASE_URL: string;
+    VITE_GLOB_DOMAIN_URL: string;
+    // Upload url
+    VITE_GLOB_UPLOAD_URL?: string;
+    // view url
+    VITE_GLOB_ONLINE_VIEW_URL?: string;
+}