[WIP] Simplify core

src/core.ts

@@ -1,2 +1,2 @@
-export { Prism } from './core/prism';
+export { Prism } from './core/prism-class';
 export { Token } from './core/token';

src/core/highlight-all.ts

@@ -0,0 +1,41 @@
+import singleton, { type Prism } from './prism';
+import type { HighlightElementOptions } from './highlight-element';
+
+/**
+ * This is the most high-level function in Prism’s API.
+ * It queries all the elements that have a `.language-xxxx` class and then calls {@link Prism#highlightElement} on
+ * each one of them.
+ *
+ * The following hooks will be run:
+ * 1. `before-highlightall`
+ * 2. `before-all-elements-highlight`
+ * 3. All hooks of {@link Prism#highlightElement} for each element.
+ */
+export function highlightAll (this: Prism, options: HighlightAllOptions = {}) {
+	const prism = this ?? singleton;
+	const { root, async, callback } = options;
+
+	const env: Record<any, any> = {
+		callback,
+		root: root ?? document,
+		selector:
+			'code[class*="language-"], [class*="language-"] code, code[class*="lang-"], [class*="lang-"] code',
+	};
+
+	prism.hooks.run('before-highlightall', env);
+
+	env.elements = [...env.root.querySelectorAll(env.selector)];
+
+	prism.hooks.run('before-all-elements-highlight', env);
+
+	for (const element of env.elements) {
+		prism.highlightElement(element, { async, callback: env.callback });
+	}
+}
+
+export interface HighlightAllOptions extends HighlightElementOptions {
+	/**
+	 * The root element, whose descendants that have a `.language-xxxx` class will be highlighted.
+	 */
+	root?: ParentNode;
+}

src/core/highlight-element.ts

@@ -0,0 +1,114 @@
+import { getLanguage, setLanguage } from '../shared/dom-util';
+import { htmlEncode } from '../shared/util';
+import type { Grammar, GrammarToken, GrammarTokens, RegExpLike } from '../types';
+import singleton, { type Prism } from './prism';
+
+/**
+ * Highlights the code inside a single element.
+ *
+ * The following hooks will be run:
+ * 1. `before-sanity-check`
+ * 2. `before-highlight`
+ * 3. All hooks of {@link Prism#highlight}. These hooks will be run by an asynchronous worker if `async` is `true`.
+ * 4. `before-insert`
+ * 5. `after-highlight`
+ * 6. `complete`
+ *
+ * Some the above hooks will be skipped if the element doesn't contain any text or there is no grammar loaded for
+ * the element's language.
+ *
+ * @param element The element containing the code.
+ * It must have a class of `language-xxxx` to be processed, where `xxxx` is a valid language identifier.
+ */
+export function highlightElement (
+	this: Prism,
+	element: Element,
+	options: HighlightElementOptions = {}
+) {
+	const prism = this ?? singleton;
+	const { async, callback } = options;
+
+	// Find language
+	const language = getLanguage(element);
+	const languageId = prism.components.resolveAlias(language);
+	const grammar = prism.components.getLanguage(languageId);
+
+	// Set language on the element, if not present
+	setLanguage(element, language);
+
+	// Set language on the parent, for styling
+	let parent = element.parentElement;
+	if (parent && parent.nodeName.toLowerCase() === 'pre') {
+		setLanguage(parent, language);
+	}
+
+	const code = element.textContent as string;
+
+	const env: Record<string, any> = {
+		element,
+		language,
+		grammar,
+		code,
+	};
+
+	const insertHighlightedCode = (highlightedCode: string) => {
+		env.highlightedCode = highlightedCode;
+		prism.hooks.run('before-insert', env);
+
+		env.element.innerHTML = env.highlightedCode;
+
+		prism.hooks.run('after-highlight', env);
+		prism.hooks.run('complete', env);
+		callback?.(env.element);
+	};
+
+	prism.hooks.run('before-sanity-check', env);
+
+	// plugins may change/add the parent/element
+	parent = env.element.parentElement;
+	if (parent && parent.nodeName.toLowerCase() === 'pre' && !parent.hasAttribute('tabindex')) {
+		parent.setAttribute('tabindex', '0');
+	}
+
+	if (!env.code) {
+		prism.hooks.run('complete', env);
+		callback?.(env.element);
+		return;
+	}
+
+	prism.hooks.run('before-highlight', env);
+
+	if (!env.grammar) {
+		insertHighlightedCode(htmlEncode(env.code));
+		return;
+	}
+
+	if (async) {
+		async({
+			language: env.language,
+			code: env.code,
+			grammar: env.grammar,
+		}).then(insertHighlightedCode, error => console.log(error));
+	}
+	else {
+		insertHighlightedCode(prism.highlight(env.code, env.language, { grammar: env.grammar }));
+	}
+}
+
+export interface HighlightElementOptions {
+	async?: AsyncHighlighter;
+	/**
+	 * An optional callback to be invoked after the highlighting is done.
+	 * Mostly useful when `async` is `true`, since in that case, the highlighting is done asynchronously.
+	 *
+	 * @param element The element successfully highlighted.
+	 */
+	callback?: (element: Element) => void;
+}
+
+export interface AsyncHighlightingData {
+	language: string;
+	code: string;
+	grammar: Grammar;
+}
+export type AsyncHighlighter = (data: AsyncHighlightingData) => Promise<string>;

src/core/highlight.ts

