mayu-live 0.0.0

data/lib/mayu/vdom/dom.rb

@@ -0,0 +1,239 @@
+# typed: strict
+
+require "cgi"
+
+module Mayu
+  module VDOM
+    class DOM
+      extend T::Sig
+
+      class DOMException < StandardError
+      end
+
+      class CSSStyleDeclaration
+        extend T::Sig
+
+        sig { void }
+        def initialize
+          @properties = T.let({}, T::Hash[String, String])
+        end
+
+        sig { params(name: String).returns(String) }
+        def get_property_value(name)
+          @properties[name].to_s
+        end
+
+        sig do
+          params(name: String, value: T.any(String, Integer, Float)).returns(
+            self
+          )
+        end
+        def set_property(name, value)
+          @properties[name] = value.to_s
+          self
+        end
+
+        sig { params(name: String).returns(self) }
+        def remove_property(name)
+          @properties.delete(name)
+          self
+        end
+
+        sig { returns(String) }
+        def to_s
+          @properties.map { "#{_1}: #{_2};" }.join(" ")
+        end
+      end
+
+      class Node
+        extend T::Sig
+
+        sig { returns(Integer) }
+        attr_reader :id
+
+        sig { returns(T.nilable(Element)) }
+        attr_reader :parent
+
+        sig { returns(T.nilable(Node)) }
+        def previous_sibling = parent&.find_previous_sibling(self)
+
+        sig { returns(T.nilable(Node)) }
+        def next_sibling = parent&.find_next_sibling(self)
+
+        sig { params(document: DOM).void }
+        def initialize(document)
+          @document = T.let(document, DOM)
+          @id = T.let(@document.next_id!, Integer)
+          @parent = T.let(nil, T.nilable(Element))
+        end
+
+        sig { returns(T::Boolean) }
+        def text? = false
+        sig { returns(T::Boolean) }
+        def element? = false
+
+        sig { returns(String) }
+        def to_s = ""
+
+        sig do
+          params(new_parent: T.nilable(Element)).returns(T.nilable(Element))
+        end
+        def parent=(new_parent)
+          @parent&.remove_child(self)
+          @parent = new_parent
+        end
+
+        sig { params(node: Node).returns(self) }
+        def append_child(node)
+          raise DOMException, "Can't append children to #{self.class.name}"
+        end
+
+        sig do
+          params(new_node: Node, reference_node: T.nilable(Node)).returns(self)
+        end
+        def insert_before(new_node, reference_node = nil)
+          raise DOMException, "Can't insert children to #{self.class.name}"
+        end
+
+        sig { params(node: Node).returns(self) }
+        def remove_child(node)
+          raise DOMException, "Can't remove children from #{self.class.name}"
+        end
+      end
+
+      class Element < Node
+        sig { returns(T::Array[Node]) }
+        attr_reader :children
+
+        sig { returns(CSSStyleDeclaration) }
+        attr_reader :style
+
+        sig { params(document: DOM, tag_name: Symbol).void }
+        def initialize(document, tag_name)
+          super(document)
+          @tag_name = T.let(tag_name, Symbol)
+          @children = T.let([], T::Array[Node])
+          @attributes = T.let({}, T::Hash[String, String])
+          @style = T.let(CSSStyleDeclaration.new, CSSStyleDeclaration)
+        end
+
+        sig { returns(T::Boolean) }
+        def element? = true
+
+        sig { returns(String) }
+        def to_s
+          attrs = [
+            %{data-mayu-id="#{id}"},
+            @attributes.map { %{#{_1}="#{CGI.escape(_2)}"} }
+          ].flatten.join(" ")
+
+          if children.empty?
+            "<#{@tag_name} #{attrs} />"
+          else
+            "<#{@tag_name} #{attrs}>#{children.join}</#{@tag_name}>"
+          end
+        end
+
+        sig { params(name: String).returns(T.nilable(String)) }
+        def get_attribute(name)
+          @attributes[name]
+        end
+
+        sig { params(name: String, value: String).void }
+        def set_attribute(name, value)
+          @attributes[name] = value
+        end
+
+        sig { params(name: String).void }
+        def remove_attribute(name)
+          @attributes.delete(name)
+        end
+
+        sig { params(node: Node).returns(self) }
+        def append_child(node)
+          node.parent = self
+          @children.push(node)
+          self
+        end
+
+        sig do
+          params(new_node: Node, reference_node: T.nilable(Node)).returns(self)
+        end
+        def insert_before(new_node, reference_node = nil)
+          new_node.parent = self
+          index = @children.index(reference_node) || -1
+          @children.insert(index, new_node)
+          self
+        end
+
+        sig { params(node: Node).returns(self) }
+        def remove_child(node)
+          @children.delete(node)
+          self
+        end
+
+        sig { params(node: Node).returns(T.nilable(Node)) }
+        def find_previous_sibling(node)
+          index = @children.index(node).to_i
+          @children[index.pred] if index > 1
+        end
+
+        sig { params(node: Node).returns(T.nilable(Node)) }
+        def find_next_sibling(node)
+          index = @children.index(node).to_i
+          @children[index.succ] if index
+        end
+      end
+
+      class Text < Node
+        sig { params(document: DOM, data: String).void }
+        def initialize(document, data)
+          super(document)
+          @data = T.let(data, String)
+        end
+
+        sig { returns(T::Boolean) }
+        def text? = true
+
+        sig { returns(String) }
+        def to_s = @data
+      end
+
+      class Comment < Node
+        sig { params(document: DOM, data: String).void }
+        def initialize(document, data)
+          super(document)
+          @data = T.let(data, String)
+        end
+
+        sig { returns(T::Boolean) }
+        def comment? = true
+
+        sig { returns(String) }
+        def to_s = "<!-- mayu-id: #{id}. #{@data} -->"
+      end
+
+      sig { returns(Element) }
+      attr_reader :root
+
+      sig { void }
+      def initialize
+        @id_counter = T.let(0, Integer)
+        @root = T.let(create_element(:html), Element)
+      end
+
+      sig { params(tag_name: Symbol).returns(Element) }
+      def create_element(tag_name)
+        Element.new(self, tag_name)
+      end
+
+      sig { params(data: String).returns(Text) }
+      def create_text_node(data)
+        Text.new(self, data)
+      end
+
+      sig { returns(Integer) }
+      def next_id! = @id_counter += 1
+    end
+  end
+end

data/lib/mayu/vdom/h.rb

@@ -0,0 +1,22 @@
+# typed: strict
+
+require "sorbet-runtime"
+
+module Mayu
+  module VDOM
+    module H
+      extend T::Sig
+
+      sig do
+        params(
+          type: Component::ElementType,
+          children: T.any(Component::Children, Component::ChildType),
+          props: T.untyped
+        ).returns(Descriptor)
+      end
+      def self.[](type, *children, **props)
+        T.unsafe(Descriptor)[type, *children, **props]
+      end
+    end
+  end
+end

data/lib/mayu/vdom/id_generator.rb

@@ -0,0 +1,55 @@
+# typed: strict
+
+module Mayu
+  module VDOM
+    class IdGenerator
+      extend T::Sig
+
+      # ALPHABET = "🌱🌴🌵🌸🌺🌻🌼🌿🍀🍃"
+      # JOINER = ""
+      ALPHABET = "0123456789"
+      JOINER = ""
+
+      DIGITS = T.let(ALPHABET.chars.freeze, T::Array[String])
+
+      Type = T.type_alias { String }
+
+      sig { void }
+      def initialize
+        @counter = T.let(0, Integer)
+      end
+
+      sig { returns(Type) }
+      def next!
+        id = @counter.tap { @counter = @counter.succ }
+        number_to_base(id, DIGITS.length).map { DIGITS[_1] }.join(JOINER)
+      end
+
+      sig { returns(Integer) }
+      def marshal_dump
+        @counter
+      end
+
+      sig { params(counter: Integer).void }
+      def marshal_load(counter)
+        @counter = counter
+      end
+
+      private
+
+      sig { params(number: Integer, base: Integer).returns(T::Array[Integer]) }
+      def number_to_base(number, base)
+        return [0] if number.zero?
+
+        digits = []
+
+        until number.zero?
+          digits.unshift(number % base)
+          number /= base
+        end
+
+        digits
+      end
+    end
+  end
+end

data/lib/mayu/vdom/interfaces.rb

@@ -0,0 +1,186 @@
+# typed: strict
+
+module Mayu
+  module VDOM
+    module Interfaces
+      module VTree
+        extend T::Sig
+        extend T::Helpers
+        abstract!
+
+        sig { abstract.returns(String) }
+        def next_id!
+        end
+
+        sig { abstract.returns(Session) }
+        def session
+        end
+
+        sig { abstract.params(path: String).void }
+        def navigate(path)
+        end
+
+        sig { abstract.params(type: Symbol, payload: T.untyped).void }
+        def action(type, payload)
+        end
+
+        sig { overridable.params(vnode: T.untyped).void }
+        def enqueue_update!(vnode)
+        end
+      end
+
+      module VNode
+        extend T::Sig
+        extend T::Helpers
+        abstract!
+
+        sig { abstract.returns(String) }
+        def id
+        end
+
+        sig { abstract.returns(Descriptor) }
+        def descriptor
+        end
+      end
+
+      module Descriptor
+        module Factory
+          extend T::Sig
+          extend T::Helpers
+          abstract!
+
+          sig { abstract.params(obj: T.untyped).returns(Descriptor) }
+          def or_text(obj)
+          end
+
+          sig { abstract.params(text_content: T.untyped).returns(Descriptor) }
+          def text(text_content)
+          end
+
+          sig { abstract.returns(Descriptor) }
+          def comment
+          end
+
+          sig do
+            abstract
+              .params(children: Component::Children, parent_type: T.untyped)
+              .returns(T::Array[Descriptor])
+          end
+          def clean(children, parent_type: nil)
+          end
+
+          sig do
+            abstract
+              .params(descriptors: T::Array[Descriptor])
+              .returns(T::Array[Descriptor])
+          end
+          def add_comments_between_texts(descriptors)
+          end
+        end
+
+        extend T::Sig
+        extend T::Helpers
+        abstract!
+
+        TEXT = :TEXT
+        COMMENT = :COMMENT
+
+        sig { overridable.returns(T::Boolean) }
+        def text? = type == TEXT
+
+        sig { overridable.returns(T::Boolean) }
+        def comment? = type == COMMENT
+
+        sig { overridable.returns(T::Boolean) }
+        def element? = type.is_a?(Symbol)
+
+        sig { abstract.returns(T::Boolean) }
+        def component?
+        end
+
+        sig { abstract.returns(Component::ElementType) }
+        def type
+        end
+
+        sig { abstract.returns(Component::Props) }
+        def props
+        end
+
+        sig { abstract.returns(T.untyped) }
+        def key
+        end
+
+        sig { abstract.returns(String) }
+        def slot
+        end
+
+        sig { overridable.returns(Children[Descriptor]) }
+        def children = props[:children]
+
+        sig { overridable.returns(T::Boolean) }
+        def has_children? = children.any?
+
+        sig { overridable.returns(String) }
+        def text = props[:text_content].to_s
+
+        sig { abstract.returns(T.class_of(Component::Base)) }
+        def component_class
+        end
+
+        sig { returns(Descriptor) }
+        def itself = self
+
+        sig do
+          type_parameters(:R)
+            .params(
+              block:
+                T.proc.params(arg0: Descriptor).returns(T.type_parameter(:R))
+            )
+            .returns(T.type_parameter(:R))
+        end
+        def then(&block) = yield self
+
+        ##
+        # This is used for hash comparisons,
+        # https://ruby-doc.org/3.2.0/Hash.html#class-Hash-label-User-Defined+Hash+Keys
+        sig { overridable.returns(Integer) }
+        def hash
+          [type, slot, key, type == :input && props[:type]].hash
+        end
+
+        ##
+        # This is used for hash comparisons,
+        # https://ruby-doc.org/3.2.0/Hash.html#class-Hash-label-User-Defined+Hash+Keys
+        sig { abstract.params(other: T.untyped).returns(T::Boolean) }
+        def eql?(other)
+        end
+
+        sig do
+          abstract.params(other: Interfaces::Descriptor).returns(T::Boolean)
+        end
+        def same?(other)
+        end
+      end
+
+      module Children
+        extend T::Sig
+        extend T::Helpers
+        extend T::Generic
+        include Enumerable
+        Elem = type_member { { upper: Descriptor } }
+        abstract!
+
+        sig do
+          abstract
+            .params(
+              name: T.nilable(String),
+              fallback: T.nilable(T.proc.returns(Descriptor))
+            )
+            .returns(T.nilable(T.any(Descriptor, T::Array[Descriptor])))
+        end
+        def slot(name = nil, &fallback)
+        end
+      end
+    end
+  end
+end

data/lib/mayu/vdom/marshalling.rb

@@ -0,0 +1,78 @@
+# typed: strict
+
+module Mayu
+  module VDOM
+    module Marshalling
+      extend T::Sig
+
+      sig { params(vtree: VTree).returns(String) }
+      def self.dump(vtree)
+        Marshal.dump(vtree)
+      end
+
+      sig do
+        params(dumped: String, session: Session, task: Async::Task).returns(
+          VTree
+        )
+      end
+      def self.restore(dumped, session:, task: Async::Task.current)
+        vtree =
+          Marshal.restore(
+            dumped,
+            ->(obj) do
+              case obj
+              when VDOM::VTree
+                obj.instance_variable_set(:@session, session)
+                obj.instance_variable_set(:@task, task)
+                obj
+              when VDOM::ComponentMarshaler
+                case obj.type
+                in klass:
+                  klass
+                in component:
+                  T.cast(
+                    session.environment.resources.load_resource(component).type,
+                    Resources::Types::Component
+                  ).component
+                else
+                  obj.type
+                end
+              else
+                obj
+              end
+            end
+          )
+
+        vtree.root&.traverse do |vnode|
+          vnode.instance_variable_set(:@vtree, vtree)
+        end
+
+        vtree
+      end
+
+      sig { params(props: Component::Props).returns(Component::Props) }
+      def self.dump_props(props)
+        props.transform_values { |value| dump_value(value) }
+      end
+
+      sig { params(state: Component::State).returns(Component::State) }
+      def self.dump_state(state)
+        state.transform_values { |value| dump_value(value) }
+      end
+
+      sig { params(value: T.untyped).returns(T.untyped) }
+      def self.dump_value(value)
+        case value
+        when Hash
+          value.transform_values { dump_value(_1) }
+        when Array
+          value.map { dump_value(_1) }
+        when Component
+          ComponentMarshaler.new(value)
+        else
+          value
+        end
+      end
+    end
+  end
+end