react-native-reanimated 2.9.1 → 3.0.0-rc.2

package/lib/commonjs/reanimated2/frameCallback/FrameCallbackRegistryJS.js

@@ -0,0 +1,55 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _core = require("../core");
+
+var _FrameCallbackRegistryUI = require("./FrameCallbackRegistryUI");
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+class FrameCallbackRegistryJS {
+  constructor() {
+    _defineProperty(this, "nextCallbackId", 0);
+
+    (0, _FrameCallbackRegistryUI.prepareUIRegistry)();
+  }
+
+  registerFrameCallback(callback) {
+    if (!callback) {
+      return -1;
+    }
+
+    const callbackId = this.nextCallbackId;
+    this.nextCallbackId++;
+    (0, _core.runOnUI)(() => {
+      'worklet';
+
+      global._frameCallbackRegistry.registerFrameCallback(callback, callbackId);
+    })();
+    return callbackId;
+  }
+
+  unregisterFrameCallback(frameCallbackId) {
+    (0, _core.runOnUI)(() => {
+      'worklet';
+
+      global._frameCallbackRegistry.unregisterFrameCallback(frameCallbackId);
+    })();
+  }
+
+  manageStateFrameCallback(frameCallbackId, state) {
+    (0, _core.runOnUI)(() => {
+      'worklet';
+
+      global._frameCallbackRegistry.manageStateFrameCallback(frameCallbackId, state);
+    })();
+  }
+
+}
+
+exports.default = FrameCallbackRegistryJS;
+//# sourceMappingURL=FrameCallbackRegistryJS.js.map

package/lib/commonjs/reanimated2/frameCallback/FrameCallbackRegistryJS.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["FrameCallbackRegistryJS","constructor","prepareUIRegistry","registerFrameCallback","callback","callbackId","nextCallbackId","runOnUI","global","_frameCallbackRegistry","unregisterFrameCallback","frameCallbackId","manageStateFrameCallback","state"],"sources":["FrameCallbackRegistryJS.ts"],"sourcesContent":["import { runOnUI } from '../core';\nimport { prepareUIRegistry } from './FrameCallbackRegistryUI';\n\nexport default class FrameCallbackRegistryJS {\n  private nextCallbackId = 0;\n\n  constructor() {\n    prepareUIRegistry();\n  }\n\n  registerFrameCallback(callback: () => void): number {\n    if (!callback) {\n      return -1;\n    }\n\n    const callbackId = this.nextCallbackId;\n    this.nextCallbackId++;\n\n    runOnUI(() => {\n      'worklet';\n      global._frameCallbackRegistry.registerFrameCallback(callback, callbackId);\n    })();\n\n    return callbackId;\n  }\n\n  unregisterFrameCallback(frameCallbackId: number): void {\n    runOnUI(() => {\n      'worklet';\n      global._frameCallbackRegistry.unregisterFrameCallback(frameCallbackId);\n    })();\n  }\n\n  manageStateFrameCallback(frameCallbackId: number, state: boolean): void {\n    runOnUI(() => {\n      'worklet';\n      global._frameCallbackRegistry.manageStateFrameCallback(\n        frameCallbackId,\n        state\n      );\n    })();\n  }\n}\n"],"mappings":";;;;;;;AAAA;;AACA;;;;AAEe,MAAMA,uBAAN,CAA8B;EAG3CC,WAAW,GAAG;IAAA,wCAFW,CAEX;;IACZ,IAAAC,0CAAA;EACD;;EAEDC,qBAAqB,CAACC,QAAD,EAA+B;IAClD,IAAI,CAACA,QAAL,EAAe;MACb,OAAO,CAAC,CAAR;IACD;;IAED,MAAMC,UAAU,GAAG,KAAKC,cAAxB;IACA,KAAKA,cAAL;IAEA,IAAAC,aAAA,EAAQ,MAAM;MACZ;;MACAC,MAAM,CAACC,sBAAP,CAA8BN,qBAA9B,CAAoDC,QAApD,EAA8DC,UAA9D;IACD,CAHD;IAKA,OAAOA,UAAP;EACD;;EAEDK,uBAAuB,CAACC,eAAD,EAAgC;IACrD,IAAAJ,aAAA,EAAQ,MAAM;MACZ;;MACAC,MAAM,CAACC,sBAAP,CAA8BC,uBAA9B,CAAsDC,eAAtD;IACD,CAHD;EAID;;EAEDC,wBAAwB,CAACD,eAAD,EAA0BE,KAA1B,EAAgD;IACtE,IAAAN,aAAA,EAAQ,MAAM;MACZ;;MACAC,MAAM,CAACC,sBAAP,CAA8BG,wBAA9B,CACED,eADF,EAEEE,KAFF;IAID,CAND;EAOD;;AAtC0C"}

package/lib/commonjs/reanimated2/frameCallback/FrameCallbackRegistryUI.js

@@ -0,0 +1,64 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.prepareUIRegistry = void 0;
+
+var _core = require("../core");
+
+const prepareUIRegistry = (0, _core.runOnUI)(() => {
+  'worklet';
+
+  const frameCallbackRegistry = {
+    frameCallbackRegistry: new Map(),
+    frameCallbackActive: new Set(),
+    isFrameCallbackRunning: false,
+
+    runCallbacks() {
+      const loop = () => {
+        this.frameCallbackActive.forEach(key => {
+          const callback = this.frameCallbackRegistry.get(key);
+          callback();
+        });
+
+        if (this.frameCallbackActive.size > 0) {
+          requestAnimationFrame(loop);
+        } else {
+          this.isFrameCallbackRunning = false;
+        }
+      };
+
+      if (!this.isFrameCallbackRunning) {
+        requestAnimationFrame(loop);
+        this.isFrameCallbackRunning = true;
+      }
+    },
+
+    registerFrameCallback(callback, callbackId) {
+      this.frameCallbackRegistry.set(callbackId, callback);
+    },
+
+    unregisterFrameCallback(frameCallbackId) {
+      this.manageStateFrameCallback(frameCallbackId, false);
+      this.frameCallbackRegistry.delete(frameCallbackId);
+    },
+
+    manageStateFrameCallback(frameCallbackId, state) {
+      if (frameCallbackId === -1) {
+        return;
+      }
+
+      if (state) {
+        this.frameCallbackActive.add(frameCallbackId);
+        this.runCallbacks();
+      } else {
+        this.frameCallbackActive.delete(frameCallbackId);
+      }
+    }
+
+  };
+  global._frameCallbackRegistry = frameCallbackRegistry;
+});
+exports.prepareUIRegistry = prepareUIRegistry;
+//# sourceMappingURL=FrameCallbackRegistryUI.js.map

