@ignix-social/editor 0.1.0

package/vendor/hyperframes/dist/chunk-DQBY7FRR.js

@@ -0,0 +1,397 @@
+import { createRequire as __hf_createRequire } from "node:module";
+import { fileURLToPath as __hf_fileURLToPath } from "node:url";
+import { dirname as __hf_dirname } from "node:path";
+var require = __hf_createRequire(import.meta.url);
+var __filename = __hf_fileURLToPath(import.meta.url);
+var __dirname = __hf_dirname(__filename);
+
+// src/utils/studioSelectionClient.ts
+import { existsSync, realpathSync } from "fs";
+import { resolve as resolve2 } from "path";
+
+// src/server/portUtils.ts
+import net from "net";
+import http from "http";
+import { execFile } from "child_process";
+import { promisify } from "util";
+import { resolve } from "path";
+var execFileAsync = promisify(execFile);
+var MAX_PORT_SCAN = 100;
+var PROBE_TIMEOUT_MS = 300;
+var PROBE_MAX_BYTES = 4096;
+async function isPortAvailableOnHost(port, host) {
+  const probe = net.createServer();
+  probe.unref();
+  const bindError = await new Promise((settle) => {
+    const handleError = (err) => settle(err);
+    probe.once("error", handleError);
+    probe.listen({ port, host }, () => {
+      probe.removeListener("error", handleError);
+      settle(null);
+    });
+  });
+  if (bindError !== null) {
+    return bindError.code !== "EADDRINUSE";
+  }
+  await new Promise((done) => probe.close(() => done()));
+  return true;
+}
+var PORT_PROBE_HOSTS = ["127.0.0.1", "0.0.0.0", "::1", "::"];
+async function testPortOnAllHosts(port, probe = isPortAvailableOnHost) {
+  for (const host of PORT_PROBE_HOSTS) {
+    const available = await probe(port, host);
+    if (!available) return false;
+  }
+  return true;
+}
+function detectHyperframesServer(port, normalizedProjectDir, expectedServerBuildSignature = null, expectedBrowserGpuMode) {
+  return new Promise((resolveResult) => {
+    const req = http.get(
+      {
+        hostname: "127.0.0.1",
+        port,
+        path: "/__hyperframes_config",
+        timeout: PROBE_TIMEOUT_MS
+      },
+      (res) => {
+        if (res.statusCode !== 200) {
+          res.resume();
+          return resolveResult({ type: "not-hyperframes" });
+        }
+        let data = "";
+        let bytes = 0;
+        res.on("data", (chunk) => {
+          bytes += typeof chunk === "string" ? chunk.length : chunk.byteLength;
+          if (bytes > PROBE_MAX_BYTES) {
+            req.destroy();
+            return resolveResult({ type: "not-hyperframes" });
+          }
+          data += chunk;
+        });
+        res.on("error", () => {
+          resolveResult({ type: "not-hyperframes" });
+        });
+        res.on("end", () => {
+          try {
+            const json = JSON.parse(data);
+            if (json.isHyperframes !== true) {
+              return resolveResult({ type: "not-hyperframes" });
+            }
+            const normalize = (p) => resolve(p).replace(/\\/g, "/").toLowerCase();
+            if (normalize(json.projectDir) === normalizedProjectDir) {
+              if (expectedServerBuildSignature !== null && json.serverBuildSignature !== expectedServerBuildSignature) {
+                return resolveResult({ type: "mismatch", projectName: json.projectName });
+              }
+              if (expectedBrowserGpuMode !== void 0 && json.browserGpuMode !== expectedBrowserGpuMode) {
+                return resolveResult({ type: "mismatch", projectName: json.projectName });
+              }
+              return resolveResult({ type: "match" });
+            }
+            return resolveResult({ type: "mismatch", projectName: json.projectName });
+          } catch {
+            resolveResult({ type: "not-hyperframes" });
+          }
+        });
+      }
+    );
+    req.on("error", () => {
+      resolveResult({ type: "not-hyperframes" });
+    });
+    req.on("timeout", () => {
+      req.destroy();
+      resolveResult({ type: "not-hyperframes" });
+    });
+  });
+}
+async function getProcessOnPort(port) {
+  if (process.platform === "win32") return windowsListenerPid(port);
+  try {
+    const { stdout } = await execFileAsync("lsof", [`-ti:${port}`, "-sTCP:LISTEN"], {
+      timeout: 2e3
+    });
+    const pid = stdout.trim().split("\n")[0]?.trim();
+    return pid || null;
+  } catch {
+    return null;
+  }
+}
+async function windowsListenerPid(port) {
+  try {
+    const { stdout } = await execFileAsync("netstat", ["-ano", "-p", "tcp"], { timeout: 4e3 });
+    for (const line of stdout.split(/\r?\n/)) {
+      const columns = line.trim().split(/\s+/);
+      if (columns.length < 5 || columns[3] !== "LISTENING") continue;
+      const local = columns[1] ?? "";
+      if (local.slice(local.lastIndexOf(":") + 1) !== String(port)) continue;
+      const pid = columns[4] ?? "";
+      return /^\d+$/.test(pid) && pid !== "0" ? pid : null;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+function probePort(port) {
+  return new Promise((resolveResult) => {
+    const req = http.get(
+      { hostname: "127.0.0.1", port, path: "/__hyperframes_config", timeout: PROBE_TIMEOUT_MS },
+      (res) => {
+        if (res.statusCode !== 200) {
+          res.resume();
+          return resolveResult(null);
+        }
+        let data = "";
+        let bytes = 0;
+        res.on("data", (chunk) => {
+          bytes += typeof chunk === "string" ? chunk.length : chunk.byteLength;
+          if (bytes > PROBE_MAX_BYTES) {
+            req.destroy();
+            return resolveResult(null);
+          }
+          data += chunk;
+        });
+        res.on("error", () => resolveResult(null));
+        res.on("end", () => {
+          try {
+            const json = JSON.parse(data);
+            resolveResult(json.isHyperframes === true ? json : null);
+          } catch {
+            resolveResult(null);
+          }
+        });
+      }
+    );
+    req.on("error", () => resolveResult(null));
+    req.on("timeout", () => {
+      req.destroy();
+      resolveResult(null);
+    });
+  });
+}
+async function scanActiveServers(startPort = 3002) {
+  const endPort = startPort + MAX_PORT_SCAN - 1;
+  const servers = [];
+  const batchSize = 20;
+  for (let batchStart = startPort; batchStart <= endPort; batchStart += batchSize) {
+    const batchEnd = Math.min(batchStart + batchSize - 1, endPort);
+    const ports = Array.from({ length: batchEnd - batchStart + 1 }, (_, i) => batchStart + i);
+    const results = await Promise.all(ports.map((port) => activeServerOnPort(port)));
+    for (const r of results) {
+      if (r) servers.push(r);
+    }
+  }
+  return servers;
+}
+async function activeServerOnPort(port, listenerLookup = getProcessOnPort) {
+  const config = await probePort(port);
+  if (!config) return null;
+  const listenerPid = await listenerLookup(port);
+  if (listenerPid) return { ...identityFrom(config, port), pid: listenerPid, pidSource: "os" };
+  const selfReported = Number.isInteger(config.pid) && Number(config.pid) > 0 ? String(config.pid) : null;
+  return {
+    ...identityFrom(config, port),
+    pid: selfReported,
+    ...selfReported ? { pidSource: "self-reported" } : {}
+  };
+}
+function identityFrom(config, port) {
+  return {
+    port,
+    projectName: config.projectName,
+    projectDir: config.projectDir,
+    version: config.version,
+    browserGpuMode: config.browserGpuMode
+  };
+}
+async function killActiveServers(startPort = 3002) {
+  const servers = await scanActiveServers(startPort);
+  let killed = 0;
+  const unverified = [];
+  for (const server of servers) {
+    if (!server.pid) continue;
+    if (server.pidSource !== "os") {
+      unverified.push(server.port);
+      continue;
+    }
+    try {
+      process.kill(parseInt(server.pid, 10), "SIGTERM");
+      killed++;
+    } catch {
+    }
+  }
+  return { killed, unverified };
+}
+async function findPortAndServe(fetch2, startPort, projectDir, forceNew, expectedServerBuildSignature = null, bindHost, expectedBrowserGpuMode) {
+  const { createAdaptorServer } = await import("@hono/node-server");
+  const host = bindHost ?? (process.env.HYPERFRAMES_PREVIEW_HOST?.trim() || "127.0.0.1");
+  const normalizedDir = resolve(projectDir).replace(/\\/g, "/").toLowerCase();
+  const endPort = startPort + MAX_PORT_SCAN - 1;
+  let server = null;
+  for (let port = startPort; port <= endPort; port++) {
+    const available = await testPortOnAllHosts(port);
+    if (available) {
+      if (!server) server = createAdaptorServer({ fetch: fetch2 });
+      try {
+        await new Promise((resolveListener, rejectListener) => {
+          const onError = (err) => {
+            server.removeListener("listening", onListening);
+            rejectListener(err);
+          };
+          const onListening = () => {
+            server.removeListener("error", onError);
+            resolveListener();
+          };
+          server.once("error", onError);
+          server.once("listening", onListening);
+          server.listen(port, host);
+        });
+        return { type: "started", server, port };
+      } catch (err) {
+        if (err.code === "EADDRINUSE") {
+          continue;
+        }
+        throw err;
+      }
+    }
+    if (!forceNew) {
+      const detection = await detectHyperframesServer(
+        port,
+        normalizedDir,
+        expectedServerBuildSignature,
+        expectedBrowserGpuMode
+      );
+      if (detection.type === "match") {
+        return { type: "already-running", port };
+      }
+      if (detection.type === "mismatch") {
+        continue;
+      }
+    }
+  }
+  throw new Error(
+    `Ports ${startPort}\u2013${endPort} are all in use. Use --port to specify a different starting port.`
+  );
+}
+
+// src/utils/studioSelectionClient.ts
+var VITE_STUDIO_DISCOVERY_PORTS = [5190];
+var AmbiguousPreviewServerError = class extends Error {
+  ports;
+  constructor(servers) {
+    const ports = servers.map((server) => server.port).sort((a, b) => a - b);
+    super(
+      `Multiple Studio preview servers match this project (${ports.join(", ")}). Pass --port <port> to choose one.`
+    );
+    this.name = "AmbiguousPreviewServerError";
+    this.ports = ports;
+  }
+};
+var PreviewServerPortMismatchError = class extends Error {
+  requestedPort;
+  ports;
+  constructor(requestedPort, servers, hint = "") {
+    const ports = servers.map((server) => server.port).sort((a, b) => a - b);
+    super(
+      `No Studio preview server for this project is running on port ${requestedPort}. Matching server port${ports.length === 1 ? "" : "s"}: ${ports.join(", ")}. Rerun with --port ${ports[0]}${ports.length > 1 ? " or omit --port to see all candidates" : ""}.${hint}`
+    );
+    this.name = "PreviewServerPortMismatchError";
+    this.requestedPort = requestedPort;
+    this.ports = ports;
+  }
+};
+function normalizePath(path) {
+  const resolved = resolve2(path);
+  try {
+    if (existsSync(resolved)) {
+      return realpathSync(resolved).replace(/\\/g, "/").toLowerCase();
+    }
+  } catch {
+  }
+  return resolved.replace(/\\/g, "/").toLowerCase();
+}
+async function findPreviewServerForProject(projectDir, startPort = 3002, scan = scanActiveServers, fetchImpl = fetch, options = {}) {
+  const normalizedProjectDir = normalizePath(projectDir);
+  const servers = await scan(startPort);
+  const embeddedServers = servers.filter(
+    (server) => normalizePath(server.projectDir) === normalizedProjectDir
+  );
+  if (options.preferredPort !== void 0) {
+    const preferred = embeddedServers.find((server) => server.port === options.preferredPort);
+    if (preferred) return preferred;
+    const viteServer = await findViteStudioServerForProject(normalizedProjectDir, fetchImpl, [
+      options.preferredPort
+    ]);
+    if (viteServer) return viteServer;
+    if (embeddedServers.length > 0) {
+      throw new PreviewServerPortMismatchError(options.preferredPort, embeddedServers);
+    }
+    return null;
+  }
+  if (embeddedServers.length === 1) return embeddedServers[0];
+  if (embeddedServers.length > 1) throw new AmbiguousPreviewServerError(embeddedServers);
+  return findViteStudioServerForProject(normalizedProjectDir, fetchImpl);
+}
+function studioSelectionUrl(server) {
+  return studioApiUrl(server, "selection");
+}
+function studioApiUrl(server, route) {
+  const host = server.host ?? "127.0.0.1";
+  return `http://${host}:${server.port}/api/projects/${encodeURIComponent(server.projectName)}/${route}`;
+}
+var LOOPBACK_HOSTS = ["127.0.0.1", "[::1]"];
+async function findViteStudioServerForProject(normalizedProjectDir, fetchImpl, ports = VITE_STUDIO_DISCOVERY_PORTS) {
+  for (const port of ports) {
+    for (const host of LOOPBACK_HOSTS) {
+      try {
+        const response = await fetchImpl(`http://${host}:${port}/api/projects`);
+        if (!response.ok) continue;
+        const payload = await response.json();
+        const project = payload.projects?.find(
+          (candidate) => normalizePath(candidate.dir) === normalizedProjectDir
+        );
+        if (!project) continue;
+        return {
+          port,
+          host,
+          projectName: project.id,
+          projectDir: project.dir,
+          version: "studio-dev",
+          pid: null
+        };
+      } catch {
+      }
+    }
+  }
+  return null;
+}
+async function fetchStudioSelection(server, fetchImpl = fetch) {
+  const url = studioSelectionUrl(server);
+  const response = await fetchImpl(url);
+  if (!response.ok) {
+    throw new Error(`selection endpoint returned ${response.status}`);
+  }
+  return await response.json();
+}
+async function fetchStudioLint(server, fetchImpl = fetch) {
+  const url = studioApiUrl(server, "lint");
+  const response = await fetchImpl(url);
+  if (!response.ok) {
+    throw new Error(`lint endpoint returned ${response.status}`);
+  }
+  return await response.json();
+}
+
+export {
+  MAX_PORT_SCAN,
+  scanActiveServers,
+  activeServerOnPort,
+  killActiveServers,
+  findPortAndServe,
+  AmbiguousPreviewServerError,
+  PreviewServerPortMismatchError,
+  findPreviewServerForProject,
+  studioSelectionUrl,
+  studioApiUrl,
+  fetchStudioSelection,
+  fetchStudioLint
+};

package/vendor/hyperframes/dist/chunk-E6RPWJVC.js

@@ -0,0 +1,213 @@
+import { createRequire as __hf_createRequire } from "node:module";
+import { fileURLToPath as __hf_fileURLToPath } from "node:url";
+import { dirname as __hf_dirname } from "node:path";
+var require = __hf_createRequire(import.meta.url);
+var __filename = __hf_fileURLToPath(import.meta.url);
+var __dirname = __hf_dirname(__filename);
+import {
+  writeCaptureFileSync
+} from "./chunk-MRF4AMKD.js";
+
+// src/capture/contactSheet.ts
+import sharp from "sharp";
+import { readdirSync, readFileSync, unlinkSync, existsSync } from "fs";
+import { join, extname, basename, dirname } from "path";
+async function createContactSheet(imagePaths, outputPath, opts = {}) {
+  const {
+    cols = 3,
+    maxImages = 16,
+    padding = 4,
+    labelMode = "index",
+    labels,
+    quality = 88,
+    cellWidth = 600
+  } = opts;
+  if ((opts.remainingMs?.() ?? 1) <= 0) return null;
+  const files = imagePaths.slice(0, maxImages);
+  if (files.length === 0) return null;
+  const firstMeta = await sharp(files[0]).metadata();
+  const srcW = firstMeta.width || 1920;
+  const srcH = firstMeta.height || 1080;
+  const scale = cellWidth / srcW;
+  const cellW = cellWidth;
+  const cellH = Math.round(srcH * scale);
+  const rows = Math.ceil(files.length / cols);
+  const labelH = 26;
+  const totalW = cols * cellW + (cols + 1) * padding;
+  const totalH = rows * (cellH + labelH) + (rows + 1) * padding;
+  const overlays = [];
+  for (let i = 0; i < files.length; i++) {
+    const col = i % cols;
+    const row = Math.floor(i / cols);
+    const x = padding + col * (cellW + padding);
+    const y = padding + row * (cellH + labelH + padding);
+    const resized = await sharp(files[i]).resize(cellW, cellH, { fit: "contain", background: { r: 26, g: 26, b: 26 } }).toBuffer();
+    overlays.push({ input: resized, left: x, top: y + labelH });
+    let labelText = `${i + 1}`;
+    if (labelMode === "filename") {
+      labelText = `${i + 1}. ${basename(files[i]).replace(extname(files[i]), "")}`;
+    } else if (labelMode === "custom" && labels?.[i]) {
+      labelText = `${i + 1}. ${labels[i]}`;
+    }
+    if (labelText.length > 60) labelText = labelText.slice(0, 57) + "...";
+    const labelSvg = Buffer.from(
+      `<svg width="${cellW}" height="${labelH}"><rect width="${cellW}" height="${labelH}" fill="#1a1a1a"/><text x="8" y="18" font-family="Arial,Helvetica,sans-serif" font-size="13" font-weight="bold" fill="#ffffff">${escapeXml(labelText)}</text></svg>`
+    );
+    overlays.push({ input: labelSvg, left: x, top: y });
+  }
+  const sheet = sharp({
+    create: {
+      width: totalW,
+      height: totalH,
+      channels: 3,
+      background: { r: 26, g: 26, b: 26 }
+    }
+  }).composite(overlays);
+  const encoded = extname(outputPath).toLowerCase() === ".png" ? await sheet.png().toBuffer() : await sheet.jpeg({ quality }).toBuffer();
+  writeCaptureFileSync(outputPath, encoded);
+  return outputPath;
+}
+function escapeXml(s) {
+  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
+}
+async function createContactSheetPages(imagePaths, outputBasePath, opts = {}, labelOffset = 0, customLabels) {
+  if (imagePaths.length === 0) return [];
+  const { pageSize = imagePaths.length, remainingMs, ...sheetOpts } = opts;
+  const ext = outputBasePath.match(/\.[^.]+$/)?.[0] ?? ".jpg";
+  const base = outputBasePath.slice(0, -ext.length);
+  const pages = Math.ceil(imagePaths.length / pageSize);
+  const results = [];
+  for (let p = 0; p < pages; p++) {
+    if ((remainingMs?.() ?? 1) <= 0) break;
+    const chunk = imagePaths.slice(p * pageSize, (p + 1) * pageSize);
+    const chunkLabels = customLabels?.slice(p * pageSize, (p + 1) * pageSize);
+    const outPath = pages === 1 ? outputBasePath : `${base}-${p + 1}${ext}`;
+    const labelsForChunk = chunkLabels ? { labelMode: "custom", labels: chunkLabels } : sheetOpts.labelMode === "filename" ? { labelMode: "filename" } : { labelMode: "index" };
+    const written = await createContactSheet(chunk, outPath, {
+      ...sheetOpts,
+      ...labelsForChunk,
+      maxImages: chunk.length
+    });
+    if (written) results.push(written);
+    void labelOffset;
+  }
+  return results;
+}
+async function createScrollContactSheet(screenshotsDir, outputPath, budget = {}) {
+  if (!existsSync(screenshotsDir)) return [];
+  const scrollFiles = readdirSync(screenshotsDir).filter((f) => f.startsWith("scroll-") && f.endsWith(".png")).sort();
+  if (scrollFiles.length === 0) return [];
+  const paths = scrollFiles.map((f) => join(screenshotsDir, f));
+  const labels = scrollFiles.map((f) => {
+    const m = f.match(/scroll-(\d+)\.png/);
+    return m ? `${m[1]}% scroll` : f;
+  });
+  return createContactSheetPages(
+    paths,
+    outputPath,
+    { cols: 3, cellWidth: 600, pageSize: 9, ...budget },
+    0,
+    labels
+  );
+}
+async function createSnapshotContactSheet(snapshotsDir, outputPath, budget = {}) {
+  if (!existsSync(snapshotsDir)) return [];
+  const snapshotFiles = readdirSync(snapshotsDir).filter((f) => f.startsWith("frame-") && f.endsWith(".png")).sort();
+  if (snapshotFiles.length === 0) return [];
+  const paths = snapshotFiles.map((f) => join(snapshotsDir, f));
+  const labels = snapshotFiles.map((f) => {
+    const m = f.match(/at-([\d.]+)s/);
+    return m ? `${m[1]}s` : f;
+  });
+  return createContactSheetPages(
+    paths,
+    outputPath,
+    { cols: 3, cellWidth: 600, pageSize: 9, ...budget },
+    0,
+    labels
+  );
+}
+async function createAssetContactSheet(assetsDir, outputPath, budget = {}) {
+  if (!existsSync(assetsDir)) return [];
+  const imageExts = /* @__PURE__ */ new Set([".png", ".jpg", ".jpeg", ".webp"]);
+  const assetFiles = readdirSync(assetsDir).filter((f) => imageExts.has(extname(f).toLowerCase()) && !f.includes("contact-sheet")).sort();
+  if (assetFiles.length === 0) return [];
+  const paths = assetFiles.map((f) => join(assetsDir, f));
+  return createContactSheetPages(paths, outputPath, {
+    cols: 4,
+    cellWidth: 480,
+    labelMode: "filename",
+    pageSize: 12,
+    ...budget
+  });
+}
+async function createSvgContactSheet(svgsDir, outputPath, assetsRootDir, budget = {}) {
+  const dirsToScan = [svgsDir, assetsRootDir].filter(
+    (d) => d !== void 0 && existsSync(d)
+  );
+  if (dirsToScan.length === 0) return [];
+  const seen = /* @__PURE__ */ new Set();
+  const svgPaths = [];
+  for (const dir of dirsToScan) {
+    for (const f of readdirSync(dir).filter((f2) => f2.endsWith(".svg")).sort()) {
+      if (!seen.has(f)) {
+        seen.add(f);
+        svgPaths.push(join(dir, f));
+      }
+    }
+  }
+  if (svgPaths.length === 0) return [];
+  const svgFileNames = svgPaths.map((p) => p.split("/").pop());
+  const thumbSize = 200;
+  const tmpDir = dirname(outputPath);
+  const tmpPaths = [];
+  const labels = [];
+  for (let i = 0; i < svgPaths.length; i++) {
+    if ((budget.remainingMs?.() ?? 1) <= 0) break;
+    const svgPath = svgPaths[i];
+    const tmpPath = join(tmpDir, `.thumb-${i}.png`);
+    try {
+      const svgBuf = readFileSync(svgPath);
+      const thumb = await sharp(svgBuf).resize(thumbSize, thumbSize, {
+        fit: "contain",
+        background: { r: 245, g: 245, b: 245, alpha: 1 }
+      }).flatten({ background: { r: 245, g: 245, b: 245 } }).png().toBuffer();
+      writeCaptureFileSync(tmpPath, thumb);
+      tmpPaths.push(tmpPath);
+      labels.push(svgFileNames[i].replace(".svg", ""));
+    } catch {
+    }
+  }
+  if (tmpPaths.length === 0) return [];
+  let results = [];
+  try {
+    results = await createContactSheetPages(
+      tmpPaths,
+      outputPath,
+      {
+        cols: 5,
+        cellWidth: thumbSize,
+        pageSize: 15,
+        ...budget
+      },
+      0,
+      labels
+    );
+  } finally {
+    for (const tmp of tmpPaths) {
+      try {
+        unlinkSync(tmp);
+      } catch {
+      }
+    }
+  }
+  return results;
+}
+
+export {
+  createContactSheet,
+  createScrollContactSheet,
+  createSnapshotContactSheet,
+  createAssetContactSheet,
+  createSvgContactSheet
+};