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

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

@@ -0,0 +1,127 @@
+export { PageContext };
+export { PageContextServer };
+export { PageContextClient };
+export { PageContextWithServerRouting };
+export { PageContextClientWithServerRouting };
+export { PageContextBuiltInServer };
+export { PageContextBuiltInServerInternal };
+export { PageContextBuiltInClientWithClientRouting };
+export { PageContextBuiltInClientWithServerRouting };
+import type { PageContextUrlComputedPropsInternal, PageContextUrlComputedPropsClient, PageContextUrlComputedPropsServer } from './addUrlComputedProps.js';
+import type { ConfigEntries, ExportsAll } from './getPageFiles/getExports.js';
+import type { Config } from './page-configs/Config.js';
+import type { PageContextConfig } from './page-configs/Config/PageContextConfig.js';
+import type { AbortStatusCode } from './route/abort.js';
+type PageContext = PageContextWithClientRouting;
+type PageContextClient = PageContextClientWithClientRouting;
+type PageContextWithClientRouting = PageContextClientWithClientRouting | PageContextServer;
+type PageContextWithServerRouting = PageContextClientWithServerRouting | PageContextServer;
+type PageContextServer = PageContextBuiltInServer & Vike.PageContext;
+type PageContextClientWithClientRouting = PageContextBuiltInClientWithClientRouting & Vike.PageContext;
+type PageContextClientWithServerRouting = PageContextBuiltInClientWithServerRouting & Vike.PageContext;
+/** Built-in `pageContext` properties set by vike.
+ *
+ * https://vike.dev/pageContext
+ */
+type PageContextBuiltInServer<Page = [never]> = PageContextBuiltInCommon<Page> & PageContextUrlComputedPropsServer;
+type PageContextBuiltInServerInternal<Page = [never]> = PageContextBuiltInCommon<Page> & PageContextUrlComputedPropsInternal;
+type PageContextBuiltInCommon<Page = [never]> = {
+    /** The `export { Page }` of your `.page.js` file.
+     *
+     * https://vike.dev/Page
+     */
+    Page: Page extends [never] ? Config['Page'] : Page;
+    /** Route Parameters, e.g. `pageContext.routeParams.productId` for a Route String `/product/@productId`.
+     *
+     * https://vike.dev/route-string
+     */
+    routeParams: Record<string, string>;
+    /** The page's configuration values.
+     *
+     * https://vike.dev/config
+     */
+    config: PageContextConfig;
+    /** The page's configuration, including the configs origin and overriden configs.
+     *
+     * https://vike.dev/config
+     */
+    configEntries: ConfigEntries;
+    /** Custom Exports/Hooks.
+     *
+     * https://vike.dev/exports
+     */
+    exports: Record<string, unknown>;
+    /**
+     * Same as `pageContext.exports` but cumulative.
+     *
+     * https://vike.dev/exports
+     */
+    exportsAll: ExportsAll;
+    /** The URL of the current page */
+    urlOriginal: string;
+    /** If an error occurs, whether the error is a `404 Page Not Found`.
+     *
+     * https://vike.dev/error-page
+     */
+    is404: boolean | null;
+    /**
+     * Whether the page was navigated by the client-side router.
+     *
+     * https://vike.dev/pageContext
+     */
+    isClientSideNavigation: boolean;
+    /**
+     * The reason why the original page was aborted. Usually used for showing a custom message on the error page.
+     *
+     * https://vike.dev/render
+     */
+    abortReason?: unknown;
+    /**
+     * The status code set by `throw render(abortStatusCode)`.
+     *
+     * https://vike.dev/render
+     */
+    abortStatusCode?: AbortStatusCode;
+    /**
+     * Error that occured while rendering.
+     *
+     * https://vike.dev/errors
+     */
+    errorWhileRendering?: unknown;
+    /** @deprecated */
+    url: string;
+    /** @deprecated */
+    pageExports: Record<string, unknown>;
+};
+/** Client-side built-in `pageContext` properties set by vike (Client Routing).
+ *
+ * https://vike.dev/pageContext
+ */
+type PageContextBuiltInClientWithClientRouting<Page = unknown> = Partial<PageContextBuiltInCommon<Page>> & Pick<PageContextBuiltInCommon<Page>, 'Page' | 'pageExports' | 'config' | 'configEntries' | 'exports' | 'exportsAll' | 'abortReason'> & {
+    /** Whether the current page is already rendered to HTML */
+    isHydration: boolean;
+    /**
+     * Whether the user is navigating back in history.
+     *
+     * The value is `true` when the user clicks on his browser's backward navigation button, or when invoking `history.back()`.
+     */
+    isBackwardNavigation: boolean | null;
+} & PageContextUrlComputedPropsClient;
+/** Client-side built-in `pageContext` properties set by vike (Server Routing).
+ *
+ * https://vike.dev/pageContext
+ */
+type PageContextBuiltInClientWithServerRouting<Page = unknown> = Partial<PageContextBuiltInCommon<Page>> & Pick<PageContextBuiltInCommon<Page>, 'Page' | 'pageExports' | 'exports' | 'abortReason'> & {
+    /**
+     * Whether the current page is already rendered to HTML.
+     *
+     * The `isHydration` value is always `true` when using Server Routing.
+     */
+    isHydration: true;
+    /**
+     * Whether the user is navigating back in history.
+     *
+     * The `isBackwardNavigation` property only works with Client Routing. (The value is always `null` when using Server Routing.)
+     */
+    isBackwardNavigation: null;
+};

