@onekeyfe/react-native-native-list 3.0.105

package/lib/nitrogen/generated/shared/c++/HybridNativeListSpec.hpp

@@ -0,0 +1,87 @@
+///
+/// HybridNativeListSpec.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#if __has_include(<NitroModules/HybridObject.hpp>)
+#include <NitroModules/HybridObject.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+// Forward declaration of `NativeListScrollAlignment` to properly resolve imports.
+namespace margelo::nitro::nativelist { enum class NativeListScrollAlignment; }
+
+#include <string>
+#include <functional>
+#include <optional>
+#include "NativeListScrollAlignment.hpp"
+
+namespace margelo::nitro::nativelist {
+
+  using namespace margelo::nitro;
+
+  /**
+   * An abstract base class for `NativeList`
+   * Inherit this class to create instances of `HybridNativeListSpec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridNativeList: public HybridNativeListSpec {
+   * public:
+   *   HybridNativeList(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridNativeListSpec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridNativeListSpec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridNativeListSpec() override = default;
+
+    public:
+      // Properties
+      virtual std::string getSnapshotJson() = 0;
+      virtual void setSnapshotJson(const std::string& snapshotJson) = 0;
+      virtual std::optional<std::function<void(const std::string& /* payloadJson */)>> getOnRowAction() = 0;
+      virtual void setOnRowAction(const std::optional<std::function<void(const std::string& /* payloadJson */)>>& onRowAction) = 0;
+      virtual std::optional<std::function<void(const std::string& /* payloadJson */)>> getOnActionAnchorInvalidated() = 0;
+      virtual void setOnActionAnchorInvalidated(const std::optional<std::function<void(const std::string& /* payloadJson */)>>& onActionAnchorInvalidated) = 0;
+      virtual std::optional<std::function<void(const std::string& /* payloadJson */)>> getOnSelectionDelta() = 0;
+      virtual void setOnSelectionDelta(const std::optional<std::function<void(const std::string& /* payloadJson */)>>& onSelectionDelta) = 0;
+      virtual std::optional<std::function<void(const std::string& /* payloadJson */)>> getOnReorder() = 0;
+      virtual void setOnReorder(const std::optional<std::function<void(const std::string& /* payloadJson */)>>& onReorder) = 0;
+      virtual std::optional<std::function<void(const std::string& /* payloadJson */)>> getOnEndReached() = 0;
+      virtual void setOnEndReached(const std::optional<std::function<void(const std::string& /* payloadJson */)>>& onEndReached) = 0;
+      virtual std::optional<std::function<void(const std::string& /* payloadJson */)>> getOnVisibleRangeChanged() = 0;
+      virtual void setOnVisibleRangeChanged(const std::optional<std::function<void(const std::string& /* payloadJson */)>>& onVisibleRangeChanged) = 0;
+
+    public:
+      // Methods
+      virtual void applySnapshot(const std::string& snapshotJson) = 0;
+      virtual void applyPatches(const std::string& patchesJson) = 0;
+      virtual void reconcileSelection(const std::string& selectedKeysJson) = 0;
+      virtual void scrollToKey(const std::string& key, bool animated, NativeListScrollAlignment alignment, double viewPosition, double viewOffset) = 0;
+      virtual void scrollToIndex(double index, bool animated, NativeListScrollAlignment alignment, double viewPosition, double viewOffset) = 0;
+      virtual void scrollToOffset(double offset, bool animated) = 0;
+      virtual void scrollToEnd(bool animated) = 0;
+      virtual void setActionAnchorState(const std::string& stateJson) = 0;
+      virtual void setRefreshing(bool refreshing) = 0;
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "NativeList";
+  };
+
+} // namespace margelo::nitro::nativelist

package/lib/nitrogen/generated/shared/c++/NativeListScrollAlignment.hpp

