markstream-solid 0.0.0-stage → 2.0.23

package/dist/components/shared/node-helpers.d.ts

@@ -0,0 +1,78 @@
+import type { BaseNode, HtmlPolicy, MarkdownIt, ParsedNode, ParseOptions } from 'stream-markdown-parser';
+import type { CustomComponentMap, HtmlComponentMap } from '../../customComponents';
+import type { CodeBlockOptions, CodeBlockPreviewPayload, CodeBlockTheme, CodeBlockThemes, D2BlockNodeProps, InfographicBlockNodeProps, MermaidBlockNodeProps } from '../../types/component-props';
+import type { NodeRendererCodeBlockProps, NodeRendererProps, NodeRendererTypewriter } from '../../types/node-renderer-props';
+import { getHtmlTagFromContent, hasCompleteHtmlTagContent, normalizeCustomHtmlTags, normalizeCustomHtmlTagName as normalizeTagName, stripCustomHtmlWrapper } from 'stream-markdown-parser';
+export { getHtmlTagFromContent, hasCompleteHtmlTagContent, normalizeCustomHtmlTags, normalizeTagName, stripCustomHtmlWrapper, };
+export type SolidRenderableNode = (ParsedNode | BaseNode) & Record<string, any>;
+export type { CodeBlockPreviewPayload } from '../../types/component-props';
+export type { NodeRendererCodeBlockProps, NodeRendererMode, NodeRendererProps } from '../../types/node-renderer-props';
+export type NodeRendererMermaidProps = Partial<Omit<MermaidBlockNodeProps, 'node'>>;
+export type NodeRendererD2Props = Partial<Omit<D2BlockNodeProps, 'node'>>;
+export type NodeRendererInfographicProps = Partial<Omit<InfographicBlockNodeProps, 'node'>>;
+export interface NodeRendererEvents {
+    onCopy?: (code: string) => void;
+    onHandleArtifactClick?: (payload: CodeBlockPreviewPayload) => void;
+}
+export interface SolidRenderContext {
+    viewportPriority?: boolean;
+    viewportPriorityOptions?: NodeRendererProps['viewportPriorityOptions'];
+    htmlComponents?: HtmlComponentMap;
+    customId?: string;
+    isDark?: boolean;
+    indexKey?: string;
+    final?: boolean;
+    typewriter?: NodeRendererTypewriter;
+    fade?: boolean;
+    textStreamState?: Map<string, string>;
+    streamRenderVersion?: number;
+    showTooltips?: boolean;
+    codeBlockStream?: boolean;
+    renderCodeBlocksAsPre?: boolean;
+    allowHtml?: boolean;
+    htmlPolicy?: HtmlPolicy;
+    customHtmlTags?: readonly string[];
+    parseOptions?: ParseOptions;
+    customMarkdownIt?: (md: MarkdownIt) => MarkdownIt;
+    codeBlockOptions?: CodeBlockOptions;
+    codeBlockProps?: NodeRendererCodeBlockProps;
+    mermaidProps?: NodeRendererMermaidProps;
+    d2Props?: NodeRendererD2Props;
+    infographicProps?: NodeRendererInfographicProps;
+    customComponents?: CustomComponentMap;
+    codeBlockThemes?: {
+        themes?: CodeBlockThemes;
+        darkTheme?: CodeBlockTheme;
+        lightTheme?: CodeBlockTheme;
+        minWidth?: string | number;
+        maxWidth?: string | number;
+    };
+    events: NodeRendererEvents;
+}
+export declare const BLOCK_LEVEL_TYPES: Set<string>;
+export declare function buildRenderContext(props: NodeRendererProps, events?: NodeRendererEvents, textStreamState?: Map<string, string>, streamRenderVersion?: number): SolidRenderContext;
+export declare function resolveParsedNodes(props: NodeRendererProps): SolidRenderableNode[];
+export declare function getNodeList(value: unknown): SolidRenderableNode[];
+export declare function isWhitespaceTextNode(node: SolidRenderableNode | null | undefined): boolean;
+export declare function getMeaningfulLinkChildren(node: SolidRenderableNode | null | undefined): SolidRenderableNode[];
+export declare function isImageOnlyLinkNode(node: SolidRenderableNode | null | undefined): boolean;
+export declare function isMediaOnlyParagraphNodes(children: readonly SolidRenderableNode[]): boolean;
+export declare function normalizeMediaOnlyParagraphNodes(children: readonly SolidRenderableNode[]): SolidRenderableNode[];
+export declare function getString(value: unknown): string;
+export declare function isSafeAttrName(value: string): boolean;
+export declare function escapeHtml(value: unknown): string;
+export declare function escapeAttr(value: unknown): string;
+export declare function sanitizeClassToken(value: string): string;
+export declare function clampHeadingLevel(value: unknown): number;
+export declare function capitalize(value: string): string;
+export declare function normalizeCodeLanguage(raw: unknown): string;
+export declare function resolveCodeBlockLanguage(node: SolidRenderableNode): string;
+export declare function encodeDataPayload(value: string): any;
+export declare function normalizeTokenAttrs(attrs?: Array<[string, string | null]> | null): Record<string, string | true> | null;
+export declare function splitParagraphChildren(children: readonly SolidRenderableNode[], getDisplay?: (node: SolidRenderableNode) => 'inline' | 'block' | undefined): ({
+    kind: "inline";
+    nodes: SolidRenderableNode[];
+} | {
+    kind: "block";
+    node: SolidRenderableNode;
+})[];