package/dist/esm/shared/types.js

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

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

@@ -0,0 +1,23 @@
+export * from '../utils/assert.js';
+export * from '../utils/parseUrl.js';
+export * from '../utils/objectAssign.js';
+export * from '../utils/isCallable.js';
+export * from '../utils/isObject.js';
+export * from '../utils/unique.js';
+export * from '../utils/slice.js';
+export * from '../utils/sorter.js';
+export * from '../utils/isBrowser.js';
+export * from '../utils/hasProp.js';
+export * from '../utils/isPlainObject.js';
+export * from '../utils/compareString.js';
+export * from '../utils/isNotNullish.js';
+export * from '../utils/stringifyStringArray.js';
+export * from '../utils/filesystemPathHandling.js';
+export * from '../utils/cast.js';
+export * from '../utils/projectInfo.js';
+export * from '../utils/hasPropertyGetter.js';
+export * from '../utils/isPromise.js';
+export * from '../utils/checkType.js';
+export * from '../utils/assertDefaultExport.js';
+export * from '../utils/objectEntries.js';
+export * from '../utils/getValuePrintable.js';

package/dist/esm/shared/utils.js

@@ -0,0 +1,27 @@
+// Utils needed by all runtimes:
+//  - runtime of server
+//  - runtime of client (Server Routing)
+//  - runtime of client (Client Routing)
+export * from '../utils/assert.js';
+export * from '../utils/parseUrl.js';
+export * from '../utils/objectAssign.js';
+export * from '../utils/isCallable.js';
+export * from '../utils/isObject.js';
+export * from '../utils/unique.js';
+export * from '../utils/slice.js';
+export * from '../utils/sorter.js';
+export * from '../utils/isBrowser.js';
+export * from '../utils/hasProp.js';
+export * from '../utils/isPlainObject.js';
+export * from '../utils/compareString.js';
+export * from '../utils/isNotNullish.js';
+export * from '../utils/stringifyStringArray.js';
+export * from '../utils/filesystemPathHandling.js';
+export * from '../utils/cast.js';
+export * from '../utils/projectInfo.js';
+export * from '../utils/hasPropertyGetter.js';
+export * from '../utils/isPromise.js';
+export * from '../utils/checkType.js';
+export * from '../utils/assertDefaultExport.js';
+export * from '../utils/objectEntries.js';
+export * from '../utils/getValuePrintable.js';

package/dist/esm/types/index-dreprecated.d.ts

