isomorfeus-preact 10.6.18 → 10.6.22

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2ea65d13596d480bc9236508994f2fe5e8faed1d74cab03acd6f2c3b272c4446
-  data.tar.gz: 961c5f11b767f30b4db8a7124c2029f0aa748404c175dc8466b67f38ef58292a
+  metadata.gz: 0c7377e941df8a5dd82b65906faa7353cd463aff37722ef42e7545b00967bed8
+  data.tar.gz: 3e4a52c1ea3ab9db460e06deba29a42e915e6e01a2d8c43bbdf7c9eaa8153c3f
 SHA512:
-  metadata.gz: 57baa3fcf48a20fa0693942f0ffd84794b2ae3409a27e8cf925d3f67c27d03dc2ecdd8a5517bdd392cb06f04212892dd1d5d64177e85ddb59dc2e393bf3991be
-  data.tar.gz: 808e9777924661bef69c400af5ab5c04d02f76df9ae644344a474df2e8d14f63e6fcf2754af9cfd1cefab590cfcfedc0c7d18109ca1022341a8358f8f9d829ed
+  metadata.gz: 9010971c7c91b3dd4ee6f97c36d42b783b1885ca6a8ef74aae2c921c4e67f4cc9c1acc5a7b3997808f48338afe9a0fd4518c17d93bced3f12960c816bbd3fe94
+  data.tar.gz: 52d34fd59be865c5edac53bf371813b430f3b2ff85d94047a30b4c64cdb42bb2470435533d19bfeb405eab89597085de8cafaee6d6b8a380953df2902e7bb1ef

data/lib/browser/delegate_native.rb

@@ -16,55 +16,47 @@ module Browser
     # function, that function is invoked with `args`. Otherwise, the property
     # is returned as is.
     def method_missing message, *args, &block
-      property_name = property_for_message(message)
-      property = `#@native[#{property_name}]`
-
-      # translate setting a property
       if message.end_with? '='
+        message = message.chop
+        property_name = property_for_message(message)
         return `#@native[#{property_name}] = args[0]`
-      end
-
-      # If the native element doesn't have this property, bubble it up
-      super unless `#{property_name} in #@native`
-
-      if `property === false`
-        return false
-      elsif `typeof(property) === 'number' && isNaN(property)`
-        return nil
       else
