@utoo/pack 0.0.1-alpha.1

package/bin/cli.js

@@ -0,0 +1,9 @@
+#!/usr/bin/env node
+const { build } = require("../cjs/index.js");
+
+console.log(process.argv);
+
+// Get the directory argument, default to current directory
+const dir = process.argv[2] || process.cwd();
+
+build(dir);

package/cjs/binding.d.ts

@@ -0,0 +1,222 @@
+/* tslint:disable */
+/* eslint-disable */
+
+/* auto-generated by NAPI-RS */
+
+export declare class ExternalObject<T> {
+  readonly '': {
+    readonly '': unique symbol
+    [K: symbol]: T
+  }
+}
+export interface TransformOutput {
+  code: string
+  map?: string
+  output?: string
+  diagnostics: Array<string>
+}
+export interface NapiEndpointConfig {
+  
+}
+export interface NapiServerPath {
+  path: string
+  contentHash: string
+}
+export interface NapiWrittenEndpoint {
+  type: string
+  entryPath?: string
+  clientPaths: Array<string>
+  serverPaths: Array<NapiServerPath>
+  config: NapiEndpointConfig
+}
+export declare function endpointWriteToDisk(endpoint: { __napiType: "Endpoint" }): Promise<TurbopackResult>
+export declare function endpointServerChangedSubscribe(endpoint: { __napiType: "Endpoint" }, issues: boolean, func: (...args: any[]) => any): { __napiType: "RootTask" }
+export declare function endpointClientChangedSubscribe(endpoint: { __napiType: "Endpoint" }, func: (...args: any[]) => any): { __napiType: "RootTask" }
+export interface NapiEnvVar {
+  name: string
+  value: string
+}
+export interface NapiWatchOptions {
+  /** Whether to watch the filesystem for file changes. */
+  enable: boolean
+  /**
+   * Enable polling at a certain interval if the native file watching doesn't work (e.g.
+   * docker).
+   */
+  pollIntervalMs?: number
+}
+export interface NapiProjectOptions {
+  /**
+   * 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
+  /** Filesystem watcher options. */
+  watch: NapiWatchOptions
+  /** The contents of config.js, serialized to JSON. */
+  config: string
+  /** A map of environment variables to use when compiling code. */
+  processEnv: Array<NapiEnvVar>
+  /**
+   * A map of environment variables which should get injected at compile
+   * time.
+   */
+  processDefineEnv: NapiDefineEnv
+  /** The mode in which Next.js is running. */
+  dev: boolean
+  /** The build id. */
+  buildId: string
+}
+/** [NapiProjectOptions] with all fields optional. */
+export interface NapiPartialProjectOptions {
+  /**
+   * 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
+  /** Filesystem watcher options. */
+  watch?: NapiWatchOptions
+  /** The contents of config.js, serialized to JSON. */
+  config?: string
+  /** A map of environment variables to use when compiling code. */
+  processEnv?: Array<NapiEnvVar>
+  /**
+   * A map of environment variables which should get injected at compile
+   * time.
+   */
+  processDefineEnv?: NapiDefineEnv
+  /** The mode in which Next.js is running. */
+  dev?: boolean
+  /** The build id. */
+  buildId?: string
+  /**
+   * When the code is minified, this opts out of the default mangling of
+   * local names for variables, functions etc., which can be useful for
+   * debugging/profiling purposes.
+   */
+  noMangling?: boolean
+}
+export interface NapiDefineEnv {
+  client: Array<NapiEnvVar>
+  edge: Array<NapiEnvVar>
+  nodejs: Array<NapiEnvVar>
+}
+export interface NapiTurboEngineOptions {
+  /** Use the new backend with persistent caching enabled. */
+  persistentCaching?: boolean
+  /** An upper bound of memory that turbopack will attempt to stay under. */
+  memoryLimit?: number
+  /** Track dependencies between tasks. If false, any change during build will error. */
+  dependencyTracking?: boolean
+}
+export declare function projectNew(options: NapiProjectOptions, turboEngineOptions: NapiTurboEngineOptions): Promise<{ __napiType: "Project" }>
+export declare function projectUpdate(project: { __napiType: "Project" }, options: NapiPartialProjectOptions): Promise<void>
+/**
+ * Runs exit handlers for the project registered using the [`ExitHandler`] API.
+ *
+ * This is called by `project_shutdown`, so if you're calling that API, you shouldn't call this
+ * one.
+ */
+export declare function projectOnExit(project: { __napiType: "Project" }): Promise<void>
+/**
+ * Runs `project_on_exit`, and then waits for turbo_tasks to gracefully shut down.
+ *
+ * This is used in builds where it's important that we completely persist turbo-tasks to disk, but
+ * it's skipped in the development server (`project_on_exit` is used instead with a short timeout),
+ * where we prioritize fast exit and user responsiveness over all else.
+ */
+export declare function projectShutdown(project: { __napiType: "Project" }): Promise<void>
+export interface NapiEntrypoints {
+  apps?: Array<ExternalObject<ExternalEndpoint>>
+  libraries?: Array<ExternalObject<ExternalEndpoint>>
+}
+export declare function projectWriteAllEntrypointsToDisk(project: { __napiType: "Project" }): Promise<TurbopackResult>
+export declare function projectEntrypointsSubscribe(project: { __napiType: "Project" }, func: (...args: any[]) => any): { __napiType: "RootTask" }
+export declare function projectHmrEvents(project: { __napiType: "Project" }, identifier: string, func: (...args: any[]) => any): { __napiType: "RootTask" }
+export interface HmrIdentifiers {
+  identifiers: Array<string>
+}
+export declare function projectHmrIdentifiersSubscribe(project: { __napiType: "Project" }, func: (...args: any[]) => any): { __napiType: "RootTask" }
+export interface NapiUpdateMessage {
+  updateType: string
+  value?: NapiUpdateInfo
+}
+export interface NapiUpdateInfo {
+  duration: number
+  tasks: number
+}
+/**
+ * Subscribes to lifecycle events of the compilation.
+ *
+ * Emits an [UpdateMessage::Start] event when any computation starts.
+ * Emits an [UpdateMessage::End] event when there was no computation for the
+ * specified time (`aggregation_ms`). The [UpdateMessage::End] event contains
+ * information about the computations that happened since the
+ * [UpdateMessage::Start] event. It contains the duration of the computation
+ * (excluding the idle time that was spend waiting for `aggregation_ms`), and
+ * the number of tasks that were executed.
+ *
+ * The signature of the `func` is `(update_message: UpdateMessage) => void`.
+ */
+export declare function projectUpdateInfoSubscribe(project: { __napiType: "Project" }, aggregationMs: number, func: (...args: any[]) => any): void
+export interface StackFrame {
+  isServer: boolean
+  isInternal?: boolean
+  originalFile?: string
+  file: string
+  line?: number
+  column?: number
+  methodName?: string
+}
+export declare function projectTraceSource(project: { __napiType: "Project" }, frame: StackFrame, currentDirectoryFileUrl: string): Promise<StackFrame | null>
+export declare function projectGetSourceForAsset(project: { __napiType: "Project" }, filePath: string): Promise<string | null>
+export declare function projectGetSourceMap(project: { __napiType: "Project" }, filePath: string): Promise<string | null>
+export declare function projectGetSourceMapSync(project: { __napiType: "Project" }, filePath: string): string | null
+export declare function rootTaskDispose(rootTask: { __napiType: "RootTask" }): void
+export interface NapiIssue {
+  severity: string
+  stage: string
+  filePath: string
+  title: any
+  description?: any
+  detail?: any
+  source?: NapiIssueSource
+  documentationLink: string
+  subIssues: Array<NapiIssue>
+}
+export interface NapiIssueSource {
+  source: NapiSource
+  range?: NapiIssueSourceRange
+}
+export interface NapiIssueSourceRange {
+  start: NapiSourcePos
+  end: NapiSourcePos
+}
+export interface NapiSource {
+  ident: string
+  content?: string
+}
+export interface NapiSourcePos {
+  line: number
+  column: number
+}
+export interface NapiDiagnostic {
+  category: string
+  name: string
+  payload: Record<string, string>
+}
+/**
+ * Initialize tracing subscriber to emit traces. This configures subscribers
+ * for Trace Event Format <https://docs.google.com/document/d/1CvAClvFfyA5R-PhYUmn5OOQtYMH4h6I0nSsKchNAySU/preview>.
+ */
+export declare function initCustomTraceSubscriber(traceOutFilePath?: string | undefined | null): ExternalObject<RefCell>
+/**
+ * Teardown currently running tracing subscriber to flush out remaining traces.
+ * This should be called when parent node.js process exits, otherwise generated
+ * trace may drop traces in the buffer.
+ */
+export declare function teardownTraceSubscriber(guardExternal: ExternalObject<RefCell>): void

package/cjs/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/cjs/index.d.ts

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

package/cjs/index.js

@@ -0,0 +1,75 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.build = build;
+const nanoid_1 = require("nanoid");
+const project_1 = require("./project");
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const util_1 = require("./util");
+const xcodeProfile_1 = require("./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);
+    }
+}
+async function build(dir) {
+    var _a, _b, _c, _d;
+    blockStdout();
+    if (process.env.XCODE_PROFILE) {
+        await (0, xcodeProfile_1.xcodeProfilingReady)();
+    }
+    const cwd = dir || process.cwd();
+    const projectOptions = JSON.parse(fs_1.default.readFileSync(path_1.default.join(cwd, "project_options.json"), {
+        encoding: "utf-8",
+    }));
+    const createProject = (0, project_1.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: (0, nanoid_1.nanoid)(),
+        config: projectOptions.config,
+        rootPath: path_1.default.resolve(cwd, projectOptions.rootPath),
+        projectPath: path_1.default.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((0, util_1.formatIssue)(issue));
+        }
+        else if ((0, util_1.isRelevantWarning)(issue)) {
+            topLevelWarnings.push((0, util_1.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/cjs/magicIdentifier.d.ts

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