canvas2d-wrapper 2.1.1 → 2.2.1

package/dist/collisions/collideElement.js

@@ -1,53 +1,62 @@
-import f from "../functions/calcTileSize.js";
-import u from "./inCircle.js";
-import p from "./inPoly.js";
-import x from "./inRect.js";
-import y from "./onLinePath.js";
-function I(o, c, a, s, m, d) {
-  const r = f(m, d), i = [];
-  for (const e of c) {
-    if (!e.hasCollisions)
+import u from "../functions/calcTileSize.js";
+import f from "./pointInCircle.js";
+import x from "./pointInPolygon.js";
+import h from "./pointInRectangle.js";
+import g from "./pointOnLinePath.js";
+function O(r, d, s, l, p, m) {
+  const e = u(p, m), i = [];
+  for (const n of d) {
+    if (!n.hasCollisions)
       continue;
-    const n = e.x * r, l = e.y * r;
-    switch (e.constructorName) {
+    const t = n.x * e, a = n.y * e;
+    switch (n.constructorName) {
       case "Rect":
       case "CanvasImage":
-        const t = e;
-        x(t, n, l, a, s, r, t.rotation) && i.push({
-          id: t.id,
-          element: e,
-          originalEvent: o,
-          posOnMap: { x: t.x, y: t.y }
+        const o = n;
+        h(
+          t,
+          a,
+          o.width * e,
+          o.height * e,
+          s,
+          l,
+          o.rotation
+        ) && i.push({
+          id: o.id,
+          element: n,
+          originalEvent: r,
+          posOnMap: { x: o.x, y: o.y }
         });
         break;
       case "Circle":
-        u(e, n, l, a, s, r) && i.push({
-          id: e.id,
-          element: e,
-          originalEvent: o,
-          posOnMap: { x: e.x, y: e.y }
+        f(t, a, n.radius * e, s, l) && i.push({
+          id: n.id,
+          element: n,
+          originalEvent: r,
+          posOnMap: { x: n.x, y: n.y }
         });
         break;
       case "Polygon":
-        p(e, a, s, r) && i.push({
-          id: e.id,
-          element: e,
-          originalEvent: o,
-          posOnMap: { x: e.x, y: e.y }
+        x(n.points, s, l, e) && i.push({
+          id: n.id,
+          element: n,
+          originalEvent: r,
+          posOnMap: { x: n.x, y: n.y }
         });
         break;
       case "LinePath":
-        y(e, a, s, r) && i.push({
-          id: e.id,
-          element: e,
-          originalEvent: o,
-          posOnMap: { x: e.x, y: e.y }
+        const c = n;
+        g(c.points, c.lineWidth, s, l, e) && i.push({
+          id: n.id,
+          element: n,
+          originalEvent: r,
+          posOnMap: { x: n.x, y: n.y }
         });
         break;
     }
   }
-  return i.length === 0 ? null : (i.length === 1 || i.sort((e, n) => e.element.zIndex > n.element.zIndex ? -1 : e.element.zIndex < n.element.zIndex || e.id > n.id ? 1 : e.id < n.id ? -1 : 0), i[0]);
+  return i.length === 0 ? null : (i.length === 1 || i.sort((n, t) => n.element.zIndex > t.element.zIndex ? -1 : n.element.zIndex < t.element.zIndex || n.id > t.id ? 1 : n.id < t.id ? -1 : 0), i[0]);
 }
 export {
-  I as default
+  O as default
 };

package/dist/collisions/lineWithLine.d.ts

@@ -0,0 +1,2 @@
+import { default as Position2D } from '../types/Position2D';
+export default function lineWithLine(aOrigin: Position2D, aDestination: Position2D, bOrigin: Position2D, bDestination: Position2D): Position2D | null;

package/dist/collisions/lineWithLine.js

@@ -0,0 +1,7 @@
+function e(x, l, y, u) {
+  const t = l.x - x.x, c = l.y - x.y, s = u.x - y.x, d = u.y - y.y, _ = (-c * (x.x - y.x) + t * (x.y - y.y)) / (-s * c + t * d), o = (+s * (x.y - y.y) - d * (x.x - y.x)) / (-s * c + t * d);
+  return _ >= 0 && _ <= 1 && o >= 0 && o <= 1 ? { x: x.x + o * t, y: x.y + o * c } : null;
+}
+export {
+  e as default
+};

package/dist/collisions/pointInCircle.d.ts

@@ -0,0 +1 @@
+export default function pointInCircle(centerX: number, centerY: number, radius: number, pointX: number, pointY: number): boolean;

package/dist/collisions/pointInCircle.js

@@ -0,0 +1,6 @@
+function e(n, t, a, c, s) {
+  return (n - c) * (n - c) + (t - s) * (t - s) <= a * a;
+}
+export {
+  e as default
+};

package/dist/collisions/pointInPolygon.d.ts

@@ -0,0 +1,2 @@
+import { default as Position2D } from '../types/Position2D';
+export default function pointInPolygon(points: Position2D[], pointX: number, pointY: number, tileSize?: number): boolean;

package/dist/collisions/pointInPolygon.js

@@ -0,0 +1,21 @@
+function s(r, a, t, u = 1) {
+  let n = !1;
+  for (let e = 0; e < r.length; e++) {
+    const l = r[e].x * u, f = r[e].y * u;
+    if (a === l && t === f)
+      return !0;
+    let c = e + 1;
+    c >= r.length && (c = 0);
+    const j = r[c].x * u, o = r[c].y * u;
+    if (f > t != o > t) {
+      const g = (a - l) * (o - f) - (j - l) * (t - f);
+      if (g === 0)
+        return !0;
+      g < 0 != o < f && (n = !n);
+    }
+  }
+  return n;
+}
+export {
+  s as default
+};

package/dist/collisions/pointInRectangle.d.ts

@@ -0,0 +1 @@
+export default function pointInRectangle(rectangleX: number, rectangleY: number, rectangleWidth: number, rectangleHeight: number, pointX: number, pointY: number, rotation?: number): boolean;

package/dist/collisions/pointInRectangle.js

@@ -0,0 +1,11 @@
+function L(f, M, x, I, u, c, s) {
+  let d = u, h = c;
+  if (s) {
+    const e = f + x / 2, t = M + I / 2;
+    d = e + (u - e) * Math.cos(-s) - (c - t) * Math.sin(-s), h = t + (c - t) * Math.cos(-s) + (u - e) * Math.sin(-s);
+  }
+  return f <= d && d <= f + x && M <= h && h <= M + I;
+}
+export {
+  L as default
+};

package/dist/collisions/pointOnLinePath.d.ts

@@ -0,0 +1,2 @@
+import { default as Position2D } from '../types/Position2D';
+export default function pointOnLinePath(points: Position2D[], lineWidth: number, pointX: number, pointY: number, tileSize?: number): boolean;

package/dist/collisions/pointOnLinePath.js

@@ -0,0 +1,45 @@
+import h from "./pointInCircle.js";
+function q(r, m, u, n, x = 1) {
+  const a = m / 2;
+  if (h(
+    r[0].x * x,
+    r[0].y * x,
+    a * x,
+    u,
+    n
+  ) || h(
+    r[r.length - 1].x * x,
+    r[r.length - 1].y * x,
+    a * x,
+    u,
+    n
+  ))
+    return !0;
+  for (let f = 1; f < r.length; f++) {
+    const y = {
+      x: r[f - 1].x * x,
+      y: r[f - 1].y * x
+    }, c = {
+      x: r[f].x * x,
+      y: r[f].y * x
+    }, d = y.x - c.x, o = y.y - c.y, s = Math.sqrt(d * d + o * o), t = ((u - y.x) * (c.x - y.x) + (n - y.y) * (c.y - y.y)) / Math.pow(s, 2);
+    if (t < 0 || t > 1)
+      continue;
+    const g = {
+      x: y.x + t * (c.x - y.x),
+      y: y.y + t * (c.y - y.y)
+    };
+    if (h(
+      g.x,
+      g.y,
+      a * x,
+      u,
+      n
+    ))
+      return !0;
+  }
+  return !1;
+}
+export {
+  q as default
+};

package/dist/main.d.ts

@@ -1,9 +1,17 @@
 import { default as Canvas2D } from './Canvas2D';
+import { default as lineWithLine } from './collisions/lineWithLine';
+import { default as pointInCircle } from './collisions/pointInCircle';
+import { default as pointInPolygon } from './collisions/pointInPolygon';
+import { default as pointInRectangle } from './collisions/pointInRectangle';
+import { default as pointOnLinePath } from './collisions/pointOnLinePath';
 import { default as preloadImages } from './functions/preloadImages';
 import { default as useGamepad } from './hooks/useGamepad';
 import { default as useKeyboard } from './hooks/useKeyboard';
 import { default as useMousePosition } from './hooks/useMousePosition';
 import { default as useWindowDimensions } from './hooks/useWindowDimensions';
+import { default as getLineLength } from './maths/getLineLength';
+import { default as normalOnLine } from './maths/normalOnLine';
+import { default as segmentAngle } from './maths/segmentAngle';
 import { default as CanvasImage } from './shapes/CanvasImage';
 import { default as CanvasObject } from './shapes/CanvasObject';
 import { default as Circle } from './shapes/Circle';
@@ -21,4 +29,10 @@ declare global {
         };
     };
 }
-export { Canvas2D, CanvasImage, CanvasObject, Circle, LinePath, Polygon, preloadImages, Rect, useGamepad, useKeyboard, useMousePosition, useWindowDimensions, type Canvas2DProps, type CollideElementResultItem, type Position2D, type Surface2D };
+export { Canvas2D };
+export { CanvasImage, CanvasObject, Circle, LinePath, Polygon, Rect };
+export { lineWithLine, pointInCircle, pointInPolygon, pointInRectangle, pointOnLinePath };
+export { preloadImages };
+export { useGamepad, useKeyboard, useMousePosition, useWindowDimensions };
+export { getLineLength, normalOnLine, segmentAngle };
+export { type Canvas2DProps, type CollideElementResultItem, type Position2D, type Surface2D };

package/dist/main.js

@@ -1,26 +1,42 @@
 import { default as o } from "./Canvas2D.js";
-import { default as r } from "./functions/preloadImages.js";
-import { default as s } from "./hooks/useGamepad.js";
-import { default as d } from "./hooks/useKeyboard.js";
-import { default as l } from "./hooks/useMousePosition.js";
-import { default as x } from "./hooks/useWindowDimensions.js";
-import { default as i } from "./shapes/CanvasImage.js";
-import { default as c } from "./shapes/CanvasObject.js";
-import { default as v } from "./shapes/Circle.js";
-import { default as b } from "./shapes/LinePath.js";
-import { default as D } from "./shapes/Polygon.js";
-import { default as h } from "./shapes/Rect.js";
+import { default as r } from "./collisions/lineWithLine.js";
+import { default as s } from "./collisions/pointInCircle.js";
+import { default as n } from "./collisions/pointInPolygon.js";
+import { default as p } from "./collisions/pointInRectangle.js";
+import { default as d } from "./collisions/pointOnLinePath.js";
+import { default as i } from "./functions/preloadImages.js";
+import { default as L } from "./hooks/useGamepad.js";
+import { default as C } from "./hooks/useKeyboard.js";
+import { default as P } from "./hooks/useMousePosition.js";
+import { default as v } from "./hooks/useWindowDimensions.js";
+import { default as O } from "./maths/getLineLength.js";
+import { default as D } from "./maths/normalOnLine.js";
+import { default as W } from "./maths/segmentAngle.js";
+import { default as w } from "./shapes/CanvasImage.js";
+import { default as G } from "./shapes/CanvasObject.js";
+import { default as M } from "./shapes/Circle.js";
+import { default as q } from "./shapes/LinePath.js";
+import { default as B } from "./shapes/Polygon.js";
+import { default as F } from "./shapes/Rect.js";
 export {
   o as Canvas2D,
-  i as CanvasImage,
-  c as CanvasObject,
-  v as Circle,
-  b as LinePath,
-  D as Polygon,
-  h as Rect,
-  r as preloadImages,
-  s as useGamepad,
-  d as useKeyboard,
-  l as useMousePosition,
-  x as useWindowDimensions
+  w as CanvasImage,
+  G as CanvasObject,
+  M as Circle,
+  q as LinePath,
+  B as Polygon,
+  F as Rect,
+  O as getLineLength,
+  r as lineWithLine,
+  D as normalOnLine,
+  s as pointInCircle,
+  n as pointInPolygon,
+  p as pointInRectangle,
+  d as pointOnLinePath,
+  i as preloadImages,
+  W as segmentAngle,
+  L as useGamepad,
+  C as useKeyboard,
+  P as useMousePosition,
+  v as useWindowDimensions
 };

package/dist/maths/getLineLength.d.ts

@@ -0,0 +1,2 @@
+import { default as Position2D } from '../types/Position2D.ts';
+export default function getLineLength(from: Position2D, to: Position2D): number;

package/dist/maths/getLineLength.js

@@ -0,0 +1,7 @@
+function i(t, n) {
+  const e = n.x - t.x, f = n.y - t.y;
+  return Math.sqrt(e * e + f * f);
+}
+export {
+  i as default
+};

package/dist/maths/normalOnLine.d.ts

@@ -0,0 +1,2 @@
+import { Position2D } from '../main';
+export default function normalOnLine(lineOrigin: Position2D, lineDestination: Position2D, clockwise?: boolean): Position2D | null;

package/dist/maths/normalOnLine.js

@@ -0,0 +1,7 @@
+function f(n, t, o = !1) {
+  const s = t.x - n.x, x = t.y - n.y, y = Math.hypot(s, x), c = s / y, u = x / y, a = o ? u : -u, d = o ? -c : c;
+  return { x: a, y: d };
+}
+export {
+  f as default
+};

package/dist/maths/segmentAngle.d.ts

@@ -0,0 +1,2 @@
+import { default as Position2D } from '../types/Position2D';
+export default function segmentAngle(from: Position2D, to: Position2D): number;

package/dist/maths/segmentAngle.js

@@ -0,0 +1,7 @@
+function r(t, n) {
+  const e = n.x - t.x, a = n.y - t.y;
+  return e === 0 && a === 0 ? 0 : Math.atan2(a, e) + Math.PI / 2;
+}
+export {
+  r as default
+};

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "canvas2d-wrapper",
-	"version": "2.1.1",
+	"version": "2.2.1",
 	"type": "module",
 	"main": "dist/main.js",
 	"types": "dist/main.d.ts",
@@ -20,28 +20,28 @@
 		"react-dom": "^19.0.0"
 	},
 	"devDependencies": {
-		"@eslint/js": "^9.39.0",
+		"@eslint/js": "^9.39.1",
 		"@testing-library/jest-dom": "^6.9.1",
 		"@testing-library/react": "^16.3.0",
 		"@types/jest": "^30.0.0",
-		"@types/node": "^24.9.2",
-		"@types/react": "^19.2.2",
-		"@types/react-dom": "^19.2.2",
-		"@vitejs/plugin-react": "^5.1.0",
-		"@vitest/coverage-v8": "^4.0.6",
-		"eslint": "^9.39.0",
+		"@types/node": "^25.0.1",
+		"@types/react": "^19.2.7",
+		"@types/react-dom": "^19.2.3",
+		"@vitejs/plugin-react": "^5.1.2",
+		"@vitest/coverage-v8": "^4.0.15",
+		"eslint": "^9.39.1",
 		"eslint-plugin-react-hooks": "^7.0.1",
 		"eslint-plugin-react-refresh": "^0.4.24",
-		"glob": "^11.0.3",
+		"glob": "^13.0.0",
 		"globals": "^16.5.0",
-		"jsdom": "^27.1.0",
-		"react": "^19.2.0",
-		"react-dom": "^19.2.0",
+		"jsdom": "^27.3.0",
+		"react": "^19.2.3",
+		"react-dom": "^19.2.3",
 		"typescript": "5.9",
-		"typescript-eslint": "^8.46.2",
-		"vite": "^7.1.12",
+		"typescript-eslint": "^8.49.0",
+		"vite": "^7.2.7",
 		"vite-plugin-dts": "^4.5.4",
 		"vite-plugin-lib-inject-css": "^2.2.2",
-		"vitest": "^4.0.6"
+		"vitest": "^4.0.15"
 	}
 }