atome 0.5.3.8.0 → 0.5.3.8.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a7a73219833a1b762ef00a884f0799800a1b638742057c29352c98c4208f47df
-  data.tar.gz: 7b343fa8cecaa21084ab2e764ce251b38dc954a8ff97d49e1a951fdcd18760fc
+  metadata.gz: 6e15b6625b3ba6dd5801418dd7dab9f9d0670dedb65e3ea8caa03df984f29541
+  data.tar.gz: 5a23055c7535a94ebe0c29b4dd226477b99564aa73a7f2640c533447bf24f52e
 SHA512:
-  metadata.gz: 482d2e6986aef0fa1ff7dc11df7b89e62fb9fab3211196f9ef5b8be39050478d6735b24e99e9b0e263fdd0fbfcc1fc323ed28ee26daeb7871294ff847cf37d16
-  data.tar.gz: d81ed5c1b4c5e5eacdc3cb85726d0e3d81781726c052bff148664fcf8fd11843f2af975ac3478be9c18b2cffd3cb6cf8a11c6a77de896b528095cc894b378fdf
+  metadata.gz: ca47d04143b5d3cdec3120da89f863f3edaf84cbebee58fc257a8d12c7f1c2d699752ba6cc9e98e080cb10fbebe8900c788bd1c698705a59c7c0dfaa891073db
+  data.tar.gz: f1757fb74688cddb937f1a40790dd33ca121485a2446e2a5236f8de6ae9b302726b71521d2decd455e3cfca9613e37600075e91f3e96cf0777da3b5d67b4cb88

data/Rakefile

@@ -15,7 +15,7 @@ task :re_build do
   FileUtils.copy_entry('vendor/assets/src/js/', 'test/test_app/src/js/')
   FileUtils.copy_entry('vendor/assets/src/css/', 'test/test_app/src/css/')
   FileUtils.copy_entry('vendor/assets/src/medias/', 'test/test_app/src/medias/')
-  `gem cleanup atome;yes | gem uninstall atome ;gem build atome.gemspec;gem install atome`
+  `gem cleanup atome;yes | gem uninstall atome;gem build atome.gemspec;gem install atome --local`
   `cd test/test_app;atome update`
   puts 'solution re-build!'
   # `cd test/test_app;atome update;atome run`
@@ -25,7 +25,7 @@ task :run_browser do
   FileUtils.copy_entry('vendor/assets/src/js/', 'test/test_app/src/js/')
   FileUtils.copy_entry('vendor/assets/src/css/', 'test/test_app/src/css/')
   FileUtils.copy_entry('vendor/assets/src/medias/', 'test/test_app/src/medias/')
-  `gem cleanup atome;yes | gem uninstall atome ;gem build atome.gemspec;gem install atome`
+  `gem cleanup atome;yes | gem uninstall atome;gem build atome.gemspec;gem install atome --local`
   `cd test/test_app;atome update;atome run compile`
   puts 'atome browser is running'
 end
@@ -35,7 +35,7 @@ task :test_server do
   FileUtils.copy_entry('vendor/assets/src/js/', 'test/test_app/src/js/')
   FileUtils.copy_entry('vendor/assets/src/css/', 'test/test_app/src/css/')
   FileUtils.copy_entry('vendor/assets/src/medias/', 'test/test_app/src/medias/')
-  `gem cleanup atome;yes | gem uninstall atome ;gem build atome.gemspec;gem install atome`
+  `gem cleanup atome;yes | gem uninstall atome ;gem build atome.gemspec;gem install atome --local`
   `cd test/test_app;atome update;atome run server`
 end
 

data/exe/atome

@@ -124,11 +124,10 @@ end
 
 def browser_case(location)
   # `cd #{location}/src;open index.html`
-  guard_check
+  # `echo jello`
+  # guard_check
 end
 
-#
-
 def osx_case(location)
   `cd #{location};cargo tauri dev`
 end

data/lib/atome/atome.rb

@@ -8,19 +8,20 @@
 class Atome
   # TODO : clean or delete @private_atome
   include Essentials
+
   private
 
   def initialize(atomes = {}, &atomes_proc)
+
     atomes.each_value do |elements|
       # the instance variable below contain the id all any atomes that need to be informed when changes occurs
       @broadcast = {}
       # now we store the proc in a an atome's property called :bloc
       elements[:code] = atomes_proc if atomes_proc
+
       @atome = elements
