tanxin-ui 0.2.0

package/es/alert/src/alert.js

@@ -0,0 +1,156 @@
+import { createVNode, defineComponent, ref, watch, resolveComponent, computed, Fragment, withDirectives, mergeProps, vShow } from "vue";
+import { PropTypes } from "../../utils/type.js";
+import { useConfig } from "../../utils/hooks/useConfig.js";
+import { TIcon } from "../../icon/index.js";
+import SlideUpTransition from "../../utils/components/transition/slide-up-transition.js";
+import "../../utils/components/icons/Checkmark.js";
+import "../../utils/components/icons/CheckmarkCircle.js";
+import "../../utils/components/icons/CheckmarkSharp.js";
+import CheckmarkCircleOutline from "../../utils/components/icons/CheckmarkCircleOutline.js";
+import "../../utils/components/icons/AlertCircle.js";
+import AlertCircleOutline from "../../utils/components/icons/AlertCircleOutline.js";
+import "../../utils/components/icons/InformationCircle.js";
+import InformationCircleOutline from "../../utils/components/icons/InformationCircleOutline.js";
+import "../../utils/components/icons/CloseCircle.js";
+import CloseCircleOutline from "../../utils/components/icons/CloseCircleOutline.js";
+import "../../utils/components/icons/HelpCircleSharp.js";
+import "../../utils/components/icons/EyeOffOutline.js";
+import "../../utils/components/icons/EyeOutline.js";
+import "../../utils/components/icons/LoadingOutlined.js";
+import Close from "../../utils/components/icons/Close.js";
+import "../../utils/components/icons/CloseOutline.js";
+import "../../utils/components/icons/ArrowsMaximize.js";
+import "../../utils/components/icons/ArrowsMinimize.js";
+import "../../utils/components/icons/AddOutline.js";
+import "../../utils/components/icons/RemoveOutline.js";
+import "../../utils/components/icons/ChevronUp.js";
+import "../../utils/components/icons/ChevronDown.js";
+import "../../utils/components/icons/ChevronForward.js";
+import "../../utils/components/icons/ChevronLeft24Filled.js";
+import "../../utils/components/icons/ChevronRight24Filled.js";
+import "../../utils/components/icons/ChevronDoubleLeft16Filled.js";
+import "../../utils/components/icons/ChevronDoubleRight16Filled.js";
+import "../../utils/components/icons/CheckmarkOutline.js";
+import "../../utils/components/icons/IosCheckmark.js";
+import "../../utils/components/icons/Empty.js";
+import "../../utils/components/icons/Bars.js";
+import "../../utils/components/icons/ArrowUpCircle.js";
+import "../../utils/components/icons/ArrowUp.js";
+import "../../utils/components/icons/ArrowForward.js";
+import "../../utils/components/icons/TimeOutline.js";
+import "../../utils/components/icons/CalendarClearOutline.js";
+import "../../utils/components/icons/KeyboardArrowLeftRound.js";
+import "../../utils/components/icons/KeyboardArrowRightRound.js";
+import "../../utils/components/icons/KeyboardDoubleArrowLeftRound.js";
+import "../../utils/components/icons/KeyboardDoubleArrowRightRound.js";
+import "../../utils/components/icons/MenuFoldOutlined.js";
+import "../../utils/components/icons/IosArrowDown.js";
+import "../../utils/components/icons/IosArrowBack.js";
+import "../../utils/components/icons/IosArrowForward.js";
+import "../../utils/components/icons/ImageSharp.js";
+import "../../utils/components/icons/Pause.js";
+import "../../utils/components/icons/Refresh.js";
+import "../../utils/components/icons/QuestionCircle24Regular.js";
+import "../../utils/components/icons/CloudUploadOutline.js";
+import "../../utils/components/icons/UploadFileFilled.js";
+import "../../utils/components/icons/EllipsisHorizontal.js";
+import "../../utils/components/icons/ArrowNext24Filled.js";
+import "../../utils/components/icons/ArrowPrevious24Filled.js";
+import "../../utils/components/icons/ArrowDropDownSharp.js";
+import "../../utils/components/icons/ArrowDropUpSharp.js";
+import "../../utils/components/icons/ArrowForwardIosFilled.js";
+const alertProps = {
+  type: PropTypes.oneOf(["primary", "success", "info", "warning", "danger"]),
+  closable: PropTypes.bool.def(false),
+  showIcon: PropTypes.bool.def(false),
+  title: PropTypes.string,
+  content: PropTypes.string,
+  closeText: PropTypes.string,
+  notice: PropTypes.bool.def(false)
+};
+const leftIcons = {
+  success: createVNode(CheckmarkCircleOutline, null, null),
+  info: createVNode(InformationCircleOutline, null, null),
+  warning: createVNode(AlertCircleOutline, null, null),
+  danger: createVNode(CloseCircleOutline, null, null)
+};
+var Alert = defineComponent({
+  name: "TAlert",
+  components: {
+    TIcon,
+    CheckmarkCircleOutline,
+    AlertCircleOutline,
+    InformationCircleOutline,
+    CloseCircleOutline,
+    Close
+  },
+  inheritAttrs: false,
+  props: alertProps,
+  emits: ["close"],
+  setup(props, {
+    slots,
+    emit,
+    attrs
+  }) {
+    const {
+      prefixCls
+    } = useConfig("alert", props);
+    const closed = ref(false);
+    const showIcon = ref(props.showIcon);
+    const title = slots.title ? slots.title() : props.title;
+    const content = ref(slots.content ? slots.content() : props.content);
+    watch(() => {
+      var _a;
+      return (_a = slots == null ? void 0 : slots.content) == null ? void 0 : _a.call(slots);
+    }, () => {
+      content.value = slots.content();
+    });
+    watch(() => props.content, () => {
+      content.value = props.content;
+    });
+    const alertType = props.notice && props.type === void 0 ? "warning" : props.type || "info";
+    const leftIcon = showIcon.value ? createVNode("div", {
+      "class": `${prefixCls.value}-icon`
+    }, [createVNode(resolveComponent("t-icon"), null, {
+      default: () => [slots.icon ? slots.icon() : leftIcons[alertType]]
+    })]) : null;
+    const classes = computed(() => {
+      return [[`${prefixCls.value}`], {
+        [`${prefixCls.value}-${alertType}`]: alertType,
+        [`is-lg`]: title,
+        [`is-notice`]: props.notice
+      }];
+    });
+    const handleClose = () => {
+      closed.value = true;
+      emit("close");
+    };
+    const closeIcon = props.closable ? createVNode("button", {
+      "type": "button",
+      "onClick": handleClose,
+      "class": `${prefixCls.value}-close-btn`
+    }, [slots.closeText ? slots.closeText() : props.closeText ? props.closeText : createVNode(resolveComponent("t-icon"), null, {
+      default: () => [createVNode(Close, null, null)]
+    })]) : null;
+    const render = () => {
+      return createVNode(Fragment, null, [createVNode(SlideUpTransition, null, {
+        default: () => [withDirectives(createVNode("div", mergeProps(attrs, {
+          "class": classes.value
+        }), [leftIcon, createVNode("div", {
+          "class": `${prefixCls.value}-body`
+        }, [title ? createVNode("div", {
+          "class": `${prefixCls.value}-body-title`
+        }, [title]) : null, createVNode("div", {
+          "class": `${prefixCls.value}-body-content`
+        }, [content.value])]), slots.extra ? slots.extra() : closeIcon]), [[vShow, !closed.value]])]
+      })]);
+    };
+    return {
+      render
+    };
+  },
+  render() {
+    return this.render();
+  }
+});
+export { Alert as default };

