yeet

modules/panels/isChannelFocused.native.tsx

@@ -0,0 +1,152 @@
+// Metro module 10253 (f10254).
+import { useState, useEffect } from "react";
+import ChannelRTCStore from "../calls/ChannelRTCStore";
+import NavigationHistoryStore, { CHANNEL_PREFIX } from "../main_tabs_v2/native/NavigationHistoryStore";
+import VoicePanelStore from "../voice_panel/VoicePanelStore";
+import getInitialNavigationState from "../main_tabs_v2/native/getInitialNavigationState";
+import { coerceChannelRoute, coerceGuildsRoute, coerceMainRoute, coerceTabsRoute } from "../main_tabs_v2/helpers/NavigationRouteUtils.native";
+import { getRootNavigationRef } from "../main_tabs_v2/RootNavigationRef.native";
+import useChatLayout, { getChatLayout } from "../chat/native/useChatLayout";
+let channelId;
+const getFocusedChannelId = function getFocusedChannelId() {
+  const rootNavigationRef2 = getRootNavigationRef();
+  const isChatLockedOpen = getChatLayout().isChatLockedOpen;
+  if (rootNavigationRef2 != null && rootNavigationRef2.isReady()) {
+    const currentRoute = rootNavigationRef2.getCurrentRoute();
+    const r28 = coerceChannelRoute(currentRoute);
+    if (r28 != null) {
+      return r28.params.channelId;
+    }
+    if (isChatLockedOpen) {
+      const r31 = coerceGuildsRoute(currentRoute);
+      return r31 != null ? r31.params?.channelId : void 0;
+    }
+    return void 0;
+  }
+  let r38 = channelId;
+  if (r38 === null) {
+    const initialNavigationState = getInitialNavigationState();
+    const r45 = initialNavigationState == null;
+    let r46 = void 0;
+    if (!r45) {
+      const routes = initialNavigationState.routes;
+      const r47 = routes == null;
+      r46 = void 0;
+      if (!r47) {
+        let r12 = initialNavigationState?.index;
+        if (r12 == null) {
+          r12 = 0;
+        }
+        r46 = routes[r12];
+      }
+    }
+    const r49 = coerceMainRoute(r46);
+    const r50 = r49 != null;
+    let r51 = void 0;
+    if (r50) {
+      if (isChatLockedOpen) {
+        const state2 = r49.state;
+        const r69 = state2 == null;
+        let r70 = void 0;
+        if (!r69) {
+          const routes3 = state2.routes;
+          const r72 = routes3 == null;
+          r70 = void 0;
+          if (!r72) {
+            let r75 = r49.state?.index;
+            if (r75 == null) {
+              r75 = 0;
+            }
+            r70 = routes3[r75];
+          }
+        }
+        const r76 = coerceTabsRoute(r70);
+        const r77 = r76 != null;
+        r51 = void 0;
+        if (r77) {
+          const state3 = r76.state;
+          const r82 = state3 == null;
+          let r83 = void 0;
+          if (!r82) {
+            const routes4 = state3.routes;
+            const r85 = routes4 == null;
+            r83 = void 0;
+            if (!r85) {
+              let r88 = r76.state?.index;
+              if (r88 == null) {
+                r88 = 0;
+              }
+              r83 = routes4[r88];
+            }
+          }
+          const r89 = coerceGuildsRoute(r83);
+          r51 = r89 != null ? r89.params?.channelId : void 0;
+        }
+      } else {
+        const state = r49.state;
+        const r56 = state == null;
+        let r57 = void 0;
+        if (!r56) {
+          const routes2 = state.routes;
+          const r59 = routes2 == null;
+          r57 = void 0;
+          if (!r59) {
+            let r61 = r49.state?.index;
+            if (r61 == null) {
+              r61 = 0;
+            }
+            r57 = routes2[r61];
+          }
+        }
+        const r62 = coerceChannelRoute(r57);
+        r51 = r62 == null ? void 0 : r62.params?.channelId;
+      }
+    }
+    channelId = r51;
+    r38 = r51;
+  }
+  return r38;
+};
+channelId = null;
+export { getFocusedChannelId };
+export function isChannelFocused() {
+  return getFocusedChannelId() != null;
+}
+export function useIsChannelFocused() {
+  const [state, setState] = useState(() => getFocusedChannelId() != null);
+  useEffect(() => {
+    setState(getFocusedChannelId() != null);
+  }, [useChatLayout()]);
+  useEffect(() => {
+    let rootNavigationRef;
+    const handleStateChange2 = function handleStateChange() {
+      setState(getFocusedChannelId() != null);
+    };
+    rootNavigationRef = getRootNavigationRef();
+    if (rootNavigationRef != null) {
+      rootNavigationRef.addListener("state", handleStateChange2);
+      return () => {
+        rootNavigationRef.removeListener("state", handleStateChange2);
+      };
+    }
+  }, []);
+  return state;
+}
+export function isChannelFocusedForReadStateAck(a0, a1) {
+  if (ChannelRTCStore.getChatOpen(a0)) {
+    return true;
+  }
+  if (VoicePanelStore.getState().isVoicePanelFullscreen()) {
+    return false;
+  }
+  if (getFocusedChannelId() === a0) {
+    return true;
+  }
+  if (a1 != null) {
+    const lastFocusedTimestampForHistoryItem = NavigationHistoryStore.getLastFocusedTimestampForHistoryItem(CHANNEL_PREFIX + a0);
+    if (lastFocusedTimestampForHistoryItem != null && lastFocusedTimestampForHistoryItem >= a1) {
+      return true;
+    }
+  }
+  return false;
+}

modules/panels/morphable/AppFreezeStore.tsx

@@ -0,0 +1,30 @@
+// Metro module 8134 (f8135).
+import { create } from "../../../_bundle/Module644";
+import { batchUpdates } from "../../../_bundle/Module705";
+const r15 = create((c16280_0) => ({
+  lockKeys: new Set(),
+  requestFreezeLock: ({ key, lockEnabled }) => {
+    batchUpdates(() => {
+      c16280_0((a0) => {
+        const lockKeys = a0.lockKeys;
+        const r12 = lockKeys.has(key);
+        if (lockEnabled) {
+          return r12 ? a0 : {
+            ...a0,
+            lockKeys: new Set([key, ...Array.from(a0.lockKeys)])
+          };
+        }
+        if (r12) {
+          const set = new Set(lockKeys);
+          set.delete(key);
+          return {
+            ...a0,
+            lockKeys: set
+          };
+        }
+        return a0;
+      });
+    });
+  }
+}));
+export default r15;

