@menapo/vi18n 0.0.0-stage → 0.1.0

package/dist/parse.js

@@ -0,0 +1,156 @@
+import { _ as DEV, b as trim, h as createScope, n as S, x as warnOnce } from "./dir-zw6bGMKQ.js";
+import { o as formatMessage, r as t } from "./t-DC-c9zE5.js";
+import { f as isDiagnosticError, i as normalizeSource, s as parseSource, t as compileMessage } from "./compile-Cc97JaW2.js";
+import { n as validateTranslation, t as validateSource } from "./validate-D6DJepZv.js";
+//#region src/parse/index.ts
+/**
+* `@menapo/vi18n/parse` (PLAN §4.1, INTERNALS §3.6): messages that are not in
+* the code — a CMS, a database, a template an admin edits — parsed at
+* runtime by the compiler's own parser, validation and IR compiler, then
+* rendered by the runtime's interpreter. They follow every rule a compiled
+* message follows: the same syntax (ICU, or MF2 lowered into it), the same
+* hard errors, bidi isolation of string values, escaping in `richHtml()`,
+* plural, select, number and date semantics.
+*
+* A message with errors never throws into rendering: it renders its source
+* (`options.source`) when that is valid, as the build falls back along the
+* chain, else its own text without bidi controls; dev warns once and
+* `onParseError` handlers hear of it.
+*
+* Its own entry, never imported by `.`: the parsers are about 16 KB gzipped
+* (PLAN §6), several times the runtime, and an app that compiles its
+* messages never ships them.
+*/
+/** Codes that need the text's locale; without one, `und` would flag every category. */
+const LOCALE_CODES = /* @__PURE__ */ new Set(["icu-plural-missing-category", "icu-plural-unused-category"]);
+/**
+* Parses per text and options, newest kept: components call `parse()` on
+* every render, and a CMS page holds a bounded set of texts.
+*/
+const cache = /* @__PURE__ */ new Map();
+const handlers = /* @__PURE__ */ new Set();
+/**
+* Parses and validates `message`. Never throws: errors are in `errors`, and
+* the result still renders (see the module comment).
+*/
+function parse(message, options = {}) {
+	const { syntax = "auto", source, locale } = options;
+	const key = `${syntax}\0${locale ?? ""}\0${source === void 0 ? "" : "
" + source}\0${message}`;
+	let parsed = cache.get(key);
+	if (parsed !== void 0) cache.delete(key);
+	else {
+		parsed = build(String(message), syntax, source, locale);
+		trim(cache, 499);
+		if (parsed.errors.length > 0) report(parsed);
+	}
+	cache.set(key, parsed);
+	return parsed;
+}
+/**
+* Renders `message` as plain text (tags render their children): in the
+* current locale, as `t(parse(message), values)` does, or in `locale` with
+* the current time zone.
+*/
+function format(message, values, locale) {
+	const parsed = typeof message === "string" ? parse(message) : message;
+	if (locale === void 0) return t(parsed, values);
+	const resolver = S.serverResolver;
+	const current = resolver ? resolver() : S.resolve();
+	let tag;
+	try {
+		tag = Intl.getCanonicalLocales(locale)[0] ?? "und";
+	} catch {
+		if (DEV) warnOnce(`format(): ${JSON.stringify(locale)} is no locale; using the current one`);
+		tag = current?.locale ?? "und";
+	}
+	const scope = createScope("translator", tag, /* @__PURE__ */ new Map(), {
+		timeZone: current?.timeZone,
+		now: current?.now
+	});
+	return formatMessage(parsed.ir, values, scope);
+}
+/**
+* Calls `handler` with every message `parse()` finds errors in, once per
+* text and options while it is cached; returns the unsubscribe function.
+*/
+function onParseError(handler) {
+	handlers.add(handler);
+	return () => {
+		handlers.delete(handler);
+	};
+}
+function build(text, syntax, sourceText, locale) {
+	const errors = [];
+	const warnings = [];
+	const ast = read(text, syntax, errors);
+	let source = null;
+	if (sourceText !== void 0) {
+		const problems = [];
+		source = read(sourceText, syntax, problems);
+		if (source !== null) {
+			for (const d of validateSource(source, {
+				locale: "und",
+				text: sourceText
+			})) if (d.severity === "error") problems.push(issue(d));
+		}
+		if (problems.length > 0) {
+			source = null;
+			for (const p of problems) warnings.push({
+				...p,
+				severity: "warning",
+				message: `In the source: ${p.message}`
+			});
+		}
+	}
+	if (ast !== null) {
+		const options = {
+			locale: locale ?? "und",
+			text
+		};
+		const found = source !== null ? validateTranslation(ast, source, options) : validateSource(ast, options);
+		for (const d of found) {
+			if (locale === void 0 && LOCALE_CODES.has(d.code)) continue;
+			(d.severity === "error" ? errors : warnings).push(issue(d));
+		}
+	}
+	let ir;
+	if (errors.length === 0) ir = compileMessage(ast);
+	else if (source !== null) ir = compileMessage(source);
+	else ir = text.replace(/[‪-‮⁦-⁩]/g, "");
+	return Object.freeze({
+		id: "",
+		message: text,
+		ir,
+		errors: Object.freeze(errors),
+		warnings: Object.freeze(warnings)
+	});
+}
+function read(text, syntax, errors) {
+	try {
+		return parseSource(normalizeSource(text), syntax);
+	} catch (error) {
+		if (!isDiagnosticError(error)) throw error;
+		errors.push(issue(error.diagnostic));
+		return null;
+	}
+}
+function issue(d) {
+	const out = {
+		code: d.code,
+		severity: d.severity === "error" ? "error" : "warning",
+		message: d.message
+	};
+	if (d.line) out.line = d.line;
+	if (d.column) out.column = d.column;
+	return out;
+}
+function report(parsed) {
+	if (DEV) warnOnce(`parse(): ${JSON.stringify(parsed.message)} is invalid (${parsed.errors.map((e) => e.message).join("; ")}); rendering ${typeof parsed.ir === "string" ? JSON.stringify(parsed.ir) : "its source"}`);
+	for (const handler of handlers) try {
+		handler(parsed);
+	} catch (error) {
+		if (DEV) warnOnce(`onParseError handler threw: ${String(error)}`);
+	}
+}
+//#endregion
+export { format, onParseError, parse };