vike 0.0.0-alpha.0 → 0.4.142-commit-6eb0dd3

package/dist/cjs/node/plugin/shared/loggerNotProd/errorWithCodeSnippet.js

@@ -0,0 +1,168 @@
+"use strict";
+// Prettify transpilation errors
+//  - Doesn't work for optimize errors: https://gist.github.com/brillout/9b7bb78ae866558b292ea1b516a986ec
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPrettyErrMessage = exports.isEquivalentErrorWithCodeSnippet = exports.isErrorWithCodeSnippet = exports.getPrettyErrorWithCodeSnippet = void 0;
+// Copied & adapted from https://github.com/vitejs/vite/blob/9c114c5c72a6af87e3330d5573362554b4511265/packages/vite/src/node/server/middlewares/error.ts
+const picocolors_1 = __importDefault(require("@brillout/picocolors"));
+const utils_js_1 = require("../../utils.js");
+function isErrorWithCodeSnippet(err) {
+    if (!(0, utils_js_1.isObject)(err)) {
+        return false;
+    }
+    const { id, frame, message } = err;
+    if (typeof id !== 'string' || !id.trim()) {
+        return false;
+    }
+    if (typeof frame === 'string' && frame.trim()) {
+        return true;
+    }
+    if (typeof message === 'string' && containsCodeSnippet(message)) {
+        return true;
+    }
+    return false;
+}
+exports.isErrorWithCodeSnippet = isErrorWithCodeSnippet;
+function getPrettyErrorWithCodeSnippet(err, userRootDir) {
+    /* Uncomment to inspect and/or create fixture for ./errorWithCodeSnippet.spec.ts
+    console.log('userRootDir', userRootDir)
+    console.log('err.message', err.message)
+    console.log('err.stack', (err as any).stack)
+    console.log('err.pluginCode', (err as any).pluginCode)
+    console.log('Object.keys(err)', Object.keys(err))
+    console.log('err', err)
+    // For copy-pasting errors while preserving terminal ANSI colors
+    console.log(
+      'JSON.stringify(err)',
+      JSON.stringify({
+        ...err,
+        message: err.message,
+        stack: (err as any).stack
+      })
+    )
+    //*/
+    (0, utils_js_1.assert)(isErrorWithCodeSnippet(err));
+    let { id, frame } = err;
+    const msgFirstLine = [
+        picocolors_1.default.red('Failed to transpile'),
+        picocolors_1.default.bold(picocolors_1.default.red((0, utils_js_1.getFilePathVite)(normalizeId(id), userRootDir))),
+        picocolors_1.default.red('because:')
+    ].join(' ');
+    const errMsg = getPrettyErrMessage(err);
+    if (errMsg && containsCodeSnippet(errMsg)) {
+        // Conditionally swallowing frame is a risky move but worth it thanks to logErrorDebugNote()
+        // We swallow frame because many tools set 'error.frame' to something rubbish, for example:
+        //  - @vitejs/plugin-vue
+        //  - @vitejs/plugin-react-swc
+        //  - @mdx-js/rollup
+        frame = undefined;
+    }
+    else {
+        (0, utils_js_1.assert)(frame);
+        frame = frame.trim();
+        (0, utils_js_1.assert)(frame);
+        frame = picocolors_1.default.yellow(frame);
+    }
+    let msg = [msgFirstLine, errMsg, frame].filter(Boolean).join('\n');
+    msg = (0, utils_js_1.removeEmptyLines)(msg);
+    /* Vite already does a fairly good job at showing a concise error in the layover
+    server.ws.send({
+      type: 'error',
+      err: msg
+    })
+    */
+    return msg;
+}
+exports.getPrettyErrorWithCodeSnippet = getPrettyErrorWithCodeSnippet;
+function getPrettyErrMessage(err) {
+    const { id, frame } = err;
+    let errMsg = err.message;
+    if (!errMsg || !errMsg.trim())
+        return null;
+    const trail = /(?:\:|)(?:\s|$)/;
+    // Remove "Transform failed with 1 error:" (redundant since we already print an intro message)
+    errMsg = errMsg.split(reg([/Transform failed with \d* error(?:s|)/, trail], 'gi')).join('');
+    // Remove "/home/rom/code/vike/examples/react-full-v1/components/Counter.tsx:1:8:" (redundant since we already print the filename)
+    const pos = /(?:\:\d+|)/;
+    errMsg = errMsg.split(reg([id, pos, pos, trail], 'gi')).join('');
+    errMsg = errMsg.split(reg([normalizeId(id), pos, pos, trail], 'gi')).join('');
+    // Remove "ERROR:" (useless)
+    errMsg = errMsg.split(reg(['ERROR:', trail])).join('');
+    // Remove "Internal server error:" (useless)
+    errMsg = errMsg.split(reg(['Internal server error', trail])).join('');
+    if (containsCodeSnippet(errMsg)) {
+        errMsg = removeStandaloneCodePosition(errMsg);
+    }
+    errMsg = errMsg.trim();
+    if (frame && frame.includes(errMsg))
+        errMsg = '';
+    return errMsg;
+}
+exports.getPrettyErrMessage = getPrettyErrMessage;
+function containsCodeSnippet(str) {
+    str = (0, utils_js_1.stripAnsi)(str);
+    let codeBlockSize = 0;
+    for (const line of str.split('\n')) {
+        if (!isCodeSnippetLine(line)) {
+            codeBlockSize = 0;
+        }
+        else {
+            codeBlockSize++;
+        }
+        if (codeBlockSize >= 3) {
+            return true;
+        }
+    }
+    return false;
+}
+function isCodeSnippetLine(line) {
+    // Babel
+    if (/[\s\d>]*\|/.test(line))
+        return true;
+    // SWC
+    if (/[\s\d>]*(╭─|│|·)/.test(line))
+        return true;
+    return false;
+}
+function reg(parts, flags = '') {
+    return new RegExp(parts.map((part) => (typeof part === 'string' ? (0, utils_js_1.escapeRegex)(part) : part.source)).join(''), flags);
+}
+function removeStandaloneCodePosition(errMsg) {
+    // Remove weird standalone code position " (2:7) "
+    errMsg = errMsg
+        .split('\n')
+        .map((line) => {
+        const posRE = /(\s|^)\(\d+:\d+\)(\s|$)/;
+        (0, utils_js_1.assert)(posRE.test(' (1:2)'));
+        (0, utils_js_1.assert)(posRE.test('(13:42) '));
+        if (!isCodeSnippetLine(line)) {
+            line = line.split(posRE).join('');
+        }
+        return line;
+    })
+        .join('\n');
+    return errMsg;
+}
+function isEquivalentErrorWithCodeSnippet(err1, err2) {
+    if (!(0, utils_js_1.isObject)(err1) || !(0, utils_js_1.isObject)(err2))
+        return false;
+    if (isDefinedAndSame(err1.message, err2.message) &&
+        isDefinedAndSame(err1.frame, err2.frame) &&
+        isDefinedAndSame(err1.id, err2.id)) {
+        return true;
+    }
+    return false;
+}
+exports.isEquivalentErrorWithCodeSnippet = isEquivalentErrorWithCodeSnippet;
+function isDefinedAndSame(val1, val2) {
+    return val1 && val1 === val2;
+}
+function normalizeId(id) {
+    id = (0, utils_js_1.toPosixPath)(id);
+    // remove query
+    id = id.split('?')[0];
+    return id;
+}

