@tamagui/animate-presence 1.88.13 → 1.89.0-1706308641099

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+  Copyright (c) 2020 Nate Wienert
+  
+  Permission is hereby granted, free of charge, to any person obtaining a copy
+  of this software and associated documentation files (the "Software"), to deal
+  in the Software without restriction, including without limitation the rights
+  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+  copies of the Software, and to permit persons to whom the Software is
+  furnished to do so, subject to the following conditions:
+  
+  The above copyright notice and this permission notice shall be included in all
+  copies or substantial portions of the Software.
+  
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+  SOFTWARE.

package/dist/esm/AnimatePresence.mjs

@@ -0,0 +1,93 @@
+import { useForceUpdate } from "@tamagui/use-force-update";
+import { Children, cloneElement, isValidElement, useContext, useRef } from "react";
+import { LayoutGroupContext } from "./LayoutGroupContext.mjs";
+import { PresenceChild } from "./PresenceChild.mjs";
+import { Fragment, jsx } from "react/jsx-runtime";
+const getChildKey = child => child.key || "";
+function updateChildLookup(children, allChildren) {
+  children.forEach(child => {
+    const key = getChildKey(child);
+    allChildren.set(key, child);
+  });
+}
+function onlyElements(children) {
+  const filtered = [];
+  return Children.forEach(children, child => {
+    isValidElement(child) && filtered.push(child);
+  }), filtered;
+}
+const AnimatePresence = ({
+  children,
+  enterVariant,
+  exitVariant,
+  enterExitVariant,
+  initial = !0,
+  onExitComplete,
+  exitBeforeEnter,
+  presenceAffectsLayout = !0,
+  custom
+}) => {
+  let forceRender = useContext(LayoutGroupContext).forceRender ?? useForceUpdate();
+  const filteredChildren = onlyElements(children),
+    presentChildren = useRef(filteredChildren),
+    allChildren = useRef( /* @__PURE__ */new Map()).current,
+    exiting = useRef( /* @__PURE__ */new Set()).current;
+  updateChildLookup(filteredChildren, allChildren);
+  const isInitialRender = useRef(!0);
+  if (isInitialRender.current) return isInitialRender.current = !1, /* @__PURE__ */jsx(Fragment, {
+    children: filteredChildren.map(child => /* @__PURE__ */jsx(PresenceChild, {
+      isPresent: !0,
+      enterExitVariant,
+      exitVariant,
+      enterVariant,
+      initial: initial ? void 0 : !1,
+      presenceAffectsLayout,
+      custom,
+      children: child
+    }, getChildKey(child)))
+  });
+  let childrenToRender = [...filteredChildren];
+  const presentKeys = presentChildren.current.map(getChildKey),
+    targetKeys = filteredChildren.map(getChildKey),
+    numPresent = presentKeys.length;
+  for (let i = 0; i < numPresent; i++) {
+    const key = presentKeys[i];
+    targetKeys.indexOf(key) === -1 ? exiting.add(key) : exiting.delete(key);
+  }
+  return exitBeforeEnter && exiting.size && (childrenToRender = []), exiting.forEach(key => {
+    if (targetKeys.indexOf(key) !== -1) return;
+    const child = allChildren.get(key);
+    if (!child) return;
+    const insertionIndex = presentKeys.indexOf(key),
+      exitingComponent = /* @__PURE__ */jsx(PresenceChild, {
+        isPresent: !1,
+        onExitComplete: () => {
+          allChildren.delete(key), exiting.delete(key);
+          const removeIndex = presentChildren.current.findIndex(presentChild => presentChild.key === key);
+          presentChildren.current.splice(removeIndex, 1), exiting.size || (presentChildren.current = filteredChildren, forceRender(), onExitComplete?.());
+        },
+        presenceAffectsLayout,
+        enterExitVariant,
+        enterVariant,
+        exitVariant,
+        custom,
+        children: child
+      }, getChildKey(child));
+    childrenToRender.splice(insertionIndex, 0, exitingComponent);
+  }), childrenToRender = childrenToRender.map(child => {
+    const key = child.key;
+    return exiting.has(key) ? child : /* @__PURE__ */jsx(PresenceChild, {
+      isPresent: !0,
+      exitVariant,
+      enterVariant,
+      enterExitVariant,
+      presenceAffectsLayout,
+      custom,
+      children: child
+    }, getChildKey(child));
+  }), presentChildren.current = childrenToRender, /* @__PURE__ */jsx(Fragment, {
+    children: exiting.size ? childrenToRender : childrenToRender.map(child => cloneElement(child))
+  });
+};
+AnimatePresence.displayName = "AnimatePresence";
+export { AnimatePresence };

