@v-c/menu 0.0.1

package/dist/context/MenuContext.cjs

@@ -0,0 +1,184 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const omit = require("@v-c/util/dist/omit.ts");
+const vue = require("vue");
+const MenuContextKey = Symbol("MenuContextKey");
+function mergeProps(origin, target) {
+  const clone = {
+    ...origin
+  };
+  Object.keys(target).forEach((key) => {
+    const value = target[key];
+    if (value !== void 0) {
+      target[key] = value;
+    }
+  });
+  return clone;
+}
+function useMenuContext() {
+  return vue.inject(MenuContextKey, null);
+}
+function useMenuContextProvider(context) {
+  vue.provide(MenuContextKey, context);
+}
+const InheritableContextProvider = /* @__PURE__ */ vue.defineComponent((props, {
+  slots
+}) => {
+  const context = useMenuContext();
+  const inheritContext = vue.computed(() => {
+    return mergeProps(context?.value ?? {}, omit(props, ["locked"]));
+  });
+  useMenuContextProvider(inheritContext);
+  return () => {
+    return slots?.default?.();
+  };
+}, {
+  props: {
+    locked: {
+      type: Boolean,
+      required: false,
+      default: void 0
+    },
+    prefixCls: {
+      type: String,
+      required: false,
+      default: void 0
+    },
+    classNames: {
+      type: Object,
+      required: false,
+      default: void 0
+    },
+    styles: {
+      type: Object,
+      required: false,
+      default: void 0
+    },
+    rootClassName: {
+      type: String,
+      required: false,
+      default: void 0
+    },
+    openKeys: {
+      type: Array,
+      required: false,
+      default: void 0
+    },
+    rtl: {
+      type: Boolean,
+      required: false,
+      default: void 0
+    },
+    mode: {
+      type: String,
+      required: false,
+      default: void 0
+    },
+    disabled: {
+      type: Boolean,
+      required: false,
+      default: void 0
+    },
+    overflowDisabled: {
+      type: Boolean,
+      required: false,
+      default: void 0
+    },
+    activeKey: {
+      type: String,
+      required: false,
+      default: void 0
+    },
+    onActive: {
+      type: Function,
+      required: false,
+      default: void 0
+    },
+    onInactive: {
+      type: Function,
+      required: false,
+      default: void 0
+    },
+    selectedKeys: {
+      type: Array,
+      required: false,
+      default: void 0
+    },
+    inlineIndent: {
+      type: Number,
+      required: false,
+      default: void 0
+    },
+    motion: {
+      type: Object,
+      required: false,
+      default: void 0
+    },
+    defaultMotions: {
+      type: Object,
+      required: false,
+      default: void 0
+    },
+    subMenuOpenDelay: {
+      type: Number,
+      required: false,
+      default: void 0
+    },
+    subMenuCloseDelay: {
+      type: Number,
+      required: false,
+      default: void 0
+    },
+    forceSubMenuRender: {
+      type: Boolean,
+      required: false,
+      default: void 0
+    },
+    builtinPlacements: {
+      type: Object,
+      required: false,
+      default: void 0
+    },
+    triggerSubMenuAction: {
+      type: String,
+      required: false,
+      default: void 0
+    },
+    popupRender: {
+      type: Function,
+      required: false,
+      default: void 0
+    },
+    itemIcon: {
+      type: [String, Number, null, Array, Function, Boolean],
+      required: false,
+      skipCheck: true,
+      default: void 0
+    },
+    expandIcon: {
+      type: [String, Number, null, Array, Function, Boolean],
+      required: false,
+      skipCheck: true,
+      default: void 0
+    },
+    onItemClick: {
+      type: Function,
+      required: false,
+      default: void 0
+    },
+    onOpenChange: {
+      type: Function,
+      required: false,
+      default: void 0
+    },
+    getPopupContainer: {
+      type: Function,
+      required: false,
+      default: void 0
+    }
+  },
+  inheritAttrs: false
+});
+exports.default = InheritableContextProvider;
+exports.useMenuContext = useMenuContext;
+exports.useMenuContextProvider = useMenuContextProvider;

