@ceale/util 1.7.1 → 1.9.0

package/README.md

@@ -1,3 +1,41 @@
 # @ceale/util
 
-小工具集
+小工具集
+
+提供了
+- String.prototype
+    - removePrefix()
+    - removeSuffix()
+    - removeAllPrefixes()
+    - removeAllSuffixes()
+    - toCamelCase()
+    - toKebabCase()
+- Function.prototype
+    - isDirectSubclass()
+    - isSubclass()
+    - isDirectInstance()
+    - isInstance()
+- namespace: `uri`
+    - join()
+- namespace: `css`
+    - rule()
+    - selector()
+    - at()
+    - join()
+- `time.ts`
+    - wait() `# Alias: sleepAsync()`
+    - sleep() `# Alias: waitSync()`
+- `task.ts`
+    - debounce()
+    - throttle()
+- `bezier.ts`
+    - namespace `quadraticCurve`
+        - solveX()
+        - solveY()
+        - solveTForX()
+    - namespace `cubicCurve`
+        - solveX()
+        - solveY()
+        - solveTForX()
+    - class `QuadraticBezier`
+    - class `CubicBezier`

package/dist/cjs/index.js

@@ -32,9 +32,15 @@ __export(exports_src, {
   waitSync: () => waitSync,
   wait: () => wait,
   uri: () => uri,
+  throttle: () => throttle,
   sleepAsync: () => sleepAsync,
   sleep: () => sleep,
-  css: () => css
+  quadraticCurve: () => quadraticCurve,
+  debounce: () => debounce,
+  cubicCurve: () => cubicCurve,
+  css: () => css,
+  QuadraticBezier: () => QuadraticBezier,
+  CubicBezier: () => CubicBezier
 });
 module.exports = __toCommonJS(exports_src);
 
@@ -216,3 +222,146 @@ var sleep = (time) => {
       return;
 };
 var waitSync = sleep;
+// src/task.ts
+var debounce = (func, delay) => {
+  let timer = null;
+  return function(...args) {
+    if (timer) {
+      clearTimeout(timer);
+    }
+    timer = setTimeout(() => {
+      func.apply(this, args);
+    }, delay);
+  };
+};
+var throttle = (func, delay) => {
+  let timer = false;
+  let lastArgs = null;
+  return function(...args) {
+    if (timer) {
+      lastArgs = args;
+      return;
+    }
+    func.apply(this, args);
+    timer = true;
+    setTimeout(() => {
+      if (lastArgs) {
+        func.apply(this, lastArgs);
+        lastArgs = null;
+      }
+      timer = false;
+    }, delay);
+  };
+};
+// src/bezier.ts
+class BezierError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "BezierError";
+  }
+}
+var quadraticCurve;
+((quadraticCurve) => {
+  quadraticCurve.solveX = (p1, t) => {
+    const [p1x, p1y] = p1;
+    const oneMinusT = 1 - t;
+    return 2 * oneMinusT * t * p1x + t * t;
+  };
+  quadraticCurve.solveY = (p1, t) => {
+    const [p1x, p1y] = p1;
+    const oneMinusT = 1 - t;
+    return 2 * oneMinusT * t * p1y + t * t;
+  };
+  quadraticCurve.solveTForX = (p1, x, iterations = 8) => {
+    let tMin = 0;
+    let tMax = 1;
+    let tGuess;
+    for (let i = 0;i < iterations; i++) {
+      tGuess = (tMin + tMax) / 2;
+      const xGuess = quadraticCurve.solveX(p1, tGuess);
+      if (xGuess < x) {
+        tMin = tGuess;
+      } else {
+        tMax = tGuess;
+      }
+    }
+    return (tMin + tMax) / 2;
+  };
+})(quadraticCurve ||= {});
+var cubicCurve;
+((cubicCurve) => {
+  cubicCurve.solveX = ([p1, p2], t) => {
+    const [p1x, p1y] = p1;
+    const [p2x, p2y] = p2;
+    const oneMinusT = 1 - t;
+    const t2 = t * t;
+    return 3 * oneMinusT * oneMinusT * t * p1x + 3 * oneMinusT * t2 * p2x + t2 * t;
+  };
+  cubicCurve.solveY = ([p1, p2], t) => {
+    const [p1x, p1y] = p1;
+    const [p2x, p2y] = p2;
+    const oneMinusT = 1 - t;
+    const t2 = t * t;
+    return 3 * oneMinusT * oneMinusT * t * p1y + 3 * oneMinusT * t2 * p2y + t2 * t;
+  };
+  cubicCurve.solveTForX = ([p1, p2], x, iterations = 12) => {
+    let tMin = 0;
+    let tMax = 1;
+    let tGuess;
+    for (let i = 0;i < iterations; i++) {
+      tGuess = (tMin + tMax) / 2;
+      const xGuess = cubicCurve.solveX([p1, p2], tGuess);
+      if (xGuess < x) {
+        tMin = tGuess;
+      } else {
+        tMax = tGuess;
+      }
+    }
+    return (tMin + tMax) / 2;
+  };
+})(cubicCurve ||= {});
+
+class QuadraticBezier {
+  p1;
+  constructor(p1) {
+    this.p1 = p1;
+    if (this.p1[0] < 0 || this.p1[0] > 1) {
+      throw new BezierError("控制点P1的x坐标必须在[0, 1]之间");
+    }
+  }
+  solveX(t) {
+    return quadraticCurve.solveX(this.p1, t);
+  }
+  solveY(t) {
+    return quadraticCurve.solveY(this.p1, t);
+  }
+  solveYForX(x) {
+    const t = quadraticCurve.solveTForX(this.p1, x);
+    return this.solveY(t);
+  }
+}
+
+class CubicBezier {
+  p1;
+  p2;
+  constructor(p1, p2) {
+    this.p1 = p1;
+    this.p2 = p2;
+    if (this.p1[0] < 0 || this.p1[0] > 1) {
+      throw new BezierError("控制点P1的x坐标必须在[0, 1]之间");
+    }
+    if (this.p2[0] < 0 || this.p2[0] > 1) {
+      throw new BezierError("控制点P2的x坐标必须在[0, 1]之间");
+    }
+  }
+  solveX(t) {
+    return cubicCurve.solveX([this.p1, this.p2], t);
+  }
+  solveY(t) {
+    return cubicCurve.solveY([this.p1, this.p2], t);
+  }
+  solveYForX(x) {
+    const t = cubicCurve.solveTForX([this.p1, this.p2], x);
+    return this.solveY(t);
+  }
+}

