@dtsx/bun 0.0.0-stage → 0.11.40

package/LICENSE.md

@@ -0,0 +1,21 @@
+# MIT License
+
+Copyright (c) 2024 Open Web Foundation
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,149 @@
-# Temporary Holding Version
+# @dtsx/bun
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+A Bun Bundler plugin for automatic TypeScript declaration file generation using dtsx.
+
+## Installation
+
+```bash
+bun add @dtsx/bun -d
+# or
+npm install @dtsx/bun --save-dev
+```
+
+## Usage
+
+```typescript
+// build.ts
+import { dts } from '@dtsx/bun'
+
+await Bun.build({
+  entrypoints: ['src/index.ts'],
+  outdir: 'dist',
+  plugins: [
+    dts({
+      // Options
+    }),
+  ],
+})
+```
+
+## Options
+
+| Option | Type | Default | Description |
+|--------|------|---------|-------------|
+| `trigger` | `'build' \| 'watch' \| 'both'` | `'build'` | When to generate declarations |
+| `entryPointsOnly` | `boolean` | `true` | Only generate for entry points |
+| `declarationDir` | `string` | Bun outdir | Output directory for declarations |
+| `bundle` | `boolean` | `false` | Bundle all declarations into one file |
+| `bundleOutput` | `string` | `'index.d.ts'` | Bundled output filename |
+| `exclude` | `(string \| RegExp)[]` | `[]` | Patterns to exclude |
+| `include` | `(string \| RegExp)[]` | `[]` | Patterns to include |
+| `emitOnError` | `boolean` | `true` | Emit even with type errors |
+
+## Examples
+
+### Basic Usage
+
+```typescript
+import { dts } from '@dtsx/bun'
+
+await Bun.build({
+  entrypoints: ['src/index.ts'],
+  outdir: 'dist',
+  plugins: [dts()],
+})
+```
+
+### With Bundled Declarations
+
+```typescript
+import { dts } from '@dtsx/bun'
+
+await Bun.build({
+  entrypoints: ['src/index.ts'],
+  outdir: 'dist',
+  plugins: [
+    dts({
+      bundle: true,
+      bundleOutput: 'types.d.ts',
+    }),
+  ],
+})
+```
+
+### Multiple Entry Points
+
+```typescript
+import { dts } from '@dtsx/bun'
+
+await Bun.build({
+  entrypoints: ['src/index.ts', 'src/utils.ts'],
+  outdir: 'dist',
+  plugins: [
+    dts({
+      entryPointsOnly: true,
+    }),
+  ],
+})
+```
+
+### With Callbacks
+
+```typescript
+import { dts } from '@dtsx/bun'
+
+await Bun.build({
+  entrypoints: ['src/index.ts'],
+  outdir: 'dist',
+  plugins: [
+    dts({
+      onStart: () => {
+        console.log('Starting declaration generation...')
+      },
+      onSuccess: (stats) => {
+        console.log(`Generated ${stats.totalFiles} files in ${stats.totalTime}ms`)
+      },
+      onError: (error) => {
+        console.error('Failed to generate declarations:', error.message)
+      },
+    }),
+  ],
+})
+```
+
+### Filter Files
+
+```typescript
+import { dts } from '@dtsx/bun'
+
+await Bun.build({
+  entrypoints: ['src/index.ts'],
+  outdir: 'dist',
+  plugins: [
+    dts({
+      include: [/src\/lib/],
+      exclude: ['test', /\.spec\.ts$/],
+    }),
+  ],
+})
+```
+
+### Custom Output Directory
+
+```typescript
+import { dts } from '@dtsx/bun'
+
+await Bun.build({
+  entrypoints: ['src/index.ts'],
+  outdir: 'dist',
+  plugins: [
+    dts({
+      declarationDir: 'types',
+    }),
+  ],
+})
+```
+
+## License
+
+MIT

package/dist/index.d.ts

