react-broadcast-sync 1.6.0 → 1.8.0

package/src/types/types.ts

@@ -1,124 +0,0 @@
-/**
- * Options for configuring the broadcast channel
- */
-export interface BroadcastOptions {
-  /** Custom source name for this instance */
-  sourceName?: string;
-
-  /** Interval in milliseconds for cleaning expired messages (default: 1000) */
-  cleaningInterval?: number;
-
-  /** If true, only the latest message is kept */
-  keepLatestMessage?: boolean;
-
-  /** Array of allowed message types */
-  registeredTypes?: string[];
-
-  /** Channel namespace for isolation */
-  namespace?: string;
-
-  /** TTL for deduplication in milliseconds (default: 5 minutes) */
-  deduplicationTTL?: number;
-
-  /** Debounce time for messages cleanup in milliseconds (default: 1000) */
-  cleanupDebounceMs?: number;
-
-  /** Delay in milliseconds for batching messages (default: 20) */
-  batchingDelayMs?: number;
-
-  /** Array of message types that should not be batched and sent immediately (default: []) */
-  excludedBatchMessageTypes?: string[];
-}
-
-/**
- * Options for sending messages
- */
-export interface SendMessageOptions {
-  /** Message expiration duration in milliseconds */
-  expirationDuration?: number;
-
-  /** Specific expiration timestamp */
-  expirationDate?: number;
-}
-
-/**
- * Structure of a broadcast message
- */
-export interface BroadcastMessage {
-  /** Unique message identifier */
-  id: string;
-
-  /** Message type for categorization */
-  type: string;
-
-  /** Message content */
-  message: any;
-
-  /** Creation timestamp */
-  timestamp: number;
-
-  /** Source identifier */
-  source: string;
-
-  /** Optional expiration timestamp */
-  expirationDate?: number;
-}
-export interface ClearOptions {
-  ids?: string[];
-  types?: string[];
-}
-
-export interface ClearReceivedMessagesOptions extends ClearOptions {
-  sources?: string[];
-}
-
-export interface ClearSentMessagesOptions extends ClearOptions {
-  sync?: boolean;
-}
-
-export interface GetLatestMessageOptions {
-  source?: string;
-  type?: string;
-}
-
-/**
- * Actions and state provided by the broadcast channel hook
- */
-export interface BroadcastActions {
-  /** The resolved channel name including namespace */
-  channelName: string;
-
-  /** Array of received messages */
-  messages: BroadcastMessage[];
-
-  /** Array of sent messages */
-  sentMessages: BroadcastMessage[];
-
-  /** Whether a ping operation is currently in progress */
-  isPingInProgress: boolean;
-
-  /** Function to ping the channel and get active sources */
-  ping: (timeoutMs?: number) => Promise<string[]>;
-
-  /** Function to send a message */
-  postMessage: (messageType: string, messageContent: any, options?: SendMessageOptions) => void;
-
-  /** Function to clear received messages */
-  clearReceivedMessages: (options?: ClearReceivedMessagesOptions) => void;
-
-  /** Function to clear sent messages */
-  clearSentMessages: (options?: ClearSentMessagesOptions) => void;
-
-  /** Function to get the latest message by source and type */
-  getLatestMessage: (options?: GetLatestMessageOptions) => BroadcastMessage | null;
-
-  /** Explicitly close the broadcast channel and remove listeners */
-  closeChannel: () => void;
-
-  /** Current error state */
-  error: string | null;
-}
-
-export type ClearMessage = 'CLEAR_SENT_MESSAGES';
-
-export type InternalMessage = ClearMessage | 'PING' | 'PONG';

package/src/utils/debug.ts

