@veryfront/ext-content-mdx 0.1.985

package/esm/extensions/ext-content-mdx/src/compiler/mdx-compile.js

@@ -0,0 +1,53 @@
+import { compile } from "@mdx-js/mdx";
+import { extractFrontmatter } from "../../../../src/transforms/mdx/compiler/frontmatter-extractor.js";
+import { rewriteBodyImports, rewriteCompiledImports } from "../../../../src/transforms/mdx/compiler/import-rewriter.js";
+import { getRehypePlugins, getRemarkPlugins } from "../plugins/plugin-loader.js";
+import { rehypeNodePositions } from "../plugins/rehype-node-positions.js";
+export async function compileMdx(options) {
+    const { projectDir, content, frontmatter: providedFrontmatter, filePath, target = "server", baseUrl, studioEmbed, outputFormat = "program", remarkPlugins: additionalRemarkPlugins = [], rehypePlugins: additionalRehypePlugins = [], } = options;
+    const remarkPlugins = [
+        ...getRemarkPlugins(),
+        ...additionalRemarkPlugins,
+    ];
+    const rehypePlugins = [
+        ...getRehypePlugins(),
+        ...additionalRehypePlugins,
+    ];
+    if (studioEmbed && filePath) {
+        rehypePlugins.push([rehypeNodePositions, { filePath }]);
+    }
+    const { body: extractedBody, frontmatter: extractedFrontmatter } = extractFrontmatter(content, providedFrontmatter);
+    const shouldRewriteImports = Boolean(filePath) &&
+        (target === "browser" || target === "server");
+    const body = shouldRewriteImports
+        ? rewriteBodyImports(extractedBody, { filePath: filePath, target, baseUrl, projectDir })
+        : extractedBody;
+    const compiled = await compile(body, {
+        outputFormat,
+        // Always false: @mdx-js/mdx development mode emits extra JSX
+        // transforms that break the existing rendering pipeline.
+        development: false,
+        remarkPlugins,
+        rehypePlugins,
+        providerImportSource: undefined,
+        jsxImportSource: "react",
+    });
+    const headings = compiled.data?.headings ??
+        [];
+    const compiledString = String(compiled);
+    const compiledCode = shouldRewriteImports
+        ? rewriteCompiledImports(compiledString, {
+            filePath: filePath,
+            target,
+            baseUrl,
+            projectDir,
+        })
+        : compiledString;
+    return {
+        compiledCode,
+        frontmatter: extractedFrontmatter,
+        globals: {},
+        headings,
+        nodeMap: new Map(),
+    };
+}

package/esm/extensions/ext-content-mdx/src/index.d.ts

@@ -0,0 +1,31 @@
+/**
+ * ext-content-mdx: ContentProcessor implementation backed by MDX + remark/rehype.
+ *
+ * Provides the `ContentProcessor` contract:
+ *  - `compileMdx(options)` runs @mdx-js/mdx through Veryfront's remark +
+ *    rehype plugin stack and returns compiled ESM plus extracted headings
+ *    and frontmatter.
+ *  - `compileMarkdown(options)` runs a unified markdown pipeline
+ *    (remark-parse to remark-rehype to rehype-sanitize to rehype-stringify)
+ *    producing sanitized HTML wrapped in a React component.
+ *
+ * Core's `src/transforms/md/compiler` and `src/transforms/mdx/compiler`
+ * resolve this contract at call time. When the extension is not installed,
+ * core throws an actionable install message (see
+ * `src/extensions/recommendations.ts`).
+ *
+ * @module extensions/ext-content-mdx
+ */
+import "../../../_dnt.polyfills.js";
+import type { ExtensionFactory } from "veryfront/extensions";
+import type { ContentCompileOptions, ContentPlugin, ContentProcessingResult, ContentProcessor } from "veryfront/extensions/content";
+declare class MdxContentProcessor implements ContentProcessor {
+    compileMdx(options: ContentCompileOptions): Promise<ContentProcessingResult>;
+    compileMarkdown(options: ContentCompileOptions): Promise<ContentProcessingResult>;
+    getRemarkPlugins(): ContentPlugin[];
+    getRehypePlugins(): ContentPlugin[];
+}
+declare const extMdx: ExtensionFactory;
+export default extMdx;
+export { MdxContentProcessor };
+//# sourceMappingURL=index.d.ts.map

