vite-plus 0.1.24 → 0.2.0

package/dist/{main-DpJl3LoU.js → json-Dn87fvjk.js}

@@ -1,3 +1,4 @@
+import fs from "node:fs";
 //#region ../../node_modules/.pnpm/jsonc-parser@3.3.1/node_modules/jsonc-parser/lib/esm/impl/scanner.js
 /**
 * Creates a JSON scanner on the given text.
@@ -1223,4 +1224,139 @@ function applyEdits(text, edits) {
 	return text;
 }
 //#endregion
-export { modify as n, parse as r, applyEdits as t };
+//#region ../../node_modules/.pnpm/detect-indent@7.0.2/node_modules/detect-indent/index.js
+const INDENT_REGEX = /^(?:( )+|\t+)/;
+const INDENT_TYPE_SPACE = "space";
+const INDENT_TYPE_TAB = "tab";
+function shouldIgnoreSingleSpace(ignoreSingleSpaces, indentType, value) {
+	return ignoreSingleSpaces && indentType === INDENT_TYPE_SPACE && value === 1;
+}
+/**
+Make a Map that counts how many indents/unindents have occurred for a given size and how many lines follow a given indentation.
+
+The key is a concatenation of the indentation type (s = space and t = tab) and the size of the indents/unindents.
+
+```
+indents = {
+t3: [1, 0],
+t4: [1, 5],
+s5: [1, 0],
+s12: [1, 0],
+}
+```
+*/
+function makeIndentsMap(string, ignoreSingleSpaces) {
+	const indents = /* @__PURE__ */ new Map();
+	let previousSize = 0;
+	let previousIndentType;
+	let key;
+	for (const line of string.split(/\n/g)) {
+		if (!line) continue;
+		const matches = line.match(INDENT_REGEX);
+		if (matches === null) {
+			previousSize = 0;
+			previousIndentType = "";
+		} else {
+			const indent = matches[0].length;
+			const indentType = matches[1] ? INDENT_TYPE_SPACE : INDENT_TYPE_TAB;
+			if (shouldIgnoreSingleSpace(ignoreSingleSpaces, indentType, indent)) continue;
+			if (indentType !== previousIndentType) previousSize = 0;
+			previousIndentType = indentType;
+			let use = 1;
+			let weight = 0;
+			const indentDifference = indent - previousSize;
+			previousSize = indent;
+			if (indentDifference === 0) {
+				use = 0;
+				weight = 1;
+			} else {
+				const absoluteIndentDifference = Math.abs(indentDifference);
+				if (shouldIgnoreSingleSpace(ignoreSingleSpaces, indentType, absoluteIndentDifference)) continue;
+				key = encodeIndentsKey(indentType, absoluteIndentDifference);
+			}
+			const entry = indents.get(key);
+			indents.set(key, entry === void 0 ? [1, 0] : [entry[0] + use, entry[1] + weight]);
+		}
+	}
+	return indents;
+}
+function encodeIndentsKey(indentType, indentAmount) {
+	return (indentType === INDENT_TYPE_SPACE ? "s" : "t") + String(indentAmount);
+}
+function decodeIndentsKey(indentsKey) {
+	return {
+		type: indentsKey[0] === "s" ? INDENT_TYPE_SPACE : INDENT_TYPE_TAB,
+		amount: Number(indentsKey.slice(1))
+	};
+}
+function getMostUsedKey(indents) {
+	let result;
+	let maxUsed = 0;
+	let maxWeight = 0;
+	for (const [key, [usedCount, weight]] of indents) if (usedCount > maxUsed || usedCount === maxUsed && weight > maxWeight) {
+		maxUsed = usedCount;
+		maxWeight = weight;
+		result = key;
+	}
+	return result;
+}
+function makeIndentString(type, amount) {
+	return (type === INDENT_TYPE_SPACE ? " " : "	").repeat(amount);
+}
+function detectIndent(string) {
+	if (typeof string !== "string") throw new TypeError("Expected a string");
+	let indents = makeIndentsMap(string, true);
+	if (indents.size === 0) indents = makeIndentsMap(string, false);
+	const keyOfMostUsedIndent = getMostUsedKey(indents);
+	let type;
+	let amount = 0;
+	let indent = "";
+	if (keyOfMostUsedIndent !== void 0) {
+		({type, amount} = decodeIndentsKey(keyOfMostUsedIndent));
+		indent = makeIndentString(type, amount);
+	}
+	return {
+		amount,
+		type,
+		indent
+	};
+}
+//#endregion
+//#region ../../node_modules/.pnpm/detect-newline@4.0.1/node_modules/detect-newline/index.js
+function detectNewline(string) {
+	if (typeof string !== "string") throw new TypeError("Expected a string");
+	const newlines = string.match(/(?:\r?\n)/g) || [];
+	if (newlines.length === 0) return;
+	const crlf = newlines.filter((newline) => newline === "\r\n").length;
+	return crlf > newlines.length - crlf ? "\r\n" : "\n";
+}
+//#endregion
+//#region src/utils/json.ts
+function readJsonFile(file, allowComments) {
+	const content = fs.readFileSync(file, "utf-8");
+	return (allowComments ? parse : JSON.parse)(content);
+}
+function writeJsonFile(file, data) {
+	let newline = "\n";
+	let indent = "  ";
+	if (fs.existsSync(file)) {
+		const content = fs.readFileSync(file, "utf-8");
+		indent = detectIndent(content).indent;
+		newline = detectNewline(content) ?? "";
+	}
+	fs.writeFileSync(file, JSON.stringify(data, null, indent) + newline, "utf-8");
+}
+function editJsonFile(file, callback) {
+	const newJson = callback(readJsonFile(file));
+	if (newJson) writeJsonFile(file, newJson);
+}
+function isJsonFile(file) {
+	try {
+		readJsonFile(file);
+		return true;
+	} catch {
+		return false;
+	}
+}
+//#endregion
+export { applyEdits as a, writeJsonFile as i, isJsonFile as n, modify as o, readJsonFile as r, parse as s, editJsonFile as t };