KaneAI - World’s First E2E Software Testing Agent.Book a Demo Join TestMu Conference

How to use AstArgument method in wpt

Best JavaScript code snippet using wpt

parser.ts

Source:parser.ts

1import { AdapterRef } from '@core/adapters';2import {3  AstArgumentImpl,4  CommandAstImpl,5  CommandContainer,6  isGenericToken,7  isNumberToken,8  isParameterToken,9  isPrefixToken,10  NullToken,11  TokenImpl,12  TokenPositionImpl,13} from '@core/command';14import {15  AstArgument,16  AstCommand,17  AstPrefix,18  BOOLEAN_LIKE_VALUES,19  ChannelMentionToken,20  CodeBlock,21  CodeBlockToken,22  CommandAst,23  CommandParameterType,24  CommandPipeline,25  CommandRoute,26  CommandTokenKind,27  DateParameterOptions,28  EmoteToken,29  GenericToken,30  GuildCtx,31  isFlagSet,32  isNil,33  NumberToken,34  ParameterConfiguration,35  ParameterToken,36  Parsable,37  ParsedAstArguments,38  Parser,39  RoleMentionToken,40  StringBuilder,41  StringExpandableToken,42  StringLikeToken,43  StringLiteralToken,44  StringTemplateToken,45  Token,46  TokenWithValue,47  UserMentionToken,48} from '@watsonjs/common';49import { Injector } from '@watsonjs/di';50import { Channel, Client, Emoji, Message, Role, User } from 'discord.js';51import { DateTime } from 'luxon';52import { format, URL } from 'url';53import { ParsingException } from '../exceptions/parsing.exception';54import { AstCommandImpl, AstPrefixImpl } from './ast';55import { CommandTokenizer } from './tokenizer';56type ParseFn<T> = (57  token: Token,58  param: ParameterConfiguration,59  ctx: ClosureCtx,60  configuration?: any,61  ...args: any[]62) => T | Promise<T>;63/**64 * Makes the passing of65 * closure reference arguments66 * a little easier67 */68interface ClosureCtx {69  nextTokenFn: NextTokenFn;70  peekTokenFn: PeekTokenFn;71  ungetTokenFn: UngetTokenFn;72  injector: Injector;73}74const STRING_LIKE_TOKEN_FLAGS =75  CommandTokenKind.Generic |76  CommandTokenKind.StringExpandable |77  CommandTokenKind.StringLiteral |78  CommandTokenKind.StringTemplate;79/**80 * A map of parameter types and the81 * token kinds they accept.82 */83const PARAMETER_TOKEN_MAP = {84  [CommandParameterType.String]: STRING_LIKE_TOKEN_FLAGS,85  [CommandParameterType.StringExpandable]: CommandTokenKind.StringExpandable,86  [CommandParameterType.StringLiteral]: CommandTokenKind.StringLiteral,87  [CommandParameterType.StringTemplate]: CommandTokenKind.StringTemplate,88  [CommandParameterType.Boolean]: STRING_LIKE_TOKEN_FLAGS,89  [CommandParameterType.Number]:90    STRING_LIKE_TOKEN_FLAGS | CommandTokenKind.Number,91  [CommandParameterType.URL]: STRING_LIKE_TOKEN_FLAGS,92  [CommandParameterType.Date]: STRING_LIKE_TOKEN_FLAGS,93  [CommandParameterType.Channel]:94    STRING_LIKE_TOKEN_FLAGS | CommandTokenKind.ChannelMention,95  [CommandParameterType.Role]:96    STRING_LIKE_TOKEN_FLAGS | CommandTokenKind.RoleMention,97  [CommandParameterType.User]:98    STRING_LIKE_TOKEN_FLAGS | CommandTokenKind.UserMention,99  [CommandParameterType.Emote]: CommandTokenKind.Emote,100  [CommandParameterType.CodeBlock]: CommandTokenKind.CodeBlock,101};102export type NextTokenFn = () => Token | null;103export type PeekTokenFn = () => Token | null;104export type UngetTokenFn = (token: Token) => void;105export class CommandParser implements Parser<CommandAst> {106  constructor(private _commandContainer: CommandContainer) {}107  public parseMessageTokens(message: Message, prefixLength: number) {108    const { content } = message;109    const tokenizer = new CommandTokenizer(this);110    return tokenizer.tokenize(content, prefixLength);111  }112  public async parseMessage(113    message: Message,114    prefixLength: number,115    pipeLine: CommandPipeline116  ): Promise<CommandAst> {117    const tokens = this.parseMessageTokens(message, prefixLength);118    return this.parseInput(tokens, pipeLine);119  }120  public async parseInput(121    tokens: Token<any>[],122    pipeLine: CommandPipeline123  ): Promise<CommandAst> {124    /**125     * These methods allow us to change the126     * state of `tokens` in this lexical scope127     * throughout the parser as well as in `Parsables`.128     *129     * ??? WHY ???130     * Doing this we can use one parser instance131     * across the app and still allow users to132     * update references to a token or such through133     * a function.134     */135    const nextTokenFn = (): Token | null => tokens.shift() ?? null;136    const peekTokenFn = () => tokens[0];137    const ungetTokenFn = (token: Token): void => {138      tokens.unshift(token);139    };140    const closureCtx: ClosureCtx = {141      injector: pipeLine.getInjector(),142      nextTokenFn,143      peekTokenFn,144      ungetTokenFn,145    };146    const prefixAst = this.getPrefixAst(nextTokenFn);147    const { commandAst, routeRef } = this.getCommandAst(closureCtx);148    const parsedArguments = await this.getArgumentsAst(routeRef, closureCtx);149    return new CommandAstImpl()150      .applyPrefix(prefixAst)151      .applyCommand(commandAst)152      .applyArguments(parsedArguments);153  }154  /** @Section Check Prefix */155  public getPrefixAst(nextTokenFn: NextTokenFn): AstPrefix {156    const prefixToken = nextTokenFn();157    if (!prefixToken) {158      throw new ParsingException(null, null, "No prefix present");159    }160    if (!isPrefixToken(prefixToken)) {161      throw new ParsingException(162        prefixToken,163        null,164        "No valid prefixToken found"165      );166    }167    return new AstPrefixImpl(prefixToken);168  }169  /** @Section Resolve Command Used */170  public getCommandAst(ctx: ClosureCtx): {171    routeRef: CommandRoute;172    commandAst: AstCommand;173  } {174    const commandToken = ctx.nextTokenFn();175    if (isNil(commandToken)) {176      throw new ParsingException(commandToken, null, "No command found");177    }178    const { text: commandText, kind } = commandToken;179    if (kind !== CommandTokenKind.Generic) {180      throw new Error("No command specified");181    }182    const routeRef = this._commandContainer.get(commandText!.toLowerCase());183    if (isNil(routeRef)) {184      throw new Error("No matching command found");185    }186    const astCommand = new AstCommandImpl(commandToken);187    const resolvedRouteRef = this.resolveSubCommand(routeRef, astCommand, ctx);188    return {189      routeRef: resolvedRouteRef,190      commandAst: astCommand,191    };192  }193  /**194   * Resolves a command route using195   * the parsed command tokens to find196   * the deepest nested command.197   */198  public resolveSubCommand(199    route: CommandRoute,200    astCommand: AstCommand,201    ctx: ClosureCtx202  ): CommandRoute {203    const { nextTokenFn, ungetTokenFn } = ctx;204    let routeRef = route;205    while (!isNil(routeRef.children)) {206      const { children } = routeRef;207      const nextToken = nextTokenFn();208      if (isNil(nextToken)) {209        break;210      }211      if (!isGenericToken(nextToken)) {212        ungetTokenFn(nextToken);213        break;214      }215      const { text } = nextToken;216      const childRef = children.get(text!.toLowerCase());217      if (isNil(childRef)) {218        ungetTokenFn(nextToken);219        break;220      }221      const { caseSensitive } = childRef.configuration;222      if (caseSensitive) {223        const hasName = childRef.hasName(text!, true);224        if (!hasName) {225          /**226           * TODO:227           * This might break bots where228           * there is a sub command which229           * requires a case sensitive name230           * but also an argument that is231           * the same string but in lower case:232           *233           * !help User - lists help for all user commands234           * !help user - Gets help for the user command235           * -----------------------------------------------236           * Should we just accept the last matched route237           * and interpret this token as an argument?238           */239          throw new Error(240            "Command was matched but does not have correct casing"241          );242        }243      }244      astCommand.applySubCommand(nextToken);245      routeRef = childRef;246    }247    return routeRef;248  }249  /** @Section Parse Arguments */250  public async getArgumentsAst(251    route: CommandRoute,252    ctx: ClosureCtx253  ): Promise<ParsedAstArguments> {254    const { params } = route;255    const { peekTokenFn } = ctx;256    const astArguments = new Map<string, AstArgument | null>();257    const parsedArguments: ParameterConfiguration[] = [];258    while (parsedArguments.length < params.length) {259      const argumentAst = await this.parseNextParameter(260        route,261        parsedArguments,262        ctx263      );264      const { name } = parsedArguments[parsedArguments.length - 1];265      astArguments.set(name, argumentAst);266    }267    // Clean up overflowing tokens268    if (!isNil(peekTokenFn())) {269      this.cleanUpTokenOverflow(astArguments, parsedArguments, ctx);270    }271    return astArguments;272  }273  /**274   * !help user @username @otherUser hey, you thingies275   *276   */277  public async parseNextParameter<T extends any = any>(278    route: CommandRoute,279    parsedParams: ParameterConfiguration[],280    ctx: ClosureCtx281  ): Promise<AstArgument<T>> {282    const { nextTokenFn } = ctx;283    const token = nextTokenFn();284    const param = this.getNextParameter(route, parsedParams)!;285    if (isNil(token)) {286      return this.parseEmptyNextToken<T>(param, parsedParams);287    }288    if (isParameterToken(token)) {289      return this.parseParameterToken<T>(route, token, parsedParams, ctx);290    }291    /**292     * At this point the next token will be a293     * regular text token in the command message:294     *295     * !help -All user296     *            ^297     */298    const { configuration, optional, default: defaultValue } = param;299    const parseFn = await this.getParseFn(param, ctx);300    let parsed: T;301    this.validateArgumentToken(token, param);302    try {303      parsed = (await parseFn(token, param, ctx, configuration)) as T;304    } catch (err: unknown) {305      if (optional) {306        return new AstArgumentImpl(307          new NullToken(),308          param,309          null310        ) as AstArgument<T>;311      }312      if (defaultValue) {313        const text = defaultValue?.toString() ?? null;314        return new AstArgumentImpl(new NullToken(text), param, text);315      }316      throw err;317    }318    return new AstArgumentImpl(token, param, parsed);319  }320  private async parseParameterToken<T extends any = any>(321    route: CommandRoute,322    paramToken: Token,323    parsedParams: ParameterConfiguration[],324    ctx: ClosureCtx325  ): Promise<AstArgument<T>> {326    const { peekTokenFn, nextTokenFn } = ctx;327    const argumentOrParameter = peekTokenFn();328    const param = this.getParameterInRouteFromToken(329      paramToken as ParameterToken,330      route331    );332    parsedParams.push(param);333    // Checking for switch parameter334    if (param.paramType === CommandParameterType.Boolean) {335      // Argument was used as switch336      if (isNil(argumentOrParameter) || isParameterToken(argumentOrParameter)) {337        parsedParams.push(param);338        return new AstArgumentImpl(paramToken, param, true) as AstArgument<T>;339      }340      if (this.isBooleanToken(argumentOrParameter)) {341        parsedParams.push(param);342        return this.parseToBoolean(343          argumentOrParameter as GenericToken,344          param345        ) as AstArgumentImpl<T>;346      }347      const { kind, position } = argumentOrParameter;348      throw new ParsingException(349        paramToken,350        param,351        `Unexpected token at position ${position}. Expected BOOLEAN got ${kind}`352      );353    }354    /** The parameter had no values */355    if (isNil(argumentOrParameter) || isParameterToken(argumentOrParameter)) {356      return this.parseEmptyNextToken(param, parsedParams);357    }358    const parseFn = await this.getParseFn<T>(param, ctx);359    const { hungry, configuration } = param;360    if (hungry) {361      return this.parseHungryArguments<T>(param, parseFn, ctx);362    }363    this.validateArgumentToken(argumentOrParameter, param);364    /** Pops `argumentOrParameter` off the tokens array */365    nextTokenFn();366    const parsed = await parseFn(367      argumentOrParameter,368      param,369      ctx,370      configuration371    );372    return new AstArgumentImpl(argumentOrParameter, param, parsed);373  }374  private async parseHungryArguments<T extends any = any>(375    param: ParameterConfiguration,376    parseFn: ParseFn<T>,377    ctx: ClosureCtx378  ): Promise<AstArgument<T>> {379    const { peekTokenFn, nextTokenFn, ungetTokenFn } = ctx;380    const { configuration, paramType } = param;381    const parsedArguments: any[] = [];382    const parsedTokens: Token[] = [];383    while (!isNil(peekTokenFn())) {384      const argumentOrParameter = nextTokenFn()!;385      // We've reached a new parameter386      if (isParameterToken(argumentOrParameter)) {387        ungetTokenFn(argumentOrParameter);388        const hungryToken = this.createHungryToken(parsedTokens);389        return new AstArgumentImpl(390          hungryToken,391          param,392          parsedArguments393        ) as AstArgumentImpl<T>;394      }395      this.validateArgumentToken(argumentOrParameter, param);396      const parsed = await parseFn(397        argumentOrParameter,398        param,399        ctx,400        configuration401      );402      parsedArguments.push(parsed);403      parsedTokens.push(argumentOrParameter);404    }405    const hungryToken = this.createHungryToken(parsedTokens);406    return new AstArgumentImpl(407      hungryToken,408      param,409      parsedArguments410    ) as AstArgumentImpl<T>;411  }412  private validateArgumentToken(413    token: Token,414    param: ParameterConfiguration415  ): void {416    const { name, paramType } = param;417    const { kind, position } = token;418    const validKinds = PARAMETER_TOKEN_MAP[paramType];419    if (!isFlagSet(kind, validKinds)) {420      throw new ParsingException(421        token,422        param,423        `Unexpected token "${token}" at position ${position} while parsing "${name}".`424      );425    }426  }427  private parseEmptyNextToken<T = any>(428    param: ParameterConfiguration,429    parsedParams: ParameterConfiguration[]430  ): AstArgument<T> {431    const { name, optional, default: defaultValue } = param;432    parsedParams.push(param);433    if (optional) {434      return new AstArgumentImpl(435        new NullToken(),436        param,437        null438      ) as AstArgument<T>;439    }440    if (defaultValue) {441      const defaultString: null | string = defaultValue?.toString() ?? null;442      return new AstArgumentImpl(443        new NullToken(defaultString),444        param,445        defaultValue446      );447    }448    throw new ParsingException(449      null,450      param,451      `Could not find required parameter with name ${name} in the command message`452    );453  }454  /**455   * If there are generic tokens at the end of456   * the token list which we didn't parse457   * before we add them to the last argument458   * parsed, given it was a generic token.459   */460  private cleanUpTokenOverflow(461    argumentAst: Map<string, AstArgument | null>,462    parsedArguments: ParameterConfiguration[],463    ctx: ClosureCtx464  ) {465    const { nextTokenFn, peekTokenFn } = ctx;466    let token = peekTokenFn()!;467    const { name, paramType } = parsedArguments[parsedArguments.length - 1];468    /**469     * We only append to `String` parameters470     * as all the other ones should be encapsulated471     * in `"`.472     */473    if (paramType !== CommandParameterType.String) {474      return;475    }476    const argumentToExpand = argumentAst.get(name)!;477    const { position } = argumentToExpand;478    const previousToken = new TokenImpl(CommandTokenKind.None, null, position);479    while (!isNil(peekTokenFn())) {480      token = nextTokenFn()!;481      /**482       * Right now we ignore non483       * generic tokens as we don't484       * have a way to concatenate485       * them with a previous token.486       */487      if (!isFlagSet(token.kind, STRING_LIKE_TOKEN_FLAGS)) {488        return;489      }490      const value = this.getValueFromStringLikeToken(token);491      argumentToExpand.value += ` ${value}`;492      argumentToExpand.text += token.text;493    }494    const { position: updatedPosition } = this.createHungryToken([495      previousToken,496      token,497    ]);498    argumentToExpand.position = updatedPosition;499  }500  /**501   * Returns the next parameter that502   * should be processed by the parser.503   */504  private getNextParameter(505    route: CommandRoute,506    parsedParams: ParameterConfiguration[]507  ): ParameterConfiguration | null {508    const { params } = route;509    for (let i = 0; i < params.length; i++) {510      const param = params[i];511      for (let y = 0; y < parsedParams.length; y++) {512        const parsed = parsedParams[y];513        if (parsed === param) {514          return param;515        }516      }517    }518    return null;519  }520  public async getParseFn<T>(521    param: ParameterConfiguration,522    ctx: ClosureCtx523  ): Promise<ParseFn<T>> {524    let fn: Function;525    const { paramType } = param;526    switch (paramType) {527      case CommandParameterType.Boolean:528        fn = this.parseToBoolean;529        break;530      case CommandParameterType.Number:531        fn = this.parseToNumber;532        break;533      case CommandParameterType.String:534        fn = this.parseToString;535        break;536      case CommandParameterType.StringExpandable:537        fn = this.parseToStringExpandable;538        break;539      case CommandParameterType.StringLiteral:540        fn = this.parseToStringLiteral;541        break;542      case CommandParameterType.StringTemplate:543        fn = this.parseToStringTemplate;544        break;545      case CommandParameterType.URL:546        fn = this.parseToUrl;547        break;548      case CommandParameterType.Date:549        fn = this.parseToDate;550        break;551      case CommandParameterType.Channel:552        fn = this.parseToChannel;553        break;554      case CommandParameterType.Role:555        fn = this.parseToRole;556        break;557      case CommandParameterType.User:558        fn = this.parseToUser;559        break;560      case CommandParameterType.Emote:561        fn = this.parseToEmote;562        break;563      case CommandParameterType.CodeBlock:564        fn = this.parseToCodeBlock;565        break;566      case CommandParameterType.Custom:567        const { injector, nextTokenFn, peekTokenFn, ungetTokenFn } = ctx;568        const parsableRef = await injector.get(param.type as typeof Parsable);569        parsableRef.parser = this;570        parsableRef.nextToken = nextTokenFn;571        parsableRef.peekToken = peekTokenFn;572        parsableRef.ungetToken = ungetTokenFn;573        // In this case we don't want574        // to bind the function to the575        // `this` context of the parser.576        return parsableRef.parse.bind(parsableRef) as ParseFn<T>;577    }578    return fn!.bind(this);579  }580  private isBooleanToken(argument: Token): boolean {581    const value = (argument as TokenWithValue).value;582    if (isNil(value)) {583      return false;584    }585    const lowerCaseValue = value.toLowerCase();586    for (let i = 0; i < BOOLEAN_LIKE_VALUES.length; i++) {587      const booleanValue = BOOLEAN_LIKE_VALUES[i];588      if (lowerCaseValue === booleanValue) {589        return true;590      }591    }592    return false;593  }594  private getParameterInRouteFromToken(595    token: ParameterToken,596    route: CommandRoute597  ) {598    const { value } = token;599    const { params } = route;600    for (let i = 0; i < params.length; i++) {601      const param = params[i];602      const { name } = param;603      if (name.toLowerCase() === value.toLowerCase()) {604        return param;605      }606    }607    throw new ParsingException(608      token,609      null,610      `A parameter cannot be found that matches parameter name "${value}" at position ${token.position}`611    );612  }613  public parseToDate(614    token: StringLikeToken,615    param: ParameterConfiguration,616    ctx: ClosureCtx,617    options: DateParameterOptions618  ): AstArgument<DateTime> {619    const { format, options: formatOptions } = options;620    const argument = new AstArgumentImpl<DateTime>(token, param);621    const dateString = this.getValueFromStringLikeToken(token);622    if (isNil(format)) {623      return argument.withValue(DateTime.fromISO(dateString, formatOptions));624    }625    return argument.withValue(626      DateTime.fromFormat(dateString, format, formatOptions)627    );628  }629  public async parseToUser(630    token: StringLikeToken | UserMentionToken,631    param: ParameterConfiguration,632    ctx: ClosureCtx633  ): Promise<AstArgument<User>> {634    const { injector } = ctx;635    const { client } = await injector.get(AdapterRef);636    let userId: string;637    if (token.kind !== CommandTokenKind.UserMention) {638      userId = token.text!;639    } else {640      userId = (token as UserMentionToken).value;641    }642    const user = await (<Client>client).users.fetch(userId);643    return new AstArgumentImpl(token, param, user);644  }645  public async parseToRole(646    token: StringLikeToken | RoleMentionToken,647    param: ParameterConfiguration,648    ctx: ClosureCtx649  ): Promise<AstArgument<Role>> {650    const { injector } = ctx;651    const guild = await injector.get(GuildCtx);652    let roleId: string;653    if (token.kind !== CommandTokenKind.RoleMention) {654      roleId = token.text!;655    } else {656      roleId = (token as RoleMentionToken).value;657    }658    const role = await guild.roles.fetch(roleId);659    return new AstArgumentImpl(token, param, role!);660  }661  public async parseToChannel(662    token: StringLikeToken | ChannelMentionToken,663    param: ParameterConfiguration,664    ctx: ClosureCtx665  ): Promise<AstArgument<Channel>> {666    const { injector } = ctx;667    const guild = await injector.get(GuildCtx);668    let channelId: string;669    if (token.kind !== CommandTokenKind.ChannelMention) {670      channelId = token.text!;671    } else {672      channelId = (token as ChannelMentionToken).value;673    }674    const channel = guild.channels.resolve(channelId);675    return new AstArgumentImpl(token, param, channel!);676  }677  public async parseToEmote(678    token: StringLikeToken | EmoteToken,679    param: ParameterConfiguration,680    ctx: ClosureCtx681  ): Promise<AstArgument<Emoji>> {682    const { injector } = ctx;683    const { client } = await injector.get(AdapterRef);684    const argument = new AstArgumentImpl(token, param);685    let emojiId: string;686    if (token.kind !== CommandTokenKind.Emote) {687      emojiId = token.text!;688    } else {689      const idOrIsEmote = (token as EmoteToken).value;690      if (isNil(idOrIsEmote)) {691        return argument.withValue(token.text);692      }693      emojiId = idOrIsEmote;694    }695    const emoji = (<Client>client).emojis.resolve(emojiId);696    return argument.withValue(emoji!);697  }698  public parseToString(699    token: StringLikeToken,700    param: ParameterConfiguration701  ): AstArgument<string> {702    const value = this.getValueFromStringLikeToken(token);703    return new AstArgumentImpl<string>(token, param, value);704  }705  public parseToCodeBlock(706    token: CodeBlockToken,707    param: ParameterConfiguration708  ): AstArgument<CodeBlock> {709    const argument = new AstArgumentImpl<CodeBlock>(token, param);710    const { language, text, value } = token;711    const codeBlock: CodeBlock = {712      code: value,713      language: language,714      raw: text!,715    };716    return argument.withValue(codeBlock);717  }718  // In the future we might allow719  // for variables in strings720  // or other templating features721  public parseToStringExpandable(722    token: StringExpandableToken,723    param: ParameterConfiguration724  ): AstArgument<string> {725    const argument = new AstArgumentImpl<string>(token, param);726    return argument.withValue(token.value);727  }728  public parseToStringLiteral(729    token: StringLiteralToken,730    param: ParameterConfiguration731  ): AstArgument<string> {732    const argument = new AstArgumentImpl<string>(token, param);733    return argument.withValue(token.value);734  }735  public parseToStringTemplate(736    token: StringTemplateToken,737    param: ParameterConfiguration738  ): AstArgument<string> {739    const argument = new AstArgumentImpl<string>(token, param);740    return argument.withValue(token.value);741  }742  public parseToBoolean(743    token: StringLikeToken,744    param: ParameterConfiguration745  ): AstArgument<boolean> {746    const boolean = this.getValueFromStringLikeToken(token);747    const inferBooleanLikeValue = () => {748      const lowerCaseValue = boolean.toLowerCase();749      for (let i = 0; i < BOOLEAN_LIKE_VALUES.length; i++) {750        const { name, value } = BOOLEAN_LIKE_VALUES[i];751        if (lowerCaseValue === name) {752          return value;753        }754      }755      return null;756    };757    const booleanLikeValue = inferBooleanLikeValue();758    const argument = new AstArgumentImpl<boolean>(token, param);759    if (!isNil(booleanLikeValue)) {760      return argument.withValue(booleanLikeValue);761    }762    return argument.withValue(Boolean(boolean));763  }764  public parseToNumber(765    token: StringLikeToken | NumberToken,766    param: ParameterConfiguration767  ): AstArgument<number> {768    const argument = new AstArgumentImpl<number>(token, param);769    const { text, position } = token;770    const checkNaN = (number: number) => {771      if (isNaN(number)) {772        throw new ParsingException(773          token,774          param,775          `Unexpected token "${text}" at position ${position}. Expected Number got NaN.`776        );777      }778    };779    if (isNumberToken(token)) {780      const number = token.value;781      checkNaN(number);782      return argument.withValue(number);783    }784    const value = this.getValueFromStringLikeToken(token);785    const number = Number(value);786    checkNaN(number);787    return argument.withValue(number);788  }789  public parseToUrl(790    token: StringLikeToken,791    param: ParameterConfiguration792  ): AstArgument<URL> {793    const url = this.getValueFromStringLikeToken(token);794    let parsed: URL;795    try {796      parsed = new URL(url);797    } catch (err) {798      throw new ParsingException(799        token,800        param,801        `Failed to parse token "${url}" of kind "${token.kind}" type URL`802      );803    }804    return new AstArgumentImpl<URL>(token, param, parsed);805  }806  private getValueFromStringLikeToken(token: StringLikeToken): string {807    return isGenericToken(token)808      ? (token.text as string)809      : ((token as StringLiteralToken).value as string);810  }811  private expectNextTokenToBeOfKind(812    peekToken: PeekTokenFn,813    ...validKinds: CommandTokenKind[]814  ): CommandTokenKind {815    const token = peekToken() ?? {};816    const { kind, position } = token as Token;817    for (let i = 0; i < validKinds.length; i++) {818      const kind = validKinds[i];819      if (kind === kind) {820        return kind;821      }822    }823    throw new ParsingException(824      token as Token,825      null,826      `Expected token at position ${position} to be one of ${validKinds.join(827        ", "828      )} but got ${kind}`829    );830  }831  /** @Section Utilities */832  private createHungryToken(tokens: Token[]): Token {833    const [{ position: firstPosition, kind }] = tokens;834    const { position: lastPosition } = tokens[tokens.length - 1];835    const { tokenStart } = firstPosition;836    const { tokenEnd } = lastPosition;837    const sb = new StringBuilder();838    for (let i = 0; i < tokens.length; i++) {839      const { text } = tokens[i];840      sb.append(text!);841      sb.append(" ");842    }843    const tokenText = sb.toString();844    const tokenPosition = new TokenPositionImpl(845      tokenText,846      tokenStart,847      tokenEnd848    );849    return new TokenImpl(kind, sb.toString(), tokenPosition);850  }...

ast.ts

Source:ast.ts

1/*2 * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one3 * or more contributor license agreements. Licensed under the Elastic License4 * 2.0 and the Server Side Public License, v 1; you may not use this file except5 * in compliance with, at your election, the Elastic License 2.0 or the Server6 * Side Public License, v 1.7 */8export type AstNode = Ast | AstFunction | AstArgument;9// eslint-disable-next-line @typescript-eslint/consistent-type-definitions10export type Ast = {11  type: 'expression';12  chain: AstFunction[];13};14// eslint-disable-next-line @typescript-eslint/consistent-type-definitions15export type AstFunction = {16  type: 'function';17  function: string;18  arguments: Record<string, AstArgument[]>;19};20export type AstArgument = string | boolean | number | Ast;21interface WithMeta<T> {22  start: number;23  end: number;24  text: string;25  node: T;26}27type Replace<T, R> = Pick<T, Exclude<keyof T, keyof R>> & R;28type WrapAstArgumentWithMeta<T> = T extends Ast ? AstWithMeta : WithMeta<T>;29export type AstArgumentWithMeta = WrapAstArgumentWithMeta<AstArgument>;30export type AstFunctionWithMeta = WithMeta<31  Replace<32    AstFunction,33    {34      arguments: {35        [key: string]: AstArgumentWithMeta[];36      };37    }38  >39>;40export type AstWithMeta = WithMeta<41  Replace<42    Ast,43    {44      chain: AstFunctionWithMeta[];45    }46  >47>;48export function isAstWithMeta(value: any): value is AstWithMeta {49  return typeof value?.node === 'object';50}51export function isAst(value: any): value is Ast {52  return typeof value === 'object' && value?.type === 'expression';...

AstDeclareFunction.ts

Source:AstDeclareFunction.ts

1ï»¿import { Location } from 'earley';2import { AstArgument } from './AstArgument';3import { CodeGenerator } from '../CodeGenerator';4import { TypeChecker } from '../TypeChecker';5export class AstDeclareFunction {6  type: any = null; // calculated later7  hasBody = false; // Set to true during type checking if sub is later8  used = false;9  /** @constructor */10  constructor(11    public location: Location,12    public name: string,13    public args: AstArgument[],14    public isFunction: boolean,15    readonly typeName?: string16  ) {17    // this.locus = locus;18    // this.name = name;19    // this.args = args; // array of AstArgument20    // this.isFunction = isFunction;21    this.type = null; // calculated later22    this.hasBody = false; // Set to true during type checking if sub is later23    // implemented.24    this.used = false;25  }26  accept(visitor: CodeGenerator | TypeChecker) {27    visitor.visitDeclareFunction(this);28  }...

Using AI Code Generation

1var wpt = require('webpagetest');2    videoParams: {3    },4    timelineParams: {5    },6    browserUserAgent: 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_10_5) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/45.0.2454.85 Safari/537.36',7    browserConnectionExtraHeaders: {8    },

Using AI Code Generation

1var wpt = require('webpagetest');2var api = new wpt('API_KEY');3var options = {4    videoParams: {5    },6    lighthouseConfig: {7        settings: {8        }9    },10    lighthouseThrottling: {11    },12    lighthouseBudget: {

Using AI Code Generation

1var wpt = require('./wpt.js');2var wpt = new WebPageTest('www.webpagetest.org', 'APIKEY');3wpt.runTest(url, { location: 'Dulles:Chrome', runs: 1, pollResults: 1, firstViewOnly: 1 }, function(err, data) {4    if (err) return console.error(err);5    console.log('Test status: ' + data.statusText);6    console.log('View the test at: ' + data.data.userUrl);7});

Using AI Code Generation

1var wptools = require('wptools');2var wiki = new wptools('Barack Obama');3wiki.get(function(err, resp) {4  if (!err) {5    console.log(resp.data.image[0]);6  }7});8var wptools = require('wptools');9var wiki = new wptools('Barack Obama');10wiki.get(function(err, resp) {11  if (!err) {12    console.log(resp.data.image[0]);13  }14});15var wptools = require('wptools');16var wiki = new wptools('Barack Obama');17wiki.get(function(err, resp) {18  if (!err) {19    console.log(resp.data.image[0]);20  }21});22var wptools = require('wptools');23var wiki = new wptools('Barack Obama');24wiki.get(function(err, resp) {25  if (!err) {26    console.log(resp.data.image[0]);27  }28});29var wptools = require('wptools');30var wiki = new wptools('Barack Obama');31wiki.get(function(err, resp) {32  if (!err) {33    console.log(resp.data.image[0]);34  }35});36var wptools = require('wptools');37var wiki = new wptools('Barack Obama');38wiki.get(function(err, resp) {39  if (!err) {40    console.log(resp.data.image[0]);41  }42});43var wptools = require('wptools');44var wiki = new wptools('Barack Obama');45wiki.get(function(err, resp) {46  if (!err) {47    console.log(resp.data.image[0]);48  }49});50var wptools = require('wptools');51var wiki = new wptools('Barack Obama');52wiki.get(function(err,

Using AI Code Generation

1import AstArgument from 'wpt/ast/ast-argument.js';2import AstExpression from 'wpt/ast/ast-expression.js';3import AstIdentifier from 'wpt/ast/ast-identifier.js';4import AstLiteral from 'wpt/ast/ast-literal.js';5import AstMemberExpression from 'wpt/ast/ast-member-expression.js';6import AstNewExpression from 'wpt/ast/ast-new-expression.js';7import AstObjectExpression from 'wpt/ast/ast-object-expression.js';8import AstProgram from 'wpt/ast/ast-program.js';9import AstProperty from 'wpt/ast/ast-property.js';10import AstSequenceExpression from 'wpt/ast/ast-sequence-expression.js';11import AstStatement from 'wpt/ast/ast-statement.js';12import AstVariableDeclaration from 'wpt/ast/ast-variable-declaration.js';13import AstVariableDeclarator from 'wpt/ast/ast-variable-declarator.js';14var program = new AstProgram('Program', 'Program', 'Program');15program.body = [];16var body = program.body;17var varDecl = new AstVariableDeclaration('VariableDeclaration', 'VariableDeclaration', 'VariableDeclaration');18varDecl.declarations = [];19varDecl.kind = 'var';20var decl = new AstVariableDeclarator('VariableDeclarator', 'VariableDeclarator', 'VariableDeclarator');21decl.init = new AstLiteral('Literal', 'Literal', 'Literal', '1');22decl.id = new AstIdentifier('Identifier', 'Identifier', 'Identifier', 'a');23varDecl.declarations.push(decl);24body.push(varDecl);25varDecl = new AstVariableDeclaration('VariableDeclaration', 'VariableDeclaration', 'VariableDeclaration');26varDecl.declarations = [];27varDecl.kind = 'var';28decl = new AstVariableDeclarator('VariableDeclarator', 'VariableDeclarator', 'VariableDeclarator');29decl.init = new AstIdentifier('Identifier', 'Identifier', 'Identifier', 'a');30decl.id = new AstIdentifier('Identifier', 'Identifier', 'Identifier', 'b');31varDecl.declarations.push(decl);32body.push(varDecl);

Using AI Code Generation

1var wptools = require('wptools');2var fs = require('fs');3var wiki = new wptools();4wiki.setPage('Barack Obama');5wiki.setLang('en');6wiki.setFormat('json');7wiki.setArguments('action', 'parse');8wiki.setCallback(function (err, data) {9    if (err) {10        console.log(err);11    } else {12        console.log(data);13    }14});15wiki.AstArgument();16var wptools = require('wptools');17var fs = require('fs');18var wiki = new wptools();19wiki.setPage('Barack Obama');20wiki.setLang('en');21wiki.setFormat('json');22wiki.setArguments('action', 'parse');23wiki.setCallback(function (err, data) {24    if (err) {25        console.log(err);26    } else {27        console.log(data);28    }29});30wiki.AstCallback();

Using AI Code Generation

1var wptoolkit = require('wptoolkit');2var wp = new wptoolkit();3  if (!error && response.statusCode == 200) {4  }5})6var wptoolkit = require('wptoolkit');7var wp = new wptoolkit();8  if (!error && response.statusCode == 200) {9  }10})11var wptoolkit = require('wptoolkit');12var wp = new wptoolkit();13  if (!error && response.statusCode == 200) {14  }15})16var wptoolkit = require('wptoolkit');17var wp = new wptoolkit();18  if (!error && response.statusCode == 200) {19  }20})21var wptoolkit = require('wptoolkit');22var wp = new wptoolkit();23  if (!error && response.statusCode == 200) {24  }25})

Automation Testing Tutorials

Learn to execute automation testing from scratch with LambdaTest Learning Hub. Right from setting up the prerequisites to run your first automation test, to following best practices and diving deeper into advanced test scenarios. LambdaTest Learning Hubs compile a list of step-by-step guides to help you be proficient with different test automation frameworks i.e. Selenium, Cypress, TestNG etc.