package/lib/commonjs/reanimated2/frameCallback/FrameCallbackRegistryUI.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["prepareUIRegistry","runOnUI","frameCallbackRegistry","Map","frameCallbackActive","Set","isFrameCallbackRunning","runCallbacks","loop","forEach","key","callback","get","size","requestAnimationFrame","registerFrameCallback","callbackId","set","unregisterFrameCallback","frameCallbackId","manageStateFrameCallback","delete","state","add","global","_frameCallbackRegistry"],"sources":["FrameCallbackRegistryUI.ts"],"sourcesContent":["import { runOnUI } from '../core';\n\nexport default interface FrameCallbackRegistryUI {\n  frameCallbackRegistry: Map<number, () => void>;\n  frameCallbackActive: Set<number>;\n  isFrameCallbackRunning: boolean;\n  runCallbacks: () => void;\n  registerFrameCallback: (callback: () => void, callbackId: number) => void;\n  unregisterFrameCallback: (frameCallbackId: number) => void;\n  manageStateFrameCallback: (frameCallbackId: number, state: boolean) => void;\n}\n\nexport const prepareUIRegistry = runOnUI(() => {\n  'worklet';\n\n  const frameCallbackRegistry: FrameCallbackRegistryUI = {\n    frameCallbackRegistry: new Map<number, () => void>(),\n    frameCallbackActive: new Set<number>(),\n    isFrameCallbackRunning: false,\n\n    runCallbacks() {\n      const loop = () => {\n        this.frameCallbackActive.forEach((key: number) => {\n          const callback = this.frameCallbackRegistry.get(key);\n          callback!();\n        });\n\n        if (this.frameCallbackActive.size > 0) {\n          requestAnimationFrame(loop);\n        } else {\n          this.isFrameCallbackRunning = false;\n        }\n      };\n\n      if (!this.isFrameCallbackRunning) {\n        requestAnimationFrame(loop);\n        this.isFrameCallbackRunning = true;\n      }\n    },\n\n    registerFrameCallback(callback: () => void, callbackId: number) {\n      this.frameCallbackRegistry.set(callbackId, callback);\n    },\n\n    unregisterFrameCallback(frameCallbackId: number) {\n      this.manageStateFrameCallback(frameCallbackId, false);\n      this.frameCallbackRegistry.delete(frameCallbackId);\n    },\n\n    manageStateFrameCallback(frameCallbackId: number, state: boolean) {\n      if (frameCallbackId === -1) {\n        return;\n      }\n      if (state) {\n        this.frameCallbackActive.add(frameCallbackId);\n        this.runCallbacks();\n      } else {\n        this.frameCallbackActive.delete(frameCallbackId);\n      }\n    },\n  };\n\n  global._frameCallbackRegistry = frameCallbackRegistry;\n});\n"],"mappings":";;;;;;;AAAA;;AAYO,MAAMA,iBAAiB,GAAG,IAAAC,aAAA,EAAQ,MAAM;EAC7C;;EAEA,MAAMC,qBAA8C,GAAG;IACrDA,qBAAqB,EAAE,IAAIC,GAAJ,EAD8B;IAErDC,mBAAmB,EAAE,IAAIC,GAAJ,EAFgC;IAGrDC,sBAAsB,EAAE,KAH6B;;IAKrDC,YAAY,GAAG;MACb,MAAMC,IAAI,GAAG,MAAM;QACjB,KAAKJ,mBAAL,CAAyBK,OAAzB,CAAkCC,GAAD,IAAiB;UAChD,MAAMC,QAAQ,GAAG,KAAKT,qBAAL,CAA2BU,GAA3B,CAA+BF,GAA/B,CAAjB;UACAC,QAAQ;QACT,CAHD;;QAKA,IAAI,KAAKP,mBAAL,CAAyBS,IAAzB,GAAgC,CAApC,EAAuC;UACrCC,qBAAqB,CAACN,IAAD,CAArB;QACD,CAFD,MAEO;UACL,KAAKF,sBAAL,GAA8B,KAA9B;QACD;MACF,CAXD;;MAaA,IAAI,CAAC,KAAKA,sBAAV,EAAkC;QAChCQ,qBAAqB,CAACN,IAAD,CAArB;QACA,KAAKF,sBAAL,GAA8B,IAA9B;MACD;IACF,CAvBoD;;IAyBrDS,qBAAqB,CAACJ,QAAD,EAAuBK,UAAvB,EAA2C;MAC9D,KAAKd,qBAAL,CAA2Be,GAA3B,CAA+BD,UAA/B,EAA2CL,QAA3C;IACD,CA3BoD;;IA6BrDO,uBAAuB,CAACC,eAAD,EAA0B;MAC/C,KAAKC,wBAAL,CAA8BD,eAA9B,EAA+C,KAA/C;MACA,KAAKjB,qBAAL,CAA2BmB,MAA3B,CAAkCF,eAAlC;IACD,CAhCoD;;IAkCrDC,wBAAwB,CAACD,eAAD,EAA0BG,KAA1B,EAA0C;MAChE,IAAIH,eAAe,KAAK,CAAC,CAAzB,EAA4B;QAC1B;MACD;;MACD,IAAIG,KAAJ,EAAW;QACT,KAAKlB,mBAAL,CAAyBmB,GAAzB,CAA6BJ,eAA7B;QACA,KAAKZ,YAAL;MACD,CAHD,MAGO;QACL,KAAKH,mBAAL,CAAyBiB,MAAzB,CAAgCF,eAAhC;MACD;IACF;;EA5CoD,CAAvD;EA+CAK,MAAM,CAACC,sBAAP,GAAgCvB,qBAAhC;AACD,CAnDgC,CAA1B"}

package/lib/commonjs/reanimated2/globals.d.js

@@ -0,0 +1,6 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+//# sourceMappingURL=globals.d.js.map

package/lib/commonjs/reanimated2/globals.d.js.map

@@ -0,0 +1 @@
+{"version":3,"names":[],"sources":["globals.d.ts"],"sourcesContent":["import { AnimatedStyle, StyleProps } from './commonTypes';\nimport { ReanimatedConsole } from './core';\nimport { FrameCallbackRegistryUI } from './frameCallback/FrameCallbackRegistryUI';\nimport { ShadowNodeWrapper } from './hook/commonTypes';\nimport { MeasuredDimensions } from './NativeMethods';\nimport { NativeReanimated } from './NativeReanimated/NativeReanimated';\ndeclare global {\n  const _WORKLET: boolean;\n  const _IS_FABRIC: boolean;\n  const _frameTimestamp: number;\n  const _eventTimestamp: number;\n  const _setGlobalConsole: (console?: ReanimatedConsole) => void;\n  const _getCurrentTime: () => number;\n  const _stopObservingProgress: (tag: number, flag: boolean) => void;\n  const _startObservingProgress: (\n    tag: number,\n    flag: { value: boolean; _value: boolean }\n  ) => void;\n  const _setGestureState: (handlerTag: number, newState: number) => void;\n  const _updatePropsPaper: (\n    tag: number,\n    name: string,\n    updates: StyleProps | AnimatedStyle\n  ) => void;\n  const _updatePropsFabric: (\n    shadowNodeWrapper: ShadowNodeWrapper,\n    props: StyleProps | AnimatedStyle\n  ) => void;\n  const _removeShadowNodeFromRegistry: (\n    shadowNodeWrapper: ShadowNodeWrapper\n  ) => void;\n  const _measure: (viewTag: number) => MeasuredDimensions;\n  const _scrollTo: (\n    viewTag: number,\n    x: number,\n    y: number,\n    animated: boolean\n  ) => void;\n  const _dispatchCommand: (\n    shadowNodeWrapper: ShadowNodeWrapper,\n    commandName: string,\n    args: Array<unknown>\n  ) => void;\n  const _chronoNow: () => number;\n  const ReanimatedDataMock: {\n    now: () => number;\n  };\n  const _frameCallbackRegistry: FrameCallbackRegistryUI;\n  namespace NodeJS {\n    interface Global {\n      _setGlobalConsole: (console?: ReanimatedConsole) => void;\n      _log: (s: string) => void;\n      _setGestureState: () => void;\n      _WORKLET: boolean;\n      _IS_FABRIC: boolean;\n      __reanimatedModuleProxy: NativeReanimated;\n      _frameTimestamp: number | null;\n      _measure: () => MeasuredDimensions;\n      _scrollTo: () => void;\n      _dispatchCommand: () => void;\n      _chronoNow: () => number;\n      performance: { now: () => number };\n      LayoutAnimationRepository: {\n        configs: Record<string, unknown>;\n        registerConfig(tag: number, config: Record<string, unknown>): void;\n        removeConfig(tag: number): void;\n        startAnimationForTag(\n          tag: number,\n          type: string,\n          yogaValues: unknown\n        ): void;\n      };\n      ReanimatedDataMock: {\n        now: () => number;\n      };\n      _frameCallbackRegistry: FrameCallbackRegistryUI;\n    }\n  }\n}\n"],"mappings":""}

