@powersync/web 0.0.0-dev-20260504100448 → 0.0.0-dev-20260630144038

package/lib/src/db/adapters/wa-sqlite/WASQLiteOpenFactory.js

@@ -1,145 +0,0 @@
-import { createLogger } from '@powersync/common';
-import * as Comlink from 'comlink';
-import { openWorkerDatabasePort, resolveWorkerDatabasePortFactory } from '../../../worker/db/open-worker-database.js';
-import { DEFAULT_CACHE_SIZE_KB, isServerSide, resolveWebSQLFlags, TemporaryStorageOption } from '../web-sql-flags.js';
-import { SSRDBAdapter } from '../SSRDBAdapter.js';
-import { vfsRequiresDedicatedWorkers, WASQLiteVFS } from './vfs.js';
-import { MultiDatabaseServer } from '../../../worker/db/MultiDatabaseServer.js';
-import { DatabaseClient } from './DatabaseClient.js';
-import { generateTabCloseSignal } from '../../../shared/tab_close_signal.js';
-import { AsyncDbAdapter } from '../AsyncWebAdapter.js';
-/**
- * Opens a SQLite connection using WA-SQLite.
- */
-export class WASQLiteOpenFactory {
-    options;
-    resolvedFlags;
-    logger;
-    constructor(options) {
-        this.options = options;
-        assertValidWASQLiteOpenFactoryOptions(options);
-        this.resolvedFlags = resolveWebSQLFlags(options.flags);
-        this.logger = options.logger ?? createLogger(`WASQLiteOpenFactory - ${this.options.dbFilename}`);
-    }
-    get waOptions() {
-        // Cast to extended type
-        return this.options;
-    }
-    openAdapter() {
-        return new AsyncDbAdapter(this.openConnection(), this.options.dbFilename);
-    }
-    openDB() {
-        const { resolvedFlags: { disableSSRWarning, enableMultiTabs, ssrMode = isServerSide() } } = this;
-        if (ssrMode) {
-            if (!disableSSRWarning) {
-                this.logger.warn(`
-      Running PowerSync in SSR mode.
-      Only empty query results will be returned.
-      Disable this warning by setting 'disableSSRWarning: true' in options.`);
-            }
-            return new SSRDBAdapter();
-        }
-        if (!enableMultiTabs) {
-            this.logger.warn('Multiple tab support is not enabled. Using this site across multiple tabs may not function correctly.');
-        }
-        return this.openAdapter();
-    }
-    async openConnection() {
-        const { enableMultiTabs, useWebWorker } = this.resolvedFlags;
-        const { vfs = WASQLiteVFS.IDBBatchAtomicVFS, temporaryStorage = TemporaryStorageOption.MEMORY, cacheSizeKb = DEFAULT_CACHE_SIZE_KB, encryptionKey } = this.waOptions;
-        if (!enableMultiTabs) {
-            this.logger.warn('Multiple tabs are not enabled in this browser');
-        }
-        const resolveOptions = (isReadOnly) => ({
-            dbFilename: this.options.dbFilename,
-            dbLocation: this.options.dbLocation,
-            debugMode: this.options.debugMode,
-            vfs,
-            temporaryStorage,
-            cacheSizeKb,
-            flags: this.resolvedFlags,
-            encryptionKey: encryptionKey,
-            isReadOnly
-        });
-        let client;
-        let additionalReaders = [];
-        let requiresPersistentTriggers = vfsRequiresDedicatedWorkers(vfs);
-        if (useWebWorker) {
-            const optionsDbWorker = this.options.worker;
-            const openDatabaseWorker = async (resolvedOptions) => {
-                const workerPort = typeof optionsDbWorker == 'function'
-                    ? resolveWorkerDatabasePortFactory(() => optionsDbWorker({
-                        ...this.options,
-                        temporaryStorage,
-                        cacheSizeKb,
-                        flags: this.resolvedFlags,
-                        encryptionKey
-                    }))
-                    : openWorkerDatabasePort(this.options.dbFilename, enableMultiTabs, optionsDbWorker, this.waOptions.vfs);
-                const source = Comlink.wrap(workerPort);
-                const closeSignal = new AbortController();
-                const connection = await source.connect({
-                    ...resolvedOptions,
-                    logLevel: this.logger.getLevel(),
-                    lockName: await generateTabCloseSignal(closeSignal.signal)
-                });
-                const clientOptions = {
-                    connection,
-                    source,
-                    // This tab owns the worker, so we're guaranteed to outlive it.
-                    remoteCanCloseUnexpectedly: false,
-                    onClose: () => {
-                        closeSignal.abort();
-                        if (workerPort instanceof Worker) {
-                            workerPort.terminate();
-                        }
-                        else {
-                            workerPort.close();
-                        }
-                    }
-                };
-                return new DatabaseClient(clientOptions, {
-                    ...resolvedOptions,
-                    requiresPersistentTriggers
-                });
-            };
-            client = await openDatabaseWorker(resolveOptions(false));
-            if (vfs == WASQLiteVFS.OPFSWriteAheadVFS) {
-                // This VFS supports concurrent reads, so we can open additional workers to host read-only connections for
-                // concurrent reads / writes.
-                const additionalReadersCount = this.options.additionalReaders ?? 1;
-                for (let i = 0; i < additionalReadersCount; i++) {
-                    const reader = await openDatabaseWorker(resolveOptions(true));
-                    additionalReaders.push(reader);
-                }
-            }
-        }
-        else {
-            // Don't use a web worker. Instead, open the MultiDatabaseServer a worker would use locally.
-            const localServer = new MultiDatabaseServer(this.logger);
-            requiresPersistentTriggers = true;
-            const resolvedOptions = resolveOptions(false);
-            const connection = await localServer.openConnectionLocally(resolvedOptions);
-            client = new DatabaseClient({ connection, source: null, remoteCanCloseUnexpectedly: false }, {
-                ...resolvedOptions,
-                requiresPersistentTriggers
-            });
-        }
-        return {
-            writer: client,
-            additionalReaders
-        };
-    }
-}
-/**
- * Asserts that the factory options are valid.
- */
-function assertValidWASQLiteOpenFactoryOptions(options) {
-    // The OPFS VFS only works in dedicated web workers.
-    if ('vfs' in options && 'flags' in options) {
-        const { vfs, flags = {} } = options;
-        if (vfs && vfsRequiresDedicatedWorkers(vfs) && 'useWebWorker' in flags && !flags.useWebWorker) {
-            throw new Error(`Invalid configuration: The 'useWebWorker' flag must be true when using an OPFS-based VFS (${vfs}).`);
-        }
-    }
-}

