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

package/dist/cjs/node/plugin/plugins/importUserCode/getVirtualFileImportUserCode.js

@@ -0,0 +1,242 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getVirtualFileImportUserCode = void 0;
+const utils_js_1 = require("../../utils.js");
+const virtualFileImportUserCode_js_1 = require("../../../shared/virtual-files/virtualFileImportUserCode.js");
+const fileTypes_js_1 = require("../../../../shared/getPageFiles/fileTypes.js");
+const path_1 = __importDefault(require("path"));
+const getVirtualFilePageConfigs_js_1 = require("./v1-design/getVirtualFilePageConfigs.js");
+const generateEagerImport_js_1 = require("./generateEagerImport.js");
+async function getVirtualFileImportUserCode(id, options, configVike, config, isDev) {
+    const idParsed = (0, virtualFileImportUserCode_js_1.isVirtualFileIdImportUserCode)(id);
+    (0, utils_js_1.assert)(idParsed);
+    const { isForClientSide, isClientRouting } = idParsed;
+    (0, utils_js_1.assert)(isForClientSide === !(0, utils_js_1.viteIsSSR_options)(options));
+    const isPrerendering = !!configVike.prerender;
+    const code = await getCode(config, configVike, isForClientSide, isClientRouting, isPrerendering, isDev, id);
+    return code;
+}
+exports.getVirtualFileImportUserCode = getVirtualFileImportUserCode;
+async function getCode(config, configVike, isForClientSide, isClientRouting, isPrerendering, isDev, id) {
+    const { command } = config;
+    (0, utils_js_1.assert)(command === 'serve' || command === 'build');
+    const isBuild = command === 'build';
+    (0, utils_js_1.assert)(isDev === !isBuild);
+    let content = '';
+    {
+        const globRoots = getGlobRoots(config, configVike);
+        (0, utils_js_1.debugGlob)('Glob roots: ', globRoots);
+        content += await generateGlobImports(globRoots, isBuild, isForClientSide, isClientRouting, configVike, isPrerendering, config, isDev, id);
+    }
+    {
+        const extensionsImportPaths = configVike.extensions
+            .map(({ pageConfigsDistFiles }) => pageConfigsDistFiles)
+            .flat()
+            .filter(utils_js_1.isNotNullish)
+            .map(({ importPath }) => importPath);
+        content += generateExtensionImports(extensionsImportPaths, isForClientSide, isBuild, isClientRouting, isPrerendering);
+    }
+    (0, utils_js_1.debugGlob)(`Glob imports for ${isForClientSide ? 'client' : 'server'}:\n`, content);
+    return content;
+}
+function generateExtensionImports(extensionsImportPaths, isForClientSide, isBuild, isClientRouting, isPrerendering) {
+    let fileContent = '\n\n';
+    extensionsImportPaths
+        .filter((importPath) => {
+        (0, utils_js_1.assert)(
+        // V1 design
+        importPath.includes('+') ||
+            // V0.4 design
+            importPath.includes('.page.'));
+        return !importPath.includes('+');
+    })
+        .forEach((importPath) => {
+        const fileType = (0, fileTypes_js_1.determineFileType)(importPath);
+        const { includeImport, includeExportNames } = determineInjection({
+            fileType,
+            isForClientSide,
+            isClientRouting,
+            isPrerendering,
+            isBuild
+        });
+        if (includeImport) {
+            fileContent += addImport(importPath, fileType, false, isBuild);
+        }
+        if (includeExportNames) {
+            fileContent += addImport(importPath, fileType, true, isBuild);
+        }
+        if (!includeImport && !includeExportNames && !isForClientSide) {
+            fileContent += `pageFilesList.push("${importPath}");` + '\n';
+        }
+    });
+    return fileContent;
+}
+function determineInjection({ fileType, isForClientSide, isClientRouting, isPrerendering, isBuild }) {
+    if (!isForClientSide) {
+        return {
+            includeImport: fileType === '.page.server' || fileType === '.page' || fileType === '.page.route',
+            includeExportNames: isPrerendering && isBuild
+                ? fileType === '.page.client' || fileType === '.page.server' || fileType === '.page' // We extensively use `PageFile['exportNames']` while pre-rendering, in order to avoid loading page files unnecessarily, and therefore reducing memory usage.
+                : fileType === '.page.client'
+        };
+    }
+    else {
+        const includeImport = fileType === '.page.client' || fileType === '.css' || fileType === '.page';
+        if (!isClientRouting) {
+            return {
+                includeImport,
+                includeExportNames: false
+            };
+        }
+        else {
+            return {
+                includeImport: includeImport || fileType === '.page.route',
+                includeExportNames: fileType === '.page.client' || fileType === '.page.server' || fileType === '.page'
+            };
+        }
+    }
+}
+function addImport(importPath, fileType, exportNames, isBuild) {
+    const pageFilesVar = (() => {
+        if (exportNames) {
+            if (isBuild) {
+                return 'pageFilesExportNamesEager';
+            }
+            else {
+                return 'pageFilesExportNamesLazy';
+            }
+        }
+        else {
+            if (fileType === '.page.route') {
+                return 'pageFilesEager';
+            }
+            else {
+                return 'pageFilesLazy';
+            }
+        }
+    })();
+    const query = !exportNames ? '' : '?extractExportNames';
+    let fileContent = '';
+    const mapVar = `${pageFilesVar}['${fileType}']`;
+    fileContent += `${mapVar} = ${mapVar} ?? {};\n`;
+    const value = (() => {
+        if (!pageFilesVar.endsWith('Eager')) {
+            return `() => import('${importPath}${query}')`;
+        }
+        else {
+            const { importVar, importStatement } = (0, generateEagerImport_js_1.generateEagerImport)(`${importPath}${query}`);
+            fileContent += importStatement + '\n';
+            return importVar;
+        }
+    })();
+    fileContent += `${mapVar}['${importPath}'] = ${value};\n`;
+    return fileContent;
+}
+async function generateGlobImports(globRoots, isBuild, isForClientSide, isClientRouting, configVike, isPrerendering, config, isDev, id) {
+    let fileContent = `// Generatead by node/plugin/plugins/virtualFiles/index.ts
+
+export const pageFilesLazy = {};
+export const pageFilesEager = {};
+export const pageFilesExportNamesLazy = {};
+export const pageFilesExportNamesEager = {};
+export const pageFilesList = [];
+export const neverLoaded = {};
+export const isGeneratedFile = true;
+
+${await (0, getVirtualFilePageConfigs_js_1.getVirtualFilePageConfigs)(config.root, isForClientSide, isDev, id, configVike, isClientRouting)}
+
+`;
+    fileTypes_js_1.fileTypes
+        .filter((fileType) => fileType !== '.css')
+        .forEach((fileType) => {
+        (0, utils_js_1.assert)(fileType !== '.css');
+        const { includeImport, includeExportNames } = determineInjection({
+            fileType,
+            isForClientSide,
+            isClientRouting,
+            isPrerendering,
+            isBuild
+        });
+        if (includeImport) {
+            fileContent += getGlobs(globRoots, isBuild, fileType);
+        }
+        if (includeExportNames) {
+            fileContent += getGlobs(globRoots, isBuild, fileType, 'extractExportNames');
+        }
+    });
+    if (configVike.includeAssetsImportedByServer && isForClientSide) {
+        fileContent += getGlobs(globRoots, isBuild, '.page.server', 'extractAssets');
+    }
+    return fileContent;
+}
+function getGlobs(globRoots, isBuild, fileType, query) {
+    const isEager = isBuild && (query === 'extractExportNames' || fileType === '.page.route');
+    let pageFilesVar;
+    if (query === 'extractExportNames') {
+        if (!isEager) {
+            pageFilesVar = 'pageFilesExportNamesLazy';
+        }
+        else {
+            pageFilesVar = 'pageFilesExportNamesEager';
+        }
+    }
+    else if (query === 'extractAssets') {
+        (0, utils_js_1.assert)(!isEager);
+        pageFilesVar = 'neverLoaded';
+    }
+    else if (!query) {
+        if (!isEager) {
+            pageFilesVar = 'pageFilesLazy';
+        }
+        else {
+            // Used for `.page.route.js` files
+            pageFilesVar = 'pageFilesEager';
+        }
+    }
+    else {
+        (0, utils_js_1.assert)(false);
+    }
+    const varNameSuffix = (fileType === '.page' && 'Isomorph') ||
+        (fileType === '.page.client' && 'Client') ||
+        (fileType === '.page.server' && 'Server') ||
+        (fileType === '.page.route' && 'Route');
+    (0, utils_js_1.assert)(varNameSuffix);
+    const varName = `${pageFilesVar}${varNameSuffix}`;
+    const varNameLocals = [];
+    return [
+        ...globRoots.map((globRoot, i) => {
+            const varNameLocal = `${varName}${i + 1}`;
+            varNameLocals.push(varNameLocal);
+            const globPath = `'${getGlobPath(globRoot, fileType)}'`;
+            const globOptions = JSON.stringify({ eager: isEager, as: query });
+            (0, utils_js_1.assert)(globOptions.startsWith('{"eager":true') || globOptions.startsWith('{"eager":false'));
+            const globLine = `const ${varNameLocal} = import.meta.glob(${globPath}, ${globOptions});`;
+            return globLine;
+        }),
+        `const ${varName} = {${varNameLocals.map((varNameLocal) => `...${varNameLocal}`).join(',')}};`,
+        `${pageFilesVar}['${fileType}'] = ${varName};`,
+        ''
+    ].join('\n');
+}
+function getGlobRoots(config, configVike) {
+    const globRoots = ['/'];
+    configVike.extensions
+        .map(({ pageConfigsSrcDir }) => pageConfigsSrcDir)
+        .filter(utils_js_1.isNotNullish)
+        .forEach((pageConfigsSrcDir) => {
+        const globRoot = path_1.default.posix.relative(config.root, pageConfigsSrcDir);
+        globRoots.push(globRoot);
+    });
+    return globRoots;
+}
+function getGlobPath(globRoot, fileType) {
+    (0, utils_js_1.assertPosixPath)(globRoot);
+    let globPath = [...globRoot.split('/'), '**', `*${fileType}.${utils_js_1.scriptFileExtensions}`].filter(Boolean).join('/');
+    if (!globPath.startsWith('/')) {
+        globPath = '/' + globPath;
+    }
+    return globPath;
+}