package/lib/commonjs/reanimated2/hook/Hooks.js

@@ -0,0 +1,35 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useAnimatedProps = void 0;
+Object.defineProperty(exports, "useEvent", {
+  enumerable: true,
+  get: function () {
+    return _utils.useEvent;
+  }
+});
+Object.defineProperty(exports, "useHandler", {
+  enumerable: true,
+  get: function () {
+    return _utils.useHandler;
+  }
+});
+exports.useWorkletCallback = useWorkletCallback;
+
+var _react = require("react");
+
+var _useAnimatedStyle = require("./useAnimatedStyle");
+
+var _utils = require("./utils");
+
+// TODO: we should make sure that when useAP is used we are not assigning styles
+// when you need styles to animated you should always use useAS
+const useAnimatedProps = _useAnimatedStyle.useAnimatedStyle;
+exports.useAnimatedProps = useAnimatedProps;
+
+function useWorkletCallback(fun, deps) {
+  return (0, _react.useCallback)(fun, deps ?? []);
+}
+//# sourceMappingURL=Hooks.js.map

package/lib/commonjs/reanimated2/hook/Hooks.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["useAnimatedProps","useAnimatedStyle","useWorkletCallback","fun","deps","useCallback"],"sources":["Hooks.ts"],"sourcesContent":["import { useCallback } from 'react';\nimport { DependencyList } from './commonTypes';\nimport { useAnimatedStyle } from './useAnimatedStyle';\n\n// TODO: we should make sure that when useAP is used we are not assigning styles\n// when you need styles to animated you should always use useAS\nexport const useAnimatedProps = useAnimatedStyle;\n\nexport function useWorkletCallback<A extends unknown[], R>(\n  fun: (...args: A) => R,\n  deps?: DependencyList\n): (...args: Parameters<typeof fun>) => R {\n  return useCallback(fun, deps ?? []);\n}\n\nexport { useEvent, useHandler } from './utils';\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;;AAEA;;AAaA;;AAXA;AACA;AACO,MAAMA,gBAAgB,GAAGC,kCAAzB;;;AAEA,SAASC,kBAAT,CACLC,GADK,EAELC,IAFK,EAGmC;EACxC,OAAO,IAAAC,kBAAA,EAAYF,GAAZ,EAAiBC,IAAI,IAAI,EAAzB,CAAP;AACD"}

package/lib/commonjs/reanimated2/hook/commonTypes.js

@@ -0,0 +1,6 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+//# sourceMappingURL=commonTypes.js.map

package/lib/commonjs/reanimated2/hook/commonTypes.js.map

@@ -0,0 +1 @@
+{"version":3,"names":[],"sources":["commonTypes.ts"],"sourcesContent":["import { Context, ShadowNodeWrapper } from '../commonTypes';\n\nexport type DependencyList = Array<unknown> | undefined;\n\nexport interface ContextWithDependencies<TContext extends Context> {\n  context: TContext;\n  savedDependencies: DependencyList;\n}\n\nexport interface Descriptor {\n  tag: number;\n  name: string;\n  shadowNodeWrapper: ShadowNodeWrapper;\n}\n\nexport interface RefObjectFunction<T> {\n  current: T | null;\n  (component?: T): number;\n}\n"],"mappings":""}

package/lib/commonjs/reanimated2/hook/index.js

@@ -0,0 +1,118 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "SensorType", {
+  enumerable: true,
+  get: function () {
+    return _useAnimatedSensor.SensorType;
+  }
+});
+Object.defineProperty(exports, "useAnimatedGestureHandler", {
+  enumerable: true,
+  get: function () {
+    return _useAnimatedGestureHandler.useAnimatedGestureHandler;
+  }
+});
+Object.defineProperty(exports, "useAnimatedKeyboard", {
+  enumerable: true,
+  get: function () {
+    return _useAnimatedKeyboard.useAnimatedKeyboard;
+  }
+});
+Object.defineProperty(exports, "useAnimatedProps", {
+  enumerable: true,
+  get: function () {
+    return _Hooks.useAnimatedProps;
+  }
+});
+Object.defineProperty(exports, "useAnimatedReaction", {
+  enumerable: true,
+  get: function () {
+    return _useAnimatedReaction.useAnimatedReaction;
+  }
+});
+Object.defineProperty(exports, "useAnimatedRef", {
+  enumerable: true,
+  get: function () {
+    return _useAnimatedRef.useAnimatedRef;
+  }
+});
+Object.defineProperty(exports, "useAnimatedScrollHandler", {
+  enumerable: true,
+  get: function () {
+    return _useAnimatedScrollHandler.useAnimatedScrollHandler;
+  }
+});
+Object.defineProperty(exports, "useAnimatedSensor", {
+  enumerable: true,
+  get: function () {
+    return _useAnimatedSensor.useAnimatedSensor;
+  }
+});
+Object.defineProperty(exports, "useAnimatedStyle", {
+  enumerable: true,
+  get: function () {
+    return _useAnimatedStyle.useAnimatedStyle;
+  }
+});
+Object.defineProperty(exports, "useDerivedValue", {
+  enumerable: true,
+  get: function () {
+    return _useDerivedValue.useDerivedValue;
+  }
+});
+Object.defineProperty(exports, "useEvent", {
+  enumerable: true,
+  get: function () {
+    return _Hooks.useEvent;
+  }
+});
+Object.defineProperty(exports, "useFrameCallback", {
+  enumerable: true,
+  get: function () {
+    return _useFrameCallback.useFrameCallback;
+  }
+});
+Object.defineProperty(exports, "useHandler", {
+  enumerable: true,
+  get: function () {
+    return _Hooks.useHandler;
+  }
+});
+Object.defineProperty(exports, "useSharedValue", {
+  enumerable: true,
+  get: function () {
+    return _useSharedValue.useSharedValue;
+  }
+});
+Object.defineProperty(exports, "useWorkletCallback", {
+  enumerable: true,
+  get: function () {
+    return _Hooks.useWorkletCallback;
+  }
+});
+
+var _Hooks = require("./Hooks");
+
+var _useSharedValue = require("./useSharedValue");
+
+var _useAnimatedStyle = require("./useAnimatedStyle");
+
+var _useAnimatedGestureHandler = require("./useAnimatedGestureHandler");
+
+var _useAnimatedReaction = require("./useAnimatedReaction");
+
+var _useAnimatedRef = require("./useAnimatedRef");
+
+var _useAnimatedScrollHandler = require("./useAnimatedScrollHandler");
+
+var _useDerivedValue = require("./useDerivedValue");
+
+var _useAnimatedSensor = require("./useAnimatedSensor");
+
+var _useFrameCallback = require("./useFrameCallback");
+
+var _useAnimatedKeyboard = require("./useAnimatedKeyboard");
+//# sourceMappingURL=index.js.map

package/lib/commonjs/reanimated2/hook/index.js.map

