Skip to content

armgit / macro

Public Imported from GitHub
0

Macro is a unified workspace for teams: email, chat, docs, tasks, agents, calls, and CRM — @-linked together with shared AI memory.

15.5 KB
Raw Blame
/**
 * The editor's commands, as the menus, shortcuts, and panels run them:
 * clipboard, layers, masks, selections, canvas changes, filters and
 * adjustments (with their dialogs), exports, and the view. Each knows
 * whether it is available now.
 */

import type {
  Adjustment,
  FilterSpec,
  MaskInit,
  NewLayer,
  Op,
} from '@core/psd-engine/types';
import { fireAndForget } from '@core/util/fireAndForget';
import { Telemetry } from '@macro-inc/observability';
import { createSignal } from 'solid-js';
import {
  defaultAdjustment,
  type EditableAdjustment,
} from '../core/adjustments';
import type { FilterKind } from '../core/filters';
import { twoColorGradient } from '../core/gradient';
import {
  clippingOp,
  mergeDownOp,
  newLayerOp,
  nextLayerName,
} from '../core/ops';
import { stepBrushSize } from '../core/shortcuts';
import type { CanvasTools } from './create-canvas-tools';
import type { PsdEditor } from './create-psd-editor';
import type { PsdView } from './create-psd-view';

/** A dialog the editor shows. */
export type EditorDialog =
  | { kind: 'imageSize' }
  | { kind: 'canvasSize' }
  | { kind: 'filter'; filter: FilterKind }
  /** Image > Adjustments: applied to the pixels. */
  | { kind: 'adjust'; adjustment: Adjustment }
  | { kind: 'feather' }
  | { kind: 'expand'; contract: boolean }
  | { kind: 'resolution' };

export interface PsdCommandsOptions {
  editor: PsdEditor;
  view: PsdView;
  tools: CanvasTools;
  fileName: () => string;
  download: (blob: Blob, name: string) => void;
  notifyError: (message: string) => void;
  notifyInfo: (message: string) => void;
  /** A dialog closed: the keys go back to the editor. */
  onDialogClosed?: () => void;
}

