Method parseJsEventDirectives

packages/core/src/compiler/parser.ts:656–714

(
    parentKeyword: Keyword,
    directiveId: string
  )

  }

  private parseJsEventDirectives(
    parentKeyword: Keyword,
    directiveId: string
  ): JsEventDirective[] {
    const { directives, blockToken } =
      this.parseDirectiveGroup<JsEventDirective>({
        parseDirective: () => {
          const onToken = this.consume(
            TokenType.IDENTIFIER,
            `Unexpected identifier in <${parentKeyword.name}>`
          );
          if (onToken.value !== "on") {
            throw new ParserError(
              `Unexpected identifier '${onToken.value}' inside <${parentKeyword.name}>`,
              onToken.position
            );
          }

          this.consume(
            TokenType.COLON,
            `Expected ':' after 'on' in <${parentKeyword.name}>`
          );

          const eventToken = this.consume(
            TokenType.IDENTIFIER,
            `Expected event name after 'on:' in <${parentKeyword.name}>`
          );

          if (!isJsEvent(eventToken.value)) {
            throw new ParserError(
              `Unknown JavaScript event '${eventToken.value}'`,
              eventToken.position
            );
          }

          return {
            type: "JsEvent",
            name: eventToken.value,
            dataId: directiveId,
            block: "",
            position: onToken.position,
          } satisfies JsEventDirective;
        },
        hasNext: () =>
          this.check(TokenType.COMMA) &&
          this.peek(1).type === TokenType.IDENTIFIER &&
          this.peek(1).value === "on" &&
          this.peek(2).type === TokenType.COLON,
        separatorMessage: "Expected ',' between JavaScript events",
        blockMessageFor: (directive) =>
          `Expected block for event '${directive.name}' in <${parentKeyword.name}>`,
      });

    const blockValue = blockToken.value;
    return directives.map((directive) => ({
      ...directive,
      block: blockValue,
    }));