@@ -0,0 +1,84 @@
+///
+/// NativeListScrollAlignment.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#if __has_include(<NitroModules/NitroHash.hpp>)
+#include <NitroModules/NitroHash.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/JSIConverter.hpp>)
+#include <NitroModules/JSIConverter.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/NitroDefines.hpp>)
+#include <NitroModules/NitroDefines.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+namespace margelo::nitro::nativelist {
+
+  /**
+   * An enum which can be represented as a JavaScript union (NativeListScrollAlignment).
+   */
+  enum class NativeListScrollAlignment {
+    START      SWIFT_NAME(start) = 0,
+    CENTER      SWIFT_NAME(center) = 1,
+    END      SWIFT_NAME(end) = 2,
+    NEAREST      SWIFT_NAME(nearest) = 3,
+  } CLOSED_ENUM;
+
+} // namespace margelo::nitro::nativelist
+
+namespace margelo::nitro {
+
+  // C++ NativeListScrollAlignment <> JS NativeListScrollAlignment (union)
+  template <>
+  struct JSIConverter<margelo::nitro::nativelist::NativeListScrollAlignment> final {
+    static inline margelo::nitro::nativelist::NativeListScrollAlignment fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
+      std::string unionValue = JSIConverter<std::string>::fromJSI(runtime, arg);
+      switch (hashString(unionValue.c_str(), unionValue.size())) {
+        case hashString("start"): return margelo::nitro::nativelist::NativeListScrollAlignment::START;
+        case hashString("center"): return margelo::nitro::nativelist::NativeListScrollAlignment::CENTER;
+        case hashString("end"): return margelo::nitro::nativelist::NativeListScrollAlignment::END;
+        case hashString("nearest"): return margelo::nitro::nativelist::NativeListScrollAlignment::NEAREST;
+        default: [[unlikely]]
+          throw std::invalid_argument("Cannot convert \"" + unionValue + "\" to enum NativeListScrollAlignment - invalid value!");
+      }
+    }
+    static inline jsi::Value toJSI(jsi::Runtime& runtime, margelo::nitro::nativelist::NativeListScrollAlignment arg) {
+      switch (arg) {
+        case margelo::nitro::nativelist::NativeListScrollAlignment::START: return JSIConverter<std::string>::toJSI(runtime, "start");
+        case margelo::nitro::nativelist::NativeListScrollAlignment::CENTER: return JSIConverter<std::string>::toJSI(runtime, "center");
+        case margelo::nitro::nativelist::NativeListScrollAlignment::END: return JSIConverter<std::string>::toJSI(runtime, "end");
+        case margelo::nitro::nativelist::NativeListScrollAlignment::NEAREST: return JSIConverter<std::string>::toJSI(runtime, "nearest");
+        default: [[unlikely]]
+          throw std::invalid_argument("Cannot convert NativeListScrollAlignment to JS - invalid value: "
+                                    + std::to_string(static_cast<int>(arg)) + "!");
+      }
+    }
+    static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) {
+      if (!value.isString()) {
+        return false;
+      }
+      std::string unionValue = JSIConverter<std::string>::fromJSI(runtime, value);
+      switch (hashString(unionValue.c_str(), unionValue.size())) {
+        case hashString("start"):
+        case hashString("center"):
+        case hashString("end"):
+        case hashString("nearest"):
+          return true;
+        default:
+          return false;
+      }
+    }
+  };
+
+} // namespace margelo::nitro

package/lib/nitrogen/generated/shared/c++/views/HybridNativeListComponent.cpp

