mayu-live 0.0.0

data/lib/mayu/utils.rb

@@ -0,0 +1,114 @@
+# typed: strict
+
+module Mayu
+  module Utils
+    extend T::Sig
+
+    sig { params(unit: Symbol).returns(Float) }
+    def self.monotonic_now(unit = :float_millisecond)
+      Process.clock_gettime(Process::CLOCK_MONOTONIC, unit).to_f
+    end
+
+    sig { params(unit: Symbol, block: T.proc.void).returns(Float) }
+    def self.measure_time(unit = :float_millisecond, &block)
+      start = monotonic_now
+      yield
+      monotonic_now - start
+    end
+
+    sig do
+      params(
+        hash: T::Hash[T.untyped, T.untyped],
+        path: T::Array[String]
+      ).returns(T::Hash[Symbol, T.untyped])
+    end
+    def self.flatten_props(hash, path = [])
+      hash.reduce({}) do |obj, (k, v)|
+        next obj.merge(style: v) if k == :style && path.empty?
+
+        current_path = [*path, k]
+
+        obj.merge(
+          case v
+          when Hash
+            flatten_props(v, current_path)
+          else
+            { current_path.join("_").to_sym => v }
+          end
+        )
+      end
+    end
+
+    class DeepFreezer
+      extend T::Sig
+      extend T::Generic
+      Elem = type_member { { upper: Object } }
+
+      sig { params(obj: Elem).void }
+      def initialize(obj) = @obj = obj
+
+      sig { returns(Elem) }
+      def deep_freeze
+        case @obj
+        when Hash
+          @obj.freeze
+          T.cast(
+            @obj
+              .transform_keys { Utils.deep_freeze(_1) }
+              .transform_values { Utils.deep_freeze(_1) },
+            Elem
+          )
+        when Array
+          T.cast(@obj.map(&:freeze), Elem)
+        else
+          @obj.freeze
+        end
+      end
+    end
+
+    class DeepDuper
+      extend T::Sig
+      extend T::Generic
+      Elem = type_member { { upper: Object } }
+
+      sig { params(obj: Elem).void }
+      def initialize(obj) = @obj = obj
+
+      sig { returns(Elem) }
+      def deep_dup
+        case @obj
+        when Hash
+          @obj.dup
+          T.cast(
+            @obj
+              .transform_keys { Utils.deep_dup(_1) }
+              .transform_values { Utils.deep_dup(_1) },
+            Elem
+          )
+        when Array
+          T.cast(@obj.map(&:dup), Elem)
+        else
+          @obj.dup
+        end
+      end
+    end
+
+    sig do
+      type_parameters(:O)
+        .params(obj: T.type_parameter(:O))
+        .returns(T.type_parameter(:O))
+    end
+    def self.deep_freeze(obj)
+      DeepFreezer.new(obj).deep_freeze
+    end
+
+    sig do
+      type_parameters(:O)
+        .params(obj: T.type_parameter(:O))
+        .returns(T.type_parameter(:O))
+    end
+    def self.deep_dup(obj)
+      DeepDuper.new(obj).deep_dup
+    end
+  end
+end

data/lib/mayu/vdom/children.rb

