@react-native-oh-tpl/react-native-gesture-handler 2.12.1-0.0.1

package/ios/RNGestureHandlerPointerTracker.h

@@ -0,0 +1,25 @@
+#import <Foundation/Foundation.h>
+
+#import "RNGHTouchEventType.h"
+
+#define MAX_POINTERS_COUNT 12
+
+@class RNGestureHandler;
+
+@interface RNGestureHandlerPointerTracker : NSObject
+
+@property (nonatomic) RNGHTouchEventType eventType;
+@property (nonatomic) NSArray<NSDictionary *> *changedPointersData;
+@property (nonatomic) NSArray<NSDictionary *> *allPointersData;
+@property (nonatomic) int trackedPointersCount;
+
+- (id)initWithGestureHandler:(RNGestureHandler *)gestureHandler;
+
+- (void)touchesBegan:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event;
+- (void)touchesMoved:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event;
+- (void)touchesEnded:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event;
+- (void)touchesCancelled:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event;
+- (void)reset;
+- (void)cancelPointers;
+
+@end

package/ios/RNGestureHandlerPointerTracker.m

@@ -0,0 +1,243 @@
+#import "RNGestureHandlerPointerTracker.h"
+#import "RNGestureHandler.h"
+
+#import <React/UIView+React.h>
+
+@implementation RNGestureHandlerPointerTracker {
+  __weak RNGestureHandler *_gestureHandler;
+  UITouch *_trackedPointers[MAX_POINTERS_COUNT];
+  int _trackedPointersCount;
+}
+
+- (id)initWithGestureHandler:(id)gestureHandler
+{
+  _gestureHandler = gestureHandler;
+  _trackedPointersCount = 0;
+  _changedPointersData = nil;
+  _allPointersData = nil;
+
+  for (int i = 0; i < MAX_POINTERS_COUNT; i++) {
+    _trackedPointers[i] = nil;
+  }
+
+  return self;
+}
+
+- (int)registerTouch:(UITouch *)touch
+{
+  for (int index = 0; index < MAX_POINTERS_COUNT; index++) {
+    if (_trackedPointers[index] == nil) {
+      _trackedPointers[index] = touch;
+      return index;
+    }
+  }
+
+  return -1;
+}
+
+- (int)unregisterTouch:(UITouch *)touch
+{
+  for (int index = 0; index < MAX_POINTERS_COUNT; index++) {
+    if (_trackedPointers[index] == touch) {
+      _trackedPointers[index] = nil;
+      return index;
+    }
+  }
+
+  return -1;
+}
+
+- (int)findTouchIndex:(UITouch *)touch
+{
+  for (int index = 0; index < MAX_POINTERS_COUNT; index++) {
+    if (_trackedPointers[index] == touch) {
+      return index;
+    }
+  }
+  return -1;
+}
+
+- (int)registeredTouchesCount
+{
+  int count = 0;
+  for (int i = 0; i < MAX_POINTERS_COUNT; i++) {
+    if (_trackedPointers[i] != nil) {
+      count++;
+    }
+  }
+  return count;
+}
+
+- (NSDictionary *)extractPointerData:(int)index forTouch:(UITouch *)touch
+{
+  CGPoint relativePos = [touch locationInView:_gestureHandler.recognizer.view];
+  CGPoint absolutePos = [touch locationInView:_gestureHandler.recognizer.view.window];
+
+  return @{
+    @"id" : @(index),
+    @"x" : @(relativePos.x),
+    @"y" : @(relativePos.y),
+    @"absoluteX" : @(absolutePos.x),
+    @"absoluteY" : @(absolutePos.y)
+  };
+}
+
+- (void)extractAllTouches
+{
+  int registeredTouches = [self registeredTouchesCount];
+
+  NSDictionary *data[registeredTouches];
+  int nextIndex = 0;
+
+  for (int i = 0; i < MAX_POINTERS_COUNT; i++) {
+    UITouch *touch = _trackedPointers[i];
+    if (touch != nil) {
+      data[nextIndex++] = [self extractPointerData:i forTouch:touch];
+    }
+  }
+
+  _allPointersData = [[NSArray alloc] initWithObjects:data count:registeredTouches];
+}
+
+- (void)touchesBegan:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event
+{
+  if (!_gestureHandler.needsPointerData) {
+    return;
+  }
+
+  _eventType = RNGHTouchEventTypePointerDown;
+
+  NSDictionary *data[touches.count];
+
+  for (int i = 0; i < [touches count]; i++) {
+    UITouch *touch = [[touches allObjects] objectAtIndex:i];
+    int index = [self registerTouch:touch];
+    if (index >= 0) {
+      _trackedPointersCount++;
+    }
+
+    data[i] = [self extractPointerData:index forTouch:touch];
+  }
+
+  _changedPointersData = [[NSArray alloc] initWithObjects:data count:[touches count]];
+  // extract all touches last to include the ones that were just added
+  [self extractAllTouches];
+  [self sendEvent];
+}
+
+- (void)touchesMoved:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event
+{
+  if (!_gestureHandler.needsPointerData) {
+    return;
+  }
+
+  _eventType = RNGHTouchEventTypePointerMove;
+
+  NSDictionary *data[touches.count];
+
+  for (int i = 0; i < [touches count]; i++) {
+    UITouch *touch = [[touches allObjects] objectAtIndex:i];
+    int index = [self findTouchIndex:touch];
+    data[i] = [self extractPointerData:index forTouch:touch];
+  }
+
+  _changedPointersData = [[NSArray alloc] initWithObjects:data count:[touches count]];
+  [self extractAllTouches];
+  [self sendEvent];
+}
+
+- (void)touchesEnded:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event
+{
+  if (!_gestureHandler.needsPointerData) {
+    return;
+  }
+
+  // extract all touches first to include the ones that were just lifted
+  [self extractAllTouches];
+
+  _eventType = RNGHTouchEventTypePointerUp;
+
+  NSDictionary *data[touches.count];
+
+  for (int i = 0; i < [touches count]; i++) {
+    UITouch *touch = [[touches allObjects] objectAtIndex:i];
+    int index = [self unregisterTouch:touch];
+    if (index >= 0) {
+      _trackedPointersCount--;
+    }
+
+    data[i] = [self extractPointerData:index forTouch:touch];
+  }
+
+  _changedPointersData = [[NSArray alloc] initWithObjects:data count:[touches count]];
+  [self sendEvent];
+}
+
+- (void)touchesCancelled:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event
+{
+  if (!_gestureHandler.needsPointerData) {
+    return;
+  }
+
+  [self reset];
+}
+
+- (void)reset
+{
+  if (!_gestureHandler.needsPointerData) {
+    return;
+  }
+
+  if (_trackedPointersCount == 0) {
+    // gesture has finished because all pointers were lifted, reset event type to send state change event
+    _eventType = RNGHTouchEventTypeUndetermined;
+  } else {
+    // turns out that the gesture may be made to fail without calling touchesCancelled in that case there
+    // are still tracked pointers but the recognizer state is already set to UIGestureRecognizerStateFailed
+    // we need to clear the pointers and send info about their cancellation
+    [self cancelPointers];
+  }
+
+  [_gestureHandler reset];
+}
+
+- (void)cancelPointers
+{
+  // extract all touches first to include the ones that were just cancelled
+  [self extractAllTouches];
+
+  int registeredTouches = [self registeredTouchesCount];
+
+  if (registeredTouches > 0) {
+    int nextIndex = 0;
+    NSDictionary *data[registeredTouches];
+
+    for (int i = 0; i < MAX_POINTERS_COUNT; i++) {
+      UITouch *touch = _trackedPointers[i];
+      if (touch != nil) {
+        data[nextIndex++] = [self extractPointerData:i forTouch:touch];
+        [self unregisterTouch:touch];
+      }
+    }
+
+    _eventType = RNGHTouchEventTypeCancelled;
+    _changedPointersData = [[NSArray alloc] initWithObjects:data count:registeredTouches];
+    [self sendEvent];
+    _trackedPointersCount = 0;
+  }
+}
+
+- (void)sendEvent
+{
+  // it may happen that the gesture recognizer is reset after it's been unbound from the view,
+  // it that recognizer tried to send event, the app would crash because the target of the event
+  // would be nil.
+  if (!_gestureHandler.needsPointerData || _gestureHandler.recognizer.view.reactTag == nil) {
+    return;
+  }
+
+  [_gestureHandler sendTouchEventInState:[_gestureHandler state]
+                          forViewWithTag:_gestureHandler.recognizer.view.reactTag];
+}
+
+@end