@@ -0,0 +1,46 @@
+///
+/// HybridNativeListComponent.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "HybridNativeListComponent.hpp"
+
+#include <NitroModules/NitroHash.hpp>
+#include <NitroModules/ReactProp.hpp>
+
+namespace margelo::nitro::nativelist::views {
+
+  using namespace facebook;
+
+  extern const char HybridNativeListComponentName[] = "NativeList";
+
+  HybridNativeListProps::HybridNativeListProps(const react::PropsParserContext& context,
+                                               const HybridNativeListProps& sourceProps,
+                                               const react::RawProps& rawProps):
+    react::ViewProps(context, sourceProps, rawProps, filterObjectKeys),
+    snapshotJson(nitro::ReactProp<std::string>::fromRawValue("NativeList", "snapshotJson", rawProps, sourceProps.snapshotJson)),
+    onRowAction(nitro::ReactProp<std::optional<std::function<void(const std::string& /* payloadJson */)>>>::fromRawValue("NativeList", "onRowAction", rawProps, sourceProps.onRowAction)),
+    onActionAnchorInvalidated(nitro::ReactProp<std::optional<std::function<void(const std::string& /* payloadJson */)>>>::fromRawValue("NativeList", "onActionAnchorInvalidated", rawProps, sourceProps.onActionAnchorInvalidated)),
+    onSelectionDelta(nitro::ReactProp<std::optional<std::function<void(const std::string& /* payloadJson */)>>>::fromRawValue("NativeList", "onSelectionDelta", rawProps, sourceProps.onSelectionDelta)),
+    onReorder(nitro::ReactProp<std::optional<std::function<void(const std::string& /* payloadJson */)>>>::fromRawValue("NativeList", "onReorder", rawProps, sourceProps.onReorder)),
+    onEndReached(nitro::ReactProp<std::optional<std::function<void(const std::string& /* payloadJson */)>>>::fromRawValue("NativeList", "onEndReached", rawProps, sourceProps.onEndReached)),
+    onVisibleRangeChanged(nitro::ReactProp<std::optional<std::function<void(const std::string& /* payloadJson */)>>>::fromRawValue("NativeList", "onVisibleRangeChanged", rawProps, sourceProps.onVisibleRangeChanged)),
+    hybridRef(nitro::ReactProp<std::optional<std::function<void(const std::shared_ptr<HybridNativeListSpec>& /* ref */)>>>::fromRawValue("NativeList", "hybridRef", rawProps, sourceProps.hybridRef)) { }
+
+  bool HybridNativeListProps::filterObjectKeys(const std::string& propName) {
+    switch (hashString(propName)) {
+      case hashString("snapshotJson"): return true;
+      case hashString("onRowAction"): return true;
+      case hashString("onActionAnchorInvalidated"): return true;
+      case hashString("onSelectionDelta"): return true;
+      case hashString("onReorder"): return true;
+      case hashString("onEndReached"): return true;
+      case hashString("onVisibleRangeChanged"): return true;
+      case hashString("hybridRef"): return true;
+      default: return false;
+    }
+  }
+
+} // namespace margelo::nitro::nativelist::views

package/lib/nitrogen/generated/shared/c++/views/HybridNativeListComponent.hpp

@@ -0,0 +1,103 @@
+///
+/// HybridNativeListComponent.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <NitroModules/ReactProp.hpp>
+#include <NitroModules/ViewComponentDescriptor.hpp>
+#include <NitroModules/ViewPropsHolderState.hpp>
+#include <react/renderer/components/view/ConcreteViewShadowNode.h>
+#include <react/renderer/components/view/ViewProps.h>
+#include <react/renderer/core/PropsParserContext.h>
+#include <react/renderer/core/RawProps.h>
+
+#include <string>
+
+#include <string>
+#include <functional>
+#include <optional>
+#include <memory>
+#include "HybridNativeListSpec.hpp"
+
+namespace margelo::nitro::nativelist::views {
+
+  using namespace facebook;
+
+  /**
+   * The name of the actual native View.
+   */
+  extern const char HybridNativeListComponentName[];
+
+  /**
+   * Props for the "NativeList" View.
+   */
+  class HybridNativeListProps final: public react::ViewProps {
+  public:
+    HybridNativeListProps() = default;
+    HybridNativeListProps(const react::PropsParserContext& context,
+                          const HybridNativeListProps& sourceProps,
+                          const react::RawProps& rawProps);
+
+  public:
+    nitro::ReactProp<std::string> snapshotJson;
+    nitro::ReactProp<std::optional<std::function<void(const std::string& /* payloadJson */)>>> onRowAction;
+    nitro::ReactProp<std::optional<std::function<void(const std::string& /* payloadJson */)>>> onActionAnchorInvalidated;
+    nitro::ReactProp<std::optional<std::function<void(const std::string& /* payloadJson */)>>> onSelectionDelta;
+    nitro::ReactProp<std::optional<std::function<void(const std::string& /* payloadJson */)>>> onReorder;
+    nitro::ReactProp<std::optional<std::function<void(const std::string& /* payloadJson */)>>> onEndReached;
+    nitro::ReactProp<std::optional<std::function<void(const std::string& /* payloadJson */)>>> onVisibleRangeChanged;
+    nitro::ReactProp<std::optional<std::function<void(const std::shared_ptr<HybridNativeListSpec>& /* ref */)>>> hybridRef;
+
+    [[nodiscard]]
+    bool hasSameProps(const HybridNativeListProps& other) const noexcept {
+      return snapshotJson.hasSameValue(other.snapshotJson) &&
+             onRowAction.hasSameValue(other.onRowAction) &&
+             onActionAnchorInvalidated.hasSameValue(other.onActionAnchorInvalidated) &&
+             onSelectionDelta.hasSameValue(other.onSelectionDelta) &&
+             onReorder.hasSameValue(other.onReorder) &&
+             onEndReached.hasSameValue(other.onEndReached) &&
+             onVisibleRangeChanged.hasSameValue(other.onVisibleRangeChanged) &&
+             hybridRef.hasSameValue(other.hybridRef);
+    }
+
+    [[nodiscard]]
+    bool hasAnyProvidedProps() const noexcept {
+      return snapshotJson.isProvided() ||
+             onRowAction.isProvided() ||
+             onActionAnchorInvalidated.isProvided() ||
+             onSelectionDelta.isProvided() ||
+             onReorder.isProvided() ||
+             onEndReached.isProvided() ||
+             onVisibleRangeChanged.isProvided() ||
+             hybridRef.isProvided();
+    }
+
+  private:
+    static bool filterObjectKeys(const std::string& propName);
+  };
+
+  /**
+   * State for the "NativeList" View.
+   */
+  using HybridNativeListState = nitro::ViewPropsHolderState<HybridNativeListProps>;
+
+  /**
+   * The Shadow Node for the "NativeList" View.
+   */
+  using HybridNativeListShadowNode = react::ConcreteViewShadowNode<HybridNativeListComponentName /* "HybridNativeList" */,
+                                                                   HybridNativeListProps /* custom props */,
+                                                                   react::ViewEventEmitter /* default */,
+                                                                   HybridNativeListState /* custom state */>;
+
+  /**
+   * The Component Descriptor for the "NativeList" View.
+   */
+  using HybridNativeListComponentDescriptor = nitro::ViewComponentDescriptor<HybridNativeListShadowNode>;
+
+  /* The actual view for "NativeList" needs to be implemented in platform-specific code. */
+
+} // namespace margelo::nitro::nativelist::views