package/dist/context/MenuContext.d.ts

@@ -0,0 +1,42 @@
+import { CSSMotionProps } from '@v-c/util/dist/utils/transition';
+import { Ref } from 'vue';
+import { BuiltinPlacements, MenuClickEventHandler, MenuMode, PopupRender, RenderIconType, TriggerSubMenuAction } from '../interface.ts';
+import { SubMenuProps } from '../SubMenu';
+export interface MenuContextProps {
+    prefixCls: string;
+    classNames?: SubMenuProps['classNames'];
+    styles?: SubMenuProps['styles'];
+    rootClassName?: string;
+    openKeys: string[];
+    rtl?: boolean;
+    mode: MenuMode;
+    disabled?: boolean;
+    overflowDisabled?: boolean;
+    activeKey: string;
+    onActive: (key: string) => void;
+    onInactive: (key: string) => void;
+    selectedKeys: string[];
+    inlineIndent: number;
+    motion?: CSSMotionProps;
+    defaultMotions?: Partial<{
+        [key in MenuMode | 'other']: CSSMotionProps;
+    }>;
+    subMenuOpenDelay: number;
+    subMenuCloseDelay: number;
+    forceSubMenuRender?: boolean;
+    builtinPlacements?: BuiltinPlacements;
+    triggerSubMenuAction?: TriggerSubMenuAction;
+    popupRender?: PopupRender;
+    itemIcon?: RenderIconType;
+    expandIcon?: RenderIconType;
+    onItemClick: MenuClickEventHandler;
+    onOpenChange: (key: string, open: boolean) => void;
+    getPopupContainer: (node: HTMLElement) => HTMLElement;
+}
+export interface InheritableContextProps extends Partial<MenuContextProps> {
+    locked?: boolean;
+}
+export declare function useMenuContext(): Ref<MenuContextProps, MenuContextProps> | null;
+export declare function useMenuContextProvider(context: Ref<MenuContextProps>): void;
+declare const InheritableContextProvider: import('vue').DefineSetupFnComponent<InheritableContextProps, {}, {}, InheritableContextProps & {}, import('vue').PublicProps>;
+export default InheritableContextProvider;

package/dist/context/MenuContext.js

