@wix/services-manager 0.2.17 → 0.2.19

package/cjs/build/remote-helpers.d.ts

@@ -1,54 +0,0 @@
-import type { ServicesManager, PromisifiedServiceAPI, ServiceDefinition, ThreadMode } from './types.js';
-import { GetService, NamedSignals } from '@wix/services-definitions';
-import * as Comlink from 'comlink';
-export type RemoteServicesManager = ServicesManager<ThreadMode.REMOTE> & {
-    getServiceProxy: GetService<ThreadMode.REMOTE>;
-    syncSignal: (signalId: string, value: any, revision: string) => void;
-    exchangeServicesAndSignals: (serviceSignalsArr: {
-        serviceId: string;
-        signals: NamedSignals;
-    }[]) => {
-        serviceId: string;
-        signals: any;
-    }[];
-    awaitConnectionFromMain: () => Promise<boolean>;
-    enableContext: (context: 'global' | 'module') => RemoteServicesManager;
-};
-export type ProxyServiceManager = Comlink.Remote<RemoteServicesManager>;
-export declare function createServiceProxy<T extends ServiceDefinition<any, any>>(definition: T, remoteServiceManager: ProxyServiceManager | Promise<ProxyServiceManager>, localServicesManager: ServicesManager): PromisifiedServiceAPI<T>;
-export declare enum SERVICE_MANAGER_MESSAGES {
-    INIT_PORT = "WIX_MESSAGE.SERVICE_MANAGER.INIT_PORT",
-    SIGNAL = "WIX_MESSAGE.SERVICE_MANAGER.SIGNAL",
-    REMOTE_READY = "WIX_MESSAGE.SERVICE_MANAGER.REMOTE_READY",
-    READY_FOR_CONNECTION = "WIX_MESSAGE.SERVICE_MANAGER.READY_FOR_CONNECTION"
-}
-export declare function connectRemoteIframe(manager: ServicesManager<any>, target: Window, options?: {
-    retryOptions?: ConnectRemoteParams['retryOptions'];
-    remoteServices?: ConnectRemoteParams['remoteServices'];
-    awaitInitialConnection?: ConnectRemoteParams['awaitInitialConnection'];
-}): Promise<ProxyServiceManager>;
-export declare function connectRemoteWorker(manager: ServicesManager<any>, target: Worker, options?: {
-    retryOptions?: ConnectRemoteParams['retryOptions'];
-    remoteServices?: ConnectRemoteParams['remoteServices'];
-    awaitInitialConnection?: ConnectRemoteParams['awaitInitialConnection'];
-}): Promise<ProxyServiceManager>;
-type ConnectRemoteParams = {
-    awaitInitialConnection?: boolean;
-    manager: ServicesManager<any>;
-    retryOptions?: {
-        timeout?: number;
-        interval?: number;
-    };
-    remoteServices?: ServiceDefinition<any, any>[];
-} & ({
-    target: Window;
-    type: 'iframe';
-} | {
-    target: Worker;
-    type: 'worker';
-});
-export declare function createRemoteServicesManager({ servicesManager, messageFrame, }: {
-    servicesManager: ServicesManager<any>;
-    messageFrame?: Window | Worker;
-}): RemoteServicesManager;
-export {};

package/cjs/build/remote-helpers.js

