quince 0.3.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2189200f4bee6758d6a981e3f4ba7b0d8dc558d0e0e2bb66fd421c11b404f954
-  data.tar.gz: 4153ceb85c057cfe7c2e74852aee81b82dde74362aecec53647b485fea191b87
+  metadata.gz: 8a30e10c958d56fc7a73d2515d200cae1080d407e2a19e132827b2b77837b6bb
+  data.tar.gz: 2f43465799409bb6a7336879189d35bfcfcd259b8637a1eec546826317034436
 SHA512:
-  metadata.gz: 923689df34d18c7357785812424acc62f38f89a3966c568bfd6e86f03c41eb1a9dd629eebdee4b1ae9321e42e1180d0be65af560613e31543496ebc312c40a30
-  data.tar.gz: 2624224d31f066ef9562333264e6f1cc00275bf72ab35942a1b0b3097864a14c89f04a6d4ebeee7ffb07ce240f22bde8f07939b61ee64a8019017ceceead23c9
+  metadata.gz: 86e5e960621d4e6ecde1ce2cf07486596b00e64aeb8ddecf0c82d7c2ac9c3818ee2f367256e1a1539af86a1eee534af572cd45c94d2ed8676d5bd4d9867543f9
+  data.tar.gz: 0360b4ed00cba7ec1604c1bd42d79a8fce65b065b409a0dcb4539816980de92a33bf1c181d8f09f7542699edac24508684d01e2ad05cd08630b5c14c5e06f433

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    quince (0.3.0)
+    quince (0.5.0)
       oj (~> 3.13)
       typed_struct (>= 0.1.4)
 
@@ -9,7 +9,7 @@ GEM
   remote: https://rubygems.org/
   specs:
     diff-lcs (1.4.4)
-    oj (3.13.6)
+    oj (3.13.9)
     rake (13.0.6)
     rbs (1.6.2)
     rspec (3.10.0)

data/README.md

@@ -92,8 +92,8 @@ class Counter < Quince::Component
     def render
         div(
             h2("count is #{state.val}"),
-            button(onclick: method(:increment)) { "++" },
-            button(onclick: method(:decrement)) { "--" }
+            button(onclick: callback(:increment)) { "++" },
+            button(onclick: callback(:decrement)) { "--" }
         )
     end
 end

data/lib/quince/attributes_by_element.rb

@@ -4,14 +4,14 @@ require_relative "types"
 
 module Quince
   module HtmlTagComponents
-    referrer_policy = Rbs("'' | 'no-referrer' | 'no-referrer-when-downgrade' | 'origin' | 'origin-when-cross-origin' | 'same-origin' | 'strict-origin' | 'strict-origin-when-cross-origin' | 'unsafe-url' | Quince::Types::Undefined")
+    referrer_policy = Rbs("'' | 'no-referrer' | 'no-referrer-when-downgrade' | 'origin' | 'origin-when-cross-origin' | 'same-origin' | 'strict-origin' | 'strict-origin-when-cross-origin' | 'unsafe-url' | nil")
     form_method = Rbs(
-      '"get" | "post" | "GET" | "POST" | :GET | :POST | :get | :post | Quince::Types::Undefined'
+      '"get" | "post" | "GET" | "POST" | :GET | :POST | :get | :post | nil'
     )
     t = Quince::Types
     opt_string_sym = Rbs("#{t::OptionalString} | Symbol")
     opt_bool = t::OptionalBoolean
