studiocms 0.1.0-beta.7 → 0.1.0-beta.8

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

@@ -0,0 +1,39 @@
+import { type CommandUnknownOpts, type OutputConfiguration, Command as _Command, Help as _Help } from '@commander-js/extra-typings';
+import { type ChalkInstance } from 'chalk';
+export declare class Help extends _Help {
+    chalk: ChalkInstance;
+    colorway: ChalkInstance;
+    colorwayError: ChalkInstance;
+    sortOptions: boolean;
+    sortSubcommands: boolean;
+    showGlobalOptions: boolean;
+    subcommandTerm: (cmd: CommandUnknownOpts) => string;
+    subcommandDescription: (cmd: CommandUnknownOpts) => string;
+    constructor();
+    prepareContext(contextOptions: {
+        error?: boolean;
+        helpWidth?: number;
+        outputHasColors?: boolean;
+    }): void;
+    displayWidth(str: string): number;
+    boxWrap(str: string, width: number): string;
+    styleTitle(str: string): string;
+    styleCommandText(str: string): string;
+    styleCommandDescription(str: string): string;
+    styleDescriptionText(str: string): string;
+    styleOptionText(str: string): string;
+    styleArgumentText(str: string): string;
+    styleSubcommandText(str: string): string;
+}
+export declare class Command extends _Command {
+    chalk: ChalkInstance;
+    colorwayError: ChalkInstance;
+    supportsColor: boolean;
+    max: number;
+    prefix: string;
+    _outputConfiguration: OutputConfiguration | undefined;
+    createCommand(name: string | undefined): Command;
+    createHelp(): Help & Partial<_Help>;
+}
+export type newInstanceCommand = InstanceType<typeof Command>;
+export type instanceCommand = InstanceType<typeof _Command>;

package/dist/cli/lib/commander.js

@@ -0,0 +1,87 @@
+import {
+  Command as _Command,
+  Help as _Help
+} from "@commander-js/extra-typings";
+import { chalkStderr as chalkStdErr, default as chalkStdOut } from "chalk";
+import stripAnsi from "strip-ansi";
+import wrapAnsi from "wrap-ansi";
+import { StudioCMSColorwayError, date, supportsColor } from "./utils.js";
+class Help extends _Help {
+  chalk;
+  colorway;
+  colorwayError = StudioCMSColorwayError;
+  sortOptions = true;
+  sortSubcommands = true;
+  showGlobalOptions = true;
+  subcommandTerm = (cmd) => cmd.name() === "interactive" ? `${this.colorway(cmd.name())}${this.colorwayError("*")}` : this.colorway(cmd.name());
+  subcommandDescription = (cmd) => {
+    const desc = cmd.summary() || cmd.description();
+    return desc;
+  };
+  constructor() {
+    super();
+    this.chalk = chalkStdOut;
+    this.colorway = this.chalk.hex("#a581f3");
+  }
+  prepareContext(contextOptions) {
+    super.prepareContext(contextOptions);
+    if (contextOptions?.error) {
+      this.chalk = chalkStdErr;
+    }
+  }
+  displayWidth(str) {
+    return stripAnsi(str).length;
+  }
+  boxWrap(str, width) {
+    return wrapAnsi(str, width, { hard: true });
+  }
+  styleTitle(str) {
+    return this.chalk.bold(str);
+  }
+  styleCommandText(str) {
+    return this.chalk.cyan(str);
+  }
+  styleCommandDescription(str) {
+    return this.chalk.magenta(str);
+  }
+  styleDescriptionText(str) {
+    return this.chalk.italic(str);
+  }
+  styleOptionText(str) {
+    return this.chalk.green(str);
+  }
+  styleArgumentText(str) {
+    return this.chalk.yellow(str);
+  }
+  styleSubcommandText(str) {
+    return str;
+  }
+}
+class Command extends _Command {
+  chalk = chalkStdOut;
+  colorwayError = StudioCMSColorwayError;
+  supportsColor = supportsColor;
+  max = process.stdout.columns;
+  prefix = this.max < 80 ? " " : " ".repeat(2);
+  _outputConfiguration = {
+    writeOut: (str) => process.stdout.write(str),
+    writeErr: (str) => process.stdout.write(`ERROR [${date}]: ${str}`),
+    // Output errors in red.
+    outputError: (str, write) => write(`${this.chalk.red.bold(`ERROR [${date}]:`)} ${this.chalk.red(str)}`),
+    getOutHelpWidth: () => process.stdout.isTTY ? process.stdout.columns ?? 80 : 80,
+    getErrHelpWidth: () => process.stderr.isTTY ? process.stderr.columns ?? 80 : 80,
+    getOutHasColors: () => this.supportsColor,
+    getErrHasColors: () => this.supportsColor,
+    stripColor: (str) => stripAnsi(str)
+  };
+  createCommand(name) {
+    return new Command(name);
+  }
+  createHelp() {
+    return Object.assign(new Help(), this.configureHelp());
+  }
+}
+export {
+  Command,
+  Help
+};

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

