@editframe/cli 0.26.2-beta.0 → 0.26.4-beta.0

package/src/utils/createReadableStreamFromReadable.ts

@@ -1,113 +0,0 @@
-import { type Readable, Stream } from "node:stream";
-
-export const createReadableStreamFromReadable = (
-  source: Readable & { readableHighWaterMark?: number },
-) => {
-  const pump = new StreamPump(source);
-  const stream = new ReadableStream(pump, pump);
-  return stream;
-};
-
-class StreamPump {
-  public highWaterMark: number;
-  public accumalatedSize: number;
-  private stream: Stream & {
-    readableHighWaterMark?: number;
-    readable?: boolean;
-    resume?: () => void;
-    pause?: () => void;
-    destroy?: (error?: Error) => void;
-  };
-  private controller?: ReadableStreamController<Uint8Array>;
-
-  constructor(
-    stream: Stream & {
-      readableHighWaterMark?: number;
-      readable?: boolean;
-      resume?: () => void;
-      pause?: () => void;
-      destroy?: (error?: Error) => void;
-    },
-  ) {
-    this.highWaterMark =
-      stream.readableHighWaterMark ||
-      new Stream.Readable().readableHighWaterMark;
-    this.accumalatedSize = 0;
-    this.stream = stream;
-    this.enqueue = this.enqueue.bind(this);
-    this.error = this.error.bind(this);
-    this.close = this.close.bind(this);
-  }
-
-  size(chunk: Uint8Array) {
-    return chunk?.byteLength || 0;
-  }
-
-  start(controller: ReadableStreamController<Uint8Array>) {
-    this.controller = controller;
-    this.stream.on("data", this.enqueue);
-    this.stream.once("error", this.error);
-    this.stream.once("end", this.close);
-    this.stream.once("close", this.close);
-  }
-
-  pull() {
-    this.resume();
-  }
-
-  cancel(reason?: Error) {
-    if (this.stream.destroy) {
-      this.stream.destroy(reason);
-    }
-
-    this.stream.off("data", this.enqueue);
-    this.stream.off("error", this.error);
-    this.stream.off("end", this.close);
-    this.stream.off("close", this.close);
-  }
-
-  enqueue(chunk: Uint8Array | string) {
-    if (this.controller) {
-      try {
-        const available = (this.controller.desiredSize || 0) - chunk.length;
-        this.controller.enqueue(chunk as Uint8Array);
-        if (available <= 0) {
-          this.pause();
-        }
-      } catch (_error: any) {
-        this.controller.error(
-          new Error(
-            "Could not create Buffer, chunk must be of type string or an instance of Buffer, ArrayBuffer, or Array or an Array-like Object",
-          ),
-        );
-        this.cancel();
-      }
-    }
-  }
-
-  pause() {
-    if (this.stream.pause) {
-      this.stream.pause();
-    }
-  }
-
-  resume() {
-    if (this.stream.readable && this.stream.resume) {
-      this.stream.resume();
-    }
-  }
-
-  close() {
-    if (this.controller) {
-      this.controller.close();
-      delete this.controller;
-    }
-  }
-
-  error(error: Error) {
-    if (this.controller) {
-      this.controller.error(error);
-      delete this.controller;
-    }
-  }
-}

package/src/utils/getFolderSize.ts

@@ -1,20 +0,0 @@
-import { promises as fs } from "node:fs";
-import path from "node:path";
-
-export async function getFolderSize(dir: string): Promise<number> {
-  const files = await fs.readdir(dir);
-  let size = 0;
-
-  for (const file of files) {
-    const filePath = path.join(dir, file);
-    const stats = await fs.stat(filePath);
-
-    if (stats.isDirectory()) {
-      size += await getFolderSize(filePath);
-    } else {
-      size += stats.size;
-    }
-  }
-
-  return size;
-}

package/src/utils/index.ts

@@ -1,20 +0,0 @@
-import { program } from "commander";
-import "dotenv/config";
-import { Client } from "@editframe/api";
-
-let client: Client;
-
-export const getClient = () => {
-  if (!client) {
-    const programOpts = program.opts();
-    const token = programOpts.token || process.env.EF_TOKEN;
-    const efHost = programOpts.efHost || process.env.EF_HOST;
-    if (!token) {
-      throw new Error(
-        "EF_TOKEN must be set or supplied as command line argument",
-      );
-    }
-    client = new Client(token, efHost);
-  }
-  return client;
-};

package/src/utils/launchBrowserAndWaitForSDK.ts

@@ -1,64 +0,0 @@
-import chalk from "chalk";
-import debug from "debug";
-import { type Browser, chromium, type Page } from "playwright";
-
-import { withSpinner } from "./withSpinner.js";
-
-const browserLog = debug("ef:cli::browser");
-
-interface LaunchOptions {
-  url: string;
-  headless?: boolean;
-  interactive?: boolean;
-  efInteractive?: boolean;
-}
-
-export async function launchBrowserAndWaitForSDK(
-  options: LaunchOptions,
-  fn: (page: Page) => Promise<void>,
-) {
-  const browser = await withSpinner("Launching chrome", async () => {
-    return chromium.launch({
-      channel: "chrome",
-      headless: options.headless ?? true,
-      // headless: false,
-      devtools: options.interactive === true,
-    });
-  });
-
-  const page = await withSpinner("Loading Editframe SDK", async () => {
-    const pageOptions: Parameters<Browser["newPage"]>[0] = {};
-    if (options.interactive === true) {
-      // By default, playwright uses its own viewport, so resizing the browser window
-      // doesn't actually change the viewport. And the gui doesn't scale to fit.
-      // This is not desirable for interactive mode, so we disable the viewport feature.
-      pageOptions.viewport = null;
-    }
-    const page = await browser.newPage(pageOptions);
-    page.on("console", (msg) => {
-      browserLog(chalk.blue(`browser (${msg.type()}) |`), msg.text());
-    });
-    const url =
-      options.url + (options.efInteractive ? "" : "?EF_NONINTERACTIVE=1");
-    process.stderr.write("\nLoading url: ");
-    process.stderr.write(url);
-    process.stderr.write("\n");
-    await page.goto(url);
-    await page.waitForFunction(
-      () => {
-        return (
-          // @ts-expect-error
-          window.EF_REGISTERED
-        );
-      },
-      [],
-      { timeout: 10_000 },
-    );
-    return page;
-  });
-  await fn(page);
-  if (options.interactive !== true) {
-    await browser.close();
-    process.exit(0);
-  }
-}