package/ios/RNGestureHandlerRegistry.h

@@ -0,0 +1,21 @@
+//
+//  RNGestureHandlerRegistry.h
+//  RNGestureHandler
+//
+//  Created by Krzysztof Magiera on 12/10/2017.
+//  Copyright © 2017 Software Mansion. All rights reserved.
+//
+
+#import "RNGestureHandler.h"
+
+@interface RNGestureHandlerRegistry : NSObject
+
+- (nullable RNGestureHandler *)handlerWithTag:(nonnull NSNumber *)handlerTag;
+- (void)registerGestureHandler:(nonnull RNGestureHandler *)gestureHandler;
+- (void)attachHandlerWithTag:(nonnull NSNumber *)handlerTag
+                      toView:(nonnull UIView *)view
+              withActionType:(RNGestureHandlerActionType)actionType;
+- (void)dropHandlerWithTag:(nonnull NSNumber *)handlerTag;
+- (void)dropAllHandlers;
+
+@end

package/ios/RNGestureHandlerRegistry.m

@@ -0,0 +1,63 @@
+//
+//  RNGestureHandlerRegistry.m
+//  RNGestureHandler
+//
+//  Created by Krzysztof Magiera on 12/10/2017.
+//  Copyright © 2017 Software Mansion. All rights reserved.
+//
+
+#import "RNGestureHandlerRegistry.h"
+
+#import <React/RCTAssert.h>
+
+@implementation RNGestureHandlerRegistry {
+  NSMutableDictionary<NSNumber *, RNGestureHandler *> *_handlers;
+}
+
+- (instancetype)init
+{
+  if ((self = [super init])) {
+    _handlers = [NSMutableDictionary new];
+  }
+  return self;
+}
+
+- (RNGestureHandler *)handlerWithTag:(NSNumber *)handlerTag
+{
+  return _handlers[handlerTag];
+}
+
+- (void)registerGestureHandler:(RNGestureHandler *)gestureHandler
+{
+  _handlers[gestureHandler.tag] = gestureHandler;
+}
+
+- (void)attachHandlerWithTag:(NSNumber *)handlerTag
+                      toView:(UIView *)view
+              withActionType:(RNGestureHandlerActionType)actionType
+{
+  RNGestureHandler *handler = _handlers[handlerTag];
+  RCTAssert(handler != nil, @"Handler for tag %@ does not exists", handlerTag);
+  [handler unbindFromView];
+  handler.actionType = actionType;
+  [handler bindToView:view];
+}
+
+- (void)dropHandlerWithTag:(NSNumber *)handlerTag
+{
+  RNGestureHandler *handler = _handlers[handlerTag];
+  [handler unbindFromView];
+  [_handlers removeObjectForKey:handlerTag];
+}
+
+- (void)dropAllHandlers
+{
+  for (NSNumber *tag in _handlers) {
+    RNGestureHandler *handler = _handlers[tag];
+    [handler unbindFromView];
+  }
+
+  [_handlers removeAllObjects];
+}
+
+@end

