favalib 0.0.6 → 0.0.7

package/build/TwoFaLib.d.mts

@@ -1,6 +1,6 @@
 import { TypedEventTarget } from 'typescript-event-target';
 import type CryptoLib from './interfaces/CryptoLib.mjs';
-import type { EncryptedPrivateKey, EncryptedSymmetricKey, Passphrase, PrivateKey, PublicKey, Salt, SymmetricKey } from './interfaces/CryptoLib.mjs';
+import type { EncryptedPrivateKey, EncryptedSymmetricKey, PrivateKey, PublicKey, Salt, SymmetricKey } from './interfaces/CryptoLib.mjs';
 import type { DeviceFriendlyName, DeviceId, DeviceType } from './interfaces/SyncTypes.mjs';
 import type { TwoFaLibEventMapEvents } from './interfaces/Events.mjs';
 import type { PassphraseExtraDict } from './interfaces/PassphraseExtraDict.js';
@@ -8,6 +8,8 @@ import type { Vault, VaultSyncState } from './interfaces/Vault.mjs';
 import SyncManager from './subclasses/SyncManager.mjs';
 import ExportImportManager from './subclasses/ExportImportManager.mjs';
 import VaultOperationsManager from './subclasses/VaultOperationsManager.mjs';
+import SaveFunction from './interfaces/SaveFunction.mjs';
+import StorageOperationsManager from './subclasses/StorageOperationsManager.mjs';
 /**
  * The Two-Factor Library, this is the main entry point.
  */
