@pawover/kit 0.0.0-alpha.1

package/dist/utils/tree/treeForEach.js

@@ -0,0 +1,60 @@
+import { isArray } from "../typeof";
+import { getFinalChildrenKey } from "./types";
+const strategies = { pre: preImpl, post: postImpl, breadth: breadthImpl };
+// 前置遍历
+function preImpl(row, callback, options) {
+    callback(row, options);
+    const finalChildrenKey = getFinalChildrenKey(row, options, options);
+    const children = row[finalChildrenKey];
+    if (isArray(children)) {
+        const nextLevelOptions = { ...options, parents: [...options.parents, row], depth: options.depth + 1 };
+        for (const child of children) {
+            preImpl(child, callback, nextLevelOptions);
+        }
+    }
+}
+// 后置遍历
+function postImpl(row, callback, options) {
+    const finalChildrenKey = getFinalChildrenKey(row, options, options);
+    const children = row[finalChildrenKey];
+    if (isArray(children)) {
+        const nextLevelOptions = { ...options, parents: [...options.parents, row], depth: options.depth + 1 };
+        for (const child of children) {
+            postImpl(child, callback, nextLevelOptions);
+        }
+    }
+    callback(row, options);
+}
+// 广度优先遍历
+function breadthImpl(row, callback, options) {
+    const queue = [{ queueRow: row, queueOptions: options }];
+    const runQueue = () => {
+        if (queue.length === 0) {
+            return;
+        }
+        const { queueRow, queueOptions } = queue.shift();
+        const finalChildrenKey = getFinalChildrenKey(queueRow, queueOptions, queueOptions);
+        const children = queueRow[finalChildrenKey];
+        if (isArray(children)) {
+            const nextLevelOptions = { ...queueOptions, parents: [...queueOptions.parents, queueRow], depth: queueOptions.depth + 1 };
+            const subQueueItems = children.map((queueRow) => ({ queueRow, queueOptions: nextLevelOptions }));
+            queue.push(...subQueueItems);
+        }
+        callback(queueRow, queueOptions);
+        runQueue();
+    };
+    runQueue();
+}
+export function treeForEach(tree, callback, options = {}) {
+    const { childrenKey = "children", strategy = "pre", getChildrenKey } = options;
+    const traversalMethod = strategies[strategy];
+    const innerOptions = { childrenKey: childrenKey, depth: 0, parents: [], getChildrenKey };
+    if (isArray(tree)) {
+        for (const row of tree) {
+            traversalMethod(row, callback, innerOptions);
+        }
+    }
+    else {
+        traversalMethod(tree, callback, innerOptions);
+    }
+}

package/dist/utils/tree/treeMap.js

@@ -0,0 +1,79 @@
+import { arrayLast } from "../array";
+import { isArray } from "../typeof";
+import { getFinalChildrenKey } from "./types";
+const strategies = { pre: preImpl, post: postImpl, breadth: breadthImpl };
+// 前置遍历
+function preImpl(row, callback, options) {
+    const finalChildrenKey = getFinalChildrenKey(row, options, options);
+    const result = callback(row, options);
+    const children = row[finalChildrenKey];
+    let newChildren;
+    if (isArray(children)) {
+        const nextLevelOptions = { ...options, parents: [...options.parents, row], depth: options.depth + 1 };
+        newChildren = children.map((c) => preImpl(c, callback, nextLevelOptions));
+    }
+    return { ...result, [finalChildrenKey]: newChildren };
+}
+// 子节点优先遍历
+function postImpl(row, callback, options) {
+    const finalChildrenKey = getFinalChildrenKey(row, options, options);
+    const children = row[finalChildrenKey];
+    let newChildren;
+    if (isArray(children)) {
+        const nextLevelOptions = { ...options, parents: [...options.parents, row], depth: options.depth + 1 };
+        newChildren = children.map((c) => postImpl(c, callback, nextLevelOptions));
+    }
+    const result = callback(row, options);
+    return { ...result, [finalChildrenKey]: newChildren };
+}
+// 广度优先遍历
+function breadthImpl(row, callback, options) {
+    const queue = [{ queueRow: row, queueOptions: options }];
+    const cache = new WeakMap();
+    const childrenKeyCache = new WeakMap();
+    let result;
+    const runQueue = () => {
+        if (queue.length === 0) {
+            return result;
+        }
+        const { queueRow, queueOptions } = queue.shift();
+        const finalChildrenKey = getFinalChildrenKey(queueRow, queueOptions, queueOptions);
+        const children = queueRow[finalChildrenKey];
+        if (isArray(children)) {
+            const nextLevelOptions = { ...queueOptions, parents: [...queueOptions.parents, queueRow], depth: queueOptions.depth + 1 };
+            const subQueueItems = children.map((queueRow) => ({ queueRow, queueOptions: nextLevelOptions }));
+            queue.push(...subQueueItems);
+        }
+        const res = callback(queueRow, queueOptions);
+        cache.set(queueRow, res);
+        childrenKeyCache.set(queueRow, finalChildrenKey);
+        // breadth 模式的子节点一定晚于父节点执行，所以可以在cache中找到父节点的生成物
+        const parent = arrayLast(queueOptions.parents);
+        if (parent) {
+            const newParent = cache.get(parent);
+            const parentChildrenKey = childrenKeyCache.get(parent);
+            if (newParent && parentChildrenKey) {
+                if (newParent[parentChildrenKey]) {
+                    newParent[parentChildrenKey].push(res);
+                }
+                else {
+                    newParent[parentChildrenKey] = [res];
+                }
+            }
+        }
+        // 这棵树的顶点
+        if (queueOptions.depth === 0) {
+            result = res;
+        }
+        return runQueue();
+    };
+    return runQueue();
+}
+export function treeMap(tree, callback, options = {}) {
+    const { childrenKey = "children", strategy = "pre", getChildrenKey } = options;
+    const traversalMethod = strategies[strategy];
+    const innerOptions = { childrenKey: childrenKey, depth: 0, parents: [], getChildrenKey };
+    return isArray(tree)
+        ? tree.map((row) => traversalMethod(row, callback, innerOptions))
+        : traversalMethod(tree, callback, innerOptions);
+}

