interfacets 0.1.0 → 0.9.9

data/lib/interfacets/client/channels/audio.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+module Interfacets
+  module Client
+    module Channels
+      class Audio
+        include Channels::Base
+
+        type("interfacets:audio")
+
+        class Builder
+          attr_reader :event, :callbacks
+          attr_accessor :entity
+
+          def initialize
+            @event = {}
+            @callbacks = {}
+          end
+
+          def flush_event
+            @event.tap { @event = {} }
+          end
+
+          def play(sounds, reset_offset: false)
+            event[:type] = "play"
+            event[:payload] ||= { sounds:, resetOffset: reset_offset }
+          end
+
+          def load_audios(audios, &block)
+            id = SecureRandom.uuid
+            @event = {
+              id:,
+              type: "load",
+              payload: audios,
+            }
+            @callbacks[id] = block
+          end
+
+          def request_mic(&block)
+            id = SecureRandom.uuid
+            @callbacks[id] = block
+            @event = {
+              id:,
+              type: "request-mic",
+              payload: {},
+            }
+          end
+
+          def start_recording(&block)
+            id = SecureRandom.uuid
+            @callbacks[id] = block
+            @event = {
+              id:,
+              type: "start-record",
+              payload: {},
+            }
+          end
+
+          def stop_recording(&block)
+            id = SecureRandom.uuid
+            @callbacks[id] = block
+            @event = {
+              id:,
+              type: "stop-record",
+              payload: {},
+            }
+          end
+        end
+
+        def prepare(entity)
+          @builder ||= Builder.new
+        end
+
+        def builder(stream = "default")
+          @builder
+        end
+
+        def handle(event:, entity:, **)
+          return unless [
+            "loaded",
+            "mic-ready",
+            "recording-started",
+            "recording-stopped",
+          ].include?(event.fetch("type"))
+
+          callback_id = event.dig("payload", "id")
+          callback = builder.callbacks.delete(callback_id)
+          if event["payload"].nil? || event["payload"].empty?
+            entity.instance_exec(&callback) if callback
+          elsif callback
+            entity.instance_exec(event.fetch("payload"), &callback)
+          end
+        end
+
+        def result
+          { streams: { default: @builder.flush_event } }
+        end
+      end
+    end
+  end
+end

data/lib/interfacets/client/channels/base.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Interfacets
+  module Client
+    module Channels
+      module Base
+        extend ActiveSupport::Concern
+
+        attr_reader :id
+
+        def initialize(id:)
+          @id = id
+        end
+
+        def type
+          self.class.type
+        end
+
+        class_methods do
+          def type(str = nil)
+            @type = str if str
+            @type
+          end
+        end
+      end
+    end
+  end
+end

data/lib/interfacets/client/channels/page_visibility.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Interfacets
+  module Client
+    module Channels
+      class PageVisibility
+        include Channels::Base
+
+        type("interfacets:page-visibility")
+
+        def configure(facet:); end
+
+        def handle(facet:, event:)
+          facet.visibility_change(event.dig("payload", "state"))
+        end
+
+        def render(_facet); end
+      end
+    end
+  end
+end

data/lib/interfacets/client/channels/react/builder.rb