@@ -0,0 +1,184 @@
+import omit from "@v-c/util/dist/omit.ts";
+import { defineComponent, provide, computed, inject } from "vue";
+const MenuContextKey = Symbol("MenuContextKey");
+function mergeProps(origin, target) {
+  const clone = {
+    ...origin
+  };
+  Object.keys(target).forEach((key) => {
+    const value = target[key];
+    if (value !== void 0) {
+      target[key] = value;
+    }
+  });
+  return clone;
+}
+function useMenuContext() {
+  return inject(MenuContextKey, null);
+}
+function useMenuContextProvider(context) {
+  provide(MenuContextKey, context);
+}
+const InheritableContextProvider = /* @__PURE__ */ defineComponent((props, {
+  slots
+}) => {
+  const context = useMenuContext();
+  const inheritContext = computed(() => {
+    return mergeProps(context?.value ?? {}, omit(props, ["locked"]));
+  });
+  useMenuContextProvider(inheritContext);
+  return () => {
+    return slots?.default?.();
+  };
+}, {
+  props: {
+    locked: {
+      type: Boolean,
+      required: false,
+      default: void 0
+    },
+    prefixCls: {
+      type: String,
+      required: false,
+      default: void 0
+    },
+    classNames: {
+      type: Object,
+      required: false,
+      default: void 0
+    },
+    styles: {
+      type: Object,
+      required: false,
+      default: void 0
+    },
+    rootClassName: {
+      type: String,
+      required: false,
+      default: void 0
+    },
+    openKeys: {
+      type: Array,
+      required: false,
+      default: void 0
+    },
+    rtl: {
+      type: Boolean,
+      required: false,
+      default: void 0
+    },
+    mode: {
+      type: String,
+      required: false,
+      default: void 0
+    },
+    disabled: {
+      type: Boolean,
+      required: false,
+      default: void 0
+    },
+    overflowDisabled: {
+      type: Boolean,
+      required: false,
+      default: void 0
+    },
+    activeKey: {
+      type: String,
+      required: false,
+      default: void 0
+    },
+    onActive: {
+      type: Function,
+      required: false,
+      default: void 0
+    },
+    onInactive: {
+      type: Function,
+      required: false,
+      default: void 0
+    },
+    selectedKeys: {
+      type: Array,
+      required: false,
+      default: void 0
+    },
+    inlineIndent: {
+      type: Number,
+      required: false,
+      default: void 0
+    },
+    motion: {
+      type: Object,
+      required: false,
+      default: void 0
+    },
+    defaultMotions: {
+      type: Object,
+      required: false,
+      default: void 0
+    },
+    subMenuOpenDelay: {
+      type: Number,
+      required: false,
+      default: void 0
+    },
+    subMenuCloseDelay: {
+      type: Number,
+      required: false,
+      default: void 0
+    },
+    forceSubMenuRender: {
+      type: Boolean,
+      required: false,
+      default: void 0
+    },
+    builtinPlacements: {
+      type: Object,
+      required: false,
+      default: void 0
+    },
+    triggerSubMenuAction: {
+      type: String,
+      required: false,
+      default: void 0
+    },
+    popupRender: {
+      type: Function,
+      required: false,
+      default: void 0
+    },
+    itemIcon: {
+      type: [String, Number, null, Array, Function, Boolean],
+      required: false,
+      skipCheck: true,
+      default: void 0
+    },
+    expandIcon: {
+      type: [String, Number, null, Array, Function, Boolean],
+      required: false,
+      skipCheck: true,
+      default: void 0
+    },
+    onItemClick: {
+      type: Function,
+      required: false,
+      default: void 0
+    },
+    onOpenChange: {
+      type: Function,
+      required: false,
+      default: void 0
+    },
+    getPopupContainer: {
+      type: Function,
+      required: false,
+      default: void 0
+    }
+  },
+  inheritAttrs: false
+});
+export {
+  InheritableContextProvider as default,
+  useMenuContext,
+  useMenuContextProvider
+};

package/dist/context/PathContext.cjs

@@ -0,0 +1,100 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const vue = require("vue");
+const EmptyList = [];
+const PathRegisterContextKey = Symbol("PathRegisterContext");
+function useMeasure() {
+  return vue.inject(PathRegisterContextKey, null);
+}
+function useMeasureProvider(context) {
+  vue.provide(PathRegisterContextKey, context);
+}
+const MeasureProvider = /* @__PURE__ */ vue.defineComponent((props, {
+  slots
+}) => {
+  useMeasureProvider(props);
+  return () => {
+    return slots?.default?.();
+  };
+}, {
+  props: {
+    registerPath: {
+      type: Function,
+      required: true,
+      default: void 0
+    },
+    unregisterPath: {
+      type: Function,
+      required: true,
+      default: void 0
+    }
+  }
+});
+const PathTrackerContextKey = Symbol("PathTrackerContext");
+function useFullPath(eventKey) {
+  const parentKeyPath = vue.inject(PathTrackerContextKey, vue.ref(EmptyList));
+  return vue.computed(() => {
+    return eventKey !== void 0 ? [...parentKeyPath.value, eventKey.value] : parentKeyPath.value;
+  });
+}
+const PathTrackerProvider = /* @__PURE__ */ vue.defineComponent((props, {
+  slots
+}) => {
+  vue.provide(PathTrackerContextKey, vue.computed(() => props.value));
+  return () => {
+    return slots?.default?.();
+  };
+}, {
+  props: {
+    value: {
+      type: Array,
+      required: true,
+      default: void 0
+    }
+  }
+});
+const PathUserContextKey = Symbol("PathUserContext");
+function usePathUserContextProvider(context) {
+  vue.provide(PathUserContextKey, context);
+}
+function usePathUserContext() {
+  return vue.inject(PathUserContextKey, {
+    isSubPathKey: () => false
+  });
+}
+const PathUserProvider = /* @__PURE__ */ vue.defineComponent((props, {
+  slots
+}) => {
+  usePathUserContextProvider(props);
+  return () => {
+    return slots?.default?.();
+  };
+}, {
+  props: {
+    isSubPathKey: {
+      type: Function,
+      required: true,
+      default: void 0
+    }
+  }
+});
+const PathTrackerContext = {
+  Provider: PathTrackerProvider
+};
+const PathRegisterContext = {
+  Provider: MeasureProvider
+};
+const PathUserContext = {
+  Provider: PathUserProvider
+};
+exports.MeasureProvider = MeasureProvider;
+exports.PathRegisterContext = PathRegisterContext;
+exports.PathTrackerContext = PathTrackerContext;
+exports.PathTrackerProvider = PathTrackerProvider;
+exports.PathUserContext = PathUserContext;
+exports.PathUserProvider = PathUserProvider;
+exports.useFullPath = useFullPath;
+exports.useMeasure = useMeasure;
+exports.useMeasureProvider = useMeasureProvider;
+exports.usePathUserContext = usePathUserContext;
+exports.usePathUserContextProvider = usePathUserContextProvider;

