atome 0.5.5.7.7 → 0.5.5.8.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2a47df79a8df1efe611c135f99a343afefe4e76b8a23bec82385f6f4a95890b4
-  data.tar.gz: b1315627fd2df81fbc1bb45d19bbc1d6d8a25c8b49e13ab409bc5d0a5b565456
+  metadata.gz: fe95794110662e88b3aac3f5a49c75859e6d8f82bc8d54a1413b99f868139893
+  data.tar.gz: a755990f9a94ee89f4b3d3271b2c6b822c971a225ae5b4b7465c1f845d99a920
 SHA512:
-  metadata.gz: 809b5491aa72a6f62ac9c4765bc4ed7f6910f444ee1447e2ce394c6f1217c72ad1e15f39fd5e0f07c13ca0706acca5e7c66a4fb573c8418d54eef532342ffd3b
-  data.tar.gz: 3df3f9ab29f3d5775fc16d4372cc65f8c9b902771958806eedb7f5fbf05706e5042771248083b6b97a3476eb27055346510a7c3c0772c60e68740ab88bf9ef47
+  metadata.gz: '09a7452177a47e2720aec7f93a48f113a12087b5bd64fcdeb0ffbe30831f70e40ac7fab9f64dcdf8e7636bccbb2d5eb7f7b1b9e8db1cd4ddf1852ad135d2bdbe'
+  data.tar.gz: a3832fda01f201a82ef0182a2275af3a1d650195c308a4cde13594bcf3e6a83e15c6db2c58e19a3e329960d89f9fe6ef3ee3d52c0c557327afe7d272f84fad37

data/exe/atome

@@ -413,6 +413,8 @@ def find_requires(file)
 end
 
 def copy_file(source, destination)
+  return if source == 'server.rb'
+
   FileUtils.mkdir_p(File.dirname(destination))
   FileUtils.cp(source, destination)
 end
@@ -577,52 +579,113 @@ STR
 
 end
 
-if ARGV.include?('opal')
-  puts 'building Opal'
+if ARGV.include?('sparkle')
+  temp_dir = if RbConfig::CONFIG['host_os'] =~ /mswin|mingw|cygwin/
+               'C:\Windows\Temp'
+               # code to exec with Windows
+             elsif RbConfig::CONFIG['host_os'] =~ /darwin|mac os/
+               '/tmp'
+               # code to exec with MacOS
+             else
+               '/tmp'
+               # code to exec with Unix/Linux
+             end
+
+  `cd #{temp_dir}; atome create atome_app` unless Dir.exist?("#{temp_dir}/atome_app")
+  # search for server file
+  if File.exist?('server.rb')
+    file_content = File.read('server.rb')
+    File.write("#{temp_dir}/atome_app/server/atome_server.rb", file_content)
+    base_folder = File.dirname(project_name)
+    copy_with_requires('server.rb', "#{temp_dir}/atome_app/server", base_folder)
+  end
+  project_name = ARGV[1]
+  if project_name.nil? || project_name == 'opal' || project_name == 'wasm' || project_name == 'server'
+    project_name = 'index.rb'
+  end
+  project_name = ensure_rb_extension(project_name)
+  base_folder = File.dirname(project_name)
+  copy_with_requires(project_name, "#{temp_dir}/atome_app/application", base_folder)
 
-  build_opal_application(nil, destination, project_name)
-  # build host_mode
-  build_host_mode(destination, project_name, 'web-opal')
-  # build Opal extensions
-  if RbConfig::CONFIG['host_os'] =~ /mswin|mingw|cygwin/
-    # code to exec for Windows
-    `start "" "#{destination}\\#{project_name}\\src\\index_opal.html"`
-  elsif RbConfig::CONFIG['host_os'] =~ /darwin|mac os/
-    # code to exec for MacOS
-    `open #{destination}/#{project_name}/src/index_opal.html`
+  if ARGV.include?('opal')
+    `cd #{temp_dir}/atome_app;atome run opal`
+
+  elsif ARGV.include?('wasm')
+    `cd #{temp_dir}/atome_app;atome run wasm`
+
+  elsif ARGV.include?('server')
+    `cd #{temp_dir}/atome_app;atome run server`
   else
-    # code to exec for Unix/Linux
-    `open #{destination}/#{project_name}/src/index_opal.html`
+    `cd #{temp_dir}/atome_app;atome run opal`
   end
+else
+  if ARGV.include?('opal')
+    puts 'building Opal'
 
