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

package/dist/chunk-GA5RAHE7.js

@@ -0,0 +1,432 @@
+// src/composables/clientData.ts
+import { inject } from "vue";
+var clientDataSymbol = Symbol(
+  __VUEPRESS_DEV__ ? "clientData" : ""
+);
+var useClientData = () => {
+  const clientData = inject(clientDataSymbol);
+  if (!clientData) {
+    throw new Error("useClientData() is called without provider.");
+  }
+  return clientData;
+};
+
+// src/composables/clientDataUtils.ts
+var useLayouts = () => useClientData().layouts;
+var usePageComponent = () => useClientData().pageComponent;
+var usePageData = () => useClientData().pageData;
+var usePageFrontmatter = () => useClientData().pageFrontmatter;
+var usePageHead = () => useClientData().pageHead;
+var usePageLang = () => useClientData().pageLang;
+var usePageLayout = () => useClientData().pageLayout;
+var useRedirects = () => useClientData().redirects;
+var useRouteLocale = () => useClientData().routeLocale;
+var useRoutePath = () => useClientData().routePath;
+var useRoutes = () => useClientData().routes;
+var useSiteData = () => useClientData().siteData;
+var useSiteLocaleData = () => useClientData().siteLocaleData;
+
+// src/composables/updateHead.ts
+import { inject as inject2 } from "vue";
+var updateHeadSymbol = Symbol(
+  __VUEPRESS_DEV__ ? "updateHead" : ""
+);
+var useUpdateHead = () => {
+  const updateHead = inject2(updateHeadSymbol);
+  if (!updateHead) {
+    throw new Error("useUpdateHead() is called without provider.");
+  }
+  return updateHead;
+};
+
+// src/router/resolveRoutePath.ts
+import { normalizeRoutePath } from "@vuepress/shared";
+
+// src/internal/routes.ts
+import {
+  redirects as redirectsRaw,
+  routes as routesRaw
+} from "@internal/routes";
+import { shallowRef } from "vue";
+var redirects = shallowRef(redirectsRaw);
+var routes = shallowRef(routesRaw);
+if (__VUEPRESS_DEV__ && (import.meta.webpackHot || import.meta.hot)) {
+  __VUE_HMR_RUNTIME__.updateRedirects = (data) => {
+    redirects.value = data;
+  };
+  __VUE_HMR_RUNTIME__.updateRoutes = (data) => {
+    routes.value = data;
+  };
+}
+
+// src/router/resolveRoutePath.ts
+var resolveRoutePath = (path, currentPath) => {
+  const normalizedPath = normalizeRoutePath(path, currentPath);
+  if (routes.value[normalizedPath])
+    return normalizedPath;
+  const encodedPath = encodeURI(normalizedPath);
+  if (routes.value[encodedPath])
+    return encodedPath;
+  return redirects.value[normalizedPath] || redirects.value[encodedPath] || normalizedPath;
+};
+
+// src/router/resolveRoute.ts
+var resolveRoute = (path, currentPath) => {
+  const routePath = resolveRoutePath(path, currentPath);
+  const route = routes.value[routePath] ?? {
+    ...routes.value["/404.html"],
+    notFound: true
+  };
+  return {
+    path: routePath,
+    notFound: false,
+    ...route
+  };
+};
+
+// src/router/index.ts
+import { useRoute, useRouter } from "vue-router";
+
+// src/components/RouteLink.ts
+import { computed, defineComponent, h } from "vue";
+import { useRoute as useRoute2, useRouter as useRouter2 } from "vue-router";
+var guardEvent = (event) => {
+  if (event.metaKey || event.altKey || event.ctrlKey || event.shiftKey)
+    return;
+  if (event.defaultPrevented)
+    return;
+  if (event.button !== void 0 && event.button !== 0)
+    return;
+  if (event.currentTarget) {
+    const target = event.currentTarget.getAttribute("target");
+    if (target?.match(/\b_blank\b/i))
+      return;
+  }
+  event.preventDefault();
+  return true;
+};
+var RouteLink = defineComponent({
+  name: "RouteLink",
+  props: {
+    /**
+     * The route path to link to
+     */
+    to: {
+      type: String,
+      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: Boolean,
+    /**
+     * The class to add when the link is active
+     */
+    activeClass: {
+      type: String,
+      default: "route-link-active"
+    }
+  },
+  slots: Object,
+  setup(props, { slots }) {
+    const router = useRouter2();
+    const route = useRoute2();
+    const path = computed(
+      () => props.to.startsWith("#") || props.to.startsWith("?") ? props.to : `${__VUEPRESS_BASE__}${resolveRoutePath(props.to, route.path).substring(1)}`
+    );
+    return () => h(
+      "a",
+      {
+        class: ["route-link", { [props.activeClass]: props.active }],
+        href: path.value,
+        onClick: (event = {}) => {
+          if (guardEvent(event)) {
+            router.push(props.to).catch();
+          }
+        }
+      },
+      slots.default?.()
+    );
+  }
+});
+
+// src/components/AutoLink.ts
+import { isLinkWithProtocol } from "@vuepress/shared";
+import { computed as computed2, defineComponent as defineComponent2, h as h2 } from "vue";
+import { useRoute as useRoute3 } from "vue-router";
+var AutoLink = defineComponent2({
+  name: "AutoLink",
+  props: {
+    /**
+     * Pattern to determine if the link should be active, which has higher priority than `exact`
+     */
+    activeMatch: {
+      type: [String, RegExp],
+      default: ""
+    },
+    /**
+     * The `aria-label` attribute
+     */
+    ariaLabel: {
+      type: String,
+      default: ""
+    },
+    /**
+     * Whether the link should be active only if the url is an exact match
+     */
+    exact: Boolean,
+    /**
+     * URL of the auto link
+     */
+    link: {
+      type: String,
+      required: true
+    },
+    /**
+     * The `rel` attribute
+     */
+    rel: {
+      type: String,
+      default: ""
+    },
+    /**
+     * The `target` attribute
+     */
+    target: {
+      type: String,
+      default: ""
+    },
+    /**
+     * Text of the auto link
+     */
+    text: {
+      type: String,
+      required: true
+    }
+  },
+  slots: Object,
+  setup(props, { slots }) {
+    const route = useRoute3();
+    const siteData = useSiteData();
+    const withProtocol = computed2(() => isLinkWithProtocol(props.link));
+    const linkTarget = computed2(
+      () => props.target || (withProtocol.value ? "_blank" : void 0)
+    );
+    const isBlankTarget = computed2(() => linkTarget.value === "_blank");
+    const isInternal = computed2(
+      () => !withProtocol.value && !isBlankTarget.value
+    );
+    const linkRel = computed2(
+      () => props.rel || (isBlankTarget.value ? "noopener noreferrer" : null)
+    );
+    const linkAriaLabel = computed2(() => props.ariaLabel ?? props.text);
+    const shouldBeActiveInSubpath = computed2(() => {
+      if (props.exact)
+        return false;
+      const localePaths = Object.keys(siteData.value.locales);
+      return localePaths.length ? (
+        // Check all the locales
+        localePaths.every((key) => key !== props.link)
+      ) : (
+        // Check root
+        props.link !== "/"
+      );
+    });
+    const isActive = computed2(() => {
+      if (!isInternal.value)
+        return false;
+      if (props.activeMatch) {
+        return (props.activeMatch instanceof RegExp ? props.activeMatch : new RegExp(props.activeMatch, "u")).test(route.path);
+      }
+      if (shouldBeActiveInSubpath.value) {
+        return route.path.startsWith(props.link);
+      }
+      return route.path === props.link;
+    });
+    return () => {
+      const { before, after, default: defaultSlot } = slots;
+      const content = defaultSlot?.() || [before?.(), props.text, after?.()];
+      return isInternal.value ? h2(
+        RouteLink,
+        {
+          "class": "auto-link",
+          "to": props.link,
+          "active": isActive.value,
+          "aria-label": linkAriaLabel.value
+        },
+        () => content
+      ) : h2(
+        "a",
+        {
+          "class": "auto-link external-link",
+          "href": props.link,
+          "aria-label": linkAriaLabel.value,
+          "rel": linkRel.value,
+          "target": linkTarget.value
+        },
+        content
+      );
+    };
+  }
+});
+
+// src/components/ClientOnly.ts
+import { defineComponent as defineComponent3, onMounted, ref } from "vue";
+var ClientOnly = defineComponent3({
+  name: "ClientOnly",
+  setup(_, ctx) {
+    const isMounted = ref(false);
+    onMounted(() => {
+      isMounted.value = true;
+    });
+    return () => isMounted.value ? ctx.slots.default?.() : null;
+  }
+});
+
+// src/components/Content.ts
+import { computed as computed3, defineAsyncComponent, defineComponent as defineComponent4, h as h3 } from "vue";
+var Content = defineComponent4({
+  // eslint-disable-next-line vue/no-reserved-component-names
+  name: "Content",
+  props: {
+    path: {
+      type: String,
+      required: false,
+      default: ""
+    }
+  },
+  setup(props) {
+    const pageComponent = usePageComponent();
+    const ContentComponent = computed3(() => {
+      if (!props.path)
+        return pageComponent.value;
+      const route = resolveRoute(props.path);
+      return defineAsyncComponent(() => route.loader().then(({ comp }) => comp));
+    });
+    return () => h3(ContentComponent.value);
+  }
+});
+
+// src/resolvers.ts
+import { dedupeHead, isString, resolveLocalePath } from "@vuepress/shared";
+import { reactive } from "vue";
+
+// src/constants.ts
+var LAYOUT_NAME_DEFAULT = "Layout";
+var LANG_DEFAULT = "en-US";
+
+// src/resolvers.ts
+var resolvers = reactive({
+  /**
+   * Resolve layouts component map
+   */
+  resolveLayouts: (clientConfigs) => clientConfigs.reduce(
+    (prev, item) => ({
+      ...prev,
+      ...item.layouts
+    }),
+    {}
+  ),
+  /**
+   * Merge the head config in frontmatter and site locale
+   *
+   * Frontmatter should take priority over site locale
+   */
+  resolvePageHead: (pageHeadTitle, pageFrontmatter, siteLocaleDate) => {
+    const description = isString(pageFrontmatter.description) ? pageFrontmatter.description : siteLocaleDate.description;
+    const head = [
+      ...Array.isArray(pageFrontmatter.head) ? pageFrontmatter.head : [],
+      ...siteLocaleDate.head,
+      ["title", {}, pageHeadTitle],
+      ["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: (pageData, siteLocaleDate) => [pageData.title, siteLocaleDate.title].filter((item) => !!item).join(" | "),
+  /**
+   * Resolve page language from page data
+   *
+   * It would be used as the `lang` attribute of `<html>` tag
+   */
+  resolvePageLang: (pageData, siteLocaleData) => pageData.lang || siteLocaleData.lang || LANG_DEFAULT,
+  /**
+   * Resolve layout component of current page
+   */
+  resolvePageLayout: (pageData, layouts) => {
+    const layoutName = isString(pageData.frontmatter.layout) ? pageData.frontmatter.layout : LAYOUT_NAME_DEFAULT;
+    if (!layouts[layoutName]) {
+      throw new Error(`[vuepress] Cannot resolve layout: ${layoutName}`);
+    }
+    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: ({ base, locales, ...siteData }, routeLocale) => ({
+    ...siteData,
+    ...locales[routeLocale],
+    head: [
+      // when merging head, the locales head should be placed before root head
+      // to get higher priority
+      ...locales[routeLocale]?.head ?? [],
+      ...siteData.head ?? []
+    ]
+  })
+});
+
+// src/utils/defineClientConfig.ts
+var defineClientConfig = (clientConfig = {}) => clientConfig;
+
+// src/utils/withBase.ts
+import { isLinkHttp, removeLeadingSlash } from "@vuepress/shared";
+var withBase = (url) => {
+  if (isLinkHttp(url))
+    return url;
+  return `${__VUEPRESS_BASE__}${removeLeadingSlash(url)}`;
+};
+
+export {
+  clientDataSymbol,
+  useClientData,
+  useLayouts,
+  usePageComponent,
+  usePageData,
+  usePageFrontmatter,
+  usePageHead,
+  usePageLang,
+  usePageLayout,
+  useRedirects,
+  useRouteLocale,
+  useRoutePath,
+  useRoutes,
+  useSiteData,
+  useSiteLocaleData,
+  updateHeadSymbol,
+  useUpdateHead,
+  redirects,
+  routes,
+  resolveRoutePath,
+  resolveRoute,
+  useRoute,
+  useRouter,
+  RouteLink,
+  AutoLink,
+  ClientOnly,
+  Content,
+  resolvers,
+  defineClientConfig,
+  withBase
+};

package/dist/createVueAppFunction-onJTVJru.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 };