@symbiote-native/vue 3.3.0 → 3.5.0

package/build/components/virtualized-list/list-children.d.ts

@@ -0,0 +1,18 @@
+import { type VNode } from '@vue/runtime-core';
+import { type IListMetrics, type ISeparatorProps, type ISeparators } from '@symbiote-native/components';
+import type { ISymbioteEvent } from '@symbiote-native/engine';
+import type { INarrowedProps } from './narrow-props';
+export type IChildrenArgs<ItemT> = {
+    props: INarrowedProps<ItemT>;
+    metrics: IListMetrics;
+    keyFor: (index: number) => string;
+    separatorOverrides: Map<number, Partial<ISeparatorProps<unknown>>>;
+    makeSeparators: (index: number) => ISeparators;
+    makeCellMeasure: (index: number) => (event: ISymbioteEvent) => void;
+    makeCellFocus: (index: number) => () => void;
+};
+export type IListChildren = {
+    children: VNode[];
+    hasHeader: boolean;
+};
+export declare function buildListChildren<ItemT>(args: IChildrenArgs<ItemT>): IListChildren;

package/build/components/virtualized-list/list-children.js

@@ -0,0 +1,81 @@
+// The list's child VNodes: header, the windowed cells with their spacers, footer
+import { h } from '@vue/runtime-core';
+import { FIRST_INDEX, LIST_SEGMENT_KIND, buildSeparatorProps, cellStyleOf, listStyleOf, planFromMetrics, spacerStyleOf, } from '@symbiote-native/components';
+import { renderCellContent, resolveElement } from './list-elements.js';
+// The separator lives INSIDE the cell's measuring wrapper, a sibling would be an extra flex child
+// that lands every cell below a collapsed spacer short by the separator plus the gap
+// It gates on the last index of the DATA, or a cell's measured height would change with the window
+function separatorOf(args, index) {
+    const { props, metrics } = args;
+    if (props.itemSeparatorComponent === undefined)
+        return undefined;
+    if (index >= metrics.count - 1)
+        return undefined;
+    return h(props.itemSeparatorComponent, buildSeparatorProps(props.getItem(props.data, index), props.getItem(props.data, index + 1), args.separatorOverrides.get(index)));
+}
+// A cell the app flagged sticky IS the `sticky-header` tag, which pins by document order and so
+// survives windowing, `stickyHeaderIndices` numbers paint children and does not
+function cellVNode(args, segment, stickySet) {
+    const { props } = args;
+    const content = renderCellContent(props, {
+        item: props.getItem(props.data, segment.index),
+        index: segment.index,
+        separators: args.makeSeparators(segment.index),
+    });
+    const separator = separatorOf(args, segment.index);
+    const isSticky = stickySet?.has(segment.index) === true;
+    const key = `cell-${segment.key}`;
+    const cellProps = {
+        onLayout: args.makeCellMeasure(segment.index),
+        onFocus: args.makeCellFocus(segment.index),
+        style: cellStyleOf(props),
+    };
+    const children = separator === undefined ? [content] : [content, separator];
+    if (props.cellRendererComponent === undefined) {
+        return h(isSticky ? 'sticky-header' : 'view', { key, ...cellProps }, children);
+    }
+    const custom = h(props.cellRendererComponent, {
+        key,
+        ...cellProps,
+        cellKey: segment.key,
+        index: segment.index,
+        item: props.getItem(props.data, segment.index),
+    }, { default: () => children });
+    // RN pins the custom component itself, the sticky wrapper only holds it
+    return isSticky ? h('sticky-header', { key }, [custom]) : custom;
+}
+function windowChildren(args) {
+    const { props, metrics } = args;
+    if (metrics.count === FIRST_INDEX) {
+        const empty = resolveElement(props.listEmptyComponent);
+        return empty === undefined
+            ? []
+            : [
+                h('view', { key: 'list-empty', style: listStyleOf(props, undefined) }, [empty]),
+            ];
+    }
+    const { plan, stickySet } = planFromMetrics(metrics, args.keyFor, props.stickyHeaderIndices);
+    return plan.segments.map(segment => segment.kind === LIST_SEGMENT_KIND.spacer
+        ? h('view', {
+            key: segment.key,
+            style: spacerStyleOf(segment.extent, props.horizontal),
+        })
+        : cellVNode(args, segment, stickySet));
+}
+function slotVNodes(props, slot, slotStyle, key) {
+    return slot === undefined
+        ? []
+        : [h('view', { key, style: listStyleOf(props, slotStyle) }, [slot])];
+}
+export function buildListChildren(args) {
+    const header = resolveElement(args.props.listHeaderComponent);
+    const footer = resolveElement(args.props.listFooterComponent);
+    return {
+        hasHeader: header !== undefined,
+        children: [
+            ...slotVNodes(args.props, header, args.props.listHeaderComponentStyle, 'list-header'),
+            ...windowChildren(args),
+            ...slotVNodes(args.props, footer, args.props.listFooterComponentStyle, 'list-footer'),
+        ],
+    };
+}

