@tanwan/utils 1.0.0 → 1.2.0

package/dist/setStyle.d.cts

@@ -0,0 +1,19 @@
+//#region src/dom/setStyle/index.d.ts
+/**
+* 批量设置元素行内样式
+*
+* @param el - DOM 元素
+* @param styles - 样式对象，属性名为 camelCase
+*
+* @example
+* ```ts
+* import setStyle from '@tanwan/utils/setStyle'
+* setStyle(el, {
+*   width: '100px',
+*   height: '200px',
+*   backgroundColor: 'red',
+* })
+* ```
+*/
+declare function setStyle(el: HTMLElement, styles: Record<string, string | number>): void;
+export = setStyle;

package/dist/setStyle.d.ts

@@ -0,0 +1,20 @@
+//#region src/dom/setStyle/index.d.ts
+/**
+* 批量设置元素行内样式
+*
+* @param el - DOM 元素
+* @param styles - 样式对象，属性名为 camelCase
+*
+* @example
+* ```ts
+* import setStyle from '@tanwan/utils/setStyle'
+* setStyle(el, {
+*   width: '100px',
+*   height: '200px',
+*   backgroundColor: 'red',
+* })
+* ```
+*/
+declare function setStyle(el: HTMLElement, styles: Record<string, string | number>): void;
+//#endregion
+export { setStyle as default };

package/dist/setStyle.js

@@ -0,0 +1,22 @@
+//#region src/dom/setStyle/index.ts
+/**
+* 批量设置元素行内样式
+*
+* @param el - DOM 元素
+* @param styles - 样式对象，属性名为 camelCase
+*
+* @example
+* ```ts
+* import setStyle from '@tanwan/utils/setStyle'
+* setStyle(el, {
+*   width: '100px',
+*   height: '200px',
+*   backgroundColor: 'red',
+* })
+* ```
+*/
+function setStyle(el, styles) {
+	for (const key of Object.keys(styles)) el.style[key] = String(styles[key]);
+}
+//#endregion
+export { setStyle as default };

package/dist/{array/shuffle.cjs → shuffle.cjs}

@@ -3,7 +3,7 @@
 * 数组洗牌（Fisher-Yates 算法）
 * @example
 * ```ts
-* import shuffle from '@tw/utils/shuffle'
+* import shuffle from '@tanwan/utils/shuffle'
 * shuffle([1, 2, 3, 4, 5]) // [3, 1, 5, 2, 4]（随机）
 * ```
 */

package/dist/{array/shuffle.d.cts → shuffle.d.cts}

@@ -3,10 +3,9 @@
 * 数组洗牌（Fisher-Yates 算法）
 * @example
 * ```ts
-* import shuffle from '@tw/utils/shuffle'
+* import shuffle from '@tanwan/utils/shuffle'
 * shuffle([1, 2, 3, 4, 5]) // [3, 1, 5, 2, 4]（随机）
 * ```
 */
 declare function shuffle<T>(arr: T[]): T[];
-export = shuffle;
-//# sourceMappingURL=shuffle.d.cts.map
+export = shuffle;

package/dist/{array/shuffle.d.ts → shuffle.d.ts}

@@ -3,11 +3,10 @@
 * 数组洗牌（Fisher-Yates 算法）
 * @example
 * ```ts
-* import shuffle from '@tw/utils/shuffle'
+* import shuffle from '@tanwan/utils/shuffle'
 * shuffle([1, 2, 3, 4, 5]) // [3, 1, 5, 2, 4]（随机）
 * ```
 */
 declare function shuffle<T>(arr: T[]): T[];
 //#endregion
-export { shuffle as default };
-//# sourceMappingURL=shuffle.d.ts.map
+export { shuffle as default };

package/dist/{array/shuffle.js → shuffle.js}

@@ -3,7 +3,7 @@
 * 数组洗牌（Fisher-Yates 算法）
 * @example
 * ```ts
-* import shuffle from '@tw/utils/shuffle'
+* import shuffle from '@tanwan/utils/shuffle'
 * shuffle([1, 2, 3, 4, 5]) // [3, 1, 5, 2, 4]（随机）
 * ```
 */