@@ -0,0 +1,203 @@
+# frozen_string_literal: true
+
+module Interfacets
+  module Client
+    module Channels
+      module React
+        class Builder
+          attr_reader :nodes, :callbacks, :entity
+          def initialize(entity, cache)
+            @entity = entity
+            @nodes = []
+            @callbacks = {}
+            @stack = []
+            @cache = cache
+            @memos = (@cache["Interfacets.Memos"] ||= {})
+          end
+
+          def __reset__
+            @nodes = []
+            @stack = []
+            @memos = (@cache["Interfacets.Memos"] ||= {})
+          end
+
+          def apply(nodes)
+            nodes.each { @nodes << _1 }
+          end
+
+          def capture
+            raise ArgumentError unless block_given?
+
+            original_nodes = @nodes
+            @nodes = []
+            yield
+            captured_nodes = @nodes
+            @nodes = original_nodes
+            captured_nodes
+          end
+
+          def string(val)
+            string_node(val)
+          end
+
+          def str(...)
+            string(...)
+          end
+
+          # Need to override ruby's "p" methods (ie, puts)
+          def p(...)
+            add_node("p", ...)
+          end
+
+          def memo(*keys, on:, &)
+            System.logger.warn("Memo is disabled")
+            return add_node(
+              "React.Fragment",
+              &
+            )
+            memo_key = (
+              ([entity.internal_id] + keys)
+                .map(&:to_json)
+                .join(".")
+            )
+            memo_val = Array(on).map(&:to_json).join(".")
+
+            if @memos.dig(memo_key, :memo_val) == memo_val
+              @nodes << @memos.dig(memo_key, :component)
+            else
+              component = add_node(
+                "Interfacets.Memo",
+                memoKey: memo_key,
+                memoVal: memo_val,
+                &
+              )
+
+              @memos[memo_key] = { memo_val:, component: }
+            end
+          end
+
+          def cache(*keys, &)
+            cache_key = keys.map(&:to_json).join(".")
+            if @cache.key?(cache_key)
+              @nodes << @cache.fetch(cache_key)
+            else
+              @cache[cache_key] = (
+                add_node(
+                  "Interfacets.Cache",
+                  cacheKey: cache_key,
+                  &
+                )
+              )
+            end
+          end
+
+          def safe_html(str)
+            # add_node("React.Fragment", dangerouslySetInnerHTML: { __html: str })
+          end
+
+          def f(id, callback = nil, &block)
+            register_handler(id: id.to_json, callback: callback || block)
+          end
+
+          def prop(path)
+            paths = (
+              if path.is_a?(String)
+                path.split(".")
+              elsif path.is_a?(Symbol)
+                [path.to_s]
+              else
+                path
+              end
+            )
+
+            {
+              type: "interfacets:react-dom:prop",
+              payload: { path: paths },
+            }
+          end
+
+          def function(...)
+            f(...)
+          end
+
+          def respond_to_missing?(...)
+            true
+          end
+
+          def method_missing(meth, *, **, &)
+            raise if meth.to_s == "name"
+            add_node(meth, *, **, &)
+          end
+
+          private
+
+          def string_node(str)
+            @nodes << {
+              type: "interfacets:string-node",
+              attributes: { value: str },
+            }
+          end
+
+          def register_handler(id:, callback:)
+            callbacks[id] = callback
+
+            {
+              type: "interfacets:react-dom:memoized-action",
+              payload: { id: },
+
+            }
+          end
+
+          def add_node(element, str = nil, **attrs)
+            raise("cannot pass both a block and a string") if str && block_given?
+            raise if element == :entity
+
+            new_element = {
+              type: "interfacets:react-dom:element",
+              element:,
+              children: [],
+              attributes: (
+                attrs.transform_values { |value| transform_attr(value) }
+              ),
+            }
+
+            if block_given? || str
+              # recurse
+              original_nodes = @nodes
+              @nodes = new_element[:children]
+              begin
+                yield if block_given?
+                string_node(str) if str
+              ensure
+                @nodes = original_nodes
+              end
+            end
+
+            @nodes << new_element
+            new_element
+          end
+
+          def transform_attr(value)
+            if value.is_a?(Proc)
+              register_handler(
+                id: value.object_id.to_s,
+                callback: value,
+              )
+
+              {
+                type: "interfacets:react-dom:action",
+                payload: { id: value.object_id.to_s },
+              }
+            elsif value.is_a?(Array)
+              value.map { transform_attr(_1) }
+            elsif value.is_a?(Hash)
+              value.transform_values { |k| transform_attr(k) }
+            else
+              value
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/interfacets/client/channels/react/channel.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module Interfacets
+  module Client
+    module Channels
+      module React
+        class Channel
+          include Channels::Base
+
+          type("interfacets:react-dom")
+
+          def prepare(entity)
+            @cache ||= {}
+
+            if entity.internal_entity_id == @builder&.entity&.internal_entity_id
+              # keep all the callbacks we've ever assigned, if its the same entity
+              # should probably prune these? Only need to remember last renders
+              # callbacks?
+              builder.__reset__
+            else
+              @builder = Builder.new(entity, @cache)
+            end
+          end
+
+          def builder(stream = "default")
+            @builder
+          end
+
+          def result
+            @callbacks = builder.callbacks
+
+            {
+              streams: {
+                default: { dom: builder.nodes }
+              }
+            }
+          end
+
+          def handle(entity:, event:, build_entity:)
+            raise if event.nil?
+
+            actions = [
+              "interfacets:react-dom:action",
+              "interfacets:react-dom:memoized-action",
+              "interfacets:react-dom:online",
+            ]
+
+            raise("unknown event: #{event}") unless actions.include?(event.fetch("type"))
+
+            return if event.fetch("type") == "interfacets:react-dom:online"
+
+            payload = event.fetch("payload")
+            callback_id = payload.fetch("id")
+            callback = @callbacks.fetch(callback_id)
+            Evaluator.call(entity, callback, payload["event"])
+          end
+        end
+      end
+    end
+  end
+end

