@dtsx/tsup 0.0.0-stage → 0.11.39

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,236 @@
-# Temporary Holding Version
+# @dtsx/tsup
 
-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 tsup plugin for automatic TypeScript declaration file generation using dtsx.
+
+## Supported tsup versions
+
+The plugin supports tsup `>=8.3.6 <8.5.1` and requires `@swc/core` as a peer.
+These dependencies are checked together in strict consumers of the normally
+packed plugin. tsup 8.5.1 and 9.0.0 publish declarations that import a missing
+`./types.cts` file; this range avoids advertising a broken SDK contract.
+The SWC peer supplies the types referenced by tsup 8.5.0's public declarations.
+
+## Installation
+
+```bash
+bun add @dtsx/tsup -d
+# or
+npm install @dtsx/tsup --save-dev
+```
+
+## Usage
+
+### Basic Usage
+
+```typescript
+// tsup.config.ts
+import { defineConfig } from 'tsup'
+import { dtsxPlugin } from '@dtsx/tsup'
+
+export default defineConfig({
+  entry: ['src/index.ts'],
+  format: ['esm', 'cjs'],
+  dts: false, // Disable tsup's dts, use dtsx instead
+  plugins: [
+    dtsxPlugin(),
+  ],
+})
+```
+
+### Using the Helper
+
+```typescript
+// tsup.config.ts
+import { defineConfig } from '@dtsx/tsup'
+
+export default defineConfig({
+  entry: ['src/index.ts'],
+  format: ['esm', 'cjs'],
+  dtsx: {
+    // dtsx options
+    bundle: true,
+  },
+})
+```
+
+### Quick Config
+
+```typescript
+// tsup.config.ts
+import { createTsupConfig } from '@dtsx/tsup'
+
+export default createTsupConfig('src/index.ts', {
+  bundle: true,
+  bundleOutput: 'types.d.ts',
+})
+```
+
+## Options
+
+| Option | Type | Default | Description |
+|--------|------|---------|-------------|
+| `trigger` | `'buildStart' \| 'buildEnd'` | `'buildEnd'` | When to generate declarations |
+| `entryPointsOnly` | `boolean` | `true` | Only generate for entry points |
+| `declarationDir` | `string` | tsup 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 |
+| `skipIfTsupDts` | `boolean` | `true` | Skip if tsup dts is enabled |
+
+## Examples
+
+### With Bundled Declarations
+
+```typescript
+// tsup.config.ts
+import { defineConfig } from 'tsup'
+import { dtsxPlugin } from '@dtsx/tsup'
+
+export default defineConfig({
+  entry: ['src/index.ts'],
+  format: ['esm', 'cjs'],
+  dts: false,
+  plugins: [
+    dtsxPlugin({
+      bundle: true,
+      bundleOutput: 'types.d.ts',
+    }),
+  ],
+})
+```
+
+### Multiple Entry Points
+
+```typescript
+// tsup.config.ts
+import { defineConfig } from 'tsup'
+import { dtsxPlugin } from '@dtsx/tsup'
+
+export default defineConfig({
+  entry: {
+    index: 'src/index.ts',
+    utils: 'src/utils.ts',
+    types: 'src/types.ts',
+  },
+  format: ['esm', 'cjs'],
+  dts: false,
+  plugins: [
+    dtsxPlugin({
+      entryPointsOnly: true,
+    }),
+  ],
+})
+```
+
+### With Callbacks
+
+```typescript
+// tsup.config.ts
+import { defineConfig } from 'tsup'
+import { dtsxPlugin } from '@dtsx/tsup'
+
+export default defineConfig({
+  entry: ['src/index.ts'],
+  format: ['esm'],
+  dts: false,
+  plugins: [
+    dtsxPlugin({
+      onStart: () => {
+        console.log('Starting declaration generation...')
+      },
+      onSuccess: (stats) => {
+        console.log(`Generated ${stats.totalFiles} files in ${stats.totalTime}ms`)
+      },
+      onError: (error) => {
+        console.error('Failed:', error.message)
+      },
+    }),
+  ],
+})
+```
+
+### Generate Before Build
+
+```typescript
+// tsup.config.ts
+import { defineConfig } from 'tsup'
+import { dtsxPlugin } from '@dtsx/tsup'
+
+export default defineConfig({
+  entry: ['src/index.ts'],
+  format: ['esm'],
+  dts: false,
+  plugins: [
+    dtsxPlugin({
+      trigger: 'buildStart', // Generate before build
+    }),
+  ],
+})
+```
+
+### Filter Files
+
+```typescript
+// tsup.config.ts
+import { defineConfig } from 'tsup'
+import { dtsxPlugin } from '@dtsx/tsup'
+
+export default defineConfig({
+  entry: ['src/index.ts'],
+  format: ['esm'],
+  dts: false,
+  plugins: [
+    dtsxPlugin({
+      include: [/src\/lib/],
+      exclude: ['test', /\.spec\.ts$/],
+    }),
+  ],
+})
+```
+
+### Custom Output Directory
+
+```typescript
+// tsup.config.ts
+import { defineConfig } from 'tsup'
+import { dtsxPlugin } from '@dtsx/tsup'
+
+export default defineConfig({
+  entry: ['src/index.ts'],
+  outDir: 'dist',
+  dts: false,
+  plugins: [
+    dtsxPlugin({
+      declarationDir: 'types', // Outputs to types/ instead of dist/
+    }),
+  ],
+})
+```
+
+## Why Use dtsx Instead of tsup's Built-in dts
+
+1. **Faster**: dtsx is optimized for speed and can be significantly faster for large projects
+2. **More Options**: Bundling, filtering, callbacks, and more
+3. **Better Control**: Fine-grained control over declaration generation
+4. **Incremental Support**: Only regenerate changed files
+
+## Compatibility
+
+- tsup 6.x, 7.x, 8.x
+- Node.js 18+
+- Bun 1.0+
+
+## TypeScript Configuration
+
+The plugin automatically detects your `tsconfig.json`. You can also specify a custom path:
+
+```typescript
+dtsxPlugin({
+  tsconfigPath: './tsconfig.build.json',
+})
+```
+
+## License
+
+MIT

