@wdprlib/ast 0.1.0

package/dist/index.d.cts

@@ -0,0 +1,583 @@
+/**
+* Source code position
+*/
+interface Point {
+	/** Line number (1-based) */
+	line: number;
+	/** Column number (1-based) */
+	column: number;
+	/** Offset (0-based) */
+	offset: number;
+}
+/**
+* Source code range
+*/
+interface Position {
+	start: Point;
+	end: Point;
+}
+/**
+* Helper to create a Point
+*/
+declare function createPoint(line: number, column: number, offset: number): Point;
+/**
+* Helper to create a Position
+*/
+declare function createPosition(start: Point, end: Point): Position;
+/**
+* Element types for AST
+*/
+/**
+* Attributes map
+*/
+type AttributeMap = Record<string, string>;
+/**
+* Variable map for includes
+*/
+type VariableMap = Record<string, string>;
+/**
+* Alignment
+*/
+type Alignment = "left" | "right" | "center" | "justify";
+/**
+* Float alignment
+*/
+interface FloatAlignment {
+	align: Alignment;
+	float: boolean;
+}
+/**
+* Heading level
+*/
+type HeadingLevel = 1 | 2 | 3 | 4 | 5 | 6;
+/**
+* Heading structure
+*/
+interface Heading {
+	level: HeadingLevel;
+	"has-toc": boolean;
+}
+/**
+* Header container type
+*/
+interface HeaderType {
+	header: Heading;
+}
+/**
+* Align container type
+*/
+interface AlignType {
+	align: Alignment;
+}
+/**
+* String-only container types (formatting, structural, etc.)
+*/
+type StringContainerType = "bold" | "italics" | "underline" | "superscript" | "subscript" | "strikethrough" | "monospace" | "span" | "div" | "blockquote" | "size" | "paragraph" | "heading" | "collapsible" | "definition-list" | "definition-list-item" | "definition-list-key" | "definition-list-value" | "table-row" | "table-cell";
+/**
+* Container types
+*/
+type ContainerType = StringContainerType | HeaderType | AlignType;
+/**
+* Type guard: ContainerType is a string literal
+*/
+declare function isStringContainerType(type: ContainerType): type is StringContainerType;
+/**
+* Type guard: ContainerType is a HeaderType
+*/
+declare function isHeaderType(type: ContainerType): type is HeaderType;
+/**
+* Type guard: ContainerType is an AlignType
+*/
+declare function isAlignType(type: ContainerType): type is AlignType;
+/**
+* Container data
+*/
+interface ContainerData {
+	type: ContainerType;
+	attributes: AttributeMap;
+	elements: Element[];
+	_paragraphStrip?: boolean;
+	_emptyParagraphStrip?: boolean;
+	_escapedFromParagraph?: boolean;
+	_closeSpan?: boolean;
+	_splitByBlankLine?: boolean;
+}
+/**
+* Anchor target
+*/
+type AnchorTarget = "new-tab" | "parent" | "top" | "same";
+/**
+* Page reference (for internal links)
+*/
+interface PageRef {
+	site: string | null;
+	page: string;
+}
+/**
+* Link location - either a page reference or a URL string
+*/
+type LinkLocation = PageRef | string;
+/**
+* Link label types
+*/
+type LinkLabel = {
+	text: string;
+} | {
+	url: string | null;
+} | "page";
+/**
+* Link type
+*/
+type LinkType = "direct" | "page" | "interwiki" | "anchor" | "table-of-contents";
+/**
+* Image source
+*/
+type ImageSource = {
+	type: "url";
+	data: string;
+} | {
+	type: "file1";
+	data: {
+		file: string;
+	};
+} | {
+	type: "file2";
+	data: {
+		page: string;
+		file: string;
+	};
+} | {
+	type: "file3";
+	data: {
+		site: string;
+		page: string;
+		file: string;
+	};
+};
+/**
+* List type
+*/
+type ListType = "bullet" | "numbered" | "generic";
+/**
+* List item - discriminated union
+*/
+type ListItem = {
+	"item-type": "elements";
+	attributes: AttributeMap;
+	elements: Element[];
+} | {
+	"item-type": "sub-list";
+	element: "list";
+	data: ListData;
+};
+/**
+* List data
+*/
+interface ListData {
+	type: ListType;
+	attributes: AttributeMap;
+	items: ListItem[];
+}
+/**
+* Definition list item
+*/
+interface DefinitionListItem {
+	key_string: string;
+	key: Element[];
+	value: Element[];
+}
+/**
+* Table cell
+*/
+interface TableCell {
+	header: boolean;
+	"column-span": number;
+	align: Alignment | null;
+	attributes: AttributeMap;
+	elements: Element[];
+}
+/**
+* Table row
+*/
+interface TableRow {
+	attributes: AttributeMap;
+	cells: TableCell[];
+}
+/**
+* Table data
+*/
+interface TableData {
+	attributes: AttributeMap;
+	rows: TableRow[];
+}
+/**
+* Tab data
+*/
+interface TabData {
+	label: string;
+	elements: Element[];
+}
+/**
+* Code block data
+*/
+interface CodeBlockData {
+	contents: string;
+	language: string | null;
+	name: string | null;
+}
+/**
+* Collapsible data
+*/
+interface CollapsibleData {
+	elements: Element[];
+	attributes: AttributeMap;
+	"start-open": boolean;
+	"show-text": string | null;
+	"hide-text": string | null;
+	"show-top": boolean;
+	"show-bottom": boolean;
+}
+/**
+* Module types
+*/
+type Module = {
+	module: "unknown";
+	name: string;
+	arguments: AttributeMap;
+	body?: string;
+} | {
+	module: "backlinks";
+	page: string | null;
+} | {
+	module: "categories";
+	"include-hidden": boolean;
+} | {
+	module: "join";
+	"button-text": string | null;
+	attributes: AttributeMap;
+} | {
+	module: "page-tree";
+	root: string | null;
+	"show-root": boolean;
+	depth: number | null;
+} | {
+	module: "rate";
+} | {
+	module: "list-users";
+	users: string;
+	body?: string;
+	attributes: AttributeMap;
+} | {
+	module: "list-pages";
+	category?: string;
+	tags?: string;
+	parent?: string;
+	"link-to"?: string;
+	"created-by"?: string;
+	"created-at"?: string;
+	"updated-at"?: string;
+	rating?: string;
+	votes?: string;
+	name?: string;
+	fullname?: string;
+	range?: string;
+	pagetype?: string;
+	offset?: number;
+	limit?: number;
+	"per-page"?: number;
+	order?: string;
+	reverse: boolean;
+	separate: boolean;
+	wrapper: boolean;
+	"prepend-line"?: string;
+	"append-line"?: string;
+	rss?: string;
+	"rss-description"?: string;
+	"rss-home"?: string;
+	"rss-limit"?: number;
+	"rss-only": boolean;
+	"url-attr-prefix"?: string;
+	body?: string;
+	attributes: AttributeMap;
+};
+/**
+* Embed types
+*/
+type Embed = {
+	embed: "youtube";
+	data: {
+		"video-id": string;
+	};
+} | {
+	embed: "vimeo";
+	data: {
+		"video-id": string;
+	};
+} | {
+	embed: "github-gist";
+	data: {
+		username: string;
+		hash: string;
+	};
+} | {
+	embed: "gitlab-snippet";
+	data: {
+		"snippet-id": string;
+	};
+};
+/**
+* Date item value
+*/
+interface DateItem {
+	timestamp: number;
+	timezone: string;
+}
+/**
+* Clear float direction
+*/
+type ClearFloat = "left" | "right" | "both";
+interface AnchorData {
+	target: AnchorTarget | null;
+	attributes: AttributeMap;
+	elements: Element[];
+}
+interface LinkData {
+	type: LinkType;
+	link: LinkLocation;
+	extra: string | null;
+	label: LinkLabel;
+	target: AnchorTarget | null;
+}
+interface ImageData {
+	source: ImageSource;
+	link: LinkLocation | null;
+	alignment: FloatAlignment | null;
+	attributes: AttributeMap;
+}
+interface TableOfContentsData {
+	attributes: AttributeMap;
+	align: Alignment | null;
+}
+interface FootnoteBlockData {
+	title: string | null;
+	hide?: boolean;
+}
+interface BibliographyCiteData {
+	label: string;
+	brackets: boolean;
+}
+interface BibliographyBlockData {
+	index: number;
+	title: string | null;
+	hide: boolean;
+}
+interface UserData {
+	name: string;
+	"show-avatar": boolean;
+}
+interface DateData {
+	value: DateItem;
+	format: string | null;
+	hover: boolean;
+}
+interface ColorData {
+	color: string;
+	elements: Element[];
+}
+interface MathData {
+	name: string | null;
+	"latex-source": string;
+}
+interface MathInlineData {
+	"latex-source": string;
+}
+interface HtmlData {
+	contents: string;
+}
+interface IframeData {
+	url: string;
+	attributes: AttributeMap;
+}
+interface IncludeData {
+	"paragraph-safe": boolean;
+	variables: VariableMap;
+	location: PageRef;
+	elements: Element[];
+}
+interface IfTagsData {
+	condition: string;
+	elements: Element[];
+}
+/**
+* Expression data: [[#expr expression]]
+* The expression is stored as a string and evaluated at render time.
+*/
+interface ExprData {
+	expression: string;
+}
+/**
+* If data: [[#if value | then | else]]
+* Simple true/false checker that treats the value as a string.
+* False values: "false", "null", "", "0"
+*/
+interface IfCondData {
+	condition: string;
+	then: Element[];
+	else: Element[];
+}
+/**
+* IfExpr data: [[#ifexpr expression | then | else]]
+* Evaluates the expression and branches based on the result.
+*/
+interface IfExprData {
+	expression: string;
+	then: Element[];
+	else: Element[];
+}
+type ElementDataMap = {
+	container: ContainerData;
+	module: Module;
+	text: string;
+	raw: string;
+	variable: string;
+	email: string;
+	table: TableData;
+	"tab-view": TabData[];
+	anchor: AnchorData;
+	"anchor-name": string;
+	link: LinkData;
+	image: ImageData;
+	list: ListData;
+	"definition-list": DefinitionListItem[];
+	collapsible: CollapsibleData;
+	"table-of-contents": TableOfContentsData;
+	footnote: void;
+	"footnote-ref": number;
+	"footnote-block": FootnoteBlockData;
+	"bibliography-cite": BibliographyCiteData;
+	"bibliography-block": BibliographyBlockData;
+	user: UserData;
+	date: DateData;
+	color: ColorData;
+	code: CodeBlockData;
+	math: MathData;
+	"math-inline": MathInlineData;
+	"equation-reference": string;
+	embed: Embed;
+	html: HtmlData;
+	iframe: IframeData;
+	include: IncludeData;
+	style: string;
+	"line-break": void;
+	"line-breaks": number;
+	"clear-float": ClearFloat;
+	"horizontal-rule": void;
+	"content-separator": void;
+	"if-tags": IfTagsData;
+	expr: ExprData;
+	if: IfCondData;
+	ifexpr: IfExprData;
+};
+/**
+* All element tag names
+*/
+type ElementName = keyof ElementDataMap;
+/**
+* Get the data type for a given element name
+*/
+type ElementData<K extends ElementName> = ElementDataMap[K];
+/**
+* Get the Element variant for a given element name
+*/
+type ElementOf<K extends ElementName> = ElementDataMap[K] extends void ? {
+	element: K;
+} : {
+	element: K;
+	data: ElementDataMap[K];
+};
+/**
+* Element - tagged union generated from ElementDataMap
+*/
+type Element = { [K in ElementName] : ElementOf<K> }[ElementName];
+/**
+* TOC entry collected during parsing (internal format)
+*/
+interface TocEntry {
+	level: number;
+	text: string;
+}
+/**
+* Syntax tree - root of the AST
+*/
+interface SyntaxTree {
+	elements: Element[];
+	"table-of-contents"?: Element[];
+	styles?: string[];
+	"html-blocks"?: string[];
+	"code-blocks"?: CodeBlockData[];
+	footnotes?: Element[][];
+}
+/**
+* Create a text element
+*/
+declare function text(value: string): Element;
+/**
+* Create a container element
+*/
+declare function container(type: ContainerType, elements: Element[], attributes?: AttributeMap): Element;
+/**
+* Create a paragraph element
+*/
+declare function paragraph(elements: Element[], attributes?: AttributeMap): Element;
+/**
+* Create a bold element
+*/
+declare function bold(elements: Element[], attributes?: AttributeMap): Element;
+/**
+* Create an italics element
+*/
+declare function italics(elements: Element[], attributes?: AttributeMap): Element;
+/**
+* Create a heading element
+*/
+declare function heading(level: HeadingLevel, elements: Element[], hasToc?: boolean, attributes?: AttributeMap): Element;
+/**
+* Create a line break element
+*/
+declare function lineBreak(): Element;
+/**
+* Create a horizontal rule element
+*/
+declare function horizontalRule(): Element;
+/**
+* Create a link element
+*/
+declare function link(linkLocation: LinkLocation, label: LinkLabel, options?: {
+	type?: LinkType;
+	extra?: string | null;
+	target?: AnchorTarget | null;
+}): Element;
+/**
+* Create a list element
+*/
+declare function list(type: ListType, items: ListItem[], attributes?: AttributeMap): Element;
+/**
+* Create a list item (elements type)
+*/
+declare function listItemElements(elements: Element[], attributes?: AttributeMap): ListItem;
+/**
+* Create a list item (sub-list type)
+*/
+declare function listItemSubList(data: ListData): ListItem;
+/**
+* Check if a container type is paragraph-safe.
+*/
+declare function isContainerTypeParagraphSafe(type: ContainerType): boolean;
+/**
+* Check if an element is paragraph-safe (can be contained within a paragraph).
+*
+* This does a surface-level check and does not look into element interiors.
+*/
+declare function isParagraphSafe(element: Element): boolean;
+type Version = "wikidot";
+export { text, paragraph, listItemSubList, listItemElements, list, link, lineBreak, italics, isStringContainerType, isParagraphSafe, isHeaderType, isContainerTypeParagraphSafe, isAlignType, horizontalRule, heading, createPosition, createPoint, container, bold, Version, VariableMap, UserData, TocEntry, TableRow, TableOfContentsData, TableData, TableCell, TabData, SyntaxTree, StringContainerType, Position, Point, PageRef, Module, MathInlineData, MathData, ListType, ListItem, ListData, LinkType, LinkLocation, LinkLabel, LinkData, IncludeData, ImageSource, ImageData, IframeData, IfTagsData, IfExprData, IfCondData, HtmlData, HeadingLevel, Heading, HeaderType, FootnoteBlockData, FloatAlignment, ExprData, Embed, ElementOf, ElementName, ElementDataMap, ElementData, Element, DefinitionListItem, DateItem, DateData, ContainerType, ContainerData, ColorData, CollapsibleData, CodeBlockData, ClearFloat, BibliographyCiteData, BibliographyBlockData, AttributeMap, AnchorTarget, AnchorData, Alignment, AlignType };