@nuiisweety/baileys 0.1.1 → 0.1.2

package/lib/Utils/rich-message-utils.js.bak

@@ -0,0 +1,246 @@
+import { getRandomValues, randomUUID, randomBytes } from 'crypto';
+import { DONATE_URL, LEXER_REGEX } from '../Defaults/index.js';
+import { LANGUAGE_KEYWORDS } from '../WABinary/constants.js';
+import { CodeHighlightType, RichSubMessageType } from '../Types/RichType.js';
+import { proto } from '../../WAProto/index.js';
+import { unixTimestampSeconds } from './generics.js';
+const NOOP = new Set([]);
+export const tokenizeCode = (code, language = 'javascript') => {
+    const keywords = LANGUAGE_KEYWORDS[language] || NOOP;
+    const blocks = [];
+    LEXER_REGEX.lastIndex = 0;
+    let match;
+    while ((match = LEXER_REGEX.exec(code)) !== null) {
+        if (match[1]) {
+            blocks.push({ highlightType: CodeHighlightType.COMMENT, codeContent: match[1] });
+        }
+        else if (match[2]) {
+            blocks.push({ highlightType: CodeHighlightType.STRING, codeContent: match[2] });
+        }
+        else if (match[3]) {
+            blocks.push({
+                highlightType: keywords.has(match[3]) ? CodeHighlightType.KEYWORD : CodeHighlightType.METHOD,
+                codeContent: match[3],
+            });
+        }
+        else if (match[4]) {
+            blocks.push({
+                highlightType: keywords.has(match[4]) ? CodeHighlightType.KEYWORD : CodeHighlightType.DEFAULT,
+                codeContent: match[4],
+            });
+        }
+        else if (match[5]) {
+            blocks.push({ highlightType: CodeHighlightType.NUMBER, codeContent: match[5] });
+        }
+        else {
+            blocks.push({ highlightType: CodeHighlightType.DEFAULT, codeContent: match[6] });
+        }
+    }
+    return blocks;
+};
+export const toUnified = (submessages) => ({
+    response_id: randomUUID(),
+    sections: submessages.map((submessage, index) => {
+        switch (submessage.messageType) {
+            case RichSubMessageType.CODE:
+                const codeMetadata = submessage.codeMetadata;
+                return {
+                    view_model: {
+                        primitive: {
+                            language: codeMetadata.codeLanguage,
+                            code_blocks: codeMetadata.codeBlocks.map((block) => ({ content: block.codeContent, type: CodeHighlightType[block.highlightType] })),
+                            __typename: 'GenAICodeUXPrimitive'
+                        },
+                        __typename: 'GenAISingleLayoutViewModel'
+                    }
+                };
+            case RichSubMessageType.TABLE:
+                const tableMetadata = submessage.tableMetadata;
+                return {
+                    view_model: {
+                        primitive: {
+                            title: tableMetadata.title,
+                            rows: tableMetadata.rows.map((row) => ({
+                                is_header: row.isHeading,
+                                cells: row.items,
+                                markdown_cells: row.items.map((item) => ({ text: item }))
+                            })),
+                            __typename: 'GenATableUXPrimitive'
+                        },
+                        __typename: 'GenAISingleLayoutViewModel'
+                    }
+                };
+            case RichSubMessageType.TEXT:
+                return {
+                    view_model: {
+                        primitive: {
+                            text: submessage.messageText,
+                            inline_entities: submessage.inlineEntities || [],
+                            __typename: 'GenAIMarkdownTextUXPrimitive'
+                        },
+                        __typename: 'GenAISingleLayoutViewModel'
+                    }
+                };
+        }
+        return submessage;
+    })
+});
+export const prepareRichResponseMessage = (content) => {
+    const { code, contentText, disclaimerText, footerText, headerText, language, links, noHeading, richResponse, table, title } = content;
+    let submessages = [];
+    if (Array.isArray(richResponse)) {
+        submessages = richResponse.map((submessage) => {
+            if (submessage.text) {
+                return {
+                    messageType: RichSubMessageType.TEXT,
+                    messageText: submessage.text,
+                    inlineEntities: submessage.inlineEntities
+                };
+            }
+            else if (submessage.code) {
+                return {
+                    messageType: RichSubMessageType.CODE,
+                    codeMetadata: {
+                        codeLanguage: submessage.language,
+                        codeBlocks: submessage.code
+                    }
+                };
+            }
+            else if (submessage.table) {
+                return {
+                    messageType: RichSubMessageType.TABLE,
+                    tableMetadata: {
+                        title: submessage.title,
+                        rows: submessage.table
+                    }
+                };
+            }
+            return submessage;
+        });
+    }
+    else {
+        if (headerText) {
+            submessages.push({
+                messageType: RichSubMessageType.TEXT,
+                messageText: headerText
+            });
+        }
+        if (contentText) {
+            submessages.push({
+                messageType: RichSubMessageType.TEXT,
+                messageText: contentText
+            });
+        }
+        if (code) {
+            language ||= 'javascript';
+            submessages.push({
+                messageType: RichSubMessageType.CODE,
+                codeMetadata: {
+                    codeLanguage: language,
+                    codeBlocks: tokenizeCode(code, language)
+                }
+            });
+        }
+        else if (links) {
+            links.forEach((linkField, index) => {
+                const prefix = 'SS_' + index;
+                const url = linkField.url || DONATE_URL;
+                const sources = linkField.sources?.map((sourceField) => ({
+                    source_type: 'THIRD_PARTY',
+                    source_display_name: sourceField.displayName || 'Donate',
+                    source_subtitle: sourceField.subtitle || 'Saweria',
+                    source_url: sourceField.url || url
+                }));
+                submessages.push({
+                    messageType: RichSubMessageType.TEXT,
+                    messageText: linkField.text + ` {{${prefix}}}¹{{/${prefix}}} `,
+                    inlineEntities: [{
+                            key: prefix,
+                            metadata: {
+                                reference_id: index + 1,
+                                reference_url: url,
+                                reference_title: linkField.title || 'For Donation via Saweria',
+                                reference_display_name: linkField.displayName || 'Donation',
+                                sources: sources || [],
+                                __typename: 'GenAISearchCitationItem'
+                            }
+                        }]
+                });
+            });
+        }
+        else if (table) {
+            submessages.push({
+                messageType: RichSubMessageType.TABLE,
+                tableMetadata: {
+                    title,
+                    rows: table.map((items, index) => ({
+                        isHeading: !noHeading && index == 0,
+                        items
+                    }))
+                }
+            });
+        }
+        if (footerText) {
+            submessages.push({
+                messageType: RichSubMessageType.TEXT,
+                messageText: footerText
+            });
+        }
+    }
+    const unified = toUnified(submessages);
+    const richResponseMessage = proto.AIRichResponseMessage.create({
+        submessages,
+        messageType: proto.AIRichResponseMessageType.AI_RICH_RESPONSE_TYPE_STANDARD,
+        unifiedResponse: {
+            data: Buffer.from(JSON.stringify(unified), 'utf-8')
+        },
+        contextInfo: {
+            isForwarded: true,
+            forwardingScore: 1,
+            forwardedAiBotMessageInfo: { botJid: '867051314767696@bot' },
+            forwardOrigin: 4
+        }
+    });
+    const message = wrapToBotForwardedMessage(richResponseMessage);
+    const botMetadata = message.messageContextInfo.botMetadata;
+    if (disclaimerText) {
+        botMetadata.messageDisclaimerText = disclaimerText;
+    }
+    botMetadata.botResponseId = unified.response_id;
+    return message;
+};
+export const botMetadataSignature = () => {
+    const signature = new Uint8Array(64);
+    getRandomValues(signature);
+    return signature;
+};
+export const botMetadataCertificate = (length = 685) => {
+    const certificate = new Uint8Array(length);
+    certificate[0] = 48;
+    certificate[1] = 130;
+    getRandomValues(certificate.subarray(2));
+    return certificate;
+};
+export const wrapToBotForwardedMessage = (richResponseMessage) => ({
+    messageContextInfo: {
+        botMetadata: {
+            verificationMetadata: {
+                proofs: [
+                    {
+                        certificateChain: [
+                            botMetadataCertificate(),
+                            botMetadataCertificate(892)
+                        ],
+                        version: 1,
+                        useCase: 1,
+                        signature: botMetadataSignature()
+                    }
+                ]
+            }
+        }
+    },
+    botForwardedMessage: {
+        message: { richResponseMessage }
+    }
+});
+//# sourceMappingURL=rich-message-utils.js.map