@@ -1,283 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SERVICE_MANAGER_MESSAGES = void 0;
-exports.createServiceProxy = createServiceProxy;
-exports.connectRemoteIframe = connectRemoteIframe;
-exports.connectRemoteWorker = connectRemoteWorker;
-exports.createRemoteServicesManager = createRemoteServicesManager;
-const services_definitions_1 = require("@wix/services-definitions");
-const Comlink = __importStar(require("comlink"));
-const init_handlers_js_1 = require("./transfer-handlers/init-handlers.js");
-function createServiceProxy(definition, remoteServiceManager, localServicesManager) {
-    return new Proxy({}, {
-        get(_, prop) {
-            if (prop === 'signals') {
-                return localServicesManager.getServiceSignals(definition);
-            }
-            return async (...args) => {
-                const remoteManager = remoteServiceManager instanceof Promise
-                    ? await remoteServiceManager
-                    : remoteServiceManager;
-                let service = remoteManager.getServiceProxy(definition);
-                if (!service[prop]) {
-                    service = await service;
-                }
-                return service[prop](...args);
-            };
-        },
-    });
-}
-var SERVICE_MANAGER_MESSAGES;
-(function (SERVICE_MANAGER_MESSAGES) {
-    SERVICE_MANAGER_MESSAGES["INIT_PORT"] = "WIX_MESSAGE.SERVICE_MANAGER.INIT_PORT";
-    SERVICE_MANAGER_MESSAGES["SIGNAL"] = "WIX_MESSAGE.SERVICE_MANAGER.SIGNAL";
-    SERVICE_MANAGER_MESSAGES["REMOTE_READY"] = "WIX_MESSAGE.SERVICE_MANAGER.REMOTE_READY";
-    SERVICE_MANAGER_MESSAGES["READY_FOR_CONNECTION"] = "WIX_MESSAGE.SERVICE_MANAGER.READY_FOR_CONNECTION";
-})(SERVICE_MANAGER_MESSAGES || (exports.SERVICE_MANAGER_MESSAGES = SERVICE_MANAGER_MESSAGES = {}));
-// the main thread always connects to workers and iframes and not the other way around
-async function connectRemoteIframe(manager, target, options) {
-    return connectRemote({
-        manager,
-        target,
-        type: 'iframe',
-        retryOptions: options?.retryOptions,
-        remoteServices: options?.remoteServices,
-        awaitInitialConnection: options?.awaitInitialConnection,
-    });
-}
-async function connectRemoteWorker(manager, target, options) {
-    return connectRemote({
-        manager,
-        target,
-        type: 'worker',
-        retryOptions: options?.retryOptions,
-        remoteServices: options?.remoteServices,
-        awaitInitialConnection: options?.awaitInitialConnection,
-    });
-}
-async function connectRemote({ manager, target, type, 
-// by default the connection attempt is only once
-retryOptions: { timeout = 10000, interval = 11000 } = {}, remoteServices = [], awaitInitialConnection = false, }) {
-    if (interval < 5) {
-        console.warn('setting a low interval might cause a race condition on the response message');
-    }
-    const signalsRegistry = manager.getSignalsRegistry();
-    const onReadyFromRemote = (callback) => {
-        if (type === 'iframe') {
-            window.addEventListener('message', (event) => {
-                if (event.data?.type === SERVICE_MANAGER_MESSAGES.READY_FOR_CONNECTION &&
-                    event.source === target) {
-                    callback();
-                }
-            });
-        }
-        else {
-            target.onmessage = (event) => {
-                if (event.data?.type === SERVICE_MANAGER_MESSAGES.READY_FOR_CONNECTION) {
-                    callback();
-                }
-            };
-        }
-    };
-    if (awaitInitialConnection && typeof window !== 'undefined') {
-        await new Promise((resolve) => {
-            onReadyFromRemote(resolve);
-        });
-    }
-    return new Promise((resolve, reject) => {
-        const triggerConnection = () => {
-            const remoteConnectionId = Math.random().toString(36).substring(7);
-            const { port1: remotePort, port2: localPort } = new MessageChannel();
-            const servicesToSignals = remoteServices.map((definition) => {
-                let signals = {};
-                try {
-                    signals = manager.getService(definition)?.signals;
-                }
-                catch (e) {
-                    // do nothing, service probably not present here
-                }
-                return {
-                    serviceId: definition.toString(),
-                    signals,
-                };
-            });
-            const message = {
-                type: SERVICE_MANAGER_MESSAGES.INIT_PORT,
-                remoteConnectionId,
-                port: remotePort,
-            };
-            if (type === 'iframe') {
-                target.postMessage(message, '*', [remotePort]);
-            }
-            else {
-                target.postMessage(message, [remotePort]);
-            }
-            localPort.onmessage = async (event) => {
-                if (event.data.type === SERVICE_MANAGER_MESSAGES.REMOTE_READY &&
-                    event.data.remoteConnectionId === remoteConnectionId) {
-                    clearTimeout(timeoutId);
-                    clearInterval(intervalId);
-                    const wrappedManager = Comlink.wrap(localPort);
-                    const remoteServicesManager = createRemoteServicesManager({
-                        servicesManager: manager,
-                    });
-                    Comlink.expose(remoteServicesManager, localPort);
-                    // sync from main to remote manager when set is from main
-                    signalsRegistry.addReplicator((id, value, revision) => {
-                        wrappedManager.syncSignal(id, value, revision);
-                    });
-                    const remoteSignals = await wrappedManager.exchangeServicesAndSignals(servicesToSignals);
-                    remoteSignals
-                        .filter(({ signals }) => !!signals)
-                        .forEach(({ serviceId, signals }) => {
-                        signalsRegistry.setServiceSignals(serviceId, signals);
-                    });
-                    resolve(wrappedManager);
-                }
-            };
-        };
-        // first connection
-        triggerConnection();
-        // re-establish connection if remote frame is reloaded
-        onReadyFromRemote(() => triggerConnection());
-        // retries if defined in options
-        const intervalId = setInterval(triggerConnection, interval);
-        const timeoutId = setTimeout(() => {
-            clearInterval(intervalId);
-            reject(new Error('Connection timeout'));
-        }, timeout);
-    });
-}
-function createRemoteServicesManager({ servicesManager, messageFrame, }) {
-    let connectedResolver = (result) => { };
-    const connectedPromise = new Promise((resolve) => {
-        connectedResolver = resolve;
-    });
-    (0, init_handlers_js_1.initializeTransferHandlers)(servicesManager.getSignalsRegistry());
-    let remoteServiceManager = null;
-    const signalsRegistry = servicesManager.getSignalsRegistry();
-    const remoteManager = {
-        ...servicesManager,
-        async awaitConnectionFromMain() {
-            const result = await connectedPromise;
-            return result === 'connected';
-        },
-        getService(definition, getService = remoteManager.getService, signals = {}) {
-            let result = null;
-            if (servicesManager.hasService(definition)) {
-                result = servicesManager.getService(definition, getService, signals || servicesManager.getServiceSignals(definition));
-            }
-            else {
-                result = createServiceProxy(definition, 
-                // remoteServiceManager!,
-                (async () => {
-                    await connectedPromise;
-                    return remoteServiceManager;
-                })(), servicesManager);
-                servicesManager.addService(definition, () => result);
-            }
-            if (result) {
-                if (result.signals) {
-                    signalsRegistry.setServiceSignals(definition.toString(), result.signals);
-                }
-                return result;
-            }
-            else {
-                throw new Error(`Service ${definition} is not provided`);
-            }
-        },
-        getServiceProxy(definition, getService = remoteManager.getService) {
-            const service = remoteManager.getService(definition, getService);
-            return service ? Comlink.proxy(service) : service;
-        },
-        syncSignal(signalId, value, revision) {
-            const signal = signalsRegistry.getSignalById(signalId);
-            if (signal) {
-                signal.syncSignal(value, revision);
-            }
-            else {
-                const newSignal = signalsRegistry.createSignal(value, signalId);
-                newSignal.set(value);
-            }
-        },
-        exchangeServicesAndSignals(serviceSignalArr) {
-            serviceSignalArr
-                .map(({ serviceId, signals }) => ({
-                serviceId,
-                signals,
-            }))
-                .filter(({ signals }) => !!signals)
-                .forEach(({ serviceId, signals }) => {
-                signalsRegistry.setServiceSignals(serviceId, signals);
-            });
-            connectedResolver('connected');
-            return serviceSignalArr
-                .map(({ serviceId }) => (0, services_definitions_1.defineService)(serviceId))
-                .map((definition) => ({
-                serviceId: definition.toString(),
-                signals: remoteManager.getService(definition).signals,
-            }));
-        },
-        enableContext(context) {
-            servicesManager.enableContext.bind(this)(context);
-            return this;
-        },
-    };
-    if (messageFrame) {
-        messageFrame.onmessage = (event) => {
-            if (event.data.type === SERVICE_MANAGER_MESSAGES.INIT_PORT) {
-                remoteServiceManager = Comlink.wrap(event.data.port);
-                Comlink.expose(remoteManager, event.data.port);
-                event.data.port.postMessage({
-                    type: SERVICE_MANAGER_MESSAGES.REMOTE_READY,
-                    remoteConnectionId: event.data.remoteConnectionId,
-                }, {});
-                // sync from remote to main when set is from remote
-                signalsRegistry.addReplicator((id, value, revision) => {
-                    void remoteServiceManager.syncSignal(id, value, revision);
-                });
-            }
-        };
-        const message = { type: SERVICE_MANAGER_MESSAGES.READY_FOR_CONNECTION };
-        if (messageFrame.parent) {
-            messageFrame.parent.postMessage(message, '*');
-        }
-        else {
-            messageFrame.postMessage(message);
-        }
-    }
-    return remoteManager;
-}

