atome 0.5.7.3.3 → 0.5.7.3.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0f111d86401c9293ac46fa899d202bf0ab2a1c905d5d17186f0b87ba0560f65d
-  data.tar.gz: ae3208f9349448b93a93864308445ce9108c450366ce8ee2ac1b7026724b40c2
+  metadata.gz: 7d7593f1e5f01474e9e5445f3af74ca576521aa07623acc289a2df9946d38447
+  data.tar.gz: 157a8892017ec1c64a7193d261ae21c2c0361c8fef232ceeda18181a02e470b8
 SHA512:
-  metadata.gz: 3139df2c2320097e707d095e2aa577104669823e61c77fa9b7a4e43553537068926cea7701bd0cd9c8e21bd41087f9d1e04f101883adcd0ea3b5cc84ba1d665e
-  data.tar.gz: c151bca3643df87d2388087cf534eb44e22e3ca8bf4281de8a9311bc7a20717164dd8be7c4a65dced3365e23e110af18648d732374706aaa9aab1fabcfc98bee
+  metadata.gz: 49dff402a4d28eaf636d76574701b7739b4e33d961b1402936469facd548234c17c4d4e4733aecbea7c1a5e31d8089bbbdd5a8b4c2cf008d8c6b220af8be6f6a
+  data.tar.gz: 0ab6747de306ebcd4d0e06974bc0f6ecdbad1eb59477c2b96aca7be4bfaaf5851bb507d5cdb04f8ea8e6fdf5196842b5c1d8bd083aafa07bcc53c8e882d68e88

data/lib/atome/atome.rb

@@ -19,7 +19,6 @@ class Atome
   #
   # end
 
-
   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}})
@@ -38,8 +37,8 @@ class Atome
     # @language = :english
     # @callback = {}
     @tag = {}
-    @tick={}
-    @storage={}
+    @tick = {}
+    @storage = {}
     @behavior = {}
     @selected = false
     #@metrics = {}
@@ -48,49 +47,44 @@ class Atome
     @collect = {}
     @int8 = {}
     @css = {}
-    @code={}
-    @aid=  new_atome[:aid]  || identity_generator
-    @controller_proc=[]
+    @code = {}
+    @aid = new_atome[:aid] || identity_generator
+    @controller_proc = []
     @id = new_atome[:id] || @aid
-    Universe.atomes.each_value do |atome_f|
-      # we affect the already existing atome to target
-      next unless atome_f.id == @id
+    # if grab(@id)
+    #   collapse({})
+    #   puts "#{@id} already exists"
+    # else
+      Universe.atomes.each_value do |atome_f|
+        # we affect the already existing atome to target
+        next unless atome_f.id == @id
 
-      new_atome[:affect].each do |affected|
-        grab(affected).apply(@id)
+        new_atome[:affect].each do |affected|
+          grab(affected).apply(@id)
+        end if new_atome[:affect]
+        return false
       end
-      return false
-    end
-    Universe.add_to_atomes(@aid, self)
-    Universe.id_to_aid(@id, @aid)
-    @type = new_atome[:type] || :element
-    @attached = []
-    @affect = []
-    @category = []
-    # @display = { mode: :default }
-    # @backup={} # mainly used to restore particle when using grid /table /list display mode
-    @html = HTML.new(@id, self)
-    @headless = Headless.new(@id, self)
-    @initialized={}
-    @creator= Universe.current_user
-    # 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
-    reordered_atome = reorder_particles(new_atome)
-    # FIXME : try to remove the condition below (it crash in the method :  def generator ... in genesis.rb)
-    collapse(reordered_atome)
-    # end
-    # puts "@initialized : #{Atome.instance_variable_get('@initialized')}"
-    # puts "****> #{Atome.instance_variable_get('@initialized')}"
+      Universe.add_to_atomes(@aid, self)
+      Universe.id_to_aid(@id, @aid)
+      @type = new_atome[:type] || :element
+      @attached = []
+      @affect = []
+      @category = []
+      # @display = { mode: :default }
+      # @backup={} # mainly used to restore particle when using grid /table /list display mode
+      @html = HTML.new(@id, self)
+      @headless = Headless.new(@id, self)
+      @initialized = {}
+      @creator = Universe.current_user
+      # 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
+      reordered_atome = reorder_particles(new_atome)
+      # FIXME : try to remove the condition below (it crash in the method :  def generator ... in genesis.rb)
 
-    # if Atome.instance_variable_get('@initialized')
-    # puts  "-----> #{Atome.instance_variable_get('@initialized')}"
-    #   Atome.instance_variable_get('@initialized').each do |p_found, bloc|
-    #     # puts "==> #{p_found}"
-    #     # instance_exec.call
-    #     # instance_exec(p_found, &bloc) if bloc.is_a?(Proc)
-    #   end
+      collapse(reordered_atome)
     # end