package/ios/RNGestureHandlerRootViewComponentView.mm

@@ -0,0 +1,21 @@
+#ifdef RCT_NEW_ARCH_ENABLED
+
+#import <React/RCTFabricComponentsPlugins.h>
+
+Class<RCTComponentViewProtocol> RNGestureHandlerRootViewCls(void)
+{
+  // RNGestureHandlerRootView is Android-only.
+  // However, if we set `excludedPlatforms: ['iOS']` in `codegenNativeComponent`,
+  // codegen still generates `RNGestureHandlerRootViewShadowNode` (which it shouldn't)
+  // and thus the project fails to compile due to missing `RNGestureHandlerRootViewProps`.
+  // As a workaround, we could set `interfaceOnly: true` to disable autogenerating ShadowNode
+  // but then we would have to implement ComponentDescriptor and ShadowNode ourselves
+  // (probably just generate it once and keep the generated files in the repo)
+  // as well as make additional configuration so these files are actually compiled for Android.
+  // This simple trick allows us to have all the necessary files generated
+  // and compiled on Android while avoiding compilation errors on iOS.
+  // TODO: remove this file once `excludedPlatforms` option properly disables generating ShadowNode
+  return nil;
+}
+
+#endif // RCT_NEW_ARCH_ENABLED

package/ios/RNGestureHandlerState.h

