view_component_atomix 0.1.0

data/lib/view_component/atomix/rule.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module ViewComponent
+  module Atomix
+    Rule = Struct.new(:selector, :property, :value, :conditions, :priority, keyword_init: true) do
+      def initialize(selector:, property:, value:, conditions: [], priority: nil)
+        super(
+          selector: Immutable.copy(selector),
+          property: Immutable.copy(property),
+          value: Immutable.copy(value),
+          conditions: Immutable.copy(conditions),
+          priority: priority || Property.priority(property, conditions)
+        )
+        freeze
+      end
+
+      def to_css
+        pseudos = conditions.reject { |c| c.start_with?("@") }
+                            .sort_by { |c| c.start_with?("::") ? 1 : 0 }
+        at_rules = conditions.select { |c| c.start_with?("@") }
+                             .sort_by { |c| Property.condition_priority(c) }
+
+        # StyleX adds one class per at-rule so a matching media query can
+        # override a pseudo-class even when cascade layers are disabled.
+        repetitions = 0
+        if selector.start_with?(".")
+          repetitions = at_rules.length
+          repetitions += 1 if pseudos.any? { |pseudo| pseudo.include?(":where(") }
+        end
+        css = "#{selector * (1 + repetitions)}#{pseudos.join}{#{declarations}}"
+        at_rules.reverse_each { |at| css = "#{at}{#{css}}" }
+        css
+      end
+
+      private
+
+      def declarations
+        Array(value).map { |v| "#{property}:#{v}" }.join(";")
+      end
+    end
+  end
+end

data/lib/view_component/atomix/sheet.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+module ViewComponent
+  module Atomix
+    class Sheet
+      attr_reader :sets, :vars
+
+      def initialize(sets = {}, vars = {})
+        @sets = Immutable.copy(sets)
+        @vars = Immutable.copy(vars)
+        freeze
+      end
+
+      EMPTY = new
+
+      def [](name)
+        return nil if name.nil?
+
+        key = name.to_sym
+        return sets[key] if sets.key?(key)
+
+        owner = vars_for(key)
+        return owner[key] if owner
+
+        raise KeyError, "Unknown trait #{name.inspect}. Available sets: #{names.inspect}, vars: #{var_names.inspect}"
+      end
+
+      def fetch(name, *args, **kwargs)
+        invoke(name, self[name], *args, **kwargs)
+      end
+
+      def key?(name)
+        sets.key?(name.to_sym) || !vars_for(name).nil?
+      end
+
+      def names
+        sets.keys
+      end
+
+      def var_names
+        vars.keys
+      end
+
+      def vars_for(name)
+        key = name.to_sym
+        return vars[key] if vars.key?(key)
+
+        global = ViewComponent::Atomix.configured_vars
+        global if global&.names&.key?(key)
+      end
+
+      def empty?
+        sets.empty? && vars.empty?
+      end
+
+      def merge(other)
+        return self if other.nil? || other.empty?
+
+        Sheet.new(sets.merge(other.sets), vars.merge(other.vars))
+      end
+
+      def to_h
+        sets
+      end
+
+      def props(*styles)
+        ViewComponent::Atomix.props(*styles)
+      end
+
+      def method_missing(name, *args, **kwargs, &block)
+        if sets.key?(name)
+          invoke(name, sets[name], *args, **kwargs)
+        elsif args.empty? && kwargs.empty? && (owner = vars_for(name))
+          owner[name]
+        else
+          super
+        end
+      end
+
+      def respond_to_missing?(name, include_private = false)
+        sets.key?(name) || !vars_for(name).nil? || super
+      end
+
+      private
+
+      def invoke(name, set, *args, **kwargs)
+        return set.call(*args, **kwargs) if callable?(set)
+        return set if args.empty? && kwargs.empty?
+
+        raise ArgumentError, "Trait #{name.inspect} is static and takes no arguments"
+      end
+
+      def callable?(set)
+        set.is_a?(DynamicStyle) || set.is_a?(EnumeratedStyle)
+      end
+    end
+  end
+end

