function createAsyncBatcher<TValue, TSelected>(
   fn, 
   initialOptions, 
selector): SolidAsyncBatcher<TValue, TSelected>

function createAsyncBatcher<TValue, TSelected>(
   fn, 
   initialOptions, 
selector): SolidAsyncBatcher<TValue, TSelected>

Definiert in: async-batcher/createAsyncBatcher.ts:128

Erstellt eine Solid-kompatible AsyncBatcher-Instanz zur Verwaltung asynchroner Batches von Elementen und stellt Solid-Signale für alle zustandsbehafteten Eigenschaften bereit.

Dies ist die asynchrone Version des createBatcher-Hooks. Im Gegensatz zur synchronen Version behandelt dieser asynchrone Batcher

• Verarbeitet Promises und gibt Ergebnisse von Stapelausführungen zurück
• Bietet Fehlerbehandlung mit konfigurierbarem Fehlerverhalten
• Zählt Erfolgs-, Fehler- und Abschlusszählungen separat
• Hat eine Zustandsverfolgung, wenn Stapel ausgeführt werden
• Gibt das Ergebnis der Ausführung der Stapelfunktion zurück

Merkmale

• Konfigurierbare Stapelgröße und Wartezeit
• Benutzerdefinierte Batch-Verarbeitungslogik über getShouldExecute
• Event-Callbacks zur Überwachung von Batch-Operationen
• Fehlerbehandlung für fehlgeschlagene Stapelvorgänge
• Automatische oder manuelle Batch-Verarbeitung
• Alle zustandsbehafteten Eigenschaften (Elemente, Zählungen usw.) werden als Solid-Signale für Reaktivität ausgegeben

Der Batcher sammelt Elemente und verarbeitet sie in Stapeln basierend auf

• Maximaler Batch-Größe (Anzahl der Elemente pro Batch)
• Zeitbasierte Batching (Verarbeitung nach X Millisekunden)
• Benutzerdefinierte Batch-Verarbeitungslogik über getShouldExecute

Fehlerbehandlung

• Wenn ein onError-Handler bereitgestellt wird, wird dieser mit dem Fehler und der Batcher-Instanz aufgerufen
• Wenn throwOnError auf true gesetzt ist (Standardwert, wenn kein onError-Handler bereitgestellt wird), wird der Fehler ausgelöst.
• Wenn throwOnError auf false gesetzt ist (Standardwert, wenn ein onError-Handler bereitgestellt wird), wird der Fehler "verschluckt".
• Sowohl onError als auch throwOnError können zusammen verwendet werden; der Handler wird aufgerufen, bevor ein Fehler ausgelöst wird
• Der Fehlerzustand kann über die zugrunde liegende AsyncBatcher-Instanz überprüft werden

Der Hook verwendet TanStack Store für reaktives Zustandsmanagement. Der Parameter selector ermöglicht es Ihnen anzugeben, welche Zustandsänderungen ein erneutes Rendern auslösen, wodurch die Leistung optimiert wird, indem unnötige erneute Renderings verhindert werden, wenn irrelevante Zustandsänderungen auftreten.

Standardmäßig erfolgen keine reaktiven Zustands-Subscriptions und Sie müssen das Zustands-Tracking durch Bereitstellen einer Selector-Funktion aktivieren. Dies verhindert unnötige Renderings und gibt Ihnen die volle Kontrolle darüber, wann Ihre Komponente aktualisiert wird. Nur wenn Sie einen Selector bereitstellen, wird die Komponente neu gerendert, wenn sich die ausgewählten Zustandswerte ändern.

Verfügbare Zustandseigenschaften

• errorCount: Anzahl fehlgeschlagener Batch-Ausführungen
• executionCount: Gesamtzahl der Versuche zur Batch-Ausführung (erfolgreich + fehlgeschlagen)
• hasError: Gibt an, ob die letzte Batch-Ausführung zu einem Fehler geführt hat
• isExecuting: Gibt an, ob eine Batch-Ausführung gerade läuft
• items: Array von Elementen, die derzeit für das Batching in der Warteschlange stehen
• lastError: Der Fehler von der letzten fehlgeschlagenen Batch-Ausführung (falls vorhanden)
• lastResult: Das Ergebnis der letzten erfolgreichen Batch-Ausführung
• settleCount: Anzahl der abgeschlossenen Batch-Ausführungen (erfolgreich oder fehlgeschlagen)
• successCount: Anzahl der erfolgreichen Batch-Ausführungen

Beispielanwendung

// Default behavior - no reactive state subscriptions
const asyncBatcher = createAsyncBatcher(
  async (items) => {
    const results = await Promise.all(items.map(item => processItem(item)));
    return results;
  },
  {
    maxSize: 10,
    wait: 2000,
    onSuccess: (result) => {
      console.log('Batch processed successfully:', result);
    },
    onError: (error) => {
      console.error('Batch processing failed:', error);
    }
  }
);

// Opt-in to re-render when items or isExecuting changes (optimized for UI updates)
const asyncBatcher = createAsyncBatcher(
  async (items) => {
    const results = await Promise.all(items.map(item => processItem(item)));
    return results;
  },
  { maxSize: 10, wait: 2000 },
  (state) => ({ items: state.items, isExecuting: state.isExecuting })
);

// Opt-in to re-render when error state changes (optimized for error handling)
const asyncBatcher = createAsyncBatcher(
  async (items) => {
    const results = await Promise.all(items.map(item => processItem(item)));
    return results;
  },
  { maxSize: 10, wait: 2000 },
  (state) => ({ hasError: state.hasError, lastError: state.lastError })
);

// Add items to batch
asyncBatcher.addItem(newItem);

// Manually execute batch
const result = await asyncBatcher.execute();

// Access the selected state (will be empty object {} unless selector provided)
const { items, isExecuting } = asyncBatcher.state();

// Default behavior - no reactive state subscriptions
const asyncBatcher = createAsyncBatcher(
  async (items) => {
    const results = await Promise.all(items.map(item => processItem(item)));
    return results;
  },
  {
    maxSize: 10,
    wait: 2000,
    onSuccess: (result) => {
      console.log('Batch processed successfully:', result);
    },
    onError: (error) => {
      console.error('Batch processing failed:', error);
    }
  }
);

// Opt-in to re-render when items or isExecuting changes (optimized for UI updates)
const asyncBatcher = createAsyncBatcher(
  async (items) => {
    const results = await Promise.all(items.map(item => processItem(item)));
    return results;
  },
  { maxSize: 10, wait: 2000 },
  (state) => ({ items: state.items, isExecuting: state.isExecuting })
);

// Opt-in to re-render when error state changes (optimized for error handling)
const asyncBatcher = createAsyncBatcher(
  async (items) => {
    const results = await Promise.all(items.map(item => processItem(item)));
    return results;
  },
  { maxSize: 10, wait: 2000 },
  (state) => ({ hasError: state.hasError, lastError: state.lastError })
);

// Add items to batch
asyncBatcher.addItem(newItem);

// Manually execute batch
const result = await asyncBatcher.execute();

// Access the selected state (will be empty object {} unless selector provided)
const { items, isExecuting } = asyncBatcher.state();

• TValue

• TSelected = {}

(items) => Promise<any>

AsyncBatcherOptions<TValue> = {}

(state) => TSelected

SolidAsyncBatcher<TValue, TSelected>