+
   end
 
   def js

data/lib/atome/extensions/atome.rb

@@ -1,16 +1,14 @@
 # frozen_string_literal: true
 
-module ObjectExtension
+require 'time'
 
+module ObjectExtension
 
   def new(params, &bloc)
     # Genesis = Genesis.Genesis
     if params.key?(:atome)
-      # if Universe.atome_list.include?(params[:atome])
-      #   puts "atome #{params[:atome]} already exist you can't create it"
-      # else
-        Universe.add_atomes_specificities params[:atome]
-        Genesis.build_atome(params[:atome], &bloc)
+      Universe.add_atomes_specificities params[:atome]
+      Genesis.build_atome(params[:atome], &bloc)
       # end
     elsif params.key?(:particle)
       if Universe.particle_list[params[:particle]]
@@ -51,12 +49,12 @@ module ObjectExtension
       #     bloc.call(option)
       #   end
     elsif params.key?(:molecule)
-      molecule=params[:molecule]
+      molecule = params[:molecule]
       Genesis.build_molecule(molecule, &bloc)
       Universe.add_to_molecule_list(molecule)
 
-    # elsif params.key?(:applicaton)
-    #   alert params
+      # elsif params.key?(:applicaton)
+      #   alert params
 
       # molecule=params[:molecule]
       # Genesis.build_molecule(molecule, &bloc)
@@ -66,7 +64,7 @@ module ObjectExtension
 
       tool_content = Atome.instance_exec(&bloc) if bloc.is_a?(Proc)
 
-      Universe.tools[params[:tool]]=tool_content
+      Universe.tools[params[:tool]] = tool_content
       # Universe.tools[params[:tool]]=bloc
 
     elsif params.key?(:template)
@@ -86,54 +84,6 @@ end
 # atome extensions
 class Object
   include ObjectExtension
-  # def new(params, &bloc)
-  #   # Genesis = Genesis.Genesis
-  #   if params.key?(:atome)
-  #     if Universe.atome_list.include?(params[:atome])
-  #       puts "atome #{params[:atome]} already exist you can't create it"
-  #     else
-  #       Universe.add_atomes_specificities params[:atome]
-  #       Genesis.build_atome(params[:atome], &bloc)
-  #     end
-  #   elsif params.key?(:particle)
-  #     if Universe.particle_list[params[:particle]]
-  #       puts "particle #{params[:particle]} already exist you can't create it"
-  #     else
-  #       Atome.instance_variable_set("@main_#{params[:particle]}", bloc)
-  #       # render indicate if the particle needs to be rendered
-  #       # store tell the system if it need to store the particle value
-  #       # type help the system what type of type the particle will receive and store
-  #       Genesis.build_particle(params[:particle], { render: params[:render], return: params[:return],
-  #                                                   store: params[:store], type: params[:type],
-  #                                                   category: params[:category] }, &bloc)
-  #     end
-  #
-  #   elsif params.key?(:sanitizer)
-  #     Genesis.build_sanitizer(params[:sanitizer], &bloc)
-  #   elsif params.key?(:pre)
-  #     Atome.instance_variable_set("@pre_#{params[:pre]}", bloc)
-  #   elsif params.key?(:post)
-  #     Atome.instance_variable_set("@post_#{params[:post]}", bloc)
-  #   elsif params.key?(:after)
-  #     Atome.instance_variable_set("@after_#{params[:after]}", bloc)
-  #   elsif params.key?(:read)
-  #     Atome.instance_variable_set("@read_#{params[:read]}", bloc)
-  #   elsif params[:renderer]
-  #     renderer_found = params[:renderer]
-  #     if params[:specific]
-  #       Universe.set_atomes_specificities(params)
-  #       params[:specific] = "#{params[:specific]}_"
-  #     end
-  #     render_method = "#{renderer_found}_#{params[:specific]}#{params[:method]}"
-  #     Genesis.build_render(render_method, &bloc)
-  #   # elsif params.key?(:callback)
-  #   #   particle_targetted = params[:callback]
-  #   #   Atome.define_method("#{particle_targetted}_callback", option) do
-  #   #     alert option
-  #   #     bloc.call(option)
-  #   #   end
-  #   end
-  # end
 
   def reorder_particles(hash_to_reorder)
     # we reorder the hash
@@ -142,7 +92,7 @@ class Object
     ordered_part = ordered_keys.map { |k| [k, hash_to_reorder[k]] }.to_h
     other_part = hash_to_reorder.reject { |k, _| ordered_keys.include?(k) }
     # merge the parts  to obtain an re-ordered hash
-   ordered_part.merge(other_part)
+    ordered_part.merge(other_part)
     # reordered_hash
   end
 
@@ -155,16 +105,14 @@ class Object
   end
 
   def hook(a_id)
