@adonisjs/assembler 8.0.0-next.6 → 8.0.0-next.8

package/build/src/hooks.d.ts

@@ -0,0 +1,224 @@
+import { type AsyncOrSync } from '@poppinss/utils/types';
+import { type HookParams } from './types/hooks.ts';
+/**
+ * Collection of hooks that can be used to listen for various events during
+ * the application lifecycle. These hooks allow you to execute custom logic
+ * at specific points in the development server, build process, and testing.
+ *
+ * @example
+ * ```js
+ * const { hooks } = await import('@adonisjs/assembler/hooks')
+ *
+ * hooks.init((app) => {
+ *   console.log('Application initialized')
+ * })
+ *
+ * hooks.devServerStarted((server) => {
+ *   console.log('Dev server started on port', server.port)
+ * })
+ * ```
+ */
+export declare const hooks: {
+    /**
+     * Hook called during application initialization. This is the first hook
+     * that gets executed when the assembler starts up.
+     *
+     * @param callback - Function to execute when the init event occurs
+     *
+     * @example
+     * ```js
+     * hooks.init((app) => {
+     *   console.log('Application is initializing')
+     *   // Setup global configurations
+     * })
+     * ```
+     */
+    init(callback: (...args: HookParams<"init">) => AsyncOrSync<void>): (parent: import("./dev_server.ts").DevServer | import("./test_runner.ts").TestRunner | import("./bundler.ts").Bundler, indexGenerator: import("./index_generator/main.ts").IndexGenerator) => AsyncOrSync<void>;
+    /**
+     * Hook called after routes have been committed to the router.
+     * This occurs after all route definitions have been processed.
+     *
+     * @param callback - Function to execute when routes are committed
+     *
+     * @example
+     * ```js
+     * hooks.routesCommitted((router) => {
+     *   console.log('All routes have been committed to the router')
+     *   // Perform route-based setup
+     * })
+     * ```
+     */
+    routesCommitted(callback: (...args: HookParams<"routesCommitted">) => AsyncOrSync<void>): (parent: import("./dev_server.ts").DevServer, routes: Record<string, import("./types/code_scanners.ts").RoutesListItem[]>) => AsyncOrSync<void>;
+    /**
+     * Hook called when the assembler starts scanning for route files.
+     * This happens before any route files are actually processed.
+     *
+     * @param callback - Function to execute when route scanning begins
+     *
+     * @example
+     * ```js
+     * hooks.routesScanning(() => {
+     *   console.log('Starting to scan for route files')
+     *   // Setup route scanning configurations
+     * })
+     * ```
+     */
+    routesScanning(callback: (...args: HookParams<"routesScanning">) => AsyncOrSync<void>): (parent: import("./dev_server.ts").DevServer, routesScanner: import("./code_scanners/routes_scanner/main.ts").RoutesScanner) => AsyncOrSync<void>;
+    /**
+     * Hook called after all route files have been scanned and processed.
+     * This occurs once the route scanning phase is complete.
+     *
+     * @param callback - Function to execute when route scanning is finished
+     *
+     * @example
+     * ```js
+     * hooks.routesScanned((scannedRoutes) => {
+     *   console.log('Route scanning completed')
+     *   // Process scanned route information
+     * })
+     * ```
+     */
+    routesScanned(callback: (...args: HookParams<"routesScanned">) => AsyncOrSync<void>): (parent: import("./dev_server.ts").DevServer, routesScanner: import("./code_scanners/routes_scanner/main.ts").RoutesScanner) => AsyncOrSync<void>;
+    /**
+     * Hook called when a file is modified during development.
+     * This is triggered by the file watcher when changes are detected.
+     *
+     * @param callback - Function to execute when a file changes
+     *
+     * @example
+     * ```js
+     * hooks.fileChanged((filePath, stats) => {
+     *   console.log(`File changed: ${filePath}`)
+     *   // Handle file change logic
+     * })
+     * ```
+     */
+    fileChanged(callback: (...args: HookParams<"fileChanged">) => AsyncOrSync<void>): (relativePath: string, absolutePath: string, info: {
+        source: "hot-hook" | "watcher";
+        hotReloaded: boolean;
+        fullReload: boolean;
+    }, parent: import("./dev_server.ts").DevServer | import("./test_runner.ts").TestRunner) => AsyncOrSync<void>;
+    /**
+     * Hook called when a new file is added during development.
+     * This is triggered by the file watcher when new files are created.
+     *
+     * @param callback - Function to execute when a file is added
+     *
+     * @example
+     * ```js
+     * hooks.fileAdded((filePath, stats) => {
+     *   console.log(`New file added: ${filePath}`)
+     *   // Handle new file logic
+     * })
+     * ```
+     */
+    fileAdded(callback: (...args: HookParams<"fileAdded">) => AsyncOrSync<void>): (relativePath: string, absolutePath: string, server: import("./dev_server.ts").DevServer | import("./test_runner.ts").TestRunner) => AsyncOrSync<void>;
+    /**
+     * Hook called when a file is removed during development.
+     * This is triggered by the file watcher when files are deleted.
+     *
+     * @param callback - Function to execute when a file is removed
+     *
+     * @example
+     * ```js
+     * hooks.fileRemoved((filePath) => {
+     *   console.log(`File removed: ${filePath}`)
+     *   // Handle file removal logic
+     * })
+     * ```
+     */
+    fileRemoved(callback: (...args: HookParams<"fileRemoved">) => AsyncOrSync<void>): (relativePath: string, absolutePath: string, server: import("./dev_server.ts").DevServer | import("./test_runner.ts").TestRunner) => AsyncOrSync<void>;
+    /**
+     * Hook called when the development server is about to start.
+     * This occurs before the server begins listening for connections.
+     *
+     * @param callback - Function to execute when dev server is starting
+     *
+     * @example
+     * ```js
+     * hooks.devServerStarting((server) => {
+     *   console.log('Development server is starting')
+     *   // Setup server configurations
+     * })
+     * ```
+     */
+    devServerStarting(callback: (...args: HookParams<"devServerStarting">) => AsyncOrSync<void>): (server: import("./dev_server.ts").DevServer) => AsyncOrSync<void>;
+    /**
+     * Hook called after the development server has successfully started.
+     * This occurs once the server is listening and ready to accept requests.
+     *
+     * @param callback - Function to execute when dev server has started
+     *
+     * @example
+     * ```js
+     * hooks.devServerStarted((server) => {
+     *   console.log(`Development server started on port ${server.port}`)
+     *   // Notify external services or open browser
+     * })
+     * ```
+     */
+    devServerStarted(callback: (...args: HookParams<"devServerStarted">) => AsyncOrSync<void>): (server: import("./dev_server.ts").DevServer, info: {
+        port: number;
+        host: string;
+    }, uiInstructions: import("@poppinss/cliui").Instructions) => AsyncOrSync<void>;
+    /**
+     * Hook called when the build process is about to start.
+     * This occurs before any build tasks are executed.
+     *
+     * @param callback - Function to execute when build is starting
+     *
+     * @example
+     * ```js
+     * hooks.buildStarting((buildConfig) => {
+     *   console.log('Build process is starting')
+     *   // Setup build configurations or clean directories
+     * })
+     * ```
+     */
+    buildStarting(callback: (...args: HookParams<"buildStarting">) => AsyncOrSync<void>): (server: import("./bundler.ts").Bundler) => AsyncOrSync<void>;
+    /**
+     * Hook called after the build process has completed.
+     * This occurs once all build tasks have finished executing.
+     *
+     * @param callback - Function to execute when build is finished
+     *
+     * @example
+     * ```js
+     * hooks.buildFinished((buildResult) => {
+     *   console.log('Build process completed')
+     *   // Deploy artifacts or notify build completion
+     * })
+     * ```
+     */
+    buildFinished(callback: (...args: HookParams<"buildFinished">) => AsyncOrSync<void>): (server: import("./bundler.ts").Bundler, uiInstructions: import("@poppinss/cliui").Instructions) => AsyncOrSync<void>;
+    /**
+     * Hook called when the test suite is about to start.
+     * This occurs before any test files are executed.
+     *
+     * @param callback - Function to execute when tests are starting
+     *
+     * @example
+     * ```js
+     * hooks.testsStarting((testConfig) => {
+     *   console.log('Test suite is starting')
+     *   // Setup test database or mock services
+     * })
+     * ```
+     */
+    testsStarting(callback: (...args: HookParams<"testsStarting">) => AsyncOrSync<void>): (server: import("./test_runner.ts").TestRunner) => AsyncOrSync<void>;
+    /**
+     * Hook called after the test suite has completed.
+     * This occurs once all test files have finished executing.
+     *
+     * @param callback - Function to execute when tests are finished
+     *
+     * @example
+     * ```js
+     * hooks.testsFinished((testResults) => {
+     *   console.log('Test suite completed')
+     *   // Generate test reports or cleanup test resources
+     * })
+     * ```
+     */
+    testsFinished(callback: (...args: HookParams<"testsFinished">) => AsyncOrSync<void>): (server: import("./test_runner.ts").TestRunner) => AsyncOrSync<void>;
+};