-      # we initiate the rendering, eg for for browser we will call :browser_type generate method in identity.rb file
-      create_particle(:type, true, true)
-      # set type is a particle method it's dynamically generated at : generator/identity.rb
-      set_type(@atome[:type])
+      # we initiate the rendering suing set_type method,
+      # eg for for browser we will call :browser_type generate method in identity.rb file
       collapse
     end
   end
@@ -30,7 +31,7 @@ class Atome
       if params || params == false
         # the line below execute the proc created when using the build_particle method
         instance_exec(params, user_proc, &method_proc) if method_proc.is_a?(Proc)
-        params = sanitize(element, params,&user_proc)
+        params = sanitize(element, params, &user_proc)
         create_particle(element, store, render)
         send("set_#{element}", params, &user_proc)
       else
@@ -47,41 +48,67 @@ class Atome
     end
   end
 
-  def atome_creation_pre_treatment(element, params, &user_proc)
+  def atome_parsing(element, params, &user_proc)
     params = sanitize(element, params)
+    current_atome = send(element).value
+
+    # The condition below check if we need to add or replace the newly created atome
+    if current_atome && !(@atome[:add] && @atome[:add][element])
+      detached(current_atome)
+      @atome[element] = []
+    end
+
+
+    # TODO :replace with the line below but need extensive testing as it crash some demos ex: animation
+    params = atome_common(element, params)
+    # ############ code to remove below
+    # parent_found = found_parents_and_renderers[:parent]
+    # render_found = found_parents_and_renderers[:renderers]
+    # default_params = Essentials.default_params[element] || {}
+    # generated_id = params[:id] || identity_generator(element)
+    #
+    # default_params = { renderers: render_found, id: generated_id, type: element,
+    #                    attach: parent_found }.merge(default_params)
+    # params = default_params.merge(params).merge({ clones: [] })
+    # ############ code to remove above
+    # puts params[:renderers]
+    # puts params[:id]
+    # new_params= {renderers: params[:renderers], id:  params[:id]}.merge(params)
+    #
+    # params=new_params
+    # puts "new_params : #{params}"
+    ###
+    ###
+    # puts "params :\n #{params}\n\n, params2 :\n #{params2}"
     run_optional_proc("pre_render_#{@atome[:type]}".to_sym, self, params, &user_proc)
-    create_atome(element)
     run_optional_proc("post_render_#{@atome[:type]}".to_sym, self, params, &user_proc)
-    send("set_#{element}", params, &user_proc)
-  end
-
-  def atome_initializer(element, params = {})
-    temp_default = Essentials.default_params[element] || {}
-    generated_render = params[:renderers] || []
-    generated_id = params[:id] || identity_generator(:element)
-
-    generated_parents = params[:parents] || [id.value]
-    generated_children = params[:children] || []
-    temp_default[:id] = generated_id
-    temp_default[:parents] = generated_parents
-    temp_default[:clones] = []
-    temp_default[:renderers] = generated_render
-    temp_default[:children] = generated_children
-    temp_default.merge(params)
+    send("set_#{element}", params, &user_proc) # it call  Atome.define_method "set_#{element}" in  new_atome method
   end
 
   def new_atome(element, &method_proc)
-    Atome.define_method element do |params = nil, &user_proc|
 
+    # the method define below is the slowest but params are analysed and sanitized
+    Atome.define_method element do |params = nil, &user_proc|
       if params
         instance_exec(params, user_proc, &method_proc) if method_proc.is_a?(Proc)
-        atome_creation_pre_treatment(element, params, &user_proc)
+        atome_parsing(element, params, &user_proc)
       else
         get_atome(element, &user_proc)
       end
     end
+
+    # the method define below is the fastest params are passed directly
+    Atome.define_method "set_#{element}" do |params, &user_proc|
+      # we add the newly created atome to the list of "child in it's category, eg if it's a shape we add the new atome
+      # to the shape particles list : @atome[:shape] << params[:id]
+      new_atome = Atome.new({ element => params }, &user_proc)
+      # Now we return the newly created atome instead of the current atome that is the parent cf: b=box; c=b.circle
+      # c must return the circle not the parent box
+      new_atome
+    end
     # the method below generate Atome method creation at Object level
     create_method_at_object_level(element)
+
   end
 
   def new_render_engine(renderer_name, &method_proc)
@@ -119,10 +146,10 @@ class Atome
     # Params is now an instance variable so it should be passed thru different methods
     instance_variable_set("@#{element}", params) if store
     run_optional_proc("pre_render_#{element}".to_sym, self, params, &user_proc)
