react-native-gleam 1.0.0-beta.1

package/android/src/main/java/com/gleam/GleamViewManager.kt

@@ -0,0 +1,89 @@
+package com.gleam
+
+import android.graphics.Color
+import com.facebook.react.module.annotations.ReactModule
+import com.facebook.react.uimanager.ThemedReactContext
+import com.facebook.react.uimanager.ViewGroupManager
+import com.facebook.react.uimanager.ViewManagerDelegate
+import com.facebook.react.uimanager.annotations.ReactProp
+import com.facebook.react.viewmanagers.GleamViewManagerInterface
+import com.facebook.react.viewmanagers.GleamViewManagerDelegate
+
+@ReactModule(name = GleamViewManager.NAME)
+class GleamViewManager : ViewGroupManager<GleamView>(),
+  GleamViewManagerInterface<GleamView> {
+
+  private val mDelegate: ViewManagerDelegate<GleamView> = GleamViewManagerDelegate(this)
+
+  override fun getDelegate(): ViewManagerDelegate<GleamView> = mDelegate
+
+  override fun getName(): String = NAME
+
+  override fun createViewInstance(context: ThemedReactContext): GleamView {
+    return GleamView(context)
+  }
+
+  @ReactProp(name = "loading", defaultBoolean = true)
+  override fun setLoading(view: GleamView, loading: Boolean) {
+    view.loading = loading
+  }
+
+  @ReactProp(name = "speed", defaultFloat = 1000f)
+  override fun setSpeed(view: GleamView, speed: Float) {
+    view.speed = speed
+  }
+
+  @ReactProp(name = "delay", defaultFloat = 0f)
+  override fun setDelay(view: GleamView, delay: Float) {
+    view.delay = delay
+  }
+
+  @ReactProp(name = "transitionDuration", defaultFloat = 300f)
+  override fun setTransitionDuration(view: GleamView, transitionDuration: Float) {
+    view.transitionDuration = transitionDuration
+  }
+
+  @ReactProp(name = "transitionType")
+  override fun setTransitionType(view: GleamView, transitionType: String?) {
+    view.transitionType = when (transitionType) {
+      "shrink" -> GleamView.TransitionType.SHRINK
+      "collapse" -> GleamView.TransitionType.COLLAPSE
+      else -> GleamView.TransitionType.FADE
+    }
+  }
+
+  @ReactProp(name = "intensity", defaultFloat = 1f)
+  override fun setIntensity(view: GleamView, intensity: Float) {
+    view.intensity = intensity
+  }
+
+  @ReactProp(name = "direction")
+  override fun setDirection(view: GleamView, direction: String?) {
+    view.direction = when (direction) {
+      "rtl" -> GleamView.Direction.RTL
+      "ttb" -> GleamView.Direction.TTB
+      else -> GleamView.Direction.LTR
+    }
+  }
+
+  @ReactProp(name = "baseColor", customType = "Color")
+  override fun setBaseColor(view: GleamView, baseColor: Int?) {
+    view.baseColor = baseColor ?: 0xFFE0E0E0.toInt()
+  }
+
+  @ReactProp(name = "highlightColor", customType = "Color")
+  override fun setHighlightColor(view: GleamView, highlightColor: Int?) {
+    view.highlightColor = highlightColor ?: 0xFFF5F5F5.toInt()
+  }
+
+  override fun setBorderRadius(view: GleamView, borderRadius: Float) {
+    view.cornerRadius = borderRadius
+    super.setBorderRadius(view, borderRadius)
+  }
+
+  override fun needsCustomLayoutForChildren(): Boolean = false
+
+  companion object {
+    const val NAME = "GleamView"
+  }
+}

package/ios/GleamView.h

@@ -0,0 +1,14 @@
+#import <React/RCTViewComponentView.h>
+#import <UIKit/UIKit.h>
+
+#ifndef GleamViewNativeComponent_h
+#define GleamViewNativeComponent_h
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface GleamView : RCTViewComponentView
+@end
+
+NS_ASSUME_NONNULL_END
+
+#endif /* GleamViewNativeComponent_h */