package/build/components/virtualized-list/list-elements.d.ts

@@ -0,0 +1,7 @@
+import { type Component, type VNode } from '@vue/runtime-core';
+import type { IListItemInfo, IRenderItem } from './narrow-props';
+export declare function renderCellContent<ItemT>(renderers: {
+    renderItem?: IRenderItem<ItemT>;
+    listItemComponent?: Component;
+}, info: IListItemInfo<ItemT>): VNode | VNode[] | undefined;
+export declare function resolveElement(value: unknown): VNode | undefined;

package/build/components/virtualized-list/list-elements.js

@@ -0,0 +1,29 @@
+// Turning a header, footer or empty slot value into a VNode
+import { h, isVNode } from '@vue/runtime-core';
+import { pickItemRenderer } from '@symbiote-native/components';
+// RN's `_renderElement`: the component wins over the `#item` slot. A list with neither keeps
+// rendering empty cells here (the list logs it), RN would throw
+export function renderCellContent(renderers, info) {
+    const { renderItem, listItemComponent } = renderers;
+    if (listItemComponent === undefined)
+        return renderItem?.(info);
+    pickItemRenderer({
+        hasRenderItem: renderItem !== undefined,
+        hasComponent: true,
+    });
+    return h(listItemComponent, info);
+}
+function isComponent(value) {
+    return (typeof value === 'function' || (typeof value === 'object' && value !== null));
+}
+// A list component element is either a Vue component (invoked via `h`) or a ready VNode, narrowed
+// with `isVNode` first because a VNode is an object too
+export function resolveElement(value) {
+    if (value === undefined || value === null)
+        return undefined;
+    if (isVNode(value))
+        return value;
+    if (isComponent(value))
+        return h(value);
+    return undefined;
+}

package/build/components/virtualized-list/list-scroll-props.d.ts

@@ -0,0 +1,20 @@
+import type { ISymbioteEvent } from '@symbiote-native/engine';
+import type { INarrowedProps } from './narrow-props';
+export type IScrollTagInputs<ItemT> = {
+    props: INarrowedProps<ItemT>;
+    total: number;
+    hasHeader: boolean;
+    onScroll: (event: ISymbioteEvent) => void;
+    onScrollBeginDrag: (event: ISymbioteEvent) => void;
+    onScrollEndDrag: (event: ISymbioteEvent) => void;
+    onMomentumScrollBegin: (event: ISymbioteEvent) => void;
+    onMomentumScrollEnd: (event: ISymbioteEvent) => void;
+    onContentSizeChange: (width: number, height: number) => void;
+    onLayout: (event: ISymbioteEvent) => void;
+    setRef: (el: unknown) => void;
+    commandedOffset: {
+        x: number;
+        y: number;
+    } | undefined;
+};
+export declare function buildScrollProps<ItemT>(inputs: IScrollTagInputs<ItemT>): Record<string, unknown>;

package/build/components/virtualized-list/list-scroll-props.js

@@ -0,0 +1,9 @@
+// The props handed to the scroll tag: the shared list set over the attrs the consumer passed
+import { buildListScrollProps } from '@symbiote-native/components';
+export function buildScrollProps(inputs) {
+    const { props, setRef, ...tagInputs } = inputs;
+    return {
+        ...buildListScrollProps({ ...props, ...tagInputs }, props.forwarded),
+        ref: setRef,
+    };
+}

package/build/components/virtualized-list/narrow-props.d.ts

