vike 0.0.0-alpha.0 → 0.4.142-commit-8bf568b

package/dist/esm/node/plugin/shared/loggerNotProd.js

@@ -0,0 +1,218 @@
+// Non-production logger used for:
+//  - Development
+//  - Preview
+//  - Build
+//  - Pre-rendering
+// In other words: everywhere except in production
+export { logViteAny };
+export { logViteErrorContainingCodeSnippet };
+export { logConfigInfo };
+export { logConfigError };
+export { logConfigErrorRecover };
+export { logErrorDebugNote };
+export { clearLogs };
+import { isAbortError } from '../../../shared/route/abort.js';
+import { getViteConfig } from '../../runtime/globalContext.js';
+import { overwriteRuntimeProductionLogger } from '../../runtime/renderPage/loggerRuntime.js';
+import { assert, assertIsNotProductionRuntime, getAssertErrMsg, isUserHookError, overwriteAssertProductionLogger, stripAnsi, warnIfErrorIsNotObject } from '../utils.js';
+import { getHttpRequestAsyncStore } from './getHttpRequestAsyncStore.js';
+import { isErrorDebug } from './isErrorDebug.js';
+import { isErrorWithCodeSnippet, getPrettyErrorWithCodeSnippet } from './loggerNotProd/errorWithCodeSnippet.js';
+import { getConfigExececutionErrorIntroMsg, getConfigBuildErrorFormatted } from '../plugins/importUserCode/v1-design/transpileAndExecuteFile.js';
+import { logWithVikeTag, logWithViteTag, logDirectly, isFirstLog, screenHasErrors, clearScreen } from './loggerNotProd/log.js';
+import pc from '@brillout/picocolors';
+import { setAlreadyLogged } from '../../runtime/renderPage/isNewError.js';
+import { isConfigInvalid } from '../../runtime/renderPage/isConfigInvalid.js';
+assertIsNotProductionRuntime();
+overwriteRuntimeProductionLogger(logRuntimeError, logRuntimeInfo);
+overwriteAssertProductionLogger(assertLogger);
+function logRuntimeInfo(msg, httpRequestId, logType, clearErrors) {
+    if (clearErrors)
+        clearLogs({ clearErrors: true });
+    const category = getCategory(httpRequestId);
+    assert(category);
+    logWithVikeTag(msg, logType, category);
+}
+function logViteAny(msg, logType, httpRequestId, prependViteTag) {
+    if (prependViteTag) {
+        const category = getCategory(httpRequestId);
+        logWithViteTag(msg, logType, category);
+    }
+    else {
+        logDirectly(msg, logType);
+    }
+}
+function logConfigInfo(msg, logType) {
+    const category = getConfigCategory();
+    logWithVikeTag(msg, logType, category);
+}
+function logConfigErrorRecover() {
+    const msg = pc.bold(pc.green('Configuration successfully loaded'));
+    clearLogs({ clearAlsoIfConfigIsInvalid: true });
+    const category = getConfigCategory();
+    logWithVikeTag(msg, 'error-recover', category);
+}
+function logRuntimeError(err, 
+/** `httpRequestId` is `null` when pre-rendering */
+httpRequestId) {
+    logErr(err, httpRequestId);
+}
+function logViteErrorContainingCodeSnippet(err) {
+    logErr(err);
+}
+function logErr(err, httpRequestId = null) {
+    warnIfErrorIsNotObject(err);
+    if (isAbortError(err) && !isErrorDebug()) {
+        return;
+    }
+    const store = getHttpRequestAsyncStore();
+    setAlreadyLogged(err);
+    if (getHttpRequestAsyncStore()?.shouldErrorBeSwallowed(err)) {
+        if (!isErrorDebug())
+            return;
+    }
+    else {
+        store?.markErrorAsLogged(err);
+    }
+    const category = getCategory(httpRequestId);
+    if (!isErrorDebug()) {
+        if (isErrorWithCodeSnippet(err)) {
+            // We handle transpile errors globally because wrapping viteDevServer.ssrLoadModule() wouldn't be enough: transpile errors can be thrown not only when calling viteDevServer.ssrLoadModule() but also later when loading user code with import() (since Vite lazy-transpiles import() calls)
+            const viteConfig = getViteConfig();
+            assert(viteConfig);
+            let prettyErr = getPrettyErrorWithCodeSnippet(err, viteConfig.root);
+            assert(stripAnsi(prettyErr).startsWith('Failed to transpile'));
+            logWithViteTag(prettyErr, 'error', category);
+            logErrorDebugNote();
+            return;
+        }
+        {
+            const logged = handleAssertMsg(err, category);
+            if (logged)
+                return;
+        }
+    }
+    // Needs to be after assertion messages handling, because user hooks may throw an assertion error
+    const hook = isUserHookError(err);
+    if (hook) {
+        const { hookName, hookFilePath } = hook;
+        logWithVikeTag(pc.red(`Following error was thrown by the ${hookName}() hook defined at ${hookFilePath}`), 'error', category);
+    }
+    else if (category) {
+        logFallbackErrIntro(category);
+    }
+    logDirectly(err, 'error');
+}
+function logConfigError(err) {
+    clearLogs({ clearAlsoIfConfigIsInvalid: true });
+    warnIfErrorIsNotObject(err);
+    const category = getConfigCategory();
+    {
+        const errIntroMsg = getConfigExececutionErrorIntroMsg(err);
+        if (errIntroMsg) {
+            assert(stripAnsi(errIntroMsg).startsWith('Failed to execute'));
+            logWithVikeTag(errIntroMsg, 'error', category);
+            logDirectly(err, 'error');
+            return;
+        }
+    }
+    {
+        const errMsgFormatted = getConfigBuildErrorFormatted(err);
+        if (errMsgFormatted) {
+            assert(stripAnsi(errMsgFormatted).startsWith('Failed to transpile'));
+            if (!isErrorDebug()) {
+                logWithVikeTag(errMsgFormatted, 'error', category);
+            }
+            else {
+                logDirectly(err, 'error');
+            }
+            return;
+        }
+    }
+    {
+        const logged = handleAssertMsg(err, category);
+        if (logged)
+            return;
+    }
+    if (category)
+        logFallbackErrIntro(category);
+    logDirectly(err, 'error');
+}
+function logFallbackErrIntro(category) {
+    logWithVikeTag(pc.bold(pc.red('[Error] An error was thrown:')), 'error', category);
+}
+function getConfigCategory() {
+    const category = getCategory() ?? 'config';
+    return category;
+}
+function handleAssertMsg(err, category) {
+    const res = getAssertErrMsg(err);
+    if (!res)
+        return false;
+    const { assertMsg, showVikeVersion } = res;
+    logWithVikeTag(assertMsg, 'error', category, showVikeVersion);
+    return true;
+}
+function assertLogger(thing, logType) {
+    const category = getCategory();
+    const res = getAssertErrMsg(thing);
+    /* Risk of infinite loop
+    assert(res)
+    */
+    if (!res)
+        throw new Error('Internal error, reach out to a maintainer');
+    const { assertMsg, showVikeVersion } = res;
+    logWithVikeTag(assertMsg, logType, category, showVikeVersion);
+}
+function clearLogs(conditions = {}) {
+    if (!conditions.clearAlsoIfConfigIsInvalid && isConfigInvalid) {
+        // Avoid hiding the config error: the config error is printed only once
+        return;
+    }
+    if (conditions.clearErrors && !screenHasErrors) {
+        return;
+    }
+    if (conditions.clearIfFirstLog && !isFirstLog) {
+        return;
+    }
+    const viteConfig = getViteConfig();
+    if (viteConfig) {
+        clearScreen(viteConfig);
+    }
+}
+/** Note shown to user when vike does something risky:
+ *  - When vike dedupes (i.e. swallows) an error with getHttpRequestAsyncStore().shouldErrorBeSwallowed(err)
+ *  - When vike modifies the error with getPrettyErrorWithCodeSnippet(err)
+ */
+function logErrorDebugNote() {
+    if (isErrorDebug())
+        return;
+    const store = getHttpRequestAsyncStore();
+    if (store) {
+        if (store.errorDebugNoteAlreadyShown)
+            return;
+        store.errorDebugNoteAlreadyShown = true;
+    }
+    const msg = pc.dim([
+        '┌─────────────────────────────────────────────────────────────────────┐',
+        "│ Error isn't helpful? See https://vike.dev/errors#verbose │",
+        '└─────────────────────────────────────────────────────────────────────┘'
+    ].join('\n'));
+    logDirectly(msg, 'error');
+}
+function getCategory(httpRequestId = null) {
+    const store = getHttpRequestAsyncStore();
+    if (store?.httpRequestId !== undefined) {
+        if (httpRequestId === null) {
+            httpRequestId = store.httpRequestId;
+        }
+        else {
+            assert(httpRequestId === store.httpRequestId);
+        }
+    }
+    if (httpRequestId === null)
+        return null;
+    // const category = httpRequestId % 2 === 1 ? (`request-${httpRequestId}` as const) : (`request(${httpRequestId})` as const)
+    const category = `request(${httpRequestId})`;
+    return category;
+}

