trickle-observe 0.2.110 → 0.2.112

package/dist/express.js

@@ -181,11 +181,6 @@ function wrapExpressHandler(handler, routeName, opts) {
                 return next(err);
             }
         };
-        const debug = process.env.TRICKLE_DEBUG === '1';
-        if (debug) {
-            const hs = handler.toString().substring(0, 200);
-            process.stderr.write(`[trickle/express-wrap] Calling handler: ${hs.replace(/\n/g, '\\n')}\n`);
-        }
         try {
             const result = handler.call(this, req, res, wrappedNext);
             // Handle async handlers that return a promise

package/dist/observe-register.js

@@ -1080,10 +1080,7 @@ function transformCjsSource(source, filename, moduleName, env, sourceMap) {
             lineNo: remapLine(ins.lineNo),
         }));
         if (debug && funcParamInsertions.length > 0) {
-            console.log(`[trickle/observe] Found ${funcParamInsertions.length} function param insertions in ${moduleName}`);
-            for (const ins of funcParamInsertions) {
-                console.log(`  Line ${ins.lineNo}: params=[${ins.paramNames.join(', ')}]`);
-            }
+            console.log(`[trickle/observe] Tracing ${funcParamInsertions.length} function param sites in ${moduleName}`);
         }
     }
     if (insertions.length === 0 && varInsertions.length === 0 && destructInsertions.length === 0 && reassignInsertions.length === 0 && forLoopInsertions.length === 0 && catchInsertions.length === 0 && classInsertions.length === 0 && funcParamInsertions.length === 0)
@@ -1120,7 +1117,7 @@ function transformCjsSource(source, filename, moduleName, env, sourceMap) {
         const traceModuleName = sourceMap
             ? path_1.default.basename(sourceMap.originalFile).replace(/\.[jt]sx?$/, '')
             : moduleName;
-        prefixLines.push(`var __trickle_tv_mod = require(${JSON.stringify(traceVarPath)});`, `var __trickle_tv = function(v, n, l, m, f) { try { __trickle_tv_mod.traceVar(v, n, l, m || ${JSON.stringify(traceModuleName)}, f || ${JSON.stringify(traceFilePath)}); } catch(e){ if (process.env.TRICKLE_DEBUG === '1') console.error('[trickle/tv] Error tracing', n, ':', e && e.message); } };`);
+        prefixLines.push(`var __trickle_tv_mod = require(${JSON.stringify(traceVarPath)});`, `var __trickle_tv = function(v, n, l, m, f) { try { __trickle_tv_mod.traceVar(v, n, l, m || ${JSON.stringify(traceModuleName)}, f || ${JSON.stringify(traceFilePath)}); } catch(e){} };`);
     }
     prefixLines.push('');
     const prefix = prefixLines.join('\n');
@@ -1184,7 +1181,7 @@ function transformCjsSource(source, filename, moduleName, env, sourceMap) {
         const calls = paramNames.map(n => `__trickle_tv(${n},${JSON.stringify(n)},${lineNo}${sf})`).join(';');
         allInsertions.push({
             position: bodyStart,
-            code: `\nprocess.stderr.write("[trickle/params] Entering L${lineNo}\\n");try{${calls}}catch(__e3){process.stderr.write('[trickle/params] Error:'+(__e3&&__e3.message)+'\\n')}\n`,
+            code: `\ntry{${calls}}catch(__e3){}\n`,
         });
     }
     // Add class method wrappings