@@ -0,0 +1,79 @@
+import type { Component, VNode } from '@vue/runtime-core';
+import { type IViewableItemsChangedInfo, type IViewabilityConfig, type IViewabilityConfigCallbackPair, type ISeparators } from '@symbiote-native/components';
+import type { IStyleProp, ISymbioteEvent, IViewStyle } from '@symbiote-native/engine';
+import type { IVirtualizedListEmits, IVirtualizedListProps, IVirtualizedListSlots } from './virtualized-list-props';
+export type IListItemInfo<ItemT> = {
+    item: ItemT;
+    index: number;
+    separators: ISeparators;
+};
+export type IRenderItem<ItemT> = (info: IListItemInfo<ItemT>) => VNode | VNode[] | undefined;
+type IScrollHandler = (event: ISymbioteEvent) => void;
+type IScrollToIndexFailedInfo = {
+    index: number;
+    highestMeasuredFrameIndex: number;
+    averageItemLength: number;
+};
+export type INarrowedProps<ItemT> = {
+    data: unknown;
+    getItem: (data: unknown, index: number) => ItemT;
+    getItemCount: (data: unknown) => number;
+    renderItem?: IRenderItem<ItemT>;
+    listItemComponent?: Component;
+    keyExtractor?: (item: ItemT, index: number) => string;
+    getItemLayout?: (data: unknown, index: number) => {
+        length: number;
+        offset: number;
+        index: number;
+    };
+    itemSeparatorComponent?: Component;
+    cellRendererComponent?: Component;
+    listHeaderComponent?: unknown;
+    listFooterComponent?: unknown;
+    listEmptyComponent?: unknown;
+    horizontal: boolean;
+    inverted: boolean;
+    onEndReached?: (info: {
+        distanceFromEnd: number;
+    }) => void;
+    onEndReachedThreshold?: number;
+    onStartReached?: (info: {
+        distanceFromStart: number;
+    }) => void;
+    onStartReachedThreshold?: number;
+    onRefresh?: () => void;
+    refreshing: boolean;
+    progressViewOffset?: number;
+    onViewableItemsChanged?: (info: IViewableItemsChangedInfo<ItemT>) => void;
+    viewabilityConfig?: IViewabilityConfig;
+    viewabilityConfigCallbackPairs?: IViewabilityConfigCallbackPair<ItemT>[];
+    onScrollToIndexFailed?: (info: IScrollToIndexFailedInfo) => void;
+    initialNumToRender: number;
+    initialScrollIndex?: number;
+    maxToRenderPerBatch: number;
+    updateCellsBatchingPeriod: number;
+    windowSize: number;
+    disableVirtualization: boolean;
+    stickyHeaderIndices?: number[];
+    maintainVisibleContentPosition?: {
+        minIndexForVisible: number;
+        autoscrollToTopThreshold?: number;
+    };
+    userOnScroll?: IScrollHandler;
+    style?: IStyleProp<IViewStyle>;
+    contentContainerStyle?: IStyleProp<IViewStyle>;
+    listHeaderComponentStyle?: IStyleProp<IViewStyle>;
+    listFooterComponentStyle?: IStyleProp<IViewStyle>;
+    keyboardShouldPersistTaps?: boolean | 'always' | 'never' | 'handled';
+    keyboardDismissMode?: 'none' | 'on-drag' | 'interactive';
+    forwarded: Record<string, unknown>;
+};
+export type INarrowSource<ItemT> = {
+    props: IVirtualizedListProps<ItemT>;
+    attrs: Record<string, unknown>;
+    slots: IVirtualizedListSlots<ItemT>;
+    emit: <K extends keyof IVirtualizedListEmits<ItemT>>(event: K, ...args: Parameters<IVirtualizedListEmits<ItemT>[K]>) => void;
+    listens: (onName: string) => boolean;
+};
+export declare function narrowProps<ItemT>(source: INarrowSource<ItemT>): INarrowedProps<ItemT>;
+export {};

package/build/components/virtualized-list/narrow-props.js

