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

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

@@ -0,0 +1,13 @@
+export * from '../../utils/assert.js';
+export * from '../../utils/hasProp.js';
+export * from '../../utils/projectInfo.js';
+export * from '../../utils/objectAssign.js';
+export * from '../../utils/isObjectWithKeys.js';
+export * from '../../utils/isCallable.js';
+export * from '../../utils/getOutDirs.js';
+export * from '../../utils/hasPropertyGetter.js';
+export * from '../../utils/filesystemPathHandling.js';
+export * from '../../utils/urlToFile.js';
+export * from '../../shared/hooks/executeHook.js';
+export * from '../../utils/isPlainObject.js';
+export * from '../../utils/nodeEnv.js';

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

@@ -0,0 +1,15 @@
+import { assertIsNotBrowser } from '../../utils/assertIsNotBrowser.js';
+assertIsNotBrowser();
+export * from '../../utils/assert.js';
+export * from '../../utils/hasProp.js';
+export * from '../../utils/projectInfo.js';
+export * from '../../utils/objectAssign.js';
+export * from '../../utils/isObjectWithKeys.js';
+export * from '../../utils/isCallable.js';
+export * from '../../utils/getOutDirs.js';
+export * from '../../utils/hasPropertyGetter.js';
+export * from '../../utils/filesystemPathHandling.js';
+export * from '../../utils/urlToFile.js';
+export * from '../../shared/hooks/executeHook.js';
+export * from '../../utils/isPlainObject.js';
+export * from '../../utils/nodeEnv.js';

package/dist/esm/node/runtime/globalContext/loadImportBuild.d.ts

@@ -0,0 +1,18 @@
+export { loadImportBuild };
+export { setImportBuildGetters };
+type BuildGetters = null | {
+    pageFiles: () => Promise<Record<string, unknown>>;
+    clientManifest: () => Promise<Record<string, unknown>>;
+    pluginManifest: () => Promise<Record<string, unknown>>;
+};
+declare function setImportBuildGetters(getters: BuildGetters): void;
+declare function loadImportBuild(outDir?: string): Promise<{
+    pageFiles: Record<string, unknown>;
+    clientManifest: Record<string, unknown>;
+    pluginManifest: Record<string, unknown>;
+}>;
+declare global {
+    var __vike_buildGetters: undefined | {
+        getters: BuildGetters;
+    };
+}

package/dist/esm/node/runtime/globalContext/loadImportBuild.js

@@ -0,0 +1,27 @@
+export { loadImportBuild };
+export { setImportBuildGetters };
+import { loadServerBuild } from '@brillout/vite-plugin-import-build/loadServerBuild.js';
+import { assert, autoRetry } from '../utils.js';
+const buildGetters = (globalThis.__vike_buildGetters = globalThis.__vike_buildGetters || {
+    getters: null
+});
+function setImportBuildGetters(getters) {
+    buildGetters.getters = getters;
+}
+async function loadImportBuild(outDir) {
+    if (!buildGetters.getters) {
+        await loadServerBuild(outDir);
+        // Await dist/server/importBuild.cjs
+        await autoRetry(() => {
+            assert(buildGetters.getters);
+        }, 2000);
+        assert(buildGetters.getters);
+    }
+    const [pageFiles, clientManifest, pluginManifest] = await Promise.all([
+        buildGetters.getters.pageFiles(),
+        buildGetters.getters.clientManifest(),
+        buildGetters.getters.pluginManifest()
+    ]);
+    const buildEntries = { pageFiles, clientManifest, pluginManifest };
+    return buildEntries;
+}

package/dist/esm/node/runtime/globalContext.d.ts