package/dist/esm/LayoutGroupContext.mjs

@@ -0,0 +1,3 @@
+import { createContext } from "react";
+const LayoutGroupContext = createContext({});
+export { LayoutGroupContext };

package/dist/esm/PresenceChild.mjs

@@ -0,0 +1,53 @@
+import { useConstant } from "@tamagui/use-constant";
+import { PresenceContext } from "@tamagui/use-presence";
+import * as React from "react";
+import { useId } from "react";
+import { jsx } from "react/jsx-runtime";
+const PresenceChild = ({
+  children,
+  initial,
+  isPresent,
+  onExitComplete,
+  exitVariant,
+  enterVariant,
+  enterExitVariant,
+  presenceAffectsLayout,
+  custom
+}) => {
+  const presenceChildren = useConstant(newChildrenMap),
+    id = useId() || "",
+    context = React.useMemo(() => ({
+      id,
+      initial,
+      isPresent,
+      custom,
+      exitVariant,
+      enterVariant,
+      enterExitVariant,
+      onExitComplete: id2 => {
+        presenceChildren.set(id2, !0);
+        for (const isComplete of presenceChildren.values()) if (!isComplete) return;
+        onExitComplete?.();
+      },
+      register: id2 => (presenceChildren.set(id2, !1), () => presenceChildren.delete(id2))
+    }),
+    /**
+     * If the presence of a child affects the layout of the components around it,
+     * we want to make a new context value to ensure they get re-rendered
+     * so they can detect that layout change.
+     */
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    presenceAffectsLayout ? void 0 : [isPresent, exitVariant, enterVariant]);
+  return React.useMemo(() => {
+    presenceChildren.forEach((_, key) => presenceChildren.set(key, !1));
+  }, [isPresent]), React.useEffect(() => {
+    !isPresent && !presenceChildren.size && onExitComplete?.();
+  }, [isPresent]), /* @__PURE__ */jsx(PresenceContext.Provider, {
+    value: context,
+    children
+  });
+};
+function newChildrenMap() {
+  return /* @__PURE__ */new Map();
+}
+export { PresenceChild };

package/dist/esm/index.mjs

@@ -0,0 +1,4 @@
+export * from "./AnimatePresence.mjs";
+export * from "@tamagui/use-presence";
+export * from "./types.mjs";
+export * from "./PresenceChild.mjs";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tamagui/animate-presence",
-  "version": "1.88.13",
+  "version": "1.89.0-1706308641099",
   "source": "src/index.ts",
   "sideEffects": false,
   "license": "MIT",
@@ -13,14 +13,14 @@
     "dist"
   ],
   "dependencies": {
-    "@tamagui/helpers": "1.88.13",
-    "@tamagui/use-constant": "1.88.13",
-    "@tamagui/use-force-update": "1.88.13",
-    "@tamagui/use-presence": "1.88.13",
-    "@tamagui/web": "1.88.13"
+    "@tamagui/helpers": "1.89.0-1706308641099",
+    "@tamagui/use-constant": "1.89.0-1706308641099",
+    "@tamagui/use-force-update": "1.89.0-1706308641099",
+    "@tamagui/use-presence": "1.89.0-1706308641099",
+    "@tamagui/web": "1.89.0-1706308641099"
   },
   "devDependencies": {
-    "@tamagui/build": "1.88.13"
+    "@tamagui/build": "1.89.0-1706308641099"
   },
   "scripts": {
     "build": "tamagui-build",