@cendarsoss/pusher-js 8.4.11

package/src/core/defaults.ts

@@ -0,0 +1,66 @@
+import {
+  ChannelAuthorizationOptions,
+  UserAuthenticationOptions,
+} from './auth/options';
+import { AuthTransport } from './config';
+
+export interface DefaultConfig {
+  VERSION: string;
+  PROTOCOL: number;
+  wsPort: number;
+  wssPort: number;
+  wsPath: string;
+  httpHost: string;
+  httpPort: number;
+  httpsPort: number;
+  httpPath: string;
+  stats_host: string;
+  authEndpoint: string;
+  authTransport: AuthTransport;
+  activityTimeout: number;
+  pongTimeout: number;
+  unavailableTimeout: number;
+  userAuthentication: UserAuthenticationOptions;
+  channelAuthorization: ChannelAuthorizationOptions;
+
+  cdn_http?: string;
+  cdn_https?: string;
+  dependency_suffix?: string;
+}
+
+var Defaults: DefaultConfig = {
+  VERSION: VERSION,
+  PROTOCOL: 7,
+
+  wsPort: 80,
+  wssPort: 443,
+  wsPath: '',
+  // DEPRECATED: SockJS fallback parameters
+  httpHost: 'sockjs.pusher.com',
+  httpPort: 80,
+  httpsPort: 443,
+  httpPath: '/pusher',
+  // DEPRECATED: Stats
+  stats_host: 'stats.pusher.com',
+  // DEPRECATED: Other settings
+  authEndpoint: '/pusher/auth',
+  authTransport: 'ajax',
+  activityTimeout: 120000,
+  pongTimeout: 30000,
+  unavailableTimeout: 10000,
+  userAuthentication: {
+    endpoint: '/pusher/user-auth',
+    transport: 'ajax',
+  },
+  channelAuthorization: {
+    endpoint: '/pusher/auth',
+    transport: 'ajax',
+  },
+
+  // CDN configuration
+  cdn_http: CDN_HTTP,
+  cdn_https: CDN_HTTPS,
+  dependency_suffix: DEPENDENCY_SUFFIX,
+};
+
+export default Defaults;

package/src/core/delta/channel_state.ts