modules/panels/morphable/native/AppFreezer.tsx

@@ -0,0 +1,11 @@
+// Metro module 15392 (f15393).
+import AppFreezeStore from "../AppFreezeStore";
+import NativeView from "../../../core/native/NativeView";
+import { Freeze } from "../../../../_bundle/Suspender";
+const placeholder = <NativeView style={{
+  flex: 1
+}} />;
+export default function AppFreezer(props) {
+  const { children, manualFreeze = false, placeholder: placeholder2 = placeholder, lockKeys } = props;
+  return <Freeze freeze={AppFreezeStore(({ lockKeys: lockKeys2 }) => lockKeys != null ? lockKeys.some((lockKey) => lockKeys2.has(lockKey)) : lockKeys2.size > 0) || manualFreeze} placeholder={placeholder2}>{children}</Freeze>;
+};

modules/panels/morphable/native/MorphablePanelConstants.tsx

@@ -0,0 +1,28 @@
+// Metro module 10039 (f10040).
+import * as _PlatformUtils from "../../../../utils/PlatformUtils";
+const isIOS = _PlatformUtils.isIOS();
+const r16 = {
+  PANEL: "panel",
+  PIP: "pip",
+  CHANGING_ORIENTATION: "changing_orientation",
+  UNDEFINED: "undefined"
+};
+const r21 = {
+  FLOATING_DEFAULT: "floating-default",
+  DRAWER: "drawer",
+  UNDEFINED: "undefined"
+};
+export const MIN_PAN_GESTURE_MOVE = 10;
+export const PANEL_TAP_GESTURE_MAX_DISTANCE = 30;
+export { isIOS as IS_IOS };
+export const PIP_POP_HEIGHT = 140;
+export const PIP_WINDOW_OFFSET = 16;
+export const MIN_PIP_TOSS_VELOCITY = 500;
+export { r16 as MorphablePanelModes };
+export { r21 as PanelControlsModes };
+export const SCALE_PHYSICS = {
+  mass: 0.4,
+  damping: 30,
+  stiffness: 400
+};
+export const POP_RESISTANCE = 0.55;

modules/panels/morphable/native/MorphablePanelUtils.tsx