package/esm/extensions/ext-content-mdx/src/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/extensions/ext-content-mdx/src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AACH,OAAO,4BAA4B,CAAC;AAGpC,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AAC7D,OAAO,KAAK,EACV,qBAAqB,EACrB,aAAa,EACb,uBAAuB,EACvB,gBAAgB,EACjB,MAAM,8BAA8B,CAAC;AAKtC,cAAM,mBAAoB,YAAW,gBAAgB;IACnD,UAAU,CAAC,OAAO,EAAE,qBAAqB,GAAG,OAAO,CAAC,uBAAuB,CAAC;IAG5E,eAAe,CAAC,OAAO,EAAE,qBAAqB,GAAG,OAAO,CAAC,uBAAuB,CAAC;IAGjF,gBAAgB,IAAI,aAAa,EAAE;IAGnC,gBAAgB,IAAI,aAAa,EAAE;CAGpC;AAED,QAAA,MAAM,MAAM,EAAE,gBAiBb,CAAC;AAEF,eAAe,MAAM,CAAC;AACtB,OAAO,EAAE,mBAAmB,EAAE,CAAC"}

package/esm/extensions/ext-content-mdx/src/index.js

@@ -0,0 +1,56 @@
+/**
+ * ext-content-mdx: ContentProcessor implementation backed by MDX + remark/rehype.
+ *
+ * Provides the `ContentProcessor` contract:
+ *  - `compileMdx(options)` runs @mdx-js/mdx through Veryfront's remark +
+ *    rehype plugin stack and returns compiled ESM plus extracted headings
+ *    and frontmatter.
+ *  - `compileMarkdown(options)` runs a unified markdown pipeline
+ *    (remark-parse to remark-rehype to rehype-sanitize to rehype-stringify)
+ *    producing sanitized HTML wrapped in a React component.
+ *
+ * Core's `src/transforms/md/compiler` and `src/transforms/mdx/compiler`
+ * resolve this contract at call time. When the extension is not installed,
+ * core throws an actionable install message (see
+ * `src/extensions/recommendations.ts`).
+ *
+ * @module extensions/ext-content-mdx
+ */
+import "../../../_dnt.polyfills.js";
+import { compileMdx } from "./compiler/mdx-compile.js";
+import { compileMarkdown } from "./compiler/markdown-compile.js";
+import { getRehypePlugins, getRemarkPlugins } from "./plugins/plugin-loader.js";
+class MdxContentProcessor {
+    compileMdx(options) {
+        return compileMdx(options);
+    }
+    compileMarkdown(options) {
+        return compileMarkdown(options);
+    }
+    getRemarkPlugins() {
+        return getRemarkPlugins();
+    }
+    getRehypePlugins() {
+        return getRehypePlugins();
+    }
+}
+const extMdx = () => {
+    const impl = new MdxContentProcessor();
+    return {
+        name: "ext-content-mdx",
+        version: "0.1.0",
+        contracts: {
+            provides: ["ContentProcessor"],
+        },
+        capabilities: [],
+        setup(ctx) {
+            ctx.provide("ContentProcessor", impl);
+            ctx.logger.info("[ext-content-mdx] ContentProcessor registered");
+        },
+        teardown() {
+            // No resources to release.
+        },
+    };
+};
+export default extMdx;
+export { MdxContentProcessor };

package/esm/extensions/ext-content-mdx/src/plugins/plugin-loader.d.ts

@@ -0,0 +1,4 @@
+import type { Pluggable } from "unified";
+export declare function getRemarkPlugins(): Pluggable[];
+export declare function getRehypePlugins(): Pluggable[];
+//# sourceMappingURL=plugin-loader.d.ts.map

package/esm/extensions/ext-content-mdx/src/plugins/plugin-loader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plugin-loader.d.ts","sourceRoot":"","sources":["../../../../../src/extensions/ext-content-mdx/src/plugins/plugin-loader.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;AAQzC,wBAAgB,gBAAgB,IAAI,SAAS,EAAE,CAQ9C;AAED,wBAAgB,gBAAgB,IAAI,SAAS,EAAE,CAE9C"}

package/esm/extensions/ext-content-mdx/src/plugins/plugin-loader.js

