@utoo/pack 1.1.2-alpha.5 → 1.1.2-lingguang

package/esm/project.js

@@ -1,247 +0,0 @@
-import { isDeepStrictEqual } from "util";
-import * as binding from "./binding";
-import { runLoaderWorkerPool } from "./loaderWorkerPool";
-import { rustifyEnv } from "./util";
-export class TurbopackInternalError extends Error {
-    constructor(cause) {
-        super(cause.message);
-        this.name = "TurbopackInternalError";
-        this.stack = cause.stack;
-    }
-}
-async function withErrorCause(fn) {
-    try {
-        return await fn();
-    }
-    catch (nativeError) {
-        throw new TurbopackInternalError(nativeError);
-    }
-}
-function ensureLoadersHaveSerializableOptions(turbopackRules) {
-    for (const [glob, rule] of Object.entries(turbopackRules)) {
-        if (Array.isArray(rule)) {
-            checkLoaderItems(rule, glob);
-        }
-        else {
-            checkConfigItem(rule, glob);
-        }
-    }
-    function checkConfigItem(rule, glob) {
-        if (!rule)
-            return;
-        if ("loaders" in rule) {
-            checkLoaderItems(rule.loaders, glob);
-        }
-        else {
-            for (const key in rule) {
-                const inner = rule[key];
-                if (typeof inner === "object" && inner) {
-                    checkConfigItem(inner, glob);
-                }
-            }
-        }
-    }
-    function checkLoaderItems(loaderItems, glob) {
-        for (const loaderItem of loaderItems) {
-            if (typeof loaderItem !== "string" &&
-                !isDeepStrictEqual(loaderItem, JSON.parse(JSON.stringify(loaderItem)))) {
-                throw new Error(`loader ${loaderItem.loader} for match "${glob}" does not have serializable options. Ensure that options passed are plain JavaScript objects and values.`);
-            }
-        }
-    }
-}
-async function serializeConfig(config) {
-    var _a, _b;
-    let configSerializable = { ...config };
-    if ((_a = configSerializable.module) === null || _a === void 0 ? void 0 : _a.rules) {
-        ensureLoadersHaveSerializableOptions(configSerializable.module.rules);
-    }
-    if (configSerializable.optimization) {
-        configSerializable.optimization.modularizeImports =
-            configSerializable.optimization &&
-                ((_b = configSerializable.optimization) === null || _b === void 0 ? void 0 : _b.modularizeImports)
-                ? Object.fromEntries(Object.entries(configSerializable.optimization.modularizeImports).map(([mod, config]) => [
-                    mod,
-                    {
-                        ...config,
-                        transform: typeof config.transform === "string"
-                            ? config.transform
-                            : Object.entries(config.transform).map(([key, value]) => [
-                                key,
-                                value,
-                            ]),
-                    },
-                ]))
-                : undefined;
-    }
-    return JSON.stringify(configSerializable, null, 2);
-}
-async function rustifyPartialProjectOptions(options) {
-    return {
-        ...options,
-        config: options.config && (await serializeConfig(options.config)),
-        processEnv: options.processEnv && rustifyEnv(options.processEnv),
-    };
-}
-async function rustifyProjectOptions(options) {
-    var _a;
-    return {
-        ...options,
-        config: await serializeConfig(options.config),
-        processEnv: rustifyEnv((_a = options.processEnv) !== null && _a !== void 0 ? _a : {}),
-    };
-}
-export function projectFactory() {
-    const cancel = new (class Cancel extends Error {
-    })();
-    function subscribe(useBuffer, nativeFunction) {
-        // A buffer of produced items. This will only contain values if the
-        // consumer is slower than the producer.
-        let buffer = [];
-        // A deferred value waiting for the next produced item. This will only
-        // exist if the consumer is faster than the producer.
-        let waiting;
-        let canceled = false;
-        // The native function will call this every time it emits a new result. We
-        // either need to notify a waiting consumer, or buffer the new result until
-        // the consumer catches up.
-        function emitResult(err, value) {
-            if (waiting) {
-                let { resolve, reject } = waiting;
-                waiting = undefined;
-                if (err)
-                    reject(err);
-                else
-                    resolve(value);
-            }
-            else {
-                const item = { err, value };
-                if (useBuffer)
-                    buffer.push(item);
-                else
-                    buffer[0] = item;
-            }
-        }
-        async function* createIterator() {
-            const task = await withErrorCause(() => nativeFunction(emitResult));
-            try {
-                while (!canceled) {
-                    if (buffer.length > 0) {
-                        const item = buffer.shift();
-                        if (item.err)
-                            throw item.err;
-                        yield item.value;
-                    }
-                    else {
-                        // eslint-disable-next-line no-loop-func
-                        yield new Promise((resolve, reject) => {
-                            waiting = { resolve, reject };
-                        });
-                    }
-                }
-            }
-            catch (e) {
-                if (e === cancel)
-                    return;
-                if (e instanceof Error) {
-                    throw new TurbopackInternalError(e);
-                }
-                throw e;
-            }
-            finally {
-                if (task) {
-                    binding.rootTaskDispose(task);
-                }
-            }
-        }
-        const iterator = createIterator();
-        iterator.return = async () => {
-            canceled = true;
-            if (waiting)
-                waiting.reject(cancel);
-            return { value: undefined, done: true };
-        };
-        return iterator;
-    }
-    class ProjectImpl {
-        constructor(nativeProject) {
-            this._nativeProject = nativeProject;
-            if (typeof binding.registerWorkerScheduler === "function") {
-                runLoaderWorkerPool(binding, require.resolve("@utoo/pack/cjs/binding.js"));
-            }
-        }
-        async update(options) {
-            await withErrorCause(async () => binding.projectUpdate(this._nativeProject, await rustifyPartialProjectOptions(options)));
-        }
-        async writeAllEntrypointsToDisk() {
-            return await withErrorCause(async () => {
-                const napiEndpoints = (await binding.projectWriteAllEntrypointsToDisk(this._nativeProject));
-                return napiEntrypointsToRawEntrypoints(napiEndpoints);
-            });
-        }
-        entrypointsSubscribe() {
-            const subscription = subscribe(false, async (callback) => binding.projectEntrypointsSubscribe(this._nativeProject, callback));
-            return (async function* () {
-                for await (const entrypoints of subscription) {
-                    yield napiEntrypointsToRawEntrypoints(entrypoints);
-                }
-            })();
-        }
-        hmrEvents(identifier) {
-            return subscribe(true, async (callback) => binding.projectHmrEvents(this._nativeProject, identifier, callback));
-        }
-        hmrIdentifiersSubscribe() {
-            return subscribe(false, async (callback) => binding.projectHmrIdentifiersSubscribe(this._nativeProject, callback));
-        }
-        traceSource(stackFrame, currentDirectoryFileUrl) {
-            return binding.projectTraceSource(this._nativeProject, stackFrame, currentDirectoryFileUrl);
-        }
-        getSourceForAsset(filePath) {
-            return binding.projectGetSourceForAsset(this._nativeProject, filePath);
-        }
-        getSourceMap(filePath) {
-            return binding.projectGetSourceMap(this._nativeProject, filePath);
-        }
-        getSourceMapSync(filePath) {
-            return binding.projectGetSourceMapSync(this._nativeProject, filePath);
-        }
-        updateInfoSubscribe(aggregationMs) {
-            return subscribe(true, async (callback) => binding.projectUpdateInfoSubscribe(this._nativeProject, aggregationMs, callback));
-        }
-        shutdown() {
-            return binding.projectShutdown(this._nativeProject);
-        }
-        onExit() {
-            return binding.projectOnExit(this._nativeProject);
-        }
-    }
-    class EndpointImpl {
-        constructor(nativeEndpoint) {
-            this._nativeEndpoint = nativeEndpoint;
-        }
-        async writeToDisk() {
-            return await withErrorCause(() => binding.endpointWriteToDisk(this._nativeEndpoint));
-        }
-        async clientChanged() {
-            const clientSubscription = subscribe(false, async (callback) => binding.endpointClientChangedSubscribe(await this._nativeEndpoint, callback));
-            await clientSubscription.next();
-            return clientSubscription;
-        }
-        async serverChanged(includeIssues) {
-            const serverSubscription = subscribe(false, async (callback) => binding.endpointServerChangedSubscribe(await this._nativeEndpoint, includeIssues, callback));
-            await serverSubscription.next();
-            return serverSubscription;
-        }
-    }
-    function napiEntrypointsToRawEntrypoints(entrypoints) {
-        return {
-            apps: (entrypoints.apps || []).map((e) => new EndpointImpl(e)),
-            libraries: (entrypoints.libraries || []).map((e) => new EndpointImpl(e)),
-            issues: entrypoints.issues,
-            diagnostics: entrypoints.diagnostics,
-        };
-    }
-    return async function createProject(options, turboEngineOptions) {
-        return new ProjectImpl(await binding.projectNew(await rustifyProjectOptions(options), turboEngineOptions || {}));
-    };
-}