package/dist/index.d.ts

@@ -0,0 +1,39 @@
+import type { DtsGenerationOption, GenerationStats } from '@dtsx/dtsx';
+import type { Options as TsupOptions } from 'tsup';
+// Re-export types
+export type { DtsGenerationOption, GenerationStats };
+/**
+ * Create tsup plugin for dtsx declaration generation
+ */
+export declare function dtsxPlugin(options?: DtsxTsupOptions): any;
+/**
+ * Create a preset tsup config with dtsx integration
+ */
+export declare function createTsupConfig(entry: string | string[] | Record<string, string>, options?: DtsxTsupOptions & {
+     
+    tsupOptions?: Partial<TsupOptions>
+  }): TsupOptions;
+/**
+ * Define tsup config with dtsx (helper for tsup.config.ts)
+ */
+export declare function defineConfig(options: TsupOptions & { dtsx?: DtsxTsupOptions }): TsupOptions;
+/**
+ * Plugin configuration options
+ */
+export declare interface DtsxTsupOptions extends Omit<Partial<DtsGenerationOption>, 'exclude' | 'include'> {
+  trigger?: 'buildStart' | 'buildEnd'
+  entryPointsOnly?: boolean
+  declarationDir?: string
+  bundle?: boolean
+  bundleOutput?: string
+  exclude?: (string | RegExp)[]
+  include?: (string | RegExp)[]
+  skipIfTsupDts?: boolean
+  declarationMap?: boolean
+  onSuccess?: (stats: GenerationStats) => void | Promise<void>
+  onError?: (error: Error) => void | Promise<void>
+  onStart?: () => void | Promise<void>
+  onProgress?: (current: number, total: number, file: string) => void
+}
+// Default export
+export default dtsxPlugin;

package/dist/index.js

