atome 0.5.7.5.9 → 0.5.7.6.5

data/exe/atome

@@ -116,18 +116,18 @@ def build_opal_application(_source, destination, project_name)
   end
   process_directories("#{destination}/#{project_name}/application", "#{destination}/#{project_name}/tmp/application")
 
-  opal_compiler_content = <<STR
-# frozen_string_literal: true
-
-require 'opal'
-application_js = "../../src/js/application.js"
-builder = Opal::Builder.new
-builder.append_paths("./")
-application_content = builder.build("./index.rb").to_s
-File.open(application_js, 'w') do |f|
-  f.puts application_content
-end
-STR
+  opal_compiler_content = <<~STR
+    # frozen_string_literal: true
+
+    require 'opal'
+    application_js = "../../src/js/application.js"
+    builder = Opal::Builder.new
+    builder.append_paths("./")
+    application_content = builder.build("./index.rb").to_s
+    File.open(application_js, 'w') do |f|
+      f.puts application_content
+    end
+  STR
 
   # we create an hidden file
   opal_compiler = "#{destination}/#{project_name}/tmp/application/.opal_compiler.rb"
@@ -377,6 +377,21 @@ def build_for_wasm(source, destination, project_name, wasi_file)
   wasm_initialize(source, destination, project_name, wasi_file)
 end
 
+def build_for_ios(destination, mode = :dev)
+  # dev or build
+  if RbConfig::CONFIG['host_os'] =~ /mswin|mingw|cygwin/
+    # code to exec with Windows
+    `cd /d #{destination} && cargo tauri ios init  --verbose && cargo tauri ios #{mode} -- --log-level=debug`
+  elsif RbConfig::CONFIG['host_os'] =~ /darwin|mac os/
+    # code to exec with MacOS
+    `cd #{destination};cargo tauri ios init  --verbose;cargo tauri ios #{mode} -- --log-level=debug`
+  else
+    # code to exec with Unix/Linux
+    `cd #{destination};cargo tauri ios init  --verbose;cargo tauri ios #{mode} -- --log-level=debug`
+  end
+
+end
+
 def build_for_osx(destination, mode = :dev)
   # dev or build
   if RbConfig::CONFIG['host_os'] =~ /mswin|mingw|cygwin/
@@ -424,22 +439,22 @@ end
 def build_for_opal_server(destination, project_name, port, production, run_server = true)
   if production
     prod = '--env production'
-    ru_file = <<STR
-require 'roda'
-require './atome_server.rb'
-run App.app.freeze
-STR
+    ru_file = <<~STR
+      require 'roda'
+      require './atome_server.rb'
+      run App.app.freeze
+    STR
   else
-    ru_file = <<STR
-require 'roda'
-require 'rack/unreloader'
-Unreloader = Rack::Unreloader.new(subclasses: %w[Roda]) { App }
-Unreloader.require './atome_server.rb'
-run Unreloader
-require './atome_server.rb'
-STR
-  end
-  if run_server ==true
+    ru_file = <<~STR
+      require 'roda'
+      require 'rack/unreloader'
+      Unreloader = Rack::Unreloader.new(subclasses: %w[Roda]) { App }
+      Unreloader.require './atome_server.rb'
+      run Unreloader
+      require './atome_server.rb'
+    STR
+  end
+  if run_server == true
     init_server(destination, project_name, port, prod, ru_file)
   end
 
@@ -448,22 +463,22 @@ end
 def build_for_wasm_server(destination, project_name, port, production, run_server = true)
   if production
     prod = '--env production'
-    ru_file = <<STR
-require 'roda'
-require './atome_server_wasm.rb'
-run App.app.freeze
-STR
+    ru_file = <<~STR
+      require 'roda'
+      require './atome_server_wasm.rb'
+      run App.app.freeze
+    STR
   else
-    ru_file = <<STR
-require 'roda'
-require 'rack/unreloader'
-Unreloader = Rack::Unreloader.new(subclasses: %w[Roda]) { App }
-Unreloader.require './atome_server_wasm.rb'
-run Unreloader
-require './atome_server.rb'
-STR
-  end
-  if run_server ==true
+    ru_file = <<~STR
+      require 'roda'
+      require 'rack/unreloader'
+      Unreloader = Rack::Unreloader.new(subclasses: %w[Roda]) { App }
+      Unreloader.require './atome_server_wasm.rb'
+      run Unreloader
+      require './atome_server.rb'
+    STR
+  end
+  if run_server == true
     init_server(destination, project_name, port, prod, ru_file)
   end
   # if RbConfig::CONFIG['host_os'] =~ /mswin|mingw|cygwin/
@@ -599,20 +614,20 @@ if ARGV.include?('update')
   # if local_gem_spec.nil?
   #   puts :case1
   #   puts " #{gem_name} gem  is not install will install from distant server"