@@ -0,0 +1,189 @@
+// Metro module 15845 (f15846).
+import { MIN_PIP_TOSS_VELOCITY, PIP_WINDOW_OFFSET } from "./MorphablePanelConstants";
+let clamp, getPIPWindowDimensions, pipXYtoAbsoluteXY;
+const clamp2 = function clamp(a0, a1, a2) {
+  return Math.min(Math.max(a0, a1), a2);
+};
+clamp2.__closure = {};
+clamp2.__workletHash = 1391695493868;
+clamp2.__initData = {
+  code: "function clamp_MorphablePanelUtilsTsx1(value,min,max){return Math.min(Math.max(value,min),max);}"
+};
+clamp = clamp2;
+export function calculateXYDiff(a0, a1) {
+  const r14 = a0.changedTouches[0];
+  const { absoluteY, absoluteX } = r14;
+  const yDiff = a1.get().absoluteYStart - absoluteY;
+  const xDiff = a1.get().absoluteXStart - absoluteX;
+  const absoluteMovement = Math.max(Math.abs(yDiff), Math.abs(xDiff));
+  return {
+    absoluteX,
+    absoluteY,
+    xDiff,
+    yDiff,
+    isNotPullDownGesture: Math.abs(xDiff) >= Math.abs(yDiff) || yDiff > 0,
+    absoluteMovement
+  };
+}
+calculateXYDiff.__closure = {};
+calculateXYDiff.__workletHash = 9827767064556;
+calculateXYDiff.__initData = {
+  code: "function calculateXYDiff_MorphablePanelUtilsTsx2(event,initialGestureOffset){const{absoluteY:absoluteY,absoluteX:absoluteX}=event.changedTouches[0];const yDiff=initialGestureOffset.get().absoluteYStart-absoluteY;const xDiff=initialGestureOffset.get().absoluteXStart-absoluteX;const absoluteMovement=Math.max(Math.abs(yDiff),Math.abs(xDiff));const isNotPullDownGesture=Math.abs(xDiff)>=Math.abs(yDiff)||yDiff>0;return{absoluteX:absoluteX,absoluteY:absoluteY,xDiff:xDiff,yDiff:yDiff,isNotPullDownGesture:isNotPullDownGesture,absoluteMovement:absoluteMovement};}"
+};
+const getPIPWindowDimensions2 = function getPIPWindowDimensions(a0, a1, a2) {
+  const xOffset = a2 ? Math.max(a1.left, PIP_WINDOW_OFFSET) : PIP_WINDOW_OFFSET;
+  const r20 = a0.width - xOffset - Math.max(a1.right, PIP_WINDOW_OFFSET);
+  let xRange = a0.width - a1.left - a1.right - 2 * PIP_WINDOW_OFFSET;
+  if (a2) {
+    xRange = r20;
+  }
+  const yOffset = Math.max(a1.top, PIP_WINDOW_OFFSET);
+  return {
+    xOffset,
+    yOffset,
+    xRange,
+    yRange: a0.height - yOffset - Math.max(a1.bottom, PIP_WINDOW_OFFSET)
+  };
+};
+getPIPWindowDimensions2.__closure = {
+  PIP_WINDOW_OFFSET
+};
+getPIPWindowDimensions2.__workletHash = 4008246762710;
+getPIPWindowDimensions2.__initData = {
+  code: "function getPIPWindowDimensions_MorphablePanelUtilsTsx3(windowDimensions,safeArea,disableHorizontalSafeAreas){const{PIP_WINDOW_OFFSET}=this.__closure;const xOffset=disableHorizontalSafeAreas?Math.max(safeArea.left,PIP_WINDOW_OFFSET):PIP_WINDOW_OFFSET;const disabledHorizontalSafeAreasRange=windowDimensions.width-xOffset-Math.max(safeArea.right,PIP_WINDOW_OFFSET);const enabledHorizontalSafeAreasRange=windowDimensions.width-safeArea.left-safeArea.right-PIP_WINDOW_OFFSET*2;const xRange=disableHorizontalSafeAreas?disabledHorizontalSafeAreasRange:enabledHorizontalSafeAreasRange;const yOffset=Math.max(safeArea.top,PIP_WINDOW_OFFSET);return{xOffset:xOffset,yOffset:yOffset,xRange:xRange,yRange:windowDimensions.height-yOffset-Math.max(safeArea.bottom,PIP_WINDOW_OFFSET)};}"
+};
+getPIPWindowDimensions = getPIPWindowDimensions2;
+export function calculatePIPPositionFromVelocity({ velocityX, velocityY, absoluteX, absoluteY, windowDimensions, safeArea, disableHorizontalSafeAreas }) {
+  let r77, r78;
+  const r7 = disableHorizontalSafeAreas ? Math.max(safeArea.left, PIP_WINDOW_OFFSET) : PIP_WINDOW_OFFSET;
+  const r32 = windowDimensions.width - r7 - Math.max(safeArea.right, PIP_WINDOW_OFFSET);
+  let r39 = windowDimensions.width - safeArea.left - safeArea.right - 2 * PIP_WINDOW_OFFSET;
+  if (disableHorizontalSafeAreas) {
+    r39 = r32;
+  }
+  L38: {
+    const r44 = Math.max(safeArea.top, PIP_WINDOW_OFFSET);
+    const r51 = windowDimensions.height - r44 - Math.max(safeArea.bottom, PIP_WINDOW_OFFSET);
+    const r52 = absoluteX - r7;
+    const r53 = absoluteY - r44;
+    if (Math.max(Math.abs(velocityY), Math.abs(velocityX)) < MIN_PIP_TOSS_VELOCITY) {
+      const r89 = {
+        left: Math.min(Math.max(r52, 0), r39),
+        right: Math.min(Math.max(r39 - r52, 0), r39),
+        top: Math.min(Math.max(r53, 0), r51),
+        bottom: Math.min(Math.max(r51 - r53, 0), r51)
+      };
+      const r116 = Math;
+      const r125 = r116.min.apply(r116, [...Object.values(r89)]);
+      const r128 = r89.left !== r125 ? r89.top !== r125 ? r89.right === r125 ? "right" : "bottom" : "top" : "left";
+      if (r128 === "left") {
+        r78 = r53 / r51;
+        r77 = 0;
+      } else if (r128 === "right") {
+        r78 = r53 / r51;
+        r77 = 1;
+      } else if (r128 === "top") {
+        r77 = r52 / r39;
+        r78 = 0;
+      } else {
+        r78 = 0;
+        r77 = 0;
+        if (r128 === "bottom") {
+          r77 = r52 / r39;
+          r78 = 1;
+        }
+      }
+    } else {
+      const r64 = velocityY / velocityX;
+      const r66 = velocityX > 0 ? r39 : 0;
+      const r69 = r53 + r64 * (r66 - r52);
+      if (r69 >= 0 && r69 <= r51) {
+        r77 = r66 / r39;
+        r78 = r69 / r51;
+        break L38;
+      }
+      const r71 = 1 / r64;
+      const r73 = velocityY > 0 ? r51 : 0;
+      r77 = (r52 + r71 * (r73 - r53)) / r39;
+      r78 = r73 / r51;
+    }
+  }
+  return {
+    pipX: Math.min(Math.max(r77, 0), 1),
+    pipY: Math.min(Math.max(r78, 0), 1)
+  };
+}
+calculatePIPPositionFromVelocity.__closure = {
+  getPIPWindowDimensions,
+  MIN_PIP_TOSS_VELOCITY,
+  clamp
+};
+calculatePIPPositionFromVelocity.__workletHash = 3215524498124;
+calculatePIPPositionFromVelocity.__initData = {
+  code: "function calculatePIPPositionFromVelocity_MorphablePanelUtilsTsx4({velocityX:velocityX,velocityY:velocityY,absoluteX:absoluteX,absoluteY:absoluteY,windowDimensions:windowDimensions,safeArea:safeArea,disableHorizontalSafeAreas:disableHorizontalSafeAreas}){const{getPIPWindowDimensions,MIN_PIP_TOSS_VELOCITY,clamp}=this.__closure;const pipRegion=getPIPWindowDimensions(windowDimensions,safeArea,disableHorizontalSafeAreas);const{xRange:xRange,yRange:yRange}=pipRegion;const x=absoluteX-pipRegion.xOffset;const y=absoluteY-pipRegion.yOffset;let pipX=0;let pipY=0;if(Math.max(Math.abs(velocityY),Math.abs(velocityX))<MIN_PIP_TOSS_VELOCITY){const closestEdge=function(specs){const minValue=Math.min(...Object.values(specs));if(specs.left===minValue){return'left';}if(specs.top===minValue){return'top';}if(specs.right===minValue){return'right';}return'bottom';}({left:clamp(x,0,xRange),right:clamp(xRange-x,0,xRange),top:clamp(y,0,yRange),bottom:clamp(yRange-y,0,yRange)});switch(closestEdge){case'left':pipX=0;pipY=y/yRange;break;case'right':pipX=1;pipY=y/yRange;break;case'top':pipY=0;pipX=x/xRange;break;case'bottom':pipY=1;pipX=x/xRange;break;}}else{const slope=velocityY/velocityX;let intersectionY=0;let intersectionX=0;intersectionX=velocityX>0?xRange:0;intersectionY=y+slope*(intersectionX-x);if(intersectionY>=0&&intersectionY<=yRange){pipX=intersectionX/xRange;pipY=intersectionY/yRange;}else{intersectionY=velocityY>0?yRange:0;intersectionX=x+1/slope*(intersectionY-y);pipX=intersectionX/xRange;pipY=intersectionY/yRange;}}return{pipX:clamp(pipX,0,1),pipY:clamp(pipY,0,1)};}"
+};
+const pipXYtoAbsoluteXY2 = function pipXYtoAbsoluteXY({ pipX, pipY, windowDimensions, safeArea, disableHorizontalSafeAreas }) {
+  const r6 = disableHorizontalSafeAreas ? Math.max(safeArea.left, PIP_WINDOW_OFFSET) : PIP_WINDOW_OFFSET;
+  const r27 = windowDimensions.width - r6 - Math.max(safeArea.right, PIP_WINDOW_OFFSET);
+  let r34 = windowDimensions.width - safeArea.left - safeArea.right - 2 * PIP_WINDOW_OFFSET;
+  if (disableHorizontalSafeAreas) {
+    r34 = r27;
+  }
+  const r38 = Math.max(safeArea.top, PIP_WINDOW_OFFSET);
+  return {
+    x: r6 + pipX * r34,
+    y: r38 + pipY * (windowDimensions.height - r38 - Math.max(safeArea.bottom, PIP_WINDOW_OFFSET))
+  };
+};
+pipXYtoAbsoluteXY2.__closure = {
+  getPIPWindowDimensions
+};
+pipXYtoAbsoluteXY2.__workletHash = 1981621867924;
+pipXYtoAbsoluteXY2.__initData = {
+  code: "function pipXYtoAbsoluteXY_MorphablePanelUtilsTsx5({pipX:pipX,pipY:pipY,windowDimensions:windowDimensions,safeArea:safeArea,disableHorizontalSafeAreas:disableHorizontalSafeAreas}){const{getPIPWindowDimensions}=this.__closure;const{xOffset:xOffset,yOffset:yOffset,xRange:xRange,yRange:yRange}=getPIPWindowDimensions(windowDimensions,safeArea,disableHorizontalSafeAreas);return{x:xOffset+pipX*xRange,y:yOffset+pipY*yRange};}"
+};
+pipXYtoAbsoluteXY = pipXYtoAbsoluteXY2;
+export function getClampedPIPPosition({ pipX, pipY, width, height, windowDimensions, safeArea, bottomAvoidanceRegion = 0, topAvoidanceRegion = 0, positionOffset = {
+  x: 0,
+  y: 0
+}, disableHorizontalSafeAreas }) {
+  const pipX2 = pipX !== -1 ? pipX : 1;
+  const r4 = pipY === -1;
+  const r27 = pipXYtoAbsoluteXY({
+    pipX: pipX2,
+    pipY: r4 ? 0 : pipY,
+    windowDimensions,
+    safeArea,
+    disableHorizontalSafeAreas
+  });
+  const { x: r28, y: r29 } = r27;
+  const r31 = r28 - width / 2;
+  const r32 = r4 ? r29 + 72 : r29 - height / 2;
+  const r19 = disableHorizontalSafeAreas ? Math.max(safeArea.left, PIP_WINDOW_OFFSET) : PIP_WINDOW_OFFSET;
+  const r47 = windowDimensions.width - r19 - Math.max(safeArea.right, PIP_WINDOW_OFFSET);
+  let r54 = windowDimensions.width - safeArea.left - safeArea.right - 2 * PIP_WINDOW_OFFSET;
+  if (disableHorizontalSafeAreas) {
+    r54 = r47;
+  }
+  const r59 = Math.max(safeArea.top, PIP_WINDOW_OFFSET);
+  const r66 = windowDimensions.height - r59 - Math.max(safeArea.bottom, PIP_WINDOW_OFFSET);
+  const r69 = r19 + r54 - width;
+  const r77 = Math.min(Math.max(r31, r19), r69);
+  const r78 = r59 + topAvoidanceRegion;
+  const r81 = r59 + r66 - bottomAvoidanceRegion - height;
+  return {
+    x: r77 + positionOffset.x,
+    y: Math.min(Math.max(r32, r78), r81) + positionOffset.y
+  };
+}
+getClampedPIPPosition.__closure = {
+  pipXYtoAbsoluteXY,
+  getPIPWindowDimensions,
+  clamp
+};
+getClampedPIPPosition.__workletHash = 7754262947803;
+getClampedPIPPosition.__initData = {
+  code: "function getClampedPIPPosition_MorphablePanelUtilsTsx6({pipX:pipX,pipY:pipY,width:width,height:height,windowDimensions:windowDimensions,safeArea:safeArea,bottomAvoidanceRegion=0,topAvoidanceRegion=0,positionOffset={x:0,y:0},disableHorizontalSafeAreas:disableHorizontalSafeAreas}){const{pipXYtoAbsoluteXY,getPIPWindowDimensions,clamp}=this.__closure;let{x:x,y:y}=pipXYtoAbsoluteXY({pipX:pipX===-1?1:pipX,pipY:pipY===-1?0:pipY,windowDimensions:windowDimensions,safeArea:safeArea,disableHorizontalSafeAreas:disableHorizontalSafeAreas});const halfWidth=width/2;const halfHeight=height/2;x-=halfWidth;if(pipY===-1){y+=72;}else{y-=halfHeight;}const pipRegion=getPIPWindowDimensions(windowDimensions,safeArea,disableHorizontalSafeAreas);x=clamp(x,pipRegion.xOffset,pipRegion.xOffset+pipRegion.xRange-width);y=clamp(y,pipRegion.yOffset+topAvoidanceRegion,pipRegion.yOffset+pipRegion.yRange-bottomAvoidanceRegion-height);x+=positionOffset.x;y+=positionOffset.y;return{x:x,y:y};}"
+};
+export { getPIPWindowDimensions };
+export { pipXYtoAbsoluteXY };