package/dist/esm/index.js

@@ -176,11 +176,160 @@ var sleep = (time) => {
       return;
 };
 var waitSync = sleep;
+// src/task.ts
+var debounce = (func, delay) => {
+  let timer = null;
+  return function(...args) {
+    if (timer) {
+      clearTimeout(timer);
+    }
+    timer = setTimeout(() => {
+      func.apply(this, args);
+    }, delay);
+  };
+};
+var throttle = (func, delay) => {
+  let timer = false;
+  let lastArgs = null;
+  return function(...args) {
+    if (timer) {
+      lastArgs = args;
+      return;
+    }
+    func.apply(this, args);
+    timer = true;
+    setTimeout(() => {
+      if (lastArgs) {
+        func.apply(this, lastArgs);
+        lastArgs = null;
+      }
+      timer = false;
+    }, delay);
+  };
+};
+// src/bezier.ts
+class BezierError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "BezierError";
+  }
+}
+var quadraticCurve;
+((quadraticCurve) => {
+  quadraticCurve.solveX = (p1, t) => {
+    const [p1x, p1y] = p1;
+    const oneMinusT = 1 - t;
+    return 2 * oneMinusT * t * p1x + t * t;
+  };
+  quadraticCurve.solveY = (p1, t) => {
+    const [p1x, p1y] = p1;
+    const oneMinusT = 1 - t;
+    return 2 * oneMinusT * t * p1y + t * t;
+  };
+  quadraticCurve.solveTForX = (p1, x, iterations = 8) => {
+    let tMin = 0;
+    let tMax = 1;
+    let tGuess;
+    for (let i = 0;i < iterations; i++) {
+      tGuess = (tMin + tMax) / 2;
+      const xGuess = quadraticCurve.solveX(p1, tGuess);
+      if (xGuess < x) {
+        tMin = tGuess;
+      } else {
+        tMax = tGuess;
+      }
+    }
+    return (tMin + tMax) / 2;
+  };
+})(quadraticCurve ||= {});
+var cubicCurve;
+((cubicCurve) => {
+  cubicCurve.solveX = ([p1, p2], t) => {
+    const [p1x, p1y] = p1;
+    const [p2x, p2y] = p2;
+    const oneMinusT = 1 - t;
+    const t2 = t * t;
+    return 3 * oneMinusT * oneMinusT * t * p1x + 3 * oneMinusT * t2 * p2x + t2 * t;
+  };
+  cubicCurve.solveY = ([p1, p2], t) => {
+    const [p1x, p1y] = p1;
+    const [p2x, p2y] = p2;
+    const oneMinusT = 1 - t;
+    const t2 = t * t;
+    return 3 * oneMinusT * oneMinusT * t * p1y + 3 * oneMinusT * t2 * p2y + t2 * t;
+  };
+  cubicCurve.solveTForX = ([p1, p2], x, iterations = 12) => {
+    let tMin = 0;
+    let tMax = 1;
+    let tGuess;
+    for (let i = 0;i < iterations; i++) {
+      tGuess = (tMin + tMax) / 2;
+      const xGuess = cubicCurve.solveX([p1, p2], tGuess);
+      if (xGuess < x) {
+        tMin = tGuess;
+      } else {
+        tMax = tGuess;
+      }
+    }
+    return (tMin + tMax) / 2;
+  };
+})(cubicCurve ||= {});
+
+class QuadraticBezier {
+  p1;
+  constructor(p1) {
+    this.p1 = p1;
+    if (this.p1[0] < 0 || this.p1[0] > 1) {
+      throw new BezierError("控制点P1的x坐标必须在[0, 1]之间");
+    }
+  }
+  solveX(t) {
+    return quadraticCurve.solveX(this.p1, t);
+  }
+  solveY(t) {
+    return quadraticCurve.solveY(this.p1, t);
+  }
+  solveYForX(x) {
+    const t = quadraticCurve.solveTForX(this.p1, x);
+    return this.solveY(t);
+  }
+}
+
+class CubicBezier {
+  p1;
+  p2;
+  constructor(p1, p2) {
+    this.p1 = p1;
+    this.p2 = p2;
+    if (this.p1[0] < 0 || this.p1[0] > 1) {
+      throw new BezierError("控制点P1的x坐标必须在[0, 1]之间");
+    }
+    if (this.p2[0] < 0 || this.p2[0] > 1) {
+      throw new BezierError("控制点P2的x坐标必须在[0, 1]之间");
+    }
+  }
+  solveX(t) {
+    return cubicCurve.solveX([this.p1, this.p2], t);
+  }
+  solveY(t) {
+    return cubicCurve.solveY([this.p1, this.p2], t);
+  }
+  solveYForX(x) {
+    const t = cubicCurve.solveTForX([this.p1, this.p2], x);
+    return this.solveY(t);
+  }
+}
 export {
   waitSync,
   wait,
   uri,
+  throttle,
   sleepAsync,
   sleep,
-  css
+  quadraticCurve,
+  debounce,
+  cubicCurve,
+  css,
+  QuadraticBezier,
+  CubicBezier
 };

