@leftium/gg 0.0.31 → 0.0.34

package/dist/eruda/types.d.ts

@@ -12,11 +12,6 @@ export interface GgErudaOptions {
      * @default 2000
      */
     maxEntries?: number;
-    /**
-     * Auto-enable localStorage.debug = 'gg:*' if unset
-     * @default true
-     */
-    autoEnable?: boolean;
     /**
      * Additional Eruda options passed to eruda.init()
      * @default {}
@@ -39,6 +34,14 @@ export interface CapturedEntry {
     args: unknown[];
     /** Timestamp */
     timestamp: number;
+    /** Source file path for open-in-editor (e.g., "src/routes/blog/[slug]/+page.svelte") */
+    file?: string;
+    /** Source line number */
+    line?: number;
+    /** Source column number */
+    col?: number;
+    /** Source expression text for icecream-style display (e.g., "user.name") */
+    src?: string;
 }
 /**
  * Eruda plugin interface

package/dist/gg-call-sites-plugin.d.ts

@@ -12,13 +12,40 @@ export interface GgCallSitesPluginOptions {
     srcRootPattern?: string;
 }
 /**
- * Vite plugin that rewrites bare `gg(...)` calls to `gg.ns('callpoint', ...)`
- * at build time. This gives each call site a unique namespace with zero runtime
- * cost — no stack trace parsing needed.
+ * A range of source code that contains JS expressions, tagged with its context.
+ * - 'script': inside a `<script>` block — use object literal `{...}` syntax
+ * - 'template': inside a template expression `{...}` or event handler — use `gg._o()` syntax
+ */
+export interface CodeRange {
+    start: number;
+    end: number;
+    context: 'script' | 'template';
+}
+/**
+ * A function scope range, mapping a byte range to the enclosing function name.
+ * Built from the estree AST during `collectCodeRanges()`.
+ */
+export interface FunctionScope {
+    start: number;
+    end: number;
+    name: string;
+}
+/**
+ * Result of `collectCodeRanges()` — code ranges plus function scope info.
+ */
+export interface SvelteCodeInfo {
+    ranges: CodeRange[];
+    /** Function scopes extracted from the estree AST, sorted by start position. */
+    functionScopes: FunctionScope[];
+}
+/**
+ * Vite plugin that rewrites `gg(...)` and `gg.ns(...)` calls to
+ * `gg._ns({ns, file, line, col}, ...)` at build time. This gives each call
+ * site a unique namespace plus source location metadata for open-in-editor
+ * support, with zero runtime cost — no stack trace parsing needed.
  *
- * Works in both dev and prod. When the plugin is installed, `gg.ns()` is called
- * with the callpoint baked in as a string literal. Without the plugin, gg()
- * falls back to runtime stack parsing in dev and bare `gg:` in prod.
+ * Works in both dev and prod. Without the plugin, gg() falls back to runtime
+ * stack parsing in dev and bare `gg:` in prod.
  *
  * @example
  * // vite.config.ts
@@ -29,3 +56,60 @@ export interface GgCallSitesPluginOptions {
  * });
  */
 export default function ggCallSitesPlugin(options?: GgCallSitesPluginOptions): Plugin;
+/**
+ * Parse JavaScript/TypeScript code using acorn to extract function scopes.
+ * Returns function scope ranges for accurate function name detection in .js/.ts files.
+ * Uses @sveltejs/acorn-typescript plugin to handle TypeScript syntax.
+ *
+ * For .svelte files, use `collectCodeRanges()` instead (which uses svelte.parse()).
+ */
+export declare function parseJavaScript(code: string): FunctionScope[];
+/**
+ * Use `svelte.parse()` to collect all code ranges and function scopes in a .svelte file.
+ *
+ * Code ranges identify where JS expressions live:
+ * - `<script>` blocks (context: 'script')
+ * - Template expressions: `{expr}`, `onclick={expr}`, `bind:value={expr}`,
+ *   `class:name={expr}`, `{#if expr}`, `{#each expr}`, etc. (context: 'template')
+ *
+ * Function scopes are extracted from the estree AST in script blocks, mapping
+ * byte ranges to enclosing function names. This replaces regex-based function
+ * detection for .svelte files.
+ *
+ * Text nodes (prose) are NOT included, so `gg()` in `<p>text gg()</p>` is never transformed.
+ */
+export declare function collectCodeRanges(code: string): SvelteCodeInfo;
+/**
+ * Find the innermost enclosing function name for a byte position
+ * using the pre-built function scope map.
+ * Returns empty string if not inside any named function.
+ */
+export declare function findEnclosingFunctionFromScopes(pos: number, scopes: FunctionScope[]): string;
+/**
+ * Escape a string for embedding as a single-quoted JS string literal.
+ */
+export declare function escapeForString(s: string): string;
+/**
+ * Transform gg() and gg.ns() calls in source code to gg._ns({ns, file, line, col, src}, ...) calls.
+ *
+ * Handles:
+ * - bare gg(expr) → gg._ns({ns, file, line, col, src: 'expr'}, expr)
+ * - gg.ns('label', expr) → gg._ns({ns, file, line, col, src: 'expr'}, expr)
+ *   - label supports template variables: $NS, $FN, $FILE, $LINE, $COL
+ *   - plain label (no variables) is used as-is (no auto @fn append)
+ * - gg.enable, gg.disable, gg.clearPersist, gg._onLog, gg._ns → left untouched
+ * - gg inside strings and comments → left untouched
+ *
+ * For .svelte files, `svelteInfo` (from `collectCodeRanges()`) determines which
+ * positions contain JS code and provides AST-based function scope detection.
+ * Script ranges use `{...}` object literal syntax; template ranges use `gg._o()`
+ * function-call syntax (no braces in Svelte markup). Positions outside any code
+ * range (e.g. prose text) are skipped.
+ *
+ * For .js/.ts files, `jsFunctionScopes` (from `parseJavaScript()`) provides
+ * AST-based function scope detection (no regex fallback).
+ */
+export declare function transformGgCalls(code: string, shortPath: string, filePath: string, svelteInfo?: SvelteCodeInfo, jsFunctionScopes?: FunctionScope[]): {
+    code: string;
+    map: null;
+} | null;