@@ -0,0 +1,10 @@
+#import <Foundation/Foundation.h>
+
+typedef NS_ENUM(NSInteger, RNGestureHandlerState) {
+  RNGestureHandlerStateUndetermined = 0,
+  RNGestureHandlerStateFailed,
+  RNGestureHandlerStateBegan,
+  RNGestureHandlerStateCancelled,
+  RNGestureHandlerStateActive,
+  RNGestureHandlerStateEnd,
+};

package/ios/RNGestureHandlerStateManager.h

@@ -0,0 +1,5 @@
+@protocol RNGestureHandlerStateManager
+
+- (void)setGestureState:(int)state forHandler:(int)handlerTag;
+
+@end

package/ios/RNManualActivationRecognizer.h

@@ -0,0 +1,10 @@
+#import <UIKit/UIGestureRecognizerSubclass.h>
+
+@class RNGestureHandler;
+
+@interface RNManualActivationRecognizer : UIGestureRecognizer <UIGestureRecognizerDelegate>
+
+- (id)initWithGestureHandler:(RNGestureHandler *)gestureHandler;
+- (void)fail;
+
+@end

package/ios/RNManualActivationRecognizer.m

@@ -0,0 +1,88 @@
+#import "RNManualActivationRecognizer.h"
+#import "RNGestureHandler.h"
+
+@implementation RNManualActivationRecognizer {
+  RNGestureHandler *_handler;
+  int _activePointers;
+}
+
+- (id)initWithGestureHandler:(RNGestureHandler *)gestureHandler
+{
+  if ((self = [super initWithTarget:self action:@selector(handleGesture:)])) {
+    _handler = gestureHandler;
+    _activePointers = 0;
+    self.delegate = self;
+    self.cancelsTouchesInView = NO;
+  }
+  return self;
+}
+
+- (void)handleGesture:(UIGestureRecognizer *)recognizer
+{
+  if (recognizer.state == UIGestureRecognizerStateBegan) {
+    self.state = UIGestureRecognizerStateEnded;
+    [self reset];
+  }
+}
+
+- (void)touchesBegan:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event
+{
+  [super touchesBegan:touches withEvent:event];
+
+  _activePointers += touches.count;
+}
+
+- (void)touchesMoved:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event
+{
+  [super touchesMoved:touches withEvent:event];
+}
+
+- (void)touchesEnded:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event
+{
+  [super touchesEnded:touches withEvent:event];
+
+  _activePointers -= touches.count;
+
+  if (_activePointers == 0) {
+    self.state = UIGestureRecognizerStateBegan;
+  }
+}
+
+- (void)touchesCancelled:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event
+{
+  [super touchesCancelled:touches withEvent:event];
+
+  _activePointers = 0;
+  [self reset];
+}
+
+- (void)reset
+{
+  self.enabled = YES;
+  [super reset];
+}
+
+- (void)fail
+{
+  self.enabled = NO;
+}
+
+- (BOOL)gestureRecognizer:(UIGestureRecognizer *)gestureRecognizer
+    shouldRecognizeSimultaneouslyWithGestureRecognizer:(UIGestureRecognizer *)otherGestureRecognizer
+{
+  return YES;
+}
+
+- (BOOL)shouldBeRequiredToFailByGestureRecognizer:(UIGestureRecognizer *)otherGestureRecognizer
+{
+  RNGestureHandler *handler = [RNGestureHandler findGestureHandlerByRecognizer:otherGestureRecognizer];
+  if (handler != nil) {
+    if (handler.tag == _handler.tag) {
+      return YES;
+    }
+  }
+
+  return NO;
+}
+
+@end

