atome 0.5.7.0.3 → 0.3191

data/lib/renderers/html/identity.rb

@@ -1,104 +0,0 @@
-# frozen_string_literal: true
-
-new({ renderer: :html, method: :id, type: :string })
-
-new({ method: :type, type: :string, renderer: :html }) do |_value, _user_proc|
-  html.shape(@id)
-end
-
-new({ method: :type, type: :string, renderer: :html, specific: :vector }) do |_value, _user_proc|
-  html.svg(@id)
-end
-
-new({ method: :type, type: :string, renderer: :html, specific: :image }) do |_value, _user_proc|
-  html.image(@id)
-end
-
-new({ method: :type, type: :string, renderer: :html, specific: :video }) do |_value, _user_proc|
-  html.video(@id)
-end
-
-new({ method: :type, type: :string, renderer: :html, specific: :www }) do |_value, _user_proc|
-  html.www(@id)
-end
-
-new({ method: :type, type: :string, renderer: :html, specific: :raw }) do |_value, _user_proc|
-  html.raw(@id)
-end
-
-new({ method: :type, type: :string, specific: :shape, renderer: :html }) do |_value, _user_proc|
-  html.shape(@id)
-end
-
-new({ method: :type, type: :string, specific: :text, renderer: :html }) do |_value, _user_proc|
-  html.text(@id)
-  html.add_class(:text)
-end
-
-new({ method: :type, type: :string, specific: :paint, renderer: :html }) do
-end
-
-new({ method: :type, type: :string, specific: :color, renderer: :html }) do
-end
-
-new({ method: :data, type: :string, specific: :text, renderer: :html }) do |params|
-
-  js[:innerHTML] = if int8[language]
-                     int8[language].to_s
-                   else
-                     params.to_s
-                   end
-end
-
-new({ method: :data, type: :string, specific: :vector, renderer: :html }) do |value|
-  unless value.instance_of? Array
-    value=[value]
-  end
-  html.svg_data(value)
-end
-
-new({ method: :component, type: :hash, specific: :text, renderer: :html }) do |params, _user_proc|
-  params.each do |prop, value|
-    # we send component data directly to the text html renderer
-    send("html_text_#{prop}", value)
-  end
-end
-
-new({ method: :component, type: :hash, specific: :vector, renderer: :html }) do |params, _user_proc|
-  html.update_svg_data(params)
-end
-
-new({ method: :path, type: :string, renderer: :html }) do |value, _user_proc|
-  html.path(value)
-end
-
-new({ method: :path, type: :string, renderer: :html, specific: :image }) do |value, _user_proc|
-  html.path(value)
-end
-
-new({ method: :path, type: :string, renderer: :html, specific: :www }) do |value, _user_proc|
-  html.path(value)
-end
-
-new({ method: :data, type: :string, renderer: :html, specific: :raw }) do |value, _user_proc|
-  html.raw_data(value)
-end
-
-new({ renderer: :html, method: :category, type: :symbol }) do |category_names|
-  category_names.each do |category_name|
-    html.add_class(category_name)
-  end
-end
-
-new({ method: :data, type: :string, specific: :table, renderer: :html }) do |value, _user_proc|
-  html.table(value)
-end
-
-new({ method: :type, type: :hash, specific: :atomized, renderer: :html }) do |value, _user_proc|
-  html.atomized(value)
-end
-
-
-new({ renderer: :html, method: :selected, specific: :text }) do |value, &bloc|
-  html.select_text(value)
-end

data/lib/renderers/html/index.rb

@@ -1,19 +0,0 @@
-# frozen_string_literal: true
-
-# require without relative is needed when using Opal
-
-require 'renderers/html/atome'
-require 'renderers/html/atome_html'
-require 'renderers/html/communication'
-require 'renderers/html/effect'
-require 'renderers/html/event'
-require 'renderers/html/geometry'
-require 'renderers/html/hierarchy'
-require 'renderers/html/html'
-require 'renderers/html/identity'
-require 'renderers/html/material'
-require 'renderers/html/property'
-require 'renderers/html//security'
-require 'renderers/html/spatial'
-require 'renderers/html//time'
-require 'renderers/html/utility'

data/lib/renderers/html/index_relative.rb

