@x18n/builtins 0.0.13 → 0.0.14

package/dist/formats/resx.mjs

@@ -0,0 +1,202 @@
+import { a as splice, i as leafText, n as detectEol } from "../shared-BWaXUmwA.mjs";
+import { diffText, errors, pathId, walkLeaves } from "@x18n/core";
+//#region src/formats/resx/index.ts
+const entities = {
+	lt: "<",
+	gt: ">",
+	amp: "&",
+	quot: "\"",
+	apos: "'"
+};
+function decode(raw) {
+	return raw.replace(/\r\n?/g, "\n").replace(/<!\[CDATA\[([\s\S]*?)\]\]>|&(#x[\da-f]+|#\d+|\w+);/gi, (match, cdata, name) => {
+		if (name === void 0) return cdata ?? match;
+		if (name.startsWith("#")) {
+			const code = name[1] === "x" ? Number.parseInt(name.slice(2), 16) : Number.parseInt(name.slice(1), 10);
+			return code <= 1114111 ? String.fromCodePoint(code) : match;
+		}
+		return entities[name] ?? match;
+	});
+}
+const escapeText = (text) => text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+const escapeAttribute = (text) => escapeText(text).replace(/"/g, "&quot;");
+const isSpace = (char) => char === " " || char === "	";
+/** The range with its indent and line break when it stands on a line of its own. */
+function lineOf(text, range) {
+	let start = range.start;
+	while (isSpace(text[start - 1])) start--;
+	let end = range.end;
+	while (isSpace(text[end])) end++;
+	if (text[end] === "\r") end++;
+	if (text[end] === "\n") end++;
+	return (start === 0 || text[start - 1] === "\n") && (end === text.length || text[end - 1] === "\n") ? {
+		start,
+		end
+	} : range;
+}
+/** Comments and CDATA are skipped so the schema sample in the standard header is not read as data. */
+const tokens = /<!--[\s\S]*?-->|<!\[CDATA\[[\s\S]*?\]\]>|<data\b((?:[^>"']|"[^"]*"|'[^']*')*)>/g;
+/** The `<value>` inside a `<data>` whose content starts at `offset`. */
+function valueIn(inner, offset) {
+	const match = /<value\s*\/>|<value\s*>([\s\S]*?)<\/value\s*>/d.exec(inner);
+	if (!match) return {
+		value: "",
+		body: void 0,
+		emptyValue: void 0
+	};
+	const [start, end] = match.indices[0];
+	const body = match.indices[1];
+	if (!body) return {
+		value: "",
+		body: void 0,
+		emptyValue: {
+			start: offset + start,
+			end: offset + end
+		}
+	};
+	return {
+		value: decode(match[1]),
+		body: {
+			start: offset + body[0],
+			end: offset + body[1]
+		},
+		emptyValue: void 0
+	};
+}
+function read(text, path) {
+	const entries = [];
+	const objects = /* @__PURE__ */ new Set();
+	const closing = /<\/data\s*>/g;
+	tokens.lastIndex = 0;
+	for (let match = tokens.exec(text); match; match = tokens.exec(text)) {
+		const attributes = match[1];
+		if (attributes === void 0) continue;
+		const start = match.index;
+		const open = start + match[0].length;
+		const selfClosing = attributes.endsWith("/");
+		closing.lastIndex = open;
+		const close = selfClosing ? void 0 : closing.exec(text);
+		if (close === null) throw errors.X18N2002({
+			path,
+			reason: "unclosed <data> element"
+		});
+		const end = close ? close.index + close[0].length : open;
+		tokens.lastIndex = end;
+		const name = /\sname\s*=\s*(?:"([^"]*)"|'([^']*)')/d.exec(attributes);
+		if (!name) continue;
+		const key = decode(name[1] ?? name[2]);
+		if (/\s(?:type|mimetype)\s*=/.test(attributes)) {
+			objects.add(key);
+			continue;
+		}
+		const nameAt = name.indices[1] ?? name.indices[2];
+		const inner = close ? text.slice(open, close.index) : "";
+		const { value, body, emptyValue } = valueIn(inner, open);
+		const line = lineOf(text, {
+			start,
+			end
+		});
+		const keyOffset = start + 5;
+		entries.push({
+			key,
+			value,
+			range: {
+				key: {
+					start: keyOffset + nameAt[0],
+					end: keyOffset + nameAt[1]
+				},
+				value: body ?? emptyValue ?? {
+					start: open,
+					end: open
+				}
+			},
+			body,
+			emptyValue,
+			content: close && inner.trim() ? {
+				start: open,
+				end: close.index
+			} : void 0,
+			element: {
+				start,
+				end
+			},
+			line,
+			indent: line.start < start ? text.slice(line.start, start) : ""
+		});
+	}
+	return {
+		entries,
+		objects
+	};
+}
+function dataElement(key, value, indent, eol) {
+	return `<data name="${escapeAttribute(key)}" xml:space="preserve">${eol}${indent.repeat(2)}<value>${value}</value>${eol}${indent}</data>`;
+}
+function applyOp(text, op, path) {
+	const key = op.path.join(".");
+	const { entries, objects } = read(text, path);
+	const entry = entries.findLast((e) => e.key === key);
+	if (op.type === "delete") return entry ? splice(text, entry.line, "") : text;
+	if (!entry && objects.has(key)) throw errors.X18N4008({ reason: `"${key}" in ${path} holds a file or object, not a string` });
+	const eol = detectEol(text);
+	const value = escapeText(leafText(op.value)).replace(/\n/g, eol);
+	if (entry?.body) return splice(text, entry.body, value);
+	if (entry?.emptyValue) return splice(text, entry.emptyValue, `<value>${value}</value>`);
+	if (entry?.content) {
+		const lead = /^\s*/.exec(text.slice(entry.content.start, entry.content.end))[0];
+		return splice(text, {
+			start: entry.content.start,
+			end: entry.content.start
+		}, `${lead}<value>${value}</value>`);
+	}
+	if (entry) return splice(text, entry.element, dataElement(key, value, entry.indent, eol));
+	const root = text.lastIndexOf("</root>");
+	if (root === -1) throw errors.X18N2002({
+		path,
+		reason: "missing </root>"
+	});
+	const indent = entries.at(-1)?.indent ?? [...text.matchAll(/^([ \t]*)<resheader\b/gm)].at(-1)?.[1] ?? "  ";
+	let at = root;
+	while (isSpace(text[at - 1])) at--;
+	const lead = at === 0 || text[at - 1] === "\n" ? "" : eol;
+	return splice(text, {
+		start: at,
+		end: at
+	}, `${lead}${indent}${dataElement(key, value, indent, eol)}${eol}`);
+}
+const head = `<?xml version="1.0" encoding="utf-8"?>\n<root>\n${[
+	["resmimetype", "text/microsoft-resx"],
+	["version", "2.0"],
+	["reader", "System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089"],
+	["writer", "System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089"]
+].map(([name, value]) => `  <resheader name="${name}">\n    <value>${value}</value>\n  </resheader>\n`).join("")}`;
+/** .NET `.resx` files: `<data name="key"><value>text</value></data>` inside `<root>`. */
+function resx() {
+	return {
+		name: "x18n:format-resx",
+		formats: [{
+			id: "resx",
+			extensions: ["resx"],
+			parse(text, ctx) {
+				const tree = {};
+				const ranges = /* @__PURE__ */ new Map();
+				for (const entry of read(text, ctx.path).entries) {
+					tree[entry.key] = entry.value;
+					ranges.set(pathId([entry.key]), entry.range);
+				}
+				return {
+					tree,
+					ranges
+				};
+			},
+			edit(text, ops, ctx) {
+				let next = text;
+				for (const op of ops) next = applyOp(next, op, ctx.path);
+				return diffText(text, next);
+			},
+			serialize: (tree) => `${head}${[...walkLeaves(tree)].map((leaf) => `  ${dataElement(leaf.path.join("."), escapeText(leafText(leaf.value)), "  ", "\n")}\n`).join("")}</root>\n`
+		}]
+	};
+}
+//#endregion
+export { resx as default, resx };

package/dist/formats/yaml.d.mts

@@ -0,0 +1,5 @@
+import { Plugin } from "@x18n/core";
+//#region src/formats/yaml/index.d.ts
+export declare function yaml(): Plugin;
+//#endregion
+export { yaml as default };

package/dist/formats/yaml.mjs

@@ -0,0 +1,113 @@
+import { s as toLeaf } from "../shared-BWaXUmwA.mjs";
+import { applyTextEdits, diffText, errors, pathId } from "@x18n/core";
+import { Document, Scalar, isMap, isNode, isScalar, parseDocument, stringify } from "yaml";
+//#region src/formats/yaml/index.ts
+function scalarTextRange(node) {
+	const range = node.range;
+	if (!range) return void 0;
+	if (isScalar(node) && (node.type === Scalar.QUOTE_DOUBLE || node.type === Scalar.QUOTE_SINGLE)) return {
+		start: range[0] + 1,
+		end: range[1] - 1
+	};
+	return {
+		start: range[0],
+		end: range[1]
+	};
+}
+function readMap(node, path, ranges) {
+	const out = {};
+	if (!isMap(node)) return out;
+	for (const pair of node.items) {
+		const keyNode = pair.key;
+		if (!isScalar(keyNode)) continue;
+		const key = String(keyNode.value);
+		const childPath = [...path, key];
+		const keyRange = scalarTextRange(keyNode);
+		const value = isNode(pair.value) ? pair.value : void 0;
+		const valueRange = value && value.range ? {
+			start: value.range[0],
+			end: value.range[1]
+		} : void 0;
+		if (keyRange) ranges.set(pathId(childPath), {
+			key: keyRange,
+			value: valueRange ?? keyRange
+		});
+		if (value === void 0) out[key] = null;
+		else if (isMap(value)) out[key] = readMap(value, childPath, ranges);
+		else if (isScalar(value)) {
+			const leaf = toLeaf(value.value);
+			if (leaf !== void 0) out[key] = leaf;
+		}
+	}
+	return out;
+}
+function parse$1(text, path) {
+	const doc = parseDocument(text, {
+		keepSourceTokens: true,
+		uniqueKeys: false
+	});
+	if (doc.errors.length > 0) throw errors.X18N2002({
+		path,
+		reason: doc.errors[0].message
+	});
+	return doc;
+}
+function scalarText(value, type) {
+	if (typeof value !== "string") return stringify(value).trimEnd();
+	if (type === Scalar.QUOTE_DOUBLE) return JSON.stringify(value);
+	if (type === Scalar.QUOTE_SINGLE) return `'${value.replace(/'/g, "''")}'`;
+	return stringify(value, { lineWidth: 0 }).trimEnd();
+}
+function indentOf(text) {
+	return /^( +)\S/m.exec(text)?.[1]?.length ?? 2;
+}
+function yaml() {
+	return {
+		name: "x18n:format-yaml",
+		formats: [{
+			id: "yaml",
+			extensions: ["yml", "yaml"],
+			parse(text, ctx) {
+				const doc = parse$1(text, ctx.path);
+				const ranges = /* @__PURE__ */ new Map();
+				if (doc.contents === null) return {
+					tree: {},
+					ranges
+				};
+				if (!isMap(doc.contents)) throw errors.X18N2003({ path: ctx.path });
+				return {
+					tree: readMap(doc.contents, [], ranges),
+					ranges
+				};
+			},
+			edit(text, ops, ctx) {
+				let next = text;
+				for (const op of ops) {
+					let doc = parse$1(next, ctx.path);
+					const current = doc.getIn(op.path, true);
+					if (op.type === "set" && isScalar(current) && current.range && current.type !== Scalar.BLOCK_FOLDED && current.type !== Scalar.BLOCK_LITERAL) {
+						next = applyTextEdits(next, [{
+							range: {
+								start: current.range[0],
+								end: current.range[1]
+							},
+							text: scalarText(op.value, current.type)
+						}]);
+						continue;
+					}
+					if (doc.contents === null) doc = new Document({});
+					if (op.type === "set") doc.setIn(op.path, op.value);
+					else doc.deleteIn(op.path);
+					next = doc.toString({
+						indent: indentOf(text),
+						lineWidth: 0
+					});
+				}
+				return diffText(text, next);
+			},
+			serialize: (tree) => Object.keys(tree).length === 0 ? "{}\n" : stringify(tree, { lineWidth: 0 })
+		}]
+	};
+}
+//#endregion
+export { yaml as default, yaml };

package/dist/formats.d.mts

@@ -1,34 +1,10 @@
-import { Plugin } from "@x18n/core";
-//#region src/formats/ecmascript.d.ts
-export declare function ecmascript(): Plugin;
-//#endregion
-//#region src/formats/ftl.d.ts
-export declare function ftl(): Plugin;
-//#endregion
-//#region src/formats/ini.d.ts
-export declare function ini(): Plugin;
-//#endregion
-//#region src/formats/json.d.ts
-interface JsonOptions {
-  /** Spaces per level for new files. Existing files keep their indent. */
-  readonly indent?: number;
-}
-export declare function json(options?: JsonOptions): Plugin;
-export declare function jsonc(options?: JsonOptions): Plugin;
-//#endregion
-//#region src/formats/json5.d.ts
-export declare function json5(): Plugin;
-//#endregion
-//#region src/formats/php.d.ts
-export declare function php(): Plugin;
-//#endregion
-//#region src/formats/po.d.ts
-export declare function po(): Plugin;
-//#endregion
-//#region src/formats/properties.d.ts
-export declare function properties(): Plugin;
-//#endregion
-//#region src/formats/yaml.d.ts
-export declare function yaml(): Plugin;
-//#endregion
-export type { JsonOptions };
+import { FormatEntry } from "@x18n/core";
+//#region src/formats/index.d.ts
+/**
+ * Built-in formats by id, in claim order. A format is a folder: `<name>/entry.ts` holds its extensions and a
+ * `load` for `<name>/index.ts`, the format itself, which is imported when a file of that format is first read.
+ */
+export declare const formats: {
+  readonly [id: string]: FormatEntry;
+};
+//#endregion

package/dist/formats.mjs

@@ -1 +1,61 @@
-export { u as ecmascript, l as ftl, c as ini, o as json, a as json5, s as jsonc, i as php, r as po, n as properties, t as yaml } from "./formats-CFkM5co0.mjs";
+//#endregion
+//#region src/formats/index.ts
+/**
+* Built-in formats by id, in claim order. A format is a folder: `<name>/entry.ts` holds its extensions and a
+* `load` for `<name>/index.ts`, the format itself, which is imported when a file of that format is first read.
+*/
+const formats = {
+	json: {
+		extensions: ["json"],
+		load: () => import("./formats/json.mjs")
+	},
+	jsonc: {
+		extensions: ["jsonc"],
+		load: () => import("./formats/jsonc.mjs")
+	},
+	json5: {
+		extensions: ["json5"],
+		load: () => import("./formats/json5.mjs")
+	},
+	yaml: {
+		extensions: ["yml", "yaml"],
+		load: () => import("./formats/yaml.mjs")
+	},
+	po: {
+		extensions: ["po", "pot"],
+		load: () => import("./formats/po.mjs")
+	},
+	properties: {
+		extensions: ["properties"],
+		load: () => import("./formats/properties.mjs")
+	},
+	resx: {
+		extensions: ["resx"],
+		load: () => import("./formats/resx.mjs")
+	},
+	ftl: {
+		extensions: ["ftl"],
+		load: () => import("./formats/ftl.mjs")
+	},
+	ini: {
+		extensions: ["ini"],
+		load: () => import("./formats/ini.mjs")
+	},
+	php: {
+		extensions: ["php"],
+		load: () => import("./formats/php.mjs")
+	},
+	js: {
+		extensions: [
+			"js",
+			"mjs",
+			"cjs",
+			"ts",
+			"mts",
+			"cts"
+		],
+		load: () => import("./formats/ecmascript.mjs")
+	}
+};
+//#endregion
+export { formats };

package/dist/index.d.mts

@@ -1,5 +1,5 @@
 import { Builtins } from "@x18n/core";
 //#region src/index.d.ts
-/** Plugins that are always on, and the presets that `'auto'` detects. */
-export declare function createBuiltins(): Builtins;
+/** Plugins that are always on, and the presets that `'auto'` detects. Formats, scanners and presets load on demand; `regex` and the reporters are always loaded. */
+export declare function createBuiltins(): Promise<Builtins>;
 //#endregion

package/dist/index.mjs

@@ -1,35 +1,41 @@
 import { recommended } from "./checks.mjs";
 import { i as pattern } from "./finders-CqTGh4OJ.mjs";
-import { a as json5, c as ini, i as php, l as ftl, n as properties, o as json, r as po, s as jsonc, t as yaml, u as ecmascript } from "./formats-CFkM5co0.mjs";
-import { a as js, n as vue } from "./vue-CF4pe-Yr.mjs";
 import { manifests } from "./manifests.mjs";
-import { n as regex } from "./regex-AYVhuSb6.mjs";
-import { t as presets } from "./presets-Co5SlnKr.mjs";
-import { reporters } from "./reporters.mjs";
-import { t as svelte } from "./scanners-DhnnVp7s.mjs";
+import { formats } from "@x18n/builtins/formats";
+import { presets } from "@x18n/builtins/presets";
+import { reporters } from "@x18n/builtins/reporters";
+import { scanners } from "@x18n/builtins/scanners";
+import regex from "@x18n/builtins/scanners/regex";
 //#region src/index.ts
-/** Plugins that are always on, and the presets that `'auto'` detects. */
-function createBuiltins() {
+/** Plugins that are always on, and the presets that `'auto'` detects. Formats, scanners and presets load on demand; `regex` and the reporters are always loaded. */
+async function createBuiltins() {
+	const formatPlugins = Object.entries(formats).map(([id, entry]) => ({
+		name: `x18n:format-${id}`,
+		lazyFormats: [{
+			id,
+			...entry
+		}]
+	}));
+	const scannerPlugins = Object.entries(scanners).map(([id, entry]) => ({
+		name: `x18n:scanner-${id}`,
+		lazyScanners: [{
+			id,
+			...entry
+		}]
+	}));
+	const reporterPlugin = {
+		name: "x18n:reporters",
+		reporters: await Promise.all(Object.values(reporters).map(async (load) => (await load()).default))
+	};
 	return {
 		plugins: [
 			manifests(),
-			json(),
-			jsonc(),
-			json5(),
-			yaml(),
-			po(),
-			properties(),
-			ftl(),
-			ini(),
-			php(),
-			ecmascript(),
+			...formatPlugins,
 			pattern(),
-			js(),
-			vue(),
-			svelte(),
+			...scannerPlugins,
 			regex(),
 			recommended(),
-			reporters()
+			reporterPlugin
 		],
 		presets
 	};