package/dist/cjs/node/plugin/shared/loggerNotProd/log.js

@@ -0,0 +1,114 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.screenHasErrors = exports.clearScreen = exports.isFirstLog = exports.logDirectly = exports.logWithVikeTag = exports.logWithViteTag = void 0;
+const utils_js_1 = require("../../utils.js");
+const picocolors_1 = __importDefault(require("@brillout/picocolors"));
+const isErrorDebug_js_1 = require("../isErrorDebug.js");
+const globalContext_js_1 = require("../../../runtime/globalContext.js");
+(0, utils_js_1.assertIsNotProductionRuntime)();
+let isFirstLog = true;
+exports.isFirstLog = isFirstLog;
+let screenHasErrors = false;
+exports.screenHasErrors = screenHasErrors;
+function logWithVikeTag(msg, logType, category, showVikeVersion = false) {
+    const projectTag = getProjectTag(showVikeVersion);
+    msg = prependTags(msg, projectTag, category, logType);
+    logDirectly(msg, logType);
+}
+exports.logWithVikeTag = logWithVikeTag;
+function getProjectTag(showVikeVersion) {
+    let projectTag;
+    if (showVikeVersion) {
+        projectTag = `[${utils_js_1.projectInfo.npmPackageName}@${utils_js_1.projectInfo.projectVersion}]`;
+    }
+    else {
+        projectTag = `[${utils_js_1.projectInfo.npmPackageName}]`;
+    }
+    return projectTag;
+}
+function logWithViteTag(msg, logType, category) {
+    msg = prependTags(msg, '[vite]', category, logType);
+    logDirectly(msg, logType);
+}
+exports.logWithViteTag = logWithViteTag;
+// Not production => every log is triggered by logDirectly()
+//  - Even all Vite logs also go through logDirectly() (see interceptors of loggerVite.ts)
+//  - Production => logs aren't managed by loggerNotProd.ts => logDirectly() is never called (not even loaded as asserted by assertIsVitePluginCode())
+function logDirectly(thing, logType) {
+    applyViteSourceMapToStackTrace(thing);
+    exports.isFirstLog = isFirstLog = false;
+    if (logType === 'info') {
+        console.log(thing);
+        return;
+    }
+    if (logType === 'warn') {
+        console.warn(thing);
+        return;
+    }
+    if (logType === 'error') {
+        exports.screenHasErrors = screenHasErrors = true;
+        console.error(thing);
+        return;
+    }
+    if (logType === 'error-recover') {
+        // stderr because user will most likely want to know about error recovering
+        console.error(thing);
+        return;
+    }
+    (0, utils_js_1.assert)(false);
+}
+exports.logDirectly = logDirectly;
+function clearScreen(viteConfig) {
+    // We use Vite's logger in order to respect the user's `clearScreen: false` setting
+    viteConfig.logger.clearScreen('error');
+    exports.screenHasErrors = screenHasErrors = false;
+}
+exports.clearScreen = clearScreen;
+function applyViteSourceMapToStackTrace(thing) {
+    if ((0, isErrorDebug_js_1.isErrorDebug)())
+        return;
+    if (!(0, utils_js_1.hasProp)(thing, 'stack'))
+        return;
+    const viteDevServer = (0, globalContext_js_1.getViteDevServer)();
+    if (!viteDevServer)
+        return;
+    // Apply Vite's source maps
+    viteDevServer.ssrFixStacktrace(thing);
+}
+function prependTags(msg, projectTag, category, logType) {
+    const color = (s) => {
+        if (logType === 'error' && !hasRed(msg))
+            return picocolors_1.default.bold(picocolors_1.default.red(s));
+        if (logType === 'error-recover' && !hasGreen(msg))
+            return picocolors_1.default.bold(picocolors_1.default.green(s));
+        if (logType === 'warn' && !hasYellow(msg))
+            return picocolors_1.default.yellow(s);
+        if (projectTag === '[vite]')
+            return picocolors_1.default.bold(picocolors_1.default.cyan(s));
+        if (projectTag.startsWith(`[${utils_js_1.projectInfo.npmPackageName}`))
+            return picocolors_1.default.bold(picocolors_1.default.cyan(s));
+        (0, utils_js_1.assert)(false);
+    };
+    let tag = color(`${projectTag}`);
+    if (category) {
+        tag = tag + picocolors_1.default.dim(`[${category}]`);
+    }
+    const timestamp = picocolors_1.default.dim(new Date().toLocaleTimeString());
+    const whitespace = /\s|\[/.test((0, utils_js_1.stripAnsi)(msg)[0]) ? '' : ' ';
+    return `${timestamp} ${tag}${whitespace}${msg}`;
+}
+function hasRed(str) {
+    // https://github.com/brillout/picocolors/blob/e291f2a3e3251a7f218ab6369ae94434d85d0eb0/picocolors.js#L57
+    return str.includes('\x1b[31m');
+}
+function hasGreen(str) {
+    // https://github.com/brillout/picocolors/blob/e291f2a3e3251a7f218ab6369ae94434d85d0eb0/picocolors.js#L58
+    return str.includes('\x1b[32m');
+}
+function hasYellow(str) {
+    // https://github.com/brillout/picocolors/blob/e291f2a3e3251a7f218ab6369ae94434d85d0eb0/picocolors.js#L59
+    return str.includes('\x1b[33m');
+}

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

@@ -0,0 +1,224 @@
+"use strict";
+// Non-production logger used for:
+//  - Development
+//  - Preview
+//  - Build
+//  - Pre-rendering
+// In other words: everywhere except in production
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.clearLogs = exports.logErrorDebugNote = exports.logConfigErrorRecover = exports.logConfigError = exports.logConfigInfo = exports.logViteErrorContainingCodeSnippet = exports.logViteAny = void 0;
+const abort_js_1 = require("../../../shared/route/abort.js");
+const globalContext_js_1 = require("../../runtime/globalContext.js");
+const loggerRuntime_js_1 = require("../../runtime/renderPage/loggerRuntime.js");
+const utils_js_1 = require("../utils.js");
+const getHttpRequestAsyncStore_js_1 = require("./getHttpRequestAsyncStore.js");
+const isErrorDebug_js_1 = require("./isErrorDebug.js");
+const errorWithCodeSnippet_js_1 = require("./loggerNotProd/errorWithCodeSnippet.js");
+const transpileAndExecuteFile_js_1 = require("../plugins/importUserCode/v1-design/transpileAndExecuteFile.js");
+const log_js_1 = require("./loggerNotProd/log.js");
+const picocolors_1 = __importDefault(require("@brillout/picocolors"));
+const isNewError_js_1 = require("../../runtime/renderPage/isNewError.js");
+const isConfigInvalid_js_1 = require("../../runtime/renderPage/isConfigInvalid.js");
+(0, utils_js_1.assertIsNotProductionRuntime)();
+(0, loggerRuntime_js_1.overwriteRuntimeProductionLogger)(logRuntimeError, logRuntimeInfo);
+(0, utils_js_1.overwriteAssertProductionLogger)(assertLogger);
+function logRuntimeInfo(msg, httpRequestId, logType, clearErrors) {
+    if (clearErrors)
+        clearLogs({ clearErrors: true });
+    const category = getCategory(httpRequestId);
+    (0, utils_js_1.assert)(category);
+    (0, log_js_1.logWithVikeTag)(msg, logType, category);
+}
+function logViteAny(msg, logType, httpRequestId, prependViteTag) {
+    if (prependViteTag) {
+        const category = getCategory(httpRequestId);
+        (0, log_js_1.logWithViteTag)(msg, logType, category);
+    }
+    else {
+        (0, log_js_1.logDirectly)(msg, logType);
+    }
+}
+exports.logViteAny = logViteAny;
+function logConfigInfo(msg, logType) {
+    const category = getConfigCategory();
+    (0, log_js_1.logWithVikeTag)(msg, logType, category);
+}
+exports.logConfigInfo = logConfigInfo;
+function logConfigErrorRecover() {
+    const msg = picocolors_1.default.bold(picocolors_1.default.green('Configuration successfully loaded'));
+    clearLogs({ clearAlsoIfConfigIsInvalid: true });
+    const category = getConfigCategory();
+    (0, log_js_1.logWithVikeTag)(msg, 'error-recover', category);
+}
+exports.logConfigErrorRecover = logConfigErrorRecover;
+function logRuntimeError(err, 
+/** `httpRequestId` is `null` when pre-rendering */
+httpRequestId) {
+    logErr(err, httpRequestId);
+}
+function logViteErrorContainingCodeSnippet(err) {
+    logErr(err);
+}
+exports.logViteErrorContainingCodeSnippet = logViteErrorContainingCodeSnippet;
+function logErr(err, httpRequestId = null) {
+    (0, utils_js_1.warnIfErrorIsNotObject)(err);
+    if ((0, abort_js_1.isAbortError)(err) && !(0, isErrorDebug_js_1.isErrorDebug)()) {
+        return;
+    }
+    const store = (0, getHttpRequestAsyncStore_js_1.getHttpRequestAsyncStore)();
+    (0, isNewError_js_1.setAlreadyLogged)(err);
+    if ((0, getHttpRequestAsyncStore_js_1.getHttpRequestAsyncStore)()?.shouldErrorBeSwallowed(err)) {
+        if (!(0, isErrorDebug_js_1.isErrorDebug)())
+            return;
+    }
+    else {
+        store?.markErrorAsLogged(err);
+    }
+    const category = getCategory(httpRequestId);
+    if (!(0, isErrorDebug_js_1.isErrorDebug)()) {
+        if ((0, errorWithCodeSnippet_js_1.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 = (0, globalContext_js_1.getViteConfig)();
+            (0, utils_js_1.assert)(viteConfig);
+            let prettyErr = (0, errorWithCodeSnippet_js_1.getPrettyErrorWithCodeSnippet)(err, viteConfig.root);
+            (0, utils_js_1.assert)((0, utils_js_1.stripAnsi)(prettyErr).startsWith('Failed to transpile'));
+            (0, log_js_1.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 = (0, utils_js_1.isUserHookError)(err);
+    if (hook) {
+        const { hookName, hookFilePath } = hook;
+        (0, log_js_1.logWithVikeTag)(picocolors_1.default.red(`Following error was thrown by the ${hookName}() hook defined at ${hookFilePath}`), 'error', category);
+    }
+    else if (category) {
+        logFallbackErrIntro(category);
+    }
+    (0, log_js_1.logDirectly)(err, 'error');
+}
+function logConfigError(err) {
+    clearLogs({ clearAlsoIfConfigIsInvalid: true });
+    (0, utils_js_1.warnIfErrorIsNotObject)(err);
+    const category = getConfigCategory();
+    {
+        const errIntroMsg = (0, transpileAndExecuteFile_js_1.getConfigExececutionErrorIntroMsg)(err);
+        if (errIntroMsg) {
+            (0, utils_js_1.assert)((0, utils_js_1.stripAnsi)(errIntroMsg).startsWith('Failed to execute'));
+            (0, log_js_1.logWithVikeTag)(errIntroMsg, 'error', category);
+            (0, log_js_1.logDirectly)(err, 'error');
+            return;
+        }
+    }
+    {
+        const errMsgFormatted = (0, transpileAndExecuteFile_js_1.getConfigBuildErrorFormatted)(err);
+        if (errMsgFormatted) {
+            (0, utils_js_1.assert)((0, utils_js_1.stripAnsi)(errMsgFormatted).startsWith('Failed to transpile'));
+            if (!(0, isErrorDebug_js_1.isErrorDebug)()) {
+                (0, log_js_1.logWithVikeTag)(errMsgFormatted, 'error', category);
+            }
+            else {
+                (0, log_js_1.logDirectly)(err, 'error');
+            }
+            return;
+        }
+    }
+    {
+        const logged = handleAssertMsg(err, category);
+        if (logged)
+            return;
+    }
+    if (category)
+        logFallbackErrIntro(category);
+    (0, log_js_1.logDirectly)(err, 'error');
+}
+exports.logConfigError = logConfigError;
+function logFallbackErrIntro(category) {
+    (0, log_js_1.logWithVikeTag)(picocolors_1.default.bold(picocolors_1.default.red('[Error] An error was thrown:')), 'error', category);
+}
+function getConfigCategory() {
+    const category = getCategory() ?? 'config';
+    return category;
+}
+function handleAssertMsg(err, category) {
+    const res = (0, utils_js_1.getAssertErrMsg)(err);
+    if (!res)
+        return false;
+    const { assertMsg, showVikeVersion } = res;
+    (0, log_js_1.logWithVikeTag)(assertMsg, 'error', category, showVikeVersion);
+    return true;
+}
+function assertLogger(thing, logType) {
+    const category = getCategory();
+    const res = (0, utils_js_1.getAssertErrMsg)(thing);
+    /* Risk of infinite loop
+    assert(res)
+    */
+    if (!res)
+        throw new Error('Internal error, reach out to a maintainer');
+    const { assertMsg, showVikeVersion } = res;
+    (0, log_js_1.logWithVikeTag)(assertMsg, logType, category, showVikeVersion);
+}
+function clearLogs(conditions = {}) {
+    if (!conditions.clearAlsoIfConfigIsInvalid && isConfigInvalid_js_1.isConfigInvalid) {
+        // Avoid hiding the config error: the config error is printed only once
+        return;
+    }
+    if (conditions.clearErrors && !log_js_1.screenHasErrors) {
+        return;
+    }
+    if (conditions.clearIfFirstLog && !log_js_1.isFirstLog) {
+        return;
+    }
+    const viteConfig = (0, globalContext_js_1.getViteConfig)();
+    if (viteConfig) {
+        (0, log_js_1.clearScreen)(viteConfig);
+    }
+}
+exports.clearLogs = clearLogs;
+/** 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 ((0, isErrorDebug_js_1.isErrorDebug)())
+        return;
+    const store = (0, getHttpRequestAsyncStore_js_1.getHttpRequestAsyncStore)();
+    if (store) {
+        if (store.errorDebugNoteAlreadyShown)
+            return;
+        store.errorDebugNoteAlreadyShown = true;
+    }
+    const msg = picocolors_1.default.dim([
+        '┌─────────────────────────────────────────────────────────────────────┐',
+        "│ Error isn't helpful? See https://vike.dev/errors#verbose │",
+        '└─────────────────────────────────────────────────────────────────────┘'
+    ].join('\n'));
+    (0, log_js_1.logDirectly)(msg, 'error');
+}
+exports.logErrorDebugNote = logErrorDebugNote;
+function getCategory(httpRequestId = null) {
+    const store = (0, getHttpRequestAsyncStore_js_1.getHttpRequestAsyncStore)();
+    if (store?.httpRequestId !== undefined) {
+        if (httpRequestId === null) {
+            httpRequestId = store.httpRequestId;
+        }
+        else {
+            (0, utils_js_1.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/cjs/node/plugin/shared/loggerVite/removeSuperfluousViteLog.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.removeSuperfluousViteLog_disable = exports.removeSuperfluousViteLog_enable = exports.removeSuperfluousViteLog = void 0;
+const utils_js_1 = require("../../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')) {
+        (0, utils_js_1.assert)(msg === superfluousLog, msg); // assertion fails => Vite changed its message => update this function
+        return true;
+    }
+    return false;
+}
+exports.removeSuperfluousViteLog = removeSuperfluousViteLog;
+function removeSuperfluousViteLog_enable() {
+    enabled = true;
+}
+exports.removeSuperfluousViteLog_enable = removeSuperfluousViteLog_enable;
+function removeSuperfluousViteLog_disable() {
+    enabled = false;
+}
+exports.removeSuperfluousViteLog_disable = removeSuperfluousViteLog_disable;

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

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.improveViteLogs = void 0;
+const utils_js_1 = require("../utils.js");
+const loggerNotProd_js_1 = require("./loggerNotProd.js");
+const errorWithCodeSnippet_js_1 = require("./loggerNotProd/errorWithCodeSnippet.js");
+const getHttpRequestAsyncStore_js_1 = require("./getHttpRequestAsyncStore.js");
+const removeSuperfluousViteLog_js_1 = require("./loggerVite/removeSuperfluousViteLog.js");
+const isErrorDebug_js_1 = require("./isErrorDebug.js");
+function improveViteLogs(config) {
+    intercept('info', config);
+    intercept('warn', config);
+    intercept('error', config);
+}
+exports.improveViteLogs = improveViteLogs;
+function intercept(logType, config) {
+    config.logger[logType] = (msg, options = {}) => {
+        (0, utils_js_1.assert)(!(0, isErrorDebug_js_1.isErrorDebug)());
+        if ((0, removeSuperfluousViteLog_js_1.removeSuperfluousViteLog)(msg))
+            return;
+        if (!!options.timestamp) {
+            msg = (0, utils_js_1.trimWithAnsi)(msg);
+        }
+        else {
+            // No timestamp => no "[vite]" tag prepended => we don't trim the beginning of the message
+            msg = (0, utils_js_1.trimWithAnsiTrailOnly)(msg);
+        }
+        msg = cleanFirstViteLog(msg);
+        const store = (0, getHttpRequestAsyncStore_js_1.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 && (0, errorWithCodeSnippet_js_1.isErrorWithCodeSnippet)(options.error)) {
+            (0, loggerNotProd_js_1.logViteErrorContainingCodeSnippet)(options.error);
+            return;
+        }
+        // Only allow Vite to clear its first log. All other clearing is controlled by vike.
+        if (options.clear)
+            (0, loggerNotProd_js_1.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;
+        (0, loggerNotProd_js_1.logViteAny)(msg, logType, store?.httpRequestId ?? null, prependViteTag);
+    };
+}
+function cleanFirstViteLog(msg) {
+    const isFirstVitLog = msg.includes('VITE') && msg.includes('ready');
+    if (isFirstVitLog) {
+        return (0, utils_js_1.removeEmptyLines)(msg);
+    }
+    else {
+        return msg;
+    }
+}

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

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getImportStatements = exports.getExportNames = void 0;
+const es_module_lexer_1 = require("es-module-lexer");
+const utils_js_1 = require("../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)`
+            (0, utils_js_1.assert)(n);
+            wildcardReExports.push(n);
+        }
+    });
+    return { wildcardReExports, exportNames };
+}
+exports.getExportNames = getExportNames;
+async function getImportStatements(src) {
+    const parseResult = await parseEsModule(src);
+    const imports = parseResult[0].slice();
+    return imports;
+}
+exports.getImportStatements = getImportStatements;
+async function parseEsModule(src) {
+    await es_module_lexer_1.init;
+    return (0, es_module_lexer_1.parse)(src);
+}

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

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.removeSourceMap = void 0;
+function removeSourceMap(code) {
+    return {
+        code,
+        // Remove Source Map to save KBs
+        //  - https://rollupjs.org/guide/en/#source-code-transformations
+        map: { mappings: '' }
+    };
+}
+exports.removeSourceMap = removeSourceMap;

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

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rollupIsEsm = void 0;
+const utils_js_1 = require("../utils.js");
+function rollupIsEsm(rollupOptions) {
+    const { format } = rollupOptions;
+    (0, utils_js_1.assert)(typeof format === 'string');
+    (0, utils_js_1.assert)(format === 'amd' ||
+        format === 'cjs' ||
+        format === 'es' ||
+        format === 'iife' ||
+        format === 'system' ||
+        format === 'umd');
+    return format === 'es';
+}
+exports.rollupIsEsm = rollupIsEsm;