isomorfeus-preact 10.6.17 → 10.6.21

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4ccc4b9e2e9c992e268704b23e9e1fdf21d323c5f3a38fb92ec8e35c1b512f2b
-  data.tar.gz: 27bc9c10c4627bbbeb07e087c46d29e5e74be6b1a33b336f8843646eb9ea9236
+  metadata.gz: 76c5ba07f42c9e53b189fed74f0ac51e7041cd9d243b080295e86492cfc12bd8
+  data.tar.gz: 5ae156acd8f5c22acfdca4642df719459183727df885d141a1b72b37268c4304
 SHA512:
-  metadata.gz: e12591ed06bdc60ab93eb88d9d208e2b16159c89901c3a07dd387d2a4a434b93d798855109dc270689bdfeceea1ffd59e0ae4c8e1532e70bbba818127d031c82
-  data.tar.gz: efc7de705de7b59cb84ab654c06b8d10836a631e92a21a51607f310e70ca35f216657ba6639bce91279af5816f59cef6be4949acb0a3954c04cb48d538aa4414
+  metadata.gz: 7aecd0b46f5d6901d435444fe02080d2aa114778bf3de8ce1ee42052226bd06a3d91644bfe73456a8bce24f336769e1347a079b38894f63ef16f3186732a98dd
+  data.tar.gz: a3c3ae921ad2bd80cc5fae87857b299ff206c9026300c99a177b96249b5517eb09b1401a56e287b629cfabf4a613dd37cc39b0fffc95afd64beda63f97bda6ce

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,10 @@ 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]`)}
+                  #{`this.__ruby_instance`.instance_exec(`element`, &`defined_refs[r]`)}
                 }
                 this[ref] = this[ref].bind(this);
               } else {
@@ -56,17 +57,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,10 @@ 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]`)}
+                  #{`this.__ruby_instance`.instance_exec(`element`, &`defined_refs[r]`)}
                 }
                 this[ref] = this[ref].bind(this);
               } else {
@@ -50,16 +51,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,10 @@ 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]`)}
+                    #{`this.__ruby_instance`.instance_exec(`element`, &`defined_refs[r]`)}
                   }
                   this[ref] = this[ref].bind(this);
                 } else {
@@ -35,12 +36,10 @@ 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;
             }

data/lib/preact/version.rb

@@ -1,3 +1,3 @@
 module Preact
-  VERSION = '10.6.17'
+  VERSION = '10.6.21'
 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) {
@@ -169,6 +184,8 @@ module Preact
               else { component_name = active_component.$to_s(); }
               #{Isomorfeus.raise_error(message: "Is #{`value`} a valid method of #{`component_name`}? If so then please use: #{`key`}: method_ref(:#{`value`}) within component: #{`component_name`}")}
             }
+          } else if (type === "object" && value === nil) {
+              result[self.lower_camelize(key)] = null;
           } else {
             let active_component = self.active_component();
             let component_name;

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: isomorfeus-preact
 version: !ruby/object:Gem::Version
-  version: 10.6.17
+  version: 10.6.21
 platform: ruby
 authors:
 - Jan Biedermann
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-01-27 00:00:00.000000000 Z
+date: 2022-01-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: concurrent-ruby
@@ -86,14 +86,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.14.6
+        version: 0.14.7
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.14.6
+        version: 0.14.7
 - !ruby/object:Gem::Dependency
   name: isomorfeus-redux
   requirement: !ruby/object:Gem::Requirement