-  puts "opal ready!"
-end
+    build_opal_application(nil, destination, project_name)
+    # build host_mode
+    build_host_mode(destination, project_name, 'web-opal')
+    # build Opal extensions
+    if RbConfig::CONFIG['host_os'] =~ /mswin|mingw|cygwin/
+      # code to exec for Windows
+      `start "" "#{destination}\\#{project_name}\\src\\index_opal.html"`
+    elsif RbConfig::CONFIG['host_os'] =~ /darwin|mac os/
+      # code to exec for MacOS
+      `open #{destination}/#{project_name}/src/index_opal.html`
+    else
+      # code to exec for Unix/Linux
+      `open #{destination}/#{project_name}/src/index_opal.html`
+    end
 
-if ARGV.include?('wasm')
-  puts 'building Ruby wasm'
-  wasi_file = 'wasi-vfs-osx_arm'
-  wasm_common(source, destination, project_name, wasi_file, :pure_wasi)
+    puts "opal ready!"
+  end
+
+  if ARGV.include?('wasm')
+    puts 'building Ruby wasm'
+    wasi_file = 'wasi-vfs-osx_arm'
+    wasm_common(source, destination, project_name, wasi_file, :pure_wasi)
+
+    if RbConfig::CONFIG['host_os'] =~ /mswin|mingw|cygwin/
+      # code to exec for Windows
+      `start "" "#{destination}\\#{project_name}\\src\\index.html"`
+    elsif RbConfig::CONFIG['host_os'] =~ /darwin|mac os/
+      # code to exec for MacOS
+      `open #{destination}/#{project_name}/src/index.html`
+    else
+      # code to exec for Unix/Linux
+      `open #{destination}/#{project_name}/src/index.html`
+    end
 
-  if RbConfig::CONFIG['host_os'] =~ /mswin|mingw|cygwin/
-    # code to exec for Windows
-    `start "" "#{destination}\\#{project_name}\\src\\index.html"`
-  elsif RbConfig::CONFIG['host_os'] =~ /darwin|mac os/
-    # code to exec for MacOS
-    `open #{destination}/#{project_name}/src/index.html`
-  else
-    # code to exec for Unix/Linux
-    `open #{destination}/#{project_name}/src/index.html`
   end
 
-end
+  if ARGV.include?('server')
+    puts 'building Server'
+    build_opal_application(nil, destination, project_name)
+    build_host_mode(destination, project_name, 'web-opal')
+    threads = []
+    threads << Thread.new do
+      sleep 1
+      if RbConfig::CONFIG['host_os'] =~ /mswin|mingw|cygwin/
+        # code to exec with Windows
+        `start "" "#{destination}\\#{project_name}\\src\\index_opal.html`
+      elsif RbConfig::CONFIG['host_os'] =~ /darwin|mac os/
+        # code to exec with MacOS
+        `open http://localhost:9292`
+      else
+        # code to exec with Unix/Linux
+        `open http://localhost:9292`
+      end
+    end
+    threads << Thread.new do
+      build_for_server(destination, project_name, 9292, false)
+    end
 
-if ARGV.include?('server')
-  puts 'building Server'
-  build_opal_application(nil, destination, project_name)
-  build_host_mode(destination, project_name, 'web-opal')
-  threads = []
-  threads << Thread.new do
-    sleep 1
+    threads.each(&:join)
+  end
+
+  if ARGV.include?('server_refresh')
+    puts 're building Server'
+    build_opal_application(nil, destination, project_name)
     if RbConfig::CONFIG['host_os'] =~ /mswin|mingw|cygwin/
       # code to exec with Windows
       `start "" "#{destination}\\#{project_name}\\src\\index_opal.html`
@@ -634,63 +697,19 @@ if ARGV.include?('server')
       `open http://localhost:9292`
     end
   end
-  threads << Thread.new do
-    build_for_server(destination, project_name, 9292, false)
-  end
-
-  threads.each(&:join)
-end
 
-if ARGV.include?('server_refresh')
-  puts 're building Server'
-  build_opal_application(nil, destination, project_name)
-  if RbConfig::CONFIG['host_os'] =~ /mswin|mingw|cygwin/
-    # code to exec with Windows
-    `start "" "#{destination}\\#{project_name}\\src\\index_opal.html`
-  elsif RbConfig::CONFIG['host_os'] =~ /darwin|mac os/
-    # code to exec with MacOS
-    `open http://localhost:9292`
-  else
-    # code to exec with Unix/Linux
-    `open http://localhost:9292`
+  if ARGV.include?('osx')
+    puts 'building osx'
+    wasi_file = 'wasi-vfs-osx_arm'
+    wasm_common(source, destination, project_name, wasi_file, :tauri)
+    build_for_osx(destination)
   end
