zapo-js 0.1.0 → 0.1.2

package/dist/client/coordinators/WaAppStateMutationCoordinator.js

@@ -0,0 +1,471 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WaAppStateMutationCoordinator = void 0;
+const constants_1 = require("../../protocol/constants");
+const jid_1 = require("../../protocol/jid");
+const coercion_1 = require("../../util/coercion");
+const primitives_1 = require("../../util/primitives");
+const WA_APP_STATE_MUTATION_FLUSH_SUCCESS_STATES = new Set([
+    constants_1.WA_APP_STATE_COLLECTION_STATES.SUCCESS,
+    constants_1.WA_APP_STATE_COLLECTION_STATES.SUCCESS_HAS_MORE
+]);
+const WA_APP_STATE_ARCHIVE_RANGE_DEFAULT_LIMIT = 256;
+class WaAppStateMutationCoordinator {
+    constructor(options) {
+        this.logger = options.logger;
+        this.messageStore = options.messageStore;
+        this.syncAppState = options.syncAppState;
+        this.archiveRangeLimit = (0, coercion_1.resolvePositive)(options.archiveRangeLimit, WA_APP_STATE_ARCHIVE_RANGE_DEFAULT_LIMIT, 'WaAppStateMutationCoordinatorOptions.archiveRangeLimit');
+        this.pendingMutations = new Map();
+        this.flushPromise = null;
+    }
+    async setChatMute(chatJid, muted, muteEndTimestampMs) {
+        const chatIndexJid = this.normalizeChatMutationJid(chatJid);
+        const timestamp = Date.now();
+        const normalizedMuteEnd = muteEndTimestampMs;
+        if (normalizedMuteEnd !== undefined &&
+            (!Number.isFinite(normalizedMuteEnd) ||
+                !Number.isSafeInteger(normalizedMuteEnd) ||
+                normalizedMuteEnd < 0)) {
+            throw new Error(`invalid muteEndTimestampMs: ${muteEndTimestampMs}`);
+        }
+        if (muted && normalizedMuteEnd === undefined) {
+            throw new Error('setChatMute requires muteEndTimestampMs when muted is true');
+        }
+        const mutation = this.createSetMutation({
+            spec: constants_1.WA_APP_STATE_CHAT_MUTATION_SPECS.MUTE,
+            chatIndexJid,
+            value: {
+                muteAction: {
+                    muted,
+                    ...(normalizedMuteEnd === undefined
+                        ? {}
+                        : { muteEndTimestamp: normalizedMuteEnd })
+                }
+            },
+            timestamp
+        });
+        await this.enqueueAndFlush([mutation]);
+    }
+    async setMessageStar(message, starred) {
+        const messageIndex = this.buildMessageMutationIndex(message);
+        const timestamp = Date.now();
+        const mutation = this.createSetMutation({
+            spec: constants_1.WA_APP_STATE_CHAT_MUTATION_SPECS.STAR,
+            chatIndexJid: messageIndex.chatIndexJid,
+            value: {
+                starAction: {
+                    starred
+                }
+            },
+            timestamp,
+            indexPartsTail: messageIndex.indexPartsTail
+        });
+        await this.enqueueAndFlush([mutation]);
+    }
+    async setChatRead(chatJid, read) {
+        const chatIndexJid = this.normalizeChatMutationJid(chatJid);
+        const timestamp = Date.now();
+        const messageRange = await this.buildChatMessageRange(chatIndexJid);
+        const mutation = this.createSetMutation({
+            spec: constants_1.WA_APP_STATE_CHAT_MUTATION_SPECS.MARK_CHAT_AS_READ,
+            chatIndexJid,
+            value: {
+                markChatAsReadAction: {
+                    read,
+                    messageRange
+                }
+            },
+            timestamp
+        });
+        await this.enqueueAndFlush([mutation]);
+    }
+    async setChatPin(chatJid, pinned) {
+        const chatIndexJid = this.normalizeChatMutationJid(chatJid);
+        const timestamp = Date.now();
+        const pending = [
+            this.createSetMutation({
+                spec: constants_1.WA_APP_STATE_CHAT_MUTATION_SPECS.PIN,
+                chatIndexJid,
+                value: {
+                    pinAction: {
+                        pinned
+                    }
+                },
+                timestamp
+            })
+        ];
+        if (pinned) {
+            pending.push(await this.createArchiveMutation(chatIndexJid, false, timestamp));
+        }
+        await this.enqueueAndFlush(pending);
+    }
+    async setChatArchive(chatJid, archived) {
+        const chatIndexJid = this.normalizeChatMutationJid(chatJid);
+        const timestamp = Date.now();
+        const pending = [
+            await this.createArchiveMutation(chatIndexJid, archived, timestamp)
+        ];
+        if (archived) {
+            pending.push(this.createSetMutation({
+                spec: constants_1.WA_APP_STATE_CHAT_MUTATION_SPECS.PIN,
+                chatIndexJid,
+                value: {
+                    pinAction: {
+                        pinned: false
+                    }
+                },
+                timestamp
+            }));
+        }
+        await this.enqueueAndFlush(pending);
+    }
+    async clearChat(chatJid, options = {}) {
+        const chatIndexJid = this.normalizeChatMutationJid(chatJid);
+        const timestamp = Date.now();
+        const deleteStarred = options.deleteStarred === true;
+        const deleteMedia = options.deleteMedia === true;
+        const messageRange = await this.buildChatMessageRange(chatIndexJid);
+        const mutation = this.createSetMutation({
+            spec: constants_1.WA_APP_STATE_CHAT_MUTATION_SPECS.CLEAR_CHAT,
+            chatIndexJid,
+            value: {
+                clearChatAction: {
+                    messageRange
+                }
+            },
+            timestamp,
+            indexPartsTail: [deleteStarred ? '1' : '0', deleteMedia ? '1' : '0']
+        });
+        await this.enqueueAndFlush([mutation]);
+    }
+    async deleteChat(chatJid, options = {}) {
+        const chatIndexJid = this.normalizeChatMutationJid(chatJid);
+        const timestamp = Date.now();
+        const deleteMedia = options.deleteMedia === true;
+        const messageRange = await this.buildChatMessageRange(chatIndexJid);
+        const mutation = this.createSetMutation({
+            spec: constants_1.WA_APP_STATE_CHAT_MUTATION_SPECS.DELETE_CHAT,
+            chatIndexJid,
+            value: {
+                deleteChatAction: {
+                    messageRange
+                }
+            },
+            timestamp,
+            indexPartsTail: [deleteMedia ? '1' : '0']
+        });
+        await this.enqueueAndFlush([mutation]);
+    }
+    async deleteMessageForMe(message, options = {}) {
+        const messageIndex = this.buildMessageMutationIndex(message);
+        const timestamp = Date.now();
+        const deleteMedia = options.deleteMedia === true;
+        const messageTimestampMs = options.messageTimestampMs;
+        let messageTimestamp;
+        if (messageTimestampMs !== undefined) {
+            if (!Number.isFinite(messageTimestampMs) ||
+                !Number.isSafeInteger(messageTimestampMs) ||
+                messageTimestampMs < 0) {
+                throw new Error(`invalid messageTimestampMs: ${messageTimestampMs}`);
+            }
+            messageTimestamp = Math.floor(messageTimestampMs / 1000);
+        }
+        const mutation = this.createSetMutation({
+            spec: constants_1.WA_APP_STATE_CHAT_MUTATION_SPECS.DELETE_MESSAGE_FOR_ME,
+            chatIndexJid: messageIndex.chatIndexJid,
+            value: {
+                deleteMessageForMeAction: {
+                    deleteMedia,
+                    ...(messageTimestamp === undefined ? {} : { messageTimestamp })
+                }
+            },
+            timestamp,
+            indexPartsTail: messageIndex.indexPartsTail
+        });
+        await this.enqueueAndFlush([mutation]);
+    }
+    async setChatLock(chatJid, locked) {
+        const chatIndexJid = this.normalizeChatMutationJid(chatJid);
+        const timestamp = Date.now();
+        const pending = [];
+        if (locked) {
+            pending.push(await this.createArchiveMutation(chatIndexJid, false, timestamp));
+            pending.push(this.createSetMutation({
+                spec: constants_1.WA_APP_STATE_CHAT_MUTATION_SPECS.PIN,
+                chatIndexJid,
+                value: {
+                    pinAction: {
+                        pinned: false
+                    }
+                },
+                timestamp
+            }));
+        }
+        pending.push(this.createSetMutation({
+            spec: constants_1.WA_APP_STATE_CHAT_MUTATION_SPECS.LOCK_CHAT,
+            chatIndexJid,
+            value: {
+                lockChatAction: {
+                    locked
+                }
+            },
+            timestamp
+        }));
+        await this.enqueueAndFlush(pending);
+    }
+    async flushMutations() {
+        if (this.flushPromise) {
+            return this.flushPromise;
+        }
+        const inFlight = this.flushPendingMutationsLoop();
+        this.flushPromise = inFlight;
+        try {
+            return await inFlight;
+        }
+        finally {
+            if (this.flushPromise === inFlight) {
+                this.flushPromise = null;
+            }
+        }
+    }
+    async enqueueAndFlush(mutations) {
+        for (const mutation of mutations) {
+            this.enqueueMutation(mutation);
+        }
+        await this.flushMutations();
+    }
+    enqueueMutation(mutation) {
+        const key = `${mutation.collection}\u0001${mutation.index}`;
+        if (this.pendingMutations.has(key)) {
+            this.pendingMutations.delete(key);
+        }
+        this.pendingMutations.set(key, mutation);
+    }
+    takePendingMutationsBatch() {
+        if (this.pendingMutations.size === 0) {
+            return [];
+        }
+        const batch = [...this.pendingMutations.values()];
+        this.pendingMutations.clear();
+        return batch;
+    }
+    async flushPendingMutationsLoop() {
+        while (true) {
+            const batch = this.takePendingMutationsBatch();
+            if (batch.length === 0) {
+                return;
+            }
+            this.logger.debug('app-state mutation flush start', {
+                pending: batch.length,
+                actions: this.describeMutationActions(batch)
+            });
+            const collections = [];
+            let syncResult;
+            try {
+                const seenCollections = new Set();
+                for (const mutation of batch) {
+                    if (seenCollections.has(mutation.collection)) {
+                        continue;
+                    }
+                    seenCollections.add(mutation.collection);
+                    collections.push(mutation.collection);
+                }
+                syncResult = await this.syncAppState({
+                    collections,
+                    pendingMutations: batch
+                });
+            }
+            catch (error) {
+                this.requeueMutations(batch);
+                this.logger.warn('app-state mutation flush failed', {
+                    pending: batch.length,
+                    actions: this.describeMutationActions(batch),
+                    message: (0, primitives_1.toError)(error).message
+                });
+                throw (0, primitives_1.toError)(error);
+            }
+            const stateByCollection = new Map();
+            for (const entry of syncResult.collections) {
+                stateByCollection.set(entry.collection, entry.state);
+            }
+            const failedCollections = collections.filter((collection) => {
+                const state = stateByCollection.get(collection);
+                return !state || !WA_APP_STATE_MUTATION_FLUSH_SUCCESS_STATES.has(state);
+            });
+            if (failedCollections.length === 0) {
+                this.logger.debug('app-state mutation flush completed', {
+                    pending: batch.length
+                });
+                continue;
+            }
+            this.requeueMutations(batch.filter((mutation) => failedCollections.includes(mutation.collection)));
+            const error = new Error(`app-state mutation flush incomplete (${failedCollections.join(',')})`);
+            this.logger.warn('app-state mutation flush incomplete', {
+                pending: batch.length,
+                actions: this.describeMutationActions(batch),
+                failedCollections: failedCollections.join(','),
+                message: error.message
+            });
+            throw error;
+        }
+    }
+    requeueMutations(mutations) {
+        if (mutations.length === 0) {
+            return;
+        }
+        const existing = [...this.pendingMutations.values()];
+        this.pendingMutations.clear();
+        for (const mutation of mutations) {
+            this.enqueueMutation(mutation);
+        }
+        for (const mutation of existing) {
+            this.enqueueMutation(mutation);
+        }
+    }
+    createSetMutation(input) {
+        return {
+            collection: input.spec.collection,
+            operation: 'set',
+            index: this.buildMutationIndex(input.spec.action, input.chatIndexJid, input.indexPartsTail ?? []),
+            value: {
+                ...input.value,
+                timestamp: input.timestamp
+            },
+            version: input.spec.version,
+            timestamp: input.timestamp
+        };
+    }
+    async createArchiveMutation(chatIndexJid, archived, timestamp) {
+        const messageRange = await this.buildChatMessageRange(chatIndexJid);
+        return this.createSetMutation({
+            spec: constants_1.WA_APP_STATE_CHAT_MUTATION_SPECS.ARCHIVE,
+            chatIndexJid,
+            value: {
+                archiveChatAction: {
+                    archived,
+                    messageRange
+                }
+            },
+            timestamp
+        });
+    }
+    async buildChatMessageRange(chatIndexJid) {
+        const records = await this.messageStore.listByThread(chatIndexJid, this.archiveRangeLimit);
+        const messages = [];
+        let lastMessageTimestamp;
+        let skippedMissingGroupParticipant = 0;
+        for (const record of records) {
+            const timestampSeconds = this.toOptionalTimestampSeconds(record.timestampMs);
+            const message = this.toChatMessageRangeMessage(record, chatIndexJid, timestampSeconds);
+            if (!message) {
+                skippedMissingGroupParticipant += 1;
+                continue;
+            }
+            if (timestampSeconds !== undefined &&
+                (lastMessageTimestamp === undefined || timestampSeconds > lastMessageTimestamp)) {
+                lastMessageTimestamp = timestampSeconds;
+            }
+            messages.push(message);
+        }
+        if (skippedMissingGroupParticipant > 0) {
+            this.logger.debug('app-state message range skipped invalid group messages', {
+                chatJid: chatIndexJid,
+                skippedMissingGroupParticipant
+            });
+        }
+        return {
+            ...(lastMessageTimestamp === undefined ? {} : { lastMessageTimestamp }),
+            messages
+        };
+    }
+    toChatMessageRangeMessage(record, chatIndexJid, timestampSeconds) {
+        const key = {
+            remoteJid: chatIndexJid,
+            fromMe: record.fromMe,
+            id: record.id
+        };
+        if ((0, jid_1.isGroupJid)(chatIndexJid) && !record.fromMe) {
+            const participant = record.participantJid ?? record.senderJid;
+            if (!participant) {
+                return null;
+            }
+            key.participant = this.normalizeMessageRangeParticipant(participant);
+        }
+        return {
+            key,
+            ...(timestampSeconds === undefined ? {} : { timestamp: timestampSeconds })
+        };
+    }
+    normalizeMessageRangeParticipant(participantJid) {
+        const normalized = (0, jid_1.normalizeRecipientJid)(participantJid);
+        if ((0, jid_1.isGroupOrBroadcastJid)(normalized)) {
+            throw new Error(`invalid group/broadcast participant in message range: ${participantJid}`);
+        }
+        return (0, jid_1.normalizeDeviceJid)(normalized);
+    }
+    toOptionalTimestampSeconds(timestampMs) {
+        if (timestampMs === undefined) {
+            return undefined;
+        }
+        if (!Number.isFinite(timestampMs) ||
+            !Number.isSafeInteger(timestampMs) ||
+            timestampMs < 0) {
+            return undefined;
+        }
+        return Math.floor(timestampMs / 1000);
+    }
+    normalizeChatMutationJid(chatJid) {
+        const normalized = (0, jid_1.normalizeRecipientJid)(chatJid);
+        if ((0, jid_1.isGroupOrBroadcastJid)(normalized)) {
+            return normalized;
+        }
+        return (0, jid_1.toUserJid)(normalized);
+    }
+    buildMessageMutationIndex(message) {
+        const chatIndexJid = this.normalizeChatMutationJid(message.chatJid);
+        const messageId = message.id.trim();
+        if (messageId.length === 0) {
+            throw new Error('message id cannot be empty');
+        }
+        const fromMe = message.fromMe === true;
+        const participant = this.resolveMessageMutationParticipant(chatIndexJid, fromMe, message.participantJid);
+        return {
+            chatIndexJid,
+            indexPartsTail: [messageId, fromMe ? '1' : '0', participant]
+        };
+    }
+    resolveMessageMutationParticipant(chatIndexJid, fromMe, participantJid) {
+        if (fromMe || !(0, jid_1.isGroupOrBroadcastJid)(chatIndexJid)) {
+            return '0';
+        }
+        if (!participantJid) {
+            throw new Error('participantJid is required for incoming message mutations in group/broadcast chats');
+        }
+        const normalized = (0, jid_1.normalizeRecipientJid)(participantJid);
+        if ((0, jid_1.isGroupOrBroadcastJid)(normalized)) {
+            throw new Error(`invalid participantJid for message mutation: ${participantJid}`);
+        }
+        return (0, jid_1.normalizeDeviceJid)(normalized);
+    }
+    buildMutationIndex(action, chatIndexJid, indexPartsTail) {
+        return JSON.stringify([action, chatIndexJid, ...indexPartsTail]);
+    }
+    describeMutationActions(mutations) {
+        return mutations
+            .map((mutation) => {
+            try {
+                const parsed = JSON.parse(mutation.index);
+                if (Array.isArray(parsed) && typeof parsed[0] === 'string') {
+                    return `${mutation.collection}:${parsed[0]}`;
+                }
+            }
+            catch (error) {
+                void error;
+            }
+            return `${mutation.collection}:unknown`;
+        })
+            .join(',');
+    }
+}
+exports.WaAppStateMutationCoordinator = WaAppStateMutationCoordinator;