@@ -33,17 +35,27 @@ declare class TwoFaLib extends TypedEventTarget<TwoFaLibEventMapEvents> {
      * @param publicKey - The public key of the device.
      * @param deviceId - A unique identifier for this device.
      * @param vault - The vault data (entries)
+     * @param saveFunction - The function to save the data.
      * @param syncState - The state of the sync, includes the serverUrl
      * @returns A promise that resolves when initialization is complete.
      * @throws {InitializationError} If some parameter has an invalid value
      * @throws {AuthenticationError} If the provided passphrase is incorrect.
      */
-    constructor(deviceType: DeviceType, cryptoLib: CryptoLib, passphraseExtraDict: PassphraseExtraDict, privateKey: PrivateKey, symmetricKey: SymmetricKey, encryptedPrivateKey: EncryptedPrivateKey, encryptedSymmetricKey: EncryptedSymmetricKey, salt: Salt, publicKey: PublicKey, deviceId: DeviceId, vault?: Vault, syncState?: VaultSyncState);
+    constructor(deviceType: DeviceType, cryptoLib: CryptoLib, passphraseExtraDict: PassphraseExtraDict, privateKey: PrivateKey, symmetricKey: SymmetricKey, encryptedPrivateKey: EncryptedPrivateKey, encryptedSymmetricKey: EncryptedSymmetricKey, salt: Salt, publicKey: PublicKey, deviceId: DeviceId, vault?: Vault, saveFunction?: SaveFunction, syncState?: VaultSyncState);
+    /**
+     * @returns The persistent storage manager instance which can be used to store data.
+     */
+    private get persistentStorageManager();
     /**
      * Gives access to vault operations.
-     * @returns The vault manager instance which can be used to perform operations on the vault.
+     * @returns The vault operations manager instance which can be used to perform operations on the vault.
      */
     get vault(): VaultOperationsManager;
+    /**
+     * Gives access to storage operations.
+     * @returns The storage operations manager instance which can be used to perform operations on the vault.
+     */
+    get storage(): StorageOperationsManager;
     /**
      * Gives access to export/import operations.
      * @returns The export/import manager instance which can be used to export and import vaults.
@@ -54,22 +66,6 @@ declare class TwoFaLib extends TypedEventTarget<TwoFaLibEventMapEvents> {
      * @returns The sync manager instance which can be used to sync the vault with a server or null if none was initialized.
      */
     get sync(): SyncManager | null;
-    /**
-     * @returns The persistent storage manager instance which can be used to store data.
-     */
-    private get persistentStorage();
-    /**
-     * Forces a save of the persistent storage.
-     */
-    forceSave(): Promise<void>;
-    /**
-     * Changes the library's passphrase.
-     * @param oldPassphrase - The current passphrase.
-     * @param newPassphrase - The new passphrase to set.
-     * @returns A promise that resolves when the passphrase change is complete.
-     * @throws {AuthenticationError} If the provided old passphrase is incorrect.
-     */
-    changePassphrase(oldPassphrase: Passphrase, newPassphrase: Passphrase): Promise<void>;
     /**
      * Sets a server url, this will allow syncing with the server.
      * @param serverUrl - The server url.

package/build/TwoFaLib.mjs

@@ -9,6 +9,7 @@ import PersistentStorageManager from './subclasses/PersistentStorageManager.mjs'
 import VaultDataManager from './subclasses/VaultDataManager.mjs';
 import VaultOperationsManager from './subclasses/VaultOperationsManager.mjs';
 import CommandManager from './subclasses/CommandManager.mjs';
+import StorageOperationsManager from './subclasses/StorageOperationsManager.mjs';
 /**
  * The Two-Factor Library, this is the main entry point.
  */
@@ -28,12 +29,13 @@ class TwoFaLib extends TypedEventTarget {
      * @param publicKey - The public key of the device.
      * @param deviceId - A unique identifier for this device.
      * @param vault - The vault data (entries)
+     * @param saveFunction - The function to save the data.
      * @param syncState - The state of the sync, includes the serverUrl
      * @returns A promise that resolves when initialization is complete.
      * @throws {InitializationError} If some parameter has an invalid value
      * @throws {AuthenticationError} If the provided passphrase is incorrect.
      */
-    constructor(deviceType, cryptoLib, passphraseExtraDict, privateKey, symmetricKey, encryptedPrivateKey, encryptedSymmetricKey, salt, publicKey, deviceId, vault, syncState) {
+    constructor(deviceType, cryptoLib, passphraseExtraDict, privateKey, symmetricKey, encryptedPrivateKey, encryptedSymmetricKey, salt, publicKey, deviceId, vault, saveFunction, syncState) {
         super();
         this.deviceFriendlyName = '';
         if (!deviceType) {
@@ -57,11 +59,12 @@ class TwoFaLib extends TypedEventTarget {
             ['libraryLoader', new LibraryLoader(cryptoLib)],
             [
                 'persistentStorageManager',
-                new PersistentStorageManager(this.mediator, passphraseExtraDict, deviceId, privateKey, symmetricKey, encryptedPrivateKey, encryptedSymmetricKey, salt),
+                new PersistentStorageManager(this.mediator, passphraseExtraDict, deviceId, privateKey, symmetricKey, encryptedPrivateKey, encryptedSymmetricKey, salt, saveFunction),
             ],
             ['vaultDataManager', new VaultDataManager(this.mediator)],
             ['commandManager', new CommandManager(this.mediator)],
             ['vaultOperationsManager', new VaultOperationsManager(this.mediator)],
+            ['storageOperationsManager', new StorageOperationsManager(this.mediator)],
             [
                 'exportImportManager',
                 new ExportImportManager(this.mediator, passphraseExtraDict),
@@ -92,13 +95,26 @@ class TwoFaLib extends TypedEventTarget {
         };
         this.addEventListener(TwoFaLibEvent.Ready, handleReadyEvent);
     }
+    /**
+     * @returns The persistent storage manager instance which can be used to store data.
+     */
+    get persistentStorageManager() {
+        return this.mediator.getComponent('persistentStorageManager');
+    }
     /**
      * Gives access to vault operations.
-     * @returns The vault manager instance which can be used to perform operations on the vault.
+     * @returns The vault operations manager instance which can be used to perform operations on the vault.
      */
     get vault() {
         return this.mediator.getComponent('vaultOperationsManager');
     }
+    /**
+     * Gives access to storage operations.
+     * @returns The storage operations manager instance which can be used to perform operations on the vault.
+     */
+    get storage() {
+        return this.mediator.getComponent('storageOperationsManager');
+    }
     /**
      * Gives access to export/import operations.
      * @returns The export/import manager instance which can be used to export and import vaults.
@@ -116,28 +132,6 @@ class TwoFaLib extends TypedEventTarget {
         }
         return this.mediator.getComponent('syncManager');
     }
-    /**
-     * @returns The persistent storage manager instance which can be used to store data.
-     */
-    get persistentStorage() {
-        return this.mediator.getComponent('persistentStorageManager');
-    }
-    /**
-     * Forces a save of the persistent storage.
-     */
-    async forceSave() {
-        await this.persistentStorage.save();
-    }
-    /**
-     * Changes the library's passphrase.
-     * @param oldPassphrase - The current passphrase.
-     * @param newPassphrase - The new passphrase to set.
-     * @returns A promise that resolves when the passphrase change is complete.
-     * @throws {AuthenticationError} If the provided old passphrase is incorrect.
-     */
-    async changePassphrase(oldPassphrase, newPassphrase) {
-        return this.persistentStorage.changePassphrase(oldPassphrase, newPassphrase);
-    }
     /**
      * Sets a server url, this will allow syncing with the server.
      * @param serverUrl - The server url.
@@ -182,7 +176,7 @@ class TwoFaLib extends TypedEventTarget {
         this.mediator.unRegisterComponent('syncManager');
         this.mediator.registerComponent('syncManager', newSyncManager);
         // save
-        await this.forceSave();
+        await this.persistentStorageManager.save();
     }
     /**
      * Dispatches a library event.

package/build/interfaces/Events.d.mts

@@ -1,12 +1,8 @@
 import type { EmptyObject } from 'type-fest';
 import type { TwoFaLibEvent } from '../TwoFaLibEvent.mjs';
-import type { LockedRepresentationString } from './Vault.mjs';
 import type { ConnectionStatus } from '../subclasses/SyncManager.mjs';
-export interface ChangedEvent {
-    newLockedRepresentationString: LockedRepresentationString;
-}
 export interface TwoFaLibEventMap {
-    [TwoFaLibEvent.Changed]: ChangedEvent;
+    [TwoFaLibEvent.Changed]: EmptyObject;
     [TwoFaLibEvent.LoadedFromLockedRepresentation]: EmptyObject;
     [TwoFaLibEvent.ConnectToExistingVaultFinished]: EmptyObject;
     [TwoFaLibEvent.ConnectionToSyncServerStatusChanged]: {

package/build/interfaces/SaveFunction.d.mts

@@ -0,0 +1,3 @@
+import type { LockedRepresentationString } from './Vault.mjs';
+type SaveFunction = (newLockedRepresentationString: LockedRepresentationString) => Promise<void> | void;
+export default SaveFunction;

package/build/interfaces/SaveFunction.mjs

@@ -0,0 +1 @@
+export {};

package/build/main.d.mts

@@ -5,8 +5,9 @@ import type CryptoLib from './interfaces/CryptoLib.mjs';
 import type { Encrypted, EncryptedPrivateKey, EncryptedSymmetricKey, EncryptedPublicKey, PrivateKey, SymmetricKey, PublicKey, Passphrase, Salt } from './interfaces/CryptoLib.mjs';
 import type { PublicSyncDevice, DeviceId, DeviceType, DeviceFriendlyName } from './interfaces/SyncTypes.mjs';
 import type { EncryptedVaultStateString, LockedRepresentationString } from './interfaces/Vault.mjs';
+import type SaveFunction from './interfaces/SaveFunction.mjs';
 import { TwoFALibError, InitializationError, AuthenticationError, EntryNotFoundError, TokenGenerationError } from './TwoFALibError.mjs';
 import { TwoFaLibEvent } from './TwoFaLibEvent.mjs';
 import { getTwoFaLibVaultCreationUtils } from './utils/creationUtils.mjs';
 export { TwoFaLib, TwoFALibError, getTwoFaLibVaultCreationUtils, InitializationError, AuthenticationError, EntryNotFoundError, TokenGenerationError, TwoFaLibEvent, };
-export type { Entry, EntryId, NewEntry, EntryMeta, EntryMetaWithToken, EntryType, TotpPayload, Token, EncryptedVaultStateString, LockedRepresentationString, CryptoLib, Encrypted, EncryptedPrivateKey, EncryptedPublicKey, EncryptedSymmetricKey, PrivateKey, SymmetricKey, PublicKey, Passphrase, Salt, DeviceId, DeviceType, DeviceFriendlyName, PublicSyncDevice, };
+export type { Entry, EntryId, NewEntry, EntryMeta, EntryMetaWithToken, EntryType, TotpPayload, Token, EncryptedVaultStateString, LockedRepresentationString, CryptoLib, Encrypted, EncryptedPrivateKey, EncryptedPublicKey, EncryptedSymmetricKey, PrivateKey, SymmetricKey, PublicKey, Passphrase, Salt, DeviceId, DeviceType, DeviceFriendlyName, PublicSyncDevice, SaveFunction, };

package/build/subclasses/PersistentStorageManager.d.mts

@@ -1,8 +1,9 @@
 import type { EncryptedPrivateKey, EncryptedSymmetricKey, Passphrase, PrivateKey, Salt, SymmetricKey } from '../interfaces/CryptoLib.mjs';
-import { EncryptedVaultStateString, LockedRepresentationString } from '../interfaces/Vault.mjs';
+import { EncryptedVaultStateString } from '../interfaces/Vault.mjs';
 import type TwoFaLibMediator from '../TwoFaLibMediator.mjs';
 import type { DeviceId } from '../interfaces/SyncTypes.mjs';
 import type { PassphraseExtraDict } from '../interfaces/PassphraseExtraDict.js';
+import SaveFunction from '../interfaces/SaveFunction.mjs';
 /**
  * Manages all storage of data that should be persistent.
  */
@@ -15,7 +16,9 @@ declare class PersistentStorageManager {
     private encryptedPrivateKey;
     private encryptedSymmetricKey;
     private salt;
+    private saveFunction?;
     static readonly storageVersion = 1;
+    private savePromise;
     /**
      * Constructs a new instance of PersistentStorageManager.
      * @param mediator - The mediator for accessing other components.
@@ -26,12 +29,12 @@ declare class PersistentStorageManager {
      * @param encryptedPrivateKey - The encrypted private key
      * @param encryptedSymmetricKey - The encrypted symmetric key
      * @param salt - The salt used for key derivation.
+     * @param saveFunction - The function to save the data.
      */
-    constructor(mediator: TwoFaLibMediator, passphraseExtraDict: PassphraseExtraDict, deviceId: DeviceId, privateKey: PrivateKey, symmetricKey: SymmetricKey, encryptedPrivateKey: EncryptedPrivateKey, encryptedSymmetricKey: EncryptedSymmetricKey, salt: Salt);
+    constructor(mediator: TwoFaLibMediator, passphraseExtraDict: PassphraseExtraDict, deviceId: DeviceId, privateKey: PrivateKey, symmetricKey: SymmetricKey, encryptedPrivateKey: EncryptedPrivateKey, encryptedSymmetricKey: EncryptedSymmetricKey, salt: Salt, saveFunction?: SaveFunction | undefined);
     private get cryptoLib();
     private get vaultDataManager();
     private get syncManager();
-    private get dispatchLibEvent();
     /**
      * Retrieves an encrypted representation of the library's current state.
      * This can be used for secure storage or transmission of the library's data.
@@ -46,12 +49,21 @@ declare class PersistentStorageManager {
      * @returns A promise that resolves with a json encoded string of
      * the partially encrypted library's data.
      */
-    getLockedRepresentation(): Promise<LockedRepresentationString>;
+    private getLockedRepresentation;
+    /**
+     * Sets the save function for the library. Used for testing.
+     * @param saveFunction - The save function to set.
+     */
+    setSaveFunction(saveFunction: SaveFunction): void;
     /**
      * Saves the current state of the library.
      * @returns A promise that resolves when the save operation is complete.
      */
     save(): Promise<void>;
+    /**
+     * Internal method to perform the actual save operation.
+     */
+    private performSave;
     /**
      * Validates the provided passphrase against the current library passphrase.
      * @param salt - The salt used for key derivation.

package/build/subclasses/PersistentStorageManager.mjs

@@ -1,5 +1,4 @@
 import { AuthenticationError } from '../TwoFALibError.mjs';
-import { TwoFaLibEvent } from '../TwoFaLibEvent.mjs';
 import TwoFaLib from '../TwoFaLib.mjs';
 import { validatePassphraseStrength } from '../utils/creationUtils.mjs';
 /**
@@ -17,8 +16,9 @@ class PersistentStorageManager {
      * @param encryptedPrivateKey - The encrypted private key
      * @param encryptedSymmetricKey - The encrypted symmetric key
      * @param salt - The salt used for key derivation.
+     * @param saveFunction - The function to save the data.
      */
-    constructor(mediator, passphraseExtraDict, deviceId, privateKey, symmetricKey, encryptedPrivateKey, encryptedSymmetricKey, salt) {
+    constructor(mediator, passphraseExtraDict, deviceId, privateKey, symmetricKey, encryptedPrivateKey, encryptedSymmetricKey, salt, saveFunction) {
         this.mediator = mediator;
         this.passphraseExtraDict = passphraseExtraDict;
         this.deviceId = deviceId;
@@ -27,6 +27,8 @@ class PersistentStorageManager {
         this.encryptedPrivateKey = encryptedPrivateKey;
         this.encryptedSymmetricKey = encryptedSymmetricKey;
         this.salt = salt;
+        this.saveFunction = saveFunction;
+        this.savePromise = null;
     }
     get cryptoLib() {
         return this.mediator.getComponent('libraryLoader').getCryptoLib();
@@ -40,9 +42,6 @@ class PersistentStorageManager {
         }
         return this.mediator.getComponent('syncManager');
     }
-    get dispatchLibEvent() {
-        return this.mediator.getComponent('dispatchLibEvent');
-    }
     /**
      * Retrieves an encrypted representation of the library's current state.
      * This can be used for secure storage or transmission of the library's data.
@@ -82,15 +81,42 @@ class PersistentStorageManager {
         };
         return JSON.stringify(lockedRepresentation);
     }
+    /**
+     * Sets the save function for the library. Used for testing.
+     * @param saveFunction - The save function to set.
+     */
+    setSaveFunction(saveFunction) {
+        this.saveFunction = saveFunction;
+    }
     /**
      * Saves the current state of the library.
      * @returns A promise that resolves when the save operation is complete.
      */
     async save() {
+        if (this.saveFunction) {
+            // If a save is already in progress, wait for it to complete
+            if (this.savePromise) {
+                await this.savePromise;
+                // recurse
+                await this.save();
+                return;
+            }
+            // Start a new save operation
+            this.savePromise = this.performSave();
+            try {
+                await this.savePromise;
+            }
+            finally {
+                this.savePromise = null;
+            }
+        }
+    }
+    /**
+     * Internal method to perform the actual save operation.
+     */
+    async performSave() {
         const lockedRepresentation = await this.getLockedRepresentation();
-        this.dispatchLibEvent(TwoFaLibEvent.Changed, {
-            newLockedRepresentationString: lockedRepresentation,
-        });
+        await this.saveFunction(lockedRepresentation);
     }
     /**
      * Validates the provided passphrase against the current library passphrase.

package/build/subclasses/StorageOperationsManager.d.mts

@@ -0,0 +1,30 @@
+import type TwoFaLibMediator from '../TwoFaLibMediator.mjs';
+import type { Passphrase } from '../interfaces/CryptoLib.mjs';
+/**
+ * Manages the public operations related to the vault storage
+ */
+declare class StorageOperationsManager {
+    private readonly mediator;
+    /**
+     * Constructs a new instance of StorageOperationsManager.
+     * @param mediator - The mediator for accessing other components.
+     */
+    constructor(mediator: TwoFaLibMediator);
+    /**
+     * @returns The persistent storage manager instance which can be used to store data.
+     */
+    get persistentStorage(): import("./PersistentStorageManager.mjs").default;
+    /**
+     * Forces a save.
+     */
+    forceSave(): Promise<void>;
+    /**
+     * Changes the library's passphrase.
+     * @param oldPassphrase - The current passphrase.
+     * @param newPassphrase - The new passphrase to set.
+     * @returns A promise that resolves when the passphrase change is complete.
+     * @throws {AuthenticationError} If the provided old passphrase is incorrect.
+     */
+    changePassphrase(oldPassphrase: Passphrase, newPassphrase: Passphrase): Promise<void>;
+}
+export default StorageOperationsManager;

package/build/subclasses/StorageOperationsManager.mjs

@@ -0,0 +1,35 @@
+/**
+ * Manages the public operations related to the vault storage
+ */
+class StorageOperationsManager {
+    /**
+     * Constructs a new instance of StorageOperationsManager.
+     * @param mediator - The mediator for accessing other components.
+     */
+    constructor(mediator) {
+        this.mediator = mediator;
+    }
+    /**
+     * @returns The persistent storage manager instance which can be used to store data.
+     */
+    get persistentStorage() {
+        return this.mediator.getComponent('persistentStorageManager');
+    }
+    /**
+     * Forces a save.
+     */
+    async forceSave() {
+        return this.persistentStorage.save();
+    }
+    /**
+     * Changes the library's passphrase.
+     * @param oldPassphrase - The current passphrase.
+     * @param newPassphrase - The new passphrase to set.
+     * @returns A promise that resolves when the passphrase change is complete.
+     * @throws {AuthenticationError} If the provided old passphrase is incorrect.
+     */
+    async changePassphrase(oldPassphrase, newPassphrase) {
+        return this.persistentStorage.changePassphrase(oldPassphrase, newPassphrase);
+    }
+}
+export default StorageOperationsManager;

package/build/subclasses/VaultDataManager.d.mts

@@ -15,6 +15,7 @@ declare class VaultDataManager {
      */
     constructor(mediator: TwoFaLibMediator);
     private get persistentStorageManager();
+    private get dispatchLibEvent();
     /**
      * @returns The number of entries in the vault.
      */

package/build/subclasses/VaultDataManager.mjs

@@ -1,5 +1,6 @@
 import { TOTP } from 'totp-generator';
 import { EntryNotFoundError, TokenGenerationError } from '../TwoFALibError.mjs';
+import { TwoFaLibEvent } from '../TwoFaLibEvent.mjs';
 import { SUPPORTED_ALGORITHMS, } from '../utils/constants.mjs';
 /**
  * Manages the data within the vault. This class should only be used internally
@@ -17,6 +18,9 @@ class VaultDataManager {
     get persistentStorageManager() {
         return this.mediator.getComponent('persistentStorageManager');
     }
+    get dispatchLibEvent() {
+        return this.mediator.getComponent('dispatchLibEvent');
+    }
     /**
      * @returns The number of entries in the vault.
      */
@@ -80,6 +84,7 @@ class VaultDataManager {
             return;
         }
         this.vault.push(entry);
+        this.dispatchLibEvent(TwoFaLibEvent.Changed);
         if (saveAfter) {
             await this.persistentStorageManager.save();
         }
@@ -94,6 +99,7 @@ class VaultDataManager {
         if (index === -1)
             throw new EntryNotFoundError('Entry not found');
         this.vault.splice(index, 1);
+        this.dispatchLibEvent(TwoFaLibEvent.Changed);
         await this.persistentStorageManager.save();
     }
     /**
@@ -108,6 +114,7 @@ class VaultDataManager {
         if (index === -1)
             throw new EntryNotFoundError('Entry not found');
         this.vault[index] = updatedEntry;
+        this.dispatchLibEvent(TwoFaLibEvent.Changed);
         await this.persistentStorageManager.save();
     }
     /**
@@ -116,6 +123,7 @@ class VaultDataManager {
      */
     replaceVault(newVault) {
         this.vault = newVault;
+        this.dispatchLibEvent(TwoFaLibEvent.Changed);
     }
 }
 export default VaultDataManager;

package/build/subclasses/VaultOperationsManager.d.mts

@@ -4,7 +4,7 @@ import type TwoFaLibMediator from '../TwoFaLibMediator.mjs';
 /**
  * Manages the public operations related to the vault, including adding, deleting, and updating entries.
  */
-declare class VaultManager {
+declare class VaultOperationsManager {
     private readonly mediator;
     /**
      * Constructs a new instance of VaultManager.
@@ -88,4 +88,4 @@ declare class VaultManager {
      */
     updateEntry(entryId: EntryId, updates: Partial<Omit<Entry, 'id'>>): Promise<EntryMeta>;
 }
-export default VaultManager;
+export default VaultOperationsManager;

package/build/subclasses/VaultOperationsManager.mjs

@@ -14,7 +14,7 @@ const getMetaForEntry = (entry) => ({
 /**
  * Manages the public operations related to the vault, including adding, deleting, and updating entries.
  */
-class VaultManager {
+class VaultOperationsManager {
     /**
      * Constructs a new instance of VaultManager.
      * @param mediator - The mediator for accessing other components.
@@ -160,4 +160,4 @@ class VaultManager {
         return getMetaForEntry(updatedEntry);
     }
 }
-export default VaultManager;
+export default VaultOperationsManager;

package/build/utils/creationUtils.d.mts

@@ -6,6 +6,7 @@ import TwoFaLib from '../TwoFaLib.mjs';
 import LibraryLoader from '../subclasses/LibraryLoader.mjs';
 import type { LockedRepresentationString } from '../interfaces/Vault.mjs';
 import type { PassphraseExtraDict } from '../interfaces/PassphraseExtraDict.js';
+import SaveFunction from '../interfaces/SaveFunction.mjs';
 /**
  * Evaluates the strength of a passphrase.
  * @param libraryLoader - An instance of LibraryLoader.
@@ -27,10 +28,11 @@ export declare const validatePassphraseStrength: (libraryLoader: LibraryLoader,
  * @param cryptoLib - An instance of CryptoLib that is compatible with the environment.
  * @param deviceType - A unique identifier for this device type (e.g. 2fa-cli).
  * @param passphraseExtraDict - Additional words to be used for passphrase strength evaluation.
+ * @param saveFunction - The function to save the data.
  * @param serverUrl - The server URL for syncing.
  * @returns An object with methods to evaluate passphrase strength and create a new TwoFaLib vault.
  */
-export declare const getTwoFaLibVaultCreationUtils: (cryptoLib: CryptoLib, deviceType: DeviceType, passphraseExtraDict: PassphraseExtraDict, serverUrl?: string) => {
+export declare const getTwoFaLibVaultCreationUtils: (cryptoLib: CryptoLib, deviceType: DeviceType, passphraseExtraDict: PassphraseExtraDict, saveFunction?: SaveFunction, serverUrl?: string) => {
     getPassphraseStrength: (passphrase: Passphrase, passphraseExtraDict: PassphraseExtraDict) => Promise<ZxcvbnResult>;
     createNewTwoFaLibVault: (passphrase: Passphrase) => Promise<{
         twoFaLib: TwoFaLib;

package/build/utils/creationUtils.mjs

@@ -56,15 +56,16 @@ export const validatePassphraseStrength = async (libraryLoader, passphrase, pass
  * @param deviceType - A unique identifier for the device type e.g. 2fa-cli.
  * @param serverUrl - The server URL for syncing.
  * @param passphraseExtraDict - Additional words to be used for passphrase strength evaluation.
+ * @param saveFunction - The function to save the data.
  * @param passphrase - The passphrase to be used to encrypt the private key.
  * @returns Promise resolving to an object containing the newly created TwoFaLib instance and related data.
  */
-const createNewTwoFaLibVault = async (libraryLoader, deviceType, serverUrl, passphraseExtraDict, passphrase) => {
+const createNewTwoFaLibVault = async (libraryLoader, deviceType, serverUrl, passphraseExtraDict, saveFunction, passphrase) => {
     const cryptoLib = libraryLoader.getCryptoLib();
     const { publicKey, privateKey, symmetricKey, encryptedPrivateKey, encryptedSymmetricKey, salt, } = await cryptoLib.createKeys(passphrase);
     await validatePassphraseStrength(libraryLoader, passphrase, passphraseExtraDict);
     const deviceId = genUuidV4();
-    const twoFaLib = new TwoFaLib(deviceType, cryptoLib, passphraseExtraDict, privateKey, symmetricKey, encryptedPrivateKey, encryptedSymmetricKey, salt, publicKey, deviceId, [], {
+    const twoFaLib = new TwoFaLib(deviceType, cryptoLib, passphraseExtraDict, privateKey, symmetricKey, encryptedPrivateKey, encryptedSymmetricKey, salt, publicKey, deviceId, [], saveFunction, {
         serverUrl,
         devices: [],
         commandSendQueue: [],
@@ -82,12 +83,13 @@ const createNewTwoFaLibVault = async (libraryLoader, deviceType, serverUrl, pass
  * @param libraryLoader - An instance of LibraryLoader.
  * @param deviceType - A unique identifier for this device type (e.g. 2fa-cli).
  * @param passphraseExtraDict - Additional words to be used for passphrase strength evaluation.
+ * @param saveFunction - The function to save the data.
  * @param lockedRepresentationString - The string representation of the locked library state representation.
  * @param passphrase - The passphrase for decrypting the keys.
  * @returns A promise that resolves when loading is complete.
  * @throws {InitializationError} If loading fails due to invalid or corrupted data.
  */
-const loadTwoFaLibFromLockedRepesentation = async (libraryLoader, deviceType, passphraseExtraDict, lockedRepresentationString, passphrase) => {
+const loadTwoFaLibFromLockedRepesentation = async (libraryLoader, deviceType, passphraseExtraDict, saveFunction, lockedRepresentationString, passphrase) => {
     const cryptoLib = libraryLoader.getCryptoLib();
     const lockedRepresentation = JSON.parse(lockedRepresentationString);
     if (!lockedRepresentation ||
@@ -105,21 +107,22 @@ const loadTwoFaLibFromLockedRepesentation = async (libraryLoader, deviceType, pa
         !vaultState.sync?.devices) {
         throw new InitializationError('encryptedVaultState is incomplete or corrupted');
     }
-    return new TwoFaLib(deviceType, cryptoLib, passphraseExtraDict, privateKey, symmetricKey, lockedRepresentation.encryptedPrivateKey, lockedRepresentation.encryptedSymmetricKey, lockedRepresentation.salt, publicKey, vaultState.deviceId, vaultState.vault, vaultState.sync);
+    return new TwoFaLib(deviceType, cryptoLib, passphraseExtraDict, privateKey, symmetricKey, lockedRepresentation.encryptedPrivateKey, lockedRepresentation.encryptedSymmetricKey, lockedRepresentation.salt, publicKey, vaultState.deviceId, vaultState.vault, saveFunction, vaultState.sync);
 };
 /**
  * Returns utility functions useful in creating a new twoFaLib vault
  * @param cryptoLib - An instance of CryptoLib that is compatible with the environment.
  * @param deviceType - A unique identifier for this device type (e.g. 2fa-cli).
  * @param passphraseExtraDict - Additional words to be used for passphrase strength evaluation.
+ * @param saveFunction - The function to save the data.
  * @param serverUrl - The server URL for syncing.
  * @returns An object with methods to evaluate passphrase strength and create a new TwoFaLib vault.
  */
-export const getTwoFaLibVaultCreationUtils = (cryptoLib, deviceType, passphraseExtraDict, serverUrl) => {
+export const getTwoFaLibVaultCreationUtils = (cryptoLib, deviceType, passphraseExtraDict, saveFunction, serverUrl) => {
     const libraryLoader = new LibraryLoader(cryptoLib);
     return {
         getPassphraseStrength: getPassphraseStrength.bind(null, libraryLoader),
-        createNewTwoFaLibVault: createNewTwoFaLibVault.bind(null, libraryLoader, deviceType, serverUrl, passphraseExtraDict),
-        loadTwoFaLibFromLockedRepesentation: loadTwoFaLibFromLockedRepesentation.bind(null, libraryLoader, deviceType, passphraseExtraDict),
+        createNewTwoFaLibVault: createNewTwoFaLibVault.bind(null, libraryLoader, deviceType, serverUrl, passphraseExtraDict, saveFunction),
+        loadTwoFaLibFromLockedRepesentation: loadTwoFaLibFromLockedRepesentation.bind(null, libraryLoader, deviceType, passphraseExtraDict, saveFunction),
     };
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "favalib",
-  "version": "0.0.6",
+  "version": "0.0.7",
   "description": "",
   "type": "module",
   "exports": {