devix 0.1.2 → 1.0.1

package/LICENSE

@@ -1,21 +1,21 @@
-MIT License
-
-Copyright (c) 2024 OpenKnights
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
+MIT License
+
+Copyright (c) 2024 OpenKnights
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -14,10 +14,10 @@ Then, utilize modern module bundling tools such as Vite or Webpack to import thi
 
 ```javascript
 // Using ES Module
-import { [[ModuleName]] } from 'devix'
+import { shallowClone } from 'devix'
 
 // Using CommonJS
-const { [[ModuleName]]  } = require('devix')
+const { deepClone } = require('devix')
 ```
 
 ## Usage

package/dist/index.cjs

@@ -0,0 +1,314 @@
+
+//#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
+exports.SortType = SortType;
+exports.bubblingSort = bubblingSort;
+exports.compose = compose;
+exports.currying = currying;
+exports.debounce = debounce;
+exports.deepClone = deepClone;
+exports.formatTimer = formatTimer;
+exports.insertStr = insertStr;
+exports.isType = isType;
+exports.setTimer = setTimer;
+exports.shallowClone = shallowClone;
+exports.stringCase = stringCase;
+exports.throttle = throttle;
+exports.transformGetParams = transformGetParams;

package/dist/index.d.cts

@@ -0,0 +1,74 @@
+//#region src/clone.d.ts
+declare function shallowClone<T = any>(source: T): T;
+declare function deepClone(source: any, hash?: WeakMap<object, any>): any;
+//#endregion
+//#region src/types.d.ts
+type CaseType = 'upper' | 'lower';
+type CaseTypeTuple = [CaseType, CaseType];
+type FormatTimerFn = (cellValue: string | number | Date, formatType?: string) => string | TimerFormatObj;
+interface TimerFormatObj {
+  year: string;
+  month: string;
+  day: string;
+  hours: string;
+  minutes: string;
+  seconds: string;
+  week: string;
+  weekNum: string;
+}
+interface ThrottleOptions {
+  leading?: boolean;
+  trailing?: boolean;
+}
+//#endregion
+//#region src/others.d.ts
+declare function currying(fn: (...args: any[]) => any): (this: any, ...args: any[]) => any;
+declare function compose(...fns: ((...args: any[]) => any)[]): ((this: any, ...args: any[]) => any) | null;
+declare function insertStr(soure: string, start: number, newStr: string): string;
+declare function stringCase(soure: string, separa?: string[], cases?: CaseTypeTuple): string;
+declare const transformGetParams: (params: Record<string, any>) => string;
+//#endregion
+//#region src/retalimit.d.ts
+declare function debounce<T extends (...args: any[]) => any>(callback: T, delay?: number, immediate?: boolean): ((...args: Parameters<T>) => Promise<ReturnType<T>>) & {
+  cancel: () => void;
+};
+declare function throttle<T extends (...args: any[]) => any>(callback: T, interval: number, options?: ThrottleOptions): ((...args: Parameters<T>) => Promise<ReturnType<T>>) & {
+  cancel: () => void;
+};
+//#endregion
+//#region src/sort.d.ts
+declare enum SortType {
+  ASC = "ASC",
+  DESC = "DESC",
+}
+declare function bubblingSort<T>(array: T[], type?: string, key?: keyof T): T[];
+//#endregion
+//#region src/timer.d.ts
+declare const formatTimer: FormatTimerFn;
+declare function setTimer(execute: (...args: any[]) => any, delay?: number, immediate?: boolean): Promise<{
+  cancel: () => void;
+}>;
+//#endregion
+//#region src/typeof.d.ts
+declare const typeCheckRules: {
+  undefined: (target: unknown) => target is undefined;
+  null: (target: unknown) => target is null;
+  number: (target: unknown) => target is number;
+  string: (target: unknown) => target is string;
+  boolean: (target: unknown) => target is boolean;
+  symbol: (target: unknown) => target is symbol;
+  bigint: (target: unknown) => target is bigint;
+  object: (target: unknown) => target is object;
+  array: (target: unknown) => target is any[];
+  function: (target: unknown) => target is Function;
+  date: (target: unknown) => target is Date;
+  set: (target: unknown) => target is Set<any>;
+  map: (target: unknown) => target is Map<any, any>;
+  regexp: (target: unknown) => target is RegExp;
+  promise: (target: unknown) => target is Promise<any>;
+  empty(target: unknown): target is "";
+};
+type TypeCheckOption = keyof typeof typeCheckRules;
+declare const isType: (type: TypeCheckOption, target: unknown) => boolean;
+//#endregion
+export { SortType, bubblingSort, compose, currying, debounce, deepClone, formatTimer, insertStr, isType, setTimer, shallowClone, stringCase, throttle, transformGetParams };

