@ciderjs/gasnuki 0.2.10 → 0.3.0

package/.docs/vite-plugin/design.md

@@ -0,0 +1,220 @@
+# `@ciderjs/gasnuki` Viteプラグイン 設計書
+
+## 1. はじめに
+
+### 1.1. 目的
+
+本ドキュメントは、先に作成された「`@ciderjs/gasnuki` Viteプラグイン機能追加 要件定義書」に基づき、Viteプラグイン機能の具体的なアーキテクチャ、実装詳細、データ構造などを定義することを目的とする。
+
+### 1.2. 対象読者
+
+`@ciderjs/gasnuki` の開発者およびコントリビューターを対象とする。
+
+## 2. アーキテクチャ概要
+
+`@ciderjs/gasnuki` のViteプラグインは、Viteの開発サーバーのライフサイクルにフックすることで動作する。既存の型生成コアロジック (`generateAppsScriptTypes`) を再利用し、Viteの開発環境とシームレスに連携する。
+
+### 2.1. 構成図
+
+```mermaid
+graph TD
+    subgraph Vite開発環境
+        A[vite.config.ts] --> B(Vite Dev Server);
+        B -- 起動 --> C{gasnuki Plugin};
+        B -- ファイル変更通知 --> C;
+    end
+
+    subgraph gasnuki Plugin
+        C -- configResolvedフック --> D[設定解決ロジック];
+        C -- configureServerフック --> E[初回生成 & ウォッチャー設定];
+        E -- ファイル変更イベント --> F[型再生成トリガー];
+    end
+
+    subgraph gasnuki コアモジュール
+        G[./modules/config.ts];
+        H[./modules/generate.ts];
+    end
+
+    D -- 読み込み --> G;
+    E -- 実行 --> H;
+    F -- 実行 --> H;
+
+    style Vite開発環境 fill:#e6f2ff,stroke:#b3d9ff
+    style gasnukiコアモジュール fill:#fff2e6,stroke:#ffdab3
+```
+
+### 2.2. 処理フロー
+
+1.  **設定解決**: Vite開発サーバー起動時、`configResolved` フックが発火。Viteの設定情報 (`config.root`) を元にプロジェクトルートを特定し、プラグインオプション、`gasnuki.config.ts`、デフォルト値をマージして最終的な設定を確定する。
+2.  **初回生成**: `configureServer` フックで、開発サーバーの起動処理の一環として、型定義の初回生成 (`generateAppsScriptTypes`) を実行する。
+3.  **ファイル監視と再生成**: 同じく `configureServer` フック内で、Viteのファイルウォッチャー (`server.watcher`) を利用して、設定されたソースディレクトリ (`srcDir`) を監視する。ファイルの追加・変更・削除を検知すると、再度 `generateAppsScriptTypes` を実行して型定義を更新する。
+
+## 3. ファイル構成
+
+| ファイルパス         | 状態 | 役割                                                                                                |
+| :------------------- | :--- | :-------------------------------------------------------------------------------------------------- |
+| `src/vite.ts`        | 新規 | Viteプラグインのロジックを実装する。プラグインのファクトリ関数 `gasnuki()` をエクスポートする。         |
+| `package.json`       | 変更 | `exports` フィールドに `./vite` エントリーポイントを追加し、Viteプラグインを外部から利用可能にする。    |
+| `build.config.ts`    | 変更 | `unbuild` のビルド対象に `src/vite.ts` を追加する。                                                   |
+| `src/modules/generate.ts` | 変更 | (必要であれば) Vite環境でのロギングやエラーハンドリングを改善するために軽微な修正を行う可能性がある。 |
+| `src/modules/config.ts`   | 変更なし | 既存のコンフィグローダーをそのまま利用する。                                                        |
+
+## 4. 詳細設計
+
+### 4.1. Viteプラグインエントリーポイント (`src/vite.ts`)
+
+プラグインは `gasnuki(options?: UserConfig): Plugin` というファクトリ関数として提供する。
+
+```typescript:gasnuki Vite Plugin:src/vite.ts
+import type { Plugin, ResolvedConfig, ViteDevServer } from 'vite';
+import * as path from 'node:path';
+import { consola } from 'consola';
+import { generateAppsScriptTypes } from './modules/generate';
+import { loadConfig, type UserConfig } from './modules/config';
+import type { GenerateOptions } from './index';
+
+/**
+ * A factory function to create the gasnuki Vite plugin.
+ * @param options - The user-defined configuration for gasnuki.
+ * @returns The Vite plugin object.
+ */
+export function gasnuki(options?: UserConfig): Plugin {
+  let projectRoot: string;
+  let gasnukiOptions: Omit<GenerateOptions, 'watch' | 'project'>;
+
+  // Debounce mechanism to prevent rapid-fire regeneration
+  let debounceTimer: NodeJS.Timeout | null = null;
+  const debounce = (func: () => void, timeout = 300) => {
+    if (debounceTimer) {
+      clearTimeout(debounceTimer);
+    }
+    debounceTimer = setTimeout(func, timeout);
+  };
+
+  const runGeneration = (triggeredBy?: string) => {
+    debounce(async () => {
+      const reason = triggeredBy ? ` (triggered by: ${triggeredBy})` : '';
+      consola.info(`[gasnuki] Generating AppsScript types${reason}...`);
+      try {
+        await generateAppsScriptTypes({
+          ...gasnukiOptions,
+          project: projectRoot,
+        });
+        consola.success('[gasnuki] Type generation complete.');
+      } catch (e) {
+        consola.error(`[gasnuki] Type generation failed: ${(e as Error).message}`);
+      }
+    });
+  };
+
+  return {
+    name: 'vite-plugin-gasnuki',
+    apply: 'serve', // Apply only in serve mode
+
+    async configResolved(config: ResolvedConfig) {
+      projectRoot = config.root;
+      const fileConfig = await loadConfig(projectRoot);
+      const defaultOptions: Partial<GenerateOptions> = {
+        srcDir: 'server',
+        outDir: 'types',
+        outputFile: 'appsscript.ts',
+      };
+      gasnukiOptions = {
+        ...defaultOptions,
+        ...fileConfig,
+        ...(options || {}),
+      };
+    },
+
+    async configureServer(server: ViteDevServer) {
+      const targetDir = path.resolve(projectRoot, gasnukiOptions.srcDir);
+
+      // Initial generation on server startup
+      runGeneration('server startup');
+
+      // Watch for file changes
+      server.watcher.on('all', (event, filePath) => {
+        // Normalize paths for reliable comparison
+        const normalizedFilePath = path.normalize(filePath);
+        const normalizedTargetDir = path.normalize(targetDir);
+
+        if (normalizedFilePath.startsWith(normalizedTargetDir)) {
+          runGeneration(path.relative(projectRoot, filePath));
+        }
+      });
+    },
+  };
+}
+```
+
+### 4.2. 設定解決ロジック (`configResolved` フック内)
+
+1.  `config.root` からプロジェクトのルートパスを取得する。
+2.  既存の `loadConfig(projectRoot)` を呼び出し、`gasnuki.config.ts` の内容を読み込む。
+3.  以下の優先順位で設定をマージし、`gasnukiOptions` として内部に保持する。
+    1.  **高**: `vite.config.ts` でプラグインに渡された `options`
+    2.  **中**: `gasnuki.config.ts` の内容
+    3.  **低**: プラグイン内部で定義されたデフォルト値 (`srcDir`, `outDir`, `outputFile`)
+
+### 4.3. ファイル監視ロジック (`configureServer` フック内)
+
+-   Viteの `server.watcher` を利用することで、`chokidar` を直接依存関係に追加する必要はない。
+-   `on('all', callback)` を使用し、ファイルの追加(`add`)、変更(`change`)、削除(`unlink`) すべてのイベントを捕捉する。
+-   イベントのコールバック内で、変更されたファイルパスが `gasnukiOptions.srcDir` 内に存在するかをチェックし、関係のないファイルの変更で再生成が走らないようにする。
+-   頻繁なファイル変更による過剰な再生成を防ぐため、300ms程度のデバウンス処理を実装する。
+
+## 5. データ構造・インターフェース
+
+### 5.1. `UserConfig` (既存)
+
+既存の `UserConfig` 型をそのままプラグインオプションの型として利用する。
+
+```typescript
+// src/modules/config.ts (既存)
+export type UserConfig = Partial<Omit<GenerateOptions, 'watch' | 'project'>>;
+```
+
+## 6. シーケンス図
+
+### 6.1. 開発サーバー起動時
+
+```mermaid
+sequenceDiagram
+    participant User
+    participant Vite
+    participant gasnukiPlugin as gasnuki Plugin
+    participant Core as gasnuki Core
+
+    User->>Vite: `vite dev` を実行
+    Vite->>gasnukiPlugin: configResolved フックを呼び出し
+    gasnukiPlugin->>Core: loadConfig()
+    Core-->>gasnukiPlugin: 設定ファイルを返す
+    gasnukiPlugin->>gasnukiPlugin: 設定をマージ
+    Vite->>gasnukiPlugin: configureServer フックを呼び出し
+    gasnukiPlugin->>gasnukiPlugin: runGeneration('server startup')
+    gasnukiPlugin->>Core: generateAppsScriptTypes()
+    Core-->>gasnukiPlugin: 生成完了
+    Note right of gasnukiPlugin: ファイルウォッチャーを設定
+```
+
+### 6.2. ファイル変更時
+
+```mermaid
+sequenceDiagram
+    participant User
+    participant ViteWatcher
+    participant gasnukiPlugin as gasnuki Plugin
+    participant Core as gasnuki Core
+
+    User->>ViteWatcher: ソースファイルを変更・保存
+    ViteWatcher->>gasnukiPlugin: 'all' イベントを発火
+    gasnukiPlugin->>gasnukiPlugin: runGeneration('path/to/file.ts')
+    Note right of gasnukiPlugin: (デバウンス処理)
+    gasnukiPlugin->>Core: generateAppsScriptTypes()
+    Core-->>gasnukiPlugin: 再生成完了
+```
+
+## 7. その他考慮事項
+
+-   **エラー表示**: `generateAppsScriptTypes` が例外をスローした場合、`consola.error` を使用してViteのコンソールにスタックトレースを含む詳細なエラー情報を出力する。これにより、開発者はエラーの原因を特定しやすくなる。
+-   **テスト**: Viteプラグインの動作を検証するための単体テスト・結合テストを追加する。`vite` を `devDependencies` に追加し、テスト環境内でViteサーバーをプログラム的に起動してプラグインの各フックが正しく動作するかを確認する。

