@wix/services-manager 0.2.18 → 0.2.20

package/build/core-services/signals/transfer-helpers.js

@@ -1,64 +0,0 @@
-import * as Comlink from 'comlink';
-function hasSignals(obj) {
-    if ((obj && typeof obj !== 'object') || typeof obj === 'function') {
-        return false;
-    }
-    if (obj?.isSignal) {
-        return true;
-    }
-    for (const key in obj) {
-        if (hasSignals(obj[key])) {
-            return true;
-        }
-    }
-    return false;
-}
-function deserializeSignals(obj, signalsRegistry) {
-    if (obj?.isSignal) {
-        return signalsRegistry.setOrCreateSignal(obj.id, obj.value, obj.readonly);
-    }
-    if (Array.isArray(obj)) {
-        return obj.map((item) => deserializeSignals(item, signalsRegistry));
-    }
-    if (typeof obj === 'object') {
-        const res = {};
-        for (const key in obj) {
-            res[key] = deserializeSignals(obj[key], signalsRegistry);
-        }
-        return res;
-    }
-    return obj;
-}
-function serializeSignals(obj) {
-    if (obj?.isSignal) {
-        const signal = obj;
-        return {
-            id: signal.id,
-            value: signal.peek(),
-            isSignal: true,
-            readonly: !obj.set,
-        };
-    }
-    if (Array.isArray(obj)) {
-        return obj.map((item) => serializeSignals(item));
-    }
-    if (typeof obj === 'object') {
-        const res = {};
-        for (const key in obj) {
-            res[key] = serializeSignals(obj[key]);
-        }
-        return res;
-    }
-    return obj;
-}
-export const createSignalsTransferHandler = (signalsRegistry) => {
-    Comlink.transferHandlers.set('Signals', {
-        // @ts-expect-error
-        canHandle: hasSignals,
-        serialize: (obj) => {
-            const serialized = serializeSignals(obj);
-            return [serialized, []];
-        },
-        deserialize: (obj) => deserializeSignals(obj, signalsRegistry),
-    });
-};

package/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/build/remote-helpers.js

@@ -1,243 +0,0 @@
-import { defineService, } from '@wix/services-definitions';
-import * as Comlink from 'comlink';
-import { initializeTransferHandlers } from './transfer-handlers/init-handlers.js';
-export 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);
-            };
-        },
-    });
-}
-export 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 || (SERVICE_MANAGER_MESSAGES = {}));
-// the main thread always connects to workers and iframes and not the other way around
-export async function connectRemoteIframe(manager, target, options) {
-    return connectRemote({
-        manager,
-        target,
-        type: 'iframe',
-        retryOptions: options?.retryOptions,
-        remoteServices: options?.remoteServices,
-        awaitInitialConnection: options?.awaitInitialConnection,
-    });
-}
-export 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);
-    });
-}
-export function createRemoteServicesManager({ servicesManager, messageFrame, }) {
-    let connectedResolver = (result) => { };
-    const connectedPromise = new Promise((resolve) => {
-        connectedResolver = resolve;
-    });
-    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 }) => 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/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/build/transfer-handlers/init-handlers.js

