gramstax 0.0.1

package/dist/src/template/manager.js

@@ -0,0 +1,237 @@
+import { TemplateEngine } from ".";
+import { readFile, mkdir } from "node:fs/promises";
+import { watch } from "chokidar";
+import { basename, join, extname } from "node:path";
+import { readdirSync, readFileSync, existsSync, statSync, writeFileSync } from "node:fs";
+/** Template management system */
+export class TemplateManager {
+    _map = new Map();
+    _engine = TemplateEngine;
+    _watcher = null;
+    _supportedExtensions = new Set([`.html`]);
+    _path;
+    _forceLanguage;
+    _isWatchEnabled;
+    constructor(options = {}) {
+        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 */
+    _validatePath() {
+        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 */
+    _initializeWatcher() {
+        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 */
+    async _handleFileChange(filepath) {
+        const filename = basename(filepath);
+        if (this._isValidFile(filename)) {
+            await this._loadFile(filename, false);
+        }
+    }
+    /** Handle file add events */
+    async _handleFileAdd(filePath) {
+        const fileName = basename(filePath);
+        if (this._isValidFile(fileName)) {
+            await this._loadFile(fileName, false);
+        }
+    }
+    /** Handle file delete events */
+    _handleFileDelete(filePath) {
+        const fileName = basename(filePath);
+        const fileKey = this._getKey(fileName);
+        if (this._map.has(fileKey)) {
+            this._map.delete(fileKey);
+        }
+    }
+    /** Handle watcher errors */
+    _handleWatchError(error) {
+        // you can overrides
+    }
+    /** Load all Template files during initialization */
+    _loadAllFiles() {
+        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 */
+    async _loadFile(filename, useSync = true) {
+        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);
+    }
+    _isValidFile(filename) {
+        const extension = extname(filename).toLowerCase();
+        return this._supportedExtensions.has(extension);
+    }
+    _getKey(filename) {
+        return filename.replace(/\.[^/.]+$/, ``);
+    }
+    compile(key, rawTemplate, keepIfExist) {
+        const existing = this._map.get(key);
+        const compiled = existing || {};
+        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
+     */
+    getMessage(key, baseId = `default`, language = `en`, data) {
+        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
+     */
+    getKeyboard(key, baseId = `default`, language = `en`, display = `inline`, data) {
+        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
+     */
+    setMessage(key, rawTemplate) {
+        this.compile(key, rawTemplate, { keyboard: true });
+    }
+    /**
+     * Update keyboard template in memory
+     * @param key Template identifier (filename without extension)
+     * @param rawTemplate Raw template string
+     */
+    setKeyboard(key, rawTemplate) {
+        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
+     */
+    async write(filename, rawTemplate) {
+        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
+     */
+    getAvailable() {
+        return Array.from(this._map.keys());
+    }
+    /**
+     * Check if template exists
+     * @param key Template identifier
+     * @returns True if template exists
+     */
+    has(key) {
+        return this._map.has(key);
+    }
+    /**
+     * Get cache statistics
+     * @returns Object with cache information
+     */
+    getCacheStats() {
+        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
+     */
+    async destroy() {
+        if (this._watcher) {
+            await this._watcher.close();
+        }
+        this._map.clear();
+    }
+}

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "gramstax",
+  "version": "0.0.1",
+  "private": false,
+  "description": "A powerful Telegram bot framework with page-based routing and template system",
+  "keywords": [
+    "telegram",
+    "bot",
+    "grammy",
+    "telegram-bot",
+    "bot-framework",
+    "gramstax"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/gramstax/gramstax"
+  },
+  "bugs": {
+    "url": "https://github.com/gramstax/gramstax/issues"
+  },
+  "homepage": "https://github.com/gramstax/gramstax",
+  "author": "gramstax",
+  "license": "MIT",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "src"
+  ],
+  "devDependencies": {
+    "@types/bun": "latest"
+  },
+  "peerDependencies": {
+    "typescript": "^5.9.3"
+  },
+  "dependencies": {
+    "@keyv/redis": "^5.1.3",
+    "chokidar": "^4.0.3",
+    "grammy": "^1.38.3",
+    "keyv": "^5.5.3",
+    "logging-pretty": "^3.0.0"
+  }
+}

package/src/base/general.ts

@@ -0,0 +1,17 @@
+import LoggingPretty from "logging-pretty"
+
+export abstract class BaseGeneral {
+  protected static log = new LoggingPretty()
+  protected static logError(error: any, func: string) {
+    // const name = typeof this.name != `string` ? this.toString().match(/class\s+([^\s{]+)/)?.[1] : this.name
+    this.log.error(`[${this.toString().match(/class\s+([^\s{]+)/)?.[1]}:${func}]: ${String(error)}`)
+  }
+
+  // protected logError(error: any, func: string, name?: string) {
+  //   log.error(`[${name || this.constructor.name}:${func}]: ${String(error)}`)
+  // }
+
+  protected logError(error: any, constructorName?: string, funcName?: string) {
+    ;(this.constructor as any).log.error(`[${constructorName || this.constructor.name}:${funcName}] ${String(error)}`)
+  }
+}

package/src/base/guard.ts

@@ -0,0 +1,10 @@
+import { BasePage } from "./page"
+import type { Ctx } from "../core/ctx"
+
+export abstract class BaseGuard extends BasePage {
+  public pageData: { name: string; callbackData: (...args: any) => string | any } // because Guard not have static data like Page and public data so we assign to new property
+  public constructor(page: { ctx: Ctx; data?: any }) {
+    super(page.ctx)
+    this.pageData = page.data
+  }
+}

package/src/base/index.ts

@@ -0,0 +1,3 @@
+export * from "./general"
+export * from "./guard"
+export * from "./page"