isomorfeus-preact 10.9.0 → 22.9.0.rc2

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

data/lib/preact/component/mixin.rb

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

data/lib/preact/component/native_component_constructor.rb

@@ -1,77 +0,0 @@
-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);
-                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);
-              }
-              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);
-          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/context_wrapper.rb

@@ -1,48 +0,0 @@
-module Preact
-  class ContextWrapper
-    include ::Native::Wrapper
-
-    def initialize(native)
-      @native = native
-    end
-
-    def is_wrapped_context
-      true
-    end
-
-    def Consumer(*args, &block)
-      %x{
-        let operabu = Opal.Preact.render_buffer;
-        let props = null;
-
-        if (args.length > 0) { props = Opal.Preact.to_native_preact_props(args[0]); }
-
-        let preact_element = Opal.global.Preact.createElement(this.native.Consumer, props, function(value) {
-          let children = null;
-          if (block !== nil) {
-            operabu.push([]);
-            // console.log("consumer pushed", operabu, operabu.toString());
-            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]; }
-            else if (children.length === 0) { children = null; }
-          }
-          return children;
-        });
-        operabu[operabu.length - 1].push(preact_element);
-      }
-    end
-
-    def Provider(*args, &block)
-      %x{
-        var props = null;
-        if (args.length > 0) { props = Opal.Preact.to_native_preact_props(args[0]); }
-        Opal.Preact.internal_render(this.native.Provider, props, null, block);
-      }
-    end
-  end
-end

data/lib/preact/native_constant_wrapper.rb

@@ -1,29 +0,0 @@
-module Preact
-  class NativeConstantWrapper
-    include ::Native::Wrapper
-
-    def initialize(native, const_name)
-      @native = native
-      @const_name = const_name
-    end
-
-    def method_missing(name, *args, &block)
-      %x{
-        if (name[0] === 'u' && name[1] === 's' && name[2] === 'e') {
-          if (name.indexOf('_') > 0) { name = Opal.Preact.lower_camelize(name); }
-          return #@native[name].call(this, args);
-        }
-        var component = null;
-        var component_type = typeof #@native[name];
-        if (component_type === "function" || component_type === "object") {
-          component = #@native[name];
-        }
-        if (component) {
-          return Opal.Preact.internal_prepare_args_and_render(component, args, block);
-        } else {
-          #{Isomorfeus.raise_error(error_class: NameError, message: "No such native Component #@const_name.#{name}")};
-        }
-      }
-    end
-  end
-end

data/lib/preact/option_hooks.rb

@@ -1,98 +0,0 @@
-module Preact
-  class OptionHooks
-    class << self
-      def debounce_rendering(&block)
-        %x{
-          const old_hook = Opal.global.Preact.options.debounceRendering;
-          Opal.global.Preact.options.debounceRendering = function(callback) {
-            #{block.call};
-            if (old_hook) {
-              old_hook(callback);
-            }
-          }
-        }
-        nil
-      end
-
-      def diffed(&block)
-        # TODO wrap vnode
-        %x{
-          const old_hook = Opal.global.Preact.options.diffed;
-          Opal.global.Preact.options.diffed = function(vnode) {
-            #{block.call(`vnode`)};
-            if (old_hook) {
-              old_hook(vnode);
-            }
-          }
-        }
-        nil
-      end
-
-      def event(&block)
-        %x{
-          const old_hook = Opal.global.Preact.options.event;
-          Opal.global.Preact.options.event = function(event) {
-            ruby_event = #{Browser::Event.new(`event`)}
-            ruby_event = #{block.call(`ruby_event`)};
-            return ruby_event.native;
-          }
-        }
-        nil
-      end
-
-      def request_animation_frame(&block)
-        %x{
-          const old_hook = Opal.global.Preact.options.requestAnimationFrame;
-          Opal.global.Preact.options.requestAnimationFrame = function(callback) {
-            #{block.call};
-            if (old_hook) {
-              old_hook(callback);
-            }
-          }
-        }
-        nil
-      end
-
-      def unmount(&block)
-        # TODO wrap vnode
-        %x{
-          const old_hook = Opal.global.Preact.options.unmount;
-          Opal.global.Preact.options.unmount = function(vnode) {
-            #{block.call(`vnode`)};
-            if (old_hook) {
-              old_hook(vnode);
-            }
-          }
-        }
-        nil
-      end
-
-      def use_debug_value(&block)
-        %x{
-          const old_hook = Opal.global.Preact.options.useDebugValue;
-          Opal.global.Preact.options.useDebugValue = function(value) {
-            #{block.call(`value`)};
-            if (old_hook) {
-              old_hook(value);
-            }
-          }
-        }
-        nil
-      end
-
-      def vnode(&block)
-        %x{
-          const old_hook = Opal.global.Preact.options.unmount;
-          Opal.global.Preact.options.unmount = function(vnode) {
-            #{block.call(`vnode`)};
-            if (old_hook) {
-              old_hook(vnode);
-            }
-          }
-        }
-        nil
-      end
-
-    end
-  end
-end