@@ -1,20 +0,0 @@
-
-# frozen_string_literal: true
-
-# relative is needed when using ruby wasm
-
-require_relative './atome'
-require_relative './atome_html'
-require_relative './communication'
-require_relative './effect'
-require_relative './event'
-require_relative './geometry'
-require_relative './hierarchy'
-require_relative './html'
-require_relative './identity'
-require_relative './material'
-require_relative './property'
-require_relative './/security'
-require_relative './spatial'
-require_relative './/time'
-require_relative './utility'

data/lib/renderers/html/material.rb

@@ -1,88 +0,0 @@
-# frozen_string_literal: true
-
-new({ method: :overflow, renderer: :html, type: :string }) do |params, bloc|
-  html.overflow(params, bloc)
-end
-
-new({ method: :gradient, renderer: :html, type: :hash })
-
-new({ method: :remove, renderer: :html, type: :string }) do |object_id_to_remove, bloc|
-
-  if object_id_to_remove.instance_of? Hash
-    object_id_to_remove.each do |particle, value|
-      case particle
-      when :category
-        html.remove_class(value)
-      else
-        atome_ids_found = send(object_id_to_remove[:all])
-        atome_ids_found.each do |atome_id|
-          remove(atome_id)
-        end
-      end
-    end
-  else
-    atome_to_remove = grab(object_id_to_remove)
-    atome_type_found = atome_to_remove.type
-    case atome_type_found
-    when :color
-      if color == []
-        # we remove the last color set
-        html.style(:backgroundColor, :black)
-      else
-        html.style(:background, '')
-        html.style(:backgroundColor, '')
-        @apply.delete(object_id_to_remove)
-        apply(@apply)
-      end
-    when :shadow
-      html.style("boxShadow", 'none')
-      html.style("filter", 'none')
-      @apply.delete(object_id_to_remove)
-      apply(@apply)
-    when :paint
-      atome_to_remove = grab(object_id_to_remove)
-      atome_to_remove.gradient.each do |color_id|
-        html.style(:background, '')
-        html.style(:backgroundColor, '')
-        @apply.delete(color_id)
-      end
-      @apply.delete(object_id_to_remove)
-      apply(@apply)
-    end
-  end
-end
-
-# new({ method: :border, type: :hash, renderer: :html }) do |value, _user_proc|
-#   thickness = value[:thickness] || 5
-#   type = value[:pattern] || :solid
-#
-#   if value[:color].instance_of? Atome
-#     color_found = value[:color]
-#   else
-#     color_found = grab('black_matter').color(value[:color])
-#   end
-#
-#   red = color_found.red * 255
-#   green = color_found.green * 255
-#   blue = color_found.blue * 255
-#   alpha = color_found.alpha
-#
-#   html.style(:border, "#{type} #{thickness}px rgba(#{red},#{green},#{blue},#{alpha})")
-# end
-new({ method: :thickness, type: :integer, renderer: :html})
-
-# end
-new({ method: :pattern, type: :integer, renderer: :html})
-
-new({ method: :fill, renderer: :html }) do |params|
-  html.fill(params)
-end
-
-new({ method: :opacity, type: :integer, renderer: :html}) do |value|
-  # html.opacity(value)
-  html.style('opacity',value)
-end
-
-new({ method: :visual, type: :string, renderer: :html, specific: :text }) do |value, _user_proc|
-    html.style('fontFamily', value)
-end

data/lib/renderers/html/property.rb

@@ -1,52 +0,0 @@
-# frozen_string_literal: true
-
-new({ renderer: :html, method: :diffusion, type: :string })
-
-new({ method: :red, type: :integer, specific: :color, renderer: :html }) do |value, _user_proc|
-end
-
-new({ method: :green, type: :integer, specific: :color, renderer: :html }) do |value, _user_proc|
-end
-
-new({ method: :blue, type: :integer, specific: :color, renderer: :html }) do |value, _user_proc|
-end
-
-new({ method: :alpha, type: :integer, specific: :color, renderer: :html }) do |value, _user_proc|
-end
-
-new({ renderer: :html, method: :diffusion, type: :string })
-
-# edit
-new({ renderer: :html, method: :edit }) do |params|
-  html.attr(:contenteditable, params)
-  html.update_data(params)
-end
-
-
-new({ method: :clean, renderer: :html, type: :hash }) do |params|
-  html.table_clean(params)
-end
-
-new({ method: :insert, renderer: :html, type: :hash }) do |params|
-  html.table_insert(params)
-end
-
-new({ method: :remove, renderer: :html, type: :hash }) do |params|
-  # alert "===> #{params}"
-  # html.table_remove(params)
-  html.remove(params)
-end
-
-new({ method: :sort, renderer: :html, type: :hash }) do |params|
-  html.refresh_table(params)
-end
-
-new({ method: :inside, renderer: :html }) do |params|
-  if params
-    affect.each do |at_found|
-      grab(at_found).html.style("box-sizing", 'border-box')
-    end
-  else
-    html.style("boxSizing", ' content-box')
-  end
-end