package/es/anchor/index.d.ts

@@ -0,0 +1,114 @@
+declare const TAnchor: {
+    new (...args: any[]): {
+        $: import("vue").ComponentInternalInstance;
+        $data: {};
+        $props: Partial<{}> & Omit<Readonly<import("vue").ExtractPropTypes<{
+            offsetTop: import("vue").PropType<import("../utils/type").Width>;
+        }>> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, never>;
+        $attrs: {
+            [x: string]: unknown;
+        };
+        $refs: {
+            [x: string]: unknown;
+        };
+        $slots: Readonly<{
+            [name: string]: import("vue").Slot;
+        }>;
+        $root: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}>>;
+        $parent: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}>>;
+        $emit: (event: string, ...args: any[]) => void;
+        $el: any;
+        $options: import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
+            offsetTop: import("vue").PropType<import("../utils/type").Width>;
+        }>>, {
+            render: () => JSX.Element;
+        }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, {}> & {
+            beforeCreate?: (() => void) | (() => void)[];
+            created?: (() => void) | (() => void)[];
+            beforeMount?: (() => void) | (() => void)[];
+            mounted?: (() => void) | (() => void)[];
+            beforeUpdate?: (() => void) | (() => void)[];
+            updated?: (() => void) | (() => void)[];
+            activated?: (() => void) | (() => void)[];
+            deactivated?: (() => void) | (() => void)[];
+            beforeDestroy?: (() => void) | (() => void)[];
+            beforeUnmount?: (() => void) | (() => void)[];
+            destroyed?: (() => void) | (() => void)[];
+            unmounted?: (() => void) | (() => void)[];
+            renderTracked?: ((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[];
+            renderTriggered?: ((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[];
+            errorCaptured?: ((err: unknown, instance: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}>>, info: string) => boolean | void) | ((err: unknown, instance: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}>>, info: string) => boolean | void)[];
+        };
+        $forceUpdate: () => void;
+        $nextTick: typeof import("vue").nextTick;
+        $watch(source: string | Function, cb: Function, options?: import("vue").WatchOptions<boolean>): import("vue").WatchStopHandle;
+    } & Readonly<import("vue").ExtractPropTypes<{
+        offsetTop: import("vue").PropType<import("../utils/type").Width>;
+    }>> & import("vue").ShallowUnwrapRef<{
+        render: () => JSX.Element;
+    }> & {} & import("vue").ComponentCustomProperties;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
+    offsetTop: import("vue").PropType<import("../utils/type").Width>;
+}>>, {
+    render: () => JSX.Element;
+}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, {}> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & import("@vue/runtime-core").Plugin;
+export { TAnchor };
+declare const TAnchorLink: {
+    new (...args: any[]): {
+        $: import("vue").ComponentInternalInstance;
+        $data: {};
+        $props: Partial<{} | {
+            [x: string]: any;
+        }> & Omit<Readonly<any> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, never>;
+        $attrs: {
+            [x: string]: unknown;
+        };
+        $refs: {
+            [x: string]: unknown;
+        };
+        $slots: Readonly<{
+            [name: string]: import("vue").Slot;
+        }>;
+        $root: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}>>;
+        $parent: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}>>;
+        $emit: (event: string, ...args: any[]) => void;
+        $el: any;
+        $options: import("vue").ComponentOptionsBase<Readonly<any>, {
+            render: () => JSX.Element;
+        }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, {} | {
+            [x: string]: any;
+        }> & {
+            beforeCreate?: (() => void) | (() => void)[];
+            created?: (() => void) | (() => void)[];
+            beforeMount?: (() => void) | (() => void)[];
+            mounted?: (() => void) | (() => void)[];
+            beforeUpdate?: (() => void) | (() => void)[];
+            updated?: (() => void) | (() => void)[];
+            activated?: (() => void) | (() => void)[];
+            deactivated?: (() => void) | (() => void)[];
+            beforeDestroy?: (() => void) | (() => void)[];
+            beforeUnmount?: (() => void) | (() => void)[];
+            destroyed?: (() => void) | (() => void)[];
+            unmounted?: (() => void) | (() => void)[];
+            renderTracked?: ((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[];
+            renderTriggered?: ((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[];
+            errorCaptured?: ((err: unknown, instance: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}>>, info: string) => boolean | void) | ((err: unknown, instance: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}>>, info: string) => boolean | void)[];
+        };
+        $forceUpdate: () => void;
+        $nextTick: typeof import("vue").nextTick;
+        $watch(source: string | Function, cb: Function, options?: import("vue").WatchOptions<boolean>): import("vue").WatchStopHandle;
+    } & Readonly<any> & import("vue").ShallowUnwrapRef<{
+        render: () => JSX.Element;
+    }> & {} & import("vue").ComponentCustomProperties;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import("vue").ComponentOptionsBase<Readonly<any>, {
+    render: () => JSX.Element;
+}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, {} | {
+    [x: string]: any;
+}> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & import("@vue/runtime-core").Plugin;
+export { TAnchorLink };

package/es/anchor/index.js

@@ -0,0 +1,6 @@
+import { withInstall } from "../utils/type.js";
+import Anchor from "./src/anchor.js";
+import AnchorLink from "./src/anchor-link.js";
+const TAnchor = withInstall(Anchor);
+const TAnchorLink = withInstall(AnchorLink);
+export { TAnchor, TAnchorLink };

package/es/anchor/src/anchor-link.d.ts

@@ -0,0 +1,6 @@
+declare const _default: import("vue").DefineComponent<any, {
+    render: () => JSX.Element;
+}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<any>, {} | {
+    [x: string]: any;
+}>;
+export default _default;

package/es/anchor/src/anchor-link.js

@@ -0,0 +1,69 @@
+import { defineComponent, computed, onMounted, onUnmounted, createVNode, Fragment, resolveComponent, mergeProps } from "vue";
+import { PropTypes } from "../../utils/type.js";
+import { useConfig } from "../../utils/hooks/useConfig.js";
+import { TLink } from "../../link/index.js";
+import { injectAnchor } from "./context.js";
+const anchorProps = Object.assign({
+  href: PropTypes.string,
+  type: PropTypes.oneOf(["primary", "success", "warning", "danger", "info", "default"]).def("default"),
+  disabled: PropTypes.bool.def(false),
+  underline: PropTypes.bool.def(false)
+});
+var AnchorLink = defineComponent({
+  name: "TAnchorLink",
+  components: {
+    TLink
+  },
+  inheritAttrs: false,
+  props: anchorProps,
+  setup(props, {
+    slots
+  }) {
+    const {
+      prefixCls,
+      rootPrefix
+    } = useConfig("anchor-link", props);
+    const anchorContext = injectAnchor();
+    const classes = computed(() => {
+      return [prefixCls.value];
+    });
+    const linkClasses = computed(() => {
+      return {
+        [`${rootPrefix.value}-link-active`]: props.href == anchorContext.selectedValue.value
+      };
+    });
+    const handleClick = (event) => {
+      event.preventDefault();
+      event.stopPropagation();
+      anchorContext.handleClick(props.href);
+    };
+    onMounted(() => {
+      anchorContext.registerLink(props.href);
+    });
+    onUnmounted(() => {
+      anchorContext.unregisterLink(props.href);
+    });
+    const render = () => {
+      var _a;
+      return createVNode(Fragment, null, [createVNode("div", {
+        "class": classes.value,
+        "data-href": `#${(_a = props.href) == null ? void 0 : _a.substr(1)}`
+      }, [createVNode(resolveComponent("t-link"), mergeProps(props, {
+        "class": linkClasses.value,
+        "onClick": handleClick
+      }), {
+        default: () => {
+          var _a2;
+          return [(_a2 = slots.default) == null ? void 0 : _a2.call(slots)];
+        }
+      })])]);
+    };
+    return {
+      render
+    };
+  },
+  render() {
+    return this.render();
+  }
+});
+export { AnchorLink as default };

package/es/anchor/src/anchor.d.ts

@@ -0,0 +1,10 @@
+import type { PropType } from 'vue';
+import type { Width } from '../../utils/type';
+declare const _default: import("vue").DefineComponent<{
+    offsetTop: PropType<Width>;
+}, {
+    render: () => JSX.Element;
+}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    offsetTop: PropType<Width>;
+}>>, {}>;
+export default _default;

