@vuepress/client 2.0.0-rc.0 → 2.0.0-rc.10

package/dist/index.d.ts

@@ -1,35 +1,74 @@
-import { PageData, PageFrontmatter, HeadConfig, SiteData } from '@vuepress/shared';
-export { PageData, PageFrontmatter, PageHeader, SiteData } from '@vuepress/shared';
 import * as vue from 'vue';
-import { Component, App, ComputedRef, InjectionKey, Ref } from 'vue';
-import { Router, RouteMeta } from 'vue-router';
-
-declare const ClientOnly: vue.DefineComponent<{}, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
-    [key: string]: any;
-}>[] | null | undefined, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<{}>>, {}, {}>;
+import { Component, ComputedRef, Ref, App, VNode, SlotsType, InjectionKey } from 'vue';
+import { PageData, HeadConfig, PageFrontmatter, SiteData, SiteLocaleData } from '@vuepress/shared';
+export { HeadConfig, PageData, PageFrontmatter, PageHeader, SiteData, SiteLocaleData } from '@vuepress/shared';
+import { Router } from 'vue-router';
+export { RouteLocationNormalizedLoaded, Router, useRoute, useRouter } from 'vue-router';
+export { C as CreateVueAppFunction } from './createVueAppFunction-onJTVJru.js';
 
 /**
- * Markdown rendered content
+ * Name of the default layout
  */
-declare const Content: vue.DefineComponent<{
-    pageKey: {
-        type: StringConstructor;
-        required: false;
-        default: string;
-    };
-}, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
-    [key: string]: any;
-}>, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.VNodeProps & vue.AllowedComponentProps & vue.ComponentCustomProps, Readonly<vue.ExtractPropTypes<{
-    pageKey: {
-        type: StringConstructor;
-        required: false;
-        default: string;
-    };
-}>>, {
-    pageKey: string;
-}, {}>;
+declare const LAYOUT_NAME_DEFAULT = "Layout";
+/**
+ * Name of the 404 page layout
+ */
+declare const LAYOUT_NAME_NOT_FOUND = "NotFound";
+
+interface PageChunk {
+    comp: Component;
+    data: PageData;
+}
+type RouteMeta = Record<string, unknown>;
+interface Route<T extends RouteMeta = RouteMeta> {
+    loader: () => Promise<PageChunk>;
+    meta: T;
+}
+type Redirects = Record<string, string>;
+type Routes = Record<string, Route>;
 
-type Layouts = Record<string, Component>;
+interface Layouts {
+    [LAYOUT_NAME_DEFAULT]: Component;
+    [LAYOUT_NAME_NOT_FOUND]: Component;
+    [key: string]: Component;
+}
+type PageComponent = Component;
+type PageHead = HeadConfig[];
+type PageHeadTitle = string;
+type PageLang = string;
+type PageLayout = Component;
+type RoutePath = string;
+type RouteLocale = string;
+type LayoutsRef = ComputedRef<Layouts>;
+type PageComponentRef = ComputedRef<PageComponent>;
+type PageDataRef<T extends Record<any, any> = Record<never, never>> = ComputedRef<PageData<T>>;
+type PageFrontmatterRef<T extends Record<any, any> = Record<never, never>> = ComputedRef<PageFrontmatter<T>>;
+type PageHeadRef = ComputedRef<PageHead>;
+type PageHeadTitleRef = ComputedRef<PageHeadTitle>;
+type PageLangRef = ComputedRef<PageLang>;
+type PageLayoutRef = ComputedRef<PageLayout>;
+type RedirectsRef = Ref<Redirects>;
+type RoutePathRef = ComputedRef<RoutePath>;
+type RouteLocaleRef = ComputedRef<RouteLocale>;
+type RoutesRef = Ref<Routes>;
+type SiteDataRef = Ref<SiteData>;
+type SiteLocaleDataRef = ComputedRef<SiteLocaleData>;
+interface ClientData {
+    layouts: LayoutsRef;
+    pageComponent: PageComponentRef;
+    pageData: PageDataRef;
+    pageFrontmatter: PageFrontmatterRef;
+    pageHead: PageHeadRef;
+    pageHeadTitle: PageHeadTitleRef;
+    pageLang: PageLangRef;
+    pageLayout: PageLayoutRef;
+    redirects: RedirectsRef;
+    routePath: RoutePathRef;
+    routeLocale: RouteLocaleRef;
+    routes: RoutesRef;
+    siteData: SiteDataRef;
+    siteLocaleData: SiteLocaleDataRef;
+}
 
 /**
  * Configure vuepress client
@@ -51,197 +90,284 @@ interface ClientConfig {
     /**
      * Layout components
      */
