isomorfeus-preact 10.8.2 → 22.9.0.rc1

data/lib/isomorfeus_preact/lucid_func/native_component_constructor.rb

@@ -1,56 +0,0 @@
-module LucidFunc::NativeComponentConstructor
-  def self.extended(base)
-    component_name = base.to_s
-    %x{
-      base.css_styles = null;
-      base.instance_init = function(initial) {
-        let ruby_state = { instance: #{base.new(`{}`)} };
-        ruby_state.instance.__ruby_instance = ruby_state.instance;
-        ruby_state.instance.data_access = function() { return this.props.iso_store; }
-        ruby_state.instance.data_access.bind(ruby_state.instance);
-        return ruby_state;
-      }
-      base.instance_reducer = function(state, action) { return state; }
-      base.preact_component = function(props) {
-        const og = Opal.global;
-        const oper = Opal.Preact;
-        oper.render_buffer.push([]);
-        // console.log("function pushed", oper.render_buffer, oper.render_buffer.toString());
-        // Lucid functionality
-        let context = og.PreactHooks.useContext(og.LucidApplicationContext);
-        // prepare Ruby instance
-        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.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);
-        // console.log("function popping", oper.render_buffer, oper.render_buffer.toString());
-        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
-  end
-end

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

@@ -1,140 +0,0 @@
-module Preact::FunctionComponent::Api
-  def self.included(base)
-    base.instance_exec do
-      def to_js
-        self.JS[:preact_component]
-      end
-    end
-  end
-
-  def props
-    @native_props
-  end
-
-  def use_callback(*deps, &block)
-    `Opal.global.PreactHooks.useCallback(function() { #{block.call} }, deps)`
-  end
-
-  def use_context(context)
-    native_context = `(typeof context.$is_wrapped_context !== 'undefined')` ? context.to_n : context
-    `Opal.global.PreactHooks.useContext(native_context)`
-  end
-
-  def use_debug_value(value, formatter)
-    formatter = `null` unless formatter
-    `Opal.global.PreactHooks.useDebugValue(value, formatter)`
-  end
-
-  def use_effect(*args, &block)
-    `Opal.global.PreactHooks.useEffect(function() { #{block.call} }, args)`
-  end
-
-  def use_error_boundary(&block)
-    error = nil
-    reset_error = nil
-    %x{
-      let _error;
-      let _reset_error;
-      if (block) {
-        [_error, reset_error] = Opal.global.PreactHooks.useErrorBoundary(function() { #{block.call(Error(_error))} });
-      } else {
-        [_error, reset_error] = Opal.global.PreactHooks.useErrorBoundary();
-      }
-      error = #{Error(e)};
-    }
-    [error, reset_error]
-  end
-
-  def use_imperative_handle(ruby_ref, *args, &block)
-    ref = ruby_ref.to_n
-    args = `null` if args.empty?
-    `Opal.global.PreactHooks.useImperativeHandle(ref, function() { #{block.call} }, args)`
-  end
-
-  def use_layout_effect(&block)
-    `Opal.global.PreactHooks.useLayoutEffect(function() { #{block.call} })`
-  end
-
-  def use_memo(*deps, &block)
-    `Opal.global.PreactHooks.useMemo(function() { #{block.call} }, deps)`
-  end
-
-  def use_reducer(inital_state, &block)
-    state = nil
-    dispatcher = nil
-    %x{
-      [state, dispatcher] = Opal.global.PreactHooks.useReducer(function(state, action) {
-        #{block.call(state, action)}
-      }, initial_state);
-    }
-    [state, proc { |arg| `dispatcher(arg)` }]
-  end
-
-  def use_ref(native_ref)
-    Preact::Ref.new(`Opal.global.PreactHooks.useRef(native_ref)`)
-  end
-
-  def use_state(initial_value)
-    initial = nil
-    setter = nil
-    `[initial, setter] = Opal.global.PreactHooks.useState(initial_value);`
-    [initial, proc { |arg| `setter(arg)` }]
-  end
-
-  def get_preact_element(arg, &block)
-    `let operabu = Opal.Preact.render_buffer`
-    if block_given?
-      # execute block, fetch last element from buffer
-      %x{
-        let last_buffer_length = operabu[operabu.length - 1].length;
-        let last_buffer_element = operabu[operabu.length - 1][last_buffer_length - 1];
-        block.$call();
-        // console.log("get_preact_element popping", operabu, operabu.toString())
-        let new_element = operabu[operabu.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", operabu, operabu.toString())`
-      `operabu[operabu.length - 1].pop()`
-    end
-  end
-  alias gpe get_preact_element
-
-  def history
-    Isomorfeus.browser_history
-  end
-
-  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 method_ref(method_symbol, *args)
-    method_key = "#{method_symbol}#{args}"
-    %x{
-      if (#{self}.method_refs?.[#{method_key}]) { return #{self}.method_refs[#{method_key}]; }
-      if (!#{self}.method_refs) { #{self}.method_refs = {}; }
-      #{self}.method_refs[#{method_key}] = { m: null, a: args };
-      let r = #{self}.method_refs[#{method_key}];
-      let dev = #{Isomorfeus.development?};
-      r.preact_event_handler_function = function(event, info) {
-        let ruby_event = Opal.Preact.native_to_ruby_event(event);
-        if (!r.m || dev) { r.m = #{method(method_symbol)} };
-        if (r.a.length > 0) { r.m.$call.apply(r.m, [ruby_event, info].concat(r.a)); }
-        else { r.m.$call(ruby_event, info); }
-      };
-      return #{self}.method_refs[#{method_key}];
-    }
-  end
-  alias m_ref method_ref
-
-  def to_n
-    self
-  end
-end

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

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

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

@@ -1,6 +0,0 @@
-module Preact::FunctionComponent::Initializer
-  def initialize
-    self.JS[:native_props] = `{ props: null }`
-    @native_props = `Opal.Preact.Props.$new(self)`
-  end
-end

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

@@ -1,8 +0,0 @@
-module Preact::FunctionComponent::Mixin
-  def self.included(base)
-    base.include(::Preact::Elements)
-    base.include(::Preact::FunctionComponent::Initializer)
-    base.include(::Preact::FunctionComponent::Api)
-    base.extend(::Preact::FunctionComponent::NativeComponentConstructor)
-  end
-end

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

@@ -1,47 +0,0 @@
-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
-  end
-end

data/lib/lucid_app/context.rb

@@ -1,24 +0,0 @@
-module LucidApp
-  module Context
-    def self.create_application_context
-      nano_css = `null`
-      css_server = `null`
-      css_server = `document.getElementById('css-server-side')` unless on_ssr?
-      %x{
-        let n = Opal.NanoCSS;
-        nano_css = (css_server) ? n.create({ sh: css_server }) : n.create();
-        n.rule(nano_css);
-        n.sheet(nano_css);
-        n.nesting(nano_css);
-        n.hydrate(nano_css);
-        n.unitless(nano_css);
-        n.global(nano_css);
-        n.keyframes(nano_css);
-        n.fadeIn(nano_css);
-        n.fadeOut(nano_css);
-        Opal.global.NanoCSSInstance = nano_css;
-      }
-      Preact.create_context('LucidApplicationContext', { iso_store: Isomorfeus.store, nano_css: nano_css })
-    end
-  end
-end

data/lib/lucid_prop_declaration/mixin.rb

@@ -1,126 +0,0 @@
-module LucidPropDeclaration
-  module Mixin
-    if RUBY_ENGINE == 'opal'
-      def self.extended(base)
-        def prop(prop_name, validate_hash = { required: true })
-          validate_hash = validate_hash.to_h if validate_hash.class == Isomorfeus::Props::ValidateHashProxy
-          if validate_hash.key?(:default)
-            %x{
-              if (base.lucid_preact_component) {
-                let preact_prop_name = Opal.Preact.lower_camelize(prop_name);
-                #{value = validate_hash[:default]}
-                if (!base.lucid_preact_component.defaultProps) { base.lucid_preact_component.defaultProps = {}; }
-                base.lucid_preact_component.defaultProps[preact_prop_name] = value;
-                if (!base.lucid_preact_component.propTypes) { base.lucid_preact_component.propTypes = {}; }
-                base.lucid_preact_component.propTypes[preact_prop_name] = base.lucid_preact_component.prototype.validateProp;
-              } else if (base.preact_component) {
-                let preact_prop_name = Opal.Preact.lower_camelize(prop_name);
-                #{value = validate_hash[:default]}
-                if (!base.preact_component.defaultProps) { base.preact_component.defaultProps = {}; }
-                base.preact_component.defaultProps[preact_prop_name] = value;
-                if (!base.preact_component.propTypes) { base.preact_component.propTypes = {}; }
-                base.preact_component.propTypes[preact_prop_name] = base.preact_component.prototype.validateProp;
-              }
-            }
-          end
-          declared_props[prop_name.to_sym] = validate_hash
-        end
-      end
-
-      def validate_function
-        %x{
-          if (typeof self.validate_function === 'undefined') {
-            self.validate_function = function(props_object) {
-              try { self.$validate_props(Opal.Hash.$new(props_object)) }
-              catch (e) { return e.message; }
-            }
-          }
-          return self.validate_function;
-        }
-      end
-
-      def validate_prop_function(prop)
-        function_name = "validate_#{prop}_function"
-        %x{
-          if (typeof self[function_name] === 'undefined') {
-            self[function_name] = function(value) {
-              try { self.$validate_prop(prop, value); }
-              catch (e) { return e.message; }
-            }
-          }
-          return self[function_name];
-        }
-      end
-    else
-      def prop(prop_name, validate_hash = { required: true })
-        validate_hash = validate_hash.to_h if validate_hash.class == Isomorfeus::Props::ValidateHashProxy
-        declared_props[prop_name.to_sym] = validate_hash
-      end
-    end
-
-    def declared_props
-      @declared_props ||= {}
-    end
-
-    def valid_prop?(prop, value)
-      validate_prop(prop, value)
-    rescue
-      false
-    end
-
-    def valid_props?(props)
-      validate_props(props)
-    rescue
-      false
-    end
-
-    def validate
-      Isomorfeus::Props::ValidateHashProxy.new
-    end
-
-    def validate_prop(prop, value)
-      return false unless declared_props.key?(prop)
-      validator = Isomorfeus::Props::Validator.new(self, prop, value, declared_props[prop])
-      validator.validate!
-      true
-    end
-
-    def validate_props(props)
-      props = {} unless props
-      declared_props.each_key do |prop|
-        if declared_props[prop].key?(:required) && declared_props[prop][:required] && !props.key?(prop)
-          Isomorfeus.raise_error(message: "Required prop '#{prop}' not given!")
-        end
-      end
-      result = true
-      props.each do |p, v|
-        r = validate_prop(p, v)
-        result = false unless r
-      end
-      result
-    end
-
-    def validated_prop(prop, value)
-      Isomorfeus.raise_error(message: "No such prop '#{prop}' declared!") unless declared_props.key?(prop)
-      validator = Isomorfeus::Props::Validator.new(self, prop, value, declared_props[prop])
-      validator.validated_value
-    end
-
-    def validated_props(props)
-      props = {} unless props
-
-      declared_props.each_key do |prop|
-        if declared_props[prop].key?(:required) && declared_props[prop][:required] && !props.key?(prop)
-          Isomorfeus.raise_error(message: "Required prop '#{prop}' not given!")
-        end
-        props[prop] = nil unless props.key?(prop) # let validator handle value
-      end
-
-      result = {}
-      props.each do |p, v|
-        result[p] = validated_prop(p, v)
-      end
-      result
-    end
-  end
-end

data/lib/preact/component/api.rb

@@ -1,137 +0,0 @@
-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
-
-      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
-
-      def to_js
-        self.JS[:preact_component]
-      end
-    end
-  end
-
-  def display_name
-    @native.JS[:displayName]
-  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)
-    `const operabu = Opal.Preact.render_buffer`
-    if block_given?
-      # execute block, fetch last element from buffer
-      %x{
-        let last_buffer_length = operabu[operabu.length - 1].length;
-        let last_buffer_element = operabu[operabu.length - 1][last_buffer_length - 1];
-        block.$call();
-        // console.log("get_preact_element popping", operabu, operabu.toString())
-        let new_element = operabu[operabu.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", operabu, operabu.toString())`
-      `operabu[operabu.length - 1].pop()`
-    end
-  end
-  alias gpe get_preact_element
-
-  def history
-    Isomorfeus.browser_history
-  end
-
-  def method_ref(method_symbol, *args)
-    method_key = "#{method_symbol}#{args}"
-    %x{
-      if (#@native.method_refs?.[#{method_key}]) { return #@native.method_refs[#{method_key}]; }
-      if (!#@native.method_refs) { #@native.method_refs = {}; }
-      #@native.method_refs[#{method_key}] = { m: null, a: args };
-      let r = #@native.method_refs[#{method_key}];
-      let dev = #{Isomorfeus.development?};
-      r.preact_event_handler_function = function(event, info) {
-        let ruby_event = Opal.Preact.native_to_ruby_event(event);
-        if (!r.m || dev) { r.m = #{method(method_symbol)} };
-        if (r.a.length > 0) { r.m.$call.apply(r.m, [ruby_event, info].concat(r.a)); }
-        else { r.m.$call(ruby_event, info); }
-      };
-      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,7 +0,0 @@
-module Preact::Component
-  class Base
-    def self.inherited(base)
-      base.include(::Preact::Component::Mixin)
-    end
-  end
-end

data/lib/preact/component/callbacks.rb

@@ -1,111 +0,0 @@
-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, newVNode, oldVNode, errorInfo) {
-            const oper = Opal.Preact;
-            oper.register_active_component(this);
-            try {
-              #{`this.__ruby_instance`.instance_exec(`error`, `newVNode`, `oldVNode`, `errorInfo`, &block)};
-            } catch (e) { console.error(e.message === Opal.nil ? 'error at' : e.message, e.stack); }
-            oper.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() {
-            const oper = Opal.Preact;
-            oper.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); }
-            if (self.preload_did_mount_proc) { #{`this.__ruby_instance`.instance_exec { self.class.JS[:preload_did_mount_proc].call } } }
-            oper.unregister_active_component(this);
-          }
-          if (self.lucid_preact_component) {
-            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) {
-            const oper = Opal.Preact;
-            oper.register_active_component(this);
-            try {
-              #{`this.__ruby_instance`.instance_exec(`oper.Props.$new({props: prev_props})`,
-                                                     `oper.State.$new({state: prev_state})`,
-                                                     `snapshot`, &block)};
-            } catch (e) { console.error(e.message === Opal.nil ? 'error at' : e.message, e.stack); }
-            oper.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() {
-            const oper = Opal.Preact;
-            if (typeof this.unsubscriber === "function") { this.unsubscriber(); };
-            oper.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); }
-            oper.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) {
-            const oper = Opal.Preact;
-            oper.register_active_component(this);
-            try {
-              var result = #{`this.__ruby_instance`.instance_exec(`oper.Props.$new({props: props})`,
-                                                                  `oper.State.$new({state: state})`, &block)};
-            } catch (e) { console.error(e.message === Opal.nil ? 'error at' : e.message, e.stack); }
-            oper.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) {
-            const oper = Opal.Preact;
-            oper.register_active_component(this);
-            try {
-              var result = #{`this.__ruby_instance`.instance_exec(`oper.Props.$new({props: prev_props})`,
-                                                                  `oper.State.$new({state: prev_state})`, &block)};
-            } catch (e) { console.error(e.message === Opal.nil ? 'error at' : e.message, e.stack); }
-            oper.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
-end

data/lib/preact/component/initializer.rb

@@ -1,7 +0,0 @@
-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