herb 0.10.3-x86-linux-gnu → 0.11.0-x86-linux-gnu

data/templates/java/org/herb/ast/HelperRegistry.java.erb

@@ -5,34 +5,6 @@ import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Map;
 
-/**
- * Type enum for all supported Action View tag helpers.
- */
-public enum HelperType {
-<%- helpers.each_with_index do |helper, index| -%>
-  <%= helper.constant_name %>("<%= helper.name %>")<%= index < helpers.size - 1 ? "," : ";" %>
-<%- end -%>
-
-  private final String name;
-
-  HelperType(String name) {
-    this.name = name;
-  }
-
-  public String getName() {
-    return name;
-  }
-
-  public static HelperType fromName(String name) {
-    for (HelperType type : values()) {
-      if (type.name.equals(name)) {
-        return type;
-      }
-    }
-    return null;
-  }
-}
-
 /**
  * Argument metadata for a tag helper.
  */
@@ -86,6 +58,28 @@ class HelperOption {
   public String getDescription() { return description; }
 }
 
+class HelperBlockArgument {
+  private final String name;
+  private final int position;
+  private final String type;
+  private final boolean optional;
+  private final String description;
+
+  HelperBlockArgument(String name, int position, String type, boolean optional, String description) {
+    this.name = name;
+    this.position = position;
+    this.type = type;
+    this.optional = optional;
+    this.description = description;
+  }
+
+  public String getName() { return name; }
+  public int getPosition() { return position; }
+  public String getType() { return type; }
+  public boolean isOptional() { return optional; }
+  public String getDescription() { return description; }
+}
+
 /**
  * Implicit attribute metadata for a tag helper.
  */
@@ -108,6 +102,31 @@ class HelperImplicitAttribute {
   public String getWrapper() { return wrapper; }
 }
 
+/**
+ * Content metadata describing where a helper takes its rendered content from.
+ */
+class HelperContent {
+  private final String source;
+  private final Integer argPosition;
+  private final boolean skipIfHash;
+  private final boolean toSSuffixWhenSingle;
+  private final Integer positionalArgumentsWithBlock;
+
+  HelperContent(String source, Integer argPosition, boolean skipIfHash, boolean toSSuffixWhenSingle, Integer positionalArgumentsWithBlock) {
+    this.source = source;
+    this.argPosition = argPosition;
+    this.skipIfHash = skipIfHash;
+    this.toSSuffixWhenSingle = toSSuffixWhenSingle;
+    this.positionalArgumentsWithBlock = positionalArgumentsWithBlock;
+  }
+
+  public String getSource() { return source; }
+  public Integer getArgPosition() { return argPosition; }
+  public boolean skipIfHash() { return skipIfHash; }
+  public boolean toSSuffixWhenSingle() { return toSSuffixWhenSingle; }
+  public Integer getPositionalArgumentsWithBlock() { return positionalArgumentsWithBlock; }
+}
+
 /**
  * Registry entry containing all metadata for a single tag helper.
  */