package/lib/src/db/adapters/wa-sqlite/WASQLitePowerSyncDatabaseOpenFactory.d.ts

@@ -1,15 +0,0 @@
-import { AbstractPowerSyncDatabase, DBAdapter, PowerSyncDatabaseOptions } from '@powersync/common';
-import { AbstractWebPowerSyncDatabaseOpenFactory } from '../AbstractWebPowerSyncDatabaseOpenFactory.js';
-/**
- * @deprecated {@link PowerSyncDatabase} can now be constructed directly
- * @example
- * ```typescript
- * const powersync = new PowerSyncDatabase({database: {
- *  dbFileName: 'powersync.db'
- * }});
- * ```
- */
-export declare class WASQLitePowerSyncDatabaseOpenFactory extends AbstractWebPowerSyncDatabaseOpenFactory {
-    protected openDB(): DBAdapter;
-    generateInstance(options: PowerSyncDatabaseOptions): AbstractPowerSyncDatabase;
-}

package/lib/src/db/adapters/wa-sqlite/WASQLitePowerSyncDatabaseOpenFactory.js

@@ -1,21 +0,0 @@
-import { PowerSyncDatabase } from '../../../db/PowerSyncDatabase.js';
-import { AbstractWebPowerSyncDatabaseOpenFactory } from '../AbstractWebPowerSyncDatabaseOpenFactory.js';
-import { WASQLiteOpenFactory } from './WASQLiteOpenFactory.js';
-/**
- * @deprecated {@link PowerSyncDatabase} can now be constructed directly
- * @example
- * ```typescript
- * const powersync = new PowerSyncDatabase({database: {
- *  dbFileName: 'powersync.db'
- * }});
- * ```
- */
-export class WASQLitePowerSyncDatabaseOpenFactory extends AbstractWebPowerSyncDatabaseOpenFactory {
-    openDB() {
-        const factory = new WASQLiteOpenFactory(this.options);
-        return factory.openDB();
-    }
-    generateInstance(options) {
-        return new PowerSyncDatabase(options);
-    }
-}