package/dist/cjs/node/plugin/plugins/importUserCode/index.js

@@ -0,0 +1,140 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.importUserCode = void 0;
+const vite_1 = require("vite");
+const getConfigVike_js_1 = require("../../../shared/getConfigVike.js");
+const getVirtualFilePageConfigValuesAll_js_1 = require("./v1-design/getVirtualFilePageConfigValuesAll.js");
+const getVirtualFileImportUserCode_js_1 = require("./getVirtualFileImportUserCode.js");
+const utils_js_1 = require("../../utils.js");
+const virtualFilePageConfigValuesAll_js_1 = require("../../../shared/virtual-files/virtualFilePageConfigValuesAll.js");
+const virtualFileImportUserCode_js_1 = require("../../../shared/virtual-files/virtualFileImportUserCode.js");
+const getVikeConfig_js_1 = require("./v1-design/getVikeConfig.js");
+const picocolors_1 = __importDefault(require("@brillout/picocolors"));
+const loggerNotProd_js_1 = require("../../shared/loggerNotProd.js");
+function importUserCode() {
+    let config;
+    let configVike;
+    return {
+        name: 'vike:importUserCode',
+        config() {
+            return {
+                experimental: {
+                    // TODO/v1-release: remove
+                    importGlobRestoreExtension: true
+                }
+            };
+        },
+        async configResolved(config_) {
+            configVike = await (0, getConfigVike_js_1.getConfigVike)(config_);
+            config = config_;
+        },
+        resolveId(id) {
+            if ((0, utils_js_1.isVirtualFileId)(id)) {
+                return (0, utils_js_1.resolveVirtualFileId)(id);
+            }
+        },
+        handleHotUpdate(ctx) {
+            try {
+                return handleHotUpdate(ctx, config, configVike);
+            }
+            catch (err) {
+                // Vite swallows errors thrown by handleHotUpdate()
+                console.error(err);
+                throw err;
+            }
+        },
+        async load(id, options) {
+            const isDev = (0, utils_js_1.isDev1)();
+            if (!(0, utils_js_1.isVirtualFileId)(id))
+                return undefined;
+            id = (0, utils_js_1.getVirtualFileId)(id);
+            if ((0, virtualFilePageConfigValuesAll_js_1.isVirtualFileIdPageConfigValuesAll)(id)) {
+                const code = await (0, getVirtualFilePageConfigValuesAll_js_1.getVirtualFilePageConfigValuesAll)(id, config.root, isDev, configVike);
+                return code;
+            }
+            if ((0, virtualFileImportUserCode_js_1.isVirtualFileIdImportUserCode)(id)) {
+                const code = await (0, getVirtualFileImportUserCode_js_1.getVirtualFileImportUserCode)(id, options, configVike, config, isDev);
+                return code;
+            }
+        },
+        configureServer(server) {
+            (0, utils_js_1.isDev1_onConfigureServer)();
+            handleFileAddRemove(server, config, configVike);
+        }
+    };
+}
+exports.importUserCode = importUserCode;
+function handleFileAddRemove(server, config, configVike) {
+    server.watcher.prependListener('add', (f) => listener(f, false));
+    server.watcher.prependListener('unlink', (f) => listener(f, true));
+    return;
+    function listener(file, isRemove) {
+        file = (0, vite_1.normalizePath)(file);
+        const isVikeConfig = isVikeConfigModule(file) || (0, getVikeConfig_js_1.isVikeConfigFile)(file);
+        if (isVikeConfig) {
+            const virtualModules = getVirtualModules(server);
+            virtualModules.forEach((mod) => {
+                server.moduleGraph.invalidateModule(mod);
+            });
+            reloadConfig(file, config, configVike, isRemove ? 'removed' : 'created');
+        }
+    }
+}
+function handleHotUpdate(ctx, config, configVike) {
+    const { file, server } = ctx;
+    (0, utils_js_1.assertPosixPath)(file);
+    getVikeConfig_js_1.vikeConfigDependencies.forEach((f) => (0, utils_js_1.assertPosixPath)(f));
+    const isVikeConfig = isVikeConfigModule(file);
+    const isViteModule = ctx.modules.length > 0;
+    /* Should we show this?
+    // - Can be useful for server files that aren't processed by Vite.
+    // - Can be annoying for files that obviously aren't processed by Vite.
+    if (!isVikeConfig && !isViteModule) {
+      logViteAny(
+        `${msg} — ${pc.cyan('no HMR')}, see https://vike.dev/on-demand-compiler`,
+        'info',
+        null,
+        true,
+        clear,
+        config
+      )
+      return
+    }
+    //*/
+    // HMR can resolve errors => we clear previously shown errors.
+    // It can hide an error it shouldn't hide (because the error isn't shown again), but it's ok since users can reload the page and the error will be shown again (Vite transpilation errors are shown again upon a page reload).
+    if (!isVikeConfig && isViteModule) {
+        (0, loggerNotProd_js_1.clearLogs)({ clearErrors: true });
+        return;
+    }
+    if (isVikeConfig) {
+        (0, utils_js_1.assert)(!isViteModule);
+        reloadConfig(file, config, configVike, 'modified');
+        const virtualModules = getVirtualModules(server);
+        return virtualModules;
+    }
+}
+function isVikeConfigModule(filePathAbsolute) {
+    return getVikeConfig_js_1.vikeConfigDependencies.has(filePathAbsolute);
+}
+function reloadConfig(filePath, config, configVike, op) {
+    {
+        const filePathToShowToUser = picocolors_1.default.dim((0, utils_js_1.getFilePathVite)(filePath, config.root, true));
+        const msg = `${op} ${filePathToShowToUser}`;
+        (0, loggerNotProd_js_1.logConfigInfo)(msg, 'info');
+    }
+    (0, getVikeConfig_js_1.reloadVikeConfig)(config.root, configVike.extensions);
+}
+function getVirtualModules(server) {
+    const virtualModules = Array.from(server.moduleGraph.urlToModuleMap.keys())
+        .filter((url) => (0, virtualFilePageConfigValuesAll_js_1.isVirtualFileIdPageConfigValuesAll)(url) || (0, virtualFileImportUserCode_js_1.isVirtualFileIdImportUserCode)(url))
+        .map((url) => {
+        const mod = server.moduleGraph.urlToModuleMap.get(url);
+        (0, utils_js_1.assert)(mod);
+        return mod;
+    });
+    return virtualModules;
+}

