@vuepress/client 2.0.0-beta.5 → 2.0.0-beta.50

package/dist/app.js

@@ -0,0 +1,286 @@
+import {
+  ClientOnly,
+  Content,
+  Vuepress,
+  pageData,
+  pageFrontmatterSymbol,
+  pageHeadSymbol,
+  pageHeadTitleSymbol,
+  pageLangSymbol,
+  resolvers,
+  routeLocaleSymbol,
+  siteData,
+  siteLocaleDataSymbol,
+  updateHeadSymbol,
+  usePageHead,
+  usePageLang,
+  withBase
+} from "./chunk-V3MKNX2O.js";
+
+// src/app.ts
+import { clientConfigs } from "@internal/clientConfigs";
+import { createApp, createSSRApp, h } from "vue";
+import { RouterView } from "vue-router";
+
+// src/router.ts
+import { pagesComponents } from "@internal/pagesComponents";
+import { removeEndingSlash } from "@vuepress/shared";
+import {
+  createMemoryHistory,
+  createRouter,
+  createWebHistory,
+  START_LOCATION
+} from "vue-router";
+
+// src/routes.ts
+import { pagesRoutes } from "@internal/pagesRoutes";
+var createRoutes = () => pagesRoutes.reduce(
+  (result, [name, path, meta, redirects]) => {
+    result.push(
+      {
+        name,
+        path,
+        component: Vuepress,
+        meta
+      },
+      ...redirects.map((item) => ({
+        path: item,
+        redirect: path
+      }))
+    );
+    return result;
+  },
+  [
+    {
+      name: "404",
+      path: "/:catchAll(.*)",
+      component: Vuepress
+    }
+  ]
+);
+
+// src/router.ts
+var historyCreator = __VUEPRESS_SSR__ ? createMemoryHistory : createWebHistory;
+var createVueRouter = () => {
+  const router = createRouter({
+    history: historyCreator(removeEndingSlash(siteData.value.base)),
+    routes: createRoutes(),
+    scrollBehavior: (to, from, savedPosition) => {
+      if (savedPosition)
+        return savedPosition;
+      if (to.hash)
+        return { el: to.hash };
+      return { top: 0 };
+    }
+  });
+  router.beforeResolve(async (to, from) => {
+    if (to.path !== from.path || from === START_LOCATION) {
+      ;
+      [pageData.value] = await Promise.all([
+        resolvers.resolvePageData(to.name),
+        pagesComponents[to.name]?.__asyncLoader()
+      ]);
+    }
+  });
+  return router;
+};
+
+// src/setupGlobalComponents.ts
+var setupGlobalComponents = (app) => {
+  app.component("ClientOnly", ClientOnly);
+  app.component("Content", Content);
+};
+
+// src/setupGlobalComputed.ts
+import { computed } from "vue";
+var setupGlobalComputed = (app, router) => {
+  const routeLocale = computed(
+    () => resolvers.resolveRouteLocale(
+      siteData.value.locales,
+      router.currentRoute.value.path
+    )
+  );
+  const siteLocaleData = computed(
+    () => resolvers.resolveSiteLocaleData(siteData.value, routeLocale.value)
+  );
+  const pageFrontmatter = computed(
+    () => resolvers.resolvePageFrontmatter(pageData.value)
+  );
+  const pageHeadTitle = computed(
+    () => resolvers.resolvePageHeadTitle(pageData.value, siteLocaleData.value)
+  );
+  const pageHead = computed(
+    () => resolvers.resolvePageHead(
+      pageHeadTitle.value,
+      pageFrontmatter.value,
+      siteLocaleData.value
+    )
+  );
+  const pageLang = computed(() => resolvers.resolvePageLang(pageData.value));
+  app.provide(routeLocaleSymbol, routeLocale);
+  app.provide(siteLocaleDataSymbol, siteLocaleData);
+  app.provide(pageFrontmatterSymbol, pageFrontmatter);
+  app.provide(pageHeadTitleSymbol, pageHeadTitle);
+  app.provide(pageHeadSymbol, pageHead);
+  app.provide(pageLangSymbol, pageLang);
+  Object.defineProperties(app.config.globalProperties, {
+    $frontmatter: { get: () => pageFrontmatter.value },
+    $head: { get: () => pageHead.value },
+    $headTitle: { get: () => pageHeadTitle.value },
+    $lang: { get: () => pageLang.value },
+    $page: { get: () => pageData.value },
+    $routeLocale: { get: () => routeLocale.value },
+    $site: { get: () => siteData.value },
+    $siteLocale: { get: () => siteLocaleData.value },
+    $withBase: { get: () => withBase }
+  });
+  return {
+    pageData,
+    pageFrontmatter,
+    pageHead,
+    pageHeadTitle,
+    pageLang,
+    routeLocale,
+    siteData,
+    siteLocaleData
+  };
+};
+
+// src/setupUpdateHead.ts
+import { isPlainObject, isString } from "@vuepress/shared";
+import { onMounted, provide, ref, useSSRContext, watch } from "vue";
+import { useRoute } from "vue-router";
+var setupUpdateHead = () => {
+  const route = useRoute();
+  const head = usePageHead();
+  const lang = usePageLang();
+  if (__VUEPRESS_SSR__) {
+    const ssrContext = useSSRContext();
+    if (ssrContext) {
+      ssrContext.head = head.value;
+      ssrContext.lang = lang.value;
+    }
+    return;
+  }
+  const headTags = ref([]);
+  const loadHead = () => {
+    head.value.forEach((item) => {
+      const tag = queryHeadTag(item);
+      if (tag) {
+        headTags.value.push(tag);
+      }
+    });
+  };
+  const updateHead = () => {
+    document.documentElement.lang = lang.value;
+    headTags.value.forEach((item) => {
+      if (item.parentNode === document.head) {
+        document.head.removeChild(item);
+      }
+    });
+    headTags.value.splice(0, headTags.value.length);
+    head.value.forEach((item) => {
+      const tag = createHeadTag(item);
+      if (tag !== null) {
+        document.head.appendChild(tag);
+        headTags.value.push(tag);
+      }
+    });
+  };
+  provide(updateHeadSymbol, updateHead);
+  onMounted(() => {
+    loadHead();
+    updateHead();
+    watch(
+      () => __VUEPRESS_DEV__ ? head.value : route.path,
+      () => updateHead()
+    );
+  });
+};
+var queryHeadTag = ([
+  tagName,
+  attrs,
+  content = ""
+]) => {
+  const attrsSelector = Object.entries(attrs).map(([key, value]) => {
+    if (isString(value)) {
+      return `[${key}="${value}"]`;
+    }
+    if (value === true) {
+      return `[${key}]`;
+    }
+    return "";
+  }).join("");
+  const selector = `head > ${tagName}${attrsSelector}`;
+  const tags = Array.from(document.querySelectorAll(selector));
+  const matchedTag = tags.find((item) => item.innerText === content);
+  return matchedTag || null;
+};
+var createHeadTag = ([
+  tagName,
+  attrs,
+  content
+]) => {
+  if (!isString(tagName)) {
+    return null;
+  }
+  const tag = document.createElement(tagName);
+  if (isPlainObject(attrs)) {
+    Object.entries(attrs).forEach(([key, value]) => {
+      if (isString(value)) {
+        tag.setAttribute(key, value);
+      } else if (value === true) {
+        tag.setAttribute(key, "");
+      }
+    });
+  }
+  if (isString(content)) {
+    tag.appendChild(document.createTextNode(content));
+  }
+  return tag;
+};
+
+// src/app.ts
+var appCreator = __VUEPRESS_DEV__ ? createApp : createSSRApp;
+var createVueApp = async () => {
+  const app = appCreator({
+    name: "VuepressApp",
+    setup() {
+      setupUpdateHead();
+      for (const clientConfig of clientConfigs) {
+        clientConfig.setup?.();
+      }
+      return () => [
+        h(RouterView),
+        ...clientConfigs.flatMap(
+          ({ rootComponents = [] }) => rootComponents.map((component) => h(component))
+        )
+      ];
+    }
+  });
+  const router = createVueRouter();
+  setupGlobalComponents(app);
+  const globalComputed = setupGlobalComputed(app, router);
+  if (__VUEPRESS_DEV__ || __VUE_PROD_DEVTOOLS__) {
+    const { setupDevtools } = await import("./setupDevtools-EXVHPMXB.js");
+    setupDevtools(app, globalComputed);
+  }
+  for (const clientConfig of clientConfigs) {
+    await clientConfig.enhance?.({ app, router, siteData });
+  }
+  app.use(router);
+  return {
+    app,
+    router
+  };
+};
+if (!__VUEPRESS_SSR__) {
+  createVueApp().then(({ app, router }) => {
+    router.isReady().then(() => {
+      app.mount("#app");
+    });
+  });
+}
+export {
+  createVueApp
+};

