@ciderjs/gasnuki 0.2.8 → 0.2.9

package/dist/cli.cjs

@@ -0,0 +1,77 @@
+#! /usr/bin/env  node
+'use strict';
+
+const path = require('node:path');
+const commander = require('commander');
+const index = require('./shared/gasnuki.93G9yyCy.cjs');
+require('chokidar');
+require('consola');
+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 version = "0.2.9";
+
+const parseArgs = async (command) => {
+  const cliOpts = command.opts();
+  const fileConfig = await index.loadConfig(path__namespace.resolve(cliOpts.project));
+  const defaultOpts = {};
+  for (const option of command.options) {
+    const key = option.attributeName();
+    defaultOpts[key] = option.defaultValue;
+  }
+  const explicitCliOpts = {};
+  for (const option of command.options) {
+    const key = option.attributeName();
+    if (command.getOptionValueSource(key) === "cli") {
+      explicitCliOpts[key] = cliOpts[key];
+    }
+  }
+  const finalOptions = {
+    ...defaultOpts,
+    ...fileConfig,
+    ...explicitCliOpts,
+    project: cliOpts.project,
+    watch: cliOpts.watch
+  };
+  await index.generateTypes(finalOptions);
+};
+const cli = async () => {
+  const program = new commander.Command();
+  program.name("gasnuki").description(
+    "Generate type definitions and utilities for Google Apps Script client-side API"
+  );
+  program.version(version, "-v, --version");
+  program.action(async (_param, command) => await parseArgs(command)).option(
+    "-p, --project <project>",
+    "Project root directory path",
+    process.cwd().replace(/\\/g, "/")
+  ).option(
+    "-s, --srcDir <dir>",
+    "Source directory name (relative to project root)",
+    "server"
+  ).option(
+    "-o, --outDir <dir>",
+    "Output directory name (relative to project root)",
+    "types"
+  ).option("-f, --outputFile <file>", "Output file name", "appsscript.ts").option("-w, --watch", "Watch for changes and re-generate types", false);
+  await program.parseAsync(process.argv);
+};
+cli();
+
+exports.cli = cli;
+exports.parseArgs = parseArgs;

package/dist/cli.d.cts

@@ -0,0 +1,7 @@
+
+import { Command } from 'commander';
+
+declare const parseArgs: (command: Command) => Promise<void>;
+declare const cli: () => Promise<void>;
+
+export { cli, parseArgs };

package/dist/cli.d.mts

@@ -0,0 +1,7 @@
+
+import { Command } from 'commander';
+
+declare const parseArgs: (command: Command) => Promise<void>;
+declare const cli: () => Promise<void>;
+
+export { cli, parseArgs };

package/dist/cli.d.ts

@@ -0,0 +1,7 @@
+
+import { Command } from 'commander';
+
+declare const parseArgs: (command: Command) => Promise<void>;
+declare const cli: () => Promise<void>;
+
+export { cli, parseArgs };

package/dist/cli.mjs

@@ -0,0 +1,60 @@
+#! /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 'chokidar';
+import 'consola';
+import 'node:fs';
+import 'ts-morph';
+import 'jiti';
+
+const version = "0.2.9";
+
+const parseArgs = async (command) => {
+  const cliOpts = command.opts();
+  const fileConfig = await loadConfig(path.resolve(cliOpts.project));
+  const defaultOpts = {};
+  for (const option of command.options) {
+    const key = option.attributeName();
+    defaultOpts[key] = option.defaultValue;
+  }
+  const explicitCliOpts = {};
+  for (const option of command.options) {
+    const key = option.attributeName();
+    if (command.getOptionValueSource(key) === "cli") {
+      explicitCliOpts[key] = cliOpts[key];
+    }
+  }
+  const finalOptions = {
+    ...defaultOpts,
+    ...fileConfig,
+    ...explicitCliOpts,
+    project: cliOpts.project,
+    watch: cliOpts.watch
+  };
+  await generateTypes(finalOptions);
+};
+const cli = async () => {
+  const program = new Command();
+  program.name("gasnuki").description(
+    "Generate type definitions and utilities for Google Apps Script client-side API"
+  );
+  program.version(version, "-v, --version");
+  program.action(async (_param, command) => await parseArgs(command)).option(
+    "-p, --project <project>",
+    "Project root directory path",
+    process.cwd().replace(/\\/g, "/")
+  ).option(
+    "-s, --srcDir <dir>",
+    "Source directory name (relative to project root)",
+    "server"
+  ).option(
+    "-o, --outDir <dir>",
+    "Output directory name (relative to project root)",
+    "types"
+  ).option("-f, --outputFile <file>", "Output file name", "appsscript.ts").option("-w, --watch", "Watch for changes and re-generate types", false);
+  await program.parseAsync(process.argv);
+};
+cli();
+
+export { cli, parseArgs };

package/dist/index.cjs

