gramstax 0.0.1 → 0.0.2

package/src/core/ctx.ts

@@ -1,177 +0,0 @@
-import { CacheExternal } from "../cache"
-import { setTimeout } from "node:timers/promises"
-import { BaseGeneral } from "../base"
-import { TemplateManager } from "../template"
-import { InlineKeyboard, Keyboard, type Context } from "grammy"
-
-export class Ctx extends BaseGeneral {
-  public data = (this as any).constructor.data as { name: string; callbackData: (...args: any) => string | any } // for internal access (this.**). example this.data.callbackData
-
-  public get isPremium() {
-    return this.ct.from?.is_premium ?? false
-  }
-  public get isBot() {
-    return this.ct.from?.is_bot ?? false
-  }
-  public get userid() {
-    return this.ct.from?.id as number
-  }
-  public get username() {
-    return this.ct.from?.username as string
-  }
-  public get fullname() {
-    return `${this.ct.from?.first_name || ``}${this.ct.from?.last_name || ``}`
-  }
-  public get firstname() {
-    return this.ct.from?.first_name as string
-  }
-  public get lastname() {
-    return this.ct.from?.last_name as string
-  }
-  public get msgText() {
-    return this.ct.message?.text as string
-  }
-  public get msgTextIntent() {
-    return this.msgText && this.msgText.indexOf(` `) != -1 ? (this.msgText.split(` `)[0] as string) : ``
-  }
-  public get msgTextPayloads() {
-    return this.msgText && this.msgText.indexOf(` `) != -1 ? (this.msgText.split(` `).slice(1) as any[]) : ([] as any[])
-  }
-  public get msgTextPayload() {
-    return this.msgTextPayloads[0] as string
-  }
-  public get msgCaption() {
-    return this.ct.message?.caption as string
-  }
-  public get msgCaptionIntent() {
-    return this.msgCaption && this.msgCaption.indexOf(` `) != -1 ? (this.msgCaption.split(` `)[0] as string) : ``
-  }
-  public get msgPhoto() {
-    return this.ct.message?.photo
-  }
-  public get msgVideo() {
-    return this.ct.message?.video
-  }
-  public get msgAudio() {
-    return this.ct.message?.audio
-  }
-  public get callbackData() {
-    return this.ct.callbackQuery?.data as string
-  }
-  public get callbackDataIntent() {
-    return this.callbackData && this.callbackData.indexOf(`:`) != -1 ? (this.callbackData.split(`:`)[0] as string) : ``
-  }
-  public get callbackDataPayloads() {
-    return this.callbackData && this.callbackData.indexOf(`:`) != -1 ? (this.callbackData.split(`:`).slice(1) as any[]) : ([] as any[])
-  }
-  public get callbackDataPayload() {
-    return this.callbackDataPayloads?.[0] as string
-  }
-  public get callbackDataParts() {
-    return this.callbackDataPayload && this.callbackDataPayload.indexOf(`+`) != -1 ? (this.callbackDataPayload.split(`+`) as any[]) : ([] as any[])
-  }
-  public get languageCode() {
-    return this.ct.from?.language_code as string
-  }
-  public set languageCode(v: any) {
-    ;(this as any).ct.from.language_code = v
-  }
-
-  public session: { method?: string; params?: any } = {}
-  public constructor(public ct: Context, public templateManager: TemplateManager, public cacheSession: CacheExternal, public cacheKeyboard: Map<any, any>) {
-    super()
-  }
-
-  public async broadcast(ids: any[], languageCode: any[], keyboard?: Keyboard | InlineKeyboard, data?: Record<string, any>, baseId?: string, options?: any) {
-    const limitFree = 30
-    const msgs = languageCode.map((it) => this.templateManager.getMessage(this.data.name, baseId, it, data)) as any[]
-    for (let index = 0; index < ids.length; index++) {
-      const id = ids[index]
-      const msg = msgs[index]
-      await this.ct.api.sendMessage(id, msg, {
-        parse_mode: `HTML`,
-        reply_markup: keyboard,
-        ...options
-      })
-
-      if (index + 1 == limitFree) {
-        await setTimeout(1200)
-      }
-    }
-  }
-
-  public async reply(keyboard?: Keyboard | InlineKeyboard, data?: Record<string, any>, baseId?: string, options?: any) {
-    const msg = this.templateManager.getMessage(this.data.name, baseId, this.languageCode, data)
-    return await this.ct.reply(msg, {
-      parse_mode: `HTML`,
-      reply_markup: keyboard,
-      ...options
-    })
-  }
-
-  public async replyAction(type: Parameters<typeof this.ct.replyWithChatAction>[0]) {
-    return await this.ct.replyWithChatAction(type)
-  }
-
-  public async edit(keyboard?: Keyboard | InlineKeyboard, data?: Record<string, any>, baseId?: string, options?: any) {
-    try {
-      const msg = this.templateManager.getMessage(this.data.name, baseId, this.languageCode, data)
-      return await this.ct.editMessageText(msg, {
-        parse_mode: `HTML`,
-        reply_markup: keyboard,
-        ...options
-      })
-    } catch (error) {
-      await this.reply(keyboard, data, baseId, options)
-    }
-  }
-
-  public async delete() {
-    return await this.ct.deleteMessage()
-  }
-
-  public async callbackQueryAnswer(options?: any) {
-    try {
-      return await this.ct.answerCallbackQuery(options)
-    } catch {
-      return null
-    }
-  }
-
-  public async sessionSet(method: string, params: any, ...moreRoot: any) {
-    try {
-      const value = { method, params, ...moreRoot }
-      const result = await this.cacheSession.set(`${this.userid}`, { method, params, ...moreRoot })
-      if (result) {
-        this.session = value
-      }
-      return result
-    } catch {
-      return null
-    }
-  }
-
-  public async sessionGet(): Promise<{ method: string; params: any; [moreRoot: string]: any } | null> {
-    try {
-      const result = await this.cacheSession.get(`${this.userid}`)
-      if (result) {
-        this.session = result
-      }
-      return result || null
-    } catch {
-      return null
-    }
-  }
-
-  public async sessionClear() {
-    try {
-      const result = await this.cacheSession.delete(`${this.userid}`)
-      if (result) {
-        this.session = {}
-      }
-      return result
-    } catch {
-      return null
-    }
-  }
-}

