herb 0.10.4-aarch64-linux-gnu → 0.11.1-aarch64-linux-gnu

data/templates/javascript/packages/core/src/action-view-helpers.ts.erb

@@ -6,6 +6,7 @@ export enum HelperType {
 
 export type HelperDetectStyle = "call_name" | "receiver_call"
 export type HelperOutput = "html" | "text" | "url" | "boolean" | "void" | "object"
+export type HelperReceiver = "view" | "form_builder"
 
 export interface HelperArgument {
   readonly name: string
@@ -24,6 +25,14 @@ export interface HelperOption {
   readonly description: string
 }
 
+export interface HelperBlockArgument {
+  readonly name: string
+  readonly position: number
+  readonly type: string
+  readonly optional: boolean
+  readonly description: string
+}
+
 export interface HelperImplicitAttribute {
   readonly name: string
   readonly source: string
@@ -32,6 +41,16 @@ export interface HelperImplicitAttribute {
   readonly skipWrappingFor: string[]
 }
 
+export type HelperContentSource = "first_arg" | "block_or_arg"
+
+export interface HelperContent {
+  readonly source: HelperContentSource
+  readonly argPosition: number | null
+  readonly skipIfHash: boolean
+  readonly toSSuffixWhenSingle: boolean
+  readonly positionalArgumentsWithBlock: number | null
+}
+
 export interface HelperEntry {
   readonly name: string
   readonly type: HelperType
@@ -39,6 +58,7 @@ export interface HelperEntry {
   readonly gem: string
   readonly output: HelperOutput
   readonly visibility: "public" | "internal"
+  readonly receiver: HelperReceiver
   readonly tagName: string | null
   readonly isVoid: boolean
   readonly supportsBlock: boolean
@@ -49,8 +69,10 @@ export interface HelperEntry {
   readonly signature: string
   readonly documentationURL: string
   readonly implicitAttribute: HelperImplicitAttribute | null
+  readonly content: HelperContent | null
   readonly arguments: HelperArgument[]
   readonly options: HelperOption[]
+  readonly blockArguments: HelperBlockArgument[]
   readonly specialBehaviors: string[]
   readonly aliases: string[]
 }
@@ -63,6 +85,7 @@ const <%= helper.lower_camel_case_name %>Entry: HelperEntry = {
   gem: "<%= helper.gem %>",
   output: "<%= helper.output %>",
   visibility: "<%= helper.visibility %>",
+  receiver: "<%= helper.receiver %>",
   tagName: <%= helper.tag_name ? "\"#{helper.tag_name}\"" : "null" %>,
   isVoid: <%= helper.void? %>,
   supportsBlock: <%= helper.supports_block %>,
@@ -83,6 +106,17 @@ const <%= helper.lower_camel_case_name %>Entry: HelperEntry = {
   <%- else -%>
   implicitAttribute: null,
   <%- end -%>
+  <%- if helper.content? -%>
+  content: {
+    source: "<%= helper.content.source %>",
+    argPosition: <%= helper.content.arg_position || "null" %>,
+    skipIfHash: <%= helper.content.skip_if_hash %>,
+    toSSuffixWhenSingle: <%= helper.content.to_s_suffix_when_single %>,
+    positionalArgumentsWithBlock: <%= helper.content.positional_arguments_with_block || "null" %>,
+  },
+  <%- else -%>
+  content: null,
+  <%- end -%>
   arguments: [
   <%- helper.arguments.each do |arg| -%>
     { name: "<%= arg.name %>", position: <%= arg.position %>, type: "<%= arg.type_display %>", optional: <%= arg.optional %>, default: <%= arg.default ? "\"#{arg.escaped_default}\"" : "null" %>, splat: <%= arg.splat %>, description: "<%= arg.escaped_description %>" },
@@ -93,6 +127,11 @@ const <%= helper.lower_camel_case_name %>Entry: HelperEntry = {
     { name: "<%= opt.name %>", type: "<%= opt.type_display %>", mapsTo: <%= opt.maps_to ? "\"#{opt.maps_to}\"" : "null" %>, description: "<%= opt.escaped_description %>" },
   <%- end -%>
   ],
+  blockArguments: [
+  <%- helper.block_arguments.each do |arg| -%>
+    { name: "<%= arg.name %>", position: <%= arg.position %>, type: "<%= arg.type_display %>", optional: <%= arg.optional %>, description: "<%= arg.escaped_description %>" },
+  <%- end -%>
+  ],
   specialBehaviors: [<%= helper.special_behaviors.map { |b| "\"#{b}\"" }.join(", ") %>],
   aliases: [<%= helper.aliases.map { |a| "\"#{a}\"" }.join(", ") %>],
 }
@@ -140,6 +179,10 @@ export function helperExists(name: string): boolean {
   return name in HELPER_REGISTRY
 }
 
+export function viewHelperExists(name: string): boolean {
+  return HELPER_REGISTRY[name]?.receiver === "view"
+}
+
 export function getHelpersForTag(tagName: string): HelperEntry[] {
   return HELPERS_BY_TAG_NAME[tagName] ?? []
 }
@@ -163,6 +206,10 @@ export function getHelpersByOutput(output: HelperOutput): HelperEntry[] {
   return Object.values(HELPER_REGISTRY).filter(entry => entry.output === output)
 }
 
+export function getHelpersByReceiver(receiver: HelperReceiver): HelperEntry[] {
+  return Object.values(HELPER_REGISTRY).filter(entry => entry.receiver === receiver)
+}
+
 export function getHelpersByModule(moduleName: string): HelperEntry[] {
   return Object.values(HELPER_REGISTRY).filter(entry => {
     const parts = entry.source.split("#")[0].split("::")

data/templates/javascript/packages/core/src/built-in-components.ts.erb

@@ -0,0 +1,67 @@
+export type BuiltInComponent =
+<%- slots_components.each do |component| -%>
+  | <%= component.name.inspect %>
+<%- end -%>
+
+export type ComponentAttributeType =
+<%- slots_components.flat_map { |component| component.attributes.map(&:type) }.uniq.each do |type| -%>
+  | <%= type.inspect %>
+<%- end -%>
+
+export interface ComponentAttributeDefinition {
+  name: string
+  type: ComponentAttributeType
+  description: string
+}
+
+export interface ComponentDefinition {
+  name: BuiltInComponent
+  void: boolean
+  deferred: boolean
+  parents: readonly BuiltInComponent[] | null
+  description: string
+  attributes: readonly ComponentAttributeDefinition[]
+}
+
+export const COMPONENT_DEFINITIONS: Readonly<Record<BuiltInComponent, ComponentDefinition>> = {
+<%- slots_components.each do |component| -%>
+  <%= component.name %>: {
+    name: <%= component.name.inspect %>,
+    void: <%= component.void? %>,
+    deferred: <%= component.deferred? %>,
+    parents: <%= component.parents ? "[#{component.parents.map(&:inspect).join(", ")}]" : "null" %>,
+    description: <%= component.description.inspect %>,
+<%- if component.attributes.empty? -%>
+    attributes: [],
+<%- else -%>
+    attributes: [
+<%- component.attributes.each do |attribute| -%>
+      { name: <%= attribute.name.inspect %>, type: <%= attribute.type.inspect %>, description: <%= attribute.description.inspect %> },
+<%- end -%>
+    ],
+<%- end -%>
+  },
+<%- end -%>
+}
+
+export const BUILT_IN_COMPONENTS: readonly BuiltInComponent[] = Object.keys(COMPONENT_DEFINITIONS) as BuiltInComponent[]
+
+export const BUILT_IN_COMPONENT_NAMES: ReadonlySet<string> = new Set(BUILT_IN_COMPONENTS)
+
+export const DEFERRED_COMPONENTS: ReadonlySet<string> = new Set(BUILT_IN_COMPONENTS.filter((name) => COMPONENT_DEFINITIONS[name].deferred))
+
+export function isBuiltInComponent(tagName: string | null | undefined): tagName is BuiltInComponent {
+  if (!tagName) return false
+
+  return BUILT_IN_COMPONENT_NAMES.has(tagName)
+}
+
+export function isComponentTagName(tagName: string | null | undefined): boolean {
+  if (!tagName) return false
+
+  return /^[A-Z][A-Za-z0-9]*$/.test(tagName) && /[a-z]/.test(tagName)
+}
+
+export function componentAttribute(component: BuiltInComponent, attributeName: string): ComponentAttributeDefinition | undefined {
+  return COMPONENT_DEFINITIONS[component].attributes.find((attribute) => attribute.name === attributeName)
+}

data/templates/javascript/packages/core/src/errors.ts.erb

@@ -67,8 +67,10 @@ export interface Serialized<%= error.name %> {
   <%= field.name %>: string | null;
   <%- when Herb::Template::PositionField -%>
   <%= field.name %>: SerializedPosition;
+  <%- when Herb::Template::SizeTField -%>
+  <%= field.name %>: number;
   <%- else -%>
-  <%= field.name %>: any; // <%= field.inspect %>
+  <% raise "Unexpected type: #{field.class}" %>
   <%- end -%>
   <%- end -%>
 }
@@ -87,8 +89,10 @@ export interface <%= error.name %>Props {
   <%= field.name %>: string | null;
   <%- when Herb::Template::PositionField -%>
   <%= field.name %>: Position;
+  <%- when Herb::Template::SizeTField -%>
+  <%= field.name %>: number;
   <%- else -%>
-  <%= field.name %>: any; // <%= field.inspect %>
+  <% raise "Unexpected type: #{field.class}" %>
   <%- end -%>
   <%- end -%>
 }
@@ -104,8 +108,10 @@ export class <%= error.name %> extends HerbError {
   readonly <%= field.name %>: string | null;
   <%- when Herb::Template::PositionField -%>
   readonly <%= field.name %>: Position;
+  <%- when Herb::Template::SizeTField -%>
+  readonly <%= field.name %>: number;
   <%- else -%>
-  readonly <%= field.name %>: any;
+  <% raise "Unexpected type: #{field.class}" %>
   <%- end -%>
   <%- end -%>
 

data/templates/javascript/packages/core/src/foreign-content-elements.ts.erb

@@ -0,0 +1,18 @@
+export type ForeignContentKind = "raw_text" | "rcdata"
+
+export interface ForeignContentElement {
+  name: string
+  kind: ForeignContentKind
+  endTag: boolean
+  htmlOnly: boolean
+}
+
+export const FOREIGN_CONTENT_ELEMENTS: readonly ForeignContentElement[] = [
+<%- foreign_content_elements.each do |element| -%>
+  { name: <%= element.name.inspect %>, kind: <%= element.kind.inspect %>, endTag: <%= element.end_tag? %>, htmlOnly: <%= element.html_only? %> },
+<%- end -%>
+]
+
+export const RAW_TEXT_ELEMENTS: ReadonlySet<string> = new Set([<%= foreign_content_elements.select(&:raw_text?).map { |element| element.name.inspect }.join(", ") %>])
+
+export const RCDATA_ELEMENTS: ReadonlySet<string> = new Set([<%= foreign_content_elements.select(&:rcdata?).map { |element| element.name.inspect }.join(", ") %>])

data/templates/javascript/packages/core/src/html-constants.ts.erb

@@ -0,0 +1,32 @@
+// https://html.spec.whatwg.org/multipage/common-microsyntaxes.html#boolean-attributes
+export const HTML_BOOLEAN_ATTRIBUTES = new Set([
+<%- boolean_attributes.each do |attribute| -%>
+  <%= attribute.inspect %>,
+<%- end -%>
+])
+
+export function isBooleanAttribute(attributeName: string): boolean {
+  return HTML_BOOLEAN_ATTRIBUTES.has(attributeName.toLowerCase())
+}
+
+// https://html.spec.whatwg.org/multipage/rendering.html#the-page
+export const HTML_WHITESPACE_PRESERVING_ELEMENTS: ReadonlySet<string> = new Set([
+<%- whitespace_preserving_elements.each do |element| -%>
+  <%= element.inspect %>,
+<%- end -%>
+])
+
+export function isWhitespacePreservingElement(tagName: string): boolean {
+  return HTML_WHITESPACE_PRESERVING_ELEMENTS.has(tagName.toLowerCase())
+}
+
+// https://html.spec.whatwg.org/multipage/rendering.html#phrasing-content-3
+export const HTML_INLINE_ELEMENTS: ReadonlySet<string> = new Set([
+<%- inline_elements.each do |element| -%>
+  <%= element.inspect %>,
+<%- end -%>
+])
+
+export function isInlineElement(tagName: string): boolean {
+  return HTML_INLINE_ELEMENTS.has(tagName.toLowerCase())
+}

data/templates/javascript/packages/core/src/html-elements.ts.erb

@@ -0,0 +1,41 @@
+// https://html.spec.whatwg.org/multipage/indices.html#elements-3
+// https://html.spec.whatwg.org/multipage/obsolete.html#non-conforming-features
+
+export interface HTMLElementInfo {
+  name: string
+  description: string
+  isVoid: boolean
+  isDeprecated: boolean
+}
+
+export const HTML_ELEMENTS: HTMLElementInfo[] = [
+<%- html_elements.each do |element| -%>
+  { name: <%= element.name.inspect %>, description: <%= element.description.inspect %>, isVoid: <%= element.void? %>, isDeprecated: <%= element.deprecated? %> },
+<%- end -%>
+]
+
+export const HTML_ELEMENT_NAMES = new Set(HTML_ELEMENTS.map(element => element.name))
+
+export const HTML_VOID_ELEMENTS = new Set(
+  HTML_ELEMENTS.filter(element => element.isVoid).map(element => element.name),
+)
+
+export const HTML_DEPRECATED_ELEMENTS = new Set(
+  HTML_ELEMENTS.filter(element => element.isDeprecated).map(element => element.name),
+)
+
+export function isKnownHTMLElement(tagName: string): boolean {
+  return HTML_ELEMENT_NAMES.has(tagName.toLowerCase())
+}
+
+export function isVoidElement(tagName: string): boolean {
+  return HTML_VOID_ELEMENTS.has(tagName.toLowerCase())
+}
+
+export function isDeprecatedElement(tagName: string): boolean {
+  return HTML_DEPRECATED_ELEMENTS.has(tagName.toLowerCase())
+}
+
+export function isCustomElement(tagName: string): boolean {
+  return tagName.includes("-")
+}

data/templates/javascript/packages/core/src/node-type-guards.ts.erb

@@ -1,4 +1,4 @@
-import type { Node, NodeType, ERBNode } from "./nodes.js"
+import type { Node, NodeType, ERBNode, HTMLNode } from "./nodes.js"
 
 import { Token } from "./token.js"
 import { ParseResult } from "./parse-result.js"
@@ -34,16 +34,20 @@ export function is<%= node.name %>(node: Node | null | undefined): node is <%=
 /**
  * Checks if a node is any HTML node type
  */
-export function isHTMLNode(node: Node): boolean {
-<%- html_nodes = nodes.select { |n| n.name.start_with?("HTML") } -%>
+export function isHTMLNode(node: Node | null | undefined): node is HTMLNode {
+  if (!node) return false
+
+<%- html_nodes = nodes.select(&:html?) -%>
   return <%= html_nodes.map { |n| "is#{n.name}(node)" }.join(" ||\n         ") %>
 }
 
 /**
  * Checks if a node is any ERB node type
  */
-export function isERBNode(node: Node): node is ERBNode {
-<%- erb_nodes = nodes.select { |n| n.name.start_with?("ERB") } -%>
+export function isERBNode(node: Node | null | undefined): node is ERBNode {
+  if (!node) return false
+
+<%- erb_nodes = nodes.select(&:erb_tag?) -%>
   return <%= erb_nodes.map { |n| "is#{n.name}(node)" }.join(" ||\n         ") %>
 }
 
@@ -176,7 +180,7 @@ export function areAllOfType<T extends (new (...args: any[]) => Node)[]>(
 
 export function areAllOfType(
   nodes: Node[],
-  ...types: Array<(node: Node) => boolean>
+  ...types: Array<NodeType | (new (...args: any[]) => Node) | ((node: Node) => boolean)>
 ): boolean
 
 export function areAllOfType(
@@ -220,7 +224,7 @@ export function filterNodes<T extends (new (...args: any[]) => Node)[]>(
 
 export function filterNodes(
   nodes: Node[] | undefined | null,
-  ...types: Array<(node: Node) => boolean>
+  ...types: Array<NodeType | (new (...args: any[]) => Node) | ((node: Node) => boolean)>
 ): Node[]
 
 export function filterNodes(

data/templates/javascript/packages/core/src/nodes.ts.erb

@@ -1,4 +1,5 @@
 import { Location } from "./location.js"
+import { locate, locatable } from "./locate.js"
 import { Token, SerializedToken } from "./token.js"
 import { HerbError } from "./errors.js"
 import { deserializePrismNode, inspectPrismSerialized } from "./prism/index.js"
@@ -7,9 +8,31 @@ import type { PrismNode } from "./prism/index.js"
 import type { SerializedLocation } from "./location.js"
 import type { SerializedHerbError } from "./errors.js"
 import type { Visitor } from "./visitor.js"
+import type { Position } from "./position.js"
+import type { LocateResult } from "./locate.js"
 
 export type SerializedNodeType = string
 
+type PrismNodeCacheEntry = {
+  bytes: Uint8Array
+  source: string
+  node: PrismNode | null
+}
+
+const prismNodeCache = new WeakMap<Node, PrismNodeCacheEntry>()
+
+function cachedPrismNode(owner: Node, bytes: Uint8Array, source: string): PrismNode | null {
+  const cached = prismNodeCache.get(owner)
+
+  if (cached && cached.bytes === bytes && cached.source === source) return cached.node
+
+  const node = deserializePrismNode(bytes, source)
+
+  prismNodeCache.set(owner, { bytes, source, node })
+
+  return node
+}
+
 export interface SerializedNode {
   type: SerializedNodeType
   location: SerializedLocation
@@ -42,6 +65,14 @@ export abstract class Node implements BaseNodeProps {
     this.errors = errors
   }
 
+  locate(position: Position): LocateResult | null {
+    return locate(this, position)
+  }
+
+  locatable(position: Position): boolean {
+    return locatable(this, position)
+  }
+
   setSource(source: string): void {
     this.source = source
     this.compactChildNodes().forEach(child => child.setSource(source))
@@ -50,7 +81,7 @@ export abstract class Node implements BaseNodeProps {
   toJSON(): SerializedNode {
     return {
       type: this.type,
-      location: this.location.toJSON(),
+      location: this.location ? this.location.toJSON() : (null as unknown as SerializedLocation),
       errors: this.errors,
     }
   }
@@ -72,7 +103,13 @@ export abstract class Node implements BaseNodeProps {
   }
 
   abstract treeInspect(indent?: number): string
-  abstract recursiveErrors(): HerbError[]
+  recursiveErrors(): HerbError[] {
+    const accumulator: HerbError[] = []
+    this.collectErrors(accumulator)
+    return accumulator
+  }
+
+  abstract collectErrors(accumulator: HerbError[]): void
   abstract accept(visitor: Visitor): void
   abstract childNodes(): (Node | null | undefined)[]
   abstract compactChildNodes(): Node[]
@@ -254,7 +291,7 @@ export class <%= node.name %> extends Node {
   static from(data: Serialized<%= node.name %>): <%= node.name %> {
     return new <%= node.name %>({
       type: data.type,
-      location: Location.from(data.location),
+      location: Location.fromOptional(data.location),
       errors: (data.errors || []).map(error => HerbError.from(error)),
       <%- node.fields.each do |field| -%>
       <%- case field -%>
@@ -289,6 +326,31 @@ export class <%= node.name %> extends Node {
     })
   }
 
+  static build(props: Partial<Omit<<%= node.name %>Props, "type">> = {}): <%= node.name %> {
+    return new <%= node.name %>({
+      type: "<%= node.type %>",
+      location: Location.zero,
+      errors: [],
+      <%- node.fields.each do |field| -%>
+      <%- case field -%>
+      <%- when Herb::Template::StringField, Herb::Template::ElementSourceField -%>
+      <%= field.name %>: "",
+      <%- when Herb::Template::BooleanField -%>
+      <%= field.name %>: false,
+      <%- when Herb::Template::ArrayField -%>
+      <%= field.name %>: [],
+      <%- when Herb::Template::TokenField, Herb::Template::LocationField, Herb::Template::NodeField, Herb::Template::BorrowedNodeField, Herb::Template::PrismSerializedField, Herb::Template::PrismNodeField -%>
+      <%= field.name %>: null,
+      <%- when Herb::Template::AnalyzedRubyField, Herb::Template::PrismContextField -%>
+      // no-op for <%= field.name %>
+      <%- else -%>
+      <% raise "Unhandled class #{field.class}" %>
+      <%- end -%>
+      <%- end -%>
+      ...props,
+    })
+  }
+
   constructor(props: <%= node.name %>Props) {
     super(props.type, props.location, props.errors);
     <%- node.fields.each do |field| -%>
@@ -346,22 +408,20 @@ export class <%= node.name %> extends Node {
   <%- prism_field = node.fields.find { |f| f.is_a?(Herb::Template::PrismSerializedField) || f.is_a?(Herb::Template::PrismNodeField) } -%>
   get prismNode(): PrismNode | null {
     if (!this.<%= prism_field.name %> || !this.source) return null;
-    return deserializePrismNode(this.<%= prism_field.name %>, this.source);
+    return cachedPrismNode(this, this.<%= prism_field.name %>, this.source);
   }
   <%- end -%>
 
-  recursiveErrors(): HerbError[] {
-    return [
-      ...this.errors,
-      <%- node.fields.each do |field| -%>
-      <%- case field -%>
-      <%- when Herb::Template::NodeField, Herb::Template::BorrowedNodeField -%>
-      this.<%= field.name %> ? this.<%= field.name %>.recursiveErrors() : [],
-      <%- when Herb::Template::ArrayField -%>
-      ...this.<%= field.name %>.map(node => node.recursiveErrors()),
-      <%- end -%>
-      <%- end -%>
-    ].flat();
+  collectErrors(accumulator: HerbError[]): void {
+    if (this.errors.length > 0) accumulator.push(...this.errors);
+    <%- node.fields.each do |field| -%>
+    <%- case field -%>
+    <%- when Herb::Template::NodeField, Herb::Template::BorrowedNodeField -%>
+    this.<%= field.name %>?.collectErrors(accumulator);
+    <%- when Herb::Template::ArrayField -%>
+    for (const node of this.<%= field.name %>) node.collectErrors(accumulator);
+    <%- end -%>
+    <%- end -%>
   }
 
   toJSON(): Serialized<%= node.name %> {
@@ -398,7 +458,7 @@ export class <%= node.name %> extends Node {
   treeInspect(): string {
     let output = "";
 
-    output += `@ <%= node.name %> ${this.location.treeInspectWithLabel()}\n`;
+    output += `@ <%= node.name %> ${this.location ? this.location.treeInspectWithLabel() : "(location: ∅)"}\n`;
     output += `├── errors: ${this.inspectArray(this.errors, "<%= node.fields.any? ? "│   " : "    " %>")}`;
     <%- node.field_visibilities.each do |visibility| -%>
     <%- field = visibility.field -%>
@@ -493,17 +553,40 @@ export type NodeType =
   | "<%= node.type %>"
   <%- end -%>
 
-export type ERBNodeType = Extract<NodeType, `AST_ERB_${string}`>;
+export type HTMLNodeType =
+  <%- nodes.each do |node| -%>
+    <%- next unless node.html? -%>
+  | "<%= node.type %>"
+  <%- end -%>
+
+export type HTMLNode =
+  <%- nodes.each do |node| -%>
+    <%- next unless node.html? -%>
+  | <%= node.name %>
+  <%- end -%>
+
+export const HTMLNodeClasses = [
+  <%- nodes.each do |node| -%>
+  <%- next unless node.html? -%>
+  <%= node.name %>,
+  <%- end -%>
+]
+
+export type ERBNodeType =
+  <%- nodes.each do |node| -%>
+    <%- next unless node.erb_tag? -%>
+  | "<%= node.type %>"
+  <%- end -%>
 
 export type ERBNode =
   <%- nodes.each_with_index.map do |node, index| -%>
-    <%- next unless node.name.start_with?("ERB") -%>
+    <%- next unless node.erb_tag? -%>
   | <%= node.name %>
   <%- end -%>
 
 export const ERBNodeClasses = [
   <%- nodes.each_with_index.map do |node, index| -%>
-  <%- next unless node.name.start_with?("ERB") -%>
+  <%- next unless node.erb_tag? -%>
   <%= node.name %>,
   <%- end -%>
 ]

data/templates/javascript/packages/core/src/parser-options.ts.erb

@@ -0,0 +1,41 @@
+export interface LexOptions {
+<%- parser_options.lex_fields_for(:javascript).each do |field| -%>
+  /** <%= field.description %> */
+  <%= field.snake_case %>?: <%= field.typescript_type %>
+<%- end -%>
+}
+
+export interface ParseOptions extends LexOptions {
+<%- parser_options.parse_fields_for(:javascript).each do |field| -%>
+  /** <%= field.description %> */
+  <%= field.snake_case %>?: <%= field.typescript_type %>
+<%- end -%>
+}
+
+export type SerializedParserOptions = Required<ParseOptions>
+
+export const DEFAULT_PARSER_OPTIONS: SerializedParserOptions = {
+<%- parser_options.fields_for(:javascript).each do |field| -%>
+  <%= field.snake_case %>: <%= field.js_default %>,
+<%- end -%>
+}
+
+/**
+ * Represents the parser options used during parsing.
+ */
+export class ParserOptions {
+<%- parser_options.fields_for(:javascript).each do |field| -%>
+  /** <%= field.description %> */
+  readonly <%= field.snake_case %>: <%= field.typescript_type %>
+
+<%- end -%>
+  static from(options: SerializedParserOptions): ParserOptions {
+    return new ParserOptions(options)
+  }
+
+  constructor(options: ParseOptions = {}) {
+  <%- parser_options.fields_for(:javascript).each do |field| -%>
+    this.<%= field.snake_case %> = options.<%= field.snake_case %> ?? DEFAULT_PARSER_OPTIONS.<%= field.snake_case %>
+  <%- end -%>
+  }
+}

data/templates/javascript/packages/core/src/visitor.ts.erb

@@ -47,7 +47,7 @@ export class Visitor implements IVisitor {
   <%- nodes.each do |node| -%>
   visit<%= node.name %>(node: <%= node.name %>): void {
     this.visitNode(node)
-    <%- if node.name.start_with?("ERB") -%>
+    <%- if node.erb_tag? -%>
     this.visitERBNode(node)
     <%- end -%>
     this.visitChildNodes(node)

data/templates/javascript/packages/node/extension/error_helpers.cpp.erb

@@ -42,11 +42,11 @@ napi_value <%= error.name %>FromCStruct(napi_env env, <%= error.struct_type %>*
   napi_set_named_property(env, result, "<%= field.name %>", <%= field.name %>);
 
   <%- when Herb::Template::NodeField -%>
-  napi_value <%= field.name %> = NodeFromCStruct(env, (AST_NODE_T*) <%= error.human %>-><%= field.name %>);
+  napi_value <%= field.name %> = NodeFromCStruct(env, (AST_NODE_T*) <%= error.human %>-><%= field.name %>, &HERB_DEFAULT_PARSER_OPTIONS);
   napi_set_named_property(env, result, "<%= field.name %>", <%= field.name %>);
 
   <%- when Herb::Template::TokenField -%>
-  napi_value <%= field.name %> = CreateToken(env, <%= error.human %>-><%= field.name %>);
+  napi_value <%= field.name %> = CreateToken(env, <%= error.human %>-><%= field.name %>, &HERB_DEFAULT_PARSER_OPTIONS);
   napi_set_named_property(env, result, "<%= field.name %>", <%= field.name %>);
 
   <%- when Herb::Template::TokenTypeField -%>
@@ -68,7 +68,7 @@ napi_value <%= error.name %>FromCStruct(napi_env env, <%= error.struct_type %>*
   napi_set_named_property(env, result, "<%= field.name %>", <%= field.name %>);
 
   <%- when Herb::Template::ArrayField -%>
-  napi_value <%= field.name %> = NodesArrayFromCArray(env, <%= error.human %>-><%= field.name %>);
+  napi_value <%= field.name %> = NodesArrayFromCArray(env, <%= error.human %>-><%= field.name %>, &HERB_DEFAULT_PARSER_OPTIONS);
   napi_set_named_property(env, result, "<%= field.name %>", <%= field.name %>);
 
   <%- else -%>