@sysa-ivan/gas-helpers 1.0.0

package/README.md

@@ -0,0 +1,36 @@
+# gas-helpers
+
+Helper utilities for Google Apps Script: UI, triggers, Telegram notifications, Google Sheets (Entity/Repository).
+
+> **For AI agents**: See [AGENTS.md](./AGENTS.md) for imports, patterns, and GAS caveats.
+
+## Installation
+
+```bash
+npm install gas-helpers
+```
+
+## Modules
+
+| Module                                   | Description                                                             |
+| ---------------------------------------- | ----------------------------------------------------------------------- |
+| [ui](./src/ui/README.md)                 | Spreadsheet UI dialogs (alert, confirm, prompt) with availability check |
+| [triggers](./src/triggers/README.md)     | Managing time-based triggers in Google Apps Script                      |
+| [telegram](./src/telegram/README.md)     | Sending notifications to Telegram via Bot API                           |
+| [sheet](./src/sheet/README.md)           | Entity and Repository for working with Google Sheets data               |
+| [properties](./src/properties/README.md) | ScriptProperty for typed key-value storage in script properties         |
+
+## Requirements
+
+- Google Apps Script
+- `@types/google-apps-script` (peer dependency)
+
+## Common Pitfalls
+
+- **Ui unavailable**: When script runs from a trigger, `onEdit`, or time-driven execution, `SpreadsheetApp.getUi()` throws. Always use `Ui.isAvailable()` before `alert`, `confirm`, `prompt`.
+- **Secrets**: Store `botToken` in `PropertiesService.getScriptProperties()`, not in source code.
+- **Entity columns**: Column indices are 0-based (same as array indices).
+
+## License
+
+ISC

package/dist/properties/index.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Type-safe wrapper for PropertiesService.getScriptProperties().
+ * Stores values as JSON. Use for script state, not configuration.
+ *
+ * @template T - Stored value type (typically an object)
+ */
+export declare class ScriptProperty<T> {
+    private readonly key;
+    private readonly defaults?;
+    constructor(key: string, defaults?: T | undefined);
+    /**
+     * Reads value from script properties.
+     * @returns Parsed value or null if not set (or defaults if provided in constructor)
+     */
+    get: () => T | null;
+    /**
+     * Writes value to script properties.
+     * @param value - Value to store (serialized as JSON)
+     */
+    set: (value: T) => void;
+    /**
+     * Removes the property.
+     */
+    delete: () => void;
+    /**
+     * Checks if the property exists (non-empty value).
+     */
+    exists: () => boolean;
+    /**
+     * Returns stored value or fallback. Uses constructor defaults when def is omitted.
+     * @param def - Override when no defaults in constructor; required if no defaults
+     * @throws Error when value is missing and neither def nor constructor defaults provided
+     */
+    getOrDefault: (def?: T) => T;
+}

package/dist/properties.js

@@ -0,0 +1,38 @@
+class o {
+  constructor(r, i) {
+    this.key = r, this.defaults = i, this.get = () => {
+      const t = PropertiesService.getScriptProperties().getProperty(
+        this.key
+      );
+      if (t == null) return this.defaults ?? null;
+      try {
+        return JSON.parse(t);
+      } catch {
+        return this.defaults ?? null;
+      }
+    }, this.set = (t) => {
+      PropertiesService.getScriptProperties().setProperty(
+        this.key,
+        JSON.stringify(t)
+      );
+    }, this.delete = () => {
+      PropertiesService.getScriptProperties().deleteProperty(this.key);
+    }, this.exists = () => {
+      const t = PropertiesService.getScriptProperties().getProperty(
+        this.key
+      );
+      return t != null;
+    }, this.getOrDefault = (t) => {
+      const e = this.get();
+      if (e !== null) return e;
+      if (t !== void 0) return t;
+      if (this.defaults !== void 0) return this.defaults;
+      throw new Error(
+        `ScriptProperty "${this.key}" has no value and no defaults`
+      );
+    };
+  }
+}
+export {
+  o as ScriptProperty
+};

