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

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

@@ -0,0 +1,134 @@
+export { importUserCode };
+import { normalizePath } from 'vite';
+import { getConfigVike } from '../../../shared/getConfigVike.js';
+import { getVirtualFilePageConfigValuesAll } from './v1-design/getVirtualFilePageConfigValuesAll.js';
+import { getVirtualFileImportUserCode } from './getVirtualFileImportUserCode.js';
+import { assert, assertPosixPath, getFilePathVite, getVirtualFileId, isDev1, isDev1_onConfigureServer, isVirtualFileId, resolveVirtualFileId } from '../../utils.js';
+import { isVirtualFileIdPageConfigValuesAll } from '../../../shared/virtual-files/virtualFilePageConfigValuesAll.js';
+import { isVirtualFileIdImportUserCode } from '../../../shared/virtual-files/virtualFileImportUserCode.js';
+import { vikeConfigDependencies, reloadVikeConfig, isVikeConfigFile } from './v1-design/getVikeConfig.js';
+import pc from '@brillout/picocolors';
+import { logConfigInfo, clearLogs } from '../../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 getConfigVike(config_);
+            config = config_;
+        },
+        resolveId(id) {
+            if (isVirtualFileId(id)) {
+                return 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 = isDev1();
+            if (!isVirtualFileId(id))
+                return undefined;
+            id = getVirtualFileId(id);
+            if (isVirtualFileIdPageConfigValuesAll(id)) {
+                const code = await getVirtualFilePageConfigValuesAll(id, config.root, isDev, configVike);
+                return code;
+            }
+            if (isVirtualFileIdImportUserCode(id)) {
+                const code = await getVirtualFileImportUserCode(id, options, configVike, config, isDev);
+                return code;
+            }
+        },
+        configureServer(server) {
+            isDev1_onConfigureServer();
+            handleFileAddRemove(server, config, configVike);
+        }
+    };
+}
+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 = normalizePath(file);
+        const isVikeConfig = isVikeConfigModule(file) || 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;
+    assertPosixPath(file);
+    vikeConfigDependencies.forEach((f) => 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) {
+        clearLogs({ clearErrors: true });
+        return;
+    }
+    if (isVikeConfig) {
+        assert(!isViteModule);
+        reloadConfig(file, config, configVike, 'modified');
+        const virtualModules = getVirtualModules(server);
+        return virtualModules;
+    }
+}
+function isVikeConfigModule(filePathAbsolute) {
+    return vikeConfigDependencies.has(filePathAbsolute);
+}
+function reloadConfig(filePath, config, configVike, op) {
+    {
+        const filePathToShowToUser = pc.dim(getFilePathVite(filePath, config.root, true));
+        const msg = `${op} ${filePathToShowToUser}`;
+        logConfigInfo(msg, 'info');
+    }
+    reloadVikeConfig(config.root, configVike.extensions);
+}
+function getVirtualModules(server) {
+    const virtualModules = Array.from(server.moduleGraph.urlToModuleMap.keys())
+        .filter((url) => isVirtualFileIdPageConfigValuesAll(url) || isVirtualFileIdImportUserCode(url))
+        .map((url) => {
+        const mod = server.moduleGraph.urlToModuleMap.get(url);
+        assert(mod);
+        return mod;
+    });
+    return virtualModules;
+}

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

@@ -0,0 +1,8 @@
+export declare const debug: ((...msgs: unknown[]) => void) & {
+    options: (options: {
+        serialization?: {
+            emptyArray?: string | undefined;
+        } | undefined;
+    }) => (...msgs: unknown[]) => void;
+    isEnabled: boolean;
+};

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

@@ -0,0 +1,2 @@
+import { createDebugger } from '../../../utils.js';
+export const debug = createDebugger('vike:virtual-files');

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

@@ -0,0 +1,7 @@
+export { getFilePathToShowToUser };
+export type { FilePath };
+type FilePath = {
+    filePathAbsolute: string;
+    filePathRelativeToUserRootDir: null | string;
+};
+declare function getFilePathToShowToUser(filePath: FilePath): string;

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

@@ -0,0 +1,7 @@
+export { getFilePathToShowToUser };
+import { assert } from '../../../utils.js';
+function getFilePathToShowToUser(filePath) {
+    const filePathToShowToUser = filePath.filePathRelativeToUserRootDir ?? filePath.filePathAbsolute;
+    assert(filePathToShowToUser);
+    return filePathToShowToUser;
+}

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

