@choice-ui/react 1.3.11 → 1.4.0

package/dist/esm/_vendor/unist-util-is/lib-index.js

@@ -1,100 +0,0 @@
-const convert = (
-  // Note: overloads in JSDoc can’t yet use different `@template`s.
-  /**
-   * @type {(
-   *   (<Condition extends string>(test: Condition) => (node: unknown, index?: number | null | undefined, parent?: Parent | null | undefined, context?: unknown) => node is Node & {type: Condition}) &
-   *   (<Condition extends Props>(test: Condition) => (node: unknown, index?: number | null | undefined, parent?: Parent | null | undefined, context?: unknown) => node is Node & Condition) &
-   *   (<Condition extends TestFunction>(test: Condition) => (node: unknown, index?: number | null | undefined, parent?: Parent | null | undefined, context?: unknown) => node is Node & Predicate<Condition, Node>) &
-   *   ((test?: null | undefined) => (node?: unknown, index?: number | null | undefined, parent?: Parent | null | undefined, context?: unknown) => node is Node) &
-   *   ((test?: Test) => Check)
-   * )}
-   */
-  /**
-   * @param {Test} [test]
-   * @returns {Check}
-   */
-  function(test) {
-    if (test === null || test === void 0) {
-      return ok;
-    }
-    if (typeof test === "function") {
-      return castFactory(test);
-    }
-    if (typeof test === "object") {
-      return Array.isArray(test) ? anyFactory(test) : (
-        // Cast because `ReadonlyArray` goes into the above but `isArray`
-        // narrows to `Array`.
-        propertiesFactory(
-          /** @type {Props} */
-          test
-        )
-      );
-    }
-    if (typeof test === "string") {
-      return typeFactory(test);
-    }
-    throw new Error("Expected function, string, or object as test");
-  }
-);
-function anyFactory(tests) {
-  const checks = [];
-  let index = -1;
-  while (++index < tests.length) {
-    checks[index] = convert(tests[index]);
-  }
-  return castFactory(any);
-  function any(...parameters) {
-    let index2 = -1;
-    while (++index2 < checks.length) {
-      if (checks[index2].apply(this, parameters)) return true;
-    }
-    return false;
-  }
-}
-function propertiesFactory(check) {
-  const checkAsRecord = (
-    /** @type {Record<string, unknown>} */
-    check
-  );
-  return castFactory(all);
-  function all(node) {
-    const nodeAsRecord = (
-      /** @type {Record<string, unknown>} */
-      /** @type {unknown} */
-      node
-    );
-    let key;
-    for (key in check) {
-      if (nodeAsRecord[key] !== checkAsRecord[key]) return false;
-    }
-    return true;
-  }
-}
-function typeFactory(check) {
-  return castFactory(type);
-  function type(node) {
-    return node && node.type === check;
-  }
-}
-function castFactory(testFunction) {
-  return check;
-  function check(value, index, parent) {
-    return Boolean(
-      looksLikeANode(value) && testFunction.call(
-        this,
-        value,
-        typeof index === "number" ? index : void 0,
-        parent || void 0
-      )
-    );
-  }
-}
-function ok() {
-  return true;
-}
-function looksLikeANode(value) {
-  return value !== null && typeof value === "object" && "type" in value;
-}
-export {
-  convert
-};

package/dist/esm/_vendor/unist-util-position/lib-index.js

@@ -1,27 +0,0 @@
-const pointEnd = point("end");
-const pointStart = point("start");
-function point(type) {
-  return point2;
-  function point2(node) {
-    const point3 = node && node.position && node.position[type] || {};
-    if (typeof point3.line === "number" && point3.line > 0 && typeof point3.column === "number" && point3.column > 0) {
-      return {
-        line: point3.line,
-        column: point3.column,
-        offset: typeof point3.offset === "number" && point3.offset > -1 ? point3.offset : void 0
-      };
-    }
-  }
-}
-function position(node) {
-  const start = pointStart(node);
-  const end = pointEnd(node);
-  if (start && end) {
-    return { start, end };
-  }
-}
-export {
-  pointEnd,
-  pointStart,
-  position
-};

package/dist/esm/_vendor/unist-util-stringify-position/lib-index.js

