@1771technologies/lytenyte-pro 0.0.41 → 0.0.43

package/dist/CompositeList-CGRaS6LQ.js

@@ -0,0 +1,149 @@
+import * as React from "react";
+import { d as useEnhancedEffect, P as PropTypes } from "./proptypes-BjYr2nFr.js";
+import { jsx } from "react/jsx-runtime";
+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 useCompositeListItem(params = {}) {
+  const {
+    label,
+    metadata
+  } = params;
+  const {
+    register,
+    unregister,
+    map,
+    elementsRef,
+    labelsRef
+  } = useCompositeListContext();
+  const [index, setIndex] = React.useState(null);
+  const componentRef = React.useRef(null);
+  const ref = React.useCallback((node) => {
+    componentRef.current = node;
+    if (index !== null) {
+      elementsRef.current[index] = node;
+      if (labelsRef) {
+        const isLabelDefined = label !== void 0;
+        labelsRef.current[index] = isLabelDefined ? label : node?.textContent ?? null;
+      }
+    }
+  }, [index, elementsRef, labelsRef, label]);
+  useEnhancedEffect(() => {
+    const node = componentRef.current;
+    if (node) {
+      register(node, metadata);
+      return () => {
+        unregister(node);
+      };
+    }
+    return void 0;
+  }, [register, unregister, metadata]);
+  useEnhancedEffect(() => {
+    const i = componentRef.current ? map.get(componentRef.current)?.index : null;
+    if (i != null) {
+      setIndex(i);
+    }
+  }, [map]);
+  return React.useMemo(() => ({
+    ref,
+    index: index == null ? -1 : index
+  }), [index, ref]);
+}
+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;
+export {
+  CompositeList as C,
+  useCompositeListItem as u
+};

package/dist/DirectionContext-DIPP5cAe.js

@@ -0,0 +1,15 @@
+import * as React from "react";
+const DirectionContext = /* @__PURE__ */ React.createContext(void 0);
+if (process.env.NODE_ENV !== "production") {
+  DirectionContext.displayName = "DirectionContext";
+}
+function useDirection(optional = true) {
+  const context = React.useContext(DirectionContext);
+  if (context === void 0 && !optional) {
+    throw new Error("Base UI: DirectionContext is missing.");
+  }
+  return context?.direction ?? "ltr";
+}
+export {
+  useDirection as u
+};

package/dist/InternalBackdrop-C4RACVzs.js