@@ -0,0 +1,117 @@
+# typed: strict
+# frozen_string_literal: true
+
+require_relative "children"
+require_relative "../component"
+require_relative "component_marshaler"
+
+module Mayu
+  module VDOM
+    Slots =
+      T.type_alias do
+        T::Hash[T.nilable(String), T::Array[Interfaces::Descriptor]]
+      end
+
+    class Children
+      extend T::Sig
+      extend T::Generic
+      include Enumerable
+
+      include Interfaces::Children
+
+      sig do
+        params(
+          descriptors: T::Array[Interfaces::Descriptor],
+          parent_type: T.untyped
+        ).void
+      end
+      def self.check_duplicate_keys(descriptors, parent_type: "??unknown??")
+        keys = descriptors.map(&:key).compact
+        duplicates = keys.reject { keys.rindex(_1) == keys.index(_1) }.uniq
+        duplicates.each do |key|
+          Console.logger.warn(
+            self,
+            "Duplicate keys detected: #{key.inspect}",
+            "This may cause an update error!",
+            "Parent type: #{parent_type.inspect}"
+          )
+        end
+      end
+
+      Elem = type_member { { fixed: Interfaces::Descriptor } }
+
+      sig do
+        params(
+          descriptors: T::Array[Interfaces::Descriptor],
+          parent_type: T.untyped
+        ).void
+      end
+      def initialize(descriptors, parent_type: nil)
+        @descriptors =
+          T.let(
+            Descriptor::Factory.clean(descriptors, parent_type:),
+            T::Array[Interfaces::Descriptor]
+          )
+        @slots = T.let(nil, T.nilable(Slots))
+      end
+
+      sig { returns(T::Array[Interfaces::Descriptor]) }
+      def to_a = @descriptors
+
+      sig { params(other: T.untyped).returns(T::Boolean) }
+      def ==(other)
+        case other
+        when Children
+          @descriptors == other.to_a
+        when Array
+          @descriptors == other
+        else
+          false
+        end
+      end
+
+      sig { returns(T::Boolean) }
+      def empty? = @descriptors.empty?
+
+      sig do
+        override
+          .params(
+            name: T.nilable(String),
+            fallback: T.nilable(T.proc.returns(Interfaces::Descriptor))
+          )
+          .returns(
+            T.nilable(
+              T.any(Interfaces::Descriptor, T::Array[Interfaces::Descriptor])
+            )
+          )
+      end
+      def slot(name = nil, &fallback)
+        case slots.fetch(name, [])
+        in []
+          yield if block_given?
+        in [one]
+          one
+        in [*many] unless name
+          many
+        in [*many]
+          raise "Got #{many.size} slots one slot with name #{name.inspect}, #{many.map(&:type).inspect}"
+        end
+      end
+
+      sig { returns(String) }
+      def join = @descriptors.join
+
+      sig { returns(Slots) }
+      def slots = @slots ||= @descriptors.group_by(&:slot)
+
+      sig do
+        override
+          .params(block: T.proc.params(arg0: T.untyped).returns(BasicObject))
+          .returns(T.untyped)
+      end
+      def each(&block)
+        @descriptors.each(&block)
+      end
+    end
+  end
+end

data/lib/mayu/vdom/component_marshaler.rb

@@ -0,0 +1,53 @@
+# typed: strict
+
+require_relative "../component"
+
+module Mayu
+  module VDOM
+    class ComponentMarshaler
+      extend T::Sig
+
+      sig { returns(T.untyped) }
+      attr_reader :type
+
+      sig { params(type: T.untyped).void }
+      def initialize(type)
+        @type =
+          T.let(
+            if Component === type
+              klass = T.cast(type, T.class_of(Component::Base))
+
+              # TODO: Would be better to do something like
+              # resources.resouce_for_type(klass)
+              if resource =
+                   (
+                     begin
+                       klass.__mayu_resource
+                     rescue StandardError
+                       nil
+                     end
+                   )
+                component = resource.path
+                { component: }
+              else
+                { klass: klass }
+              end
+            else
+              type
+            end,
+            T.untyped
+          )
+      end
+
+      sig { returns(T.untyped) }
+      def marshal_dump
+        @type
+      end
+
+      sig { params(a: T.untyped).void }
+      def marshal_load(a)
+        @type = a
+      end
+    end
+  end
+end

data/lib/mayu/vdom/css_attributes.rb