modules/panels/morphable/native/SafeAreaDisabledStore.tsx

@@ -0,0 +1,31 @@
+// Metro module 10676 (f10677).
+import { create } from "../../../../_bundle/Module644";
+import { batchUpdates } from "../../../../_bundle/Module705";
+const r15 = create((c18183_0, c18183_1) => ({
+  lockKeys: new Set(),
+  shouldDisableSafeAreas: () => c18183_1().lockKeys.size > 0,
+  requestSafeAreaDisableLock: ({ key, lockEnabled }) => {
+    batchUpdates(() => {
+      c18183_0((a0) => {
+        const lockKeys = a0.lockKeys;
+        const r12 = lockKeys.has(key);
+        if (lockEnabled) {
+          return r12 ? a0 : {
+            ...a0,
+            lockKeys: new Set([key, ...Array.from(a0.lockKeys)])
+          };
+        }
+        if (r12) {
+          const set = new Set(lockKeys);
+          set.delete(key);
+          return {
+            ...a0,
+            lockKeys: set
+          };
+        }
+        return a0;
+      });
+    });
+  }
+}));
+export default r15;

modules/panels/morphable/native/getAdjustedBottomOffsets.tsx

@@ -0,0 +1,16 @@
+// Metro module 15838 (f15839).
+import * as _PlatformUtils from "../../../../utils/PlatformUtils";
+const isAndroid = _PlatformUtils.isAndroid();
+const t = function t({ screenBottomOffset, safeAreaBottom, keyboardHeight }) {
+  return {
+    bottomOffset: keyboardHeight > 0 ? screenBottomOffset + ((isAndroid ? 0 : keyboardHeight) - safeAreaBottom) : screenBottomOffset
+  };
+};
+t.__closure = {
+  IS_ANDROID: isAndroid
+};
+t.__workletHash = 9166664651792;
+t.__initData = {
+  code: "function getAdjustedBottomOffsets_getAdjustedBottomOffsetsTsx1({screenBottomOffset:screenBottomOffset,safeAreaBottom:safeAreaBottom,keyboardHeight:keyboardHeight}){const{IS_ANDROID}=this.__closure;let bottomOffset=screenBottomOffset;if(keyboardHeight>0){bottomOffset+=(IS_ANDROID?0:keyboardHeight)-safeAreaBottom;}return{bottomOffset:bottomOffset};}"
+};
+export default t;