@@ -0,0 +1,89 @@
+// The props snapshot the list lifecycle works against: defaults applied, slots resolved, native
+// listeners turned into emit bridges
+import { DEFAULT_INITIAL_NUM_TO_RENDER, DEFAULT_MAX_TO_RENDER_PER_BATCH, DEFAULT_UPDATE_CELLS_BATCHING_PERIOD, DEFAULT_WINDOW_SIZE, } from '@symbiote-native/components';
+import { normalizeVueAttrs } from '../../utils/normalize-attrs.js';
+import { componentFromSlot } from '../../utils/slots-to-render-props.js';
+function isHandler(value) {
+    return typeof value === 'function';
+}
+function asNumber(value, fallback) {
+    return typeof value === 'number' ? value : fallback;
+}
+// The list composes `onScroll` and `onLayout` itself, a consumer-passed one is re-set there
+function forwardAttrs(attrs) {
+    const result = {};
+    for (const key of Object.keys(attrs)) {
+        if (key !== 'onScroll' && key !== 'onLayout')
+            result[key] = attrs[key];
+    }
+    return result;
+}
+// Each bridge exists only when the consumer listens, so a list builds RefreshControl and computes
+// viewability strictly on demand
+function emitBridges(source) {
+    const { emit, listens } = source;
+    return {
+        onEndReached: listens('onEndReached')
+            ? info => emit('endReached', info)
+            : undefined,
+        onStartReached: listens('onStartReached')
+            ? info => emit('startReached', info)
+            : undefined,
+        onRefresh: listens('onRefresh') ? () => emit('refresh') : undefined,
+        onViewableItemsChanged: listens('onViewableItemsChanged')
+            ? info => emit('viewableItemsChanged', info)
+            : undefined,
+        onScrollToIndexFailed: listens('onScrollToIndexFailed')
+            ? info => emit('scrollToIndexFailed', info)
+            : undefined,
+    };
+}
+export function narrowProps(source) {
+    const { props, slots } = source;
+    const folded = normalizeVueAttrs(source.attrs);
+    return {
+        ...emitBridges(source),
+        data: props.data,
+        getItem: props.getItem,
+        getItemCount: props.getItemCount,
+        // `#item` IS the render fn, `#separator` carries scope props so it becomes a component, the
+        // scopeless header, footer and empty slots are handed over bare
+        renderItem: slots.item,
+        listItemComponent: props.listItemComponent,
+        keyExtractor: props.keyExtractor,
+        getItemLayout: props.getItemLayout,
+        itemSeparatorComponent: componentFromSlot(slots.separator),
+        cellRendererComponent: props.cellRendererComponent,
+        listHeaderComponent: slots.header,
+        listFooterComponent: slots.footer,
+        listEmptyComponent: slots.empty,
+        horizontal: props.horizontal === true,
+        inverted: props.inverted === true,
+        onEndReachedThreshold: typeof props.onEndReachedThreshold === 'number'
+            ? props.onEndReachedThreshold
+            : undefined,
+        onStartReachedThreshold: typeof props.onStartReachedThreshold === 'number'
+            ? props.onStartReachedThreshold
+            : undefined,
+        refreshing: props.refreshing === true,
+        progressViewOffset: props.progressViewOffset,
+        viewabilityConfig: props.viewabilityConfig,
+        viewabilityConfigCallbackPairs: props.viewabilityConfigCallbackPairs,
+        initialNumToRender: asNumber(props.initialNumToRender, DEFAULT_INITIAL_NUM_TO_RENDER),
+        initialScrollIndex: props.initialScrollIndex,
+        maxToRenderPerBatch: asNumber(props.maxToRenderPerBatch, DEFAULT_MAX_TO_RENDER_PER_BATCH),
+        updateCellsBatchingPeriod: asNumber(props.updateCellsBatchingPeriod, DEFAULT_UPDATE_CELLS_BATCHING_PERIOD),
+        windowSize: asNumber(props.windowSize, DEFAULT_WINDOW_SIZE),
+        disableVirtualization: props.disableVirtualization === true,
+        stickyHeaderIndices: props.stickyHeaderIndices,
+        maintainVisibleContentPosition: props.maintainVisibleContentPosition,
+        userOnScroll: isHandler(folded.onScroll) ? folded.onScroll : undefined,
+        style: props.style,
+        contentContainerStyle: props.contentContainerStyle,
+        listHeaderComponentStyle: props.listHeaderComponentStyle,
+        listFooterComponentStyle: props.listFooterComponentStyle,
+        keyboardShouldPersistTaps: props.keyboardShouldPersistTaps,
+        keyboardDismissMode: props.keyboardDismissMode,
+        forwarded: forwardAttrs(folded),
+    };
+}