package/cjs/build/transfer-handlers/init-handlers.d.ts

@@ -1,2 +0,0 @@
-import { SignalsRegistry } from '../core-services/signals/registry.js';
-export declare function initializeTransferHandlers(signalsRegistry: SignalsRegistry): void;

package/cjs/build/transfer-handlers/init-handlers.js

@@ -1,115 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.initializeTransferHandlers = initializeTransferHandlers;
-const Comlink = __importStar(require("comlink"));
-// import type { ServiceDefinition } from '../types.js';
-// import { defineService } from '@wix/services-definitions';
-const transfer_helpers_js_1 = require("../core-services/signals/transfer-helpers.js");
-function isObjectOrFunction(obj) {
-    return (typeof obj === 'object' && obj !== null) || typeof obj === 'function';
-}
-function needsProxy(obj) {
-    if (!isObjectOrFunction(obj)) {
-        return false;
-    }
-    if (typeof obj === 'function') {
-        return true;
-    }
-    // Check if any property of the object needs a proxy
-    for (const key in obj) {
-        if (needsProxy(obj[key])) {
-            return true;
-        }
-    }
-    return false;
-}
-const methodIdentifier = '3#p7C$:remote-helpers-method-identifier';
-const stripMethods = (obj) => {
-    if (typeof obj === 'function') {
-        return methodIdentifier;
-    }
-    if (Array.isArray(obj)) {
-        const strippedArr = obj.map(stripMethods).filter(Boolean);
-        return strippedArr.length ? strippedArr : undefined;
-    }
-    if (isObjectOrFunction(obj)) {
-        return Object.entries(obj).reduce((entries, [key, value]) => {
-            entries[key] = stripMethods(value);
-            return entries;
-        }, {});
-    }
-    return obj;
-};
-const deepMerge = (target, source) => {
-    if (typeof target === 'undefined' || target === methodIdentifier) {
-        return source;
-    }
-    for (const key in target) {
-        target[key] = deepMerge(target[key] || {}, source[key]);
-    }
-    return target;
-};
-let isInitialized = false;
-function initializeTransferHandlers(signalsRegistry) {
-    if (isInitialized) {
-        return;
-    }
-    isInitialized = true;
-    (0, transfer_helpers_js_1.createSignalsTransferHandler)(signalsRegistry);
-    Comlink.transferHandlers.set('FUNC', {
-        // @ts-expect-error
-        canHandle: needsProxy,
-        serialize: (obj) => {
-            const { port1, port2 } = new MessageChannel();
-            Comlink.expose(obj, port1);
-            return [{ stripped: stripMethods(obj), port: port2 }, [port2]];
-        },
-        deserialize: ({ stripped, port }) => deepMerge(stripped, Comlink.wrap(port)),
-    });
-    //
-    // Comlink.transferHandlers.set('ServiceDefinition', {
-    //   // @ts-expect-error
-    //   canHandle: (obj?: ServiceDefinition<any, any>) => {
-    //     return !!obj?.isServiceDefinition;
-    //   },
-    //   serialize: (p: any) => {
-    //     return [p.toString(), []];
-    //   },
-    //   deserialize: (definition: string) => {
-    //     return defineService(definition);
-    //   },
-    // });
-}

package/remote-helpers/package.json

@@ -1,3 +0,0 @@
-{
-  "main": "../cjs/build/remote-helpers.js"
-}