studiocms 0.1.0-beta.10

package/dist/cli/lib/runExternal.d.ts

@@ -0,0 +1,20 @@
+import { type SpawnOptions } from 'node:child_process';
+/**
+ * Check if a command exists on the system.
+ * @param command The command to check.
+ * @returns A boolean indicating if the command exists.
+ */
+export declare function commandExists(command: string): boolean;
+/**
+ * Run a shell command.
+ * @param command The full shell command to execute.
+ * @returns A Promise that resolves with the command's output or rejects with an error.
+ */
+export declare function runShellCommand(command: string): Promise<string>;
+/**
+ * Run a shell command interactively.
+ * @param command The shell command to execute.
+ * @param options Optional spawn options.
+ * @returns A Promise that resolves when the command completes or rejects on error.
+ */
+export declare function runInteractiveCommand(command: string, options?: SpawnOptions): Promise<void>;

package/dist/cli/lib/runExternal.js

@@ -0,0 +1,40 @@
+import { exec, spawn, spawnSync } from "node:child_process";
+function commandExists(command) {
+  const result = spawnSync(command, ["--version"], {
+    stdio: "ignore",
+    shell: true
+  });
+  return result.status === 0;
+}
+function runShellCommand(command) {
+  return new Promise((resolve, reject) => {
+    exec(command, (error, stdout, stderr) => {
+      if (error) {
+        reject(new Error(`Error: ${error.message}
+${stderr}`));
+        return;
+      }
+      resolve(stdout);
+    });
+  });
+}
+function runInteractiveCommand(command, options = { shell: true, stdio: "inherit" }) {
+  return new Promise((resolve, reject) => {
+    const process = spawn(command, [], options);
+    process.on("close", (code) => {
+      if (code === 0) {
+        resolve();
+      } else {
+        reject(new Error(`Command exited with code ${code}`));
+      }
+    });
+    process.on("error", (error) => {
+      reject(error);
+    });
+  });
+}
+export {
+  commandExists,
+  runInteractiveCommand,
+  runShellCommand
+};

package/dist/cli/lib/seasonal.d.ts

@@ -0,0 +1,5 @@
+interface SeasonalMessages {
+    messages: string[];
+}
+export default function getSeasonalMessages(): SeasonalMessages;
+export {};

package/dist/cli/lib/seasonal.js

@@ -0,0 +1,88 @@
+function getSeasonalMessages() {
+  const season = getSeason();
+  switch (season) {
+    case "new-year": {
+      const year = (/* @__PURE__ */ new Date()).getFullYear();
+      return {
+        messages: [
+          `Welcome to StudioCMS! Let's create something amazing.`,
+          `Kicking off ${year} with StudioCMS? You're in for a treat!`,
+          `Happy ${year}! Ready to craft the perfect CMS?`,
+          `${year} is your year to create something awesome with StudioCMS!`,
+          `${year} is the year of StudioCMS-powered sites!`,
+          `Excited to see what you'll build with StudioCMS in ${year}!`,
+          `Thanks for choosing StudioCMS to start your ${year} journey!`
+        ]
+      };
+    }
+    case "spooky":
+      return {
+        messages: [
+          `Beware! You're entering the realm of StudioCMS.`,
+          "Boo! Ready to create something frightfully good?",
+          `Let's brew up a spooktacular website together!`,
+          "No tricks, just treats with StudioCMS this Halloween.",
+          "Spiders spin webs, but you build the internet with StudioCMS!",
+          "StudioCMS: your cauldron for conjuring up the perfect site.",
+          "A hauntingly beautiful project awaits you!",
+          "The only thing spooky here is how good your site will look!",
+          "Prepare for chills and thrills as we craft your CMS masterpiece!",
+          "StudioCMS: Helping you scare up a perfect website this Halloween!"
+        ]
+      };
+    case "holiday":
+      return {
+        messages: [
+          `'Tis the season to build with StudioCMS!`,
+          "Jingle all the way to your next great website!",
+          "Deck the web with StudioCMS magic!",
+          `Let's unwrap the gift of creativity together!`,
+          "May your holidays be merry and your site extraordinary!",
+          "Building a website is the best kind of holiday cheer!",
+          "StudioCMS: the perfect companion for your festive projects!",
+          "Create a winter wonderland online with StudioCMS.",
+          `Ho ho ho! Let's build something unforgettable this holiday season!`,
+          "Your ideas are the brightest stars on this holiday tree!"
+        ]
+      };
+    default:
+      return {
+        messages: [
+          `Welcome to StudioCMS! Let's get started.`,
+          "Ready to shape the future of the web with StudioCMS?",
+          "Claim your digital space with StudioCMS!",
+          "Time to turn your ideas into reality.",
+          `Let's craft something amazing together!`,
+          `Let's make the internet a better place.`,
+          "Your creativity + StudioCMS = magic.",
+          `We're thrilled to have you on this journey.`,
+          "Building the web, one project at a time.",
+          `The web is yours to shape. Let's begin!`,
+          "Fast, flexible, and ready to go\u2014just like StudioCMS.",
+          `Let's build the CMS of your dreams!`,
+          `Let's make your vision a reality.`,
+          "Ready to create something extraordinary?",
+          "Here to assist you in building greatness.",
+          `It's time to create your next masterpiece.`,
+          "StudioCMS: The power of the web in your hands."
+        ]
+      };
+  }
+}
+function getSeason() {
+  const date = /* @__PURE__ */ new Date();
+  const month = date.getMonth() + 1;
+  const day = date.getDate() + 1;
+  if (month === 1 && day <= 7) {
+    return "new-year";
+  }
+  if (month === 10 && day > 7) {
+    return "spooky";
+  }
+  if (month === 12 && day > 7 && day < 25) {
+    return "holiday";
+  }
+}
+export {
+  getSeasonalMessages as default
+};

