@leftium/gg 0.0.20 → 0.0.23

package/dist/eruda/buffer.d.ts

@@ -0,0 +1,26 @@
+import type { CapturedEntry } from './types.js';
+/**
+ * Ring buffer for captured log entries
+ */
+export declare class LogBuffer {
+    private entries;
+    private maxSize;
+    constructor(maxSize?: number);
+    /**
+     * Add an entry to the buffer
+     * If buffer is full, oldest entry is removed
+     */
+    push(entry: CapturedEntry): void;
+    /**
+     * Get all entries (optionally filtered)
+     */
+    getEntries(filter?: (entry: CapturedEntry) => boolean): CapturedEntry[];
+    /**
+     * Clear all entries
+     */
+    clear(): void;
+    /**
+     * Get entry count
+     */
+    get size(): number;
+}

package/dist/eruda/buffer.js

@@ -0,0 +1,40 @@
+/**
+ * Ring buffer for captured log entries
+ */
+export class LogBuffer {
+    entries = [];
+    maxSize;
+    constructor(maxSize = 2000) {
+        this.maxSize = maxSize;
+    }
+    /**
+     * Add an entry to the buffer
+     * If buffer is full, oldest entry is removed
+     */
+    push(entry) {
+        this.entries.push(entry);
+        if (this.entries.length > this.maxSize) {
+            this.entries.shift(); // Remove oldest
+        }
+    }
+    /**
+     * Get all entries (optionally filtered)
+     */
+    getEntries(filter) {
+        if (!filter)
+            return [...this.entries];
+        return this.entries.filter(filter);
+    }
+    /**
+     * Clear all entries
+     */
+    clear() {
+        this.entries = [];
+    }
+    /**
+     * Get entry count
+     */
+    get size() {
+        return this.entries.length;
+    }
+}

package/dist/eruda/index.d.ts

@@ -0,0 +1,24 @@
+import type { GgErudaOptions } from './types.js';
+export type { GgErudaOptions, CapturedEntry, ErudaPlugin } from './types.js';
+/**
+ * Initialize the gg Eruda plugin
+ *
+ * In development, loads Eruda eagerly.
+ * In production, loads only when triggers fire.
+ *
+ * @example
+ * ```ts
+ * import { initGgEruda } from '@leftium/gg/eruda';
+ *
+ * // Simple usage - works in dev, respects ?gg in prod
+ * initGgEruda();
+ *
+ * // Custom triggers
+ * initGgEruda({
+ *   prod: 'url-param', // Only ?gg trigger, no gesture
+ *   maxEntries: 5000,
+ *   autoEnable: true
+ * });
+ * ```
+ */
+export declare function initGgEruda(options?: GgErudaOptions): void;

package/dist/eruda/index.js

@@ -0,0 +1,82 @@
+import { BROWSER } from 'esm-env';
+import { shouldLoadEruda, loadEruda } from './loader.js';
+let initialized = false;
+/**
+ * Initialize the gg Eruda plugin
+ *
+ * In development, loads Eruda eagerly.
+ * In production, loads only when triggers fire.
+ *
+ * @example
+ * ```ts
+ * import { initGgEruda } from '@leftium/gg/eruda';
+ *
+ * // Simple usage - works in dev, respects ?gg in prod
+ * initGgEruda();
+ *
+ * // Custom triggers
+ * initGgEruda({
+ *   prod: 'url-param', // Only ?gg trigger, no gesture
+ *   maxEntries: 5000,
+ *   autoEnable: true
+ * });
+ * ```
+ */
+export function initGgEruda(options = {}) {
+    // Only run in browser
+    if (!BROWSER)
+        return;
+    // Prevent double initialization
+    if (initialized) {
+        console.warn('[gg] initGgEruda() called multiple times. Ignoring subsequent calls.');
+        return;
+    }
+    initialized = true;
+    // Check if we should load Eruda
+    if (!shouldLoadEruda(options)) {
+        // In production without triggers, set up gesture detection if enabled
+        const prodTriggers = options.prod ?? ['url-param', 'gesture'];
+        const triggerArray = Array.isArray(prodTriggers) ? prodTriggers : [prodTriggers];
+        if (triggerArray.includes('gesture')) {
+            setupGestureDetection(options);
+        }
+        return;
+    }
+    // Load Eruda
+    loadEruda(options);
+}
+/**
+ * Set up 5-tap gesture detection for production
+ */
+function setupGestureDetection(options) {
+    let tapCount = 0;
+    let tapTimer = null;
+    const resetTaps = () => {
+        tapCount = 0;
+        if (tapTimer)
+            clearTimeout(tapTimer);
+        tapTimer = null;
+    };
+    document.addEventListener('click', () => {
+        tapCount++;
+        // Reset timer on each tap
+        if (tapTimer)
+            clearTimeout(tapTimer);
+        // If 5 taps detected, load Eruda
+        if (tapCount >= 5) {
+            console.log('[gg] 5 taps detected, loading Eruda...');
+            // Persist the decision
+            try {
+                localStorage.setItem('gg-enabled', 'true');
+            }
+            catch {
+                // localStorage might not be available
+            }
+            loadEruda(options);
+            resetTaps();
+            return;
+        }
+        // Reset after 1 second of no taps
+        tapTimer = setTimeout(resetTaps, 1000);
+    });
+}