package/lib/src/db/adapters/web-sql-flags.d.ts

@@ -1,92 +0,0 @@
-import { type ILogger, SQLOpenOptions } from '@powersync/common';
-/**
- * Common settings used when creating SQL connections on web.
- */
-export interface WebSQLFlags {
-    /**
-     * Broadcast logs from shared workers, such as the shared sync worker,
-     * to individual tabs. This defaults to true.
-     */
-    broadcastLogs?: boolean;
-    /**
-     * SQLite operations are currently not supported in SSR mode.
-     * A warning will be logged if attempting to use SQLite in SSR.
-     * Setting this to `true` will disabled the warning above.
-     */
-    disableSSRWarning?: boolean;
-    /**
-     * Enables multi tab support
-     */
-    enableMultiTabs?: boolean;
-    /**
-     * The SQLite connection is often executed through a web worker
-     * in order to offload computation. This can be used to manually
-     * disable the use of web workers in environments where web workers
-     * might be unstable.
-     */
-    useWebWorker?: boolean;
-    /**
-     * Open in SSR placeholder mode. DB operations and Sync operations will be a No-op
-     */
-    ssrMode?: boolean;
-}
-export type ResolvedWebSQLFlags = Required<WebSQLFlags>;
-export interface ResolvedWebSQLOpenOptions extends SQLOpenOptions {
-    flags: ResolvedWebSQLFlags;
-    /**
-     * Where to store SQLite temporary files. Defaults to 'MEMORY'.
-     * Setting this to `FILESYSTEM` can cause issues with larger queries or datasets.
-     */
-    temporaryStorage: TemporaryStorageOption;
-    cacheSizeKb: number;
-    /**
-     * Encryption key for the database.
-     * If set, the database will be encrypted using ChaCha20.
-     */
-    encryptionKey?: string;
-}
-export declare enum TemporaryStorageOption {
-    MEMORY = "memory",
-    FILESYSTEM = "file"
-}
-export declare const DEFAULT_CACHE_SIZE_KB: number;
-/**
- * Options for opening a Web SQL connection
- */
-export interface WebSQLOpenFactoryOptions extends SQLOpenOptions {
-    flags?: WebSQLFlags;
-    /**
-     * Allows you to override the default wasqlite db worker.
-     *
-     * You can either provide a path to the worker script
-     * or a factory method that returns a worker.
-     */
-    worker?: string | URL | ((options: ResolvedWebSQLOpenOptions) => Worker | SharedWorker);
-    /**
-     * Use an existing port to an initialized worker.
-     * A worker will be initialized if none is provided
-     */
-    workerPort?: MessagePort;
-    logger?: ILogger;
-    /**
-     * Where to store SQLite temporary files. Defaults to 'MEMORY'.
-     * Setting this to `FILESYSTEM` can cause issues with larger queries or datasets.
-     *
-     * For details, see: https://www.sqlite.org/pragma.html#pragma_temp_store
-     */
-    temporaryStorage?: TemporaryStorageOption;
-    /**
-     * Maximum SQLite cache size. Defaults to 50MB.
-     *
-     * For details, see: https://www.sqlite.org/pragma.html#pragma_cache_size
-     */
-    cacheSizeKb?: number;
-    /**
-     * Encryption key for the database.
-     * If set, the database will be encrypted using ChaCha20.
-     */
-    encryptionKey?: string;
-}
-export declare function isServerSide(): boolean;
-export declare const DEFAULT_WEB_SQL_FLAGS: ResolvedWebSQLFlags;
-export declare function resolveWebSQLFlags(flags?: WebSQLFlags): ResolvedWebSQLFlags;

