@flighthq/shape 0.3.0-next.906.07cea63 → 0.3.1-next.209.43ef1bc

package/src/morphShapeAnimation.test.ts

@@ -0,0 +1,147 @@
+import {
+  createAnimationBlendTree,
+  createAnimationBlendTreeInput,
+  createAnimationChannel,
+  createAnimationClip,
+  createAnimationPlayer,
+  createAnimationTrack,
+  sampleAnimationBlendTree,
+} from '@flighthq/animation/contract';
+import { getNodeLocalContentRevision } from '@flighthq/node/contract';
+import { appendPathLineTo, appendPathMoveTo, createPath, createPathMorph } from '@flighthq/path/contract';
+import type { MorphShape, MorphShapeAnimationTarget } from '@flighthq/types/contract';
+
+import { appendMorphShapePath, createMorphShape } from './morphShape';
+import {
+  applyAnimationClipToMorphShape,
+  applyMorphShapeAnimationSample,
+  createMorphShapeAnimationTarget,
+} from './morphShapeAnimation';
+import { appendMorphShapeBeginFill } from './morphShapePaint';
+
+describe('applyAnimationClipToMorphShape', () => {
+  it('samples scalar progress while preserving easing overshoot', () => {
+    const shape = createTestMorphShape();
+    const target = createMorphShapeAnimationTarget(shape);
+    const clip = createAnimationClip([
+      createAnimationChannel(
+        createAnimationTrack({ easing: (progress) => progress * 2, times: [0, 1], values: [0, 1] }),
+        target,
+      ),
+    ]);
+
+    applyAnimationClipToMorphShape(clip, 0.75);
+
+    expect(shape.data.progress).toBe(1.5);
+    expect(shape.data.path.data.slice(0, 2)).toStrictEqual([30, 45]);
+  });
+
+  it('applies one clip sample atomically to compound geometry and paint', () => {
+    const shape = createTestMorphShape();
+    const secondMorph = createTestMorph(100);
+    appendMorphShapeBeginFill(shape, { color: 0xff0000 }, { color: 0x0000ff });
+    appendMorphShapePath(shape);
+    const secondPath = appendMorphShapePath(shape, secondMorph);
+    const revision = getNodeLocalContentRevision(shape);
+    const clip = createAnimationClip([
+      createAnimationChannel(
+        createAnimationTrack({ times: [0, 1], values: [0, 1] }),
+        createMorphShapeAnimationTarget(shape),
+      ),
+    ]);
+
+    applyAnimationClipToMorphShape(clip, 0.5);
+
+    expect(shape.data.path.data.slice(0, 2)).toStrictEqual([10, 15]);
+    expect(secondPath.data.slice(0, 2)).toStrictEqual([110, 115]);
+    expect(shape.data.commands[2]).toBe(0x800080);
+    expect(getNodeLocalContentRevision(shape)).toBe(revision + 1);
+  });
+
+  it('ignores foreign channels in a composed clip', () => {
+    const shape = createTestMorphShape();
+    const clip = createAnimationClip([
+      createAnimationChannel(createAnimationTrack({ times: [0, 1], values: [0, 100] }), { node: shape, path: 'X' }),
+      createAnimationChannel(
+        createAnimationTrack({ times: [0, 1], values: [0, 1] }),
+        createMorphShapeAnimationTarget(shape),
+      ),
+    ]);
+
+    applyAnimationClipToMorphShape(clip, 0.25);
+
+    expect(shape.x).toBe(0);
+    expect(shape.data.progress).toBe(0.25);
+  });
+});
+
+describe('applyMorphShapeAnimationSample', () => {
+  it('mutates stable path buffers and invalidates retained content', () => {
+    const shape = createTestMorphShape();
+    const commands = shape.data.path.commands;
+    const data = shape.data.path.data;
+    const revision = getNodeLocalContentRevision(shape);
+    const channel = createAnimationChannel(
+      createAnimationTrack({ times: [0, 1], values: [0, 1] }),
+      createMorphShapeAnimationTarget(shape),
+    );
+
+    expect(applyMorphShapeAnimationSample([0.5], channel)).toBe(true);
+    expect(shape.data.progress).toBe(0.5);
+    expect(shape.data.path.commands).toBe(commands);
+    expect(shape.data.path.data).toBe(data);
+    expect(getNodeLocalContentRevision(shape)).toBe(revision + 1);
+  });
+
+  it('serves as the sink for composed animation samples', () => {
+    const shape = createTestMorphShape();
+    const target = createMorphShapeAnimationTarget(shape);
+    const a = createAnimationPlayer(
+      createAnimationClip([createAnimationChannel(createAnimationTrack({ times: [0, 1], values: [0, 1] }), target)]),
+      { time: 0.5 },
+    );
+    const b = createAnimationPlayer(
+      createAnimationClip([createAnimationChannel(createAnimationTrack({ times: [0, 1], values: [0, 0.2] }), target)]),
+      { time: 0.5 },
+    );
+    const tree = createAnimationBlendTree([createAnimationBlendTreeInput(a, 1), createAnimationBlendTreeInput(b, 1)]);
+
+    sampleAnimationBlendTree([0], tree, applyMorphShapeAnimationSample);
+
+    expect(shape.data.progress).toBeCloseTo(0.3);
+  });
+
+  it('returns false for foreign targets without changing the shape', () => {
+    const shape = createTestMorphShape();
+    const channel = createAnimationChannel(createAnimationTrack({ times: [0, 1], values: [0, 1] }), {
+      shape: { kind: 'acme.NotMorphShape' },
+    });
+
+    expect(applyMorphShapeAnimationSample([1], channel)).toBe(false);
+    expect(shape.data.progress).toBe(0);
+  });
+});
+
+describe('createMorphShapeAnimationTarget', () => {
+  it('allocates a reusable target descriptor for one MorphShape', () => {
+    const shape = createTestMorphShape();
+
+    const target: MorphShapeAnimationTarget = createMorphShapeAnimationTarget(shape);
+
+    expect(target).toStrictEqual({ shape });
+  });
+});
+
+function createTestMorphShape(): MorphShape {
+  return createMorphShape(createTestMorph());
+}
+
+function createTestMorph(offset = 0) {
+  const start = createPath();
+  appendPathMoveTo(start, offset, offset);
+  appendPathLineTo(start, offset + 10, offset);
+  const end = createPath();
+  appendPathMoveTo(end, offset + 20, offset + 30);
+  appendPathLineTo(end, offset + 40, offset + 30);
+  return createPathMorph(start, end)!;
+}

