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

package/dist/shared/absPath.d.ts

@@ -0,0 +1,3 @@
+export declare function absPath(path: string): string;
+export declare function absPathEnsured(path: string): string;
+export declare function absDirectoryEnsured(path: string): string;

package/dist/shared/absPath.js

@@ -0,0 +1,25 @@
+import { existsSync, lstatSync } from 'node:fs';
+import { isAbsolute, resolve } from 'node:path';
+import chalk from 'chalk';
+export function absPath(path) {
+    const normalize = (p) => p.replaceAll('\\', '/');
+    path = normalize(path);
+    if (!isAbsolute(path)) {
+        path = normalize(resolve(process.cwd(), path));
+    }
+    return path;
+}
+export function absPathEnsured(path) {
+    const abs = absPath(path);
+    if (!existsSync(abs)) {
+        throw new Error(chalk.red(`Path does not exist: ${abs}`));
+    }
+    return abs;
+}
+export function absDirectoryEnsured(path) {
+    const abs = absPathEnsured(path);
+    if (!lstatSync(abs).isDirectory()) {
+        throw new Error(chalk.red(`Path is not a directory: ${abs}`));
+    }
+    return abs;
+}

package/dist/shared/args.d.ts

@@ -1,17 +1,25 @@
-export declare const eruditPathArg: {
-    eruditPath: {
+export declare const projectPathArg: {
+    projectPath: {
+        type: "positional";
+        description: string;
+        required: false;
+        valueHint: string;
+    };
+};
+export declare const siteUrlArg: {
+    siteUrl: {
         type: "string";
         description: string;
         required: false;
-        default: string;
+        valueHint: string;
     };
 };
-export declare const projectPathArg: {
-    projectPath: {
-        type: "positional";
+export declare const basePathArg: {
+    basePath: {
+        type: "string";
         description: string;
         required: false;
-        default: string;
+        valueHint: string;
     };
 };
 export declare const contentTargetsArg: {
@@ -19,7 +27,7 @@ export declare const contentTargetsArg: {
         type: "string";
         description: string;
         required: false;
-        default: string;
+        valueHint: string;
     };
 };
 export declare const nitroPresetArg: {
@@ -29,7 +37,3 @@ export declare const nitroPresetArg: {
         description: string;
     };
 };
-export declare function resolveArgPaths(projectPath: string, eruditPath: string): {
-    projectPath: string;
-    eruditPath: string;
-};

package/dist/shared/args.js

@@ -1,20 +1,25 @@
-import { consola } from 'consola';
-import chalk from 'chalk';
-import { resolvePath } from './path.js';
-export const eruditPathArg = {
-    eruditPath: {
+export const projectPathArg = {
+    projectPath: {
+        type: 'positional',
+        description: 'Erudit project directory. Can also be set via ERUDIT_PROJECT_PATH env variable.',
+        required: false,
+        valueHint: '.',
+    },
+};
+export const siteUrlArg = {
+    siteUrl: {
         type: 'string',
-        description: 'Custom Erudit Nuxt Layer location',
+        description: 'Erudit full site URL. Can also be set via ERUDIT_SITE_URL env variable.',
         required: false,
-        default: 'erudit', // Let `nuxi` find erudit in project dependencies
+        valueHint: 'https://my-awesome-site.com/',
     },
 };
-export const projectPathArg = {
-    projectPath: {
-        type: 'positional',
-        description: 'Erudit project location',
+export const basePathArg = {
+    basePath: {
+        type: 'string',
+        description: 'Base path for Erudit site. Can also be set via ERUDIT_BASE_PATH env variable.',
         required: false,
-        default: '.',
+        valueHint: '/subfolder/',
     },
 };
 export const contentTargetsArg = {
@@ -22,31 +27,13 @@ export const contentTargetsArg = {
         type: 'string',
         description: 'Content targets to process',
         required: false,
-        default: '',
+        valueHint: '"combinatorics"',
     },
 };
 export const nitroPresetArg = {
     preset: {
         type: 'string',
         required: false,
-        description: '(Nuxt Build Flag) Nitro preset to use for building',
+        description: '(Nuxt Build Flag) Nitro preset to use for building. Can also be set via ERUDIT_NITRO_PRESET env variable.',
     },
 };
-export 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,
-    };
-}

package/dist/shared/cliError.d.ts

@@ -0,0 +1 @@
+export declare function cliError(message: string, causeError?: any): Error;

package/dist/shared/cliError.js

@@ -0,0 +1,8 @@
+import chalk from 'chalk';
+export function cliError(message, causeError) {
+    const error = new Error(`\n${chalk.red(message)}\n${causeError ?? ''}`, {
+        cause: causeError,
+    });
+    error.name = '';
+    return error;
+}

package/dist/shared/env.d.ts

@@ -0,0 +1 @@
+export declare function loadEnvFiles(files: string[]): void;

package/dist/shared/env.js

@@ -0,0 +1,9 @@
+import dotenv from 'dotenv';
+import { CONFIG } from '../config.js';
+import { version } from '../inject.js';
+export function loadEnvFiles(files) {
+    dotenv.config({
+        quiet: true,
+        path: files,
+    });
+}

package/dist/shared/logCommand.js

@@ -0,0 +1,4 @@
+import chalk from 'chalk';
+export function logCommand(command) {
+    console.log(`Running command: ${chalk.bold.cyan(command)}`);
+}

package/dist/shared/nuxt.d.ts

@@ -1,3 +1,8 @@
-type NuxtCommand = 'dev' | 'build' | 'generate' | 'prepare';
-export declare function spawnNuxt(command: NuxtCommand, projectPath: string, restParams?: string): Promise<void>;
+interface NuxtConfig {
+    command: 'prepare' | 'dev' | 'build' | 'generate';
+    absProjectPath: string;
+    restArgs?: string | string[];
+    env?: Record<string, string>;
+}
+export declare function spawnNuxt(config: NuxtConfig): Promise<void>;
 export {};

package/dist/shared/nuxt.js

@@ -1,50 +1,91 @@
 import { spawn } from 'node:child_process';
-export async function spawnNuxt(command, projectPath, restParams) {
-    return new Promise((resolve) => {
-        const onClose = (exitCode) => {
-            if (exitCode === 0) {
+export async function spawnNuxt(config) {
+    const onClose = (exitCode) => {
+        switch (exitCode) {
+            case 0:
                 console.log('Nuxt process exited successfully!');
-                return resolve();
-            }
-            if (exitCode === 1) {
-                console.error('Nuxt process exited with an error!');
-                return resolve();
-            }
-            if (exitCode === 1337) {
+                return;
+            case 1337:
                 console.warn('Nuxt full restart is requested!');
                 _spawnNuxt();
                 return;
-            }
-            if (command === 'dev') {
-                console.error(`Nuxt process exited with an error code ${exitCode} in development mode!\nRespawning...`);
-                _spawnNuxt();
+            default:
+                console.error(`Nuxt process exited with code ${exitCode}!`);
                 return;
-            }
-        };
-        const _spawnNuxt = () => {
-            const mode = (() => {
-                switch (command) {
-                    case 'dev':
-                    case 'prepare':
-                        return 'dev';
-                    case 'build':
-                        return 'write';
-                    case 'generate':
-                        return 'static';
-                }
-            })();
-            const nuxtProcess = spawn(`nuxt ${command} ${projectPath}/.erudit/nuxt ${restParams || ''}`, {
-                shell: true,
-                stdio: 'inherit',
-                env: {
-                    ...process.env,
-                    ERUDIT_PROJECT_DIR: projectPath,
-                    ERUDIT_COMMAND: command,
-                    ERUDIT_MODE: mode,
-                },
-            });
-            nuxtProcess.on('close', onClose);
-        };
-        _spawnNuxt();
-    });
+        }
+    };
+    const _spawnNuxt = () => {
+        const restArgs = Array.isArray(config.restArgs)
+            ? config.restArgs.join(' ')
+            : config.restArgs || '';
+        const nuxtProcess = spawn(`nuxt ${config.command} ${config.absProjectPath}/.erudit/nuxt ${restArgs}`, {
+            shell: true,
+            stdio: 'inherit',
+            env: {
+                ...process.env,
+                ...config.env,
+            },
+        });
+        nuxtProcess.on('close', onClose);
+    };
+    _spawnNuxt();
 }
+// type NuxtCommand = 'dev' | 'build' | 'generate' | 'prepare';
+// export async function spawnNuxt(
+//     command: NuxtCommand,
+//     projectPath: string,
+//     restParams?: string,
+// ) {
+//     return new Promise<void>((resolve) => {
+//         const onClose = (exitCode: number) => {
+//             if (exitCode === 0) {
+//                 console.log('Nuxt process exited successfully!');
+//                 return resolve();
+//             }
+//             if (exitCode === 1) {
+//                 console.error('Nuxt process exited with an error!');
+//                 return resolve();
+//             }
+//             if (exitCode === 1337) {
+//                 console.warn('Nuxt full restart is requested!');
+//                 _spawnNuxt();
+//                 return;
+//             }
+//             if (command === 'dev') {
+//                 console.error(
+//                     `Nuxt process exited with an error code ${exitCode} in development mode!\nRespawning...`,
+//                 );
+//                 _spawnNuxt();
+//                 return;
+//             }
+//         };
+//         const _spawnNuxt = () => {
+//             const mode: EruditMode | undefined = (() => {
+//                 switch (command) {
+//                     case 'dev':
+//                     case 'prepare':
+//                         return 'dev';
+//                     case 'build':
+//                         return 'write';
+//                     case 'generate':
+//                         return 'static';
+//                 }
+//             })();
+//             const nuxtProcess = spawn(
+//                 `nuxt ${command} ${projectPath}/.erudit/nuxt ${restParams || ''}`,
+//                 {
+//                     shell: true,
+//                     stdio: 'inherit',
+//                     env: {
+//                         ...process.env,
+//                         ERUDIT_PROJECT_DIR: projectPath,
+//                         ERUDIT_COMMAND: command,
+//                         ERUDIT_MODE: mode,
+//                     },
+//                 },
+//             );
+//             nuxtProcess.on('close', onClose);
+//         };
+//         _spawnNuxt();
+//     });
+// }

package/dist/shared/prepare.d.ts

@@ -1,7 +1,3 @@
-interface PrepareData {
-    projectPath: string;
-    eruditPath: string;
-    contentTargets?: string | string[];
-}
-export declare function prepare({ projectPath, eruditPath, contentTargets, }: PrepareData): Promise<void>;
-export {};
+export declare function prepareProject({ absProjectPath, }: {
+    absProjectPath: string;
+}): Promise<void>;

package/dist/shared/prepare.js

@@ -1,32 +1,58 @@
 import { existsSync, mkdirSync, rmSync, writeFileSync } from 'node:fs';
-import { consola } from 'consola';
-export async function prepare({ projectPath, eruditPath, contentTargets, }) {
-    const eruditBuildDir = `${projectPath}/.erudit`;
-    const distDir = `${projectPath}/.output`;
-    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`, `
+import chalk from 'chalk';
+import { CONFIG } from '../config.js';
+export async function prepareProject({ absProjectPath, }) {
+    process.stdout.write('Preparing Erudit project...');
+    const eruditBuildPath = `${absProjectPath}/.erudit`;
+    const nuxtLayerPath = `${eruditBuildPath}/nuxt`;
+    const distPath = `${absProjectPath}/.output`;
+    if (existsSync(eruditBuildPath)) {
+        rmSync(eruditBuildPath, { force: true, recursive: true });
+    }
+    if (existsSync(distPath)) {
+        rmSync(distPath, { force: true, recursive: true });
+    }
+    mkdirSync(nuxtLayerPath, { recursive: true });
+    if (!existsSync(`${absProjectPath}/erudit.config.ts`)) {
+        writeFileSync(`${absProjectPath}/erudit.config.ts`, `export default defineEruditConfig({\n  /* Adjust Erudit to your needs here... */\n});`);
+    }
+    if (!existsSync(`${absProjectPath}/tsconfig.json`)) {
+        writeFileSync(`${absProjectPath}/tsconfig.json`, JSON.stringify({
+            files: [],
+            references: [
+                {
+                    path: './.erudit/tsconfig.erudit.json',
+                },
+                {
+                    path: './.erudit/tsconfig.nuxt.app.json',
+                },
+                {
+                    path: './.erudit/tsconfig.nuxt.server.json',
+                },
+                {
+                    path: './.erudit/tsconfig.nuxt.shared.json',
+                },
+                {
+                    path: './.erudit/tsconfig.nuxt.node.json',
+                },
+            ],
+        }, null, 2));
+    }
+    writeFileSync(`${nuxtLayerPath}/nuxt.config.ts`, `
         export default {
-            compatibilityDate: '2025-07-20',
-            extends: ['${eruditPath}'],
+            compatibilityDate: '2026-01-01',
+            extends: ['${CONFIG.ERUDIT_PATH}'],
         }
         `);
     ['app', 'server', 'shared', 'node'].forEach((name) => {
-        writeFileSync(`${eruditBuildDir}/tsconfig.nuxt.${name}.json`, JSON.stringify({ extends: [`./nuxt/.nuxt/tsconfig.${name}.json`] }, null, 4));
+        writeFileSync(`${eruditBuildPath}/tsconfig.nuxt.${name}.json`, JSON.stringify({ extends: [`./nuxt/.nuxt/tsconfig.${name}.json`] }, null, 4));
     });
-    mkdirSync(`${eruditBuildDir}/types`, { recursive: true });
-    writeFileSync(`${eruditBuildDir}/tsconfig.erudit.json`, JSON.stringify({
+    mkdirSync(`${eruditBuildPath}/types`, { recursive: true });
+    writeFileSync(`${eruditBuildPath}/tsconfig.erudit.json`, JSON.stringify({
         compilerOptions: {
             paths: {
-                '#project/*': [`${projectPath}/*`],
-                '#content/*': [`${projectPath}/content/*`],
+                '#project/*': [`${absProjectPath}/*`],
+                '#content/*': [`${absProjectPath}/content/*`],
             },
             verbatimModuleSyntax: true,
             forceConsistentCasingInFileNames: true,
@@ -44,14 +70,11 @@ export async function prepare({ projectPath, eruditPath, contentTargets, }) {
             types: ['@jsprose/core/types', '@erudit-js/prose/types'],
             lib: ['ESNext'],
         },
-        include: [`${projectPath}/**/*`, `${eruditBuildDir}/**/*`],
-        exclude: [
-            `${eruditBuildDir}/nuxt/**/*`,
-            `${projectPath}/**/docs.ts`,
-        ],
+        include: [`${absProjectPath}/**/*`, `${eruditBuildPath}/**/*`],
+        exclude: [`${nuxtLayerPath}/**/*`],
     }, null, 4));
-    if (!existsSync(`${projectPath}/tsconfig.json`)) {
-        writeFileSync(`${projectPath}/tsconfig.json`, JSON.stringify({
+    if (!existsSync(`${absProjectPath}/tsconfig.json`)) {
+        writeFileSync(`${absProjectPath}/tsconfig.json`, JSON.stringify({
             files: [],
             references: [
                 {
@@ -72,21 +95,6 @@ export async function prepare({ projectPath, eruditPath, contentTargets, }) {
             ],
         }, null, 4));
     }
-    await prepareContentTargets(eruditBuildDir, contentTargets);
-    writeFileSync(`${eruditBuildDir}/__AUTOGENERATED__`, `This directory is autogenerated by Erudit CLI.\nAll changes will be lost on next launch!`);
-    consola.success('Erudit build files ready!');
-}
-async function prepareContentTargets(buildDir, targets) {
-    if (typeof targets === 'undefined' || targets === '') {
-        return;
-    }
-    if (typeof targets === 'string') {
-        targets = [targets];
-    }
-    if (Array.isArray(targets)) {
-        writeFileSync(`${buildDir}/targets.json`, JSON.stringify(targets, null, 4));
-        consola.success(`Saved ${targets.length} content targets!`);
-        return;
-    }
-    throw new Error(`Failed to resolve content targets: "${targets}"!`);
+    writeFileSync(`${eruditBuildPath}/__AUTOGENERATED__`, `This directory is autogenerated by Erudit CLI.\nAll changes will be lost on next build!`);
+    process.stdout.write(` ${chalk.bold.green('Done!')}\n`);
 }

package/dist/shared/projectPath.d.ts

@@ -0,0 +1,3 @@
+export declare function retrieveProjectPath(projectPathArg?: string): string;
+export declare function normalizeProjectPath(projectPath: string): string;
+export declare function logProjectPath(projectPath: string): void;

package/dist/shared/projectPath.js

@@ -0,0 +1,22 @@
+import chalk from 'chalk';
+import { absDirectoryEnsured } from './absPath.js';
+import { cliError } from './cliError.js';
+export function retrieveProjectPath(projectPathArg) {
+    if (projectPathArg) {
+        return projectPathArg;
+    }
+    return process.env.ERUDIT_PROJECT_PATH || '.';
+}
+export function normalizeProjectPath(projectPath) {
+    let absProjectPath;
+    try {
+        absProjectPath = absDirectoryEnsured(projectPath);
+    }
+    catch (error) {
+        throw cliError('Error normalizing project path!', error);
+    }
+    return absProjectPath;
+}
+export function logProjectPath(projectPath) {
+    console.log('Project path:', chalk.bold.cyan(projectPath));
+}

package/dist/shared/urlProps.d.ts

@@ -0,0 +1,7 @@
+export interface UrlProps {
+    siteUrl: string;
+    basePath: string;
+}
+export declare function retrieveUrlProps(siteUrlArg?: string, basePathArg?: string): UrlProps;
+export declare function normalizeUrlProps(urlProps: UrlProps): UrlProps;
+export declare function logUrlProps(urlProps: UrlProps): void;

package/dist/shared/urlProps.js

@@ -0,0 +1,77 @@
+import chalk from 'chalk';
+import { cliError } from './cliError.js';
+export function retrieveUrlProps(siteUrlArg, basePathArg) {
+    const finalProps = {
+        siteUrl: 'http://localhost:3000',
+        basePath: '/',
+    };
+    if (siteUrlArg) {
+        finalProps.siteUrl = siteUrlArg;
+    }
+    else if (process.env.ERUDIT_SITE_URL) {
+        finalProps.siteUrl = process.env.ERUDIT_SITE_URL;
+    }
+    if (basePathArg) {
+        finalProps.basePath = basePathArg;
+    }
+    else if (process.env.ERUDIT_BASE_PATH) {
+        finalProps.basePath = process.env.ERUDIT_BASE_PATH;
+    }
+    return finalProps;
+}
+export function normalizeUrlProps(urlProps) {
+    const rawSiteUrl = urlProps.siteUrl || 'http://localhost:3000';
+    let url;
+    try {
+        url = new URL(rawSiteUrl);
+    }
+    catch {
+        throw cliError(`Invalid site URL: "${rawSiteUrl}"`);
+    }
+    if (!/^https?:$/.test(url.protocol)) {
+        throw cliError(`Site URL must use http or https (got ${url.protocol})`);
+    }
+    if (url.search || url.hash) {
+        throw cliError(`Site URL must not include query or hash`);
+    }
+    const inferredBasePath = url.pathname && url.pathname !== '/'
+        ? normalizeBasePath(url.pathname)
+        : '/';
+    let finalBasePath;
+    if (urlProps.basePath !== undefined && urlProps.basePath !== '/') {
+        const normalizedProvided = normalizeBasePath(urlProps.basePath);
+        if (inferredBasePath !== '/' && normalizedProvided !== inferredBasePath) {
+            throw cliError(`Conflicting base paths:\n` +
+                `  Site URL implies base path "${inferredBasePath}"\n` +
+                `  Explicitly set base path "${normalizedProvided}"\n\n` +
+                `Remove one of them or make them match!`);
+        }
+        finalBasePath = normalizedProvided;
+    }
+    else {
+        finalBasePath = inferredBasePath;
+    }
+    const finalSiteUrl = finalBasePath === '/'
+        ? `${url.protocol}//${url.host}/`
+        : `${url.protocol}//${url.host}${finalBasePath}`;
+    return {
+        siteUrl: finalSiteUrl,
+        basePath: finalBasePath,
+    };
+}
+function normalizeBasePath(input) {
+    if (!input || input === '/')
+        return '/';
+    if (input.includes('?') || input.includes('#')) {
+        throw cliError(`Base path must not contain ? or #`);
+    }
+    if (input.includes('://')) {
+        throw cliError(`Base path must be a path, not a URL`);
+    }
+    const trimmed = input.replace(/^\/+|\/+$/g, '');
+    return trimmed === '' ? '/' : `/${trimmed}/`;
+}
+export function logUrlProps(urlProps) {
+    console.log(`Site URL: ${chalk.bold.cyan(urlProps.siteUrl)}`);
+    console.log(`Site base path: ${chalk.bold.cyan(urlProps.basePath)}`);
+}

package/package.json

@@ -1,40 +1,39 @@
 {
-    "name": "@erudit-js/cli",
-    "version": "4.0.0-dev.3",
-    "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"
+  "name": "@erudit-js/cli",
+  "version": "4.0.0-dev.5",
+  "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"
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
     },
-    "main": "./dist/index.js",
-    "types": "./dist/index.d.ts",
-    "exports": {
-        ".": {
-            "import": "./dist/index.js",
-            "types": "./dist/index.d.ts"
-        },
-        "./cli": "./bin/erudit-cli.js"
-    },
-    "bin": {
-        "erudit-cli": "bin/erudit-cli.js",
-        "erudit": "bin/erudit-cli.js"
-    },
-    "scripts": {
-        "build": "rm -rf dist && bun tsc --project ./tsconfig.src.json && bun run postBuild.ts",
-        "test": "bun vitest run",
-        "prepack": "bun run build"
-    },
-    "files": [
-        "bin",
-        "dist"
-    ],
-    "dependencies": {
-        "@erudit-js/core": "4.0.0-dev.3",
-        "chalk": "^5.6.2",
-        "citty": "^0.1.6",
-        "consola": "^3.4.2"
+    "./cli": {
+      "import": "./dist/cli.js",
+      "types": "./dist/cli.d.ts"
     }
+  },
+  "scripts": {
+    "build": "rm -rf dist && bun tsc --project ./tsconfig.src.json && bun run postBuild.ts",
+    "test": "bun vitest run",
+    "prepack": "bun run build"
+  },
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "@erudit-js/core": "4.0.0-dev.5",
+    "http-server": "^14.1.1",
+    "chalk": "^5.6.2",
+    "citty": "^0.2.0",
+    "dotenv": "^17.2.3"
+  }
 }