data/lib/view_component/atomix/style.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module ViewComponent
+  module Atomix
+    class Style
+      attr_reader :classes, :inline
+
+      def initialize(classes = {}, inline = {})
+        assign(Immutable.copy(classes), Immutable.copy(inline))
+      end
+
+      def self.combine(styles)
+        styles = styles.reject(&:empty?)
+        return EMPTY if styles.empty?
+        return styles.first if styles.one?
+
+        classes = {}
+        inline = {}
+        styles.each do |style|
+          classes.update(style.classes)
+          inline.update(style.inline)
+        end
+        allocate.send(:assign, classes.freeze, inline.freeze)
+      end
+
+      def merge(other)
+        return self if other.nil? || other.empty?
+
+        Style.combine([self, other])
+      end
+
+      def empty?
+        classes.empty? && inline.empty?
+      end
+
+      def class_names
+        names = classes.values.compact.flatten
+        names.empty? ? nil : names.join(" ")
+      end
+
+      def inline_style
+        return nil if inline.empty?
+
+        inline.map { |name, value| "#{name}:#{value}" }.join(";")
+      end
+
+      def to_attrs
+        attrs = Attrs.new
+        names = class_names
+        declarations = inline_style
+        attrs[:class] = names if names
+        attrs[:style] = declarations if declarations
+        attrs
+      end
+
+      def to_s
+        class_names.to_s
+      end
+
+      def ==(other)
+        other.is_a?(Style) && classes == other.classes && inline == other.inline
+      end
+      alias eql? ==
+
+      def hash
+        [classes, inline].hash
+      end
+
+      private
+
+      def assign(classes, inline)
+        @classes = classes
+        @inline = inline
+        freeze
+      end
+
+      EMPTY = new
+    end
+  end
+end

data/lib/view_component/atomix/tasks/build.rake

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+namespace :view_component do
+  namespace :atomix do
+    desc "Compile all ViewComponent::Atomix rules into a CSS file"
+    task build: :environment do
+      Rails.application.eager_load!
+      ViewComponent::Atomix.eager_load!
+      ViewComponent::Atomix.compile_dynamic_styles!
+      path = ViewComponent::Atomix.write_css(force: true)
+      puts "Wrote #{ViewComponent::Atomix.registry.size} rules to #{path}"
+    end
+  end
+end
+
+task "assets:precompile"
+Rake::Task["assets:precompile"].prerequisites.unshift("view_component:atomix:build")

data/lib/view_component/atomix/theme_compiler.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module ViewComponent
+  module Atomix
+    module ThemeCompiler
+      # A variable group may span multiple style_vars declarations.
+      def self.compile(id, names, overrides)
+        digest_input = overrides.sort_by { |k, _| k.to_s }.map { |k, v| "#{k}=#{v.inspect}" }
+        class_name = Hashing.class_name("theme", id, digest_input)
+        Atomix.registry.transaction do
+          overrides.each do |key, value|
+            Vars.register(".#{class_name}", names.fetch(key.to_sym), value)
+          end
+        end
+        Style.new({ "theme:#{id}" => [class_name] })
+      end
+    end
+  end
+end

data/lib/view_component/atomix/theme_resolution.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module ViewComponent
+  module Atomix
+    module ThemeResolution
+      private
+
+      def resolved_theme
+        resolve_owner(:theme) do |reentrant|
+          reentrant ? theme_context : compile_theme
+        end
+      end
+
+      def compile_theme
+        styles_state.themes.drain do |declaration|
+          built = ViewComponent::Atomix.registry.with_source(declaration.source) do
+            build_theme(declaration.vars, declaration.overrides, declaration.block)
+          end
+          styles_state.theme_own = (styles_state.theme_own || Style::EMPTY).merge(built)
+        end
+
+        theme_context
+      end
+
+      def theme_context
+        inherited = inherited_theme
+        matching_mixins = styles_mixins.select { |mod| mod < Theme && theme_accessor_for(mod) == :theme }
+        layers = [inherited, companion_theme, *matching_mixins.map { |mod| mod.send(:resolved_theme) },
+                  styles_state.theme_own || Style::EMPTY]
+        layers.reduce(Style::EMPTY, :merge)
+      end
+
+      def inherited_theme
+        return Style::EMPTY unless is_a?(Class) && superclass.respond_to?(:resolved_theme, true)
+
+        superclass.send(:resolved_theme)
+      end
+
+      def build_theme(vars, overrides, block)
+        overrides = block.call if block
+        unless overrides.is_a?(Hash)
+          raise ArgumentError, "Theme overrides must be a Hash, got #{overrides.class}"
+        end
+
+        if vars
+          return commit_owner_declaration do
+            ViewComponent::Atomix.create_theme(vars, **overrides)
+          end
+        end
+
+        sheet = resolved_styles
+        grouped = overrides.group_by do |key, _|
+          owner = sheet.vars_for(key) ||
+            raise(KeyError, "Unknown var #{key.inspect} in theme for #{self}. Available vars: #{sheet.var_names.inspect}")
+          owner.id
+        end
+        commit_owner_declaration do
+          grouped.map do |id, pairs|
+            names = pairs.to_h { |key, _| [key.to_sym, sheet.vars_for(key).var_name(key)] }
+            ThemeCompiler.compile(id, names, pairs.to_h)
+          end.reduce(Style::EMPTY, :merge)
+        end
+      end
+    end
+  end
+end