@@ -1,79 +0,0 @@
-import * as Comlink from 'comlink';
-// import type { ServiceDefinition } from '../types.js';
-// import { defineService } from '@wix/services-definitions';
-import { createSignalsTransferHandler } from '../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;
-export function initializeTransferHandlers(signalsRegistry) {
-    if (isInitialized) {
-        return;
-    }
-    isInitialized = true;
-    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/cjs/build/core-services/signals/registry.d.ts

@@ -1,27 +0,0 @@
-import { ReadOnlySignal, Signal } from './definition.js';
-import { Jsonifiable } from 'type-fest';
-import { SignalsWrapper, SignalValue } from '@wix/services-definitions';
-export declare function generateSignalId(): string;
-export type SignalReplicator = (id: string, value: any, revision: string) => void;
-export type InnerSignal<T extends SignalValue> = Signal<T> & {
-    syncSignal: (value: T, revision: string) => void;
-    getRevision(): string;
-    readonly: boolean;
-};
-export declare class SignalsRegistry {
-    private signalsStore;
-    private serviceSignalsRegistry;
-    private replicators;
-    private createInnerSignal;
-    getSignals(): ReadOnlySignal<any>[];
-    clearSignalsRegistry(): void;
-    private _createSignal;
-    setOrCreateSignal<T extends Jsonifiable>(id: string, initialValue: T, readonly?: boolean): ReadOnlySignal<T>;
-    createSignal<T extends Jsonifiable>(initialValue: T, id?: string): Signal<T>;
-    createComputedSignal<T extends Jsonifiable>(fn: () => T, id?: string): ReadOnlySignal<T>;
-    getSignalById(id: string): InnerSignal<any> | undefined;
-    addReplicator(replicator: SignalReplicator): void;
-    getServiceSignals(serviceId: string): SignalsWrapper | undefined;
-    setServiceSignals(serviceId: string, signals: SignalsWrapper): void;
-}
-export declare const createSignalsRegistry: () => SignalsRegistry;

package/cjs/build/core-services/signals/registry.js

@@ -1,121 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createSignalsRegistry = exports.SignalsRegistry = void 0;
-exports.generateSignalId = generateSignalId;
-const signals_core_1 = require("@preact/signals-core");
-function generateSignalId() {
-    return 'signal:xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function (c) {
-        const r = (Math.random() * 16) | 0, v = c === 'x' ? r : (r & 0x3) | 0x8;
-        return v.toString(16);
-    });
-}
-function generateRevisionId() {
-    return Math.random().toString(36).slice(2);
-}
-function toPublicSignal(signal) {
-    return {
-        ...(signal.readonly ? {} : { set: signal.set }),
-        get: signal.get,
-        peek: signal.peek,
-        subscribe: signal.subscribe,
-        id: signal.id,
-        isSignal: true,
-    };
-}
-class SignalsRegistry {
-    signalsStore = new Map();
-    serviceSignalsRegistry = new Map();
-    replicators = [];
-    createInnerSignal(value, id, readonly = false) {
-        let revisionId = generateRevisionId();
-        const sig = (0, signals_core_1.signal)(value);
-        const signal = {
-            get: () => sig.value,
-            peek: () => sig.peek(),
-            syncSignal: (newValue, revision) => {
-                if (sig.peek() !== newValue && revision !== revisionId) {
-                    revisionId = revision;
-                    sig.value = newValue;
-                }
-            },
-            set: (newValue) => {
-                if (sig.peek() !== newValue) {
-                    revisionId = generateRevisionId();
-                    sig.value = newValue;
-                }
-            },
-            subscribe: (sfn) => sig.subscribe(sfn),
-            id,
-            isSignal: true,
-            getRevision: () => revisionId,
-            readonly,
-        };
-        return signal;
-    }
-    getSignals() {
-        return Array.from(this.signalsStore.values());
-    }
-    clearSignalsRegistry() {
-        this.signalsStore.clear();
-        this.serviceSignalsRegistry.clear();
-        this.replicators = [];
-    }
-    _createSignal(initialValue, id = generateSignalId(), readonly = false) {
-        const innerSignal = this.createInnerSignal(initialValue, id, readonly);
-        this.signalsStore.set(innerSignal.id, innerSignal);
-        innerSignal.subscribe((newValue) => {
-            this.replicators.forEach((replicator) => replicator(innerSignal.id, newValue, innerSignal.getRevision()));
-        });
-        return toPublicSignal(innerSignal);
-    }
-    setOrCreateSignal(id, initialValue, readonly = false) {
-        const existingSignal = this.signalsStore.get(id);
-        if (existingSignal) {
-            return toPublicSignal(existingSignal);
-        }
-        return this._createSignal(initialValue, id, readonly);
-    }
-    createSignal(initialValue, id) {
-        return this._createSignal(initialValue, id);
-    }
-    createComputedSignal(fn, id = generateSignalId()) {
-        const sig = (0, signals_core_1.computed)(fn);
-        const signal = {
-            get: () => sig.value,
-            peek: () => sig.peek(),
-            id,
-            subscribe: (sfn) => sig.subscribe(sfn),
-            isSignal: true,
-        };
-        // a replica of the signal that can be used to subscribe to the computed signal and set the value
-        const replicaSignal = this.createInnerSignal(sig.peek(), id, true);
-        this.signalsStore.set(signal.id, replicaSignal);
-        sig.subscribe((newValue) => {
-            replicaSignal.set(newValue);
-            this.replicators.forEach((replicator) => {
-                try {
-                    replicator(signal.id, newValue, replicaSignal.getRevision());
-                }
-                catch (e) {
-                    console.error(`Error replicating signal ${signal.id}`, e);
-                }
-            });
-        });
-        return signal;
-    }
-    getSignalById(id) {
-        return this.signalsStore.get(id);
-    }
-    addReplicator(replicator) {
-        this.replicators.push(replicator);
-    }
-    getServiceSignals(serviceId) {
-        return this.serviceSignalsRegistry.get(serviceId);
-    }
-    setServiceSignals(serviceId, signals) {
-        this.serviceSignalsRegistry.set(serviceId, signals);
-    }
-}
-exports.SignalsRegistry = SignalsRegistry;
-const createSignalsRegistry = () => new SignalsRegistry();
-exports.createSignalsRegistry = createSignalsRegistry;

package/cjs/build/core-services/signals/transfer-helpers.d.ts

@@ -1,2 +0,0 @@
-import { SignalsRegistry } from './registry.js';
-export declare const createSignalsTransferHandler: (signalsRegistry: SignalsRegistry) => void;