@utoo/pack 0.0.1-alpha.1

package/esm/binding.js

@@ -0,0 +1,341 @@
+"use strict";
+/* tslint:disable */
+/* eslint-disable */
+/* prettier-ignore */
+/* auto-generated by NAPI-RS */
+const { existsSync, readFileSync } = require('fs');
+const { join } = require('path');
+const { platform, arch } = process;
+let nativeBinding = null;
+let localFileExisted = false;
+let loadError = null;
+function isMusl() {
+    // For Node 10
+    if (!process.report || typeof process.report.getReport !== 'function') {
+        try {
+            const lddPath = require('child_process').execSync('which ldd').toString().trim();
+            return readFileSync(lddPath, 'utf8').includes('musl');
+        }
+        catch (e) {
+            return true;
+        }
+    }
+    else {
+        const { glibcVersionRuntime } = process.report.getReport().header;
+        return !glibcVersionRuntime;
+    }
+}
+switch (platform) {
+    case 'android':
+        switch (arch) {
+            case 'arm64':
+                localFileExisted = existsSync(join(__dirname, 'pack.android-arm64.node'));
+                try {
+                    if (localFileExisted) {
+                        nativeBinding = require('./pack.android-arm64.node');
+                    }
+                    else {
+                        nativeBinding = require('@utoo/pack-android-arm64');
+                    }
+                }
+                catch (e) {
+                    loadError = e;
+                }
+                break;
+            case 'arm':
+                localFileExisted = existsSync(join(__dirname, 'pack.android-arm-eabi.node'));
+                try {
+                    if (localFileExisted) {
+                        nativeBinding = require('./pack.android-arm-eabi.node');
+                    }
+                    else {
+                        nativeBinding = require('@utoo/pack-android-arm-eabi');
+                    }
+                }
+                catch (e) {
+                    loadError = e;
+                }
+                break;
+            default:
+                throw new Error(`Unsupported architecture on Android ${arch}`);
+        }
+        break;
+    case 'win32':
+        switch (arch) {
+            case 'x64':
+                localFileExisted = existsSync(join(__dirname, 'pack.win32-x64-msvc.node'));
+                try {
+                    if (localFileExisted) {
+                        nativeBinding = require('./pack.win32-x64-msvc.node');
+                    }
+                    else {
+                        nativeBinding = require('@utoo/pack-win32-x64-msvc');
+                    }
+                }
+                catch (e) {
+                    loadError = e;
+                }
+                break;
+            case 'ia32':
+                localFileExisted = existsSync(join(__dirname, 'pack.win32-ia32-msvc.node'));
+                try {
+                    if (localFileExisted) {
+                        nativeBinding = require('./pack.win32-ia32-msvc.node');
+                    }
+                    else {
+                        nativeBinding = require('@utoo/pack-win32-ia32-msvc');
+                    }
+                }
+                catch (e) {
+                    loadError = e;
+                }
+                break;
+            case 'arm64':
+                localFileExisted = existsSync(join(__dirname, 'pack.win32-arm64-msvc.node'));
+                try {
+                    if (localFileExisted) {
+                        nativeBinding = require('./pack.win32-arm64-msvc.node');
+                    }
+                    else {
+                        nativeBinding = require('@utoo/pack-win32-arm64-msvc');
+                    }
+                }
+                catch (e) {
+                    loadError = e;
+                }
+                break;
+            default:
+                throw new Error(`Unsupported architecture on Windows: ${arch}`);
+        }
+        break;
+    case 'darwin':
+        localFileExisted = existsSync(join(__dirname, 'pack.darwin-universal.node'));
+        try {
+            if (localFileExisted) {
+                nativeBinding = require('./pack.darwin-universal.node');
+            }
+            else {
+                nativeBinding = require('@utoo/pack-darwin-universal');
+            }
+            break;
+        }
+        catch (_a) { }
+        switch (arch) {
+            case 'x64':
+                localFileExisted = existsSync(join(__dirname, 'pack.darwin-x64.node'));
+                try {
+                    if (localFileExisted) {
+                        nativeBinding = require('./pack.darwin-x64.node');
+                    }
+                    else {
+                        nativeBinding = require('@utoo/pack-darwin-x64');
+                    }
+                }
+                catch (e) {
+                    loadError = e;
+                }
+                break;
+            case 'arm64':
+                localFileExisted = existsSync(join(__dirname, 'pack.darwin-arm64.node'));
+                try {
+                    if (localFileExisted) {
+                        nativeBinding = require('./pack.darwin-arm64.node');
+                    }
+                    else {
+                        nativeBinding = require('@utoo/pack-darwin-arm64');
+                    }
+                }
+                catch (e) {
+                    loadError = e;
+                }
+                break;
+            default:
+                throw new Error(`Unsupported architecture on macOS: ${arch}`);
+        }
+        break;
+    case 'freebsd':
+        if (arch !== 'x64') {
+            throw new Error(`Unsupported architecture on FreeBSD: ${arch}`);
+        }
+        localFileExisted = existsSync(join(__dirname, 'pack.freebsd-x64.node'));
+        try {
+            if (localFileExisted) {
+                nativeBinding = require('./pack.freebsd-x64.node');
+            }
+            else {
+                nativeBinding = require('@utoo/pack-freebsd-x64');
+            }
+        }
+        catch (e) {
+            loadError = e;
+        }
+        break;
+    case 'linux':
+        switch (arch) {
+            case 'x64':
+                if (isMusl()) {
+                    localFileExisted = existsSync(join(__dirname, 'pack.linux-x64-musl.node'));
+                    try {
+                        if (localFileExisted) {
+                            nativeBinding = require('./pack.linux-x64-musl.node');
+                        }
+                        else {
+                            nativeBinding = require('@utoo/pack-linux-x64-musl');
+                        }
+                    }
+                    catch (e) {
+                        loadError = e;
+                    }
+                }
+                else {
+                    localFileExisted = existsSync(join(__dirname, 'pack.linux-x64-gnu.node'));
+                    try {
+                        if (localFileExisted) {
+                            nativeBinding = require('./pack.linux-x64-gnu.node');
+                        }
+                        else {
+                            nativeBinding = require('@utoo/pack-linux-x64-gnu');
+                        }
+                    }
+                    catch (e) {
+                        loadError = e;
+                    }
+                }
+                break;
+            case 'arm64':
+                if (isMusl()) {
+                    localFileExisted = existsSync(join(__dirname, 'pack.linux-arm64-musl.node'));
+                    try {
+                        if (localFileExisted) {
+                            nativeBinding = require('./pack.linux-arm64-musl.node');
+                        }
+                        else {
+                            nativeBinding = require('@utoo/pack-linux-arm64-musl');
+                        }
+                    }
+                    catch (e) {
+                        loadError = e;
+                    }
+                }
+                else {
+                    localFileExisted = existsSync(join(__dirname, 'pack.linux-arm64-gnu.node'));
+                    try {
+                        if (localFileExisted) {
+                            nativeBinding = require('./pack.linux-arm64-gnu.node');
+                        }
+                        else {
+                            nativeBinding = require('@utoo/pack-linux-arm64-gnu');
+                        }
+                    }
+                    catch (e) {
+                        loadError = e;
+                    }
+                }
+                break;
+            case 'arm':
+                if (isMusl()) {
+                    localFileExisted = existsSync(join(__dirname, 'pack.linux-arm-musleabihf.node'));
+                    try {
+                        if (localFileExisted) {
+                            nativeBinding = require('./pack.linux-arm-musleabihf.node');
+                        }
+                        else {
+                            nativeBinding = require('@utoo/pack-linux-arm-musleabihf');
+                        }
+                    }
+                    catch (e) {
+                        loadError = e;
+                    }
+                }
+                else {
+                    localFileExisted = existsSync(join(__dirname, 'pack.linux-arm-gnueabihf.node'));
+                    try {
+                        if (localFileExisted) {
+                            nativeBinding = require('./pack.linux-arm-gnueabihf.node');
+                        }
+                        else {
+                            nativeBinding = require('@utoo/pack-linux-arm-gnueabihf');
+                        }
+                    }
+                    catch (e) {
+                        loadError = e;
+                    }
+                }
+                break;
+            case 'riscv64':
+                if (isMusl()) {
+                    localFileExisted = existsSync(join(__dirname, 'pack.linux-riscv64-musl.node'));
+                    try {
+                        if (localFileExisted) {
+                            nativeBinding = require('./pack.linux-riscv64-musl.node');
+                        }
+                        else {
+                            nativeBinding = require('@utoo/pack-linux-riscv64-musl');
+                        }
+                    }
+                    catch (e) {
+                        loadError = e;
+                    }
+                }
+                else {
+                    localFileExisted = existsSync(join(__dirname, 'pack.linux-riscv64-gnu.node'));
+                    try {
+                        if (localFileExisted) {
+                            nativeBinding = require('./pack.linux-riscv64-gnu.node');
+                        }
+                        else {
+                            nativeBinding = require('@utoo/pack-linux-riscv64-gnu');
+                        }
+                    }
+                    catch (e) {
+                        loadError = e;
+                    }
+                }
+                break;
+            case 's390x':
+                localFileExisted = existsSync(join(__dirname, 'pack.linux-s390x-gnu.node'));
+                try {
+                    if (localFileExisted) {
+                        nativeBinding = require('./pack.linux-s390x-gnu.node');
+                    }
+                    else {
+                        nativeBinding = require('@utoo/pack-linux-s390x-gnu');
+                    }
+                }
+                catch (e) {
+                    loadError = e;
+                }
+                break;
+            default:
+                throw new Error(`Unsupported architecture on Linux: ${arch}`);
+        }
+        break;
+    default:
+        throw new Error(`Unsupported OS: ${platform}, architecture: ${arch}`);
+}
+if (!nativeBinding) {
+    if (loadError) {
+        throw loadError;
+    }
+    throw new Error(`Failed to load native binding`);
+}
+const { endpointWriteToDisk, endpointServerChangedSubscribe, endpointClientChangedSubscribe, projectNew, projectUpdate, projectOnExit, projectShutdown, projectWriteAllEntrypointsToDisk, projectEntrypointsSubscribe, projectHmrEvents, projectHmrIdentifiersSubscribe, projectUpdateInfoSubscribe, projectTraceSource, projectGetSourceForAsset, projectGetSourceMap, projectGetSourceMapSync, rootTaskDispose, initCustomTraceSubscriber, teardownTraceSubscriber } = nativeBinding;
+module.exports.endpointWriteToDisk = endpointWriteToDisk;
+module.exports.endpointServerChangedSubscribe = endpointServerChangedSubscribe;
+module.exports.endpointClientChangedSubscribe = endpointClientChangedSubscribe;
+module.exports.projectNew = projectNew;
+module.exports.projectUpdate = projectUpdate;
+module.exports.projectOnExit = projectOnExit;
+module.exports.projectShutdown = projectShutdown;
+module.exports.projectWriteAllEntrypointsToDisk = projectWriteAllEntrypointsToDisk;
+module.exports.projectEntrypointsSubscribe = projectEntrypointsSubscribe;
+module.exports.projectHmrEvents = projectHmrEvents;
+module.exports.projectHmrIdentifiersSubscribe = projectHmrIdentifiersSubscribe;
+module.exports.projectUpdateInfoSubscribe = projectUpdateInfoSubscribe;
+module.exports.projectTraceSource = projectTraceSource;
+module.exports.projectGetSourceForAsset = projectGetSourceForAsset;
+module.exports.projectGetSourceMap = projectGetSourceMap;
+module.exports.projectGetSourceMapSync = projectGetSourceMapSync;
+module.exports.rootTaskDispose = rootTaskDispose;
+module.exports.initCustomTraceSubscriber = initCustomTraceSubscriber;
+module.exports.teardownTraceSubscriber = teardownTraceSubscriber;

