@bouzu/shared 0.0.1 → 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) zhong666 <hi@zhong666.me> and bouzu contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,57 @@
+# @bouzu/shared
+
+[![npm version][npm-version-src]][npm-version-href]
+[![npm downloads][npm-downloads-src]][npm-downloads-href]
+[![bundle][bundle-src]][bundle-href]
+[![JSDocs][jsdocs-src]][jsdocs-href]
+
+## Usage
+
+Install package:
+
+```sh
+# npm
+npm install @bouzu/shared
+
+# yarn
+yarn add @bouzu/shared
+
+# pnpm
+pnpm install @bouzu/shared
+```
+
+Import:
+
+```js
+// ESM
+import * as shared from '@bouzu/shared'
+
+// CommonJS
+const shared = require('@bouzu/shared')
+```
+
+## Development
+
+- Clone this repository
+- Install latest LTS version of [Node.js](https://nodejs.org/en/)
+- Enable [Corepack](https://github.com/nodejs/corepack) using `corepack enable`
+- Install dependencies using `pnpm install`
+- Run interactive tests using `pnpm dev`
+
+## License
+
+Made with 💛
+
+Published under [MIT License](./LICENSE).
+
+
+<!-- Badges -->
+
+[npm-version-src]: https://img.shields.io/npm/v/@bouzu/shared?style=flat&colorA=18181B&colorB=F0DB4F
+[npm-version-href]: https://npmjs.com/package/@bouzu/shared
+[npm-downloads-src]: https://img.shields.io/npm/dm/@bouzu/shared?style=flat&colorA=18181B&colorB=F0DB4F
+[npm-downloads-href]: https://npmjs.com/package/@bouzu/shared
+[bundle-src]: https://img.shields.io/bundlephobia/minzip/@bouzu/shared?style=flat&colorA=18181B&colorB=F0DB4F
+[bundle-href]: https://bundlephobia.com/result?p=@bouzu/shared
+[jsdocs-src]: https://img.shields.io/badge/jsDocs.io-reference-18181B?style=flat&colorA=18181B&colorB=F0DB4F
+[jsdocs-href]: https://www.jsdocs.io/package/@bouzu/shared

package/dist/index.cjs

@@ -46,6 +46,23 @@ function checkPointOrigin(p) {
 function checkPointEqual(a, b) {
   return a.x === b.x && a.y === b.y;
 }
+function checkPointEqualWithTolerance(a, b, tolerance = 0.01) {
+  return Math.abs(a.x - b.x) < tolerance && Math.abs(a.y - b.y) < tolerance;
+}
+function getPointCenter(p1, p2) {
+  return createPoint(
+    (p1.x + p2.x) / 2,
+    (p1.y + p2.y) / 2
+  );
+}
+function getPointDistance(p1, p2) {
+  const dx = p1.x - p2.x;
+  const dy = p1.y - p2.y;
+  return Math.sqrt(dx * dx + dy * dy);
+}
+function clonePoint(a) {
+  return createPoint(a.x, a.y);
+}
 
 function createSize(width = 0, height = 0) {
   return { width, height };
@@ -54,13 +71,12 @@ function checkSizeEqual(a, b) {
   return a.width === b.width && a.height === b.height;
 }
 
-var RectCorner = /* @__PURE__ */ ((RectCorner2) => {
-  RectCorner2["TopLeft"] = "TopLeft";
-  RectCorner2["TopRight"] = "TopRight";
-  RectCorner2["BottomLeft"] = "BottomLeft";
-  RectCorner2["BottomRight"] = "BottomRight";
-  return RectCorner2;
-})(RectCorner || {});
+const RectCorner = {
+  TopLeft: "TopLeft",
+  TopRight: "TopRight",
+  BottomLeft: "BottomLeft",
+  BottomRight: "BottomRight"
+};
 function createRect(x = 0, y = 0, width = 0, height = 0) {
   return {
     ...createPoint(x, y),
@@ -93,13 +109,13 @@ function getRectBottomRight(rect) {
 }
 function getRectPointByRectCorner(rect, corner) {
   switch (corner) {
-    case "TopLeft" /* TopLeft */:
+    case RectCorner.TopLeft:
       return getRectTopLeft(rect);
-    case "TopRight" /* TopRight */:
+    case RectCorner.TopRight:
       return getRectTopRight(rect);
-    case "BottomLeft" /* BottomLeft */:
+    case RectCorner.BottomLeft:
       return getRectBottomLeft(rect);
-    case "BottomRight" /* BottomRight */:
+    case RectCorner.BottomRight:
       return getRectBottomRight(rect);
     default:
       throw new TypeError(`Not match corner: ${corner}`);
@@ -147,9 +163,148 @@ function toPoint(rect) {
   return createPoint(rect.x, rect.y);
 }
 
+function isObject(val) {
+  return Object.prototype.toString.call(val) === "[object Object]";
+}
+
+const Axis = {
+  X: "x",
+  Y: "y"
+};
+function checkAxis(currVisibleRect, prevVisibleRect) {
+  if (Math.abs(currVisibleRect.x - prevVisibleRect.x) > 0)
+    return Axis.X;
+  if (Math.abs(currVisibleRect.y - prevVisibleRect.y) > 0)
+    return Axis.Y;
+}
+function reverseAxis(axis) {
+  switch (axis) {
+    case Axis.X:
+      return Axis.Y;
+    case Axis.Y:
+      return Axis.X;
+  }
+}
+function getSizeByAxis(size, axis, reverse = false) {
+  switch (reverse ? reverseAxis(axis) : axis) {
+    case Axis.X:
+      return size.width;
+    case Axis.Y:
+      return size.height;
+  }
+}
+function getPointByAxis(point, axis, reverse = false) {
+  return point[reverse ? reverseAxis(axis) : axis];
+}
+function updateSizeByAxis(size, axis, value, reverse = false) {
+  switch (reverse ? reverseAxis(axis) : axis) {
+    case Axis.X:
+      size.width = value;
+      break;
+    case Axis.Y:
+      size.height = value;
+      break;
+  }
+}
+function updatePointByAxis(point, axis, value, reverse = false) {
+  point[reverse ? reverseAxis(axis) : axis] = value;
+}
+function getRectMaxByAxis(rect, axis, reverse = false) {
+  switch (reverse ? reverseAxis(axis) : axis) {
+    case Axis.X:
+      return getRectMaxX(rect);
+    case Axis.Y:
+      return getRectMaxY(rect);
+  }
+}
+function checkRectIntersectsByAxis(a, b, axis, reverse = false) {
+  switch (reverse ? reverseAxis(axis) : axis) {
+    case Axis.X:
+      return checkRectIntersectsX(a, b);
+    case Axis.Y:
+      return checkRectIntersectsY(a, b);
+  }
+}
+
+function registerRaf(handler, methods) {
+  const raf = methods?.raf ?? window.requestAnimationFrame;
+  const caf = methods?.caf ?? window.cancelAnimationFrame;
+  let handleId = raf(handler);
+  return () => {
+    if (handleId == null)
+      return;
+    caf(handleId);
+    handleId = null;
+  };
+}
+
+const perf = window?.performance ?? null;
+const perfNowFn = perf?.now ?? perf?.webkitNow ?? perf?.msNow ?? perf?.mozNow;
+const getTime = perfNowFn ? perfNowFn.bind(perf) : Date.now ?? (() => (/* @__PURE__ */ new Date()).getTime());
+
+function clamp(value, min, max) {
+  return Math.min(Math.max(value, min), max);
+}
+
+function runTransition(options) {
+  const {
+    start,
+    end,
+    onUpdate,
+    onStarted,
+    onFinished,
+    raf = window.requestAnimationFrame,
+    caf = window.cancelAnimationFrame,
+    duration = 1e3,
+    // eslint-disable-next-line ts/no-use-before-define
+    easing = easeLinear,
+    getTime: getTime$1 = getTime
+  } = options;
+  const rafMethos = { raf, caf };
+  let _cancelRaf = noop;
+  let _canceled = false;
+  const promise = new Promise((resolve) => {
+    const startAt = getTime$1();
+    onStarted?.();
+    const tick = (currentTime) => {
+      if (_canceled) {
+        resolve();
+        return;
+      }
+      const elapsed = currentTime - startAt;
+      const progress = Math.min(elapsed / duration, 1);
+      const value = start + (end - start) * easing(progress);
+      onUpdate(value);
+      if (progress < 1) {
+        _cancelRaf = registerRaf(tick, rafMethos);
+      } else {
+        onFinished?.();
+        resolve();
+      }
+    };
+    _cancelRaf = registerRaf(tick, rafMethos);
+  });
+  promise.cancel = () => {
+    _canceled = true;
+    _cancelRaf();
+  };
+  return promise;
+}
+function runNoopTransition() {
+  const promise = new Promise((resolve) => resolve());
+  promise.cancel = noop;
+  return promise;
+}
+const easeLinear = (t) => t;
+const easeOut = (t) => Math.sin(t * Math.PI / 2);
+const easeOutCubic = (t) => 1 - (1 - t) ** 3;
+
+exports.Axis = Axis;
 exports.RectCorner = RectCorner;
+exports.checkAxis = checkAxis;
 exports.checkLayoutInvalidate = checkLayoutInvalidate;
 exports.checkPointEqual = checkPointEqual;
+exports.checkPointEqualWithTolerance = checkPointEqualWithTolerance;
 exports.checkPointOrigin = checkPointOrigin;
 exports.checkRectContains = checkRectContains;
 exports.checkRectContainsPoint = checkRectContainsPoint;
@@ -157,24 +312,43 @@ exports.checkRectEqual = checkRectEqual;
 exports.checkRectEqualPoint = checkRectEqualPoint;
 exports.checkRectEqualSize = checkRectEqualSize;
 exports.checkRectIntersects = checkRectIntersects;
+exports.checkRectIntersectsByAxis = checkRectIntersectsByAxis;
 exports.checkRectIntersectsX = checkRectIntersectsX;
 exports.checkRectIntersectsY = checkRectIntersectsY;
 exports.checkSizeEqual = checkSizeEqual;
+exports.clamp = clamp;
+exports.clonePoint = clonePoint;
 exports.cloneRect = cloneRect;
 exports.createPoint = createPoint;
 exports.createRect = createRect;
 exports.createSize = createSize;
+exports.easeLinear = easeLinear;
+exports.easeOut = easeOut;
+exports.easeOutCubic = easeOutCubic;
 exports.execLastTick = execLastTick;
+exports.getPointByAxis = getPointByAxis;
+exports.getPointCenter = getPointCenter;
+exports.getPointDistance = getPointDistance;
 exports.getRectArea = getRectArea;
 exports.getRectBottomLeft = getRectBottomLeft;
 exports.getRectBottomRight = getRectBottomRight;
 exports.getRectCornerInOther = getRectCornerInOther;
+exports.getRectMaxByAxis = getRectMaxByAxis;
 exports.getRectMaxX = getRectMaxX;
 exports.getRectMaxY = getRectMaxY;
 exports.getRectPointByRectCorner = getRectPointByRectCorner;
 exports.getRectTopLeft = getRectTopLeft;
 exports.getRectTopRight = getRectTopRight;
+exports.getSizeByAxis = getSizeByAxis;
+exports.getTime = getTime;
+exports.isObject = isObject;
 exports.noop = noop;
+exports.registerRaf = registerRaf;
+exports.reverseAxis = reverseAxis;
+exports.runNoopTransition = runNoopTransition;
+exports.runTransition = runTransition;
 exports.toPoint = toPoint;
 exports.toSize = toSize;
+exports.updatePointByAxis = updatePointByAxis;
+exports.updateSizeByAxis = updateSizeByAxis;
 exports.usePrevious = usePrevious;

package/dist/index.d.cts

@@ -0,0 +1,123 @@
+import { ValueOf } from 'type-fest';
+
+declare function noop(): void;
+
+type Previous<T> = [
+    {
+        readonly curr: T | undefined;
+        readonly prev: T | undefined;
+    },
+    (val: T) => void
+];
+declare function usePrevious<T>(val?: T): Previous<T>;
+
+type WithoutFirstParameter<T> = T extends (arg1: any, ...args: infer U) => any ? U : any;
+declare function execLastTick<TTickFn extends typeof setTimeout | typeof queueMicrotask | typeof requestAnimationFrame, TFn extends (...args: any) => any>(tickFn: TTickFn, fn: TFn, ...tickFnArgs: WithoutFirstParameter<TTickFn>): (...args: Parameters<TFn>) => void;
+
+interface Point {
+    x: number;
+    y: number;
+}
+declare function createPoint(x?: number, y?: number): Point;
+declare function checkPointOrigin(p: Point): boolean;
+declare function checkPointEqual(a: Point, b: Point): boolean;
+declare function checkPointEqualWithTolerance(a: Point, b: Point, tolerance?: number): boolean;
+declare function getPointCenter(p1: Point, p2: Point): Point;
+declare function getPointDistance(p1: Point, p2: Point): number;
+declare function clonePoint(a: Point): Point;
+
+interface Size {
+    width: number;
+    height: number;
+}
+declare function createSize(width?: number, height?: number): Size;
+declare function checkSizeEqual(a: Size, b: Size): boolean;
+
+type Rect = Size & Point;
+declare const RectCorner: {
+    readonly TopLeft: "TopLeft";
+    readonly TopRight: "TopRight";
+    readonly BottomLeft: "BottomLeft";
+    readonly BottomRight: "BottomRight";
+};
+type RectCornerValue = ValueOf<typeof RectCorner>;
+declare function createRect(x?: number, y?: number, width?: number, height?: number): Rect;
+declare function cloneRect(rect: Rect): Rect;
+declare function getRectMaxX(rect: Rect): number;
+declare function getRectMaxY(rect: Rect): number;
+declare function getRectArea(rect: Rect): number;
+declare function getRectTopLeft(rect: Rect): Point;
+declare function getRectTopRight(rect: Rect): Point;
+declare function getRectBottomLeft(rect: Rect): Point;
+declare function getRectBottomRight(rect: Rect): Point;
+declare function getRectPointByRectCorner(rect: Rect, corner: RectCornerValue): Point;
+declare function checkRectIntersectsX(a: Rect, b: Rect): boolean;
+declare function checkRectIntersectsY(a: Rect, b: Rect): boolean;
+declare function checkRectIntersects(a: Rect, b: Rect): boolean;
+declare function checkRectContains(a: Rect, b: Rect): boolean;
+declare function checkRectContainsPoint(a: Rect, p: Point): boolean;
+declare function getRectCornerInOther(a: Rect, b: Rect): RectCornerValue | null;
+declare function checkRectEqual(a: Rect, b: Rect): boolean;
+declare function checkRectEqualPoint(r: Rect, p: Point | Rect): boolean;
+declare function checkRectEqualSize(r: Rect, s: Size | Rect): boolean;
+declare function checkLayoutInvalidate(newRect: Rect, oldRect: Rect): boolean;
+declare function toSize(rect: Rect): Size;
+declare function toPoint(rect: Rect): Point;
+
+declare function isObject(val: unknown): val is Record<PropertyKey, any>;
+
+declare const Axis: {
+    readonly X: "x";
+    readonly Y: "y";
+};
+type AxisValue = ValueOf<typeof Axis>;
+declare function checkAxis(currVisibleRect: Rect, prevVisibleRect: Rect): AxisValue | undefined;
+declare function reverseAxis(axis: AxisValue): AxisValue;
+declare function getSizeByAxis(size: Size, axis: AxisValue, reverse?: boolean): number;
+declare function getPointByAxis(point: Point, axis: AxisValue, reverse?: boolean): number;
+declare function updateSizeByAxis(size: Size, axis: AxisValue, value: number, reverse?: boolean): void;
+declare function updatePointByAxis(point: Point, axis: AxisValue, value: number, reverse?: boolean): void;
+declare function getRectMaxByAxis(rect: Rect, axis: AxisValue, reverse?: boolean): number;
+declare function checkRectIntersectsByAxis(a: Rect, b: Rect, axis: AxisValue, reverse?: boolean): boolean;
+
+interface RegisterRafMethods {
+    /**
+     * requestAnimationFrame
+     */
+    raf: AnimationFrameProvider['requestAnimationFrame'];
+    /**
+     * cancelAnimationFrame
+     */
+    caf: AnimationFrameProvider['cancelAnimationFrame'];
+}
+type CancelRaf = () => void;
+declare function registerRaf(handler: (time: number) => void, methods?: RegisterRafMethods): CancelRaf;
+
+type GetTimeFn = () => number;
+declare const getTime: GetTimeFn;
+
+declare function clamp(value: number, min: number, max: number): number;
+
+interface RunTransitionOptions {
+    start: number;
+    end: number;
+    onUpdate: (value: number) => void | boolean;
+    easing?: EaseFn;
+    duration?: number;
+    onStarted?: () => void;
+    onFinished?: () => void;
+    getTime?: GetTimeFn;
+    raf?: RegisterRafMethods['raf'];
+    caf?: RegisterRafMethods['caf'];
+}
+type TransitionRunner = Promise<void> & {
+    cancel: () => void;
+};
+declare function runTransition(options: RunTransitionOptions): TransitionRunner;
+declare function runNoopTransition(): TransitionRunner;
+type EaseFn = (t: number) => number;
+declare const easeLinear: EaseFn;
+declare const easeOut: EaseFn;
+declare const easeOutCubic: EaseFn;
+
+export { Axis, type AxisValue, type CancelRaf, type EaseFn, type GetTimeFn, type Point, type Previous, type Rect, RectCorner, type RectCornerValue, type RegisterRafMethods, type RunTransitionOptions, type Size, type TransitionRunner, checkAxis, checkLayoutInvalidate, checkPointEqual, checkPointEqualWithTolerance, checkPointOrigin, checkRectContains, checkRectContainsPoint, checkRectEqual, checkRectEqualPoint, checkRectEqualSize, checkRectIntersects, checkRectIntersectsByAxis, checkRectIntersectsX, checkRectIntersectsY, checkSizeEqual, clamp, clonePoint, cloneRect, createPoint, createRect, createSize, easeLinear, easeOut, easeOutCubic, execLastTick, getPointByAxis, getPointCenter, getPointDistance, getRectArea, getRectBottomLeft, getRectBottomRight, getRectCornerInOther, getRectMaxByAxis, getRectMaxX, getRectMaxY, getRectPointByRectCorner, getRectTopLeft, getRectTopRight, getSizeByAxis, getTime, isObject, noop, registerRaf, reverseAxis, runNoopTransition, runTransition, toPoint, toSize, updatePointByAxis, updateSizeByAxis, usePrevious };

package/dist/index.d.mts

@@ -0,0 +1,123 @@
+import { ValueOf } from 'type-fest';
+
+declare function noop(): void;
+
+type Previous<T> = [
+    {
+        readonly curr: T | undefined;
+        readonly prev: T | undefined;
+    },
+    (val: T) => void
+];
+declare function usePrevious<T>(val?: T): Previous<T>;
+
+type WithoutFirstParameter<T> = T extends (arg1: any, ...args: infer U) => any ? U : any;
+declare function execLastTick<TTickFn extends typeof setTimeout | typeof queueMicrotask | typeof requestAnimationFrame, TFn extends (...args: any) => any>(tickFn: TTickFn, fn: TFn, ...tickFnArgs: WithoutFirstParameter<TTickFn>): (...args: Parameters<TFn>) => void;
+
+interface Point {
+    x: number;
+    y: number;
+}
+declare function createPoint(x?: number, y?: number): Point;
+declare function checkPointOrigin(p: Point): boolean;
+declare function checkPointEqual(a: Point, b: Point): boolean;
+declare function checkPointEqualWithTolerance(a: Point, b: Point, tolerance?: number): boolean;
+declare function getPointCenter(p1: Point, p2: Point): Point;
+declare function getPointDistance(p1: Point, p2: Point): number;
+declare function clonePoint(a: Point): Point;
+
+interface Size {
+    width: number;
+    height: number;
+}
+declare function createSize(width?: number, height?: number): Size;
+declare function checkSizeEqual(a: Size, b: Size): boolean;
+
+type Rect = Size & Point;
+declare const RectCorner: {
+    readonly TopLeft: "TopLeft";
+    readonly TopRight: "TopRight";
+    readonly BottomLeft: "BottomLeft";
+    readonly BottomRight: "BottomRight";
+};
+type RectCornerValue = ValueOf<typeof RectCorner>;
+declare function createRect(x?: number, y?: number, width?: number, height?: number): Rect;
+declare function cloneRect(rect: Rect): Rect;
+declare function getRectMaxX(rect: Rect): number;
+declare function getRectMaxY(rect: Rect): number;
+declare function getRectArea(rect: Rect): number;
+declare function getRectTopLeft(rect: Rect): Point;
+declare function getRectTopRight(rect: Rect): Point;
+declare function getRectBottomLeft(rect: Rect): Point;
+declare function getRectBottomRight(rect: Rect): Point;
+declare function getRectPointByRectCorner(rect: Rect, corner: RectCornerValue): Point;
+declare function checkRectIntersectsX(a: Rect, b: Rect): boolean;
+declare function checkRectIntersectsY(a: Rect, b: Rect): boolean;
+declare function checkRectIntersects(a: Rect, b: Rect): boolean;
+declare function checkRectContains(a: Rect, b: Rect): boolean;
+declare function checkRectContainsPoint(a: Rect, p: Point): boolean;
+declare function getRectCornerInOther(a: Rect, b: Rect): RectCornerValue | null;
+declare function checkRectEqual(a: Rect, b: Rect): boolean;
+declare function checkRectEqualPoint(r: Rect, p: Point | Rect): boolean;
+declare function checkRectEqualSize(r: Rect, s: Size | Rect): boolean;
+declare function checkLayoutInvalidate(newRect: Rect, oldRect: Rect): boolean;
+declare function toSize(rect: Rect): Size;
+declare function toPoint(rect: Rect): Point;
+
+declare function isObject(val: unknown): val is Record<PropertyKey, any>;
+
+declare const Axis: {
+    readonly X: "x";
+    readonly Y: "y";
+};
+type AxisValue = ValueOf<typeof Axis>;
+declare function checkAxis(currVisibleRect: Rect, prevVisibleRect: Rect): AxisValue | undefined;
+declare function reverseAxis(axis: AxisValue): AxisValue;
+declare function getSizeByAxis(size: Size, axis: AxisValue, reverse?: boolean): number;
+declare function getPointByAxis(point: Point, axis: AxisValue, reverse?: boolean): number;
+declare function updateSizeByAxis(size: Size, axis: AxisValue, value: number, reverse?: boolean): void;
+declare function updatePointByAxis(point: Point, axis: AxisValue, value: number, reverse?: boolean): void;
+declare function getRectMaxByAxis(rect: Rect, axis: AxisValue, reverse?: boolean): number;
+declare function checkRectIntersectsByAxis(a: Rect, b: Rect, axis: AxisValue, reverse?: boolean): boolean;
+
+interface RegisterRafMethods {
+    /**
+     * requestAnimationFrame
+     */
+    raf: AnimationFrameProvider['requestAnimationFrame'];
+    /**
+     * cancelAnimationFrame
+     */
+    caf: AnimationFrameProvider['cancelAnimationFrame'];
+}
+type CancelRaf = () => void;
+declare function registerRaf(handler: (time: number) => void, methods?: RegisterRafMethods): CancelRaf;
+
+type GetTimeFn = () => number;
+declare const getTime: GetTimeFn;
+
+declare function clamp(value: number, min: number, max: number): number;
+
+interface RunTransitionOptions {
+    start: number;
+    end: number;
+    onUpdate: (value: number) => void | boolean;
+    easing?: EaseFn;
+    duration?: number;
+    onStarted?: () => void;
+    onFinished?: () => void;
+    getTime?: GetTimeFn;
+    raf?: RegisterRafMethods['raf'];
+    caf?: RegisterRafMethods['caf'];
+}
+type TransitionRunner = Promise<void> & {
+    cancel: () => void;
+};
+declare function runTransition(options: RunTransitionOptions): TransitionRunner;
+declare function runNoopTransition(): TransitionRunner;
+type EaseFn = (t: number) => number;
+declare const easeLinear: EaseFn;
+declare const easeOut: EaseFn;
+declare const easeOutCubic: EaseFn;
+
+export { Axis, type AxisValue, type CancelRaf, type EaseFn, type GetTimeFn, type Point, type Previous, type Rect, RectCorner, type RectCornerValue, type RegisterRafMethods, type RunTransitionOptions, type Size, type TransitionRunner, checkAxis, checkLayoutInvalidate, checkPointEqual, checkPointEqualWithTolerance, checkPointOrigin, checkRectContains, checkRectContainsPoint, checkRectEqual, checkRectEqualPoint, checkRectEqualSize, checkRectIntersects, checkRectIntersectsByAxis, checkRectIntersectsX, checkRectIntersectsY, checkSizeEqual, clamp, clonePoint, cloneRect, createPoint, createRect, createSize, easeLinear, easeOut, easeOutCubic, execLastTick, getPointByAxis, getPointCenter, getPointDistance, getRectArea, getRectBottomLeft, getRectBottomRight, getRectCornerInOther, getRectMaxByAxis, getRectMaxX, getRectMaxY, getRectPointByRectCorner, getRectTopLeft, getRectTopRight, getSizeByAxis, getTime, isObject, noop, registerRaf, reverseAxis, runNoopTransition, runTransition, toPoint, toSize, updatePointByAxis, updateSizeByAxis, usePrevious };

package/dist/index.d.ts

@@ -1,3 +1,5 @@
+import { ValueOf } from 'type-fest';
+
 declare function noop(): void;
 
 type Previous<T> = [
@@ -19,6 +21,10 @@ interface Point {
 declare function createPoint(x?: number, y?: number): Point;
 declare function checkPointOrigin(p: Point): boolean;
 declare function checkPointEqual(a: Point, b: Point): boolean;
+declare function checkPointEqualWithTolerance(a: Point, b: Point, tolerance?: number): boolean;
+declare function getPointCenter(p1: Point, p2: Point): Point;
+declare function getPointDistance(p1: Point, p2: Point): number;
+declare function clonePoint(a: Point): Point;
 
 interface Size {
     width: number;
@@ -28,12 +34,13 @@ declare function createSize(width?: number, height?: number): Size;
 declare function checkSizeEqual(a: Size, b: Size): boolean;
 
 type Rect = Size & Point;
-declare enum RectCorner {
-    TopLeft = "TopLeft",
-    TopRight = "TopRight",
-    BottomLeft = "BottomLeft",
-    BottomRight = "BottomRight"
-}
+declare const RectCorner: {
+    readonly TopLeft: "TopLeft";
+    readonly TopRight: "TopRight";
+    readonly BottomLeft: "BottomLeft";
+    readonly BottomRight: "BottomRight";
+};
+type RectCornerValue = ValueOf<typeof RectCorner>;
 declare function createRect(x?: number, y?: number, width?: number, height?: number): Rect;
 declare function cloneRect(rect: Rect): Rect;
 declare function getRectMaxX(rect: Rect): number;
@@ -43,13 +50,13 @@ declare function getRectTopLeft(rect: Rect): Point;
 declare function getRectTopRight(rect: Rect): Point;
 declare function getRectBottomLeft(rect: Rect): Point;
 declare function getRectBottomRight(rect: Rect): Point;
-declare function getRectPointByRectCorner(rect: Rect, corner: RectCorner): Point;
+declare function getRectPointByRectCorner(rect: Rect, corner: RectCornerValue): Point;
 declare function checkRectIntersectsX(a: Rect, b: Rect): boolean;
 declare function checkRectIntersectsY(a: Rect, b: Rect): boolean;
 declare function checkRectIntersects(a: Rect, b: Rect): boolean;
 declare function checkRectContains(a: Rect, b: Rect): boolean;
 declare function checkRectContainsPoint(a: Rect, p: Point): boolean;
-declare function getRectCornerInOther(a: Rect, b: Rect): RectCorner | null;
+declare function getRectCornerInOther(a: Rect, b: Rect): RectCornerValue | null;
 declare function checkRectEqual(a: Rect, b: Rect): boolean;
 declare function checkRectEqualPoint(r: Rect, p: Point | Rect): boolean;
 declare function checkRectEqualSize(r: Rect, s: Size | Rect): boolean;
@@ -57,4 +64,60 @@ declare function checkLayoutInvalidate(newRect: Rect, oldRect: Rect): boolean;
 declare function toSize(rect: Rect): Size;
 declare function toPoint(rect: Rect): Point;
 
-export { Point, Previous, Rect, RectCorner, Size, checkLayoutInvalidate, checkPointEqual, checkPointOrigin, checkRectContains, checkRectContainsPoint, checkRectEqual, checkRectEqualPoint, checkRectEqualSize, checkRectIntersects, checkRectIntersectsX, checkRectIntersectsY, checkSizeEqual, cloneRect, createPoint, createRect, createSize, execLastTick, getRectArea, getRectBottomLeft, getRectBottomRight, getRectCornerInOther, getRectMaxX, getRectMaxY, getRectPointByRectCorner, getRectTopLeft, getRectTopRight, noop, toPoint, toSize, usePrevious };
+declare function isObject(val: unknown): val is Record<PropertyKey, any>;
+
+declare const Axis: {
+    readonly X: "x";
+    readonly Y: "y";
+};
+type AxisValue = ValueOf<typeof Axis>;
+declare function checkAxis(currVisibleRect: Rect, prevVisibleRect: Rect): AxisValue | undefined;
+declare function reverseAxis(axis: AxisValue): AxisValue;
+declare function getSizeByAxis(size: Size, axis: AxisValue, reverse?: boolean): number;
+declare function getPointByAxis(point: Point, axis: AxisValue, reverse?: boolean): number;
+declare function updateSizeByAxis(size: Size, axis: AxisValue, value: number, reverse?: boolean): void;
+declare function updatePointByAxis(point: Point, axis: AxisValue, value: number, reverse?: boolean): void;
+declare function getRectMaxByAxis(rect: Rect, axis: AxisValue, reverse?: boolean): number;
+declare function checkRectIntersectsByAxis(a: Rect, b: Rect, axis: AxisValue, reverse?: boolean): boolean;
+
+interface RegisterRafMethods {
+    /**
+     * requestAnimationFrame
+     */
+    raf: AnimationFrameProvider['requestAnimationFrame'];
+    /**
+     * cancelAnimationFrame
+     */
+    caf: AnimationFrameProvider['cancelAnimationFrame'];
+}
+type CancelRaf = () => void;
+declare function registerRaf(handler: (time: number) => void, methods?: RegisterRafMethods): CancelRaf;
+
+type GetTimeFn = () => number;
+declare const getTime: GetTimeFn;
+
+declare function clamp(value: number, min: number, max: number): number;
+
+interface RunTransitionOptions {
+    start: number;
+    end: number;
+    onUpdate: (value: number) => void | boolean;
+    easing?: EaseFn;
+    duration?: number;
+    onStarted?: () => void;
+    onFinished?: () => void;
+    getTime?: GetTimeFn;
+    raf?: RegisterRafMethods['raf'];
+    caf?: RegisterRafMethods['caf'];
+}
+type TransitionRunner = Promise<void> & {
+    cancel: () => void;
+};
+declare function runTransition(options: RunTransitionOptions): TransitionRunner;
+declare function runNoopTransition(): TransitionRunner;
+type EaseFn = (t: number) => number;
+declare const easeLinear: EaseFn;
+declare const easeOut: EaseFn;
+declare const easeOutCubic: EaseFn;
+
+export { Axis, type AxisValue, type CancelRaf, type EaseFn, type GetTimeFn, type Point, type Previous, type Rect, RectCorner, type RectCornerValue, type RegisterRafMethods, type RunTransitionOptions, type Size, type TransitionRunner, checkAxis, checkLayoutInvalidate, checkPointEqual, checkPointEqualWithTolerance, checkPointOrigin, checkRectContains, checkRectContainsPoint, checkRectEqual, checkRectEqualPoint, checkRectEqualSize, checkRectIntersects, checkRectIntersectsByAxis, checkRectIntersectsX, checkRectIntersectsY, checkSizeEqual, clamp, clonePoint, cloneRect, createPoint, createRect, createSize, easeLinear, easeOut, easeOutCubic, execLastTick, getPointByAxis, getPointCenter, getPointDistance, getRectArea, getRectBottomLeft, getRectBottomRight, getRectCornerInOther, getRectMaxByAxis, getRectMaxX, getRectMaxY, getRectPointByRectCorner, getRectTopLeft, getRectTopRight, getSizeByAxis, getTime, isObject, noop, registerRaf, reverseAxis, runNoopTransition, runTransition, toPoint, toSize, updatePointByAxis, updateSizeByAxis, usePrevious };

package/dist/index.mjs

@@ -44,6 +44,23 @@ function checkPointOrigin(p) {
 function checkPointEqual(a, b) {
   return a.x === b.x && a.y === b.y;
 }
+function checkPointEqualWithTolerance(a, b, tolerance = 0.01) {
+  return Math.abs(a.x - b.x) < tolerance && Math.abs(a.y - b.y) < tolerance;
+}
+function getPointCenter(p1, p2) {
+  return createPoint(
+    (p1.x + p2.x) / 2,
+    (p1.y + p2.y) / 2
+  );
+}
+function getPointDistance(p1, p2) {
+  const dx = p1.x - p2.x;
+  const dy = p1.y - p2.y;
+  return Math.sqrt(dx * dx + dy * dy);
+}
+function clonePoint(a) {
+  return createPoint(a.x, a.y);
+}
 
 function createSize(width = 0, height = 0) {
   return { width, height };
@@ -52,13 +69,12 @@ function checkSizeEqual(a, b) {
   return a.width === b.width && a.height === b.height;
 }
 
-var RectCorner = /* @__PURE__ */ ((RectCorner2) => {
-  RectCorner2["TopLeft"] = "TopLeft";
-  RectCorner2["TopRight"] = "TopRight";
-  RectCorner2["BottomLeft"] = "BottomLeft";
-  RectCorner2["BottomRight"] = "BottomRight";
-  return RectCorner2;
-})(RectCorner || {});
+const RectCorner = {
+  TopLeft: "TopLeft",
+  TopRight: "TopRight",
+  BottomLeft: "BottomLeft",
+  BottomRight: "BottomRight"
+};
 function createRect(x = 0, y = 0, width = 0, height = 0) {
   return {
     ...createPoint(x, y),
@@ -91,13 +107,13 @@ function getRectBottomRight(rect) {
 }
 function getRectPointByRectCorner(rect, corner) {
   switch (corner) {
-    case "TopLeft" /* TopLeft */:
+    case RectCorner.TopLeft:
       return getRectTopLeft(rect);
-    case "TopRight" /* TopRight */:
+    case RectCorner.TopRight:
       return getRectTopRight(rect);
-    case "BottomLeft" /* BottomLeft */:
+    case RectCorner.BottomLeft:
       return getRectBottomLeft(rect);
-    case "BottomRight" /* BottomRight */:
+    case RectCorner.BottomRight:
       return getRectBottomRight(rect);
     default:
       throw new TypeError(`Not match corner: ${corner}`);
@@ -145,4 +161,140 @@ function toPoint(rect) {
   return createPoint(rect.x, rect.y);
 }
 
-export { RectCorner, checkLayoutInvalidate, checkPointEqual, checkPointOrigin, checkRectContains, checkRectContainsPoint, checkRectEqual, checkRectEqualPoint, checkRectEqualSize, checkRectIntersects, checkRectIntersectsX, checkRectIntersectsY, checkSizeEqual, cloneRect, createPoint, createRect, createSize, execLastTick, getRectArea, getRectBottomLeft, getRectBottomRight, getRectCornerInOther, getRectMaxX, getRectMaxY, getRectPointByRectCorner, getRectTopLeft, getRectTopRight, noop, toPoint, toSize, usePrevious };
+function isObject(val) {
+  return Object.prototype.toString.call(val) === "[object Object]";
+}
+
+const Axis = {
+  X: "x",
+  Y: "y"
+};
+function checkAxis(currVisibleRect, prevVisibleRect) {
+  if (Math.abs(currVisibleRect.x - prevVisibleRect.x) > 0)
+    return Axis.X;
+  if (Math.abs(currVisibleRect.y - prevVisibleRect.y) > 0)
+    return Axis.Y;
+}
+function reverseAxis(axis) {
+  switch (axis) {
+    case Axis.X:
+      return Axis.Y;
+    case Axis.Y:
+      return Axis.X;
+  }
+}
+function getSizeByAxis(size, axis, reverse = false) {
+  switch (reverse ? reverseAxis(axis) : axis) {
+    case Axis.X:
+      return size.width;
+    case Axis.Y:
+      return size.height;
+  }
+}
+function getPointByAxis(point, axis, reverse = false) {
+  return point[reverse ? reverseAxis(axis) : axis];
+}
+function updateSizeByAxis(size, axis, value, reverse = false) {
+  switch (reverse ? reverseAxis(axis) : axis) {
+    case Axis.X:
+      size.width = value;
+      break;
+    case Axis.Y:
+      size.height = value;
+      break;
+  }
+}
+function updatePointByAxis(point, axis, value, reverse = false) {
+  point[reverse ? reverseAxis(axis) : axis] = value;
+}
+function getRectMaxByAxis(rect, axis, reverse = false) {
+  switch (reverse ? reverseAxis(axis) : axis) {
+    case Axis.X:
+      return getRectMaxX(rect);
+    case Axis.Y:
+      return getRectMaxY(rect);
+  }
+}
+function checkRectIntersectsByAxis(a, b, axis, reverse = false) {
+  switch (reverse ? reverseAxis(axis) : axis) {
+    case Axis.X:
+      return checkRectIntersectsX(a, b);
+    case Axis.Y:
+      return checkRectIntersectsY(a, b);
+  }
+}
+
+function registerRaf(handler, methods) {
+  const raf = methods?.raf ?? window.requestAnimationFrame;
+  const caf = methods?.caf ?? window.cancelAnimationFrame;
+  let handleId = raf(handler);
+  return () => {
+    if (handleId == null)
+      return;
+    caf(handleId);
+    handleId = null;
+  };
+}
+
+const perf = window?.performance ?? null;
+const perfNowFn = perf?.now ?? perf?.webkitNow ?? perf?.msNow ?? perf?.mozNow;
+const getTime = perfNowFn ? perfNowFn.bind(perf) : Date.now ?? (() => (/* @__PURE__ */ new Date()).getTime());
+
+function clamp(value, min, max) {
+  return Math.min(Math.max(value, min), max);
+}
+
+function runTransition(options) {
+  const {
+    start,
+    end,
+    onUpdate,
+    onStarted,
+    onFinished,
+    raf = window.requestAnimationFrame,
+    caf = window.cancelAnimationFrame,
+    duration = 1e3,
+    // eslint-disable-next-line ts/no-use-before-define
+    easing = easeLinear,
+    getTime: getTime$1 = getTime
+  } = options;
+  const rafMethos = { raf, caf };
+  let _cancelRaf = noop;
+  let _canceled = false;
+  const promise = new Promise((resolve) => {
+    const startAt = getTime$1();
+    onStarted?.();
+    const tick = (currentTime) => {
+      if (_canceled) {
+        resolve();
+        return;
+      }
+      const elapsed = currentTime - startAt;
+      const progress = Math.min(elapsed / duration, 1);
+      const value = start + (end - start) * easing(progress);
+      onUpdate(value);
+      if (progress < 1) {
+        _cancelRaf = registerRaf(tick, rafMethos);
+      } else {
+        onFinished?.();
+        resolve();
+      }
+    };
+    _cancelRaf = registerRaf(tick, rafMethos);
+  });
+  promise.cancel = () => {
+    _canceled = true;
+    _cancelRaf();
+  };
+  return promise;
+}
+function runNoopTransition() {
+  const promise = new Promise((resolve) => resolve());
+  promise.cancel = noop;
+  return promise;
+}
+const easeLinear = (t) => t;
+const easeOut = (t) => Math.sin(t * Math.PI / 2);
+const easeOutCubic = (t) => 1 - (1 - t) ** 3;
+
+export { Axis, RectCorner, checkAxis, checkLayoutInvalidate, checkPointEqual, checkPointEqualWithTolerance, checkPointOrigin, checkRectContains, checkRectContainsPoint, checkRectEqual, checkRectEqualPoint, checkRectEqualSize, checkRectIntersects, checkRectIntersectsByAxis, checkRectIntersectsX, checkRectIntersectsY, checkSizeEqual, clamp, clonePoint, cloneRect, createPoint, createRect, createSize, easeLinear, easeOut, easeOutCubic, execLastTick, getPointByAxis, getPointCenter, getPointDistance, getRectArea, getRectBottomLeft, getRectBottomRight, getRectCornerInOther, getRectMaxByAxis, getRectMaxX, getRectMaxY, getRectPointByRectCorner, getRectTopLeft, getRectTopRight, getSizeByAxis, getTime, isObject, noop, registerRaf, reverseAxis, runNoopTransition, runTransition, toPoint, toSize, updatePointByAxis, updateSizeByAxis, usePrevious };

package/package.json

@@ -1,15 +1,23 @@
 {
   "name": "@bouzu/shared",
-  "version": "0.0.1",
+  "version": "0.1.0",
   "private": false,
   "author": "zhong666 <hi@zhong666.me>",
   "license": "MIT",
+  "homepage": "https://bouzu.zhong666.me",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/aa900031/bouzu"
+  },
+  "bugs": {
+    "url": "https://github.com/aa900031/bouzu/issues"
+  },
   "sideEffects": false,
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
-      "require": "./dist/index.cjs",
-      "import": "./dist/index.mjs"
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.cjs"
     }
   },
   "main": "./dist/index.cjs",
@@ -21,7 +29,15 @@
   "publishConfig": {
     "access": "public"
   },
+  "dependencies": {
+    "type-fest": "^3.13.1"
+  },
+  "devDependencies": {
+    "@bouzu/release-it-config": "0.1.0",
+    "@bouzu/tsconfig": "0.1.0"
+  },
   "scripts": {
-    "build": "unbuild"
+    "build": "unbuild",
+    "release": "release-it --ci"
   }
 }