@zhouyihang/js-kit 1.0.0

package/src/index.js

@@ -0,0 +1,66 @@
+// ========== Polyfills (手写系列) ==========
+export {
+  myCall,
+  myApply,
+  myBind,
+  applyPolyfills,
+  myNew,
+  deepClone,
+  deepFreeze,
+  jsonStringify,
+  MyPromise,
+  promiseAll,
+  promiseRace,
+  promiseAllSettled,
+  promiseAny,
+  createIterator,
+} from "./polyfills/index.js";
+
+// ========== Utility Functions (工具函数) ==========
+export {
+  debounce,
+  throttle,
+  flatten,
+  flattenReduce,
+  flattenDeep,
+  mergeArr,
+  chunkArr,
+  formatSizeUnits,
+  parseUrl,
+  makeTree,
+  toTree,
+  asyncPool,
+} from "./utils/index.js";
+
+// ========== Design Patterns (设计模式) ==========
+export { Singleton, Storage, PubSub, createProxyObj } from "./patterns/index.js";
+
+// ========== Framework Internals (框架原理) ==========
+export { reactive, effect, h, mount, HashRouter, HistoryRouter } from "./framework/index.js";
+
+// ========== Algorithms (算法) ==========
+export {
+  twoSum,
+  threeSum,
+  myAtoi,
+  WordDictionary,
+  removeDuplicateLetters,
+  removeKdigits,
+  validParentheses,
+  quickSort,
+  insertionSort,
+  selectionSort,
+  bubbleSort,
+  shellSort,
+  mergeSort,
+  countingSort,
+} from "./algorithms/index.js";
+
+// ========== Data Structures (数据结构) ==========
+export { Queue } from "./data-structures/index.js";
+
+// ========== DOM Utilities ==========
+export { traverseElRoot } from "./dom/index.js";
+
+// ========== JavaScript Basics (JS基础) ==========
+export { curry, inherit } from "./javascript/index.js";

package/src/javascript/curry.js

@@ -0,0 +1,8 @@
+function curry(fn, ...args) {
+  if (args.length >= fn.length) {
+    return fn(...args);
+  }
+  return (..._args) => curry(fn, ...args, ..._args);
+}
+
+export default curry;

package/src/javascript/index.js

@@ -0,0 +1,2 @@
+export { default as curry } from "./curry.js";
+export { inherit, Parent, Child } from "./inheritance.js";

package/src/javascript/inheritance.js

@@ -0,0 +1,23 @@
+// 寄生组合继承
+function inherit(Child, Parent) {
+  Child.prototype = Object.create(Parent.prototype);
+  Child.prototype.constructor = Child;
+}
+
+// 示例
+function Parent(name) {
+  this.name = name;
+}
+
+Parent.prototype.sayHello = function () {
+  return "Hello " + this.name;
+};
+
+function Child(name, age) {
+  Parent.call(this, name);
+  this.age = age;
+}
+
+inherit(Child, Parent);
+
+export { inherit, Parent, Child };

package/src/patterns/index.js

@@ -0,0 +1,3 @@
+export { Singleton, Storage } from "./singleton.js";
+export { default as PubSub } from "./pubsub.js";
+export { createProxyObj } from "./proxyObserver.js";

package/src/patterns/proxyObserver.js

@@ -0,0 +1,30 @@
+import PubSub from "./pubsub.js";
+
+function createProxyObj(obj, option = {}) {
+  const observer = new PubSub();
+  const handler = {
+    get(target, key) {
+      return target[key];
+    },
+    set(target, key, value) {
+      target[key] = value;
+      observer.$emit("change", key, value);
+      return true;
+    },
+  };
+
+  const proxy = new Proxy(obj, handler);
+  proxy.$on = observer.$on.bind(observer);
+  proxy.$off = observer.$off.bind(observer);
+  proxy.$emit = observer.$emit.bind(observer);
+
+  for (const key in option) {
+    if (!proxy[key]) {
+      proxy[key] = option[key];
+    }
+  }
+
+  return proxy;
+}
+
+export { createProxyObj };

