isomorfeus-preact 10.8.2 → 22.9.0.rc1

data/lib/preact/component.rb

@@ -0,0 +1,222 @@
+module Preact
+  class Component
+    extend Preact::PropDeclarationMixin
+    include Preact::Elements
+    include Preact::ComponentResolution
+
+    class << self
+      def inherited(base)
+        base.instance_exec do
+          base_module = base.to_s.deconstantize
+          unless %w[LucidApp LucidComponent Preact::Component Preact::Context Fragment].include?(base_module)
+            if base_module != ''
+              base_module.constantize.define_singleton_method(base.to_s.demodulize) do |props = nil, &block|
+                Preact._render_element(base, props, &block)
+              end
+            end
+          end
+        end
+      end
+
+      attr_accessor :context_type
+
+      # lifecycle methods
+
+      def component_did_catch(&block)
+        define_method(:component_did_catch) do |error|
+          instance_exec(error, &block)
+          nil
+        end
+      end
+
+      def component_did_mount(&block)
+        define_method(:component_did_mount) do
+          instance_exec(&block)
+          nil
+        end
+      end
+
+      def component_did_update(&block)
+        define_method(:component_did_update) do |prev_props, prev_state, snapshot|
+          instance_exec(prev_props, prev_state, snapshot, &block)
+          nil
+        end
+      end
+
+      def component_will_unmount(&block)
+        define_method(:component_will_unmount) do
+          instance_exec do
+            @provider_subs.delete(self) if @provider_subs
+          end
+          instance_exec(&block)
+          nil
+        end
+      end
+
+      def get_derived_state_from_error(&block)
+        define_method(:get_derived_state_from_error) do |error|
+          instance_exec(error, &block)
+          new_state
+        end
+      end
+
+      def get_derived_state_from_props(&block)
+        define_method(:get_derived_state_from_props) do |next_props, next_state|
+          instance_exec(next_props, next_state, &block)
+        end
+      end
+
+      def get_snapshot_before_update(&block)
+        define_method(:get_snapshot_before_update) do |prev_props, prev_state|
+          instance_exec(prev_props, prev_state, &block)
+        end
+      end
+
+      def render(&block)
+        define_method(:render) do
+          pr = Preact.render_buffer
+          pr.push([])
+          block_result = instance_exec(&block)
+          if Preact.is_renderable?(block_result)
+            pr.pop.push(block_result)
+          else
+            pr.pop
+          end
+        end
+      end
+
+      def should_component_update?(&block)
+        define_method(:should_component_update?) do |next_props, next_state, context|
+          instance_exec(next_props, next_state, context, &block)
+        end
+      end
+
+      # state
+
+      def state
+        @default_state ||= {}
+      end
+
+      def set_state(update)
+        state.merge!(update)
+      end
+
+      # refs
+
+      def ref(ref_name, &block)
+        @declared_refs = {} unless @declared_refs
+        @declared_refs[ref_name] = block
+        attr_reader ref_name
+      end
+    end
+
+    attr_accessor :provider_subs
+    attr_reader :context
+    attr_reader :props
+    attr_reader :state
+
+    if RUBY_ENGINE != 'opal'
+      attr_accessor :__d
+      attr_accessor :__s
+      attr_accessor :__v
+      attr_accessor :_dirty
+      attr_accessor :_next_state
+    end
+
+    def initialize(props, context)
+      @development = Isomorfeus.development?
+      @self_class = self.class
+
+      if RUBY_ENGINE == 'opal'
+        @state = `#@self_class.default_state`&.dup
+        declared_refs = `#@self_class.declared_refs`
+      else
+        @state = @self_class.instance_variable_get(:@default_state)&.dup
+        declared_refs = @self_class.instance_variable_get(:@declared_refs)
+      end
+
+      # props
+      @props = props
+
+      # state
+      @state = {} unless @state
+
+      # context
+      @context = context
+      @context_type = @self_class.context_type
+
+      # refs
+      declared_refs&.each do |ref_name, block|
+        if block
+          cmpnt = self
+          instance_variable_set("@#{ref_name}".to_sym, proc { |element| cmpnt.instance_exec(element, &block) })
+        else
+          instance_variable_set("@#{ref_name}".to_sym, { current: nil })
+        end
+      end
+
+      @method_cache = {}
+    end
+
+    def call(m)
+      return @method_cache[m] if @method_cache.key?(m)
+      @method_cache[m] = method(m)
+    end
+
+    def params
+      @props[:params] || {}
+    end
+
+    def component_will_unmount
+      @provider_subs.delete(self) if @provider_subs
+    end
+
+    def force_update(&block)
+      if @_vnode
+        # Set render mode so that we can differentiate where the render request
+        # is coming from. We need this because forceUpdate should never call
+        # should_component_update
+        @_force = true
+        @_renderCallbacks.push(block.to_n) if block_given?
+        Preact._enqueue_render(self)
+      end
+    end
+
+    def set_state(update, &block)
+      s = if @_nextState && @_nextState != @state
+            @_nextState
+          else
+            @_nextState = @state.dup
+          end
+      s = {} unless s
+
+      update = update.call(s, @props) if update.is_a?(Proc)
+
+      if update
+        s.merge!(update)
+      else
+        return
+      end
+
+      if @_vnode
+        @_renderCallbacks.push(block.to_n) if block_given?
+        Preact._enqueue_render(self)
+      end
+    end
+
+    def get_preact_element(arg, &block)
+      if block_given?
+        el = block.call
+        return el if el
+      end
+      Preact.render_buffer.last.pop
+    end
+    alias gpe get_preact_element
+
+    def render_preact_element(el)
+      Preact.render_buffer.last.push(el)
+      nil
+    end
+    alias rpe render_preact_element
+  end
+end