package/ios/RNRootViewGestureRecognizer.h

@@ -0,0 +1,17 @@
+//
+//  RNRootViewGestureRecognizer.h
+//  RNGestureHandler
+//
+//  Created by Krzysztof Magiera on 12/10/2017.
+//  Copyright © 2017 Software Mansion. All rights reserved.
+//
+
+#import "RNGestureHandler.h"
+
+@interface RNRootViewGestureRecognizer : UIGestureRecognizer
+
+@property (nullable, nonatomic, weak) id<RNRootViewGestureRecognizerDelegate> delegate;
+
+- (void)blockOtherRecognizers;
+
+@end

package/ios/RNRootViewGestureRecognizer.m

@@ -0,0 +1,106 @@
+//
+//  RNRootViewGestureRecognizer.m
+//  RNGestureHandler
+//
+//  Created by Krzysztof Magiera on 12/10/2017.
+//  Copyright © 2017 Software Mansion. All rights reserved.
+//
+
+#import "RNRootViewGestureRecognizer.h"
+
+#import <UIKit/UIGestureRecognizerSubclass.h>
+
+#ifdef RCT_NEW_ARCH_ENABLED
+#import <React/RCTSurfaceTouchHandler.h>
+#else
+#import <React/RCTTouchHandler.h>
+#endif // RCT_NEW_ARCH_ENABLED
+
+@implementation RNRootViewGestureRecognizer {
+  BOOL _active;
+}
+
+@dynamic delegate;
+
+- (instancetype)init
+{
+  if (self = [super init]) {
+    self.delaysTouchesEnded = NO;
+    self.delaysTouchesBegan = NO;
+  }
+  return self;
+}
+
+- (BOOL)shouldBeRequiredToFailByGestureRecognizer:(UIGestureRecognizer *)otherGestureRecognizer
+{
+  // This method is used to implement "enabled" feature for gesture handlers. We enforce gesture
+  // recognizers that are connected with "disabled" handlers to wait for the root gesture
+  // recognizer to fail and this way we block them from acting.
+  RNGestureHandler *otherHandler = [RNGestureHandler findGestureHandlerByRecognizer:otherGestureRecognizer];
+  if (otherHandler != nil && otherHandler.enabled == NO) {
+    return YES;
+  }
+  return NO;
+}
+
+- (BOOL)canPreventGestureRecognizer:(UIGestureRecognizer *)preventedGestureRecognizer
+{
+  return ![preventedGestureRecognizer isKindOfClass:[
+#ifdef RCT_NEW_ARCH_ENABLED
+        RCTSurfaceTouchHandler
+#else
+        RCTTouchHandler
+#endif
+        class]];
+}
+
+- (BOOL)canBePreventedByGestureRecognizer:(UIGestureRecognizer *)preventingGestureRecognizer
+{
+  // When this method is called it means that one of handlers has activated, in this case we want
+  // to send an info to JS so that it cancells all JS responders, as long as the preventing
+  // recognizer is from Gesture Handler, otherwise we might break some interactions
+  RNGestureHandler *handler = [RNGestureHandler findGestureHandlerByRecognizer:preventingGestureRecognizer];
+  if (handler != nil) {
+    [self.delegate gestureRecognizer:preventingGestureRecognizer didActivateInViewWithTouchHandler:self.view];
+  }
+
+  return [super canBePreventedByGestureRecognizer:preventingGestureRecognizer];
+}
+
+- (void)touchesBegan:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event
+{
+  _active = YES;
+  self.state = UIGestureRecognizerStatePossible;
+}
+
+- (void)touchesMoved:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event
+{
+  self.state = UIGestureRecognizerStatePossible;
+}
+
+- (void)touchesEnded:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event
+{
+  if (self.state == UIGestureRecognizerStateBegan || self.state == UIGestureRecognizerStateChanged) {
+    self.state = UIGestureRecognizerStateEnded;
+  } else {
+    self.state = UIGestureRecognizerStateFailed;
+  }
+  [self reset];
+  _active = NO;
+}
+
+- (void)touchesCancelled:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event
+{
+  self.state = UIGestureRecognizerStateCancelled;
+  [self reset];
+  _active = NO;
+}
+
+- (void)blockOtherRecognizers
+{
+  if (_active) {
+    self.state = UIGestureRecognizerStateBegan;
+  }
+}
+
+@end

