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

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

@@ -0,0 +1,15 @@
+export * from '../../utils/assert.js';
+export * from '../../utils/getFileExtension.js';
+export * from '../../utils/isPlainObject.js';
+export * from '../../utils/projectInfo.js';
+export * from '../../utils/checkType.js';
+export * from '../../utils/hasProp.js';
+export * from '../../utils/isStringRecord.js';
+export * from '../../utils/objectAssign.js';
+export * from '../../utils/checkType.js';
+export * from '../../utils/hasProp.js';
+export * from '../../utils/parseUrl.js';
+export * from '../../utils/parseUrl-extras.js';
+export * from '../../utils/isObject.js';
+export * from '../../utils/virtual-files.js';
+export * from '../../utils/assertIsNotBrowser.js';

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

@@ -0,0 +1,17 @@
+import { assertIsNotBrowser } from '../../utils/assertIsNotBrowser.js';
+assertIsNotBrowser();
+export * from '../../utils/assert.js';
+export * from '../../utils/getFileExtension.js';
+export * from '../../utils/isPlainObject.js';
+export * from '../../utils/projectInfo.js';
+export * from '../../utils/checkType.js';
+export * from '../../utils/hasProp.js';
+export * from '../../utils/isStringRecord.js';
+export * from '../../utils/objectAssign.js';
+export * from '../../utils/checkType.js';
+export * from '../../utils/hasProp.js';
+export * from '../../utils/parseUrl.js';
+export * from '../../utils/parseUrl-extras.js';
+export * from '../../utils/isObject.js';
+export * from '../../utils/virtual-files.js';
+export * from '../../utils/assertIsNotBrowser.js';

package/dist/esm/node/shared/virtual-files/virtualFileImportUserCode.d.ts

@@ -0,0 +1,11 @@
+export { virtualFileIdImportUserCodeServer };
+export { virtualFileIdImportUserCodeClientSR };
+export { virtualFileIdImportUserCodeClientCR };
+export { isVirtualFileIdImportUserCode };
+declare const virtualFileIdImportUserCodeServer = "virtual:vike:importUserCode:server";
+declare const virtualFileIdImportUserCodeClientSR = "virtual:vike:importUserCode:client:server-routing";
+declare const virtualFileIdImportUserCodeClientCR = "virtual:vike:importUserCode:client:client-routing";
+declare function isVirtualFileIdImportUserCode(id: string): false | {
+    isForClientSide: boolean;
+    isClientRouting: boolean;
+};

package/dist/esm/node/shared/virtual-files/virtualFileImportUserCode.js

@@ -0,0 +1,24 @@
+export { virtualFileIdImportUserCodeServer };
+export { virtualFileIdImportUserCodeClientSR };
+export { virtualFileIdImportUserCodeClientCR };
+export { isVirtualFileIdImportUserCode };
+import { assert, getVirtualFileId } from '../utils.js';
+const idBase = 'virtual:vike:importUserCode';
+const virtualFileIdImportUserCodeServer = `${idBase}:server`;
+const virtualFileIdImportUserCodeClientSR = `${idBase}:client:server-routing`;
+const virtualFileIdImportUserCodeClientCR = `${idBase}:client:client-routing`;
+function isVirtualFileIdImportUserCode(id) {
+    id = getVirtualFileId(id);
+    if (!id.startsWith(idBase))
+        return false;
+    assert(
+    // prettier-ignore
+    [
+        virtualFileIdImportUserCodeServer,
+        virtualFileIdImportUserCodeClientCR,
+        virtualFileIdImportUserCodeClientSR
+    ].includes(id));
+    const isForClientSide = id !== virtualFileIdImportUserCodeServer;
+    const isClientRouting = id === virtualFileIdImportUserCodeClientCR;
+    return { isForClientSide, isClientRouting };
+}

package/dist/esm/node/shared/virtual-files/virtualFilePageConfigValuesAll.d.ts

@@ -0,0 +1,9 @@
+export { isVirtualFileIdPageConfigValuesAll };
+export { getVirtualFileIdPageConfigValuesAll };
+declare const idBase = "virtual:vike:pageConfigValuesAll:";
+declare function getVirtualFileIdPageConfigValuesAll(pageId: string, isForClientSide: boolean): `${typeof idBase}${string}`;
+declare function isVirtualFileIdPageConfigValuesAll(id: string): false | {
+    isForClientSide: boolean;
+    pageId: string;
+    isExtractAssets: boolean;
+};