modules/panels/morphable/native/getPIPBottomOffsetForPIPMode.tsx

@@ -0,0 +1,22 @@
+// Metro module 15737 (f15738).
+import { PIP_WINDOW_OFFSET } from "./MorphablePanelConstants";
+const _ = function _(a0) {
+  if (a0 !== "panels" && a0 !== "channel") {
+    if (a0 !== "messages" && a0 !== "notifications" && a0 !== "main_tab" && a0 !== "guilds") {
+      return 0;
+    }
+    return 46 + PIP_WINDOW_OFFSET;
+  }
+  return 60 + PIP_WINDOW_OFFSET;
+};
+_.__closure = {
+  DEFAULT_CHANNEL_INPUT_HEIGHT: 60,
+  PIP_WINDOW_OFFSET,
+  PIP_AVOIDANCE_TAB_BAR_HEIGHT: 46
+};
+_.__workletHash = 7115458448589;
+_.__initData = {
+  code: "function getPIPBottomOffsetForPIPMode_getPIPBottomOffsetForPIPModeTsx1(screenName){const{DEFAULT_CHANNEL_INPUT_HEIGHT,PIP_WINDOW_OFFSET,PIP_AVOIDANCE_TAB_BAR_HEIGHT}=this.__closure;switch(screenName){case'panels':return DEFAULT_CHANNEL_INPUT_HEIGHT+PIP_WINDOW_OFFSET;case'channel':return DEFAULT_CHANNEL_INPUT_HEIGHT+PIP_WINDOW_OFFSET;case'messages':case'notifications':case'main_tab':case'guilds':return PIP_AVOIDANCE_TAB_BAR_HEIGHT+PIP_WINDOW_OFFSET;default:return 0;}}"
+};
+export default _;
+export const PIP_AVOIDANCE_TAB_BAR_HEIGHT = 46;

modules/panels/morphable/native/triggerIOSHaptic.tsx

@@ -0,0 +1,8 @@
+// Metro module 15848 (f15849).
+import { IS_IOS } from "./MorphablePanelConstants";
+import { triggerHapticFeedback, HapticFeedbackTypes } from "../../../haptics/HapticUtils.native";
+export default function triggerIOSHaptic() {
+  if (IS_IOS) {
+    triggerHapticFeedback(HapticFeedbackTypes.IMPACT_MEDIUM);
+  }
+};

modules/panels/morphable/native/useMorphablePanelGesture.tsx