@@ -0,0 +1 @@
+{"version":3,"names":[],"sources":["index.ts"],"sourcesContent":["export type { DependencyList } from './commonTypes';\nexport {\n  useAnimatedProps,\n  useEvent,\n  useHandler,\n  useWorkletCallback,\n} from './Hooks';\nexport { useSharedValue } from './useSharedValue';\nexport { useAnimatedStyle } from './useAnimatedStyle';\nexport type { AnimatedStyleResult } from './useAnimatedStyle';\nexport { useAnimatedGestureHandler } from './useAnimatedGestureHandler';\nexport type {\n  GestureHandlerEvent,\n  GestureHandlers,\n} from './useAnimatedGestureHandler';\nexport { useAnimatedReaction } from './useAnimatedReaction';\nexport type { AnimatedReactionWorkletFunction } from './useAnimatedReaction';\nexport { useAnimatedRef } from './useAnimatedRef';\nexport { useAnimatedScrollHandler } from './useAnimatedScrollHandler';\nexport type { ScrollHandler, ScrollHandlers } from './useAnimatedScrollHandler';\nexport { useDerivedValue } from './useDerivedValue';\nexport type { DerivedValue } from './useDerivedValue';\nexport { useAnimatedSensor, SensorType } from './useAnimatedSensor';\nexport { useFrameCallback } from './useFrameCallback';\nexport type { FrameCallback } from './useFrameCallback';\nexport { useAnimatedKeyboard } from './useAnimatedKeyboard';\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AACA;;AAMA;;AACA;;AAEA;;AAKA;;AAEA;;AACA;;AAEA;;AAEA;;AACA;;AAEA"}

package/lib/commonjs/reanimated2/hook/useAnimatedGestureHandler.js

@@ -0,0 +1,66 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.EventType = void 0;
+exports.useAnimatedGestureHandler = useAnimatedGestureHandler;
+
+var _Hooks = require("./Hooks");
+
+let EventType;
+exports.EventType = EventType;
+
+(function (EventType) {
+  EventType[EventType["UNDETERMINED"] = 0] = "UNDETERMINED";
+  EventType[EventType["FAILED"] = 1] = "FAILED";
+  EventType[EventType["BEGAN"] = 2] = "BEGAN";
+  EventType[EventType["CANCELLED"] = 3] = "CANCELLED";
+  EventType[EventType["ACTIVE"] = 4] = "ACTIVE";
+  EventType[EventType["END"] = 5] = "END";
+})(EventType || (exports.EventType = EventType = {}));
+
+function useAnimatedGestureHandler(handlers, dependencies) {
+  const {
+    context,
+    doDependenciesDiffer,
+    useWeb
+  } = (0, _Hooks.useHandler)(handlers, dependencies);
+
+  const handler = e => {
+    'worklet';
+
+    const event = useWeb ? e.nativeEvent : e;
+
+    if (event.state === EventType.BEGAN && handlers.onStart) {
+      handlers.onStart(event, context);
+    }
+
+    if (event.state === EventType.ACTIVE && handlers.onActive) {
+      handlers.onActive(event, context);
+    }
+
+    if (event.oldState === EventType.ACTIVE && event.state === EventType.END && handlers.onEnd) {
+      handlers.onEnd(event, context);
+    }
+
+    if (event.oldState === EventType.BEGAN && event.state === EventType.FAILED && handlers.onFail) {
+      handlers.onFail(event, context);
+    }
+
+    if (event.oldState === EventType.ACTIVE && event.state === EventType.CANCELLED && handlers.onCancel) {
+      handlers.onCancel(event, context);
+    }
+
+    if ((event.oldState === EventType.BEGAN || event.oldState === EventType.ACTIVE) && event.state !== EventType.BEGAN && event.state !== EventType.ACTIVE && handlers.onFinish) {
+      handlers.onFinish(event, context, event.state === EventType.CANCELLED || event.state === EventType.FAILED);
+    }
+  };
+
+  if (useWeb) {
+    return handler;
+  }
+
+  return (0, _Hooks.useEvent)(handler, ['onGestureHandlerStateChange', 'onGestureHandlerEvent'], doDependenciesDiffer);
+}
+//# sourceMappingURL=useAnimatedGestureHandler.js.map

package/lib/commonjs/reanimated2/hook/useAnimatedGestureHandler.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["EventType","useAnimatedGestureHandler","handlers","dependencies","context","doDependenciesDiffer","useWeb","useHandler","handler","e","event","nativeEvent","state","BEGAN","onStart","ACTIVE","onActive","oldState","END","onEnd","FAILED","onFail","CANCELLED","onCancel","onFinish","useEvent"],"sources":["useAnimatedGestureHandler.ts"],"sourcesContent":["import { MutableRefObject } from 'react';\nimport { Context, WorkletFunction } from '../commonTypes';\nimport WorkletEventHandler from '../WorkletEventHandler';\nimport { DependencyList } from './commonTypes';\nimport { useEvent, useHandler } from './Hooks';\n\ninterface Handler<T, TContext extends Context> extends WorkletFunction {\n  (event: T, context: TContext, isCanceledOrFailed?: boolean): void;\n}\n\nexport interface GestureHandlers<T, TContext extends Context> {\n  [key: string]: Handler<T, TContext> | undefined;\n  onStart?: Handler<T, TContext>;\n  onActive?: Handler<T, TContext>;\n  onEnd?: Handler<T, TContext>;\n  onFail?: Handler<T, TContext>;\n  onCancel?: Handler<T, TContext>;\n  onFinish?: Handler<T, TContext>;\n}\n\nexport enum EventType {\n  UNDETERMINED = 0,\n  FAILED,\n  BEGAN,\n  CANCELLED,\n  ACTIVE,\n  END,\n}\n\nexport interface GestureHandlerStateChangeNativeEvent {\n  handlerTag: number;\n  numberOfPointers: number;\n  state: EventType;\n  oldState: EventType;\n}\n\nexport interface GestureHandlerEvent<T>\n  extends GestureHandlerStateChangeNativeEvent {\n  nativeEvent: T;\n}\n\nexport function useAnimatedGestureHandler<\n  T extends GestureHandlerEvent<T>,\n  TContext extends Context\n>(\n  handlers: GestureHandlers<T, TContext>,\n  dependencies?: DependencyList\n): MutableRefObject<WorkletEventHandler<T> | null> | ((e: T) => void) {\n  const { context, doDependenciesDiffer, useWeb } = useHandler<T, TContext>(\n    handlers,\n    dependencies\n  );\n\n  const handler = (e: T) => {\n    'worklet';\n    const event = useWeb ? e.nativeEvent : e;\n\n    if (event.state === EventType.BEGAN && handlers.onStart) {\n      handlers.onStart(event, context);\n    }\n    if (event.state === EventType.ACTIVE && handlers.onActive) {\n      handlers.onActive(event, context);\n    }\n    if (\n      event.oldState === EventType.ACTIVE &&\n      event.state === EventType.END &&\n      handlers.onEnd\n    ) {\n      handlers.onEnd(event, context);\n    }\n    if (\n      event.oldState === EventType.BEGAN &&\n      event.state === EventType.FAILED &&\n      handlers.onFail\n    ) {\n      handlers.onFail(event, context);\n    }\n    if (\n      event.oldState === EventType.ACTIVE &&\n      event.state === EventType.CANCELLED &&\n      handlers.onCancel\n    ) {\n      handlers.onCancel(event, context);\n    }\n    if (\n      (event.oldState === EventType.BEGAN ||\n        event.oldState === EventType.ACTIVE) &&\n      event.state !== EventType.BEGAN &&\n      event.state !== EventType.ACTIVE &&\n      handlers.onFinish\n    ) {\n      handlers.onFinish(\n        event,\n        context,\n        event.state === EventType.CANCELLED || event.state === EventType.FAILED\n      );\n    }\n  };\n\n  if (useWeb) {\n    return handler;\n  }\n\n  return useEvent<T>(\n    handler,\n    ['onGestureHandlerStateChange', 'onGestureHandlerEvent'],\n    doDependenciesDiffer\n  );\n}\n"],"mappings":";;;;;;;;AAIA;;IAgBYA,S;;;WAAAA,S;EAAAA,S,CAAAA,S;EAAAA,S,CAAAA,S;EAAAA,S,CAAAA,S;EAAAA,S,CAAAA,S;EAAAA,S,CAAAA,S;EAAAA,S,CAAAA,S;GAAAA,S,yBAAAA,S;;AAqBL,SAASC,yBAAT,CAILC,QAJK,EAKLC,YALK,EAM+D;EACpE,MAAM;IAAEC,OAAF;IAAWC,oBAAX;IAAiCC;EAAjC,IAA4C,IAAAC,iBAAA,EAChDL,QADgD,EAEhDC,YAFgD,CAAlD;;EAKA,MAAMK,OAAO,GAAIC,CAAD,IAAU;IACxB;;IACA,MAAMC,KAAK,GAAGJ,MAAM,GAAGG,CAAC,CAACE,WAAL,GAAmBF,CAAvC;;IAEA,IAAIC,KAAK,CAACE,KAAN,KAAgBZ,SAAS,CAACa,KAA1B,IAAmCX,QAAQ,CAACY,OAAhD,EAAyD;MACvDZ,QAAQ,CAACY,OAAT,CAAiBJ,KAAjB,EAAwBN,OAAxB;IACD;;IACD,IAAIM,KAAK,CAACE,KAAN,KAAgBZ,SAAS,CAACe,MAA1B,IAAoCb,QAAQ,CAACc,QAAjD,EAA2D;MACzDd,QAAQ,CAACc,QAAT,CAAkBN,KAAlB,EAAyBN,OAAzB;IACD;;IACD,IACEM,KAAK,CAACO,QAAN,KAAmBjB,SAAS,CAACe,MAA7B,IACAL,KAAK,CAACE,KAAN,KAAgBZ,SAAS,CAACkB,GAD1B,IAEAhB,QAAQ,CAACiB,KAHX,EAIE;MACAjB,QAAQ,CAACiB,KAAT,CAAeT,KAAf,EAAsBN,OAAtB;IACD;;IACD,IACEM,KAAK,CAACO,QAAN,KAAmBjB,SAAS,CAACa,KAA7B,IACAH,KAAK,CAACE,KAAN,KAAgBZ,SAAS,CAACoB,MAD1B,IAEAlB,QAAQ,CAACmB,MAHX,EAIE;MACAnB,QAAQ,CAACmB,MAAT,CAAgBX,KAAhB,EAAuBN,OAAvB;IACD;;IACD,IACEM,KAAK,CAACO,QAAN,KAAmBjB,SAAS,CAACe,MAA7B,IACAL,KAAK,CAACE,KAAN,KAAgBZ,SAAS,CAACsB,SAD1B,IAEApB,QAAQ,CAACqB,QAHX,EAIE;MACArB,QAAQ,CAACqB,QAAT,CAAkBb,KAAlB,EAAyBN,OAAzB;IACD;;IACD,IACE,CAACM,KAAK,CAACO,QAAN,KAAmBjB,SAAS,CAACa,KAA7B,IACCH,KAAK,CAACO,QAAN,KAAmBjB,SAAS,CAACe,MAD/B,KAEAL,KAAK,CAACE,KAAN,KAAgBZ,SAAS,CAACa,KAF1B,IAGAH,KAAK,CAACE,KAAN,KAAgBZ,SAAS,CAACe,MAH1B,IAIAb,QAAQ,CAACsB,QALX,EAME;MACAtB,QAAQ,CAACsB,QAAT,CACEd,KADF,EAEEN,OAFF,EAGEM,KAAK,CAACE,KAAN,KAAgBZ,SAAS,CAACsB,SAA1B,IAAuCZ,KAAK,CAACE,KAAN,KAAgBZ,SAAS,CAACoB,MAHnE;IAKD;EACF,CA5CD;;EA8CA,IAAId,MAAJ,EAAY;IACV,OAAOE,OAAP;EACD;;EAED,OAAO,IAAAiB,eAAA,EACLjB,OADK,EAEL,CAAC,6BAAD,EAAgC,uBAAhC,CAFK,EAGLH,oBAHK,CAAP;AAKD"}