package/dist/esm/node/shared/virtual-files/virtualFilePageConfigValuesAll.js

@@ -0,0 +1,36 @@
+export { isVirtualFileIdPageConfigValuesAll };
+export { getVirtualFileIdPageConfigValuesAll };
+import { extractAssetsRemoveQuery } from '../extractAssetsQuery.js';
+import { assert, getVirtualFileId } from '../utils.js';
+const idBase = 'virtual:vike:pageConfigValuesAll:';
+const idBaseClient = `${idBase}client:`;
+const idBaseServer = `${idBase}server:`;
+function getVirtualFileIdPageConfigValuesAll(pageId, isForClientSide) {
+    const id = `${(isForClientSide ? idBaseClient : idBaseServer)}${pageId}`;
+    return id;
+}
+function isVirtualFileIdPageConfigValuesAll(id) {
+    id = getVirtualFileId(id);
+    if (!id.includes(idBase))
+        return false;
+    assert(id.startsWith(idBase));
+    const idOriginal = id;
+    id = extractAssetsRemoveQuery(id);
+    const isExtractAssets = idOriginal !== id;
+    if (id.startsWith(idBaseClient)) {
+        assert(isExtractAssets === false);
+        return {
+            pageId: id.slice(idBaseClient.length),
+            isForClientSide: true,
+            isExtractAssets
+        };
+    }
+    if (id.startsWith(idBaseServer)) {
+        return {
+            pageId: id.slice(idBaseServer.length),
+            isForClientSide: false,
+            isExtractAssets
+        };
+    }
+    assert(false);
+}

package/dist/esm/shared/ConfigVike.d.ts

@@ -0,0 +1,128 @@
+export type { ConfigVikeUserProvided };
+export type { ConfigVikeResolved };
+export type { ExtensionResolved };
+type ExtensionUserProvided = {
+    npmPackageName: string;
+    pageConfigsDistFiles?: string[];
+    pageConfigsSrcDir?: string;
+    assetsDir?: string;
+    /** @deprecated */
+    pageFilesDist?: string[];
+    /** @deprecated */
+    pageFilesSrc?: string;
+};
+type ExtensionResolved = {
+    npmPackageName: string;
+    npmPackageRootDir: string;
+    pageConfigsDistFiles: null | {
+        importPath: string;
+        filePath: string;
+    }[];
+    pageConfigsSrcDir: null | string;
+    assetsDir: null | string;
+};
+type ConfigVikeResolved = {
+    prerender: false | {
+        noExtraDir: boolean;
+        parallel: boolean | number;
+        partial: boolean;
+        disableAutoRun: boolean;
+    };
+    extensions: ExtensionResolved[];
+    disableAutoFullBuild: boolean | null;
+    includeAssetsImportedByServer: boolean;
+    baseAssets: string;
+    baseServer: string;
+    redirects: Record<string, string>;
+    trailingSlash: boolean;
+    disableUrlNormalization: boolean;
+};
+type ConfigVikeUserProvided = {
+    /**
+     * Enable pre-rendering.
+     *
+     * https://vike.dev/pre-rendering
+     *
+     * @default false
+     */
+    prerender?: boolean | {
+        /**
+         * Don't create a new directory for each HTML file.
+         *
+         * For example, generate `dist/client/about.html` instead of `dist/client/about/index.html`.
+         *
+         * @default false
+         */
+        noExtraDir?: boolean;
+        /**
+         * Number of concurrent pre-render jobs.
+         *
+         * Set to `false` to disable concurrency.
+         *
+         * @default os.cpus().length
+         */
+        parallel?: boolean | number;
+        /**
+         * Allow only some of your pages to be pre-rendered.
+         *
+         * This setting doesn't affect the pre-rendering process: it merely suppresses the warnings when some of your pages cannot be pre-rendered.
+
+         * @default false
+         */
+        partial?: boolean;
+        /**
+         * Disable the automatic initiation of the pre-rendering process when running `$ vite build`.
+         *
+         * Use this if you want to programmatically initiate the pre-rendering process instead.
+         *
+         * https://vike.dev/prerender-programmatic
+         *
+         * @default false
+         */
+        disableAutoRun?: boolean;
+    };
+    /**
+     * @beta
+     * Don't use without having talked to a vike maintainer.
+     */
+    extensions?: ExtensionUserProvided[];
+    /**
+     * Set to `true` to disable the automatic chaining of all the build steps.
+     *
+     * https://vike.dev/disableAutoFullBuild
+     *
+     * @default false
+     */
+    disableAutoFullBuild?: boolean;
+    /** The Base URL of your server.
+     *
+     * https://vike.dev/base-url
+     */
+    baseServer?: string;
+    /** The Base URL of your static assets.
+     *
+     * https://vike.dev/base-url
+     */
+    baseAssets?: string;
+    /** @deprecated It's now `true` by default. You can remove this option. */
+    includeAssetsImportedByServer?: boolean;
+    /** Permanent redirections (HTTP status code 301)
+     *
+     * https://vike.dev/redirects
+     */
+    redirects?: Record<string, string>;
+    /** Whether URLs should end with a trailing slash.
+     *
+     * https://vike.dev/url-normalization
+     *
+     * @default false
+     */
+    trailingSlash?: boolean;
+    /** Disable automatic URL normalization.
+     *
+     * https://vike.dev/url-normalization
+     *
+     * @default false
+     */
+    disableUrlNormalization?: boolean;
+};

