gramstax 0.0.1 → 0.0.2

package/dist/src/template/manager.js

@@ -1,237 +0,0 @@
-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/src/base/general.ts

@@ -1,17 +0,0 @@
-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

@@ -1,10 +0,0 @@
-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

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