@@ -0,0 +1,51 @@
+export type { PageContextBuiltIn, PageContextBuiltInClientWithClientRouting, PageContextBuiltInClientWithServerRouting, InjectFilterEntry, Config, Env, ConfigEntries };
+import type { PageContextBuiltInServer, PageContextBuiltInClientWithClientRouting as PageContextBuiltInClientWithClientRouting_, PageContextBuiltInClientWithServerRouting as PageContextBuiltInClientWithServerRouting_, InjectFilterEntry as InjectFilterEntry_, Config as Config_, Env as Env_, ConfigEntries as ConfigEntries_ } from './index.js';
+/** @deprecated All types have been moved to `vike/types`.
+ * Replace:
+ *   `import type { PageContextBuiltIn } from 'vike'`
+ * With:
+ *   `import type { PageContextBuiltInServer } from 'vike/types'`
+ */
+type PageContextBuiltIn<Page = any> = PageContextBuiltInServer<Page>;
+/** @deprecated All types have been moved to `vike/types`.
+ * Replace:
+ *   `import type { PageContextBuiltInClientWithClientRouting } from 'vike'`
+ * With:
+ *   `import type { PageContextBuiltInClientWithClientRouting } from 'vike/types'`
+ */
+type PageContextBuiltInClientWithClientRouting<Page = any> = PageContextBuiltInClientWithClientRouting_<Page>;
+/** @deprecated All types have been moved to `vike/types`.
+ * Replace:
+ *   `import type { PageContextBuiltInClientWithServerRouting } from 'vike'`
+ * With:
+ *   `import type { PageContextBuiltInClientWithServerRouting } from 'vike/types'`
+ */
+type PageContextBuiltInClientWithServerRouting<Page = any> = PageContextBuiltInClientWithServerRouting_<Page>;
+/** @deprecated All types have been moved to `vike/types`.
+ * Replace:
+ *   `import type { InjectFilterEntry } from 'vike'`
+ * With:
+ *   `import type { InjectFilterEntry } from 'vike/types'`
+ */
+type InjectFilterEntry = InjectFilterEntry_;
+/** @deprecated All types have been moved to `vike/types`.
+ * Replace:
+ *   `import type { Config } from 'vike'`
+ * With:
+ *   `import type { Config } from 'vike/types'`
+ */
+type Config = Config_;
+/** @deprecated All types have been moved to `vike/types`.
+ * Replace:
+ *   `import type { Env } from 'vike'`
+ * With:
+ *   `import type { Env } from 'vike/types'`
+ */
+type Env = Env_;
+/** @deprecated All types have been moved to `vike/types`.
+ * Replace:
+ *   `import type { ConfigEntries } from 'vike'`
+ * With:
+ *   `import type { ConfigEntries } from 'vike/types'`
+ */
+type ConfigEntries = ConfigEntries_;

package/dist/esm/types/index-dreprecated.js

@@ -0,0 +1,2 @@
+// Same as ./index.ts but with deprecation notice.
+export {};

package/dist/esm/types/index.d.ts

@@ -0,0 +1,47 @@
+export type { PageContext } from '../shared/types.js';
+export type { PageContextServer } from '../shared/types.js';
+export type { PageContextClient } from '../shared/types.js';
+export type { PageContextWithServerRouting } from '../shared/types.js';
+export type { PageContextClientWithServerRouting } from '../shared/types.js';
+export type { PageContextBuiltInServer } from '../shared/types.js';
+export type { PageContextBuiltInClientWithClientRouting } from '../shared/types.js';
+export type { PageContextBuiltInClientWithServerRouting } from '../shared/types.js';
+export type { Config, ConfigMeta as Meta } from '../shared/page-configs/Config.js';
+export type { ConfigEnv } from '../shared/page-configs/PageConfig.js';
+export type { ConfigDefinition, ConfigEffect } from '../node/plugin/plugins/importUserCode/v1-design/getVikeConfig/configDefinitionsBuiltIn.js';
+export type { ConfigEntries } from '../shared/getPageFiles/getExports.js';
+export type { InjectFilterEntry } from '../node/runtime/html/injectAssets/getHtmlTags.js';
+import type { ConfigEnv } from '../shared/page-configs/PageConfig.js';
+/** @deprecated Replace:
+ *   `import type { Env } from 'vike/types'`
+ * With:
+ *   `import type { ConfigEnv } from 'vike/types'`
+ */
+type Env = ConfigEnv;
+export type { Env };
+import type { ConfigEffect } from '../node/plugin/plugins/importUserCode/v1-design/getVikeConfig/configDefinitionsBuiltIn.js';
+/** @deprecated Replace:
+ *   `import type { Effect } from 'vike/types'`
+ * With:
+ *   `import type { ConfigEffect } from 'vike/types'`
+ */
+type Effect = ConfigEffect;
+export type { Effect };
+import { PageContextBuiltInClientWithServerRouting } from '../shared/types.js';
+/** @deprecated Replace:
+ *   `import type { PageContextBuiltInClient } from 'vike/types'`
+ * With:
+ *   `import type { PageContextBuiltInClientWithServerRouting } from 'vike/types'`
+ * Or:
+ *   `import type { PageContextBuiltInClientWithClientRouting } from 'vike/types'`
+ */
+type PageContextBuiltInClient<Page = any> = PageContextBuiltInClientWithServerRouting<Page>;
+export type { PageContextBuiltInClient };
+import { PageContextBuiltInServer } from '../shared/types.js';
+/** @deprecated Replace:
+ *   `import type { PageContextBuiltIn } from 'vike/types'`
+ * With:
+ *   `import type { PageContextBuiltInServer } from 'vike/types'`
+ */
+type PageContextBuiltIn<Page = any> = PageContextBuiltInServer<Page>;
+export type { PageContextBuiltIn };

