@dinkarjallan/rezilient-utils

A utility library for building resilient, offline-first applications by providing tools for managing frontend logic and handling complex operations. This package is a core part of the Rezilient.js ecosystem, designed to enable powerful offline and network-resilient functionality.

What is `rezilient-utils`?

@dinkarjallan/rezilient-utils provides a collection of utilities for handling the non-UI aspects of offline-ready applications. It focuses on logic-heavy operations, such as worker thread management, local storage synchronization, retry/queue handling, and network-aware decision-making. It works seamlessly alongside @dinkarjallan/rezilient-ui.

What to Expect from This Package

Decorators to enable worker thread execution for intensive functions.
Local storage and IndexedDB management tools for state persistence.
Retry and queue management functions for API calls and offline actions.
Error handling utilities for offline-related issues.
Tools to estimate and act on network strength.
Offline mode detection and reconciliation utilities.

Features and Examples

1. Worker Thread Decorators (for Functions)

Enable functions to execute in worker threads for better performance and responsiveness.

import { runInWorkerThread } from '@dinkarjallan/rezilient-utils';

@runInWorkerThread
function processData(data) {
  // Perform complex data processing
}

2. Local Storage Management

Manage and synchronize application state with localStorage or IndexedDB.

Redux Middleware: Automatically sync specific Redux slices with local storage.

import { createLocalStorageMiddleware } from '@dinkarjallan/rezilient-utils';

const middleware = createLocalStorageMiddleware(['userSession', 'cart']);

3. Retry/Queue Management

Handle queued API calls and retry operations with prioritization and batching capabilities.

import {
  enqueueAPICall,
  retryFailedCalls,
} from '@dinkarjallan/rezilient-utils';

// Queue an API call
enqueueAPICall('/api/save', { data: payload });

// Retry all failed calls
retryFailedCalls();

4. Error Handling Utilities

Plug offline-related error handlers into your catch blocks for graceful handling.

import { handleOfflineError } from '@dinkarjallan/rezilient-utils';

try {
  await fetchData();
} catch (error) {
  handleOfflineError(error);
}

5. Network Strength Utilities

Estimate network conditions and execute logic based on strength.

import { getNetworkStrength } from '@dinkarjallan/rezilient-utils';

if (getNetworkStrength() === 'weak') {
  alert('Sync postponed due to weak network');
}

6. Offline Mode Detection and State Reconciliation

Detect offline mode and reconcile local data with server-side data.

import {
  enableOfflineMode,
  reconcileData,
} from '@dinkarjallan/rezilient-utils';

// Enable offline mode
enableOfflineMode();

// Reconcile data
reconcileData(localData, serverData);

Why Use `rezilient-utils`?

Logic-Driven Resilience: Enhance the performance and reliability of your application's logic layer.
Effortless State Management: Simplify state persistence and reconciliation with battle-tested tools.
Network-Aware Operations: Adapt your application's behavior dynamically to network conditions.
Seamless Integration: Designed to work alongside @dinkarjallan/rezilient-ui for a full offline-first solution.

Contributing

Contributions, issues, and feature requests are welcome! Feel free to open an issue or submit a pull request.

License

This project is licensed under the MIT License.