package/src/core/index.ts

@@ -1,2 +0,0 @@
-export * from "./bot"
-export * from "./ctx"

package/src/grammy/index.ts

@@ -1 +0,0 @@
-export * from "grammy"

package/src/index.ts

@@ -1,4 +0,0 @@
-export * from "./base"
-export * from "./cache"
-export * from "./core"
-export * from "./template"

package/src/template/engine.ts

@@ -1,167 +0,0 @@
-export class TemplateEngine {
-  public static _escape(str: string): string {
-    return str
-      .replace(/\\/g, `\\\\`) // escape backslash: \ → \\
-      .replace(/`/g, `\\\``) // escape backtick: ` → \`
-  }
-
-  public static _processVariables(template: string) {
-    return template.replace(/\{\{(\w+)\}\}/g, (_, key) => `\${(data && data["${key}"]) ?? ""}`)
-  }
-
-  public static _processBaseBlocks(template: string) {
-    const baseRegex = /<base\b[^>]*?(?:\sid=(["']?)([^"'\s>]+)\1)?[^>]*?>([\s\S]*?)<\/base>/g
-    const result: {
-      [baseId: string]: string
-    } = {}
-
-    for (const match of template.matchAll(baseRegex)) {
-      const idValue = match[2] ?? `default`
-      const inner = match[3] ?? ``
-      const cleaned = inner
-        .replace(/^[\t ]+/gm, ``)
-        .replace(/^\n+/, ``)
-        .replace(/\n+$/, ``)
-        .trim()
-
-      result[idValue] = cleaned
-    }
-    return result
-  }
-
-  public static _processScriptBlocks(template: string) {
-    return template.replace(/<script\b[^>]*>([\s\S]*?)<\/script>/gi, (_, rawCode) => {
-      const innerCode = rawCode.trim()
-      if (!innerCode) return ``
-
-      return `\${(() => { if (!data) return ''; try { with(data) { ${innerCode} } } catch(e) { return '' } })()}`
-    })
-  }
-
-  public static _processSpaceBlocks(template: string) {
-    return template.replace(/^[ \t]*<space\s*\/>[ \t]*$/gim, ``)
-  }
-
-  public static _processDivBlocks(template: string) {
-    return template.replace(/<div>([\s\S]*?)<\/div>/gi, (_, inner) => {
-      const cleaned = inner
-        .replace(/^[\t ]+/gm, ``)
-        .replace(/^\n+/, ``)
-        .replace(/\n+$/, ``)
-      return cleaned
-    })
-  }
-
-  public static _processMessageBlocks(template: string) {
-    const messageRegex = /<message\s+lang="([^"]+)"\s*>([\s\S]*?)<\/message>/gi
-    const result: {
-      [lang: string]: string
-    } = {}
-
-    for (const [, lang, rawContent] of template.matchAll(messageRegex) as any) {
-      const cleaned = rawContent
-        .replace(/^[\t ]+/gm, ``)
-        .replace(/^\n+/, ``)
-        .replace(/\n+$/, ``)
-        .trim()
-
-      result[lang] = cleaned
-    }
-    return result
-  }
-
-  public static _processKeyboardBlocks(template: string) {
-    const keyboardRegex = /<keyboard\b[^>]*\blang="([^"]*)"[^>]*?(?:\sfor="([^"]*)")?[^>]*>([\s\S]*?)<\/keyboard>/gi
-    const result: {
-      [lang: string]: {
-        inline?: string
-        default?: string
-      }
-    } = {}
-
-    for (const [, lang, forAttr, rawContent] of template.matchAll(keyboardRegex) as any) {
-      const mode = forAttr === `default` ? `default` : `inline`
-      const cleaned = rawContent.trim()
-
-      if (!result[lang]) {
-        result[lang] = {}
-      }
-      result[lang][mode] = cleaned
-    }
-    return result
-  }
-
-  public static _compileToFunction<T extends boolean>(template: T extends true ? string[] : string, isArray: T): T extends true ? (data?: Record<string, any>) => string[] : (data?: Record<string, any>) => string {
-    let singleOrCombined: string
-    if (isArray) {
-      const multiTemplate = template as string[]
-      singleOrCombined = multiTemplate.map((t) => `\`${t}\``).join(`,`)
-    } else {
-      singleOrCombined = `\`${template as string}\``
-    }
-
-    let processed = singleOrCombined
-    processed = this._processScriptBlocks(this._processDivBlocks(this._processSpaceBlocks(processed)))
-
-    if (isArray) {
-      const functionBody = `return [${processed}]`
-      return new Function(`data`, functionBody) as any
-    } else {
-      const functionBody = `return ${processed}`
-      return new Function(`data`, functionBody) as any
-    }
-  }
-
-  public static compileMessages(template: string) {
-    const baseBlocks = this._processBaseBlocks(template)
-    const result: {
-      [baseId: string]: {
-        [lang: string]: (data?: Record<string, any>) => string
-      }
-    } = {}
-
-    for (const [baseId, baseContent] of Object.entries(baseBlocks)) {
-      const messages = this._processMessageBlocks(baseContent)
-      result[baseId] = {}
-
-      for (const [lang, content] of Object.entries(messages)) {
-        const processed = this._processVariables(this._processScriptBlocks(content))
-        result[baseId][lang] = this._compileToFunction(processed, false)
-      }
-    }
-
-    return result
-  }
-
-  public static compileKeyboards(template: string) {
-    const baseBlocks = this._processBaseBlocks(template)
-    const result: {
-      [baseId: string]: {
-        [lang: string]: {
-          inline?: (data?: Record<string, any>) => string[]
-          default?: (data?: Record<string, any>) => string[]
-        }
-      }
-    } = {}
-
-    for (const [baseId, baseContent] of Object.entries(baseBlocks)) {
-      const keyboards = this._processKeyboardBlocks(baseContent)
-      result[baseId] = {}
-
-      for (const [lang, modes] of Object.entries(keyboards)) {
-        result[baseId][lang] = {}
-
-        for (const [mode, content] of Object.entries(modes)) {
-          // Pisahkan label, handle escaped comma
-          const labels = content.split(/(?<!\\),\s*/).map((label: string) => label.replace(/\\,/g, `,`).trim())
-
-          const processedLabels = labels.map((label) => this._processVariables(this._processScriptBlocks(label)))
-
-          result[baseId][lang][mode as `inline` | `default`] = this._compileToFunction(processedLabels, true)
-        }
-      }
-    }
-
-    return result
-  }
-}

