panelui-native 0.71.0 → 0.75.0

package/lib/module/components/splitter/index.js

@@ -0,0 +1,433 @@
+"use strict";
+
+/**
+ * Splitter — panes that share a container, with a seam between them the reader
+ * can drag.
+ *
+ * ```tsx
+ * <Splitter className="h-64" defaultLayout={[65, 35]}>
+ *   <Splitter.Panel minSize={30}>{list}</Splitter.Panel>
+ *   <Splitter.Handle />
+ *   <Splitter.Panel minSize={20} collapsible>{detail}</Splitter.Panel>
+ * </Splitter>
+ * ```
+ *
+ * Sizes are percentages of the splitter, so a layout dragged in portrait is
+ * still the same layout in landscape. The splitter itself has no height of its
+ * own — give it one, or put it in something that does, or it collapses to
+ * nothing and takes its panes with it.
+ *
+ * The seams are drawn over the panes rather than between them. A handle that
+ * took layout space would have to be measured before the panes could be sized,
+ * which puts the whole layout downstream of a number nobody controls; floating
+ * it means the panes add up to exactly the container and the handle can be as
+ * wide a target as a finger needs without changing anything.
+ *
+ * Dragging runs on the UI thread. `onLayoutChange` fires when the seam is let
+ * go rather than on every frame, because a layout that round-trips through
+ * React sixty times a second is the one thing that makes this feel slow.
+ */
+import { Children, createContext, isValidElement, useCallback, useContext, useEffect, useMemo, useRef, useState } from 'react';
+import { View } from 'react-native';
+import { Gesture, GestureDetector } from 'react-native-gesture-handler';
+import Animated, { runOnJS, useAnimatedStyle, useSharedValue } from 'react-native-reanimated';
+import { tv } from 'tailwind-variants';
+import { useDirectionSign } from "../../hooks/use-direction.js";
+import { selectionTick } from "../../utils/haptics.js";
+import { isCollapsed, layoutOffset, normalizeConstraint, resizeLayout, resolveLayout } from "./splitter-math.js";
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * How thick the seam's touch target is, in points. Wider than the line it
+ * draws, because the line is a hairline and a hairline is not a target.
+ */
+const HANDLE_THICKNESS = 24;
+const splitterVariants = tv({
+  slots: {
+    root: 'relative overflow-hidden',
+    panel: 'overflow-hidden',
+    handle: 'absolute items-center justify-center',
+    line: 'bg-border',
+    grip: 'absolute rounded-full bg-muted-foreground/30'
+  },
+  variants: {
+    orientation: {
+      horizontal: {
+        // `w-full`, because the panes are shares of a width the splitter has to
+        // already know. Left to size itself, a row asks its children how wide
+        // they are and the children answer with a share of that answer — a
+        // circle that resolves to zero and takes the whole splitter with it.
+        // Inside anything that centres its children, that is what happens.
+        root: 'w-full flex-row',
+        // Over the pane that follows it, not under. A seam is drawn between two
+        // panes but written between them too, and a later sibling paints on top
+        // — which left the outer half of every touch target dead.
+        handle: 'bottom-0 start-0 top-0 z-10 w-6',
+        line: 'h-full w-px',
+        grip: 'h-8 w-1'
+      },
+      vertical: {
+        root: 'flex-col',
+        handle: 'end-0 start-0 top-0 z-10 h-6',
+        line: 'h-px w-full',
+        grip: 'h-1 w-8'
+      }
+    }
+  },
+  defaultVariants: {
+    orientation: 'horizontal'
+  }
+});
+const SplitterContext = /*#__PURE__*/createContext(null);
+const PanelIndexContext = /*#__PURE__*/createContext(0);
+const BoundaryIndexContext = /*#__PURE__*/createContext(-1);
+function useSplitter(component) {
+  const context = useContext(SplitterContext);
+  if (!context) throw new Error(`${component} must be used within a <Splitter>`);
+  return context;
+}
+function isElementOfType(child, type) {
+  return /*#__PURE__*/isValidElement(child) && child.type === type;
+}
+function SplitterRoot({
+  className,
+  orientation = 'horizontal',
+  layout: layoutProp,
+  defaultLayout,
+  onLayoutChange,
+  disabled = false,
+  step = 5,
+  children,
+  onLayout,
+  ...props
+}) {
+  const horizontal = orientation === 'horizontal';
+  const sign = useDirectionSign();
+  const {
+    root
+  } = splitterVariants({
+    orientation
+  });
+  const items = Children.toArray(children);
+  const panels = items.filter(child => isElementOfType(child, SplitterPanel));
+
+  // The panes' limits are read straight off their elements rather than
+  // registered from an effect. A layout that is only correct after the children
+  // have mounted and reported in is a layout that is wrong on the first frame,
+  // and this one is knowable before any of them render.
+  const constraintsKey = JSON.stringify(panels.map(panel => [panel.props.minSize, panel.props.maxSize, panel.props.collapsible === true, panel.props.collapsedSize, panel.props.defaultSize]));
+  const constraints = useMemo(() => panels.map(panel => normalizeConstraint(panel.props)),
+  // eslint-disable-next-line react-hooks/exhaustive-deps
+  [constraintsKey]);
+  const sizesKey = JSON.stringify([layoutProp ?? null, defaultLayout ?? null, panels.map(panel => panel.props.defaultSize ?? null)]);
+  const resolved = useMemo(() => {
+    const declared = layoutProp ?? defaultLayout;
+    return resolveLayout(panels.map((panel, index) => declared?.[index] ?? panel.props.defaultSize), constraints);
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [sizesKey, constraints]);
+  const layout = useSharedValue(resolved);
+  const available = useSharedValue(0);
+  const [measured, setMeasured] = useState(false);
+  const [settled, setSettled] = useState(resolved);
+  // Bumped when a controlled splitter is let go, so a caller that ignored the
+  // change gets the seam put back where its props still say it is.
+  const [syncToken, setSyncToken] = useState(0);
+  const controlled = layoutProp !== undefined;
+  const controlledRef = useRef(controlled);
+  controlledRef.current = controlled;
+  useEffect(() => {
+    layout.value = resolved;
+    setSettled(resolved);
+  }, [resolved, syncToken, layout]);
+  const commit = useCallback(next => {
+    if (controlledRef.current) setSyncToken(token => token + 1);else setSettled(next);
+    onLayoutChange?.(next);
+  }, [onLayoutChange]);
+  const handleLayout = useCallback(event => {
+    const box = event.nativeEvent.layout;
+    const size = horizontal ? box.width : box.height;
+    available.value = size;
+    if (size > 0) setMeasured(true);
+    onLayout?.(event);
+  }, [available, horizontal, onLayout]);
+  const context = useMemo(() => ({
+    orientation,
+    layout,
+    available,
+    measured,
+    settled,
+    initial: resolved,
+    constraints,
+    disabled,
+    // A step of zero or less is a seam that cannot be moved without a drag,
+    // which is the one thing the accessibility actions exist to avoid.
+    step: Number.isFinite(step) && step > 0 ? step : 5,
+    sign,
+    commit
+  }), [orientation, layout, available, measured, settled, resolved, constraints, disabled, step, sign, commit]);
+
+  // Panes learn their index and seams learn which pair they sit between from
+  // where they appear, so nothing has to be numbered by hand and a pane cannot
+  // be given the wrong one.
+  let panelIndex = -1;
+  const laidOut = items.map((child, index) => {
+    if (isElementOfType(child, SplitterPanel)) {
+      panelIndex += 1;
+      return /*#__PURE__*/_jsx(PanelIndexContext.Provider, {
+        value: panelIndex,
+        children: child
+      }, `panel-${panelIndex}`);
+    }
+    if (isElementOfType(child, SplitterHandle)) {
+      return /*#__PURE__*/_jsx(BoundaryIndexContext.Provider, {
+        value: panelIndex,
+        children: child
+      }, `handle-${index}`);
+    }
+    return child;
+  });
+  return /*#__PURE__*/_jsx(SplitterContext.Provider, {
+    value: context,
+    children: /*#__PURE__*/_jsx(View, {
+      className: root({
+        className
+      }),
+      onLayout: handleLayout,
+      ...props,
+      children: laidOut
+    })
+  });
+}
+/**
+ * One pane.
+ *
+ * It clips what is inside it, so a pane dragged narrower hides its content
+ * rather than pushing it into the pane beside it.
+ */
+function SplitterPanel({
+  className,
+  children,
+  style,
+  ...props
+}) {
+  const context = useSplitter('Splitter.Panel');
+  const index = useContext(PanelIndexContext);
+  const {
+    panel
+  } = splitterVariants({
+    orientation: context.orientation
+  });
+  const horizontal = context.orientation === 'horizontal';
+  const animatedStyle = useAnimatedStyle(() => {
+    const size = context.available.value * (context.layout.value[index] ?? 0) / 100;
+    return horizontal ? {
+      width: size
+    } : {
+      height: size
+    };
+  }, [index, horizontal]);
+
+  // Nothing is measured on the first frame, and a pane sized from a container of
+  // zero is a pane nobody can see. Until the measurement lands, a definite flex
+  // basis of zero takes precedence over that width and the shares below carry
+  // the layout — so the first frame is already in proportion, and the switch to
+  // measured points changes nothing anybody can see.
+  const unmeasured = {
+    flexGrow: context.settled[index] ?? 0,
+    flexBasis: 0,
+    flexShrink: 1
+  };
+  return /*#__PURE__*/_jsx(Animated.View, {
+    className: panel({
+      className
+    }),
+    style: [context.measured ? null : unmeasured, style, animatedStyle],
+    ...props,
+    children: children
+  });
+}
+/**
+ * The seam between two panes.
+ *
+ * Put one between each pair. It is `adjustable` to a screen reader, so the
+ * layout can be moved a step at a time without a drag, and a double tap puts
+ * the pair back where it started — the fastest way out of a pane dragged shut
+ * by accident.
+ */
+function SplitterHandle({
+  className,
+  disabled,
+  withGrip = true,
+  accessibilityLabel = 'Resize panels',
+  ...props
+}) {
+  const context = useSplitter('Splitter.Handle');
+  const boundary = useContext(BoundaryIndexContext);
+  const {
+    handle,
+    line,
+    grip
+  } = splitterVariants({
+    orientation: context.orientation
+  });
+  const horizontal = context.orientation === 'horizontal';
+  const frozen = context.disabled || disabled === true;
+  const {
+    layout,
+    available,
+    constraints,
+    sign,
+    commit
+  } = context;
+  const start = useSharedValue([]);
+  const collapsed = useSharedValue(false);
+  const moved = useSharedValue(false);
+  const pan = useMemo(() => {
+    const gesture = Gesture.Pan().enabled(!frozen && boundary >= 0).onBegin(() => {
+      start.value = layout.value.slice();
+      moved.value = false;
+      const constraint = constraints[boundary];
+      collapsed.value = constraint ? isCollapsed(layout.value[boundary] ?? 0, constraint) : false;
+    }).onUpdate(event => {
+      if (available.value <= 0) return;
+      const travelled = horizontal ? event.translationX * sign : event.translationY;
+      const delta = travelled / available.value * 100;
+      const next = resizeLayout(start.value, boundary, delta, constraints);
+      moved.value = true;
+      layout.value = next;
+
+      // The one moment in a drag worth feeling: a pane arriving at shut, or
+      // leaving it. Both are a jump the finger did not make, so the tick is
+      // what says the jump was the control and not a stutter.
+      const constraint = constraints[boundary];
+      if (constraint) {
+        const shut = isCollapsed(next[boundary] ?? 0, constraint);
+        if (shut !== collapsed.value) {
+          collapsed.value = shut;
+          runOnJS(selectionTick)();
+        }
+      }
+    })
+    // A seam that was pressed and not moved has nothing to report, and a
+    // layout change nobody made is a re-render nobody asked for.
+    .onFinalize(() => {
+      if (moved.value) runOnJS(commit)(layout.value.slice());
+    });
+
+    /*
+     * A seam only answers to the axis it moves on. Without that it claims any
+     * movement at all — which is a splitter inside a scroller taking the
+     * scroll, and a drag with no way to fail, which is the one thing the double
+     * tap behind it is waiting for.
+     */
+    return horizontal ? gesture.activeOffsetX([-8, 8]).failOffsetY([-16, 16]) : gesture.activeOffsetY([-8, 8]).failOffsetX([-16, 16]);
+  }, [available, boundary, collapsed, commit, constraints, frozen, horizontal, layout, moved, sign, start]);
+  const {
+    initial
+  } = context;
+  /**
+   * Puts this pair back to the proportions the splitter started with, without
+   * touching the panes further along — the two of them share exactly the room
+   * they already have between them.
+   */
+  const reset = useCallback(() => {
+    const pair = boundary >= 0 ? boundary : 0;
+    const next = layout.value.slice();
+    const room = (next[pair] ?? 0) + (next[pair + 1] ?? 0);
+    const first = initial[pair] ?? 0;
+    const span = first + (initial[pair + 1] ?? 0);
+    if (span <= 0) return;
+    next[pair] = first / span * room;
+    next[pair + 1] = room - next[pair];
+    layout.value = next;
+    commit(next);
+  }, [boundary, commit, initial, layout]);
+  const doubleTap = useMemo(() => Gesture.Tap().numberOfTaps(2)
+  // A tap that has travelled this far is a drag, and saying so is what
+  // lets it give up on the movement rather than on a timer.
+  .maxDistance(HANDLE_THICKNESS / 2).enabled(!frozen && boundary >= 0).onEnd((_event, success) => {
+    if (success) runOnJS(reset)();
+  }), [boundary, frozen, reset]);
+
+  /*
+   * The drag comes first, and the order is the whole of it.
+   *
+   * A race gives its first gesture the priority and makes the rest wait for it
+   * to fail. With the tap in front, every drag was held back until the tap gave
+   * up — which a two-tap gesture only does once its window has expired, half a
+   * second after the finger lands. A slow first drag outlasted that and worked;
+   * the quicker one after it did not, and the seam ignored it.
+   *
+   * Round this way the pan activates on movement, and a press that never moves
+   * fails it and hands the touch on, which is all the tap was waiting for.
+   */
+  const gesture = useMemo(() => Gesture.Race(pan, doubleTap), [doubleTap, pan]);
+  const animatedStyle = useAnimatedStyle(() => {
+    if (available.value <= 0) return {
+      opacity: 0
+    };
+    const seam = available.value * layoutOffset(layout.value, boundary) / 100;
+    const shift = seam - HANDLE_THICKNESS / 2;
+    return {
+      opacity: 1,
+      transform: horizontal ? [{
+        translateX: shift * sign
+      }] : [{
+        translateY: shift
+      }]
+    };
+  }, [boundary, horizontal, sign]);
+
+  // A step moves the seam along the layout, not along the screen, so it is the
+  // one piece of this that the reading direction does not touch: incrementing
+  // grows the pane that comes first either way.
+  const step = useCallback(direction => {
+    const next = resizeLayout(layout.value.slice(), boundary, direction * context.step, constraints);
+    layout.value = next;
+    commit(next);
+  }, [boundary, commit, constraints, context.step, layout]);
+  const onAccessibilityAction = useCallback(event => {
+    if (event.nativeEvent.actionName === 'increment') step(1);else if (event.nativeEvent.actionName === 'decrement') step(-1);
+  }, [step]);
+  const now = Math.round(layoutOffset(context.settled, boundary));
+  return /*#__PURE__*/_jsx(GestureDetector, {
+    gesture: gesture,
+    children: /*#__PURE__*/_jsxs(Animated.View, {
+      accessible: true,
+      accessibilityRole: "adjustable",
+      accessibilityLabel: accessibilityLabel,
+      accessibilityState: {
+        disabled: frozen
+      },
+      accessibilityValue: {
+        min: 0,
+        max: 100,
+        now
+      },
+      accessibilityActions: frozen ? undefined : [{
+        name: 'increment'
+      }, {
+        name: 'decrement'
+      }],
+      onAccessibilityAction: frozen ? undefined : onAccessibilityAction,
+      className: handle({
+        className
+      }),
+      style: animatedStyle,
+      ...props,
+      children: [/*#__PURE__*/_jsx(View, {
+        className: line()
+      }), withGrip ? /*#__PURE__*/_jsx(View, {
+        className: grip()
+      }) : null]
+    })
+  });
+}
+SplitterRoot.displayName = 'Splitter';
+SplitterPanel.displayName = 'Splitter.Panel';
+SplitterHandle.displayName = 'Splitter.Handle';
+export const Splitter = Object.assign(SplitterRoot, {
+  Panel: SplitterPanel,
+  Handle: SplitterHandle
+});
+export { DEFAULT_MAX_SIZE, DEFAULT_MIN_SIZE, isCollapsed, layoutOffset, normalizeConstraint, panelFloor, resizeLayout, resolveLayout } from "./splitter-math.js";
+//# sourceMappingURL=index.js.map

package/lib/module/components/splitter/index.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["Children","createContext","isValidElement","useCallback","useContext","useEffect","useMemo","useRef","useState","View","Gesture","GestureDetector","Animated","runOnJS","useAnimatedStyle","useSharedValue","tv","useDirectionSign","selectionTick","isCollapsed","layoutOffset","normalizeConstraint","resizeLayout","resolveLayout","jsx","_jsx","jsxs","_jsxs","HANDLE_THICKNESS","splitterVariants","slots","root","panel","handle","line","grip","variants","orientation","horizontal","vertical","defaultVariants","SplitterContext","PanelIndexContext","BoundaryIndexContext","useSplitter","component","context","Error","isElementOfType","child","type","SplitterRoot","className","layout","layoutProp","defaultLayout","onLayoutChange","disabled","step","children","onLayout","props","sign","items","toArray","panels","filter","SplitterPanel","constraintsKey","JSON","stringify","map","minSize","maxSize","collapsible","collapsedSize","defaultSize","constraints","sizesKey","resolved","declared","index","available","measured","setMeasured","settled","setSettled","syncToken","setSyncToken","controlled","undefined","controlledRef","current","value","commit","next","token","handleLayout","event","box","nativeEvent","size","width","height","initial","Number","isFinite","panelIndex","laidOut","Provider","SplitterHandle","style","animatedStyle","unmeasured","flexGrow","flexBasis","flexShrink","withGrip","accessibilityLabel","boundary","frozen","start","collapsed","moved","pan","gesture","Pan","enabled","onBegin","slice","constraint","onUpdate","travelled","translationX","translationY","delta","shut","onFinalize","activeOffsetX","failOffsetY","activeOffsetY","failOffsetX","reset","pair","room","first","span","doubleTap","Tap","numberOfTaps","maxDistance","onEnd","_event","success","Race","opacity","seam","shift","transform","translateX","translateY","direction","onAccessibilityAction","actionName","now","Math","round","accessible","accessibilityRole","accessibilityState","accessibilityValue","min","max","accessibilityActions","name","displayName","Splitter","Object","assign","Panel","Handle","DEFAULT_MAX_SIZE","DEFAULT_MIN_SIZE","panelFloor"],"sourceRoot":"../../../../src","sources":["components/splitter/index.tsx"],"mappings":"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","ignoreList":[]}