package/dist/esm/shared/ConfigVike.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/shared/RenderErrorPage.d.ts

@@ -0,0 +1 @@
+export { RenderErrorPage } from './route/abort.js';

package/dist/esm/shared/RenderErrorPage.js

@@ -0,0 +1,2 @@
+// TODO/v1-release: remove
+export { RenderErrorPage } from './route/abort.js';

package/dist/esm/shared/VikeNamespace.d.ts

@@ -0,0 +1,43 @@
+export type { Vike };
+export type { VikePackages };
+declare global {
+    /** Refine Vike types. */
+    namespace Vike {
+        /** Extend and/or refine the `Config` type (`import type { Config } from 'vike/types'`).
+         *
+         *  For example:
+         *  - You can refine the type of `Config['Page']`.
+         *  - You can define the type of custom configurations created with `config.meta` (https://vike.dev/meta)
+         *
+         */
+        interface Config {
+        }
+        /** Extend and/or refine the `PageContext` type (`import type { PageContext } from 'vike/types'`).
+         *
+         *  For example:
+         *  - You can define the type of fetched data, e.g. `PageContext['movies']`.
+         *  - You can refine the type of `PageContext['Page']`.
+         *
+         */
+        interface PageContext {
+        }
+    }
+    /** This namespace is only used by:
+     *  - `vike-react`
+     *  - `vike-vue`
+     *  - `vike-solid`
+     *  - `vike-svelte`
+     *
+     *  As a Vike user, you can ignore this.
+     */
+    namespace VikePackages {
+        interface ConfigVikeReact {
+        }
+        interface ConfigVikeVue {
+        }
+        interface ConfigVikeSolid {
+        }
+        interface ConfigVikeSvelte {
+        }
+    }
+}

package/dist/esm/shared/VikeNamespace.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/shared/abort.d.ts

@@ -0,0 +1 @@
+export { redirect, render } from './route/abort.js';

package/dist/esm/shared/abort.js

@@ -0,0 +1,11 @@
+// TODO/v1-release: Move all universal imports (when using Client Routing) to:
+//   import {
+//     redirect,
+//     render,
+//     resolveRoute,
+//     navigate,
+//     prefetch,
+//   } from 'vike'
+// Use package.json#exports to make the imports isomorphic.
+// The client-side has no utility when using Server Routing.
+export { redirect, render } from './route/abort.js';

package/dist/esm/shared/addIs404ToPageProps.d.ts

@@ -0,0 +1,7 @@
+export { addIs404ToPageProps };
+import type { PageConfig } from './page-configs/PageConfig.js';
+declare function addIs404ToPageProps(pageContext: Record<string, unknown> & PageContextAssertIs404): void;
+type PageContextAssertIs404 = {
+    _pageId: string;
+    _pageConfigs: PageConfig[];
+};

