@flighthq/swf 0.3.0 → 0.3.1-next.1041.35b950c

package/src/swfEditText.test.ts

@@ -42,6 +42,34 @@ describe('readSwfEditTextFactory', () => {
     expect(field.data.wordWrap).toBe(true);
     expect(field.data.border).toBe(true);
     expect(field.data.selectable).toBe(false);
+    expect(field.data.maxChars).toBe(-1);
+  });
+
+  it('preserves an authored maximum character count', () => {
+    const field = build({ maxChars: 12, text: 'limited' })(() => '');
+
+    expect(field.data.maxChars).toBe(12);
+  });
+
+  it('preserves the authored RGBA text color', () => {
+    const field = build({ color: 0x11223344, text: 'Color' })(() => '');
+
+    expect(field.data.defaultTextFormat.color).toBe(0x11223344);
+    expect(field.data.textColor).toBe(0x11223344);
+  });
+
+  it('preserves an authored zero alpha instead of making it opaque', () => {
+    const field = build({ color: 0x11223300, text: 'Transparent' })(() => '');
+
+    expect(field.data.defaultTextFormat.color).toBe(0x11223300);
+    expect(field.data.textColor).toBe(0x11223300);
+  });
+
+  it('uses the opaque black field default when the tag omits text color', () => {
+    const field = build({ color: null, text: 'Default' })(() => '');
+
+    expect(field.data.defaultTextFormat.color).toBeUndefined();
+    expect(field.data.textColor).toBe(0x000000ff);
   });
 
   it('parses the markup of a field flagged as html into text and format ranges', () => {
@@ -70,12 +98,14 @@ describe('readSwfEditTextFactory', () => {
 
 interface FieldOptions {
   border?: boolean;
+  color?: number | null;
   fontHeight?: number;
   fontId?: number;
   html?: boolean;
   indent?: number;
   leading?: number;
   leftMargin?: number;
+  maxChars?: number;
   multiline?: boolean;
   noSelect?: boolean;
   rightMargin?: number;
@@ -102,7 +132,13 @@ function bytesFor(options: Readonly<FieldOptions>): Uint8Array {
     u8(0);
   };
 
-  const flags = 0x80 | 0x04 | 0x01 | (options.wordWrap === true ? 0x40 : 0) | (options.multiline === true ? 0x20 : 0);
+  const flags =
+    0x80 |
+    0x01 |
+    (options.color === null ? 0 : 0x04) |
+    (options.wordWrap === true ? 0x40 : 0) |
+    (options.multiline === true ? 0x20 : 0) |
+    (options.maxChars === undefined ? 0 : 0x02);
   const layoutFlags =
     0x20 |
     (options.border === true ? 0x08 : 0) |
@@ -112,10 +148,14 @@ function bytesFor(options: Readonly<FieldOptions>): Uint8Array {
   u8(layoutFlags);
   u16(options.fontId ?? 1);
   u16(options.fontHeight ?? 200);
-  u8(0x11);
-  u8(0x22);
-  u8(0x33);
-  u8(0xff);
+  if (options.color !== null) {
+    const color = options.color ?? 0x112233ff;
+    u8(color >>> 24);
+    u8(color >>> 16);
+    u8(color >>> 8);
+    u8(color);
+  }
+  if (options.maxChars !== undefined) u16(options.maxChars);
   u8(0); // align: left
   u16(options.leftMargin ?? 0);
   u16(options.rightMargin ?? 0);

package/src/swfFilter.test.ts

@@ -1,3 +1,4 @@
+import { collectImportDiagnostics } from '@flighthq/importdiagnostics/contract';
 import type {
   Adjustment,
   BevelEffect,
@@ -6,11 +7,13 @@ import type {
   ConvolutionEffect,
   DropShadowEffect,
   GradientGlowEffect,
+  ImportDiagnostic,
   InnerGlowEffect,
   InnerShadowEffect,
   OuterGlowEffect,
   RenderEffect,
 } from '@flighthq/types/contract';
+import { ImportDiagnosticSeverity } from '@flighthq/types/contract';
 
 import { readSwfFilterList, setSwfFilterListGuard } from './swfFilter';
 import { SwfReader } from './swfReader';
@@ -124,6 +127,35 @@ describe('readSwfFilterList', () => {
     expect(glow.ratios).toEqual([0, 255]);
   });
 
+  it('reports a gradient glow angle and distance it cannot represent, and stays silent without them', () => {
+    // GradientGlowEffect has no angle, distance, or inner/on-top member, so a glow authored with any of
+    // them loses that placement. The zero case is the load-bearing half: no crumb when nothing is lost.
+    const withPlacement = collectImportDiagnostics((sink) => {
+      readGlow(fixed(45), fixed(4), sink);
+    });
+    expect(withPlacement.map((entry) => entry.kind)).toEqual(['swf.filter-field-unrepresentable']);
+    expect(withPlacement[0].severity).toBe(ImportDiagnosticSeverity.Skip);
+    expect(withPlacement[0].detail).toEqual({
+      capability: 'swf.placement.filter-list',
+      field: 'placement',
+      filterId: 4,
+    });
+
+    expect(collectImportDiagnostics((sink) => readGlow(fixed(0), fixed(0), sink))).toEqual([]);
+  });
+
+  it('reports a blur pass count it cannot represent, and stays silent at one pass', () => {
+    // Found by auditing the CLAIM against the code: the filter-list wire covered gradient glow only,
+    // while BlurEffect silently discards an authored pass count. Same kind, distinguished by `field`.
+    const multi = collectImportDiagnostics((sink) => {
+      readBlur(3, sink);
+    });
+    expect(multi.map((entry) => entry.kind)).toEqual(['swf.filter-field-unrepresentable']);
+    expect(multi[0].detail).toEqual({ capability: 'swf.placement.filter-list', field: 'passes', filterId: 1 });
+
+    expect(collectImportDiagnostics((sink) => readBlur(1, sink))).toEqual([]);
+  });
+
   it('reads a convolution kernel with its flags', () => {
     const { effects } = read(
       joinBytes(
@@ -225,6 +257,27 @@ describe('setSwfFilterListGuard', () => {
   });
 });
 
+function readBlur(passes: number, diagnostics: ImportDiagnostic[]): void {
+  const bytes = joinBytes(new Uint8Array([1, 1]), fixed(4), fixed(4), new Uint8Array([passes]));
+  readSwfFilterList(new SwfReader(bytes, 0, bytes.length), [], [], diagnostics);
+}
+
+function readGlow(angle: Uint8Array, distance: Uint8Array, diagnostics: ImportDiagnostic[]): void {
+  const bytes = joinBytes(
+    new Uint8Array([1, 4, 2]),
+    rgba(0xff, 0, 0, 0),
+    rgba(0, 0, 0xff, 0xff),
+    new Uint8Array([0, 255]),
+    fixed(6),
+    fixed(6),
+    angle,
+    distance,
+    fixed8(1),
+    new Uint8Array([0]),
+  );
+  readSwfFilterList(new SwfReader(bytes, 0, bytes.length), [], [], diagnostics);
+}
+
 function read(bytes: Uint8Array): { adjustments: Adjustment[]; complete: boolean; effects: RenderEffect[] } {
   const adjustments: Adjustment[] = [];
   const effects: RenderEffect[] = [];

package/src/swfFrameAction.test.ts

@@ -1,3 +1,4 @@
+import { collectImportDiagnostics } from '@flighthq/importdiagnostics/contract';
 import {
   createMovieClip,
   getMovieClipCurrentFrame,
@@ -6,8 +7,10 @@ import {
   setMovieClipSource,
 } from '@flighthq/movieclip/contract';
 import type { MovieClip, Node2D } from '@flighthq/types/contract';
+import { ImportDiagnosticSeverity } from '@flighthq/types/contract';
 
 import { readSwfAbcFrameScripts, readSwfFrameActions } from './swfFrameAction';
+import { buildFrameScriptAbc } from './swfFrameActionTestHelper';
 import { SwfReader } from './swfReader';
 
 describe('readSwfAbcFrameScripts', () => {
@@ -25,6 +28,29 @@ describe('readSwfAbcFrameScripts', () => {
     expect(isMovieClipPlaying(clip)).toBe(false);
   });
 
+  it('reports a frame script whose body is not a command this importer obeys', () => {
+    // The handler calls a name that is not one of the recognized playback commands, so the body parses
+    // and is then declined. The file bound a script to frame 1 and the document has none.
+    const diagnostics = collectImportDiagnostics((sink) => {
+      expect(readSwfAbcFrameScripts(buildFrameScriptAbc(1), sink)).not.toBeNull();
+    });
+
+    const dropped = diagnostics.filter((entry) => entry.kind === 'swf.abc-frame-script-declined');
+    expect(dropped).toHaveLength(1);
+    expect(dropped[0].severity).toBe(ImportDiagnosticSeverity.Drop);
+    expect(dropped[0].detail).toEqual({ frame: 1, reason: 'commands-declined' });
+  });
+
+  it('stays silent about a frame script it does obey, so the drop entry carries information', () => {
+    const diagnostics = collectImportDiagnostics((sink) => {
+      const scripts = readSwfAbcFrameScripts(buildFrameScriptAbc(), sink);
+      // Non-vacuous: a run that bound no frame script would be silent for the wrong reason.
+      expect([...scripts!.get('Main')!.keys()]).toEqual([1]);
+    });
+
+    expect(diagnostics).toEqual([]);
+  });
+
   it('reports nothing for bytecode that is not a readable container', () => {
     expect(readSwfAbcFrameScripts(new Uint8Array([1, 2, 3]))).toBeNull();
   });
@@ -86,103 +112,6 @@ describe('readSwfFrameActions', () => {
 
 // An ABC file shaped the way a compiler writes one: a class whose constructor calls
 // `addFrameScript(0, this.frame1)`, and a `frame1` method whose whole body is `stop()`.
-function buildFrameScriptAbc(): Uint8Array {
-  const bytes: number[] = [];
-  const u8 = (v: number): void => void bytes.push(v & 0xff);
-  const u16 = (v: number): void => {
-    u8(v);
-    u8(v >> 8);
-  };
-  const u30 = (v: number): void => {
-    let r = v;
-    do {
-      const b = r % 0x80;
-      r = Math.floor(r / 0x80);
-      u8(r > 0 ? b | 0x80 : b);
-    } while (r > 0);
-  };
-  const str = (v: string): void => {
-    const e = new TextEncoder().encode(v);
-    u30(e.length);
-    for (const b of e) u8(b);
-  };
-
-  u16(16);
-  u16(46);
-  u30(1); // no integers
-  u30(1); // no unsigned integers
-  u30(1); // no doubles
-  u30(6); // strings: Main, addFrameScript, stop, frame1, ''
-  str('Main');
-  str('addFrameScript');
-  str('stop');
-  str('frame1');
-  str('');
-  u30(2); // one namespace: public, named by the empty string
-  u8(0x16);
-  u30(5);
-  u30(1); // no namespace sets
-  u30(5); // four qualified names, one per string above
-  for (let i = 1; i <= 4; i++) {
-    u8(0x07);
-    u30(1);
-    u30(i);
-  }
-
-  u30(2); // two methods: the constructor and frame1
-  for (let i = 0; i < 2; i++) {
-    u30(0);
-    u30(0);
-    u30(0);
-    u8(0);
-  }
-  u30(0); // no metadata
-
-  u30(1); // one class
-  u30(1); // instance name -> Main
-  u30(1); // super name
-  u8(0);
-  u30(0); // no interfaces
-  u30(0); // instance initializer is method 0
-  u30(1); // one trait: the frame1 method
-  u30(4);
-  u8(0x01); // method trait
-  u30(0); // dispatch id
-  u30(1); // method index
-  u30(0); // class initializer
-  u30(0); // no class traits
-
-  u30(1); // one script
-  u30(0);
-  u30(0);
-
-  u30(2); // two method bodies
-  // The constructor: addFrameScript(0, this.frame1)
-  const constructorCode = [0xd0, 0x30, 0x5d, 0x02, 0x24, 0x00, 0xd0, 0x66, 0x04, 0x4f, 0x02, 0x02, 0x47];
-  u30(0);
-  u30(3);
-  u30(1);
-  u30(1);
-  u30(2);
-  u30(constructorCode.length);
-  for (const b of constructorCode) u8(b);
-  u30(0);
-  u30(0);
-  // frame1: stop()
-  const handlerCode = [0xd0, 0x30, 0x5d, 0x03, 0x4f, 0x03, 0x00, 0x47];
-  u30(1);
-  u30(2);
-  u30(1);
-  u30(1);
-  u30(2);
-  u30(handlerCode.length);
-  for (const b of handlerCode) u8(b);
-  u30(0);
-  u30(0);
-
-  return new Uint8Array(bytes);
-}
-
 function actions(bytes: readonly number[]): SwfReader {
   const source = new Uint8Array(bytes);
   return new SwfReader(source, 0, source.length);

package/src/swfImageDecoder.test.ts

@@ -0,0 +1,73 @@
+import { registerDeflateDecompressor, unregisterDecompressor } from '@flighthq/compression/contract';
+import {
+  clearImageDecoders,
+  decodeImage,
+  decodeImagePremultiplied,
+  hasImageDecoder,
+} from '@flighthq/image-codec/contract';
+import { Compression } from '@flighthq/types/contract';
+
+import { registerSwfImageDecoders, SWF_LOSSLESS_ALPHA_MIME_TYPE, SWF_LOSSLESS_MIME_TYPE } from './swfImageDecoder';
+
+beforeEach(() => {
+  clearImageDecoders();
+  unregisterDecompressor(Compression.Deflate);
+});
+
+afterEach(() => {
+  clearImageDecoders();
+  unregisterDecompressor(Compression.Deflate);
+});
+
+describe('registerSwfImageDecoders', () => {
+  it('explicitly registers both container-native lossless MIME types', () => {
+    expect(hasImageDecoder(SWF_LOSSLESS_MIME_TYPE)).toBe(false);
+    expect(hasImageDecoder(SWF_LOSSLESS_ALPHA_MIME_TYPE)).toBe(false);
+
+    registerSwfImageDecoders();
+
+    expect(hasImageDecoder(SWF_LOSSLESS_MIME_TYPE)).toBe(true);
+    expect(hasImageDecoder(SWF_LOSSLESS_ALPHA_MIME_TYPE)).toBe(true);
+  });
+
+  it('retains authored premultiplied pixels when requested and normalizes the default to straight', async () => {
+    registerDeflateDecompressor();
+    registerSwfImageDecoders();
+    const payload = losslessPayload(5, 1, 1, stored([0x80, 0x40, 0x20, 0x10]));
+
+    const premultiplied = await decodeImagePremultiplied(payload, SWF_LOSSLESS_ALPHA_MIME_TYPE);
+    const straight = await decodeImage(payload, SWF_LOSSLESS_ALPHA_MIME_TYPE);
+
+    expect([...premultiplied!.data]).toEqual([0x40, 0x20, 0x10, 0x80]);
+    expect([...straight!.data]).toEqual([0x80, 0x40, 0x20, 0x80]);
+  });
+});
+
+function losslessPayload(format: number, width: number, height: number, pixels: readonly number[]): Uint8Array {
+  return new Uint8Array([format, width & 0xff, width >> 8, height & 0xff, height >> 8, ...pixels]);
+}
+
+function stored(bytes: readonly number[]): number[] {
+  const length = bytes.length;
+  let first = 1;
+  let second = 0;
+  for (const byte of bytes) {
+    first = (first + byte) % 65_521;
+    second = (second + first) % 65_521;
+  }
+  const adler = ((second << 16) | first) >>> 0;
+  return [
+    0x78,
+    0x01,
+    0x01,
+    length & 0xff,
+    length >> 8,
+    ~length & 0xff,
+    (~length >> 8) & 0xff,
+    ...bytes,
+    adler >>> 24,
+    (adler >>> 16) & 0xff,
+    (adler >>> 8) & 0xff,
+    adler & 0xff,
+  ];
+}

package/src/swfImageResources.test.ts

@@ -1,11 +1,12 @@
 // @vitest-environment jsdom
+import { clearImageDecoders, registerImageDecoder } from '@flighthq/image-codec/contract';
 import { getNodeChildren } from '@flighthq/node/contract';
 import { loadScene2DImageResources } from '@flighthq/scene2d-resources/contract';
 import { getTextureSource } from '@flighthq/texture/contract';
-import type { Image, Shape, Texture2D, TextureSource } from '@flighthq/types/contract';
+import type { Bitmap, Shape, Texture2D, TextureSource } from '@flighthq/types/contract';
 import {
+  BitmapTextureSourceKind,
   ImageResourceReferenceKind,
-  ImageTextureSourceKind,
   ResourceResolutionState,
   ShapeKind,
 } from '@flighthq/types/contract';
@@ -14,18 +15,15 @@ import { createScene2DFromSwf } from './swfDocument';
 import { ShapeWriter } from './swfShapeTestHelper';
 
 beforeEach(() => {
-  // jsdom has the browser image surface but does not decode image bytes. Keep the production Blob ->
-  // HTMLImageElement path intact and model the dimensions a real decode of this 1x1 PNG supplies.
-  HTMLImageElement.prototype.decode = vi.fn(function (this: HTMLImageElement) {
-    this.width = 1;
-    this.height = 1;
-    return Promise.resolve();
-  });
+  registerImageDecoder('image/png', async () => ({
+    data: new Uint8ClampedArray([0x11, 0x22, 0x33, 0xff]),
+    height: 1,
+    width: 1,
+  }));
 });
 
 afterEach(() => {
-  vi.restoreAllMocks();
-  delete (HTMLImageElement.prototype as Partial<HTMLImageElement>).decode;
+  clearImageDecoders();
 });
 
 describe('SWF image resources', () => {
@@ -53,18 +51,17 @@ describe('SWF image resources', () => {
     expect(resources.resolved).toEqual([reference]);
     expect(resources.unresolved).toEqual([]);
     expect(reference.state).toBe(ResourceResolutionState.Resolved);
-    expect(image?.kind).toBe(ImageTextureSourceKind);
-    if (!isImageTextureSource(image)) throw new Error('Expected decoded image source');
+    expect(image?.kind).toBe(BitmapTextureSourceKind);
+    if (!isBitmapTextureSource(image)) throw new Error('Expected decoded bitmap source');
     expect(image.width).toBe(1);
     expect(image.height).toBe(1);
-    expect(image.source).toBeInstanceOf(HTMLImageElement);
-    expect(HTMLImageElement.prototype.decode).toHaveBeenCalledOnce();
+    expect([...image.data]).toEqual([0x11, 0x22, 0x33, 0xff]);
     expect(getTextureSource(reference.textures![0])).toBe(image);
   });
 });
 
-function isImageTextureSource(source: Readonly<TextureSource> | null): source is Image {
-  return source?.kind === ImageTextureSourceKind;
+function isBitmapTextureSource(source: Readonly<TextureSource> | null): source is Bitmap {
+  return source?.kind === BitmapTextureSourceKind;
 }
 
 function createBitmapFillSwf(imageBytes: Uint8Array): Uint8Array {

package/src/swfMorphShape.test.ts

@@ -1,5 +1,7 @@
+import { collectImportDiagnostics } from '@flighthq/importdiagnostics/contract';
 import { setMorphShapeProgress } from '@flighthq/shape/contract';
 import { createTexture } from '@flighthq/texture/contract';
+import { ImportDiagnosticSeverity } from '@flighthq/types/contract';
 import type { Texture2D } from '@flighthq/types/contract';
 
 import { createSwfMorphShape } from './swfMorphShape';
@@ -61,6 +63,22 @@ describe('createSwfMorphShape', () => {
     expect(shape.data.commands[index + 2]).toBe(texture);
   });
 
+  // No fire proof: the two edge streams are read in lockstep by readSwfMorphShapePaths, which breaks the
+  // moment either runs out, so both paths of a pair are built with identical structure and the mismatches
+  // createPathMorph declines on cannot arise from SWF bytes. The wire stays as a guard; the absence of a
+  // fire proof is recorded rather than papered over with a fixture that does not reach it.
+  it('stays silent when every path pair morphs, so the declined count carries information', () => {
+    const body = buildMorph({ endWidth: 400, startWidth: 200 });
+    let shape: ReturnType<typeof createSwfMorphShape> = null;
+    const diagnostics = collectImportDiagnostics((sink) => {
+      shape = createSwfMorphShape(new SwfReader(body, 0, body.length), 1, null, sink);
+    });
+
+    // Non-vacuous: a run that produced no morph at all would be silent for the wrong reason.
+    expect(shape).not.toBeNull();
+    expect(diagnostics).toEqual([]);
+  });
+
   it('returns null for a body that does not decode rather than throwing', () => {
     expect(readMorph(new Uint8Array())).toBeNull();
     expect(readMorph(new Uint8Array([1, 2, 3, 4, 5]))).toBeNull();

package/src/swfShape.test.ts

@@ -1,4 +1,5 @@
 import { createTexture } from '@flighthq/texture/contract';
+import type { ImportDiagnostic } from '@flighthq/types/contract';
 
 import { SwfReader } from './swfReader';
 import { createSwfGlyphShape, createSwfShape, readSwfMorphShapePaths } from './swfShape';
@@ -270,6 +271,52 @@ describe('createSwfShape', () => {
     expect(shape?.data.commands[7]).toBe('pad');
   });
 
+  // The fill matrix is file data, so a collapsed one is a plain thing to encounter. Validated where it
+  // enters rather than at the renderer, which would otherwise invert it into a defined-but-wrong matrix
+  // (a/b/c/d zeroed, tx/ty negated) and paint wrong pixels with nothing raised and nothing to grep for.
+  it('drops a singular bitmap fill matrix and names the character, keeping the fill', () => {
+    const writer = new ShapeWriter();
+    writer.writeFillStyleCount(1);
+    writer.writeByte(0x41);
+    writer.writeUint16(7);
+    writer.writeZeroScaleMatrix();
+    writer.writeLineStyleCount(0);
+    writer.writeStyleBits(1, 0);
+    writer.writeStyleChange({ fill1: 1, moveToX: 0, moveToY: 0 });
+    writer.writeStraightEdge(2000, 0);
+    writer.writeEndShape();
+
+    const diagnostics: ImportDiagnostic[] = [];
+    const shape = createSwfShape(writer.toReader(), 1, () => createTexture(), diagnostics);
+
+    const matches = diagnostics.filter((d) => d.kind === 'swf.fill-matrix-singular');
+    expect(matches).toHaveLength(1);
+    expect(matches[0].severity).toBe('Recover');
+    expect(matches[0].detail).toMatchObject({ character: 7 });
+    // Recovered, not rejected: the fill is still emitted, just untransformed.
+    expect(shape?.data.commands[0]).toBe('beginTextureFill');
+    expect(shape?.data.commands[3]).toBeNull();
+  });
+
+  it('keeps an invertible bitmap fill matrix and reports nothing', () => {
+    const writer = new ShapeWriter();
+    writer.writeFillStyleCount(1);
+    writer.writeByte(0x41);
+    writer.writeUint16(7);
+    writer.writeIdentityMatrix(0, 0);
+    writer.writeLineStyleCount(0);
+    writer.writeStyleBits(1, 0);
+    writer.writeStyleChange({ fill1: 1, moveToX: 0, moveToY: 0 });
+    writer.writeStraightEdge(2000, 0);
+    writer.writeEndShape();
+
+    const diagnostics: ImportDiagnostic[] = [];
+    const shape = createSwfShape(writer.toReader(), 1, () => createTexture(), diagnostics);
+
+    expect(diagnostics.filter((d) => d.kind === 'swf.fill-matrix-singular')).toHaveLength(0);
+    expect(shape?.data.commands[3]).not.toBeNull();
+  });
+
   it('emits geometry for a bitmap fill, with a texture its pixels arrive into later', () => {
     const writer = new ShapeWriter();
     writer.writeFillStyleCount(1);