@onekeyfe/react-native-native-list 3.0.105 → 3.0.106

package/src/avatarPrefetch.ts

@@ -0,0 +1,236 @@
+// OneKey patch: share a bounded URI-only window across renderers. No bitmap or
+// account-specific data enters list snapshots or the UI runtime.
+import type { ImageSource, LeadingVisual, RowModel, RowPatch } from './models';
+
+export type AvatarCandidate = Readonly<{
+  source: ImageSource;
+  priority: 0 | 1 | 2;
+}>;
+const PREFIX = 'onekey-avatar://blockie/v1/';
+const MAX_CANDIDATES = 64;
+const IMAGE_PATCH_FIELDS = [
+  'leading',
+  'secondaryLeading',
+  'image',
+  'networkImage',
+  'thumbnail',
+  'visual',
+] as const;
+
+export function avatarPrefetchWindow(
+  rows: readonly RowModel[],
+  first: number,
+  last: number,
+  direction: number,
+  resolveRow?: (row: RowModel) => RowModel
+): AvatarCandidate[] {
+  if (first < 0 || last < first || first >= rows.length) return [];
+  last = Math.min(last, rows.length - 1);
+  const result: AvatarCandidate[] = [];
+  const seen = new Set<string>();
+  let limit = MAX_CANDIDATES;
+  const add = (source: ImageSource | undefined, priority: 0 | 1 | 2) => {
+    if (
+      !source?.uri.startsWith(PREFIX) ||
+      source.cachePolicy === 'none' ||
+      seen.has(source.uri) ||
+      result.length >= limit
+    )
+      return;
+    seen.add(source.uri);
+    result.push({ source, priority });
+  };
+  const visual = (value: LeadingVisual | undefined, priority: 0 | 1 | 2) => {
+    if (!value) return;
+    if ('image' in value) add(value.image, priority);
+    if ('networkImage' in value) add(value.networkImage, priority);
+    if ('images' in value)
+      value.images.forEach((image) => add(image, priority));
+    if ('overlays' in value)
+      value.overlays?.forEach((overlay) => add(overlay.image, priority));
+  };
+  const row = (value: RowModel, priority: 0 | 1 | 2) => {
+    value = resolveRow?.(value) ?? value;
+    if ('leading' in value) visual(value.leading, priority);
+    if ('secondaryLeading' in value) visual(value.secondaryLeading, priority);
+    if ('image' in value) add(value.image, priority);
+    if ('networkImage' in value) add(value.networkImage, priority);
+    if ('thumbnail' in value) add(value.thumbnail, priority);
+    if (value.type === 'walletGroup') {
+      visual(value.parent.leading, priority);
+      for (const child of value.children.slice(0, MAX_CANDIDATES)) {
+        if (result.length >= limit) break;
+        visual(child.leading, priority);
+      }
+    }
+  };
+  // Bound row examination too: a giant non-avatar group must not scan all data.
+  for (let index = first; index <= last && index < first + 64; index += 1)
+    row(rows[index], 0);
+  const span = Math.min(24, (last - first + 1) * 2);
+  const step = direction < 0 ? -1 : 1;
+  const aheadStart = step > 0 ? last + 1 : first - 1;
+  const aheadLimit = Math.min(MAX_CANDIDATES, result.length + 24);
+  limit = aheadLimit;
+  for (
+    let distance = 0;
+    distance < span && result.length < aheadLimit;
+    distance += 1
+  ) {
+    const index = aheadStart + distance * step;
+    if (index < 0 || index >= rows.length) break;
+    row(rows[index], 1);
+  }
+  const behindStart = step > 0 ? first - 1 : last + 1;
+  const behindLimit = Math.min(MAX_CANDIDATES, result.length + 8);
+  limit = behindLimit;
+  for (
+    let distance = 0;
+    distance < Math.min(8, span) && result.length < behindLimit;
+    distance += 1
+  ) {
+    const index = behindStart - distance * step;
+    if (index < 0 || index >= rows.length) break;
+    row(rows[index], 2);
+  }
+  return result;
+}
+
+// OneKey patch: imperative image patches update a sparse prefetch overlay, not
+// the readonly prop or a full cloned snapshot. The key index is rebuilt only for
+// a complete snapshot; ordinary balance patches retain no extra row copies.
+export class NativeAvatarPrefetchModel {
+  private rows: readonly RowModel[];
+  private rowByKey: Map<string, RowModel>;
+  private readonly imageRows = new Map<string, RowModel>();
+
+  constructor(rows: readonly RowModel[]) {
+    this.rows = rows;
+    this.rowByKey = new Map(rows.map((row) => [row.key, row]));
+  }
+
+  replaceSnapshot(rows: readonly RowModel[]) {
+    this.rows = rows;
+    this.rowByKey = new Map(rows.map((row) => [row.key, row]));
+    this.imageRows.clear();
+  }
+
+  applyPatches(patches: readonly RowPatch[], dispatch?: () => void): boolean {
+    // Native methods have no acknowledgement. Mirror only dispatched batches;
+    // a missing host or a synchronous serialization/dispatch failure changes nothing.
+    if (!dispatch) return false;
+    dispatch();
+    const seen = new Set<string>();
+    for (const patch of patches) {
+      const row = this.rowByKey.get(patch.key);
+      // Both native renderers reject the whole batch for an unknown key/type.
+      if (!row || row.type !== patch.type || seen.has(patch.key)) return false;
+      seen.add(patch.key);
+    }
+    let changed = false;
+    for (const patch of patches) {
+      const changes: Readonly<Record<string, unknown>> = patch.changes;
+      let imageChanges: Record<string, unknown> | undefined;
+      for (const key of IMAGE_PATCH_FIELDS) {
+        if (changes[key] !== undefined) {
+          imageChanges ??= {};
+          imageChanges[key] = changes[key];
+        }
+      }
+      // JSON.stringify omits undefined top-level fields. Native therefore keeps
+      // them unchanged; an explicit replacement visual without image clears it.
+      if (!imageChanges) continue;
+      const row =
+        this.imageRows.get(patch.key) ?? this.rowByKey.get(patch.key)!;
+      // Preserve the validated row discriminant, matching applyRowPatches' shallow merge.
+      this.imageRows.set(patch.key, {
+        ...row,
+        ...imageChanges,
+        key: row.key,
+        type: row.type,
+      } as RowModel);
+      changed = true;
+    }
+    return changed;
+  }
+
+  window(first: number, last: number, direction: number): AvatarCandidate[] {
+    return avatarPrefetchWindow(
+      this.rows,
+      first,
+      last,
+      direction,
+      (row) => this.imageRows.get(row.key) ?? row
+    );
+  }
+}
+
+// Native preload has no cancellation token. One in-flight source is the bound;
+// direction changes replace all not-yet-started work rather than appending it.
+export class NativeAvatarPrefetchQueue {
+  private pending: ImageSource[] = [];
+  private activeUri: string | undefined;
+  private timer: ReturnType<typeof setTimeout> | undefined;
+  private disposed = false;
+  private readonly recent = new Map<string, number>();
+
+  constructor(
+    private readonly preload: (source: ImageSource) => Promise<boolean>
+  ) {}
+
+  update(candidates: readonly AvatarCandidate[]) {
+    if (this.disposed) return;
+    const now = Date.now();
+    this.pending = candidates
+      .filter(
+        ({ source, priority }) =>
+          priority !== 0 &&
+          source.uri !== this.activeUri &&
+          now - (this.recent.get(source.uri) ?? 0) > 30_000
+      )
+      .map(({ source }) => source);
+    this.schedule();
+  }
+
+  dispose() {
+    this.disposed = true;
+    this.pending = [];
+    this.recent.clear();
+    if (this.timer !== undefined) clearTimeout(this.timer);
+    this.timer = undefined;
+  }
+
+  private schedule() {
+    if (
+      this.disposed ||
+      this.activeUri ||
+      this.timer !== undefined ||
+      !this.pending.length
+    )
+      return;
+    // Yield between short batches without imposing a frame-per-image throughput cap.
+    this.timer = setTimeout(() => {
+      this.timer = undefined;
+      const source = this.pending.shift();
+      if (!source || this.disposed) return;
+      this.activeUri = source.uri;
+      Promise.resolve()
+        .then(() => this.preload(source))
+        .then((success) => {
+          if (success && !this.disposed) {
+            this.recent.delete(source.uri);
+            this.recent.set(source.uri, Date.now());
+            if (this.recent.size > 128)
+              this.recent.delete(this.recent.keys().next().value as string);
+          }
+        })
+        .catch(() => {
+          /* Visible loading retains its own failure/retry behavior. */
+        })
+        .finally(() => {
+          this.activeUri = undefined;
+          this.schedule();
+        });
+    }, 0);
+  }
+}