@@ -0,0 +1,18 @@
+import rehypeHighlight from "rehype-highlight";
+import rehypeSlug from "rehype-slug";
+import remarkFrontmatter from "remark-frontmatter";
+import remarkGfm from "remark-gfm";
+import { remarkMdxHeadings } from "./remark-headings.js";
+import { remarkCodeBlocks, remarkMdxRemoveParagraphs } from "./remark-mdx-utils.js";
+export function getRemarkPlugins() {
+    return [
+        remarkGfm,
+        remarkFrontmatter,
+        remarkMdxHeadings,
+        remarkMdxRemoveParagraphs,
+        remarkCodeBlocks,
+    ];
+}
+export function getRehypePlugins() {
+    return [rehypeHighlight, rehypeSlug];
+}

package/esm/extensions/ext-content-mdx/src/plugins/rehype-node-positions.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Rehype plugin that injects source location attributes on every element.
+ *
+ * Handles both:
+ *   - HTML elements from markdown (h1, p, li, …)
+ *   - MDX JSX nodes (mdxJsxFlowElement, mdxJsxTextElement)
+ *
+ * Injected attributes:
+ *   data-node-file   — project-relative source file path
+ *   data-node-name   — element or component name
+ *   data-node-line   — source line number
+ *   data-node-column — source column number (0-based)
+ */
+import type { Root } from "@types/hast";
+interface RehypeNodePositionsOptions {
+    filePath?: string;
+}
+export declare function rehypeNodePositions(options?: RehypeNodePositionsOptions): (tree: Root) => void;
+export {};
+//# sourceMappingURL=rehype-node-positions.d.ts.map

package/esm/extensions/ext-content-mdx/src/plugins/rehype-node-positions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rehype-node-positions.d.ts","sourceRoot":"","sources":["../../../../../src/extensions/ext-content-mdx/src/plugins/rehype-node-positions.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,KAAK,EAAW,IAAI,EAAE,MAAM,aAAa,CAAC;AAGjD,UAAU,0BAA0B;IAClC,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AASD,wBAAgB,mBAAmB,CACjC,OAAO,GAAE,0BAA+B,GACvC,CAAC,IAAI,EAAE,IAAI,KAAK,IAAI,CAoCtB"}

package/esm/extensions/ext-content-mdx/src/plugins/rehype-node-positions.js

@@ -0,0 +1,45 @@
+/**
+ * Rehype plugin that injects source location attributes on every element.
+ *
+ * Handles both:
+ *   - HTML elements from markdown (h1, p, li, …)
+ *   - MDX JSX nodes (mdxJsxFlowElement, mdxJsxTextElement)
+ *
+ * Injected attributes:
+ *   data-node-file   — project-relative source file path
+ *   data-node-name   — element or component name
+ *   data-node-line   — source line number
+ *   data-node-column — source column number (0-based)
+ */
+import { visit } from "unist-util-visit";
+export function rehypeNodePositions(options = {}) {
+    return function transform(tree) {
+        visit(tree, (node) => {
+            if (node.type === "element") {
+                const el = node;
+                if (!el.position)
+                    return;
+                const props = el.properties ?? (el.properties = {});
+                const { start } = el.position;
+                if (options.filePath)
+                    props["data-node-file"] = options.filePath;
+                props["data-node-name"] = el.tagName;
+                props["data-node-line"] = String(start.line);
+                props["data-node-column"] = String(start.column - 1);
+                props["data-node-source"] = "md";
+                return;
+            }
+            if (node.type !== "mdxJsxFlowElement" && node.type !== "mdxJsxTextElement")
+                return;
+            const mdx = node;
+            if (!mdx.position)
+                return;
+            const attrs = mdx.attributes ?? (mdx.attributes = []);
+            const { start } = mdx.position;
+            if (options.filePath) {
+                attrs.push({ type: "mdxJsxAttribute", name: "data-node-file", value: options.filePath });
+            }
+            attrs.push({ type: "mdxJsxAttribute", name: "data-node-name", value: mdx.name || "unknown" }, { type: "mdxJsxAttribute", name: "data-node-line", value: String(start.line) }, { type: "mdxJsxAttribute", name: "data-node-column", value: String(start.column - 1) });
+        });
+    };
+}

package/esm/extensions/ext-content-mdx/src/plugins/remark-headings.d.ts

