isomorfeus-preact 10.6.29 → 10.6.33

data/lib/preact/component/native_component_constructor.rb

@@ -1,70 +1,77 @@
-module Preact
-  module Component
-    module NativeComponentConstructor
-      # for should_component_update we apply ruby semantics for comparing props
-      # to do so, we convert the props to ruby hashes and then compare
-      # this makes sure, that for example rubys Nil object gets handled properly
-      def self.extended(base)
-        component_name = base.to_s
-        %x{
-          base.preact_component = class extends Opal.global.Preact.Component {
-            constructor(props) {
-              super(props);
-              if (base.$default_state_defined()) {
-                this.state = base.$state().$to_n();
-              } else {
-                this.state = {};
-              };
-              this.__ruby_instance = base.$new(this);
-              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) {
-                    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 {
-                  this[ref] = Opal.global.Preact.createRef();
-                }
-              }
-            }
-            static get displayName() {
-              return #{component_name};
-            }
-            render(props, state) {
-              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); }
-              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) {
+module Preact::Component::NativeComponentConstructor
+  # for should_component_update we apply ruby semantics for comparing props
+  # to do so, we convert the props to ruby hashes and then compare
+  # this makes sure, that for example rubys Nil object gets handled properly
+  def self.extended(base)
+    component_name = base.to_s
+    %x{
+      base.preact_component = class extends Opal.global.Preact.Component {
+        constructor(props) {
+          super(props);
+          if (base.$default_state_defined()) {
+            this.state = base.$state().$to_n();
+          } else {
+            this.state = {};
+          };
+          this.__ruby_instance = base.$new(this);
+          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) {
+                const oper = Opal.Preact;
+                element = oper.native_element_or_component_to_ruby(element);
                 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`)};
+                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);
               }
-              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) {
-              try { base.$validate_prop(propName, props[propName]) }
-              catch (e) { return new Error(componentName + " Error: prop validation failed: " + e.message); }
-              return null;
+              this[ref] = this[ref].bind(this);
+            } else {
+              this[ref] = Opal.global.Preact.createRef();
             }
           }
         }
-      end
-    end
+        static get displayName() {
+          return #{component_name};
+        }
+        render(props, state) {
+          const oper = Opal.Preact;
+          oper.render_buffer.push([]);
+          oper.register_active_component(this);
+          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;
+        }
+        shouldComponentUpdate(next_props, next_state) {
+          const oper = Opal.Preact;
+          if (base.should_component_update_block) {
+            oper.register_active_component(this);
+            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; }
+          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); }
+          return null;
+        }
+      }
+    }
   end
 end

data/lib/preact/component_resolution.rb

@@ -1,94 +1,92 @@
-module Preact
-  module ComponentResolution
-    def self.included(base)
-      base.instance_exec do
-        unless method_defined?(:_preact_component_class_resolution_original_const_missing)
-          alias _preact_component_class_resolution_original_const_missing const_missing
-        end
+module Preact::ComponentResolution
+  def self.included(base)
+    base.instance_exec do
+      unless method_defined?(:_preact_component_class_resolution_original_const_missing)
+        alias _preact_component_class_resolution_original_const_missing const_missing
+      end
 
-        def const_missing(const_name)
-          %x{
-            if (typeof Opal.global[const_name] !== "undefined" && (const_name[0] === const_name[0].toUpperCase())) {
-              var new_const = Opal.Preact.NativeConstantWrapper.$new(Opal.global[const_name], const_name);
-              new_const.preact_component = Opal.global[const_name];
-              Opal.Object.$const_set(const_name, new_const);
-              return new_const;
-            } else {
-              return #{_preact_component_class_resolution_original_const_missing(const_name)};
-            }
+      def const_missing(const_name)
+        %x{
+          if (typeof Opal.global[const_name] !== "undefined" && (const_name[0] === const_name[0].toUpperCase())) {
+            var new_const = Opal.Preact.NativeConstantWrapper.$new(Opal.global[const_name], const_name);
+            new_const.preact_component = Opal.global[const_name];
+            Opal.Object.$const_set(const_name, new_const);
+            return new_const;
+          } else {
+            return #{_preact_component_class_resolution_original_const_missing(const_name)};
           }
-        end
+        }
+      end
 
-        # this is required for autoloading support, as the component may not be loaded and so its method is not registered.
-        # must load it first, done by const_get, and next time the method will be there.
-        unless method_defined?(:_preact_component_class_resolution_original_method_missing)
-          alias _preact_component_class_resolution_original_method_missing method_missing
-        end
+      # this is required for autoloading support, as the component may not be loaded and so its method is not registered.
+      # must load it first, done by const_get, and next time the method will be there.
+      unless method_defined?(:_preact_component_class_resolution_original_method_missing)
+        alias _preact_component_class_resolution_original_method_missing method_missing
+      end
 
-        def method_missing(component_name, *args, &block)
-          # check for ruby component and render it
-          # otherwise pass on method missing
-          %x{
-            var constant = null;
-            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 {
-              try {
-                constant = self.$const_get(component_name);
-                self.iso_preact_const_cache[component_name] = constant;
-              } 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)};
+      def method_missing(component_name, *args, &block)
+        # check for ruby component and render it
+        # otherwise pass on method missing
+        %x{
+          var constant = null;
+          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 {
+            try {
+              constant = self.$const_get(component_name);
+              self.iso_preact_const_cache[component_name] = constant;
+            } catch(err) { }
+          }
+          if (constant && typeof constant.preact_component !== 'undefined') {
+            return Opal.Preact.internal_prepare_args_and_render(constant.preact_component, args, block);
           }
-        end
+          return #{_preact_component_class_resolution_original_method_missing(component_name, *args, block)};
+        }
       end
     end
+  end
 
-    unless method_defined?(:_preact_component_resolution_original_method_missing)
-      alias _preact_component_resolution_original_method_missing method_missing
-    end
+  unless method_defined?(:_preact_component_resolution_original_method_missing)
+    alias _preact_component_resolution_original_method_missing method_missing
+  end
 
-    def method_missing(component_name, *args, &block)
-      # Further on it must check for modules, because $const_get does not take
-      # the full nesting into account, as usually its called via $$ with the
-      # nesting provided by the compiler.
-      %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') {
-          try {
-            constant = self.$const_get(component_name);
-            self.iso_preact_const_cache[component_name] = constant;
-          } catch(err) { }
-        } else {
-          let sc = self.$class();
-          try {
-            constant = sc.$const_get(component_name);
-            self.iso_preact_const_cache[component_name] = constant;
-          } catch(err) {
-            var module_names = sc.$to_s().split("::");
-            var module_name;
-            for (var i = module_names.length - 1; i > 0; i--) {
-              module_name = module_names.slice(0, i).join('::');
-              try {
-                constant = sc.$const_get(module_name).$const_get(component_name, false);
-                self.iso_preact_const_cache[component_name] = constant;
-                break;
-              } catch(err) { }
-            }
+  def method_missing(component_name, *args, &block)
+    # Further on it must check for modules, because $const_get does not take
+    # the full nesting into account, as usually its called via $$ with the
+    # nesting provided by the compiler.
+    %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') {
+        try {
+          constant = self.$const_get(component_name);
+          self.iso_preact_const_cache[component_name] = constant;
+        } catch(err) { }
+      } else {
+        let sc = self.$class();
+        try {
+          constant = sc.$const_get(component_name);
+          self.iso_preact_const_cache[component_name] = constant;
+        } catch(err) {
+          var module_names = sc.$to_s().split("::");
+          var module_name;
+          for (var i = module_names.length - 1; i > 0; i--) {
+            module_name = module_names.slice(0, i).join('::');
+            try {
+              constant = sc.$const_get(module_name).$const_get(component_name, false);
+              self.iso_preact_const_cache[component_name] = constant;
+              break;
+            } 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_resolution_original_method_missing(component_name, *args, block)};
       }
-    end
+      if (constant && typeof constant.preact_component !== 'undefined') {
+        return Opal.Preact.internal_prepare_args_and_render(constant.preact_component, args, block);
+      }
+      return #{_preact_component_resolution_original_method_missing(component_name, *args, block)};
+    }
   end
 end

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/elements.rb

@@ -1,62 +1,60 @@
-module Preact
-  module Elements
-    # https://www.w3.org/TR/html52/fullindex.html#index-elements
-    # https://www.w3.org/TR/SVG11/eltindex.html
-    SUPPORTED_HTML_AND_SVG_ELEMENTS = %w[
-      a abbr address area article aside audio
-      b base bdi bdo blockquote body br button
-      canvas caption cite code col colgroup
-      data datalist dd del details dfn dialog div dl dt
-      em embed
-      fieldset figcaption figure footer form
-      h1 h2 h3 h4 h5 h6 head header hr html
-      i iframe img input ins
-      kbd
-      label legend li link
-      main map mark meta meter
-      nav noscript
-      object ol optgroup option output
-      p param picture pre progress
-      q
-      rp rt rtc ruby
-      s samp script section select small source span strong style sub summary sup
-      table tbody td template textarea tfoot th thead time title tr track
-      u ul
-      var video
-      wbr
-      altGlyph altGlyphDef altGlyphItem animate animateColor animateMotion animateTransform
-      circle clipPath color-profile cursor
-      defs desc
-      ellipse
-      feBlend feColorMatrix feComponentTransfer feComposite feConvolveMatrix feDiffuseLighting
-      feDisplacementMap feDistantLight feFlood feFuncA feFuncB feFuncG feFuncR feGaussianBlur
-      feImage feMerge feMergeNode feMorphology feOffset fePointLight feSpecularLighting
-      feSpotLight feTile feTurbulence
-      filter font font-face font-face-format font-face-name font-face-src font-face-uri foreignObject
-      g glyph glyphRef
-      hkern
-      image
-      line linearGradient
-      marker mask metadata missing-glyph mpath
-      path pattern polygon polyline
-      radialGradient rect
-      script set stop style svg switch symbol
-      text textPath tref tspan
-      use
-      view vkern
-    ]
+module Preact::Elements
+  # https://www.w3.org/TR/html52/fullindex.html#index-elements
+  # https://www.w3.org/TR/SVG11/eltindex.html
+  SUPPORTED_HTML_AND_SVG_ELEMENTS = %w[
+    a abbr address area article aside audio
+    b base bdi bdo blockquote body br button
+    canvas caption cite code col colgroup
+    data datalist dd del details dfn dialog div dl dt
+    em embed
+    fieldset figcaption figure footer form
+    h1 h2 h3 h4 h5 h6 head header hr html
+    i iframe img input ins
+    kbd
+    label legend li link
+    main map mark meta meter
+    nav noscript
+    object ol optgroup option output
+    p param picture pre progress
+    q
+    rp rt rtc ruby
+    s samp script section select small source span strong style sub summary sup
+    table tbody td template textarea tfoot th thead time title tr track
+    u ul
+    var video
+    wbr
+    altGlyph altGlyphDef altGlyphItem animate animateColor animateMotion animateTransform
+    circle clipPath color-profile cursor
+    defs desc
+    ellipse
+    feBlend feColorMatrix feComponentTransfer feComposite feConvolveMatrix feDiffuseLighting
+    feDisplacementMap feDistantLight feFlood feFuncA feFuncB feFuncG feFuncR feGaussianBlur
+    feImage feMerge feMergeNode feMorphology feOffset fePointLight feSpecularLighting
+    feSpotLight feTile feTurbulence
+    filter font font-face font-face-format font-face-name font-face-src font-face-uri foreignObject
+    g glyph glyphRef
+    hkern
+    image
+    line linearGradient
+    marker mask metadata missing-glyph mpath
+    path pattern polygon polyline
+    radialGradient rect
+    script set stop style svg switch symbol
+    text textPath tref tspan
+    use
+    view vkern
+  ]
 
-    SUPPORTED_HTML_AND_SVG_ELEMENTS.each do |element|
-      define_method(element) do |*args, &block|
-        `Opal.Preact.internal_prepare_args_and_render(element, args, block)`
-      end
-      define_method(`element.toUpperCase()`) do |*args, &block|
-        `Opal.Preact.internal_prepare_args_and_render(element, args, block)`
-      end
+  SUPPORTED_HTML_AND_SVG_ELEMENTS.each do |element|
+    define_method(element) do |*args, &block|
+      `Opal.Preact.internal_prepare_args_and_render(element, args, block)`
     end
-
-    def Fragment(*args, &block)
-      `Opal.Preact.internal_prepare_args_and_render(Opal.global.Preact.Fragment, args, block)`
+    define_method(`element.toUpperCase()`) do |*args, &block|
+      `Opal.Preact.internal_prepare_args_and_render(element, args, block)`
     end
   end
+
+  def Fragment(*args, &block)
+    `Opal.Preact.internal_prepare_args_and_render(Opal.global.Preact.Fragment, args, block)`
+  end
 end

data/lib/preact/version.rb

@@ -1,3 +1,3 @@
 module Preact
-  VERSION = '10.6.29'
+  VERSION = '10.6.33'
 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() {

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: isomorfeus-preact
 version: !ruby/object:Gem::Version
-  version: 10.6.29
+  version: 10.6.33
 platform: ruby
 authors:
 - Jan Biedermann
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-02-05 00:00:00.000000000 Z
+date: 2022-02-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: concurrent-ruby
@@ -86,42 +86,42 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.14.8
+        version: 0.14.9
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.14.8
+        version: 0.14.9
 - !ruby/object:Gem::Dependency
   name: isomorfeus-redux
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 4.1.11
+        version: 4.1.15
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 4.1.11
+        version: 4.1.15
 - !ruby/object:Gem::Dependency
   name: isomorfeus-speednode
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.4.8
+        version: 0.4.9
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.4.8
+        version: 0.4.9
 - !ruby/object:Gem::Dependency
   name: dalli
   requirement: !ruby/object:Gem::Requirement
@@ -170,14 +170,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.6.4
+        version: 0.6.5
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.6.4
+        version: 0.6.5
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -206,7 +206,7 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3.10'
-description: Write Preact Components in Ruby.
+description: Write Preact Components in Ruby, including styles and reactive data access.
 email:
 - jan@kursator.com
 executables: []
@@ -449,11 +449,12 @@ files:
 - node_modules/wouter-preact/use-location.d.ts
 - node_modules/wouter-preact/use-location.js
 - package.json
-homepage: http://isomorfeus.com
+homepage: https://isomorfeus.com
 licenses:
 - MIT
 metadata:
   github_repo: ssh://github.com/isomorfeus/gems
+  source_code_uri: https://github.com/isomorfeus/isomorfeus-preact
 post_install_message:
 rdoc_options: []
 require_paths:
@@ -472,5 +473,5 @@ requirements: []
 rubygems_version: 3.3.3
 signing_key:
 specification_version: 4
-summary: Preact for the Isomorfeus Framework Project.
+summary: Preact Components for Isomorfeus.
 test_files: []