@analogjs/content 3.0.0-alpha.10 → 3.0.0-alpha.12

package/fesm2022/analogjs-content-md4x.mjs

@@ -0,0 +1,290 @@
+import { d as ContentRenderer, o as withContentFileLoader, r as withContentListLoader } from "./content-list-loader.mjs";
+import * as i0 from "@angular/core";
+import { Injectable, InjectionToken, inject } from "@angular/core";
+//#region packages/content/md4x/src/lib/md4x-content-renderer.service.ts
+var MD4X_RENDERER_OPTIONS = new InjectionToken("md4x_renderer_options");
+function makeSlug$1(text, slugCounts) {
+	const baseSlug = text.toLowerCase().replace(/[^\w\s-]/g, "").trim().replace(/\s+/g, "-");
+	const count = slugCounts.get(baseSlug) ?? 0;
+	slugCounts.set(baseSlug, count + 1);
+	return count === 0 ? baseSlug : `${baseSlug}-${count}`;
+}
+function headingsToToc$1(headings) {
+	const slugCounts = /* @__PURE__ */ new Map();
+	return headings.map((h) => ({
+		id: makeSlug$1(h.text, slugCounts),
+		level: h.level,
+		text: h.text
+	}));
+}
+function injectHeadingIds$1(html, toc) {
+	let tocIndex = 0;
+	return html.replace(/<h([1-6])>/g, (match, level) => {
+		const item = toc[tocIndex++];
+		return item ? `<h${level} id="${item.id}">` : match;
+	});
+}
+/**
+* Content renderer backed by md4x (C-based CommonMark parser compiled with Zig).
+* 50-70x faster than marked for complex documents.
+*
+* @experimental md4x integration is experimental and may change in future releases.
+*/
+var Md4xContentRendererService = class Md4xContentRendererService extends ContentRenderer {
+	constructor() {
+		super(...arguments);
+		this.options = inject(MD4X_RENDERER_OPTIONS, { optional: true });
+	}
+	async render(content) {
+		const { renderToHtml, parseMeta } = await import("md4x/napi");
+		const html = renderToHtml(content, {
+			heal: this.options?.heal,
+			highlighter: this.options?.highlighter
+		});
+		const toc = headingsToToc$1(parseMeta(content).headings);
+		return {
+			content: injectHeadingIds$1(html, toc),
+			toc
+		};
+	}
+	getContentHeadings(content) {
+		const lines = content.split("\n");
+		const toc = [];
+		const slugCounts = /* @__PURE__ */ new Map();
+		for (const line of lines) {
+			const match = /^(#{1,6})\s+(.+?)\s*$/.exec(line);
+			if (!match) continue;
+			const level = match[1].length;
+			const text = match[2].trim();
+			if (!text) continue;
+			toc.push({
+				id: makeSlug$1(text, slugCounts),
+				level,
+				text
+			});
+		}
+		return toc;
+	}
+	static {
+		this.ɵfac = i0.ɵɵngDeclareFactory({
+			minVersion: "12.0.0",
+			version: "21.1.1",
+			ngImport: i0,
+			type: Md4xContentRendererService,
+			deps: null,
+			target: i0.ɵɵFactoryTarget.Injectable
+		});
+	}
+	static {
+		this.ɵprov = i0.ɵɵngDeclareInjectable({
+			minVersion: "12.0.0",
+			version: "21.1.1",
+			ngImport: i0,
+			type: Md4xContentRendererService
+		});
+	}
+};
+i0.ɵɵngDeclareClassMetadata({
+	minVersion: "12.0.0",
+	version: "21.1.1",
+	ngImport: i0,
+	type: Md4xContentRendererService,
+	decorators: [{ type: Injectable }]
+});
+//#endregion
+//#region packages/content/md4x/src/lib/md4x-wasm-content-renderer.service.ts
+function makeSlug(text, slugCounts) {
+	const baseSlug = text.toLowerCase().replace(/[^\w\s-]/g, "").trim().replace(/\s+/g, "-");
+	const count = slugCounts.get(baseSlug) ?? 0;
+	slugCounts.set(baseSlug, count + 1);
+	return count === 0 ? baseSlug : `${baseSlug}-${count}`;
+}
+function headingsToToc(headings) {
+	const slugCounts = /* @__PURE__ */ new Map();
+	return headings.map((h) => ({
+		id: makeSlug(h.text, slugCounts),
+		level: h.level,
+		text: h.text
+	}));
+}
+function injectHeadingIds(html, toc) {
+	let tocIndex = 0;
+	return html.replace(/<h([1-6])>/g, (match, level) => {
+		const item = toc[tocIndex++];
+		return item ? `<h${level} id="${item.id}">` : match;
+	});
+}
+/**
+* Content renderer backed by md4x/wasm for client-side (browser) rendering.
+* ~100KB gzip, 3-6x faster than marked in the browser.
+*
+* @experimental md4x integration is experimental and may change in future releases.
+*/
+var Md4xWasmContentRendererService = class Md4xWasmContentRendererService extends ContentRenderer {
+	constructor() {
+		super(...arguments);
+		this.options = inject(MD4X_RENDERER_OPTIONS, { optional: true });
+		this.initPromise = null;
+	}
+	async render(content) {
+		const wasm = await import("md4x/wasm");
+		if (!this.initPromise) this.initPromise = wasm.init();
+		await this.initPromise;
+		const html = wasm.renderToHtml(content, {
+			heal: this.options?.heal,
+			highlighter: this.options?.highlighter
+		});
+		const toc = headingsToToc(wasm.parseMeta(content).headings);
+		return {
+			content: injectHeadingIds(html, toc),
+			toc
+		};
+	}
+	getContentHeadings(content) {
+		const lines = content.split("\n");
+		const toc = [];
+		const slugCounts = /* @__PURE__ */ new Map();
+		for (const line of lines) {
+			const match = /^(#{1,6})\s+(.+?)\s*$/.exec(line);
+			if (!match) continue;
+			const level = match[1].length;
+			const text = match[2].trim();
+			if (!text) continue;
+			toc.push({
+				id: makeSlug(text, slugCounts),
+				level,
+				text
+			});
+		}
+		return toc;
+	}
+	static {
+		this.ɵfac = i0.ɵɵngDeclareFactory({
+			minVersion: "12.0.0",
+			version: "21.1.1",
+			ngImport: i0,
+			type: Md4xWasmContentRendererService,
+			deps: null,
+			target: i0.ɵɵFactoryTarget.Injectable
+		});
+	}
+	static {
+		this.ɵprov = i0.ɵɵngDeclareInjectable({
+			minVersion: "12.0.0",
+			version: "21.1.1",
+			ngImport: i0,
+			type: Md4xWasmContentRendererService
+		});
+	}
+};
+i0.ɵɵngDeclareClassMetadata({
+	minVersion: "12.0.0",
+	version: "21.1.1",
+	ngImport: i0,
+	type: Md4xWasmContentRendererService,
+	decorators: [{ type: Injectable }]
+});
+//#endregion
+//#region packages/content/md4x/src/lib/provide-md4x.ts
+/**
+* Provides the experimental md4x-based content renderer (NAPI, server/build-time).
+*
+* @experimental md4x integration is experimental and may change in future releases.
+*
+* @example
+* ```typescript
+* provideContent(withMd4xRenderer());
+* provideContent(withMd4xRenderer({ heal: true }));
+* ```
+*/
+function withMd4xRenderer(options) {
+	return [
+		{
+			provide: ContentRenderer,
+			useClass: Md4xContentRendererService
+		},
+		options ? {
+			provide: MD4X_RENDERER_OPTIONS,
+			useValue: options
+		} : [],
+		withContentFileLoader(),
+		withContentListLoader()
+	];
+}
+/**
+* Provides the experimental md4x WASM content renderer (browser/CSR).
+* ~100KB gzip, 3-6x faster than marked in the browser.
+*
+* @experimental md4x integration is experimental and may change in future releases.
+*
+* @example
+* ```typescript
+* provideContent(withMd4xWasmRenderer());
+* ```
+*/
+function withMd4xWasmRenderer(options) {
+	return [
+		{
+			provide: ContentRenderer,
+			useClass: Md4xWasmContentRendererService
+		},
+		options ? {
+			provide: MD4X_RENDERER_OPTIONS,
+			useValue: options
+		} : [],
+		withContentFileLoader(),
+		withContentListLoader()
+	];
+}
+//#endregion
+//#region packages/content/md4x/src/lib/streaming-markdown-renderer.ts
+/**
+* Transforms a stream of markdown chunks into a stream of rendered HTML.
+* Uses md4x's `heal()` to fix incomplete markdown from streaming sources
+* (LLMs, collaborative editing) so each emitted HTML chunk is valid.
+*
+* @experimental Streaming markdown support is experimental and may change in future releases.
+*
+* @example
+* ```typescript
+* // In a Nitro API route
+* import { streamMarkdown } from '@analogjs/content';
+*
+* export default defineEventHandler(async (event) => {
+*   const llmStream = getAIStream(prompt);
+*   return streamMarkdown(llmStream, { heal: true });
+* });
+* ```
+*/
+async function streamMarkdown(input, options) {
+	const { renderToHtml, heal } = await import("md4x/napi");
+	let buffer = "";
+	const reader = input.getReader();
+	return new ReadableStream({
+		async pull(controller) {
+			try {
+				const { done, value } = await reader.read();
+				if (done) {
+					if (buffer) {
+						const source = options?.heal ? heal(buffer) : buffer;
+						controller.enqueue(renderToHtml(source));
+					}
+					controller.close();
+					return;
+				}
+				buffer += value;
+				const source = options?.heal ? heal(buffer) : buffer;
+				controller.enqueue(renderToHtml(source));
+			} catch (error) {
+				controller.error(error);
+			}
+		},
+		cancel() {
+			reader.cancel();
+		}
+	});
+}
+//#endregion
+export { MD4X_RENDERER_OPTIONS, Md4xContentRendererService, Md4xWasmContentRendererService, streamMarkdown, withMd4xRenderer, withMd4xWasmRenderer };
+
+//# sourceMappingURL=analogjs-content-md4x.mjs.map

package/fesm2022/analogjs-content-mdc.mjs

@@ -0,0 +1,170 @@
+import * as i0 from "@angular/core";
+import { Directive, ElementRef, InjectionToken, Renderer2, ViewContainerRef, effect, inject, input } from "@angular/core";
+//#region packages/content/mdc/src/lib/mdc-component-registry.ts
+/**
+* Registry mapping MDC component names to lazy-loaded Angular components.
+*
+* @experimental MDC component support is experimental and may change in future releases.
+*/
+var MDC_COMPONENTS = new InjectionToken("mdc_components");
+/**
+* Provides a registry of Angular components that can be used in MDC
+* (Markdown Components) syntax within markdown content.
+*
+* @experimental MDC component support is experimental and may change in future releases.
+*
+* @example
+* ```typescript
+* provideContent(
+*   withMd4xRenderer(),
+*   withMdcComponents({
+*     alert: () => import('./components/alert.component').then(m => m.AlertComponent),
+*     card: () => import('./components/card.component').then(m => m.CardComponent),
+*   }),
+* );
+* ```
+*/
+function withMdcComponents(components) {
+	return {
+		provide: MDC_COMPONENTS,
+		useValue: new Map(Object.entries(components))
+	};
+}
+//#endregion
+//#region packages/content/mdc/src/lib/mdc-renderer.directive.ts
+/**
+* Directive that renders MDC (Markdown Components) AST nodes as Angular components.
+*
+* Walks the ComarkTree AST from md4x's `parseAST()`, matches component nodes
+* to the registered MDC_COMPONENTS map, and instantiates them via
+* `ViewContainerRef.createComponent()` with MDC attributes bound as inputs.
+*
+* @experimental MDC component support is experimental and may change in future releases.
+*
+* @example
+* ```html
+* <div [mdcAst]="parsedAst"></div>
+* ```
+*/
+var MdcRendererDirective = class MdcRendererDirective {
+	constructor() {
+		this.ast = input(null, { alias: "mdcAst" });
+		this.viewContainer = inject(ViewContainerRef);
+		this.renderer = inject(Renderer2);
+		this.el = inject(ElementRef);
+		this.components = inject(MDC_COMPONENTS, { optional: true });
+		this.renderId = 0;
+		effect(() => {
+			const ast = this.ast();
+			const currentRenderId = ++this.renderId;
+			this.viewContainer.clear();
+			const host = this.el.nativeElement;
+			host.innerHTML = "";
+			if (!ast?.nodes) return;
+			this.renderNodes(ast.nodes, host, currentRenderId);
+		});
+	}
+	async renderNodes(nodes, parent, renderId) {
+		for (const node of nodes) {
+			if (this.renderId !== renderId) return;
+			await this.renderNode(node, parent, renderId);
+		}
+	}
+	async renderNode(node, parent, renderId) {
+		if (this.renderId !== renderId) return;
+		if (typeof node === "string") {
+			const text = this.renderer.createText(node);
+			this.renderer.appendChild(parent, text);
+			return;
+		}
+		const [tag, props, ...children] = node;
+		if (!tag) {
+			for (const child of children) {
+				if (this.renderId !== renderId) return;
+				await this.renderNode(child, parent, renderId);
+			}
+			return;
+		}
+		const componentLoader = this.components?.get(tag);
+		if (componentLoader) {
+			try {
+				const componentType = await componentLoader();
+				if (this.renderId !== renderId) return;
+				const tempContainer = this.renderer.createElement("div");
+				for (const child of children) {
+					if (this.renderId !== renderId) return;
+					await this.renderNode(child, tempContainer, renderId);
+				}
+				if (this.renderId !== renderId) return;
+				const projectableNodes = [Array.from(tempContainer.childNodes)];
+				const componentRef = this.viewContainer.createComponent(componentType, { projectableNodes });
+				for (const [key, value] of Object.entries(props)) componentRef.setInput(key, value);
+				const componentEl = componentRef.location.nativeElement;
+				this.renderer.appendChild(parent, componentEl);
+			} catch (e) {
+				console.error(`[MdcRenderer] Failed to load component "${tag}":`, e);
+			}
+			return;
+		}
+		const el = this.renderer.createElement(tag);
+		for (const [key, value] of Object.entries(props)) this.renderer.setAttribute(el, key, String(value));
+		for (const child of children) {
+			if (this.renderId !== renderId) return;
+			await this.renderNode(child, el, renderId);
+		}
+		this.renderer.appendChild(parent, el);
+	}
+	static {
+		this.ɵfac = i0.ɵɵngDeclareFactory({
+			minVersion: "12.0.0",
+			version: "21.1.1",
+			ngImport: i0,
+			type: MdcRendererDirective,
+			deps: [],
+			target: i0.ɵɵFactoryTarget.Directive
+		});
+	}
+	static {
+		this.ɵdir = i0.ɵɵngDeclareDirective({
+			minVersion: "17.1.0",
+			version: "21.1.1",
+			type: MdcRendererDirective,
+			isStandalone: true,
+			selector: "[mdcAst]",
+			inputs: { ast: {
+				classPropertyName: "ast",
+				publicName: "mdcAst",
+				isSignal: true,
+				isRequired: false,
+				transformFunction: null
+			} },
+			ngImport: i0
+		});
+	}
+};
+i0.ɵɵngDeclareClassMetadata({
+	minVersion: "12.0.0",
+	version: "21.1.1",
+	ngImport: i0,
+	type: MdcRendererDirective,
+	decorators: [{
+		type: Directive,
+		args: [{
+			selector: "[mdcAst]",
+			standalone: true
+		}]
+	}],
+	ctorParameters: () => [],
+	propDecorators: { ast: [{
+		type: i0.Input,
+		args: [{
+			isSignal: true,
+			alias: "mdcAst",
+			required: false
+		}]
+	}] }
+});
+//#endregion
+export { MDC_COMPONENTS, MdcRendererDirective, withMdcComponents };
+
+//# sourceMappingURL=analogjs-content-mdc.mjs.map