-        property = `property == null ? nil : property`
-      end
-
-      # If it's a method, call it. Otherwise, return it.
-      if `typeof(property) === 'function'`
-        `property.apply(#@native, args)`
-      else
-        property
+        property_name = property_for_message(message)
+
+        %x{
+          let value = #@native[#{property_name}];
+          let type = typeof(value);
+          if (type === 'function') {
+            return value.apply(#@native, args);
+          } else if (value === null || type === 'undefined' || (type === 'number' && isNaN(value))) {
+            return nil;
+          }
+          return value;
+        }
       end
     end
 
     def respond_to_missing? message, include_all
-      return true if message.end_with? '='
-      return true if property_for_message(message)
-
+      message = message.chop if message.end_with? '='
+      property_name = property_for_message(message)
+      return true unless `#{property_name} in #@native`
       false
     end
 
-    def property_for_message message
-      camel_cased_message = message
-        .gsub(/_\w/) { |match| `match[1]`.upcase }
-        .sub(/=$/, '')
-
-      # translate `supported?` to `supported` or `isSupported`
-      if message.end_with? '?'
-        camel_cased_message = camel_cased_message.chop
-        property_type = `typeof(#@native[camel_cased_message])`
-        if property_type == 'undefined'
-          camel_cased_message = "is#{camel_cased_message[0].upcase}#{camel_cased_message[1..-1]}"
-        end
-      end
-
-      camel_cased_message
+    def property_for_message(message)
+      %x{
+        let camel_cased_message;
+        if (typeof(#@native[message]) !== 'undefined') { camel_cased_message = message; }
+        else { camel_cased_message = Opal.Preact.lower_camelize(message) }
+
+        if (camel_cased_message.endsWith('?')) {
+          camel_cased_message = camel_cased_message.substring(0, camel_cased_message.length - 2);
+          if (typeof(#@native[camel_cased_message]) === 'undefined') {
+            camel_cased_message = 'is' + camel_cased_message[0].toUpperCase() + camel_cased_message.substring(0, camel_cased_message.length - 1);
+          }
+        }
+        return camel_cased_message
+      }
     end
   end
 end

data/lib/isomorfeus-preact.rb

@@ -7,7 +7,7 @@ if RUBY_ENGINE == 'opal'
     require 'browser/event'
     require 'browser/event_target'
     require 'browser/delegate_native'
-    require 'browser/element'
+    require 'browser/element' # depends on 'preact'
   end
 
   require 'isomorfeus/preact/config'

data/lib/isomorfeus_preact/lucid_app/native_component_constructor.rb

@@ -33,9 +33,12 @@ module LucidApp
             var defined_refs = #{base.defined_refs};
             for (var ref in defined_refs) {
               if (defined_refs[ref] != null) {
+                let r = ref; // to ensure closure for function below gets correct ref name
                 this[ref] = function(element) {
                   element = oper.native_element_or_component_to_ruby(element);
-                  #{`this.__ruby_instance`.instance_exec(`element`, &`defined_refs[ref]`)}
+                  oper.register_active_component(this);
+                  #{`this.__ruby_instance`.instance_exec(`element`, &`defined_refs[r]`)}
+                  oper.unregister_active_component(this);
                 }
                 this[ref] = this[ref].bind(this);
               } else {
@@ -43,9 +46,9 @@ module LucidApp
               }
             }
             if (base.preload_block) {
-              oper.active_redux_components.push(this);
+              oper.register_active_component(this);
               this.state.preloaded = this.__ruby_instance.$execute_preload_block();
-              oper.active_redux_components.pop();
+              oper.unregister_active_component(this);
             }
             this.listener = this.listener.bind(this);
             this.unsubscriber = Opal.Isomorfeus.store.native.subscribe(this.listener);
@@ -56,17 +59,13 @@ module LucidApp
           render(props, state) {
             const oper = Opal.Preact;
             oper.render_buffer.push([]);
-            // console.log("lucid app pushed", oper.render_buffer, oper.render_buffer.toString());
-            oper.active_components.push(this);
-            oper.active_redux_components.push(this);
+            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); }
-            oper.active_redux_components.pop();
-            oper.active_components.pop();
+            oper.unregister_active_component(this);
             let children = oper.render_buffer.pop();
-            // console.log("lucid app popping", oper.render_buffer, oper.render_buffer.toString());
             return Opal.global.Preact.createElement(Opal.global.LucidApplicationContext.Provider, { value: { iso_store: this.state.isomorfeus_store_state, iso_theme: base.css_theme }}, children);
           }
           data_access() {

data/lib/isomorfeus_preact/lucid_component/native_component_constructor.rb

@@ -29,9 +29,12 @@ module LucidComponent
             var defined_refs = base.$defined_refs();
             for (var ref in defined_refs) {
               if (defined_refs[ref] != null) {
+                let r = ref; // to ensure closure for function below gets correct ref name
                 this[ref] = function(element) {
                   element = oper.native_element_or_component_to_ruby(element);
-                  #{`this.__ruby_instance`.instance_exec(`element`, &`defined_refs[ref]`)}
+                  oper.register_active_component(this);
+                  #{`this.__ruby_instance`.instance_exec(`element`, &`defined_refs[r]`)}
+                  oper.unregister_active_component(this);
                 }
                 this[ref] = this[ref].bind(this);
               } else {
@@ -39,9 +42,9 @@ module LucidComponent
               }
             }
             if (base.preload_block) {
-              oper.active_redux_components.push(this);
+              oper.register_active_component(this);
               this.state.preloaded = this.__ruby_instance.$execute_preload_block();
-              oper.active_redux_components.pop();
+              oper.unregister_active_component(this);
             }
           }
           static get displayName() {
@@ -50,16 +53,12 @@ module LucidComponent
           render(props, state) {
             const oper = Opal.Preact;
             oper.render_buffer.push([]);
-            // console.log("lucid component pushed", oper.render_buffer, oper.render_buffer.toString());
-            oper.active_components.push(this);
-            oper.active_redux_components.push(this);
+            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); }
-            oper.active_redux_components.pop();
-            oper.active_components.pop();
-            // console.log("lucid component popping", oper.render_buffer, oper.render_buffer.toString());
+            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

@@ -23,12 +23,10 @@ module LucidFunc
           const [__ruby_state, __ruby_dispatch] = og.PreactHooks.useReducer(base.instance_reducer, null, base.instance_init);
           const __ruby_instance = __ruby_state.instance;
           __ruby_instance.props = Object.assign({}, props, context);
-          oper.active_components.push(__ruby_instance);
-          oper.active_redux_components.push(__ruby_instance);
+          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); }
-          oper.active_redux_components.pop();
-          oper.active_components.pop();
+          oper.unregister_active_component(__ruby_instance);
           // console.log("function popping", oper.render_buffer, oper.render_buffer.toString());
           let result = oper.render_buffer.pop();
           return (result.length === 1) ? result[0] : result;

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