@@ -0,0 +1,4 @@
+import type { Root } from "@types/mdast";
+import type { VFile } from "vfile";
+export declare function remarkMdxHeadings(): (tree: Root, file: VFile) => void;
+//# sourceMappingURL=remark-headings.d.ts.map

package/esm/extensions/ext-content-mdx/src/plugins/remark-headings.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"remark-headings.d.ts","sourceRoot":"","sources":["../../../../../src/extensions/ext-content-mdx/src/plugins/remark-headings.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAW,IAAI,EAAE,MAAM,cAAc,CAAC;AAGlD,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,OAAO,CAAC;AA0BnC,wBAAgB,iBAAiB,IAAI,CAAC,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,KAAK,KAAK,IAAI,CA8DrE"}

package/esm/extensions/ext-content-mdx/src/plugins/remark-headings.js

@@ -0,0 +1,69 @@
+import GithubSlugger from "github-slugger";
+import { toString } from "mdast-util-to-string";
+import { visit } from "unist-util-visit";
+function createHeadingProperty(name, value) {
+    return {
+        type: "Property",
+        key: { type: "Identifier", name },
+        value: { type: "Literal", value },
+        kind: "init",
+        method: false,
+        shorthand: false,
+        computed: false,
+    };
+}
+export function remarkMdxHeadings() {
+    const slugger = new GithubSlugger();
+    return (tree, file) => {
+        const headings = [];
+        slugger.reset();
+        visit(tree, "heading", (node) => {
+            const text = toString(node);
+            const id = slugger.slug(text);
+            node.data ??= {};
+            node.data.hProperties ??= {};
+            node.data.hProperties.id = id;
+            headings.push({ text, id, level: node.depth });
+        });
+        file.data.headings = headings;
+        const headingsExport = {
+            type: "mdxjsEsm",
+            value: "",
+            data: {
+                estree: {
+                    type: "Program",
+                    sourceType: "module",
+                    body: [
+                        {
+                            type: "ExportNamedDeclaration",
+                            specifiers: [],
+                            source: null,
+                            declaration: {
+                                type: "VariableDeclaration",
+                                kind: "const",
+                                declarations: [
+                                    {
+                                        type: "VariableDeclarator",
+                                        id: { type: "Identifier", name: "headings" },
+                                        init: {
+                                            type: "ArrayExpression",
+                                            elements: headings.map((h) => ({
+                                                type: "ObjectExpression",
+                                                properties: [
+                                                    createHeadingProperty("text", h.text),
+                                                    createHeadingProperty("id", h.id),
+                                                    createHeadingProperty("level", h.level),
+                                                ],
+                                            })),
+                                        },
+                                    },
+                                ],
+                            },
+                        },
+                    ],
+                },
+            },
+        };
+        tree.children.unshift(headingsExport);
+    };
+}

package/esm/extensions/ext-content-mdx/src/plugins/remark-mdx-utils.d.ts

@@ -0,0 +1,14 @@
+import type { Root } from "@types/mdast";
+import type { VFile } from "vfile";
+/**
+ * Removes unnecessary <p> elements from MDX content.
+ *
+ * Handles edge cases where <p> elements get incorrectly nested inside JSX components:
+ * - `<Button><p>text</p></Button>` → `<Button>text</Button>`
+ * - Inline parents: `<span><p>text</p></span>` → `<span>text</span>`
+ * - Multiple children with mixed content
+ */
+export declare function remarkMdxRemoveParagraphs(): (tree: Root) => void;
+export declare function remarkCodeBlocks(): (tree: Root) => void;
+export declare function remarkMdxImports(): (tree: Root, file: VFile) => void;
+//# sourceMappingURL=remark-mdx-utils.d.ts.map

package/esm/extensions/ext-content-mdx/src/plugins/remark-mdx-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"remark-mdx-utils.d.ts","sourceRoot":"","sources":["../../../../../src/extensions/ext-content-mdx/src/plugins/remark-mdx-utils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAmB,IAAI,EAAE,MAAM,cAAc,CAAC;AAE1D,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,OAAO,CAAC;AAoGnC;;;;;;;GAOG;AACH,wBAAgB,yBAAyB,IAAI,CAAC,IAAI,EAAE,IAAI,KAAK,IAAI,CA6EhE;AAYD,wBAAgB,gBAAgB,IAAI,CAAC,IAAI,EAAE,IAAI,KAAK,IAAI,CAmBvD;AAQD,wBAAgB,gBAAgB,IAAI,CAAC,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,KAAK,KAAK,IAAI,CAmBpE"}