@@ -0,0 +1,131 @@
+# typed: strict
+
+require_relative "update_context"
+require_relative "vnode"
+
+module Mayu
+  module VDOM
+    class CSSAttributes
+      extend T::Sig
+
+      # CSS properties which accept numbers but are not in units of "px".
+      # Copied from React:
+      # https://github.com/facebook/react/blob/a7c57268fb71163e4abb5e386c0d0e63290baaae/packages/react-dom/src/shared/CSSProperty.js
+      UNITLESS_PROPERTIES =
+        T.let(
+          [
+            :animation_iteration_count,
+            :aspect_ratio,
+            :border_image_outset,
+            :border_image_slice,
+            :border_image_width,
+            :box_flex,
+            :box_flex_group,
+            :box_ordinal_group,
+            :column_count,
+            :columns,
+            :flex,
+            :flex_grow,
+            :flex_positive,
+            :flex_shrink,
+            :flex_negative,
+            :flex_order,
+            :grid_area,
+            :grid_row,
+            :grid_row_end,
+            :grid_row_span,
+            :grid_row_start,
+            :grid_column,
+            :grid_column_end,
+            :grid_column_span,
+            :grid_column_start,
+            :font_weight,
+            :line_clamp,
+            :line_height,
+            :opacity,
+            :order,
+            :orphans,
+            :tab_size,
+            :widows,
+            :z_index,
+            :zoom,
+            # SVG-related properties
+            :fill_opacity,
+            :flood_opacity,
+            :stop_opacity,
+            :stroke_dasharray,
+            :stroke_dashoffset,
+            :stroke_miterlimit,
+            :stroke_opacity,
+            :stroke_width
+          ].freeze,
+          T::Array[Symbol]
+        )
+
+      sig { returns(T::Hash[Symbol, T.untyped]) }
+      attr_reader :properties
+
+      sig { params(properties: T.untyped).void }
+      def initialize(**properties)
+        @properties = properties
+      end
+
+      sig { returns(String) }
+      def to_s
+        @properties
+          .map do |property, value|
+            format(
+              "%s:%s;",
+              transform_property(property),
+              transform_value(property, value)
+            )
+          end
+          .join
+      end
+
+      sig do
+        params(ctx: UpdateContext, vnode: VNode, other: CSSAttributes).void
+      end
+      def patch(ctx, vnode, other)
+        (properties.keys | other.properties.keys).sort.each do |property|
+          old_value = properties[property]
+          new_value = other.properties[property]
+
+          next if old_value == new_value
+
+          unless new_value
+            ctx.css(vnode, transform_property(property))
+            next
+          end
+
+          ctx.css(
+            vnode,
+            transform_property(property),
+            transform_value(property, new_value)
+          )
+        end
+      end
+
+      private
+
+      sig { params(property: Symbol).returns(String) }
+      def transform_property(property)
+        property.to_s.tr("_", "-")
+      end
+
+      sig { params(property: Symbol, value: T.untyped).returns(String) }
+      def transform_value(property, value)
+        should_apply_px?(property, value) ? "#{value}px" : value.to_s
+      end
+
+      sig { params(property: Symbol, value: T.untyped).returns(T::Boolean) }
+      def should_apply_px?(property, value)
+        return false unless Integer === value
+        return false if UNITLESS_PROPERTIES.include?(property)
+        return false if property.start_with?("__")
+        return false if property.start_with?("--")
+        true
+      end
+    end
+  end
+end

data/lib/mayu/vdom/descriptor.rb

