@zhouyihang/js-kit 1.0.0

package/README.md

@@ -0,0 +1,64 @@
+# @yihang/js-kit
+
+A long-lasting JavaScript toolkit — polyfills, utilities, design patterns, framework internals, algorithms, and data structures.
+
+## Install
+
+```bash
+npm install @yihang/js-kit
+```
+
+## Usage
+
+```js
+// import everything
+import { debounce, deepClone, quickSort, Queue, curry } from "@yihang/js-kit";
+
+// or from sub-paths
+import { debounce, throttle } from "@yihang/js-kit/utils";
+import { reactive, effect } from "@yihang/js-kit/framework";
+import { twoSum, quickSort } from "@yihang/js-kit/algorithms";
+import { MyPromise } from "@yihang/js-kit/polyfills";
+```
+
+## Modules
+
+### Polyfills — `@yihang/js-kit/polyfills`
+
+`myCall` `myApply` `myBind` `applyPolyfills` `myNew` `deepClone` `deepFreeze` `jsonStringify` `MyPromise` `promiseAll` `promiseRace` `promiseAllSettled` `promiseAny` `createIterator`
+
+### Utilities — `@yihang/js-kit/utils`
+
+`debounce` `throttle` `flatten` `flattenReduce` `flattenDeep` `mergeArr` `chunkArr` `formatSizeUnits` `parseUrl` `makeTree` `toTree` `asyncPool`
+
+### Design Patterns — `@yihang/js-kit/patterns`
+
+`Singleton` `Storage` `PubSub` `createProxyObj`
+
+### Framework — `@yihang/js-kit/framework`
+
+`reactive` `effect` `h` `mount` `HashRouter` `HistoryRouter`
+
+### Algorithms — `@yihang/js-kit/algorithms`
+
+`twoSum` `threeSum` `myAtoi` `WordDictionary` `removeDuplicateLetters` `removeKdigits` `validParentheses` `quickSort` `insertionSort` `selectionSort` `bubbleSort` `shellSort` `mergeSort` `countingSort`
+
+### Data Structures — `@yihang/js-kit/data-structures`
+
+`Queue`
+
+### DOM — `@yihang/js-kit/dom`
+
+`traverseElRoot`
+
+### JavaScript Basics — `@yihang/js-kit/javascript`
+
+`curry` `inherit`
+
+### Types — `@yihang/js-kit/types`
+
+`NestedArray<T>`
+
+## License
+
+MIT

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "@zhouyihang/js-kit",
+  "version": "1.0.0",
+  "description": "A long-lasting JavaScript toolkit — polyfills, utilities, design patterns, framework internals, algorithms, and data structures",
+  "type": "module",
+  "main": "src/index.js",
+  "types": "src/types/index.d.ts",
+  "exports": {
+    ".": "./src/index.js",
+    "./polyfills": "./src/polyfills/index.js",
+    "./utils": "./src/utils/index.js",
+    "./patterns": "./src/patterns/index.js",
+    "./framework": "./src/framework/index.js",
+    "./algorithms": "./src/algorithms/index.js",
+    "./data-structures": "./src/data-structures/index.js",
+    "./dom": "./src/dom/index.js",
+    "./javascript": "./src/javascript/index.js",
+    "./types": "./src/types/index.d.ts"
+  },
+  "files": [
+    "src/"
+  ],
+  "keywords": [
+    "javascript",
+    "toolkit",
+    "polyfills",
+    "algorithms",
+    "design-patterns",
+    "utilities",
+    "data-structures",
+    "debounce",
+    "throttle",
+    "deep-clone",
+    "promise",
+    "sorting",
+    "curry"
+  ],
+  "author": "YiHang",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/yihang/js-kit.git"
+  },
+  "packageManager": "pnpm@10.17.1"
+}

package/src/algorithms/index.js

