rolldown 1.0.0-beta.2-commit.2666b23 → 1.0.0-beta.20

package/dist/types/api/build.d.ts

@@ -1,18 +0,0 @@
-import { InputOptions } from '../options/input-options';
-import { OutputOptions } from '../options/output-options';
-import type { RolldownOutput } from '../types/rolldown-output';
-export interface BuildOptions extends InputOptions {
-    /**
-     * Write the output to the file system
-     *
-     * @default true
-     */
-    write?: boolean;
-    output?: OutputOptions;
-}
-declare function build(options: BuildOptions): Promise<RolldownOutput>;
-/**
- * Build multiple outputs __sequentially__.
- */
-declare function build(options: BuildOptions[]): Promise<RolldownOutput[]>;
-export { build };

package/dist/types/api/build.js

@@ -1,22 +0,0 @@
-import { rolldown } from './rolldown';
-async function build(options) {
-    if (Array.isArray(options)) {
-        return Promise.all(options.map((opts) => build(opts)));
-    }
-    else {
-        const { output, write = true, ...inputOptions } = options;
-        const build = await rolldown(inputOptions);
-        try {
-            if (write) {
-                return await build.write(output);
-            }
-            else {
-                return await build.generate(output);
-            }
-        }
-        finally {
-            await build.close();
-        }
-    }
-}
-export { build };

package/dist/types/api/experimental.d.ts

@@ -1,7 +0,0 @@
-import type { InputOptions } from '../options/input-options';
-/**
- * This is an experimental API. It's behavior may change in the future.
- *
- * Calling this API will only execute the scan stage of rolldown.
- */
-export declare const experimental_scan: (input: InputOptions) => Promise<void>;

package/dist/types/api/experimental.js

@@ -1,13 +0,0 @@
-import { createBundler } from '../utils/create-bundler';
-import { handleOutputErrors } from '../utils/transform-to-rollup-output';
-/**
- * This is an experimental API. It's behavior may change in the future.
- *
- * Calling this API will only execute the scan stage of rolldown.
- */
-export const experimental_scan = async (input) => {
-    const { bundler, stopWorkers } = await createBundler(input, {});
-    const output = await bundler.scan();
-    handleOutputErrors(output);
-    await stopWorkers?.();
-};

package/dist/types/api/rolldown/index.d.ts

@@ -1,3 +0,0 @@
-import type { InputOptions } from '../../options/input-options';
-import { RolldownBuild } from './rolldown-build';
-export declare const rolldown: (input: InputOptions) => Promise<RolldownBuild>;

package/dist/types/api/rolldown/index.js

@@ -1,7 +0,0 @@
-import { PluginDriver } from '../../plugin/plugin-driver';
-import { RolldownBuild } from './rolldown-build';
-// `async` here is intentional to be compatible with `rollup.rollup`.
-export const rolldown = async (input) => {
-    const inputOptions = await PluginDriver.callOptionsHook(input);
-    return new RolldownBuild(inputOptions);
-};

package/dist/types/api/rolldown/rolldown-build.d.ts

@@ -1,12 +0,0 @@
-import type { InputOptions } from '../../options/input-options';
-import type { OutputOptions } from '../../options/output-options';
-import type { RolldownOutput } from '../../types/rolldown-output';
-export declare class RolldownBuild {
-    #private;
-    constructor(inputOptions: InputOptions);
-    get closed(): boolean;
-    generate(outputOptions?: OutputOptions): Promise<RolldownOutput>;
-    write(outputOptions?: OutputOptions): Promise<RolldownOutput>;
-    close(): Promise<void>;
-    [Symbol.asyncDispose](): Promise<void>;
-}

package/dist/types/api/rolldown/rolldown-build.js