@@ -0,0 +1,14 @@
+'use strict';
+
+require('node:path');
+require('chokidar');
+require('consola');
+const index = require('./shared/gasnuki.93G9yyCy.cjs');
+require('node:fs');
+require('ts-morph');
+require('jiti');
+
+
+
+exports.defineConfig = index.defineConfig;
+exports.generateTypes = index.generateTypes;

package/dist/index.d.cts

@@ -0,0 +1,23 @@
+/**
+ * User-defined configuration for gasnuki.
+ * `project` and `watch` options are excluded as they are runtime flags.
+ */
+type UserConfig = Partial<Omit<GenerateOptions, 'watch' | 'project'>>;
+/**
+ * A helper function to define the gasnuki configuration with type safety.
+ * @param config The configuration object.
+ * @returns The configuration object.
+ */
+declare function defineConfig(config: UserConfig): UserConfig;
+
+interface GenerateOptions {
+    project: string;
+    srcDir: string;
+    outDir: string;
+    outputFile: string;
+    watch: boolean;
+}
+declare const generateTypes: ({ project, srcDir, outDir, outputFile, watch, }: GenerateOptions) => Promise<void>;
+
+export { defineConfig, generateTypes };
+export type { GenerateOptions, UserConfig };

package/dist/index.d.mts

@@ -0,0 +1,23 @@
+/**
+ * User-defined configuration for gasnuki.
+ * `project` and `watch` options are excluded as they are runtime flags.
+ */
+type UserConfig = Partial<Omit<GenerateOptions, 'watch' | 'project'>>;
+/**
+ * A helper function to define the gasnuki configuration with type safety.
+ * @param config The configuration object.
+ * @returns The configuration object.
+ */
+declare function defineConfig(config: UserConfig): UserConfig;
+
+interface GenerateOptions {
+    project: string;
+    srcDir: string;
+    outDir: string;
+    outputFile: string;
+    watch: boolean;
+}
+declare const generateTypes: ({ project, srcDir, outDir, outputFile, watch, }: GenerateOptions) => Promise<void>;
+
+export { defineConfig, generateTypes };
+export type { GenerateOptions, UserConfig };

package/dist/index.d.ts

@@ -0,0 +1,23 @@
+/**
+ * User-defined configuration for gasnuki.
+ * `project` and `watch` options are excluded as they are runtime flags.
+ */
+type UserConfig = Partial<Omit<GenerateOptions, 'watch' | 'project'>>;
+/**
+ * A helper function to define the gasnuki configuration with type safety.
+ * @param config The configuration object.
+ * @returns The configuration object.
+ */
+declare function defineConfig(config: UserConfig): UserConfig;
+
+interface GenerateOptions {
+    project: string;
+    srcDir: string;
+    outDir: string;
+    outputFile: string;
+    watch: boolean;
+}
+declare const generateTypes: ({ project, srcDir, outDir, outputFile, watch, }: GenerateOptions) => Promise<void>;
+
+export { defineConfig, generateTypes };
+export type { GenerateOptions, UserConfig };

package/dist/index.mjs

@@ -0,0 +1,7 @@
+import 'node:path';
+import 'chokidar';
+import 'consola';
+export { d as defineConfig, g as generateTypes } from './shared/gasnuki.CS974pL-.mjs';
+import 'node:fs';
+import 'ts-morph';
+import 'jiti';

package/dist/promise.cjs

@@ -0,0 +1,19 @@
+'use strict';
+
+const getPromisedServerScripts = (mockupFunctions = {}) => {
+  return new Proxy(mockupFunctions, {
+    get(target, method) {
+      if (!("google" in globalThis) || !google?.script?.run) {
+        return target[method];
+      }
+      if (!(method in google.script.run)) {
+        throw Error(`Method ${method} not found in AppsScript.`);
+      }
+      return (...args) => new Promise((resolve, reject) => {
+        google.script.run.withSuccessHandler(resolve).withFailureHandler(reject)[method](...args);
+      });
+    }
+  });
+};
+
+exports.getPromisedServerScripts = getPromisedServerScripts;

package/dist/promise.d.cts