@@ -0,0 +1,94 @@
+import type { BunPlugin } from 'bun';
+import type { DtsGenerationOption, GenerationStats } from '@dtsx/dtsx';
+export type { DtsGenerationOption, GenerationStats };
+/**
+ * Creates a Bun plugin for generating TypeScript declaration files
+ * @param options - Configuration options for DTS generation
+ * @returns BunPlugin instance
+ */
+export declare function dts(options?: PluginConfig): BunPlugin;
+/**
+ * Create a watch mode plugin that regenerates on file changes
+ */
+export declare function dtsWatch(options?: PluginConfig): BunPlugin;
+/**
+ * Create a plugin that only validates types without generating
+ */
+export declare function dtsCheck(options: Omit<PluginConfig, 'outdir'>): BunPlugin;
+/**
+ * Clear the incremental cache
+ */
+export declare function clearCache(cacheDir?: string): void;
+/**
+ * Error codes for categorizing plugin errors
+ */
+export declare const PluginErrorCodes: {
+  readonly CONFIG_ERROR: 'CONFIG_ERROR';
+  readonly GENERATION_ERROR: 'GENERATION_ERROR';
+  readonly FILE_ERROR: 'FILE_ERROR';
+  readonly CACHE_ERROR: 'CACHE_ERROR';
+  readonly TIMEOUT_ERROR: 'TIMEOUT_ERROR'
+};
+/**
+ * Build event payload
+ */
+export declare interface BuildEvent {
+  type: BuildEventType
+  timestamp: number
+  data: BuildEventData
+}
+/**
+ * Configuration interface extending DtsGenerationOption with build-specific properties
+ */
+export declare interface PluginConfig extends DtsGenerationOption {
+  build?: {
+    config: {
+      root?: string
+      outdir?: string
+      entrypoints?: string[]
+      target?: 'bun' | 'browser' | 'node'
+    }
+  }
+  onSuccess?: (stats: GenerationStats) => void | Promise<void>
+  onError?: (error: DtsxPluginError) => void | Promise<void>
+  failOnError?: boolean
+  incremental?: boolean
+  cacheDir?: string
+  on?: Partial<Record<BuildEventType, BuildEventListener>>
+  timeout?: number
+  continueOnError?: boolean
+  verbose?: boolean
+}
+export type PluginErrorCode = typeof PluginErrorCodes[keyof typeof PluginErrorCodes];
+/**
+ * Build event types
+ */
+export type BuildEventType = 'start' | 'progress' | 'file' | 'complete' | 'error';
+export type BuildEventData = | { type: 'start', files: string[], config: DtsGenerationOption }
+| { type: 'progress', processed: number, total: number, currentFile: string }
+| { type: 'file', file: string, outputFile: string, duration: number, cached: boolean }
+| { type: 'complete', stats: GenerationStats, duration: number, fromCache: number }
+| { type: 'error', error: DtsxPluginError, file?: string }
+/**
+ * Event listener function
+ */
+export type BuildEventListener = (_event: BuildEvent) => void | Promise<void>;
+/**
+ * Custom error class for bun-plugin-dtsx
+ */
+export declare class DtsxPluginError extends Error {
+  readonly code: PluginErrorCode;
+  readonly context?: Record<string, unknown>;
+  readonly cause?: Error;
+  constructor(message: string, code: PluginErrorCode, context?: Record<string, unknown>, cause?: Error);
+  toJSON(): Record<string, unknown>;
+}
+/**
+ * Event emitter for build events
+ */
+declare class BuildEventEmitter {
+  private listeners;
+  on(type: BuildEventType, listener: BuildEventListener): void;
+  emit(type: BuildEventType, data: BuildEventData): Promise<void>;
+}
+export default dts;

package/dist/index.js