package/esm/types.d.ts

@@ -1,284 +0,0 @@
-import { HmrIdentifiers, NapiDiagnostic, NapiIssue, NapiUpdateMessage, NapiWrittenEndpoint, StackFrame } from "./binding";
-declare global {
-    export type TurbopackResult<T = {}> = T & {
-        issues: NapiIssue[];
-        diagnostics: NapiDiagnostic[];
-    };
-    export type RefCell = {
-        readonly __tag: unique symbol;
-    };
-    export type ExternalEndpoint = {
-        readonly __tag: unique symbol;
-    };
-    export type RcStr = string;
-}
-export interface BaseUpdate {
-    resource: {
-        headers: unknown;
-        path: string;
-    };
-    diagnostics: unknown[];
-    issues: NapiIssue[];
-}
-export interface IssuesUpdate extends BaseUpdate {
-    type: "issues";
-}
-export interface EcmascriptMergedUpdate {
-    type: "EcmascriptMergedUpdate";
-    chunks: {
-        [moduleName: string]: {
-            type: "partial";
-        };
-    };
-    entries: {
-        [moduleName: string]: {
-            code: string;
-            map: string;
-            url: string;
-        };
-    };
-}
-export interface PartialUpdate extends BaseUpdate {
-    type: "partial";
-    instruction: {
-        type: "ChunkListUpdate";
-        merged: EcmascriptMergedUpdate[] | undefined;
-    };
-}
-export type Update = IssuesUpdate | PartialUpdate;
-export type RustifiedEnv = {
-    name: string;
-    value: string;
-}[];
-export interface EntryOptions {
-    name?: string;
-    import: string;
-    library?: LibraryOptions;
-}
-export interface LibraryOptions {
-    name?: string;
-    export?: Array<string>;
-}
-export interface DefineEnv {
-    client: RustifiedEnv;
-    edge: RustifiedEnv;
-    nodejs: RustifiedEnv;
-}
-export interface ExperimentalConfig {
-}
-export type TurbopackRuleConfigItem = TurbopackRuleConfigItemOptions | {
-    [condition: string]: TurbopackRuleConfigItem;
-} | false;
-/**
- * @deprecated Use `TurbopackRuleConfigItem` instead.
- */
-export type TurbopackLoaderItem = string | {
-    loader: string;
-    options: Record<string, JSONValue>;
-};
-export type TurbopackRuleConfigItemOrShortcut = TurbopackLoaderItem[] | TurbopackRuleConfigItem;
-export type TurbopackRuleConfigItemOptions = {
-    loaders: TurbopackLoaderItem[];
-    as?: string;
-};
-export type TurbopackRuleCondition = {
-    path: string | RegExp;
-};
-export interface ModuleOptions {
-    rules?: Record<string, TurbopackRuleConfigItem>;
-}
-export interface ResolveOptions {
-    alias?: Record<string, string | string[] | Record<string, string | string[]>>;
-    extensions?: string[];
-}
-export type ExternalType = "script" | "commonjs" | "esm" | "global";
-export interface ExternalAdvanced {
-    root: string;
-    type?: ExternalType;
-    script?: string;
-}
-export type ExternalConfig = string | ExternalAdvanced;
-export interface ConfigComplete {
-    entry: EntryOptions[];
-    mode?: "production" | "development";
-    module?: ModuleOptions;
-    resolve?: ResolveOptions;
-    externals?: Record<string, ExternalConfig>;
-    output?: {
-        path?: string;
-        type?: "standalone" | "export";
-        filename?: string;
-        chunkFilename?: string;
-        clean?: boolean;
-        copy?: Array<{
-            from: string;
-            to?: string;
-        } | string>;
-        publicPath?: string;
-    };
-    target?: string;
-    sourceMaps?: boolean;
-    define?: Record<string, string>;
-    optimization?: {
-        moduleIds?: "named" | "deterministic";
-        minify?: boolean;
-        treeShaking?: boolean;
-        splitChunks?: Record<"js" | "css", {
-            minChunkSize?: number;
-            maxChunkCountPerGroup?: number;
-            maxMergeChunkSize?: number;
-        }>;
-        modularizeImports?: Record<string, {
-            transform: string | Record<string, string>;
-            preventFullImport?: boolean;
-            skipDefaultConversion?: boolean;
-            handleDefaultImport?: boolean;
-            handleNamespaceImport?: boolean;
-            style?: string;
-        }>;
-        packageImports?: string[];
-        transpilePackages?: string[];
-        removeConsole?: boolean | {
-            exclude?: string[];
-        };
-        concatenateModules?: boolean;
-        removeUnusedExports?: boolean;
-        nestedAsyncChunking?: boolean;
-        wasmAsAsset?: boolean;
-    };
-    styles?: {
-        less?: {
-            implementation?: string;
-            [key: string]: any;
-        };
-        sass?: {
-            implementation?: string;
-            [key: string]: any;
-        };
-        inlineCss?: {
-            insert?: string;
-            injectType?: string;
-        };
-        styledJsx?: boolean | {
-            useLightningcss?: boolean;
-        };
-        styledComponents?: boolean | StyledComponentsConfig;
-        emotion?: boolean | EmotionConfig;
-    };
-    images?: {
-        inlineLimit?: number;
-    };
-    stats?: boolean;
-    persistentCaching?: boolean;
-    nodePolyfill?: boolean;
-    devServer?: {
-        hot: boolean;
-    };
-    cacheHandler?: string;
-    experimental?: ExperimentalConfig;
-}
-export interface StyledComponentsConfig {
-    /**
-     * Enabled by default in development, disabled in production to reduce file size,
-     * setting this will override the default for all environments.
-     */
-    displayName?: boolean;
-    topLevelImportPaths?: string[];
-    ssr?: boolean;
-    fileName?: boolean;
-    meaninglessFileNames?: string[];
-    minify?: boolean;
-    transpileTemplateLiterals?: boolean;
-    namespace?: string;
-    pure?: boolean;
-    cssProp?: boolean;
-}
-export interface EmotionConfig {
-    sourceMap?: boolean;
-    autoLabel?: "dev-only" | "always" | "never";
-    labelFormat?: string;
-    importMap?: {
-        [importName: string]: {
-            [exportName: string]: {
-                canonicalImport?: [string, string];
-                styledBaseImport?: [string, string];
-            };
-        };
-    };
-}
-export type JSONValue = string | number | boolean | JSONValue[] | {
-    [k: string]: JSONValue;
-};
-export interface ProjectOptions {
-    /**
-     * A root path from which all files must be nested under. Trying to access
-     * a file outside this root will fail. Think of this as a chroot.
-     */
-    rootPath: string;
-    /**
-     * A path inside the root_path which contains the app/pages directories.
-     */
-    projectPath: string;
-    /**
-     * The utoo pack configs.
-     */
-    config: ConfigComplete;
-    /**
-     * A map of environment variables to use when compiling code.
-     */
-    processEnv?: Record<string, string>;
-    defineEnv?: DefineEnv;
-    /**
-     * Whether to watch the filesystem for file changes.
-     */
-    watch?: {
-        enable: boolean;
-        pollIntervalMs?: number;
-    };
-    /**
-     * The mode of utoo-pack.
-     */
-    dev?: boolean;
-    /**
-     * The build id.
-     */
-    buildId?: string;
-    /**
-     * Absolute path for `@utoo/pack`.
-     */
-    packPath?: string;
-}
-export type BundleOptions = Omit<ProjectOptions, "rootPath" | "projectPath">;
-export interface Project {
-    update(options: Partial<ProjectOptions>): Promise<void>;
-    entrypointsSubscribe(): AsyncIterableIterator<TurbopackResult<RawEntrypoints>>;
-    hmrEvents(identifier: string): AsyncIterableIterator<TurbopackResult<Update>>;
-    hmrIdentifiersSubscribe(): AsyncIterableIterator<TurbopackResult<HmrIdentifiers>>;
-    getSourceForAsset(filePath: string): Promise<string | null>;
-    getSourceMap(filePath: string): Promise<string | null>;
-    getSourceMapSync(filePath: string): string | null;
-    traceSource(stackFrame: StackFrame, currentDirectoryFileUrl: string): Promise<StackFrame | null>;
-    updateInfoSubscribe(aggregationMs: number): AsyncIterableIterator<TurbopackResult<NapiUpdateMessage>>;
-    shutdown(): Promise<void>;
-    onExit(): Promise<void>;
-}
-export interface RawEntrypoints {
-    apps?: Endpoint[];
-    libraries?: Endpoint[];
-}
-export interface Endpoint {
-    /** Write files for the endpoint to disk. */
-    writeToDisk(): Promise<TurbopackResult<NapiWrittenEndpoint>>;
-    /**
-     * Listen to client-side changes to the endpoint.
-     * After clientChanged() has been awaited it will listen to changes.
-     * The async iterator will yield for each change.
-     */
-    clientChanged(): Promise<AsyncIterableIterator<TurbopackResult>>;
-    /**
-     * Listen to server-side changes to the endpoint.
-     * After serverChanged() has been awaited it will listen to changes.
-     * The async iterator will yield for each change.
-     */
-    serverChanged(includeIssues: boolean): Promise<AsyncIterableIterator<TurbopackResult>>;
-}

