@gracile-labs/better-errors 0.1.0-next.0

package/dist/dev/utils.js

@@ -0,0 +1,271 @@
+/* eslint-disable */
+import c from 'picocolors';
+import * as fs from 'node:fs';
+import { isAbsolute, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { normalizePath } from 'vite';
+import { codeFrame } from './printer.js';
+import { removeLeadingForwardSlashWindows } from '@gracile/internal-utils/paths';
+import { AggregateError, } from '../errors.js';
+const ansiPattern = [
+    '[\\u001B\\u009B][[\\]()#;?]*(?:(?:(?:(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]+)*|[a-zA-Z\\d]+(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]*)*)?\\u0007)',
+    '(?:(?:\\d{1,4}(?:;\\d{0,4})*)?[\\dA-PR-TZcf-ntqry=><~]))',
+].join('|');
+const stripAnsi = (input, { onlyFirst = false } = {}) => {
+    return input.replace(new RegExp(ansiPattern, onlyFirst ? undefined : 'g'), '');
+};
+/** Coalesce any throw variable to an Error instance. */
+export function createSafeError(err) {
+    if (err instanceof Error || (err?.name && err.message)) {
+        return err;
+    }
+    else {
+        const error = new Error(JSON.stringify(err));
+        error['hint'] =
+            `To get as much information as possible from your errors, make sure to throw Error objects instead of \`${typeof err}\`. See https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error for more information.`;
+        return error;
+    }
+}
+export function normalizeLF(code) {
+    return code.replace(/\r\n|\r(?!\n)|\n/g, '\n');
+}
+/**
+ * Takes any error-like object and returns a standardized Error + metadata object.
+ * Useful for consistent reporting regardless of where the error surfaced from.
+ */
+export function collectErrorMetadata(e, rootFolder) {
+    const err = AggregateError.is(e) || Array.isArray(e.errors)
+        ? e.errors
+        : [e];
+    err.forEach((error) => {
+        if (e.stack) {
+            const stackInfo = collectInfoFromStacktrace(e);
+            try {
+                error.stack = stripAnsi(stackInfo.stack);
+            }
+            catch { }
+            if (stackInfo.loc)
+                error.loc = stackInfo.loc;
+            if (stackInfo.plugin)
+                error.plugin = stackInfo.plugin;
+            if (stackInfo.pluginCode)
+                error.pluginCode = stackInfo.pluginCode;
+        }
+        // Make sure the file location is absolute, otherwise:
+        // - It won't be clickable in the terminal
+        // - We'll fail to show the file's content in the browser
+        // - We'll fail to show the code frame in the terminal
+        // - The "Open in Editor" button won't work
+        // Normalize the paths so that we can correctly detect if it's absolute on any platform
+        const normalizedFile = normalizePath(error.loc?.file || '');
+        const normalizedRootFolder = removeLeadingForwardSlashWindows(rootFolder?.pathname || '');
+        if (error.loc?.file &&
+            rootFolder &&
+            (!normalizedFile?.startsWith(normalizedRootFolder) ||
+                !isAbsolute(normalizedFile))) {
+            error.loc.file = join(fileURLToPath(rootFolder), error.loc.file);
+        }
+        // If we don't have a frame, but we have a location let's try making up a frame for it
+        if (error.loc && (!error.frame || !error['fullCode'])) {
+            try {
+                const fileContents = fs.readFileSync(error.loc.file, 'utf8');
+                if (!error.frame) {
+                    const frame = codeFrame(fileContents, error.loc);
+                    error.frame = stripAnsi(frame);
+                }
+                if (!error['fullCode']) {
+                    error['fullCode'] = fileContents;
+                }
+            }
+            catch { }
+        }
+        // Generic error (probably from Vite, and already formatted)
+        error['hint'] = generateHint(e);
+        // Strip ANSI for `message` property. Note that ESBuild errors may not have the property,
+        // but it will be handled and added below, which is already ANSI-free
+        if (error.message) {
+            try {
+                error.message = stripAnsi(error.message);
+            }
+            catch {
+                // Setting `error.message` can fail here if the message is read-only, which for the vast majority of cases will never happen, however some somewhat obscure cases can cause this to happen.
+            }
+        }
+    });
+    // If we received an array of errors and it's not from us, it's most likely from ESBuild, try to extract info for Vite to display
+    // NOTE: We still need to be defensive here, because it might not necessarily be from ESBuild, it's just fairly likely.
+    if (!AggregateError.is(e) && Array.isArray(e.errors)) {
+        e.errors.forEach((buildError, i) => {
+            const { location, pluginName, text } = buildError;
+            if (!err[i])
+                return;
+            // ESBuild can give us a slightly better error message than the one in the error, so let's use it
+            if (text) {
+                try {
+                    err[i].message = text;
+                }
+                catch { }
+            }
+            if (location) {
+                err[i].loc = {
+                    file: location.file,
+                    line: location.line,
+                    column: location.column,
+                };
+                err[i].id = err[0]?.id || location?.file;
+            }
+            // Vite adds the error message to the frame for ESBuild errors, we don't want that
+            if (err[i].frame) {
+                const errorLines = err[i].frame?.trim().split('\n');
+                if (errorLines && errorLines[0]) {
+                    err[i].frame = !/^\d/.test(errorLines[0])
+                        ? errorLines?.slice(1).join('\n')
+                        : err[i].frame;
+                }
+            }
+            const possibleFilePath = location?.file ?? err[i].id;
+            if (possibleFilePath &&
+                err[i].loc &&
+                (!err[i].frame || !err[i]['fullCode'])) {
+                try {
+                    const fileContents = fs.readFileSync(possibleFilePath, 'utf8');
+                    if (!err[i].frame) {
+                        err[i].frame = codeFrame(fileContents, {
+                            ...err[i].loc,
+                            file: possibleFilePath,
+                        });
+                    }
+                    err[i]['fullCode'] = fileContents;
+                }
+                catch {
+                    err[i]['fullCode'] = err[i].pluginCode;
+                }
+            }
+            if (pluginName) {
+                err[i].plugin = pluginName;
+            }
+            if (err[0])
+                err[i]['hint'] = generateHint(err[0]);
+        });
+    }
+    // TODO: Handle returning multiple errors
+    // if (err[0]) return err[0];
+    return err[0];
+}
+function generateHint(err) {
+    const commonBrowserAPIs = ['document', 'window'];
+    // 	if (
+    // 		/Unknown file extension "\.(?:jsx|vue|svelte|astro|css)" for /.test(
+    // 			err.message,
+    // 		)
+    // 	) {
+    // 		return 'You likely need to add this package to `vite.ssr.noExternal` in your astro config file.';
+    // 	} else if (commonBrowserAPIs.some((api) => err.toString().includes(api))) {
+    // 		const hint = `Browser APIs are not available on the server.
+    // ${
+    // 	err.loc?.file?.endsWith('.astro')
+    // 		? 'Move your code to a <script> tag outside of the frontmatter, so the code runs on the client.'
+    // 		: 'If the code is in a framework component, try to access these objects after rendering using lifecycle methods or use a `client:only` directive to make the component exclusively run on the client.'
+    // }
+    // See https://docs.astro.build/en/guides/troubleshooting/#document-or-window-is-not-defined for more information.
+    // 		`;
+    // 		return hint;
+    // 	}
+    return err.hint;
+}
+function collectInfoFromStacktrace(error) {
+    // @ts-expect-error exact optional
+    let stackInfo = {
+        stack: error.stack,
+        plugin: error.plugin,
+        pluginCode: error.pluginCode,
+        loc: error.loc,
+    };
+    // normalize error stack line-endings to \n
+    stackInfo.stack = normalizeLF(error.stack);
+    const stackText = stripAnsi(error.stack);
+    // Try to find possible location from stack if we don't have one
+    if (!stackInfo.loc || (!stackInfo.loc.column && !stackInfo.loc.line)) {
+        const possibleFilePath = error.loc?.file ||
+            error.pluginCode ||
+            error.id ||
+            // TODO: this could be better, `src` might be something else
+            stackText
+                .split('\n')
+                .find((ln) => ln.includes('src') || ln.includes('node_modules'));
+        // Disable eslint as we're not sure how to improve this regex yet
+        // eslint-disable-next-line regexp/no-super-linear-backtracking
+        const source = possibleFilePath
+            ?.replace?.(/^[^(]+\(([^)]+).*$/, '$1')
+            .replace(/^\s+at\s+/, '');
+        let file = source?.replace(/:\d+/g, '');
+        const location = /:(\d+):(\d+)/.exec(source) ?? [];
+        const line = location[1];
+        const column = location[2];
+        if (file && line && column) {
+            try {
+                file = fileURLToPath(file);
+            }
+            catch { }
+            stackInfo.loc = {
+                file,
+                line: Number.parseInt(line),
+                column: Number.parseInt(column),
+            };
+        }
+    }
+    // // Derive plugin from stack (if possible)
+    // if (!stackInfo.plugin) {
+    // 	const stack =
+    // 		/withastro\/astro\/packages\/integrations\/([\w-]+)/i
+    // 			.exec(stackText)
+    // 			?.at(1) ||
+    // 		/(@astrojs\/[\w-]+)\/(server|client|index)/i.exec(stackText)?.at(1);
+    // 	if (stack) stackInfo.plugin = stack;
+    // }
+    // Normalize stack (remove `/@fs/` urls, etc)
+    stackInfo.stack = cleanErrorStack(error.stack);
+    return stackInfo;
+}
+function cleanErrorStack(stack) {
+    return stack
+        .split(/\n/)
+        .map((l) => l.replace(/\/@fs\//g, '/'))
+        .join('\n');
+}
+export function getDocsForError(err, errorsData, docsBaseUrl) {
+    if (err.name !== 'UnknownError' && err.name in errorsData) {
+        return `${docsBaseUrl}/${getKebabErrorName(err.name)}/`;
+    }
+    return undefined;
+    /**
+     * The docs has kebab-case urls for errors, so we need to convert the error name
+     * @param errorName
+     */
+    function getKebabErrorName(errorName) {
+        return errorName.replace(/([a-z])([A-Z])/g, '$1-$2').toLowerCase();
+    }
+}
+const linkRegex = /\[([^[]+)\]\((.*)\)/g;
+const boldRegex = /\*\*(.+)\*\*/g;
+const urlRegex = / ((?:https?|ftp):\/\/[-\w+&@#\\/%?=~|!:,.;]*[-\w+&@#\\/%=~|])/gi;
+const codeRegex = /`([^`]+)`/g;
+/**
+ * Render a subset of Markdown to HTML or a CLI output
+ */
+export function renderErrorMarkdown(markdown, target) {
+    if (target === 'html') {
+        //  escape()
+        return markdown
+            .replace(linkRegex, `<a href="$2" target="_blank">$1</a>`)
+            .replace(boldRegex, '<b>$1</b>')
+            .replace(urlRegex, ' <a href="$1" target="_blank">$1</a>')
+            .replace(codeRegex, '<code>$1</code>');
+    }
+    else {
+        return markdown
+            .replace(linkRegex, (_, m1, m2) => `${c.bold(m1)} ${c.underline(m2)}`)
+            .replace(urlRegex, (fullMatch) => ` ${c.underline(fullMatch.trim())}`)
+            .replace(boldRegex, (_, m1) => `${c.bold(m1)}`);
+    }
+}

package/dist/dev/vite.d.ts

@@ -0,0 +1,33 @@
+import type { BetterErrorData } from './../errors-data.js';
+import type { ErrorPayload, ViteDevServer } from 'vite';
+import type { ErrorWithMetadata } from '../errors.js';
+export declare function enhanceViteSSRError({ error, filePath, vite, }: {
+    error: unknown;
+    filePath?: URL | undefined;
+    vite?: ViteDevServer | undefined;
+}): Error;
+export interface BetterErrorPayload {
+    type: ErrorPayload['type'];
+    err: Omit<ErrorPayload['err'], 'loc'> & {
+        name?: string;
+        title?: string;
+        hint?: string;
+        docslink?: string;
+        highlightedCode?: string;
+        loc?: {
+            file?: string;
+            line?: number;
+            column?: number;
+        };
+        cause?: unknown;
+    };
+}
+/**
+ * Generate a payload for Vite's error overlay
+ */
+export declare function getViteErrorPayload({ err, errorsData, docsBaseUrl, }: {
+    err: ErrorWithMetadata;
+    errorsData?: Record<string, BetterErrorData>;
+    docsBaseUrl: string;
+}): Promise<BetterErrorPayload>;
+//# sourceMappingURL=vite.d.ts.map

package/dist/dev/vite.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vite.d.ts","sourceRoot":"","sources":["../../src/dev/vite.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAE3D,OAAO,KAAK,EAAE,YAAY,EAAE,aAAa,EAAE,MAAM,MAAM,CAAC;AASxD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,cAAc,CAAC;AAGtD,wBAAgB,mBAAmB,CAAC,EACnC,KAAK,EACL,QAAQ,EACR,IAAI,GAEJ,EAAE;IACF,KAAK,EAAE,OAAO,CAAC;IACf,QAAQ,CAAC,EAAE,GAAG,GAAG,SAAS,CAAC;IAC3B,IAAI,CAAC,EAAE,aAAa,GAAG,SAAS,CAAC;CAEjC,GAAG,KAAK,CAwFR;AAED,MAAM,WAAW,kBAAkB;IAClC,IAAI,EAAE,YAAY,CAAC,MAAM,CAAC,CAAC;IAC3B,GAAG,EAAE,IAAI,CAAC,YAAY,CAAC,KAAK,CAAC,EAAE,KAAK,CAAC,GAAG;QACvC,IAAI,CAAC,EAAE,MAAM,CAAC;QACd,KAAK,CAAC,EAAE,MAAM,CAAC;QACf,IAAI,CAAC,EAAE,MAAM,CAAC;QACd,QAAQ,CAAC,EAAE,MAAM,CAAC;QAClB,eAAe,CAAC,EAAE,MAAM,CAAC;QACzB,GAAG,CAAC,EAAE;YACL,IAAI,CAAC,EAAE,MAAM,CAAC;YACd,IAAI,CAAC,EAAE,MAAM,CAAC;YACd,MAAM,CAAC,EAAE,MAAM,CAAC;SAChB,CAAC;QACF,KAAK,CAAC,EAAE,OAAO,CAAC;KAChB,CAAC;CACF;AAcD;;GAEG;AACH,wBAAsB,mBAAmB,CAAC,EACzC,GAAG,EACH,UAAU,EACV,WAAW,GACX,EAAE;IACF,GAAG,EAAE,iBAAiB,CAAC;IACvB,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,eAAe,CAAC,CAAC;IAC7C,WAAW,EAAE,MAAM,CAAC;CACpB,GAAG,OAAO,CAAC,kBAAkB,CAAC,CAkF9B"}

package/dist/dev/vite.js

@@ -0,0 +1,191 @@
+/* eslint-disable */
+import * as fs from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { getDocsForError, createSafeError, renderErrorMarkdown, } from './utils.js';
+import { html, render } from '@lit-labs/ssr';
+import { collectResultSync } from '@lit-labs/ssr/lib/render-result.js';
+import { FailedToLoadModuleSSR } from '../errors-data.js';
+export function enhanceViteSSRError({ error, filePath, vite,
+// renderers,
+ }) {
+    // NOTE: We don't know where the error that's coming here comes from, so we need to be defensive regarding what we do
+    // to it to make sure we keep as much information as possible. It's very possible that we receive an error that does not
+    // follow any kind of standard formats (ex: a number, a string etc)
+    // let safeError = error as ErrorWithMetadata;
+    let safeError = createSafeError(error);
+    // Vite will give you better stacktraces, using sourcemaps.
+    if (vite) {
+        try {
+            vite.ssrFixStacktrace(safeError);
+        }
+        catch { }
+    }
+    if (filePath) {
+        const path = fileURLToPath(filePath);
+        const content = fs.readFileSync(path).toString();
+        const lns = content.split('\n');
+        // Vite has a fairly generic error message when it fails to load a module, let's try to enhance it a bit
+        // https://github.com/vitejs/vite/blob/ee7c28a46a6563d54b828af42570c55f16b15d2c/packages/vite/src/node/ssr/ssrModuleLoader.ts#L91
+        let importName;
+        if ((importName = /Failed to load url (.*?) \(resolved id:/.exec(safeError.message)?.[1])) {
+            safeError.title = FailedToLoadModuleSSR.title;
+            safeError.name = 'FailedToLoadModuleSSR';
+            safeError.message = FailedToLoadModuleSSR.message(importName);
+            safeError.hint = FailedToLoadModuleSSR.hint;
+            const line = lns.findIndex((ln) => ln.includes(importName));
+            console.log({ line });
+            if (line !== -1) {
+                const column = lns[line]?.indexOf(importName);
+                safeError.loc = {
+                    file: path,
+                    line: line + 1,
+                };
+                if (column)
+                    safeError.loc.column = column;
+            }
+        }
+        // const fileId = safeError.id ?? safeError.loc?.file;
+        // // Vite throws a syntax error trying to parse MDX without a plugin.
+        // // Suggest installing the MDX integration if none is found.
+        // if (
+        // 	fileId &&
+        // 	!renderers?.find((r) => r.name === '@astrojs/mdx') &&
+        // 	safeError.message.includes('Syntax error') &&
+        // 	/.mdx$/.test(fileId)
+        // ) {
+        // 	safeError = new BetterError({
+        // 		...MdxIntegrationMissingError,
+        // 		message: MdxIntegrationMissingError.message(JSON.stringify(fileId)),
+        // 		location: safeError.loc,
+        // 		stack: safeError.stack,
+        // 	}) as ErrorWithMetadata;
+        // }
+        // // Since Astro.glob is a wrapper around Vite's import.meta.glob, errors don't show accurate information, let's fix that
+        // if (safeError.message.includes('Invalid glob')) {
+        // 	const globPattern = /glob: "(.+)" \(/.exec(safeError.message)?.[1];
+        // 	if (globPattern) {
+        // 		safeError.message = InvalidGlob.message(globPattern);
+        // 		safeError.name = 'InvalidGlob';
+        // 		safeError.title = InvalidGlob.title;
+        // 		const line = lns.findIndex((ln) => ln.includes(globPattern));
+        // 		if (line !== -1) {
+        // 			const column = lns[line]?.indexOf(globPattern);
+        // 			safeError.loc = {
+        // 				file: path,
+        // 				line: line + 1,
+        // 				column,
+        // 			};
+        // 		}
+        // 	}
+        // }
+    }
+    return safeError;
+}
+// Shiki does not support `mjs` or `cjs` aliases by default.
+// Map these to `.js` during error highlighting.
+const ALTERNATIVE_JS_EXTS = ['cjs', 'mjs'];
+const ALTERNATIVE_MD_EXTS = ['mdoc'];
+// let _cssVariablesTheme: ReturnType<typeof createCssVariablesTheme>;
+// const cssVariablesTheme = () =>
+// 	_cssVariablesTheme ??
+// 	(_cssVariablesTheme = createCssVariablesTheme({
+// 		variablePrefix: '--astro-code-',
+// 	}));
+/**
+ * Generate a payload for Vite's error overlay
+ */
+export async function getViteErrorPayload({ err, errorsData, docsBaseUrl, }) {
+    let plugin = err.plugin;
+    if (!plugin && err.hint) {
+        plugin = 'astro';
+    }
+    const message = renderErrorMarkdown(err.message.trim(), 'html');
+    const hint = err.hint
+        ? renderErrorMarkdown(err.hint.trim(), 'html')
+        : undefined;
+    const docslink = errorsData
+        ? getDocsForError(err, errorsData, docsBaseUrl)
+        : undefined;
+    // let highlighterLang = err.loc?.file?.split('.').pop();
+    // if (ALTERNATIVE_JS_EXTS.includes(highlighterLang ?? '')) {
+    // 	highlighterLang = 'js';
+    // } else if (ALTERNATIVE_MD_EXTS.includes(highlighterLang ?? '')) {
+    // 	highlighterLang = 'md';
+    // }
+    // const highlightedCode = err.fullCode
+    // 	? await codeToHtml(err.fullCode, {
+    // 			lang: highlighterLang ?? 'text',
+    // 			theme: cssVariablesTheme(),
+    // 			transformers: [
+    // 				transformerCompactLineOptions(
+    // 					err.loc?.line
+    // 						? [{ line: err.loc.line, classes: ['error-line'] }]
+    // 						: undefined,
+    // 				),
+    // 			],
+    // 		})
+    // 	: undefined;
+    const highlightedCode = err.fullCode
+        ? collectResultSync(render(html `
+					<div id="code-content">
+						<pre
+							class="shiki css-variables"
+							style="background-color:var(--betterr-code-background);color:var(--betterr-code-foreground)"
+							tabindex="0"
+						><code>${err.fullCode
+            .split('\n')
+            .map((l, i) => html `<span
+											class="line ${err.loc?.line === i + 1
+            ? 'error-line'
+            : ''} "
+											>${l}</span
+										>${'\n'}`)}</code></pre>
+					</div>
+				`))
+        : undefined;
+    return {
+        type: 'error',
+        err: {
+            ...err,
+            name: err.name,
+            type: err.type,
+            message,
+            hint,
+            frame: err.frame,
+            highlightedCode,
+            docslink,
+            // @ts-expect-error Exact optional props
+            loc: {
+                file: err.loc?.file,
+                line: err.loc?.line,
+                column: err.loc?.column,
+            },
+            plugin,
+            stack: err.stack,
+            cause: err.cause,
+        },
+    };
+}
+// /**
+//  * Transformer for `shiki`'s legacy `lineOptions`, allows to add classes to specific lines
+//  * FROM: https://github.com/shikijs/shiki/blob/4a58472070a9a359a4deafec23bb576a73e24c6a/packages/transformers/src/transformers/compact-line-options.ts
+//  * LICENSE: https://github.com/shikijs/shiki/blob/4a58472070a9a359a4deafec23bb576a73e24c6a/LICENSE
+//  */
+// function transformerCompactLineOptions(
+// 	lineOptions: {
+// 		/**
+// 		 * 1-based line number.
+// 		 */
+// 		line: number;
+// 		classes?: string[];
+// 	}[] = [],
+// ): ShikiTransformer {
+// 	return {
+// 		name: '@shikijs/transformers:compact-line-options',
+// 		line(node, line) {
+// 			const lineOption = lineOptions.find((o) => o.line === line);
+// 			if (lineOption?.classes) this.addClassToHast(node, lineOption.classes);
+// 			return node;
+// 		},
+// 	};
+// }

package/dist/errors-data.d.ts

@@ -0,0 +1,16 @@
+export interface BetterErrorData {
+    name: string;
+    title: string;
+    message?: string | ((...params: any) => string) | undefined;
+    hint?: string | ((...params: any) => string) | undefined;
+}
+/**
+ *
+ */
+export declare const FailedToLoadModuleSSR: {
+    name: string;
+    title: string;
+    message: (importName: string) => string;
+    hint: string;
+};
+//# sourceMappingURL=errors-data.d.ts.map

package/dist/errors-data.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors-data.d.ts","sourceRoot":"","sources":["../src/errors-data.ts"],"names":[],"mappings":"AAIA,MAAM,WAAW,eAAe;IAC/B,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,CAAC,EAAE,MAAM,GAAG,CAAC,CAAC,GAAG,MAAM,EAAE,GAAG,KAAK,MAAM,CAAC,GAAG,SAAS,CAAC;IAC5D,IAAI,CAAC,EAAE,MAAM,GAAG,CAAC,CAAC,GAAG,MAAM,EAAE,GAAG,KAAK,MAAM,CAAC,GAAG,SAAS,CAAC;CACzD;AAED;;GAEG;AACH,eAAO,MAAM,qBAAqB;;;0BAGX,MAAM;;CAEF,CAAC"}

package/dist/errors-data.js

@@ -0,0 +1,10 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/**
+ *
+ */
+export const FailedToLoadModuleSSR = {
+    name: 'FailedToLoadModuleSSR',
+    title: 'Could not import file.',
+    message: (importName) => `Could not import \`${importName}\`.`,
+    hint: 'This is often caused by a typo in the import path. Please make sure the file exists.',
+};

package/dist/errors.d.ts

@@ -0,0 +1,66 @@
+import type { ErrorPayload } from 'vite';
+export type BuiltinErrorTypes = 'BetterError' | 'InternalError' | 'AggregateError';
+/**
+ * Generic object representing an error with all possible data
+ * Compatible with Gracile, Astro's and Vite's errors
+ */
+export interface ErrorWithMetadata<T extends string = string> {
+    [name: string]: unknown;
+    name: string;
+    title?: string;
+    type?: BuiltinErrorTypes & T;
+    message: string;
+    stack: string;
+    hint?: string;
+    id?: string;
+    frame?: string;
+    plugin?: string;
+    pluginCode?: string;
+    fullCode?: string;
+    loc?: {
+        file?: string;
+        line?: number;
+        column?: number;
+    };
+    cause?: unknown;
+}
+interface ErrorProperties {
+    title?: string | undefined;
+    name: string;
+    message?: string | undefined;
+    location?: ErrorLocation | undefined;
+    hint?: string | undefined;
+    stack?: string | undefined;
+    frame?: string | undefined;
+}
+export interface ErrorLocation {
+    file?: string | undefined;
+    line?: number | undefined;
+    column?: number | undefined;
+}
+export declare class BetterError<ConsumerErrorTypes extends string = string> extends Error {
+    loc: ErrorLocation | undefined;
+    title: string | undefined;
+    hint: string | undefined;
+    frame: string | undefined;
+    type: BuiltinErrorTypes | ConsumerErrorTypes;
+    constructor(props: ErrorProperties, options?: ErrorOptions);
+    setLocation(location: ErrorLocation): void;
+    setName(name: string): void;
+    setMessage(message: string): void;
+    setHint(hint: string): void;
+    setFrame(source: string, location: ErrorLocation): void;
+    static is(err: unknown): err is BetterError;
+}
+export declare class AggregateError extends BetterError {
+    type: BuiltinErrorTypes;
+    errors: BetterError[];
+    constructor(props: ErrorProperties & {
+        errors: BetterError[];
+    }, options?: ErrorOptions);
+    static is(err: unknown): err is AggregateError;
+}
+export declare function isBetterError(e: unknown): e is BetterError;
+export type SSRError = Error & ErrorPayload['err'];
+export {};
+//# sourceMappingURL=errors.d.ts.map

package/dist/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":"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"}

package/dist/errors.js

@@ -0,0 +1,51 @@
+import { codeFrame } from './dev/printer.js';
+export class BetterError extends Error {
+    constructor(props, options) {
+        const { name, title, message, stack, location, hint, frame } = props;
+        super(message, options);
+        this.type = 'BetterError';
+        this.title = title;
+        this.name = name;
+        if (message)
+            this.message = message;
+        // Only set this if we actually have a stack passed, otherwise uses Error's
+        if (stack)
+            this.stack = stack;
+        this.loc = location;
+        this.hint = hint;
+        this.frame = frame;
+    }
+    setLocation(location) {
+        this.loc = location;
+    }
+    setName(name) {
+        this.name = name;
+    }
+    setMessage(message) {
+        this.message = message;
+    }
+    setHint(hint) {
+        this.hint = hint;
+    }
+    setFrame(source, location) {
+        this.frame = codeFrame(source, location);
+    }
+    static is(err) {
+        return err.type === 'BetterError';
+    }
+}
+export class AggregateError extends BetterError {
+    // Despite being a collection of errors, AggregateError still needs to have a main error attached to it
+    // This is because Vite expects every thrown errors handled during HMR to be, well, Error and have a message
+    constructor(props, options) {
+        super(props, options);
+        this.type = 'AggregateError';
+        this.errors = props.errors;
+    }
+    static is(err) {
+        return err.type === 'AggregateError';
+    }
+}
+export function isBetterError(e) {
+    return e instanceof BetterError;
+}

package/dist/plugin.d.ts

@@ -0,0 +1,5 @@
+export declare function patchOverlay(code: string, importPath?: string): string;
+export declare function betterErrors(options?: {
+    overlayImportPath: string;
+}): any[];
+//# sourceMappingURL=plugin.d.ts.map

package/dist/plugin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plugin.d.ts","sourceRoot":"","sources":["../src/plugin.ts"],"names":[],"mappings":"AAeA,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,EAAE,UAAU,CAAC,EAAE,MAAM,UA6B7D;AAED,wBAAgB,YAAY,CAAC,OAAO,CAAC,EAAE;IACtC,iBAAiB,EAAE,MAAM,CAAC;CAK1B,GAAG,GAAG,EAAE,CAgER"}