package/lib/src/db/adapters/web-sql-flags.js

@@ -1,36 +0,0 @@
-export var TemporaryStorageOption;
-(function (TemporaryStorageOption) {
-    TemporaryStorageOption["MEMORY"] = "memory";
-    TemporaryStorageOption["FILESYSTEM"] = "file";
-})(TemporaryStorageOption || (TemporaryStorageOption = {}));
-export const DEFAULT_CACHE_SIZE_KB = 50 * 1024;
-export function isServerSide() {
-    return typeof window == 'undefined';
-}
-export const DEFAULT_WEB_SQL_FLAGS = {
-    broadcastLogs: true,
-    disableSSRWarning: false,
-    ssrMode: isServerSide(),
-    /**
-     * Multiple tabs are by default not supported on Android, iOS and Safari.
-     * Other platforms will have multiple tabs enabled by default.
-     */
-    enableMultiTabs: typeof globalThis.navigator !== 'undefined' && // For SSR purposes
-        typeof SharedWorker !== 'undefined' &&
-        !navigator.userAgent.match(/(Android|iPhone|iPod|iPad)/i) &&
-        !window.safari,
-    useWebWorker: true
-};
-export function resolveWebSQLFlags(flags) {
-    const resolvedFlags = {
-        ...DEFAULT_WEB_SQL_FLAGS,
-        ...(flags ?? {})
-    };
-    if (typeof flags?.enableMultiTabs != 'undefined') {
-        resolvedFlags.enableMultiTabs = flags.enableMultiTabs;
-    }
-    if (flags?.useWebWorker === false) {
-        resolvedFlags.enableMultiTabs = false;
-    }
-    return resolvedFlags;
-}

package/lib/src/db/sync/WebRemote.d.ts

@@ -1,7 +0,0 @@
-import { AbstractRemote, AbstractRemoteOptions, ILogger, RemoteConnector } from '@powersync/common';
-export declare class WebRemote extends AbstractRemote {
-    protected connector: RemoteConnector;
-    protected logger: ILogger;
-    constructor(connector: RemoteConnector, logger?: ILogger, options?: Partial<AbstractRemoteOptions>);
-    getUserAgent(): string;
-}

package/lib/src/db/sync/WebRemote.js

@@ -1,32 +0,0 @@
-import { AbstractRemote, DEFAULT_REMOTE_LOGGER, FetchImplementationProvider } from '@powersync/common';
-import { getUserAgentInfo } from './userAgent.js';
-/*
- * Depends on browser's implementation of global fetch.
- */
-class WebFetchProvider extends FetchImplementationProvider {
-    getFetch() {
-        return fetch.bind(globalThis);
-    }
-}
-export class WebRemote extends AbstractRemote {
-    connector;
-    logger;
-    constructor(connector, logger = DEFAULT_REMOTE_LOGGER, options) {
-        super(connector, logger, {
-            ...(options ?? {}),
-            fetchImplementation: options?.fetchImplementation ?? new WebFetchProvider()
-        });
-        this.connector = connector;
-        this.logger = logger;
-    }
-    getUserAgent() {
-        let ua = [super.getUserAgent(), `powersync-web`];
-        try {
-            ua.push(...getUserAgentInfo());
-        }
-        catch (e) {
-            this.logger.warn('Failed to get user agent info', e);
-        }
-        return ua.join(' ');
-    }
-}

package/lib/src/worker/db/MultiDatabaseServer.d.ts

@@ -1,17 +0,0 @@
-import { ILogger } from '@powersync/common';
-import { ClientConnectionView } from '../../db/adapters/wa-sqlite/DatabaseServer.js';
-import { ResolvedWASQLiteOpenFactoryOptions, WorkerDBOpenerOptions } from '../../db/adapters/wa-sqlite/WASQLiteOpenFactory.js';
-/**
- * Shared state to manage multiple database connections hosted by a worker.
- */
-export declare class MultiDatabaseServer {
-    readonly logger: ILogger;
-    private activeDatabases;
-    constructor(logger: ILogger);
-    handleConnection(options: WorkerDBOpenerOptions): Promise<ClientConnectionView>;
-    connectToExisting(name: string, lockName: string): Promise<ClientConnectionView>;
-    openConnectionLocally(options: ResolvedWASQLiteOpenFactoryOptions, lockName?: string): Promise<ClientConnectionView>;
-    private databaseOpenAttempt;
-    closeAll(): Promise<void[]>;
-}
-export declare const isSharedWorker: boolean;

