feat: restrict typings and refactor RenderedModule (rolldown#503)

crates/rolldown/src/chunk/mod.rs

@@ -2,6 +2,7 @@ mod de_conflict;
 pub mod render_chunk;
 mod render_chunk_exports;
 mod render_chunk_imports;
+
 use index_vec::IndexVec;
 use rolldown_common::ChunkId;
 
@@ -106,13 +107,7 @@ impl Chunk {
         );
         Some((
           m.resource_id.expect_file().to_string(),
-          RenderedModule {
-            original_length: m.source.len().try_into().unwrap(),
-            rendered_length: rendered_content
-              .as_ref()
-              .map(|c| c.code.len() as u32)
-              .unwrap_or_default(),
-          },
+          RenderedModule { code: None },
           rendered_content,
           if output_options.sourcemap.is_hidden() {
             None

crates/rolldown_binding/index.d.ts

@@ -86,7 +86,7 @@ export interface RenderedChunk {
   moduleIds: Array<string>
   exports: Array<string>
   fileName: string
-  modules: Record<string, RenderedModule>
+  modules: Record<string, BindingRenderedModule>
 }
 export interface SourceMap {
   mappings: string
@@ -95,12 +95,8 @@ export interface SourceMap {
   sources: Array<string>
   sourcesContent: Array<string>
 }
-export interface RenderedModule {
+export interface BindingRenderedModule {
   code?: string
-  removedExports: Array<string>
-  renderedExports: Array<string>
-  originalLength: number
-  renderedLength: number
 }
 export interface OutputChunk {
   isEntry: boolean
@@ -109,7 +105,7 @@ export interface OutputChunk {
   moduleIds: Array<string>
   exports: Array<string>
   fileName: string
-  modules: Record<string, RenderedModule>
+  modules: Record<string, BindingRenderedModule>
   code: string
 }
 export interface OutputAsset {

crates/rolldown_binding/src/options/plugin/plugin.rs

@@ -155,7 +155,8 @@ pub struct RenderedChunk {
   pub exports: Vec<String>,
   // RenderedChunk
   pub file_name: String,
-  pub modules: HashMap<String, crate::output::RenderedModule>,
+  #[serde(skip)]
+  pub modules: HashMap<String, crate::output::BindingRenderedModule>,
 }
 
 impl From<rolldown_common::RenderedChunk> for RenderedChunk {

crates/rolldown_binding/src/output.rs

@@ -1,29 +1,23 @@
-use std::collections::HashMap;
+use std::{collections::HashMap, fmt::Debug};
 
 use derivative::Derivative;
+use napi_derive::napi;
 use serde::Deserialize;
 
-#[napi_derive::napi(object)]
-#[derive(Deserialize, Default, Derivative)]
-#[serde(rename_all = "camelCase")]
-#[derivative(Debug)]
-pub struct RenderedModule {
+#[napi(object)]
+pub struct BindingRenderedModule {
   pub code: Option<String>,
-  pub removed_exports: Vec<String>,
-  pub rendered_exports: Vec<String>,
-  pub original_length: u32,
-  pub rendered_length: u32,
 }
 
-impl From<rolldown_common::RenderedModule> for RenderedModule {
+impl Debug for BindingRenderedModule {
+  fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+    f.debug_struct("BindingRenderedModule").field("code", &"...").finish()
+  }
+}
+
+impl From<rolldown_common::RenderedModule> for BindingRenderedModule {
   fn from(value: rolldown_common::RenderedModule) -> Self {
-    Self {
-      code: None,
-      original_length: value.original_length,
-      rendered_length: value.rendered_length,
-      removed_exports: vec![],
-      rendered_exports: vec![],
-    }
+    Self { code: value.code }
   }
 }
 
@@ -40,7 +34,8 @@ pub struct OutputChunk {
   pub exports: Vec<String>,
   // RenderedChunk
   pub file_name: String,
-  pub modules: HashMap<String, RenderedModule>,
+  #[serde(skip_deserializing)]
+  pub modules: HashMap<String, BindingRenderedModule>,
   // OutputChunk
   pub code: String,
 }

crates/rolldown_common/src/types/output_chunk.rs

@@ -2,6 +2,7 @@ use rustc_hash::FxHashMap;
 
 use super::rendered_module::RenderedModule;
 
+#[allow(clippy::zero_sized_map_values)]
 #[derive(Debug, Clone)]
 pub struct OutputChunk {
   // PreRenderedChunk

crates/rolldown_common/src/types/rendered_module.rs

@@ -1,6 +1,4 @@
 #[derive(Debug, Clone)]
 pub struct RenderedModule {
-  // The code of the module is omit at now.
-  pub original_length: u32,
-  pub rendered_length: u32,
+  pub code: Option<String>,
 }

justfile

@@ -78,6 +78,7 @@ lint-node:
     yarn lint-filename
     yarn lint
     yarn prettier:ci
+    yarn typecheck
 
 lint:
     just lint-rust

packages/node/package.json

@@ -33,6 +33,7 @@
   },
   "devDependencies": {
     "@types/node": "^20.11.25",
+    "type-fest": "^4.12.0",
     "typescript": "^5.4.2",
     "unbuild": "^2.0.0",
     "vitest": "^1.3.1"

packages/node/src/index.ts

@@ -1,6 +1,6 @@
+import { RolldownOutput } from './objects/rolldown-output'
 import type { InputOptions, RolldownPlugin } from './options/input-options'
 import type { OutputOptions } from './options/output-options'
-import { RolldownOutput } from './utils'
 
 export { rolldown, experimental_scan } from './rolldown'
 
@@ -15,5 +15,5 @@ export type {
   InputOptions,
   OutputOptions,
   RolldownPlugin as Plugin,
-  RolldownOutput as RollupOutput,
+  RolldownOutput as RollupOutput
 }

packages/node/src/objects/output-bundle.ts

@@ -0,0 +1,5 @@
+import { RolldownOutputAsset, RolldownOutputChunk } from './rolldown-output';
+
+export interface OutputBundle {
+  [fileName: string]: RolldownOutputAsset | RolldownOutputChunk;
+}

packages/node/src/objects/rendered-module.ts

@@ -0,0 +1 @@
+export interface RenderedModule { }

packages/node/src/objects/rolldown-output.ts

@@ -0,0 +1,43 @@
+import type { OutputAsset, OutputChunk, RollupOutput } from '../rollup'
+import { HasProperty, IsPropertiesEqual, IsPropertyEqual, TypeAssert } from '../utils/type-assert';
+import { RenderedModule } from './rendered-module';
+
+export interface RolldownOutputAsset {
+  type: 'asset';
+  fileName: string;
+  source: string | Uint8Array;
+}
+
+function _assertRolldownOutputAsset() {
+  type _ = TypeAssert<IsPropertiesEqual<RolldownOutputAsset, OutputAsset>>;
+}
+
+export interface RolldownOutputChunk {
+  type: 'chunk';
+  code: string;
+  isEntry: boolean;
+  exports: string[];
+  fileName: string;
+  modules: {
+    [id: string]: RenderedModule;
+  };
+  facadeModuleId: string | null;
+  isDynamicEntry: boolean;
+  moduleIds: string[];
+}
+
+function _assertRolldownOutputChunk() {
+  type _ = TypeAssert<IsPropertiesEqual<Omit<RolldownOutputChunk, 'modules'>, OutputChunk>>;
+}
+
+export interface RolldownOutput {
+  output: [
+    RolldownOutputChunk,
+    ...(RolldownOutputChunk | RolldownOutputAsset)[],
+  ]
+}
+
+
+function _assertRolldownOutput() {
+  type _ = TypeAssert<HasProperty<RolldownOutput, 'output'>>;
+}

packages/node/src/options/create-build-plugin-adapter.ts

@@ -34,7 +34,7 @@ function writeBundle(hook: Plugin['writeBundle']) {
     }
     return async (outputs: Outputs) => {
       try {
-        // TODO outputOptions
+        // @ts-expect-error: FIXME: hyf0
         await hook.call({} as any, {} as any, transformToOutputBundle(outputs))
       } catch (error) {
         console.error(error)
@@ -51,10 +51,10 @@ function generateBundle(hook: Plugin['generateBundle']) {
     }
     return async (outputs: Outputs, isWrite: boolean) => {
       try {
-        // TODO outputOptions
         await hook.call(
           {} as any,
           {} as any,
+          // @ts-expect-error: FIXME: hyf0
           transformToOutputBundle(outputs),
           isWrite,
         )
@@ -127,6 +127,7 @@ function renderChunk(hook: Plugin['renderChunk']) {
         const value = await hook.call(
           {} as any,
           code,
+          // @ts-expect-error: FIXME: hyf0
           renderedChunk,
           {} as any,
           {} as any,

packages/node/src/rolldown-build.ts

@@ -1,16 +1,15 @@
 import { Bundler } from '@rolldown/node-binding'
 import { normalizeOutputOptions, OutputOptions } from './options/output-options'
-import type { RollupBuild, SerializedTimings } from './rollup-types'
-import { transformToRollupOutput, RolldownOutput, unimplemented } from './utils'
+import { transformToRollupOutput, unimplemented } from './utils'
+import { RolldownOutput } from './objects/rolldown-output'
+import { HasProperty, TypeAssert } from './utils/type-assert'
 
-export class RolldownBuild implements Omit<RollupBuild, 'generate' | 'write'> {
+export class RolldownBuild {
   #bundler: Bundler
   constructor(bundler: Bundler) {
     this.#bundler = bundler
   }
 
-  closed = false
-
   async generate(outputOptions: OutputOptions = {}): Promise<RolldownOutput> {
     const bindingOptions = normalizeOutputOptions(outputOptions)
     const output = await this.#bundler.write(bindingOptions)
@@ -22,23 +21,8 @@ export class RolldownBuild implements Omit<RollupBuild, 'generate' | 'write'> {
     const output = await this.#bundler.write(bindingOptions)
     return transformToRollupOutput(output) as RolldownOutput
   }
+}
 
-  async close() {
-    this.closed = true
-  }
-
-  // -- unimplemented
-
-  get cache(): undefined {
-    throw unimplemented()
-    return unimplemented()
-  }
-  get watchFiles(): string[] {
-    throw unimplemented()
-    return unimplemented()
-  }
-  get getTimings(): () => SerializedTimings {
-    throw unimplemented()
-    return unimplemented()
-  }
+function _assert() {
+  type _ = TypeAssert<HasProperty<RolldownBuild, 'generate' | 'write'>>
 }

packages/node/src/rollup-types.ts

@@ -1,8 +1,5 @@
 export type {
-  RollupBuild,
-  RollupOutput,
   OutputOptions,
-  SerializedTimings,
   InputOptions,
   Plugin,
   OutputPlugin,

packages/node/src/utils/index.ts

@@ -16,4 +16,11 @@ export function unimplemented(info?: string): never {
   throw new Error('unimplemented')
 }
 
-export function noop(..._args: any[]) {}
+export function unreachable(info?: string): never {
+  if (info) {
+    throw new Error(`unreachable: ${info}`)
+  }
+  throw new Error('unreachable')
+}
+
+export function noop(..._args: any[]) { }