@utoo/pack 0.0.1-alpha.1

package/esm/project.js

@@ -0,0 +1,252 @@
+import { isDeepStrictEqual } from "util";
+import * as binding from "./binding";
+import { nanoid } from "nanoid";
+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 };
+    configSerializable.generateBuildId = () => nanoid();
+    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);
+}
+function rustifyEnv(env) {
+    return Object.entries(env)
+        .filter(([_, value]) => value != null)
+        .map(([name, value]) => ({
+        name,
+        value,
+    }));
+}
+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;
+        }
+        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

@@ -0,0 +1,261 @@
+import { HmrIdentifiers, NapiIssue, NapiUpdateMessage, NapiWrittenEndpoint, StackFrame } from "./binding";
+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 TurbopackRuleConfigItemOrShortcut = TurbopackRuleConfigItem;
+export type TurbopackRuleConfigItem = TurbopackRuleConfigItemOptions | {
+    [condition: string]: TurbopackRuleConfigItem;
+} | false;
+/**
+ * @deprecated Use `TurbopackRuleConfigItem` instead.
+ */
+export type TurbopackLoaderItem = string | {
+    loader: string;
+    options: Record<string, JSONValue>;
+};
+export type TurbopackRuleConfigItemOptions = {
+    loaders: TurbopackLoaderItem[];
+    as?: string;
+};
+export interface ModuleOptions {
+    rules?: Record<string, TurbopackRuleConfigItemOrShortcut>;
+}
+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;
+    };
+    target?: string;
+    sourceMaps?: boolean;
+    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;
+        }>;
+        packageImports?: string[];
+        transpilePackages?: string[];
+        removeConsole?: boolean | {
+            exclude?: string[];
+        };
+    };
+    define?: Record<string, string>;
+    styles?: {
+        sass?: {
+            implementation?: string;
+            [key: string]: any;
+        };
+        less?: {
+            implementation?: string;
+            [key: string]: any;
+        };
+        styledJsx?: boolean | {
+            useLightningcss?: boolean;
+        };
+        inlineCss?: {
+            insert?: string;
+            injectType: string;
+        };
+        styledComponents?: boolean | StyledComponentsConfig;
+        emotion?: boolean | EmotionConfig;
+    };
+    images?: {
+        inlineLimit?: number;
+    };
+    experimental?: ExperimentalConfig;
+    persistentCaching?: boolean;
+    cacheHandler?: string;
+}
+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>;
+    processDefineEnv: DefineEnv;
+    /**
+     * Whether to watch the filesystem for file changes.
+     */
+    watch: {
+        enable: boolean;
+        pollIntervalMs?: number;
+    };
+    /**
+     * The mode in which Next.js is running.
+     */
+    dev: boolean;
+    /**
+     * The build id.
+     */
+    buildId: string;
+}
+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>>;
+}
+export type StyledString = {
+    type: "text";
+    value: string;
+} | {
+    type: "code";
+    value: string;
+} | {
+    type: "strong";
+    value: string;
+} | {
+    type: "stack";
+    value: StyledString[];
+} | {
+    type: "line";
+    value: StyledString[];
+};

package/esm/types.js

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

package/esm/util.d.ts

@@ -0,0 +1,10 @@
+import { NapiIssue } from "./binding";
+import { StyledString } 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 formatIssue(issue: NapiIssue): string;
+export declare function renderStyledStringToErrorAnsi(string: StyledString): string;
+export declare function isRelevantWarning(issue: NapiIssue): boolean;

package/esm/util.js