package/dist/cli/lib/utils.d.ts

@@ -0,0 +1,55 @@
+import type { Key } from 'node:readline';
+import { type Options as BoxenOptions } from 'boxen';
+export declare const ASCIIText: string;
+export declare const dt: Intl.DateTimeFormat;
+export declare const date: string;
+export declare const supportsColor: boolean;
+export declare const StudioCMSColorway: import("chalk").ChalkInstance;
+export declare const StudioCMSColorwayBg: import("chalk").ChalkInstance;
+export declare const StudioCMSColorwayInfo: import("chalk").ChalkInstance;
+export declare const StudioCMSColorwayInfoBg: import("chalk").ChalkInstance;
+export declare const StudioCMSColorwayWarn: import("chalk").ChalkInstance;
+export declare const StudioCMSColorwayWarnBg: import("chalk").ChalkInstance;
+export declare const StudioCMSColorwayError: import("chalk").ChalkInstance;
+export declare const StudioCMSColorwayErrorBg: import("chalk").ChalkInstance;
+export declare const TursoColorway: import("chalk").ChalkInstance;
+export declare const CLITitle: string;
+export declare const action: (key: Key, isSelect: boolean) => false | "home" | "left" | "right" | "delete" | "first" | "abort" | "last" | "reset" | "down" | "up" | "submit" | "deleteForward" | "exit" | "next" | "nextPage" | "prevPage" | "end" | undefined;
+export type LogMessageOptions = {
+    symbol?: string;
+};
+export declare function createClackMessageUpdate(stream?: NodeJS.WriteStream & {
+    fd: 1;
+}, { showCursor, symbol }?: {
+    showCursor?: boolean | undefined;
+    symbol?: string | undefined;
+}): {
+    (arguments_: string): void;
+    clear(): void;
+    done(): void;
+};
+export declare function boxen(header?: string, body?: {
+    ln0?: string;
+    ln1?: string;
+    ln2?: string;
+    ln3?: string;
+    ln4?: string;
+    ln5?: string;
+}, footer?: string, boxenOptions?: BoxenOptions): string;
+export declare const logger: {
+    log: (message: string) => void;
+    debug: (message: string) => void;
+    error: (message: string) => void;
+    warn: (message: string) => void;
+};
+export declare const say: (msg?: string | string[], { clear }?: {
+    clear?: boolean | undefined;
+}) => Promise<void>;
+export declare const randomBetween: (min: number, max: number) => number;
+export declare const random: (...arr: any[]) => any;
+export declare const label: (text: string, c?: import("chalk").ChalkInstance, t?: import("chalk").ChalkInstance) => string;
+export declare const sleep: (ms: number) => Promise<unknown>;
+export declare const getName: () => Promise<string>;
+export declare const cancelMessage = "Operation cancelled, exiting... If you're stuck, join us at https://chat.studiocms.dev";
+export declare function readJson<T>(path: string | URL): T;
+export declare function exists(path: string | URL | undefined): boolean;

