ruby2js 4.0.5 → 4.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6728e4201e77b477a9203551b57de3f23b36077f6012061233d4b072d92886b9
-  data.tar.gz: 7d5e6ef7aa5b9add1477b3cc642cc55714a657f7f962dbb6dd7af6688d45cfb0
+  metadata.gz: 7ff40ad496d47d0ec4fa430f6d04b47b1c0d7ae6f152c479da8de49a9f506a00
+  data.tar.gz: 84de6a0f644de7716d9e094f2944d896c49cafaca082523d4947a5d8f567eddc
 SHA512:
-  metadata.gz: 321dc88308946ff626914ceb87fa93f93bec4f5cde0b660cab75d7df46b52f9ca63da830e7fab4f070b989586ef468b3cdf9d8f682f64b44ee06fef9df5230f7
-  data.tar.gz: 22f5161f0bc03c294fbfd3f32be407030fea293985e1eff4c7d0fc464bd57aaa6a3cfc70e1bf9ed13e9bbb0dbbac9f394b860e76df52ae236b494accd86c840b
+  metadata.gz: 7f34521a4ef3677997f541721dfc5a0eb8e870a567ec2198b9b98e1f0d15270160bc076a070e0e5728b77a6622ba4ed0c133f20c9086dbec1cbb1d736bbe28a2
+  data.tar.gz: 9196de55781c332df1183361bcf1428f51ccebb1e38eab2b2ab9f7e3b30b6502b4176eefac0539eb3079906b955e138ee95971822ea59a775a36af5ca27a8aa5

data/lib/ruby2js/converter.rb

@@ -359,6 +359,7 @@ require 'ruby2js/converter/kwbegin'
 require 'ruby2js/converter/literal'
 require 'ruby2js/converter/logical'
 require 'ruby2js/converter/masgn'
+require 'ruby2js/converter/match'
 require 'ruby2js/converter/module'
 require 'ruby2js/converter/next'
 require 'ruby2js/converter/nil'

data/lib/ruby2js/converter/class.rb

@@ -36,7 +36,8 @@ module Ruby2JS
         end
 
         if inheritance
-          init = s(:def, :initialize, s(:args), s(:super))
+          parent = @namespace.find(inheritance)&.[](:constructor)
+          init = s(:def, :initialize, parent || s(:args), s(:zsuper))
         else
           init = s(:def, :initialize, s(:args), nil)
         end
@@ -58,7 +59,7 @@ module Ruby2JS
           m = m.updated(:def, m.children[1..-1])
         end
 
-        node = if m.type == :def
+        node = if %i(def defm deff).include? m.type
           if m.children.first == :initialize and !visible[:initialize]
             # constructor: remove from body and overwrite init function
             init = m
@@ -89,7 +90,7 @@ module Ruby2JS
             end
           end
 
-        elsif m.type == :defs and m.children.first == s(:self)
+        elsif %i(defs defp).include? m.type and m.children.first == s(:self)
           if m.children[1] =~ /=$/
             # class property setter
             s(:prop, name, m.children[1].to_s[0..-2] =>
@@ -313,7 +314,7 @@ module Ruby2JS
       # prepend constructor
       if init
         constructor = init.updated(:constructor, [name, *init.children[1..-1]])
-        @comments[constructor] = @comments[init] unless @comments[init].empty?
+        visible[:constructor] = init.children[1]
 
         if @ast.type == :class_extend or extend
           if es2015
@@ -329,6 +330,7 @@ module Ruby2JS
           end
         end
 
+        @comments[constructor] = @comments[init] unless @comments[init].empty?
         body.unshift constructor
       end
 
@@ -349,7 +351,7 @@ module Ruby2JS
         self.ivars = ivars
         @class_name = class_name
         @class_parent = class_parent
-        @rbstack.pop
+        @namespace.defineProps @rbstack.pop
         @namespace.leave unless @ast.type == :class_module
       end
     end

data/lib/ruby2js/converter/class2.rb

@@ -99,7 +99,6 @@ module Ruby2JS
           end
           walk[@ast]
 
-          # process leading initializers in constructor
           while constructor.length == 1 and constructor.first.type == :begin
             constructor = constructor.first.children.dup
           end
@@ -116,6 +115,7 @@ module Ruby2JS
             put 'static #$' + cvar.to_s[2..-1]
           end
 
+          # process leading initializers in constructor
           while constructor.length > 0 and constructor.first.type == :ivasgn
             put(index == 0 ? @nl : @sep)
             index += 1

data/lib/ruby2js/converter/match.rb

@@ -0,0 +1,7 @@
+module Ruby2JS
+  class Converter
+    handle :match_pattern do |value, name|
+      parse @ast.updated(:lvasgn, [name.children.first, value]), @state
+    end
+  end
+end

data/lib/ruby2js/converter/send.rb

@@ -323,13 +323,13 @@ module Ruby2JS
         put 'typeof '; parse args.first
 
       elsif ast.children[1] == :is_a? and receiver and args.length == 1
-        parse receiver; put ' instanceof '; parse args.first
+        put '('; parse receiver; put ' instanceof '; parse args.first; put ')'
 
       elsif ast.children[1] == :kind_of? and receiver and args.length == 1
-        parse receiver; put ' instanceof '; parse args.first
+        put '('; parse receiver; put ' instanceof '; parse args.first; put ')'
 
       elsif ast.children[1] == :instance_of? and receiver and args.length == 1
-        parse s(:send, s(:attr, receiver, :constructor), :==, args.first)
+        put '('; parse s(:send, s(:attr, receiver, :constructor), :==, args.first); put ')'
 
       else
         if method == :bind and receiver&.type == :send

data/lib/ruby2js/converter/taglit.rb

@@ -10,8 +10,12 @@ module Ruby2JS
         # disable autobinding in tag literals
         save_autobind, @autobind = @autobind, false
       
-        put tag.children.first
-        parse_all(*children, join: '')
+        if es2015
+          put tag.children.first
+          parse_all(*children, join: '')
+        else
+          parse @ast.updated(:send, [nil, tag.children.last, *children])
+        end
       ensure
         @autobind = save_autobind
       end

data/lib/ruby2js/filter/camelCase.rb

@@ -14,6 +14,9 @@ module Ruby2JS
         attr_reader
         attr_writer
         method_missing
+        is_a?
+        kind_of?
+        instance_of?
       }
 
       CAPS_EXCEPTIONS = {
@@ -28,6 +31,8 @@ module Ruby2JS
       }
 
       def camelCase(symbol)