package/dist/esm/shared/addIs404ToPageProps.js

@@ -0,0 +1,23 @@
+export { addIs404ToPageProps };
+import { assert, assertWarning, hasProp, isObject } from './utils.js';
+import { isErrorPage } from './error-page.js';
+function addIs404ToPageProps(pageContext) {
+    assertIs404(pageContext);
+    addIs404(pageContext);
+}
+function assertIs404(pageContext) {
+    if (isErrorPage(pageContext._pageId, pageContext._pageConfigs)) {
+        assert(hasProp(pageContext, 'is404', 'boolean'));
+    }
+}
+function addIs404(pageContext) {
+    if (pageContext.is404 === undefined || pageContext.is404 === null)
+        return;
+    const pageProps = pageContext.pageProps || {};
+    if (!isObject(pageProps)) {
+        assertWarning(false, 'pageContext.pageProps should be an object', { showStackTrace: true, onlyOnce: true });
+        return;
+    }
+    pageProps.is404 = pageProps.is404 || pageContext.is404;
+    pageContext.pageProps = pageProps;
+}

package/dist/esm/shared/addUrlComputedProps.d.ts

@@ -0,0 +1,62 @@
+export { addUrlComputedProps };
+export { assertPageContextUrlComputedProps };
+export type { PageContextUrlComputedPropsInternal };
+export type { PageContextUrlComputedPropsClient };
+export type { PageContextUrlComputedPropsServer };
+export type { PageContextUrlSources };
+type UrlParsed = {
+    /** The URL origin, e.g. `https://example.com` of `https://example.com/product/42?details=yes#reviews` */
+    origin: null | string;
+    /** The URL pathname, e.g. `/product/42` of `https://example.com/product/42?details=yes#reviews` */
+    pathname: string;
+    /** URL pathname including the Base URL, e.g. `/some-base-url/product/42` of `https://example.com/some-base-url/product/42` (whereas `pageContext.urlParsed.pathname` is `/product/42`) */
+    pathnameOriginal: string;
+    /** The URL search parameters, e.g. `{ details: 'yes' }` for `https://example.com/product/42?details=yes#reviews` */
+    search: Record<string, string>;
+    /** The URL search parameters array, e.g. `{ fruit: ['apple', 'orange'] }` for `https://example.com?fruit=apple&fruit=orange` **/
+    searchAll: Record<string, string[]>;
+    /** The URL search parameterer string, e.g. `?details=yes` of `https://example.com/product/42?details=yes#reviews` */
+    searchOriginal: null | string;
+    /** @deprecated */
+    searchString: null | string;
+    /** The URL hash, e.g. `reviews` of `https://example.com/product/42?details=yes#reviews` */
+    hash: string;
+    /** The URL hash string, e.g. `#reviews` of `https://example.com/product/42?details=yes#reviews` */
+    hashOriginal: null | string;
+    /** @deprecated */
+    hashString: null | string;
+};
+type PageContextUrlComputedPropsClient = {
+    /** @deprecated */
+    url: string;
+    /** The URL of the HTTP request */
+    urlOriginal: string;
+    /** The URL pathname, e.g. `/product/42` of `https://example.com/product/42?details=yes#reviews` */
+    urlPathname: string;
+    /** Parsed information about the current URL */
+    urlParsed: UrlParsed;
+};
+type PageContextUrlComputedPropsInternal = PageContextUrlComputedPropsClient & {
+    _urlRewrite: string | null;
+};
+type HashProps = 'hash' | 'hashString' | 'hashOriginal';
+type PageContextUrlComputedPropsServer = PageContextUrlComputedPropsClient & {
+    urlParsed: Omit<PageContextUrlComputedPropsClient['urlParsed'], HashProps> & {
+        /** Only available on the client-side */
+        hash: '';
+        /** Only available on the client-side */
+        hashString: null;
+        /** @deprecated */
+        hashOriginal: null;
+    };
+};
+declare function addUrlComputedProps<PageContext extends Record<string, unknown> & PageContextUrlSources>(pageContext: PageContext, enumerable?: boolean): asserts pageContext is PageContext & PageContextUrlComputedPropsInternal;
+type PageContextUrlSources = {
+    urlOriginal: string;
+    _urlRewrite: string | null;
+    _baseServer: string;
+    _urlHandler: null | ((url: string) => string);
+};
+declare function assertPageContextUrlComputedProps(pageContext: {
+    urlOriginal: string;
+} & PageContextUrlComputedPropsClient): void;

