function createAsyncRateLimiter<TFn, TSelected>(
   fn, 
   initialOptions, 
selector): SolidAsyncRateLimiter<TFn, TSelected>

function createAsyncRateLimiter<TFn, TSelected>(
   fn, 
   initialOptions, 
selector): SolidAsyncRateLimiter<TFn, TSelected>

Definiert in: async-rate-limiter/createAsyncRateLimiter.ts:129

Ein Low-Level-Solid-Hook, der eine AsyncRateLimiter-Instanz erstellt, um zu begrenzen, wie oft eine asynchrone Funktion innerhalb eines Zeitfensters ausgeführt werden kann.

Dieser Hook ist flexibel und zustandsverwaltungsagnostisch konzipiert – er gibt einfach eine Rate-Limiter-Instanz zurück, die Sie mit jeder Zustandsverwaltungslösung (createSignal usw.) integrieren können.

Ratenbegrenzung ist ein einfacher Ansatz, der es einer Funktion ermöglicht, bis zu einem bestimmten Limit innerhalb eines Zeitfensters ausgeführt zu werden, und dann alle nachfolgenden Aufrufe blockiert, bis das Fenster abgelaufen ist. Dies kann zu "bursty" Verhalten führen, bei dem alle Ausführungen sofort erfolgen, gefolgt von einer vollständigen Blockierung.

Der Ratenbegrenzer unterstützt zwei Arten von Fenstern

• 'fixed': Ein striktes Fenster, das nach Ablauf des Zeitfensters zurückgesetzt wird. Alle Ausführungen innerhalb des Fensters zählen für das Limit, und das Fenster wird nach Ablauf der Periode vollständig zurückgesetzt.
• 'sliding': Ein rollierendes Fenster, das Ausführungen ermöglicht, sobald ältere abgelaufen sind. Dies sorgt für eine konsistentere Ausführungsrate im Laufe der Zeit.

Im Gegensatz zum nicht-asynchronen RateLimiter unterstützt diese asynchrone Version das Zurückgeben von Werten aus der ratenbegrenzten Funktion, was sie ideal für API-Aufrufe und andere asynchrone Operationen macht, bei denen Sie das Ergebnis des Aufrufs maybeExecute anstelle der Festlegung des Ergebnisses in einer Zustandsvariablen innerhalb der ratenbegrenzten Funktion wünschen.

Für reibungslosere Ausführungsmuster sollten Sie erwägen:

• Throttling: Sorgt für einen gleichmäßigen Abstand zwischen den Ausführungen (z. B. maximal einmal alle 200 ms)
• Debouncing: Wartet auf eine Pause bei den Aufrufen, bevor er ausgeführt wird (z. B. nach 500 ms ohne Aufrufe)

Ratenbegrenzung eignet sich am besten für harte API-Limits oder Ressourcenbeschränkungen. Für UI-Updates oder das Glätten häufiger Ereignisse bieten Throttling oder Debouncing normalerweise eine bessere Benutzererfahrung.

Fehlerbehandlung

• Wenn ein onError-Handler bereitgestellt wird, wird dieser mit dem Fehler und der Ratenbegrenzerinstanz 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 mit der zugrunde liegenden AsyncRateLimiter-Instanz überprüft werden
• Ratenlimit-Zurückweisungen (wenn das Limit überschritten wird) werden getrennt von Ausführungsfehlern über den onReject-Handler behandelt

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

• currentWindowStart: Zeitstempel, wann das aktuelle Fenster begann
• executionCount: Anzahl der abgeschlossenen Funktionsaufrufe
• hasError: Ob die letzte Ausführung zu einem Fehler geführt hat
• isExecuting: Ob die Ausführung einer asynchronen Funktion gerade läuft
• lastError: Der Fehler der letzten fehlgeschlagenen Ausführung (falls vorhanden)
• lastResult: Das Ergebnis der letzten erfolgreichen Ausführung
• nextWindowTime: Zeitstempel, wann das nächste Fenster beginnt
• rejectionCount: Anzahl der Funktionsaufrufe, die aufgrund von Ratenbegrenzung abgelehnt wurden
• remainingInWindow: Anzahl der verbleibenden Ausführungen im aktuellen Fenster

• TFn extends AnyAsyncFunction

• TSelected = {}

TFn

AsyncRateLimiterOptions<TFn>

(state) => TSelected

SolidAsyncRateLimiter<TFn, TSelected>

// Default behavior - no reactive state subscriptions
const { maybeExecute } = createAsyncRateLimiter(
  async (id: string) => {
    const data = await api.fetchData(id);
    return data; // Return value is preserved
  },
  { limit: 5, window: 1000 } // 5 calls per second
);

// Opt-in to re-render when rate limit and execution state changes (optimized for UI feedback)
const rateLimiter = createAsyncRateLimiter(
  async (query) => {
    const result = await searchAPI(query);
    return result;
  },
  { limit: 10, window: 60000 },
  (state) => ({
    remainingInWindow: state.remainingInWindow,
    isExecuting: state.isExecuting,
    rejectionCount: state.rejectionCount
  })
);

// Opt-in to re-render when error state changes (optimized for error handling)
const rateLimiter = createAsyncRateLimiter(
  async (query) => {
    const result = await searchAPI(query);
    return result;
  },
  {
    limit: 10,
    window: 60000, // 10 calls per minute
    onReject: (info) => console.log(`Rate limit exceeded: ${info.nextValidTime - Date.now()}ms until next window`)
  },
  (state) => ({ hasError: state.hasError, lastError: state.lastError })
);

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

// Default behavior - no reactive state subscriptions
const { maybeExecute } = createAsyncRateLimiter(
  async (id: string) => {
    const data = await api.fetchData(id);
    return data; // Return value is preserved
  },
  { limit: 5, window: 1000 } // 5 calls per second
);

// Opt-in to re-render when rate limit and execution state changes (optimized for UI feedback)
const rateLimiter = createAsyncRateLimiter(
  async (query) => {
    const result = await searchAPI(query);
    return result;
  },
  { limit: 10, window: 60000 },
  (state) => ({
    remainingInWindow: state.remainingInWindow,
    isExecuting: state.isExecuting,
    rejectionCount: state.rejectionCount
  })
);

// Opt-in to re-render when error state changes (optimized for error handling)
const rateLimiter = createAsyncRateLimiter(
  async (query) => {
    const result = await searchAPI(query);
    return result;
  },
  {
    limit: 10,
    window: 60000, // 10 calls per minute
    onReject: (info) => console.log(`Rate limit exceeded: ${info.nextValidTime - Date.now()}ms until next window`)
  },
  (state) => ({ hasError: state.hasError, lastError: state.lastError })
);

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