@@ -0,0 +1,244 @@
+// src/index.ts
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, join, relative, resolve } from "node:path";
+import { generate } from "@dtsx/dtsx";
+var PLUGIN_NAME = "dtsx";
+function dtsxPlugin(options = {}) {
+  const {
+    trigger = "buildEnd",
+    entryPointsOnly = true,
+    declarationDir,
+    bundle: bundleDeclarations = false,
+    bundleOutput = "index.d.ts",
+    exclude = [],
+    include = [],
+    skipIfTsupDts = true,
+    declarationMap = false,
+    onSuccess,
+    onError,
+    onStart,
+    onProgress,
+    ...dtsOptions
+  } = options;
+  const state = {
+    tsupOptions: null,
+    generatedFiles: new Set,
+    errors: []
+  };
+  return {
+    name: PLUGIN_NAME,
+    esbuildOptions(esbuildOptions, context) {
+      state.tsupOptions = context.options;
+    },
+    async buildStart() {
+      if (trigger !== "buildStart")
+        return;
+      if (skipIfTsupDts && state.tsupOptions?.dts) {
+        console.log(`[${PLUGIN_NAME}] Skipping - tsup dts is enabled`);
+        return;
+      }
+      await generateDeclarations();
+    },
+    async buildEnd() {
+      if (trigger !== "buildEnd")
+        return;
+      if (skipIfTsupDts && state.tsupOptions?.dts) {
+        console.log(`[${PLUGIN_NAME}] Skipping - tsup dts is enabled`);
+        return;
+      }
+      await generateDeclarations();
+    }
+  };
+  async function generateDeclarations() {
+    try {
+      await onStart?.();
+      let filesToProcess = getEntryPoints(state.tsupOptions);
+      filesToProcess = filterFiles(filesToProcess, include, exclude);
+      if (filesToProcess.length === 0) {
+        console.log(`[${PLUGIN_NAME}] No files to process`);
+        return;
+      }
+      console.log(`[${PLUGIN_NAME}] Generating declarations for ${filesToProcess.length} file(s)...`);
+      const outdir = declarationDir || state.tsupOptions?.outDir || "dist";
+      const config = normalizeConfig(dtsOptions, state.tsupOptions, outdir);
+      const stats = await generate({
+        ...config,
+        entrypoints: filesToProcess.map((f) => relative(config.cwd || process.cwd(), f))
+      });
+      state.generatedFiles = new Set;
+      if (bundleDeclarations && state.generatedFiles.size > 0) {
+        await bundleDeclarationsFiles(Array.from(state.generatedFiles), join(outdir, bundleOutput));
+      }
+      await onSuccess?.(stats);
+      console.log(`[${PLUGIN_NAME}] Generated ${state.generatedFiles.size} declaration file(s)`);
+    } catch (error) {
+      const err = error instanceof Error ? error : new Error(String(error));
+      state.errors.push(err);
+      if (onError) {
+        await onError(err);
+      } else {
+        console.error(`[${PLUGIN_NAME}] Error generating declarations:`, err.message);
+      }
+    }
+  }
+}
+function getEntryPoints(options) {
+  if (!options?.entry)
+    return [];
+  const entry = options.entry;
+  if (typeof entry === "string") {
+    return [resolve(entry)];
+  }
+  if (Array.isArray(entry)) {
+    return entry.map((e) => resolve(e));
+  }
+  if (typeof entry === "object") {
+    return Object.values(entry).map((e) => resolve(e));
+  }
+  return [];
+}
+function filterFiles(files, include, exclude) {
+  return files.filter((file) => {
+    if (!file.endsWith(".ts") && !file.endsWith(".tsx")) {
+      return false;
+    }
+    if (file.endsWith(".d.ts")) {
+      return false;
+    }
+    for (const pattern of exclude) {
+      if (typeof pattern === "string") {
+        if (file.includes(pattern))
+          return false;
+      } else if (pattern.test(file)) {
+        return false;
+      }
+    }
+    if (include.length > 0) {
+      for (const pattern of include) {
+        if (typeof pattern === "string") {
+          if (file.includes(pattern))
+            return true;
+        } else if (pattern.test(file)) {
+          return true;
+        }
+      }
+      return false;
+    }
+    return true;
+  });
+}
+function normalizeConfig(options, tsupOptions, outdir) {
+  const cwd = options.cwd || process.cwd();
+  let tsconfigPath = options.tsconfigPath || tsupOptions?.tsconfig;
+  if (!tsconfigPath) {
+    const defaultPaths = ["tsconfig.json", "tsconfig.build.json"];
+    for (const p of defaultPaths) {
+      if (existsSync(resolve(cwd, p))) {
+        tsconfigPath = p;
+        break;
+      }
+    }
+  }
+  return {
+    cwd,
+    root: options.root || "./src",
+    outdir,
+    tsconfigPath,
+    clean: options.clean ?? false,
+    keepComments: options.keepComments ?? true,
+    ...options
+  };
+}
+async function bundleDeclarationsFiles(files, outputPath) {
+  const contents = [
+    "/**",
+    " * Bundled TypeScript declarations",
+    ` * Generated by ${PLUGIN_NAME}`,
+    " */",
+    ""
+  ];
+  const imports = new Map;
+  const declarations = [];
+  for (const file of files) {
+    if (!existsSync(file))
+      continue;
+    const content = readFileSync(file, "utf-8");
+    const lines = content.split(`
+`);
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (trimmed.startsWith("import ")) {
+        const match = trimmed.match(/from\s+['"]([^'"]+)['"]/);
+        if (match && !match[1].startsWith(".")) {
+          if (!imports.has(match[1])) {
+            imports.set(match[1], new Set);
+          }
+          const specMatch = trimmed.match(/\{([^}]+)\}/);
+          if (specMatch) {
+            specMatch[1].split(",").forEach((s) => {
+              imports.get(match[1]).add(s.trim());
+            });
+          }
+        }
+        continue;
+      }
+      if (trimmed.startsWith("import ") || trimmed === "")
+        continue;
+      declarations.push(line);
+    }
+  }
+  for (const [source, specifiers] of imports) {
+    if (specifiers.size > 0) {
+      contents.push(`import { ${Array.from(specifiers).join(", ")} } from '${source}';`);
+    }
+  }
+  if (imports.size > 0) {
+    contents.push("");
+  }
+  contents.push(...declarations);
+  const outDir = dirname(outputPath);
+  if (!existsSync(outDir)) {
+    mkdirSync(outDir, { recursive: true });
+  }
+  writeFileSync(outputPath, contents.join(`
+`));
+  console.log(`[${PLUGIN_NAME}] Bundled declarations to ${outputPath}`);
+}
+function createTsupConfig(entry, options = {}) {
+  const { tsupOptions = {}, ...dtsxOptions } = options;
+  return {
+    entry,
+    format: ["esm", "cjs"],
+    splitting: false,
+    sourcemap: true,
+    clean: true,
+    dts: false,
+    esbuildPlugins: [],
+    ...tsupOptions,
+    plugins: [
+      ...tsupOptions.plugins || [],
+      dtsxPlugin(dtsxOptions)
+    ]
+  };
+}
+function defineConfig(options) {
+  const { dtsx: dtsxOptions, ...tsupOptions } = options;
+  if (dtsxOptions) {
+    return {
+      ...tsupOptions,
+      dts: false,
+      plugins: [
+        ...tsupOptions.plugins || [],
+        dtsxPlugin(dtsxOptions)
+      ]
+    };
+  }
+  return tsupOptions;
+}
+var src_default = dtsxPlugin;
+export {
+  createTsupConfig,
+  src_default as default,
+  defineConfig,
+  dtsxPlugin
+};

package/package.json

@@ -1,6 +1,58 @@
 {
   "name": "@dtsx/tsup",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "type": "module",
+  "version": "0.11.39",
+  "description": "A tsup 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/tsup-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",
+    "tsup",
+    "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"
+  },
+  "dependencies": {
+    "@dtsx/dtsx": "0.11.39"
+  },
+  "peerDependencies": {
+    "tsup": ">=8.3.6 <8.5.1",
+    "@swc/core": "^1.16.22"
+  }
+}