@@ -0,0 +1,16 @@
+export { default as twoSum } from "./twoSum.js";
+export { default as threeSum } from "./threeSum.js";
+export { default as myAtoi } from "./myAtoi.js";
+export { default as WordDictionary } from "./wordDictionary.js";
+export { default as removeDuplicateLetters } from "./removeDuplicateLetters.js";
+export { default as removeKdigits } from "./removeKdigits.js";
+export { default as validParentheses } from "./validParentheses.js";
+export {
+  quickSort,
+  insertionSort,
+  selectionSort,
+  bubbleSort,
+  shellSort,
+  mergeSort,
+  countingSort,
+} from "./sort.js";

package/src/algorithms/myAtoi.js

@@ -0,0 +1,19 @@
+// 字符串转整数 (atoi)
+function myAtoi(str) {
+  const reg = /\s*([-+]?[0-9]*).*/;
+  const groups = str.match(reg);
+  const max = Math.pow(2, 31) - 1;
+  const min = -max - 1;
+
+  let result = 0;
+  if (groups) {
+    result = +groups[1];
+    if (isNaN(result)) return 0;
+  }
+
+  if (result > max) return max;
+  if (result < min) return min;
+  return result;
+}
+
+export default myAtoi;

package/src/algorithms/removeDuplicateLetters.js

@@ -0,0 +1,29 @@
+// 去除重复字母 - 返回字典序最小的结果
+function removeDuplicateLetters(str) {
+  const stack = [];
+  const seen = new Set();
+  const lastOccurrence = {};
+
+  for (let i = 0; i < str.length; i++) {
+    lastOccurrence[str[i]] = i;
+  }
+
+  for (let i = 0; i < str.length; i++) {
+    const char = str[i];
+    if (!seen.has(char)) {
+      while (
+        stack.length > 0 &&
+        char < stack[stack.length - 1] &&
+        i < lastOccurrence[stack[stack.length - 1]]
+      ) {
+        seen.delete(stack.pop());
+      }
+      seen.add(char);
+      stack.push(char);
+    }
+  }
+
+  return stack.join("");
+}
+
+export default removeDuplicateLetters;

package/src/algorithms/removeKdigits.js

@@ -0,0 +1,25 @@
+// 移除 K 位数字 - 使剩余数字最小
+function removeKdigits(num, k) {
+  const stack = [];
+
+  for (let i = 0; i < num.length; i++) {
+    while (k > 0 && stack.length && stack[stack.length - 1] > num[i]) {
+      stack.pop();
+      k--;
+    }
+    stack.push(num[i]);
+  }
+
+  while (k > 0) {
+    stack.pop();
+    k--;
+  }
+
+  while (stack[0] === "0") {
+    stack.shift();
+  }
+
+  return stack.length ? stack.join("") : "0";
+}
+
+export default removeKdigits;

package/src/algorithms/sort.js

