@vuepress/client 2.0.0-beta.9 → 2.0.0-rc.1

package/dist/chunk-PEQEPZ75.js

@@ -0,0 +1,339 @@
+// src/composables/layouts.ts
+import { inject } from "vue";
+var layoutsSymbol = Symbol(
+  __VUEPRESS_DEV__ ? "layouts" : ""
+);
+var useLayouts = () => {
+  const layouts = inject(layoutsSymbol);
+  if (!layouts) {
+    throw new Error("useLayouts() is called without provider.");
+  }
+  return layouts;
+};
+
+// src/composables/pageData.ts
+import { inject as inject2, readonly } from "vue";
+var pageDataSymbol = Symbol(
+  __VUEPRESS_DEV__ ? "pageData" : ""
+);
+var pageDataEmpty = readonly({
+  key: "",
+  path: "",
+  title: "",
+  lang: "",
+  frontmatter: {},
+  headers: []
+});
+var usePageData = () => {
+  const pageData = inject2(pageDataSymbol);
+  if (!pageData) {
+    throw new Error("pageData() is called without provider.");
+  }
+  return pageData;
+};
+
+// src/composables/pageFrontmatter.ts
+import { inject as inject3 } from "vue";
+var pageFrontmatterSymbol = Symbol(
+  __VUEPRESS_DEV__ ? "pageFrontmatter" : ""
+);
+var usePageFrontmatter = () => {
+  const pageFrontmatter = inject3(pageFrontmatterSymbol);
+  if (!pageFrontmatter) {
+    throw new Error("usePageFrontmatter() is called without provider.");
+  }
+  return pageFrontmatter;
+};
+
+// src/composables/pageHead.ts
+import { inject as inject4 } from "vue";
+var pageHeadSymbol = Symbol(
+  __VUEPRESS_DEV__ ? "pageHead" : ""
+);
+var usePageHead = () => {
+  const pageHead = inject4(pageHeadSymbol);
+  if (!pageHead) {
+    throw new Error("usePageHead() is called without provider.");
+  }
+  return pageHead;
+};
+
+// src/composables/pageHeadTitle.ts
+import { inject as inject5 } from "vue";
+var pageHeadTitleSymbol = Symbol(
+  __VUEPRESS_DEV__ ? "pageHeadTitle" : ""
+);
+var usePageHeadTitle = () => {
+  const pageHeadTitle = inject5(pageHeadTitleSymbol);
+  if (!pageHeadTitle) {
+    throw new Error("usePageHeadTitle() is called without provider.");
+  }
+  return pageHeadTitle;
+};
+
+// src/composables/pageLang.ts
+import { inject as inject6 } from "vue";
+var pageLangSymbol = Symbol(
+  __VUEPRESS_DEV__ ? "pageLang" : ""
+);
+var usePageLang = () => {
+  const pageLang = inject6(pageLangSymbol);
+  if (!pageLang) {
+    throw new Error("usePageLang() is called without provider.");
+  }
+  return pageLang;
+};
+
+// src/composables/pageLayout.ts
+import { inject as inject7 } from "vue";
+var pageLayoutSymbol = Symbol(
+  __VUEPRESS_DEV__ ? "pageLayout" : ""
+);
+var usePageLayout = () => {
+  const pageLayout = inject7(pageLayoutSymbol);
+  if (!pageLayout) {
+    throw new Error("usePageLayout() is called without provider.");
+  }
+  return pageLayout;
+};
+
+// src/composables/pagesData.ts
+import { pagesData as pagesDataRaw } from "@internal/pagesData";
+import { ref } from "vue";
+var pagesData = ref(pagesDataRaw);
+var usePagesData = () => pagesData;
+
+// src/composables/routeLocale.ts
+import { inject as inject8 } from "vue";
+var routeLocaleSymbol = Symbol(
+  __VUEPRESS_DEV__ ? "routeLocale" : ""
+);
+var useRouteLocale = () => {
+  const routeLocale = inject8(routeLocaleSymbol);
+  if (!routeLocale) {
+    throw new Error("useRouteLocale() is called without provider.");
+  }
+  return routeLocale;
+};
+
+// src/composables/siteData.ts
+import { siteData as siteDataRaw } from "@internal/siteData";
+import { ref as ref2 } from "vue";
+var siteData = ref2(siteDataRaw);
+var useSiteData = () => siteData;
+if (__VUEPRESS_DEV__ && (import.meta.webpackHot || import.meta.hot)) {
+  __VUE_HMR_RUNTIME__.updateSiteData = (data) => {
+    siteData.value = data;
+  };
+}
+
+// src/composables/siteLocaleData.ts
+import { inject as inject9 } from "vue";
+var siteLocaleDataSymbol = Symbol(
+  __VUEPRESS_DEV__ ? "siteLocaleData" : ""
+);
+var useSiteLocaleData = () => {
+  const siteLocaleData = inject9(siteLocaleDataSymbol);
+  if (!siteLocaleData) {
+    throw new Error("useSiteLocaleData() is called without provider.");
+  }
+  return siteLocaleData;
+};
+
+// src/composables/updateHead.ts
+import { inject as inject10 } from "vue";
+var updateHeadSymbol = Symbol(
+  __VUEPRESS_DEV__ ? "updateHead" : ""
+);
+var useUpdateHead = () => {
+  const updateHead = inject10(updateHeadSymbol);
+  if (!updateHead) {
+    throw new Error("useUpdateHead() is called without provider.");
+  }
+  return updateHead;
+};
+
+// src/resolvers.ts
+import { dedupeHead, isString, resolveLocalePath } from "@vuepress/shared";
+import { reactive } from "vue";
+
+// src/constants.ts
+var LAYOUT_NAME_DEFAULT = "Layout";
+var LAYOUT_NAME_NOT_FOUND = "NotFound";
+
+// src/resolvers.ts
+var resolvers = reactive({
+  /**
+   * Resolve layouts component map
+   */
+  resolveLayouts: (clientConfigs) => clientConfigs.reduce(
+    (prev, item) => ({
+      ...prev,
+      ...item.layouts
+    }),
+    {}
+  ),
+  /**
+   * Resolve page data according to page key
+   */
+  resolvePageData: async (pageKey) => {
+    const pageDataResolver = pagesData.value[pageKey];
+    const pageData = await pageDataResolver?.();
+    return pageData ?? pageDataEmpty;
+  },
+  /**
+   * Resolve page frontmatter from page data
+   */
+  resolvePageFrontmatter: (pageData) => pageData.frontmatter,
+  /**
+   * Merge the head config in frontmatter and site locale
+   *
+   * Frontmatter should take priority over site locale
+   */
+  resolvePageHead: (headTitle, frontmatter, siteLocale) => {
+    const description = isString(frontmatter.description) ? frontmatter.description : siteLocale.description;
+    const head = [
+      ...Array.isArray(frontmatter.head) ? frontmatter.head : [],
+      ...siteLocale.head,
+      ["title", {}, headTitle],
+      ["meta", { name: "description", content: description }]
+    ];
+    return dedupeHead(head);
+  },
+  /**
+   * Resolve the content of page head title
+   *
+   * It would be used as the content of the `<title>` tag
+   */
+  resolvePageHeadTitle: (page, siteLocale) => [page.title, siteLocale.title].filter((item) => !!item).join(" | "),
+  /**
+   * Resolve page language from page data
+   *
+   * It would be used as the `lang` attribute of `<html>` tag
+   */
+  resolvePageLang: (page, siteLocale) => page.lang || siteLocale.lang || "en-US",
+  /**
+   * Resolve layout component of current page
+   */
+  resolvePageLayout: (page, layouts) => {
+    let layoutName;
+    if (page.path) {
+      const frontmatterLayout = page.frontmatter.layout;
+      if (isString(frontmatterLayout)) {
+        layoutName = frontmatterLayout;
+      } else {
+        layoutName = LAYOUT_NAME_DEFAULT;
+      }
+    } else {
+      layoutName = LAYOUT_NAME_NOT_FOUND;
+    }
+    return layouts[layoutName];
+  },
+  /**
+   * Resolve locale path according to route path and locales config
+   */
+  resolveRouteLocale: (locales, routePath) => resolveLocalePath(locales, routePath),
+  /**
+   * Resolve site data for specific locale
+   *
+   * It would merge the locales fields to the root fields
+   */
+  resolveSiteLocaleData: (site, routeLocale) => ({
+    ...site,
+    ...site.locales[routeLocale],
+    head: [
+      // when merging head, the locales head should be placed before root head
+      // to get higher priority
+      ...site.locales[routeLocale]?.head ?? [],
+      ...site.head ?? []
+    ]
+  })
+});
+
+// src/components/ClientOnly.ts
+import { defineComponent, onMounted, ref as ref3 } from "vue";
+var ClientOnly = defineComponent({
+  name: "ClientOnly",
+  setup(_, ctx) {
+    const isMounted = ref3(false);
+    onMounted(() => {
+      isMounted.value = true;
+    });
+    return () => isMounted.value ? ctx.slots.default?.() : null;
+  }
+});
+
+// src/components/Content.ts
+import { pagesComponents } from "@internal/pagesComponents";
+import { computed, defineComponent as defineComponent2, h } from "vue";
+var Content = defineComponent2({
+  // eslint-disable-next-line vue/no-reserved-component-names
+  name: "Content",
+  props: {
+    pageKey: {
+      type: String,
+      required: false,
+      default: ""
+    }
+  },
+  setup(props) {
+    const page = usePageData();
+    const pageComponent = computed(
+      () => pagesComponents[props.pageKey || page.value.key]
+    );
+    return () => pageComponent.value ? (
+      // use page component
+      h(pageComponent.value)
+    ) : (
+      // fallback content
+      h(
+        "div",
+        __VUEPRESS_DEV__ ? "Page does not exist. This is a fallback content." : "404 Not Found"
+      )
+    );
+  }
+});
+
+// src/helpers/defineClientConfig.ts
+var defineClientConfig = (clientConfig = {}) => clientConfig;
+
+// src/helpers/withBase.ts
+import { isLinkHttp, removeLeadingSlash } from "@vuepress/shared";
+var withBase = (url) => {
+  if (isLinkHttp(url))
+    return url;
+  return `${__VUEPRESS_BASE__}${removeLeadingSlash(url)}`;
+};
+
+export {
+  layoutsSymbol,
+  useLayouts,
+  pageDataSymbol,
+  pageDataEmpty,
+  usePageData,
+  pageFrontmatterSymbol,
+  usePageFrontmatter,
+  pageHeadSymbol,
+  usePageHead,
+  pageHeadTitleSymbol,
+  usePageHeadTitle,
+  pageLangSymbol,
+  usePageLang,
+  pageLayoutSymbol,
+  usePageLayout,
+  pagesData,
+  usePagesData,
+  routeLocaleSymbol,
+  useRouteLocale,
+  siteData,
+  useSiteData,
+  siteLocaleDataSymbol,
+  useSiteLocaleData,
+  updateHeadSymbol,
+  useUpdateHead,
+  resolvers,
+  ClientOnly,
+  Content,
+  defineClientConfig,
+  withBase
+};

