devix 0.1.2 → 1.0.3

package/dist/index.js

@@ -0,0 +1,300 @@
+//#region src/typeof.ts
+function getDataType(target) {
+	const type = typeof target;
+	return type !== "object" ? type : Object.prototype.toString.call(target).slice(8, -1).toLowerCase();
+}
+const typeCheckRules = {
+	undefined: (target) => typeof target === "undefined",
+	null: (target) => target === null,
+	number: (target) => typeof target === "number",
+	string: (target) => typeof target === "string",
+	boolean: (target) => typeof target === "boolean",
+	symbol: (target) => typeof target === "symbol",
+	bigint: (target) => typeof target === "bigint",
+	object: (target) => target !== null && typeof target === "object",
+	array: (target) => Array.isArray(target),
+	function: (target) => typeof target === "function",
+	date: (target) => target instanceof Date,
+	set: (target) => target instanceof Set,
+	map: (target) => target instanceof Map,
+	regexp: (target) => target instanceof RegExp,
+	promise: (target) => target instanceof Promise,
+	empty(target) {
+		return this.string(target) && target === "";
+	}
+};
+const isType = (type, target) => {
+	const dataType = typeCheckRules[type] ? typeCheckRules[type](target) : getDataType(target) === type;
+	return dataType;
+};
+
+//#endregion
+//#region src/clone.ts
+//! Function Shallow Copy
+function shallowClone(source) {
+	if (isType("array", source)) return source.slice();
+	if (isType("object", source)) return { ...source };
+	return source;
+}
+//! Function Deep Copy
+const isFormat = (target) => isType("object", target) || isType("function", target);
+function handleSpeciBoundar(source, dpClone, hash) {
+	if (isType("symbol", source)) return Symbol(source.description);
+	if (!isFormat(source)) return source;
+	if (isType("set", source)) {
+		const newSet = /* @__PURE__ */ new Set();
+		source.forEach((value) => newSet.add(dpClone(value, hash)));
+		return newSet;
+	}
+	if (isType("map", source)) {
+		const newMap = /* @__PURE__ */ new Map();
+		source.forEach((value, key) => newMap.set(key, dpClone(value, hash)));
+		return newMap;
+	}
+	return null;
+}
+function deepClone(source, hash = /* @__PURE__ */ new WeakMap()) {
+	if (hash.get(source)) return hash.get(source);
+	const result = handleSpeciBoundar(source, deepClone, hash);
+	if (result) return result;
+	const isArray = isType("array", source);
+	const cloneObject = isArray ? [] : {};
+	hash.set(source, cloneObject);
+	if (isArray) source.forEach((item, index) => {
+		cloneObject[index] = deepClone(item, hash);
+	});
+	else {
+		Object.keys(source).forEach((key) => {
+			cloneObject[key] = deepClone(source[key], hash);
+		});
+		Object.getOwnPropertySymbols(source).forEach((sym) => {
+			cloneObject[Symbol(sym.description)] = deepClone(source[sym], hash);
+		});
+	}
+	return cloneObject;
+}
+
+//#endregion
+//#region src/others.ts
+function currying(fn) {
+	function curried(...args) {
+		if (args.length >= fn.length) return fn.apply(this, args);
+		return function subCurried(...args2) {
+			return curried.apply(this, args.concat(args2));
+		};
+	}
+	return curried;
+}
+function compose(...fns) {
+	const { length } = fns;
+	if (length <= 0) return null;
+	for (let i = 0; i < length; i++) {
+		const fn = fns[i];
+		if (typeof fn !== "function") throw new TypeError(`argument with index ${i} is not a function`);
+	}
+	function executeFn(...args) {
+		let index = 0;
+		let result = fns[index].apply(this, args);
+		while (++index < length) result = fns[index].call(this, result);
+		return result;
+	}
+	return executeFn;
+}
+function insertStr(soure, start, newStr) {
+	return soure.slice(0, start) + newStr + soure.slice(start);
+}
+function setCaseType(soure, type) {
+	const newStr = soure.slice(0, 1)[type === "upper" ? "toUpperCase" : "toLowerCase"]() + soure.slice(1).toLowerCase();
+	return newStr;
+}
+function stringCase(soure, separa = ["", ""], cases = ["upper", "upper"]) {
+	const [separator, separate] = separa;
+	const [firstCase, argsCase] = cases;
+	const newStr = soure.split(separator);
+	for (let i = 0; i < newStr.length; i++) newStr[i] = setCaseType(newStr[i], i === 0 ? firstCase : argsCase);
+	return newStr.join(separate);
+}
+const transformGetParams = (params) => {
+	let result = "";
+	for (const propName of Object.keys(params)) {
+		const value = params[propName];
+		const part = `${encodeURIComponent(propName)}=`;
+		if (isType("empty", value)) continue;
+		if (!isType("object", value)) {
+			result += `${part + encodeURIComponent(value)}&`;
+			continue;
+		}
+		for (const key of Object.keys(value)) {
+			if (!isType("empty", value)) continue;
+			const paramsStr = `${propName}[${key}]`;
+			const subPart = `${encodeURIComponent(paramsStr)}=`;
+			result += `${subPart + encodeURIComponent(value[key])}&`;
+		}
+	}
+	return result.slice(0, -1);
+};
+
+//#endregion
+//#region src/retalimit.ts
+function debounce(callback, delay = 0, immediate = false) {
+	let timer = null;
+	let isInvoke = false;
+	function subDebounce(...args) {
+		return new Promise((resolve, reject) => {
+			if (timer !== null) clearTimeout(timer);
+			if (immediate && !isInvoke) {
+				try {
+					const result = callback.apply(this, args);
+					resolve(result);
+				} catch (error) {
+					reject(error);
+				}
+				isInvoke = true;
+				return;
+			}
+			timer = setTimeout(() => {
+				try {
+					const result = callback.apply(this, args);
+					resolve(result);
+				} catch (error) {
+					reject(error);
+				} finally {
+					timer = null;
+					isInvoke = false;
+				}
+			}, delay);
+		});
+	}
+	subDebounce.cancel = () => {
+		if (timer !== null) clearTimeout(timer);
+		timer = null;
+		isInvoke = false;
+	};
+	return subDebounce;
+}
+function throttle(callback, interval, options = {}) {
+	const { leading = true, trailing = false } = options;
+	let startTime = 0;
+	let timer = null;
+	function subThrottle(...args) {
+		return new Promise((resolve, reject) => {
+			try {
+				const nowTime = Date.now();
+				let result;
+				if (!leading && startTime === 0) startTime = nowTime;
+				const waitTime = interval - (nowTime - startTime);
+				if (waitTime <= 0) {
+					if (timer) clearTimeout(timer);
+					result = callback.apply(this, args);
+					resolve(result);
+					startTime = nowTime;
+					timer = null;
+					return;
+				}
+				if (trailing && !timer) timer = setTimeout(() => {
+					result = callback.apply(this, args);
+					resolve(result);
+					startTime = Date.now();
+					timer = null;
+				}, waitTime);
+			} catch (error) {
+				reject(error);
+			}
+		});
+	}
+	subThrottle.cancel = () => {
+		if (timer) clearTimeout(timer);
+		startTime = 0;
+		timer = null;
+	};
+	return subThrottle;
+}
+
+//#endregion
+//#region src/sort.ts
+let SortType = /* @__PURE__ */ function(SortType$1) {
+	SortType$1["ASC"] = "ASC";
+	SortType$1["DESC"] = "DESC";
+	return SortType$1;
+}({});
+function swap(array, index1, index2) {
+	[array[index1], array[index2]] = [array[index2], array[index1]];
+}
+function compare(value1, value2, type) {
+	return type === SortType.ASC ? value1 > value2 : value1 < value2;
+}
+function bubblingSort(array, type = "ASC", key) {
+	const { length } = array;
+	if (length < 2) return array;
+	for (let i = 0; i < length - 1; i++) for (let j = 0; j < length - 1 - i; j++) {
+		const value1 = key ? array[j][key] : array[j];
+		const value2 = key ? array[j + 1][key] : array[j + 1];
+		if (compare(value1, value2, type)) swap(array, j, j + 1);
+	}
+	return array;
+}
+
+//#endregion
+//#region src/timer.ts
+const formatRules = new Map([
+	["yyyy", "year"],
+	["MM", "month"],
+	["dd", "day"],
+	["HH", "hours"],
+	["mm", "minutes"],
+	["ss", "seconds"],
+	["W", "week"]
+]);
+const WeekList = new Map([
+	[1, "一"],
+	[2, "二"],
+	[3, "三"],
+	[4, "四"],
+	[5, "五"],
+	[6, "六"],
+	[0, "日"]
+]);
+function processWeek(weekNum) {
+	return WeekList.get(weekNum) || "";
+}
+function formatNumber(value) {
+	return value.toString().padStart(2, "0");
+}
+function createTimerFormatObj(date) {
+	const dayOfWeek = date.getDay() === 0 ? 7 : date.getDay();
+	return {
+		year: date.getFullYear().toString(),
+		month: formatNumber(date.getMonth() + 1),
+		day: formatNumber(date.getDate()),
+		hours: formatNumber(date.getHours()),
+		minutes: formatNumber(date.getMinutes()),
+		seconds: formatNumber(date.getSeconds()),
+		week: processWeek(dayOfWeek),
+		weekNum: dayOfWeek.toString()
+	};
+}
+const formatTimer = (cellValue, formatOption = "yyyy-MM-dd HH:mm:ss") => {
+	if (!cellValue) return (/* @__PURE__ */ new Date()).toISOString();
+	const date = new Date(cellValue);
+	const timerFormatObj = createTimerFormatObj(date);
+	if (isType("string", formatOption) && !formatOption.trim()) return timerFormatObj;
+	const timerFormatStr = Array.from(formatRules).reduce((currentFormat, [rule, key]) => {
+		return currentFormat.replace(new RegExp(rule, "g"), timerFormatObj[key]);
+	}, formatOption);
+	return timerFormatStr;
+};
+async function setTimer(execute, delay = 0, immediate = false) {
+	let timer = null;
+	const interval = async () => {
+		await execute();
+		timer = setTimeout(interval, delay);
+	};
+	if (immediate) await execute();
+	setTimeout(interval, delay);
+	return { cancel: () => {
+		if (timer !== null) clearTimeout(timer);
+	} };
+}
+
+//#endregion
+export { SortType, bubblingSort, compose, currying, debounce, deepClone, formatTimer, insertStr, isType, setTimer, shallowClone, stringCase, throttle, transformGetParams };

