limina 0.0.4 → 0.0.6

package/chunks/dep-esXeyN9I.js

@@ -0,0 +1,194 @@
+import { a as __toESM, t as require_picocolors } from "./dep-BPK-6PAr.js";
+
+//#region ../../node_modules/.pnpm/publint@0.3.17/node_modules/publint/src/shared/utils.js
+/**
+* @param {string[]} path
+* @returns {string}
+*/
+function formatMessagePath(path) {
+	let formatted = "pkg";
+	for (const part of path) if (/^\d+$/.test(part)) formatted += `[${part}]`;
+	else if (!/^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(part)) formatted += `["${part}"]`;
+	else formatted += "." + part;
+	return formatted;
+}
+/** @type {import('../utils.d.ts').getPkgPathValue} */
+function getPkgPathValue(pkg, path) {
+	let v = pkg;
+	for (const p of path) v = v[p];
+	return v;
+}
+/**
+* @param {string} str
+* @param {string} search
+* @param {string} replace
+*/
+function replaceLast(str, search, replace) {
+	const index = str.lastIndexOf(search);
+	if (index === -1) return str;
+	return str.slice(0, index) + replace + str.slice(index + search.length);
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/publint@0.3.17/node_modules/publint/src/shared/message.js
+var import_picocolors = /* @__PURE__ */ __toESM(require_picocolors(), 1);
+const EMPTY_MSG = "<empty>";
+/** @type {import('../utils.d.ts').formatMessage} */
+function formatMessage(m, pkg, opts = {}) {
+	const h = getHighlighter(opts.color);
+	/** @param {string[]} path */
+	const pv = (path) => {
+		try {
+			const str = String(getPkgPathValue(pkg, path));
+			return str === "" ? EMPTY_MSG : str;
+		} catch {
+			return "undefined";
+		}
+	};
+	switch (m.code) {
+		case "IMPLICIT_INDEX_JS_INVALID_FORMAT": return `index.js should be ${m.args.expectFormat} but it is ${m.args.actualFormat}`;
+		case "FILE_INVALID_FORMAT": {
+			const relativePath = m.args.actualFilePath ?? pv(m.path);
+			let start = "";
+			if (opts.reference || m.path[0] === "name") start = h.bold(relativePath);
+			else {
+				const is = pv(m.path).includes("*") ? "matches" : "is";
+				start = `${h.bold(formatMessagePath(m.path))} ${is} ${h.bold(relativePath)} and`;
+			}
+			return `${start} is written in ${h.warn(m.args.actualFormat)}, but is interpreted as ${h.warn(m.args.expectFormat)}. Consider using the ${h.warn(m.args.expectExtension)} extension, e.g. ${h.bold(replaceLast(relativePath, ".js", m.args.expectExtension))}`;
+		}
+		case "FILE_INVALID_EXPLICIT_FORMAT": {
+			const relativePath = m.args.actualFilePath ?? pv(m.path);
+			let start = "";
+			if (opts.reference || m.path[0] === "name") start = h.bold(relativePath);
+			else {
+				const is = pv(m.path).includes("*") ? "matches" : "is";
+				start = `${h.bold(formatMessagePath(m.path))} ${is} ${h.bold(relativePath)} and`;
+			}
+			return `${start} ends with the ${h.warn(m.args.actualExtension)} extension, but the code is written in ${h.warn(m.args.actualFormat)}. Consider using the ${h.warn(m.args.expectExtension)} extension, e.g. ${h.bold(replaceLast(relativePath, m.args.actualExtension, m.args.expectExtension))}`;
+		}
+		case "FILE_INVALID_JSX_EXTENSION": {
+			const relativePath = m.args.globbedFilePath ?? pv(m.path);
+			let start = "";
+			if (opts.reference || m.path[0] === "name") start = h.bold(relativePath);
+			else {
+				const is = m.args.globbedFilePath ? "matches" : "is";
+				start = `${h.bold(formatMessagePath(m.path))} ${is} ${h.bold(relativePath)} and`;
+			}
+			return `${start} uses an invalid ${h.bold(m.args.actualExtension)} extension. You don't need to split ESM and CJS formats for JSX. You should write a single file in ESM with the ${h.bold(".jsx")} extension instead, e.g. ${h.bold(replaceLast(pv(m.path), m.args.actualExtension, ".jsx"))}`;
+		}
+		case "FILE_DOES_NOT_EXIST": if (opts.reference) return `File does not exist`;
+		else {
+			let value = pv(m.path);
+			if (value === EMPTY_MSG && m.path[0] === "main") value += " (implies index.js)";
+			return `${h.bold(formatMessagePath(m.path))} is ${h.bold(value)} but the file does not exist.`;
+		}
+		case "FILE_NOT_PUBLISHED": if (opts.reference) return `File is not published. Is it specified in ${h.bold("pkg.files")}?`;
+		else return `${h.bold(formatMessagePath(m.path))} is ${h.bold(pv(m.path))} but the file is not published. Is it specified in ${h.bold("pkg.files")}?`;
+		case "HAS_ESM_MAIN_BUT_NO_EXPORTS": return `${h.bold("pkg.main")} is an ESM file, but it is usually better to use ${h.bold("pkg.exports")} instead. If you don't support Node.js 12.6 and below, you can also remove ${h.bold("pkg.main")}. (This will be a breaking change)`;
+		case "HAS_MODULE_BUT_NO_EXPORTS": return `${h.bold("pkg.module")} is used to output ESM, but ${h.bold("pkg.exports")} is not defined. As Node.js doesn't read ${h.bold("pkg.module")}, the ESM output may be skipped. Consider adding ${h.bold("pkg.exports")} to export the ESM output. ${h.bold("pkg.module")} can usually be removed alongside too. (This will be a breaking change)`;
+		case "MODULE_SHOULD_BE_ESM":
+		case "EXPORTS_MODULE_SHOULD_BE_ESM":
+		case "IMPORTS_MODULE_SHOULD_BE_ESM": return `${opts.reference ? "Should" : `${h.bold(formatMessagePath(m.path))} should`} be ESM, but the code is written in CJS.`;
+		case "EXPORTS_GLOB_NO_MATCHED_FILES":
+		case "IMPORTS_GLOB_NO_MATCHED_FILES": return `${opts.reference ? "Does" : `${h.bold(formatMessagePath(m.path))} is ${h.bold(pv(m.path))} but does`} not match any files.`;
+		case "EXPORTS_GLOB_NO_DEPRECATED_SUBPATH_MAPPING":
+		case "IMPORTS_GLOB_NO_DEPRECATED_SUBPATH_MAPPING": return `${h.bold(formatMessagePath(m.path))} maps to a path that ends with ${h.bold("/")} which is a removed feature. Use ${h.bold(formatMessagePath(m.args.expectPath))}: "${h.bold(m.args.expectValue)}" instead.`;
+		case "EXPORTS_TYPES_SHOULD_BE_FIRST": return `${opts.reference ? "Should" : `${h.bold(formatMessagePath(m.path))} should`} be the first in the object as conditions are order-sensitive so it can be resolved by TypeScript.`;
+		case "EXPORTS_MODULE_SHOULD_PRECEDE_REQUIRE":
+		case "IMPORTS_MODULE_SHOULD_PRECEDE_REQUIRE": return `${opts.reference ? "Should" : `${h.bold(formatMessagePath(m.path))} should`} come before the "require" condition so it can take precedence when used by a bundler.`;
+		case "EXPORTS_DEFAULT_SHOULD_BE_LAST":
+		case "IMPORTS_DEFAULT_SHOULD_BE_LAST": return `${opts.reference ? "Should" : `${h.bold(formatMessagePath(m.path))} should`} be the last in the object so it doesn't take precedence over the keys following it.`;
+		case "EXPORTS_VALUE_INVALID":
+		case "IMPORTS_VALUE_INVALID": return `${opts.reference ? h.bold(pv(m.path)) : `${h.bold(formatMessagePath(m.path))} is ${h.bold(pv(m.path))} but`} is invalid as it does not start with "${h.bold("./")}". Use ${h.bold(m.args.suggestValue)} instead.`;
+		case "EXPORTS_FALLBACK_ARRAY_USE":
+		case "IMPORTS_FALLBACK_ARRAY_USE": return `${opts.reference ? "The value" : h.bold(formatMessagePath(m.path))} uses fallback arrays which is not recommended. It picks the first value that can be parsed and does not have a use case in Node.js currently. It also works differently in some tools and may face inconsistent behaviors.`;
+		case "EXPORTS_MISSING_ROOT_ENTRYPOINT": {
+			const mainField = m.args.mainFields[0];
+			return `${opts.reference ? "The root entrypoint is missing" : `${h.bold(formatMessagePath(m.path))} is missing the root entrypoint export`}, which is defined in ${h.bold("pkg." + mainField)}. Environments that support the ${h.bold("\"exports\"")} field will ignore ${h.bold("pkg." + mainField)} as ${h.bold("\"exports\"")} takes the highest priority. Consider adding ${h.bold(formatMessagePath(m.path.concat(".")))}: "${h.bold(pv([mainField]))}".`;
+		}
+		case "USE_EXPORTS_BROWSER": return `${h.bold("pkg.browser")} with a string value can be refactored to use ${h.bold("pkg.exports")} and the ${h.bold("\"browser\"")} condition to declare browser-specific exports. e.g. ${h.bold("pkg.exports[\".\"].browser")}: "${h.bold(pv(m.path))}". (This will be a breaking change)`;
+		case "USE_EXPORTS_OR_IMPORTS_BROWSER": return `${h.bold("pkg.browser")} with an object value can be refactored to use ${h.bold("pkg.exports")}/${h.bold("pkg.imports")} and the ${h.bold("\"browser\"")} condition to declare browser-specific exports. (This will be a breaking change)`;
+		case "USE_FILES": return `The package ${h.bold("publishes internal tests or config files")}. You can use ${h.bold("pkg.files")} to only publish certain files and save user bandwidth.`;
+		case "USE_TYPE": return `The package does not specify the ${h.bold("\"type\"")} field. Node.js may attempt to detect the package type causing a small performance hit. Consider adding ${h.bold("\"type\"")}: "${h.bold("commonjs")}".`;
+		case "USE_LICENSE": return `The package does not specify the ${h.bold("\"license\"")} field but a license file was detected at ${h.bold(m.args.licenseFilePath)}. Consider adding a ${h.bold("\"license\"")} field so it's displayed on npm.`;
+		case "TYPES_NOT_EXPORTED": {
+			const typesFilePath = exportsRel(m.args.typesFilePath);
+			const start = opts.reference ? "The" : h.bold(formatMessagePath(m.path));
+			if (m.args.actualExtension && m.args.expectExtension) return `${start} types is not exported. Consider adding ${h.bold(formatMessagePath(m.path) + ".types")} to be compatible with TypeScript's ${h.bold("\"moduleResolution\": \"bundler\"")} compiler option. Note that you cannot use "${h.bold(typesFilePath)}" because it has a mismatching format. Instead, you can duplicate the file and use the ${h.bold(m.args.expectExtension)} extension, e.g. ${h.bold(formatMessagePath(m.path) + ".types")}: "${h.bold(replaceLast(typesFilePath, m.args.actualExtension, m.args.expectExtension))}"`;
+			else return `${start} types is not exported. Consider adding ${h.bold(formatMessagePath(m.path) + ".types")}: "${h.bold(typesFilePath)}" to be compatible with TypeScript's ${h.bold("\"moduleResolution\": \"bundler\"")} compiler option.`;
+		}
+		case "EXPORTS_TYPES_INVALID_FORMAT": {
+			let additionalMessage = "";
+			if (m.args.expectFormat === "ESM" && m.args.actualFormat === "CJS") additionalMessage = `This causes the types to be ambiguous when default importing the package due to its implied interop. `;
+			else if (m.args.expectFormat === "CJS" && m.args.actualFormat === "ESM") additionalMessage = `This causes the types to only work when dynamically importing the package, even though the package exports CJS. `;
+			return `${opts.reference ? "The" : h.bold(formatMessagePath(m.path))} types is interpreted as ${m.args.actualFormat} when resolving with the "${h.bold(m.args.condition)}" condition. ` + additionalMessage + `Consider splitting out two ${h.bold("\"types\"")} conditions for ${h.bold("\"import\"")} and ${h.bold("\"require\"")}, and use the ${h.warn(m.args.expectExtension)} extension, e.g. ${h.bold(formatMessagePath(m.args.expectPath))}: "${h.bold(replaceLast(pv(m.path), m.args.actualExtension, m.args.expectExtension))}"`;
+		}
+		case "FIELD_INVALID_VALUE_TYPE": {
+			let expectStr = m.args.expectTypes[0];
+			for (let i = 1; i < m.args.expectTypes.length; i++) if (i === m.args.expectTypes.length - 1) expectStr += ` or ${m.args.expectTypes[i]}`;
+			else expectStr += `, ${m.args.expectTypes[i]}`;
+			return `${opts.reference ? "The field value has" : `${h.bold(formatMessagePath(m.path))} is ${h.bold(pv(m.path))} which is`} an invalid ${h.bold(m.args.actualType)} type. Expected a ${h.bold(expectStr)} type instead.`;
+		}
+		case "EXPORTS_VALUE_CONFLICTS_WITH_BROWSER": return `${opts.reference ? `${h.bold(pv(m.path))} matches` : `${h.bold(formatMessagePath(m.path))} is ${h.bold(pv(m.path))} which also matches`} ${h.bold(formatMessagePath(m.args.browserPath))}: "${h.bold(pv(m.args.browserPath))}", which overrides the path when building the library with the "${h.bold(m.args.browserishCondition)}" condition. This is usually unintentional and may cause build issues. Consider using a different file name for ${h.bold(pv(m.path))}.`;
+		case "DEPRECATED_FIELD_JSNEXT": return `${h.bold(formatMessagePath(m.path))} is deprecated. ${h.bold("pkg.module")} should be used instead.`;
+		case "INVALID_REPOSITORY_VALUE": switch (m.args.type) {
+			case "invalid-string-shorthand": return `${opts.reference ? "The field value" : `${h.bold(formatMessagePath(m.path))} is ${h.bold(pv(m.path))} which`} isn't a valid shorthand value supported by npm. Consider using an object that references a repository.`;
+			case "invalid-git-url": return `${opts.reference ? "The field value" : `${h.bold(formatMessagePath(m.path))} is ${h.bold(pv(m.path))} which`} isn't a valid git URL. A valid git URL is usually in the form of "${h.bold("git+https://example.com/user/repo.git")}".`;
+			case "deprecated-github-git-protocol": return `${opts.reference ? "The field value" : `${h.bold(formatMessagePath(m.path))} is ${h.bold(pv(m.path))} which`} uses the git:// protocol that is deprecated by GitHub due to security concerns. Consider replacing the protocol with https://.`;
+			case "shorthand-git-sites": return `${opts.reference ? "The field value" : `${h.bold(formatMessagePath(m.path))} is ${h.bold(pv(m.path))} but`} could be a full git URL like "${h.bold(m.args.suggestValue)}".`;
+		}
+		case "LOCAL_DEPENDENCY": if (opts.reference) return `This dependency references a local package that will likely not work when installed by end-users.`;
+		else return `The "${h.bold(m.path[m.path.length - 1])}" dependency references "${h.bold(pv(m.path))}" that will likely not work when installed by end-users.`;
+		case "BIN_FILE_NOT_EXECUTABLE": return `${opts.reference ? "This bin file" : `${h.bold(formatMessagePath(m.path))} is ${h.bold(pv(m.path))} but the file`} is not executable. It should start with a shebang, e.g. ${h.bold("#!/usr/bin/env node")}.`;
+		case "IMPORTS_KEY_INVALID": return `${opts.reference ? `The imports key is invalid as it` : `${h.bold(formatMessagePath(m.path))} is invalid as the imports key`} does not start with "${h.bold("#")}". Use ${h.bold(m.args.suggestKey)} instead.`;
+		case "CJS_WITH_ESMODULE_DEFAULT_EXPORT": return `${m.path[0] === "name" && m.args.filePath ? h.bold(m.args.filePath) : opts.reference ? "This file" : `${h.bold(formatMessagePath(m.path))}`} sets both ${h.bold("exports.__esModule = true")} and ${h.bold("exports.default")}. This pattern breaks default imports when importing from an ESM-interpreted file in some bundlers. Consider using ESM syntax instead of CommonJS with ${h.bold("__esModule")} or avoid the default export.`;
+		default: return;
+	}
+}
+/** @type { import('picocolors/types.js').Colors | undefined } */
+let _picocolorsWithForcedColor;
+/**
+* @param {import('../utils.js').FormatMessageOptions['color']} color
+*/
+function getHighlighter(color) {
+	/** @type {(s: string) => string} */
+	let bold;
+	/** @type {(s: string) => string} */
+	let warn;
+	switch (color) {
+		case "html":
+			bold = (s) => `<strong>${s}</strong>`;
+			warn = (s) => `<strong>${s}</strong>`;
+			break;
+		case true:
+			_picocolorsWithForcedColor ??= import_picocolors.default.createColors(true);
+			bold = (s) => _picocolorsWithForcedColor.bold(s);
+			warn = (s) => _picocolorsWithForcedColor.yellow(s);
+			break;
+		case false:
+			bold = (s) => s;
+			warn = (s) => s;
+			break;
+		default:
+			bold = (s) => import_picocolors.default.bold(s);
+			warn = (s) => import_picocolors.default.yellow(s);
+			break;
+	}
+	return {
+		bold,
+		warn
+	};
+}
+/**
+* Make sure s is an `"exports"` compatible relative path
+* @param {string} s
+*/
+function exportsRel(s) {
+	if (s[0] === ".") return s;
+	if (s[0] === "/") return "." + s;
+	return "./" + s;
+}
+
+//#endregion
+export { formatMessage, formatMessagePath, getPkgPathValue };