@openmrs/esm-offline 3.4.1-pre.96 → 4.0.0-pre.1

package/.turbo/turbo-build.log

@@ -1,17 +1,17 @@
-@openmrs/esm-offline:build: cache hit, replaying output 44e1f49aa8c09bf2
+@openmrs/esm-offline:build: cache hit, replaying output 1364214084b08f2a
 @openmrs/esm-offline:build: $ webpack --mode=production
-@openmrs/esm-offline:build: asset openmrs-esm-offline.js 112 KiB [emitted] [minimized] (name: main) 1 related asset
-@openmrs/esm-offline:build: orphan modules 164 KiB [orphan] 26 modules
+@openmrs/esm-offline:build: asset openmrs-esm-offline.js 112 KiB [emitted] [minimized] (name: main) 1 related asset
+@openmrs/esm-offline:build: orphan modules 164 KiB [orphan] 26 modules
 @openmrs/esm-offline:build: runtime modules 2.02 KiB 7 modules
-@openmrs/esm-offline:build: built modules 177 KiB [built]
+@openmrs/esm-offline:build: built modules 177 KiB [built]
 @openmrs/esm-offline:build:   cacheable modules 176 KiB
-@openmrs/esm-offline:build:     modules by path ../../../node_modules/systemjs-webpack-interop/ 3.27 KiB
-@openmrs/esm-offline:build:       ../../../node_modules/systemjs-webpack-interop/auto-public-path/1.js 89 bytes [built] [code generated]
-@openmrs/esm-offline:build:       ../../../node_modules/systemjs-webpack-interop/auto-public-path/auto-public-path.js 846 bytes [built] [code generated]
-@openmrs/esm-offline:build:       ../../../node_modules/systemjs-webpack-interop/public-path.js 2.36 KiB [built] [code generated]
-@openmrs/esm-offline:build:     ./src/index.ts + 16 modules 149 KiB [built] [code generated]
-@openmrs/esm-offline:build:     ../../../node_modules/regenerator-runtime/runtime.js 24.3 KiB [built] [code generated]
-@openmrs/esm-offline:build:   modules by path external "@openmrs/ 84 bytes
-@openmrs/esm-offline:build:     external "@openmrs/esm-api" 42 bytes [built] [code generated]
-@openmrs/esm-offline:build:     external "@openmrs/esm-state" 42 bytes [built] [code generated]
-@openmrs/esm-offline:build: webpack 5.70.0 compiled successfully in 8264 ms
+@openmrs/esm-offline:build:     modules by path ../../../node_modules/systemjs-webpack-interop/ 3.27 KiB
+@openmrs/esm-offline:build:       ../../../node_modules/systemjs-webpack-interop/auto-public-path/1.js 89 bytes [built] [code generated]
+@openmrs/esm-offline:build:       ../../../node_modules/systemjs-webpack-interop/auto-public-path/auto-public-path.js 846 bytes [built] [code generated]
+@openmrs/esm-offline:build:       ../../../node_modules/systemjs-webpack-interop/public-path.js 2.36 KiB [built] [code generated]
+@openmrs/esm-offline:build:     ./src/index.ts + 16 modules 149 KiB [built] [code generated]
+@openmrs/esm-offline:build:     ../../../node_modules/regenerator-runtime/runtime.js 24.3 KiB [built] [code generated]
+@openmrs/esm-offline:build:   modules by path external "@openmrs/ 84 bytes
+@openmrs/esm-offline:build:     external "@openmrs/esm-api" 42 bytes [built] [code generated]
+@openmrs/esm-offline:build:     external "@openmrs/esm-state" 42 bytes [built] [code generated]
+@openmrs/esm-offline:build: webpack 5.70.0 compiled successfully in 10780 ms

package/.turbo/turbo-lint.log

@@ -0,0 +1,2 @@
+@openmrs/esm-offline:lint: cache hit, replaying output ea6024db99e36a2e
+@openmrs/esm-offline:lint: $ eslint src --ext ts,tsx

package/.turbo/turbo-test.log