package/es/anchor/src/anchor.js

@@ -0,0 +1,163 @@
+import { defineComponent, ref, computed, onMounted, onBeforeUnmount, createVNode, Fragment } from "vue";
+import { useConfig } from "../../utils/hooks/useConfig.js";
+import { provideAnchor } from "./context.js";
+import { getLengthNumber, isClient } from "../../utils/common.js";
+const loadingProps = {
+  offsetTop: [String, Number]
+};
+var Anchor = defineComponent({
+  name: "TAnchor",
+  inheritAttrs: false,
+  props: loadingProps,
+  setup(props, {
+    slots
+  }) {
+    const {
+      prefixCls
+    } = useConfig("anchor", props);
+    const linkList = ref([]);
+    const linkPosYList = ref([]);
+    const selectedValue = ref();
+    let processing = false;
+    const refAnchor = ref();
+    const classes = computed(() => {
+      return [prefixCls.value];
+    });
+    const styles = computed(() => {
+      const styles2 = {};
+      return styles2;
+    });
+    const lineClasses = computed(() => {
+      return [`${prefixCls.value}-line`];
+    });
+    const ballClasses = computed(() => {
+      return [`${prefixCls.value}-ball`];
+    });
+    const ballStyles = ref({});
+    const registerLink = (to) => {
+      if (!linkList.value.includes(to))
+        linkList.value.push(to);
+    };
+    const unregisterLink = (to) => {
+      linkList.value.splice(linkList.value.findIndex((item) => item == to), 1);
+    };
+    const handleClick = (href) => {
+      if (!isClient)
+        return;
+      const scrollTop = document.body.scrollTop || document.documentElement.scrollTop;
+      const element = document.querySelector(href);
+      if (!element)
+        return;
+      const rect = element.getBoundingClientRect();
+      selectedValue.value = href;
+      const distance = props.offsetTop ? rect.y + scrollTop - getLengthNumber(props.offsetTop) : rect.y;
+      window.scrollTo({
+        top: distance,
+        left: 0,
+        behavior: "smooth"
+      });
+    };
+    provideAnchor({
+      selectedValue: computed(() => selectedValue.value),
+      registerLink,
+      unregisterLink,
+      handleClick
+    });
+    const offsetTop = computed(() => {
+      if (!props.offsetTop)
+        return 0;
+      return getLengthNumber(props.offsetTop);
+    });
+    const handleScroll = () => {
+      if (!isClient)
+        return;
+      if (processing)
+        return;
+      processing = true;
+      updateContentPosY();
+      const offset = 5;
+      let found = false;
+      if (offsetTop.value >= linkPosYList.value[0].top - offset && offsetTop.value <= linkPosYList.value[linkPosYList.value.length - 1].deepBottom) {
+        for (const index in linkPosYList.value) {
+          if (offsetTop.value < linkPosYList.value[index]["deepBottom"] - offset) {
+            selectedValue.value = linkPosYList.value[index]["href"];
+            updateBallPosY(linkPosYList.value[index]["href"]);
+            found = true;
+            break;
+          }
+        }
+      }
+      if (!found) {
+        selectedValue.value = "";
+      }
+      processing = false;
+    };
+    const updateContentPosY = () => {
+      if (!isClient)
+        return;
+      linkPosYList.value = [];
+      linkList.value.forEach((href) => {
+        const element = document.querySelector(`${href}`);
+        if (!element)
+          return;
+        const rect = element.getBoundingClientRect();
+        linkPosYList.value.push({
+          href,
+          top: rect.top,
+          deepBottom: rect.bottom
+        });
+      });
+      linkPosYList.value.sort((a, b) => {
+        return a.top - b.top;
+      });
+      for (let index = 1; index < linkPosYList.value.length; index++) {
+        linkPosYList.value[index - 1]["deepBottom"] = linkPosYList.value[index]["top"];
+      }
+    };
+    const updateBallPosY = (href) => {
+      if (!isClient)
+        return;
+      const containerRect = refAnchor.value.getBoundingClientRect();
+      const element = refAnchor.value.querySelector(`[data-href='${href}']`);
+      if (!element)
+        return;
+      const rect = element.getBoundingClientRect();
+      const top = rect.top - containerRect.top + rect.height / 2 - 8;
+      ballStyles.value = {
+        top: `${top}px`
+      };
+    };
+    onMounted(() => {
+      if (!isClient)
+        return;
+      window.addEventListener("scroll", handleScroll);
+    });
+    onBeforeUnmount(() => {
+      if (!isClient)
+        return;
+      window.removeEventListener("scroll", handleScroll);
+    });
+    const render = () => {
+      var _a;
+      return createVNode(Fragment, null, [createVNode("div", {
+        "ref": refAnchor,
+        "class": classes.value,
+        "style": styles.value
+      }, [createVNode("div", {
+        "class": lineClasses.value
+      }, [selectedValue.value ? createVNode("div", {
+        "class": ballClasses.value,
+        "style": ballStyles.value
+      }, null) : null]), createVNode("div", {
+        "class": `${prefixCls.value}-list`
+      }, [(_a = slots.default) == null ? void 0 : _a.call(slots)])])]);
+    };
+    return {
+      render
+    };
+  },
+  render() {
+    return this.render();
+  }
+});
+export { Anchor as default };

package/es/anchor/src/context.d.ts

@@ -0,0 +1,11 @@
+import type { InjectionKey, ComputedRef } from 'vue';
+export interface AnchorContext {
+    selectedValue: ComputedRef<string>;
+    registerLink: (href: string) => void;
+    unregisterLink: (href: string) => void;
+    handleClick: (href: string) => void;
+}
+export declare const AnchorContextKey: InjectionKey<AnchorContext>;
+declare const provideAnchor: (data: AnchorContext) => void;
+declare const injectAnchor: () => AnchorContext;
+export { injectAnchor, provideAnchor };

package/es/anchor/src/context.js

@@ -0,0 +1,9 @@
+import { inject, provide } from "vue";
+const AnchorContextKey = Symbol("AnchorContextKey");
+const provideAnchor = (data) => {
+  provide(AnchorContextKey, data);
+};
+const injectAnchor = () => {
+  return inject(AnchorContextKey);
+};
+export { AnchorContextKey, injectAnchor, provideAnchor };