-    system("gem update #{gem_name}")
+  system("gem update #{gem_name}")
   # else
   #   puts :case2
 
-    available_versions = Gem::Specification.find_all_by_name(gem_name).map(&:version)
+  available_versions = Gem::Specification.find_all_by_name(gem_name).map(&:version)
 
-    latest_version = available_versions.max
+  latest_version = available_versions.max
 
-    if latest_version > local_gem_spec.version
-      puts "update availlable: #{local_gem_spec.version} -> #{latest_version}"
-      system("gem update #{gem_name}")
-    else
-      puts "No update necessary '#{gem_name}'. current version : #{local_gem_spec.version}"
-    end
+  if latest_version > local_gem_spec.version
+    puts "update availlable: #{local_gem_spec.version} -> #{latest_version}"
+    system("gem update #{gem_name}")
+  else
+    puts "No update necessary '#{gem_name}'. current version : #{local_gem_spec.version}"
+  end
   # end
 
   ########
@@ -661,7 +676,7 @@ src/favicon.ico src/index_wasm.html src/index_opal.html src/index_server.html sr
   # now we get the version of the atome gem
   gem_name = 'atome'
   local_gem_spec = Gem::Specification.find_by_name(gem_name) rescue nil
-  latest_version=local_gem_spec.version
+  latest_version = local_gem_spec.version
   puts "#{gem_name} #{latest_version} is now installed "
 
 end
@@ -674,12 +689,12 @@ if ARGV.include?('run')
   case ARGV[1]
   when 'opal'
 
-    guard_content = <<STR
-guard 'rake', first_match: true, :task => 'build_opal' do
-  watch(%r{^server.+\.rb})
-  watch(%r{^application.+\.rb})
-end
-STR
+    guard_content = <<~STR
+      guard 'rake', first_match: true, :task => 'build_opal' do
+        watch(%r{^server.+\.rb})
+        watch(%r{^application.+\.rb})
+      end
+    STR
 
     File.open("./#{location}/Guardfile", "w") do |f|
       f.write(guard_content)
@@ -689,12 +704,12 @@ STR
       `guard`
     end
   when 'wasm' # osx wasi
-    guard_content = <<STR
-guard 'rake', first_match: true, :task => 'build_wasm' do
-  watch(%r{^server.+\.rb})
-  watch(%r{^application.+\.rb})
-end
-STR
+    guard_content = <<~STR
+      guard 'rake', first_match: true, :task => 'build_wasm' do
+        watch(%r{^server.+\.rb})
+        watch(%r{^application.+\.rb})
+      end
+    STR
 
     File.open("./#{location}/Guardfile", "w") do |f|
       f.write(guard_content)
@@ -704,13 +719,13 @@ STR
       `guard`
     end
   when 'server'
-    guard_content = <<STR
-guard 'rake', first_match: true, :task => 'build_server' do
-  watch(%r{^server.+\.rb})
-  watch(%r{^application.+\.rb})
-end
-
-STR
+    guard_content = <<~STR
+      guard 'rake', first_match: true, :task => 'build_server' do
+        watch(%r{^server.+\.rb})
+        watch(%r{^application.+\.rb})
+      end
+      
+    STR
 
     File.open("./#{location}/Guardfile", "w") do |f|
       f.write(guard_content)
@@ -892,6 +907,13 @@ else
     build_for_osx(destination)
   end
 
+  if ARGV.include?('ios')
+    puts 'building ios'
+    wasi_file = 'wasi-vfs-osx_arm'
+    wasm_common(source, destination, project_name, wasi_file, :tauri)
+    build_for_ios(destination)
+  end
+
   puts 'building Android' if ARGV.include?('android')
   puts 'building iOS' if ARGV.include?('ios')
   puts 'building Windows' if ARGV.include?('windows')

data/lib/atome/extensions/atome.rb

@@ -69,6 +69,25 @@ end
 class Object
   include ObjectExtension
 
+
+  def js_func(function_name, *params)
+    args = params.map do |param|
+      case param
+      when String
+        "'#{param}'"
+      when TrueClass, FalseClass, Numeric
+        param.to_s
+      else
+        raise ArgumentError, "Unsupported parameter type: #{param.class}"
+      end
+    end.join(", ")
+    JS.eval("#{function_name}(#{args})")
+  end
+
+  def js_class(class_name)
+    JS.eval("return new #{class_name}()")
+  end
+
   def refresh
     grab(:view).retrieve do |child|
       child.refresh
@@ -83,7 +102,6 @@ class Object
     string.length > max_length ? string.slice(0, max_length) + '.' : string
   end
 
-
   def remove_key_pair_but(hash, keys_to_keep)
     hash.dup.delete_if do |key, value|
       key.is_a?(Integer) && key.even? && !keys_to_keep.include?(key)