-end
-
-if ARGV.include?('osx')
-  puts 'building osx'
-  wasi_file = 'wasi-vfs-osx_arm'
-  wasm_common(source, destination, project_name, wasi_file, :tauri)
-  build_for_osx(destination)
-end
 
-puts 'building Android' if ARGV.include?('android')
+  puts 'building Android' if ARGV.include?('android')
 
-puts 'building iOS' if ARGV.include?('ios')
-puts 'building Windows' if ARGV.include?('windows')
-puts 'building Linux' if ARGV.include?('linux')
-puts 'building Freebsd' if ARGV.include?('freebsd')
-
-if ARGV.include?('sparkle')
-  if RbConfig::CONFIG['host_os'] =~ /mswin|mingw|cygwin/
-    temp_dir = 'C:\Windows\Temp'
-    # code to exec with Windows
-  elsif RbConfig::CONFIG['host_os'] =~ /darwin|mac os/
-    temp_dir = '/tmp'
-    # code to exec with MacOS
-  else
-    temp_dir = '/tmp'
-    # code to exec with Unix/Linux
-  end
-  unless Dir.exist?("#{temp_dir}/atome_app")
-    # `cd #{temp_dir}; atome create atome_app;cd atome_app;atome run opal`
-    `cd #{temp_dir}; atome create atome_app`
-  end
-
-  project_name = ARGV[1]
-  project_name = ensure_rb_extension(project_name)
-  base_folder = File.dirname(project_name)
-
-  copy_with_requires(project_name, "#{temp_dir}/atome_app/application", base_folder)
-  `cd #{temp_dir}/atome_app;atome run opal`
+  puts 'building iOS' if ARGV.include?('ios')
+  puts 'building Windows' if ARGV.include?('windows')
+  puts 'building Linux' if ARGV.include?('linux')
+  puts 'building Freebsd' if ARGV.include?('freebsd')
 
 end

data/lib/atome/atome.rb

@@ -5,6 +5,9 @@ class Atome
   include Essentials
 
   def initialize(new_atome = {}, &atomes_proc)
+    # TODO: atome format should always be as followed : {value: 0.44, unit: :px, opt1: 554}
+    # when using optimised version of atome you must type eg : a.set({left: {value: 33, unit: '%', reference: :center}})
+
     # the keys :renderers, :type and :id should be placed in the first position in the hash
     @history = {}
     @callback = {}
@@ -23,7 +26,7 @@ class Atome
     # now we store the proc in a an atome's property called :bloc
     new_atome[:code] = atomes_proc if atomes_proc
     # we reorder the hash
-    ordered_keys = %i[renderers id type]
+    ordered_keys = %i[renderers id alien type]
     ordered_part = ordered_keys.map { |k| [k, new_atome[k]] }.to_h
     other_part = new_atome.reject { |k, _| ordered_keys.include?(k) }
     # merge the parts  to obtain an re-ordered hash

data/lib/atome/extensions/atome.rb

@@ -101,7 +101,7 @@ class Object
     @repeat ||= []
     @repeat << proc
     repeat_id = @repeat.length - 1
