Skip to content

Free open-source image editor for the browser

Simplify the tests: one workflow test per feature, fewer duplicates (#66)

Rodrigo Belfiore45fd7fcbf08f
diff --git a/src/app/loaders/scene.ts b/src/app/loaders/scene.ts
index c1b0975..b3d47ad 100644
--- a/src/app/loaders/scene.ts
+++ b/src/app/loaders/scene.ts
@@ -11,7 +11,7 @@ export const sceneExtension = ".openlight";
/** Sources are stored, so only `scene.json` inflates; a scene with 7,000 stroke points is about 200 kB. */
const inflateLimit = 256 * 2 ** 20;
-export function isSceneFile(file: File) {
+function isSceneFile(file: File) {
return file.name.toLowerCase().endsWith(sceneExtension);
}
diff --git a/src/features/color-mixer/pass.ts b/src/features/color-mixer/pass.ts
index c674404..a5b3805 100644
--- a/src/features/color-mixer/pass.ts
+++ b/src/features/color-mixer/pass.ts
@@ -3,8 +3,8 @@ import { node } from "@/core/renderer";
import shader from "./mixer.wgsl";
import { colors, isNeutral } from "./model";
-export function colorMixer(mixer?: ColorMixer, name = "color-mixer") {
- if (!mixer || isNeutral(mixer)) {
+export function colorMixer(mixer: ColorMixer, name: string) {
+ if (isNeutral(mixer)) {
return;
}
return node(name, shader, {
diff --git a/src/features/heal/source.ts b/src/features/heal/source.ts
index c190403..3aca6ec 100644
--- a/src/features/heal/source.ts
+++ b/src/features/heal/source.ts
@@ -1,4 +1,4 @@
-import type { Gpu, Target, Timer } from "vgpu";
+import type { Gpu, Target } from "vgpu";
import type { BrushStroke } from "@/core/document";
import type { Point } from "@/core/image/frame";
import { createRenderGraph, input, merge, node } from "@/core/renderer";
@@ -93,8 +93,8 @@ function matchSource(
}
/** Owns one thumbnail pass, reused for each automatic source search. */
-export function createHealSearch(gpu: Gpu, timer?: Timer) {
- const graph = createRenderGraph(gpu, timer);
+export function createHealSearch(gpu: Gpu) {
+ const graph = createRenderGraph(gpu);
return {
async find(
image: Target,
@@ -125,7 +125,6 @@ export function createHealSearch(gpu: Gpu, timer?: Timer) {
strokes,
);
},
- inspect: graph.inspect,
dispose: graph.dispose,
};
}
diff --git a/src/features/layers/edits.ts b/src/features/layers/edits.ts
index 60f8c87..4c2d289 100644
--- a/src/features/layers/edits.ts
+++ b/src/features/layers/edits.ts
@@ -43,7 +43,7 @@ function changeChildren(
}));
}
-export function validateDepth(layers: readonly Layer[]) {
+function validateDepth(layers: readonly Layer[]) {
if (
layers.some((layer) =>
layer.children.some((child) => child.children.length > 0),
diff --git a/tests/assistant.e2e.ts b/tests/assistant.e2e.ts
index cbcf042..9e2c5a1 100644
--- a/tests/assistant.e2e.ts
+++ b/tests/assistant.e2e.ts
@@ -1,6 +1,6 @@
-import { expect, test } from "./fixtures";
+import { expect, openPhoto, test } from "./fixtures";
-test("the assistant shows only at /?assistant, opens, runs the commands a message returns on the photo it was sent for, selects the layer they edit, replies, and closes", async ({
+test("the assistant at /?assistant edits the photo it was asked about and selects the layer it edits", async ({
page,
}) => {
const requests: unknown[] = [];
@@ -10,16 +10,6 @@ test("the assistant shows only at /?assistant, opens, runs the commands a messag
});
await page.route("**/api/assistant", async (route) => {
requests.push(route.request().postDataJSON());
- if (requests.length === 3) {
- await released;
- await route.fulfill({
- json: {
- commands: [{ type: "set-adjustments", exposure: 2 }],
- message: "exposure 0 → 2",
- },
- });
- return;
- }
if (requests.length === 1) {
await route.fulfill({
json: {
@@ -32,29 +22,25 @@ test("the assistant shows only at /?assistant, opens, runs the commands a messag
});
return;
}
+ await released;
await route.fulfill({
- json: { commands: [], message: "You're welcome!" },
+ json: {
+ commands: [{ type: "set-adjustments", exposure: 2 }],
+ message: "exposure 0 → 2",
+ },
});
});
- const open = async () => {
- await page
- .locator('input[type="file"]')
- .setInputFiles("tests/fixtures/photo.svg");
- await expect(
- page.getByRole("button", { name: "Open an image or scene" }),
- ).toBeVisible();
- };
const button = page.getByRole("button", { name: "Assistant", exact: true });
- await page.goto("/");
- await open();
+ const state = () => page.evaluate(() => window.openlight.getState());
+ await openPhoto(page);
await expect(button).toBeHidden();
await page.goto("/?assistant");
- await open();
+ await page
+ .locator('input[type="file"]')
+ .setInputFiles("tests/fixtures/photo.svg");
await button.click();
const message = page.getByRole("textbox", { name: "Message", exact: true });
- await expect(message).toBeFocused();
-
await message.fill("darker, with a vignette");
await message.press("Enter");
await expect(
@@ -62,21 +48,15 @@ test("the assistant shows only at /?assistant, opens, runs the commands a messag
).toBeVisible();
expect(requests[0]).toMatchObject({
message: "darker, with a vignette",
- earlier: [],
- photo: { sourceSize: [1200, 800], comparison: "edited" },
+ photo: { sourceSize: [1200, 800] },
});
- const state = await page.evaluate(() => window.openlight.getState());
- expect(state.adjustments.exposure).toBe(-1);
- const vignette = state.scene?.layers.find(
+ const edited = await state();
+ expect(edited.adjustments.exposure).toBe(-1);
+ const vignette = edited.scene?.layers.find(
(layer) => layer.kind === "vignette",
);
expect(vignette).toMatchObject({ vignette: { intensity: 40 } });
- expect(state.selectedLayerId).toBe(vignette?.id);
-
- await message.fill("thanks");
- await message.press("Enter");
- await expect(page.getByText("You're welcome!")).toBeVisible();
- expect(requests[1]).toMatchObject({ earlier: ["darker, with a vignette"] });
+ expect(edited.selectedLayerId).toBe(vignette?.id);
// An answer that arrives after another photo opens leaves the new photo alone.
await message.fill("brighter");
@@ -84,23 +64,13 @@ test("the assistant shows only at /?assistant, opens, runs the commands a messag
const chooser = page.waitForEvent("filechooser");
await page.getByRole("button", { name: "Open an image or scene" }).click();
await (await chooser).setFiles("tests/fixtures/tones.png");
- await expect
- .poll(() => page.evaluate(() => window.openlight.getState().file))
- .toBe("tones.png");
+ await expect.poll(async () => (await state()).file).toBe("tones.png");
release();
- await expect(
- page.getByText(
- "Another photo opened before the answer came, so I left it unedited.",
- ),
- ).toBeVisible();
- expect(
- (await page.evaluate(() => window.openlight.getState())).adjustments
- .exposure,
- ).toBe(0);
+ await expect(page.getByText("Another photo opened")).toBeVisible();
+ expect(requests[1]).toMatchObject({ earlier: ["darker, with a vignette"] });
+ expect((await state()).adjustments.exposure).toBe(0);
await message.press("Escape");
await expect(message).toBeHidden();
- await expect(
- page.getByRole("button", { name: "Assistant", exact: true }),
- ).toBeFocused();
+ await expect(button).toBeFocused();
});
diff --git a/tests/assistant.test.ts b/tests/assistant.test.ts
index e92cda8..f472802 100644
--- a/tests/assistant.test.ts
+++ b/tests/assistant.test.ts
@@ -1,30 +1,18 @@
import { expect, test } from "bun:test";
import { ask, interpret } from "@/app/assistant/jev";
import type { AssistantRequest } from "@/app/assistant/protocol";
+import { defaultAdjustments } from "@/features/adjustments/model";
+import { defaultCurve } from "@/features/tone-curves/curve";
const request: AssistantRequest = {
message: "warmer and darker",
earlier: [],
photo: {
- adjustments: {
- exposure: 0.5,
- contrast: 0,
- highlights: 0,
- shadows: 0,
- whites: 0,
- blacks: 0,
- incrementalTemperature: 0,
- incrementalTint: 0,
- vibrance: 0,
- saturation: 0,
- },
+ adjustments: { ...defaultAdjustments, exposure: 0.5 },
vignette: 0,
clarity: 0,
sharpening: 0,
- toneCurve: [
- { x: 0, y: 0 },
- { x: 1, y: 1 },
- ],
+ toneCurve: [...defaultCurve],
comparison: "edited",
sourceSize: [300, 200],
},
@@ -93,34 +81,16 @@ test("the assistant asks one question per decision and turns the answers into co
]);
expect(sky.message).toBe("top exposure -1");
- const inverted = {
- ...request,
- photo: {
- ...request.photo,
- toneCurve: [
- { x: 0, y: 1 },
- { x: 1, y: 0 },
- ],
- },
- };
- expect(interpret(inverted, answers({ invert: 1 }, { count: "one" }))).toEqual(
- {
- commands: [{ type: "set-tone-curve" }],
- message: "Colors restored",
- },
- );
+ const toneCurve = defaultCurve.map(({ x, y }) => ({ x, y: 1 - y }));
+ const inverted = { ...request, photo: { ...request.photo, toneCurve } };
+ const reset = interpret(inverted, answers({ invert: 1 }, { count: "one" }));
+ expect(reset.commands).toEqual([{ type: "set-tone-curve" }]);
+ expect(reset.message).toBe("Colors restored");
- expect(
- interpret(
- request,
- answers(
- { reply: 0.9, exposure: 0.1 },
- { count: "one", reply: "greeting" },
- ),
- ),
- ).toEqual({
- commands: [],
- message:
- "Hi! I can edit this photo for you. Try “make it warmer” or “darken the sky”.",
- });
+ const greeting = interpret(
+ request,
+ answers({ reply: 0.9, exposure: 0.1 }, { count: "one", reply: "greeting" }),
+ );
+ expect(greeting.commands).toEqual([]);
+ expect(greeting.message).toStartWith("Hi! I can edit this photo for you.");
});
diff --git a/tests/brush.e2e.ts b/tests/brush.e2e.ts
index aa7f6bd..7ede517 100644
--- a/tests/brush.e2e.ts
+++ b/tests/brush.e2e.ts
@@ -1,23 +1,22 @@
-import type { Page } from "@playwright/test";
-import { expect, test } from "./fixtures";
+import { expect, openPhoto, test } from "./fixtures";
import { readImage, readPreview } from "./images";
import { box, drag } from "./pointer";
-/** Export pixels inside the stroke and far above it. */
-async function samples(page: Page) {
- const { samples } = await readImage(page, undefined, [
- [600, 400],
- [600, 100],
- ]);
- return samples ?? [];
-}
-
test("paint a brush mask, adjust it in the sidebar, erase, and undo", async ({
page,
-}, info) => {
+}) => {
test.setTimeout(90_000);
await page.setViewportSize({ width: 1440, height: 1000 });
const state = () => page.evaluate(() => window.openlight.getState());
+ const adjustTab = page.getByRole("tab", { name: "Adjust", exact: true });
+ /** Export pixels inside the stroke and far above it. */
+ async function samples() {
+ const points = [
+ [600, 400],
+ [600, 100],
+ ] as const;
+ return (await readImage(page, undefined, points)).samples ?? [];
+ }
async function setField(name: string, value: string) {
const field = page.getByRole("textbox", { name, exact: true });
await field.fill(value);
@@ -27,31 +26,11 @@ test("paint a brush mask, adjust it in the sidebar, erase, and undo", async ({
const { center } = await readPreview(page);
return center[0] > center[1] + 30;
}
- await page.goto("/");
- await page
- .locator('input[type="file"]')
- .setInputFiles("tests/fixtures/photo.svg");
- await expect(
- page.getByRole("textbox", { name: "Exposure", exact: true }),
- ).toHaveValue("0.00");
- const original = await samples(page);
+ await openPhoto(page);
+ const original = await samples();
+ const { history } = await state();
await page.getByRole("tab", { name: "Brush", exact: true }).click();
const canvas = page.getByLabel("Brush canvas", { exact: true });
- await expect(canvas).toBeVisible();
- // Choosing the tool creates its mask at once, so the sidebar already edits it.
- expect((await state()).scene?.layers).toHaveLength(2);
- // Tool options sit over the canvas; the sidebar keeps the selected layer's adjustments.
- const options = page.getByRole("group", { name: "Layer options" });
- const overlayButton = page.getByRole("button", {
- name: "Mask overlay",
- exact: true,
- });
- await expect(
- options.getByRole("textbox", { name: "Size", exact: true }),
- ).toBeVisible();
- await expect(
- page.getByRole("heading", { name: "Mask adjustments", exact: true }),
- ).toBeVisible();
const bounds = await box(canvas);
const scale = Math.min(
(bounds.width - 48) / 1200,
@@ -61,41 +40,39 @@ test("paint a brush mask, adjust it in the sidebar, erase, and undo", async ({
const center = [bounds.x + bounds.width / 2, bounds.y + bounds.height / 2];
const from = [center[0] - 150 * scale, center[1]];
const to = [center[0] + 150 * scale, center[1]];
- const brushCursor = canvas.locator('[data-brush-cursor="true"]');
- const sizeField = options.getByRole("textbox", {
- name: "Size",
- exact: true,
- });
- await sizeField.focus();
- await expect(brushCursor).toHaveAttribute("data-preview", "true");
- await sizeField.fill("200");
- await sizeField.press("Enter");
- await expect(brushCursor).toHaveCount(0);
- const featherField = options.getByRole("textbox", {
- name: "Feather",
- exact: true,
+ await test.step("a cancelled stroke leaves the new mask untouched, and leaving drops it", async () => {
+ await page.mouse.move(from[0], from[1]);
+ await page.mouse.down();
+ await page.mouse.move(to[0], to[1], { steps: 8 });
+ await page.keyboard.press("Escape");
+ await page.mouse.up();
+ await page.keyboard.press("Escape");
+ await expect(canvas).toHaveCount(0);
+ expect(await state()).toMatchObject({ scene: { layers: [{}] }, history });
});
- await featherField.focus();
- await expect(brushCursor).toHaveAttribute("data-preview", "true");
- await featherField.press("Enter");
- await expect(brushCursor).toHaveCount(0);
- await test.step("a drag paints the new brush mask, which shows its overlay", async () => {
+ await test.step("an adjustment before the first stroke belongs to the new mask", async () => {
+ await page.keyboard.press("b");
+ await setField("Size", "200");
+ await setField("Exposure", "2");
+ expect(await samples()).toEqual(original);
await drag(page, from, to, 16);
- const layers = (await state()).scene?.layers;
- expect(layers).toHaveLength(2);
- const mask = layers?.[1];
- expect(mask).toMatchObject({ kind: "mask", name: "Brush" });
- if (mask?.kind === "mask" && mask.mask.kind === "brush") {
- expect(mask.mask.strokes).toHaveLength(1);
- expect(mask.mask.strokes[0].size).toBeCloseTo(200 / scale, 6);
- expect(mask.mask.strokes[0].points.length).toBeGreaterThan(2);
- }
- expect((await state()).selectedLayerId).toBe(mask?.id);
- expect(await samples(page)).toEqual(original);
+ const current = await state();
+ expect(current.scene?.layers[1]).toMatchObject({
+ id: current.selectedLayerId,
+ name: "Brush",
+ mask: {
+ kind: "brush",
+ strokes: [{ size: expect.closeTo(200 / scale, 6) }],
+ },
+ });
+ const [inside, above] = await samples();
+ expect(inside[0]).toBeGreaterThan(original[0][0] + 40);
+ expect(above).toEqual(original[1]);
await page.mouse.move(bounds.x + 20, bounds.y + 20);
+ await page.keyboard.press("o");
await expect.poll(tinted).toBe(true);
- await expect(overlayButton).toHaveAttribute("aria-pressed", "true");
- // The row's thumbnail shows the stroke through the middle once it is committed.
+ await page.keyboard.press("o");
+ // The row's thumbnail shows the stroke through the middle.
const thumbnail = page
.getByRole("region", { name: "Layers", exact: true })
.getByLabel("Mask thumbnail", { exact: true });
@@ -110,97 +87,28 @@ test("paint a brush mask, adjust it in the sidebar, erase, and undo", async ({
)
.toEqual({ lit: true, dark: true });
});
+ await test.step("Alt erases in one undo step", async () => {
+ const painted = await samples();
+ await page.keyboard.down("Alt");
+ await drag(page, from, to, 16);
+ await page.keyboard.up("Alt");
+ expect((await samples())[0]).toEqual(original[0]);
+ await page.keyboard.press("ControlOrMeta+z");
+ expect(await samples()).toEqual(painted);
+ });
await test.step("Enter leaves one level at a time; selecting the mask returns", async () => {
- const selected = (await state()).selectedLayerId;
+ const { selectedLayerId, scene } = await state();
await page.keyboard.press("Enter");
- await expect(
- page.getByRole("tab", { name: "Adjust", exact: true }),
- ).toHaveAttribute("aria-selected", "true");
- await expect(canvas).toHaveCount(0);
- expect((await state()).selectedLayerId).toBe(selected);
- await expect.poll(tinted).toBe(false);
- await expect(overlayButton).toHaveAttribute("aria-pressed", "false");
- // The next Enter selects the image and its global controls.
+ await expect(adjustTab).toHaveAttribute("aria-selected", "true");
+ expect((await state()).selectedLayerId).toBe(selectedLayerId);
await page.keyboard.press("Enter");
- const state2 = await state();
- expect(state2.selectedLayerId).toBe(state2.scene?.layers[0].id);
- await expect(overlayButton).toHaveCount(0);
+ expect((await state()).selectedLayerId).toBe(scene?.layers[0].id);
await page
.getByRole("button", { name: "Select Brush", exact: true })
.click();
- await expect(
- page.getByRole("tab", { name: "Brush", exact: true }),
- ).toHaveAttribute("aria-selected", "true");
- await expect(canvas).toBeVisible();
- await page.mouse.move(bounds.x + 20, bounds.y + 20);
- await expect.poll(tinted).toBe(true);
- });
- await test.step("an adjustment replaces the overlay with its own effect", async () => {
- await setField("Exposure", "2");
- const [inside, above] = await samples(page);
- expect(inside[0]).toBeGreaterThan(original[0][0] + 40);
- expect(above).toEqual(original[1]);
- await expect.poll(tinted).toBe(false);
- await page.keyboard.press("o");
- await expect.poll(tinted).toBe(true);
- await expect(overlayButton).toHaveAttribute("aria-pressed", "true");
- await page.keyboard.press("o");
- await expect.poll(tinted).toBe(false);
- await page.screenshot({ path: info.outputPath("brush-ui.png") });
- });
- await test.step("Alt erases and each stroke is one undo step", async () => {
- const painted = await samples(page);
- const before = (await state()).history.undoCount;
- await page.keyboard.down("Alt");
- await drag(page, from, to, 16);
- await page.keyboard.up("Alt");
- expect((await state()).history.undoCount).toBe(before + 1);
- expect((await samples(page))[0]).toEqual(original[0]);
- await page.keyboard.press("ControlOrMeta+z");
- expect(await samples(page)).toEqual(painted);
- await page.keyboard.press("ControlOrMeta+z");
- expect(await samples(page)).toEqual(original);
- await page.keyboard.press("ControlOrMeta+z");
- await page.keyboard.press("ControlOrMeta+z");
- expect((await state()).scene?.layers).toHaveLength(1);
- });
- await test.step("an untouched new brush mask leaves no trace; an adjusted one stays", async () => {
- const before = (await state()).history.undoCount;
- await page.keyboard.press("b");
await expect(canvas).toBeVisible();
- expect((await state()).scene?.layers[1]).toMatchObject({
- kind: "mask",
- name: "Brush",
- mask: { kind: "brush", strokes: [] },
- });
- // Escape cancels the stroke and keeps the empty mask; Escape again leaves the tool.
- await page.mouse.move(from[0], from[1]);
- await page.mouse.down();
- await page.mouse.move(to[0], to[1], { steps: 8 });
- await page.keyboard.press("Escape");
- await page.mouse.up();
- expect((await state()).scene?.layers).toHaveLength(2);
- await page.keyboard.press("Escape");
- await expect(canvas).toHaveCount(0);
- expect((await state()).scene?.layers).toHaveLength(1);
- expect((await state()).history).toMatchObject({
- undoCount: before,
- redoCount: 0,
- });
- // An adjustment before the first stroke belongs to the new mask and keeps it.
- await page.keyboard.press("b");
- await setField("Exposure", "1");
- expect(await samples(page)).toEqual(original);
- await drag(page, from, to, 16);
- expect((await samples(page))[0][0]).toBeGreaterThan(original[0][0] + 20);
- await page.keyboard.press("Enter");
- expect((await state()).scene?.layers).toHaveLength(2);
- for (let i = 0; i < 3; i++) {
- await page.keyboard.press("ControlOrMeta+z");
- }
- expect((await state()).scene?.layers).toHaveLength(1);
});
- await test.step("Subtract adds a brush inside the selected gradient", async () => {
+ await test.step("Subtract adds a brush inside a gradient, and erasing it restores the gradient", async () => {
await page.keyboard.press("l");
await drag(
page,
@@ -208,7 +116,7 @@ test("paint a brush mask, adjust it in the sidebar, erase, and undo", async ({
[center[0], center[1] + 200 * scale],
);
await setField("Exposure", "1");
- const lit = await samples(page);
+ const lit = await samples();
expect(lit[1][0]).toBeGreaterThan(original[1][0] + 20);
await page
.getByRole("button", { name: "Linear Gradient actions", exact: true })
@@ -217,82 +125,42 @@ test("paint a brush mask, adjust it in the sidebar, erase, and undo", async ({
.getByRole("menuitem", { name: "Subtract from mask", exact: true })
.click();
await page.getByRole("menuitem", { name: "Brush", exact: true }).click();
- await expect(
- page.getByRole("tab", { name: "Brush", exact: true }),
- ).toHaveAttribute("aria-selected", "true");
- await drag(
- page,
- [center[0], center[1] - 300 * scale],
- [center[0], center[1] - 300 * scale + 1],
- 2,
- );
- const layers = (await state()).scene?.layers;
- expect(layers?.[1].children).toHaveLength(1);
- expect(layers?.[1].children[0]).toMatchObject({
- kind: "mask",
- operation: "subtract",
- mask: { kind: "brush" },
- });
- expect((await samples(page))[1]).toEqual(original[1]);
- // The child row previews its own coverage, and erasing in it restores the gradient's.
- const thumbnails = page
- .getByRole("region", { name: "Layers", exact: true })
- .getByLabel("Mask thumbnail", { exact: true });
- await expect(thumbnails).toHaveCount(2);
- await expect
- .poll(() =>
- thumbnails.nth(1).evaluate((element) => {
- const context = (element as HTMLCanvasElement).getContext("2d");
- return context?.getImageData(32, 8, 1, 1).data[0] ?? 0;
- }),
- )
- .toBeGreaterThan(200);
+ const dot = [center[0], center[1] - 300 * scale];
+ await drag(page, dot, [dot[0], dot[1] + 1], 2);
+ expect((await state()).scene?.layers.at(-1)?.children).toMatchObject([
+ { operation: "subtract", mask: { kind: "brush" } },
+ ]);
+ expect((await samples())[1]).toEqual(original[1]);
await page.keyboard.down("Alt");
- await drag(
- page,
- [center[0], center[1] - 300 * scale],
- [center[0], center[1] - 300 * scale + 1],
- 2,
- );
+ await drag(page, dot, [dot[0], dot[1] + 1], 2);
await page.keyboard.up("Alt");
- expect((await samples(page))[1]).toEqual(lit[1]);
+ expect((await samples())[1]).toEqual(lit[1]);
});
- await test.step("Escape climbs from the child mask to its parent and the image; Enter on a button is its click", async () => {
- const initial = await state();
- const gradient = initial.scene?.layers[1];
- const child = gradient?.children[0];
- expect(initial.selectedLayerId).toBe(child?.id);
+ await test.step("Escape climbs from the child mask to its parent and the image", async () => {
+ const { selectedLayerId, scene } = await state();
+ const gradient = scene?.layers.at(-1);
+ expect(selectedLayerId).toBe(gradient?.children[0].id);
await page.keyboard.press("Escape");
- await expect(
- page.getByRole("tab", { name: "Adjust", exact: true }),
- ).toHaveAttribute("aria-selected", "true");
- expect((await state()).selectedLayerId).toBe(child?.id);
+ await expect(adjustTab).toHaveAttribute("aria-selected", "true");
await page.keyboard.press("Escape");
expect((await state()).selectedLayerId).toBe(gradient?.id);
- await overlayButton.click();
- await expect(overlayButton).toHaveAttribute("aria-pressed", "true");
- await overlayButton.press("Enter");
- await expect(overlayButton).toHaveAttribute("aria-pressed", "false");
- expect((await state()).selectedLayerId).toBe(gradient?.id);
await page.keyboard.press("Escape");
- expect((await state()).selectedLayerId).toBe(initial.scene?.layers[0].id);
- await expect(overlayButton).toHaveCount(0);
- await page.keyboard.press("Escape");
- expect((await state()).selectedLayerId).toBe(initial.scene?.layers[0].id);
+ expect((await state()).selectedLayerId).toBe(scene?.layers[0].id);
});
});
-test("a second finger during a touch stroke cancels it and pinches instead", async ({
- browser,
-}) => {
- const context = await browser.newContext({
+test.describe("on a touch phone", () => {
+ test.use({
viewport: { width: 390, height: 844 },
isMobile: true,
hasTouch: true,
deviceScaleFactor: 2,
});
- try {
- const page = await context.newPage();
+
+ test("a second finger during a touch stroke cancels it and pinches instead", async ({
+ page,
+ context,
+ }) => {
await page.goto("/");
await page
.locator('input[type="file"]')
@@ -301,45 +169,32 @@ test("a second finger during a touch stroke cancels it and pinches instead", asy
page.getByRole("slider", { name: "Exposure", exact: true }),
).toHaveAttribute("aria-valuetext", "0.00");
await page.getByRole("tab", { name: "Brush", exact: true }).click();
- const canvas = page.getByLabel("Brush canvas", { exact: true });
- await expect(canvas).toBeVisible();
+ const bounds = await box(page.getByLabel("Brush canvas", { exact: true }));
const zoom = page.getByRole("button", { name: /^\d+%$/ });
- const before = await zoom.textContent();
- const bounds = await box(canvas);
- const [cx, cy] = [
- bounds.x + bounds.width / 2,
- bounds.y + bounds.height / 2,
- ];
+ const fitted = await zoom.innerText();
+ const [x, y] = [bounds.x + bounds.width / 2, bounds.y + bounds.height / 2];
const touch = await context.newCDPSession(page);
const send = (
type: "touchStart" | "touchMove" | "touchEnd",
- points: number[][],
+ at: number[],
) =>
touch.send("Input.dispatchTouchEvent", {
type,
- touchPoints: points.map(([x, y]) => ({ x, y })),
+ touchPoints: at.map((dx) => ({ x: x + dx, y })),
});
- await send("touchStart", [[cx - 40, cy]]);
- await send("touchMove", [[cx - 20, cy + 10]]);
- await send("touchStart", [
- [cx - 20, cy + 10],
- [cx + 40, cy],
- ]);
+ await send("touchStart", [-40]);
+ await send("touchMove", [-20]);
+ await send("touchStart", [-20, 40]);
for (let step = 1; step <= 6; step++) {
- await send("touchMove", [
- [cx - 20 - step * 8, cy + 10 + step * 4],
- [cx + 40 + step * 8, cy - step * 4],
- ]);
+ await send("touchMove", [-20 - step * 8, 40 + step * 8]);
}
await send("touchEnd", []);
- await expect(zoom).not.toHaveText(before ?? "");
- const state = await page.evaluate(() => window.openlight.getState());
- const mask = state.scene?.layers[1];
+ await expect(zoom).not.toHaveText(fitted);
expect(
- mask?.kind === "mask" && mask.mask.kind === "brush" && mask.mask.strokes,
- ).toEqual([]);
- expect("editing" in state.history && state.history.editing).toBe(false);
- } finally {
- await context.close();
- }
+ await page.evaluate(() => window.openlight.getState()),
+ ).toMatchObject({
+ scene: { layers: [{}, { mask: { strokes: [] } }] },
+ history: { editing: false },
+ });
+ });
});
diff --git a/tests/brush.test.ts b/tests/brush.test.ts
index 1c91f68..faf5d58 100644
--- a/tests/brush.test.ts
+++ b/tests/brush.test.ts
@@ -83,183 +83,145 @@ test("a walk goes on where it stopped as a stroke grows, landing the dabs a whol
test("brush strokes stamp incrementally, replay after undo, and render a proxy during gestures", async () => {
const gpu = await init();
- const source = createImageSource(
- target(gpu, { size: [64, 32], format: "rgba16float" }),
- );
- const resources = createResources();
- const sourceId = resources.add(new File([], "photo.png"), source);
- const document = createDocument(
- {
- frame: imageFrame(source.image.size),
- layers: [{ ...createImageLayer(sourceId, "Photo"), id: "base" }],
- },
- resources,
- );
+ const image = target(gpu, { size: [64, 32], format: "rgba16float" });
+ const source = createImageSource(image);
+ const layers = [createImageLayer("photo", "Photo")] as const;
+ const document = createDocument({ frame: imageFrame(image.size), layers });
const renderer = createEditorRenderer(gpu, source);
const notify = mock(() => {});
renderer.subscribe(notify);
- const render = (interactive = false) =>
- renderer.update(document.scene.getState(), undefined, interactive);
- try {
- const mask = addLayer(document, createMask({ kind: "brush", strokes: [] }));
- setAdjustments(document, { exposure: 1 }, mask);
- await render();
- // An empty brush covers nothing, so the layer is bypassed without a raster.
- expect(renderer.inspect()).toMatchObject({
- passes: [],
- stamped: 0,
- rasters: [],
- });
- expect(document.history.status.getState().editing).toBe(false);
- expect(document.history.begin()).toBe(true);
- expect(document.history.status.getState().editing).toBe(true);
- paintStroke(document, mask, stroke);
- await render(true);
- expect(renderer.inspect()).toMatchObject({
- passes: [`layer/${mask}/exposure`, `layer/${mask}/raster`],
- stamped: 1,
- // The open stroke waits in the stroke buffer, and the mask reads it laid over its raster in the view.
- rasters: [
- { id: mask, size: [32, 16], format: "r8unorm" },
- { id: "stroke view", size: [32, 16], format: "r8unorm" },
- { id: "stroke buffer", size: [32, 16], format: "r16float" },
- ],
- });
- expect(renderer.coverage(mask)?.target.size).toEqual([32, 16]);
- // A 20 px extension adds twenty dabs; earlier ones are not stamped again.
- extendStroke(document, mask, [[30, 10, 1]]);
- await render(true);
- expect(renderer.inspect().stamped).toBe(21);
- expect(renderer.outputImage().size).toEqual([64, 32]);
- // The display scale sets the proxy: a quarter of a device pixel per source pixel means a quarter-size render.
- renderer.setDisplayScale(0.25);
- await render(true);
- expect(renderer.outputImage().size).toEqual([16, 8]);
- expect(renderer.inspect().stamped).toBe(21);
- document.history.commit();
- expect(document.history.status.getState().editing).toBe(false);
- await render();
- expect(renderer.outputImage().size).toEqual([64, 32]);
- const rendered = notify.mock.calls.length;
- await render();
- expect(notify).toHaveBeenCalledTimes(rendered);
- paintStroke(document, mask, { ...stroke, mode: "erase" });
- await render();
- expect(renderer.inspect().stamped).toBe(22);
- // Undo removes the last stroke, which rebuilds the raster from the remaining one.
- document.history.undo();
- await render();
- expect(renderer.inspect().stamped).toBe(43);
- const layer = findLayer(document.scene.getState().layers, mask);
- expect(layer?.kind === "mask" && layer.mask.kind === "brush").toBe(true);
- if (layer?.kind === "mask" && layer.mask.kind === "brush") {
- expect(layer.mask.strokes).toHaveLength(1);
- expect(layer.mask.strokes[0].points).toHaveLength(2);
- }
- document.history.undo();
- await render();
- expect(renderer.coverage(mask)).toBeUndefined();
- expect(
- renderer.inspect().rasters.some((raster) => raster.id === mask),
- ).toBe(true);
- document.history.redo();
- await render();
- expect(renderer.coverage(mask)).toBeDefined();
- // A brush subtracting from a gradient turns the whole mask into a raster.
- const gradient = addLayer(document, createMask(defaultGradient([64, 32])));
- setAdjustments(document, { exposure: -1 }, gradient);
- await render();
- expect(renderer.inspect().passes).toContain(`layer/${gradient}/mix`);
- // Inspecting the mask copies its curve input with coverage as alpha, even at zero opacity.
- await renderer.update(document.scene.getState(), gradient);
- expect(renderer.inputImage(gradient)).toBeDefined();
- expect(renderer.inspect().passes).toContain(`layer/${gradient}/input`);
- setLayer(document, gradient, { opacity: 0 });
- await renderer.update(document.scene.getState(), gradient);
- expect(renderer.inputImage(gradient)).toBeDefined();
- expect(renderer.inspect().passes).toEqual([
- `layer/${mask}/exposure`,
- `layer/${mask}/raster`,
- `layer/${gradient}/exposure`,
- `layer/${gradient}/input`,
- ]);
- setLayer(document, gradient, { opacity: 1 });
- const child = addLayer(
- document,
- createMask({ kind: "brush", strokes: [stroke] }, "subtract"),
- { inside: gradient },
- );
- await render();
- expect(renderer.inspect().passes).toContain(`layer/${gradient}/raster`);
- expect(renderer.inspect().passes).not.toContain(`layer/${gradient}/mix`);
- await renderer.update(document.scene.getState(), gradient);
- expect(renderer.inspect().passes).toContain(
- `layer/${gradient}/raster-input`,
- );
- // The child keeps its own coverage for its preview; the graph folds it into the gradient's.
- expect(renderer.inspect().rasters.map((raster) => raster.id)).toEqual([
- mask,
- child,
- "stroke view",
- "stroke buffer",
- ]);
- expect(renderer.inspect().passes).toEqual(
- expect.arrayContaining([
- `mask/${gradient}/gradient`,
- `mask/${child}/combine`,
- ]),
- );
- expect(renderer.coverage(child)?.target.size).toEqual([32, 16]);
- expect(renderer.coverage(gradient)?.target.size).toEqual([32, 16]);
- setLayer(document, child, { visible: false });
- await render();
- expect(renderer.coverage(child)?.target.size).toEqual([32, 16]);
- expect(renderer.inspect().passes).not.toContain(`mask/${child}/combine`);
- setLayer(document, child, { visible: true, opacity: 0 });
- await render();
- expect(renderer.coverage(child)?.target.size).toEqual([32, 16]);
- setLayerMask(document, child, { kind: "brush", strokes: [] });
- await render();
- expect(renderer.coverage(child)).toBeUndefined();
- document.history.undo();
- setLayer(document, child, { opacity: 1 });
- // Hiding a group bypasses its effect, but preserves the combined coverage shown in its row.
- setLayer(document, gradient, { visible: false });
- await render();
- expect(renderer.coverage(gradient)?.target.size).toEqual([32, 16]);
- expect(renderer.inspect().passes).toContain(`mask/${child}/combine`);
- expect(renderer.inspect().passes).not.toContain(`layer/${gradient}/raster`);
- setLayer(document, gradient, { visible: true });
- // Erasing inside the child stamps its own raster only, and the group recombines.
- const stampedBefore = renderer.inspect().stamped;
- paintStroke(document, child, { ...stroke, mode: "erase" });
- await render();
- expect(renderer.inspect().stamped).toBe(stampedBefore + 1);
- deleteLayer(document, child);
- deleteLayer(document, mask);
- await render();
- expect(renderer.inspect().rasters).toEqual([]);
- expect(renderer.inspect().passes).toContain(`layer/${gradient}/mix`);
- for (const invalid of [
- { ...stroke, size: 0 },
- { ...stroke, feather: 2 },
- { ...stroke, flow: -1 },
- { ...stroke, mode: "smudge" as BrushStroke["mode"] },
- { ...stroke, points: [] },
- { ...stroke, points: [[1, 2, 3]] as BrushStroke["points"] },
- ]) {
- expect(() =>
- setLayerMask(document, gradient, { kind: "brush", strokes: [invalid] }),
- ).toThrow();
- }
- expect(() => extendStroke(document, gradient, [[1, 1, 1]])).toThrow(
- "brush",
- );
- } finally {
- renderer.dispose();
- document.dispose();
- gpu.dispose();
- }
+ const render = (inputId?: string, interactive = false) =>
+ renderer.update(document.scene.getState(), inputId, interactive);
+ const inspect = () => renderer.inspect();
+ const mask = addLayer(document, createMask({ kind: "brush", strokes: [] }));
+ setAdjustments(document, { exposure: 1 }, mask);
+ await render();
+ // An empty brush covers nothing, so the layer is bypassed without a raster.
+ expect(inspect()).toMatchObject({ passes: [], stamped: 0, rasters: [] });
+ document.history.begin();
+ paintStroke(document, mask, stroke);
+ await render(undefined, true);
+ expect(inspect()).toMatchObject({
+ passes: [`layer/${mask}/exposure`, `layer/${mask}/raster`],
+ stamped: 1,
+ // The open stroke waits in the stroke buffer, and the mask reads it laid over its raster in the view.
+ rasters: [
+ { id: mask, size: [32, 16], format: "r8unorm" },
+ { id: "stroke view", size: [32, 16], format: "r8unorm" },
+ { id: "stroke buffer", size: [32, 16], format: "r16float" },
+ ],
+ });
+ expect(renderer.coverage(mask)?.target.size).toEqual([32, 16]);
+ // A 20 px extension adds twenty dabs; earlier ones are not stamped again.
+ extendStroke(document, mask, [[30, 10, 1]]);
+ await render(undefined, true);
+ expect(inspect().stamped).toBe(21);
+ // A quarter of a device pixel per source pixel means a quarter-size render.
+ renderer.setDisplayScale(0.25);
+ await render(undefined, true);
+ expect(renderer.outputImage().size).toEqual([16, 8]);
+ expect(inspect().stamped).toBe(21);
+ document.history.commit();
+ await render();
+ const rendered = notify.mock.calls.length;
+ await render();
+ expect(notify).toHaveBeenCalledTimes(rendered);
+ paintStroke(document, mask, { ...stroke, mode: "erase" });
+ await render();
+ expect(inspect().stamped).toBe(22);
+ // Undo removes the last stroke, which rebuilds the raster from the remaining one.
+ document.history.undo();
+ await render();
+ expect(inspect().stamped).toBe(43);
+ expect(findLayer(document.scene.getState().layers, mask)).toMatchObject({
+ mask: { strokes: [{ points: [stroke.points[0], [30, 10, 1]] }] },
+ });
+ document.history.undo();
+ await render();
+ expect(renderer.coverage(mask)).toBeUndefined();
+ expect(renderer.inspect().rasters.some((raster) => raster.id === mask)).toBe(
+ true,
+ );
+ document.history.redo();
+ await render();
+ expect(renderer.coverage(mask)).toBeDefined();
+ const gradient = addLayer(document, createMask(defaultGradient([64, 32])));
+ setAdjustments(document, { exposure: -1 }, gradient);
+ // Inspecting the mask copies its curve input with coverage as alpha, even at zero opacity.
+ setLayer(document, gradient, { opacity: 0 });
+ await render(gradient);
+ expect(renderer.inputImage(gradient)).toBeDefined();
+ expect(inspect().passes).toEqual([
+ `layer/${mask}/exposure`,
+ `layer/${mask}/raster`,
+ `layer/${gradient}/exposure`,
+ `layer/${gradient}/input`,
+ ]);
+ setLayer(document, gradient, { opacity: 1 });
+ // A brush subtracting from a gradient turns the whole mask into a raster.
+ const child = addLayer(
+ document,
+ createMask({ kind: "brush", strokes: [stroke] }, "subtract"),
+ { inside: gradient },
+ );
+ await render();
+ expect(inspect().passes).toContain(`layer/${gradient}/raster`);
+ expect(inspect().passes).not.toContain(`layer/${gradient}/mix`);
+ await render(gradient);
+ expect(inspect().passes).toContain(`layer/${gradient}/raster-input`);
+ // The child keeps its own coverage for its preview; the graph folds it into the gradient's.
+ expect(renderer.inspect().rasters.map((raster) => raster.id)).toEqual([
+ mask,
+ child,
+ "stroke view",
+ "stroke buffer",
+ ]);
+ expect(renderer.inspect().passes).toEqual(
+ expect.arrayContaining([
+ `mask/${gradient}/gradient`,
+ `mask/${child}/combine`,
+ ]),
+ );
+ expect(renderer.coverage(child)?.target.size).toEqual([32, 16]);
+ expect(renderer.coverage(gradient)?.target.size).toEqual([32, 16]);
+ setLayer(document, child, { visible: false });
+ await render();
+ expect(renderer.coverage(child)?.target.size).toEqual([32, 16]);
+ expect(renderer.inspect().passes).not.toContain(`mask/${child}/combine`);
+ setLayer(document, child, { visible: true, opacity: 0 });
+ await render();
+ expect(renderer.coverage(child)?.target.size).toEqual([32, 16]);
+ setLayerMask(document, child, { kind: "brush", strokes: [] });
+ await render();
+ expect(renderer.coverage(child)).toBeUndefined();
+ document.history.undo();
+ setLayer(document, child, { opacity: 1 });
+ // Hiding a group bypasses its effect, but preserves the combined coverage shown in its row.
+ setLayer(document, gradient, { visible: false });
+ await render();
+ expect(renderer.coverage(gradient)?.target.size).toEqual([32, 16]);
+ expect(renderer.inspect().passes).toContain(`mask/${child}/combine`);
+ expect(renderer.inspect().passes).not.toContain(`layer/${gradient}/raster`);
+ setLayer(document, gradient, { visible: true });
+ // Erasing inside the child stamps its own raster only, and the group recombines.
+ const stamped = inspect().stamped;
+ paintStroke(document, child, { ...stroke, mode: "erase" });
+ await render();
+ expect(inspect().stamped).toBe(stamped + 1);
+ deleteLayer(document, child);
+ deleteLayer(document, mask);
+ await render();
+ expect(inspect().rasters).toEqual([]);
+ expect(inspect().passes).toContain(`layer/${gradient}/mix`);
+ const invalid = { ...stroke, flow: 2 };
+ expect(() =>
+ setLayerMask(document, gradient, { kind: "brush", strokes: [invalid] }),
+ ).toThrow();
+ expect(() => extendStroke(document, gradient, [[1, 1, 1]])).toThrow("brush");
+ renderer.dispose();
+ document.dispose();
+ source.dispose();
+ gpu.dispose();
});
test("a brush yet to paint takes no part in its group", async () => {
diff --git a/tests/clarity.e2e.ts b/tests/clarity.e2e.ts
index 3d91a93..f43c31a 100644
--- a/tests/clarity.e2e.ts
+++ b/tests/clarity.e2e.ts
@@ -1,22 +1,16 @@
import { expect, test } from "./fixtures";
// Full-resolution Gaussian reference, independent of GPU passes and working-space conversion.
-function expectedStep(
- x: number,
- left: number,
- right: number,
- amount: number,
- sigma: number,
-) {
+function expectedStep(x: number, amount: number, sigma: number) {
let sum = 0;
let weights = 0;
const radius = Math.ceil(3 * sigma);
for (let offset = -radius; offset <= radius; offset++) {
const weight = Math.exp(-0.5 * (offset / sigma) ** 2);
- sum += (x + offset < 512 ? left : right) * weight;
+ sum += (x + offset < 512 ? 64 : 192) * weight;
weights += weight;
}
- const original = x < 512 ? left : right;
+ const original = x < 512 ? 64 : 192;
return Math.max(
0,
Math.min(255, original + amount * (original - sum / weights)),
@@ -28,128 +22,93 @@ test("detail filters follow Gaussian unsharp masking and preserve flat fields an
}) => {
await page.goto("/");
await page.waitForFunction(() => window.openlight);
- const xs = [
- 0, 256, 384, 448, 504, 509, 510, 511, 512, 513, 514, 519, 576, 640, 768,
- 1023,
+ const xs = [0, 384, 448, 504, 509, 510, 511, 512, 513, 514, 519, 576, 640];
+ const settings = [
+ { clarity: -100, sharpening: 0, sharpenRadius: 1 },
+ { clarity: 100, sharpening: 0, sharpenRadius: 1 },
+ { clarity: 0, sharpening: 150, sharpenRadius: 0.5 },
+ { clarity: 0, sharpening: 50, sharpenRadius: 1.7 },
+ { clarity: 0, sharpening: 100, sharpenRadius: 3 },
];
- const result = await page.evaluate(async (xs) => {
- const api = window.openlight;
- const load = async (width: number, height: number, shapes: string) => {
- await api.loadImage(
- new File(
- [
- `<svg xmlns="http://www.w3.org/2000/svg" width="${width}" height="${height}">${shapes}</svg>`,
- ],
- "probe.svg",
- { type: "image/svg+xml" },
- ),
- );
- };
- const read = async (positions: number[][]) => {
- const image = await createImageBitmap(await api.exportImage());
- const canvas = new OffscreenCanvas(image.width, image.height);
- const context = canvas.getContext("2d");
- if (!context) throw new Error("Cannot read clarity probe.");
- context.drawImage(image, 0, 0);
- image.close();
- return positions.map(([x, y]) => [
- ...context.getImageData(x, y, 1, 1).data,
- ]);
- };
- const steps = [];
- for (const [left, right] of [
- [64, 192],
- [0, 128],
- ]) {
+ const result = await page.evaluate(
+ async ({ xs, settings }) => {
+ const api = window.openlight;
+ const load = (width: number, height: number, shapes: string) =>
+ api.loadImage(
+ new File(
+ [
+ `<svg xmlns="http://www.w3.org/2000/svg" width="${width}" height="${height}">${shapes}</svg>`,
+ ],
+ "probe.svg",
+ { type: "image/svg+xml" },
+ ),
+ );
+ const read = async (positions: number[][]) => {
+ const image = await createImageBitmap(await api.exportImage());
+ const canvas = new OffscreenCanvas(image.width, image.height);
+ const context = canvas.getContext("2d");
+ if (!context) throw new Error("Cannot read clarity probe.");
+ context.drawImage(image, 0, 0);
+ image.close();
+ return positions.map(([x, y]) => [
+ ...context.getImageData(x, y, 1, 1).data,
+ ]);
+ };
await load(
1024,
129,
- [left, right]
- .map(
- (value, i) =>
- `<rect x="${i * 512}" width="512" height="129" fill="rgb(${value},${value},${value})"/>`,
- )
- .join(""),
+ '<rect width="512" height="129" fill="rgb(64,64,64)"/><rect x="512" width="512" height="129" fill="rgb(192,192,192)"/>',
);
- const settings = [
- ...[-100, -50, 0, 50, 100].map((clarity) => ({
- clarity,
- sharpening: 0,
- sharpenRadius: 1,
- })),
- ...[0.5, 1, 1.7, 3].flatMap((sharpenRadius) =>
- [0, 50, 100, 150].map((sharpening) => ({
- clarity: 0,
- sharpening,
- sharpenRadius,
- })),
- ),
- ];
+ const steps = [];
for (const adjustment of settings) {
api.setDetails(adjustment);
- steps.push({
- left,
- right,
- amount: adjustment.sharpening
- ? adjustment.sharpening / 50
- : adjustment.clarity / 200,
- sigma: adjustment.sharpening ? adjustment.sharpenRadius : 64,
- pixels: await read(xs.map((x) => [x, 64])),
- });
+ steps.push(await read(xs.map((x) => [x, 64])));
}
- }
- await load(127, 65, '<rect width="127" height="65" fill="#737373"/>');
- const flat = [];
- for (const clarity of [-100, 0, 100]) {
- api.setDetails({ clarity, sharpening: 150, sharpenRadius: 3 });
- flat.push(
- ...(await read([
- [0, 0],
- [63, 32],
- [126, 64],
- ])),
+ // An opaque half beside a translucent half of the same color, then transparency.
+ await load(
+ 127,
+ 65,
+ '<rect width="40" height="65" fill="#737373"/><rect x="40" width="40" height="65" fill="#737373" fill-opacity="0.5"/>',
);
- }
- await load(
- 127,
- 65,
- '<rect width="64" height="65" fill="#737373" fill-opacity="0.5"/>',
- );
- const positions = [
- [10, 32],
- [63, 32],
- [64, 32],
- [126, 64],
- ];
- const neutral = await read(positions);
- const alpha = [];
- for (const clarity of [-100, 100]) {
- api.setDetails({ clarity, sharpening: 150, sharpenRadius: 3 });
- alpha.push(await read(positions));
- }
- return { steps, flat, neutral, alpha };
- }, xs);
- for (const { left, right, amount, sigma, pixels } of result.steps) {
+ const positions = [
+ [10, 32],
+ [39, 32],
+ [40, 32],
+ [79, 32],
+ [80, 32],
+ [126, 64],
+ ];
+ const neutral = await read(positions);
+ const filtered = [];
+ for (const clarity of [-100, 100]) {
+ api.setDetails({ clarity, sharpening: 150, sharpenRadius: 3 });
+ filtered.push(await read(positions));
+ }
+ return { steps, neutral, filtered };
+ },
+ { xs, settings },
+ );
+ for (const [s, pixels] of result.steps.entries()) {
+ const { clarity, sharpening, sharpenRadius } = settings[s];
+ const amount = sharpening ? sharpening / 50 : clarity / 200;
+ const sigma = sharpening ? sharpenRadius : 64;
for (const [i, pixel] of pixels.entries()) {
- for (const channel of pixel.slice(0, 3))
- expect(
- Math.abs(channel - expectedStep(xs[i], left, right, amount, sigma)),
- ).toBeLessThanOrEqual(2);
+ for (const channel of pixel.slice(0, 3)) {
+ const expected = expectedStep(xs[i], amount, sigma);
+ expect(Math.abs(channel - expected)).toBeLessThanOrEqual(2);
+ }
expect(pixel[3]).toBe(255);
}
}
- for (const pixel of result.flat) {
- for (const channel of pixel.slice(0, 3))
- expect(Math.abs(channel - 115)).toBeLessThanOrEqual(1);
- expect(pixel[3]).toBe(255);
- }
- for (const pixels of result.alpha) {
+ expect(result.neutral[0]).toEqual([115, 115, 115, 255]);
+ for (const pixels of result.filtered) {
for (const [i, pixel] of pixels.entries()) {
expect(pixel[3]).toBe(result.neutral[i][3]);
- for (const [channel, value] of pixel.entries())
+ for (const [channel, value] of pixel.entries()) {
expect(
Math.abs(value - result.neutral[i][channel]),
).toBeLessThanOrEqual(2);
+ }
}
}
});
diff --git a/tests/color-mixer-editing.ts b/tests/color-mixer-editing.ts
deleted file mode 100644
index 3155fa9..0000000
--- a/tests/color-mixer-editing.ts
+++ /dev/null
@@ -1,87 +0,0 @@
-import type { Locator, Page } from "@playwright/test";
-import { expect, test } from "./fixtures";
-import { box, drag } from "./pointer";
-
-export async function colorMixerEditing(page: Page) {
- const state = () => page.evaluate(() => window.openlight.getState());
- // Base UI keeps a slider's range input inside its thumb, on the bar a person drags.
- const bar = (slider: Locator) =>
- slider.locator('xpath=ancestor::*[@data-slot="slider-track"]');
- await test.step("color mixer switches channels, groups vertical drags, exports selected colors and resets", async () => {
- await page.getByRole("button", { name: "Add effect", exact: true }).click();
- await page
- .getByRole("menuitem", { name: "Color Mixer", exact: true })
- .click();
- const before = (await state()).history.undoCount;
- const hue = page.getByRole("slider", { name: "Blue hue", exact: true });
- await hue.scrollIntoViewIfNeeded();
- await expect(hue).toHaveAttribute("aria-orientation", "vertical");
- const bounds = await box(bar(hue));
- expect(bounds.height).toBeGreaterThan(bounds.width * 3);
- await hue.press("ArrowUp");
- await expect(hue).toHaveValue("1");
- expect((await state()).history.undoCount).toBe(before + 1);
- await page.keyboard.press("ControlOrMeta+z");
- await expect(hue).toHaveValue("0");
- const beforeTabs = await state();
- await page
- .getByRole("tab", { name: "Hue", exact: true })
- .press("ArrowRight");
- await expect(
- page.getByRole("tab", { name: "Saturation", exact: true }),
- ).toHaveAttribute("aria-selected", "true");
- expect(await state()).toEqual(beforeTabs);
- const saturation = page.getByRole("slider", {
- name: "Blue saturation",
- exact: true,
- });
- const track = await box(bar(saturation));
- await drag(
- page,
- [track.x + track.width / 2, track.y + track.height / 2],
- [track.x + track.width / 2, track.y + track.height / 4],
- );
- const dragged = (await state()).colorMixer.saturation[5];
- expect(dragged).toBeGreaterThan(0);
- expect((await state()).history.undoCount).toBe(before + 1);
- await page.keyboard.press("ControlOrMeta+z");
- await expect(saturation).toHaveValue("0");
- await page.keyboard.press("ControlOrMeta+Shift+z");
- await expect(saturation).toHaveValue(String(dragged));
- const numeric = page.getByRole("textbox", {
- name: "Blue saturation value",
- exact: true,
- });
- await numeric.fill("-100");
- await numeric.press("Enter");
- await expect(saturation).toHaveValue("-100");
- const pixel = await page.evaluate(async () => {
- const bitmap = await createImageBitmap(
- await window.openlight.exportImage(),
- );
- const canvas = new OffscreenCanvas(bitmap.width, bitmap.height);
- const context = canvas.getContext("2d");
- if (!context) throw new Error("Cannot read color mixer export.");
- context.drawImage(bitmap, 0, 0);
- bitmap.close();
- return [...context.getImageData(350, 200, 1, 1).data];
- });
- for (const channel of pixel.slice(0, 3)) {
- expect(Math.abs(channel - 79)).toBeLessThanOrEqual(2);
- }
- expect(pixel[3]).toBe(255);
- await page.getByRole("tab", { name: "Luminance", exact: true }).click();
- await expect(
- page.getByRole("slider", { name: "Blue luminance", exact: true }),
- ).toHaveValue("0");
- await page.getByRole("tab", { name: "Saturation", exact: true }).click();
- await expect(saturation).toHaveValue("-100");
- await saturation.locator("..").dblclick();
- await expect(saturation).toHaveValue("0");
- await page.keyboard.press("ControlOrMeta+z");
- await expect(saturation).toHaveValue("-100");
- await page.keyboard.press("ControlOrMeta+Shift+z");
- await expect(saturation).toHaveValue("0");
- });
- await page.getByRole("button", { name: "photo.svg", exact: true }).click();
-}
diff --git a/tests/color-mixer-gpu.ts b/tests/color-mixer-gpu.ts
index 4b8f688..ab64e63 100644
--- a/tests/color-mixer-gpu.ts
+++ b/tests/color-mixer-gpu.ts
@@ -68,17 +68,14 @@ export async function probeColorMixer() {
{ set: { samples: data } },
);
const graph = createRenderGraph(gpu);
- const uniform = (channel: keyof ColorMixer, value: number): ColorMixer => ({
- ...defaultMixer,
- [channel]: colors.map(() => value),
- });
- const selected = (
- index: number,
+ /** Sets one channel of every color, or only of the color at `index`. */
+ const mix = (
channel: keyof ColorMixer,
value: number,
+ index?: number,
): ColorMixer => ({
...defaultMixer,
- [channel]: colors.map((_, i) => (i === index ? value : 0)),
+ [channel]: colors.map((_, i) => ((index ?? i) === i ? value : 0)),
});
try {
frame(gpu, (f) => f.pass(input, fill));
@@ -87,16 +84,14 @@ export async function probeColorMixer() {
const outputs = [];
for (const settings of [
defaultMixer,
- uniform("hue", 100),
- uniform("hue", -100),
- uniform("saturation", -100),
- uniform("luminance", 100),
- uniform("luminance", -100),
- selected(5, "saturation", -100),
- selected(0, "hue", 100),
+ mix("hue", 100),
+ mix("saturation", -100),
+ mix("luminance", 100),
+ mix("saturation", -100, 5),
+ mix("hue", 100, 0),
]) {
const [output] = graph.render([
- pipeline(inputNode(input), [colorMixer(settings)]),
+ pipeline(inputNode(input), [colorMixer(settings, "color-mixer")]),
]);
outputs.push([...(await output.readFloats())]);
}
diff --git a/tests/color-mixer.e2e.ts b/tests/color-mixer.e2e.ts
index f79dbcc..6b36e62 100644
--- a/tests/color-mixer.e2e.ts
+++ b/tests/color-mixer.e2e.ts
@@ -1,9 +1,17 @@
-import { expect, test } from "./fixtures";
+import { expect, openPhoto, test } from "./fixtures";
+import { readImage } from "./images";
+import { box, drag } from "./pointer";
function luminance(rgb: number[]) {
return rgb[0] * 0.2627 + rgb[1] * 0.678 + rgb[2] * 0.0593;
}
+function expectClose(actual: number[], expected: number[], tolerance = 0.003) {
+ for (const [i, value] of expected.entries()) {
+ expect(Math.abs(actual[i] - value)).toBeLessThan(tolerance);
+ }
+}
+
test("color mixing preserves luminance, neutrals, alpha and HDR, isolates ranges and joins the hue seam", async ({
page,
}) => {
@@ -15,57 +23,84 @@ test("color mixing preserves luminance, neutrals, alpha and HDR, isolates ranges
)) as typeof import("./color-mixer-gpu");
return probeColorMixer();
});
- const [neutral, hueUp, hueDown, gray, lighter, darker, blue, red] = outputs;
+ const rgb = (output: number[], index: number) =>
+ output.slice(index * 4, index * 4 + 3);
+ const alpha = (output: number[]) => output.filter((_, i) => i % 4 === 3);
+ const [neutral, hue, gray, lighter, blue, red] = outputs;
expect(neutral).toEqual(original);
for (const output of outputs) {
expect(output.every(Number.isFinite)).toBe(true);
- for (let i = 3; i < output.length; i += 4) {
- expect(output[i]).toBe(original[i]);
- }
- for (const index of [8, 9, 10]) {
- expect(output.slice(index * 4, index * 4 + 4)).toEqual(
- original.slice(index * 4, index * 4 + 4),
- );
- }
+ expect(alpha(output)).toEqual(alpha(original));
+ // Transparent black, mid gray, and HDR white have no color to mix.
+ expect(output.slice(32, 44)).toEqual(original.slice(32, 44));
}
for (let index = 0; index < sampleCount; index++) {
- const input = original.slice(index * 4, index * 4 + 3);
- const light = luminance(input);
- for (const output of [hueUp, hueDown, gray]) {
- expect(
- Math.abs(luminance(output.slice(index * 4, index * 4 + 3)) - light),
- ).toBeLessThan(0.003);
- }
if (index >= 8 && index <= 10) continue;
- for (let channel = 0; channel < 3; channel++) {
- expect(Math.abs(gray[index * 4 + channel] - light)).toBeLessThan(0.003);
- expect(
- Math.abs(lighter[index * 4 + channel] - input[channel] * 2),
- ).toBeLessThan(0.006);
- expect(
- Math.abs(darker[index * 4 + channel] - input[channel] / 2),
- ).toBeLessThan(0.003);
- }
+ const input = rgb(original, index);
+ const light = luminance(input);
+ expect(Math.abs(luminance(rgb(hue, index)) - light)).toBeLessThan(0.003);
+ expectClose(rgb(gray, index), [light, light, light]);
+ expectClose(
+ rgb(lighter, index),
+ input.map((value) => value * 2),
+ 0.006,
+ );
}
for (const index of [0, 1, 2, 3, 4, 7]) {
- for (let channel = 0; channel < 3; channel++) {
- expect(
- Math.abs(blue[index * 4 + channel] - original[index * 4 + channel]),
- ).toBeLessThan(0.003);
- }
- }
- const blueLight = luminance(original.slice(20, 23));
- for (const channel of blue.slice(20, 23)) {
- expect(Math.abs(channel - blueLight)).toBeLessThan(0.003);
+ expectClose(rgb(blue, index), rgb(original, index));
}
- expect(Math.max(...lighter.slice(44, 47))).toBeGreaterThan(4);
- expect(hueUp[1]).toBeGreaterThan(original[1]);
- expect(hueDown[2]).toBeGreaterThan(original[2]);
+ const blueLight = luminance(rgb(original, 5));
+ expectClose(rgb(blue, 5), [blueLight, blueLight, blueLight]);
+ expect(Math.max(...rgb(lighter, 11))).toBeGreaterThan(4);
+ expect(hue[1]).toBeGreaterThan(original[1]);
for (let i = 0; i < 360; i++) {
- for (let channel = 0; channel < 3; channel++) {
- const a = red[(sampleCount + i) * 4 + channel];
- const b = red[(sampleCount + ((i + 1) % 360)) * 4 + channel];
- expect(Math.abs(a - b)).toBeLessThan(0.035);
- }
+ const next = sampleCount + ((i + 1) % 360);
+ expectClose(rgb(red, sampleCount + i), rgb(red, next), 0.035);
+ }
+});
+
+test("color mixer drags a vertical slider as one step, exports the selected color, and resets", async ({
+ page,
+}) => {
+ const state = () => page.evaluate(() => window.openlight.getState());
+ await openPhoto(page);
+ await page.getByRole("button", { name: "Add effect", exact: true }).click();
+ await page
+ .getByRole("menuitem", { name: "Color Mixer", exact: true })
+ .click();
+ const before = (await state()).history.undoCount;
+ await page.getByRole("tab", { name: "Saturation", exact: true }).click();
+ const saturation = page.getByRole("slider", {
+ name: "Blue saturation",
+ exact: true,
+ });
+ await saturation.scrollIntoViewIfNeeded();
+ // Base UI keeps a slider's range input inside its thumb, on the bar a person drags.
+ const track = await box(
+ saturation.locator('xpath=ancestor::*[@data-slot="slider-track"]'),
+ );
+ const x = track.x + track.width / 2;
+ await drag(
+ page,
+ [x, track.y + track.height / 2],
+ [x, track.y + track.height / 4],
+ );
+ expect((await state()).colorMixer.saturation[5]).toBeGreaterThan(0);
+ expect((await state()).history.undoCount).toBe(before + 1);
+ const numeric = page.getByRole("textbox", {
+ name: "Blue saturation value",
+ exact: true,
+ });
+ await numeric.fill("-100");
+ await numeric.press("Enter");
+ const { samples } = await readImage(page, undefined, [[350, 200]]);
+ const pixel = samples?.[0] ?? [];
+ expect(pixel).toHaveLength(4);
+ for (const channel of pixel.slice(0, 3)) {
+ expect(Math.abs(channel - 79)).toBeLessThanOrEqual(2);
}
+ await saturation.locator("..").dblclick();
+ await expect(saturation).toHaveValue("0");
+ await page.keyboard.press("ControlOrMeta+z");
+ await expect(saturation).toHaveValue("-100");
});
diff --git a/tests/color-mixer.test.ts b/tests/color-mixer.test.ts
index 6dacb51..f43b50c 100644
--- a/tests/color-mixer.test.ts
+++ b/tests/color-mixer.test.ts
@@ -1,5 +1,5 @@
import { expect, test } from "bun:test";
-import { getMockGPUDeviceInstrumentation, init, target } from "vgpu/mock";
+import { init, target } from "vgpu/mock";
import { createImageLayer, createLayer } from "@/app/editor/layers";
import { createEditorRenderer } from "@/app/editor/renderer";
import { createDocument } from "@/core/document";
@@ -8,91 +8,53 @@ import { imageFrame } from "@/core/image/frame";
import { resetColorMixer, setColorMixer } from "@/features/color-mixer/edits";
import { defaultMixer } from "@/features/color-mixer/model";
-test("color edits validate, group, cancel and reset while renderers reuse and release their outputs", async () => {
+test("color edits validate, skip no-ops, and reset, and a neutral mixer renders no pass", async () => {
const gpu = await init();
const image = target(gpu, { size: [32, 16], format: "rgba16float" });
const source = createImageSource(image);
- const document = createDocument({
- frame: imageFrame(image.size),
- layers: [
- {
- ...createImageLayer("photo", "Photo"),
- id: "base",
- children: [{ ...createLayer("color-mixer"), id: "mixer" }],
- },
- ],
- });
+ const mixer = { ...createLayer("color-mixer"), id: "mixer" };
+ const photo = { ...createImageLayer("photo", "Photo"), children: [mixer] };
+ const frame = imageFrame(image.size);
+ const document = createDocument({ frame, layers: [photo] });
const renderer = createEditorRenderer(gpu, source);
- try {
- await renderer.update(document.scene.getState());
- setColorMixer(document, "blue", { hue: 0 }, "mixer");
- resetColorMixer(document, "mixer");
- expect(document.history.status.getState().undoCount).toBe(0);
- document.history.begin();
- setColorMixer(document, "blue", { hue: 10 }, "mixer");
- setColorMixer(document, "blue", { hue: 25, saturation: -20 }, "mixer");
- document.history.commit();
- expect(document.history.status.getState().undoCount).toBe(1);
- const scene = document.scene.getState();
- const mixer = scene.layers[0].children[0];
- expect(mixer?.kind === "color-mixer" && mixer.colorMixer.hue[5]).toBe(25);
- expect(
- mixer?.kind === "color-mixer" && mixer.colorMixer.saturation[5],
- ).toBe(-20);
- await renderer.update(scene);
- expect(renderer.inspect().passes).toEqual(["layer/mixer/color-mixer"]);
- const edited = renderer.outputImage();
- expect(edited.format).toBe("rgba16float");
- const calls = getMockGPUDeviceInstrumentation(gpu.gpu).calls;
- const pipelines = calls.createRenderPipeline;
- setColorMixer(document, "blue", { hue: 25 }, "mixer");
- expect(document.history.status.getState().undoCount).toBe(1);
- document.history.begin();
- setColorMixer(document, "red", { luminance: 100 }, "mixer");
- document.history.cancel();
- expect(document.scene.getState()).toEqual(scene);
- document.history.undo();
- await renderer.update(document.scene.getState());
- expect(renderer.inspect().passes).toEqual([]);
- document.history.redo();
+ const undoCount = () => document.history.status.getState().undoCount;
+ const passes = async () => {
await renderer.update(document.scene.getState());
- expect(renderer.inspect().passes).toEqual(["layer/mixer/color-mixer"]);
- expect(calls.createRenderPipeline).toBe(pipelines);
- for (const value of [NaN, Infinity, -101, 101]) {
- expect(() =>
- setColorMixer(document, "red", { hue: value }, "mixer"),
- ).toThrow("Invalid");
- }
- expect(() =>
- Reflect.apply(setColorMixer, undefined, [
- document,
- "pink",
- { hue: 2 },
- "mixer",
- ]),
- ).toThrow("Invalid");
- expect(() =>
- Reflect.apply(setColorMixer, undefined, [
- document,
- "red",
- { contrast: 2 },
- "mixer",
- ]),
- ).toThrow("Invalid");
- expect(document.scene.getState()).toEqual(scene);
- resetColorMixer(document, "mixer");
- expect(document.scene.getState().layers[0].children[0]).toMatchObject({
- colorMixer: defaultMixer,
- });
- document.history.undo();
- expect(document.scene.getState()).toEqual(scene);
- renderer.dispose();
- expect(() => edited.color.view).toThrow("destroyed");
- expect(() => image.color.view).not.toThrow();
- } finally {
- renderer.dispose();
- document.dispose();
- source.dispose();
- gpu.dispose();
+ return renderer.inspect().passes;
+ };
+ expect(await passes()).toEqual([]);
+ setColorMixer(document, "blue", { hue: 0 }, "mixer");
+ resetColorMixer(document, "mixer");
+ expect(undoCount()).toBe(0);
+ setColorMixer(document, "blue", { hue: 25, saturation: -20 }, "mixer");
+ const scene = document.scene.getState();
+ // Blue is the sixth range.
+ expect(scene.layers[0].children[0]).toMatchObject({
+ colorMixer: { hue: { 5: 25 }, saturation: { 5: -20 } },
+ });
+ expect(await passes()).toEqual(["layer/mixer/color-mixer"]);
+ setColorMixer(document, "blue", { hue: 25 }, "mixer");
+ expect(undoCount()).toBe(1);
+ for (const [color, change] of [
+ ["red", { hue: 101 }],
+ ["pink", { hue: 2 }],
+ ["red", { contrast: 2 }],
+ ]) {
+ const edit = [document, color, change, "mixer"];
+ expect(() => Reflect.apply(setColorMixer, undefined, edit)).toThrow(
+ "Invalid",
+ );
}
+ expect(document.scene.getState()).toBe(scene);
+ resetColorMixer(document, "mixer");
+ expect(document.scene.getState().layers[0].children[0]).toMatchObject({
+ colorMixer: defaultMixer,
+ });
+ expect(await passes()).toEqual([]);
+ document.history.undo();
+ expect(document.scene.getState()).toEqual(scene);
+ renderer.dispose();
+ document.dispose();
+ source.dispose();
+ gpu.dispose();
});
diff --git a/tests/commands.test.ts b/tests/commands.test.ts
index bf71f5e..573389f 100644
--- a/tests/commands.test.ts
+++ b/tests/commands.test.ts
@@ -15,21 +15,16 @@ import { imageFrame } from "@/core/image/frame";
test("commands validate their input, return the layer they edit, and reset as one edit", async () => {
const gpu = await init();
- const source = createImageSource(
- target(gpu, { size: [32, 16], format: "rgba16float" }),
- );
const resources = createResources();
- const sourceId = resources.add(new File([], "photo.png"), source);
- const document = createDocument(
- {
- frame: imageFrame(source.image.size),
- layers: [{ ...createImageLayer(sourceId, "Photo"), id: "base" }],
- },
- resources,
- );
+ const image = target(gpu, { size: [32, 16], format: "rgba16float" });
+ const file = new File([], "photo.png");
+ const source = resources.add(file, createImageSource(image));
+ const base = { ...createImageLayer(source, "Photo"), id: "base" };
+ const frame = imageFrame(image.size);
+ const document = createDocument({ frame, layers: [base] }, resources);
const workspace = createWorkspace();
await workspace.open("photo.png", async () => document);
- const { run } = createControls(gpu, workspace);
+ const { run, setVignette } = createControls(gpu, workspace);
const opened = document.scene.getState();
const undoCount = () => document.history.status.getState().undoCount;
@@ -39,22 +34,18 @@ test("commands validate their input, return the layer they edit, and reset as on
expect(() => run({ type: "set-vignette", intensity: 101 })).toThrow(
"Invalid set-vignette intensity",
);
- expect(undoCount()).toBe(0);
+ // The edit that would create the layer fails, so the layer is not left behind.
+ expect(() => setVignette({ intensity: 101 })).toThrow(
+ "Invalid vignette adjustment",
+ );
+ expect(document.scene.getState()).toBe(opened);
- expect(run({ type: "set-adjustments", exposure: 1 })).toEqual({
- layerId: "base",
- });
+ expect(run({ type: "set-adjustments", exposure: 1 }).layerId).toBe("base");
const vignette = run({ type: "set-vignette", intensity: 40 }).layerId;
expect(run({ type: "set-vignette", softness: 80 }).layerId).toBe(vignette);
const mask = run({
type: "add-mask",
- mask: {
- kind: "radial",
- center: [16, 8],
- radius: [8, 4],
- angle: 0,
- feather: 0.5,
- },
+ mask: { kind: "linear", start: [0, 0], end: [32, 16] },
adjustments: { exposure: -1 },
}).layerId;
expect(document.scene.getState().layers.at(-1)).toMatchObject({
@@ -70,6 +61,7 @@ test("commands validate their input, return the layer they edit, and reset as on
expect(undoCount()).toBe(6);
run({ type: "undo" });
expect(document.scene.getState()).toEqual(edited);
+ workspace.dispose();
});
test("range masks select tones or a color, validate their bounds, and intersect other masks", async () => {
diff --git a/tests/crop.e2e.ts b/tests/crop.e2e.ts
new file mode 100644
index 0000000..9774530
--- /dev/null
+++ b/tests/crop.e2e.ts
@@ -0,0 +1,88 @@
+import { expect, openPhoto, test } from "./fixtures";
+import { readImage } from "./images";
+import { box, choose, drag, zoom } from "./pointer";
+
+test("crop, rotate, flip and straighten the photo, then undo", async ({
+ page,
+}) => {
+ const state = () => page.evaluate(() => window.openlight.getState());
+ await openPhoto(page);
+ const initial = await state();
+ const open = page.getByRole("tab", { name: "Crop" });
+ const panel = page.getByRole("region", { name: "Crop tool" });
+ const selection = page.getByRole("application", { name: "Crop selection" });
+ const apply = page.getByRole("button", { name: "Apply crop" });
+ const reset = panel.getByRole("button", { name: "Reset", exact: true });
+ const aspect = panel.getByRole("combobox", { name: "Aspect ratio" });
+
+ await test.step("Escape discards a draft", async () => {
+ await open.click();
+ await choose(page, aspect, "Square");
+ await page.keyboard.press("Escape");
+ await expect(panel).toBeHidden();
+ expect(await state()).toEqual(initial);
+ });
+
+ await test.step("a square crop resized by its edge and moved applies as one edit", async () => {
+ await page.keyboard.press("c");
+ await choose(page, aspect, "Square");
+ const edge = await box(
+ page.getByRole("button", { name: "Resize crop right", exact: true }),
+ );
+ const x = edge.x + edge.width / 2;
+ const y = edge.y + edge.height / 2;
+ await drag(page, [x, y], [x - 60, y]);
+ const bounds = await box(selection);
+ await drag(
+ page,
+ [bounds.x + bounds.width / 2, y],
+ [bounds.x + bounds.width / 2 + 300, y],
+ );
+ await page.keyboard.press("Enter");
+ await expect(panel).toBeHidden();
+ const cropped = await readImage(page);
+ expect(cropped.size[0]).toBe(cropped.size[1]);
+ expect(cropped.size[0]).toBeLessThan(800);
+ expect(cropped.corner).toEqual([0, 0, 0, 255]);
+ expect((await state()).history.undoCount).toBe(1);
+ await page.getByRole("button", { name: "Undo", exact: true }).click();
+ expect((await readImage(page)).size).toEqual([1200, 800]);
+ });
+
+ await test.step("a quarter turn swaps the size and a flip mirrors it", async () => {
+ await open.click();
+ await panel
+ .getByRole("button", { name: "Rotate counterclockwise" })
+ .click();
+ await panel.getByRole("button", { name: "Flip vertical" }).click();
+ await apply.click();
+ expect(await readImage(page)).toEqual({
+ size: [800, 1200],
+ center: [128, 128, 128, 255],
+ corner: [0, 0, 0, 255],
+ });
+ });
+
+ await test.step("a drag outside the crop straightens it, and reset restores the photo", async () => {
+ await open.click();
+ await reset.click();
+ await page.getByRole("button", { name: "Move crop" }).hover();
+ await zoom(page, 0.5);
+ const bounds = await box(selection);
+ const x = bounds.x + bounds.width + 40;
+ const y = bounds.y + bounds.height / 2;
+ const rise = (bounds.width / 2 + 40) * Math.tan(Math.PI / 6);
+ await drag(page, [x, y], [x, y + rise]);
+ await apply.click();
+ expect((await state()).frame?.angle).toBeCloseTo(30, 0);
+ expect(await readImage(page)).toEqual({
+ size: [1200, 800],
+ center: [128, 128, 128, 255],
+ corner: [32, 32, 32, 255],
+ });
+ await open.click();
+ await reset.click();
+ await apply.click();
+ expect((await state()).frame).toEqual(initial.frame);
+ });
+});
diff --git a/tests/crop.test.ts b/tests/crop.test.ts
index 4e6a360..22b7e32 100644
--- a/tests/crop.test.ts
+++ b/tests/crop.test.ts
@@ -16,17 +16,21 @@ import {
} from "@/features/crop/geometry";
const source: Point = [1200, 800];
+const corners = [0, 1].flatMap((x) => [0, 1].map((y) => [x, y] as const));
function sample(frame: ImageFrame, x: number, y: number) {
const { origin, xAxis, yAxis } = frameTransform(frame, source);
return origin.map((value, axis) => value + x * xAxis[axis] + y * yAxis[axis]);
}
+function expectSame(actual: number[], expected: number[]) {
+ for (const [i, value] of actual.entries()) {
+ expect(value).toBeCloseTo(expected[i], 8);
+ }
+}
function expectCovered(frame: ImageFrame) {
- for (const x of [0, 1]) {
- for (const y of [0, 1]) {
- for (const value of sample(frame, x, y)) {
- expect(value).toBeGreaterThanOrEqual(-1e-9);
- expect(value).toBeLessThanOrEqual(1 + 1e-9);
- }
+ for (const [x, y] of corners) {
+ for (const value of sample(frame, x, y)) {
+ expect(value).toBeGreaterThanOrEqual(-1e-9);
+ expect(value).toBeLessThanOrEqual(1 + 1e-9);
}
}
}
@@ -39,15 +43,15 @@ test("crop preserves source coverage, opposite anchors, flips, and sliding along
};
expect(move(edge, 120, 80, source).center).toEqual([900, 480]);
const minimum = resize(imageFrame(source), "se", -1200, -800, null, source);
- for (const ratio of [16 / 9, 9 / 16, 4 / 3, 3 / 4, 1]) {
+ for (const ratio of [16 / 9, 3 / 4, 1]) {
const next = fitRatio(minimum, ratio);
expect(() => validateFrame(next)).not.toThrow();
expect(next.size[0] / next.size[1]).toBeCloseTo(ratio, 10);
expect(next.center).toEqual(minimum.center);
expectCovered(next);
}
- for (const rotation of [0, 90, 180, 270]) {
- for (const angle of [-45, -30, 0, 30, 45]) {
+ for (const rotation of [0, 90, 270]) {
+ for (const angle of [-45, 0, 30]) {
const before = rotate(
{ ...edge, center: [480, 360], rotation },
angle,
@@ -56,48 +60,33 @@ test("crop preserves source coverage, opposite anchors, flips, and sliding along
for (const axis of [0, 1]) {
const flipped = flip(before, axis);
expectCovered(flipped);
- for (const x of [0, 0.3, 1]) {
- for (const y of [0, 0.7, 1]) {
- const expected = sample(
- before,
- axis === 0 ? 1 - x : x,
- axis === 1 ? 1 - y : y,
- );
- for (const [i, value] of sample(flipped, x, y).entries()) {
- expect(value).toBeCloseTo(expected[i], 10);
- }
- }
- }
- for (const direction of [-1, 1]) {
- const turned = turn(flipped, direction);
- expectCovered(turned);
- expect(turn(turned, -direction)).toEqual(flipped);
+ for (const [x, y] of corners) {
+ const [fx, fy] = axis === 0 ? [1 - x, y] : [x, 1 - y];
+ expectSame(sample(flipped, x, y), sample(before, fx, fy));
}
+ const turned = turn(flipped, 1);
+ expectCovered(turned);
+ expect(turn(turned, -1)).toEqual(flipped);
+ // Each handle anchors the opposite corner or edge midpoint.
for (const [handle, x, y] of [
["nw", 1, 1],
- ["ne", 0, 1],
- ["sw", 1, 0],
["se", 0, 0],
["n", 0.5, 1],
- ["s", 0.5, 0],
- ["w", 1, 0.5],
["e", 0, 0.5],
] as const) {
for (const delta of [-1200, 1200]) {
for (const ratio of [before.size[0] / before.size[1], null]) {
const next = resize(flipped, handle, delta, delta, ratio, source);
expectCovered(next);
- if (ratio)
+ expectSame(sample(next, x, y), sample(flipped, x, y));
+ expect(next.scale).toBe(flipped.scale);
+ if (ratio) {
expect(next.size[0] / next.size[1]).toBeCloseTo(ratio, 8);
- if (!ratio && x === 0.5)
+ } else if (x === 0.5) {
expect(next.size[0]).toBe(flipped.size[0]);
- if (!ratio && y === 0.5)
+ } else if (y === 0.5) {
expect(next.size[1]).toBe(flipped.size[1]);
- const anchor = sample(flipped, x, y);
- for (const [i, value] of sample(next, x, y).entries()) {
- expect(value).toBeCloseTo(anchor[i], 8);
}
- expect(next.scale).toBe(flipped.scale);
expectCovered(move(next, delta, delta, source));
expectCovered(rotate(next, -angle, source));
}
diff --git a/tests/curves.test.ts b/tests/curves.test.ts
index 94608e2..a359726 100644
--- a/tests/curves.test.ts
+++ b/tests/curves.test.ts
@@ -1,18 +1,17 @@
import { expect, test } from "bun:test";
-import { sampleCurve } from "@/features/tone-curves/curve";
+import {
+ defaultCurve,
+ insertCurvePoint,
+ moveCurvePoint,
+ removeCurvePoint,
+ sampleCurve,
+} from "@/features/tone-curves/curve";
import { interpolatePchip } from "@/lib/math";
test("curves interpolate smoothly through their handles without overshoot", () => {
- const identity = [
- { x: 0, y: 0 },
- { x: 1, y: 1 },
- ];
- const samples = sampleCurve(identity, 257);
- expect(samples).toBeInstanceOf(Float32Array);
- for (let i = 0; i < samples.length; i++) {
- expect(samples[i]).toBeCloseTo(i / 256, 7);
- }
-
+ expect(sampleCurve(defaultCurve, 5)).toEqual(
+ new Float32Array([0, 0.25, 0.5, 0.75, 1]),
+ );
const lift = interpolatePchip([
{ x: 0, y: 0 },
{ x: 0.5, y: 0.75 },
@@ -21,11 +20,12 @@ test("curves interpolate smoothly through their handles without overshoot", () =
expect(lift(0.25)).toBeCloseTo(0.453125, 7);
expect(lift(0.5)).toBe(0.75);
expect(lift(0.75)).toBeCloseTo(0.921875, 7);
- expect(lift(-1)).toBe(0);
- expect(lift(2)).toBe(1);
- const leftSlope = (lift(0.5) - lift(0.5 - 0.00001)) / 0.00001;
- const rightSlope = (lift(0.5 + 0.00001) - lift(0.5)) / 0.00001;
- expect(leftSlope).toBeCloseTo(rightSlope, 3);
+ expect([lift(-1), lift(2)]).toEqual([0, 1]);
+ const h = 1e-5;
+ expect((lift(0.5) - lift(0.5 - h)) / h).toBeCloseTo(
+ (lift(0.5 + h) - lift(0.5)) / h,
+ 3,
+ );
const points = [
{ x: 0, y: 0 },
{ x: 0.02, y: 0.4 },
@@ -35,13 +35,13 @@ test("curves interpolate smoothly through their handles without overshoot", () =
{ x: 1, y: 1 },
];
const evaluate = interpolatePchip(points);
- for (let i = 0; i < points.length - 1; i++) {
- const start = points[i];
+ // Between two handles the curve stays within their values and moves one way.
+ for (const [i, start] of points.slice(0, -1).entries()) {
const end = points[i + 1];
- expect(evaluate(start.x)).toBeCloseTo(start.y, 10);
- let previous = start.y;
- for (let step = 1; step <= 100; step++) {
- const value = evaluate(start.x + ((end.x - start.x) * step) / 100);
+ let previous = evaluate(start.x);
+ expect(previous).toBeCloseTo(start.y, 10);
+ for (let step = 1; step <= 20; step++) {
+ const value = evaluate(start.x + ((end.x - start.x) * step) / 20);
expect(value).toBeGreaterThanOrEqual(Math.min(start.y, end.y) - 1e-12);
expect(value).toBeLessThanOrEqual(Math.max(start.y, end.y) + 1e-12);
expect(
@@ -51,3 +51,32 @@ test("curves interpolate smoothly through their handles without overshoot", () =
}
}
});
+
+test("curve point edits keep endpoints on their edges and points apart", () => {
+ const gap = 1 / 1024;
+ const curve = [
+ { x: 0, y: 0 },
+ { x: 0.5, y: 0.5 },
+ { x: 1, y: 1 },
+ ];
+ const move = (index: number, x: number, y: number) =>
+ Object.values(moveCurvePoint(curve, index, { x, y })[index]);
+ // An endpoint follows whichever edge of the graph the drag stays nearer.
+ expect(move(0, 0.3, 0.1)).toEqual([0.3, 0]);
+ expect(move(0, 0.1, 0.3)).toEqual([0, 0.3]);
+ expect(move(2, 0.9, 0.7)).toEqual([1, 0.7]);
+ expect(move(2, 0.7, 0.9)).toEqual([0.7, 1]);
+ expect(move(0, 0.9, 0)).toEqual([0.5 - gap, 0]);
+ expect(move(1, 2, 0.5)).toEqual([1 - gap, 0.5]);
+
+ expect(removeCurvePoint(curve, 0)).toBe(curve);
+ expect(removeCurvePoint(curve, 2)).toBe(curve);
+ expect(removeCurvePoint(curve, 1)).toEqual(defaultCurve);
+
+ expect(insertCurvePoint(defaultCurve)).toEqual({ curve, index: 1 });
+ expect(insertCurvePoint(curve, { x: 0.5 + gap / 2, y: 0.6 })).toBeNull();
+ expect(insertCurvePoint(curve, { x: 0.75, y: 0.9 })).toEqual({
+ curve: [...curve.slice(0, 2), { x: 0.75, y: 0.9 }, curve[2]],
+ index: 2,
+ });
+});
diff --git a/tests/documents.test.ts b/tests/documents.test.ts
index dac83fc..13ab3a4 100644
--- a/tests/documents.test.ts
+++ b/tests/documents.test.ts
@@ -1,15 +1,15 @@
import { expect, test } from "bun:test";
import { init, target } from "vgpu/mock";
-import { createImageLayer } from "@/app/editor/layers";
+import { createImageLayer, createLayer } from "@/app/editor/layers";
import { createWorkspace } from "@/app/workspace";
import { createDocument, createResources } from "@/core/document";
import { createImageSource } from "@/core/image";
import { imageFrame } from "@/core/image/frame";
import { setAdjustments } from "@/features/adjustments/edits";
-import { detailsChange } from "@/features/details/edits";
+import { setDetails } from "@/features/details/edits";
+import { addLayer } from "@/features/layers/edits";
import { defaultCurve } from "@/features/tone-curves/curve";
import { setToneCurve } from "@/features/tone-curves/edits";
-import { parse } from "@/lib/parse";
function document() {
return createDocument({
@@ -20,6 +20,7 @@ function document() {
test("drop removes the latest entry only after its snapshot, leaving no redo, and cancels an open group", () => {
const doc = document();
+ const status = () => doc.history.status.getState();
const start = doc.scene.getState();
setAdjustments(doc, { exposure: 1 });
const adjusted = doc.scene.getState();
@@ -27,40 +28,32 @@ test("drop removes the latest entry only after its snapshot, leaving no redo, an
doc.history.undo();
doc.history.drop(adjusted);
expect(doc.scene.getState()).toBe(adjusted);
- expect(doc.history.status.getState()).toEqual({
- undoCount: 1,
- redoCount: 1,
- editing: false,
- });
+ expect(status()).toMatchObject({ undoCount: 1, redoCount: 1 });
doc.history.drop(start);
expect(doc.scene.getState()).toBe(start);
- expect(doc.history.status.getState()).toEqual({
- undoCount: 0,
- redoCount: 0,
- editing: false,
- });
+ expect(status()).toMatchObject({ undoCount: 0, redoCount: 0 });
doc.history.begin();
setAdjustments(doc, { exposure: 3 });
doc.history.drop(start);
expect(doc.scene.getState()).toBe(start);
- expect(doc.history.status.getState().undoCount).toBe(0);
+ expect(status().editing).toBe(false);
+});
+
+test("detail edits reject out-of-range values and leave the scene unchanged", () => {
+ const doc = document();
+ const id = addLayer(doc, createLayer("details"));
+ const added = doc.scene.getState();
+ for (const change of [{ sharpening: 151 }, { sharpenRadius: NaN }]) {
+ expect(() => setDetails(doc, change, id)).toThrow(
+ "Invalid detail adjustment",
+ );
+ }
+ expect(doc.scene.getState()).toBe(added);
});
test("documents edit independently without React, retain bounded history, and reject edits after replacement", async () => {
const first = document();
const second = document();
- for (const change of [
- { sharpening: -1 },
- { sharpening: 151 },
- { sharpenRadius: 0 },
- { sharpenRadius: 3.1 },
- { sharpenRadius: NaN },
- ]) {
- expect(() =>
- parse(detailsChange, change, "Invalid detail adjustment"),
- ).toThrow("Invalid detail adjustment");
- }
-
setAdjustments(first, { exposure: 1 });
const points = [
{ x: 0, y: 0 },
@@ -69,84 +62,46 @@ test("documents edit independently without React, retain bounded history, and re
];
setToneCurve(first, points);
points[1].y = 0.2;
- expect(first.scene.getState().layers[0]).toMatchObject({
- toneCurve: [
- { x: 0, y: 0 },
- { x: 0.5, y: 0.7 },
- { x: 1, y: 1 },
- ],
- });
+ expect(first.scene.getState().layers[0].toneCurve[1].y).toBe(0.7);
expect(second.scene.getState().layers[0].adjustments.exposure).toBe(0);
expect(second.history.status.getState().undoCount).toBe(0);
const unchanged = first.scene.getState();
+ // Too few points, points closer than the minimum gap, and an endpoint off its edge.
for (const curve of [
- [],
[{ x: 0, y: 0 }],
- [
- { x: 0, y: 0 },
- { x: 0, y: 1 },
- ],
[
{ x: 0, y: 0 },
{ x: 1 / 2048, y: 1 },
],
- [
- { x: 0, y: 0 },
- { x: 0.8, y: 0.5 },
- { x: 0.5, y: 1 },
- ],
- [
- { x: 0, y: 0 },
- { x: 1, y: Number.NaN },
- ],
- [
- { x: 0, y: -1 },
- { x: 1, y: 1 },
- ],
[
{ x: 0.1, y: 0.1 },
{ x: 1, y: 1 },
],
- [
- { x: 0, y: 0 },
- { x: 0.9, y: 0.9 },
- ],
]) {
- expect(() => setToneCurve(first, curve)).toThrow();
+ expect(() => setToneCurve(first, curve)).toThrow("Invalid tone curve");
}
expect(first.scene.getState()).toBe(unchanged);
first.history.undo();
- expect(first.scene.getState().layers[0]).toMatchObject({
- toneCurve: defaultCurve,
- });
+ expect(first.scene.getState().layers[0].toneCurve).toEqual(defaultCurve);
+ const status = () => first.history.status.getState();
for (let i = 0; i < 150; i++) setAdjustments(first, { exposure: i % 2 });
- expect(first.history.status.getState().undoCount).toBe(100);
+ expect(status().undoCount).toBe(100);
for (let i = 0; i < 100; i++) first.history.undo();
- expect(first.history.status.getState()).toEqual({
- undoCount: 0,
- redoCount: 100,
- editing: false,
- });
+ expect(status().redoCount).toBe(100);
setAdjustments(first, { contrast: 10 });
- expect(first.history.status.getState()).toEqual({
- undoCount: 1,
- redoCount: 0,
- editing: false,
- });
+ expect(status()).toMatchObject({ undoCount: 1, redoCount: 0 });
const workspace = createWorkspace();
await workspace.open("first", async () => first);
const stale = document();
- let release = () => {};
- const pending = new Promise<typeof stale>((resolve) => {
- release = () => resolve(stale);
- });
- const loading = workspace.open("slow", () => pending);
+ const pending = Promise.withResolvers<typeof stale>();
+ const loading = workspace.open("slow", () => pending.promise);
await workspace.open("second", async () => second);
- release();
+ pending.resolve(stale);
await loading;
- expect(() => setAdjustments(stale, { exposure: 2 })).toThrow("closed");
expect(workspace.getDocument()).toBe(second);
- expect(() => setAdjustments(first, { exposure: 2 })).toThrow("closed");
+ for (const closed of [stale, first]) {
+ expect(() => setAdjustments(closed, { exposure: 2 })).toThrow("closed");
+ }
workspace.dispose();
expect(() => setAdjustments(second, { exposure: 2 })).toThrow("closed");
@@ -157,52 +112,29 @@ test("documents edit independently without React, retain bounded history, and re
const add = () =>
resources.add(file, createImageSource(target(gpu, { size: [2, 2] })));
const source = add();
- const doc = createDocument(
- {
- ...document().scene.getState(),
- layers: [{ ...document().scene.getState().layers[0], source }],
- },
- resources,
- );
- const replace = (source: string) =>
- doc.edit({
- ...doc.scene.getState(),
- layers: [{ ...doc.scene.getState().layers[0], source }],
- });
+ const base = document().scene.getState();
+ const layers = [{ ...base.layers[0], source }] as const;
+ const doc = createDocument({ ...base, layers }, resources);
+ const replace = (source: string) => {
+ const scene = doc.scene.getState();
+ doc.edit({ ...scene, layers: [{ ...scene.layers[0], source }] });
+ };
const canceled = add();
doc.history.begin();
replace(canceled);
- expect(resources.get(source)).toBeDefined();
doc.history.cancel();
expect(() => resources.get(canceled)).toThrow("unavailable");
const branch = add();
replace(branch);
doc.history.undo();
expect(resources.get(branch)).toBeDefined();
- doc.history.redo();
- expect(doc.scene.getState().layers[0].source).toBe(branch);
- doc.history.undo();
setAdjustments(doc, { exposure: 1 });
expect(() => resources.get(branch)).toThrow("unavailable");
const replacement = add();
replace(replacement);
- for (let i = 0; i < 100; i++) {
- setAdjustments(doc, { exposure: i % 2 });
- }
+ for (let i = 0; i < 100; i++) setAdjustments(doc, { exposure: i % 2 });
expect(() => resources.get(source)).toThrow("unavailable");
expect(resources.get(replacement)).toBeDefined();
- const frame = doc.scene.getState().frame;
- for (const invalid of [
- { ...frame, size: [0, 1] as const },
- { ...frame, scale: [0, 1] as const },
- { ...frame, angle: Number.NaN },
- ]) {
- expect(() => doc.edit({ ...doc.scene.getState(), frame: invalid })).toThrow(
- "Invalid image frame",
- );
- }
- expect(doc.scene.getState().frame).toBe(frame);
-
doc.dispose();
expect(() => resources.get(replacement)).toThrow("unavailable");
gpu.dispose();
diff --git a/tests/draft.e2e.ts b/tests/draft.e2e.ts
index 0135ea9..e7c7b83 100644
--- a/tests/draft.e2e.ts
+++ b/tests/draft.e2e.ts
@@ -1,101 +1,56 @@
import type { Page } from "@playwright/test";
-import { expect, test } from "./fixtures";
+import { expect, openPhoto, test } from "./fixtures";
import { readImage } from "./images";
-/** The stored draft's base exposure and source keys, read straight from IndexedDB. */
-function storedDraft(page: Page) {
+/** The stored draft's base exposure, read straight from IndexedDB. */
+function savedExposure(page: Page) {
return page.evaluate(
() =>
- new Promise<{ exposure: number; sources: IDBValidKey[] } | null>(
- (resolve, reject) => {
- const opening = indexedDB.open("openlight", 1);
- opening.onerror = () => reject(opening.error);
- opening.onsuccess = () => {
- const database = opening.result;
- const transaction = database.transaction(["draft", "sources"]);
- const record = transaction.objectStore("draft").get("latest");
- const sources = transaction.objectStore("sources").getAllKeys();
- transaction.oncomplete = () => {
- database.close();
- resolve(
- record.result
- ? {
- exposure:
- record.result.scene.scene.layers[0].adjustments
- .exposure,
- sources: sources.result,
- }
- : null,
- );
- };
+ new Promise<number | undefined>((resolve, reject) => {
+ const opening = indexedDB.open("openlight", 1);
+ opening.onerror = () => reject(opening.error);
+ opening.onsuccess = () => {
+ const database = opening.result;
+ const request = database
+ .transaction("draft")
+ .objectStore("draft")
+ .get("latest");
+ request.onsuccess = () => {
+ database.close();
+ resolve(request.result?.scene.scene.layers[0].adjustments.exposure);
};
- },
- ),
+ };
+ }),
);
}
-test("edits survive a reload as a draft that recovers, keeps editing, and can be forgotten", async ({
+test("edits survive a reload as a draft that recovers, keeps saving, and can be forgotten", async ({
page,
}) => {
- await page.goto("/");
const recover = page.getByRole("button", { name: "Recover", exact: true });
- const forget = page.getByRole("button", { name: "Forget", exact: true });
- await page
- .locator('input[type="file"]')
- .setInputFiles("tests/fixtures/photo.svg");
const exposure = page.getByRole("textbox", { name: "Exposure", exact: true });
- await expect(exposure).toHaveValue("0.00");
- await expect(recover).toHaveCount(0);
- expect(await storedDraft(page)).toBeNull();
-
+ await openPhoto(page);
await page.evaluate(() => {
- const api = window.openlight;
- api.setAdjustments({ exposure: -1 });
- const mask = api.addLayer("mask");
- api.setLayerMask(mask, {
- kind: "radial",
- center: [600, 400],
- radius: [300, 200],
- angle: 0,
- feather: 0.5,
- });
- api.setAdjustments({ exposure: 1.5 }, mask);
- api.selectLayer(api.getState().scene?.layers[0].id ?? "");
+ window.openlight.setVignette({ intensity: 80 });
+ window.openlight.setAdjustments({ exposure: -1 });
});
- await expect(exposure).toHaveValue("-1.00");
- const samples = [
- [600, 400],
- [1100, 400],
- ] as const;
- const edited = await readImage(page, undefined, samples);
- await expect.poll(() => storedDraft(page)).toMatchObject({ exposure: -1 });
- const { sources } = (await storedDraft(page)) ?? { sources: [] };
- expect(sources).toHaveLength(1);
+ const edited = await readImage(page);
+ await expect.poll(() => savedExposure(page)).toBe(-1);
await page.reload();
- await expect(recover).toBeVisible();
- await expect(forget).toBeVisible();
await recover.click();
await expect(exposure).toHaveValue("-1.00");
- expect(await readImage(page, undefined, samples)).toEqual(edited);
+ expect(await readImage(page)).toEqual(edited);
expect(
(await page.evaluate(() => window.openlight.getState())).history.undoCount,
).toBe(0);
-
await page.evaluate(() => window.openlight.setAdjustments({ exposure: 0.5 }));
- await expect(exposure).toHaveValue("0.50");
- // The recovered source keeps its ID, so the save reuses the stored file.
- await expect
- .poll(() => storedDraft(page))
- .toEqual({ exposure: 0.5, sources });
+ await expect.poll(() => savedExposure(page)).toBe(0.5);
await page.reload();
- await forget.click();
- await expect(recover).toHaveCount(0);
- expect(await storedDraft(page)).toBeNull();
- await page.reload();
- await expect(page.getByText("choose a file")).toBeVisible();
+ await page.getByRole("button", { name: "Forget", exact: true }).click();
await expect(recover).toHaveCount(0);
+ await expect.poll(() => savedExposure(page)).toBeUndefined();
});
test("without IndexedDB a notice suggests scene files and editing still works", async ({
@@ -104,25 +59,13 @@ test("without IndexedDB a notice suggests scene files and editing still works",
await page.addInitScript(() =>
Object.defineProperty(window, "indexedDB", { value: undefined }),
);
- await page.goto("/");
+ await openPhoto(page);
const notice = page.getByRole("status").filter({ hasText: "Drafts" });
await expect(notice).toContainText("Save a scene from Export");
- await page
- .locator('input[type="file"]')
- .setInputFiles("tests/fixtures/photo.svg");
- const exposure = page.getByRole("textbox", { name: "Exposure", exact: true });
- await expect(exposure).toBeEnabled();
- await expect
- .poll(() => page.evaluate(() => window.openlight.getState().documentId))
- .toBeDefined();
await page.evaluate(() => window.openlight.setAdjustments({ exposure: 1 }));
- await expect(exposure).toHaveValue("1.00");
+ await expect(
+ page.getByRole("textbox", { name: "Exposure", exact: true }),
+ ).toHaveValue("1.00");
await notice.getByRole("button", { name: "Dismiss" }).click();
await expect(notice).toHaveCount(0);
- // The autosave after that edit fails the same way without bringing the notice back.
- await page.waitForTimeout(2000);
- await expect(notice).toHaveCount(0);
- await expect(
- page.evaluate(() => window.openlight.recoverDraft()),
- ).rejects.toThrow("IndexedDB is unavailable.");
});
diff --git a/tests/draft.test.ts b/tests/draft.test.ts
index eab26b6..0c28cef 100644
--- a/tests/draft.test.ts
+++ b/tests/draft.test.ts
@@ -1,6 +1,7 @@
import { expect, test } from "bun:test";
import { init, target } from "vgpu/mock";
-import { openDraft, snapshotDraft } from "@/app/draft/store";
+import { createDraftSession } from "@/app/draft/session";
+import { createDraftStore, openDraft, snapshotDraft } from "@/app/draft/store";
import { createImageLayer, createLayer } from "@/app/editor/layers";
import { createDocument, createResources } from "@/core/document";
import { createImageSource } from "@/core/image";
@@ -17,24 +18,16 @@ test("a draft survives storage's structured clone, reopens under its source ID,
);
const bytes = new Uint8Array([1, 2, 3, 4]);
const resources = createResources();
- const source = resources.add(
- new File([bytes], "photo.png", { type: "image/png" }),
- await decode(),
- );
- expect(() =>
- resources.add(
- new File([], "copy.png"),
- createImageSource(target(gpu, { size: [1, 1] })),
- source,
- ),
- ).toThrow("already exists");
- const document = createDocument(
- {
- frame: imageFrame([8, 4]),
- layers: [createImageLayer(source, "photo.png")],
- },
- resources,
+ const file = new File([bytes], "photo.png", { type: "image/png" });
+ const source = resources.add(file, await decode());
+ const duplicate = await decode();
+ expect(() => resources.add(file, duplicate, source)).toThrow(
+ "already exists",
);
+ duplicate.dispose();
+ const layers = [createImageLayer(source, "photo.png")] as const;
+ const frame = imageFrame([8, 4]);
+ const document = createDocument({ frame, layers }, resources);
setAdjustments(document, { exposure: 0.5 });
const vignette = addLayer(document, createLayer("vignette"));
setVignette(document, { intensity: 30, softness: 70 }, vignette);
@@ -44,9 +37,7 @@ test("a draft survives storage's structured clone, reopens under its source ID,
const stored = structuredClone(snapshotDraft(document, "photo.png"));
document.dispose();
expect(stored.record).toMatchObject({ version: 1, name: "photo.png" });
- const file = stored.files.get(source);
- expect(file).toBeInstanceOf(File);
- expect(await file?.bytes()).toEqual(bytes);
+ expect(await stored.files.get(source)?.bytes()).toEqual(bytes);
const recovered = await openDraft(stored, decode);
expect(recovered.scene.getState()).toEqual(edited);
expect(recovered.resources.get(source).file.name).toBe("photo.png");
@@ -54,33 +45,28 @@ test("a draft survives storage's structured clone, reopens under its source ID,
recovered.dispose();
const { record, files } = stored;
- const malformed: [unknown, string][] = [
+ for (const [value, message] of [
[undefined, "Invalid draft"],
- [{ ...record, version: "1" }, "Invalid draft version"],
[{ ...record, version: 2 }, "This draft needs a newer version"],
- [{ ...record, scene: undefined }, "doesn't contain an OpenLight scene"],
- [
- { ...record, scene: { ...record.scene, version: 2 } },
- "This scene needs a newer version",
- ],
- ];
- for (const [value, message] of malformed) {
+ ] as const) {
await expect(
openDraft({ record: value as typeof record, files }, decode),
).rejects.toThrow(message);
}
- await expect(openDraft({ record, files: new Map() }, decode)).rejects.toThrow(
- "The scene's image is missing.",
- );
+ gpu.dispose();
+});
- // A draft from before a group gained a parameter opens with its default, as a scene file does.
- const older = structuredClone(record);
- const layer = older.scene.scene.layers[1];
- if (layer.kind !== "vignette") throw Error("Missing vignette.");
- Reflect.deleteProperty(layer.vignette, "softness");
- const reopened = await openDraft({ record: older, files }, decode);
- expect(reopened.scene.getState().layers[1]).toMatchObject({
- vignette: { intensity: 30, softness: 50 },
+test("a dismissed draft failure stays dismissed while autosave fails the same way", () => {
+ const session = createDraftSession(createDraftStore(), {
+ recoverDraft: async () => {},
+ discardDraft: async () => {},
});
- reopened.dispose();
+ const error = () => session.state.getState().error;
+ session.report(Error("IndexedDB is unavailable."));
+ expect(error()).toBe("IndexedDB is unavailable.");
+ session.dismiss();
+ session.report(Error("IndexedDB is unavailable."));
+ expect(error()).toBeUndefined();
+ session.report(Error("The quota is exceeded."));
+ expect(error()).toBe("The quota is exceeded.");
});
diff --git a/tests/editing.e2e.ts b/tests/editing.e2e.ts
index d368733..b33beef 100644
--- a/tests/editing.e2e.ts
+++ b/tests/editing.e2e.ts
@@ -1,48 +1,14 @@
import { readFile } from "node:fs/promises";
-import type { Page } from "@playwright/test";
-import { type ImageFrame, imageFrame } from "@/core/image/frame";
import { interpolatePchip } from "@/lib/math";
-import { colorMixerEditing } from "./color-mixer-editing";
-import { expect, test } from "./fixtures";
+import { expect, openPhoto, test } from "./fixtures";
import { readImage, readPixel, readPreview } from "./images";
-import { box, choose, drag } from "./pointer";
-
-function expectCentered(
- actual: { x: number; y: number; width: number; height: number },
- expected: typeof actual,
-) {
- expect(actual.x + actual.width / 2).toBeCloseTo(
- expected.x + expected.width / 2,
- 0,
- );
- expect(actual.y + actual.height / 2).toBeCloseTo(
- expected.y + expected.height / 2,
- 0,
- );
-}
-
-async function zoom(page: Page, factor: number) {
- await page.keyboard.down("Control");
- await page.mouse.wheel(0, -Math.log(factor) * 100);
- await page.keyboard.up("Control");
-}
+import { box, choose, drag, zoom } from "./pointer";
test("edit a photo, inspect the preview and histograms, undo changes, and export", async ({
page,
- browser,
}) => {
- test.setTimeout(180_000);
const state = () => page.evaluate(() => window.openlight.getState());
- await page.goto("/");
- await expect(
- page.getByRole("button", { name: "choose a file" }),
- ).toBeVisible();
- // The start screen has no layer stack until a document opens.
- await expect(page.getByRole("heading", { name: "Layers" })).toHaveCount(0);
- await expect(page.getByRole("tab", { name: "Adjust" })).toBeDisabled();
- await page
- .locator('input[type="file"]')
- .setInputFiles("tests/fixtures/photo.svg");
+ await openPhoto(page);
const canvas = page
.getByRole("region", { name: "Image canvas" })
.locator("canvas");
@@ -50,120 +16,69 @@ test("edit a photo, inspect the preview and histograms, undo changes, and export
.getByLabel("output histogram", { exact: true })
.locator("polyline")
.first();
- await expect(
- page.getByLabel("output histogram", { exact: true }).locator("polygon"),
- ).toHaveCount(3);
await expect(output).toHaveAttribute("points", /,\d{1,2}\./);
const original = await canvas.screenshot();
- const histogram = await output.getAttribute("points");
+ const histogram = (await output.getAttribute("points")) ?? "";
const initial = await state();
- expect((await readImage(page)).center).toEqual([128, 128, 128, 255]);
-
- await test.step("image adjustments share a single section", async () => {
- await expect(
- page.getByRole("heading", { name: "Adjustments", exact: true }),
- ).toBeVisible();
- await expect(
- page.getByRole("slider", { name: "Clarity", exact: true }),
- ).toHaveCount(0);
- await expect(
- page.getByRole("slider", { name: "Exposure", exact: true }),
- ).toBeVisible();
- await expect(
- page.getByRole("slider", { name: "Temp", exact: true }),
- ).toBeVisible();
- });
+ async function type(name: string, value: string) {
+ const field = page.getByRole("textbox", { name, exact: true });
+ await field.fill(value);
+ await field.press("Enter");
+ }
- await test.step("zoomed rendering reaches the edges of the editor viewport", async () => {
- const viewport = await page
- .getByRole("region", { name: "Image canvas" })
- .boundingBox();
- if (!viewport) throw new Error("Missing editor viewport.");
- expect(await canvas.boundingBox()).toEqual(viewport);
+ await test.step("zoom and Space panning move only the view", async () => {
+ const viewport = await box(canvas);
+ const [x, y] = [
+ viewport.x + viewport.width / 2,
+ viewport.y + viewport.height / 2,
+ ];
await canvas.hover();
await zoom(page, 2);
- const edge = {
- x: viewport.x + viewport.width / 2,
- y: viewport.y + 4,
- width: 1,
- height: 1,
- };
+ // Only a zoomed photo reaches past the fitted margin to the top edge.
await expect
- .poll(async () => await readPixel(page, edge))
+ .poll(() => readPixel(page, { x, y: viewport.y + 4 }))
.toEqual([128, 128, 128, 255]);
await canvas.dblclick();
await expect.poll(() => canvas.screenshot()).toEqual(original);
- });
-
- await test.step("Space panning continues smoothly after releasing the key mid-drag", async () => {
- const viewport = await canvas.boundingBox();
- if (!viewport) throw new Error("Missing canvas.");
const scale = Math.min(
(viewport.width - 48) / 1200,
(viewport.height - 48) / 800,
- 2,
);
- const sample = {
- x: viewport.x + viewport.width / 2 + (430 - 600) * scale,
- y: viewport.y + viewport.height / 2 + (150 - 400) * scale,
- width: 1,
- height: 1,
- };
- expect(await readPixel(page, sample)).toEqual([48, 80, 128, 255]);
- await canvas.hover();
+ const blue = { x: x + (430 - 600) * scale, y: y + (150 - 400) * scale };
+ expect(await readPixel(page, blue)).toEqual([48, 80, 128, 255]);
+ // Releasing Space mid-drag keeps the pan going.
await page.keyboard.down("Space");
await page.mouse.down();
- await page.mouse.move(
- viewport.x + viewport.width / 2 + 100,
- viewport.y + viewport.height / 2,
- );
+ await page.mouse.move(x + 100, y);
await page.keyboard.up("Space");
- await page.mouse.move(
- viewport.x + viewport.width / 2 + 101,
- viewport.y + viewport.height / 2,
- );
+ await page.mouse.move(x + 101, y);
await page.mouse.up();
await expect
- .poll(async () => await readPixel(page, { ...sample, x: sample.x + 101 }))
+ .poll(() => readPixel(page, { ...blue, x: blue.x + 101 }))
.toEqual([48, 80, 128, 255]);
expect(await state()).toEqual(initial);
await canvas.dblclick();
- await expect.poll(() => canvas.screenshot()).toEqual(original);
});
- await test.step("exposure moves the preview and RGB histogram, then resets", async () => {
+ await test.step("an exposure drag is one edit of the image and histogram", async () => {
const exposure = page.getByRole("slider", {
name: "Exposure",
exact: true,
});
- await exposure.focus();
- await page.keyboard.down("ArrowRight");
- await page.keyboard.press("ArrowRight");
- await page.keyboard.up("ArrowRight");
- expect((await state()).history.undoCount).toBe(1);
- await page.getByRole("button", { name: "Undo", exact: true }).click();
- await expect(exposure).toHaveValue("0");
// Base UI keeps the range input inside the thumb, on the bar a person drags.
- const bounds = await box(
+ const track = await box(
exposure.locator('xpath=ancestor::*[@data-slot="slider-track"]'),
);
+ const y = track.y + track.height / 2;
await drag(
page,
- [bounds.x + bounds.width / 2, bounds.y + bounds.height / 2],
- [bounds.x + bounds.width * 0.6, bounds.y + bounds.height / 2],
- 8,
+ [track.x + track.width / 2, y],
+ [track.x + track.width * 0.6, y],
);
- expect((await state()).history.undoCount).toBe(1);
- await expect.poll(() => canvas.screenshot()).not.toEqual(original);
- await expect(output).not.toHaveAttribute("points", histogram ?? "");
+ await expect(output).not.toHaveAttribute("points", histogram);
expect((await readImage(page)).center[0]).toBeGreaterThan(160);
await page.keyboard.press("ControlOrMeta+z");
- await expect.poll(() => canvas.screenshot()).toEqual(original);
- await page.keyboard.press("ControlOrMeta+Shift+z");
- await expect.poll(() => canvas.screenshot()).not.toEqual(original);
- await exposure.locator("..").dblclick();
await expect(exposure).toHaveValue("0");
- await expect(output).toHaveAttribute("points", histogram ?? "");
await expect.poll(() => canvas.screenshot()).toEqual(original);
});
@@ -176,98 +91,42 @@ test("edit a photo, inspect the preview and histograms, undo changes, and export
{ x: 1, y: 1 },
]);
});
- const before = page.getByRole("button", {
+ const edited = await readImage(page);
+ const { history } = await state();
+ const center = async () => (await readPreview(page)).center;
+ const compare = page.getByRole("button", {
name: "Compare before and after",
exact: true,
});
- const shadows = page.getByRole("button", { name: "Show clipped shadows" });
- const highlights = page.getByRole("button", {
- name: "Show clipped highlights",
- });
- const edited = await readImage(page);
- const history = (await state()).history;
- const bins = await output.getAttribute("points");
- await before.focus();
+ await compare.focus();
await page.keyboard.down("Backslash");
- await expect(before).toHaveAttribute("aria-pressed", "true");
- await expect
- .poll(async () => (await readPreview(page)).center)
- .toEqual([128, 128, 128, 255]);
+ await expect.poll(center).toEqual([128, 128, 128, 255]);
await page.keyboard.up("Backslash");
- await expect
- .poll(async () => (await readPreview(page)).center)
- .toEqual([255, 255, 255, 255]);
- await before.click();
+ await expect.poll(center).toEqual([255, 255, 255, 255]);
+ await compare.click();
const divider = page.getByRole("slider", {
name: "Before and after divider",
});
- await expect(divider).toHaveAttribute("aria-valuenow", "50");
- const bounds = await canvas.boundingBox();
- if (!bounds) throw new Error("Preview is missing.");
+ const bounds = await box(canvas);
await divider.hover();
await page.mouse.down();
- await page.mouse.move(
- bounds.x + bounds.width * 0.8,
- bounds.y + bounds.height / 2,
- { steps: 8 },
- );
+ await page.mouse.move(bounds.x + bounds.width * 0.8, bounds.y + 10);
await page.mouse.up();
await expect(divider).toHaveAttribute("aria-valuenow", "80");
- await expect
- .poll(async () => (await readPreview(page)).center)
- .toEqual([128, 128, 128, 255]);
- await divider.press("Home");
- await expect
- .poll(async () => (await readPreview(page)).center)
- .toEqual([255, 255, 255, 255]);
- await divider.press("End");
- await expect
- .poll(async () => (await readPreview(page)).center)
- .toEqual([128, 128, 128, 255]);
- await divider.press("Shift+ArrowLeft");
- await expect(divider).toHaveAttribute("aria-valuenow", "90");
- await page.keyboard.down("Backslash");
- await expect(divider).toBeHidden();
- await page.keyboard.up("Backslash");
- await expect(divider).toHaveAttribute("aria-valuenow", "90");
- await before.click();
- await expect(divider).toBeHidden();
- await page.keyboard.down("Backslash");
- await page.evaluate(() => window.dispatchEvent(new Event("blur")));
- await expect(before).toHaveAttribute("aria-pressed", "false");
- await page.keyboard.up("Backslash");
- const field = page.getByRole("textbox", { name: "Exposure", exact: true });
- await field.focus();
- await page.keyboard.press("Backslash");
- await expect(before).toHaveAttribute("aria-pressed", "false");
- await field.press("Escape");
+ await expect.poll(center).toEqual([128, 128, 128, 255]);
+ await compare.click();
+ const shadows = page.getByRole("button", { name: "Show clipped shadows" });
+ const highlights = page.getByRole("button", {
+ name: "Show clipped highlights",
+ });
await shadows.click();
- await expect
- .poll(async () => (await readPreview(page)).blue)
- .toBeGreaterThan(100);
await highlights.click();
- await expect
- .poll(async () => (await readPreview(page)).center)
- .toEqual([255, 0, 0, 255]);
- await expect
- .poll(async () => (await readPreview(page)).blue)
- .toBeGreaterThan(100);
- await before.click();
- await expect
- .poll(async () => (await readPreview(page)).center)
- .toEqual([128, 128, 128, 255]);
+ await expect.poll(center).toEqual([255, 0, 0, 255]);
+ expect((await readPreview(page)).blue).toBeGreaterThan(100);
expect(await readImage(page)).toEqual(edited);
expect((await state()).history).toEqual(history);
- await expect(output).toHaveAttribute("points", bins ?? "");
- await page.evaluate(() =>
- window.openlight.setPreview({
- comparison: "edited",
- shadows: false,
- highlights: false,
- }),
- );
- await expect(highlights).toHaveAttribute("aria-pressed", "false");
- await expect.poll(async () => (await readPreview(page)).blue).toBe(0);
+ await shadows.click();
+ await highlights.click();
await page.evaluate(() => {
window.openlight.setAdjustments({ exposure: 0 });
window.openlight.setToneCurve();
@@ -275,694 +134,89 @@ test("edit a photo, inspect the preview and histograms, undo changes, and export
await expect.poll(() => canvas.screenshot()).toEqual(original);
});
- await test.step("light and color controls render together and reset", async () => {
- for (const [label, value] of [
- ["Highlights", -50],
- ["Shadows", 50],
- ["Whites", 25],
- ["Blacks", -25],
- ] as const) {
- const field = page.getByRole("textbox", { name: label, exact: true });
- await field.fill(String(value));
- await field.press("Enter");
- await expect(
- page.getByRole("slider", { name: label, exact: true }),
- ).toHaveValue(String(value));
- }
- await page.evaluate(() =>
- window.openlight.setAdjustments({
- contrast: 20,
- incrementalTemperature: 15,
- incrementalTint: -10,
- vibrance: 30,
- saturation: -20,
- }),
- );
- await expect.poll(() => canvas.screenshot()).not.toEqual(original);
- await expect(output).not.toHaveAttribute("points", histogram ?? "");
- const edited = await readImage(page);
- expect(edited.center).not.toEqual([128, 128, 128, 255]);
- await page.evaluate(
- (adjustments) => window.openlight.setAdjustments(adjustments),
- initial.adjustments,
- );
- await expect.poll(() => canvas.screenshot()).toEqual(original);
- });
-
- await colorMixerEditing(page);
-
- await test.step("clarity changes local contrast and histogram, then undoes and resets", async () => {
+ await test.step("clarity and sharpening edit a Details effect", async () => {
await page.getByRole("button", { name: "Add effect", exact: true }).click();
await page.getByRole("menuitem", { name: "Details", exact: true }).click();
- const field = page.getByRole("textbox", { name: "Clarity", exact: true });
- const slider = page.getByRole("slider", { name: "Clarity", exact: true });
- await field.fill("100");
- await field.press("Enter");
- await expect(slider).toHaveValue("100");
- await expect(output).not.toHaveAttribute("points", histogram ?? "");
- const positive = await readImage(page);
- expect(positive.center).toEqual([128, 128, 128, 255]);
- expect(positive.corner).toEqual([0, 0, 0, 255]);
- await page.getByRole("button", { name: "Undo", exact: true }).click();
- await expect(slider).toHaveValue("0");
- expect((await readImage(page)).center).toEqual([128, 128, 128, 255]);
- await field.fill("-100");
- await field.press("Enter");
- expect((await readImage(page)).center).toEqual([128, 128, 128, 255]);
+ await type("Clarity", "-100");
expect((await readImage(page)).corner[0]).toBeGreaterThan(0);
- await slider.locator("..").dblclick();
- await expect(slider).toHaveValue("0");
- await expect(output).toHaveAttribute("points", histogram ?? "");
- });
-
- await test.step("sharpening amount and radius edit, undo, and reset", async () => {
- const amount = page.getByRole("textbox", {
- name: "Sharpening",
- exact: true,
- });
- const radius = page.getByRole("textbox", { name: "Radius", exact: true });
- await amount.fill("100");
- await amount.press("Enter");
- await radius.fill("3");
- await radius.press("Enter");
- await expect(output).not.toHaveAttribute("points", histogram ?? "");
- expect((await readImage(page)).center).toEqual([128, 128, 128, 255]);
+ const clarity = page.getByRole("slider", { name: "Clarity", exact: true });
+ await clarity.locator("..").dblclick();
+ await expect(clarity).toHaveValue("0");
+ const edge = () => readImage(page, undefined, [[102, 50]]);
+ await type("Sharpening", "100");
+ await type("Radius", "3");
+ expect((await edge()).samples?.[0][0]).toBeGreaterThan(40);
await page.getByRole("button", { name: "Undo", exact: true }).click();
- await expect(radius).toHaveValue("1.0");
await page.getByRole("button", { name: "Undo", exact: true }).click();
- await expect(amount).toHaveValue("0");
- await expect(output).toHaveAttribute("points", histogram ?? "");
- await amount.fill("150");
- await amount.press("Enter");
- await page
- .getByRole("slider", { name: "Sharpening", exact: true })
- .locator("..")
- .dblclick();
- await expect(amount).toHaveValue("0");
+ expect((await edge()).samples?.[0][0]).toBe(32);
+ await expect(output).toHaveAttribute("points", histogram);
});
- await test.step("curve gestures change output after adjustments and undo as one edit", async () => {
+ await test.step("a curve drag after adjustments is one edit", async () => {
await page.evaluate(() =>
window.openlight.setAdjustments({ exposure: -1 }),
);
const adjusted = await readImage(page);
await page.getByRole("button", { name: "photo.svg", exact: true }).click();
const graph = page.getByRole("application", { name: "Tone curve" });
- const curveHistogram = page
+ const input = page
.getByLabel("curve input histogram", { exact: true })
.locator("polyline");
await graph.scrollIntoViewIfNeeded();
- await expect(curveHistogram).toHaveAttribute("points", /,\d{1,2}\./);
- const curveInput = await curveHistogram.getAttribute("points");
- const before = await page.evaluate(
- () => window.openlight.getState().history.undoCount,
- );
- const bounds = await graph.boundingBox();
- if (!bounds) throw new Error("Curve graph is missing.");
- expect((await box(graph.locator(".."))).height).toBe(180);
+ await expect(input).toHaveAttribute("points", /,\d{1,2}\./);
+ const points = (await input.getAttribute("points")) ?? "";
+ const bounds = await box(graph);
+ const x = bounds.x + bounds.width / 2;
await drag(
page,
- [bounds.x + bounds.width / 2, bounds.y + bounds.height / 2],
- [bounds.x + bounds.width / 2, bounds.y + bounds.height / 4],
- 8,
+ [x, bounds.y + bounds.height / 2],
+ [x, bounds.y + bounds.height / 4],
);
await expect(graph.locator("circle")).toHaveCount(3);
- await expect(curveHistogram).toHaveAttribute("points", curveInput ?? "");
- expect((await state()).history.undoCount).toBe(before + 1);
- const curved = await readImage(page);
- const curve = await page.evaluate(
- () => window.openlight.getState().toneCurve,
+ await expect(input).toHaveAttribute("points", points);
+ const curve = interpolatePchip((await state()).toneCurve);
+ const expected = curve(adjusted.center[0] / 255) * 255;
+ expect(Math.abs((await readImage(page)).center[0] - expected)).toBeLessThan(
+ 2,
);
- const expected = interpolatePchip(curve)(adjusted.center[0] / 255) * 255;
- expect(Math.abs(curved.center[0] - expected)).toBeLessThan(2);
await page.keyboard.press("ControlOrMeta+z");
expect(await readImage(page)).toEqual(adjusted);
- await page.keyboard.press("ControlOrMeta+Shift+z");
- expect(await readImage(page)).toEqual(curved);
- await graph.press("Shift+ArrowDown");
- await graph.press("Delete");
- await expect(graph.locator("circle")).toHaveCount(2);
- expect(await readImage(page)).toEqual(adjusted);
- await graph.press("Enter");
- await graph.press("ArrowUp");
- await expect(graph.locator("circle")).toHaveCount(3);
+ // Raising the black point lifts the black corner.
+ await drag(
+ page,
+ [bounds.x + 1, bounds.y + bounds.height - 1],
+ [bounds.x, bounds.y + bounds.height * 0.75],
+ 5,
+ );
+ expect(Math.abs((await readImage(page)).corner[0] - 64)).toBeLessThan(2);
await page.getByRole("button", { name: "Reset curve" }).click();
- await expect(graph.locator("circle")).toHaveCount(2);
await page.evaluate(() => window.openlight.setAdjustments({ exposure: 0 }));
await expect.poll(() => canvas.screenshot()).toEqual(original);
- for (const { from, to, sample, expected } of [
- { from: [0, 1], to: [0, 0.75], sample: "corner", expected: 64 },
- { from: [1, 0], to: [0.1, 0], sample: "center", expected: 255 },
- ] as const) {
- await graph.scrollIntoViewIfNeeded();
- const bounds = await box(graph);
- await drag(
- page,
- [
- bounds.x + 1 + from[0] * (bounds.width - 2),
- bounds.y + 1 + from[1] * (bounds.height - 2),
- ],
- [bounds.x + to[0] * bounds.width, bounds.y + to[1] * bounds.height],
- 5,
- );
- expect(
- Math.abs((await readImage(page))[sample][0] - expected),
- ).toBeLessThan(2);
- await graph.dblclick({
- position: { x: to[0] * bounds.width, y: to[1] * bounds.height },
- });
- expect(
- await page.evaluate(() => window.openlight.getState().toneCurve),
- ).toEqual(initial.toneCurve);
- }
});
- await page.getByRole("button", { name: "photo.svg", exact: true }).click();
- await test.step("a mask's curve input weighs its coverage and stays while the mask is hidden", async () => {
- const plot = page
- .getByLabel("curve input histogram", { exact: true })
- .locator("polyline");
- await expect(plot).toHaveAttribute("points", /,\d{1,2}\./);
- const whole = await plot.getAttribute("points");
- await page.evaluate(() => {
- const api = window.openlight;
- const mask = api.addLayer("mask");
- api.setLayer(mask, { name: "Curve input mask" });
- });
- // A neutral mask receives the same pixels, counted only where it covers them.
- await expect(plot).toHaveAttribute("points", /,\d{1,2}\./);
- await expect(plot).not.toHaveAttribute("points", whole ?? "");
- const neutral = await plot.getAttribute("points");
- await page.evaluate(() => {
- const api = window.openlight;
- api.setAdjustments({ exposure: 1 }, api.getState().selectedLayerId);
- });
- await expect(plot).not.toHaveAttribute("points", neutral ?? "");
- await expect(plot).toHaveAttribute("points", /,\d{1,2}\./);
- const points = await plot.getAttribute("points");
- await page
- .getByRole("button", { name: "Show Curve input mask", exact: true })
- .click();
- await expect(plot).toHaveAttribute("points", points ?? "");
- await page.getByRole("button", { name: "Undo", exact: true }).click();
- await expect(plot).toHaveAttribute("points", points ?? "");
- await page.evaluate(() => {
- const api = window.openlight;
- const mask = api.getState().selectedLayerId;
- if (!mask) throw Error("Missing mask selection.");
- api.deleteLayer(mask);
- });
- });
- await page.getByRole("button", { name: "photo.svg", exact: true }).click();
- await test.step("mode bar switches panels by click, arrow keys, and letters", async () => {
+ await test.step("the mode bar switches panels by click, arrow keys, and letters", async () => {
const modes = page.getByRole("tablist", { name: "Tools" });
const selected = modes.getByRole("tab", { selected: true });
- await expect(selected).toHaveAccessibleName("Adjust");
- const exportButton = page.getByRole("button", {
- name: "Export",
- exact: true,
- });
- await exportButton.click();
- await expect(exportButton).toHaveAttribute("aria-pressed", "true");
- await expect(
- page.getByRole("region", { name: "Image export" }),
- ).toBeVisible();
- await expect(
- page.getByRole("region", { name: "Layers", exact: true }),
- ).toHaveCount(0);
- await page.getByRole("button", { name: "Close", exact: true }).click();
- await expect(selected).toHaveAccessibleName("Adjust");
- await expect(
- page.getByRole("region", { name: "Layers", exact: true }),
- ).toBeVisible();
+ const layers = page.getByRole("region", { name: "Layers", exact: true });
await modes.getByRole("tab", { name: "Crop" }).click();
- await expect(selected).toHaveAccessibleName("Crop");
await page.keyboard.press("ArrowLeft");
await expect(selected).toHaveAccessibleName("Healing");
- await page.keyboard.press("ArrowLeft");
- await expect(selected).toHaveAccessibleName("Radial gradient");
+ await page.keyboard.press("e");
await expect(
- page.getByRole("heading", { name: "Adjustments", exact: true }),
+ page.getByRole("region", { name: "Image export" }),
).toBeVisible();
- await page.keyboard.press("ArrowLeft");
- await page.keyboard.press("ArrowLeft");
- await expect(selected).toHaveAccessibleName("Brush");
- await page.keyboard.press("ArrowLeft");
- await expect(selected).toHaveAccessibleName("Adjust");
- await expect(selected).toBeFocused();
- await page.keyboard.press("e");
- await expect(exportButton).toHaveAttribute("aria-pressed", "true");
+ await expect(layers).toHaveCount(0);
+ await page.getByRole("button", { name: "Close", exact: true }).click();
+ await expect(layers).toBeVisible();
await page.keyboard.press("a");
await expect(selected).toHaveAccessibleName("Adjust");
- await expect(page.getByRole("slider", { name: "Exposure" })).toBeVisible();
- });
-
- const open = page.getByRole("tab", { name: "Crop" });
- const panel = page.getByRole("region", { name: "Crop tool" });
- const selection = page.getByRole("application", { name: "Crop selection" });
- const corner = page.getByRole("button", { name: "Resize crop bottom right" });
- const move = page.getByRole("button", { name: "Move crop" });
- const reset = panel.getByRole("button", { name: "Reset", exact: true });
- const aspect = panel.getByRole("combobox", { name: "Aspect ratio" });
- const rotation = panel.getByRole("slider", { name: "Rotation", exact: true });
- async function setFrame(change: Partial<ImageFrame> = {}) {
- const frame = { ...imageFrame([1200, 800]), ...change };
- await page.evaluate((frame) => window.openlight.setFrame(frame), frame);
- }
-
- async function expectImage(size: number[], corner: number) {
- expect(await readImage(page)).toEqual({
- size,
- center: [128, 128, 128, 255],
- corner: [corner, corner, corner, 255],
- });
- }
-
- await test.step("Enter activates focused crop panel buttons", async () => {
- const before = await state();
- await open.click();
- await choose(page, aspect, "Square");
- await page
- .getByRole("button", { name: "Close", exact: true })
- .press("Enter");
- await expect(panel).toBeHidden();
- expect((await state()).frame).toEqual(before.frame);
- expect((await state()).history).toEqual(before.history);
- await open.click();
- await panel
- .getByRole("button", { name: "Rotate clockwise" })
- .press("Enter");
- await expect(panel).toBeVisible();
- expect((await state()).frame).toEqual(before.frame);
- await reset.press("Enter");
- await page.getByRole("button", { name: "Apply crop" }).press("Enter");
- await expect(panel).toBeHidden();
- expect((await state()).frame).toEqual(before.frame);
- expect((await state()).history).toEqual(before.history);
- });
-
- await test.step("locked crop corners resize continuously when the drag changes direction", async () => {
- await setFrame({ size: [600, 400] });
- await open.click();
- const grip = await box(corner);
- const x = grip.x + grip.width / 2;
- const y = grip.y + grip.height / 2;
- await page.mouse.move(x, y);
- await page.mouse.down();
- await page.mouse.move(x - 30, y + 19, { steps: 6 });
- const before = await box(selection);
- await page.mouse.move(x - 30, y + 21);
- const after = await box(selection);
- expect(Math.abs(after.width - before.width)).toBeLessThan(6);
- expectCentered(after, before);
- await page.keyboard.press("Escape");
- await page.mouse.up();
- await page.keyboard.press("c");
- const reopened = await box(selection);
- await page.mouse.move(x - 40, y - 40);
- expect(await box(selection)).toEqual(reopened);
- await page.keyboard.press("Escape");
- await setFrame();
- });
-
- await test.step("44px edge targets resize along one axis and preserve locked ratios", async () => {
- for (const locked of [false, true]) {
- for (const [label, sx, sy] of [
- ["top", 0, -1],
- ["right", 1, 0],
- ["bottom", 0, 1],
- ["left", -1, 0],
- ] as const) {
- await setFrame({ size: [300, 200] });
- await open.click();
- if (!locked) await choose(page, aspect, "Free");
- const bounds = await box(selection);
- const edge = page.getByRole("button", {
- name: `Resize crop ${label}`,
- exact: true,
- });
- const target = await box(edge);
- expect(sx ? target.width : target.height).toBe(44);
- const grip = await box(corner);
- expect([grip.width, grip.height]).toEqual([44, 44]);
- const x =
- bounds.x + bounds.width * (sx ? (sx + 1) / 2 : 0.35) + sx * 20;
- const y =
- bounds.y + bounds.height * (sy ? (sy + 1) / 2 : 0.35) + sy * 20;
- await drag(
- page,
- [x, y],
- [x - sx * 30 + Math.abs(sy) * 15, y - sy * 30 + Math.abs(sx) * 15],
- );
- const resized = await box(selection);
- const widthChange = sx ? 60 : Number(locked) * 90;
- const heightChange = sy ? 60 : Number(locked) * 40;
- expect(resized.width).toBeCloseTo(bounds.width - widthChange, 0);
- expect(resized.height).toBeCloseTo(bounds.height - heightChange, 0);
- expectCentered(resized, bounds);
- await page.getByRole("button", { name: "Apply crop" }).click();
- const frame = (await state()).frame;
- if (!frame) throw new Error("Missing cropped frame");
- const exported = await readImage(page);
- expect(exported.size).toEqual(frame.size.map(Math.round));
- expect(exported.center).toEqual([128, 128, 128, 255]);
- }
- }
- await setFrame();
- });
-
- await test.step("crop drafts cancel, apply once, rotate and straighten without losing the source", async () => {
- const before = await state();
- await expect(output).toHaveAttribute("points", histogram ?? "");
- await open.click();
- await expect(aspect).toContainText("Original");
- await choose(page, aspect, "Square");
- const bounds = await box(selection);
- await drag(
- page,
- [bounds.x + bounds.width, bounds.y + bounds.height],
- [bounds.x + bounds.width * 0.8, bounds.y + bounds.height * 0.8],
- );
- const beforeZoom = await box(selection);
- expect(beforeZoom.width).toBeLessThan(bounds.width);
- expect(beforeZoom.width).toBeCloseTo(beforeZoom.height, 4);
- expectCentered(beforeZoom, bounds);
- await corner.hover();
- await zoom(page, Math.exp(0.4));
- await expect
- .poll(async () => (await box(selection)).width)
- .toBeGreaterThan(beforeZoom.width * 1.4);
- const zoomed = await box(selection);
- const grip = await box(corner);
- await drag(
- page,
- [grip.x + grip.width / 2, grip.y + grip.height / 2],
- [grip.x + grip.width / 2 - 20, grip.y + grip.height / 2 - 20],
- 4,
- );
- const resized = await box(selection);
- expect(resized.width).toBeCloseTo(zoomed.width - 40, 0);
- const beforePan = await box(selection);
- expectCentered(beforePan, zoomed);
- await page.mouse.wheel(30, 20);
- await expect
- .poll(async () => (await box(selection)).x)
- .not.toBe(beforePan.x);
- expect((await box(selection)).width).toBe(resized.width);
- await move.press("Shift+ArrowRight");
- for (const gap of [20, 24]) {
- const frame = await box(selection);
- const x = frame.x + frame.width + gap;
- const y = frame.y + frame.height / 2;
- await page.mouse.move(x, y);
- expect(
- await page.evaluate(
- ({ x, y }) => {
- const element = document.elementFromPoint(x, y);
- return element && getComputedStyle(element).cursor;
- },
- { x, y },
- ),
- ).toContain(gap < 22 ? "ew-resize" : "url(");
- await page.mouse.down();
- await page.mouse.move(
- x,
- y + (frame.width / 2 + gap) * Math.tan(Math.PI / 6),
- { steps: 8 },
- );
- await page.mouse.up();
- const angle = await rotation.inputValue();
- expect(Number(angle)).toBeCloseTo(gap < 22 ? 0 : 30, 0);
- expect(await box(selection)).toEqual(frame);
- await page.mouse.move(x + 20, y);
- await expect(rotation).toHaveValue(angle);
- }
- expect((await readImage(page)).size).toEqual([1200, 800]);
- await page.keyboard.press("Escape");
- expect((await state()).frame).toEqual(before.frame);
- expect((await state()).history).toEqual(before.history);
- await open.focus();
- await page.keyboard.press("c");
- await choose(page, aspect, "Square");
- await corner.press("Enter");
- await expect(panel).toBeHidden();
- await expectImage([800, 800], 128);
- await expect(output).not.toHaveAttribute("points", histogram ?? "");
- expect((await state()).history.undoCount).toBe(
- before.history.undoCount + 1,
- );
- await page.getByRole("button", { name: "Undo", exact: true }).click();
- expect((await readImage(page)).size).toEqual([1200, 800]);
- await page.getByRole("button", { name: "Redo", exact: true }).click();
- expect((await readImage(page)).size).toEqual([800, 800]);
- await open.click();
- await reset.click();
- await panel
- .getByRole("button", { name: "Rotate counterclockwise" })
- .click();
- await corner.press("Enter");
- await expectImage([800, 1200], 224);
- await open.click();
- await panel.getByRole("button", { name: "Rotate clockwise" }).click();
- await panel.getByRole("button", { name: "Rotate clockwise" }).click();
- await page.getByRole("button", { name: "Apply crop" }).click();
- await expectImage([800, 1200], 32);
- await open.click();
- await reset.click();
- const angle = panel.getByRole("textbox", {
- name: "Rotation",
- exact: true,
- });
- await angle.fill("30");
- await angle.press("Enter");
- await expect(panel).toBeHidden();
- await expectImage([1200, 800], 32);
- await open.click();
- await reset.click();
- await page.getByRole("button", { name: "Apply crop" }).click();
- await expect.poll(() => canvas.screenshot()).toEqual(original);
- });
-
- await test.step("flip controls mirror pixels, preserve framing, and support undo", async () => {
- for (const [axis, value] of [
- ["horizontal", 224],
- ["vertical", 224],
- ["horizontal", 32],
- ["vertical", 0],
- ] as const) {
- const pixel = [value, value, value, 255];
- await open.click();
- const bounds = await box(selection);
- await page.getByRole("button", { name: `Flip ${axis}` }).click();
- expect(await box(selection)).toEqual(bounds);
- const corner = {
- x: bounds.x + 10,
- y: bounds.y + 10,
- };
- await expect
- .poll(async () => await readPixel(page, corner))
- .toEqual(pixel);
- await page.getByRole("button", { name: "Apply crop" }).click();
- expect((await readImage(page)).corner).toEqual(pixel);
- await page.getByRole("button", { name: "Undo", exact: true }).click();
- await page.getByRole("button", { name: "Redo", exact: true }).click();
- expect((await readImage(page)).corner).toEqual(pixel);
- }
- });
-
- await test.step("cropping preserves framing, moves the image, and rotates around the crop center", async () => {
- const sidebar = page.getByRole("complementary");
- const sidebarBefore = await box(sidebar);
- await drag(
- page,
- [sidebarBefore.x - 2, sidebarBefore.y + 40],
- [sidebarBefore.x - 82, sidebarBefore.y + 40],
- );
- const resizedSidebar = await box(sidebar);
- expect(resizedSidebar.width).toBe(sidebarBefore.width + 80);
- await setFrame({ center: [360, 200], size: [240, 240] });
- const viewport = await box(canvas);
- await open.click();
- expect(await box(sidebar)).toEqual(resizedSidebar);
- const bounds = await box(selection);
- // A 240px crop starts at 200%, centered exactly where it was before opening the tool.
- expect(bounds.width).toBeCloseTo(480, 0);
- expect(bounds.height).toBeCloseTo(480, 0);
- expect(bounds.x).toBeCloseTo(viewport.x + (viewport.width - 480) / 2, 0);
- expect(bounds.y).toBeCloseTo(viewport.y + (viewport.height - 480) / 2, 0);
- const sample = {
- x: bounds.x + 40,
- y: bounds.y + bounds.height / 2,
- };
- expect(await readPixel(page, sample)).toEqual([48, 80, 128, 255]);
- const x = bounds.x + bounds.width / 2;
- const y = bounds.y + bounds.height / 2;
- const beforePan = await state();
- for (const [startX, startY] of [
- [x, y],
- [bounds.x, bounds.y],
- [bounds.x + bounds.width, y],
- [bounds.x + bounds.width + 12, y],
- [bounds.x + bounds.width + 60, y],
- ]) {
- await page.mouse.move(startX, startY);
- await page.keyboard.down("Space");
- await expect(
- page.getByRole("button", { name: "Resize crop top left" }),
- ).toHaveCSS("cursor", "grab");
- await page.mouse.down();
- await page.mouse.move(startX + 40, startY + 20, { steps: 4 });
- await page.mouse.up();
- await page.keyboard.up("Space");
- expect(await box(selection)).toEqual({
- ...bounds,
- x: bounds.x + 40,
- y: bounds.y + 20,
- });
- expect(await state()).toEqual(beforePan);
- expect(
- await readPixel(page, {
- ...sample,
- x: sample.x + 40,
- y: sample.y + 20,
- }),
- ).toEqual([48, 80, 128, 255]);
- await page.keyboard.down("Space");
- await page.mouse.down();
- await page.mouse.move(startX, startY, { steps: 4 });
- await page.mouse.up();
- await page.keyboard.up("Space");
- }
- await page.mouse.move(x, y);
- await expect(move).toHaveCSS("cursor", "grab");
- await page.mouse.down();
- await expect(move).toHaveCSS("cursor", "grabbing");
- await page.mouse.move(x + 80, y + 30, { steps: 8 });
- await page.mouse.up();
- expect(await box(selection)).toEqual(bounds);
- expect(await readPixel(page, sample)).toEqual([128, 128, 128, 255]);
- await drag(
- page,
- [bounds.x + bounds.width + 60, y],
- [
- bounds.x + bounds.width + 60,
- y + (bounds.width / 2 + 60) * Math.tan(Math.PI / 6),
- ],
- 8,
- );
- expect(await box(selection)).toEqual(bounds);
- expect(Number(await rotation.inputValue())).toBeCloseTo(30, 0);
- const center = { x, y };
- expect(await readPixel(page, center)).toEqual([48, 80, 128, 255]);
- await page.keyboard.press("Enter");
- expect(await box(sidebar)).toEqual(resizedSidebar);
- expect((await readImage(page)).center).toEqual([48, 80, 128, 255]);
- await canvas.hover();
- await zoom(page, 2.5);
- await page.mouse.wheel(30, 20);
- const before = await readPixel(page, center);
- await open.click();
- const zoomed = await box(selection);
- expect(zoomed.width).toBeCloseTo(1200, 0);
- expect(zoomed.x).toBeCloseTo(
- viewport.x + (viewport.width - 1200) / 2 - 30,
- 0,
- );
- expect(zoomed.y).toBeCloseTo(
- viewport.y + (viewport.height - 1200) / 2 - 20,
- 0,
- );
- expect(await readPixel(page, center)).toEqual(before);
- await drag(page, [x, y], [x + 80, y + 30], 8);
- await page.keyboard.press("Enter");
- await open.click();
- expect(await box(selection)).toEqual(bounds);
- await page.keyboard.press("Escape");
- expect(await box(sidebar)).toEqual(resizedSidebar);
- await drag(
- page,
- [resizedSidebar.x - 2, resizedSidebar.y + 40],
- [sidebarBefore.x - 2, sidebarBefore.y + 40],
- );
- await setFrame();
- });
-
- await test.step("straightened crops leave empty space outside the source and reset restores geometry and camera", async () => {
- await setFrame({ size: [600, 400], angle: 30 });
- await open.click();
- await move.hover();
- await zoom(page, 0.5);
- const bounds = await box(selection);
- const outside = {
- x: bounds.x - bounds.width * 0.46,
- y: bounds.y - bounds.height * 0.46,
- };
- const pixel = async () => await readPixel(page, outside);
- await expect.poll(pixel).toEqual([9, 9, 9, 255]);
- await zoom(page, 0.5);
- const smaller = await box(selection);
- // Known light patch rotated beyond the original source rectangle.
- const revealed = {
- x: smaller.x + smaller.width * 1.535,
- y: smaller.y + smaller.height * 0.542,
- };
- await expect
- .poll(async () => await readPixel(page, revealed))
- .toEqual([90, 90, 90, 255]);
- await reset.click();
- await expect.poll(pixel).toEqual([0, 0, 0, 255]);
- const fitted = await box(selection);
- const viewport = await box(canvas);
- const fit = Math.min(
- (viewport.width - 48) / 1200,
- (viewport.height - 48) / 800,
- 2,
- );
- expect(fitted.width).toBeCloseTo(1200 * fit, 0);
- expect(fitted.height).toBeCloseTo(800 * fit, 0);
- expectCentered(fitted, viewport);
- await page.getByRole("button", { name: "Rotate clockwise" }).click();
- await move.hover();
- await zoom(page, Math.exp(0.8));
- await page.mouse.wheel(60, 40);
- await reset.click();
- expect(await box(selection)).toEqual(fitted);
- await expect(
- page.getByRole("slider", { name: "Rotation", exact: true }),
- ).toHaveValue("0");
- await expect(aspect).toContainText("Original");
- await choose(page, aspect, "Square");
- const fixed = await box(selection);
- for (const direction of [
- "ArrowLeft",
- "ArrowRight",
- "ArrowUp",
- "ArrowDown",
- ]) {
- for (let i = 0; i < 20; i++) await move.press(`Shift+${direction}`);
- const actual = await box(selection);
- expect(actual.x).toBeCloseTo(fixed.x, 0);
- expect(actual.y).toBeCloseTo(fixed.y, 0);
- }
- await page.keyboard.press("Escape");
- await setFrame();
});
- await test.step("export retains edits and original dimensions independently of viewport zoom", async () => {
+ await test.step("export keeps edits and size at any zoom, in PNG, JPEG and resized WebP", async () => {
await page.evaluate(() => {
window.openlight.beginEdit();
- window.openlight.setAdjustments({
- exposure: 1,
- highlights: -20,
- shadows: 30,
- whites: 10,
- blacks: -5,
- });
- window.openlight.setDetails({
- clarity: -50,
- sharpening: 100,
- sharpenRadius: 1,
- });
+ window.openlight.setAdjustments({ exposure: 1, shadows: 30 });
+ window.openlight.setDetails({ clarity: -50, sharpening: 100 });
window.openlight.setToneCurve([
{ x: 0, y: 0 },
{ x: 0.5, y: 0.75 },
@@ -971,15 +225,12 @@ test("edit a photo, inspect the preview and histograms, undo changes, and export
window.openlight.commitEdit();
});
const expected = await readImage(page);
- expect(expected.center[0]).toBeGreaterThan(190);
- expect(expected.center[0]).toBeLessThan(255);
- expect(expected.corner[0]).toBeGreaterThan(0);
- expect(expected.corner[3]).toBe(255);
+ expect(expected.center).not.toEqual([128, 128, 128, 255]);
await canvas.hover();
await zoom(page, Math.E);
- const panel = page.getByRole("region", { name: "Image export" });
await page.getByRole("button", { name: "Export", exact: true }).click();
- const quality = panel.getByRole("textbox", { name: "Quality" });
+ const panel = page.getByRole("region", { name: "Image export" });
+ const format = panel.getByRole("combobox", { name: "Format" });
async function save(name: string) {
const pending = page.waitForEvent("download");
await panel.getByRole("button", { name: "Save image" }).click();
@@ -989,21 +240,14 @@ test("edit a photo, inspect the preview and histograms, undo changes, and export
if (!path) throw new Error("Missing image download.");
return readFile(path);
}
- const format = panel.getByRole("combobox", { name: "Format" });
await choose(page, format, "PNG");
- await expect(panel.getByRole("textbox", { name: "Width" })).toHaveValue(
- "1200",
- );
- await expect(panel.getByText(/kB|MB/)).toBeVisible();
expect(await readImage(page, await save("photo.png"))).toEqual(expected);
await choose(page, format, "JPEG");
- await expect(format).toContainText("JPEG");
- await quality.fill("20");
- await quality.press("Enter");
+ await type("Quality", "20");
const small = await save("photo.jpg");
- await quality.fill("95");
- await quality.press("Enter");
+ await type("Quality", "95");
const large = await save("photo.jpg");
+ expect(large.length).toBeGreaterThan(small.length);
// The estimate encodes what Save writes, so it matches the file within its rounding.
const estimate = panel.getByText(/^[\d.,]+\s*(kB|MB)$/);
await expect
@@ -1015,89 +259,47 @@ test("edit a photo, inspect the preview and histograms, undo changes, and export
);
})
.toBeLessThan(Math.max(1000, large.length * 0.01));
- expect(large.length).toBeGreaterThan(small.length);
- for (const bytes of [small, large]) {
- const actual = await readImage(page, bytes);
- expect(actual.size).toEqual([1200, 800]);
- expect(
- Math.abs(actual.center[0] - expected.center[0]),
- ).toBeLessThanOrEqual(3);
- }
- expect(large.length).toBeGreaterThan(small.length);
+ const jpeg = await readImage(page, large);
+ expect(jpeg.size).toEqual([1200, 800]);
+ expect(Math.abs(jpeg.center[0] - expected.center[0])).toBeLessThanOrEqual(
+ 3,
+ );
await choose(page, format, "WebP");
- const width = panel.getByRole("textbox", { name: "Width" });
- await width.fill("600");
- await width.press("Enter");
+ await type("Width", "600");
await expect(panel.getByRole("textbox", { name: "Height" })).toHaveValue(
"400",
);
- const resized = await readImage(page, await save("photo.webp"));
- expect(resized.size).toEqual([600, 400]);
- expect(
- Math.abs(resized.center[0] - expected.center[0]),
- ).toBeLessThanOrEqual(3);
- await expect(quality).toHaveValue("95");
+ const webp = await readImage(page, await save("photo.webp"));
+ expect(webp.size).toEqual([600, 400]);
+ expect(Math.abs(webp.center[0] - expected.center[0])).toBeLessThanOrEqual(
+ 3,
+ );
await page.keyboard.press("a");
- await expect(panel).toBeHidden();
});
- await test.step("mobile dials take a finger's drag, and a double tap resets", async () => {
- const context = await browser.newContext({
- viewport: { width: 390, height: 844 },
- isMobile: true,
- hasTouch: true,
- deviceScaleFactor: 2,
+ await test.step("a mask's curve input weighs its coverage and stays while the mask is hidden", async () => {
+ const plot = page
+ .getByLabel("curve input histogram", { exact: true })
+ .locator("polyline");
+ await expect(plot).toHaveAttribute("points", /,\d{1,2}\./);
+ const whole = (await plot.getAttribute("points")) ?? "";
+ const mask = await page.evaluate(() => {
+ const mask = window.openlight.addLayer("mask");
+ window.openlight.setLayer(mask, { name: "Curve input mask" });
+ return mask;
});
- try {
- const mobile = await context.newPage();
- await mobile.goto(page.url());
- await mobile
- .locator('input[type="file"]')
- .setInputFiles("tests/fixtures/photo.svg");
- const histogram = await box(
- mobile.getByRole("region", { name: "Image histogram" }),
- );
- expect(histogram.width).toBe(176);
- expect(histogram.height).toBe(56);
- const exposure = mobile.getByRole("slider", {
- name: "Exposure",
- exact: true,
- });
- // Every dial takes a fingertip.
- for (const dial of await mobile.getByRole("slider").all()) {
- const bounds = await box(dial);
- expect(bounds.width).toBeGreaterThanOrEqual(44);
- expect(bounds.height).toBeGreaterThanOrEqual(44);
- }
- const bounds = await box(exposure);
- const [x, y] = [bounds.x + bounds.width / 2, bounds.y + 20];
- const touch = await context.newCDPSession(mobile);
- const send = (type: "touchStart" | "touchMove" | "touchEnd", at = [x]) =>
- touch.send("Input.dispatchTouchEvent", {
- type,
- touchPoints: type === "touchEnd" ? [] : at.map((x) => ({ x, y })),
- });
- await send("touchStart");
- for (let step = 1; step <= 6; step++) {
- await send("touchMove", [x + step * 10]);
- }
- await send("touchEnd");
- // Sixty pixels sweep a tenth of the range.
- await expect(exposure).toHaveAttribute("aria-valuetext", "1.00");
- expect((await readImage(mobile)).center).not.toEqual([
- 128, 128, 128, 255,
- ]);
- await mobile.touchscreen.tap(x, y);
- await mobile.touchscreen.tap(x, y);
- await expect(exposure).toHaveAttribute("aria-valuetext", "0.00");
- const undo = mobile.getByRole("button", { name: "Undo", exact: true });
- await undo.tap();
- await expect(exposure).toHaveAttribute("aria-valuetext", "1.00");
- await undo.tap();
- await expect(exposure).toHaveAttribute("aria-valuetext", "0.00");
- expect((await readImage(mobile)).center).toEqual([128, 128, 128, 255]);
- } finally {
- await context.close();
- }
+ // A neutral mask receives the same pixels, counted only where it covers them.
+ await expect(plot).toHaveAttribute("points", /,\d{1,2}\./);
+ await expect(plot).not.toHaveAttribute("points", whole);
+ await page.evaluate(
+ (mask) => window.openlight.setAdjustments({ exposure: 1 }, mask),
+ mask,
+ );
+ await expect(plot).toHaveAttribute("points", /,\d{1,2}\./);
+ const points = (await plot.getAttribute("points")) ?? "";
+ await page
+ .getByRole("button", { name: "Show Curve input mask", exact: true })
+ .click();
+ await expect(plot).toHaveAttribute("points", points);
});
});
diff --git a/tests/fill.e2e.ts b/tests/fill.e2e.ts
index de7e60e..cab12c0 100644
--- a/tests/fill.e2e.ts
+++ b/tests/fill.e2e.ts
@@ -1,69 +1,34 @@
-import { expect, test } from "./fixtures";
+import { expect, openPhoto, test } from "./fixtures";
import { readImage } from "./images";
import { box, choose, drag } from "./pointer";
-test("a color layer paints the image or a brush stroke with Photoshop blends", async ({
+test("a color layer paints a brush stroke with Photoshop blends", async ({
page,
-}, info) => {
- await page.setViewportSize({ width: 1440, height: 1000 });
- const state = () => page.evaluate(() => window.openlight.getState());
- async function addColor() {
- await page.getByRole("button", { name: "Add effect", exact: true }).click();
- await page.getByRole("menuitem", { name: "Color", exact: true }).click();
+}) => {
+ await openPhoto(page);
+ await page.getByRole("tab", { name: "Brush", exact: true }).click();
+ const bounds = await box(page.getByLabel("Brush canvas", { exact: true }));
+ const y = bounds.y + bounds.height / 2;
+ const x = bounds.x + bounds.width / 2;
+ await drag(page, [x - 100, y], [x + 100, y], 16);
+ await page.getByRole("button", { name: "Add effect", exact: true }).click();
+ await page.getByRole("menuitem", { name: "Color", exact: true }).click();
+ const read = async () =>
+ (
+ await readImage(page, undefined, [
+ [600, 400],
+ [600, 100],
+ ])
+ ).samples ?? [];
+ const [painted, outside] = await read();
+ for (const [channel, expected] of [240, 118, 60].entries()) {
+ expect(Math.abs(painted[channel] - expected)).toBeLessThanOrEqual(2);
}
- await page.goto("/");
- await page
- .locator('input[type="file"]')
- .setInputFiles("tests/fixtures/photo.svg");
- await expect(
- page.getByRole("textbox", { name: "Exposure", exact: true }),
- ).toHaveValue("0.00");
- expect((await readImage(page)).center).toEqual([128, 128, 128, 255]);
- await test.step("Normal paints the color; Multiply darkens by it", async () => {
- await addColor();
- const blend = page.getByRole("combobox", { name: "Blend" });
- await expect(blend).toContainText("Normal");
- const painted = (await readImage(page)).center;
- for (const [channel, expected] of [240, 118, 60].entries()) {
- expect(Math.abs(painted[channel] - expected)).toBeLessThanOrEqual(2);
- }
- await choose(page, blend, "Multiply");
- const multiplied = (await readImage(page)).center;
- expect(multiplied[0]).toBeLessThan(128);
- expect(multiplied[0]).toBeGreaterThan(multiplied[2] + 40);
- await page.evaluate(() => window.openlight.setFill({ color: "#ffffff" }));
- expect((await readImage(page)).center).toEqual([128, 128, 128, 255]);
- await page.keyboard.press("ControlOrMeta+z");
- await page.keyboard.press("ControlOrMeta+z");
- expect((await readImage(page)).center).toEqual(painted);
- await page.keyboard.press("ControlOrMeta+z");
- expect((await readImage(page)).center).toEqual([128, 128, 128, 255]);
- expect((await state()).scene?.layers).toHaveLength(1);
- });
- await test.step("inside a brush mask the color follows the stroke", async () => {
- await page.getByRole("tab", { name: "Brush", exact: true }).click();
- const canvas = page.getByLabel("Brush canvas", { exact: true });
- const bounds = await box(canvas);
- const scale = Math.min(bounds.width / 1200, bounds.height / 800, 2);
- const center = [bounds.x + bounds.width / 2, bounds.y + bounds.height / 2];
- await page.getByRole("textbox", { name: "Size", exact: true }).fill("200");
- await page
- .getByRole("textbox", { name: "Size", exact: true })
- .press("Enter");
- await drag(
- page,
- [center[0] - 150 * scale, center[1]],
- [center[0] + 150 * scale, center[1]],
- 16,
- );
- await addColor();
- const { samples } = await readImage(page, undefined, [
- [600, 400],
- [600, 100],
- ]);
- expect(samples?.[0][0]).toBeGreaterThan(200);
- expect(samples?.[0][2]).toBeLessThan(100);
- expect(samples?.[1]).toEqual([128, 128, 128, 255]);
- await page.screenshot({ path: info.outputPath("fill-ui.png") });
- });
+ expect(outside).toEqual([128, 128, 128, 255]);
+ await choose(page, page.getByRole("combobox", { name: "Blend" }), "Multiply");
+ const [multiplied] = await read();
+ expect(multiplied[0]).toBeLessThan(128);
+ expect(multiplied[0]).toBeGreaterThan(multiplied[2] + 40);
+ await page.keyboard.press("ControlOrMeta+z");
+ expect((await read())[0]).toEqual(painted);
});
diff --git a/tests/fill.test.ts b/tests/fill.test.ts
index 5dc47cd..1d685ed 100644
--- a/tests/fill.test.ts
+++ b/tests/fill.test.ts
@@ -7,7 +7,7 @@ import {
maskNeutral,
} from "@/app/editor/layers";
import { createEditorRenderer } from "@/app/editor/renderer";
-import { createDocument, createResources, findLayer } from "@/core/document";
+import { createDocument, findLayer } from "@/core/document";
import { createImageSource } from "@/core/image";
import { parseColor } from "@/core/image/blend";
import { imageFrame } from "@/core/image/frame";
@@ -18,59 +18,44 @@ import { defaultGradient } from "@/features/layers/gradient";
test("a color layer renders its fill, validates its settings, and keeps a mask from looking neutral", async () => {
const gpu = await init();
- const source = createImageSource(
- target(gpu, { size: [16, 8], format: "rgba16float" }),
- );
- const resources = createResources();
- const sourceId = resources.add(new File([], "photo.png"), source);
- const document = createDocument(
- {
- frame: imageFrame(source.image.size),
- layers: [{ ...createImageLayer(sourceId, "Photo"), id: "base" }],
- },
- resources,
- );
+ const image = target(gpu, { size: [16, 8], format: "rgba16float" });
+ const layers = [createImageLayer("photo", "Photo")] as const;
+ const document = createDocument({ frame: imageFrame(image.size), layers });
+ const source = createImageSource(image);
const renderer = createEditorRenderer(gpu, source);
- try {
- expect(parseColor("#ff8000")).toEqual([1, 128 / 255, 0]);
- const mask = addLayer(document, createMask(defaultGradient([16, 8])));
- const layer = () => {
- const item = findLayer(document.scene.getState().layers, mask);
- if (item?.kind !== "mask") {
- throw Error("Mask is missing.");
- }
- return item;
- };
- expect(maskNeutral(layer())).toBe(true);
- const fill = addLayer(document, createLayer("fill"), { inside: mask });
- expect(maskNeutral(layer())).toBe(false);
- await renderer.update(document.scene.getState());
- expect(renderer.inspect().passes).toEqual([
- `layer/${fill}/fill`,
- `layer/${mask}/mix`,
- ]);
- setFill(document, { color: "#00FF00", blend: "multiply" }, fill);
- expect(findLayer(document.scene.getState().layers, fill)).toMatchObject({
- fill: { color: "#00ff00", blend: "multiply" },
- });
- for (const change of [
- { color: "red" },
- { color: "#12345" },
- { blend: "darken" as "normal" },
- ]) {
- expect(() => setFill(document, change, fill)).toThrow("Invalid fill");
- }
- expect(() => setFill(document, { color: "#000000" }, mask)).toThrow(
- "color layer",
- );
- // A hidden fill leaves the mask neutral; an adjustment does not.
- setLayer(document, fill, { visible: false });
- expect(maskNeutral(layer())).toBe(true);
- setAdjustments(document, { contrast: 5 }, mask);
- expect(maskNeutral(layer())).toBe(false);
- } finally {
- renderer.dispose();
- document.dispose();
- gpu.dispose();
+ expect(parseColor("#ff8000")).toEqual([1, 128 / 255, 0]);
+ const mask = addLayer(document, createMask(defaultGradient([16, 8])));
+ const neutral = () => {
+ const layer = findLayer(document.scene.getState().layers, mask);
+ return layer?.kind === "mask" && maskNeutral(layer);
+ };
+ expect(neutral()).toBe(true);
+ const fill = addLayer(document, createLayer("fill"), { inside: mask });
+ expect(neutral()).toBe(false);
+ await renderer.update(document.scene.getState());
+ expect(renderer.inspect().passes).toEqual([
+ `layer/${fill}/fill`,
+ `layer/${mask}/mix`,
+ ]);
+ setFill(document, { color: "#00FF00", blend: "multiply" }, fill);
+ expect(findLayer(document.scene.getState().layers, fill)).toMatchObject({
+ fill: { color: "#00ff00", blend: "multiply" },
+ });
+ for (const change of [{ color: "#12345" }, { blend: "darken" }]) {
+ expect(() =>
+ Reflect.apply(setFill, undefined, [document, change, fill]),
+ ).toThrow("Invalid fill");
}
+ expect(() => setFill(document, { color: "#000000" }, mask)).toThrow(
+ "color layer",
+ );
+ // A hidden fill leaves the mask neutral; an adjustment does not.
+ setLayer(document, fill, { visible: false });
+ expect(neutral()).toBe(true);
+ setAdjustments(document, { contrast: 5 }, mask);
+ expect(neutral()).toBe(false);
+ renderer.dispose();
+ document.dispose();
+ source.dispose();
+ gpu.dispose();
});
diff --git a/tests/fixtures.ts b/tests/fixtures.ts
index 2873aee..ad21940 100644
--- a/tests/fixtures.ts
+++ b/tests/fixtures.ts
@@ -1,7 +1,18 @@
-import { test as base, expect } from "@playwright/test";
+import { test as base, expect, type Page } from "@playwright/test";
export { expect };
+/** Opens the test photo and waits for its controls. */
+export async function openPhoto(page: Page) {
+ await page.goto("/");
+ await page
+ .locator('input[type="file"]')
+ .setInputFiles("tests/fixtures/photo.svg");
+ await expect(
+ page.getByRole("textbox", { name: "Exposure", exact: true }),
+ ).toHaveValue("0.00");
+}
+
export const test = base.extend<{ browserErrors: undefined }>({
browserErrors: [
async ({ page, baseURL }, use) => {
diff --git a/tests/fixtures/rgb8-jpeg.tif b/tests/fixtures/rgb8-jpeg.tif
deleted file mode 100644
index e351659..0000000
Binary files a/tests/fixtures/rgb8-jpeg.tif and /dev/null differ
diff --git a/tests/heic.e2e.ts b/tests/heic.e2e.ts
index ae5861f..b9afb27 100644
--- a/tests/heic.e2e.ts
+++ b/tests/heic.e2e.ts
@@ -1,57 +1,32 @@
-import { readFile } from "node:fs/promises";
import { expect, test } from "./fixtures";
+import { readImage } from "./images";
-test("loads a HEIC image with the expected dimensions and pixels", async ({
- page,
-}) => {
- const bytes = await readFile(
- new URL("./fixtures/patches.heic", import.meta.url),
- );
+test("a HEIC image opens with its size and pixels", async ({ page }) => {
await page.goto("/");
- await page.waitForFunction(() => window.openlight);
- const supported = await page.evaluate(async () => {
- if (!("VideoDecoder" in window)) {
- return false;
- }
- // Main Still Picture profile used by patches.heic.
- return (await VideoDecoder.isConfigSupported({ codec: "hvc1.3.e.L30" }))
- .supported;
- });
+ const supported = await page.evaluate(
+ async () =>
+ "VideoDecoder" in window &&
+ // Main Still Picture profile used by patches.heic.
+ (await VideoDecoder.isConfigSupported({ codec: "hvc1.3.e.L30" }))
+ .supported,
+ );
test.skip(!supported, "This browser has no HEVC Main Still Picture decoder.");
- const result = await page.evaluate(
- async (bytes) => {
- await window.openlight.loadImage(
- new File([new Uint8Array(bytes)], "patches.heic", {
- type: "image/heic",
- }),
- );
- const image = await createImageBitmap(
- await window.openlight.exportImage(),
- );
- const canvas = new OffscreenCanvas(image.width, image.height);
- const context = canvas.getContext("2d");
- if (!context) throw new Error("Cannot read exported image.");
- context.drawImage(image, 0, 0);
- image.close();
- return {
- size: [canvas.width, canvas.height],
- pixels: [
- [16, 16],
- [48, 16],
- [16, 48],
- [48, 48],
- ].flatMap(([x, y]) => [...context.getImageData(x, y, 1, 1).data]),
- };
- },
- [...bytes],
+ await page.waitForFunction(() => window.openlight);
+ await page.evaluate(() =>
+ window.openlight.loadUrl("/tests/fixtures/patches.heic"),
);
-
- expect(result.size).toEqual([64, 64]);
+ const { size, samples } = await readImage(page, undefined, [
+ [16, 16],
+ [48, 16],
+ [16, 48],
+ [48, 48],
+ ]);
+ expect(size).toEqual([64, 64]);
// Reference pixels decoded independently with libheif.
const expected = [
176, 96, 95, 255, 97, 176, 97, 255, 94, 95, 175, 255, 128, 128, 128, 255,
];
- result.pixels.forEach((value, i) => {
+ samples?.flat().forEach((value, i) => {
expect(Math.abs(value - expected[i]), `Channel ${i}`).toBeLessThanOrEqual(
3,
);
diff --git a/tests/layer-drop.test.ts b/tests/layer-drop.test.ts
index 2cff1bb..746b4aa 100644
--- a/tests/layer-drop.test.ts
+++ b/tests/layer-drop.test.ts
@@ -26,74 +26,26 @@ const scene: Scene = {
],
};
+type Result = ReturnType<typeof layerDrop>;
+
// Drop positions are visual, top to bottom; results are bottom-to-top sibling indices.
-test.each<[string, LayerDrop, ReturnType<typeof layerDrop>]>([
- [
- "above a root sibling",
- { id: "top", target: "mask", position: "before" },
- { index: 2 },
- ],
- [
- "below a root sibling",
- { id: "top", target: "mask", position: "after" },
- { index: 1 },
- ],
- [
- "above the image",
- { id: "vignette", target: "image", position: "before" },
- { index: 1 },
- ],
- [
- "into a mask",
- { id: "top", target: "mask", position: "inside" },
- { parentId: "mask", index: 2 },
- ],
- [
- "above a nested sibling",
- { id: "top", target: "exposure", position: "before" },
- { parentId: "mask", index: 1 },
- ],
- [
- "below a nested sibling",
- { id: "top", target: "exposure", position: "after" },
- { parentId: "mask", index: 0 },
- ],
- [
- "below the image",
- { id: "vignette", target: "image", position: "after" },
- undefined,
- ],
- [
- "into the image",
- { id: "top", target: "image", position: "inside" },
- undefined,
- ],
- [
- "the image itself",
- { id: "image", target: "top", position: "before" },
- undefined,
- ],
- [
- "a parent into its child",
- { id: "mask", target: "exposure", position: "inside" },
- undefined,
- ],
- [
- "a parent into another mask",
- { id: "mask", target: "other", position: "inside" },
- undefined,
- ],
- [
- "a parent beside a nested layer",
- { id: "mask", target: "details", position: "before" },
- undefined,
- ],
- ["onto itself", { id: "top", target: "top", position: "inside" }, undefined],
- [
- "an unknown target",
- { id: "top", target: "missing", position: "before" },
- undefined,
- ],
-])("layerDrop rejects or resolves %s", (_, drop, expected) => {
- expect(layerDrop(scene, drop)).toEqual(expected);
+test.each<[string, LayerDrop["position"], string, Result]>([
+ ["top", "before", "mask", { index: 2 }],
+ ["top", "after", "mask", { index: 1 }],
+ ["vignette", "before", "image", { index: 1 }],
+ ["top", "inside", "mask", { parentId: "mask", index: 2 }],
+ ["top", "before", "exposure", { parentId: "mask", index: 1 }],
+ // Below the image, into the image, or moving the image itself.
+ ["vignette", "after", "image", undefined],
+ ["top", "inside", "image", undefined],
+ ["image", "before", "top", undefined],
+ // A parent into its own child, into another mask, or beside a nested layer.
+ ["mask", "inside", "exposure", undefined],
+ ["mask", "inside", "other", undefined],
+ ["mask", "before", "details", undefined],
+ // Deeper than two levels, or next to a missing layer.
+ ["top", "inside", "exposure", undefined],
+ ["top", "before", "missing", undefined],
+])("drop %s %s %s", (id, position, target, expected) => {
+ expect(layerDrop(scene, { id, target, position })).toEqual(expected);
});
diff --git a/tests/layers.e2e.ts b/tests/layers.e2e.ts
index cb03994..49ee5f7 100644
--- a/tests/layers.e2e.ts
+++ b/tests/layers.e2e.ts
@@ -1,96 +1,57 @@
-import { writeFile } from "node:fs/promises";
-import type { Page } from "@playwright/test";
-import { expect, test } from "./fixtures";
+import { expect, openPhoto, test } from "./fixtures";
import { readImage, readPreview } from "./images";
import { box, choose, drag } from "./pointer";
-async function samples(page: Page) {
- const { samples } = await readImage(page, undefined, [
- [600, 100],
- [600, 700],
- ]);
- return samples ?? [];
-}
-
-test("draw a mask, edit its child effects, reorder layers and undo", async ({
+test("draw masks, edit their child effects, reorder layers and undo", async ({
page,
-}, info) => {
+}) => {
test.setTimeout(90_000);
await page.setViewportSize({ width: 1440, height: 1000 });
const state = () => page.evaluate(() => window.openlight.getState());
+ const layers = async () => (await state()).scene?.layers ?? [];
+ const undo = () =>
+ page.getByRole("button", { name: "Undo", exact: true }).click();
+ async function samples() {
+ const points = [
+ [600, 100],
+ [600, 700],
+ ] as const;
+ return (await readImage(page, undefined, points)).samples ?? [];
+ }
+ async function radialMask() {
+ const layer = (await layers()).at(-1);
+ if (layer?.kind !== "mask" || layer.mask.kind !== "radial") {
+ throw Error("Radial mask missing");
+ }
+ return layer.mask;
+ }
async function setField(name: string, value: string) {
const field = page.getByRole("textbox", { name, exact: true });
await field.fill(value);
await field.press("Enter");
}
- async function action(name: string, command: string) {
+ async function action(layer: string, ...items: string[]) {
await page
- .getByRole("button", { name: `${name} actions`, exact: true })
+ .getByRole("button", { name: `${layer} actions`, exact: true })
.click();
- await page.getByRole("menuitem", { name: command, exact: true }).click();
- }
- async function dragLayer(name: string, target: string, fraction: number) {
- const from = await box(
- page
- .getByRole("region", { name: "Layers", exact: true })
- .getByRole("button", { name, exact: true }),
- );
- const row = page
- .locator("[data-selected]")
- .filter({ has: page.getByRole("button", { name: target, exact: true }) });
- const to = await box(row);
- await drag(
- page,
- [from.x + from.width / 2, from.y + from.height / 2],
- [to.x + to.width / 2, to.y + to.height * fraction],
- );
- }
- async function saveExport(name: string) {
- const bytes = await page.evaluate(async () => [
- ...new Uint8Array(
- await (await window.openlight.exportImage()).arrayBuffer(),
- ),
- ]);
- await writeFile(info.outputPath(name), new Uint8Array(bytes));
+ for (const item of items) {
+ await page.getByRole("menuitem", { name: item, exact: true }).click();
+ }
}
- await page.goto("/");
- await page
- .locator('input[type="file"]')
- .setInputFiles("tests/fixtures/photo.svg");
- await expect(
- page.getByRole("textbox", { name: "Exposure", exact: true }),
- ).toHaveValue("0.00");
- await test.step("Details is an optional effect, separate from image adjustments", async () => {
- await expect(
- page.getByRole("heading", { name: "Adjustments", exact: true }),
- ).toBeVisible();
- await expect(
- page.getByRole("textbox", { name: "Clarity", exact: true }),
- ).toHaveCount(0);
- await page.getByRole("button", { name: "Add effect", exact: true }).click();
- await page.getByRole("menuitem", { name: "Details", exact: true }).click();
- await setField("Clarity", "-100");
- expect((await readImage(page)).corner[0]).toBeGreaterThan(0);
- await page.getByRole("button", { name: "Undo", exact: true }).click();
- expect((await readImage(page)).corner).toEqual([0, 0, 0, 255]);
- await page.getByRole("button", { name: "Undo", exact: true }).click();
- });
- const original = await samples(page);
+ await openPhoto(page);
+ const original = await samples();
await test.step("a local exposure recovers light the global exposure pushed past white", async () => {
- // Export pixels at the gray field and the light band, both inside the radial mask below.
- const tones = async () => {
- const { samples } = await readImage(page, undefined, [
- [600, 700],
- [1100, 700],
- ]);
- return samples?.map((pixel) => pixel[0]) ?? [];
- };
- const [gray, band] = await tones();
- expect([gray, band]).toEqual([128, 224]);
- await page.evaluate(() => window.openlight.setAdjustments({ exposure: 2 }));
- expect((await tones())[0]).toBeGreaterThan(200);
+ // The gray field and the light band, both inside the radial mask.
+ const points = [
+ [600, 700],
+ [1100, 700],
+ ] as const;
+ const tones = async () =>
+ (await readImage(page, undefined, points)).samples?.map(([red]) => red);
+ expect(await tones()).toEqual([128, 224]);
await page.evaluate(() => {
const api = window.openlight;
+ api.setAdjustments({ exposure: 2 });
const mask = api.addLayer("mask");
api.setLayerMask(mask, {
kind: "radial",
@@ -101,94 +62,49 @@ test("draw a mask, edit its child effects, reorder layers and undo", async ({
});
api.setAdjustments({ exposure: -2 }, mask);
});
- const recovered = await tones();
- expect(Math.abs(recovered[0] - gray)).toBeLessThan(30);
- expect(Math.abs(recovered[1] - band)).toBeLessThan(30);
- expect(recovered[1] - recovered[0]).toBeGreaterThan(0.6 * (band - gray));
- expect((await samples(page))[0][0]).toBeGreaterThan(200);
+ const [gray, band] = (await tones()) ?? [];
+ expect(Math.abs(gray - 128)).toBeLessThan(30);
+ expect(Math.abs(band - 224)).toBeLessThan(30);
+ expect(band - gray).toBeGreaterThan(0.6 * (224 - 128));
+ expect((await samples())[0][0]).toBeGreaterThan(200);
await page.evaluate(() => {
for (let i = 0; i < 4; i++) window.openlight.undo();
});
- expect(await samples(page)).toEqual(original);
+ expect(await samples()).toEqual(original);
});
- await page.screenshot({ path: info.outputPath("layers-before-ui.png") });
- await saveExport("layers-before-export.png");
- await page.getByRole("tab", { name: "Linear gradient", exact: true }).click();
- const overlay = page.getByLabel("Gradient mask canvas", { exact: true });
- const bounds = await box(overlay);
+ await page.keyboard.press("l");
+ const bounds = await box(
+ page.getByLabel("Gradient mask canvas", { exact: true }),
+ );
const scale = Math.min(bounds.width / 1200, bounds.height / 800, 2);
const center = [bounds.x + bounds.width / 2, bounds.y + bounds.height / 2];
const from = [center[0], center[1] - 200 * scale];
const to = [center[0], center[1] + 200 * scale];
- await test.step("cancellation is empty; a new mask shows its overlay until it changes the image", async () => {
- await page.mouse.move(from[0], from[1]);
- await page.mouse.down();
- await page.mouse.move(to[0], to[1]);
- await page.keyboard.press("Escape");
- await page.mouse.up();
- expect((await state()).scene?.layers).toHaveLength(1);
+ await test.step("a linear mask shows its overlay until an adjustment changes the image", async () => {
// Sample above the center, clear of the guide lines and the move handle.
- async function maskPreview() {
+ const tinted = async () => {
const { center } = await readPreview(page, [0, -100 * scale]);
- return {
- shown: (await state()).preview?.maskOverlay !== undefined,
- tinted: center[0] > center[1] + 30,
- };
- }
- await drag(page, from, to);
- await expect.poll(maskPreview).toEqual({ shown: true, tinted: true });
- await page.keyboard.press("ControlOrMeta+z");
- expect((await state()).scene?.layers).toHaveLength(1);
- await expect.poll(maskPreview).toEqual({ shown: false, tinted: false });
- await page.keyboard.press("l");
+ return center[0] > center[1] + 30;
+ };
await drag(page, from, to);
- await expect.poll(maskPreview).toEqual({ shown: true, tinted: true });
- const layers = (await state()).scene?.layers;
- expect(layers).toHaveLength(2);
- expect(layers?.[1]).toMatchObject({
- kind: "mask",
- children: [],
- });
+ expect(await layers()).toMatchObject([{}, { mask: { kind: "linear" } }]);
+ await expect.poll(tinted).toBe(true);
await setField("Exposure", "1");
- await expect.poll(maskPreview).toEqual({ shown: false, tinted: false });
+ await expect.poll(tinted).toBe(false);
await page.keyboard.press("o");
- await expect.poll(maskPreview).toEqual({ shown: true, tinted: true });
+ await expect.poll(tinted).toBe(true);
await page.keyboard.press("o");
- await expect.poll(maskPreview).toEqual({ shown: false, tinted: false });
- const [top, bottom] = await samples(page);
+ const [top, bottom] = await samples();
expect(top[0]).toBeGreaterThan(170);
- expect(bottom).toEqual([128, 128, 128, 255]);
- await setField("Temp", "20");
- const warmed = await samples(page);
- expect(warmed[0][0]).toBeGreaterThan(warmed[0][2]);
- await page.getByRole("button", { name: "Undo", exact: true }).click();
- expect(await samples(page)).toEqual([top, bottom]);
- await setField("Exposure", "2");
- expect((await samples(page))[0][0]).toBeGreaterThan(top[0] + 20);
+ expect(bottom).toEqual(original[1]);
});
- await test.step("selected gradient guides move, resize and rotate with atomic undo and cancellation", async () => {
+ await test.step("the move guide is one undo step, Escape cancels it, and Delete removes the mask", async () => {
const before = await state();
- const pixels = await samples(page);
+ const pixels = await samples();
await drag(page, center, [center[0], center[1] - 150 * scale]);
- expect((await state()).history.undoCount).toBe(
- before.history.undoCount + 1,
- );
- expect(await samples(page)).not.toEqual(pixels);
- await page.keyboard.press("ControlOrMeta+z");
- expect((await state()).scene).toEqual(before.scene);
- expect(await samples(page)).toEqual(pixels);
- await drag(page, from, [from[0], from[1] - 50 * scale]);
- expect((await state()).scene).not.toEqual(before.scene);
- await page.keyboard.press("ControlOrMeta+z");
- await drag(page, [center[0] + 80, center[1]], [center[0], center[1] + 80]);
- const rotated = (await state()).scene?.layers[1];
- expect(rotated?.kind).toBe("mask");
- if (rotated?.kind === "mask" && rotated.mask.kind === "linear") {
- expect(
- Math.abs(rotated.mask.end[1] - rotated.mask.start[1]),
- ).toBeLessThan(1);
- }
+ expect(await samples()).not.toEqual(pixels);
await page.keyboard.press("ControlOrMeta+z");
+ expect(await samples()).toEqual(pixels);
await page.mouse.move(center[0], center[1]);
await page.mouse.down();
await page.mouse.move(center[0] + 50, center[1] + 50);
@@ -196,258 +112,130 @@ test("draw a mask, edit its child effects, reorder layers and undo", async ({
await page.mouse.up();
expect((await state()).scene).toEqual(before.scene);
await page.keyboard.press("Delete");
- expect((await state()).scene?.layers).toHaveLength(1);
+ expect(await layers()).toHaveLength(1);
await page.keyboard.press("ControlOrMeta+z");
expect((await state()).scene).toEqual(before.scene);
});
- await test.step("mask opacity and visibility apply to the complete branch", async () => {
+ await test.step("a subtracting child changes coverage and Add restores it", async () => {
await page
.getByRole("button", { name: "Linear Gradient", exact: true })
.dblclick();
await setField("Layer name", "Sky");
- const masked = await samples(page);
- // The overlay tint scales with opacity, like the mask's coverage does.
- const tint = async () => {
- const { center } = await readPreview(page, [0, -100 * scale]);
- return center[0] - center[1];
- };
- await page.keyboard.press("o");
- await expect.poll(tint).toBeGreaterThan(30);
- const full = await tint();
- await setField("Opacity", "50");
- await expect.poll(tint).toBeLessThan(full - 10);
- await page.keyboard.press("o");
- await page.getByRole("button", { name: "Undo", exact: true }).click();
- await setField("Opacity", "0");
- expect(await samples(page)).toEqual(original);
- // The curve still shows what it would affect.
- await expect(
- page.getByLabel("curve input histogram").locator("polyline"),
- ).toHaveAttribute("points", /,\d{1,2}\./);
- await page.getByRole("button", { name: "Undo", exact: true }).click();
- expect(await samples(page)).toEqual(masked);
- await page.getByRole("button", { name: "Show Sky", exact: true }).click();
- expect(await samples(page)).toEqual(original);
- await page.getByRole("button", { name: "Show Sky", exact: true }).click();
- expect(await samples(page)).toEqual(masked);
- });
- await test.step("a subtracting child changes coverage and Add restores the masked region", async () => {
- const masked = await samples(page);
- await page
- .getByRole("button", { name: "Sky actions", exact: true })
- .click();
- await page
- .getByRole("menuitem", { name: "Subtract from mask", exact: true })
- .click();
- await page
- .getByRole("menuitem", { name: "Linear gradient", exact: true })
- .click();
+ const masked = await samples();
+ await action("Sky", "Subtract from mask", "Linear gradient");
await drag(page, from, to);
- expect((await samples(page))[0]).toEqual(original[0]);
- const operation = page.getByRole("combobox", {
- name: "Mask operation",
- exact: true,
- });
+ expect((await samples())[0]).toEqual(original[0]);
+ const operation = page.getByRole("combobox", { name: "Mask operation" });
await choose(page, operation, "Add");
- expect((await samples(page))[0]).toEqual(masked[0]);
- await page.getByRole("button", { name: "Undo", exact: true }).click();
- expect((await samples(page))[0]).toEqual(original[0]);
- await page.getByRole("button", { name: "Undo", exact: true }).click();
- expect(await samples(page)).toEqual(masked);
+ expect((await samples())[0]).toEqual(masked[0]);
+ await undo();
+ await undo();
+ expect(await samples()).toEqual(masked);
await page.getByRole("button", { name: "Sky", exact: true }).click();
});
-
- await test.step("child effects can leave the mask, reorder and return through undo", async () => {
- const masked = await samples(page);
- await page.getByRole("button", { name: "Add effect", exact: true }).click();
- await expect(page.getByRole("menu")).toBeVisible();
- await page.keyboard.press("Escape");
- await expect(page.getByRole("menu")).toHaveCount(0);
+ await test.step("a child effect moves out by drag and menu, returns, duplicates and deletes", async () => {
+ const masked = await samples();
await page.getByRole("button", { name: "Add effect", exact: true }).click();
await page.getByRole("menuitem", { name: "Vignette", exact: true }).click();
- expect(
- (await state()).scene?.layers[1].children.map((layer) => layer.kind),
- ).toEqual(["vignette"]);
await setField("Intensity", "80");
- const nested = await samples(page);
+ const nested = await samples();
expect(nested[0][0]).toBeLessThan(masked[0][0]);
expect(nested[1]).toEqual(masked[1]);
- const beforeMove = (await state()).history.undoCount;
- await dragLayer("Vignette", "Sky", 0.1);
- expect((await state()).history.undoCount).toBe(beforeMove + 1);
- expect((await state()).scene?.layers).toHaveLength(3);
- expect((await samples(page))[1][0]).toBeLessThan(masked[1][0]);
- await dragLayer("Vignette", "photo.svg", 0.1);
- expect((await state()).scene?.layers[1].kind).toBe("vignette");
- await dragLayer("Vignette", "Sky", 0.5);
- expect(await samples(page)).toEqual(nested);
- await page.getByRole("button", { name: "Undo", exact: true }).click();
- await page.getByRole("button", { name: "Undo", exact: true }).click();
- await page.getByRole("button", { name: "Undo", exact: true }).click();
- expect(await samples(page)).toEqual(nested);
+ const row = (name: string) =>
+ box(
+ page
+ .getByRole("region", { name: "Layers", exact: true })
+ .getByRole("button", { name, exact: true }),
+ );
+ const vignette = await row("Vignette");
+ const sky = await row("Sky");
+ await drag(
+ page,
+ [vignette.x + vignette.width / 2, vignette.y + vignette.height / 2],
+ [sky.x + sky.width / 2, sky.y + 2],
+ );
+ expect(await layers()).toHaveLength(3);
+ expect((await samples())[1][0]).toBeLessThan(masked[1][0]);
+ await undo();
+ expect(await samples()).toEqual(nested);
+ await action("Vignette", "Move out");
+ expect((await samples())[1][0]).toBeLessThan(masked[1][0]);
+ await action("Vignette", "Move into", "Sky");
+ expect(await samples()).toEqual(nested);
+ await action("Vignette", "Duplicate");
+ expect((await samples())[0][0]).toBeLessThan(nested[0][0]);
+ await undo();
await action("Vignette", "Delete");
- expect(await samples(page)).toEqual(masked);
- await page.getByRole("button", { name: "Undo", exact: true }).click();
- expect((await state()).scene?.layers[1].children).toHaveLength(1);
+ expect(await samples()).toEqual(masked);
+ await undo();
+ expect(await samples()).toEqual(nested);
+ });
+ await test.step("mask opacity and visibility apply to the whole branch", async () => {
+ await page.getByRole("button", { name: "Sky", exact: true }).click();
+ const masked = await samples();
+ await setField("Opacity", "0");
+ expect(await samples()).toEqual(original);
+ await undo();
+ const show = page.getByRole("button", { name: "Show Sky", exact: true });
+ await show.click();
+ expect(await samples()).toEqual(original);
+ await show.click();
+ expect(await samples()).toEqual(masked);
});
- await page.getByRole("button", { name: "Sky", exact: true }).click();
- await page.screenshot({ path: info.outputPath("layers-after-ui.png") });
- await saveExport("layers-after-export.png");
- await test.step("radial masks edit locally, resize, feather, rotate, subtract and undo", async () => {
+ await test.step("a radial mask moves, resizes, rotates and feathers with its guides", async () => {
+ await page.getByRole("button", { name: "photo.svg", exact: true }).click();
const before = await readImage(page);
- const beforeSamples = await samples(page);
- // Guides win over drawing, so the drag starts below Sky's rotation guide.
- const origin = [center[0], center[1] + 60 * scale];
await page.keyboard.press("r");
- await drag(page, origin, [
- origin[0] + 220 * scale,
- origin[1] + 120 * scale,
+ await drag(page, center, [
+ center[0] + 220 * scale,
+ center[1] + 120 * scale,
]);
await setField("Exposure", "1");
expect((await readImage(page)).center[0]).toBeGreaterThan(
before.center[0] + 20,
);
- expect((await samples(page))[1]).toEqual(beforeSamples[1]);
- await page.screenshot({ path: info.outputPath("radial-ui.png") });
- await saveExport("radial-export.png");
- const edited = await state();
- await page.mouse.move(origin[0] + 40, origin[1] + 30);
- await expect(
- page.getByLabel("Move radial gradient", { exact: true }),
- ).toHaveCSS("cursor", "grab");
- await page.mouse.down();
- await expect(overlay).toHaveCSS("cursor", "grabbing");
- await page.mouse.move(origin[0] + 40 + 300 * scale, origin[1] + 30, {
- steps: 8,
- });
- const preview = (await state()).scene;
- await page.mouse.up();
- expect((await state()).scene).toEqual(preview);
- expect((await state()).history.undoCount).toBe(
- edited.history.undoCount + 1,
- );
- expect((await readImage(page)).center).toEqual(before.center);
- await page.keyboard.press("ControlOrMeta+z");
- expect((await state()).scene).toEqual(edited.scene);
- await expect(
- page.getByLabel("Radial right radius", { exact: true }),
- ).toHaveCSS("cursor", "ew-resize");
- await expect(
- page.getByLabel("Rotate radial gradient", { exact: true }),
- ).toHaveCSS("cursor", /url/);
- const radius = await box(
- page.getByLabel("Radial right radius", { exact: true }),
- );
await drag(
page,
- [radius.x + radius.width / 2, radius.y + radius.height / 2],
- [radius.x + radius.width / 2 - 60, radius.y + radius.height / 2],
+ [center[0] + 40, center[1] + 30],
+ [center[0] + 40 + 300 * scale, center[1] + 30],
);
- expect((await state()).scene).not.toEqual(edited.scene);
+ expect((await readImage(page)).center).toEqual(before.center);
await page.keyboard.press("ControlOrMeta+z");
- const options = page.getByRole("group", { name: "Layer options" });
- await expect(
- options.getByRole("slider", { name: "Opacity", exact: true }),
- ).toBeVisible();
- await expect(
- options.getByRole("slider", { name: "Feather", exact: true }),
- ).toBeVisible();
- await expect(
- options.getByRole("textbox", { name: "Feather", exact: true }),
- ).toBeVisible();
- const panel = page.getByRole("region", { name: "Editor controls" });
- await expect(
- panel.getByRole("heading", { name: "Mask adjustments", exact: true }),
- ).toBeVisible();
- await expect(
- panel.getByRole("textbox", { name: "Feather", exact: true }),
- ).toHaveCount(0);
- await setField("Feather", "80");
- await page.getByRole("button", { name: "Undo", exact: true }).click();
- await expect(
- page.getByRole("textbox", { name: "Feather", exact: true }),
- ).toHaveValue("50");
- const rotation = await box(
- page.getByLabel("Rotate radial gradient", { exact: true }),
- );
+ const radius = await box(page.getByLabel("Radial right radius"));
+ const [x, y] = [radius.x + radius.width / 2, radius.y + radius.height / 2];
+ await drag(page, [x, y], [x - 120 * scale, y]);
+ const rotation = await box(page.getByLabel("Rotate radial gradient"));
await drag(
page,
[rotation.x + rotation.width / 2, rotation.y + rotation.height / 2],
- [origin[0] + 150 * scale, origin[1]],
+ [center[0] + 150 * scale, center[1]],
);
- const rotated = (await state()).scene?.layers.at(-1);
- expect(
- rotated?.kind === "mask" &&
- rotated.mask.kind === "radial" &&
- Math.abs(rotated.mask.angle - 90) < 1,
- ).toBe(true);
- await page.keyboard.press("ControlOrMeta+z");
- await page
- .getByRole("button", { name: "Radial Gradient actions", exact: true })
- .click();
- await page
- .getByRole("menuitem", { name: "Subtract from mask", exact: true })
- .click();
- await page
- .getByRole("menuitem", { name: "Radial gradient", exact: true })
- .click();
- await drag(page, origin, [
- origin[0] + 220 * scale,
- origin[1] + 120 * scale,
- ]);
- expect((await readImage(page)).center).toEqual(before.center);
- await page.keyboard.press("Delete");
- expect((await readImage(page)).center[0]).toBeGreaterThan(
- before.center[0] + 20,
- );
- await page.keyboard.press("ControlOrMeta+z");
- expect((await readImage(page)).center).toEqual(before.center);
+ await setField("Feather", "80");
+ const radial = await radialMask();
+ expect(radial).toMatchObject({
+ angle: expect.closeTo(90, 0),
+ feather: 0.8,
+ });
+ expect(radial.radius[0]).toBeLessThan(radial.radius[1]);
});
- await test.step("guide clicks and mobile drawing keep the preview stable", async () => {
- await page
- .getByRole("button", { name: "Select Radial Gradient", exact: true })
- .first()
- .click();
- await page.getByRole("button", { name: "Zoom in", exact: true }).click();
- const zoom = page.getByRole("button", { name: /^\d+%$/ });
- const percent = await zoom.innerText();
- await page.getByLabel("Move gradient", { exact: true }).dblclick();
- await expect(zoom).toHaveText(percent);
- await zoom.click();
- // At fit the percentage zooms to one image pixel per device pixel, then fits again.
- const fitted = await zoom.innerText();
- await page.mouse.move(0, 0);
- await zoom.hover();
- await expect(page.getByText("Zoom to 100%", { exact: true })).toBeVisible();
- await zoom.click();
- await expect(zoom).toHaveText("100%");
- await zoom.click();
- await expect(zoom).toHaveText(fitted);
- await page.setViewportSize({ width: 390, height: 844 });
- await page.getByRole("tab", { name: "Layers", exact: true }).click();
+ await test.step("Shift draws a circle, and a guide's double click keeps the zoom", async () => {
await page.getByRole("button", { name: "photo.svg", exact: true }).click();
await page.keyboard.press("r");
- await expect(overlay).toHaveCSS("cursor", "crosshair");
- const view = await box(overlay);
- const x = view.x + view.width / 2,
- y = view.y + view.height / 2;
- await page.mouse.move(x, y);
+ await page.mouse.move(center[0], center[1]);
await page.mouse.down();
await page.keyboard.down("Shift");
- await page.mouse.move(x + 65, y + 35);
- const pin = page.getByLabel("Move gradient", { exact: true });
- const drawn = await box(pin);
+ await page.mouse.move(center[0] + 65, center[1] + 35);
await page.keyboard.up("Shift");
await page.mouse.up();
- expect(await box(pin)).toEqual(drawn);
- const result = await state();
- const layer = result.scene?.layers.find(
- (item) => item.id === result.selectedLayerId,
- );
- expect(
- layer?.kind === "mask" &&
- layer.mask.kind === "radial" &&
- layer.mask.radius[0] === layer.mask.radius[1],
- ).toBe(true);
+ const { radius } = await radialMask();
+ expect(radius[0]).toBe(radius[1]);
+ const zoom = page.getByRole("button", { name: /^\d+%$/ });
+ const fitted = await zoom.innerText();
+ // At fit the percentage zooms to one image pixel per device pixel, then fits again.
+ await zoom.click();
+ await page.getByLabel("Move gradient", { exact: true }).dblclick();
+ await expect(zoom).toHaveText("100%");
+ await zoom.click();
+ await expect(zoom).toHaveText(fitted);
});
});
diff --git a/tests/layers.test.ts b/tests/layers.test.ts
index cae4376..fb0979b 100644
--- a/tests/layers.test.ts
+++ b/tests/layers.test.ts
@@ -13,7 +13,6 @@ import {
import { createImageSource } from "@/core/image";
import { imageFrame } from "@/core/image/frame";
import { setExposure } from "@/features/adjustments/edits";
-import { layerDrop } from "@/features/layers/drop";
import {
addLayer,
deleteLayer,
@@ -26,179 +25,131 @@ import { defaultGradient } from "@/features/layers/gradient";
test("nested layers compose in order, move atomically, and duplicate with independent IDs", async () => {
const gpu = await init();
- const source = createImageSource(
- target(gpu, { size: [32, 16], format: "rgba16float" }),
- );
+ const image = target(gpu, { size: [32, 16], format: "rgba16float" });
+ const source = createImageSource(image);
const resources = createResources();
const sourceId = resources.add(new File([], "photo.png"), source);
- const document = createDocument(
- {
- frame: imageFrame(source.image.size),
- layers: [{ ...createImageLayer(sourceId, "Photo"), id: "base" }],
- },
- resources,
- );
+ const base = { ...createImageLayer(sourceId, "Photo"), id: "base" };
+ const frame = imageFrame(image.size);
+ const document = createDocument({ frame, layers: [base] }, resources);
const workspace = createWorkspace();
await workspace.open("photo.png", async () => document);
const controls = createControls(gpu, workspace);
const renderer = createEditorRenderer(gpu, source);
- try {
- const original = document.scene.getState();
- controls.beginEdit();
- controls.setAdjustments({ exposure: 1 });
- controls.setColorMixer("blue", { saturation: -20 });
- expect(() => controls.setToneCurve([])).toThrow();
- controls.cancelEdit();
- expect(document.scene.getState()).toEqual(original);
- expect(document.history.status.getState()).toEqual({
- undoCount: 0,
- redoCount: 0,
- editing: false,
- });
- expect(document.selection.getState().layerId).toBe("base");
- controls.setVignette({ softness: 75 });
- expect(document.scene.getState().layers[1]).toMatchObject({
- vignette: { intensity: 50, softness: 75 },
- });
- controls.undo();
- for (const field of ["center", "size", "scale"]) {
- for (const value of [[8], [8, 8, 8], [], [8, NaN], null]) {
- expect(() =>
- Reflect.apply(controls.setFrame, undefined, [
- { ...original.frame, [field]: value },
- ]),
- ).toThrow("Invalid image frame");
- }
- }
- const size: [number, number] = [8, 8];
- const frame = { ...original.frame, size };
- controls.setFrame(frame);
- const cropped = document.scene.getState();
- frame.size[0] = 99;
- expect(cropped.frame.size).toEqual([8, 8]);
- controls.setFrame(structuredClone(cropped.frame));
- expect(document.scene.getState()).toBe(cropped);
- const defaultMask = controls.addLayer("mask");
- expect(
- findLayer(document.scene.getState().layers, defaultMask),
- ).toMatchObject({ mask: { start: [6.4, 8], end: [25.6, 8] } });
- controls.undo();
- controls.undo();
- const mask = addLayer(document, createMask(defaultGradient([32, 16])));
- const exposure = addLayer(document, createLayer("exposure"), {
- inside: mask,
- });
- const vignette = addLayer(document, createLayer("vignette"), {
- inside: mask,
- });
- expect(document.scene.getState().layers[0]).toBe(original.layers[0]);
- const unchangedScene = document.scene.getState();
- document.edit(structuredClone(unchangedScene));
- expect(document.scene.getState()).toBe(unchangedScene);
- document.history.begin();
- setExposure(document, exposure, 2);
- setExposure(document, exposure, 3);
- document.selectLayer("base");
- document.history.undo();
- expect(findLayer(document.scene.getState().layers, exposure)).toMatchObject(
- { exposure: 1 },
- );
- expect(document.selection.getState().layerId).toBe("base");
- await renderer.update(document.scene.getState());
- expect(renderer.inspect().passes).toEqual([
- `layer/${exposure}/exposure`,
- `layer/${vignette}/vignette`,
- `layer/${mask}/mix`,
- ]);
- const calls = getMockGPUDeviceInstrumentation(gpu.gpu).calls;
- const compiled = calls.createRenderPipeline;
- setLayer(document, mask, { visible: false });
- await renderer.update(document.scene.getState());
- expect(renderer.inspect().passes).toEqual([]);
- setLayer(document, mask, { visible: true, opacity: 0.5 });
- await renderer.update(document.scene.getState());
- expect(calls.createRenderPipeline).toBe(compiled);
- const duplicate = duplicateLayer(document, mask);
- const copy = findLayer(document.scene.getState().layers, duplicate);
- expect(copy?.children.map((layer) => layer.kind)).toEqual([
- "exposure",
- "vignette",
- ]);
- const ids = Array.from(
- walkLayers(document.scene.getState().layers),
- ({ layer }) => layer.id,
- );
- expect(new Set(ids).size).toBe(ids.length);
- moveLayer(document, exposure, 1);
- expect(document.scene.getState().layers[1].id).toBe(exposure);
- expect(
- findLayer(document.scene.getState().layers, mask)?.children.map(
- (layer) => layer.id,
- ),
- ).toEqual([vignette]);
- document.history.undo();
- expect(
- findLayer(document.scene.getState().layers, mask)?.children[0].id,
- ).toBe(exposure);
- const unchanged = document.scene.getState();
+ const scene = () => document.scene.getState();
+ const find = (id: string) => findLayer(scene().layers, id);
+ const childIds = (id: string) => find(id)?.children.map((layer) => layer.id);
+ const original = scene();
+ controls.beginEdit();
+ controls.setAdjustments({ exposure: 1 });
+ controls.setColorMixer("blue", { saturation: -20 });
+ expect(() => controls.setToneCurve([])).toThrow();
+ controls.cancelEdit();
+ expect(scene()).toEqual(original);
+ expect(document.history.status.getState().undoCount).toBe(0);
+ controls.setVignette({ softness: 75 });
+ expect(scene().layers[1]).toMatchObject({
+ vignette: { intensity: 50, softness: 75 },
+ });
+ controls.undo();
+ for (const change of [{ size: [] }, { center: [8, NaN] }, { angle: NaN }]) {
expect(() =>
- addLayer(document, createLayer("vignette"), { inside: exposure }),
- ).toThrow("two levels");
- expect(() => moveLayer(document, mask, 0, exposure)).toThrow("itself");
- expect(() => moveLayer(document, exposure, 0, "base")).toThrow("image");
- expect(
- layerDrop(document.scene.getState(), {
- id: exposure,
- target: "base",
- position: "inside",
- }),
- ).toBeUndefined();
- expect(() => moveLayer(document, exposure, 0)).toThrow("position");
- expect(() =>
- setLayerMask(document, mask, {
- kind: "linear",
- start: [0, 0],
- end: [0, 0],
- }),
- ).toThrow("distinct");
- expect(() => setExposure(document, exposure, NaN)).toThrow("Exposure");
- expect(() => deleteLayer(document, "base")).toThrow("unavailable");
- expect(document.scene.getState()).toBe(unchanged);
- const added = addLayer(document, createLayer("vignette"), {
- above: exposure,
- });
- expect(
- findLayer(document.scene.getState().layers, mask)?.children.map(
- (layer) => layer.id,
- ),
- ).toEqual([exposure, added, vignette]);
- const top = addLayer(document, createLayer("vignette"));
- expect(document.scene.getState().layers.at(-1)?.id).toBe(top);
- expect(() =>
- addLayer(document, createLayer("vignette"), { above: "missing" }),
- ).toThrow("unavailable");
- document.history.undo();
- document.history.undo();
- expect(document.scene.getState()).toBe(unchanged);
- document.selectLayer(exposure);
- await renderer.update(document.scene.getState());
- const retained = renderer.inspect().effects;
- deleteLayer(document, mask);
- // A deleted layer's passes, and those of its children, leave with it; its duplicate keeps its own.
- await renderer.update(document.scene.getState());
- const { effects, passes } = renderer.inspect();
- expect(effects).toBeLessThan(retained);
- expect(effects).toBe(passes.length);
- expect(document.selection.getState().layerId).toBe("base");
- expect(
- findLayer(document.scene.getState().layers, exposure),
- ).toBeUndefined();
- document.history.undo();
- expect(findLayer(document.scene.getState().layers, exposure)).toBeDefined();
- expect(renderer.outputImage().format).toBe("rgba16float");
- } finally {
- renderer.dispose();
- workspace.dispose();
- gpu.dispose();
+ Reflect.apply(controls.setFrame, undefined, [{ ...frame, ...change }]),
+ ).toThrow("Invalid image frame");
}
+ expect(scene().frame).toBe(original.frame);
+ const crop = { ...frame, size: [8, 8] as [number, number] };
+ controls.setFrame(crop);
+ const cropped = scene();
+ crop.size[0] = 99;
+ expect(cropped.frame.size).toEqual([8, 8]);
+ // An edit equal in value keeps the scene.
+ controls.setFrame(structuredClone(cropped.frame));
+ expect(scene()).toBe(cropped);
+ // A new mask's gradient spans the cropped frame.
+ expect(find(controls.addLayer("mask"))).toMatchObject({
+ mask: { start: [6.4, 8], end: [25.6, 8] },
+ });
+ controls.undo();
+ controls.undo();
+ const mask = addLayer(document, createMask(defaultGradient([32, 16])));
+ const inside = { inside: mask };
+ const exposure = addLayer(document, createLayer("exposure"), inside);
+ const vignette = addLayer(document, createLayer("vignette"), inside);
+ expect(scene().layers[0]).toBe(original.layers[0]);
+ document.history.begin();
+ setExposure(document, exposure, 2);
+ setExposure(document, exposure, 3);
+ document.selectLayer("base");
+ document.history.undo();
+ expect(find(exposure)).toMatchObject({ exposure: 1 });
+ expect(document.selection.getState().layerId).toBe("base");
+ await renderer.update(scene());
+ expect(renderer.inspect().passes).toEqual([
+ `layer/${exposure}/exposure`,
+ `layer/${vignette}/vignette`,
+ `layer/${mask}/mix`,
+ ]);
+ const calls = getMockGPUDeviceInstrumentation(gpu.gpu).calls;
+ const compiled = calls.createRenderPipeline;
+ setLayer(document, mask, { visible: false });
+ await renderer.update(scene());
+ expect(renderer.inspect().passes).toEqual([]);
+ setLayer(document, mask, { visible: true, opacity: 0.5 });
+ await renderer.update(scene());
+ expect(calls.createRenderPipeline).toBe(compiled);
+ const duplicate = duplicateLayer(document, mask);
+ expect(find(duplicate)?.children.map((layer) => layer.kind)).toEqual([
+ "exposure",
+ "vignette",
+ ]);
+ const ids = Array.from(walkLayers(scene().layers), ({ layer }) => layer.id);
+ expect(new Set(ids).size).toBe(ids.length);
+ moveLayer(document, exposure, 1);
+ expect(scene().layers[1].id).toBe(exposure);
+ expect(childIds(mask)).toEqual([vignette]);
+ document.history.undo();
+ expect(childIds(mask)).toEqual([exposure, vignette]);
+ const unchanged = scene();
+ expect(() =>
+ addLayer(document, createLayer("vignette"), { inside: exposure }),
+ ).toThrow("two levels");
+ expect(() => moveLayer(document, mask, 0, exposure)).toThrow("itself");
+ expect(() => moveLayer(document, exposure, 0, "base")).toThrow("image");
+ expect(() => moveLayer(document, exposure, 0)).toThrow("position");
+ expect(() =>
+ setLayerMask(document, mask, {
+ kind: "linear",
+ start: [0, 0],
+ end: [0, 0],
+ }),
+ ).toThrow("distinct");
+ expect(() => setExposure(document, exposure, NaN)).toThrow("Exposure");
+ expect(() => deleteLayer(document, "base")).toThrow("unavailable");
+ expect(scene()).toBe(unchanged);
+ const added = addLayer(document, createLayer("vignette"), {
+ above: exposure,
+ });
+ expect(childIds(mask)).toEqual([exposure, added, vignette]);
+ const top = addLayer(document, createLayer("vignette"));
+ expect(scene().layers.at(-1)?.id).toBe(top);
+ expect(() =>
+ addLayer(document, createLayer("vignette"), { above: "missing" }),
+ ).toThrow("unavailable");
+ document.selectLayer(exposure);
+ await renderer.update(scene());
+ const retained = renderer.inspect().effects;
+ deleteLayer(document, mask);
+ // A deleted layer's passes, and those of its children, leave with it; its duplicate keeps its own.
+ await renderer.update(scene());
+ const { effects, passes } = renderer.inspect();
+ expect(effects).toBeLessThan(retained);
+ expect(effects).toBe(passes.length);
+ expect(document.selection.getState().layerId).toBe("base");
+ expect(find(exposure)).toBeUndefined();
+ document.history.undo();
+ expect(find(exposure)).toBeDefined();
+ renderer.dispose();
+ workspace.dispose();
+ gpu.dispose();
});
diff --git a/tests/layout.e2e.ts b/tests/layout.e2e.ts
index 9957927..0238138 100644
--- a/tests/layout.e2e.ts
+++ b/tests/layout.e2e.ts
@@ -1,68 +1,28 @@
-import { expect, test } from "./fixtures";
-import { box, drag } from "./pointer";
+import { expect, openPhoto, test } from "./fixtures";
+import { box } from "./pointer";
test("edit on a phone and carry the canvas across the breakpoint", async ({
page,
}) => {
- const state = () => page.evaluate(() => window.openlight.getState());
const canvas = page.getByRole("region", { name: "Image canvas" });
+ const layers = page.getByRole("region", { name: "Layers", exact: true });
await page.setViewportSize({ width: 1280, height: 800 });
- await page.goto("/");
- await page
- .locator('input[type="file"]')
- .setInputFiles("tests/fixtures/photo.svg");
- await expect(
- page.getByRole("textbox", { name: "Exposure", exact: true }),
- ).toHaveValue("0.00");
+ await openPhoto(page);
await test.step("the canvas stays mounted while the layout switches", async () => {
await canvas.locator("canvas").evaluate((element) => {
element.dataset.mounted = "";
});
await page.setViewportSize({ width: 390, height: 844 });
- await expect(page.getByRole("tab", { name: "Layers" })).toBeVisible();
- await expect(
- page.getByRole("region", { name: "Layers", exact: true }),
- ).toHaveCount(0);
+ await expect(layers).toHaveCount(0);
await expect(canvas.locator("canvas[data-mounted]")).toHaveCount(1);
await page.setViewportSize({ width: 1280, height: 800 });
- await expect(
- page.getByRole("region", { name: "Layers", exact: true }),
- ).toBeVisible();
+ await expect(layers).toBeVisible();
await expect(canvas.locator("canvas[data-mounted]")).toHaveCount(1);
await page.setViewportSize({ width: 390, height: 844 });
});
- await test.step("a drag on a dial is one edit", async () => {
- const contrast = page.getByRole("slider", {
- name: "Contrast",
- exact: true,
- });
- await expect(contrast).toBeVisible();
- const bounds = await box(contrast);
- const y = bounds.y + 20;
- await drag(
- page,
- [bounds.x + bounds.width / 2, y],
- [bounds.x + bounds.width / 2 + 60, y],
- );
- expect((await state()).adjustments.contrast).toBe(20);
- await page.getByRole("button", { name: "Undo" }).click();
- expect((await state()).adjustments.contrast).toBe(0);
- });
-
- await test.step("a tapped dial takes a typed value", async () => {
- await page.getByRole("slider", { name: "Exposure", exact: true }).click();
- const field = page.getByRole("textbox", { name: "Exposure", exact: true });
- await field.click();
- await field.fill("0.5");
- await field.press("Enter");
- expect((await state()).adjustments.exposure).toBe(0.5);
- await page.getByRole("button", { name: "Done", exact: true }).click();
- await expect(field).toHaveCount(0);
- });
-
- await test.step("the stack is a tab, and an effect's dials follow the selection", async () => {
+ await test.step("tabs switch the dock between the stack, dials, and crop", async () => {
await page.getByRole("tab", { name: "Layers" }).click();
await page.getByRole("button", { name: "Add effect", exact: true }).click();
await page.getByRole("menuitem", { name: "Details", exact: true }).click();
@@ -70,34 +30,58 @@ test("edit on a phone and carry the canvas across the breakpoint", async ({
await expect(
page.getByRole("slider", { name: "Clarity", exact: true }),
).toBeVisible();
- });
-
- await test.step("a crop is chosen and applied from the dock", async () => {
await page.getByRole("tab", { name: "Crop" }).click();
- // On a 3:2 photo, Original and 3:2 match, but only the one chosen shows.
- const chosen = page
- .getByRole("group", { name: "Aspect ratio" })
- .locator('[aria-pressed="true"]');
- await expect(chosen).toHaveText(["Original"]);
await page.getByRole("button", { name: "Square", exact: true }).click();
- await expect(chosen).toHaveText(["Square"]);
await page.getByRole("button", { name: "Apply", exact: true }).click();
- const [width, height] = (await state()).frame?.size ?? [];
- expect(width).toBe(height);
- await expect(
- page.getByRole("slider", { name: "Clarity", exact: true }),
- ).toBeVisible();
+ await expect
+ .poll(() => page.evaluate(() => window.openlight.getState().frame?.size))
+ .toEqual([800, 800]);
});
+});
- await test.step("tool options move from the canvas bar to the dock", async () => {
- await page.getByRole("tab", { name: "Brush" }).click();
- await expect(
- page.getByRole("slider", { name: "Size", exact: true }),
- ).toBeVisible();
- await expect(
- page.getByRole("region", { name: "Image canvas" }).getByRole("group", {
- name: "Brush mode",
- }),
- ).toHaveCount(0);
+test.describe("on a touch phone", () => {
+ test.use({
+ viewport: { width: 390, height: 844 },
+ isMobile: true,
+ hasTouch: true,
+ deviceScaleFactor: 2,
+ });
+
+ test("dials take a finger's drag as one edit, and a double tap resets", async ({
+ page,
+ context,
+ }) => {
+ await page.goto("/");
+ await page
+ .locator('input[type="file"]')
+ .setInputFiles("tests/fixtures/photo.svg");
+ const exposure = page.getByRole("slider", {
+ name: "Exposure",
+ exact: true,
+ });
+ await expect(exposure).toHaveAttribute("aria-valuetext", "0.00");
+ const bounds = await box(exposure);
+ const [x, y] = [bounds.x + bounds.width / 2, bounds.y + 20];
+ const touch = await context.newCDPSession(page);
+ const send = (type: "touchStart" | "touchMove" | "touchEnd", at = [x]) =>
+ touch.send("Input.dispatchTouchEvent", {
+ type,
+ touchPoints: type === "touchEnd" ? [] : at.map((x) => ({ x, y })),
+ });
+ await send("touchStart");
+ for (let step = 1; step <= 6; step++) {
+ await send("touchMove", [x + step * 10]);
+ }
+ await send("touchEnd");
+ // Sixty pixels sweep a tenth of the range.
+ await expect(exposure).toHaveAttribute("aria-valuetext", "1.00");
+ await page.touchscreen.tap(x, y);
+ await page.touchscreen.tap(x, y);
+ await expect(exposure).toHaveAttribute("aria-valuetext", "0.00");
+ const undo = page.getByRole("button", { name: "Undo", exact: true });
+ await undo.tap();
+ await expect(exposure).toHaveAttribute("aria-valuetext", "1.00");
+ await undo.tap();
+ await expect(exposure).toHaveAttribute("aria-valuetext", "0.00");
});
});
diff --git a/tests/loaders.e2e.ts b/tests/loaders.e2e.ts
index 812441a..eba492a 100644
--- a/tests/loaders.e2e.ts
+++ b/tests/loaders.e2e.ts
@@ -1,78 +1,42 @@
-import { readFile } from "node:fs/promises";
-import { expect, test } from "./fixtures";
+import { expect, openPhoto, test } from "./fixtures";
import { readImage } from "./images";
-import { choose } from "./pointer";
-test("decode an image, apply XMP, recover from failure, and replace a document during export", async ({
+test("a photo takes XMP settings, survives a failed open, and exports while another replaces it", async ({
page,
}) => {
- await page.goto("/");
- await page.waitForFunction(() => window.openlight);
- await page.evaluate(() =>
- window.openlight.loadImage(new File(["invalid"], "broken.png")),
- );
- await expect(
- page.getByText("Couldn't open broken.png:", { exact: false }),
- ).toBeVisible();
- await page.evaluate(
- (text) =>
- window.openlight.loadImage(
- new File([text], "photo.svg", { type: "image/svg+xml" }),
- ),
- await readFile("tests/fixtures/photo.svg", "utf8"),
- );
- const baseline = await readImage(page);
- expect(baseline.center).toEqual([128, 128, 128, 255]);
- await page.evaluate(() =>
- window.openlight.importXmp(
- new File(
- [
- '<rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"><rdf:Description xmlns:crs="http://ns.adobe.com/camera-raw-settings/1.0/" crs:Exposure2012="-1" /></rdf:RDF>',
- ],
- "photo.xmp",
- ),
+ const state = () => page.evaluate(() => window.openlight.getState());
+ await openPhoto(page);
+ expect((await readImage(page)).center).toEqual([128, 128, 128, 255]);
+ const chooser = page.waitForEvent("filechooser");
+ await page.getByRole("button", { name: "Open an image or scene" }).click();
+ await (await chooser).setFiles({
+ name: "photo.xmp",
+ mimeType: "",
+ buffer: Buffer.from(
+ '<rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"><rdf:Description xmlns:crs="http://ns.adobe.com/camera-raw-settings/1.0/" crs:Exposure2012="-1" /></rdf:RDF>',
),
- );
+ });
await expect(
page.getByRole("textbox", { name: "Exposure", exact: true }),
).toHaveValue("-1.00");
- const expected = await readImage(page);
- expect(expected.center[0]).toBeLessThan(baseline.center[0]);
- // A file that fails to open leaves the edited document open, with the failure beside it.
- const kept = await page.evaluate(() => window.openlight.getState());
+ const edited = await readImage(page);
+ expect(edited.center[0]).toBeLessThan(128);
+
+ const { documentId } = await state();
await page.evaluate(() =>
window.openlight.loadImage(new File(["invalid"], "broken.png")),
);
- const failure = page.getByText("Couldn't open broken.png:", {
- exact: false,
- });
+ const failure = page.getByText("Couldn't open broken.png:", { exact: false });
await expect(failure).toBeVisible();
- const afterFailure = await page.evaluate(() => window.openlight.getState());
- expect(afterFailure.documentId).toBe(kept.documentId);
- expect(afterFailure.failure?.file).toBe("broken.png");
- expect(afterFailure.adjustments.exposure).toBe(-1);
+ expect(await state()).toMatchObject({
+ documentId,
+ failure: { file: "broken.png" },
+ adjustments: { exposure: -1 },
+ });
await page.getByRole("button", { name: "Dismiss", exact: true }).click();
await expect(failure).toBeHidden();
- const before = await page.evaluate(() => window.openlight.getState());
- await page.evaluate(() => {
- const frame = window.openlight.getState().frame;
- if (!frame) throw new Error("Missing loaded frame");
- frame.angle = 30;
- Reflect.set(frame.center, 0, 0);
- });
- expect(
- (await page.evaluate(() => window.openlight.getState())).frame,
- ).toEqual(before.frame);
- await page.evaluate(() => window.openlight.undo());
- expect(await readImage(page)).toEqual(baseline);
- await page.evaluate(() => window.openlight.redo());
- expect(await readImage(page)).toEqual(expected);
- await page.getByRole("tab", { name: "Crop" }).click();
- await choose(
- page,
- page.getByRole("combobox", { name: "Aspect ratio" }),
- "Square",
- );
+
+ // Export renders the scene it captured, even when another image opens before it encodes.
const exported = await page.evaluate(async () => {
const api = window.openlight;
const convert = OffscreenCanvas.prototype.convertToBlob;
@@ -100,15 +64,10 @@ test("decode an image, apply XMP, recover from failure, and replace a document d
OffscreenCanvas.prototype.convertToBlob = convert;
}
});
- expect(await readImage(page, new Uint8Array(exported))).toEqual(expected);
- const replaced = await page.evaluate(() => window.openlight.getState());
- await expect(page.getByRole("region", { name: "Crop tool" })).toBeHidden();
- expect(replaced.frame?.size).toEqual([32, 32]);
- expect(replaced.documentId).not.toBe(before.documentId);
- expect(replaced.history).toEqual({
- undoCount: 0,
- redoCount: 0,
- editing: false,
+ expect(await readImage(page, new Uint8Array(exported))).toEqual(edited);
+ expect(await state()).toMatchObject({
+ size: [32, 32],
+ adjustments: { exposure: 0 },
+ history: { undoCount: 0 },
});
- expect(replaced.adjustments.exposure).toBe(0);
});
diff --git a/tests/loaders.test.ts b/tests/loaders.test.ts
index 799ab82..53788f1 100644
--- a/tests/loaders.test.ts
+++ b/tests/loaders.test.ts
@@ -43,152 +43,108 @@ test("file batches preserve ordering, group imports, recover from failures, and
[xmp, image],
() => workspace.state.getState().status === "ready",
);
+ const layers = () => workspace.getDocument().scene.getState().layers;
+ const adjustments = () => layers()[0].adjustments;
const photo = new File([], "photo.png");
+ const broken = new File([], "broken.png");
const exposure = settings('crs:Exposure2012="1.25"');
- try {
- await registry.openFiles([new File([], "notes.txt"), exposure]);
- expect(workspace.state.getState()).toEqual({ status: "empty" });
- for (const settingsFirst of [true, false]) {
- const parameters = settings(
- 'crs:Exposure2012="1.25" crs:Contrast2012="-20" crs:Highlights2012="-50" crs:Shadows2012="50" crs:Whites2012="25" crs:Blacks2012="-25" crs:Vibrance="30" crs:Saturation="-10"',
- settingsFirst ? "photo.xml" : "photo.xmp",
- );
- const images = [photo, new File([], "broken.png")];
- await registry.openFiles(
- settingsFirst ? [parameters, ...images] : [...images, parameters],
- );
- const document = workspace.getDocument();
- expect(workspace.state.getState().file).toBe("photo.png");
- const imported = {
- ...defaultAdjustments,
- exposure: 1.25,
- contrast: -20,
- highlights: -50,
- shadows: 50,
- whites: 25,
- blacks: -25,
- vibrance: 30,
- saturation: -10,
- };
- expect(document.scene.getState().layers[0].adjustments).toEqual(imported);
- await registry.openFiles([
- settings('crs:Exposure2012="3"'),
- settings('crs:Exposure2012="-1"'),
- ]);
- expect(document.scene.getState().layers[0].adjustments).toEqual({
- ...imported,
- exposure: -1,
- });
- document.history.undo();
- expect(document.scene.getState().layers[0].adjustments.exposure).toBe(3);
- document.history.redo();
- document.history.begin();
- setAdjustments(document, { contrast: 20 });
- setAdjustments(document, { contrast: 30 });
- await registry.openFiles([
- settings(
- 'crs:Highlights2012="0" crs:Shadows2012="0" crs:Whites2012="0" crs:Blacks2012="0"',
- ),
- ]);
- expect(document.history.status.getState()).toEqual({
- undoCount: 5,
- redoCount: 0,
- editing: false,
- });
- expect(document.scene.getState().layers[0].adjustments).toMatchObject({
- highlights: 0,
- shadows: 0,
- whites: 0,
- blacks: 0,
- });
- document.history.undo();
- expect(document.scene.getState().layers[0].adjustments).toEqual({
- ...imported,
- exposure: -1,
- contrast: 30,
- });
- document.history.undo();
- expect(document.scene.getState().layers[0].adjustments.contrast).toBe(
- -20,
- );
- }
- const document = workspace.getDocument();
- const maskId = addLayer(document, createMask(defaultGradient([32, 32])));
- addLayer(document, createLayer("details"), { inside: maskId });
- const beforeDetails = document.scene.getState();
- await xmp.load(settings('crs:Exposure2012="0.5" crs:Clarity2012="35"'));
- expect(document.scene.getState().layers[2]).toMatchObject({
- kind: "details",
- details: { clarity: 35 },
- });
- expect(document.scene.getState().layers[0].adjustments.exposure).toBe(0.5);
- expect(document.scene.getState().layers[1]).toBe(beforeDetails.layers[1]);
- document.history.undo();
- expect(document.scene.getState()).toEqual(beforeDetails);
- document.history.redo();
- await xmp.load(settings('crs:Clarity2012="0"'));
- expect(document.scene.getState().layers).toHaveLength(3);
- expect(document.scene.getState().layers[2]).toMatchObject({
- details: { clarity: 0 },
- });
- expect(document.scene.getState().layers[1]).toBe(beforeDetails.layers[1]);
- await Promise.all([
- registry.openFiles([exposure, new File([], "first.png")]),
- registry.openFiles([
- new File([], "second.png"),
- settings('crs:Contrast2012="20"'),
- ]),
- ]);
- expect(workspace.state.getState().file).toBe("second.png");
- expect(
- workspace.getDocument().scene.getState().layers[0].adjustments,
- ).toEqual({
- ...defaultAdjustments,
- contrast: 20,
- });
- // A failed replacement keeps the open document and skips the settings meant for the failed file.
- const kept = workspace.getDocument();
- const keptAdjustments = kept.scene.getState().layers[0].adjustments;
- await registry.openFiles([exposure, new File([], "broken.png")]);
- expect(workspace.getDocument()).toBe(kept);
- expect(workspace.state.getState()).toMatchObject({
- status: "ready",
- file: "second.png",
- failure: { file: "broken.png", error: "Error: Decode failed" },
- });
- expect(kept.scene.getState().layers[0].adjustments).toBe(keptAdjustments);
- workspace.dismissFailure();
- expect(workspace.state.getState()).not.toHaveProperty("failure");
- await registry.openFiles([exposure, photo]);
- const recovered = workspace.getDocument();
- expect(recovered.scene.getState().layers[0].adjustments.exposure).toBe(
- 1.25,
- );
- await expect(
- registry.openFiles([settings('crs:Exposure2012="99"')]),
- ).rejects.toThrow("Invalid adjustment");
- await registry.openFiles([
- settings('crs:Contrast2012="10" crs:Exposure2012="NaN"'),
- ]);
- expect(recovered.scene.getState().layers[0].adjustments).toEqual({
- ...defaultAdjustments,
- exposure: 1.25,
- contrast: 10,
- });
-
- // Hold file reading so replacement happens before the old import completes.
- const text = Promise.withResolvers<string>();
- const delayed = settings('crs:Exposure2012="4"');
- delayed.text = () => text.promise;
- const pending = xmp.load(delayed);
- await registry.loadFile(image, photo);
- text.resolve(await exposure.text());
- await pending;
- expect(workspace.getDocument()).not.toBe(recovered);
- expect(
- workspace.getDocument().scene.getState().layers[0].adjustments,
- ).toEqual(defaultAdjustments);
- } finally {
- workspace.dispose();
+ await registry.openFiles([new File([], "notes.txt"), exposure]);
+ expect(workspace.state.getState()).toEqual({ status: "empty" });
+ const imported = {
+ ...defaultAdjustments,
+ exposure: 1.25,
+ contrast: -20,
+ highlights: -50,
+ shadows: 50,
+ whites: 25,
+ blacks: -25,
+ vibrance: 30,
+ saturation: -10,
+ };
+ const all =
+ 'crs:Exposure2012="1.25" crs:Contrast2012="-20" crs:Highlights2012="-50" crs:Shadows2012="50" crs:Whites2012="25" crs:Blacks2012="-25" crs:Vibrance="30" crs:Saturation="-10"';
+ // Settings wait for the batch's first image, before or after them.
+ for (const batch of [
+ [settings(all, "photo.xml"), photo, broken],
+ [photo, broken, settings(all)],
+ ]) {
+ await registry.openFiles(batch);
+ expect(workspace.state.getState().file).toBe("photo.png");
+ expect(adjustments()).toEqual(imported);
}
+ const document = workspace.getDocument();
+ // Each settings file is its own undo step, and an import commits an open gesture first.
+ await registry.openFiles([
+ settings('crs:Exposure2012="3"'),
+ settings('crs:Exposure2012="-1"'),
+ ]);
+ document.history.undo();
+ expect(adjustments().exposure).toBe(3);
+ document.history.redo();
+ document.history.begin();
+ setAdjustments(document, { contrast: 20 });
+ setAdjustments(document, { contrast: 30 });
+ await registry.openFiles([settings('crs:Highlights2012="0"')]);
+ expect(adjustments().highlights).toBe(0);
+ document.history.undo();
+ expect(adjustments()).toEqual({ ...imported, exposure: -1, contrast: 30 });
+ document.history.undo();
+ expect(adjustments().contrast).toBe(-20);
+ const maskId = addLayer(document, createMask(defaultGradient([32, 32])));
+ addLayer(document, createLayer("details"), { inside: maskId });
+ const before = document.scene.getState();
+ // Clarity goes to a root Details layer, leaving the mask's own untouched.
+ await xmp.load(settings('crs:Exposure2012="0.5" crs:Clarity2012="35"'));
+ expect(layers()[2]).toMatchObject({ details: { clarity: 35 } });
+ expect(adjustments().exposure).toBe(0.5);
+ expect(layers()[1]).toBe(before.layers[1]);
+ document.history.undo();
+ expect(document.scene.getState()).toEqual(before);
+ document.history.redo();
+ await xmp.load(settings('crs:Clarity2012="0"'));
+ expect(layers()).toHaveLength(3);
+ expect(layers()[2]).toMatchObject({ details: { clarity: 0 } });
+ await Promise.all([
+ registry.openFiles([exposure, new File([], "first.png")]),
+ registry.openFiles([
+ new File([], "second.png"),
+ settings('crs:Contrast2012="20"'),
+ ]),
+ ]);
+ expect(workspace.state.getState().file).toBe("second.png");
+ expect(adjustments()).toEqual({ ...defaultAdjustments, contrast: 20 });
+ // A failed replacement keeps the open document and skips the settings meant for the failed file.
+ const kept = workspace.getDocument();
+ const keptAdjustments = adjustments();
+ await registry.openFiles([exposure, broken]);
+ expect(workspace.getDocument()).toBe(kept);
+ expect(workspace.state.getState()).toMatchObject({
+ status: "ready",
+ file: "second.png",
+ failure: { file: "broken.png", error: "Error: Decode failed" },
+ });
+ expect(adjustments()).toBe(keptAdjustments);
+ workspace.dismissFailure();
+ expect(workspace.state.getState()).not.toHaveProperty("failure");
+ await registry.openFiles([exposure, photo]);
+ const recovered = workspace.getDocument();
+ await expect(
+ registry.openFiles([settings('crs:Exposure2012="99"')]),
+ ).rejects.toThrow("Invalid adjustment");
+ await registry.openFiles([
+ settings('crs:Contrast2012="10" crs:Exposure2012="NaN"'),
+ ]);
+ expect(adjustments()).toMatchObject({ exposure: 1.25, contrast: 10 });
+
+ // Hold file reading so replacement happens before the old import completes.
+ const text = Promise.withResolvers<string>();
+ const delayed = settings('crs:Exposure2012="4"');
+ delayed.text = () => text.promise;
+ const pending = xmp.load(delayed);
+ await registry.loadFile(image, photo);
+ text.resolve(await exposure.text());
+ await pending;
+ expect(workspace.getDocument()).not.toBe(recovered);
+ expect(adjustments()).toEqual(defaultAdjustments);
+ workspace.dispose();
});
diff --git a/tests/paint.e2e.ts b/tests/paint.e2e.ts
index 3c3ad61..936d65e 100644
--- a/tests/paint.e2e.ts
+++ b/tests/paint.e2e.ts
@@ -1,21 +1,11 @@
import type { Page } from "@playwright/test";
-import { expect, test } from "./fixtures";
+import { expect, openPhoto, test } from "./fixtures";
import { readImage } from "./images";
import { box, choose, drag } from "./pointer";
const gray = [128, 128, 128, 255];
-/** Opens the gray test photo, 1200 × 800, in a wide window. */
-async function openPhoto(page: Page) {
- await page.setViewportSize({ width: 1440, height: 1000 });
- await page.goto("/");
- await page
- .locator('input[type="file"]')
- .setInputFiles("tests/fixtures/photo.svg");
- await expect(
- page.getByRole("textbox", { name: "Exposure", exact: true }),
- ).toHaveValue("0.00");
-}
+test.use({ viewport: { width: 1440, height: 1000 } });
const brushBar = (page: Page) =>
page.getByRole("group", { name: "Layer options" });
diff --git a/tests/pointer.ts b/tests/pointer.ts
index db281c5..f3b9dbd 100644
--- a/tests/pointer.ts
+++ b/tests/pointer.ts
@@ -20,6 +20,13 @@ export async function drag(
await page.mouse.up();
}
+/** Zooms the canvas under the pointer as a Control-wheel gesture does. */
+export async function zoom(page: Page, factor: number) {
+ await page.keyboard.down("Control");
+ await page.mouse.wheel(0, -Math.log(factor) * 100);
+ await page.keyboard.up("Control");
+}
+
/** Chooses from OpenLight's custom select surface through the visible UI. */
export async function choose(page: Page, select: Locator, option: string) {
await select.click();
diff --git a/tests/raw.e2e.ts b/tests/raw.e2e.ts
index e80f3f8..0520039 100644
--- a/tests/raw.e2e.ts
+++ b/tests/raw.e2e.ts
@@ -1,80 +1,38 @@
-import { readFile } from "node:fs/promises";
import { expect, test } from "./fixtures";
import { readImage, readPreview } from "./images";
-test("RAW Bayer and JPEG XL DNG preserve color, orientation, white balance, history and export", async ({
+function expectNear(actual: number[], expected: number[]) {
+ for (const [i, value] of expected.entries()) {
+ expect(Math.abs(actual[i] - value), `Channel ${i}`).toBeLessThanOrEqual(1);
+ }
+}
+
+test("Bayer and JPEG XL DNG files open in color and take white balance", async ({
page,
}) => {
await page.goto("/");
await page.waitForFunction(() => window.openlight);
- const load = async (name: string) => {
- const bytes = [...(await readFile(`tests/fixtures/raw/${name}`))];
- await page.evaluate(
- ({ bytes, name }) =>
- window.openlight.loadImage(
- new File([new Uint8Array(bytes)], name, { type: "image/tiff" }),
- ),
- { bytes, name },
- );
- };
for (const name of ["bayer.dng", "linear-jxl.dng"]) {
await test.step(name, async () => {
- await load(name);
+ await page.evaluate(
+ (url) => window.openlight.loadUrl(url),
+ `/tests/fixtures/raw/${name}`,
+ );
const image = await readImage(page);
expect(image.size).toEqual([96, 128]);
// The fixture's camera profile is sRGB with known linear samples .5, .25, .125.
- for (const [i, expected] of [188, 137, 99, 255].entries()) {
- expect(Math.abs(image.center[i] - expected)).toBeLessThanOrEqual(1);
- }
- const asShot = await page.evaluate(
- () => window.openlight.getState().whiteBalance,
- );
- expect(asShot?.temperature).toBeGreaterThan(6000);
- await expect(
- page.getByRole("slider", { name: "Temperature (K)", exact: true }),
- ).toBeVisible();
+ expectNear(image.center, [188, 137, 99, 255]);
await page.evaluate(() =>
window.openlight.setWhiteBalance({ temperature: 4000, tint: 20 }),
);
const cool = await readImage(page);
// Full SDK camera calibration, including its white-point normalization.
- for (const [i, expected] of [192, 161, 166, 255].entries()) {
- expect(Math.abs(cool.center[i] - expected)).toBeLessThanOrEqual(1);
- }
+ expectNear(cool.center, [192, 161, 166, 255]);
await expect
.poll(async () => (await readPreview(page)).center.slice(0, 3))
.toEqual(cool.center.slice(0, 3));
- await page.evaluate(() => window.openlight.undo());
- expect((await readImage(page)).center).toEqual(image.center);
- await page.evaluate(() => window.openlight.redo());
- expect((await readImage(page)).center).toEqual(cool.center);
await page.getByRole("button", { name: "As Shot", exact: true }).click();
- expect(
- await page.evaluate(() => window.openlight.getState().whiteBalance),
- ).toEqual(asShot);
expect((await readImage(page)).center).toEqual(image.center);
});
}
- // A renderer exporting a captured scene owns its source while the workspace replaces it.
- const bytes = [...(await readFile("tests/fixtures/raw/bayer.dng"))];
- const replacement = await page.evaluate(async (bytes) => {
- window.openlight.setWhiteBalance({ temperature: 4000, tint: 20 });
- const exporting = window.openlight.exportImage();
- await window.openlight.loadImage(
- new File([new Uint8Array(bytes)], "replacement.dng"),
- );
- const image = await createImageBitmap(await exporting);
- const size = [image.width, image.height];
- image.close();
- return size;
- }, bytes);
- expect(replacement).toEqual([96, 128]);
- await page.evaluate(() =>
- window.openlight.loadImage(new File(["invalid RAW"], "broken.dng")),
- );
- await expect(
- page.getByText("Couldn't open broken.dng:", { exact: false }),
- ).toBeVisible();
- await load("linear-jxl.dng");
- expect((await readImage(page)).size).toEqual([96, 128]);
});
diff --git a/tests/render-graph.test.ts b/tests/render-graph.test.ts
index 0f64bfc..9c68336 100644
--- a/tests/render-graph.test.ts
+++ b/tests/render-graph.test.ts
@@ -6,6 +6,7 @@ import {
merge,
node,
pipeline,
+ type RenderImage,
split,
} from "@/core/renderer";
@@ -18,6 +19,12 @@ const shader = `
}`;
const options = { storage: { weights: new Float32Array([0.5]) } };
+function mixed(image: RenderImage, name: string, extra = {}) {
+ return merge(
+ { source: image, base: image },
+ node(name, shader, { ...options, ...extra }),
+ );
+}
test("cached branches skip their dependencies, retain two revisions, and release owned results", async () => {
const gpu = await init();
const image = target(gpu, { size: [8, 8], format: "rgba16float" });
@@ -65,37 +72,35 @@ test("pipeline and split preserve order, bypasses, and named merge inputs", asyn
const gpu = await init();
const image = target(gpu, { size: [8, 4], format: "rgba16float" });
const source = input(image);
- try {
- const first = node("first", shader);
- const last = node("last", shader);
- const result = pipeline(source, [
- first,
- undefined,
- (image) => pipeline(image, [last]),
- ]);
- expect(result).toMatchObject({
- name: "last",
- inputs: { source: { name: "first", inputs: { source } } },
- });
- expect(pipeline(source, [undefined])).toBe(source);
- const [unchanged, small] = split(result, [
- [],
- [node("small", shader, { size: [2, 1] })],
- ]);
- expect(unchanged).toBe(result);
- expect(small).toMatchObject({ inputs: { source: result }, size: [2, 1] });
- const joined = merge({ base: source, source: small }, node("join", shader));
- expect(joined.inputs.base).toBe(source);
- expect(joined.inputs.source).toBe(small);
- expect(joined.size).toEqual([8, 4]);
- expect(joined.format).toBe("rgba16float");
- expect(
- getMockGPUDeviceInstrumentation(gpu.gpu).calls.createRenderPipeline ?? 0,
- ).toBe(0);
- } finally {
- image.color.dispose();
- gpu.dispose();
- }
+ const first = node("first", shader);
+ const last = node("last", shader);
+ const result = pipeline(source, [
+ first,
+ undefined,
+ (image) => pipeline(image, [last]),
+ ]);
+ expect(result).toMatchObject({
+ name: "last",
+ inputs: { source: { name: "first", inputs: { source } } },
+ });
+ expect(pipeline(source, [undefined])).toBe(source);
+ const [unchanged, small] = split(result, [
+ [],
+ [node("small", shader, { size: [2, 1] })],
+ ]);
+ expect(unchanged).toBe(result);
+ expect(small).toMatchObject({ inputs: { source: result }, size: [2, 1] });
+ const joined = merge({ base: source, source: small }, node("join", shader));
+ expect(joined).toMatchObject({
+ inputs: { base: source, source: small },
+ size: [8, 4],
+ format: "rgba16float",
+ });
+ expect(
+ getMockGPUDeviceInstrumentation(gpu.gpu).calls.createRenderPipeline ?? 0,
+ ).toBe(0);
+ image.color.dispose();
+ gpu.dispose();
});
test("a shared branch renders once and reuses effects, buffers, and temporary storage", async () => {
@@ -103,103 +108,67 @@ test("a shared branch renders once and reuses effects, buffers, and temporary st
const image = target(gpu, { size: [8, 8], format: "rgba16float" });
const source = input(image);
const graph = createRenderGraph(gpu);
- const shared = merge(
- { source, base: source },
- node("shared", shader, options),
- );
- const middle = merge(
- { source: shared, base: shared },
- node("middle", shader, options),
- );
- const branch = merge(
- { source: middle, base: middle },
- node("branch", shader, options),
- );
+ const shared = mixed(source, "shared");
+ const branch = mixed(mixed(shared, "middle"), "branch");
const joined = merge(
{ source: shared, base: branch },
node("join", shader, options),
);
const uploads = spyOn(gpu.gpu.queue, "writeBuffer");
- try {
- const [saved, output] = graph.render([shared, joined]);
- expect(output).not.toBe(saved);
- expect(uploads).toHaveBeenCalledTimes(4);
- expect(graph.inspect().passes).toEqual([
- "shared",
- "middle",
- "branch",
- "join",
- ]);
- expect(graph.inspect().textures).toHaveLength(3);
- const calls = getMockGPUDeviceInstrumentation(gpu.gpu).calls;
- const buffers = calls.createBuffer;
- const pipelines = calls.createRenderPipeline;
- expect(graph.render([shared, joined])).toEqual([saved, output]);
- expect(graph.render([joined, shared, joined])).toEqual([
- output,
- saved,
- output,
- ]);
- expect(calls.createBuffer).toBe(buffers);
- expect(calls.createRenderPipeline).toBe(pipelines);
- // A storage array uploads once while passes keep receiving it.
- expect(uploads).toHaveBeenCalledTimes(4);
- // Bypassing releases scratch storage.
- expect(graph.render([shared])[0]).toBe(saved);
- expect(graph.inspect().textures).toHaveLength(1);
- expect(() => output.color.view).toThrow("destroyed");
- const sized = (size: [number, number]) =>
- merge(
- { source, base: source },
- node("shared", shader, { ...options, size }),
- );
- // A proxy size and the full size alternate without reallocating; a third size lets the oldest go.
- const [proxy] = graph.render([sized([4, 4])]);
- expect(proxy.size).toEqual([4, 4]);
- expect(graph.inspect().textures).toHaveLength(2);
- expect(graph.render([shared])[0]).toBe(saved);
- expect(graph.render([sized([4, 4])])[0]).toBe(proxy);
- graph.render([sized([2, 2])]);
- expect(graph.inspect().textures).toHaveLength(2);
- expect(() => saved.color.view).toThrow("destroyed");
- // Removing a composition retires its cached effect so its name can be reused.
- graph.release("shared");
- const replacement = merge(
- { source, base: source },
- node("shared", shader.replace("weights[0]", "1.0 - weights[0]"), options),
- );
- expect(() => graph.render([replacement])).not.toThrow();
- graph.dispose();
- expect(() => saved.color.view).toThrow("destroyed");
- expect(() => image.color.view).not.toThrow();
- expect(() => graph.render([shared])).toThrow("closed");
- } finally {
- graph.dispose();
- image.color.dispose();
- gpu.dispose();
- }
-});
-
-test("passes with identical uniforms can share prepared binding state", async () => {
- const gpu = await init();
- const image = target(gpu, { size: [8, 8], format: "rgba16float" });
- const source = input(image);
- const graph = createRenderGraph(gpu);
- const first = merge(
+ const [saved, output] = graph.render([shared, joined]);
+ expect(output).not.toBe(saved);
+ expect(uploads).toHaveBeenCalledTimes(4);
+ expect(graph.inspect().passes).toEqual([
+ "shared",
+ "middle",
+ "branch",
+ "join",
+ ]);
+ expect(graph.inspect().textures).toHaveLength(3);
+ const calls = getMockGPUDeviceInstrumentation(gpu.gpu).calls;
+ const buffers = calls.createBuffer;
+ const pipelines = calls.createRenderPipeline;
+ expect(graph.render([joined, shared, joined])).toEqual([
+ output,
+ saved,
+ output,
+ ]);
+ expect(calls.createBuffer).toBe(buffers);
+ expect(calls.createRenderPipeline).toBe(pipelines);
+ // A storage array uploads once while passes keep receiving it.
+ expect(uploads).toHaveBeenCalledTimes(4);
+ // Bypassing releases scratch storage.
+ expect(graph.render([shared])[0]).toBe(saved);
+ expect(graph.inspect().textures).toHaveLength(1);
+ expect(() => output.color.view).toThrow("destroyed");
+ // A proxy size and the full size alternate without reallocating; a third size lets the oldest go.
+ const sized = (size: number) =>
+ mixed(source, "shared", { size: [size, size] });
+ const [proxy] = graph.render([sized(4)]);
+ expect(proxy.size).toEqual([4, 4]);
+ expect(graph.render([shared])[0]).toBe(saved);
+ expect(graph.render([sized(4)])[0]).toBe(proxy);
+ graph.render([sized(2)]);
+ expect(graph.inspect().textures).toHaveLength(2);
+ expect(() => saved.color.view).toThrow("destroyed");
+ // Removing a composition retires its cached effect so its name can be reused.
+ graph.release("shared");
+ const replacement = merge(
{ source, base: source },
- node("first", shader, { ...options, instance: "shared" }),
- );
- const second = merge(
- { source: first, base: source },
- node("second", shader, { ...options, instance: "shared" }),
+ node("shared", shader.replace("weights[0]", "1.0 - weights[0]"), options),
);
- try {
- graph.render([second]);
- expect(graph.inspect().passes).toEqual(["first", "second"]);
- expect(graph.inspect().effects).toBe(1);
- } finally {
- graph.dispose();
- image.color.dispose();
- gpu.dispose();
- }
+ expect(() => graph.render([replacement])).not.toThrow();
+ // Passes with identical uniforms share one prepared binding state.
+ const { effects } = graph.inspect();
+ const first = mixed(source, "first", { instance: "twin" });
+ graph.render([mixed(first, "second", { instance: "twin" })]);
+ expect(graph.inspect()).toMatchObject({
+ passes: ["first", "second"],
+ effects: effects + 1,
+ });
+ graph.dispose();
+ expect(() => image.color.view).not.toThrow();
+ expect(() => graph.render([shared])).toThrow("closed");
+ image.color.dispose();
+ gpu.dispose();
});
diff --git a/tests/renderer.test.ts b/tests/renderer.test.ts
index c1a067f..795ed17 100644
--- a/tests/renderer.test.ts
+++ b/tests/renderer.test.ts
@@ -32,10 +32,9 @@ test("RAW edits coalesce, recover from failure, and retain an exporting source a
const started = Promise.withResolvers<void>();
const close = mock(() => {});
const develop = mock(() => {
- const request = Promise.withResolvers<void>();
- requests.push(request);
+ requests.push(Promise.withResolvers<void>());
started.resolve();
- return request.promise;
+ return requests[requests.length - 1].promise;
});
const source = createImageSource(image, {
asShot,
@@ -43,11 +42,8 @@ test("RAW edits coalesce, recover from failure, and retain an exporting source a
const output = target(gpu, { size: image.size, format: image.format });
outputs.push(output);
return {
- prepare: (balance) =>
- balance.temperature === asShot.temperature &&
- balance.tint === asShot.tint
- ? Promise.resolve()
- : develop(),
+ prepare: ({ temperature }) =>
+ temperature === asShot.temperature ? Promise.resolve() : develop(),
render: () => output,
dispose: () => output.color.dispose(),
};
@@ -56,72 +52,59 @@ test("RAW edits coalesce, recover from failure, and retain an exporting source a
});
const resources = createResources();
const id = resources.add(new File([], "photo.nef"), source);
+ const layers = [createImageLayer(id, "Photo", asShot)] as const;
const document = createDocument(
- {
- frame: imageFrame(image.size),
- layers: [{ ...createImageLayer(id, "Photo", asShot), id: "base" }],
- },
+ { frame: imageFrame(image.size), layers },
resources,
);
const preview = createRenderer(gpu, source);
const exported = createRenderer(gpu, source);
const notify = mock(() => {});
preview.subscribe(notify);
- try {
- // An edit in the same tick as the initial render must not be lost.
- const initial = preview.update(document.scene.getState());
- setWhiteBalance(document, { temperature: 2000 });
- preview.update(document.scene.getState());
- await started.promise;
- expect(develop).toHaveBeenCalledTimes(1);
- setWhiteBalance(document, { temperature: 3000 });
- preview.update(document.scene.getState());
- setWhiteBalance(document);
- preview.update(document.scene.getState());
- requests[0].resolve();
- await initial;
- expect(develop).toHaveBeenCalledTimes(1);
- expect(notify).toHaveBeenCalledTimes(2);
- expect(outputs).toHaveLength(2);
- document.history.undo();
- expect(document.scene.getState().layers[0].whiteBalance?.temperature).toBe(
- 3000,
- );
- const failed = preview.update(document.scene.getState());
- requests[1].reject(Error("Decode failure"));
- await expect(failed).rejects.toThrow("Decode failure");
- const superseded = preview.update(document.scene.getState());
- setWhiteBalance(document);
- preview.update(document.scene.getState());
- requests[2].reject(Error("Superseded failure"));
- await superseded;
- setWhiteBalance(document, { temperature: 6500 });
- const recovered = preview.update(document.scene.getState());
- requests[3].resolve();
- await recovered;
- expect(() => setWhiteBalance(document, { temperature: NaN })).toThrow(
- "Invalid",
- );
- const exporting = exported.update(document.scene.getState());
- preview.dispose();
- document.dispose();
- expect(close).not.toHaveBeenCalled();
- expect(() => image.color.view).not.toThrow();
- requests[4].resolve();
- await exporting;
- expect(exported.outputImage().size).toEqual([8, 8]);
- exported.dispose();
- expect(close).toHaveBeenCalledTimes(1);
- expect(() => image.color.view).toThrow("destroyed");
- for (const output of outputs) {
- expect(() => output.color.view).toThrow("destroyed");
- }
- } finally {
- preview.dispose();
- exported.dispose();
- document.dispose();
- gpu.dispose();
+ const render = () => preview.update(document.scene.getState());
+ // An edit in the same tick as the initial render must not be lost.
+ const initial = render();
+ setWhiteBalance(document, { temperature: 2000 });
+ render();
+ await started.promise;
+ setWhiteBalance(document, { temperature: 3000 });
+ render();
+ setWhiteBalance(document);
+ render();
+ requests[0].resolve();
+ await initial;
+ // Only the first edit developed; the ones queued behind it collapsed into the last.
+ expect(develop).toHaveBeenCalledTimes(1);
+ expect(notify).toHaveBeenCalledTimes(2);
+ document.history.undo();
+ const failed = render();
+ requests[1].reject(Error("Decode failure"));
+ await expect(failed).rejects.toThrow("Decode failure");
+ const superseded = render();
+ setWhiteBalance(document);
+ render();
+ requests[2].reject(Error("Superseded failure"));
+ await superseded;
+ setWhiteBalance(document, { temperature: 6500 });
+ const recovered = render();
+ requests[3].resolve();
+ await recovered;
+ expect(() => setWhiteBalance(document, { temperature: NaN })).toThrow(
+ "Invalid",
+ );
+ const exporting = exported.update(document.scene.getState());
+ preview.dispose();
+ document.dispose();
+ expect(close).not.toHaveBeenCalled();
+ requests[4].resolve();
+ await exporting;
+ expect(exported.outputImage().size).toEqual([8, 8]);
+ exported.dispose();
+ expect(close).toHaveBeenCalledTimes(1);
+ for (const destroyed of [image, ...outputs]) {
+ expect(() => destroyed.color.view).toThrow("destroyed");
}
+ gpu.dispose();
});
test.each([1, 16])(
@@ -130,46 +113,29 @@ test.each([1, 16])(
const gpu = await init();
const source = target(gpu, { size: [127, 65], format: "rgba16float" });
const graph = createRenderGraph(gpu);
- let output = source;
- const render = (amount: number) => {
- [output] = graph.render([
+ const calls = getMockGPUDeviceInstrumentation(gpu.gpu).calls;
+ const radius = reduction === 1 ? 1 : 64;
+ const render = (amount: number) =>
+ graph.render([
pipeline(input(source), [
- unsharpMask(
- "detail",
- amount / 200,
- reduction === 1 ? 1 : 64,
- reduction,
- ),
+ unsharpMask("detail", amount / 200, radius, reduction),
]),
- ]);
- };
- try {
- render(0);
- expect(output).toBe(source);
- const calls = getMockGPUDeviceInstrumentation(gpu.gpu).calls;
- expect(calls.createRenderPipeline ?? 0).toBe(0);
- render(100);
- const filtered = output;
- expect(filtered).not.toBe(source);
- expect(filtered.size).toEqual(source.size);
- const pipelines = calls.createRenderPipeline;
- expect(graph.inspect().textures).toHaveLength(reduction === 1 ? 2 : 3);
- for (const amount of [-100, -50, 25, 75]) {
- render(amount);
- expect(output).toBe(filtered);
- }
- expect(calls.createRenderPipeline).toBe(pipelines);
- render(0);
- expect(output).toBe(source);
- expect(graph.inspect().textures).toHaveLength(0);
- graph.dispose();
- expect(() => filtered.color.view).toThrow("destroyed");
- expect(() => source.color.view).not.toThrow();
- } finally {
- graph.dispose();
- source.color.dispose();
- gpu.dispose();
- }
+ ])[0];
+ expect(render(0)).toBe(source);
+ expect(calls.createRenderPipeline ?? 0).toBe(0);
+ const filtered = render(100);
+ expect(filtered).not.toBe(source);
+ expect(filtered.size).toEqual(source.size);
+ expect(graph.inspect().textures).toHaveLength(reduction === 1 ? 2 : 3);
+ const pipelines = calls.createRenderPipeline;
+ expect(render(-100)).toBe(filtered);
+ expect(render(25)).toBe(filtered);
+ expect(calls.createRenderPipeline).toBe(pipelines);
+ expect(render(0)).toBe(source);
+ expect(graph.inspect().textures).toHaveLength(0);
+ graph.dispose();
+ source.color.dispose();
+ gpu.dispose();
},
);
@@ -177,16 +143,10 @@ test("rendering follows grouped edits and undo, reuses pipelines, and releases o
const gpu = await init();
const source = target(gpu, { size: [32, 16], format: "rgba16float" });
const canvas = Object.assign(target(gpu, { size: [64, 32] }), { dpr: 2 });
- const document = createDocument({
- frame: imageFrame([32, 16]),
- layers: [
- {
- ...createImageLayer("photo", "Photo"),
- id: "base",
- adjustments: { ...defaultAdjustments, exposure: 0.25 },
- },
- ],
- });
+ const adjustments = { ...defaultAdjustments, exposure: 0.25 };
+ const image = { ...createImageLayer("photo", "Photo"), id: "base" };
+ const layers = [{ ...image, adjustments }] as const;
+ const document = createDocument({ frame: imageFrame([32, 16]), layers });
const resource = createImageSource(source);
const renderer = createRenderer(gpu, resource);
const notify = mock(() => {});
@@ -201,128 +161,77 @@ test("rendering follows grouped edits and undo, reuses pipelines, and releases o
view: { pan: [4, 8], zoom: 2 },
}),
);
- try {
- expect(notify).not.toHaveBeenCalled();
- await expect(
- renderer.update({
- ...document.scene.getState(),
- get layers(): never {
- throw Error("Render failure");
- },
- }),
- ).rejects.toThrow("Render failure");
- renderer.update(document.scene.getState());
- const adjusted = renderer.outputImage();
- expect(adjusted.size).toEqual(source.size);
- expect(adjusted.format).toBe(source.format);
- expect(renderer.outputImage()).toBe(adjusted);
- document.history.begin();
- setAdjustments(document, { exposure: 0.5 });
- setAdjustments(document, { exposure: 1 });
- setToneCurve(document, [
- { x: 0, y: 0 },
- { x: 0.5, y: 0.7 },
- { x: 1, y: 1 },
- ]);
- document.history.commit();
- const curved = renderer.outputImage();
- expect(curved).not.toBe(adjusted);
- expect(curved.size).toEqual(source.size);
- expect(document.history.status.getState()).toEqual({
- undoCount: 1,
- redoCount: 0,
- editing: false,
- });
- draw();
- const calls = getMockGPUDeviceInstrumentation(gpu.gpu).calls;
- const pipelines = calls.createRenderPipeline;
- expect(pipelines).toBeGreaterThan(0);
- const late = mock(() => {});
- const detachLate = renderer.subscribe(late);
- expect(late).toHaveBeenCalledTimes(1);
- detachLate();
- document.history.undo();
- expect(renderer.outputImage()).toBe(adjusted);
- expect(document.scene.getState().layers[0].adjustments.exposure).toBe(0.25);
- document.history.redo();
- expect(renderer.inspect().passes).toEqual([
- "layer/base/exposure",
- "layer/base/curves",
- ]);
- document.history.begin();
- setToneCurve(document);
- expect(renderer.outputImage()).toBe(adjusted);
- document.history.cancel();
- expect(renderer.inspect().passes).toEqual([
- "layer/base/exposure",
- "layer/base/curves",
- ]);
- draw();
- expect(calls.createRenderPipeline).toBe(pipelines);
- expect(notify).toHaveBeenCalledTimes(8);
- expect(late).toHaveBeenCalledTimes(1);
- detach();
- const beforeInput = document.scene.getState();
- const base = beforeInput.layers[0];
- document.edit({
- ...beforeInput,
- layers: [
- {
- ...base,
- children: [
- { ...createLayer("exposure"), id: "exposure" },
- ...base.children,
- ],
- },
- ],
- });
- await renderer.update(document.scene.getState(), "base");
- expect(renderer.inputImage("base")).toBeDefined();
- expect(renderer.inputImage("base")).not.toBe(renderer.outputImage());
- expect(renderer.inputImage("exposure")).toBeUndefined();
- expect(renderer.inspect().passes).toEqual([
- "layer/base/exposure",
- "layer/base/curves",
- "layer/exposure/exposure",
- ]);
- document.edit(beforeInput);
- expect(renderer.inputImage("base")).toBeUndefined();
- setAdjustments(document, { exposure: -1 });
- const scene = document.scene.getState();
- const [image, ...effects] = scene.layers;
- document.edit({
- ...scene,
- layers: [
- image,
- {
- ...createLayer("details"),
- details: { clarity: 50, sharpening: 100, sharpenRadius: 2 },
- },
- ...effects,
- ],
- });
- expect(notify).toHaveBeenCalledTimes(8);
- document.edit({
- ...document.scene.getState(),
- frame: {
- ...document.scene.getState().frame,
- size: [16, 8],
- angle: 10,
- },
- });
- const croppedOutput = renderer.outputImage();
- expect(croppedOutput.size).toEqual([16, 8]);
- renderer.dispose();
- expect(() => croppedOutput.color.view).toThrow("destroyed");
- expect(() => adjusted.color.view).toThrow("destroyed");
- expect(() => curved.color.view).toThrow("destroyed");
- expect(() => source.color.view).not.toThrow();
- } finally {
- unsubscribe();
- detach();
- renderer.dispose();
- document.dispose();
- resource.dispose();
- gpu.dispose();
+ const passes = () => renderer.inspect().passes;
+ renderer.update(document.scene.getState());
+ const adjusted = renderer.outputImage();
+ document.history.begin();
+ setAdjustments(document, { exposure: 0.5 });
+ setAdjustments(document, { exposure: 1 });
+ setToneCurve(document, [
+ { x: 0, y: 0 },
+ { x: 0.5, y: 0.7 },
+ { x: 1, y: 1 },
+ ]);
+ document.history.commit();
+ const curved = renderer.outputImage();
+ expect(curved).not.toBe(adjusted);
+ draw();
+ const calls = getMockGPUDeviceInstrumentation(gpu.gpu).calls;
+ const pipelines = calls.createRenderPipeline;
+ expect(pipelines).toBeGreaterThan(0);
+ const late = mock(() => {});
+ renderer.subscribe(late)();
+ expect(late).toHaveBeenCalledTimes(1);
+ document.history.undo();
+ expect(renderer.outputImage()).toBe(adjusted);
+ expect(document.scene.getState().layers[0].adjustments.exposure).toBe(0.25);
+ document.history.redo();
+ const curves = ["layer/base/exposure", "layer/base/curves"];
+ expect(passes()).toEqual(curves);
+ document.history.begin();
+ setToneCurve(document);
+ expect(renderer.outputImage()).toBe(adjusted);
+ document.history.cancel();
+ expect(passes()).toEqual(curves);
+ draw();
+ expect(calls.createRenderPipeline).toBe(pipelines);
+ detach();
+ const beforeInput = document.scene.getState();
+ const base = beforeInput.layers[0];
+ const exposure = { ...createLayer("exposure"), id: "exposure" };
+ document.edit({
+ ...beforeInput,
+ layers: [{ ...base, children: [exposure, ...base.children] }],
+ });
+ await renderer.update(document.scene.getState(), "base");
+ expect(renderer.inputImage("base")).toBeDefined();
+ expect(renderer.inputImage("base")).not.toBe(renderer.outputImage());
+ expect(passes()).toEqual([...curves, "layer/exposure/exposure"]);
+ document.edit(beforeInput);
+ expect(renderer.inputImage("base")).toBeUndefined();
+ const scene = document.scene.getState();
+ const details = { clarity: 50, sharpening: 100, sharpenRadius: 2 };
+ document.edit({
+ ...scene,
+ layers: [...scene.layers, { ...createLayer("details"), details }],
+ });
+ // Eight renders reached the listener before it detached.
+ expect(notify).toHaveBeenCalledTimes(8);
+ document.edit({
+ ...document.scene.getState(),
+ frame: { ...scene.frame, size: [16, 8], angle: 10 },
+ });
+ const croppedOutput = renderer.outputImage();
+ expect(croppedOutput.size).toEqual([16, 8]);
+ renderer.dispose();
+ for (const owned of [croppedOutput, adjusted, curved]) {
+ expect(() => owned.color.view).toThrow("destroyed");
}
+ expect(() => source.color.view).not.toThrow();
+ unsubscribe();
+ document.dispose();
+ resource.dispose();
+ canvas.color.dispose();
+ display.dispose();
+ gpu.dispose();
});
diff --git a/tests/rendering.e2e.ts b/tests/rendering.e2e.ts
index e12871b..542c16d 100644
--- a/tests/rendering.e2e.ts
+++ b/tests/rendering.e2e.ts
@@ -17,10 +17,9 @@ test("tone adjustments preserve ramps, colors and alpha, compose, and reset", as
const result = await page.evaluate(
async (bytes) => {
const api = window.openlight;
- const file = new File([new Uint8Array(bytes)], "tones.png", {
- type: "image/png",
- });
- await api.loadImage(file);
+ await api.loadImage(
+ new File([new Uint8Array(bytes)], "tones.png", { type: "image/png" }),
+ );
const defaults = api.getState().adjustments;
const canvas = new OffscreenCanvas(256, 128);
const context = canvas.getContext("2d");
@@ -37,15 +36,11 @@ test("tone adjustments preserve ramps, colors and alpha, compose, and reset", as
for (const change of [
{},
{ whites: 100 },
- { whites: -100 },
- { blacks: -100 },
{ blacks: 100 },
- { whites: 100, blacks: -100 },
- { whites: -100, blacks: 100 },
+ { whites: -100, blacks: -100 },
{ highlights: -100 },
{ highlights: -50 },
{ highlights: 100 },
- { shadows: 50 },
{ shadows: 100 },
]) {
api.setAdjustments({ ...defaults, ...change });
@@ -68,42 +63,17 @@ test("tone adjustments preserve ramps, colors and alpha, compose, and reset", as
),
});
}
- const prepared = {
- ...defaults,
- highlights: -75,
- exposure: 0.4,
- incrementalTemperature: 20,
- incrementalTint: -12,
- };
- api.setAdjustments(prepared);
- const edited = await read();
- await api.loadImage(file);
- api.setAdjustments(prepared);
- const fresh = await read();
api.setAdjustments(defaults);
const reset = await read();
return {
outputs,
- reloadMatches: edited.every((value, i) => value === fresh[i]),
resetMatches: neutral.every((value, i) => value === reset[i]),
};
},
[...bytes],
);
- const [
- original,
- whiteClip,
- whiteLower,
- blackClip,
- blackLift,
- clipped,
- compressed,
- negative,
- half,
- positive,
- halfShadows,
- liftedShadows,
- ] = result.outputs;
+ const [original, whites, blacks, clipped, negative, half, positive, shadows] =
+ result.outputs;
for (const output of result.outputs) {
expect(output.alphaMatches).toBe(true);
expect(output.grayMatches).toBe(true);
@@ -112,72 +82,46 @@ test("tone adjustments preserve ramps, colors and alpha, compose, and reset", as
expect(output.ramp[x] - output.ramp[x - 1]).toBeLessThanOrEqual(6);
}
}
- for (const output of result.outputs.slice(0, 7))
- expect(output.ramp[128]).toBe(128);
+ expect(original.ramp).toEqual(Array.from({ length: 256 }, (_, x) => x));
+ // Whites and blacks each leave the other half of the ramp untouched.
+ expect(whites.ramp.slice(0, 129)).toEqual(original.ramp.slice(0, 129));
+ expect(blacks.ramp.slice(128)).toEqual(original.ramp.slice(128));
+ expect(clipped.ramp[128]).toBe(128);
+ expect(whites.ramp[230]).toBe(255);
+ expect(whites.colorEnds[1]).toEqual([255, 255, 255]);
+ expect(clipped.ramp[25]).toBe(0);
+ expect(clipped.colorEnds[0]).toEqual([0, 0, 0]);
+ expect(blacks.ramp[0]).toBeGreaterThanOrEqual(25);
+ expect(blacks.ramp[0]).toBeLessThanOrEqual(26);
+ expect(clipped.ramp[255]).toBeGreaterThanOrEqual(229);
+ expect(clipped.ramp[255]).toBeLessThanOrEqual(230);
for (let x = 0; x < 256; x++) {
- expect(original.ramp[x]).toBe(x);
- if (x <= 127) {
- expect(whiteClip.ramp[x]).toBe(x);
- expect(whiteLower.ramp[x]).toBe(x);
- } else {
- expect(blackClip.ramp[x]).toBe(x);
- expect(blackLift.ramp[x]).toBe(x);
- }
expect(negative.ramp[x]).toBeLessThanOrEqual(half.ramp[x]);
expect(half.ramp[x]).toBeLessThanOrEqual(x);
expect(positive.ramp[x]).toBeGreaterThanOrEqual(x);
- expect(halfShadows.ramp[x]).toBeGreaterThanOrEqual(x);
- expect(halfShadows.ramp[x]).toBeLessThanOrEqual(liftedShadows.ramp[x]);
- for (const [middle, full] of [
- [half, negative],
- [halfShadows, liftedShadows],
- ]) {
- expect(
- Math.abs(
- linear(middle.ramp[x]) - (linear(x) + linear(full.ramp[x])) / 2,
- ),
- ).toBeLessThan(0.01);
- }
- }
- for (const output of [whiteClip, clipped]) {
- expect(output.ramp[230]).toBe(255);
- expect(output.colorEnds[1]).toEqual([255, 255, 255]);
- }
- for (const output of [blackClip, clipped]) {
- expect(output.ramp[25]).toBe(0);
- expect(output.colorEnds[0]).toEqual([0, 0, 0]);
- }
- for (const output of [blackLift, compressed]) {
- expect(output.ramp[0]).toBeGreaterThanOrEqual(25);
- expect(output.ramp[0]).toBeLessThanOrEqual(26);
+ expect(shadows.ramp[x]).toBeGreaterThanOrEqual(x);
+ // Half the slider moves halfway in linear light.
+ expect(
+ Math.abs(
+ linear(half.ramp[x]) - (linear(x) + linear(negative.ramp[x])) / 2,
+ ),
+ ).toBeLessThan(0.01);
}
- for (const output of [whiteLower, compressed]) {
- expect(output.ramp[255]).toBeGreaterThanOrEqual(229);
- expect(output.ramp[255]).toBeLessThanOrEqual(230);
+ for (const output of [negative, half, positive, shadows]) {
+ expect(output.ramp[0]).toBe(0);
}
+ expect(shadows.ramp[255]).toBe(255);
expect(original.patches).toEqual([240, 240]);
expect(negative.patches[0]).toBe(negative.patches[1]);
expect(negative.patches[0]).toBeLessThan(240);
expect(positive.patches[0]).toBe(positive.patches[1]);
expect(positive.patches[0]).toBeGreaterThan(240);
- for (const output of [negative, half, positive, liftedShadows])
- expect(output.ramp[0]).toBe(0);
- expect(liftedShadows.ramp[255]).toBe(255);
expect(Math.abs(negative.pastel[0] - negative.pastel[2])).toBeLessThanOrEqual(
1,
);
for (let channel = 0; channel < 3; channel++) {
expect(negative.pastel[channel]).toBeLessThan(original.pastel[channel]);
- expect(
- Math.abs(
- linear(half.pastel[channel]) -
- (linear(original.pastel[channel]) +
- linear(negative.pastel[channel])) /
- 2,
- ),
- ).toBeLessThan(0.01);
}
- expect(result.reloadMatches).toBe(true);
expect(result.resetMatches).toBe(true);
});
diff --git a/tests/scene-file.e2e.ts b/tests/scene-file.e2e.ts
index 06c97f1..8c8976b 100644
--- a/tests/scene-file.e2e.ts
+++ b/tests/scene-file.e2e.ts
@@ -1,21 +1,16 @@
import { readFile } from "node:fs/promises";
-import { expect, test } from "./fixtures";
+import { expect, openPhoto, test } from "./fixtures";
import { readImage } from "./images";
test("a saved scene reopens the photo with its edits and keeps editing", async ({
page,
}) => {
- await page.goto("/");
- const picker = page.locator('input[type="file"]');
- await picker.setInputFiles("tests/fixtures/photo.svg");
- const exposure = page.getByRole("textbox", { name: "Exposure", exact: true });
- await expect(exposure).toHaveValue("0.00");
+ await openPhoto(page);
// Inside the radial mask, and on the light strip outside it.
const samples = [
[600, 400],
[1100, 400],
] as const;
- const baseline = await readImage(page, undefined, samples);
await page.evaluate(() => {
const api = window.openlight;
api.setAdjustments({ exposure: -1 });
@@ -29,44 +24,29 @@ test("a saved scene reopens the photo with its edits and keeps editing", async (
});
api.setAdjustments({ exposure: 1.5 }, mask);
api.setFill({ color: "#3060c0", blend: "soft-light" });
- api.selectLayer(api.getState().scene?.layers[0].id ?? "");
});
- await expect(exposure).toHaveValue("-1.00");
const edited = await readImage(page, undefined, samples);
- const [inside, outside] = edited.samples ?? [];
- expect(outside[0]).toBeLessThan(baseline.samples?.[1][0] ?? 0);
- expect(inside).not.toEqual(outside);
await page.getByRole("button", { name: "Export", exact: true }).click();
const pending = page.waitForEvent("download");
- await page
- .getByRole("region", { name: "Scene export" })
- .getByRole("button", { name: "Save scene" })
- .click();
+ await page.getByRole("button", { name: "Save scene" }).click();
const download = await pending;
expect(download.suggestedFilename()).toBe("photo.openlight");
- const path = await download.path();
- if (!path) throw new Error("Missing scene download.");
await page.reload();
+ const picker = page.locator('input[type="file"]');
await expect(picker).toHaveAttribute("accept", /\.openlight/);
await picker.setInputFiles({
name: "photo.openlight",
mimeType: "",
- buffer: await readFile(path),
+ buffer: await readFile(await download.path()),
});
+ const exposure = page.getByRole("textbox", { name: "Exposure", exact: true });
await expect(exposure).toHaveValue("-1.00");
- await expect(page.getByText("photo.openlight")).toBeVisible();
- await expect(
- page
- .getByRole("region", { name: "Layers", exact: true })
- .getByText("Color"),
- ).toBeVisible();
expect(await readImage(page, undefined, samples)).toEqual(edited);
await page.evaluate(() => window.openlight.setAdjustments({ exposure: 0 }));
await expect(exposure).toHaveValue("0.00");
await page.keyboard.press("ControlOrMeta+z");
await expect(exposure).toHaveValue("-1.00");
- expect(await readImage(page, undefined, samples)).toEqual(edited);
});
diff --git a/tests/scene-file.test.ts b/tests/scene-file.test.ts
index 59c4e88..38c7855 100644
--- a/tests/scene-file.test.ts
+++ b/tests/scene-file.test.ts
@@ -4,8 +4,12 @@ import { createControls } from "@/app/controls";
import { createImageLayer, createLayer, createMask } from "@/app/editor/layers";
import { openSceneFile } from "@/app/loaders/scene";
import { createWorkspace } from "@/app/workspace";
-import { createDocument, createResources } from "@/core/document";
-import { createImageSource, type WhiteBalance } from "@/core/image";
+import {
+ type BrushStroke,
+ createDocument,
+ createResources,
+} from "@/core/document";
+import { createImageSource } from "@/core/image";
import { imageFrame } from "@/core/image/frame";
import { readZip, writeZip } from "@/lib/zip";
@@ -13,300 +17,216 @@ const asShot = { temperature: 5000, tint: 10 };
const size = [64, 32] as const;
const bytes = new Uint8Array(4096).map((_, index) => index * 7);
-async function decoder(balance?: WhiteBalance) {
+test("scene files reopen the photo with every layer for further editing", async () => {
const gpu = await init();
+ const workspace = createWorkspace();
+ const api = createControls(gpu, workspace);
const decoded: File[] = [];
- function decode(file: File) {
+ const decode = (file: File) => {
decoded.push(file);
- const raw = balance && {
- asShot: balance,
+ const raw = {
+ asShot,
createPass(): never {
throw Error("Not rendered.");
},
dispose() {},
};
- return Promise.resolve(
- createImageSource(target(gpu, { size, format: "rgba16float" }), raw),
- );
- }
- return { decode, decoded };
-}
-
-test("scene files reopen the photo with every layer for further editing", async () => {
- const workspace = createWorkspace();
- const api = createControls(await init(), workspace);
- const raw = await decoder(asShot);
- try {
- await workspace.open("photo.nef", async () => {
- const file = new File([bytes], "photo.nef", {
- type: "image/x-nikon-nef",
- });
- const resources = createResources();
- const source = resources.add(file, await raw.decode(file));
- return createDocument(
- {
- frame: imageFrame(size),
- layers: [createImageLayer(source, "photo.nef", asShot)],
- },
- resources,
- );
- });
- api.setAdjustments({ exposure: 1, contrast: 20 });
- api.setWhiteBalance({ temperature: 6500 });
- api.setToneCurve([
- { x: 0, y: 0 },
- { x: 0.5, y: 0.6 },
- { x: 1, y: 1 },
- ]);
- api.setFrame({
- center: [30, 16],
- size: [40, 24],
- rotation: 90,
- angle: 5,
- scale: [-1, 1],
- });
- const mask = api.addLayer("mask");
- api.setLayerMask(mask, {
- kind: "brush",
- strokes: [
- {
- mode: "paint",
- size: 6,
- feather: 0.5,
- flow: 0.8,
- points: [
- [10.25, 8, 1],
- [20, 12.5, 0.5],
- ],
- },
- ],
- });
- api.setAdjustments({ shadows: 40 }, mask);
- const tones = api.addLayer("mask", { inside: mask });
- api.setLayerMask(tones, {
- kind: "luminance-range",
- low: 20,
- high: 80,
- smoothness: 10,
- });
- api.setMaskOperation(tones, "intersect");
- api.run({
- type: "add-mask",
- mask: { kind: "color-range", color: "#336699", tolerance: 40 },
- });
- api.run({
- type: "add-mask",
- mask: { kind: "color-range", color: null, tolerance: 30 },
- });
- api.setDetails({ clarity: 30 }, api.addLayer("details", { inside: mask }));
- const subtract = api.addLayer("mask", { inside: mask });
- api.setLayerMask(subtract, {
- kind: "radial",
- center: [16, 16],
- radius: [8, 6],
- angle: 30,
- feather: 0.4,
- });
- api.setMaskOperation(subtract, "subtract");
- const heal = api.addLayer("heal");
- const firstPatch = api.addHealPatch(
- heal,
- { mode: "paint", size: 4, feather: 0.2, flow: 1, points: [[40, 20, 1]] },
- [-6, 2],
- );
- api.addHealStroke(heal, firstPatch, {
- mode: "paint",
- size: 6,
- feather: 0.2,
- flow: 1,
- points: [[44, 22, 1]],
- });
- api.addHealStroke(heal, firstPatch, {
- mode: "erase",
- size: 2,
- feather: 0,
- flow: 1,
- points: [[40, 20, 1]],
- });
- api.addHealPatch(
- heal,
- { mode: "paint", size: 4, feather: 0.2, flow: 1, points: [[48, 20, 1]] },
- [-6, 2],
- "clone",
- );
- api.addRemovePatch(heal, {
- mode: "paint",
- size: 4,
- feather: 0.2,
- flow: 1,
- points: [[52, 24, 1]],
- });
- const paint = api.addLayer("paint");
- api.addPaintStroke(paint, {
- mode: "paint",
- size: 5,
- feather: 0.3,
- flow: 1,
- color: "#ff8800",
- points: [
- [12, 6, 1],
- [30, 9, 0.7],
- ],
- });
- api.setPaintBlend(paint, "overlay");
- api.setFill({ color: "#123456", blend: "soft-light" });
- const fill = api.getState().scene?.layers.at(-1)?.id ?? "";
- api.setLayer(fill, { name: "Warm", opacity: 0.5, visible: false });
- api.setVignette({ intensity: 70, softness: 20 });
- api.setColorMixer("blue", { hue: 20, luminance: -10 });
- api.setExposure(api.addLayer("exposure"), -0.5);
- await api.openFile(
- new File(
- [
- [
- "TITLE Grade",
- "LUT_3D_SIZE 2",
- ...Array(8).fill("0.5 0.5 0.5"),
- ].join("\n"),
- ],
- "grade.cube",
- ),
- );
- const edited = workspace.getDocument().scene.getState();
- const lut = edited.layers.at(-1);
- if (lut?.kind !== "lut") throw Error("Missing LUT layer.");
- expect(lut.name).toBe("Grade");
+ const image = target(gpu, { size, format: "rgba16float" });
+ return Promise.resolve(createImageSource(image, raw));
+ };
+ const nef = new File([bytes], "photo.nef", { type: "image/x-nikon-nef" });
+ const resources = createResources();
+ const source = resources.add(nef, await decode(nef));
+ const layers = [createImageLayer(source, "photo.nef", asShot)] as const;
+ const frame = imageFrame(size);
+ const document = createDocument({ frame, layers }, resources);
+ await workspace.open("photo.nef", async () => document);
+ api.setAdjustments({ exposure: 1, contrast: 20 });
+ api.setWhiteBalance({ temperature: 6500 });
+ api.setToneCurve([
+ { x: 0, y: 0 },
+ { x: 0.5, y: 0.6 },
+ { x: 1, y: 1 },
+ ]);
+ api.setFrame({ ...imageFrame(size), angle: 5, scale: [-0.8, 0.8] });
+ const mask = api.addLayer("mask");
+ const stroke: BrushStroke = {
+ mode: "paint",
+ size: 6,
+ feather: 0.5,
+ flow: 0.8,
+ points: [[10.25, 8, 0.5]],
+ };
+ api.setLayerMask(mask, { kind: "brush", strokes: [stroke] });
+ api.setAdjustments({ shadows: 40 }, mask);
+ const tones = api.addLayer("mask", { inside: mask });
+ api.setLayerMask(tones, {
+ kind: "luminance-range",
+ low: 20,
+ high: 80,
+ smoothness: 10,
+ });
+ api.setMaskOperation(tones, "intersect");
+ api.run({
+ type: "add-mask",
+ mask: { kind: "color-range", color: "#336699", tolerance: 40 },
+ });
+ api.run({
+ type: "add-mask",
+ mask: { kind: "color-range", color: null, tolerance: 30 },
+ });
+ api.setDetails({ clarity: 30 }, api.addLayer("details", { inside: mask }));
+ const subtract = api.addLayer("mask", { inside: mask });
+ api.setLayerMask(subtract, {
+ kind: "radial",
+ center: [16, 16],
+ radius: [8, 6],
+ angle: 30,
+ feather: 0.4,
+ });
+ api.setMaskOperation(subtract, "subtract");
+ const heal = api.addLayer("heal");
+ const firstPatch = api.addHealPatch(
+ heal,
+ { mode: "paint", size: 4, feather: 0.2, flow: 1, points: [[40, 20, 1]] },
+ [-6, 2],
+ );
+ api.addHealStroke(heal, firstPatch, {
+ mode: "paint",
+ size: 6,
+ feather: 0.2,
+ flow: 1,
+ points: [[44, 22, 1]],
+ });
+ api.addHealStroke(heal, firstPatch, {
+ mode: "erase",
+ size: 2,
+ feather: 0,
+ flow: 1,
+ points: [[40, 20, 1]],
+ });
+ api.addHealPatch(
+ heal,
+ { mode: "paint", size: 4, feather: 0.2, flow: 1, points: [[48, 20, 1]] },
+ [-6, 2],
+ "clone",
+ );
+ api.addRemovePatch(heal, {
+ mode: "paint",
+ size: 4,
+ feather: 0.2,
+ flow: 1,
+ points: [[52, 24, 1]],
+ });
+ const paint = api.addLayer("paint");
+ api.addPaintStroke(paint, { ...stroke, color: "#ff8800" });
+ api.setPaintBlend(paint, "overlay");
+ api.setFill({ color: "#123456", blend: "soft-light" });
+ const fill = api.getState().scene?.layers.at(-1)?.id ?? "";
+ api.setLayer(fill, { name: "Warm", opacity: 0.5, visible: false });
+ api.setVignette({ intensity: 70, softness: 20 });
+ api.setColorMixer("blue", { hue: 20, luminance: -10 });
+ api.setExposure(api.addLayer("exposure"), -0.5);
+ const cube = [
+ "TITLE Grade",
+ "LUT_3D_SIZE 2",
+ ...Array(8).fill("0.5 0.5 0.5"),
+ ];
+ await api.openFile(new File([cube.join("\n")], "grade.cube"));
+ const edited = workspace.getDocument().scene.getState();
+ const lut = edited.layers.at(-1);
+ if (lut?.kind !== "lut") throw Error("Missing LUT layer.");
+ expect(lut.name).toBe("Grade");
- const file = await api.exportScene();
- expect(file.name).toBe("photo.openlight");
- const entries = await readZip(file);
- const json = JSON.parse((await entries.get("scene.json")?.text()) ?? "");
- const { source } = edited.layers[0];
- expect(json).toMatchObject({
- format: "openlight",
- version: 1,
- sources: { [source]: { name: "photo.nef", type: "image/x-nikon-nef" } },
- scene: edited,
- });
- const stored = await entries.get(`sources/${source}`)?.bytes();
- expect(stored).toEqual(bytes);
+ const file = await api.exportScene();
+ expect(file.name).toBe("photo.openlight");
+ const entries = await readZip(file);
+ const json = JSON.parse((await entries.get("scene.json")?.text()) ?? "");
+ expect(json).toMatchObject({
+ format: "openlight",
+ version: 1,
+ sources: { [source]: { name: "photo.nef", type: "image/x-nikon-nef" } },
+ scene: edited,
+ });
+ const opened = await openSceneFile(file, decode);
+ const reopened = decoded.at(-1);
+ expect(reopened).toMatchObject({ name: "photo.nef", type: nef.type });
+ expect(await reopened?.bytes()).toEqual(bytes);
+ expect(opened.scene.getState()).toEqual(edited);
+ expect(opened.history.status.getState().undoCount).toBe(0);
+ opened.dispose();
- const opened = await openSceneFile(file, raw.decode);
- const reopened = raw.decoded.at(-1);
- expect(reopened?.name).toBe("photo.nef");
- expect(reopened?.type).toBe("image/x-nikon-nef");
- expect(await reopened?.bytes()).toEqual(bytes);
- expect(opened.scene.getState()).toEqual(edited);
- expect(opened.history.status.getState().undoCount).toBe(0);
- opened.dispose();
-
- async function archive(value: unknown, sources = entries) {
- return writeZip([
- { name: "scene.json", data: new Blob([JSON.stringify(value)]) },
- ...[...sources]
- .filter(([name]) => name !== "scene.json")
- .map(([name, data]) => ({ name, data })),
- ]);
- }
- const invalid: [Blob, string][] = [
- [new Blob(["not a zip"]), "Not a ZIP archive."],
- [
- await archive({ ...json, format: "other" }),
- "doesn't contain an OpenLight scene",
- ],
- [await archive({ ...json, version: 2 }), "needs a newer version"],
- [await archive(json, new Map()), "The scene's image is missing."],
- [
- await archive({
- ...json,
- scene: {
- ...json.scene,
- layers: [...json.scene.layers, json.scene.layers[1]],
- },
- }),
- "IDs must be unique",
- ],
- [
- await archive({
- ...json,
- scene: {
- ...json.scene,
- layers: [
- ...json.scene.layers,
- { ...json.scene.layers[2], id: "new", kind: "text" },
- ],
- },
- }),
- "Unknown layer kind: text.",
- ],
- [
- await archive({
- ...json,
- scene: {
- ...json.scene,
- layers: [
- ...json.scene.layers,
- { ...lut, id: "short", lut: { ...lut.lut, table: [0, 0, 0] } },
- ],
- },
- }),
- "The table needs three values per entry",
- ],
- ];
- for (const [kind, count, message] of [
- ["paint", 5, "up to 4 paint layers"],
- ["mask", 11, "up to 10 brush masks"],
- ] as const) {
- const layers = Array.from({ length: count }, () =>
- kind === "paint"
- ? createLayer("paint")
- : createMask({ kind: "brush", strokes: [] }),
- );
- invalid.push([
- await archive({
- ...json,
- scene: { ...json.scene, layers: [json.scene.layers[0], ...layers] },
- }),
- message,
- ]);
- }
- const decodedBefore = raw.decoded.length;
- for (const [value, message] of invalid) {
- await expect(openSceneFile(value, raw.decode)).rejects.toThrow(message);
- }
-
- expect(raw.decoded).toHaveLength(decodedBefore);
+ async function archive(value: unknown, sources = entries) {
+ return writeZip([
+ { name: "scene.json", data: new Blob([JSON.stringify(value)]) },
+ ...[...sources]
+ .filter(([name]) => name !== "scene.json")
+ .map(([name, data]) => ({ name, data })),
+ ]);
+ }
+ const saved = json.scene.layers;
+ const withLayers = (layers: unknown[]) =>
+ archive({ ...json, scene: { ...json.scene, layers } });
+ const adding = (layer: unknown) => withLayers([...saved, layer]);
+ const many = (count: number, layer: () => unknown) =>
+ withLayers([saved[0], ...Array.from({ length: count }, layer)]);
+ const invalid: [Blob, string][] = [
+ [new Blob(["not a zip"]), "Not a ZIP archive."],
+ [await archive({ ...json, format: "other" }), "an OpenLight scene"],
+ [await archive({ ...json, version: 2 }), "needs a newer version"],
+ [await archive(json, new Map()), "The scene's image is missing."],
+ [await adding(saved[1]), "IDs must be unique"],
+ [await adding({ id: "new", kind: "text" }), "Unknown layer kind: text."],
+ [
+ await adding({
+ ...lut,
+ id: "short",
+ lut: { ...lut.lut, table: [0, 0, 0] },
+ }),
+ "The table needs three values per entry",
+ ],
+ [await many(5, () => createLayer("paint")), "up to 4 paint layers"],
+ [
+ await many(11, () => createMask({ kind: "brush", strokes: [] })),
+ "up to 10 brush masks",
+ ],
+ ];
+ const decodes = decoded.length;
+ for (const [value, message] of invalid) {
+ await expect(openSceneFile(value, decode)).rejects.toThrow(message);
+ }
+ expect(decoded).toHaveLength(decodes);
- // A parameter missing from a group takes its default, as in a file older than that parameter.
- const vignette = json.scene.layers.find(
- (layer: { kind: string }) => layer.kind === "vignette",
- );
- delete vignette.vignette.softness;
- delete json.scene.layers[0].whiteBalance;
- const healing = json.scene.layers.find(
- (layer: { kind: string }) => layer.kind === "heal",
- );
- delete healing.patches[0].mode;
- // Earlier files held one painted stroke per patch.
- for (const patch of healing.patches) {
- patch.stroke = patch.strokes[0];
- delete patch.strokes;
- }
- const older = await openSceneFile(await archive(json), raw.decode);
- const loaded = older.scene.getState();
- expect(loaded.layers[0].whiteBalance).toEqual(asShot);
- expect(loaded.layers.find((layer) => layer.kind === "heal")).toMatchObject({
- patches: [
- { mode: "heal", strokes: [{ mode: "paint" }] },
- { mode: "clone", strokes: [{ mode: "paint" }] },
- { mode: "remove", strokes: [{ mode: "paint" }] },
- ],
- });
- expect(
- loaded.layers.find((layer) => layer.kind === "vignette"),
- ).toMatchObject({ vignette: { intensity: 70, softness: 50 } });
- older.dispose();
- } finally {
- workspace.dispose();
+ // A parameter missing from a group takes its default, as in a file older than that parameter.
+ const vignette = saved.find(
+ (layer: { kind: string }) => layer.kind === "vignette",
+ );
+ delete vignette.vignette.softness;
+ delete saved[0].whiteBalance;
+ const healing = json.scene.layers.find(
+ (layer: { kind: string }) => layer.kind === "heal",
+ );
+ delete healing.patches[0].mode;
+ // Earlier files held one painted stroke per patch.
+ for (const patch of healing.patches) {
+ patch.stroke = patch.strokes[0];
+ delete patch.strokes;
}
+ const older = await openSceneFile(await archive(json), decode);
+ const loaded = older.scene.getState();
+ expect(loaded.layers[0].whiteBalance).toEqual(asShot);
+ expect(loaded.layers.find((layer) => layer.kind === "heal")).toMatchObject({
+ patches: [
+ { mode: "heal", strokes: [{ mode: "paint" }] },
+ { mode: "clone", strokes: [{ mode: "paint" }] },
+ { mode: "remove", strokes: [{ mode: "paint" }] },
+ ],
+ });
+
+ expect(
+ loaded.layers.find((layer) => layer.kind === "vignette"),
+ ).toMatchObject({ vignette: { intensity: 70, softness: 50 } });
+ older.dispose();
+ workspace.dispose();
+ gpu.dispose();
});
diff --git a/tests/tiff.e2e.ts b/tests/tiff.e2e.ts
index 45214b8..9d2c86c 100644
--- a/tests/tiff.e2e.ts
+++ b/tests/tiff.e2e.ts
@@ -1,86 +1,63 @@
-import { readFile } from "node:fs/promises";
import { expect, test } from "./fixtures";
import { readImage } from "./images";
-const directory = "tests/fixtures";
-
-test("TIFF files open through the loader with their color, orientation, headroom, alpha, and error recovery", async ({
+test("TIFF files open with their color, orientation, headroom, and alpha", async ({
page,
}) => {
await page.goto("/");
await page.waitForFunction(() => window.openlight);
- const load = async (name: string) => {
- const bytes = [...(await readFile(`${directory}/${name}`))];
- await page.evaluate(
- ({ bytes, name }) =>
- window.openlight.loadImage(new File([new Uint8Array(bytes)], name)),
- { bytes, name },
+ const open = (name: string) =>
+ page.evaluate(
+ (url) => window.openlight.loadUrl(url),
+ `/tests/fixtures/${name}`,
+ );
+ const exposure = (exposure: number) =>
+ page.evaluate(
+ (exposure) => window.openlight.setAdjustments({ exposure }),
+ exposure,
);
- };
// A gray profile file exported back to sRGB returns its encoded value: 16384 of 65535 is 64 of 255.
- await load("gray16-para.tif");
+ await open("gray16-para.tif");
const gray = await readImage(page);
expect(gray.size).toEqual([7, 5]);
for (const value of gray.center.slice(0, 3)) {
expect(Math.abs(value - 64)).toBeLessThanOrEqual(1);
}
- await load("orientation-6.tif");
+ await open("orientation-6.tif");
expect((await readImage(page)).size).toEqual([17, 19]);
+
// Row 1 of the float file holds linear 1, 2, and 4 at x = 4..6: all clip at first, then separate at -2 stops.
- await load("float32-be.tif");
- const row = () =>
- page.evaluate(async () => {
- const image = await createImageBitmap(
- await window.openlight.exportImage(),
- );
- const canvas = new OffscreenCanvas(image.width, image.height);
- const context = canvas.getContext("2d");
- if (!context) throw new Error("Cannot read exported image.");
- context.drawImage(image, 0, 0);
- image.close();
- return [...context.getImageData(0, 1, 7, 1).data].filter(
- (_, i) => i % 4 === 0,
- );
- });
- expect((await row()).slice(4)).toEqual([255, 255, 255]);
- await page.evaluate(() => window.openlight.setAdjustments({ exposure: -2 }));
- const recovered = await row();
- expect(recovered[4]).toBeLessThan(150);
- expect(recovered[5]).toBeGreaterThan(recovered[4]);
- expect(recovered[6]).toBeGreaterThan(240);
+ await open("float32-be.tif");
+ const reds = async () => {
+ const { samples = [] } = await readImage(page, undefined, [
+ [4, 1],
+ [5, 1],
+ [6, 1],
+ ]);
+ return samples.map((pixel) => pixel[0]);
+ };
+ expect(await reds()).toEqual([255, 255, 255]);
+ await exposure(-2);
+ const [one, two, four] = await reds();
+ expect(one).toBeLessThan(150);
+ expect(two).toBeGreaterThan(one);
+ expect(four).toBeGreaterThan(240);
+
// The blue pixel brightens without losing its hue, then approaches white.
- await load("blue-float.tif");
- const colors = [];
- for (const exposure of [0, 2, 5]) {
- await page.evaluate(
- (exposure) => window.openlight.setAdjustments({ exposure }),
- exposure,
- );
- colors.push((await readImage(page)).center.slice(0, 3));
- }
- for (const rgb of colors.slice(0, 2)) {
- expect(rgb[2] - Math.max(rgb[0], rgb[1])).toBeGreaterThan(20);
- }
- const brightness = colors.map((rgb) =>
- rgb.reduce((sum, value) => sum + value, 0),
- );
- expect(brightness[1]).toBeGreaterThan(brightness[0]);
- const white = colors[2];
+ await open("blue-float.tif");
+ await exposure(2);
+ const [red, green, blue] = (await readImage(page)).center;
+ expect(blue - Math.max(red, green)).toBeGreaterThan(20);
+ await exposure(5);
+ const white = (await readImage(page)).center.slice(0, 3);
expect(Math.min(...white)).toBeGreaterThan(240);
expect(Math.max(...white) - Math.min(...white)).toBeLessThan(10);
- await load("rgb8-jpeg.tif");
- await expect(
- page.getByText("Couldn't open rgb8-jpeg.tif:", { exact: false }),
- ).toBeVisible();
- // Recover in the same session after the package rejects an unsupported TIFF.
- await load("alpha16.tif");
+
+ await open("alpha16.tif");
const alpha = await readImage(page);
expect(alpha.size).toEqual([7, 5]);
// Export composites 50% alpha over the editor's 0.09 display background.
for (const [i, expected] of [43, 75, 107, 255].entries()) {
expect(Math.abs(alpha.center[i] - expected)).toBeLessThanOrEqual(1);
}
- await expect(
- page.getByText("Couldn't open rgb8-jpeg.tif:", { exact: false }),
- ).toBeHidden();
});
diff --git a/tests/vignette.e2e.ts b/tests/vignette.e2e.ts
index 3a63277..658a622 100644
--- a/tests/vignette.e2e.ts
+++ b/tests/vignette.e2e.ts
@@ -18,16 +18,6 @@ test("vignette darkens a white image's edges, softens, undoes and disables", asy
name: "Intensity",
exact: true,
});
- await intensity.fill("0");
- await intensity.press("Enter");
- const exportBytes = () =>
- page.evaluate(async () => [
- ...new Uint8Array(
- await (await window.openlight.exportImage()).arrayBuffer(),
- ),
- ]);
- const original = await exportBytes();
-
await intensity.fill("80");
await intensity.press("Enter");
const vignetted = await readImage(page);
@@ -37,14 +27,11 @@ test("vignette darkens a white image's edges, softens, undoes and disables", asy
const softness = page.getByRole("textbox", { name: "Softness", exact: true });
await softness.fill("100");
await softness.press("Enter");
- const softer = await readImage(page);
- expect(softer.center).toEqual(vignetted.center);
- expect(softer.corner[0]).toBeLessThan(vignetted.corner[0]);
-
+ expect((await readImage(page)).corner[0]).toBeLessThan(vignetted.corner[0]);
await page.getByRole("button", { name: "Undo", exact: true }).click();
expect(await readImage(page)).toEqual(vignetted);
await intensity.fill("0");
await intensity.press("Enter");
- expect(await exportBytes()).toEqual(original);
+ expect((await readImage(page)).corner).toEqual([255, 255, 255, 255]);
});
diff --git a/tests/webmcp.e2e.ts b/tests/webmcp.e2e.ts
index 7057a8b..0e7bb3d 100644
--- a/tests/webmcp.e2e.ts
+++ b/tests/webmcp.e2e.ts
@@ -17,7 +17,7 @@ function callTool(page: Page, name: string, input: object = {}) {
);
}
-test("a browser agent opens, edits, masks, crops, undoes, and resets through WebMCP tools", async ({
+test("a browser agent opens, edits, masks, crops, and resets a photo through WebMCP tools", async ({
page,
}) => {
// Another origin, with CORS and no extension, as an agent serves a local file.
@@ -38,64 +38,40 @@ test("a browser agent opens, edits, masks, crops, undoes, and resets through Web
),
)
.toBeGreaterThan(0);
- expect(await callTool(page, "set-adjustments", { exposure: 1 })).toBe(
- "Error: Load an image before editing.",
- );
expect(JSON.parse(await callTool(page, "open-image", { url }))).toMatchObject(
{ file: "gray card", sourceSize: [128, 64] },
);
const state = async () => JSON.parse(await callTool(page, "get-state"));
const gray = await readImage(page);
const [image] = (await state()).layers;
-
- expect(await callTool(page, "set-adjustments", { exposure: 9 })).toMatch(
- /exposure/,
- );
expect(
JSON.parse(await callTool(page, "set-adjustments", { exposure: 1 })),
).toEqual({ layerId: image.id });
- const brighter = await readImage(page);
- expect(brighter.center[0]).toBeGreaterThan(gray.center[0]);
-
- await callTool(page, "add-mask", {
- mask: { kind: "linear", start: [0, 0], end: [0, 32] },
- adjustments: { exposure: -2 },
- });
- const readEnds = () =>
- readImage(page, undefined, [
- [64, 2],
- [64, 60],
- ]);
- const masked = await readEnds();
- expect(masked.samples?.[0][0]).toBeLessThan(gray.center[0]);
- expect(masked.samples?.[1]).toEqual(brighter.center);
-
- expect(await callTool(page, "set-crop", { aspectRatio: 1 })).toBe("Done.");
- expect((await readImage(page)).size).toEqual([64, 64]);
- await callTool(page, "undo");
- expect(await readEnds()).toEqual(masked);
-
- await callTool(page, "reset");
- expect((await state()).layers).toHaveLength(1);
- expect(await readImage(page)).toEqual(gray);
- await callTool(page, "undo");
- expect(await readEnds()).toEqual(masked);
// A batch runs in order and stops at its first invalid command, keeping the ones before it.
- const { undoCount } = (await state()).history;
expect(
await callTool(page, "run-commands", {
commands: [
- { type: "set-adjustments", exposure: -1 },
- { type: "set-vignette", intensity: 40 },
+ {
+ type: "add-mask",
+ mask: { kind: "linear", start: [0, 0], end: [0, 32] },
+ adjustments: { exposure: -2 },
+ },
+ { type: "set-crop", aspectRatio: 1 },
{ type: "set-adjustments", exposure: 9 },
],
}),
- ).toMatch(/^Error: Command 3 of 3 failed/);
- const batched = await state();
- expect(batched.history.undoCount).toBe(undoCount + 2);
- expect(batched.layers[0].adjustments.exposure).toBe(-1);
- expect(batched.layers).toContainEqual(
- expect.objectContaining({ kind: "vignette" }),
- );
+ ).toMatch(/^Error: Command 3 of 3 failed.*exposure/);
+ expect((await state()).history.undoCount).toBe(3);
+ const edited = await readImage(page, undefined, [
+ [32, 2],
+ [32, 60],
+ ]);
+ const [top, bottom] = edited.samples ?? [];
+ expect(edited.size).toEqual([64, 64]);
+ expect(top[0]).toBeLessThan(gray.center[0]);
+ expect(bottom[0]).toBeGreaterThan(gray.center[0]);
+
+ await callTool(page, "reset");
+ expect(await readImage(page)).toEqual(gray);
});