-    rendering(element,params, &user_proc) if render
+    rendering(element, params, &user_proc) if render
     run_optional_proc("post_render_#{element}".to_sym, self, params, &user_proc)
     broadcasting(element)
-    store_value(element)  if store
+    store_value(element) if store
     self
   end
 
@@ -142,8 +169,6 @@ class Atome
     virtual_atome.real_atome = @atome
     virtual_atome.property = element
     virtual_atome.user_proc = user_proc
-    # run_optional_proc("pre_get_#{@atome[:type]}".to_sym, 'virtual_atome', &user_proc)
-    # run_optional_proc("pre_get_#{element}".to_sym, self, 'virtual_atome', &user_proc)
     virtual_atome
   end
 
@@ -156,11 +181,5 @@ class Atome
     virtual_atome
   end
 
-  def create_atome(new_atome)
-    Atome.define_method "set_#{new_atome}" do |params, &user_proc|
-      Atome.new({ new_atome => params }, &user_proc)
-    end
-  end
-
   Universe.connected
 end

data/lib/atome/extensions/atome.rb

@@ -20,7 +20,7 @@ def new(params, &bloc)
   end
 end
 
-def identity_generator(type=:element)
+def identity_generator(type = :element)
   "#{type}_#{Universe.counter}"
   # { date: Time.now, location: geolocation }
 end
@@ -46,7 +46,8 @@ end
 def create_method_at_object_level(element)
 
   Object.define_method element do |params, &user_proc|
-    grab(:view).send(element, params, &user_proc)
+    default_parent=Essentials.default_params[element][:attach][0] # we get the first parents
+    grab(default_parent).send(element, params, &user_proc)
   end
 
 end

data/lib/atome/extensions/matrix.rb

@@ -1,5 +1,4 @@
 # frozen_string_literal: true
-#
 
 module Matrix
   def content(items = nil)
@@ -80,6 +79,7 @@ module Matrix
         cells_to_alter = cells_in_column[value[0]..value[1]]
         cells_to_alter.each_with_index do |cell_nb, index|
           current_cell = grab("#{id.value}_#{cell_nb}")
+          # puts "==> current cell is #{id}"
           if index.zero?
             current_cell.height(cell_height * cells_to_alter.length + @margin * (cells_to_alter.length - 1))
           else
@@ -173,9 +173,8 @@ module Matrix
         x = (col_index + 1) * margin + col_index * cell_width
         y = (row_index + 1) * margin + row_index * cell_height
         current_cell = grab("#{matrix_id}_#{i}")
-        # puts "===> #{current_cell}"
-        current_cell.children.each do |child|
-          # puts "=>#{cell_width}"
+        # puts current_cell
+        current_cell.materials.each do |child|
           grab(child).width(cell_width) if grab(child)
           grab(child).height(cell_width) if grab(child)
         end
@@ -189,19 +188,21 @@ module Matrix
 
     # exceptions management
 
-    number_of_cells = nb_of_rows * nb_of_cols
+    # number_of_cells = nb_of_rows * nb_of_cols
     # columns exceptions
+    # return
     return unless exceptions
 
     fusion({ columns: exceptions[:columns_fusion] }) if exceptions[:columns_fusion]
-    fusion({ rows: exceptions[:rows_fusion] }) if exceptions[:rows_fusion]
-    divide({ columns: exceptions[:columns_divided] }) if exceptions[:columns_divided]
-    divide({ rows: exceptions[:rows_divided] }) if exceptions[:rows_divided]
+    # fusion({ rows: exceptions[:rows_fusion] }) if exceptions[:rows_fusion]
+    # divide({ columns: exceptions[:columns_divided] }) if exceptions[:columns_divided]
+    # divide({ rows: exceptions[:rows_divided] }) if exceptions[:rows_divided]
   end
 
   def apply_style(current_cell, style)
     current_cell.set(style)
   end
+
   def matrix_sanitizer(params)
     default_params = {
 
@@ -213,8 +214,10 @@ module Matrix
     }
     default_params.merge(params)
   end
+
   def matrix(params = {}, &bloc)
-    params= matrix_sanitizer(params)
+    params = matrix_sanitizer(params)
+
     columns_data = if params[:columns]
                      params.delete(:columns)
                    else
@@ -241,14 +244,17 @@ module Matrix
     exceptions_data = params.delete(:exceptions)
     default_renderer = Essentials.default_params[:render_engines]
     atome_type = :matrix
-    generated_render = params[:renderers] || default_renderer
+    # generated_render = params[:renderers] || default_renderer
     generated_id = params[:id] || identity_generator(:matrix)