package/dist/esm/node/plugin/shared/loggerVite/removeSuperfluousViteLog.d.ts

@@ -0,0 +1,6 @@
+export { removeSuperfluousViteLog };
+export { removeSuperfluousViteLog_enable };
+export { removeSuperfluousViteLog_disable };
+declare function removeSuperfluousViteLog(msg: string): boolean;
+declare function removeSuperfluousViteLog_enable(): void;
+declare function removeSuperfluousViteLog_disable(): void;

package/dist/esm/node/plugin/shared/loggerVite/removeSuperfluousViteLog.js

@@ -0,0 +1,22 @@
+export { removeSuperfluousViteLog };
+export { removeSuperfluousViteLog_enable };
+export { removeSuperfluousViteLog_disable };
+import { assert } from '../../utils.js';
+const superfluousLog = 'Forced re-optimization of dependencies';
+let enabled = false;
+function removeSuperfluousViteLog(msg) {
+    if (!enabled) {
+        return false;
+    }
+    if (msg.toLowerCase().includes('forced') && msg.toLowerCase().includes('optimization')) {
+        assert(msg === superfluousLog, msg); // assertion fails => Vite changed its message => update this function
+        return true;
+    }
+    return false;
+}
+function removeSuperfluousViteLog_enable() {
+    enabled = true;
+}
+function removeSuperfluousViteLog_disable() {
+    enabled = false;
+}