package/dist/esm/shared/addUrlComputedProps.js

@@ -0,0 +1,108 @@
+// URLs props need to be computed props, because the user can modify the URL e.g. with onBeforeRoute() for i18n
+export { addUrlComputedProps };
+export { assertPageContextUrlComputedProps };
+import { assert, parseUrl, assertWarning, isPlainObject, hasPropertyGetter, isBrowser } from './utils.js';
+function addUrlComputedProps(pageContext, enumerable = true) {
+    assert(pageContext.urlOriginal);
+    if ('urlPathname' in pageContext) {
+        assert(hasPropertyGetter(pageContext, 'urlPathname'));
+    }
+    Object.defineProperty(pageContext, 'urlPathname', {
+        get: urlPathnameGetter,
+        enumerable,
+        configurable: true
+    });
+    // TODO/v1-release: move pageContext.urlParsed to pageContext.url
+    if ('url' in pageContext)
+        assert(hasPropertyGetter(pageContext, 'url'));
+    Object.defineProperty(pageContext, 'url', {
+        get: urlGetter,
+        enumerable: false,
+        configurable: true
+    });
+    if ('urlParsed' in pageContext) {
+        assert(hasPropertyGetter(pageContext, 'urlParsed'));
+    }
+    Object.defineProperty(pageContext, 'urlParsed', {
+        get: urlParsedGetter,
+        enumerable,
+        configurable: true
+    });
+}
+function getUrlParsed(pageContext) {
+    // We use a url handler function because the onBeforeRoute() hook may modify pageContext.urlOriginal (e.g. for i18n)
+    let urlHandler = pageContext._urlHandler;
+    if (!urlHandler) {
+        urlHandler = (url) => url;
+    }
+    const url = pageContext._urlRewrite ?? pageContext.urlOriginal;
+    assert(url && typeof url === 'string');
+    const urlLogical = urlHandler(url);
+    const baseServer = pageContext._baseServer;
+    assert(baseServer.startsWith('/'));
+    return parseUrl(urlLogical, baseServer);
+}
+function urlPathnameGetter() {
+    const { pathname } = getUrlParsed(this);
+    const urlPathname = pathname;
+    assert(urlPathname.startsWith('/'));
+    return urlPathname;
+}
+function urlGetter() {
+    // TODO/v1-release: remove
+    assertWarning(false, '`pageContext.url` is outdated. Use `pageContext.urlPathname`, `pageContext.urlParsed`, or `pageContext.urlOriginal` instead. (See https://vike.dev/migration/0.4.23 for more information.)', { onlyOnce: true, showStackTrace: true });
+    return urlPathnameGetter.call(this);
+}
+function urlParsedGetter() {
+    const urlParsedOriginal = getUrlParsed(this);
+    const { origin, pathname, pathnameOriginal, search, searchAll, searchOriginal, hash, hashOriginal } = urlParsedOriginal;
+    const hashIsAvailable = isBrowser();
+    const warnHashNotAvailable = (prop) => {
+        assertWarning(hashIsAvailable, `pageContext.urlParsed.${prop} isn't available on the server-side (HTTP requests don't include the URL hash by design)`, { onlyOnce: true, showStackTrace: true });
+    };
+    const urlParsed = {
+        origin,
+        pathname,
+        pathnameOriginal,
+        search,
+        searchAll,
+        searchOriginal,
+        get hash() {
+            warnHashNotAvailable('hash');
+            return hash;
+        },
+        get hashOriginal() {
+            warnHashNotAvailable('hashOriginal');
+            return hashOriginal;
+        },
+        get hashString() {
+            assertWarning(false, 'pageContext.urlParsed.hashString has been renamed to pageContext.urlParsed.hashOriginal', {
+                onlyOnce: true,
+                showStackTrace: true
+            });
+            warnHashNotAvailable('hashString');
+            return hashOriginal;
+        },
+        get searchString() {
+            assertWarning(false, 'pageContext.urlParsed.searchString has been renamed to pageContext.urlParsed.searchOriginal', { onlyOnce: true, showStackTrace: true });
+            return searchOriginal;
+        }
+    };
+    makeNonEnumerable(urlParsed, 'hashString');
+    makeNonEnumerable(urlParsed, 'searchString');
+    if (!hashIsAvailable) {
+        makeNonEnumerable(urlParsed, 'hash');
+        makeNonEnumerable(urlParsed, 'hashOriginal');
+    }
+    return urlParsed;
+}
+function makeNonEnumerable(obj, prop) {
+    const descriptor = Object.getOwnPropertyDescriptor(obj, prop);
+    Object.defineProperty(obj, prop, { ...descriptor, enumerable: false });
+}
+function assertPageContextUrlComputedProps(pageContext) {
+    assert(typeof pageContext.urlOriginal === 'string');
+    assert(typeof pageContext.urlPathname === 'string');
+    assert(isPlainObject(pageContext.urlParsed));
+    assert(pageContext.urlPathname === pageContext.urlParsed.pathname);
+}