-    layouts?: Layouts;
+    layouts?: Partial<Layouts>;
     /**
      * Components to be placed directly into the root node of vue app
      */
     rootComponents?: Component[];
 }
 
-type CreateVueAppFunction = () => Promise<{
-    app: App;
-    router: Router;
-}>;
-
-type PageRouteItem = [
-    name: string,
-    path: string,
-    meta: RouteMeta,
-    redirects: string[]
-];
-
-/**
- * Ref wrapper of `Layouts`
- */
-type LayoutsRef = ComputedRef<Layouts>;
-/**
- * Injection key for layouts
- */
-declare const layoutsSymbol: InjectionKey<LayoutsRef>;
+interface AutoLinkProps {
+    /**
+     * Pattern to determine if the link should be active, which has higher priority than `exact`
+     */
+    activeMatch?: string | RegExp;
+    /**
+     * The `aria-label` attribute
+     */
+    ariaLabel?: string;
+    /**
+     * Whether the link should be active only if the url is an exact match
+     */
+    exact?: boolean;
+    /**
+     * URL of the auto link
+     */
+    link: string;
+    /**
+     * The `rel` attribute
+     */
+    rel?: string;
+    /**
+     * The `target` attribute
+     */
+    target?: string;
+    /**
+     * Text of the auto link
+     */
+    text: string;
+}
 /**
- * Returns layouts component map
+ * Component to render a link automatically according to the link type
+ *
+ * - If the link is internal, it will be rendered as a `<RouteLink>`
+ * - If the link is external, it will be rendered as a normal `<a>` tag
  */
-declare const useLayouts: () => LayoutsRef;
+declare const AutoLink: vue.DefineComponent<{
+    /**
+     * Pattern to determine if the link should be active, which has higher priority than `exact`
+     */
+    activeMatch: {
+        type: (StringConstructor | RegExpConstructor)[];
+        default: string;
+    };
+    /**
+     * The `aria-label` attribute
+     */
+    ariaLabel: {
+        type: StringConstructor;
+        default: string;
+    };
+    /**
+     * Whether the link should be active only if the url is an exact match
+     */
+    exact: BooleanConstructor;
+    /**
+     * URL of the auto link
+     */
+    link: {
+        type: StringConstructor;
+        required: true;
+    };
+    /**
+     * The `rel` attribute
+     */
+    rel: {
+        type: StringConstructor;
+        default: string;
+    };
+    /**
+     * The `target` attribute
+     */
+    target: {
+        type: StringConstructor;
+        default: string;
+    };
+    /**
+     * Text of the auto link
+     */
+    text: {
+        type: StringConstructor;
+        required: true;
+    };
+}, () => VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}>, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    /**
+     * Pattern to determine if the link should be active, which has higher priority than `exact`
+     */
+    activeMatch: {
+        type: (StringConstructor | RegExpConstructor)[];
+        default: string;
+    };
+    /**
+     * The `aria-label` attribute
+     */
+    ariaLabel: {
+        type: StringConstructor;
+        default: string;
+    };
+    /**
+     * Whether the link should be active only if the url is an exact match
+     */
+    exact: BooleanConstructor;
+    /**
+     * URL of the auto link
+     */
+    link: {
+        type: StringConstructor;
+        required: true;
+    };
+    /**
+     * The `rel` attribute
+     */
+    rel: {
+        type: StringConstructor;
+        default: string;
+    };
+    /**
+     * The `target` attribute
+     */
+    target: {
+        type: StringConstructor;
+        default: string;
+    };
+    /**
+     * Text of the auto link
+     */
+    text: {
+        type: StringConstructor;
+        required: true;
+    };
+}>>, {
+    target: string;
+    activeMatch: string | RegExp;
+    ariaLabel: string;
+    exact: boolean;
+    rel: string;
+}, SlotsType<{
+    default?: (() => VNode[] | VNode) | undefined;
+    before?: (() => VNode[] | VNode | null) | undefined;
+    after?: (() => VNode[] | VNode | null) | undefined;
+}>>;
 
 /**
- * Ref wrapper of `PageData`
+ * Wrapper component that only renders its content on the client side and skips server side rendering
  */
