vitepress 2.0.0-alpha.2 → 2.0.0-alpha.21

package/dist/client/app/utils.js

@@ -1,119 +1,86 @@
-import { h, onMounted, onUnmounted, shallowRef } from 'vue';
-import { EXTERNAL_URL_RE, inBrowser, sanitizeFileName } from '../shared';
-import { siteDataRef } from './data';
-export { escapeHtml as _escapeHtml, inBrowser } from '../shared';
+import { EXTERNAL_URL_RE, RELATIVE_BASE_SENTINEL, escapeHtml, inBrowser, isRelativeBase, joinPath, pageChunkPath, sanitizeFileName } from "../shared.js";
+import { siteDataRef } from "./data.js";
+import { h, isVNode, onMounted, shallowRef } from "vue";
+import { tryOnUnmounted } from "@vueuse/core";
+//#region src/client/app/utils.ts
+let resolvedBase;
 /**
- * Join two paths by resolving the slash collision.
- */
-export function joinPath(base, path) {
-    return `${base}${path}`.replace(/\/+/g, '/');
+* Runtime base path used by the app.
+*
+* Usually this is the configured site base.
+*
+* For a relative base (`'./'`), the mount point is unknown at build time, so:
+* - SSR: uses `RELATIVE_BASE_SENTINEL` (for per-page URL relativization)
+* - dev browser: uses `'/'` (dev server always mounts at root)
+* - prod browser: resolves from the page's `__VP_SITE_ROOT__`
+*/
+function runtimeBase() {
+	if (resolvedBase === void 0) {
+		const base = siteDataRef.value.base;
+		if (!isRelativeBase(base)) return resolvedBase = base;
+		if (!inBrowser) return resolvedBase = RELATIVE_BASE_SENTINEL;
+		if (import.meta.env.DEV) return resolvedBase = "/";
+		const root = window.__VP_SITE_ROOT__;
+		resolvedBase = root ? decodeURIComponent(new URL(root, location.href).pathname) : "/";
+	}
+	return resolvedBase;
 }
 /**
- * Append base to internal (non-relative) urls
- */
-export function withBase(path) {
-    return EXTERNAL_URL_RE.test(path) || !path.startsWith('/')
-        ? path
-        : joinPath(siteDataRef.value.base, path);
+* Prepend base to internal (non-relative) urls
+*/
+function withBase(path) {
+	return EXTERNAL_URL_RE.test(path) || !path.startsWith("/") ? path : joinPath(runtimeBase(), path);
 }
 /**
- * Converts a url path to the corresponding js chunk filename.
- */
-export function pathToFile(path) {
-    let pagePath = path.replace(/\.html$/, '');
-    pagePath = decodeURIComponent(pagePath);
-    pagePath = pagePath.replace(/\/$/, '/index'); // /foo/ -> /foo/index
-    if (import.meta.env.DEV) {
-        // always force re-fetch content in dev
-        pagePath += `.md?t=${Date.now()}`;
-    }
-    else {
-        // in production, each .md file is built into a .md.js file following
-        // the path conversion scheme.
-        // /foo/bar.html -> ./foo_bar.md
-        if (inBrowser) {
-            const base = import.meta.env.BASE_URL;
-            pagePath =
-                sanitizeFileName(pagePath.slice(base.length).replace(/\//g, '_') || 'index') + '.md';
-            // client production build needs to account for page hash, which is
-            // injected directly in the page's html
-            let pageHash = __VP_HASH_MAP__[pagePath.toLowerCase()];
-            if (!pageHash) {
-                pagePath = pagePath.endsWith('_index.md')
-                    ? pagePath.slice(0, -9) + '.md'
-                    : pagePath.slice(0, -3) + '_index.md';
-                pageHash = __VP_HASH_MAP__[pagePath.toLowerCase()];
-            }
-            if (!pageHash)
-                return null;
-            pagePath = `${base}${__ASSETS_DIR__}/${pagePath}.${pageHash}.js`;
-        }
-        else {
-            // ssr build uses much simpler name mapping
-            pagePath = `./${sanitizeFileName(pagePath.slice(1).replace(/\//g, '_'))}.md.js`;
-        }
-    }
-    return pagePath;
+* Converts a url path to the corresponding js chunk filename.
+*/
+function pathToFile(path) {
+	let pagePath = path.replace(/\.html$/, "");
+	pagePath = decodeURIComponent(pagePath);
+	pagePath = pagePath.replace(/\/$/, "/index");
+	if (import.meta.env.DEV) pagePath += `.md?t=${Date.now()}`;
+	else if (inBrowser) {
+		const base = runtimeBase();
+		if (pagePath + "/" === base) pagePath = base;
+		if (!pagePath.startsWith(base)) return null;
+		pagePath = sanitizeFileName(pagePath.slice(base.length).replace(/\//g, "_") || "index") + ".md";
+		let pageHash = __VP_HASH_MAP__[pagePath.toLowerCase()];
+		if (!pageHash) {
+			pagePath = pagePath.endsWith("_index.md") ? pagePath.slice(0, -9) + ".md" : pagePath.slice(0, -3) + "_index.md";
+			pageHash = __VP_HASH_MAP__[pagePath.toLowerCase()];
+		}
+		if (!pageHash) return null;
+		pagePath = `${__ASSETS_BASE__ || base}${__ASSETS_DIR__}/${pageChunkPath(pagePath, pageHash)}`;
+	} else pagePath = `./${sanitizeFileName(pagePath.slice(1).replace(/\//g, "_"))}.md.js`;
+	return pagePath;
 }
-export let contentUpdatedCallbacks = [];
+let contentUpdatedCallbacks = [];
 /**
- * Register callback that is called every time the markdown content is updated
- * in the DOM.
- */
-export function onContentUpdated(fn) {
-    contentUpdatedCallbacks.push(fn);
-    onUnmounted(() => {
-        contentUpdatedCallbacks = contentUpdatedCallbacks.filter((f) => f !== fn);
-    });
+* Register callback that is called every time the markdown content is updated
+* in the DOM.
+*/
+function onContentUpdated(fn) {
+	contentUpdatedCallbacks.push(fn);
+	tryOnUnmounted(() => {
+		contentUpdatedCallbacks = contentUpdatedCallbacks.filter((f) => f !== fn);
+	});
 }
-export function defineClientComponent(loader, args, cb) {
-    return {
-        setup() {
-            const comp = shallowRef();
-            onMounted(async () => {
-                let res = await loader();
-                // interop module default
-                if (res && (res.__esModule || res[Symbol.toStringTag] === 'Module')) {
-                    res = res.default;
-                }
-                comp.value = res;
-                await cb?.();
-            });
-            return () => (comp.value ? h(comp.value, ...(args ?? [])) : null);
-        }
-    };
-}
-export function getScrollOffset() {
-    let scrollOffset = siteDataRef.value.scrollOffset;
-    let offset = 0;
-    let padding = 24;
-    if (typeof scrollOffset === 'object' && 'padding' in scrollOffset) {
-        padding = scrollOffset.padding;
-        scrollOffset = scrollOffset.selector;
-    }
-    if (typeof scrollOffset === 'number') {
-        offset = scrollOffset;
-    }
-    else if (typeof scrollOffset === 'string') {
-        offset = tryOffsetSelector(scrollOffset, padding);
-    }
-    else if (Array.isArray(scrollOffset)) {
-        for (const selector of scrollOffset) {
-            const res = tryOffsetSelector(selector, padding);
-            if (res) {
-                offset = res;
-                break;
-            }
-        }
-    }
-    return offset;
-}
-function tryOffsetSelector(selector, padding) {
-    const el = document.querySelector(selector);
-    if (!el)
-        return 0;
-    const bot = el.getBoundingClientRect().bottom;
-    if (bot < 0)
-        return 0;
-    return bot + padding;
+function defineClientComponent(loader, args, cb) {
+	return { setup(_, { slots }) {
+		const comp = shallowRef();
+		onMounted(async () => {
+			let res = await loader();
+			if (res && (res.__esModule || res[Symbol.toStringTag] === "Module")) res = res.default;
+			comp.value = res;
+			await cb?.();
+		});
+		return () => {
+			if (!comp.value) return null;
+			const props = args?.[0];
+			if ((!args || args.length < 2) && (props == null || typeof props === "object" && !Array.isArray(props) && !isVNode(props))) return h(comp.value, props, slots);
+			return h(comp.value, ...args ?? []);
+		};
+	} };
 }
+//#endregion
+export { escapeHtml as _escapeHtml, contentUpdatedCallbacks, defineClientComponent, inBrowser, joinPath, onContentUpdated, pathToFile, runtimeBase, withBase };

package/dist/client/index.d.ts

@@ -1,138 +1,22 @@
-import * as vue from 'vue';
-import { Component, InjectionKey, Ref, App, AsyncComponentLoader } from 'vue';
-import { PageData, Awaitable, SiteData } from '../../types/shared.js';
-export { HeadConfig, Header, PageData, SiteData } from '../../types/shared.js';
-
-declare const inBrowser: boolean;
-/**
- * @internal
- */
-declare function escapeHtml(str: string): string;
-
-interface Route {
-    path: string;
-    hash: string;
-    query: string;
-    data: PageData;
-    component: Component | null;
+import { ClientOnly } from "./app/components/ClientOnly.js";
+import { Content } from "./app/components/Content.js";
+import { Route, VitePressData, escapeHtml, inBrowser } from "./shared.js";
+import { useIcon } from "./app/composables/icon.js";
+import { dataSymbol, useData } from "./app/data.js";
+import { Router, useRoute, useRouter } from "./app/router.js";
+import { EnhanceAppContext, Theme } from "./app/theme.js";
+import { defineClientComponent, onContentUpdated, withBase } from "./app/utils.js";
+import { HeadConfig, Header, PageData, PageData as PageData$1, SiteData } from "../../types/shared.js";
+//#region src/client/index.d.ts
+declare module 'vue' {
+  interface GlobalComponents {
+    ClientOnly: typeof ClientOnly;
+    Content: typeof Content;
+  }
+  interface ComponentCustomProperties {
+    $frontmatter: PageData$1['frontmatter'];
+    $params: PageData$1['params'];
+  }
 }
-interface Router {
-    /**
-     * Current route.
-     */
-    route: Route;
-    /**
-     * Navigate to a new URL.
-     */
-    go: (to: string, options?: {
-        initialLoad?: boolean;
-        smoothScroll?: boolean;
-    }) => Promise<void>;
-    /**
-     * Called before the route changes. Return `false` to cancel the navigation.
-     */
-    onBeforeRouteChange?: (to: string) => Awaitable<void | boolean>;
-    /**
-     * Called before the page component is loaded (after the history state is
-     * updated). Return `false` to cancel the navigation.
-     */
-    onBeforePageLoad?: (to: string) => Awaitable<void | boolean>;
-    /**
-     * Called after the page component is loaded (before the page component is updated).
-     */
-    onAfterPageLoad?: (to: string) => Awaitable<void>;
-    /**
-     * Called after the route changes.
-     */
-    onAfterRouteChange?: (to: string) => Awaitable<void>;
-}
-declare function useRouter(): Router;
-declare function useRoute(): Route;
-
-declare const dataSymbol: InjectionKey<VitePressData>;
-interface VitePressData<T = any> {
-    /**
-     * Site-level metadata
-     */
-    site: Ref<SiteData<T>>;
-    /**
-     * themeConfig from .vitepress/config.js
-     */
-    theme: Ref<T>;
-    /**
-     * Page-level metadata
-     */
-    page: Ref<PageData>;
-    /**
-     * page frontmatter data
-     */
-    frontmatter: Ref<PageData['frontmatter']>;
-    /**
-     * dynamic route params
-     */
-    params: Ref<PageData['params']>;
-    title: Ref<string>;
-    description: Ref<string>;
-    lang: Ref<string>;
-    dir: Ref<string>;
-    localeIndex: Ref<string>;
-    isDark: Ref<boolean>;
-    /**
-     * Current location hash
-     */
-    hash: Ref<string>;
-}
-declare function useData<T = any>(): VitePressData<T>;
-
-interface EnhanceAppContext {
-    app: App;
-    router: Router;
-    siteData: Ref<SiteData>;
-}
-interface Theme {
-    Layout?: Component;
-    enhanceApp?: (ctx: EnhanceAppContext) => Awaitable<void>;
-    extends?: Theme;
-    /**
-     * @deprecated can be replaced by wrapping layout component
-     */
-    setup?: () => void;
-    /**
-     * @deprecated Render not found page by checking `useData().page.value.isNotFound` in Layout instead.
-     */
-    NotFound?: Component;
-}
-
-/**
- * Append base to internal (non-relative) urls
- */
-declare function withBase(path: string): string;
-/**
- * Register callback that is called every time the markdown content is updated
- * in the DOM.
- */
-declare function onContentUpdated(fn: () => any): void;
-declare function defineClientComponent(loader: AsyncComponentLoader, args?: any[], cb?: () => Awaitable<void>): {
-    setup(): () => vue.VNode<vue.RendererNode, vue.RendererElement, {
-        [key: string]: any;
-    }> | null;
-};
-declare function getScrollOffset(): number;
-
-declare const Content: vue.DefineComponent<vue.ExtractPropTypes<{
-    as: {
-        type: (ObjectConstructor | StringConstructor)[];
-        default: string;
-    };
-}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
-    [key: string]: any;
-}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
-    as: {
-        type: (ObjectConstructor | StringConstructor)[];
-        default: string;
-    };
-}>> & Readonly<{}>, {
-    as: string | Record<string, any>;
-}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
-
-export { Content, type EnhanceAppContext, type Route, type Router, type Theme, type VitePressData, escapeHtml as _escapeHtml, dataSymbol, defineClientComponent, getScrollOffset, inBrowser, onContentUpdated, useData, useRoute, useRouter, withBase };
+//#endregion
+export { ClientOnly, Content, type EnhanceAppContext, type HeadConfig, type Header, type PageData, type Route, type Router, type SiteData, type Theme, type VitePressData, escapeHtml as _escapeHtml, dataSymbol, defineClientComponent, inBrowser, onContentUpdated, useData, useIcon, useRoute, useRouter, withBase };

package/dist/client/index.js

@@ -1,9 +1,8 @@
-// exports in this file are exposed to themes and md files via 'vitepress'
-// so the user can do `import { useRoute, useData } from 'vitepress'`
-// composables
-export { dataSymbol, useData } from './app/data';
-export { useRoute, useRouter } from './app/router';
-// utilities
-export { _escapeHtml, defineClientComponent, getScrollOffset, inBrowser, onContentUpdated, withBase } from './app/utils';
-// components
-export { Content } from './app/components/Content';
+import { ClientOnly } from "./app/components/ClientOnly.js";
+import { escapeHtml, inBrowser } from "./shared.js";
+import { dataSymbol, useData } from "./app/data.js";
+import { defineClientComponent, onContentUpdated, withBase } from "./app/utils.js";
+import { Content } from "./app/components/Content.js";
+import { useIcon } from "./app/composables/icon.js";
+import { useRoute, useRouter } from "./app/router.js";
+export { ClientOnly, Content, escapeHtml as _escapeHtml, dataSymbol, defineClientComponent, inBrowser, onContentUpdated, useData, useIcon, useRoute, useRouter, withBase };

package/dist/client/shared.d.ts

@@ -0,0 +1,88 @@
+import { AdditionalConfig, AdditionalConfigDict, AdditionalConfigLoader, Awaitable, CodeCopyButtonOptions, ContainerOptions, DefaultTheme, HeadConfig, HeadConfig as HeadConfig$1, Header, LocaleConfig, LocaleSpecificConfig, MarkdownEnv, MarkdownLocaleOptions, PageData, PageData as PageData$1, PageDataPayload, Route, SSGContext, SiteData, SiteData as SiteData$1, VitePressData } from "../../types/shared.js";
+//#region src/client/shared.d.ts
+export declare const EXTERNAL_URL_RE: RegExp;
+export declare const APPEARANCE_KEY = "vitepress-theme-appearance";
+/**
+ * Parses a fully qualified `collection:name` icon name, corresponding to
+ * the `vpi-<collection>-<name>` class. Returns null for anything else,
+ * keeping malformed input out of generated selectors and class attributes.
+ */
+export declare function parseIconName(name: string): {
+  collection: string;
+  icon: string;
+} | null;
+/**
+ * Placeholder prepended to SSR-emitted URLs when base is relative, later
+ * replaced with each page's `../` prefix back to the site root.
+ */
+export declare const RELATIVE_BASE_SENTINEL = "/__VP_BASE__/";
+export declare function isRelativeBase(base: string): boolean;
+/**
+ * The ../-prefix that leads from `relativePath`'s directory back to the
+ * site root ('./' for root-level pages).
+ */
+export declare function relativePathToRoot(relativePath: string): string;
+/**
+ * Join two paths, collapsing slash collisions but keeping the `//` that
+ * follows a protocol.
+ */
+export declare function joinPath(base: string, path: string): string;
+export declare const VP_SOURCE_KEY = "[VP_SOURCE]";
+export declare const inBrowser: boolean;
+export declare const notFoundPageData: PageData$1;
+export declare function isActive(currentPath: string, currentHash: string, matchPath: string, asRegex?: boolean, skipHashCheck?: boolean): boolean;
+export declare function normalize(path: string): string;
+export declare function isExternal(path: string): boolean;
+export declare function getLocaleForPath(siteData: SiteData$1 | undefined, relativePath: string): string;
+/**
+ * Resolves the site data for a route, layering the matched locale and
+ * additional configs over the root config.
+ */
+export declare function resolveSiteDataByRoute(siteData: SiteData$1, relativePath: string, filePath?: string): SiteData$1;
+/**
+ * Create the page title string based on config.
+ */
+export declare function createTitle(siteData: SiteData$1, pageData: PageData$1): string;
+export declare function mergeHead(...headArrays: HeadConfig$1[][]): HeadConfig$1[];
+export declare function sanitizeFileName(name: string): string;
+/**
+ * Output path of a page's client chunk relative to `assetsDir`, from its hash
+ * map entry. The entry is the chunk's hash, prefixed with the subdirectory the
+ * build put the chunk in when `assetsShards` is set (`<shard>/<hash>`), so the
+ * client never has to guess the layout.
+ */
+export declare function pageChunkPath(pageName: string, hashEntry: string, ext?: string): string;
+export declare function slash(p: string): string;
+export declare function treatAsHtml(filename: string): boolean;
+/**
+ * Default `tokenize` of the local search. It splits on spaces and punctuation
+ * like MiniSearch does, and additionally segments the runs of Chinese or
+ * Japanese characters inside those words, as they are not separated by spaces.
+ * Everything else is kept as MiniSearch would.
+ *
+ * It is used both when building the index and when searching in the browser.
+ * A browser without `Intl.Segmenter` (e.g. Firefox < 125) falls back to the
+ * plain split, which can't match multi-word queries against an index that was
+ * built with segmentation.
+ *
+ * @internal
+ */
+export declare function tokenizeSearchText(text: string): string[];
+export declare function escapeRegExp(str: string): string;
+/**
+ * @internal
+ */
+export declare function escapeHtml(str: string): string;
+/**
+ * Creates a readonly proxy behaving like a deep merge of the given layers,
+ * without mutating them. Earlier layers take precedence.
+ */
+export declare function stackView<T extends ObjectType>(..._layers: Partial<T>[]): T;
+export declare namespace stackView {
+  var unpack: <T>(obj: T) => T[] | undefined;
+}
+type ObjectType = Record<PropertyKey, any>;
+export declare function isObject(value: unknown): value is ObjectType;
+export declare function isShell(lang: string): boolean;
+//#endregion
+export type { AdditionalConfig, AdditionalConfigDict, AdditionalConfigLoader, Awaitable, CodeCopyButtonOptions, ContainerOptions, DefaultTheme, HeadConfig, Header, LocaleConfig, LocaleSpecificConfig, MarkdownEnv, MarkdownLocaleOptions, PageData, PageDataPayload, Route, SSGContext, SiteData, VitePressData };