@zhin.js/dependency 1.0.1

package/loaders/bun-plugin.ts

@@ -0,0 +1,86 @@
+/**
+ * Bun Plugin
+ * 在 Bun 运行时拦截模块加载，自动转换 import 语句
+ */
+
+import type { BunPlugin } from 'bun';
+import { readFileSync } from 'fs';
+import { transformImports, hasRelativeImports, shouldTransformPath } from './transform-utils.mjs';
+
+/**
+ * 创建 Bun Plugin 配置
+ * 使用环境变量配置：
+ * - DEPENDENCY_TREE_INCLUDE: 需要处理的路径（支持 node_modules）
+ * - DEPENDENCY_TREE_EXCLUDE: 需要排除的路径
+ */
+export function createDependencyTreePlugin(): BunPlugin {
+  return {
+    name: 'dependency-tree-plugin',
+    
+    setup(build) {
+      // 根据环境变量动态构建 filter，避免不必要的文件读取
+      const includePaths = process.env.DEPENDENCY_TREE_INCLUDE;
+      
+      let filter: RegExp;
+      if (includePaths) {
+        // 如果设置了 INCLUDE，构建包含这些路径的 filter
+        const paths = includePaths.split(',').map(p => p.trim());
+        const patterns = paths.map(p => p.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')).join('|');
+        filter = new RegExp(`(${patterns}).*\\.(ts|js)$`);
+      } else {
+        // 默认：只处理非 node_modules 的文件
+        filter = /^(?!.*\/node_modules\/).*\.(ts|js)$/;
+      }
+      
+      build.onLoad({ filter }, async (args) => {
+        const source = readFileSync(args.path, 'utf-8');
+        
+        // 二次检查：使用统一的判断逻辑（支持 EXCLUDE）
+        if (!shouldTransformPath(args.path, ['.ts', '.js'])) {
+          // 不需要处理此文件，返回原始内容
+          return {
+            contents: source,
+            loader: 'ts',
+          };
+        }
+        
+        // 检查是否是热重载（URL 包含时间戳查询参数）
+        // 如果是热重载，强制重新转换以重新注册 hooks
+        const isHotReload = args.path.includes('?');
+        
+        // 检查是否已经转换过或没有相对路径的 import
+        const alreadyTransformed = source.includes('__BUN_PLUGIN_TRANSFORMED__');
+        
+        // 如果不是热重载，且已经转换过或没有相对导入，跳过转换
+        if (!isHotReload && (alreadyTransformed || !hasRelativeImports(source))) {
+          // 返回原始内容，不进行转换
+          return {
+            contents: source,
+            loader: 'ts',
+          };
+        }
+        
+        // 转换相对路径的 import 语句
+        const transformed = transformImports(source, args.path, isHotReload, '__BUN_PLUGIN_TRANSFORMED__');
+        
+        return {
+          contents: transformed,
+          loader: 'ts',
+        };
+      });
+    },
+  };
+}
+
+/**
+ * 默认的 Bun Plugin（保持向后兼容）
+ */
+export const dependencyTreePlugin = createDependencyTreePlugin();
+
+/**
+ * 注册 Bun Plugin
+ */
+export function registerBunPlugin() {
+  // Bun 会自动识别并加载此插件
+  return dependencyTreePlugin;
+}

package/loaders/bun-preload.ts

@@ -0,0 +1,16 @@
+/**
+ * Bun Preload Script
+ * 在 Bun 启动时注册插件
+ */
+
+import { plugin } from 'bun';
+import { createDependencyTreePlugin } from './bun-plugin';
+
+// 创建并注册插件
+// 可以通过环境变量 DEPENDENCY_TREE_INCLUDE 配置需要处理的路径
+// 例如: DEPENDENCY_TREE_INCLUDE="/plugins/,/src/modules/" bun run index.ts
+const dependencyTreePlugin = createDependencyTreePlugin();
+plugin(dependencyTreePlugin);
+
+console.log('✅ Bun plugin registered');
+

package/loaders/register.mjs

@@ -0,0 +1,18 @@
+/**
+ * Universal Loader Registration
+ * 适用于 Node.js 和 tsx
+ * 使用新的 register() API 注册 loader
+ */
+
+import { register } from 'node:module';
+import { pathToFileURL } from 'node:url';
+import { fileURLToPath } from 'node:url';
+import { dirname, join } from 'node:path';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+// 注册通用 loader（tsx-loader 同时支持 .ts 和 .js，适用于两种环境）
+const loaderPath = join(__dirname, 'tsx-loader.mjs');
+register(pathToFileURL(loaderPath), import.meta.url);
+

package/loaders/transform-utils.mjs

@@ -0,0 +1,108 @@
+import pkgJson from '../package.json' with { type: 'json' };
+/**
+ * 通用转换工具
+ * 供 tsx-loader 和 bun-plugin 共享使用
+ */
+
+/**
+ * 检查是否有相对路径的 import
+ */
+export function hasRelativeImports(source) {
+  return /^import\s+['"](\.[^'"]+)['"]/m.test(source);
+}
+
+/**
+ * 转换 import 语句
+ * @param {string} source - 源代码
+ * @param {string} currentPath - 当前文件路径
+ * @param {boolean} isHotReload - 是否为热重载
+ * @param {string} marker - 转换标记（如 '__LOADER_TRANSFORMED__' 或 '__BUN_PLUGIN_TRANSFORMED__'）
+ */
+export function transformImports(source, currentPath, isHotReload = false, marker = '__LOADER_TRANSFORMED__') {
+  // 检查是否有相对路径的 import
+  if (!hasRelativeImports(source) && !isHotReload) {
+    return source;
+  }
+  
+  // 添加标记（热重载时添加时间戳）
+  let result = isHotReload 
+    ? `/* ${marker} (Hot Reload: ${Date.now()}) */\n`
+    : `/* ${marker} */\n`;
+  
+  // 检查是否已有 importModule 导入
+  const hasImportModule = /import.*importModule.*from.*hooks/.test(source);
+  
+  // 如果没有，添加 importModule 导入
+  if (!hasImportModule) {
+    const hooksPath = pkgJson.name;
+    result += `import { importModule } from '${hooksPath}';\n`;
+  }
+  
+  // 转换相对路径的 import
+  // 注意：先转换 source，然后再拼接
+  const transformedSource = source.replace(
+    /^import\s+(['"])(\.[^'"]+)\1;?\s*$/gm,
+    (match, quote, importPath) => {
+      return `await importModule(${quote}${importPath}${quote});`;
+    }
+  );
+  
+  result += transformedSource;
+  
+  return result;
+}
+
+
+/**
+ * 检查文件是否需要处理
+ * 
+ * 环境变量配置：
+ * - DEPENDENCY_TREE_INCLUDE: 需要处理的路径（优先级最高，即使在 node_modules 中也会处理）
+ * - DEPENDENCY_TREE_EXCLUDE: 需要排除的路径（可用于排除特定的 node_modules 包）
+ * 
+ * @example
+ * // 包含 npm 包中的插件
+ * DEPENDENCY_TREE_INCLUDE=node_modules/@my-org/my-plugin/plugins
+ * 
+ * // 包含多个路径
+ * DEPENDENCY_TREE_INCLUDE=src/plugins,node_modules/@my-org/plugin1,node_modules/@my-org/plugin2
+ * 
+ * // 排除特定路径（与默认的 node_modules 排除结合使用）
+ * DEPENDENCY_TREE_EXCLUDE=node_modules/some-lib
+ */
+export function shouldTransformPath(path, extensions = ['.ts', '.js']) {
+  // 去除查询参数（如 ?t=timestamp）
+  const [actualPath] = path.split('?');
+  
+  // 检查扩展名
+  const hasValidExtension = extensions.some(ext => actualPath.endsWith(ext));
+  if (!hasValidExtension) {
+    return false;
+  }
+  
+  // 1. 检查 INCLUDE 路径（优先级最高，即使在 node_modules 中也处理）
+  const includePaths = process.env.DEPENDENCY_TREE_INCLUDE;
+  if (includePaths) {
+    const paths = includePaths.split(',').map(p => p.trim());
+    if (paths.some(p => actualPath.includes(p))) {
+      return true; // 明确包含，直接返回 true
+    }
+  }
+  
+  // 2. 检查 EXCLUDE 路径（优先级第二）
+  const excludePaths = process.env.DEPENDENCY_TREE_EXCLUDE;
+  if (excludePaths) {
+    const paths = excludePaths.split(',').map(p => p.trim());
+    if (paths.some(p => actualPath.includes(p))) {
+      return false; // 明确排除
+    }
+  }
+  
+  // 3. 默认规则：排除所有 node_modules，除非明确 INCLUDE
+  if (actualPath.includes('/node_modules/')) {
+    return false;
+  }
+  
+  return true;
+}
+

package/loaders/tsx-loader.mjs

@@ -0,0 +1,68 @@
+/**
+ * tsx Loader Hook
+ * 在 tsx 运行时拦截模块加载，自动转换 import 语句
+ */
+
+import { readFileSync } from 'fs';
+import { fileURLToPath } from 'url';
+import { transformImports, hasRelativeImports, shouldTransformPath } from './transform-utils.mjs';
+
+// 当前正在加载的依赖栈
+const dependencyStack = [];
+
+/**
+ * resolve hook
+ */
+export async function resolve(specifier, context, nextResolve) {
+  return nextResolve(specifier, context);
+}
+
+/**
+ * 检查文件是否需要处理
+ */
+function shouldTransform(url) {
+  return shouldTransformPath(url, ['.ts', '.js']);
+}
+
+/**
+ * load hook - 拦截模块加载并转换代码
+ */
+export async function load(url, context, nextLoad) {
+  // 检查是否需要处理此文件
+  if (shouldTransform(url)) {
+    try {
+      // 检查是否是热重载（URL 包含时间戳查询参数）
+      const isHotReload = url.includes('?t=');
+      
+      // 从 URL 中分离实际路径
+      const [actualUrl] = url.split('?');
+      const filePath = fileURLToPath(actualUrl);
+      let source = readFileSync(filePath, 'utf-8');
+      
+      // 检查是否已经转换过（热重载时强制重新转换）
+      if (!isHotReload && source.includes('__LOADER_TRANSFORMED__')) {
+        return nextLoad(url, context);
+      }
+      
+      // 检查是否有相对路径的 import 需要转换
+      if (!isHotReload && !hasRelativeImports(source)) {
+        return nextLoad(url, context);
+      }
+      
+      // 转换相对路径的 import 语句
+      const transformed = transformImports(source, actualUrl, isHotReload, '__LOADER_TRANSFORMED__');
+      
+      return {
+        format: 'module',
+        source: transformed,
+        shortCircuit: true,
+      };
+    } catch (error) {
+      console.error('Loader error:', error);
+      return nextLoad(url, context);
+    }
+  }
+  
+  // 其他文件使用默认加载
+  return nextLoad(url, context);
+}

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "@zhin.js/dependency",
+  "version": "1.0.1",
+  "description": "A TypeScript dependency tree analyzer with ESM support",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./register.mjs": "./loaders/register.mjs",
+    "./tsx-loader.mjs": "./loaders/tsx-loader.mjs",
+    "./bun-plugin": "./loaders/bun-plugin.ts",
+    "./bun-preload.ts": "./loaders/bun-preload.ts"
+  },
+  "files": [
+    "dist",
+    "loaders",
+    "README.md"
+  ],
+  "keywords": [
+    "dependency",
+    "tree",
+    "module",
+    "import",
+    "loader",
+    "typescript",
+    "esm"
+  ],
+  "author": "",
+  "license": "ISC",
+  "devDependencies": {
+    "@types/node": "^20.10.0",
+    "@types/bun": "^1.2.0",
+    "typescript": "^5.3.0"
+  },
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "clean": "rm -rf dist",
+    "type-check": "tsc --noEmit"
+  }
+}