@utoo/pack-shared 0.0.1

package/esm/index.d.ts

@@ -0,0 +1,3 @@
+export { formatIssue, handleIssues } from "./issue";
+export { decodeMagicIdentifier } from "./magicIdentifier";
+export { renderStyledStringToErrorAnsi } from "./styledString";

package/esm/index.js

@@ -0,0 +1,3 @@
+export { formatIssue, handleIssues } from "./issue";
+export { decodeMagicIdentifier } from "./magicIdentifier";
+export { renderStyledStringToErrorAnsi } from "./styledString";

package/esm/issue.d.ts

@@ -0,0 +1,29 @@
+export interface Issue {
+    severity: string;
+    stage: string;
+    filePath: string;
+    title: any;
+    description?: any;
+    detail?: any;
+    source?: IssueSource;
+    documentationLink: string;
+    importTraces: any;
+}
+export interface IssueSource {
+    source: Source;
+    range?: IssueSourceRange;
+}
+export interface IssueSourceRange {
+    start: SourcePos;
+    end: SourcePos;
+}
+export interface Source {
+    ident: string;
+    content?: string;
+}
+export interface SourcePos {
+    line: number;
+    column: number;
+}
+export declare function formatIssue(issue: Issue): string;
+export declare function handleIssues(issues: Issue[]): void;

package/esm/issue.js

@@ -0,0 +1,82 @@
+import { codeFrameColumns } from "@babel/code-frame";
+import { renderStyledStringToErrorAnsi } from "./styledString";
+export 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 +=
+            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;
+}
+export function handleIssues(issues) {
+    const topLevelErrors = [];
+    const topLevelWarnings = [];
+    for (const issue of 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(`Utoopack build encountered ${topLevelWarnings.length} warnings:\n${topLevelWarnings.join("\n")}`);
+    }
+    if (topLevelErrors.length > 0) {
+        throw new Error(`Utoopack build failed with ${topLevelErrors.length} errors:\n${topLevelErrors.join("\n")}`);
+    }
+}
+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/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/styledString.d.ts

@@ -0,0 +1,17 @@
+export type StyledString = {
+    type: "text";
+    value: string;
+} | {
+    type: "code";
+    value: string;
+} | {
+    type: "strong";
+    value: string;
+} | {
+    type: "stack";
+    value: StyledString[];
+} | {
+    type: "line";
+    value: StyledString[];
+};
+export declare function renderStyledStringToErrorAnsi(string: StyledString): string;

package/esm/styledString.js

@@ -0,0 +1,28 @@
+import { bold, green, magenta, red } from "picocolors";
+import { decodeMagicIdentifier, MAGIC_IDENTIFIER_REGEX, } from "./magicIdentifier";
+export function renderStyledStringToErrorAnsi(string) {
+    function decodeMagicIdentifiers(str) {
+        return str.replaceAll(MAGIC_IDENTIFIER_REGEX, (ident) => {
+            try {
+                return magenta(`{${decodeMagicIdentifier(ident)}}`);
+            }
+            catch (e) {
+                return magenta(`{${ident} (decoding failed: ${e})}`);
+            }
+        });
+    }
+    switch (string.type) {
+        case "text":
+            return decodeMagicIdentifiers(string.value);
+        case "strong":
+            return bold(red(decodeMagicIdentifiers(string.value)));
+        case "code":
+            return 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);
+    }
+}

package/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "@utoo/pack-shared",
+  "version": "0.0.1",
+  "module": "esm/index.js",
+  "types": "esm/index.d.ts",
+  "files": [
+    "esm/*"
+  ],
+  "scripts": {
+    "build": "rm -rf esm && tsc -p ./tsconfig.json"
+  },
+  "dependencies": {
+    "@babel/code-frame": "7.22.5",
+    "picocolors": "^1.1.1"
+  },
+  "devDependencies": {
+    "typescript": "^5.8.3",
+    "@types/babel__code-frame": "7.0.2"
+  },
+  "engines": {
+    "node": ">= 20"
+  },
+  "author": "xusd320",
+  "license": "MIT",
+  "repository": "git@github.com:utooland/utoo.git"
+}