@analogjs/content 3.0.0-alpha.1 → 3.0.0-alpha.11

package/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2022 Brandon Roberts
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/fesm2022/__vite-browser-external.mjs

@@ -0,0 +1,9 @@
+import { t as __commonJSMin } from "./chunk.mjs";
+//#region __vite-browser-external
+var require___vite_browser_external = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	module.exports = {};
+}));
+//#endregion
+export { require___vite_browser_external as t };
+
+//# sourceMappingURL=__vite-browser-external.mjs.map

package/fesm2022/analogjs-content-md4x.mjs

@@ -0,0 +1,290 @@
+import * as i0 from "@angular/core";
+import { Injectable, InjectionToken, inject } from "@angular/core";
+import { ContentRenderer, withContentFileLoader, withContentListLoader } from "@analogjs/content";
+//#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

package/fesm2022/analogjs-content-og.mjs

@@ -1,48 +1,36 @@
-import satori from 'satori';
-import { html } from 'satori-html';
-import sharp from 'sharp';
-
-// Credit for modified source: https://github.com/etherCorps/sveltekit-og/blob/main/src/lib/api.ts
-const generateImage = async (element, options) => {
-    const elementHtml = html(element);
-    const svg = await satori(elementHtml, {
-        width: options.width || 1200,
-        height: options.height || 630,
-        fonts: options.fonts?.length ? options.fonts : [],
-        tailwindConfig: options.tailwindConfig,
-    });
-    const svgBuffer = Buffer.from(svg);
-    const png = sharp(svgBuffer).png().toBuffer();
-    const pngBuffer = await png;
-    return pngBuffer;
+import satori from "satori";
+import { html } from "satori-html";
+import sharp from "sharp";
+//#region packages/content/og/src/lib/og.ts
+var generateImage = async (element, options) => {
+	const svg = await satori(html(element), {
+		width: options.width || 1200,
+		height: options.height || 630,
+		fonts: options.fonts?.length ? options.fonts : [],
+		tailwindConfig: options.tailwindConfig
+	});
+	return await sharp(Buffer.from(svg)).png().toBuffer();
 };
-class ImageResponse extends Response {
-    constructor(element, options = {}) {
-        super();
-        const body = new ReadableStream({
-            async start(controller) {
-                const buffer = await generateImage(element, options);
-                controller.enqueue(buffer);
-                controller.close();
-            },
-        });
-        return new Response(body, {
-            headers: {
-                'Content-Type': 'image/png',
-                'Cache-Control': options.debug
-                    ? 'no-cache, no-store'
-                    : 'public, immutable, no-transform, max-age=31536000',
-                ...options.headers,
-            },
-            status: options.status || 200,
-            statusText: options.statusText,
-        });
-    }
-}
-
-/**
- * Generated bundle index. Do not edit.
- */
-
+var ImageResponse = class extends Response {
+	constructor(element, options = {}) {
+		super();
+		const body = new ReadableStream({ async start(controller) {
+			const buffer = await generateImage(element, options);
+			controller.enqueue(buffer);
+			controller.close();
+		} });
+		return new Response(body, {
+			headers: {
+				"Content-Type": "image/png",
+				"Cache-Control": options.debug ? "no-cache, no-store" : "public, immutable, no-transform, max-age=31536000",
+				...options.headers
+			},
+			status: options.status || 200,
+			statusText: options.statusText
+		});
+	}
+};
+//#endregion
 export { ImageResponse };
-//# sourceMappingURL=analogjs-content-og.mjs.map
+
+//# sourceMappingURL=analogjs-content-og.mjs.map