@flighthq/shape 0.1.0

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "@flighthq/shape",
+  "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/displayobject": "0.1.0",
+    "@flighthq/geometry": "0.1.0",
+    "@flighthq/node": "0.1.0",
+    "@flighthq/path": "0.1.0",
+    "@flighthq/types": "0.1.0"
+  },
+  "devDependencies": {
+    "typescript": "^5.3.0"
+  },
+  "description": "Vector Shape display node: drawing commands, scale-9 shapes, and shape hit testing",
+  "sideEffects": false
+}

package/src/scale9Shape.test.ts

@@ -0,0 +1,64 @@
+import { Scale9ShapeKind } from '@flighthq/types';
+
+import {
+  createScale9Shape,
+  createScale9ShapeData,
+  createScale9ShapeRuntime,
+  getScale9ShapeRuntime,
+} from './scale9Shape';
+
+const grid = { x: 10, y: 10, width: 80, height: 80 };
+
+describe('createScale9Shape', () => {
+  it('returns a shape with the given scale9Grid on its data', () => {
+    const shape = createScale9Shape(grid);
+    expect(shape.data.scale9Grid).toBe(grid);
+  });
+
+  it('initializes with an empty commands array', () => {
+    const shape = createScale9Shape(grid);
+    expect(shape.data.commands).toHaveLength(0);
+  });
+
+  it('has Scale9ShapeKind', () => {
+    const shape = createScale9Shape(grid);
+    expect(shape.kind).toStrictEqual(Scale9ShapeKind);
+  });
+
+  it('returns a new object each call', () => {
+    expect(createScale9Shape(grid)).not.toBe(createScale9Shape(grid));
+  });
+});
+
+describe('createScale9ShapeData', () => {
+  it('stores the scale9Grid reference', () => {
+    const data = createScale9ShapeData(grid);
+    expect(data.scale9Grid).toBe(grid);
+  });
+
+  it('returns an empty commands array', () => {
+    const data = createScale9ShapeData(grid);
+    expect(data.commands).toHaveLength(0);
+  });
+
+  it('uses provided commands when given', () => {
+    const commands = [{ key: 'endFill' as const, args: [] as const }];
+    const data = createScale9ShapeData(grid, { commands });
+    expect(data.commands).toBe(commands);
+  });
+});
+
+describe('createScale9ShapeRuntime', () => {
+  it('returns a non-null runtime', () => {
+    const runtime = createScale9ShapeRuntime();
+    expect(runtime).not.toBeNull();
+  });
+});
+
+describe('getScale9ShapeRuntime', () => {
+  it('returns the runtime for a Scale9Shape', () => {
+    const shape = createScale9Shape(grid);
+    const runtime = getScale9ShapeRuntime(shape);
+    expect(runtime).not.toBeNull();
+  });
+});

package/src/shape.test.ts