package/src/patterns/pubsub.js

@@ -0,0 +1,30 @@
+class PubSub {
+  constructor() {
+    this.events = {};
+  }
+
+  $on(name, callback) {
+    if (!this.events[name]) {
+      this.events[name] = [];
+    }
+    this.events[name].push(callback);
+  }
+
+  $off(name, callback) {
+    if (!this.events[name]) return;
+    if (!callback) {
+      this.events[name] = undefined;
+      return;
+    }
+    this.events[name] = this.events[name].filter((item) => item !== callback);
+  }
+
+  $emit(name, ...args) {
+    if (!this.events[name]) return;
+    this.events[name].forEach((callback) => {
+      callback(...args);
+    });
+  }
+}
+
+export default PubSub;

package/src/patterns/singleton.js

@@ -0,0 +1,32 @@
+class Singleton {
+  constructor(implClass) {
+    this.implClass = implClass;
+  }
+
+  getInstance(...args) {
+    if (!this.instance) {
+      this.instance = new this.implClass(...args);
+    }
+    return this.instance;
+  }
+}
+
+// Storage 单例示例
+class Storage {
+  static getInstance() {
+    if (!Storage.instance) {
+      Storage.instance = new Storage();
+    }
+    return Storage.instance;
+  }
+
+  setItem(key, value) {
+    return localStorage.setItem(key, value);
+  }
+
+  getItem(key) {
+    return localStorage.getItem(key);
+  }
+}
+
+export { Singleton, Storage };

package/src/polyfills/call.js

@@ -0,0 +1,54 @@
+function myCall(fn, context, ...args) {
+  if (typeof fn !== "function") {
+    throw new TypeError("被调用的对象必须是函数");
+  }
+  context = context || globalThis;
+  const key = Symbol("fn");
+  context[key] = fn;
+  const result = context[key](...args);
+  delete context[key];
+  return result;
+}
+
+function myApply(fn, context, argsArr) {
+  if (typeof fn !== "function") {
+    throw new TypeError("被调用的对象必须是函数");
+  }
+  if (argsArr && !Array.isArray(argsArr)) {
+    throw new TypeError("第二个参数必须是数组");
+  }
+  context = context || globalThis;
+  const key = Symbol("fn");
+  context[key] = fn;
+  const result = context[key](...argsArr);
+  delete context[key];
+  return result;
+}
+
+function myBind(fn, context, ...args) {
+  if (typeof fn !== "function") {
+    throw new TypeError("被绑定的对象必须是函数");
+  }
+  context = context || globalThis;
+  return function bound(...innerArgs) {
+    if (this instanceof bound) {
+      return new fn(...args, ...innerArgs);
+    }
+    return fn.apply(context, args.concat(innerArgs));
+  };
+}
+
+// opt-in: 挂载到 Function.prototype
+function applyPolyfills() {
+  Function.prototype.myCall = function (context, ...args) {
+    return myCall(this, context, ...args);
+  };
+  Function.prototype.myApply = function (context, argsArr) {
+    return myApply(this, context, argsArr);
+  };
+  Function.prototype.myBind = function (context, ...args) {
+    return myBind(this, context, ...args);
+  };
+}
+
+export { myCall, myApply, myBind, applyPolyfills };

package/src/polyfills/deepClone.js

