@ricardojbd/ngrx-signals-broadcast-sync/esm2022/lib/with-broadcast-sync.mjs

Enables seamless synchronization of state between browser contexts

import { signalStoreFeature, withMethods, withHooks, getState, patchState } from '@ngrx/signals';
import { effect, inject, PLATFORM_ID } from '@angular/core';
import { isPlatformServer } from '@angular/common';
import isEqual from 'lodash.isequal';
const NOOP = () => null;
const BroadcastSyncStub = {
    getBroadcastChannel: NOOP,
    broadcastState: NOOP,
    _requestBroadcastState: NOOP,
    _patchStateFromBroadcast: NOOP
};
/**
 * Adds broadcast synchronization capabilities to a Signal Store.
 *
 * This function enables state synchronization between multiple clients using the `BroadcastChannel` API.
 * It can be invoked either with a broadcast channel name or with a configuration object (`Options`).
 * It allows clients to request, send, and patch the state across multiple contexts.
 *
 * @template Input The type of the store feature result, extending `SignalStoreFeatureResult`.
 * @param channelOrOptions Either the name of the broadcast channel or a configuration object.
 * If a string is provided, it is treated as the broadcast channel name.
 * If an `Options` object is provided, it allows further configuration of the broadcast behavior.
 * @returns A Signal Store feature that adds methods for broadcast synchronization.
 */
