@utoo/pack 1.1.2 → 1.1.3

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,300 +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;
-/**
- * Provider configuration for automatic module imports.
- * Similar to webpack's ProvidePlugin.
- *
- * @example
- * ```ts
- * provider: {
- *   // Provides `$` as `import $ from 'jquery'`
- *   $: 'jquery',
- *   // Provides `Buffer` as `import { Buffer } from 'buffer'`
- *   Buffer: ['buffer', 'Buffer'],
- * }
- * ```
- */
-export type ProviderConfig = Record<string, string | [string, string]>;
-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>;
-    provider?: ProviderConfig;
-    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 {};