code.ts

// code.ts — v13: proxy fetch через plugin sandbox (обход CORS для Gitea)

figma.showUI(__html__, { width: 560, height: 820, themeColors: true });

interface FrameInfo { name: string; width: number; height: number; section?: string; }

function isIOSScreenshot(name: string): boolean { return /^\d+_APP_/.test(name); }

const ANDROID_SECTIONS: Record<string, { folder: string; scale: number }> = {
  "ANDROID PHONE":      { folder: "phoneScreenshots",     scale: 3 },
  "ANDROID TAB 7 INCH": { folder: "sevenInchScreenshots", scale: 3 },
  "ANDROID TAB 10 INCH":{ folder: "tenInchScreenshots",   scale: 2 },
  "ANDROID TV":         { folder: "tvScreenshots",         scale: 2 },
  "FEATUREGRAPHIC":     { folder: "__feature__",           scale: 1 },
};

function norm(s: string) { return s.trim().toUpperCase().replace(/\s+/g, " "); }

function extractFrameIndex(frameName: string): number | null {
  const m = frameName.match(/^(\d+)/);
  return m ? parseInt(m[1]) : null;
}

function getIOSFrames(page: PageNode): FrameInfo[] {
  return page.children
    .filter(n => (n.type === "FRAME" || n.type === "COMPONENT" || n.type === "INSTANCE") && isIOSScreenshot(n.name))
    .map(f => ({ name: f.name, width: Math.round(f.width), height: Math.round(f.height) }));
}

function getAndroidFrames(page: PageNode): { frames: FrameInfo[]; sections: string[] } {
  const frames: FrameInfo[] = [], sections: string[] = [];
  for (const child of page.children) {
    if (child.type === "SECTION" && ANDROID_SECTIONS[norm(child.name)]) {
      sections.push(child.name);
      for (const sub of (child as SectionNode).children) {
        if (sub.type === "FRAME" || sub.type === "COMPONENT" || sub.type === "INSTANCE")
          frames.push({ name: sub.name, width: Math.round(sub.width), height: Math.round(sub.height), section: child.name });
      }
    }
  }
  return { frames, sections };
}

function sendDocInfo() {
  figma.ui.postMessage({ type: "doc-info", docName: figma.root.name });
}

function sendPagesInfo(storeType: string) {
  const pages: any[] = figma.root.children.map(p => {
    const all = p.children.length;
    if (storeType === "playmarket") {
      const { frames, sections } = getAndroidFrames(p);
      return { id: p.id, name: p.name, frames, sections, allFramesCount: all, skippedCount: all - frames.length };
    }
    const frames = getIOSFrames(p);
    return { id: p.id, name: p.name, frames, allFramesCount: all, skippedCount: all - frames.length };
  });
  figma.ui.postMessage({ type: "pages-info", pages });
}

// ─── Proxy fetch (обход CORS) ────────────────────────────────────────────────
// UI не может напрямую обращаться к Gitea из-за отсутствия CORS-заголовков.
// Все HTTP-запросы к Git API проксируются через plugin sandbox — он не ограничен CORS.
async function proxyFetch(reqId: string, url: string, options: any) {
  try {
    const res = await fetch(url, {
      method: options.method || "GET",
      headers: options.headers || {},
      body: options.body != null ? options.body : undefined,
    });
    // Читаем тело как текст (JSON либо пустое)
    const text = await res.text();
    figma.ui.postMessage({
      type: "proxy-response",
      reqId,
      ok: res.ok,
      status: res.status,
      body: text,
    });
  } catch (e: any) {
    figma.ui.postMessage({
      type: "proxy-response",
      reqId,
      ok: false,
      status: 0,
      body: JSON.stringify({ message: e.message || String(e) }),
    });
  }
}

let stopRequested = false;