@@ -0,0 +1,123 @@
+@openmrs/esm-offline:test: cache hit, replaying output 1a48812f0c130a46
+@openmrs/esm-offline:test: $ jest --config jest.config.js --passWithNoTests
+@openmrs/esm-offline:test: PASS src/sync.test.ts (14.915 s)
+@openmrs/esm-offline:test: PASS src/dynamic-offline-data.test.ts (16.473 s)
+@openmrs/esm-offline:test:   ● Console
+@openmrs/esm-offline:test: 
+@openmrs/esm-offline:test:     console.warn
+@openmrs/esm-offline:test:       The query {"type":"test","users":"00000000-0000-0000-0000-000000000000"} on dynamicOfflineData would benefit of a compound index [type+users]
+@openmrs/esm-offline:test: 
+@openmrs/esm-offline:test:       149 |   const db = new OfflineDb();
+@openmrs/esm-offline:test:       150 |   return await db.dynamicOfflineData
+@openmrs/esm-offline:test:     > 151 |     .where(filter)
+@openmrs/esm-offline:test:           |      ^
+@openmrs/esm-offline:test:       152 |     .toArray()
+@openmrs/esm-offline:test:       153 |     .catch(Dexie.errnames.DatabaseClosed, () => []);
+@openmrs/esm-offline:test:       154 | }
+@openmrs/esm-offline:test: 
+@openmrs/esm-offline:test:       at Table.Object.<anonymous>.Table.where (../../../node_modules/dexie/src/classes/table/table.ts:118:42)
+@openmrs/esm-offline:test:       at where (src/dynamic-offline-data.ts:151:6)
+@openmrs/esm-offline:test:       at Object.getDynamicOfflineDataEntriesFor [as getDynamicOfflineDataEntries] (src/dynamic-offline-data.ts:135:16)
+@openmrs/esm-offline:test:       at Object.<anonymous> (src/dynamic-offline-data.test.ts:28:21)
+@openmrs/esm-offline:test: 
+@openmrs/esm-offline:test:     console.warn
+@openmrs/esm-offline:test:       The query {"type":"test","users":"00000000-0000-0000-0000-000000000000"} on dynamicOfflineData would benefit of a compound index [type+users]
+@openmrs/esm-offline:test: 
+@openmrs/esm-offline:test:       149 |   const db = new OfflineDb();
+@openmrs/esm-offline:test:       150 |   return await db.dynamicOfflineData
+@openmrs/esm-offline:test:     > 151 |     .where(filter)
+@openmrs/esm-offline:test:           |      ^
+@openmrs/esm-offline:test:       152 |     .toArray()
+@openmrs/esm-offline:test:       153 |     .catch(Dexie.errnames.DatabaseClosed, () => []);
+@openmrs/esm-offline:test:       154 | }
+@openmrs/esm-offline:test: 
+@openmrs/esm-offline:test:       at Table.Object.<anonymous>.Table.where (../../../node_modules/dexie/src/classes/table/table.ts:118:42)
+@openmrs/esm-offline:test:       at where (src/dynamic-offline-data.ts:151:6)
+@openmrs/esm-offline:test:       at Object.getDynamicOfflineDataEntriesFor [as getDynamicOfflineDataEntries] (src/dynamic-offline-data.ts:135:16)
+@openmrs/esm-offline:test:       at Object.<anonymous> (src/dynamic-offline-data.test.ts:39:21)
+@openmrs/esm-offline:test: 
+@openmrs/esm-offline:test:     console.warn
+@openmrs/esm-offline:test:       The query {"type":"test","users":"user-id-1"} on dynamicOfflineData would benefit of a compound index [type+users]
+@openmrs/esm-offline:test: 
+@openmrs/esm-offline:test:       149 |   const db = new OfflineDb();
+@openmrs/esm-offline:test:       150 |   return await db.dynamicOfflineData
+@openmrs/esm-offline:test:     > 151 |     .where(filter)
+@openmrs/esm-offline:test:           |      ^
+@openmrs/esm-offline:test:       152 |     .toArray()
+@openmrs/esm-offline:test:       153 |     .catch(Dexie.errnames.DatabaseClosed, () => []);
+@openmrs/esm-offline:test:       154 | }
+@openmrs/esm-offline:test: 
+@openmrs/esm-offline:test:       at Table.Object.<anonymous>.Table.where (../../../node_modules/dexie/src/classes/table/table.ts:118:42)
+@openmrs/esm-offline:test:       at Object.where [as getDynamicOfflineDataEntriesFor] (src/dynamic-offline-data.ts:151:6)
+@openmrs/esm-offline:test:       at Object.<anonymous> (src/dynamic-offline-data.test.ts:47:79)
+@openmrs/esm-offline:test: 
+@openmrs/esm-offline:test:     console.warn
+@openmrs/esm-offline:test:       The query {"type":"test","identifier":"123","users":"00000000-0000-0000-0000-000000000000"} on dynamicOfflineData would benefit of a compound index [type+identifier+users]
+@openmrs/esm-offline:test: 
+@openmrs/esm-offline:test:       233 |   const db = new OfflineDb();
+@openmrs/esm-offline:test:       234 |   const existingEntry = await db.dynamicOfflineData
+@openmrs/esm-offline:test:     > 235 |     .get({
+@openmrs/esm-offline:test:           |      ^
+@openmrs/esm-offline:test:       236 |       type,
+@openmrs/esm-offline:test:       237 |       identifier,
+@openmrs/esm-offline:test:       238 |       users: userId,
+@openmrs/esm-offline:test: 
+@openmrs/esm-offline:test:       at Table.Object.<anonymous>.Table.where (../../../node_modules/dexie/src/classes/table/table.ts:118:42)
+@openmrs/esm-offline:test:       at Table.Object.<anonymous>.Table.get (../../../node_modules/dexie/src/classes/table/table.ts:77:19)
+@openmrs/esm-offline:test:       at get (src/dynamic-offline-data.ts:235:6)
+@openmrs/esm-offline:test:       at Object.removeDynamicOfflineDataFor [as removeDynamicOfflineData] (src/dynamic-offline-data.ts:218:16)
+@openmrs/esm-offline:test:       at Object.<anonymous> (src/dynamic-offline-data.test.ts:56:5)
+@openmrs/esm-offline:test: 
+@openmrs/esm-offline:test:     console.warn
+@openmrs/esm-offline:test:       The query {"type":"test","users":"00000000-0000-0000-0000-000000000000"} on dynamicOfflineData would benefit of a compound index [type+users]
+@openmrs/esm-offline:test: 
+@openmrs/esm-offline:test:       149 |   const db = new OfflineDb();
+@openmrs/esm-offline:test:       150 |   return await db.dynamicOfflineData
+@openmrs/esm-offline:test:     > 151 |     .where(filter)
+@openmrs/esm-offline:test:           |      ^
+@openmrs/esm-offline:test:       152 |     .toArray()
+@openmrs/esm-offline:test:       153 |     .catch(Dexie.errnames.DatabaseClosed, () => []);
+@openmrs/esm-offline:test:       154 | }
+@openmrs/esm-offline:test: 
+@openmrs/esm-offline:test:       at Table.Object.<anonymous>.Table.where (../../../node_modules/dexie/src/classes/table/table.ts:118:42)
+@openmrs/esm-offline:test:       at where (src/dynamic-offline-data.ts:151:6)
+@openmrs/esm-offline:test:       at Object.getDynamicOfflineDataEntriesFor [as getDynamicOfflineDataEntries] (src/dynamic-offline-data.ts:135:16)
+@openmrs/esm-offline:test:       at Object.<anonymous> (src/dynamic-offline-data.test.ts:57:21)
+@openmrs/esm-offline:test: 
+@openmrs/esm-offline:test:     console.warn
+@openmrs/esm-offline:test:       The query {"type":"test","identifier":"123","users":"user-id-1"} on dynamicOfflineData would benefit of a compound index [type+identifier+users]
+@openmrs/esm-offline:test: 
+@openmrs/esm-offline:test:       233 |   const db = new OfflineDb();
+@openmrs/esm-offline:test:       234 |   const existingEntry = await db.dynamicOfflineData
+@openmrs/esm-offline:test:     > 235 |     .get({
+@openmrs/esm-offline:test:           |      ^
+@openmrs/esm-offline:test:       236 |       type,
+@openmrs/esm-offline:test:       237 |       identifier,
+@openmrs/esm-offline:test:       238 |       users: userId,
+@openmrs/esm-offline:test: 
+@openmrs/esm-offline:test:       at Table.Object.<anonymous>.Table.where (../../../node_modules/dexie/src/classes/table/table.ts:118:42)
+@openmrs/esm-offline:test:       at Table.Object.<anonymous>.Table.get (../../../node_modules/dexie/src/classes/table/table.ts:77:19)
+@openmrs/esm-offline:test:       at Object.get [as removeDynamicOfflineDataFor] (src/dynamic-offline-data.ts:235:6)
+@openmrs/esm-offline:test:       at Object.<anonymous> (src/dynamic-offline-data.test.ts:64:66)
+@openmrs/esm-offline:test: 
+@openmrs/esm-offline:test:     console.warn
+@openmrs/esm-offline:test:       The query {"type":"test","users":"user-id-2"} on dynamicOfflineData would benefit of a compound index [type+users]
+@openmrs/esm-offline:test: 
+@openmrs/esm-offline:test:       149 |   const db = new OfflineDb();
+@openmrs/esm-offline:test:       150 |   return await db.dynamicOfflineData
+@openmrs/esm-offline:test:     > 151 |     .where(filter)
+@openmrs/esm-offline:test:           |      ^
+@openmrs/esm-offline:test:       152 |     .toArray()
+@openmrs/esm-offline:test:       153 |     .catch(Dexie.errnames.DatabaseClosed, () => []);
+@openmrs/esm-offline:test:       154 | }
+@openmrs/esm-offline:test: 
+@openmrs/esm-offline:test:       at Table.Object.<anonymous>.Table.where (../../../node_modules/dexie/src/classes/table/table.ts:118:42)
+@openmrs/esm-offline:test:       at Object.where [as getDynamicOfflineDataEntriesFor] (src/dynamic-offline-data.ts:151:6)
+@openmrs/esm-offline:test:       at Object.<anonymous> (src/dynamic-offline-data.test.ts:66:79)
+@openmrs/esm-offline:test: 
+@openmrs/esm-offline:test: 
+@openmrs/esm-offline:test: Test Suites: 2 passed, 2 total
+@openmrs/esm-offline:test: Tests:       14 passed, 14 total
+@openmrs/esm-offline:test: Snapshots:   0 total
+@openmrs/esm-offline:test: Time:        20.647 s
+@openmrs/esm-offline:test: Ran all test suites.

package/.turbo/turbo-typescript.log

@@ -0,0 +1,2 @@
+@openmrs/esm-offline:typescript: cache hit, replaying output 7455ab648603336c
+@openmrs/esm-offline:typescript: $ tsc

package/dist/dynamic-offline-data.d.ts

@@ -0,0 +1,156 @@
+/**
+ * A handler for synchronizing dynamically declared offline data.
+ * Can be setup using the {@link setupDynamicOfflineDataHandler} function.
+ */
+export interface DynamicOfflineDataHandler {
+    /**
+     * A string uniquely identifying the handler.
+     */
+    id: string;
+    /**
+     * The type of offline data handled by this handler.
+     * See {@link DynamicOfflineData.type} for details.
+     */
+    type: string;
+    /**
+     * A human-readable string representing the handler.
+     * If provided, the handler can be rendered in the UI using that string.
+     */
+    displayName?: string;
+    /**
+     * Evaluates whether the given offline data is correctly synced at this point in time from the perspective
+     * of this single handler.
+     * If `false`, the handler would have to (re-)sync the data in order for offline mode to properly work.
+     * @param identifier The identifier of the offline data. See {@link DynamicOfflineData} for details.
+     * @param abortSignal An {@link AbortSignal} which can be used to cancel the operation.
+     */
+    isSynced(identifier: string, abortSignal?: AbortSignal): Promise<boolean>;
+    /**
+     * Synchronizes the given offline data.
+     * @param identifier The identifier of the offline data. See {@link DynamicOfflineData} for details.
+     * @param abortSignal An {@link AbortSignal} which can be used to cancel the operation.
+     */
+    sync(identifier: string, abortSignal?: AbortSignal): Promise<void>;
+}
+/**
+ * Represents the registration of a single dynamic offline data entry.
+ */
+export interface DynamicOfflineData {
+    /**
+     * The internal ID of the data entry, as assigned by the IndexedDB where it is stored.
+     */
+    id?: number;
+    /**
+     * The underlying type used for categorizing the data entry.
+     * Examples could be `"patient"` or `"form"`.
+     */
+    type: string;
+    /**
+     * The externally provided identifier of the data entry.
+     * This is typically the ID of the resource as assigned by a remote API.
+     */
+    identifier: string;
+    /**
+     * The UUIDs of the users who need this data entry available offline.
+     */
+    users: Array<string>;
+    /**
+     * If this entry has already been synced, returns the result of that last sync attempt.
+     * Otherwise this is `undefined`.
+     */
+    syncState?: DynamicOfflineDataSyncState;
+}
+/**
+ * Represents the result of syncing a given {@link DynamicOfflineData} entry.
+ */
+export interface DynamicOfflineDataSyncState {
+    /**
+     * The time when the entry has been synced the last time.
+     */
+    syncedOn: Date;
+    /**
+     * The ID of the user who has triggered the data synchronization.
+     */
+    syncedBy: string;
+    /**
+     * The IDs of the handlers which successfully synchronized their data.
+     */
+    succeededHandlers: Array<string>;
+    /**
+     * The IDs of the handlers which failed to synchronize their data.
+     */
+    erroredHandlers: Array<string>;
+    /**
+     * A collection of the errors caught while synchronizing, per handler.
+     */
+    errors: Array<{
+        handlerId: string;
+        message: string;
+    }>;
+}
+/**
+ * Returns all handlers which have been setup using the {@link setupDynamicOfflineDataHandler} function.
+ */
+export declare function getDynamicOfflineDataHandlers(): DynamicOfflineDataHandler[];
+/**
+ * Sets up a handler for synchronizing dynamic offline data.
+ * See {@link DynamicOfflineDataHandler} for details.
+ * @param handler The handler to be setup.
+ */
+export declare function setupDynamicOfflineDataHandler(handler: DynamicOfflineDataHandler): void;
+/**
+ * Returns all {@link DynamicOfflineData} entries which registered for the currently logged in user.
+ * Optionally returns only entries of a given type.
+ * @param type The type of the entries to be returned. If `undefined`, returns all types.
+ */
+export declare function getDynamicOfflineDataEntries(type?: string): Promise<Array<DynamicOfflineData>>;
+/**
+ * Returns all {@link DynamicOfflineData} entries which registered for the given user.
+ * Optionally returns only entries of a given type.
+ * @param userId The ID of the user whose entries are to be retrieved.
+ * @param type The type of the entries to be returned. If `undefined`, returns all types.
+ */
+export declare function getDynamicOfflineDataEntriesFor(userId: string, type?: string): Promise<Array<DynamicOfflineData>>;
+/**
+ * Declares that dynamic offline data of the given {@link type} with the given {@link identifier}
+ * should be made available offline for the currently logged in user.
+ * @param type The type of the offline data. See {@link DynamicOfflineData} for details.
+ * @param identifier The identifier of the offline data. See {@link DynamicOfflineData} for details.
+ */
+export declare function putDynamicOfflineData(type: string, identifier: string): Promise<void>;
+/**
+ * Declares that dynamic offline data of the given {@link type} with the given {@link identifier}
+ * should be made available offline for the user with the given ID.
+ * @param userId The ID of the user for whom the dynamic offline data should be made available.
+ * @param type The type of the offline data. See {@link DynamicOfflineData} for details.
+ * @param identifier The identifier of the offline data. See {@link DynamicOfflineData} for details.
+ */
+export declare function putDynamicOfflineDataFor(userId: string, type: string, identifier: string): Promise<void>;
+/**
+ * Declares that dynamic offline data of the given {@link type} with the given {@link identifier}
+ * no longer needs to be available offline for the currently logged in user.
+ * @param type The type of the offline data. See {@link DynamicOfflineData} for details.
+ * @param identifier The identifier of the offline data. See {@link DynamicOfflineData} for details.
+ */
+export declare function removeDynamicOfflineData(type: string, identifier: string): Promise<void>;
+/**
+ * Declares that dynamic offline data of the given {@link type} with the given {@link identifier}
+ * no longer needs to be available offline for the user with the given ID.
+ * @param userId The ID of the user who doesn't require the specified offline data.
+ * @param type The type of the offline data. See {@link DynamicOfflineData} for details.
+ * @param identifier The identifier of the offline data. See {@link DynamicOfflineData} for details.
+ */
+export declare function removeDynamicOfflineDataFor(userId: string, type: string, identifier: string): Promise<void>;
+/**
+ * Synchronizes all offline data entries of the given {@link type} for the currently logged in user.
+ * @param type The type of the offline data. See {@link DynamicOfflineData} for details.
+ * @param abortSignal An {@link AbortSignal} which can be used to cancel the operation.
+ */
+export declare function syncAllDynamicOfflineData(type: string, abortSignal?: AbortSignal): Promise<void>;
+/**
+ * Synchronizes a single offline data entry of the given {@link type} for the currently logged in user.
+ * @param type The type of the offline data. See {@link DynamicOfflineData} for details.
+ * @param identifier The identifier of the offline data. See {@link DynamicOfflineData} for details.
+ * @param abortSignal An {@link AbortSignal} which can be used to cancel the operation.
+ */
+export declare function syncDynamicOfflineData(type: string, identifier: string, abortSignal?: AbortSignal): Promise<void>;

package/dist/dynamic-offline-data.test.d.ts

@@ -0,0 +1 @@
+import "fake-indexeddb/auto";

package/dist/index.d.ts

@@ -0,0 +1,9 @@
+export * from "./service-worker";
+export * from "./service-worker-http-headers";
+export * from "./service-worker-messaging";
+export * from "./mode";
+export * from "./sync";
+export * from "./uuid";
+export * from "./offline-patient-data";
+export * from "./dynamic-offline-data";
+export { getOfflineDb } from "./offline-db";

package/dist/mode.d.ts

@@ -0,0 +1,10 @@
+/** @module @category Offline */
+export declare type OfflineMode = "on" | "off" | "unavailable";
+export interface OfflineModeResult {
+    current: OfflineMode;
+    notAvailable: boolean;
+    active: boolean;
+}
+export declare function getCurrentOfflineMode(): OfflineModeResult;
+export declare function setCurrentOfflineMode(mode: OfflineMode): void;
+export declare function activateOfflineCapability(): Promise<void>;

package/dist/offline-db.d.ts

@@ -0,0 +1,20 @@
+import Dexie, { Table } from "dexie";
+import { DynamicOfflineData } from "./dynamic-offline-data";
+import { SyncItem } from "./sync";
+/**
+ * Accesses the central IndexedDB used by the `esm-offline` module to persist offline related state.
+ * Leverages the `dexie` library for IndexedDB management.
+ */
+export declare class OfflineDb extends Dexie {
+    /**
+     * The table used to store the data of the offline synchronization queue (aka "sync queue" / "offline actions").
+     */
+    syncQueue: Table<SyncItem, number>;
+    dynamicOfflineData: Table<DynamicOfflineData, number>;
+    constructor();
+}
+/**
+ * @internal Temporarily added for esm-offline-tools-app and workarounds. Please don't use elsewhere.
+ * @deprecated Should/Will be removed in the future per the above reason.
+ */
+export declare function getOfflineDb(): OfflineDb;

package/dist/offline-patient-data.d.ts

@@ -0,0 +1,30 @@
+/** @deprecated Will be removed once all modules have been migrated to the new dynamic offline data API. */
+export interface OfflinePatientDataSyncStore {
+    offlinePatientDataSyncState: Record<string, OfflinePatientDataSyncState>;
+    handlers: Record<string, OfflinePatientDataSyncHandler>;
+}
+/** @deprecated Will be removed once all modules have been migrated to the new dynamic offline data API. */
+export interface OfflinePatientDataSyncState {
+    readonly timestamp: Date;
+    readonly syncingHandlers: Array<string>;
+    readonly syncedHandlers: Array<string>;
+    readonly failedHandlers: Array<string>;
+    readonly errors: Record<string, string>;
+    abort(): boolean;
+}
+/** @deprecated Will be removed once all modules have been migrated to the new dynamic offline data API. */
+export interface OfflinePatientDataSyncHandler {
+    readonly displayName: string;
+    onOfflinePatientAdded(args: OfflinePatientArgs): Promise<void>;
+}
+/** @deprecated Will be removed once all modules have been migrated to the new dynamic offline data API. */
+export interface OfflinePatientArgs {
+    patientUuid: string;
+    signal: AbortSignal;
+}
+/** @deprecated Will be removed once all modules have been migrated to the new dynamic offline data API. */
+export declare function getOfflinePatientDataStore(): import("unistore").Store<OfflinePatientDataSyncStore>;
+/** @deprecated Will be removed once all modules have been migrated to the new dynamic offline data API. */
+export declare function registerOfflinePatientHandler(identifier: string, handler: OfflinePatientDataSyncHandler): void;
+/** @deprecated Will be removed once all modules have been migrated to the new dynamic offline data API. */
+export declare function syncOfflinePatientData(patientUuid: string): Promise<void>;

package/dist/public.d.ts

@@ -0,0 +1,8 @@
+export { OfflineMode, OfflineModeResult, getCurrentOfflineMode } from "./mode";
+export * from "./offline-patient-data";
+export * from "./service-worker-messaging";
+export * from "./service-worker-http-headers";
+export * from "./uuid";
+export { QueueItemDescriptor, SyncItem, SyncProcessOptions, queueSynchronizationItem, getSynchronizationItem, getSynchronizationItems, getFullSynchronizationItems, getFullSynchronizationItemsFor, canBeginEditSynchronizationItemsOfType, beginEditSynchronizationItem, deleteSynchronizationItem, setupOfflineSync, } from "./sync";
+export * from "./dynamic-offline-data";
+export { getOfflineDb } from "./offline-db";

package/dist/service-worker-http-headers.d.ts

@@ -0,0 +1,36 @@
+/** @module @category Offline */
+export declare const omrsOfflineResponseBodyHttpHeaderName = "x-omrs-offline-response-body";
+export declare const omrsOfflineResponseStatusHttpHeaderName = "x-omrs-offline-response-status";
+export declare const omrsOfflineCachingStrategyHttpHeaderName = "x-omrs-offline-caching-strategy";
+/**
+ *
+ *
+ * * `cache-or-network`: The default strategy, equal to the absence of this header.
+ *   The SW attempts to resolve the request via the network, but falls back to the cache if required.
+ *   The service worker decides the strategy to be used.
+ * * `network-first`: See https://developers.google.com/web/tools/workbox/modules/workbox-strategies#network_first_network_falling_back_to_cache.
+ */
+export declare type OmrsOfflineCachingStrategy = "network-only-or-cache-only" | "network-first";
+/**
+ * Defines the keys of the custom headers which can be appended to an HTTP request.
+ * HTTP requests with these headers are handled in a special way by the SPA's service worker.
+ */
+export declare type OmrsOfflineHttpHeaders = {
+    /**
+     * If the client is offline and the request cannot be read from the cache (i.e. if there is no way
+     * to receive any kind of data for this request), the service worker will return a response with
+     * the body in this header.
+     */
+    [omrsOfflineResponseBodyHttpHeaderName]?: string;
+    /**
+     * If the client is offline and the request cannot be read from the cache (i.e. if there is no way
+     * to receive any kind of data for this request), the service worker will return a response with
+     * the status code defined in this header.
+     */
+    [omrsOfflineResponseStatusHttpHeaderName]?: `${number}`;
+    /**
+     * Instructs the service worker to use a specific caching strategy for this request.
+     */
+    [omrsOfflineCachingStrategyHttpHeaderName]?: OmrsOfflineCachingStrategy;
+};
+export declare type OmrsOfflineHttpHeaderNames = keyof OmrsOfflineHttpHeaders;

package/dist/service-worker-messaging.d.ts

@@ -0,0 +1,28 @@
+/** @module @category Offline */
+import type { ImportMap } from "@openmrs/esm-globals";
+import { OmrsOfflineCachingStrategy } from "./service-worker-http-headers";
+/**
+ * Sends the specified message to the application's service worker.
+ * @param message The message to be sent.
+ * @returns A promise which completes when the message has been successfully processed by the Service Worker.
+ */
+export declare function messageOmrsServiceWorker(message: KnownOmrsServiceWorkerMessages): Promise<MessageServiceWorkerResult<any>>;
+export interface OmrsServiceWorkerMessage<MessageTypeTypeIdentifier extends string> {
+    type: MessageTypeTypeIdentifier;
+}
+export interface OnImportMapChangedMessage extends OmrsServiceWorkerMessage<"onImportMapChanged"> {
+    importMap: ImportMap;
+}
+export interface ClearDynamicRoutesMessage extends OmrsServiceWorkerMessage<"clearDynamicRoutes"> {
+}
+export interface RegisterDynamicRouteMessage extends OmrsServiceWorkerMessage<"registerDynamicRoute"> {
+    pattern?: string;
+    url?: string;
+    strategy?: OmrsOfflineCachingStrategy;
+}
+export declare type KnownOmrsServiceWorkerMessages = OnImportMapChangedMessage | ClearDynamicRoutesMessage | RegisterDynamicRouteMessage;
+export interface MessageServiceWorkerResult<T> {
+    success: boolean;
+    result?: T;
+    error?: string;
+}

package/dist/service-worker.d.ts

@@ -0,0 +1,18 @@
+import { Workbox } from "workbox-window";
+/**
+ * If not yet registered, registers the application's global Service Worker.
+ * Throws if registration is not possible.
+ * @param scriptURL The service worker script associated with this instance.
+ * @param [registerOptions] The service worker options associated with this instance.
+ * @returns A promise which resolves to the registered {@link Workbox} instance which manages the SW.
+ */
+export declare function registerOmrsServiceWorker(scriptUrl: string, registerOptions?: object): Promise<Workbox>;
+/**
+ * If a service worker has been registered, returns a promise that resolves to a {@link Workbox}
+ * instance which is used by the application to manage that service worker.
+ *
+ * If no service worker has been registered (e.g. when the application is built without offline specific features),
+ * returns a promise which immediately resolves to `undefined`.
+ * @returns A promise which either resolves to `undefined` or to the app's {@link Workbox} instance.
+ */
+export declare function getOmrsServiceWorker(): Promise<Workbox | undefined>;

package/dist/sync.d.ts

@@ -0,0 +1,151 @@
+/**
+ * Defines an item queued up in the offline synchronization queue.
+ * A `SyncItem` contains both meta information about the item in the sync queue, as well as the
+ * actual data to be synchronized (i.e. the item's `content`).
+ */
+export interface SyncItem<T = any> {
+    id?: number;
+    userId: string;
+    type: string;
+    content: T;
+    createdOn: Date;
+    descriptor: QueueItemDescriptor;
+    lastError?: {
+        name?: string;
+        message?: string;
+    };
+}
+/**
+ * Contains information about the sync item which has been provided externally by the caller
+ * who added the item to the queue.
+ * This information is all optional, but, when provided while enqueuing the item, can be used in other
+ * locations to better represent the sync item, e.g. in the UI.
+ */
+export interface QueueItemDescriptor {
+    id?: string;
+    dependencies?: Array<{
+        id: string;
+        type: string;
+    }>;
+    patientUuid?: string;
+    displayName?: string;
+}
+/**
+ * A function which, when invoked, performs the actual client-server synchronization of the given
+ * `item` (which is the actual data to be synchronized).
+ * The function receives additional `options` which provide additional data that can be used
+ * for synchronizing.
+ */
+export declare type ProcessSyncItem<T> = (item: T, options: SyncProcessOptions<T>) => Promise<any>;
+/**
+ * Additional data which can be used for synchronizing data in a {@link ProcessSyncItem} function.
+ */
+export interface SyncProcessOptions<T> {
+    abort: AbortController;
+    userId: string;
+    index: number;
+    items: Array<T>;
+    dependencies: Array<any>;
+}
+/**
+ * Defines additional options which can optionally be provided when setting up a synchronization callback
+ * for a specific synchronization item type.
+ * These are not required, but, when set, allow further
+ */
+interface SetupOfflineSyncOptions<T> {
+    /**
+     * Invoked when the user requests to edit a sync item.
+     * The typical behavior for such a callback is to launch a UI which allows editing the content
+     * encapsulated by the sync item.
+     * @param syncItem The sync item to be edited.
+     */
+    onBeginEditSyncItem?(syncItem: SyncItem<T>): void;
+}
+/**
+ * Represents the data inside the global offline synchronization store.
+ * Provides information about a currently ongoing synchronization.
+ */
+export interface OfflineSynchronizationStore {
+    synchronization?: {
+        totalCount: number;
+        pendingCount: number;
+        abortController: AbortController;
+    };
+}
+export declare function getOfflineSynchronizationStore(): import("unistore").Store<OfflineSynchronizationStore>;
+/**
+ * Runs a full synchronization of **all** queued synchronization items.
+ */
+export declare function runSynchronization(): Promise<void>;
+/**
+ * Enqueues a new item in the sync queue for a specific user.
+ * @param userId The user with whom the sync item should be associated with.
+ * @param type The identifying type of the synchronization item.
+ * @param content The actual data to be synchronized.
+ * @param descriptor An optional descriptor providing additional metadata about the sync item.
+ */
+export declare function queueSynchronizationItemFor<T>(userId: string, type: string, content: T, descriptor?: QueueItemDescriptor): Promise<number>;
+/**
+ * Enqueues a new item in the sync queue and associates the item with the currently signed in user.
+ * @param type The identifying type of the synchronization item.
+ * @param content The actual data to be synchronized.
+ * @param descriptor An optional descriptor providing additional metadata about the sync item.
+ */
+export declare function queueSynchronizationItem<T>(type: string, content: T, descriptor?: QueueItemDescriptor): Promise<number>;
+/**
+ * Returns the content of all currently queued up sync items of a given user.
+ * @param userId The ID of the user whose synchronization items should be returned.
+ * @param type The identifying type of the synchronization items to be returned..
+ */
+export declare function getSynchronizationItemsFor<T>(userId: string, type?: string): Promise<T[]>;
+/**
+ * Returns all currently queued up sync items of a given user.
+ * @param userId The ID of the user whose synchronization items should be returned.
+ * @param type The identifying type of the synchronization items to be returned..
+ */
+export declare function getFullSynchronizationItemsFor<T>(userId: string, type?: string): Promise<Array<SyncItem<T>>>;
+/**
+ * Returns the content of all currently queued up sync items of the currently signed in user.
+ * @param type The identifying type of the synchronization items to be returned.
+ */
+export declare function getSynchronizationItems<T>(type?: string): Promise<T[]>;
+/**
+ * Returns all currently queued up sync items of the currently signed in user.
+ * @param type The identifying type of the synchronization items to be returned.
+ */
+export declare function getFullSynchronizationItems<T>(type?: string): Promise<SyncItem<T>[]>;
+/**
+ * Returns a queued sync item with the given ID or `undefined` if no such item exists.
+ * @param id The ID of the requested sync item.
+ */
+export declare function getSynchronizationItem<T = any>(id: number): Promise<SyncItem<T> | undefined>;
+/**
+ * Returns whether editing synchronization items of the given type is supported by the currently
+ * registered synchronization handlers.
+ * @param type The identifying type of the synchronization item which should be edited.
+ */
+export declare function canBeginEditSynchronizationItemsOfType(type: string): boolean;
+/**
+ * Triggers an edit flow for the given synchronization item.
+ * If this is not possible, throws an error.
+ * @param id The ID of the synchronization item to be edited.
+ */
+export declare function beginEditSynchronizationItem(id: number): Promise<void>;
+/**
+ * Deletes a queued up sync item with the given ID.
+ * @param id The ID of the synchronization item to be deleted.
+ */
+export declare function deleteSynchronizationItem(id: number): Promise<void>;
+/**
+ * Registers a new synchronization handler which is able to synchronize data of a specific type.
+ * @param type The identifying type of the synchronization items which can be handled by this handler.
+ * @param dependsOn An array of other sync item types which must be synchronized before this handler
+ *   can synchronize its own data. Items of these types are effectively dependencies of the data
+ *   synchronized by this handler.
+ * @param process A function which, when invoked, performs the actual client-server synchronization of the given
+ *   `item` (which is the actual data to be synchronized).
+ * @param options Additional options which can optionally be provided when setting up a synchronization callback
+ *   for a specific synchronization item type.
+ */
+export declare function setupOfflineSync<T>(type: string, dependsOn: Array<string>, process: ProcessSyncItem<T>, options?: SetupOfflineSyncOptions<T>): void;
+export {};

package/dist/sync.test.d.ts

@@ -0,0 +1 @@
+import "fake-indexeddb/auto";

package/dist/uuid.d.ts

@@ -0,0 +1,5 @@
+export declare const offlineUuidPrefix = "OFFLINE+";
+/** Generates a UUID-like string which is used for uniquely identifying objects while offline. */
+export declare function generateOfflineUuid(): string;
+/** Checks whether the given string has the format of an offline UUID generated by {@link generateOfflineUuid} */
+export declare function isOfflineUuid(uuid: string): boolean;

package/jest.config.js

@@ -4,5 +4,9 @@ module.exports = {
   },
   moduleNameMapper: {
     "lodash-es": "lodash",
+    // See https://jestjs.io/docs/upgrading-to-jest28#packagejson-exports
+    // which links to https://github.com/microsoft/accessibility-insights-web/pull/5421#issuecomment-1109168149
+    "^dexie$": require.resolve("dexie"),
   },
+  testEnvironment: "jsdom",
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openmrs/esm-offline",
-  "version": "3.4.1-pre.96",
+  "version": "4.0.0-pre.1",
   "license": "MPL-2.0",
   "description": "Helper utilities for OpenMRS",
   "browser": "dist/openmrs-esm-offline.js",
@@ -36,18 +36,18 @@
     "access": "public"
   },
   "devDependencies": {
-    "@openmrs/esm-api": "^3.4.1-pre.96",
-    "@openmrs/esm-globals": "^3.4.1-pre.96",
-    "@openmrs/esm-state": "^3.4.1-pre.96",
-    "@openmrs/esm-styleguide": "^3.4.1-pre.96",
+    "@openmrs/esm-api": "^4.0.0-pre.1",
+    "@openmrs/esm-globals": "^4.0.0-pre.1",
+    "@openmrs/esm-state": "^4.0.0-pre.1",
+    "@openmrs/esm-styleguide": "^4.0.0-pre.1",
     "@types/uuid": "^8.3.0",
     "rxjs": "^6.5.3"
   },
   "peerDependencies": {
-    "@openmrs/esm-api": "3.x",
-    "@openmrs/esm-globals": "3.x",
-    "@openmrs/esm-state": "3.x",
-    "@openmrs/esm-styleguide": "3.x",
+    "@openmrs/esm-api": "4.x",
+    "@openmrs/esm-globals": "4.x",
+    "@openmrs/esm-state": "4.x",
+    "@openmrs/esm-styleguide": "4.x",
     "rxjs": "6.x"
   },
   "dependencies": {
@@ -56,5 +56,5 @@
     "uuid": "^8.3.2",
     "workbox-window": "^6.1.5"
   },
-  "gitHead": "593214cd88408e07e9c18eab4c204be4a3722c73"
+  "gitHead": "9f58b801f07526083a9edc1cc5a1e58660d71eb0"
 }

package/src/sync.test.ts

@@ -43,7 +43,7 @@ describe("Sync Queue", () => {
   beforeAll(() => {
     // We want to control the timers to ensure that we can test the `createdOn` attribute
     // of the sync item (which is created using `new Date()`).
-    jest.useFakeTimers("modern");
+    jest.useFakeTimers();
     jest.setSystemTime(systemTime);
   });