@@ -0,0 +1,324 @@
+import * as React from "react";
+import { m as mergeProps, P as PropTypes } from "./proptypes-BjYr2nFr.js";
+import { jsx } from "react/jsx-runtime";
+function getStyleHookProps(state, customMapping) {
+  let props = {};
+  Object.entries(state).forEach(([key, value]) => {
+    if (customMapping?.hasOwnProperty(key)) {
+      const customProps = customMapping[key](value);
+      if (customProps != null) {
+        props = {
+          ...props,
+          ...customProps
+        };
+      }
+      return;
+    }
+    if (value === true) {
+      props[`data-${key.toLowerCase()}`] = "";
+    } else if (value) {
+      props[`data-${key.toLowerCase()}`] = value.toString();
+    }
+  });
+  return props;
+}
+function resolveClassName(className, state) {
+  return typeof className === "function" ? className(state) : className;
+}
+function evaluateRenderProp(render, props, state) {
+  return typeof render === "function" ? render(props, state) : /* @__PURE__ */ React.cloneElement(render, {
+    ...mergeProps(props, render.props),
+    ref: props.ref
+  });
+}
+function useForkRef(...refs) {
+  const cleanupRef = React.useRef(void 0);
+  const refEffect = React.useCallback((instance) => {
+    const cleanups = refs.map((ref) => {
+      if (ref == null) {
+        return null;
+      }
+      if (typeof ref === "function") {
+        const refCallback = ref;
+        const refCleanup = refCallback(instance);
+        return typeof refCleanup === "function" ? refCleanup : () => {
+          refCallback(null);
+        };
+      }
+      ref.current = instance;
+      return () => {
+        ref.current = null;
+      };
+    });
+    return () => {
+      cleanups.forEach((refCleanup) => refCleanup?.());
+    };
+  }, refs);
+  return React.useMemo(() => {
+    if (refs.every((ref) => ref == null)) {
+      return null;
+    }
+    return (value) => {
+      if (cleanupRef.current) {
+        cleanupRef.current();
+        cleanupRef.current = void 0;
+      }
+      if (value != null) {
+        cleanupRef.current = refEffect(value);
+      }
+    };
+  }, refs);
+}
+const majorVersion = parseInt(React.version, 10);
+function isReactVersionAtLeast(reactVersionToCheck) {
+  return majorVersion >= reactVersionToCheck;
+}
+function useRenderPropForkRef(render, ...refs) {
+  let childRef;
+  if (typeof render !== "function") {
+    childRef = isReactVersionAtLeast(19) ? render.props.ref : render.ref;
+  } else {
+    childRef = null;
+  }
+  return useForkRef(childRef, ...refs);
+}
+const defaultRenderFunctions = {
+  button: (props) => {
+    return /* @__PURE__ */ jsx("button", {
+      type: "button",
+      ...props
+    });
+  },
+  div: (props) => {
+    return /* @__PURE__ */ jsx("div", {
+      ...props
+    });
+  },
+  h2: (props) => {
+    return /* @__PURE__ */ jsx("h2", {
+      ...props
+    });
+  },
+  h3: (props) => {
+    return /* @__PURE__ */ jsx("h3", {
+      ...props
+    });
+  },
+  output: (props) => {
+    return /* @__PURE__ */ jsx("output", {
+      ...props
+    });
+  },
+  p: (props) => {
+    return /* @__PURE__ */ jsx("p", {
+      ...props
+    });
+  },
+  span: (props) => {
+    return /* @__PURE__ */ jsx("span", {
+      ...props
+    });
+  },
+  a: (props) => {
+    return /* @__PURE__ */ jsx("a", {
+      ...props
+    });
+  },
+  label: (props) => {
+    return /* @__PURE__ */ jsx("label", {
+      ...props
+    });
+  },
+  input: (props) => {
+    return /* @__PURE__ */ jsx("input", {
+      ...props
+    });
+  },
+  fieldset: (props) => {
+    return /* @__PURE__ */ jsx("fieldset", {
+      ...props
+    });
+  },
+  form: (props) => {
+    return /* @__PURE__ */ jsx("form", {
+      ...props
+    });
+  },
+  img: (props) => {
+    return /* @__PURE__ */ jsx("img", {
+      alt: "",
+      ...props
+    });
+  }
+};
+const emptyObject = {};
+function useComponentRenderer(settings) {
+  const {
+    render: renderProp,
+    className: classNameProp,
+    state,
+    ref,
+    propGetter = (props) => props,
+    extraProps,
+    customStyleHookMapping,
+    styleHooks: generateStyleHooks = true
+  } = settings;
+  const className = resolveClassName(classNameProp, state);
+  const styleHooks = React.useMemo(() => {
+    if (!generateStyleHooks) {
+      return emptyObject;
+    }
+    return getStyleHookProps(state, customStyleHookMapping);
+  }, [state, customStyleHookMapping, generateStyleHooks]);
+  const ownProps = {
+    ...styleHooks,
+    ...extraProps
+  };
+  let resolvedRenderProp;
+  if (typeof renderProp === "string") {
+    resolvedRenderProp = defaultRenderFunctions[renderProp];
+  } else {
+    resolvedRenderProp = renderProp;
+  }
+  let refs = [];
+  if (ref !== void 0) {
+    refs = Array.isArray(ref) ? ref : [ref];
+  }
+  const renderedElementProps = propGetter(ownProps);
+  const propsWithRef = {
+    ...renderedElementProps,
+    ref: useRenderPropForkRef(resolvedRenderProp, renderedElementProps.ref, ...refs)
+  };
+  if (className !== void 0) {
+    propsWithRef.className = className;
+  }
+  const renderElement = () => evaluateRenderProp(resolvedRenderProp, propsWithRef, state);
+  return {
+    renderElement
+  };
+}
+const TRIGGER_HOOK = {
+  "data-popup-open": ""
+};
+const PRESSABLE_TRIGGER_HOOK = {
+  "data-popup-open": "",
+  "data-pressed": ""
+};
+const POPUP_OPEN_HOOK = {
+  "data-open": ""
+};
+const POPUP_CLOSED_HOOK = {
+  "data-closed": ""
+};
+const ANCHOR_HIDDEN_HOOK = {
+  "data-anchor-hidden": ""
+};
+const triggerOpenStateMapping = {
+  open(value) {
+    if (value) {
+      return TRIGGER_HOOK;
+    }
+    return null;
+  }
+};
+const pressableTriggerOpenStateMapping = {
+  open(value) {
+    if (value) {
+      return PRESSABLE_TRIGGER_HOOK;
+    }
+    return null;
+  }
+};
+const popupStateMapping = {
+  open(value) {
+    if (value) {
+      return POPUP_OPEN_HOOK;
+    }
+    return POPUP_CLOSED_HOOK;
+  },
+  anchorHidden(value) {
+    if (value) {
+      return ANCHOR_HIDDEN_HOOK;
+    }
+    return null;
+  }
+};
+const STARTING_HOOK = {
+  "data-starting-style": ""
+};
+const ENDING_HOOK = {
+  "data-ending-style": ""
+};
+const transitionStatusMapping = {
+  transitionStatus(value) {
+    if (value === "starting") {
+      return STARTING_HOOK;
+    }
+    if (value === "ending") {
+      return ENDING_HOOK;
+    }
+    return null;
+  }
+};
+let globalId = 0;
+function useGlobalId(idOverride, prefix = "mui") {
+  const [defaultId, setDefaultId] = React.useState(idOverride);
+  const id = idOverride || defaultId;
+  React.useEffect(() => {
+    if (defaultId == null) {
+      globalId += 1;
+      setDefaultId(`${prefix}-${globalId}`);
+    }
+  }, [defaultId, prefix]);
+  return id;
+}
+const safeReact = {
+  ...React
+};
+const maybeReactUseId = safeReact.useId;
+function useId(idOverride, prefix) {
+  if (maybeReactUseId !== void 0) {
+    const reactId = maybeReactUseId();
+    return idOverride ?? `${prefix}-${reactId}`;
+  }
+  return useGlobalId(idOverride, prefix);
+}
+function useBaseUiId(idOverride) {
+  return useId(idOverride, "base-ui");
+}
+const InternalBackdrop = /* @__PURE__ */ React.forwardRef(function InternalBackdrop2(props, ref) {
+  return /* @__PURE__ */ jsx("div", {
+    ref,
+    role: "presentation",
+    "data-floating-ui-inert": true,
+    ...props,
+    style: {
+      position: "fixed",
+      inset: 0
+    }
+  });
+});
+process.env.NODE_ENV !== "production" ? InternalBackdrop.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,
+  /**
+   * @ignore
+   */
+  className: PropTypes.string
+} : void 0;
+export {
+  InternalBackdrop as I,
+  useComponentRenderer as a,
+  useBaseUiId as b,
+  pressableTriggerOpenStateMapping as c,
+  triggerOpenStateMapping as d,
+  popupStateMapping as p,
+  transitionStatusMapping as t,
+  useForkRef as u
+};