package/dist/context/PathContext.d.ts

@@ -0,0 +1,33 @@
+import { Ref } from 'vue';
+export interface PathRegisterContextProps {
+    registerPath: (key: string, keyPath: string[]) => void;
+    unregisterPath: (key: string, keyPath: string[]) => void;
+}
+export declare function useMeasure(): PathRegisterContextProps | null;
+export declare function useMeasureProvider(context: PathRegisterContextProps): void;
+export declare const MeasureProvider: import('vue').DefineSetupFnComponent<PathRegisterContextProps, {}, {}, PathRegisterContextProps & {}, import('vue').PublicProps>;
+export declare function useFullPath(eventKey?: Ref<string | undefined>): import('vue').ComputedRef<(string | undefined)[]>;
+export declare const PathTrackerProvider: import('vue').DefineSetupFnComponent<{
+    value: string[];
+}, {}, {}, {
+    value: string[];
+} & {}, import('vue').PublicProps>;
+export interface PathUserContextProps {
+    isSubPathKey: (pathKeys: string[], eventKey: string) => boolean;
+}
+export declare function usePathUserContextProvider(context: PathUserContextProps): void;
+export declare function usePathUserContext(): PathUserContextProps;
+export declare const PathUserProvider: import('vue').DefineSetupFnComponent<PathUserContextProps, {}, {}, PathUserContextProps & {}, import('vue').PublicProps>;
+export declare const PathTrackerContext: {
+    Provider: import('vue').DefineSetupFnComponent<{
+        value: string[];
+    }, {}, {}, {
+        value: string[];
+    } & {}, import('vue').PublicProps>;
+};
+export declare const PathRegisterContext: {
+    Provider: import('vue').DefineSetupFnComponent<PathRegisterContextProps, {}, {}, PathRegisterContextProps & {}, import('vue').PublicProps>;
+};
+export declare const PathUserContext: {
+    Provider: import('vue').DefineSetupFnComponent<PathUserContextProps, {}, {}, PathUserContextProps & {}, import('vue').PublicProps>;
+};

package/dist/context/PathContext.js