package/lib/src/worker/db/WASQLiteDB.worker.d.ts

@@ -1,4 +0,0 @@
-/**
- * Supports both shared and dedicated workers, based on how the worker is constructed (new SharedWorker vs new Worker()).
- */
-import '@journeyapps/wa-sqlite';

package/lib/src/worker/db/WASQLiteDB.worker.js

@@ -1,30 +0,0 @@
-/**
- * Supports both shared and dedicated workers, based on how the worker is constructed (new SharedWorker vs new Worker()).
- */
-import '@journeyapps/wa-sqlite';
-import { createBaseLogger, createLogger } from '@powersync/common';
-import * as Comlink from 'comlink';
-import { isSharedWorker, MultiDatabaseServer } from './MultiDatabaseServer.js';
-const baseLogger = createBaseLogger();
-baseLogger.useDefaults();
-const logger = createLogger('db-worker');
-const server = new MultiDatabaseServer(logger);
-const exposedFunctions = {
-    connect: (config) => server.handleConnection(config),
-    connectToExisting: ({ identifier, lockName }) => server.connectToExisting(identifier, lockName)
-};
-// Check if we're in a SharedWorker context
-if (isSharedWorker) {
-    const _self = self;
-    _self.onconnect = function (event) {
-        const port = event.ports[0];
-        Comlink.expose(exposedFunctions, port);
-    };
-}
-else {
-    // A dedicated worker can be shared externally
-    Comlink.expose(exposedFunctions);
-}
-addEventListener('unload', () => {
-    server.closeAll();
-});

package/lib/src/worker/db/open-worker-database.d.ts

@@ -1,14 +0,0 @@
-import * as Comlink from 'comlink';
-import { WASQLiteVFS } from '../../db/adapters/wa-sqlite/vfs.js';
-import { OpenWorkerConnection } from '../../db/adapters/wa-sqlite/DatabaseClient.js';
-/**
- * Opens a shared or dedicated worker which exposes opening of database connections
- */
-export declare function openWorkerDatabasePort(workerIdentifier: string, multipleTabs?: boolean, worker?: string | URL, vfs?: WASQLiteVFS): Worker | MessagePort;
-/**
- * @returns A function which allows for opening database connections inside
- * a worker.
- */
-export declare function getWorkerDatabaseOpener(workerIdentifier: string, multipleTabs?: boolean, worker?: string | URL): Comlink.Remote<OpenWorkerConnection>;
-export declare function resolveWorkerDatabasePortFactory(worker: () => Worker | SharedWorker): Worker | MessagePort;
-export declare function isSharedWorker(worker: Worker | SharedWorker): worker is SharedWorker;

package/lib/src/worker/db/open-worker-database.js