package/build/src/index_generator/main.d.ts

@@ -19,6 +19,10 @@ import { type IndexGeneratorSourceConfig } from '../types/common.ts';
  */
 export declare class IndexGenerator {
     #private;
+    /**
+     * The application root directory path
+     */
+    appRoot: string;
     /**
      * Create a new IndexGenerator instance
      *
@@ -26,15 +30,6 @@ export declare class IndexGenerator {
      * @param cliLogger - Logger instance for CLI output
      */
     constructor(appRoot: string, cliLogger: Logger);
-    /**
-     * Set the logger instance used for CLI output
-     *
-     * Updates the CLI logger instance for this index generator and all
-     * registered sources to use the new logger for output.
-     *
-     * @param cliLogger - New logger instance to use
-     */
-    setLogger(cliLogger: Logger): void;
     /**
      * Add a new index generator source
      *

package/build/src/index_generator/main.js

@@ -1,7 +1,7 @@
 import {
   IndexGenerator
-} from "../../chunk-MC3FJR62.js";
-import "../../chunk-F4RAGKQN.js";
+} from "../../chunk-N6H4XTTC.js";
+import "../../chunk-PORDZS62.js";
 export {
   IndexGenerator
 };

package/build/src/index_generator/source.d.ts

@@ -32,12 +32,6 @@ export declare class IndexGeneratorSource {
      * @param config - Configuration for this index generator source
      */
     constructor(name: string, appRoot: string, cliLogger: Logger, config: IndexGeneratorSourceConfig);
-    /**
-     * Set the logger instance used for CLI output
-     *
-     * @param cliLogger - New logger instance to use
-     */
-    setLogger(cliLogger: Logger): void;
     /**
      * Add a file to the virtual file system and regenerate index if needed
      *

package/build/src/test_runner.d.ts

@@ -1,5 +1,4 @@
 import type tsStatic from 'typescript';
-import { cliui } from '@poppinss/cliui';
 import type { TestRunnerOptions } from './types/common.ts';
 /**
  * Exposes the API to run Japa tests and optionally watch for file
@@ -27,13 +26,29 @@ import type { TestRunnerOptions } from './types/common.ts';
 export declare class TestRunner {
     #private;
     /**
-     * CLI UI instance to log colorful messages and progress information
+     * CLI UI instance for displaying colorful messages and progress information
      */
-    get ui(): ReturnType<typeof cliui>;
-    /**
-     * CLI UI instance to log colorful messages and progress information
-     */
-    set ui(ui: ReturnType<typeof cliui>);
+    ui: {
+        colors: import("@poppinss/colors/types").Colors;
+        logger: import("@poppinss/cliui").Logger;
+        table: (tableOptions?: Partial<import("@poppinss/cliui/types").TableOptions>) => import("@poppinss/cliui").Table;
+        tasks: (tasksOptions?: Partial<import("@poppinss/cliui/types").TaskManagerOptions>) => import("@poppinss/cliui").TaskManager;
+        icons: {
+            tick: string;
+            cross: string;
+            bullet: string;
+            nodejs: string;
+            pointer: string;
+            info: string;
+            warning: string;
+            squareSmallFilled: string;
+        };
+        sticker: () => import("@poppinss/cliui").Instructions;
+        instructions: () => import("@poppinss/cliui").Instructions;
+        switchMode(modeToUse: "raw" | "silent" | "normal"): void;
+        useRenderer(rendererToUse: import("@poppinss/cliui/types").RendererContract): void;
+        useColors(colorsToUse: import("@poppinss/colors/types").Colors): void;
+    };
     /**
      * The script file to run as a child process
      */
@@ -42,6 +57,10 @@ export declare class TestRunner {
      * The current working directory URL
      */
     cwd: URL;
+    /**
+     * The current working directory path as a string
+     */
+    cwdPath: string;
     /**
      * Test runner configuration options including filters, reporters, and hooks
      */

package/build/src/types/common.d.ts

@@ -1,8 +1,9 @@
 import type { Logger } from '@poppinss/cliui';
 import { type Prettify } from '@poppinss/utils/types';
+import type StringBuilder from '@poppinss/utils/string_builder';
+import { type AllHooks } from './hooks.ts';
 import { type FileBuffer } from '../file_buffer.ts';
 import { type VirtualFileSystem } from '../virtual_file_system.ts';
-import { type CommonHooks, type RouterHooks, type BundlerHooks, type WatcherHooks, type DevServerHooks, type TestRunnerHooks } from './hooks.ts';
 /**
  * Recursive file tree structure for representing nested directory hierarchies
  */
@@ -22,8 +23,11 @@ export type IndexGeneratorSourceConfig = ({
     exportName: string;
     as: 'barrelFile';
 } | {
-    as: (vfs: VirtualFileSystem, buffer: FileBuffer, config: IndexGeneratorSourceConfig) => void;
+    as: (vfs: VirtualFileSystem, buffer: FileBuffer, config: IndexGeneratorSourceConfig, helpers: {
+        toImportPath(filePath: string): string;
+    }) => void;
 }) & {
+    computeBaseName?: (baseName: StringBuilder) => StringBuilder;
     source: string;
     output: string;
     glob?: string[];
@@ -121,7 +125,7 @@ export type AssemblerRcFile = {
     /**
      * Hooks to execute at different stages of development and build processes
      */
-    hooks?: Partial<CommonHooks & WatcherHooks & DevServerHooks & BundlerHooks & TestRunnerHooks & RouterHooks>;
+    hooks?: Partial<AllHooks>;
     /**
      * An array of test suites configuration
      */

package/build/src/types/hooks.d.ts

@@ -4,8 +4,27 @@ import { type Bundler } from '../bundler.ts';
 import { type DevServer } from '../dev_server.ts';
 import { type TestRunner } from '../test_runner.ts';
 import { type RoutesListItem } from './code_scanners.ts';
-import { type RoutesScanner } from '../code_scanners/routes_scanner/main.ts';
 import { type IndexGenerator } from '../index_generator/main.ts';
+import { type RoutesScanner } from '../code_scanners/routes_scanner/main.ts';
+/**
+ * Defines a hook that can be either a lazy import or an object with a run method.
+ * This type provides flexibility in how hooks are defined and imported, supporting
+ * both dynamic imports for code splitting and direct object definitions.
+ *
+ * @template Fn - The function signature that the hook must conform to
+ *
+ * @example
+ * // Using lazy import
+ * const hook: DefineHook<(server: DevServer) => void> = () => import('./my-hook')
+ *
+ * // Using direct object
+ * const hook: DefineHook<(server: DevServer) => void> = {
+ *   run: (server) => console.log('Hook executed')
+ * }
+ */
+type DefineHook<Fn extends (...args: any) => any> = LazyImport<Fn> | {
+    run: Fn;
+};
 /**
  * Common hooks executed by the dev-server, test runner and the bundler.
  * These hooks are shared across all assembler operations and provide
@@ -26,7 +45,7 @@ export type CommonHooks = {
      *
      * @param parent - The parent instance (DevServer, TestRunner, or Bundler)
      */
-    init: LazyImport<(parent: DevServer | TestRunner | Bundler, indexGenerator: IndexGenerator) => AsyncOrSync<void>>[];
+    init: DefineHook<(parent: DevServer | TestRunner | Bundler, indexGenerator: IndexGenerator) => AsyncOrSync<void>>[];
 };
 /**
  * Hooks executed by the dev server around the router.
@@ -53,7 +72,7 @@ export type RouterHooks = {
      * @param parent - The DevServer instance
      * @param routes - Record of routes grouped by domain or method
      */
-    routesCommitted: LazyImport<(parent: DevServer, routes: Record<string, RoutesListItem[]>) => AsyncOrSync<void>>[];
+    routesCommitted: DefineHook<(parent: DevServer, routes: Record<string, RoutesListItem[]>) => AsyncOrSync<void>>[];
     /**
      * The hook is executed when dev server begins the routes scanning process.
      * Use this hook to prepare for route scanning or modify scanner configuration.
@@ -61,7 +80,7 @@ export type RouterHooks = {
      * @param parent - The DevServer instance
      * @param routesScanner - The RoutesScanner instance being used
      */
-    routesScanning: LazyImport<(parent: DevServer, routesScanner: RoutesScanner) => AsyncOrSync<void>>[];
+    routesScanning: DefineHook<(parent: DevServer, routesScanner: RoutesScanner) => AsyncOrSync<void>>[];
     /**
      * The hook is executed when routes scanning process has finished.
      * Use this hook to process the scanned routes or clean up resources.
@@ -69,7 +88,7 @@ export type RouterHooks = {
      * @param parent - The DevServer instance
      * @param routesScanner - The RoutesScanner instance that was used
      */
-    routesScanned: LazyImport<(parent: DevServer, routesScanner: RoutesScanner) => AsyncOrSync<void>>[];
+    routesScanned: DefineHook<(parent: DevServer, routesScanner: RoutesScanner) => AsyncOrSync<void>>[];
 };
 /**
  * Hooks executed by the file watcher during development and testing.
@@ -103,7 +122,7 @@ export type WatcherHooks = {
      * @param info.fullReload - Whether a full server reload is required
      * @param parent - The parent DevServer or TestRunner instance
      */
-    fileChanged: LazyImport<(relativePath: string, absolutePath: string, info: {
+    fileChanged: DefineHook<(relativePath: string, absolutePath: string, info: {
         /** Source of the file change notification */
         source: 'hot-hook' | 'watcher';
         /** Whether the file was hot reloaded without server restart */
@@ -118,7 +137,7 @@ export type WatcherHooks = {
      * @param filePath - The absolute path to the added file
      * @param server - The DevServer or TestRunner instance
      */
-    fileAdded: LazyImport<(relativePath: string, absolutePath: string, server: DevServer | TestRunner) => AsyncOrSync<void>>[];
+    fileAdded: DefineHook<(relativePath: string, absolutePath: string, server: DevServer | TestRunner) => AsyncOrSync<void>>[];
     /**
      * The hook is executed after a file has been removed from the filesystem.
      * Use this hook to clean up resources or update caches when files are deleted.
@@ -126,7 +145,7 @@ export type WatcherHooks = {
      * @param filePath - The absolute path to the removed file
      * @param server - The DevServer or TestRunner instance
      */
-    fileRemoved: LazyImport<(relativePath: string, absolutePath: string, server: DevServer | TestRunner) => AsyncOrSync<void>>[];
+    fileRemoved: DefineHook<(relativePath: string, absolutePath: string, server: DevServer | TestRunner) => AsyncOrSync<void>>[];
 };
 /**
  * Hooks executed when running the development server.
@@ -148,7 +167,7 @@ export type DevServerHooks = {
      *
      * @param server - The DevServer instance that is about to start
      */
-    devServerStarting: LazyImport<(server: DevServer) => AsyncOrSync<void>>[];
+    devServerStarting: DefineHook<(server: DevServer) => AsyncOrSync<void>>[];
     /**
      * The hook is executed after the child process has been started.
      * Use this hook to display additional information or perform post-startup tasks.
@@ -159,7 +178,7 @@ export type DevServerHooks = {
      * @param info.host - The host address the server is bound to
      * @param uiInstructions - UI instructions for displaying server information
      */
-    devServerStarted: LazyImport<(server: DevServer, info: {
+    devServerStarted: DefineHook<(server: DevServer, info: {
         port: number;
         host: string;
     }, uiInstructions: Instructions) => AsyncOrSync<void>>[];
@@ -184,7 +203,7 @@ export type BundlerHooks = {
      *
      * @param server - The Bundler instance that will create the build
      */
-    buildStarting: LazyImport<(server: Bundler) => AsyncOrSync<void>>[];
+    buildStarting: DefineHook<(server: Bundler) => AsyncOrSync<void>>[];
     /**
      * The hook is executed after the production build has been created.
      * Use this hook to perform post-build tasks or display build statistics.
@@ -192,7 +211,7 @@ export type BundlerHooks = {
      * @param server - The Bundler instance that created the build
      * @param uiInstructions - UI instructions for displaying build information
      */
-    buildFinished: LazyImport<(server: Bundler, uiInstructions: Instructions) => AsyncOrSync<void>>[];
+    buildFinished: DefineHook<(server: Bundler, uiInstructions: Instructions) => AsyncOrSync<void>>[];
 };
 /**
  * Hooks executed when running the test suite.
@@ -214,12 +233,50 @@ export type TestRunnerHooks = {
      *
      * @param server - The TestRunner instance that will execute the tests
      */
-    testsStarting: LazyImport<(server: TestRunner) => AsyncOrSync<void>>[];
+    testsStarting: DefineHook<(server: TestRunner) => AsyncOrSync<void>>[];
     /**
      * The hook is executed after the tests have been executed.
      * Use this hook to clean up resources or generate test reports.
      *
      * @param server - The TestRunner instance that executed the tests
      */
-    testsFinished: LazyImport<(server: TestRunner) => AsyncOrSync<void>>[];
+    testsFinished: DefineHook<(server: TestRunner) => AsyncOrSync<void>>[];
 };
+/**
+ * Combined type representing all available hooks across the assembler ecosystem.
+ * This intersection type merges all hook categories into a single type for
+ * comprehensive hook management and type safety.
+ *
+ * @example
+ * ```js
+ * const allHooks: AllHooks = {
+ *   init: [() => import('./hooks/init')],
+ *   fileChanged: [() => import('./hooks/file_changed')],
+ *   devServerStarted: [() => import('./hooks/dev_server_started')],
+ *   buildFinished: [() => import('./hooks/build_finished')],
+ *   testsFinished: [() => import('./hooks/tests_finished')],
+ *   routesCommitted: [() => import('./hooks/routes_committed')]
+ * }
+ * ```
+ */
+export type AllHooks = CommonHooks & WatcherHooks & DevServerHooks & BundlerHooks & TestRunnerHooks & RouterHooks;
+/**
+ * Utility type that extracts the parameter types for a specific hook.
+ * This type helps maintain type safety when working with hook callbacks
+ * by providing the exact parameter signature for any given hook name.
+ *
+ * @template Hook - The name of the hook to extract parameters for
+ *
+ * @example
+ * ```js
+ * // Get parameters for the fileChanged hook
+ * type FileChangedParams = HookParams<'fileChanged'>
+ * // Result: [string, string, {...}, DevServer | TestRunner]
+ *
+ * // Get parameters for the devServerStarted hook
+ * type DevServerStartedParams = HookParams<'devServerStarted')
+ * // Result: [DevServer, {port: number, host: string}, Instructions]
+ * ```
+ */
+export type HookParams<Hook extends keyof AllHooks> = AllHooks[Hook][number] extends DefineHook<infer A> ? Parameters<A> : never;
+export {};

package/build/src/utils.d.ts

@@ -1,9 +1,8 @@
 import Hooks from '@poppinss/hooks';
 import type tsStatic from 'typescript';
 import { type ChokidarOptions } from 'chokidar';
-import { type UnWrapLazyImport } from '@poppinss/utils/types';
 import type { RunScriptOptions } from './types/common.ts';
-import { type CommonHooks, type RouterHooks, type WatcherHooks, type BundlerHooks, type DevServerHooks, type TestRunnerHooks } from './types/hooks.ts';
+import { type AllHooks, type HookParams } from './types/hooks.ts';
 /**
  * Parses tsconfig.json and prints errors using typescript compiler host
  *
@@ -145,8 +144,7 @@ export declare function isRelative(pathValue: string): boolean;
  * @param names - Array of hook names to load
  * @returns Promise resolving to configured Hooks instance
  */
-type AllHooks = CommonHooks & RouterHooks & WatcherHooks & DevServerHooks & BundlerHooks & TestRunnerHooks;
-export declare function loadHooks<K extends keyof AllHooks>(rcFileHooks: Partial<AllHooks> | undefined, names: K[]): Promise<Hooks<{ [P in K]: [Parameters<UnWrapLazyImport<AllHooks[K][number]>>, Parameters<UnWrapLazyImport<AllHooks[K][number]>>]; }>>;
+export declare function loadHooks<K extends keyof AllHooks>(rcFileHooks: Partial<AllHooks> | undefined, names: K[]): Promise<Hooks<{ [P in K]: [HookParams<P>, HookParams<P>]; }>>;
 /**
  * Wraps a function inside another function that throttles the concurrent
  * executions of a function. If the function is called too quickly, then
@@ -167,4 +165,3 @@ export declare function throttle<Args extends any[]>(fn: (...args: Args) => Prom
  * @returns The file path without extension
  */
 export declare function removeExtension(filePath: string): string;
-export {};

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@adonisjs/assembler",
   "description": "Provides utilities to run AdonisJS development server and build project for production",
-  "version": "8.0.0-next.6",
+  "version": "8.0.0-next.8",
   "engines": {
     "node": ">=24.0.0"
   },
@@ -33,6 +33,7 @@
     "precompile": "npm run lint && npm run clean",
     "compile": "tsup-node && tsc --emitDeclarationOnly --declaration",
     "build": "npm run compile",
+    "docs": "typedoc",
     "release": "release-it",
     "version": "npm run build",
     "prepublishOnly": "npm run build",
@@ -48,18 +49,19 @@
     "@japa/snapshot": "^2.0.9",
     "@poppinss/ts-exec": "^1.4.1",
     "@release-it/conventional-changelog": "^10.0.1",
-    "@types/node": "^24.3.0",
+    "@types/node": "^24.3.1",
     "@types/picomatch": "^4.0.2",
     "@types/pretty-hrtime": "^1.0.3",
     "c8": "^10.1.3",
     "cross-env": "^10.0.0",
     "del-cli": "^6.0.0",
-    "eslint": "^9.34.0",
+    "eslint": "^9.35.0",
     "hot-hook": "^0.4.1-next.0",
     "p-event": "^6.0.1",
     "prettier": "^3.6.2",
     "release-it": "^19.0.4",
     "tsup": "^8.5.0",
+    "typedoc": "^0.28.12",
     "typescript": "^5.9.2"
   },
   "dependencies": {
@@ -70,7 +72,7 @@
     "@poppinss/hooks": "^7.2.6",
     "@poppinss/utils": "^7.0.0-next.3",
     "chokidar": "^4.0.3",
-    "dedent": "^1.6.0",
+    "dedent": "^1.7.0",
     "execa": "^9.6.0",
     "fast-glob": "^3.3.3",
     "fdir": "^6.5.0",