@flighthq/interaction 0.1.0

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "@flighthq/interaction",
+  "version": "0.1.0",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "src/**/*.test.ts",
+    "!dist/**/*.test.js",
+    "!dist/**/*.test.d.ts",
+    "!dist/**/*.test.js.map",
+    "!dist/**/*.test.d.ts.map"
+  ],
+  "scripts": {
+    "build": "tsc -b",
+    "clean": "tsc -b --clean",
+    "test": "vitest run --config vitest.config.ts",
+    "test:watch": "vitest --watch --config vitest.config.ts",
+    "prepack": "npm run clean && npm run clean:dist && npm run build",
+    "clean:dist": "tsx ../../scripts/clean-package-dist.ts"
+  },
+  "dependencies": {
+    "@flighthq/geometry": "0.1.0",
+    "@flighthq/node": "0.1.0",
+    "@flighthq/displayobject": "0.1.0",
+    "@flighthq/signals": "0.1.0",
+    "@flighthq/types": "0.1.0"
+  },
+  "devDependencies": {
+    "@flighthq/shape": "*",
+    "@flighthq/sprite": "*",
+    "typescript": "^5.3.0"
+  },
+  "description": "Hit testing: point-in-node tests and object overlap detection",
+  "sideEffects": false
+}

package/src/displayHitTests.test.ts

@@ -0,0 +1,137 @@
+import { createDisplayObject } from '@flighthq/displayobject';
+import { setRectangle } from '@flighthq/geometry';
+import { getNodeLocalBoundsRectangle } from '@flighthq/node';
+
+import {
+  defaultBitmapHitTestPointHandler,
+  defaultDisplayObjectHitTestPointHandler,
+  defaultHtmlViewHitTestPointHandler,
+  defaultMovieClipHitTestPointHandler,
+  defaultRenderViewHitTestPointHandler,
+  defaultRichTextHitTestPointHandler,
+  defaultShapeHitTestPointHandler,
+  defaultStageHitTestPointHandler,
+  defaultTextHitTestPointHandler,
+  defaultTextInputHitTestPointHandler,
+  defaultVideoHitTestPointHandler,
+} from './displayHitTests';
+
+function makeDisplayObject() {
+  const obj = createDisplayObject();
+  setRectangle(getNodeLocalBoundsRectangle(obj), 0, 0, 100, 100);
+  return obj;
+}
+
+describe('defaultBitmapHitTestPointHandler', () => {
+  it('returns true when point is within local bounds', () => {
+    const obj = makeDisplayObject();
+    expect(defaultBitmapHitTestPointHandler(obj, 50, 50, false)).toBe(true);
+  });
+
+  it('returns false when point is outside local bounds', () => {
+    const obj = makeDisplayObject();
+    expect(defaultBitmapHitTestPointHandler(obj, 200, 200, false)).toBe(false);
+  });
+});
+
+describe('defaultDisplayObjectHitTestPointHandler', () => {
+  it('always returns false — plain display objects have no hit geometry', () => {
+    const obj = makeDisplayObject();
+    expect(defaultDisplayObjectHitTestPointHandler(obj, 50, 50, false)).toBe(false);
+    expect(defaultDisplayObjectHitTestPointHandler(obj, 0, 0, false)).toBe(false);
+    expect(defaultDisplayObjectHitTestPointHandler(obj, 200, 200, false)).toBe(false);
+  });
+});
+
+describe('defaultHtmlViewHitTestPointHandler', () => {
+  it('always returns false — browser manages HtmlView hit testing', () => {
+    const obj = makeDisplayObject();
+    expect(defaultHtmlViewHitTestPointHandler(obj, 50, 50, false)).toBe(false);
+  });
+});
+
+describe('defaultMovieClipHitTestPointHandler', () => {
+  it('always returns false — containers have no self hit area', () => {
+    const obj = makeDisplayObject();
+    expect(defaultMovieClipHitTestPointHandler(obj, 50, 50, false)).toBe(false);
+  });
+});
+
+describe('defaultRenderViewHitTestPointHandler', () => {
+  it('returns true when point is within local bounds', () => {
+    const obj = makeDisplayObject();
+    expect(defaultRenderViewHitTestPointHandler(obj, 50, 50, false)).toBe(true);
+  });
+
+  it('returns false when point is outside local bounds', () => {
+    const obj = makeDisplayObject();
+    expect(defaultRenderViewHitTestPointHandler(obj, 200, 200, false)).toBe(false);
+  });
+});
+
+describe('defaultRichTextHitTestPointHandler', () => {
+  it('returns true when point is within local bounds', () => {
+    const obj = makeDisplayObject();
+    expect(defaultRichTextHitTestPointHandler(obj, 50, 50, false)).toBe(true);
+  });
+
+  it('returns false when point is outside local bounds', () => {
+    const obj = makeDisplayObject();
+    expect(defaultRichTextHitTestPointHandler(obj, 200, 200, false)).toBe(false);
+  });
+});
+
+describe('defaultShapeHitTestPointHandler', () => {
+  it('returns true when point is within local bounds', () => {
+    const obj = makeDisplayObject();
+    expect(defaultShapeHitTestPointHandler(obj, 50, 50, false)).toBe(true);
+  });
+
+  it('returns false when point is outside local bounds', () => {
+    const obj = makeDisplayObject();
+    expect(defaultShapeHitTestPointHandler(obj, 200, 200, false)).toBe(false);
+  });
+});
+
+describe('defaultStageHitTestPointHandler', () => {
+  it('always returns false — containers have no self hit area', () => {
+    const obj = makeDisplayObject();
+    expect(defaultStageHitTestPointHandler(obj, 50, 50, false)).toBe(false);
+  });
+});
+
+describe('defaultTextHitTestPointHandler', () => {
+  it('returns true when point is within local bounds', () => {
+    const obj = makeDisplayObject();
+    expect(defaultTextHitTestPointHandler(obj, 50, 50, false)).toBe(true);
+  });
+
+  it('returns false when point is outside local bounds', () => {
+    const obj = makeDisplayObject();
+    expect(defaultTextHitTestPointHandler(obj, 200, 200, false)).toBe(false);
+  });
+});
+
+describe('defaultTextInputHitTestPointHandler', () => {
+  it('returns true when point is within local bounds', () => {
+    const obj = makeDisplayObject();
+    expect(defaultTextInputHitTestPointHandler(obj, 50, 50, false)).toBe(true);
+  });
+
+  it('returns false when point is outside local bounds', () => {
+    const obj = makeDisplayObject();
+    expect(defaultTextInputHitTestPointHandler(obj, 200, 200, false)).toBe(false);
+  });
+});
+
+describe('defaultVideoHitTestPointHandler', () => {
+  it('returns true when point is within local bounds', () => {
+    const obj = makeDisplayObject();
+    expect(defaultVideoHitTestPointHandler(obj, 50, 50, false)).toBe(true);
+  });
+
+  it('returns false when point is outside local bounds', () => {
+    const obj = makeDisplayObject();
+    expect(defaultVideoHitTestPointHandler(obj, 200, 200, false)).toBe(false);
+  });
+});

