@flighthq/adjustments 0.1.0

package/src/colorLutCache.test.ts

@@ -0,0 +1,61 @@
+import { createColorGradeAdjustment } from './colorGradeAdjustment';
+import { bakeColorLut } from './colorLut';
+import { getAdjustmentColorTransform } from './colorLutAdjustment';
+import { bakeColorLutForRun, createColorLutCache } from './colorLutCache';
+import { createHueSaturationAdjustment } from './hueSaturationAdjustment';
+
+describe('bakeColorLutForRun', () => {
+  it('reuses the same ColorLut reference for a content-identical run rebuilt with fresh objects', () => {
+    const cache = createColorLutCache();
+    // The run is rebuilt each frame with fresh descriptors and fresh transform closures — reference
+    // identity differs, but the content signature is equal, so the bake is reused by identity.
+    const first = bakeColorLutForRun(cache, [createHueSaturationAdjustment({ hue: 30, saturation: 0.5 })], 8);
+    const second = bakeColorLutForRun(cache, [createHueSaturationAdjustment({ hue: 30, saturation: 0.5 })], 8);
+    expect(second).toBe(first);
+    expect(cache.lut).toBe(first);
+    expect(cache.signature).not.toBeNull();
+  });
+
+  it('re-bakes into a new LUT when an op param changes', () => {
+    const cache = createColorLutCache();
+    const first = bakeColorLutForRun(cache, [createHueSaturationAdjustment({ saturation: 0.4 })], 8);
+    const changed = bakeColorLutForRun(cache, [createHueSaturationAdjustment({ saturation: 0.8 })], 8);
+    expect(changed).not.toBe(first);
+    expect(changed.samples).not.toEqual(first.samples);
+  });
+
+  it('re-keys when the LUT size changes', () => {
+    const cache = createColorLutCache();
+    const small = bakeColorLutForRun(cache, [createHueSaturationAdjustment({ saturation: 0.4 })], 8);
+    const large = bakeColorLutForRun(cache, [createHueSaturationAdjustment({ saturation: 0.4 })], 16);
+    expect(large).not.toBe(small);
+    expect(large.size).toBe(16);
+  });
+
+  it('bakes byte-for-byte the same samples as the uncached bakeColorLut', () => {
+    const cache = createColorLutCache();
+    const run = [createHueSaturationAdjustment({ hue: 45 }), createColorGradeAdjustment({ contrast: 1.2 })];
+    const cached = bakeColorLutForRun(cache, run, 8);
+    const uncached = bakeColorLut(
+      run.map((op) => getAdjustmentColorTransform(op)!),
+      8,
+    );
+    expect(cached.size).toBe(uncached.size);
+    expect(cached.samples).toEqual(uncached.samples);
+  });
+
+  it('bakes an empty run into an identity LUT and caches it', () => {
+    const cache = createColorLutCache();
+    const lut = bakeColorLutForRun(cache, [], 4);
+    expect(lut.size).toBe(4);
+    expect(bakeColorLutForRun(cache, [], 4)).toBe(lut);
+  });
+});
+
+describe('createColorLutCache', () => {
+  it('starts empty', () => {
+    const cache = createColorLutCache();
+    expect(cache.signature).toBeNull();
+    expect(cache.lut).toBeNull();
+  });
+});

package/src/colorMatrixAdjustment.test.ts

@@ -0,0 +1,24 @@
+import { getAdjustmentColorMatrix, isColorMatrixAdjustment } from './colorMatrixAdjustment';
+import { createInvertAdjustment } from './invertAdjustment';
+
+describe('getAdjustmentColorMatrix', () => {
+  it('returns the matrix for a matrix-tier adjustment', () => {
+    const adjustment = createInvertAdjustment();
+    expect(getAdjustmentColorMatrix(adjustment)).toBe(adjustment.colorMatrix);
+  });
+
+  it('returns null for a spatial/composite effect (no colorMatrix)', () => {
+    expect(getAdjustmentColorMatrix({ kind: 'BlurEffect' })).toBeNull();
+  });
+
+  it('returns null for a malformed colorMatrix', () => {
+    expect(getAdjustmentColorMatrix({ kind: 'acme.Bad', colorMatrix: [1, 2, 3] } as never)).toBeNull();
+  });
+});
+
+describe('isColorMatrixAdjustment', () => {
+  it('is true for a matrix-tier adjustment and false for an effect', () => {
+    expect(isColorMatrixAdjustment(createInvertAdjustment())).toBe(true);
+    expect(isColorMatrixAdjustment({ kind: 'BlurEffect' })).toBe(false);
+  });
+});