package/src/template/index.ts

@@ -1,2 +0,0 @@
-export * from "./engine"
-export * from "./manager"

package/src/template/manager.ts

@@ -1,280 +0,0 @@
-import { TemplateEngine } from "."
-import { readFile, mkdir } from "node:fs/promises"
-import { watch, FSWatcher } from "chokidar"
-import { basename, join, extname } from "node:path"
-import { readdirSync, readFileSync, existsSync, statSync, writeFileSync } from "node:fs"
-
-/** Template file interface for better type safety */
-type ICompiledTemplate = {
-  message: ReturnType<typeof TemplateEngine.compileMessages>
-  keyboard: ReturnType<typeof TemplateEngine.compileKeyboards>
-}
-
-/** Template loading options */
-type ITemplateOptions = {
-  /** Enable file watching for hot reloading (if have templatePath) */
-  enableWatch?: boolean
-  /** Base path for template files (set null if dont want read template from file) */
-  path?: string | undefined | null
-  /** Force language params to this value */
-  forceLanguage?: string | undefined | null
-}
-
-/** Template management system */
-export class TemplateManager {
-  public _map = new Map<string, ICompiledTemplate>()
-  public _engine = TemplateEngine
-  public _watcher: FSWatcher | null = null
-  public _supportedExtensions = new Set([`.html`])
-  public readonly _path: string | null
-  public readonly _forceLanguage: string | null
-  public readonly _isWatchEnabled: boolean
-  public constructor(options: ITemplateOptions = {}) {
-    const { enableWatch = false, path = null, forceLanguage = null } = options
-
-    this._path = path
-    this._forceLanguage = forceLanguage
-    this._isWatchEnabled = enableWatch
-
-    this._validatePath()
-    this._initializeWatcher()
-    this._loadAllFiles()
-  }
-
-  /** Validate and ensure template directory exists. @returns Void */
-  public _validatePath(): void {
-    try {
-      if (this._path === null || !existsSync(this._path)) {
-        return
-      }
-
-      const stats = statSync(this._path)
-      if (!stats.isDirectory()) {
-        throw new Error(`Template path is not a directory: ${this._path}`)
-      }
-    } catch (error) {
-      throw new Error(`Failed to validate Template path: ${error}`)
-    }
-  }
-
-  /** Initialize file system watcher for hot reloading. @returns Void */
-  public _initializeWatcher(): void {
-    if (this._path === null || !this._isWatchEnabled) {
-      return
-    }
-
-    this._watcher = watch(this._path, {
-      persistent: true,
-      ignoreInitial: true,
-      awaitWriteFinish: {
-        stabilityThreshold: 100,
-        pollInterval: 50
-      }
-    })
-
-    this._watcher!.on(`change`, this._handleFileChange.bind(this))
-    this._watcher!.on(`add`, this._handleFileAdd.bind(this))
-    this._watcher!.on(`unlink`, this._handleFileDelete.bind(this))
-    this._watcher!.on(`error`, this._handleWatchError.bind(this))
-  }
-
-  /** Handle file change events */
-  public async _handleFileChange(filepath: string): Promise<void> {
-    const filename = basename(filepath)
-    if (this._isValidFile(filename)) {
-      await this._loadFile(filename, false)
-    }
-  }
-
-  /** Handle file add events */
-  public async _handleFileAdd(filePath: string): Promise<void> {
-    const fileName = basename(filePath)
-    if (this._isValidFile(fileName)) {
-      await this._loadFile(fileName, false)
-    }
-  }
-
-  /** Handle file delete events */
-  public _handleFileDelete(filePath: string): void {
-    const fileName = basename(filePath)
-    const fileKey = this._getKey(fileName)
-    if (this._map.has(fileKey)) {
-      this._map.delete(fileKey)
-    }
-  }
-
-  /** Handle watcher errors */
-  public _handleWatchError(error: any): void {
-    // you can overrides
-  }
-
-  /** Load all Template files during initialization */
-  public _loadAllFiles(): void {
-    if (this._path === null || !existsSync(this._path)) {
-      return
-    }
-    const files = readdirSync(this._path, { encoding: `utf8` })
-    const validFiles = files.filter((file) => this._isValidFile(file))
-    for (const fileName of validFiles) {
-      this._loadFile(fileName, true)
-    }
-  }
-
-  /** Load and compile a single template file */
-  public async _loadFile(filename: string, useSync: boolean = true): Promise<void> {
-    if (this._path === null) {
-      return
-    }
-    const path = join(this._path, filename)
-    const key = this._getKey(filename)
-    const raw = useSync ? readFileSync(path, { encoding: `utf8` }) : await readFile(path, { encoding: `utf8` })
-    this.compile(key, raw)
-  }
-
-  public _isValidFile(filename: string): boolean {
-    const extension = extname(filename).toLowerCase()
-    return this._supportedExtensions.has(extension)
-  }
-
-  public _getKey(filename: string): string {
-    return filename.replace(/\.[^/.]+$/, ``)
-  }
-
-  public compile(key: string, rawTemplate: string, keepIfExist?: Partial<{ [K in keyof ICompiledTemplate]: boolean }>) {
-    const existing = this._map.get(key)
-    const compiled = existing || ({} as ICompiledTemplate)
-    let updated = false
-
-    if (keepIfExist === undefined || keepIfExist?.message === false || existing?.message === undefined) {
-      compiled.message = TemplateEngine.compileMessages(rawTemplate)
-      updated = true
-    }
-    if (keepIfExist === undefined || keepIfExist?.keyboard === false || existing?.keyboard === undefined) {
-      compiled.keyboard = TemplateEngine.compileKeyboards(rawTemplate)
-      updated = true
-    }
-
-    if (updated) {
-      this._map.set(key, compiled)
-    }
-  }
-
-  /**
-   * Get compiled message template
-   * @param key Template identifier (filename without extension)
-   * @param baseId Base id attr from block
-   * @param language Target language code
-   * @param data Template variables
-   * @returns Rendered message string
-   */
-  public getMessage(key: string, baseId: string = `default`, language: string = `en`, data?: Record<string, any>): string {
-    const template = this._map.get(key)
-    const func = template?.message?.[baseId]?.[this._forceLanguage || language]
-    if (!func) {
-      return ``
-    }
-
-    try {
-      return func(data)
-    } catch (error) {
-      return ``
-    }
-  }
-
-  /**
-   * Get compiled keyboard template
-   * @param key Template identifier (filename without extension)
-   * @param baseId Base id attr from block
-   * @param language Target language code
-   * @param data Template variables
-   * @returns Array of rendered button labels
-   */
-  public getKeyboard(key: string, baseId: string = `default`, language: string = `en`, display: `inline` | `default` = `inline`, data?: Record<string, any>): string[] {
-    const template = this._map.get(key)
-    const func = template?.keyboard?.[baseId]?.[this._forceLanguage || language]?.[display]
-    if (!func) {
-      return []
-    }
-
-    try {
-      return func(data)
-    } catch (error) {
-      return []
-    }
-  }
-
-  /**
-   * Update message template in memory
-   * @param key Template identifier (filename without extension)
-   * @param rawTemplate Raw template string
-   */
-  public setMessage(key: string, rawTemplate: string): void {
-    this.compile(key, rawTemplate, { keyboard: true })
-  }
-
-  /**
-   * Update keyboard template in memory
-   * @param key Template identifier (filename without extension)
-   * @param rawTemplate Raw template string
-   */
-  public setKeyboard(key: string, rawTemplate: string): void {
-    this.compile(key, rawTemplate, { message: true })
-  }
-
-  /**
-   * Write template to file and update cache
-   * @param filename Target filename (with extension)
-   * @param rawTemplate Template to write
-   * @returns Promise that resolves when file is written
-   */
-  public async write(filename: string, rawTemplate: string): Promise<void> {
-    if (this._path === null) {
-      return
-    }
-    const filePath = join(this._path, filename)
-    await mkdir(this._path, { recursive: true })
-    writeFileSync(filePath, rawTemplate, { encoding: `utf8` })
-    await this._loadFile(filename, false)
-  }
-
-  /**
-   * Get list of available template
-   * @returns Array of template names
-   */
-  public getAvailable(): string[] {
-    return Array.from(this._map.keys())
-  }
-
-  /**
-   * Check if template exists
-   * @param key Template identifier
-   * @returns True if template exists
-   */
-  public has(key: string): boolean {
-    return this._map.has(key)
-  }
-
-  /**
-   * Get cache statistics
-   * @returns Object with cache information
-   */
-  public getCacheStats(): { templateCount: number; totalSize: number } {
-    return {
-      templateCount: this._map.size,
-      totalSize: JSON.stringify(this._map.entries().toArray(), (_, value) => {
-        return typeof value === `function` ? value.toString() : value
-      }).length
-    }
-  }
-
-  /**
-   * Cleanup resources and close watchers
-   * @returns Promise void
-   */
-  public async destroy(): Promise<void> {
-    if (this._watcher) {
-      await this._watcher.close()
-    }
-    this._map.clear()
-  }
-}

package/src/types/page.d.ts

@@ -1,4 +0,0 @@
-import type { BasePage } from "../base/page"
-
-const Page = class extends BasePage {}
-export type IPageBase = typeof Page