package/dist/esm/node/plugin/shared/loggerVite.d.ts

@@ -0,0 +1,3 @@
+export { improveViteLogs };
+import type { ResolvedConfig } from 'vite';
+declare function improveViteLogs(config: ResolvedConfig): void;

package/dist/esm/node/plugin/shared/loggerVite.js

@@ -0,0 +1,58 @@
+export { improveViteLogs };
+import { assert, removeEmptyLines, trimWithAnsi, trimWithAnsiTrailOnly } from '../utils.js';
+import { logViteErrorContainingCodeSnippet, logViteAny, clearLogs } from './loggerNotProd.js';
+import { isErrorWithCodeSnippet } from './loggerNotProd/errorWithCodeSnippet.js';
+import { getHttpRequestAsyncStore } from './getHttpRequestAsyncStore.js';
+import { removeSuperfluousViteLog } from './loggerVite/removeSuperfluousViteLog.js';
+import { isErrorDebug } from './isErrorDebug.js';
+function improveViteLogs(config) {
+    intercept('info', config);
+    intercept('warn', config);
+    intercept('error', config);
+}
+function intercept(logType, config) {
+    config.logger[logType] = (msg, options = {}) => {
+        assert(!isErrorDebug());
+        if (removeSuperfluousViteLog(msg))
+            return;
+        if (!!options.timestamp) {
+            msg = trimWithAnsi(msg);
+        }
+        else {
+            // No timestamp => no "[vite]" tag prepended => we don't trim the beginning of the message
+            msg = trimWithAnsiTrailOnly(msg);
+        }
+        msg = cleanFirstViteLog(msg);
+        const store = getHttpRequestAsyncStore();
+        // Dedupe Vite error messages
+        if (options.error && store?.shouldErrorBeSwallowed(options.error)) {
+            return;
+        }
+        // Remove this once https://github.com/vitejs/vite/pull/13495 is released
+        if (msg.startsWith('Transform failed with ') && store && logType === 'error') {
+            store.markErrorMessageAsLogged(msg);
+            return;
+        }
+        if (options.error && isErrorWithCodeSnippet(options.error)) {
+            logViteErrorContainingCodeSnippet(options.error);
+            return;
+        }
+        // Only allow Vite to clear its first log. All other clearing is controlled by vike.
+        if (options.clear)
+            clearLogs({ clearIfFirstLog: true });
+        if (options.error)
+            store?.markErrorAsLogged(options.error);
+        // Vite's default logger preprends the "[vite]" tag if and only if options.timestamp is true
+        const prependViteTag = options.timestamp || !!store?.httpRequestId;
+        logViteAny(msg, logType, store?.httpRequestId ?? null, prependViteTag);
+    };
+}
+function cleanFirstViteLog(msg) {
+    const isFirstVitLog = msg.includes('VITE') && msg.includes('ready');
+    if (isFirstVitLog) {
+        return removeEmptyLines(msg);
+    }
+    else {
+        return msg;
+    }
+}

