@dmsi/wedgekit-react 0.0.2

package/dist/components/useMenuSystem.cjs

@@ -0,0 +1,358 @@
+"use strict";
+"use client";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/components/useMenuSystem.tsx
+var useMenuSystem_exports = {};
+__export(useMenuSystem_exports, {
+  useMenuPosition: () => useMenuPosition,
+  useSubMenuSystem: () => useSubMenuSystem
+});
+module.exports = __toCommonJS(useMenuSystem_exports);
+var import_react2 = require("react");
+
+// src/components/useMatchesMedia.tsx
+var import_react = require("react");
+var useMatchesMedia = (query) => {
+  const [matches, setMatches] = (0, import_react.useState)(
+    () => typeof window !== "undefined" ? window.matchMedia(query).matches : false
+  );
+  (0, import_react.useLayoutEffect)(() => {
+    const mediaQueryList = window.matchMedia(query);
+    const listener = (event) => {
+      setMatches(event.matches);
+    };
+    mediaQueryList.addEventListener("change", listener);
+    setMatches(mediaQueryList.matches);
+    return () => {
+      mediaQueryList.removeEventListener("change", listener);
+    };
+  }, [query]);
+  return matches;
+};
+var useMatchesMobile = () => {
+  const isMobile = useMatchesMedia("(width < 48rem)");
+  return isMobile;
+};
+
+// src/components/useMenuSystem.tsx
+function useSubMenuSystem(mobilePositionTo) {
+  const [activeMenus, setActiveMenus] = (0, import_react2.useState)(
+    {}
+  );
+  const [activeMenu, setActiveMenu] = (0, import_react2.useState)("");
+  const [currentSubMenuLevel, setCurrentSubMenuLevel] = (0, import_react2.useState)(null);
+  const menuRootRef = (0, import_react2.useRef)(null);
+  const subMenuRefs = (0, import_react2.useRef)({});
+  const hoverTimeoutRef = (0, import_react2.useRef)(null);
+  const closeTimeoutRef = (0, import_react2.useRef)(null);
+  const isMobile = useMatchesMobile();
+  const toggleMenu = (menuId, level) => {
+    if (closeTimeoutRef.current) {
+      clearTimeout(closeTimeoutRef.current);
+      closeTimeoutRef.current = null;
+    }
+    setActiveMenu(menuId);
+    setCurrentSubMenuLevel(level);
+    setActiveMenus((prev) => {
+      const newActiveMenus = __spreadValues({}, prev);
+      if (newActiveMenus[level] === menuId) {
+        delete newActiveMenus[level];
+      } else {
+        newActiveMenus[level] = menuId;
+      }
+      Object.keys(newActiveMenus).forEach((key) => {
+        if (Number(key) > level) {
+          delete newActiveMenus[Number(key)];
+        }
+      });
+      return newActiveMenus;
+    });
+  };
+  const openMenu = (menuId, level) => {
+    if (closeTimeoutRef.current) {
+      clearTimeout(closeTimeoutRef.current);
+      closeTimeoutRef.current = null;
+    }
+    setActiveMenus((prev) => {
+      const newActiveMenus = __spreadValues({}, prev);
+      newActiveMenus[level] = menuId;
+      Object.keys(newActiveMenus).forEach((key) => {
+        if (Number(key) > level) {
+          delete newActiveMenus[Number(key)];
+        }
+      });
+      return newActiveMenus;
+    });
+  };
+  const openMenuWithDelay = (menuId, level, delay = 150) => {
+    if (isMobile) {
+      return;
+    }
+    if (hoverTimeoutRef.current) {
+      clearTimeout(hoverTimeoutRef.current);
+    }
+    hoverTimeoutRef.current = setTimeout(() => {
+      openMenu(menuId, level);
+    }, delay);
+  };
+  const closeMenuWithDelay = (level, delay = 500) => {
+    if (isMobile) {
+      return;
+    }
+    if (hoverTimeoutRef.current) {
+      clearTimeout(hoverTimeoutRef.current);
+      hoverTimeoutRef.current = null;
+    }
+    closeTimeoutRef.current = setTimeout(() => {
+      closeSubMenuLevel(level);
+    }, delay);
+  };
+  const cancelCloseTimeout = () => {
+    if (isMobile) {
+      return;
+    }
+    if (closeTimeoutRef.current) {
+      clearTimeout(closeTimeoutRef.current);
+      closeTimeoutRef.current = null;
+    }
+  };
+  const closeSubMenuLevel = (level) => {
+    setActiveMenus((prev) => {
+      const newActiveMenus = __spreadValues({}, prev);
+      delete newActiveMenus[level];
+      Object.keys(newActiveMenus).forEach((key) => {
+        if (Number(key) >= level) {
+          delete newActiveMenus[Number(key)];
+        }
+      });
+      if (isMobile) {
+        const newSubMenuLevel = level - 1;
+        setCurrentSubMenuLevel(newSubMenuLevel);
+        const newActiveMenu = newActiveMenus[newSubMenuLevel];
+        if (Object.keys(newActiveMenus).length > 0 && newActiveMenu) {
+          setActiveMenu(newActiveMenu);
+        }
+      }
+      return newActiveMenus;
+    });
+  };
+  const registerSubMenu = (id, element) => {
+    subMenuRefs.current[id] = element;
+  };
+  const isMenuActive = (menuId, level) => {
+    return activeMenus[level] === menuId;
+  };
+  (0, import_react2.useEffect)(() => {
+    const handleClickOutside = (event) => {
+      var _a;
+      if (Object.keys(activeMenus).length === 0) return;
+      const target = event.target;
+      if ((_a = menuRootRef.current) == null ? void 0 : _a.contains(target)) return;
+      const isInsideActiveSubmenu = Object.values(activeMenus).some((id) => {
+        const submenuEl = subMenuRefs.current[id];
+        return submenuEl == null ? void 0 : submenuEl.contains(target);
+      });
+      if (!isInsideActiveSubmenu) {
+        setActiveMenus({});
+      }
+    };
+    document.addEventListener("mousedown", handleClickOutside);
+    return () => {
+      document.removeEventListener("mousedown", handleClickOutside);
+    };
+  }, [activeMenus]);
+  (0, import_react2.useEffect)(() => {
+    return () => {
+      if (hoverTimeoutRef.current) {
+        clearTimeout(hoverTimeoutRef.current);
+      }
+      if (closeTimeoutRef.current) {
+        clearTimeout(closeTimeoutRef.current);
+      }
+    };
+  }, []);
+  const getAllFocusableMenuElements = () => {
+    const elements = [];
+    if (menuRootRef.current) {
+      elements.push(...Array.from(menuRootRef.current.children));
+    }
+    Object.values(activeMenus).forEach((menuId) => {
+      const submenuEl = subMenuRefs.current[menuId];
+      if (submenuEl) {
+        elements.push(...Array.from(submenuEl.children));
+      }
+    });
+    return elements;
+  };
+  const findCurrentMenuLevel = (element) => {
+    let current = element.parentElement;
+    while (current) {
+      const level = current.getAttribute("data-menu-level");
+      if (level !== null) {
+        return parseInt(level, 10);
+      }
+      current = current.parentElement;
+    }
+    return 0;
+  };
+  const getMenuElementsAtLevel = (level) => {
+    var _a;
+    if (level === 0 && menuRootRef.current) {
+      return Array.from(menuRootRef.current.children);
+    }
+    const menuId = (_a = Object.entries(activeMenus).find(([, id]) => {
+      const submenuEl = subMenuRefs.current[id];
+      return submenuEl && submenuEl.getAttribute("data-menu-level") === level.toString();
+    })) == null ? void 0 : _a[1];
+    if (menuId) {
+      const submenuEl = subMenuRefs.current[menuId];
+      if (submenuEl) {
+        return Array.from(submenuEl.children);
+      }
+    }
+    return [];
+  };
+  return {
+    menuRootRef,
+    activeMenus,
+    openMenu,
+    isMenuActive,
+    registerSubMenu,
+    closeSubMenuLevel,
+    getAllFocusableMenuElements,
+    findCurrentMenuLevel,
+    getMenuElementsAtLevel,
+    mobileHide: isMobile && Object.keys(activeMenus).length > 0,
+    listeners: {
+      onSubMenuHover: openMenuWithDelay,
+      onSubMenuLeave: closeMenuWithDelay,
+      onSubMenuEnter: cancelCloseTimeout,
+      toggleMenu,
+      mobilePositionTo,
+      activeMenu,
+      currentSubMenuLevel,
+      closeSubMenuLevel
+    }
+  };
+}
+function useMenuPosition(elementRef, position = "bottom", options) {
+  const [menuPosition, setMenuPosition] = (0, import_react2.useState)({
+    top: 0,
+    left: 0,
+    minWidth: 0
+  });
+  const isMobile = useMatchesMobile();
+  const updatePosition = (0, import_react2.useCallback)(() => {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _i;
+    if (!(elementRef == null ? void 0 : elementRef.current)) return;
+    const triggerRect = elementRef.current.getBoundingClientRect();
+    const menuRect = (_b = (_a = options == null ? void 0 : options.menuRef) == null ? void 0 : _a.current) == null ? void 0 : _b.getBoundingClientRect();
+    const viewportWidth = window.innerWidth;
+    const menuWidth = (menuRect == null ? void 0 : menuRect.width) || triggerRect.width;
+    const topOffset = (_c = options == null ? void 0 : options.topOffset) != null ? _c : 4;
+    let top = 0;
+    let left = 0;
+    if (position === "bottom" || position === "bottom-right") {
+      top = triggerRect.top + triggerRect.height + topOffset;
+    } else {
+      top = triggerRect.top;
+    }
+    if (position === "bottom") {
+      left = triggerRect.left + window.scrollX;
+    } else if (position === "bottom-right") {
+      left = triggerRect.right + window.scrollX - menuWidth;
+    } else if (position === "right") {
+      left = triggerRect.right + window.scrollX;
+    }
+    const overflowsLeftViewport = left + menuWidth > viewportWidth;
+    if (overflowsLeftViewport) {
+      left = triggerRect.left - menuWidth;
+    }
+    if (isMobile) {
+      left = triggerRect.left + menuWidth > viewportWidth ? Math.max(viewportWidth - menuWidth, 0) - 8 : triggerRect.left;
+      top = ((_f = (_e = (_d = elementRef.current.parentElement) == null ? void 0 : _d.getBoundingClientRect()) == null ? void 0 : _e.top) != null ? _f : 0) + ((_i = (_h = (_g = elementRef.current.parentElement) == null ? void 0 : _g.getBoundingClientRect()) == null ? void 0 : _h.height) != null ? _i : 0) + topOffset;
+    }
+    setMenuPosition({
+      top,
+      left,
+      minWidth: triggerRect.width
+    });
+  }, [elementRef, position, options == null ? void 0 : options.menuRef, options == null ? void 0 : options.topOffset, isMobile]);
+  (0, import_react2.useEffect)(() => {
+    if (!(options == null ? void 0 : options.isOpen) || !(options == null ? void 0 : options.setIsOpen)) return;
+    const handleClickOutside = (event) => {
+      var _a, _b, _c, _d, _e;
+      const target = event.target;
+      if ((_a = elementRef.current) == null ? void 0 : _a.contains(target)) return;
+      if ((_c = (_b = options.menuRef) == null ? void 0 : _b.current) == null ? void 0 : _c.contains(target)) return;
+      if ((_d = options.additionalRefs) == null ? void 0 : _d.some((ref) => {
+        var _a2;
+        return (_a2 = ref.current) == null ? void 0 : _a2.contains(target);
+      }))
+        return;
+      (_e = options.setIsOpen) == null ? void 0 : _e.call(options, false);
+    };
+    document.addEventListener("mousedown", handleClickOutside);
+    return () => {
+      document.removeEventListener("mousedown", handleClickOutside);
+    };
+  }, [
+    options,
+    elementRef,
+    options == null ? void 0 : options.isOpen,
+    options == null ? void 0 : options.setIsOpen,
+    options == null ? void 0 : options.menuRef,
+    options == null ? void 0 : options.additionalRefs
+  ]);
+  (0, import_react2.useEffect)(() => {
+    updatePosition();
+    const resizeObserver = new ResizeObserver(updatePosition);
+    if (elementRef == null ? void 0 : elementRef.current) {
+      resizeObserver.observe(elementRef.current);
+    }
+    window.addEventListener("scroll", updatePosition);
+    window.addEventListener("resize", updatePosition);
+    return () => {
+      resizeObserver.disconnect();
+      window.removeEventListener("scroll", updatePosition);
+      window.removeEventListener("resize", updatePosition);
+    };
+  }, [elementRef, updatePosition]);
+  return { menuPosition, updatePosition };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  useMenuPosition,
+  useSubMenuSystem
+});