@@ -0,0 +1,290 @@
+// Metro module 15847 (f15848).
+import { useMemo } from "react";
+import { IS_IOS, MIN_PAN_GESTURE_MOVE, MorphablePanelModes, PANEL_TAP_GESTURE_MAX_DISTANCE, PIP_POP_HEIGHT, POP_RESISTANCE } from "./MorphablePanelConstants";
+import useWindowDimensions_native from "../../../screen/useWindowDimensions.native";
+import useSafeAreaInsets_native from "../../../safe_area/useSafeAreaInsets.native";
+import * as _ReanimatedRexport from "../../../reanimated/ReanimatedRexport";
+import { useSharedValue } from "../../../reanimated/ReanimatedRexport";
+import * as _Module5273 from "../../../../_bundle/Module5273";
+import { Gesture } from "../../../../_bundle/Module5273";
+import updateSharedValueIfChanged_native from "../../../reanimated/utils/updateSharedValueIfChanged.native";
+import * as _MorphablePanelUtils from "./MorphablePanelUtils";
+import triggerIOSHaptic from "./triggerIOSHaptic";
+import * as _HapticUtils_native from "../../../haptics/HapticUtils.native";
+const __initData = {
+  code: "function useMorphablePanelGestureTsx1(){const{onTapGestureStart}=this.__closure;var _onTapGestureStart;(_onTapGestureStart=onTapGestureStart)===null||_onTapGestureStart===void 0||_onTapGestureStart();}"
+};
+const __initData2 = {
+  code: "function useMorphablePanelGestureTsx2(){const{updateSharedValueIfChanged,initialGestureOffset}=this.__closure;updateSharedValueIfChanged(initialGestureOffset,{active:false,cancel:false});}"
+};
+const __initData3 = {
+  code: "function useMorphablePanelGestureTsx3(event){const{initialGestureOffset,mode,MorphablePanelModes,calculatePIPPositionFromVelocity,windowDimensions,safeArea,disableHorizontalSafeAreas,updateSharedValueIfChanged,wrapperOffset,pipState,onPanMinimizeGestureEnd}=this.__closure;if(initialGestureOffset.get().cancel){return;}const{velocityX:velocityX,velocityY:velocityY,absoluteX:absoluteX,absoluteY:absoluteY}=event;if(mode===MorphablePanelModes.PIP){const{pipX:pipX,pipY:pipY}=calculatePIPPositionFromVelocity({velocityX:velocityX,velocityY:velocityY,absoluteX:absoluteX,absoluteY:absoluteY,windowDimensions:windowDimensions,safeArea:safeArea,disableHorizontalSafeAreas:disableHorizontalSafeAreas});updateSharedValueIfChanged(wrapperOffset,{gestureActive:false});updateSharedValueIfChanged(pipState,{x:pipX,y:pipY});}else if(mode===MorphablePanelModes.PANEL){if(velocityY>0){if(!initialGestureOffset.get().requiresPop){var _onPanMinimizeGesture;updateSharedValueIfChanged(wrapperOffset,{x:0,y:windowDimensions.height});(_onPanMinimizeGesture=onPanMinimizeGestureEnd)===null||_onPanMinimizeGesture===void 0||_onPanMinimizeGesture();return;}}}updateSharedValueIfChanged(wrapperOffset,{x:0,y:0,gestureActive:false});}"
+};
+const __initData4 = {
+  code: "function useMorphablePanelGestureTsx4(_e){const{updateSharedValueIfChanged,initialGestureOffset,wrapperOffset}=this.__closure;updateSharedValueIfChanged(initialGestureOffset,{active:false});updateSharedValueIfChanged(wrapperOffset,{gestureActive:false});}"
+};
+const __initData5 = {
+  code: "function useMorphablePanelGestureTsx5(event){const{mode,MorphablePanelModes,safeArea,initialGestureOffset,POP_RESISTANCE,PIP_POP_HEIGHT,runOnJS,triggerHapticFeedback,HapticFeedbackTypes,updateSharedValueIfChanged,wrapperOffset}=this.__closure;if(mode!==MorphablePanelModes.PIP){const minYOffset=safeArea.top;let newYOffset=(initialGestureOffset.get().absoluteYStart-event.absoluteY)*-1;if(!initialGestureOffset.get().requiresPop&&newYOffset<=minYOffset){initialGestureOffset.set({...initialGestureOffset.get(),requiresPop:true});}if(initialGestureOffset.get().requiresPop){const distance=Math.max(newYOffset,0);const resistance=distance*POP_RESISTANCE;if(distance<=PIP_POP_HEIGHT){newYOffset=distance-resistance;}else{initialGestureOffset.set({...initialGestureOffset.get(),requiresPop:false});runOnJS(triggerHapticFeedback)(HapticFeedbackTypes.IMPACT_MEDIUM);}}updateSharedValueIfChanged(wrapperOffset,{y:newYOffset,x:0});}else{updateSharedValueIfChanged(wrapperOffset,{x:(initialGestureOffset.get().absoluteXStart-event.absoluteX)*-1,y:(initialGestureOffset.get().absoluteYStart-event.absoluteY)*-1});}}"
+};
+const __initData6 = {
+  code: "function useMorphablePanelGestureTsx6(event,manager){const{IS_IOS,initialGestureOffset,State,calculateXYDiff,mode,MorphablePanelModes,MIN_PAN_GESTURE_MOVE,runOnJS,triggerIOSHaptic,updateSharedValueIfChanged,wrapperOffset}=this.__closure;if(IS_IOS&&initialGestureOffset.get().gestureInBottomSafeArea){manager.activate();return;}if(initialGestureOffset.get().cancel){manager.fail();return;}if(event.state!==State.BEGAN||initialGestureOffset.get().active){return;}const{absoluteX:absoluteX,absoluteY:absoluteY,absoluteMovement:absoluteMovement,isNotPullDownGesture:isNotPullDownGesture,yDiff:yDiff}=calculateXYDiff(event,initialGestureOffset);let startGesture=false;if(mode===MorphablePanelModes.PANEL){if(yDiff<0){startGesture=true;}else if(isNotPullDownGesture){manager.fail();}}else if(mode===MorphablePanelModes.PIP&&absoluteMovement>MIN_PAN_GESTURE_MOVE){startGesture=true;runOnJS(triggerIOSHaptic)();}if(startGesture){updateSharedValueIfChanged(wrapperOffset,{x:0,y:0,gestureActive:true});initialGestureOffset.set({absoluteXStart:absoluteX,absoluteYStart:absoluteY,active:true,cancel:false,gestureInBottomSafeArea:false,requiresPop:initialGestureOffset.get().requiresPop});manager.activate();}}"
+};
+const __initData7 = {
+  code: "function useMorphablePanelGestureTsx7(event){const{updateSharedValueIfChanged,wrapperOffset,initialGestureOffset,windowDimensions,safeArea,swipeRequiresPop}=this.__closure;updateSharedValueIfChanged(wrapperOffset,{x:0,y:0});initialGestureOffset.set({absoluteXStart:event.absoluteX,absoluteYStart:event.absoluteY,active:false,cancel:event.absoluteY>windowDimensions.height-safeArea.bottom*2,gestureInBottomSafeArea:event.absoluteY>windowDimensions.height-safeArea.bottom,requiresPop:swipeRequiresPop});}"
+};
+export default function useMorphablePanelGesture(a0) {
+  const { mode, onPanMinimizeGestureEnd, onTapGestureStart, panGestureEnabled = false } = a0;
+  let c22509_3 = panGestureEnabled;
+  const { pipState, swipeRequiresPop: swipeRequiresPop2 = false } = a0;
+  const swipeRequiresPop = swipeRequiresPop2;
+  const { wrapperOffset, disableHorizontalSafeAreas: disableHorizontalSafeAreas2 = false } = a0;
+  const disableHorizontalSafeAreas = disableHorizontalSafeAreas2;
+  const windowDimensions = useWindowDimensions_native();
+  const safeArea = useSafeAreaInsets_native();
+  const sharedValue = useSharedValue({
+    absoluteXStart: 0,
+    absoluteYStart: 0,
+    active: false,
+    gestureInBottomSafeArea: false,
+    cancel: false,
+    requiresPop: false
+  });
+  return useMemo(() => {
+    const r31 = Gesture.Tap().enabled(onTapGestureStart != null).maxDistance(PANEL_TAP_GESTURE_MAX_DISTANCE);
+    const x = function x() {
+      if (onTapGestureStart != null) {
+        onTapGestureStart();
+      }
+    };
+    x.__closure = {
+      onTapGestureStart
+    };
+    x.__workletHash = 9880530558215;
+    x.__initData = __initData;
+    const r35 = r31.onStart(x);
+    const shouldCancelWhenOutside = Gesture.Pan().enabled(c22509_3).manualActivation(true).maxPointers(1).shouldCancelWhenOutside(false);
+    const V = function V(a0) {
+      updateSharedValueIfChanged_native(wrapperOffset, {
+        x: 0,
+        y: 0
+      });
+      sharedValue.set({
+        absoluteXStart: a0.absoluteX,
+        absoluteYStart: a0.absoluteY,
+        active: false,
+        cancel: a0.absoluteY > windowDimensions.height - 2 * safeArea.bottom,
+        gestureInBottomSafeArea: a0.absoluteY > windowDimensions.height - safeArea.bottom,
+        requiresPop: swipeRequiresPop
+      });
+    };
+    V.__closure = {
+      updateSharedValueIfChanged: updateSharedValueIfChanged_native,
+      wrapperOffset,
+      initialGestureOffset: sharedValue,
+      windowDimensions,
+      safeArea,
+      swipeRequiresPop
+    };
+    V.__workletHash = 14796057583737;
+    V.__initData = __initData7;
+    const r60 = shouldCancelWhenOutside.onBegin(V);
+    const C = function C(a0, a1) {
+      let r1;
+      if (IS_IOS && sharedValue.get().gestureInBottomSafeArea) {
+        a1.activate();
+      } else if (sharedValue.get().cancel) {
+        a1.fail();
+      } else if (a0.state === _Module5273.State.BEGAN && !sharedValue.get().active) {
+        const r13 = _MorphablePanelUtils.calculateXYDiff(a0, sharedValue);
+        const { absoluteX, absoluteY, absoluteMovement, isNotPullDownGesture, yDiff } = r13;
+        if (mode === MorphablePanelModes.PANEL) {
+          const r50 = yDiff < 0;
+          r1 = true;
+          if (!r50) {
+            r1 = false;
+            if (isNotPullDownGesture) {
+              a1.fail();
+              r1 = false;
+            }
+          }
+        } else {
+          const r2 = mode === MorphablePanelModes.PIP && absoluteMovement > MIN_PAN_GESTURE_MOVE;
+          r1 = false;
+          if (r2) {
+            _ReanimatedRexport.runOnJS(triggerIOSHaptic)();
+            r1 = true;
+          }
+        }
+        if (r1) {
+          updateSharedValueIfChanged_native(wrapperOffset, {
+            x: 0,
+            y: 0,
+            gestureActive: true
+          });
+          sharedValue.set({
+            absoluteXStart: absoluteX,
+            absoluteYStart: absoluteY,
+            active: true,
+            cancel: false,
+            gestureInBottomSafeArea: false,
+            requiresPop: sharedValue.get().requiresPop
+          });
+          a1.activate();
+        }
+      }
+    };
+    C.__closure = {
+      IS_IOS,
+      initialGestureOffset: sharedValue,
+      State: _Module5273.State,
+      calculateXYDiff: _MorphablePanelUtils.calculateXYDiff,
+      mode,
+      MorphablePanelModes,
+      MIN_PAN_GESTURE_MOVE,
+      runOnJS: _ReanimatedRexport.runOnJS,
+      triggerIOSHaptic,
+      updateSharedValueIfChanged: updateSharedValueIfChanged_native,
+      wrapperOffset
+    };
+    C.__workletHash = 12545486163726;
+    C.__initData = __initData6;
+    const r81 = r60.onTouchesMove(C);
+    const H = function H(a0) {
+      if (mode !== MorphablePanelModes.PIP) {
+        const top = safeArea.top;
+        const r40 = -1 * (sharedValue.get().absoluteYStart - a0.absoluteY);
+        const requiresPop = sharedValue.get().requiresPop;
+        if (requiresPop ? !requiresPop : r40 <= top) {
+          sharedValue.set({
+            ...sharedValue.get(),
+            requiresPop: true
+          });
+        }
+        const requiresPop2 = sharedValue.get().requiresPop;
+        let r54 = r40;
+        if (requiresPop2) {
+          const r59 = Math.max(r40, 0);
+          if (r59 <= PIP_POP_HEIGHT) {
+            r54 = r59 - r59 * POP_RESISTANCE;
+          } else {
+            sharedValue.set({
+              ...sharedValue.get(),
+              requiresPop: false
+            });
+            _ReanimatedRexport.runOnJS(_HapticUtils_native.triggerHapticFeedback)(_HapticUtils_native.HapticFeedbackTypes.IMPACT_MEDIUM);
+            r54 = r40;
+          }
+        }
+        updateSharedValueIfChanged_native(wrapperOffset, {
+          y: r54,
+          x: 0
+        });
+      } else {
+        updateSharedValueIfChanged_native(wrapperOffset, {
+          x: -1 * (sharedValue.get().absoluteXStart - a0.absoluteX),
+          y: -1 * (sharedValue.get().absoluteYStart - a0.absoluteY)
+        });
+      }
+    };
+    H.__closure = {
+      mode,
+      MorphablePanelModes,
+      safeArea,
+      initialGestureOffset: sharedValue,
+      POP_RESISTANCE,
+      PIP_POP_HEIGHT,
+      runOnJS: _ReanimatedRexport.runOnJS,
+      triggerHapticFeedback: _HapticUtils_native.triggerHapticFeedback,
+      HapticFeedbackTypes: _HapticUtils_native.HapticFeedbackTypes,
+      updateSharedValueIfChanged: updateSharedValueIfChanged_native,
+      wrapperOffset
+    };
+    H.__workletHash = 6076208535373;
+    H.__initData = __initData5;
+    const r100 = r81.onChange(H);
+    const D = function D() {
+      updateSharedValueIfChanged_native(sharedValue, {
+        active: false
+      });
+      updateSharedValueIfChanged_native(wrapperOffset, {
+        gestureActive: false
+      });
+    };
+    D.__closure = {
+      updateSharedValueIfChanged: updateSharedValueIfChanged_native,
+      initialGestureOffset: sharedValue,
+      wrapperOffset
+    };
+    D.__workletHash = 14566382353702;
+    D.__initData = __initData4;
+    const r108 = r100.onTouchesCancelled(D);
+    const X = function X(a0) {
+      if (!sharedValue.get().cancel) {
+        const { velocityX, velocityY, absoluteX, absoluteY } = a0;
+        if (mode === MorphablePanelModes.PIP) {
+          const r45 = _MorphablePanelUtils.calculatePIPPositionFromVelocity({
+            velocityX,
+            velocityY,
+            absoluteX,
+            absoluteY,
+            windowDimensions,
+            safeArea,
+            disableHorizontalSafeAreas
+          });
+          const { pipX, pipY } = r45;
+          updateSharedValueIfChanged_native(wrapperOffset, {
+            gestureActive: false
+          });
+          updateSharedValueIfChanged_native(pipState, {
+            x: pipX,
+            y: pipY
+          });
+        } else if (mode === MorphablePanelModes.PANEL && velocityY > 0 && !sharedValue.get().requiresPop) {
+          updateSharedValueIfChanged_native(wrapperOffset, {
+            x: 0,
+            y: windowDimensions.height
+          });
+          if (onPanMinimizeGestureEnd != null) {
+            onPanMinimizeGestureEnd();
+          }
+          return void 0;
+        }
+        updateSharedValueIfChanged_native(wrapperOffset, {
+          x: 0,
+          y: 0,
+          gestureActive: false
+        });
+      }
+    };
+    X.__closure = {
+      initialGestureOffset: sharedValue,
+      mode,
+      MorphablePanelModes,
+      calculatePIPPositionFromVelocity: _MorphablePanelUtils.calculatePIPPositionFromVelocity,
+      windowDimensions,
+      safeArea,
+      disableHorizontalSafeAreas,
+      updateSharedValueIfChanged: updateSharedValueIfChanged_native,
+      wrapperOffset,
+      pipState,
+      onPanMinimizeGestureEnd
+    };
+    X.__workletHash = 2406462688275;
+    X.__initData = __initData3;
+    const r122 = r108.onEnd(X);
+    const t = function t() {
+      updateSharedValueIfChanged_native(sharedValue, {
+        active: false,
+        cancel: false
+      });
+    };
+    t.__closure = {
+      updateSharedValueIfChanged: updateSharedValueIfChanged_native,
+      initialGestureOffset: sharedValue
+    };
+    t.__workletHash = 11153815903321;
+    t.__initData = __initData2;
+    return Gesture.Race(r35, r122.onFinalize(t));
+  }, [sharedValue, mode, swipeRequiresPop, onPanMinimizeGestureEnd, onTapGestureStart, panGestureEnabled, safeArea, windowDimensions, pipState, wrapperOffset, disableHorizontalSafeAreas]);
+};
+export { MorphablePanelModes };