@@ -0,0 +1,53 @@
+export { configDefinitionsBuiltIn };
+export { configDefinitionsBuiltInGlobal };
+export type { ConfigDefinition };
+export type { ConfigDefinitionInternal };
+export type { ConfigNameGlobal };
+export type { ConfigEffect };
+import type { ConfigEnvInternal, ConfigEnv, PageConfigBuildTime } from '../../../../../../shared/page-configs/PageConfig.js';
+import type { Config, ConfigNameBuiltIn } from '../../../../../../shared/page-configs/Config.js';
+/** The meta definition of a config.
+ *
+ * https://vike.dev/meta
+ */
+type ConfigDefinition = {
+    /** In what environment(s) the config value is loaded.
+     *
+     * https://vike.dev/meta
+     */
+    env: ConfigEnv;
+    /** Disable config overriding and make config values cumulative instead.
+     *
+     * @default false
+     *
+     * https://vike.dev/meta
+     */
+    cumulative?: boolean;
+    /**
+     * Define a so-called "Shortcut Config".
+     *
+     * https://vike.dev/meta
+     */
+    effect?: ConfigEffect;
+};
+type ConfigEffect = (config: {
+    /** The resolved config value.
+     *
+     * https://vike.dev/meta
+     */
+    configValue: unknown;
+    /** Place where the resolved config value comes from.
+     *
+     * https://vike.dev/meta
+     */
+    configDefinedAt: `Config ${string}`;
+}) => Config | undefined;
+type ConfigDefinitionInternal = Omit<ConfigDefinition, 'env'> & {
+    _computed?: (pageConfig: PageConfigBuildTime) => unknown;
+    _valueIsFilePath?: true;
+    env: ConfigEnvInternal;
+};
+type ConfigDefinitionsBuiltIn = Record<ConfigNameBuiltIn, ConfigDefinitionInternal>;
+declare const configDefinitionsBuiltIn: ConfigDefinitionsBuiltIn;
+type ConfigNameGlobal = 'onPrerenderStart' | 'onBeforeRoute' | 'prerender' | 'extensions' | 'disableAutoFullBuild' | 'includeAssetsImportedByServer' | 'baseAssets' | 'baseServer' | 'redirects' | 'trailingSlash' | 'disableUrlNormalization';
+declare const configDefinitionsBuiltInGlobal: Record<ConfigNameGlobal, ConfigDefinitionInternal>;

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

@@ -0,0 +1,97 @@
+export { configDefinitionsBuiltIn };
+export { configDefinitionsBuiltInGlobal };
+import { getConfigEnv, isConfigSet } from '../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) => isConfigSet(pageConfig, 'onRenderClient') &&
+            isConfigSet(pageConfig, 'Page') &&
+            getConfigEnv(pageConfig, 'Page') !== 'server-only'
+    },
+    onBeforeRenderEnv: {
+        env: 'client-only',
+        _computed: (pageConfig) => !isConfigSet(pageConfig, 'onBeforeRender') ? null : getConfigEnv(pageConfig, 'onBeforeRender')
+    }
+};
+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' }
+};

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

@@ -0,0 +1,31 @@
+export { getFilesystemRouteString };
+export { getFilesystemRouteDefinedBy };
+export { isInherited };
+export { getLocationId };
+export { sortAfterInheritanceOrder };
+export { isGlobalLocation };
+export { applyFilesystemRoutingRootEffect };
+export { getLogicalPath };
+/**
+ * getLocationId('/pages/some-page/+Page.js') => '/pages/some-page'
+ * getLocationId('/pages/some-page') => '/pages/some-page'
+ * getLocationId('/renderer/+config.js') => '/renderer'
+ */
+declare function getLocationId(somePath: string): string;
+/** Get URL determined by filesystem path */
+declare function getFilesystemRouteString(locationId: string): string;
+/**
+ * getLogicalPath('/pages/some-page', ['pages']) => '/some-page'
+ * getLogicalPath('some-npm-pkg/renderer', ['renderer']) => '/'
+ */
+declare function getLogicalPath(someDir: string, removeDirs: string[]): string;
+/** Whether configs defined in `locationId` apply in every `locationIds` */
+declare function isGlobalLocation(locationId: string, locationIds: string[]): boolean;
+declare function sortAfterInheritanceOrder(locationId1: string, locationId2: string, locationIdPage: string): -1 | 1 | 0;
+/** Whether configs defined at `locationId1` also apply at `locationId2` */
+declare function isInherited(locationId1: string, locationId2: string): boolean;
+declare function getFilesystemRouteDefinedBy(locationId: string): string;
+declare function applyFilesystemRoutingRootEffect(routeFilesystem: string, filesystemRoutingRootEffect: {
+    before: string;
+    after: string;
+}): string;

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