package/esm/index.d.ts

@@ -0,0 +1 @@
+export declare function build(dir?: string): Promise<void>;

package/esm/index.js

@@ -0,0 +1,69 @@
+import { nanoid } from "nanoid";
+import { projectFactory } from "./project";
+import fs from "fs";
+import path from "path";
+import { formatIssue, isRelevantWarning } from "./util";
+import { xcodeProfilingReady } from "./xcodeProfile";
+// ref:
+// https://github.com/vercel/next.js/pull/51883
+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 async function build(dir) {
+    var _a, _b, _c, _d;
+    blockStdout();
+    if (process.env.XCODE_PROFILE) {
+        await xcodeProfilingReady();
+    }
+    const cwd = dir || process.cwd();
+    const projectOptions = JSON.parse(fs.readFileSync(path.join(cwd, "project_options.json"), {
+        encoding: "utf-8",
+    }));
+    const createProject = projectFactory();
+    const project = await createProject({
+        processEnv: (_a = projectOptions.processEnv) !== null && _a !== void 0 ? _a : {},
+        processDefineEnv: (_b = projectOptions.processDefineEnv) !== null && _b !== void 0 ? _b : {
+            client: [],
+            nodejs: [],
+            edge: [],
+        },
+        watch: (_c = projectOptions.watch) !== null && _c !== void 0 ? _c : {
+            enable: false,
+        },
+        dev: (_d = projectOptions.dev) !== null && _d !== void 0 ? _d : false,
+        buildId: nanoid(),
+        config: projectOptions.config,
+        rootPath: path.resolve(cwd, projectOptions.rootPath),
+        projectPath: path.resolve(cwd, projectOptions.projectPath),
+    }, {
+        persistentCaching: false,
+    });
+    const entrypoints = await project.writeAllEntrypointsToDisk();
+    const topLevelErrors = [];
+    const topLevelWarnings = [];
+    for (const issue of entrypoints.issues) {
+        if (issue.severity === "error" || issue.severity === "fatal") {
+            topLevelErrors.push(formatIssue(issue));
+        }
+        else if (isRelevantWarning(issue)) {
+            topLevelWarnings.push(formatIssue(issue));
+        }
+    }
+    if (topLevelWarnings.length > 0) {
+        console.warn(`Turbopack build encountered ${topLevelWarnings.length} warnings:\n${topLevelWarnings.join("\n")}`);
+    }
+    if (topLevelErrors.length > 0) {
+        throw new Error(`Turbopack build failed with ${topLevelErrors.length} errors:\n${topLevelErrors.join("\n")}`);
+    }
+    await project.shutdown();
+    // TODO: Maybe run tasks in worker is a better way, see
+    // https://github.com/vercel/next.js/blob/512d8283054407ab92b2583ecce3b253c3be7b85/packages/next/src/lib/worker.ts
+}

