chore: improve documentation and add bun-git-hooks

Author: cab-mikee

build.ts

@@ -12,7 +12,9 @@ await Bun.build({
   format: 'esm',
   target: 'bun',
   minify: true,
-  plugins: [dts()],
+  plugins: [
+    dts(),
+  ],
 })
 
 // prepare dist for publishing

bun.lock

@@ -2,6 +2,7 @@
 // @ts-nocheck
 // Generated by unplugin-vue-components
 // Read more: https://github.com/vuejs/core/pull/3399
+// biome-ignore lint: disable
 export {}
 
 /* prettier-ignore */

docs/.vitepress/components.d.ts

@@ -60,6 +60,26 @@ const sidebar = [
       { text: 'Config', link: '/config' },
     ],
   },
+  {
+    text: 'Features',
+    items: [
+      { text: 'Overview', link: '/features/' },
+      { text: 'Type Support', link: '/features/type-support' },
+      { text: 'Import Optimization', link: '/features/import-optimization' },
+      { text: 'Type Inference', link: '/features/type-inference' },
+    ],
+  },
+  {
+    text: 'Advanced',
+    items: [
+      { text: 'Overview', link: '/advanced/' },
+      { text: 'Type Processing', link: '/advanced/type-processing' },
+      { text: 'Performance', link: '/advanced/performance' },
+      { text: 'Integration', link: '/advanced/integration' },
+      { text: 'Troubleshooting', link: '/advanced/troubleshooting' },
+    ],
+  },
+  { text: 'API Reference', link: '/api-reference' },
   { text: 'Showcase', link: '/Showcase' },
 ]
 const description = 'Extremely fast & configurable DTS emitter.'

docs/.vitepress/config.ts

@@ -0,0 +1,31 @@
+# Advanced Topics
+
+This section covers advanced topics and techniques for using dtsx effectively.
+
+## Advanced Type Processing
+
+- **Complex Type Inference**: Handling nested and recursive types
+- **Type Relationship Tracking**: Maintaining type relationships across files
+- **Custom Type Transformations**: Advanced type manipulation techniques
+- **Type Augmentation**: Extending existing type definitions
+
+## Performance Optimization
+
+- **Import Optimization Strategies**: Advanced techniques for optimizing imports
+- **Memory Management**: Handling large codebases efficiently
+- **Parallel Processing**: Optimizing multi-file processing
+- **Caching Strategies**: Improving build times with caching
+
+## Integration Patterns
+
+- **Build System Integration**: Integrating with various build tools
+- **CI/CD Integration**: Setting up automated declaration generation
+- **Custom Transformers**: Creating custom type transformers
+- **Plugin System**: Extending dtsx functionality
+
+## Troubleshooting
+
+- **Common Issues**: Solutions to frequent problems
+- **Debugging Techniques**: Advanced debugging strategies
+- **Performance Profiling**: Identifying and fixing performance bottlenecks
+- **Type Resolution**: Handling complex type resolution scenarios

docs/advanced/index.md

@@ -0,0 +1,219 @@
+# Integration
+
+This guide covers how to integrate dtsx with various build tools and development environments.
+
+## Build System Integration
+
+### Vite Integration
+
+```typescript
+// vite.config.ts
+import { defineConfig } from 'vite';
+import dtsx from 'dtsx/vite';
+
+export default defineConfig({
+  plugins: [
+    dtsx({
+      // dtsx configuration
+      root: './src',
+      outdir: './dist',
+      clean: true,
+    }),
+  ],
+});
+```
+
+### Webpack Integration
+
+```typescript
+// webpack.config.js
+const DtsxPlugin = require('dtsx/webpack');
+
+module.exports = {
+  plugins: [
+    new DtsxPlugin({
+      // dtsx configuration
+      root: './src',
+      outdir: './dist',
+      clean: true,
+    }),
+  ],
+};
+```
+
+### Rollup Integration
+
+```typescript
+// rollup.config.js
+import dtsx from 'dtsx/rollup';
+
+export default {
+  plugins: [
+    dtsx({
+      // dtsx configuration
+      root: './src',
+      outdir: './dist',
+      clean: true,
+    }),
+  ],
+};
+```
+
+## CI/CD Integration
+
+### GitHub Actions
+
+```yaml
+# .github/workflows/build.yml
+name: Build
+on: [push, pull_request]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+      - uses: actions/setup-node@v2
+        with:
+          node-version: '18'
+      - run: npm install
+      - run: npm run build
+      - run: npm run generate-dts
+```
+
+### GitLab CI
+
+```yaml
+# .gitlab-ci.yml
+build:
+  image: node:18
+  script:
+    - npm install
+    - npm run build
+    - npm run generate-dts
+```
+
+## Custom Transformers
+
+### Type Transformer
+
+```typescript
+interface TypeTransformer {
+  // Transform type definition
+  transformType(type: TypeDefinition): TypeDefinition;
+  // Transform type reference
+  transformReference(ref: TypeReference): TypeReference;
+  // Transform type usage
+  transformUsage(usage: TypeUsage): TypeUsage;
+}
+
+// Example transformer
+const transformer: TypeTransformer = {
+  transformType(type) {
+    // Transform type definition
+    return type;
+  },
+  transformReference(ref) {
+    // Transform type reference
+    return ref;
+  },
+  transformUsage(usage) {
+    // Transform type usage
+    return usage;
+  },
+};
+```
+
+### Import Transformer
+
+```typescript
+interface ImportTransformer {
+  // Transform import statement
+  transformImport(import: ImportStatement): ImportStatement;
+  // Transform import usage
+  transformUsage(usage: ImportUsage): ImportUsage;
+  // Transform import relationships
+  transformRelationships(relationships: ImportRelationships): ImportRelationships;
+}
+
+// Example transformer
+const transformer: ImportTransformer = {
+  transformImport(import) {
+    // Transform import statement
+    return import;
+  },
+  transformUsage(usage) {
+    // Transform import usage
+    return usage;
+  },
+  transformRelationships(relationships) {
+    // Transform import relationships
+    return relationships;
+  },
+};
+```
+
+## Plugin System
+
+### Plugin Interface
+
+```typescript
+interface DtsxPlugin {
+  // Plugin name
+  name: string;
+  // Plugin version
+  version: string;
+  // Plugin hooks
+  hooks: {
+    // Before processing
+    beforeProcess?: (context: ProcessingContext) => void;
+    // After processing
+    afterProcess?: (context: ProcessingContext) => void;
+    // Before type generation
+    beforeTypeGeneration?: (context: TypeGenerationContext) => void;
+    // After type generation
+    afterTypeGeneration?: (context: TypeGenerationContext) => void;
+  };
+}
+```
+
+### Plugin Configuration
+
+```typescript
+interface PluginConfig {
+  // Plugin name
+  name: string;
+  // Plugin options
+  options: Record<string, unknown>;
+  // Plugin dependencies
+  dependencies?: string[];
+  // Plugin order
+  order?: number;
+}
+```
+
+## Best Practices
+
+1. **Build System Integration**
+   - Use appropriate plugin
+   - Configure correctly
+   - Handle errors
+   - Monitor performance
+
+2. **CI/CD Integration**
+   - Set up automated builds
+   - Configure caching
+   - Handle artifacts
+   - Monitor builds
+
+3. **Custom Transformers**
+   - Keep transformers focused
+   - Handle errors
+   - Document transformations
+   - Test thoroughly
+
+4. **Plugin Development**
+   - Follow plugin interface
+   - Handle dependencies
+   - Document usage
+   - Test thoroughly