@@ -1197,14 +1194,6 @@ function transformCjsSource(source, filename, moduleName, env, sourceMap) {
     for (const { position, code } of allInsertions) {
         result = result.slice(0, position) + code + result.slice(position);
     }
-    // Debug: dump transformed source
-    if (debug && funcParamInsertions.length > 0) {
-        try {
-            const debugDir = process.env.TRICKLE_LOCAL_DIR || path_1.default.join(process.cwd(), '.trickle');
-            fs_1.default.writeFileSync(path_1.default.join(debugDir, 'transformed-' + moduleName + '.js'), prefix + result);
-        }
-        catch { }
-    }
     return prefix + result;
 }
 /**

package/dist/trace-var.js

@@ -145,9 +145,6 @@ function traceVar(value, varName, line, moduleName, filePath) {
             return;
     }
     try {
-        if (debugMode) {
-            console.log(`[trickle/vars] traceVar called: ${varName} at ${filePath}:${line} (typeof=${typeof value})`);
-        }
         const type = (0, type_inference_1.inferType)(value, 3);
         // Create a stable hash for dedup
         const dummyArgs = { kind: 'tuple', elements: [] };
@@ -193,11 +190,8 @@ function traceVar(value, varName, line, moduleName, filePath) {
             }
         }
     }
-    catch (err) {
+    catch {
         // Never crash user's app
-        if (debugMode) {
-            console.error(`[trickle/vars] Error tracing ${varName}: ${err instanceof Error ? err.message : String(err)}`);
-        }
     }
 }
 /**

package/dist/vite-plugin.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/vite-plugin.test.js

@@ -0,0 +1,160 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Unit tests for the Vite plugin transform (React component tracking).
+ *
+ * Run with: node --experimental-strip-types --test src/vite-plugin.test.ts
+ * Or after build: node --test dist/vite-plugin.test.js
+ */
+const node_test_1 = require("node:test");
+const strict_1 = __importDefault(require("node:assert/strict"));
+const vite_plugin_js_1 = require("../dist/vite-plugin.js");
+// Helper: transform code as if it came from a .tsx file
+function transformTsx(code) {
+    const plugin = (0, vite_plugin_js_1.tricklePlugin)({ debug: false, traceVars: false });
+    const result = plugin.transform(code, '/test/App.tsx');
+    return result ? result.code : null;
+}
+function transformTs(code) {
+    const plugin = (0, vite_plugin_js_1.tricklePlugin)({ debug: false, traceVars: false });
+    const result = plugin.transform(code, '/test/util.ts');
+    return result ? result.code : null;
+}
+// ── React file detection ─────────────────────────────────────────────────────
+(0, node_test_1.describe)('React file detection', () => {
+    (0, node_test_1.it)('tracks uppercase components in .tsx files', () => {
+        const code = `function UserCard(props) { return null; }`;
+        const out = transformTsx(code);
+        strict_1.default.ok(out, 'should transform');
+        strict_1.default.ok(out.includes('__trickle_rc'), 'should inject render tracker');
+    });
+    (0, node_test_1.it)('does not inject render tracker for .ts files', () => {
+        const code = `function UserCard(props) { return null; }`;
+        const out = transformTs(code);
+        // May still transform for function wrapping, but not for render tracking
+        if (out) {
+            strict_1.default.ok(!out.includes('__trickle_rc'), 'should NOT inject render tracker in .ts files');
+        }
+    });
+    (0, node_test_1.it)('does not track lowercase functions as components', () => {
+        const code = `function helper(x) { return x + 1; }`;
+        const out = transformTsx(code);
+        if (out) {
+            strict_1.default.ok(!out.includes('__trickle_rc'), 'lowercase function should not be tracked');
+        }
+    });
+});
+// ── Props capture: function declarations ─────────────────────────────────────
+(0, node_test_1.describe)('Props capture — function declarations', () => {
+    (0, node_test_1.it)('uses arguments[0] for simple param: function Component(props)', () => {
+        const code = `function MyComponent(props) { return null; }`;
+        const out = transformTsx(code);
+        strict_1.default.ok(out, 'should transform');
+        strict_1.default.ok(out.includes('arguments[0]'), 'should pass arguments[0] as props');
+    });
+    (0, node_test_1.it)('uses arguments[0] for destructured param: function Component({ name })', () => {
+        const code = `function UserCard({ name, age }) { return null; }`;
+        const out = transformTsx(code);
+        strict_1.default.ok(out, 'should transform');
+        strict_1.default.ok(out.includes('arguments[0]'), 'should pass arguments[0] for destructured params');
+    });
+    (0, node_test_1.it)('injects __trickle_rc call at start of function body', () => {
+        const code = `function MyComponent(props) {\n  const x = 1;\n  return null;\n}`;
+        const out = transformTsx(code);
+        strict_1.default.ok(out, 'should transform');
+        // __trickle_rc should appear before body statements
+        const rcIdx = out.indexOf('__trickle_rc');
+        const bodyIdx = out.indexOf('const x = 1');
+        strict_1.default.ok(rcIdx !== -1, '__trickle_rc should be present');
+        strict_1.default.ok(bodyIdx !== -1, 'body code should be present');
+        strict_1.default.ok(rcIdx < bodyIdx, '__trickle_rc should come before body statements');
+    });
+    (0, node_test_1.it)('includes correct component name and line in __trickle_rc call', () => {
+        const code = `function UserCard(props) { return null; }`;
+        const out = transformTsx(code);
+        strict_1.default.ok(out, 'should transform');
+        strict_1.default.ok(out.includes('"UserCard"'), 'should include component name');
+        strict_1.default.ok(out.includes('__trickle_rc("UserCard"'), 'should call with component name');
+    });
+});
+// ── Props capture: arrow function components ──────────────────────────────────
+(0, node_test_1.describe)('Props capture — arrow function components', () => {
+    (0, node_test_1.it)('uses single param name for simple arrow: const C = (props) => {}', () => {
+        const code = `const Dashboard = (props) => { return null; };`;
+        const out = transformTsx(code);
+        strict_1.default.ok(out, 'should transform');
+        strict_1.default.ok(out.includes('__trickle_rc'), 'should inject render tracker');
+        // props should be the param variable, not arguments[0]
+        strict_1.default.ok(out.includes('__trickle_rc("Dashboard"'), 'should use component name');
+        // should NOT use arguments[0] for arrow functions
+        const rcCall = out.match(/__trickle_rc\("Dashboard",[^)]+\)/);
+        strict_1.default.ok(rcCall, 'should have __trickle_rc call');
+        strict_1.default.ok(!rcCall[0].includes('arguments[0]'), 'arrow functions should not use arguments[0]');
+    });
+    (0, node_test_1.it)('reconstructs object for destructured arrow: const C = ({ a, b }) => {}', () => {
+        const code = `const Counter = ({ count, label }) => { return null; };`;
+        const out = transformTsx(code);
+        strict_1.default.ok(out, 'should transform');
+        strict_1.default.ok(out.includes('__trickle_rc'), 'should inject render tracker');
+        // Should reconstruct { count, label }
+        const rcCall = out.match(/__trickle_rc\("Counter",[^,]+,([^)]+)\)/);
+        if (rcCall) {
+            strict_1.default.ok(rcCall[1].includes('count') && rcCall[1].includes('label'), 'should reconstruct props object from destructured fields');
+        }
+    });
+    (0, node_test_1.it)('passes undefined for no-param arrow: const C = () => {}', () => {
+        const code = `const NoProps = () => { return null; };`;
+        const out = transformTsx(code);
+        if (out && out.includes('__trickle_rc')) {
+            strict_1.default.ok(out.includes('undefined'), 'should pass undefined for no-param component');
+        }
+    });
+});
+// ── render count tracking ─────────────────────────────────────────────────────
+(0, node_test_1.describe)('Render count tracking', () => {
+    (0, node_test_1.it)('includes react_render kind in emitted record code', () => {
+        const code = `function Card(props) { return null; }`;
+        const out = transformTsx(code);
+        strict_1.default.ok(out, 'should transform');
+        strict_1.default.ok(out.includes("'react_render'"), 'emitted record should have kind react_render');
+    });
+    (0, node_test_1.it)('includes props data in emitted record', () => {
+        const code = `function Card(props) { return null; }`;
+        const out = transformTsx(code);
+        strict_1.default.ok(out, 'should transform');
+        strict_1.default.ok(out.includes('rec.props'), 'should capture props onto the record');
+        strict_1.default.ok(out.includes('propKeys'), 'should include propKeys');
+    });
+    (0, node_test_1.it)('tracks multiple components in one file', () => {
+        const code = [
+            `function Header(props) { return null; }`,
+            `function Footer(props) { return null; }`,
+            `function helper(x) { return x; }`,
+        ].join('\n');
+        const out = transformTsx(code);
+        strict_1.default.ok(out, 'should transform');
+        strict_1.default.ok(out.includes('"Header"'), 'should track Header');
+        strict_1.default.ok(out.includes('"Footer"'), 'should track Footer');
+        // helper should not be tracked as a component
+        const rcCalls = out.match(/__trickle_rc\("helper"/g);
+        strict_1.default.ok(!rcCalls, 'lowercase helper should not be tracked');
+    });
+});
+// ── findFunctionBodyBrace — destructured params don't confuse brace finding ───
+(0, node_test_1.describe)('Correct function body brace detection', () => {
+    (0, node_test_1.it)('finds body brace even with destructured object params', () => {
+        const code = `function Form({ onSubmit, title }) {\n  const x = 1;\n  return null;\n}`;
+        const out = transformTsx(code);
+        strict_1.default.ok(out, 'should transform');
+        // __trickle_rc should be INSIDE the function body (before 'const x = 1')
+        const rcIdx = out.indexOf('__trickle_rc');
+        const bodyIdx = out.indexOf('const x = 1');
+        strict_1.default.ok(rcIdx < bodyIdx, 'render tracker must be inside the function body, before first statement');
+        // The wrap insertion should be AFTER the closing brace of the function
+        const wrapIdx = out.indexOf('__trickle_wrap');
+        strict_1.default.ok(wrapIdx > bodyIdx, 'function wrap should be after the function body');
+    });
+});

package/dist/wrap.js

@@ -94,6 +94,34 @@ function wrapFunction(fn, opts) {
     // Preserve function name and length
     Object.defineProperty(wrapper, 'name', { value: fn.name || opts.functionName, configurable: true });
     Object.defineProperty(wrapper, 'length', { value: fn.length, configurable: true });
+    // Copy all own properties from original function to wrapper.
+    // This is critical for Express apps (app.get, app.listen, etc.),
+    // class constructors with static methods, and other functions with properties.
+    for (const key of Object.getOwnPropertyNames(fn)) {
+        if (key === 'name' || key === 'length' || key === 'prototype' || key === 'caller' || key === 'arguments')
+            continue;
+        try {
+            const desc = Object.getOwnPropertyDescriptor(fn, key);
+            if (desc)
+                Object.defineProperty(wrapper, key, desc);
+        }
+        catch {
+            // Some properties may not be configurable
+        }
+    }
+    // Also copy symbol properties
+    for (const sym of Object.getOwnPropertySymbols(fn)) {
+        try {
+            const desc = Object.getOwnPropertyDescriptor(fn, sym);
+            if (desc)
+                Object.defineProperty(wrapper, sym, desc);
+        }
+        catch { }
+    }
+    // Copy prototype for constructor functions
+    if (fn.prototype && fn.prototype !== Object.prototype) {
+        wrapper.prototype = fn.prototype;
+    }
     // Mark as wrapped to prevent double-wrapping
     wrapper[TRICKLE_WRAPPED] = true;
     return wrapper;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "trickle-observe",
-  "version": "0.2.110",
+  "version": "0.2.112",
   "description": "Runtime type observability for JavaScript applications",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/express.ts

@@ -205,11 +205,6 @@ function wrapExpressHandler(
       }
     };
 
-    const debug = process.env.TRICKLE_DEBUG === '1';
-    if (debug) {
-      const hs = handler.toString().substring(0, 200);
-      process.stderr.write(`[trickle/express-wrap] Calling handler: ${hs.replace(/\n/g, '\\n')}\n`);
-    }
     try {
       const result = handler.call(this, req, res, wrappedNext);
 

package/src/observe-register.ts

@@ -1041,10 +1041,7 @@ function transformCjsSource(source: string, filename: string, moduleName: string
       lineNo: remapLine(ins.lineNo),
     }));
     if (debug && funcParamInsertions.length > 0) {
-      console.log(`[trickle/observe] Found ${funcParamInsertions.length} function param insertions in ${moduleName}`);
-      for (const ins of funcParamInsertions) {
-        console.log(`  Line ${ins.lineNo}: params=[${ins.paramNames.join(', ')}]`);
-      }
+      console.log(`[trickle/observe] Tracing ${funcParamInsertions.length} function param sites in ${moduleName}`);
     }
   }
 