package/lib/nitrogen/generated/shared/json/NativeListConfig.json

@@ -0,0 +1,16 @@
+{
+  "uiViewClassName": "NativeList",
+  "supportsRawText": false,
+  "bubblingEventTypes": {},
+  "directEventTypes": {},
+  "validAttributes": {
+    "snapshotJson": true,
+    "onRowAction": true,
+    "onActionAnchorInvalidated": true,
+    "onSelectionDelta": true,
+    "onReorder": true,
+    "onEndReached": true,
+    "onVisibleRangeChanged": true,
+    "hybridRef": true
+  }
+}

package/lib/typescript/package.json

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

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

@@ -0,0 +1,18 @@
+import React from 'react';
+import type { NativeListProps } from './NativeList.types';
+export type { NativeListProps, NativeListRef } from './NativeList.types';
+export type { ActionAnchorState, ScrollAlignment, ScrollPositionOptions, ScrollToEndParams, ScrollToIndexFailedInfo, ScrollToIndexParams, ScrollToItemParams, ScrollToKeyParams, ScrollToLocationParams, ScrollToOffsetParams, } from './NativeList.types';
+export declare const NativeList: React.ForwardRefExoticComponent<NativeListProps & React.RefAttributes<Readonly<{
+    applySnapshot(snapshot: import("./models").NativeListSnapshot): void;
+    applyPatches(patches: readonly import("./models").RowPatch[]): void;
+    reconcileSelection(selectedKeys: readonly string[]): void;
+    scrollToKey: (paramsOrKey: import("./NativeList.types").ScrollToKeyParams | string, animated?: boolean, alignment?: import("./NativeList.types").ScrollAlignment) => void;
+    scrollToIndex: (paramsOrIndex: import("./NativeList.types").ScrollToIndexParams | number, animated?: boolean, alignment?: import("./NativeList.types").ScrollAlignment) => void;
+    scrollToItem(params: import("./NativeList.types").ScrollToItemParams): void;
+    scrollToOffset(params: import("./NativeList.types").ScrollToOffsetParams): void;
+    scrollToEnd(params?: import("./NativeList.types").ScrollToEndParams): void;
+    scrollToLocation(params: import("./NativeList.types").ScrollToLocationParams): void;
+    setActionAnchorState(state: import("./NativeList.types").ActionAnchorState): void;
+    setRefreshing(refreshing: boolean): void;
+}>>>;
+//# sourceMappingURL=NativeList.d.ts.map

package/lib/typescript/src/NativeList.nitro.d.ts