package/dist/sheet/Entity.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Value transformation when reading from sheet (from) and writing (to).
+ * @template T - Value type
+ */
+export type Transformer<T> = {
+    /** When reading row from sheet */
+    from?: (value: unknown) => T;
+    /** When writing to sheet */
+    to?: (value: T) => unknown;
+};
+/** Entity configuration: columns, transformers, optional, defaults, primaryKey */
+export type EntityConfig<T extends Record<string, any>> = {
+    columns: Record<keyof T, number>;
+    transformers?: {
+        [K in keyof T]?: Transformer<T[K]>;
+    };
+    optional?: ReadonlyArray<keyof T>;
+    defaults?: {
+        [K in keyof T]?: () => T[K];
+    };
+    primaryKey?: string;
+};
+/**
+ * Base class for a Google Sheets table row.
+ * Maps array row[] to object and back via config.
+ * @template T - Entity data type
+ */
+export declare abstract class Entity<T extends Record<string, any>> {
+    protected static config: EntityConfig<any>;
+    private _original?;
+    constructor(data?: Partial<T>);
+    /**
+     * Creates entity from sheet row (array of values).
+     * @param row - Array of cell values (0-based indices from config.columns)
+     * @returns Entity of type T
+     * @example const user = UserEntity.fromRow([1, 'Alice', 'a@x.com']);
+     */
+    static fromRow<T>(this: new (data: T) => any, row: any[]): T;
+    /**
+     * Converts entity to row for writing to sheet.
+     * validate() is called before conversion.
+     * @returns Array of values for cells
+     */
+    toRow(): any[];
+    /** Validates entity before toRow(). Throws Error on invalid data. */
+    abstract validate(): void;
+    /**
+     * Checks if data changed after fromRow or insert.
+     * @returns true if data was modified
+     */
+    isDirty(): boolean;
+    /**
+     * Returns primary key (primaryKey or _rowIndex).
+     * @throws Error if primaryKey not set and _rowIndex is missing
+     */
+    getPrimaryKey(): any;
+}

package/dist/sheet/Repository.d.ts

@@ -0,0 +1,82 @@
+import { Entity, EntityConfig } from './Entity';
+/**
+ * Repository for working with a Google Sheets tab.
+ * Cache, Unit of Work, CRUD. First row is headers, data from row 2.
+ * @template T - Entity data type
+ * @template E - Entity class
+ */
+export declare abstract class Repository<T extends Record<string, any>, E extends Entity<T>> {
+    protected cache: (E & {
+        _rowIndex: number;
+    })[];
+    protected dirty: Set<E>;
+    protected toDelete: Set<E>;
+    protected abstract entity: {
+        new (data?: Partial<T>): E;
+        fromRow(row: any[]): E;
+        config: EntityConfig<T>;
+    };
+    protected abstract sheetName: string;
+    private _sheet?;
+    get sheet(): GoogleAppsScript.Spreadsheet.Sheet;
+    /**
+     * Loads data from sheet into cache. First row = headers, data from row 2.
+     * @param options - fromRow, toRow, columns (projection)
+     * @example repo.load(); repo.load({ fromRow: 2, toRow: 100 });
+     */
+    load(options?: {
+        fromRow?: number;
+        toRow?: number;
+        columns?: (keyof T)[];
+    }): void;
+    /** All entities from cache. */
+    findAll(): (E & {
+        _rowIndex: number;
+    })[];
+    /** Entity by row number or null. */
+    findByRowIndex(rowIndex: number): (E & {
+        _rowIndex: number;
+    }) | null;
+    /** Array of entities with given field value. */
+    findBy<K extends keyof T>(field: K, value: T[K]): (E & {
+        _rowIndex: number;
+    })[];
+    /** First entity with given value or null. */
+    findOne<K extends keyof T>(field: K, value: T[K]): (E & {
+        _rowIndex: number;
+    }) | null;
+    /** Checks if at least one record with given value exists. */
+    exists<K extends keyof T>(field: K, value: T[K]): boolean;
+    /** Number of records in cache. */
+    count(): number;
+    /** Number of records with given field value. */
+    countBy<K extends keyof T>(field: K, value: T[K]): number;
+    /** Adds entity to dirty set if isDirty(). */
+    save(entity: E & {
+        _rowIndex: number;
+    }): void;
+    /** Updates entities via callback and adds to dirty. */
+    update(entities: (E & {
+        _rowIndex: number;
+    })[], updater: (entity: E) => void): void;
+    /** Marks entity for deletion on commit(). */
+    delete(entity: E & {
+        _rowIndex: number;
+    }): void;
+    /**
+     * Applies all changes (dirty, toDelete) to sheet and reloads cache.
+     * @example repo.save(entity); repo.delete(entity); repo.commit();
+     */
+    commit(): void;
+    /** Inserts one row, updates _rowIndex and cache. */
+    insert(entity: E): void;
+    /** Inserts multiple rows in a single API call. */
+    insertBatch(entities: E[]): void;
+    /** save() if _rowIndex exists, otherwise insert(). */
+    upsert(entity: E & {
+        _rowIndex?: number;
+    }): void;
+    /** Removes all data rows (except header), clears cache. */
+    clear(): void;
+    private _snapshotColumns;
+}