@@ -1088,7 +1085,7 @@ function transformCjsSource(source: string, filename: string, moduleName: string
 
     prefixLines.push(
       `var __trickle_tv_mod = require(${JSON.stringify(traceVarPath)});`,
-      `var __trickle_tv = function(v, n, l, m, f) { try { __trickle_tv_mod.traceVar(v, n, l, m || ${JSON.stringify(traceModuleName)}, f || ${JSON.stringify(traceFilePath)}); } catch(e){ if (process.env.TRICKLE_DEBUG === '1') console.error('[trickle/tv] Error tracing', n, ':', e && e.message); } };`,
+      `var __trickle_tv = function(v, n, l, m, f) { try { __trickle_tv_mod.traceVar(v, n, l, m || ${JSON.stringify(traceModuleName)}, f || ${JSON.stringify(traceFilePath)}); } catch(e){} };`,
     );
   }
 
@@ -1164,7 +1161,7 @@ function transformCjsSource(source: string, filename: string, moduleName: string
     const calls = paramNames.map(n => `__trickle_tv(${n},${JSON.stringify(n)},${lineNo}${sf})`).join(';');
     allInsertions.push({
       position: bodyStart,
-      code: `\nprocess.stderr.write("[trickle/params] Entering L${lineNo}\\n");try{${calls}}catch(__e3){process.stderr.write('[trickle/params] Error:'+(__e3&&__e3.message)+'\\n')}\n`,
+      code: `\ntry{${calls}}catch(__e3){}\n`,
     });
   }
 