+        return symbol if ALLOWLIST.include?(symbol.to_s)
+
         should_symbolize = symbol.is_a?(Symbol)
         symbol = symbol
                   .to_s
@@ -99,6 +104,10 @@ module Ruby2JS
         handle_generic_node(super, :arg)
       end
 
+      def on_kwarg(node)
+        handle_generic_node(super, :kwarg)
+      end
+
       def on_lvasgn(node)
         handle_generic_node(super, :lvasgn)
       end
@@ -111,6 +120,14 @@ module Ruby2JS
         handle_generic_node(super, :cvasgn)
       end
 
+      def on_match_pattern(node)
+        handle_generic_node(super, :match_pattern)
+      end
+
+      def on_match_var(node)
+        handle_generic_node(super, :match_var)
+      end
+
       def on_sym(node)
         handle_generic_node(super, :sym)
       end

data/lib/ruby2js/filter/cjs.rb

@@ -7,6 +7,59 @@ module Ruby2JS
     module CJS
       include SEXP
 
+      def options=(options)
+        super
+        @cjs_autoexports = !@disable_autoexports && options[:autoexports]
+      end
+
+      def process(node)
+        return super unless @cjs_autoexports
+
+        list = [node]
+        while list.length == 1 and list.first.type == :begin
+          list = list.first.children.dup
+        end
+
+        replaced = []
+        list.map! do |child|
+          replacement = child
+
+          if [:module, :class].include? child.type and
+            child.children.first.type == :const and
+            child.children.first.children.first == nil \
+          then
+            replacement = s(:send, nil, :export, child)
+          elsif child.type == :casgn and child.children.first == nil
+            replacement = s(:send, nil, :export, child)
+          elsif child.type == :def
+            replacement = s(:send, nil, :export, child)
+          end
+
+          if replacement != child
+            replaced << replacement
+            @comments[replacement] = @comments[child] if @comments[child]
+          end
+
+          replacement
+        end
+
+        if replaced.length == 1 and @cjs_autoexports == :default
+          list.map! do |child|
+            if child == replaced.first
+              replacement = s(:send, nil, :export, s(:send, nil, :default,
+                *child.children[2..-1]))
+              @comments[replacement] = @comments[child] if @comments[child]
+              replacement
+            else
+              child
+            end
+          end
+        end
+
+        @cjs_autoexports = false
+        process s(:begin, *list)
+      end
+
       def on_send(node)
         return super unless node.children[1] == :export
 
@@ -23,9 +76,54 @@ module Ruby2JS
           node.updated(nil, [
             s(:attr, nil, :exports),
             assign.children[0].to_s + '=',
-            *assign.children[1..-1]
+            *process_all(assign.children[1..-1])
           ])
 
+        elsif node.children[2].type == :casgn
+          assign = node.children[2]
+          if assign.children[0] == nil
+            node.updated(nil, [
+              s(:attr, nil, :exports),
+              assign.children[1].to_s + '=',
+              *process_all(assign.children[2..-1])
+            ])
+          else
+            node
+          end
+
+        elsif node.children[2].type == :class
+          assign = node.children[2]
+          if assign.children[0].children[0] != nil
+            node
+          elsif assign.children[1] == nil
+            node.updated(nil, [
+              s(:attr, nil, :exports),
+              assign.children[0].children[1].to_s + '=',
+              s(:block, s(:send, s(:const, nil, :Class), :new),
+              s(:args), *process_all(assign.children[2..-1]))
+            ])
+          else
+            node.updated(nil, [
+              s(:attr, nil, :exports),
+              assign.children[0].children[1].to_s + '=',
+              s(:block, s(:send, s(:const, nil, :Class), :new,
+              assign.children[1]), s(:args), 
+              *process_all(assign.children[2..-1]))
+            ])
+          end
+
+        elsif node.children[2].type == :module
+          assign = node.children[2]
+          if assign.children[0].children[0] != nil
+            node
+          else
+            node.updated(nil, [
+              s(:attr, nil, :exports),
+              assign.children[0].children[1].to_s + '=',
+              s(:class_module, nil, nil, *process_all(assign.children[1..-1]))
+            ])
+          end
+
         elsif \
           node.children[2].type == :send and
           node.children[2].children[0..1] == [nil, :async] and