package/src/models.ts

@@ -22,6 +22,9 @@ export type ImageSource = Readonly<{
   optimizeTos?: boolean;
   overscan?: number;
   loadingStrategy?: ImageLoadingStrategy;
+  // OneKey patch: fallbackUri is Web-only; retryTimes opts all platforms into terminal retries.
+  fallbackUri?: string;
+  retryTimes?: number;
 }>;
 
 export type BadgeModel = Readonly<{
@@ -30,7 +33,34 @@ export type BadgeModel = Readonly<{
   tone?: 'neutral' | 'info' | 'success' | 'warning' | 'danger';
 }>;
 
+// OneKey patch: keep selector decoration and text data serializable.
+export type SelectorTextSegment = Readonly<{
+  text: string;
+  textSegments?: readonly ValueTextSegment[];
+  tone?: TextTone | 'disabled' | 'caution';
+  separatorBefore?: boolean;
+}>;
+export type VisualOverlay = Readonly<{
+  position: 'topLeft' | 'bottomRight';
+  size?: number;
+  width?: number;
+  height?: number;
+  padding?: number;
+  offset?: number;
+  offsetX?: number;
+  offsetY?: number;
+  image?: ImageSource;
+  name?: string;
+  text?: string;
+  tintColor?: string;
+  backgroundColor?: string;
+}>;
+
 type VisualWithImage = Readonly<{
+  fallbackIcon?: Readonly<{ name: string; tintColor?: string }>;
+  overlays?: readonly VisualOverlay[];
+  borderStyle?: 'dashed';
+  borderColor?: string;
   image?: ImageSource;
   fallbackText?: string;
   backgroundColor?: string;
@@ -70,8 +100,16 @@ export type SelectionTarget =
   | Readonly<{ scope: 'section'; sectionKey: string }>
   | Readonly<{ scope: 'list' }>;
 
+// OneKey patch: preserve compact very-small-balance digit runs.
+export type ValueTextSegment = Readonly<{ text: string; style?: 'subscript' }>;
+
 export type TrailingAccessory =
-  | Readonly<{ kind: 'value'; text: string; secondary?: boolean }>
+  | Readonly<{
+      kind: 'value';
+      text: string;
+      secondary?: boolean;
+      textSegments?: readonly ValueTextSegment[];
+    }>
   | Readonly<{
       kind: 'valuePair';
       primary: string;
@@ -108,6 +146,9 @@ export type TrailingAccessory =
       tintColor?: string;
       disabled?: boolean;
       actionKey?: string;
+      testID?: string;
+      hoverActionKey?: string;
+      accessibilityLabel?: string;
     }>
   | Readonly<{ kind: 'spinner' }>
   | Readonly<{ kind: 'progress'; value: number }>;
@@ -120,6 +161,15 @@ export type FooterAction = Readonly<{
 }>;
 
 export type RowBase = Readonly<{
+  // OneKey patch: preserve measured selector geometry without changing defaults.
+  height?: number;
+  // OneKey patch: retain the source Android list's measured fractional-DP rounding.
+  heightRounding?: 'floor' | 'nearest';
+  testID?: string;
+  opacity?: number;
+  backgroundColor?: string;
+  backgroundFullWidth?: boolean;
+  pressDisabled?: boolean;
   key: string;
   revision?: number;
   sectionKey?: string;
@@ -136,6 +186,11 @@ export type RowBase = Readonly<{
 export type IdentityRow = RowBase &
   Readonly<{
     type: 'identity';
+    // OneKey patch: UTF-16 ranges match Fuse indices and native attributed strings.
+    titleMatch?: readonly Readonly<{ start: number; end: number }>[];
+    titleActionKey?: string;
+    titleActionOnHover?: boolean;
+    subtitleSegments?: readonly SelectorTextSegment[];
     presentation?: 'walletSidebar' | 'accountSelector' | 'networkSelector';
     leading: LeadingVisual;
     leadingAction?: Extract<TrailingAccessory, { kind: 'icon' }>;
@@ -257,6 +312,12 @@ export type MetricCardRow = RowBase &
 export type SectionHeaderRow = RowBase &
   Readonly<{
     type: 'sectionHeader';
+    // OneKey patch: title help stays independent of section selection.
+    sticky?: boolean;
+    valueActionTestID?: string;
+    valueSegments?: readonly ValueTextSegment[];
+    titleActionKey?: string;
+    titleActionOnHover?: boolean;
     sectionKey: string;
     presentation?: 'networkSelector';
     indexTitle?: string;
@@ -291,6 +352,13 @@ export type SystemRow = RowBase &
         message: string;
         actionKey: string;
       }>
+    | Readonly<{
+        type: 'system';
+        variant: 'warning';
+        title: string;
+        message: string;
+        borderColor?: string;
+      }>
     | Readonly<{ type: 'system'; variant: 'noMatch'; message: string }>
     | Readonly<{ type: 'system'; variant: 'end'; message?: string }>
     | Readonly<{ type: 'system'; variant: 'spacer'; height: number }>
@@ -310,6 +378,11 @@ export type RowModel =
   | SystemRow;
 
 export type NativeListTheme = Readonly<{
+  // OneKey patch: explicit selector controls use the original semantic theme tokens.
+  checkboxBackground?: string;
+  checkboxBorder?: string;
+  checkboxIcon?: string;
+  cautionBackground?: string;
   background: string;
   rowBackground: string;
   rowSelectedBackground: string;
@@ -329,6 +402,8 @@ export type NativeListTheme = Readonly<{
   inverseBackground?: string;
   inverseText?: string;
   info?: string;
+  // OneKey patch: match the existing account warning address tone.
+  caution?: string;
 }>;
 
 export type SectionIndexConfig = Readonly<{
@@ -369,7 +444,20 @@ export type NativeListSnapshot = Readonly<{
   theme?: NativeListTheme;
 }>;
 
-type CommonPatchFields = 'revision' | 'disabled' | 'selected' | 'separator';
+// OneKey patch: include selector-only mutable presentation fields.
+// type CommonPatchFields = 'revision' | 'disabled' | 'selected' | 'separator';
+// OneKey patch: balance patches also refresh the existing row's spoken content.
+// type CommonPatchFields = 'revision' | 'disabled' | 'selected' | 'separator' | 'height' | 'heightRounding' | 'opacity' | 'pressDisabled';
+type CommonPatchFields =
+  | 'revision'
+  | 'disabled'
+  | 'selected'
+  | 'separator'
+  | 'height'
+  | 'heightRounding'
+  | 'opacity'
+  | 'pressDisabled'
+  | 'accessibilityLabel';
 
 export type RowPatch =
   | Readonly<{
@@ -387,6 +475,10 @@ export type RowPatch =
           | 'trailing'
           | 'leading'
           | 'leadingAction'
+          | 'titleMatch'
+          | 'titleActionKey'
+          | 'titleActionOnHover'
+          | 'subtitleSegments'
         >
       >;
     }>
@@ -501,6 +593,8 @@ export type RowPatch =
           | 'subtitle'
           | 'value'
           | 'valueActionKey'
+          | 'titleActionKey'
+          | 'titleActionOnHover'
           | 'titleIcon'
           | 'valueIcon'
           | 'checkbox'
@@ -565,11 +659,8 @@ export type RowActionEvent = Readonly<{
 }>;
 
 export type ActionAnchorInvalidationReason =
-  | 'scroll'
-  | 'rebind'
-  | 'snapshot'
-  | 'layout'
-  | 'destroy';
+  // OneKey patch: close web title tooltips when their native list target is left.
+  'pointerLeave' | 'scroll' | 'rebind' | 'snapshot' | 'layout' | 'destroy';
 
 export type ActionAnchorInvalidatedEvent = Readonly<{
   token: string;

package/src/validation.ts

@@ -214,6 +214,69 @@ function assertLeadingVisual(
     assertImage(visual.image, `${path}.image`);
     assertVisualShape(visual.shape, `${path}.shape`);
     assertText(visual.cornerIcon?.name, `${path}.cornerIcon.name`);
+    // OneKey patch: validate optional selector overlays at the JSON boundary.
+    assertText(visual.fallbackIcon?.name, `${path}.fallbackIcon.name`);
+    if ((visual.overlays?.length ?? 0) > 2)
+      fail(`${path}.overlays`, 'supports at most two overlays');
+    visual.overlays?.forEach((overlay, index) => {
+      if (!['topLeft', 'bottomRight'].includes(overlay.position))
+        fail(
+          `${path}.overlays[${index}].position`,
+          'must be topLeft or bottomRight'
+        );
+      if (
+        overlay.size !== undefined &&
+        (overlay.size <= 0 || overlay.size > 40)
+      )
+        fail(`${path}.overlays[${index}].size`, 'must be within 1...40');
+      if (
+        overlay.padding !== undefined &&
+        (!Number.isFinite(overlay.padding) ||
+          overlay.padding < 0 ||
+          overlay.padding * 2 >= (overlay.size ?? 20))
+      )
+        fail(
+          `${path}.overlays[${index}].padding`,
+          'must fit inside the overlay'
+        );
+      if (
+        overlay.offset !== undefined &&
+        (!Number.isFinite(overlay.offset) ||
+          overlay.offset < 0 ||
+          overlay.offset > 20)
+      )
+        fail(`${path}.overlays[${index}].offset`, 'must be within 0...20');
+      for (const field of ['width', 'height'] as const) {
+        const value = overlay[field];
+        if (
+          value !== undefined &&
+          (!Number.isFinite(value) || value <= 0 || value > 40)
+        )
+          fail(`${path}.overlays[${index}].${field}`, 'must be within 1...40');
+      }
+      for (const field of ['offsetX', 'offsetY'] as const) {
+        const value = overlay[field];
+        if (
+          value !== undefined &&
+          (!Number.isFinite(value) || value < 0 || value > 20)
+        )
+          fail(`${path}.overlays[${index}].${field}`, 'must be within 0...20');
+      }
+      if (
+        overlay.padding !== undefined &&
+        overlay.padding * 2 >=
+          Math.min(
+            overlay.width ?? overlay.size ?? 20,
+            overlay.height ?? overlay.size ?? 20
+          )
+      )
+        fail(
+          `${path}.overlays[${index}].padding`,
+          'must fit inside the overlay'
+        );
+      assertImage(overlay.image, `${path}.overlays[${index}].image`);
+      assertText(overlay.text, `${path}.overlays[${index}].text`);
+    });
     if (visual.kind === 'token') {
       assertImage(visual.networkImage, `${path}.networkImage`);
     }
@@ -288,6 +351,20 @@ function assertRow(
   path = `rows[${index}]`
 ): void {
   assertKey(row.key, `${path}.key`);
+  // OneKey patch: explicit dimensions and opacity cannot corrupt list layout.
+  if (row.height !== undefined && (row.height < 0 || row.height > 4096))
+    fail(`${path}.height`, 'must be within 0...4096');
+  if (
+    row.heightRounding !== undefined &&
+    (row.height === undefined ||
+      !['floor', 'nearest'].includes(row.heightRounding))
+  )
+    fail(
+      `${path}.heightRounding`,
+      'requires an explicit height and must be floor or nearest'
+    );
+  if (row.opacity !== undefined && (row.opacity < 0 || row.opacity > 1))
+    fail(`${path}.opacity`, 'must be within 0...1');
   if (row.groupId && !row.groupPosition) {
     fail(`${path}.groupPosition`, 'is required when groupId is present');
   }
@@ -314,6 +391,43 @@ function assertRow(
       }
       assertText(row.title, `${path}.title`);
       assertText(row.subtitle, `${path}.subtitle`);
+      // OneKey patch: selector text segments truncate independently.
+      row.subtitleSegments?.forEach((segment, segmentIndex) => {
+        assertText(
+          segment.text,
+          `${path}.subtitleSegments[${segmentIndex}].text`
+        );
+        if (
+          segment.tone !== undefined &&
+          ![
+            'primary',
+            'secondary',
+            'disabled',
+            'caution',
+            'positive',
+            'negative',
+          ].includes(segment.tone)
+        )
+          fail(
+            `${path}.subtitleSegments[${segmentIndex}].tone`,
+            'invalid selector text tone'
+          );
+      });
+      let previousMatchEnd = 0;
+      row.titleMatch?.forEach((match) => {
+        if (
+          !Number.isInteger(match.start) ||
+          !Number.isInteger(match.end) ||
+          match.start < previousMatchEnd ||
+          match.end <= match.start ||
+          match.end > row.title.length
+        )
+          fail(
+            `${path}.titleMatch`,
+            'must contain ordered, non-overlapping UTF-16 ranges inside title'
+          );
+        previousMatchEnd = match.end;
+      });
       assertText(row.tertiary, `${path}.tertiary`);
       if (
         row.tertiaryTone !== undefined &&
@@ -470,13 +584,17 @@ function assertRow(
       break;
     case 'system':
       if (
-        !['loading', 'retry', 'noMatch', 'end', 'spacer'].includes(row.variant)
+        // OneKey patch: deprecated-wallet warnings retain the original scrolling semantics.
+        !['loading', 'retry', 'noMatch', 'end', 'spacer', 'warning'].includes(
+          row.variant
+        )
       ) {
         fail(
           `${path}.variant`,
-          'must be loading, retry, noMatch, end, or spacer'
+          'must be loading, retry, noMatch, end, spacer, or warning'
         );
       }
+      if (row.variant === 'warning') assertText(row.title, `${path}.title`);
       if (row.variant !== 'spacer') {
         assertText(row.message, `${path}.message`);
       }
@@ -649,6 +767,17 @@ export function validateSnapshot(
 
 function assertPatchChanges(patch: RowPatch, index: number): void {
   const path = `patches[${index}].changes`;
+  // OneKey patch: partial balance updates retain a valid, current accessibility label.
+  if ('accessibilityLabel' in patch.changes) {
+    assertText(patch.changes.accessibilityLabel, `${path}.accessibilityLabel`);
+  }
+  // OneKey patch: partial updates may refer to an existing height but still require a valid policy.
+  if (
+    'heightRounding' in patch.changes &&
+    patch.changes.heightRounding !== undefined &&
+    !['floor', 'nearest'].includes(patch.changes.heightRounding)
+  )
+    fail(`${path}.heightRounding`, 'must be floor or nearest');
   if (
     patch.changes.revision !== undefined &&
     (!Number.isSafeInteger(patch.changes.revision) ||