isomorfeus-preact 23.6.0.rc5 → 23.7.0.rc1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 779986a2bb11f9fa0c6e2843cc7dd178aa260d61545a11e9880029e814e9271a
-  data.tar.gz: e3f778adfa0d62c4e51528f9823a8c83cf7a0ed2e49e89a8a714203159a3f6e9
+  metadata.gz: dc75f42dc15647d420c75efe94ad0fec2a7c94d8fa2732c322953d983b73a605
+  data.tar.gz: d86d420916c4d71f1fab8b443924f6ba2c0dc1e09980808965b4aa9f655c0e85
 SHA512:
-  metadata.gz: 6897c32a84bf1802b752eb2909634e688dff95f0136cf93ba5fc87b78b6fb7bc719e392e230212a454e4aeb2983860af08044a980c2e1727e3e6c6b9d69f4b7a
-  data.tar.gz: 63aa3a8557f8ac5101732670b4abb38f9138e2eecf0c801dacde6f3bed47afe44d68f283a11d16de7f6504f7e29eaa8acfc24b22107d493a5b89dab1d0a8bcd5
+  metadata.gz: 6a084e4db02bac9c49b0b1825d2737fcb92df7d0ecfcf173635f28394d9b3b832554d64083ad0ef16ae7ca6e19119a4c197720cdc5d6c5a6b90b6f0f6ad2be1f
+  data.tar.gz: 76830024265abd1e8d792a3424d01ceb585ab1a0499ce4652ba77bb9c334e7af99504bc541a4835eadaf33ec67fbaff8a86b9bfb3b88c9e365cdce6d7f4324bb

data/ext/isomorfeus_preact_ext/preact.c

@@ -154,6 +154,19 @@ static VALUE get_context(VALUE node_type, VALUE context) {
   return context;
 }
 
