@pushwoosh/spa-context 1.0.0

package/SimpleEventEmitter.d.ts

@@ -0,0 +1,11 @@
+type Listener<T> = (payload: T) => void;
+export declare class SimpleEventEmitter {
+    private listeners;
+    private lastPayloads;
+    on<T>(eventName: string, fn: Listener<T>, callImmediately?: boolean): () => void;
+    off<T>(eventName: string, fn: Listener<T>): void;
+    emit<T>(eventName: string, payload: T): void;
+    getLastPayload<T>(eventName: string): T | undefined;
+    clear(eventName?: string): void;
+}
+export {};

package/SimpleEventEmitter.js

@@ -0,0 +1,43 @@
+export class SimpleEventEmitter {
+  listeners = {};
+  lastPayloads = {};
+  on(eventName, fn, callImmediately) {
+    if (!this.listeners[eventName]) {
+      this.listeners[eventName] = [];
+    }
+    this.listeners[eventName].push(fn);
+    // Call immediately with last payload if requested and available
+    if (callImmediately && eventName in this.lastPayloads) {
+      fn(this.lastPayloads[eventName]);
+    }
+    return () => {
+      this.off(eventName, fn);
+    };
+  }
+  off(eventName, fn) {
+    if (!this.listeners[eventName]) return;
+    this.listeners[eventName] = this.listeners[eventName].filter(l => l !== fn);
+    if (this.listeners[eventName].length === 0) {
+      delete this.listeners[eventName];
+    }
+  }
+  emit(eventName, payload) {
+    // Store last payload
+    this.lastPayloads[eventName] = payload;
+    if (!this.listeners[eventName]) return;
+    // Copy to avoid reentrancy issues if a listener removes itself
+    [...this.listeners[eventName]].forEach(l => l(payload));
+  }
+  getLastPayload(eventName) {
+    return this.lastPayloads[eventName];
+  }
+  clear(eventName) {
+    if (eventName) {
+      delete this.listeners[eventName];
+      delete this.lastPayloads[eventName];
+    } else {
+      this.listeners = {};
+      this.lastPayloads = {};
+    }
+  }
+}

package/UniversalKeyValueStore.d.ts

@@ -0,0 +1,32 @@
+export type ChangeType = 'init' | 'set' | 'remove';
+export interface KeyValueChange<K extends IDBValidKey = IDBValidKey, V = unknown> {
+    key: K;
+    value: V | undefined;
+    inMemory: boolean;
+    type: ChangeType;
+}
+export interface UniversalKeyValueStoreOptions<K extends IDBValidKey = IDBValidKey> {
+    memoryKeys?: K[];
+}
+export declare class UniversalKeyValueStore<K extends IDBValidKey = IDBValidKey, V = unknown> {
+    private readonly store;
+    private readonly memoryKeySet;
+    private readonly memory;
+    private readonly emitter;
+    private constructor();
+    static initialize<K extends IDBValidKey = IDBValidKey, V = unknown>(dbName: string, tableName: string, options: UniversalKeyValueStoreOptions<K>): Promise<UniversalKeyValueStore<K, V>>;
+    private init;
+    static makeEventName(key: IDBValidKey): string;
+    private toStorageKey;
+    private isMemoryKey;
+    private emitEvent;
+    get(key: K): Promise<V | undefined>;
+    getMemory(key: K): V | undefined;
+    set(key: K, value: V): Promise<void>;
+    remove(key: K): Promise<void>;
+    getAll(): Promise<Record<string, V>>;
+    getAllMemory(): Record<string, V>;
+    subscribe(key: K, listener: (change: KeyValueChange<K, V>) => void, options?: {
+        callImmediately?: boolean;
+    }): () => void;
+}

package/UniversalKeyValueStore.js