@@ -139,12 +157,12 @@ class Object
   def hook(a_id)
     a_id = a_id.to_sym
     # Universe.atomes[a_id]
-    atome_get=''
+    atome_get = ''
     Universe.atomes.each do |aid_f, atome|
       # alert "1 #{atome}"
 
-      if atome.id== a_id
-        atome_get= atome
+      if atome.id == a_id
+        atome_get = atome
         # alert "2 #{atome}"
       end
       # alert "3 #{atome_get}"
@@ -165,7 +183,7 @@ class Object
   # the method below generate Atome method creation at Object level
   def atome_method_for_object(element)
 
-    Object.define_method element do |params=nil, &user_proc|
+    Object.define_method element do |params = nil, &user_proc|
       default_parent = Essentials.default_params[element][:attach] || :view
       grab(default_parent).send(element, params, &user_proc)
     end
@@ -339,7 +357,7 @@ class Object
             oldLog.apply(console, arguments);
           };
         }());
-JS
+      JS
 
       console_clear = console_top.circle({ id: :console_clear, color: :red, top: 3, left: 3, width: 19, height: 19 })
       console_clear.touch(true) do
@@ -461,57 +479,134 @@ JS
     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)
+  #       # puts "#{current_atome}, #{atome_id}, left:  #{current_atome.left}, ratio: #{ratio}"
+  #       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
+  # 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
+
+    found_area_used(atomes_found) do |result|
+      total_width = result[:max][:x] - result[:min][:x]
+      total_height = result[:max][:y] - result[:min][:y]
+
+      ratio = if axis == :x
+                target_size / total_width
+              else
+                target_size / total_height
+              end
+
       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)
+
+        left = current_atome.left || 0
+        top = current_atome.top || 0
+
+        current_atome.left(left * ratio)
+        current_atome.top(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
   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
+  # 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 found_area_used(ids, &block)
+
+    check_interval = 0.1
+
+    wait(check_interval) do
+      all_ready = ids.all? do |id|
+        atome = grab(id)
+        width = atome.to_px(:width).to_f rescue 0
+        height = atome.to_px(:height).to_f rescue 0
+        width > 0 && height > 0
+      end
+      if all_ready
+        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].to_f rescue 0
+          y = atome.compute({ particle: :top })[:value].to_f rescue 0
+          width = atome.to_px(:width).to_f rescue 0
+          height = atome.to_px(:height).to_f rescue 0
+
+          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
+
+        result = { min: { x: min_x, y: min_y }, max: { x: max_x, y: max_y } }
+        block.call(result) if block_given?
+      else
+        found_area_used(ids, &block)
+      end
     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)
@@ -593,11 +688,11 @@ JS
     end
   end
 
-  def above(item, margin = 6, ref=grab(:view))
+  def above(item, margin = 6, ref = grab(:view))
     # FIXME above is broken when using % in margin
     unless margin.is_a?(Numeric)
-      item_height= ref.to_px(:height)
-      margin=   (margin.to_f*item_height)/100
+      item_height = ref.to_px(:height)
+      margin = (margin.to_f * item_height) / 100
     end
     pos = item.to_px(:bottom) + item.height + margin
     item.top(:auto)
@@ -608,10 +703,10 @@ JS
     end
   end
 
-  def below(item, margin = 6, ref=grab(:view))
+  def below(item, margin = 6, ref = grab(:view))
     unless margin.is_a?(Numeric)
-      item_height= ref.to_px(:height)
-      margin=   (margin.to_f*item_height)/100
+      item_height = ref.to_px(:height)
+      margin = (margin.to_f * item_height) / 100
     end
     pos = item.to_px(:top) + item.to_px(:height) + margin
     if item.display == :none
@@ -622,10 +717,10 @@ JS
 
   end
 
-  def after(item, margin = 6, ref=grab(:view))
+  def after(item, margin = 6, ref = grab(:view))
     unless margin.is_a?(Numeric)
-      item_width= ref.to_px(:width)
-      margin=   (margin.to_f*item_width)/100
+      item_width = ref.to_px(:width)
+      margin = (margin.to_f * item_width) / 100
     end
     left_f = if item.left.instance_of?(Integer)
                item.left
@@ -646,10 +741,10 @@ JS
     end
   end
 
-  def before(item, margin = 6, ref=grab(:view))
+  def before(item, margin = 6, ref = grab(:view))
     unless margin.is_a?(Numeric)
-      item_width= ref.to_px(:width)
-      margin=   (margin.to_f*item_width)/100
+      item_width = ref.to_px(:width)
+      margin = (margin.to_f * item_width) / 100
     end
     pos = item.to_px(:right) + item.width + margin
     if item.display == :none
@@ -826,8 +921,4 @@ class CssProxy
     bloc.call(parsed)
   end
 