package/dist/cjs/node/plugin/plugins/importUserCode/v1-design/debug.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.debug = void 0;
+const utils_js_1 = require("../../../utils.js");
+exports.debug = (0, utils_js_1.createDebugger)('vike:virtual-files');

package/dist/cjs/node/plugin/plugins/importUserCode/v1-design/getFilePathToShowToUser.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getFilePathToShowToUser = void 0;
+const utils_js_1 = require("../../../utils.js");
+function getFilePathToShowToUser(filePath) {
+    const filePathToShowToUser = filePath.filePathRelativeToUserRootDir ?? filePath.filePathAbsolute;
+    (0, utils_js_1.assert)(filePathToShowToUser);
+    return filePathToShowToUser;
+}
+exports.getFilePathToShowToUser = getFilePathToShowToUser;

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

@@ -0,0 +1,100 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.configDefinitionsBuiltInGlobal = exports.configDefinitionsBuiltIn = void 0;
+const helpers_js_1 = require("../helpers.js");
+const configDefinitionsBuiltIn = {
+    onRenderHtml: {
+        env: 'server-only'
+    },
+    onRenderClient: {
+        env: 'client-only'
+    },
+    onHydrationEnd: {
+        env: 'client-only'
+    },
+    onPageTransitionStart: {
+        env: 'client-only'
+    },
+    onPageTransitionEnd: {
+        env: 'client-only'
+    },
+    onBeforeRender: {
+        env: 'server-only'
+    },
+    onBeforePrerenderStart: {
+        env: 'server-only'
+    },
+    Page: {
+        env: 'server-and-client'
+    },
+    passToClient: {
+        env: 'server-only',
+        cumulative: true
+    },
+    route: {
+        env: '_routing-eager'
+    },
+    guard: {
+        env: '_routing-lazy'
+    },
+    iKnowThePerformanceRisksOfAsyncRouteFunctions: {
+        env: '_routing-eager'
+    },
+    filesystemRoutingRoot: {
+        env: 'config-only'
+    },
+    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',
+        _valueIsFilePath: true
+    },
+    clientRouting: {
+        env: 'server-and-client' // TODO: config-only instead?
+    },
+    prerender: {
+        env: 'server-only'
+    },
+    hydrationCanBeAborted: {
+        env: 'client-only' // TODO: config-only instead?
+    },
+    prefetchStaticAssets: {
+        env: 'client-only' // TODO: config-only instead?
+    },
+    extends: {
+        env: 'config-only'
+    },
+    meta: {
+        env: 'config-only'
+    },
+    isClientSideRenderable: {
+        env: 'server-and-client',
+        _computed: (pageConfig) => (0, helpers_js_1.isConfigSet)(pageConfig, 'onRenderClient') &&
+            (0, helpers_js_1.isConfigSet)(pageConfig, 'Page') &&
+            (0, helpers_js_1.getConfigEnv)(pageConfig, 'Page') !== 'server-only'
+    },
+    onBeforeRenderEnv: {
+        env: 'client-only',
+        _computed: (pageConfig) => !(0, helpers_js_1.isConfigSet)(pageConfig, 'onBeforeRender') ? null : (0, helpers_js_1.getConfigEnv)(pageConfig, 'onBeforeRender')
+    }
+};
+exports.configDefinitionsBuiltIn = configDefinitionsBuiltIn;
+const configDefinitionsBuiltInGlobal = {
+    onPrerenderStart: {
+        env: 'server-only'
+    },
+    onBeforeRoute: {
+        env: '_routing-eager'
+    },
+    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' }
+};
+exports.configDefinitionsBuiltInGlobal = configDefinitionsBuiltInGlobal;