@@ -0,0 +1,117 @@
+// 快速排序
+function quickSort(arr) {
+  if (arr.length <= 1) return arr;
+  const pivotIndex = Math.floor(arr.length / 2);
+  const pivot = arr.splice(pivotIndex, 1)[0];
+  const left = [];
+  const right = [];
+  for (let i = 0; i < arr.length; i++) {
+    if (arr[i] < pivot) left.push(arr[i]);
+    else right.push(arr[i]);
+  }
+  return quickSort(left).concat(pivot, quickSort(right));
+}
+
+// 插入排序
+function insertionSort(arr) {
+  for (let i = 1; i < arr.length; i++) {
+    let preIndex = i - 1;
+    const current = arr[i];
+    while (preIndex >= 0 && arr[preIndex] > current) {
+      arr[preIndex + 1] = arr[preIndex];
+      preIndex--;
+    }
+    arr[preIndex + 1] = current;
+  }
+  return arr;
+}
+
+// 选择排序
+function selectionSort(arr) {
+  for (let i = 0; i < arr.length - 1; i++) {
+    let minIndex = i;
+    for (let j = i + 1; j < arr.length; j++) {
+      if (arr[j] < arr[minIndex]) minIndex = j;
+    }
+    if (minIndex !== i) {
+      [arr[i], arr[minIndex]] = [arr[minIndex], arr[i]];
+    }
+  }
+  return arr;
+}
+
+// 冒泡排序
+function bubbleSort(arr) {
+  for (let i = 0; i < arr.length; i++) {
+    let swapped = false;
+    for (let j = 0; j < arr.length - i - 1; j++) {
+      if (arr[j] > arr[j + 1]) {
+        [arr[j], arr[j + 1]] = [arr[j + 1], arr[j]];
+        swapped = true;
+      }
+    }
+    if (!swapped) break;
+  }
+  return arr;
+}
+
+// 希尔排序
+function shellSort(arr) {
+  let gap = Math.floor(arr.length / 2);
+  while (gap > 0) {
+    for (let i = gap; i < arr.length; i++) {
+      let j = i;
+      while (j >= gap && arr[j - gap] > arr[j]) {
+        [arr[j], arr[j - gap]] = [arr[j - gap], arr[j]];
+        j -= gap;
+      }
+    }
+    gap = Math.floor(gap / 2);
+  }
+  return arr;
+}
+
+// 归并排序
+function mergeSort(arr) {
+  if (arr.length < 2) return arr;
+  const mid = Math.floor(arr.length / 2);
+  const left = arr.slice(0, mid);
+  const right = arr.slice(mid);
+  return merge(mergeSort(left), mergeSort(right));
+}
+
+function merge(left, right) {
+  const result = [];
+  while (left.length && right.length) {
+    if (left[0] <= right[0]) result.push(left.shift());
+    else result.push(right.shift());
+  }
+  while (left.length) result.push(left.shift());
+  while (right.length) result.push(right.shift());
+  return result;
+}
+
+// 计数排序
+function countingSort(arr, max = Math.max(...arr)) {
+  const bucketArr = new Array(max + 1).fill(0);
+  for (let i = 0; i < arr.length; i++) {
+    bucketArr[arr[i]]++;
+  }
+  let pointer = 0;
+  for (let i = 0; i < bucketArr.length; i++) {
+    while (bucketArr[i]-- > 0) {
+      arr[pointer++] = i;
+    }
+  }
+  return arr;
+}
+
+export {
+  quickSort,
+  insertionSort,
+  selectionSort,
+  bubbleSort,
+  shellSort,
+  mergeSort,
+  countingSort,
+};

package/src/algorithms/threeSum.js

@@ -0,0 +1,34 @@
+// 三数之和
+function threeSum(nums) {
+  const res = [];
+  const len = nums.length;
+  nums.sort((a, b) => a - b);
+
+  for (let i = 0; i < len; i++) {
+    let left = i + 1,
+      right = len - 1;
+    const curNum = nums[i];
+
+    if (curNum > 0) return res;
+    if (curNum === nums[i - 1]) continue;
+
+    while (left < right) {
+      const leftNum = nums[left],
+        rightNum = nums[right],
+        sum = curNum + leftNum + rightNum;
+
+      if (sum < 0) left++;
+      else if (sum > 0) right--;
+      else {
+        res.push([curNum, leftNum, rightNum]);
+        while (left < right && nums[left] === nums[left + 1]) left++;
+        while (left < right && nums[right] === nums[right - 1]) right--;
+        left++;
+        right--;
+      }
+    }
+  }
+  return res;
+}
+
+export default threeSum;

package/src/algorithms/twoSum.js

@@ -0,0 +1,23 @@
+// 两数之和 - 找出所有和为 target 的不重复数对
+function twoSum(nums, target) {
+  const map = new Map();
+  const result = [];
+  const set = new Set();
+
+  for (let i = 0; i < nums.length; i++) {
+    const complement = target - nums[i];
+    if (map.has(complement)) {
+      const pair = [complement, nums[i]].sort((a, b) => a - b);
+      const key = pair.join(",");
+      if (!set.has(key)) {
+        set.add(key);
+        result.push(pair);
+      }
+    }
+    map.set(nums[i], nums[i]);
+  }
+
+  return result;
+}
+
+export default twoSum;