@@ -118,6 +137,7 @@ class HelperEntry {
   private final String gem;
   private final String output;
   private final String visibility;
+  private final String receiver;
   private final String tagName;
   private final boolean isVoid;
   private final boolean supportsBlock;
@@ -128,16 +148,19 @@ class HelperEntry {
   private final String signature;
   private final String documentationUrl;
   private final HelperImplicitAttribute implicitAttribute;
+  private final HelperContent content;
   private final List<HelperArgument> arguments;
   private final List<HelperOption> options;
+  private final List<HelperBlockArgument> blockArguments;
   private final List<String> specialBehaviors;
   private final List<String> aliases;
 
   HelperEntry(
-    String name, HelperType type, String source, String gem, String output, String visibility, String tagName,
+    String name, HelperType type, String source, String gem, String output, String visibility, String receiver, String tagName,
     boolean isVoid, boolean supportsBlock, boolean preferredForTag, boolean supported, String detectStyle, String description,
-    String signature, String documentationUrl, HelperImplicitAttribute implicitAttribute,
-    List<HelperArgument> arguments, List<HelperOption> options, List<String> specialBehaviors, List<String> aliases
+    String signature, String documentationUrl, HelperImplicitAttribute implicitAttribute, HelperContent content,
+    List<HelperArgument> arguments, List<HelperOption> options, List<HelperBlockArgument> blockArguments,
+    List<String> specialBehaviors, List<String> aliases
   ) {
     this.name = name;
     this.type = type;
@@ -145,6 +168,7 @@ class HelperEntry {
     this.gem = gem;
     this.output = output;
     this.visibility = visibility;
+    this.receiver = receiver;
     this.tagName = tagName;
     this.isVoid = isVoid;
     this.supportsBlock = supportsBlock;
@@ -155,8 +179,10 @@ class HelperEntry {
     this.signature = signature;
     this.documentationUrl = documentationUrl;
     this.implicitAttribute = implicitAttribute;
+    this.content = content;
     this.arguments = arguments;
     this.options = options;
+    this.blockArguments = blockArguments;
     this.specialBehaviors = specialBehaviors;
     this.aliases = aliases;
   }
@@ -167,6 +193,7 @@ class HelperEntry {
   public String getGem() { return gem; }
   public String getOutput() { return output; }
   public String getVisibility() { return visibility; }
+  public String getReceiver() { return receiver; }
   public String getTagName() { return tagName; }
   public boolean isVoid() { return isVoid; }
   public boolean supportsBlock() { return supportsBlock; }
@@ -177,8 +204,10 @@ class HelperEntry {
   public String getSignature() { return signature; }
   public String getDocumentationUrl() { return documentationUrl; }
   public HelperImplicitAttribute getImplicitAttribute() { return implicitAttribute; }
+  public HelperContent getContent() { return content; }
   public List<HelperArgument> getArguments() { return arguments; }
   public List<HelperOption> getOptions() { return options; }
+  public List<HelperBlockArgument> getBlockArguments() { return blockArguments; }
   public List<String> getSpecialBehaviors() { return specialBehaviors; }
   public List<String> getAliases() { return aliases; }
 }
@@ -210,6 +239,7 @@ public final class HelperRegistry {
         "<%= helper.gem %>",
         "<%= helper.output %>",
         "<%= helper.visibility %>",
+        "<%= helper.receiver %>",
         <%= helper.tag_name ? "\"#{helper.tag_name}\"" : "null" %>,
         <%= helper.void? %>,
         <%= helper.supports_block %>,
@@ -223,9 +253,15 @@ public final class HelperRegistry {
         new HelperImplicitAttribute("<%= helper.implicit_attribute.name %>", "<%= helper.implicit_attribute.source %>", <%= helper.implicit_attribute.source_with_block ? "\"#{helper.implicit_attribute.source_with_block}\"" : "null" %>, "<%= helper.implicit_attribute.wrapper %>"),
 <%- else -%>
         null,
+<%- end -%>
+<%- if helper.content? -%>
+        new HelperContent("<%= helper.content.source %>", <%= helper.content.arg_position || "null" %>, <%= helper.content.skip_if_hash %>, <%= helper.content.to_s_suffix_when_single %>, <%= helper.content.positional_arguments_with_block || "null" %>),
+<%- else -%>
+        null,
 <%- end -%>
         List.of(<%= helper.arguments.map { |arg| "new HelperArgument(\"#{arg.name}\", #{arg.position}, \"#{arg.type_display}\", #{arg.optional}, #{arg.default ? "\"#{arg.escaped_default}\"" : "null"}, #{arg.splat}, \"#{arg.escaped_description}\")" }.join(", ") %>),
         List.of(<%= helper.options.map { |opt| "new HelperOption(\"#{opt.name}\", \"#{opt.type_display}\", #{opt.maps_to ? "\"#{opt.maps_to}\"" : "null"}, \"#{opt.escaped_description}\")" }.join(", ") %>),
+        List.of(<%= helper.block_arguments.map { |arg| "new HelperBlockArgument(\"#{arg.name}\", #{arg.position}, \"#{arg.type_display}\", #{arg.optional}, \"#{arg.escaped_description}\")" }.join(", ") %>),
         List.of(<%= helper.special_behaviors.map { |b| "\"#{b}\"" }.join(", ") %>),
         List.of(<%= helper.aliases.map { |a| "\"#{a}\"" }.join(", ") %>)
       );

data/templates/java/org/herb/ast/HelperType.java.erb

@@ -0,0 +1,29 @@
+package org.herb.ast;
+
+/**
+ * Type enum for all supported Action View tag helpers.
+ */
+public enum HelperType {
+<%- helpers.each_with_index do |helper, index| -%>
+  <%= helper.constant_name %>("<%= helper.name %>")<%= index < helpers.size - 1 ? "," : ";" %>
+<%- end -%>
+
+  private final String name;
+
+  HelperType(String name) {
+    this.name = name;
+  }
+
+  public String getName() {
+    return name;
+  }
+
+  public static HelperType fromName(String name) {
+    for (HelperType type : values()) {
+      if (type.name.equals(name)) {
+        return type;
+      }
+    }
+    return null;
+  }
+}

data/templates/java/org/herb/ast/Nodes.java.erb

@@ -162,7 +162,7 @@ class <%= node.name %> extends BaseNode {
   public String inspect(String source) {
     StringBuilder output = new StringBuilder();
 
-    output.append("@ <%= node.name %> ").append(location != null ? "(location: " + location.toString() + ")" : "no-location").append("\n");
+    output.append("@ <%= node.name %> ").append("(location: " + (location != null ? location.toString() : "∅") + ")").append("\n");
     <%- if node.fields.any? -%>
     output.append(inspectErrors("│   "));
     <%- else -%>
@@ -250,10 +250,16 @@ class <%= node.name %> extends BaseNode {
 
   @Override
   public List<Node> recursiveErrors() {
-    List<Node> result = new ArrayList<>();
+    List<Node> accumulator = new ArrayList<>();
+    collectErrors(accumulator);
 
+    return accumulator;
+  }
+
+  @Override
+  protected void collectErrors(List<Node> accumulator) {
     if (errors != null) {
-      result.addAll(errors);
+      accumulator.addAll(errors);
     }
 
     <%- if node.fields.any? -%>
@@ -263,21 +269,19 @@ class <%= node.name %> extends BaseNode {
     if (<%= field.name %> != null) {
       for (Node child : <%= field.name %>) {
         if (child != null) {
-          result.addAll(child.recursiveErrors());
+          ((BaseNode) child).collectErrors(accumulator);
         }
       }
     }
 
     <%- elsif field.is_a?(Herb::Template::NodeField) || field.is_a?(Herb::Template::BorrowedNodeField) -%>
     if (<%= field.name %> != null) {
-      result.addAll(<%= field.name %>.recursiveErrors());
+      ((BaseNode) <%= field.name %>).collectErrors(accumulator);
     }
 
     <%- end -%>
     <%- end -%>
     <%- end -%>
-
-    return result;
   }
 
   @Override

data/templates/java/parser_options_helpers.c.erb

@@ -0,0 +1,45 @@
+#include "parser_options_helpers.h"
+
+void herb_extract_parser_options(JNIEnv* env, jobject options, parser_options_T* parser_options) {
+  if (options == NULL) { return; }
+
+  jclass optionsClass = (*env)->GetObjectClass(env, options);
+<%- parser_options.extractable_fields_for(:java).each do |field| -%>
+
+<%- if field.boolean? -%>
+  {
+    jmethodID method = (*env)->GetMethodID(env, optionsClass, "<%= field.java_getter %>", "<%= field.java_jni_signature %>");
+
+    if (method != NULL) {
+      jboolean value = (*env)->CallBooleanMethod(env, options, method);
+      parser_options-><%= field.c_name %> = (value == JNI_TRUE);
+    }
+  }
+<%- elsif field.nullable? -%>
+  {
+    jmethodID method = (*env)->GetMethodID(env, optionsClass, "<%= field.java_getter %>", "<%= field.java_jni_signature %>");
+
+    if (method != NULL) {
+      jobject value = (*env)->CallObjectMethod(env, options, method);
+
+      if (value == NULL) {
+        parser_options-><%= field.c_name %> = <%= field.null_sentinel %>;
+      } else {
+        jclass integerClass = (*env)->FindClass(env, "java/lang/Integer");
+        jmethodID intValue = (*env)->GetMethodID(env, integerClass, "intValue", "()I");
+        parser_options-><%= field.c_name %> = (uint32_t) (*env)->CallIntMethod(env, value, intValue);
+      }
+    }
+  }
+<%- else -%>
+  {
+    jmethodID method = (*env)->GetMethodID(env, optionsClass, "<%= field.java_getter %>", "<%= field.java_jni_signature %>");
+
+    if (method != NULL) {
+      jint value = (*env)->CallIntMethod(env, options, method);
+      parser_options-><%= field.c_name %> = (uint32_t) value;
+    }
+  }
+<%- end -%>
+<%- end -%>
+}

data/templates/java/parser_options_helpers.h.erb

@@ -0,0 +1,10 @@
+#ifndef HERB_JAVA_PARSER_OPTIONS_HELPERS_H
+#define HERB_JAVA_PARSER_OPTIONS_HELPERS_H
+
+#include "../src/include/parser/parser_options.h"
+
+#include <jni.h>
+
+void herb_extract_parser_options(JNIEnv* env, jobject options, parser_options_T* parser_options);
+
+#endif

data/templates/javascript/packages/client/src/state-kinds.ts.erb

@@ -0,0 +1,49 @@
+export type StateDefaultKind =
+<%- state_kinds.each do |kind| -%>
+  | <%= kind.name.inspect %>
+<%- end -%>
+
+export type StateValueKind =
+<%- state_kinds.select(&:value?).each do |kind| -%>
+  | <%= kind.name.inspect %>
+<%- end -%>
+
+export const STATE_DEFAULT_KINDS: readonly StateDefaultKind[] = [<%= state_kinds.map { |kind| kind.name.inspect }.join(", ") %>]
+
+export const LITERAL_STATE_KINDS: ReadonlySet<string> = new Set([<%= state_kinds.select(&:literal?).map { |kind| kind.name.inspect }.join(", ") %>])
+
+export const UNKNOWN_STATE_KINDS: ReadonlySet<string> = new Set([<%= state_kinds.select(&:unknown?).map { |kind| kind.name.inspect }.join(", ") %>])
+
+export const FALSY_STATE_KINDS: ReadonlySet<string> = new Set([<%= state_kinds.select(&:falsy?).map { |kind| kind.name.inspect }.join(", ") %>])
+
+export const NILABLE_STATE_KINDS: ReadonlySet<string> = new Set([<%= state_kinds.select(&:nilable?).map { |kind| kind.name.inspect }.join(", ") %>])
+
+export const PRISM_LITERAL_KINDS: Record<string, StateDefaultKind> = {
+<%- state_kinds.select(&:literal?).each do |kind| -%>
+<%- kind.prism_nodes.each do |node| -%>
+  <%= node.inspect %>: <%= kind.name.inspect %>,
+<%- end -%>
+<%- end -%>
+}
+
+const STATE_KIND_ARTICLES: Record<string, string> = {
+<%- state_kinds.each do |kind| -%>
+  <%= kind.name.inspect %>: <%= kind.article.inspect %>,
+<%- end -%>
+}
+
+export function stateKindArticle(kind: string): string {
+  const known = STATE_KIND_ARTICLES[kind]
+
+  if (known) {
+    return known
+  }
+
+  const spelled = kind.charAt(0).toUpperCase() + kind.slice(1)
+
+  if (spelled === "") {
+    return "a value"
+  }
+
+  return /^[AEIOU]/.test(spelled) ? `an ${spelled}` : `a ${spelled}`
+}

data/templates/javascript/packages/client/src/state-operators.ts.erb

@@ -0,0 +1,15 @@
+export const MIRRORED_COMPARISONS: Record<string, string> = {
+<%- state_operators.select(&:mirrored).each do |operator| -%>
+  <%= operator.operator.inspect %>: <%= operator.mirrored.inspect %>,
+<%- end -%>
+}
+
+export const NEGATED_COMPARISONS: Record<string, string> = {
+<%- state_operators.each do |operator| -%>
+  <%= operator.operator.inspect %>: <%= operator.negated.inspect %>,
+<%- end -%>
+}
+
+export const ORDERED_COMPARISONS: ReadonlySet<string> = new Set([<%= state_operators.select(&:ordered?).map { |operator| operator.operator.inspect }.join(", ") %>])
+
+export const COMPARISON_OPERATORS: ReadonlySet<string> = new Set([<%= state_operators.map { |operator| operator.operator.inspect }.join(", ") %>])

data/templates/javascript/packages/client/src/state-predicates.ts.erb

@@ -0,0 +1,27 @@
+export interface StatePredicate {
+  readonly comparand?: string
+  readonly operator?: string
+  readonly kinds: string[] | null
+  readonly only: string
+  readonly rewrite?: string
+}
+
+export const STATE_PREDICATES: Record<string, StatePredicate> = {
+<%- state_predicates.each do |predicate| -%>
+  <%= predicate.literal(predicate.name) %>: {
+<%- if predicate.comparand -%>
+    comparand: <%= predicate.literal(predicate.comparand) %>,
+<%- end -%>
+<%- if predicate.operator -%>
+    operator: <%= predicate.literal(predicate.operator) %>,
+<%- end -%>
+    kinds: <%= predicate.typescript_kinds %>,
+    only: <%= predicate.literal(predicate.only) %>,
+<%- if predicate.rewrite -%>
+    rewrite: <%= predicate.literal(predicate.rewrite) %>,
+<%- end -%>
+  },
+<%- end -%>
+}
+
+export const STATE_PREDICATE_NAMES = Object.keys(STATE_PREDICATES)

data/templates/javascript/packages/client/src/state-transforms.ts.erb

@@ -0,0 +1,19 @@
+export interface StateTransform {
+  readonly operation: string
+  readonly kinds: string[] | null
+  readonly returns: string
+  readonly only: string
+}
+
+export const STATE_TRANSFORMS: Record<string, StateTransform> = {
+<%- state_transforms.each do |transform| -%>
+  <%= transform.name.inspect %>: {
+    operation: <%= transform.operation.inspect %>,
+    kinds: <%= transform.typescript_kinds %>,
+    returns: <%= transform.returns.inspect %>,
+    only: <%= transform.only.inspect %>,
+  },
+<%- end -%>
+}
+
+export const STATE_TRANSFORM_NAMES = Object.keys(STATE_TRANSFORMS)

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(", ") %>])