@@ -17,5 +17,3 @@ function shuffle(arr) {
 }
 //#endregion
 export { shuffle as default };
-
-//# sourceMappingURL=shuffle.js.map

package/dist/snakeCase.cjs

@@ -0,0 +1,18 @@
+//#region src/string/snakeCase/index.ts
+/**
+* 将字符串转换为蛇形命名（snake_case）
+*
+* @example
+* ```ts
+* import snakeCase from '@tanwan/utils/snakeCase'
+* snakeCase('fooBar')     // 'foo_bar'
+* snakeCase('FooBarBaz')  // 'foo_bar_baz'
+* snakeCase('foo-bar')    // 'foo_bar'
+* snakeCase('foo bar')    // 'foo_bar'
+* ```
+*/
+function snakeCase(str) {
+	return str.replace(/[A-Z]/g, (letter, index) => index === 0 ? letter : "_" + letter).replace(/[-_\s]+/g, "_").toLowerCase();
+}
+//#endregion
+module.exports = snakeCase;

package/dist/snakeCase.d.cts

@@ -0,0 +1,15 @@
+//#region src/string/snakeCase/index.d.ts
+/**
+* 将字符串转换为蛇形命名（snake_case）
+*
+* @example
+* ```ts
+* import snakeCase from '@tanwan/utils/snakeCase'
+* snakeCase('fooBar')     // 'foo_bar'
+* snakeCase('FooBarBaz')  // 'foo_bar_baz'
+* snakeCase('foo-bar')    // 'foo_bar'
+* snakeCase('foo bar')    // 'foo_bar'
+* ```
+*/
+declare function snakeCase(str: string): string;
+export = snakeCase;

package/dist/snakeCase.d.ts

@@ -0,0 +1,16 @@
+//#region src/string/snakeCase/index.d.ts
+/**
+* 将字符串转换为蛇形命名（snake_case）
+*
+* @example
+* ```ts
+* import snakeCase from '@tanwan/utils/snakeCase'
+* snakeCase('fooBar')     // 'foo_bar'
+* snakeCase('FooBarBaz')  // 'foo_bar_baz'
+* snakeCase('foo-bar')    // 'foo_bar'
+* snakeCase('foo bar')    // 'foo_bar'
+* ```
+*/
+declare function snakeCase(str: string): string;
+//#endregion
+export { snakeCase as default };

package/dist/snakeCase.js

@@ -0,0 +1,18 @@
+//#region src/string/snakeCase/index.ts
+/**
+* 将字符串转换为蛇形命名（snake_case）
+*
+* @example
+* ```ts
+* import snakeCase from '@tanwan/utils/snakeCase'
+* snakeCase('fooBar')     // 'foo_bar'
+* snakeCase('FooBarBaz')  // 'foo_bar_baz'
+* snakeCase('foo-bar')    // 'foo_bar'
+* snakeCase('foo bar')    // 'foo_bar'
+* ```
+*/
+function snakeCase(str) {
+	return str.replace(/[A-Z]/g, (letter, index) => index === 0 ? letter : "_" + letter).replace(/[-_\s]+/g, "_").toLowerCase();
+}
+//#endregion
+export { snakeCase as default };

package/dist/sortBy.cjs

@@ -0,0 +1,30 @@
+//#region src/array/sortBy/index.ts
+/**
+* 按指定属性或迭代函数对数组排序（升序）
+*
+* @param arr - 待排序数组
+* @param iteratee - 排序依据：属性名或返回排序值的函数
+* @returns 排序后的新数组
+*
+* @example
+* ```ts
+* import sortBy from '@tanwan/utils/sortBy'
+* sortBy([{ age: 30 }, { age: 20 }], 'age')
+* // [{ age: 20 }, { age: 30 }]
+*
+* sortBy(['apple', 'banana', 'cherry'], (s) => s.length)
+* // ['apple', 'cherry', 'banana']
+* ```
+*/
+function sortBy(arr, iteratee) {
+	const getValue = typeof iteratee === "function" ? iteratee : (item) => item[iteratee];
+	return [...arr].sort((a, b) => {
+		const va = getValue(a);
+		const vb = getValue(b);
+		if (va < vb) return -1;
+		if (va > vb) return 1;
+		return 0;
+	});
+}
+//#endregion
+module.exports = sortBy;