package/lib/commonjs/reanimated2/hook/useAnimatedKeyboard.js

@@ -0,0 +1,48 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useAnimatedKeyboard = useAnimatedKeyboard;
+
+var _react = require("react");
+
+var _NativeReanimated = _interopRequireDefault(require("../NativeReanimated"));
+
+var _core = require("../core");
+
+var _commonTypes = require("../commonTypes");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function useAnimatedKeyboard() {
+  const ref = (0, _react.useRef)(null);
+  const listenerId = (0, _react.useRef)(-1);
+  const isSubscribed = (0, _react.useRef)(false);
+
+  if (ref.current === null) {
+    const keyboardEventData = {
+      state: (0, _core.makeMutable)(_commonTypes.KeyboardState.UNKNOWN),
+      height: (0, _core.makeMutable)(0)
+    };
+    listenerId.current = _NativeReanimated.default.subscribeForKeyboardEvents(keyboardEventData);
+    ref.current = keyboardEventData;
+    isSubscribed.current = true;
+  }
+
+  (0, _react.useEffect)(() => {
+    if (isSubscribed.current === false && ref.current !== null) {
+      // subscribe again after Fast Refresh
+      listenerId.current = _NativeReanimated.default.subscribeForKeyboardEvents(ref.current);
+      isSubscribed.current = true;
+    }
+
+    return () => {
+      _NativeReanimated.default.unsubscribeFromKeyboardEvents(listenerId.current);
+
+      isSubscribed.current = false;
+    };
+  }, []);
+  return ref.current;
+}
+//# sourceMappingURL=useAnimatedKeyboard.js.map

