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

package/LICENSE

@@ -1,6 +1,6 @@
 The MIT License (MIT)
 
-Copyright (c) 2018-present, Yuxi (Evan) You
+Copyright (c) 2018-present, VuePress Community
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/README.md

@@ -0,0 +1,12 @@
+# @vuepress/client
+
+[![npm](https://badgen.net/npm/v/@vuepress/client/next)](https://www.npmjs.com/package/@vuepress/client)
+[![license](https://badgen.net/github/license/vuepress/core)](https://github.com/vuepress/core/blob/main/LICENSE)
+
+## Documentation
+
+https://v2.vuepress.vuejs.org
+
+## License
+
+[MIT](https://github.com/vuepress/core/blob/main/LICENSE)

package/dist/app.d.ts

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

package/dist/app.js

@@ -0,0 +1,353 @@
+import {
+  ClientOnly,
+  Content,
+  layoutsSymbol,
+  pageDataSymbol,
+  pageFrontmatterSymbol,
+  pageHeadSymbol,
+  pageHeadTitleSymbol,
+  pageLangSymbol,
+  pageLayoutSymbol,
+  pagesData,
+  resolvers,
+  routeLocaleSymbol,
+  siteData,
+  siteLocaleDataSymbol,
+  updateHeadSymbol,
+  usePageHead,
+  usePageLang,
+  usePageLayout,
+  withBase
+} from "./chunk-PEQEPZ75.js";
+
+// src/app.ts
+import { clientConfigs } from "@internal/clientConfigs";
+import { createApp, createSSRApp, h as h2 } 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";
+
+// src/components/Vuepress.ts
+import { defineComponent, h } from "vue";
+var Vuepress = defineComponent({
+  name: "Vuepress",
+  setup() {
+    const layout = usePageLayout();
+    return () => h(layout.value);
+  }
+});
+
+// src/routes.ts
+var createRoutes = () => pagesRoutes.reduce(
+  (result, [name, path, meta, redirects]) => {
+    result.push(
+      {
+        name,
+        path,
+        component: Vuepress,
+        meta
+      },
+      {
+        path: path.endsWith("/") ? (
+          // redirect from `/index.html` to `/`
+          path + "index.html"
+        ) : (
+          // redirect from `/foo` to `/foo.html`
+          path.substring(0, path.length - 5)
+        ),
+        redirect: path
+      },
+      ...redirects.map((item) => ({
+        path: item === ":md" ? (
+          // redirect from `/foo.md` to `/foo.html`
+          path.substring(0, path.length - 5) + ".md"
+        ) : 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({
+    // it might be an issue of vue-router that have to remove the ending slash
+    history: historyCreator(removeEndingSlash(__VUEPRESS_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) {
+      ;
+      [to.meta._data] = 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 { computedWithControl } from "@vueuse/core";
+import { computed } from "vue";
+var setupGlobalComputed = (app, router, clientConfigs2) => {
+  const routePath = computed(() => router.currentRoute.value.path);
+  const pageData = computedWithControl(
+    routePath,
+    () => router.currentRoute.value.meta._data
+  );
+  if (__VUEPRESS_DEV__ && (import.meta.webpackHot || import.meta.hot)) {
+    __VUE_HMR_RUNTIME__.updatePageData = (data) => {
+      pagesData.value[data.key] = () => Promise.resolve(data);
+      if (data.key === router.currentRoute.value.meta._data?.key) {
+        router.currentRoute.value.meta._data = data;
+        pageData.trigger();
+      }
+    };
+  }
+  const layouts = computed(() => resolvers.resolveLayouts(clientConfigs2));
+  const routeLocale = computed(
+    () => resolvers.resolveRouteLocale(siteData.value.locales, routePath.value)
+  );
+  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, siteLocaleData.value)
+  );
+  const pageLayout = computed(
+    () => resolvers.resolvePageLayout(pageData.value, layouts.value)
+  );
+  app.provide(layoutsSymbol, layouts);
+  app.provide(pageDataSymbol, pageData);
+  app.provide(pageFrontmatterSymbol, pageFrontmatter);
+  app.provide(pageHeadTitleSymbol, pageHeadTitle);
+  app.provide(pageHeadSymbol, pageHead);
+  app.provide(pageLangSymbol, pageLang);
+  app.provide(pageLayoutSymbol, pageLayout);
+  app.provide(routeLocaleSymbol, routeLocale);
+  app.provide(siteLocaleDataSymbol, siteLocaleData);
+  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 {
+    layouts,
+    pageData,
+    pageFrontmatter,
+    pageHead,
+    pageHeadTitle,
+    pageLang,
+    pageLayout,
+    routeLocale,
+    siteData,
+    siteLocaleData
+  };
+};
+
+// src/setupUpdateHead.ts
+import { isPlainObject, isString } from "@vuepress/shared";
+import { onMounted, provide, useSSRContext, watch } from "vue";
+var setupUpdateHead = () => {
+  const head = usePageHead();
+  const lang = usePageLang();
+  if (__VUEPRESS_SSR__) {
+    const ssrContext = useSSRContext();
+    if (ssrContext) {
+      ssrContext.head = head.value;
+      ssrContext.lang = lang.value;
+    }
+    return;
+  }
+  let managedHeadElements = [];
+  const takeOverHeadElements = () => {
+    head.value.forEach((item) => {
+      const headElement = queryHeadElement(item);
+      if (headElement) {
+        managedHeadElements.push(headElement);
+      }
+    });
+  };
+  const generateHeadElements = () => {
+    const result = [];
+    head.value.forEach((item) => {
+      const headElement = createHeadElement(item);
+      if (headElement) {
+        result.push(headElement);
+      }
+    });
+    return result;
+  };
+  const updateHead = () => {
+    document.documentElement.lang = lang.value;
+    const newHeadElements = generateHeadElements();
+    managedHeadElements.forEach((oldEl, oldIndex) => {
+      const matchedIndex = newHeadElements.findIndex(
+        (newEl) => oldEl.isEqualNode(newEl)
+      );
+      if (matchedIndex === -1) {
+        oldEl.remove();
+        delete managedHeadElements[oldIndex];
+      } else {
+        newHeadElements.splice(matchedIndex, 1);
+      }
+    });
+    newHeadElements.forEach((el) => document.head.appendChild(el));
+    managedHeadElements = [
+      // filter out empty deleted items
+      ...managedHeadElements.filter((item) => !!item),
+      ...newHeadElements
+    ];
+  };
+  provide(updateHeadSymbol, updateHead);
+  onMounted(() => {
+    if (!__VUEPRESS_DEV__) {
+      takeOverHeadElements();
+    }
+    watch(head, updateHead, { immediate: __VUEPRESS_DEV__ });
+  });
+};
+var queryHeadElement = ([
+  tagName,
+  attrs,
+  content = ""
+]) => {
+  const attrsSelector = Object.entries(attrs).map(([key, value]) => {
+    if (isString(value)) {
+      return `[${key}=${JSON.stringify(value)}]`;
+    }
+    if (value === true) {
+      return `[${key}]`;
+    }
+    return "";
+  }).join("");
+  const selector = `head > ${tagName}${attrsSelector}`;
+  const headElements = Array.from(
+    document.querySelectorAll(selector)
+  );
+  const matchedHeadElement = headElements.find(
+    (item) => item.innerText === content
+  );
+  return matchedHeadElement || null;
+};
+var createHeadElement = ([
+  tagName,
+  attrs,
+  content
+]) => {
+  if (!isString(tagName)) {
+    return null;
+  }
+  const headElement = document.createElement(tagName);
+  if (isPlainObject(attrs)) {
+    Object.entries(attrs).forEach(([key, value]) => {
+      if (isString(value)) {
+        headElement.setAttribute(key, value);
+      } else if (value === true) {
+        headElement.setAttribute(key, "");
+      }
+    });
+  }
+  if (isString(content)) {
+    headElement.appendChild(document.createTextNode(content));
+  }
+  return headElement;
+};
+
+// 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 () => [
+        h2(RouterView),
+        ...clientConfigs.flatMap(
+          ({ rootComponents = [] }) => rootComponents.map((component) => h2(component))
+        )
+      ];
+    }
+  });
+  const router = createVueRouter();
+  setupGlobalComponents(app);
+  const globalComputed = setupGlobalComputed(app, router, clientConfigs);
+  if (__VUEPRESS_DEV__ || __VUE_PROD_DEVTOOLS__) {
+    const { setupDevtools } = await import("./setupDevtools-X4YFRK4B.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
+};