Skip to content

Free open-source image editor for the browser

9.7 KB
Raw Blame
import type { Gpu } from "vgpu";
import {
  createDraftStore,
  type DraftStore,
  openDraft,
} from "@/app/draft/store";
import {
  type ExportOptions,
  exportImage,
} from "@/app/editor/export/export-image";
import { createCameraRawXmpLoader } from "@/app/loaders/camera-raw-xmp";
import { createImageLoader } from "@/app/loaders/image";
import { createLutLoader } from "@/app/loaders/lut";
import { createLoaderRegistry } from "@/app/loaders/registry";
import { createSceneLoader, writeSceneFile } from "@/app/loaders/scene";
import type {
  Adjustments,
  Blend,
  BrushStroke,
  Details,
  Fill,
  Grain,
  HealMode,
  Mask,
  MaskLayer,
  PaintStroke,
  Preview,
  ToneCurve,
  Vignette,
} from "@/core/document";
import type { WhiteBalance } from "@/core/image";
import { decode } from "@/core/image/decode";
import type { ImageFrame, Point } from "@/core/image/frame";
import { setAdjustments, setExposure } from "@/features/adjustments/edits";
import { defaultAdjustments } from "@/features/adjustments/model";
import { resetColorMixer, setColorMixer } from "@/features/color-mixer/edits";
import {
  defaultMixer,
  type MixerChange,
  type MixerColor,
} from "@/features/color-mixer/model";
import { applyCrop } from "@/features/crop/edits";
import { setDetails } from "@/features/details/edits";
import { defaultDetails } from "@/features/details/model";
import { setFill } from "@/features/fill/edits";
import { setGrain } from "@/features/grain/edits";
import { defaultGrain } from "@/features/grain/model";
import {
  addHealPatch,
  addHealStroke,
  addRemovePatch,
  setHealSource,
} from "@/features/heal/edits";
import {
  addLayer,
  deleteLayer,
  duplicateLayer,
  type LayerPlacement,
  moveLayer,
  setLayer,
  setLayerMask,
  setMaskOperation,
} from "@/features/layers/edits";
import { defaultGradient } from "@/features/layers/gradient";
import { addPaintStroke, setPaintBlend } from "@/features/paint/edits";
import { defaultCurve } from "@/features/tone-curves/curve";
import { setToneCurve } from "@/features/tone-curves/edits";
import { setVignette } from "@/features/vignette/edits";
import { defaultVignette } from "@/features/vignette/model";
import { autoWhiteBalance } from "@/features/white-balance/auto";
import { setWhiteBalance } from "@/features/white-balance/edits";
import { type Command, runCommand } from "./commands";
import {
  createLayer,
  createMask,
  type DefaultEffect,
  editEffect,
  findEffect,
} from "./editor/layers";
import type { Workspace } from "./workspace";

