rubika 1.0.4 → 1.0.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rubika",
-  "version": "1.0.4",
+  "version": "1.0.6",
   "author": "Hadi Rostami",
   "main": "src/index.ts",
   "description": "A modern library for Rubika built with Bun.",

package/src/methods/chat/index.ts

@@ -1,3 +1,6 @@
+import banChatMember from './banChatMember';
 import getChat from './getChat';
+import unbanChatMember from './unbanChatMember';
 
-export { getChat };
+
+export { getChat, banChatMember, unbanChatMember };

package/src/methods/index.ts

@@ -170,6 +170,20 @@ export default class Methods {
     return Chat.getChat.apply(this, args);
   }
 
+  async banChatMember(
+    this: Bot,
+    ...args: Parameters<typeof Chat.banChatMember>
+  ): Promise<any> {
+    return Chat.banChatMember.apply(this, args);
+  }
+
+  async unbanChatMember(
+    this: Bot,
+    ...args: Parameters<typeof Chat.unbanChatMember>
+  ): Promise<any> {
+    return Chat.unbanChatMember.apply(this, args);
+  }
+
   // utilities
   async start(
     this: Bot,

package/src/types/utils.ts

@@ -1,9 +1,34 @@
-export type MarkdownEntity = {
-  type: string;
+export type MarkdownType =
+  | "Quote"
+  | "Pre"
+  | "Bold"
+  | "Mono"
+  | "Italic"
+  | "Underline"
+  | "Strike"
+  | "Spoiler"
+  | "Link"
+  | "MentionText";
+
+export interface MetaDataPart {
+  type: MarkdownType;
   from_index: number;
   length: number;
   language?: string;
+  link_url?: string;
+  link?: {
+    type: string;
+    hyperlink_data?: { url: string };
+  };
   mention_text_object_guid?: string;
+  mention_text_user_id?: string;
   mention_text_object_type?: string;
-  link?: { type: string; hyperlink_data: { url: string } };
-};
+}
+
+
+export interface MetadataResult {
+  text: string;
+  metadata?: {
+    meta_data_parts: MetaDataPart[];
+  };
+}

package/src/utils/parser.ts

@@ -1,127 +1,173 @@
-import { MarkdownEntity } from "../types/utils";
-
-class Markdown {
-  static markdownRegExp =
-    /(^|\s|\n)(````?)([\s\S]+?)(````?)([\s\n\.,:?!;]|$)|(^|\s)(`|\*\*|__|~~|--|\|\||\^\^)([^\n]+?)\7([\s\.,:?!;]|$)|@([a-zA-Z0-9]+)\s*\((.+?)\)|\[(.+?)\]\((.+?)\)/m;
-
-  static markdownEntities: Record<string, string> = {
-    "`": "Mono",
-    "**": "Bold",
-    __: "Italic",
-    "||": "Spoiler",
-    "~~": "Strike",
-    "--": "Underline",
-    "^^": "Quote",
-  };
-
-  static toMetadata(text: string): {
-    text: string;
-    metadata?: { meta_data_parts: MarkdownEntity[] };
-  } {
-    let entities: MarkdownEntity[] = [];
-    let match: RegExpMatchArray | null;
-    let remainingText = text;
-    let parsedTextParts: string[] = [];
-    let offset = 0;
+import { MarkdownType, MetaDataPart, MetadataResult } from "../types/utils";
+
+const MENTION_PREFIX_TYPES: Record<string, string> = {
+  u: "User",
+  g: "Group",
+  c: "Channel",
+  b: "Bot",
+};
+
+function buildUtf16PrefixLengths(text: string): number[] {
+  const prefixLengths: number[] = [0];
+  let total = 0;
+  for (const char of text) {
+    total += char.codePointAt(0)! > 0xffff ? 2 : 1;
+    prefixLengths.push(total);
+  }
+  return prefixLengths;
+}
 
-    while ((match = remainingText.match(this.markdownRegExp))) {
-      const matchIndex = offset + (match.index || 0);
-      parsedTextParts.push(remainingText.substring(0, match.index!));
-      let matchedContent = match[3] || match[8] || match[11] || match[13];
-
-      if (matchedContent) {
-        offset -= matchedContent.length;
-        matchedContent = matchedContent.trim();
-        offset += matchedContent.length;
-
-        if (/^`*$/.test(matchedContent)) {
-          parsedTextParts.push(match[0]);
-        } else if (match[3]) {
-          if (match[5] === "\n") {
-            match[5] = "";
-            offset -= 1;
-          }
-          parsedTextParts.push(match[1] + matchedContent + match[5]);
-          entities.push({
-            type: "Pre",
-            language: "",
-            from_index: matchIndex + match[1].length,
-            length: matchedContent.length,
-          });
-          offset -= match[2].length + match[4].length;
-        } else if (match[7]) {
-          parsedTextParts.push(match[6] + matchedContent + match[9]);
-          entities.push({
-            type: this.markdownEntities[match[7]],
-            from_index: matchIndex + match[6].length,
-            length: matchedContent.length,
-          });
-          offset -= 2 * match[7].length;
-        } else if (match[11]) {
-          parsedTextParts.push(matchedContent);
-          entities.push({
-            type: "MentionText",
-            mention_text_object_guid: match[10],
-            from_index: matchIndex,
-            length: matchedContent.length,
-            mention_text_object_type: "User",
-          });
-          offset -= match[0].length - matchedContent.length;
-        } else if (match[12]) {
-          const [label, url] = [match[12], match[13]];
-
-          let mentionType: string | undefined;
-          if (url.length === 32) {
-            if (url.startsWith("u")) mentionType = "User";
-            else if (url.startsWith("g")) mentionType = "Group";
-            else if (url.startsWith("c")) mentionType = "Channel";
+const MARKDOWN_RE =
+  /(?:^(?:> ?[^\n]*\n?)+)|```([\s\S]*?)```|\*\*([^\n*]+?)\*\*|`([^\n`]+?)`|__([^\n_]+?)__|--([^\n-]+?)--|~~([^\n~]+?)~~|\|\|([^\n|]+?)\|\||\[([^\]]+?)\]\((\S+)\)/gms;
+
+const MARKDOWN_TYPE_SEQUENCE: [string, [MarkdownType, number | null]][] = [
+  [">", ["Quote", null]],
+  ["```", ["Pre", 1]],
+  ["**", ["Bold", 2]],
+  ["`", ["Mono", 3]],
+  ["__", ["Italic", 4]],
+  ["--", ["Underline", 5]],
+  ["~~", ["Strike", 6]],
+  ["||", ["Spoiler", 7]],
+  ["[", ["Link", 8]],
+];
+
+export default class Markdown {
+  static toMetadata(text: string): MetadataResult {
+    const metaDataParts: MetaDataPart[] = [];
+    let currentText = text;
+    let offset = 0;
+    let charOffset = 0;
+    const utf16Prefix = buildUtf16PrefixLengths(text);
+
+    let match: RegExpExecArray | null;
+    const globalRegex = new RegExp(MARKDOWN_RE, "gms");
+
+    while ((match = globalRegex.exec(text)) !== null) {
+      const group = match[0];
+      const start = match.index;
+      const end = start + group.length;
+      const adjustedStart = utf16Prefix[start] - offset;
+      const adjustedCharStart = start - charOffset;
+
+      for (const [prefix, [mdType, groupIdx]] of MARKDOWN_TYPE_SEQUENCE) {
+        if (group.startsWith(prefix)) {
+          let content = "";
+          let contentLength = 0;
+          let charContentLength = 0;
+
+          if (mdType === "Quote") {
+            const quoteLines = group.split("\n");
+            const contentLines = quoteLines.map((line) => {
+              if (line.startsWith("> ")) return line.slice(2);
+              if (line.startsWith(">")) return line.slice(1);
+              return line;
+            });
+            content = contentLines.join("\n");
+            charContentLength = content.length;
+            contentLength = Markdown.getUtf16Length(content);
+
+            const innerMeta = this.toMetadata(content);
+            content = innerMeta.text;
+            contentLength = Markdown.getUtf16Length(content);
+            charContentLength = content.length;
+
+            if (innerMeta.metadata) {
+              for (const part of innerMeta.metadata.meta_data_parts) {
+                part.from_index += adjustedStart;
+                metaDataParts.push(part);
+              }
+            }
+          } else {
+            if (groupIdx !== null && match[groupIdx] !== undefined) {
+              content = match[groupIdx] || "";
+              const groupStart = match.index + group.indexOf(content);
+              const groupEnd = groupStart + content.length;
+              contentLength = utf16Prefix[groupEnd] - utf16Prefix[groupStart];
+              charContentLength = content.length;
+
+              if (mdType !== "Pre" && mdType !== "Link") {
+                const innerMeta = this.toMetadata(content);
+                content = innerMeta.text;
+                contentLength = Markdown.getUtf16Length(content);
+                charContentLength = content.length;
+
+                if (innerMeta.metadata) {
+                  for (const part of innerMeta.metadata.meta_data_parts) {
+                    part.from_index += adjustedStart;
+                    metaDataParts.push(part);
+                  }
+                }
+              }
+            } else {
+              content = "";
+              contentLength = 0;
+              charContentLength = 0;
+            }
           }
 
-          parsedTextParts.push(label);
-          const metaDataPart: MarkdownEntity = {
-            type: mentionType ? "MentionText" : "Link",
-            from_index: matchIndex,
-            length: label.length,
+          const metaDataPart: MetaDataPart = {
+            type: mdType,
+            from_index: adjustedStart,
+            length: contentLength,
           };
 
-          if (mentionType) {
-            metaDataPart.mention_text_object_guid = url;
-            metaDataPart.mention_text_object_type = mentionType;
-          } else {
-            metaDataPart.link = { type: "hyperlink", hyperlink_data: { url } };
+          // تنظیمات بر اساس نوع
+          if (mdType === "Pre") {
+            const lines = content.split("\n", 2);
+            const language =
+              lines.length > 1 && lines[0].trim() ? lines[0].trim() : "";
+            metaDataPart.language = language;
+            if (language) {
+              content = lines.slice(1).join("\n");
+              contentLength = Markdown.getUtf16Length(content);
+              charContentLength = content.length;
+            }
+          } else if (mdType === "Link") {
+            const url = match[9];
+            const mentionType = MENTION_PREFIX_TYPES[url?.[0]] || "hyperlink";
+
+            if (mentionType === "hyperlink") {
+              metaDataPart.link_url = url;
+              metaDataPart.link = {
+                type: mentionType,
+                hyperlink_data: { url },
+              };
+            } else {
+              metaDataPart.type = "MentionText";
+              metaDataPart.mention_text_object_guid = url;
+              metaDataPart.mention_text_user_id = url;
+              metaDataPart.mention_text_object_type = mentionType;
+            }
           }
 
-          entities.push(metaDataPart);
-          offset -= match[0].length - label.length;
-        }
+          metaDataParts.push(metaDataPart);
+          currentText =
+            currentText.slice(0, adjustedCharStart) +
+            content +
+            currentText.slice(end - charOffset);
 
-        remainingText = remainingText.substring(match.index! + match[0].length);
-        offset += match.index! + match[0].length;
-      }
-    }
+          const markupLength = utf16Prefix[end] - utf16Prefix[start];
+          const charMarkupLength = end - start;
+          offset += markupLength - contentLength;
+          charOffset += charMarkupLength - charContentLength;
 
-    parsedTextParts.push(remainingText);
-    let resultText = parsedTextParts.join("");
-    if (!resultText.replace(/\s+/g, "").length) {
-      resultText = text;
-      entities.splice(0, entities.length);
-    }
-    if (!entities.length) {
-      resultText = resultText.trim();
+          break;
+        }
+      }
     }
 
-    let returnData: {
-      text: string;
-      metadata?: { meta_data_parts: MarkdownEntity[] };
-    } = {
-      text: resultText,
+    return {
+      text: currentText.trim(),
+      ...(metaDataParts.length > 0 && {
+        metadata: { meta_data_parts: metaDataParts },
+      }),
     };
+  }
 
-    if (entities.length > 0)
-      returnData.metadata = { meta_data_parts: entities };
-
-    return returnData;
+  static getUtf16Length(str: string): number {
+    return str.split("").reduce((len, char) => {
+      return len + (char.codePointAt(0)! > 0xffff ? 2 : 1);
+    }, 0);
   }
 }
-
-export default Markdown;

package/src/utils.ts

@@ -1,11 +1,12 @@
 class Utils {
-  static Code = (text: string): string => "`" + text.trim() + "`";
+  static Mono = (text: string): string => "`" + text.trim() + "`";
+  static Pre = (text: string): string => "```" + text.trim() + "```";
   static Bold = (text: string): string => `**${text.trim()}**`;
   static Italic = (text: string): string => `__${text.trim()}__`;
   static Spoiler = (text: string): string => `||${text.trim()}||`;
   static Strike = (text: string): string => `~~${text.trim()}~~`;
   static Underline = (text: string): string => `--${text.trim()}--`;
-  static Quote = (text: string): string => `^^${text.trim()}^^`;
+  static Quote = (text: string): string => `>${text.trim()}>`;
   static HyperLink = (text: string, link: string): string =>
     `[${text.trim()}](${link.trim()})`;
 }