package/lib/module/components/splitter/splitter-math.js

@@ -0,0 +1,206 @@
+"use strict";
+
+/**
+ * The arithmetic a splitter runs while a seam is under a finger.
+ *
+ * Sizes are percentages of the whole splitter, never points, which is what
+ * makes a dragged layout survive a rotation or a window resize: the numbers
+ * mean the same thing at any container size, so nothing has to be re-measured
+ * and re-derived when one changes.
+ *
+ * It lives apart from the component for two reasons. It is the part with the
+ * edge cases — a pair of panels that cannot both honour their minimums, a
+ * collapse that has to decide between shut and its floor, a caller's sizes that
+ * do not add up — and it is the part that runs on the UI thread, where a wrong
+ * answer is a layout that sticks rather than an exception anybody sees.
+ */
+
+/** How small a panel may get before its neighbour stops taking room, in percent. */
+export const DEFAULT_MIN_SIZE = 10;
+/** How large a panel may get, in percent. */
+export const DEFAULT_MAX_SIZE = 100;
+function clamp(value, low, high) {
+  'worklet';
+
+  return Math.min(Math.max(value, low), high);
+}
+function finite(value, fallback) {
+  'worklet';
+
+  return typeof value === 'number' && Number.isFinite(value) ? value : fallback;
+}
+
+/** The smallest share a panel can hold at all — its floor once shut, or its minimum. */
+export function panelFloor(constraint) {
+  'worklet';
+
+  return constraint.collapsible ? constraint.collapsedSize : constraint.minSize;
+}
+
+/**
+ * Fills a panel's declared limits in, in an order that cannot contradict
+ * itself: the maximum is never below the minimum, and a collapsed size is never
+ * above the minimum it exists to sit below.
+ */
+export function normalizeConstraint(input) {
+  const minSize = clamp(finite(input?.minSize, DEFAULT_MIN_SIZE), 0, 100);
+  const maxSize = clamp(finite(input?.maxSize, DEFAULT_MAX_SIZE), minSize, 100);
+  const collapsible = input?.collapsible === true;
+  const collapsedSize = clamp(finite(input?.collapsedSize, 0), 0, minSize);
+  return {
+    minSize,
+    maxSize,
+    collapsible,
+    collapsedSize
+  };
+}
+function total(layout) {
+  'worklet';
+
+  let sum = 0;
+  for (let index = 0; index < layout.length; index += 1) sum += layout[index];
+  return sum;
+}
+
+/**
+ * Pushes a layout onto exactly 100, moving each panel by its share of the room
+ * it has left in the direction the correction is going. Panels already against
+ * a limit therefore absorb none of it, which is what keeps a correction from
+ * quietly undoing the limit it just honoured.
+ *
+ * Four passes, because clamping after each one can hand the next a smaller
+ * remainder rather than none; it converges long before that in practice, and
+ * the bound is what stops a contradictory set of limits from spinning.
+ */
+function settle(layout, constraints) {
+  'worklet';
+
+  const next = layout.slice();
+  for (let pass = 0; pass < 4; pass += 1) {
+    const remainder = 100 - total(next);
+    if (Math.abs(remainder) < 1e-6) break;
+    let room = 0;
+    const headroom = [];
+    for (let index = 0; index < next.length; index += 1) {
+      const constraint = constraints[index];
+      const available = remainder > 0 ? constraint.maxSize - next[index] : next[index] - panelFloor(constraint);
+      headroom.push(Math.max(available, 0));
+      room += Math.max(available, 0);
+    }
+    if (room <= 1e-6) break;
+    for (let index = 0; index < next.length; index += 1) {
+      next[index] = clamp(next[index] + remainder * headroom[index] / room, panelFloor(constraints[index]), constraints[index].maxSize);
+    }
+  }
+
+  // Minimums that add up to more than the whole cannot all be honoured. Scaling
+  // the whole layout down is the failure that stays legible: every panel is
+  // smaller than it asked for, rather than the last one being pushed out of the
+  // container where nobody can see that it is there at all.
+  const sum = total(next);
+  if (sum > 100 + 1e-6) {
+    for (let index = 0; index < next.length; index += 1) {
+      next[index] = next[index] * 100 / sum;
+    }
+  }
+  return next;
+}
+
+/**
+ * Turns whatever sizes a caller gave into one layout that adds up.
+ *
+ * Panels with no size of their own split what the sized ones left over, so a
+ * three-pane splitter that only pins its sidebar gets the sensible reading of
+ * that: the sidebar keeps its number and the other two share the rest.
+ */
+export function resolveLayout(sizes, constraints) {
+  if (constraints.length === 0) return [];
+  let claimed = 0;
+  let unsized = 0;
+  for (let index = 0; index < constraints.length; index += 1) {
+    const size = sizes[index];
+    if (typeof size === 'number' && Number.isFinite(size)) {
+      claimed += clamp(size, 0, 100);
+    } else {
+      unsized += 1;
+    }
+  }
+  const share = unsized > 0 ? Math.max(100 - claimed, 0) / unsized : 0;
+  const layout = [];
+  for (let index = 0; index < constraints.length; index += 1) {
+    const size = sizes[index];
+    const raw = typeof size === 'number' && Number.isFinite(size) ? clamp(size, 0, 100) : share;
+    layout.push(clamp(raw, panelFloor(constraints[index]), constraints[index].maxSize));
+  }
+  return settle(layout, constraints);
+}
+
+/**
+ * A panel's size once it is below its minimum: shut if it is collapsible and
+ * the drag has gone more than halfway there, and otherwise held at the minimum.
+ *
+ * The halfway point is what makes collapsing feel like a decision rather than
+ * an accident — a finger that grazes the minimum springs back, and one that
+ * keeps going shuts the panel.
+ */
+function snapDown(size, constraint) {
+  'worklet';
+
+  if (size >= constraint.minSize) return size;
+  if (!constraint.collapsible) return constraint.minSize;
+  return size < (constraint.collapsedSize + constraint.minSize) / 2 ? constraint.collapsedSize : constraint.minSize;
+}
+
+/**
+ * Moves one seam, in percent, and hands back the whole layout.
+ *
+ * Only the two panels either side of the seam change: a drag borrows from its
+ * neighbour and nobody else, so the panels further along stay exactly where the
+ * reader left them.
+ *
+ * Collapsing is only ever offered to the panel being shrunk. Both sides could
+ * technically be past their minimum at once at the end of a long drag, and
+ * shutting the panel that is currently growing is never what the drag meant.
+ */
+export function resizeLayout(layout, boundary, delta, constraints) {
+  'worklet';
+
+  const next = layout.slice();
+  if (boundary < 0 || boundary + 1 >= next.length) return next;
+  if (!Number.isFinite(delta)) return next;
+  const first = constraints[boundary];
+  const second = constraints[boundary + 1];
+  if (!first || !second) return next;
+  const pair = next[boundary] + next[boundary + 1];
+  let intended = next[boundary] + delta;
+  if (delta < 0) {
+    intended = snapDown(intended, first);
+  } else if (delta > 0) {
+    intended = pair - snapDown(pair - intended, second);
+  }
+  const low = Math.max(panelFloor(first), pair - second.maxSize);
+  const high = Math.min(first.maxSize, pair - panelFloor(second));
+  if (low > high) return next;
+  next[boundary] = clamp(intended, low, high);
+  next[boundary + 1] = pair - next[boundary];
+  return next;
+}
+
+/** Where a seam sits, in percent, measured from the start of the splitter. */
+export function layoutOffset(layout, boundary) {
+  'worklet';
+
+  let offset = 0;
+  for (let index = 0; index <= boundary && index < layout.length; index += 1) {
+    offset += layout[index];
+  }
+  return offset;
+}
+
+/** Whether a panel is currently shut rather than merely small. */
+export function isCollapsed(size, constraint) {
+  'worklet';
+
+  return constraint.collapsible && size <= constraint.collapsedSize + 1e-6;
+}
+//# sourceMappingURL=splitter-math.js.map