@utoo/pack 0.0.1-alpha.1 → 0.0.1-alpha.13

package/cjs/util.d.ts

@@ -1,5 +1,5 @@
 import { NapiIssue } from "./binding";
-import { StyledString } from "./types";
+import { ConfigComplete, DefineEnv, RustifiedEnv, StyledString } from "./types";
 export declare class ModuleBuildError extends Error {
     name: string;
 }
@@ -8,3 +8,14 @@ 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;
+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 {};

package/cjs/util.js

@@ -6,8 +6,12 @@ exports.isWellKnownError = isWellKnownError;
 exports.formatIssue = formatIssue;
 exports.renderStyledStringToErrorAnsi = renderStyledStringToErrorAnsi;
 exports.isRelevantWarning = isRelevantWarning;
-const picocolors_1 = require("picocolors");
+exports.rustifyEnv = rustifyEnv;
+exports.createDefineEnv = createDefineEnv;
+exports.debounce = debounce;
+exports.blockStdout = blockStdout;
 const code_frame_1 = require("@babel/code-frame");
+const picocolors_1 = require("picocolors");
 const magicIdentifier_1 = require("./magicIdentifier");
 class ModuleBuildError extends Error {
     constructor() {
@@ -137,3 +141,100 @@ function isNodeModulesIssue(issue) {
         (issue.filePath.match(/^(?:.*[\\/])?node_modules(?:[\\/].*)?$/) !== null ||
             issue.filePath.includes("@utoo/pack")));
 }
+function rustifyEnv(env) {
+    return Object.entries(env)
+        .filter(([_, value]) => value != null)
+        .map(([name, value]) => ({
+        name,
+        value,
+    }));
+}
+function createDefineEnv(options) {
+    var _a;
+    let defineEnv = (_a = options.optionDefineEnv) !== null && _a !== void 0 ? _a : {
+        client: [],
+        edge: [],
+        nodejs: [],
+    };
+    function getDefineEnv() {
+        var _a;
+        const envs = {
+            "process.env.NODE_ENV": options.dev ? "development" : "production",
+        };
+        const userDefines = (_a = options.config.define) !== null && _a !== void 0 ? _a : {};
+        for (const key in userDefines) {
+            envs[key] = userDefines[key];
+        }
+        // serialize
+        const defineEnvStringified = {};
+        for (const key in defineEnv) {
+            const value = envs[key];
+            defineEnvStringified[key] = JSON.stringify(value);
+        }
+        return defineEnvStringified;
+    }
+    // TODO: future define envs need to extends for more compiler like server or edge.
+    for (const variant of Object.keys(defineEnv)) {
+        defineEnv[variant] = rustifyEnv(getDefineEnv());
+    }
+    return defineEnv;
+}
+function debounce(fn, ms, maxWait = Infinity) {
+    let timeoutId;
+    // The time the debouncing function was first called during this debounce queue.
+    let startTime = 0;
+    // The time the debouncing function was last called.
+    let lastCall = 0;
+    // The arguments and this context of the last call to the debouncing function.
+    let args, context;
+    // A helper used to that either invokes the debounced function, or
+    // reschedules the timer if a more recent call was made.
+    function run() {
+        const now = Date.now();
+        const diff = lastCall + ms - now;
+        // If the diff is non-positive, then we've waited at least `ms`
+        // milliseconds since the last call. Or if we've waited for longer than the
+        // max wait time, we must call the debounced function.
+        if (diff <= 0 || startTime + maxWait >= now) {
+            // It's important to clear the timeout id before invoking the debounced
+            // function, in case the function calls the debouncing function again.
+            timeoutId = undefined;
+            fn.apply(context, args);
+        }
+        else {
+            // Else, a new call was made after the original timer was scheduled. We
+            // didn't clear the timeout (doing so is very slow), so now we need to
+            // reschedule the timer for the time difference.
+            timeoutId = setTimeout(run, diff);
+        }
+    }
+    return function (...passedArgs) {
+        // The arguments and this context of the most recent call are saved so the
+        // debounced function can be invoked with them later.
+        args = passedArgs;
+        context = this;
+        // Instead of constantly clearing and scheduling a timer, we record the
+        // time of the last call. If a second call comes in before the timer fires,
+        // then we'll reschedule in the run function. Doing this is considerably
+        // faster.
+        lastCall = Date.now();
+        // Only schedule a new timer if we're not currently waiting.
+        if (timeoutId === undefined) {
+            startTime = lastCall;
+            timeoutId = setTimeout(run, ms);
+        }
+    };
+}
+// 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);
+    }
+}