From c99cb3c8e3012895e4f66fd6636e246454822012 Mon Sep 17 00:00:00 2001 From: Shinigami Date: Fri, 1 May 2020 18:09:20 +0200 Subject: [PATCH] TypeScript definitions for pug-tokens (#3196) --- packages/pug-lexer/index.d.ts | 338 ++++++++++++++++++++++++++++++++++ 1 file changed, 338 insertions(+) create mode 100644 packages/pug-lexer/index.d.ts diff --git a/packages/pug-lexer/index.d.ts b/packages/pug-lexer/index.d.ts new file mode 100644 index 000000000..a5c3addf4 --- /dev/null +++ b/packages/pug-lexer/index.d.ts @@ -0,0 +1,338 @@ +declare module 'pug-lexer' { + namespace lex { + export interface Loc { + start: { line: number; column: number }; + end: { line: number; column: number }; + } + + export type LexTokenType = + | ':' + | '&attributes' + | 'attribute' + | 'block' + | 'blockcode' + | 'call' + | 'case' + | 'class' + | 'code' + | 'comment' + | 'default' + | 'doctype' + | 'dot' + | 'each' + | 'else-if' + | 'else' + | 'end-attributes' + | 'end-pipeless-text' + | 'end-pug-interpolation' + | 'eos' + | 'extends' + | 'filter' + | 'id' + | 'if' + | 'include' + | 'indent' + | 'interpolated-code' + | 'interpolation' + | 'mixin-block' + | 'mixin' + | 'newline' + | 'outdent' + | 'path' + | 'slash' + | 'start-attributes' + | 'start-pipeless-text' + | 'start-pug-interpolation' + | 'tag' + | 'text-html' + | 'text' + | 'when' + | 'while' + | 'yield'; + + export interface LexToken { + type: Type; + loc: Loc; + } + + export interface TagToken extends LexToken<'tag'> { + val: string; + } + + export type StartAttributesToken = LexToken<'start-attributes'>; + + export interface AttributeToken extends LexToken<'attribute'> { + name: string; + val: string | boolean; + mustEscape: boolean; + } + + export type EndAttributesToken = LexToken<'end-attributes'>; + + export interface IndentToken extends LexToken<'indent'> { + val: number; + } + + export interface ClassToken extends LexToken<'class'> { + val: string; + } + + export type OutdentToken = LexToken<'outdent'>; + + export type EosToken = LexToken<'eos'>; + + export interface CommentToken extends LexToken<'comment'> { + val: string; + buffer: boolean; + } + + export type NewlineToken = LexToken<'newline'>; + + export interface TextToken extends LexToken<'text'> { + val: string; + } + + export interface InterpolatedCodeToken extends LexToken<'interpolated-code'> { + mustEscape: boolean; + buffer: boolean; + val: string; + } + + export interface CodeToken extends LexToken<'code'> { + val: string; + mustEscape: boolean; + buffer: boolean; + } + + export interface IdToken extends LexToken<'id'> { + val: string; + } + + export type StartPipelessTextToken = LexToken<'start-pipeless-text'>; + + export type EndPipelessTextToken = LexToken<'end-pipeless-text'>; + + export interface DoctypeToken extends LexToken<'doctype'> { + val: string; + } + + export type DotToken = LexToken<'dot'>; + + export interface BlockToken extends LexToken<'block'> { + val: string; + mode: 'replace' | 'prepend' | 'append'; + } + + export type ExtendsToken = LexToken<'extends'>; + + export interface PathToken extends LexToken<'path'> { + val: string; + } + + export type StartPugInterpolationToken = LexToken<'start-pug-interpolation'>; + + export type EndPugInterpolationToken = LexToken<'end-pug-interpolation'>; + + export interface InterpolationToken extends LexToken<'interpolation'> { + val: string; + } + + export type IncludeToken = LexToken<'include'>; + + export interface FilterToken extends LexToken<'filter'> { + val: string; + } + + export interface CallToken extends LexToken<'call'> { + val: string; + args: string; + } + + export interface MixinToken extends LexToken<'mixin'> { + val: string; + args: string | null; + } + + export interface IfToken extends LexToken<'if'> { + val: string; + } + + export type MixinBlockToken = LexToken<'mixin-block'>; + + export interface ElseToken extends LexToken<'else'> { + val: string; + } + + export interface AndAttributesToken extends LexToken<'&attributes'> { + val: string; + } + + export interface TextHtmlToken extends LexToken<'text-html'> { + val: string; + } + + export interface EachToken extends LexToken<'each'> { + val: string; + key: string | null; + code: string; + } + + export interface WhileToken extends LexToken<'while'> { + val: string; + } + + export interface CaseToken extends LexToken<'case'> { + val: string; + } + + export interface WhenToken extends LexToken<'when'> { + val: string; + } + + export type ColonToken = LexToken<':'>; + + export type DefaultToken = LexToken<'default'>; + + export interface ElseIfToken extends LexToken<'else-if'> { + val: string; + } + + export type BlockcodeToken = LexToken<'blockcode'>; + + export type YieldToken = LexToken<'yield'>; + + export type SlashToken = LexToken<'slash'>; + + export type Token = + | AndAttributesToken + | AttributeToken + | BlockcodeToken + | BlockToken + | CallToken + | CaseToken + | ClassToken + | CodeToken + | ColonToken + | CommentToken + | DefaultToken + | DoctypeToken + | DotToken + | EachToken + | ElseIfToken + | ElseToken + | EndAttributesToken + | EndPipelessTextToken + | EndPugInterpolationToken + | EosToken + | ExtendsToken + | FilterToken + | IdToken + | IfToken + | IncludeToken + | IndentToken + | InterpolatedCodeToken + | InterpolationToken + | MixinBlockToken + | MixinToken + | NewlineToken + | OutdentToken + | PathToken + | SlashToken + | StartAttributesToken + | StartPipelessTextToken + | StartPugInterpolationToken + | TagToken + | TextHtmlToken + | TextToken + | WhenToken + | WhileToken + | YieldToken; + + export type LexerFunction = (type: string, exp?: any) => boolean; + export interface LexerOptions { + filename: string; + interpolated?: boolean; + startingLine?: number; + startingColumn?: number; + plugins?: LexerFunction[]; + } + export class Lexer { + input: string; + originalInput: string; + filename?: string; + interpolated: boolean; + lineno: number; + colno: number; + plugins: LexerFunction[]; + indentStack: number[]; + indentRe: RegExp | null; + interpolationAllowed: boolean; + whitespaceRe: RegExp; + tokens: Token[]; + ended: boolean; + constructor(str: string, options?: LexerOptions); + error(code: string, message: string): never; + assert(value: any, message: string): void; + isExpression(exp: string): boolean; + assertExpression(exp: string, noThrow?: boolean): boolean; + assertNestingCorrect(exp: string): void; + private tok(type: Type, val?: any): LexToken; + private tokEnd(tok: LexToken): LexToken; + private incrementLine(increment: number): void; + private incrementColumn(increment: number): void; + private consume(len: number): void; + private scan(regexp: RegExp, type: Type): LexToken | undefined; + private scanEndOfLine(regexp: RegExp, type: Type): LexToken | undefined; + private bracketExpression(skip?: number): number; + scanIndentation(): RegExpExecArray | null; + eos(): true | undefined; + blank(): true | undefined; + comment(): true | undefined; + interpolation(): true | undefined; + tag(): true | undefined; + filter(): true | undefined; + doctype(): true | undefined; + id(): true | undefined; + className(): true | undefined; + endInterpolation(): true | undefined; + addText(type: LexTokenType, value: string, prefix?: string, escaped?: number): void; + text(): true | undefined; + textHtml(): true | undefined; + dot(): true | undefined; + extends(): true | undefined; + prepend(): true | undefined; + append(): true | undefined; + block(): true | undefined; + mixinBlock(): true | undefined; + yield(): true | undefined; + include(): true | undefined; + path(): true | undefined; + case(): true | undefined; + when(): true | undefined; + default(): true | undefined; + call(): true | undefined; + mixin(): true | undefined; + conditional(): true | undefined; + while(): true | undefined; + each(): true | undefined; + eachOf(): true | undefined; + code(): true | undefined; + blockCode(): true | undefined; + attribute(): string; + attributeValue(str: string): { val?: string; mustEscape?: boolean; remainingSource: string }; + attrs(): true | undefined; + attributesBlock(): true | undefined; + indent(): true | NewlineToken | undefined; + pipelessText(indents?: number): boolean | undefined; + slash(): true | undefined; + colon(): true | undefined; + fail(): never; + callLexerFunction(func: string): boolean; + private advance(): boolean; + getTokens(): Token[]; + } + } + function lex(str: string, options?: lex.LexerOptions): lex.Token[]; + export = lex; +} +