@@ -1,80 +0,0 @@
-declare const process: { env: { [key: string]: string | undefined } };
-
-const isDebugMode = () => {
-  if (typeof process !== 'undefined' && process.env) {
-    return process.env.REACT_APP_DEBUG_BROADCAST === 'true';
-  }
-  return false;
-};
-
-type LogLevel = 'info' | 'warn' | 'error';
-
-const log = (level: LogLevel, message: string, data?: any) => {
-  if (!isDebugMode()) return;
-
-  const timestamp = new Date().toISOString();
-  const prefix = `[${timestamp}] [react-broadcast-sync]`;
-  switch (level) {
-    case 'info':
-      console.log(prefix, message, data || '');
-      break;
-    case 'warn':
-      console.warn(prefix, message, data || '');
-      break;
-    case 'error':
-      console.error(prefix, message, data || '');
-      break;
-  }
-};
-
-export const debug = {
-  channel: {
-    created: (name: string) => log('info', 'Channel created:', name),
-    closed: (name: string) => log('info', 'Channel closed:', name),
-  },
-  message: {
-    sent: (message: any) => log('info', 'Message sent:', message),
-    received: (message: any) => log('info', 'Message received:', message),
-    cleared: (messageId: string) => log('info', 'Message cleared:', messageId),
-    expired: (messageId: string) => log('info', 'Message expired:', messageId),
-    duplicate: (messageId: string) => log('warn', 'Duplicate message ignored:', messageId),
-    allSentCleared: () => log('info', 'All sent messages cleared'),
-    allReceivedCleared: () => log('info', 'All received messages cleared'),
-    ignored: (messageType: string) =>
-      log('info', 'Message ignored due to type filter:', messageType),
-  },
-  ping: {
-    inProgress: () => log('warn', 'Ping already in progress. Skipping call.'),
-  },
-  cleanup: {
-    started: () => log('info', 'Cleanup started'),
-    completed: (removedCount: number) => log('info', 'Cleanup completed:', removedCount),
-  },
-  error: (context: {
-    action: string;
-    channelName?: string;
-    type?: string;
-    source?: string;
-    originalError?: unknown;
-  }) => {
-    const { action, channelName, type, source, originalError } = context;
-
-    let message = `${action}`;
-    if (channelName) message += ` | channel: ${channelName}`;
-    if (type) message += ` | type: ${type}`;
-    if (source) message += ` | source: ${source}`;
-    if (originalError instanceof Error) {
-      message += ` | cause: ${originalError.message}`;
-    } else if (typeof originalError === 'string') {
-      message += ` | cause: ${originalError}`;
-    } else if (originalError != null) {
-      try {
-        message += ` | cause: ${JSON.stringify(originalError)}`;
-      } catch {
-        message += ' | cause: [unserializable]';
-      }
-    }
-
-    log('error', 'Error:', message);
-  },
-};

package/src/utils/messageUtils.ts