@@ -1181,14 +1178,6 @@ function transformCjsSource(source: string, filename: string, moduleName: string
     result = result.slice(0, position) + code + result.slice(position);
   }
 
-  // Debug: dump transformed source
-  if (debug && funcParamInsertions.length > 0) {
-    try {
-      const debugDir = process.env.TRICKLE_LOCAL_DIR || path.join(process.cwd(), '.trickle');
-      fs.writeFileSync(path.join(debugDir, 'transformed-' + moduleName + '.js'), prefix + result);
-    } catch {}
-  }
-
   return prefix + result;
 }
 

package/src/trace-var.ts

@@ -130,9 +130,6 @@ export function traceVar(
   }
 
   try {
-    if (debugMode) {
-      console.log(`[trickle/vars] traceVar called: ${varName} at ${filePath}:${line} (typeof=${typeof value})`);
-    }
     const type = inferType(value, 3);
 
     // Create a stable hash for dedup
@@ -181,11 +178,8 @@ export function traceVar(
         flushTimer.unref();
       }
     }
-  } catch (err: unknown) {
+  } catch {
     // Never crash user's app
-    if (debugMode) {
-      console.error(`[trickle/vars] Error tracing ${varName}: ${err instanceof Error ? err.message : String(err)}`);
-    }
   }
 }
 