package/src/colorMatrixMath.test.ts

@@ -0,0 +1,431 @@
+import {
+  applyColorMatrixToColor,
+  COLOR_MATRIX_LENGTH,
+  concatColorMatrix,
+  createBrightnessColorMatrix,
+  createChannelMixerColorMatrix,
+  createColorBalanceColorMatrix,
+  createColorMatrixFromTint,
+  createContrastColorMatrix,
+  createDesaturateColorMatrix,
+  createGrayscaleColorMatrix,
+  createHueRotateColorMatrix,
+  createIdentityColorMatrix,
+  createInvertColorMatrix,
+  createLevelsColorMatrix,
+  createOpacityColorMatrix,
+  createPolaroidColorMatrix,
+  createSaturationColorMatrix,
+  createSepiaColorMatrix,
+  createTechnicolorColorMatrix,
+  createVintageColorMatrix,
+  createWhiteBalanceColorMatrix,
+  fuseColorMatrices,
+  multiplyColorMatrix,
+} from './colorMatrixMath';
+
+const WHITE = 0xffffffff;
+const BLACK = 0x000000ff;
+const RED = 0xff0000ff;
+const GREEN = 0x00ff00ff;
+
+describe('applyColorMatrixToColor', () => {
+  it('identity matrix leaves color unchanged', () => {
+    const identity = createIdentityColorMatrix();
+    expect(applyColorMatrixToColor(identity, RED)).toBe(RED);
+    expect(applyColorMatrixToColor(identity, GREEN)).toBe(GREEN);
+    expect(applyColorMatrixToColor(identity, WHITE)).toBe(WHITE);
+  });
+
+  it('invert matrix inverts RGB channels', () => {
+    const inv = createInvertColorMatrix();
+    // 0xff0000ff → 0x00ffffff
+    expect(applyColorMatrixToColor(inv, 0xff0000ff)).toBe(0x00ffffff);
+  });
+
+  it('grayscale matrix produces equal R/G/B', () => {
+    const gray = createGrayscaleColorMatrix();
+    const result = applyColorMatrixToColor(gray, RED);
+    const r = (result >>> 24) & 0xff;
+    const g = (result >>> 16) & 0xff;
+    const b = (result >>> 8) & 0xff;
+    expect(r).toBe(g);
+    expect(g).toBe(b);
+  });
+});
+
+describe('COLOR_MATRIX_LENGTH', () => {
+  it('is 20', () => {
+    expect(COLOR_MATRIX_LENGTH).toBe(20);
+  });
+});
+
+describe('concatColorMatrix', () => {
+  it('applying identity leaves matrix unchanged', () => {
+    const m = createGrayscaleColorMatrix();
+    const original = m.slice();
+    concatColorMatrix(m, createIdentityColorMatrix());
+    expect(m).toEqual(original);
+  });
+
+  it('is alias-safe when target === source', () => {
+    const m = createIdentityColorMatrix();
+    const original = m.slice();
+    concatColorMatrix(m, m);
+    // identity ∘ identity = identity
+    expect(m).toEqual(original);
+  });
+});
+
+describe('createBrightnessColorMatrix', () => {
+  it('returns a 20-element array', () => {
+    expect(createBrightnessColorMatrix(50)).toHaveLength(COLOR_MATRIX_LENGTH);
+  });
+
+  it('brightens black to grey', () => {
+    const m = createBrightnessColorMatrix(128);
+    const result = applyColorMatrixToColor(m, BLACK);
+    const r = (result >>> 24) & 0xff;
+    expect(r).toBe(128);
+  });
+});
+
+describe('createChannelMixerColorMatrix', () => {
+  it('returns a 20-element array', () => {
+    expect(createChannelMixerColorMatrix([1, 0, 0], [0, 1, 0], [0, 0, 1])).toHaveLength(COLOR_MATRIX_LENGTH);
+  });
+
+  it('identity mix leaves color unchanged', () => {
+    const m = createChannelMixerColorMatrix([1, 0, 0], [0, 1, 0], [0, 0, 1]);
+    const identity = createIdentityColorMatrix();
+    for (let i = 0; i < 20; i++) {
+      expect(m[i]).toBeCloseTo(identity[i]);
+    }
+  });
+
+  it('swap R and G channels', () => {
+    const m = createChannelMixerColorMatrix([0, 1, 0], [1, 0, 0], [0, 0, 1]);
+    // Apply to 0xff0000ff (pure red) — should output pure green
+    const result = applyColorMatrixToColor(m, 0xff0000ff);
+    const r = (result >>> 24) & 0xff;
+    const g = (result >>> 16) & 0xff;
+    expect(r).toBe(0);
+    expect(g).toBe(255);
+  });
+});
+
+describe('createColorBalanceColorMatrix', () => {
+  it('returns a 20-element array', () => {
+    expect(createColorBalanceColorMatrix([0, 0, 0], [0, 0, 0], [0, 0, 0])).toHaveLength(COLOR_MATRIX_LENGTH);
+  });
+
+  it('all-zero offsets is identity', () => {
+    const m = createColorBalanceColorMatrix([0, 0, 0], [0, 0, 0], [0, 0, 0]);
+    const identity = createIdentityColorMatrix();
+    for (let i = 0; i < 20; i++) {
+      expect(m[i]).toBeCloseTo(identity[i]);
+    }
+  });
+
+  it('positive red midtone raises red channel offset', () => {
+    const m = createColorBalanceColorMatrix([0, 0, 0], [100, 0, 0], [0, 0, 0]);
+    // Red offset should be positive (midtone weight 0.5 * 255 = 127.5)
+    expect(m[4]).toBeCloseTo(127.5, 0);
+    expect(m[9]).toBeCloseTo(0, 5); // green unaffected
+    expect(m[14]).toBeCloseTo(0, 5); // blue unaffected
+  });
+});
+
+describe('createColorMatrixFromTint', () => {
+  it('returns a 20-element array', () => {
+    expect(createColorMatrixFromTint(0xff0000ff, 0.5)).toHaveLength(COLOR_MATRIX_LENGTH);
+  });
+
+  it('amount=0 is identity', () => {
+    const m = createColorMatrixFromTint(0xff0000ff, 0);
+    const identity = createIdentityColorMatrix();
+    for (let i = 0; i < 20; i++) {
+      expect(m[i]).toBeCloseTo(identity[i]);
+    }
+  });
+});
+
+describe('createContrastColorMatrix', () => {
+  it('returns a 20-element array', () => {
+    expect(createContrastColorMatrix(1.5)).toHaveLength(COLOR_MATRIX_LENGTH);
+  });
+
+  it('amount=1 is identity', () => {
+    const m = createContrastColorMatrix(1);
+    const identity = createIdentityColorMatrix();
+    for (let i = 0; i < 20; i++) {
+      expect(m[i]).toBeCloseTo(identity[i]);
+    }
+  });
+});
+
+describe('createDesaturateColorMatrix', () => {
+  it('amount=1 produces a grayscale matrix', () => {
+    const desaturate = createDesaturateColorMatrix(1);
+    const grayscale = createGrayscaleColorMatrix();
+    for (let i = 0; i < 20; i++) {
+      expect(desaturate[i]).toBeCloseTo(grayscale[i]);
+    }
+  });
+
+  it('amount=0 is identity', () => {
+    const m = createDesaturateColorMatrix(0);
+    const identity = createIdentityColorMatrix();
+    for (let i = 0; i < 20; i++) {
+      expect(m[i]).toBeCloseTo(identity[i]);
+    }
+  });
+});
+
+describe('createGrayscaleColorMatrix', () => {
+  it('returns a 20-element array', () => {
+    expect(createGrayscaleColorMatrix()).toHaveLength(COLOR_MATRIX_LENGTH);
+  });
+
+  it('luma row sums to 1', () => {
+    const m = createGrayscaleColorMatrix();
+    expect(m[0] + m[1] + m[2]).toBeCloseTo(1);
+  });
+});
+
+describe('createHueRotateColorMatrix', () => {
+  it('returns a 20-element array', () => {
+    expect(createHueRotateColorMatrix(90)).toHaveLength(COLOR_MATRIX_LENGTH);
+  });
+
+  it('0 degrees is close to identity', () => {
+    const m = createHueRotateColorMatrix(0);
+    const identity = createIdentityColorMatrix();
+    for (let i = 0; i < 20; i++) {
+      expect(m[i]).toBeCloseTo(identity[i]);
+    }
+  });
+
+  it('360 degrees is close to identity', () => {
+    const m = createHueRotateColorMatrix(360);
+    const identity = createIdentityColorMatrix();
+    for (let i = 0; i < 20; i++) {
+      expect(m[i]).toBeCloseTo(identity[i]);
+    }
+  });
+});
+
+describe('createIdentityColorMatrix', () => {
+  it('returns a 20-element array', () => {
+    expect(createIdentityColorMatrix()).toHaveLength(COLOR_MATRIX_LENGTH);
+  });
+
+  it('leaves red unchanged', () => {
+    expect(applyColorMatrixToColor(createIdentityColorMatrix(), RED)).toBe(RED);
+  });
+});
+
+describe('createInvertColorMatrix', () => {
+  it('returns a 20-element array', () => {
+    expect(createInvertColorMatrix()).toHaveLength(COLOR_MATRIX_LENGTH);
+  });
+
+  it('inverts white to black (RGB only, alpha unchanged)', () => {
+    const result = applyColorMatrixToColor(createInvertColorMatrix(), 0xffffff00);
+    expect((result >>> 24) & 0xff).toBe(0);
+    expect((result >>> 16) & 0xff).toBe(0);
+    expect((result >>> 8) & 0xff).toBe(0);
+  });
+});
+
+describe('createLevelsColorMatrix', () => {
+  it('returns a 20-element array', () => {
+    expect(createLevelsColorMatrix(0, 255, 0, 255)).toHaveLength(COLOR_MATRIX_LENGTH);
+  });
+
+  it('full range with gamma=1 is identity', () => {
+    const m = createLevelsColorMatrix(0, 255, 0, 255, 1);
+    const identity = createIdentityColorMatrix();
+    for (let i = 0; i < 20; i++) {
+      expect(m[i]).toBeCloseTo(identity[i]);
+    }
+  });
+
+  it('clips blacks: inBlack=128 shifts scale', () => {
+    const m = createLevelsColorMatrix(128, 255, 0, 255);
+    // scale = 255 / (255-128) ≈ 2.008; offset = 0 - 128 * 2.008 ≈ -257
+    expect(m[0]).toBeGreaterThan(1); // amplified
+  });
+});
+
+describe('createOpacityColorMatrix', () => {
+  it('returns a 20-element array', () => {
+    expect(createOpacityColorMatrix(0.5)).toHaveLength(COLOR_MATRIX_LENGTH);
+  });
+
+  it('scales alpha channel', () => {
+    const m = createOpacityColorMatrix(0.5);
+    // white fully opaque (alpha=255) → alpha should be ~128
+    const result = applyColorMatrixToColor(m, WHITE);
+    const a = result & 0xff;
+    expect(a).toBeCloseTo(128, 0);
+  });
+});
+
+describe('createPolaroidColorMatrix', () => {
+  it('returns a 20-element array', () => {
+    expect(createPolaroidColorMatrix()).toHaveLength(COLOR_MATRIX_LENGTH);
+  });
+});
+
+describe('createSaturationColorMatrix', () => {
+  it('returns a 20-element array', () => {
+    expect(createSaturationColorMatrix(0.5)).toHaveLength(COLOR_MATRIX_LENGTH);
+  });
+
+  it('saturation=1 is identity', () => {
+    const m = createSaturationColorMatrix(1);
+    const identity = createIdentityColorMatrix();
+    for (let i = 0; i < 20; i++) {
+      expect(m[i]).toBeCloseTo(identity[i]);
+    }
+  });
+
+  it('saturation=0 matches grayscale matrix', () => {
+    const sat0 = createSaturationColorMatrix(0);
+    const gray = createGrayscaleColorMatrix();
+    for (let i = 0; i < 20; i++) {
+      expect(sat0[i]).toBeCloseTo(gray[i]);
+    }
+  });
+});
+
+describe('createSepiaColorMatrix', () => {
+  it('returns a 20-element array', () => {
+    expect(createSepiaColorMatrix()).toHaveLength(COLOR_MATRIX_LENGTH);
+  });
+});
+
+describe('createTechnicolorColorMatrix', () => {
+  it('returns a 20-element array', () => {
+    expect(createTechnicolorColorMatrix()).toHaveLength(COLOR_MATRIX_LENGTH);
+  });
+});
+
+describe('createVintageColorMatrix', () => {
+  it('returns a 20-element array', () => {
+    expect(createVintageColorMatrix()).toHaveLength(COLOR_MATRIX_LENGTH);
+  });
+});
+
+describe('createWhiteBalanceColorMatrix', () => {
+  it('returns a 20-element array', () => {
+    expect(createWhiteBalanceColorMatrix(0, 0)).toHaveLength(COLOR_MATRIX_LENGTH);
+  });
+
+  it('neutral (0, 0) is identity', () => {
+    const m = createWhiteBalanceColorMatrix(0, 0);
+    const identity = createIdentityColorMatrix();
+    for (let i = 0; i < 20; i++) {
+      expect(m[i]).toBeCloseTo(identity[i]);
+    }
+  });
+
+  it('warm temperature (positive) increases red gain and decreases blue gain', () => {
+    const m = createWhiteBalanceColorMatrix(50, 0);
+    // m[0] = R diagonal (index 0), m[12] = B diagonal (index 2*5+2)
+    expect(m[0]).toBeGreaterThan(1); // R gain > 1
+    expect(m[12]).toBeLessThan(1); // B gain < 1
+  });
+
+  it('cool temperature (negative) decreases red gain and increases blue gain', () => {
+    const m = createWhiteBalanceColorMatrix(-50, 0);
+    // m[0] = R diagonal (index 0), m[12] = B diagonal (index 2*5+2)
+    expect(m[0]).toBeLessThan(1); // R gain < 1
+    expect(m[12]).toBeGreaterThan(1); // B gain > 1
+  });
+
+  it('positive tint increases green gain', () => {
+    const m = createWhiteBalanceColorMatrix(0, 100);
+    // m[6] = G diagonal (index 1*5+1)
+    expect(m[6]).toBeGreaterThan(1); // G gain > 1
+  });
+});
+
+describe('fuseColorMatrices', () => {
+  it('empty list yields the identity', () => {
+    expect(fuseColorMatrices([])).toEqual(createIdentityColorMatrix());
+  });
+
+  it('single matrix is returned as an independent copy', () => {
+    const invert = createInvertColorMatrix();
+    const fused = fuseColorMatrices([invert]);
+    expect(fused).toEqual(invert);
+    expect(fused).not.toBe(invert);
+  });
+
+  it('fuses a run of three in application order (index 0 first)', () => {
+    const a = createInvertColorMatrix();
+    const b = createGrayscaleColorMatrix();
+    const c = createContrastColorMatrix(1.5);
+    // Applying `a` then `b` then `c` = c × b × a as a single composed matrix (no per-stage rounding).
+    const expected = multiplyColorMatrix(c, multiplyColorMatrix(b, a));
+    const fused = fuseColorMatrices([a, b, c]);
+    for (let i = 0; i < 20; i++) expect(fused[i]).toBeCloseTo(expected[i], 10);
+  });
+
+  it('order matters (composition is not commutative)', () => {
+    const invert = createInvertColorMatrix();
+    const sepia = createSepiaColorMatrix();
+    const forward = fuseColorMatrices([invert, sepia]);
+    const reversed = fuseColorMatrices([sepia, invert]);
+    expect(applyColorMatrixToColor(forward, RED)).not.toBe(applyColorMatrixToColor(reversed, RED));
+  });
+
+  it('does not mutate its inputs', () => {
+    const a = createInvertColorMatrix();
+    const b = createSepiaColorMatrix();
+    const aCopy = a.slice();
+    const bCopy = b.slice();
+    fuseColorMatrices([a, b]);
+    expect(a).toEqual(aCopy);
+    expect(b).toEqual(bCopy);
+  });
+});
+
+describe('multiplyColorMatrix', () => {
+  it('identity ∘ identity = identity', () => {
+    const identity = createIdentityColorMatrix();
+    const result = multiplyColorMatrix(identity, identity);
+    for (let i = 0; i < 20; i++) {
+      expect(result[i]).toBeCloseTo(identity[i]);
+    }
+  });
+
+  it('writes to out when provided', () => {
+    const identity = createIdentityColorMatrix();
+    const out = new Array(20).fill(0);
+    const returned = multiplyColorMatrix(identity, identity, out);
+    expect(returned).toBe(out);
+  });
+
+  it('is alias-safe when out === a', () => {
+    const a = createGrayscaleColorMatrix();
+    const b = createIdentityColorMatrix();
+    const expected = multiplyColorMatrix(a, b);
+    multiplyColorMatrix(a, b, a);
+    for (let i = 0; i < 20; i++) {
+      expect(a[i]).toBeCloseTo(expected[i]);
+    }
+  });
+
+  it('is alias-safe when out === b', () => {
+    const a = createIdentityColorMatrix();
+    const b = createGrayscaleColorMatrix();
+    const expected = multiplyColorMatrix(a, b);
+    multiplyColorMatrix(a, b, b);
+    for (let i = 0; i < 20; i++) {
+      expect(b[i]).toBeCloseTo(expected[i]);
+    }
+  });
+});