@@ -0,0 +1,36 @@
+function deepClone(obj, map = new Map()) {
+  if (typeof obj !== "object" || obj === null) {
+    return obj;
+  }
+  if (map.has(obj)) {
+    return map.get(obj);
+  }
+
+  let newObj;
+  if (Array.isArray(obj)) {
+    newObj = [];
+  } else if (obj instanceof Date) {
+    newObj = new Date(obj);
+  } else if (obj instanceof RegExp) {
+    newObj = new RegExp(obj.source, obj.flags);
+  } else {
+    newObj = {};
+  }
+
+  map.set(obj, newObj);
+
+  for (let key in obj) {
+    if (obj.hasOwnProperty(key)) {
+      newObj[key] = deepClone(obj[key], map);
+    }
+  }
+
+  const symbolKeys = Object.getOwnPropertySymbols(obj);
+  for (const symbol of symbolKeys) {
+    newObj[symbol] = deepClone(obj[symbol], map);
+  }
+
+  return newObj;
+}
+
+export default deepClone;

package/src/polyfills/deepFreeze.js

@@ -0,0 +1,11 @@
+function deepFreeze(obj) {
+  Object.freeze(obj);
+  for (let key in obj) {
+    if (typeof obj[key] === "object" && !Object.isFrozen(obj[key])) {
+      deepFreeze(obj[key]);
+    }
+  }
+  return obj;
+}
+
+export default deepFreeze;

package/src/polyfills/index.js

@@ -0,0 +1,8 @@
+export { myCall, myApply, myBind, applyPolyfills } from "./call.js";
+export { default as myNew } from "./new.js";
+export { default as deepClone } from "./deepClone.js";
+export { default as deepFreeze } from "./deepFreeze.js";
+export { default as jsonStringify } from "./jsonStringify.js";
+export { default as MyPromise } from "./promise.js";
+export { promiseAll, promiseRace, promiseAllSettled, promiseAny } from "./promiseMethods.js";
+export { default as createIterator } from "./iterator.js";

package/src/polyfills/iterator.js

@@ -0,0 +1,13 @@
+function createIterator(list) {
+  let index = 0;
+  const length = list.length;
+  return {
+    next: () => {
+      const done = index >= length;
+      const value = !done ? list[index++] : undefined;
+      return { done, value };
+    },
+  };
+}
+
+export default createIterator;

package/src/polyfills/jsonStringify.js

@@ -0,0 +1,27 @@
+function jsonStringify(target) {
+  let type = typeof target;
+  if (type !== "object") {
+    if (/string|undefined|function/.test(type)) {
+      target = '"' + target + '"';
+    }
+    return String(target);
+  }
+
+  let json = [];
+  let arr = target && target.constructor === Array;
+
+  for (let k in target) {
+    let v = target[k];
+    let vType = typeof v;
+    if (/string|undefined|function/.test(vType)) {
+      v = '"' + v + '"';
+    } else if (vType === "object") {
+      v = jsonStringify(v);
+    }
+    json.push((arr ? "" : '"' + k + '":') + String(v));
+  }
+
+  return (arr ? "[" : "{") + String(json) + (arr ? "]" : "}");
+}
+
+export default jsonStringify;

package/src/polyfills/new.js

@@ -0,0 +1,7 @@
+function myNew(Fn, ...args) {
+  const obj = Object.create(Fn.prototype);
+  const result = Fn.apply(obj, args);
+  return result instanceof Object ? result : obj;
+}
+
+export default myNew;

package/src/polyfills/promise.js