@@ -0,0 +1,174 @@
+export { getFilesystemRouteString };
+export { getFilesystemRouteDefinedBy };
+export { isInherited };
+export { getLocationId };
+export { sortAfterInheritanceOrder };
+export { isGlobalLocation };
+export { applyFilesystemRoutingRootEffect };
+// For ./filesystemRouting.spec.ts
+export { getLogicalPath };
+import { assert, assertPosixPath, getNpmPackageImportPath, isNpmPackageImport, higherFirst } from '../../../../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;
+}
+/** Get URL determined by filesystem path */
+function getFilesystemRouteString(locationId) {
+    return getLogicalPath(locationId, ['renderer', 'pages', 'src', 'index']);
+}
+/** 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;
+}
+/** Whether configs defined in `locationId` apply in every `locationIds` */
+function isGlobalLocation(locationId, locationIds) {
+    return locationIds.every((locId) => isInherited(locationId, locId) || locationIsRendererDir(locId));
+}
+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
+    assert(isInherited(locationId1, locationIdPage));
+    assert(isInherited(locationId2, locationIdPage));
+    // Equivalent assertion (see isInherited() implementation)
+    assert(startsWith(inheritanceRootPage, inheritanceRoot1));
+    assert(startsWith(inheritanceRootPage, inheritanceRoot2));
+    if (inheritanceRoot1 !== inheritanceRoot2) {
+        // Should be true since locationId1 and locationId2 are both inherited by the same page
+        assert(startsWith(inheritanceRoot1, inheritanceRoot2) || startsWith(inheritanceRoot2, inheritanceRoot1));
+        assert(inheritanceRoot1.length !== inheritanceRoot2.length);
+        return higherFirst((inheritanceRoot) => inheritanceRoot.length)(inheritanceRoot1, inheritanceRoot2);
+    }
+    // Should be true since we aggregate interface files by locationId
+    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 higherFirst((locationId) => locationId.length)(locationId1, locationId2);
+    }
+    return locationId1 > locationId2 ? locationId1First : locationId2First;
+}
+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);
+}
+function removeNpmPackageName(somePath) {
+    if (!isNpmPackageImport(somePath)) {
+        assert(somePath.startsWith('/'));
+        return somePath;
+    }
+    const importPath = getNpmPackageImportPath(somePath);
+    if (!importPath)
+        return '/';
+    assertPosixPath(importPath);
+    assert(!importPath.startsWith('/'));
+    somePath = '/' + importPath;
+    return somePath;
+}
+function removeDirectories(somePath, removeDirs) {
+    assertPosixPath(somePath);
+    somePath = somePath
+        .split('/')
+        .filter((p) => !removeDirs.includes(p))
+        .join('/');
+    if (somePath === '')
+        somePath = '/';
+    return somePath;
+}
+function removeFilename(filePath, optional) {
+    assertPosixPath(filePath);
+    assert(filePath.startsWith('/') || isNpmPackageImport(filePath));
+    {
+        const filename = filePath.split('/').slice(-1)[0];
+        if (!filename.includes('.')) {
+            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;
+    assert(!locationId.endsWith('/'));
+    const routeFilesystemDefinedBy = locationId + '/';
+    return routeFilesystemDefinedBy;
+}
+function applyFilesystemRoutingRootEffect(routeFilesystem, filesystemRoutingRootEffect) {
+    const { before, after } = filesystemRoutingRootEffect;
+    assert(after.startsWith('/'));
+    assert(routeFilesystem.startsWith(before));
+    routeFilesystem = after + '/' + routeFilesystem.slice(before.length);
+    routeFilesystem = '/' + routeFilesystem.split('/').filter(Boolean).join('/');
+    return routeFilesystem;
+}
+function assertLocationId(locationId) {
+    assert(locationId.startsWith('/') || isNpmPackageImport(locationId));
+    assert(!locationId.endsWith('/') || locationId === '/');
+}
+function assertIsPath(logicalPath) {
+    assert(logicalPath.startsWith('/'));
+    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;
+        }
+    }
+    assert(inheritanceRoot1.startsWith(inheritanceRoot2));
+    return true;
+}

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

@@ -0,0 +1,15 @@
+export { getVikeConfig };
+export { reloadVikeConfig };
+export { vikeConfigDependencies };
+export { isVikeConfigFile };
+import type { PageConfigGlobalData, PageConfigBuildTime } from '../../../../../shared/page-configs/PageConfig.js';
+import type { ExtensionResolved } from '../../../../../shared/ConfigVike.js';
+type VikeConfig = {
+    pageConfigs: PageConfigBuildTime[];
+    pageConfigGlobal: PageConfigGlobalData;
+    globalVikeConfig: Record<string, unknown>;
+};
+declare const vikeConfigDependencies: Set<string>;
+declare function reloadVikeConfig(userRootDir: string, extensions: ExtensionResolved[]): void;
+declare function getVikeConfig(userRootDir: string, isDev: boolean, extensions: ExtensionResolved[], tolerateInvalidConfig?: boolean): Promise<VikeConfig>;
+declare function isVikeConfigFile(filePath: string): boolean;