@@ -0,0 +1,52 @@
+export { initGlobalContext };
+export { getGlobalContext };
+export { getViteDevServer };
+export { getViteConfig };
+export { setGlobalContext_viteDevServer };
+export { setGlobalContext_vitePreviewServer };
+export { setGlobalContext_viteConfig };
+export { getRuntimeManifest };
+import type { ViteManifest } from '../shared/ViteManifest.js';
+import type { ResolvedConfig, ViteDevServer, PreviewServer as VitePreviewServer } from 'vite';
+import { PluginManifest } from '../shared/assertPluginManifest.js';
+import type { ConfigVikeResolved } from '../../shared/ConfigVike.js';
+import { type RuntimeManifest } from '../shared/assertRuntimeManifest.js';
+type GlobalContext = {
+    baseServer: string;
+    baseAssets: null | string;
+    includeAssetsImportedByServer: boolean;
+    redirects: Record<string, string>;
+    trailingSlash: boolean;
+    disableUrlNormalization: boolean;
+} & ({
+    isProduction: false;
+    isPrerendering: false;
+    viteConfig: ResolvedConfig;
+    configVike: ConfigVikeResolved;
+    viteDevServer: ViteDevServer;
+    vitePreviewServer: null;
+    clientManifest: null;
+    pluginManifest: null;
+} | ({
+    isProduction: true;
+    clientManifest: ViteManifest;
+    pluginManifest: PluginManifest;
+    viteDevServer: null;
+    vitePreviewServer: null | VitePreviewServer;
+} & ({
+    isPrerendering: false;
+    viteConfig: null;
+    configVike: null;
+} | {
+    isPrerendering: true;
+    viteConfig: ResolvedConfig;
+    configVike: ConfigVikeResolved;
+})));
+declare function getGlobalContext(): GlobalContext;
+declare function setGlobalContext_viteDevServer(viteDevServer: ViteDevServer): void;
+declare function setGlobalContext_vitePreviewServer(vitePreviewServer: VitePreviewServer): void;
+declare function getViteDevServer(): ViteDevServer | null;
+declare function setGlobalContext_viteConfig(viteConfig: ResolvedConfig): void;
+declare function getViteConfig(): ResolvedConfig | null;
+declare function initGlobalContext(isPrerendering?: boolean, outDir?: string): Promise<void>;
+declare function getRuntimeManifest(configVike: ConfigVikeResolved): RuntimeManifest;

package/dist/esm/node/runtime/globalContext.js

