bitfab 0.61.0 → 0.61.2

package/dist/transform/bun.d.ts

@@ -0,0 +1,12 @@
+import { B as BitfabTransformOptions } from '../transformOptions-Df2_Chtc.js';
+import { bitfabTraceUnplugin } from './unplugin.js';
+import 'unplugin';
+
+/**
+ * Add experimental Bitfab automatic call tracing to Bun builds and runtime.
+ *
+ * @experimental The generated function identity protocol may change.
+ */
+declare function bitfabBunPlugin(options?: BitfabTransformOptions): ReturnType<typeof bitfabTraceUnplugin.bun>;
+
+export { bitfabBunPlugin as default };

package/dist/transform/bun.js

@@ -0,0 +1,14 @@
+import {
+  bitfabTraceUnplugin
+} from "../chunk-OXFZJP4E.js";
+import "../chunk-PACLPKDH.js";
+import "../chunk-6R33XLNY.js";
+
+// ../bitfab-typescript-transform/src/bunPlugin.ts
+function bitfabBunPlugin(options = {}) {
+  return bitfabTraceUnplugin.bun(options);
+}
+export {
+  bitfabBunPlugin as default
+};
+//# sourceMappingURL=bun.js.map

package/dist/transform/bun.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../bitfab-typescript-transform/src/bunPlugin.ts"],"sourcesContent":["import type { BitfabTransformOptions } from \"./transformOptions.js\"\nimport { bitfabTraceUnplugin } from \"./unplugin.js\"\n\n/**\n * Add experimental Bitfab automatic call tracing to Bun builds and runtime.\n *\n * @experimental The generated function identity protocol may change.\n */\nexport default function bitfabBunPlugin(\n  options: BitfabTransformOptions = {},\n): ReturnType<typeof bitfabTraceUnplugin.bun> {\n  return bitfabTraceUnplugin.bun(options)\n}\n"],"mappings":";;;;;;;AAQe,SAAR,gBACL,UAAkC,CAAC,GACS;AAC5C,SAAO,oBAAoB,IAAI,OAAO;AACxC;","names":[]}

package/dist/transform/esbuild.cjs

