@nerxa/socketon 0.0.0-stage → 1.21.0

package/src/Utils/html-app.js

@@ -0,0 +1,96 @@
+
+export const HTML_APP_MESSAGE_CEILING = 1024 * 1024;
+
+export const HTML_APP_BYTE_BUDGET = 960 * 1024;
+
+export const HTML_APP_BYTE_LIMIT = HTML_APP_BYTE_BUDGET;
+
+export const wireBytes = (html) => Buffer.byteLength(
+    JSON.stringify(String(html)).replace(/[\u007f-\uffff]/g, (c) => '\\u' + c.charCodeAt(0).toString(16).padStart(4, '0')),
+    'utf-8'
+);
+
+const STORAGE_APIS = ['localStorage', 'sessionStorage', 'indexedDB', 'document.cookie', 'caches'];
+
+const strip = (html) => html
+    .replace(/<!--[\s\S]*?-->/g, '')
+    .replace(/data:[a-z0-9!#$&^_.+-]+\/[a-z0-9!#$&^_.+-]*;base64,[A-Za-z0-9+/=]+/gi, 'data:');
+
+const hasVisibilityGuard = (source) => /document\.(hidden|visibilityState)|visibilitychange|IntersectionObserver|cancelAnimationFrame|clearInterval/.test(source);
+
+export const checkHtmlApp = (html, { height, maxBytes = HTML_APP_BYTE_BUDGET } = {}) => {
+    if (typeof html !== 'string') {
+        throw new TypeError('checkHtmlApp requires an HTML string');
+    }
+
+    const bytes = Buffer.byteLength(html, 'utf-8');
+    const wire = wireBytes(html);
+    const source = strip(html);
+    const problems = [];
+    const warnings = [];
+
+    if (wire > maxBytes) {
+        problems.push(`${Math.round(wire / 1024)}KB on the wire, over the ${Math.round(maxBytes / 1024)}KB budget — a message past ${Math.round(HTML_APP_MESSAGE_CEILING / 1024)}KB is dropped by the receiving client, which logs it and renders nothing, so this one would arrive as silence`);
+    }
+
+    if (wire > bytes * 1.15) {
+        warnings.push(`escaping inflates this page from ${Math.round(bytes / 1024)}KB to ${Math.round(wire / 1024)}KB — every non-ASCII character is rewritten as \\uXXXX, so emoji and accents cost up to three times their size`);
+    }
+
+    const remote = [...source.matchAll(/\b(?:src|href)\s*=\s*["']?(https?:)?\/\//gi)];
+    if (remote.length) {
+        problems.push(`${remote.length} remote subresource${remote.length === 1 ? '' : 's'} — the page runs in an opaque origin with no network, so every one of them fails silently; embed as data: URIs instead`);
+    }
+
+    if (/\bfetch\s*\(|XMLHttpRequest|navigator\.sendBeacon|new\s+EventSource/.test(source)) {
+        problems.push('a call over the HTTP stack — fetch, XHR, sendBeacon and EventSource were measured dead in this WebView, and no securitypolicyviolation fires to tell the page why');
+    }
+
+    const socket = /new\s+WebSocket/.test(source);
+    const peer = /RTCPeerConnection/.test(source);
+    if (socket && !/wss:\/\//.test(source)) {
+        problems.push('a WebSocket on something other than wss:// — the page is not a secure context, and a cleartext ws:// endpoint sends the room and every move in the open');
+    }
+    if ((socket || peer) && !hasVisibilityGuard(source)) {
+        warnings.push('a live connection with nothing closing it — the bubble outlives the screen, so close or pause the socket on visibilitychange');
+    }
+
+    const storage = STORAGE_APIS.filter(api => source.includes(api));
+    if (storage.length) {
+        problems.push(`${storage.join(', ')} — every storage API throws SecurityError in an opaque origin, so the catch branch always runs`);
+    }
+
+    if (/crypto\.subtle/.test(source)) {
+        problems.push('crypto.subtle needs a secure context and this page is not one');
+    }
+
+    const rafLoop = /requestAnimationFrame/.test(source);
+    const interval = /setInterval\s*\(/.test(source);
+    if ((rafLoop || interval) && !hasVisibilityGuard(source)) {
+        problems.push('an animation or timer loop with nothing to stop it — the bubble stays alive while the chat scrolls, so it keeps burning CPU and battery off-screen; gate it on document.hidden or an IntersectionObserver');
+    }
+
+    const reportsHeight = /AndroidBridge\s*\.\s*updateSize/.test(source);
+    if (height === undefined && !reportsHeight) {
+        const pinned = /(?:html|body)[^{}]*\{[^{}]*height\s*:\s*\d/i.test(source);
+        if (!pinned) {
+            warnings.push('no height settled — pass height or autoHeight to sendHtmlApp, or call AndroidBridge.updateSize yourself, or the host and the page measure each other and the card shudders');
+        }
+    }
+
+    if (/aspect-ratio\s*:/i.test(source)) {
+        warnings.push('aspect-ratio makes the height depend on the width, which is the layout chase the host cannot settle');
+    }
+
+    if (/<canvas[^>]*style\s*=\s*["'][^"']*height\s*:\s*auto/i.test(source)) {
+        warnings.push('a canvas at height:auto resizes with the bubble; give it pixel dimensions');
+    }
+
+    const dataUris = [...html.matchAll(/data:[a-z0-9!#$&^_.+-]+\/[a-z0-9!#$&^_.+-]*;base64,([A-Za-z0-9+/=]+)/gi)];
+    const embedded = dataUris.reduce((total, match) => total + match[1].length, 0);
+    if (embedded > bytes * 0.6 && dataUris.length) {
+        warnings.push(`${Math.round(embedded / 1024)}KB of the page is embedded media — shrink it before the byte budget forces you to`);
+    }
+
+    return { ok: problems.length === 0, bytes, wireBytes: wire, embeddedBytes: embedded, problems, warnings };
+};

package/src/Utils/html-multiplayer.d.ts

@@ -0,0 +1,10 @@
+export interface HtmlMultiplayerOptions {
+    url: string
+    room: string
+    seat?: string | number | null
+    reconnectMs?: number
+    maxReconnectMs?: number
+}
+
+export declare function htmlMultiplayerPrelude(options: HtmlMultiplayerOptions): string
+export declare function withHtmlMultiplayer(html: string, options: HtmlMultiplayerOptions): string

package/src/Utils/html-multiplayer.js

@@ -0,0 +1,94 @@
+
+const escapeForScript = (value) => JSON.stringify(value).replace(/</g, '\\u003c').replace(/>/g, '\\u003e');
+
+export const htmlMultiplayerPrelude = ({ url, room, seat, reconnectMs = 1500, maxReconnectMs = 15000 } = {}) => {
+    if (typeof url !== 'string' || !url.startsWith('wss://')) {
+        throw new TypeError('htmlMultiplayerPrelude requires a wss:// url, since the page is not a secure context');
+    }
+    if (typeof room !== 'string' || room.trim() === '') {
+        throw new TypeError('htmlMultiplayerPrelude requires a non-empty room id');
+    }
+
+    const config = escapeForScript({ url, room, seat: seat ?? null, reconnectMs, maxReconnectMs });
+
+    return `<script>
+(function () {
+  var cfg = ${config};
+  var listeners = [];
+  var queue = [];
+  var sock = null;
+  var backoff = cfg.reconnectMs;
+  var closed = false;
+
+  var api = {
+    room: cfg.room,
+    seat: cfg.seat,
+    connected: false,
+    send: function (payload) {
+      var frame = JSON.stringify({ room: cfg.room, seat: cfg.seat, data: payload });
+      if (sock && sock.readyState === 1) sock.send(frame); else queue.push(frame);
+    },
+    on: function (fn) { listeners.push(fn); return function () { listeners = listeners.filter(function (f) { return f !== fn }) } },
+    close: function () { closed = true; if (sock) try { sock.close() } catch (e) {} }
+  };
+
+  function emit(kind, detail) {
+    for (var i = 0; i < listeners.length; i++) {
+      try { listeners[i](kind, detail) } catch (e) {}
+    }
+  }
+
+  function open() {
+    if (closed || (sock && (sock.readyState === 0 || sock.readyState === 1))) return;
+    try { sock = new WebSocket(cfg.url) } catch (e) { emit('error', e); return schedule() }
+
+    sock.onopen = function () {
+      backoff = cfg.reconnectMs;
+      api.connected = true;
+      sock.send(JSON.stringify({ join: cfg.room, seat: cfg.seat }));
+      while (queue.length && sock.readyState === 1) sock.send(queue.shift());
+      emit('open', null);
+    };
+    sock.onmessage = function (event) {
+      var parsed = event.data;
+      try { parsed = JSON.parse(event.data) } catch (e) {}
+      emit('message', parsed);
+    };
+    sock.onclose = function (event) {
+      api.connected = false;
+      emit('close', event.code);
+      schedule();
+    };
+    sock.onerror = function () { api.connected = false };
+  }
+
+  function schedule() {
+    if (closed || document.hidden) return;
+    setTimeout(open, backoff);
+    backoff = Math.min(backoff * 2, cfg.maxReconnectMs);
+  }
+
+  document.addEventListener('visibilitychange', function () {
+    if (document.hidden) {
+      if (sock) try { sock.close() } catch (e) {}
+    } else if (!closed) {
+      backoff = cfg.reconnectMs;
+      open();
+    }
+  });
+
+  window.addEventListener('pagehide', function () { api.close() });
+
+  window.room = api;
+  open();
+})();
+</script>
+`;
+};
+
+export const withHtmlMultiplayer = (html, options) => {
+    if (typeof html !== 'string' || html.trim() === '') {
+        throw new TypeError('withHtmlMultiplayer requires an HTML string');
+    }
+    return htmlMultiplayerPrelude(options) + html;
+};

package/src/Utils/identity-change-handler.d.ts

@@ -0,0 +1,13 @@
+export function handleIdentityChange(node: any, ctx: any): Promise<{
+    action: string;
+    device?: undefined;
+    error?: undefined;
+} | {
+    action: string;
+    device: number;
+    error?: undefined;
+} | {
+    action: string;
+    error: unknown;
+    device?: undefined;
+}>;

package/src/Utils/identity-change-handler.js

@@ -0,0 +1,48 @@
+import { areJidsSameUser, getBinaryNodeChild, jidDecode } from '../WABinary/index.js';
+import { isStringNullOrEmpty } from './generics.js';
+export async function handleIdentityChange(node, ctx) {
+    const from = node.attrs.from;
+    if (!from) {
+        return { action: 'invalid_notification' };
+    }
+    const identityNode = getBinaryNodeChild(node, 'identity');
+    if (!identityNode) {
+        return { action: 'no_identity_node' };
+    }
+    ctx.logger.info({ jid: from }, 'identity changed');
+    const decoded = jidDecode(from);
+    if (decoded?.device && decoded.device !== 0) {
+        ctx.logger.debug({ jid: from, device: decoded.device }, 'ignoring identity change from companion device');
+        return { action: 'skipped_companion_device', device: decoded.device };
+    }
+    const isSelfPrimary = ctx.meId && (areJidsSameUser(from, ctx.meId) || (ctx.meLid && areJidsSameUser(from, ctx.meLid)));
+    if (isSelfPrimary) {
+        ctx.logger.info({ jid: from }, 'self primary identity changed');
+        return { action: 'skipped_self_primary' };
+    }
+    if (ctx.debounceCache.get(from)) {
+        ctx.logger.debug({ jid: from }, 'skipping identity assert (debounced)');
+        return { action: 'debounced' };
+    }
+    ctx.debounceCache.set(from, true);
+    const isOfflineNotification = !isStringNullOrEmpty(node.attrs.offline);
+    const hasExistingSession = await ctx.validateSession(from);
+    if (!hasExistingSession.exists) {
+        ctx.logger.debug({ jid: from }, 'no old session, skipping session refresh');
+        return { action: 'skipped_no_session' };
+    }
+    ctx.logger.debug({ jid: from }, 'old session exists, will refresh session');
+    if (isOfflineNotification) {
+        ctx.logger.debug({ jid: from }, 'skipping session refresh during offline processing');
+        return { action: 'skipped_offline' };
+    }
+    ctx.onBeforeSessionRefresh?.(from);
+    try {
+        await ctx.assertSessions([from], true);
+        return { action: 'session_refreshed' };
+    }
+    catch (error) {
+        ctx.logger.warn({ error, jid: from }, 'failed to assert sessions after identity change');
+        return { action: 'session_refresh_failed', error };
+    }
+}

package/src/Utils/index.d.ts

@@ -0,0 +1,44 @@
+export * from "./generics.js";
+export * from "./decode-wa-message.js";
+export * from "./messages.js";
+export * from "./messages-media.js";
+export * from "./validate-connection.js";
+export * from "./crypto.js";
+export * from "./signal.js";
+export * from "./noise-handler.js";
+export * from "./history.js";
+export * from "./chat-utils.js";
+export * from "./lt-hash.js";
+export * from "./auth-utils.js";
+export * from "./use-multi-file-auth-state.js";
+export * from "./use-single-file-auth-state.js";
+export * from "./use-sqlite-auth-state.js";
+export * from "./auth-store.js";
+export * from "./use-postgres-auth-state.js";
+export * from "./use-mysql-auth-state.js";
+export * from "./use-mongo-auth-state.js";
+export * from "./use-redis-auth-state.js";
+export * from "./link-preview.js";
+export * from "./event-buffer.js";
+export * from "./process-message.js";
+export * from "./message-retry-manager.js";
+export * from "./ttl-cache.js";
+export * from "./browser-utils.js";
+export * from "./companion-reg-client-utils.js";
+export * from "./identity-change-handler.js";
+export * from "./stanza-ack.js";
+export * from "./useNekoDBAuth.js";
+export * from "./modern-messages.js";
+export * from "./sender-key-memory.js";
+export * from "./group-metadata-cache.js";
+export * from "./newsletter-status.js";
+export * from "./voice-recognition.js";
+export * from "./username.js";
+export * from "./scheduled-message.js";
+export * from "./status-stickers.js";
+export * from "./link-preview-metadata.js";
+export * from "./payment-messages.js";
+export * from "./native-flow.js";
+export * from "./html-app.js";
+export * from "./html-multiplayer.js";
+export * from "./optional-media.js";

package/src/Utils/index.js

@@ -0,0 +1,44 @@
+export * from './generics.js';
+export * from './decode-wa-message.js';
+export * from './messages.js';
+export * from './messages-media.js';
+export * from './validate-connection.js';
+export * from './crypto.js';
+export * from './signal.js';
+export * from './noise-handler.js';
+export * from './history.js';
+export * from './chat-utils.js';
+export * from './lt-hash.js';
+export * from './auth-utils.js';
+export * from './use-multi-file-auth-state.js';
+export * from './use-single-file-auth-state.js';
+export * from './use-sqlite-auth-state.js';
+export * from './auth-store.js';
+export * from './use-postgres-auth-state.js';
+export * from './use-mysql-auth-state.js';
+export * from './use-mongo-auth-state.js';
+export * from './use-redis-auth-state.js';
+export * from './link-preview.js';
+export * from './event-buffer.js';
+export * from './process-message.js';
+export * from './message-retry-manager.js';
+export * from './ttl-cache.js';
+export * from './browser-utils.js';
+export * from './companion-reg-client-utils.js';
+export * from './identity-change-handler.js';
+export * from './stanza-ack.js';
+export * from "./useNekoDBAuth.js";
+export * from './modern-messages.js';
+export * from './sender-key-memory.js';
+export * from './group-metadata-cache.js';
+export * from './newsletter-status.js';
+export * from './voice-recognition.js';
+export * from './username.js';
+export * from './scheduled-message.js';
+export * from './status-stickers.js';
+export * from './link-preview-metadata.js';
+export * from './payment-messages.js';
+export * from './native-flow.js';
+export * from './html-app.js';
+export * from './html-multiplayer.js';
+export * from './optional-media.js';

package/src/Utils/link-preview-metadata.d.ts

@@ -0,0 +1,47 @@
+import type { proto } from '../../WAProto/index.js';
+
+export declare const SocialMediaPostType: Readonly<{
+    NONE: 0;
+    REEL: 1;
+    LIVE_VIDEO: 2;
+    LONG_VIDEO: 3;
+    SINGLE_IMAGE: 4;
+    CAROUSEL: 5;
+}>;
+
+export declare function videoEndCard(options?: {
+    username?: string;
+    caption?: string;
+    thumbnailUrl?: string;
+    profilePictureUrl?: string;
+}): proto.Message.IVideoEndCard;
+
+export interface SocialPreviewOptions {
+    postType?: number;
+    videoUrl?: string;
+    videoCaption?: string;
+    muted?: boolean;
+    /** Seconds, not milliseconds — the client stores link_media_duration_seconds. */
+    durationSeconds?: number;
+    experimentId?: number;
+    music?: proto.IEmbeddedMusic;
+    endCards?: proto.Message.IVideoEndCard[];
+}
+
+export declare function buildSocialPreview(options?: SocialPreviewOptions): {
+    linkPreviewMetadata?: proto.Message.ILinkPreviewMetadata;
+    videoContentUrl?: string;
+    musicMetadata?: proto.IEmbeddedMusic;
+    endCardTiles?: proto.Message.IVideoEndCard[];
+};
+
+export declare function readSocialPreview(msg: any): {
+    postType?: number;
+    durationSeconds?: number;
+    muted?: boolean;
+    videoUrl?: string;
+    videoCaption?: string;
+    music?: proto.IEmbeddedMusic;
+    experimentId?: number;
+    endCards?: proto.Message.IVideoEndCard[];
+} | null;

package/src/Utils/link-preview-metadata.js

@@ -0,0 +1,88 @@
+
+export const SocialMediaPostType = Object.freeze({
+    NONE: 0,
+    REEL: 1,
+    LIVE_VIDEO: 2,
+    LONG_VIDEO: 3,
+    SINGLE_IMAGE: 4,
+    CAROUSEL: 5
+})
+
+const drop = (object) => {
+    for (const key of Object.keys(object)) {
+        if (object[key] === undefined || object[key] === null) {
+            delete object[key]
+        }
+    }
+    return object
+}
+
+export const videoEndCard = ({ username, caption, thumbnailUrl, profilePictureUrl } = {}) =>
+    drop({
+        username,
+        caption,
+        thumbnailImageUrl: thumbnailUrl,
+        profilePictureUrl
+    })
+
+/**
+ * The same video url and music node exist twice, once nested in
+ * LinkPreviewMetadata and once directly on ExtendedTextMessage. Which one the
+ * client reads is not visible from the client, so both carry the same value.
+ */
+export const buildSocialPreview = ({
+    postType,
+    videoUrl,
+    videoCaption,
+    muted,
+    durationSeconds,
+    experimentId,
+    music,
+    endCards
+} = {}) => {
+    if (postType !== undefined && !Object.values(SocialMediaPostType).includes(postType)) {
+        throw new TypeError(`postType ${postType} is not one of ${Object.keys(SocialMediaPostType).join(', ')}`)
+    }
+    if (durationSeconds !== undefined && (!Number.isFinite(Number(durationSeconds)) || Number(durationSeconds) < 0)) {
+        throw new TypeError('durationSeconds must be a non-negative number of seconds, not milliseconds')
+    }
+
+    const metadata = drop({
+        socialMediaPostType: postType,
+        linkMediaDuration: durationSeconds === undefined ? undefined : Math.round(Number(durationSeconds)),
+        linkInlineVideoMuted: muted === undefined ? undefined : !!muted,
+        videoContentUrl: videoUrl,
+        videoContentCaption: videoCaption,
+        musicMetadata: music,
+        fbExperimentId: experimentId
+    })
+
+    return drop({
+        linkPreviewMetadata: Object.keys(metadata).length ? metadata : undefined,
+        videoContentUrl: videoUrl,
+        musicMetadata: music,
+        endCardTiles: endCards?.length ? endCards : undefined
+    })
+}
+
+export const readSocialPreview = (msg) => {
+    const message = msg?.message ?? msg
+    const text = message?.extendedTextMessage
+    if (!text) {
+        return null
+    }
+    const metadata = text.linkPreviewMetadata
+    if (!metadata && !text.endCardTiles?.length && !text.videoContentUrl) {
+        return null
+    }
+    return drop({
+        postType: metadata?.socialMediaPostType,
+        durationSeconds: metadata?.linkMediaDuration,
+        muted: metadata?.linkInlineVideoMuted,
+        videoUrl: metadata?.videoContentUrl ?? text.videoContentUrl,
+        videoCaption: metadata?.videoContentCaption,
+        music: metadata?.musicMetadata ?? text.musicMetadata,
+        experimentId: metadata?.fbExperimentId,
+        endCards: text.endCardTiles?.length ? text.endCardTiles : undefined
+    })
+}

package/src/Utils/link-preview.d.ts

@@ -0,0 +1,12 @@
+export function getUrlInfo(text: any, opts?: {
+    thumbnailWidth: number;
+    fetchOpts: {
+        timeout: number;
+    };
+}): Promise<{
+    'canonical-url': any;
+    'matched-text': any;
+    title: any;
+    description: any;
+    originalThumbnailUrl: any;
+} | undefined>;

package/src/Utils/link-preview.js

@@ -0,0 +1,79 @@
+import { prepareWAMessageMedia } from './messages.js';
+import { extractImageThumb, getHttpStream } from './messages-media.js';
+const THUMBNAIL_WIDTH_PX = 192;
+
+const getCompressedJpegThumbnail = async (url, { thumbnailWidth, fetchOpts }) => {
+    const stream = await getHttpStream(url, fetchOpts);
+    const result = await extractImageThumb(stream, thumbnailWidth);
+    return result;
+};
+
+export const getUrlInfo = async (text, opts = {
+    thumbnailWidth: THUMBNAIL_WIDTH_PX,
+    fetchOpts: { timeout: 3000 }
+}) => {
+    try {
+
+        let retries = 0;
+        const maxRetry = 5;
+        const { getLinkPreview } = await import('link-preview-js');
+        let previewLink = text;
+        if (!text.startsWith('https://') && !text.startsWith('http://')) {
+            previewLink = 'https://' + previewLink;
+        }
+        const info = await getLinkPreview(previewLink, {
+            ...opts.fetchOpts,
+            followRedirects: 'follow',
+            handleRedirects: (baseURL, forwardedURL) => {
+                const urlObj = new URL(baseURL);
+                const forwardedURLObj = new URL(forwardedURL);
+                if (retries >= maxRetry) {
+                    return false;
+                }
+                if (forwardedURLObj.hostname === urlObj.hostname ||
+                    forwardedURLObj.hostname === 'www.' + urlObj.hostname ||
+                    'www.' + forwardedURLObj.hostname === urlObj.hostname) {
+                    retries += 1;
+                    return true;
+                }
+                else {
+                    return false;
+                }
+            },
+            headers: opts.fetchOpts?.headers
+        });
+        if (info && 'title' in info && info.title) {
+            const [image] = info.images;
+            const urlInfo = {
+                'canonical-url': info.url,
+                'matched-text': text,
+                title: info.title,
+                description: info.description,
+                originalThumbnailUrl: image
+            };
+            if (opts.uploadImage) {
+                const { imageMessage } = await prepareWAMessageMedia({ image: { url: image } }, {
+                    upload: opts.uploadImage,
+                    mediaTypeOverride: 'thumbnail-link',
+                    options: opts.fetchOpts
+                });
+                urlInfo.jpegThumbnail = imageMessage?.jpegThumbnail ? Buffer.from(imageMessage.jpegThumbnail) : undefined;
+                urlInfo.highQualityThumbnail = imageMessage || undefined;
+            }
+            else {
+                try {
+                    urlInfo.jpegThumbnail = image ? (await getCompressedJpegThumbnail(image, opts)).buffer : undefined;
+                }
+                catch (error) {
+                    opts.logger?.debug({ err: error.stack, url: previewLink }, 'error in generating thumbnail');
+                }
+            }
+            return urlInfo;
+        }
+    }
+    catch (error) {
+        if (!error.message.includes('receive a valid')) {
+            throw error;
+        }
+    }
+};

package/src/Utils/logger.d.ts

@@ -0,0 +1,2 @@
+declare const _default: any;
+export default _default;

package/src/Utils/logger.js

@@ -0,0 +1,2 @@
+import P from 'pino';
+export default P({ timestamp: () => `,"time":"${new Date().toJSON()}"` });

package/src/Utils/lt-hash.d.ts

@@ -0,0 +1,6 @@
+/**
+ * LT Hash is a summation based hash algorithm that maintains the integrity of a piece of data
+ * over a series of mutations. You can add/remove mutations and it'll return a hash equal to
+ * if the same series of mutations was made sequentially.
+ */
+export const LT_HASH_ANTI_TAMPERING: any;

package/src/Utils/lt-hash.js

@@ -0,0 +1,3 @@
+import { LTHashAntiTampering } from '@rexxhayanasi/wangcap-id-bridge';
+
+export const LT_HASH_ANTI_TAMPERING = new LTHashAntiTampering();

package/src/Utils/make-mutex.d.ts

@@ -0,0 +1,6 @@
+export function makeMutex(): {
+    mutex(code: any): any;
+};
+export function makeKeyedMutex(): {
+    mutex(key: any, task: any): Promise<any>;
+};

package/src/Utils/make-mutex.js

@@ -0,0 +1,32 @@
+import { Mutex as AsyncMutex } from 'async-mutex';
+export const makeMutex = () => {
+    const mutex = new AsyncMutex();
+    return {
+        mutex(code) {
+            return mutex.runExclusive(code);
+        }
+    };
+};
+export const makeKeyedMutex = () => {
+    const map = new Map();
+    return {
+        async mutex(key, task) {
+            let entry = map.get(key);
+            if (!entry) {
+                entry = { mutex: new AsyncMutex(), refCount: 0 };
+                map.set(key, entry);
+            }
+            entry.refCount++;
+            try {
+                return await entry.mutex.runExclusive(task);
+            }
+            finally {
+                entry.refCount--;
+
+                if (entry.refCount === 0 && map.get(key) === entry) {
+                    map.delete(key);
+                }
+            }
+        }
+    };
+};