@unicom-cloud/utils 0.1.38 → 0.1.40

package/dom-helpers/triggerEvent.js

@@ -1,10 +1,11 @@
-/* 2026-02-26 14:42:29 */
-function a(t, n, i = !1, v = !0) {
-  if (t) {
-    const e = document.createEvent("HTMLEvents");
-    e.initEvent(n, i, v), t.dispatchEvent(e);
-  }
+/* 潘启宝 2026-04-03 14:06:50 星期五 */
+//#region utils/dom-helpers/triggerEvent.ts
+function e(e, t, n = !1, r = !0) {
+	if (e) {
+		let i = document.createEvent("HTMLEvents");
+		i.initEvent(t, n, r), e.dispatchEvent(i);
+	}
 }
-export {
-  a as default
-};
+//#endregion
+export { e as default };
+/* 独立思考，明辨是非 */

package/dom-helpers/types.d.ts

@@ -0,0 +1,6 @@
+import type * as CSS from 'csstype';
+export type HyphenProperty = keyof CSS.PropertiesHyphen;
+export type CamelProperty = keyof CSS.Properties;
+export type Property = HyphenProperty | CamelProperty;
+declare const _default: {};
+export default _default;

package/dom-helpers/types.js

@@ -1,5 +1,6 @@
-/* 2026-02-26 14:42:29 */
-const t = {};
-export {
-  t as default
-};
+/* 潘启宝 2026-04-03 14:06:50 星期五 */
+//#region utils/dom-helpers/types.ts
+var e = {};
+//#endregion
+export { e as default };
+/* 独立思考，明辨是非 */

package/dom-helpers/width.js

@@ -1,10 +1,11 @@
-/* 2026-02-26 14:42:29 */
-import n from "./isWindow.js";
-import o from "./offset.js";
-function d(t, r) {
-  const i = n(t);
-  return i ? i.innerWidth : r ? t.clientWidth : o(t).width;
+/* 潘启宝 2026-04-03 14:06:50 星期五 */
+import e from "./isWindow.js";
+import t from "./offset.js";
+//#region utils/dom-helpers/width.ts
+function n(n, r) {
+	let i = e(n);
+	return i ? i.innerWidth : r ? n.clientWidth : t(n).width;
 }
-export {
-  d as default
-};
+//#endregion
+export { n as default };
+/* 独立思考，明辨是非 */

package/emitter/index.d.ts

@@ -0,0 +1,75 @@
+export type EventType = string | symbol;
+export type HandlerType = (...args: unknown[]) => void;
+export type AllType = Map<EventType, Set<HandlerType>>;
+export interface EmitterInterface {
+    on(type: EventType, handler: HandlerType): void;
+    once(type: EventType, handler: HandlerType): void;
+    off(type: EventType, handler?: HandlerType): void;
+    offAll(type?: EventType): void;
+    emit(type: EventType, ...args: unknown[]): void;
+    has(type: EventType): boolean;
+    hasHandler(type: EventType, handler?: HandlerType): boolean;
+    get(type: EventType): Set<HandlerType> | undefined;
+    clear(): void;
+    destroy(): void;
+}
+/**
+ * Emitter: 类式事件发射器 / 发布-订阅模式实现
+ */
+declare class Emitter implements EmitterInterface {
+    #private;
+    constructor(all?: AllType);
+    /**
+     * 为指定类型注册一个事件处理函数
+     * @param type 要监听的事件类型
+     * @param handler 响应事件时要调用的函数
+     */
+    on(type: EventType, handler: HandlerType): void;
+    /**
+     * 为指定类型注册一个事件处理函数（只首次调用起作用，之后将被移除）
+     * @param type 要监听的事件类型
+     * @param handler 响应事件时要调用的函数
+     */
+    once(type: EventType, handler: HandlerType): void;
+    /**
+     * 移除指定类型的事件处理函数
+     * 如果省略 `handler` 参数，则移除该类型的所有处理函数
+     * @param type 要移除处理函数的事件类型
+     * @param handler 要移除的处理函数
+     */
+    off(type: EventType, handler?: HandlerType): void;
+    /**
+     * 移除指定类型的所有事件处理函数
+     * 如果省略 `type` 参数，则移除所有处理函数
+     * @param type 要移除处理函数的事件类型
+     */
+    offAll(type?: EventType): void;
+    /**
+     * 调用指定类型的所有处理函数
+     * @param type 要触发的事件类型
+     * @param args 传递给处理函数的参数
+     */
+    emit(type: EventType, ...args: unknown[]): void;
+    get(type: EventType): Set<HandlerType> | undefined;
+    has(type: EventType): boolean;
+    /**
+     * 检查指定类型是否有事件处理函数
+     * @param type 事件类型
+     * @returns 是否存在处理函数
+     */
+    hasHandler(type: EventType, handler?: HandlerType): boolean;
+    clear(): void;
+    /**
+     * 销毁实例，释放资源
+     */
+    destroy(): void;
+    /**
+     * 获取所有已注册的事件类型
+     * @returns 事件类型数组
+     */
+    keys(): MapIterator<EventType>;
+    values(): MapIterator<Set<HandlerType>>;
+    entries(): MapIterator<[EventType, Set<HandlerType>]>;
+}
+export { Emitter };
+export default Emitter;

package/emitter/index.js

@@ -1,5 +1,69 @@
-/* 2026-02-26 14:42:29 */
-import { Emitter as r } from "./src/index.js";
-export {
-  r as default
+/* 潘启宝 2026-04-03 14:06:50 星期五 */
+//#region utils/emitter/index.ts
+var e = class {
+	#e;
+	constructor(e = /* @__PURE__ */ new Map()) {
+		this.#e = e;
+	}
+	on(e, t) {
+		if (typeof t != "function") throw Error(`${String(e)}: handler 必须为函数`);
+		let n = this.get(e) ?? /* @__PURE__ */ new Set();
+		n.add(t), this.#n(e, n);
+	}
+	once(e, t) {
+		let n = (...r) => {
+			t(...r), this.off(e, n);
+		};
+		this.on(e, n);
+	}
+	off(e, t) {
+		let n = this.get(e);
+		n && (t ? n.delete(t) : n.clear(), n.size || this.offAll(e));
+	}
+	offAll(e) {
+		e ? this.#t(e) : this.clear();
+	}
+	emit(e, ...t) {
+		let n = this.get(e);
+		if (!n) return;
+		let r = Array.from(n);
+		for (let e of r) e(...t);
+	}
+	get(e) {
+		return this.#e.get(e);
+	}
+	has(e) {
+		return this.#e.has(e);
+	}
+	hasHandler(e, t) {
+		if (t) {
+			let n = this.get(e);
+			if (n) return n.has(t);
+		} else return this.has(e);
+		return !1;
+	}
+	clear() {
+		this.#e.clear();
+	}
+	#t(e) {
+		this.#e.delete(e);
+	}
+	#n(e, t) {
+		this.#e.set(e, t);
+	}
+	destroy() {
+		this.clear(), this.#e = /* @__PURE__ */ new Map();
+	}
+	keys() {
+		return this.#e.keys();
+	}
+	values() {
+		return this.#e.values();
+	}
+	entries() {
+		return this.#e.entries();
+	}
 };
+//#endregion
+export { e as Emitter, e as default };
+/* 独立思考，明辨是非 */