package/dist/createVueAppFunction-YNGNKfE3.d.ts

@@ -0,0 +1,9 @@
+import { App } from 'vue';
+import { Router } from 'vue-router';
+
+type CreateVueAppFunction = () => Promise<{
+    app: App;
+    router: Router;
+}>;
+
+export type { CreateVueAppFunction as C };

package/dist/index.d.ts

@@ -0,0 +1,283 @@
+import { PageData, PageFrontmatter, HeadConfig, SiteData } from '@vuepress/shared';
+export { PageData, PageFrontmatter, PageHeader, SiteData } from '@vuepress/shared';
+import * as vue from 'vue';
+import { ComputedRef, InjectionKey, Ref, Component, App } from 'vue';
+import { Router, RouteMeta } from 'vue-router';
+export { C as CreateVueAppFunction } from './createVueAppFunction-YNGNKfE3.js';
+
+/**
+ * Ref wrapper of `Layouts`
+ */
+type LayoutsRef = ComputedRef<Layouts>;
+/**
+ * Injection key for layouts
+ */
+declare const layoutsSymbol: InjectionKey<LayoutsRef>;
+/**
+ * Returns layouts component map
+ */
+declare const useLayouts: () => LayoutsRef;
+
+/**
+ * Ref wrapper of `PageData`
+ */
+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>;
+
+/**
+ * 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
+ */
+declare const usePageFrontmatter: <T extends Record<any, any> = Record<string, unknown>>() => PageFrontmatterRef<T>;
+
+/**
+ * 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
+ */
+declare const usePageHead: () => PageHeadRef;
+
+/**
+ * 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
+ */
+declare const pageHeadTitleSymbol: InjectionKey<PageHeadTitleRef>;
+/**
+ * Returns the ref of the head title of current page
+ */
+declare const usePageHeadTitle: () => PageHeadTitleRef;
+
+/**
+ * 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 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 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 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;
+
+/**
+ * A util function to force update `<head>` of current page
+ */
+type UpdateHead = () => void;
+/**
+ * Injection key for `updateHead` util
+ */
+declare const updateHeadSymbol: InjectionKey<UpdateHead>;
+/**
+ * Returns the `updateHead` util
+ */
+declare const useUpdateHead: () => UpdateHead;
+
+type Layouts = Record<string, Component>;
+
+/**
+ * Configure vuepress client
+ */
+interface ClientConfig {
+    /**
+     * An enhance function to be called after vue app instance and
+     * vue-router instance has been created
+     */
+    enhance?: (context: {
+        app: App;
+        router: Router;
+        siteData: SiteDataRef;
+    }) => void | Promise<void>;
+    /**
+     * A function to be called inside the setup function of vue app
+     */
+    setup?: () => void;
+    /**
+     * Layout components
+     */
+    layouts?: Layouts;
+    /**
+     * Components to be placed directly into the root node of vue app
+     */
+    rootComponents?: Component[];
+}
+
+type PageRouteItem = [
+    name: string,
+    path: string,
+    meta: RouteMeta,
+    redirects: string[]
+];
+
+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<{}>>, {}, {}>;
+
+/**
+ * Markdown rendered content
+ */
+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.PublicProps, Readonly<vue.ExtractPropTypes<{
+    pageKey: {
+        type: StringConstructor;
+        required: false;
+        default: string;
+    };
+}>>, {
+    pageKey: string;
+}, {}>;
+
+/**
+ * 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;
+
+/**
+ * Resolver methods to get global computed
+ *
+ * Users can override corresponding method for advanced customization
+ */
+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;
+    resolveRouteLocale: (locales: SiteData['locales'], routePath: string) => RouteLocale;
+    resolveSiteLocaleData: (site: SiteData, routeLocale: RouteLocale) => SiteLocaleData;
+};
+
+export { type ClientConfig, ClientOnly, Content, type Layouts, type LayoutsRef, type PageDataRef, type PageFrontmatterRef, type PageHead, type PageHeadRef, type PageHeadTitle, type PageHeadTitleRef, type PageLang, type PageLangRef, type PageLayoutRef, type PageRouteItem, type PagesData, type PagesDataRef, type RouteLocale, type RouteLocaleRef, type SiteDataRef, type SiteLocaleData, type SiteLocaleDataRef, type 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 };

package/dist/index.js

@@ -0,0 +1,64 @@
+import {
+  ClientOnly,
+  Content,
+  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
+} from "./chunk-PEQEPZ75.js";
+export {
+  ClientOnly,
+  Content,
+  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
+};