@@ -1,43 +0,0 @@
-import { transformToRollupOutput } from '../../utils/transform-to-rollup-output';
-import { createBundler, } from '../../utils/create-bundler';
-// @ts-expect-error TS2540: the polyfill of `asyncDispose`.
-Symbol.asyncDispose ??= Symbol('Symbol.asyncDispose');
-export class RolldownBuild {
-    #inputOptions;
-    #bundler;
-    constructor(inputOptions) {
-        // TODO: Check if `inputOptions.output` is set. If so, throw an warning that it is ignored.
-        this.#inputOptions = inputOptions;
-    }
-    get closed() {
-        // If the bundler has not yet been created, it is not closed.
-        return this.#bundler ? this.#bundler.bundler.closed : false;
-    }
-    // Create bundler for each `bundle.write/generate`
-    async #getBundlerWithStopWorker(outputOptions) {
-        if (this.#bundler) {
-            this.#bundler.stopWorkers?.();
-        }
-        return (this.#bundler = await createBundler(this.#inputOptions, outputOptions));
-    }
-    async generate(outputOptions = {}) {
-        const { bundler } = await this.#getBundlerWithStopWorker(outputOptions);
-        const output = await bundler.generate();
-        return transformToRollupOutput(output);
-    }
-    async write(outputOptions = {}) {
-        const { bundler } = await this.#getBundlerWithStopWorker(outputOptions);
-        const output = await bundler.write();
-        return transformToRollupOutput(output);
-    }
-    async close() {
-        const { bundler, stopWorkers } = await this.#getBundlerWithStopWorker({});
-        await stopWorkers?.();
-        await bundler.close();
-    }
-    async [Symbol.asyncDispose]() {
-        await this.close();
-    }
-}
-function _assert() {
-}

package/dist/types/api/watch/index.d.ts

@@ -1,3 +0,0 @@
-import type { WatchOptions } from '../../options/watch-options';
-import { RolldownWatcher } from './watch-emitter';
-export declare const watch: (input: WatchOptions | WatchOptions[]) => RolldownWatcher;

package/dist/types/api/watch/index.js

@@ -1,8 +0,0 @@
-import { WatcherEmitter } from './watch-emitter';
-import { createWatcher } from './watcher';
-// Compat to `rollup.watch`
-export const watch = (input) => {
-    const emitter = new WatcherEmitter();
-    createWatcher(emitter, input);
-    return emitter;
-};

package/dist/types/api/watch/watch-emitter.d.ts

@@ -1,31 +0,0 @@
-import { BindingWatcherEvent } from '../../binding';
-import { MaybePromise } from '../../types/utils';
-export type WatcherEvent = 'close' | 'event' | 'restart' | 'change';
-export type ChangeEvent = 'create' | 'update' | 'delete';
-export type RollupWatcherEvent = {
-    code: 'START';
-} | {
-    code: 'BUNDLE_START';
-} | {
-    code: 'BUNDLE_END';
-    duration: number;
-    output: readonly string[];
-} | {
-    code: 'END';
-} | {
-    code: 'ERROR';
-    error: Error;
-};
-export declare class WatcherEmitter {
-    listeners: Map<WatcherEvent, Array<(...parameters: any[]) => MaybePromise<void>>>;
-    timer: any;
-    constructor();
-    on(event: 'change', listener: (id: string, change: {
-        event: ChangeEvent;
-    }) => MaybePromise<void>): this;
-    on(event: 'event', listener: (data: RollupWatcherEvent) => MaybePromise<void>): this;
-    on(event: 'restart' | 'close', listener: () => MaybePromise<void>): this;
-    onEvent(event: BindingWatcherEvent): Promise<void>;
-    close(): Promise<void>;
-}
-export type RolldownWatcher = WatcherEmitter;

package/dist/types/api/watch/watch-emitter.js