package/dist/esm/shared/assertHookReturnedObject.d.ts

@@ -0,0 +1,4 @@
+export { assertHookReturnedObject };
+declare function assertHookReturnedObject<Keys extends readonly string[]>(obj: Record<string, unknown>, keysExpected: Keys, errPrefix: string): asserts obj is {
+    [key in Keys[number]]?: unknown;
+};

package/dist/esm/shared/assertHookReturnedObject.js

@@ -0,0 +1,19 @@
+export { assertHookReturnedObject };
+import { assert, assertUsage, stringifyStringArray } from './utils.js';
+function assertHookReturnedObject(obj, keysExpected, errPrefix) {
+    assert(!errPrefix.endsWith(' '));
+    const keysUnknown = [];
+    const keys = Object.keys(obj);
+    for (const key of keys) {
+        if (!keysExpected.includes(key)) {
+            keysUnknown.push(key);
+        }
+    }
+    assertUsage(keysUnknown.length === 0, [
+        errPrefix,
+        'returned an object with following unknown keys:',
+        stringifyStringArray(keysUnknown) + '.',
+        'Only following keys are allowed:',
+        stringifyStringArray(keysExpected) + '.'
+    ].join(' '));
+}

package/dist/esm/shared/assertOnBeforeRenderHookReturn.d.ts

@@ -0,0 +1,4 @@
+export { assertOnBeforeRenderHookReturn };
+declare function assertOnBeforeRenderHookReturn<Keys extends readonly string[]>(hookReturnValue: unknown, hookFilePath: string): asserts hookReturnValue is undefined | null | {
+    [key in Keys[number]]?: unknown;
+};

package/dist/esm/shared/assertOnBeforeRenderHookReturn.js

@@ -0,0 +1,16 @@
+export { assertOnBeforeRenderHookReturn };
+import { assertUsage, isPlainObject } from './utils.js';
+import { assertPageContextProvidedByUser } from './assertPageContextProvidedByUser.js';
+import { assertHookReturnedObject } from './assertHookReturnedObject.js';
+import pc from '@brillout/picocolors';
+function assertOnBeforeRenderHookReturn(hookReturnValue, hookFilePath) {
+    if (hookReturnValue === undefined || hookReturnValue === null) {
+        return;
+    }
+    const errPrefix = `The onBeforeRender() hook defined by ${hookFilePath}`;
+    assertUsage(isPlainObject(hookReturnValue), `${errPrefix} should return a plain JavaScript object, ${pc.cyan('undefined')}, or ${pc.cyan('null')}`);
+    assertHookReturnedObject(hookReturnValue, ['pageContext'], errPrefix);
+    if (hookReturnValue.pageContext) {
+        assertPageContextProvidedByUser(hookReturnValue['pageContext'], { hookName: 'onBeforeRender', hookFilePath });
+    }
+}

package/dist/esm/shared/assertPageContextProvidedByUser.d.ts

