@bouzu/shared 0.0.1

package/dist/index.cjs

@@ -0,0 +1,180 @@
+'use strict';
+
+function noop() {
+}
+
+function usePrevious(val) {
+  const value = {
+    curr: val,
+    prev: val
+  };
+  Object.defineProperty(value, "curr", { writable: false });
+  Object.defineProperty(value, "prev", { writable: false });
+  return [
+    value,
+    (nextValue) => {
+      Object.defineProperty(value, "prev", { value: value.curr, writable: false });
+      Object.defineProperty(value, "curr", { value: nextValue, writable: false });
+    }
+  ];
+}
+
+function execLastTick(tickFn, fn, ...tickFnArgs) {
+  let taskId = 0;
+  let lastArgs;
+  return (...fnArgs) => {
+    lastArgs = fnArgs;
+    taskId++;
+    const currId = taskId;
+    tickFn(
+      () => {
+        if (currId !== taskId)
+          return;
+        fn.apply(null, lastArgs ?? []);
+      },
+      ...tickFnArgs
+    );
+  };
+}
+
+function createPoint(x = 0, y = 0) {
+  return { x, y };
+}
+function checkPointOrigin(p) {
+  return p.x === 0 && p.y === 0;
+}
+function checkPointEqual(a, b) {
+  return a.x === b.x && a.y === b.y;
+}
+
+function createSize(width = 0, height = 0) {
+  return { width, height };
+}
+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 || {});
+function createRect(x = 0, y = 0, width = 0, height = 0) {
+  return {
+    ...createPoint(x, y),
+    ...createSize(width, height)
+  };
+}
+function cloneRect(rect) {
+  return createRect(rect.x, rect.y, rect.width, rect.height);
+}
+function getRectMaxX(rect) {
+  return rect.x + rect.width;
+}
+function getRectMaxY(rect) {
+  return rect.y + rect.height;
+}
+function getRectArea(rect) {
+  return rect.width * rect.height;
+}
+function getRectTopLeft(rect) {
+  return createPoint(rect.x, rect.y);
+}
+function getRectTopRight(rect) {
+  return createPoint(getRectMaxX(rect), rect.y);
+}
+function getRectBottomLeft(rect) {
+  return createPoint(rect.x, getRectMaxY(rect));
+}
+function getRectBottomRight(rect) {
+  return createPoint(getRectMaxX(rect), getRectMaxY(rect));
+}
+function getRectPointByRectCorner(rect, corner) {
+  switch (corner) {
+    case "TopLeft" /* TopLeft */:
+      return getRectTopLeft(rect);
+    case "TopRight" /* TopRight */:
+      return getRectTopRight(rect);
+    case "BottomLeft" /* BottomLeft */:
+      return getRectBottomLeft(rect);
+    case "BottomRight" /* BottomRight */:
+      return getRectBottomRight(rect);
+    default:
+      throw new TypeError(`Not match corner: ${corner}`);
+  }
+}
+function checkRectIntersectsX(a, b) {
+  return a.x <= getRectMaxX(b) && b.x <= getRectMaxX(a);
+}
+function checkRectIntersectsY(a, b) {
+  return a.y <= getRectMaxY(b) && b.y <= getRectMaxY(a);
+}
+function checkRectIntersects(a, b) {
+  return checkRectIntersectsX(a, b) && checkRectIntersectsY(a, b);
+}
+function checkRectContains(a, b) {
+  return a.x <= b.x && a.y <= b.y && getRectMaxX(a) >= getRectMaxX(b) && getRectMaxY(a) >= getRectMaxY(b);
+}
+function checkRectContainsPoint(a, p) {
+  return a.x <= p.x && a.y <= p.y && getRectMaxX(a) >= p.x && getRectMaxY(a) >= p.y;
+}
+function getRectCornerInOther(a, b) {
+  for (const key in RectCorner) {
+    const point = getRectPointByRectCorner(a, RectCorner[key]);
+    if (checkRectContainsPoint(b, point))
+      return RectCorner[key];
+  }
+  return null;
+}
+function checkRectEqual(a, b) {
+  return a.x === b.x && a.y === b.y && a.width === b.width && a.height === b.height;
+}
+function checkRectEqualPoint(r, p) {
+  return r.x === p.x && r.y === p.y;
+}
+function checkRectEqualSize(r, s) {
+  return r.width === s.width && r.height === s.height;
+}
+function checkLayoutInvalidate(newRect, oldRect) {
+  return newRect.width !== oldRect.width || newRect.height !== oldRect.height;
+}
+function toSize(rect) {
+  return createSize(rect.width, rect.height);
+}
+function toPoint(rect) {
+  return createPoint(rect.x, rect.y);
+}
+
+exports.RectCorner = RectCorner;
+exports.checkLayoutInvalidate = checkLayoutInvalidate;
+exports.checkPointEqual = checkPointEqual;
+exports.checkPointOrigin = checkPointOrigin;
+exports.checkRectContains = checkRectContains;
+exports.checkRectContainsPoint = checkRectContainsPoint;
+exports.checkRectEqual = checkRectEqual;
+exports.checkRectEqualPoint = checkRectEqualPoint;
+exports.checkRectEqualSize = checkRectEqualSize;
+exports.checkRectIntersects = checkRectIntersects;
+exports.checkRectIntersectsX = checkRectIntersectsX;
+exports.checkRectIntersectsY = checkRectIntersectsY;
+exports.checkSizeEqual = checkSizeEqual;
+exports.cloneRect = cloneRect;
+exports.createPoint = createPoint;
+exports.createRect = createRect;
+exports.createSize = createSize;
+exports.execLastTick = execLastTick;
+exports.getRectArea = getRectArea;
+exports.getRectBottomLeft = getRectBottomLeft;
+exports.getRectBottomRight = getRectBottomRight;
+exports.getRectCornerInOther = getRectCornerInOther;
+exports.getRectMaxX = getRectMaxX;
+exports.getRectMaxY = getRectMaxY;
+exports.getRectPointByRectCorner = getRectPointByRectCorner;
+exports.getRectTopLeft = getRectTopLeft;
+exports.getRectTopRight = getRectTopRight;
+exports.noop = noop;
+exports.toPoint = toPoint;
+exports.toSize = toSize;
+exports.usePrevious = usePrevious;