package/dist/{anchor-context-B9sGQdR5.js → PopoverPortalContext-BdsDjihw.js}

@@ -1,16 +1,14 @@
 import * as React from "react";
-import { createContext, useContext } from "react";
-import { jsx } from "react/jsx-runtime";
 const PopoverRootContext = /* @__PURE__ */ React.createContext(void 0);
 if (process.env.NODE_ENV !== "production") {
   PopoverRootContext.displayName = "PopoverRootContext";
 }
 function usePopoverRootContext() {
-  const context2 = React.useContext(PopoverRootContext);
-  if (context2 === void 0) {
+  const context = React.useContext(PopoverRootContext);
+  if (context === void 0) {
     throw new Error("Base UI: PopoverRootContext is missing. Popover parts must be placed within <Popover.Root>.");
   }
-  return context2;
+  return context;
 }
 const PopoverPortalContext = /* @__PURE__ */ React.createContext(void 0);
 function usePopoverPortalContext() {
@@ -20,16 +18,9 @@ function usePopoverPortalContext() {
   }
   return value;
 }
-const context = createContext(null);
-function AnchorProvider(props) {
-  return /* @__PURE__ */ jsx(context.Provider, { value: props.anchor, children: props.children });
-}
-const useAnchor = () => useContext(context);
 export {
-  AnchorProvider as A,
   PopoverRootContext as P,
   usePopoverPortalContext as a,
-  useAnchor as b,
-  PopoverPortalContext as c,
+  PopoverPortalContext as b,
   usePopoverRootContext as u
 };

package/dist/anchor-context-Cqr_oiJt.js

@@ -0,0 +1,11 @@
+import { jsx } from "react/jsx-runtime";
+import { createContext, useContext } from "react";
+const context = createContext(null);
+function AnchorProvider(props) {
+  return /* @__PURE__ */ jsx(context.Provider, { value: props.anchor, children: props.children });
+}
+const useAnchor = () => useContext(context);
+export {
+  AnchorProvider as A,
+  useAnchor as u
+};

package/dist/column-manager.js

@@ -1,13 +1,14 @@
 import { jsxs, jsx, Fragment } from "react/jsx-runtime";
 import { IsoResizeObserver, getPreciseElementDimensions, clsx } from "@1771technologies/js-utils";
-import { u as useGrid, a as useDragStore, b as useDrag, C as Checkbox, I as Input, G as GridProvider, D as DragProvider } from "./use-grid-DKvzGZWc.js";
+import { u as useDragStore, a as useDrag, C as Checkbox, I as Input, D as DragProvider } from "./drag-store-CO3z13Ju.js";
 import "@1771technologies/react-sizer";
 import { useCombinedRefs, useEvent } from "@1771technologies/react-utils";
 import "@1771technologies/grid-provider";
 import { useRef, useState, useEffect, useCallback, useMemo, createContext, useContext, forwardRef, useId } from "react";
 import "@1771technologies/react-dragon";
 import "@1771technologies/grid-core";
-import { g as useEdgeScroll, h as useDraggable, c as canAgg, a as canMeasure, f as useDroppable, u as useAggregationSource, b as useMeasuresSource, d as useRowGroupsSource, e as useColumnPivotSource, P as Pill, M as MenuTrigger, i as PillManagerAggMenu, j as PillManagerMeasureMenu } from "./pill-C4Jhdf8E.js";
+import { c as useGrid, G as GridProvider } from "./useScrollLock-D4UY33Sb.js";
+import { g as useEdgeScroll, h as useDraggable, c as canAgg, a as canMeasure, f as useDroppable, u as useAggregationSource, b as useMeasuresSource, d as useRowGroupsSource, e as useColumnPivotSource, P as Pill, M as MenuTrigger, i as PillManagerAggMenu, j as PillManagerMeasureMenu } from "./pill-gga9iHqS.js";
 import { A as ArrowRightIcon } from "./tickmark-icon-CoogRMoO.js";
 import { A as ArrowDownIcon } from "./arrow-down-icon-B-3ldODD.js";
 import { D as DragIcon, M as MeasuresIcon, C as ColumnPivotIcon, R as RowGroupIcon } from "./row-group-icon-D8JA6sh9.js";
@@ -15,7 +16,8 @@ import { createPortal } from "react-dom";
 import { D as DragGroupIcon, S as SearchIcon } from "./search-icon-CcG1lqsn.js";
 import { M as MoreDotsIcon } from "./more-dots-icon-CzAH3xHG.js";
 import { C as CrossIcon } from "./cross-icon-CEMLAlFX.js";
-import { M as MenuRoot, a as MenuPortal, b as MenuPositioner } from "./MenuRoot-9n64jNWP.js";
+import { M as MenuRoot, a as MenuPortal } from "./column-menu-driver-cG-EZgLa.js";
+import { M as MenuPositioner } from "./menu-CkfZmNR3.js";
 function Sizer({
   children,
   onSizeChange,