@@ -0,0 +1,157 @@
+export { initGlobalContext };
+export { getGlobalContext };
+export { getViteDevServer };
+export { getViteConfig };
+export { setGlobalContext_viteDevServer };
+export { setGlobalContext_vitePreviewServer };
+export { setGlobalContext_viteConfig };
+export { getRuntimeManifest };
+import { assert, assertUsage, assertWarning, getGlobalObject, getNodeEnv, isPlainObject, objectAssign } from './utils.js';
+import { loadImportBuild } from './globalContext/loadImportBuild.js';
+import { setPageFiles } from '../../shared/getPageFiles.js';
+import { assertPluginManifest } from '../shared/assertPluginManifest.js';
+import { getConfigVike } from '../shared/getConfigVike.js';
+import { assertRuntimeManifest } from '../shared/assertRuntimeManifest.js';
+import pc from '@brillout/picocolors';
+const globalObject = getGlobalObject('globalContext.ts', {});
+function getGlobalContext() {
+    assert(globalObject.globalContext);
+    return globalObject.globalContext;
+}
+function setGlobalContext_viteDevServer(viteDevServer) {
+    if (globalObject.viteDevServer)
+        return;
+    assert(!globalObject.globalContext);
+    globalObject.viteDevServer = viteDevServer;
+}
+function setGlobalContext_vitePreviewServer(vitePreviewServer) {
+    if (globalObject.vitePreviewServer)
+        return;
+    assert(!globalObject.globalContext);
+    globalObject.vitePreviewServer = vitePreviewServer;
+}
+function getViteDevServer() {
+    return globalObject.viteDevServer ?? null;
+}
+function setGlobalContext_viteConfig(viteConfig) {
+    if (globalObject.viteConfig)
+        return;
+    assert(!globalObject.globalContext);
+    globalObject.viteConfig = viteConfig;
+}
+function getViteConfig() {
+    return globalObject.viteConfig ?? null;
+}
+async function initGlobalContext(isPrerendering = false, outDir) {
+    if (globalObject.globalContext)
+        return;
+    const { viteDevServer, vitePreviewServer, viteConfig } = globalObject;
+    assertNodeEnv(!!viteDevServer);
+    const isProduction = !viteDevServer;
+    if (!isProduction) {
+        assert(viteConfig);
+        assert(!isPrerendering);
+        assert(!vitePreviewServer);
+        const configVike = await getConfigVike(viteConfig);
+        const pluginManifest = getRuntimeManifest(configVike);
+        globalObject.globalContext = {
+            isProduction: false,
+            isPrerendering: false,
+            clientManifest: null,
+            pluginManifest: null,
+            viteDevServer,
+            vitePreviewServer: null,
+            viteConfig,
+            configVike,
+            baseServer: pluginManifest.baseServer,
+            baseAssets: pluginManifest.baseAssets,
+            includeAssetsImportedByServer: pluginManifest.includeAssetsImportedByServer,
+            redirects: pluginManifest.redirects,
+            trailingSlash: pluginManifest.trailingSlash,
+            disableUrlNormalization: pluginManifest.disableUrlNormalization
+        };
+    }
+    else {
+        const buildEntries = await loadImportBuild(outDir);
+        assertBuildEntries(buildEntries, isPrerendering ?? false);
+        const { pageFiles, clientManifest, pluginManifest } = buildEntries;
+        setPageFiles(pageFiles);
+        assertViteManifest(clientManifest);
+        assertPluginManifest(pluginManifest);
+        const globalContext = {
+            isProduction: true,
+            clientManifest,
+            pluginManifest,
+            viteDevServer: null,
+            vitePreviewServer: vitePreviewServer ?? null,
+            baseServer: pluginManifest.baseServer,
+            baseAssets: pluginManifest.baseAssets,
+            includeAssetsImportedByServer: pluginManifest.includeAssetsImportedByServer,
+            redirects: pluginManifest.redirects,
+            trailingSlash: pluginManifest.trailingSlash,
+            disableUrlNormalization: pluginManifest.disableUrlNormalization
+        };
+        if (isPrerendering) {
+            assert(viteConfig);
+            const configVike = await getConfigVike(viteConfig);
+            assert(configVike);
+            objectAssign(globalContext, {
+                isPrerendering: true,
+                viteConfig,
+                configVike
+            });
+            globalObject.globalContext = globalContext;
+        }
+        else {
+            objectAssign(globalContext, {
+                isPrerendering: false,
+                viteConfig: null,
+                configVike: null
+            });
+            globalObject.globalContext = globalContext;
+        }
+    }
+}
+function getRuntimeManifest(configVike) {
+    const { includeAssetsImportedByServer, baseServer, baseAssets, redirects, trailingSlash, disableUrlNormalization } = configVike;
+    const manifest = {
+        baseServer,
+        baseAssets,
+        includeAssetsImportedByServer,
+        redirects,
+        trailingSlash,
+        disableUrlNormalization
+    };
+    assertRuntimeManifest(manifest);
+    return manifest;
+}
+function assertBuildEntries(buildEntries, isPreRendering) {
+    const errMsg = [
+        `You are tyring to run`,
+        isPreRendering ? 'pre-rendering' : 'the server for production',
+        `but your app isn't built yet. Run ${pc.cyan('$ vite build')} before `,
+        isPreRendering ? 'pre-rendering.' : 'running the server.'
+    ].join(' ');
+    assertUsage(buildEntries, errMsg);
+}
+function assertViteManifest(manifest) {
+    assert(isPlainObject(manifest));
+    /* We should include these assertions but we don't as a workaround for PWA manifests: https://github.com/vikejs/vike/issues/769
+       Instead, we should rename the vite manifest e.g. with https://vitejs.dev/config/build-options.html#build-manifest
+    Object.entries(manifest)
+      // circumvent esbuild bug: esbuild adds a `default` key to JSON upon `require('./some.json')`.
+      .filter(([key]) => key !== 'default')
+      .forEach(([_, entry]) => {
+        assert(isPlainObject(entry))
+        assert(typeof entry.file === 'string')
+      })
+    */
+}
+function assertNodeEnv(hasViteDevServer) {
+    const nodeEnv = getNodeEnv();
+    if (nodeEnv === null || nodeEnv === 'test')
+        return;
+    const isDevNodeEnv = [undefined, '', 'dev', 'development'].includes(nodeEnv);
+    // calling Vite's createServer() is enough for hasViteDevServer to be true, even without actually adding Vite's development middleware to the server: https://github.com/vikejs/vike/issues/792#issuecomment-1516830759
+    assertWarning(hasViteDevServer === isDevNodeEnv, `Vite's development server was${hasViteDevServer ? '' : "n't"} instantiated while the environment is set to be a ${isDevNodeEnv ? 'development' : 'production'} environment by ${pc.cyan(`process.env.NODE_ENV === ${JSON.stringify(nodeEnv)}`)} which is contradictory, see https://vike.dev/NODE_ENV`, { onlyOnce: true });
+}