package/src/displayObjectOverlap.test.ts

@@ -0,0 +1,78 @@
+import { createDisplayObject } from '@flighthq/displayobject';
+import { createRectangle, setRectangle } from '@flighthq/geometry';
+import { getNodeLocalBoundsRectangle } from '@flighthq/node';
+
+import {
+  containsDisplayObject,
+  getDisplayObjectOverlapRectangle,
+  hitTestDisplayObjectsShape,
+} from './displayObjectOverlap';
+
+function makeAt(x: number, y: number, w: number, h: number) {
+  const obj = createDisplayObject();
+  setRectangle(getNodeLocalBoundsRectangle(obj), x, y, w, h);
+  return obj;
+}
+
+describe('containsDisplayObject', () => {
+  it('returns true when inner is fully inside outer', () => {
+    const outer = makeAt(0, 0, 100, 100);
+    const inner = makeAt(10, 10, 20, 20);
+    expect(containsDisplayObject(outer, inner)).toBe(true);
+  });
+
+  it('returns false when inner extends beyond outer', () => {
+    const outer = makeAt(0, 0, 50, 50);
+    const inner = makeAt(30, 30, 40, 40);
+    expect(containsDisplayObject(outer, inner)).toBe(false);
+  });
+
+  it('returns false when inner is completely outside outer', () => {
+    const outer = makeAt(0, 0, 50, 50);
+    const inner = makeAt(100, 100, 20, 20);
+    expect(containsDisplayObject(outer, inner)).toBe(false);
+  });
+});
+
+describe('getDisplayObjectOverlapRectangle', () => {
+  it('writes the intersection rectangle into out', () => {
+    const a = makeAt(0, 0, 100, 100);
+    const b = makeAt(50, 50, 100, 100);
+    const out = createRectangle();
+    const result = getDisplayObjectOverlapRectangle(a, b, out);
+    expect(result).toBe(out);
+    expect(out.x).toBe(50);
+    expect(out.y).toBe(50);
+    expect(out.width).toBe(50);
+    expect(out.height).toBe(50);
+  });
+
+  it('writes an empty rectangle when there is no overlap', () => {
+    const a = makeAt(0, 0, 50, 50);
+    const b = makeAt(100, 100, 50, 50);
+    const out = createRectangle();
+    getDisplayObjectOverlapRectangle(a, b, out);
+    expect(out.width).toBe(0);
+    expect(out.height).toBe(0);
+  });
+});
+
+describe('hitTestDisplayObjectsShape', () => {
+  it('returns true when centers overlap', () => {
+    const a = makeAt(0, 0, 100, 100);
+    const b = makeAt(20, 20, 60, 60);
+    expect(hitTestDisplayObjectsShape(a, b)).toBe(true);
+  });
+
+  it('returns false when AABBs do not intersect', () => {
+    const a = makeAt(0, 0, 50, 50);
+    const b = makeAt(100, 100, 50, 50);
+    expect(hitTestDisplayObjectsShape(a, b)).toBe(false);
+  });
+
+  it('returns false when AABBs barely intersect but no center is inside the other', () => {
+    const a = makeAt(0, 0, 10, 100);
+    const b = makeAt(8, 0, 10, 100);
+    expect(hitTestDisplayObjectsShape(a, b)).toBe(false);
+  });
+});