package/dist/sortBy.d.cts

@@ -0,0 +1,20 @@
+//#region src/array/sortBy/index.d.ts
+/**
+* 按指定属性或迭代函数对数组排序（升序）
+*
+* @param arr - 待排序数组
+* @param iteratee - 排序依据：属性名或返回排序值的函数
+* @returns 排序后的新数组
+*
+* @example
+* ```ts
+* import sortBy from '@tanwan/utils/sortBy'
+* sortBy([{ age: 30 }, { age: 20 }], 'age')
+* // [{ age: 20 }, { age: 30 }]
+*
+* sortBy(['apple', 'banana', 'cherry'], (s) => s.length)
+* // ['apple', 'cherry', 'banana']
+* ```
+*/
+declare function sortBy<T>(arr: T[], iteratee: keyof T | ((item: T) => number | string)): T[];
+export = sortBy;

package/dist/sortBy.d.ts

@@ -0,0 +1,21 @@
+//#region src/array/sortBy/index.d.ts
+/**
+* 按指定属性或迭代函数对数组排序（升序）
+*
+* @param arr - 待排序数组
+* @param iteratee - 排序依据：属性名或返回排序值的函数
+* @returns 排序后的新数组
+*
+* @example
+* ```ts
+* import sortBy from '@tanwan/utils/sortBy'
+* sortBy([{ age: 30 }, { age: 20 }], 'age')
+* // [{ age: 20 }, { age: 30 }]
+*
+* sortBy(['apple', 'banana', 'cherry'], (s) => s.length)
+* // ['apple', 'cherry', 'banana']
+* ```
+*/
+declare function sortBy<T>(arr: T[], iteratee: keyof T | ((item: T) => number | string)): T[];
+//#endregion
+export { sortBy as default };

package/dist/sortBy.js

@@ -0,0 +1,30 @@
+//#region src/array/sortBy/index.ts
+/**
+* 按指定属性或迭代函数对数组排序（升序）
+*
+* @param arr - 待排序数组
+* @param iteratee - 排序依据：属性名或返回排序值的函数
+* @returns 排序后的新数组
+*
+* @example
+* ```ts
+* import sortBy from '@tanwan/utils/sortBy'
+* sortBy([{ age: 30 }, { age: 20 }], 'age')
+* // [{ age: 20 }, { age: 30 }]
+*
+* sortBy(['apple', 'banana', 'cherry'], (s) => s.length)
+* // ['apple', 'cherry', 'banana']
+* ```
+*/
+function sortBy(arr, iteratee) {
+	const getValue = typeof iteratee === "function" ? iteratee : (item) => item[iteratee];
+	return [...arr].sort((a, b) => {
+		const va = getValue(a);
+		const vb = getValue(b);
+		if (va < vb) return -1;
+		if (va > vb) return 1;
+		return 0;
+	});
+}
+//#endregion
+export { sortBy as default };

package/dist/stringifyQueryString.cjs

@@ -0,0 +1,38 @@
+//#region src/url/stringifyQueryString/index.ts
+/**
+* 将对象序列化为 URL 查询字符串
+*
+* 支持嵌套对象用 `encodeURIComponent` 编码，数组值生成重复 key
+*
+* @param params - 要序列化的键值对对象
+* @returns 查询字符串（不含前导 `?`），无参数时返回空字符串
+*
+* @example
+* ```ts
+* import stringifyQueryString from '@tanwan/utils/stringifyQueryString'
+* stringifyQueryString({ name: 'John', age: 25 })     // 'name=John&age=25'
+* stringifyQueryString({ ids: [1, 2, 3] })            // 'ids=1&ids=2&ids=3'
+* stringifyQueryString({ q: 'hello world' })          // 'q=hello%20world'
+* stringifyQueryString({ a: null, b: undefined })     // 'a='
+* stringifyQueryString({})                            // ''
+* ```
+*/
+function stringifyQueryString(params) {
+	const parts = [];
+	for (const key of Object.keys(params)) {
+		const value = params[key];
+		if (value === void 0) continue;
+		if (value === null) {
+			parts.push(`${encodeURIComponent(key)}=`);
+			continue;
+		}
+		if (Array.isArray(value)) {
+			for (const item of value) parts.push(`${encodeURIComponent(key)}=${encodeURIComponent(String(item))}`);
+			continue;
+		}
+		parts.push(`${encodeURIComponent(key)}=${encodeURIComponent(String(value))}`);
+	}
+	return parts.join("&");
+}
+//#endregion
+module.exports = stringifyQueryString;