package/dist/client/coordinators/WaGroupCoordinator.js

@@ -1,24 +1,30 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createGroupCoordinator = createGroupCoordinator;
+const group_1 = require("../events/group");
 const defaults_1 = require("../../protocol/defaults");
-const group_1 = require("../../protocol/group");
+const group_2 = require("../../protocol/group");
 const nodes_1 = require("../../protocol/nodes");
-const group_2 = require("../../transport/node/builders/group");
+const group_3 = require("../../transport/node/builders/group");
 const helpers_1 = require("../../transport/node/helpers");
 const query_1 = require("../../transport/node/query");
 function parseGroupParticipants(node) {
-    const participantNodes = (0, helpers_1.getNodeChildrenByTag)(node, nodes_1.WA_NODE_TAGS.PARTICIPANT);
-    return participantNodes.map((p) => {
-        const type = p.attrs.type ?? group_1.WA_GROUP_PARTICIPANT_TYPES.REGULAR;
-        return {
-            jid: p.attrs.jid,
+    const parsed = (0, group_1.parseParticipants)(node);
+    const participants = [];
+    for (const participant of parsed) {
+        if (!participant.jid) {
+            continue;
+        }
+        const type = participant.role ?? group_2.WA_GROUP_PARTICIPANT_TYPES.REGULAR;
+        participants.push({
+            jid: participant.jid,
             type,
-            isAdmin: type === group_1.WA_GROUP_PARTICIPANT_TYPES.ADMIN ||
-                type === group_1.WA_GROUP_PARTICIPANT_TYPES.SUPERADMIN,
-            isSuperAdmin: type === group_1.WA_GROUP_PARTICIPANT_TYPES.SUPERADMIN
-        };
-    });
+            isAdmin: type === group_2.WA_GROUP_PARTICIPANT_TYPES.ADMIN ||
+                type === group_2.WA_GROUP_PARTICIPANT_TYPES.SUPERADMIN,
+            isSuperAdmin: type === group_2.WA_GROUP_PARTICIPANT_TYPES.SUPERADMIN
+        });
+    }
+    return participants;
 }
 function parseGroupMetadata(node) {
     const groupNode = node.tag === nodes_1.WA_NODE_TAGS.GROUP ? node : (0, helpers_1.findNodeChild)(node, nodes_1.WA_NODE_TAGS.GROUP);
@@ -63,7 +69,7 @@ function createGroupCoordinator(options) {
     const { queryWithContext } = options;
     const changeParticipants = async (action, groupJid, participants) => {
         const context = `group.${action}Participants`;
-        const node = (0, group_2.buildGroupParticipantChangeIq)({
+        const node = (0, group_3.buildGroupParticipantChangeIq)({
             groupJid,
             action,
             participants
@@ -97,8 +103,12 @@ function createGroupCoordinator(options) {
             ]);
             const result = await queryWithContext('group.list', node);
             (0, query_1.assertIqResult)(result, 'group.list');
-            const groupNodes = (0, helpers_1.getNodeChildren)(result).flatMap((child) => (0, helpers_1.getNodeChildrenByTag)(child, nodes_1.WA_NODE_TAGS.GROUP));
-            return groupNodes.map(parseGroupMetadata);
+            const groupNodes = (0, helpers_1.getNodeChildrenByTagFromChildren)(result, nodes_1.WA_NODE_TAGS.GROUP);
+            const metadata = [];
+            for (const groupNode of groupNodes) {
+                metadata.push(parseGroupMetadata(groupNode));
+            }
+            return metadata;
         },
         queryGroupInviteInfo: async (code) => {
             const node = (0, query_1.buildIqNode)('get', defaults_1.WA_DEFAULTS.GROUP_SERVER, nodes_1.WA_XMLNS.GROUPS, [
@@ -109,7 +119,7 @@ function createGroupCoordinator(options) {
             return result;
         },
         createGroup: async (subject, participants, opts) => {
-            const node = (0, group_2.buildCreateGroupIq)({
+            const node = (0, group_3.buildCreateGroupIq)({
                 subject,
                 participants,
                 description: opts?.description
@@ -166,7 +176,7 @@ function createGroupCoordinator(options) {
         promoteParticipants: async (groupJid, participants) => changeParticipants('promote', groupJid, participants),
         demoteParticipants: async (groupJid, participants) => changeParticipants('demote', groupJid, participants),
         leaveGroup: async (groupJids) => {
-            const node = (0, group_2.buildLeaveGroupIq)(groupJids);
+            const node = (0, group_3.buildLeaveGroupIq)(groupJids);
             const result = await queryWithContext('group.leave', node);
             (0, query_1.assertIqResult)(result, 'group.leave');
             return result;

package/dist/client/coordinators/WaIncomingNodeCoordinator.js

@@ -80,14 +80,20 @@ class WaIncomingNodeCoordinator {
         return true;
     }
     async dispatchIncomingNode(node) {
+        const handlersByTag = this.nodeHandlerRegistry.get(node.tag);
+        const nodeSubtype = node.attrs.type;
         if (node.tag === constants_1.WA_MESSAGE_TAGS.RECEIPT) {
-            const handlers = this.getHandlersForNode(node);
-            for (const handler of handlers) {
-                if (await handler(node)) {
-                    if (!this.isRetryReceiptType(node.attrs.type)) {
-                        this.runtime.tryResolvePendingNode(node);
+            if (handlersByTag && handlersByTag.length > 0) {
+                for (const entry of handlersByTag) {
+                    if (entry.subtype !== undefined && entry.subtype !== nodeSubtype) {
+                        continue;
+                    }
+                    if (await entry.handler(node)) {
+                        if (!this.isRetryReceiptType(nodeSubtype)) {
+                            this.runtime.tryResolvePendingNode(node);
+                        }
+                        return true;
                     }
-                    return true;
                 }
             }
             return this.runtime.tryResolvePendingNode(node);
@@ -99,12 +105,14 @@ class WaIncomingNodeCoordinator {
         if (genericHandled) {
             return true;
         }
-        const handlers = this.getHandlersForNode(node);
-        if (handlers.length === 0) {
+        if (!handlersByTag || handlersByTag.length === 0) {
             return false;
         }
-        for (const handler of handlers) {
-            if (await handler(node)) {
+        for (const entry of handlersByTag) {
+            if (entry.subtype !== undefined && entry.subtype !== nodeSubtype) {
+                continue;
+            }
+            if (await entry.handler(node)) {
                 return true;
             }
         }
@@ -113,21 +121,6 @@ class WaIncomingNodeCoordinator {
     isRetryReceiptType(type) {
         return type === 'retry' || type === 'enc_rekey_retry';
     }
-    getHandlersForNode(node) {
-        const handlersByTag = this.nodeHandlerRegistry.get(node.tag);
-        if (!handlersByTag || handlersByTag.length === 0) {
-            return [];
-        }
-        const nodeSubtype = node.attrs.type;
-        const handlers = [];
-        for (const entry of handlersByTag) {
-            if (entry.subtype !== undefined && entry.subtype !== nodeSubtype) {
-                continue;
-            }
-            handlers.push(entry.handler);
-        }
-        return handlers;
-    }
     registerDefaultIncomingHandlers() {
         const runtime = this.runtime;
         this.registerIncomingHandler({
@@ -275,8 +268,8 @@ class WaIncomingNodeCoordinator {
         const ibType = node.attrs.type;
         if (ibType && INFO_BULLETIN_NOTIFICATION_TYPES.has(ibType)) {
             this.runtime.emitIncomingNotification((0, incoming_1.createInfoBulletinNotificationEvent)(node, ibType, {
-                count: (0, parse_1.parseOptionalInt)(node.attrs.count),
-                t: (0, parse_1.parseOptionalInt)(node.attrs.t)
+                count: (0, primitives_1.parseOptionalInt)(node.attrs.count),
+                t: (0, primitives_1.parseOptionalInt)(node.attrs.t)
             }));
             handled = true;
         }