package/dist/esm/types/index.js

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

package/dist/esm/utils/PromiseType.d.ts

@@ -0,0 +1 @@
+export type PromiseType<T> = T extends PromiseLike<infer U> ? U : T;

package/dist/esm/utils/PromiseType.js

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

package/dist/esm/utils/arrayIncludes.d.ts

@@ -0,0 +1 @@
+export declare function arrayIncludes<Arr extends any[] | readonly any[]>(arr: Arr, el: unknown): el is Arr[number];

package/dist/esm/utils/arrayIncludes.js

@@ -0,0 +1,3 @@
+export function arrayIncludes(arr, el) {
+    return arr.includes(el);
+}

package/dist/esm/utils/assert.d.ts

@@ -0,0 +1,29 @@
+export { assert };
+export { assertUsage };
+export { assertWarning };
+export { assertInfo };
+export { getProjectError };
+export { addOnBeforeLogHook };
+export { getAssertErrMsg };
+export { overwriteAssertProductionLogger };
+export { isBug };
+type Logger = (msg: string | Error, logType: 'warn' | 'info') => void;
+declare function assert(condition: unknown, debugInfo?: unknown): asserts condition;
+declare function assertUsage(condition: unknown, errMsg: string, { showStackTrace }?: {
+    showStackTrace?: true;
+}): asserts condition;
+declare function getProjectError(errMsg: string): Error;
+declare function assertWarning(condition: unknown, msg: string, { onlyOnce, showStackTrace }: {
+    onlyOnce: boolean | string;
+    showStackTrace?: true;
+}): void;
+declare function assertInfo(condition: unknown, msg: string, { onlyOnce }: {
+    onlyOnce: boolean;
+}): void;
+declare function addOnBeforeLogHook(onBeforeLog: () => void): void;
+declare function getAssertErrMsg(thing: unknown): {
+    assertMsg: string;
+    showVikeVersion: boolean;
+} | null;
+declare function overwriteAssertProductionLogger(logger: Logger): void;
+declare function isBug(err: unknown): boolean;

package/dist/esm/utils/assert.js