package/dist/stringifyQueryString.d.cts

@@ -0,0 +1,21 @@
+//#region src/url/stringifyQueryString/index.d.ts
+/**
+* 将对象序列化为 URL 查询字符串
+*
+* 支持嵌套对象用 `encodeURIComponent` 编码，数组值生成重复 key
+*
+* @param params - 要序列化的键值对对象
+* @returns 查询字符串（不含前导 `?`），无参数时返回空字符串
+*
+* @example
+* ```ts
+* import stringifyQueryString from '@tanwan/utils/stringifyQueryString'
+* stringifyQueryString({ name: 'John', age: 25 })     // 'name=John&age=25'
+* stringifyQueryString({ ids: [1, 2, 3] })            // 'ids=1&ids=2&ids=3'
+* stringifyQueryString({ q: 'hello world' })          // 'q=hello%20world'
+* stringifyQueryString({ a: null, b: undefined })     // 'a='
+* stringifyQueryString({})                            // ''
+* ```
+*/
+declare function stringifyQueryString(params: Record<string, unknown>): string;
+export = stringifyQueryString;

package/dist/stringifyQueryString.d.ts

@@ -0,0 +1,22 @@
+//#region src/url/stringifyQueryString/index.d.ts
+/**
+* 将对象序列化为 URL 查询字符串
+*
+* 支持嵌套对象用 `encodeURIComponent` 编码，数组值生成重复 key
+*
+* @param params - 要序列化的键值对对象
+* @returns 查询字符串（不含前导 `?`），无参数时返回空字符串
+*
+* @example
+* ```ts
+* import stringifyQueryString from '@tanwan/utils/stringifyQueryString'
+* stringifyQueryString({ name: 'John', age: 25 })     // 'name=John&age=25'
+* stringifyQueryString({ ids: [1, 2, 3] })            // 'ids=1&ids=2&ids=3'
+* stringifyQueryString({ q: 'hello world' })          // 'q=hello%20world'
+* stringifyQueryString({ a: null, b: undefined })     // 'a='
+* stringifyQueryString({})                            // ''
+* ```
+*/
+declare function stringifyQueryString(params: Record<string, unknown>): string;
+//#endregion
+export { stringifyQueryString as default };

package/dist/stringifyQueryString.js

@@ -0,0 +1,38 @@
+//#region src/url/stringifyQueryString/index.ts
+/**
+* 将对象序列化为 URL 查询字符串
+*
+* 支持嵌套对象用 `encodeURIComponent` 编码，数组值生成重复 key
+*
+* @param params - 要序列化的键值对对象
+* @returns 查询字符串（不含前导 `?`），无参数时返回空字符串
+*
+* @example
+* ```ts
+* import stringifyQueryString from '@tanwan/utils/stringifyQueryString'
+* stringifyQueryString({ name: 'John', age: 25 })     // 'name=John&age=25'
+* stringifyQueryString({ ids: [1, 2, 3] })            // 'ids=1&ids=2&ids=3'
+* stringifyQueryString({ q: 'hello world' })          // 'q=hello%20world'
+* stringifyQueryString({ a: null, b: undefined })     // 'a='
+* stringifyQueryString({})                            // ''
+* ```
+*/
+function stringifyQueryString(params) {
+	const parts = [];
+	for (const key of Object.keys(params)) {
+		const value = params[key];
+		if (value === void 0) continue;
+		if (value === null) {
+			parts.push(`${encodeURIComponent(key)}=`);
+			continue;
+		}
+		if (Array.isArray(value)) {
+			for (const item of value) parts.push(`${encodeURIComponent(key)}=${encodeURIComponent(String(item))}`);
+			continue;
+		}
+		parts.push(`${encodeURIComponent(key)}=${encodeURIComponent(String(value))}`);
+	}
+	return parts.join("&");
+}
+//#endregion
+export { stringifyQueryString as default };