-type PageDataRef<T extends Record<any, any> = Record<never, never>> = Ref<PageData<T>>;
-/**
- * Injection key for page data
- */
-declare const pageDataSymbol: InjectionKey<PageDataRef>;
-/**
- * Empty page data to be used as the fallback value
- */
-declare const pageDataEmpty: PageData;
-/**
- * Returns the ref of the data of current page
- */
-declare const usePageData: <T extends Record<any, any> = Record<never, never>>() => PageDataRef<T>;
+declare const ClientOnly: vue.DefineComponent<{}, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}>[] | null | undefined, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{}>>, {}, {}>;
 
 /**
- * Ref wrapper of `PageFrontmatter`
- */
-type PageFrontmatterRef<T extends Record<any, any> = Record<string, unknown>> = ComputedRef<PageFrontmatter<T>>;
-/**
- * Injection key for page frontmatter
- */
-declare const pageFrontmatterSymbol: InjectionKey<PageFrontmatterRef>;
-/**
- * Returns the ref of the frontmatter of current page
+ * Markdown rendered content
  */
-declare const usePageFrontmatter: <T extends Record<any, any> = Record<string, unknown>>() => PageFrontmatterRef<T>;
+declare const Content: vue.DefineComponent<{
+    path: {
+        type: StringConstructor;
+        required: false;
+        default: string;
+    };
+}, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}>, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    path: {
+        type: StringConstructor;
+        required: false;
+        default: string;
+    };
+}>>, {
+    path: string;
+}, {}>;
 
+interface RouteLinkProps {
+    /**
+     * Whether the link is active to have an active class
+     *
+     * Notice that the active status is not automatically determined according to the current route.
+     *
+     * @default false
+     */
+    active?: boolean;
+    /**
+     * The class to add when the link is active
+     *
+     * @default 'route-link-active'
+     */
+    activeClass?: string;
+    /**
+     * The route path to link to
+     */
+    to: string;
+}
 /**
- * Page head config, which would be used for generate html tags in `<head>`
- */
-type PageHead = HeadConfig[];
-/**
- * Ref wrapper of `PageHead`
- */
-type PageHeadRef = ComputedRef<PageHead>;
-/**
- * Injection key for page head
- */
-declare const pageHeadSymbol: InjectionKey<PageHeadRef>;
-/**
- * Returns the ref of the head config of current page
+ * Component to render a link to another route.
+ *
+ * It's similar to `RouterLink` in `vue-router`, but more lightweight.
+ *
+ * It's recommended to use `RouteLink` in VuePress.
  */