package/ios/GleamView.mm

@@ -0,0 +1,430 @@
+#import "GleamView.h"
+
+#import <QuartzCore/QuartzCore.h>
+#import <React/RCTConversions.h>
+
+#import <react/renderer/components/GleamViewSpec/ComponentDescriptors.h>
+#import <react/renderer/components/GleamViewSpec/EventEmitters.h>
+#import <react/renderer/components/GleamViewSpec/Props.h>
+#import <react/renderer/components/GleamViewSpec/RCTComponentViewHelpers.h>
+
+#import "RCTFabricComponentsPlugins.h"
+
+using namespace facebook::react;
+
+typedef NS_ENUM(NSInteger, GleamDirection) {
+    GleamDirectionLTR = 0,
+    GleamDirectionRTL,
+    GleamDirectionTTB,
+};
+
+#pragma mark - Shared Display Link Clock
+
+static NSMutableSet<GleamView *> *_registeredViews;
+static CADisplayLink *_displayLink;
+
+static void _ensureDisplayLink(void) {
+    if (!_registeredViews) {
+        _registeredViews = [NSMutableSet new];
+    }
+}
+
+static void _startDisplayLinkIfNeeded(void) {
+    if (_displayLink) return;
+    _displayLink = [CADisplayLink displayLinkWithTarget:[GleamView class] selector:@selector(_onFrame:)];
+    [_displayLink addToRunLoop:[NSRunLoop mainRunLoop] forMode:NSRunLoopCommonModes];
+}
+
+static void _stopDisplayLinkIfNeeded(void) {
+    if (_registeredViews.count > 0) return;
+    [_displayLink invalidate];
+    _displayLink = nil;
+}
+
+static void _registerView(GleamView *view) {
+    _ensureDisplayLink();
+    [_registeredViews addObject:view];
+    _startDisplayLinkIfNeeded();
+}
+
+static void _unregisterView(GleamView *view) {
+    [_registeredViews removeObject:view];
+    _stopDisplayLinkIfNeeded();
+}
+
+#pragma mark - GleamView
+
+@implementation GleamView {
+    UIView *_contentView;
+    CAGradientLayer *_shimmerLayer;
+    BOOL _loading;
+    BOOL _wasLoading;
+    BOOL _isRegistered;
+    CGFloat _speed;
+    CGFloat _delay;
+    CGFloat _transitionDuration;
+    NSInteger _transitionTypeValue; // 0=fade, 1=slide, 2=dissolve, 3=scale
+    CGFloat _intensity;
+    GleamDirection _direction;
+    UIColor *_baseColor;
+    UIColor *_highlightColor;
+
+    // Transition state
+    BOOL _isTransitioning;
+    CGFloat _transitionElapsed;
+    CGFloat _shimmerOpacity;
+    CGFloat _contentAlpha;
+}
+
++ (ComponentDescriptorProvider)componentDescriptorProvider
+{
+    return concreteComponentDescriptorProvider<GleamViewComponentDescriptor>();
+}
+
++ (void)_onFrame:(CADisplayLink *)link
+{
+    NSArray *views = [_registeredViews allObjects];
+    for (GleamView *view in views) {
+        [view _tick];
+    }
+}
+
+- (instancetype)initWithFrame:(CGRect)frame
+{
+    if (self = [super initWithFrame:frame]) {
+        static const auto defaultProps = std::make_shared<const GleamViewProps>();
+        _props = defaultProps;
+
+        _loading = YES;
+        _wasLoading = YES;
+        _isRegistered = NO;
+        _speed = 1.0;
+        _delay = 0.0;
+        _transitionDuration = 0.3;
+        _transitionTypeValue = 0;
+        _intensity = 1.0;
+        _direction = GleamDirectionLTR;
+        _baseColor = [UIColor colorWithRed:0.878 green:0.878 blue:0.878 alpha:1.0];
+        _highlightColor = [UIColor colorWithRed:0.961 green:0.961 blue:0.961 alpha:1.0];
+
+        _isTransitioning = NO;
+        _shimmerOpacity = 1.0;
+        _contentAlpha = 0.0;
+
+        _contentView = [[UIView alloc] init];
+        _contentView.autoresizingMask = UIViewAutoresizingFlexibleWidth | UIViewAutoresizingFlexibleHeight;
+        _contentView.alpha = 0.0;
+
+        _shimmerLayer = [CAGradientLayer layer];
+        // Disable implicit animations on the gradient layer
+        _shimmerLayer.actions = @{
+            @"startPoint": [NSNull null],
+            @"endPoint": [NSNull null],
+            @"opacity": [NSNull null],
+            @"bounds": [NSNull null],
+            @"position": [NSNull null],
+            @"transform": [NSNull null],
+        };
+
+        self.contentView = _contentView;
+    }
+    return self;
+}
+
+- (void)layoutSubviews
+{
+    [super layoutSubviews];
+    _shimmerLayer.frame = self.bounds;
+    _shimmerLayer.cornerRadius = self.layer.cornerRadius;
+    _shimmerLayer.maskedCorners = self.layer.maskedCorners;
+
+    if (_loading && !_isRegistered) {
+        [self _registerClock];
+    }
+}
+
+- (void)removeFromSuperview
+{
+    [self _unregisterClock];
+    _shimmerLayer.mask = nil;
+    [super removeFromSuperview];
+}
+
+- (void)dealloc
+{
+    [self _unregisterClock];
+}
+
+- (void)_registerClock
+{
+    if (!_isRegistered) {
+        _isRegistered = YES;
+        _registerView(self);
+    }
+}
+
+- (void)_unregisterClock
+{
+    if (_isRegistered) {
+        _isRegistered = NO;
+        _unregisterView(self);
+    }
+}
+
+- (void)updateProps:(Props::Shared const &)props oldProps:(Props::Shared const &)oldProps
+{
+    const auto &oldViewProps = *std::static_pointer_cast<GleamViewProps const>(_props);
+    const auto &newViewProps = *std::static_pointer_cast<GleamViewProps const>(props);
+
+    if (oldViewProps.speed != newViewProps.speed) {
+        _speed = newViewProps.speed / 1000.0;
+    }
+
+    if (oldViewProps.delay != newViewProps.delay) {
+        _delay = newViewProps.delay / 1000.0;
+    }
+
+    if (oldViewProps.transitionDuration != newViewProps.transitionDuration) {
+        _transitionDuration = newViewProps.transitionDuration / 1000.0;
+    }
+
+    if (oldViewProps.transitionType != newViewProps.transitionType) {
+        auto tt = newViewProps.transitionType;
+        if (tt == GleamViewTransitionType::Shrink) _transitionTypeValue = 1;
+        else if (tt == GleamViewTransitionType::Collapse) _transitionTypeValue = 2;
+        else _transitionTypeValue = 0;
+    }
+
+    if (oldViewProps.intensity != newViewProps.intensity) {
+        _intensity = fmin(fmax(newViewProps.intensity, 0.0), 1.0);
+    }
+
+    if (oldViewProps.direction != newViewProps.direction) {
+        auto dir = newViewProps.direction;
+        if (dir == GleamViewDirection::Rtl) {
+            _direction = GleamDirectionRTL;
+        } else if (dir == GleamViewDirection::Ttb) {
+            _direction = GleamDirectionTTB;
+        } else {
+            _direction = GleamDirectionLTR;
+        }
+    }
+
+    if (oldViewProps.baseColor != newViewProps.baseColor) {
+        UIColor *color = RCTUIColorFromSharedColor(newViewProps.baseColor);
+        _baseColor = color ?: [UIColor colorWithRed:0.878 green:0.878 blue:0.878 alpha:1.0];
+    }
+
+    if (oldViewProps.highlightColor != newViewProps.highlightColor) {
+        UIColor *color = RCTUIColorFromSharedColor(newViewProps.highlightColor);
+        _highlightColor = color ?: [UIColor colorWithRed:0.961 green:0.961 blue:0.961 alpha:1.0];
+    }
+
+    if (oldViewProps.loading != newViewProps.loading) {
+        _loading = newViewProps.loading;
+    }
+
+    [self _updateShimmerColors];
+    [self _applyLoadingState];
+
+    [super updateProps:props oldProps:oldProps];
+}
+
+#pragma mark - Private
+
+/**
+ * Compute shimmer progress from global time.
+ * All views with same speed/delay share the same progress value.
+ * Uses cosine easing for smooth looping (matches AccelerateDecelerateInterpolator).
+ */
+- (CGFloat)_computeProgress
+{
+    CFTimeInterval time = CACurrentMediaTime();
+    CGFloat effectiveTime = fmax(time - _delay, 0.0);
+    CGFloat rawProgress = fmod(effectiveTime, _speed) / _speed;
+    // Cosine easing: (1 - cos(rawProgress * PI)) / 2
+    return (1.0 - cos(rawProgress * M_PI)) / 2.0;
+}
+
+- (void)_tick
+{
+    if (_isTransitioning) {
+        _transitionElapsed += _displayLink.duration;
+        CGFloat t = fmin(_transitionElapsed / _transitionDuration, 1.0);
+        // Ease out
+        CGFloat eased = 1.0 - (1.0 - t) * (1.0 - t);
+
+        switch (_transitionTypeValue) {
+            case 1: { // Shrink — scale down with mask clipping
+                _contentAlpha = eased;
+                _contentView.alpha = _contentAlpha;
+                CGFloat shrinkOpacity = 1.0 - fmin(eased * 2.5, 1.0);
+                _shimmerLayer.opacity = shrinkOpacity;
+                CGFloat scale = 1.0 - eased * 0.5;
+                CGRect bounds = self.bounds;
+                CGFloat w = bounds.size.width * scale;
+                CGFloat h = bounds.size.height * scale;
+                CGFloat x = (bounds.size.width - w) / 2.0;
+                CGFloat y = (bounds.size.height - h) / 2.0;
+
+                CAShapeLayer *mask = (CAShapeLayer *)_shimmerLayer.mask;
+                if (!mask) {
+                    mask = [CAShapeLayer layer];
+                    mask.actions = @{@"path": [NSNull null]};
+                    _shimmerLayer.mask = mask;
+                }
+                mask.path = [UIBezierPath bezierPathWithRoundedRect:CGRectMake(x, y, fmax(w, 0.1), fmax(h, 0.1)) cornerRadius:self.layer.cornerRadius * scale].CGPath;
+                break;
+            }
+            case 2: { // Collapse — vertically then horizontally via clip rect
+                _contentAlpha = eased;
+                _contentView.alpha = _contentAlpha;
+                CGFloat collapseOpacity = 1.0 - fmin(eased * 2.5, 1.0);
+                _shimmerLayer.opacity = collapseOpacity;
+                CGRect bounds = self.bounds;
+                CGFloat scaleY = eased < 0.6 ? 1.0 - (eased / 0.6) * 0.98 : 0.02;
+                CGFloat scaleX = eased < 0.6 ? 1.0 : 1.0 - ((eased - 0.6) / 0.4);
+                CGFloat w = bounds.size.width * scaleX;
+                CGFloat h = bounds.size.height * scaleY;
+                CGFloat x = (bounds.size.width - w) / 2.0;
+                CGFloat y = (bounds.size.height - h) / 2.0;
+
+                // Use a mask layer to clip the shimmer to the collapsing rect
+                CAShapeLayer *mask = (CAShapeLayer *)_shimmerLayer.mask;
+                if (!mask) {
+                    mask = [CAShapeLayer layer];
+                    mask.actions = @{@"path": [NSNull null]};
+                    _shimmerLayer.mask = mask;
+                }
+                mask.path = [UIBezierPath bezierPathWithRoundedRect:CGRectMake(x, y, fmax(w, 0.1), fmax(h, 0.1)) cornerRadius:self.layer.cornerRadius].CGPath;
+                break;
+            }
+            default: // Fade
+                _contentAlpha = eased;
+                _contentView.alpha = _contentAlpha;
+                _shimmerOpacity = 1.0 - eased;
+                _shimmerLayer.opacity = _shimmerOpacity;
+                break;
+        }
+
+        [self _updateGradientPosition];
+
+        if (t >= 1.0) {
+            [self _finishTransition];
+        }
+    } else if (_loading) {
+        [self _updateGradientPosition];
+    }
+}
+
+- (void)_updateGradientPosition
+{
+    CGFloat progress = [self _computeProgress];
+
+    CGPoint startPoint, endPoint;
+
+    switch (_direction) {
+        case GleamDirectionRTL: {
+            CGFloat s = 2.0 - progress * 3.0;
+            startPoint = CGPointMake(s, 0.5);
+            endPoint = CGPointMake(s - 1.0, 0.5);
+            break;
+        }
+        case GleamDirectionTTB: {
+            CGFloat s = -1.0 + progress * 3.0;
+            startPoint = CGPointMake(0.5, s);
+            endPoint = CGPointMake(0.5, s + 1.0);
+            break;
+        }
+        case GleamDirectionLTR:
+        default: {
+            CGFloat s = -1.0 + progress * 3.0;
+            startPoint = CGPointMake(s, 0.5);
+            endPoint = CGPointMake(s + 1.0, 0.5);
+            break;
+        }
+    }
+
+    _shimmerLayer.startPoint = startPoint;
+    _shimmerLayer.endPoint = endPoint;
+}
+
+- (void)_updateShimmerColors
+{
+    UIColor *effectiveHighlight = _highlightColor;
+    if (_intensity < 1.0) {
+        CGFloat br, bg, bb, ba;
+        CGFloat hr, hg, hb, ha;
+        [_baseColor getRed:&br green:&bg blue:&bb alpha:&ba];
+        [_highlightColor getRed:&hr green:&hg blue:&hb alpha:&ha];
+        CGFloat r = br + (hr - br) * _intensity;
+        CGFloat g = bg + (hg - bg) * _intensity;
+        CGFloat b = bb + (hb - bb) * _intensity;
+        CGFloat a = ba + (ha - ba) * _intensity;
+        effectiveHighlight = [UIColor colorWithRed:r green:g blue:b alpha:a];
+    }
+
+    _shimmerLayer.colors = @[
+        (id)_baseColor.CGColor,
+        (id)effectiveHighlight.CGColor,
+        (id)_baseColor.CGColor,
+    ];
+    _shimmerLayer.locations = @[@0.0, @0.5, @1.0];
+}
+
+- (void)_applyLoadingState
+{
+    if (_loading) {
+        _isTransitioning = NO;
+        _contentAlpha = 0.0;
+        _shimmerOpacity = 1.0;
+        _contentView.alpha = 0.0;
+        _shimmerLayer.opacity = 1.0;
+        _shimmerLayer.frame = self.bounds;
+        if (_shimmerLayer.superlayer != self.layer) {
+            [self.layer addSublayer:_shimmerLayer];
+        }
+        [self _registerClock];
+        _wasLoading = YES;
+    } else {
+        BOOL shouldAnimate = _wasLoading && _transitionDuration > 0;
+        _wasLoading = NO;
+
+        if (shouldAnimate) {
+            _isTransitioning = YES;
+            _transitionElapsed = 0.0;
+            // Clock stays registered to drive the transition
+        } else {
+            [self _unregisterClock];
+            _contentView.alpha = 1.0;
+            _shimmerLayer.opacity = 0.0;
+            [_shimmerLayer removeFromSuperlayer];
+            [self _emitTransitionEnd:YES];
+        }
+    }
+}
+
+- (void)_finishTransition
+{
+    _isTransitioning = NO;
+    [self _unregisterClock];
+    _contentView.alpha = 1.0;
+    _shimmerLayer.opacity = 0.0;
+    _shimmerLayer.transform = CATransform3DIdentity;
+    _shimmerLayer.mask = nil;
+    _shimmerLayer.frame = self.bounds;
+    [_shimmerLayer removeFromSuperlayer];
+    [self _updateShimmerColors]; // Reset colors after dissolve
+    [self _emitTransitionEnd:YES];
+}
+
+- (void)_emitTransitionEnd:(BOOL)finished
+{
+    if (!_eventEmitter) {
+        return;
+    }
+    auto emitter = std::static_pointer_cast<const GleamViewEventEmitter>(_eventEmitter);
+    emitter->onTransitionEnd(GleamViewEventEmitter::OnTransitionEnd{.finished = finished});
+}
+
+@end