package/dist/esm/node/plugin/shared/parseEsModule.d.ts

@@ -0,0 +1,11 @@
+export { getExportNames };
+export { getImportStatements };
+export type { ImportStatement };
+import { parse } from 'es-module-lexer';
+type ParseResult = ReturnType<typeof parse>;
+type ImportStatement = ParseResult[0][0];
+declare function getExportNames(src: string): Promise<{
+    exportNames: string[];
+    wildcardReExports: string[];
+}>;
+declare function getImportStatements(src: string): Promise<ImportStatement[]>;

package/dist/esm/node/plugin/shared/parseEsModule.js

@@ -0,0 +1,31 @@
+export { getExportNames };
+export { getImportStatements };
+import { init, parse } from 'es-module-lexer';
+import { assert } from '../utils.js';
+async function getExportNames(src) {
+    const parseResult = await parseEsModule(src);
+    const [imports, exports] = parseResult;
+    const exportNames = exports.map((e) => e.n);
+    // This seems to be the only way to detect re-exports
+    //  - https://github.com/brillout/es-module-lexer_tests
+    //  - https://github.com/vitejs/vite/blob/8469bf0a5e38cbf08ec28e598ab155d339edc442/packages/vite/src/node/optimizer/index.ts#L978-L981
+    const wildcardReExports = [];
+    imports.forEach(({ n, ss, se }) => {
+        const exp = src.slice(ss, se);
+        if (/export\s+\*\s+from/.test(exp)) {
+            // `n` is `undefined` for dynamic imports with variable, e.g. `import(moduleName)`
+            assert(n);
+            wildcardReExports.push(n);
+        }
+    });
+    return { wildcardReExports, exportNames };
+}
+async function getImportStatements(src) {
+    const parseResult = await parseEsModule(src);
+    const imports = parseResult[0].slice();
+    return imports;
+}
+async function parseEsModule(src) {
+    await init;
+    return parse(src);
+}

package/dist/esm/node/plugin/shared/removeSourceMap.d.ts

@@ -0,0 +1,7 @@
+export { removeSourceMap };
+declare function removeSourceMap(code: string): {
+    code: string;
+    map: {
+        mappings: "";
+    };
+};

package/dist/esm/node/plugin/shared/removeSourceMap.js

@@ -0,0 +1,9 @@
+export { removeSourceMap };
+function removeSourceMap(code) {
+    return {
+        code,
+        // Remove Source Map to save KBs
+        //  - https://rollupjs.org/guide/en/#source-code-transformations
+        map: { mappings: '' }
+    };
+}

package/dist/esm/node/plugin/shared/rollupIsEsm.d.ts

@@ -0,0 +1,3 @@
+export declare function rollupIsEsm(rollupOptions: {
+    format: string;
+}): boolean;

package/dist/esm/node/plugin/shared/rollupIsEsm.js

@@ -0,0 +1,12 @@
+import { assert } from '../utils.js';
+export function rollupIsEsm(rollupOptions) {
+    const { format } = rollupOptions;
+    assert(typeof format === 'string');
+    assert(format === 'amd' ||
+        format === 'cjs' ||
+        format === 'es' ||
+        format === 'iife' ||
+        format === 'system' ||
+        format === 'umd');
+    return format === 'es';
+}

package/dist/esm/node/plugin/utils.d.ts

@@ -0,0 +1,19 @@
+export * from '../runtime/utils.js';
+export * from '../../utils/viteIsSSR.js';
+export * from '../../utils/getFilePathAbsolute.js';
+export * from '../../utils/getDependencyPackageJson.js';
+export * from '../../utils/resolve.js';
+export * from '../../utils/assertDefaultExport.js';
+export * from '../../utils/arrayIncludes.js';
+export * from '../../utils/isDev.js';
+export * from '../../utils/objectKeys.js';
+export * from '../../utils/getMostSimilar.js';
+export * from '../../utils/getRandomId.js';
+export * from '../../utils/joinEnglish.js';
+export * from '../../utils/escapeRegex.js';
+export * from '../../utils/stripAnsi.js';
+export * from '../../utils/trimWithAnsi.js';
+export * from '../../utils/removeEmptyLines.js';
+export * from '../../utils/findUserPackageJsonPath.js';
+export * from '../../utils/getPropAccessNotation.js';
+export * from '../../utils/mergeCumulativeValues.js';

