@erudit-js/cli 4.0.0-dev.3 → 4.0.0-dev.5

package/README.md

@@ -2,7 +2,7 @@
 
 Command Line Interface for [Erudit](https://github.com/erudit-js/erudit).
 
-CLI is accessible via `erudit` or `erudit-cli` commands.
+CLI is accessible via `erudit` command **only** through installed `erudit` package!
 
 ## Commands
 
@@ -10,4 +10,4 @@ CLI is accessible via `erudit` or `erudit-cli` commands.
 - `build` - compiles Erudit project
 - `launch` - launches compiled Erudit project
 - `generate` - generates a fully static production-ready site from Erudit project
-- `preview` - preview generated static site
+- `preview` - previews generated static site

package/dist/cli.d.ts

@@ -0,0 +1 @@
+export declare function runCli(absEruditPath: string): void;

package/dist/cli.js

@@ -0,0 +1,7 @@
+import { runMain } from 'citty';
+import { CONFIG } from './config.js';
+import { main } from './commands/main.js';
+export function runCli(absEruditPath) {
+    CONFIG.ERUDIT_PATH = absEruditPath;
+    runMain(main);
+}

package/dist/commands/build.d.ts

@@ -1,25 +1,8 @@
 export declare const build: import("citty").CommandDef<{
-    preset: {
-        type: "string";
-        required: false;
-        description: string;
-    };
-    target: {
-        type: "string";
-        description: string;
-        required: false;
-        default: string;
-    };
-    eruditPath: {
-        type: "string";
-        description: string;
-        required: false;
-        default: string;
-    };
-    projectPath: {
+    readonly projectPath: {
         type: "positional";
         description: string;
         required: false;
-        default: string;
+        valueHint: string;
     };
 }>;

package/dist/commands/build.js

@@ -1,34 +1,39 @@
 import { rmSync } from 'node:fs';
-import consola from 'consola';
 import { defineCommand } from 'citty';
-import { contentTargetsArg, eruditPathArg, nitroPresetArg, projectPathArg, resolveArgPaths, } from '../shared/args.js';
-import { logCommand } from '../shared/log.js';
+import { projectPathArg } from '../shared/args.js';
+import { logProjectPath, normalizeProjectPath, retrieveProjectPath, } from '../shared/projectPath.js';
+import { prepareProject } from '../shared/prepare.js';
 import { spawnNuxt } from '../shared/nuxt.js';
-import { prepare } from '../shared/prepare.js';
+import { CONFIG } from '../config.js';
+import { version } from '../inject.js';
 export const build = defineCommand({
     meta: {
-        name: 'Build',
-        description: 'Builds Erudit project for fast and convenient content writing',
+        name: 'build',
+        description: 'Builds Erudit project that can be launched for fast content writing',
     },
     args: {
         ...projectPathArg,
-        ...eruditPathArg,
-        ...contentTargetsArg,
-        ...nitroPresetArg,
     },
     async run({ args }) {
-        logCommand('build');
-        const { projectPath, eruditPath } = resolveArgPaths(args.projectPath, args.eruditPath);
-        await prepare({
-            projectPath,
-            eruditPath,
-            contentTargets: args.target,
+        const absProjectPath = normalizeProjectPath(retrieveProjectPath(args.projectPath));
+        logProjectPath(absProjectPath);
+        await prepareProject({
+            absProjectPath,
+        });
+        console.log('Building Erudit Nuxt Layer...');
+        await spawnNuxt({
+            command: 'build',
+            absProjectPath,
+            env: {
+                ERUDIT_COMMAND: 'build',
+                NUXT_ERUDIT_PATH: CONFIG.ERUDIT_PATH,
+                NUXT_PROJECT_PATH: absProjectPath,
+                NUXT_PUBLIC_ERUDIT_MODE: 'write',
+                NUXT_PUBLIC_ERUDIT_VERSION: version,
+            },
         });
-        const restParams = args.preset ? ` --preset ${args.preset}` : '';
-        consola.start('Starting Nuxt build...');
-        await spawnNuxt('build', projectPath, restParams);
         // Just fucking remove @jsprose because not a single fucking option inside Nuxt/Nitro allows NOT TO bundle it!
-        rmSync(`${projectPath}/.output/server/node_modules/@jsprose`, {
+        rmSync(`${absProjectPath}/.output/server/node_modules/@jsprose`, {
             recursive: true,
             force: true,
         });

package/dist/commands/dev.d.ts

@@ -1,20 +1,26 @@
 export declare const dev: import("citty").CommandDef<{
-    target: {
+    readonly target: {
         type: "string";
         description: string;
         required: false;
-        default: string;
+        valueHint: string;
     };
-    eruditPath: {
+    readonly basePath: {
         type: "string";
         description: string;
         required: false;
-        default: string;
+        valueHint: string;
     };
-    projectPath: {
+    readonly siteUrl: {
+        type: "string";
+        description: string;
+        required: false;
+        valueHint: string;
+    };
+    readonly projectPath: {
         type: "positional";
         description: string;
         required: false;
-        default: string;
+        valueHint: string;
     };
 }>;

package/dist/commands/dev.js

@@ -1,28 +1,46 @@
-import { consola } from 'consola';
 import { defineCommand } from 'citty';
-import { logCommand } from '../shared/log.js';
-import { prepare } from '../shared/prepare.js';
+import { prepareProject } from '../shared/prepare.js';
+import { projectPathArg, siteUrlArg, basePathArg, contentTargetsArg, } from '../shared/args.js';
+import { logProjectPath, normalizeProjectPath, retrieveProjectPath, } from '../shared/projectPath.js';
+import { logUrlProps, normalizeUrlProps, retrieveUrlProps, } from '../shared/urlProps.js';
+import { loadEnvFiles } from '../shared/env.js';
 import { spawnNuxt } from '../shared/nuxt.js';
-import { contentTargetsArg, eruditPathArg, projectPathArg, resolveArgPaths, } from '../shared/args.js';
+import { CONFIG } from '../config.js';
+import { version } from '../inject.js';
 export const dev = defineCommand({
     meta: {
-        name: 'Dev',
+        name: 'dev',
         description: 'Runs Erudit project in development mode',
     },
     args: {
         ...projectPathArg,
-        ...eruditPathArg,
+        ...siteUrlArg,
+        ...basePathArg,
         ...contentTargetsArg,
     },
     async run({ args }) {
-        logCommand('dev');
-        const { projectPath, eruditPath } = resolveArgPaths(args.projectPath, args.eruditPath);
-        await prepare({
-            projectPath,
-            eruditPath,
-            contentTargets: args.target,
+        const absProjectPath = normalizeProjectPath(retrieveProjectPath(args.projectPath));
+        logProjectPath(absProjectPath);
+        loadEnvFiles([`${absProjectPath}/.env.dev`, `${absProjectPath}/.env`]);
+        const urlProps = normalizeUrlProps(retrieveUrlProps(args.siteUrl, args.basePath));
+        logUrlProps(urlProps);
+        await prepareProject({
+            absProjectPath,
+        });
+        console.log('Launching Erudit Nuxt Layer in development mode...');
+        await spawnNuxt({
+            command: 'dev',
+            absProjectPath,
+            env: {
+                ERUDIT_COMMAND: 'dev',
+                NUXT_ERUDIT_PATH: CONFIG.ERUDIT_PATH,
+                NUXT_PROJECT_PATH: absProjectPath,
+                NUXT_CONTENT_TARGETS: args.target ?? '',
+                NUXT_PUBLIC_ERUDIT_MODE: 'dev',
+                NUXT_PUBLIC_ERUDIT_VERSION: version,
+                NUXT_APP_BASE_URL: urlProps.basePath,
+                NUXT_PUBLIC_SITE_URL: urlProps.siteUrl,
+            },
         });
-        consola.start('Starting Nuxt dev...');
-        await spawnNuxt('dev', projectPath);
     },
 });

package/dist/commands/generate.d.ts

@@ -1,25 +1,31 @@
 export declare const generate: import("citty").CommandDef<{
-    preset: {
+    readonly preset: {
         type: "string";
         required: false;
         description: string;
     };
-    target: {
+    readonly target: {
         type: "string";
         description: string;
         required: false;
-        default: string;
+        valueHint: string;
     };
-    eruditPath: {
+    readonly basePath: {
         type: "string";
         description: string;
         required: false;
-        default: string;
+        valueHint: string;
     };
-    projectPath: {
+    readonly siteUrl: {
+        type: "string";
+        description: string;
+        required: false;
+        valueHint: string;
+    };
+    readonly projectPath: {
         type: "positional";
         description: string;
         required: false;
-        default: string;
+        valueHint: string;
     };
 }>;

package/dist/commands/generate.js

@@ -1,29 +1,49 @@
 import { defineCommand } from 'citty';
-import { contentTargetsArg, eruditPathArg, nitroPresetArg, projectPathArg, resolveArgPaths, } from '../shared/args.js';
-import { logCommand } from '../shared/log.js';
-import { prepare } from '../shared/prepare.js';
+import { basePathArg, contentTargetsArg, nitroPresetArg, projectPathArg, siteUrlArg, } from '../shared/args.js';
+import { prepareProject } from '../shared/prepare.js';
 import { spawnNuxt } from '../shared/nuxt.js';
+import { logProjectPath, normalizeProjectPath, retrieveProjectPath, } from '../shared/projectPath.js';
+import { loadEnvFiles } from '../shared/env.js';
+import { logUrlProps, normalizeUrlProps, retrieveUrlProps, } from '../shared/urlProps.js';
+import { version } from '../inject.js';
+import { CONFIG } from '../config.js';
 export const generate = defineCommand({
     meta: {
-        name: 'Generate',
-        description: 'Generates static production-ready site from Erudit project',
+        name: 'generate',
+        description: 'Generates fully static production-ready site from Erudit project',
     },
     args: {
         ...projectPathArg,
-        ...eruditPathArg,
+        ...siteUrlArg,
+        ...basePathArg,
         ...contentTargetsArg,
         ...nitroPresetArg,
     },
     async run({ args }) {
-        logCommand('generate');
-        const { projectPath, eruditPath } = resolveArgPaths(args.projectPath, args.eruditPath);
-        await prepare({
-            projectPath,
-            eruditPath,
-            contentTargets: args.target,
+        const absProjectPath = normalizeProjectPath(retrieveProjectPath(args.projectPath));
+        logProjectPath(absProjectPath);
+        loadEnvFiles([`${absProjectPath}/.env.prod`, `${absProjectPath}/.env`]);
+        const urlProps = normalizeUrlProps(retrieveUrlProps(args.siteUrl, args.basePath));
+        logUrlProps(urlProps);
+        await prepareProject({
+            absProjectPath,
+        });
+        const nitroPreset = args.nitroPreset || process.env.ERUDIT_NITRO_PRESET;
+        console.log('Generating static site from Erudit Nuxt Layer...');
+        await spawnNuxt({
+            command: 'generate',
+            absProjectPath,
+            restArgs: nitroPreset ? `--preset ${nitroPreset}` : '',
+            env: {
+                ERUDIT_COMMAND: 'generate',
+                NUXT_ERUDIT_PATH: CONFIG.ERUDIT_PATH,
+                NUXT_PROJECT_PATH: absProjectPath,
+                NUXT_CONTENT_TARGETS: args.target ?? '',
+                NUXT_PUBLIC_ERUDIT_MODE: 'static',
+                NUXT_PUBLIC_ERUDIT_VERSION: version,
+                NUXT_APP_BASE_URL: urlProps.basePath,
+                NUXT_PUBLIC_SITE_URL: urlProps.siteUrl,
+            },
         });
-        const restParams = args.preset ? `--preset ${args.preset}` : '';
-        console.log('Starting Nuxt generate...');
-        await spawnNuxt('generate', projectPath, restParams);
     },
 });

package/dist/commands/launch.d.ts

@@ -1,8 +1,26 @@
 export declare const launch: import("citty").CommandDef<{
-    project: {
+    readonly target: {
+        type: "string";
+        description: string;
+        required: false;
+        valueHint: string;
+    };
+    readonly basePath: {
+        type: "string";
+        description: string;
+        required: false;
+        valueHint: string;
+    };
+    readonly siteUrl: {
+        type: "string";
+        description: string;
+        required: false;
+        valueHint: string;
+    };
+    readonly projectPath: {
         type: "positional";
         description: string;
         required: false;
-        default: string;
+        valueHint: string;
     };
 }>;

package/dist/commands/launch.js

@@ -1,38 +1,49 @@
-import { defineCommand } from 'citty';
-import { consola } from 'consola';
-import chalk from 'chalk';
 import { existsSync } from 'node:fs';
 import { spawn } from 'node:child_process';
-import { resolvePath } from '../shared/path.js';
+import { defineCommand } from 'citty';
+import { basePathArg, contentTargetsArg, projectPathArg, siteUrlArg, } from '../shared/args.js';
+import { logProjectPath, normalizeProjectPath, retrieveProjectPath, } from '../shared/projectPath.js';
+import { loadEnvFiles } from '../shared/env.js';
+import { logUrlProps, normalizeUrlProps, retrieveUrlProps, } from '../shared/urlProps.js';
+import { cliError } from '../shared/cliError.js';
+import { CONFIG } from '../config.js';
+import { version } from '../inject.js';
 export const launch = defineCommand({
     meta: {
-        name: 'Launch',
-        description: 'Launch builded Erudit server',
+        name: 'launch',
+        description: 'Launchs already built Erudit project for content writing',
     },
     args: {
-        project: {
-            type: 'positional',
-            description: 'Project path',
-            required: false,
-            default: '.',
-        },
+        ...projectPathArg,
+        ...siteUrlArg,
+        ...basePathArg,
+        ...contentTargetsArg,
     },
     async run({ args }) {
-        consola.start('Resolving project path...');
-        const projectPath = resolvePath(args.project);
-        consola.success('Resolved project path:', chalk.greenBright(projectPath));
-        const distPath = `${projectPath}/.output/server`;
-        if (!existsSync(distPath))
-            throw new Error(`No ".output/server" folder found! Did you run 'erudit build'?`);
-        spawn(`node index.mjs`, {
-            shell: true,
+        const absProjectPath = normalizeProjectPath(retrieveProjectPath(args.projectPath));
+        logProjectPath(absProjectPath);
+        loadEnvFiles([`${absProjectPath}/.env.prod`, `${absProjectPath}/.env`]);
+        const urlProps = normalizeUrlProps(retrieveUrlProps(args.siteUrl, args.basePath));
+        logUrlProps(urlProps);
+        const logProjectPathStr = args.projectPath ? ` "${args.projectPath}"` : '';
+        const didYouRun = `Did you run 'erudit build${logProjectPathStr}'?`;
+        const serverIndexPath = `${absProjectPath}/.output/server/index.mjs`;
+        if (!existsSync(serverIndexPath)) {
+            throw cliError(`Failed to find built Erudit project at "${absProjectPath}"!\n${didYouRun}`);
+        }
+        console.log('Launching Erudit project...');
+        spawn('node', [serverIndexPath], {
             stdio: 'inherit',
             env: {
-                ...process.env,
                 ERUDIT_COMMAND: 'launch',
-                ERUDIT_MODE: 'write',
+                NUXT_ERUDIT_PATH: CONFIG.ERUDIT_PATH,
+                NUXT_PROJECT_PATH: absProjectPath,
+                NUXT_CONTENT_TARGETS: args.target,
+                NUXT_PUBLIC_ERUDIT_MODE: 'write',
+                NUXT_PUBLIC_ERUDIT_VERSION: version,
+                NUXT_APP_BASE_URL: urlProps.basePath,
+                NUXT_PUBLIC_SITE_URL: urlProps.siteUrl,
             },
-            cwd: distPath,
         });
     },
 });

package/dist/commands/main.js

@@ -1,29 +1,36 @@
 import { defineCommand } from 'citty';
+import chalk from 'chalk';
 import { brandColorLogotype } from '@erudit-js/core/brandTerminal';
+import { version } from '../inject.js';
+import { logCommand } from '../shared/logCommand.js';
+import { CONFIG } from '../config.js';
 // Sub commands
-import { init } from './init.js';
 import { prepare } from './prepare.js';
 import { dev } from './dev.js';
 import { build } from './build.js';
-import { preview } from './preview.js';
 import { launch } from './launch.js';
 import { generate } from './generate.js';
+import { preview } from './preview.js';
 export const main = defineCommand({
     meta: {
-        name: 'Erudit CLI',
-        description: 'Command Line Interface for Erudit!',
-        version: '4.0.0-dev.3',
+        name: 'erudit',
+        description: 'CLI for Erudit',
+        version,
     },
     subCommands: {
-        init,
         prepare,
         dev,
         build,
+        launch,
         generate,
         preview,
-        launch,
     },
-    setup() {
+    setup({ args }) {
         console.log(brandColorLogotype);
+        console.log(`Version: ${chalk.bold.cyan(version)}`);
+        if (args._[0]) {
+            logCommand(args._[0]);
+        }
+        console.log(`Erudit path: ${chalk.bold.cyan(CONFIG.ERUDIT_PATH)}`);
     },
 });

package/dist/commands/prepare.d.ts

@@ -1,14 +1,8 @@
 export declare const prepare: import("citty").CommandDef<{
-    eruditPath: {
-        type: "string";
-        description: string;
-        required: false;
-        default: string;
-    };
-    projectPath: {
+    readonly projectPath: {
         type: "positional";
         description: string;
         required: false;
-        default: string;
+        valueHint: string;
     };
 }>;

package/dist/commands/prepare.js

@@ -1,27 +1,35 @@
-import { consola } from 'consola';
 import { defineCommand } from 'citty';
-import { logCommand } from '../shared/log.js';
-import { prepare as _prepare } from '../shared/prepare.js';
+import { projectPathArg } from '../shared/args.js';
+import { logProjectPath, normalizeProjectPath, retrieveProjectPath, } from '../shared/projectPath.js';
+import { prepareProject } from '../shared/prepare.js';
 import { spawnNuxt } from '../shared/nuxt.js';
-import { eruditPathArg, projectPathArg, resolveArgPaths, } from '../shared/args.js';
+import { CONFIG } from '../config.js';
+import { version } from '../inject.js';
 export const prepare = defineCommand({
     meta: {
-        name: 'Prepare',
-        description: 'Creates a .erudit directory in your project and generates build files',
+        name: 'prepare',
+        description: 'Creates necessary files for Erudit project',
     },
     args: {
         ...projectPathArg,
-        ...eruditPathArg,
     },
     async run({ args }) {
-        logCommand('prepare');
-        const { projectPath, eruditPath } = resolveArgPaths(args.projectPath, args.eruditPath);
-        await _prepare({
-            projectPath,
-            eruditPath,
+        const absProjectPath = normalizeProjectPath(retrieveProjectPath(args.projectPath));
+        logProjectPath(absProjectPath);
+        await prepareProject({
+            absProjectPath,
+        });
+        console.log('Preparing Erudit Nuxt Layer...');
+        await spawnNuxt({
+            command: 'prepare',
+            absProjectPath,
+            env: {
+                ERUDIT_COMMAND: 'prepare',
+                NUXT_ERUDIT_PATH: CONFIG.ERUDIT_PATH,
+                NUXT_PROJECT_PATH: absProjectPath,
+                NUXT_PUBLIC_ERUDIT_MODE: 'write',
+                NUXT_PUBLIC_ERUDIT_VERSION: version,
+            },
         });
-        consola.start('Generating Nuxt build files...');
-        await spawnNuxt('prepare', projectPath);
-        consola.success('Nuxt is prepared!');
     },
 });

package/dist/commands/preview.d.ts

@@ -1,8 +1,8 @@
 export declare const preview: import("citty").CommandDef<{
-    project: {
+    readonly projectPath: {
         type: "positional";
         description: string;
         required: false;
-        default: string;
+        valueHint: string;
     };
 }>;

package/dist/commands/preview.js

@@ -1,37 +1,64 @@
 import { spawn } from 'node:child_process';
-import { existsSync } from 'node:fs';
+import { existsSync, readdirSync } from 'node:fs';
+import { join, relative, sep } from 'node:path';
 import { defineCommand } from 'citty';
-import { consola } from 'consola';
 import chalk from 'chalk';
-import { resolvePath } from '../shared/path.js';
+import { projectPathArg } from '../shared/args.js';
+import { logProjectPath, normalizeProjectPath, retrieveProjectPath, } from '../shared/projectPath.js';
+import { cliError } from '../shared/cliError.js';
 export const preview = defineCommand({
     meta: {
-        name: 'Preview',
-        description: 'Preview builded static Erudit site',
+        name: 'preview',
+        description: 'Previews already generated static Erudit site',
     },
     args: {
-        project: {
-            type: 'positional',
-            description: 'Project path',
-            required: false,
-            default: '.',
-        },
+        ...projectPathArg,
     },
     async run({ args }) {
-        consola.start('Resolving project path...');
-        const projectPath = resolvePath(args.project);
-        consola.success('Resolved project path:', chalk.greenBright(projectPath));
-        const distPath = `${projectPath}/.output/public`;
+        const absProjectPath = normalizeProjectPath(retrieveProjectPath(args.projectPath));
+        logProjectPath(absProjectPath);
+        const distPath = `${absProjectPath}/.output/public`;
+        const logProjectPathStr = args.projectPath ? ` "${args.projectPath}"` : '';
+        const didYouRun = `Did you run 'erudit generate${logProjectPathStr}'?`;
         if (!existsSync(distPath)) {
-            throw new Error(`No ".output/public" folder found! Did you run 'erudit build'?`);
+            throw cliError(`Failed to find generated static Erudit site at "${absProjectPath}"!\n${didYouRun}`);
         }
-        spawn(`npx http-server ${distPath} -p 3000`, {
+        const possibleBasePath = findBasePath(distPath);
+        if (!possibleBasePath) {
+            throw cliError(`Failed to find valid entry point (index.html with _nuxt directory) in generated static Erudit site!\n${didYouRun}`);
+        }
+        console.log(`Launching static site preview...\n → ${chalk.underline.cyan(`http://localhost:3000${possibleBasePath}`)}\n`);
+        spawn(`http-server ${distPath} -p 3000`, {
             shell: true,
             stdio: 'inherit',
-            env: {
-                ...process.env,
-                ERUDIT_MODE: 'static',
-            },
+            env: process.env,
         });
     },
 });
+function findBasePath(rootDir) {
+    const queue = [rootDir];
+    while (queue.length > 0) {
+        const currentDir = queue.shift();
+        if (!currentDir)
+            continue;
+        const hasIndexHtml = existsSync(join(currentDir, 'index.html'));
+        const hasNuxtDir = existsSync(join(currentDir, '_nuxt'));
+        if (hasIndexHtml && hasNuxtDir) {
+            const rel = relative(rootDir, currentDir);
+            const urlPath = rel.split(sep).join('/');
+            return urlPath ? `/${urlPath}/` : '/';
+        }
+        try {
+            const entries = readdirSync(currentDir, { withFileTypes: true });
+            for (const entry of entries) {
+                if (entry.isDirectory()) {
+                    queue.push(join(currentDir, entry.name));
+                }
+            }
+        }
+        catch {
+            continue;
+        }
+    }
+    return null;
+}

package/dist/config.d.ts

@@ -0,0 +1,3 @@
+export declare const CONFIG: {
+    ERUDIT_PATH: string;
+};

package/dist/config.js

@@ -0,0 +1,3 @@
+export const CONFIG = {
+    ERUDIT_PATH: '',
+};

package/dist/index.d.ts

@@ -1 +1 @@
-export { run } from './run.js';
+export { version } from './inject.js';

package/dist/index.js

@@ -1 +1 @@
-export { run } from './run.js';
+export { version } from './inject.js';

package/dist/inject.d.ts

@@ -0,0 +1 @@
+export declare const version = "{{ VERSION }}";

package/dist/inject.js

@@ -0,0 +1 @@
+export const version = '4.0.0-dev.5';