package/src/utils/startDevServer.ts

@@ -1,61 +0,0 @@
-import path from "node:path";
-import { vitePluginEditframe as editframe } from "@editframe/vite-plugin";
-import tailwindcss from "tailwindcss";
-import { createServer, type ViteDevServer } from "vite";
-
-import { withSpinner } from "./withSpinner.js";
-
-export class DevServer {
-  static async start(directory: string) {
-    return new DevServer(await startDevServer(directory));
-  }
-
-  constructor(private devServer: ViteDevServer) {}
-
-  get url() {
-    return `http://localhost:${this.devServer.config.server.port}`;
-  }
-}
-
-const startDevServer = async (directory: string) => {
-  return await withSpinner("Starting vite...", async () => {
-    const resolvedDirectory = path.resolve(process.cwd(), directory);
-    const cacheRoot = path.join(resolvedDirectory, "assets");
-    const devServer = await createServer({
-      root: resolvedDirectory,
-      css: {
-        postcss: {
-          plugins: [
-            tailwindcss({
-              content: [
-                path.join(resolvedDirectory, "*.{html,css,js,ts,jsx,tsx}"),
-                path.join(resolvedDirectory, "**/*.{html,css,js,ts,jsx,tsx}"),
-              ],
-            }),
-          ],
-        },
-      },
-      esbuild: {
-        target: "es2022",
-        include: /\.(m?[jt]s|[jt]sx)$/,
-        exclude: [],
-      },
-      plugins: [
-        editframe({
-          root: resolvedDirectory,
-          cacheRoot,
-        }),
-      ],
-      build: {
-        target: "es2022",
-        rollupOptions: {
-          treeshake: {
-            moduleSideEffects: false,
-          },
-        },
-      },
-    });
-    await devServer.listen();
-    return devServer;
-  });
-};

package/src/utils/startPreviewServer.ts

@@ -1,38 +0,0 @@
-import path from "node:path";
-import { vitePluginEditframe as editframe } from "@editframe/vite-plugin";
-import { createServer, type ViteDevServer } from "vite";
-
-import { withSpinner } from "./withSpinner.js";
-
-export class PreviewServer {
-  static async start(directory: string) {
-    return new PreviewServer(await startPreviewServer(directory));
-  }
-
-  constructor(private previewServer: ViteDevServer) {}
-
-  get url() {
-    return `http://localhost:${this.previewServer.config.server.port}`;
-  }
-}
-
-const startPreviewServer = async (directory: string) => {
-  return await withSpinner("Starting vite...", async () => {
-    const resolvedDirectory = path.resolve(process.cwd(), directory);
-    const cacheRoot = path.join(resolvedDirectory, "assets");
-    const devServer = await createServer({
-      server: {
-        watch: null,
-      },
-      root: resolvedDirectory,
-      plugins: [
-        editframe({
-          root: resolvedDirectory,
-          cacheRoot,
-        }),
-      ],
-    });
-    await devServer.listen();
-    return devServer;
-  });
-};

package/src/utils/validateVideoResolution.ts

@@ -1,36 +0,0 @@
-import debug from "debug";
-import ora from "ora";
-import { z } from "zod";
-
-const log = debug("ef:cli:validateVideoResolution");
-
-type VideoPayload = {
-  width: number;
-  height: number;
-};
-
-const schema = z
-  .object({
-    width: z.number().int(),
-    height: z.number().int(),
-  })
-  .refine((data) => data.width % 2 === 0, {
-    message: "Width must be divisible by 2",
-    path: ["width"],
-  })
-  .refine((data) => data.height % 2 === 0, {
-    message: "Height must be divisible by 2",
-  });
-export const validateVideoResolution = async (rawPayload: VideoPayload) => {
-  const spinner = ora("Validating video resolution").start();
-  const result = schema.safeParse(rawPayload);
-  if (result.success) {
-    spinner.succeed("Video resolution is valid");
-    return result.data;
-  }
-  spinner.fail("Invalid video resolution");
-  process.stderr.write(result.error?.errors.map((e) => e.message).join("\n"));
-  process.stderr.write("\n");
-  log("Error:", result.error?.errors.map((e) => e.message).join("\n"));
-  process.exit(1);
-};

package/src/utils/withSpinner.ts

@@ -1,16 +0,0 @@
-import ora from "ora";
-
-export const withSpinner = async <T extends any | undefined>(
-  label: string,
-  fn: () => Promise<T>,
-) => {
-  const spinner = ora(label).start();
-  try {
-    const result = await fn();
-    spinner.succeed();
-    return result;
-  } catch (error) {
-    spinner.fail();
-    throw error;
-  }
-};