package/src/morphShapePaint.test.ts

@@ -0,0 +1,236 @@
+import { createMatrix } from '@flighthq/geometry/contract';
+import { getNodeLocalContentRevision } from '@flighthq/node/contract';
+import { appendPathLineTo, appendPathMoveTo, createPath, createPathMorph } from '@flighthq/path/contract';
+
+import { createMorphShape, setMorphShapeProgress } from './morphShape';
+import {
+  appendMorphShapeBeginFill,
+  appendMorphShapeBeginGradientFill,
+  appendMorphShapeBeginTextureFill,
+  appendMorphShapeLineGradientStyle,
+  appendMorphShapeLineStyle,
+  appendMorphShapeLineTextureStyle,
+  sampleMorphShapePaintBindings,
+} from './morphShapePaint';
+import { clearShapeCommands } from './shape';
+
+const fakeTexture = { id: 1 } as never;
+
+describe('appendMorphShapeBeginFill', () => {
+  it('retains one command while sampling packed RGB and alpha at the current progress', () => {
+    const shape = createTestMorphShape(0.5);
+
+    appendMorphShapeBeginFill(shape, { alpha: 0.25, color: 0xff0000 }, { alpha: 0.75, color: 0x0000ff });
+
+    expect(shape.data.commands).toStrictEqual(['beginFill', 2, 0x800080, 0.5]);
+    expect(shape.data.paintBindings).toHaveLength(1);
+    const commands = shape.data.commands;
+    setMorphShapeProgress(shape, 1);
+    expect(shape.data.commands).toBe(commands);
+    expect(shape.data.commands).toStrictEqual(['beginFill', 2, 0x0000ff, 0.75]);
+  });
+});
+
+describe('appendMorphShapeBeginGradientFill', () => {
+  it('samples stops, matrices, and focal ratio into stable retained values', () => {
+    const shape = createTestMorphShape();
+    const startMatrix = createMatrix(1, 2, 3, 4, 5, 6);
+    const endMatrix = createMatrix(3, 4, 5, 6, 7, 8);
+
+    expect(
+      appendMorphShapeBeginGradientFill(
+        shape,
+        'radial',
+        {
+          alphas: [0.25, 0.5],
+          colors: [0x000000, 0xff0000],
+          focalPointRatio: -0.5,
+          matrix: startMatrix,
+          ratios: [0, 100],
+        },
+        {
+          alphas: [0.75, 1],
+          colors: [0xffffff, 0x0000ff],
+          focalPointRatio: 0.5,
+          matrix: endMatrix,
+          ratios: [100, 200],
+        },
+      ),
+    ).toBe(true);
+    const colors = shape.data.commands[3];
+    const alphas = shape.data.commands[4];
+    const ratios = shape.data.commands[5];
+    const matrix = shape.data.commands[6];
+
+    setMorphShapeProgress(shape, 0.5);
+
+    expect(shape.data.commands[3]).toBe(colors);
+    expect(shape.data.commands[4]).toBe(alphas);
+    expect(shape.data.commands[5]).toBe(ratios);
+    expect(shape.data.commands[6]).toBe(matrix);
+    expect(colors).toStrictEqual([0x808080, 0x800080]);
+    expect(alphas).toStrictEqual([0.5, 0.75]);
+    expect(ratios).toStrictEqual([50, 150]);
+    expect(matrix).toMatchObject({ a: 2, b: 3, c: 4, d: 5, tx: 6, ty: 7 });
+    expect(shape.data.commands[9]).toBe(0);
+  });
+
+  it('rejects incompatible gradient stop topology without mutating the shape', () => {
+    const shape = createTestMorphShape();
+    const revision = getNodeLocalContentRevision(shape);
+
+    expect(
+      appendMorphShapeBeginGradientFill(
+        shape,
+        'linear',
+        { alphas: [1], colors: [0], ratios: [0] },
+        { alphas: [1, 1], colors: [0, 1], ratios: [0, 255] },
+      ),
+    ).toBe(false);
+    expect(shape.data.commands).toStrictEqual([]);
+    expect(shape.data.paintBindings).toStrictEqual([]);
+    expect(getNodeLocalContentRevision(shape)).toBe(revision);
+  });
+
+  it('treats a missing endpoint matrix as identity while retaining one live matrix', () => {
+    const shape = createTestMorphShape();
+    expect(
+      appendMorphShapeBeginGradientFill(
+        shape,
+        'linear',
+        { alphas: [1], colors: [0], ratios: [0] },
+        { alphas: [1], colors: [0xffffff], matrix: createMatrix(3, 0, 0, 5, 20, 40), ratios: [255] },
+      ),
+    ).toBe(true);
+    const matrix = shape.data.commands[6];
+
+    setMorphShapeProgress(shape, 0.5);
+
+    expect(shape.data.commands[6]).toBe(matrix);
+    expect(matrix).toMatchObject({ a: 2, b: 0, c: 0, d: 3, tx: 10, ty: 20 });
+  });
+});
+
+describe('appendMorphShapeBeginTextureFill', () => {
+  it('preserves an ordinary null matrix when neither endpoint needs placement morphing', () => {
+    const shape = createTestMorphShape();
+
+    appendMorphShapeBeginTextureFill(shape, fakeTexture);
+
+    expect(shape.data.commands).toStrictEqual(['beginTextureFill', 2, fakeTexture, null]);
+    expect(shape.data.paintBindings).toStrictEqual([]);
+  });
+
+  it('morphs the placement matrix while retaining the texture and matrix identities', () => {
+    const shape = createTestMorphShape();
+    appendMorphShapeBeginTextureFill(shape, fakeTexture, null, createMatrix(2, 0, 0, 4, 10, 20));
+    const matrix = shape.data.commands[3];
+
+    setMorphShapeProgress(shape, 0.5);
+
+    expect(shape.data.commands[2]).toBe(fakeTexture);
+    expect(shape.data.commands[3]).toBe(matrix);
+    expect(matrix).toMatchObject({ a: 1.5, b: 0, c: 0, d: 2.5, tx: 5, ty: 10 });
+  });
+});
+
+describe('appendMorphShapeLineGradientStyle', () => {
+  it('uses the same stable gradient sampler for a stroke paint', () => {
+    const shape = createTestMorphShape();
+
+    expect(
+      appendMorphShapeLineGradientStyle(
+        shape,
+        'linear',
+        { alphas: [1], colors: [0xff0000], ratios: [0] },
+        { alphas: [0.5], colors: [0x0000ff], ratios: [255] },
+      ),
+    ).toBe(true);
+    setMorphShapeProgress(shape, 1);
+
+    expect(shape.data.commands[0]).toBe('lineGradientStyle');
+    expect(shape.data.commands[3]).toStrictEqual([0x0000ff]);
+    expect(shape.data.commands[4]).toStrictEqual([0.5]);
+    expect(shape.data.commands[5]).toStrictEqual([255]);
+  });
+});
+
+describe('appendMorphShapeLineStyle', () => {
+  it('samples stroke width and color while retaining structural stroke options', () => {
+    const shape = createTestMorphShape(0.5);
+
+    appendMorphShapeLineStyle(
+      shape,
+      { alpha: 0.25, color: 0xff0000, thickness: 2 },
+      { alpha: 0.75, color: 0x0000ff, thickness: 10 },
+      true,
+      'horizontal',
+      'round',
+      'bevel',
+      5,
+    );
+
+    expect(shape.data.commands).toStrictEqual([
+      'lineStyle',
+      8,
+      6,
+      0x800080,
+      0.5,
+      true,
+      'horizontal',
+      'round',
+      'bevel',
+      5,
+    ]);
+  });
+});
+
+describe('appendMorphShapeLineTextureStyle', () => {
+  it('uses the same stable matrix sampler for a stroke texture', () => {
+    const shape = createTestMorphShape();
+    appendMorphShapeLineTextureStyle(shape, fakeTexture, createMatrix(), createMatrix(2, 0, 0, 2, 10, 20));
+    const matrix = shape.data.commands[3];
+
+    setMorphShapeProgress(shape, 1);
+
+    expect(shape.data.commands[0]).toBe('lineTextureStyle');
+    expect(shape.data.commands[3]).toBe(matrix);
+    expect(matrix).toMatchObject({ a: 2, d: 2, tx: 10, ty: 20 });
+  });
+});
+
+describe('clearShapeCommands with MorphShape paint', () => {
+  it('removes stale paint bindings with the ordinary Shape command stream', () => {
+    const shape = createTestMorphShape();
+    appendMorphShapeBeginFill(shape, { color: 0 }, { color: 0xffffff });
+
+    clearShapeCommands(shape);
+    setMorphShapeProgress(shape, 1);
+
+    expect(shape.data.commands).toStrictEqual([]);
+    expect(shape.data.paintBindings).toStrictEqual([]);
+  });
+});
+
+describe('sampleMorphShapePaintBindings', () => {
+  it('can resample prepared paint bindings without reallocating their command values', () => {
+    const shape = createTestMorphShape();
+    appendMorphShapeBeginFill(shape, { color: 0 }, { color: 0xffffff });
+    const commands = shape.data.commands;
+
+    sampleMorphShapePaintBindings(shape.data, 0.25);
+
+    expect(shape.data.commands).toBe(commands);
+    expect(shape.data.commands[2]).toBe(0x404040);
+  });
+});
+
+function createTestMorphShape(progress = 0) {
+  const start = createPath();
+  appendPathMoveTo(start, 0, 0);
+  appendPathLineTo(start, 10, 0);
+  const end = createPath();
+  appendPathMoveTo(end, 20, 30);
+  appendPathLineTo(end, 40, 30);
+  return createMorphShape(createPathMorph(start, end)!, { data: { progress } });
+}

