uview-pro 0.6.18 → 0.6.19

package/libs/util/emitter.ts

@@ -1,112 +1,112 @@
-import { getCurrentInstance, type ComponentInternalInstance } from 'vue';
-
-/**
- * 适用于 uni-app Vue3 的事件派发/广播工具
- * 用法：import { dispatch, broadcast } from './emitter'
- */
-
-/**
- * 向上查找父组件并派发事件
- * @param instance 当前组件实例（setup中可用getCurrentInstance()）
- * @param componentName 目标组件名
- * @param eventName 事件名
- * @param params 参数
- */
-
-// 将事件名转换为驼峰格式
-// 例如：on-form-change -> onFormChange
-function formatToCamelCase(str: string): string {
-    return str.replace(/-([a-z])/g, function (g) {
-        return g[1].toUpperCase();
-    });
-}
-
-/**
- * 向上查找父组件
- * @param instance 当前组件实例（setup中可用getCurrentInstance()）
- * @param componentName 目标组件名
- * @returns 父组件实例
- */
-function parent(instance: ComponentInternalInstance | null | undefined = undefined, componentName: string = '') {
-    if (!instance) {
-        instance = getCurrentInstance();
-    }
-    let parent = instance && (instance.parent as ComponentInternalInstance | null | undefined);
-
-    if (!componentName) return parent;
-    while (parent) {
-        const name = (parent.type as any)?.name as string | undefined;
-        if (name === componentName) {
-            return parent;
-        }
-        parent = parent.parent;
-    }
-    return null;
-}
-
-/** * 向上查找父组件并派发事件
- * @param instance 当前组件实例（setup中可用getCurrentInstance()）
- * @param componentName 目标组件名
- * @param eventName 事件名
- * @param params 参数
- */
-function dispatch(
-    instance: ComponentInternalInstance | null | undefined,
-    componentName: string,
-    eventName: string,
-    ...params: any[]
-) {
-    let parent = instance && (instance.parent as ComponentInternalInstance | null | undefined);
-    while (parent) {
-        const name = (parent.type as any)?.name as string | undefined;
-        if (name === componentName) {
-            // 找到目标组件，派发事件
-            // Vue3未解决，目标组件事件监听失效，待优化，暂时使用下面的方式解决，如果你有好的方式也可以告诉我或者提PR
-            parent.emit && parent.emit(eventName, ...params);
-            // 如果有对应的方法，执行方法
-            // 这里可以考虑将 eventName 转换为驼峰格式
-            // 例如：on-form-change -> onFormChange
-            parent.exposed?.[formatToCamelCase(eventName)] && parent.exposed[formatToCamelCase(eventName)](...params);
-            break;
-        }
-        parent = parent.parent;
-    }
-}
-
-/**
- * 向下递归查找子组件并广播事件
- * @param instance 当前组件实例（setup中可用getCurrentInstance()）
- * @param componentName 目标组件名
- * @param eventName 事件名
- * @param params 参数
- */
-function broadcast(
-    instance: ComponentInternalInstance | null | undefined,
-    componentName: string,
-    eventName: string,
-    ...params: any[]
-) {
-    if (!instance) return;
-    const subTree = (instance.subTree as any)?.children || [];
-    const children = Array.isArray(subTree) ? subTree : [subTree];
-    children.forEach((vnode: any) => {
-        const child = vnode.component as ComponentInternalInstance | undefined;
-
-        if (child) {
-            const name = (child.type as any)?.name as string | undefined;
-            if (name === componentName) {
-                // 找到目标组件，广播事件
-                // Vue3未解决，目标组件事件监听失效，待优化，暂时使用下面的方式解决，如果你有好的方式也可以告诉我或者提PR
-                child.emit && child.emit(eventName, ...params);
-                // 如果有对应的方法，执行方法
-                // 这里可以考虑将 eventName 转换为驼峰格式
-                // 例如：on-form-change -> onFormChange
-                child.exposed?.[formatToCamelCase(eventName)] && child.exposed[formatToCamelCase(eventName)](...params);
-            } else {
-                broadcast(child, componentName, eventName, ...params);
-            }
-        }
-    });
-}
-
-export { dispatch, broadcast, parent };
+import { getCurrentInstance, type ComponentInternalInstance } from 'vue';
+
+/**
+ * 适用于 uni-app Vue3 的事件派发/广播工具
+ * 用法：import { dispatch, broadcast } from './emitter'
+ */
+
+/**
+ * 向上查找父组件并派发事件
+ * @param instance 当前组件实例（setup中可用getCurrentInstance()）
+ * @param componentName 目标组件名
+ * @param eventName 事件名
+ * @param params 参数
+ */
+
+// 将事件名转换为驼峰格式
+// 例如：on-form-change -> onFormChange
+function formatToCamelCase(str: string): string {
+    return str.replace(/-([a-z])/g, function (g) {
+        return g[1].toUpperCase();
+    });
+}
+
+/**
+ * 向上查找父组件
+ * @param instance 当前组件实例（setup中可用getCurrentInstance()）
+ * @param componentName 目标组件名
+ * @returns 父组件实例
+ */
+function parent(instance: ComponentInternalInstance | null | undefined = undefined, componentName: string = '') {
+    if (!instance) {
+        instance = getCurrentInstance();
+    }
+    let parent = instance && (instance.parent as ComponentInternalInstance | null | undefined);
+
+    if (!componentName) return parent;
+    while (parent) {
+        const name = (parent.type as any)?.name as string | undefined;
+        if (name === componentName) {
+            return parent;
+        }
+        parent = parent.parent;
+    }
+    return null;
+}
+
+/** * 向上查找父组件并派发事件
+ * @param instance 当前组件实例（setup中可用getCurrentInstance()）
+ * @param componentName 目标组件名
+ * @param eventName 事件名
+ * @param params 参数
+ */
+function dispatch(
+    instance: ComponentInternalInstance | null | undefined,
+    componentName: string,
+    eventName: string,
+    ...params: any[]
+) {
+    let parent = instance && (instance.parent as ComponentInternalInstance | null | undefined);
+    while (parent) {
+        const name = (parent.type as any)?.name as string | undefined;
+        if (name === componentName) {
+            // 找到目标组件，派发事件
+            // Vue3未解决，目标组件事件监听失效，待优化，暂时使用下面的方式解决，如果你有好的方式也可以告诉我或者提PR
+            parent.emit && parent.emit(eventName, ...params);
+            // 如果有对应的方法，执行方法
+            // 这里可以考虑将 eventName 转换为驼峰格式
+            // 例如：on-form-change -> onFormChange
+            parent.exposed?.[formatToCamelCase(eventName)] && parent.exposed[formatToCamelCase(eventName)](...params);
+            break;
+        }
+        parent = parent.parent;
+    }
+}
+
+/**
+ * 向下递归查找子组件并广播事件
+ * @param instance 当前组件实例（setup中可用getCurrentInstance()）
+ * @param componentName 目标组件名
+ * @param eventName 事件名
+ * @param params 参数
+ */
+function broadcast(
+    instance: ComponentInternalInstance | null | undefined,
+    componentName: string,
+    eventName: string,
+    ...params: any[]
+) {
+    if (!instance) return;
+    const subTree = (instance.subTree as any)?.children || [];
+    const children = Array.isArray(subTree) ? subTree : [subTree];
+    children.forEach((vnode: any) => {
+        const child = vnode.component as ComponentInternalInstance | undefined;
+
+        if (child) {
+            const name = (child.type as any)?.name as string | undefined;
+            if (name === componentName) {
+                // 找到目标组件，广播事件
+                // Vue3未解决，目标组件事件监听失效，待优化，暂时使用下面的方式解决，如果你有好的方式也可以告诉我或者提PR
+                child.emit && child.emit(eventName, ...params);
+                // 如果有对应的方法，执行方法
+                // 这里可以考虑将 eventName 转换为驼峰格式
+                // 例如：on-form-change -> onFormChange
+                child.exposed?.[formatToCamelCase(eventName)] && child.exposed[formatToCamelCase(eventName)](...params);
+            } else {
+                broadcast(child, componentName, eventName, ...params);
+            }
+        }
+    });
+}
+
+export { dispatch, broadcast, parent };