package/src/wrap.ts

@@ -102,6 +102,30 @@ export function wrapFunction<T extends (...args: any[]) => any>(fn: T, opts: Wra
   Object.defineProperty(wrapper, 'name', { value: fn.name || opts.functionName, configurable: true });
   Object.defineProperty(wrapper, 'length', { value: fn.length, configurable: true });
 
+  // Copy all own properties from original function to wrapper.
+  // This is critical for Express apps (app.get, app.listen, etc.),
+  // class constructors with static methods, and other functions with properties.
+  for (const key of Object.getOwnPropertyNames(fn)) {
+    if (key === 'name' || key === 'length' || key === 'prototype' || key === 'caller' || key === 'arguments') continue;
+    try {
+      const desc = Object.getOwnPropertyDescriptor(fn, key);
+      if (desc) Object.defineProperty(wrapper, key, desc);
+    } catch {
+      // Some properties may not be configurable
+    }
+  }
+  // Also copy symbol properties
+  for (const sym of Object.getOwnPropertySymbols(fn)) {
+    try {
+      const desc = Object.getOwnPropertyDescriptor(fn, sym);
+      if (desc) Object.defineProperty(wrapper, sym, desc);
+    } catch {}
+  }
+  // Copy prototype for constructor functions
+  if (fn.prototype && fn.prototype !== Object.prototype) {
+    wrapper.prototype = fn.prototype;
+  }
+
   // Mark as wrapped to prevent double-wrapping
   (wrapper as any)[TRICKLE_WRAPPED] = true;