bitfab 0.60.1 → 0.61.1

package/dist/transform/nodeLoader.js

@@ -0,0 +1,640 @@
+// ../bitfab-typescript-transform/src/nodeLoader.ts
+import { readFile } from "fs/promises";
+import { createRequire } from "module";
+import { isAbsolute, relative, resolve as resolvePath } from "path";
+import { fileURLToPath, pathToFileURL } from "url";
+
+// ../bitfab-typescript-transform/src/loaderRuntime.ts
+import { dirname } from "path";
+import ts2 from "typescript";
+
+// ../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 isAbsolute2 = normalized.startsWith("/") || /^[A-Za-z]:\//.test(normalized);
+  if (normalizedCwd && isAbsolute2 && 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
+import ts from "typescript";
+function hasUseClientDirective(sourceFile) {
+  return sourceFile.statements.some(
+    (statement) => ts.isExpressionStatement(statement) && ts.isStringLiteral(statement.expression) && statement.expression.text === "use client"
+  );
+}
+function hasTransformMarker(sourceFile) {
+  return sourceFile.statements.some(
+    (statement) => ts.isVariableStatement(statement) && statement.declarationList.declarations.some(
+      (declaration) => ts.isIdentifier(declaration.name) && declaration.name.text === AUTO_TRACE_TRANSFORM_MARKER
+    )
+  );
+}
+function isBitfabMemberCall(node, memberName) {
+  return ts.isCallExpression(node) && ts.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 (ts.isIdentifier(fn)) {
+    return fn.text;
+  }
+  if (ts.isPropertyAccessExpression(fn)) {
+    return fn.name.text;
+  }
+  if (ts.isFunctionExpression(fn) && fn.name) {
+    return fn.name.text;
+  }
+  return null;
+}
+function traceDecorators(node) {
+  if (!ts.canHaveDecorators(node)) {
+    return [];
+  }
+  return ts.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 && (ts.isArrowFunction(fn) || ts.isFunctionExpression(fn))) {
+        inlineRoots.add(fn);
+      } else if (fn && ts.isIdentifier(fn)) {
+        referencedRoots.add(fn.text);
+      }
+    }
+    ts.forEachChild(node, visit);
+  }
+  visit(sourceFile);
+  return { inlineRoots, referencedRoots };
+}
+function declaredFunctionName(node) {
+  if (node.name && ts.isIdentifier(node.name)) {
+    return node.name.text;
+  }
+  if ((ts.isArrowFunction(node) || ts.isFunctionExpression(node)) && ts.isVariableDeclaration(node.parent) && ts.isIdentifier(node.parent.name)) {
+    return node.parent.name.text;
+  }
+  if ((ts.isArrowFunction(node) || ts.isFunctionExpression(node)) && ts.isPropertyAssignment(node.parent) && (ts.isIdentifier(node.parent.name) || ts.isStringLiteral(node.parent.name))) {
+    return node.parent.name.text;
+  }
+  return null;
+}
+function objectContainerName(node) {
+  if (ts.isVariableDeclaration(node.parent) && ts.isIdentifier(node.parent.name)) {
+    return node.parent.name.text;
+  }
+  if (ts.isPropertyAssignment(node.parent) && (ts.isIdentifier(node.parent.name) || ts.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 ((ts.isClassDeclaration(ancestor) || ts.isClassExpression(ancestor)) && ancestor.name) {
+        scopes.unshift(ancestor.name.text);
+      } else if (ts.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 (!ts.isFunctionDeclaration(node) && !ts.isFunctionExpression(node) && !ts.isArrowFunction(node) && !ts.isMethodDeclaration(node)) {
+    return false;
+  }
+  return node.body !== void 0 && node.asteriskToken === void 0 && (!node.name || !ts.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 (!ts.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 (ts.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 ts.isArrowFunction(node) && node.parameters.some(
+    (parameter) => !ts.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) => !(ts.isExpressionStatement(statement) && ts.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 (ts.isFunctionDeclaration(node)) {
+    return factory.updateFunctionDeclaration(
+      node,
+      node.modifiers,
+      node.asteriskToken,
+      node.name,
+      node.typeParameters,
+      node.parameters,
+      node.type,
+      body
+    );
+  }
+  if (ts.isFunctionExpression(node)) {
+    return factory.updateFunctionExpression(
+      node,
+      node.modifiers,
+      node.asteriskToken,
+      node.name,
+      node.typeParameters,
+      node.parameters,
+      node.type,
+      body
+    );
+  }
+  if (ts.isArrowFunction(node)) {
+    return factory.updateArrowFunction(
+      node,
+      node.modifiers,
+      node.typeParameters,
+      node.parameters,
+      node.type,
+      node.equalsGreaterThanToken,
+      body
+    );
+  }
+  if (ts.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 = ts.visitEachChild(node, visitor, context);
+      if (ts.isCallExpression(node) && ts.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 === ts.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
+              )
+            ],
+            ts.NodeFlags.Const
+          )
+        )
+      );
+      if (needsArgumentWrapper(visited)) {
+        usedRuntime = true;
+        usedWrapper = true;
+        return factory.createCallExpression(wrapperIdentifier, void 0, [
+          definitionIdentifier,
+          visited
+        ]);
+      }
+      const visitedBody = visited.body;
+      const originalBody = ts.isBlock(visitedBody) ? visitedBody : factory.createBlock(
+        [factory.createReturnStatement(visitedBody)],
+        true
+      );
+      const { directives, statements } = splitDirectivePrologue(originalBody);
+      const invoke = factory.createArrowFunction(
+        hasAsyncModifier(node) ? [factory.createModifier(ts.SyntaxKind.AsyncKeyword)] : void 0,
+        void 0,
+        [],
+        void 0,
+        factory.createToken(ts.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 = ts.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()
+            )
+          )
+        ],
+        ts.NodeFlags.Const
+      )
+    );
+    return factory.updateSourceFile(transformed, [
+      context.getCompilerOptions().module === ts.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"
+                  )
+                ]
+              )
+            )
+          ],
+          ts.NodeFlags.Const
+        )
+      ) : runtimeImport,
+      transformMarker,
+      ...definitions,
+      ...transformed.statements
+    ]);
+  };
+}
+function hasAsyncModifier(node) {
+  return ts.canHaveModifiers(node) ? ts.getModifiers(node)?.some((modifier) => modifier.kind === ts.SyntaxKind.AsyncKeyword) ?? false : false;
+}
+
+// ../bitfab-typescript-transform/src/loaderRuntime.ts
+var OPTIONS_THAT_ONLY_APPLY_TO_A_WHOLE_PROGRAM = [
+  "composite",
+  "declarationDir",
+  "incremental",
+  "outDir",
+  "rootDir",
+  "rootDirs",
+  "tsBuildInfoFile"
+];
+function readCompilerOptions(filename, configuredPath) {
+  const configPath = configuredPath ?? ts2.findConfigFile(dirname(filename), ts2.sys.fileExists, "tsconfig.json");
+  if (!configPath) {
+    return {};
+  }
+  const config = ts2.readConfigFile(configPath, ts2.sys.readFile);
+  if (config.error) {
+    throw new Error(
+      ts2.flattenDiagnosticMessageText(config.error.messageText, "\n")
+    );
+  }
+  const { options } = ts2.parseJsonConfigFileContent(
+    config.config,
+    ts2.sys,
+    dirname(configPath)
+  );
+  for (const option of OPTIONS_THAT_ONLY_APPLY_TO_A_WHOLE_PROGRAM) {
+    delete options[option];
+  }
+  return options;
+}
+function moduleKindForFormat(filename, format) {
+  if (format === "commonjs" || filename.endsWith(".cts")) {
+    return ts2.ModuleKind.CommonJS;
+  }
+  return ts2.ModuleKind.ESNext;
+}
+function transformBitfabModuleToJavaScript(source, filename, options = {}, format, sourceMapMode = "external") {
+  const { tsconfig, ...transformOptions } = options;
+  if (!shouldTransformBitfabFile(filename, transformOptions)) {
+    return { code: source };
+  }
+  const compilerOptions = readCompilerOptions(filename, tsconfig);
+  const result = ts2.transpileModule(source, {
+    compilerOptions: {
+      ...compilerOptions,
+      allowJs: true,
+      declaration: false,
+      emitDeclarationOnly: false,
+      inlineSourceMap: sourceMapMode === "inline",
+      inlineSources: sourceMapMode === "inline",
+      module: moduleKindForFormat(filename, format),
+      moduleResolution: format === "commonjs" ? ts2.ModuleResolutionKind.Node10 : ts2.ModuleResolutionKind.Bundler,
+      noEmit: false,
+      noEmitOnError: false,
+      sourceMap: sourceMapMode === "external"
+    },
+    fileName: filename,
+    reportDiagnostics: true,
+    transformers: {
+      before: [createBitfabTypeScriptTransformer(transformOptions)]
+    }
+  });
+  const errors = result.diagnostics?.filter(
+    (diagnostic) => diagnostic.category === ts2.DiagnosticCategory.Error
+  );
+  if (errors && errors.length > 0) {
+    throw new Error(
+      ts2.formatDiagnostics(errors, {
+        getCanonicalFileName: (file) => file,
+        getCurrentDirectory: () => process.cwd(),
+        getNewLine: () => "\n"
+      })
+    );
+  }
+  return {
+    code: result.outputText,
+    ...result.sourceMapText ? { map: result.sourceMapText } : {}
+  };
+}
+
+// ../bitfab-typescript-transform/src/nodeLoader.ts
+var runtimeParentURL = process.env.BITFAB_SDK_RESOLVE_FROM === void 0 ? import.meta.url : pathToFileURL(resolvePath(process.env.BITFAB_SDK_RESOLVE_FROM)).href;
+async function resolve(specifier, context, nextResolve) {
+  return specifier === "bitfab:runtime/auto" ? nextResolve("bitfab/auto", {
+    ...context,
+    parentURL: runtimeParentURL
+  }) : nextResolve(specifier, context);
+}
+function runtimeFormat(format, filename) {
+  return format?.startsWith("commonjs") || /\.c(?:js|ts)$/.test(filename) ? "commonjs" : "module";
+}
+function isInsideWorkingDirectory(filename) {
+  const path = relative(process.cwd(), filename);
+  return path !== ".." && !path.startsWith(`..${process.platform === "win32" ? "\\" : "/"}`) && !isAbsolute(path);
+}
+async function load(url, context, nextLoad) {
+  if (!url.startsWith("file:")) {
+    return nextLoad(url, context);
+  }
+  const filename = fileURLToPath(url);
+  if (!isInsideWorkingDirectory(filename) || !shouldTransformBitfabFile(filename, {})) {
+    return nextLoad(url, context);
+  }
+  const source = await readFile(filename, "utf8");
+  const format = runtimeFormat(context.format, filename);
+  const transformed = transformBitfabModuleToJavaScript(
+    source,
+    filename,
+    format === "commonjs" ? {
+      runtimeModule: createRequire(runtimeParentURL).resolve("bitfab/auto")
+    } : { runtimeModule: "bitfab:runtime/auto" },
+    format,
+    "inline"
+  );
+  return {
+    format,
+    shortCircuit: true,
+    source: transformed.code
+  };
+}
+export {
+  load,
+  resolve
+};
+//# sourceMappingURL=nodeLoader.js.map