data/lib/renderers/html/security.rb

@@ -1 +0,0 @@
-# frozen_string_literal: true

data/lib/renderers/html/spatial.rb

@@ -1,75 +0,0 @@
-# frozen_string_literal: true
-
-new({ method: :left, type: :integer, renderer: :html }) do |params|
-  unit = @unit[:left] || :px if params.is_a? Numeric
-  js[:style][:left] = "#{params}#{unit}"
-end
-
-new({ method: :top, type: :integer, renderer: :html }) do |params|
-  unit = @unit[:top] || :px if params.is_a? Numeric
-  js[:style][:top] = "#{params}#{unit}"
-end
-
-new({ method: :bottom, type: :integer, renderer: :html }) do |params|
-  unit = @unit[:bottom] || :px if params.is_a? Numeric
-  js[:style][:bottom] = "#{params}#{unit}"
-end
-
-new({ method: :right, type: :integer, renderer: :html }) do |params|
-  unit = @unit[:right] || :px if params.is_a? Numeric
-
-  js[:style][:right] = "#{params}#{unit}"
-end
-
-new({ method: :top, type: :integer, renderer: :html, specific: :shadow }) do
-  # now we refresh if needed for dynamic refresh od affected atomes
-  affect(affect)
-end
-
-# new({ method: :top, type: :integer, renderer: :html, specific: :text }) do |params|
-#   unit = @unit[:left] || :px
-#   html.style(:top,  "#{params}#{unit}"
-# end
-#
-# new({ method: :bottom, type: :integer, renderer: :html, specific: :text }) do |params|
-#   html.style(:bottom,  "#{params}#{unit}")
-# end
-
-new({ method: :left, type: :integer, specific: :color, renderer: :html })
-
-new({ method: :left, type: :integer, renderer: :html, specific: :shadow }) do
-  # now we refresh if needed for dynamic refresh od affected atomes
-  affect(affect)
-end
-
-new({ method: :top, type: :integer, specific: :color, renderer: :html })
-
-new({ method: :rotate, type: :integer, renderer: :html }) do |params|
-  html.transform(:rotate, params)
-end
-
-new({ method: :rotate, type: :integer, renderer: :html, specific: :paint })
-
-new({ renderer: :html, method: :position }) do |params|
-  html.style("position", params)
-end
-
-new({ renderer: :html, method: :depth }) do |params|
-  html.style("z-index", params)
-end
-
-new({ method: :organise, renderer: :html }) do |params|
-  html.style(:gridTemplateColumns, params)
-end
-
-new({ method: :spacing, renderer: :html }) do |params|
-  html.style(:gap, "#{params}px")
-end
-
-new({ method: :display, renderer: :html }) do |params|
-  html.style(:display, params)
-end
-
-new({ renderer: :html, method: :center }) do |params|
-  html.center(params, attach)
-end

data/lib/renderers/html/time.rb

@@ -1 +0,0 @@
-# frozen_string_literal: true

data/lib/renderers/html/utility.rb