package/lib/module/GleamViewNativeComponent.ts

@@ -0,0 +1,26 @@
+import {
+  codegenNativeComponent,
+  type ColorValue,
+  type ViewProps,
+  type CodegenTypes,
+} from 'react-native';
+
+export interface NativeProps extends ViewProps {
+  loading?: CodegenTypes.WithDefault<boolean, true>;
+  speed?: CodegenTypes.WithDefault<CodegenTypes.Float, 1000>;
+  direction?: CodegenTypes.WithDefault<'ltr' | 'rtl' | 'ttb', 'ltr'>;
+  delay?: CodegenTypes.WithDefault<CodegenTypes.Float, 0>;
+  transitionDuration?: CodegenTypes.WithDefault<CodegenTypes.Float, 300>;
+  transitionType?: CodegenTypes.WithDefault<
+    'fade' | 'shrink' | 'collapse',
+    'fade'
+  >;
+  intensity?: CodegenTypes.WithDefault<CodegenTypes.Float, 1>;
+  baseColor?: ColorValue;
+  highlightColor?: ColorValue;
+  onTransitionEnd?: CodegenTypes.DirectEventHandler<
+    Readonly<{ finished: boolean }>
+  >;
+}
+
+export default codegenNativeComponent<NativeProps>('GleamView');

