xonecas.io
719
Le

lextide / files

lextide / src / registry.ts

4.4 KB
1import { parseSource } from "./core/engine";
2import { buildChildren, createRoot } from "./hast";
3import { LanguageStream } from "./stream";
4import type {
5	AutoOptions,
6	GrammarDefinition,
7	HighlightStream,
8	LanguageFn,
9	Lowlight,
10	Options,
11	Root,
12	StreamOptions,
13} from "./types";
14
15interface RegisteredLanguage {
16	grammar: GrammarDefinition;
17	name: string;
18}
19
20export function createLowlight(
21	grammars?: Readonly<Record<string, LanguageFn>> | null,
22): Lowlight {
23	const languages = new Map<string, RegisteredLanguage>();
24	const aliases = new Map<string, string>();
25
26	if (grammars) {
27		register(grammars);
28	}
29
30	function highlight(
31		language: string,
32		value: string,
33		options?: Options | null,
34	): Root {
35		const registered = resolveRegisteredLanguage(language);
36
37		if (!registered) {
38			throw new Error(`Unknown language: \`${language}\` is not registered`);
39		}
40
41		const parse = parseSource(registered.grammar, value);
42		const children = buildChildren(parse.segments, options?.prefix);
43
44		return createRoot(
45			children,
46			language,
47			(registered.grammar.relevance ?? 0) + parse.relevance,
48		);
49	}
50
51	function highlightAuto(value: string, options?: AutoOptions | null): Root {
52		const subset = options?.subset ?? listLanguages();
53		let best: Root | undefined;
54		let bestRelevance = 0;
55
56		for (const name of subset) {
57			if (!registered(name)) {
58				continue;
59			}
60
61			const current = highlight(name, value, { prefix: options?.prefix });
62			const relevance = current.data?.relevance ?? 0;
63
64			if (relevance > bestRelevance) {
65				best = current;
66				bestRelevance = relevance;
67			}
68		}
69
70		return best ?? createRoot([], undefined, 0);
71	}
72
73	function listLanguages(): string[] {
74		return [...languages.keys()];
75	}
76
77	function register(name: string, grammar: LanguageFn): void;
78	function register(
79		grammarsToRegister: Readonly<Record<string, LanguageFn>>,
80	): void;
81	function register(
82		grammarsOrName: Readonly<Record<string, LanguageFn>> | string,
83		grammar?: LanguageFn,
84	): void {
85		if (typeof grammarsOrName === "string") {
86			if (!grammar) {
87				throw new Error("expected `grammar`");
88			}
89
90			registerLanguage(grammarsOrName, grammar);
91			return;
92		}
93
94		for (const [name, currentGrammar] of Object.entries(grammarsOrName)) {
95			registerLanguage(name, currentGrammar);
96		}
97	}
98
99	function registerAlias(
100		language: string,
101		alias: readonly string[] | string,
102	): void;
103	function registerAlias(
104		aliasesToRegister: Readonly<Record<string, readonly string[] | string>>,
105	): void;
106	function registerAlias(
107		aliasesOrLanguage:
108			| Readonly<Record<string, readonly string[] | string>>
109			| string,
110		alias?: readonly string[] | string,
111	): void {
112		if (typeof aliasesOrLanguage === "string") {
113			if (alias === undefined) {
114				throw new Error("expected `alias`");
115			}
116
117			registerLanguageAlias(aliasesOrLanguage, alias);
118			return;
119		}
120
121		for (const [languageName, currentAlias] of Object.entries(
122			aliasesOrLanguage,
123		)) {
124			registerLanguageAlias(languageName, currentAlias);
125		}
126	}
127
128	function registered(aliasOrName: string): boolean {
129		return resolveRegisteredLanguage(aliasOrName) !== undefined;
130	}
131
132	function stream(
133		language: string,
134		options?: StreamOptions | null,
135	): HighlightStream {
136		const registered = resolveRegisteredLanguage(language);
137
138		if (!registered) {
139			throw new Error(`Unknown language: \`${language}\` is not registered`);
140		}
141
142		return new LanguageStream(
143			registered.grammar,
144			language,
145			options?.prefix,
146			options?.allowRecalls === true,
147		);
148	}
149
150	return {
151		highlight,
152		highlightAuto,
153		listLanguages,
154		register,
155		registerAlias,
156		registered,
157		stream,
158	};
159
160	function registerLanguage(name: string, grammar: LanguageFn): void {
161		const definition = grammar();
162		languages.set(name, { grammar: definition, name });
163
164		if (definition.aliases) {
165			registerLanguageAlias(name, definition.aliases);
166		}
167	}
168
169	function registerLanguageAlias(
170		language: string,
171		alias: readonly string[] | string,
172	): void {
173		if (!languages.has(language)) {
174			throw new Error(`Unknown language: \`${language}\` is not registered`);
175		}
176
177		const values = typeof alias === "string" ? [alias] : [...alias];
178
179		for (const value of values) {
180			aliases.set(value, language);
181		}
182	}
183
184	function resolveRegisteredLanguage(
185		aliasOrName: string,
186	): RegisteredLanguage | undefined {
187		const direct = languages.get(aliasOrName);
188
189		if (direct) {
190			return direct;
191		}
192
193		const canonicalName = aliases.get(aliasOrName);
194
195		return canonicalName ? languages.get(canonicalName) : undefined;
196	}
197}