package/lib/WABinary/constants.js

@@ -1354,6 +1354,90 @@ export const RUST_KEYWORDS = new Set([
     'where', 'while', 'async', 'await', 'dyn', 'abstract', 'become', 'box', 'do', 'final',
     'macro', 'override', 'priv', 'typeof', 'unsized', 'virtual', 'yield'
 ]);
+export const JAVA_KEYWORDS = new Set([
+    'abstract', 'assert', 'boolean', 'break', 'byte', 'case', 'catch', 'char', 'class', 'const',
+    'continue', 'default', 'do', 'double', 'else', 'enum', 'extends', 'final', 'finally', 'float',
+    'for', 'goto', 'if', 'implements', 'import', 'instanceof', 'int', 'interface', 'long', 'native',
+    'new', 'package', 'private', 'protected', 'public', 'return', 'short', 'static', 'strictfp',
+    'super', 'switch', 'synchronized', 'this', 'throw', 'throws', 'transient', 'try', 'void',
+    'volatile', 'while', 'true', 'false', 'null', 'var', 'record', 'sealed', 'permits', 'yield'
+]);
+export const PHP_KEYWORDS = new Set([
+    'abstract', 'and', 'array', 'as', 'break', 'callable', 'case', 'catch', 'class', 'clone',
+    'const', 'continue', 'declare', 'default', 'do', 'echo', 'else', 'elseif', 'empty',
+    'enddeclare', 'endfor', 'endforeach', 'endif', 'endswitch', 'endwhile', 'enum', 'extends',
+    'final', 'finally', 'fn', 'for', 'foreach', 'function', 'global', 'goto', 'if', 'implements',
+    'include', 'include_once', 'instanceof', 'insteadof', 'interface', 'isset', 'list', 'match',
+    'namespace', 'new', 'or', 'print', 'private', 'protected', 'public', 'readonly', 'require',
+    'require_once', 'return', 'static', 'switch', 'throw', 'trait', 'try', 'unset', 'use',
+    'var', 'while', 'xor', 'yield', 'true', 'false', 'null'
+]);
+export const RUBY_KEYWORDS = new Set([
+    'alias', 'and', 'begin', 'break', 'case', 'class', 'def', 'defined?', 'do', 'else', 'elsif',
+    'end', 'ensure', 'false', 'for', 'if', 'in', 'module', 'next', 'nil', 'not', 'or', 'redo',
+    'rescue', 'retry', 'return', 'self', 'super', 'then', 'true', 'undef', 'unless', 'until',
+    'when', 'while', 'yield', 'puts', 'print', 'require', 'require_relative', 'attr_accessor',
+    'attr_reader', 'attr_writer', 'private', 'protected', 'public', 'include', 'extend'
+]);
+export const KOTLIN_KEYWORDS = new Set([
+    'as', 'as?', 'break', 'class', 'continue', 'do', 'else', 'false', 'for', 'fun', 'if', 'in',
+    '!in', 'interface', 'is', '!is', 'null', 'object', 'package', 'return', 'super', 'this',
+    'throw', 'true', 'try', 'typealias', 'typeof', 'val', 'var', 'when', 'while', 'by', 'catch',
+    'constructor', 'delegate', 'dynamic', 'field', 'file', 'finally', 'get', 'import', 'init',
+    'param', 'property', 'receiver', 'set', 'setparam', 'value', 'where', 'abstract', 'actual',
+    'annotation', 'companion', 'crossinline', 'data', 'enum', 'expect', 'external', 'final',
+    'infix', 'inline', 'inner', 'internal', 'lateinit', 'noinline', 'open', 'operator', 'out',
+    'override', 'private', 'protected', 'public', 'reified', 'sealed', 'suspend', 'tailrec',
+    'vararg', 'it', 'Unit', 'Nothing', 'Any', 'Int', 'Long', 'Double', 'Float', 'Boolean',
+    'String', 'Char', 'Byte', 'Short', 'List', 'Map', 'Set', 'MutableList', 'MutableMap'
+]);
+export const SWIFT_KEYWORDS = new Set([
+    'associatedtype', 'class', 'deinit', 'enum', 'extension', 'fileprivate', 'func', 'import',
+    'init', 'inout', 'internal', 'let', 'open', 'operator', 'private', 'precedencegroup',
+    'protocol', 'public', 'rethrows', 'static', 'struct', 'subscript', 'typealias', 'var',
+    'break', 'case', 'catch', 'continue', 'default', 'defer', 'do', 'else', 'fallthrough',
+    'for', 'guard', 'if', 'in', 'repeat', 'return', 'throw', 'switch', 'where', 'while',
+    'any', 'as', 'await', 'false', 'is', 'nil', 'self', 'Self', 'super', 'throws', 'true', 'try',
+    'async', 'convenience', 'dynamic', 'didSet', 'final', 'get', 'indirect', 'lazy', 'mutating',
+    'nonmutating', 'optional', 'override', 'postfix', 'prefix', 'required', 'set', 'some',
+    'unowned', 'weak', 'willSet', 'String', 'Int', 'Double', 'Float', 'Bool', 'Array', 'Dictionary'
+]);
+export const SQL_KEYWORDS = new Set([
+    'SELECT', 'FROM', 'WHERE', 'INSERT', 'INTO', 'VALUES', 'UPDATE', 'SET', 'DELETE', 'CREATE',
+    'TABLE', 'DROP', 'ALTER', 'ADD', 'COLUMN', 'INDEX', 'VIEW', 'DATABASE', 'SCHEMA', 'TRUNCATE',
+    'JOIN', 'INNER', 'LEFT', 'RIGHT', 'FULL', 'OUTER', 'CROSS', 'ON', 'AS', 'UNION', 'ALL',
+    'DISTINCT', 'ORDER', 'BY', 'GROUP', 'HAVING', 'LIMIT', 'OFFSET', 'ASC', 'DESC',
+    'AND', 'OR', 'NOT', 'IN', 'LIKE', 'BETWEEN', 'IS', 'NULL', 'EXISTS', 'CASE', 'WHEN',
+    'THEN', 'ELSE', 'END', 'IF', 'COALESCE', 'NULLIF', 'CAST', 'CONVERT',
+    'COUNT', 'SUM', 'AVG', 'MAX', 'MIN', 'ROUND', 'LENGTH', 'UPPER', 'LOWER', 'TRIM',
+    'PRIMARY', 'KEY', 'FOREIGN', 'REFERENCES', 'UNIQUE', 'DEFAULT', 'NOT', 'CONSTRAINT',
+    'BEGIN', 'COMMIT', 'ROLLBACK', 'TRANSACTION', 'AUTO_INCREMENT', 'SERIAL', 'RETURNING',
+    'select', 'from', 'where', 'insert', 'into', 'values', 'update', 'delete', 'create',
+    'table', 'drop', 'alter', 'join', 'left', 'right', 'inner', 'outer', 'on', 'as',
+    'and', 'or', 'not', 'in', 'like', 'is', 'null', 'order', 'group', 'by', 'having', 'limit'
+]);
+export const C_KEYWORDS = new Set([
+    'auto', 'break', 'case', 'char', 'const', 'continue', 'default', 'do', 'double', 'else',
+    'enum', 'extern', 'float', 'for', 'goto', 'if', 'inline', 'int', 'long', 'register',
+    'restrict', 'return', 'short', 'signed', 'sizeof', 'static', 'struct', 'switch', 'typedef',
+    'union', 'unsigned', 'void', 'volatile', 'while', '_Alignas', '_Alignof', '_Atomic',
+    '_Bool', '_Complex', '_Generic', '_Imaginary', '_Noreturn', '_Static_assert', '_Thread_local',
+    'true', 'false', 'NULL', 'include', 'define', 'ifdef', 'ifndef', 'endif', 'pragma'
+]);
+export const BASH_KEYWORDS = new Set([
+    'if', 'then', 'else', 'elif', 'fi', 'case', 'esac', 'for', 'select', 'while', 'until',
+    'do', 'done', 'in', 'function', 'time', 'coproc', 'echo', 'exit', 'return', 'break',
+    'continue', 'source', 'export', 'local', 'declare', 'readonly', 'unset', 'shift', 'trap',
+    'exec', 'eval', 'alias', 'unalias', 'set', 'unset', 'read', 'printf', 'test', 'let',
+    'true', 'false', 'null', 'cd', 'pwd', 'ls', 'grep', 'sed', 'awk', 'cat', 'mkdir',
+    'rm', 'cp', 'mv', 'chmod', 'chown', 'curl', 'wget', 'tar', 'zip', 'sudo', 'apt', 'npm'
+]);
+export const JSON_KEYWORDS = new Set([
+    'true', 'false', 'null'
+]);
+export const YAML_KEYWORDS = new Set([
+    'true', 'false', 'null', 'yes', 'no', 'on', 'off', 'include', 'extends', 'anchor'
+]);
 export const LANGUAGE_KEYWORDS = {
     css: CSS_KEYWORDS,
     html: HTML_KEYWORDS,
@@ -1369,5 +1453,23 @@ export const LANGUAGE_KEYWORDS = {
     'c++': CPP_KEYWORDS,
     rust: RUST_KEYWORDS,
     rs: RUST_KEYWORDS,
+    java: JAVA_KEYWORDS,
+    php: PHP_KEYWORDS,
+    ruby: RUBY_KEYWORDS,
+    rb: RUBY_KEYWORDS,
+    kotlin: KOTLIN_KEYWORDS,
+    kt: KOTLIN_KEYWORDS,
+    swift: SWIFT_KEYWORDS,
+    sql: SQL_KEYWORDS,
+    mysql: SQL_KEYWORDS,
+    postgresql: SQL_KEYWORDS,
+    sqlite: SQL_KEYWORDS,
+    c: C_KEYWORDS,
+    bash: BASH_KEYWORDS,
+    sh: BASH_KEYWORDS,
+    shell: BASH_KEYWORDS,
+    json: JSON_KEYWORDS,
+    yaml: YAML_KEYWORDS,
+    yml: YAML_KEYWORDS,
 };
 //# sourceMappingURL=constants.js.map