package/dist/eruda/loader.d.ts

@@ -0,0 +1,9 @@
+import type { GgErudaOptions } from './types.js';
+/**
+ * Determines if Eruda should be loaded based on environment and triggers
+ */
+export declare function shouldLoadEruda(options: GgErudaOptions): boolean;
+/**
+ * Dynamically imports and initializes Eruda
+ */
+export declare function loadEruda(options: GgErudaOptions): Promise<void>;

package/dist/eruda/loader.js

@@ -0,0 +1,94 @@
+import { BROWSER, DEV } from 'esm-env';
+/**
+ * Checks if any production trigger is active
+ */
+function checkProdTriggers(triggers) {
+    if (!BROWSER)
+        return false;
+    if (triggers === false)
+        return false;
+    const triggerArray = Array.isArray(triggers) ? triggers : [triggers];
+    for (const trigger of triggerArray) {
+        if (trigger === 'url-param') {
+            try {
+                const params = new URLSearchParams(window.location.search);
+                if (params.has('gg')) {
+                    // Persist the decision
+                    localStorage.setItem('gg-enabled', 'true');
+                    return true;
+                }
+            }
+            catch {
+                // URLSearchParams might not be available
+            }
+        }
+        if (trigger === 'localStorage') {
+            try {
+                if (localStorage.getItem('gg-enabled') === 'true') {
+                    return true;
+                }
+            }
+            catch {
+                // localStorage might not be available
+            }
+        }
+        if (trigger === 'gesture') {
+            // TODO: Implement 5-tap gesture detection
+            // For now, fall through
+        }
+    }
+    return false;
+}
+/**
+ * Determines if Eruda should be loaded based on environment and triggers
+ */
+export function shouldLoadEruda(options) {
+    if (!BROWSER)
+        return false;
+    // Development - always load
+    if (DEV)
+        return true;
+    // Production - check triggers
+    const prodTriggers = options.prod ?? ['url-param', 'gesture'];
+    return checkProdTriggers(prodTriggers);
+}
+/**
+ * Dynamically imports and initializes Eruda
+ */
+export async function loadEruda(options) {
+    if (!BROWSER)
+        return;
+    try {
+        // Dynamic import of Eruda
+        const erudaModule = await import('eruda');
+        const eruda = erudaModule.default;
+        // Initialize Eruda
+        eruda.init({
+            ...options.erudaOptions,
+            // Ensure tool is always visible in case user customizes
+            tool: ['console', 'elements', 'network', 'resources', 'info', 'snippets', 'sources']
+        });
+        // Auto-enable localStorage.debug if requested and unset
+        if (options.autoEnable !== false) {
+            try {
+                if (!localStorage.getItem('debug')) {
+                    localStorage.setItem('debug', 'gg:*');
+                }
+            }
+            catch {
+                // localStorage might not be available
+            }
+        }
+        // Register gg plugin
+        // Import gg and pass it to the plugin directly
+        const { gg } = await import('../gg.js');
+        const { createGgPlugin } = await import('./plugin.js');
+        const ggPlugin = createGgPlugin(options, gg);
+        eruda.add(ggPlugin);
+        // Make GG tab the default selected tab
+        eruda.show('GG');
+    }
+    catch (error) {
+        console.error('[gg] Failed to load Eruda:', error);
+    }
+}

package/dist/eruda/plugin.d.ts

@@ -0,0 +1,14 @@
+import type { GgErudaOptions } from './types.js';
+/**
+ * Creates the gg Eruda plugin
+ *
+ * Uses Eruda's plugin API where $el is a jQuery-like (licia) wrapper.
+ * Methods: $el.html(), $el.show(), $el.hide(), $el.find(), $el.on()
+ */
+export declare function createGgPlugin(options: GgErudaOptions, gg: any): {
+    name: string;
+    init($container: any): void;
+    show(): void;
+    hide(): void;
+    destroy(): void;
+};