package/src/scale9ShapeCommands.test.ts

@@ -0,0 +1,64 @@
+import type { ShapeCommandToken } from '@flighthq/types/contract';
+
+import { createScale9Shape } from './scale9Shape';
+import { mapScale9ShapeCommands } from './scale9ShapeCommands';
+import { appendShapeBeginFill, appendShapeRectangle } from './shapeCommands';
+
+const grid = { x: 10, y: 10, width: 80, height: 80 };
+
+describe('mapScale9ShapeCommands', () => {
+  const out: ShapeCommandToken[] = [];
+
+  it('passes style commands through unchanged', () => {
+    const mapper = { mapX: (x: number) => x, mapY: (y: number) => y };
+    mapScale9ShapeCommands(out, ['beginFill', 2, 0xff0000, 1], mapper);
+    expect(out).toEqual(['beginFill', 2, 0xff0000, 1]);
+  });
+
+  it('remaps moveTo coordinates', () => {
+    const mapper = { mapX: (x: number) => x * 2, mapY: (y: number) => y * 3 };
+    mapScale9ShapeCommands(out, ['moveTo', 2, 10, 20], mapper);
+    expect(out).toEqual(['moveTo', 2, 20, 60]);
+  });
+
+  it('remaps lineTo coordinates', () => {
+    const mapper = { mapX: (x: number) => x + 5, mapY: (y: number) => y + 10 };
+    mapScale9ShapeCommands(out, ['lineTo', 2, 100, 50], mapper);
+    expect(out).toEqual(['lineTo', 2, 105, 60]);
+  });
+
+  it('remaps drawRectangle corners and recomputes size', () => {
+    const mapper = { mapX: (x: number) => x * 2, mapY: (y: number) => y * 2 };
+    mapScale9ShapeCommands(out, ['drawRectangle', 4, 10, 20, 50, 30], mapper);
+    // x=10→20, y=20→40, x+w=60→120 (w=100), y+h=50→100 (h=60)
+    expect(out).toEqual(['drawRectangle', 4, 20, 40, 100, 60]);
+  });
+
+  it('remaps drawRoundRectangle corners but leaves ellipse radii unchanged', () => {
+    const mapper = { mapX: (x: number) => x * 2, mapY: (y: number) => y * 2 };
+    mapScale9ShapeCommands(out, ['drawRoundRectangle', 6, 10, 20, 50, 30, 8, 8], mapper);
+    expect(out).toEqual(['drawRoundRectangle', 6, 20, 40, 100, 60, 8, 8]);
+  });
+
+  it('remaps drawCircle center but leaves radius unchanged', () => {
+    const mapper = { mapX: (x: number) => x + 5, mapY: (y: number) => y + 10 };
+    mapScale9ShapeCommands(out, ['drawCircle', 3, 50, 50, 25], mapper);
+    expect(out).toEqual(['drawCircle', 3, 55, 60, 25]);
+  });
+
+  it('remaps drawEllipse corners and recomputes size', () => {
+    const mapper = { mapX: (x: number) => x * 2, mapY: (y: number) => y * 2 };
+    mapScale9ShapeCommands(out, ['drawEllipse', 4, 0, 0, 100, 50], mapper);
+    expect(out).toEqual(['drawEllipse', 4, 0, 0, 200, 100]);
+  });
+
+  it('returns a buffer with the same element count as the input', () => {
+    const shape = createScale9Shape(grid);
+    appendShapeBeginFill(shape, 0xff0000);
+    appendShapeRectangle(shape, 0, 0, 100, 100);
+    // A mapper is any pair of coordinate functions; building one from a grid is a renderer's job, and
+    // the rewrite under test does not care where the mapping came from.
+    mapScale9ShapeCommands(out, shape.data.commands, { mapX: (x) => x * 2, mapY: (y) => y * 2 });
+    expect(out).toHaveLength(shape.data.commands.length);
+  });
+});