package/esm/magicIdentifier.d.ts

@@ -0,0 +1,2 @@
+export declare function decodeMagicIdentifier(identifier: string): string;
+export declare const MAGIC_IDENTIFIER_REGEX: RegExp;

package/esm/magicIdentifier.js

@@ -0,0 +1,85 @@
+function decodeHex(hexStr) {
+    if (hexStr.trim() === "") {
+        throw new Error("can't decode empty hex");
+    }
+    const num = parseInt(hexStr, 16);
+    if (isNaN(num)) {
+        throw new Error(`invalid hex: \`${hexStr}\``);
+    }
+    return String.fromCodePoint(num);
+}
+const DECODE_REGEX = /^__TURBOPACK__([a-zA-Z0-9_$]+)__$/;
+export function decodeMagicIdentifier(identifier) {
+    const matches = identifier.match(DECODE_REGEX);
+    if (!matches) {
+        return identifier;
+    }
+    const inner = matches[1];
+    let output = "";
+    let mode = 0 /* Mode.Text */;
+    let buffer = "";
+    for (let i = 0; i < inner.length; i++) {
+        const char = inner[i];
+        if (mode === 0 /* Mode.Text */) {
+            if (char === "_") {
+                mode = 1 /* Mode.Underscore */;
+            }
+            else if (char === "$") {
+                mode = 2 /* Mode.Hex */;
+            }
+            else {
+                output += char;
+            }
+        }
+        else if (mode === 1 /* Mode.Underscore */) {
+            if (char === "_") {
+                output += " ";
+                mode = 0 /* Mode.Text */;
+            }
+            else if (char === "$") {
+                output += "_";
+                mode = 2 /* Mode.Hex */;
+            }
+            else {
+                output += char;
+                mode = 0 /* Mode.Text */;
+            }
+        }
+        else if (mode === 2 /* Mode.Hex */) {
+            if (buffer.length === 2) {
+                output += decodeHex(buffer);
+                buffer = "";
+            }
+            if (char === "_") {
+                if (buffer !== "") {
+                    throw new Error(`invalid hex: \`${buffer}\``);
+                }
+                mode = 3 /* Mode.LongHex */;
+            }
+            else if (char === "$") {
+                if (buffer !== "") {
+                    throw new Error(`invalid hex: \`${buffer}\``);
+                }
+                mode = 0 /* Mode.Text */;
+            }
+            else {
+                buffer += char;
+            }
+        }
+        else if (mode === 3 /* Mode.LongHex */) {
+            if (char === "_") {
+                throw new Error(`invalid hex: \`${buffer + char}\``);
+            }
+            else if (char === "$") {
+                output += decodeHex(buffer);
+                buffer = "";
+                mode = 0 /* Mode.Text */;
+            }
+            else {
+                buffer += char;
+            }
+        }
+    }
+    return output;
+}
+export const MAGIC_IDENTIFIER_REGEX = /__TURBOPACK__[a-zA-Z0-9_$]+__/g;