-declare const usePageHead: () => PageHeadRef;
+declare const RouteLink: vue.DefineComponent<{
+    /**
+     * The route path to link to
+     */
+    to: {
+        type: StringConstructor;
+        required: true;
+    };
+    /**
+     * Whether the link is active to have an active class
+     *
+     * Notice that the active status is not automatically determined according to the current route.
+     */
+    active: BooleanConstructor;
+    /**
+     * The class to add when the link is active
+     */
+    activeClass: {
+        type: StringConstructor;
+        default: string;
+    };
+}, () => VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}>, unknown, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    /**
+     * The route path to link to
+     */
+    to: {
+        type: StringConstructor;
+        required: true;
+    };
+    /**
+     * Whether the link is active to have an active class
+     *
+     * Notice that the active status is not automatically determined according to the current route.
+     */
+    active: BooleanConstructor;
+    /**
+     * The class to add when the link is active
+     */
+    activeClass: {
+        type: StringConstructor;
+        default: string;
+    };
+}>>, {
+    active: boolean;
+    activeClass: string;
+}, SlotsType<{
+    default: () => string | VNode | (string | VNode)[];
+}>>;
 
 /**
- * Page head title, which would be used as the content of `head > title` tag
- */
-type PageHeadTitle = string;
-/**
- * Ref wrapper of `PageHeadTitle`
- */
-type PageHeadTitleRef = ComputedRef<PageHeadTitle>;
-/**
- * Injection key for page head title
+ * Injection key for client data
  */
-declare const pageHeadTitleSymbol: InjectionKey<PageHeadTitleRef>;
+declare const clientDataSymbol: InjectionKey<ClientData>;
 /**
- * Returns the ref of the head title of current page
+ * Returns client data
  */
-declare const usePageHeadTitle: () => PageHeadTitleRef;
+declare const useClientData: () => ClientData;
 
-/**
- * Page language
- */
-type PageLang = string;
-/**
- * Ref wrapper of `PageLang`
- */
-type PageLangRef = ComputedRef<PageLang>;
-/**
- * Injection key for page language
- */
-declare const pageLangSymbol: InjectionKey<PageLangRef>;
-/**
- * Returns the ref of the language of current page
- */
+declare const useLayouts: () => LayoutsRef;
+declare const usePageComponent: () => PageComponentRef;
+declare const usePageData: <T extends Record<any, any> = Record<never, never>>() => PageDataRef<T>;
+declare const usePageFrontmatter: <T extends Record<any, any> = Record<string, unknown>>() => PageFrontmatterRef<T>;
+declare const usePageHead: () => PageHeadRef;
 declare const usePageLang: () => PageLangRef;
-
-/**
- * Ref wrapper of `PageLayout`
- */
-type PageLayoutRef = ComputedRef<Component>;
-/**
- * Injection key for page layout
- */
-declare const pageLayoutSymbol: InjectionKey<PageLayoutRef>;
-/**
- * Returns layout component of current page
- */
-declare const usePageLayout: () => ComputedRef<Component>;
-
-/**
- * Data resolvers of all pages
- *
- * The key is page key, and the value is an async function that
- * returns the page data
- */
-type PagesData = Record<string, (() => Promise<PageData>) | undefined>;
-/**
- * Ref wrapper of `PagesData`
- */
-type PagesDataRef = Ref<PagesData>;
-/**
- * Global pages data ref
- */
-declare const pagesData: PagesDataRef;
-/**
- * Returns the ref of data resolvers of all pages
- */
-declare const usePagesData: () => PagesDataRef;
-
-/**
- * Route locale path
- */
-type RouteLocale = string;
-/**
- * Ref wrapper of `RouteLocale`
- */
-type RouteLocaleRef = Readonly<Ref<RouteLocale>>;
-/**
- * Injection key for page route locale path
- */
-declare const routeLocaleSymbol: InjectionKey<RouteLocaleRef>;
-/**
- * Returns the ref of the route locale path of current page
- */
+declare const usePageLayout: () => PageLayoutRef;
+declare const useRedirects: () => RedirectsRef;
 declare const useRouteLocale: () => RouteLocaleRef;
-
-/**
- * Ref wrapper of `SiteData`
- */
-type SiteDataRef = Ref<SiteData>;
-/**
- * Global site data ref
- */
-declare const siteData: SiteDataRef;
-/**
- * Returns the ref of the site data
- */
+declare const useRoutePath: () => RoutePathRef;
+declare const useRoutes: () => RoutesRef;
 declare const useSiteData: () => SiteDataRef;