@@ -1,170 +0,0 @@
-# frozen_string_literal: true
-
-new({ renderer: :html, method: :web }) do |params, &user_proc|
-  params
-end
-
-new({ renderer: :html, method: :renderers, type: :string })
-new({ renderer: :html, method: :delete, type: :string }) do |params|
-  html.delete(id)
-end
-new({ renderer: :html, method: :hypertext }) do |params|
-  html.hypertext(params)
-end
-new({ renderer: :html, method: :hyperedit }) do |params, usr_proc|
-  html.hyperedit(params, usr_proc)
-end
-new({ renderer: :html, method: :read, type: :string }) do |value, &bloc|
-  html.read(id, value)
-end
-
-new({ renderer: :html, method: :browse, type: :string }) do |value, &bloc|
-  html.browse(id, value)
-end
-
-new({ renderer: :html, method: :terminal, type: :string }) do |value, &bloc|
-  html.terminal(id, value)
-end
-
-new({ renderer: :html, method: :match }) do |params, bloc|
-  case id
-  when :atome || :view
-    result = bloc.call
-    result = { alterations: result }
-    params = params.merge(result)
-    html.match(params)
-  end
-end
-
-new({ renderer: :html, method: :import, type: :blob }) do |_params, bloc|
-
-  if Atome::host == 'web-opal'
-    file_for_opal(@id, bloc) do |file_content|
-      bloc.call(file_content)
-    end
-
-  else
-    # Wasm version
-    def create_file_browser(_options = '', &bloc)
-      div_element = JS.global[:document].getElementById(@id.to_s)
-      input_element = JS.global[:document].createElement("input")
-      input_element[:type] = "file"
-      input_element[:style][:position] = "absolute"
-      input_element[:style][:display] = "none"
-      input_element[:style][:width] = "0px"
-      input_element[:style][:height] = "0px"
-
-      input_element.addEventListener("change") do |native_event|
-        event = Native(native_event)
-        file = event[:target][:files][0]
-        if file
-          puts "file requested: #{file[:name]}"
-          file_reader = JS.global[:FileReader].new
-          file_reader.addEventListener("load") do |load_event|
-            file_content = load_event[:target][:result]
-            Atome.file_handler(@id, file_content, bloc)
-          end
-          file_reader.readAsText(file)
-        end
-      end
-
-      div_element.addEventListener("mousedown") do |event|
-        input_element.click
-      end
-      div_element.appendChild(input_element)
-    end
-
-    create_file_browser(:options) do |file_content|
-      # puts "wasm ===>#{file_content}"
-      bloc.call(file_content)
-    end
-  end
-
-end
-
-new({ method: :compute, type: :hash, renderer: :html }) do |params|
-  element = JS.global[:document].getElementById(@id.to_s)
-  bounding_box = element.getBoundingClientRect()
-
-  top = bounding_box[:top]
-  left = bounding_box[:left]
-  width = bounding_box[:width]
-  height = bounding_box[:height]
-  value_found = case params[:particle]
-                when :left
-                  left.to_f
-                when :top
-                  top.to_f
-                when :width
-                  width.to_f
-                when :height
-                  height.to_f
-                else
-                  nil
-                end
-  @compute[:value] = value_found
-end
-
-new({ renderer: :html, method: :preview }) do |params, user_proc|
-  if params[:id]
-    id_f = params[:id]
-  else
-    id_f = identity_generator
-  end
-  if params[:stop]
-    html.stop_video_preview(id_f)
-  else
-
-    if params[:media] == :video
-      html.video_preview(id_f, true, false)
-    elsif params[:media] == :audio
-      html.video_preview(id_f, false, true)
-    elsif params[:media] == :all
-      html.video_preview(id_f, true, true)
-    else
-      html.video_preview(id_f, true, true)
-    end
-  end
-
-end
-new({ renderer: :html, method: :record }) do |params, user_proc|
-  duration = params[:duration] ||= 1000000
-  media = params[:media] ||= :video
-  mode = params[:mode] ||= :web # web or native
-  name = params[:name] ||= :record
-  path = params[:path] ||= './'
-  data = params[:data] ||= {}
-  stop = params[:stop]
-  if stop
-    if @video_recorder_type == :web || @audio_recorder_type == :web
-      html.stop_media_recorder(id)
-    elsif @video_recorder_type == :native || @audio_recorder_type == :native
-      A.message({ action: :stop_recording, data: params })
-    end
-
-  elsif media == :video
-    type = params[:type] ||= :mp4
-    if mode == :native
-      @video_recorder_type = :native
-      A.message({ action: :record, data: { type: type, duration: duration, name: name, path: path, media: media, data: data } }) do |result|
-        user_proc.call(result)
-      end
-    else
-      @video_recorder_type = :web
-      html.record_video(params)
-    end
-
-  elsif media == :audio
-    type = params[:type] ||= :wav
-    if mode == :native
-      @audio_recorder_type = :native
-      A.message({ action: :record, data: { type: type, duration: duration, name: name, path: path, media: media, data: data } }) do |result|
-        user_proc.call(result)
-      end
-    else
-      @audio_recorder_type = :web
-      html.record_audio(params)
-    end
-  end
-
-end