package/src/shape.test.ts

@@ -4,9 +4,12 @@ import {
   getNodeLocalContentRevision,
   getNodeLocalTransformRevision,
 } from '@flighthq/node/contract';
+import { createPath, createPathMorph } from '@flighthq/path/contract';
 import type { ShapeCommandToken } from '@flighthq/types/contract';
 import { ShapeKind } from '@flighthq/types/contract';
 
+import { createMorphShape, setMorphShapeProgress } from './morphShape';
+import { appendMorphShapeBeginFill } from './morphShapePaint';
 import {
   clearShapeCommands,
   computeShapeLocalBoundsRectangle,
@@ -169,6 +172,19 @@ describe('computeShapeLocalBoundsRectangle', () => {
 });
 
 describe('copyShapeCommands', () => {
+  it('discards target paint bindings when replacing a MorphShape command stream', () => {
+    const path = createPath();
+    const target = createMorphShape(createPathMorph(path, path)!);
+    appendMorphShapeBeginFill(target, { color: 0 }, { color: 0xffffff });
+    const source = createShape({ data: { commands: ['beginFill', 2, 0x123456, 1] } });
+
+    copyShapeCommands(target, source);
+    setMorphShapeProgress(target, 1);
+
+    expect(target.data.commands).toStrictEqual(['beginFill', 2, 0x123456, 1]);
+    expect(target.data.paintBindings).toStrictEqual([]);
+  });
+
   it('copies commands from source to target', () => {
     const source = createShape();
     source.data.commands.push('endFill', 0);
@@ -178,6 +194,25 @@ describe('copyShapeCommands', () => {
     expect(target.data.commands).toEqual(['endFill', 0]);
   });
 
+  it('copies a command stream longer than the engine argument limit', () => {
+    // Imported vector artwork reaches this length routinely, and a spread into push would pass one
+    // argument per command — so this is the size at which copying, not drawing, is what fails.
+    const source = createShape();
+    for (let i = 0; i < 400_000; i++) source.data.commands.push('lineTo', 2, i, i);
+    const target = createShape();
+
+    expect(() => copyShapeCommands(target, source)).not.toThrow();
+    expect(target.data.commands).toHaveLength(source.data.commands.length);
+    expect(target.data.commands[1_599_998]).toBe(399_999);
+  });
+
+  it('leaves the command stream intact when target and source are the same shape', () => {
+    const shape = createShape();
+    shape.data.commands.push('endFill', 0);
+    copyShapeCommands(shape, shape);
+    expect(shape.data.commands).toEqual(['endFill', 0]);
+  });
+
   it('replaces existing target commands and bumps the content revision', () => {
     const source = createShape();
     source.data.commands.push('endFill', 0);

package/src/shapeCommands.test.ts

@@ -4,7 +4,7 @@ import { createShape } from './shape';
 import {
   appendShapeArc,
   appendShapeArcTo,
-  appendShapeBeginBitmapFill,
+  appendShapeBeginTextureFill,
   appendShapeBeginFill,
   appendShapeBeginGradientFill,
   appendShapeCircle,
@@ -13,7 +13,7 @@ import {
   appendShapeDrawTriangles,
   appendShapeEllipse,
   appendShapeEndFill,
-  appendShapeLineBitmapStyle,
+  appendShapeLineTextureStyle,
   appendShapeLineGradientStyle,
   appendShapeLineStyle,
   appendShapeLineTo,
@@ -27,7 +27,7 @@ import {
   PathCommand,
 } from './shapeCommands';
 
-const fakeImageSource = { id: 1, height: 10, source: null, width: 10 } as never;
+const fakeTexture = { id: 1 } as never;
 const fakeMatrix = { id: 2, a: 1, b: 0, c: 0, d: 1, tx: 0, ty: 0 } as never;
 
 describe('appendShapeArc', () => {
@@ -124,20 +124,6 @@ describe('appendShapeArcTo', () => {
   });
 });
 
-describe('appendShapeBeginBitmapFill', () => {
-  it('pushes a beginBitmapFill command with bitmap, matrix, repeat, smooth', () => {
-    const shape = createShape();
-    appendShapeBeginBitmapFill(shape, fakeImageSource, fakeMatrix, false, true);
-    expect(shape.data.commands).toEqual(['beginBitmapFill', 4, fakeImageSource, fakeMatrix, false, true]);
-  });
-
-  it('defaults matrix to null, repeat to true, smooth to false', () => {
-    const shape = createShape();
-    appendShapeBeginBitmapFill(shape, fakeImageSource);
-    expect(shape.data.commands).toEqual(['beginBitmapFill', 4, fakeImageSource, null, true, false]);
-  });
-});
-
 describe('appendShapeBeginFill', () => {
   it('pushes a beginFill command with color and alpha', () => {
     const shape = createShape();
@@ -198,6 +184,20 @@ describe('appendShapeBeginGradientFill', () => {
   });
 });
 
+describe('appendShapeBeginTextureFill', () => {
+  it('pushes a beginTextureFill command with texture and matrix', () => {
+    const shape = createShape();
+    appendShapeBeginTextureFill(shape, fakeTexture, fakeMatrix);
+    expect(shape.data.commands).toEqual(['beginTextureFill', 2, fakeTexture, fakeMatrix]);
+  });
+
+  it('defaults matrix to null', () => {
+    const shape = createShape();
+    appendShapeBeginTextureFill(shape, fakeTexture);
+    expect(shape.data.commands).toEqual(['beginTextureFill', 2, fakeTexture, null]);
+  });
+});
+
 describe('appendShapeCircle', () => {
   it('pushes a drawCircle command with position and radius', () => {
     const shape = createShape();
@@ -293,20 +293,6 @@ describe('appendShapeEndFill', () => {
   });
 });
 
-describe('appendShapeLineBitmapStyle', () => {
-  it('pushes a lineBitmapStyle command with bitmap, matrix, repeat, smooth', () => {
-    const shape = createShape();
-    appendShapeLineBitmapStyle(shape, fakeImageSource, fakeMatrix, false, true);
-    expect(shape.data.commands).toEqual(['lineBitmapStyle', 4, fakeImageSource, fakeMatrix, false, true]);
-  });
-
-  it('defaults matrix to null, repeat to true, smooth to false', () => {
-    const shape = createShape();
-    appendShapeLineBitmapStyle(shape, fakeImageSource);
-    expect(shape.data.commands).toEqual(['lineBitmapStyle', 4, fakeImageSource, null, true, false]);
-  });
-});
-
 describe('appendShapeLineGradientStyle', () => {
   it('pushes a lineGradientStyle command with all fields', () => {
     const shape = createShape();
@@ -340,6 +326,20 @@ describe('appendShapeLineStyle', () => {
   });
 });
 
+describe('appendShapeLineTextureStyle', () => {
+  it('pushes a lineTextureStyle command with texture and matrix', () => {
+    const shape = createShape();
+    appendShapeLineTextureStyle(shape, fakeTexture, fakeMatrix);
+    expect(shape.data.commands).toEqual(['lineTextureStyle', 2, fakeTexture, fakeMatrix]);
+  });
+
+  it('defaults matrix to null', () => {
+    const shape = createShape();
+    appendShapeLineTextureStyle(shape, fakeTexture);
+    expect(shape.data.commands).toEqual(['lineTextureStyle', 2, fakeTexture, null]);
+  });
+});
+
 describe('appendShapeLineTo', () => {
   it('pushes a lineTo command with position', () => {
     const shape = createShape();

package/src/shapeFill.test.ts

@@ -151,14 +151,17 @@ describe('getShapeFillRegions', () => {
     expect(getShapeFillRegions(shape.data.commands)).toBeNull();
   });
 
-  it('returns null when a stroke is present', () => {
+  it('resolves solid fills independently of a solid stroke', () => {
     const shape = createShape();
     appendShapeLineStyle(shape, 2, 0x000000);
     appendShapeBeginFill(shape, 0xff0000);
     appendShapeRectangle(shape, 0, 0, 10, 10);
     appendShapeEndFill(shape);
 
-    expect(getShapeFillRegions(shape.data.commands)).toBeNull();
+    const regions = getShapeFillRegions(shape.data.commands);
+    expect(regions).not.toBeNull();
+    expect(regions).toHaveLength(1);
+    expect(regions![0].color).toBe(0xff0000);
   });
 });
 
@@ -171,9 +174,12 @@ describe('hasNonSolidShapeFill', () => {
     expect(hasNonSolidShapeFill(shape.data.commands)).toBe(false);
   });
 
-  it('is true when a bitmap or gradient fill or stroke is present', () => {
+  it('is false for a solid stroke and true for a bitmap or gradient style', () => {
     const shape = createShape();
     appendShapeLineStyle(shape, 1, 0);
+    expect(hasNonSolidShapeFill(shape.data.commands)).toBe(false);
+
+    appendShapeBeginGradientFill(shape, 'linear', [0xff0000, 0x0000ff], [1, 1], [0, 255]);
     expect(hasNonSolidShapeFill(shape.data.commands)).toBe(true);
   });
 });