data/lib/view_component/atomix/trait_classifier.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+module ViewComponent
+  module Atomix
+    # Classifies the DSL without emitting CSS. Available references contain only
+    # inherited sets and sets compiled earlier in declaration order.
+    class TraitClassifier
+      Result = Struct.new(:kind, :properties, :references, :members, :default, :fn, keyword_init: true)
+
+      def initialize(sets:, inherited_sets:, conditions:)
+        @sets = sets
+        @inherited_sets = inherited_sets
+        @conditions = conditions
+      end
+
+      def classify(set_name, definition)
+        if Property.known?(Property.normalize_key(set_name))
+          raise ArgumentError, "Trait #{set_name.inspect} is named after a CSS property. Pick another name."
+        end
+        if Sheet.method_defined?(set_name)
+          raise ArgumentError, "Trait #{set_name.inspect} collides with a method on the styles sheet. Pick another name."
+        end
+
+        case definition
+        when Proc
+          Result.new(kind: :dynamic, fn: definition)
+        when Hash
+          if definition.key?(:dynamic) || definition.key?(:using)
+            classify_dynamic(set_name, definition)
+          else
+            classify_hash(set_name, definition)
+          end
+        else
+          raise ArgumentError, "Trait #{set_name.inspect} must be a Hash or a lambda, got #{definition.class}"
+        end
+      end
+
+      private
+
+      def classify_dynamic(set_name, definition)
+        unknown = definition.keys - %i[dynamic using]
+        raise ArgumentError, "Dynamic trait #{set_name.inspect} has unknown options #{unknown.inspect}" if unknown.any?
+
+        properties = definition[:dynamic]
+        fn = definition[:using]
+        unless properties.is_a?(Array) && properties.all? { |property| property.is_a?(Symbol) || property.is_a?(String) }
+          raise ArgumentError, "Dynamic trait #{set_name.inspect} requires dynamic: with an Array of property names"
+        end
+        raise ArgumentError, "Dynamic trait #{set_name.inspect} requires using: with a lambda" unless fn.is_a?(Proc)
+
+        Result.new(kind: :dynamic, fn: fn, properties: properties)
+      end
+
+      def classify_hash(set_name, definition)
+        references = {}
+        members = {}
+        properties = {}
+        default = nil
+
+        definition.each do |key, value|
+          if key == :default
+            if value.is_a?(Hash)
+              raise ArgumentError,
+                    "Default for trait #{set_name.inspect} must name a member, not define styles"
+            end
+            default = value
+          elsif @conditions.breakpoint?(key) && value.is_a?(Hash)
+            raise ArgumentError,
+                  "#{key.inspect} in trait #{set_name.inspect} is a configured breakpoint, so it cannot name a " \
+                  "member. Conditions must be nested under a property, and members need a name that is not a breakpoint."
+          elsif reference_key?(key)
+            references[key] = value
+          elsif member_key?(key, value)
+            members[key] = value
+          else
+            properties[key] = value
+          end
+        end
+
+        if members.any? && (references.any? || properties.any?)
+          raise ArgumentError,
+                "Trait #{set_name.inspect} mixes enumerated members #{members.keys.inspect} with " \
+                "#{(references.keys + properties.keys).inspect}. A trait is either a list of members or a style."
+        end
+        if default && members.empty?
+          raise ArgumentError, "Trait #{set_name.inspect} has a default but no members"
+        end
+
+        if members.any?
+          Result.new(kind: :enumerated, members: members, default: default)
+        elsif references.any?
+          Result.new(kind: :combination, references: references, properties: properties)
+        else
+          Result.new(kind: :plain, properties: definition)
+        end
+      end
+
+      def reference_key?(key)
+        key.is_a?(Symbol) && (@sets.key?(key) || @inherited_sets.key?(key))
+      end
+
+      def member_key?(key, value)
+        return false unless key.is_a?(Symbol) && value.is_a?(Hash)
+        return false if Property.known?(Property.normalize_key(key))
+        return false if @conditions.condition?(key)
+
+        true
+      end
+    end
+  end
+end

