lintmax 0.1.15

package/dist/path-Cu_Nf2ct.mjs

@@ -0,0 +1,168 @@
+//#region src/normalize.ts
+const normalizeIgnorePattern = ({ pattern }) => {
+	const trimmed = pattern.trim();
+	if (trimmed.length === 0) return "";
+	return trimmed.startsWith("./") ? trimmed.slice(2) : trimmed;
+};
+const normalizePathListInput = ({ allowUndefined = false, label, value }) => {
+	if (value === void 0 && allowUndefined) return [];
+	if (!Array.isArray(value)) throw new Error(`${label} must be an array of strings`);
+	const out = [];
+	const arr = value;
+	for (let i = 0; i < arr.length; i += 1) {
+		const item = arr[i];
+		if (typeof item !== "string") throw new Error(`${label}[${i}] must be a string`);
+		const normalized = normalizeIgnorePattern({ pattern: item });
+		if (normalized.length === 0) throw new Error(`${label}[${i}] must not be empty`);
+		if (!out.includes(normalized)) out.push(normalized);
+	}
+	return out;
+};
+const hasPlainObjectPrototype = ({ value }) => {
+	const prototype = Object.getPrototypeOf(value);
+	return prototype === null || prototype === Object.prototype;
+};
+const isObjectLike = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const isRecord = (value) => isObjectLike(value) && hasPlainObjectPrototype({ value });
+const assertObject = ({ label, value }) => {
+	if (!isRecord(value)) throw new Error(`${label} must be an object`);
+	return value;
+};
+const assertOptionalString = ({ label, value }) => {
+	if (value !== void 0 && typeof value !== "string") throw new Error(`${label} must be a string`);
+};
+const stripPluginNamespace = ({ rule }) => rule.includes("/") ? rule.slice(rule.indexOf("/") + 1) : rule;
+const findUnknownRules = ({ knownRules, normalizeRule, rules }) => {
+	const unknown = [];
+	for (const rule of Object.keys(rules)) {
+		const normalized = normalizeRule ? normalizeRule(rule) : rule;
+		if (!knownRules.has(normalized)) unknown.push(rule);
+	}
+	return unknown;
+};
+const assertJsonSerializable = ({ label, seen, value }) => {
+	if (value === null) return;
+	if (typeof value === "string" || typeof value === "boolean") return;
+	if (typeof value === "number") {
+		if (!Number.isFinite(value)) throw new Error(`${label} must be JSON-serializable`);
+		return;
+	}
+	if (typeof value !== "object") throw new Error(`${label} must be JSON-serializable`);
+	const objectValue = value;
+	const objectSeen = seen ?? /* @__PURE__ */ new WeakSet();
+	if (objectSeen.has(objectValue)) throw new Error(`${label} must be JSON-serializable`);
+	objectSeen.add(objectValue);
+	try {
+		if (Array.isArray(value)) {
+			for (let i = 0; i < value.length; i += 1) assertJsonSerializable({
+				label: `${label}[${i}]`,
+				seen: objectSeen,
+				value: value[i]
+			});
+			return;
+		}
+		if (!isRecord(value)) throw new Error(`${label} must be JSON-serializable`);
+		for (const [key, nested] of Object.entries(value)) assertJsonSerializable({
+			label: `${label}.${key}`,
+			seen: objectSeen,
+			value: nested
+		});
+	} finally {
+		objectSeen.delete(objectValue);
+	}
+};
+const normalizeObjectListInput = ({ allowNonPlain = false, label, value }) => {
+	if (value === void 0) return [];
+	if (!Array.isArray(value)) throw new Error(`${label} must be an array of objects`);
+	const out = [];
+	const arr = value;
+	for (let i = 0; i < arr.length; i += 1) {
+		const item = arr[i];
+		let normalizedItem;
+		if (allowNonPlain) {
+			if (isObjectLike(item)) normalizedItem = item;
+		} else if (isRecord(item)) normalizedItem = item;
+		if (!normalizedItem) throw new Error(`${label}[${i}] must be an object`);
+		out.push(normalizedItem);
+	}
+	return out;
+};
+const normalizeRulesOffInput = ({ label, value }) => {
+	if (value === void 0) return;
+	if (!Array.isArray(value)) throw new Error(`${label} must be an array of rule names`);
+	const out = {};
+	const arr = value;
+	for (let i = 0; i < arr.length; i += 1) {
+		const item = arr[i];
+		if (typeof item !== "string") throw new Error(`${label}[${i}] must be a string rule name`);
+		const ruleName = item.trim();
+		if (ruleName.length === 0) throw new Error(`${label}[${i}] must not be empty`);
+		out[ruleName] = "off";
+	}
+	const sorted = {};
+	for (const key of Object.keys(out).toSorted((a, b) => a.localeCompare(b))) sorted[key] = "off";
+	return sorted;
+};
+const normalizeTailwindOption = ({ label, value }) => {
+	if (value === void 0) return;
+	if (typeof value === "boolean" || typeof value === "string") return value;
+	throw new Error(`${label} must be a string, true, or false`);
+};
+const warnToError = (rules) => {
+	const result = {};
+	for (const [key, value] of Object.entries(rules)) if (value === void 0) result[key] = "error";
+	else if (value === "warn" || value === 1) result[key] = "error";
+	else if (Array.isArray(value) && (value[0] === "warn" || value[0] === 1)) result[key] = ["error", ...value.slice(1)];
+	else result[key] = value;
+	return result;
+};
+//#endregion
+//#region src/path.ts
+const DRIVE_PATH_REGEX = /^[A-Za-z]:\//u;
+const MULTI_SLASH_REGEX = /\/+/gu;
+const normalizeSlashes = (value) => value.replaceAll("\\", "/");
+const trimLeadingSlash = (value) => {
+	let result = value;
+	while (result.startsWith("/")) result = result.slice(1);
+	return result;
+};
+const trimTrailingSlash = (value) => {
+	let result = value;
+	while (result.endsWith("/") && result.length > 1) result = result.slice(0, -1);
+	return result;
+};
+const fromFileUrl = (value) => {
+	if (!value.startsWith("file://")) return normalizeSlashes(value);
+	const normalized = normalizeSlashes(decodeURIComponent(new URL(value).pathname));
+	if (DRIVE_PATH_REGEX.test(normalized.slice(1))) return normalized.slice(1);
+	return normalized;
+};
+const joinPath = (...parts) => {
+	if (parts.length === 0) return "";
+	const normalizedParts = [];
+	for (const part of parts) {
+		const normalized = normalizeSlashes(part);
+		if (normalized.length > 0) normalizedParts.push(normalized);
+	}
+	if (normalizedParts.length === 0) return "";
+	const first = normalizedParts[0] ?? "";
+	const isAbsolute = first.startsWith("/") || DRIVE_PATH_REGEX.test(first);
+	const [head, ...tail] = normalizedParts;
+	const segments = [trimTrailingSlash(head ?? "")];
+	for (const segment of tail) segments.push(trimLeadingSlash(trimTrailingSlash(segment)));
+	const joined = segments.join("/").replace(MULTI_SLASH_REGEX, "/");
+	return isAbsolute && !joined.startsWith("/") && !DRIVE_PATH_REGEX.test(joined) ? `/${joined}` : joined;
+};
+const dirnamePath = (value) => {
+	const normalized = trimTrailingSlash(normalizeSlashes(value));
+	const lastSlash = normalized.lastIndexOf("/");
+	if (lastSlash === -1) return ".";
+	if (lastSlash === 0) return "/";
+	return normalized.slice(0, lastSlash);
+};
+const isAbsolutePath = (value) => {
+	const normalized = normalizeSlashes(value);
+	return normalized.startsWith("/") || DRIVE_PATH_REGEX.test(normalized);
+};
+//#endregion
+export { assertJsonSerializable as a, findUnknownRules as c, normalizeObjectListInput as d, normalizePathListInput as f, warnToError as g, stripPluginNamespace as h, joinPath as i, isRecord as l, normalizeTailwindOption as m, fromFileUrl as n, assertObject as o, normalizeRulesOffInput as p, isAbsolutePath as r, assertOptionalString as s, dirnamePath as t, normalizeIgnorePattern as u };