@@ -0,0 +1,8 @@
+type Promised<T> = {
+    [K in keyof T]: T[K] extends (...args: infer A) => infer R ? (...args: A) => Promise<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>;
+
+export { getPromisedServerScripts };
+export type { PartialScriptType, Promised };

package/dist/promise.d.mts

@@ -0,0 +1,8 @@
+type Promised<T> = {
+    [K in keyof T]: T[K] extends (...args: infer A) => infer R ? (...args: A) => Promise<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>;
+
+export { getPromisedServerScripts };
+export type { PartialScriptType, Promised };

package/dist/promise.d.ts

@@ -0,0 +1,8 @@
+type Promised<T> = {
+    [K in keyof T]: T[K] extends (...args: infer A) => infer R ? (...args: A) => Promise<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>;
+
+export { getPromisedServerScripts };
+export type { PartialScriptType, Promised };

package/dist/promise.mjs

@@ -0,0 +1,17 @@
+const getPromisedServerScripts = (mockupFunctions = {}) => {
+  return new Proxy(mockupFunctions, {
+    get(target, method) {
+      if (!("google" in globalThis) || !google?.script?.run) {
+        return target[method];
+      }
+      if (!(method in google.script.run)) {
+        throw Error(`Method ${method} not found in AppsScript.`);
+      }
+      return (...args) => new Promise((resolve, reject) => {
+        google.script.run.withSuccessHandler(resolve).withFailureHandler(reject)[method](...args);
+      });
+    }
+  });
+};
+
+export { getPromisedServerScripts };

package/dist/shared/gasnuki.93G9yyCy.cjs

@@ -0,0 +1,409 @@
+'use strict';
+
+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');
+
+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);
+const fs__namespace = /*#__PURE__*/_interopNamespaceCompat(fs);
+
+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";
+
+const getInterfaceMethodDefinition_ = (name, node) => {
+  const typeParameters = node.getTypeParameters?.() ?? [];
+  const typeParamsString = typeParameters.length > 0 ? `<${typeParameters.map((tp) => tp.getText()).join(", ")}>` : "";
+  const parameters = node.getParameters().map((param) => {
+    const paramName = param.getName();
+    const type = param.getTypeNode()?.getText() ?? param.getType().getText(node) ?? "any";
+    const questionToken = param.hasQuestionToken() ? "?" : "";
+    return `${paramName}${questionToken}: ${type}`;
+  }).join(", ");
+  const returnTypeNode = node.getReturnTypeNode();
+  let returnType;
+  if (returnTypeNode != null) {
+    returnType = returnTypeNode.getText();
+  } else {
+    const inferredReturnType = node.getReturnType();
+    if (inferredReturnType.isVoid()) {
+      returnType = "void";
+    } else {
+      returnType = inferredReturnType.getText(node);
+    }
+  }
+  let jsDocString = "";
+  const jsDocOwner = "getJsDocs" in node ? node : "getParentOrThrow" in node && // @ts-expect-error variable declaration
+  node.getParentOrThrow().getKind() === tsMorph.SyntaxKind.VariableDeclaration ? (
+    // @ts-expect-error variable declaration
+    node.getParentOrThrow()
+  ) : null;
+  if (jsDocOwner != null) {
+    const jsDocs = "getJsDocs" in jsDocOwner ? jsDocOwner.getJsDocs() : [];
+    if (jsDocs.length > 0) {
+      const firstDoc = jsDocs[0];
+      jsDocString = `${firstDoc.getFullText().trim()}
+`;
+    }
+  }
+  return `${jsDocString}${name}${typeParamsString}(${parameters}): ${returnType};`;
+};
+const SIMPLE_TRIGGER_FUNCTION_NAMES = [
+  "onOpen",
+  "onEdit",
+  "onInstall",
+  "onSelectionChange",
+  "doGet",
+  "doPost"
+];
+const generateAppsScriptTypes = async ({
+  project: projectPath,
+  srcDir,
+  outDir,
+  outputFile
+}) => {
+  const absoluteSrcDir = path__namespace.resolve(projectPath, srcDir);
+  const absoluteOutDir = path__namespace.resolve(projectPath, outDir);
+  const absoluteOutputFile = path__namespace.resolve(absoluteOutDir, outputFile);
+  consola.consola.info("Starting AppsScript type generation with gasnuki...");
+  consola.consola.info(`  AppsScript Source Directory: ${absoluteSrcDir}`);
+  consola.consola.info(`  Output File: ${absoluteOutputFile}`);
+  const project = new tsMorph.Project({
+    tsConfigFilePath: path__namespace.resolve(projectPath, "tsconfig.json"),
+    skipAddingFilesFromTsConfig: true
+  });
+  const sourceFilesPattern = path__namespace.join(absoluteSrcDir, "**/*.ts").replace(/\\/g, "/");
+  const testFilesPattern = `!${path__namespace.join(absoluteSrcDir, "**/*.{test,spec}.ts").replace(/\\/g, "/")}`;
+  project.addSourceFilesAtPaths([sourceFilesPattern, testFilesPattern]);
+  const sourceFiles = project.getSourceFiles();
+  consola.consola.info(`Found ${sourceFiles.length} source file(s).`);
+  const methodDefinitions = [];
+  const exportedDeclarations = [];
+  const exportedDeclarationNames = /* @__PURE__ */ new Set();
+  const exportedFunctions = [];
+  for (const sourceFile of sourceFiles) {
+    for (const iface of sourceFile.getInterfaces()) {
+      if (iface.isExported() && !iface.getName()?.endsWith("_")) {
+        exportedDeclarations.push(iface);
+        exportedDeclarationNames.add(iface.getName());
+      }
+    }
+    for (const typeAlias of sourceFile.getTypeAliases()) {
+      if (typeAlias.isExported() && !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)) {
+        exportedDeclarations.push(func);
+        exportedDeclarationNames.add(name);
+        methodDefinitions.push(getInterfaceMethodDefinition_(name, func));
+        exportedFunctions.push(func);
+      }
+    }
+    for (const varStmt of sourceFile.getVariableStatements()) {
+      if (!varStmt.isExported()) continue;
+      for (const varDecl of varStmt.getDeclarations()) {
+        const name = varDecl.getName();
+        const initializer = varDecl.getInitializer();
+        if (!name.endsWith("_") && !SIMPLE_TRIGGER_FUNCTION_NAMES.includes(name) && initializer && (initializer.getKind() === tsMorph.SyntaxKind.ArrowFunction || initializer.getKind() === tsMorph.SyntaxKind.FunctionExpression)) {
+          const funcExpr = initializer;
+          exportedDeclarations.push(varDecl);
+          exportedDeclarationNames.add(name);
+          methodDefinitions.push(getInterfaceMethodDefinition_(name, funcExpr));
+          exportedFunctions.push(funcExpr);
+        }
+      }
+    }
+  }
+  const collectSymbolsFromType = (type, foundSymbols) => {
+    const symbol = type.getAliasSymbol() ?? type.getSymbol();
+    if (symbol && !foundSymbols.has(symbol)) {
+      foundSymbols.add(symbol);
+      if (type.isObject()) {
+        for (const prop of type.getProperties()) {
+          const propDecl = prop.getDeclarations()[0];
+          if (propDecl) {
+            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);
+      }
+    }
+  };
+  const returnValueSymbols = /* @__PURE__ */ new Set();
+  for (const func of exportedFunctions) {
+    collectSymbolsFromType(func.getReturnType(), returnValueSymbols);
+  }
+  const symbolsToProcess = /* @__PURE__ */ new Set();
+  for (const decl of exportedDeclarations) {
+    if (decl.getKind() === tsMorph.SyntaxKind.FunctionDeclaration || decl.getKind() === tsMorph.SyntaxKind.VariableDeclaration && (decl.getInitializer()?.getKind() === tsMorph.SyntaxKind.ArrowFunction || decl.getInitializer()?.getKind() === tsMorph.SyntaxKind.FunctionExpression)) {
+      const func = decl.getKind() === tsMorph.SyntaxKind.FunctionDeclaration ? decl : decl.getInitializer();
+      const parameters = func.getParameters();
+      for (const param of parameters) {
+        const typeRefs = param.getDescendantsOfKind(tsMorph.SyntaxKind.TypeReference);
+        for (const typeRef of typeRefs) {
+          const symbol = typeRef.getType().getAliasSymbol() ?? typeRef.getType().getSymbol();
+          if (symbol) symbolsToProcess.add(symbol);
+        }
+      }
+      const returnTypeNode = func.getReturnTypeNode();
+      if (returnTypeNode) {
+        const typeRefs = returnTypeNode.getDescendantsOfKind(
+          tsMorph.SyntaxKind.TypeReference
+        );
+        for (const typeRef of typeRefs) {
+          const symbol = typeRef.getType().getAliasSymbol() ?? typeRef.getType().getSymbol();
+          if (symbol) symbolsToProcess.add(symbol);
+        }
+      }
+    } else if (decl.getKind() === tsMorph.SyntaxKind.InterfaceDeclaration || decl.getKind() === tsMorph.SyntaxKind.TypeAliasDeclaration) {
+      const typeRefs = decl.getDescendantsOfKind(tsMorph.SyntaxKind.TypeReference);
+      for (const typeRef of typeRefs) {
+        const symbol = typeRef.getType().getAliasSymbol() ?? typeRef.getType().getSymbol();
+        if (symbol) symbolsToProcess.add(symbol);
+      }
+    }
+  }
+  const importsMap = /* @__PURE__ */ new Map();
+  const inlineDefinitions = /* @__PURE__ */ new Map();
+  const processedSymbols = /* @__PURE__ */ new Set();
+  while (symbolsToProcess.size > 0) {
+    const symbol = symbolsToProcess.values().next().value;
+    if (!symbol) continue;
+    symbolsToProcess.delete(symbol);
+    const symbolName = symbol.getName();
+    if (processedSymbols.has(symbolName) || exportedDeclarationNames.has(symbolName) || symbolName === "__type") {
+      continue;
+    }
+    const symbolFlags = symbol.getFlags();
+    if (symbolFlags & tsMorph.SymbolFlags.TypeParameter) {
+      continue;
+    }
+    const declaration = symbol.getDeclarations()[0];
+    if (!declaration) {
+      continue;
+    }
+    const sourceFile = declaration.getSourceFile();
+    if (sourceFile.getFilePath().includes("node_modules")) {
+      continue;
+    }
+    processedSymbols.add(symbolName);
+    const isLocalDefinition = declaration.getParent()?.getKind() !== tsMorph.SyntaxKind.SourceFile;
+    if (isLocalDefinition) {
+      if (returnValueSymbols.has(symbol)) {
+        const declText = declaration.getText();
+        inlineDefinitions.set(symbolName, declText);
+        const tempSourceFile = project.createSourceFile(
+          `__temp_${symbolName}.ts`,
+          declText
+        );
+        for (const descendant of tempSourceFile.getDescendantsOfKind(
+          tsMorph.SyntaxKind.TypeReference
+        )) {
+          const newSymbol = descendant.getType().getAliasSymbol() ?? descendant.getType().getSymbol();
+          if (newSymbol) {
+            symbolsToProcess.add(newSymbol);
+          }
+        }
+        tempSourceFile.delete();
+      }
+    } else {
+      let modulePath = path__namespace.relative(absoluteOutDir, sourceFile.getFilePath()).replace(/\\/g, "/");
+      modulePath = modulePath.replace(/\.(d\.)?ts$/, "");
+      if (modulePath.endsWith("/index")) {
+        modulePath = modulePath.slice(0, -6);
+      }
+      if (modulePath === "index" || modulePath === "") {
+        modulePath = ".";
+      }
+      if (!modulePath.startsWith(".")) {
+        modulePath = `./${modulePath}`;
+      }
+      if (!importsMap.has(modulePath)) {
+        importsMap.set(modulePath, /* @__PURE__ */ new Set());
+      }
+      importsMap.get(modulePath)?.add(symbolName);
+    }
+  }
+  if (!fs__namespace.existsSync(absoluteOutDir)) {
+    fs__namespace.mkdirSync(absoluteOutDir, { recursive: true });
+    consola.consola.info(`Created output directory: ${absoluteOutDir}`);
+  }
+  const generatorName = "gasnuki";
+  let outputContent = `// Auto-generated by ${generatorName}
+// Do NOT edit this file manually.
+
+`;
+  const sortedModulePaths = [...importsMap.keys()].sort((a, b) => {
+    const aIsRelative = a.startsWith(".");
+    const bIsRelative = b.startsWith(".");
+    if (aIsRelative !== bIsRelative) return aIsRelative ? 1 : -1;
+    return a.localeCompare(b);
+  });
+  if (sortedModulePaths.length > 0) {
+    const importStatements = sortedModulePaths.map((modulePath) => {
+      const imports = [...importsMap.get(modulePath) ?? []].sort();
+      const finalModulePath = modulePath === "." ? "./index" : modulePath;
+      return `import type { ${imports.join(", ")} } from '${finalModulePath}';`;
+    });
+    outputContent += `${importStatements.join("\n")}
+
+`;
+  }
+  if (inlineDefinitions.size > 0) {
+    outputContent += `${[...inlineDefinitions.values()].join("\n\n")}
+
+`;
+  }
+  const exportedTypeDefinitions = exportedDeclarations.filter(
+    (d) => d.getKind() === tsMorph.SyntaxKind.InterfaceDeclaration || d.getKind() === tsMorph.SyntaxKind.TypeAliasDeclaration
+  ).map((decl) => decl.getText());
+  if (exportedTypeDefinitions.length > 0) {
+    outputContent += `${exportedTypeDefinitions.join("\n\n")}
+
+`;
+  }
+  if (methodDefinitions.length > 0) {
+    const formattedMethods = methodDefinitions.map(
+      (method) => method.split("\n").map((line) => `  ${line}`).join("\n")
+    ).join("\n\n");
+    outputContent += `export type ServerScripts = {
+${formattedMethods}
+}
+`;
+    consola.consola.info(
+      `Interface 'ServerScript' type definitions written to ${absoluteOutputFile} (${methodDefinitions.length} function(s), ${exportedTypeDefinitions.length + inlineDefinitions.size} type(s)).`
+    );
+  } else {
+    outputContent += "export type ServerScripts = {}\n";
+    consola.consola.info(
+      `Interface 'ServerScript' type definitions written to ${absoluteOutputFile} (no functions found).`
+    );
+  }
+  outputContent += `
+// Auto-generated Types for GoogleAppsScript in client-side code
+
+${text}`;
+  fs__namespace.writeFileSync(absoluteOutputFile, outputContent);
+};
+
+function defineConfig(config) {
+  return config;
+}
+async function loadConfig(projectRoot) {
+  const configFileExtensions = [".ts", ".mts", ".cts", ".js", ".mjs", ".cjs"];
+  let foundConfigPath;
+  let foundConfigFileName;
+  for (const configFileExtension of configFileExtensions) {
+    const configFile = `gasnuki.config${configFileExtension}`;
+    const fullPath = path__namespace.resolve(projectRoot, configFile);
+    if (fs__namespace.existsSync(fullPath)) {
+      foundConfigPath = fullPath;
+      foundConfigFileName = configFile;
+      break;
+    }
+  }
+  if (!foundConfigPath || !foundConfigFileName) {
+    return {};
+  }
+  try {
+    const jiti$1 = jiti.createJiti(projectRoot, {
+      fsCache: false,
+      moduleCache: false,
+      interopDefault: true
+    });
+    const configModule = await jiti$1.import(foundConfigPath, {
+      default: true
+    });
+    consola.consola.success(`Loaded configuration from ${foundConfigFileName}`);
+    return configModule;
+  } catch (error) {
+    consola.consola.error(`Error loading ${foundConfigFileName}:`, error);
+    return {};
+  }
+}
+
+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.loadConfig = loadConfig;

package/dist/shared/gasnuki.CS974pL-.mjs

@@ -0,0 +1,389 @@
+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';
+
+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";
+
+const getInterfaceMethodDefinition_ = (name, node) => {
+  const typeParameters = node.getTypeParameters?.() ?? [];
+  const typeParamsString = typeParameters.length > 0 ? `<${typeParameters.map((tp) => tp.getText()).join(", ")}>` : "";
+  const parameters = node.getParameters().map((param) => {
+    const paramName = param.getName();
+    const type = param.getTypeNode()?.getText() ?? param.getType().getText(node) ?? "any";
+    const questionToken = param.hasQuestionToken() ? "?" : "";
+    return `${paramName}${questionToken}: ${type}`;
+  }).join(", ");
+  const returnTypeNode = node.getReturnTypeNode();
+  let returnType;
+  if (returnTypeNode != null) {
+    returnType = returnTypeNode.getText();
+  } else {
+    const inferredReturnType = node.getReturnType();
+    if (inferredReturnType.isVoid()) {
+      returnType = "void";
+    } else {
+      returnType = inferredReturnType.getText(node);
+    }
+  }
+  let jsDocString = "";
+  const jsDocOwner = "getJsDocs" in node ? node : "getParentOrThrow" in node && // @ts-expect-error variable declaration
+  node.getParentOrThrow().getKind() === SyntaxKind.VariableDeclaration ? (
+    // @ts-expect-error variable declaration
+    node.getParentOrThrow()
+  ) : null;
+  if (jsDocOwner != null) {
+    const jsDocs = "getJsDocs" in jsDocOwner ? jsDocOwner.getJsDocs() : [];
+    if (jsDocs.length > 0) {
+      const firstDoc = jsDocs[0];
+      jsDocString = `${firstDoc.getFullText().trim()}
+`;
+    }
+  }
+  return `${jsDocString}${name}${typeParamsString}(${parameters}): ${returnType};`;
+};
+const SIMPLE_TRIGGER_FUNCTION_NAMES = [
+  "onOpen",
+  "onEdit",
+  "onInstall",
+  "onSelectionChange",
+  "doGet",
+  "doPost"
+];
+const generateAppsScriptTypes = async ({
+  project: projectPath,
+  srcDir,
+  outDir,
+  outputFile
+}) => {
+  const absoluteSrcDir = path.resolve(projectPath, srcDir);
+  const absoluteOutDir = path.resolve(projectPath, outDir);
+  const absoluteOutputFile = path.resolve(absoluteOutDir, outputFile);
+  consola.info("Starting AppsScript type generation with gasnuki...");
+  consola.info(`  AppsScript Source Directory: ${absoluteSrcDir}`);
+  consola.info(`  Output File: ${absoluteOutputFile}`);
+  const project = new Project({
+    tsConfigFilePath: path.resolve(projectPath, "tsconfig.json"),
+    skipAddingFilesFromTsConfig: true
+  });
+  const sourceFilesPattern = path.join(absoluteSrcDir, "**/*.ts").replace(/\\/g, "/");
+  const testFilesPattern = `!${path.join(absoluteSrcDir, "**/*.{test,spec}.ts").replace(/\\/g, "/")}`;
+  project.addSourceFilesAtPaths([sourceFilesPattern, testFilesPattern]);
+  const sourceFiles = project.getSourceFiles();
+  consola.info(`Found ${sourceFiles.length} source file(s).`);
+  const methodDefinitions = [];
+  const exportedDeclarations = [];
+  const exportedDeclarationNames = /* @__PURE__ */ new Set();
+  const exportedFunctions = [];
+  for (const sourceFile of sourceFiles) {
+    for (const iface of sourceFile.getInterfaces()) {
+      if (iface.isExported() && !iface.getName()?.endsWith("_")) {
+        exportedDeclarations.push(iface);
+        exportedDeclarationNames.add(iface.getName());
+      }
+    }
+    for (const typeAlias of sourceFile.getTypeAliases()) {
+      if (typeAlias.isExported() && !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)) {
+        exportedDeclarations.push(func);
+        exportedDeclarationNames.add(name);
+        methodDefinitions.push(getInterfaceMethodDefinition_(name, func));
+        exportedFunctions.push(func);
+      }
+    }
+    for (const varStmt of sourceFile.getVariableStatements()) {
+      if (!varStmt.isExported()) continue;
+      for (const varDecl of varStmt.getDeclarations()) {
+        const name = varDecl.getName();
+        const initializer = varDecl.getInitializer();
+        if (!name.endsWith("_") && !SIMPLE_TRIGGER_FUNCTION_NAMES.includes(name) && initializer && (initializer.getKind() === SyntaxKind.ArrowFunction || initializer.getKind() === SyntaxKind.FunctionExpression)) {
+          const funcExpr = initializer;
+          exportedDeclarations.push(varDecl);
+          exportedDeclarationNames.add(name);
+          methodDefinitions.push(getInterfaceMethodDefinition_(name, funcExpr));
+          exportedFunctions.push(funcExpr);
+        }
+      }
+    }
+  }
+  const collectSymbolsFromType = (type, foundSymbols) => {
+    const symbol = type.getAliasSymbol() ?? type.getSymbol();
+    if (symbol && !foundSymbols.has(symbol)) {
+      foundSymbols.add(symbol);
+      if (type.isObject()) {
+        for (const prop of type.getProperties()) {
+          const propDecl = prop.getDeclarations()[0];
+          if (propDecl) {
+            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);
+      }
+    }
+  };
+  const returnValueSymbols = /* @__PURE__ */ new Set();
+  for (const func of exportedFunctions) {
+    collectSymbolsFromType(func.getReturnType(), returnValueSymbols);
+  }
+  const symbolsToProcess = /* @__PURE__ */ new Set();
+  for (const decl of exportedDeclarations) {
+    if (decl.getKind() === SyntaxKind.FunctionDeclaration || decl.getKind() === SyntaxKind.VariableDeclaration && (decl.getInitializer()?.getKind() === SyntaxKind.ArrowFunction || decl.getInitializer()?.getKind() === SyntaxKind.FunctionExpression)) {
+      const func = decl.getKind() === SyntaxKind.FunctionDeclaration ? decl : decl.getInitializer();
+      const parameters = func.getParameters();
+      for (const param of parameters) {
+        const typeRefs = param.getDescendantsOfKind(SyntaxKind.TypeReference);
+        for (const typeRef of typeRefs) {
+          const symbol = typeRef.getType().getAliasSymbol() ?? typeRef.getType().getSymbol();
+          if (symbol) symbolsToProcess.add(symbol);
+        }
+      }
+      const returnTypeNode = func.getReturnTypeNode();
+      if (returnTypeNode) {
+        const typeRefs = returnTypeNode.getDescendantsOfKind(
+          SyntaxKind.TypeReference
+        );
+        for (const typeRef of typeRefs) {
+          const symbol = typeRef.getType().getAliasSymbol() ?? typeRef.getType().getSymbol();
+          if (symbol) symbolsToProcess.add(symbol);
+        }
+      }
+    } else if (decl.getKind() === SyntaxKind.InterfaceDeclaration || decl.getKind() === SyntaxKind.TypeAliasDeclaration) {
+      const typeRefs = decl.getDescendantsOfKind(SyntaxKind.TypeReference);
+      for (const typeRef of typeRefs) {
+        const symbol = typeRef.getType().getAliasSymbol() ?? typeRef.getType().getSymbol();
+        if (symbol) symbolsToProcess.add(symbol);
+      }
+    }
+  }
+  const importsMap = /* @__PURE__ */ new Map();
+  const inlineDefinitions = /* @__PURE__ */ new Map();
+  const processedSymbols = /* @__PURE__ */ new Set();
+  while (symbolsToProcess.size > 0) {
+    const symbol = symbolsToProcess.values().next().value;
+    if (!symbol) continue;
+    symbolsToProcess.delete(symbol);
+    const symbolName = symbol.getName();
+    if (processedSymbols.has(symbolName) || exportedDeclarationNames.has(symbolName) || symbolName === "__type") {
+      continue;
+    }
+    const symbolFlags = symbol.getFlags();
+    if (symbolFlags & SymbolFlags.TypeParameter) {
+      continue;
+    }
+    const declaration = symbol.getDeclarations()[0];
+    if (!declaration) {
+      continue;
+    }
+    const sourceFile = declaration.getSourceFile();
+    if (sourceFile.getFilePath().includes("node_modules")) {
+      continue;
+    }
+    processedSymbols.add(symbolName);
+    const isLocalDefinition = declaration.getParent()?.getKind() !== SyntaxKind.SourceFile;
+    if (isLocalDefinition) {
+      if (returnValueSymbols.has(symbol)) {
+        const declText = declaration.getText();
+        inlineDefinitions.set(symbolName, declText);
+        const tempSourceFile = project.createSourceFile(
+          `__temp_${symbolName}.ts`,
+          declText
+        );
+        for (const descendant of tempSourceFile.getDescendantsOfKind(
+          SyntaxKind.TypeReference
+        )) {
+          const newSymbol = descendant.getType().getAliasSymbol() ?? descendant.getType().getSymbol();
+          if (newSymbol) {
+            symbolsToProcess.add(newSymbol);
+          }
+        }
+        tempSourceFile.delete();
+      }
+    } else {
+      let modulePath = path.relative(absoluteOutDir, sourceFile.getFilePath()).replace(/\\/g, "/");
+      modulePath = modulePath.replace(/\.(d\.)?ts$/, "");
+      if (modulePath.endsWith("/index")) {
+        modulePath = modulePath.slice(0, -6);
+      }
+      if (modulePath === "index" || modulePath === "") {
+        modulePath = ".";
+      }
+      if (!modulePath.startsWith(".")) {
+        modulePath = `./${modulePath}`;
+      }
+      if (!importsMap.has(modulePath)) {
+        importsMap.set(modulePath, /* @__PURE__ */ new Set());
+      }
+      importsMap.get(modulePath)?.add(symbolName);
+    }
+  }
+  if (!fs.existsSync(absoluteOutDir)) {
+    fs.mkdirSync(absoluteOutDir, { recursive: true });
+    consola.info(`Created output directory: ${absoluteOutDir}`);
+  }
+  const generatorName = "gasnuki";
+  let outputContent = `// Auto-generated by ${generatorName}
+// Do NOT edit this file manually.
+
+`;
+  const sortedModulePaths = [...importsMap.keys()].sort((a, b) => {
+    const aIsRelative = a.startsWith(".");
+    const bIsRelative = b.startsWith(".");
+    if (aIsRelative !== bIsRelative) return aIsRelative ? 1 : -1;
+    return a.localeCompare(b);
+  });
+  if (sortedModulePaths.length > 0) {
+    const importStatements = sortedModulePaths.map((modulePath) => {
+      const imports = [...importsMap.get(modulePath) ?? []].sort();
+      const finalModulePath = modulePath === "." ? "./index" : modulePath;
+      return `import type { ${imports.join(", ")} } from '${finalModulePath}';`;
+    });
+    outputContent += `${importStatements.join("\n")}
+
+`;
+  }
+  if (inlineDefinitions.size > 0) {
+    outputContent += `${[...inlineDefinitions.values()].join("\n\n")}
+
+`;
+  }
+  const exportedTypeDefinitions = exportedDeclarations.filter(
+    (d) => d.getKind() === SyntaxKind.InterfaceDeclaration || d.getKind() === SyntaxKind.TypeAliasDeclaration
+  ).map((decl) => decl.getText());
+  if (exportedTypeDefinitions.length > 0) {
+    outputContent += `${exportedTypeDefinitions.join("\n\n")}
+
+`;
+  }
+  if (methodDefinitions.length > 0) {
+    const formattedMethods = methodDefinitions.map(
+      (method) => method.split("\n").map((line) => `  ${line}`).join("\n")
+    ).join("\n\n");
+    outputContent += `export type ServerScripts = {
+${formattedMethods}
+}
+`;
+    consola.info(
+      `Interface 'ServerScript' type definitions written to ${absoluteOutputFile} (${methodDefinitions.length} function(s), ${exportedTypeDefinitions.length + inlineDefinitions.size} type(s)).`
+    );
+  } else {
+    outputContent += "export type ServerScripts = {}\n";
+    consola.info(
+      `Interface 'ServerScript' type definitions written to ${absoluteOutputFile} (no functions found).`
+    );
+  }
+  outputContent += `
+// Auto-generated Types for GoogleAppsScript in client-side code
+
+${text}`;
+  fs.writeFileSync(absoluteOutputFile, outputContent);
+};
+
+function defineConfig(config) {
+  return config;
+}
+async function loadConfig(projectRoot) {
+  const configFileExtensions = [".ts", ".mts", ".cts", ".js", ".mjs", ".cjs"];
+  let foundConfigPath;
+  let foundConfigFileName;
+  for (const configFileExtension of configFileExtensions) {
+    const configFile = `gasnuki.config${configFileExtension}`;
+    const fullPath = path.resolve(projectRoot, configFile);
+    if (fs.existsSync(fullPath)) {
+      foundConfigPath = fullPath;
+      foundConfigFileName = configFile;
+      break;
+    }
+  }
+  if (!foundConfigPath || !foundConfigFileName) {
+    return {};
+  }
+  try {
+    const jiti = createJiti(projectRoot, {
+      fsCache: false,
+      moduleCache: false,
+      interopDefault: true
+    });
+    const configModule = await jiti.import(foundConfigPath, {
+      default: true
+    });
+    consola.success(`Loaded configuration from ${foundConfigFileName}`);
+    return configModule;
+  } catch (error) {
+    consola.error(`Error loading ${foundConfigFileName}:`, error);
+    return {};
+  }
+}
+
+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 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ciderjs/gasnuki",
-  "version": "0.2.8",
+  "version": "0.2.9",
   "description": "Type definitions and utilities for Google Apps Script client-side API",
   "main": "dist/index.mjs",
   "types": "dist/index.d.ts",