-
-/**
- * Site data of current locale
- */
-type SiteLocaleData = SiteData;
-/**
- * Ref wrapper of `SiteLocaleData`
- */
-type SiteLocaleDataRef = ComputedRef<SiteLocaleData>;
-/**
- * Injection key for site locale data
- */
-declare const siteLocaleDataSymbol: InjectionKey<SiteLocaleDataRef>;
-/**
- * Returns the ref of the site data of current locale
- */
 declare const useSiteLocaleData: () => SiteLocaleDataRef;
 
 /**
@@ -257,31 +383,45 @@ declare const updateHeadSymbol: InjectionKey<UpdateHead>;
  */
 declare const useUpdateHead: () => UpdateHead;
 
+interface ResolvedRoute<T extends RouteMeta = RouteMeta> extends Route<T> {
+    path: string;
+    notFound: boolean;
+}
 /**
- * A helper function to help you define vuepress client config file
+ * Resolve route with given path
  */
-declare const defineClientConfig: (clientConfig?: ClientConfig) => ClientConfig;
+declare const resolveRoute: <T extends RouteMeta = RouteMeta>(path: string, currentPath?: string) => ResolvedRoute<T>;
 
 /**
- * Prefix url with site base
+ * Resolve route path with given raw path
  */
-declare const withBase: (url: string) => string;
+declare const resolveRoutePath: (path: string, currentPath?: string) => string;
 
 /**
  * Resolver methods to get global computed
  *
  * Users can override corresponding method for advanced customization
+ *
+ * @experimental - This is an experimental API and may be changed in minor versions
  */
 declare const resolvers: {
     resolveLayouts: (clientConfigs: ClientConfig[]) => Layouts;
-    resolvePageData: (pageKey: string) => Promise<PageData>;
-    resolvePageFrontmatter: (pageData: PageData) => PageFrontmatter;
-    resolvePageHead: (headTitle: PageHeadTitle, frontmatter: PageFrontmatter, siteLocale: SiteLocaleData) => PageHead;
-    resolvePageHeadTitle: (page: PageData, siteLocale: SiteLocaleData) => PageHeadTitle;
-    resolvePageLang: (page: PageData, siteLocale: SiteLocaleData) => PageLang;
-    resolvePageLayout: (page: PageData, layouts: Layouts) => Component;
+    resolvePageHead: (pageHeadTitle: PageHeadTitle, pageFrontmatter: PageFrontmatter, siteLocaleDate: SiteLocaleData) => PageHead;
+    resolvePageHeadTitle: (pageData: PageData, siteLocaleDate: SiteLocaleData) => PageHeadTitle;
+    resolvePageLang: (pageData: PageData, siteLocaleData: SiteLocaleData) => PageLang;
+    resolvePageLayout: (pageData: PageData, layouts: Layouts) => PageLayout;
     resolveRouteLocale: (locales: SiteData['locales'], routePath: string) => RouteLocale;
-    resolveSiteLocaleData: (site: SiteData, routeLocale: RouteLocale) => SiteLocaleData;
+    resolveSiteLocaleData: ({ base, locales, ...siteData }: SiteData, routeLocale: RouteLocale) => SiteLocaleData;
 };
 
