@regmisatyam/retex 0.1.0

package/dist/react-v8gyKEAs.d.cts

@@ -0,0 +1,420 @@
+/**
+ * Source-location primitives shared by every stage of the compiler.
+ *
+ * Every token and AST node carries a {@link SourceRange} so that diagnostics,
+ * editor tooling (hover, completion, error underlines) and incremental
+ * re-parsing can map results back to the exact bytes in the original source.
+ */
+/** A single position in the source text. */
+interface Position {
+    /** Zero-based UTF-16 code-unit offset from the start of the document. */
+    offset: number;
+    /** One-based line number. */
+    line: number;
+    /** One-based column number. */
+    column: number;
+}
+/** A half-open `[start, end)` range in the source text. */
+interface SourceRange {
+    start: Position;
+    end: Position;
+}
+/** Convenience constructor for a {@link Position}. */
+declare function pos(offset: number, line: number, column: number): Position;
+/** Convenience constructor for a {@link SourceRange}. */
+declare function range(start: Position, end: Position): SourceRange;
+/** Merge two ranges into the smallest range that contains both. */
+declare function mergeRanges(a: SourceRange, b: SourceRange): SourceRange;
+/** Test whether an offset falls within a range (start inclusive, end inclusive). */
+declare function rangeContains(r: SourceRange, offset: number): boolean;
+
+/**
+ * The ReTeX Abstract Syntax Tree.
+ *
+ * Every node is a member of the {@link Node} discriminated union keyed on
+ * `type`. Nodes fall into three broad families:
+ *
+ *  - **Structural** — {@link DocumentNode}, {@link GroupNode}, {@link ParBreakNode}.
+ *  - **Inline / typography** — text, marks (bold/italic/…), links, icons.
+ *  - **Resume semantics** — sections, jobs, education, skills, contact fields.
+ *
+ * Unknown or plugin-provided commands are preserved as {@link CommandNode} so
+ * the tree is always a faithful, loss-less representation of the source and can
+ * be re-rendered by custom renderers.
+ */
+interface NodeBase {
+    type: string;
+    /** Source span this node was produced from. Synthetic nodes may omit it. */
+    range?: SourceRange;
+    /**
+     * Stable structural hash used by the incremental compiler / render cache.
+     * Populated lazily; never authored by hand.
+     */
+    hash?: string;
+}
+interface DocumentNode extends NodeBase {
+    type: "document";
+    children: Node[];
+}
+/** A literal run of text. */
+interface TextNode extends NodeBase {
+    type: "text";
+    value: string;
+}
+/** A paragraph break (one or more blank lines). */
+interface ParBreakNode extends NodeBase {
+    type: "parbreak";
+}
+/** An explicit line break (`\\` or `\newline`). */
+interface LineBreakNode extends NodeBase {
+    type: "linebreak";
+}
+/** A horizontal rule (`\hrule` / `\divider`). */
+interface RuleNode extends NodeBase {
+    type: "rule";
+}
+/** Spacing primitive (`\vspace{1em}` / `\hspace{...}`). */
+interface SpaceNode extends NodeBase {
+    type: "space";
+    axis: "horizontal" | "vertical";
+    size: string;
+}
+/** A bare `{ ... }` group. Mostly used to scope font switches. */
+interface GroupNode extends NodeBase {
+    type: "group";
+    children: Node[];
+}
+type MarkType = "bold" | "italic" | "underline" | "strike";
+/** Simple wrapping mark such as `\textbf{...}`. */
+interface MarkNode extends NodeBase {
+    type: MarkType;
+    children: Node[];
+}
+/** `\textcolor{#hex|name}{...}` */
+interface ColorNode extends NodeBase {
+    type: "color";
+    color: string;
+    children: Node[];
+}
+/** `\themecolor{primary}{...}` — color resolved from the active theme. */
+interface ThemeColorNode extends NodeBase {
+    type: "themecolor";
+    token: string;
+    children: Node[];
+}
+/** `\fontsize{14pt}{...}` */
+interface FontSizeNode extends NodeBase {
+    type: "fontsize";
+    size: string;
+    children: Node[];
+}
+/** `\fontfamily{Inter}{...}` */
+interface FontFamilyNode extends NodeBase {
+    type: "fontfamily";
+    family: string;
+    children: Node[];
+}
+/** Relative size switch: `\small`, `\large`, `\Large`, `\Huge`. */
+type FontScale = "small" | "normal" | "large" | "Large" | "Huge";
+interface FontScaleNode extends NodeBase {
+    type: "fontscale";
+    scale: FontScale;
+    /** Content the switch applies to (rest of the enclosing group). */
+    children: Node[];
+}
+/** `\href{url}{label}` */
+interface LinkNode extends NodeBase {
+    type: "link";
+    /** Sanitized, render-safe URL. */
+    href: string;
+    /** Original, unsanitized URL (kept for diagnostics / round-tripping). */
+    rawHref: string;
+    children: Node[];
+}
+/** `\url{url}` — renders the URL as its own label. */
+interface UrlNode extends NodeBase {
+    type: "url";
+    href: string;
+    rawHref: string;
+}
+/** `\icon{github}` */
+interface IconNode extends NodeBase {
+    type: "icon";
+    name: string;
+}
+interface SectionNode extends NodeBase {
+    type: "section";
+    title: string;
+    /** 1 = `\section`, 2 = `\subsection`. */
+    level: number;
+}
+type ListKind = "itemize" | "enumerate";
+interface ListNode extends NodeBase {
+    type: "list";
+    kind: ListKind;
+    items: ListItemNode[];
+}
+interface ListItemNode extends NodeBase {
+    type: "item";
+    children: Node[];
+}
+interface ColumnsNode extends NodeBase {
+    type: "columns";
+    columns: ColumnNode[];
+    /** Gap between columns, e.g. `"1.5rem"`. */
+    gap?: string;
+}
+interface ColumnNode extends NodeBase {
+    type: "column";
+    /** Width as authored (`"40%"`, `"200px"`, `"2fr"`). */
+    width: string;
+    children: Node[];
+}
+type ContactField = "name" | "title" | "email" | "phone" | "location" | "website";
+/** One of the single-value header commands (`\name`, `\email`, …). */
+interface ContactNode extends NodeBase {
+    type: "contact";
+    field: ContactField;
+    value: string;
+}
+/** Parsed `key=value` map preserving per-field source ranges. */
+interface FieldMap {
+    [key: string]: string;
+}
+/** `\job{title=…, company=…, …}{ body }` */
+interface JobNode extends NodeBase {
+    type: "job";
+    fields: FieldMap;
+    children: Node[];
+}
+/** `\education{school=…, degree=…, …}{ body? }` */
+interface EducationNode extends NodeBase {
+    type: "education";
+    fields: FieldMap;
+    children: Node[];
+}
+/** `\project{name=…, …}{ body? }` */
+interface ProjectNode extends NodeBase {
+    type: "project";
+    fields: FieldMap;
+    children: Node[];
+}
+/** `\skills{a, b, c}` */
+interface SkillsNode extends NodeBase {
+    type: "skills";
+    items: string[];
+}
+/** A parsed argument attached to a generic {@link CommandNode}. */
+interface ArgumentNode {
+    kind: "required" | "optional";
+    /** Parsed children for `content` arguments. */
+    children: Node[];
+    /** Raw text for `string`/verbatim arguments. */
+    raw?: string;
+    range?: SourceRange;
+}
+/**
+ * A command the core does not model natively — including every
+ * plugin-registered command and any unknown command encountered during
+ * lenient parsing. Keeps the tree loss-less.
+ */
+interface CommandNode extends NodeBase {
+    type: "command";
+    name: string;
+    args: ArgumentNode[];
+}
+/** A placeholder emitted during error recovery so rendering can continue. */
+interface ErrorNode extends NodeBase {
+    type: "error";
+    message: string;
+    /** The raw source that could not be parsed. */
+    raw: string;
+}
+type Node = DocumentNode | TextNode | ParBreakNode | LineBreakNode | RuleNode | SpaceNode | GroupNode | MarkNode | ColorNode | ThemeColorNode | FontSizeNode | FontFamilyNode | FontScaleNode | LinkNode | UrlNode | IconNode | SectionNode | ListNode | ListItemNode | ColumnsNode | ColumnNode | ContactNode | JobNode | EducationNode | ProjectNode | SkillsNode | CommandNode | ErrorNode;
+type NodeType = Node["type"];
+/** Map from node `type` to its concrete interface, for typed visitors. */
+interface NodeMap {
+    document: DocumentNode;
+    text: TextNode;
+    parbreak: ParBreakNode;
+    linebreak: LineBreakNode;
+    rule: RuleNode;
+    space: SpaceNode;
+    group: GroupNode;
+    bold: MarkNode;
+    italic: MarkNode;
+    underline: MarkNode;
+    strike: MarkNode;
+    color: ColorNode;
+    themecolor: ThemeColorNode;
+    fontsize: FontSizeNode;
+    fontfamily: FontFamilyNode;
+    fontscale: FontScaleNode;
+    link: LinkNode;
+    url: UrlNode;
+    icon: IconNode;
+    section: SectionNode;
+    list: ListNode;
+    item: ListItemNode;
+    columns: ColumnsNode;
+    column: ColumnNode;
+    contact: ContactNode;
+    job: JobNode;
+    education: EducationNode;
+    project: ProjectNode;
+    skills: SkillsNode;
+    command: CommandNode;
+    error: ErrorNode;
+}
+/** Nodes that carry a `children: Node[]` array. */
+type ParentNode = Extract<Node, {
+    children: Node[];
+}>;
+declare function isParent(node: Node): node is ParentNode;
+/** Type guard generator for a given node type. */
+declare function isNode<T extends NodeType>(node: Node, type: T): node is NodeMap[T];
+
+/**
+ * Theme model. Themes are plain data so they can be serialized, shipped over
+ * the wire, edited in a GUI, or composed at runtime. {@link resolveTheme}
+ * (see `src/theme`) deep-merges a partial theme over the default.
+ */
+interface ThemeColors {
+    /** Brand / accent color used for links, section rules, highlights. */
+    primary: string;
+    /** Muted secondary color for meta text (dates, locations). */
+    secondary: string;
+    /** Default body text color. */
+    text: string;
+    /** De-emphasized text color. */
+    muted: string;
+    /** Page background. */
+    background: string;
+    /** Hairline / border color. */
+    border: string;
+    /** Arbitrary named swatches usable via `\themecolor{name}`. */
+    [token: string]: string;
+}
+interface ThemeFonts {
+    /** Font stack for headings (`\name`, `\section`). */
+    heading: string;
+    /** Font stack for body text. */
+    body: string;
+    /** Monospace stack (code, technical skills). */
+    mono: string;
+}
+interface ThemeFontSizes {
+    /** Base body size, e.g. `"11pt"`. */
+    base: string;
+    small: string;
+    large: string;
+    Large: string;
+    Huge: string;
+    /** `\name` size. */
+    name: string;
+    /** `\section` heading size. */
+    section: string;
+}
+interface ThemeSpacing {
+    /** Vertical rhythm unit. */
+    unit: string;
+    section: string;
+    item: string;
+    /** Page padding when rendering a full document. */
+    page: string;
+}
+interface ThemePage {
+    /** CSS page size keyword or dimensions, e.g. `"A4"` or `"8.5in 11in"`. */
+    size: string;
+    margin: string;
+    /** Max content width for screen preview. */
+    maxWidth: string;
+}
+interface Theme {
+    name: string;
+    colors: ThemeColors;
+    fonts: ThemeFonts;
+    fontSizes: ThemeFontSizes;
+    spacing: ThemeSpacing;
+    page: ThemePage;
+    /** Section heading style hint consumed by renderers. */
+    sectionStyle: "underline" | "rule" | "plain" | "bar";
+}
+/** A user-supplied theme override; everything is optional and deep-merged. */
+type PartialTheme = {
+    name?: string;
+    colors?: Partial<ThemeColors>;
+    fonts?: Partial<ThemeFonts>;
+    fontSizes?: Partial<ThemeFontSizes>;
+    spacing?: Partial<ThemeSpacing>;
+    page?: Partial<ThemePage>;
+    sectionStyle?: Theme["sectionStyle"];
+};
+
+/**
+ * Minimal structural type for a JSX factory (React.createElement, Preact's `h`,
+ * etc.). Declaring it locally means the package has **no** hard React
+ * dependency — callers pass whichever factory they use.
+ */
+type JsxFactory = (type: unknown, props: Record<string, unknown> | null, ...children: unknown[]) => unknown;
+/** A React render override keyed by node `type` or `command:<name>`. */
+type ReactRenderFn = (node: Node, ctx: ReactRenderContext, renderChildren: (nodes: Node[]) => unknown[]) => unknown;
+interface ReactRenderContext {
+    theme: Theme;
+    classPrefix: string;
+    h: JsxFactory;
+    Fragment: unknown;
+    overrides: Map<string, ReactRenderFn>;
+    renderNodes: (nodes: Node[]) => unknown[];
+    cls: (name: string) => string;
+}
+interface ReactRenderOptions {
+    /** JSX factory. Required. Pass `React.createElement`. */
+    createElement: JsxFactory;
+    /** Fragment component. Pass `React.Fragment`. Falls back to a `<div>`. */
+    Fragment?: unknown;
+    theme?: Theme;
+    classPrefix?: string;
+    overrides?: Map<string, ReactRenderFn>;
+    header?: boolean;
+}
+/**
+ * The React renderer. Produces a React element tree mirroring the HTML
+ * renderer's structure and class names, so the same theme stylesheet applies.
+ */
+declare class ReactRenderer {
+    private readonly theme;
+    private readonly prefix;
+    private readonly h;
+    private readonly Fragment;
+    private readonly overrides;
+    private readonly useHeader;
+    private key;
+    constructor(options: ReactRenderOptions);
+    /** The stylesheet for the active theme. Render it in a `<style>` yourself. */
+    styles(): string;
+    /** Render the document AST to a React element. */
+    render(ast: DocumentNode): unknown;
+    private ctx;
+    private renderSection;
+    private renderPreamble;
+    private renderFlow;
+    private renderInline;
+    private renderNode;
+    private renderContact;
+    private contactLink;
+    private renderLink;
+    private renderList;
+    private renderColumns;
+    private renderEntry;
+    private renderCommand;
+    private renderIcon;
+    private el;
+    private frag;
+    private dim;
+    private cls;
+}
+/** Render a document AST to a React element tree. */
+declare function renderReact(ast: DocumentNode, options: ReactRenderOptions): unknown;
+
+export { isNode as $, type ArgumentNode as A, ReactRenderer as B, type CommandNode as C, type DocumentNode as D, type EducationNode as E, type FieldMap as F, type GroupNode as G, type RuleNode as H, type IconNode as I, type JobNode as J, type SkillsNode as K, type LineBreakNode as L, type MarkNode as M, type Node as N, type SpaceNode as O, type PartialTheme as P, type TextNode as Q, type ReactRenderFn as R, type SourceRange as S, type Theme as T, type ThemeColorNode as U, type ThemeColors as V, type ThemeFontSizes as W, type ThemeFonts as X, type ThemePage as Y, type ThemeSpacing as Z, type UrlNode as _, type ContactNode as a, isParent as a0, mergeRanges as a1, pos as a2, range as a3, rangeContains as a4, renderReact as a5, type SectionNode as b, type ReactRenderOptions as c, type ColorNode as d, type ColumnNode as e, type ColumnsNode as f, type ContactField as g, type ErrorNode as h, type FontFamilyNode as i, type FontScale as j, type FontScaleNode as k, type FontSizeNode as l, type JsxFactory as m, type LinkNode as n, type ListItemNode as o, type ListKind as p, type ListNode as q, type MarkType as r, type NodeBase as s, type NodeMap as t, type NodeType as u, type ParBreakNode as v, type ParentNode as w, type Position as x, type ProjectNode as y, type ReactRenderContext as z };