package/dist/sheet/index.d.ts

@@ -0,0 +1,2 @@
+export { Entity, type EntityConfig, type Transformer } from './Entity';
+export { Repository } from './Repository';

package/dist/sheet.js

@@ -0,0 +1,227 @@
+class x {
+  constructor(t) {
+    const s = this.constructor.config;
+    if (s?.defaults)
+      for (const e in s.defaults)
+        this[e] = s.defaults[e]();
+    t && Object.assign(this, t);
+  }
+  /**
+   * Creates entity from sheet row (array of values).
+   * @param row - Array of cell values (0-based indices from config.columns)
+   * @returns Entity of type T
+   * @example const user = UserEntity.fromRow([1, 'Alice', 'a@x.com']);
+   */
+  static fromRow(t) {
+    const s = new this({}), o = this.config, r = o.columns, n = o.transformers ?? {};
+    for (const i in r) {
+      const a = r[i];
+      let l = t[a];
+      n[i]?.from && (l = n[i].from(l)), s[i] = l;
+    }
+    const c = {};
+    for (const i in r)
+      c[i] = s[i];
+    return s._original = c, s;
+  }
+  /**
+   * Converts entity to row for writing to sheet.
+   * validate() is called before conversion.
+   * @returns Array of values for cells
+   */
+  toRow() {
+    this.validate();
+    const s = this.constructor.config, e = s.columns, o = s.transformers ?? {}, r = new Set(s.optional ?? []), n = [];
+    for (const c in e) {
+      let i = this[c];
+      if (i === void 0 && r.has(c)) {
+        n[e[c]] = "";
+        continue;
+      }
+      o[c]?.to && (i = o[c].to(i)), n[e[c]] = i;
+    }
+    return n;
+  }
+  /**
+   * Checks if data changed after fromRow or insert.
+   * @returns true if data was modified
+   */
+  isDirty() {
+    if (!this._original) return !0;
+    const s = this.constructor.config.columns;
+    for (const e in s) {
+      const o = this[e], r = this._original[e];
+      if (o instanceof Date && r instanceof Date) {
+        if (o.getTime() !== r.getTime()) return !0;
+      } else if (Array.isArray(o) && Array.isArray(r)) {
+        if (JSON.stringify(o) !== JSON.stringify(r))
+          return !0;
+      } else if (o !== r)
+        return !0;
+    }
+    return !1;
+  }
+  /**
+   * Returns primary key (primaryKey or _rowIndex).
+   * @throws Error if primaryKey not set and _rowIndex is missing
+   */
+  getPrimaryKey() {
+    const t = this.constructor;
+    if (t.config.primaryKey)
+      return this[t.config.primaryKey];
+    const s = this._rowIndex;
+    if (s == null)
+      throw new Error("Primary key not defined and rowIndex not set");
+    return s;
+  }
+}
+class p {
+  constructor() {
+    this.cache = [], this.dirty = /* @__PURE__ */ new Set(), this.toDelete = /* @__PURE__ */ new Set();
+  }
+  get sheet() {
+    if (!this._sheet) {
+      const t = SpreadsheetApp.getActive();
+      if (this._sheet = t.getSheetByName(this.sheetName), !this._sheet)
+        throw new Error(`Sheet ${this.sheetName} not found`);
+    }
+    return this._sheet;
+  }
+  /**
+   * Loads data from sheet into cache. First row = headers, data from row 2.
+   * @param options - fromRow, toRow, columns (projection)
+   * @example repo.load(); repo.load({ fromRow: 2, toRow: 100 });
+   */
+  load(t) {
+    const s = t?.fromRow ?? 2, e = t?.toRow ?? this.sheet.getLastRow();
+    if (e < s) return;
+    const o = this.entity.config.columns, n = (t?.columns ?? Object.keys(o)).map((h) => o[h]), c = Math.min(...n), a = Math.max(...n) - c + 1, l = e - s + 1, f = this.sheet.getRange(s, c + 1, l, a).getValues();
+    this.cache = [];
+    for (let h = 0; h < f.length; h++) {
+      const u = [];
+      for (const y of Object.keys(o)) {
+        const g = o[y], w = n.indexOf(g);
+        u[g] = w >= 0 ? f[h][w] : void 0;
+      }
+      const d = this.entity.fromRow(u);
+      d._rowIndex = s + h, this.cache.push(d);
+    }
+  }
+  /** All entities from cache. */
+  findAll() {
+    return this.cache;
+  }
+  /** Entity by row number or null. */
+  findByRowIndex(t) {
+    return this.cache.find((s) => s._rowIndex === t) ?? null;
+  }
+  /** Array of entities with given field value. */
+  findBy(t, s) {
+    return this.cache.filter((e) => e[t] === s);
+  }
+  /** First entity with given value or null. */
+  findOne(t, s) {
+    return this.cache.find((e) => e[t] === s) ?? null;
+  }
+  /** Checks if at least one record with given value exists. */
+  exists(t, s) {
+    return this.cache.some((e) => e[t] === s);
+  }
+  /** Number of records in cache. */
+  count() {
+    return this.cache.length;
+  }
+  /** Number of records with given field value. */
+  countBy(t, s) {
+    return this.cache.filter((e) => e[t] === s).length;
+  }
+  /** Adds entity to dirty set if isDirty(). */
+  save(t) {
+    t.isDirty() && this.dirty.add(t);
+  }
+  /** Updates entities via callback and adds to dirty. */
+  update(t, s) {
+    t.forEach((e) => {
+      s(e), this.save(e);
+    });
+  }
+  /** Marks entity for deletion on commit(). */
+  delete(t) {
+    this.toDelete.add(t);
+  }
+  /**
+   * Applies all changes (dirty, toDelete) to sheet and reloads cache.
+   * @example repo.save(entity); repo.delete(entity); repo.commit();
+   */
+  commit() {
+    const t = Array.from(this.dirty).map((e) => ({
+      rowIndex: e._rowIndex,
+      row: e.toRow().map((o) => o ?? "")
+    })).sort((e, o) => e.rowIndex - o.rowIndex);
+    if (t.length > 0) {
+      const e = Math.max(...t.map((n) => n.row.length)), o = [];
+      let r = null;
+      for (const { rowIndex: n, row: c } of t) {
+        const i = [
+          ...c,
+          ...new Array(e - c.length).fill("")
+        ];
+        r && n === r.startRow + r.rows.length ? r.rows.push(i) : (r = { startRow: n, rows: [i] }, o.push(r));
+      }
+      for (const n of o)
+        this.sheet.getRange(n.startRow, 1, n.rows.length, e).setValues(n.rows);
+    }
+    this.dirty.clear();
+    const s = Array.from(this.toDelete).map((e) => e._rowIndex).filter(Boolean).sort((e, o) => o - e);
+    for (const e of s)
+      this.sheet.getRange(
+        e,
+        1,
+        1,
+        Math.max(...Object.values(this.entity.config.columns)) + 1
+      ).clearContent();
+    this.toDelete.clear(), this.load();
+  }
+  /** Inserts one row, updates _rowIndex and cache. */
+  insert(t) {
+    const s = t.toRow().map((o) => o ?? ""), e = this.sheet.getLastRow() + 1;
+    this.sheet.getRange(e, 1, 1, s.length).setValues([s]), t._rowIndex = e, t._original = this._snapshotColumns(t), this.cache.push(t);
+  }
+  /** Inserts multiple rows in a single API call. */
+  insertBatch(t) {
+    if (t.length === 0) return;
+    const s = this.sheet.getLastRow() + 1, e = t.map((n) => n.toRow()), o = Math.max(...e.map((n) => n.length)), r = e.map((n) => {
+      const c = new Array(o).fill("");
+      return n.forEach((i, a) => {
+        c[a] = i ?? "";
+      }), c;
+    });
+    this.sheet.getRange(s, 1, t.length, o).setValues(r), t.forEach((n, c) => {
+      n._rowIndex = s + c, n._original = this._snapshotColumns(n), this.cache.push(n);
+    });
+  }
+  /** save() if _rowIndex exists, otherwise insert(). */
+  upsert(t) {
+    t._rowIndex !== null && t._rowIndex !== void 0 ? this.save(t) : this.insert(t);
+  }
+  /** Removes all data rows (except header), clears cache. */
+  clear() {
+    const t = this.sheet.getLastRow();
+    t <= 1 || (this.sheet.getRange(
+      2,
+      1,
+      t - 1,
+      Math.max(...Object.values(this.entity.config.columns)) + 1
+    ).clearContent(), this.cache = [], this.dirty.clear(), this.toDelete.clear());
+  }
+  _snapshotColumns(t) {
+    const s = this.entity.config.columns, e = {};
+    for (const o in s)
+      e[o] = t[o];
+    return e;
+  }
+}
+export {
+  x as Entity,
+  p as Repository
+};