modules/panels/morphable/native/useScreenNameSharedValue.tsx

@@ -0,0 +1,39 @@
+// Metro module 15837 (f15838).
+import { useEffect } from "react";
+import { getRootNavigationRef } from "../../../main_tabs_v2/RootNavigationRef.native";
+import { useSharedValue } from "../../../reanimated/ReanimatedRexport";
+let c11330_3 = "unknown";
+export default function useScreenNameSharedValue() {
+  let r16;
+  const rootNavigationRef2 = getRootNavigationRef();
+  if ((rootNavigationRef2 == null ? void 0 : rootNavigationRef2.isReady()) === true) {
+    let r20 = rootNavigationRef2.getCurrentRoute()?.name;
+    if (r20 == null) {
+      r20 = c11330_3;
+    }
+    r16 = r20;
+  } else {
+    r16 = c11330_3;
+  }
+  const sharedValue = useSharedValue(r16);
+  useEffect(() => {
+    let rootNavigationRef;
+    const handleStateChange2 = function handleStateChange() {
+      if (rootNavigationRef != null && rootNavigationRef.isReady()) {
+        let r11 = rootNavigationRef.getCurrentRoute()?.name;
+        if (r11 == null) {
+          r11 = "unknown";
+        }
+        sharedValue.set(r11);
+      }
+    };
+    rootNavigationRef = getRootNavigationRef();
+    if (rootNavigationRef != null) {
+      rootNavigationRef.addListener("state", handleStateChange2);
+      return () => {
+        rootNavigationRef.removeListener("state", handleStateChange2);
+      };
+    }
+  }, [sharedValue]);
+  return sharedValue;
+};