package/dist/esm/node/runtime/html/injectAssets/getHtmlTags.d.ts

@@ -0,0 +1,27 @@
+export { getHtmlTags };
+export type { HtmlTag };
+export type { PreloadFilter };
+export type { InjectFilterEntry };
+import type { PageContextInjectAssets } from '../injectAssets.js';
+import type { InjectToStream } from '../stream/react-streaming.js';
+import type { PageAsset } from '../../renderPage/getPageAssets.js';
+type PreloadFilter = null | ((assets: InjectFilterEntry[]) => InjectFilterEntry[]);
+type PreloadFilterInject = false | 'HTML_BEGIN' | 'HTML_END';
+/** Filter what assets vike injects in the HTML.
+ *
+ * https://vike.dev/injectFilter
+ */
+type InjectFilterEntry = {
+    src: string;
+    assetType: null | PageAsset['assetType'];
+    mediaType: null | PageAsset['mediaType'];
+    isEntry: boolean;
+    inject: PreloadFilterInject;
+};
+type HtmlTag = {
+    htmlTag: string | (() => string);
+    position: 'HTML_BEGIN' | 'HTML_END' | 'STREAM';
+};
+declare function getHtmlTags(pageContext: {
+    _isStream: boolean;
+} & PageContextInjectAssets, injectToStream: null | InjectToStream, injectFilter: PreloadFilter): Promise<HtmlTag[]>;

package/dist/esm/node/runtime/html/injectAssets/getHtmlTags.js