package/src/colorTransformAdjustment.test.ts

@@ -0,0 +1,40 @@
+import type { ColorTransform } from '@flighthq/types';
+
+import { applyColorMatrixToColor } from './colorMatrixMath';
+import { createColorTransformAdjustment } from './colorTransformAdjustment';
+
+function makeColorTransform(fields: Partial<ColorTransform>): ColorTransform {
+  return {
+    redMultiplier: 1,
+    greenMultiplier: 1,
+    blueMultiplier: 1,
+    alphaMultiplier: 1,
+    redOffset: 0,
+    greenOffset: 0,
+    blueOffset: 0,
+    alphaOffset: 0,
+    ...fields,
+  } as ColorTransform;
+}
+
+describe('createColorTransformAdjustment', () => {
+  it('carries the ColorTransform payload and the ColorTransformAdjustment kind', () => {
+    const colorTransform = makeColorTransform({ redMultiplier: 0.5 });
+    const adjustment = createColorTransformAdjustment(colorTransform);
+    expect(adjustment.kind).toBe('ColorTransformAdjustment');
+    expect(adjustment.colorTransform).toBe(colorTransform);
+  });
+
+  it('bakes a diagonal-affine 4×5 matrix so white tints to red', () => {
+    const adjustment = createColorTransformAdjustment(
+      makeColorTransform({ redMultiplier: 1, greenMultiplier: 0, blueMultiplier: 0 }),
+    );
+    expect(applyColorMatrixToColor(adjustment.colorMatrix as number[], 0xffffffff)).toBe(0xff0000ff);
+  });
+
+  it('bakes offsets in the 0–255 column', () => {
+    const adjustment = createColorTransformAdjustment(makeColorTransform({ redOffset: 40 }));
+    // Red channel 0x10 (16) + 40 = 56 = 0x38; other channels unchanged.
+    expect(applyColorMatrixToColor(adjustment.colorMatrix as number[], 0x102030ff)).toBe(0x382030ff);
+  });
+});