package/lib/commonjs/reanimated2/hook/useAnimatedKeyboard.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["useAnimatedKeyboard","ref","useRef","listenerId","isSubscribed","current","keyboardEventData","state","makeMutable","KeyboardState","UNKNOWN","height","NativeReanimated","subscribeForKeyboardEvents","useEffect","unsubscribeFromKeyboardEvents"],"sources":["useAnimatedKeyboard.ts"],"sourcesContent":["import { useEffect, useRef } from 'react';\nimport NativeReanimated from '../NativeReanimated';\nimport { makeMutable } from '../core';\nimport { AnimatedKeyboardInfo, KeyboardState } from '../commonTypes';\n\nexport function useAnimatedKeyboard(): AnimatedKeyboardInfo {\n  const ref = useRef<AnimatedKeyboardInfo | null>(null);\n  const listenerId = useRef<number>(-1);\n  const isSubscribed = useRef<boolean>(false);\n\n  if (ref.current === null) {\n    const keyboardEventData: AnimatedKeyboardInfo = {\n      state: makeMutable(KeyboardState.UNKNOWN),\n      height: makeMutable(0),\n    };\n    listenerId.current =\n      NativeReanimated.subscribeForKeyboardEvents(keyboardEventData);\n    ref.current = keyboardEventData;\n    isSubscribed.current = true;\n  }\n  useEffect(() => {\n    if (isSubscribed.current === false && ref.current !== null) {\n      // subscribe again after Fast Refresh\n      listenerId.current = NativeReanimated.subscribeForKeyboardEvents(\n        ref.current\n      );\n      isSubscribed.current = true;\n    }\n    return () => {\n      NativeReanimated.unsubscribeFromKeyboardEvents(listenerId.current);\n      isSubscribed.current = false;\n    };\n  }, []);\n  return ref.current;\n}\n"],"mappings":";;;;;;;AAAA;;AACA;;AACA;;AACA;;;;AAEO,SAASA,mBAAT,GAAqD;EAC1D,MAAMC,GAAG,GAAG,IAAAC,aAAA,EAAoC,IAApC,CAAZ;EACA,MAAMC,UAAU,GAAG,IAAAD,aAAA,EAAe,CAAC,CAAhB,CAAnB;EACA,MAAME,YAAY,GAAG,IAAAF,aAAA,EAAgB,KAAhB,CAArB;;EAEA,IAAID,GAAG,CAACI,OAAJ,KAAgB,IAApB,EAA0B;IACxB,MAAMC,iBAAuC,GAAG;MAC9CC,KAAK,EAAE,IAAAC,iBAAA,EAAYC,0BAAA,CAAcC,OAA1B,CADuC;MAE9CC,MAAM,EAAE,IAAAH,iBAAA,EAAY,CAAZ;IAFsC,CAAhD;IAIAL,UAAU,CAACE,OAAX,GACEO,yBAAA,CAAiBC,0BAAjB,CAA4CP,iBAA5C,CADF;IAEAL,GAAG,CAACI,OAAJ,GAAcC,iBAAd;IACAF,YAAY,CAACC,OAAb,GAAuB,IAAvB;EACD;;EACD,IAAAS,gBAAA,EAAU,MAAM;IACd,IAAIV,YAAY,CAACC,OAAb,KAAyB,KAAzB,IAAkCJ,GAAG,CAACI,OAAJ,KAAgB,IAAtD,EAA4D;MAC1D;MACAF,UAAU,CAACE,OAAX,GAAqBO,yBAAA,CAAiBC,0BAAjB,CACnBZ,GAAG,CAACI,OADe,CAArB;MAGAD,YAAY,CAACC,OAAb,GAAuB,IAAvB;IACD;;IACD,OAAO,MAAM;MACXO,yBAAA,CAAiBG,6BAAjB,CAA+CZ,UAAU,CAACE,OAA1D;;MACAD,YAAY,CAACC,OAAb,GAAuB,KAAvB;IACD,CAHD;EAID,CAZD,EAYG,EAZH;EAaA,OAAOJ,GAAG,CAACI,OAAX;AACD"}

package/lib/commonjs/reanimated2/hook/useAnimatedReaction.js

@@ -0,0 +1,44 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useAnimatedReaction = useAnimatedReaction;
+
+var _react = require("react");
+
+var _core = require("../core");
+
+var _useSharedValue = require("./useSharedValue");
+
+/**
+ * @param prepare - worklet used for data preparation for the second parameter
+ * @param react - worklet which takes data prepared by the one in the first parameter and performs certain actions
+ * the first worklet defines the inputs, in other words on which shared values change will it be called.
+ * the second one can modify any shared values but those which are mentioned in the first worklet. Beware of that, because this may result in endless loop and high cpu usage.
+ */
+function useAnimatedReaction(prepare, react, dependencies) {
+  const previous = (0, _useSharedValue.useSharedValue)(null);
+
+  if (dependencies === undefined) {
+    dependencies = [Object.values(prepare._closure ?? {}), Object.values(react._closure ?? {}), prepare.__workletHash, react.__workletHash];
+  } else {
+    dependencies.push(prepare.__workletHash, react.__workletHash);
+  }
+
+  (0, _react.useEffect)(() => {
+    const fun = () => {
+      'worklet';
+
+      const input = prepare();
+      react(input, previous.value);
+      previous.value = input;
+    };
+
+    const mapperId = (0, _core.startMapper)(fun, Object.values(prepare._closure ?? {}), []);
+    return () => {
+      (0, _core.stopMapper)(mapperId);
+    };
+  }, dependencies);
+}
+//# sourceMappingURL=useAnimatedReaction.js.map

package/lib/commonjs/reanimated2/hook/useAnimatedReaction.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["useAnimatedReaction","prepare","react","dependencies","previous","useSharedValue","undefined","Object","values","_closure","__workletHash","push","useEffect","fun","input","value","mapperId","startMapper","stopMapper"],"sources":["useAnimatedReaction.ts"],"sourcesContent":["import { useEffect } from 'react';\nimport { BasicWorkletFunction, WorkletFunction } from '../commonTypes';\nimport { startMapper, stopMapper } from '../core';\nimport { DependencyList } from './commonTypes';\nimport { useSharedValue } from './useSharedValue';\n\nexport interface AnimatedReactionWorkletFunction<T> extends WorkletFunction {\n  (prepared: T, previous: T | null): void;\n}\n/**\n * @param prepare - worklet used for data preparation for the second parameter\n * @param react - worklet which takes data prepared by the one in the first parameter and performs certain actions\n * the first worklet defines the inputs, in other words on which shared values change will it be called.\n * the second one can modify any shared values but those which are mentioned in the first worklet. Beware of that, because this may result in endless loop and high cpu usage.\n */\nexport function useAnimatedReaction<T>(\n  prepare: BasicWorkletFunction<T>,\n  react: AnimatedReactionWorkletFunction<T>,\n  dependencies: DependencyList\n): void {\n  const previous = useSharedValue<T | null>(null);\n  if (dependencies === undefined) {\n    dependencies = [\n      Object.values(prepare._closure ?? {}),\n      Object.values(react._closure ?? {}),\n      prepare.__workletHash,\n      react.__workletHash,\n    ];\n  } else {\n    dependencies.push(prepare.__workletHash, react.__workletHash);\n  }\n\n  useEffect(() => {\n    const fun = () => {\n      'worklet';\n      const input = prepare();\n      react(input, previous.value);\n      previous.value = input;\n    };\n    const mapperId = startMapper(\n      fun,\n      Object.values(prepare._closure ?? {}),\n      []\n    );\n    return () => {\n      stopMapper(mapperId);\n    };\n  }, dependencies);\n}\n"],"mappings":";;;;;;;AAAA;;AAEA;;AAEA;;AAKA;AACA;AACA;AACA;AACA;AACA;AACO,SAASA,mBAAT,CACLC,OADK,EAELC,KAFK,EAGLC,YAHK,EAIC;EACN,MAAMC,QAAQ,GAAG,IAAAC,8BAAA,EAAyB,IAAzB,CAAjB;;EACA,IAAIF,YAAY,KAAKG,SAArB,EAAgC;IAC9BH,YAAY,GAAG,CACbI,MAAM,CAACC,MAAP,CAAcP,OAAO,CAACQ,QAAR,IAAoB,EAAlC,CADa,EAEbF,MAAM,CAACC,MAAP,CAAcN,KAAK,CAACO,QAAN,IAAkB,EAAhC,CAFa,EAGbR,OAAO,CAACS,aAHK,EAIbR,KAAK,CAACQ,aAJO,CAAf;EAMD,CAPD,MAOO;IACLP,YAAY,CAACQ,IAAb,CAAkBV,OAAO,CAACS,aAA1B,EAAyCR,KAAK,CAACQ,aAA/C;EACD;;EAED,IAAAE,gBAAA,EAAU,MAAM;IACd,MAAMC,GAAG,GAAG,MAAM;MAChB;;MACA,MAAMC,KAAK,GAAGb,OAAO,EAArB;MACAC,KAAK,CAACY,KAAD,EAAQV,QAAQ,CAACW,KAAjB,CAAL;MACAX,QAAQ,CAACW,KAAT,GAAiBD,KAAjB;IACD,CALD;;IAMA,MAAME,QAAQ,GAAG,IAAAC,iBAAA,EACfJ,GADe,EAEfN,MAAM,CAACC,MAAP,CAAcP,OAAO,CAACQ,QAAR,IAAoB,EAAlC,CAFe,EAGf,EAHe,CAAjB;IAKA,OAAO,MAAM;MACX,IAAAS,gBAAA,EAAWF,QAAX;IACD,CAFD;EAGD,CAfD,EAeGb,YAfH;AAgBD"}