@@ -0,0 +1,155 @@
+export { getHtmlTags };
+import { assert, assertWarning, assertUsage, isObject, freezePartial } from '../../utils.js';
+import { serializePageContextClientSide } from '../serializePageContextClientSide.js';
+import { sanitizeJson } from './sanitizeJson.js';
+import { inferAssetTag, inferPreloadTag } from './inferHtmlTags.js';
+import { getViteDevScripts } from './getViteDevScripts.js';
+import { mergeScriptTags } from './mergeScriptTags.js';
+import { getGlobalContext } from '../../globalContext.js';
+import pc from '@brillout/picocolors';
+async function getHtmlTags(pageContext, injectToStream, injectFilter) {
+    assert([true, false].includes(pageContext._isHtmlOnly));
+    const isHtmlOnly = pageContext._isHtmlOnly;
+    const globalContext = getGlobalContext();
+    const { isProduction } = globalContext;
+    const injectJavaScriptDuringStream = !pageContext._pageContextPromise && !!injectToStream;
+    const pageAssets = await pageContext.__getPageAssets();
+    const stamp = Symbol('injectFilterEntryStamp');
+    const getInject = (asset) => {
+        if (!isProduction) {
+            return 'HTML_BEGIN';
+        }
+        if (asset.assetType === 'style' || asset.assetType === 'font') {
+            return 'HTML_BEGIN';
+        }
+        if (asset.assetType === 'script') {
+            return 'HTML_END';
+        }
+        return false;
+    };
+    const injectFilterEntries = pageAssets
+        .filter((asset) => {
+        if (asset.isEntry && asset.assetType === 'script') {
+            // We could in principle allow the user to change the position of <script> but we don't because of `getMergedScriptTag()`
+            return false;
+        }
+        if (isHtmlOnly && asset.assetType === 'script') {
+            return false;
+        }
+        return true;
+    })
+        .map((asset) => {
+        const inject = getInject(asset);
+        const entry = {
+            ...asset,
+            inject,
+            // @ts-ignore
+            [stamp]: true
+        };
+        return entry;
+    });
+    assertInjectFilterEntries(injectFilterEntries, stamp);
+    if (injectFilter && isProduction) {
+        Object.seal(injectFilterEntries); // `Object.seal()` instead of `Object.freeze()` to allow the user to `assets.sort()`
+        Object.values(injectFilterEntries).forEach((entry) => freezePartial(entry, { inject: (val) => val === false || val === 'HTML_BEGIN' || val === 'HTML_END' }));
+        const res = injectFilter(injectFilterEntries);
+        assertUsage(res === undefined, 'Wrong injectFilter() usage, see https://vike.dev/injectFilter');
+        assertInjectFilterUsage(injectFilterEntries, stamp);
+        injectFilterEntries.forEach((a) => {
+            /*
+            if (a.assetType === 'script' && a.isEntry) {
+              assertUsage(a.inject, `[injectFilter()] ${a.src} needs to be injected`)
+            }
+            */
+            if (a.assetType === 'style' && a.isEntry) {
+                // In development, Vite automatically inject styles, but we still inject `<link rel="stylesheet" type="text/css" href="${src}">` tags in order to avoid FOUC (flash of unstyled content).
+                //  - https://github.com/vitejs/vite/issues/2282
+                //  - https://github.com/vikejs/vike/issues/261
+                assertWarning(a.inject, `[injectFilter()] We recommend against not injecting ${a.src}`, {
+                    onlyOnce: true
+                });
+            }
+            if (!isHtmlOnly && a.assetType === 'script') {
+                assertWarning(a.inject, `[injectFilter()] We recommend against not preloading JavaScript (${a.src})`, {
+                    onlyOnce: true
+                });
+            }
+        });
+    }
+    const htmlTags = [];
+    // Non-JavaScript
+    for (const asset of injectFilterEntries) {
+        if (asset.assetType !== 'script' && asset.inject) {
+            const htmlTag = asset.isEntry ? inferAssetTag(asset) : inferPreloadTag(asset);
+            htmlTags.push({ htmlTag, position: asset.inject });
+        }
+    }
+    // JavaScript
+    const positionProd = injectJavaScriptDuringStream ? 'STREAM' : 'HTML_END';
+    const positionScript = !isProduction ? 'HTML_BEGIN' : positionProd;
+    const positionJsonData = !isProduction && !pageContext._pageContextPromise && !pageContext._isStream ? 'HTML_BEGIN' : positionProd;
+    const jsScript = await getMergedScriptTag(pageAssets, isProduction);
+    if (jsScript) {
+        htmlTags.push({
+            htmlTag: jsScript,
+            position: positionScript
+        });
+    }
+    for (const asset of injectFilterEntries) {
+        if (asset.assetType === 'script' && asset.inject) {
+            const htmlTag = asset.isEntry ? inferAssetTag(asset) : inferPreloadTag(asset);
+            const position = asset.inject === 'HTML_END' ? positionScript : asset.inject;
+            htmlTags.push({ htmlTag, position });
+        }
+    }
+    // `pageContext` JSON data
+    if (!isHtmlOnly) {
+        // Don't allow the user to manipulate with injectFilter(): injecting <script type="application/json"> before the stream can break the app when:
+        //  - using https://vike.dev/stream#initial-data-after-stream-end
+        //  - `pageContext` is modified during the stream, e.g. /examples/vue-pinia which uses https://vuejs.org/api/composition-api-lifecycle.html#onserverprefetch
+        // The <script> tags are handled separately by vike down below.
+        htmlTags.push({
+            // Needs to be called after `resolvePageContextPromise()`
+            htmlTag: () => getPageContextTag(pageContext),
+            position: positionJsonData
+        });
+    }
+    return htmlTags;
+}
+async function getMergedScriptTag(pageAssets, isProduction) {
+    const scriptAssets = pageAssets.filter((pageAsset) => pageAsset.isEntry && pageAsset.assetType === 'script');
+    const viteScripts = await getViteDevScripts();
+    const scriptTagsHtml = `${viteScripts}${scriptAssets.map((asset) => inferAssetTag(asset)).join('')}`;
+    const scriptTag = mergeScriptTags(scriptTagsHtml, isProduction);
+    return scriptTag;
+}
+function getPageContextTag(pageContext) {
+    const pageContextSerialized = sanitizeJson(serializePageContextClientSide(pageContext));
+    const htmlTag = `<script id="vike_pageContext" type="application/json">${pageContextSerialized}</script>`;
+    // @ts-expect-error
+    pageContext._pageContextHtmlTag = htmlTag;
+    return htmlTag;
+}
+function assertInjectFilterEntries(injectFilterEntries, stamp) {
+    try {
+        assertInjectFilterUsage(injectFilterEntries, stamp);
+    }
+    catch (err) {
+        if (err?.message.includes('[Wrong Usage]')) {
+            assert(false);
+        }
+        throw err;
+    }
+}
+function assertInjectFilterUsage(injectFilterEntries, stamp) {
+    injectFilterEntries.forEach((entry, i) => {
+        assertUsage(isObject(entry), `[injectFilter()] Entry ${i} isn't an object`);
+        assertUsage(typeof entry.src === 'string', `[injectFilter()] Entry ${i} is missing property ${pc.cyan('src')}`);
+        assertUsage(entry[stamp] === true, `[injectFilter()] Entry ${i} (${entry.src}) isn't the original object, see https://vike.dev/injectFilter`);
+        assert([false, 'HTML_BEGIN', 'HTML_END'].includes(entry.inject));
+        assert(entry.assetType === null || typeof entry.assetType === 'string');
+        assert(entry.mediaType === null || typeof entry.mediaType === 'string');
+        assert(typeof entry.isEntry === 'boolean');
+        assert(Object.keys(entry).length === 5);
+    });
+}