-    opt_callback = Rbs("Quince::Callback::Interface | Quince::Types::Undefined")
+    opt_callback = Rbs("Quince::Callback::Interface | nil")
     value = opt_string_sym # for now
 
     ATTRIBUTES_BY_ELEMENT = {
@@ -58,7 +58,7 @@ module Quince
         formnovalidate: opt_bool,
         formtarget: opt_string_sym,
         name: opt_string_sym,
-        type: Rbs("'submit' | 'reset' | 'button' | Quince::Types::Undefined"),
+        type: Rbs("'submit' | 'reset' | 'button' | nil"),
         value: value,
       }.freeze,
       "Canvas" => {
@@ -128,7 +128,7 @@ module Quince
         allowfullscreen: opt_bool,
         allowtransparency: opt_bool,
         height: opt_string_sym,
-        loading: Rbs('"eager" | "lazy" | Quince::Types::Undefined'),
+        loading: Rbs('"eager" | "lazy" | nil'),
         name: opt_string_sym,
         referrerpolicy: referrer_policy,
         sandbox: opt_string_sym,
@@ -192,7 +192,7 @@ module Quince
       "Ol" => {
         reversed: opt_bool,
         start: opt_string_sym,
-        type: Rbs("'1' | 'a' | 'A' | 'i' | 'I' | Quince::Types::Undefined"),
+        type: Rbs("'1' | 'a' | 'A' | 'i' | 'I' | nil"),
       }.freeze,
       "Optgroup" => {
         disabled: opt_bool,
@@ -270,7 +270,7 @@ module Quince
       }.freeze,
       "Tbody" => {}.freeze,
       "Td" => {
-        align: Rbs('"left" | "center" | "right" | "justify" | "char" | Quince::Types::Undefined'),
+        align: Rbs('"left" | "center" | "right" | "justify" | "char" | nil'),
         colspan: opt_string_sym,
         headers: opt_string_sym,
         rowspan: opt_string_sym,
@@ -278,7 +278,7 @@ module Quince
         abbr: opt_string_sym,
         height: opt_string_sym,
         width: opt_string_sym,
-        valign: Rbs('"top" | "middle" | "bottom" | "baseline" | Quince::Types::Undefined'),
+        valign: Rbs('"top" | "middle" | "bottom" | "baseline" | nil'),
       }.freeze,
       "Textarea" => {
         autocomplete: opt_string_sym,
@@ -300,7 +300,7 @@ module Quince
       }.freeze,
       "Tfoot" => {}.freeze,
       "Th" => {
-        align: Rbs('"left" | "center" | "right" | "justify" | "char" | Quince::Types::Undefined'),
+        align: Rbs('"left" | "center" | "right" | "justify" | "char" | nil'),
         colspan: opt_string_sym,
         headers: opt_string_sym,
         rowspan: opt_string_sym,
@@ -364,10 +364,10 @@ module Quince
       "Hr" => {}.freeze,
       "Img" => {
         alt: opt_string_sym,
-        crossorigin: Rbs('"anonymous" | "use-credentials" | "" | Quince::Types::Undefined'),
-        decoding: Rbs('"async" | "auto" | "sync" | Quince::Types::Undefined'),
+        crossorigin: Rbs('"anonymous" | "use-credentials" | "" | nil'),
+        decoding: Rbs('"async" | "auto" | "sync" | nil'),
         height: Rbs("#{opt_string_sym} | Integer"),
-        loading: Rbs('"eager" | "lazy" | Quince::Types::Undefined'),
+        loading: Rbs('"eager" | "lazy" | nil'),
         referrerpolicy: referrer_policy,
         sizes: opt_string_sym,
         src: opt_string_sym,
@@ -475,8 +475,7 @@ module Quince
       onsearch: opt_callback,
       onkeyup: opt_callback,
       onselect: opt_callback,
+      onscroll: opt_callback,
     }.freeze
   end
 end
-
-Undefined = Quince::Types::Undefined

data/lib/quince/callback.js.erb

@@ -0,0 +1,32 @@
+const p = this.dataset[`quOn<%= key.to_s[2..-1] %>State`];
+<% if value.debugger %>debugger;<% end %>
+<% if value.if %>
+if (<%= value.if %>) {
+<% end %>
+<% if value.debounce_ms %>
+if (!window[`<%= fn_name %>`]) window[`<%= fn_name %>`] = Q.d((p) => {
+<% end %>
+Q.c(
+`<%= endpoint %>`,
+JSON.stringify(
+{component: p, event: `<%= key.to_s[2..-1]  %>`,stateContainer: `<%= state_container %>`,
+<% if value.take_form_values %>
+params: Q.f(this),
+<% end %>
+<% if rerender %>
+rerender: <%= rerender.to_json %>,
+<% end %>}),
+`<%= rerender&.dig(:selector)&.to_s || selector %>`,
+`<%= (mode = rerender&.dig(:mode)) ? mode.to_s : "replace" %>`,
+<%= value.handle_errors.to_json %>,
+);
+<% unless push_params_state == "null" %>Q.ps(<%= push_params_state %>);<% end %>
+<% if value.debounce_ms&.positive? %>
+}, <%= value.debounce_ms %>); window[`<%= fn_name %>`](p)
+<% end %>
+<% if value.if %>
+};
+<% end %>
+<% if value.prevent_default %>
+;return false;
+<% end %>

data/lib/quince/callback.rb

@@ -6,8 +6,12 @@ module Quince
       DEFAULT_CALLBACK_OPTIONS = {
         prevent_default: false,
         take_form_values: false,
-      # others could include:
-      # debounce: false,
+        debounce_ms: nil,
+        if: nil,
+        debugger: false,
+        rerender: nil,
+        push_params_state: nil,
+        handle_errors: true,
       }.freeze
 
       def callback(method_name, **opts)
@@ -22,15 +26,24 @@ module Quince
     end
 
     module Interface
-      attr_reader :receiver, :method_name, :prevent_default, :take_form_values
+      attr_reader(
+        :receiver,
+        :method_name,
+        *ComponentHelpers::DEFAULT_CALLBACK_OPTIONS.keys,
+      )
     end
 
     include Interface
 
-    def initialize(receiver, method_name, prevent_default:, take_form_values:)
+    def initialize(
+      receiver,
+      method_name,
+      **opts
+    )
       @receiver, @method_name = receiver, method_name
-      @prevent_default = prevent_default
-      @take_form_values = take_form_values
+      ComponentHelpers::DEFAULT_CALLBACK_OPTIONS.each_key do |opt|
+        instance_variable_set :"@#{opt}", opts.fetch(opt)
+      end
     end
   end
 end

data/lib/quince/component.rb

@@ -9,30 +9,35 @@ module Quince
 
       def Props(**kw)
         self.const_set "Props", TypedStruct.new(
-          { default: Quince::Types::Undefined },
-          Quince::Component::HTML_SELECTOR_ATTR => String,
+          Quince::Component::PARENT_SELECTOR_ATTR => String,
+          Quince::Component::SELF_SELECTOR => String,
           **kw,
         )
       end
 
       def State(**kw)
-        st = kw.empty? ? nil : TypedStruct.new(
-          { default: Quince::Types::Undefined },
-          **kw,
-        )
+        st = kw.empty? ? nil : TypedStruct.new(**kw)
         self.const_set "State", st
       end
 
-      def exposed(action, meth0d: :POST)
+      def exposed(action, method: :POST)
         @exposed_actions ||= Set.new
         @exposed_actions.add action
         route = "/api/#{self.name}/#{action}"
         Quince.middleware.create_route_handler(
-          verb: meth0d,
+          verb: method,
           route: route,
         ) do |params|
           instance = Quince::Serialiser.deserialise(CGI.unescapeHTML(params[:component]))
-          Quince::Component.class_variable_set :@@params, params
+          Quince::Component.class_variable_set :@@params, params[:params]
+          render_with = if params[:rerender]
+              instance.instance_variable_set :@state_container, params[:stateContainer]
+              params[:rerender][:method].to_sym
+            else
+              :render
+            end
+          instance.instance_variable_set :@render_with, render_with
+          instance.instance_variable_set :@callback_event, params[:event]
           if @exposed_actions.member? action
             instance.send action
             instance
@@ -58,7 +63,13 @@ module Quince
       private
 
       def initialize_props(const, id, **props)
-        const::Props.new(HTML_SELECTOR_ATTR => id, **props) if const.const_defined?("Props")
+        if const.const_defined?("Props")
+          const::Props.new(
+            PARENT_SELECTOR_ATTR => id,
+            **props,
+            SELF_SELECTOR => id
+          )
+        end
       end
     end
 
@@ -76,7 +87,7 @@ module Quince
     protected
 
     def to(route, via: :POST)
-      self.class.exposed route, meth0d: via
+      self.class.exposed route, method: via
     end
 
     def params
@@ -87,10 +98,16 @@ module Quince
 
     attr_reader :__id
 
-    HTML_SELECTOR_ATTR = :"data-quid"
+    PARENT_SELECTOR_ATTR = :"data-quid-parent"
+    SELF_SELECTOR = :"data-quid"
+
+    def html_parent_selector
+      id = props ? props[SELF_SELECTOR] : __id
+      "[#{PARENT_SELECTOR_ATTR}='#{id}']".freeze
+    end
 
-    def html_element_selector
-      "[#{HTML_SELECTOR_ATTR}='#{__id}']".freeze
+    def html_self_selector
+      "[#{SELF_SELECTOR}='#{__id}']".freeze
     end
   end
 end

data/lib/quince/html_tag_components.rb

@@ -1,9 +1,13 @@
 require "oj"
 require_relative "attributes_by_element"
 require_relative "serialiser"
+require "erb"
 
 module Quince
   module HtmlTagComponents
+    CALLBACK_TEMPLATE = File.read(File.join(__dir__, "callback.js.erb")).delete!("\n").freeze
+    CALLBACK_ERB_INSTANCE = ERB.new(CALLBACK_TEMPLATE)
+
     def self.define_html_tag_component(const_name, attrs, self_closing: false)
       klass = Class.new(Quince::Component) do
         Props(
@@ -17,9 +21,12 @@ module Quince
               props.each_pair.map { |k, v| to_html_attr(k, v) }.compact.join(" ")
             end
           result = "<#{tag_name}"
-          result << " #{attrs}>" unless attrs.empty?
-
-          return result if self_closing?
+          if !attrs.empty?
+            result << " #{attrs}>"
+            return result if self_closing?
+          elsif attrs.empty? && self_closing?
+            return result << ">"
+          end
 
           result << Quince.to_html(children)
           result << "</#{tag_name}>"
@@ -37,22 +44,19 @@ module Quince
               receiver = value.receiver
               owner = receiver.class.name
               name = value.method_name
-              selector = receiver.send :html_element_selector
+              endpoint = "/api/#{owner}/#{name}"
+              selector = receiver.send :html_parent_selector
               internal = Quince::Serialiser.serialise receiver
-              payload = { component: CGI.escapeHTML(internal) }.to_json
-              payload_var_name = "p"
-              stringify_payload = if value.take_form_values
-                  "{...#{payload_var_name}, params: getFormValues(this)}"
-                else
-                  payload_var_name
-                end
-              cb = %Q{const #{payload_var_name} = #{payload}; callRemoteEndpoint(`/api/#{owner}/#{name}`, JSON.stringify(#{stringify_payload}),`#{selector}`)}
-              cb += ";return false" if value.prevent_default
-              CGI.escape_html(cb)
+              fn_name = "_Q_#{key}_#{receiver.send(:__id)}"
+              rerender = value.rerender
+              state_container = selector
+              push_params_state = value.push_params_state.to_json
+              code = CALLBACK_ERB_INSTANCE.result(binding)
+              return %Q{#{key}="#{CGI.escape_html(code)}" data-qu-#{key}-state="#{CGI.escapeHTML(internal)}"}
             when true
               return key
-            when false, nil, Quince::Types::Undefined
-              return ""
+            when false, nil
+              return nil
             else
               raise "prop type not yet implemented #{value}"
             end
@@ -88,14 +92,35 @@ module Quince
         contents
       }
     end
-  end
 
-  Quince::Component.include HtmlTagComponents
-end
+    ERROR_HANDLING_STYLES = <<~CSS.freeze
+      .quince-err-container {
+        position: absolute;
+        bottom: 32px;
+        width: 300px;
+        height: 50px;
+        background-color: white;
+        border-radius: 4px;
+        border: 1px solid #bbb;
+        z-index: 999;
+        box-shadow: 2px 2px 8px rgba(0,0,0,0.3);
+        padding: 0 24px;
+        left: calc(50vw - 50px);
+      }
 
-# tmp hack
-class TypedStruct < Struct
-  def to_json(*args)
-    to_h.to_json(*args)
+      .quince-err-msg {
+        font-size: 1.2em;
+        text-align: center;
+        margin: auto;
+        color: chocolate;
+      }
+    CSS
+    private_constant :ERROR_HANDLING_STYLES
+
+    def error_message_styles
+      style(ERROR_HANDLING_STYLES)
+    end
   end
+
+  Quince::Component.include HtmlTagComponents
 end

data/lib/quince/singleton_methods.rb

@@ -16,18 +16,37 @@ module Quince
         ) do |params|
           component = component.create if component.instance_of? Class
           Quince::Component.class_variable_set :@@params, params
+          component.instance_variable_set :@render_with, :render
           component
         end
       end
       Object.send :private, :expose
     end
 
-    def define_constructor(const, constructor_name = const.to_s)
+    def define_constructor(const, constructor_name = nil)
+      if const.name
+        parts = const.name.split("::")
+        parent_namespace = Object.const_get(parts[0...-1].join("::")) if parts.length > 1
+        constructor_name ||= parts.last
+      end
+      constructor_name ||= const.to_s
+
       HtmlTagComponents.instance_eval do
-        define_method(constructor_name) do |*children, **props, &block_children|
-          new_props = { **props, Quince::Component::HTML_SELECTOR_ATTR => __id }
+        mthd = lambda do |*children, **props, &block_children|
+          new_props = {
+            **props,
+            Quince::Component::PARENT_SELECTOR_ATTR => __id,
+          }
           const.create(*children, **new_props, &block_children)
         end
+
+        if parent_namespace
+          parent_namespace.instance_exec do
+            define_method(constructor_name, &mthd)
+          end
+        else
+          define_method(constructor_name, &mthd)
+        end
       end
     end
 
@@ -44,12 +63,32 @@ module Quince
           output = to_html(output.call)
         when NilClass
           output = ""
-        else
+        when Component
           tmp = output
-          output = output.render
-          if output.is_a?(Array)
-            raise "#render in #{tmp.class} should not return multiple elements. Consider wrapping it in a div"
+          render_with = output.instance_variable_get(:@render_with) || :render
+          output = output.send render_with
+          case render_with
+          when :render
+            if output.is_a?(Array)
+              raise "#render in #{tmp.class} should not return multiple elements. Consider wrapping it in a div"
+            end
+          else
+            internal = Quince::Serialiser.serialise tmp
+            updated_state = CGI.escapeHTML(internal).to_json
+            selector = tmp.instance_variable_get :@state_container
+            event = tmp.instance_variable_get :@callback_event
+
+            scr = to_html(HtmlTagComponents::Script.create(<<~JS, type: "text/javascript"))
+              var stateContainer = document.querySelector(`#{selector}`);
+              console.log('yes');
+              stateContainer.dataset.quOn#{event}State = #{updated_state};
+            JS
+            output = output.render if output.is_a?(Component)
+
+            output += (output.is_a?(String) ? scr : [scr])
           end
+        else
+          raise "don't know how to render #{output.class} (#{output.inspect})"
         end
       end
 
@@ -57,3 +96,10 @@ module Quince
     end
   end
 end
+
+############## TODO #############
+# I think you should be able to know when a component is the first to be called in a render method,
+# so you should be able to attach some props to it behind the scenes. Then any consumers of this
+# state just have to know the selector, so they can read from it before passing it to the back end.
+#
+# Also, the front end needs to be updated such that script tags from the back end are always read

data/lib/quince/types.rb

@@ -1,13 +1,8 @@
 module Quince
   module Types
-    class Base; end
-
     # precompiled helper types
-    OptionalString = Rbs("String | Quince::Types::Undefined").freeze
-    OptionalBoolean = Rbs("true | false | Quince::Types::Undefined").freeze
-
-    # no functional value for now, other than constants
-    Undefined = Class.new(Base).new.freeze
-    Any = Class.new(Base).new.freeze
+    OptionalString = Rbs("String?").freeze
+    OptionalBoolean = Rbs("true | false | nil").freeze
+    Any = Rbs("untyped").freeze
   end
 end

data/lib/quince/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Quince
-  VERSION = "0.3.0"
+  VERSION = "0.5.0"
 end

data/scripts.js

@@ -1,28 +1,133 @@
-const callRemoteEndpoint = (endpoint, payload, selector) => {
-  fetch(
-    endpoint,
-    {
-      method: `POST`,
-      headers: {
-        "Content-Type": `application/json;charset=utf-8`
-      },
-      body: payload,
-    }
-  ).then(resp => resp.text()).then(html => {
-    const element = document.querySelector(selector);
-    if (!element) {
-      throw `element not found for ${selector}`;
-    }
+const Q = {
+  c: (endpoint, payload, selector, mode, handleErrors) => {
+    return fetch(
+      endpoint,
+      {
+        method: `POST`,
+        headers: {
+          "Content-Type": `application/json;charset=utf-8`
+        },
+        body: payload,
+      }
+    ).then(resp => {
+      if (resp.status <= 299) {
+        return resp.text()
+      } else if (resp.status >= 500) {
+        throw Q.em["500"];
+      } else {
+        let msg = Q.em[`${resp.code}`];
+        
+        if (!msg && resp.code >= 400) msg = Q.em.generic;
+        
+        throw msg;
+      }
+    }).then(html => {
+      const element = document.querySelector(selector);
+      if (!element) {
+        throw `element not found for ${selector}`;
+      }
+
+      switch (mode) {
+        case "append_diff":
+          const tmpElem = document.createElement(element.nodeName);
+          tmpElem.innerHTML = html;
+          const newNodes = Array.from(tmpElem.childNodes);
+          const script = newNodes.pop();
+          const existingChildren = element.childNodes;
+          // This comparison doesn't currently work because of each node's unique id (data-quid).
+          // maybe it would be possible to use regex replace to on the raw html, but it could also
+          // be overkill
+          // let c = 0;
+          // for (; c < existingChildren.length; c++) {
+          //   if (existingChildren[c].isEqualNode(newNodes[c]))
+          //     continue;
+          //   else
+          //     break;
+          // }
+          // for the time being, we can just assume that we can just take the extra items
+          let c = existingChildren.length;
+          for (const node of newNodes.slice(c)) {
+            element.appendChild(node);
+          }
 
-    element.outerHTML = html
-  })
-}
+          const newScript = document.createElement("script");
+          newScript.dataset.quid = script.dataset.quid;
+          newScript.innerHTML = script.innerHTML;
+          document.head.appendChild(newScript);
+          break;
+        case "replace": 
+          element.outerHTML = html;
+          break;
+        default:
+          throw `mode ${mode} is not valid`;
+      }
+    }).catch(err => {
+      if (!handleErrors) throw err;
+
+      let msg;
+      if (typeof err === "string") {
+        msg = err;
+      } else if (err.message) {
+        if (err.message.startsWith("NetworkError")) {
+          msg = Q.em.network;
+        } else {
+          msg = err.message;
+        }
+      } else msg = Q.em.generic;
+      Q.e(msg, 2500);
+    })
+  },
+  f: (elem) => {
+    let form = elem.localName === "form" ? elem : elem.form;
+    if (!form) {
+      throw `element ${elem} should belong to a form`;
+    }
+    const fd = new FormData(form);
+    return Object.fromEntries(fd.entries());
+  },
+  d: (func, wait_ms) => {
+    let timer = null;
 
-const getFormValues = (elem) => {
-  let form = elem.localName === "form" ? elem : elem.form;
-  if (!form) {
-    throw `element ${elem} should belong to a form`;
+    return (...args) => {
+      clearTimeout(timer);
+      return new Promise((resolve) => {
+        timer = setTimeout(
+          () => resolve(func(...args)),
+          wait_ms,
+        );
+      });
+    };
+  },
+  ps: (stateObj) => {
+    const base = location.origin + location.pathname;
+    const url = new URL(base);
+    for (const p in stateObj) {
+      url.searchParams.append(p, stateObj[p]);
+    };
+    window.history.pushState({}, document.title, url);
+  },
+  e: (msg, durationMs) => {
+    const containerClassName = "quince-err-container";
+    document.querySelectorAll(`.${containerClassName}`).forEach(e => e.remove());
+    const container = document.createElement("div");
+    const strong = document.createElement("strong");
+    strong.innerText = msg;
+    container.className = containerClassName;
+    strong.className = "quince-err-msg";
+    container.appendChild(strong);
+    document.body.insertAdjacentElement("afterbegin", container);
+    setTimeout(() => container.remove(), durationMs);
+  },
+  em: {
+    400: "Bad request",
+    401: "Unauthorised",
+    402: "Payment required",
+    403: "Forbidden",
+    404: "Not found",
+    422: "Unprocessable entity",
+    429: "Too many requests",
+    500: "Internal server error",
+    generic: "An error occurred",
+    network: "Network error", 
   }
-  const fd = new FormData(form);
-  return Object.fromEntries(fd.entries());
-}
+};

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: quince
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.5.0
 platform: ruby
 authors:
 - Joseph Johansen
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-09-15 00:00:00.000000000 Z
+date: 2021-10-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: typed_struct
@@ -57,6 +57,7 @@ files:
 - bin/setup
 - lib/quince.rb
 - lib/quince/attributes_by_element.rb
+- lib/quince/callback.js.erb
 - lib/quince/callback.rb
 - lib/quince/component.rb
 - lib/quince/html_tag_components.rb