atome 0.5.1.9 → 0.5.2.7

data/lib/atome/genesis/sparkle.rb

@@ -37,7 +37,7 @@ Atome.new(
 Atome.new(
   { shape: { renderers: default_render, id: :view, type: :shape, parents: [:user_view], children: [],
              left: 0, right: 0, top: 0, bottom: 0, overflow: :auto,
-             color: { renderers: default_render, id: :view_color, type: :color, parents: [:view],
+             color: { renderers: default_render, id: :view_color, type: :color, attach: [:view],
                       red: 0.15, green: 0.15, blue: 0.15, alpha: 1 } } }
 )
 

data/lib/atome/helpers/callbacks.rb

@@ -18,13 +18,15 @@ class Atome
     instance_exec(file, &proc) if proc.is_a?(Proc)
   end
 
-  def time_callback(current_time)
+  def time_callback(current_time, markers)
     @atome[:time] = current_time
-    return unless @at_time[:time] && (current_time.round(1) > @at_time[:time] && @at_time[:used].nil?)
-
-    proc = @at_time[:code]
-    instance_exec(current_time, &proc) if proc.is_a?(Proc)
-    @at_time[:used] = true
+    markers.each_value do |marker|
+      # check if the current time matches the time of the marker, thanks to chat GPT for the example
+      if current_time >= marker[:begin] && current_time < marker[:end]
+        code_found = marker[:code]
+        instance_exec(current_time, &code_found) if code_found.is_a?(Proc)
+      end
+    end
   end
 
   def drag_start_callback(page_x, page_y, left_val, top_val)
@@ -54,27 +56,32 @@ class Atome
     instance_exec(atome, &sort_proc) if sort_proc.is_a?(Proc)
   end
 
-  # def play_start_callback(particle_found, value)
-  #   @atome[particle_found] = value
-  #   play_proc = play_start_proc
-  #   anim_proc = animation_start_proc
-  #   instance_exec({ @atome[particle_found] => value }, &play_proc) if play_proc.is_a?(Proc)
-  #   instance_exec({ @atome[particle_found] => value }, &anim_proc) if anim_proc.is_a?(Proc)
-  # end
-  #
-  # def play_active_callback(particle_found, value)
-  #   @atome[particle_found] = value
-  #   play_proc = play_active_proc
-  #   anim_proc = animation_active_proc
-  #   instance_exec({ @atome[particle_found] => value }, &play_proc) if play_proc.is_a?(Proc)
-  #   instance_exec({ @atome[particle_found] => value }, &anim_proc) if anim_proc.is_a?(Proc)
-  # end
-  #
-  # def play_stop_callback(particle_found, value)
-  #   @atome[particle_found] = value
-  #   play_proc = play_end_proc
-  #   anim_proc = animation_end_proc
-  #   instance_exec({ @atome[particle_found] => value }, &play_proc) if play_proc.is_a?(Proc)
-  #   instance_exec({ @atome[particle_found] => value }, &anim_proc) if anim_proc.is_a?(Proc)
-  # end
+  # animation
+  def browser_animate_callback(particle_found, value, animation_hash, original_particle, animation_atome)
+    anim_proc = animation_hash[:code]
+    #  we exec the callback bloc from :animate
+    instance_exec({ original_particle => value }, &anim_proc) if anim_proc.is_a?(Proc)
+    # we exec the callback bloc from :play
+    play_proc = animation_atome.play_active_proc
+    instance_exec({ @atome[particle_found] => value }, &play_proc) if play_proc.is_a?(Proc)
+    # we animate:
+    browser_object.style[particle_found] = value if browser_object
+    # we update the atome property
+    @atome[original_particle] = value
+  end
+
+  def play_start_callback(_particle_found, _start_value, animation_hash, original_particle, atome_found)
+    value = animation_hash[:begin][original_particle]
+    value = atome_found.atome[original_particle] if value == :self
+    start_proc = @animation_start_proc
+    @atome[original_particle] = value
+    instance_exec({ original_particle => value }, &start_proc) if start_proc.is_a?(Proc)
+  end
+
+  def play_stop_callback(_particle_found, _end_value, animation_hash, original_particle, _atome_found)
+    value = animation_hash[:end][original_particle]
+    end_proc = @animation_stop_proc
+    @atome[original_particle] = value
+    instance_exec({ original_particle => value }, &end_proc) if end_proc.is_a?(Proc)
+  end
 end

data/lib/atome/helpers/essentials.rb

@@ -7,13 +7,16 @@ module Essentials
     animation: { type: :animation },
     element: { type: :element, renderers: [] },
     box: { renderers: '', id: '', type: :shape, parents: [], children: [], width: 99, height: 99,
+           color: { left: 0, top: 0,  red: 0.1, green: 0.9, blue: 0.9, alpha: 1, diffusion: :linear },
            left: 100, top: 100 },
     circle: { renderers: '', id: '', type: :shape, parents: [], children: [], width: 99, height: 99,
+              color: { left: 0, top: 0, red: 0.1, green: 0.9, blue: 0.9, alpha: 1, diffusion: :linear },
               left: 100, top: 100, smooth: '100%' },
     shape: { renderers: '', id: '', width: 100, type: :shape, height: 100, left: 100, top: 100,
-             color: { left: 0, top: 0, z: 0, red: 0.1, green: 0.9, blue: 0.9, alpha: 1, diffusion: :linear },
+             color: { left: 0, top: 0, red: 0.1, green: 0.9, blue: 0.9, alpha: 1, diffusion: :linear },
              generator: :manual },
-    text: { type: :text, parents: [:view], children: [], visual: { size: 25 },
+    text: { renderers: '', id: '',type: :text, parents: [:view], children: [], visual: { size: 25 },
+            color: { left: 0, top: 0, red: 0.3, green: 0.3, blue: 0.3, alpha: 1, diffusion: :linear },
             data: 'this is a text sample', width: 199, height: 33 },
     drm: { type: :drm },
     shadow: {}

data/lib/atome/helpers/utilities.rb

@@ -24,22 +24,51 @@ class Atome
     { date: Time.now, location: geolocation }
   end
 
-  def broadcasting(element, value)
-    return unless @broadcast[:particles]&.include?(element)
-
-    bloc_found = @broadcast[:bloc]
-    instance_exec(self, element, value, &bloc_found) if bloc_found.is_a?(Proc)
-  end
-
   def history(property, value)
     "historize : #{property} #{value}"
   end
 
+  def broadcasting(altered_particle, value)
+    @broadcast.each_value do |particle_monitored|
+      if particle_monitored[:particles].include?(altered_particle)
+        code_found=particle_monitored[:code]
+        instance_exec(self, altered_particle, value, &code_found) if code_found.is_a?(Proc)
+      end
+    end
+  end
+
   public
 
-  def monitor(params, &proc_monitoring)
-    params[:atomes].each do |atome_id|
-      grab(atome_id).instance_variable_set('@broadcast', { particles: params[:particles], bloc: proc_monitoring })
+  def monitor(params=nil, &proc_monitoring)
+    if params
+      atome[:monitor] ||= {}
+      params[:atomes].each do |atome_id|
+        target_broadcaster = grab(atome_id).instance_variable_get('@broadcast')
+        monitor_id = params[:id] || "monitor#{target_broadcaster.length}"
+        atome[:monitor] [monitor_id]=params.merge({code: proc_monitoring})
+        target_broadcaster[monitor_id] = { particles: params[:particles], code:  proc_monitoring }
+      end
+    else
+      atome[:monitor]
+    end
+
+  end
+
+  def store_code_bloc(element, &user_proc)
+    # TODO : maybe we have to change tis code if we need multiple proc for an particle
+    Object.attr_accessor "#{element}_code"
+
+    instance_variable_set("@#{element}_code", user_proc)
+  end
+
+
+  def particles(particles_found = nil)
+    if particles_found
+      particles_found.each do |particle_found, value_found|
+        atome[particle_found] = value_found
+      end
+    else
+      atome
     end
   end
 
@@ -48,6 +77,26 @@ class Atome
     real_atome[property] << value
   end
 
+  def add_to_hash(particle, values, &user_proc)
+    # we update  the holder of any new particle if user pass a bloc
+    store_code_bloc(particle, &user_proc) if user_proc
+    values.each do |value_id, value|
+      @atome[particle][value_id] = value
+    end
+  end
+
+  def add_to_array(particle, value, &_user_proc)
+    # we update  the holder of any new particle if user pass a bloc
+    @atome[particle] << value
+  end
+
+  def add(particles, &user_proc)
+    particles.each do |particle, value|
+      particle_type = Universe.particle_list[particle]
+      send("add_to_#{particle_type}", particle, value, &user_proc)
+    end
+  end
+
   def refresh
     collapse
   end

data/lib/atome/kernel/universe.rb

@@ -4,7 +4,7 @@
 class Universe
   @atomes = {}
   @atome_list = []
-  @particle_list = []
+  @particle_list = {}
   @renderer_list = %i[html browser headless server]
   @options = {}
   @sanitizers = {}
@@ -12,8 +12,8 @@ class Universe
   class << self
     attr_reader :atomes, :renderer_list, :atome_list, :particle_list
 
-    def add_to_particle_list(particle = nil)
-      instance_variable_get('@particle_list').push(particle)
+    def add_to_particle_list(particle = nil, type)
+      instance_variable_get('@particle_list')[particle]=type
     end
 
     def add_optional_method(method_name, &method_proc)
@@ -58,10 +58,6 @@ class Universe
       # and finally the object is 3 as this the third object created by the main server
     end
 
-    # def change_atome_id(prev_id, new_id)
-    #   @atomes[new_id] = @atomes.delete(prev_id)
-    # end
-
     def delete(id)
       @atomes.delete(id)
     end

data/lib/atome/presets/atome.rb

@@ -11,6 +11,7 @@ class Atome
     temp_default = Essentials.default_params[atome_type] || {}
     temp_default[:id] = generated_id
     temp_default[:parents] = generated_parents
+    temp_default[:clones] = []
     temp_default[:renderers] = generated_render
     temp_default.merge(params)
   end
@@ -22,8 +23,6 @@ class Atome
     generated_id = params[:id] || "#{atome_type}_#{Universe.atomes.length}"
     generated_parents = params[:parents] || [id.value]
     params = atome_common(atome_type, generated_id, generated_render, generated_parents, params)
-    color_generated = sanitize(:color, { parents: [generated_id], red: 0.3, green: 0.3, blue: 0.3 })
-    params[:color] = color_generated
     Atome.new({ atome_type => params }, &bloc)
   end
 
@@ -34,14 +33,11 @@ class Atome
     generated_id = params[:id] || "#{atome_type}_#{Universe.atomes.length}"
     generated_parents = params[:parents] || [id.value]
     params = atome_common(atome_type, generated_id, generated_render, generated_parents, params)
-    color_generated = sanitize(:color, { parents: [generated_id], red: 0.6, green: 0.6, blue: 0.6 })
-    params[:color] = color_generated
     Atome.new({ atome_type => params }, &bloc)
   end
 
   def image(params = {}, &bloc)
     default_renderer = Essentials.default_params[:render_engines]
-
     generated_id = params[:id] || "image_#{Universe.atomes.length}"
     generated_render = params[:renderers] || default_renderer
     generated_parents = params[:parents] || id.value
@@ -59,8 +55,6 @@ class Atome
     generated_id = params[:id] || "#{atome_type}_#{Universe.atomes.length}"
     generated_parents = params[:parents] || [id.value]
     params = atome_common(atome_type, generated_id, generated_render, generated_parents, params)
-    color_generated = sanitize(:color, { parents: [generated_id], red: 0.9, green: 0.9, blue: 0.9 })
-    params[:color] = color_generated
     Atome.new({ atome_type => params }, &bloc)
   end
 
@@ -85,4 +79,14 @@ class Atome
     params = temp_default.merge(params)
     Atome.new({ image: params }, &bloc)
   end
+
+  def animation(params = {}, &bloc)
+    default_renderer = Essentials.default_params[:render_engines]
+    atome_type = :animation
+    generated_render = params[:renderers] || default_renderer
+    generated_id = params[:id] || "#{atome_type}_#{Universe.atomes.length}"
+    generated_parents = params[:parents] || []
+    params = atome_common(atome_type, generated_id, generated_render, generated_parents, params)
+    Atome.new({ atome_type => params }, &bloc)
+  end
 end

data/lib/atome/renderers/browser/atome.rb

@@ -10,7 +10,7 @@ def parents(_val) end
 
 generator = Genesis.generator
 
-generator.build_render_method(:browser_shape) do
+generator.build_render(:browser_shape) do
   @browser_type = :div
   id_found = @atome[:id]
   DOM do
@@ -19,7 +19,7 @@ generator.build_render_method(:browser_shape) do
   @browser_object = BrowserHelper.browser_document[id_found]
 end
 
-generator.build_render_method(:browser_color) do |_value|
+generator.build_render(:browser_color) do |_value|
   @browser_type = :style
   id_found = @atome[:id]
   type_found = @atome[:type]
@@ -36,7 +36,7 @@ generator.build_render_method(:browser_color) do |_value|
   @browser_object = BrowserHelper.browser_document[id_found]
 end
 
-generator.build_render_method(:browser_shadow) do |_value|
+generator.build_render(:browser_shadow) do |_value|
   @browser_type = :style
   id_found = @atome[:id]
   type_found = @atome[:type]
@@ -58,7 +58,7 @@ generator.build_render_method(:browser_shadow) do |_value|
   @browser_object = BrowserHelper.browser_document[id_found]
 end
 
-generator.build_render_method(:browser_image) do |_user_prc|
+generator.build_render(:browser_image) do |_user_prc|
   @browser_type = :div
   id_found = @atome[:id]
   DOM do
@@ -67,7 +67,7 @@ generator.build_render_method(:browser_image) do |_user_prc|
   @browser_object = BrowserHelper.browser_document[id_found]
 end
 
-generator.build_render_method(:browser_text) do |_value, _user_proc|
+generator.build_render(:browser_text) do |_value, _user_proc|
   id_found = @atome[:id]
   DOM do
     div(id: id_found).atome.text
@@ -76,7 +76,7 @@ generator.build_render_method(:browser_text) do |_value, _user_proc|
   @browser_type = :div
 end
 
-generator.build_render_method(:browser_web) do
+generator.build_render(:browser_web) do
   @browser_type = :web
   id_found = @atome[:id]
   DOM do
@@ -87,7 +87,7 @@ generator.build_render_method(:browser_web) do
   @browser_object.attributes[:allowfullscreen] = true
 end
 
-generator.build_render_method(:browser_video) do |_value, _user_proc|
+generator.build_render(:browser_video) do |_value, _user_proc|
   @browser_type = :div
   id_found = @atome[:id]
   DOM do

data/lib/atome/renderers/browser/browser.rb

@@ -8,11 +8,13 @@ require 'atome/renderers/browser/material'
 require 'atome/renderers/browser/spatial'
 require 'atome/renderers/browser/atome'
 require 'atome/renderers/browser/utility'
+require 'atome/renderers/browser/time'
 require 'atome/renderers/browser/helpers/browser_helper'
 require 'atome/renderers/browser/helpers/animation_helper'
 require 'atome/renderers/browser/helpers/color_helper'
 require 'atome/renderers/browser/helpers/drag_helper'
 require 'atome/renderers/browser/helpers/effect_helper'
+require 'atome/renderers/browser/helpers/event_helper'
 require 'atome/renderers/browser/helpers/image_helper'
 require 'atome/renderers/browser/helpers/shadow_helper'
 require 'atome/renderers/browser/helpers/shape_helper'
@@ -21,7 +23,9 @@ require 'atome/renderers/browser/helpers/video_helper'
 require 'atome/renderers/browser/helpers/web_helper'
 
 class Atome
-  attr_accessor :browser_object
+  attr_accessor 'browser_object'
 end
 
-AtomeJS=`atomeJS`
+def atome_js
+  `atomeJS`
+end

data/lib/atome/renderers/browser/effect.rb

@@ -2,7 +2,7 @@
 
 generator = Genesis.generator
 
-generator.build_render_method(:browser_smooth) do |value|
+generator.build_render(:browser_smooth) do |value|
   format_params = case value
                   when Array
                     properties = []
@@ -18,6 +18,6 @@ generator.build_render_method(:browser_smooth) do |value|
   @browser_object.style['border-radius'] = format_params
 end
 
-generator.build_render_method(:browser_blur) do |value|
+generator.build_render(:browser_blur) do |value|
   BrowserHelper.send("browser_blur_#{@browser_type}", @browser_object, value, @atome)
 end

data/lib/atome/renderers/browser/event.rb

@@ -2,20 +2,20 @@
 
 generator = Genesis.generator
 
-generator.build_render_method(:browser_touch) do |_value, proc|
-  @browser_object.on :click do |e|
-    instance_exec(e, &proc) if proc.is_a?(Proc)
-  end
+generator.build_render(:browser_touch) do |value, proc|
+  atome_id = @browser_object.attribute(:id)
+  BrowserHelper.send("browser_touch_#{value}", atome_id, proc)
+  # end
 end
 
-generator.build_render_method(:browser_play) do |value, proc|
+generator.build_render(:browser_play) do |value, proc|
   # first we reinit the 'at' event so the condition will be met again
-  @at_time[:used] = nil
+  # @at_time[:used] = nil
   @browser_object.currentTime = value if value != true
   BrowserHelper.send("browser_play_#{@atome[:type]}", value, @browser_object, @atome, self, proc)
 end
 
-generator.build_render_method(:browser_time) do |value = nil, _proc|
+generator.build_render(:browser_time) do |value = nil, _proc|
   if value
     @browser_object.currentTime = value
   else
@@ -23,23 +23,23 @@ generator.build_render_method(:browser_time) do |value = nil, _proc|
   end
 end
 
-generator.build_render_method(:browser_pause) do |_value, proc|
+generator.build_render(:browser_pause) do |_value, proc|
   instance_exec(@browser_object.currentTime, &proc) if proc.is_a?(Proc)
   @browser_object.pause
 end
 
-generator.build_render_method(:on) do |value, proc|
+generator.build_render(:on) do |value, proc|
   @browser_object.on(value) do |e|
     instance_exec(e, &proc) if proc.is_a?(Proc)
   end
 end
 
-generator.build_render_method(:fullscreen) do |_value, _proc|
+generator.build_render(:fullscreen) do |_value, _proc|
   atome_id = atome[:id]
-  AtomeJS.JS.fullscreen(atome_id)
+  atome_js.JS.fullscreen(atome_id)
 end
 
-generator.build_render_method(:mute) do |value, _proc|
+generator.build_render(:mute) do |value, _proc|
   if value
     browser_object.muted
   else
@@ -47,18 +47,24 @@ generator.build_render_method(:mute) do |value, _proc|
   end
 end
 
-generator.build_render_method(:browser_at) do |at, proc|
-  @at_time = { code: proc }.merge(at)
-end
-
-generator.build_render_method(:browser_drag) do |options, proc|
+generator.build_render(:browser_drag) do |options, proc|
   options.each do |method, params|
     atome_id = @atome[:id]
     BrowserHelper.send("browser_drag_#{method}", params, atome_id, self, proc)
   end
 end
 
-generator.build_render_method(:browser_sort) do |options, _proc|
-  AtomeJS.JS.sort(options, @atome[:id], self)
+generator.build_render(:browser_sort) do |options, _proc|
+  atome_js.JS.sort(options, @atome[:id], self)
 end
 
+# TODO: for now unbind remove all touch event we should remove only the targeted one (store proc and restore it)
+generator.build_render(:browser_unbind) do |options, _proc|
+  id_found = self.atome[:id]
+  `
+const el = document.getElementById(#{id_found});
+interact('#'+#{id_found}).unset(#{options});
+`
+end
+
+

data/lib/atome/renderers/browser/geometry.rb

@@ -2,10 +2,10 @@
 
 generator = Genesis.generator
 
-generator.build_render_method(:browser_width) do |value|
+generator.build_render(:browser_width) do |value|
   @browser_object.style[:width] = "#{value}px"
 end
 
-generator.build_render_method(:browser_height) do |value|
+generator.build_render(:browser_height) do |value|
   @browser_object.style[:height] = "#{value}px"
 end

data/lib/atome/renderers/browser/helpers/animation_helper.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+# for browser rendering
+module BrowserHelper
+  def self.anim_convertor(value)
+    { left: [:left, "#{value}px"], right: [:right, "#{value}px"], top: [:top, "#{value}px"],
+      bottom: [:bottom, "#{value}px"], smooth: ['border-radius', "#{value}px"],
+      left_add: ['transform', "translateX(#{value}px)"],
+      right_add: ['transform', "translateY(#{value}px)"],
+      width: [:width, "#{value}px"], height: [:height, "#{value}px"] }
+  end
+
+  def self.anim_value_analysis(value, particle_found, atome_found)
+    case value
+    when :self
+      # this case mean the user use the current atome so we get the particle value of the atome
+      value = atome_found.atome[particle_found]
+    when Integer
+      value
+    else
+      # this case mean the user try to pass an id so we get the particle value of the atome
+      value = grab(value).atome[particle_found]
+      value
+    end
+    value
+  end
+
+  def self.send_anim_to_js(animation, atome_hash, atome_found, atome_id, animation_atome)
+    animated_particle = animation[0]
+    start_value = animation[1]
+    end_value = animation[2]
+    original_particle = animation[3]
+    atome_js.JS.animate(animated_particle, atome_hash[:duration], atome_hash[:damping], atome_hash[:ease],
+                       atome_hash[:mass], atome_hash[:repeat], atome_hash[:stiffness], atome_hash[:velocity],
+                       start_value, end_value, atome_id, atome_found, atome_hash, original_particle, animation_atome)
+  end
+
+  def self.sanitize_anim_params(value, particle_found, atome_hash, atome_found, atome_id, animation_atome)
+    start_value = anim_value_analysis(value, particle_found, atome_found)
+    start_value = BrowserHelper.anim_convertor(start_value)[particle_found][1]
+    end_value = anim_value_analysis(atome_hash[:end][particle_found], particle_found, atome_found)
+    end_value = BrowserHelper.anim_convertor(end_value)[particle_found][1]
+    animated_particle = BrowserHelper.anim_convertor(value)[particle_found][0]
+    # animation is a stupid array to satisfy rubocop stupidity
+    animation = [animated_particle, start_value, end_value, particle_found]
+    send_anim_to_js(animation, atome_hash, atome_found, atome_id, animation_atome)
+  end
+
+  def self.anim_pop_motion_converter(atome_hash, atome_found, atome_id, animation_atome)
+    atome_hash[:dampingRatio] = atome_hash.delete(:damping)
+    atome_hash[:begin].each do |particle_found, value|
+      sanitize_anim_params(value, particle_found, atome_hash, atome_found, atome_id, animation_atome)
+    end
+  end
+
+  def self.begin_animation(atome_hash, atome_found, atome_id, animation_atome)
+    anim_pop_motion_converter(atome_hash, atome_found, atome_id, animation_atome)
+  end
+
+  def self.browser_play_animation(_options, _browser_object, atome_hash, animation_atome, proc)
+    atome_hash[:targets] = [:eDen] unless atome_hash[:targets]
+    animation_atome.play_active_proc = proc
+    atome_hash[:targets].each do |target|
+      atome_found = grab(target)
+      atome_id = atome_found.atome[:id]
+      begin_animation(atome_hash, atome_found, atome_id, animation_atome)
+    end
+  end
+end

data/lib/atome/renderers/browser/helpers/browser_helper.rb

@@ -14,5 +14,4 @@ module BrowserHelper
   def self.browser_attach_style(parents, _html_object, atome)
     browser_document[parents].add_class(atome[:id])
   end
-  
 end

data/lib/atome/renderers/browser/helpers/color_helper.rb

@@ -2,7 +2,6 @@
 
 # for browser rendering
 module BrowserHelper
-
   def self.browser_colorize_color(color_updated, atome)
     `document.getElementById(#{atome[:id]}).sheet.cssRules[0].style.backgroundColor = #{color_updated}`
   end
@@ -31,5 +30,4 @@ module BrowserHelper
   def self.browser_bottom_color(_value, _browser_object, _atome)
     puts 'code to write when implementing gradient'
   end
-
 end

data/lib/atome/renderers/browser/helpers/drag_helper.rb

@@ -5,28 +5,28 @@
 module BrowserHelper
   def self.browser_drag_move(params, atome_id, atome, proc)
     atome.drag_move_proc = proc
-    AtomeJS.JS.drag(params, atome_id, atome)
+    atome_js.JS.drag(params, atome_id, atome)
   end
 
   def self.browser_drag_lock(params, atome_id, atome, _proc)
-    AtomeJS.JS.lock(params, atome_id, atome)
+    atome_js.JS.lock(params, atome_id, atome)
   end
 
   def self.browser_drag_remove(params, atome_id, atome, _proc)
     params = params != true
-    AtomeJS.JS.remove(params, atome_id, atome)
+    atome_js.JS.remove(params, atome_id, atome)
   end
 
   def self.browser_drag_snap(params, atome_id, atome, _proc)
-    AtomeJS.JS.snap(params.to_n, atome_id, atome)
+    atome_js.JS.snap(params.to_n, atome_id, atome)
   end
 
   def self.browser_drag_inertia(params, atome_id, atome, _proc)
-    AtomeJS.JS.inertia(params, atome_id, atome)
+    atome_js.JS.inertia(params, atome_id, atome)
   end
 
   def self.browser_drag_constraint(params, atome_id, atome, _proc)
-    AtomeJS.JS.constraint(params.to_n, atome_id, atome)
+    atome_js.JS.constraint(params.to_n, atome_id, atome)
   end
 
   def self.browser_drag_start(_params, _atome_id, atome, proc)

data/lib/atome/renderers/browser/helpers/effect_helper.rb

@@ -2,6 +2,7 @@
 
 # for browser rendering
 module BrowserHelper
+
   def self.browser_blur_style(_browser_object, value, atome)
     b_left = "#{atome[:left]}px"
     b_top = "#{atome[:top]}px"