@@ -0,0 +1,194 @@
+/**
+ * Per-channel delta state tracking with conflation key support
+ */
+
+import { CachedMessage, CacheSyncData, ChannelDeltaStats } from './types';
+
+export default class ChannelState {
+  channelName: string;
+  conflationKey: string | null;
+  maxMessagesPerKey: number;
+  conflationCaches: Map<string, CachedMessage[]>;
+
+  // Legacy single-base tracking (for non-conflation channels)
+  baseMessage: string | null;
+  baseSequence: number | null;
+  lastSequence: number | null;
+
+  // Statistics
+  deltaCount: number;
+  fullMessageCount: number;
+
+  constructor(channelName: string) {
+    this.channelName = channelName;
+    this.conflationKey = null;
+    this.maxMessagesPerKey = 10;
+    this.conflationCaches = new Map();
+
+    this.baseMessage = null;
+    this.baseSequence = null;
+    this.lastSequence = null;
+
+    this.deltaCount = 0;
+    this.fullMessageCount = 0;
+  }
+
+  /**
+   * Initialize cache from server sync
+   */
+  initializeFromCacheSync(data: CacheSyncData): void {
+    this.conflationKey = data.conflation_key || null;
+    this.maxMessagesPerKey = data.max_messages_per_key || 10;
+    this.conflationCaches.clear();
+
+    if (data.states) {
+      for (const [key, messages] of Object.entries(data.states)) {
+        const cache = messages.map((msg) => ({
+          content: msg.content,
+          sequence: msg.seq,
+        }));
+        this.conflationCaches.set(key, cache);
+      }
+    }
+  }
+
+  /**
+   * Set new base message (legacy - for non-conflation channels)
+   */
+  setBase(message: string, sequence: number): void {
+    this.baseMessage = message;
+    this.baseSequence = sequence;
+    this.lastSequence = sequence;
+  }
+
+  /**
+   * Get base message for a conflation key at specific index
+   * Note: baseIndex is the sequence number, not array index
+   */
+  getBaseMessage(
+    conflationKeyValue?: string,
+    baseIndex?: number,
+  ): string | null {
+    if (!this.conflationKey) {
+      // Legacy mode: return single base
+      return this.baseMessage;
+    }
+
+    const key = conflationKeyValue || '';
+    const cache = this.conflationCaches.get(key);
+
+    if (!cache || baseIndex === undefined) {
+      console.error('[ChannelState] No cache or baseIndex undefined', {
+        hasCache: !!cache,
+        baseIndex,
+        key,
+        allCacheKeys: Array.from(this.conflationCaches.keys()),
+      });
+      return null;
+    }
+
+    // baseIndex is actually a sequence number, not an array index
+    // Find the message with matching sequence number
+    const message = cache.find((msg) => msg.sequence === baseIndex);
+
+    if (!message) {
+      console.error('[ChannelState] Could not find message with sequence', {
+        searchingFor: baseIndex,
+        cacheSize: cache.length,
+        cacheSequences: cache.map((m) => m.sequence),
+        key: conflationKeyValue,
+      });
+      return null;
+    }
+
+    return message.content;
+  }
+
+  /**
+   * Add or update message in conflation cache
+   */
+  updateConflationCache(
+    conflationKeyValue: string | undefined,
+    message: string,
+    sequence: number,
+  ): void {
+    const key = conflationKeyValue || '';
+    let cache = this.conflationCaches.get(key);
+
+    if (!cache) {
+      cache = [];
+      this.conflationCaches.set(key, cache);
+    }
+
+    // If sequence is not greater than the last cache item, clear the cache entirely
+    if (cache.length > 0) {
+      const lastCacheItem = cache[cache.length - 1];
+      if (sequence <= lastCacheItem.sequence) {
+        cache.length = 0;
+      }
+    }
+
+    // Add message to cache
+    cache.push({ content: message, sequence });
+
+    // Enforce max size (FIFO eviction)
+    while (cache.length > this.maxMessagesPerKey) {
+      cache.shift();
+    }
+  }
+
+  /**
+   * Check if we have a valid base
+   */
+  hasBase(): boolean {
+    if (this.conflationKey) {
+      return this.conflationCaches.size > 0;
+    }
+    return this.baseMessage !== null && this.baseSequence !== null;
+  }
+
+  /**
+   * Validate sequence number
+   */
+  isValidSequence(sequence: number): boolean {
+    if (this.lastSequence === null) {
+      return true; // First message
+    }
+    return sequence > this.lastSequence;
+  }
+
+  /**
+   * Update sequence after processing a message
+   */
+  updateSequence(sequence: number): void {
+    this.lastSequence = sequence;
+  }
+
+  /**
+   * Record delta received
+   */
+  recordDelta(): void {
+    this.deltaCount++;
+  }
+
+  /**
+   * Record full message received
+   */
+  recordFullMessage(): void {
+    this.fullMessageCount++;
+  }
+
+  /**
+   * Get statistics
+   */
+  getStats(): ChannelDeltaStats {
+    return {
+      channelName: this.channelName,
+      conflationKey: this.conflationKey,
+      conflationGroupCount: this.conflationCaches.size,
+      deltaCount: this.deltaCount,
+      fullMessageCount: this.fullMessageCount,
+      totalMessages: this.deltaCount + this.fullMessageCount,
+    };
+  }
+}

package/src/core/delta/decoders.ts