modules/panels/native/PanelsConfig.tsx

@@ -0,0 +1,59 @@
+// Metro module 14921 (f14922).
+import { STANDARD_EASING, DECELERATED_EASING } from "../../../design/void/native";
+export function isTimingConfig(a0) {
+  return a0 != null && a0.duration != null;
+}
+isTimingConfig.__closure = {};
+isTimingConfig.__workletHash = 14033676769786;
+isTimingConfig.__initData = {
+  code: "function isTimingConfig_PanelsConfigTsx1(obj){return obj!=null&&obj.duration!=null;}"
+};
+const r20 = {
+  mass: 1,
+  stiffness: 250,
+  overshootClamping: true,
+  restSpeedThreshold: 0.001,
+  restDisplacementThreshold: 0.001
+};
+const swipeSidePanelOpen = {
+  damping: 30,
+  ...r20
+};
+const swipeSidePanelClose = {
+  damping: 20,
+  ...r20
+};
+const nonSwipeSidePanelOpen = {
+  duration: 250,
+  easing: STANDARD_EASING
+};
+const nonSwipeSidePanelClose = {
+  duration: 200,
+  easing: STANDARD_EASING
+};
+const r33 = {
+  swipeSidePanelOpen,
+  swipeSidePanelClose,
+  nonSwipeSidePanelOpen,
+  nonSwipeSidePanelClose,
+  touchSlopForPanGesture: 8,
+  minFlingVelocityX: 240
+};
+const r37 = {
+  swipeSidePanelOpen: {
+    duration: 250,
+    easing: DECELERATED_EASING
+  },
+  swipeSidePanelClose: {
+    duration: 200,
+    easing: DECELERATED_EASING
+  },
+  nonSwipeSidePanelOpen,
+  nonSwipeSidePanelClose,
+  touchSlopForPanGesture: 8,
+  minFlingVelocityX: 240
+};
+export const SIDE_PANEL_OPEN_DURATION_MS = 250;
+export const SIDE_PANEL_CLOSE_DURATION_MS = 200;
+export { r33 as DEFAULT_PANELS_ANIMATION_CONFIG };
+export { r37 as ANDROID_PANELS_ANIMATION_CONFIG };