-    intervalId = JS.eval(<<~JS)
+    JS.eval(<<~JS)
                 function repeat(action, interval, repetitions) {
                let count = 0;
                let intervalId = null;
@@ -128,7 +128,6 @@ class Object
 
       return intervalId;
     JS
-    intervalId
 
   end
 
@@ -166,4 +165,322 @@ class Object
     atome_get
   end
 
+  # shortcut
+
+  # we initialise $current_hovered_element
+  $current_hovered_element = nil
+
+  def shortcut(key:, option: nil, affect: :all, exclude: [], &block)
+    element_ids = (Array(affect) + Array(exclude)).uniq
+
+    element_ids.each do |element_id|
+      element = JS.global[:document].querySelector("##{element_id}")
+      unless element_id.to_sym == :all
+        element.addEventListener("mouseenter") { $current_hovered_element = element_id }
+        element.addEventListener("mouseleave") { $current_hovered_element = nil }
+      end
+    end
+
+    JS.global[:document].addEventListener("keydown") do |native_event|
+      event = Native(native_event)
+      key_pressed = event[:key].to_s.downcase
+      ctrl_pressed = event[:ctrlKey].to_s
+      alt_pressed = event[:altKey].to_s
+      meta_pressed = event[:metaKey].to_s
+
+      modifier_matched = case option
+                         when :ctrl then ctrl_pressed
+                         when :alt then alt_pressed
+                         when :meta then meta_pressed
+                         else true
+                         end
+
+      affect_condition = affect == :all || Array(affect).include?($current_hovered_element)
+      exclude_condition = !Array(exclude).include?($current_hovered_element)
+      $current_hovered_element = :view if $current_hovered_element.nil?
+      if key_pressed == key.to_s.downcase && modifier_matched && affect_condition && exclude_condition
+        block.call(key_pressed, $current_hovered_element)
+      end
+    end
+  end
+
+  def console(debug)
+    if debug
+      console = box({ id: :console, width: :auto, height: 225, bottom: 0, top: :auto, left: 0, right: 0, depth: 30, color: { alpha: 0, red: 0, green: 0, blue: 0 } })
+      console_back = console.box({ id: :console_back, blur: { value: 5, affect: :back }, overflow: :auto, width: :auto, height: :auto, top: 25, bottom: 0, left: 0, right: 0, depth: 30, color: { alpha: 0.5, red: 0, green: 0, blue: 0 } })
+      console_top = console.box({ id: :console_top, overflow: :auto, width: :auto, height: 25, top: 0, bottom: 0, left: 0, right: 0, depth: 30, color: { alpha: 1, red: 0.3, green: 0.3, blue: 0.3 } })
+
+      console_top.touch(:double) do
+        console.height(25)
+        console.bottom(0)
+        console.top(:auto)
+      end
+      console_top.shadow({
+                           id: :s1,
+                           # affect: [:the_circle],
+                           left: 0, top: 3, blur: 9,
+                           invert: false,
+                           red: 0, green: 0, blue: 0, alpha: 1
+                         })
+      console.drag(:locked) do |event|
+        dy = event[:dy]
+        y = console.to_px(:top) + dy.to_f
+        console.top(y)
+        console.height(:auto)
+        total_height = grab(:view).to_px(:height)
+        # console_back.height(total_height-console.top)
+      end
+      console_output = console_back.text({ data: '', id: :console_output, component: { size: 12 } })
+      JS.eval <<~JS
+        (function() {
+          var oldLog = console.log;
+          var consoleDiv = document.getElementById("console_output");
+          console.log = function(message) {
+            if (consoleDiv) {
+              consoleDiv.innerHTML += '<p>' + message + '</p>';
+            }
+            oldLog.apply(console, arguments);
+          };
+        }());
+      JS
+
+      console_clear = console_top.circle({ id: :console_clear, color: :red, top: 3, left: 3, width: 19, height: 19 })
+      console_clear.touch(true) do
+        console_output.data("")
+      end
+      JS.global[:document].addEventListener("contextmenu") do |event|
+      end
+      # element[:style][:WebkitUserSelect] = 'none'
+      # element[:style][:MozUserSelect] = 'none'
+    else
+      grab(:console_back).delete(true)
+      JS.global[:document].addEventListener("contextmenu") do |native_event|
+        event = Native(native_event)
+        event.preventDefault
+      end
+    end
+  end
+
+  # import methode below
+  def importer_all(&proc)
+    JS.global[:document][:body].addEventListener('dragover') do |native_event|
+      event = Native(native_event)
+      event.preventDefault
+    end
+
+    JS.global[:document][:body].addEventListener('drop') do |native_event|
+      event = Native(native_event)
+      event.preventDefault
+      files = event[:dataTransfer][:files]
+
+      if files[:length].to_i > 0
+        (0...files[:length].to_i).each do |i|
+          file = files[i]
+          reader = JS.eval('let a= new FileReader(); return a')
+          reader.readAsText(file)
+          reader.addEventListener('load') do
+            proc.call({ content: reader[:result].to_s, name: file[:name].to_s, type: file[:type].to_s, size: file[:size].to_s })
+          end
+          reader.addEventListener('error') do
+            puts 'Error: ' + file[:name].to_s
+          end
+        end
+      end
+    end
+  end
+
+  def exception_import(atome_id, &proc)
+    if Universe.user_atomes.include?(atome_id.to_sym)
+      special_div = JS.global[:document].getElementById(atome_id)
+      special_div.addEventListener('dragover') do |native_event|
+        event = Native(native_event)
+        special_div[:style][:backgroundColor] = 'red'
+        event.preventDefault
+        event.stopPropagation
+      end
+
+      special_div.addEventListener('dragleave') do |native_event|
+        event = Native(native_event)
+        special_div[:style][:backgroundColor] = 'yellow'
+        event.stopPropagation
+      end
+
+      special_div.addEventListener('drop') do |native_event|
+        event = Native(native_event)
+        event.preventDefault
+        event.stopPropagation
+
+        files = event[:dataTransfer][:files]
+
+        if files[:length].to_i > 0
+          (0...files[:length].to_i).each do |i|
+            file = files[i]
+            reader = JS.eval('let a= new FileReader(); return a')
+            reader.readAsText(file)
+            reader.addEventListener('load') do
+              proc.call({ content: reader[:result].to_s, name: file[:name].to_s, type: file[:type].to_s, size: file[:size].to_s })
+            end
+            reader.addEventListener('error') do
+              puts 'Error: ' + file[:name].to_s
+            end
+          end
+        end
+      end
+      JS.global[:document][:body].addEventListener('drop') do |native_event|
+        event = Native(native_event)
+        event.preventDefault
+        event.stopPropagation
+        # puts 'File drop out of the special zonne'
+      end
+    end
+  end
+
+  def importer(target = :all, &proc)
+    if target == :all
+      importer_all(&proc)
+    else
+      exception_import(target, &proc)
+    end
+  end
+
+  def infos
+    particle_list = Universe.particle_list.dup
+    particle_list.delete(:password)
+    particle_list.delete(:selection)
+    infos = {}
+    particle_list.each do |particle_found|
+      infos[particle_found[0]] = send(particle_found[0]) unless send(particle_found[0]).nil?
+    end
+    infos
+  end
+
+  def dig
+    ids = []
+    dig_recursive = lambda do |atome|
+      ids << atome.id
+      atome.attached.each { |attached_atome| dig_recursive.call(grab(attached_atome)) }
+    end
+    dig_recursive.call(self)
+    ids
+  end
+
+  def fit(params)
+    unless params.instance_of?(Hash)
+      params = { value: params }
+    end
+    target_size = params[:value]
+    axis = params[:axis]
+    objet_atome = self
+    atomes_found = objet_atome.dig
+    total_width = found_area_used(atomes_found)[:max][:x] - found_area_used(atomes_found)[:min][:x]
+    total_height = found_area_used(atomes_found)[:max][:y] - found_area_used(atomes_found)[:min][:y]
+    if axis == :x
+      ratio = target_size / total_width
+      # now we resize and re-position all atomes
+      atomes_found.each do |atome_id|
+        current_atome = grab(atome_id)
+        current_atome.left(current_atome.left * ratio)
+        current_atome.top(current_atome.top * ratio)
+        new_width = current_atome.to_px(:width) * ratio
+        new_height = current_atome.to_px(:height) * ratio
+        current_atome.width(new_width)
+        current_atome.height(new_height)
+      end
+    else
+      ratio = target_size / total_height
+      # now we resize and re-position all atomes
+      atomes_found.each do |atome_id|
+        current_atome = grab(atome_id)
+        current_atome.left(current_atome.left * ratio)
+        current_atome.top(current_atome.top * ratio)
+        current_atome.width(current_atome.to_px(:width) * ratio)
+        current_atome.height(current_atome.to_px(:height) * ratio)
+      end
+    end
+    # total_size, max_other_axis_size = calculate_total_size(objet_atome, axis)
+    # scale_factor = target_size.to_f / total_size
+    # resize_and_reposition(objet_atome, scale_factor, axis, max_other_axis_size)
+  end
+
+  def found_area_used(ids)
+
+    min_x, min_y = Float::INFINITY, Float::INFINITY
+    max_x, max_y = 0, 0
+
+    ids.each do |id|
+      atome = grab(id)
+
+      x = atome.compute({ particle: :left })[:value]
+      y = atome.compute({ particle: :top })[:value]
+      width = atome.to_px(:width)
+      height = atome.to_px(:height)
+      min_x = [min_x, x].min
+      min_y = [min_y, y].min
+      max_x = [max_x, x + width].max
+      max_y = [max_y, y + height].max
+    end
+
+    { min: { x: min_x, y: min_y }, max: { x: max_x, y: max_y } }
+
+  end
+
+  def calculate_total_size(objet_atome, axis)
+    total_size = (axis == :x) ? objet_atome.to_px(:width) : objet_atome.to_px(:height)
+    max_other_axis_size = (axis == :x) ? objet_atome.to_px(:height) : objet_atome.to_px(:width)
+
+    objet_atome.attached.each do |child_id|
+      child = grab(child_id)
+      child_size = (axis == :x) ? child.to_px(:width) : child.to_px(:height)
+      other_axis_size = (axis == :x) ? child.to_px(:height) : child.to_px(:width)
+
+      total_size += child_size
+      max_other_axis_size = [max_other_axis_size, other_axis_size].max
+    end
+
+    [total_size, max_other_axis_size]
+  end
+
+  def resize_and_reposition(objet_atome, scale_factor, axis, max_other_axis_size)
+    current_position = 0
+    resize_object(objet_atome, scale_factor, axis, max_other_axis_size)
+    current_position += (axis == :x) ? objet_atome.to_px(:width) : objet_atome.to_px(:height)
+    objet_atome.attached.each do |child_id|
+      child = grab(child_id)
+      resize_object(child, scale_factor, axis, max_other_axis_size)
+      child.top(child.top * scale_factor)
+      child.left(child.left * scale_factor)
+      current_position += child.to_px(:height)
+    end
+  end
+
+  def resize_object(objet, scale_factor, axis, max_other_axis_size)
+    if axis == :x
+      new_width = objet.width * scale_factor
+      new_height = new_width / (objet.width.to_f / objet.height)
+      objet.width(new_width)
+      objet.height([new_height, max_other_axis_size].min)
+    else
+      new_height = objet.height * scale_factor
+      new_width = new_height / (objet.height.to_f / objet.width)
+      objet.height(new_height)
+      objet.width([new_width, max_other_axis_size].min)
+    end
+  end
+
+  def atomizer(params)
+    unless params.instance_of? Hash
+      params = { target: params }
+    end
+    id = params[:id]
+    if id
+      id_wanted = { id: id }
+    else
+      id_wanted = {}
+    end
+    basis = { alien: params[:target],renderers: [:html],  type: :atomized }.merge(id_wanted)
+    a = Atome.new(basis)
+    return a
+    # convert any foreign object (think HTML) to a pseudo atome objet , that embed foreign objet
+  end
+
 end

data/lib/atome/genesis/generators/atome.rb

@@ -18,12 +18,17 @@ new({ sanitizer: :image }) do |params|
     # TODO : we have to convert all image to png or maintain a database with extension
     # FIXME : temporary patch that add .png to the string if no extension is found
     params = "#{params}.png" if params.to_s.split('.').length == 1
-
     params = { path: "./medias/images/#{params}" }
   end
   # TODO : the line below should get the value from default params Essentials
   params
 end
+new({ post: :image }) do
+  # we have find the size od the image to set it in the atome
+  instance_variable_set("@width", compute({ particle: :width })[:value])
+  instance_variable_set("@height", compute({ particle: :height })[:value])
+end
+
 new({ atome: :video })
 new({ sanitizer: :video }) do |params|
   unless params.instance_of? Hash
@@ -87,4 +92,8 @@ new({ atome: :machine })
 new({ atome: :paint })
 new({ atome: :vector })
 
+new({ atome: :matrix })
+new({ atome: :atomized, type: :hash })
+
+
 

data/lib/atome/genesis/generators/communication.rb

@@ -6,6 +6,14 @@ new({ particle: :connection }) do |params, bloc|
 end
 
 new({ particle: :message }) do |params, bloc|
-  params = { server: params } unless params.instance_of? Hash
-  html.send_message(params[:server], &bloc)
+
+  params = {message:  params } unless params.instance_of? Hash
+  params[:user]=Universe.current_user
+  params[:pass]=Black_matter.password
+
+  html.send_message(params, &bloc)
 end
+
+new({ particle: :controller }) do |msg|
+  Atome.controller_sender(msg)
+end

data/lib/atome/genesis/generators/effect.rb

@@ -1,4 +1,10 @@
 # frozen_string_literal: true
 
 new({ particle: :smooth })
-new({ particle: :blur })
+
+
+new({ particle: :blur }) do |params|
+  # alert params
+  { value: params, affect: :self } unless params.instance_of?(Hash)
+  # params
+end

data/lib/atome/genesis/generators/event.rb

@@ -229,9 +229,10 @@ new({ sanitizer: :over }) do |params, user_bloc|
   params
 
 end
-new({ particle: :sort }) do |_value, sort_proc|
-  @sort_proc = sort_proc
-end
+# new({ particle: :sort }) do |_value, sort_proc|
+#   @sort_proc = sort_proc
+# end
+
 new({ particle: :targets })
 new({ particle: :start })
 new({ pre: :start }) do |_value, user_proc|