package/dist/components/shared/node-outlet-helpers.d.ts

@@ -0,0 +1,10 @@
+import type { SolidRenderableNode, SolidRenderContext } from './node-helpers';
+export type CodeBlockMode = 'mermaid' | 'd2' | 'infographic' | 'pre' | 'code';
+export declare function resolveNodeOutletCodeMode(node: SolidRenderableNode, context?: SolidRenderContext): CodeBlockMode;
+export declare function resolveHtmlTag(node: SolidRenderableNode): string;
+export declare function coerceCustomHtmlNode(node: SolidRenderableNode): SolidRenderableNode;
+export declare function coerceBuiltinHtmlNode(node: SolidRenderableNode, resolvedType: string): SolidRenderableNode;
+export declare function resolveNodeOutletCustomInputs(node: SolidRenderableNode, context?: SolidRenderContext): Partial<Omit<import("../..").D2BlockNodeProps, "node">> | {
+    [x: string]: any;
+} | null;
+export declare function resolveNodeOutletCustomComponent(node: SolidRenderableNode, context?: SolidRenderContext, customComponents?: Record<string, any> | null): any;

package/dist/components/shared/render-window.d.ts

@@ -0,0 +1,18 @@
+export declare const DEFAULT_NODE_HEIGHT = 32;
+export declare const MAX_DEFERRED_NODE_COUNT = 900;
+export interface LiveRange {
+    start: number;
+    end: number;
+}
+export interface DeferNodesOptions {
+    deferNodesUntilVisible?: boolean;
+    maxLiveNodes?: number;
+    parsedNodeCount: number;
+    viewportPriority?: boolean;
+    virtualizationEnabled: boolean;
+}
+export declare function resolveVirtualizationEnabled(parsedNodeCount: number, maxLiveNodes?: number): boolean;
+export declare function resolveDeferNodes(options: DeferNodesOptions): boolean;
+export declare function resolveAverageNodeHeight(nodeHeights: ReadonlyMap<number, number>, fallback?: number): number;
+export declare function estimateHeightRange(start: number, end: number, nodeHeights: ReadonlyMap<number, number>, averageNodeHeight: number): number;
+export declare function computeLiveRange(total: number, focusIndex: number, maxLiveNodes?: number, liveNodeBuffer?: number): LiveRange;

package/dist/components/shared/reuseParsedNodes.d.ts

@@ -0,0 +1,3 @@
+import type { SolidRenderableNode } from './node-helpers';
+export declare function sameParserValue(previous: unknown, next: unknown, seen?: WeakMap<object, object>): boolean;
+export declare function reuseParsedNodes(previous: readonly SolidRenderableNode[] | undefined, next: SolidRenderableNode[]): SolidRenderableNode[];

package/dist/components/viewport.d.ts