package/libs/util/mitt.ts

@@ -1,118 +1,118 @@
-/* eslint-disable @typescript-eslint/no-non-null-assertion */
-/**
- * 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 = unknown> = (event: T) => void;
-export type WildcardHandler<T = Record<string, unknown>> = (type: keyof T, event: T[keyof T]) => void;
-
-// An array of all currently registered event handlers for a type
-export type EventHandlerList<T = unknown> = Array<Handler<T>>;
-export type WildCardEventHandlerList<T = Record<string, unknown>> = Array<WildcardHandler<T>>;
-
-// A map of event types and their corresponding event handlers.
-export type EventHandlerMap<Events extends Record<EventType, unknown>> = Map<
-    '*' | keyof Events,
-    EventHandlerList<Events[keyof Events]> | WildCardEventHandlerList<Events>
->;
-
-export interface Emitter<Events extends Record<EventType, unknown>> {
-    all: EventHandlerMap<Events>;
-
-    on<Key extends keyof Events>(type: Key, handler: Handler<Events[Key]>): void;
-    on(type: '*', handler: WildcardHandler<Events>): void;
-
-    off<Key extends keyof Events>(type: Key, handler?: Handler<Events[Key]>): void;
-    off(type: '*', handler: WildcardHandler<Events>): void;
-
-    emit<Key extends keyof Events>(type: Key, event: Events[Key]): void;
-    emit<Key extends keyof Events>(type: undefined extends Events[Key] ? Key : never): void;
-    clear(): void;
-}
-
-/**
- * Mitt: Tiny (~200b) functional event emitter / pubsub.
- * @name mitt
- * @returns {Mitt}
- */
-export function mitt<Events extends Record<EventType, unknown>>(all?: EventHandlerMap<Events>): Emitter<Events> {
-    type GenericEventHandler = Handler<Events[keyof Events]> | WildcardHandler<Events>;
-    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<Key extends keyof Events>(type: Key, handler: GenericEventHandler) {
-            const handlers: Array<GenericEventHandler> | undefined = all!.get(type);
-            if (handlers) {
-                handlers.push(handler);
-            } else {
-                all!.set(type, [handler] as EventHandlerList<Events[keyof Events]>);
-            }
-        },
-
-        /**
-         * Remove an event handler for the given type.
-         * If `handler` is omitted, all handlers of the given type are removed.
-         * @param {string|symbol} type Type of event to unregister `handler` from (`'*'` to remove a wildcard handler)
-         * @param {Function} [handler] Handler function to remove
-         * @memberOf mitt
-         */
-        off<Key extends keyof Events>(type: Key, handler?: GenericEventHandler) {
-            const handlers: Array<GenericEventHandler> | undefined = all!.get(type);
-            if (handlers) {
-                if (handler) {
-                    handlers.splice(handlers.indexOf(handler) >>> 0, 1);
-                } else {
-                    all!.set(type, []);
-                }
-            }
-        },
-
-        /**
-         * 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<Key extends keyof Events>(type: Key, evt?: Events[Key]) {
-            let handlers = all!.get(type);
-            if (handlers) {
-                [...(handlers as EventHandlerList<Events[keyof Events]>)].forEach(handler => {
-                    handler(evt as Events[Key]);
-                });
-            }
-
-            handlers = all!.get('*');
-            if (handlers) {
-                [...(handlers as WildCardEventHandlerList<Events>)].forEach(handler => {
-                    handler(type, evt as Events[Key]);
-                });
-            }
-        },
-
-        /**
-         * Clear all
-         */
-        clear() {
-            this.all.clear();
-        }
-    };
-}
+/* eslint-disable @typescript-eslint/no-non-null-assertion */
+/**
+ * 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 = unknown> = (event: T) => void;
+export type WildcardHandler<T = Record<string, unknown>> = (type: keyof T, event: T[keyof T]) => void;
+
+// An array of all currently registered event handlers for a type
+export type EventHandlerList<T = unknown> = Array<Handler<T>>;
+export type WildCardEventHandlerList<T = Record<string, unknown>> = Array<WildcardHandler<T>>;
+
+// A map of event types and their corresponding event handlers.
+export type EventHandlerMap<Events extends Record<EventType, unknown>> = Map<
+    '*' | keyof Events,
+    EventHandlerList<Events[keyof Events]> | WildCardEventHandlerList<Events>
+>;
+
+export interface Emitter<Events extends Record<EventType, unknown>> {
+    all: EventHandlerMap<Events>;
+
+    on<Key extends keyof Events>(type: Key, handler: Handler<Events[Key]>): void;
+    on(type: '*', handler: WildcardHandler<Events>): void;
+
+    off<Key extends keyof Events>(type: Key, handler?: Handler<Events[Key]>): void;
+    off(type: '*', handler: WildcardHandler<Events>): void;
+
+    emit<Key extends keyof Events>(type: Key, event: Events[Key]): void;
+    emit<Key extends keyof Events>(type: undefined extends Events[Key] ? Key : never): void;
+    clear(): void;
+}
+
+/**
+ * Mitt: Tiny (~200b) functional event emitter / pubsub.
+ * @name mitt
+ * @returns {Mitt}
+ */
+export function mitt<Events extends Record<EventType, unknown>>(all?: EventHandlerMap<Events>): Emitter<Events> {
+    type GenericEventHandler = Handler<Events[keyof Events]> | WildcardHandler<Events>;
+    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<Key extends keyof Events>(type: Key, handler: GenericEventHandler) {
+            const handlers: Array<GenericEventHandler> | undefined = all!.get(type);
+            if (handlers) {
+                handlers.push(handler);
+            } else {
+                all!.set(type, [handler] as EventHandlerList<Events[keyof Events]>);
+            }
+        },
+
+        /**
+         * Remove an event handler for the given type.
+         * If `handler` is omitted, all handlers of the given type are removed.
+         * @param {string|symbol} type Type of event to unregister `handler` from (`'*'` to remove a wildcard handler)
+         * @param {Function} [handler] Handler function to remove
+         * @memberOf mitt
+         */
+        off<Key extends keyof Events>(type: Key, handler?: GenericEventHandler) {
+            const handlers: Array<GenericEventHandler> | undefined = all!.get(type);
+            if (handlers) {
+                if (handler) {
+                    handlers.splice(handlers.indexOf(handler) >>> 0, 1);
+                } else {
+                    all!.set(type, []);
+                }
+            }
+        },
+
+        /**
+         * 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<Key extends keyof Events>(type: Key, evt?: Events[Key]) {
+            let handlers = all!.get(type);
+            if (handlers) {
+                [...(handlers as EventHandlerList<Events[keyof Events]>)].forEach(handler => {
+                    handler(evt as Events[Key]);
+                });
+            }
+
+            handlers = all!.get('*');
+            if (handlers) {
+                [...(handlers as WildCardEventHandlerList<Events>)].forEach(handler => {
+                    handler(type, evt as Events[Key]);
+                });
+            }
+        },
+
+        /**
+         * Clear all
+         */
+        clear() {
+            this.all.clear();
+        }
+    };
+}