package/dist/telegram/index.d.ts

@@ -0,0 +1,30 @@
+/** Parameters for TelegramNotifier constructor */
+export type TelegramNotifierParams = {
+    /** Bot token from @BotFather */
+    botToken: string;
+    /** Chat ID for sending messages */
+    chatId: string;
+    /** Spreadsheet name — prepended to messages (optional) */
+    spreadsheetName?: string;
+};
+/**
+ * Sends notifications to Telegram via Bot API.
+ * Uses UrlFetchApp for HTTP requests.
+ */
+export declare class TelegramNotifier {
+    private readonly apiUrl;
+    private readonly chatId;
+    private readonly spreadsheetName;
+    /**
+     * @param params - botToken, chatId, spreadsheetName (optional)
+     */
+    constructor(params: TelegramNotifierParams);
+    /**
+     * Sends a message to Telegram. Logs errors; does not throw.
+     * @param message - Message text
+     * @param disableNotification - Mute notification sound (default true)
+     * @param spreadsheetName - Spreadsheet name prefix (default from constructor)
+     * @example notifier.sendNotification('Error in script');
+     */
+    sendNotification(message: string, disableNotification?: boolean, spreadsheetName?: string): void;
+}

package/dist/telegram.js

@@ -0,0 +1,46 @@
+class c {
+  /**
+   * @param params - botToken, chatId, spreadsheetName (optional)
+   */
+  constructor(t) {
+    const { botToken: s, chatId: o, spreadsheetName: e = "" } = t;
+    this.apiUrl = `https://api.telegram.org/bot${s}/sendMessage`, this.chatId = o, this.spreadsheetName = e;
+  }
+  /**
+   * Sends a message to Telegram. Logs errors; does not throw.
+   * @param message - Message text
+   * @param disableNotification - Mute notification sound (default true)
+   * @param spreadsheetName - Spreadsheet name prefix (default from constructor)
+   * @example notifier.sendNotification('Error in script');
+   */
+  sendNotification(t, s = !0, o = this.spreadsheetName) {
+    try {
+      const e = o ? `${o}
+${t}` : t, r = {
+        chat_id: this.chatId,
+        text: e,
+        disable_notification: s
+      }, n = UrlFetchApp.fetch(this.apiUrl, {
+        method: "post",
+        headers: {
+          "Content-Type": "application/json"
+        },
+        payload: JSON.stringify(r),
+        muteHttpExceptions: !0
+      }), a = n.getResponseCode();
+      if (a !== 200) {
+        const i = n.getContentText();
+        Logger.log(
+          `Error sending message to Telegram: ${a} - ${i}`
+        );
+      } else
+        Logger.log(`Message sent to Telegram: ${t}`);
+    } catch (e) {
+      const r = e instanceof Error ? e.message : String(e);
+      Logger.log(`Error sending message to Telegram: ${r}`);
+    }
+  }
+}
+export {
+  c as TelegramNotifier
+};