package/dist/{function/throttle.cjs → throttle.cjs}

@@ -3,7 +3,7 @@
 * 节流函数
 * @example
 * ```ts
-* import throttle from '@tw/utils/throttle'
+* import throttle from '@tanwan/utils/throttle'
 * const onScroll = throttle(() => {
 *   console.log('滚动事件触发')
 * }, 200)

package/dist/{function/throttle.d.cts → throttle.d.cts}

@@ -3,12 +3,11 @@
 * 节流函数
 * @example
 * ```ts
-* import throttle from '@tw/utils/throttle'
+* import throttle from '@tanwan/utils/throttle'
 * const onScroll = throttle(() => {
 *   console.log('滚动事件触发')
 * }, 200)
 * ```
 */
 declare function throttle<T extends (...args: any[]) => any>(func: T, wait: number): (...args: Parameters<T>) => void;
-export = throttle;
-//# sourceMappingURL=throttle.d.cts.map
+export = throttle;

package/dist/{function/throttle.d.ts → throttle.d.ts}

@@ -3,7 +3,7 @@
 * 节流函数
 * @example
 * ```ts
-* import throttle from '@tw/utils/throttle'
+* import throttle from '@tanwan/utils/throttle'
 * const onScroll = throttle(() => {
 *   console.log('滚动事件触发')
 * }, 200)
@@ -11,5 +11,4 @@
 */
 declare function throttle<T extends (...args: any[]) => any>(func: T, wait: number): (...args: Parameters<T>) => void;
 //#endregion
-export { throttle as default };
-//# sourceMappingURL=throttle.d.ts.map
+export { throttle as default };

package/dist/{function/throttle.js → throttle.js}