@@ -0,0 +1,99 @@
+class MyPromise {
+  constructor(executor) {
+    this.state = "pending";
+    this.value = undefined;
+    this.reason = undefined;
+    this.onFulfilledCallbacks = [];
+    this.onRejectedCallbacks = [];
+
+    const resolve = (value) => {
+      if (this.state === "pending") {
+        this.state = "fulfilled";
+        this.value = value;
+        this.onFulfilledCallbacks.forEach((fn) => fn());
+      }
+    };
+
+    const reject = (reason) => {
+      if (this.state === "pending") {
+        this.state = "rejected";
+        this.reason = reason;
+        this.onRejectedCallbacks.forEach((fn) => fn());
+      }
+    };
+
+    try {
+      executor(resolve, reject);
+    } catch (e) {
+      reject(e);
+    }
+  }
+
+  then(onFulfilled, onRejected) {
+    onFulfilled = typeof onFulfilled === "function" ? onFulfilled : (v) => v;
+    onRejected =
+      typeof onRejected === "function"
+        ? onRejected
+        : (e) => {
+            throw e;
+          };
+
+    return new MyPromise((resolve, reject) => {
+      const handleFulfilled = () => {
+        queueMicrotask(() => {
+          try {
+            const result = onFulfilled(this.value);
+            resolve(result);
+          } catch (e) {
+            reject(e);
+          }
+        });
+      };
+
+      const handleRejected = () => {
+        queueMicrotask(() => {
+          try {
+            const result = onRejected(this.reason);
+            resolve(result);
+          } catch (e) {
+            reject(e);
+          }
+        });
+      };
+
+      if (this.state === "fulfilled") {
+        handleFulfilled();
+      } else if (this.state === "rejected") {
+        handleRejected();
+      } else {
+        this.onFulfilledCallbacks.push(handleFulfilled);
+        this.onRejectedCallbacks.push(handleRejected);
+      }
+    });
+  }
+
+  catch(onRejected) {
+    return this.then(null, onRejected);
+  }
+
+  finally(onFinally) {
+    return this.then(
+      (value) => MyPromise.resolve(onFinally()).then(() => value),
+      (reason) =>
+        MyPromise.resolve(onFinally()).then(() => {
+          throw reason;
+        })
+    );
+  }
+
+  static resolve(value) {
+    if (value instanceof MyPromise) return value;
+    return new MyPromise((resolve) => resolve(value));
+  }
+
+  static reject(reason) {
+    return new MyPromise((_, reject) => reject(reason));
+  }
+}
+
+export default MyPromise;

package/src/polyfills/promiseMethods.js

@@ -0,0 +1,67 @@
+function promiseAll(promises) {
+  return new Promise((resolve, reject) => {
+    const result = [];
+    let count = 0;
+    promises.forEach((promise, index) => {
+      Promise.resolve(promise).then(
+        (value) => {
+          result[index] = value;
+          count++;
+          if (count === promises.length) {
+            resolve(result);
+          }
+        },
+        (reason) => {
+          reject(reason);
+        }
+      );
+    });
+  });
+}
+
+function promiseRace(promises) {
+  return new Promise((resolve, reject) => {
+    promises.forEach((promise) => {
+      Promise.resolve(promise).then(resolve, reject);
+    });
+  });
+}
+
+function promiseAllSettled(promises) {
+  return new Promise((resolve) => {
+    const result = [];
+    let count = 0;
+    promises.forEach((promise, index) => {
+      Promise.resolve(promise).then(
+        (value) => {
+          result[index] = { status: "fulfilled", value };
+          count++;
+          if (count === promises.length) resolve(result);
+        },
+        (reason) => {
+          result[index] = { status: "rejected", reason };
+          count++;
+          if (count === promises.length) resolve(result);
+        }
+      );
+    });
+  });
+}
+
+function promiseAny(promises) {
+  return new Promise((resolve, reject) => {
+    const errors = [];
+    let count = 0;
+    promises.forEach((promise, index) => {
+      Promise.resolve(promise).then(resolve, (reason) => {
+        errors[index] = reason;
+        count++;
+        if (count === promises.length) {
+          reject(new AggregateError(errors, "All promises were rejected"));
+        }
+      });
+    });
+  });
+}
+
+export { promiseAll, promiseRace, promiseAllSettled, promiseAny };

package/src/types/index.d.ts

@@ -0,0 +1 @@
+export type { NestedArray } from "./nestedArray.js";

package/src/types/nestedArray.d.ts

@@ -0,0 +1,3 @@
+type NestedArray<T> = T | NestedArray<T>[];
+
+export { NestedArray };

package/src/utils/asyncPool.js

