@whitesev/utils 1.0.0 → 1.0.2

package/dist/src/Dictionary.d.ts

@@ -1,48 +1,53 @@
-declare class UtilsDictionary<K extends any, V extends any> {
-    items: {
-        [key: string | number | symbol]: V;
-    };
+export class UtilsDictionary {
+    items: {};
     /**
      * 检查是否有某一个键
-     * @param key 键
+     * @param {string} key 键
+     * @returns {boolean}
      */
-    has(key: K): boolean;
+    has(key: string): boolean;
     /**
      * 检查已有的键中是否以xx开头
-     * @param key 需要匹配的键
+     * @param {string} key 需要匹配的键
+     * @returns {boolean}
      */
     startsWith(key: string): boolean;
     /**
      * 获取以xx开头的键的值
-     * @param key 需要匹配的键
+     * @param {string} key 需要匹配的键
+     * @returns {any}
      */
-    getStartsWith(key: string): V | undefined;
+    getStartsWith(key: string): any;
     /**
      * 为字典添加某一个值
-     * @param key 键
-     * @param val 值，默认为""
+     * @param {string} key 键
+     * @param {any} val 值，默认为""
      */
-    set(key: K, val: V): void;
+    set(key: string, val?: any): void;
     /**
      * 删除某一个键
-     * @param key 键
+     * @param {string} key 键
+     * @returns {boolean}
      */
-    delete(key: K): boolean;
+    delete(key: string): boolean;
     /**
      * 获取某个键的值
-     * @param key 键
+     * @param {string} key 键
+     * @returns {any}
      */
-    get(key: K): V;
+    get(key: string): any;
     /**
      * 返回字典中的所有值
+     * @returns {any[]}
      */
-    values(): V[];
+    values(): any[];
     /**
      * 清空字典
      */
     clear(): void;
     /**
      * 获取字典的长度
+     * @returns {number}
      */
     size(): number;
     /**
@@ -51,37 +56,30 @@ declare class UtilsDictionary<K extends any, V extends any> {
     keys(): string[];
     /**
      * 返回字典本身
-     * @returns
+     * @returns {object}
      */
-    getItems(): {
-        [key: string]: V;
-        [key: number]: V;
-        [key: symbol]: V;
-    };
+    getItems(): object;
     /**
      * 合并另一个字典
-     * @param data 需要合并的字典
+     * @param {object} data 需要合并的字典
      */
-    concat(data: UtilsDictionary<K, V>): void;
-    /**
-     * 循环字典
-     */
-    forEach(callbackfn: (value: V, key: K, dictionary: UtilsDictionary<K, V>) => void): void;
+    concat(data: object): void;
+    forEach(callbackfn: any): void;
     /**
      * 获取字典的长度，同this.size
+     * @returns {number}
      */
     get length(): number;
     /**
      * 迭代器
      */
-    get entries(): () => Generator<(string | V)[], void, unknown>;
+    get entries(): () => Generator<any[], void, unknown>;
     /**
      * 是否可遍历
      */
-    get [Symbol.iterator](): () => Generator<(string | V)[], void, unknown>;
+    get [Symbol.iterator](): () => Generator<any[], void, unknown>;
     /**
      * .toString()和.toLocaleString()输出的字符串
      */
     get [Symbol.toStringTag](): string;
 }
-export { UtilsDictionary };

package/dist/src/Utils.d.ts

@@ -1,5 +1,4 @@
 import { ColorConversion } from "./ColorConversion";
-import { UtilsDictionary } from "./Dictionary";
 import { GBKEncoder } from "./GBKEncoder";
 import { UtilsGMCookie } from "./UtilsGMCookie";
 declare class Utils {
@@ -135,7 +134,9 @@ declare class Utils {
      * > true
      * dictionary.concat(dictionary2);
      **/
-    Dictionary: typeof UtilsDictionary;
+    Dictionary: {
+        new <K, V>(): UtilsDictionaryConstructor<K, V>;
+    };
     /**
      * 主动触发事件
      * @param element 元素

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@whitesev/utils",
-	"version": "1.0.0",
+	"version": "1.0.2",
 	"description": "一个常用的工具库",
 	"main": "dist/index.cjs.js",
 	"module": "dist/node/index.esm.js",
@@ -23,6 +23,7 @@
 	"author": "WhiteSev",
 	"license": "MIT",
 	"dependencies": {
+		"@rollup/plugin-babel": "^6.0.4",
 		"@rollup/plugin-commonjs": "^25.0.8",
 		"@rollup/plugin-node-resolve": "^15.2.3",
 		"@rollup/plugin-typescript": "^11.1.6",

package/rollup.config.js

@@ -1,9 +1,11 @@
 // 允许使用 node 或 umd 包
 const commonjs = require("@rollup/plugin-commonjs");
+// 解析导入的依赖模块路径，以便 Rollup 能够正确找到依赖模块。
 const { nodeResolve } = require("@rollup/plugin-node-resolve");
 // 编译 TS 代码
 const typescript = require("@rollup/plugin-typescript");
 
+const moduleName = "Utils";
 module.exports = {
 	plugins: [nodeResolve(), commonjs(), typescript()],
 	input: "./index.ts", // 源文件入口
@@ -20,9 +22,26 @@ module.exports = {
 		},
 		{
 			file: "dist/index.umd.js",
-			name: "Utils", // 模块名
+			name: moduleName, // 模块名
 			format: "umd", // umd 兼容形式的包， 可以直接应用于网页 script
 			sourcemap: true,
 		},
+		{
+			file: "dist/index.amd.js",
+			format: "amd", // amd 兼容形式的包， 适用于浏览器环境中使用 AMD 加载器加载模块
+			sourcemap: true,
+		},
+		{
+			file: "dist/index.iife.js",
+			name: moduleName, // 模块名
+			format: "iife", // iife 兼容形式的包， 将模块包裹在一个立即执行的函数中。适用于直接在浏览器中使用
+			sourcemap: true,
+		},
+		{
+			file: "dist/index.system.js",
+			name: moduleName, // 模块名
+			format: "system", // system 兼容形式的包， 可以在浏览器和 Node.js 环境下加载
+			sourcemap: true,
+		},
 	],
 };

package/src/{Dictionary.ts → Dictionary.js}

@@ -1,21 +1,19 @@
-import { Utils } from "./Utils";
-
-class UtilsDictionary<K extends any, V extends any> {
-	items: {
-		[key: string | number | symbol]: V;
-	} = {};
+class UtilsDictionary {
+	items = {};
 	/**
 	 * 检查是否有某一个键
-	 * @param key 键
+	 * @param {string} key 键
+	 * @returns {boolean}
 	 */
-	has(key: K) {
-		return this.items.hasOwnProperty(key as any);
+	has(key) {
+		return this.items.hasOwnProperty(key);
 	}
 	/**
 	 * 检查已有的键中是否以xx开头
-	 * @param key 需要匹配的键
+	 * @param {string} key 需要匹配的键
+	 * @returns {boolean}
 	 */
-	startsWith(key: string) {
+	startsWith(key) {
 		let allKeys = this.keys();
 		for (const keyName of allKeys) {
 			if (keyName.startsWith(key)) {
@@ -26,52 +24,56 @@ class UtilsDictionary<K extends any, V extends any> {
 	}
 	/**
 	 * 获取以xx开头的键的值
-	 * @param key 需要匹配的键
+	 * @param {string} key 需要匹配的键
+	 * @returns {any}
 	 */
-	getStartsWith(key: string) {
+	getStartsWith(key) {
 		let allKeys = this.keys();
 		for (const keyName of allKeys) {
 			if (keyName.startsWith(key)) {
-				return this.getItems()[keyName];
+				return this.items[keyName];
 			}
 		}
 	}
 	/**
 	 * 为字典添加某一个值
-	 * @param key 键
-	 * @param val 值，默认为""
+	 * @param {string} key 键
+	 * @param {any} val 值，默认为""
 	 */
-	set(key: K, val: V) {
+	set(key, val = "") {
 		if (key === void 0) {
 			throw new Error("Utils.Dictionary().set 参数 key 不能为空");
 		}
-		this.items[key as any] = val;
+		this.items[key] = val;
 	}
 	/**
 	 * 删除某一个键
-	 * @param key 键
+	 * @param {string} key 键
+	 * @returns {boolean}
 	 */
-	delete(key: K) {
+	delete(key) {
 		if (this.has(key)) {
-			Reflect.deleteProperty(this.items, key as any);
+			Reflect.deleteProperty(this.items, key);
 			return true;
 		}
 		return false;
 	}
 	/**
 	 * 获取某个键的值
-	 * @param key 键
+	 * @param {string} key 键
+	 * @returns {any}
 	 */
-	get(key: K) {
-		return this.getItems()[key as any];
+	get(key) {
+		return this.has(key) ? this.items[key] : void 0;
 	}
 	/**
 	 * 返回字典中的所有值
+	 * @returns {any[]}
 	 */
 	values() {
 		let resultList = [];
 		for (let prop in this.items) {
-			if (this.has(prop as K)) {
+			if (this.has(prop)) {
 				resultList.push(this.items[prop]);
 			}
 		}
@@ -81,11 +83,12 @@ class UtilsDictionary<K extends any, V extends any> {
 	 * 清空字典
 	 */
 	clear() {
-		this.items = void 0 as any;
+		this.items = null;
 		this.items = {};
 	}
 	/**
 	 * 获取字典的长度
+	 * @returns {number}
 	 */
 	size() {
 		return Object.keys(this.items).length;
@@ -98,30 +101,26 @@ class UtilsDictionary<K extends any, V extends any> {
 	}
 	/**
 	 * 返回字典本身
-	 * @returns
+	 * @returns {object}
 	 */
 	getItems() {
 		return this.items;
 	}
 	/**
 	 * 合并另一个字典
-	 * @param data 需要合并的字典
+	 * @param {object} data 需要合并的字典
 	 */
-	concat(data: UtilsDictionary<K, V>) {
+	concat(data) {
 		this.items = Utils.assign(this.items, data.getItems());
 	}
-	/**
-	 * 循环字典
-	 */
-	forEach(
-		callbackfn: (value: V, key: K, dictionary: UtilsDictionary<K, V>) => void
-	) {
-		for (const key in this.getItems()) {
-			callbackfn(this.get(key as K), key as K, this.getItems() as any);
+	forEach(callbackfn) {
+		for (const key in this.items) {
+			callbackfn(this.get(key), key, this.items);
 		}
 	}
 	/**
 	 * 获取字典的长度，同this.size
+	 * @returns {number}
 	 */
 	get length() {
 		return this.size();
@@ -134,7 +133,7 @@ class UtilsDictionary<K extends any, V extends any> {
 		return function* () {
 			let itemKeys = Object.keys(that.getItems());
 			for (const keyName of itemKeys) {
-				yield [keyName, that.get(keyName as K)];
+				yield [keyName, that.get(keyName)];
 			}
 		};
 	}

package/src/Utils.ts

@@ -1,5 +1,4 @@
 import { ColorConversion } from "./ColorConversion";
-import { UtilsDictionary } from "./Dictionary";
 import { GBKEncoder } from "./GBKEncoder";
 import { UtilsCore } from "./UtilsCore";
 import { UtilsGMCookie } from "./UtilsGMCookie";
@@ -12,6 +11,7 @@ import { LockFunction } from "./LockFunction";
 import { Log } from "./Log";
 import { Progress } from "./Progress";
 import { TryCatch } from "./tryCatch";
+import { UtilsDictionary } from "./Dictionary";
 
 class Utils {
 	/** 版本号 */
@@ -442,7 +442,9 @@ class Utils {
 	 * > true
 	 * dictionary.concat(dictionary2);
 	 **/
-	Dictionary = UtilsDictionary;
+	Dictionary: {
+		new <K, V>(): UtilsDictionaryConstructor<K, V>;
+	} = UtilsDictionary as any;
 	/**
 	 * 主动触发事件
 	 * @param element 元素

package/src/ajaxHooker.js

@@ -1,9 +1,7 @@
-// ==UserScript==
 // @name         ajaxHooker
 // @author       cxxjackie
 // @version      1.4.1
 // @supportURL   https://bbs.tampermonkey.net.cn/thread-3284-1-1.html
-// ==/UserScript==
 
 var ajaxHooker = (function () {
 	"use strict";

package/src/types/Dictionary.d.ts

@@ -0,0 +1,52 @@
+declare interface UtilsDictionaryConstructor<K extends any, V extends any> {
+	/** 检查是否有某一个键 */
+	has(key: K): boolean;
+	/** 检查已有的键中是否以xx开头 */
+	startsWith(key: K): boolean;
+	/** 获取以xx开头的键的值 */
+	getStartsWith(key: K): V;
+	/** 为字典添加某一个值 */
+	set(key: K, val: V): void;
+	/** 删除某一个键 */
+	delete(key: K): boolean;
+	/** 获取某个键的值 */
+	get(key: K): V;
+	/** 返回字典中的所有值 */
+	values(): V[];
+	/** 清空字典 */
+	clear(): void;
+	/** 获取字典的长度 */
+	size(): number;
+	/** 获取字典所有的键 */
+	keys(): K[];
+	/** 返回字典本身 */
+	getItems(): Record<K, V>;
+	/** 合并另一个字典 */
+	concat(data: UtilsDictionaryConstructor<K, V>): void;
+	/**
+	 * 迭代器
+	 */
+	entries(): IterableIterator<[K, V]>;
+	/**
+	 * 循环字典
+	 */
+	forEach(
+		callbackfn: (
+			value: V,
+			key: K,
+			dictionary: UtilsDictionaryConstructor<K, V>
+		) => void
+	): void;
+	/**
+	 * 可迭代
+	 */
+	[Symbol.iterator](): IterableIterator<[K, V]>;
+	/**
+	 * .toString()和.toLocaleString()输出的字符串
+	 */
+	[Symbol.toStringTag](): string;
+	/**
+	 * 同this.size()
+	 */
+	get length(): number;
+}