package/dist/triggers/index.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Manages time-based triggers in Google Apps Script.
+ * Create, check and delete triggers by handler function name.
+ */
+export declare class Trigger {
+    private readonly functionName;
+    /**
+     * @param functionName - Name of the trigger handler function
+     */
+    constructor(functionName: string);
+    /**
+     * Checks if a clock trigger exists for this function.
+     * @returns true if trigger exists
+     */
+    has: () => boolean;
+    /** Deletes one trigger for this function. */
+    delete: () => void;
+    /** Deletes all triggers for this function. */
+    deleteAll: () => void;
+    /**
+     * Creates a one-time trigger to run after specified minutes.
+     * @param afterMinutes - Minutes until execution
+     * @param removeOld - Remove existing triggers before creating (default true)
+     * @example trigger.set(5); // run myHandler in 5 minutes
+     */
+    set: (afterMinutes: number, removeOld?: boolean) => void;
+    /**
+     * Creates a recurring trigger. Skips if one already exists.
+     * @param intervalMinutes - Interval in minutes (skips if trigger already exists)
+     * @example trigger.setRecurring(60); // every hour
+     */
+    setRecurring: (intervalMinutes: number) => void;
+}

package/dist/triggers.js

@@ -0,0 +1,28 @@
+class g {
+  /**
+   * @param functionName - Name of the trigger handler function
+   */
+  constructor(r) {
+    this.functionName = r, this.has = () => ScriptApp.getProjectTriggers().some(
+      (e) => e.getHandlerFunction() === this.functionName && e.getTriggerSource() === ScriptApp.TriggerSource.CLOCK
+    ), this.delete = () => {
+      const e = ScriptApp.getProjectTriggers().find(
+        (t) => t.getHandlerFunction() === this.functionName
+      );
+      e && ScriptApp.deleteTrigger(e);
+    }, this.deleteAll = () => {
+      ScriptApp.getProjectTriggers().forEach((e) => {
+        e.getHandlerFunction() === this.functionName && ScriptApp.deleteTrigger(e);
+      });
+    }, this.set = (e, t = !0) => {
+      t && this.deleteAll(), ScriptApp.newTrigger(this.functionName).timeBased().after(e * 60 * 1e3).create();
+    }, this.setRecurring = (e) => {
+      this.has() || (ScriptApp.newTrigger(this.functionName).timeBased().everyMinutes(e).create(), Logger.log(
+        `[setRecurringTrigger] Created ${this.functionName} (every ${e} min)`
+      ));
+    };
+  }
+}
+export {
+  g as Trigger
+};