@@ -0,0 +1,21 @@
+async function asyncPool(poolLimit, array, iteratorFn) {
+  const ret = [];
+  const pool = [];
+
+  for (const item of array) {
+    const p = Promise.resolve().then(() => iteratorFn(item));
+    ret.push(p);
+
+    if (poolLimit <= array.length) {
+      const e = p.then(() => pool.splice(pool.indexOf(e), 1));
+      pool.push(e);
+      if (pool.length >= poolLimit) {
+        await Promise.race(pool);
+      }
+    }
+  }
+
+  return Promise.all(ret);
+}
+
+export default asyncPool;

package/src/utils/chunkArr.js

@@ -0,0 +1,10 @@
+// chunk(["a", "b", "c", "d"], 2) => [["a", "b"], ["c", "d"]]
+function chunkArr(array, size) {
+  const result = [];
+  for (let i = 0; i < array.length; i += size) {
+    result.push(array.slice(i, i + size));
+  }
+  return result;
+}
+
+export default chunkArr;

package/src/utils/debounce.js

@@ -0,0 +1,11 @@
+function debounce(func, delay) {
+  let timer;
+  return function (...args) {
+    clearTimeout(timer);
+    timer = setTimeout(() => {
+      func.apply(this, args);
+    }, delay);
+  };
+}
+
+export default debounce;

package/src/utils/flatten.js

@@ -0,0 +1,40 @@
+// 递归版本（支持指定深度）
+function flatten(arr, level = 1) {
+  let result = [];
+  for (let i = 0; i < arr.length; i++) {
+    if (Array.isArray(arr[i]) && level > 0) {
+      result = result.concat(flatten(arr[i], level - 1));
+    } else {
+      result.push(arr[i]);
+    }
+  }
+  return result;
+}
+
+// reduce 版本
+function flattenReduce(arr, level = 1) {
+  return arr.reduce(
+    (prev, cur) =>
+      prev.concat(
+        level > 0 && Array.isArray(cur) ? flattenReduce(cur, level - 1) : cur
+      ),
+    []
+  );
+}
+
+// 栈版本（完全扁平化）
+function flattenDeep(arr) {
+  const stack = [...arr];
+  const res = [];
+  while (stack.length) {
+    const next = stack.pop();
+    if (Array.isArray(next)) {
+      stack.push(...next);
+    } else {
+      res.push(next);
+    }
+  }
+  return res.reverse();
+}
+
+export { flatten, flattenReduce, flattenDeep };

package/src/utils/formatSizeUnits.js

@@ -0,0 +1,13 @@
+function formatSizeUnits(kb) {
+  const units = ["KB", "MB", "GB", "TB", "PB"];
+  let unitIndex = 0;
+
+  while (kb >= 1024 && unitIndex < units.length - 1) {
+    kb /= 1024;
+    unitIndex++;
+  }
+
+  return `${kb.toFixed(2)} ${units[unitIndex]}`;
+}
+
+export default formatSizeUnits;

package/src/utils/index.js

@@ -0,0 +1,10 @@
+export { default as debounce } from "./debounce.js";
+export { default as throttle } from "./throttle.js";
+export { flatten, flattenReduce, flattenDeep } from "./flatten.js";
+export { default as mergeArr } from "./mergeArr.js";
+export { default as chunkArr } from "./chunkArr.js";
+export { default as formatSizeUnits } from "./formatSizeUnits.js";
+export { default as parseUrl } from "./parseUrl.js";
+export { default as makeTree } from "./makeTree.js";
+export { default as toTree } from "./toTree.js";
+export { default as asyncPool } from "./asyncPool.js";

package/src/utils/makeTree.js

@@ -0,0 +1,17 @@
+// 将多个文件路径生成树形结构
+function makeTree(paths) {
+  const tree = {};
+  paths.forEach((path) => {
+    const pathArr = path.split("/");
+    let current = tree;
+    pathArr.forEach((dir) => {
+      if (!current[dir]) {
+        current[dir] = {};
+      }
+      current = current[dir];
+    });
+  });
+  return tree;
+}
+
+export default makeTree;