@@ -1,52 +0,0 @@
-import * as Comlink from 'comlink';
-import { vfsRequiresDedicatedWorkers } from '../../db/adapters/wa-sqlite/vfs.js';
-/**
- * Opens a shared or dedicated worker which exposes opening of database connections
- */
-export function openWorkerDatabasePort(workerIdentifier, multipleTabs = true, worker = '', vfs) {
-    const needsDedicated = vfs && vfsRequiresDedicatedWorkers(vfs);
-    if (worker) {
-        return !needsDedicated && multipleTabs
-            ? new SharedWorker(`${worker}`, {
-                /* @vite-ignore */
-                name: `shared-DB-worker-${workerIdentifier}`
-            }).port
-            : new Worker(`${worker}`, {
-                /* @vite-ignore */
-                name: `DB-worker-${workerIdentifier}`
-            });
-    }
-    else {
-        /**
-         *  Webpack V5 can bundle the worker automatically if the full Worker constructor syntax is used
-         *  https://webpack.js.org/guides/web-workers/
-         *  This enables multi tab support by default, but falls back if SharedWorker is not available
-         *  (in the case of Android)
-         */
-        return !needsDedicated && multipleTabs
-            ? new SharedWorker(new URL('./WASQLiteDB.worker.js', import.meta.url), {
-                /* @vite-ignore */
-                name: `shared-DB-worker-${workerIdentifier}`,
-                type: 'module'
-            }).port
-            : new Worker(new URL('./WASQLiteDB.worker.js', import.meta.url), {
-                /* @vite-ignore */
-                name: `DB-worker-${workerIdentifier}`,
-                type: 'module'
-            });
-    }
-}
-/**
- * @returns A function which allows for opening database connections inside
- * a worker.
- */
-export function getWorkerDatabaseOpener(workerIdentifier, multipleTabs = true, worker = '') {
-    return Comlink.wrap(openWorkerDatabasePort(workerIdentifier, multipleTabs, worker));
-}
-export function resolveWorkerDatabasePortFactory(worker) {
-    const workerInstance = worker();
-    return isSharedWorker(workerInstance) ? workerInstance.port : workerInstance;
-}
-export function isSharedWorker(worker) {
-    return 'port' in worker;
-}

package/lib/src/worker/sync/AbstractSharedSyncClientProvider.d.ts

@@ -1,19 +0,0 @@
-import type { PowerSyncCredentials, SyncStatusOptions } from '@powersync/common';
-/**
- * The client side port should provide these methods.
- */
-export declare abstract class AbstractSharedSyncClientProvider {
-    abstract fetchCredentials(): Promise<PowerSyncCredentials | null>;
-    abstract invalidateCredentials(): void;
-    abstract uploadCrud(): Promise<void>;
-    abstract statusChanged(status: SyncStatusOptions): void;
-    abstract getDBWorkerPort(): Promise<MessagePort>;
-    abstract trace(...x: any[]): void;
-    abstract debug(...x: any[]): void;
-    abstract info(...x: any[]): void;
-    abstract log(...x: any[]): void;
-    abstract warn(...x: any[]): void;
-    abstract error(...x: any[]): void;
-    abstract time(label: string): void;
-    abstract timeEnd(label: string): void;
-}

package/lib/src/worker/sync/BroadcastLogger.d.ts

@@ -1,47 +0,0 @@
-import { type ILogger, type ILogLevel } from '@powersync/common';
-import { type WrappedSyncPort } from './SharedSyncImplementation.js';
-/**
- * Broadcasts logs to all clients
- */
-export declare class BroadcastLogger implements ILogger {
-    protected clients: WrappedSyncPort[];
-    TRACE: ILogLevel;
-    DEBUG: ILogLevel;
-    INFO: ILogLevel;
-    TIME: ILogLevel;
-    WARN: ILogLevel;
-    ERROR: ILogLevel;
-    OFF: ILogLevel;
-    private currentLevel;
-    constructor(clients: WrappedSyncPort[]);
-    trace(...x: any[]): void;
-    debug(...x: any[]): void;
-    info(...x: any[]): void;
-    log(...x: any[]): void;
-    warn(...x: any[]): void;
-    error(...x: any[]): void;
-    time(label: string): void;
-    timeEnd(label: string): void;
-    /**
-     * Set the global log level.
-     */
-    setLevel(level: ILogLevel): void;
-    /**
-     * Get the current log level.
-     */
-    getLevel(): ILogLevel;
-    /**
-     * Returns true if the given level is enabled.
-     */
-    enabledFor(level: ILogLevel): boolean;
-    /**
-     * Iterates all clients, catches individual client exceptions
-     * and proceeds to execute for all clients.
-     */
-    protected iterateClients(callback: (client: WrappedSyncPort) => Promise<void>): Promise<void>;
-    /**
-     * Guards against any logging errors.
-     * We don't want a logging exception to cause further issues upstream
-     */
-    protected sanitizeArgs(x: any[]): any[];
-}

package/lib/src/worker/sync/BroadcastLogger.js