package/src/exposureAdjustment.test.ts

@@ -0,0 +1,22 @@
+import { applyColorMatrixToColor } from './colorMatrixMath';
+import { createExposureAdjustment } from './exposureAdjustment';
+
+describe('createExposureAdjustment', () => {
+  it('defaults to the identity (exposure 0)', () => {
+    const adjustment = createExposureAdjustment();
+    expect(adjustment.kind).toBe('ExposureAdjustment');
+    expect(applyColorMatrixToColor(adjustment.colorMatrix as number[], 0x204060ff)).toBe(0x204060ff);
+  });
+
+  it('scales RGB by 2^exposure, preserving alpha', () => {
+    const adjustment = createExposureAdjustment({ exposure: 1 });
+    // Each channel doubles; alpha is untouched.
+    expect(applyColorMatrixToColor(adjustment.colorMatrix as number[], 0x204060ff)).toBe(0x4080c0ff);
+  });
+
+  it('clamps to SDR [0,1] for the default pipeline', () => {
+    const adjustment = createExposureAdjustment({ exposure: 1 });
+    // 0x80 doubled is 256 → clamps to 255.
+    expect(applyColorMatrixToColor(adjustment.colorMatrix as number[], 0x808080ff)).toBe(0xffffffff);
+  });
+});

