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.

5.4 KB
Raw Blame
/**
 * Handoff around the editor: exporting the selection with its presets
 * (one file or a ZIP), "Export frames to PDF", storing presets and layout
 * grids on layers, the export preview, and Dev Mode's assets (the
 * selection and the layers inside it with presets).
 */

import type { FigEngine } from '@core/fig-engine/client';
import type {
  Exportable,
  ExportSetting,
  LayoutGridInfo,
} from '@core/fig-engine/handoff-types';
import type { NodeInfo } from '@core/fig-engine/types';
import { fireAndForget } from '@core/util/fireAndForget';
import { createEffect, createSignal, on } from 'solid-js';
import type { FigViewerContext } from '../context/fig-viewer-context';
import { defaultSetting } from '../core/export-settings';
import { gridSpec } from '../core/handoff-ops';
import type { FigEditor } from './create-fig-editor';
import type { FigViewer } from './create-fig-viewer';

/** The preview's longest side, in pixels. */
const PREVIEW_SIDE = 480;

export function createHandoff(options: {
  context: FigViewerContext;
  engine: FigEngine;
  viewer: FigViewer;
  editor: FigEditor;
  /** The single selected layer's properties. */
  info: () => NodeInfo | undefined;
  /** Dev Mode (the Code tab) is showing. */
  devMode: () => boolean;
}) {
  const { context, engine, viewer, editor } = options;

  const fail = (e: unknown, fallback: string) =>
    context.notifyError(e instanceof Error ? e.message : fallback);

  /**
   * Exports the selection: with `settings` (every selected layer), or each
   * layer's own presets, 1x PNG for layers without any.
   */
  const exportSelection = async (settings?: ExportSetting[]) => {
    const selected = viewer.selected().map((s) => s.id);
    if (selected.length === 0) {
      context.notifyInfo('Select a layer to export');
      return;
    }
    try {
      let items = selected.map((id) => ({
        id,
        settings: settings ?? null,
      }));
      if (!settings) {
        // Layers without presets export at 1x, as Figma's ⇧⌘E does.
        const own = await Promise.all(
          selected.map((id) => engine.nodeInfo(viewer.page(), id))
        );
        items = own.map((i) => ({
          id: i.id,
          settings: i.exportSettings.length ? null : [defaultSetting()],
        }));
      }
      const file = await engine.exportFiles(viewer.page(), {
        items,
        zipName: context.fileName(),
      });
      context.download(file.blob, file.name);
    } catch (e) {
      fail(e, 'Export failed');
    }
  };

  /** One layer with one preset (a Dev Mode asset). */
  const downloadAsset = async (id: string, setting: ExportSetting) => {
    try {
      const file = await engine.exportFiles(viewer.page(), {
        items: [{ id, settings: [setting] }],
      });
      context.download(file.blob, file.name);
    } catch (e) {
      fail(e, 'Export failed');
    }
  };

  /** "Export frames to PDF": the page's top-level frames, a page each. */
  const exportFramesPdf = async () => {
    try {
      const pdf = await engine.exportFramesPdf(viewer.page());
      const page = viewer.pages[viewer.page()]?.name ?? 'Page';
      context.download(pdf, `${context.fileName()} - ${page}.pdf`);
    } catch (e) {
      fail(e, 'Export failed');
    }
  };

  /** Stores presets on the selected layers. */
  const setExports = (settings: ExportSetting[]) => {
    const ids = editor.editableIds();
    if (ids.length === 0) return;
    fireAndForget(
      editor.apply([{ op: 'setExports', ids, settings }]),
      'fig-handoff'
    );
  };

  // A drag (a color, a scrubbed value) is one undo step.
  let gridGesture: string | undefined;
  let gestures = 0;
  /** Replaces the selected frame's layout grids. */
  const setGrids = (grids: LayoutGridInfo[], live: boolean) => {
    const id = options.info()?.id;
    if (!id || id.startsWith('I')) return;
    if (live && !gridGesture) gridGesture = `layout-grids-${++gestures}`;
    const key = gridGesture;
    if (!live) gridGesture = undefined;
    fireAndForget(
      editor.apply(
        [{ op: 'setLayoutGrids', ids: [id], grids: grids.map(gridSpec) }],
        key
      ),
      'fig-handoff'
    );
  };

  /** A PNG of the selected layer for the preview (an object URL). */
  const preview = async (): Promise<string | undefined> => {
    const info = options.info();
    if (!info) return undefined;
    const side = Math.max(info.bounds.w, info.bounds.h, 1);
    const scale = Math.min(2, PREVIEW_SIDE / side);
    try {
      const png = await engine.exportPng(viewer.page(), info.id, scale);
      return URL.createObjectURL(png);
    } catch {
      return undefined;
    }
  };

  const [assets, setAssets] = createSignal<Exportable[]>([]);
  let request = 0;
  const loadAssets = async (id: string) => {
    const mine = ++request;
    try {
      const list = await engine.exportables(viewer.page(), id);
      if (mine === request) setAssets(list);
    } catch {
      if (mine === request) setAssets([]);
    }
  };
  // Dev Mode reads the engine (an external system) after every edit.
  createEffect(
    on([options.devMode, viewer.selected, viewer.editVersion], ([dev, sel]) => {
      if (!dev || sel.length !== 1) {
        ++request;
        setAssets([]);
        return;
      }
      fireAndForget(loadAssets(sel[0].id), 'fig-handoff');
    })
  );

  return {
    exportSelection,
    exportFramesPdf,
    downloadAsset,
    setExports,
    setGrids,
    preview,
    assets,
  };
}

export type Handoff = ReturnType<typeof createHandoff>;