package/dist/types/bezier.d.ts

@@ -0,0 +1,96 @@
+type Point = [number, number];
+export declare namespace quadraticCurve {
+    /**
+     * [二次] 给定控制点 P1 和 t (时间)，计算 x 坐标
+     * @param p1 控制点1 的坐标
+     * @param t 时间比例 [0, 1]
+     * @returns x 坐标
+     */
+    const solveX: (p1: Point, t: number) => number;
+    /**
+     * [二次] 给定控制点 P1 和 t (时间)，计算 y 坐标
+     * @param p1 控制点1 坐标
+     * @param t 时间比例 [0, 1]
+     * @returns y 坐标
+     */
+    const solveY: (p1: Point, t: number) => number;
+    /**
+     * [二次] 给定控制点 P1 和 x (坐标)，反向求解 t (时间)
+     * 使用二分查找法
+     * @param p1 控制点1 坐标
+     * @param x 目标 x 坐标 [0, 1]
+     * @returns 对应的时间 t
+     */
+    const solveTForX: (p1: Point, x: number, iterations?: number) => number;
+}
+export declare namespace cubicCurve {
+    /**
+     * [三次] 给定控制点 P1, P2 和 t (时间)，计算 x 坐标
+     * @param \[p1, p2] 控制点1 控制点2 的坐标
+     * @param t 时间比例 [0, 1]
+     * @returns x 坐标
+     */
+    const solveX: ([p1, p2]: [Point, Point], t: number) => number;
+    /**
+     * [三次] 给定控制点 P1, P2 和 t (时间)，计算 y 坐标
+     * @param \[p1, p2] 控制点1 控制点2 的坐标
+     * @param t 时间比例 [0, 1]
+     * @returns y 坐标
+     */
+    const solveY: ([p1, p2]: [Point, Point], t: number) => number;
+    /**
+     * [三次] 给定控制点 P1, P2 和 x (坐标)，反向求解 t (时间)
+     * 使用二分查找法
+     * @param \[p1, p2] 控制点1 控制点2 的坐标
+     * @param x 目标 x 坐标 [0, 1]
+     * @returns 对应的时间 t
+     */
+    const solveTForX: ([p1, p2]: [Point, Point], x: number, iterations?: number) => number;
+}
+/**
+ * 代表一个二次贝塞尔缓动曲线
+ */
+export declare class QuadraticBezier {
+    private readonly p1;
+    /**
+     * @param p1 控制点 P1
+     */
+    constructor(p1: Point);
+    /**
+     * 根据时间 t [0, 1]，计算 x 坐标
+     */
+    solveX(t: number): number;
+    /**
+     * 根据时间 t [0, 1]，计算 y 坐标
+     */
+    solveY(t: number): number;
+    /**
+     * 根据 x 坐标 [0, 1]，计算 y 坐标
+     */
+    solveYForX(x: number): number;
+}
+/**
+ * 代表一个三次贝塞尔缓动曲线
+ */
+export declare class CubicBezier {
+    private readonly p1;
+    private readonly p2;
+    /**
+     * @param p1 控制点 P1
+     * @param p2 控制点 P2
+     */
+    constructor(p1: Point, p2: Point);
+    /**
+     * 根据时间 t [0, 1]，计算 x 坐标
+     */
+    solveX(t: number): number;
+    /**
+     * 根据时间 t [0, 1]，计算 y 坐标
+     */
+    solveY(t: number): number;
+    /**
+     * 根据 x 坐标 [0, 1]，计算 y 坐标
+     */
+    solveYForX(x: number): number;
+}
+export {};

