isomorfeus-preact 22.9.0.rc9 → 22.10.0.rc1

data/ext/isomorfeus_preact_ext/isomorfeus_preact_ext.c

@@ -0,0 +1,9 @@
+#include <ruby.h>
+
+extern void Init_VNode(void);
+extern void Init_Preact(void);
+
+void Init_isomorfeus_preact_ext(void) {
+    Init_VNode();
+    Init_Preact();
+}

data/ext/isomorfeus_preact_ext/isomorfeus_preact_ext.h

@@ -0,0 +1,24 @@
+/*
+  class VNode
+    attr_accessor :__c
+    attr_reader :key
+    attr_reader :props
+    attr_reader :ref
+    attr_reader :type
+
+    def initialize(type, props, key, ref)
+      @type = type
+      @props = props
+      @key = key
+      @ref = ref
+    end
+  end
+*/
+
+typedef struct VNode {
+  VALUE component;
+  VALUE key;
+  VALUE props;
+  VALUE ref;
+  VALUE type;
+} VNode;

data/ext/isomorfeus_preact_ext/preact.c

@@ -0,0 +1,538 @@
+#include <ruby.h>
+#define FIO_STR_NAME render_result
+#include "fio-stl.h"
+#include "isomorfeus_preact_ext.h"
+
+static ID id_ancestors;
+static ID id_checked;
+static ID id_children;
+static ID id_class;
+static ID id_class_name;
+static ID id_class_name2;
+static ID id_context_id;
+static ID id_context_type;
+static ID id_dangerously_set_inner_html;
+static ID id_default_checked;
+static ID id_default_selected;
+static ID id_default_value;
+static ID id_development;
+static ID id_downcase;
+static ID id_encode_entities;
+static ID id_eqeq;
+static ID id_for;
+static ID id_get_child_context;
+static ID id_get_derived_state_from_props;
+static ID id_gsub;
+static ID id_html_for;
+static ID id_include;
+static ID id_is_a;
+static ID id_is_renderable;
+static ID id_key;
+static ID id_keyq;
+static ID id_keys;
+static ID id_match;
+static ID id_merge;
+static ID id_new;
+static ID id_props;
+static ID id_ref;
+static ID id_render;
+static ID id_render_buffer;
+static ID id_selected;
+static ID id_self;
+static ID id_source;
+static ID id_start_withq;
+static ID id_state;
+static ID id_style;
+static ID id_style_obj_to_css;
+static ID id_validate_props;
+static ID id_value;
+
+static ID iv_context;
+static ID iv_declared_props;
+static ID iv_next_state;
+static ID iv_props;
+static ID iv_state;
+
+static char *str_foreign_object = "foreignObject";
+static char *str_option = "option";
+static char *str_select = "select";
+static char *str_selected = "selected";
+static char *str_svg = "svg";
+static char *str_textarea = "textarea";
+
+static char *str_rve = "^(area|base|br|col|embed|hr|img|input|link|meta|param|source|track|wbr)$";
+static char *str_run = "[\\s\\n\\\\\\/='\"\\0<>]";
+static char *str_rxl = "^xlink:?.";
+static char *str_rx2 = "^xlink:?";
+// static char *str_ree = "[\"&<]";
+
+static VALUE s_aria;
+static VALUE s_false;
+static VALUE s_true;
+static VALUE s_xlink;
+
+static VALUE sym_children;
+static VALUE sym_class;
+static VALUE sym_default;
+static VALUE sym_for;
+static VALUE sym_html;
+static VALUE sym_key;
+static VALUE sym_ref;
+static VALUE sym_selected;
+static VALUE sym_value;
+
+static VALUE mIsomorfeus;
+static VALUE mPreact;
+static VALUE cFragment;
+static VALUE cProc;
+static VALUE cRegexp;
+
+extern VALUE cVNode;
+
+static VALUE rXlink;
+static VALUE rUnsafe;
+static VALUE rVoid;
+static VALUE rXlink2;
+
+int set_default_prop_value(VALUE prop, VALUE value, VALUE props) {
+  if ((rb_funcall(value, id_keyq, 1, sym_default) == Qtrue) && (rb_funcall(props, id_keyq, 1, prop) == Qfalse)) {
+    rb_hash_aset(props, props, rb_hash_lookup(value, sym_default));
+  }
+  return 0;
+}
+
+ID normalize_prop_name(ID name_id, VALUE is_svg_mode) {
+  if (name_id == id_class_name || name_id == id_class_name2) { return id_class; }
+  if (name_id == id_html_for) { return id_for; }
+  if (name_id == id_default_value) { return id_value; }
+  if (name_id == id_default_checked) { return id_checked; }
+  if (name_id == id_default_selected) { return id_selected; }
+  if (is_svg_mode == Qtrue) {
+    VALUE name_s = rb_id2str(name_id);
+    if (rb_funcall(rXlink, id_match, 1, name_s) == Qtrue) {
+      name_s = rb_funcall(name_s, id_downcase, 0);
+      name_s = rb_funcall(name_s, id_gsub, 2, rXlink2, s_xlink);
+      return SYM2ID(rb_to_symbol(name_s));
+    }
+  }
+  return name_id;
+}
+
+VALUE normalize_prop_value(ID name_id, VALUE name_s, VALUE value, VALUE self) {
+	if (name_id == id_style && value != Qnil && TYPE(value) == T_HASH) {
+		return rb_funcall(self, id_style_obj_to_css, 1, value);
+	}
+  // name[0] === 'a' && name[1] === 'r'
+  if (value == Qtrue && rb_funcall(name_s, id_start_withq, 1, s_aria) == Qtrue) {
+    // always use string values instead of booleans for aria attributes
+		// also see https://github.com/preactjs/preact/pull/2347/files
+    return s_true;
+	}
+  if (value == Qfalse && rb_funcall(name_s, id_start_withq, 1, s_aria) == Qtrue) {
+    // always use string values instead of booleans for aria attributes
+		// also see https://github.com/preactjs/preact/pull/2347/files
+    return s_false;
+	}
+	return value;
+}
+
+VALUE get_context(VALUE node_type, VALUE context) {
+  VALUE ctx_type = rb_funcall(node_type, id_context_type, 0);
+  VALUE provider = Qnil;
+  VALUE cctx = context;
+  if (ctx_type != Qnil) {
+    provider = rb_hash_lookup(context, rb_funcall(ctx_type, id_context_id, 0));
+    if (provider != Qnil) {
+      cctx = rb_hash_lookup(rb_funcall(provider, id_props, 0), sym_value); }
+    else {
+      cctx = rb_funcall(ctx_type, id_value, 0); }
+  }
+  return cctx;
+}
+
+VALUE render_class_component(VALUE vnode, VALUE context) {
+  VNode *v = (VNode *)DATA_PTR(vnode);
+
+	VALUE node_type = v->type;
+  VALUE props = v->props;
+
+  // get context
+	VALUE cctx = get_context(node_type, context);
+
+  // validate props
+  VALUE declared_props = rb_ivar_get(node_type, iv_declared_props);
+  if (declared_props != Qnil) {
+    rb_hash_foreach(declared_props, set_default_prop_value, props);
+    if (rb_funcall(mIsomorfeus, id_development, 0) == Qtrue) { rb_funcall(node_type, id_validate_props, 1, props); }
+  }
+
+  // instantiate component
+  VALUE c = rb_funcall(node_type, id_new, 2, props, cctx);
+	v->component = c;
+
+  // set state, props, context
+  rb_ivar_set(c, iv_props, props);
+  if (rb_funcall(c, id_state, 0) == Qnil) { rb_ivar_set(c, iv_state, rb_hash_new()); }
+  if (rb_ivar_get(c, iv_next_state) == Qnil) { rb_ivar_set(c, iv_next_state, rb_funcall(c, id_state, 0)); }
+  rb_ivar_set(c, iv_context, cctx);
+
+  // get_derived_state_from_props
+  if (rb_respond_to(c, id_get_derived_state_from_props)) {
+    VALUE state = rb_funcall(c, id_state, 0);
+    VALUE res = rb_funcall(c, id_get_derived_state_from_props, 2, rb_funcall(c, id_props, 0), state);
+    rb_ivar_set(c, iv_state, rb_funcall(state, id_merge, res));
+  }
+
+  // render
+	return rb_funcall(c, id_render, 0);
+}
+
+void internal_render_to_string(VALUE vnode, VALUE context, VALUE is_svg_mode, VALUE select_value, VALUE self, render_result_s *rres) {
+  VNode *v;
+  VALUE res;
+  VALUE node_type, props;
+  int i, len;
+
+  if (vnode == Qnil || vnode == Qfalse || vnode == Qtrue || ((TYPE(vnode) == T_STRING) && RSTRING_LEN(vnode) == 0)) {
+    return;
+  }
+
+  switch (TYPE(vnode)) {
+    case T_STRING:
+      res = rb_funcall(self, id_encode_entities, 1, vnode);
+      render_result_write(rres, RSTRING_PTR(res), RSTRING_LEN(res));
+      return;
+    case T_FIXNUM:
+    case T_BIGNUM:
+      res = rb_obj_as_string(vnode);
+      render_result_write(rres, RSTRING_PTR(res), RSTRING_LEN(res));
+      return;
+    case T_ARRAY:
+      len = RARRAY_LEN(vnode);
+      for (i = 0; i < len; i++) {
+        internal_render_to_string(RARRAY_PTR(vnode)[i], context, is_svg_mode, select_value, self, rres);
+      }
+      return;
+  }
+
+  v = (VNode *)DATA_PTR(vnode);
+  node_type = v->type;
+  props = v->props;
+
+  if (TYPE(node_type) != T_STRING) {
+    // components and Fragments
+    VALUE rendered;
+    VALUE ancestors = rb_funcall(node_type, id_ancestors, 0);
+    rb_funcall(ancestors, id_include, 1, cFragment);
+
+    if (RARRAY_PTR(ancestors)[0] == cFragment) {
+      rendered = rb_hash_lookup(props, sym_children);
+    } else {
+      rendered = render_class_component(vnode, context);
+
+      VALUE component = v->component;
+      if (rb_respond_to(component, id_get_child_context)) {
+        context = rb_funcall(context, id_merge, 1, rb_funcall(component, id_get_child_context, 0));
+      }
+    }
+
+    internal_render_to_string(rendered, context, is_svg_mode, select_value, self, rres);
+    return;
+  }
+
+  props = v->props;
+
+  // render JSX to HTML
+  VALUE node_type_s = rb_obj_as_string(node_type);
+  render_result_write(rres, "<", 1);
+  render_result_write(rres, RSTRING_PTR(node_type_s), RSTRING_LEN(node_type_s));
+
+  VALUE children = Qnil;
+  VALUE html = Qnil;
+
+  if (props != Qnil) {
+    children = rb_hash_lookup(props, sym_children);
+    VALUE attrs = rb_funcall(props, id_keys, 0);
+    len = RARRAY_LEN(attrs);
+    for (i = 0; i < len; i++) {
+      VALUE name = RARRAY_PTR(attrs)[i];
+      if (TYPE(name) == T_STRING) { name = rb_to_symbol(name); }
+      ID name_id = SYM2ID(name);
+      VALUE value = rb_hash_lookup(props, name);
+
+      if (name_id == id_key || name_id == id_ref || name_id == id_self || name_id == id_source || name_id == id_children ||
+        ((name_id == id_class_name || name_id == id_class_name2) && (rb_hash_lookup(props, sym_class) != Qnil)) ||
+        ((name_id == id_html_for) && (rb_hash_lookup(props, sym_for) != Qnil))) {
+        continue;
+      }
+
+      VALUE name_s = rb_id2str(name_id);
+      if (rb_funcall(rUnsafe, id_match, 1, name_s) == Qtrue) {
+        continue;
+      }
+
+      name_id = normalize_prop_name(name_id, is_svg_mode);
+      name_s = rb_id2str(name_id);
+      value = normalize_prop_value(name_id, name_s, value, self);
+
+      if (name_id == id_dangerously_set_inner_html && value != Qnil) {
+        html = rb_hash_lookup(value, sym_html);
+      } else if (name_id == id_value && strcmp(RSTRING_PTR(node_type_s), str_textarea) == 0) {
+        // <textarea value="a&b"> --> <textarea>a&amp;b</textarea>
+        children = value;
+      } else if (value != Qnil && value != Qfalse && rb_funcall(value, id_is_a, 1, cProc) != Qtrue) {
+        if (value == Qtrue || ((TYPE(value) == T_STRING) && (RSTRING_PTR(value)[0] == 0))) {
+          // if (name_id == id_class || name_id == id_style) { continue; }
+          value = name_s;
+          render_result_write(rres, " ", 1);
+          render_result_write(rres, RSTRING_PTR(name_s), RSTRING_LEN(name_s));
+          continue;
+        }
+
+        if (name_id == id_value) {
+          if (strcmp(RSTRING_PTR(node_type_s), str_select) == 0) {
+            select_value = value;
+            continue;
+          } else if (
+            // If we're looking at an <option> and it's the currently selected one
+            strcmp(RSTRING_PTR(node_type_s), str_option) == 0 &&
+            rb_funcall(select_value, id_eqeq, 1, value) == Qtrue &&
+            // and the <option> doesn't already have a selected attribute on it
+            rb_hash_lookup(props, sym_selected) == Qnil
+          ) {
+            render_result_write(rres, " ", 1);
+            render_result_write(rres, str_selected, strlen(str_selected));
+          }
+        }
+
+        render_result_write(rres, " ", 1);
+        render_result_write(rres, RSTRING_PTR(name_s), RSTRING_LEN(name_s));
+        render_result_write(rres, "=\"", 2);
+        res = rb_funcall(self, id_encode_entities, 1, value);
+        render_result_write(rres, RSTRING_PTR(res), RSTRING_LEN(res));
+        render_result_write(rres, "\"", 1);
+      }
+    }
+  }
+
+  render_result_write(rres, ">", 1);
+
+  if (rb_funcall(rUnsafe, id_match, 1, node_type_s) == Qtrue) {
+    rb_raise(rb_eRuntimeError, "%s is not a valid HTML tag name in %s", RSTRING_PTR(node_type_s), render_result2ptr(rres));
+  }
+
+  render_result_s *pieces = render_result_new();
+  VALUE has_children = Qfalse;
+  int children_type = TYPE(children);
+
+  if (html != Qnil) {
+    render_result_write(pieces, RSTRING_PTR(html), RSTRING_LEN(html));
+    has_children = Qtrue;
+  } else if (children_type == T_STRING) {
+    res = rb_funcall(self, id_encode_entities, 1, children);
+    render_result_write(pieces, RSTRING_PTR(res), RSTRING_LEN(res));
+    has_children = Qtrue;
+  } else if (children_type == T_ARRAY) {
+    VALUE child;
+    len = RARRAY_LEN(children);
+    for (i = 0; i < len; i++) {
+      child = RARRAY_PTR(children)[i];
+      if (child != Qnil && child != Qfalse) {
+        VALUE child_svg_mode;
+        if (strcmp(RSTRING_PTR(node_type_s), str_svg) == 0) {
+          child_svg_mode = Qtrue;
+        } else if (strcmp(RSTRING_PTR(node_type_s), str_foreign_object) == 0 && is_svg_mode == Qtrue) {
+          child_svg_mode = Qfalse;
+        } else {
+          child_svg_mode = is_svg_mode;
+        }
+        size_t len = render_result_len(pieces);
+        internal_render_to_string(child, context, child_svg_mode, select_value, self, pieces);
+        if (len < render_result_len(pieces)) { has_children = Qtrue; }
+      }
+    }
+  } else if (children != Qnil && children != Qfalse && children != Qtrue) {
+    VALUE child_svg_mode;
+    if (strcmp(RSTRING_PTR(node_type_s), str_svg) == 0) {
+      child_svg_mode = Qtrue;
+    } else if (strcmp(RSTRING_PTR(node_type_s), str_foreign_object) == 0 && is_svg_mode == Qtrue) {
+      child_svg_mode = Qfalse;
+    } else {
+      child_svg_mode = is_svg_mode;
+    }
+    size_t len = render_result_len(pieces);
+    internal_render_to_string(children, context, child_svg_mode, select_value, self, pieces);
+    if (len < render_result_len(pieces)) { has_children = Qtrue; }
+  }
+
+  if (has_children == Qtrue) {
+    render_result_concat(rres, pieces);
+  } else if (rb_funcall(rVoid, id_match, 1, node_type_s) == Qtrue) {
+    char *s = render_result2ptr(rres);
+    char l = s[render_result_len(rres) - 1];
+    if (l == '>') {
+      render_result_resize(rres, render_result_len(rres) - 1);
+      render_result_write(rres, " />", 3);
+    }
+    return;
+  }
+
+  render_result_free(pieces);
+
+  render_result_write(rres, "</", 2);
+  render_result_write(rres, RSTRING_PTR(node_type_s), RSTRING_LEN(node_type_s));
+  render_result_write(rres, ">", 1);
+
+  return;
+}
+
+VALUE render_to_string(int argc, VALUE *argv, VALUE self) {
+  VALUE vnode, context, is_svg_mode, select_value, res;
+  render_result_s *rres = render_result_new();
+  rb_scan_args(argc, argv, "22", &vnode, &context, &is_svg_mode, &select_value);
+  internal_render_to_string(vnode, context, is_svg_mode, select_value, self, rres);
+  res = rb_str_new(render_result2ptr(rres), render_result_len(rres));
+  render_result_free(rres);
+  return res;
+}
+
+VALUE create_element(int argc, VALUE *argv, VALUE self) {
+  VALUE type, props, children;
+  rb_scan_args(argc, argv, "12", &type, &props, &children);
+  VALUE normalized_props, key, ref;
+
+  if (props != Qnil) {
+    if (TYPE(props) == T_HASH) {
+      normalized_props = rb_hash_dup(props);
+      key = rb_hash_delete(normalized_props, sym_key);
+      ref = rb_hash_delete(normalized_props, sym_ref);
+    } else {
+      children = props;
+      normalized_props = rb_hash_new();
+      key = Qnil;
+      ref = Qnil;
+    }
+  } else {
+    normalized_props = rb_hash_new();
+    key = Qnil;
+    ref = Qnil;
+  }
+
+  if (rb_block_given_p()) {
+    VALUE pr = rb_funcall(mPreact, id_render_buffer, 0);
+    pr = rb_ary_push(pr, rb_ary_new());
+    VALUE block_result = rb_yield(Qnil);
+    VALUE c = rb_ary_pop(pr);
+    if (rb_funcall(mPreact, id_is_renderable, 1, block_result) == Qtrue) {
+      rb_ary_push(c, block_result);
+    }
+    if (RARRAY_LEN(c) > 0) {
+      children = c;
+    }
+  }
+
+  if (children != Qnil) {
+    rb_hash_aset(normalized_props, sym_children, children);
+  }
+
+  return rb_funcall(cVNode, id_new, 4, type, normalized_props, key, ref);
+}
+
+void Init_Preact(void) {
+  id_ancestors = rb_intern("ancestors");
+  id_checked = rb_intern("checked");
+  id_children = rb_intern("children");
+  id_class = rb_intern("class");
+  id_class_name = rb_intern("class_name");
+  id_class_name2 = rb_intern("className");
+  id_context_id = rb_intern("context_id");
+  id_context_type = rb_intern("context_type");
+  id_dangerously_set_inner_html = rb_intern("dangerouslySetInnerHTML");
+  id_default_checked = rb_intern("default_checked");
+  id_default_selected = rb_intern("default_selected");
+  id_default_value = rb_intern("default_value");
+  id_development = rb_intern("development?");
+  id_downcase = rb_intern("downcase");
+  id_encode_entities = rb_intern("_encode_entities");
+  id_eqeq = rb_intern("==");
+  id_get_child_context = rb_intern("get_child_context");
+  id_get_derived_state_from_props = rb_intern("get_derived_state_from_props");
+  id_gsub = rb_intern("gsub");
+  id_html_for = rb_intern("html_for");
+  id_for = rb_intern("for");
+  id_include = rb_intern("include?");
+  id_is_a = rb_intern("is_a?");
+  id_is_renderable = rb_intern("is_renderable?");
+  id_key = rb_intern("key");
+  id_keyq = rb_intern("key?");
+  id_keys = rb_intern("keys");
+  id_match = rb_intern("match?");
+  id_merge = rb_intern("merge");
+  id_new = rb_intern("new");
+  id_props = rb_intern("props");
+  id_ref = rb_intern("ref");
+  id_render = rb_intern("render");
+  id_render_buffer = rb_intern("render_buffer");
+  id_selected = rb_intern("selected");
+  id_self = rb_intern("__self");
+  id_source = rb_intern("__source");
+  id_start_withq = rb_intern("start_with?");
+  id_state = rb_intern("state");
+  id_style = rb_intern("style");
+  id_style_obj_to_css = rb_intern("_style_obj_to_css");
+  id_validate_props = rb_intern("validate_props");
+  id_value = rb_intern("value");
+
+  iv_context = rb_intern("@context");
+  iv_declared_props = rb_intern("@declared_props");
+  iv_next_state = rb_intern("@_nextState");
+  iv_props = rb_intern("@props");
+  iv_state = rb_intern("@state");
+
+  sym_children = ID2SYM(rb_intern("children"));
+  sym_class = ID2SYM(rb_intern("class"));
+  sym_default = ID2SYM(rb_intern("default"));
+  sym_for = ID2SYM(id_for);
+  sym_html = ID2SYM(rb_intern("__html"));
+  sym_key = ID2SYM(rb_intern("key"));
+  sym_ref = ID2SYM(rb_intern("ref"));
+  sym_selected = ID2SYM(rb_intern("selected"));
+  sym_value = ID2SYM(id_value);
+
+  cProc = rb_const_get(rb_cObject, rb_intern("Proc"));
+  cRegexp = rb_const_get(rb_cObject, rb_intern("Regexp"));
+  mIsomorfeus = rb_const_get(rb_cObject, rb_intern("Isomorfeus"));
+  mPreact = rb_define_module("Preact");
+  cFragment = rb_define_class("Fragment", rb_cObject);
+
+  // set instance variables on the module to keep references to these objects
+  // to prevent garbage colloction
+  rUnsafe = rb_funcall(cRegexp, id_new, 1, rb_str_new_cstr(str_run));
+  rb_obj_freeze(rUnsafe);
+  rb_ivar_set(mPreact, rb_intern("@_r_unsafe"), rUnsafe);
+  rVoid = rb_funcall(cRegexp, id_new, 1, rb_str_new_cstr(str_rve));
+  rb_obj_freeze(rVoid);
+  rb_ivar_set(mPreact, rb_intern("@_r_void"), rVoid);
+  rXlink = rb_funcall(cRegexp, id_new, 1, rb_str_new_cstr(str_rxl));
+  rb_obj_freeze(rXlink);
+  rb_ivar_set(mPreact, rb_intern("@_r_xlink"), rXlink);
+  rXlink2 = rb_funcall(cRegexp, id_new, 1, rb_str_new_cstr(str_rx2));
+  rb_obj_freeze(rXlink2);
+  rb_ivar_set(mPreact, rb_intern("@_r_xlink2"), rXlink2);
+
+  s_aria = rb_str_new_cstr("aria");
+  rb_obj_freeze(s_aria);
+  rb_ivar_set(mPreact, rb_intern("@_s_aria"), s_aria);
+  s_false = rb_str_new_cstr("false");
+  rb_obj_freeze(s_false);
+  rb_ivar_set(mPreact, rb_intern("@_s_false"), s_false);
+  s_true = rb_str_new_cstr("true");
+  rb_obj_freeze(s_true);
+  rb_ivar_set(mPreact, rb_intern("@_s_true"), s_true);
+  s_xlink = rb_str_new_cstr("xlink:");
+  rb_obj_freeze(s_xlink);
+  rb_ivar_set(mPreact, rb_intern("@_s_xlink"), s_xlink);
+
+  rb_define_module_function(mPreact, "_render_to_string", render_to_string, -1);
+  rb_define_module_function(mPreact, "create_element", create_element, -1);
+}