async function exportFrames(
  pageIds: string[],
  storeType: string,
  scaleMap: Record<string, number> | null,
  defaultScale: number,
  sectionFilter: string[] | null
) {
  stopRequested = false;
  const toExport = figma.root.children.filter(p => pageIds.includes(p.id));
  let total = 0;
  for (const p of toExport) {
    if (storeType === "playmarket") {
      const { frames } = getAndroidFrames(p);
      total += sectionFilter
        ? frames.filter(f => f.section && sectionFilter.includes(norm(f.section))).length
        : frames.length;
    } else {
      total += getIOSFrames(p).length;
    }
  }
  figma.ui.postMessage({ type: "export-start", total });

  let done = 0;
  for (const page of toExport) {
    if (stopRequested) break;
    figma.currentPage = page;

    if (storeType === "playmarket") {
      for (const child of page.children) {
        if (stopRequested) break;
        if (child.type !== "SECTION") continue;
        const sectionNorm = norm(child.name);
        const cfg = ANDROID_SECTIONS[sectionNorm];
        if (!cfg) continue;
        if (sectionFilter && !sectionFilter.includes(sectionNorm)) continue;
        const sectionScale = (scaleMap && scaleMap[sectionNorm] != null)
          ? scaleMap[sectionNorm]
          : cfg.scale;

        for (const frame of (child as SectionNode).children) {
          if (stopRequested) break;
          if (frame.type !== "FRAME" && frame.type !== "COMPONENT" && frame.type !== "INSTANCE") continue;
          try {
            const bytes = await (frame as FrameNode).exportAsync({ format: "PNG", constraint: { type: "SCALE", value: sectionScale } });
            done++;
            const frameIndex = extractFrameIndex(frame.name);
            figma.ui.postMessage({
              type: "frame-exported",
              pageName: page.name,
              frameName: frame.name,
              frameIndex,
              width: Math.round(frame.width),
              height: Math.round(frame.height),
              scale: sectionScale,
              section: child.name,
              folder: cfg.folder,
              bytes: Array.from(bytes),
              current: done,
              total
            });
          } catch (e) {
            done++;
            figma.ui.postMessage({ type: "log", level: "error", text: `Fail: ${frame.name}: ${e}` });
          }
        }
      }
    } else {
      const frames = page.children.filter(n =>
        (n.type === "FRAME" || n.type === "COMPONENT" || n.type === "INSTANCE") && isIOSScreenshot(n.name)
      );
      for (const frame of frames) {
        if (stopRequested) break;
        try {
          let scale = defaultScale;
          if (scaleMap) {
            const u = frame.name.toUpperCase();
            for (const [k, v] of Object.entries(scaleMap)) { if (u.includes(k)) { scale = v; break; } }
          }
          const bytes = await (frame as FrameNode).exportAsync({ format: "PNG", constraint: { type: "SCALE", value: scale } });
          done++;
          figma.ui.postMessage({
            type: "frame-exported",
            pageName: page.name,
            frameName: frame.name,
            frameIndex: null,
            width: Math.round(frame.width),
            height: Math.round(frame.height),
            scale,
            bytes: Array.from(bytes),
            current: done,
            total
          });
        } catch (e) {
          done++;
          figma.ui.postMessage({ type: "log", level: "error", text: `Fail: ${frame.name}: ${e}` });
        }
      }
    }
  }
  figma.ui.postMessage({ type: "export-done", exported: done, total, stopped: stopRequested });
}

figma.ui.onmessage = msg => {
  if (msg.type === "get-doc-info") sendDocInfo();
  if (msg.type === "get-pages") sendPagesInfo(msg.store || "appstore");
  if (msg.type === "export-frames") exportFrames(
    msg.pages || [],
    msg.store || "appstore",
    msg.scaleMap || null,
    msg.scale || 2,
    msg.sectionFilter || null
  );
  if (msg.type === "stop-export") stopRequested = true;
  if (msg.type === "cancel") figma.closePlugin();
  // Проксируем HTTP-запросы из UI через sandbox (обход CORS)
  if (msg.type === "proxy-fetch") proxyFetch(msg.reqId, msg.url, msg.options || {});
};

sendDocInfo();
sendPagesInfo("appstore");