@@ -0,0 +1,55 @@
+import { Token } from './token';
+import singleton, { type Prism } from './prism';
+import { stringify } from './stringify';
+import type { Grammar, GrammarToken, GrammarTokens, RegExpLike } from '../types';
+
+/**
+ * Low-level function, only use if you know what you’re doing. It accepts a string of text as input
+ * and the language definitions to use, and returns a string with the HTML produced.
+ *
+ * The following hooks will be run:
+ * 1. `before-tokenize`
+ * 2. `after-tokenize`
+ * 3. `wrap`: On each {@link Token}.
+ *
+ * @param text A string with the code to be highlighted.
+ * @param language The name of the language definition passed to `grammar`.
+ * @param options An object containing the tokens to use.
+ *
+ * Usually a language definition like `Prism.languages.markup`.
+ * @returns The highlighted HTML.
+ * @example
+ * Prism.highlight('var foo = true;', 'javascript');
+ */
+export function highlight (
+	this: Prism,
+	text: string,
+	language: string,
+	options?: HighlightOptions
+): string {
+	const prism = this ?? singleton;
+
+	const languageId = prism.components.resolveAlias(language);
+	const grammar = options?.grammar ?? prism.components.getLanguage(languageId);
+
+	const env: Record<string, any> | Record<string, any> = {
+		code: text,
+		grammar,
+		language,
+	};
+
+	prism.hooks.run('before-tokenize', env);
+
+	if (!env.grammar) {
+		throw new Error('The language "' + env.language + '" has no grammar.');
+	}
+
+	env.tokens = prism.tokenize(env.code, env.grammar);
+	prism.hooks.run('after-tokenize', env);
+
+	return stringify(env.tokens, env.language, prism.hooks);
+}
+
+export interface HighlightOptions {
+	grammar?: Grammar;
+}

src/core/hooks.ts

@@ -1,7 +1,3 @@
-import type { Grammar, TokenName } from '../types';
-import type { HookState } from './hook-state';
-import type { TokenStream } from './token';
-
 export class Hooks {
 	// eslint-disable-next-line func-call-spacing
 	private _all = new Map<string, ((env: unknown) => void)[]>();
@@ -47,7 +43,7 @@ export class Hooks {
 	 * @param name The name of the hook.
 	 * @param env The environment variables of the hook passed to all callbacks registered.
 	 */
-	run<Name extends string> (name: Name, env: HookEnv<Name>): void {
+	run<Name extends string> (name: Name, env: Record<string, any>): void {
 		const callbacks = this._all.get(name);
 
 		if (!callbacks || !callbacks.length) {
@@ -60,102 +56,4 @@ export class Hooks {
 	}
 }
 
-/**
- * An interface containing all hooks Prism runs.
- */
-export interface HookEnvMap {
-	// Prism.highlightAll
-	'before-highlightall': BeforeHighlightAllEnv;
-	'before-all-elements-highlight': BeforeAllElementsHighlightEnv;
-
-	// Prism.highlightElement
-	'before-sanity-check': BeforeSanityCheckEnv;
-	'before-highlight': BeforeHighlightEnv;
-
-	'before-insert': BeforeInsertEnv;
-	'after-highlight': AfterHighlightEnv;
-	'complete': CompleteEnv;
-
-	// Prism.highlight
-	'before-tokenize': BeforeTokenizeEnv;
-	'after-tokenize': AfterTokenizeEnv;
-
-	// stringify
-	'wrap': WrapEnv;
-}
-
-export type HookEnv<HookName extends string> = HookName extends keyof HookEnvMap
-	? HookEnvMap[HookName]
-	: unknown;
-
-export type HookCallback<HookName extends string> = (env: HookEnv<HookName>) => void;
-
-interface StatefulEnv {
-	readonly state: HookState;
-}
-
-export interface BeforeHighlightAllEnv extends StatefulEnv {
-	root: ParentNode;
-	selector: string;
-	callback?: (element: Element) => void;
-}
-export interface BeforeAllElementsHighlightEnv extends StatefulEnv {
-	root: ParentNode;
-	selector: string;
-	callback?: (element: Element) => void;
-	elements: Element[];
-}
-
-export interface BeforeSanityCheckEnv extends StatefulEnv {
-	element: Element;
-	language: string;
-	grammar: Grammar | undefined;
-	code: string;
-}
-export interface BeforeHighlightEnv extends StatefulEnv {
-	element: Element;
-	language: string;
-	grammar: Grammar | undefined;
-	code: string;
-}
-export interface CompleteEnv extends StatefulEnv {
-	element: Element;
-	language: string;
-	grammar: Grammar | undefined;
-	code: string;
-}
-export interface BeforeInsertEnv extends StatefulEnv {
-	element: Element;
-	language: string;
-	grammar: Grammar | undefined;
-	code: string;
-	highlightedCode: string;
-}
-export interface AfterHighlightEnv extends StatefulEnv {
-	element: Element;
-	language: string;
-	grammar: Grammar | undefined;
-	code: string;
-	highlightedCode: string;
-}
-
-export interface BeforeTokenizeEnv {
-	code: string;
-	language: string;
-	grammar: Grammar | undefined;
-}
-export interface AfterTokenizeEnv {
-	code: string;
-	language: string;
-	grammar: Grammar;
-	tokens: TokenStream;
-}
-
-export interface WrapEnv {
-	type: TokenName;
-	content: string;
-	tag: string;
-	classes: string[];
-	attributes: Record<string, string>;
-	language: string;
-}
+export type HookCallback<HookName extends string> = (env: Record<string, any>) => void;