data/ext/isomorfeus_preact_ext/vnode.c

@@ -0,0 +1,91 @@
+#include <ruby.h>
+#define FIO_MEMORY_NAME vnode
+#include "fio-stl.h"
+#include "isomorfeus_preact_ext.h"
+
+VALUE cVNode;
+
+static void preact_vnode_mark(void *p) {
+    VNode *v = (VNode *)p;
+    rb_gc_mark(v->component);
+    rb_gc_mark(v->key);
+    rb_gc_mark(v->props);
+    rb_gc_mark(v->ref);
+    rb_gc_mark(v->type);
+}
+
+static void preact_vnode_free(void *p) {
+  vnode_free(p);
+}
+
+static size_t preact_vnode_size(const void *p) {
+  return sizeof(VNode);
+  (void)p;
+}
+
+const rb_data_type_t preact_vnode_t = {
+  .wrap_struct_name = "VNode",
+  .function = {
+    .dmark = preact_vnode_mark,
+    .dfree = preact_vnode_free,
+    .dsize = preact_vnode_size,
+    .dcompact = NULL,
+    .reserved = {0}
+  },
+  .parent = NULL,
+  .data = NULL,
+  .flags = RUBY_TYPED_FREE_IMMEDIATELY
+};
+
+static VALUE preact_vnode_alloc(VALUE rclass) {
+  void *v = vnode_malloc(sizeof(VNode));
+  return TypedData_Wrap_Struct(rclass, &preact_vnode_t, v);
+}
+
+static VALUE preact_vnode_init(VALUE self, VALUE type, VALUE props, VALUE key, VALUE ref) {
+  VNode *v = (VNode *)DATA_PTR(self);
+  v->component = Qnil;
+  v->key = key;
+  v->props = props;
+  v->type = type;
+  v->ref = ref;
+  return self;
+}
+
+static VALUE preact_vnode_set_c(VALUE self, VALUE c) {
+  VNode *v = (VNode *)DATA_PTR(self);
+  v->component = c;
+  return c;
+}
+
+static VALUE preact_vnode_get_c(VALUE self) {
+  return ((VNode *)DATA_PTR(self))->component;
+}
+
+static VALUE preact_vnode_get_key(VALUE self) {
+  return ((VNode *)DATA_PTR(self))->key;
+}
+
+static VALUE preact_vnode_get_props(VALUE self) {
+  return ((VNode *)DATA_PTR(self))->props;
+}
+
+static VALUE preact_vnode_get_ref(VALUE self) {
+  return ((VNode *)DATA_PTR(self))->ref;
+}
+
+static VALUE preact_vnode_get_type(VALUE self) {
+  return ((VNode *)DATA_PTR(self))->type;
+}
+
+void Init_VNode(void) {
+  cVNode = rb_define_class("VNode", rb_cObject);
+  rb_define_alloc_func(cVNode, preact_vnode_alloc);
+  rb_define_method(cVNode, "initialize", preact_vnode_init, 4);
+  rb_define_method(cVNode, "component=", preact_vnode_set_c, 1);
+  rb_define_method(cVNode, "component", preact_vnode_get_c, 0);
+  rb_define_method(cVNode, "key", preact_vnode_get_key, 0);
+  rb_define_method(cVNode, "props", preact_vnode_get_props, 0);
+  rb_define_method(cVNode, "ref", preact_vnode_get_ref, 0);
+  rb_define_method(cVNode, "type", preact_vnode_get_type, 0);
+}

data/lib/isomorfeus/preact/ssr.rb

@@ -30,7 +30,6 @@ module Isomorfeus
 
     def render_component_to_string(component_name, props)
       component = component_name.is_a?(String) ? self.class.const_get(component_name) : component_name
-      ::Preact._vnode_id = 0
       ::Preact.render_to_string(::Preact.create_element(component, props))
     end
   end

data/lib/isomorfeus/preact/version.rb

@@ -1,5 +1,5 @@
 module Isomorfeus
   module Preact
-    VERSION = '22.9.0.rc9'
+    VERSION = '22.10.0.rc1'
   end
 end