/** Imperative commands bound to an explicit workspace, usable without React. */
export function createControls(
  gpu: Gpu,
  workspace: Workspace,
  drafts: DraftStore = createDraftStore(),
) {
  const image = createImageLoader(gpu, workspace);
  const xmp = createCameraRawXmpLoader(workspace);
  const scene = createSceneLoader(gpu, workspace);
  const lut = createLutLoader(workspace);
  const files = createLoaderRegistry(
    [scene, xmp, lut, image],
    () => workspace.state.getState().status === "ready",
  );

  return {
    openFiles: files.openFiles,
    openFile: (file: File) => files.openFiles([file]),
    loadImage: (file: File) => files.loadFile(image, file),
    loadUrl: image.loadUrl,
    loadScene: (file: File) => files.loadFile(scene, file),
    /** Opens the stored draft like a scene file; a draft that fails to open leaves the workspace in its error state. */
    async recoverDraft() {
      const draft = await drafts.read();
      if (!draft) {
        throw Error("There is no draft to recover.");
      }
      await workspace.open(draft.record.name, () =>
        openDraft(draft, (file) => decode(gpu, file)),
      );
    },
    discardDraft: () => drafts.discard(),
    importXmp: (file: File) => files.loadFile(xmp, file),
    setDetails(change: Partial<Details>, id?: string) {
      const document = workspace.getDocument();
      editEffect(document, "details", id, (id) =>
        setDetails(document, change, id),
      );
    },
    setAdjustments: (change: Partial<Adjustments>, id?: string) =>
      setAdjustments(workspace.getDocument(), change, id),
    setWhiteBalance: (change?: Partial<WhiteBalance>) =>
      setWhiteBalance(workspace.getDocument(), change),
    autoWhiteBalance: () => autoWhiteBalance(workspace.getDocument(), gpu),
    setToneCurve: (curve?: ToneCurve, id?: string) =>
      setToneCurve(workspace.getDocument(), curve, id),
    setColorMixer(color: MixerColor, change: MixerChange, id?: string) {
      const document = workspace.getDocument();
      editEffect(document, "color-mixer", id, (id) =>
        setColorMixer(document, color, change, id),
      );
    },
    resetColorMixer(id?: string) {
      const document = workspace.getDocument();
      const existing =
        id ?? findEffect(document.scene.getState().layers, "color-mixer")?.id;
      if (existing) {
        resetColorMixer(document, existing);
      }
    },
    setVignette(change: Partial<Vignette>, id?: string) {
      const document = workspace.getDocument();
      editEffect(document, "vignette", id, (id) =>
        setVignette(document, change, id),
      );
    },
    setGrain(change: Partial<Grain>, id?: string) {
      const document = workspace.getDocument();
      editEffect(document, "grain", id, (id) => setGrain(document, change, id));
    },
    setFill(change: Partial<Fill>, id?: string) {
      const document = workspace.getDocument();
      editEffect(document, "fill", id, (id) => setFill(document, change, id));
    },
    addHealPatch: (
      id: string,
      stroke: BrushStroke,
      offset: Point,
      mode?: Exclude<HealMode, "remove">,
    ) => addHealPatch(workspace.getDocument(), id, stroke, offset, mode),
    addHealStroke: (id: string, patch: string, stroke: BrushStroke) =>
      addHealStroke(workspace.getDocument(), id, patch, stroke),
    addRemovePatch: (id: string, stroke: BrushStroke) =>
      addRemovePatch(workspace.getDocument(), id, stroke),
    setHealSource: (id: string, patchId: string, offset: Point) =>
      setHealSource(workspace.getDocument(), id, patchId, offset),
    addPaintStroke: (id: string, stroke: PaintStroke) =>
      addPaintStroke(workspace.getDocument(), id, stroke),
    setPaintBlend: (id: string, blend: Blend) =>
      setPaintBlend(workspace.getDocument(), id, blend),
    addLayer(kind: DefaultEffect | "mask", placement?: LayerPlacement) {
      const document = workspace.getDocument();
      if (kind !== "mask") {
        return addLayer(document, createLayer(kind), placement);
      }
      const scene = document.scene.getState();
      const [width, height] = document.resources.get(scene.layers[0].source)
        .image.size;
      const mask = createMask(defaultGradient([width, height]));
      return addLayer(document, mask, placement);
    },
    setLayer: (id: string, change: Parameters<typeof setLayer>[2]) =>
      setLayer(workspace.getDocument(), id, change),
    setExposure: (id: string, exposure: number) =>
      setExposure(workspace.getDocument(), id, exposure),
    setLayerMask: (id: string, mask: Mask) =>
      setLayerMask(workspace.getDocument(), id, mask),
    setMaskOperation: (id: string, operation: MaskLayer["operation"]) =>
      setMaskOperation(workspace.getDocument(), id, operation),
    duplicateLayer: (id: string) => duplicateLayer(workspace.getDocument(), id),
    deleteLayer: (id: string) => deleteLayer(workspace.getDocument(), id),
    moveLayer: (id: string, index: number, parentId?: string) =>
      moveLayer(workspace.getDocument(), id, index, parentId),
    selectLayer: (id: string) => workspace.getDocument().selectLayer(id),
    setFrame: (frame: ImageFrame) => applyCrop(workspace.getDocument(), frame),
    setPreview: (change: Partial<Preview>) =>
      workspace.getDocument().preview.setState(change),
    beginEdit: () => workspace.getDocument().history.begin(),
    commitEdit: () => workspace.getDocument().history.commit(),
    cancelEdit: () => workspace.getDocument().history.cancel(),
    undo: () => workspace.getDocument().history.undo(),
    redo: () => workspace.getDocument().history.redo(),
    /** Validates and runs a serializable command, returning the layer it edited. */
    run: (command: Command) => runCommand(workspace, command),
    exportImage: (options?: ExportOptions) =>
      exportImage(gpu, workspace.getDocument(), options),
    exportScene: () => writeSceneFile(workspace.getDocument()),
    getState() {
      const current = workspace.state.getState();
      const { file, document } = current;
      const scene = document?.scene.getState();
      const layers = scene?.layers ?? [];
      let failure: { file: string; error: string } | undefined;
      if (current.status === "error") {
        failure = { file: current.file, error: current.error };
      } else if (current.status === "ready") {
        failure = current.failure;
      }
      return structuredClone({
        file,
        failure,
        preview: document?.preview.getState(),
        documentId: document?.id,
        scene,
        selectedLayerId: document?.selection.getState().layerId,
        size: scene?.frame.size,
        frame: scene?.frame,
        adjustments: scene?.layers[0].adjustments ?? defaultAdjustments,
        whiteBalance: scene?.layers[0].whiteBalance,
        details: findEffect(layers, "details")?.details ?? defaultDetails,
        toneCurve: scene?.layers[0].toneCurve ?? defaultCurve,
        colorMixer:
          findEffect(layers, "color-mixer")?.colorMixer ?? defaultMixer,
        vignette: findEffect(layers, "vignette")?.vignette ?? defaultVignette,
        grain: findEffect(layers, "grain")?.grain ?? defaultGrain,
        history: document?.history.status.getState() ?? {
          undoCount: 0,
          redoCount: 0,
        },
      });
    },
  };
}

declare global {
  interface Window {
    openlight: ReturnType<typeof createControls>;
  }
}