@@ -0,0 +1,188 @@
+export { assert };
+export { assertUsage };
+export { assertWarning };
+export { assertInfo };
+export { getProjectError };
+export { addOnBeforeLogHook };
+export { getAssertErrMsg };
+export { overwriteAssertProductionLogger };
+export { isBug };
+import { createErrorWithCleanStackTrace } from './createErrorWithCleanStackTrace.js';
+import { getGlobalObject } from './getGlobalObject.js';
+import { isObject } from './isObject.js';
+import { projectInfo } from './projectInfo.js';
+import pc from '@brillout/picocolors';
+const globalObject = getGlobalObject('utils/assert.ts', {
+    alreadyLogged: new Set(),
+    // Production logger. Overwritten by loggerNotProd.ts in non-production environments.
+    logger(msg, logType) {
+        if (logType === 'info') {
+            console.log(msg);
+        }
+        else {
+            console.warn(msg);
+        }
+    },
+    showStackTraceList: new WeakSet()
+});
+const projectTag = `[${projectInfo.npmPackageName}]`;
+const projectTagWithVersion = `[${projectInfo.npmPackageName}@${projectInfo.projectVersion}]`;
+const numberOfStackTraceLinesToRemove = 2;
+function assert(condition, debugInfo) {
+    if (condition)
+        return;
+    const debugStr = (() => {
+        if (!debugInfo) {
+            return null;
+        }
+        const debugInfoSerialized = typeof debugInfo === 'string' ? debugInfo : JSON.stringify(debugInfo);
+        return pc.dim(`Debug info (for ${projectInfo.projectName} maintainers; you can ignore this): ${debugInfoSerialized}`);
+    })();
+    const link = `${projectInfo.githubRepository}/issues/new`;
+    let errMsg = [
+        `You stumbled upon a bug in ${projectInfo.projectName}'s source code.`,
+        `Go to ${pc.blue(link)} and copy-paste this error; a maintainer will fix the bug (usually under 24 hours).`,
+        debugStr
+    ]
+        .filter(Boolean)
+        .join(' ');
+    errMsg = addWhitespace(errMsg);
+    errMsg = addPrefixAssertType(errMsg, 'Bug');
+    errMsg = addPrefixProjctName(errMsg, true);
+    const internalError = createErrorWithCleanStackTrace(errMsg, numberOfStackTraceLinesToRemove);
+    globalObject.onBeforeLog?.();
+    throw internalError;
+}
+function assertUsage(condition, errMsg, { showStackTrace } = {}) {
+    if (condition)
+        return;
+    errMsg = addWhitespace(errMsg);
+    errMsg = addPrefixAssertType(errMsg, 'Wrong Usage');
+    errMsg = addPrefixProjctName(errMsg);
+    const usageError = createErrorWithCleanStackTrace(errMsg, numberOfStackTraceLinesToRemove);
+    if (showStackTrace) {
+        globalObject.showStackTraceList.add(usageError);
+    }
+    globalObject.onBeforeLog?.();
+    throw usageError;
+}
+function getProjectError(errMsg) {
+    errMsg = addWhitespace(errMsg);
+    errMsg = addPrefixAssertType(errMsg, 'Error');
+    errMsg = addPrefixProjctName(errMsg);
+    const projectError = createErrorWithCleanStackTrace(errMsg, numberOfStackTraceLinesToRemove);
+    return projectError;
+}
+function assertWarning(condition, msg, { onlyOnce, showStackTrace }) {
+    if (condition)
+        return;
+    msg = addWhitespace(msg);
+    msg = addPrefixAssertType(msg, 'Warning');
+    msg = addPrefixProjctName(msg);
+    if (onlyOnce) {
+        const { alreadyLogged } = globalObject;
+        const key = onlyOnce === true ? msg : onlyOnce;
+        if (alreadyLogged.has(key)) {
+            return;
+        }
+        else {
+            alreadyLogged.add(key);
+        }
+    }
+    globalObject.onBeforeLog?.();
+    if (showStackTrace) {
+        const err = new Error(msg);
+        globalObject.showStackTraceList.add(err);
+        globalObject.logger(err, 'warn');
+    }
+    else {
+        globalObject.logger(msg, 'warn');
+    }
+}
+function assertInfo(condition, msg, { onlyOnce }) {
+    if (condition) {
+        return;
+    }
+    msg = addWhitespace(msg);
+    msg = addPrefixProjctName(msg);
+    if (onlyOnce) {
+        const { alreadyLogged } = globalObject;
+        const key = msg;
+        if (alreadyLogged.has(key)) {
+            return;
+        }
+        else {
+            alreadyLogged.add(key);
+        }
+    }
+    globalObject.onBeforeLog?.();
+    globalObject.logger(msg, 'info');
+}
+function addOnBeforeLogHook(onBeforeLog) {
+    globalObject.onBeforeLog = onBeforeLog;
+}
+function addPrefixAssertType(msg, tag) {
+    let prefix = `[${tag}]`;
+    const color = tag === 'Warning' ? 'yellow' : 'red';
+    prefix = pc.bold(pc[color](prefix));
+    return `${prefix}${msg}`;
+}
+function addWhitespace(msg) {
+    if (msg.startsWith('[')) {
+        return msg;
+    }
+    else {
+        return ` ${msg}`;
+    }
+}
+function addPrefixProjctName(msg, showProjectVersion = false) {
+    const prefix = showProjectVersion ? projectTagWithVersion : projectTag;
+    return `${prefix}${msg}`;
+}
+function getAssertErrMsg(thing) {
+    let errMsg;
+    let errStack = null;
+    if (typeof thing === 'string') {
+        errMsg = thing;
+    }
+    else if (isObject(thing) && typeof thing.message === 'string' && typeof thing.stack === 'string') {
+        errMsg = thing.message;
+        errStack = thing.stack;
+    }
+    else {
+        return null;
+    }
+    let assertMsg;
+    let isBug;
+    if (errMsg.startsWith(projectTag)) {
+        assertMsg = errMsg.slice(projectTag.length);
+        isBug = false;
+    }
+    else if (errMsg.startsWith(projectTagWithVersion)) {
+        assertMsg = errMsg.slice(projectTagWithVersion.length);
+        isBug = true;
+    }
+    else {
+        return null;
+    }
+    // Append stack trace
+    if (errStack && (isBug || globalObject.showStackTraceList.has(thing))) {
+        assertMsg = `${assertMsg}\n${removeErrMsg(errStack)}`;
+    }
+    const showVikeVersion = isBug;
+    return { assertMsg, showVikeVersion };
+}
+function removeErrMsg(stack) {
+    if (typeof stack !== 'string')
+        return String(stack);
+    const [firstLine, ...stackLines] = stack.split('\n');
+    if (!firstLine.startsWith('Error: '))
+        return stack;
+    return stackLines.join('\n');
+}
+function overwriteAssertProductionLogger(logger) {
+    globalObject.logger = logger;
+}
+function isBug(err) {
+    return !String(err).includes('[Bug]');
+}