package/src/hitTests.test.ts

@@ -0,0 +1,206 @@
+import { createDisplayObject, createDisplayObjectGeneric, getDisplayObjectRuntime } from '@flighthq/displayobject';
+import { setRectangle } from '@flighthq/geometry';
+import { addNodeChild, getNodeLocalBoundsRectangle, invalidateNodeLocalTransform } from '@flighthq/node';
+import type { DisplayObject, DisplayObjectRuntime } from '@flighthq/types';
+import { DisplayObjectKind } from '@flighthq/types';
+
+import {
+  findGraphHitTarget,
+  hitTestDisplayObjects,
+  hitTestGraphLocalBounds,
+  hitTestGraphPoint,
+  registerHitTestPoint,
+} from './hitTests';
+
+describe('findGraphHitTarget', () => {
+  it('returns null when node is disabled', () => {
+    const obj = createDisplayObject();
+    obj.enabled = false;
+    expect(findGraphHitTarget(obj, 50, 50)).toBeNull();
+  });
+
+  it('returns a child node registered with a hit handler', () => {
+    const parent = createDisplayObject();
+    const child = createDisplayObjectGeneric(DisplayObjectKind);
+    setRectangle(getNodeLocalBoundsRectangle(child), 0, 0, 100, 100);
+    addNodeChild(parent, child);
+    registerHitTestPoint(DisplayObjectKind, hitTestGraphLocalBounds);
+    const hit = findGraphHitTarget(parent, 50, 50);
+    expect(hit).toBe(child);
+  });
+});
+
+describe('hitTestDisplayObjects', () => {
+  let a: DisplayObject;
+  let b: DisplayObject;
+
+  beforeEach(() => {
+    a = createDisplayObject();
+    b = createDisplayObject();
+
+    addNodeChild(createDisplayObject(), a);
+    addNodeChild(createDisplayObject(), b);
+
+    setRectangle(getNodeLocalBoundsRectangle(a), 0, 0, 10, 10);
+    setRectangle(getNodeLocalBoundsRectangle(b), 0, 0, 10, 10);
+
+    a.x = 0;
+    a.y = 0;
+    b.x = 5;
+    b.y = 5;
+
+    a.scaleX = a.scaleY = 1;
+    b.scaleX = b.scaleY = 1;
+  });
+
+  it('returns true when bounds intersect', () => {
+    const result = hitTestDisplayObjects(a, b);
+    expect(result).toBe(true);
+  });
+
+  it('returns false when bounds do not intersect', () => {
+    b.x = 20;
+    b.y = 20;
+    invalidateNodeLocalTransform(b);
+
+    const result = hitTestDisplayObjects(a, b);
+    expect(result).toBe(false);
+  });
+
+  it('returns false if either object has no parent', () => {
+    (getDisplayObjectRuntime(b) as DisplayObjectRuntime).parent = null;
+
+    const result = hitTestDisplayObjects(a, b);
+    expect(result).toBe(false);
+  });
+
+  it('compares bounds in world space', () => {
+    a.scaleX = 1;
+    a.scaleY = 1;
+
+    b.x = 5;
+    b.y = 5;
+    invalidateNodeLocalTransform(b);
+
+    const result = hitTestDisplayObjects(a, b);
+    expect(result).toBe(true);
+  });
+
+  it('includes child bounds when a child extends beyond the object local bounds', () => {
+    const child = createDisplayObject();
+    child.x = 90;
+    child.y = 90;
+    invalidateNodeLocalTransform(child);
+    setRectangle(getNodeLocalBoundsRectangle(child), 0, 0, 20, 20);
+    addNodeChild(a, child);
+
+    b.x = 100;
+    b.y = 100;
+    invalidateNodeLocalTransform(b);
+
+    expect(hitTestDisplayObjects(a, b)).toBe(true);
+  });
+});
+
+describe('hitTestGraphLocalBounds', () => {
+  it('returns true when world-space point is inside local bounds', () => {
+    const obj = createDisplayObject();
+    setRectangle(getNodeLocalBoundsRectangle(obj), 0, 0, 100, 100);
+    expect(hitTestGraphLocalBounds(obj, 50, 50)).toBe(true);
+  });
+
+  it('returns false when world-space point is outside local bounds', () => {
+    const obj = createDisplayObject();
+    setRectangle(getNodeLocalBoundsRectangle(obj), 0, 0, 100, 100);
+    expect(hitTestGraphLocalBounds(obj, 200, 200)).toBe(false);
+  });
+});
+
+describe('hitTestGraphPoint', () => {
+  let obj: DisplayObject;
+
+  beforeAll(() => {
+    registerHitTestPoint(DisplayObjectKind, hitTestGraphLocalBounds);
+  });
+
+  beforeEach(() => {
+    obj = createDisplayObject();
+    setRectangle(getNodeLocalBoundsRectangle(obj), 0, 0, 100, 100);
+  });
+
+  it('returns true for point inside bounds', () => {
+    const result = hitTestGraphPoint(obj, 50, 50);
+    expect(result).toBe(true);
+  });
+
+  it('returns false for point outside bounds', () => {
+    const result = hitTestGraphPoint(obj, 200, 200);
+    expect(result).toBe(false);
+  });
+
+  it('returns false if object is not enabled', () => {
+    obj.enabled = false;
+    const result = hitTestGraphPoint(obj, 50, 50);
+    expect(result).toBe(false);
+  });
+
+  it('returns false when point is outside bounds', () => {
+    const result = hitTestGraphPoint(obj, 200, 200);
+    expect(result).toBe(false);
+  });
+
+  it('respects world transform', () => {
+    obj.x = 100;
+    obj.y = 100;
+    invalidateNodeLocalTransform(obj);
+    const inside = hitTestGraphPoint(obj, 150, 150);
+    const outside = hitTestGraphPoint(obj, 50, 50);
+
+    expect(inside).toBe(true);
+    expect(outside).toBe(false);
+  });
+
+  it('works with the default shapeFlag param', () => {
+    const result = hitTestGraphPoint(obj, 50, 50);
+    expect(result).toBe(true);
+
+    const resultExplicit = hitTestGraphPoint(obj, 50, 50, true);
+    expect(resultExplicit).toBe(true);
+  });
+
+  it('returns true when a child is hit even if the parent has no local bounds', () => {
+    const child = createDisplayObject();
+    setRectangle(getNodeLocalBoundsRectangle(child), 0, 0, 100, 100);
+    addNodeChild(obj, child);
+
+    setRectangle(getNodeLocalBoundsRectangle(obj), 0, 0, 0, 0);
+    expect(hitTestGraphPoint(obj, 50, 50)).toBe(true);
+  });
+
+  it('does not test children of a disabled parent', () => {
+    obj.enabled = false;
+
+    const child = createDisplayObject();
+    setRectangle(getNodeLocalBoundsRectangle(child), 0, 0, 100, 100);
+    addNodeChild(obj, child);
+
+    expect(hitTestGraphPoint(obj, 50, 50)).toBe(false);
+  });
+
+  it('uses a registered handler for a custom kind', () => {
+    const CustomKind = 'CustomKind';
+    registerHitTestPoint(CustomKind, () => true);
+    const custom = createDisplayObjectGeneric(CustomKind);
+
+    expect(hitTestGraphPoint(custom, 50, 50)).toBe(true);
+  });
+});
+
+describe('registerHitTestPoint', () => {
+  it('registers a handler that hitTestGraphPoint will use', () => {
+    const kind = 'RegisterTest';
+    registerHitTestPoint(kind, () => true);
+    const node = createDisplayObjectGeneric(kind);
+    expect(hitTestGraphPoint(node, 0, 0)).toBe(true);
+  });
+});