package/dist/ui/index.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Utilities for Google Sheets UI (alert, confirm, prompt dialogs).
+ * Methods safely check UI availability (e.g. when running from a trigger).
+ */
+export declare class Ui {
+    /**
+     * Checks if Spreadsheet UI is available (e.g. when document is open by user).
+     * UI is NOT available when running from triggers, onEdit, or time-driven scripts.
+     * @returns true if UI is available
+     * @example
+     * if (Ui.isAvailable()) Ui.alert('Hello');
+     */
+    static isAvailable: () => boolean;
+    /**
+     * Shows an alert dialog. No-op if UI unavailable.
+     * @param message - Message text
+     * @example Ui.alert('Done');
+     */
+    static alert: (message: string) => void;
+    /**
+     * Shows a confirm dialog (OK/Cancel).
+     * @param title - Dialog title
+     * @param message - Message text
+     * @returns true if user clicked OK
+     */
+    static confirm: (title: string, message: string) => boolean;
+    /**
+     * Shows a prompt dialog for text input.
+     * @param title - Dialog title
+     * @param message - Prompt hint
+     * @returns Entered text or null if cancelled
+     */
+    static prompt: (title: string, message: string) => string | null;
+}

package/dist/ui.js

@@ -0,0 +1,23 @@
+const t = class t {
+};
+t.isAvailable = () => {
+  try {
+    return SpreadsheetApp.getUi(), !0;
+  } catch {
+    return !1;
+  }
+}, t.alert = (r) => {
+  t.isAvailable() && SpreadsheetApp.getUi().alert(r);
+}, t.confirm = (r, s) => {
+  if (!t.isAvailable()) return !1;
+  const e = SpreadsheetApp.getUi();
+  return e.alert(r, s, e.ButtonSet.OK_CANCEL) === e.Button.OK;
+}, t.prompt = (r, s) => {
+  if (!t.isAvailable()) return null;
+  const e = SpreadsheetApp.getUi(), a = e.prompt(r, s, e.ButtonSet.OK_CANCEL);
+  return a.getSelectedButton() === e.Button.OK ? a.getResponseText() : null;
+};
+let i = t;
+export {
+  i as Ui
+};

