uview-pro 0.0.17 → 0.0.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/parent.ts

@@ -1,20 +1,20 @@
-import { type ComponentInternalInstance, getCurrentInstance } from 'vue';
-
-export function parent(componentName?: string) {
-    const instance: ComponentInternalInstance | null | undefined = getCurrentInstance();
-    let parent = instance && (instance.parent as ComponentInternalInstance | null | undefined);
-
-    while (parent) {
-        const name = (parent.type as any)?.name as string | undefined;
-        if (name === componentName) {
-            return parent;
-        }
-        parent = parent.parent;
-    }
-    return null;
-}
-
-export function parentData(componentName?: string) {
-    const parentData = parent(componentName);
-    return parentData?.exposed ?? null;
-}
+import { type ComponentInternalInstance, getCurrentInstance } from 'vue';
+
+export function parent(componentName?: string) {
+    const instance: ComponentInternalInstance | null | undefined = getCurrentInstance();
+    let parent = instance && (instance.parent as ComponentInternalInstance | null | undefined);
+
+    while (parent) {
+        const name = (parent.type as any)?.name as string | undefined;
+        if (name === componentName) {
+            return parent;
+        }
+        parent = parent.parent;
+    }
+    return null;
+}
+
+export function parentData(componentName?: string) {
+    const parentData = parent(componentName);
+    return parentData?.exposed ?? null;
+}