-    a_id=a_id.to_sym
+    a_id = a_id.to_sym
     Universe.atomes[a_id]
   end
 
   def grab(id_to_get)
-    id_to_get=id_to_get.to_sym
+    id_to_get = id_to_get.to_sym
     return if id_to_get == false
-    aid_to_get= Universe.atomes_ids[id_to_get]
-    # puts id_to_get.class
-    # alert Universe.atomes
+    aid_to_get = Universe.atomes_ids[id_to_get]
     aid_to_get = '' if aid_to_get.instance_of? Array
     # id_to_get = id_to_get.to_sym
 
@@ -255,7 +203,7 @@ class Object
 
       return intervalId;
     JS
-    repeat_id+1
+    repeat_id + 1
   end
 
   def stop(params)
@@ -266,16 +214,16 @@ class Object
         JS.eval(<<~JS)
           clearInterval(#{repeater_to_stop});
         JS
-      elsif   params.key?(:wait)
+      elsif params.key?(:wait)
         waiter_to_stop = params[:wait]
         JS.eval(<<~JS)
-        clearTimeout(window.timeoutIds['#{waiter_to_stop}'])
+          clearTimeout(window.timeoutIds['#{waiter_to_stop}'])
         JS
       else
-        puts "La clé :repeat n'existe pas dans params"
+        puts "msg from stop method: the :repeat key doesn't exist"
       end
     else
-      puts "params n'est pas un hash"
+      puts "msg from stop method, this params is not a Hash"
     end
   end
 
@@ -462,7 +410,6 @@ class Object
         event = Native(native_event)
         event.preventDefault
         event.stopPropagation
-        # puts 'File drop out of the special zonne'
       end
     end
   end
@@ -480,12 +427,12 @@ class Object
     particle_list.delete(:password)
     particle_list.delete(:selection)
     infos = {}
-    particle_list[:css]=:poil
+    particle_list[:css] = :poil
     particle_list.each do |particle_found|
       infos[particle_found[0]] = send(particle_found[0]) unless send(particle_found[0]).nil?
     end
     # we convert CssProxy object to hash below
-    infos[:css]=eval(infos[:css].to_s)
+    infos[:css] = eval(infos[:css].to_s)
     infos
   end
 
@@ -618,8 +565,6 @@ class Object
     # convert any foreign object (think HTML) to a pseudo atome objet , that embed foreign objet
   end
 
-
-
   def touch_allow(allow)
     if allow
       # Retire l'écouteur d'événements en utilisant la fonction globale
@@ -630,7 +575,6 @@ class Object
     end
   end
 
-
   def allow_copy(allow)
     if allow
       # allow selection and text copy
@@ -647,7 +591,7 @@ class Object
     end
   end
 
-  def above(item, margin=6)
+  def above(item, margin = 6)
     pos = item.to_px(:bottom) + item.height + margin
     if item.display == :none
       33
@@ -656,7 +600,7 @@ class Object
     end
   end
 
-  def below(item, margin=6)
+  def below(item, margin = 6)
     pos = item.to_px(:top) + item.to_px(:height) + margin
     if item.display == :none
       0
@@ -666,7 +610,7 @@ class Object
 
   end
 
-  def after(item, margin=6)
+  def after(item, margin = 6)
     left_f = if item.left.instance_of?(Integer)
                item.left
              else
@@ -686,7 +630,7 @@ class Object
     end
   end
 
-  def before(item, margin=6)
+  def before(item, margin = 6)
     pos = item.to_px(:right) + item.width + margin
     if item.display == :none
       0
@@ -695,6 +639,130 @@ class Object
     end
   end
 
+  # Helper method to store task configuration in localStorage
+  def store_task(name, config)
+    JS.global[:localStorage].setItem(name, config.to_json)
+  end
+
+  # Helper method to retrieve task configuration from localStorage
+  def retrieve_task(name)
+    config = JS.global[:localStorage].getItem(name)
+    config.nil? ? nil : JSON.parse(config)
+  end
+
+  # Helper method to retrieve all tasks from localStorage
+  def retrieve_all_tasks
+    tasks = []
+    local_storage = JS.global[:localStorage]
+    if Atome::host == "web-opal"
+      local_storage.each do |key|
+        value = local_storage.getItem(key)
+        if value
+          value = JSON.parse(value)
+          tasks << { name: key, config: value }
+        end
+      end
+    else
+      length = local_storage[:length].to_i
+      length.times do |i|
+        key = local_storage.call(:key, i)
+        value = local_storage.call(:getItem, key)
+        tasks << { name: key, config: JSON.parse(value.to_s) } if value
+      end
+    end
+    tasks
+  end
+
+  # Helper method to schedule a task
+  def schedule_task(name, years, month, day, hours, minutes, seconds, recurrence: nil, &block)
+    target_time = Time.new(years, month, day, hours, minutes, seconds)
+    now = Time.now
+
+    if target_time < now
+      schedule_recurrence(name, target_time, recurrence, &block)
+    else
+      seconds_until_target = target_time - now
+      wait_task = wait(seconds_until_target) do
+        block.call
+        schedule_recurrence(name, target_time, recurrence, &block) if recurrence
+      end
+      store_task(name, { wait: wait_task, target_time: target_time, recurrence: recurrence })
+    end
+  end
+
+  def schedule_recurrence(name, target_time, recurrence, &block)
+    now = Time.now
+    next_time = target_time
+
+    case recurrence
+    when :yearly
+      next_time += 365 * 24 * 60 * 60 while next_time <= now
+    when :monthly
+      next_time = next_time >> 1 while next_time <= now
+    when :weekly
+      next_time += 7 * 24 * 60 * 60 while next_time <= now
+    when :daily
+      next_time += 24 * 60 * 60 while next_time <= now
+    when :hourly
+      next_time += 60 * 60 while next_time <= now
+    when :minutely
+      next_time += 60 while next_time <= now
+    when :secondly
+      next_time += 1 while next_time <= now
+    when Hash
+      if recurrence[:weekly]
+        wday = recurrence[:weekly]
+        next_time += 7 * 24 * 60 * 60 while next_time <= now
+        next_time += 24 * 60 * 60 until next_time.wday == wday
+      elsif recurrence[:monthly]
+        week_of_month = recurrence[:monthly][:week]
+        wday = recurrence[:monthly][:wday]
+        while next_time <= now
+          next_month = next_time >> 1
+          next_time = Time.new(next_month.year, next_month.month, 1, target_time.hour, target_time.min, target_time.sec)
+          next_time += 24 * 60 * 60 while next_time.wday != wday
+          next_time += (week_of_month - 1) * 7 * 24 * 60 * 60
+        end
+      end
+    else
+      puts "Invalid recurrence option"
+      return
+    end
+
+    seconds_until_next = next_time - Time.now
+    wait_task = wait(seconds_until_next) do
+      block.call
+      schedule_recurrence(name, next_time, recurrence, &block)
+    end
+    store_task(name, { wait: wait_task, target_time: next_time, recurrence: recurrence })
+  end
+
+  # Helper method to stop a scheduled task
+  def stop_task(name)
+    task_config = retrieve_task(name)
+    return unless task_config
+
+    stop({ wait: task_config['wait'] })
+    JS.global[:localStorage].removeItem(name)
+  end
+
+  # Method to relaunch all tasks from localStorage
+  def relaunch_all_tasks
+    tasks = retrieve_all_tasks
+
+    tasks.each do |task|
+      name = task[:name]
+      config = task[:config]
+      target_time_found = config['target_time']
+      target_time = Time.parse(target_time_found)
+      recurrence_found = config['recurrence']
+      next unless recurrence_found
+      recurrence = config['recurrence'].is_a?(Hash) ? config['recurrence'].transform_keys(&:to_sym) : config['recurrence'].to_sym
+      schedule_task(name, target_time.year, target_time.month, target_time.day, target_time.hour, target_time.min, target_time.sec, recurrence: recurrence) do
+        puts "Relaunched task  #{name}(add proc here)"
+      end
+    end
+  end
 
 end
 
@@ -720,7 +788,7 @@ class CssProxy
       @js[@parent_key][key] = value
       @current_atome.instance_variable_set('@css', { @parent_key => { key => value } })
       @css[@parent_key] = { key => value }
-      puts "==> Clé parente: #{@parent_key}, Clé: #{key}, Valeur: #{value}"
+      puts "==> parent key: #{@parent_key}, Clé: #{key}, value: #{value}"
     else
       @style[key] = value
       @js[key] = value
@@ -738,8 +806,6 @@ class CssProxy
     bloc.call(parsed)
   end
 
-
-
 end
 
 

data/lib/atome/genesis/genesis.rb

@@ -81,12 +81,8 @@ class Genesis
       # end
 
       Atome.define_method element do |params = nil, &user_proc|
-        # if @id
-        #   alert  "======> #{self.class}"
         @history[element] ||= []
-        # else
-        #   alert  "======> #{self.inspect}"
-        # end
+
         if (params || params == false) && write_auth(element)
           params = particle_sanitizer(element, params, &user_proc)
           # the line below execute the main code when creating a new particle

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

@@ -1,7 +1,16 @@
 # frozen_string_literal: true
+class Atome
+  def animation_callback(proc_sub_category, value=nil)
+    # puts  "#{p◊roc_sub_category}"
+    proc_found = @animate_code[proc_sub_category]
+    # puts proc_found
+    instance_exec(value,&proc_found) if proc_found.is_a?(Proc)
+  end
+end
 
 new({ particle: :touch, category: :event, type: :hash, store: false })
 new({ sanitizer: :touch }) do |params, user_bloc|
+  # user_params=params.dup
   if params
     # TODO: factorise code below
     @touch ||= {}
@@ -11,6 +20,7 @@ new({ sanitizer: :touch }) do |params, user_bloc|
          user_bloc =params.delete(:code) if params[:code]
          @touch_code[params.keys[0]] = user_bloc
          option = params[params.keys[0]]
+         @touch={ code: user_bloc}
          params.keys[0]
              else
                case params
@@ -47,7 +57,6 @@ new({ sanitizer: :touch }) do |params, user_bloc|
     @touch = false
     params
   end
-
 end
 new({ particle: :play, category: :event, type: :boolean, store: false })
 new({ sanitizer: :play }) do |params, user_bloc|
@@ -94,6 +103,7 @@ new({ sanitizer: :on }) do |params, user_bloc|
   params = if params.instance_of? Hash
              @on_code[:view_resize] = user_bloc
              option = params[params.keys[0]]
+             @resize={ code: user_bloc}
              :resize
            else
              case params
@@ -123,6 +133,7 @@ new({ sanitizer: :drag }) do |params, user_bloc|
        user_bloc =params.delete(:code) if params[:code]
        @drag_code[params.keys[0]] = user_bloc
        option = params[params.keys[0]]
+       @drag={ code: user_bloc}
        params.keys[0]
            else
              case params
@@ -177,6 +188,7 @@ new({ sanitizer: :drop }) do |params, user_bloc|
        user_bloc =params.delete(:code) if params[:code]
        @drop_code[params.keys[0]] = user_bloc
        option = params[params.keys[0]]
+       @drop={ code: user_bloc}
        params.keys[0]
            else
              case params
@@ -215,6 +227,8 @@ new({ sanitizer: :over }) do |params, user_bloc|
        user_bloc =params.delete(:code) if params[:code]
        @over_code[params.keys[0]] = user_bloc
        option = params[params.keys[0]]
+       @over={ code: user_bloc}
+
        params.keys[0]
            else
              case params
@@ -242,9 +256,6 @@ new({ sanitizer: :over }) do |params, user_bloc|
   params
 
 end
-# new({ particle: :sort }) do |_value, sort_proc|
-#   @sort_proc = sort_proc
-# end
 new({ particle: :targets, category: :event, type: :string })
 new({ particle: :start, category: :event, type: :boolean })
 new({ pre: :start }) do |_value, user_proc|
@@ -261,9 +272,8 @@ new({ particle: :mass, category: :event, type: :int })
 new({ particle: :damping, category: :event, type: :int })
 new({ particle: :stiffness, category: :event, type: :int })
 new({ particle: :velocity, category: :event, type: :int })
-# new({ particle: :repeat, category: :event, type: :boolean })
 new({ particle: :ease, category: :event, type: :boolean })
-new(particle: :keyboard, category: :event, type: :hash, store: false)
+new({ particle: :keyboard, category: :event, type: :hash, store: false })
 new({ sanitizer: :keyboard }) do |params, user_bloc|
   @keyboard ||= {}
   @keyboard_code ||= {}
@@ -277,6 +287,8 @@ new({ sanitizer: :keyboard }) do |params, user_bloc|
              @keyboard_code[params.keys[0]] = user_bloc
              option = params[params.keys[0]]
              params.keys[0]
+             @keyboard={ code: user_bloc}
+
            else
              case params
              when true
@@ -314,6 +326,8 @@ new({ sanitizer: :resize }) do |params, user_bloc|
   params = if params.instance_of? Hash
              @resize_code[:resize] = user_bloc
              option = params[params.keys[0]]
+             @resize={ code: user_bloc}
+
              :resize
            else
              case params
@@ -338,16 +352,6 @@ new({ particle: :overflow, category: :event, type: :boolean }) do |params, bloc|
   params
 
 end
-
-class Atome
-  def animation_callback(proc_sub_category, value=nil)
-    # puts  "#{p◊roc_sub_category}"
-    proc_found = @animate_code[proc_sub_category]
-    # puts proc_found
-    instance_exec(value,&proc_found) if proc_found.is_a?(Proc)
-  end
-end
-
 new({ particle: :animate, category: :event, type: :hash }) do |params, proc|
   if params.instance_of? Hash
     params = { from: 0, to: 300, duration: 1000 }.merge(params)
@@ -364,7 +368,12 @@ new({ particle: :animate, category: :event, type: :hash }) do |params, proc|
 
   params
 end
-
-new ({ after: :animate }) do |params|
+new({ after: :animate }) do |params|
   html.animate(params) unless params[:end] || params[:start]
 end
+
+
+# new({ particle: :repeat, category: :event, type: :boolean })
+# # new({ particle: :sort }) do |_value, sort_proc|
+# #   @sort_proc = sort_proc
+# # end

data/lib/atome/genesis/particles/utility.rb

@@ -2,7 +2,7 @@
 
 new({ particle: :renderers, category: :utility, type: :string })
 new({ particle: :code, category: :utility, type: :string, store: false }) do |params, code|
-  @code[params]=code
+  @code[params] = code
 end
 # new({ particle: :run, category: :utility, type: :boolean }) do |params|
 #   code_found = @code
@@ -10,9 +10,9 @@ end
 # end
 
 new({ particle: :run }) do |params, code|
-    instance_exec(&params) if params.is_a?(Proc)
-    code_found = @code[params]
-    instance_exec(params, &code_found) if code_found.is_a?(Proc)
+  instance_exec(&params) if params.is_a?(Proc)
+  code_found = @code[params]
+  instance_exec(params, &code_found) if code_found.is_a?(Proc)
 end
 
 new({ particle: :target }) do |params|
@@ -27,10 +27,9 @@ new({ particle: :target }) do |params|
   end
 end
 
-
 # new({ particle: :broadcast })
 
-def delete_recursive(atome_id, force=false)
+def delete_recursive(atome_id, force = false)
   return if grab(atome_id).tag && (grab(atome_id).tag[:persistent] || grab(atome_id).tag[:system]) unless force
 
   parent_id_found = grab(atome_id).attach
@@ -47,86 +46,95 @@ def delete_recursive(atome_id, force=false)
 end
 
 new({ particle: :delete, category: :utility, type: :boolean, render: false }) do |params|
-  if params == true
 
-    # We use the tag persistent to exclude color of system object and other default colors
-    unless @tag && (@tag[:persistent] || @tag[:system])
+  basic_system_object = %i[view eDen black_matter intuition copy atome
+  user_view view_color shape_color
+box_color invisible_color text_color circle_color back_selection
+text_selection nil
+]
+
+  unless basic_system_object.include?(id) || id.nil?
+
+    if params == true
+      # We use the tag persistent to exclude color of system object and other default colors
+      unless @tag && (@tag[:persistent] || @tag[:system])
+        # if we are on a matrix we delete cells found & group found
+        cells.delete(true)
+        group.delete(true)
+        # now we detach the atome from it's parent
+        # now we init rendering
+        render(:delete, params)
+        # the machine delete the current atome from the universe
+        id_found = @id.to_sym
+        if @attach
+          parent_found = grab(@attach)
+          parent_found.attached.delete(id_found)
+        end
+        @affect&.each do |affected_atome|
+          affected_found = grab(affected_atome)
+          affected_found.apply.delete(id_found)
+          affected_found.refresh
+        end
+
+        # Universe.delete(@aid)
+      end
+    elsif params.instance_of? Hash
       # if we are on a matrix we delete cells found & group found
       cells.delete(true)
       group.delete(true)
-      # now we detach the atome from it's parent
-      # now we init rendering
-      render(:delete, params)
-      # the machine delete the current atome from the universe
-      id_found = @id.to_sym
-      if @attach
-        parent_found = grab(@attach)
-        parent_found.attached.delete(id_found)
-      end
-      @affect&.each do |affected_atome|
-        affected_found = grab(affected_atome)
-        affected_found.apply.delete(id_found)
-        affected_found.refresh
-      end
-      Universe.delete(@aid)
-    end
-  # elsif params == :force
-  #   cells.delete(true)
-  #   group.delete(true)
-  #   # now we detach the atome from it's parent
-  #   # now we init rendering
-  #   render(:delete, params)
-  #   # the machine delete the current atome from the universe
-  #   id_found = @id.to_sym
-  #   if @attach
-  #     parent_found = grab(@attach)
-  #     parent_found.attached.delete(id_found)
-  #   end
-  #   @affect&.each do |affected_atome|
-  #     affected_found = grab(affected_atome)
-  #     affected_found.apply.delete(id_found)
-  #     affected_found.refresh
-  #   end
-  #   Universe.delete(@aid)
-  elsif params.instance_of? Hash
-    # if we are on a matrix we delete cells found & group found
-    cells.delete(true)
-    group.delete(true)
-    if params[:recursive]
-      unless grab(@id).tag && (grab(@id).tag[:persistent] || grab(@id).tag[:system])
+      if params[:recursive]
+        unless grab(@id).tag && (grab(@id).tag[:persistent] || grab(@id).tag[:system])
+          attached.each do |atttached_atomes|
+            delete_recursive(atttached_atomes)
+          end
+          # touch(:remove)
+          # render(:delete, params)
+          # Universe.delete(@aid)
+        end
+      elsif params[:force]
         attached.each do |atttached_atomes|
-          delete_recursive(atttached_atomes)
+          # alert "attached : #{attached}"
+          delete_recursive(atttached_atomes, true)
+        end
+        # touch(:remove)
+        # render(:delete, params)
+        # Universe.delete(@aid)
+      else
+        # the machine try to find the sub particle id and remove it eg a.delete(monitor: :my_monitor) remove the monitor
+        # with id my_monitor
+        params.each do |param, value|
+          atome[param][value] = nil
         end
-        touch(:remove)
-        render(:delete, params)
-        Universe.delete(@aid)
-      end
-    elsif params[:force]
-      attached.each do |atttached_atomes|
-        # alert "attached : #{attached}"
-        delete_recursive(atttached_atomes, true)
       end
-      touch(:remove)
-      render(:delete, params)
-      # alert "Universe : #{Universe.atomes[@aid]}"
-      # alert "length = #{Universe.atomes.length}"
-      Universe.delete(@aid)
-      # alert "Universe : #{Universe.atomes.length}"
 
+    elsif Universe.atome_list.include?(params)
+      # we check if the params passed is an atome to treat it in a different way
+      puts "write code here : #{apply} , #{attached}"
     else
-      # the machine try to find the sub particle id and remove it eg a.delete(monitor: :my_monitor) remove the monitor
-      # with id my_monitor
-      params.each do |param, value|
-        atome[param][value] = nil
+      send(params, 0) unless params == :id
+    end
+    touch(:remove)
+    drag(false)
+    drop(false)
+    on(false)
+    keyboard(false)
+    resize(:remove)
+    overflow(:remove)
+
+    render(:delete, params)
+    Universe.delete(@aid)
+
+    exclusions = %i[@history @renderers @type @tag @html]
+
+    instance_variables.each do |i_var|
+      unless exclusions.include?(i_var)
+        instance_variable_set(i_var, nil)
       end
     end
 
-  elsif Universe.atome_list.include?(params)
-    # we check if the params passed is an atome to treat it in a different way
-    puts "write code here : #{apply} , #{attached}"
-  else
-    send(params, 0) unless params == :id
+    instance_variable_set('@renderers', [])
   end
+
 end
 
 new({ particle: :clear, category: :utility, type: :boolean })
@@ -226,7 +234,7 @@ new({ particle: :duplicate, category: :utility, type: :string, store: false }) d
   end
   params[:attached] = attached_atomes
   infos_found = infos.dup
-  keys_to_delete = [:history, :callback, :duplicate, :copy, :paste, :touch_code, :html, :attached, :aid]
+  keys_to_delete = %i[history callback duplicate copy paste touch_code html attached aid]
   keys_to_delete.each { |key| infos_found.delete(key) }
   new_atome_id = "#{@id}_copy_#{copy_number}".to_sym
   infos_found[:id] = new_atome_id

data/lib/atome/utilities/utilities.rb

@@ -117,6 +117,11 @@ class Atome
 
   @initialized = {}
 
+
+    def recursive(_val)
+      #dummy method
+    end
+
   def help(particle, &doc)
     if doc
       Universe.set_help(particle, &doc)
@@ -149,7 +154,6 @@ class Atome
   def collapse(new_atome)
     initialized_procs = []
     initialized = Atome.initialized
-
     new_atome.each do |element, value|
       send(element, value)
       initialized_proc = initialized[element]

data/lib/atome/version.rb

@@ -2,5 +2,5 @@
 
 #  return atome version
 class Atome
-  VERSION = '0.5.7.3.3'
+  VERSION = '0.5.7.3.5'
 end

data/lib/renderers/html/html.rb

@@ -1303,6 +1303,7 @@ class HTML
       proc_content = @touch_tap.call(event) if event_validation(@touch_tap)
       if proc_content.instance_of? Hash
         proc_content.each do |k, v|
+          # alert "(#{@original_atome.id}, #{k}, #{v}, #{_option})"
           @original_atome.send(k, v)
         end
       end
@@ -1329,8 +1330,6 @@ class HTML
         end
       end
     end
-
-    # end
   end
 
   def touch_double(_option)

data/lib/renderers/renderer.rb

@@ -6,7 +6,7 @@ class Atome
 
   def render(element, params, &user_proc)
 
-    render_engines = @renderers
+    render_engines = @renderers || []
     render_engines.each do |render_engine|
       # in case we found an exception the method call will have the form, example for color top  : html_color_top
       exception_found = "#{Universe.get_atomes_specificities[type][element]}"

data/vendor/assets/application/examples/scheduler.rb

@@ -1,131 +1,5 @@
 # frozen_string_literal: true
 
-require 'time'
-# Helper method to store task configuration in localStorage
-def store_task(name, config)
-  JS.global[:localStorage].setItem(name, config.to_json)
-end
-
-# Helper method to retrieve task configuration from localStorage
-def retrieve_task(name)
-  config = JS.global[:localStorage].getItem(name)
-  config.nil? ? nil : JSON.parse(config)
-end
-
-# Helper method to retrieve all tasks from localStorage
-def retrieve_all_tasks
-  tasks = []
-  local_storage = JS.global[:localStorage]
-  if Atome::host == "web-opal"
-    local_storage.each do |key|
-      value = local_storage.getItem(key)
-      if value
-        value= JSON.parse(value)
-        tasks << { name: key, config:value }
-      end
-    end
-  else
-    length = local_storage[:length].to_i
-    length.times do |i|
-      key = local_storage.call(:key, i)
-      value = local_storage.call(:getItem, key)
-      tasks << { name: key, config: JSON.parse(value.to_s) } if value
-    end
-  end
-  tasks
-end
-
-# Helper method to schedule a task
-def schedule_task(name, years, month, day, hours, minutes, seconds, recurrence: nil, &block)
-  target_time = Time.new(years, month, day, hours, minutes, seconds)
-  now = Time.now
-
-  if target_time < now
-    schedule_recurrence(name, target_time, recurrence, &block)
-  else
-    seconds_until_target = target_time - now
-    wait_task = wait(seconds_until_target) do
-      block.call
-      schedule_recurrence(name, target_time, recurrence, &block) if recurrence
-    end
-    store_task(name, { wait: wait_task, target_time: target_time, recurrence: recurrence })
-  end
-end
-
-def schedule_recurrence(name, target_time, recurrence, &block)
-  now = Time.now
-  next_time = target_time
-
-  case recurrence
-  when :yearly
-    next_time += 365 * 24 * 60 * 60 while next_time <= now
-  when :monthly
-    next_time = next_time >> 1 while next_time <= now
-  when :weekly
-    next_time += 7 * 24 * 60 * 60 while next_time <= now
-  when :daily
-    next_time += 24 * 60 * 60 while next_time <= now
-  when :hourly
-    next_time += 60 * 60 while next_time <= now
-  when :minutely
-    next_time += 60 while next_time <= now
-  when :secondly
-    next_time += 1 while next_time <= now
-  when Hash
-    if recurrence[:weekly]
-      wday = recurrence[:weekly]
-      next_time += 7 * 24 * 60 * 60 while next_time <= now
-      next_time += 24 * 60 * 60 until next_time.wday == wday
-    elsif recurrence[:monthly]
-      week_of_month = recurrence[:monthly][:week]
-      wday = recurrence[:monthly][:wday]
-      while next_time <= now
-        next_month = next_time >> 1
-        next_time = Time.new(next_month.year, next_month.month, 1, target_time.hour, target_time.min, target_time.sec)
-        next_time += 24 * 60 * 60 while next_time.wday != wday
-        next_time += (week_of_month - 1) * 7 * 24 * 60 * 60
-      end
-    end
-  else
-    puts "Invalid recurrence option"
-    return
-  end
-
-  seconds_until_next = next_time - Time.now
-  wait_task = wait(seconds_until_next) do
-    block.call
-    schedule_recurrence(name, next_time, recurrence, &block)
-  end
-  store_task(name, { wait: wait_task, target_time: next_time, recurrence: recurrence })
-end
-
-# Helper method to stop a scheduled task
-def stop_task(name)
-  task_config = retrieve_task(name)
-  return unless task_config
-
-  stop({ wait: task_config['wait'] })
-  JS.global[:localStorage].removeItem(name)
-end
-
-# Method to relaunch all tasks from localStorage
-def relaunch_all_tasks
-  tasks = retrieve_all_tasks
-
-  tasks.each do |task|
-    name = task[:name]
-    config = task[:config]
-    target_time_found = config['target_time']
-    target_time = Time.parse(target_time_found)
-    recurrence_found = config['recurrence']
-    next unless recurrence_found
-    recurrence = config['recurrence'].is_a?(Hash) ? config['recurrence'].transform_keys(&:to_sym) : config['recurrence'].to_sym
-    puts "found : #{name}, #{target_time.year}, #{target_time.month}, #{target_time.day}, #{target_time.hour}, #{target_time.min}, #{target_time.sec}, recurrence: #{recurrence}"
-    schedule_task(name, target_time.year, target_time.month, target_time.day, target_time.hour, target_time.min, target_time.sec, recurrence: recurrence) do
-      puts "Relaunched task #{name}"
-    end
-  end
-end
 
 ######## check
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: atome
 version: !ruby/object:Gem::Version
-  version: 0.5.7.3.3
+  version: 0.5.7.3.5
 platform: ruby
 authors:
 - Jean-Eric Godard
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-06-09 00:00:00.000000000 Z
+date: 2024-06-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: eventmachine