@aussieljk/forkbook 0.0.1-7 → 0.0.1-9

package/dist/_browser-chunks/chunk-XKTORVEQ.js

@@ -0,0 +1,255 @@
+import {
+  EMPTY_ARRAY,
+  NOOP,
+  getComputedStyle,
+  isHTMLElement,
+  isReactVersionAtLeast,
+  round,
+  startingStyle,
+  useIsoLayoutEffect,
+  useRefWithInit,
+  useStableCallback
+} from "./chunk-XTQCLWVH.js";
+
+// ../../node_modules/@base-ui/react/internals/useOpenChangeComplete.mjs
+import * as React2 from "react";
+
+// ../../node_modules/@base-ui/react/internals/useAnimationsFinished.mjs
+import * as ReactDOM from "react-dom";
+
+// ../../node_modules/@base-ui/utils/useOnMount.mjs
+import * as React from "react";
+function useOnMount(fn) {
+  React.useEffect(fn, EMPTY_ARRAY);
+}
+
+// ../../node_modules/@base-ui/utils/useAnimationFrame.mjs
+var EMPTY = null, LAST_RAF = globalThis.requestAnimationFrame, Scheduler = class {
+  /* This implementation uses an array as a backing data-structure for frame callbacks.
+   * It allows `O(1)` callback cancelling by inserting a `null` in the array, though it
+   * never calls the native `cancelAnimationFrame` if there are no frames left. This can
+   * be much more efficient if there is a call pattern that alterns as
+   * "request-cancel-request-cancel-…".
+   * But in the case of "request-request-…-cancel-cancel-…", it leaves the final animation
+   * frame to run anyway. We turn that frame into a `O(1)` no-op via `callbacksCount`. */
+  callbacks = [];
+  callbacksCount = 0;
+  nextId = 1;
+  startId = 1;
+  isScheduled = !1;
+  tick = (timestamp) => {
+    this.isScheduled = !1;
+    let currentCallbacks = this.callbacks, currentCallbacksCount = this.callbacksCount;
+    if (this.callbacks = [], this.callbacksCount = 0, this.startId = this.nextId, currentCallbacksCount > 0)
+      for (let i = 0; i < currentCallbacks.length; i += 1)
+        currentCallbacks[i]?.(timestamp);
+  };
+  request(fn) {
+    let id = this.nextId;
+    this.nextId += 1, this.callbacks.push(fn), this.callbacksCount += 1;
+    let didRAFChange = process.env.NODE_ENV !== "production" && LAST_RAF !== requestAnimationFrame && (LAST_RAF = requestAnimationFrame, !0);
+    return (!this.isScheduled || didRAFChange) && (requestAnimationFrame(this.tick), this.isScheduled = !0), id;
+  }
+  cancel(id) {
+    let index = id - this.startId;
+    index < 0 || index >= this.callbacks.length || this.callbacks[index] !== null && (this.callbacks[index] = null, this.callbacksCount -= 1);
+  }
+}, scheduler = new Scheduler();
+var AnimationFrame = class _AnimationFrame {
+  static create() {
+    return new _AnimationFrame();
+  }
+  static request(fn) {
+    return scheduler.request(fn);
+  }
+  static cancel(id) {
+    return scheduler.cancel(id);
+  }
+  currentId = EMPTY;
+  /**
+   * Executes `fn` after `delay`, clearing any previously scheduled call.
+   */
+  request(fn) {
+    this.cancel(), this.currentId = scheduler.request(() => {
+      this.currentId = EMPTY, fn();
+    });
+  }
+  cancel = () => {
+    this.currentId !== EMPTY && (scheduler.cancel(this.currentId), this.currentId = EMPTY);
+  };
+  disposeEffect = () => this.cancel;
+};
+function useAnimationFrame() {
+  let timeout = useRefWithInit(AnimationFrame.create).current;
+  return useOnMount(timeout.disposeEffect), timeout;
+}
+
+// ../../node_modules/@base-ui/react/utils/resolveRef.mjs
+function resolveRef(maybeRef) {
+  return maybeRef == null ? maybeRef : "current" in maybeRef ? maybeRef.current : maybeRef;
+}
+
+// ../../node_modules/@base-ui/react/utils/getFiniteAnimations.mjs
+function getFiniteAnimations(element, options) {
+  return element.getAnimations(options).filter((animation) => {
+    let timing = animation.effect?.getTiming();
+    return timing?.duration !== 1 / 0 && timing?.iterations !== 1 / 0;
+  });
+}
+
+// ../../node_modules/@base-ui/react/internals/useAnimationsFinished.mjs
+var pendingCallbacks = null;
+function flushBeforePaint(fn) {
+  if (!pendingCallbacks) {
+    let callbacks = [];
+    pendingCallbacks = callbacks, queueMicrotask(() => {
+      pendingCallbacks = null, ReactDOM.flushSync(() => {
+        for (let callback of callbacks)
+          callback();
+      });
+    });
+  }
+  pendingCallbacks.push(fn);
+}
+function useAnimationsFinished(elementOrRef, waitForStartingStyleRemoved = !1, batch = !1) {
+  let frame = useAnimationFrame();
+  return useStableCallback((fnToExecute, signal = null) => {
+    frame.cancel();
+    let element = resolveRef(elementOrRef);
+    if (element == null)
+      return;
+    let resolvedElement = element, done = () => {
+      if (!batch) {
+        ReactDOM.flushSync(fnToExecute);
+        return;
+      }
+      flushBeforePaint(() => {
+        signal?.aborted || fnToExecute();
+      });
+    };
+    if (typeof resolvedElement.getAnimations != "function" || globalThis.BASE_UI_ANIMATIONS_DISABLED) {
+      fnToExecute();
+      return;
+    }
+    function exec() {
+      Promise.all(getFiniteAnimations(resolvedElement).map((animation) => animation.finished.then(NOOP))).then(() => {
+        signal?.aborted || done();
+      }, () => {
+        if (signal?.aborted)
+          return;
+        if (getFiniteAnimations(resolvedElement).some((animation) => animation.pending || animation.playState !== "finished")) {
+          exec();
+          return;
+        }
+        done();
+      });
+    }
+    if (waitForStartingStyleRemoved) {
+      let startingStyleAttribute = startingStyle;
+      if (!resolvedElement.hasAttribute(startingStyleAttribute)) {
+        frame.request(exec);
+        return;
+      }
+      let attributeObserver = new MutationObserver(() => {
+        resolvedElement.hasAttribute(startingStyleAttribute) || (attributeObserver.disconnect(), exec());
+      });
+      attributeObserver.observe(resolvedElement, {
+        attributes: !0,
+        attributeFilter: [startingStyleAttribute]
+      }), signal?.addEventListener("abort", () => attributeObserver.disconnect(), {
+        once: !0
+      });
+      return;
+    }
+    frame.request(exec);
+  });
+}
+
+// ../../node_modules/@base-ui/react/internals/useOpenChangeComplete.mjs
+function useOpenChangeComplete(parameters) {
+  let {
+    enabled = !0,
+    open,
+    ref,
+    batch = !1,
+    onComplete: onCompleteParam
+  } = parameters, onComplete = useStableCallback(onCompleteParam), runOnceAnimationsFinish = useAnimationsFinished(ref, open, batch);
+  React2.useEffect(() => {
+    if (!enabled)
+      return;
+    let abortController = new AbortController();
+    return runOnceAnimationsFinish(onComplete, abortController.signal), () => {
+      abortController.abort();
+    };
+  }, [enabled, open, onComplete, runOnceAnimationsFinish]);
+}
+
+// ../../node_modules/@base-ui/utils/inertValue.mjs
+function inertValue(value) {
+  return isReactVersionAtLeast(19) ? value : value ? "true" : void 0;
+}
+
+// ../../node_modules/@base-ui/react/internals/useTransitionStatus.mjs
+import * as React3 from "react";
+function useTransitionStatus(open, enableIdleState = !1, deferEndingState = !1, animateInitialOpen = !1) {
+  let [transitionStatus, setTransitionStatus] = React3.useState(open && enableIdleState ? "idle" : void 0), [mounted, setMounted] = React3.useState(open && !animateInitialOpen);
+  return open && !mounted && (setMounted(!0), setTransitionStatus("starting")), !open && mounted && transitionStatus !== "ending" && !deferEndingState && setTransitionStatus("ending"), !open && !mounted && transitionStatus === "ending" && setTransitionStatus(void 0), useIsoLayoutEffect(() => {
+    if (!open && mounted && transitionStatus !== "ending" && deferEndingState) {
+      let frame = AnimationFrame.request(() => {
+        setTransitionStatus("ending");
+      });
+      return () => {
+        AnimationFrame.cancel(frame);
+      };
+    }
+  }, [open, mounted, transitionStatus, deferEndingState]), useIsoLayoutEffect(() => {
+    if (!open || enableIdleState || transitionStatus === void 0)
+      return;
+    let frame = AnimationFrame.request(() => {
+      setTransitionStatus(void 0);
+    });
+    return () => {
+      AnimationFrame.cancel(frame);
+    };
+  }, [enableIdleState, open, transitionStatus]), useIsoLayoutEffect(() => {
+    if (!open || !enableIdleState)
+      return;
+    open && mounted && transitionStatus !== "idle" && setTransitionStatus("starting");
+    let frame = AnimationFrame.request(() => {
+      setTransitionStatus("idle");
+    });
+    return () => {
+      AnimationFrame.cancel(frame);
+    };
+  }, [enableIdleState, open, mounted, transitionStatus]), {
+    mounted,
+    setMounted,
+    transitionStatus
+  };
+}
+
+// src/shared/use-sync-external-store/shim.ts
+import { useSyncExternalStore } from "react";
+
+// ../../node_modules/@base-ui/react/utils/getCssDimensions.mjs
+function getCssDimensions(element) {
+  let css = getComputedStyle(element), width = parseFloat(css.width) || 0, height = parseFloat(css.height) || 0, hasOffset = isHTMLElement(element), offsetWidth = hasOffset ? element.offsetWidth : width, offsetHeight = hasOffset ? element.offsetHeight : height;
+  return (round(width) !== offsetWidth || round(height) !== offsetHeight) && (width = offsetWidth, height = offsetHeight), {
+    width,
+    height
+  };
+}
+
+export {
+  useOnMount,
+  getFiniteAnimations,
+  AnimationFrame,
+  useAnimationFrame,
+  resolveRef,
+  useTransitionStatus,
+  useAnimationsFinished,
+  useOpenChangeComplete,
+  useSyncExternalStore,
+  inertValue,
+  getCssDimensions
+};