package/dist/index.d.ts

@@ -0,0 +1,60 @@
+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;
+
+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 enum RectCorner {
+    TopLeft = "TopLeft",
+    TopRight = "TopRight",
+    BottomLeft = "BottomLeft",
+    BottomRight = "BottomRight"
+}
+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: RectCorner): 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 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;
+
+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 };

package/dist/index.mjs

@@ -0,0 +1,148 @@
+function noop() {
+}
+
+function usePrevious(val) {
+  const value = {
+    curr: val,
+    prev: val
+  };
+  Object.defineProperty(value, "curr", { writable: false });
+  Object.defineProperty(value, "prev", { writable: false });
+  return [
+    value,
+    (nextValue) => {
+      Object.defineProperty(value, "prev", { value: value.curr, writable: false });
+      Object.defineProperty(value, "curr", { value: nextValue, writable: false });
+    }
+  ];
+}
+
+function execLastTick(tickFn, fn, ...tickFnArgs) {
+  let taskId = 0;
+  let lastArgs;
+  return (...fnArgs) => {
+    lastArgs = fnArgs;
+    taskId++;
+    const currId = taskId;
+    tickFn(
+      () => {
+        if (currId !== taskId)
+          return;
+        fn.apply(null, lastArgs ?? []);
+      },
+      ...tickFnArgs
+    );
+  };
+}
+
+function createPoint(x = 0, y = 0) {
+  return { x, y };
+}
+function checkPointOrigin(p) {
+  return p.x === 0 && p.y === 0;
+}
+function checkPointEqual(a, b) {
+  return a.x === b.x && a.y === b.y;
+}
+
+function createSize(width = 0, height = 0) {
+  return { width, height };
+}
+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 || {});
+function createRect(x = 0, y = 0, width = 0, height = 0) {
+  return {
+    ...createPoint(x, y),
+    ...createSize(width, height)
+  };
+}
+function cloneRect(rect) {
+  return createRect(rect.x, rect.y, rect.width, rect.height);
+}
+function getRectMaxX(rect) {
+  return rect.x + rect.width;
+}
+function getRectMaxY(rect) {
+  return rect.y + rect.height;
+}
+function getRectArea(rect) {
+  return rect.width * rect.height;
+}
+function getRectTopLeft(rect) {
+  return createPoint(rect.x, rect.y);
+}
+function getRectTopRight(rect) {
+  return createPoint(getRectMaxX(rect), rect.y);
+}
+function getRectBottomLeft(rect) {
+  return createPoint(rect.x, getRectMaxY(rect));
+}
+function getRectBottomRight(rect) {
+  return createPoint(getRectMaxX(rect), getRectMaxY(rect));
+}
+function getRectPointByRectCorner(rect, corner) {
+  switch (corner) {
+    case "TopLeft" /* TopLeft */:
+      return getRectTopLeft(rect);
+    case "TopRight" /* TopRight */:
+      return getRectTopRight(rect);
+    case "BottomLeft" /* BottomLeft */:
+      return getRectBottomLeft(rect);
+    case "BottomRight" /* BottomRight */:
+      return getRectBottomRight(rect);
+    default:
+      throw new TypeError(`Not match corner: ${corner}`);
+  }
+}
+function checkRectIntersectsX(a, b) {
+  return a.x <= getRectMaxX(b) && b.x <= getRectMaxX(a);
+}
+function checkRectIntersectsY(a, b) {
+  return a.y <= getRectMaxY(b) && b.y <= getRectMaxY(a);
+}
+function checkRectIntersects(a, b) {
+  return checkRectIntersectsX(a, b) && checkRectIntersectsY(a, b);
+}
+function checkRectContains(a, b) {
+  return a.x <= b.x && a.y <= b.y && getRectMaxX(a) >= getRectMaxX(b) && getRectMaxY(a) >= getRectMaxY(b);
+}
+function checkRectContainsPoint(a, p) {
+  return a.x <= p.x && a.y <= p.y && getRectMaxX(a) >= p.x && getRectMaxY(a) >= p.y;
+}
+function getRectCornerInOther(a, b) {
+  for (const key in RectCorner) {
+    const point = getRectPointByRectCorner(a, RectCorner[key]);
+    if (checkRectContainsPoint(b, point))
+      return RectCorner[key];
+  }
+  return null;
+}
+function checkRectEqual(a, b) {
+  return a.x === b.x && a.y === b.y && a.width === b.width && a.height === b.height;
+}
+function checkRectEqualPoint(r, p) {
+  return r.x === p.x && r.y === p.y;
+}
+function checkRectEqualSize(r, s) {
+  return r.width === s.width && r.height === s.height;
+}
+function checkLayoutInvalidate(newRect, oldRect) {
+  return newRect.width !== oldRect.width || newRect.height !== oldRect.height;
+}
+function toSize(rect) {
+  return createSize(rect.width, rect.height);
+}
+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 };

package/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "@bouzu/shared",
+  "version": "0.0.1",
+  "private": false,
+  "author": "zhong666 <hi@zhong666.me>",
+  "license": "MIT",
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "require": "./dist/index.cjs",
+      "import": "./dist/index.mjs"
+    }
+  },
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "unbuild"
+  }
+}