@onekeyfe/react-native-native-list 3.0.105

package/src/scrolling.ts

@@ -0,0 +1,189 @@
+import type {
+  ScrollAlignment,
+  ScrollPositionOptions,
+  ScrollToIndexFailedInfo,
+  ScrollToIndexParams,
+  ScrollToKeyParams,
+  ScrollToLocationParams,
+} from './NativeList.types';
+import type { RowModel } from './models';
+
+export type NormalizedPositionScroll = Readonly<{
+  animated: boolean;
+  alignment: ScrollAlignment;
+  viewPosition: number;
+  viewOffset: number;
+}>;
+
+export type AlignedOffsetInput = Readonly<{
+  itemOffset: number;
+  itemLength: number;
+  viewportLength: number;
+  contentLength: number;
+  currentOffset: number;
+  alignment: ScrollAlignment;
+  viewPosition: number;
+  viewOffset: number;
+}>;
+
+function assertNonNegativeInteger(value: number, name: string): void {
+  if (!Number.isInteger(value) || value < 0) {
+    throw new Error(`NativeList ${name} must be a non-negative integer`);
+  }
+}
+
+function assertFiniteNumber(value: number, name: string): void {
+  if (!Number.isFinite(value)) {
+    throw new Error(`NativeList ${name} must be a finite number`);
+  }
+}
+
+function positionForAlignment(alignment: ScrollAlignment): number {
+  switch (alignment) {
+    case 'center':
+      return 0.5;
+    case 'end':
+      return 1;
+    default:
+      return 0;
+  }
+}
+
+export function normalizePositionScroll(
+  options: ScrollPositionOptions,
+  defaultAlignment: ScrollAlignment
+): NormalizedPositionScroll {
+  const alignment = options.alignment ?? defaultAlignment;
+  if (options.alignment !== undefined && options.viewPosition !== undefined) {
+    throw new Error(
+      'NativeList alignment and viewPosition cannot be used together'
+    );
+  }
+  const viewPosition = options.viewPosition ?? positionForAlignment(alignment);
+  if (!Number.isFinite(viewPosition) || viewPosition < 0 || viewPosition > 1) {
+    throw new Error('NativeList viewPosition must be between 0 and 1');
+  }
+  const viewOffset = options.viewOffset ?? 0;
+  assertFiniteNumber(viewOffset, 'viewOffset');
+  return {
+    animated: options.animated ?? true,
+    alignment:
+      options.viewPosition === undefined ? alignment : ('start' as const),
+    viewPosition,
+    viewOffset,
+  };
+}
+
+export function normalizeIndexScroll(
+  paramsOrIndex: ScrollToIndexParams | number,
+  animated?: boolean,
+  alignment?: ScrollAlignment
+): Readonly<{ index: number; scroll: NormalizedPositionScroll }> {
+  if (typeof paramsOrIndex === 'number') {
+    assertNonNegativeInteger(paramsOrIndex, 'scrollToIndex index');
+    return {
+      index: paramsOrIndex,
+      scroll: normalizePositionScroll({ animated, alignment }, 'nearest'),
+    };
+  }
+  assertNonNegativeInteger(paramsOrIndex.index, 'scrollToIndex index');
+  return {
+    index: paramsOrIndex.index,
+    scroll: normalizePositionScroll(paramsOrIndex, 'start'),
+  };
+}
+
+export function normalizeKeyScroll(
+  paramsOrKey: ScrollToKeyParams | string,
+  animated?: boolean,
+  alignment?: ScrollAlignment
+): Readonly<{ key: string; scroll: NormalizedPositionScroll }> {
+  if (typeof paramsOrKey === 'string') {
+    return {
+      key: paramsOrKey,
+      scroll: normalizePositionScroll({ animated, alignment }, 'nearest'),
+    };
+  }
+  return {
+    key: paramsOrKey.key,
+    scroll: normalizePositionScroll(paramsOrKey, 'start'),
+  };
+}
+
+export function validateOffset(offset: number): void {
+  assertFiniteNumber(offset, 'scroll offset');
+  if (offset < 0) {
+    throw new Error('NativeList scroll offset must be non-negative');
+  }
+}
+
+export function resolveLocationIndex(
+  rows: readonly RowModel[],
+  params: ScrollToLocationParams
+): number | undefined {
+  assertNonNegativeInteger(
+    params.sectionIndex,
+    'scrollToLocation sectionIndex'
+  );
+  assertNonNegativeInteger(params.itemIndex, 'scrollToLocation itemIndex');
+  const headers = rows
+    .map((row, index) => ({ row, index }))
+    .filter(
+      (entry) =>
+        entry.row.type === 'sectionHeader' && entry.row.variant !== 'summary'
+    );
+  const section = headers[params.sectionIndex];
+  if (!section || section.row.type !== 'sectionHeader') return undefined;
+  const end = headers[params.sectionIndex + 1]?.index ?? rows.length;
+  const items = rows
+    .slice(section.index + 1, end)
+    .map((row, offset) => ({ row, index: section.index + 1 + offset }))
+    .filter(
+      (entry) =>
+        entry.row.type !== 'sectionHeader' &&
+        entry.row.sectionKey === section.row.sectionKey
+    );
+  return items[params.itemIndex]?.index;
+}
+
+export function scrollFailure(
+  rows: readonly RowModel[],
+  index: number,
+  reason: ScrollToIndexFailedInfo['reason'],
+  averageItemLength = 0
+): ScrollToIndexFailedInfo {
+  return {
+    index,
+    itemCount: rows.length,
+    highestMeasuredFrameIndex: rows.length - 1,
+    averageItemLength,
+    reason,
+  };
+}
+
+export function calculateAlignedScrollOffset({
+  itemOffset,
+  itemLength,
+  viewportLength,
+  contentLength,
+  currentOffset,
+  alignment,
+  viewPosition,
+  viewOffset,
+}: AlignedOffsetInput): number {
+  let resolvedPosition = viewPosition;
+  if (alignment === 'nearest') {
+    if (itemOffset < currentOffset) resolvedPosition = 0;
+    else if (itemOffset + itemLength > currentOffset + viewportLength)
+      resolvedPosition = 1;
+    else return currentOffset;
+  }
+  const target =
+    itemOffset -
+    resolvedPosition * Math.max(0, viewportLength - itemLength) -
+    viewOffset;
+  return Math.min(
+    Math.max(0, target),
+    Math.max(0, contentLength - viewportLength)
+  );
+}

