isomorfeus-preact 10.6.29 → 10.6.33

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

@@ -1,46 +1,47 @@
-module Preact
-  module FunctionComponent
-    module NativeComponentConstructor
-      def self.extended(base)
-        component_name = base.to_s
-        %x{
-          base.instance_init = function(initial) {
-            let ruby_state = { instance: #{base.new(`{}`)} };
-            ruby_state.instance.__ruby_instance = ruby_state.instance;
-            return ruby_state;
-          }
-          base.instance_reducer = function(state, action) { return state; }
-          base.preact_component = function(props) {
-            const oper = Opal.Preact;
-            oper.render_buffer.push([]);
-            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.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.unregister_active_component(__ruby_instance);
-            let result = oper.render_buffer.pop();
-            return (result.length === 1) ? result[0] : result;
-          }
-          base.preact_component.displayName = #{component_name};
+module Preact::FunctionComponent::NativeComponentConstructor
+  def self.extended(base)
+    component_name = base.to_s
+    %x{
+      base.instance_init = function(initial) {
+        let ruby_state = { instance: #{base.new(`{}`)} };
+        ruby_state.instance.__ruby_instance = ruby_state.instance;
+        return ruby_state;
+      }
+      base.instance_reducer = function(state, action) { return state; }
+      base.preact_component = function(props) {
+        const oper = Opal.Preact;
+        oper.render_buffer.push([]);
+        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.register_active_component(__ruby_instance);
+        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;
+      }
+      base.preact_component.displayName = #{component_name};
+    }
 
-        base_module = base.to_s.deconstantize
-        if base_module != ''
-          base_module.constantize.define_singleton_method(base.to_s.demodulize) do |*args, &block|
-            `Opal.Preact.internal_prepare_args_and_render(#{base}.preact_component, args, block)`
-          end
-        else
-          Object.define_method(base.to_s) do |*args, &block|
-            `Opal.Preact.internal_prepare_args_and_render(#{base}.preact_component, args, block)`
-          end
-        end
-
-        def render(&block)
-          `base.render_block = #{block}`
-        end
+    base_module = base.to_s.deconstantize
+    if base_module != ''
+      base_module.constantize.define_singleton_method(base.to_s.demodulize) do |*args, &block|
+        `Opal.Preact.internal_prepare_args_and_render(#{base}.preact_component, args, block)`
+      end
+    else
+      Object.define_method(base.to_s) do |*args, &block|
+        `Opal.Preact.internal_prepare_args_and_render(#{base}.preact_component, args, block)`
       end
     end
+
+    def render(&block)
+      `base.render_block = #{block}`
+    end
   end
 end

data/lib/preact/component/api.rb

@@ -1,124 +1,120 @@
-module Preact
-  module Component
-    module Api
-      def self.included(base)
-        base.instance_exec do
-          base_module = base.to_s.deconstantize
-          if base_module != ''
-            base_module.constantize.define_singleton_method(base.to_s.demodulize) do |*args, &block|
-              `Opal.Preact.internal_prepare_args_and_render(#{base}.preact_component, args, block)`
-            end
-          else
-            Object.define_method(base.to_s) do |*args, &block|
-              `Opal.Preact.internal_prepare_args_and_render(#{base}.preact_component, args, block)`
-            end
-          end
-
-          attr_accessor :props
-          attr_accessor :state
-
-          def ref(ref_name, &block)
-            defined_refs.JS[ref_name] = block_given? ? block : `null`
-          end
-
-          def defined_refs
-            @defined_refs ||= `{}`
-          end
-
-          def default_state_defined
-            @default_state_defined
-          end
-
-          def state
-            return @default_state if @default_state
-            @default_state_defined = true
-            %x{
-              var native_state = {state: {}};
-              native_state.setState = function(new_state, callback) {
-                for (var key in new_state) {
-                  this.state[key] = new_state[key];
-                }
-                if (callback) { callback.call(); }
-              }
-            }
-            @default_state = `Opal.Preact.State.$new(native_state)`
-          end
-
-          def render(&block)
-            `base.render_block = #{block}`
-          end
-
-          def should_component_update?(&block)
-            `base.should_component_update_block = block`
-          end
+module Preact::Component::Api
+  def self.included(base)
+    base.instance_exec do
+      base_module = base.to_s.deconstantize
+      if base_module != ''
+        base_module.constantize.define_singleton_method(base.to_s.demodulize) do |*args, &block|
+          `Opal.Preact.internal_prepare_args_and_render(#{base}.preact_component, args, block)`
+        end
+      else
+        Object.define_method(base.to_s) do |*args, &block|
+          `Opal.Preact.internal_prepare_args_and_render(#{base}.preact_component, args, block)`
         end
       end
 
-      def display_name
-        @native.JS[:displayName]
+      attr_accessor :props
+      attr_accessor :state
+
+      def ref(ref_name, &block)
+        defined_refs.JS[ref_name] = block_given? ? block : `null`
       end
 
-      def force_update(&block)
-        if block_given?
-          # this maybe needs instance_exec too
-          @native.JS.forceUpdate(`function() { block.$call(); }`)
-        else
-          @native.JS.forceUpdate
-        end
+      def defined_refs
+        @defined_refs ||= `{}`
       end
 
-      def get_preact_element(arg, &block)
-        if block_given?
-          # execute block, fetch last element from buffer
-          %x{
-            let last_buffer_length = Opal.Preact.render_buffer[Opal.Preact.render_buffer.length - 1].length;
-            let last_buffer_element = Opal.Preact.render_buffer[Opal.Preact.render_buffer.length - 1][last_buffer_length - 1];
-            block.$call();
-            // console.log("get_preact_element popping", Opal.Preact.render_buffer, Opal.Preact.render_buffer.toString())
-            let new_element = Opal.Preact.render_buffer[Opal.Preact.render_buffer.length - 1].pop();
-            if (last_buffer_element === new_element) { #{Isomorfeus.raise_error(message: "Block did not create any Preact element!")} }
-            return new_element;
-          }
-        else
-          # element was rendered before being passed as arg
-          # fetch last element from buffer
-          # `console.log("get_preact_element popping", Opal.Preact.render_buffer, Opal.Preact.render_buffer.toString())`
-          `Opal.Preact.render_buffer[Opal.Preact.render_buffer.length - 1].pop()`
-        end
+      def default_state_defined
+        @default_state_defined
       end
-      alias gpe get_preact_element
 
-      def method_ref(method_symbol, *args)
-        method_key = "#{method_symbol}#{args}"
+      def state
+        return @default_state if @default_state
+        @default_state_defined = true
         %x{
-          if (#@native.method_refs && #@native.method_refs[#{method_key}]) { return #@native.method_refs[#{method_key}]; }
-          if (!#@native.method_refs) { #@native.method_refs = {}; }
-          #@native.method_refs[#{method_key}] = { m: #{method(method_symbol)}, a: args };
-          return #@native.method_refs[#{method_key}];
+          var native_state = {state: {}};
+          native_state.setState = function(new_state, callback) {
+            for (var key in new_state) {
+              this.state[key] = new_state[key];
+            }
+            if (callback) { callback.call(); }
+          }
         }
+        @default_state = `Opal.Preact.State.$new(native_state)`
       end
-      alias m_ref method_ref
 
-      def render_preact_element(el)
-        # push el to buffer
-        `Opal.Preact.render_buffer[Opal.Preact.render_buffer.length - 1].push(el)`
-        # `console.log("render_preact_element pushed", Opal.Preact.render_buffer, Opal.Preact.render_buffer.toString())`
-        nil
+      def render(&block)
+        `base.render_block = #{block}`
       end
-      alias rpe render_preact_element
 
-      def ref(name)
-        `#@native[name]`
+      def should_component_update?(&block)
+        `base.should_component_update_block = block`
       end
+    end
+  end
 
-      def ruby_ref(name)
-        return `#@native[name]` if `(typeof #@native[name] === 'function')`
-        `Opal.Preact.Ref.$new(#@native[name])`
-      end
+  def display_name
+    @native.JS[:displayName]
+  end
 
-      def set_state(updater, &callback)
-        @state.set_state(updater, &callback)
-      end
+  def force_update(&block)
+    if block_given?
+      # this maybe needs instance_exec too
+      @native.JS.forceUpdate(`function() { block.$call(); }`)
+    else
+      @native.JS.forceUpdate
+    end
+  end
+
+  def get_preact_element(arg, &block)
+    if block_given?
+      # execute block, fetch last element from buffer
+      %x{
+        let last_buffer_length = Opal.Preact.render_buffer[Opal.Preact.render_buffer.length - 1].length;
+        let last_buffer_element = Opal.Preact.render_buffer[Opal.Preact.render_buffer.length - 1][last_buffer_length - 1];
+        block.$call();
+        // console.log("get_preact_element popping", Opal.Preact.render_buffer, Opal.Preact.render_buffer.toString())
+        let new_element = Opal.Preact.render_buffer[Opal.Preact.render_buffer.length - 1].pop();
+        if (last_buffer_element === new_element) { #{Isomorfeus.raise_error(message: "Block did not create any Preact element!")} }
+        return new_element;
+      }
+    else
+      # element was rendered before being passed as arg
+      # fetch last element from buffer
+      # `console.log("get_preact_element popping", Opal.Preact.render_buffer, Opal.Preact.render_buffer.toString())`
+      `Opal.Preact.render_buffer[Opal.Preact.render_buffer.length - 1].pop()`
     end
   end
+  alias gpe get_preact_element
+
+  def method_ref(method_symbol, *args)
+    method_key = "#{method_symbol}#{args}"
+    %x{
+      if (#@native.method_refs && #@native.method_refs[#{method_key}]) { return #@native.method_refs[#{method_key}]; }
+      if (!#@native.method_refs) { #@native.method_refs = {}; }
+      #@native.method_refs[#{method_key}] = { m: #{method(method_symbol)}, a: args };
+      return #@native.method_refs[#{method_key}];
+    }
+  end
+  alias m_ref method_ref
+
+  def render_preact_element(el)
+    # push el to buffer
+    `Opal.Preact.render_buffer[Opal.Preact.render_buffer.length - 1].push(el)`
+    # `console.log("render_preact_element pushed", Opal.Preact.render_buffer, Opal.Preact.render_buffer.toString())`
+    nil
+  end
+  alias rpe render_preact_element
+
+  def ref(name)
+    `#@native[name]`
+  end
+
+  def ruby_ref(name)
+    return `#@native[name]` if `(typeof #@native[name] === 'function')`
+    `Opal.Preact.Ref.$new(#@native[name])`
+  end
+
+  def set_state(updater, &callback)
+    @state.set_state(updater, &callback)
+  end
 end

data/lib/preact/component/base.rb

@@ -1,9 +1,7 @@
-module Preact
-  module Component
-    class Base
-      def self.inherited(base)
-        base.include(::Preact::Component::Mixin)
-      end
+module Preact::Component
+  class Base
+    def self.inherited(base)
+      base.include(::Preact::Component::Mixin)
     end
   end
-end
+end

data/lib/preact/component/callbacks.rb

@@ -1,101 +1,110 @@
-module Preact
-  module Component
-    module Callbacks
-      def self.included(base)
-        base.instance_exec do
-          def component_did_catch(&block)
-            # TODO convert error
-            %x{
-              var fun = function(error) {
-                Opal.Preact.register_active_component(this);
-                #{`this.__ruby_instance`.instance_exec(`error`, &block)};
-                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; }
-            }
-          end
+module Preact::Component::Callbacks
+  def self.included(base)
+    base.instance_exec do
+      def component_did_catch(&block)
+        # TODO convert error
+        %x{
+          var fun = function(error) {
+            Opal.Preact.register_active_component(this);
+            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
 
-          def component_did_mount(&block)
-            %x{
-              let fun = function() {
-                Opal.Preact.register_active_component(this);
-                #{`this.__ruby_instance`.instance_exec(&block)};
-                Opal.Preact.unregister_active_component(this);
+      def component_did_mount(&block)
+        %x{
+          let fun = function() {
+            Opal.Preact.register_active_component(this);
+            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) {
+            if (self.lucid_preact_component.prototype.componentDidMount) {
+              let fun_one = self.lucid_preact_component.prototype.componentDidMount;
+              let fun_two = fun;
+              fun = function() {
+                fun_one();
+                fun_two();
               }
-              if (self.lucid_preact_component) {
-                if (self.lucid_preact_component.prototype.componentDidMount) {
-                  let fun_one = self.lucid_preact_component.prototype.componentDidMount;
-                  let fun_two = fun;
-                  fun = function() {
-                    fun_one();
-                    fun_two();
-                  }
-                }
-                self.lucid_preact_component.prototype.componentDidMount = fun;
-              } else { self.preact_component.prototype.componentDidMount = fun; }
             }
-          end
+            self.lucid_preact_component.prototype.componentDidMount = fun;
+          } else { self.preact_component.prototype.componentDidMount = fun; }
+        }
+      end
 
-          def component_did_update(&block)
-            %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)};
-                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; }
-            }
-          end
+      def component_did_update(&block)
+        %x{
+          var fun = function(prev_props, prev_state, snapshot) {
+            Opal.Preact.register_active_component(this);
+            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; }
+          else { self.preact_component.prototype.componentDidUpdate = fun; }
+        }
+      end
 
-          def component_will_unmount(&block)
-            %x{
-              var fun = function() {
-                if (typeof this.unsubscriber === "function") { this.unsubscriber(); };
-                Opal.Preact.register_active_component(this);
-                #{`this.__ruby_instance`.instance_exec(&block)};
-                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; }
-            }
-          end
+      def component_will_unmount(&block)
+        %x{
+          var fun = function() {
+            if (typeof this.unsubscriber === "function") { this.unsubscriber(); };
+            Opal.Preact.register_active_component(this);
+            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; }
+          else { self.preact_component.prototype.componentWillUnmount = fun; }
+        }
+      end
 
 
-          def get_derived_state_from_props(&block)
-            %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)};
-                Opal.Preact.unregister_active_component(this);
-                if (typeof result.$to_n === 'function') { result = result.$to_n() }
-                if (result === nil) { return null; }
-                return result;
-              }
-              if (self.lucid_preact_component) { self.lucid_preact_component.prototype.getDerivedStateFromProps = fun; }
-              else { self.preact_component.prototype.getDerivedStateFromProps = fun; }
-            }
-          end
+      def get_derived_state_from_props(&block)
+        %x{
+          var fun = function(props, state) {
+            Opal.Preact.register_active_component(this);
+            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; }
+            return result;
+          }
+          if (self.lucid_preact_component) { self.lucid_preact_component.prototype.getDerivedStateFromProps = fun; }
+          else { self.preact_component.prototype.getDerivedStateFromProps = fun; }
+        }
+      end
 
-          def get_snapshot_before_update(&block)
-            %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)};
-                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; }
-              else { self.preact_component.prototype.getSnapshotBeforeUpdate = fun; }
-            }
-          end
-        end
+      def get_snapshot_before_update(&block)
+        %x{
+          var fun = function(prev_props, prev_state) {
+            Opal.Preact.register_active_component(this);
+            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;
+          }
+          if (self.lucid_preact_component) { self.lucid_preact_component.prototype.getSnapshotBeforeUpdate = fun; }
+          else { self.preact_component.prototype.getSnapshotBeforeUpdate = fun; }
+        }
       end
     end
   end