package/jest-utils/package.json

@@ -0,0 +1,6 @@
+{
+  "main": "../lib/commonjs/jestUtils/index",
+  "module": "../lib/module/jestUtils/index",
+  "react-native": "../src/jestUtils/index",
+  "types": "../lib/typescript/jestUtils/index.d.ts"
+}

package/jestSetup.js

@@ -0,0 +1,7 @@
+jest.mock('./src/RNGestureHandlerModule', () => require('./src/mocks'));
+jest.mock('./lib/commonjs/RNGestureHandlerModule', () =>
+  require('./lib/commonjs/mocks')
+);
+jest.mock('./lib/module/RNGestureHandlerModule', () =>
+  require('./lib/module/mocks')
+);

package/lib/commonjs/ActionType.js

@@ -0,0 +1,15 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ActionType = void 0;
+const ActionType = {
+  REANIMATED_WORKLET: 1,
+  NATIVE_ANIMATED_EVENT: 2,
+  JS_FUNCTION_OLD_API: 3,
+  JS_FUNCTION_NEW_API: 4
+}; // eslint-disable-next-line @typescript-eslint/no-redeclare -- backward compatibility; it can be used as a type and as a value
+
+exports.ActionType = ActionType;
+//# sourceMappingURL=ActionType.js.map

package/lib/commonjs/ActionType.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["ActionType.ts"],"names":["ActionType","REANIMATED_WORKLET","NATIVE_ANIMATED_EVENT","JS_FUNCTION_OLD_API","JS_FUNCTION_NEW_API"],"mappings":";;;;;;AAAO,MAAMA,UAAU,GAAG;AACxBC,EAAAA,kBAAkB,EAAE,CADI;AAExBC,EAAAA,qBAAqB,EAAE,CAFC;AAGxBC,EAAAA,mBAAmB,EAAE,CAHG;AAIxBC,EAAAA,mBAAmB,EAAE;AAJG,CAAnB,C,CAOP","sourcesContent":["export const ActionType = {\r\n  REANIMATED_WORKLET: 1,\r\n  NATIVE_ANIMATED_EVENT: 2,\r\n  JS_FUNCTION_OLD_API: 3,\r\n  JS_FUNCTION_NEW_API: 4,\r\n} as const;\r\n\r\n// eslint-disable-next-line @typescript-eslint/no-redeclare -- backward compatibility; it can be used as a type and as a value\r\nexport type ActionType = typeof ActionType[keyof typeof ActionType];\r\n"]}

package/lib/commonjs/Directions.js

@@ -0,0 +1,15 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Directions = void 0;
+const Directions = {
+  RIGHT: 1,
+  LEFT: 2,
+  UP: 4,
+  DOWN: 8
+}; // eslint-disable-next-line @typescript-eslint/no-redeclare -- backward compatibility; it can be used as a type and as a value
+
+exports.Directions = Directions;
+//# sourceMappingURL=Directions.js.map

package/lib/commonjs/Directions.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["Directions.ts"],"names":["Directions","RIGHT","LEFT","UP","DOWN"],"mappings":";;;;;;AAAO,MAAMA,UAAU,GAAG;AACxBC,EAAAA,KAAK,EAAE,CADiB;AAExBC,EAAAA,IAAI,EAAE,CAFkB;AAGxBC,EAAAA,EAAE,EAAE,CAHoB;AAIxBC,EAAAA,IAAI,EAAE;AAJkB,CAAnB,C,CAOP","sourcesContent":["export const Directions = {\r\n  RIGHT: 1,\r\n  LEFT: 2,\r\n  UP: 4,\r\n  DOWN: 8,\r\n} as const;\r\n\r\n// eslint-disable-next-line @typescript-eslint/no-redeclare -- backward compatibility; it can be used as a type and as a value\r\nexport type Directions = typeof Directions[keyof typeof Directions];\r\n"]}