package/dist/index.d.ts

@@ -0,0 +1,74 @@
+//#region src/clone.d.ts
+declare function shallowClone<T = any>(source: T): T;
+declare function deepClone(source: any, hash?: WeakMap<object, any>): any;
+//#endregion
+//#region src/types.d.ts
+type CaseType = 'upper' | 'lower';
+type CaseTypeTuple = [CaseType, CaseType];
+type FormatTimerFn = (cellValue: string | number | Date, formatType?: string) => string | TimerFormatObj;
+interface TimerFormatObj {
+  year: string;
+  month: string;
+  day: string;
+  hours: string;
+  minutes: string;
+  seconds: string;
+  week: string;
+  weekNum: string;
+}
+interface ThrottleOptions {
+  leading?: boolean;
+  trailing?: boolean;
+}
+//#endregion
+//#region src/others.d.ts
+declare function currying(fn: (...args: any[]) => any): (this: any, ...args: any[]) => any;
+declare function compose(...fns: ((...args: any[]) => any)[]): ((this: any, ...args: any[]) => any) | null;
+declare function insertStr(soure: string, start: number, newStr: string): string;
+declare function stringCase(soure: string, separa?: string[], cases?: CaseTypeTuple): string;
+declare const transformGetParams: (params: Record<string, any>) => string;
+//#endregion
+//#region src/retalimit.d.ts
+declare function debounce<T extends (...args: any[]) => any>(callback: T, delay?: number, immediate?: boolean): ((...args: Parameters<T>) => Promise<ReturnType<T>>) & {
+  cancel: () => void;
+};
+declare function throttle<T extends (...args: any[]) => any>(callback: T, interval: number, options?: ThrottleOptions): ((...args: Parameters<T>) => Promise<ReturnType<T>>) & {
+  cancel: () => void;
+};
+//#endregion
+//#region src/sort.d.ts
+declare enum SortType {
+  ASC = "ASC",
+  DESC = "DESC",
+}
+declare function bubblingSort<T>(array: T[], type?: string, key?: keyof T): T[];
+//#endregion
+//#region src/timer.d.ts
+declare const formatTimer: FormatTimerFn;
+declare function setTimer(execute: (...args: any[]) => any, delay?: number, immediate?: boolean): Promise<{
+  cancel: () => void;
+}>;
+//#endregion
+//#region src/typeof.d.ts
+declare const typeCheckRules: {
+  undefined: (target: unknown) => target is undefined;
+  null: (target: unknown) => target is null;
+  number: (target: unknown) => target is number;
+  string: (target: unknown) => target is string;
+  boolean: (target: unknown) => target is boolean;
+  symbol: (target: unknown) => target is symbol;
+  bigint: (target: unknown) => target is bigint;
+  object: (target: unknown) => target is object;
+  array: (target: unknown) => target is any[];
+  function: (target: unknown) => target is Function;
+  date: (target: unknown) => target is Date;
+  set: (target: unknown) => target is Set<any>;
+  map: (target: unknown) => target is Map<any, any>;
+  regexp: (target: unknown) => target is RegExp;
+  promise: (target: unknown) => target is Promise<any>;
+  empty(target: unknown): target is "";
+};
+type TypeCheckOption = keyof typeof typeCheckRules;
+declare const isType: (type: TypeCheckOption, target: unknown) => boolean;
+//#endregion
+export { SortType, bubblingSort, compose, currying, debounce, deepClone, formatTimer, insertStr, isType, setTimer, shallowClone, stringCase, throttle, transformGetParams };