@@ -1,27 +0,0 @@
-function stringifyPosition(value) {
-  if (!value || typeof value !== "object") {
-    return "";
-  }
-  if ("position" in value || "type" in value) {
-    return position(value.position);
-  }
-  if ("start" in value || "end" in value) {
-    return position(value);
-  }
-  if ("line" in value || "column" in value) {
-    return point(value);
-  }
-  return "";
-}
-function point(point2) {
-  return index(point2 && point2.line) + ":" + index(point2 && point2.column);
-}
-function position(pos) {
-  return point(pos && pos.start) + "-" + point(pos && pos.end);
-}
-function index(value) {
-  return value && typeof value === "number" ? value : 1;
-}
-export {
-  stringifyPosition
-};

package/dist/esm/_vendor/unist-util-visit/lib-index.js

@@ -1,28 +0,0 @@
-import { visitParents } from "../unist-util-visit-parents/lib-index.js";
-import { CONTINUE, EXIT, SKIP } from "../unist-util-visit-parents/lib-index.js";
-function visit(tree, testOrVisitor, visitorOrReverse, maybeReverse) {
-  let reverse;
-  let test;
-  let visitor;
-  if (typeof testOrVisitor === "function" && typeof visitorOrReverse !== "function") {
-    test = void 0;
-    visitor = testOrVisitor;
-    reverse = visitorOrReverse;
-  } else {
-    test = testOrVisitor;
-    visitor = visitorOrReverse;
-    reverse = maybeReverse;
-  }
-  visitParents(tree, test, overload, reverse);
-  function overload(node, parents) {
-    const parent = parents[parents.length - 1];
-    const index = parent ? parent.children.indexOf(node) : void 0;
-    return visitor(node, index, parent);
-  }
-}
-export {
-  CONTINUE,
-  EXIT,
-  SKIP,
-  visit
-};

package/dist/esm/_vendor/unist-util-visit-parents/lib-color.js

@@ -1,6 +0,0 @@
-function color(d) {
-  return d;
-}
-export {
-  color
-};

package/dist/esm/_vendor/unist-util-visit-parents/lib-index.js

@@ -1,83 +0,0 @@
-import { color } from "./lib-color.js";
-import { convert } from "../unist-util-is/lib-index.js";
-const empty = [];
-const CONTINUE = true;
-const EXIT = false;
-const SKIP = "skip";
-function visitParents(tree, test, visitor, reverse) {
-  let check;
-  if (typeof test === "function" && typeof visitor !== "function") {
-    reverse = visitor;
-    visitor = test;
-  } else {
-    check = test;
-  }
-  const is = convert(check);
-  const step = reverse ? -1 : 1;
-  factory(tree, void 0, [])();
-  function factory(node, index, parents) {
-    const value = (
-      /** @type {Record<string, unknown>} */
-      node && typeof node === "object" ? node : {}
-    );
-    if (typeof value.type === "string") {
-      const name = (
-        // `hast`
-        typeof value.tagName === "string" ? value.tagName : (
-          // `xast`
-          typeof value.name === "string" ? value.name : void 0
-        )
-      );
-      Object.defineProperty(visit, "name", {
-        value: "node (" + color(node.type + (name ? "<" + name + ">" : "")) + ")"
-      });
-    }
-    return visit;
-    function visit() {
-      let result = empty;
-      let subresult;
-      let offset;
-      let grandparents;
-      if (!test || is(node, index, parents[parents.length - 1] || void 0)) {
-        result = toResult(visitor(node, parents));
-        if (result[0] === EXIT) {
-          return result;
-        }
-      }
-      if ("children" in node && node.children) {
-        const nodeAsParent = (
-          /** @type {UnistParent} */
-          node
-        );
-        if (nodeAsParent.children && result[0] !== SKIP) {
-          offset = (reverse ? nodeAsParent.children.length : -1) + step;
-          grandparents = parents.concat(nodeAsParent);
-          while (offset > -1 && offset < nodeAsParent.children.length) {
-            const child = nodeAsParent.children[offset];
-            subresult = factory(child, offset, grandparents)();
-            if (subresult[0] === EXIT) {
-              return subresult;
-            }
-            offset = typeof subresult[1] === "number" ? subresult[1] : offset + step;
-          }
-        }
-      }
-      return result;
-    }
-  }
-}
-function toResult(value) {
-  if (Array.isArray(value)) {
-    return value;
-  }
-  if (typeof value === "number") {
-    return [CONTINUE, value];
-  }
-  return value === null || value === void 0 ? empty : [value];
-}
-export {
-  CONTINUE,
-  EXIT,
-  SKIP,
-  visitParents
-};

package/dist/esm/_vendor/use-stick-to-bottom/dist-useStickToBottom.js

