@vuepress/client 2.0.0-beta.4 → 2.0.0-beta.42

package/dist/app.d.ts

@@ -0,0 +1,7 @@
+import { C as CreateVueAppFunction } from './createVueAppFunction-c8e67ca1.js';
+import 'vue';
+import 'vue-router';
+
+declare const createVueApp: CreateVueAppFunction;
+
+export { createVueApp };

package/dist/app.js

@@ -0,0 +1,259 @@
+import {
+  ClientOnly,
+  Content,
+  pageData,
+  pageFrontmatterSymbol,
+  pageHeadSymbol,
+  pageHeadTitleSymbol,
+  pageLangSymbol,
+  resolvers,
+  routeLocaleSymbol,
+  siteData,
+  siteLocaleDataSymbol,
+  updateHeadSymbol,
+  usePageHead,
+  usePageLang,
+  withBase
+} from "./chunk-RTLFYRTT.js";
+
+// src/app.ts
+import { clientAppEnhances } from "@internal/clientAppEnhances";
+import { clientAppRootComponents } from "@internal/clientAppRootComponents";
+import { clientAppSetups } from "@internal/clientAppSetups";
+import { createApp, createSSRApp, h } from "vue";
+import { RouterView } from "vue-router";
+
+// src/router.ts
+import { pagesComponents } from "@internal/pagesComponents";
+import { pagesRoutes } from "@internal/pagesRoutes";
+import { removeEndingSlash } from "@vuepress/shared";
+import {
+  createMemoryHistory,
+  createRouter,
+  createWebHistory,
+  START_LOCATION
+} from "vue-router";
+var historyCreator = __VUEPRESS_SSR__ ? createMemoryHistory : createWebHistory;
+var createVueRouter = () => {
+  const router = createRouter({
+    history: historyCreator(removeEndingSlash(siteData.value.base)),
+    routes: pagesRoutes,
+    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/setupDevtools.ts
+import { setupDevtoolsPlugin } from "@vue/devtools-api";
+var setupDevtools = (app, globalComputed) => {
+  setupDevtoolsPlugin({
+    app,
+    id: "org.vuejs.vuepress",
+    label: "VuePress",
+    packageName: "@vuepress/client",
+    homepage: "https://v2.vuepress.vuejs.org",
+    logo: "https://v2.vuepress.vuejs.org/images/hero.png",
+    componentStateTypes: ["VuePress"]
+  }, (api) => {
+    api.on.inspectComponent((payload) => {
+      payload.instanceData.state.push(...Object.entries(globalComputed).map(([name, item]) => ({
+        type: "VuePress",
+        key: name,
+        editable: false,
+        value: item.value
+      })));
+    });
+  });
+};
+
+// 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 clientAppSetup of clientAppSetups) {
+        clientAppSetup();
+      }
+      return () => [
+        h(RouterView),
+        ...clientAppRootComponents.map((comp) => h(comp))
+      ];
+    }
+  });
+  const router = createVueRouter();
+  setupGlobalComponents(app);
+  const globalComputed = setupGlobalComputed(app, router);
+  if (__VUEPRESS_DEV__ || __VUE_PROD_DEVTOOLS__) {
+    setupDevtools(app, globalComputed);
+  }
+  for (const clientAppEnhance of clientAppEnhances) {
+    await clientAppEnhance({ 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-RTLFYRTT.js

@@ -0,0 +1,250 @@
+// 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({
+  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 { h } from "vue";
+var Content = (props) => {
+  let key;
+  if (props.pageKey) {
+    key = props.pageKey;
+  } else {
+    const page = usePageData();
+    key = page.value.key;
+  }
+  const component = pagesComponents[key];
+  if (component) {
+    return h(component);
+  }
+  return h("div", __VUEPRESS_DEV__ ? "Page does not exist. This is a fallback content." : "404 Not Found");
+};
+Content.displayName = "Content";
+Content.props = {
+  pageKey: {
+    type: String,
+    required: false
+  }
+};
+
+// src/components/Vuepress.ts
+import { layoutComponents } from "@internal/layoutComponents";
+import { isString as isString2 } from "@vuepress/shared";
+import { computed, defineComponent as defineComponent2, h as h2, resolveComponent } from "vue";
+var Vuepress = defineComponent2({
+  name: "Vuepress",
+  setup() {
+    const page = usePageData();
+    const layoutComponent = computed(() => {
+      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
+};

package/dist/createVueAppFunction-c8e67ca1.d.ts

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