From d696992432de128e3fa2b776f31dd8b69fc22d71 Mon Sep 17 00:00:00 2001 From: Lilian Saget-Lethias Date: Wed, 20 Mar 2019 18:55:38 +0100 Subject: [PATCH 1/3] [remarkable] Improve Rules types --- types/remarkable/index.d.ts | 3 + types/remarkable/lib/index.d.ts | 708 ++++++++++++++++++++++++-------- 2 files changed, 537 insertions(+), 174 deletions(-) diff --git a/types/remarkable/index.d.ts b/types/remarkable/index.d.ts index 584c855387..e6eeda2c37 100644 --- a/types/remarkable/index.d.ts +++ b/types/remarkable/index.d.ts @@ -2,8 +2,11 @@ // Project: https://github.com/jonschlinkert/remarkable // Definitions by: makepost // Richard Lea +// Lilian Saget-Lethias // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped +// TypeScript Version: 2.3 import Remarkable = require("./lib"); export = Remarkable; +export as namespace Remarkable; diff --git a/types/remarkable/lib/index.d.ts b/types/remarkable/lib/index.d.ts index c2c9b13511..45643dcc8d 100644 --- a/types/remarkable/lib/index.d.ts +++ b/types/remarkable/lib/index.d.ts @@ -1,3 +1,5 @@ +// tslint:disable:no-empty-interface + import * as Utils from "./common/utils"; import Renderer = require("./renderer"); import Ruler = require("./ruler"); @@ -76,7 +78,7 @@ declare namespace Remarkable { [key: string]: any; } - type GetBreak = (tokens: ContentToken[], idx: number) => "" | "\n"; + type GetBreak = Rule; interface Options { /** @@ -140,76 +142,76 @@ declare namespace Remarkable { } interface StateBlock { - src: string; - /** Shortcuts to simplify nested calls */ - parser: ParserBlock; - options: Options; - env: Env; - tokens: [ContentToken]; - bMarks: number[]; - eMarks: number[]; - tShift: number[]; - /** required block content indent */ - blkIndent: number; - /** line index in src */ - line: number; - /** lines count */ - lineMax: number; - /** loose/tight mode for lists */ - tight: boolean; - /** If `list`, block parser stops on two newlines */ - parentType: 'root' | 'list'; - /** Indent of the current dd block, -1 if there isn't any */ - ddIndent: number; - level: number; - result: string; - isEmpty: (line: number) => boolean; - skipEmptyLines: (from: number) => number; - skipSpaces: (pos: number) => number; - skipChars: (pos: number, code: number) => number; - getLines: (begin: number, end: number, indent: number, keepLastLF: boolean) => string; + src: string; + /** Shortcuts to simplify nested calls */ + parser: ParserBlock; + options: Options; + env: Env; + tokens: [ContentToken]; + bMarks: number[]; + eMarks: number[]; + tShift: number[]; + /** required block content indent */ + blkIndent: number; + /** line index in src */ + line: number; + /** lines count */ + lineMax: number; + /** loose/tight mode for lists */ + tight: boolean; + /** If `list`, block parser stops on two newlines */ + parentType: 'root' | 'list'; + /** Indent of the current dd block, -1 if there isn't any */ + ddIndent: number; + level: number; + result: string; + isEmpty: (line: number) => boolean; + skipEmptyLines: (from: number) => number; + skipSpaces: (pos: number) => number; + skipChars: (pos: number, code: number) => number; + getLines: (begin: number, end: number, indent: number, keepLastLF: boolean) => string; } interface StateInline { - src: string; - env: Env; - parser: ParserInline; - tokens: [ContentToken]; - pos: number; - posMax: number; - level: number; - pending: string; - pendingLevel: number; - /** Set true when seek link label */ - isInLabel: boolean; - /** - * Increment for each nesting link. - * Used to prevent nesting in definitions. - */ - linkLevel: number; - /** - * Temporary storage for link url. - */ - linkContent: string; + src: string; + env: Env; + parser: ParserInline; + tokens: [ContentToken]; + pos: number; + posMax: number; + level: number; + pending: string; + pendingLevel: number; + /** Set true when seek link label */ + isInLabel: boolean; + /** + * Increment for each nesting link. + * Used to prevent nesting in definitions. + */ + linkLevel: number; + /** + * Temporary storage for link url. + */ + linkContent: string; - /** - * Track unpaired `[` for link labels. - */ - labelUnmatchedScopes: number; - push: (token: ContentToken) => void; - pushPending: () => void; - } + /** + * Track unpaired `[` for link labels. + */ + labelUnmatchedScopes: number; + push: (token: ContentToken) => void; + pushPending: () => void; + } - /** - * Return `true` if the parsing function has recognized the current position - * in the input as one if its tokens. - */ - type CoreParsingRule = ( - /** - * Representation of the current input stream, and the results of - * parsing it so far. - */ - state: StateInline, - ) => boolean; + /** + * Return `true` if the parsing function has recognized the current position + * in the input as one if its tokens. + */ + type CoreParsingRule = ( + /** + * Representation of the current input stream, and the results of + * parsing it so far. + */ + state: StateInline, + ) => boolean; /** * Return `true` if the parsing function has recognized the current position @@ -257,11 +259,12 @@ declare namespace Remarkable { silent: boolean ) => boolean; - type Rule = ( + type Rule = ( /** * The list of tokens currently being processed. */ - tokens: ContentToken[], + // tslint:disable-next-line:no-unnecessary-generics + tokens: T[], /** * The index of the token currently being processed. @@ -271,78 +274,86 @@ declare namespace Remarkable { /** * The options given to remarkable. */ - options: Options, + options?: Options, /** * The key-value store created by the parsing rules. */ - env: Env, - ) => string; + env?: Env, + /** + * The possible instance of Remarkable. See `fence` renderer function. + */ + instance?: Remarkable, + ) => R; + + /** + * Renderer rules. + */ interface Rules { - [name: string]: Rule; - "blockquote_open": Rule; - "blockquote_close": Rule; - "code": Rule; - "fence": Rule; - "fence_custom": Rule; - "heading_open": Rule; - "heading_close": Rule; - "hr": Rule; - "bullet_list_open": Rule; - "bullet_list_close": Rule; - "list_item_open": Rule; - "list_item_close": Rule; - "ordered_list_open": Rule; - "ordered_list_close": Rule; - "paragraph_open": Rule; - "paragraph_close": Rule; - "link_open": Rule; - "link_close": Rule; - "image": Rule; - "table_open": Rule; - "table_close": Rule; - "thead_open": Rule; - "thead_close": Rule; - "tbody_open": Rule; - "tbody_close": Rule; - "tr_open": Rule; - "tr_close": Rule; - "th_open": Rule; - "th_close": Rule; - "td_open": Rule; - "td_close": Rule; - "strong_open": Rule; - "strong_close": Rule; - "em_open": Rule; - "em_close": Rule; - "del_open": Rule; - "del_close": Rule; - "ins_open": Rule; - "ins_close": Rule; - "mark_open": Rule; - "mark_close": Rule; - "sub": Rule; - "sup": Rule; - "hardbreak": Rule; - "softbreak": Rule; - "text": Rule; - "htmlblock": Rule; - "htmltag": Rule; - "abbr_open": Rule; - "abbr_close": Rule; - "footnote_ref": Rule; - "footnote_block_open": Rule; - "footnote_block_close": Rule; - "footnote_open": Rule; - "footnote_close": Rule; - "footnote_anchor": Rule; - "dl_open": Rule; - "dt_open": Rule; - "dd_open": Rule; - "dl_close": Rule; - "dt_close": Rule; - "dd_close": Rule; + [name: string]: Rule | { [name: string]: Rule }; + "blockquote_open": Rule; + "blockquote_close": Rule; + "code": Rule; + "fence": Rule; + "fence_custom": { [name: string]: Rule }; + "heading_open": Rule; + "heading_close": Rule; + "hr": Rule; + "bullet_list_open": Rule; + "bullet_list_close": Rule; + "list_item_open": Rule; + "list_item_close": Rule; + "ordered_list_open": Rule; + "ordered_list_close": Rule; + "paragraph_open": Rule; + "paragraph_close": Rule; + "link_open": Rule; + "link_close": Rule; + "image": Rule; + "table_open": Rule; + "table_close": Rule; + "thead_open": Rule; + "thead_close": Rule; + "tbody_open": Rule; + "tbody_close": Rule; + "tr_open": Rule; + "tr_close": Rule; + "th_open": Rule; + "th_close": Rule; + "td_open": Rule; + "td_close": Rule; + "strong_open": Rule; + "strong_close": Rule; + "em_open": Rule; + "em_close": Rule; + "del_open": Rule; + "del_close": Rule; + "ins_open": Rule; + "ins_close": Rule; + "mark_open": Rule; + "mark_close": Rule; + "sub": Rule; + "sup": Rule; + "hardbreak": Rule; + "softbreak": Rule; + "text": Rule; + "htmlblock": Rule; + "htmltag": Rule; + "abbr_open": Rule; + "abbr_close": Rule; + "footnote_ref": Rule; + "footnote_block_open": Rule; + "footnote_block_close": Rule; + "footnote_open": Rule; + "footnote_close": Rule; + "footnote_anchor": Rule; + "dl_open": Rule; + "dt_open": Rule; + "dd_open": Rule; + "dl_close": Rule; + "dt_close": Rule; + "dd_close": Rule; /** * Check to see if `\n` is needed before the next token. @@ -390,81 +401,430 @@ declare namespace Remarkable { */ content: any; - /** - * The type of the token. - */ - type: string; - /** * Is this a block element */ block: boolean; } - interface MiscTokenProps { - /** - * Image alt. - */ - alt?: string; + // --------------- + // Specific Block Tokens + // --------------- + interface BlockquoteToken extends TagToken {} + interface BlockquoteOpenToken extends BlockquoteToken { + type: 'blockquote_open'; + } + interface BlockquoteCloseToken extends BlockquoteToken { + type: 'blockquote_close'; + } + + interface CodeToken extends BlockContentToken { /** * Code: `true` if block, `false` if inline. */ - block?: boolean; + block: boolean; - /** - * Footnote label. - */ - label?: any; + type: 'code'; + } - /** - * Heading level. - */ - hLevel?: number; + interface DlOpenToken extends TagToken { + type: 'dl_open'; + } + interface DlCloseToken extends TagToken { + type: 'dl_close'; + } + interface DtOpenToken extends TagToken { + type: 'dt_open'; + } + interface DtCloseToken extends TagToken { + type: 'dt_close'; + } + interface DdOpenToken extends TagToken { + type: 'dd_open'; + } + interface DdCloseToken extends TagToken { + type: 'dd_close'; + } - /** - * Link url. - */ - href?: string; - - /** - * Footnote id. - */ - id?: number; - - /** - * Ordered list marker value. - */ - order?: number; + interface FenceToken extends ContentToken { + content: string; + block: false; /** * Fenced block params. */ - params?: any[]; + params: string; + type: 'fence'; + } + interface FootnoteGenericToken extends TagToken { /** - * Image url. + * Footnote id. */ - src?: string; + id: number; /** * Footnote sub id. */ subId?: number; + } + interface FootnoteReferenceToken extends TagToken {} + interface FootnoteReferenceOpenToken extends FootnoteReferenceToken { + label: string; + type: 'footnote_reference_open'; + } + interface FootnoteReferenceCloseToken extends FootnoteReferenceToken { + type: 'footnote_reference_close'; + } + type HeadingValue = 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9; + interface HeadingToken extends TagToken { + hLevel: HeadingValue; + } + interface HeadingOpenToken extends HeadingToken { + type: 'heading_open'; + } + interface HeadingCloseToken extends HeadingToken { + type: 'heading_close'; + } + + interface HrToken extends TagToken { + type: 'hr'; + } + + interface HtmlBlockToken extends ContentToken { + content: string; + block: false; + type: 'htmlblock'; + } + + interface LHeadingOpenToken extends HeadingOpenToken {} + interface LHeadingCloseToken extends HeadingCloseToken {} + + interface OrderedListToken extends TagToken {} + interface OrderedListOpenToken extends OrderedListToken { + /** + * Ordered list marker value. + */ + order: number; + type: 'ordered_list_open'; + } + interface OrderedListCloseToken extends OrderedListToken { + type: 'ordered_list_close'; + } + interface BulletListToken extends TagToken {} + interface BulletListOpenToken extends BulletListToken { + type: 'bullet_list_open'; + } + interface BulletListCloseToken extends BulletListToken { + type: 'bullet_list_close'; + } + interface ListItemToken extends TagToken {} + interface ListItemOpenToken extends ListItemToken { + type: 'list_item_open'; + } + interface ListItemCloseToken extends ListItemToken { + type: 'list_item_close'; + } + + interface ParagraphToken extends TagToken { /** * Absence of empty line before current tag: `true` if absent, `false` * if present. List is tight if any list item is tight. */ - tight?: boolean; + tight: boolean; + } + interface ParagraphOpenToken extends ParagraphToken { + type: 'paragraph_open'; + } + + interface ParagraphCloseToken extends ParagraphToken { + type: 'paragraph_close'; + } + + interface TextToken extends TagToken { + content?: string; + type: 'text'; + } + + interface StrongToken extends TagToken {} + interface StrongOpenToken extends TagToken { + type: 'strong_open'; + } + interface StrongCloseToken extends TagToken { + type: 'strong_close'; + } + + interface TableToken extends TagToken {} + interface TableOpenToken extends TableToken { + type: 'table_open'; + } + interface TableCloseToken extends TableToken { + type: 'table_close'; + } + interface THeadToken extends TagToken {} + interface THeadOpenToken extends THeadToken { + type: 'thead_open'; + } + interface THeadCloseToken extends THeadToken { + type: 'thead_close'; + } + interface TBodyToken extends TagToken {} + interface TBodyOpenToken extends TBodyToken { + type: 'tbody_open'; + } + interface TBodyCloseToken extends TBodyToken { + type: 'tbody_close'; + } + interface TRToken extends TagToken {} + interface TROpenToken extends TRToken { + type: 'tr_open'; + } + interface TRCloseToken extends TRToken { + type: 'tr_close'; + } + interface THToken extends TagToken {} + interface THOpenToken extends THToken { + type: 'th_open'; + } + interface THCloseToken extends THToken { + type: 'th_close'; + } + interface TDToken extends TagToken {} + interface TDOpenToken extends TDToken { + type: 'td_open'; + } + interface TDCloseToken extends TDToken { + type: 'td_close'; + } + + // --------------- + // Specific Block Tokens + // --------------- + + interface LinkToken extends TagToken {} + interface LinkOpenToken extends LinkToken { + /** + * Link url. + */ + href: string; + /** + * Link title. + */ + title?: string; + type: 'link_open'; + } + interface LinkCloseToken extends LinkToken { + type: 'link_close'; + } + + interface DelToken extends TagToken {} + interface DelOpenToken extends DelToken { + type: 'del_open'; + } + interface DelCloseToken extends DelToken { + type: 'del_open'; + } + + interface EmToken extends TagToken {} + interface EmOpenToken extends EmToken { + type: 'em_open'; + } + interface EmCloseToken extends EmToken { + type: 'em_close'; + } + + interface HardbreakToken extends TagToken { + type: 'hardbreak'; + } + interface SoftbreakToken extends TagToken { + type: 'softbreak'; + } + + interface FootnoteInlineToken extends FootnoteGenericToken { + type: 'footnote_ref'; + } + + interface HtmlTagToken extends ContentToken { + content: string; + type: 'htmltag'; + } + + interface InsToken extends TagToken {} + interface InsOpenToken extends InsToken { + type: 'ins_open'; + } + interface InsCloseToken extends InsToken { + type: 'ins_close'; + } + + interface ImageToken extends ContentToken { + /** + * Image url. + */ + src: string; + + /** + * Image alt. + */ + alt: string; + + /** + * Image title. + */ + title: string; + + type: 'image'; + } + + interface MarkToken extends TagToken {} + interface MarkOpenToken extends MarkToken { + type: 'mark_open'; + } + interface MarkCloseToken extends MarkToken { + type: 'mark_close'; + } + + interface SubToken extends ContentToken { + content: string; + type: 'sub'; + } + + interface SupToken extends ContentToken { + content: string; + type: 'sup'; + } + + // --------------- + // Specific Core Tokens + // --------------- + + interface AbbrToken extends TagToken {} + interface AbbrOpenToken extends AbbrToken { /** * Abbreviation title. */ - title?: string; + title: string; + type: 'abbr_open'; + } + interface AbbrCloseToken extends AbbrToken { + type: 'abbr_close'; } - type Token = (BlockContentToken | ContentToken | TagToken) & MiscTokenProps; + interface FootnoteToken extends FootnoteGenericToken {} + interface FootnoteOpenToken extends FootnoteToken { + type: 'footnote_open'; + } + interface FootnoteCloseToken extends FootnoteToken { + type: 'footnote_close'; + } + + interface FootnoteBlockToken extends TagToken {} + interface FootnoteBlockOpenToken extends FootnoteBlockToken { + type: 'footnote_block_open'; + } + interface FootnoteBlockCloseToken extends FootnoteBlockToken { + type: 'footnote_block_close'; + } + + interface FootnoteAnchorToken extends FootnoteGenericToken { + type: 'footnote_anchor'; + } + + type Token = + | BlockContentToken + | ContentToken + | TagToken + | BlockquoteToken + | BlockquoteOpenToken + | BlockquoteCloseToken + | CodeToken + | DlOpenToken + | DlCloseToken + | DtOpenToken + | DtCloseToken + | DdOpenToken + | DdCloseToken + | FenceToken + | FootnoteGenericToken + | FootnoteReferenceToken + | FootnoteReferenceOpenToken + | FootnoteReferenceCloseToken + | HeadingToken + | HeadingOpenToken + | HeadingCloseToken + | HrToken + | HtmlBlockToken + | LHeadingOpenToken + | LHeadingCloseToken + | OrderedListToken + | OrderedListOpenToken + | OrderedListCloseToken + | BulletListToken + | BulletListOpenToken + | BulletListCloseToken + | ListItemToken + | ListItemOpenToken + | ListItemCloseToken + | ParagraphToken + | ParagraphOpenToken + | ParagraphCloseToken + | TextToken + | StrongToken + | StrongOpenToken + | StrongCloseToken + | TableToken + | TableOpenToken + | TableCloseToken + | THeadToken + | THeadOpenToken + | THeadCloseToken + | TBodyToken + | TBodyOpenToken + | TBodyCloseToken + | TRToken + | TROpenToken + | TRCloseToken + | THToken + | THOpenToken + | THCloseToken + | TDToken + | TDOpenToken + | TDCloseToken + | LinkToken + | LinkOpenToken + | LinkCloseToken + | DelToken + | DelOpenToken + | DelCloseToken + | EmToken + | EmOpenToken + | EmCloseToken + | HardbreakToken + | SoftbreakToken + | FootnoteInlineToken + | HtmlTagToken + | InsToken + | InsOpenToken + | InsCloseToken + | ImageToken + | MarkToken + | MarkOpenToken + | MarkCloseToken + | SubToken + | SupToken + | AbbrToken + | AbbrOpenToken + | AbbrCloseToken + | FootnoteToken + | FootnoteOpenToken + | FootnoteCloseToken + | FootnoteBlockToken + | FootnoteBlockOpenToken + | FootnoteBlockCloseToken + | FootnoteAnchorToken; } declare class ParserBlock { From c20137ad171b959422b4645e78918f7d76bb1c20 Mon Sep 17 00:00:00 2001 From: Lilian Saget-Lethias Date: Wed, 20 Mar 2019 19:58:48 +0100 Subject: [PATCH 2/3] [remarkable] Disable strictFunctionTypes for generics --- types/remarkable/lib/index.d.ts | 2 +- types/remarkable/tsconfig.json | 4 ++-- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/types/remarkable/lib/index.d.ts b/types/remarkable/lib/index.d.ts index 45643dcc8d..77762ed5a1 100644 --- a/types/remarkable/lib/index.d.ts +++ b/types/remarkable/lib/index.d.ts @@ -259,7 +259,7 @@ declare namespace Remarkable { silent: boolean ) => boolean; - type Rule = ( + type Rule = ( /** * The list of tokens currently being processed. */ diff --git a/types/remarkable/tsconfig.json b/types/remarkable/tsconfig.json index 33af23cbf9..c77fd8a6cc 100644 --- a/types/remarkable/tsconfig.json +++ b/types/remarkable/tsconfig.json @@ -7,7 +7,7 @@ "noImplicitAny": true, "noImplicitThis": true, "strictNullChecks": true, - "strictFunctionTypes": true, + "strictFunctionTypes": false, "baseUrl": "../", "typeRoots": [ "../" @@ -24,4 +24,4 @@ "index.d.ts", "remarkable-tests.ts" ] -} \ No newline at end of file +} From 61b01dec5056d1da69ccbde0f79902c98f080766 Mon Sep 17 00:00:00 2001 From: Lilian Saget-Lethias Date: Thu, 28 Mar 2019 16:05:50 +0100 Subject: [PATCH 3/3] [remarkable] Clean and fix types and add tests --- types/remarkable/lib/index.d.ts | 16 ++-- types/remarkable/remarkable-tests.ts | 121 ++++++++++++++++----------- 2 files changed, 80 insertions(+), 57 deletions(-) diff --git a/types/remarkable/lib/index.d.ts b/types/remarkable/lib/index.d.ts index 77762ed5a1..c5ae3e677b 100644 --- a/types/remarkable/lib/index.d.ts +++ b/types/remarkable/lib/index.d.ts @@ -147,7 +147,7 @@ declare namespace Remarkable { parser: ParserBlock; options: Options; env: Env; - tokens: [ContentToken]; + tokens: BlockContentToken[]; bMarks: number[]; eMarks: number[]; tShift: number[]; @@ -175,7 +175,7 @@ declare namespace Remarkable { src: string; env: Env; parser: ParserInline; - tokens: [ContentToken]; + tokens: ContentToken[]; pos: number; posMax: number; level: number; @@ -385,13 +385,13 @@ declare namespace Remarkable { * The content of the block. This might include inline mardown syntax * which may need further processing by the inline rules. */ - content: string; + content?: string; /** * This is initialized with an empty array (`[]`) and will be filled * with the inline parser tokens as the inline parsing rules are applied. */ - children: Token[]; + children?: Token[]; } interface ContentToken extends TagToken { @@ -399,12 +399,12 @@ declare namespace Remarkable { * A text token has a `content` property. This is passed to * the corresponding renderer to be converted for output. */ - content: any; + content?: any; /** * Is this a block element */ - block: boolean; + block?: boolean; } // --------------- @@ -449,7 +449,7 @@ declare namespace Remarkable { interface FenceToken extends ContentToken { content: string; - block: false; + block?: false; /** * Fenced block params. @@ -469,7 +469,7 @@ declare namespace Remarkable { */ subId?: number; } - interface FootnoteReferenceToken extends TagToken {} + interface FootnoteReferenceToken extends FootnoteGenericToken {} interface FootnoteReferenceOpenToken extends FootnoteReferenceToken { label: string; type: 'footnote_reference_open'; diff --git a/types/remarkable/remarkable-tests.ts b/types/remarkable/remarkable-tests.ts index c908af5f2a..67e5d82e4d 100644 --- a/types/remarkable/remarkable-tests.ts +++ b/types/remarkable/remarkable-tests.ts @@ -2,6 +2,7 @@ import hljs = require("highlight.js"); import Remarkable = require("remarkable"); +import * as ImportedRemarkable from "remarkable"; /** * Examples from README. @@ -10,6 +11,9 @@ export class RemarkableTest { usage() { const md = new Remarkable(); md.render("# Remarkable rulezz!"); + + const importedMd = new ImportedRemarkable(); + importedMd.render("# Remarkable rulezz!"); } defineOptionsInContructor() { @@ -148,72 +152,78 @@ export class RemarkableTest { */ export class TokenTest { blockRules() { - const tokens: Remarkable.Token[] = []; - const state = { - level: 0, - line: 0, - tokens, - }; + const state: Remarkable.StateBlock = {} as any; const lines: [number, number] = [0, 0]; const startLine = 0; - state.tokens.push({ + const blockquoteOpenToken: Remarkable.BlockquoteOpenToken = { type: "blockquote_open", lines, level: state.level++, - }); + }; + state.tokens.push(blockquoteOpenToken); - state.tokens.push({ + const blockquoteCloseToken: Remarkable.BlockquoteCloseToken = { type: "blockquote_close", level: --state.level, - }); + }; + state.tokens.push(blockquoteCloseToken); - state.tokens.push({ + const codeToken: Remarkable.CodeToken = { type: "code", content: "", block: true, lines, level: state.level, - }); + }; + state.tokens.push(codeToken); - state.tokens.push({ + // inline token doesn't need a proper type + const inlineToken: Remarkable.BlockContentToken = { type: "inline", content: "", level: state.level + 1, lines, children: [], - }); + }; + state.tokens.push(inlineToken); - state.tokens.push({ + const fenceToken: Remarkable.FenceToken = { type: "fence", - params: [], + params: "", content: "", lines: [startLine, state.line], level: state.level, - }); + }; + state.tokens.push(fenceToken); - state.tokens.push({ + const footnoteRefOpenToken: Remarkable.FootnoteReferenceOpenToken = { type: "footnote_reference_open", label: "", level: state.level++, - }); + id: 0, + }; + state.tokens.push(footnoteRefOpenToken); - state.tokens.push({ type: "heading_close", hLevel: 1, level: state.level }); + const headingCloseToken: Remarkable.HeadingCloseToken = { type: "heading_close", hLevel: 1, level: state.level }; + state.tokens.push(headingCloseToken); - state.tokens.push({ + const orderedListOpenToken: Remarkable.OrderedListOpenToken = { type: "ordered_list_open", order: 0, lines: [startLine, 0], level: state.level++, - }); + }; + state.tokens.push(orderedListOpenToken); - state.tokens.push({ + const paragraphOpenToken: Remarkable.ParagraphOpenToken = { type: "paragraph_open", tight: false, lines: [startLine, state.line], level: state.level, - }); + }; + state.tokens.push(paragraphOpenToken); } coreRules() { @@ -224,89 +234,102 @@ export class TokenTest { const m = ["", "", ""]; let level = 0; - nodes.push({ + const textToken1: Remarkable.TextToken = { type: "text", content: "", level, - }); + }; + nodes.push(textToken1); - nodes.push({ + const abbrOpenToken: Remarkable.AbbrOpenToken = { type: "abbr_open", title: state.env["abbreviations"][":" + m[2]], level: level++, - }); + }; + nodes.push(abbrOpenToken); - nodes.push({ + const textToken2: Remarkable.TextToken = { type: "text", content: m[2], level, - }); + }; + nodes.push(textToken2); - nodes.push({ + const abbrCloseToken: Remarkable.AbbrCloseToken = { type: "abbr_close", level: --level, - }); + }; + nodes.push(abbrCloseToken); - state.tokens.push({ + // inline token doesn't need a proper type + const inlineToken1: Remarkable.BlockContentToken = { type: "inline", content: state.src.replace(/\n/g, " ").trim(), level: 0, lines: [0, 1], children: [], - }); + }; + state.tokens.push(inlineToken1); - tokens.push({ + const inlineToken2: Remarkable.BlockContentToken = { type: "inline", content: "", level, children: [], - }); + }; + tokens.push(inlineToken2); } inlineRules() { - const state: Remarkable.Token[] = []; + const state: Remarkable.StateInline = {} as any; let level = 0; - state.push({ + const linkOpenToken1: Remarkable.LinkOpenToken = { type: "link_open", href: "", level, - }); + }; + state.push(linkOpenToken1); - state.push({ + const codeToken: Remarkable.CodeToken = { type: "code", content: "", block: false, level, - }); + }; + state.push(codeToken); - state.push({ + const footnoteRefToken1: Remarkable.FootnoteReferenceToken = { type: "footnote_ref", id: 1, level, - }); + }; + state.push(footnoteRefToken1); - state.push({ + const footnoteRefToken2: Remarkable.FootnoteReferenceToken = { type: "footnote_ref", id: 1, subId: 1, level, - }); + }; + state.push(footnoteRefToken2); - state.push({ + const imageToken: Remarkable.ImageToken = { type: "image", src: "", title: "", alt: "", level, - }); + }; + state.push(imageToken); - state.push({ + const linkOpenToken2: Remarkable.LinkOpenToken = { type: "link_open", href: "", title: "", level: level++, - }); + }; + state.push(linkOpenToken2); } }