@@ -1,69 +0,0 @@
-import { normalizeErrors } from '../../utils/error';
-export class WatcherEmitter {
-    listeners = new Map();
-    timer;
-    constructor() {
-        // The rust side already create a thread for watcher, but it isn't at main thread.
-        // So here we need to avoid main process exit util the user call `watcher.close()`.
-        this.timer = setInterval(() => { }, 1e9 /* Low power usage */);
-    }
-    on(event, listener) {
-        const listeners = this.listeners.get(event);
-        if (listeners) {
-            listeners.push(listener);
-        }
-        else {
-            this.listeners.set(event, [listener]);
-        }
-        return this;
-    }
-    async onEvent(event) {
-        const listeners = this.listeners.get(event.eventKind());
-        if (listeners) {
-            switch (event.eventKind()) {
-                case 'close':
-                case 'restart':
-                    for (const listener of listeners) {
-                        await listener();
-                    }
-                    break;
-                case 'event':
-                    for (const listener of listeners) {
-                        const code = event.bundleEventKind();
-                        switch (code) {
-                            case 'BUNDLE_END':
-                                const { duration, output } = event.bundleEndData();
-                                await listener({
-                                    code: 'BUNDLE_END',
-                                    duration,
-                                    output: [output], // rolldown doesn't support arraying configure output
-                                });
-                                break;
-                            case 'ERROR':
-                                const errors = event.errors();
-                                await listener({
-                                    code: 'ERROR',
-                                    error: normalizeErrors(errors),
-                                });
-                                break;
-                            default:
-                                await listener({ code });
-                                break;
-                        }
-                    }
-                    break;
-                case 'change':
-                    for (const listener of listeners) {
-                        const { path, kind } = event.watchChangeData();
-                        await listener(path, { event: kind });
-                    }
-                    break;
-                default:
-                    throw new Error(`Unknown event: ${event}`);
-            }
-        }
-    }
-    async close() {
-        clearInterval(this.timer);
-    }
-}

package/dist/types/api/watch/watcher.d.ts

@@ -1,13 +0,0 @@
-import { BindingWatcher } from '../../binding';
-import { WatchOptions } from '../../options/watch-options';
-import { WatcherEmitter } from './watch-emitter';
-export declare class Watcher {
-    closed: boolean;
-    inner: BindingWatcher;
-    emitter: WatcherEmitter;
-    stopWorkers: ((() => Promise<void>) | undefined)[];
-    constructor(emitter: WatcherEmitter, inner: BindingWatcher, stopWorkers: ((() => Promise<void>) | undefined)[]);
-    close(): Promise<void>;
-    start(): void;
-}
-export declare function createWatcher(emitter: WatcherEmitter, input: WatchOptions | WatchOptions[]): Promise<void>;

package/dist/types/api/watch/watcher.js

@@ -1,66 +0,0 @@
-import { BindingWatcher } from '../../binding';
-import { LOG_LEVEL_WARN } from '../../log/logging';
-import { logMultiplyNotifyOption } from '../../log/logs';
-import { PluginDriver } from '../../plugin/plugin-driver';
-import { createBundlerOptions, } from '../../utils/create-bundler-option';
-import { arraify } from '../../utils/misc';
-export class Watcher {
-    closed;
-    inner;
-    emitter;
-    stopWorkers;
-    constructor(emitter, inner, stopWorkers) {
-        this.closed = false;
-        this.inner = inner;
-        this.emitter = emitter;
-        const originClose = emitter.close.bind(emitter);
-        emitter.close = async () => {
-            await this.close();
-            originClose();
-        };
-        this.stopWorkers = stopWorkers;
-    }
-    async close() {
-        if (this.closed)
-            return;
-        this.closed = true;
-        for (const stop of this.stopWorkers) {
-            await stop?.();
-        }
-        await this.inner.close();
-    }
-    start() {
-        // run first build after listener is attached
-        process.nextTick(() => this.inner.start(this.emitter.onEvent.bind(this.emitter)));
-    }
-}
-export async function createWatcher(emitter, input) {
-    const options = arraify(input);
-    const bundlerOptions = await Promise.all(options
-        .map((option) => arraify(option.output || {}).map(async (output) => {
-        const inputOptions = await PluginDriver.callOptionsHook(option);
-        return createBundlerOptions(inputOptions, output);
-    }))
-        .flat());
-    const notifyOptions = getValidNotifyOption(bundlerOptions);
-    const bindingWatcher = new BindingWatcher(bundlerOptions.map((option) => option.bundlerOptions), notifyOptions);
-    const watcher = new Watcher(emitter, bindingWatcher, bundlerOptions.map((option) => option.stopWorkers));
-    watcher.start();
-}
-function getValidNotifyOption(bundlerOptions) {
-    let result;
-    for (const option of bundlerOptions) {
-        if (option.inputOptions.watch) {
-            const notifyOption = option.inputOptions.watch.notify;
-            if (notifyOption) {
-                if (result) {
-                    option.onLog(LOG_LEVEL_WARN, logMultiplyNotifyOption());
-                    return result;
-                }
-                else {
-                    result = notifyOption;
-                }
-            }
-        }
-    }
-}