const safeName = (name: string) =>
  name
    .replace(/[\\/:*?"<>|]+/g, '-')
    .replace(/\.(psd|psb)$/i, '')
    .trim() || 'image';

export function createPsdCommands(options: PsdCommandsOptions) {
  const { editor, view, tools } = options;
  const engine = editor.engine;
  const [dialog, setDialog] = createSignal<EditorDialog>();
  /** The pixels last copied here (when the system clipboard is closed). */
  let clipboard: Blob | undefined;

  const editable = () => editor.enabled();
  const active = () => editor.activeRow();
  const chosen = () => editor.selected();
  const pixelTarget = () => {
    const row = active();
    return row ? { id: row.id, target: editor.target() } : undefined;
  };

  // ---- clipboard ---------------------------------------------------------

  const writeClipboard = async (blob: Blob) => {
    clipboard = blob;
    try {
      await navigator.clipboard.write([
        new ClipboardItem({ 'image/png': blob }),
      ]);
    } catch {
      // Kept for pasting here; the system clipboard refused it.
    }
  };

  const copy = async (merged: boolean) => {
    const layer = merged ? undefined : active()?.id;
    if (!merged && layer === undefined) return;
    const blob = await editor.enqueue(() => engine.copyPixels(layer));
    if (blob) await writeClipboard(blob);
  };

  const cut = async () => {
    const t = pixelTarget();
    if (!t || !editor.hasSelection()) {
      options.notifyError('Select the pixels to cut first.');
      return;
    }
    await copy(false);
    await editor.apply([{ op: 'clear', id: t.id, target: t.target }]);
  };

  /** An image on the system clipboard, when the browser lets us read it. */
  const readClipboardImage = async (): Promise<Blob | undefined> => {
    try {
      for (const item of await navigator.clipboard.read()) {
        const type = item.types.find((t) => t.startsWith('image/'));
        if (type) return await item.getType(type);
      }
    } catch {
      // Closed to this page, or empty.
    }
    return undefined;
  };

  /**
   * Pastes an image as a layer: the one a paste event carried, else the
   * last copy made here, else (for Edit > Paste, `ask`) the system
   * clipboard's, which the browser may ask the person to allow.
   */
  const paste = async (image?: Blob, ask = false) => {
    if (!editable()) return;
    const blob =
      image ?? clipboard ?? (ask ? await readClipboardImage() : undefined);
    if (!blob) {
      options.notifyInfo('There is no image to paste.');
      return;
    }
    let bytes: ArrayBuffer;
    try {
      bytes = await blob.arrayBuffer();
    } catch (error) {
      Telemetry.error(error, { surface: 'psd-editor' });
      options.notifyError('The image could not be pasted.');
      return;
    }
    const camera = view.camera();
    const v = view.viewport();
    const center = {
      x: camera.x + v.w / 2 / camera.zoom,
      y: camera.y + v.h / 2 / camera.zoom,
    };
    // Into the view's middle, or the selection's when there is one.
    const sel = editor.selection().bounds;
    const at = sel ? { x: sel.x + sel.w / 2, y: sel.y + sel.h / 2 } : center;
    await placeImage(bytes, nextLayerName(editor.layers()), at);
  };

  const placeImage = async (
    bytes: ArrayBuffer,
    name: string,
    at?: { x: number; y: number }
  ) => {
    await editor.placeImage(bytes, name, at, active()?.id);
  };

  // ---- layers -------------------------------------------------------------

  const newLayer = (kind: NewLayer, name: string | null = null) =>
    editor.apply([newLayerOp(active(), kind, name)]);

  const newFill = (type: 'solid' | 'gradient') =>
    newLayer({
      type: 'fill',
      fill:
        type === 'solid'
          ? { type: 'solid', color: view.foreground() }
          : {
              type: 'gradient',
              gradient: twoColorGradient(view.foreground(), view.background()),
            },
      path: null,
      stroke: null,
    });

  const newAdjustment = (type: EditableAdjustment) =>
    newLayer({ type: 'adjustment', adjustment: defaultAdjustment(type) });

  const ids = () => chosen();

  /** Adds a mask to the active layer; painting then edits the mask. */
  const addMask = async (init: MaskInit) => {
    const row = active();
    if (!row) return;
    if (row.background) {
      options.notifyError('The Background layer cannot have a mask.');
      return;
    }
    if (row.hasMask) return;
    const result = await editor.apply([{ op: 'addMask', id: row.id, init }]);
    if (result && editor.active() === row.id) editor.setTarget('mask');
  };

  const filterOp = (filter: FilterSpec): Op[] => {
    const t = pixelTarget();
    return t ? [{ op: 'filter', id: t.id, target: t.target, filter }] : [];
  };

  const requirePixels = (): boolean => {
    const row = active();
    const target = editor.target();
    if (!row) return false;
    if (target === 'mask' ? !row.hasMask : row.kind !== 'pixel') {
      options.notifyError(
        `Rasterize "${row.name}" first: filters change pixels.`
      );
      return false;
    }
    return true;
  };

  // ---- exports ---------------------------------------------------------------

  const downloadPsd = async () => {
    const saved = await editor.enqueue(() => engine.save());
    if (!saved) return;
    const large = editor.summary().large;
    options.download(
      new Blob([saved.bytes], { type: 'image/vnd.adobe.photoshop' }),
      `${safeName(options.fileName())}.${large ? 'psb' : 'psd'}`
    );
  };

  const exportImage = async (format: 'png' | 'jpeg', layer?: number) => {
    const blob = await editor.enqueue(() =>
      format === 'png' ? engine.exportPng(layer) : engine.exportJpeg(90)
    );
    if (!blob) return;
    const row =
      layer === undefined
        ? undefined
        : editor.layers().find((r) => r.id === layer);
    options.download(
      blob,
      `${safeName(row?.name ?? options.fileName())}.${format === 'png' ? 'png' : 'jpg'}`
    );
  };

  // ---- the commands ------------------------------------------------------------

  const hasLayer = () => !!active();
  const run = {
    undo: () => fireAndForget(editor.undo(), 'psd-editor'),
    redo: () => fireAndForget(editor.redo(), 'psd-editor'),
    copy: () => fireAndForget(copy(false), 'psd-editor'),
    copyMerged: () => fireAndForget(copy(true), 'psd-editor'),
    cut: () => fireAndForget(cut(), 'psd-editor'),
    /** Edit > Paste. */
    paste: () => fireAndForget(paste(undefined, true), 'psd-editor'),
    layerViaCopy: () => {
      const row = active();
      if (row)
        fireAndForget(
          editor.apply([{ op: 'copyToLayer', id: row.id, cut: false }]),
          'psd-editor'
        );
    },
    layerViaCut: () => {
      const row = active();
      if (row)
        fireAndForget(
          editor.apply([{ op: 'copyToLayer', id: row.id, cut: true }]),
          'psd-editor'
        );
    },
    fillForeground: () => {
      const t = pixelTarget();
      if (t)
        fireAndForget(
          editor.apply([
            { op: 'fill', ...t, color: view.foreground(), opacity: 1 },
          ]),
          'psd-editor'
        );
    },
    fillBackground: () => {
      const t = pixelTarget();
      if (t)
        fireAndForget(
          editor.apply([
            { op: 'fill', ...t, color: view.background(), opacity: 1 },
          ]),
          'psd-editor'
        );
    },
    /** Delete: the selected pixels, else the chosen layers. */
    delete: () => {
      const t = pixelTarget();
      if (t && editor.hasSelection()) {
        fireAndForget(
          editor.apply([{ op: 'clear', id: t.id, target: t.target }]),
          'psd-editor'
        );
        return;
      }
      if (ids().length > 0)
        fireAndForget(
          editor.apply([{ op: 'delete', ids: ids() }]),
          'psd-editor'
        );
    },
    freeTransform: () =>
      fireAndForget(tools.startFreeTransform(), 'psd-editor'),
    flipLayer: (horizontal: boolean) => {
      if (ids().length > 0)
        fireAndForget(
          editor.apply([{ op: 'flip', ids: ids(), horizontal }]),
          'psd-editor'
        );
    },
    rotateLayer: (quarters: number) => {
      if (ids().length > 0)
        fireAndForget(
          editor.apply([{ op: 'rotate', ids: ids(), quarters }]),
          'psd-editor'
        );
    },
    newLayer: () => fireAndForget(newLayer({ type: 'pixel' }), 'psd-editor'),
    newGroup: () => fireAndForget(newLayer({ type: 'group' }), 'psd-editor'),
    newFill,
    newAdjustment,
    duplicate: () => {
      if (ids().length > 0)
        fireAndForget(
          editor.apply([{ op: 'duplicate', ids: ids() }]),
          'psd-editor'
        );
    },
    deleteLayers: () => {
      if (ids().length > 0)
        fireAndForget(
          editor.apply([{ op: 'delete', ids: ids() }]),
          'psd-editor'
        );
    },
    mergeDown: () => {
      const row = active();
      const op = row && mergeDownOp(editor.layers(), row.id);
      if (op) fireAndForget(editor.apply([op]), 'psd-editor');
    },
    mergeVisible: () => {
      const visible = editor.layers().filter((r) => r.shown && r.depth === 0);
      if (visible.length > 1)
        fireAndForget(
          editor.apply([{ op: 'merge', ids: visible.map((r) => r.id) }]),
          'psd-editor'
        );
    },
    flatten: () =>
      fireAndForget(editor.apply([{ op: 'flatten' }]), 'psd-editor'),
    rasterize: () => {
      if (ids().length > 0)
        fireAndForget(
          editor.apply([{ op: 'rasterize', ids: ids() }]),
          'psd-editor'
        );
    },
    group: () => {
      if (ids().length > 0)
        fireAndForget(
          editor.apply([{ op: 'group', ids: ids(), name: null }]),
          'psd-editor'
        );
    },
    ungroup: () => {
      const row = active();
      if (row?.kind === 'group')
        fireAndForget(
          editor.apply([{ op: 'ungroup', id: row.id }]),
          'psd-editor'
        );
    },
    clippingMask: () => {
      const row = active();
      const op = row && clippingOp(row);
      if (op) fireAndForget(editor.apply([op]), 'psd-editor');
    },
    addMask,
    deleteMask: (apply: boolean) => {
      const row = active();
      if (row?.hasMask) {
        editor.setTarget('pixels');
        fireAndForget(
          editor.apply([{ op: 'deleteMask', id: row.id, apply }]),
          'psd-editor'
        );
      }
    },
    toggleMask: () => {
      const row = active();
      if (row?.hasMask)
        fireAndForget(
          editor.apply([
            { op: 'setMask', id: row.id, disabled: !row.maskDisabled },
          ]),
          'psd-editor'
        );
    },
    selectAll: () =>
      fireAndForget(editor.select({ type: 'all' }), 'psd-editor'),
    deselect: () =>
      fireAndForget(editor.select({ type: 'none' }), 'psd-editor'),
    invertSelection: () =>
      fireAndForget(editor.select({ type: 'invert' }), 'psd-editor'),
    loadTransparency: () => {
      const row = active();
      if (row)
        fireAndForget(
          editor.select({
            type: 'layer',
            id: row.id,
            mask: editor.target() === 'mask',
          }),
          'psd-editor'
        );
    },
    convertToRgb: () => fireAndForget(editor.convertToRgb(), 'psd-editor'),
    rotateCanvas: (quarters: number) =>
      fireAndForget(
        editor.apply([{ op: 'rotateCanvas', quarters }]),
        'psd-editor'
      ),
    flipCanvas: (horizontal: boolean) =>
      fireAndForget(
        editor.apply([{ op: 'flipCanvas', horizontal }]),
        'psd-editor'
      ),
    cropToSelection: () => {
      const b = editor.selection().bounds;
      if (b)
        fireAndForget(editor.apply([{ op: 'crop', rect: b }]), 'psd-editor');
    },
    desaturate: () => {
      if (requirePixels())
        fireAndForget(
          editor.apply(filterOp({ type: 'desaturate' })),
          'psd-editor'
        );
    },
    openFilter: (filter: FilterKind) => {
      if (requirePixels()) setDialog({ kind: 'filter', filter });
    },
    openAdjust: (type: EditableAdjustment) => {
      if (requirePixels())
        setDialog({ kind: 'adjust', adjustment: defaultAdjustment(type) });
    },
    openDialog: (d: EditorDialog) => setDialog(d),
    downloadPsd: () => fireAndForget(downloadPsd(), 'psd-editor'),
    exportPng: () => fireAndForget(exportImage('png'), 'psd-editor'),
    exportJpeg: () => fireAndForget(exportImage('jpeg'), 'psd-editor'),
    exportLayer: () => {
      const row = active();
      if (row) fireAndForget(exportImage('png', row.id), 'psd-editor');
    },
    zoomIn: () => view.zoomStep(1),
    zoomOut: () => view.zoomStep(-1),
    zoomFit: () => view.zoomToFit(),
    zoom100: () => view.zoom100(),
    togglePixelGrid: () => view.setPixelGrid(!view.pixelGrid()),
    brushSmaller: () =>
      view.setBrush({ size: stepBrushSize(view.brush().size, -1) }),
    brushLarger: () =>
      view.setBrush({ size: stepBrushSize(view.brush().size, 1) }),
    brushSofter: () =>
      view.setBrush({
        hardness: Math.max(
          0,
          Math.round((view.brush().hardness - 0.25) * 4) / 4
        ),
      }),
    brushHarder: () =>
      view.setBrush({
        hardness: Math.min(
          1,
          Math.round((view.brush().hardness + 0.25) * 4) / 4
        ),
      }),
    swapColors: () => view.swapColors(),
    defaultColors: () => view.resetColors(),
  };

  return {
    run,
    dialog,
    closeDialog: () => {
      setDialog(undefined);
      options.onDialogClosed?.();
    },
    paste,
    placeImage,
    filterOp,
    available: {
      layer: hasLayer,
      pixels: () => {
        const row = active();
        return (
          !!row &&
          (editor.target() === 'mask' ? row.hasMask : row.kind === 'pixel')
        );
      },
      selection: () => editor.hasSelection(),
      mask: () => !!active()?.hasMask,
      group: () => active()?.kind === 'group',
      mergeDown: () => {
        const row = active();
        return !!row && !!mergeDownOp(editor.layers(), row.id);
      },
    },
  };
}

export type PsdCommands = ReturnType<typeof createPsdCommands>;