@@ -0,0 +1,29 @@
+import type { HybridView, HybridViewMethods, HybridViewProps } from 'react-native-nitro-modules';
+/**
+ * Nitro owns only the React Native host boundary. Snapshot diffing, layout,
+ * recycling, selection, and scrolling remain native UICollectionView /
+ * RecyclerView work.
+ */
+export interface NativeListNativeProps extends HybridViewProps {
+    snapshotJson: string;
+    onRowAction?: (payloadJson: string) => void;
+    onActionAnchorInvalidated?: (payloadJson: string) => void;
+    onSelectionDelta?: (payloadJson: string) => void;
+    onReorder?: (payloadJson: string) => void;
+    onEndReached?: (payloadJson: string) => void;
+    onVisibleRangeChanged?: (payloadJson: string) => void;
+}
+export type NativeListScrollAlignment = 'start' | 'center' | 'end' | 'nearest';
+export interface NativeListMethods extends HybridViewMethods {
+    applySnapshot(snapshotJson: string): void;
+    applyPatches(patchesJson: string): void;
+    reconcileSelection(selectedKeysJson: string): void;
+    scrollToKey(key: string, animated: boolean, alignment: NativeListScrollAlignment, viewPosition: number, viewOffset: number): void;
+    scrollToIndex(index: number, animated: boolean, alignment: NativeListScrollAlignment, viewPosition: number, viewOffset: number): void;
+    scrollToOffset(offset: number, animated: boolean): void;
+    scrollToEnd(animated: boolean): void;
+    setActionAnchorState(stateJson: string): void;
+    setRefreshing(refreshing: boolean): void;
+}
+export type NativeList = HybridView<NativeListNativeProps, NativeListMethods>;
+//# sourceMappingURL=NativeList.nitro.d.ts.map

package/lib/typescript/src/NativeList.types.d.ts

@@ -0,0 +1,87 @@
+import type { ViewProps } from 'react-native';
+import type { ActionAnchorInvalidatedEvent, EndReachedEvent, NativeListSnapshot, ReorderEvent, RowActionEvent, RowModel, RowPatch, SelectionDeltaEvent, VisibleRangeChangedEvent } from './models';
+export type ActionAnchorState = Readonly<{
+    token: string;
+    open: boolean;
+    restoreFocus?: boolean;
+}>;
+export type ScrollAlignment = 'start' | 'center' | 'end' | 'nearest';
+export type ScrollPositionOptions = Readonly<{
+    animated?: boolean;
+    alignment?: ScrollAlignment;
+    viewPosition?: number;
+    viewOffset?: number;
+}>;
+export type ScrollToIndexParams = ScrollPositionOptions & Readonly<{
+    index: number;
+}>;
+export type ScrollToKeyParams = ScrollPositionOptions & Readonly<{
+    key: string;
+}>;
+export type ScrollToItemParams = ScrollPositionOptions & Readonly<{
+    item: RowModel;
+}>;
+export type ScrollToOffsetParams = Readonly<{
+    offset: number;
+    animated?: boolean;
+}>;
+export type ScrollToEndParams = Readonly<{
+    animated?: boolean;
+}>;
+export type ScrollToLocationParams = ScrollPositionOptions & Readonly<{
+    sectionIndex: number;
+    itemIndex: number;
+}>;
+export type ScrollToIndexFailedInfo = Readonly<{
+    index: number;
+    itemCount: number;
+    highestMeasuredFrameIndex: number;
+    averageItemLength: number;
+    reason: 'index-out-of-range' | 'section-out-of-range' | 'item-out-of-range' | 'item-not-found';
+}>;
+type InitialScrollProps = Readonly<{
+    initialScrollIndex?: never;
+    initialScrollKey?: never;
+    initialScrollViewPosition?: never;
+    initialScrollViewOffset?: never;
+}> | Readonly<{
+    initialScrollIndex: number;
+    initialScrollKey?: never;
+    initialScrollViewPosition?: number;
+    initialScrollViewOffset?: number;
+}> | Readonly<{
+    initialScrollIndex?: never;
+    initialScrollKey: string;
+    initialScrollViewPosition?: number;
+    initialScrollViewOffset?: number;
+}>;
+type ScrollToIndex = (paramsOrIndex: ScrollToIndexParams | number, animated?: boolean, alignment?: ScrollAlignment) => void;
+type ScrollToKey = (paramsOrKey: ScrollToKeyParams | string, animated?: boolean, alignment?: ScrollAlignment) => void;
+export type NativeListRef = Readonly<{
+    applySnapshot(snapshot: NativeListSnapshot): void;
+    applyPatches(patches: readonly RowPatch[]): void;
+    reconcileSelection(selectedKeys: readonly string[]): void;
+    scrollToKey: ScrollToKey;
+    scrollToIndex: ScrollToIndex;
+    scrollToItem(params: ScrollToItemParams): void;
+    scrollToOffset(params: ScrollToOffsetParams): void;
+    scrollToEnd(params?: ScrollToEndParams): void;
+    scrollToLocation(params: ScrollToLocationParams): void;
+    setActionAnchorState(state: ActionAnchorState): void;
+    setRefreshing(refreshing: boolean): void;
+}>;
+export type NativeListProps = Omit<ViewProps, 'children'> & Readonly<{
+    snapshot: NativeListSnapshot;
+    /** Web only. Defaults to true and is ignored by the native host. */
+    webVirtualizationEnabled?: boolean;
+    onRowAction?: (event: RowActionEvent) => void;
+    onActionAnchorInvalidated?: (event: ActionAnchorInvalidatedEvent) => void;
+    onSelectionDelta?: (event: SelectionDeltaEvent) => void;
+    onReorder?: (event: ReorderEvent) => void;
+    onEndReached?: (event: EndReachedEvent) => void;
+    onVisibleRangeChanged?: (event: VisibleRangeChangedEvent) => void;
+    onRefresh?: () => void;
+    onScrollToIndexFailed?: (info: ScrollToIndexFailedInfo) => void;
+}> & InitialScrollProps;
+export {};
+//# sourceMappingURL=NativeList.types.d.ts.map