@@ -0,0 +1,207 @@
+import { createRectangle } from '@flighthq/geometry';
+import { getNodeLocalBoundsRevision, getNodeLocalContentRevision } from '@flighthq/node';
+import { ShapeKind } from '@flighthq/types';
+
+import {
+  clearShapeCommands,
+  computeShapeLocalBoundsRectangle,
+  copyShapeCommands,
+  createShape,
+  createShapeData,
+  createShapeRuntime,
+  getShapeBounds,
+  getShapeCommandCount,
+  getShapeRuntime,
+  invalidateShapeGeometry,
+  isShapeEmpty,
+} from './shape';
+
+describe('clearShapeCommands', () => {
+  it('empties the commands array and bumps the content revision', () => {
+    const shape = createShape();
+    shape.data.commands.push('endFill', 0);
+    const content = getNodeLocalContentRevision(shape);
+    clearShapeCommands(shape);
+    expect(shape.data.commands).toHaveLength(0);
+    expect(getNodeLocalContentRevision(shape)).toBe(content + 1);
+  });
+});
+
+describe('computeShapeLocalBoundsRectangle', () => {
+  it('sets out to zero for an empty shape with no commands', () => {
+    const shape = createShape();
+    const out = createRectangle(1, 2, 3, 4);
+    computeShapeLocalBoundsRectangle(out, shape as any);
+    expect(out.x).toBe(0);
+    expect(out.y).toBe(0);
+    expect(out.width).toBe(0);
+    expect(out.height).toBe(0);
+  });
+
+  it('computes bounds from drawRectangle commands', () => {
+    const shape = createShape();
+    shape.data.commands.push('drawRectangle', 4, 10, 20, 100, 50);
+    const out = createRectangle();
+    computeShapeLocalBoundsRectangle(out, shape as any);
+    expect(out.x).toBe(10);
+    expect(out.y).toBe(20);
+    expect(out.width).toBe(100);
+    expect(out.height).toBe(50);
+  });
+
+  it('computes bounds from moveTo and lineTo commands', () => {
+    const shape = createShape();
+    shape.data.commands.push('moveTo', 2, 0, 0, 'lineTo', 2, 80, 60);
+    const out = createRectangle();
+    computeShapeLocalBoundsRectangle(out, shape as any);
+    expect(out.x).toBe(0);
+    expect(out.y).toBe(0);
+    expect(out.width).toBe(80);
+    expect(out.height).toBe(60);
+  });
+});
+
+describe('copyShapeCommands', () => {
+  it('copies commands from source to target', () => {
+    const source = createShape();
+    source.data.commands.push({ key: 'endFill', args: [] });
+    const target = createShape();
+    copyShapeCommands(target, source);
+    expect(target.data.commands).toHaveLength(1);
+    expect(target.data.commands[0]).toEqual({ key: 'endFill', args: [] });
+  });
+
+  it('replaces existing target commands and bumps the content revision', () => {
+    const source = createShape();
+    source.data.commands.push({ key: 'endFill', args: [] });
+    const target = createShape();
+    target.data.commands.push({ key: 'endFill', args: [] });
+    target.data.commands.push({ key: 'endFill', args: [] });
+    const content = getNodeLocalContentRevision(target);
+    copyShapeCommands(target, source);
+    expect(target.data.commands).toHaveLength(1);
+    expect(getNodeLocalContentRevision(target)).toBe(content + 1);
+  });
+
+  it('does not share the same array reference', () => {
+    const source = createShape();
+    const target = createShape();
+    copyShapeCommands(target, source);
+    expect(target.data.commands).not.toBe(source.data.commands);
+  });
+});
+
+describe('createShape', () => {
+  it('initializes with an empty commands array', () => {
+    const shape = createShape();
+    expect(shape.data.commands).toHaveLength(0);
+    expect(shape.kind).toStrictEqual(ShapeKind);
+  });
+
+  it('allows pre-defined commands', () => {
+    const commands = [{ key: 'endFill' as const, args: [] as const }];
+    const shape = createShape({ data: { commands } });
+    expect(shape.data.commands).toBe(commands);
+  });
+
+  it('returns a new object for better hidden-class performance', () => {
+    expect(createShape()).not.toBe(createShape());
+  });
+});
+
+describe('createShapeData', () => {
+  it('returns a ShapeData object with an empty commands array', () => {
+    const data = createShapeData();
+    expect(data.commands).toHaveLength(0);
+  });
+
+  it('returns a new object each call', () => {
+    expect(createShapeData()).not.toBe(createShapeData());
+  });
+});
+
+describe('createShapeRuntime', () => {
+  it('returns a non-null runtime', () => {
+    const runtime = createShapeRuntime();
+    expect(runtime).not.toBeNull();
+  });
+});
+
+describe('getShapeBounds', () => {
+  it('returns the same bounds as computeShapeLocalBoundsRectangle', () => {
+    const shape = createShape();
+    shape.data.commands.push('drawRectangle', 4, 5, 10, 200, 80);
+    const out1 = createRectangle();
+    const out2 = createRectangle();
+    computeShapeLocalBoundsRectangle(out1, shape);
+    getShapeBounds(out2, shape);
+    expect(out2.x).toBe(out1.x);
+    expect(out2.y).toBe(out1.y);
+    expect(out2.width).toBe(out1.width);
+    expect(out2.height).toBe(out1.height);
+  });
+
+  it('returns zero bounds for an empty shape', () => {
+    const shape = createShape();
+    const out = createRectangle(1, 2, 3, 4);
+    getShapeBounds(out, shape);
+    expect(out.x).toBe(0);
+    expect(out.y).toBe(0);
+    expect(out.width).toBe(0);
+    expect(out.height).toBe(0);
+  });
+});
+
+describe('getShapeCommandCount', () => {
+  it('returns 0 for an empty shape', () => {
+    const shape = createShape();
+    expect(getShapeCommandCount(shape)).toBe(0);
+  });
+
+  it('counts each command entry (not each flat array element)', () => {
+    const shape = createShape();
+    shape.data.commands.push('beginFill', 2, 0xff0000, 1);
+    shape.data.commands.push('drawRectangle', 4, 0, 0, 100, 100);
+    shape.data.commands.push('endFill', 0);
+    expect(getShapeCommandCount(shape)).toBe(3);
+  });
+});
+
+describe('getShapeRuntime', () => {
+  it('returns the runtime for a Shape', () => {
+    const shape = createShape();
+    const runtime = getShapeRuntime(shape);
+    expect(runtime).not.toBeNull();
+  });
+});
+
+describe('invalidateShapeGeometry', () => {
+  it('bumps both the content and local-bounds revisions', () => {
+    const shape = createShape();
+    const content = getNodeLocalContentRevision(shape);
+    const bounds = getNodeLocalBoundsRevision(shape);
+    invalidateShapeGeometry(shape);
+    expect(getNodeLocalContentRevision(shape)).toBe(content + 1);
+    expect(getNodeLocalBoundsRevision(shape)).toBe(bounds + 1);
+  });
+});
+
+describe('isShapeEmpty', () => {
+  it('returns true for a shape with no commands', () => {
+    const shape = createShape();
+    expect(isShapeEmpty(shape)).toBe(true);
+  });
+
+  it('returns false after any command is appended', () => {
+    const shape = createShape();
+    shape.data.commands.push('endFill', 0);
+    expect(isShapeEmpty(shape)).toBe(false);
+  });
+
+  it('returns true again after clearShapeCommands', () => {
+    const shape = createShape();
+    shape.data.commands.push('endFill', 0);
+    clearShapeCommands(shape);
+    expect(isShapeEmpty(shape)).toBe(true);
+  });
+});