@asaidimu/utils-persistence 1.0.0 → 2.0.0

package/README.md

@@ -1,4 +1,6 @@
-# `@asaidimu/utils-persistence` - Robust Data Persistence for Web Applications
+# `@asaidimu/utils-persistence`
+
+**Robust Data Persistence for Web Applications**
 
 [![npm version](https://img.shields.io/npm/v/@asaidimu/utils-persistence.svg?style=flat-square)](https://www.npmjs.com/package/@asaidimu/utils-persistence)
 [![License](https://img.shields.io/badge/License-MIT-blue.svg?style=flat-square)](LICENSE)
@@ -12,6 +14,9 @@
 *   [Installation & Setup](#installation--setup)
 *   [Usage Documentation](#usage-documentation)
     *   [Core Interface: `SimplePersistence`](#core-interface-simplepersistence)
+    *   [The Power of Adapters](#the-power-of-adapters)
+    *   [Usage Guidelines](#usage-guidelines-for-those-consuming-the-simplepersistence-interface)
+    *   [When to Use and When to Avoid `SimplePersistence`](#when-to-use-and-when-to-avoid-simplepersistence)
     *   [Web Storage Persistence (`WebStoragePersistence`)](#web-storage-persistence-webstoragepersistence)
     *   [IndexedDB Persistence (`IndexedDBPersistence`)](#indexeddb-persistence-indexeddbpersistence)
     *   [Ephemeral Persistence (`EphemeralPersistence`)](#ephemeral-persistence-ephemeralpersistence)
@@ -35,7 +40,7 @@ This library is ideal for single-page applications (SPAs) that require robust st
     *   `WebStoragePersistence`: Supports both `localStorage` (default) and `sessionStorage` for simple key-value storage. Ideal for user preferences or small, temporary data.
     *   `IndexedDBPersistence`: Provides robust, high-capacity, and structured data storage for more complex needs like offline caching or large datasets. Leverages `@asaidimu/indexed` for simplified IndexedDB interactions.
     *   `EphemeralPersistence`: Offers an in-memory store with cross-tab synchronization using a Last Write Wins (LWW) strategy. Ideal for transient, session-specific shared state that does not need to persist across page reloads.
-*   **Automatic Cross-Instance Synchronization**: Real-time updates across multiple browser tabs, windows, or even components within the same tab. This is achieved by leveraging native `StorageEvent` (for `localStorage`) and `BroadcastChannel`-based event buses (for `WebStoragePersistence`, `IndexedDBPersistence`, and `EphemeralPersistence`).
+*   **Automatic Cross-Instance Synchronization**: Real-time updates across multiple browser tabs, windows, or even components within the same tab. This is achieved by leveraging native `StorageEvent` (for `localStorage`) and `BroadcastChannel`-based event buses (from `@asaidimu/events`) for `WebStoragePersistence`, `IndexedDBPersistence`, and `EphemeralPersistence`.
 *   **Type-Safe**: Fully written in TypeScript, providing strong typing, compile-time checks, and autocompletion for a better developer experience.
 *   **Lightweight & Minimal Dependencies**: Designed to be small and efficient, relying on a few focused internal utilities (`@asaidimu/events`, `@asaidimu/indexed`, `@asaidimu/query`).
 *   **Robust Error Handling**: Includes internal error handling for common storage operations, providing clearer debugging messages when issues arise.
@@ -51,7 +56,7 @@ This library is ideal for single-page applications (SPAs) that require robust st
 To use `@asaidimu/utils-persistence`, you need:
 
 *   Node.js (LTS version recommended)
-*   npm or Yarn package manager
+*   npm, Yarn, or Bun package manager
 *   A modern web browser environment (e.g., Chrome, Firefox, Safari, Edge) that supports `localStorage`, `sessionStorage`, `IndexedDB`, and `BroadcastChannel`.
 
 ### Installation Steps
@@ -59,13 +64,29 @@ To use `@asaidimu/utils-persistence`, you need:
 Install the package using your preferred package manager:
 
 ```bash
-# Using Yarn
+# Using Bun
 bun add @asaidimu/utils-persistence
+
+# Using Yarn
+yarn add @asaidimu/utils-persistence
+
+# Using npm
+npm install @asaidimu/utils-persistence
+```
+
+If you plan to use `uuid` for generating `instanceId`s as recommended in the examples, install it separately:
+
+```bash
+bun add uuid
+# or
+yarn add uuid
+# or
+npm install uuid
 ```
 
 ### Configuration
 
-This library does not require global configuration. All settings are passed directly to the constructor of the respective persistence adapter during instantiation.
+This library does not require global configuration. All settings are passed directly to the constructor of the respective persistence adapter during instantiation. For instance, `IndexedDBPersistence` requires a configuration object for its database and collection details.
 
 ### Verification
 
@@ -97,16 +118,6 @@ The library exposes a common interface `SimplePersistence<T>` that all adapters
 
 Every persistence adapter in this library implements the `SimplePersistence<T>` interface, where `T` is the type of data you want to persist. This interface is designed to be flexible, supporting both synchronous and asynchronous operations, and is especially geared towards handling multi-instance scenarios (e.g., multiple browser tabs or independent components sharing the same data).
 
-#### The Power of Adapters
-The adapter pattern used by `SimplePersistence<T>` is a key strength, enabling seamless swapping of persistence backends without altering application logic. This decoupling offers several advantages:
-- **Interchangeability**: Switch between storage mechanisms (e.g., `localStorage`, `IndexedDB`, an in-memory store, or a remote API) by simply changing the adapter, keeping the interface consistent.
-- **Scalability**: Start with a lightweight adapter (e.g., `EphemeralPersistence` for prototyping) and transition to a robust solution (e.g., `IndexedDBPersistence` or a server-based database) as needs evolve, with minimal changes to the consuming code.
-- **Extensibility**: Easily create custom adapters for new storage technologies or environments (e.g., file systems, serverless functions) while adhering to the same interface.
-- **Environment-Agnostic**: Use the same interface in browser, server, or hybrid applications, supporting diverse use cases like offline-first apps or cross-tab synchronization.
-- **Testing Simplicity**: Implement mock adapters for testing, isolating persistence logic without touching real storage.
-
-This flexibility ensures that the persistence layer can adapt to varying requirements, from small-scale prototypes to production-grade systems, while maintaining a consistent and predictable API.
-
 ```typescript
 export interface SimplePersistence<T> {
   /**
@@ -147,7 +158,17 @@ export interface SimplePersistence<T> {
 }
 ```
 
-### Usage and Implementation Guidelines
+### The Power of Adapters
+The adapter pattern used by `SimplePersistence<T>` is a key strength, enabling seamless swapping of persistence backends without altering application logic. This decoupling offers several advantages:
+- **Interchangeability**: Switch between storage mechanisms (e.g., `localStorage`, `IndexedDB`, an in-memory store, or a remote API) by simply changing the adapter, keeping the interface consistent.
+- **Scalability**: Start with a lightweight adapter (e.g., `EphemeralPersistence` for prototyping) and transition to a robust solution (e.g., `IndexedDBPersistence` or a server-based database) as needs evolve, with minimal changes to the consuming code.
+- **Extensibility**: Easily create custom adapters for new storage technologies or environments (e.g., file systems, serverless functions) while adhering to the same interface.
+- **Environment-Agnostic**: Use the same interface in browser, server, or hybrid applications, supporting diverse use cases like offline-first apps or cross-tab synchronization.
+- **Testing Simplicity**: Implement mock adapters for testing, isolating persistence logic without touching real storage.
+
+This flexibility ensures that the persistence layer can adapt to varying requirements, from small-scale prototypes to production-grade systems, while maintaining a consistent and predictable API.
+
+### Usage Guidelines (For those consuming the `SimplePersistence` interface)
 
 This section provides practical advice for consuming the `SimplePersistence<T>` interface.
 
@@ -172,7 +193,7 @@ It enables robust **multi-instance synchronization**. When multiple instances (e
 
 *   **Generate Once:** Create a unique UUID for your consumer instance at its very beginning (e.g., when your main application component mounts or your service initializes).
     ```typescript
-    import { v4 as uuidv4 } from 'uuid'; // Requires 'uuid' library to be installed: `npm install uuid`
+    import { v4 as uuidv4 } from 'uuid'; // Requires 'uuid' library to be installed: `bun add uuid`
 
     interface MyAppState {
       data: string;
@@ -279,7 +300,7 @@ It enables robust **multi-instance synchronization**. When multiple instances (e
     const settingsStore = new WebStoragePersistence<Settings>('app-settings');
 
     async function retrieveGlobalState() {
-      const storedState = await settingsStore.get(); // Await for async adapters
+      const storedState = await settingsStore.get(); // Await for async adapters if it returns a Promise
       if (storedState) {
         console.log("Retrieved global app settings:", storedState);
         // Integrate storedState into your application's current state
@@ -313,9 +334,9 @@ It enables robust **multi-instance synchronization**. When multiple instances (e
 
     // To simulate a change from another instance, open a new browser tab
     // and run something like:
-    // const anotherInstance = uuidv4();
+    // const anotherInstanceId = uuidv4();
     // const anotherNotificationStore = new WebStoragePersistence<NotificationState>('app-notifications');
-    // anotherNotificationStore.set(anotherInstance, { count: 5, lastMessage: 'New notification!' });
+    // anotherNotificationStore.set(anotherInstanceId, { count: 5, lastMessage: 'New notification!' });
 
     // When no longer needed:
     // unsubscribe();
@@ -333,7 +354,7 @@ It enables robust **multi-instance synchronization**. When multiple instances (e
 
     async function resetUserData() {
       console.log("Attempting to clear all persisted user data...");
-      const success = await userDataStore.clear(); // Await for async adapters
+      const success = await userDataStore.clear(); // Await for async adapters if it returns a Promise
       if (success) {
         console.log("All persisted user data cleared successfully.");
       } else {
@@ -651,51 +672,35 @@ async function manageSessionState() {
 
 The `@asaidimu/utils-persistence` library is structured to be modular and extensible, adhering strictly to the `SimplePersistence` interface as its core contract. This design promotes interchangeability and ease of maintenance.
 
-### Directory Structure
-
-```
-src/persistence/
-├── index.ts              # Export entry point for all persistence modules (SimplePersistence, WebStoragePersistence, IndexedDBPersistence, EphemeralPersistence)
-├── types.ts              # Defines the SimplePersistence interface and shared types (e.g., StorageEvents)
-├── local-storage.ts      # Implements SimplePersistence using Web Storage (localStorage/sessionStorage)
-├── ephemeral.ts          # Implements SimplePersistence using an in-memory store with LWW cross-tab sync
-├── indexedb.ts           # Implements SimplePersistence using IndexedDB
-├── fixtures.ts           # Generic test suite helper for SimplePersistence implementations
-├── local-storage.test.ts # Test suite for WebStoragePersistence (assumed from local-storage.ts existence)
-├── ephemeral.test.ts     # Test suite for EphemeralPersistence
-└── indexedb.test.ts      # Comprehensive test suite for the IndexedDBPersistence adapter
-└── README.md             # This documentation file
-```
-
 ### Core Components
 
 *   **`SimplePersistence<T>` (in `types.ts`)**: This is the fundamental TypeScript interface that defines the contract for any persistence adapter. It ensures a consistent API for `set`, `get`, `subscribe`, and `clear` operations, regardless of the underlying storage mechanism.
-*   **`WebStoragePersistence<T>` (in `local-storage.ts`)**:
+*   **`WebStoragePersistence<T>` (in `webstorage.ts`)**:
     *   **Purpose**: Provides simple key-value persistence leveraging the browser's `localStorage` or `sessionStorage` APIs.
     *   **Mechanism**: Directly interacts with `window.localStorage` or `window.sessionStorage`. Data is serialized/deserialized using `JSON.stringify` and `JSON.parse`.
-    *   **Synchronization**: Utilizes `window.addEventListener('storage', ...)` for `localStorage` (which triggers when changes occur in *other* tabs) and the `@asaidimu/events` event bus (which uses `BroadcastChannel` internally) to ensure real-time updates across multiple browser tabs for both `localStorage` and `sessionStorage`.
+    *   **Synchronization**: Utilizes `window.addEventListener('storage', ...)` for `localStorage` (which triggers when changes occur in *other* tabs on the same origin) and the `@asaidimu/events` event bus (which uses `BroadcastChannel` internally) to ensure real-time updates across multiple browser tabs for both `localStorage` and `sessionStorage`.
 *   **`EphemeralPersistence<T>` (in `ephemeral.ts`)**:
     *   **Purpose**: Offers an in-memory store for transient data that needs cross-tab synchronization but *not* persistence across page reloads.
-    *   **Mechanism**: Stores data in a private class property.
+    *   **Mechanism**: Stores data in a private class property. Data is cloned using `structuredClone` to prevent direct mutation issues.
     *   **Synchronization**: Leverages the `@asaidimu/events` event bus (via `BroadcastChannel`) for cross-instance synchronization. It implements a Last Write Wins (LWW) strategy based on timestamps included in the broadcast events, ensuring all tabs converge to the most recently written state.
 *   **`IndexedDBPersistence<T>` (in `indexedb.ts`)**:
     *   **Purpose**: Provides robust, asynchronous persistence using the browser's `IndexedDB` API, suitable for larger datasets and structured data.
-    *   **Mechanism**: Builds upon `@asaidimu/indexed` for simplified IndexedDB interactions (handling databases, object stores, and transactions) and `@asaidimu/query` for declarative data querying.
-    *   **Shared Resources**: Employs a `SharedResources` singleton pattern to manage and cache database connections and collections efficiently across multiple instances of `IndexedDBPersistence`. This avoids redundant connections and ensures a single source of truth for IndexedDB operations within the application. It also manages a shared event bus per `database`/`store` combination.
+    *   **Mechanism**: Builds upon `@asaidimu/indexed` for simplified IndexedDB interactions (handling databases, object stores, and transactions) and `@asaidimu/query` for declarative data querying. Data is stored in a specific `collection` (object store) within a `database`, identified by a `store` key.
+    *   **Shared Resources**: Employs a `SharedResources` singleton pattern to manage and cache `Database` connections, `Collection` instances, and `EventBus` instances efficiently across multiple `IndexedDBPersistence` instances. This avoids redundant connections, ensures a single source of truth for IndexedDB operations, and manages global event listeners effectively.
     *   **Synchronization**: Leverages the `@asaidimu/events` event bus (via `BroadcastChannel`) for cross-instance synchronization of IndexedDB changes, notifying other instances about updates.
 *   **`@asaidimu/events`**: An internal utility package that provides a powerful, cross-tab compatible event bus using `BroadcastChannel`. It's crucial for enabling the automatic synchronization features of all persistence adapters.
-*   **`@asaidimu/indexed` & `@asaidimu/query`**: These are internal utility packages specifically used by `IndexedDBPersistence` to abstract and simplify complex interactions with the native IndexedDB API, offering a more declarative and promise-based interface.
+*   **`@asaidimu/indexed` & `@asaidimu/query`**: These are internal utility packages specifically used by `IndexedDBPersistence` to abstract and simplify complex interactions with the native IndexedDB API, offering a more declarative and promise-based interface. `@asaidimu/indexed` handles database schema, versions, and CRUD operations, while `@asaidimu/query` provides a query builder for data retrieval.
 
 ### Data Flow for State Changes
 
 1.  **Setting State (`set(instanceId, state)`):**
-    *   The provided `state` (of type `T`) is first serialized into a format suitable for the underlying storage (e.g., `JSON.stringify` for web storage, or directly as an object for IndexedDB/Ephemeral).
-    *   It's then saved to the respective storage mechanism (`localStorage`, `sessionStorage`, in-memory, or an IndexedDB object store).
-    *   An event (of type `store:updated`) is immediately `emit`ted on an internal event bus (from `@asaidimu/events`). This event includes the `instanceId` of the updater, the `storageKey`/`store` identifying the data, and the new `state`. For `EphemeralPersistence`, a `timestamp` is also included for LWW. This event is broadcast to other browser tabs via `BroadcastChannel` (managed by `@asaidimu/events`).
+    *   The provided `state` (of type `T`) is first serialized into a format suitable for the underlying storage (e.g., `JSON.stringify` for web storage, or `structuredClone` for ephemeral, or directly as an object for IndexedDB).
+    *   It's then saved to the respective storage mechanism (`localStorage`, `sessionStorage`, in-memory, or an IndexedDB object store). For IndexedDB, existing data for the given `store` key is updated, or new data is created.
+    *   An event (of type `store:updated`) is immediately `emit`ted on an internal event bus (from `@asaidimu/events`). This event includes the `instanceId` of the updater, the `storageKey`/`store` identifying the data, and the new `state`. For `EphemeralPersistence`, a `timestamp` is also included for LWW resolution. This event is broadcast to other browser tabs via `BroadcastChannel` (managed by `@asaidimu/events`).
     *   For `localStorage`, native `StorageEvent`s also trigger when the value is set from another tab. The `WebStoragePersistence` adapter listens for these native events and re-emits them on its internal event bus, ensuring consistent notification pathways.
 2.  **Getting State (`get()`):**
     *   The adapter retrieves the serialized data using the configured `storageKey` or `store` from the underlying storage.
-    *   It attempts to parse/deserialize the data back into the original `T` type (e.g., `JSON.parse`).
+    *   It attempts to parse/deserialize the data back into the original `T` type (e.g., `JSON.parse` or direct access).
     *   Returns the deserialized data, or `null` if the data is not found or cannot be parsed.
 3.  **Subscribing to Changes (`subscribe(instanceId, callback)`):**
     *   A consumer instance registers a `callback` function with its unique `instanceId` to listen for `store:updated` events on the internal event bus.
@@ -710,6 +715,7 @@ For example, you could create adapters for:
 
 *   **Remote Backend API**: An adapter that persists data to a remote server endpoint via `fetch` or `XMLHttpRequest`, enabling cross-device synchronization.
 *   **Service Worker Cache API**: Leverage Service Workers for advanced caching strategies, providing highly performant offline capabilities.
+*   **Custom Local Storage**: Implement a persistence layer over a custom browser extension storage or a file system in an Electron app.
 
 ---
 
@@ -719,26 +725,26 @@ We welcome contributions to `@asaidimu/utils-persistence`! Please follow these g
 
 ### Development Setup
 
-1.  **Clone the Repository**: This library is likely part of a larger monorepo.
+1.  **Clone the Repository**: This library is part of a larger monorepo.
     ```bash
     git clone https://github.com/asaidimu/erp-utils.git # Or the actual monorepo URL
-    cd erp-utils-packages/utils-src/persistence # Adjust path as necessary
+    cd erp-utils # Navigate to the monorepo root
     ```
-2.  **Install Dependencies**: Navigate to the root of the monorepo first if applicable, then install.
+2.  **Install Dependencies**: Install all monorepo dependencies.
     ```bash
-    npm install # or yarn install
+    bun install # or yarn install or npm install
     ```
     This will install all necessary development dependencies, including TypeScript, Vitest, ESLint, and Prettier.
 
 ### Scripts
 
-The following `npm` scripts are available for development:
+The following `npm` scripts are available for development within the `src/persistence` directory (or can be run from the monorepo root if configured):
 
-*   `npm run build`: Compiles the TypeScript source files to JavaScript.
-*   `npm run test`: Runs the test suite using `vitest`.
-*   `npm run test:watch`: Runs tests in watch mode, re-running on file changes.
-*   `npm run lint`: Lints the codebase using ESLint to identify potential issues and enforce coding standards.
-*   `npm run format`: Formats the code using Prettier to ensure consistent code style.
+*   `bun run build` (or `npm run build`): Compiles the TypeScript source files to JavaScript.
+*   `bun run test` (or `npm run test`): Runs the test suite using `vitest`.
+*   `bun run test:watch` (or `npm run test:watch`): Runs tests in watch mode, re-running on file changes.
+*   `bun run lint` (or `npm run lint`): Lints the codebase using ESLint to identify potential issues and enforce coding standards.
+*   `bun run format` (or `npm run format`): Formats the code using Prettier to ensure consistent code style.
 
 ### Testing
 
@@ -746,11 +752,11 @@ Tests are crucial for maintaining the quality and stability of the library. The
 
 *   To run all tests:
     ```bash
-    npm test
+    bun test
     ```
 *   To run tests in watch mode during development:
     ```bash
-    npm run test:watch
+    bun test:watch
     ```
 *   Ensure that your changes are covered by new or existing tests, and that all tests pass before submitting a pull request. The `fixtures.ts` file provides a generic test suite (`testSimplePersistence`) for any `SimplePersistence` implementation, ensuring consistent behavior across adapters.
 
@@ -758,7 +764,7 @@ Tests are crucial for maintaining the quality and stability of the library. The
 
 *   **Fork the repository** and create your branch from `main`.
 *   **Follow existing coding standards**: Adhere to the TypeScript, ESLint, and Prettier configurations defined in the project.
-*   **Commit messages**: Use [Conventional Commits](https://www.conventionalcommits.org/en/v1.0.0/) for clear and consistent commit history (e.g., `feat: add new adapter`, `fix: resolve subscription issue`, `docs: update README`).
+*   **Commit messages**: Use [Conventional Commits](https://www.conventionalcommits.org/en/v1.0.0/) for clear and consistent commit history (e.g., `feat(persistence): add new adapter`, `fix(webstorage): resolve subscription issue`, `docs(readme): update usage examples`).
 *   **Pull Requests**:
     *   Open a pull request against the `main` branch.
     *   Provide a clear and detailed description of your changes, including the problem solved and the approach taken.
@@ -768,7 +774,7 @@ Tests are crucial for maintaining the quality and stability of the library. The
 
 ### Issue Reporting
 
-If you find a bug or have a feature request, please open an issue on our [GitHub Issues page](https://github.com/asaidimu/erp-utils-issues). When reporting a bug, please include:
+If you find a bug or have a feature request, please open an issue on our [GitHub Issues page](https://github.com/asaidimu/erp-utils/issues). When reporting a bug, please include:
 
 *   A clear, concise title.
 *   Steps to reproduce the issue.
@@ -784,7 +790,7 @@ If you find a bug or have a feature request, please open an issue on our [GitHub
 ### Troubleshooting
 
 *   **Storage Limits**: Be aware that browser storage mechanisms have size limitations. `localStorage` and `sessionStorage` typically offer 5-10 MB, while `IndexedDB` can store much larger amounts (often gigabytes, depending on browser and available disk space). For large data sets, always prefer `IndexedDBPersistence`.
-*   **JSON Parsing Errors**: `WebStoragePersistence`, `IndexedDBPersistence` (for the `data` field), and `EphemeralPersistence` serialize and deserialize your data using `JSON.stringify` and `JSON.parse` (or `structuredClone` for `EphemeralPersistence`). Ensure that the `state` object you are passing to `set` is a valid JSON-serializable object (i.e., it doesn't contain circular references, functions, or Symbols that JSON cannot handle).
+*   **JSON Parsing Errors**: `WebStoragePersistence` and `IndexedDBPersistence` (for the `data` field) serialize and deserialize your data using `JSON.stringify` and `JSON.parse`. `EphemeralPersistence` uses `structuredClone`. Ensure that the `state` object you are passing to `set` is a valid JSON-serializable object (i.e., it doesn't contain circular references, functions, or Symbols that JSON cannot handle).
 *   **Cross-Origin Restrictions**: Browser storage is typically restricted to the same origin (protocol, host, port). You cannot access data stored by a different origin. Ensure your application is running on the same origin across all tabs for cross-tab synchronization to work.
 *   **`IndexedDBPersistence` Asynchronous Nature**: Remember that `IndexedDBPersistence` methods (`set`, `get`, `clear`, `close`) return `Promise`s. Always use `await` or `.then()` to handle their results and ensure operations complete before proceeding. Forgetting to `await` can lead to unexpected behavior or race conditions.
 *   **`EphemeralPersistence` Data Loss**: Data stored with `EphemeralPersistence` is *not* persisted across page reloads or browser restarts. It is strictly an in-memory solution synchronized across active tabs for the current browsing session. If you need data to survive refreshes, use `WebStoragePersistence` or `IndexedDBPersistence`.
@@ -815,11 +821,11 @@ Use `WebStoragePersistence` for small, persistent key-value data, and `IndexedDB
 
 ### Changelog
 
-For detailed changes between versions, please refer to the [CHANGELOG.md](CHANGELOG.md) file in the project's root directory (or specific package directory).
+For detailed changes between versions, please refer to the [CHANGELOG.md](https://github.com/asaidimu/erp-utils/blob/main/packages/utils/src/persistence/CHANGELOG.md) file in the project's root directory (or specific package directory).
 
 ### License
 
-This project is licensed under the MIT License. See the [LICENSE](LICENSE) file for details.
+This project is licensed under the MIT License. See the [LICENSE](https://github.com/asaidimu/erp-utils/blob/main/LICENSE) file for details.
 
 ### Acknowledgments
 

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@asaidimu/utils-persistence",
-  "version": "1.0.0",
+  "version": "2.0.0",
   "description": "Persistence utilities.",
   "main": "index.js",
   "module": "index.mjs",
   "types": "index.d.ts",
   "files": [
-    "./*"
+    "./dist/*"
   ],
   "keywords": [
     "typescript",
@@ -51,7 +51,7 @@
       [
         "@semantic-release/npm",
         {
-          "pkgRoot": "../../dist/persistence"
+          "pkgRoot": "."
         }
       ],
       [

package/LICENSE.md

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2025 Saidimu
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

package/index.d.mts

@@ -1,82 +0,0 @@
-import { S as SimplePersistence } from '../types-D26luDbE.js';
-export { a as StorageEvents } from '../types-D26luDbE.js';
-
-/**
- * Implements SimplePersistence using web storage (localStorage or sessionStorage).
- * Supports cross-tab synchronization via an event bus and native storage events when using localStorage.
- */
-declare class WebStoragePersistence<T extends object> implements SimplePersistence<T> {
-    private readonly storageKey;
-    private readonly eventBus;
-    private readonly storage;
-    /**
-     * Initializes a new instance of WebStoragePersistence.
-     * @param storageKey The key under which data is stored in web storage (e.g., 'user-profile').
-     * @param session Optional flag; if true, uses sessionStorage instead of localStorage (default: false).
-     */
-    constructor(storageKey: string, session?: boolean);
-    /**
-     * Initializes the event bus with configured settings.
-     * @returns Configured event bus instance.
-     */
-    private initializeEventBus;
-    /**
-     * Sets up a listener for native storage events to synchronize across tabs (localStorage only).
-     */
-    private setupStorageEventListener;
-    /**
-     * Persists the provided state to web storage and notifies subscribers.
-     * @param instanceId Unique identifier of the instance making the update.
-     * @param state The state to persist.
-     * @returns True if successful, false if an error occurs.
-     */
-    set(instanceId: string, state: T): boolean;
-    /**
-     * Retrieves the current state from web storage.
-     * @returns The persisted state, or null if not found or invalid.
-     */
-    get(): T | null;
-    /**
-     * Subscribes to updates in the persisted state, excluding the instance’s own changes.
-     * @param instanceId Unique identifier of the subscribing instance.
-     * @param onStateChange Callback to invoke with the updated state.
-     * @returns Function to unsubscribe from updates.
-     */
-    subscribe(instanceId: string, onStateChange: (state: T) => void): () => void;
-    /**
-     * Removes the persisted state from web storage.
-     * @returns True if successful, false if an error occurs.
-     */
-    clear(): boolean;
-}
-
-/**
- * Configuration for database connections
- */
-interface DatabaseConfig {
-    store: string;
-    database: string;
-    collection: string;
-    enableTelemetry?: boolean;
-}
-/**
- * IndexedDB persistence adapter with configurable database support
- */
-declare class IndexedDBPersistence<T> implements SimplePersistence<T> {
-    private collection;
-    private collectionPromise;
-    private config;
-    private eventBus;
-    constructor(config: DatabaseConfig);
-    private getCollection;
-    set(id: string, state: T): Promise<boolean>;
-    get(): Promise<T | null>;
-    subscribe(id: string, callback: (state: T) => void): () => void;
-    clear(): Promise<boolean>;
-    /**
-     * Close a specific database
-     */
-    close(): Promise<void>;
-}
-
-export { IndexedDBPersistence, SimplePersistence, WebStoragePersistence };

package/index.d.ts

@@ -1,82 +0,0 @@
-import { S as SimplePersistence } from '../types-D26luDbE.js';
-export { a as StorageEvents } from '../types-D26luDbE.js';
-
-/**
- * Implements SimplePersistence using web storage (localStorage or sessionStorage).
- * Supports cross-tab synchronization via an event bus and native storage events when using localStorage.
- */
-declare class WebStoragePersistence<T extends object> implements SimplePersistence<T> {
-    private readonly storageKey;
-    private readonly eventBus;
-    private readonly storage;
-    /**
-     * Initializes a new instance of WebStoragePersistence.
-     * @param storageKey The key under which data is stored in web storage (e.g., 'user-profile').
-     * @param session Optional flag; if true, uses sessionStorage instead of localStorage (default: false).
-     */
-    constructor(storageKey: string, session?: boolean);
-    /**
-     * Initializes the event bus with configured settings.
-     * @returns Configured event bus instance.
-     */
-    private initializeEventBus;
-    /**
-     * Sets up a listener for native storage events to synchronize across tabs (localStorage only).
-     */
-    private setupStorageEventListener;
-    /**
-     * Persists the provided state to web storage and notifies subscribers.
-     * @param instanceId Unique identifier of the instance making the update.
-     * @param state The state to persist.
-     * @returns True if successful, false if an error occurs.
-     */
-    set(instanceId: string, state: T): boolean;
-    /**
-     * Retrieves the current state from web storage.
-     * @returns The persisted state, or null if not found or invalid.
-     */
-    get(): T | null;
-    /**
-     * Subscribes to updates in the persisted state, excluding the instance’s own changes.
-     * @param instanceId Unique identifier of the subscribing instance.
-     * @param onStateChange Callback to invoke with the updated state.
-     * @returns Function to unsubscribe from updates.
-     */
-    subscribe(instanceId: string, onStateChange: (state: T) => void): () => void;
-    /**
-     * Removes the persisted state from web storage.
-     * @returns True if successful, false if an error occurs.
-     */
-    clear(): boolean;
-}
-
-/**
- * Configuration for database connections
- */
-interface DatabaseConfig {
-    store: string;
-    database: string;
-    collection: string;
-    enableTelemetry?: boolean;
-}
-/**
- * IndexedDB persistence adapter with configurable database support
- */
-declare class IndexedDBPersistence<T> implements SimplePersistence<T> {
-    private collection;
-    private collectionPromise;
-    private config;
-    private eventBus;
-    constructor(config: DatabaseConfig);
-    private getCollection;
-    set(id: string, state: T): Promise<boolean>;
-    get(): Promise<T | null>;
-    subscribe(id: string, callback: (state: T) => void): () => void;
-    clear(): Promise<boolean>;
-    /**
-     * Close a specific database
-     */
-    close(): Promise<void>;
-}
-
-export { IndexedDBPersistence, SimplePersistence, WebStoragePersistence };