package/.docs/vite-plugin/requirements.md

@@ -0,0 +1,72 @@
+# `@ciderjs/gasnuki` Viteプラグイン機能追加 要件定義書
+
+## 1. 概要
+
+本ドキュメントは、npmパッケージ `@ciderjs/gasnuki` にViteプラグイン機能を追加するための要件を定義するものである。
+
+## 2. 背景・目的
+
+`@ciderjs/gasnuki` は、Google Apps Script (GAS) のサーバーサイドコードからTypeScriptの型定義を生成するCLIツールである。現状では、開発者はCLIを単独で、または `--watch` モードで実行する必要がある。
+
+Viteを利用したフロントエンド開発プロジェクトにおいて、`vite dev` コマンドによる開発サーバーのライフサイクルと `gasnuki` の型生成プロセスを連携させることで、以下の目的を達成する。
+
+-   **開発体験の向上**: 開発者は `vite dev` を実行するだけで、GASコードの変更が自動的にクライアントサイドの型定義に反映されるようになり、手動でのコマンド実行や別プロセスの管理が不要になる。
+-   **設定の統合**: `gasnuki` に関する設定を `vite.config.ts` 内に集約し、プロジェクト設定の一元管理を促進する。
+-   **シームレスな統合**: Viteの開発エコシステムに `gasnuki` をスムーズに統合し、導入のハードルを下げる。
+
+## 3. スコープ
+
+### 3.1. スコープ内
+
+-   Viteの開発サーバー (`vite dev` / `serve`) 実行時に動作するViteプラグインの開発。
+-   プラグイン経由での `gasnuki` の設定。
+-   開発サーバー起動時の初回型定義生成。
+-   ソースファイルの変更を監視し、型定義を自動で再生成する機能。
+
+### 3.2. スコープ外
+
+-   Viteのビルドプロセス (`vite build`) へのフック。`gasnuki` は開発時の型安全性を目的とするため、本番ビルドには関与しない。
+-   CLI機能の変更・廃止。既存のCLI機能はそのまま維持する。
+
+## 4. 機能要件
+
+| ID   | 機能名                         | 種別 | 概要                                                                                                                                                                                                             |
+| :--- | :----------------------------- | :--- | :--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| F-01 | **プラグインインターフェース** | 新規 | `import { gasnuki } from '@ciderjs/gasnuki/vite'` のようにインポートできるエントリーポイントを提供する。<br>プラグインは `gasnuki(options?: UserConfig)` という形式のファクトリ関数として提供する。              |
+| F-02 | **設定の解決**                 | 変更 | プラグインに `options` が渡された場合はその設定を優先する。<br>`options` がない場合は、プロジェクトルートの `gasnuki.config.ts` 等を自動で読み込む。<br>プロジェクトルートの特定にはViteのコンフィグを利用する。 |
+| F-03 | **初回型定義生成**             | 新規 | `vite dev` コマンドで開発サーバーが起動する際に、型定義の生成処理を一度実行する。                                                                                                                                |
+| F-04 | **ファイル変更時の自動再生成** | 新規 | 開発サーバーの起動中、設定された `srcDir` 内の `.ts` ファイルの変更（追加・更新・削除）を監視し、変更があった場合に型定義の再生成を自動で実行する。                                                              |
+| F-05 | **既存機能との連携**           | 変更 | 型定義の生成ロジック (`generateAppsScriptTypes`) や設定ファイルの読み込みロジック (`loadConfig`) など、既存のコア機能を再利用して実装する。                                                                      |
+
+## 5. 非機能要件
+
+| ID    | 要件項目           | 概要                                                                                                   |
+| :---- | :----------------- | :----------------------------------------------------------------------------------------------------- |
+| NF-01 | **パフォーマンス** | ファイル変更時の再生成処理が、開発サーバーの応答性やパフォーマンスに大きな影響を与えないこと。         |
+| NF-02 | **ユーザビリティ** | `vite.config.ts` に数行追加するだけで導入できる、シンプルで分かりやすいAPIを提供すること。             |
+| NF-03 | **フィードバック** | 型定義の生成・再生成の開始、成功、エラー発生時には、Viteのコンソールに適切なメッセージを出力すること。 |
+| NF-04 | **互換性**         | 既存のCLI機能とViteプラグイン機能が共存でき、互いに影響を与えないこと。                                |
+
+## 6. 実装方針
+
+### 6.1. パッケージ構成
+
+-   プラグインのロジックを実装するファイル (例: `src/vite.ts`) を新設する。
+-   `package.json` の `exports` フィールドに、Viteプラグイン用のエントリーポイント (例: `./vite`) を追加する。
+-   ビルド設定 (`build.config.ts`) を更新し、Viteプラグイン用のファイルを成果物として出力する。
+
+### 6.2. Viteプラグインフックの利用
+
+-   **`name`**: プラグインを識別するための一意な名前 (例: `vite-plugin-gasnuki`) を設定する。
+-   **`apply: 'serve'`**: 開発サーバーでのみプラグインが動作するように制限する。
+-   **`configResolved(config)`**: Viteの設定が解決された後に呼び出されるフック。`config.root` を基準にプロジェクトルートを特定し、`gasnuki` の最終的な設定オブジェクトをここで確定させる。
+-   **`configureServer(server)`**: 開発サーバーが構成された際に呼び出されるフック。
+    -   サーバー起動処理の一環として、初回の型生成処理を非同期で実行する。
+    -   `server.watcher` (Viteが内部で使用する `chokidar` インスタンス) を利用して、対象ソースファイルの変更イベントを購読する。
+    -   ファイル変更イベント発生時に、型定義の再生成処理を呼び出す。
+
+## 7. ドキュメント
+
+-   `README.md` および `README.ja.md` を更新し、「Viteプラグインとしての利用」のセクションを追加する。
+    -   `vite.config.ts` への基本的な設定例を記載する。
+    -   プラグインに渡せるオプションについて説明する。