@@ -0,0 +1,140 @@
+import { createStore, get as idbGet, set as idbSet, del as idbDel, entries as idbEntries } from 'idb-keyval';
+import { SimpleEventEmitter } from './SimpleEventEmitter';
+export class UniversalKeyValueStore {
+  store;
+  memoryKeySet;
+  memory;
+  emitter;
+  constructor(dbName, tableName, options) {
+    const {
+      memoryKeys = []
+    } = options;
+    this.store = createStore(dbName, tableName);
+    this.memoryKeySet = new Set(memoryKeys);
+    this.memory = new Map();
+    this.emitter = new SimpleEventEmitter();
+  }
+  static async initialize(dbName, tableName, options) {
+    const instance = new UniversalKeyValueStore(dbName, tableName, options);
+    await instance.init();
+    return instance;
+  }
+  async init() {
+    if (this.memoryKeySet.size > 0) {
+      for (const key of this.memoryKeySet) {
+        try {
+          const value = await idbGet(this.toStorageKey(key), this.store);
+          if (value !== undefined) {
+            this.memory.set(key, value);
+          }
+        } catch (e) {
+          console.error('Failed to init memory key from IndexedDB', {
+            key,
+            error: e
+          });
+        }
+      }
+    }
+  }
+  static makeEventName(key) {
+    return `key:${String(key)}`;
+  }
+  toStorageKey(key) {
+    return key;
+  }
+  isMemoryKey(key) {
+    return this.memoryKeySet.has(key);
+  }
+  emitEvent(eventName, payload) {
+    try {
+      this.emitter.emit(eventName, payload);
+    } catch (e) {
+      console.error('Failed to emit event', {
+        eventName,
+        payload,
+        error: e
+      });
+    }
+  }
+  async get(key) {
+    if (this.isMemoryKey(key) && this.memory.has(key)) {
+      return this.memory.get(key);
+    }
+    const value = await idbGet(this.toStorageKey(key), this.store);
+    if (this.isMemoryKey(key) && value !== undefined) {
+      this.memory.set(key, value);
+    }
+    return value;
+  }
+  getMemory(key) {
+    if (this.isMemoryKey(key)) {
+      return this.memory.get(key);
+    }
+    return undefined;
+  }
+  async set(key, value) {
+    const inMemory = this.isMemoryKey(key);
+    if (inMemory) {
+      this.memory.set(key, value);
+    }
+    const payload = {
+      key,
+      value,
+      inMemory,
+      type: 'set'
+    };
+    this.emitEvent(UniversalKeyValueStore.makeEventName(key), payload);
+    await idbSet(this.toStorageKey(key), value, this.store);
+  }
+  async remove(key) {
+    const inMemory = this.isMemoryKey(key);
+    if (inMemory) {
+      this.memory.delete(key);
+    }
+    const payload = {
+      key,
+      value: undefined,
+      inMemory,
+      type: 'remove'
+    };
+    this.emitEvent(UniversalKeyValueStore.makeEventName(key), payload);
+    await idbDel(this.toStorageKey(key), this.store);
+  }
+  async getAll() {
+    const persistentRaw = await idbEntries(this.store);
+    const persistent = {};
+    for (const [storageKey, value] of Object.entries(persistentRaw)) {
+      persistent[storageKey] = value;
+    }
+    const result = {
+      ...persistent
+    };
+    for (const [key, value] of this.memory.entries()) {
+      result[String(key)] = value;
+    }
+    return result;
+  }
+  getAllMemory() {
+    return Array.from(this.memory.entries()).reduce((acc, [key, value]) => {
+      acc[String(key)] = value;
+      return acc;
+    }, {});
+  }
+  subscribe(key, listener, options) {
+    const eventName = UniversalKeyValueStore.makeEventName(key);
+    const unsubscribe = this.emitter.on(eventName, listener, false);
+    if (options !== null && options !== void 0 && options.callImmediately) {
+      this.get(key).then(value => {
+        if (value !== undefined) {
+          listener({
+            key,
+            value,
+            inMemory: this.isMemoryKey(key),
+            type: 'init'
+          });
+        }
+      });
+    }
+    return unsubscribe;
+  }
+}

package/context.d.ts

@@ -0,0 +1,2 @@
+import { type SPAContextType } from './types';
+export declare const SPAContext: import("react").Context<SPAContextType | undefined>;

package/context.js

@@ -0,0 +1,2 @@
+import { createContext } from 'react';
+export const SPAContext = createContext(undefined);

package/index.d.ts

@@ -0,0 +1,7 @@
+import { SimpleEventEmitter } from './SimpleEventEmitter';
+import type { SPAContextType } from './types';
+import { UniversalKeyValueStore } from './UniversalKeyValueStore';
+import { useSPAContext } from './useSPAContext';
+export type { SPAContextType };
+export { useSPAContext, SimpleEventEmitter, UniversalKeyValueStore };
+export declare const SPAContextProvider: import("react").Provider<SPAContextType | undefined>;

package/index.js

