@ciderjs/gasnuki 0.4.0 → 0.5.0

package/README.ja.md

@@ -1,9 +1,10 @@
 # @ciderjs/gasnuki
 
 [![README-en](https://img.shields.io/badge/English-blue?logo=ReadMe)](./README.md)
-[![Test Coverage](https://img.shields.io/badge/test%20coverage-93.7%25-brightgreen)](https://github.com/luthpg/gasnuki)
+[![Test Coverage](https://img.shields.io/badge/test%20coverage-93.03%25-brightgreen)](https://github.com/luthpg/gasnuki)
 [![License](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE)
 [![npm version](https://img.shields.io/npm/v/@ciderjs/gasnuki.svg)](https://www.npmjs.com/package/@ciderjs/gasnuki)
+![NPM Downloads](https://img.shields.io/npm/dw/@ciderjs/gasnuki)
 [![GitHub issues](https://img.shields.io/github/issues/luthpg/gasnuki.svg)](https://github.com/luthpg/gasnuki/issues)
 
 Google Apps Script クライアントサイドAPIの型定義・ユーティリティ
@@ -160,7 +161,7 @@ import {
 import type { ServerScripts } from '../types/appsscript';
 
 // 開発用のモック関数を定義します
-const mockup: PartialScriptType<ServerScripts> = {
+const mockupFunctions: PartialScriptType<ServerScripts> = {
   // sayHello関数の動作をシミュレート
   sayHello: async (name) => {
     await new Promise(resolve => setTimeout(resolve, 500)); // ネットワーク遅延を模倣
@@ -169,7 +170,33 @@ const mockup: PartialScriptType<ServerScripts> = {
   // 他の関数も同様にモックできます
 };
 
-export const gas = getPromisedServerScripts<ServerScripts>(mockup);
+export const gas = getPromisedServerScripts<ServerScripts>({ mockupFunctions });
+```
+
+### 型安全な JSON パース (Optional)
+
+通常、Google Apps Script とクライアント間の通信で `JSON.parse()` を使うと戻り値が `any` になってしまいます。また、`Date` 型などはシリアライズの過程で文字列に変換され、手動での復元が必要になります。
+
+`gasnuki` は、シリアライズ前の型情報を Branded Type (`JsonString<T>`) として保持することで、**`any` を介さない型安全な復元**を可能にします。
+
+`getPromisedServerScripts` のオプションに `{ parseJson: true }` を指定すると、サーバー側で `serialize()` された戻り値を自動でデシリアライズし、`Date` オブジェクトも正しく復元します。
+
+```ts
+// サーバー側 (Apps Script)
+// const getAppData = () => serialize({ updatedAt: new Date(), user: 'Alice' });
+
+// クライアント側
+export const gas = getPromisedServerScripts<ServerScripts>({
+  parseJson: true
+});
+
+async function fetchData() {
+  // 戻り値は `any` ではなく、元のオブジェクト型として推論されます
+  // Date オブジェクトも自動的に復元されます
+  const result = await gas.getAppData();
+  console.log(result.user); // 'Alice' (string)
+  console.log(result.updatedAt instanceof Date); // true
+}
 ```
 
 ## コントリビュート

package/README.md

@@ -1,9 +1,10 @@
 # @ciderjs/gasnuki
 
 [![README-ja](https://img.shields.io/badge/日本語-blue?logo=ReadMe)](./README.ja.md)
-[![Test Coverage](https://img.shields.io/badge/test%20coverage-93.7%25-brightgreen)](https://github.com/luthpg/gasnuki)
+[![Test Coverage](https://img.shields.io/badge/test%20coverage-93.03%25-brightgreen)](https://github.com/luthpg/gasnuki)
 [![License](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE)
 [![npm version](https://img.shields.io/npm/v/@ciderjs/gasnuki.svg)](https://www.npmjs.com/package/@ciderjs/gasnuki)
+![NPM Downloads](https://img.shields.io/npm/dw/@ciderjs/gasnuki)
 [![GitHub issues](https://img.shields.io/github/issues/luthpg/gasnuki.svg)](https://github.com/luthpg/gasnuki/issues)
 
 Type definitions and utilities for Google Apps Script client-side API
@@ -160,7 +161,7 @@ import {
 import type { ServerScripts } from '../types/appsscript';
 
 // Define mockup functions for development
-const mockup: PartialScriptType<ServerScripts> = {
+const mockupFunctions: PartialScriptType<ServerScripts> = {
   // Simulate the behavior of the sayHello function
   sayHello: async (name) => {
     await new Promise(resolve => setTimeout(resolve, 500)); // Simulate network delay
@@ -169,7 +170,33 @@ const mockup: PartialScriptType<ServerScripts> = {
   // Other functions can be mocked similarly
 };
 
-export const gas = getPromisedServerScripts<ServerScripts>(mockup);
+export const gas = getPromisedServerScripts<ServerScripts>({ mockupFunctions });
+```
+
+### Type-Safe JSON Parsing (Optional)
+
+Normally, using `JSON.parse()` for communication between Google Apps Script and the client results in an `any` return type. Additionally, types like `Date` are converted to strings during serialization and require manual restoration.
+
+`gasnuki` preserves the original type information as a Branded Type (`JsonString<T>`), enabling **type-safe restoration without using `any`**.
+
+By passing `{ parseJson: true }` as the second argument to `getPromisedServerScripts`, it will automatically deserialize return values that were `serialize()`-ed on the server side, including proper `Date` object recovery.
+
+```ts
+// Server-side (Apps Script)
+// const getAppData = () => serialize({ updatedAt: new Date(), user: 'Alice' });
+
+// Client-side
+export const gas = getPromisedServerScripts<ServerScripts>({
+  parseJson: true
+});
+
+async function fetchData() {
+  // The return value is inferred as the original object type instead of `any`
+  // Date objects are also automatically recovered
+  const result = await gas.getAppData();
+  console.log(result.user); // 'Alice' (string)
+  console.log(result.updatedAt instanceof Date); // true
+}
 ```
 
 ## Contributing

package/dist/cli.cjs

@@ -4,7 +4,7 @@
 const path = require('node:path');
 const commander = require('commander');
 const index = require('./index.cjs');
-const config = require('./shared/gasnuki.DfLTmLhN.cjs');
+const config = require('./shared/gasnuki.Co0-wxJi.cjs');
 require('chokidar');
 require('consola');
 require('node:crypto');
@@ -26,7 +26,7 @@ function _interopNamespaceCompat(e) {
 
 const path__namespace = /*#__PURE__*/_interopNamespaceCompat(path);
 
-const version = "0.4.0";
+const version = "0.5.0";
 
 const parseArgs = async (command) => {
   const cliOpts = command.opts();

package/dist/cli.mjs

@@ -2,7 +2,7 @@
 import * as path from 'node:path';
 import { Command } from 'commander';
 import { generateTypes } from './index.mjs';
-import { l as loadConfig } from './shared/gasnuki.SJQVcSIQ.mjs';
+import { l as loadConfig } from './shared/gasnuki.DePJgSg9.mjs';
 import 'chokidar';
 import 'consola';
 import 'node:crypto';
@@ -10,7 +10,7 @@ import 'node:fs';
 import 'ts-morph';
 import 'jiti';
 
-const version = "0.4.0";
+const version = "0.5.0";
 
 const parseArgs = async (command) => {
   const cliOpts = command.opts();

package/dist/index.cjs

@@ -3,7 +3,7 @@
 const path = require('node:path');
 const chokidar = require('chokidar');
 const consola = require('consola');
-const config = require('./shared/gasnuki.DfLTmLhN.cjs');
+const config = require('./shared/gasnuki.Co0-wxJi.cjs');
 require('node:crypto');
 require('node:fs');
 require('ts-morph');

package/dist/index.mjs

@@ -1,8 +1,8 @@
 import * as path from 'node:path';
 import * as chokidar from 'chokidar';
 import { consola } from 'consola';
-import { g as generateAppsScriptTypes } from './shared/gasnuki.SJQVcSIQ.mjs';
-export { d as defineConfig } from './shared/gasnuki.SJQVcSIQ.mjs';
+import { g as generateAppsScriptTypes } from './shared/gasnuki.DePJgSg9.mjs';
+export { d as defineConfig } from './shared/gasnuki.DePJgSg9.mjs';
 import 'node:crypto';
 import 'node:fs';
 import 'ts-morph';

package/dist/json.cjs

@@ -0,0 +1,21 @@
+'use strict';
+
+const isoDateRegex = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}.\d{3}Z$/;
+function dateReviver(_key, value) {
+  if (typeof value === "string" && isoDateRegex.test(value)) {
+    const date = new Date(value);
+    if (!Number.isNaN(date.getTime())) {
+      return date;
+    }
+  }
+  return value;
+}
+const serialize = (data) => {
+  return JSON.stringify(data);
+};
+const deserialize = (json) => {
+  return JSON.parse(json, dateReviver);
+};
+
+exports.deserialize = deserialize;
+exports.serialize = serialize;

package/dist/json.d.cts

@@ -0,0 +1,29 @@
+declare const __brand: unique symbol;
+/**
+ * シリアライズ前の型情報 `T` を保持したJSON文字列型。
+ * 単なる string ではなく、型システム上で元の型を記憶することで、
+ * 復元時に型安全なパース（anyを介さない復元）を可能にします。
+ */
+type JsonString<T> = string & {
+    [__brand]: T;
+};
+/**
+ * オブジェクトを型情報を保持したまま JSON 文字列に変換します。
+ * 戻り値は元の型 `T` を記憶した `JsonString<T>` となります。
+ *
+ * @param data 変換するオブジェクト
+ * @returns 型情報を保持した JSON 文字列
+ */
+declare const serialize: <T>(data: T) => JsonString<T>;
+/**
+ * `JsonString<T>` から元の型 `T` を型安全に復元します。
+ * 通常の `JSON.parse` と異なり、戻り値が `any` にならず、
+ * また ISO 8601 形式の文字列は自動的に `Date` オブジェクトへ変換されます。
+ *
+ * @param json 型情報を保持した JSON 文字列
+ * @returns 元の型 `T` に復元されたオブジェクト
+ */
+declare const deserialize: <T>(json: JsonString<T>) => T;
+
+export { deserialize, serialize };
+export type { JsonString };

package/dist/json.d.mts

@@ -0,0 +1,29 @@
+declare const __brand: unique symbol;
+/**
+ * シリアライズ前の型情報 `T` を保持したJSON文字列型。
+ * 単なる string ではなく、型システム上で元の型を記憶することで、
+ * 復元時に型安全なパース（anyを介さない復元）を可能にします。
+ */
+type JsonString<T> = string & {
+    [__brand]: T;
+};
+/**
+ * オブジェクトを型情報を保持したまま JSON 文字列に変換します。
+ * 戻り値は元の型 `T` を記憶した `JsonString<T>` となります。
+ *
+ * @param data 変換するオブジェクト
+ * @returns 型情報を保持した JSON 文字列
+ */
+declare const serialize: <T>(data: T) => JsonString<T>;
+/**
+ * `JsonString<T>` から元の型 `T` を型安全に復元します。
+ * 通常の `JSON.parse` と異なり、戻り値が `any` にならず、
+ * また ISO 8601 形式の文字列は自動的に `Date` オブジェクトへ変換されます。
+ *
+ * @param json 型情報を保持した JSON 文字列
+ * @returns 元の型 `T` に復元されたオブジェクト
+ */
+declare const deserialize: <T>(json: JsonString<T>) => T;
+
+export { deserialize, serialize };
+export type { JsonString };

package/dist/json.d.ts

@@ -0,0 +1,29 @@
+declare const __brand: unique symbol;
+/**
+ * シリアライズ前の型情報 `T` を保持したJSON文字列型。
+ * 単なる string ではなく、型システム上で元の型を記憶することで、
+ * 復元時に型安全なパース（anyを介さない復元）を可能にします。
+ */
+type JsonString<T> = string & {
+    [__brand]: T;
+};
+/**
+ * オブジェクトを型情報を保持したまま JSON 文字列に変換します。
+ * 戻り値は元の型 `T` を記憶した `JsonString<T>` となります。
+ *
+ * @param data 変換するオブジェクト
+ * @returns 型情報を保持した JSON 文字列
+ */
+declare const serialize: <T>(data: T) => JsonString<T>;
+/**
+ * `JsonString<T>` から元の型 `T` を型安全に復元します。
+ * 通常の `JSON.parse` と異なり、戻り値が `any` にならず、
+ * また ISO 8601 形式の文字列は自動的に `Date` オブジェクトへ変換されます。
+ *
+ * @param json 型情報を保持した JSON 文字列
+ * @returns 元の型 `T` に復元されたオブジェクト
+ */
+declare const deserialize: <T>(json: JsonString<T>) => T;
+
+export { deserialize, serialize };
+export type { JsonString };

package/dist/json.mjs

@@ -0,0 +1,18 @@
+const isoDateRegex = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}.\d{3}Z$/;
+function dateReviver(_key, value) {
+  if (typeof value === "string" && isoDateRegex.test(value)) {
+    const date = new Date(value);
+    if (!Number.isNaN(date.getTime())) {
+      return date;
+    }
+  }
+  return value;
+}
+const serialize = (data) => {
+  return JSON.stringify(data);
+};
+const deserialize = (json) => {
+  return JSON.parse(json, dateReviver);
+};
+
+export { deserialize, serialize };

package/dist/promise.cjs

@@ -1,6 +1,9 @@
 'use strict';
 
-const getPromisedServerScripts = (mockupFunctions = {}) => {
+const json = require('./json.cjs');
+
+function getPromisedServerScripts(options = {}) {
+  const { mockupFunctions = {}, parseJson = false } = options;
   return new Proxy(mockupFunctions, {
     get(target, method) {
       if (!("google" in globalThis) || !google?.script?.run) {
@@ -10,10 +13,20 @@ const getPromisedServerScripts = (mockupFunctions = {}) => {
         throw Error(`Method ${method} not found in AppsScript.`);
       }
       return (...args) => new Promise((resolve, reject) => {
-        google.script.run.withSuccessHandler(resolve).withFailureHandler(reject)[method](...args);
+        google.script.run.withSuccessHandler((res) => {
+          if (parseJson && typeof res === "string") {
+            try {
+              resolve(json.deserialize(res));
+            } catch {
+              resolve(res);
+            }
+          } else {
+            resolve(res);
+          }
+        }).withFailureHandler(reject)[method](...args);
       });
     }
   });
-};
+}
 
 exports.getPromisedServerScripts = getPromisedServerScripts;

package/dist/promise.d.cts

@@ -1,8 +1,20 @@
+import { JsonString } from './json.cjs';
+
 type Promised<T> = {
     [K in keyof T]: T[K] extends (...args: infer A) => infer R ? (...args: A) => Promise<R> : T[K];
 };
+type UnwrapJson<T> = T extends JsonString<infer U> ? U : T;
+type PromisedWithJson<T> = {
+    [K in keyof T]: T[K] extends (...args: infer A) => infer R ? (...args: A) => Promise<UnwrapJson<R>> : T[K];
+};
 type PartialScriptType<T> = Partial<Promised<T>>;
-declare const getPromisedServerScripts: <T extends Record<string, (...args: any[]) => any> = Omit<typeof google.script.run, "withSuccessHandler" | "withFailureHandler" | "withUserObject">>(mockupFunctions?: PartialScriptType<T>) => Promised<T>;
+type PartialScriptTypeWithJson<T> = Partial<PromisedWithJson<T>>;
+type GetPromisedServerScriptsOptions<T, IsJson extends boolean = boolean> = {
+    mockupFunctions?: IsJson extends true ? PartialScriptTypeWithJson<T> : PartialScriptType<T>;
+    parseJson?: IsJson;
+};
+declare function getPromisedServerScripts<T extends Record<string, (...args: any[]) => any> = Omit<typeof google.script.run, 'withSuccessHandler' | 'withFailureHandler' | 'withUserObject'>>(options: GetPromisedServerScriptsOptions<T, true>): PromisedWithJson<T>;
+declare function getPromisedServerScripts<T extends Record<string, (...args: any[]) => any> = Omit<typeof google.script.run, 'withSuccessHandler' | 'withFailureHandler' | 'withUserObject'>>(options?: GetPromisedServerScriptsOptions<T, false>): Promised<T>;
 
 export { getPromisedServerScripts };
-export type { PartialScriptType, Promised };
+export type { GetPromisedServerScriptsOptions, PartialScriptType, PartialScriptTypeWithJson, Promised, PromisedWithJson };

package/dist/promise.d.mts

@@ -1,8 +1,20 @@
+import { JsonString } from './json.mjs';
+
 type Promised<T> = {
     [K in keyof T]: T[K] extends (...args: infer A) => infer R ? (...args: A) => Promise<R> : T[K];
 };
+type UnwrapJson<T> = T extends JsonString<infer U> ? U : T;
+type PromisedWithJson<T> = {
+    [K in keyof T]: T[K] extends (...args: infer A) => infer R ? (...args: A) => Promise<UnwrapJson<R>> : T[K];
+};
 type PartialScriptType<T> = Partial<Promised<T>>;
-declare const getPromisedServerScripts: <T extends Record<string, (...args: any[]) => any> = Omit<typeof google.script.run, "withSuccessHandler" | "withFailureHandler" | "withUserObject">>(mockupFunctions?: PartialScriptType<T>) => Promised<T>;
+type PartialScriptTypeWithJson<T> = Partial<PromisedWithJson<T>>;
+type GetPromisedServerScriptsOptions<T, IsJson extends boolean = boolean> = {
+    mockupFunctions?: IsJson extends true ? PartialScriptTypeWithJson<T> : PartialScriptType<T>;
+    parseJson?: IsJson;
+};
+declare function getPromisedServerScripts<T extends Record<string, (...args: any[]) => any> = Omit<typeof google.script.run, 'withSuccessHandler' | 'withFailureHandler' | 'withUserObject'>>(options: GetPromisedServerScriptsOptions<T, true>): PromisedWithJson<T>;
+declare function getPromisedServerScripts<T extends Record<string, (...args: any[]) => any> = Omit<typeof google.script.run, 'withSuccessHandler' | 'withFailureHandler' | 'withUserObject'>>(options?: GetPromisedServerScriptsOptions<T, false>): Promised<T>;
 
 export { getPromisedServerScripts };
-export type { PartialScriptType, Promised };
+export type { GetPromisedServerScriptsOptions, PartialScriptType, PartialScriptTypeWithJson, Promised, PromisedWithJson };

package/dist/promise.d.ts

@@ -1,8 +1,20 @@
+import { JsonString } from './json.js';
+
 type Promised<T> = {
     [K in keyof T]: T[K] extends (...args: infer A) => infer R ? (...args: A) => Promise<R> : T[K];
 };
+type UnwrapJson<T> = T extends JsonString<infer U> ? U : T;
+type PromisedWithJson<T> = {
+    [K in keyof T]: T[K] extends (...args: infer A) => infer R ? (...args: A) => Promise<UnwrapJson<R>> : T[K];
+};
 type PartialScriptType<T> = Partial<Promised<T>>;
-declare const getPromisedServerScripts: <T extends Record<string, (...args: any[]) => any> = Omit<typeof google.script.run, "withSuccessHandler" | "withFailureHandler" | "withUserObject">>(mockupFunctions?: PartialScriptType<T>) => Promised<T>;
+type PartialScriptTypeWithJson<T> = Partial<PromisedWithJson<T>>;
+type GetPromisedServerScriptsOptions<T, IsJson extends boolean = boolean> = {
+    mockupFunctions?: IsJson extends true ? PartialScriptTypeWithJson<T> : PartialScriptType<T>;
+    parseJson?: IsJson;
+};
+declare function getPromisedServerScripts<T extends Record<string, (...args: any[]) => any> = Omit<typeof google.script.run, 'withSuccessHandler' | 'withFailureHandler' | 'withUserObject'>>(options: GetPromisedServerScriptsOptions<T, true>): PromisedWithJson<T>;
+declare function getPromisedServerScripts<T extends Record<string, (...args: any[]) => any> = Omit<typeof google.script.run, 'withSuccessHandler' | 'withFailureHandler' | 'withUserObject'>>(options?: GetPromisedServerScriptsOptions<T, false>): Promised<T>;
 
 export { getPromisedServerScripts };
-export type { PartialScriptType, Promised };
+export type { GetPromisedServerScriptsOptions, PartialScriptType, PartialScriptTypeWithJson, Promised, PromisedWithJson };

package/dist/promise.mjs

@@ -1,4 +1,7 @@
-const getPromisedServerScripts = (mockupFunctions = {}) => {
+import { deserialize } from './json.mjs';
+
+function getPromisedServerScripts(options = {}) {
+  const { mockupFunctions = {}, parseJson = false } = options;
   return new Proxy(mockupFunctions, {
     get(target, method) {
       if (!("google" in globalThis) || !google?.script?.run) {
@@ -8,10 +11,20 @@ const getPromisedServerScripts = (mockupFunctions = {}) => {
         throw Error(`Method ${method} not found in AppsScript.`);
       }
       return (...args) => new Promise((resolve, reject) => {
-        google.script.run.withSuccessHandler(resolve).withFailureHandler(reject)[method](...args);
+        google.script.run.withSuccessHandler((res) => {
+          if (parseJson && typeof res === "string") {
+            try {
+              resolve(deserialize(res));
+            } catch {
+              resolve(res);
+            }
+          } else {
+            resolve(res);
+          }
+        }).withFailureHandler(reject)[method](...args);
       });
     }
   });
-};
+}
 
 export { getPromisedServerScripts };

package/dist/shared/{gasnuki.DfLTmLhN.cjs → gasnuki.Co0-wxJi.cjs}

@@ -72,7 +72,7 @@ const getInterfaceMethodDefinition_ = (name, node) => {
 `;
     }
   }
-  const cleanType = (t) => t.replace(/import\(.*?\)\./g, "");
+  const cleanType = (t) => t.replace(/import\(".*?"\)\.default\./g, "").replace(/import\(".*?"\)\./g, "");
   const cleanedReturnType = cleanType(returnType);
   const cleanedParameters = parameters.replace(
     /:\s*([^,;)]+)/g,
@@ -189,8 +189,85 @@ const generateAppsScriptTypes = async ({
       }
     }
   }
-  const collectSymbolsFromType = (type, foundSymbols) => {
+  const collectSymbolsFromType = (type, foundSymbols, contextNode, depth = 0, isComponent = false) => {
+    if (type.isArray()) {
+      const elementType = type.getArrayElementType();
+      if (elementType) {
+        collectSymbolsFromType(
+          elementType,
+          foundSymbols,
+          contextNode,
+          depth + 1
+        );
+      }
+    }
+    if (type.isTuple()) {
+      for (const element of type.getTupleElements()) {
+        collectSymbolsFromType(element, foundSymbols, contextNode, depth + 1);
+      }
+    }
+    for (const typeArg of type.getTypeArguments()) {
+      collectSymbolsFromType(typeArg, foundSymbols, contextNode, depth + 1);
+    }
+    for (const typeArg of type.getAliasTypeArguments()) {
+      collectSymbolsFromType(typeArg, foundSymbols, contextNode, depth + 1);
+    }
+    if (type.isUnion()) {
+      for (const unionType of type.getUnionTypes()) {
+        collectSymbolsFromType(
+          unionType,
+          foundSymbols,
+          contextNode,
+          depth + 1,
+          true
+        );
+      }
+    }
+    if (type.isIntersection()) {
+      for (const intersectionType of type.getIntersectionTypes()) {
+        collectSymbolsFromType(
+          intersectionType,
+          foundSymbols,
+          contextNode,
+          depth + 1,
+          true
+        );
+      }
+    }
+    const typeText = type.getText(contextNode);
+    const importMatches = typeText.matchAll(
+      /import\("(.*?)"\)\.([^<>[\]{}() ,;]+)/g
+    );
+    for (const match of importMatches) {
+      const absolutePath = match[1];
+      const typeName = match[2];
+      if (typeName === "default" || typeName === "__type") continue;
+      let sourceFile = project.getSourceFile(absolutePath) || project.addSourceFileAtPathIfExists(absolutePath);
+      if (!sourceFile) {
+        const extensions = [".ts", ".d.ts", ".tsx"];
+        for (const ext of extensions) {
+          sourceFile = project.getSourceFile(absolutePath + ext) || project.addSourceFileAtPathIfExists(absolutePath + ext);
+          if (sourceFile) break;
+        }
+      }
+      if (sourceFile) {
+        const exported = sourceFile.getExportedDeclarations().get(typeName);
+        let s;
+        if (exported && exported.length > 0) {
+          s = exported[0].getSymbol();
+        } else {
+          s = sourceFile.getInterface(typeName)?.getSymbol() || sourceFile.getTypeAlias(typeName)?.getSymbol() || sourceFile.getEnum(typeName)?.getSymbol() || sourceFile.getClass(typeName)?.getSymbol();
+        }
+        if (s && !foundSymbols.has(s)) {
+          foundSymbols.add(s);
+        }
+      }
+    }
     const aliasSymbol = type.getAliasSymbol();
+    let symbol = type.getSymbol();
+    if (!symbol && !aliasSymbol) {
+      symbol = type.getApparentType().getSymbol();
+    }
     if (aliasSymbol) {
       if (foundSymbols.has(aliasSymbol)) {
         return;
@@ -201,14 +278,10 @@ const generateAppsScriptTypes = async ({
         const isExternal = sourceFilePath.includes("node_modules") || !sourceFilePath.replace(/\\/g, "/").startsWith(absoluteSrcDir.replace(/\\/g, "/")) && !sourceFilePath.replace(/\\/g, "/").startsWith(path__namespace.join(projectPath, srcDir).replace(/\\/g, "/"));
         if (isExternal) {
           foundSymbols.add(aliasSymbol);
-          for (const typeArg of type.getAliasTypeArguments()) {
-            collectSymbolsFromType(typeArg, foundSymbols);
-          }
           return;
         }
       }
     }
-    const symbol = type.getSymbol();
     let shouldTraverseProperties = true;
     if (symbol) {
       if (foundSymbols.has(symbol)) {
@@ -222,42 +295,68 @@ const generateAppsScriptTypes = async ({
             path__namespace.join(projectPath, srcDir).replace(/\\/g, "/")
           );
           if (isExternal) {
-            shouldTraverseProperties = false;
+            const isAnonymous = declarations.every(
+              (d) => d.getKind() === tsMorph.SyntaxKind.TypeLiteral || d.getKind() === tsMorph.SyntaxKind.ObjectLiteralExpression
+            );
+            if (!isComponent && !isAnonymous) {
+              shouldTraverseProperties = false;
+            }
           }
         }
       }
     }
-    if (shouldTraverseProperties && type.isObject()) {
-      for (const prop of type.getProperties()) {
-        const propDecl = prop.getDeclarations()[0];
-        if (propDecl) {
-          const compilerNode = propDecl.compilerNode;
-          if (
-            // @ts-expect-error - avoiding full type checks for perf, checking kind directly
-            compilerNode.name && // @ts-expect-error - avoiding full type checks for perf, checking kind directly
-            compilerNode.name.kind === tsMorph.SyntaxKind.ComputedPropertyName
-          ) {
-            const expression = propDecl.getNameNode().getExpression();
-            const symbol2 = expression.getSymbol();
-            if (symbol2 && !foundSymbols.has(symbol2)) {
-              foundSymbols.add(symbol2);
+    if (shouldTraverseProperties) {
+      const props = /* @__PURE__ */ new Set([
+        ...type.getProperties(),
+        ...type.getApparentProperties()
+      ]);
+      for (const prop of props) {
+        let propType;
+        if (contextNode) {
+          try {
+            propType = prop.getTypeAtLocation(contextNode);
+          } catch {
+          }
+        }
+        if (!propType || propType.getText() === "any") {
+          const propDecls = prop.getDeclarations();
+          if (propDecls.length > 0) {
+            propType = propDecls[0].getType();
+          }
+        }
+        if ((!propType || propType.getText() === "any") && prop.getAliasedSymbol()) {
+          const aliased = prop.getAliasedSymbol();
+          if (aliased) {
+            const decl = aliased.getValueDeclaration() || aliased.getDeclarations()[0];
+            if (decl) {
+              propType = decl.getType();
             }
           }
-          collectSymbolsFromType(propDecl.getType(), foundSymbols);
         }
-      }
-    }
-    for (const typeArg of type.getTypeArguments()) {
-      collectSymbolsFromType(typeArg, foundSymbols);
-    }
-    if (type.isUnion()) {
-      for (const unionType of type.getUnionTypes()) {
-        collectSymbolsFromType(unionType, foundSymbols);
-      }
-    }
-    if (type.isIntersection()) {
-      for (const intersectionType of type.getIntersectionTypes()) {
-        collectSymbolsFromType(intersectionType, foundSymbols);
+        if (propType) {
+          const propDecls = prop.getDeclarations();
+          if (propDecls.length > 0) {
+            const propDecl = propDecls[0];
+            const compilerNode = propDecl.compilerNode;
+            if (
+              // @ts-expect-error - checking kind directly for perf
+              compilerNode.name && // @ts-expect-error - checking kind directly for perf
+              compilerNode.name.kind === tsMorph.SyntaxKind.ComputedPropertyName
+            ) {
+              const expression = propDecl.getNameNode().getExpression();
+              const s = expression.getSymbol();
+              if (s && !foundSymbols.has(s)) {
+                foundSymbols.add(s);
+              }
+            }
+          }
+          collectSymbolsFromType(
+            propType,
+            foundSymbols,
+            contextNode,
+            depth + 1
+          );
+        }
       }
     }
   };
@@ -268,14 +367,14 @@ const generateAppsScriptTypes = async ({
       const func = decl.getKind() === tsMorph.SyntaxKind.FunctionDeclaration ? decl : decl.getInitializer();
       const parameters = func.getParameters();
       for (const param of parameters) {
-        collectSymbolsFromType(param.getType(), functionSignatureSymbols);
-        collectSymbolsFromType(param.getType(), symbolsToProcess);
+        collectSymbolsFromType(param.getType(), functionSignatureSymbols, func);
+        collectSymbolsFromType(param.getType(), symbolsToProcess, func);
       }
       const returnType = func.getReturnType();
-      collectSymbolsFromType(returnType, functionSignatureSymbols);
-      collectSymbolsFromType(returnType, symbolsToProcess);
+      collectSymbolsFromType(returnType, functionSignatureSymbols, func);
+      collectSymbolsFromType(returnType, symbolsToProcess, func);
     } else if (decl.getKind() === tsMorph.SyntaxKind.InterfaceDeclaration || decl.getKind() === tsMorph.SyntaxKind.TypeAliasDeclaration) {
-      collectSymbolsFromType(decl.getType(), symbolsToProcess);
+      collectSymbolsFromType(decl.getType(), symbolsToProcess, decl);
     }
   }
   const importsMap = /* @__PURE__ */ new Map();
@@ -424,7 +523,9 @@ ${text}`;
   if (sortedModulePaths.length > 0) {
     const importStatements = sortedModulePaths.map((modulePath) => {
       const imports = [...importsMap.get(modulePath) ?? []].sort().filter((importName) => {
-        const regex = new RegExp(`\\b${importName}\\b`);
+        const regex = new RegExp(
+          `(?:import\\(".*?"\\)\\.|\\b)${importName}\\b`
+        );
         return regex.test(bodyContent);
       });
       if (imports.length === 0) {

package/dist/shared/{gasnuki.SJQVcSIQ.mjs → gasnuki.DePJgSg9.mjs}

@@ -54,7 +54,7 @@ const getInterfaceMethodDefinition_ = (name, node) => {
 `;
     }
   }
-  const cleanType = (t) => t.replace(/import\(.*?\)\./g, "");
+  const cleanType = (t) => t.replace(/import\(".*?"\)\.default\./g, "").replace(/import\(".*?"\)\./g, "");
   const cleanedReturnType = cleanType(returnType);
   const cleanedParameters = parameters.replace(
     /:\s*([^,;)]+)/g,
@@ -171,8 +171,85 @@ const generateAppsScriptTypes = async ({
       }
     }
   }
-  const collectSymbolsFromType = (type, foundSymbols) => {
+  const collectSymbolsFromType = (type, foundSymbols, contextNode, depth = 0, isComponent = false) => {
+    if (type.isArray()) {
+      const elementType = type.getArrayElementType();
+      if (elementType) {
+        collectSymbolsFromType(
+          elementType,
+          foundSymbols,
+          contextNode,
+          depth + 1
+        );
+      }
+    }
+    if (type.isTuple()) {
+      for (const element of type.getTupleElements()) {
+        collectSymbolsFromType(element, foundSymbols, contextNode, depth + 1);
+      }
+    }
+    for (const typeArg of type.getTypeArguments()) {
+      collectSymbolsFromType(typeArg, foundSymbols, contextNode, depth + 1);
+    }
+    for (const typeArg of type.getAliasTypeArguments()) {
+      collectSymbolsFromType(typeArg, foundSymbols, contextNode, depth + 1);
+    }
+    if (type.isUnion()) {
+      for (const unionType of type.getUnionTypes()) {
+        collectSymbolsFromType(
+          unionType,
+          foundSymbols,
+          contextNode,
+          depth + 1,
+          true
+        );
+      }
+    }
+    if (type.isIntersection()) {
+      for (const intersectionType of type.getIntersectionTypes()) {
+        collectSymbolsFromType(
+          intersectionType,
+          foundSymbols,
+          contextNode,
+          depth + 1,
+          true
+        );
+      }
+    }
+    const typeText = type.getText(contextNode);
+    const importMatches = typeText.matchAll(
+      /import\("(.*?)"\)\.([^<>[\]{}() ,;]+)/g
+    );
+    for (const match of importMatches) {
+      const absolutePath = match[1];
+      const typeName = match[2];
+      if (typeName === "default" || typeName === "__type") continue;
+      let sourceFile = project.getSourceFile(absolutePath) || project.addSourceFileAtPathIfExists(absolutePath);
+      if (!sourceFile) {
+        const extensions = [".ts", ".d.ts", ".tsx"];
+        for (const ext of extensions) {
+          sourceFile = project.getSourceFile(absolutePath + ext) || project.addSourceFileAtPathIfExists(absolutePath + ext);
+          if (sourceFile) break;
+        }
+      }
+      if (sourceFile) {
+        const exported = sourceFile.getExportedDeclarations().get(typeName);
+        let s;
+        if (exported && exported.length > 0) {
+          s = exported[0].getSymbol();
+        } else {
+          s = sourceFile.getInterface(typeName)?.getSymbol() || sourceFile.getTypeAlias(typeName)?.getSymbol() || sourceFile.getEnum(typeName)?.getSymbol() || sourceFile.getClass(typeName)?.getSymbol();
+        }
+        if (s && !foundSymbols.has(s)) {
+          foundSymbols.add(s);
+        }
+      }
+    }
     const aliasSymbol = type.getAliasSymbol();
+    let symbol = type.getSymbol();
+    if (!symbol && !aliasSymbol) {
+      symbol = type.getApparentType().getSymbol();
+    }
     if (aliasSymbol) {
       if (foundSymbols.has(aliasSymbol)) {
         return;
@@ -183,14 +260,10 @@ const generateAppsScriptTypes = async ({
         const isExternal = sourceFilePath.includes("node_modules") || !sourceFilePath.replace(/\\/g, "/").startsWith(absoluteSrcDir.replace(/\\/g, "/")) && !sourceFilePath.replace(/\\/g, "/").startsWith(path.join(projectPath, srcDir).replace(/\\/g, "/"));
         if (isExternal) {
           foundSymbols.add(aliasSymbol);
-          for (const typeArg of type.getAliasTypeArguments()) {
-            collectSymbolsFromType(typeArg, foundSymbols);
-          }
           return;
         }
       }
     }
-    const symbol = type.getSymbol();
     let shouldTraverseProperties = true;
     if (symbol) {
       if (foundSymbols.has(symbol)) {
@@ -204,42 +277,68 @@ const generateAppsScriptTypes = async ({
             path.join(projectPath, srcDir).replace(/\\/g, "/")
           );
           if (isExternal) {
-            shouldTraverseProperties = false;
+            const isAnonymous = declarations.every(
+              (d) => d.getKind() === SyntaxKind.TypeLiteral || d.getKind() === SyntaxKind.ObjectLiteralExpression
+            );
+            if (!isComponent && !isAnonymous) {
+              shouldTraverseProperties = false;
+            }
           }
         }
       }
     }
-    if (shouldTraverseProperties && type.isObject()) {
-      for (const prop of type.getProperties()) {
-        const propDecl = prop.getDeclarations()[0];
-        if (propDecl) {
-          const compilerNode = propDecl.compilerNode;
-          if (
-            // @ts-expect-error - avoiding full type checks for perf, checking kind directly
-            compilerNode.name && // @ts-expect-error - avoiding full type checks for perf, checking kind directly
-            compilerNode.name.kind === SyntaxKind.ComputedPropertyName
-          ) {
-            const expression = propDecl.getNameNode().getExpression();
-            const symbol2 = expression.getSymbol();
-            if (symbol2 && !foundSymbols.has(symbol2)) {
-              foundSymbols.add(symbol2);
+    if (shouldTraverseProperties) {
+      const props = /* @__PURE__ */ new Set([
+        ...type.getProperties(),
+        ...type.getApparentProperties()
+      ]);
+      for (const prop of props) {
+        let propType;
+        if (contextNode) {
+          try {
+            propType = prop.getTypeAtLocation(contextNode);
+          } catch {
+          }
+        }
+        if (!propType || propType.getText() === "any") {
+          const propDecls = prop.getDeclarations();
+          if (propDecls.length > 0) {
+            propType = propDecls[0].getType();
+          }
+        }
+        if ((!propType || propType.getText() === "any") && prop.getAliasedSymbol()) {
+          const aliased = prop.getAliasedSymbol();
+          if (aliased) {
+            const decl = aliased.getValueDeclaration() || aliased.getDeclarations()[0];
+            if (decl) {
+              propType = decl.getType();
             }
           }
-          collectSymbolsFromType(propDecl.getType(), foundSymbols);
         }
-      }
-    }
-    for (const typeArg of type.getTypeArguments()) {
-      collectSymbolsFromType(typeArg, foundSymbols);
-    }
-    if (type.isUnion()) {
-      for (const unionType of type.getUnionTypes()) {
-        collectSymbolsFromType(unionType, foundSymbols);
-      }
-    }
-    if (type.isIntersection()) {
-      for (const intersectionType of type.getIntersectionTypes()) {
-        collectSymbolsFromType(intersectionType, foundSymbols);
+        if (propType) {
+          const propDecls = prop.getDeclarations();
+          if (propDecls.length > 0) {
+            const propDecl = propDecls[0];
+            const compilerNode = propDecl.compilerNode;
+            if (
+              // @ts-expect-error - checking kind directly for perf
+              compilerNode.name && // @ts-expect-error - checking kind directly for perf
+              compilerNode.name.kind === SyntaxKind.ComputedPropertyName
+            ) {
+              const expression = propDecl.getNameNode().getExpression();
+              const s = expression.getSymbol();
+              if (s && !foundSymbols.has(s)) {
+                foundSymbols.add(s);
+              }
+            }
+          }
+          collectSymbolsFromType(
+            propType,
+            foundSymbols,
+            contextNode,
+            depth + 1
+          );
+        }
       }
     }
   };
@@ -250,14 +349,14 @@ const generateAppsScriptTypes = async ({
       const func = decl.getKind() === SyntaxKind.FunctionDeclaration ? decl : decl.getInitializer();
       const parameters = func.getParameters();
       for (const param of parameters) {
-        collectSymbolsFromType(param.getType(), functionSignatureSymbols);
-        collectSymbolsFromType(param.getType(), symbolsToProcess);
+        collectSymbolsFromType(param.getType(), functionSignatureSymbols, func);
+        collectSymbolsFromType(param.getType(), symbolsToProcess, func);
       }
       const returnType = func.getReturnType();
-      collectSymbolsFromType(returnType, functionSignatureSymbols);
-      collectSymbolsFromType(returnType, symbolsToProcess);
+      collectSymbolsFromType(returnType, functionSignatureSymbols, func);
+      collectSymbolsFromType(returnType, symbolsToProcess, func);
     } else if (decl.getKind() === SyntaxKind.InterfaceDeclaration || decl.getKind() === SyntaxKind.TypeAliasDeclaration) {
-      collectSymbolsFromType(decl.getType(), symbolsToProcess);
+      collectSymbolsFromType(decl.getType(), symbolsToProcess, decl);
     }
   }
   const importsMap = /* @__PURE__ */ new Map();
@@ -406,7 +505,9 @@ ${text}`;
   if (sortedModulePaths.length > 0) {
     const importStatements = sortedModulePaths.map((modulePath) => {
       const imports = [...importsMap.get(modulePath) ?? []].sort().filter((importName) => {
-        const regex = new RegExp(`\\b${importName}\\b`);
+        const regex = new RegExp(
+          `(?:import\\(".*?"\\)\\.|\\b)${importName}\\b`
+        );
         return regex.test(bodyContent);
       });
       if (imports.length === 0) {

package/dist/vite.cjs

@@ -2,7 +2,7 @@
 
 const path = require('node:path');
 const consola = require('consola');
-const config = require('./shared/gasnuki.DfLTmLhN.cjs');
+const config = require('./shared/gasnuki.Co0-wxJi.cjs');
 require('node:crypto');
 require('node:fs');
 require('ts-morph');

package/dist/vite.mjs

@@ -1,6 +1,6 @@
 import * as path from 'node:path';
 import { consola } from 'consola';
-import { l as loadConfig, g as generateAppsScriptTypes } from './shared/gasnuki.SJQVcSIQ.mjs';
+import { l as loadConfig, g as generateAppsScriptTypes } from './shared/gasnuki.DePJgSg9.mjs';
 import 'node:crypto';
 import 'node:fs';
 import 'ts-morph';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ciderjs/gasnuki",
-  "version": "0.4.0",
+  "version": "0.5.0",
   "description": "Type definitions and utilities for Google Apps Script client-side API",
   "main": "dist/index.mjs",
   "types": "dist/index.d.ts",
@@ -22,6 +22,11 @@
       "types": "./dist/vite.d.ts",
       "import": "./dist/vite.mjs",
       "require": "./dist/vite.cjs"
+    },
+    "./json": {
+      "types": "./dist/json.d.ts",
+      "import": "./dist/json.mjs",
+      "require": "./dist/json.cjs"
     }
   },
   "scripts": {
@@ -45,7 +50,7 @@
     "@google/clasp"
   ],
   "author": "ciderjs/luth",
-  "license": "ISC",
+  "license": "MIT",
   "repository": {
     "type": "git",
     "url": "git+ssh://git@github.com:luthpg/gasnuki.git"
@@ -62,12 +67,12 @@
     "ts-morph": "^27.0.2"
   },
   "devDependencies": {
-    "@biomejs/biome": "^2.3.10",
-    "@types/node": "^25.0.3",
+    "@biomejs/biome": "^2.3.11",
+    "@types/node": "^25.0.5",
     "@vitest/coverage-v8": "4.0.16",
     "typescript": "^5.9.3",
     "unbuild": "^3.6.1",
-    "vite": "^7.3.0",
+    "vite": "^7.3.1",
     "vitest": "4.0.16"
   },
   "peerDependencies": {