package/dist/chunk-V3MKNX2O.js

@@ -0,0 +1,264 @@
+// src/composables/pagesData.ts
+import { pagesData as pagesDataRaw } from "@internal/pagesData";
+import { ref } from "vue";
+var pagesData = ref(pagesDataRaw);
+var usePagesData = () => pagesData;
+
+// src/composables/pageData.ts
+import { readonly, ref as ref2 } from "vue";
+var pageDataEmpty = readonly({
+  key: "",
+  path: "",
+  title: "",
+  lang: "",
+  frontmatter: {},
+  excerpt: "",
+  headers: []
+});
+var pageData = ref2(pageDataEmpty);
+var usePageData = () => pageData;
+if (import.meta.webpackHot || import.meta.hot) {
+  __VUE_HMR_RUNTIME__.updatePageData = (data) => {
+    pagesData.value[data.key] = () => Promise.resolve(data);
+    if (data.key === pageData.value.key) {
+      pageData.value = data;
+    }
+  };
+}
+
+// src/composables/pageFrontmatter.ts
+import { inject } from "vue";
+var pageFrontmatterSymbol = Symbol(
+  __VUEPRESS_DEV__ ? "pageFrontmatter" : ""
+);
+var usePageFrontmatter = () => {
+  const pageFrontmatter = inject(pageFrontmatterSymbol);
+  if (!pageFrontmatter) {
+    throw new Error("usePageFrontmatter() is called without provider.");
+  }
+  return pageFrontmatter;
+};
+
+// src/composables/pageHead.ts
+import { inject as inject2 } from "vue";
+var pageHeadSymbol = Symbol(
+  __VUEPRESS_DEV__ ? "pageHead" : ""
+);
+var usePageHead = () => {
+  const pageHead = inject2(pageHeadSymbol);
+  if (!pageHead) {
+    throw new Error("usePageHead() is called without provider.");
+  }
+  return pageHead;
+};
+
+// src/composables/pageHeadTitle.ts
+import { inject as inject3 } from "vue";
+var pageHeadTitleSymbol = Symbol(
+  __VUEPRESS_DEV__ ? "pageHeadTitle" : ""
+);
+var usePageHeadTitle = () => {
+  const pageHeadTitle = inject3(pageHeadTitleSymbol);
+  if (!pageHeadTitle) {
+    throw new Error("usePageHeadTitle() is called without provider.");
+  }
+  return pageHeadTitle;
+};
+
+// src/composables/pageLang.ts
+import { inject as inject4 } from "vue";
+var pageLangSymbol = Symbol(
+  __VUEPRESS_DEV__ ? "pageLang" : ""
+);
+var usePageLang = () => {
+  const pageLang = inject4(pageLangSymbol);
+  if (!pageLang) {
+    throw new Error("usePageLang() is called without provider.");
+  }
+  return pageLang;
+};
+
+// src/composables/routeLocale.ts
+import { inject as inject5 } from "vue";
+var routeLocaleSymbol = Symbol(
+  __VUEPRESS_DEV__ ? "routeLocale" : ""
+);
+var useRouteLocale = () => {
+  const routeLocale = inject5(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 ref3 } from "vue";
+var siteData = ref3(siteDataRaw);
+var useSiteData = () => siteData;
+if (import.meta.webpackHot || import.meta.hot) {
+  __VUE_HMR_RUNTIME__.updateSiteData = (data) => {
+    siteData.value = data;
+  };
+}
+
+// src/composables/siteLocaleData.ts
+import { inject as inject6 } from "vue";
+var siteLocaleDataSymbol = Symbol(
+  __VUEPRESS_DEV__ ? "siteLocaleData" : ""
+);
+var useSiteLocaleData = () => {
+  const siteLocaleData = inject6(siteLocaleDataSymbol);
+  if (!siteLocaleData) {
+    throw new Error("useSiteLocaleData() is called without provider.");
+  }
+  return siteLocaleData;
+};
+
+// src/composables/updateHead.ts
+import { inject as inject7 } from "vue";
+var updateHeadSymbol = Symbol(
+  __VUEPRESS_DEV__ ? "updateHead" : ""
+);
+var useUpdateHead = () => {
+  const updateHead = inject7(updateHeadSymbol);
+  if (!updateHead) {
+    throw new Error("useUpdateHead() is called without provider.");
+  }
+  return updateHead;
+};
+
+// src/resolvers.ts
+import {
+  dedupeHead,
+  isArray,
+  isString,
+  resolveLocalePath
+} from "@vuepress/shared";
+import { reactive } from "vue";
+var resolvers = reactive({
+  resolvePageData: async (pageKey) => {
+    const pageDataResolver = pagesData.value[pageKey];
+    const pageData2 = await pageDataResolver?.();
+    return pageData2 ?? pageDataEmpty;
+  },
+  resolvePageFrontmatter: (pageData2) => pageData2.frontmatter,
+  resolvePageHead: (headTitle, frontmatter, siteLocale) => {
+    const description = isString(frontmatter.description) ? frontmatter.description : siteLocale.description;
+    const head = [
+      ...isArray(frontmatter.head) ? frontmatter.head : [],
+      ...siteLocale.head,
+      ["title", {}, headTitle],
+      ["meta", { name: "description", content: description }]
+    ];
+    return dedupeHead(head);
+  },
+  resolvePageHeadTitle: (page, siteLocale) => `${page.title ? `${page.title} | ` : ``}${siteLocale.title}`,
+  resolvePageLang: (pageData2) => pageData2.lang || "en",
+  resolveRouteLocale: (locales, routePath) => resolveLocalePath(locales, routePath),
+  resolveSiteLocaleData: (site, routeLocale) => ({
+    ...site,
+    ...site.locales[routeLocale]
+  })
+});
+
+// src/components/ClientOnly.ts
+import { defineComponent, onMounted, ref as ref4 } from "vue";
+var ClientOnly = defineComponent({
+  name: "ClientOnly",
+  setup(_, ctx) {
+    const isMounted = ref4(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({
+  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 ? h(pageComponent.value) : h(
+      "div",
+      __VUEPRESS_DEV__ ? "Page does not exist. This is a fallback content." : "404 Not Found"
+    );
+  }
+});
+
+// src/components/Vuepress.ts
+import { layoutComponents } from "@internal/layoutComponents";
+import { isString as isString2 } from "@vuepress/shared";
+import { computed as computed2, defineComponent as defineComponent3, h as h2, resolveComponent } from "vue";
+var Vuepress = defineComponent3({
+  name: "Vuepress",
+  setup() {
+    const page = usePageData();
+    const layoutComponent = computed2(() => {
+      let layoutName;
+      if (page.value.path) {
+        const frontmatterLayout = page.value.frontmatter.layout;
+        if (isString2(frontmatterLayout)) {
+          layoutName = frontmatterLayout;
+        } else {
+          layoutName = "Layout";
+        }
+      } else {
+        layoutName = "404";
+      }
+      return layoutComponents[layoutName] || resolveComponent(layoutName, false);
+    });
+    return () => h2(layoutComponent.value);
+  }
+});
+
+// src/withBase.ts
+import { isLinkHttp, removeLeadingSlash } from "@vuepress/shared";
+var withBase = (url) => {
+  if (isLinkHttp(url))
+    return url;
+  const base = useSiteData().value.base;
+  return `${base}${removeLeadingSlash(url)}`;
+};
+
+export {
+  pagesData,
+  usePagesData,
+  pageDataEmpty,
+  pageData,
+  usePageData,
+  pageFrontmatterSymbol,
+  usePageFrontmatter,
+  pageHeadSymbol,
+  usePageHead,
+  pageHeadTitleSymbol,
+  usePageHeadTitle,
+  pageLangSymbol,
+  usePageLang,
+  routeLocaleSymbol,
+  useRouteLocale,
+  siteData,
+  useSiteData,
+  siteLocaleDataSymbol,
+  useSiteLocaleData,
+  updateHeadSymbol,
+  useUpdateHead,
+  resolvers,
+  ClientOnly,
+  Content,
+  Vuepress,
+  withBase
+};