isomorfeus-preact 10.6.26 → 10.6.30

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0d26f73d028c328b0dc47a55e0bb2c7c413df5b8ab7b186952e50949d96dde08
-  data.tar.gz: 5952469a0ea71a67f3176f6551e91ed1968dbf0c58131026c6a81d938acc9e75
+  metadata.gz: 261bf828fca3276232e1cc9a57f32cb6bd45ddd0fa2d386c42dc799813a5f110
+  data.tar.gz: a18cdda3bbb233fd376f90c0cabda7637cd110a34697e2a2d7710e78249775db
 SHA512:
-  metadata.gz: 3c44c6fc3355ff2f600e9db9debc14804ff7578339af433a5fb271962412a4f530fd401fb592a3267a3845908f328fb94fa9721ca6859a3c701335298a5d3b8f
-  data.tar.gz: 65728c2ecc71694b1794d6c4f5d94c5cc9e962db84e4c38569bb36beb6985e408aeaad8e1c77cade61f842c5a8c3d1af0138a80569859b8d3f37a995ddfe74fd
+  metadata.gz: a76b3e58d5d4fd34409126b93487eb8f257509f6c9ff4697248c60333d51c416b1232bc78c4e72d694fbbab5b2392405cdda5aa40310f500e0a53e8d7e61e76b
+  data.tar.gz: ea99ad3ec25838e3c6c94d971e529fe92b7ba7597e685578fcd097a62a852e095faae7f10d18d7822d5880510350ac1997578818d4cde8ae9a45bd2ec9a8f971

data/lib/isomorfeus_preact/lucid_app/native_component_constructor.rb

@@ -37,7 +37,9 @@ module LucidApp
                 this[ref] = function(element) {
                   element = oper.native_element_or_component_to_ruby(element);
                   oper.register_active_component(this);
-                  #{`this.__ruby_instance`.instance_exec(`element`, &`defined_refs[r]`)}
+                  try {
+                    #{`this.__ruby_instance`.instance_exec(`element`, &`defined_refs[r]`)}
+                  } catch (e) { console.error(e.message === nil ? 'error at' : e.message, e.stack); }
                   oper.unregister_active_component(this);
                 }
                 this[ref] = this[ref].bind(this);
@@ -47,7 +49,7 @@ module LucidApp
             }
             if (base.preload_block) {
               oper.register_active_component(this);
-              this.state.preloaded = this.__ruby_instance.$execute_preload_block();
+              this.state.preloaded = this.__ruby_instance.$execute_preload_block(); // caught in execute_preload_block itself
               oper.unregister_active_component(this);
             }
             this.listener = this.listener.bind(this);
@@ -61,9 +63,14 @@ module LucidApp
             oper.render_buffer.push([]);
             oper.register_active_component(this);
             let block_result;