@@ -49,7 +147,7 @@ module Ruby2JS
           node.updated(nil, [
             s(:attr, nil, :module),
             :exports=,
-            node.children[2]
+            process(node.children[2])
           ])
 
         else

data/lib/ruby2js/filter/functions.rb

@@ -227,14 +227,19 @@ module Ruby2JS
           if before.type == :regexp
             before = before.updated(:regexp, [*before.children[0...-1],
               s(:regopt, :g, *before.children.last)])
-          elsif before.type == :str
+          elsif before.type == :str and not es2021
             before = before.updated(:regexp,
               [s(:str, Regexp.escape(before.children.first)), s(:regopt, :g)])
           end
           if after.type == :str
             after = s(:str, after.children.first.gsub(/\\(\d)/, "$\\1"))
           end
-          process node.updated nil, [target, :replace, before, after]
+
+          if es2021
+            process node.updated nil, [target, :replaceAll, before, after]
+          else
+            process node.updated nil, [target, :replace, before, after]
+          end
 
         elsif method == :ord and args.length == 0
           if target.type == :str
@@ -767,10 +772,10 @@ module Ruby2JS
             body.any? {|statement| statement.type == :def and
             statement.children.first == :initialize}
           then
-            body.unshift S(:def, :initialize, s(:args, s(:arg, :message)),
-              s(:begin, S(:send, s(:self), :message=, s(:lvar, :message)),
-              S(:send, s(:self), :name=, s(:sym, name.children[1])),
-              S(:send, s(:self), :stack=, s(:send, s(:send, nil, :Error,
+            body.unshift s(:def, :initialize, s(:args, s(:arg, :message)),
+              s(:begin, s(:send, s(:self), :message=, s(:lvar, :message)),
+              s(:send, s(:self), :name=, s(:sym, name.children[1])),
+              s(:send, s(:self), :stack=, s(:attr, s(:send, nil, :Error,
               s(:lvar, :message)), :stack))))
           end
 

data/lib/ruby2js/filter/lit-element.rb

@@ -22,10 +22,19 @@ module Ruby2JS
 
       def on_ivasgn(node)
         return super unless @le_props&.include?(node.children.first)
+        return super unless node.children.length > 1
         s(:send, s(:self), node.children.first.to_s[1..-1]+'=',
           process(node.children[1]))
       end
 
+      def on_op_asgn(node)
+        return super unless node.children.first.type == :ivasgn
+        var = node.children.first.children.first
+        return super unless @le_props&.include?(var)
+        super node.updated(nil, [s(:attr, s(:attr, nil, :this),
+          var.to_s[1..-1]), *node.children[1..-1]])
+      end
+
       def on_class(node)
         cname, inheritance, *body = node.children
         return super unless inheritance == s(:const, nil, :LitElement)
@@ -66,9 +75,9 @@ module Ruby2JS
 
         # render of a string is converted to a taglit :html
         render = nodes.find_index {|child| 
-          child.type == :def and child.children.first == :render
+          child&.type == :def and child.children.first == :render
         }
-        if render and %i[str dstr].include?(nodes[render].children[2].type)
+        if render and %i[str dstr].include?(nodes[render].children[2]&.type)
           nodes[render] = nodes[render].updated(:deff,
             [*nodes[render].children[0..1],
             s(:autoreturn, html_wrap(nodes[render].children[2]))])
@@ -76,9 +85,9 @@ module Ruby2JS
 
         # self.styles returning string is converted to a taglit :css
         styles = nodes.find_index {|child| 
-          child.type == :defs and child.children[0..1] == [s(:self), :styles]
+          child&.type == :defs and child.children[0..1] == [s(:self), :styles]
         }
-        if styles and %i[str dstr].include?(nodes[styles].children[3].type)
+        if styles and %i[str dstr].include?(nodes[styles].children[3]&.type)
           string = nodes[styles].children[3]
           string = s(:dstr, string) if string.type == :str
           children = string.children.dup
@@ -100,13 +109,13 @@ module Ruby2JS
 
         # insert super calls into initializer
         initialize = nodes.find_index {|child| 
-          child.type == :def and child.children.first == :initialize
+          child&.type == :def and child.children.first == :initialize
         }
         if initialize and nodes[initialize].children.length == 3
-          statements = nodes[initialize].children[2].children
+          statements = nodes[initialize].children[2..-1]
 
-          if statements.length == 1 and statements.children.first.type == :begin
-            statements = statements.children 
+          if statements.length == 1 and statements.first.type == :begin
+            statements = statements.first.children 
           end
 
           unless statements.any? {|statement| %i[super zuper].include?  statement.type}
@@ -174,13 +183,18 @@ module Ruby2JS
       # analyze ivar usage
       def le_walk(node)
         node.children.each do |child|
-          next unless Parser::AST::Node === child
-          le_walk(child)
+          next unless child.is_a? Parser::AST::Node
 
           if child.type == :ivar
             @le_props[child.children.first] ||= nil
-          elsif child.type == :ivasgn
-            @le_props[child.children.first] = case child.children.last.type
+          elsif child.type == :ivasgn || child.type == :op_asgn
+            prop = child.children.first
+            unless prop.is_a? Symbol
+              prop = prop.children.first if prop.type == :ivasgn
+              next unless prop.is_a? Symbol
+            end
+
+            @le_props[prop] = case child.children.last.type
               when :str, :dstr
                 :String
               when :array
@@ -190,8 +204,10 @@ module Ruby2JS
               when :true, :false
                 :Boolean
               else
-                @le_props[child.children.first] || :Object
+                @le_props[prop] || :Object
             end
+          else
+            le_walk(child)
           end
         end
       end

data/lib/ruby2js/filter/react.rb

@@ -27,7 +27,12 @@ module Ruby2JS
 
       REACT_IMPORTS = {
         React: s(:import, ['react'], s(:attr, nil, :React)),
-        ReactDOM: s(:import, ['react-dom'], s(:attr, nil, :ReactDOM))
+        ReactDOM: s(:import, ['react-dom'], s(:attr, nil, :ReactDOM)),
+        Preact: s(:import,
+          [s(:pair, s(:sym, :as), s(:const, nil, :Preact)),
+            s(:pair, s(:sym, :from), s(:str, "preact"))],
+            s(:str, '*')),
+        PreactHook: s(:import, ["preact/hooks"], [s(:attr, nil, :useState)])
       }
 
       # the following command can be used to generate ReactAttrs:
@@ -71,17 +76,23 @@ module Ruby2JS
 
       ReactLifecycle = %w(render componentDidMount shouldComponentUpdate
       getShapshotBeforeUpdate componentDidUpdate componentWillUnmount
-      componentDidCatch)
+      componentDidCatch componentWillReceiveProps)
 
       ReactAttrMap = Hash[ReactAttrs.map {|name| [name.downcase, name]}]
       ReactAttrMap['for'] = 'htmlFor'
-      ReactFragment = :'_React.Fragment'
+
+      PreactAttrMap = {
+        htmlFor: 'for',
+        onDoubleClick: 'onDblClick',
+        tabIndex: 'tabindex'
+      }
 
       def initialize(*args)
         @react = nil
         @reactApply = nil
         @reactBlock = nil
         @reactClass = nil
+        @reactMethod = nil
         @react_props = []
         @react_methods = []
         @react_filter_functions = false
@@ -118,12 +129,23 @@ module Ruby2JS
       def on_class(node)
         cname, inheritance, *body = node.children
         return super unless cname.children.first == nil
-        return super unless inheritance == s(:const, nil, :React) or
-          inheritance == s(:const, nil, :Vue) or
+
+        if inheritance == s(:const, nil, :React) or
           inheritance == s(:const, s(:const, nil, :React), :Component) or
           inheritance == s(:send, s(:const, nil, :React), :Component)
 
-        prepend_list << REACT_IMPORTS[:React] if modules_enabled?
+          react = :React
+          prepend_list << REACT_IMPORTS[:React] if modules_enabled?
+
+        elsif inheritance == s(:const, nil, :Preact) or
+          inheritance == s(:const, s(:const, nil, :Preact), :Component) or
+          inheritance == s(:send, s(:const, nil, :Preact), :Component)
+
+          react = :Preact
+          prepend_list << REACT_IMPORTS[:Preact] if modules_enabled?
+        else
+          return super
+        end
 
         # traverse down to actual list of class statements
         if body.length == 1
@@ -141,12 +163,14 @@ module Ruby2JS
         end
 
         begin
-          react, @react = @react, true
+          react, @react = @react, react
           reactClass, @reactClass = @reactClass, true
 
           pairs = []
 
-          unless es2015
+          createClass = (@react == :React and not es2015)
+
+          if createClass
             # automatically capture the displayName for the class
             pairs << s(:pair, s(:sym, :displayName),
               s(:str, cname.children.last.to_s))
@@ -156,12 +180,11 @@ module Ruby2JS
           statics = []
           body.select {|child| child.type == :defs}.each do |child|
             _parent, mname, args, *block = child.children
-            if es2015
-              block = [s(:autoreturn, *block)] unless child.is_method?
-              pairs << s(:defs, s(:self), mname, args, *block)
+            if not createClass
+              pairs << child
             elsif child.is_method?
-              statics << s(:pair, s(:sym, mname), process(child.updated(:block,
-                [s(:send, nil, :proc), args, s(:autoreturn, *block)])))
+              statics << s(:pair, s(:sym, mname), child.updated(:block,
+                [s(:send, nil, :proc), args, s(:autoreturn, *block)]))
             elsif \
               block.length == 1 and
               Converter::EXPRESSIONS.include? block.first.type
@@ -212,13 +235,53 @@ module Ruby2JS
               scan_events[node.children]
             end
           end
-          scan_events[body] unless es2015
+          scan_events[body] if createClass
 
           # append statics (if any)
           unless statics.empty?
             pairs << s(:pair, s(:sym, :statics), s(:hash, *statics))
           end
 
+          # determine if this class can be emitted as a hook
+          hook = (es2015 and inheritance.children.first == nil)
+          hookinit = nil
+          useState = []
+          body.each_with_index do |statement, index|
+            if statement.type == :def
+              method = statement.children.first
+              if method == :initialize
+                children = statement.children[2..-1]
+                children.pop unless children.last
+                while children.length == 1 and children.first.type == :begin
+                  children = children.first.children 
+                end
+                hookinit = index if children.any? {|child| child.type != :ivasgn}
+              elsif method == :render
+                nil
+              elsif ReactLifecycle.include? method.to_s
+                hook = false
+              elsif not statement.is_method?
+                hook = false
+              elsif method.to_s.end_with? '='
+                hook = false
+              end
+            elsif statement.type == :defs
+              hook = false
+            end
+          end
+
+          if hook
+            @reactClass = :hook
+            @react_props = []
+            @react_methods = []
+
+            if hookinit
+              body = body.dup
+              hookinit = body.delete_at(hookinit)
+              pairs.unshift process hookinit.children[2]
+            end
+          end
+
           # create a default getInitialState method if there is no such method
           # and there are either references to instance variables or there are
           # methods that need to be bound.
@@ -230,7 +293,13 @@ module Ruby2JS
           then
             @reactIvars = {pre: [], post: [], asgn: [], ref: [], cond: []}
             react_walk(node)
-            if not es2015 and not @reactIvars.values.flatten.empty?
+
+            if hook
+              react_walk(hookinit) if hookinit
+              useState = (@reactIvars[:asgn] + @reactIvars[:ref]).uniq
+            end
+
+            if createClass and not @reactIvars.values.flatten.empty?
               body = [s(:def, :getInitialState, s(:args),
                 s(:return, s(:hash))), *body]
             elsif not needs_binding.empty? or not @reactIvars.values.flatten.empty?
@@ -242,16 +311,21 @@ module Ruby2JS
           body.select {|child| child.type == :def}.each do |child|
             mname, args, *block = child.children
             @reactMethod = mname
-            @reactProps = child.updated(:attr, [s(:self), :props])
+
+            if @reactClass == :hook
+              @reactProps = s(:lvar, :"prop$")
+            else
+              @reactProps = child.updated(:attr, [s(:self), :props])
+            end
 
             # analyze ivar usage
             @reactIvars = {pre: [], post: [], asgn: [], ref: [], cond: []}
             react_walk(child) unless mname == :initialize
-            @reactIvars[:capture] =
-              (@reactIvars[:pre] + @reactIvars[:post]).uniq
+            @reactIvars[:capture] = (@reactIvars[:pre] + @reactIvars[:post]).uniq
+            @reactIvars[:pre] = @reactIvars[:post] = [] if @reactClass == :hook
 
             if mname == :initialize
-              mname = es2015 ? :initialize : :getInitialState
+              mname = createClass ? :getInitialState : :initialize 
 
               # extract real list of statements
               if block.length == 1
@@ -333,7 +407,7 @@ module Ruby2JS
                 else
                   # wrap multi-line blocks with a React Fragment
                   block = [s(:return,
-                    s(:block, s(:send, nil, ReactFragment), s(:args), *block))]
+                    s(:block, s(:send, nil, :"_#{@react}.Fragment"), s(:args), *block))]
                 end
               end
 
@@ -359,14 +433,14 @@ module Ruby2JS
               type = :begin if block.first.type == :return
             end
 
-            if es2015
+            if createClass
+              pairs << s(:pair, s(:sym, mname), child.updated(:block,
+                [s(:send, nil, :proc), args, process(s(type, *block))]))
+            else
               pairs << child.updated(
                 ReactLifecycle.include?(mname.to_s) ? :defm : :def, 
                 [mname, args, process(s(type, *block))]
               )
-            else
-              pairs << s(:pair, s(:sym, mname), child.updated(:block,
-                [s(:send, nil, :proc), args, process(s(type, *block))]))
             end
 
             # retain comment
@@ -374,38 +448,70 @@ module Ruby2JS
               @comments[pairs.last] = @comments[child]
             end
           end
+
+          if createClass
+            # emit a createClass statement
+            node.updated(:casgn, [nil, cname.children.last,
+              s(:send, s(:const, nil, :React), :createClass, s(:hash, *pairs))])
+          elsif hook
+            initialize = pairs.find_index {|node| node.type == :def and node.children.first == :initialize}
+
+            hash = {}
+            if initialize
+              hash = pairs.delete_at(initialize)
+              hash = hash.children.last while %i(def begin send).include? hash&.type
+              hash = s(:hash) unless hash&.type == :hash
+              hash = hash.children.map {|pair|
+                [pair.children.first.children.first, pair.children.last]
+              }.to_h
+            end 
+
+            useState.each do |symbol|
+              hash[symbol.to_s[1..-1]] ||= s(:nil)
+            end
+
+            hash.sort.reverse.each do |var, value|
+              if @react == :Preact 
+                hooker = nil
+                prepend_list << REACT_IMPORTS[:PreactHook] if modules_enabled?
+              else
+                hooker = s(:const, nil, :React)
+              end
+
+              setter = 'set' + var[0].upcase + var[1..-1]
+              pairs.unshift(s(:masgn, s(:mlhs, s(:lvasgn, var), 
+                s(:lvasgn, setter)), s(:send, hooker, :useState, value)))
+            end
+
+            render = pairs.find_index {|node| node.type == :defm and node.children.first == :render}
+            if render
+              render = pairs.delete_at(render)
+              pairs.push s(:autoreturn, render.children.last)
+            end
+
+            has_cvar = lambda {|list|
+              list.any? {|node|
+                next unless Parser::AST::Node === node
+                return true if node.type == :cvar
+                has_cvar.call(node.children)
+              }
+            }
+            args = has_cvar[node.children] ? s(:args, s(:arg, 'prop$')) : s(:args)
+
+            node.updated(:def, [cname.children.last, args, s(:begin, *pairs)])
+          else
+            # emit a class that extends React.Component
+            node.updated(:class, [s(:const, nil, cname.children.last),
+              s(:attr, s(:const, nil, @react), :Component), *pairs])
+          end
         ensure
           @react = react
           @reactClass = reactClass
           @reactMethod = nil
         end
-
-        if es2015
-          # emit a class that extends React.Component
-          node.updated(:class, [s(:const, nil, cname.children.last),
-            s(:attr, s(:const, nil, :React), :Component), *pairs]) 
-        else
-          # emit a createClass statement
-          node.updated(:casgn, [nil, cname.children.last,
-            s(:send, s(:const, nil, :React), :createClass, s(:hash, *pairs))])
-        end
       end
 
       def on_send(node)
-        # convert Vue.utile.defineReactive to class fields or assignments
-        if node.children.first == s(:send, s(:const, nil, :Vue), :util)
-          if node.children[1] == :defineReactive
-            if node.children[2].type == :cvar
-              return process s(:cvasgn, node.children[2].children.first,
-                node.children[3])
-            elsif node.children[2].type == :send
-              assign = node.children[2]
-              return assign.updated(nil, [assign.children[0],
-                assign.children[1].to_s + '=', node.children[3]])
-            end
-          end
-        end
-
         # calls to methods (including getters) defined in this class
         if node.children[0]==nil and Symbol === node.children[1]
           if node.is_method?
@@ -423,16 +529,12 @@ module Ruby2JS
           end
         end
 
-        if node.children.first == s(:const, nil, :Vue)
-          node = node.updated(nil, [s(:const, nil, :React),
-            *node.children[1..-1]])
-        end
-
         if not @react
           # enable React filtering within React class method calls or
           # React component calls
           if \
             node.children.first == s(:const, nil, :React) or
+            node.children.first == s(:const, nil, :Preact) or
             node.children.first == s(:const, nil, :ReactDOM)
           then
             if modules_enabled?
@@ -440,7 +542,8 @@ module Ruby2JS
             end
 
             begin
-              react, @react = @react, true
+              react = @react
+              @react = (node.children.first.children.last == :Preact ? :Preact : :React)
               return on_send(node)
             ensure
               @react = react
@@ -461,13 +564,26 @@ module Ruby2JS
           end
 
         elsif \
-          @reactApply and node.children[1] == :createElement and
-          node.children[0] == s(:const, nil, :React)
+          (@reactApply and node.children[1] == :createElement and
+          node.children[0] == s(:const, nil, :React)) or
+          (@reactApply and node.children[1] == :h and
+          node.children[0] == s(:const, nil, :Preact))
         then
           # push results of explicit calls to React.createElement
           s(:send, s(:gvar, :$_), :push, s(:send, *node.children[0..1],
             *process_all(node.children[2..-1])))
 
+        elsif \
+          @react == :Preact and node.children[1] == :h and node.children[0] == nil
+        then
+          if @reactApply
+            # push results of explicit calls to Preact.h
+            s(:send, s(:gvar, :$_), :push, s(:send, s(:const, nil, :Preact), :h,
+              *process_all(node.children[2..-1])))
+          else
+            node.updated(nil, [s(:const, nil, :Preact), :h, *process_all(node.children[2..-1])])
+          end
+
         elsif !@jsx and node.children[0] == nil and node.children[1] =~ /^_\w/
           # map method calls starting with an underscore to React calls
           # to create an element.
@@ -549,7 +665,12 @@ module Ruby2JS
             else
               value = s(:str, values.join(' '))
             end
-            pairs.unshift s(:pair, s(:sym, :className), value)
+
+            if @react == :Preact
+              pairs.unshift s(:pair, s(:sym, :class), value)
+            else
+              pairs.unshift s(:pair, s(:sym, :className), value)
+            end
           end
 
           # support controlled form components
@@ -559,13 +680,28 @@ module Ruby2JS
               ['value', :value].include? pair.children.first.children.first
             end
 
-            # search for the presence of a 'onChange' attribute
+            event = (@react == :Preact ? :onInput : :onChange)
+
+
+            # search for the presence of a onInput/onChange attribute
             onChange = pairs.find_index do |pair|
-              ['onChange', :onChange].include? pair.children.first.children[0]
+              pair.children.first.children[0].to_s == event.to_s
+            end
+
+            if event == :onInput and not onChange
+              # search for the presence of a 'onChange' attribute
+              onChange = pairs.find_index do |pair|
+                pair.children.first.children[0].to_s == 'onChange'
+              end
+
+              if onChange
+                pairs[onChange] = s(:pair, s(:sym, event),
+                  pairs[onChange].children.last)
+              end
             end
 
             if value and pairs[value].children.last.type == :ivar and !onChange
-              pairs << s(:pair, s(:sym, :onChange),
+              pairs << s(:pair, s(:sym, event),
                 s(:block, s(:send, nil, :proc), s(:args, s(:arg, :event)),
                 s(:ivasgn, pairs[value].children.last.children.first,
                 s(:attr, s(:attr, s(:lvar, :event), :target), :value))))
@@ -578,7 +714,7 @@ module Ruby2JS
               end
 
               if checked and pairs[checked].children.last.type == :ivar
-                pairs << s(:pair, s(:sym, :onChange),
+                pairs << s(:pair, s(:sym, event),
                   s(:block, s(:send, nil, :proc), s(:args),
                   s(:ivasgn, pairs[checked].children.last.children.first,
                   s(:send, pairs[checked].children.last, :!))))
@@ -586,13 +722,25 @@ module Ruby2JS
             end
           end
 
-          # replace attribute names with case-sensitive javascript properties
-          pairs.each_with_index do |pair, index|
-            next if pair.type == :kwsplat
-            name = pair.children.first.children.first.downcase
-            if ReactAttrMap[name] and name.to_s != ReactAttrMap[name]
-              pairs[index] = pairs[index].updated(nil, 
-                [s(:str, ReactAttrMap[name]), pairs[index].children.last])
+          if @react == :Preact
+            # replace selected Reactisms with native HTML
+            pairs.each_with_index do |pair, index|
+              next if pair.type == :kwsplat
+              name = pair.children.first.children.first.to_sym
+              if PreactAttrMap[name]
+                pairs[index] = pairs[index].updated(nil, 
+                  [s(:str, PreactAttrMap[name]), pairs[index].children.last])
+              end
+            end
+          else
+            # replace attribute names with case-sensitive javascript properties
+            pairs.each_with_index do |pair, index|
+              next if pair.type == :kwsplat
+              name = pair.children.first.children.first.downcase
+              if ReactAttrMap[name] and name.to_s != ReactAttrMap[name]
+                pairs[index] = pairs[index].updated(nil, 
+                  [s(:str, ReactAttrMap[name]), pairs[index].children.last])
+              end
             end
           end
 
@@ -654,8 +802,14 @@ module Ruby2JS
               # explicit call to React.createElement
               next true if arg.children[1] == :createElement and
                 arg.children[0] == s(:const, nil, :React)
-              next true if arg.children[1] == :createElement and
-                arg.children[0] == s(:const, nil, :Vue)
+
+              # explicit call to Preact.h
+              next true if arg.children[1] == :h and
+                arg.children[0] == s(:const, nil, :Preact)
+
+              # explicit call to h
+              next true if arg.children[1] == :h and
+                arg.children[0] == nil
 
               # JSX
               next true if arg.type == :xstr
@@ -717,8 +871,13 @@ module Ruby2JS
           params.pop if params.last == s(:nil)
 
           # construct element using params
-          element = node.updated(:send, [s(:const, nil, :React),
-            :createElement, *params])
+          if @react == :Preact
+            element = node.updated(:send, [s(:const, nil, :Preact),
+              :h, *params])
+          else
+            element = node.updated(:send, [s(:const, nil, :React),
+              :createElement, *params])
+          end
 
           if @reactApply
             # if apply is set, emit code that pushes result
@@ -846,8 +1005,13 @@ module Ruby2JS
             while node != child
               if node.children[1] !~ /!$/
                 # convert method name to hash {className: name} pair
-                pair = s(:pair, s(:sym, :className),
-                  s(:str, node.children[1].to_s.gsub('_','-')))
+                if @react == :Preact
+                  pair = s(:pair, s(:sym, :class),
+                    s(:str, node.children[1].to_s.gsub('_','-')))
+                else
+                  pair = s(:pair, s(:sym, :className),
+                    s(:str, node.children[1].to_s.gsub('_','-')))
+                end
               else
                 # convert method name to hash {id: name} pair
                 pair = s(:pair, s(:sym, :id),
@@ -917,8 +1081,11 @@ module Ruby2JS
         # Base Ruby2JS processing will convert the 'splat' to 'apply'
         child = node.children.first
         if \
-          child.children[1] == :createElement and
-          child.children[0] == s(:const, nil, :React)
+          (child.children[1] == :createElement and
+          child.children[0] == s(:const, nil, :React)) or
+          (child.children[1] == :h and
+          (child.children[0] == s(:const, nil, :Preact) or
+          child.children[0] == nil))
         then
           begin
             reactApply, @reactApply = @reactApply, true
@@ -931,11 +1098,13 @@ module Ruby2JS
             @reactApply = reactApply
           end
 
+          target = child.children[0] || s(:const, nil, :Preact)
+
           if reactApply
             return child.updated(:send, [s(:gvar, :$_), :push, 
-              s(:send, *child.children[0..1], *params)])
+              s(:send, target, child.children[1], *params)])
           else
-            return child.updated(:send, [*child.children[0..1], *params])
+            return child.updated(:send, [target, child.children[1], *params])
           end
         end
 
@@ -952,7 +1121,7 @@ module Ruby2JS
           block = s(:block, s(:send, nil, :proc), s(:args),
             *node.children[2..-1])
           return on_send node.children.first.updated(:send,
-            [nil, ReactFragment, block])
+            [nil, :"_#{@react}.Fragment", block])
 
         elsif !@jsx and child.children[0] == nil and child.children[1] =~ /^_\w/
           if node.children[1].children.empty?
@@ -998,13 +1167,17 @@ module Ruby2JS
       # convert global variables to refs
       def on_gvar(node)
         return super unless @reactClass
+        return super if @reactClass == :hook
         s(:attr, s(:attr, s(:self), :refs), node.children.first.to_s[1..-1])
       end
 
       # convert instance variables to state
       def on_ivar(node)
         return super unless @reactClass
-        if @reactMethod and @reactIvars[:capture].include? node.children.first
+
+        if @reactClass == :hook
+          node.updated(:lvar, [node.children.first.to_s[1..-1]])
+        elsif @reactMethod and @reactIvars[:capture].include? node.children.first
           node.updated(:lvar, ["$#{node.children.first[1..-1]}"])
         else
           node.updated(:attr, [s(:attr, s(:self), :state),
@@ -1016,11 +1189,17 @@ module Ruby2JS
       def on_ivasgn(node)
         return super unless @react
 
+        if @reactClass == :hook
+          var = node.children.first.to_s[1..-1]
+          return node.updated(:send, [nil, 'set' + var[0].upcase + var[1..-1],
+            process(node.children.last)])
+        end
+
         if @reactMethod and @reactIvars[:capture].include? node.children.first
           ivar = node.children.first.to_s
           if @reactBlock
             return s(:send, s(:self), :setState, s(:hash, s(:pair,
-              s(:lvar, ivar[1..-1]), process(s(:lvasgn, "$#{ivar[1..-1]}",
+              s(:str, ivar[1..-1]), process(s(:lvasgn, "$#{ivar[1..-1]}",
               *node.children[1..-1])))))
           else
             return s(:lvasgn, "$#{ivar[1..-1]}",
@@ -1072,10 +1251,14 @@ module Ruby2JS
         return super unless @react
         return super unless node.children.first.type == :ivasgn
         var = node.children.first.children.first
-        if @reactMethod and @reactIvars[:capture].include? var
+        if @reactClass == :hook
+          var = node.children.first.children.first.to_s[1..-1]
+          node.updated(:send, [nil, 'set' + var[0].upcase + var[1..-1],
+            s(:send, s(:lvar, var), *node.children[1..-1])])
+        elsif @reactMethod and @reactIvars[:capture].include? var
           if @reactBlock
             s(:send, s(:self), :setState, s(:hash, s(:pair,
-              s(:lvar, var[1..-1]), process(s(node.type,
+              s(:str, var[1..-1]), process(s(node.type,
               s(:lvasgn, "$#{var[1..-1]}"), *node.children[1..-1])))))
           else
             process s(node.type, s(:lvasgn, "$#{var[1..-1]}"),
@@ -1118,9 +1301,13 @@ module Ruby2JS
           return true if node.children[1] == :createElement and
             node.children[0] == s(:const, nil, :React)
 
-          # explicit call to Vue.createElement
-          return true if node.children[1] == :createElement and
-            node.children[0] == s(:const, nil, :Vue)
+          # explicit call to Preact.h
+          return true if node.children[1] == :h and
+            node.children[0] == s(:const, nil, :Preact)
+
+          # explicit call to h
+          return true if node.children[1] == :h and
+            node.children[0] == nil
         end
 
         # wunderbar style call
@@ -1256,6 +1443,7 @@ module Ruby2JS
           @reactIvars = {pre: [], post: [], asgn: [], ref: [], cond: []}
           react_walk(node.children.last)
           @reactIvars[:capture] = (@reactIvars[:pre] + @reactIvars[:post]).uniq
+          @reactIvars[:pre] = @reactIvars[:post] = [] if @reactClass == :hook
           node = super
           block = react_process_ivars([node.children.last.dup])
           node.updated(nil, [*node.children[0..-2], s(:begin, *block)])
@@ -1280,7 +1468,7 @@ module Ruby2JS
         # update ivars that are set and later referenced
         unless @reactIvars[:post].empty?
           updates = @reactIvars[:post].uniq.sort.reverse.map do |ivar|
-            s(:pair, s(:lvar, ivar.to_s[1..-1]),
+            s(:pair, s(:str, ivar.to_s[1..-1]),
               s(:lvar, "$#{ivar.to_s[1..-1]}"))
           end
           update = s(:send, s(:self), :setState, s(:hash, *updates))