package/src/algorithms/validParentheses.js

@@ -0,0 +1,22 @@
+// 有效的括号
+function isValid(str) {
+  const stack = [];
+  const map = {
+    "(": ")",
+    "[": "]",
+    "{": "}",
+  };
+
+  for (const char of str) {
+    if (map[char]) {
+      stack.push(char);
+    } else {
+      const top = stack.pop();
+      if (map[top] !== char) return false;
+    }
+  }
+
+  return stack.length === 0;
+}
+
+export default isValid;

package/src/algorithms/wordDictionary.js

@@ -0,0 +1,27 @@
+// 单词字典 - 支持通配符 . 的搜索
+class WordDictionary {
+  constructor() {
+    this.words = {};
+  }
+
+  addWord(word) {
+    const len = word.length;
+    if (this.words[len]) {
+      this.words[len].push(word);
+    } else {
+      this.words[len] = [word];
+    }
+  }
+
+  search(word) {
+    const len = word.length;
+    if (!this.words[len]) return false;
+    if (!word.includes(".")) {
+      return this.words[len].includes(word);
+    }
+    const reg = new RegExp(word);
+    return this.words[len].some((element) => reg.test(element));
+  }
+}
+
+export default WordDictionary;

package/src/data-structures/index.js

@@ -0,0 +1 @@
+export { default as Queue } from "./queue.js";

package/src/data-structures/queue.js

@@ -0,0 +1,46 @@
+class Queue {
+  #queue;
+  #endIndex;
+  #startIndex;
+
+  constructor() {
+    this.#queue = {};
+    this.#endIndex = 0;
+    this.#startIndex = 0;
+  }
+
+  enqueue(val) {
+    this.#queue[this.#endIndex] = val;
+    this.#endIndex++;
+    return this.#endIndex;
+  }
+
+  dequeue() {
+    if (this.isEmpty()) return;
+    const val = this.#queue[this.#startIndex];
+    delete this.#queue[this.#startIndex];
+    this.#startIndex++;
+    return val;
+  }
+
+  isEmpty() {
+    return this.size() === 0;
+  }
+
+  size() {
+    return this.#endIndex - this.#startIndex;
+  }
+
+  clear() {
+    this.#queue = {};
+    this.#endIndex = 0;
+    this.#startIndex = 0;
+  }
+
+  peek() {
+    if (this.isEmpty()) return;
+    return this.#queue[this.#startIndex];
+  }
+}
+
+export default Queue;

package/src/dom/index.js

@@ -0,0 +1 @@
+export { default as traverseElRoot } from "./traverseEl.js";

package/src/dom/traverseEl.js

@@ -0,0 +1,19 @@
+// 遍历 DOM 树，按层级返回标签名
+function traverseElRoot(elRoot) {
+  const result = [];
+
+  function traverse(element, level = 0) {
+    if (!result[level]) {
+      result[level] = [];
+    }
+    result[level].push(element.tagName);
+    Array.from(element.children).forEach((child) => {
+      traverse(child, level + 1);
+    });
+  }
+
+  traverse(elRoot);
+  return result;
+}
+
+export default traverseElRoot;

package/src/framework/hashRouter.js

@@ -0,0 +1,25 @@
+class HashRouter {
+  constructor(routes) {
+    this.routes = routes;
+    this.routeView = null;
+    this._init();
+  }
+
+  _init() {
+    window.addEventListener("DOMContentLoaded", () => this._onRouteChange());
+    window.addEventListener("hashchange", () => this._onRouteChange());
+  }
+
+  _onRouteChange() {
+    if (!this.routeView) {
+      this.routeView = document.getElementById("route-view");
+    }
+    const hash = location.hash || "#/";
+    const route = this.routes[hash] || this.routes["#/"];
+    if (route && this.routeView) {
+      this.routeView.innerHTML = route;
+    }
+  }
+}
+
+export default HashRouter;