-            if (base.while_loading_block && !state.preloaded) { block_result = #{`this.__ruby_instance`.instance_exec(&`base.while_loading_block`)}; }
-            else { block_result = #{`this.__ruby_instance`.instance_exec(&`base.render_block`)}; }
-            if (block_result && block_result !== nil) { oper.render_block_result(block_result); }
+            try {
+              if (base.while_loading_block && !state.preloaded) { block_result = #{`this.__ruby_instance`.instance_exec(&`base.while_loading_block`)}; }
+              else { block_result = #{`this.__ruby_instance`.instance_exec(&`base.render_block`)}; }
+              if (block_result && block_result !== nil) { oper.render_block_result(block_result); }
+            } catch (e) {
+              if (oper.using_did_catch) { throw e; }
+              else { console.error(e.message === nil ? 'error at' : e.message, e.stack); }
+            }
             oper.unregister_active_component(this);
             let children = oper.render_buffer.pop();
             return Opal.global.Preact.createElement(Opal.global.LucidApplicationContext.Provider, { value: { iso_store: this.state.isomorfeus_store_state, iso_theme: base.css_theme }}, children);
@@ -78,6 +85,11 @@ module LucidApp
           componentWillUnmount() {
             if (typeof this.unsubscriber === "function") { this.unsubscriber(); }
           }
+          shouldComponentUpdate(next_props, next_state) {
+            if (!Opal.Preact.props_are_equal(this.props, next_props)) { return true; }
+            if (Opal.Preact.state_is_not_equal(this.state, next_state)) { return true; }
+            return false;
+          }
           validateProp(props, propName, componentName) {
             try { base.$validate_prop(propName, props[propName]) }
             catch (e) { return new Error(componentName + ": Error: prop validation failed: " + e.message); }

data/lib/isomorfeus_preact/lucid_component/api.rb

@@ -16,17 +16,14 @@ module LucidComponent
           `base.preload_block = block`
           component_did_mount do
             unless self.state.preloaded
-              @_preload_promise.then { self.state.preloaded = true }.fail do |result|
-                err_text = "#{self.class.name}: preloading failed, last result: #{result.nil? ? 'nil' : result}!"
-                `console.error(err_text)`
-              end
+              @_preload_promise.then { self.state.preloaded = true } if @_preload_promise
             end
           end
         end
 
         def while_loading(option = nil, &block)
           wl_block = proc do
-            if @_preload_promise.resolved?
+            if @_preload_promise && @_preload_promise.resolved?
               instance_exec(&`base.render_block`)
             else
               instance_exec(&block)
@@ -85,8 +82,23 @@ module LucidComponent
 
       # preloading
       def execute_preload_block
-        @_preload_promise = instance_exec(&self.class.JS[:preload_block])
-        @_preload_promise.resolved?
+        begin
+          @_preload_promise = instance_exec(&self.class.JS[:preload_block])
+        rescue => e
+          %x{
+            console.error(e.message);
+            console.error(e.stack);
+          }
+        end
+        if @_preload_promise
+          @_preload_promise.fail do |result|
+            err_text = "#{self.class.name}: preloading failed, last result: #{result.nil? ? 'nil' : result}!"
+            `console.error(err_text)`
+          end
+          @_preload_promise.resolved?
+        else
+          false
+        end
       end
 
       def preloaded?

data/lib/isomorfeus_preact/lucid_component/native_component_constructor.rb

@@ -33,7 +33,9 @@ module LucidComponent
                 this[ref] = function(element) {
                   element = oper.native_element_or_component_to_ruby(element);
                   oper.register_active_component(this);
-                  #{`this.__ruby_instance`.instance_exec(`element`, &`defined_refs[r]`)}
+                  try {
+                    #{`this.__ruby_instance`.instance_exec(`element`, &`defined_refs[r]`)}
+                  } catch (e) { console.error(e.message === nil ? 'error at' : e.message, e.stack); }
                   oper.unregister_active_component(this);
                 }
                 this[ref] = this[ref].bind(this);
@@ -43,7 +45,7 @@ module LucidComponent
             }
             if (base.preload_block) {
               oper.register_active_component(this);
-              this.state.preloaded = this.__ruby_instance.$execute_preload_block();
+              this.state.preloaded = this.__ruby_instance.$execute_preload_block(); // caught in execute_preload_block itself
               oper.unregister_active_component(this);
             }
           }
@@ -55,9 +57,14 @@ module LucidComponent
             oper.render_buffer.push([]);
             oper.register_active_component(this);
             let block_result;
-            if (base.while_loading_block && !state.preloaded) { block_result = #{`this.__ruby_instance`.instance_exec(&`base.while_loading_block`)}; }
-            else { block_result = #{`this.__ruby_instance`.instance_exec(&`base.render_block`)}; }
-            if (block_result && block_result !== nil) { oper.render_block_result(block_result); }
+            try {
+              if (base.while_loading_block && !state.preloaded) { block_result = #{`this.__ruby_instance`.instance_exec(&`base.while_loading_block`)}; }
+              else { block_result = #{`this.__ruby_instance`.instance_exec(&`base.render_block`)}; }
+              if (block_result && block_result !== nil) { oper.render_block_result(block_result); }
+            } catch (e) {
+              if (oper.using_did_catch) { throw e; }
+              else { console.error(e.message === nil ? 'error at' : e.message, e.stack); }
+            }
             oper.unregister_active_component(this);
             let result = oper.render_buffer.pop();
             return (result.length === 1) ? result[0] : result;

data/lib/isomorfeus_preact/lucid_func/native_component_constructor.rb

@@ -24,8 +24,13 @@ module LucidFunc
           const __ruby_instance = __ruby_state.instance;
           __ruby_instance.props = Object.assign({}, props, context);
           oper.register_active_component(__ruby_instance);
-          let block_result = #{`__ruby_instance`.instance_exec(&`base.render_block`)};
-          if (block_result && block_result !== nil) { oper.render_block_result(block_result); }
+          try {
+            let block_result = #{`__ruby_instance`.instance_exec(&`base.render_block`)};
+            if (block_result && block_result !== nil) { oper.render_block_result(block_result); }
+          } catch (e) {
+            if (oper.using_did_catch) { throw e; }
+            else { console.error(e.message === nil ? 'error at' : e.message, e.stack); }
+          }
           oper.unregister_active_component(__ruby_instance);
           // console.log("function popping", oper.render_buffer, oper.render_buffer.toString());
           let result = oper.render_buffer.pop();

data/lib/isomorfeus_preact/preact/function_component/native_component_constructor.rb

@@ -17,8 +17,13 @@ module Preact
             const __ruby_instance = __ruby_state.instance;
             __ruby_instance.props = props;
             oper.register_active_component(__ruby_instance);
-            let block_result = #{`__ruby_instance`.instance_exec(&`base.render_block`)};
-            if (block_result && block_result !== nil) { oper.render_block_result(block_result); }
+            try {
+              let block_result = #{`__ruby_instance`.instance_exec(&`base.render_block`)};
+              if (block_result && block_result !== nil) { oper.render_block_result(block_result); }
+            } catch (e) {
+              if (oper.using_did_catch) { throw e; }
+              else { console.error(e.message === nil ? 'error at' : e.message, e.stack); }
+            }
             oper.unregister_active_component(__ruby_instance);
             let result = oper.render_buffer.pop();
             return (result.length === 1) ? result[0] : result;

data/lib/preact/component/callbacks.rb

@@ -8,11 +8,14 @@ module Preact
             %x{
               var fun = function(error) {
                 Opal.Preact.register_active_component(this);
-                #{`this.__ruby_instance`.instance_exec(`error`, &block)};
+                try {
+                  #{`this.__ruby_instance`.instance_exec(`error`, &block)};
+                } catch (e) { console.error(e.message === Opal.nil ? 'error at' : e.message, e.stack); }
                 Opal.Preact.unregister_active_component(this);
               }
               if (self.lucid_preact_component) { self.lucid_preact_component.prototype.componentDidCatch = fun; }
               else { self.preact_component.prototype.componentDidCatch = fun; }
+              Opal.Preact.using_did_catch = true;
             }
           end
 
@@ -20,7 +23,9 @@ module Preact
             %x{
               let fun = function() {
                 Opal.Preact.register_active_component(this);
-                #{`this.__ruby_instance`.instance_exec(&block)};
+                try {
+                  #{`this.__ruby_instance`.instance_exec(&block)};
+                } catch (e) { console.error(e.message === Opal.nil ? 'error at' : e.message, e.stack); }
                 Opal.Preact.unregister_active_component(this);
               }
               if (self.lucid_preact_component) {
@@ -41,9 +46,11 @@ module Preact
             %x{
               var fun = function(prev_props, prev_state, snapshot) {
                 Opal.Preact.register_active_component(this);
-                #{`this.__ruby_instance`.instance_exec(`Opal.Preact.Props.$new({props: prev_props})`,
-                                                       `Opal.Preact.State.$new({state: prev_state})`,
-                                                       `snapshot`, &block)};
+                try {
+                  #{`this.__ruby_instance`.instance_exec(`Opal.Preact.Props.$new({props: prev_props})`,
+                                                        `Opal.Preact.State.$new({state: prev_state})`,
+                                                        `snapshot`, &block)};
+                } catch (e) { console.error(e.message === Opal.nil ? 'error at' : e.message, e.stack); }
                 Opal.Preact.unregister_active_component(this);
               }
               if (self.lucid_preact_component) { self.lucid_preact_component.prototype.componentDidUpdate = fun; }
@@ -56,7 +63,9 @@ module Preact
               var fun = function() {
                 if (typeof this.unsubscriber === "function") { this.unsubscriber(); };
                 Opal.Preact.register_active_component(this);
-                #{`this.__ruby_instance`.instance_exec(&block)};
+                try {
+                  #{`this.__ruby_instance`.instance_exec(&block)};
+                } catch (e) { console.error(e.message === Opal.nil ? 'error at' : e.message, e.stack); }
                 Opal.Preact.unregister_active_component(this);
               }
               if (self.lucid_preact_component) { self.lucid_preact_component.prototype.componentWillUnmount = fun; }
@@ -69,8 +78,10 @@ module Preact
             %x{
               var fun = function(props, state) {
                 Opal.Preact.register_active_component(this);
-                var result = #{`this.__ruby_instance`.instance_exec(`Opal.Preact.Props.$new({props: props})`,
-                                                                     `Opal.Preact.State.$new({state: state})`, &block)};
+                try {
+                  var result = #{`this.__ruby_instance`.instance_exec(`Opal.Preact.Props.$new({props: props})`,
+                                                                      `Opal.Preact.State.$new({state: state})`, &block)};
+                } catch (e) { console.error(e.message === Opal.nil ? 'error at' : e.message, e.stack); }
                 Opal.Preact.unregister_active_component(this);
                 if (typeof result.$to_n === 'function') { result = result.$to_n() }
                 if (result === nil) { return null; }
@@ -85,8 +96,10 @@ module Preact
             %x{
               var fun = function(prev_props, prev_state) {
                 Opal.Preact.register_active_component(this);
-                var result = #{`this.__ruby_instance`.instance_exec(`Opal.Preact.Props.$new({props: prev_props})`,
-                                                                    `Opal.Preact.State.$new({state: prev_state})`, &block)};
+                try {
+                  var result = #{`this.__ruby_instance`.instance_exec(`Opal.Preact.Props.$new({props: prev_props})`,
+                                                                      `Opal.Preact.State.$new({state: prev_state})`, &block)};
+                } catch (e) { console.error(e.message === Opal.nil ? 'error at' : e.message, e.stack); }
                 Opal.Preact.unregister_active_component(this);
                 if (result === nil) { return null; }
                 return result;

data/lib/preact/component/native_component_constructor.rb

@@ -24,7 +24,9 @@ module Preact
                     const oper = Opal.Preact;
                     element = oper.native_element_or_component_to_ruby(element);
                     oper.register_active_component(this);
-                    #{`this.__ruby_instance`.instance_exec(`element`, &`defined_refs[r]`)}
+                    try {
+                      #{`this.__ruby_instance`.instance_exec(`element`, &`defined_refs[r]`)}
+                    } catch (e) { console.error(e.message === nil ? 'error at' : e.message, e.stack); }
                     oper.unregister_active_component(this);
                   }
                   this[ref] = this[ref].bind(this);
@@ -40,8 +42,13 @@ module Preact
               const oper = Opal.Preact;
               oper.render_buffer.push([]);
               oper.register_active_component(this);
-              let block_result = #{`this.__ruby_instance`.instance_exec(&`base.render_block`)};
-              if (block_result && block_result !== nil) { oper.render_block_result(block_result); }
+              try {
+                let block_result = #{`this.__ruby_instance`.instance_exec(&`base.render_block`)};
+                if (block_result && block_result !== nil) { oper.render_block_result(block_result); }
+              } catch (e) {
+                if (oper.using_did_catch) { throw e; }
+                else { console.error(e.message === nil ? 'error at' : e.message, e.stack); }
+              }
               oper.unregister_active_component(this);
               let result = oper.render_buffer.pop();
               return (result.length === 1) ? result[0] : result;
@@ -50,8 +57,12 @@ module Preact
               const oper = Opal.Preact;
               if (base.should_component_update_block) {
                 oper.register_active_component(this);
-                return #{!!`this.__ruby_instance`.instance_exec(`oper.Props.$new({props: next_props})`, `oper.State.$new({state: next_state })`, &`base.should_component_update_block`)};
+                let result;
+                try {
+                  result = #{!!`this.__ruby_instance`.instance_exec(`oper.Props.$new({props: next_props})`, `oper.State.$new({state: next_state })`, &`base.should_component_update_block`)};
+                } catch (e) { console.error(e.message === nil ? 'error at' : e.message, e.stack); }
                 oper.unregister_active_component(this);
+                return result;
               }
               if (!oper.props_are_equal(this.props, next_props)) { return true; }
               if (oper.state_is_not_equal(this.state, next_state)) { return true; }

data/lib/preact/component_resolution.rb

@@ -29,19 +29,19 @@ module Preact
           # check for ruby component and render it
           # otherwise pass on method missing
           %x{
-            var constant;
+            var constant = null;
             if (typeof self.iso_preact_const_cache === 'undefined') { self.iso_preact_const_cache = {}; }
-            try {
-              if (typeof self.iso_preact_const_cache[component_name] !== 'undefined') {
-                constant = self.iso_preact_const_cache[component_name]
-              } else {
+            if (typeof self.iso_preact_const_cache[component_name] !== 'undefined') {
+              constant = self.iso_preact_const_cache[component_name]
+            } else {
+              try {
                 constant = self.$const_get(component_name);
                 self.iso_preact_const_cache[component_name] = constant;
-              }
-              if (typeof constant.preact_component !== 'undefined') {
-                return Opal.Preact.internal_prepare_args_and_render(constant.preact_component, args, block);
-              }
-            } catch(err) { }
+              } catch(err) { }
+            }
+            if (constant && typeof constant.preact_component !== 'undefined') {
+              return Opal.Preact.internal_prepare_args_and_render(constant.preact_component, args, block);
+            }
             return #{_preact_component_class_resolution_original_method_missing(component_name, *args, block)};
           }
         end
@@ -59,7 +59,6 @@ module Preact
       %x{
         var constant;
         if (typeof self.iso_preact_const_cache === 'undefined') { self.iso_preact_const_cache = {}; }
-
         if (typeof self.iso_preact_const_cache[component_name] !== 'undefined') {
           constant = self.iso_preact_const_cache[component_name]
         } else if (typeof self.$$is_a_module !== 'undefined') {

data/lib/preact/context_wrapper.rb

@@ -5,7 +5,7 @@ module Preact
     def initialize(native)
       @native = native
     end
-    
+
     def is_wrapped_context
       true
     end
@@ -22,8 +22,10 @@ module Preact
           if (block !== nil) {
             operabu.push([]);
             // console.log("consumer pushed", operabu, operabu.toString());
-            let block_result = block.$call(value);
-            if (block_result && block_result !== nil) { Opal.Preact.render_block_result(block_result); }
+            try {
+              let block_result = block.$call(value);
+              if (block_result && block_result !== nil) { Opal.Preact.render_block_result(block_result); }
+            } catch (e) { console.error(e.message === nil ? 'error at' : e.message, e.stack); }
             // console.log("consumer popping", operabu, operabu.toString());
             children = operabu.pop();
             if (children.length === 1) { children = children[0]; }

data/lib/preact/version.rb

@@ -1,3 +1,3 @@
 module Preact
-  VERSION = '10.6.26'
+  VERSION = '10.6.30'
 end

data/lib/preact.rb

@@ -80,6 +80,8 @@ module Preact
       } else { operain(component, null, null, block); }
     };
 
+    self.using_did_catch = false;
+
     self.active_components = [];
 
     self.active_component = function() {
@@ -110,25 +112,6 @@ module Preact
       self.active_components.pop();
     };
 
-    function isObject(obj) { return (obj && typeof obj === 'object'); }
-
-    self.merge_deep = function(one, two) {
-      return [one, two].reduce(function(pre, obj) {
-        Object.keys(obj).forEach(function(key){
-          let pVal = pre[key];
-          let oVal = obj[key];
-          if (Array.isArray(pVal) && Array.isArray(oVal)) {
-            pre[key] = pVal.concat.apply(this, oVal);
-          } else if (isObject(pVal) && isObject(oVal)) {
-            pre[key] = self.merge_deep(pVal, oVal);
-          } else {
-            pre[key] = oVal;
-          }
-        });
-        return pre;
-      }, {});
-    };
-
     self.prop_dictionary = {};
 
     self.to_native_preact_props = function(ruby_style_props) {
@@ -231,23 +214,18 @@ module Preact
       }
     };
 
-    self.deep_force_update = function(component) {
-      if (component.forceUpdate) { component.forceUpdate(); }
-      if (component.__c) { self.deep_force_update(component.__c); }
-      else if (component.base) { self.update_components_from_dom(component.base); }
-    };
-
-    self.update_components_from_dom = function(node, fn) {
-      let children = node.childNodes;
-      for (let i=children && children.length; i--;) {
-        let child = children[i];
-        if (child.__c) { self.deep_force_update(child.__c); }
-        else { self.update_components_from_dom(child, fn); }
+    self.deep_force_update = function(vnode) {
+      if(vnode) {
+        if (vnode.__c && vnode.__c.forceUpdate) { vnode.__c.forceUpdate(); }
+        if (vnode.__k) {
+          for (let i=0; i<vnode.__k.length; i++) {
+            self.deep_force_update(vnode.__k[i]);
+          }
+        }
       }
     };
   }
 
-
   def self.create_element(type, props = nil, children = nil, &block)
     %x{
       const operabu = self.render_buffer;

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: isomorfeus-preact
 version: !ruby/object:Gem::Version
-  version: 10.6.26
+  version: 10.6.30
 platform: ruby
 authors:
 - Jan Biedermann
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-02-03 00:00:00.000000000 Z
+date: 2022-02-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: concurrent-ruby