@@ -0,0 +1,5 @@
+export { assertPageContextProvidedByUser };
+declare function assertPageContextProvidedByUser(pageContextProvidedByUser: unknown, { hookName, hookFilePath }: {
+    hookFilePath: string;
+    hookName: 'onBeforeRender' | 'onRenderHtml' | 'render' | 'onBeforeRoute';
+}): asserts pageContextProvidedByUser is Record<string, unknown>;

package/dist/esm/shared/assertPageContextProvidedByUser.js

@@ -0,0 +1,15 @@
+export { assertPageContextProvidedByUser };
+import { assert, assertUsage, assertWarning, isObject } from './utils.js';
+import pc from '@brillout/picocolors';
+function assertPageContextProvidedByUser(pageContextProvidedByUser, { hookName, hookFilePath }) {
+    if (pageContextProvidedByUser === undefined || pageContextProvidedByUser === null)
+        return;
+    assert(!hookName.endsWith(')'));
+    const errPrefix = `The ${pc.cyan('pageContext')} object provided by the ${hookName}() hook defined by ${hookFilePath}`;
+    assertUsage(isObject(pageContextProvidedByUser), `${errPrefix} should be an object (but it's ${pc.cyan(`typeof pageContext === ${JSON.stringify(typeof pageContextProvidedByUser)}`)} instead)`);
+    assertUsage(!('_objectCreatedByVike' in pageContextProvidedByUser), `${errPrefix} shouldn't be the whole ${pc.cyan('pageContext')} object, see https://vike.dev/pageContext-manipulation#do-not-return-entire-pagecontext`);
+    // In principle, it's possible to use onBeforeRoute()` to override and define the whole routing.
+    // Is that a good idea to allow users to do this? Beyond deep integration with Vue Router or React Router, is there a use case for this?
+    assertWarning(!('_pageId' in pageContextProvidedByUser), `${errPrefix} sets ${pc.cyan('pageContext._pageId')} which means that vike's routing is overriden. This is an experimental feature: make sure to contact a vike maintainer before using this.`, { onlyOnce: true });
+    assertUsage(!('is404' in pageContextProvidedByUser), `${errPrefix} sets ${pc.cyan('pageContext.is404')} which is forbidden, use ${pc.cyan('throw render()')} instead, see https://vike.dev/render`);
+}

package/dist/esm/shared/assertPageFilePath.d.ts

@@ -0,0 +1,2 @@
+export { assertPageFilePath };
+declare function assertPageFilePath(filePath: string): void;

package/dist/esm/shared/assertPageFilePath.js

@@ -0,0 +1,9 @@
+// TODO/v1-release: remove
+export { assertPageFilePath };
+import { assertPosixPath } from './utils.js';
+function assertPageFilePath(filePath) {
+    assertPosixPath(filePath);
+    /* This assert() is skipped to reduce client-side bundle size
+    assert(filePath.startsWith('/') || isNpmPackageImport(filePath), { filePath })
+    */
+}

package/dist/esm/shared/determinePageIdOld.d.ts

@@ -0,0 +1,2 @@
+export { determinePageIdOld };
+declare function determinePageIdOld(filePath: string): string;

package/dist/esm/shared/determinePageIdOld.js

@@ -0,0 +1,9 @@
+export { determinePageIdOld };
+import { slice, assert } from './utils.js';
+// TODO/v1-release: remove
+function determinePageIdOld(filePath) {
+    const pageSuffix = '.page.';
+    const pageId = slice(filePath.split(pageSuffix), 0, -1).join(pageSuffix);
+    assert(!pageId.includes('\\'));
+    return pageId;
+}

package/dist/esm/shared/error-page.d.ts

@@ -0,0 +1,8 @@
+export { getErrorPageId };
+export { isErrorPageId };
+export { isErrorPage };
+import type { PageConfig } from './page-configs/PageConfig.js';
+import type { PageFile } from './getPageFiles.js';
+declare function getErrorPageId(pageFilesAll: PageFile[], pageConfigs: PageConfig[]): string | null;
+declare function isErrorPageId(pageId: string, _isV1Design: false): boolean;
+declare function isErrorPage(pageId: string, pageConfigs: PageConfig[]): boolean;