package/esm/types.js

@@ -1 +0,0 @@
-export {};

package/esm/util.d.ts

@@ -1,19 +0,0 @@
-import { NapiIssue } from "./binding";
-import { ConfigComplete, DefineEnv, RustifiedEnv } from "./types";
-export declare class ModuleBuildError extends Error {
-    name: string;
-}
-export declare function processIssues(result: TurbopackResult, throwIssue: boolean, logErrors: boolean): void;
-export declare function isWellKnownError(issue: NapiIssue): boolean;
-export declare function rustifyEnv(env: Record<string, string>): RustifiedEnv;
-interface DefineEnvOptions {
-    config: ConfigComplete;
-    dev: boolean;
-    optionDefineEnv?: DefineEnv;
-}
-export declare function createDefineEnv(options: DefineEnvOptions): DefineEnv;
-type AnyFunc<T> = (this: T, ...args: any) => any;
-export declare function debounce<T, F extends AnyFunc<T>>(fn: F, ms: number, maxWait?: number): (this: T, ...passedArgs: Parameters<F>) => void;
-export declare function blockStdout(): void;
-export declare function getPackPath(): string;
-export {};

package/esm/util.js

@@ -1,141 +0,0 @@
-import { formatIssue, renderStyledStringToErrorAnsi } from "@utoo/pack-shared";
-import path from "path";
-export class ModuleBuildError extends Error {
-    constructor() {
-        super(...arguments);
-        this.name = "ModuleBuildError";
-    }
-}
-export function processIssues(result, throwIssue, logErrors) {
-    const relevantIssues = new Set();
-    for (const issue of result.issues) {
-        if (issue.severity !== "error" &&
-            issue.severity !== "fatal" &&
-            issue.severity !== "warning")
-            continue;
-        if (issue.severity !== "warning") {
-            if (throwIssue) {
-                const formatted = formatIssue(issue);
-                relevantIssues.add(formatted);
-            }
-            // if we throw the issue it will most likely get handed and logged elsewhere
-            else if (logErrors && isWellKnownError(issue)) {
-                const formatted = formatIssue(issue);
-                console.error(formatted);
-            }
-        }
-    }
-    if (relevantIssues.size && throwIssue) {
-        throw new ModuleBuildError([...relevantIssues].join("\n\n"));
-    }
-}
-export function isWellKnownError(issue) {
-    const { title } = issue;
-    const formattedTitle = renderStyledStringToErrorAnsi(title);
-    // TODO: add more well known errors
-    if (formattedTitle.includes("Module not found") ||
-        formattedTitle.includes("Unknown module type")) {
-        return true;
-    }
-    return false;
-}
-export function rustifyEnv(env) {
-    return Object.entries(env)
-        .filter(([_, value]) => value != null)
-        .map(([name, value]) => ({
-        name,
-        value,
-    }));
-}
-export function createDefineEnv(options) {
-    var _a;
-    let defineEnv = (_a = options.optionDefineEnv) !== null && _a !== void 0 ? _a : {
-        client: [],
-        edge: [],
-        nodejs: [],
-    };
-    function getDefineEnv() {
-        var _a;
-        const envs = {
-            "process.env.NODE_ENV": options.dev ? "development" : "production",
-        };
-        const userDefines = (_a = options.config.define) !== null && _a !== void 0 ? _a : {};
-        for (const key in userDefines) {
-            envs[key] = userDefines[key];
-        }
-        // serialize
-        const defineEnvStringified = {};
-        for (const key in defineEnv) {
-            const value = envs[key];
-            defineEnvStringified[key] = JSON.stringify(value);
-        }
-        return defineEnvStringified;
-    }
-    // TODO: future define envs need to extends for more compiler like server or edge.
-    for (const variant of Object.keys(defineEnv)) {
-        defineEnv[variant] = rustifyEnv(getDefineEnv());
-    }
-    return defineEnv;
-}
-export function debounce(fn, ms, maxWait = Infinity) {
-    let timeoutId;
-    // The time the debouncing function was first called during this debounce queue.
-    let startTime = 0;
-    // The time the debouncing function was last called.
-    let lastCall = 0;
-    // The arguments and this context of the last call to the debouncing function.
-    let args, context;
-    // A helper used to that either invokes the debounced function, or
-    // reschedules the timer if a more recent call was made.
-    function run() {
-        const now = Date.now();
-        const diff = lastCall + ms - now;
-        // If the diff is non-positive, then we've waited at least `ms`
-        // milliseconds since the last call. Or if we've waited for longer than the
-        // max wait time, we must call the debounced function.
-        if (diff <= 0 || startTime + maxWait >= now) {
-            // It's important to clear the timeout id before invoking the debounced
-            // function, in case the function calls the debouncing function again.
-            timeoutId = undefined;
-            fn.apply(context, args);
-        }
-        else {
-            // Else, a new call was made after the original timer was scheduled. We
-            // didn't clear the timeout (doing so is very slow), so now we need to
-            // reschedule the timer for the time difference.
-            timeoutId = setTimeout(run, diff);
-        }
-    }
-    return function (...passedArgs) {
-        // The arguments and this context of the most recent call are saved so the
-        // debounced function can be invoked with them later.
-        args = passedArgs;
-        context = this;
-        // Instead of constantly clearing and scheduling a timer, we record the
-        // time of the last call. If a second call comes in before the timer fires,
-        // then we'll reschedule in the run function. Doing this is considerably
-        // faster.
-        lastCall = Date.now();
-        // Only schedule a new timer if we're not currently waiting.
-        if (timeoutId === undefined) {
-            startTime = lastCall;
-            timeoutId = setTimeout(run, ms);
-        }
-    };
-}
-// ref:
-// https://github.com/vercel/next.js/pull/51883
-export function blockStdout() {
-    // rust needs stdout to be blocking, otherwise it will throw an error (on macOS at least) when writing a lot of data (logs) to it
-    // see https://github.com/napi-rs/napi-rs/issues/1630
-    // and https://github.com/nodejs/node/blob/main/doc/api/process.md#a-note-on-process-io
-    if (process.stdout._handle != null) {
-        process.stdout._handle.setBlocking(true);
-    }
-    if (process.stderr._handle != null) {
-        process.stderr._handle.setBlocking(true);
-    }
-}
-export function getPackPath() {
-    return path.resolve(__dirname, "..");
-}

package/esm/webpackCompat.d.ts

@@ -1,7 +0,0 @@
-import type webpack from "webpack";
-import { BundleOptions } from "./types";
-export declare function readWebpackConfig(projectPath?: string, rootPath?: string): any;
-export type WebpackConfig = Partial<Pick<webpack.Configuration, "name" | "entry" | "mode" | "module" | "resolve" | "externals" | "output" | "target" | "devtool" | "optimization" | "plugins" | "stats">> & {
-    webpackMode: true;
-};
-export declare function compatOptionsFromWebpack(webpackConfig: WebpackConfig, projectPath?: string, rootPath?: string): BundleOptions;