package/lib/module/index.js

@@ -0,0 +1,16 @@
+"use strict";
+
+export { default as GleamView } from './GleamViewNativeComponent';
+export let GleamDirection = /*#__PURE__*/function (GleamDirection) {
+  GleamDirection["LeftToRight"] = "ltr";
+  GleamDirection["RightToLeft"] = "rtl";
+  GleamDirection["TopToBottom"] = "ttb";
+  return GleamDirection;
+}({});
+export let GleamTransition = /*#__PURE__*/function (GleamTransition) {
+  GleamTransition["Fade"] = "fade";
+  GleamTransition["Shrink"] = "shrink";
+  GleamTransition["Collapse"] = "collapse";
+  return GleamTransition;
+}({});
+//# sourceMappingURL=index.js.map

package/lib/module/index.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["default","GleamView","GleamDirection","GleamTransition"],"sourceRoot":"../../src","sources":["index.tsx"],"mappings":";;AAAA,SAASA,OAAO,IAAIC,SAAS,QAAQ,4BAA4B;AAGjE,WAAYC,cAAc,0BAAdA,cAAc;EAAdA,cAAc;EAAdA,cAAc;EAAdA,cAAc;EAAA,OAAdA,cAAc;AAAA;AAM1B,WAAYC,eAAe,0BAAfA,eAAe;EAAfA,eAAe;EAAfA,eAAe;EAAfA,eAAe;EAAA,OAAfA,eAAe;AAAA","ignoreList":[]}