package/README.ja.md

@@ -1,6 +1,6 @@
 # gasnuki
 
-[![Test Coverage](https://img.shields.io/badge/test%20coverage-81.52%25-green)](https://github.com/luthpg/gasnuki)
+[![Test Coverage](https://img.shields.io/badge/test%20coverage-84.76%25-green)](https://github.com/luthpg/gasnuki)
 [![License](https://img.shields.io/badge/license-ISC-blue.svg)](LICENSE)
 [![npm version](https://img.shields.io/npm/v/@ciderjs/gasnuki.svg)](https://www.npmjs.com/package/@ciderjs/gasnuki)
 [![GitHub issues](https://img.shields.io/github/issues/luthpg/gasnuki.svg)](https://github.com/luthpg/gasnuki/issues)
@@ -45,6 +45,35 @@ npx @ciderjs/gasnuki
 
 デフォルトでは `types` ディレクトリに型定義ファイルが生成されます。
 
+### Vite プラグインとしての使い方
+
+Vite を使用している場合、`gasnuki` をプラグインとして統合し、サーバーサイドのファイルが変更されたときに自動で型定義を生成できます。
+
+1. `vite` と `@ciderjs/gasnuki` をインストールします:
+
+    ```bash
+    pnpm add -D vite @ciderjs/gasnuki
+    ```
+
+2. `vite.config.ts` にプラグインを追加します:
+
+    ```ts
+    import { defineConfig } from 'vite';
+    import { gasnuki } from '@ciderjs/gasnuki/vite';
+
+    export default defineConfig({
+      plugins: [
+        gasnuki({
+          /* オプション */
+        }),
+      ],
+    });
+    ```
+
+    これで `vite dev` を実行すると、`gasnuki` がApps Scriptソースファイルの変更を自動的に監視し、型を再生成します。
+
+---
+
 2. 生成されたディレクトリ（デフォルト: `types`）を `tsconfig.json` の `include` に追加してください:
 
 ```jsonc
@@ -77,6 +106,60 @@ google.script.run
 - Google Apps Script クライアントAPIの型定義
 - サーバーサイド関数の戻り値型をvoidに変換するユーティリティ型
 
+### Promiseベースのラッパー
+
+`@ciderjs/gasnuki/promise` を利用すると、`google.script.run` をPromiseを返す型安全なラッパーとして使用できます。これにより、`async/await` を使ったモダンな非同期処理を記述できます。
+
+1. まず、`gasnuki` で生成した型定義 (`ServerScripts`) と、`getPromisedServerScripts` 関数をインポートします。
+
+    ```ts:lib/gas.ts
+    import { getPromisedServerScripts } from '@ciderjs/gasnuki/promise';
+    // gasnukiが生成した型定義のパスを指定します
+    import type { ServerScripts } from '../types/appsscript';
+
+    export const gas = getPromisedServerScripts<ServerScripts>();
+    ```
+
+2. 作成した `gas` オブジェクトを使って、サーバーサイド関数を `async/await` で呼び出します。
+
+    ```ts:components/MyComponent.tsx
+    import { gas } from '../lib/gas';
+
+    async function fetchData() {
+      try {
+        // 'getContent' の引数と戻り値が型安全になります
+        const result = await gas.getContent('Sheet1');
+        console.log(result);
+      } catch (error) {
+        console.error(error);
+      }
+    }
+    ```
+
+#### モックアップによる開発
+
+`getPromisedServerScripts` にモック関数を渡すことで、`clasp push` をせずともフロントエンド開発を進めることができます。
+
+```ts:lib/gas.ts
+import {
+  getPromisedServerScripts,
+  type PartialScriptType,
+} from '@ciderjs/gasnuki/promise';
+import type { ServerScripts } from '../types/appsscript';
+
+// 開発用のモック関数を定義します
+const mockup: PartialScriptType<ServerScripts> = {
+  // sayHello関数の動作をシミュレート
+  sayHello: async (name) => {
+    await new Promise(resolve => setTimeout(resolve, 500)); // ネットワーク遅延を模倣
+    return `Hello from mockup, ${name}!`;
+  },
+  // 他の関数も同様にモックできます
+};
+
+export const gas = getPromisedServerScripts<ServerScripts>(mockup);
+```
+
 ## コントリビュート
 
 バグ報告やプルリクエストは歓迎します。

package/README.md

@@ -1,6 +1,6 @@
 # @ciderjs/gasnuki
 
-[![Test Coverage](https://img.shields.io/badge/test%20coverage-81.52%25-green)](https://github.com/luthpg/gasnuki)
+[![Test Coverage](https://img.shields.io/badge/test%20coverage-84.76%25-green)](https://github.com/luthpg/gasnuki)
 [![License](https://img.shields.io/badge/license-ISC-blue.svg)](LICENSE)
 [![npm version](https://img.shields.io/npm/v/@ciderjs/gasnuki.svg)](https://www.npmjs.com/package/@ciderjs/gasnuki)
 [![GitHub issues](https://img.shields.io/github/issues/luthpg/gasnuki.svg)](https://github.com/luthpg/gasnuki/issues)
@@ -44,6 +44,35 @@ npx @ciderjs/gasnuki
 
 This will generate type definition files in the `types` directory by default.
 
+### Vite Plugin Usage
+
+If you are using Vite, you can integrate `gasnuki` as a plugin to automatically generate types when your server-side files change.
+
+1. Install `vite` and `@ciderjs/gasnuki`:
+
+    ```bash
+    pnpm add -D vite @ciderjs/gasnuki
+    ```
+
+2. Add the plugin to your `vite.config.ts`:
+
+    ```ts
+    import { defineConfig } from 'vite';
+    import { gasnuki } from '@ciderjs/gasnuki/vite';
+
+    export default defineConfig({
+      plugins: [
+        gasnuki({
+          /* options */
+        }),
+      ],
+    });
+    ```
+
+    Now, when you run `vite dev`, `gasnuki` will automatically watch for changes in your Apps Script source files and regenerate the types.
+
+---
+
 2. Make sure the generated directory (default: `types`) is included in your `tsconfig.json`:
 
 ```jsonc
@@ -76,6 +105,62 @@ google.script.run
 - Type definitions for Google Apps Script client-side API
 - Utility type to convert server-side function return types to void
 
+### Promise-based Wrapper
+
+For a more modern asynchronous approach, you can use the type-safe Promise-based wrapper for `google.script.run`. This allows you to write clean code with `async/await`.
+
+1. First, import the type definitions (`ServerScripts`) generated by `gasnuki` and the `getPromisedServerScripts` function.
+
+    ```ts:lib/gas.ts
+    import { getPromisedServerScripts } from '@ciderjs/gasnuki/promise';
+    // Specify the path to the type definitions generated by gasnuki
+    import type { ServerScripts } from '../types/appsscript';
+
+    export const gas = getPromisedServerScripts<ServerScripts>();
+    ```
+
+2. Use the created `gas` object to call your server-side functions with `async/await`.
+
+    ```ts:components/MyComponent.tsx
+    import { gas } from '../lib/gas';
+
+    async function fetchData() {
+      try {
+        // The arguments and return value of 'getContent' are now type-safe!
+        const result = await gas.getContent('Sheet1');
+        console.log(result);
+      } catch (error) {
+        console.error(error);
+      }
+    }
+    ```
+
+#### Development with Mockups
+
+By passing mockup functions to `getPromisedServerScripts`, you can proceed with frontend development without needing to `clasp push` every time.
+
+```ts:lib/gas.ts
+import {
+  getPromisedServerScripts,
+  type PartialScriptType,
+} from '@ciderjs/gasnuki/promise';
+import type { ServerScripts } from '../types/appsscript';
+
+// Define mockup functions for development
+const mockup: PartialScriptType<ServerScripts> = {
+  // Simulate the behavior of the sayHello function
+  sayHello: async (name) => {
+    await new Promise(resolve => setTimeout(resolve, 500)); // Simulate network delay
+    return `Hello from mockup, ${name}!`;
+  },
+  // Other functions can be mocked similarly
+};
+
+export const gas = getPromisedServerScripts<ServerScripts>(mockup);
+```
+
+---
+
 ## Contributing
 
 Bug reports and pull requests are welcome. Please use the `issues` or `pull requests` section.

package/dist/cli.cjs

@@ -3,7 +3,8 @@
 
 const path = require('node:path');
 const commander = require('commander');
-const index = require('./shared/gasnuki.93G9yyCy.cjs');
+const index = require('./index.cjs');
+const config = require('./shared/gasnuki.CxoM0Mts.cjs');
 require('chokidar');
 require('consola');
 require('node:fs');
@@ -24,11 +25,11 @@ function _interopNamespaceCompat(e) {
 
 const path__namespace = /*#__PURE__*/_interopNamespaceCompat(path);
 
-const version = "0.2.10";
+const version = "0.3.0";
 
 const parseArgs = async (command) => {
   const cliOpts = command.opts();
-  const fileConfig = await index.loadConfig(path__namespace.resolve(cliOpts.project));
+  const fileConfig = await config.loadConfig(path__namespace.resolve(cliOpts.project));
   const defaultOpts = {};
   for (const option of command.options) {
     const key = option.attributeName();

package/dist/cli.mjs

@@ -1,14 +1,15 @@
 #! /usr/bin/env  node
 import * as path from 'node:path';
 import { Command } from 'commander';
-import { l as loadConfig, g as generateTypes } from './shared/gasnuki.CS974pL-.mjs';
+import { generateTypes } from './index.mjs';
+import { l as loadConfig } from './shared/gasnuki.BYl_yopE.mjs';
 import 'chokidar';
 import 'consola';
 import 'node:fs';
 import 'ts-morph';
 import 'jiti';
 
-const version = "0.2.10";
+const version = "0.3.0";
 
 const parseArgs = async (command) => {
   const cliOpts = command.opts();

package/dist/index.cjs

@@ -1,14 +1,79 @@
 'use strict';
 
-require('node:path');
-require('chokidar');
-require('consola');
-const index = require('./shared/gasnuki.93G9yyCy.cjs');
+const path = require('node:path');
+const chokidar = require('chokidar');
+const consola = require('consola');
+const config = require('./shared/gasnuki.CxoM0Mts.cjs');
 require('node:fs');
 require('ts-morph');
 require('jiti');
 
+function _interopNamespaceCompat(e) {
+  if (e && typeof e === 'object' && 'default' in e) return e;
+  const n = Object.create(null);
+  if (e) {
+    for (const k in e) {
+      n[k] = e[k];
+    }
+  }
+  n.default = e;
+  return n;
+}
 
+const path__namespace = /*#__PURE__*/_interopNamespaceCompat(path);
+const chokidar__namespace = /*#__PURE__*/_interopNamespaceCompat(chokidar);
 
-exports.defineConfig = index.defineConfig;
-exports.generateTypes = index.generateTypes;
+const generateTypes = async ({
+  project,
+  srcDir,
+  outDir,
+  outputFile,
+  watch
+}) => {
+  const runGeneration = async (triggeredBy) => {
+    const reason = triggeredBy ? ` (${triggeredBy})` : "";
+    consola.consola.info(`Generating AppsScript types${reason}...`);
+    try {
+      await config.generateAppsScriptTypes({ project, srcDir, outDir, outputFile });
+      consola.consola.info("Type generation complete.");
+    } catch (e) {
+      consola.consola.error(`Type generation failed: ${e.message}`, e);
+    }
+  };
+  await runGeneration();
+  if (watch) {
+    const sourcePathToWatch = path__namespace.resolve(project, srcDir).replace(/\\/g, "/");
+    consola.consola.info(
+      `Watching for changes in ${sourcePathToWatch}... (Press Ctrl+C to stop)`
+    );
+    const watcher = chokidar__namespace.watch(sourcePathToWatch, {
+      ignored: ["node_modules", "dist"],
+      persistent: true,
+      ignoreInitial: true
+    });
+    const eventHandler = async (filePath, eventName) => {
+      consola.consola.info(`Watcher is called triggered on ${eventName}`);
+      const relativePath = path__namespace.relative(project, filePath);
+      await runGeneration(relativePath);
+    };
+    watcher.on("ready", async () => {
+      console.log("...waiting...");
+      watcher.on("all", async (event, path2) => {
+        consola.consola.info(`Watcher is called triggered on ${event}: ${path2}`);
+        await eventHandler(path2, event);
+      });
+    });
+    for (const signal of ["SIGINT", "SIGTERM"]) {
+      process.on(signal, async () => {
+        await watcher.close();
+        consola.consola.info("Watcher is closed.");
+        process.exit(0);
+      });
+    }
+  } else {
+    process.exit(0);
+  }
+};
+
+exports.defineConfig = config.defineConfig;
+exports.generateTypes = generateTypes;

package/dist/index.mjs

@@ -1,7 +1,62 @@
-import 'node:path';
-import 'chokidar';
-import 'consola';
-export { d as defineConfig, g as generateTypes } from './shared/gasnuki.CS974pL-.mjs';
+import * as path from 'node:path';
+import * as chokidar from 'chokidar';
+import { consola } from 'consola';
+import { g as generateAppsScriptTypes } from './shared/gasnuki.BYl_yopE.mjs';
+export { d as defineConfig } from './shared/gasnuki.BYl_yopE.mjs';
 import 'node:fs';
 import 'ts-morph';
 import 'jiti';
+
+const generateTypes = async ({
+  project,
+  srcDir,
+  outDir,
+  outputFile,
+  watch
+}) => {
+  const runGeneration = async (triggeredBy) => {
+    const reason = triggeredBy ? ` (${triggeredBy})` : "";
+    consola.info(`Generating AppsScript types${reason}...`);
+    try {
+      await generateAppsScriptTypes({ project, srcDir, outDir, outputFile });
+      consola.info("Type generation complete.");
+    } catch (e) {
+      consola.error(`Type generation failed: ${e.message}`, e);
+    }
+  };
+  await runGeneration();
+  if (watch) {
+    const sourcePathToWatch = path.resolve(project, srcDir).replace(/\\/g, "/");
+    consola.info(
+      `Watching for changes in ${sourcePathToWatch}... (Press Ctrl+C to stop)`
+    );
+    const watcher = chokidar.watch(sourcePathToWatch, {
+      ignored: ["node_modules", "dist"],
+      persistent: true,
+      ignoreInitial: true
+    });
+    const eventHandler = async (filePath, eventName) => {
+      consola.info(`Watcher is called triggered on ${eventName}`);
+      const relativePath = path.relative(project, filePath);
+      await runGeneration(relativePath);
+    };
+    watcher.on("ready", async () => {
+      console.log("...waiting...");
+      watcher.on("all", async (event, path2) => {
+        consola.info(`Watcher is called triggered on ${event}: ${path2}`);
+        await eventHandler(path2, event);
+      });
+    });
+    for (const signal of ["SIGINT", "SIGTERM"]) {
+      process.on(signal, async () => {
+        await watcher.close();
+        consola.info("Watcher is closed.");
+        process.exit(0);
+      });
+    }
+  } else {
+    process.exit(0);
+  }
+};
+
+export { generateTypes };

package/dist/shared/{gasnuki.CS974pL-.mjs → gasnuki.BYl_yopE.mjs}

@@ -1,7 +1,6 @@
+import * as fs from 'node:fs';
 import * as path from 'node:path';
-import * as chokidar from 'chokidar';
 import { consola } from 'consola';
-import * as fs from 'node:fs';
 import { Project, SyntaxKind, SymbolFlags } from 'ts-morph';
 import { createJiti } from 'jiti';
 
@@ -79,20 +78,20 @@ const generateAppsScriptTypes = async ({
   const exportedFunctions = [];
   for (const sourceFile of sourceFiles) {
     for (const iface of sourceFile.getInterfaces()) {
-      if (iface.isExported() && !iface.getName()?.endsWith("_")) {
+      if (!iface.getName()?.endsWith("_")) {
         exportedDeclarations.push(iface);
         exportedDeclarationNames.add(iface.getName());
       }
     }
     for (const typeAlias of sourceFile.getTypeAliases()) {
-      if (typeAlias.isExported() && !typeAlias.getName().endsWith("_")) {
+      if (!typeAlias.getName().endsWith("_")) {
         exportedDeclarations.push(typeAlias);
         exportedDeclarationNames.add(typeAlias.getName());
       }
     }
     for (const func of sourceFile.getFunctions()) {
       const name = func.getName();
-      if (func.isExported() && name && !name.endsWith("_") && !SIMPLE_TRIGGER_FUNCTION_NAMES.includes(name)) {
+      if (name && !name.endsWith("_") && !SIMPLE_TRIGGER_FUNCTION_NAMES.includes(name)) {
         exportedDeclarations.push(func);
         exportedDeclarationNames.add(name);
         methodDefinitions.push(getInterfaceMethodDefinition_(name, func));
@@ -100,7 +99,6 @@ const generateAppsScriptTypes = async ({
       }
     }
     for (const varStmt of sourceFile.getVariableStatements()) {
-      if (!varStmt.isExported()) continue;
       for (const varDecl of varStmt.getDeclarations()) {
         const name = varDecl.getName();
         const initializer = varDecl.getInitializer();
@@ -334,56 +332,4 @@ async function loadConfig(projectRoot) {
   }
 }
 
-const generateTypes = async ({
-  project,
-  srcDir,
-  outDir,
-  outputFile,
-  watch
-}) => {
-  const runGeneration = async (triggeredBy) => {
-    const reason = triggeredBy ? ` (${triggeredBy})` : "";
-    consola.info(`Generating AppsScript types${reason}...`);
-    try {
-      await generateAppsScriptTypes({ project, srcDir, outDir, outputFile });
-      consola.info("Type generation complete.");
-    } catch (e) {
-      consola.error(`Type generation failed: ${e.message}`, e);
-    }
-  };
-  await runGeneration();
-  if (watch) {
-    const sourcePathToWatch = path.resolve(project, srcDir).replace(/\\/g, "/");
-    consola.info(
-      `Watching for changes in ${sourcePathToWatch}... (Press Ctrl+C to stop)`
-    );
-    const watcher = chokidar.watch(sourcePathToWatch, {
-      ignored: ["node_modules", "dist"],
-      persistent: true,
-      ignoreInitial: true
-    });
-    const eventHandler = async (filePath, eventName) => {
-      consola.info(`Watcher is called triggered on ${eventName}`);
-      const relativePath = path.relative(project, filePath);
-      await runGeneration(relativePath);
-    };
-    watcher.on("ready", async () => {
-      console.log("...waiting...");
-      watcher.on("all", async (event, path2) => {
-        consola.info(`Watcher is called triggered on ${event}: ${path2}`);
-        await eventHandler(path2, event);
-      });
-    });
-    for (const signal of ["SIGINT", "SIGTERM"]) {
-      process.on(signal, async () => {
-        await watcher.close();
-        consola.info("Watcher is closed.");
-        process.exit(0);
-      });
-    }
-  } else {
-    process.exit(0);
-  }
-};
-
-export { defineConfig as d, generateTypes as g, loadConfig as l };
+export { defineConfig as d, generateAppsScriptTypes as g, loadConfig as l };

package/dist/shared/{gasnuki.93G9yyCy.cjs → gasnuki.CxoM0Mts.cjs}

@@ -1,9 +1,8 @@
 'use strict';
 
+const fs = require('node:fs');
 const path = require('node:path');
-const chokidar = require('chokidar');
 const consola = require('consola');
-const fs = require('node:fs');
 const tsMorph = require('ts-morph');
 const jiti = require('jiti');
 
@@ -19,9 +18,8 @@ function _interopNamespaceCompat(e) {
   return n;
 }
 
-const path__namespace = /*#__PURE__*/_interopNamespaceCompat(path);
-const chokidar__namespace = /*#__PURE__*/_interopNamespaceCompat(chokidar);
 const fs__namespace = /*#__PURE__*/_interopNamespaceCompat(fs);
+const path__namespace = /*#__PURE__*/_interopNamespaceCompat(path);
 
 const text = "export type RemoveReturnType<T> = {\n  [P in keyof T]: T[P] extends (...args: infer A) => any\n    ? (...args: A) => void\n    : T[P];\n};\n\ntype _AppsScriptRun = RemoveReturnType<ServerScripts> & {\n  [key: string]: (...args: any[]) => any;\n  withSuccessHandler: <T = string | number | boolean | undefined, U = any>(\n    callback: (returnValues: T, userObject?: U) => void,\n  ) => _AppsScriptRun;\n  withFailureHandler: <U = any>(\n    callback: (error: Error, userObject?: U) => void,\n  ) => _AppsScriptRun;\n  withUserObject: <U = any>(userObject: U) => _AppsScriptRun;\n};\n\ntype _AppsScriptHistoryFunction = (\n  stateObject: object,\n  params: object,\n  hash: string,\n) => void;\n\ninterface _WebAppLocationType {\n  hash: string;\n  parameter: Record<string, string>;\n  parameters: Record<string, string[]>;\n}\n\nexport declare interface GoogleClientSideApi {\n  script: {\n    run: _AppsScriptRun;\n    url: {\n      getLocation: (callback: (location: _WebAppLocationType) => void) => void;\n    };\n    history: {\n      push: _AppsScriptHistoryFunction;\n      replace: _AppsScriptHistoryFunction;\n      setChangeHandler: (\n        callback: (e: { state: object; location: _WebAppLocationType }) => void,\n      ) => void;\n    };\n  };\n}\n\ndeclare global {\n  const google: GoogleClientSideApi;\n}\n";
 
@@ -97,20 +95,20 @@ const generateAppsScriptTypes = async ({
   const exportedFunctions = [];
   for (const sourceFile of sourceFiles) {
     for (const iface of sourceFile.getInterfaces()) {
-      if (iface.isExported() && !iface.getName()?.endsWith("_")) {
+      if (!iface.getName()?.endsWith("_")) {
         exportedDeclarations.push(iface);
         exportedDeclarationNames.add(iface.getName());
       }
     }
     for (const typeAlias of sourceFile.getTypeAliases()) {
-      if (typeAlias.isExported() && !typeAlias.getName().endsWith("_")) {
+      if (!typeAlias.getName().endsWith("_")) {
         exportedDeclarations.push(typeAlias);
         exportedDeclarationNames.add(typeAlias.getName());
       }
     }
     for (const func of sourceFile.getFunctions()) {
       const name = func.getName();
-      if (func.isExported() && name && !name.endsWith("_") && !SIMPLE_TRIGGER_FUNCTION_NAMES.includes(name)) {
+      if (name && !name.endsWith("_") && !SIMPLE_TRIGGER_FUNCTION_NAMES.includes(name)) {
         exportedDeclarations.push(func);
         exportedDeclarationNames.add(name);
         methodDefinitions.push(getInterfaceMethodDefinition_(name, func));
@@ -118,7 +116,6 @@ const generateAppsScriptTypes = async ({
       }
     }
     for (const varStmt of sourceFile.getVariableStatements()) {
-      if (!varStmt.isExported()) continue;
       for (const varDecl of varStmt.getDeclarations()) {
         const name = varDecl.getName();
         const initializer = varDecl.getInitializer();
@@ -352,58 +349,6 @@ async function loadConfig(projectRoot) {
   }
 }
 
-const generateTypes = async ({
-  project,
-  srcDir,
-  outDir,
-  outputFile,
-  watch
-}) => {
-  const runGeneration = async (triggeredBy) => {
-    const reason = triggeredBy ? ` (${triggeredBy})` : "";
-    consola.consola.info(`Generating AppsScript types${reason}...`);
-    try {
-      await generateAppsScriptTypes({ project, srcDir, outDir, outputFile });
-      consola.consola.info("Type generation complete.");
-    } catch (e) {
-      consola.consola.error(`Type generation failed: ${e.message}`, e);
-    }
-  };
-  await runGeneration();
-  if (watch) {
-    const sourcePathToWatch = path__namespace.resolve(project, srcDir).replace(/\\/g, "/");
-    consola.consola.info(
-      `Watching for changes in ${sourcePathToWatch}... (Press Ctrl+C to stop)`
-    );
-    const watcher = chokidar__namespace.watch(sourcePathToWatch, {
-      ignored: ["node_modules", "dist"],
-      persistent: true,
-      ignoreInitial: true
-    });
-    const eventHandler = async (filePath, eventName) => {
-      consola.consola.info(`Watcher is called triggered on ${eventName}`);
-      const relativePath = path__namespace.relative(project, filePath);
-      await runGeneration(relativePath);
-    };
-    watcher.on("ready", async () => {
-      console.log("...waiting...");
-      watcher.on("all", async (event, path2) => {
-        consola.consola.info(`Watcher is called triggered on ${event}: ${path2}`);
-        await eventHandler(path2, event);
-      });
-    });
-    for (const signal of ["SIGINT", "SIGTERM"]) {
-      process.on(signal, async () => {
-        await watcher.close();
-        consola.consola.info("Watcher is closed.");
-        process.exit(0);
-      });
-    }
-  } else {
-    process.exit(0);
-  }
-};
-
 exports.defineConfig = defineConfig;
-exports.generateTypes = generateTypes;
+exports.generateAppsScriptTypes = generateAppsScriptTypes;
 exports.loadConfig = loadConfig;

package/dist/vite.cjs

@@ -0,0 +1,83 @@
+'use strict';
+
+const path = require('node:path');
+const consola = require('consola');
+const config = require('./shared/gasnuki.CxoM0Mts.cjs');
+require('node:fs');
+require('ts-morph');
+require('jiti');
+
+function _interopNamespaceCompat(e) {
+  if (e && typeof e === 'object' && 'default' in e) return e;
+  const n = Object.create(null);
+  if (e) {
+    for (const k in e) {
+      n[k] = e[k];
+    }
+  }
+  n.default = e;
+  return n;
+}
+
+const path__namespace = /*#__PURE__*/_interopNamespaceCompat(path);
+
+function gasnuki(options) {
+  let projectRoot;
+  let gasnukiOptions;
+  let debounceTimer = null;
+  const debounce = (func, timeout = 300) => {
+    if (debounceTimer) {
+      clearTimeout(debounceTimer);
+    }
+    debounceTimer = setTimeout(func, timeout);
+  };
+  const runGeneration = (triggeredBy) => {
+    debounce(async () => {
+      const reason = triggeredBy ? ` (triggered by: ${triggeredBy})` : "";
+      console.log("");
+      consola.consola.info(`[gasnuki] Generating AppsScript types${reason}...`);
+      try {
+        await config.generateAppsScriptTypes({
+          ...gasnukiOptions,
+          project: projectRoot
+        });
+        consola.consola.success("[gasnuki] Type generation complete.");
+      } catch (e) {
+        consola.consola.error(
+          `[gasnuki] Type generation failed: ${e.message}`
+        );
+      }
+    });
+  };
+  return {
+    name: "vite-plugin-gasnuki",
+    apply: "serve",
+    // Apply only in serve mode
+    async configResolved(config$1) {
+      projectRoot = config$1.root;
+      const fileConfig = await config.loadConfig(projectRoot);
+      const defaultOptions = {
+        srcDir: "server",
+        outDir: "types",
+        outputFile: "appsscript.ts"
+      };
+      gasnukiOptions = {
+        ...defaultOptions,
+        ...fileConfig,
+        ...options || {}
+      };
+    },
+    async configureServer(server) {
+      const targetDir = path__namespace.resolve(projectRoot, gasnukiOptions.srcDir);
+      runGeneration("server startup");
+      server.watcher.on("all", (_event, filePath) => {
+        const relativePath = path__namespace.relative(targetDir, filePath);
+        if (!relativePath.startsWith("..") && relativePath !== "..") {
+          runGeneration(path__namespace.relative(projectRoot, filePath));
+        }
+      });
+    }
+  };
+}
+
+exports.gasnuki = gasnuki;

package/dist/vite.d.cts

@@ -0,0 +1,11 @@
+import { Plugin } from 'vite';
+import { UserConfig } from './index.cjs';
+
+/**
+ * A factory function to create the gasnuki Vite plugin.
+ * @param options - The user-defined configuration for gasnuki.
+ * @returns The Vite plugin object.
+ */
+declare function gasnuki(options?: UserConfig): Plugin;
+
+export { gasnuki };

package/dist/vite.d.mts

@@ -0,0 +1,11 @@
+import { Plugin } from 'vite';
+import { UserConfig } from './index.mjs';
+
+/**
+ * A factory function to create the gasnuki Vite plugin.
+ * @param options - The user-defined configuration for gasnuki.
+ * @returns The Vite plugin object.
+ */
+declare function gasnuki(options?: UserConfig): Plugin;
+
+export { gasnuki };

package/dist/vite.d.ts

@@ -0,0 +1,11 @@
+import { Plugin } from 'vite';
+import { UserConfig } from './index.js';
+
+/**
+ * A factory function to create the gasnuki Vite plugin.
+ * @param options - The user-defined configuration for gasnuki.
+ * @returns The Vite plugin object.
+ */
+declare function gasnuki(options?: UserConfig): Plugin;
+
+export { gasnuki };

package/dist/vite.mjs

@@ -0,0 +1,67 @@
+import * as path from 'node:path';
+import { consola } from 'consola';
+import { l as loadConfig, g as generateAppsScriptTypes } from './shared/gasnuki.BYl_yopE.mjs';
+import 'node:fs';
+import 'ts-morph';
+import 'jiti';
+
+function gasnuki(options) {
+  let projectRoot;
+  let gasnukiOptions;
+  let debounceTimer = null;
+  const debounce = (func, timeout = 300) => {
+    if (debounceTimer) {
+      clearTimeout(debounceTimer);
+    }
+    debounceTimer = setTimeout(func, timeout);
+  };
+  const runGeneration = (triggeredBy) => {
+    debounce(async () => {
+      const reason = triggeredBy ? ` (triggered by: ${triggeredBy})` : "";
+      console.log("");
+      consola.info(`[gasnuki] Generating AppsScript types${reason}...`);
+      try {
+        await generateAppsScriptTypes({
+          ...gasnukiOptions,
+          project: projectRoot
+        });
+        consola.success("[gasnuki] Type generation complete.");
+      } catch (e) {
+        consola.error(
+          `[gasnuki] Type generation failed: ${e.message}`
+        );
+      }
+    });
+  };
+  return {
+    name: "vite-plugin-gasnuki",
+    apply: "serve",
+    // Apply only in serve mode
+    async configResolved(config) {
+      projectRoot = config.root;
+      const fileConfig = await loadConfig(projectRoot);
+      const defaultOptions = {
+        srcDir: "server",
+        outDir: "types",
+        outputFile: "appsscript.ts"
+      };
+      gasnukiOptions = {
+        ...defaultOptions,
+        ...fileConfig,
+        ...options || {}
+      };
+    },
+    async configureServer(server) {
+      const targetDir = path.resolve(projectRoot, gasnukiOptions.srcDir);
+      runGeneration("server startup");
+      server.watcher.on("all", (_event, filePath) => {
+        const relativePath = path.relative(targetDir, filePath);
+        if (!relativePath.startsWith("..") && relativePath !== "..") {
+          runGeneration(path.relative(projectRoot, filePath));
+        }
+      });
+    }
+  };
+}
+
+export { gasnuki };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ciderjs/gasnuki",
-  "version": "0.2.10",
+  "version": "0.3.0",
   "description": "Type definitions and utilities for Google Apps Script client-side API",
   "main": "dist/index.mjs",
   "types": "dist/index.d.ts",
@@ -17,6 +17,11 @@
       "types": "./dist/promise.d.ts",
       "import": "./dist/promise.mjs",
       "require": "./dist/promise.cjs"
+    },
+    "./vite": {
+      "types": "./dist/vite.d.ts",
+      "import": "./dist/vite.mjs",
+      "require": "./dist/vite.cjs"
     }
   },
   "scripts": {
@@ -47,20 +52,24 @@
   "bugs": {
     "url": "https://github.com/luthpg/gasnuki/issues"
   },
-  "packageManager": "pnpm@10.11.1",
+  "packageManager": "pnpm@10.18.3",
   "dependencies": {
     "chokidar": "^4.0.3",
     "commander": "^14.0.1",
     "consola": "^3.4.2",
-    "jiti": "^2.5.1",
-    "ts-morph": "^27.0.0"
+    "jiti": "^2.6.1",
+    "ts-morph": "^27.0.2"
   },
   "devDependencies": {
-    "@biomejs/biome": "^2.2.4",
-    "@types/node": "^24.5.2",
+    "@biomejs/biome": "^2.2.6",
+    "@types/node": "^24.7.2",
     "@vitest/coverage-v8": "3.2.4",
-    "typescript": "^5.9.2",
+    "typescript": "^5.9.3",
     "unbuild": "^3.6.1",
+    "vite": "^7.1.10",
     "vitest": "3.2.4"
+  },
+  "peerDependencies": {
+    "vite": "^7"
   }
 }