taist 0.1.11 → 0.1.12

package/lib/transform.js

@@ -30,7 +30,7 @@ export function hasExports(code) {
 /**
  * Find all exports in the source code
  * @param {string} source - Source code
- * @returns {Array<{name: string, type: 'function'|'const'|'class', declaration: string|null}>}
+ * @returns {Array<{name: string, type: 'function'|'const'|'class'|'object', declaration: string|null}>}
  */
 export function findExports(source) {
   const exports = [];
@@ -49,6 +49,16 @@ export function findExports(source) {
     exports.push({ name: match[1], type: "const", declaration: "inline" });
   }
 
+  // Match: export const name = { - object literal exports
+  // Negative lookahead to avoid matching functions/arrows already caught above
+  const objectExportRegex = /export\s+const\s+(\w+)\s*=\s*\{/g;
+  while ((match = objectExportRegex.exec(source)) !== null) {
+    const name = match[1];
+    // Skip if already found as a function/const export
+    if (exports.some(e => e.name === name)) continue;
+    exports.push({ name, type: "object", declaration: "inline" });
+  }
+
   // Match: export class ClassName
   const classExportRegex = /export\s+class\s+(\w+)/g;
   while ((match = classExportRegex.exec(source)) !== null) {
@@ -66,13 +76,14 @@ export function findExports(source) {
       const isFunction = new RegExp(`function\\s+${name}\\s*\\(`).test(source) ||
                          new RegExp(`(const|let|var)\\s+${name}\\s*=\\s*(async\\s*)?\\(`).test(source) ||
                          new RegExp(`(const|let|var)\\s+${name}\\s*=\\s*(async\\s+)?function`).test(source);
+      const isObject = new RegExp(`(const|let|var)\\s+${name}\\s*=\\s*\\{`).test(source);
 
       // Skip if already found as inline export
       if (exports.some(e => e.name === name)) continue;
 
       exports.push({
         name,
-        type: isClass ? "class" : isFunction ? "function" : "unknown",
+        type: isClass ? "class" : isFunction ? "function" : isObject ? "object" : "unknown",
         declaration: "named"
       });
     }
@@ -205,6 +216,19 @@ const __taist_instrumentClass = (cls, name) => {
   }
   return cls;
 };
+const __taist_instrumentObject = (obj, name, visited = new WeakSet()) => {
+  if (!obj || typeof obj !== 'object' || visited.has(obj)) return obj;
+  visited.add(obj);
+  for (const key of Object.keys(obj)) {
+    const value = obj[key];
+    if (typeof value === 'function') {
+      obj[key] = __taist_wrap(value, name + '.' + key);
+    } else if (value && typeof value === 'object' && !Array.isArray(value)) {
+      __taist_instrumentObject(value, name + '.' + key, visited);
+    }
+  }
+  return obj;
+};
 const __taist_module = "${moduleName}";
 // --- END TAIST ---
 
@@ -227,6 +251,20 @@ const __taist_instrumentClass = (cls, name) => {
   __taist.instrument(cls, name);
   return cls;
 };
+const __taist_instrumentObject = (obj, name, visited = new WeakSet()) => {
+  if (!__taist?.options?.enabled) return obj;
+  if (!obj || typeof obj !== 'object' || visited.has(obj)) return obj;
+  visited.add(obj);
+  for (const key of Object.keys(obj)) {
+    const value = obj[key];
+    if (typeof value === 'function') {
+      obj[key] = __taist_wrap(value, name + '.' + key);
+    } else if (value && typeof value === 'object' && !Array.isArray(value)) {
+      __taist_instrumentObject(value, name + '.' + key, visited);
+    }
+  }
+  return obj;
+};
 const __taist_module = "${moduleName}";
 // --- END TAIST ---
 
@@ -246,9 +284,10 @@ const __taist_module = "${moduleName}";
 
   let transformed = shebang + injection + sourceWithoutShebang;
 
-  // Separate classes from functions - classes need different handling to preserve hoisting
+  // Separate exports by type - each needs different handling
   const classExports = exports.filter(e => e.type === "class");
-  const functionExports = exports.filter(e => e.type !== "class");
+  const objectExports = exports.filter(e => e.type === "object");
+  const functionExports = exports.filter(e => e.type !== "class" && e.type !== "object");
 
   // For CLASSES: Keep original export, instrument in-place (preserves hoisting)
   // This avoids TDZ issues with circular dependencies
@@ -355,6 +394,15 @@ const __taist_module = "${moduleName}";
     })
     .join("\n");
 
+  // Add in-place instrumentation for OBJECT LITERALS (wraps nested methods)
+  // __taist_instrumentObject recursively wraps function properties
+  const objectInstrumentations = objectExports
+    .map((exp) => {
+      const nameExpr = `(__taist_module === "${exp.name}" ? "${exp.name}" : __taist_module + ".${exp.name}")`;
+      return `__taist_instrumentObject(${exp.name}, ${nameExpr});`;
+    })
+    .join("\n");
+
   transformed += `\n\n// --- TAIST INSTRUMENTATION ---\n`;
 
   if (functionReexports) {
@@ -365,6 +413,10 @@ const __taist_module = "${moduleName}";
     transformed += `// In-place class instrumentation (preserves hoisting)\n${classInstrumentations}\n`;
   }
 
+  if (objectInstrumentations) {
+    transformed += `// In-place object literal instrumentation (wraps nested methods)\n${objectInstrumentations}\n`;
+  }
+
   // Add default exports at the end (after the wrapped versions are defined)
   for (const name of defaultExports) {
     transformed += `export default ${name};\n`;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "taist",
-  "version": "0.1.11",
+  "version": "0.1.12",
   "description": "Token-Optimized Testing Framework for AI-Assisted Development",
   "main": "index.js",
   "type": "module",