package/build/components/virtualized-list/nested-scope.d.ts

@@ -0,0 +1,3 @@
+import type { IListScope } from '@symbiote-native/components';
+export declare function useVirtualizedListScope(): IListScope | null;
+export declare function provideVirtualizedListScope(scope: IListScope | null): void;

package/build/components/virtualized-list/nested-scope.js

@@ -0,0 +1,12 @@
+// The scope a list hands down to the lists nested in its cells, Vue's way to carry it
+// What it holds and how it behaves is `createListNesting` in the shared components package
+import { inject, provide } from '@vue/runtime-core';
+const SCOPE_KEY = Symbol('virtualizedListScope');
+// Null outside every list, the scope of the nearest list above otherwise
+export function useVirtualizedListScope() {
+    return inject(SCOPE_KEY, null);
+}
+// A portal-like component (Modal) passes null, its content sits outside the list's scroll
+export function provideVirtualizedListScope(scope) {
+    provide(SCOPE_KEY, scope);
+}

package/build/components/virtualized-list/user-handlers.d.ts

@@ -0,0 +1,3 @@
+import type { IUserScrollHandlers } from '@symbiote-native/components';
+import type { INarrowedProps } from './narrow-props';
+export declare function userHandlersOf<ItemT>(props: INarrowedProps<ItemT>): IUserScrollHandlers;

package/build/components/virtualized-list/user-handlers.js

@@ -0,0 +1,24 @@
+// The app's own scroll listeners, read off the narrowed props and the attrs forwarded with them
+function listenerOf(forwarded, name) {
+    const listener = forwarded[name];
+    return typeof listener === 'function'
+        ? (event) => void listener(event)
+        : undefined;
+}
+function sizeListenerOf(forwarded) {
+    const listener = forwarded.onContentSizeChange;
+    return typeof listener === 'function'
+        ? (width, height) => void listener(width, height)
+        : undefined;
+}
+export function userHandlersOf(props) {
+    const { forwarded } = props;
+    return {
+        onContentSizeChange: sizeListenerOf(forwarded),
+        onScroll: props.userOnScroll,
+        onScrollBeginDrag: listenerOf(forwarded, 'onScrollBeginDrag'),
+        onScrollEndDrag: listenerOf(forwarded, 'onScrollEndDrag'),
+        onMomentumScrollBegin: listenerOf(forwarded, 'onMomentumScrollBegin'),
+        onMomentumScrollEnd: listenerOf(forwarded, 'onMomentumScrollEnd'),
+    };
+}

package/build/components/virtualized-list/virtualized-list-props.d.ts