@@ -0,0 +1,5 @@
+import type { Accessor } from 'solid-js';
+import type { SolidRenderContext } from './shared/node-helpers';
+export declare function useHeavyNodeVisibility(props: {
+    context?: SolidRenderContext;
+}, element: Accessor<Element | undefined>): Accessor<boolean>;

package/dist/components/virtualLayoutKey.d.ts

@@ -0,0 +1,13 @@
+import type { NodeRendererProps } from '../types/node-renderer-props';
+export interface VirtualRendererLayoutKeyOptions {
+    renderCodeBlocksAsPre: boolean;
+    isDark?: boolean;
+    codeBlockStream?: boolean;
+    codeBlockMinWidth?: NodeRendererProps['codeBlockMinWidth'];
+    codeBlockMaxWidth?: NodeRendererProps['codeBlockMaxWidth'];
+    codeBlockOptions?: NodeRendererProps['codeBlockOptions'];
+    codeBlockProps?: NodeRendererProps['codeBlockProps'];
+}
+export declare function stringifyVirtualToken(value: unknown): string;
+export declare function buildVirtualRendererLayoutKey(options: VirtualRendererLayoutKeyOptions): string;
+export declare function buildVirtualMeasurementKey(hostMeasurementKey: string | number | null | undefined, rendererLayoutKey: string): string;

package/dist/configuration.d.ts

@@ -0,0 +1,9 @@
+import type { Accessor } from 'solid-js';
+import type { CustomComponentMap } from './customComponents';
+import type { LanguageIconResolver } from './utils/languageIcon';
+export interface MarkstreamSolidOptions {
+    components?: CustomComponentMap;
+    defaultI18nMap?: Partial<Record<string, string>>;
+    languageIconResolver?: LanguageIconResolver | null;
+}
+export declare const MarkstreamConfigContext: import("solid-js").Context<Accessor<MarkstreamSolidOptions>>;

package/dist/customComponents.d.ts

@@ -0,0 +1,36 @@
+import type { Component, JSX } from 'solid-js';
+import type { SolidRenderableNode, SolidRenderContext } from './components/shared/node-helpers';
+import type { CodeBlockOptions, CodeBlockPreviewPayload } from './types/component-props';
+export interface NodeComponentProps<TNode = SolidRenderableNode> {
+    node: TNode;
+    context?: SolidRenderContext;
+    ctx?: SolidRenderContext;
+    showTooltips?: boolean;
+    codeBlockOptions?: CodeBlockOptions;
+    onCopy?: (payload: any) => void;
+    onHandleArtifactClick?: (payload: CodeBlockPreviewPayload) => void;
+    indexKey?: string | number;
+    isDark?: boolean;
+    customId?: string;
+    typewriter?: boolean | 'simple' | 'precise';
+    fade?: boolean;
+}
+export type CustomComponentMap = Record<string, Component<NodeComponentProps<any>>>;
+export type StreamingComponent<TNode = SolidRenderableNode> = Component<NodeComponentProps<TNode>>;
+export type StreamingComponentMap = Record<string, StreamingComponent<any>>;
+export type HtmlComponent<P = Record<string, unknown>> = Component<P & {
+    children?: JSX.Element;
+}>;
+export type HtmlComponentMap = Record<string, HtmlComponent<any>>;
+export type CustomComponentDisplayMode = 'inline' | 'block';
+export declare function defineStreamingComponents<T extends StreamingComponentMap>(components: T): T;
+export declare function defineHtmlComponents<T extends HtmlComponentMap>(components: T): T;
+export declare function withMarkstreamComponentDisplay<T extends Component<any>>(component: T, display: CustomComponentDisplayMode): T & {
+    markstreamDisplay: CustomComponentDisplayMode;
+};
+export declare function getCustomComponentDisplay(component?: Component<any> | null): CustomComponentDisplayMode | undefined;
+export declare function setCustomComponents(mapping: CustomComponentMap): void;
+export declare function setCustomComponents(id: string, mapping: CustomComponentMap): void;
+export declare function getCustomNodeComponents(id?: string): CustomComponentMap;
+export declare function removeCustomComponents(id: string): void;
+export declare function clearGlobalCustomComponents(): void;

