@1771technologies/lytenyte-pro 0.0.39

package/dist/useScrollLock-D6h5lZYs.js

@@ -0,0 +1,515 @@
+import * as React from "react";
+import React__default from "react";
+import { u as useEnhancedEffect, P as PropTypes, N as getUserAgent } from "./InternalBackdrop-Dm9czgoC.js";
+import { jsx } from "react/jsx-runtime";
+function useControlled({
+  controlled,
+  default: defaultProp,
+  name,
+  state = "value"
+}) {
+  const {
+    current: isControlled
+  } = React.useRef(controlled !== void 0);
+  const [valueState, setValue] = React.useState(defaultProp);
+  const value = isControlled ? controlled : valueState;
+  if (process.env.NODE_ENV !== "production") {
+    React.useEffect(() => {
+      if (isControlled !== (controlled !== void 0)) {
+        console.error([`Base UI: A component is changing the ${isControlled ? "" : "un"}controlled ${state} state of ${name} to be ${isControlled ? "un" : ""}controlled.`, "Elements should not switch from uncontrolled to controlled (or vice versa).", `Decide between using a controlled or uncontrolled ${name} element for the lifetime of the component.`, "The nature of the state is determined during the first render. It's considered controlled if the value is not `undefined`.", "More info: https://fb.me/react-controlled-components"].join("\n"));
+      }
+    }, [state, name, controlled]);
+    const {
+      current: defaultValue
+    } = React.useRef(defaultProp);
+    React.useEffect(() => {
+      if (!isControlled && !Object.is(defaultValue, defaultProp)) {
+        console.error([`Base UI: A component is changing the default ${state} state of an uncontrolled ${name} after being initialized. To suppress this warning opt to use a controlled ${name}.`].join("\n"));
+      }
+    }, [JSON.stringify(defaultProp)]);
+  }
+  const setValueIfUncontrolled = React.useCallback((newValue) => {
+    if (!isControlled) {
+      setValue(newValue);
+    }
+  }, []);
+  return [value, setValueIfUncontrolled];
+}
+const CompositeListContext = /* @__PURE__ */ React.createContext({
+  register: () => {
+  },
+  unregister: () => {
+  },
+  map: /* @__PURE__ */ new Map(),
+  elementsRef: {
+    current: []
+  }
+});
+if (process.env.NODE_ENV !== "production") {
+  CompositeListContext.displayName = "CompositeListContext";
+}
+function useCompositeListContext() {
+  return React.useContext(CompositeListContext);
+}
+function useTransitionStatus(open, delayStartingStatus = false) {
+  const [transitionStatus, setTransitionStatus] = React.useState();
+  const [mounted, setMounted] = React.useState(open);
+  if (open && !mounted) {
+    setMounted(true);
+    if (transitionStatus !== "starting" && !delayStartingStatus) {
+      setTransitionStatus("starting");
+    }
+  }
+  if (!open && mounted && transitionStatus !== "ending") {
+    setTransitionStatus("ending");
+  }
+  if (!open && !mounted && transitionStatus === "ending") {
+    setTransitionStatus(void 0);
+  }
+  useEnhancedEffect(() => {
+    if (!open) {
+      return void 0;
+    }
+    if (delayStartingStatus) {
+      setTransitionStatus("starting");
+    }
+    const frame = requestAnimationFrame(() => {
+      setTransitionStatus(void 0);
+    });
+    return () => {
+      cancelAnimationFrame(frame);
+    };
+  }, [open, delayStartingStatus]);
+  return React.useMemo(() => ({
+    mounted,
+    setMounted,
+    transitionStatus
+  }), [mounted, transitionStatus]);
+}
+function sortByDocumentPosition(a, b) {
+  const position = a.compareDocumentPosition(b);
+  if (position & Node.DOCUMENT_POSITION_FOLLOWING || position & Node.DOCUMENT_POSITION_CONTAINED_BY) {
+    return -1;
+  }
+  if (position & Node.DOCUMENT_POSITION_PRECEDING || position & Node.DOCUMENT_POSITION_CONTAINS) {
+    return 1;
+  }
+  return 0;
+}
+function CompositeList(props) {
+  const {
+    children,
+    elementsRef,
+    labelsRef,
+    onMapChange
+  } = props;
+  const [map, setMap] = React.useState(() => /* @__PURE__ */ new Map());
+  const register = React.useCallback((node, metadata) => {
+    setMap((prevMap) => new Map(prevMap).set(node, metadata ?? null));
+  }, []);
+  const unregister = React.useCallback((node) => {
+    setMap((prevMap) => {
+      const nextMap = new Map(prevMap);
+      nextMap.delete(node);
+      return nextMap;
+    });
+  }, []);
+  const sortedMap = React.useMemo(() => {
+    const newMap = /* @__PURE__ */ new Map();
+    const sortedNodes = Array.from(map.keys()).sort(sortByDocumentPosition);
+    sortedNodes.forEach((node, index) => {
+      const metadata = map.get(node) ?? {};
+      newMap.set(node, {
+        ...metadata,
+        index
+      });
+    });
+    return newMap;
+  }, [map]);
+  useEnhancedEffect(() => {
+    onMapChange?.(sortedMap);
+  }, [sortedMap, onMapChange]);
+  const contextValue = React.useMemo(() => ({
+    register,
+    unregister,
+    map: sortedMap,
+    elementsRef,
+    labelsRef
+  }), [register, unregister, sortedMap, elementsRef, labelsRef]);
+  return /* @__PURE__ */ jsx(CompositeListContext.Provider, {
+    value: contextValue,
+    children
+  });
+}
+process.env.NODE_ENV !== "production" ? CompositeList.propTypes = {
+  // ┌────────────────────────────── Warning ──────────────────────────────┐
+  // │ These PropTypes are generated from the TypeScript type definitions. │
+  // │ To update them, edit the TypeScript types and run `pnpm proptypes`. │
+  // └─────────────────────────────────────────────────────────────────────┘
+  /**
+   * @ignore
+   */
+  children: PropTypes.node,
+  /**
+   * A ref to the list of HTML elements, ordered by their index.
+   * `useListNavigation`'s `listRef` prop.
+   */
+  elementsRef: PropTypes.any,
+  /**
+   * A ref to the list of element labels, ordered by their index.
+   * `useTypeahead`'s `listRef` prop.
+   */
+  labelsRef: PropTypes.shape({
+    current: PropTypes.arrayOf(PropTypes.string).isRequired
+  }),
+  /**
+   * @ignore
+   */
+  onMapChange: PropTypes.func
+} : void 0;
+const $f0a04ccd8dbdd83b$export$e5c5a5f917a5871c = typeof document !== "undefined" ? React__default.useLayoutEffect : () => {
+};
+function $ff5963eb1fccf552$export$e08e3b67e392101e(...callbacks) {
+  return (...args) => {
+    for (let callback of callbacks) if (typeof callback === "function") callback(...args);
+  };
+}
+function $c87311424ea30a05$var$testPlatform(re) {
+  var _window_navigator_userAgentData;
+  return typeof window !== "undefined" && window.navigator != null ? re.test(((_window_navigator_userAgentData = window.navigator["userAgentData"]) === null || _window_navigator_userAgentData === void 0 ? void 0 : _window_navigator_userAgentData.platform) || window.navigator.platform) : false;
+}
+function $c87311424ea30a05$var$cached(fn) {
+  let res = null;
+  return () => {
+    if (res == null) res = fn();
+    return res;
+  };
+}
+const $c87311424ea30a05$export$9ac100e40613ea10 = $c87311424ea30a05$var$cached(function() {
+  return $c87311424ea30a05$var$testPlatform(/^Mac/i);
+});
+const $c87311424ea30a05$export$186c6964ca17d99 = $c87311424ea30a05$var$cached(function() {
+  return $c87311424ea30a05$var$testPlatform(/^iPhone/i);
+});
+const $c87311424ea30a05$export$7bef049ce92e4224 = $c87311424ea30a05$var$cached(function() {
+  return $c87311424ea30a05$var$testPlatform(/^iPad/i) || // iPadOS 13 lies and says it's a Mac, but we can distinguish by detecting touch support.
+  $c87311424ea30a05$export$9ac100e40613ea10() && navigator.maxTouchPoints > 1;
+});
+const $c87311424ea30a05$export$fedb369cb70207f1 = $c87311424ea30a05$var$cached(function() {
+  return $c87311424ea30a05$export$186c6964ca17d99() || $c87311424ea30a05$export$7bef049ce92e4224();
+});
+function $cc38e7bd3fc7b213$export$2bb74740c4e19def(node, checkForOverflow) {
+  if (!node) return false;
+  let style = window.getComputedStyle(node);
+  let isScrollable = /(auto|scroll)/.test(style.overflow + style.overflowX + style.overflowY);
+  if (isScrollable && checkForOverflow) isScrollable = node.scrollHeight !== node.clientHeight || node.scrollWidth !== node.clientWidth;
+  return isScrollable;
+}
+function $62d8ded9296f3872$export$cfa2225e87938781(node, checkForOverflow) {
+  let scrollableNode = node;
+  if ($cc38e7bd3fc7b213$export$2bb74740c4e19def(scrollableNode, checkForOverflow)) scrollableNode = scrollableNode.parentElement;
+  while (scrollableNode && !$cc38e7bd3fc7b213$export$2bb74740c4e19def(scrollableNode, checkForOverflow)) scrollableNode = scrollableNode.parentElement;
+  return scrollableNode || document.scrollingElement || document.documentElement;
+}
+const $49c51c25361d4cd2$var$visualViewport = typeof document !== "undefined" && window.visualViewport;
+const $49c51c25361d4cd2$var$nonTextInputTypes = /* @__PURE__ */ new Set([
+  "checkbox",
+  "radio",
+  "range",
+  "color",
+  "file",
+  "image",
+  "button",
+  "submit",
+  "reset"
+]);
+let $49c51c25361d4cd2$var$preventScrollCount = 0;
+let $49c51c25361d4cd2$var$restore;
+function $49c51c25361d4cd2$export$ee0f7cc6afcd1c18(options = {}) {
+  let { isDisabled } = options;
+  $f0a04ccd8dbdd83b$export$e5c5a5f917a5871c(() => {
+    if (isDisabled) return;
+    $49c51c25361d4cd2$var$preventScrollCount++;
+    if ($49c51c25361d4cd2$var$preventScrollCount === 1) {
+      if ($c87311424ea30a05$export$fedb369cb70207f1()) $49c51c25361d4cd2$var$restore = $49c51c25361d4cd2$var$preventScrollMobileSafari();
+      else $49c51c25361d4cd2$var$restore = $49c51c25361d4cd2$var$preventScrollStandard();
+    }
+    return () => {
+      $49c51c25361d4cd2$var$preventScrollCount--;
+      if ($49c51c25361d4cd2$var$preventScrollCount === 0) $49c51c25361d4cd2$var$restore();
+    };
+  }, [
+    isDisabled
+  ]);
+}
+function $49c51c25361d4cd2$var$preventScrollStandard() {
+  return $ff5963eb1fccf552$export$e08e3b67e392101e($49c51c25361d4cd2$var$setStyle(document.documentElement, "paddingRight", `${window.innerWidth - document.documentElement.clientWidth}px`), $49c51c25361d4cd2$var$setStyle(document.documentElement, "overflow", "hidden"));
+}
+function $49c51c25361d4cd2$var$preventScrollMobileSafari() {
+  let scrollable;
+  let restoreScrollableStyles;
+  let onTouchStart = (e) => {
+    scrollable = $62d8ded9296f3872$export$cfa2225e87938781(e.target, true);
+    if (scrollable === document.documentElement && scrollable === document.body) return;
+    if (scrollable instanceof HTMLElement && window.getComputedStyle(scrollable).overscrollBehavior === "auto") restoreScrollableStyles = $49c51c25361d4cd2$var$setStyle(scrollable, "overscrollBehavior", "contain");
+  };
+  let onTouchMove = (e) => {
+    if (!scrollable || scrollable === document.documentElement || scrollable === document.body) {
+      e.preventDefault();
+      return;
+    }
+    if (scrollable.scrollHeight === scrollable.clientHeight && scrollable.scrollWidth === scrollable.clientWidth) e.preventDefault();
+  };
+  let onTouchEnd = () => {
+    if (restoreScrollableStyles) restoreScrollableStyles();
+  };
+  let onFocus = (e) => {
+    let target = e.target;
+    if ($49c51c25361d4cd2$var$willOpenKeyboard(target)) {
+      setupStyles();
+      target.style.transform = "translateY(-2000px)";
+      requestAnimationFrame(() => {
+        target.style.transform = "";
+        if ($49c51c25361d4cd2$var$visualViewport) {
+          if ($49c51c25361d4cd2$var$visualViewport.height < window.innerHeight)
+            requestAnimationFrame(() => {
+              $49c51c25361d4cd2$var$scrollIntoView(target);
+            });
+          else
+            $49c51c25361d4cd2$var$visualViewport.addEventListener("resize", () => $49c51c25361d4cd2$var$scrollIntoView(target), {
+              once: true
+            });
+        }
+      });
+    }
+  };
+  let restoreStyles = null;
+  let setupStyles = () => {
+    if (restoreStyles) return;
+    let onWindowScroll = () => {
+      window.scrollTo(0, 0);
+    };
+    let scrollX = window.pageXOffset;
+    let scrollY = window.pageYOffset;
+    restoreStyles = $ff5963eb1fccf552$export$e08e3b67e392101e($49c51c25361d4cd2$var$addEvent(window, "scroll", onWindowScroll), $49c51c25361d4cd2$var$setStyle(document.documentElement, "paddingRight", `${window.innerWidth - document.documentElement.clientWidth}px`), $49c51c25361d4cd2$var$setStyle(document.documentElement, "overflow", "hidden"), $49c51c25361d4cd2$var$setStyle(document.body, "marginTop", `-${scrollY}px`), () => {
+      window.scrollTo(scrollX, scrollY);
+    });
+    window.scrollTo(0, 0);
+  };
+  let removeEvents = $ff5963eb1fccf552$export$e08e3b67e392101e($49c51c25361d4cd2$var$addEvent(document, "touchstart", onTouchStart, {
+    passive: false,
+    capture: true
+  }), $49c51c25361d4cd2$var$addEvent(document, "touchmove", onTouchMove, {
+    passive: false,
+    capture: true
+  }), $49c51c25361d4cd2$var$addEvent(document, "touchend", onTouchEnd, {
+    passive: false,
+    capture: true
+  }), $49c51c25361d4cd2$var$addEvent(document, "focus", onFocus, true));
+  return () => {
+    restoreScrollableStyles === null || restoreScrollableStyles === void 0 ? void 0 : restoreScrollableStyles();
+    restoreStyles === null || restoreStyles === void 0 ? void 0 : restoreStyles();
+    removeEvents();
+  };
+}
+function $49c51c25361d4cd2$var$setStyle(element, style, value) {
+  let cur = element.style[style];
+  element.style[style] = value;
+  return () => {
+    element.style[style] = cur;
+  };
+}
+function $49c51c25361d4cd2$var$addEvent(target, event, handler, options) {
+  target.addEventListener(event, handler, options);
+  return () => {
+    target.removeEventListener(event, handler, options);
+  };
+}
+function $49c51c25361d4cd2$var$scrollIntoView(target) {
+  let root = document.scrollingElement || document.documentElement;
+  let nextTarget = target;
+  while (nextTarget && nextTarget !== root) {
+    let scrollable = $62d8ded9296f3872$export$cfa2225e87938781(nextTarget);
+    if (scrollable !== document.documentElement && scrollable !== document.body && scrollable !== nextTarget) {
+      let scrollableTop = scrollable.getBoundingClientRect().top;
+      let targetTop = nextTarget.getBoundingClientRect().top;
+      if (targetTop > scrollableTop + nextTarget.clientHeight) scrollable.scrollTop += targetTop - scrollableTop;
+    }
+    nextTarget = scrollable.parentElement;
+  }
+}
+function $49c51c25361d4cd2$var$willOpenKeyboard(target) {
+  return target instanceof HTMLInputElement && !$49c51c25361d4cd2$var$nonTextInputTypes.has(target.type) || target instanceof HTMLTextAreaElement || target instanceof HTMLElement && target.isContentEditable;
+}
+function getNavigatorData() {
+  if (typeof navigator === "undefined") {
+    return {
+      platform: "",
+      maxTouchPoints: -1
+    };
+  }
+  const uaData = navigator.userAgentData;
+  if (uaData?.platform) {
+    return {
+      platform: uaData.platform,
+      maxTouchPoints: navigator.maxTouchPoints
+    };
+  }
+  return {
+    platform: navigator.platform,
+    maxTouchPoints: navigator.maxTouchPoints
+  };
+}
+function isWebKit() {
+  if (typeof CSS === "undefined" || !CSS.supports) {
+    return false;
+  }
+  return CSS.supports("-webkit-backdrop-filter:none");
+}
+function isIOS() {
+  const nav = getNavigatorData();
+  if (nav.platform === "MacIntel" && nav.maxTouchPoints > 1) {
+    return true;
+  }
+  return /iP(hone|ad|od)|iOS/.test(nav.platform);
+}
+function isFirefox() {
+  return /firefox/i.test(getUserAgent());
+}
+function ownerDocument(node) {
+  return node && node.ownerDocument || document;
+}
+function ownerWindow(node) {
+  const doc = ownerDocument(node);
+  return doc.defaultView || window;
+}
+let originalHtmlStyles = {};
+let originalBodyStyles = {};
+let originalHtmlScrollBehavior = "";
+let preventScrollCount = 0;
+let restore = () => {
+};
+function supportsDvh() {
+  return typeof CSS !== "undefined" && typeof CSS.supports === "function" && CSS.supports("height", "1dvh");
+}
+function hasInsetScrollbars(referenceElement) {
+  if (typeof document === "undefined") {
+    return false;
+  }
+  const doc = ownerDocument(referenceElement);
+  const win = ownerWindow(doc);
+  return win.innerWidth - doc.documentElement.clientWidth > 0;
+}
+function preventScrollStandard(referenceElement) {
+  const doc = ownerDocument(referenceElement);
+  const html = doc.documentElement;
+  const body = doc.body;
+  const win = ownerWindow(html);
+  let scrollTop = 0;
+  let scrollLeft = 0;
+  let resizeRaf = -1;
+  if (isWebKit() && (win.visualViewport?.scale ?? 1) !== 1) {
+    return () => {
+    };
+  }
+  function lockScroll() {
+    const htmlStyles = win.getComputedStyle(html);
+    const bodyStyles = win.getComputedStyle(body);
+    scrollTop = html.scrollTop;
+    scrollLeft = html.scrollLeft;
+    originalHtmlStyles = {
+      overflowY: html.style.overflowY,
+      overflowX: html.style.overflowX
+    };
+    originalHtmlScrollBehavior = html.style.scrollBehavior;
+    originalBodyStyles = {
+      position: body.style.position,
+      height: body.style.height,
+      width: body.style.width,
+      boxSizing: body.style.boxSizing,
+      overflowY: body.style.overflowY,
+      overflowX: body.style.overflowX,
+      scrollBehavior: body.style.scrollBehavior
+    };
+    const hasScrollbarGutterStable = htmlStyles.scrollbarGutter?.includes("stable");
+    const isScrollableY = html.scrollHeight > html.clientHeight;
+    const isScrollableX = html.scrollWidth > html.clientWidth;
+    const hasConstantOverflowY = htmlStyles.overflowY === "scroll" || bodyStyles.overflowY === "scroll";
+    const hasConstantOverflowX = htmlStyles.overflowX === "scroll" || bodyStyles.overflowX === "scroll";
+    const scrollbarWidth = Math.max(0, win.innerWidth - html.clientWidth);
+    const scrollbarHeight = Math.max(0, win.innerHeight - html.clientHeight);
+    Object.assign(html.style, {
+      overflowY: !hasScrollbarGutterStable && (isScrollableY || hasConstantOverflowY) ? "scroll" : "hidden",
+      overflowX: !hasScrollbarGutterStable && (isScrollableX || hasConstantOverflowX) ? "scroll" : "hidden"
+    });
+    const marginY = parseFloat(bodyStyles.marginTop) + parseFloat(bodyStyles.marginBottom);
+    const marginX = parseFloat(bodyStyles.marginLeft) + parseFloat(bodyStyles.marginRight);
+    Object.assign(body.style, {
+      position: "relative",
+      height: marginY || scrollbarHeight ? `calc(100dvh - ${marginY + scrollbarHeight}px)` : "100dvh",
+      width: marginX || scrollbarWidth ? `calc(100vw - ${marginX + scrollbarWidth}px)` : "100vw",
+      boxSizing: "border-box",
+      overflow: "hidden",
+      scrollBehavior: "unset"
+    });
+    body.scrollTop = scrollTop;
+    body.scrollLeft = scrollLeft;
+    html.setAttribute("data-base-ui-scroll-locked", "");
+    html.style.scrollBehavior = "unset";
+  }
+  function cleanup() {
+    Object.assign(html.style, originalHtmlStyles);
+    Object.assign(body.style, originalBodyStyles);
+    html.scrollTop = scrollTop;
+    html.scrollLeft = scrollLeft;
+    html.removeAttribute("data-base-ui-scroll-locked");
+    html.style.scrollBehavior = originalHtmlScrollBehavior;
+  }
+  function handleResize() {
+    cleanup();
+    cancelAnimationFrame(resizeRaf);
+    resizeRaf = requestAnimationFrame(lockScroll);
+  }
+  lockScroll();
+  win.addEventListener("resize", handleResize);
+  return () => {
+    cancelAnimationFrame(resizeRaf);
+    cleanup();
+    win.removeEventListener("resize", handleResize);
+  };
+}
+function useScrollLock(enabled = true, referenceElement) {
+  const isReactAriaHook = React.useMemo(() => enabled && (isIOS() || !supportsDvh() || // macOS Firefox "pops" scroll containers' scrollbars with our standard scroll lock
+  isFirefox() && !hasInsetScrollbars(referenceElement)), [enabled, referenceElement]);
+  $49c51c25361d4cd2$export$ee0f7cc6afcd1c18({
+    // react-aria will remove the scrollbar offset immediately upon close, since we use `open`,
+    // not `mounted`, to disable/enable the scroll lock. However since there are no inset
+    // scrollbars, no layouting issues occur.
+    isDisabled: !isReactAriaHook
+  });
+  useEnhancedEffect(() => {
+    if (!enabled || isReactAriaHook) {
+      return void 0;
+    }
+    preventScrollCount += 1;
+    if (preventScrollCount === 1) {
+      restore = preventScrollStandard(referenceElement);
+    }
+    return () => {
+      preventScrollCount -= 1;
+      if (preventScrollCount === 0) {
+        restore();
+      }
+    };
+  }, [enabled, isReactAriaHook, referenceElement]);
+}
+export {
+  CompositeList as C,
+  useControlled as a,
+  useTransitionStatus as b,
+  useScrollLock as c,
+  ownerWindow as d,
+  isWebKit as i,
+  ownerDocument as o,
+  useCompositeListContext as u
+};