@@ -0,0 +1,82 @@
+import type { Component, VNode } from '@vue/runtime-core';
+import type { IInnerViewRef, IViewabilityConfig, IViewabilityConfigCallbackPair, IViewableItemsChangedInfo, ISeparatorProps, ISeparators } from '@symbiote-native/components';
+import type { IStyleProp, ISymbioteEvent, IViewStyle } from '@symbiote-native/engine';
+export type IVirtualizedListProps<ItemT> = {
+    data: unknown;
+    getItem: (data: unknown, index: number) => ItemT;
+    getItemCount: (data: unknown) => number;
+    keyExtractor?: (item: ItemT, index: number) => string;
+    getItemLayout?: (data: unknown, index: number) => {
+        length: number;
+        offset: number;
+        index: number;
+    };
+    horizontal?: boolean;
+    inverted?: boolean;
+    extraData?: unknown;
+    onEndReachedThreshold?: number;
+    onStartReachedThreshold?: number;
+    refreshing?: boolean | null;
+    progressViewOffset?: number;
+    viewabilityConfig?: IViewabilityConfig;
+    viewabilityConfigCallbackPairs?: IViewabilityConfigCallbackPair<ItemT>[];
+    initialNumToRender?: number;
+    initialScrollIndex?: number;
+    maxToRenderPerBatch?: number;
+    updateCellsBatchingPeriod?: number;
+    windowSize?: number;
+    cellRendererComponent?: Component;
+    listItemComponent?: Component;
+    disableVirtualization?: boolean;
+    stickyHeaderIndices?: number[];
+    maintainVisibleContentPosition?: {
+        minIndexForVisible: number;
+        autoscrollToTopThreshold?: number;
+    };
+    onScroll?: (event: ISymbioteEvent) => void;
+    onScrollBeginDrag?: (event: ISymbioteEvent) => void;
+    onScrollEndDrag?: (event: ISymbioteEvent) => void;
+    onMomentumScrollBegin?: (event: ISymbioteEvent) => void;
+    onMomentumScrollEnd?: (event: ISymbioteEvent) => void;
+    onContentSizeChange?: (width: number, height: number) => void;
+    scrollEventThrottle?: number;
+    keyboardShouldPersistTaps?: boolean | 'always' | 'never' | 'handled';
+    keyboardDismissMode?: 'none' | 'on-drag' | 'interactive';
+    removeClippedSubviews?: boolean;
+    nestedScrollEnabled?: boolean;
+    stickyHeaderHiddenOnScroll?: boolean;
+    innerViewRef?: IInnerViewRef;
+    style?: IStyleProp<IViewStyle>;
+    contentContainerStyle?: IStyleProp<IViewStyle>;
+    listHeaderComponentStyle?: IStyleProp<IViewStyle>;
+    listFooterComponentStyle?: IStyleProp<IViewStyle>;
+    [key: string]: unknown;
+};
+export type IVirtualizedListSlots<ItemT> = {
+    item: (info: {
+        item: ItemT;
+        index: number;
+        separators: ISeparators;
+    }) => VNode[] | VNode;
+    separator?: (props: ISeparatorProps<ItemT>) => VNode[] | VNode;
+    header?: () => VNode[] | VNode;
+    footer?: () => VNode[] | VNode;
+    empty?: () => VNode[] | VNode;
+};
+export type IVirtualizedListEmits<ItemT> = {
+    viewableItemsChanged: (info: IViewableItemsChangedInfo<ItemT>) => void;
+    endReached: (info: {
+        distanceFromEnd: number;
+    }) => void;
+    startReached: (info: {
+        distanceFromStart: number;
+    }) => void;
+    refresh: () => void;
+    scrollToIndexFailed: (info: {
+        index: number;
+        highestMeasuredFrameIndex: number;
+        averageItemLength: number;
+    }) => void;
+};
+export declare const PROP_KEYS: readonly ["data", "getItem", "getItemCount", "keyExtractor", "getItemLayout", "viewabilityConfig", "viewabilityConfigCallbackPairs", "extraData", "horizontal", "inverted", "onEndReachedThreshold", "onStartReachedThreshold", "refreshing", "progressViewOffset", "initialNumToRender", "initialScrollIndex", "maxToRenderPerBatch", "updateCellsBatchingPeriod", "windowSize", "cellRendererComponent", "listItemComponent", "disableVirtualization", "stickyHeaderIndices", "maintainVisibleContentPosition", "style", "contentContainerStyle", "listHeaderComponentStyle", "listFooterComponentStyle", "keyboardShouldPersistTaps", "keyboardDismissMode"];
+export declare const EMIT_KEYS: readonly ["viewableItemsChanged", "endReached", "startReached", "refresh", "scrollToIndexFailed"];

package/build/components/virtualized-list/virtualized-list-props.js

@@ -0,0 +1,41 @@
+// The public prop, slot and emit contract of the Vue VirtualizedList
+// The runtime `props` declaration, the raw scroll events and the emit events are absent on purpose
+export const PROP_KEYS = [
+    'data',
+    'getItem',
+    'getItemCount',
+    'keyExtractor',
+    'getItemLayout',
+    'viewabilityConfig',
+    'viewabilityConfigCallbackPairs',
+    'extraData',
+    'horizontal',
+    'inverted',
+    'onEndReachedThreshold',
+    'onStartReachedThreshold',
+    'refreshing',
+    'progressViewOffset',
+    'initialNumToRender',
+    'initialScrollIndex',
+    'maxToRenderPerBatch',
+    'updateCellsBatchingPeriod',
+    'windowSize',
+    'cellRendererComponent',
+    'listItemComponent',
+    'disableVirtualization',
+    'stickyHeaderIndices',
+    'maintainVisibleContentPosition',
+    'style',
+    'contentContainerStyle',
+    'listHeaderComponentStyle',
+    'listFooterComponentStyle',
+    'keyboardShouldPersistTaps',
+    'keyboardDismissMode',
+];
+export const EMIT_KEYS = [
+    'viewableItemsChanged',
+    'endReached',
+    'startReached',
+    'refresh',
+    'scrollToIndexFailed',
+];