package/dist/enhanceRenderedHtml.d.ts

@@ -0,0 +1,25 @@
+import type { NodeRendererCodeBlockProps, NodeRendererD2Props, NodeRendererInfographicProps, NodeRendererMermaidProps } from './components/shared/node-helpers';
+import type { CodeBlockOptions, CodeBlockTheme, CodeBlockThemes } from './types/component-props';
+export interface EnhanceRenderedHtmlOptions {
+    final?: boolean;
+    isDark?: boolean;
+    renderCodeBlocksAsPre?: boolean;
+    d2ThemeId?: number | null;
+    d2DarkThemeId?: number | null;
+    showTooltips?: boolean;
+    codeBlockOptions?: CodeBlockOptions;
+    codeBlockProps?: NodeRendererCodeBlockProps;
+    codeBlockDarkTheme?: CodeBlockTheme;
+    codeBlockLightTheme?: CodeBlockTheme;
+    themes?: CodeBlockThemes;
+    mermaidProps?: NodeRendererMermaidProps;
+    d2Props?: NodeRendererD2Props;
+    infographicProps?: NodeRendererInfographicProps;
+    onCopy?: (code: string) => void;
+    isCancelled?: () => boolean;
+}
+export interface RenderedHtmlEnhancementHandle {
+    dispose: () => void;
+}
+export declare function enhanceRenderedHtml(root: HTMLElement, options?: EnhanceRenderedHtmlOptions): Promise<RenderedHtmlEnhancementHandle>;
+export declare function disposeRenderedHtmlEnhancements(root: HTMLElement | null | undefined): void;

package/dist/hydrateCustomTagContent.d.ts

@@ -0,0 +1,2 @@
+import type { BaseNode } from 'stream-markdown-parser';
+export declare function hydrateCustomTagContent<T extends BaseNode>(nodes: readonly T[] | null | undefined, source: string, customHtmlTags?: readonly string[]): T[];

package/dist/i18n/useSafeI18n.d.ts

@@ -0,0 +1,4 @@
+export declare function setDefaultI18nMap(map: Partial<Record<string, string>>): void;
+export declare function useSafeI18n(): {
+    t(key: string): string;
+};

package/dist/icon-themes/index.d.ts

@@ -0,0 +1,2 @@
+export { getRegisteredThemes, registerIconTheme, setIconTheme } from './registry';
+export type { IconTheme, LanguageIconMap } from './types';

package/dist/icon-themes/material/core.d.ts

@@ -0,0 +1,2 @@
+import type { LanguageIconMap } from '../types';
+export declare const materialCoreMap: LanguageIconMap;

package/dist/icon-themes/material/extended.d.ts

@@ -0,0 +1,2 @@
+import type { LanguageIconMap } from '../types';
+export declare const materialExtendedMap: LanguageIconMap;

package/dist/icon-themes/material/index.d.ts

@@ -0,0 +1,2 @@
+import type { IconTheme } from '../types';
+export declare const materialIconTheme: IconTheme;

package/dist/icon-themes/registry.d.ts

@@ -0,0 +1,9 @@
+import type { IconTheme } from './types';
+export declare function _setRevisionBumper(fn: () => void): void;
+export declare function registerIconTheme(theme: IconTheme): void;
+export declare function setIconTheme(id: string): void;
+export declare function getActiveTheme(): IconTheme | undefined;
+export declare function getRegisteredThemes(): string[];
+export declare function resolveFromTheme(normalized: string): string | undefined;
+export declare function getThemeFallback(): string;
+export declare function preloadActiveThemeExtended(): Promise<void>;

package/dist/icon-themes/types.d.ts

@@ -0,0 +1,11 @@
+export type LanguageIconMap = Record<string, string>;
+export interface IconTheme {
+    /** Unique identifier, e.g. 'default', 'material' */
+    readonly id: string;
+    /** Core icons — statically imported, always available */
+    readonly core: LanguageIconMap;
+    /** Default/fallback icon SVG string */
+    readonly fallback: string;
+    /** Lazy loader for extended icons. Called at most once; result is cached. */
+    loadExtended?: () => Promise<LanguageIconMap>;
+}