data/lib/preact/component/initializer.rb

@@ -1,11 +1,7 @@
-module Preact
-  module Component
-    module Initializer
-      def initialize(native_component)
-        @native = native_component
-        @props = `Opal.Preact.Props.$new(#@native)`
-        @state = `Opal.Preact.State.$new(#@native)`
-      end
-    end
+module Preact::Component::Initializer
+  def initialize(native_component)
+    @native = native_component
+    @props = `Opal.Preact.Props.$new(#@native)`
+    @state = `Opal.Preact.State.$new(#@native)`
   end
 end

data/lib/preact/component/mixin.rb

@@ -1,15 +1,11 @@
-module Preact
-  module Component
-    module Mixin
-      def self.included(base)
-        base.include(::Native::Wrapper)
-        base.extend(::Preact::Component::NativeComponentConstructor)
-        base.extend(::LucidPropDeclaration::Mixin)
-        base.include(::Preact::Elements)
-        base.include(::Preact::Component::Api)
-        base.include(::Preact::Component::Callbacks)
-        base.include(::Preact::Component::Initializer)
-      end
-    end
+module Preact::Component::Mixin
+  def self.included(base)
+    base.include(::Native::Wrapper)
+    base.extend(::Preact::Component::NativeComponentConstructor)
+    base.extend(::LucidPropDeclaration::Mixin)
+    base.include(::Preact::Elements)
+    base.include(::Preact::Component::Api)
+    base.include(::Preact::Component::Callbacks)
+    base.include(::Preact::Component::Initializer)
   end
 end