-
-    generated_parents = params[:parents] || [id.value]
-    generated_children = params[:children] || []
-    params = atome_common(atome_type, generated_id, generated_render, generated_parents, generated_children, params)
-    the_matrix = Atome.new({ atome_type => params }, &bloc)
-
+    #
+    # generated_parents = params[:parents] || [id.value]
+    # generated_children = params[:shape] || []
+    # params = atome_common(atome_type,  params)
+    params = atome_common(:matrix, params)
+    # puts "====>#{params} #{params.class}"
+    the_matrix = Atome.new( atome_type => params , &bloc)
+    # the_matrix = Atome.new(matrix: { type: :shape, id: :my_table, renderers: [:browser], parents: [] }, &bloc)
+    # example = Atome.new(code: { type: :code, renderers: [:headless], parents: [], children: [] })
     # TODO:  use the standard atome creation method (generator.build_atome(:collector)),
     # TODO suite => For now its impossible to make it draggable because it return the created box not the matrix
     # get necessary params
@@ -322,7 +328,10 @@ module Matrix
       apply_style(current_cell, cells_data[:particles])
     end
     # lets create the columns and rows
+
+    # puts "(#{matrix_id}, #{matrix_width}, #{matrix_height}, #{rows}, #{columns}, #{margin}, #{exceptions})"
     the_matrix.format_matrix(matrix_id, matrix_width, matrix_height, rows, columns, margin, exceptions)
+
     the_matrix
   end
 
@@ -405,3 +414,5 @@ end
 class Atome
   include Matrix
 end
+
+

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

@@ -1,138 +1,181 @@
 # frozen_string_literal: true
 
-new({ atome: :color })
+new({ atome: :color, type: :hash })
 
 new({ sanitizer: :color }) do |params|
-  parent_found = found_parents_and_renderers[:parent]
-  if parent_found == [:view]
-    parent_found = [:black_matter] if parent_found == [:view]
-  elsif color.value
-    # we delete any previous color if there's one
-    detached(color.value)
-    grab(color.value)&.delete(true)# we had the condition because the color may exist but
-    # so it is not sanitized so it has no id
-  end
+  # TODO : when attaching color to a shadow it should colorized it , cf : c.shadow({color: :blue}) should work
+  # parent_found = found_parents_and_renderers[:parent]
+  # if parent_found == [:view]
+  #   parent_found = [:black_matter] if parent_found == [:view]
+  # elsif color.value
+  #   # we delete any previous color if there's one
+  #   #  puts "========= #{@atome[:color]}>We should delete the color now except : #{@atome[:add]} "
+  #   unless @atome[:add] && @atome[:add][:color]
+  #     detached(color.value)
+  #     @atome[:color] = [] # we had the condition because the shadow may exist but
+  #   end
+  # end
+
+
 
-  render_found = found_parents_and_renderers[:renderers]
-  generated_id = params[:id] || identity_generator(:color)
 
-  default_params = { renderers: render_found, id: generated_id, type: :color,
-                     attach: parent_found,
-                     red: 0, green: 0, blue: 0, alpha: 1 }
+  # puts "---> :: #{@atome[:add]}"
+  ## we delete any previous shadow if there's one
+  # if color.value
+  #   puts 'We should delete now'
+  #   attached.value.delete(color.value)
+  #   grab(color.value)&.delete(true) # we had the condition because the color may exist but
+  #   # so it is not sanitized so it has no id
+  # end
+  # parent_found = found_parents_and_renderers[:parent]
+  # parent_found = [:user_view] if parent_found == [:view]
+  # render_found = found_parents_and_renderers[:renderers]
+  # generated_id = params[:id] || identity_generator(:color)
+
+  # default_params = { red: 0, green: 0, blue: 0, alpha: 1 }
   params = create_color_hash(params) unless params.instance_of? Hash
-  new_params = default_params.merge!(params)
-  atome[:color] = new_params[:id]
-  new_params
+  # new_params = default_params.merge!(params)
+  # atome[:color] = [new_params[:id]]
+  # test below
+  # atome[:color] = [:poil]
+  # puts "==> #{color.value}"
+  # test above
+  # new_params
+  # atome[:color] << :poil
+  # params={}
+  #
+  params
 end
 