package/src/selection.ts

@@ -0,0 +1,159 @@
+import type {
+  CheckboxState,
+  NativeListSnapshot,
+  RowModel,
+  SelectionDeltaEvent,
+  SelectionMode,
+} from './models';
+
+export type SelectionState = Readonly<{
+  mode: SelectionMode;
+  selectedKeys: ReadonlySet<string>;
+}>;
+
+export type SelectionAction =
+  | Readonly<{ scope: 'row'; key: string }>
+  | Readonly<{ scope: 'section'; sectionKey: string }>
+  | Readonly<{ scope: 'list' }>
+  | Readonly<{ scope: 'replace'; selectedKeys: readonly string[] }>;
+
+export type SelectionResult = Readonly<{
+  state: SelectionState;
+  delta: SelectionDeltaEvent;
+}>;
+
+export function isSelectableRow(row: RowModel): boolean {
+  return (
+    !row.disabled &&
+    (row.type === 'identity' ||
+      row.type === 'rail' ||
+      row.type === 'activity' ||
+      row.type === 'message' ||
+      row.type === 'dataRow' ||
+      row.type === 'mediaTile' ||
+      row.type === 'metricCard')
+  );
+}
+
+function deltaBetween(
+  before: ReadonlySet<string>,
+  after: ReadonlySet<string>,
+  source: SelectionDeltaEvent['source'],
+  sourceKey?: string
+): SelectionDeltaEvent {
+  return {
+    addedKeys: [...after].filter((key) => !before.has(key)),
+    removedKeys: [...before].filter((key) => !after.has(key)),
+    source,
+    sourceKey,
+  };
+}
+
+function targetKeys(
+  action: SelectionAction,
+  rows: readonly RowModel[]
+): string[] {
+  switch (action.scope) {
+    case 'row':
+      return rows.some((row) => row.key === action.key && isSelectableRow(row))
+        ? [action.key]
+        : [];
+    case 'section':
+      return rows
+        .filter(
+          (row) => row.sectionKey === action.sectionKey && isSelectableRow(row)
+        )
+        .map((row) => row.key);
+    case 'list':
+      return rows.filter(isSelectableRow).map((row) => row.key);
+    case 'replace':
+      return action.selectedKeys.filter((key) =>
+        rows.some((row) => row.key === key && isSelectableRow(row))
+      );
+  }
+}
+
+export function reduceSelection(
+  state: SelectionState,
+  action: SelectionAction,
+  rows: readonly RowModel[]
+): SelectionResult {
+  const before = new Set(state.selectedKeys);
+  if (state.mode === 'none') {
+    return { state, delta: { addedKeys: [], removedKeys: [], source: 'list' } };
+  }
+
+  const targets = targetKeys(action, rows);
+  const source = action.scope === 'replace' ? 'list' : action.scope;
+  const sourceKey =
+    action.scope === 'row'
+      ? action.key
+      : action.scope === 'section'
+      ? action.sectionKey
+      : undefined;
+  if (targets.length === 0 && action.scope !== 'replace') {
+    return {
+      state,
+      delta: deltaBetween(before, before, source, sourceKey),
+    };
+  }
+
+  const after = new Set(before);
+  if (action.scope === 'replace') {
+    after.clear();
+    const replacement = state.mode === 'single' ? targets.slice(0, 1) : targets;
+    replacement.forEach((key) => after.add(key));
+  } else if (state.mode === 'single') {
+    const key = targets[0];
+    after.clear();
+    if (key && !before.has(key)) after.add(key);
+  } else {
+    const allSelected =
+      targets.length > 0 && targets.every((key) => before.has(key));
+    targets.forEach((key) =>
+      allSelected ? after.delete(key) : after.add(key)
+    );
+  }
+
+  const nextState = { mode: state.mode, selectedKeys: after };
+  return {
+    state: nextState,
+    delta: deltaBetween(before, after, source, sourceKey),
+  };
+}
+
+export function checkboxStateForKeys(
+  keys: readonly string[],
+  selectedKeys: ReadonlySet<string>
+): CheckboxState {
+  if (keys.length === 0) return 'unchecked';
+  const selectedCount = keys.reduce(
+    (count, key) => count + (selectedKeys.has(key) ? 1 : 0),
+    0
+  );
+  if (selectedCount === 0) return 'unchecked';
+  if (selectedCount === keys.length) return 'checked';
+  return 'indeterminate';
+}
+
+export function checkboxStateForSection(
+  sectionKey: string,
+  rows: readonly RowModel[],
+  selectedKeys: ReadonlySet<string>
+): CheckboxState {
+  return checkboxStateForKeys(
+    rows
+      .filter((row) => row.sectionKey === sectionKey && isSelectableRow(row))
+      .map((row) => row.key),
+    selectedKeys
+  );
+}
+
+export function selectionStateFromSnapshot(
+  snapshot: NativeListSnapshot
+): SelectionState {
+  return {
+    mode: snapshot.selection?.mode ?? 'none',
+    selectedKeys: new Set(snapshot.selection?.selectedKeys ?? []),
+  };
+}