@utoo/pack-shared 0.0.7 → 1.1.8-rc.2

package/README.md

@@ -0,0 +1,19 @@
+# @utoo/pack-shared
+
+Shared utilities and types for the Utoo toolchain.
+
+## 📦 Features
+
+- ⚠️ **Issue Reporting**: Standardized issue and error reporting utilities.
+- 🆔 **Magic Identifiers**: Utilities for handling internal identifiers.
+- 🎨 **Styled Strings**: Terminal string styling helpers.
+
+## 📦 Installation
+
+```bash
+npm install @utoo/pack-shared
+```
+
+## 📄 License
+
+[MIT](./LICENSE)

package/cjs/config.d.ts

@@ -0,0 +1,227 @@
+export interface EntryOptions {
+    name?: string;
+    import: string;
+    library?: LibraryOptions;
+    /**
+     * Configuration for generating an HTML file for this entry point.
+     * When specified, an HTML file will be generated with the entry's assets injected.
+     *
+     * Similar to https://github.com/jantimon/html-webpack-plugin#options
+     */
+    html?: HtmlConfig;
+}
+export interface LibraryOptions {
+    name?: string;
+    export?: Array<string>;
+}
+export interface DefineEnv {
+    client: RustifiedEnv;
+    edge: RustifiedEnv;
+    nodejs: RustifiedEnv;
+}
+export type RustifiedEnv = {
+    name: string;
+    value: string;
+}[];
+export interface ExperimentalConfig {
+}
+export type TurbopackRuleConfigItem = TurbopackRuleConfigItemOptions | {
+    [condition: string]: TurbopackRuleConfigItem;
+} | false;
+/**
+ * @deprecated Use `TurbopackRuleConfigItem` instead.
+ */
+export type TurbopackLoaderItem = string | {
+    loader: string;
+    options: Record<string, JSONValue>;
+};
+export type TurbopackRuleConfigItemOrShortcut = TurbopackLoaderItem[] | TurbopackRuleConfigItem;
+export type TurbopackRuleConfigItemOptions = {
+    loaders: TurbopackLoaderItem[];
+    as?: string;
+};
+export type TurbopackRuleCondition = {
+    path: string | RegExp;
+};
+export interface ModuleOptions {
+    rules?: Record<string, TurbopackRuleConfigItem>;
+}
+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;
+/**
+ * Provider configuration for automatic module imports.
+ * Similar to webpack's ProvidePlugin.
+ *
+ * @example
+ * ```ts
+ * provider: {
+ *   // Provides `$` as `import $ from 'jquery'`
+ *   $: 'jquery',
+ *   // Provides `Buffer` as `import { Buffer } from 'buffer'`
+ *   Buffer: ['buffer', 'Buffer'],
+ * }
+ * ```
+ */
+export type ProviderConfig = Record<string, string | [string, string]>;
+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;
+        clean?: boolean;
+        copy?: Array<{
+            from: string;
+            to?: string;
+        } | string>;
+        publicPath?: string;
+    };
+    target?: string;
+    sourceMaps?: boolean;
+    define?: Record<string, string>;
+    provider?: ProviderConfig;
+    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;
+            handleDefaultImport?: boolean;
+            handleNamespaceImport?: boolean;
+            style?: string;
+        }>;
+        packageImports?: string[];
+        transpilePackages?: string[];
+        removeConsole?: boolean | {
+            exclude?: string[];
+        };
+        concatenateModules?: boolean;
+        removeUnusedExports?: boolean;
+        nestedAsyncChunking?: boolean;
+        wasmAsAsset?: boolean;
+    };
+    styles?: {
+        less?: {
+            implementation?: string;
+            [key: string]: any;
+        };
+        sass?: {
+            implementation?: string;
+            [key: string]: any;
+        };
+        inlineCss?: {
+            insert?: string;
+            injectType?: string;
+        };
+        styledJsx?: boolean | {
+            useLightningcss?: boolean;
+        };
+        styledComponents?: boolean | StyledComponentsConfig;
+        emotion?: boolean | EmotionConfig;
+    };
+    images?: {
+        inlineLimit?: number;
+    };
+    stats?: boolean;
+    persistentCaching?: boolean;
+    nodePolyfill?: boolean;
+    devServer?: {
+        hot: boolean;
+    };
+    cacheHandler?: string;
+    experimental?: ExperimentalConfig;
+}
+export interface HtmlConfig {
+    template?: string;
+    templateContent?: string;
+    filename?: string;
+    title?: string;
+    inject?: boolean | "body" | "head";
+    scriptLoading?: "blocking" | "defer" | "module";
+    meta?: Record<string, string | {
+        [key: string]: 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 BundleOptions {
+    /**
+     * The utoo pack configs.
+     */
+    config: ConfigComplete;
+    /**
+     * A map of environment variables to use when compiling code.
+     */
+    processEnv?: Record<string, string>;
+    defineEnv?: DefineEnv;
+    /**
+     * Whether to watch the filesystem for file changes.
+     */
+    watch?: {
+        enable: boolean;
+        pollIntervalMs?: number;
+    };
+    /**
+     * The mode of utoopack.
+     */
+    dev?: boolean;
+    /**
+     * The build id.
+     */
+    buildId?: string;
+    /**
+     * Absolute path for `@utoo/pack`.
+     */
+    packPath?: string;
+}

package/cjs/config.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/cjs/index.d.ts

@@ -1,3 +1,6 @@
+export * from "./config";
 export { formatIssue, handleIssues, Issue } from "./issue";
 export { decodeMagicIdentifier } from "./magicIdentifier";
 export { renderStyledStringToErrorAnsi } from "./styledString";
+export * from "./utils";
+export * from "./webpackCompat";

package/cjs/index.js

@@ -1,6 +1,21 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.renderStyledStringToErrorAnsi = exports.decodeMagicIdentifier = exports.handleIssues = exports.formatIssue = void 0;
+__exportStar(require("./config"), exports);
 var issue_1 = require("./issue");
 Object.defineProperty(exports, "formatIssue", { enumerable: true, get: function () { return issue_1.formatIssue; } });
 Object.defineProperty(exports, "handleIssues", { enumerable: true, get: function () { return issue_1.handleIssues; } });
@@ -8,3 +23,5 @@ var magicIdentifier_1 = require("./magicIdentifier");
 Object.defineProperty(exports, "decodeMagicIdentifier", { enumerable: true, get: function () { return magicIdentifier_1.decodeMagicIdentifier; } });
 var styledString_1 = require("./styledString");
 Object.defineProperty(exports, "renderStyledStringToErrorAnsi", { enumerable: true, get: function () { return styledString_1.renderStyledStringToErrorAnsi; } });
+__exportStar(require("./utils"), exports);
+__exportStar(require("./webpackCompat"), exports);

package/cjs/utils.d.ts

@@ -0,0 +1,20 @@
+import { ConfigComplete, DefineEnv, RustifiedEnv } from "./config";
+import { Issue } from "./issue";
+export declare class ModuleBuildError extends Error {
+    name: string;
+}
+export interface ResultWithIssues {
+    issues: Issue[];
+}
+export declare function processIssues(result: ResultWithIssues, throwIssue: boolean, logErrors: boolean): void;
+export declare function isWellKnownError(issue: Issue): 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 {};

package/cjs/utils.js

@@ -0,0 +1,134 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ModuleBuildError = void 0;
+exports.processIssues = processIssues;
+exports.isWellKnownError = isWellKnownError;
+exports.rustifyEnv = rustifyEnv;
+exports.createDefineEnv = createDefineEnv;
+exports.debounce = debounce;
+const issue_1 = require("./issue");
+const styledString_1 = require("./styledString");
+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 = (0, issue_1.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 = (0, issue_1.formatIssue)(issue);
+                console.error(formatted);
+            }
+        }
+    }
+    if (relevantIssues.size && throwIssue) {
+        throw new ModuleBuildError([...relevantIssues].join("\n\n"));
+    }
+}
+function isWellKnownError(issue) {
+    const { title } = issue;
+    const formattedTitle = (0, styledString_1.renderStyledStringToErrorAnsi)(title);
+    // TODO: add more well known errors
+    if (formattedTitle.includes("Module not found") ||
+        formattedTitle.includes("Unknown module type")) {
+        return true;
+    }
+    return false;
+}
+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);
+        }
+    };
+}

package/cjs/webpackCompat.d.ts

@@ -0,0 +1,6 @@
+import type webpack from "webpack";
+import { BundleOptions } from "./config";
+export type WebpackConfig = Partial<Pick<webpack.Configuration, "name" | "entry" | "mode" | "module" | "resolve" | "externals" | "output" | "target" | "devtool" | "optimization" | "plugins" | "stats">> & {
+    webpackMode: true;
+};
+export declare function compatOptionsFromWebpack(webpackConfig: WebpackConfig): BundleOptions;