+# new({ sanitizer: :color }) do |params|
+#   parent_found = found_parents_and_renderers[:parent]
+#   # puts  "'''''code_below_is_not_executed'''''"
+#   if parent_found == [:black_matter]
+#     alert :stop_get_out_we_are_the_strong_arm_of_the_law
+#   elsif color.value
+#     puts  ">>> Code_below_is_not_executed : #{self}"
+#     # we delete any previous color if there's one
+#     # detached(color.value)
+#     grab(color.value)&.delete(true) # we had the condition because the color may exist but
+#     # so it is not sanitized so it has no id
+#   end
+#
+#   render_found = found_parents_and_renderers[:renderers]
+#   generated_id = params[:id] || identity_generator(:color)
+#
+#   default_params = { renderers: render_found, id: generated_id, type: :color,
+#                      attach: parent_found,
+#                      red: 0, green: 0, blue: 0, alpha: 1 }
+#   params = create_color_hash(params) unless params.instance_of? Hash
+#   new_params = default_params.merge!(params)
+#   new_params
+# end
+
 new({ atome: :image })
 new({ sanitizer: :image }) do |params|
   unless params.instance_of? Hash
     # TODO : we have to convert all image to png or maintain a database with extension
     params = { path: "./medias/images/#{params}" }
   end
-  default_renderer = Essentials.default_params[:render_engines]
-  generated_id = params[:id] || identity_generator(:image)
-
-  generated_render = params[:renderers] || default_renderer
-  generated_parents = params[:parents] || id.value
-  # TODO : the line below should get the value from default params Essentials
-  temp_default = { renderers: generated_render, id: generated_id, type: :image, parents: [generated_parents],
-                   children: [], width: 99, height: 99, path: './medias/images/atome.svg' }
-  params = temp_default.merge(params)
+  # default_renderer = Essentials.default_params[:render_engines]
+  # generated_id = params[:id] || identity_generator(:image)
+  #
+  # generated_render = params[:renderers] || default_renderer
+  # generated_parents = params[:attach] || id.value
+  # # TODO : the line below should get the value from default params Essentials
+  # temp_default = { renderers: generated_render, id: generated_id, type: :image, attach: [generated_parents],
+  #                  width: 99, height: 99, path: './medias/images/atome.svg' }
+  # params = temp_default.merge(params)
   params
 end
 new({ atome: :video })
-new({ sanitizer: :video }) do |params|
-  parent_found = found_parents_and_renderers[:parent]
-  render_found = found_parents_and_renderers[:renderers]
-  generated_id = params[:id] || identity_generator(:video)
-
-  default_params = { renderers: render_found, id: generated_id, type: :video,
-                     parents: parent_found }
-  default_params.merge!(params)
-end
-new({ atome: :shadow })
+# new({ sanitizer: :video }) do |params|
+#   parent_found = found_parents_and_renderers[:parent]
+#   render_found = found_parents_and_renderers[:renderers]
+#   generated_id = params[:id] || identity_generator(:video)
+#
+#   default_params = { renderers: render_found, id: generated_id, type: :video,
+#                      attach: parent_found }
+#   default_params.merge!(params)
+# end
+new({ atome: :shadow, type: :hash })
 new({ sanitizer: :shadow }) do |params|
-
-  parent_found = found_parents_and_renderers[:parent]
-  if parent_found == [:view]
-    parent_found = [:black_matter] if parent_found == [:view]
-  elsif shadow.value
-    # we delete any previous color if there's one
-    detached(shadow.value)
-    grab(shadow.value)&.delete(true)# we had the condition because the shadow may exist but
-    # so it is not sanitized so it has no id
-  end
+  # TODO : when attaching color to a shadow it should colorised it , cf : c.shadow({color: :blue}) should work
+  # puts "############################{params}###{test}###{test2}##################################"
+  params = {} unless params.instance_of? Hash
+  # parent_found = found_parents_and_renderers[:parent]
+  # if parent_found == [:view]
+  #   parent_found = [:black_matter] if parent_found == [:view]
+  # elsif shadow.value
+  #   # we delete any previous color if there's one
+  #   detached(shadow.value)
+  #   grab(shadow.value)&.delete(true) # we had the condition because the shadow may exist but
+  # end
   ## we delete any previous shadow if there's one
   # if shadow.value
   #   attached.value.delete(shadow.value)
-  #   grab(shadow.value)&.delete(true) # we had the condition because the color may exist but 
+  #   grab(shadow.value)&.delete(true) # we had the condition because the color may exist but
   #   # so it is not sanitized so it has no id
   # end
   # parent_found = found_parents_and_renderers[:parent]
   # parent_found = [:user_view] if parent_found == [:view]