@@ -0,0 +1,267 @@
+// @bun
+// src/index.ts
+import process from "process";
+import { dirname, relative, resolve, sep } from "path";
+import { clearBuildCache } from "@dtsx/dtsx/cache";
+import { generate } from "@dtsx/dtsx/generator";
+var PluginErrorCodes = {
+  CONFIG_ERROR: "CONFIG_ERROR",
+  GENERATION_ERROR: "GENERATION_ERROR",
+  FILE_ERROR: "FILE_ERROR",
+  CACHE_ERROR: "CACHE_ERROR",
+  TIMEOUT_ERROR: "TIMEOUT_ERROR"
+};
+
+class DtsxPluginError extends Error {
+  code;
+  context;
+  cause;
+  constructor(message, code, context, cause) {
+    super(message);
+    this.name = "DtsxPluginError";
+    this.code = code;
+    this.context = context;
+    this.cause = cause;
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, this.constructor);
+    }
+  }
+  toJSON() {
+    return {
+      name: this.name,
+      code: this.code,
+      message: this.message,
+      context: this.context,
+      stack: this.stack
+    };
+  }
+}
+
+class BuildEventEmitter {
+  listeners = new Map;
+  on(type, listener) {
+    const existing = this.listeners.get(type) || [];
+    existing.push(listener);
+    this.listeners.set(type, existing);
+  }
+  async emit(type, data) {
+    const event = {
+      type,
+      timestamp: Date.now(),
+      data
+    };
+    const listeners = this.listeners.get(type) || [];
+    for (const listener of listeners) {
+      await listener(event);
+    }
+  }
+}
+var cleanedOutdirs = new Set;
+function dts(options = {}) {
+  const {
+    onSuccess,
+    onError,
+    failOnError = true,
+    incremental = false,
+    cacheDir = ".dtsx-cache",
+    on,
+    timeout = 60000,
+    continueOnError = false,
+    verbose = false,
+    ...dtsOptions
+  } = options;
+  const emitter = new BuildEventEmitter;
+  if (on) {
+    for (const [type, listener] of Object.entries(on)) {
+      if (listener) {
+        emitter.on(type, listener);
+      }
+    }
+  }
+  return {
+    name: "bun-plugin-dtsx",
+    async setup(build) {
+      const startTime = Date.now();
+      try {
+        const config = normalizeConfig({ ...dtsOptions, incremental, cacheDir }, build);
+        if (config.clean) {
+          const outdirPath = resolve(config.cwd ?? process.cwd(), config.outdir ?? "./dist");
+          if (cleanedOutdirs.has(outdirPath)) {
+            config.clean = false;
+          } else {
+            cleanedOutdirs.add(outdirPath);
+          }
+        }
+        await emitter.emit("start", {
+          type: "start",
+          files: config.entrypoints || [],
+          config
+        });
+        if (verbose) {
+          console.log("[bun-plugin-dtsx] Starting declaration generation...");
+          if (incremental) {
+            console.log("[bun-plugin-dtsx] Incremental mode enabled");
+          }
+        }
+        const generateWithTimeout = async () => {
+          return new Promise((resolvePromise, rejectPromise) => {
+            const timeoutId = setTimeout(() => {
+              rejectPromise(new DtsxPluginError(`Generation timed out after ${timeout}ms`, "TIMEOUT_ERROR", { timeout }));
+            }, timeout);
+            generate(config).then((stats) => {
+              clearTimeout(timeoutId);
+              resolvePromise(stats);
+            }).catch((err) => {
+              clearTimeout(timeoutId);
+              rejectPromise(err);
+            });
+          });
+        };
+        const stats = await generateWithTimeout();
+        const duration = Date.now() - startTime;
+        const fromCache = Math.max(0, stats.filesProcessed - stats.filesGenerated - stats.filesFailed);
+        await emitter.emit("complete", {
+          type: "complete",
+          stats,
+          duration,
+          fromCache
+        });
+        if (verbose) {
+          console.log(`[bun-plugin-dtsx] Generation complete in ${duration}ms`);
+          if (fromCache > 0) {
+            console.log(`[bun-plugin-dtsx] ${fromCache} files served from cache`);
+          }
+        }
+        if (onSuccess) {
+          await onSuccess(stats);
+        }
+      } catch (error) {
+        const pluginError = wrapError(error);
+        await emitter.emit("error", {
+          type: "error",
+          error: pluginError
+        });
+        if (onError) {
+          await onError(pluginError);
+        } else {
+          console.error("[bun-plugin-dtsx] Error generating declarations:");
+          console.error(`  Code: ${pluginError.code}`);
+          console.error(`  Message: ${pluginError.message}`);
+          if (pluginError.context) {
+            console.error(`  Context: ${JSON.stringify(pluginError.context)}`);
+          }
+          if (verbose && pluginError.stack) {
+            console.error(`  Stack: ${pluginError.stack}`);
+          }
+        }
+        if (failOnError && !continueOnError) {
+          throw pluginError;
+        }
+      }
+    }
+  };
+}
+function wrapError(error) {
+  if (error instanceof DtsxPluginError) {
+    return error;
+  }
+  if (error instanceof Error) {
+    let code = "GENERATION_ERROR";
+    if (error.message.includes("config") || error.message.includes("Config")) {
+      code = "CONFIG_ERROR";
+    } else if (error.message.includes("file") || error.message.includes("File") || error.message.includes("ENOENT")) {
+      code = "FILE_ERROR";
+    }
+    return new DtsxPluginError(error.message, code, { originalError: error.name }, error);
+  }
+  return new DtsxPluginError(String(error), "GENERATION_ERROR");
+}
+function commonParentDir(paths) {
+  const dirs = paths.map((p) => dirname(p).split(sep));
+  let common = dirs[0];
+  for (const parts of dirs.slice(1)) {
+    let i = 0;
+    while (i < common.length && i < parts.length && common[i] === parts[i])
+      i++;
+    common = common.slice(0, i);
+  }
+  return common.join(sep) || sep;
+}
+function normalizeConfig(options, build) {
+  const cwd = options.cwd || process.cwd();
+  const bunEntrypoints = build?.config?.entrypoints;
+  const outdir = options.outdir || options.build?.config.outdir || build?.config.outdir || "./dist";
+  let root = options.root || options.build?.config.root || build?.config.root;
+  if (!root && bunEntrypoints?.length) {
+    const ancestor = commonParentDir(bunEntrypoints.map((ep) => resolve(cwd, ep)));
+    root = relative(cwd, ancestor) || ".";
+  }
+  root = root || "./src";
+  let entrypoints = options.entrypoints;
+  if (!entrypoints) {
+    if (bunEntrypoints?.length) {
+      const resolvedRoot = resolve(cwd, root);
+      const inside = [];
+      for (const ep of bunEntrypoints) {
+        const resolved = resolve(cwd, ep);
+        if (resolved === resolvedRoot || resolved.startsWith(resolvedRoot + sep)) {
+          inside.push(relative(resolvedRoot, resolved));
+        } else {
+          console.warn(`[bun-plugin-dtsx] Skipping entrypoint outside root "${root}": ${ep}`);
+        }
+      }
+      entrypoints = inside.length ? inside : ["index.ts"];
+    } else {
+      entrypoints = ["index.ts"];
+    }
+  }
+  return {
+    ...options,
+    cwd,
+    root,
+    entrypoints,
+    outdir,
+    clean: options.clean ?? true,
+    tsconfigPath: options.tsconfigPath,
+    moduleSpecifierMode: options.moduleSpecifierMode ?? ((build?.config.target ?? options.build?.config.target) === "node" ? "node" : "preserve")
+  };
+}
+function dtsWatch(options = {}) {
+  return dts({
+    ...options,
+    incremental: true,
+    verbose: options.verbose ?? true
+  });
+}
+function dtsCheck(options) {
+  return {
+    name: "bun-plugin-dtsx-check",
+    async setup(build) {
+      const config = normalizeConfig({ ...options, outdir: "" }, build);
+      try {
+        await generate({ ...config, clean: false });
+      } catch (error) {
+        const pluginError = wrapError(error);
+        if (options.onError) {
+          await options.onError(pluginError);
+        }
+        if (options.failOnError !== false) {
+          throw pluginError;
+        }
+      }
+    }
+  };
+}
+function clearCache(cacheDir = ".dtsx-cache") {
+  clearBuildCache(resolve(cacheDir));
+}
+var src_default = dts;
+export {
+  DtsxPluginError,
+  PluginErrorCodes,
+  clearCache,
+  src_default as default,
+  dts,
+  dtsCheck,
+  dtsWatch
+};