+static VALUE is_renderable_q(VALUE self, VALUE block_result) {
+  switch (TYPE(block_result)) {
+  case T_BIGNUM:
+  case T_FIXNUM:
+  case T_FLOAT:
+  case T_STRING:
+    return Qtrue;
+  default:
+    return Qfalse;
+  }
+  return Qfalse;
+}
+
 static VALUE render_class_component(VALUE vnode, VALUE context, VNode *v) {
   VALUE node_type = v->type;
   VALUE props = v->props;
@@ -197,7 +210,13 @@ static VALUE render_class_component(VALUE vnode, VALUE context, VNode *v) {
   rb_obj_freeze(rb_ivar_get(c, iv_state));
 
   // render
-  return rb_funcall(c, id_render, 0);
+  VALUE pr = rb_funcall(mPreact, id_render_buffer, 0);
+  rb_ary_push(pr, rb_ary_new());
+  VALUE block_result = rb_funcall(c, id_render, 0);
+  VALUE render_result = rb_ary_pop(pr);
+  if (is_renderable_q(mPreact, block_result) == Qtrue)
+    rb_ary_push(render_result, block_result);
+  return render_result;
 }
 
 void internal_render_to_string(VALUE vnode, VALUE context, VALUE is_svg_mode,
@@ -213,8 +232,9 @@ void internal_render_to_string(VALUE vnode, VALUE context, VALUE is_svg_mode,
       return;
     rb_str_buf_append(rres, rb_funcall(self, id_encode_entities, 1, vnode));
     return;
-  case T_FIXNUM:
   case T_BIGNUM:
+  case T_FIXNUM:
+  case T_FLOAT:
     rb_str_buf_append(rres, rb_funcall(vnode, id_to_s, 0));
     return;
   case T_ARRAY:
@@ -413,27 +433,6 @@ static VALUE render_to_string(int argc, VALUE *argv, VALUE self) {
   return res;
 }
 
-static VALUE is_renderable_q(VALUE self, VALUE block_result) {
-  switch (TYPE(block_result)) {
-  case T_BIGNUM:
-  case T_FIXNUM:
-  case T_FLOAT:
-  case T_STRING:
-    return Qtrue;
-  case T_ARRAY:
-    if (RARRAY_LEN(block_result) > 0)
-      return is_renderable_q(self, RARRAY_PTR(block_result)[0]);
-    return Qfalse;
-  case T_DATA:
-    if (RBASIC_CLASS(block_result) == cVNode)
-      return Qtrue;
-    return Qfalse;
-  default:
-    return Qfalse;
-  }
-  return Qfalse;
-}
-
 static VALUE create_element(int argc, VALUE *argv, VALUE self) {
   if (argc < 1 || argc > 3)
     rb_raise(rb_eArgError, "wrong argument count, required arg: type, optional "
@@ -478,7 +477,11 @@ static VALUE create_element(int argc, VALUE *argv, VALUE self) {
 
 static VALUE render_element(int argc, VALUE *argv, VALUE self) {
   VALUE pr = rb_funcall(self, id_render_buffer, 0);
-  rb_ary_push(RARRAY_PTR(pr)[RARRAY_LEN(pr) - 1], create_element(argc, argv, self));
+  long len = RARRAY_LEN(pr);
+  if (len > 0)
+    rb_ary_push(RARRAY_PTR(pr)[len - 1], create_element(argc, argv, self));
+  else
+    rb_ary_push(pr, create_element(argc, argv, self));
   return Qnil;
 }
 

data/lib/isomorfeus/preact/version.rb

@@ -1,5 +1,5 @@
 module Isomorfeus
   module Preact
-    VERSION = '23.6.0.rc5'
+    VERSION = '23.7.0.rc1'
   end
 end

data/lib/link.rb

@@ -48,6 +48,6 @@ class Link < Preact::Component
     }
     # wraps children in `a` if needed
     a = children.is_a?(VNode) ? children : Preact.create_element("a", props)
-    Preact.clone_element(a, extra_props)
+    RPE(Preact.clone_element(a, extra_props))
   end
 end

data/lib/lucid_app.rb

@@ -6,13 +6,13 @@ class LucidApp < LucidComponent
 
     def render(&block)
       define_method(:render) do
+        block_result = _internal_render(&block)
         pr = ::Preact.render_buffer
-        block_result = _internal_render(pr, &block)
         children = pr.pop
         if ::Preact.is_renderable?(block_result)
           children << block_result
         end
-        ::Preact.create_element(::LucidApplicationContext.Provider, state[:_app_ctx], children)
+        pr << [::Preact.create_element(::LucidApplicationContext.Provider, state[:_app_ctx], children)]
       end
     end
 

data/lib/lucid_component.rb

@@ -8,13 +8,7 @@ class LucidComponent < Preact::Component
 
     def render(&block)
       define_method(:render) do
-        pr = Preact.render_buffer
-        block_result = _internal_render(pr, &block)
-        if Preact.is_renderable?(block_result)
-          pr.pop << block_result
-        else
-          pr.pop
-        end
+        _internal_render(&block)
       end
     end
 
@@ -80,8 +74,7 @@ class LucidComponent < Preact::Component
     @styles = @self_class.css_styles
   end
 
-  def _internal_render(pr, &block)
-    pr << []
+  def _internal_render(&block)
     outer_loading = ::Isomorfeus.something_loading?
     ex = nil
     begin
@@ -91,8 +84,8 @@ class LucidComponent < Preact::Component
     end
     if ::Isomorfeus.something_loading?
       STDERR.puts "#{@class_name} component still loading ...\n#{ex.message}\n#{ex.backtrace&.join("\n")}" if ex && ::Isomorfeus.development?
-      pr[pr.length-1].clear
-      block_result = @while_loading_block ? instance_exec(&@while_loading_block) : ::Preact.create_element('div')
+      ::Preact.render_buffer.last.clear
+      block_result = @while_loading_block ? instance_exec(&@while_loading_block) : RPE(::Preact.create_element('div'))
     elsif ex
       raise ex
     end

data/lib/preact/component.rb

@@ -74,14 +74,7 @@ module Preact
 
       def render(&block)
         define_method(:render) do
-          pr = Preact.render_buffer
-          pr << []
-          block_result = instance_exec(&block)
-          if Preact.is_renderable?(block_result)
-            pr.pop << block_result
-          else
-            pr.pop
-          end
+          instance_exec(&block)
         end
       end
 

data/lib/preact/context.rb

@@ -30,7 +30,7 @@ module Preact
       end
 
       def render
-        @props[:children]
+        RPE(@props[:children])
       end
 
       def should_component_update?(next_props, _next_state, _context)

data/lib/preact/html_elements.rb

@@ -25,13 +25,15 @@ module Preact::HtmlElements
   ]
 
   if RUBY_ENGINE == 'opal'
+    %x{
+      const $op = Opal.Preact;
+    }
+
     SUPPORTED_HTML_ELEMENTS.each do |element|
       define_method(element.underscore.JS.toUpperCase()) do |props = nil, &block|
         %x{
-          const op = Opal.Preact;
-          const opr = op.render_buffer;
-          if (typeof block === 'function') op.$create_element.$$p = block.$to_proc();
-          opr[opr.length-1].push(op.$create_element(element, props, nil));
+          if (typeof block === 'function') $op.$_render_element.$$p = block;
+          $op.$_render_element(element, props, block)
         }
       end
     end
@@ -43,6 +45,7 @@ module Preact::HtmlElements
     end
   end
 
+  # Get Preact Element from render buffer
   def GPE(arg, &block)
     if block_given?
       el = block.call
@@ -51,6 +54,7 @@ module Preact::HtmlElements
     ::Preact.render_buffer.last.pop
   end
 
+  # Render Preact Element to render buffer
   def RPE(el)
     ::Preact.render_buffer.last << el
     nil

data/lib/preact/math_ml_elements.rb

@@ -33,13 +33,15 @@ module Preact::MathMlElements
   ]
 
   if RUBY_ENGINE == 'opal'
+    %x{
+      const $op = Opal.Preact;
+    }
+
     SUPPORTED_MATH_ML_ELEMENTS.each do |element|
       define_method(element.underscore.JS.toUpperCase()) do |props = nil, &block|
         %x{
-          const op = Opal.Preact;
-          const opr = op.render_buffer;
-          if (typeof block === 'function') op.$create_element.$$p = block.$to_proc();
-          opr[opr.length-1].push(op.$create_element(element, props, nil));
+          if (typeof block === 'function') $op.$_render_element.$$p = block;
+          $op.$_render_element(element, props, block)
         }
       end
     end

data/lib/preact/svg_elements.rb

@@ -45,13 +45,15 @@ module Preact::SvgElements
   ]
 
   if RUBY_ENGINE == 'opal'
+    %x{
+      const $op = Opal.Preact;
+    }
+
     SUPPORTED_SVG_ELEMENTS.each do |element|
       define_method(element.underscore.JS.toUpperCase()) do |props = nil, &block|
         %x{
-          const op = Opal.Preact;
-          const opr = op.render_buffer;
-          if (typeof block === 'function') op.$create_element.$$p = block.$to_proc();
-          opr[opr.length-1].push(op.$create_element(element, props, nil));
+          if (typeof block === 'function') $op.$_render_element.$$p = block;
+          $op.$_render_element(element, props, block)
         }
       end
     end

data/lib/preact.rb

@@ -1,3 +1,5 @@
+# helpers: hash2, hash_get, hash_put
+
 if RUBY_ENGINE == 'opal'
   class VNode
     # just a empty place holder to make is_a?(VNode) work
@@ -10,8 +12,18 @@ class Fragment
     @props = props
   end
 
-  def render
-    @props[:children]
+  if RUBY_ENGINE == 'opal'
+    def render
+      `Opal.Preact.render_buffer.pop()`
+      children = @props[:children]
+      `Opal.Preact.render_buffer.push(children.$$is_array ? children : [children])`
+      nil
+    end
+  else
+    def render
+      ::Preact.render_buffer.pop
+      ::Preact.render_buffer.push(@props[:children])
+    end
   end
 end
 
@@ -50,10 +62,15 @@ module Preact
         throw error;
       }
 
-      const EMPTY_OBJ = {};
+      const EMPTY_OBJ = Object.create(null);
       const EMPTY_ARR = [];
       const slice = EMPTY_ARR.slice;
-      const isArray = Array.isArray;
+      const $has_own = Object.hasOwn || $call.bind(Object.prototype.hasOwnProperty);
+
+      function hash_fetch(hash, key) {
+        let val = $hash_get(hash, key);
+        return (val === undefined || val === null) ? nil : val;
+      }
 
       function assign(obj, props) {
         for (let i in props) obj[i] = props[i];
@@ -67,7 +84,7 @@ module Preact
           else if (typeof value.$$class !== 'undefined') { converted_value = value; }
           else if (value instanceof Element || value instanceof Node) { converted_value = #{Browser::Element.new(`value`)}; }
           if (typeof ref === "function") ref.$call(converted_value);
-          else ref["$[]="]("current", converted_value);
+          else $hash_put(ref, "current", converted_value);
         } catch (e) {
           _catchError(e, vnode);
         }
@@ -98,7 +115,7 @@ module Preact
         // Only climb up and search the parent if we aren't searching through a DOM
         // VNode (meaning we reached the DOM parent of the original vnode that began
         // the search)
-        return typeof vnode.type == 'function' ? getDomSibling(vnode) : null;
+        return typeof vnode.type === 'function' ? getDomSibling(vnode) : null;
       }
 
       function placeChild(
@@ -166,7 +183,7 @@ module Preact
             // (childVNode here).
             vnode._parent = childVNode;
 
-            if (typeof vnode.type == 'function') {
+            if (typeof vnode.type === 'function') {
               oldDom = reorderChildren(vnode, oldDom, parentDom);
             } else {
               oldDom = placeChild(
@@ -197,7 +214,7 @@ module Preact
             if (typeof r === "function") {
               applyRef(r, null, parentVNode);
             } else {
-              let rc = r["$[]"]("current");
+              let rc = hash_fetch(r, "current");
               if (rc === nil || rc === vnode._dom) { applyRef(r, null, parentVNode); }
             }
           } catch (e) {
@@ -220,7 +237,7 @@ module Preact
         if ((r = vnode._children)) {
           for (let i = 0; i < r.length; i++) {
             if (r[i]) {
-              self.unmount(r[i], parentVNode, typeof vnode.type != 'function');
+              self.unmount(r[i], parentVNode, typeof vnode.type !== 'function');
             }
           }
         }
@@ -256,13 +273,13 @@ module Preact
         for (i = 0; i < renderResult.length; i++) {
           childVNode = renderResult[i];
 
-          if (childVNode === nil || childVNode == null || typeof childVNode == 'boolean' || childVNode.$$is_boolean) {
+          if (childVNode === nil || childVNode == null || typeof childVNode === 'boolean' || childVNode.$$is_boolean) {
             childVNode = newParentVNode._children[i] = null;
           }
           // If this newVNode is being reused (e.g. <div>{reuse}{reuse}</div>) in the same diff,
           // or we are rendering a component (e.g. setState) copy the oldVNodes so it can have
           // it's own DOM & etc. pointers
-          else if (typeof childVNode == 'string' || typeof childVNode == 'number' || typeof childVNode == 'bigint') {
+          else if (typeof childVNode === 'string' || typeof childVNode === 'number' || typeof childVNode === 'bigint') {
             childVNode = newParentVNode._children[i] = self.createVNode(
               null,
               childVNode,
@@ -279,7 +296,7 @@ module Preact
               null,
               str
             );
-          } else if (isArray(childVNode)) {
+          } else if (childVNode.$$is_array) {
             childVNode = newParentVNode._children[i] = self.createVNode(
               Opal.Fragment,
               #{{ children: `childVNode` }},
@@ -389,7 +406,7 @@ module Preact
               );
             }
 
-            if (typeof newParentVNode.type == 'function') {
+            if (typeof newParentVNode.type === 'function') {
               // Because the newParentVNode is Fragment-like, we need to set it's
               // _nextDom property to the nextSibling of its last child DOM node.
               //
@@ -567,14 +584,14 @@ module Preact
 
       function diff_props(dom, new_props, old_props, is_svg, hydrate) {
         #{`old_props`.each do |prop, value|
-            `if (prop !== "children" && prop !== "key" && !(prop.$$is_string && Object.hasOwnProperty.call(new_props.$$smap, prop))) { self.setProperty(dom, prop, null, value, is_svg); }`
+            `if (prop !== "children" && prop !== "key" && !(prop.$$is_string && $has_own(new_props.$$smap, prop))) { self.setProperty(dom, prop, null, value, is_svg); }`
             nil
           end
           `new_props`.each do |prop, value|
             if (`!hydrate || (prop[0] === 'o' && prop[1] === 'n' && prop[2] === '_')` || value.is_a?(Proc)) &&
               `prop !== "children" && prop !== "key" && prop !== "value" && prop !== "checked"` &&
-              ((p = `old_props`[prop]) ? p : nil) != value
-              `self.setProperty(dom, prop, value, old_props["$[]"](prop), is_svg)`
+              `hash_fetch(old_props, prop)` != value
+              `self.setProperty(dom, prop, value, hash_fetch(old_props, prop), is_svg)`
             end
           end
         }
@@ -653,10 +670,10 @@ module Preact
           // If excessDomChildren was not null, repopulate it with the current element's children:
           excessDomChildren = excessDomChildren && slice.call(dom.childNodes);
 
-          oldProps = oldVNode.props || Opal.hash();
+          oldProps = oldVNode.props || $hash2([], {});
 
-          let oldHtml = oldProps["$[]"]("dangerouslySetInnerHTML");
-          let newHtml = newProps["$[]"]("dangerouslySetInnerHTML");
+          let oldHtml = hash_fetch(oldProps, "dangerouslySetInnerHTML");
+          let newHtml = hash_fetch(newProps, "dangerouslySetInnerHTML");
 
           // During hydration, props are not diffed at all (including dangerouslySetInnerHTML)
           // @TODO we should warn in debug mode when props don't match here.
@@ -664,9 +681,9 @@ module Preact
             // But, if we are in a situation where we are using existing DOM (e.g. replaceNode)
             // we should read the existing DOM attributes to diff them
             if (excessDomChildren != null) {
-              oldProps = Opal.hash();
+              oldProps = $hash2([], {});
               for (i = 0; i < dom.attributes.length; i++) {
-                oldProps["$[]="](dom.attributes[i].name, dom.attributes[i].value);
+                $hash_put(oldProps, dom.attributes[i].name, dom.attributes[i].value);
               }
             }
 
@@ -674,10 +691,10 @@ module Preact
               // Avoid re-applying the same '__html' if it has not changed between re-render
               if (
                 newHtml === nil ||
-                ((oldHtml === nil || newHtml["$[]"]("__html") != oldHtml["$[]"]("__html")) &&
-                  newHtml["$[]"]("__html") !== dom.innerHTML)
+                ((oldHtml === nil || hash_fetch(newHtml, "__html") != hash_fetch(oldHtml, "__html")) &&
+                  hash_fetch(newHtml, "__html") !== dom.innerHTML)
               ) {
-                dom.innerHTML = (newHtml !== nil && newHtml["$[]"]("__html")) || '';
+                dom.innerHTML = (newHtml !== nil && hash_fetch(newHtml, "__html")) || '';
               }
             }
           }
@@ -688,10 +705,10 @@ module Preact
           if (newHtml !== nil) {
             newVNode._children = [];
           } else {
-            i = newVNode.props["$[]"]("children");
+            i = hash_fetch(newVNode.props, "children");
             diffChildren(
               dom,
-              isArray(i) ? i : [i],
+              i.$$is_array ? i : [i],
               newVNode,
               oldVNode,
               globalContext,
@@ -716,8 +733,8 @@ module Preact
           if (!isHydrating) {
             if (
               // instead of newProps["$key?"]("value")
-              Object.hasOwnProperty.call(newProps.$$smap, "value") &&
-              (i = newProps["$[]"]("value")) !== nil &&
+              $has_own(newProps.$$smap, "value") &&
+              (i = hash_fetch(newProps, "value")) !== nil &&
               // #2756 For the <progress>-element the initial value is 0,
               // despite the attribute not being present. When the attribute
               // is missing the progress bar is treated as indeterminate.
@@ -726,16 +743,16 @@ module Preact
                 // This is only for IE 11 to fix <select> value not being updated.
                 // To avoid a stale select value we need to set the option.value
                 // again, which triggers IE11 to re-evaluate the select value
-                (nodeType === 'option' && i !== oldProps["$[]"]("value")))
+                (nodeType === 'option' && i !== hash_fetch(oldProps, "value")))
             ) {
-              self.setProperty(dom, 'value', i, oldProps["$[]"]("value"), false, null);
+              self.setProperty(dom, 'value', i, hash_fetch(oldProps, "value"), false, null);
             }
             if (
-              Object.hasOwnProperty.call(newProps.$$smap, "checked") &&
-              (i = newProps["$[]"]("checked")) !== nil &&
+              $has_own(newProps.$$smap, "checked") &&
+              (i = hash_fetch(newProps, "checked")) !== nil &&
               i !== dom.checked
             ) {
-              self.setProperty(dom, 'checked', i, oldProps["$[]"]("checked"), false, null);
+              self.setProperty(dom, 'checked', i, hash_fetch(oldProps, "checked"), false, null);
             }
           }
         }
@@ -747,7 +764,7 @@ module Preact
         if (newType.declared_props && newType.declared_props !== nil) {
           #{
             `newType.declared_props`.each do |prop, value|
-              `if (Object.hasOwnProperty.call(value.$$smap, "default") && !Object.hasOwnProperty.call(newProps.$$smap, prop)) { #{`newProps`[prop] = value[:default]} }`
+              `if ($has_own(value.$$smap, "default") && !$has_own(newProps.$$smap, prop)) { #{`newProps`[prop] = value[:default]} }`
               nil
             end
           }
@@ -782,15 +799,15 @@ module Preact
         }
 
         try {
-          outer: if (typeof newType == 'function') {
+          outer: if (typeof newType === 'function') {
             let c, ctxType, isNew, oldProps, oldState, renderResult, snapshot, clearProcessingException;
             let newProps = newVNode.props;
 
             // Necessary for createContext api. Setting this property will pass
             // the context value as `this.context` just for this component.
             ctxType = newType.context_type;
-            let provider = (ctxType && ctxType !== nil) && globalContext["$[]"](ctxType.context_id);
-            let componentContext = (ctxType && ctxType !== nil) ? ((provider && provider !== nil) ? provider.props["$[]"]("value") : ctxType.value) : globalContext;
+            let provider = (ctxType && ctxType !== nil) && hash_fetch(globalContext, ctxType.context_id);
+            let componentContext = (ctxType && ctxType !== nil) ? ((provider && provider !== nil) ? hash_fetch(provider.props, "value") : ctxType.value) : globalContext;
 
             // Get component and set it to `c`
             if (oldVNode._component) {
@@ -807,7 +824,7 @@ module Preact
               if (provider && provider !== nil) provider.$sub(c);
 
               c.props = newProps;
-              if (c.state === nil || !c.state) c.state = Opal.hash();
+              if (c.state === nil || !c.state) c.state = $hash2([], {});
               c.context = componentContext;
               c._globalContext = globalContext;
               isNew = c._dirty = true;
@@ -819,8 +836,11 @@ module Preact
               c._nextState = c.state;
             }
 
-            if (!isNew) { validate_props(newType, newProps); }
-            newProps.$freeze();
+            if (!isNew) {
+              validate_props(newType, newProps);
+              newProps.$freeze();
+            }
+            
             if (c["$respond_to?"]("get_derived_state_from_props")) {
               if (c._nextState == c.state) {
                 c._nextState = c._nextState.$dup();
@@ -879,7 +899,12 @@ module Preact
             c.state = c._nextState;
             c._dirty = false;
 
-            renderResult = c.$render();
+            self.render_buffer.push([])
+            const block_result = c.$render();
+            renderResult = self.render_buffer.pop()
+            if (self["$is_renderable?"](block_result)) {
+              renderResult.push(block_result);
+            }
 
             // Handle setState called in render, see #2553
             c.state = c._nextState;
@@ -892,13 +917,9 @@ module Preact
               snapshot = c.$get_snapshot_before_update(oldProps, oldState);
             }
 
-            if (renderResult !== nil && renderResult != null && renderResult.type === Opal.Fragment && renderResult.key == null) {
-              renderResult = renderResult.props["$[]"]("children");
-            }
-
             diffChildren(
               parentDom,
-              isArray(renderResult) ? renderResult : [renderResult],
+              renderResult, // always is a array
               newVNode,
               oldVNode,
               globalContext,
@@ -973,23 +994,13 @@ module Preact
       }
 
       let vnodeId = 0;
-      const vnode_class = #{::VNode};
-
-      function is_a_vnode(type) { return type === vnode_class; }
-      function is_nil() { return false; }
-      function vnode_eql(me, other) {
-        for(let prop in me) {
-          if (prop === 'props') { continue; }
-          else if (me[prop] != other[prop]) { return false; }
-        }
-        return me.props["$=="](other.props);
-      }
+
+      function is_a_vnode(type) { return type === Opal.VNode; }
 
       self.createVNode = function(type, props, key, ref, original) {
         // V8 seems to be better at detecting type shapes if the object is allocated from the same call site
         // Do not inline into createElement and coerceToVNode!
-        let eql;
-        const vnode = {
+        return {
           type,
           props,
           key,
@@ -1008,12 +1019,8 @@ module Preact
           constructor: undefined,
           _original: (original == null) ? ++vnodeId : original,
           "$is_a?": is_a_vnode,
-          "$==": eql = function(other) { return vnode_eql(vnode, other); },
-          "$eql?": eql,
-          "$nil?": is_nil,
           "$$is_vnode": true
         };
-        return vnode;
       }
 
       self.render = function(vnode, parentDom, replaceNode) {
@@ -1048,7 +1055,7 @@ module Preact
           // our custom `_children` property.
           vnode,
           ov ? oldVNode : EMPTY_OBJ,
-          Opal.hash(),
+          $hash2([], {}),
           parentDom.ownerSVGElement !== undefined,
           nohy_reno ? [replaceNode] : ov ? null : parentDom.firstChild ? slice.call(parentDom.childNodes) : null,
           commitQueue,
@@ -1180,10 +1187,8 @@ module Preact
       attr_accessor :render_buffer
       attr_accessor :rerender_queue
 
-      def is_renderable?(block_result)
-        block_result &&
-          (block_result.JS['$$is_vnode'] || block_result.JS['$$is_string'] || block_result.is_a?(Numeric) ||
-            (block_result.JS['$$is_array'] && `block_result.length > 0` && is_renderable?(block_result[0])))
+      def is_renderable?(res)
+        `(res !== null && res !== undefined && res !== nil && (res.$$is_string || res.$$is_number))`
       end
 
       def create_element(type, props = nil, children = nil)
@@ -1205,9 +1210,9 @@ module Preact
         end
 
         if block_given?
-          `self.render_buffer.push([])`
-          block_result = yield
           %x{
+            self.render_buffer.push([]);
+            const block_result = $yield();
             const c = self.render_buffer.pop();
             if (self["$is_renderable?"](block_result)) { c.push(block_result); }
             if (c.length > 0) { children = c; }
@@ -1215,7 +1220,7 @@ module Preact
         end
 
         %x{
-          if (children !== nil && children !== null) { normalized_props["$[]="]("children", children); }
+          if (children !== nil && children !== null) { $hash_put(normalized_props, "children", children); }
           return self.createVNode(type, normalized_props, key, ref, null);
         }
       end
@@ -1229,8 +1234,9 @@ module Preact
       def _render_element(component, props, &block)
         %x{
           const opr = self.render_buffer;
-          if (typeof block === 'function') self.$create_element.$$p = block.$to_proc();
-          opr[opr.length-1].push(self.$create_element(component, props, nil));
+          if (typeof block === 'function') self.$create_element.$$p = block;
+          if (opr.length > 0) { opr[opr.length-1].push(self.$create_element(component, props, nil)); }
+          else { opr.push(self.$create_element(component, props, nil)); }
         }
         nil
       end

data/lib/route.rb

@@ -10,9 +10,9 @@ class Route < Preact::Component
       component_props = props[:component_props] || {}
       if component
         component = component.constantize if component.is_a?(String)
-        Preact.create_element(component, component_props.merge!({ params: params }))
+        RPE(Preact.create_element(component, component_props.merge!({ params: params })))
       else
-        props[:children]
+        RPE(props[:children])
       end
     end
   end

data/lib/router.rb

@@ -126,7 +126,7 @@ class Router < Preact::Component
     @original_location = @router[:original_location]
     loc = @browser ? current_pathname(@rbase) : current_pathname(@rbase, @original_location)
     @prev_hash = @browser ? loc + `location.search` : loc
-    Preact.create_element(RouterContext.Provider, { value: { router: @router, location: loc }, children: props[:children] })
+    RPE(Preact.create_element(RouterContext.Provider, { value: { router: @router, location: loc }, children: props[:children] }))
   end
 
   component_did_mount do

data/lib/switch.rb

@@ -54,7 +54,6 @@ class Switch < Preact::Component
     originalLocation = router[:originalLocation]
     children = flatten(props[:children])
     location = props[:location]
-    child = nil
     if RUBY_ENGINE == 'opal'
       children.each do |vnode|
         match = nil
@@ -63,7 +62,7 @@ class Switch < Preact::Component
         # this allows to use different components that wrap Route
         # inside of a switch, for example <AnimatedRoute />.
         if vnode.is_a?(VNode) && (match = (p = vnode.JS[:props][:path]) ? matcher.call(p, location || @context[:location]) : [true, {}])[0]
-          child = Preact.clone_element(vnode, { match: match })
+          RPE(Preact.clone_element(vnode, { match: match }))
           break
         end
       end
@@ -71,11 +70,10 @@ class Switch < Preact::Component
       children.each do |vnode|
         match = nil
         if vnode.is_a?(VNode) && (match = (p = vnode.props[:path]) ? matcher.call(p, location || @context[:location]) : [true, {}])[0]
-          child = Preact.clone_element(vnode, { match: match })
+          RPE(Preact.clone_element(vnode, { match: match }))
           break
         end
       end
     end
-    child
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: isomorfeus-preact
 version: !ruby/object:Gem::Version
-  version: 23.6.0.rc5
+  version: 23.7.0.rc1
 platform: ruby
 authors:
 - Jan Biedermann
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-06-22 00:00:00.000000000 Z
+date: 2023-06-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: oj
@@ -78,28 +78,28 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 23.6.0.rc5
+        version: 23.7.0.rc1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 23.6.0.rc5
+        version: 23.7.0.rc1
 - !ruby/object:Gem::Dependency
   name: isomorfeus-redux
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 23.6.0.rc5
+        version: 23.7.0.rc1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 23.6.0.rc5
+        version: 23.7.0.rc1
 - !ruby/object:Gem::Dependency
   name: benchmark-ips
   requirement: !ruby/object:Gem::Requirement