data/lib/preact/params.rb

@@ -1,16 +0,0 @@
-module Preact
-  class Params
-    include Native::Wrapper
-
-    def method_missing(prop, *args, &block)
-      %x{
-        const p = #@native;
-        if (typeof p[prop] === 'undefined') {
-          prop = Opal.Preact.lower_camelize(prop);
-          if (typeof p[prop] === 'undefined') { return nil; }
-        }
-        return p[prop];
-      }
-    end
-  end
-end

data/lib/preact/props.rb

@@ -1,69 +0,0 @@
-module Preact
-  class Props
-    def initialize(native)
-      @native = native
-    end
-
-    def ==(other_props)
-      %x{
-        if (Opal.Preact.props_are_equal(#@native.props, #{other_props.to_n})) { return true; }
-        return false;
-      }
-    end
-
-    def [](prop)
-      %x{
-        const p = #@native.props;
-        if (typeof p[prop] === 'undefined') {
-          prop = Opal.Preact.lower_camelize(prop);
-          if (typeof p[prop] === 'undefined') { return nil; }
-        }
-        return p[prop];
-      }
-    end
-
-    def key?(k)
-      %x{
-        if (typeof #@native.props[k] !== 'undefined') { return true; }
-        return false;
-      }
-    end
-
-    def method_missing(prop, *args, &block)
-      %x{
-        const p = #@native.props;
-        if (typeof p[prop] === 'undefined') {
-          prop = Opal.Preact.lower_camelize(prop);
-          if (typeof p[prop] === 'undefined') { return nil; }
-        }
-        return p[prop];
-      }
-    end
-
-    def theme
-      `#@native.props.iso_theme`
-    end
-
-    def params
-      return @params if @params
-      return nil if `typeof #@native.props.params === 'undefined'`
-      @params = `Opal.Preact.Params.$new(#@native.props.params)`
-    end
-
-    def to_h
-      `Opal.Hash.$new(#@native.props)`.transform_keys!(&:underscore)
-    end
-
-    def to_json
-      JSON.dump(to_transport)
-    end
-
-    def to_n
-      `#@native.props`
-    end
-
-    def to_transport
-      {}.merge(to_h)
-    end
-  end
-end

data/lib/preact/ref.rb

@@ -1,17 +0,0 @@
-module Preact
-  class Ref
-    include ::Native::Wrapper
-
-    def initialize(native)
-      @native = native
-    end
-    
-    def is_wrapped_ref
-      true
-    end
-
-    def current
-      `Opal.Preact.native_element_or_component_to_ruby(#@native.current)`
-    end
-  end
-end

data/lib/preact/state.rb

@@ -1,87 +0,0 @@
-module Preact
-  class State
-    include ::Native::Wrapper
-
-    def initialize(native)
-      @native = native
-    end
-
-    def ==(other_state)
-      %x{
-        if (Opal.Preact.state_is_not_equal(#@native.state, #{other_state.to_raw_n})) { return false; }
-        return true;
-      }
-    end
-
-    def [](key)
-      %x{
-        if (typeof #@native.state[key] === 'undefined') { return nil; }
-        return #@native.state[key];
-      }
-    end
-
-    def []=(key)
-      new_state = `{}`
-      new_state.JS[(`key.endsWith('=')` ? key.chop : key)] = args[0]
-      @native.JS.setState(new_state, `null`)
-    end
-
-    def key?(k)
-      %x{
-        if (typeof #@native.state[k] !== 'undefined') { return true; }
-        return false;
-      }
-    end
-
-    def method_missing(key, *args, &block)
-      if `args.length > 0`
-        new_state = `{}`
-        new_state.JS[(`key.endsWith('=')` ? key.chop : key)] = args[0]
-        if block_given?
-          @native.JS.setState(new_state, `function() { block.$call(); }`)
-        else
-          @native.JS.setState(new_state, `null`)
-        end
-      else
-        %x{
-          if (typeof #@native.state[key] === 'undefined') { return nil; }
-          return #@native.state[key];
-        }
-      end
-    end
-
-    def set_state(updater, &block)
-      new_state = `{}`
-      updater.each do |key, value|
-        new_state.JS[key] = value
-      end
-      if block_given?
-        @native.JS.setState(new_state, `function() { block.$call(); }`)
-      else
-        @native.JS.setState(new_state, `null`)
-      end
-    end
-
-    def size
-      `Object.keys(#@native.state).length`;
-    end
-
-    def to_n
-      %x{
-        var new_native = {};
-        for (var key in #@native.state) {
-          if (typeof #@native.state[key].$to_n !== "undefined") {
-            new_native[key] = #@native.state[key].$to_n();
-          } else {
-            new_native[key] = #@native.state[key];
-          }
-        }
-        return new_native;
-      }
-    end
-
-    def to_raw_n
-      `#@native.state`
-    end
-  end
-end

data/lib/preact/version.rb

@@ -1,3 +0,0 @@
-module Preact
-  VERSION = '10.9.0'
-end

data/node_modules/.package-lock.json

@@ -1,38 +0,0 @@
-{
-  "name": "isomorfeus-preact",
-  "lockfileVersion": 2,
-  "requires": true,
-  "packages": {
-    "node_modules/preact": {
-      "version": "10.9.0",
-      "resolved": "https://registry.npmjs.org/preact/-/preact-10.9.0.tgz",
-      "integrity": "sha512-jO6/OvCRL+OT8gst/+Q2ir7dMybZAX8ioP02Zmzh3BkQMHLyqZSujvxbUriXvHi8qmhcHKC2Gwbog6Kt+YTh+Q==",
-      "funding": {
-        "type": "opencollective",
-        "url": "https://opencollective.com/preact"
-      }
-    },
-    "node_modules/preact-render-to-string": {
-      "version": "5.2.0",
-      "resolved": "https://registry.npmjs.org/preact-render-to-string/-/preact-render-to-string-5.2.0.tgz",
-      "integrity": "sha512-+RGwSW78Cl+NsZRUbFW1MGB++didsfqRk+IyRVTaqy+3OjtpKK/6HgBtfszUX0YXMfo41k2iaQSseAHGKEwrbg==",
-      "dependencies": {
-        "pretty-format": "^3.8.0"
-      },
-      "peerDependencies": {
-        "preact": ">=10"
-      }
-    },
-    "node_modules/pretty-format": {
-      "version": "3.8.0",
-      "license": "MIT"
-    },
-    "node_modules/wouter-preact": {
-      "version": "2.7.5",
-      "license": "ISC",
-      "peerDependencies": {
-        "preact": "^10.0.0"
-      }
-    }
-  }
-}

data/node_modules/preact/LICENSE

@@ -1,21 +0,0 @@
-The MIT License (MIT)
-
-Copyright (c) 2015-present Jason Miller
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.