package/dist/esm/node/plugin/utils.js

@@ -0,0 +1,25 @@
+// Utils needed by vike's Vite plugin.
+// We assume all runtime entries will load this utils.ts file
+import { onLoad } from './onLoad.js';
+onLoad();
+// We tolerate the fact that we load all of the runtime utils even though some of it isn't needed
+export * from '../runtime/utils.js';
+// Utils only needed by `plugin/*`
+export * from '../../utils/viteIsSSR.js';
+export * from '../../utils/getFilePathAbsolute.js';
+export * from '../../utils/getDependencyPackageJson.js';
+export * from '../../utils/resolve.js';
+export * from '../../utils/assertDefaultExport.js';
+export * from '../../utils/arrayIncludes.js';
+export * from '../../utils/isDev.js';
+export * from '../../utils/objectKeys.js';
+export * from '../../utils/getMostSimilar.js';
+export * from '../../utils/getRandomId.js';
+export * from '../../utils/joinEnglish.js';
+export * from '../../utils/escapeRegex.js';
+export * from '../../utils/stripAnsi.js';
+export * from '../../utils/trimWithAnsi.js';
+export * from '../../utils/removeEmptyLines.js';
+export * from '../../utils/findUserPackageJsonPath.js';
+export * from '../../utils/getPropAccessNotation.js';
+export * from '../../utils/mergeCumulativeValues.js';

package/dist/esm/node/prerender/index.d.ts

@@ -0,0 +1 @@
+export { prerenderFromAPI as prerender } from './runPrerender.js';

package/dist/esm/node/prerender/index.js

@@ -0,0 +1 @@
+export { prerenderFromAPI as prerender } from './runPrerender.js';

package/dist/esm/node/prerender/runPrerender.d.ts

@@ -0,0 +1,53 @@
+export { prerenderFromAPI };
+export { prerenderFromCLI };
+export { prerenderFromAutoFullBuild };
+export { prerenderForceExit };
+export type { PrerenderOptions };
+import '../runtime/page-files/setup.js';
+import type { InlineConfig } from 'vite';
+type PrerenderOptions = {
+    /** Initial `pageContext` values */
+    pageContextInit?: Record<string, unknown>;
+    /**
+     * The Vite config.
+     *
+     * This is optional and, if omitted, then Vite will automatically load your `vite.config.js`.
+     *
+     * We recommend to either omit this option or set it to `prerender({ viteConfig: { root }})`: the `vite.config.js` file living at `root` will be loaded.
+     *
+     * Alternatively you can:
+     *  - Set `prerender({ viteConfig: { configFile: './path/to/vite.config.js' }})`.
+     *  - Not load any `vite.config.js` file and, instead, use `prerender({ viteConfig: { configFile: false, ...myViteConfig }})` to programmatically define the entire Vite config.
+     *
+     * You can also load a `vite.config.js` file while overriding parts of the Vite config.
+     *
+     * See https://vitejs.dev/guide/api-javascript.html#inlineconfig for more information.
+     *
+     * @default { root: process.cwd() }
+     *
+     */
+    viteConfig?: InlineConfig;
+    /**
+     * @internal
+     * Don't use without having talked to a vike maintainer.
+     */
+    onPagePrerender?: Function;
+    /** @deprecated Define `prerender({ viteConfig: { root }})` instead. */
+    root?: string;
+    /** @deprecated Define `prerender({ viteConfig: { configFile }})` instead. */
+    configFile?: string;
+    /** @deprecated Define `partial` in vite.config.js instead, see https://vike.dev/prerender-config */
+    partial?: boolean;
+    /** @deprecated Define `noExtraDir` in vite.config.js instead, see https://vike.dev/prerender-config */
+    noExtraDir?: boolean;
+    /** @deprecated Define `parallel` in vite.config.js instead, see https://vike.dev/prerender-config */
+    parallel?: number;
+    /** @deprecated */
+    outDir?: string;
+    /** @deprecated */
+    base?: string;
+};
+declare function prerenderFromAPI(options?: PrerenderOptions): Promise<void>;
+declare function prerenderFromCLI(options: PrerenderOptions): Promise<void>;
+declare function prerenderFromAutoFullBuild(options: PrerenderOptions): Promise<void>;
+declare function prerenderForceExit(): void;