package/package.json

@@ -1,82 +1,51 @@
 {
   "name": "devix",
-  "type": "module",
-  "version": "0.1.2",
+  "version": "1.0.3",
   "description": "Devix is a comprehensive, powerful, and compact JavaScript utility library.",
-  "author": "king-3 <w2196592083@gmail.com>",
+  "type": "module",
+  "keywords": [
+    "devix",
+    "development tools"
+  ],
   "license": "MIT",
   "homepage": "https://github.com/OpenKnights/devix#readme",
+  "bugs": {
+    "url": "https://github.com/OpenKnights/devix/issues"
+  },
   "repository": {
     "type": "git",
     "url": "git+https://github.com/OpenKnights/devix.git"
   },
-  "bugs": {
-    "url": "https://github.com/OpenKnights/devix/issues"
-  },
-  "keywords": [
-    "template",
-    "library"
+  "author": "king-3 <w2196592083@gmail.com>",
+  "files": [
+    "dist/"
   ],
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
   "exports": {
     ".": {
-      "types": "./index.d.ts",
+      "types": "./dist/index.d.ts",
       "require": "./dist/index.cjs.js",
       "import": "./dist/index.esm.js"
     },
-    "./lib/**": {
-      "types": "./lib/**/index.d.ts",
-      "require": "./lib/**/index.cjs.js",
-      "import": "./lib/**/index.esm.js"
-    },
     "./*": "./*"
   },
-  "types": "./index.d.ts",
-  "main": "./dist/index.cjs.js",
-  "module": "./dist/index.esm.js",
-  "files": [
-    "dist/",
-    "lib/",
-    "package.json",
-    "README.md",
-    "index.d.ts"
-  ],
-  "scripts": {
-    "build": "rollup -c",
-    "clear": "pwsh clear.ps1",
-    "test": "jest",
-    "lint": "npx eslint src/**/*.ts && npx eslint test/**/*.ts && npx eslint types/**/*.ts",
-    "prettier": "npx prettier --config .prettierrc.json --write ./**/*.{ts,json}",
-    "releases": "pwsh publish.ps1",
-    "versihint": "npx bump"
-  },
   "devDependencies": {
-    "@babel/core": "^7.24.5",
-    "@babel/preset-env": "^7.24.5",
-    "@babel/preset-typescript": "^7.24.1",
-    "@rollup/plugin-alias": "^5.1.0",
-    "@rollup/plugin-babel": "^6.0.4",
-    "@rollup/plugin-commonjs": "^25.0.7",
-    "@rollup/plugin-json": "^6.1.0",
-    "@rollup/plugin-node-resolve": "^15.2.3",
-    "@types/jest": "^29.5.12",
-    "@typescript-eslint/eslint-plugin": "^7.8.0",
-    "@typescript-eslint/parser": "^7.8.0",
-    "esbuild": "^0.21.0",
-    "eslint": "^8.57.0",
-    "eslint-config-airbnb-base": "^15.0.0",
-    "eslint-config-airbnb-typescript": "^18.0.0",
-    "eslint-config-prettier": "^9.1.0",
-    "eslint-plugin-import": "^2.29.1",
-    "eslint-plugin-prettier": "^5.1.3",
-    "jest": "^29.7.0",
-    "prettier": "^3.2.5",
-    "rollup": "^4.17.2",
-    "rollup-plugin-dts": "^6.1.0",
-    "rollup-plugin-esbuild": "^6.1.1",
-    "rollup-plugin-typescript2": "^0.36.0",
-    "ts-jest": "^29.1.2",
-    "tslib": "^2.6.2",
-    "typescript": "^5.4.5",
-    "version-bump-prompt": "^6.1.0"
+    "@king-3/eslint-config": "^1.0.3",
+    "bumpp": "^10.2.3",
+    "eslint": "^9.33.0",
+    "prettier": "^3.6.2",
+    "tsdown": "^0.14.1",
+    "typescript": "^5.9.2",
+    "vitest": "^3.2.4"
+  },
+  "scripts": {
+    "build": "tsdown --clear --dts",
+    "test": "vitest run",
+    "lint": "eslint",
+    "lint:fix": "eslint --fix",
+    "format": "prettier --write ./**/*.{ts,json,md}",
+    "release": "bumpp && pnpm publish"
   }
-}
+}