uview-pro 0.2.4 → 0.3.1

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;
+}

package/package.json

@@ -2,7 +2,7 @@
     "id": "uview-pro",
     "name": "uview-pro",
     "displayName": "【Vue3重构版】uView Pro｜基于Vue3+TS全面重构的70+精选UI组件库",
-    "version": "0.2.4",
+    "version": "0.3.1",
     "description": "uView Pro，是全面支持Vue3的uni-app生态框架，70+精选组件已使用TypeScript重构，已全面支持uni-app Vue3.0",
     "main": "index.ts",
     "module": "index.ts",
@@ -73,13 +73,13 @@
                     },
                     "mp": {
                         "weixin": "√",
-                        "alipay": "-",
-                        "toutiao": "-",
+                        "alipay": "√",
+                        "toutiao": "√",
                         "baidu": "-",
                         "kuaishou": "-",
                         "jd": "-",
                         "harmony": "-",
-                        "qq": "-",
+                        "qq": "√",
                         "lark": "-"
                     },
                     "quickapp": {