@@ -0,0 +1,151 @@
+# typed: strict
+# frozen_string_literal: true
+
+require_relative "interfaces"
+require_relative "../component"
+require_relative "component_marshaler"
+require_relative "children"
+require_relative "./special_elements"
+
+module Mayu
+  module VDOM
+    class Descriptor < T::Struct
+      class FactoryImpl
+        extend T::Sig
+        include Interfaces::Descriptor::Factory
+
+        sig { override.returns(Descriptor) }
+        def comment
+          Descriptor[Interfaces::Descriptor::COMMENT]
+        end
+
+        sig { override.params(text_content: T.untyped).returns(Descriptor) }
+        def text(text_content)
+          Descriptor[
+            Interfaces::Descriptor::TEXT,
+            text_content: text_content.to_s
+          ]
+        end
+
+        sig { override.params(obj: T.untyped).returns(Descriptor) }
+        def or_text(obj)
+          Descriptor === obj ? obj : text(obj.to_s)
+        end
+
+        sig do
+          override
+            .params(children: Component::Children, parent_type: T.untyped)
+            .returns(T::Array[Descriptor])
+        end
+        def clean(children, parent_type: nil)
+          cleaned = Array(children).flatten.select(&:itself) # Remove anything falsy
+
+          if parent_type == :title
+            # <title> can only have text children
+            cleaned.map { text(_1) }
+          else
+            cleaned.map { or_text(_1) }
+          end
+        end
+
+        sig do
+          override
+            .params(descriptors: T::Array[Interfaces::Descriptor])
+            .returns(T::Array[Interfaces::Descriptor])
+        end
+        def add_comments_between_texts(descriptors)
+          comment = self.comment
+
+          [*descriptors, nil].each_cons(2)
+            .flat_map do |curr, succ|
+              if curr&.text? && succ&.text?
+                [curr, comment]
+              else
+                curr
+              end
+            end
+            .compact
+        end
+      end
+
+      Factory = T.let(FactoryImpl.new, FactoryImpl)
+
+      extend T::Sig
+      include Interfaces::Descriptor
+
+      const :type, Component::ElementType
+      const :props, Component::Props
+      const :key, T.untyped
+      const :slot, T.nilable(String)
+
+      sig do
+        params(
+          type: Component::ElementType,
+          children: T.untyped,
+          props: T.untyped
+        ).returns(Descriptor)
+      end
+      def self.[](type, *children, **props)
+        type = T.let(SpecialElements.for_type(type), Component::ElementType)
+
+        children = Children.new(children, parent_type: type)
+        props = props.merge(children:)
+        key = props.delete(:key)
+        slot = props.delete(:slot)&.to_s
+
+        new(type:, key:, slot:, props:)
+      end
+
+      sig { returns(T::Array[T.untyped]) }
+      def marshal_dump
+        [ComponentMarshaler.new(type), Marshalling.dump_props(props), key, slot]
+      end
+
+      sig { params(a: T::Array[T.untyped]).void }
+      def marshal_load(a)
+        @type, @props, @key, @slot = a
+        freeze
+      end
+
+      ##
+      # This is used for hash comparisons,
+      # https://ruby-doc.org/3.2.0/Hash.html#class-Hash-label-User-Defined+Hash+Keys
+      sig { override.params(other: T.untyped).returns(T::Boolean) }
+      def eql?(other) = self.class === other && same?(other)
+
+      sig { override.returns(T::Boolean) }
+      def component? = Component.component_class?(@type)
+
+      sig { override.returns(T.class_of(Component::Base)) }
+      def component_class
+        if Component.component_class?(@type)
+          T.cast(@type, T.class_of(Component::Base))
+        else
+          raise "#{@type.inspect} is not a component class"
+        end
+      end
+
+      sig { returns(String) }
+      def to_s
+        return text if text?
+        return "" if comment?
+        "#<Descriptor type=#{type.inspect}>"
+      end
+
+      sig { override.params(other: Interfaces::Descriptor).returns(T::Boolean) }
+      def same?(other)
+        if key == other.key && type == other.type
+          if type == :input
+            # Inputs are considered to be different if their type changes.
+            # Is this a good behavior? I think maybe it comes from from Preact.
+            props[:type] == other.props[:type]
+          else
+            true
+          end
+        else
+          false
+        end
+      end
+    end
+  end
+end

data/lib/mayu/vdom/descriptor.test.rb

@@ -0,0 +1,26 @@
+# typed: true
+
+require "minitest/autorun"
+require "test_helper"
+require_relative "descriptor"
+
+class TestDescriptor < Minitest::Test
+  class MyComponent < Mayu::Component::Base
+    def render
+    end
+  end
+
+  def test_element
+    descriptor = Mayu::VDOM::Descriptor[:foo, key: "test-key"]
+    assert_equal(descriptor.type, :foo)
+    assert_equal(descriptor.props, { children: [] })
+    assert_equal(descriptor.key, "test-key")
+  end
+
+  def test_component
+    descriptor = Mayu::VDOM::Descriptor[MyComponent, key: "test-key"]
+    assert_equal(descriptor.type, MyComponent)
+    assert_equal(descriptor.props, { children: [] })
+    assert_equal(descriptor.key, "test-key")
+  end
+end