@erudit-js/cli 3.0.0-dev.10

package/README.md

@@ -0,0 +1,12 @@
+# 📟 Erudit CLI
+
+Command Line Interface for [Erudit](https://github.com/erudit-js/erudit).
+
+CLI is accessible via `erudit` or `erudit-cli` commands.
+
+## Commands
+
+- `init`
+- `dev`
+- `build`
+- `preview`

package/bin/erudit-cli.mjs

@@ -0,0 +1,5 @@
+#!/usr/bin/env node
+
+import { run } from '../dist/index.mjs';
+
+run();

package/dist/index.d.mts

@@ -0,0 +1,3 @@
+declare function run(): void;
+
+export { run };

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+declare function run(): void;
+
+export { run };

package/dist/index.mjs

@@ -0,0 +1,438 @@
+import { defineCommand, runMain } from 'citty';
+import { brandColorLogotype } from '@erudit-js/cog/utils/brandNode';
+import consola$1, { consola } from 'consola';
+import chalk from 'chalk';
+import { existsSync, lstatSync, readdirSync, rmSync, mkdirSync, writeFileSync } from 'node:fs';
+import { resolvePaths } from '@erudit-js/cog/kit';
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+import { spawn } from 'node:child_process';
+
+const version = "3.0.0-dev.10";
+
+function resolvePath(path) {
+  path = resolvePaths(path);
+  path = path.endsWith("/") ? path.slice(0, -1) : path;
+  if (existsSync(path) && !lstatSync(path).isDirectory())
+    throw new Error(
+      `Path "${chalk.yellowBright(path)}" is not a directory!`
+    );
+  return path;
+}
+
+const init = defineCommand({
+  meta: {
+    name: "Init",
+    description: "Creates a new Erudit project at specified path"
+  },
+  args: {
+    path: {
+      type: "positional",
+      description: "Path for the new Erudit project",
+      required: true,
+      valueHint: chalk.gray(
+        `"${chalk.greenBright(".")}" OR "${chalk.greenBright("path/to/project")}"`
+      )
+    }
+  },
+  async run({ args }) {
+    consola.start("Resolving project path...");
+    const projectPath = resolvePath(args.path);
+    if (projectPath === void 0) return;
+    if (existsSync(projectPath) && readdirSync(projectPath).length > 0)
+      throw new Error(
+        `Directory "${chalk.yellowBright(projectPath)}" is not empty!`
+      );
+    consola.success(
+      "Resolved project path:",
+      chalk.greenBright(projectPath)
+    );
+    consola.start("Creating project directory...");
+    try {
+      try {
+        rmSync(projectPath, { recursive: true });
+      } catch (error) {
+        if (error?.code !== "ENOENT") {
+          throw error;
+        }
+      }
+      mkdirSync(projectPath, { recursive: true });
+    } catch (error) {
+      throw new Error(
+        `Failed to prepare project directory "${chalk.yellowBright(projectPath)}"!
+
+${error}`
+      );
+    }
+    consola.success("Project directory created!");
+    consola.start("Creating project files...");
+    consola.success("Project files created!");
+  }
+});
+
+function logCommand(command) {
+  consola.info(`Running command: ${chalk.cyanBright(command)}`);
+  console.log();
+}
+
+async function alias2Relative(baseDir, toReplaceDir) {
+  baseDir = resolvePaths(baseDir);
+  toReplaceDir = resolvePaths(toReplaceDir);
+  if (!existsSync(baseDir)) {
+    console.log(`Base directory ${baseDir} does not exist. Skipping...`);
+    return;
+  }
+  if (!existsSync(toReplaceDir)) {
+    console.log(
+      `Target directory ${toReplaceDir} does not exist. Skipping...`
+    );
+    return;
+  }
+  const ALIASES_RESOLVED_FILE = path.join(toReplaceDir, "ALIASES_RESOLVED");
+  if (existsSync(ALIASES_RESOLVED_FILE)) {
+    console.log(`Aliases already resolved in ${toReplaceDir}. Skipping...`);
+    return;
+  }
+  const replaceMap = {
+    "@erudit": "./",
+    "@module": "./module",
+    "@server": "./server/plugin",
+    "@shared": "./shared",
+    "@app": "./app"
+  };
+  const allFiles = await findAllFiles(toReplaceDir);
+  for (const filePath of allFiles) {
+    await processFile(filePath, baseDir, replaceMap);
+  }
+  await fs.writeFile(ALIASES_RESOLVED_FILE, (/* @__PURE__ */ new Date()).toISOString());
+  console.log(`All aliases in ${toReplaceDir} resolved successfully!`);
+}
+async function findAllFiles(dir) {
+  const results = [];
+  try {
+    const entries = await fs.readdir(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = path.join(dir, entry.name);
+      const ignore = [];
+      if (entry.isDirectory()) {
+        if (!ignore.includes(entry.name)) {
+          results.push(...await findAllFiles(fullPath));
+        }
+      } else if (entry.isFile() && /\.(js|ts|vue)$/.test(entry.name)) {
+        results.push(fullPath);
+      }
+    }
+  } catch (error) {
+    console.error(`Error reading directory ${dir}:`, error);
+  }
+  return results;
+}
+async function processFile(filePath, rootDir, replaceMap) {
+  try {
+    let content = await fs.readFile(filePath, "utf8");
+    let modified = false;
+    for (const [alias, targetBasePath] of Object.entries(replaceMap)) {
+      const staticAliasPattern = new RegExp(
+        `(import|from)\\s+(['"])${alias}/([^'"]+)(['"])`,
+        "g"
+      );
+      const dynamicAliasPattern = new RegExp(
+        `(import\\s*\\()\\s*(['"])${alias}/([^'"]+)(['"])\\s*\\)`,
+        "g"
+      );
+      const calculateRelativePath = (importPath) => {
+        const currentFileDir = path.dirname(filePath);
+        const targetAbsoluteDir = path.join(
+          rootDir,
+          targetBasePath.replace(/^\.\//, "")
+        );
+        const targetAbsolutePath = path.join(
+          targetAbsoluteDir,
+          importPath
+        );
+        let relativePath = path.relative(
+          currentFileDir,
+          targetAbsolutePath
+        );
+        if (!relativePath.startsWith(".")) {
+          relativePath = "./" + relativePath;
+        }
+        return relativePath.replace(/\\/g, "/");
+      };
+      content = content.replace(
+        staticAliasPattern,
+        (match, statement, openQuote, importPath, closeQuote) => {
+          const relativePath = calculateRelativePath(importPath);
+          modified = true;
+          return `${statement} ${openQuote}${relativePath}${closeQuote}`;
+        }
+      );
+      content = content.replace(
+        dynamicAliasPattern,
+        (match, importStatement, openQuote, importPath, closeQuote) => {
+          const relativePath = calculateRelativePath(importPath);
+          modified = true;
+          return `${importStatement}${openQuote}${relativePath}${closeQuote})`;
+        }
+      );
+    }
+    if (modified) {
+      await fs.writeFile(filePath, content, "utf8");
+      console.log(`Updated aliases in: ${filePath}`);
+    }
+  } catch (error) {
+    console.error(`Error processing file ${filePath}:`, error);
+  }
+}
+
+async function prepare$1(projectPath, eruditPath) {
+  const eruditBuildDir = `${projectPath}/.erudit`;
+  const distDir = `${projectPath}/dist`;
+  const nodeModules = `${projectPath}/node_modules`;
+  const nodeModulesErudit = `${nodeModules}/erudit`;
+  if (existsSync(nodeModulesErudit)) {
+    consola.start("Resolving aliases in dependencies...");
+    await alias2Relative(nodeModulesErudit, nodeModulesErudit);
+    await alias2Relative(
+      nodeModulesErudit,
+      nodeModules + "/@erudit-js/bitran-elements"
+    );
+    consola.success("Resolved aliases in dependencies!");
+  }
+  consola.start("Cleaning up...");
+  if (existsSync(distDir)) rmSync(distDir, { recursive: true });
+  if (existsSync(eruditBuildDir)) rmSync(eruditBuildDir, { recursive: true });
+  consola.success("Cleaned up!");
+  consola.start("Generating Erudit build files...");
+  mkdirSync(eruditBuildDir, { recursive: true });
+  mkdirSync(eruditBuildDir + "/nuxt", { recursive: true });
+  writeFileSync(
+    `${eruditBuildDir}/nuxt/nuxt.config.ts`,
+    `
+        export default {
+            compatibilityDate: '2025-01-01',
+            extends: ['${eruditPath}'],
+            future: {
+                compatibilityVersion: 4,
+            },
+        }
+    `
+  );
+  writeFileSync(
+    `${eruditBuildDir}/tsconfig.json`,
+    JSON.stringify(
+      {
+        extends: "./nuxt/.nuxt/tsconfig.json"
+      },
+      null,
+      4
+    )
+  );
+  consola.success("Erudit build files ready!");
+}
+
+async function spawnNuxt(command, projectPath) {
+  return new Promise((resolve) => {
+    const onClose = (exitCode) => {
+      if (exitCode === 1337) _spawnNuxt();
+      else if (exitCode !== 0)
+        throw new Error(`Nuxt exited with code ${exitCode}!`);
+      else resolve();
+    };
+    const _spawnNuxt = () => {
+      const nuxtProcess = spawn(
+        `nuxt ${command} ${projectPath}/.erudit/nuxt`,
+        {
+          shell: true,
+          stdio: "inherit",
+          env: {
+            ...process.env,
+            ERUDIT_PROJECT_DIR: projectPath
+          }
+        }
+      );
+      nuxtProcess.on("close", onClose);
+    };
+    _spawnNuxt();
+  });
+}
+
+const eruditPathArg = {
+  eruditPath: {
+    type: "string",
+    description: "Custom Erudit Nuxt Layer location",
+    required: false,
+    default: "erudit"
+    // Let `nuxi` find erudit in project dependencies
+  }
+};
+const projectPathArg = {
+  projectPath: {
+    type: "positional",
+    description: "Erudit project location",
+    required: false,
+    default: "."
+  }
+};
+function resolveArgPaths(projectPath, eruditPath) {
+  consola.start("Resolving project path...");
+  projectPath = resolvePath(projectPath);
+  consola.success("Resolved project path:", chalk.greenBright(projectPath));
+  consola.start("Resolving Erudit Nuxt Layer path...");
+  if (eruditPath === "erudit") {
+    consola.success(`'nuxi' will find Erudit in your dependencies!`);
+  } else {
+    eruditPath = resolvePath(eruditPath);
+    consola.warn(
+      "Custom Erudit Nuxt Layer path will be used: " + chalk.yellowBright(eruditPath)
+    );
+  }
+  return {
+    projectPath,
+    eruditPath
+  };
+}
+
+const prepare = defineCommand({
+  meta: {
+    name: "Prepare",
+    description: "Creates a .erudit directory in your project and generates build files"
+  },
+  args: {
+    ...projectPathArg,
+    ...eruditPathArg
+  },
+  async run({ args }) {
+    logCommand("prepare");
+    const { projectPath, eruditPath } = resolveArgPaths(
+      args.projectPath,
+      args.eruditPath
+    );
+    await prepare$1(projectPath, eruditPath);
+    consola.start("Generating Nuxt build files...");
+    await spawnNuxt("prepare", projectPath);
+    consola.success("Nuxt is prepared!");
+  }
+});
+
+const dev = defineCommand({
+  meta: {
+    name: "Dev",
+    description: "Runs Erudit project in development mode"
+  },
+  args: {
+    ...projectPathArg,
+    ...eruditPathArg
+  },
+  async run({ args }) {
+    logCommand("dev");
+    const { projectPath, eruditPath } = resolveArgPaths(
+      args.projectPath,
+      args.eruditPath
+    );
+    await prepare$1(projectPath, eruditPath);
+    consola.start("Starting Nuxt dev...");
+    await spawnNuxt("dev", projectPath);
+  }
+});
+
+const generate = defineCommand({
+  meta: {
+    name: "Generate",
+    description: "Generates fully static production ready Erudit site"
+  },
+  args: {
+    ...projectPathArg,
+    ...eruditPathArg
+  },
+  async run({ args }) {
+    logCommand("generate");
+    const { projectPath, eruditPath } = resolveArgPaths(
+      args.projectPath,
+      args.eruditPath
+    );
+    await prepare$1(projectPath, eruditPath);
+    consola.start("Starting Nuxt generate...");
+    await spawnNuxt("generate", projectPath);
+  }
+});
+
+const preview = defineCommand({
+  meta: {
+    name: "Preview",
+    description: "Preview created static Erudit site"
+  },
+  args: {
+    project: {
+      type: "positional",
+      description: "Project path",
+      required: false,
+      default: "."
+    }
+  },
+  async run({ args }) {
+    consola.start("Resolving project path...");
+    const projectPath = resolvePath(args.project);
+    consola.success(
+      "Resolved project path:",
+      chalk.greenBright(projectPath)
+    );
+    const distPath = `${projectPath}/dist`;
+    if (!existsSync(distPath))
+      throw new Error(
+        `No 'dist' folder found! Did you run 'erudit build'?`
+      );
+    spawn("npx http-server . -p 3000", {
+      shell: true,
+      stdio: "inherit",
+      env: process.env,
+      cwd: distPath
+    });
+  }
+});
+
+const build = defineCommand({
+  meta: {
+    name: "Build",
+    description: "Builds Erudit project for fast and convenient content writing"
+  },
+  args: {
+    ...projectPathArg,
+    ...eruditPathArg
+  },
+  async run({ args }) {
+    logCommand("build");
+    const { projectPath, eruditPath } = resolveArgPaths(
+      args.projectPath,
+      args.eruditPath
+    );
+    await prepare$1(projectPath, eruditPath);
+    consola$1.start("Starting Nuxt build...");
+    await spawnNuxt("build", projectPath);
+  }
+});
+
+const main = defineCommand({
+  meta: {
+    name: "Erudit CLI",
+    description: "Command Line Interface for Erudit!",
+    version
+  },
+  subCommands: {
+    init,
+    prepare,
+    dev,
+    build,
+    generate,
+    preview
+  },
+  setup() {
+    console.log(brandColorLogotype);
+  }
+});
+
+function run() {
+  runMain(main);
+}
+
+export { run };

package/package.json

@@ -0,0 +1,39 @@
+{
+    "name": "@erudit-js/cli",
+    "version": "3.0.0-dev.10",
+    "type": "module",
+    "description": "📟 Command Line Interface for Erudit",
+    "license": "MIT",
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/erudit-js/erudit.git",
+        "directory": "packages/cli"
+    },
+    "types": "./dist/index.d.ts",
+    "exports": {
+        ".": "./dist/index.mjs",
+        "./cli": "./bin/erudit-cli.mjs"
+    },
+    "bin": {
+        "erudit-cli": "bin/erudit-cli.mjs",
+        "erudit": "bin/erudit-cli.mjs"
+    },
+    "scripts": {
+        "dev": "bun unbuild --stub",
+        "build": "bun run prepack",
+        "prepack": "bun unbuild"
+    },
+    "files": [
+        "bin",
+        "dist"
+    ],
+    "dependencies": {
+        "@erudit-js/cog": "3.0.0-dev.10",
+        "chalk": "^5.4.1",
+        "citty": "^0.1.6",
+        "consola": "^3.4.0"
+    },
+    "devDependencies": {
+        "unbuild": "^3.3.1"
+    }
+}