vike 0.4.146 → 0.4.147-commit-f9a91f3

package/dist/esm/client/client-routing-runtime/getPageContextFromHooks.js

@@ -27,7 +27,7 @@ async function getPageContextFromHooks_firstRender(pageContext) {
     objectAssign(pageContextFromHooks, await loadPageFilesClientSide(pageContextFromHooks._pageId, pageContext));
     {
         const pageContextForHook = { ...pageContext, ...pageContextFromHooks };
-        if (await onBeforeRenderClientOnlyExists(pageContextForHook)) {
+        if (onBeforeRenderClientOnlyExists(pageContextForHook)) {
             const pageContextFromHook = await executeOnBeforeRenderHookClientSide(pageContextForHook);
             objectAssign(pageContextFromHooks, pageContextFromHook);
         }
@@ -57,13 +57,17 @@ async function getPageContextFromHooks_uponNavigation(pageContext) {
 }
 async function getPageContextAlreadyRouted(pageContext, isErrorPage) {
     let pageContextFromHooks = {};
+    objectAssign(pageContextFromHooks, { _hasPageContextFromClient: false });
     objectAssign(pageContextFromHooks, await loadPageFilesClientSide(pageContext._pageId, pageContext));
+    let pageContextFetchedFromServer = false;
     // Needs to be called before any client-side hook, because it may contain pageContextInit.user which is needed for guard() and onBeforeRender()
     if (
     // For the error page, we cannot fetch pageContext from the server because the pageContext JSON request is based on the URL
     !isErrorPage &&
+        // true if pageContextInit has some client data or the onBeforeRender hook is server-side only:
         (await hasPageContextServer({ ...pageContext, ...pageContextFromHooks }))) {
         const pageContextFromServer = await fetchPageContextFromServer(pageContext);
+        pageContextFetchedFromServer = true;
         if (!pageContextFromServer['_isError']) {
             objectAssign(pageContextFromHooks, pageContextFromServer);
         }
@@ -72,6 +76,7 @@ async function getPageContextAlreadyRouted(pageContext, isErrorPage) {
             assert(errorPageId);
             pageContextFromHooks = {};
             objectAssign(pageContextFromHooks, {
+                _hasPageContextFromClient: false,
                 isHydration: false,
                 _pageId: errorPageId
             });
@@ -91,25 +96,29 @@ async function getPageContextAlreadyRouted(pageContext, isErrorPage) {
         if (!isErrorPage) {
             // Should we really call the guard() hook on the client-side? Shouldn't we make the guard() hook a server-side only hook? Or maybe make its env configurable like onBeforeRender()?
             await executeGuardHook({
-                _hasPageContextFromClient: false,
                 ...pageContext,
                 ...pageContextFromHooks
             }, (pageContext) => preparePageContextForUserConsumptionClientSide(pageContext, true));
         }
     }
+    // For the error page, we also execute the client-side onBeforeRender() hook, but maybe we shouldn't? The server-side does it as well (but maybe it shouldn't).
     {
-        // For the error page, we also execute the client-side onBeforeRender() hook, but maybe we shouldn't? The server-side does it as well (but maybe it shouldn't).
-        const pageContextFromOnBeforeRender = await executeOnBeforeRenderHookClientSide({
-            ...pageContext,
-            ...pageContextFromHooks
-        });
-        objectAssign(pageContextFromHooks, pageContextFromOnBeforeRender);
+        const pageContextForHook = { ...pageContext, ...pageContextFromHooks };
+        if (onBeforeRenderClientOnlyExists(pageContextForHook) || !pageContextFetchedFromServer) {
+            // This won't do anything if no hook has been defined or if the hook's env.client is false.
+            const pageContextFromHook = await executeOnBeforeRenderHookClientSide(pageContextForHook);
+            objectAssign(pageContextFromHooks, pageContextFromHook);
+        }
+        else {
+            assert(pageContextFetchedFromServer);
+        }
     }
     return pageContextFromHooks;
 }
 async function executeOnBeforeRenderHookClientSide(pageContext) {
     const hook = getHook(pageContext, 'onBeforeRender');
     if (!hook) {
+        // No hook defined or hook's env.client is false
         const pageContextFromOnBeforeRender = {
             _hasPageContextFromClient: false
         };
@@ -153,7 +162,9 @@ async function onBeforeRenderServerOnlyExists(pageContext) {
     if (pageContext._pageConfigs.length > 0) {
         // V1
         const pageConfig = getPageConfig(pageContext._pageId, pageContext._pageConfigs);
-        return getConfigValue(pageConfig, 'onBeforeRenderEnv')?.value === 'server-only';
+        const onBeforeRenderEnv = getConfigValue(pageConfig, 'onBeforeRenderEnv')?.value ?? {};
+        assert(isObject(onBeforeRenderEnv));
+        return !!onBeforeRenderEnv.server && !onBeforeRenderEnv.client;
     }
     else {
         // TODO/v1-release: remove
@@ -162,14 +173,17 @@ async function onBeforeRenderServerOnlyExists(pageContext) {
         return hasOnBeforeRenderServerSideOnlyHook;
     }
 }
-async function onBeforeRenderClientOnlyExists(pageContext) {
+function onBeforeRenderClientOnlyExists(pageContext) {
     if (pageContext._pageConfigs.length > 0) {
         // V1
         const pageConfig = getPageConfig(pageContext._pageId, pageContext._pageConfigs);
-        return getConfigValue(pageConfig, 'onBeforeRenderEnv')?.value === 'client-only';
+        const onBeforeRenderEnv = getConfigValue(pageConfig, 'onBeforeRenderEnv')?.value ?? {};
+        assert(isObject(onBeforeRenderEnv));
+        return !!onBeforeRenderEnv.client && !onBeforeRenderEnv.server;
     }
     else {
         // TODO/v1-release: remove
+        // Client-only onBeforeRender() hooks were never supported for the V0.4 design
         return false;
     }
 }

package/dist/esm/client/client-routing-runtime/index.d.ts

@@ -1,5 +1,6 @@
 export { navigate, reload } from './navigate.js';
 export { prefetch } from './prefetch.js';
+export { PROJECT_VERSION } from './utils.js';
 import type { PageContextBuiltInClientWithClientRouting } from '../../shared/types.js';
 /** @deprecated
  * Replace:

package/dist/esm/client/client-routing-runtime/index.js

@@ -5,3 +5,4 @@
 // Use package.json#exports to make the imports isomorphic.
 export { navigate, reload } from './navigate.js';
 export { prefetch } from './prefetch.js';
+export { PROJECT_VERSION } from './utils.js';

package/dist/esm/client/client-routing-runtime/onBrowserHistoryNavigation.js

@@ -14,8 +14,8 @@ function onBrowserHistoryNavigation() {
     //     - By user clicking on a hash link `<a href="#some-hash" />`
     //       - The popstate event is *only* triggered if `href` starts with '#' (even if `href` is '/#some-hash' while the current URL's pathname is '/' then the popstate still isn't triggered)
     //     - By JavaScript: `location.hash = 'some-hash'`
-    // - The `event` of `window.addEventListener('popstate', (event) => /*...*/)` is useless: the History API doesn't provide the previous state (the popped state), see https://stackoverflow.com/questions/48055323/is-history-state-always-the-same-as-popstate-event-state
-    window.addEventListener('popstate', () => {
+    // - The `event` argument of `window.addEventListener('popstate', (event) => /*...*/)` is useless: the History API doesn't provide the previous state (the popped state), see https://stackoverflow.com/questions/48055323/is-history-state-always-the-same-as-popstate-event-state
+    window.addEventListener('popstate', (ev) => {
         const currentState = getState();
         const scrollTarget = currentState.historyState.scrollPosition || 'scroll-to-top-or-hash';
         const isUserLandPushStateNavigation = currentState.historyState.triggedBy === 'user';

package/dist/esm/client/shared/getPageContextSerializedInHtml.js

@@ -4,7 +4,7 @@ export { getPageContextSerializedInHtml };
 function getPageContextSerializedInHtml() {
     const id = 'vike_pageContext';
     const elem = document.getElementById(id);
-    assertUsage(elem, `The element #${id} (which vike automatically injects into the HTML) is missing from the DOM. This may happen if your HTML is malformed. Make sure your HTML isn't malformed, and make sure you don't remove #${id} from the HTML nor from the DOM.`);
+    assertUsage(elem, `The element #${id} (which Vike automatically injects into the HTML) is missing from the DOM. This may happen if your HTML is malformed. Make sure your HTML isn't malformed, and make sure you don't remove #${id} from the HTML nor from the DOM.`);
     const pageContextJson = elem.textContent;
     assert(pageContextJson);
     const pageContextSerializedInHtml = parse(pageContextJson);

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

@@ -2,5 +2,6 @@ export default plugin;
 export { plugin };
 export { plugin as ssr };
 export type { ConfigVikeUserProvided as UserConfig };
+export { PROJECT_VERSION as version } from './utils.js';
 import type { ConfigVikeUserProvided } from '../../shared/ConfigVike.js';
 declare function plugin(vikeConfig?: ConfigVikeUserProvided): any;

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

@@ -2,6 +2,7 @@ export default plugin;
 export { plugin };
 // TODO/v1-release: remove
 export { plugin as ssr };
+export { PROJECT_VERSION as version } from './utils.js';
 import { assertUsage, markEnvAsVite } from './utils.js';
 import { buildConfig } from './plugins/buildConfig.js';
 import { previewConfig } from './plugins/previewConfig.js';

package/dist/esm/node/plugin/plugins/devConfig/determineOptimizeDeps.js

@@ -2,7 +2,7 @@ export { determineOptimizeDeps };
 import { findPageFiles } from '../../shared/findPageFiles.js';
 import { assert, getFilePathAbsolute, isNotNullish, isNpmPackageImport, unique } from '../../utils.js';
 import { getVikeConfig } from '../importUserCode/v1-design/getVikeConfig.js';
-import { getConfigValueSourcesRelevant } from '../../shared/getConfigValueSourcesRelevant.js';
+import { getConfigValueSourcesNotOverriden } from '../../shared/getConfigValueSourcesNotOverriden.js';
 import { analyzeClientEntries } from '../buildConfig.js';
 import { virtualFileIdImportUserCodeClientCR, virtualFileIdImportUserCodeClientSR } from '../../../shared/virtual-files/virtualFileImportUserCode.js';
 async function determineOptimizeDeps(config, configVike, isDev) {
@@ -30,12 +30,11 @@ async function getPageDeps(config, pageConfigs, isDev) {
     // V1 design
     {
         pageConfigs.forEach((pageConfig) => {
-            const configValueSourcesRelevant = getConfigValueSourcesRelevant(pageConfig);
-            configValueSourcesRelevant.forEach((configValueSource) => {
+            getConfigValueSourcesNotOverriden(pageConfig).forEach((configValueSource) => {
                 if (!configValueSource.valueIsImportedAtRuntime)
                     return;
                 const { definedAt, configEnv } = configValueSource;
-                if (configEnv !== 'client-only' && configEnv !== 'server-and-client')
+                if (!configEnv.client)
                     return;
                 if (definedAt.filePathRelativeToUserRootDir !== null) {
                     const { filePathAbsoluteFilesystem } = definedAt;

package/dist/esm/node/plugin/plugins/importUserCode/v1-design/getConfigValuesSerialized.d.ts

@@ -0,0 +1,5 @@
+export { getConfigValuesSerialized };
+export { assertConfigValueIsSerializable };
+import type { ConfigEnvInternal, ConfigValueSource, DefinedAt, PageConfigBuildTime } from '../../../../../shared/page-configs/PageConfig.js';
+declare function getConfigValuesSerialized(pageConfig: PageConfigBuildTime, isEnvMatch: (configEnv: ConfigEnvInternal, configValueSource?: ConfigValueSource) => boolean): string;
+declare function assertConfigValueIsSerializable(value: unknown, configName: string, definedAt: DefinedAt): void;

package/dist/esm/node/plugin/plugins/importUserCode/v1-design/getConfigValuesSerialized.js

@@ -0,0 +1,70 @@
+export { getConfigValuesSerialized };
+export { assertConfigValueIsSerializable };
+import { assert, assertUsage, getPropAccessNotation } from '../../../utils.js';
+import { isJsonSerializerError, stringify } from '@brillout/json-serializer/stringify';
+import pc from '@brillout/picocolors';
+import { getConfigValueFilePathToShowToUser } from '../../../../../shared/page-configs/helpers.js';
+import { serializeConfigValue } from '../../../../../shared/page-configs/serialize/serializeConfigValue.js';
+import { getConfigValueSourcesNotOverriden } from '../../../shared/getConfigValueSourcesNotOverriden.js';
+function getConfigValuesSerialized(pageConfig, isEnvMatch) {
+    const lines = [];
+    Object.entries(pageConfig.configValuesComputed).forEach(([configName, configValuesComputed]) => {
+        const { value, configEnv } = configValuesComputed;
+        if (!isEnvMatch(configEnv))
+            return;
+        // configValeSources has higher precedence
+        if (pageConfig.configValueSources[configName])
+            return;
+        const configValue = pageConfig.configValues[configName];
+        assert(configValue);
+        const { definedAt } = configValue;
+        const valueSerialized = getConfigValueSerialized(value, configName, definedAt);
+        serializeConfigValue(lines, configName, { definedAt, valueSerialized });
+    });
+    getConfigValueSourcesNotOverriden(pageConfig).forEach((configValueSource) => {
+        const { configName, configEnv } = configValueSource;
+        const configValue = pageConfig.configValues[configName];
+        if (!configValue)
+            return;
+        if (!isEnvMatch(configEnv, configValueSource)) {
+            return;
+        }
+        const { value, definedAt } = configValue;
+        const valueSerialized = getConfigValueSerialized(value, configName, definedAt);
+        serializeConfigValue(lines, configName, { definedAt, valueSerialized });
+    });
+    const code = lines.join('\n');
+    return code;
+}
+function assertConfigValueIsSerializable(value, configName, definedAt) {
+    // Contains asserts
+    getConfigValueSerialized(value, configName, definedAt);
+}
+function getConfigValueSerialized(value, configName, definedAt) {
+    const valueName = `config${getPropAccessNotation(configName)}`;
+    let configValueSerialized;
+    try {
+        configValueSerialized = stringify(value, { valueName, forbidReactElements: true });
+    }
+    catch (err) {
+        let serializationErrMsg = '';
+        if (isJsonSerializerError(err)) {
+            serializationErrMsg = err.messageCore;
+        }
+        else {
+            // When a property getter throws an error
+            console.error('Serialization error:');
+            console.error(err);
+            serializationErrMsg = 'see serialization error printed above';
+        }
+        const configValueFilePathToShowToUser = getConfigValueFilePathToShowToUser({ definedAt });
+        assert(configValueFilePathToShowToUser);
+        assertUsage(false, [
+            `The value of the config ${pc.cyan(configName)} cannot be defined inside the file ${configValueFilePathToShowToUser}:`,
+            `its value must be defined in an another file and then imported by ${configValueFilePathToShowToUser}. (Because its value isn't serializable: ${serializationErrMsg}.)`,
+            `Only serializable config values can be defined inside +config.h.js files, see https://vike.dev/header-file.`
+        ].join(' '));
+    }
+    configValueSerialized = JSON.stringify(configValueSerialized);
+    return configValueSerialized;
+}

package/dist/esm/node/plugin/plugins/importUserCode/v1-design/getVikeConfig/configDefinitionsBuiltIn.js

@@ -1,98 +1,119 @@
 export { configDefinitionsBuiltIn };
 export { configDefinitionsBuiltInGlobal };
-import { getConfigEnv, isConfigSet } from '../helpers.js';
+import { assert } from '../../../../utils.js';
 const configDefinitionsBuiltIn = {
     onRenderHtml: {
-        env: 'server-only'
+        env: { server: true }
     },
     onRenderClient: {
-        env: 'client-only'
+        env: { client: true }
     },
     onHydrationEnd: {
-        env: 'client-only'
+        env: { client: true }
     },
     onPageTransitionStart: {
-        env: 'client-only'
+        env: { client: true }
     },
     onPageTransitionEnd: {
-        env: 'client-only'
+        env: { client: true }
     },
     onBeforeRender: {
-        env: 'server-only'
+        env: { server: true }
     },
     onBeforePrerenderStart: {
-        env: 'server-only'
+        env: { server: true }
     },
     Page: {
-        env: 'server-and-client'
+        env: { server: true, client: true }
     },
     passToClient: {
-        env: 'server-only',
+        env: { server: true, config: true },
         cumulative: true
     },
     route: {
-        env: '_routing-eager'
+        env: { server: true, client: 'if-client-routing', eager: true }
     },
     guard: {
-        env: '_routing-lazy'
+        env: { server: true, client: 'if-client-routing' }
     },
     iKnowThePerformanceRisksOfAsyncRouteFunctions: {
-        env: '_routing-eager'
+        env: { server: true, client: 'if-client-routing', eager: true }
     },
     filesystemRoutingRoot: {
-        env: 'config-only'
+        env: { config: true }
     },
     client: {
         // The value of the client config is merely the file path to the client entry file, which is only needed on the sever-side
-        env: 'server-only',
+        env: { server: true },
         _valueIsFilePath: true
     },
     clientRouting: {
-        // We could make it 'server-only' (we don't yet because of some legacy V0.4 design code)
-        env: 'server-and-client'
+        // We could make it { client: false } but we don't yet because of some legacy V0.4 design code
+        env: { server: true, client: true, config: true, eager: true }
     },
     prerender: {
-        env: 'config-only'
+        env: { config: true }
     },
     hydrationCanBeAborted: {
-        env: 'client-only'
+        env: { client: true }
     },
     prefetchStaticAssets: {
-        env: 'client-only'
+        env: { client: true }
     },
     extends: {
-        env: 'config-only'
+        env: { config: true }
     },
     meta: {
-        env: 'config-only'
+        env: { config: true }
     },
     isClientSideRenderable: {
-        env: 'server-and-client',
+        env: { server: true, client: true, eager: true },
         _computed: (configValueSources) => isConfigSet(configValueSources, 'onRenderClient') &&
             isConfigSet(configValueSources, 'Page') &&
-            getConfigEnv(configValueSources, 'Page') !== 'server-only'
+            !!getConfigEnv(configValueSources, 'Page')?.client
     },
     onBeforeRenderEnv: {
-        env: 'client-only',
+        env: { client: true },
         _computed: (configValueSources) => !isConfigSet(configValueSources, 'onBeforeRender') ? null : getConfigEnv(configValueSources, 'onBeforeRender')
     }
 };
 const configDefinitionsBuiltInGlobal = {
     onPrerenderStart: {
-        env: 'server-only'
+        env: { server: true }
     },
     onBeforeRoute: {
-        env: '_routing-eager'
+        env: { server: true, client: 'if-client-routing', eager: true }
     },
     prerender: {
-        env: 'config-only'
-    },
-    extensions: { env: 'config-only' },
-    disableAutoFullBuild: { env: 'config-only' },
-    includeAssetsImportedByServer: { env: 'config-only' },
-    baseAssets: { env: 'config-only' },
-    baseServer: { env: 'config-only' },
-    redirects: { env: 'server-only' },
-    trailingSlash: { env: 'server-only' },
-    disableUrlNormalization: { env: 'server-only' }
+        env: { config: true }
+    },
+    extensions: { env: { config: true } },
+    disableAutoFullBuild: { env: { config: true } },
+    includeAssetsImportedByServer: { env: { config: true } },
+    baseAssets: { env: { config: true } },
+    baseServer: { env: { config: true } },
+    redirects: { env: { server: true } },
+    trailingSlash: { env: { server: true } },
+    disableUrlNormalization: { env: { server: true } }
 };
+function getConfigEnv(configValueSources, configName) {
+    const configValueSource = getConfigValueSource(configValueSources, configName);
+    if (!configValueSource)
+        return null;
+    return configValueSource.configEnv;
+}
+function isConfigSet(configValueSources, configName) {
+    const configValueSource = getConfigValueSource(configValueSources, configName);
+    // Enable users to suppress global config values by overriding the config's value to null
+    if (configValueSource?.value === null)
+        return false;
+    return !!configValueSource;
+}
+function getConfigValueSource(configValueSources, configName) {
+    const sources = configValueSources[configName];
+    if (!sources)
+        return null;
+    const configValueSource = sources[0];
+    assert(configValueSource);
+    return configValueSource;
+}

package/dist/esm/node/plugin/plugins/importUserCode/v1-design/getVikeConfig/crawlPlusFiles.d.ts

@@ -0,0 +1,5 @@
+export { crawlPlusFiles };
+declare function crawlPlusFiles(userRootDir: string, outDirAbsoluteFilesystem: string, isDev: boolean): Promise<{
+    filePathRelativeToUserRootDir: string;
+    filePathAbsoluteFilesystem: string;
+}[]>;

package/dist/esm/node/plugin/plugins/importUserCode/v1-design/getVikeConfig/crawlPlusFiles.js

@@ -0,0 +1,98 @@
+export { crawlPlusFiles };
+import { assertPosixPath, assert, toPosixPath, assertWarning, scriptFileExtensionList, scriptFileExtensions } from '../../../../utils.js';
+import path from 'path';
+import glob from 'fast-glob';
+import { exec } from 'child_process';
+import { promisify } from 'util';
+const execA = promisify(exec);
+async function crawlPlusFiles(userRootDir, outDirAbsoluteFilesystem, isDev) {
+    assertPosixPath(userRootDir);
+    assertPosixPath(outDirAbsoluteFilesystem);
+    assert(outDirAbsoluteFilesystem.startsWith(userRootDir));
+    const outDir = path.posix.relative(userRootDir, outDirAbsoluteFilesystem);
+    assert(!outDir.startsWith('.'));
+    const timeBase = new Date().getTime();
+    let files = [];
+    const res = await gitLsFiles(userRootDir, outDir);
+    if (res &&
+        // Fallback to fast-glob for users that dynamically generate plus files (we assume generetad plus files to be skipped because they are usually included in .gitignore)
+        res.length > 0) {
+        files = res;
+    }
+    else {
+        files = await fastGlob(userRootDir, outDir);
+    }
+    {
+        const time = new Date().getTime() - timeBase;
+        if (isDev) {
+            // We only warn in dev, because while building it's expected to take a long time as fast-glob is competing for resources with other tasks
+            assertWarning(time < 2 * 1000, `Crawling your user files took an unexpected long time (${time}ms). Create a new issue on Vike's GitHub.`, {
+                onlyOnce: 'slow-page-files-search'
+            });
+        }
+    }
+    const plusFiles = files.map((p) => {
+        p = toPosixPath(p);
+        assert(!p.startsWith(userRootDir));
+        const filePathRelativeToUserRootDir = path.posix.join('/', p);
+        const filePathAbsoluteFilesystem = path.posix.join(userRootDir, p);
+        return {
+            filePathRelativeToUserRootDir,
+            filePathAbsoluteFilesystem
+        };
+    });
+    return plusFiles;
+}
+// Same as fastGlob() but using `$ git ls-files`
+async function gitLsFiles(userRootDir, outDir) {
+    const cmd = [
+        'git ls-files',
+        ...scriptFileExtensionList.map((ext) => `"**/+*.${ext}"`),
+        ...getIgnorePatterns(outDir).map((pattern) => `--exclude="${pattern}"`),
+        // --others lists untracked files only (but using .gitignore because --exclude-standard)
+        // --cached adds the tracked files to the output
+        '--others --cached --exclude-standard'
+    ].join(' ');
+    let stdout;
+    try {
+        const res = await execA(cmd, { cwd: userRootDir });
+        stdout = res.stdout;
+    }
+    catch (err) {
+        if (err.message.includes('not a git repository'))
+            return null;
+        throw err;
+    }
+    let files = stdout.split('\n').filter(Boolean);
+    assert(!outDir.startsWith('/'));
+    files = files.filter(
+    // We have to repeat the same exclusion logic here because the `git ls-files` option --exclude only applies to untracked files. (We use --exclude only to speed up the command.)
+    (file) => getIgnoreFilter(file, outDir));
+    return files;
+}
+// Same as gitLsFiles() but using fast-glob
+async function fastGlob(userRootDir, outDir) {
+    const files = await glob(`**/+*.${scriptFileExtensions}`, {
+        ignore: getIgnorePatterns(outDir),
+        cwd: userRootDir,
+        dot: false
+    });
+    return files;
+}
+// Same as getIgnoreFilter() but as glob pattern
+function getIgnorePatterns(outDir) {
+    return [
+        '**/node_modules/**',
+        `${outDir}/**`,
+        // Allow:
+        // ```
+        // +Page.js
+        // +Page.telefunc.js
+        // ```
+        '**/*.telefunc.*'
+    ];
+}
+// Same as getIgnorePatterns() but for Array.filter()
+function getIgnoreFilter(file, outDir) {
+    return !file.includes('node_modules/') && !file.includes('.telefunc.') && !file.startsWith(`${outDir}/`);
+}