package/libs/util/system-theme.ts

@@ -1,25 +1,25 @@
-declare const uni: any;
-
-type SystemTheme = 'light' | 'dark';
-
-/**
- * 非 H5 平台获取当前系统主题
- */
-export function getSystemDarkMode(): SystemTheme {
-    try {
-        if (typeof uni !== 'undefined' && typeof uni.getSystemInfoSync === 'function') {
-            const systemInfo = uni.getSystemInfoSync();
-            const theme = systemInfo.osTheme || systemInfo.theme || 'light';
-            if (theme === 'dark') {
-                return 'dark';
-            }
-            if (theme === 'light') {
-                return 'light';
-            }
-        }
-    } catch (e) {
-        // 获取失败时默认返回亮色
-        console.warn('[system-theme] getSystemDarkMode failed', e);
-    }
-    return 'light';
-}
+declare const uni: any;
+
+type SystemTheme = 'light' | 'dark';
+
+/**
+ * 非 H5 平台获取当前系统主题
+ */
+export function getSystemDarkMode(): SystemTheme {
+    try {
+        if (typeof uni !== 'undefined' && typeof uni.getSystemInfoSync === 'function') {
+            const systemInfo = uni.getSystemInfoSync();
+            const theme = systemInfo.osTheme || systemInfo.theme || 'light';
+            if (theme === 'dark') {
+                return 'dark';
+            }
+            if (theme === 'light') {
+                return 'light';
+            }
+        }
+    } catch (e) {
+        // 获取失败时默认返回亮色
+        console.warn('[system-theme] getSystemDarkMode failed', e);
+    }
+    return 'light';
+}

package/locale/index.ts

@@ -1,2 +1,2 @@
-export { default as zhCN } from './lang/zh-CN';
-export { default as enUS } from './lang/en-US';
+export { default as zhCN } from './lang/zh-CN';
+export { default as enUS } from './lang/en-US';