package/src/framework/historyRouter.js

@@ -0,0 +1,35 @@
+class HistoryRouter {
+  constructor(routes) {
+    this.routes = routes;
+    this.routeView = null;
+    this._init();
+  }
+
+  _init() {
+    window.addEventListener("DOMContentLoaded", () => this._onRouteChange());
+    window.addEventListener("popstate", () => this._onRouteChange());
+
+    document.addEventListener("click", (e) => {
+      const target = e.target.closest("a[href]");
+      if (target) {
+        e.preventDefault();
+        const href = target.getAttribute("href");
+        history.pushState(null, "", href);
+        this._onRouteChange();
+      }
+    });
+  }
+
+  _onRouteChange() {
+    if (!this.routeView) {
+      this.routeView = document.getElementById("route-view");
+    }
+    const path = location.pathname;
+    const route = this.routes[path] || this.routes["/"];
+    if (route && this.routeView) {
+      this.routeView.innerHTML = route;
+    }
+  }
+}
+
+export default HistoryRouter;

package/src/framework/index.js

@@ -0,0 +1,4 @@
+export { reactive, effect } from "./reactive.js";
+export { h, mount } from "./vdom.js";
+export { default as HashRouter } from "./hashRouter.js";
+export { default as HistoryRouter } from "./historyRouter.js";

package/src/framework/reactive.js

@@ -0,0 +1,56 @@
+const bucket = new WeakMap();
+let activeEffect = null;
+
+function isObject(value) {
+  return typeof value === "object" && value !== null;
+}
+
+function effect(fn) {
+  if (typeof fn !== "function") return;
+  activeEffect = fn;
+  fn();
+  activeEffect = null;
+}
+
+function track(target, key) {
+  if (!activeEffect) return;
+  let depMap = bucket.get(target);
+  if (!depMap) {
+    depMap = new Map();
+    bucket.set(target, depMap);
+  }
+  let depSet = depMap.get(key);
+  if (!depSet) {
+    depSet = new Set();
+    depMap.set(key, depSet);
+  }
+  depSet.add(activeEffect);
+}
+
+function trigger(target, key) {
+  const depMap = bucket.get(target);
+  if (!depMap) return;
+  const depSet = depMap.get(key);
+  if (depSet) {
+    depSet.forEach((fn) => fn());
+  }
+}
+
+function reactive(data) {
+  if (!isObject(data)) return data;
+
+  return new Proxy(data, {
+    get(target, key) {
+      track(target, key);
+      const result = target[key];
+      return isObject(result) ? reactive(result) : result;
+    },
+    set(target, key, value) {
+      target[key] = value;
+      trigger(target, key);
+      return true;
+    },
+  });
+}
+
+export { reactive, effect };

package/src/framework/vdom.js

@@ -0,0 +1,37 @@
+function h(tag, props, children) {
+  return { tag, props, children };
+}
+
+function mount(vnode, container) {
+  if (typeof container === "string") {
+    container = document.getElementById(container);
+  }
+
+  const el = document.createElement(vnode.tag);
+  vnode.el = el;
+
+  if (vnode.props) {
+    for (const key in vnode.props) {
+      if (key.startsWith("on") && typeof vnode.props[key] === "function") {
+        const eventType = key.slice(2).toLowerCase();
+        el.addEventListener(eventType, vnode.props[key]);
+        continue;
+      }
+      el.setAttribute(key, vnode.props[key]);
+    }
+  }
+
+  if (vnode.children) {
+    if (typeof vnode.children === "string") {
+      el.textContent = vnode.children;
+    } else if (Array.isArray(vnode.children)) {
+      vnode.children.forEach((child) => {
+        mount(child, el);
+      });
+    }
+  }
+
+  container.appendChild(el);
+}
+
+export { h, mount };