package/package.json

@@ -1,6 +1,57 @@
 {
   "name": "@dtsx/bun",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "type": "module",
+  "sideEffects": false,
+  "version": "0.11.40",
+  "description": "A Bun Bundler plugin that auto generates your DTS types extremely fast.",
+  "author": "Chris Breuer <chris@ow3.org>",
+  "license": "MIT",
+  "homepage": "https://github.com/stacksjs/dtsx/tree/main/packages/bun-plugin#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/stacksjs/dtsx.git"
+  },
+  "bugs": {
+    "url": "https://github.com/stacksjs/dtsx/issues"
+  },
+  "keywords": [
+    "dts",
+    "dtsx",
+    "emit",
+    "generation",
+    "typescript",
+    "types",
+    "auto",
+    "stacks",
+    "bun",
+    "plugin",
+    "package"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./*": {
+      "import": "./dist/*"
+    }
+  },
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "LICENSE.md",
+    "README.md",
+    "dist"
+  ],
+  "scripts": {
+    "build": "bun build.ts",
+    "prepublishOnly": "bun run build",
+    "test": "bun test",
+    "typecheck": "bun tsc --noEmit",
+    "lint": "bun x --bun pickier .",
+    "lint:fix": "bun x --bun pickier . --fix"
+  },
+  "dependencies": {
+    "@dtsx/dtsx": "0.11.40"
+  }
+}