package/dist/esm/node/runtime/html/injectAssets/getViteDevScripts.d.ts

@@ -0,0 +1,2 @@
+export { getViteDevScripts };
+declare function getViteDevScripts(): Promise<string>;

package/dist/esm/node/runtime/html/injectAssets/getViteDevScripts.js

@@ -0,0 +1,22 @@
+export { getViteDevScripts };
+import { getGlobalContext } from '../../globalContext.js';
+import { assert, assertUsage } from '../../utils.js';
+import pc from '@brillout/picocolors';
+async function getViteDevScripts() {
+    const globalContext = getGlobalContext();
+    if (globalContext.isProduction) {
+        return '';
+    }
+    const { viteDevServer } = globalContext;
+    const fakeHtmlBegin = '<html> <head>'; // White space to test whether user is using a minifier
+    const fakeHtmlEnd = '</head><body></body></html>';
+    let fakeHtml = fakeHtmlBegin + fakeHtmlEnd;
+    fakeHtml = await viteDevServer.transformIndexHtml('/', fakeHtml);
+    assertUsage(!fakeHtml.includes('vite-plugin-pwa'), `The HTML transformer of ${pc.cyan('vite-plugin-pwa')} cannot be applied, see workaround at https://github.com/vikejs/vike/issues/388#issuecomment-1199280084`);
+    assertUsage(!fakeHtml.startsWith(fakeHtmlBegin.replace(' ', '')), 'Vite plugins that minify the HTML are not supported by vike, see https://github.com/vikejs/vike/issues/224');
+    assertUsage(fakeHtml.startsWith(fakeHtmlBegin) && fakeHtml.endsWith(fakeHtmlEnd), 'You are using a Vite Plugin that transforms the HTML in a way that conflicts with vike. Create a new GitHub ticket to discuss a solution.');
+    const viteInjection = fakeHtml.slice(fakeHtmlBegin.length, -1 * fakeHtmlEnd.length);
+    assert(viteInjection.includes('script'), { viteInjection });
+    const scriptTags = viteInjection;
+    return scriptTags;
+}

package/dist/esm/node/runtime/html/injectAssets/inferHtmlTags.d.ts

@@ -0,0 +1,7 @@
+export { inferAssetTag };
+export { inferPreloadTag };
+export { inferEarlyHintLink };
+import type { PageAsset } from '../../renderPage/getPageAssets.js';
+declare function inferPreloadTag(pageAsset: PageAsset): string;
+declare function inferAssetTag(pageAsset: PageAsset): string;
+declare function inferEarlyHintLink(pageAsset: PageAsset): string;

package/dist/esm/node/runtime/html/injectAssets/inferHtmlTags.js