package/esm/extensions/ext-content-mdx/src/plugins/remark-mdx-utils.js

@@ -0,0 +1,191 @@
+import { CONTINUE, SKIP, visit } from "unist-util-visit";
+/**
+ * Spacer node to preserve whitespace when unwrapping paragraphs
+ */
+const spacer = {
+    type: "mdxFlowExpression",
+    value: "' '",
+    data: {
+        estree: {
+            type: "Program",
+            body: [
+                {
+                    type: "ExpressionStatement",
+                    expression: {
+                        type: "Literal",
+                        value: " ",
+                        raw: "' '",
+                    },
+                },
+            ],
+            sourceType: "module",
+        },
+    },
+};
+// Replace node at index with multiple children nodes
+// Reference: https://github.com/mdx-js/mdx/issues/1451#issuecomment-780428572
+function mergeChildren(node, index, children) {
+    node.children?.splice(index, 1, ...children);
+}
+const textNodeTypes = new Set([
+    "text",
+    "paragraph",
+    "heading",
+    "link",
+    "image",
+    "list",
+    "listItem",
+    "emphasis",
+    "strong",
+    "blockquote",
+    "code",
+    "inlineCode",
+    "thematicBreak",
+    "table",
+    "tableRow",
+    "tableCell",
+    "footnote",
+    "footnoteDefinition",
+]);
+const validParentBlockElements = new Set([
+    "address",
+    "article",
+    "aside",
+    "blockquote",
+    "details",
+    "dialog",
+    "canvas",
+    "dl",
+    "dt",
+    "dd",
+    "div",
+    "fieldset",
+    "figcaption",
+    "figure",
+    "footer",
+    "form",
+    "header",
+    "hgroup",
+    "main",
+    "nav",
+    "pre",
+    "section",
+    "video",
+]);
+function isJsxComponentName(name = "") {
+    // Check if name starts with a capital letter (JSX component, not HTML element)
+    return name.match(/^[A-Z]/);
+}
+/**
+ * Removes unnecessary <p> elements from MDX content.
+ *
+ * Handles edge cases where <p> elements get incorrectly nested inside JSX components:
+ * - `<Button><p>text</p></Button>` → `<Button>text</Button>`
+ * - Inline parents: `<span><p>text</p></span>` → `<span>text</span>`
+ * - Multiple children with mixed content
+ */
+export function remarkMdxRemoveParagraphs() {
+    return function transformer(tree) {
+        // First pass: add spacers between elements when parent has non-text children
+        visit(tree, "paragraph", (_node, _index, parent) => {
+            const extParent = parent;
+            if (!extParent)
+                return CONTINUE;
+            const parentName = extParent.name ?? extParent.type ?? extParent.tagName;
+            if (parentName === "root")
+                return CONTINUE;
+            const hasNonTextChild = extParent.children?.some((child) => !textNodeTypes.has(child.type));
+            if (!hasNonTextChild)
+                return CONTINUE;
+            if (extParent.children.some((c) => c.isMdxTextSpacer))
+                return CONTINUE;
+            const children = [];
+            extParent.children.forEach((child, i) => {
+                if (i > 0) {
+                    children.push({ ...spacer, isMdxTextSpacer: true });
+                }
+                children.push(child);
+            });
+            extParent.children = children;
+            return CONTINUE;
+        });
+        // Second pass: unwrap paragraphs
+        visit(tree, "paragraph", (node, index, parent) => {
+            const extParent = parent;
+            if (!extParent)
+                return CONTINUE;
+            const paragraphNode = node;
+            const parentName = extParent.name ?? extParent.type ?? extParent.tagName;
+            const idx = typeof index === "number" ? index : -1;
+            const previousChild = idx >= 0 ? extParent.children[idx - 1] : undefined;
+            // Unwrap <p> elements when they appear inside a direct <p> parent
+            if (parentName === "p" && idx >= 0) {
+                const child = paragraphNode.children?.[0];
+                if (child)
+                    extParent.children[idx] = child;
+                return [SKIP, idx];
+            }
+            // Keep behavior consistent between children
+            if (previousChild?.type === "paragraph")
+                return CONTINUE;
+            if (parentName === "root")
+                return CONTINUE;
+            const hasNonTextChild = extParent.children.some((child) => !textNodeTypes.has(child.type));
+            if (hasNonTextChild && idx >= 0) {
+                // Unwrap <p> elements when child contains other children besides text
+                mergeChildren(extParent, idx, paragraphNode.children);
+                return [SKIP, idx];
+            }
+            // Unwrap <p> elements with single text child elements
+            // e.g. <Button><p>Do not wrap</p></Button> => <Button>Do not wrap</Button>
+            if (extParent.children.length === 1) {
+                extParent.children = paragraphNode.children;
+                return [SKIP, idx >= 0 ? idx : 0];
+            }
+            const isElementParent = !isJsxComponentName(parentName);
+            const isInlineParent = !validParentBlockElements.has(parentName ?? "");
+            // Unwrap <p> elements which are children of inline elements
+            // e.g. <span><p>Do not wrap</p></span> => <span>Do not wrap</span>
+            if (isElementParent && isInlineParent && idx >= 0) {
+                const child = paragraphNode.children?.[0];
+                if (child)
+                    extParent.children[idx] = child;
+            }
+            return CONTINUE;
+        });
+    };
+}
+export function remarkCodeBlocks() {
+    return function transformer(tree) {
+        visit(tree, "code", (node) => {
+            const codeNode = node;
+            codeNode.data ??= {};
+            codeNode.data.hProperties ??= {};
+            if (codeNode.lang) {
+                codeNode.data.hProperties.className = [`language-${codeNode.lang}`];
+            }
+            if (!codeNode.meta)
+                return;
+            const highlightMatch = codeNode.meta.match(/\{([\d,-]+)\}/);
+            if (highlightMatch) {
+                codeNode.data.hProperties["data-line-numbers"] = highlightMatch[1];
+            }
+        });
+    };
+}
+export function remarkMdxImports() {
+    return function transformer(tree, file) {
+        const imports = [];
+        visit(tree, "mdxjsEsm", (node) => {
+            if (!node.value?.includes("import"))
+                return;
+            const importMatches = node.value.matchAll(/import\s+(?:(?:\{[^}]*\}|\*\s+as\s+\w+|\w+)\s+from\s+)?['"]([^'"]+)['"]/g);
+            for (const match of importMatches) {
+                const path = match[1];
+                if (typeof path === "string")
+                    imports.push(path);
+            }
+        });
+        file.data.imports = imports;
+    };
+}