package/dist/cli/lib/utils.js

@@ -0,0 +1,310 @@
+import { exec } from "node:child_process";
+import fs from "node:fs";
+import readline from "node:readline";
+import ansiEscapes from "ansi-escapes";
+import _boxen, {} from "boxen";
+import chalk from "chalk";
+import cliCursor from "cli-cursor";
+import figlet from "figlet";
+import isUnicodeSupported from "is-unicode-supported";
+import sliceAnsi from "slice-ansi";
+import stripAnsi from "strip-ansi";
+import wrapAnsi from "wrap-ansi";
+const ASCIIText = figlet.textSync("StudioCMS");
+const dt = new Intl.DateTimeFormat("en-us", {
+  hour: "2-digit",
+  minute: "2-digit"
+});
+const date = dt.format(/* @__PURE__ */ new Date());
+const supportsColor = chalk.level > 0;
+const StudioCMSColorway = chalk.hex("#a581f3");
+const StudioCMSColorwayBg = chalk.bgHex("#a581f3");
+const StudioCMSColorwayInfo = chalk.hex("#22c55e");
+const StudioCMSColorwayInfoBg = chalk.bgHex("#22c55e");
+const StudioCMSColorwayWarn = chalk.hex("#facc14");
+const StudioCMSColorwayWarnBg = chalk.bgHex("#facc14");
+const StudioCMSColorwayError = chalk.hex("#bd0249");
+const StudioCMSColorwayErrorBg = chalk.bgHex("#bd0249");
+const TursoColorway = chalk.bgHex("#4ff8d2");
+const CLITitle = supportsColor ? StudioCMSColorway.bold(`${ASCIIText}
+`) : `${ASCIIText}
+`;
+let stdout = process.stdout;
+const stdin = process.stdin;
+function setStdout(writable) {
+  stdout = writable;
+}
+const action = (key, isSelect) => {
+  if (key.meta && key.name !== "escape") return;
+  if (key.ctrl) {
+    if (key.name === "a") return "first";
+    if (key.name === "c") return "abort";
+    if (key.name === "d") return "abort";
+    if (key.name === "e") return "last";
+    if (key.name === "g") return "reset";
+  }
+  if (isSelect) {
+    if (key.name === "j") return "down";
+    if (key.name === "k") return "up";
+    if (key.ctrl && key.name === "n") return "down";
+    if (key.ctrl && key.name === "p") return "up";
+  }
+  if (key.name === "return") return "submit";
+  if (key.name === "enter") return "submit";
+  if (key.name === "backspace") return "delete";
+  if (key.name === "delete") return "deleteForward";
+  if (key.name === "abort") return "abort";
+  if (key.name === "escape") return "exit";
+  if (key.name === "tab") return "next";
+  if (key.name === "pagedown") return "nextPage";
+  if (key.name === "pageup") return "prevPage";
+  if (key.name === "home") return "home";
+  if (key.name === "end") return "end";
+  if (key.name === "up") return "up";
+  if (key.name === "down") return "down";
+  if (key.name === "right") return "right";
+  if (key.name === "left") return "left";
+  return false;
+};
+const unicode = isUnicodeSupported();
+const s = (c, fallback) => unicode ? c : fallback;
+const S_BAR = s("\u2502", "|");
+const defaultTerminalHeight = 24;
+const getWidth = ({ columns = 80 }) => columns;
+const fitToTerminalHeight = (stream, text) => {
+  const terminalHeight = stream.rows ?? defaultTerminalHeight;
+  const lines = text.split("\n");
+  const toRemove = Math.max(0, lines.length - terminalHeight);
+  return toRemove ? sliceAnsi(text, stripAnsi(lines.slice(0, toRemove).join("\n")).length + 1) : text;
+};
+function createClackMessageUpdate(stream = stdout, { showCursor = false, symbol = chalk.gray(S_BAR) } = {}) {
+  let previousLineCount = 0;
+  let previousWidth = getWidth(stream);
+  let previousOutput = "";
+  const reset = () => {
+    previousOutput = "";
+    previousWidth = getWidth(stream);
+    previousLineCount = 0;
+  };
+  const render = (arguments_) => {
+    if (!showCursor) {
+      cliCursor.hide();
+    }
+    const parts = [];
+    const [firstLine, ...lines] = arguments_.split("\n");
+    parts.push(`${symbol}  ${firstLine}`, ...lines.map((ln) => `${chalk.gray(S_BAR)}  ${ln}`));
+    let output = fitToTerminalHeight(stream, `${parts.join("\n")}
+`);
+    const width = getWidth(stream);
+    if (output === previousOutput && previousWidth === width) {
+      return;
+    }
+    previousOutput = output;
+    previousWidth = width;
+    output = wrapAnsi(output, width, { trim: false, hard: true, wordWrap: false });
+    stream.write(ansiEscapes.eraseLines(previousLineCount) + output);
+    previousLineCount = output.split("\n").length;
+  };
+  render.clear = () => {
+    stream.write(ansiEscapes.eraseLines(previousLineCount));
+    reset();
+  };
+  render.done = () => {
+    reset();
+    if (!showCursor) {
+      cliCursor.show();
+    }
+  };
+  return render;
+}
+function boxen(header, body, footer, boxenOptions = { padding: 0, borderStyle: "none" }) {
+  const prefix = stdout.columns < 80 ? " " : " ".repeat(4);
+  const boxContent = [];
+  const logo = _boxen(
+    [
+      `${chalk.white.bold("    \u2588\u2588\u2588\u2588")}`,
+      `${chalk.white.bold("  \u2588 \u2588\u2588\u2588\u2588")}`,
+      `${chalk.white.bold("\u2588 \u2588\u2584\u2584\u2584  ")}`,
+      `${chalk.white.bold("\u2588\u2584\u2584\u2584    ")}`
+    ].join("\n"),
+    {
+      padding: 1,
+      borderStyle: "none",
+      backgroundColor: "black"
+    }
+  ).split("\n");
+  if (header) {
+    boxContent.push(`${header}
+`);
+  }
+  boxContent.push(
+    ...[
+      `${logo[0]}${prefix}${body?.ln0 || ""}`,
+      `${logo[1]}${prefix}${body?.ln1 || ""}`,
+      `${logo[2]}${prefix}${body?.ln2 || ""}`,
+      `${logo[3]}${prefix}${body?.ln3 || ""}`,
+      `${logo[4]}${prefix}${body?.ln4 || ""}`,
+      `${logo[5]}${prefix}${body?.ln5 || ""}`
+    ]
+  );
+  if (footer) {
+    boxContent.push(`
+${footer}`);
+  }
+  return _boxen(boxContent.join("\n"), boxenOptions);
+}
+const send = (message) => stdout.write(`${message}
+`);
+const logger = {
+  log: (message) => {
+    if (!supportsColor) {
+      send(`[${date}]: ${message}`);
+      return;
+    }
+    send(`${chalk.blue.bold(`[${date}]:`)} ${message}`);
+  },
+  debug: (message) => {
+    if (!supportsColor) {
+      send(`DEBUG [${date}]: ${message}`);
+      return;
+    }
+    send(`${chalk.blue.bold(`DEBUG [${date}]:`)} ${message}`);
+  },
+  error: (message) => {
+    if (!supportsColor) {
+      send(`ERROR [${date}]: ${message}`);
+      return;
+    }
+    send(`${chalk.red.bold(`ERROR [${date}]:`)} ${chalk.red(message)}`);
+  },
+  warn: (message) => {
+    if (!supportsColor) {
+      send(`WARN [${date}]: ${message}`);
+      return;
+    }
+    send(`${chalk.yellow.bold(`WARN [${date}]:`)} ${chalk.yellow(message)}`);
+  }
+};
+const say = async (msg = [], { clear = false } = {}) => {
+  const messages = Array.isArray(msg) ? msg : [msg];
+  const rl = readline.createInterface({ input: stdin, escapeCodeTimeout: 50 });
+  const logUpdate = createClackMessageUpdate(stdout, { showCursor: false });
+  readline.emitKeypressEvents(stdin, rl);
+  let i = 0;
+  let cancelled = false;
+  const done = async () => {
+    stdin.off("keypress", done);
+    if (stdin.isTTY) stdin.setRawMode(false);
+    rl.close();
+    cancelled = true;
+    if (i < messages.length - 1) {
+      logUpdate.clear();
+    } else if (clear) {
+      logUpdate.clear();
+    } else {
+      logUpdate.done();
+    }
+  };
+  if (stdin.isTTY) stdin.setRawMode(true);
+  stdin.on("keypress", (str, key) => {
+    if (stdin.isTTY) stdin.setRawMode(true);
+    const k = action(key, true);
+    if (k === "abort") {
+      done();
+      return process.exit(0);
+    }
+    if (["up", "down", "left", "right"].includes(k)) return;
+    done();
+  });
+  for (let message of messages) {
+    message = message;
+    const _message = Array.isArray(message) ? message : message.split(" ");
+    const msg2 = [];
+    let j = 0;
+    for (let word of [""].concat(_message)) {
+      word = word;
+      if (word) msg2.push(word);
+      logUpdate(
+        `
+${boxen(void 0, { ln3: msg2.join(" ") }, void 0, { padding: 0, borderStyle: "none" })}`
+      );
+      if (!cancelled) await sleep(randomBetween(75, 200));
+      j++;
+    }
+    if (!cancelled) await sleep(100);
+    const tmp = await Promise.all(_message).then((res) => res.join(" "));
+    const text = `
+${boxen(void 0, { ln3: tmp }, void 0, { padding: 0, borderStyle: "none" })}`;
+    logUpdate(text);
+    if (!cancelled) await sleep(randomBetween(1200, 1400));
+    i++;
+  }
+  stdin.off("keypress", done);
+  await sleep(100);
+  done();
+  if (stdin.isTTY) stdin.setRawMode(false);
+  stdin.removeAllListeners("keypress");
+};
+const randomBetween = (min, max) => Math.floor(Math.random() * (max - min + 1) + min);
+const random = (...arr) => {
+  const flattenedArray = arr.flat(1);
+  return flattenedArray[Math.floor(flattenedArray.length * Math.random())];
+};
+const label = (text, c = StudioCMSColorwayBg, t = chalk.whiteBright) => c(` ${t(text)} `);
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+const getName = () => new Promise((resolve) => {
+  exec("git config user.name", { encoding: "utf-8" }, (_1, gitName) => {
+    if (gitName.trim()) {
+      return resolve(gitName.split(" ")[0].trim());
+    }
+    exec("whoami", { encoding: "utf-8" }, (_3, whoami) => {
+      if (whoami.trim()) {
+        return resolve(whoami.split(" ")[0].trim());
+      }
+      return resolve("StudioCMS User");
+    });
+  });
+});
+const cancelMessage = "Operation cancelled, exiting... If you're stuck, join us at https://chat.studiocms.dev";
+function readJson(path) {
+  return JSON.parse(fs.readFileSync(path, "utf-8"));
+}
+function exists(path) {
+  if (!path) return false;
+  try {
+    fs.statSync(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+export {
+  ASCIIText,
+  CLITitle,
+  StudioCMSColorway,
+  StudioCMSColorwayBg,
+  StudioCMSColorwayError,
+  StudioCMSColorwayErrorBg,
+  StudioCMSColorwayInfo,
+  StudioCMSColorwayInfoBg,
+  StudioCMSColorwayWarn,
+  StudioCMSColorwayWarnBg,
+  TursoColorway,
+  action,
+  boxen,
+  cancelMessage,
+  createClackMessageUpdate,
+  date,
+  dt,
+  exists,
+  getName,
+  label,
+  logger,
+  random,
+  randomBetween,
+  readJson,
+  say,
+  setStdout,
+  sleep,
+  supportsColor
+};

package/dist/cli/shared/intro.d.ts

@@ -0,0 +1,2 @@
+import type { Context } from '../lib/context.js';
+export declare function intro(ctx: Pick<Context, 'welcome' | 'version' | 'username' | 'skipBanners' | 'debug' | 'logger'>): Promise<void>;

package/dist/cli/shared/intro.js

@@ -0,0 +1,24 @@
+import color from "chalk";
+import { StudioCMSColorway, StudioCMSColorwayBg, label, say } from "../lib/utils.js";
+async function intro(ctx) {
+  if (!ctx.skipBanners) {
+    ctx.debug && ctx.logger.debug("Printing welcome message...");
+    await say(
+      [
+        [
+          "Welcome",
+          "to",
+          label("StudioCMS", StudioCMSColorwayBg, color.black),
+          StudioCMSColorway(`v${ctx.version}`),
+          ctx.username
+        ],
+        ctx.welcome
+      ],
+      { clear: true }
+    );
+    ctx.debug && ctx.logger.debug("Welcome message printed");
+  }
+}
+export {
+  intro
+};