package/package.json

@@ -0,0 +1,96 @@
+{
+  "name": "@1771technologies/lytenyte-pro",
+  "version": "0.0.39",
+  "license": "COMMERCIAL",
+  "type": "module",
+  "files": [
+    "dist",
+    "LICENSE"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/types/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.js"
+    },
+    "./types": {
+      "types": "./dist/types/types.d.ts",
+      "import": "./dist/types.js",
+      "require": "./dist/types.js"
+    },
+    "./icons": {
+      "types": "./dist/types/icons.d.ts",
+      "import": "./dist/icons.js",
+      "require": "./dist/icons.js"
+    },
+    "./grid-container": {
+      "types": "./dist/types/grid-container/grid-container.d.ts",
+      "import": "./dist/grid-container.js",
+      "require": "./dist/grid-container.js"
+    },
+    "./menu": {
+      "types": "./dist/types/menu/menu.d.ts",
+      "import": "./dist/menu.js",
+      "require": "./dist/menu.js"
+    },
+    "./column-manager": {
+      "types": "./dist/types/column-manager/column-manager.d.ts",
+      "import": "./dist/column-manager.js",
+      "require": "./dist/column-manager.js"
+    },
+    "./pill-manager": {
+      "types": "./dist/types/pill-manager/pill-manager.d.ts",
+      "import": "./dist/pill-manager.js",
+      "require": "./dist/pill-manager.js"
+    },
+    "./sort-manager": {
+      "types": "./dist/types/sort-manager/sort-manager.d.ts",
+      "import": "./dist/sort-manager.js",
+      "require": "./dist/sort-manager.js"
+    },
+    "./dialog": {
+      "types": "./dist/types/dialog/dialog.d.ts",
+      "import": "./dist/dialog.js",
+      "require": "./dist/dialog.js"
+    },
+    "./popover": {
+      "types": "./dist/types/popover/popover.d.ts",
+      "import": "./dist/popover.js",
+      "require": "./dist/popover.js"
+    },
+    "./filters": {
+      "types": "./dist/types/filter-manager/filter-manager.d.ts",
+      "import": "./dist/filter-manager.js",
+      "require": "./dist/filter-manager.js"
+    },
+    "./grid.css": "./dist/lytenyte-pro.css"
+  },
+  "peerDependencies": {
+    "react": "^18.0.0 || ^19.0.0",
+    "react-dom": "^18.0.0 || ^19.0.0"
+  },
+  "dependencies": {
+    "@1771technologies/grid-client-data-source-pro": "0.0.39",
+    "@1771technologies/grid-core": "0.0.39",
+    "@1771technologies/grid-design": "0.0.39",
+    "@1771technologies/grid-provider": "0.0.39",
+    "@1771technologies/grid-store-pro": "0.0.39",
+    "@1771technologies/grid-tree-data-source": "0.0.39",
+    "@1771technologies/grid-types": "0.0.39",
+    "@1771technologies/js-utils": "0.0.39",
+    "@1771technologies/lytenyte-core": "0.0.39",
+    "@1771technologies/positioner": "0.0.39",
+    "@1771technologies/react-cascada": "0.0.39",
+    "@1771technologies/react-dragon": "0.0.39",
+    "@1771technologies/react-popover": "0.0.39",
+    "@1771technologies/react-sizer": "0.0.39",
+    "@1771technologies/react-split-pane": "0.0.39",
+    "@1771technologies/react-utils": "0.0.39",
+    "@base-ui-components/react": "1.0.0-alpha.7"
+  },
+  "devDependencies": {
+    "@types/react": "^19.0.1",
+    "@types/react-dom": "^19.0.2"
+  },
+  "access": "public"
+}