package/dist/utils/tree/treeToRows.js

@@ -0,0 +1,13 @@
+import { treeForEach } from "./treeForEach";
+/**
+ * 树结构 转 行结构
+ */
+export function treeToRows(tree, options = {}) {
+    const { childrenKey = "children" } = options;
+    const result = [];
+    if (!tree) {
+        return result;
+    }
+    treeForEach(tree, (t) => result.push({ ...t, [childrenKey]: undefined }), options);
+    return result;
+}

package/dist/utils/tree/types.js

@@ -0,0 +1,10 @@
+import { isFunction } from "../typeof";
+export function getFinalChildrenKey(tree, meta, options) {
+    if (isFunction(options.getChildrenKey)) {
+        const dynamicChildrenKey = options.getChildrenKey(tree, meta);
+        if (dynamicChildrenKey && dynamicChildrenKey !== null) {
+            return dynamicChildrenKey;
+        }
+    }
+    return options.childrenKey;
+}

package/dist/utils/typeof.js

@@ -0,0 +1,114 @@
+const prototypes = {
+    string: "[object String]",
+    number: "[object Number]",
+    boolean: "[object Boolean]",
+    object: "[object Object]",
+    array: "[object Array]",
+    bigInt: "[object BigInt]",
+    symbol: "[object Symbol]",
+    function: "[object Function]",
+    generatorFunction: "[object GeneratorFunction]",
+    asyncFunction: "[object AsyncFunction]",
+    promise: "[object Promise]",
+    null: "[object Null]",
+    undefined: "[object Undefined]",
+    date: "[object Date]",
+    regExp: "[object RegExp]",
+    error: "[object Error]",
+    file: "[object File]",
+    map: "[object Map]",
+    weakMap: "[object WeakMap]",
+    set: "[object Set]",
+    weakSet: "[object WeakSet]",
+    window: "[object Window]",
+    webSocket: "[object WebSocket]",
+    URLSearchParams: "[object URLSearchParams]",
+};
+function resolvePrototypeString(value) {
+    return Object.prototype.toString.call(value);
+}
+export function isString(value) {
+    return resolvePrototypeString(value) === prototypes.string;
+}
+export function isNumber(value) {
+    return resolvePrototypeString(value) === prototypes.number;
+}
+export function isBoolean(value) {
+    return resolvePrototypeString(value) === prototypes.boolean;
+}
+export function isObject(value) {
+    return resolvePrototypeString(value) === prototypes.object;
+}
+export function isArray(value) {
+    return resolvePrototypeString(value) === prototypes.array;
+}
+export function isBigInt(value) {
+    return resolvePrototypeString(value) === prototypes.bigInt;
+}
+export function isSymbol(value) {
+    return resolvePrototypeString(value) === prototypes.symbol;
+}
+export function isFunction(value) {
+    const prototypeList = [prototypes.function, prototypes.generatorFunction, prototypes.asyncFunction];
+    return prototypeList.includes(resolvePrototypeString(value));
+}
+export function isGeneratorFunction(value) {
+    return resolvePrototypeString(value) === prototypes.generatorFunction;
+}
+export function isAsyncFunction(value) {
+    return resolvePrototypeString(value) === prototypes.asyncFunction;
+}
+export function isPromise(value) {
+    return resolvePrototypeString(value) === prototypes.promise;
+}
+export function isPromiseLike(value) {
+    return isPromise(value) || (isObject(value) && isFunction(value["then"]));
+}
+export function isNull(value) {
+    return resolvePrototypeString(value) === prototypes.null;
+}
+export function isUndefined(value) {
+    return resolvePrototypeString(value) === prototypes.undefined;
+}
+export function isDate(value) {
+    return resolvePrototypeString(value) === prototypes.date;
+}
+export function isRegExp(value) {
+    return resolvePrototypeString(value) === prototypes.regExp;
+}
+export function isError(value) {
+    return resolvePrototypeString(value) === prototypes.error;
+}
+export function isFile(value) {
+    return resolvePrototypeString(value) === prototypes.file;
+}
+export function isMap(value) {
+    return resolvePrototypeString(value) === prototypes.map;
+}
+export function isWeakMap(value) {
+    return resolvePrototypeString(value) === prototypes.weakMap;
+}
+export function isSet(value) {
+    return resolvePrototypeString(value) === prototypes.set;
+}
+export function isWeakSet(value) {
+    return resolvePrototypeString(value) === prototypes.weakSet;
+}
+export function isWindow(value) {
+    return resolvePrototypeString(value) === prototypes.window;
+}
+export function isWebSocket(value) {
+    return resolvePrototypeString(value) === prototypes.webSocket;
+}
+export function isURLSearchParams(value) {
+    return resolvePrototypeString(value) === prototypes.URLSearchParams;
+}
+export function isClass(value) {
+    return resolvePrototypeString(value).startsWith("class ");
+}
+export function isInteger(value) {
+    return Number.isInteger(value);
+}
+export function isIterable(value) {
+    return isObject(value) && Symbol.iterator in value;
+}