package/dist/esm/utils/assertDefaultExport.d.ts

@@ -0,0 +1,8 @@
+export { assertDefaultExportUnknown };
+export { assertDefaultExportObject };
+declare function assertDefaultExportUnknown(fileExports: Record<string, unknown>, filePath: string): asserts fileExports is Record<string, unknown> & {
+    default: unknown;
+};
+declare function assertDefaultExportObject(fileExports: Record<string, unknown>, filePath: string): asserts fileExports is {
+    default: Record<string, unknown>;
+};

package/dist/esm/utils/assertDefaultExport.js

@@ -0,0 +1,47 @@
+export { assertDefaultExportUnknown };
+export { assertDefaultExportObject };
+import { assert, assertUsage, assertWarning } from './assert.js';
+import { isObject } from './isObject.js';
+import pc from '@brillout/picocolors';
+const IGNORE = [
+    // vite-plugin-solid adds `export { $$registrations }`
+    '$$registrations',
+    // @vitejs/plugin-vue adds `export { _rerender_only }`
+    '_rerender_only'
+];
+// support `export { frontmatter }` in .mdx files
+const FILES_WITH_SIDE_EXPORTS = ['.md', '.mdx'];
+function assertDefaultExportUnknown(fileExports, filePath) {
+    assertSingleDefaultExport(fileExports, filePath, true);
+}
+function assertDefaultExportObject(fileExports, filePath) {
+    assertSingleDefaultExport(fileExports, filePath, false);
+    const exportDefault = fileExports.default;
+    assertUsage(isObject(exportDefault), `The ${pc.cyan('export default')} of ${filePath} should be an object (but it's ${pc.cyan(`typeof exportDefault === ${JSON.stringify(typeof exportDefault)}`)} instead)`);
+}
+function assertSingleDefaultExport(fileExports, filePath, defaultExportValueIsUnknown) {
+    const exportsAll = Object.keys(fileExports);
+    const exportsRelevant = exportsAll.filter((exportName) => !IGNORE.includes(exportName));
+    const exportsInvalid = exportsRelevant.filter((e) => e !== 'default');
+    const exportsHasDefault = exportsRelevant.includes('default');
+    if (exportsInvalid.length === 0) {
+        if (exportsHasDefault) {
+            return;
+        }
+        else {
+            assert(exportsRelevant.length === 0);
+            assertUsage(false, `${filePath} doesn't export any value, but it should have a ${pc.cyan('export default')} instead`);
+        }
+    }
+    else if (!FILES_WITH_SIDE_EXPORTS.some((ext) => filePath.endsWith(ext))) {
+        if (defaultExportValueIsUnknown) {
+            exportsInvalid.forEach((exportInvalid) => {
+                assertWarning(exportsInvalid.length === 0, `${filePath} should only have a default export: move ${pc.cyan(`export { ${exportInvalid} }`)} to +config.h.js or its own +${exportsInvalid}.js`, { onlyOnce: true });
+            });
+        }
+        else {
+            const exportsInvalidStr = exportsInvalid.join(', ');
+            assertWarning(exportsInvalid.length === 0, `${filePath} replace ${pc.cyan(`export { ${exportsInvalidStr} }`)} with ${pc.cyan(`export default { ${exportsInvalidStr} }`)}`, { onlyOnce: true });
+        }
+    }
+}

