@dev-pi2pie/word-counter 0.1.2 → 0.1.3-canary.1

package/dist/esm/index.d.mts

@@ -1,12 +1,3 @@
-//#region src/wc/locale-detect.d.ts
-interface LocaleDetectOptions {
-  latinLanguageHint?: string;
-  latinTagHint?: string;
-  latinLocaleHint?: string;
-  hanLanguageHint?: string;
-  hanTagHint?: string;
-}
-//#endregion
 //#region src/wc/types.d.ts
 interface LocaleChunk {
   locale: string;
@@ -53,11 +44,18 @@ interface NonWordCollection {
   whitespace?: WhitespaceCounts;
   counts: NonWordCounts;
 }
+interface LatinHintRule {
+  tag: string;
+  pattern: string | RegExp;
+  priority?: number;
+}
 interface WordCounterOptions {
   mode?: WordCounterMode;
   latinLanguageHint?: string;
   latinTagHint?: string;
   latinLocaleHint?: string;
+  latinHintRules?: LatinHintRule[];
+  useDefaultLatinHints?: boolean;
   hanLanguageHint?: string;
   hanTagHint?: string;
   nonWords?: boolean;
@@ -91,6 +89,17 @@ interface WordCounterResult {
   breakdown: WordCounterBreakdown;
 }
 //#endregion
+//#region src/wc/locale-detect.d.ts
+interface LocaleDetectOptions {
+  latinLanguageHint?: string;
+  latinTagHint?: string;
+  latinLocaleHint?: string;
+  latinHintRules?: LatinHintRule[];
+  useDefaultLatinHints?: boolean;
+  hanLanguageHint?: string;
+  hanTagHint?: string;
+}
+//#endregion
 //#region src/wc/segment.d.ts
 declare function segmentTextByLocale(text: string, options?: LocaleDetectOptions): LocaleChunk[];
 //#endregion
@@ -98,6 +107,9 @@ declare function segmentTextByLocale(text: string, options?: LocaleDetectOptions
 declare function countWordsForLocale(text: string, locale: string): number;
 declare function countCharsForLocale(text: string, locale: string): number;
 //#endregion
+//#region src/wc/latin-hints.d.ts
+declare const DEFAULT_LATIN_HINT_RULES: ReadonlyArray<Readonly<LatinHintRule>>;
+//#endregion
 //#region src/wc/wc.d.ts
 declare function wordCounter(text: string, options?: WordCounterOptions): WordCounterResult;
 //#endregion
@@ -133,5 +145,5 @@ declare function parseMarkdown(input: string): ParsedMarkdown;
 //#region src/markdown/section-count.d.ts
 declare function countSections(input: string, section: SectionMode, options?: WordCounterOptions): SectionedResult;
 //#endregion
-export { FrontmatterType, type NonWordCollection, ParsedMarkdown, SectionMode, SectionedResult, type WordCounterBreakdown, type WordCounterMode, type WordCounterOptions, type WordCounterResult, appendAll, countCharsForLocale, countSections, countWordsForLocale, wordCounter as default, wordCounter, parseMarkdown, segmentTextByLocale, showSingularOrPluralWord };
+export { DEFAULT_LATIN_HINT_RULES, FrontmatterType, type LatinHintRule, type NonWordCollection, ParsedMarkdown, SectionMode, SectionedResult, type WordCounterBreakdown, type WordCounterMode, type WordCounterOptions, type WordCounterResult, appendAll, countCharsForLocale, countSections, countWordsForLocale, wordCounter as default, wordCounter, parseMarkdown, segmentTextByLocale, showSingularOrPluralWord };
 //# sourceMappingURL=index.d.mts.map

package/dist/esm/index.mjs

@@ -322,10 +322,53 @@ function resolveMode(input, fallback = "chunk") {
 	return normalizeMode(input) ?? fallback;
 }
 
+//#endregion
+//#region src/wc/latin-hints.ts
+const DEFAULT_LATIN_HINT_RULES_SOURCE = [
+	{
+		tag: "de",
+		pattern: "[äöüÄÖÜß]"
+	},
+	{
+		tag: "es",
+		pattern: "[ñÑ¿¡]"
+	},
+	{
+		tag: "pt",
+		pattern: "[ãõÃÕ]"
+	},
+	{
+		tag: "fr",
+		pattern: "[œŒæÆ]"
+	},
+	{
+		tag: "pl",
+		pattern: "[ąćęłńśźżĄĆĘŁŃŚŹŻ]"
+	},
+	{
+		tag: "tr",
+		pattern: "[ıİğĞşŞ]"
+	},
+	{
+		tag: "ro",
+		pattern: "[ăĂâÂîÎșȘțȚ]"
+	},
+	{
+		tag: "hu",
+		pattern: "[őŐűŰ]"
+	},
+	{
+		tag: "is",
+		pattern: "[ðÐþÞ]"
+	}
+];
+const DEFAULT_LATIN_HINT_RULES = Object.freeze(DEFAULT_LATIN_HINT_RULES_SOURCE.map((rule) => Object.freeze({ ...rule })));
+
 //#endregion
 //#region src/wc/locale-detect.ts
 const DEFAULT_LOCALE = "und-Latn";
-const DEFAULT_HAN_TAG = "zh-Hani";
+const DEFAULT_HAN_TAG = "und-Hani";
+const MAX_LATIN_HINT_PATTERN_LENGTH = 256;
 const regex = {
 	hiragana: /\p{Script=Hiragana}/u,
 	katakana: /\p{Script=Katakana}/u,
@@ -337,31 +380,10 @@ const regex = {
 	devanagari: /\p{Script=Devanagari}/u,
 	thai: /\p{Script=Thai}/u
 };
-const latinLocaleHints = [
-	{
-		locale: "de",
-		regex: /[äöüÄÖÜß]/
-	},
-	{
-		locale: "es",
-		regex: /[ñÑ¿¡]/
-	},
-	{
-		locale: "pt",
-		regex: /[ãõÃÕ]/
-	},
-	{
-		locale: "fr",
-		regex: /[œŒæÆ]/
-	}
-];
-const latinLocales = new Set([DEFAULT_LOCALE, ...latinLocaleHints.map((hint) => hint.locale)]);
-function isLatinLocale(locale) {
-	return latinLocales.has(locale);
-}
-function detectLatinLocale(char) {
-	for (const hint of latinLocaleHints) if (hint.regex.test(char)) return hint.locale;
-	return DEFAULT_LOCALE;
+const defaultLatinLocales = new Set([DEFAULT_LOCALE, ...DEFAULT_LATIN_HINT_RULES.map((hint) => hint.tag)]);
+function isLatinLocale(locale, context) {
+	if (context) return context.latinLocales.has(locale);
+	return defaultLatinLocales.has(locale);
 }
 function resolveLatinHint(options) {
 	const latinTagHint = options.latinTagHint?.trim();
@@ -377,7 +399,82 @@ function resolveHanHint(options) {
 	const hanLanguageHint = options.hanLanguageHint?.trim();
 	if (hanLanguageHint) return hanLanguageHint;
 }
-function detectLocaleForChar(char, previousLocale, options = {}) {
+function compileLatinHintPattern(pattern, label) {
+	const source = typeof pattern === "string" ? pattern : pattern.source;
+	const hasUnicodeMode = typeof pattern !== "string" && (pattern.flags.includes("u") || pattern.flags.includes("v"));
+	const flags = typeof pattern === "string" ? "u" : hasUnicodeMode ? pattern.flags : `${pattern.flags}u`;
+	if (source.length === 0) throw new Error(`${label}: pattern must not be empty.`);
+	if (source.length > MAX_LATIN_HINT_PATTERN_LENGTH) throw new Error(`${label}: pattern must be at most ${MAX_LATIN_HINT_PATTERN_LENGTH} characters.`);
+	try {
+		return new RegExp(source, flags);
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		throw new Error(`${label}: invalid Unicode regex pattern (${message}).`);
+	}
+}
+function normalizeLatinHintPriority(priority, label) {
+	if (priority === void 0) return 0;
+	if (typeof priority !== "number" || !Number.isFinite(priority)) throw new Error(`${label}: priority must be a finite number when provided.`);
+	return priority;
+}
+function compileLatinHintRule(rule, order, label) {
+	const tag = typeof rule.tag === "string" ? rule.tag.trim() : "";
+	if (!tag) throw new Error(`${label}: tag must be a non-empty string.`);
+	return {
+		tag,
+		pattern: compileLatinHintPattern(rule.pattern, label),
+		priority: normalizeLatinHintPriority(rule.priority, label),
+		order
+	};
+}
+function resolveLatinHintRules(options) {
+	const useDefaultLatinHints = options.useDefaultLatinHints !== false;
+	const customRules = options.latinHintRules ?? [];
+	const combinedRules = [];
+	for (let index = 0; index < customRules.length; index += 1) {
+		const rule = customRules[index];
+		if (!rule) continue;
+		combinedRules.push({
+			rule,
+			label: `Invalid custom Latin hint rule at index ${index}`
+		});
+	}
+	if (useDefaultLatinHints) for (let index = 0; index < DEFAULT_LATIN_HINT_RULES.length; index += 1) {
+		const rule = DEFAULT_LATIN_HINT_RULES[index];
+		if (!rule) continue;
+		combinedRules.push({
+			rule,
+			label: `Invalid default Latin hint rule at index ${index}`
+		});
+	}
+	const resolvedRules = combinedRules.map((entry, index) => compileLatinHintRule(entry.rule, index, entry.label));
+	resolvedRules.sort((left, right) => {
+		if (left.priority !== right.priority) return right.priority - left.priority;
+		return left.order - right.order;
+	});
+	return resolvedRules;
+}
+function resolveLocaleDetectContext(options = {}) {
+	const latinHint = resolveLatinHint(options);
+	const latinHintRules = resolveLatinHintRules(options);
+	const latinLocales = new Set([DEFAULT_LOCALE]);
+	for (const rule of latinHintRules) latinLocales.add(rule.tag);
+	if (latinHint) latinLocales.add(latinHint);
+	return {
+		latinHint,
+		hanHint: resolveHanHint(options),
+		latinHintRules,
+		latinLocales
+	};
+}
+function detectLatinLocale(char, context) {
+	for (const hint of context.latinHintRules) {
+		hint.pattern.lastIndex = 0;
+		if (hint.pattern.test(char)) return hint.tag;
+	}
+	return DEFAULT_LOCALE;
+}
+function detectLocaleForChar(char, previousLocale, options = {}, context = resolveLocaleDetectContext(options)) {
 	if (regex.hiragana.test(char) || regex.katakana.test(char)) return "ja";
 	if (regex.hangul.test(char)) return "ko";
 	if (regex.arabic.test(char)) return "ar";
@@ -386,14 +483,13 @@ function detectLocaleForChar(char, previousLocale, options = {}) {
 	if (regex.thai.test(char)) return "th";
 	if (regex.han.test(char)) {
 		if (previousLocale && previousLocale.startsWith("ja")) return previousLocale;
-		return resolveHanHint(options) ?? DEFAULT_HAN_TAG;
+		return context.hanHint ?? DEFAULT_HAN_TAG;
 	}
 	if (regex.latin.test(char)) {
-		const hintedLocale = detectLatinLocale(char);
+		const hintedLocale = detectLatinLocale(char, context);
 		if (hintedLocale !== DEFAULT_LOCALE) return hintedLocale;
-		if (previousLocale && isLatinLocale(previousLocale) && previousLocale !== DEFAULT_LOCALE) return previousLocale;
-		const latinHint = resolveLatinHint(options);
-		if (latinHint) return latinHint;
+		if (previousLocale && isLatinLocale(previousLocale, context) && previousLocale !== DEFAULT_LOCALE) return previousLocale;
+		if (context.latinHint) return context.latinHint;
 		return DEFAULT_LOCALE;
 	}
 	return null;
@@ -402,12 +498,13 @@ function detectLocaleForChar(char, previousLocale, options = {}) {
 //#endregion
 //#region src/wc/segment.ts
 function segmentTextByLocale(text, options = {}) {
+	const context = resolveLocaleDetectContext(options);
 	const chunks = [];
 	let currentLocale = DEFAULT_LOCALE;
 	let buffer = "";
 	let bufferHasScript = false;
 	for (const char of text) {
-		const detected = detectLocaleForChar(char, currentLocale, options);
+		const detected = detectLocaleForChar(char, currentLocale, options, context);
 		const targetLocale = detected ?? currentLocale;
 		if (buffer === "") {
 			currentLocale = targetLocale;
@@ -422,7 +519,7 @@ function segmentTextByLocale(text, options = {}) {
 			continue;
 		}
 		if (targetLocale !== currentLocale && detected !== null) {
-			if (currentLocale === DEFAULT_LOCALE && isLatinLocale(targetLocale)) {
+			if (currentLocale === DEFAULT_LOCALE && isLatinLocale(targetLocale, context)) {
 				currentLocale = targetLocale;
 				buffer += char;
 				bufferHasScript = true;
@@ -475,6 +572,8 @@ function wordCounter(text, options = {}) {
 		latinLanguageHint: options.latinLanguageHint,
 		latinTagHint: options.latinTagHint,
 		latinLocaleHint: options.latinLocaleHint,
+		latinHintRules: options.latinHintRules,
+		useDefaultLatinHints: options.useDefaultLatinHints,
 		hanLanguageHint: options.hanLanguageHint,
 		hanTagHint: options.hanTagHint
 	});
@@ -1115,5 +1214,5 @@ function countSections(input, section, options = {}) {
 }
 
 //#endregion
-export { appendAll, countCharsForLocale, countSections, countWordsForLocale, wc_default as default, wc_default as wordCounter, parseMarkdown, segmentTextByLocale, showSingularOrPluralWord };
+export { DEFAULT_LATIN_HINT_RULES, appendAll, countCharsForLocale, countSections, countWordsForLocale, wc_default as default, wc_default as wordCounter, parseMarkdown, segmentTextByLocale, showSingularOrPluralWord };
 //# sourceMappingURL=index.mjs.map