-
-
-
-
 end

data/lib/atome/genesis/atomes.rb

@@ -125,7 +125,7 @@ new({ atome: :table })
 new({ atome: :atomized, type: :hash })
 new({ atome: :map, type: :hash })
 new({atome: :vr, type: :hash})
-
+new({atome: :draw})
 
 
 

data/lib/atome/genesis/genesis.rb

@@ -84,7 +84,7 @@ class Genesis
           # TODO: try to optimise and find a better way wo we can remove the condition below
           if @type == :group && !%i[type id collect layout].include?(element)
             collect.each do |collected_found|
-              grab(collected_found).send(element, params, &user_proc)
+              grab(collected_found)&.send(element, params, &user_proc)
             end
           end
 

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

@@ -38,11 +38,11 @@ new({ particle: :fasten, category: :hierarchy, type: :string, render: false }) d
   children_ids
 end
 
-new({ sanitizer: :fasten }) do |children_ids|
+new({ sanitizer: :fasten,category: :hierarchy, type: :string }) do |children_ids|
   children_ids
 end
 
-new({ particle: :unfasten }) do |params|
+new({ particle: :unfasten,category: :hierarchy, type: :string  }) do |params|
   params = fasten if params == :all
   dup_params = params.dup
   dup_params.each do |param|
@@ -60,7 +60,7 @@ new({ particle: :unfasten }) do |params|
   end
 end
 
-new({ particle: :detach }) do |params|
+new({ particle: :detach,category: :hierarchy, type: :string  }) do |params|
   grab(params).unfasten([id])
 end
 

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

@@ -63,3 +63,4 @@ new({ particle: :alien, category: :identity, type: :string }) # special particel
 
 new({ particle: :email, category: :identity, type: :string })
 
+new({ particle: :cells , category: :identity, type: :string })

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

@@ -109,7 +109,7 @@ new({ particle: :fill, category: :material, type: :array })
 
 new({ particle: :opacity, category: :material, type: :int })
 
-new({ particle: :exchange }) do |params, &bloc|
+new({ particle: :exchange, category: :material, type: :array }) do |params, &bloc|
   params.each_key do |part_f|
     part_to_remove = send(part_f)
     if part_to_remove.instance_of?(Array)

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

@@ -128,13 +128,13 @@ new({ particle: :sort, category: :property, type: :int }) do |params|
   params
 end
 
-new({ particle: :inside, render: false })
+new({ particle: :inside, render: false,category: :property, type: :string  })
 new({ initialized: :inside }) do |params, &user_proc|
   render(:inside, params, &user_proc)
 end
-new({ particle: :margin })
+new({ particle: :margin,category: :property, type: :int  })
 
-new({ particle: :value }) do |val|
+new({ particle: :value ,category: :property, type: :string }) do |val|
   pro_f = behavior[:value]
   instance_exec(val, &pro_f) if pro_f.is_a?(Proc)
   val
@@ -146,7 +146,7 @@ new({ particle: :orientation, type: :symbol, category: :property })
 
 new({ particle: :align, type: :symbol, category: :property })
 
-new({ particle: :actor, store: false }) do |params|
+new({ particle: :actor, store: false, category: :property , type: :string }) do |params|
   @actor ||= {}
   if params[:remove]
     params[:remove].each do |atome_id, role|
@@ -161,7 +161,7 @@ new({ particle: :actor, store: false }) do |params|
   end
 end
 
-new({ particle: :role, store: false }) do |params|
+new({ particle: :role, store: false, category: :property , type: :string }) do |params|
   if params.instance_of? Hash
     if params.keys[0] == :remove
       @role.delete(params.values[0])

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

@@ -107,27 +107,27 @@ new ({ particle: :increment, category: :spatial, type: :hash }) do |params|
   end
 end
 
-new({particle: :longitude}) do |params, _user_proc|
+new({particle: :longitude, category: :spatial, type: :int}) do |params, _user_proc|
   render(:map, {longitude: params })
   params
 end
 
-new({particle: :latitude}) do |params, _user_proc|
+new({particle: :latitude, category: :spatial, type: :int}) do |params, _user_proc|
   render(:map, {latitude: params })
   params
 end
 
-new({particle: :location}) do |params, _user_proc|
+new({particle: :location, category: :spatial, type: :hash}) do |params, _user_proc|
   render(:map, params)
   params
 end
 
-new({particle: :zoom, specific: :map}) do |params, _user_proc|
+new({particle: :zoom, specific: :map, category: :spatial, type: :int}) do |params, _user_proc|
   render(:map_zoom, params)
   params
 end
 
-new({particle: :pan, specific: :map}) do |params, _user_proc|
+new({particle: :pan, specific: :map, category: :spatial, type: :int}) do |params, _user_proc|
   render(:map_pan, params)
   params
 end