package/src/grayscaleAdjustment.test.ts

@@ -0,0 +1,23 @@
+import { applyColorMatrixToColor } from './colorMatrixMath';
+import { createGrayscaleAdjustment } from './grayscaleAdjustment';
+
+describe('createGrayscaleAdjustment', () => {
+  it('defaults to full BT.709 luma desaturation', () => {
+    const adjustment = createGrayscaleAdjustment();
+    expect(adjustment.kind).toBe('GrayscaleAdjustment');
+    // Pure red → luma 0.2126·255 ≈ 54, equal across channels; alpha preserved.
+    const out = applyColorMatrixToColor(adjustment.colorMatrix as number[], 0xff0000ff);
+    const r = (out >>> 24) & 0xff;
+    const g = (out >>> 16) & 0xff;
+    const b = (out >>> 8) & 0xff;
+    expect(r).toBe(g);
+    expect(g).toBe(b);
+    expect(r).toBe(Math.round(0.2126 * 255));
+    expect(out & 0xff).toBe(0xff);
+  });
+
+  it('intensity 0 leaves color unchanged', () => {
+    const adjustment = createGrayscaleAdjustment({ intensity: 0 });
+    expect(applyColorMatrixToColor(adjustment.colorMatrix as number[], 0x2040a0ff)).toBe(0x2040a0ff);
+  });
+});