package/esm/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "module"
+}

package/esm/src/config/defaults.d.ts

@@ -0,0 +1,39 @@
+import { DEFAULT_PORT } from "../platform/compat/constants.js";
+export { DEFAULT_PORT };
+export declare const DEFAULT_TIMEOUT_MS = 5000;
+export declare const SSR_TIMEOUT_MS = 10000;
+export declare const SANDBOX_TIMEOUT_MS = 5000;
+/** Timeout for user data fetching functions (getServerData, getStaticData) */
+export declare const DATA_FETCH_TIMEOUT_MS = 10000;
+export declare const DEFAULT_CACHE_MAX_SIZE = 100;
+export declare const DURATION_HISTOGRAM_BOUNDARIES_MS: readonly [5, 10, 25, 50, 75, 100, 250, 500, 750, 1000, 2500, 5000, 7500, 10000];
+export declare const SIZE_HISTOGRAM_BOUNDARIES_KB: readonly [1, 5, 10, 25, 50, 100, 250, 500, 1000, 2500, 5000, 10000];
+export declare const defaultConfig: {
+    readonly server: {
+        readonly port: 3000;
+        readonly hostname: "0.0.0.0";
+    };
+    readonly timeouts: {
+        readonly default: 5000;
+        readonly api: 30000;
+        readonly ssr: 10000;
+        readonly hmr: 30000;
+        readonly sandbox: 5000;
+    };
+    readonly cache: {
+        readonly jit: {
+            readonly maxSize: 100;
+            readonly tempDirPrefix: "vf-bundle-";
+        };
+    };
+    readonly metrics: {
+        readonly ssrBoundaries: readonly [5, 10, 25, 50, 75, 100, 250, 500, 750, 1000, 2500, 5000, 7500, 10000];
+    };
+};
+export declare const DEFAULT_PREFETCH_DELAY_MS = 100;
+export declare const DEFAULT_METRICS_COLLECT_INTERVAL_MS = 60000;
+export declare const DEFAULT_REDIS_SCAN_COUNT = 100;
+export declare const DEFAULT_REDIS_BATCH_DELETE_SIZE = 1000;
+export declare const PAGE_TRANSITION_DELAY_MS = 150;
+export type DefaultConfig = typeof defaultConfig;
+//# sourceMappingURL=defaults.d.ts.map

