@utoo/pack 0.0.1-alpha.1

package/cjs/util.js

@@ -0,0 +1,139 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ModuleBuildError = void 0;
+exports.processIssues = processIssues;
+exports.isWellKnownError = isWellKnownError;
+exports.formatIssue = formatIssue;
+exports.renderStyledStringToErrorAnsi = renderStyledStringToErrorAnsi;
+exports.isRelevantWarning = isRelevantWarning;
+const picocolors_1 = require("picocolors");
+const code_frame_1 = require("@babel/code-frame");
+const magicIdentifier_1 = require("./magicIdentifier");
+class ModuleBuildError extends Error {
+    constructor() {
+        super(...arguments);
+        this.name = "ModuleBuildError";
+    }
+}
+exports.ModuleBuildError = ModuleBuildError;
+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"));
+    }
+}
+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;
+}
+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 +=
+            (0, code_frame_1.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;
+}
+function renderStyledStringToErrorAnsi(string) {
+    function decodeMagicIdentifiers(str) {
+        return str.replaceAll(magicIdentifier_1.MAGIC_IDENTIFIER_REGEX, (ident) => {
+            try {
+                return (0, picocolors_1.magenta)(`{${(0, magicIdentifier_1.decodeMagicIdentifier)(ident)}}`);
+            }
+            catch (e) {
+                return (0, picocolors_1.magenta)(`{${ident} (decoding failed: ${e})}`);
+            }
+        });
+    }
+    switch (string.type) {
+        case "text":
+            return decodeMagicIdentifiers(string.value);
+        case "strong":
+            return (0, picocolors_1.bold)((0, picocolors_1.red)(decodeMagicIdentifiers(string.value)));
+        case "code":
+            return (0, picocolors_1.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);
+    }
+}
+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/cjs/xcodeProfile.d.ts

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

package/cjs/xcodeProfile.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.xcodeProfilingReady = xcodeProfilingReady;
+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/esm/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