package/src/hueSaturationAdjustment.test.ts

@@ -0,0 +1,33 @@
+import { createHueSaturationAdjustment } from './hueSaturationAdjustment';
+
+describe('createHueSaturationAdjustment', () => {
+  it('defaults to the identity and carries a fusable transform', () => {
+    const adjustment = createHueSaturationAdjustment();
+    expect(adjustment.kind).toBe('HueSaturationAdjustment');
+    expect(typeof adjustment.transform).toBe('function');
+    const out: [number, number, number] = [0, 0, 0];
+    adjustment.transform(out, 0.2, 0.4, 0.6);
+    expect(out[0]).toBeCloseTo(0.2, 4);
+    expect(out[1]).toBeCloseTo(0.4, 4);
+    expect(out[2]).toBeCloseTo(0.6, 4);
+  });
+
+  it('fully desaturates to luma-preserving grey at saturation 0', () => {
+    const adjustment = createHueSaturationAdjustment({ saturation: 0 });
+    const out: [number, number, number] = [0, 0, 0];
+    adjustment.transform(out, 1, 0, 0);
+    // HSL saturation 0 collapses to lightness grey (mid of max/min = 0.5).
+    expect(out[0]).toBeCloseTo(0.5, 4);
+    expect(out[0]).toBeCloseTo(out[1], 4);
+    expect(out[1]).toBeCloseTo(out[2], 4);
+  });
+
+  it('rotates hue by 120° mapping red toward green', () => {
+    const adjustment = createHueSaturationAdjustment({ hue: 120 });
+    const out: [number, number, number] = [0, 0, 0];
+    adjustment.transform(out, 1, 0, 0);
+    expect(out[1]).toBeCloseTo(1, 4);
+    expect(out[0]).toBeCloseTo(0, 4);
+    expect(out[2]).toBeCloseTo(0, 4);
+  });
+});