@@ -3,7 +3,7 @@
 * 节流函数
 * @example
 * ```ts
-* import throttle from '@tw/utils/throttle'
+* import throttle from '@tanwan/utils/throttle'
 * const onScroll = throttle(() => {
 *   console.log('滚动事件触发')
 * }, 200)
@@ -26,5 +26,3 @@ function throttle(func, wait) {
 }
 //#endregion
 export { throttle as default };
-
-//# sourceMappingURL=throttle.js.map

package/dist/toggleClass.cjs

@@ -0,0 +1,22 @@
+//#region src/dom/toggleClass/index.ts
+/**
+* 切换元素的 CSS class
+*
+* @param el - DOM 元素
+* @param className - 要切换的 class
+* @param force - 可选，强制添加（true）或移除（false）
+* @returns 切换后 class 是否存在
+*
+* @example
+* ```ts
+* import toggleClass from '@tanwan/utils/toggleClass'
+* toggleClass(el, 'active')
+* toggleClass(el, 'active', true)  // 强制添加
+* toggleClass(el, 'active', false) // 强制移除
+* ```
+*/
+function toggleClass(el, className, force) {
+	return el.classList.toggle(className, force);
+}
+//#endregion
+module.exports = toggleClass;

package/dist/toggleClass.d.cts

@@ -0,0 +1,19 @@
+//#region src/dom/toggleClass/index.d.ts
+/**
+* 切换元素的 CSS class
+*
+* @param el - DOM 元素
+* @param className - 要切换的 class
+* @param force - 可选，强制添加（true）或移除（false）
+* @returns 切换后 class 是否存在
+*
+* @example
+* ```ts
+* import toggleClass from '@tanwan/utils/toggleClass'
+* toggleClass(el, 'active')
+* toggleClass(el, 'active', true)  // 强制添加
+* toggleClass(el, 'active', false) // 强制移除
+* ```
+*/
+declare function toggleClass(el: Element, className: string, force?: boolean): boolean;
+export = toggleClass;

package/dist/toggleClass.d.ts

@@ -0,0 +1,20 @@
+//#region src/dom/toggleClass/index.d.ts
+/**
+* 切换元素的 CSS class
+*
+* @param el - DOM 元素
+* @param className - 要切换的 class
+* @param force - 可选，强制添加（true）或移除（false）
+* @returns 切换后 class 是否存在
+*
+* @example
+* ```ts
+* import toggleClass from '@tanwan/utils/toggleClass'
+* toggleClass(el, 'active')
+* toggleClass(el, 'active', true)  // 强制添加
+* toggleClass(el, 'active', false) // 强制移除
+* ```
+*/
+declare function toggleClass(el: Element, className: string, force?: boolean): boolean;
+//#endregion
+export { toggleClass as default };

package/dist/toggleClass.js

@@ -0,0 +1,22 @@
+//#region src/dom/toggleClass/index.ts
+/**
+* 切换元素的 CSS class
+*
+* @param el - DOM 元素
+* @param className - 要切换的 class
+* @param force - 可选，强制添加（true）或移除（false）
+* @returns 切换后 class 是否存在
+*
+* @example
+* ```ts
+* import toggleClass from '@tanwan/utils/toggleClass'
+* toggleClass(el, 'active')
+* toggleClass(el, 'active', true)  // 强制添加
+* toggleClass(el, 'active', false) // 强制移除
+* ```
+*/
+function toggleClass(el, className, force) {
+	return el.classList.toggle(className, force);
+}
+//#endregion
+export { toggleClass as default };

package/dist/treeFind.cjs

@@ -0,0 +1,34 @@
+//#region src/tree/treeFind/index.ts
+/**
+* 在树结构中查找节点（深度优先）
+*
+* @param tree - 树结构数组
+* @param predicate - 匹配函数
+* @param options - 配置项
+* @param options.children - 子节点属性名，默认 `'children'`
+* @returns 第一个匹配的节点，未找到返回 `undefined`
+*
+* @example
+* ```ts
+* import treeFind from '@tanwan/utils/treeFind'
+* const tree = [
+*   { id: 1, children: [{ id: 2 }] },
+*   { id: 3, children: [] },
+* ]
+* treeFind(tree, (node) => node.id === 2)
+* // { id: 2 }
+* ```
+*/
+function treeFind(tree, predicate, options = {}) {
+	const { children = "children" } = options;
+	for (const node of tree) {
+		if (predicate(node)) return node;
+		const childNodes = node[children];
+		if (Array.isArray(childNodes)) {
+			const found = treeFind(childNodes, predicate, options);
+			if (found) return found;
+		}
+	}
+}
+//#endregion
+module.exports = treeFind;

package/dist/treeFind.d.cts

@@ -0,0 +1,25 @@
+//#region src/tree/treeFind/index.d.ts
+/**
+* 在树结构中查找节点（深度优先）
+*
+* @param tree - 树结构数组
+* @param predicate - 匹配函数
+* @param options - 配置项
+* @param options.children - 子节点属性名，默认 `'children'`
+* @returns 第一个匹配的节点，未找到返回 `undefined`
+*
+* @example
+* ```ts
+* import treeFind from '@tanwan/utils/treeFind'
+* const tree = [
+*   { id: 1, children: [{ id: 2 }] },
+*   { id: 3, children: [] },
+* ]
+* treeFind(tree, (node) => node.id === 2)
+* // { id: 2 }
+* ```
+*/
+declare function treeFind<T extends Record<string, unknown>>(tree: T[], predicate: (node: T) => boolean, options?: {
+  children?: string;
+}): T | undefined;
+export = treeFind;

package/dist/treeFind.d.ts

@@ -0,0 +1,26 @@
+//#region src/tree/treeFind/index.d.ts
+/**
+* 在树结构中查找节点（深度优先）
+*
+* @param tree - 树结构数组
+* @param predicate - 匹配函数
+* @param options - 配置项
+* @param options.children - 子节点属性名，默认 `'children'`
+* @returns 第一个匹配的节点，未找到返回 `undefined`
+*
+* @example
+* ```ts
+* import treeFind from '@tanwan/utils/treeFind'
+* const tree = [
+*   { id: 1, children: [{ id: 2 }] },
+*   { id: 3, children: [] },
+* ]
+* treeFind(tree, (node) => node.id === 2)
+* // { id: 2 }
+* ```
+*/
+declare function treeFind<T extends Record<string, unknown>>(tree: T[], predicate: (node: T) => boolean, options?: {
+  children?: string;
+}): T | undefined;
+//#endregion
+export { treeFind as default };