@@ -13,15 +13,13 @@ module Preact
           base.preact_component = function(props) {
             const oper = Opal.Preact;
             oper.render_buffer.push([]);
-            // console.log("function pushed", oper.render_buffer, oper.render_buffer.toString());
             const [__ruby_state, __ruby_dispatch] = Opal.global.PreactHooks.useReducer(base.instance_reducer, null, base.instance_init);
             const __ruby_instance = __ruby_state.instance;
             __ruby_instance.props = props;
-            oper.active_components.push(__ruby_instance);
+            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); }
-            oper.active_components.pop();
-            // console.log("function popping", oper.render_buffer, oper.render_buffer.toString());
+            oper.unregister_active_component(__ruby_instance);
             let result = oper.render_buffer.pop();
             return (result.length === 1) ? result[0] : result;
           }

data/lib/preact/component/api.rb

@@ -22,7 +22,7 @@ module Preact
           end
 
           def defined_refs
-            @defined_ref ||= `{}`
+            @defined_refs ||= `{}`
           end
 
           def default_state_defined

data/lib/preact/component/callbacks.rb

@@ -7,9 +7,9 @@ module Preact
             # TODO convert error
             %x{
               var fun = function(error) {
-                Opal.Preact.active_redux_components.push(this);
+                Opal.Preact.register_active_component(this);
                 #{`this.__ruby_instance`.instance_exec(`error`, &block)};
-                Opal.Preact.active_redux_components.pop();
+                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; }
@@ -19,9 +19,9 @@ module Preact
           def component_did_mount(&block)
             %x{
               let fun = function() {
-                Opal.Preact.active_redux_components.push(this);
+                Opal.Preact.register_active_component(this);
                 #{`this.__ruby_instance`.instance_exec(&block)};
-                Opal.Preact.active_redux_components.pop();
+                Opal.Preact.unregister_active_component(this);
               }
               if (self.lucid_preact_component) {
                 if (self.lucid_preact_component.prototype.componentDidMount) {
@@ -40,11 +40,11 @@ module Preact
           def component_did_update(&block)
             %x{
               var fun = function(prev_props, prev_state, snapshot) {
-                Opal.Preact.active_redux_components.push(this);
+                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)};
-                Opal.Preact.active_redux_components.pop();
+                Opal.Preact.unregister_active_component(this);
               }
               if (self.lucid_preact_component) { self.lucid_preact_component.prototype.componentDidUpdate = fun; }
               else { self.preact_component.prototype.componentDidUpdate = fun; }
@@ -55,9 +55,9 @@ module Preact
             %x{
               var fun = function() {
                 if (typeof this.unsubscriber === "function") { this.unsubscriber(); };
-                Opal.Preact.active_redux_components.push(this);
+                Opal.Preact.register_active_component(this);
                 #{`this.__ruby_instance`.instance_exec(&block)};
-                Opal.Preact.active_redux_components.pop();
+                Opal.Preact.unregister_active_component(this);
               }
               if (self.lucid_preact_component) { self.lucid_preact_component.prototype.componentWillUnmount = fun; }
               else { self.preact_component.prototype.componentWillUnmount = fun; }
@@ -68,12 +68,12 @@ module Preact
           def get_derived_state_from_props(&block)
             %x{
               var fun = function(props, state) {
-                Opal.Preact.active_redux_components.push(this);
+                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)};
-                Opal.Preact.active_redux_components.pop();
+                Opal.Preact.unregister_active_component(this);
                 if (typeof result.$to_n === 'function') { result = result.$to_n() }
-                if (result === Opal.nil) { return null; }
+                if (result === nil) { return null; }
                 return result;
               }
               if (self.lucid_preact_component) { self.lucid_preact_component.prototype.getDerivedStateFromProps = fun; }
@@ -84,11 +84,11 @@ module Preact
           def get_snapshot_before_update(&block)
             %x{
               var fun = function(prev_props, prev_state) {
-                Opal.Preact.active_redux_components.push(this);
+                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)};
-                Opal.Preact.active_redux_components.pop();
-                if (result === Opal.nil) { return null; }
+                Opal.Preact.unregister_active_component(this);
+                if (result === nil) { return null; }
                 return result;
               }
               if (self.lucid_preact_component) { self.lucid_preact_component.prototype.getSnapshotBeforeUpdate = fun; }

data/lib/preact/component/native_component_constructor.rb

@@ -19,9 +19,13 @@ module Preact
               var defined_refs = #{base.defined_refs};
               for (var ref in defined_refs) {
                 if (defined_refs[ref] != null) {
+                  let r = ref; // to ensure closure for function below gets correct ref name
                   this[ref] = function(element) {
-                    element = Opal.Preact.native_element_or_component_to_ruby(element);
-                    #{`this.__ruby_instance`.instance_exec(`element`, &`defined_refs[ref]`)}
+                    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]`)}
+                    oper.unregister_active_component(this);
                   }
                   this[ref] = this[ref].bind(this);
                 } else {
@@ -35,21 +39,22 @@ module Preact
             render(props, state) {
               const oper = Opal.Preact;
               oper.render_buffer.push([]);
-              // console.log("preact component pushed", oper.render_buffer, oper.render_buffer.toString());
-              oper.active_components.push(this);
+              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); }
-              // console.log("preact component popping", oper.render_buffer, oper.render_buffer.toString());
-              oper.active_components.pop();
+              oper.unregister_active_component(this);
               let result = oper.render_buffer.pop();
               return (result.length === 1) ? result[0] : result;
             }
             shouldComponentUpdate(next_props, next_state) {
+              const oper = Opal.Preact;
               if (base.should_component_update_block) {
-                return #{!!`this.__ruby_instance`.instance_exec(`Opal.Preact.Props.$new({props: next_props})`, `Opal.Preact.State.$new({state: next_state })`, &`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`)};
+                oper.unregister_active_component(this);
               }
-              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; }
+              if (!oper.props_are_equal(this.props, next_props)) { return true; }
+              if (oper.state_is_not_equal(this.state, next_state)) { return true; }
               return false;
             }
             validateProp(props, propName, componentName) {

data/lib/preact/version.rb

@@ -1,3 +1,3 @@
 module Preact
-  VERSION = '10.6.18'
+  VERSION = '10.6.22'
 end

data/lib/preact.rb

@@ -57,8 +57,9 @@ module Preact
     };
 
     self.native_element_or_component_to_ruby = function (element) {
-      if (typeof element.__ruby_instance !== 'undefined') { return element.__ruby_instance }
-      if (element instanceof Element || element instanceof Node) { return #{Browser::Element.new(`element`)} }
+      if (element == null || typeof(element) === 'undefined' ) { return nil; }
+      if (typeof element.__ruby_instance !== 'undefined') { return element.__ruby_instance; }
+      if (element instanceof Element || element instanceof Node) { return #{Browser::Element.new(`element`)}; }
       return element;
     };
 
@@ -95,6 +96,20 @@ module Preact
       return self.active_redux_components[length-1];
     };
 
+    self.register_active_component = function(component) {
+      self.active_components.push(component);
+      if (typeof(component.data_access) === 'function') {
+        self.active_redux_components.push(component);
+      }
+    };
+
+    self.unregister_active_component = function(component) {
+      if (typeof(component.data_access) === 'function') {
+        self.active_redux_components.pop();
+      }
+      self.active_components.pop();
+    };
+
     function isObject(obj) { return (obj && typeof obj === 'object'); }
 
     self.merge_deep = function(one, two) {

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: isomorfeus-preact
 version: !ruby/object:Gem::Version
-  version: 10.6.18
+  version: 10.6.22
 platform: ruby
 authors:
 - Jan Biedermann
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-01-28 00:00:00.000000000 Z
+date: 2022-01-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: concurrent-ruby