@@ -1,122 +0,0 @@
-import { InternalMessage } from '../types/types';
-
-const INTERNAL_PREFIX = '__INTERNAL__';
-const SECRET = 'react-broadcast-sync';
-
-// Generate a random 9-character alphanumeric string
-export const generateRandomPart = () => Math.random().toString(36).substr(2, 9);
-
-// Generate a unique source name for a tab
-export const generateSourceName = () => `tab-${generateRandomPart()}`;
-
-// Generate a unique message ID
-export const generateMessageId = (source: string, timestamp: number) => {
-  const raw = `${generateRandomPart()}-${source}-${timestamp}`;
-  return btoa(raw).replace(/=+$/, '');
-};
-
-// Check if a message is valid
-export const isValidMessage = (message: any): boolean => {
-  return Boolean(message && typeof message === 'object' && 'id' in message);
-};
-
-// Check if a message has expired
-export const isMessageExpired = (message: { expirationDate?: number }): boolean => {
-  return message.expirationDate ? message.expirationDate < Date.now() : false;
-};
-
-// Create a new message object
-export const createMessage = (
-  type: string,
-  content: any,
-  source: string,
-  options: { expirationDate?: number; expirationDuration?: number } = {}
-): any => {
-  const timestamp = Date.now();
-  return {
-    id: generateMessageId(source, timestamp),
-    type,
-    message: content,
-    timestamp,
-    source,
-    expirationDate:
-      options.expirationDate ??
-      (options.expirationDuration ? timestamp + options.expirationDuration : undefined),
-  };
-};
-
-export const getInternalMessageType = (
-  baseType: InternalMessage,
-  channelName: string,
-  namespace = ''
-): string => {
-  const fullChannel = `${channelName}-${namespace}`;
-  const input = `${SECRET}:${baseType}:${fullChannel}`;
-  const hash = btoa(input); // optional: use sha256 if added
-  return `${INTERNAL_PREFIX}:${baseType}:${hash}`;
-};
-
-export const isInternalType = (type: string): boolean => {
-  return type.startsWith(`${INTERNAL_PREFIX}:`);
-};
-
-export const isValidInternalClearMessage = (message: any): boolean => {
-  return (
-    message &&
-    typeof message === 'object' &&
-    typeof message.type === 'string' &&
-    isInternalType(message.type) &&
-    typeof message.source === 'string'
-  );
-};
-
-export const debounce = <T extends (...args: any[]) => any>(
-  fn: T,
-  wait: number
-): ((...args: Parameters<T>) => void) & {
-  cancel: () => void;
-  flush: () => ReturnType<T> | undefined;
-} => {
-  let timeoutId: ReturnType<typeof setTimeout> | null = null;
-  let lastArgs: Parameters<T> | null = null;
-  let result: ReturnType<T> | undefined;
-
-  const debounced = (...args: Parameters<T>) => {
-    lastArgs = args;
-    if (timeoutId !== null) {
-      clearTimeout(timeoutId);
-    }
-    timeoutId = setTimeout(() => {
-      timeoutId = null;
-      if (lastArgs !== null) {
-        result = fn(...lastArgs);
-        lastArgs = null;
-      }
-    }, wait);
-  };
-
-  debounced.cancel = () => {
-    if (timeoutId !== null) {
-      clearTimeout(timeoutId);
-      timeoutId = null;
-      lastArgs = null;
-    }
-  };
-
-  debounced.flush = () => {
-    if (timeoutId !== null) {
-      clearTimeout(timeoutId);
-      timeoutId = null;
-      if (lastArgs !== null) {
-        result = fn(...lastArgs);
-        lastArgs = null;
-      }
-    }
-    return result;
-  };
-
-  return debounced as typeof debounced & {
-    cancel: () => void;
-    flush: () => ReturnType<T> | undefined;
-  };
-};

package/tsconfig.json

@@ -1,36 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ES6",
-    "lib": ["DOM", "ES2017"],
-    "module": "ESNext",
-    "moduleResolution": "node",
-    "strict": true,
-    "esModuleInterop": true,
-    "skipLibCheck": true,
-    "forceConsistentCasingInFileNames": true,
-    "jsx": "react-jsx",
-    "outDir": "./dist",
-    "declaration": true,
-    "declarationDir": "./dist",
-    "emitDeclarationOnly": false,
-    "isolatedModules": true,
-    "resolveJsonModule": true,
-    "allowSyntheticDefaultImports": true,
-    "noImplicitAny": true,
-    "strictNullChecks": true,
-    "strictFunctionTypes": true,
-    "strictBindCallApply": true,
-    "strictPropertyInitialization": true,
-    "noImplicitThis": true,
-    "alwaysStrict": true,
-    "noUnusedLocals": true,
-    "noUnusedParameters": true,
-    "noImplicitReturns": true,
-    "noFallthroughCasesInSwitch": true,
-    "allowJs": true,
-    "checkJs": false,
-    "types": ["jest", "node", "react"]
-  },
-  "include": ["src/**/*"],
-  "exclude": ["node_modules", "dist"]
-}