data/lib/interfacets/client/channels/react/dom.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module Interfacets
+  module Client
+    module Channels
+      module React
+        class Dom
+          attr_accessor :children, :handlers, :facet
+
+          def initialize(facet:)
+            @children = []
+            @portals = []
+            @handlers = {}
+            @facet = facet
+          end
+
+          def reset
+            @children = []
+            @portals = []
+            @handlers = {}
+          end
+
+          def handle(facet:, payload:)
+            handler_id = payload.fetch("id")
+            handler = handlers.fetch(handler_id)
+            callback = handler.fetch(:callback)
+            og_facet = handler.fetch(:facet)
+
+            Evaluator.call(og_facet, callback, payload["event"])
+          end
+
+          def register_handler(id:, callback:, facet:)
+            @handlers[id] = { facet:, callback: }
+
+            {
+              type: "interfacets:react-dom:memoized-action",
+              payload: { id: },
+
+            }
+          end
+
+          def string_node(str)
+            @children << {
+              type: "interfacets:string-node",
+              attributes: { value: str },
+            }
+          end
+
+          def call(type, str = nil, **attrs)
+            raise("cannot pass both a block and a string") if str && block_given?
+            raise if type == :facet
+
+            new_element = {
+              type:,
+              children: [],
+              attributes: (
+                attrs.transform_values { |value|
+                  if value.is_a?(Proc)
+                    register_handler(
+                      id: value.object_id.to_s,
+                      callback: value,
+                      facet:,
+                    )
+
+                    {
+                      type: "interfacets:react-dom:action",
+                      payload: { id: value.object_id.to_s },
+                    }
+                  else
+                    value
+                  end
+                }
+              ),
+            }
+
+            if block_given? || str
+              # recurse
+              original_children = @children
+              @children = new_element[:children]
+              yield if block_given?
+              string_node(str) if str
+              @children = original_children
+            end
+
+            @children << new_element
+          end
+        end
+      end
+    end
+  end
+end

data/lib/interfacets/client/channels/react/evaluator.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Interfacets
+  module Client
+    module Channels
+      module React
+        class Evaluator
+          def self.call(facet, handler, event)
+            new(facet).call(handler, event)
+          end
+
+          # This just isolates the evaluation so that we don't
+          # conflict with other methods
+          #
+          # for associations, this facet needs to be the relevant one...
+          attr_reader :facet
+
+          def initialize(facet)
+            @facet = facet
+          end
+
+          def call(handler, event)
+            Shared::Utils.permissive_exec(self, event, &handler)
+          end
+
+          def channel(name)
+            System.current_bus.channel(name).builder
+          end
+        end
+      end
+    end
+  end
+end

data/lib/interfacets/client/channels/speech_to_text.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+module Interfacets
+  module Client
+    module Channels
+      class SpeechToText
+        include Channels::Base
+
+        type("speechToText")
+
+        class Builder
+          attr_accessor :facet
+          attr_accessor :entity
+
+          def initialize
+            @event = {}
+            @callbacks = {}
+          end
+
+          def flush_event
+            @event.tap { @event = {} }
+          end
+
+          def record(
+            on_done: ->(*, **) {},
+            on_progress: ->(*,**) {},
+            on_submit: ->(*, **) {}
+          )
+            id = SecureRandom.uuid
+            @event = {
+              id:,
+              type: "record",
+            }
+            @callbacks[id] = {
+              on_progress:,
+              on_done:,
+              on_submit:,
+            }
+          end
+
+          def callbacks
+            @callbacks ||= {}
+          end
+
+          def event
+            @event ||= {}
+          end
+        end
+
+        attr_reader :helper
+
+        def prepare(entity)
+          @builder ||= Builder.new
+          @builder.entity = entity
+        end
+
+        def builder(stream = "default")
+          @builder
+        end
+
+        def handle(event:, entity:, **)
+          callback_id = event.dig("payload", "id")
+
+          case event.fetch("type")
+          when "text-result"
+            builder
+              .callbacks
+              .delete(callback_id)
+              .fetch(:on_done)
+              .then do
+                entity.instance_exec(event.dig("payload", "text"), &_1)
+              end
+          when "text-progress"
+            builder
+              .callbacks
+              .fetch(callback_id)
+              .fetch(:on_progress)
+              .then do
+                entity.instance_exec(event.dig("payload", "text"), &_1)
+              end
+          when "text-submit"
+            builder
+              .callbacks
+              .fetch(callback_id)
+              .fetch(:on_submit)
+              .then do
+                entity.instance_exec(event.dig("payload", "text"), &_1)
+              end
+          else
+            raise "unknown event type: #{event.inspect}"
+          end
+        end
+
+        def result
+          { streams: { default: @builder.flush_event } }
+        end
+      end
+    end
+  end
+end

data/lib/interfacets/client/channels/timer.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Interfacets
+  module Client
+    module Channels
+      class Timer
+        include Channels::Base
+
+        type("interfacets:timer")
+
+        class Builder
+          attr_reader :event, :callbacks
+
+          def initialize
+            @event = {}
+            @callbacks = {}
+          end
+
+          def flush_event
+            @event.tap { @event = {} }
+          end
+
+          def callback(in_ms:, &block)
+            id = SecureRandom.uuid
+            event[:ms] = in_ms
+            event[:response] = { id: }
+            callbacks[id] = block
+          end
+        end
+
+        def prepare(entity)
+          @builder ||= Builder.new
+        end
+
+        def builder(stream = "defualt")
+          @builder
+        end
+
+        def handle(event:, entity:, **)
+          callback_id = event.dig("payload", "id")
+          entity.instance_exec(&builder.callbacks.fetch(callback_id))
+          builder.callbacks.delete(callback_id)
+        end
+
+        def result
+          { streams: { default: @builder.flush_event } }
+        end
+      end
+    end
+  end
+end