@ignix-social/editor 0.1.0

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

@@ -0,0 +1,356 @@
+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 {
+  forceRefreshCredentials,
+  resolveCloudAuthHeaders,
+  resolveCloudBaseUrl
+} from "./chunk-SHB5VDMH.js";
+import {
+  errorBox
+} from "./chunk-IHFUKJOR.js";
+import {
+  failCommand
+} from "./chunk-PBN6GBJE.js";
+
+// src/cloud/poll.ts
+var DEFAULT_POLL_INTERVAL_MS = 1e4;
+var DEFAULT_MAX_WAIT_MS = 60 * 60 * 1e3;
+var TERMINAL_STATUSES = /* @__PURE__ */ new Set(["completed", "failed"]);
+var PollTimeoutError = class extends Error {
+  lastDetail;
+  constructor(lastDetail, elapsedMs) {
+    super(
+      `Render ${lastDetail.render_id} did not reach a terminal state within ${Math.round(elapsedMs / 1e3)}s`
+    );
+    this.name = "PollTimeoutError";
+    this.lastDetail = lastDetail;
+  }
+};
+function isTerminal(status) {
+  return TERMINAL_STATUSES.has(status);
+}
+async function pollUntilTerminal(client, renderId, options = {}) {
+  const intervalMs = options.intervalMs ?? DEFAULT_POLL_INTERVAL_MS;
+  const maxWaitMs = options.maxWaitMs ?? DEFAULT_MAX_WAIT_MS;
+  const now = options.now ?? (() => Date.now());
+  const sleep = options.sleep ?? defaultAbortableSleep(options.signal);
+  const started = now();
+  while (true) {
+    if (options.signal?.aborted) {
+      throw signalAbortError(options.signal);
+    }
+    const detail = await client.getRender({ render_id: renderId, signal: options.signal });
+    const elapsed = now() - started;
+    options.onTick?.(detail, elapsed);
+    if (isTerminal(detail.status)) {
+      return detail;
+    }
+    if (elapsed >= maxWaitMs) {
+      throw new PollTimeoutError(detail, elapsed);
+    }
+    await sleep(intervalMs);
+  }
+}
+function signalAbortError(signal) {
+  const reason = signal.reason;
+  return reason instanceof Error ? reason : new Error("Poll aborted");
+}
+function defaultAbortableSleep(signal) {
+  return (ms) => new Promise((resolve, reject) => {
+    const onAbort = () => {
+      clearTimeout(timer);
+      reject(signalAbortError(signal));
+    };
+    const timer = setTimeout(() => {
+      signal?.removeEventListener("abort", onAbort);
+      resolve();
+    }, ms);
+    signal?.addEventListener("abort", onAbort, { once: true });
+  });
+}
+
+// src/cloud/_gen/client.ts
+var HyperframesApiError = class extends Error {
+  status;
+  code;
+  param;
+  docUrl;
+  raw;
+  constructor(opts) {
+    super(opts.message);
+    this.name = "HyperframesApiError";
+    this.status = opts.status;
+    this.code = opts.code;
+    this.param = opts.param;
+    this.docUrl = opts.docUrl;
+    this.raw = opts.raw;
+  }
+};
+var HyperframesCloudClient = class {
+  baseUrl;
+  getAuthHeaders;
+  fetchImpl;
+  constructor(opts) {
+    this.baseUrl = opts.baseUrl.replace(/\/+$/, "");
+    this.getAuthHeaders = opts.getAuthHeaders;
+    this.fetchImpl = opts.fetchImpl ?? fetch;
+  }
+  async request(opts) {
+    const url = this.buildUrl(opts.path, opts.query);
+    const auth = await this.getAuthHeaders();
+    const headers = { ...auth };
+    let body;
+    if (opts.multipart) {
+      body = opts.multipart;
+    } else if (opts.body !== void 0) {
+      headers["content-type"] = "application/json";
+      body = JSON.stringify(opts.body);
+    }
+    if (opts.idempotencyKey) {
+      headers["Idempotency-Key"] = opts.idempotencyKey;
+    }
+    const res = await this.fetchImpl(url, {
+      method: opts.method,
+      headers,
+      body,
+      signal: opts.signal
+    });
+    if (!res.ok) {
+      throw await this.toApiError(res);
+    }
+    if (res.status === 204) {
+      return void 0;
+    }
+    const text = await res.text();
+    if (!text) {
+      return void 0;
+    }
+    let parsed;
+    try {
+      parsed = JSON.parse(text);
+    } catch (err) {
+      throw new HyperframesApiError({
+        status: res.status,
+        message: `Invalid JSON response: ${err.message}`,
+        raw: text.slice(0, 500)
+      });
+    }
+    const unwrap = opts.unwrapData !== false;
+    if (unwrap && parsed && typeof parsed === "object" && "data" in parsed) {
+      const envelope = parsed;
+      return envelope.data;
+    }
+    return parsed;
+  }
+  buildUrl(path, query) {
+    const url = new URL(this.baseUrl + path);
+    if (query) {
+      for (const [k, v] of Object.entries(query)) {
+        if (v === void 0) continue;
+        url.searchParams.set(k, String(v));
+      }
+    }
+    return url.toString();
+  }
+  async toApiError(res) {
+    let parsed;
+    try {
+      parsed = await res.json();
+    } catch {
+      parsed = void 0;
+    }
+    const err = parsed && typeof parsed === "object" && "error" in parsed ? parsed.error : void 0;
+    return new HyperframesApiError({
+      status: res.status,
+      message: err && typeof err.message === "string" && err.message || `HTTP ${res.status} ${res.statusText}`,
+      code: err && typeof err.code === "string" ? err.code : void 0,
+      param: err && (typeof err.param === "string" || err.param === null) ? err.param : void 0,
+      docUrl: err && (typeof err.doc_url === "string" || err.doc_url === null) ? err.doc_url : void 0,
+      raw: parsed
+    });
+  }
+  /**
+   * Upload Asset
+   *
+   * Uploads a file (image, video, audio, PDF, or SRT subtitle) and returns an asset_id for use in other endpoints. Max 32 MB. Supported types: png, jpeg, mp4, webm, mp3, wav, pdf, srt.
+   */
+  async uploadAsset(args) {
+    const fd = new FormData();
+    const blobOpts = args.mimeType ? { type: args.mimeType } : void 0;
+    const blob = args.file instanceof Blob ? args.file : new Blob([args.file], blobOpts);
+    fd.append("file", blob, args.filename);
+    return await this.request({
+      method: "POST",
+      path: "/v3/assets",
+      multipart: fd,
+      idempotencyKey: args.idempotencyKey,
+      signal: args.signal
+    });
+  }
+  /**
+   * Create Asset Upload
+   *
+   * Begin a direct-to-S3 upload. Returns an asset_id and a presigned upload_url; PUT the file bytes to upload_url, then call POST /v3/assets/{asset_id}/complete. Unlike POST /v3/assets (which proxies the bytes), this never sends the file through the API.
+   */
+  async createAssetUpload(args) {
+    return await this.request({
+      method: "POST",
+      path: "/v3/assets/direct-uploads",
+      body: args.body,
+      idempotencyKey: args.idempotencyKey,
+      signal: args.signal
+    });
+  }
+  /**
+   * Complete Asset Upload
+   *
+   * Finalize a direct-to-S3 upload into a reusable asset. Call after the upload PUT returns 200. Idempotent: repeated calls return the same finalized asset.
+   */
+  async completeAssetUpload(args) {
+    return await this.request({
+      method: "POST",
+      path: `/v3/assets/${encodeURIComponent(args.asset_id)}/complete`,
+      body: args.body,
+      signal: args.signal
+    });
+  }
+  /**
+   * Create HyperFrames Render
+   *
+   * Renders a HyperFrames composition (an HTML+JS+assets project bundled as a .zip) into a video. Submit the project via `url`, `asset_id` (pre-uploaded via POST /v3/assets), or inline `base64`. Returns a `render_id` to poll via GET /v3/hyperframes/renders/{render_id}.
+   */
+  async createRender(args) {
+    return await this.request({
+      method: "POST",
+      path: "/v3/hyperframes/renders",
+      body: args.body,
+      idempotencyKey: args.idempotencyKey,
+      signal: args.signal
+    });
+  }
+  /**
+   * List HyperFrames Renders
+   *
+   * Returns a cursor-paginated list of HyperFrames renders in the account, newest first.
+   */
+  async listRenders(args) {
+    const query = {
+      limit: args.limit,
+      token: args.token
+    };
+    return await this.request({
+      method: "GET",
+      path: "/v3/hyperframes/renders",
+      query,
+      unwrapData: false,
+      signal: args.signal
+    });
+  }
+  /**
+   * Get HyperFrames Render
+   *
+   * Returns full details for a single HyperFrames render, including status and signed video_url when complete.
+   */
+  async getRender(args) {
+    return await this.request({
+      method: "GET",
+      path: `/v3/hyperframes/renders/${encodeURIComponent(args.render_id)}`,
+      signal: args.signal
+    });
+  }
+  /**
+   * Delete HyperFrames Render
+   *
+   * Soft-deletes a HyperFrames render. Subsequent GETs return 404.
+   */
+  async deleteRender(args) {
+    return await this.request({
+      method: "DELETE",
+      path: `/v3/hyperframes/renders/${encodeURIComponent(args.render_id)}`,
+      signal: args.signal
+    });
+  }
+};
+
+// src/cloud/index.ts
+async function createCloudClient() {
+  const client = new HyperframesCloudClient({
+    baseUrl: resolveCloudBaseUrl(),
+    getAuthHeaders: resolveCloudAuthHeaders
+  });
+  return wrapWith401Retry(client);
+}
+function wrapWith401Retry(client) {
+  return new Proxy(client, {
+    get(target, prop, receiver) {
+      const value = Reflect.get(target, prop, receiver);
+      if (typeof value !== "function") return value;
+      const original = value.bind(target);
+      return async (...args) => {
+        try {
+          return await original(...args);
+        } catch (err) {
+          if (err instanceof HyperframesApiError && err.status === 401) {
+            try {
+              await forceRefreshCredentials();
+            } catch {
+              throw err;
+            }
+            return await original(...args);
+          }
+          throw err;
+        }
+      };
+    }
+  });
+}
+
+// src/cloud/errors.ts
+var ERROR_CODE_HINTS = {
+  hyperframes_project_too_large: "The zip exceeded the 200 MB limit. Run `hyperframes cloud render --dry-run`, then add only verified-unneeded paths to `.hyperframesignore` or pre-host required large media.",
+  hyperframes_render_not_found: "The render_id no longer exists \u2014 either soft-deleted or never created.",
+  invalid_parameter: "Check the listed parameter against `hyperframes cloud render --help` for the accepted values.",
+  authentication_failed: "Run `hyperframes auth status` to confirm your credential; `hyperframes auth login` to re-auth.",
+  rate_limit_exceeded: "Retry after the duration in the Retry-After header."
+};
+function reportApiError(stage, err, options = {}) {
+  const hints = { ...ERROR_CODE_HINTS, ...options.extraHints };
+  if (err instanceof HyperframesApiError) {
+    if (err.status === 404 && options.notFound) {
+      errorBox("Not found", options.notFound);
+      failCommand();
+    }
+    const hint = err.code ? hints[err.code] : void 0;
+    const title = `${stage} (HTTP ${err.status})`;
+    if (hint) {
+      errorBox(title, err.message, hint);
+    } else if (options.suggestion) {
+      errorBox(title, err.message, options.suggestion);
+    } else if (err.code) {
+      errorBox(title, err.message, `code: ${err.code}`);
+    } else {
+      errorBox(title, err.message);
+    }
+    failCommand();
+  }
+  if (err instanceof Error) {
+    errorBox(stage, err.message, options.suggestion);
+    failCommand();
+  }
+  errorBox(stage, String(err), options.suggestion);
+  failCommand();
+}
+
+export {
+  DEFAULT_POLL_INTERVAL_MS,
+  DEFAULT_MAX_WAIT_MS,
+  PollTimeoutError,
+  pollUntilTerminal,
+  HyperframesApiError,
+  createCloudClient,
+  reportApiError
+};

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

@@ -0,0 +1,44 @@
+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 {
+  parseHTML
+} from "./chunk-GK4AIFIH.js";
+
+// src/utils/compositionFps.ts
+import { readFileSync } from "fs";
+import { join } from "path";
+function readCompositionFps(html) {
+  let doc;
+  try {
+    doc = parseHTML(html).document;
+  } catch {
+    return null;
+  }
+  const explicitRoot = doc.querySelector('[data-composition-id][data-root="true"]');
+  const root = explicitRoot ?? Array.from(doc.querySelectorAll("[data-composition-id]")).find(
+    (el) => !el.parentElement?.closest("[data-composition-id]")
+  ) ?? null;
+  const raw = root?.getAttribute("data-fps")?.trim();
+  return raw ? raw : null;
+}
+function readAllowedCompositionFpsFromDir(projectDir, allowed) {
+  let html;
+  try {
+    html = readFileSync(join(projectDir, "index.html"), "utf8");
+  } catch {
+    return null;
+  }
+  const raw = readCompositionFps(html);
+  if (raw == null) return null;
+  const n = Number(raw);
+  return Number.isInteger(n) && allowed.includes(n) ? n : null;
+}
+
+export {
+  readCompositionFps,
+  readAllowedCompositionFpsFromDir
+};