@@ -0,0 +1,6 @@
+import { SPAContext } from './context';
+import { SimpleEventEmitter } from './SimpleEventEmitter';
+import { UniversalKeyValueStore } from './UniversalKeyValueStore';
+import { useSPAContext } from './useSPAContext';
+export { useSPAContext, SimpleEventEmitter, UniversalKeyValueStore };
+export const SPAContextProvider = SPAContext.Provider;

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "@pushwoosh/spa-context",
+  "main": "index.js",
+  "module": "index.js",
+  "types": "index.d.ts",
+  "sideEffects": false,
+  "scripts": {
+    "build": "pushwoosh-engine lib:build",
+    "check": "npm run check:lint && npm run check:types",
+    "check:lint": "echo \"Run check:lint\" && NODE_ENV=production eslint src",
+    "check:lint-fix": "echo \"Run check:lint\" && NODE_ENV=production eslint src --fix",
+    "check:types": "echo \"Run check:types\" && pushwoosh-engine lib:check-types"
+  },
+  "pre-commit": "check",
+  "engines": {
+    "node": ">= 22",
+    "npm": ">= 7"
+  },
+  "dependencies": {
+    "idb-keyval": "^6.2.2"
+  },
+  "devDependencies": {
+    "@pushwoosh/frontend-builder-engine": "^1.0.21",
+    "@pushwoosh/http-client": "^2.5.0",
+    "@pushwoosh/session-store": "^2.5.0",
+    "@types/react": "^18.3.27",
+    "pre-commit": "^1.2.2"
+  },
+  "peerDependencies": {
+    "@pushwoosh/http-client": "^2.5.0",
+    "@pushwoosh/rpc-gateway-journey-data": "^0.26.206",
+    "@pushwoosh/rpc-gateway-payment-data": "^0.2.135",
+    "@pushwoosh/rpc-v2-http-api-data": "^0.1.566",
+    "@pushwoosh/session-store": "^2.5.0",
+    "react": "^16.14.0 || ^18.0.0"
+  },
+  "version": "1.0.0"
+}

package/types.d.ts

@@ -0,0 +1,38 @@
+import { type History } from 'history';
+import type { GrpcClient, HttpClient, RpcClient } from '@pushwoosh/http-client';
+import type { API as RpcGatewayJourneyAPI } from '@pushwoosh/rpc-gateway-journey-data';
+import type { API as RpcGatewayPaymentAPI } from '@pushwoosh/rpc-gateway-payment-data';
+import type { API as RpcGatewayAPI } from '@pushwoosh/rpc-v2-http-api-data';
+import type { SessionStore } from '@pushwoosh/session-store';
+import type { SimpleEventEmitter } from './SimpleEventEmitter';
+import type { UniversalKeyValueStore } from './UniversalKeyValueStore';
+export type Environment = {
+    isPWI: boolean;
+    isPushwoosh: boolean;
+    isWavesend: boolean;
+    isOMO: boolean;
+};
+export type SPAContextType = {
+    readonly history: History;
+    readonly httpClient: HttpClient;
+    readonly rpcClient: RpcClient;
+    readonly grpcClient: GrpcClient;
+    readonly grpcBridge: {
+        readonly clients: {
+            readonly billingGrpcClient: GrpcClient;
+        };
+    };
+    readonly sessionStore: SessionStore;
+    readonly rpcGateway: RpcGatewayAPI;
+    readonly rpcGatewayJourney: RpcGatewayJourneyAPI;
+    readonly rpcGatewayPayment: RpcGatewayPaymentAPI;
+    readonly language: string;
+    readonly helpers: {
+        readonly getApiOrigin: (name: string) => string;
+        readonly getJsonApiUrl: (method: string) => string;
+    };
+    readonly eventBus: SimpleEventEmitter;
+    readonly environment: Environment;
+    readonly keyValueStorage: UniversalKeyValueStore;
+    readonly __smartComponentsCache: Record<string, any>;
+};

package/types.js

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

package/useSPAContext.d.ts

@@ -0,0 +1 @@
+export declare function useSPAContext(): import("./types").SPAContextType;

package/useSPAContext.js

@@ -0,0 +1,9 @@
+import { useContext } from 'react';
+import { SPAContext } from './context';
+export function useSPAContext() {
+  const contextValue = useContext(SPAContext);
+  if (!contextValue) {
+    throw new Error('useSPAContext must be used within a SPAContextProvider');
+  }
+  return contextValue;
+}