@@ -0,0 +1,28 @@
+import * as p from '@clack/prompts';
+import colors from 'chalk';
+import { logger } from './utils.js';
+interface BaseContext {
+    p: typeof p;
+    c: typeof colors;
+    pCancel(val: symbol): void;
+    pOnCancel(): void;
+    cwd: string;
+    packageManager: string;
+    username: string;
+    version: string;
+    exit(code: number): never;
+    tasks: p.Task[];
+    logger: typeof logger;
+    welcome: string;
+}
+interface InteractiveOptions {
+    dryRun?: boolean;
+    skipBanners?: boolean;
+    debug?: boolean;
+}
+export interface Context extends BaseContext, InteractiveOptions {
+}
+export declare function getContext(args: InteractiveOptions): Promise<Context>;
+export declare const random: (...arr: any[]) => any;
+export declare function detectPackageManager(): string | undefined;
+export {};

package/dist/cli/lib/context.js

@@ -0,0 +1,55 @@
+import os from "node:os";
+import * as p from "@clack/prompts";
+import colors from "chalk";
+import getSeasonalMessages from "./seasonal.js";
+import { cancelMessage, getName, logger, readJson } from "./utils.js";
+const pkgJson = readJson(new URL("../../../package.json", import.meta.url));
+async function getContext(args) {
+  let { debug, dryRun, skipBanners } = args;
+  const packageManager = detectPackageManager() ?? "npm";
+  const cwd = process.cwd();
+  const { messages } = getSeasonalMessages();
+  skipBanners = !!((os.platform() === "win32" || skipBanners) && !process.env.CI);
+  const context = {
+    p,
+    c: colors,
+    pCancel(val) {
+      p.isCancel(val);
+      p.cancel(cancelMessage);
+      process.exit(0);
+    },
+    pOnCancel() {
+      p.cancel(cancelMessage);
+      process.exit(0);
+    },
+    packageManager,
+    username: await getName(),
+    version: pkgJson.version,
+    welcome: random(messages),
+    dryRun,
+    debug,
+    cwd,
+    skipBanners,
+    exit(code) {
+      process.exit(code);
+    },
+    tasks: [],
+    logger
+  };
+  return context;
+}
+const random = (...arr) => {
+  const flattenedArray = arr.flat(1);
+  return flattenedArray[Math.floor(flattenedArray.length * Math.random())];
+};
+function detectPackageManager() {
+  if (!process.env.npm_config_user_agent) return;
+  const specifier = process.env.npm_config_user_agent.split(" ")[0];
+  const name = specifier.substring(0, specifier.lastIndexOf("/"));
+  return name === "npminstall" ? "cnpm" : name;
+}
+export {
+  detectPackageManager,
+  getContext,
+  random
+};

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

@@ -0,0 +1,5 @@
+export default function pathUtil(importMetaUrl: string): {
+    filename: string;
+    dirname: string;
+    getRelPath: (...url: string[]) => string;
+};

package/dist/cli/lib/pathUtil.js

@@ -0,0 +1,14 @@
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+function pathUtil(importMetaUrl) {
+  const filename = fileURLToPath(importMetaUrl);
+  const dirname = path.dirname(filename);
+  return {
+    filename,
+    dirname,
+    getRelPath: (...url) => path.join(dirname, ...url)
+  };
+}
+export {
+  pathUtil as default
+};

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 | "delete" | "left" | "right" | "first" | "abort" | "last" | "reset" | "down" | "up" | "submit" | "deleteForward" | "exit" | "next" | "nextPage" | "prevPage" | "home" | "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;