package/dist/cjs/node/plugin/plugins/importUserCode/v1-design/getVikeConfig/filesystemRouting.js

@@ -0,0 +1,176 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getLogicalPath = exports.applyFilesystemRoutingRootEffect = exports.isGlobalLocation = exports.sortAfterInheritanceOrder = exports.getLocationId = exports.isInherited = exports.getFilesystemRouteDefinedBy = exports.getFilesystemRouteString = void 0;
+const utils_js_1 = require("../../../../utils.js");
+/**
+ * getLocationId('/pages/some-page/+Page.js') => '/pages/some-page'
+ * getLocationId('/pages/some-page') => '/pages/some-page'
+ * getLocationId('/renderer/+config.js') => '/renderer'
+ */
+function getLocationId(somePath) {
+    const locationId = removeFilename(somePath, true);
+    assertLocationId(locationId);
+    return locationId;
+}
+exports.getLocationId = getLocationId;
+/** Get URL determined by filesystem path */
+function getFilesystemRouteString(locationId) {
+    return getLogicalPath(locationId, ['renderer', 'pages', 'src', 'index']);
+}
+exports.getFilesystemRouteString = getFilesystemRouteString;
+/** Get apply root for config inheritance */
+function getInheritanceRoot(someDir) {
+    return getLogicalPath(someDir, ['renderer']);
+}
+/**
+ * getLogicalPath('/pages/some-page', ['pages']) => '/some-page'
+ * getLogicalPath('some-npm-pkg/renderer', ['renderer']) => '/'
+ */
+function getLogicalPath(someDir, removeDirs) {
+    someDir = removeNpmPackageName(someDir);
+    someDir = removeDirectories(someDir, removeDirs);
+    assertIsPath(someDir);
+    return someDir;
+}
+exports.getLogicalPath = getLogicalPath;
+/** Whether configs defined in `locationId` apply in every `locationIds` */
+function isGlobalLocation(locationId, locationIds) {
+    return locationIds.every((locId) => isInherited(locationId, locId) || locationIsRendererDir(locId));
+}
+exports.isGlobalLocation = isGlobalLocation;
+function sortAfterInheritanceOrder(locationId1, locationId2, locationIdPage) {
+    const inheritanceRoot1 = getInheritanceRoot(locationId1);
+    const inheritanceRoot2 = getInheritanceRoot(locationId2);
+    const inheritanceRootPage = getInheritanceRoot(locationIdPage);
+    // sortAfterInheritanceOrder() only works if both locationId1 and locationId2 are inherited by the same page
+    (0, utils_js_1.assert)(isInherited(locationId1, locationIdPage));
+    (0, utils_js_1.assert)(isInherited(locationId2, locationIdPage));
+    // Equivalent assertion (see isInherited() implementation)
+    (0, utils_js_1.assert)(startsWith(inheritanceRootPage, inheritanceRoot1));
+    (0, utils_js_1.assert)(startsWith(inheritanceRootPage, inheritanceRoot2));
+    if (inheritanceRoot1 !== inheritanceRoot2) {
+        // Should be true since locationId1 and locationId2 are both inherited by the same page
+        (0, utils_js_1.assert)(startsWith(inheritanceRoot1, inheritanceRoot2) || startsWith(inheritanceRoot2, inheritanceRoot1));
+        (0, utils_js_1.assert)(inheritanceRoot1.length !== inheritanceRoot2.length);
+        return (0, utils_js_1.higherFirst)((inheritanceRoot) => inheritanceRoot.length)(inheritanceRoot1, inheritanceRoot2);
+    }
+    // Should be true since we aggregate interface files by locationId
+    (0, utils_js_1.assert)(locationId1 !== locationId2);
+    // locationId1 first, i.e. `indexOf(locationId1) < indexOf(locationId2)`
+    const locationId1First = -1;
+    // locationId2 first, i.e. `indexOf(locationId2) < indexOf(locationId1)`
+    const locationId2First = 1;
+    if (locationIsNpmPackage(locationId1) !== locationIsNpmPackage(locationId2)) {
+        return locationIsNpmPackage(locationId1) ? locationId2First : locationId1First;
+    }
+    if (locationIsRendererDir(locationId1) !== locationIsRendererDir(locationId2)) {
+        return locationIsRendererDir(locationId1) ? locationId2First : locationId1First;
+    }
+    // Doesn't have any function beyond making the order deterministic
+    //  - Although we make /src/renderer/+config.js override /renderer/+config.js which potentially can make somewhat sense (e.g. when ejecting a renderer)
+    if (locationId1.length !== locationId2.length) {
+        return (0, utils_js_1.higherFirst)((locationId) => locationId.length)(locationId1, locationId2);
+    }
+    return locationId1 > locationId2 ? locationId1First : locationId2First;
+}
+exports.sortAfterInheritanceOrder = sortAfterInheritanceOrder;
+function locationIsNpmPackage(locationId) {
+    return !locationId.startsWith('/');
+}
+function locationIsRendererDir(locationId) {
+    return locationId.split('/').includes('renderer');
+}
+/** Whether configs defined at `locationId1` also apply at `locationId2` */
+function isInherited(locationId1, locationId2) {
+    const inheritanceRoot1 = getInheritanceRoot(locationId1);
+    const inheritanceRoot2 = getInheritanceRoot(locationId2);
+    return startsWith(inheritanceRoot2, inheritanceRoot1);
+}
+exports.isInherited = isInherited;
+function removeNpmPackageName(somePath) {
+    if (!(0, utils_js_1.isNpmPackageImport)(somePath)) {
+        (0, utils_js_1.assert)(somePath.startsWith('/'));
+        return somePath;
+    }
+    const importPath = (0, utils_js_1.getNpmPackageImportPath)(somePath);
+    if (!importPath)
+        return '/';
+    (0, utils_js_1.assertPosixPath)(importPath);
+    (0, utils_js_1.assert)(!importPath.startsWith('/'));
+    somePath = '/' + importPath;
+    return somePath;
+}
+function removeDirectories(somePath, removeDirs) {
+    (0, utils_js_1.assertPosixPath)(somePath);
+    somePath = somePath
+        .split('/')
+        .filter((p) => !removeDirs.includes(p))
+        .join('/');
+    if (somePath === '')
+        somePath = '/';
+    return somePath;
+}
+function removeFilename(filePath, optional) {
+    (0, utils_js_1.assertPosixPath)(filePath);
+    (0, utils_js_1.assert)(filePath.startsWith('/') || (0, utils_js_1.isNpmPackageImport)(filePath));
+    {
+        const filename = filePath.split('/').slice(-1)[0];
+        if (!filename.includes('.')) {
+            (0, utils_js_1.assert)(optional);
+            return filePath;
+        }
+    }
+    filePath = filePath.split('/').slice(0, -1).join('/');
+    if (filePath === '')
+        filePath = '/';
+    assertLocationId(filePath);
+    return filePath;
+}
+function getFilesystemRouteDefinedBy(locationId) {
+    if (locationId === '/')
+        return locationId;
+    (0, utils_js_1.assert)(!locationId.endsWith('/'));
+    const routeFilesystemDefinedBy = locationId + '/';
+    return routeFilesystemDefinedBy;
+}
+exports.getFilesystemRouteDefinedBy = getFilesystemRouteDefinedBy;
+function applyFilesystemRoutingRootEffect(routeFilesystem, filesystemRoutingRootEffect) {
+    const { before, after } = filesystemRoutingRootEffect;
+    (0, utils_js_1.assert)(after.startsWith('/'));
+    (0, utils_js_1.assert)(routeFilesystem.startsWith(before));
+    routeFilesystem = after + '/' + routeFilesystem.slice(before.length);
+    routeFilesystem = '/' + routeFilesystem.split('/').filter(Boolean).join('/');
+    return routeFilesystem;
+}
+exports.applyFilesystemRoutingRootEffect = applyFilesystemRoutingRootEffect;
+function assertLocationId(locationId) {
+    (0, utils_js_1.assert)(locationId.startsWith('/') || (0, utils_js_1.isNpmPackageImport)(locationId));
+    (0, utils_js_1.assert)(!locationId.endsWith('/') || locationId === '/');
+}
+function assertIsPath(logicalPath) {
+    (0, utils_js_1.assert)(logicalPath.startsWith('/'));
+    (0, utils_js_1.assert)(!logicalPath.endsWith('/') || logicalPath === '/');
+}
+/** Whether `inheritanceRoot1` starts with `inheritanceRoot2` */
+function startsWith(inheritanceRoot1, inheritanceRoot2) {
+    assertIsPath(inheritanceRoot1);
+    assertIsPath(inheritanceRoot2);
+    const segments1 = inheritanceRoot1.split('/').filter(Boolean);
+    const segments2 = inheritanceRoot2.split('/').filter(Boolean);
+    for (const i in segments2) {
+        const segment1 = segments1[i];
+        const segment2 = segments2[i];
+        if (segment1 !== segment2) {
+            /* This assertion fails for:
+               ```
+               inheritanceRoot1: '/pages/about2'
+               inheritanceRoot2: '/pages/about'
+               ```
+            assert(!inheritanceRoot1.startsWith(inheritanceRoot2))
+            */
+            return false;
+        }
+    }
+    (0, utils_js_1.assert)(inheritanceRoot1.startsWith(inheritanceRoot2));
+    return true;
+}