package/lib/module/package.json

@@ -0,0 +1 @@
+{"type":"module"}

package/lib/typescript/package.json

@@ -0,0 +1 @@
+{"type":"module"}

package/lib/typescript/src/GleamViewNativeComponent.d.ts

@@ -0,0 +1,18 @@
+import { type ColorValue, type ViewProps, type CodegenTypes } from 'react-native';
+export interface NativeProps extends ViewProps {
+    loading?: CodegenTypes.WithDefault<boolean, true>;
+    speed?: CodegenTypes.WithDefault<CodegenTypes.Float, 1000>;
+    direction?: CodegenTypes.WithDefault<'ltr' | 'rtl' | 'ttb', 'ltr'>;
+    delay?: CodegenTypes.WithDefault<CodegenTypes.Float, 0>;
+    transitionDuration?: CodegenTypes.WithDefault<CodegenTypes.Float, 300>;
+    transitionType?: CodegenTypes.WithDefault<'fade' | 'shrink' | 'collapse', 'fade'>;
+    intensity?: CodegenTypes.WithDefault<CodegenTypes.Float, 1>;
+    baseColor?: ColorValue;
+    highlightColor?: ColorValue;
+    onTransitionEnd?: CodegenTypes.DirectEventHandler<Readonly<{
+        finished: boolean;
+    }>>;
+}
+declare const _default: import("react-native/types_generated/Libraries/Utilities/codegenNativeComponent").NativeComponentType<NativeProps>;
+export default _default;
+//# sourceMappingURL=GleamViewNativeComponent.d.ts.map