data/lib/preact/component_resolution.rb

@@ -1,100 +1,66 @@
 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)};
-          }
-        }
-      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;
-          try {
-            if (typeof self.iso_preact_const_cache === 'undefined') { self.iso_preact_const_cache = {}; }
-          } catch(err) {
-            return #{_preact_component_class_resolution_original_method_missing(component_name, *args, block)};
-          }
-          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)};
-        }
-      end
+  if RUBY_ENGINE == 'opal'
+    unless method_defined?(:_preact_component_resolution_original_method_missing)
+      alias _preact_component_resolution_original_method_missing method_missing
     end
-  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;
-      try {
-        if (typeof self.iso_preact_const_cache === 'undefined') { self.iso_preact_const_cache = {}; }
-      } catch(err) {
-        return #{_preact_component_resolution_original_method_missing(component_name, *args, block)};
-      }
-      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 {
+    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{
+        let constant;
         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--) {
+          let module_names = sc.$to_s().split("::");
+          let module_name;
+          for (let 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) {
+          let last = args[args.length-1];
+          #{`Opal.Preact`._render_element(`constant`, `(last === undefined || last === null) ? nil : last`, &block)};
+          return nil;
+        }
+        return #{_preact_component_resolution_original_method_missing(component_name, *args, block)};
       }
-      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
+  else
+    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
+      constant = nil
+      if self.is_a?(Module)
+        constant = const_get(component_name) rescue nil
+      else
+        begin
+          constant = self.class.const_get(component_name)
+        rescue
+          module_names = self.class.to_s.split('::')
+          module_names.each_index do |i|
+            module_name = module_names[0..i].join('::')
+            constant = self.class.const_get(module_name).const_get(component_name, false) rescue nil
+            break if constant
+          end
+        end
+      end
+      if constant
+        Preact._render_element(constant, args.last, &block)
+        nil
+      else
+        _preact_component_resolution_original_method_missing(component_name, *args, block)
+      end
+    end
   end
 end

data/lib/preact/context.rb

@@ -0,0 +1,68 @@
+module Preact
+  class Context
+    def self.create_application_contexts
+      Preact.create_context('LucidApplicationContext', { iso_location: "/", iso_store: {}, iso_theme: {} })
+      Preact.create_context('RouterContext', {})
+    end
+
+    class Provider < Preact::Component
+      attr_reader :context_id
+      attr_reader :subs
+
+      def initialize(props, context)
+        unless props.key?(:value)
+          props = props.merge({ value: get_default_value })
+        end
+        super(props, context)
+        @context_id = get_context_id
+        @child_context = { @context_id => self }
+        @getChildContext = true
+        @subs = []
+      end
+
+      def get_child_context
+        @child_context
+      end
+
+      def render
+        @props[:children]
+      end
+
+      def should_component_update?(next_props, _next_state, _context)
+        if @props[:value] != next_props[:value]
+          @subs.each do |subc|
+            Preact._enqueue_render(subc)
+          end
+        end
+        true
+      end
+
+      def sub(component)
+        @subs.push(component)
+        component.provider_subs = @subs
+      end
+    end
+
+    attr_reader :context_id
+    attr_reader :Provider
+    attr_accessor :value
+
+    def initialize(default_value = nil)
+      @Provider = Class.new(Provider)
+      @value = default_value
+      @context_id = Preact._context_id
+      ctx = self
+      @Provider.define_method(:get_default_value) do
+        ctx.value
+      end
+      @Provider.define_method(:get_context_id) do
+        ctx.context_id
+      end
+    end
+
+    def Consumer(&block)
+      block_result = block.call(@value)
+      Preact.render_buffer.last.push(block_result) if block_result
+    end
+  end
+end

data/lib/preact/elements.rb

@@ -46,15 +46,8 @@ module Preact::Elements
   ]
 
   SUPPORTED_HTML_AND_SVG_ELEMENTS.each do |element|
-    define_method(element) do |*args, &block|
-      `Opal.Preact.internal_prepare_args_and_render(element, args, block)`
+    define_method(element.to_s.underscore.upcase.to_sym) do |props = nil, &block|
+      Preact._render_element(element, props, &block)
     end
-    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/module_component_resolution.rb

@@ -0,0 +1,50 @@
+class Module
+  if RUBY_ENGINE == 'opal'
+    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.
+    def method_missing(component_name, *args, &block)
+      # check for ruby component and render it
+      # otherwise pass on method missing
+      %x{
+        let constant = null;
+        let c = component_name[0];
+        if (c == c.toUpperCase()) {
+          try {
+            constant = self.$const_get(component_name);
+          } catch(err) { }
+          if (constant) {
+            let last = args[args.length-1];
+            #{`Opal.Preact`._render_element(`constant`, `(last === undefined || last === null) ? nil : last`, &block)};
+            return nil;
+          }
+        }
+        return #{_preact_component_class_resolution_original_method_missing(component_name, *args, block)};
+      }
+    end
+  else
+    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.
+    def method_missing(component_name, *args, &block)
+      # check for ruby component and render it
+      # otherwise pass on method missing
+      component_name_s = component_name.to_s
+      c = component_name_s[0]
+      if c == c.upcase
+        constant = const_get(component_name) rescue nil
+        if constant && constant.ancestors.include?(Preact::Component)
+          Preact._render_element(constant, args.last, &block)
+          return nil
+        end
+      end
+      _preact_component_class_resolution_original_method_missing(component_name, *args, block)
+    end
+  end
+end

data/lib/preact/prop_declaration_mixin.rb

@@ -0,0 +1,73 @@
+module Preact
+  module PropDeclarationMixin
+    def declared_props
+      @declared_props ||= {}
+    end
+
+    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
+
+    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