package/lib/commonjs/reanimated2/hook/useAnimatedRef.js

@@ -0,0 +1,43 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useAnimatedRef = useAnimatedRef;
+
+var _react = require("react");
+
+var _useSharedValue = require("./useSharedValue");
+
+var _NativeMethods = require("../NativeMethods");
+
+var _fabricUtils = require("../fabricUtils");
+
+function useAnimatedRef() {
+  const tag = (0, _useSharedValue.useSharedValue)(-1);
+  const ref = (0, _react.useRef)();
+  const isFabric = global._IS_FABRIC;
+
+  if (!ref.current) {
+    const fun = component => {
+      'worklet'; // enters when ref is set by attaching to a component
+
+      if (component) {
+        tag.value = isFabric ? (0, _fabricUtils.getShadowNodeWrapperFromHostInstance)(component) : (0, _NativeMethods.getTag)(component);
+        fun.current = component;
+      }
+
+      return tag.value;
+    };
+
+    Object.defineProperty(fun, 'current', {
+      value: null,
+      writable: true,
+      enumerable: false
+    });
+    ref.current = fun;
+  }
+
+  return ref.current;
+}
+//# sourceMappingURL=useAnimatedRef.js.map

package/lib/commonjs/reanimated2/hook/useAnimatedRef.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["useAnimatedRef","tag","useSharedValue","ref","useRef","isFabric","global","_IS_FABRIC","current","fun","component","value","getShadowNodeWrapperFromHostInstance","getTag","Object","defineProperty","writable","enumerable"],"sources":["useAnimatedRef.ts"],"sourcesContent":["import { Component, useRef } from 'react';\nimport { useSharedValue } from './useSharedValue';\nimport { RefObjectFunction } from './commonTypes';\nimport { ShadowNodeWrapper } from '../commonTypes';\nimport { getTag } from '../NativeMethods';\nimport { getShadowNodeWrapperFromHostInstance } from '../fabricUtils';\n\nexport function useAnimatedRef<T extends Component>(): RefObjectFunction<T> {\n  const tag = useSharedValue<number | ShadowNodeWrapper | null>(-1);\n  const ref = useRef<RefObjectFunction<T>>();\n  const isFabric = global._IS_FABRIC;\n\n  if (!ref.current) {\n    const fun: RefObjectFunction<T> = <RefObjectFunction<T>>((component) => {\n      'worklet';\n      // enters when ref is set by attaching to a component\n      if (component) {\n        tag.value = isFabric\n          ? getShadowNodeWrapperFromHostInstance(component)\n          : getTag(component);\n        fun.current = component;\n      }\n      return tag.value;\n    });\n\n    Object.defineProperty(fun, 'current', {\n      value: null,\n      writable: true,\n      enumerable: false,\n    });\n    ref.current = fun;\n  }\n\n  return ref.current;\n}\n"],"mappings":";;;;;;;AAAA;;AACA;;AAGA;;AACA;;AAEO,SAASA,cAAT,GAAqE;EAC1E,MAAMC,GAAG,GAAG,IAAAC,8BAAA,EAAkD,CAAC,CAAnD,CAAZ;EACA,MAAMC,GAAG,GAAG,IAAAC,aAAA,GAAZ;EACA,MAAMC,QAAQ,GAAGC,MAAM,CAACC,UAAxB;;EAEA,IAAI,CAACJ,GAAG,CAACK,OAAT,EAAkB;IAChB,MAAMC,GAAyB,GAA2BC,SAAD,IAAe;MACtE,UADsE,CAEtE;;MACA,IAAIA,SAAJ,EAAe;QACbT,GAAG,CAACU,KAAJ,GAAYN,QAAQ,GAChB,IAAAO,iDAAA,EAAqCF,SAArC,CADgB,GAEhB,IAAAG,qBAAA,EAAOH,SAAP,CAFJ;QAGAD,GAAG,CAACD,OAAJ,GAAcE,SAAd;MACD;;MACD,OAAOT,GAAG,CAACU,KAAX;IACD,CAVD;;IAYAG,MAAM,CAACC,cAAP,CAAsBN,GAAtB,EAA2B,SAA3B,EAAsC;MACpCE,KAAK,EAAE,IAD6B;MAEpCK,QAAQ,EAAE,IAF0B;MAGpCC,UAAU,EAAE;IAHwB,CAAtC;IAKAd,GAAG,CAACK,OAAJ,GAAcC,GAAd;EACD;;EAED,OAAON,GAAG,CAACK,OAAX;AACD"}

package/lib/commonjs/reanimated2/hook/useAnimatedScrollHandler.js

@@ -0,0 +1,62 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useAnimatedScrollHandler = useAnimatedScrollHandler;
+
+var _Hooks = require("./Hooks");
+
+function useAnimatedScrollHandler(handlers, dependencies) {
+  // case when handlers is a function
+  const scrollHandlers = typeof handlers === 'function' ? {
+    onScroll: handlers
+  } : handlers;
+  const {
+    context,
+    doDependenciesDiffer
+  } = (0, _Hooks.useHandler)(scrollHandlers, dependencies); // build event subscription array
+
+  const subscribeForEvents = ['onScroll'];
+
+  if (scrollHandlers.onBeginDrag !== undefined) {
+    subscribeForEvents.push('onScrollBeginDrag');
+  }
+
+  if (scrollHandlers.onEndDrag !== undefined) {
+    subscribeForEvents.push('onScrollEndDrag');
+  }
+
+  if (scrollHandlers.onMomentumBegin !== undefined) {
+    subscribeForEvents.push('onMomentumScrollBegin');
+  }
+
+  if (scrollHandlers.onMomentumEnd !== undefined) {
+    subscribeForEvents.push('onMomentumScrollEnd');
+  }
+
+  return (0, _Hooks.useEvent)(event => {
+    'worklet';
+
+    const {
+      onScroll,
+      onBeginDrag,
+      onEndDrag,
+      onMomentumBegin,
+      onMomentumEnd
+    } = scrollHandlers;
+
+    if (onScroll && event.eventName.endsWith('onScroll')) {
+      onScroll(event, context);
+    } else if (onBeginDrag && event.eventName.endsWith('onScrollBeginDrag')) {
+      onBeginDrag(event, context);
+    } else if (onEndDrag && event.eventName.endsWith('onScrollEndDrag')) {
+      onEndDrag(event, context);
+    } else if (onMomentumBegin && event.eventName.endsWith('onMomentumScrollBegin')) {
+      onMomentumBegin(event, context);
+    } else if (onMomentumEnd && event.eventName.endsWith('onMomentumScrollEnd')) {
+      onMomentumEnd(event, context);
+    }
+  }, subscribeForEvents, doDependenciesDiffer);
+}
+//# sourceMappingURL=useAnimatedScrollHandler.js.map