@@ -0,0 +1,130 @@
+import { bold, green, magenta, red } from "picocolors";
+import { codeFrameColumns } from "@babel/code-frame";
+import { decodeMagicIdentifier, MAGIC_IDENTIFIER_REGEX, } from "./magicIdentifier";
+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 formatIssue(issue) {
+    const { filePath, title, description, source } = issue;
+    let { documentationLink } = issue;
+    let formattedTitle = renderStyledStringToErrorAnsi(title).replace(/\n/g, "\n    ");
+    let formattedFilePath = filePath
+        .replace("[project]/", "./")
+        .replaceAll("/./", "/")
+        .replace("\\\\?\\", "");
+    let message = "";
+    if (source && source.range) {
+        const { start } = source.range;
+        message = `${formattedFilePath}:${start.line + 1}:${start.column + 1}\n${formattedTitle}`;
+    }
+    else if (formattedFilePath) {
+        message = `${formattedFilePath}\n${formattedTitle}`;
+    }
+    else {
+        message = formattedTitle;
+    }
+    message += "\n";
+    if ((source === null || source === void 0 ? void 0 : source.range) && source.source.content) {
+        const { start, end } = source.range;
+        message +=
+            codeFrameColumns(source.source.content, {
+                start: {
+                    line: start.line + 1,
+                    column: start.column + 1,
+                },
+                end: {
+                    line: end.line + 1,
+                    column: end.column + 1,
+                },
+            }, { forceColor: true }).trim() + "\n\n";
+    }
+    if (description) {
+        message += renderStyledStringToErrorAnsi(description) + "\n\n";
+    }
+    // TODO: make it possible to enable this for debugging, but not in tests.
+    // if (detail) {
+    //   message += renderStyledStringToErrorAnsi(detail) + '\n\n'
+    // }
+    // TODO: Include a trace from the issue.
+    if (documentationLink) {
+        message += documentationLink + "\n\n";
+    }
+    return message;
+}
+export function renderStyledStringToErrorAnsi(string) {
+    function decodeMagicIdentifiers(str) {
+        return str.replaceAll(MAGIC_IDENTIFIER_REGEX, (ident) => {
+            try {
+                return magenta(`{${decodeMagicIdentifier(ident)}}`);
+            }
+            catch (e) {
+                return magenta(`{${ident} (decoding failed: ${e})}`);
+            }
+        });
+    }
+    switch (string.type) {
+        case "text":
+            return decodeMagicIdentifiers(string.value);
+        case "strong":
+            return bold(red(decodeMagicIdentifiers(string.value)));
+        case "code":
+            return green(decodeMagicIdentifiers(string.value));
+        case "line":
+            return string.value.map(renderStyledStringToErrorAnsi).join("");
+        case "stack":
+            return string.value.map(renderStyledStringToErrorAnsi).join("\n");
+        default:
+            throw new Error("Unknown StyledString type", string);
+    }
+}
+export function isRelevantWarning(issue) {
+    return issue.severity === "warning" && !isNodeModulesIssue(issue);
+}
+function isNodeModulesIssue(issue) {
+    if (issue.severity === "warning" && issue.stage === "config") {
+        // Override for the externalize issue
+        // `Package foo (serverExternalPackages or default list) can't be external`
+        if (renderStyledStringToErrorAnsi(issue.title).includes("can't be external")) {
+            return false;
+        }
+    }
+    return (issue.severity === "warning" &&
+        (issue.filePath.match(/^(?:.*[\\/])?node_modules(?:[\\/].*)?$/) !== null ||
+            issue.filePath.includes("@utoo/pack")));
+}

package/esm/xcodeProfile.d.ts

@@ -0,0 +1 @@
+export declare function xcodeProfilingReady(): Promise<void>;

package/esm/xcodeProfile.js

@@ -0,0 +1,13 @@
+export async function xcodeProfilingReady() {
+    await new Promise((resolve) => {
+        const readline = require("readline");
+        const rl = readline.createInterface({
+            input: process.stdin,
+            output: process.stdout,
+        });
+        rl.question(`Xcode profile enabled. Current process ${process.title} (${process.pid}) . Press Enter to continue...\n`, () => {
+            rl.close();
+            resolve();
+        });
+    });
+}

package/global.d.ts

@@ -0,0 +1,10 @@
+import { NapiDiagnostic, NapiIssue } from "./src/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 };
+}