@licium/toastmark 0.0.1-alpha.1

package/types/parser.d.ts

@@ -0,0 +1,88 @@
+import { BlockMdNode, BlockNodeType, MdNode, MdNodeType, RefDefMdNode, Sourcepos } from './node';
+
+export type AutolinkParser = (
+  content: string
+) => {
+  url: string;
+  text: string;
+  range: [number, number];
+}[];
+
+export type CustomParser = (
+  node: MdNode,
+  context: { entering: boolean; options: ParserOptions }
+) => void;
+export type CustomParserMap = Partial<Record<MdNodeType, CustomParser>>;
+
+type RefDefState = {
+  id: number;
+  destination: string;
+  title: string;
+  unlinked: boolean;
+  sourcepos: Sourcepos;
+};
+
+export type RefMap = {
+  [k: string]: RefDefState;
+};
+
+export type RefLinkCandidateMap = {
+  [k: number]: {
+    node: BlockMdNode;
+    refLabel: string;
+  };
+};
+
+export type RefDefCandidateMap = {
+  [k: number]: RefDefMdNode;
+};
+
+export interface ParserOptions {
+  smart: boolean;
+  tagFilter: boolean;
+  extendedAutolinks: boolean | AutolinkParser;
+  disallowedHtmlBlockTags: string[];
+  referenceDefinition: boolean;
+  disallowDeepHeading: boolean;
+  frontMatter: boolean;
+  customParser: CustomParserMap | null;
+}
+
+export class BlockParser {
+  constructor(options?: Partial<ParserOptions>);
+
+  advanceOffset(count: number, columns?: boolean): void;
+
+  advanceNextNonspace(): void;
+
+  findNextNonspace(): void;
+
+  addLine(): void;
+
+  addChild(tag: BlockNodeType, offset: number): BlockMdNode;
+
+  closeUnmatchedBlocks(): void;
+
+  finalize(block: BlockMdNode, lineNumber: number): void;
+
+  processInlines(block: BlockMdNode): void;
+
+  incorporateLine(ln: string): void;
+
+  // The main parsing function.  Returns a parsed document AST.
+  parse(input: string, lineTexts?: string[]): MdNode;
+
+  partialParseStart(lineNumber: number, lines: string[]): MdNode;
+
+  partialParseExtends(lines: string[]): void;
+
+  partialParseFinish(): void;
+
+  setRefMaps(
+    refMap: RefMap,
+    refLinkCandidateMap: RefLinkCandidateMap,
+    refDefCandidateMap: RefDefCandidateMap
+  ): void;
+
+  clearRefMaps(): void;
+}

package/types/renderer.d.ts

@@ -0,0 +1,68 @@
+import { MdNode, MdNodeType } from './node';
+
+export type HTMLConvertor = (
+  node: MdNode,
+  context: Context,
+  convertors?: HTMLConvertorMap
+) => HTMLToken | HTMLToken[] | null;
+
+export type HTMLConvertorMap = Partial<Record<MdNodeType | string, HTMLConvertor>>;
+
+interface RendererOptions {
+  gfm: boolean;
+  softbreak: string;
+  nodeId: boolean;
+  tagFilter: boolean;
+  convertors?: HTMLConvertorMap;
+}
+
+interface Context {
+  entering: boolean;
+  leaf: boolean;
+  options: Omit<RendererOptions, 'convertors'>;
+  getChildrenText: (node: MdNode) => string;
+  skipChildren: () => void;
+  origin?: () => ReturnType<HTMLConvertor>;
+}
+
+interface TagToken {
+  tagName: string;
+  outerNewLine?: boolean;
+  innerNewLine?: boolean;
+}
+
+export interface OpenTagToken extends TagToken {
+  type: 'openTag';
+  classNames?: string[];
+  attributes?: Record<string, any>;
+  selfClose?: boolean;
+}
+
+export interface CloseTagToken extends TagToken {
+  type: 'closeTag';
+}
+
+export interface TextToken {
+  type: 'text';
+  content: string;
+}
+
+export interface RawHTMLToken {
+  type: 'html';
+  content: string;
+  outerNewLine?: boolean;
+}
+
+export type HTMLToken = OpenTagToken | CloseTagToken | TextToken | RawHTMLToken;
+
+export class HTMLRenderer {
+  constructor(customOptions?: Partial<RendererOptions>);
+
+  getConvertors(): HTMLConvertorMap;
+
+  getOptions(): RendererOptions;
+
+  render(rootNode: MdNode): string;
+
+  renderHTMLNode(node: HTMLToken): void;
+}

package/types/toastMark.d.ts

@@ -0,0 +1,42 @@
+import { MdNode, Pos } from './node';
+import { ParserOptions } from './parser';
+
+export interface RemovedNodeRange {
+  id: [number, number];
+  line: [number, number];
+}
+
+export interface EditResult {
+  nodes: MdNode[];
+  removedNodeRange: RemovedNodeRange | null;
+}
+
+type EventName = 'change';
+
+type EventHandlerMap = {
+  [key in EventName]: Function[];
+};
+
+export class ToastMark {
+  constructor(contents?: string, options?: Partial<ParserOptions>);
+
+  lineTexts: string[];
+
+  editMarkdown(startPos: Pos, endPos: Pos, newText: string): EditResult[];
+
+  getLineTexts(): string[];
+
+  getRootNode(): MdNode;
+
+  findNodeAtPosition(pos: Pos): MdNode | null;
+
+  findFirstNodeAtLine(line: number): MdNode | null;
+
+  on(eventName: EventName, callback: () => void): void;
+
+  off(eventName: EventName, callback: () => void): void;
+
+  findNodeById(id: number): MdNode | null;
+
+  removeAllNode(): void;
+}