package/dist/esm/utils/assertIsBrowser.d.ts

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

package/dist/esm/utils/assertIsBrowser.js

@@ -0,0 +1,6 @@
+export { assertIsBrowser };
+import { isBrowser } from './isBrowser.js';
+import { assert } from './assert.js';
+function assertIsBrowser() {
+    assert(isBrowser());
+}

package/dist/esm/utils/assertIsNotBrowser.d.ts

@@ -0,0 +1,3 @@
+export { assertIsNotBrowser };
+/** Ensure we don't bloat the client-side */
+declare function assertIsNotBrowser(): void;

package/dist/esm/utils/assertIsNotBrowser.js

@@ -0,0 +1,7 @@
+export { assertIsNotBrowser };
+import { isBrowser } from './isBrowser.js';
+import { assert } from './assert.js';
+/** Ensure we don't bloat the client-side */
+function assertIsNotBrowser() {
+    assert(!isBrowser());
+}

package/dist/esm/utils/assertIsNotProductionRuntime.d.ts

@@ -0,0 +1,10 @@
+export { assertIsNotProductionRuntime };
+export { markEnvAsDev };
+export { markEnvAsPreview };
+export { markEnvAsVite };
+export { assertEnv };
+declare function assertIsNotProductionRuntime(): void | undefined;
+declare function markEnvAsDev(): void | undefined;
+declare function markEnvAsPreview(): void | undefined;
+declare function markEnvAsVite(): void;
+declare function assertEnv(): void | undefined;

package/dist/esm/utils/assertIsNotProductionRuntime.js

@@ -0,0 +1,41 @@
+// Mechanism to ensure code isn't loaded by production runtime
+export { assertIsNotProductionRuntime };
+export { markEnvAsDev };
+export { markEnvAsPreview };
+export { markEnvAsVite };
+export { assertEnv };
+import { assert } from './assert.js';
+import { assertIsNotBrowser } from './assertIsNotBrowser.js';
+import { getGlobalObject } from './getGlobalObject.js';
+import { isVitest } from './isVitest.js';
+assertIsNotBrowser();
+const env = getGlobalObject('utils/assertIsNotProductionRuntime.ts', {});
+// Called by *.ts that want to ensure that they aren't loaded by the server runtime in production
+function assertIsNotProductionRuntime() {
+    env.shouldBeVite = true;
+}
+// Called by Vite hook configureServer()
+function markEnvAsDev() {
+    env.isDev = true;
+}
+// Called by Vite hook configurePreviewServer()
+function markEnvAsPreview() {
+    env.isPreview = true;
+}
+// Called by ../node/plugin/index.ts
+function markEnvAsVite() {
+    env.isVite = true;
+}
+// Called by ../node/runtime/index.ts
+function assertEnv() {
+    if (isVitest())
+        return;
+    if (env.isDev || env.isPreview) {
+        assert(env.isVite);
+        assert(env.shouldBeVite);
+    }
+    else {
+        assert(!env.isVite);
+        assert(!env.shouldBeVite);
+    }
+}

package/dist/esm/utils/assertNodeVersion.d.ts

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