data/lib/renderers/renderer.rb

@@ -1,16 +0,0 @@
-# frozen_string_literal: true
-
-# Rendering method here
-class Atome
-  # private
-
-  def render(element, params, &user_proc)
-
-    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]}"
-      send("#{render_engine}_#{exception_found}#{element}", params, &user_proc)
-    end
-  end
-end

data/lib/renderers/server/index.rb

@@ -1,4 +0,0 @@
-# frozen_string_literal: true
-
-# require without relative is needed when using Opal
-require 'renderers/server/utility'

data/lib/renderers/server/index_relative.rb

@@ -1,4 +0,0 @@
-# frozen_string_literal: true
-
-# relative is needed when using ruby wasm
-require_relative 'utility'

data/lib/renderers/server/utility.rb

@@ -1,4 +0,0 @@
-# frozen_string_literal: true
-
-Genesis.build_render(:server_schedule)
-Genesis.build_render(:server_reader)

data/sig/atome_js.rbs

@@ -1 +0,0 @@
-ATOME_JS: untyped

data/sig/batch.rbs

@@ -1,7 +0,0 @@
-class Batch
-  @data: untyped
-
-  def dispatch: -> untyped
-
-  def each: -> untyped
-end

data/sig/browser_helper.rbs

@@ -1,14 +0,0 @@
-module BrowserHelper
-  @enter_action_proc: untyped
-  @leave_action_proc: untyped
-
-  def self.anim_convertor: -> untyped
-
-  def self.anim_value_analysis: -> untyped
-
-  def self.browser_over_enter: -> untyped
-
-  def self.browser_over_leave: -> untyped
-
-  def self.send_anim_to_js: -> untyped
-end

data/sig/essentials.rbs

@@ -1,11 +0,0 @@
-module Essentials
-  @default_params: untyped
-
-  def self.default_params: -> untyped
-
-  def self.new_default_params: -> untyped
-
-  def add_essential_drm: -> untyped
-
-  def validation: -> untyped
-end

data/sig/genesis.rbs

@@ -1,3 +0,0 @@
-class Genesis
-  def self.generator: -> Atome
-end

data/sig/global_variables.rbs

@@ -1 +0,0 @@
-$current_hovered_element: untyped

data/sig/matrix.rbs

@@ -1,5 +0,0 @@
-module Matrix
-  def cell: -> untyped
-
-  def content: -> untyped
-end

data/sig/object.rbs

@@ -1,7 +0,0 @@
-class Object
-  def atome_method_for_object: -> untyped
-
-  def create_method_at_object_level: -> untyped
-
-  def new: -> untyped
-end

data/sig/universe.rbs

@@ -1,3 +0,0 @@
-class Universe
-  @specificities: untyped
-end

data/src/utilities/host_mode.rb

@@ -1,5 +0,0 @@
-class Atome
-  def self.host
-    "pure_wasm"
-  end
-end

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

@@ -1,8 +0,0 @@
-# frozen_string_literal: true
-
-box({ left: 12, id: :the_first_box })
-c=color({ id: :the_col, blue: 0.21, green: 1 })
-
-wait 1 do
-  c.affect(:the_first_box)
-end

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

@@ -1,10 +0,0 @@
-# frozen_string_literal: true
-
-
-# aid is used to provide an unique and persistent id for any atome
-b=box({ left: 12, id: :the_first_box })
-
-puts " atome aid is : #{b.aid}"
-wait 1 do
-  hook(b.aid).color(:red)
-end

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

@@ -1,13 +0,0 @@
-# frozen_string_literal: true
-
-
-t=text(:hello)
-t.edit(true)
-b=box({left: 99})
-
-b.touch(true) do
-  allow_copy(true)
-  touch_allow(true)
-end
-
-