export function withBroadcastSync(channelOrOptions) {
    const { channel, requestState = false, select = (state) => state, messageEventInterceptor = (event) => event.data, broadcastStateInterceptor = (state) => state, onMessageError = () => null } = typeof channelOrOptions === 'string' ? { channel: channelOrOptions } : channelOrOptions;
    const runGuard = (platformId) => isPlatformServer(platformId) || typeof window?.BroadcastChannel === 'undefined';
    let stateChannel;
    let lastSyncedState = null;
    return signalStoreFeature(withMethods((store, platformId = inject(PLATFORM_ID)) => {
        if (runGuard(platformId)) {
            console.warn(`'withBroadcastSync' provides non-functional implementation due to server-side execution`);
            return BroadcastSyncStub;
        }
        return {
            getBroadcastChannel() {
                return stateChannel;
            },
            broadcastState() {
                let state = select(getState(store));
                if (isEqual(state, lastSyncedState)) {
                    return;
                }
                state = broadcastStateInterceptor(state);
                if (stateChannel != null) {
                    lastSyncedState = state; // Avoid broadcast duplicated state
                    stateChannel.postMessage({ type: 'UPDATE_STATE', state });
                }
            },
            _requestBroadcastState() {
                lastSyncedState = select(getState(store)); // Avoid broadcast initial state
                stateChannel?.postMessage({ type: 'REQUEST_STATE' });
            },
            _patchStateFromBroadcast(state) {
                lastSyncedState = state; // Avoid broadcast this state change
                patchState(store, state);
            }
        };
    }), withHooks({
        onInit(store, platformId = inject(PLATFORM_ID)) {
            if (runGuard(platformId)) {
                return;
            }
            stateChannel = new BroadcastChannel(channel);
            if (requestState) {
                store._requestBroadcastState();
            }
            stateChannel.onmessage = (event) => {
                const message = messageEventInterceptor(event);
                switch (message.type) {
                    case 'REQUEST_STATE': {
                        lastSyncedState = null; // Force broadcast state
                        store.broadcastState();
                        break;
                    }
                    case 'UPDATE_STATE': {
                        store._patchStateFromBroadcast(message.state);
                        break;
                    }
                    default: {
                        console.warn(`Unknown message type "${message}" in the broadcast channel "${channel}"`);
                    }
                }
            };
            stateChannel.onmessageerror = (event) => onMessageError(event);
            effect(() => {
                store.broadcastState();
            });
        },
        onDestroy() {
            stateChannel?.close();
        }
    }));
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"with-broadcast-sync.js","sourceRoot":"","sources":["../../../../../libs/ngrx-signals-broadcast-sync/src/lib/with-broadcast-sync.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  signalStoreFeature,\n  SignalStoreFeature,\n  SignalStoreFeatureResult,\n  withMethods,\n  withHooks,\n  getState,\n  patchState\n} from '@ngrx/signals';\nimport { effect, inject, PLATFORM_ID } from '@angular/core';\nimport { isPlatformServer } from '@angular/common';\nimport isEqual from 'lodash.isequal';\nimport { Message, Options, BroadcastSyncFeatureResult } from './models';\n\nconst NOOP = () => null;\n\nconst BroadcastSyncStub: Pick<BroadcastSyncFeatureResult, 'methods'>['methods'] = {\n  getBroadcastChannel: NOOP,\n  broadcastState: NOOP,\n  _requestBroadcastState: NOOP,\n  _patchStateFromBroadcast: NOOP\n};\n\n/**\n * Adds broadcast synchronization capabilities to a Signal Store.\n *\n * This function enables state synchronization between multiple clients using the `BroadcastChannel` API.\n * It allows clients to request, send, and patch the state across multiple contexts.\n *\n * @template Input The type of the store feature result, extending `SignalStoreFeatureResult`.\n * @param channel The name of the broadcast channel to use for synchronizing state across clients.\n * @returns A Signal Store feature with broadcast capabilities.\n */\nexport function withBroadcastSync<Input extends SignalStoreFeatureResult>(\n  channel: string\n): SignalStoreFeature<Input, BroadcastSyncFeatureResult>;\n\n/**\n * Adds broadcast synchronization capabilities to a Signal Store.\n *\n * This function enables state synchronization between multiple clients using the `BroadcastChannel` API.\n * It allows clients to request, send, and patch the state across multiple contexts.\n *\n * @template Input The type of the store feature result, extending `SignalStoreFeatureResult`.\n * @param options A configuration object specifying the broadcast channel and additional behavior for state synchronization.\n * @returns A Signal Store feature with customizable broadcast capabilities.\n */\nexport function withBroadcastSync<Input extends SignalStoreFeatureResult>(\n  options: Options<Input['state']>\n): SignalStoreFeature<Input, BroadcastSyncFeatureResult>;\n\n/**\n * Adds broadcast synchronization capabilities to a Signal Store.\n *\n * This function enables state synchronization between multiple clients using the `BroadcastChannel` API.\n * It can be invoked either with a broadcast channel name or with a configuration object (`Options`).\n * It allows clients to request, send, and patch the state across multiple contexts.\n *\n * @template Input The type of the store feature result, extending `SignalStoreFeatureResult`.\n * @param channelOrOptions Either the name of the broadcast channel or a configuration object.\n * If a string is provided, it is treated as the broadcast channel name.\n * If an `Options` object is provided, it allows further configuration of the broadcast behavior.\n * @returns A Signal Store feature that adds methods for broadcast synchronization.\n */\nexport function withBroadcastSync<Input extends SignalStoreFeatureResult>(\n  channelOrOptions: Options<Input['state']> | string\n): SignalStoreFeature<Input, BroadcastSyncFeatureResult> {\n  const {\n    channel,\n    requestState = false,\n    select = (state: Input['state']) => state,\n    messageEventInterceptor = (event: MessageEvent<Message<Input['state']>>) => event.data,\n    broadcastStateInterceptor = (state: Input['state']) => state,\n    onMessageError = () => null\n  } = typeof channelOrOptions === 'string' ? { channel: channelOrOptions } : channelOrOptions;\n\n  const runGuard = (platformId: object) =>\n    isPlatformServer(platformId) || typeof window?.BroadcastChannel === 'undefined';\n  let stateChannel: BroadcastChannel | null;\n  let lastSyncedState: Partial<Input['state']> | null = null;\n\n  return signalStoreFeature(\n    withMethods((store, platformId = inject(PLATFORM_ID)) => {\n      if (runGuard(platformId)) {\n        console.warn(`'withBroadcastSync' provides non-functional implementation due to server-side execution`);\n        return BroadcastSyncStub;\n      }\n\n      return {\n        getBroadcastChannel(): BroadcastChannel | null {\n          return stateChannel;\n        },\n\n        broadcastState(): void {\n          let state = select(getState(store));\n\n          if (isEqual(state, lastSyncedState)) {\n            return;\n          }\n\n          state = broadcastStateInterceptor(state);\n\n          if (stateChannel != null) {\n            lastSyncedState = state; // Avoid broadcast duplicated state\n            stateChannel.postMessage({ type: 'UPDATE_STATE', state });\n          }\n        },\n\n        _requestBroadcastState(): void {\n          lastSyncedState = select(getState(store)); // Avoid broadcast initial state\n          stateChannel?.postMessage({ type: 'REQUEST_STATE' });\n        },\n\n        _patchStateFromBroadcast(state: Input['state']) {\n          lastSyncedState = state; // Avoid broadcast this state change\n          patchState(store, state);\n        }\n      };\n    }),\n    withHooks({\n      onInit(store, platformId = inject(PLATFORM_ID)) {\n        if (runGuard(platformId)) {\n          return;\n        }\n\n        stateChannel = new BroadcastChannel(channel);\n\n        if (requestState) {\n          store._requestBroadcastState();\n        }\n\n        stateChannel.onmessage = (event: MessageEvent<Message<Input['state']>>) => {\n          const message = messageEventInterceptor(event);\n\n          switch (message.type) {\n            case 'REQUEST_STATE': {\n              lastSyncedState = null; // Force broadcast state\n              store.broadcastState();\n              break;\n            }\n            case 'UPDATE_STATE': {\n              store._patchStateFromBroadcast(message.state);\n              break;\n            }\n            default: {\n              console.warn(`Unknown message type \"${message}\" in the broadcast channel \"${channel}\"`);\n            }\n          }\n        };\n\n        stateChannel.onmessageerror = (event: MessageEvent) => onMessageError(event);\n\n        effect(() => {\n          store.broadcastState();\n        });\n      },\n\n      onDestroy() {\n        stateChannel?.close();\n      }\n    })\n  );\n}\n"]}