package/package.json

@@ -0,0 +1,90 @@
+{
+  "name": "@pawover/kit",
+  "author": "pawover<pawover@outlook.com>",
+  "description": "pawover's kit",
+  "license": "MIT",
+  "type": "module",
+  "version": "0.0.0-alpha.1",
+  "packageManager": "pnpm@10.20.0",
+  "engines": {
+    "node": ">=22.20.0"
+  },
+  "keywords": [
+    "pawover",
+    "pawover-kit"
+  ],
+  "homepage": "https://github.com/pawover/pawover-kit#readme",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/pawover/pawover-kit.git"
+  },
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "dist/types/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/types/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    },
+    "./*": {
+      "types": "./dist/types/*.d.ts",
+      "import": "./dist/*.js",
+      "default": "./dist/*.js"
+    }
+  },
+  "scripts": {
+    "build": "tsc",
+    "public": "pnpm build && npm publish --access public",
+    "check": "pnpm check:types & pnpm check:eslint & pnpm check:format",
+    "check:types": "tsc --noEmit",
+    "check:eslint": "eslint --fix \"**/*.{js,cjs,mjs,ts,cts,mts,jsx,tsx,vue}\" --cache-location=eslint.cache.json --cache",
+    "check:format": "prettier --write \"**/*.{html,json}\" !.vscode/settings.json --cache-location=prettier.cache.json --cache",
+    "check:pack": "attw --pack .",
+    "clean": "pnpm clean:cache & pnpm clean:lib & pnpm clean:output",
+    "clean:cache": "rimraf -g **/*.cache.json **/auto-*.json **/auto-*.d.ts",
+    "clean:lib": "rimraf -g **/node_modules",
+    "clean:output": "rimraf dist",
+    "lib:up": "taze -I -r --exclude pnpm"
+  },
+  "devDependencies": {
+    "@pawover/eslint-rules": "0.0.0-alpha.3",
+    "@pawover/types": "0.0.0-alpha.6",
+    "@stylistic/eslint-plugin": "^5.5.0",
+    "@types/node": "^24.10.1",
+    "@types/react": "^19.2.4",
+    "ahooks": "^3.9.6",
+    "eslint": "^9.39.1",
+    "eslint-plugin-antfu": "^3.1.1",
+    "globals": "^16.5.0",
+    "prettier": "^3.6.2",
+    "radashi": "^12.7.0",
+    "react": "^19.2.0",
+    "rimraf": "^6.1.0",
+    "taze": "^19.9.0",
+    "type-fest": "^5.2.0",
+    "typescript": "^5.9.3",
+    "typescript-eslint": "^8.46.4",
+    "vue": "^3.5.24"
+  },
+  "peerDependencies": {
+    "ahooks": ">=3.9.6",
+    "radashi": ">=12.7.0",
+    "react": ">=19.2.0",
+    "vue": ">=3.5.24"
+  },
+  "peerDependenciesMeta": {
+    "ahooks": {
+      "optional": true
+    },
+    "react": {
+      "optional": true
+    },
+    "vue": {
+      "optional": true
+    }
+  }
+}