package/eslint.config.mjs

@@ -0,0 +1,30 @@
+import gts from 'gts';
+import tseslint from 'typescript-eslint';
+
+export default [
+	{
+		ignores: [
+			'**/node_modules/*',
+			'build/*',
+			'dist/*',
+			'testing',
+			'template/**/*',
+			'template-ui/**/*',
+		],
+	},
+	...gts,
+	{
+		plugins: { '@typescript-eslint': tseslint.plugin },
+		rules: {
+			'@typescript-eslint/no-unused-vars': [
+				'error',
+				{
+					argsIgnorePattern: '^_',
+					varsIgnorePattern: 'onOpen',
+					caughtErrorsIgnorePattern: '^_',
+				},
+			],
+			'@typescript-eslint/no-explicit-any': 'off',
+		},
+	},
+];

package/package.json

@@ -0,0 +1,78 @@
+{
+	"name": "@sysa-ivan/gas-helpers",
+	"version": "1.0.0",
+	"description": "Helper utilities for Google Apps Script: UI dialogs, triggers, Telegram notifications, Entity/Repository for Sheets",
+	"keywords": [
+		"google-apps-script",
+		"gas",
+		"spreadsheet",
+		"google-sheets",
+		"triggers",
+		"entity",
+		"repository",
+		"unit-of-work",
+		"properties",
+		"script-properties"
+	],
+	"private": false,
+	"type": "module",
+	"sideEffects": false,
+	"exports": {
+		"./triggers": {
+			"types": "./dist/triggers/index.d.ts",
+			"default": "./dist/triggers.js"
+		},
+		"./telegram": {
+			"types": "./dist/telegram/index.d.ts",
+			"default": "./dist/telegram.js"
+		},
+		"./sheet": {
+			"types": "./dist/sheet/index.d.ts",
+			"default": "./dist/sheet.js"
+		},
+		"./ui": {
+			"types": "./dist/ui/index.d.ts",
+			"default": "./dist/ui.js"
+		},
+		"./properties": {
+			"types": "./dist/properties/index.d.ts",
+			"default": "./dist/properties.js"
+		},
+		"./eslint": "./eslint.config.mjs",
+		"./prettier": "./prettier.config.js"
+	},
+	"files": [
+		"dist",
+		"*.mjs",
+		"*.js"
+	],
+	"scripts": {
+		"build": "rimraf dist && vite build",
+		"lint": "eslint .",
+		"format": "prettier --check .",
+		"test": "vitest",
+		"test:run": "vitest run",
+		"pr-ready": "npm run format -- --write && npm run lint && npm run test:run && npm run build"
+	},
+	"peerDependencies": {
+		"@types/google-apps-script": "^2.0.8",
+		"eslint": ">=9",
+		"prettier": ">=3",
+		"typescript": ">=5"
+	},
+	"dependencies": {
+		"eslint-config-prettier": "^10.1.8",
+		"eslint-plugin-prettier": "^5.5.5",
+		"gts": "^7.0.0",
+		"typescript-eslint": "^8.46.0",
+		"prettier-plugin-organize-imports": "^4.3.0"
+	},
+	"devDependencies": {
+		"@types/google-apps-script": "^2.0.8",
+		"rimraf": "^6.0.0",
+		"@types/node": "^25.3.3",
+		"vite": "^7.3.1",
+		"vite-plugin-dts": "^4.5.4",
+		"vitest": "^4.0.18"
+	}
+}

package/prettier.config.js

@@ -0,0 +1,13 @@
+/** @type {import('prettier').Config} */
+export default {
+	plugins: ['prettier-plugin-organize-imports'],
+	arrowParens: 'always',
+	bracketSpacing: true,
+	bracketSameLine: false,
+	printWidth: 80,
+	semi: true,
+	singleQuote: true,
+	trailingComma: 'es5',
+	tabWidth: 4,
+	useTabs: true,
+};