package/esm/project.d.ts

@@ -0,0 +1,43 @@
+import * as binding from "./binding";
+import type { NapiWrittenEndpoint, StackFrame } from "./binding";
+import { ProjectOptions, RawEntrypoints, Update } from "./types";
+export declare class TurbopackInternalError extends Error {
+    name: string;
+    constructor(cause: Error);
+}
+export declare function projectFactory(): (options: ProjectOptions, turboEngineOptions: binding.NapiTurboEngineOptions) => Promise<{
+    readonly _nativeProject: {
+        __napiType: "Project";
+    };
+    update(options: Partial<ProjectOptions>): Promise<void>;
+    writeAllEntrypointsToDisk(): Promise<TurbopackResult<RawEntrypoints>>;
+    entrypointsSubscribe(): AsyncGenerator<{
+        apps: {
+            readonly _nativeEndpoint: {
+                __napiType: "Endpoint";
+            };
+            writeToDisk(): Promise<TurbopackResult<NapiWrittenEndpoint>>;
+            clientChanged(): Promise<AsyncIterableIterator<TurbopackResult<{}>>>;
+            serverChanged(includeIssues: boolean): Promise<AsyncIterableIterator<TurbopackResult<{}>>>;
+        }[];
+        libraries: {
+            readonly _nativeEndpoint: {
+                __napiType: "Endpoint";
+            };
+            writeToDisk(): Promise<TurbopackResult<NapiWrittenEndpoint>>;
+            clientChanged(): Promise<AsyncIterableIterator<TurbopackResult<{}>>>;
+            serverChanged(includeIssues: boolean): Promise<AsyncIterableIterator<TurbopackResult<{}>>>;
+        }[];
+        issues: binding.NapiIssue[];
+        diagnostics: binding.NapiDiagnostic[];
+    }, void, unknown>;
+    hmrEvents(identifier: string): AsyncIterableIterator<TurbopackResult<Update>>;
+    hmrIdentifiersSubscribe(): AsyncIterableIterator<TurbopackResult<binding.HmrIdentifiers>>;
+    traceSource(stackFrame: StackFrame, currentDirectoryFileUrl: string): Promise<StackFrame | null>;
+    getSourceForAsset(filePath: string): Promise<string | null>;
+    getSourceMap(filePath: string): Promise<string | null>;
+    getSourceMapSync(filePath: string): string | null;
+    updateInfoSubscribe(aggregationMs: number): AsyncIterableIterator<TurbopackResult<binding.NapiUpdateMessage>>;
+    shutdown(): Promise<void>;
+    onExit(): Promise<void>;
+}>;