@@ -1,357 +0,0 @@
-var _a, _b, _c;
-import { useState, useRef, useCallback, useMemo } from "react";
-/*!---------------------------------------------------------------------------------------------
- *  Copyright (c) StackBlitz. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-const DEFAULT_SPRING_ANIMATION = {
-  /**
-   * A value from 0 to 1, on how much to damp the animation.
-   * 0 means no damping, 1 means full damping.
-   *
-   * @default 0.7
-   */
-  damping: 0.7,
-  /**
-   * The stiffness of how fast/slow the animation gets up to speed.
-   *
-   * @default 0.05
-   */
-  stiffness: 0.05,
-  /**
-   * The inertial mass associated with the animation.
-   * Higher numbers make the animation slower.
-   *
-   * @default 1.25
-   */
-  mass: 1.25
-};
-const STICK_TO_BOTTOM_OFFSET_PX = 70;
-const SIXTY_FPS_INTERVAL_MS = 1e3 / 60;
-const RETAIN_ANIMATION_DURATION_MS = 350;
-let mouseDown = false;
-(_a = globalThis.document) == null ? void 0 : _a.addEventListener("mousedown", () => {
-  mouseDown = true;
-});
-(_b = globalThis.document) == null ? void 0 : _b.addEventListener("mouseup", () => {
-  mouseDown = false;
-});
-(_c = globalThis.document) == null ? void 0 : _c.addEventListener("click", () => {
-  mouseDown = false;
-});
-const useStickToBottom = (options = {}) => {
-  const [escapedFromLock, updateEscapedFromLock] = useState(false);
-  const [isAtBottom, updateIsAtBottom] = useState(options.initial !== false);
-  const [isNearBottom, setIsNearBottom] = useState(false);
-  const optionsRef = useRef(null);
-  optionsRef.current = options;
-  const isSelecting = useCallback(() => {
-    var _a2;
-    if (!mouseDown) {
-      return false;
-    }
-    const selection = window.getSelection();
-    if (!selection || !selection.rangeCount) {
-      return false;
-    }
-    const range = selection.getRangeAt(0);
-    return range.commonAncestorContainer.contains(scrollRef.current) || ((_a2 = scrollRef.current) == null ? void 0 : _a2.contains(range.commonAncestorContainer));
-  }, []);
-  const setIsAtBottom = useCallback((isAtBottom2) => {
-    state.isAtBottom = isAtBottom2;
-    updateIsAtBottom(isAtBottom2);
-  }, []);
-  const setEscapedFromLock = useCallback((escapedFromLock2) => {
-    state.escapedFromLock = escapedFromLock2;
-    updateEscapedFromLock(escapedFromLock2);
-  }, []);
-  const state = useMemo(() => {
-    let lastCalculation;
-    return {
-      escapedFromLock,
-      isAtBottom,
-      resizeDifference: 0,
-      accumulated: 0,
-      velocity: 0,
-      listeners: /* @__PURE__ */ new Set(),
-      get scrollTop() {
-        var _a2;
-        return ((_a2 = scrollRef.current) == null ? void 0 : _a2.scrollTop) ?? 0;
-      },
-      set scrollTop(scrollTop) {
-        if (scrollRef.current) {
-          scrollRef.current.scrollTop = scrollTop;
-          state.ignoreScrollToTop = scrollRef.current.scrollTop;
-        }
-      },
-      get targetScrollTop() {
-        if (!scrollRef.current || !contentRef.current) {
-          return 0;
-        }
-        return scrollRef.current.scrollHeight - 1 - scrollRef.current.clientHeight;
-      },
-      get calculatedTargetScrollTop() {
-        if (!scrollRef.current || !contentRef.current) {
-          return 0;
-        }
-        const { targetScrollTop } = this;
-        if (!options.targetScrollTop) {
-          return targetScrollTop;
-        }
-        if ((lastCalculation == null ? void 0 : lastCalculation.targetScrollTop) === targetScrollTop) {
-          return lastCalculation.calculatedScrollTop;
-        }
-        const calculatedScrollTop = Math.max(Math.min(options.targetScrollTop(targetScrollTop, {
-          scrollElement: scrollRef.current,
-          contentElement: contentRef.current
-        }), targetScrollTop), 0);
-        lastCalculation = { targetScrollTop, calculatedScrollTop };
-        requestAnimationFrame(() => {
-          lastCalculation = void 0;
-        });
-        return calculatedScrollTop;
-      },
-      get scrollDifference() {
-        return this.calculatedTargetScrollTop - this.scrollTop;
-      },
-      get isNearBottom() {
-        return this.scrollDifference <= STICK_TO_BOTTOM_OFFSET_PX;
-      }
-    };
-  }, []);
-  const scrollToBottom = useCallback((scrollOptions = {}) => {
-    var _a2;
-    if (typeof scrollOptions === "string") {
-      scrollOptions = { animation: scrollOptions };
-    }
-    if (!scrollOptions.preserveScrollPosition) {
-      setIsAtBottom(true);
-    }
-    const waitElapsed = Date.now() + (Number(scrollOptions.wait) || 0);
-    const behavior = mergeAnimations(optionsRef.current, scrollOptions.animation);
-    const { ignoreEscapes = false } = scrollOptions;
-    let durationElapsed;
-    let startTarget = state.calculatedTargetScrollTop;
-    if (scrollOptions.duration instanceof Promise) {
-      scrollOptions.duration.finally(() => {
-        durationElapsed = Date.now();
-      });
-    } else {
-      durationElapsed = waitElapsed + (scrollOptions.duration ?? 0);
-    }
-    const next = async () => {
-      const promise = new Promise(requestAnimationFrame).then(() => {
-        var _a3;
-        if (!state.isAtBottom) {
-          state.animation = void 0;
-          return false;
-        }
-        const { scrollTop } = state;
-        const tick = performance.now();
-        const tickDelta = (tick - (state.lastTick ?? tick)) / SIXTY_FPS_INTERVAL_MS;
-        state.animation || (state.animation = { behavior, promise, ignoreEscapes });
-        if (state.animation.behavior === behavior) {
-          state.lastTick = tick;
-        }
-        if (isSelecting()) {
-          return next();
-        }
-        if (waitElapsed > Date.now()) {
-          return next();
-        }
-        if (scrollTop < Math.min(startTarget, state.calculatedTargetScrollTop)) {
-          if (((_a3 = state.animation) == null ? void 0 : _a3.behavior) === behavior) {
-            if (behavior === "instant") {
-              state.scrollTop = state.calculatedTargetScrollTop;
-              return next();
-            }
-            state.velocity = (behavior.damping * state.velocity + behavior.stiffness * state.scrollDifference) / behavior.mass;
-            state.accumulated += state.velocity * tickDelta;
-            state.scrollTop += state.accumulated;
-            if (state.scrollTop !== scrollTop) {
-              state.accumulated = 0;
-            }
-          }
-          return next();
-        }
-        if (durationElapsed > Date.now()) {
-          startTarget = state.calculatedTargetScrollTop;
-          return next();
-        }
-        state.animation = void 0;
-        if (state.scrollTop < state.calculatedTargetScrollTop) {
-          return scrollToBottom({
-            animation: mergeAnimations(optionsRef.current, optionsRef.current.resize),
-            ignoreEscapes,
-            duration: Math.max(0, durationElapsed - Date.now()) || void 0
-          });
-        }
-        return state.isAtBottom;
-      });
-      return promise.then((isAtBottom2) => {
-        requestAnimationFrame(() => {
-          if (!state.animation) {
-            state.lastTick = void 0;
-            state.velocity = 0;
-          }
-        });
-        return isAtBottom2;
-      });
-    };
-    if (scrollOptions.wait !== true) {
-      state.animation = void 0;
-    }
-    if (((_a2 = state.animation) == null ? void 0 : _a2.behavior) === behavior) {
-      return state.animation.promise;
-    }
-    return next();
-  }, [setIsAtBottom, isSelecting, state]);
-  const stopScroll = useCallback(() => {
-    setEscapedFromLock(true);
-    setIsAtBottom(false);
-  }, [setEscapedFromLock, setIsAtBottom]);
-  const handleScroll = useCallback(({ target }) => {
-    if (target !== scrollRef.current) {
-      return;
-    }
-    const { scrollTop, ignoreScrollToTop } = state;
-    let { lastScrollTop = scrollTop } = state;
-    state.lastScrollTop = scrollTop;
-    state.ignoreScrollToTop = void 0;
-    if (ignoreScrollToTop && ignoreScrollToTop > scrollTop) {
-      lastScrollTop = ignoreScrollToTop;
-    }
-    setIsNearBottom(state.isNearBottom);
-    setTimeout(() => {
-      var _a2;
-      if (state.resizeDifference || scrollTop === ignoreScrollToTop) {
-        return;
-      }
-      if (isSelecting()) {
-        setEscapedFromLock(true);
-        setIsAtBottom(false);
-        return;
-      }
-      const isScrollingDown = scrollTop > lastScrollTop;
-      const isScrollingUp = scrollTop < lastScrollTop;
-      if ((_a2 = state.animation) == null ? void 0 : _a2.ignoreEscapes) {
-        state.scrollTop = lastScrollTop;
-        return;
-      }
-      if (isScrollingUp) {
-        setEscapedFromLock(true);
-        setIsAtBottom(false);
-      }
-      if (isScrollingDown) {
-        setEscapedFromLock(false);
-      }
-      if (!state.escapedFromLock && state.isNearBottom) {
-        setIsAtBottom(true);
-      }
-    }, 1);
-  }, [setEscapedFromLock, setIsAtBottom, isSelecting, state]);
-  const handleWheel = useCallback(({ target, deltaY }) => {
-    var _a2;
-    let element = target;
-    while (!["scroll", "auto"].includes(getComputedStyle(element).overflow)) {
-      if (!element.parentElement) {
-        return;
-      }
-      element = element.parentElement;
-    }
-    if (element === scrollRef.current && deltaY < 0 && scrollRef.current.scrollHeight > scrollRef.current.clientHeight && !((_a2 = state.animation) == null ? void 0 : _a2.ignoreEscapes)) {
-      setEscapedFromLock(true);
-      setIsAtBottom(false);
-    }
-  }, [setEscapedFromLock, setIsAtBottom, state]);
-  const scrollRef = useRefCallback((scroll) => {
-    var _a2, _b2;
-    (_a2 = scrollRef.current) == null ? void 0 : _a2.removeEventListener("scroll", handleScroll);
-    (_b2 = scrollRef.current) == null ? void 0 : _b2.removeEventListener("wheel", handleWheel);
-    scroll == null ? void 0 : scroll.addEventListener("scroll", handleScroll, { passive: true });
-    scroll == null ? void 0 : scroll.addEventListener("wheel", handleWheel, { passive: true });
-  }, []);
-  const contentRef = useRefCallback((content) => {
-    var _a2, _b2;
-    (_a2 = state.resizeObserver) == null ? void 0 : _a2.disconnect();
-    if (!content) {
-      return;
-    }
-    let previousHeight;
-    state.resizeObserver = new ResizeObserver(([entry]) => {
-      const { height } = entry.contentRect;
-      const difference = height - (previousHeight ?? height);
-      state.resizeDifference = difference;
-      if (state.scrollTop > state.targetScrollTop) {
-        state.scrollTop = state.targetScrollTop;
-      }
-      setIsNearBottom(state.isNearBottom);
-      if (difference >= 0) {
-        const animation = mergeAnimations(optionsRef.current, previousHeight ? optionsRef.current.resize : optionsRef.current.initial);
-        scrollToBottom({
-          animation,
-          wait: true,
-          preserveScrollPosition: true,
-          duration: animation === "instant" ? void 0 : RETAIN_ANIMATION_DURATION_MS
-        });
-      } else {
-        if (state.isNearBottom) {
-          setEscapedFromLock(false);
-          setIsAtBottom(true);
-        }
-      }
-      previousHeight = height;
-      requestAnimationFrame(() => {
-        setTimeout(() => {
-          if (state.resizeDifference === difference) {
-            state.resizeDifference = 0;
-          }
-        }, 1);
-      });
-    });
-    (_b2 = state.resizeObserver) == null ? void 0 : _b2.observe(content);
-  }, []);
-  return {
-    contentRef,
-    scrollRef,
-    scrollToBottom,
-    stopScroll,
-    isAtBottom: isAtBottom || isNearBottom,
-    isNearBottom,
-    escapedFromLock,
-    state
-  };
-};
-function useRefCallback(callback, deps) {
-  const result = useCallback((ref) => {
-    result.current = ref;
-    return callback(ref);
-  }, deps);
-  return result;
-}
-const animationCache = /* @__PURE__ */ new Map();
-function mergeAnimations(...animations) {
-  const result = { ...DEFAULT_SPRING_ANIMATION };
-  let instant = false;
-  for (const animation of animations) {
-    if (animation === "instant") {
-      instant = true;
-      continue;
-    }
-    if (typeof animation !== "object") {
-      continue;
-    }
-    instant = false;
-    result.damping = animation.damping ?? result.damping;
-    result.stiffness = animation.stiffness ?? result.stiffness;
-    result.mass = animation.mass ?? result.mass;
-  }
-  const key = JSON.stringify(result);
-  if (!animationCache.has(key)) {
-    animationCache.set(key, Object.freeze(result));
-  }
-  return instant ? "instant" : animationCache.get(key);
-}
-export {
-  useStickToBottom
-};