package/esm/src/config/defaults.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"defaults.d.ts","sourceRoot":"","sources":["../../../src/src/config/defaults.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,iCAAiC,CAAC;AAC/D,OAAO,EAAE,YAAY,EAAE,CAAC;AACxB,eAAO,MAAM,kBAAkB,OAAO,CAAC;AACvC,eAAO,MAAM,cAAc,QAAQ,CAAC;AACpC,eAAO,MAAM,kBAAkB,OAAO,CAAC;AAEvC,8EAA8E;AAC9E,eAAO,MAAM,qBAAqB,QAAQ,CAAC;AAE3C,eAAO,MAAM,sBAAsB,MAAM,CAAC;AAE1C,eAAO,MAAM,gCAAgC,iFAenC,CAAC;AAEX,eAAO,MAAM,4BAA4B,qEAa/B,CAAC;AAEX,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;CAqBhB,CAAC;AAEX,eAAO,MAAM,yBAAyB,MAAM,CAAC;AAC7C,eAAO,MAAM,mCAAmC,QAAQ,CAAC;AACzD,eAAO,MAAM,wBAAwB,MAAM,CAAC;AAC5C,eAAO,MAAM,+BAA+B,OAAO,CAAC;AACpD,eAAO,MAAM,wBAAwB,MAAM,CAAC;AAE5C,MAAM,MAAM,aAAa,GAAG,OAAO,aAAa,CAAC"}

package/esm/src/config/defaults.js

@@ -0,0 +1,65 @@
+import { DEFAULT_PORT } from "../platform/compat/constants.js";
+export { DEFAULT_PORT };
+export const DEFAULT_TIMEOUT_MS = 5000;
+export const SSR_TIMEOUT_MS = 10000;
+export const SANDBOX_TIMEOUT_MS = 5000;
+/** Timeout for user data fetching functions (getServerData, getStaticData) */
+export const DATA_FETCH_TIMEOUT_MS = 10000;
+export const DEFAULT_CACHE_MAX_SIZE = 100;
+export const DURATION_HISTOGRAM_BOUNDARIES_MS = [
+    5,
+    10,
+    25,
+    50,
+    75,
+    100,
+    250,
+    500,
+    750,
+    1000,
+    2500,
+    5000,
+    7500,
+    10000,
+];
+export const SIZE_HISTOGRAM_BOUNDARIES_KB = [
+    1,
+    5,
+    10,
+    25,
+    50,
+    100,
+    250,
+    500,
+    1000,
+    2500,
+    5000,
+    10000,
+];
+export const defaultConfig = {
+    server: {
+        port: DEFAULT_PORT,
+        hostname: "0.0.0.0",
+    },
+    timeouts: {
+        default: DEFAULT_TIMEOUT_MS,
+        api: 30000,
+        ssr: SSR_TIMEOUT_MS,
+        hmr: 30000,
+        sandbox: SANDBOX_TIMEOUT_MS,
+    },
+    cache: {
+        jit: {
+            maxSize: DEFAULT_CACHE_MAX_SIZE,
+            tempDirPrefix: "vf-bundle-",
+        },
+    },
+    metrics: {
+        ssrBoundaries: DURATION_HISTOGRAM_BOUNDARIES_MS,
+    },
+};
+export const DEFAULT_PREFETCH_DELAY_MS = 100;
+export const DEFAULT_METRICS_COLLECT_INTERVAL_MS = 60000;
+export const DEFAULT_REDIS_SCAN_COUNT = 100;
+export const DEFAULT_REDIS_BATCH_DELETE_SIZE = 1000;
+export const PAGE_TRANSITION_DELAY_MS = 150;