-  render_found = found_parents_and_renderers[:renderers]
-  generated_id = params[:id] || identity_generator(:shadow)
+  # render_found = found_parents_and_renderers[:renderers]
+  # generated_id = params[:id] || identity_generator(:shadow)
+
+  # default_params = { renderers: render_found, id: generated_id, type: :shadow,
+  #                    attach: parent_found,
+  #                    red: 0, green: 0, blue: 0, alpha: 1, blur: 3, left: 3, top: 3 }
+
+
+  default_params = {red: 0, green: 0, blue: 0, alpha: 1, blur: 3, left: 3, top: 3 }
 
-  default_params = { renderers: render_found, id: generated_id, type: :shadow,
-                     attach: parent_found,
-                     red: 0, green: 0, blue: 0, alpha: 1, blur: 3, left: 3, top: 3 }
-  # default_params.merge!(params)
-  params = create_shadow_hash(params) unless params.instance_of? Hash
   new_params = default_params.merge!(params)
-  atome[:shadow] = new_params
+  # atome[:shadow] = [new_params[:id]]
   new_params
-
 end
 new({ atome: :shape })
 new({ atome: :code })
 new({ atome: :audio })
 new({ atome: :element })
 new({ sanitizer: :element }) do |params|
-  parent_found = found_parents_and_renderers[:parent]
-  render_found = []
-  generated_id = params[:id] || identity_generator(:element)
+  # parent_found = found_parents_and_renderers[:parent]
+  # render_found = []
+  # generated_id = params[:id] || identity_generator(:element)
 
-  default_params = { renderers: render_found, id: generated_id, type: :element,
-                     parents: parent_found, data: '' }
+  default_params = { data: '' }
   default_params.merge!(params)
 end
 new({ atome: :web })
 new({ sanitizer: :web }) do |params|
-  default_renderer = Essentials.default_params[:render_engines]
-  generated_id = params[:id] || identity_generator(:web)
-
-  generated_render = params[:renderers] || default_renderer
-  generated_parents = params[:parents] || id.value
+  # default_renderer = Essentials.default_params[:render_engines]
+  # generated_id = params[:id] || identity_generator(:web)
+  #
+  # generated_render = params[:renderers] || default_renderer
+  # generated_parents = params[:attach] || id.value
   # TODO : the line below should get the value from default params Essentials
-  temp_default = { renderers: generated_render, id: generated_id, type: :web, parents: [generated_parents],
-                   children: [], width: 120, height: 120, path: 'https://www.youtube.com/embed/usQDazZKWAk' }
+  temp_default = { path: 'https://www.youtube.com/embed/usQDazZKWAk' }
   params = temp_default.merge(params)
   params
 end
 new({ atome: :collector })
 new({ atome: :animation })
-new({ sanitizer: :animation }) do |params|
-  default_renderer = Essentials.default_params[:render_engines]
-  atome_type = :animation
-  generated_render = params[:renderers] || default_renderer
-  generated_id = params[:id] || identity_generator(atome_type)
-  generated_parents = params[:parents] || []
-  generated_children = params[:children] || []
-  params = atome_common(atome_type, generated_id, generated_render, generated_parents, generated_children, params)
-  params
-end
-new({ atome: :text })
+# new({ sanitizer: :animation }) do |params|
+#   default_renderer = Essentials.default_params[:render_engines]
+#   atome_type = :animation
+#   generated_render = params[:renderers] || default_renderer
+#   generated_id = params[:id] || identity_generator(atome_type)
+#   generated_parents = params[:attach] || []
+#   params = atome_common(atome_type, generated_id, generated_render, generated_parents, params)
+#   params
+# end
+new({ atome: :text, type: :hash })
 new({ sanitizer: :text }) do |params|
   params = { data: params } unless params.instance_of? Hash
-  default_renderer = Essentials.default_params[:render_engines]
-  atome_type = :text
-  generated_render = params[:renderers] || default_renderer
-  generated_id = params[:id] || identity_generator(atome_type)
-  generated_parents = params[:parents] || [id.value]
-  generated_children = params[:children] || []
-  params = atome_common(atome_type, generated_id, generated_render, generated_parents, generated_children, params)
+  # default_renderer = Essentials.default_params[:render_engines]
+  # atome_type = :text
+  # generated_render = params[:renderers] || default_renderer
+  # generated_id = params[:id] || identity_generator(atome_type)
+  # generated_parents = params[:attach] || [id.value]
+  # params = atome_common(atome_type, generated_id, generated_render, generated_parents, params)
   params
 end
-