package/lib/typescript/src/GleamViewNativeComponent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"GleamViewNativeComponent.d.ts","sourceRoot":"","sources":["../../../src/GleamViewNativeComponent.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,UAAU,EACf,KAAK,SAAS,EACd,KAAK,YAAY,EAClB,MAAM,cAAc,CAAC;AAEtB,MAAM,WAAW,WAAY,SAAQ,SAAS;IAC5C,OAAO,CAAC,EAAE,YAAY,CAAC,WAAW,CAAC,OAAO,EAAE,IAAI,CAAC,CAAC;IAClD,KAAK,CAAC,EAAE,YAAY,CAAC,WAAW,CAAC,YAAY,CAAC,KAAK,EAAE,IAAI,CAAC,CAAC;IAC3D,SAAS,CAAC,EAAE,YAAY,CAAC,WAAW,CAAC,KAAK,GAAG,KAAK,GAAG,KAAK,EAAE,KAAK,CAAC,CAAC;IACnE,KAAK,CAAC,EAAE,YAAY,CAAC,WAAW,CAAC,YAAY,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC;IACxD,kBAAkB,CAAC,EAAE,YAAY,CAAC,WAAW,CAAC,YAAY,CAAC,KAAK,EAAE,GAAG,CAAC,CAAC;IACvE,cAAc,CAAC,EAAE,YAAY,CAAC,WAAW,CACvC,MAAM,GAAG,QAAQ,GAAG,UAAU,EAC9B,MAAM,CACP,CAAC;IACF,SAAS,CAAC,EAAE,YAAY,CAAC,WAAW,CAAC,YAAY,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC;IAC5D,SAAS,CAAC,EAAE,UAAU,CAAC;IACvB,cAAc,CAAC,EAAE,UAAU,CAAC;IAC5B,eAAe,CAAC,EAAE,YAAY,CAAC,kBAAkB,CAC/C,QAAQ,CAAC;QAAE,QAAQ,EAAE,OAAO,CAAA;KAAE,CAAC,CAChC,CAAC;CACH;;AAED,wBAAgE"}

package/lib/typescript/src/index.d.ts

@@ -0,0 +1,13 @@
+export { default as GleamView } from './GleamViewNativeComponent';
+export type { NativeProps as GleamViewProps } from './GleamViewNativeComponent';
+export declare enum GleamDirection {
+    LeftToRight = "ltr",
+    RightToLeft = "rtl",
+    TopToBottom = "ttb"
+}
+export declare enum GleamTransition {
+    Fade = "fade",
+    Shrink = "shrink",
+    Collapse = "collapse"
+}
+//# sourceMappingURL=index.d.ts.map

package/lib/typescript/src/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/index.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,IAAI,SAAS,EAAE,MAAM,4BAA4B,CAAC;AAClE,YAAY,EAAE,WAAW,IAAI,cAAc,EAAE,MAAM,4BAA4B,CAAC;AAEhF,oBAAY,cAAc;IACxB,WAAW,QAAQ;IACnB,WAAW,QAAQ;IACnB,WAAW,QAAQ;CACpB;AAED,oBAAY,eAAe;IACzB,IAAI,SAAS;IACb,MAAM,WAAW;IACjB,QAAQ,aAAa;CACtB"}