-export { ClientConfig, ClientOnly, Content, CreateVueAppFunction, Layouts, LayoutsRef, PageDataRef, PageFrontmatterRef, PageHead, PageHeadRef, PageHeadTitle, PageHeadTitleRef, PageLang, PageLangRef, PageLayoutRef, PageRouteItem, PagesData, PagesDataRef, RouteLocale, RouteLocaleRef, SiteDataRef, SiteLocaleData, SiteLocaleDataRef, UpdateHead, defineClientConfig, layoutsSymbol, pageDataEmpty, pageDataSymbol, pageFrontmatterSymbol, pageHeadSymbol, pageHeadTitleSymbol, pageLangSymbol, pageLayoutSymbol, pagesData, resolvers, routeLocaleSymbol, siteData, siteLocaleDataSymbol, updateHeadSymbol, useLayouts, usePageData, usePageFrontmatter, usePageHead, usePageHeadTitle, usePageLang, usePageLayout, usePagesData, useRouteLocale, useSiteData, useSiteLocaleData, useUpdateHead, withBase };
+/**
+ * A helper function to help you define vuepress client config file
+ */
+declare const defineClientConfig: (clientConfig?: ClientConfig) => ClientConfig;
+
+/**
+ * Prefix url with site base
+ */
+declare const withBase: (url: string) => string;
+
+export { AutoLink, type AutoLinkProps, type ClientConfig, type ClientData, ClientOnly, Content, type Layouts, type LayoutsRef, type PageChunk, type PageComponent, type PageComponentRef, type PageDataRef, type PageFrontmatterRef, type PageHead, type PageHeadRef, type PageHeadTitle, type PageHeadTitleRef, type PageLang, type PageLangRef, type PageLayout, type PageLayoutRef, type Redirects, type RedirectsRef, type ResolvedRoute, type Route, RouteLink, type RouteLinkProps, type RouteLocale, type RouteLocaleRef, type RouteMeta, type RoutePath, type RoutePathRef, type Routes, type RoutesRef, type SiteDataRef, type SiteLocaleDataRef, type UpdateHead, clientDataSymbol, defineClientConfig, resolveRoute, resolveRoutePath, resolvers, updateHeadSymbol, useClientData, useLayouts, usePageComponent, usePageData, usePageFrontmatter, usePageHead, usePageLang, usePageLayout, useRedirects, useRouteLocale, useRoutePath, useRoutes, useSiteData, useSiteLocaleData, useUpdateHead, withBase };

package/dist/index.js

@@ -1,62 +1,58 @@
 import {
+  AutoLink,
   ClientOnly,
   Content,
+  RouteLink,
+  clientDataSymbol,
   defineClientConfig,
-  layoutsSymbol,
-  pageDataEmpty,
-  pageDataSymbol,
-  pageFrontmatterSymbol,
-  pageHeadSymbol,
-  pageHeadTitleSymbol,
-  pageLangSymbol,
-  pageLayoutSymbol,
-  pagesData,
+  resolveRoute,
+  resolveRoutePath,
   resolvers,
-  routeLocaleSymbol,
-  siteData,
-  siteLocaleDataSymbol,
   updateHeadSymbol,
+  useClientData,
   useLayouts,
+  usePageComponent,
   usePageData,
   usePageFrontmatter,
   usePageHead,
-  usePageHeadTitle,
   usePageLang,
   usePageLayout,
-  usePagesData,
+  useRedirects,
+  useRoute,
   useRouteLocale,
+  useRoutePath,
+  useRouter,
+  useRoutes,
   useSiteData,
   useSiteLocaleData,
   useUpdateHead,
   withBase
-} from "./chunk-DHNSDB55.js";
+} from "./chunk-GA5RAHE7.js";
 export {
+  AutoLink,
   ClientOnly,
   Content,
+  RouteLink,
+  clientDataSymbol,
   defineClientConfig,
-  layoutsSymbol,
-  pageDataEmpty,
-  pageDataSymbol,
-  pageFrontmatterSymbol,
-  pageHeadSymbol,
-  pageHeadTitleSymbol,
-  pageLangSymbol,
-  pageLayoutSymbol,
-  pagesData,
+  resolveRoute,
+  resolveRoutePath,
   resolvers,
-  routeLocaleSymbol,
-  siteData,
-  siteLocaleDataSymbol,
   updateHeadSymbol,
+  useClientData,
   useLayouts,
+  usePageComponent,
   usePageData,
   usePageFrontmatter,
   usePageHead,
-  usePageHeadTitle,
   usePageLang,
   usePageLayout,
-  usePagesData,
+  useRedirects,
+  useRoute,
   useRouteLocale,
+  useRoutePath,
+  useRouter,
+  useRoutes,
   useSiteData,
   useSiteLocaleData,
   useUpdateHead,