package/dist/components/useMenuSystem.js

@@ -0,0 +1,11 @@
+"use client";
+import {
+  useMenuPosition,
+  useSubMenuSystem
+} from "../chunk-Z4UCFUF7.js";
+import "../chunk-SEKKGFM6.js";
+import "../chunk-ORMEWXMH.js";
+export {
+  useMenuPosition,
+  useSubMenuSystem
+};

package/dist/components/useMounted.cjs

@@ -0,0 +1,39 @@
+"use strict";
+"use client";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/components/useMounted.tsx
+var useMounted_exports = {};
+__export(useMounted_exports, {
+  useMounted: () => useMounted
+});
+module.exports = __toCommonJS(useMounted_exports);
+var import_react = require("react");
+var useMounted = () => {
+  const [isMounted, setIsMounted] = (0, import_react.useState)(false);
+  (0, import_react.useEffect)(() => {
+    setIsMounted(true);
+    return () => setIsMounted(false);
+  }, []);
+  return isMounted;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  useMounted
+});

package/dist/components/useMounted.js

@@ -0,0 +1,8 @@
+"use client";
+import {
+  useMounted
+} from "../chunk-4RJKB7LC.js";
+import "../chunk-ORMEWXMH.js";
+export {
+  useMounted
+};

package/dist/fonts.css

@@ -0,0 +1,21 @@
+/* src/fonts.css */
+@font-face {
+  font-family: "Open Sans";
+  src: url("./open-sans-55T6A4JE.woff2") format("woff2");
+  font-weight: 100 900;
+  font-style: normal;
+}
+@font-face {
+  font-family: "Icons";
+  src: url("./icons-light[FILL]-PPZXOLWS.woff2") format("woff2");
+  font-weight: 300;
+  font-style: normal;
+  font-display: block;
+}
+@font-face {
+  font-family: "Icons";
+  src: url("./icons-normal[FILL]-PPZXOLWS.woff2") format("woff2");
+  font-weight: 400;
+  font-style: normal;
+  font-display: block;
+}