@@ -1,128 +0,0 @@
-import { LogLevel } from '@powersync/common';
-/**
- * Broadcasts logs to all clients
- */
-export class BroadcastLogger {
-    clients;
-    TRACE;
-    DEBUG;
-    INFO;
-    TIME;
-    WARN;
-    ERROR;
-    OFF;
-    currentLevel = LogLevel.INFO;
-    constructor(clients) {
-        this.clients = clients;
-        this.TRACE = LogLevel.TRACE;
-        this.DEBUG = LogLevel.DEBUG;
-        this.INFO = LogLevel.INFO;
-        this.TIME = LogLevel.TIME;
-        this.WARN = LogLevel.WARN;
-        this.ERROR = LogLevel.ERROR;
-        this.OFF = LogLevel.OFF;
-    }
-    trace(...x) {
-        if (!this.enabledFor(this.TRACE))
-            return;
-        console.trace(...x);
-        const sanitized = this.sanitizeArgs(x);
-        this.iterateClients((client) => client.clientProvider.trace(...sanitized));
-    }
-    debug(...x) {
-        if (!this.enabledFor(this.DEBUG))
-            return;
-        console.debug(...x);
-        const sanitized = this.sanitizeArgs(x);
-        this.iterateClients((client) => client.clientProvider.debug(...sanitized));
-    }
-    info(...x) {
-        if (!this.enabledFor(this.INFO))
-            return;
-        console.info(...x);
-        const sanitized = this.sanitizeArgs(x);
-        this.iterateClients((client) => client.clientProvider.info(...sanitized));
-    }
-    log(...x) {
-        if (!this.enabledFor(this.INFO))
-            return;
-        console.log(...x);
-        const sanitized = this.sanitizeArgs(x);
-        this.iterateClients((client) => client.clientProvider.log(...sanitized));
-    }
-    warn(...x) {
-        if (!this.enabledFor(this.WARN))
-            return;
-        console.warn(...x);
-        const sanitized = this.sanitizeArgs(x);
-        this.iterateClients((client) => client.clientProvider.warn(...sanitized));
-    }
-    error(...x) {
-        if (!this.enabledFor(this.ERROR))
-            return;
-        console.error(...x);
-        const sanitized = this.sanitizeArgs(x);
-        this.iterateClients((client) => client.clientProvider.error(...sanitized));
-    }
-    time(label) {
-        if (!this.enabledFor(this.TIME))
-            return;
-        console.time(label);
-        this.iterateClients((client) => client.clientProvider.time(label));
-    }
-    timeEnd(label) {
-        if (!this.enabledFor(this.TIME))
-            return;
-        console.timeEnd(label);
-        this.iterateClients((client) => client.clientProvider.timeEnd(label));
-    }
-    /**
-     * Set the global log level.
-     */
-    setLevel(level) {
-        this.currentLevel = level;
-    }
-    /**
-     * Get the current log level.
-     */
-    getLevel() {
-        return this.currentLevel;
-    }
-    /**
-     * Returns true if the given level is enabled.
-     */
-    enabledFor(level) {
-        return level.value >= this.currentLevel.value;
-    }
-    /**
-     * Iterates all clients, catches individual client exceptions
-     * and proceeds to execute for all clients.
-     */
-    async iterateClients(callback) {
-        for (const client of this.clients) {
-            try {
-                await callback(client);
-            }
-            catch (ex) {
-                console.error('Caught exception when iterating client', ex);
-            }
-        }
-    }
-    /**
-     * Guards against any logging errors.
-     * We don't want a logging exception to cause further issues upstream
-     */
-    sanitizeArgs(x) {
-        const sanitizedParams = x.map((param) => {
-            try {
-                // Try and clone here first. If it fails it won't be passable over a MessagePort
-                return structuredClone(param);
-            }
-            catch (ex) {
-                console.error(ex);
-                return 'Could not serialize log params. Check shared worker logs for more details.';
-            }
-        });
-        return sanitizedParams;
-    }
-}

package/lib/src/worker/sync/SharedSyncImplementation.worker.d.ts

@@ -1 +0,0 @@
-export {};