package/dist/types/index.d.ts

@@ -3,3 +3,5 @@ export * from "./uri";
 export * from "./class";
 export * from "./css";
 export * from "./time";
+export * from "./task";
+export * from "./bezier";

package/dist/types/task.d.ts

@@ -0,0 +1,20 @@
+/**
+ * 将传入的函数变为防抖版本
+ *
+ * 在间隔低于`delay`连续触发函数时，只会执行最后一次调用，并在最后一次调用后延时`delay`执行
+ * @param func 原始函数
+ * @param delay 防抖时长，毫秒
+ * @returns 带防抖的函数
+ */
+export declare const debounce: <F extends (...args: any[]) => void>(func: F, delay: number) => ((...args: Parameters<F>) => void);
+/**
+ * 将传入的函数变为节流版本
+ *
+ * 函数将在首次调用后执行，首次调用后的`delay`内，如重复调用，
+ *
+ * 则函数将以最后一次调用的参数，在首次调用后延迟`delay`后执行
+ * @param func 原始函数
+ * @param delay 节流时长，毫秒
+ * @returns 带节流的函数
+ */
+export declare const throttle: <F extends (...args: any[]) => void>(func: F, delay: number) => ((...args: Parameters<F>) => void);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@ceale/util",
   "author": "Ceale",
-  "version": "1.7.1",
+  "version": "1.9.0",
   "module": "index.ts",
   "type": "module",
   "main": "dist/esm/index.js",
@@ -31,7 +31,7 @@
     "typescript": "^5"
   },
   "dependencies": {
-    "@types/vue": "^2.0.0",
-    "csstype": "^3.1.3"
+    "csstype": "^3.1.3",
+    "vue": "^3.5.21"
   }
 }