@onekeyfe/react-native-native-list 3.0.105

package/lib/module/scrolling.js

@@ -0,0 +1,121 @@
+"use strict";
+
+function assertNonNegativeInteger(value, name) {
+  if (!Number.isInteger(value) || value < 0) {
+    throw new Error(`NativeList ${name} must be a non-negative integer`);
+  }
+}
+function assertFiniteNumber(value, name) {
+  if (!Number.isFinite(value)) {
+    throw new Error(`NativeList ${name} must be a finite number`);
+  }
+}
+function positionForAlignment(alignment) {
+  switch (alignment) {
+    case 'center':
+      return 0.5;
+    case 'end':
+      return 1;
+    default:
+      return 0;
+  }
+}
+export function normalizePositionScroll(options, defaultAlignment) {
+  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',
+    viewPosition,
+    viewOffset
+  };
+}
+export function normalizeIndexScroll(paramsOrIndex, animated, alignment) {
+  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, animated, alignment) {
+  if (typeof paramsOrKey === 'string') {
+    return {
+      key: paramsOrKey,
+      scroll: normalizePositionScroll({
+        animated,
+        alignment
+      }, 'nearest')
+    };
+  }
+  return {
+    key: paramsOrKey.key,
+    scroll: normalizePositionScroll(paramsOrKey, 'start')
+  };
+}
+export function validateOffset(offset) {
+  assertFiniteNumber(offset, 'scroll offset');
+  if (offset < 0) {
+    throw new Error('NativeList scroll offset must be non-negative');
+  }
+}
+export function resolveLocationIndex(rows, params) {
+  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, index, reason, averageItemLength = 0) {
+  return {
+    index,
+    itemCount: rows.length,
+    highestMeasuredFrameIndex: rows.length - 1,
+    averageItemLength,
+    reason
+  };
+}
+export function calculateAlignedScrollOffset({
+  itemOffset,
+  itemLength,
+  viewportLength,
+  contentLength,
+  currentOffset,
+  alignment,
+  viewPosition,
+  viewOffset
+}) {
+  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));
+}
+//# sourceMappingURL=scrolling.js.map

package/lib/module/selection.js

@@ -0,0 +1,85 @@
+"use strict";
+
+export function isSelectableRow(row) {
+  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, after, source, sourceKey) {
+  return {
+    addedKeys: [...after].filter(key => !before.has(key)),
+    removedKeys: [...before].filter(key => !after.has(key)),
+    source,
+    sourceKey
+  };
+}
+function targetKeys(action, rows) {
+  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, action, rows) {
+  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, selectedKeys) {
+  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, rows, selectedKeys) {
+  return checkboxStateForKeys(rows.filter(row => row.sectionKey === sectionKey && isSelectableRow(row)).map(row => row.key), selectedKeys);
+}
+export function selectionStateFromSnapshot(snapshot) {
+  return {
+    mode: snapshot.selection?.mode ?? 'none',
+    selectedKeys: new Set(snapshot.selection?.selectedKeys ?? [])
+  };
+}
+//# sourceMappingURL=selection.js.map