package/build/components/virtualized-section-list/index.d.ts

@@ -1,9 +1,17 @@
 import { type VNode } from '@vue/runtime-core';
-import { type ISection, type ISeparatorProps, type ISeparators, type IVirtualizedSectionListHandle } from '@symbiote-native/components';
+import { type IInnerViewRef, type ISection as ICoreSection, type ISeparatorProps, type ISeparators, type IVirtualizedSectionListHandle } from '@symbiote-native/components';
 import { type IStyleProp, type ISymbioteEvent, type IViewStyle } from '@symbiote-native/engine';
-export type { ISection } from '@symbiote-native/components';
 export type { IVirtualizedSectionListHandle };
-export interface IVirtualizedSectionListProps<ItemT> {
+export type ISection<ItemT> = ICoreSection<ItemT> & {
+    renderItem?: (info: {
+        item: ItemT;
+        index: number;
+        section: ISection<ItemT>;
+        separators: ISeparators;
+    }) => VNode[] | VNode;
+    ItemSeparatorComponent?: (props: ISeparatorProps<ItemT>) => VNode[] | VNode;
+};
+export type IVirtualizedSectionListProps<ItemT> = {
     sections: ReadonlyArray<ISection<ItemT>>;
     keyExtractor?: (item: ItemT, index: number) => string;
     getItemLayout?: (data: ReadonlyArray<ISection<ItemT>> | null, index: number) => {
@@ -22,7 +30,9 @@ export interface IVirtualizedSectionListProps<ItemT> {
     maxToRenderPerBatch?: number;
     updateCellsBatchingPeriod?: number;
     windowSize?: number;
+    disableVirtualization?: boolean;
     inverted?: boolean;
+    horizontal?: boolean;
     maintainVisibleContentPosition?: {
         minIndexForVisible: number;
         autoscrollToTopThreshold?: number;
@@ -32,15 +42,20 @@ export interface IVirtualizedSectionListProps<ItemT> {
     onScrollEndDrag?: (event: ISymbioteEvent) => void;
     onMomentumScrollBegin?: (event: ISymbioteEvent) => void;
     onMomentumScrollEnd?: (event: ISymbioteEvent) => void;
+    onContentSizeChange?: (width: number, height: number) => void;
     scrollEventThrottle?: number;
     keyboardShouldPersistTaps?: boolean | 'always' | 'never' | 'handled';
     keyboardDismissMode?: 'none' | 'on-drag' | 'interactive';
     removeClippedSubviews?: boolean;
     nestedScrollEnabled?: boolean;
+    stickyHeaderHiddenOnScroll?: boolean;
+    innerViewRef?: IInnerViewRef;
     style?: IStyleProp<IViewStyle>;
     contentContainerStyle?: IStyleProp<IViewStyle>;
+    listHeaderComponentStyle?: IStyleProp<IViewStyle>;
+    listFooterComponentStyle?: IStyleProp<IViewStyle>;
     [key: string]: unknown;
-}
+};
 export type IVirtualizedSectionListSlots<ItemT> = {
     item: (info: {
         item: ItemT;
@@ -54,7 +69,7 @@ export type IVirtualizedSectionListSlots<ItemT> = {
     sectionFooter?: (info: {
         section: ISection<ItemT>;
     }) => VNode[] | VNode;
-    sectionSeparator?: () => VNode[] | VNode;
+    sectionSeparator?: (props: ISeparatorProps<ItemT>) => VNode[] | VNode;
     separator?: (props: ISeparatorProps<ItemT>) => VNode[] | VNode;
     header?: () => VNode[] | VNode;
     footer?: () => VNode[] | VNode;