@@ -0,0 +1,129 @@
+/**
+ * Delta Decoders for Fossil and Xdelta3 algorithms
+ */
+
+import { applyDelta as fossilApplyDelta } from 'fossil-delta';
+import { decode as vcdiffDecode } from '@ably/vcdiff-decoder';
+
+// Also check for globals (for browser builds without bundler)
+const fossilDeltaGlobal =
+  typeof window !== 'undefined' ? (window as any).fossilDelta : undefined;
+const vcdiffGlobal =
+  typeof window !== 'undefined' ? (window as any).vcdiff : undefined;
+
+/**
+ * Base64 decode a string to Uint8Array
+ */
+function base64ToBytes(base64: string): Uint8Array {
+  const binaryString = atob(base64);
+  const bytes = new Uint8Array(binaryString.length);
+  for (let i = 0; i < binaryString.length; i++) {
+    bytes[i] = binaryString.charCodeAt(i);
+  }
+  return bytes;
+}
+
+/**
+ * Convert Uint8Array to string
+ */
+function bytesToString(bytes: Uint8Array | number[]): string {
+  // Handle array-like objects that might not be proper Uint8Array
+  if (Array.isArray(bytes) || !(bytes instanceof Uint8Array)) {
+    bytes = new Uint8Array(bytes);
+  }
+  return new TextDecoder().decode(bytes);
+}
+
+/**
+ * Convert string to Uint8Array
+ */
+function stringToBytes(str: string): Uint8Array {
+  return new TextEncoder().encode(str);
+}
+
+/**
+ * Fossil Delta decoder
+ */
+export class FossilDeltaDecoder {
+  static isAvailable(): boolean {
+    return (
+      typeof fossilApplyDelta !== 'undefined' ||
+      (typeof fossilDeltaGlobal !== 'undefined' && fossilDeltaGlobal.apply)
+    );
+  }
+
+  static apply(base: string | Uint8Array, delta: string | Uint8Array): string {
+    if (!this.isAvailable()) {
+      throw new Error('Fossil Delta library not loaded');
+    }
+
+    const baseBytes = typeof base === 'string' ? stringToBytes(base) : base;
+    const deltaBytes = typeof delta === 'string' ? stringToBytes(delta) : delta;
+
+    try {
+      let result: Uint8Array;
+
+      // Try ES6 import first
+      if (typeof fossilApplyDelta !== 'undefined') {
+        result = fossilApplyDelta(baseBytes, deltaBytes);
+      }
+      // Fall back to global
+      else if (fossilDeltaGlobal && fossilDeltaGlobal.apply) {
+        result = fossilDeltaGlobal.apply(baseBytes, deltaBytes);
+      } else {
+        throw new Error('No fossil-delta implementation found');
+      }
+
+      return bytesToString(result);
+    } catch (error) {
+      throw new Error(
+        `Fossil delta decode failed: ${(error as Error).message} (base=${baseBytes.length}B delta=${deltaBytes.length}B)`,
+      );
+    }
+  }
+}
+
+/**
+ * Xdelta3 (VCDIFF) decoder
+ */
+export class Xdelta3Decoder {
+  static isAvailable(): boolean {
+    return (
+      typeof vcdiffDecode !== 'undefined' ||
+      (typeof vcdiffGlobal !== 'undefined' && vcdiffGlobal.decode)
+    );
+  }
+
+  static apply(base: string | Uint8Array, delta: string | Uint8Array): string {
+    if (!this.isAvailable()) {
+      throw new Error('Xdelta3/VCDIFF library not loaded');
+    }
+
+    const baseBytes = typeof base === 'string' ? stringToBytes(base) : base;
+    const deltaBytes = typeof delta === 'string' ? stringToBytes(delta) : delta;
+
+    try {
+      let result: Uint8Array;
+
+      // Try ES6 import first
+      if (typeof vcdiffDecode !== 'undefined') {
+        // @ably/vcdiff-decoder API: decode(delta, source)
+        result = vcdiffDecode(deltaBytes, baseBytes);
+      }
+      // Fall back to global
+      else if (vcdiffGlobal && vcdiffGlobal.decode) {
+        result = vcdiffGlobal.decode(deltaBytes, baseBytes);
+      } else {
+        throw new Error('No VCDIFF decoder implementation found');
+      }
+
+      return bytesToString(result);
+    } catch (error) {
+      throw new Error(
+        `Xdelta3 decode failed: ${(error as Error).message} (base=${baseBytes.length}B delta=${deltaBytes.length}B)`,
+      );
+    }
+  }
+}
+
+export { base64ToBytes, bytesToString, stringToBytes };

package/src/core/delta/index.ts

@@ -0,0 +1,10 @@
+/**
+ * Delta Compression Module
+ *
+ * Exports all delta compression related types and classes
+ */
+
+export { default as DeltaCompressionManager } from './manager';
+export { default as ChannelState } from './channel_state';
+export { FossilDeltaDecoder, Xdelta3Decoder } from './decoders';
+export * from './types';