data/lib/view_component/atomix/vars.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+module ViewComponent
+  module Atomix
+    class Vars
+      attr_reader :id, :names
+
+      def initialize(id, definitions)
+        self.class.validate_definitions!(definitions)
+        @id = Immutable.copy(id)
+        @names = {}
+        @refs = {}
+
+        Atomix.registry.transaction do
+          definitions.each do |key, value|
+            var = Hashing.var_name(id, key)
+            @names[key.to_sym] = var
+            @refs[key.to_sym] = "var(#{var})"
+            Atomix.registry.replace_root(var)
+            Vars.register(":root", var, value)
+          end
+        end
+
+        @names = Immutable.copy(@names)
+        @refs = Immutable.copy(@refs)
+        freeze
+      end
+
+      def [](key)
+        @refs.fetch(key.to_sym) do
+          raise KeyError, "Unknown var #{key.inspect}. Available vars: #{@refs.keys.inspect}"
+        end
+      end
+
+      def var_name(key)
+        @names.fetch(key.to_sym)
+      end
+
+      def to_h
+        @refs
+      end
+
+      def method_missing(name, *args)
+        return super unless @refs.key?(name) && args.empty?
+
+        @refs[name]
+      end
+
+      def respond_to_missing?(name, include_private = false)
+        @refs.key?(name) || super
+      end
+
+      def theme(**overrides)
+        Atomix.create_theme(self, **overrides)
+      end
+
+      def self.validate_definitions!(definitions)
+        unless definitions.is_a?(Hash)
+          raise ArgumentError, "Variable definitions must be a Hash, got #{definitions.class}"
+        end
+
+        definitions.each_key do |key|
+          next unless method_defined?(key.to_sym) || Sheet.method_defined?(key.to_sym)
+
+          raise ArgumentError, "Variable #{key.inspect} collides with a method on Vars or the styles sheet. Pick another name."
+        end
+      end
+
+      def self.register(selector, var, value, conditions = [])
+        return if value.nil?
+
+        case value
+        when Hash
+          value.each do |key, nested|
+            next if nested.nil?
+
+            if key == :default
+              register(selector, var, nested, conditions)
+            else
+              register(selector, var, nested, conditions + [Atomix.config.resolve_condition(key)])
+            end
+          end
+        else
+          Atomix.registry.add(
+            Rule.new(
+              selector: selector,
+              property: var,
+              value: Property.normalize_value(var, value),
+              conditions: conditions,
+              priority: conditions.sum(0) { |c| Property.condition_priority(c) }
+            )
+          )
+        end
+      end
+    end
+  end
+end

data/lib/view_component/atomix/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module ViewComponent
+  module Atomix
+    VERSION = "0.1.0"
+  end
+end

data/lib/view_component/atomix/weak_collection.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require "weakref"
+
+module ViewComponent
+  module Atomix
+    class WeakCollection
+      include Enumerable
+
+      def initialize
+        @references = []
+        @mutex = Mutex.new
+      end
+
+      def <<(object)
+        @mutex.synchronize do
+          compact!
+          @references << WeakRef.new(object) unless @references.any? { |reference| dereference(reference)&.equal?(object) }
+        end
+        self
+      end
+
+      def each
+        return enum_for(:each) unless block_given?
+
+        objects = @mutex.synchronize do
+          compact!
+          @references.filter_map { |reference| dereference(reference) }
+        end
+        objects.each { |object| yield object }
+        self
+      end
+
+      def delete_if
+        @mutex.synchronize do
+          @references.delete_if do |reference|
+            object = dereference(reference)
+            object.nil? || yield(object)
+          end
+        end
+        self
+      end
+
+      def clear
+        @mutex.synchronize { @references.clear }
+        self
+      end
+
+      private
+
+      def compact!
+        @references.select!(&:weakref_alive?)
+      end
+
+      def dereference(reference)
+        reference.__getobj__
+      rescue WeakRef::RefError
+        nil
+      end
+    end
+  end
+end