@@ -0,0 +1,49 @@
+export { inferAssetTag };
+export { inferPreloadTag };
+export { inferEarlyHintLink };
+import { assert } from '../../utils.js';
+function inferPreloadTag(pageAsset) {
+    const { src, assetType, mediaType } = pageAsset;
+    const rel = getRel(pageAsset);
+    const attributes = [
+        `rel="${rel}"`,
+        `href="${src}"`,
+        !assetType ? null : `as="${assetType}"`,
+        !mediaType ? null : `type="${mediaType}"`,
+        // `crossorigin` is needed for fonts, see https://developer.mozilla.org/en-US/docs/Web/HTML/Link_types/preload#cors-enabled_fetches
+        !isCrossOrigin(pageAsset) ? null : 'crossorigin'
+    ]
+        .filter(Boolean)
+        .join(' ');
+    return `<link ${attributes}>`;
+}
+function inferAssetTag(pageAsset) {
+    const { src, assetType, mediaType } = pageAsset;
+    if (assetType === 'script') {
+        assert(mediaType === 'text/javascript');
+        // Using <script async> seems problematic:
+        //  - in dev: https://github.com/vikejs/vike/issues/524
+        //  - in prod: https://github.com/vikejs/vike/issues/567
+        return `<script type="module" src="${src}" defer></script>`;
+    }
+    if (assetType === 'style') {
+        return `<link rel="stylesheet" type="text/css" href="${src}">`;
+    }
+    assert(false, { pageAsset });
+}
+// We ignore crossorigin, it seems like Early Hints doesn't have a "crossorigin" property: https://github.com/vikejs/vike/issues/618#issuecomment-1415752222
+function inferEarlyHintLink(pageAsset) {
+    const { src, assetType } = pageAsset;
+    const rel = getRel(pageAsset);
+    return [`<${src}>`, `rel=${rel}`, !assetType ? null : `as=${assetType}`].filter(Boolean).join('; ');
+}
+function getRel({ assetType }) {
+    if (assetType === 'script') {
+        // Vite transpiles all browser-side JavaScript to ESM
+        return 'modulepreload';
+    }
+    return 'preload';
+}
+function isCrossOrigin({ src, assetType }) {
+    return assetType === 'font' || src.startsWith('http://') || src.startsWith('https://');
+}

package/dist/esm/node/runtime/html/injectAssets/injectAssets__public.d.ts

@@ -0,0 +1,2 @@
+export { injectAssets__public };
+declare function injectAssets__public(htmlString: string, pageContext: Record<string, unknown>): Promise<string>;

package/dist/esm/node/runtime/html/injectAssets/injectAssets__public.js

@@ -0,0 +1,29 @@
+export { injectAssets__public };
+import { assertUsage, assertWarning, castProp, hasProp } from '../../utils.js';
+import { injectHtmlTagsToString } from '../injectAssets.js';
+// TODO: remove this on next semver major
+async function injectAssets__public(htmlString, pageContext) {
+    assertWarning(false, '`_injectAssets()` is deprecated and will be removed.', { onlyOnce: true, showStackTrace: true });
+    assertUsage(typeof htmlString === 'string', '[injectAssets(htmlString, pageContext)]: Argument `htmlString` should be a string.', { showStackTrace: true });
+    assertUsage(pageContext, '[injectAssets(htmlString, pageContext)]: Argument `pageContext` is missing.', {
+        showStackTrace: true
+    });
+    const errMsg = (body) => '[injectAssets(htmlString, pageContext)]: ' +
+        body +
+        '. Make sure that `pageContext` is the object that Vike provided to your `render(pageContext)` hook.';
+    assertUsage(hasProp(pageContext, 'urlPathname', 'string'), errMsg('`pageContext.urlPathname` should be a string'), {
+        showStackTrace: true
+    });
+    assertUsage(hasProp(pageContext, '_pageId', 'string'), errMsg('`pageContext._pageId` should be a string'), {
+        showStackTrace: true
+    });
+    assertUsage(hasProp(pageContext, '__getPageAssets'), errMsg('`pageContext.__getPageAssets` is missing'), {
+        showStackTrace: true
+    });
+    assertUsage(hasProp(pageContext, '_passToClient', 'string[]'), errMsg('`pageContext._passToClient` is missing'), {
+        showStackTrace: true
+    });
+    castProp(pageContext, '__getPageAssets');
+    htmlString = await injectHtmlTagsToString([htmlString], pageContext, null);
+    return htmlString;
+}

package/dist/esm/node/runtime/html/injectAssets/injectHtmlTags.d.ts

@@ -0,0 +1,10 @@
+export { injectHtmlTags };
+export { createHtmlHeadIfMissing };
+export { injectAtOpeningTag };
+export { injectAtClosingTag };
+import type { HtmlTag } from './getHtmlTags.js';
+import type { InjectToStream } from '../stream/react-streaming.js';
+declare function injectHtmlTags(htmlString: string, htmlTags: HtmlTag[], injectToStream: null | InjectToStream): string;
+declare function injectAtOpeningTag(tag: 'head' | 'html' | '!doctype', htmlString: string, htmlFragment: string): string;
+declare function injectAtClosingTag(tag: 'body' | 'html', htmlString: string, htmlFragment: string): string;
+declare function createHtmlHeadIfMissing(htmlString: string): string;