isomorfeus-react 16.9.24 → 16.10.0

data/lib/lucid_material/component/base.rb

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

data/lib/lucid_material/component/mixin.rb

@@ -1,20 +0,0 @@
-module LucidMaterial
-  module Component
-    module Mixin
-      def self.included(base)
-        base.include(::Native::Wrapper)
-        base.extend(::LucidMaterial::Component::NativeComponentConstructor)
-        base.extend(::LucidPropDeclaration::Mixin)
-        base.extend(::LucidComponent::EventHandler)
-        base.include(::React::Component::Elements)
-        base.include(::React::Component::API)
-        base.include(::React::Component::Callbacks)
-        base.include(::LucidComponent::StoreAPI)
-        base.include(::LucidComponent::StylesSupport)
-        base.include(::LucidComponent::Initializer)
-        base.include(::React::Component::Features)
-        base.include(::React::Component::Resolution)
-      end
-    end
-  end
-end

data/lib/lucid_material/component/native_component_constructor.rb

@@ -1,118 +0,0 @@
-module LucidMaterial
-  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
-        # language=JS
-        %x{
-          base.lucid_react_component = class extends Opal.global.React.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);
-              this.__object_id = this.__ruby_instance.$object_id().$to_s();
-              if (!this.state.component_state) {
-                this.state.component_state = {};
-                this.state.component_state[this.__object_id] = {};
-              };
-              var event_handlers = #{base.event_handlers};
-              for (var i = 0; i < event_handlers.length; i++) {
-                this[event_handlers[i]] = this[event_handlers[i]].bind(this);
-              }
-              var defined_refs = #{base.defined_refs};
-              for (var ref in defined_refs) {
-                if (defined_refs[ref] != null) {
-                  this[ref] = function(element) {
-                    element = Opal.React.native_element_or_component_to_ruby(element);
-                    #{`this.__ruby_instance`.instance_exec(`element`, &`defined_refs[ref]`)}
-                  }
-                  this[ref] = this[ref].bind(this);
-                } else {
-                  this[ref] = Opal.global.React.createRef();
-                }
-              }
-            }
-            static get displayName() {
-              return #{component_name};
-            }
-            render() {
-              Opal.React.render_buffer.push([]);
-              Opal.React.active_components.push(this);
-              Opal.React.active_redux_components.push(this);
-              #{`this.__ruby_instance`.instance_exec(&`base.render_block`)};
-              Opal.React.active_redux_components.pop();
-              Opal.React.active_components.pop();
-              return Opal.React.render_buffer.pop();
-            }
-            data_access() {
-              return this.context;
-            }
-            shouldComponentUpdate(next_props, next_state) {
-              var next_props_keys = Object.keys(next_props);
-              var this_props_keys = Object.keys(this.props);
-              if (next_props_keys.length !== this_props_keys.length) { return true; }
-
-              var next_state_keys = Object.keys(next_state);
-              var this_state_keys = Object.keys(this.state);
-              if (next_state_keys.length !== this_state_keys.length) { return true; }
-
-              for (var property in next_props) {
-                if (next_props.hasOwnProperty(property)) {
-                  if (!this.props.hasOwnProperty(property)) { return true; };
-                  if (property == "children") { if (next_props.children !== this.props.children) { return true; }}
-                  else if (typeof next_props[property] !== "undefined" && next_props[property] !== null &&
-                           typeof next_props[property]['$!='] !== "undefined" &&
-                           typeof this.props[property] !== "undefined" && this.props[property] !== null &&
-                           typeof this.props[property]['$!='] !== "undefined") {
-                    if (#{ !! (`next_props[property]` != `this.props[property]`) }) { return true; };
-                  } else if (next_props[property] !== this.props[property]) { return true; };
-                }
-              }
-              for (var property in next_state) {
-                if (next_state.hasOwnProperty(property)) {
-                  if (!this.state.hasOwnProperty(property)) { return true; };
-                  if (next_state[property] !== null && typeof next_state[property]['$!='] !== "undefined" &&
-                      this.state[property] !== null && typeof this.state[property]['$!='] !== "undefined") {
-                    if (#{ !! (`next_state[property]` != `this.state[property]`) }) { return true };
-                  } else if (next_state[property] !== this.state[property]) { 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;
-            }
-          };
-          base.lucid_react_component.contextType = Opal.global.LucidApplicationContext;
-          base.jss_styles = null;
-          base.jss_styles_used = null;
-          base.use_styles = null;
-          base.react_component = function(props) {
-            let classes = null;
-            let theme = Opal.global.MuiStyles.useTheme();
-            if (base.jss_styles) {
-              if (!base.use_styles || (Opal.Isomorfeus["$development?"]() && !Object.is(base.jss_styles, base.jss_styles_used))) {
-                base.jss_styles_used = base.jss_styles;
-                let styles = base.jss_styles
-                if (typeof styles === 'function') { styles = styles(theme); }
-                base.use_styles = Opal.global.MuiStyles.makeStyles(styles);
-              }
-              classes = base.use_styles();
-            }
-            let themed_classes_props = Object.assign({}, props, { classes: classes, theme: theme });
-            return Opal.global.React.createElement(base.lucid_react_component, themed_classes_props);
-          }
-        }
-      end
-    end
-  end
-end

data/lib/lucid_prop_declaration/mixin.rb

@@ -1,91 +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_react_component) {
-                let react_prop_name = Opal.React.lower_camelize(prop_name);
-                #{value = validate_hash[:default]}
-                if (!base.lucid_react_component.defaultProps) { base.lucid_react_component.defaultProps = {}; }
-                base.lucid_react_component.defaultProps[react_prop_name] = value;
-                if (!base.lucid_react_component.propTypes) { base.lucid_react_component.propTypes = {}; }
-                base.lucid_react_component.propTypes[react_prop_name] = base.lucid_react_component.prototype.validateProp;
-              } else if (base.react_component) {
-                let react_prop_name = Opal.React.lower_camelize(prop_name);
-                #{value = validate_hash[:default]}
-                if (!base.react_component.defaultProps) { base.react_component.defaultProps = {}; }
-                base.react_component.defaultProps[react_prop_name] = value;
-                if (!base.react_component.propTypes) { base.react_component.propTypes = {}; }
-                base.react_component.propTypes[react_prop_name] = base.react_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 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)
-      declared_props.each_key do |prop|
-        if declared_props[prop].key?(:required) && declared_props[prop][:required] && !props.key?(prop)
-          raise "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
-  end
-end

data/lib/react.rb

@@ -1,195 +0,0 @@
-module React
-  # to_native_react_props: the native_component params is used for event handlers, it keeps the event handlers
-  # it does not need to be compone nt, can be a object with the event handlers
-  # language=JS
-  %x{
-    self.render_buffer = [];
-
-    self.set_validate_prop = function(component, prop_name) {
-      if (typeof component.react_component.propTypes == "undefined") {
-        component.react_component.propTypes = {};
-        component.react_component.propValidations = {};
-        component.react_component.propValidations[prop_name] = {};
-      }
-      component.react_component.propTypes[prop_name] = component.react_component.prototype.validateProp;
-    };
-
-    self.lower_camelize = function(snake_cased_word) {
-      var parts = snake_cased_word.split('_');
-      var res = parts[0];
-
-      for (var i = 1; i < parts.length; i++) {
-            res += parts[i][0].toUpperCase() + parts[i].slice(1);
-      }
-      return res;
-    };
-
-    self.native_element_or_component_to_ruby = function (element) {
-      if (typeof element.__ruby_instance !== 'undefined') { return element.__ruby_instance }
-      if (element instanceof Element || element instanceof Node) { return #{Browser::Element.new(`element`)} }
-      return element;
-    };
-
-    self.to_native_react_props = function(ruby_style_props) {
-        var result = {};
-        var keys = ruby_style_props.$keys();
-        var keys_length = keys.length;
-        for (var i = 0; i < keys_length; i++) {
-          if (keys[i].startsWith("on_")) {
-            var handler = ruby_style_props['$[]'](keys[i]);
-            if (typeof handler === "function") {
-              result[Opal.React.lower_camelize(keys[i])] = handler;
-            } else {
-              var active_component = Opal.React.active_component();
-              result[Opal.React.lower_camelize(keys[i])] = active_component[handler];
-            }
-          } else if (keys[i].startsWith("aria_")) {
-            result[keys[i].replace("_", "-")] = ruby_style_props['$[]'](keys[i]);
-          } else if (keys[i] === "style") {
-            var val = ruby_style_props['$[]'](keys[i]);
-            if (typeof val.$$is_hash !== "undefined") { val = val.$to_n() }
-            result["style"] = val;
-          } else {
-            result[Opal.React.lower_camelize(keys[i])] = ruby_style_props['$[]'](keys[i]);
-          }
-        }
-        return result;
-    };
-
-    self.internal_prepare_args_and_render = function(component, args, block) {
-      if (args.length > 0) {
-        var last_arg = args[args.length - 1];
-        if (typeof last_arg === 'string' || last_arg instanceof String) {
-          if (args.length === 1) { return Opal.React.internal_render(component, null, last_arg, null); }
-          else { return Opal.React.internal_render(component, args[0], last_arg, null); }
-        } else { return Opal.React.internal_render(component, args[0], null, block); }
-      } else { return Opal.React.internal_render(component, null, null, block); }
-    };
-
-    self.internal_render = function(component, props, string_child, block) {
-      let children;
-      let react_element;
-      let native_props = null;
-
-      if (string_child) {
-        children = string_child;
-      } else if (block && block !== nil) {
-        Opal.React.render_buffer.push([]);
-        let block_result = block.$call();
-        let last_buffer_length = Opal.React.render_buffer[Opal.React.render_buffer.length - 1].length;
-        let last_buffer_element = Opal.React.render_buffer[Opal.React.render_buffer.length - 1][last_buffer_length - 1];
-        if (block_result && block_result !== last_buffer_element && (block_result !== nil && (typeof block_result === "string" || typeof block_result.$$typeof === "symbol" ||
-          (typeof block_result.constructor !== "undefined" && block_result.constructor === Array && block_result[0] && typeof block_result[0].$$typeof === "symbol")
-          ))) {
-          Opal.React.render_buffer[Opal.React.render_buffer.length - 1].push(block_result);
-        }
-        children = Opal.React.render_buffer.pop();
-        if (children.length == 1) { children = children[0]; }
-        else if (children.length == 0) { children = null; }
-      }
-      if (props && props !== nil) { native_props = Opal.React.to_native_react_props(props); }
-      react_element = Opal.global.React.createElement(component, native_props, children);
-      Opal.React.render_buffer[Opal.React.render_buffer.length - 1].push(react_element);
-      return react_element;
-    };
-
-    self.active_components = [];
-
-    self.active_component = function() {
-      var length = Opal.React.active_components.length;
-      if (length === 0) { return null; };
-      return Opal.React.active_components[length-1];
-    };
-
-    self.active_redux_components = [];
-
-    self.active_redux_component = function() {
-      var length = Opal.React.active_redux_components.length;
-      if (length === 0) { return null; };
-      return Opal.React.active_redux_components[length-1];
-    };
-  }
-
-  def self.clone_element(ruby_react_element, props = nil, children = nil, &block)
-    block_result = `null`
-    if block_given?
-      block_result = block.call
-      block_result = `null` unless block_result
-    end
-    native_props = props ? `Opal.React.to_native_react_props(props)` : `null`
-    `Opal.global.React.cloneElement(ruby_react_element.$to_n(), native_props, block_result)`
-  end
-
-  def self.create_context(const_name, default_value)
-    %x{
-      Opal.global[const_name] = Opal.global.React.createContext(default_value);
-      var new_const = #{React::ContextWrapper.new(`Opal.global[const_name]`)};
-      #{Object.const_set(const_name, `new_const`)};
-      return new_const;
-    }
-  end
-
-  def self.create_element(type, props = nil, children = nil, &block)
-    %x{
-      let component = null;
-      let native_props = null;
-      if (typeof type.react_component !== 'undefined') {
-        component = type.react_component;
-      } else {
-        component = type;
-      }
-
-      Opal.React.render_buffer.push([]);
-      if (block !== nil) {
-        let block_result = block.$call()
-        let last_buffer_length = Opal.React.render_buffer[Opal.React.render_buffer.length - 1].length;
-        let last_buffer_element = Opal.React.render_buffer[Opal.React.render_buffer.length - 1][last_buffer_length - 1];
-        if (block_result && block_result !== last_buffer_element && (block_result !== nil && (typeof block_result === "string" || typeof block_result.$$typeof === "symbol" ||
-          (typeof block_result.constructor !== "undefined" && block_result.constructor === Array && block_result[0] && typeof block_result[0].$$typeof === "symbol")
-          ))) {
-          Opal.React.render_buffer[Opal.React.render_buffer.length - 1].push(block_result);
-        }
-        children = Opal.React.render_buffer.pop()
-        if (children.length == 1) { children = children[0]; }
-        else if (children.length == 0) { children = null; }
-      }
-      if (props && props !== nil) { native_props = Opal.React.to_native_react_props(props); }
-      return Opal.global.React.createElement(component, native_props, children);
-    }
-  end
-
-  def self.create_factory(type)
-    native_function = `Opal.global.React.createFactory(type)`
-    proc { `native_function.call()` }
-  end
-
-  def self.create_ref
-    React::Ref.new(`Opal.global.React.createRef()`)
-  end
-
-  def self.forwardRef(&block)
-    # TODO whats the return here? A React:Element?, doc says a React node, whats that?
-    `Opal.global.React.forwardRef( function(props, ref) { return block.$call().$to_n(); })`
-  end
-
-  def self.is_valid_element(react_element)
-    `Opal.global.React.isValidElement(react_element)`
-  end
-
-  def self.lazy(import_statement_function)
-    `Opal.global.React.lazy(import_statement_function)`
-  end
-
-  def self.memo(function_component, &block)
-    if block_given?
-      %x{
-        var fun = function(prev_props, next_props) {
-          return #{block.call(::React::Component::Props.new(`{props: prev_props}`), ::React::Component::Props.new(`{props: next_props}`))};
-        }
-        return Opal.global.React.memo(function_component, fun);
-      }
-    else
-      `Opal.global.React.memo(function_component)`
-    end
-  end
-end

data/lib/react/active_support_support.rb

@@ -1,13 +0,0 @@
-class String
-  def demodulize
-    if i = self.rindex("::")
-      self[(i + 2)..-1]
-    else
-      self
-    end
-  end
-
-  def deconstantize
-    self[0, self.rindex("::") || 0] # implementation based on the one in facets' Module#spacename
-  end
-end