@@ -0,0 +1,586 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// ../bitfab-typescript-transform/src/esbuildPlugin.ts
+var esbuildPlugin_exports = {};
+__export(esbuildPlugin_exports, {
+  default: () => bitfabEsbuildPlugin
+});
+module.exports = __toCommonJS(esbuildPlugin_exports);
+
+// ../bitfab-typescript-transform/src/unplugin.ts
+var import_unplugin = require("unplugin");
+
+// ../bitfab-typescript-transform/src/transformOptions.ts
+var AUTO_TRACE_FUNCTION_ID_VERSION = "ts-auto-v1";
+var AUTO_TRACE_TRANSFORM_MARKER = "__bitfab_auto_trace_transformed_v1__";
+function autoTraceFunctionId(file, name) {
+  return `${AUTO_TRACE_FUNCTION_ID_VERSION}:${file}#${name}`;
+}
+function shouldTransformBitfabFile(filename, options) {
+  if (!filename) {
+    return false;
+  }
+  if (options.include && !options.include(filename)) {
+    return false;
+  }
+  const normalized = filename.replace(/\\/g, "/").split(/[?#]/, 1)[0] ?? "";
+  const normalizedCwd = options.cwd?.replace(/\\/g, "/").replace(/\/$/, "");
+  const isAbsolute = normalized.startsWith("/") || /^[A-Za-z]:\//.test(normalized);
+  if (normalizedCwd && isAbsolute && normalized !== normalizedCwd && !normalized.startsWith(`${normalizedCwd}/`)) {
+    return false;
+  }
+  return !normalized.includes("/node_modules/") && !normalized.endsWith(".d.ts") && /\.[cm]?[jt]sx?$/.test(normalized);
+}
+
+// ../bitfab-typescript-transform/src/typescriptTransformer.ts
+var import_typescript = __toESM(require("typescript"), 1);
+function hasUseClientDirective(sourceFile) {
+  return sourceFile.statements.some(
+    (statement) => import_typescript.default.isExpressionStatement(statement) && import_typescript.default.isStringLiteral(statement.expression) && statement.expression.text === "use client"
+  );
+}
+function hasTransformMarker(sourceFile) {
+  return sourceFile.statements.some(
+    (statement) => import_typescript.default.isVariableStatement(statement) && statement.declarationList.declarations.some(
+      (declaration) => import_typescript.default.isIdentifier(declaration.name) && declaration.name.text === AUTO_TRACE_TRANSFORM_MARKER
+    )
+  );
+}
+function isBitfabMemberCall(node, memberName) {
+  return import_typescript.default.isCallExpression(node) && import_typescript.default.isPropertyAccessExpression(node.expression) && node.expression.name.text === memberName;
+}
+function withNodeFunctionName(node) {
+  if (!isBitfabMemberCall(node, "withNode") || node.arguments.length > 2) {
+    return null;
+  }
+  const fn = node.arguments[node.arguments.length - 1];
+  if (import_typescript.default.isIdentifier(fn)) {
+    return fn.text;
+  }
+  if (import_typescript.default.isPropertyAccessExpression(fn)) {
+    return fn.name.text;
+  }
+  if (import_typescript.default.isFunctionExpression(fn) && fn.name) {
+    return fn.name.text;
+  }
+  return null;
+}
+function traceDecorators(node) {
+  if (!import_typescript.default.canHaveDecorators(node)) {
+    return [];
+  }
+  return import_typescript.default.getDecorators(node) ?? [];
+}
+function isTraceDecoratorRoot(node) {
+  return traceDecorators(node).some(
+    (decorator) => isBitfabMemberCall(decorator.expression, "trace")
+  );
+}
+function collectBitfabWrappedFunctions(sourceFile) {
+  const inlineRoots = /* @__PURE__ */ new Set();
+  const referencedRoots = /* @__PURE__ */ new Set();
+  function visit(node) {
+    if (isBitfabMemberCall(node, "withTrace") || isBitfabMemberCall(node, "withSpan")) {
+      const fn = node.arguments[node.arguments.length - 1];
+      if (fn && (import_typescript.default.isArrowFunction(fn) || import_typescript.default.isFunctionExpression(fn))) {
+        inlineRoots.add(fn);
+      } else if (fn && import_typescript.default.isIdentifier(fn)) {
+        referencedRoots.add(fn.text);
+      }
+    }
+    import_typescript.default.forEachChild(node, visit);
+  }
+  visit(sourceFile);
+  return { inlineRoots, referencedRoots };
+}
+function declaredFunctionName(node) {
+  if (node.name && import_typescript.default.isIdentifier(node.name)) {
+    return node.name.text;
+  }
+  if ((import_typescript.default.isArrowFunction(node) || import_typescript.default.isFunctionExpression(node)) && import_typescript.default.isVariableDeclaration(node.parent) && import_typescript.default.isIdentifier(node.parent.name)) {
+    return node.parent.name.text;
+  }
+  if ((import_typescript.default.isArrowFunction(node) || import_typescript.default.isFunctionExpression(node)) && import_typescript.default.isPropertyAssignment(node.parent) && (import_typescript.default.isIdentifier(node.parent.name) || import_typescript.default.isStringLiteral(node.parent.name))) {
+    return node.parent.name.text;
+  }
+  return null;
+}
+function objectContainerName(node) {
+  if (import_typescript.default.isVariableDeclaration(node.parent) && import_typescript.default.isIdentifier(node.parent.name)) {
+    return node.parent.name.text;
+  }
+  if (import_typescript.default.isPropertyAssignment(node.parent) && (import_typescript.default.isIdentifier(node.parent.name) || import_typescript.default.isStringLiteral(node.parent.name))) {
+    return node.parent.name.text;
+  }
+  return null;
+}
+function functionName(node) {
+  const ownName = declaredFunctionName(node);
+  if (ownName) {
+    const scopes = [];
+    let ancestor = node.parent;
+    while (ancestor) {
+      if (isInstrumentableFunction(ancestor)) {
+        const name = declaredFunctionName(ancestor);
+        if (name) {
+          scopes.unshift(name);
+        }
+      } else if ((import_typescript.default.isClassDeclaration(ancestor) || import_typescript.default.isClassExpression(ancestor)) && ancestor.name) {
+        scopes.unshift(ancestor.name.text);
+      } else if (import_typescript.default.isObjectLiteralExpression(ancestor)) {
+        const name = objectContainerName(ancestor);
+        if (name) {
+          scopes.unshift(name);
+        }
+      }
+      ancestor = ancestor.parent;
+    }
+    return [...scopes, ownName].join(".");
+  }
+  const sourceFile = node.getSourceFile();
+  const position = sourceFile.getLineAndCharacterOfPosition(node.getStart());
+  return `anonymous-${position.line + 1}-${position.character}`;
+}
+function isBitfabWrappedFunction(node, inlineRoots, referencedRoots) {
+  if (inlineRoots.has(node)) {
+    return true;
+  }
+  const name = declaredFunctionName(node);
+  return name !== null && referencedRoots.has(name);
+}
+function isInstrumentableFunction(node) {
+  if (!import_typescript.default.isFunctionDeclaration(node) && !import_typescript.default.isFunctionExpression(node) && !import_typescript.default.isArrowFunction(node) && !import_typescript.default.isMethodDeclaration(node)) {
+    return false;
+  }
+  return node.body !== void 0 && node.asteriskToken === void 0 && (!node.name || !import_typescript.default.isPrivateIdentifier(node.name));
+}
+function normalizedFilename(filename, cwd) {
+  const normalized = filename.replace(/\\/g, "/").split(/[?#]/, 1)[0] ?? "";
+  const normalizedCwd = cwd.replace(/\\/g, "/").replace(/\/$/, "");
+  return normalized.startsWith(`${normalizedCwd}/`) ? normalized.slice(normalizedCwd.length + 1) : normalized;
+}
+function parameterInputs(factory, node) {
+  return factory.createArrayLiteralExpression(
+    node.parameters.map((parameter, index) => {
+      if (!import_typescript.default.isArrowFunction(node)) {
+        if (parameter.dotDotDotToken) {
+          return factory.createSpreadElement(
+            factory.createCallExpression(
+              factory.createPropertyAccessExpression(
+                factory.createArrayLiteralExpression([
+                  factory.createSpreadElement(
+                    factory.createIdentifier("arguments")
+                  )
+                ]),
+                "slice"
+              ),
+              void 0,
+              [factory.createNumericLiteral(index)]
+            )
+          );
+        }
+        return factory.createElementAccessExpression(
+          factory.createIdentifier("arguments"),
+          factory.createNumericLiteral(index)
+        );
+      }
+      if (import_typescript.default.isIdentifier(parameter.name)) {
+        const identifier = factory.createIdentifier(parameter.name.text);
+        return parameter.dotDotDotToken ? factory.createSpreadElement(identifier) : identifier;
+      }
+      throw new Error(
+        "Bitfab transform invariant: arrow parameter requires argument wrapper"
+      );
+    })
+  );
+}
+function needsArgumentWrapper(node) {
+  return import_typescript.default.isArrowFunction(node) && node.parameters.some(
+    (parameter) => !import_typescript.default.isIdentifier(parameter.name) || parameter.initializer !== void 0
+  );
+}
+function isRestWrapper(node) {
+  return node.parameters.length === 1 && node.parameters[0]?.dotDotDotToken !== void 0;
+}
+function splitDirectivePrologue(body) {
+  const firstNonDirective = body.statements.findIndex(
+    (statement) => !(import_typescript.default.isExpressionStatement(statement) && import_typescript.default.isStringLiteral(statement.expression))
+  );
+  if (firstNonDirective === -1) {
+    return { directives: body.statements, statements: [] };
+  }
+  return {
+    directives: body.statements.slice(0, firstNonDirective),
+    statements: body.statements.slice(firstNonDirective)
+  };
+}
+function updateFunctionBody(factory, node, body) {
+  if (import_typescript.default.isFunctionDeclaration(node)) {
+    return factory.updateFunctionDeclaration(
+      node,
+      node.modifiers,
+      node.asteriskToken,
+      node.name,
+      node.typeParameters,
+      node.parameters,
+      node.type,
+      body
+    );
+  }
+  if (import_typescript.default.isFunctionExpression(node)) {
+    return factory.updateFunctionExpression(
+      node,
+      node.modifiers,
+      node.asteriskToken,
+      node.name,
+      node.typeParameters,
+      node.parameters,
+      node.type,
+      body
+    );
+  }
+  if (import_typescript.default.isArrowFunction(node)) {
+    return factory.updateArrowFunction(
+      node,
+      node.modifiers,
+      node.typeParameters,
+      node.parameters,
+      node.type,
+      node.equalsGreaterThanToken,
+      body
+    );
+  }
+  if (import_typescript.default.isMethodDeclaration(node)) {
+    return factory.updateMethodDeclaration(
+      node,
+      node.modifiers,
+      node.asteriskToken,
+      node.name,
+      node.questionToken,
+      node.typeParameters,
+      node.parameters,
+      node.type,
+      body
+    );
+  }
+  return node;
+}
+function createBitfabTypeScriptTransformer(options = {}) {
+  return (context) => (sourceFile) => {
+    if (hasUseClientDirective(sourceFile) || hasTransformMarker(sourceFile) || !shouldTransformBitfabFile(sourceFile.fileName, options)) {
+      return sourceFile;
+    }
+    const { factory } = context;
+    const { inlineRoots, referencedRoots } = collectBitfabWrappedFunctions(sourceFile);
+    const runtimeIdentifier = factory.createUniqueName("bitfabAutoSpan");
+    const activeIdentifier = factory.createUniqueName("bitfabAutoTraceActive");
+    const wrapperIdentifier = factory.createUniqueName("bitfabAutoWrap");
+    const transformedNodes = /* @__PURE__ */ new Set();
+    const definitions = [];
+    let usedRuntime = false;
+    let usedWrapper = false;
+    const cwd = options.cwd ?? process.cwd();
+    const file = normalizedFilename(sourceFile.fileName, cwd);
+    const visitor = (node) => {
+      const visited = import_typescript.default.visitEachChild(node, visitor, context);
+      if (import_typescript.default.isCallExpression(node) && import_typescript.default.isCallExpression(visited)) {
+        const configuredName = withNodeFunctionName(node);
+        if (configuredName !== null) {
+          const args = [...visited.arguments];
+          if (args.length === 1) {
+            args.push(factory.createIdentifier("undefined"));
+          }
+          args.push(factory.createStringLiteral(configuredName));
+          return factory.updateCallExpression(
+            visited,
+            visited.expression,
+            visited.typeArguments,
+            args
+          );
+        }
+      }
+      if (!isInstrumentableFunction(node)) {
+        return visited;
+      }
+      if (!isInstrumentableFunction(visited) || transformedNodes.has(visited) || isTraceDecoratorRoot(node) || isBitfabWrappedFunction(node, inlineRoots, referencedRoots)) {
+        return visited;
+      }
+      const name = functionName(node);
+      if (name.startsWith("anonymous-")) {
+        return visited;
+      }
+      const position = sourceFile.getLineAndCharacterOfPosition(node.getStart());
+      const definition = factory.createObjectLiteralExpression(
+        [
+          factory.createPropertyAssignment(
+            "id",
+            factory.createStringLiteral(autoTraceFunctionId(file, name))
+          ),
+          factory.createPropertyAssignment(
+            "name",
+            factory.createStringLiteral(name)
+          ),
+          factory.createPropertyAssignment(
+            "file",
+            factory.createStringLiteral(file)
+          ),
+          factory.createPropertyAssignment(
+            "line",
+            factory.createNumericLiteral(position.line + 1)
+          ),
+          factory.createPropertyAssignment(
+            "column",
+            factory.createNumericLiteral(position.character)
+          ),
+          ...node.modifiers?.some(
+            (modifier) => modifier.kind === import_typescript.default.SyntaxKind.AsyncKeyword
+          ) ? [factory.createPropertyAssignment("async", factory.createTrue())] : [],
+          ...isRestWrapper(node) ? [
+            factory.createPropertyAssignment(
+              "wrapper",
+              factory.createTrue()
+            )
+          ] : []
+        ],
+        false
+      );
+      const definitionIdentifier = factory.createUniqueName(
+        "bitfabAutoDefinition"
+      );
+      definitions.push(
+        factory.createVariableStatement(
+          void 0,
+          factory.createVariableDeclarationList(
+            [
+              factory.createVariableDeclaration(
+                definitionIdentifier,
+                void 0,
+                void 0,
+                definition
+              )
+            ],
+            import_typescript.default.NodeFlags.Const
+          )
+        )
+      );
+      if (needsArgumentWrapper(visited)) {
+        usedRuntime = true;
+        usedWrapper = true;
+        return factory.createCallExpression(wrapperIdentifier, void 0, [
+          definitionIdentifier,
+          visited
+        ]);
+      }
+      const visitedBody = visited.body;
+      const originalBody = import_typescript.default.isBlock(visitedBody) ? visitedBody : factory.createBlock(
+        [factory.createReturnStatement(visitedBody)],
+        true
+      );
+      const { directives, statements } = splitDirectivePrologue(originalBody);
+      const invoke = factory.createArrowFunction(
+        hasAsyncModifier(node) ? [factory.createModifier(import_typescript.default.SyntaxKind.AsyncKeyword)] : void 0,
+        void 0,
+        [],
+        void 0,
+        factory.createToken(import_typescript.default.SyntaxKind.EqualsGreaterThanToken),
+        factory.updateBlock(originalBody, statements)
+      );
+      const body = factory.createBlock(
+        [
+          ...directives,
+          factory.createIfStatement(
+            factory.createCallExpression(activeIdentifier, void 0, []),
+            factory.createBlock(
+              [
+                factory.createReturnStatement(
+                  factory.createCallExpression(runtimeIdentifier, void 0, [
+                    definitionIdentifier,
+                    parameterInputs(factory, visited),
+                    invoke
+                  ])
+                )
+              ],
+              true
+            )
+          ),
+          ...statements
+        ],
+        true
+      );
+      const updated = updateFunctionBody(factory, visited, body);
+      transformedNodes.add(updated);
+      usedRuntime = true;
+      return updated;
+    };
+    const transformed = import_typescript.default.visitEachChild(sourceFile, visitor, context);
+    if (!usedRuntime) {
+      return transformed;
+    }
+    const runtimeImport = factory.createImportDeclaration(
+      void 0,
+      factory.createImportClause(
+        false,
+        void 0,
+        factory.createNamedImports([
+          factory.createImportSpecifier(
+            false,
+            factory.createIdentifier("__bitfabAutoSpan"),
+            runtimeIdentifier
+          ),
+          factory.createImportSpecifier(
+            false,
+            factory.createIdentifier("__bitfabAutoTraceActive"),
+            activeIdentifier
+          ),
+          ...usedWrapper ? [
+            factory.createImportSpecifier(
+              false,
+              factory.createIdentifier("__bitfabAutoWrap"),
+              wrapperIdentifier
+            )
+          ] : []
+        ])
+      ),
+      factory.createStringLiteral(options.runtimeModule ?? "bitfab/auto")
+    );
+    const transformMarker = factory.createVariableStatement(
+      void 0,
+      factory.createVariableDeclarationList(
+        [
+          factory.createVariableDeclaration(
+            factory.createIdentifier(AUTO_TRACE_TRANSFORM_MARKER),
+            void 0,
+            void 0,
+            factory.createAssignment(
+              factory.createPropertyAccessExpression(
+                factory.createIdentifier("globalThis"),
+                factory.createIdentifier(AUTO_TRACE_TRANSFORM_MARKER)
+              ),
+              factory.createTrue()
+            )
+          )
+        ],
+        import_typescript.default.NodeFlags.Const
+      )
+    );
+    return factory.updateSourceFile(transformed, [
+      context.getCompilerOptions().module === import_typescript.default.ModuleKind.CommonJS ? factory.createVariableStatement(
+        void 0,
+        factory.createVariableDeclarationList(
+          [
+            factory.createVariableDeclaration(
+              factory.createObjectBindingPattern([
+                factory.createBindingElement(
+                  void 0,
+                  "__bitfabAutoSpan",
+                  runtimeIdentifier
+                ),
+                factory.createBindingElement(
+                  void 0,
+                  "__bitfabAutoTraceActive",
+                  activeIdentifier
+                ),
+                ...usedWrapper ? [
+                  factory.createBindingElement(
+                    void 0,
+                    "__bitfabAutoWrap",
+                    wrapperIdentifier
+                  )
+                ] : []
+              ]),
+              void 0,
+              void 0,
+              factory.createCallExpression(
+                factory.createIdentifier("require"),
+                void 0,
+                [
+                  factory.createStringLiteral(
+                    options.runtimeModule ?? "bitfab/auto"
+                  )
+                ]
+              )
+            )
+          ],
+          import_typescript.default.NodeFlags.Const
+        )
+      ) : runtimeImport,
+      transformMarker,
+      ...definitions,
+      ...transformed.statements
+    ]);
+  };
+}
+function hasAsyncModifier(node) {
+  return import_typescript.default.canHaveModifiers(node) ? import_typescript.default.getModifiers(node)?.some((modifier) => modifier.kind === import_typescript.default.SyntaxKind.AsyncKeyword) ?? false : false;
+}
+function transformBitfabTypeScriptSource(source, filename, options = {}) {
+  const sourceFilename = filename.replace(/\\/g, "/").split(/[?#]/, 1)[0] ?? filename;
+  const sourceFile = import_typescript.default.createSourceFile(
+    sourceFilename,
+    source,
+    import_typescript.default.ScriptTarget.Latest,
+    true,
+    sourceFilename.endsWith("x") ? import_typescript.default.ScriptKind.TSX : import_typescript.default.ScriptKind.TS
+  );
+  const result = import_typescript.default.transform(sourceFile, [
+    createBitfabTypeScriptTransformer(options)
+  ]);
+  try {
+    return {
+      code: import_typescript.default.createPrinter().printFile(result.transformed[0])
+    };
+  } finally {
+    result.dispose();
+  }
+}
+
+// ../bitfab-typescript-transform/src/unplugin.ts
+var bitfabTraceUnplugin = (0, import_unplugin.createUnplugin)((options) => {
+  const resolvedOptions = options ?? {};
+  return {
+    name: "bitfab-auto-trace",
+    enforce: "pre",
+    transform(source, filename) {
+      if (!shouldTransformBitfabFile(filename, resolvedOptions)) {
+        return null;
+      }
+      return {
+        ...transformBitfabTypeScriptSource(source, filename, resolvedOptions),
+        map: null
+      };
+    }
+  };
+});
+
+// ../bitfab-typescript-transform/src/esbuildPlugin.ts
+function bitfabEsbuildPlugin(options = {}) {
+  return bitfabTraceUnplugin.esbuild(options);
+}
+//# sourceMappingURL=esbuild.cjs.map