package/lib/typescript/src/NativeList.web.d.ts

@@ -0,0 +1,19 @@
+import React from 'react';
+import type { NativeListProps } from './NativeList.types';
+import type { NativeListSnapshot } from './models';
+export type { NativeListProps, NativeListRef } from './NativeList.types';
+export type { ActionAnchorState, ScrollAlignment, ScrollPositionOptions, ScrollToEndParams, ScrollToIndexFailedInfo, ScrollToIndexParams, ScrollToItemParams, ScrollToKeyParams, ScrollToLocationParams, ScrollToOffsetParams, } from './NativeList.types';
+export declare const NativeList: React.ForwardRefExoticComponent<NativeListProps & React.RefAttributes<Readonly<{
+    applySnapshot(snapshot: NativeListSnapshot): void;
+    applyPatches(patches: readonly import("./models").RowPatch[]): void;
+    reconcileSelection(selectedKeys: readonly string[]): void;
+    scrollToKey: (paramsOrKey: import("./NativeList.types").ScrollToKeyParams | string, animated?: boolean, alignment?: import("./NativeList.types").ScrollAlignment) => void;
+    scrollToIndex: (paramsOrIndex: import("./NativeList.types").ScrollToIndexParams | number, animated?: boolean, alignment?: import("./NativeList.types").ScrollAlignment) => void;
+    scrollToItem(params: import("./NativeList.types").ScrollToItemParams): void;
+    scrollToOffset(params: import("./NativeList.types").ScrollToOffsetParams): void;
+    scrollToEnd(params?: import("./NativeList.types").ScrollToEndParams): void;
+    scrollToLocation(params: import("./NativeList.types").ScrollToLocationParams): void;
+    setActionAnchorState(state: import("./NativeList.types").ActionAnchorState): void;
+    setRefreshing(refreshing: boolean): void;
+}>>>;
+//# sourceMappingURL=NativeList.web.d.ts.map

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

@@ -0,0 +1,7 @@
+export { NativeList } from './NativeList';
+export type { ActionAnchorState, NativeListProps, NativeListRef, ScrollAlignment, ScrollPositionOptions, ScrollToEndParams, ScrollToIndexFailedInfo, ScrollToIndexParams, ScrollToItemParams, ScrollToKeyParams, ScrollToLocationParams, ScrollToOffsetParams, } from './NativeList';
+export type * from './models';
+export { applyRowPatches, serializePatches, serializeSnapshot, validatePatches, validateSnapshot, } from './validation';
+export { checkboxStateForKeys, checkboxStateForSection, isSelectableRow, reduceSelection, selectionStateFromSnapshot, } from './selection';
+export type { SelectionAction, SelectionResult, SelectionState, } from './selection';
+//# sourceMappingURL=index.d.ts.map