package/lib/commonjs/reanimated2/hook/useAnimatedScrollHandler.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["useAnimatedScrollHandler","handlers","dependencies","scrollHandlers","onScroll","context","doDependenciesDiffer","useHandler","subscribeForEvents","onBeginDrag","undefined","push","onEndDrag","onMomentumBegin","onMomentumEnd","useEvent","event","eventName","endsWith"],"sources":["useAnimatedScrollHandler.ts"],"sourcesContent":["import { RefObject } from 'react';\nimport { NativeScrollEvent } from 'react-native';\nimport { Context, NativeEvent, WorkletFunction } from '../commonTypes';\nimport WorkletEventHandler from '../WorkletEventHandler';\nimport { DependencyList } from './commonTypes';\nimport { useEvent, useHandler } from './Hooks';\n\nexport interface ScrollHandler<TContext extends Context>\n  extends WorkletFunction {\n  (event: NativeScrollEvent, context?: TContext): void;\n}\n\ninterface ScrollEvent extends NativeScrollEvent, NativeEvent<ScrollEvent> {\n  eventName: string;\n}\nexport interface ScrollHandlers<TContext extends Context> {\n  [key: string]: ScrollHandler<TContext> | undefined;\n  onScroll?: ScrollHandler<TContext>;\n  onBeginDrag?: ScrollHandler<TContext>;\n  onEndDrag?: ScrollHandler<TContext>;\n  onMomentumBegin?: ScrollHandler<TContext>;\n  onMomentumEnd?: ScrollHandler<TContext>;\n}\n\nexport function useAnimatedScrollHandler<TContext extends Context>(\n  handlers: ScrollHandlers<TContext> | ScrollHandler<TContext>,\n  dependencies?: DependencyList\n): RefObject<WorkletEventHandler<ScrollEvent>> {\n  // case when handlers is a function\n  const scrollHandlers: ScrollHandlers<TContext> =\n    typeof handlers === 'function' ? { onScroll: handlers } : handlers;\n  const { context, doDependenciesDiffer } = useHandler<ScrollEvent, TContext>(\n    scrollHandlers,\n    dependencies\n  );\n\n  // build event subscription array\n  const subscribeForEvents = ['onScroll'];\n  if (scrollHandlers.onBeginDrag !== undefined) {\n    subscribeForEvents.push('onScrollBeginDrag');\n  }\n  if (scrollHandlers.onEndDrag !== undefined) {\n    subscribeForEvents.push('onScrollEndDrag');\n  }\n  if (scrollHandlers.onMomentumBegin !== undefined) {\n    subscribeForEvents.push('onMomentumScrollBegin');\n  }\n  if (scrollHandlers.onMomentumEnd !== undefined) {\n    subscribeForEvents.push('onMomentumScrollEnd');\n  }\n\n  return useEvent<ScrollEvent>(\n    (event: ScrollEvent) => {\n      'worklet';\n      const {\n        onScroll,\n        onBeginDrag,\n        onEndDrag,\n        onMomentumBegin,\n        onMomentumEnd,\n      } = scrollHandlers;\n      if (onScroll && event.eventName.endsWith('onScroll')) {\n        onScroll(event, context);\n      } else if (onBeginDrag && event.eventName.endsWith('onScrollBeginDrag')) {\n        onBeginDrag(event, context);\n      } else if (onEndDrag && event.eventName.endsWith('onScrollEndDrag')) {\n        onEndDrag(event, context);\n      } else if (\n        onMomentumBegin &&\n        event.eventName.endsWith('onMomentumScrollBegin')\n      ) {\n        onMomentumBegin(event, context);\n      } else if (\n        onMomentumEnd &&\n        event.eventName.endsWith('onMomentumScrollEnd')\n      ) {\n        onMomentumEnd(event, context);\n      }\n    },\n    subscribeForEvents,\n    doDependenciesDiffer\n  );\n}\n"],"mappings":";;;;;;;AAKA;;AAmBO,SAASA,wBAAT,CACLC,QADK,EAELC,YAFK,EAGwC;EAC7C;EACA,MAAMC,cAAwC,GAC5C,OAAOF,QAAP,KAAoB,UAApB,GAAiC;IAAEG,QAAQ,EAAEH;EAAZ,CAAjC,GAA0DA,QAD5D;EAEA,MAAM;IAAEI,OAAF;IAAWC;EAAX,IAAoC,IAAAC,iBAAA,EACxCJ,cADwC,EAExCD,YAFwC,CAA1C,CAJ6C,CAS7C;;EACA,MAAMM,kBAAkB,GAAG,CAAC,UAAD,CAA3B;;EACA,IAAIL,cAAc,CAACM,WAAf,KAA+BC,SAAnC,EAA8C;IAC5CF,kBAAkB,CAACG,IAAnB,CAAwB,mBAAxB;EACD;;EACD,IAAIR,cAAc,CAACS,SAAf,KAA6BF,SAAjC,EAA4C;IAC1CF,kBAAkB,CAACG,IAAnB,CAAwB,iBAAxB;EACD;;EACD,IAAIR,cAAc,CAACU,eAAf,KAAmCH,SAAvC,EAAkD;IAChDF,kBAAkB,CAACG,IAAnB,CAAwB,uBAAxB;EACD;;EACD,IAAIR,cAAc,CAACW,aAAf,KAAiCJ,SAArC,EAAgD;IAC9CF,kBAAkB,CAACG,IAAnB,CAAwB,qBAAxB;EACD;;EAED,OAAO,IAAAI,eAAA,EACJC,KAAD,IAAwB;IACtB;;IACA,MAAM;MACJZ,QADI;MAEJK,WAFI;MAGJG,SAHI;MAIJC,eAJI;MAKJC;IALI,IAMFX,cANJ;;IAOA,IAAIC,QAAQ,IAAIY,KAAK,CAACC,SAAN,CAAgBC,QAAhB,CAAyB,UAAzB,CAAhB,EAAsD;MACpDd,QAAQ,CAACY,KAAD,EAAQX,OAAR,CAAR;IACD,CAFD,MAEO,IAAII,WAAW,IAAIO,KAAK,CAACC,SAAN,CAAgBC,QAAhB,CAAyB,mBAAzB,CAAnB,EAAkE;MACvET,WAAW,CAACO,KAAD,EAAQX,OAAR,CAAX;IACD,CAFM,MAEA,IAAIO,SAAS,IAAII,KAAK,CAACC,SAAN,CAAgBC,QAAhB,CAAyB,iBAAzB,CAAjB,EAA8D;MACnEN,SAAS,CAACI,KAAD,EAAQX,OAAR,CAAT;IACD,CAFM,MAEA,IACLQ,eAAe,IACfG,KAAK,CAACC,SAAN,CAAgBC,QAAhB,CAAyB,uBAAzB,CAFK,EAGL;MACAL,eAAe,CAACG,KAAD,EAAQX,OAAR,CAAf;IACD,CALM,MAKA,IACLS,aAAa,IACbE,KAAK,CAACC,SAAN,CAAgBC,QAAhB,CAAyB,qBAAzB,CAFK,EAGL;MACAJ,aAAa,CAACE,KAAD,EAAQX,OAAR,CAAb;IACD;EACF,CA3BI,EA4BLG,kBA5BK,EA6BLF,oBA7BK,CAAP;AA+BD"}