package/src/invertAdjustment.test.ts

@@ -0,0 +1,24 @@
+import { applyColorMatrixToColor } from './colorMatrixMath';
+import { createInvertAdjustment } from './invertAdjustment';
+
+describe('createInvertAdjustment', () => {
+  it('defaults to a full invert and carries the fusable kind', () => {
+    const adjustment = createInvertAdjustment();
+    expect(adjustment.kind).toBe('InvertAdjustment');
+    expect(adjustment.colorMatrix).toHaveLength(20);
+    // Opaque mid-grey inverts to itself; pure red inverts to cyan. Alpha is preserved.
+    expect(applyColorMatrixToColor(adjustment.colorMatrix as number[], 0x808080ff)).toBe(0x7f7f7fff);
+    expect(applyColorMatrixToColor(adjustment.colorMatrix as number[], 0xff0000ff)).toBe(0x00ffffff);
+  });
+
+  it('intensity 0 is the identity', () => {
+    const adjustment = createInvertAdjustment({ intensity: 0 });
+    expect(applyColorMatrixToColor(adjustment.colorMatrix as number[], 0x123456ff)).toBe(0x123456ff);
+  });
+
+  it('intensity 0.5 collapses toward mid-grey', () => {
+    const adjustment = createInvertAdjustment({ intensity: 0.5 });
+    // scale 0, offset 127.5 → every channel rounds to 128.
+    expect(applyColorMatrixToColor(adjustment.colorMatrix as number[], 0x00ffccff)).toBe(0x808080ff);
+  });
+});