@@ -0,0 +1,100 @@
+import { defineComponent, inject, ref, computed, provide } from "vue";
+const EmptyList = [];
+const PathRegisterContextKey = Symbol("PathRegisterContext");
+function useMeasure() {
+  return inject(PathRegisterContextKey, null);
+}
+function useMeasureProvider(context) {
+  provide(PathRegisterContextKey, context);
+}
+const MeasureProvider = /* @__PURE__ */ defineComponent((props, {
+  slots
+}) => {
+  useMeasureProvider(props);
+  return () => {
+    return slots?.default?.();
+  };
+}, {
+  props: {
+    registerPath: {
+      type: Function,
+      required: true,
+      default: void 0
+    },
+    unregisterPath: {
+      type: Function,
+      required: true,
+      default: void 0
+    }
+  }
+});
+const PathTrackerContextKey = Symbol("PathTrackerContext");
+function useFullPath(eventKey) {
+  const parentKeyPath = inject(PathTrackerContextKey, ref(EmptyList));
+  return computed(() => {
+    return eventKey !== void 0 ? [...parentKeyPath.value, eventKey.value] : parentKeyPath.value;
+  });
+}
+const PathTrackerProvider = /* @__PURE__ */ defineComponent((props, {
+  slots
+}) => {
+  provide(PathTrackerContextKey, computed(() => props.value));
+  return () => {
+    return slots?.default?.();
+  };
+}, {
+  props: {
+    value: {
+      type: Array,
+      required: true,
+      default: void 0
+    }
+  }
+});
+const PathUserContextKey = Symbol("PathUserContext");
+function usePathUserContextProvider(context) {
+  provide(PathUserContextKey, context);
+}
+function usePathUserContext() {
+  return inject(PathUserContextKey, {
+    isSubPathKey: () => false
+  });
+}
+const PathUserProvider = /* @__PURE__ */ defineComponent((props, {
+  slots
+}) => {
+  usePathUserContextProvider(props);
+  return () => {
+    return slots?.default?.();
+  };
+}, {
+  props: {
+    isSubPathKey: {
+      type: Function,
+      required: true,
+      default: void 0
+    }
+  }
+});
+const PathTrackerContext = {
+  Provider: PathTrackerProvider
+};
+const PathRegisterContext = {
+  Provider: MeasureProvider
+};
+const PathUserContext = {
+  Provider: PathUserProvider
+};
+export {
+  MeasureProvider,
+  PathRegisterContext,
+  PathTrackerContext,
+  PathTrackerProvider,
+  PathUserContext,
+  PathUserProvider,
+  useFullPath,
+  useMeasure,
+  useMeasureProvider,
+  usePathUserContext,
+  usePathUserContextProvider
+};

package/dist/context/PrivateContext.cjs

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const vue = require("vue");
+const PrivateContextKey = Symbol("PrivateContext");
+function usePrivateProvider(context) {
+  vue.provide(PrivateContextKey, context);
+}
+function usePrivateContext() {
+  return vue.inject(PrivateContextKey, {});
+}
+const PrivateContextProvider = vue.defineComponent(
+  (props, { slots }) => {
+    usePrivateProvider(props);
+    return () => {
+      return slots?.default?.();
+    };
+  },
+  {
+    props: ["_internalRenderMenuItem", "_internalRenderSubMenuItem"]
+  }
+);
+exports.PrivateContextProvider = PrivateContextProvider;
+exports.usePrivateContext = usePrivateContext;
+exports.usePrivateProvider = usePrivateProvider;

package/dist/context/PrivateContext.d.ts

@@ -0,0 +1,8 @@
+import { MenuProps } from '../Menu';
+export interface PrivateContextProps {
+    _internalRenderMenuItem?: MenuProps['_internalRenderMenuItem'];
+    _internalRenderSubMenuItem?: MenuProps['_internalRenderSubMenuItem'];
+}
+export declare function usePrivateProvider(context: PrivateContextProps): void;
+export declare function usePrivateContext(): PrivateContextProps;
+export declare const PrivateContextProvider: import('vue').DefineSetupFnComponent<PrivateContextProps, {}, {}, PrivateContextProps & {}, import('vue').PublicProps>;

package/dist/context/PrivateContext.js

@@ -0,0 +1,24 @@
+import { defineComponent, provide, inject } from "vue";
+const PrivateContextKey = Symbol("PrivateContext");
+function usePrivateProvider(context) {
+  provide(PrivateContextKey, context);
+}
+function usePrivateContext() {
+  return inject(PrivateContextKey, {});
+}
+const PrivateContextProvider = defineComponent(
+  (props, { slots }) => {
+    usePrivateProvider(props);
+    return () => {
+      return slots?.default?.();
+    };
+  },
+  {
+    props: ["_internalRenderMenuItem", "_internalRenderSubMenuItem"]
+  }
+);
+export {
+  PrivateContextProvider,
+  usePrivateContext,
+  usePrivateProvider
+};