mxrb 0.1.0

data/lib/mxrb/compiler/gallery_bundle_compiler.rb

@@ -0,0 +1,190 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module Mxrb
+  module Compiler
+    # Compiles the official React Gallery widget with XPath, microflow, or nanoflow data sources.
+    class GalleryBundleCompiler # rubocop:disable Metrics/ClassLength
+      include ModelValues
+
+      WIDGET_ID = 'com.mendix.widget.web.gallery.Gallery'
+
+      attr_reader :data_source, :entity_name
+
+      def initialize(source, page_name, widget)
+        @source = source
+        @page_name = page_name
+        @widget = widget
+        @index = document_index
+        @values = property_values(widget['Object'])
+        @data_source = WebListDataSource.new(source, widget)
+        @entity_name = data_source.entity
+        @xpath_arguments = resolve_xpath_arguments
+      end
+
+      def supported?
+        widget_type&.fetch('WidgetId', nil) == WIDGET_ID &&
+          @data_source.supported? && !entity_name.to_s.empty? && !@xpath_arguments.nil?
+      end
+
+      def content_widgets = array(@values['content']&.last&.fetch('Widgets', nil))
+      def widget_key = "p.#{@page_name}.#{@widget['Name']}"
+      def data_source_id = "p.#{Digest::SHA256.hexdigest(widget_key)[0, 6].to_i(16)}"
+
+      def render(content, nanoflow_reference: nil)
+        @nanoflow_reference = nanoflow_reference
+        values = primitives(@values).merge(
+          key: widget_key, '$widgetId': widget_key, datasource: raw(datasource),
+          content: raw("TemplatedWidgetProperty({ children: () => #{content}, " \
+                       "dataSourceId: #{JSON.generate(data_source_id)}, editable: false })"),
+          itemSelection: raw(selection), class: css_class
+        )
+        "React.createElement($Gallery, #{js_object(values)})"
+      end
+
+      private
+
+      def datasource
+        config = {
+          dataSourceId: data_source_id,
+          operationId: WebOperationCompiler.operation_id(@page_name, @widget['Name'])
+        }
+        return xpath_datasource(config) if @data_source.xpath?
+        return microflow_datasource(config) if @data_source.microflow?
+
+        nanoflow_datasource(config)
+      end
+
+      def xpath_datasource(config)
+        values = config.merge(entity: entity_name, sort: [])
+        unless @xpath_arguments.empty?
+          values[:arguments] = @xpath_arguments
+          values[:fetchOnlyWithAllParams] = true
+        end
+        "DatabaseObjectListProperty(#{js_object(values)})"
+      end
+
+      def resolve_xpath_arguments
+        return {} unless @data_source.xpath?
+
+        names = xpath_variables(@data_source.xpath_constraint)
+        return {} if names.empty?
+
+        parameters = object_page_parameters(page_document, names)
+        return unless parameters
+
+        parameters.to_h { |name, _entity| [name, ["$#{name}", :undefined, false]] }
+      end
+
+      def page_document
+        module_name, document_name = @page_name.split('.', 2)
+        @source.units_of('Forms$Page').find do |unit|
+          unit.module_name == module_name && unit.document['Name'] == document_name
+        end&.document
+      end
+
+      def microflow_datasource(config)
+        values = config.merge(argMap: {}, fetchOnlyWithAllParams: false)
+        "MicroflowObjectListProperty(#{js_object(values)})"
+      end
+
+      def nanoflow_datasource(config)
+        values = config.except(:operationId).merge(
+          source: { nanoflow: raw(@nanoflow_reference || 'undefined') },
+          argMap: {}, fetchOnlyWithAllParams: false
+        )
+        "NanoflowObjectListProperty(#{js_object(values)})"
+      end
+
+      def selection
+        type = @values['itemSelection']&.last&.fetch('Selection', 'None') || 'None'
+        "SelectionProperty(#{js_object(selectionType: type, dataSourceId: data_source_id)})"
+      end
+
+      def primitives(values)
+        values.each_with_object({}) do |(key, pair), result|
+          type, value = pair
+          compiled = primitive(type, value)
+          result[key.to_sym] = compiled unless compiled.equal?(:undefined)
+        end
+      end
+
+      def primitive(type, value) # rubocop:disable Metrics/CyclomaticComplexity
+        compiled = case type
+                   when 'Boolean' then value['PrimitiveValue'] == 'true'
+                   when 'Integer' then value['PrimitiveValue'].to_i
+                   when 'Enumeration' then value['PrimitiveValue'].to_s
+                   when 'TextTemplate' then raw(expression(translated_text(value['TextTemplate'])))
+                   when 'Widgets' then [] if array(value['Widgets']).empty?
+                   end
+        compiled.nil? ? :undefined : compiled
+      end
+
+      def expression(value)
+        "ExpressionProperty(#{js_object(expression: { expr: { type: 'literal', value: }, args: {} })})"
+      end
+
+      def raw(value) = { '$raw' => value }
+
+      def js_object(value)
+        pairs = value.map { |key, item| "#{JSON.generate(key)}: #{js_value(item)}" }
+        "{ #{pairs.join(', ')} }"
+      end
+
+      def js_value(value)
+        return value['$raw'] if value.is_a?(Hash) && value.key?('$raw')
+        return 'undefined' if value == :undefined
+        return "[#{value.map { js_value(_1) }.join(', ')}]" if value.is_a?(Array)
+        return js_object(value) if value.is_a?(Hash)
+
+        JSON.generate(value)
+      end
+
+      def property_values(object)
+        array(object&.fetch('Properties', nil)).filter_map do |property|
+          type = @index[IO::BsonCodec.extract_id(property['TypePointer'])]
+          next unless type
+
+          [type.fetch('PropertyKey'), [type.dig('ValueType', 'Type'), property['Value']]]
+        end.to_h
+      end
+
+      def css_class
+        ["mx-name-#{@widget['Name']}", @widget.dig('Appearance', 'Class')]
+          .map(&:to_s).reject(&:empty?).uniq.join(' ')
+      end
+
+      def translated_text(text)
+        items = array(text&.dig('Template', 'Items'))
+        items.find { _1['LanguageCode'] == 'en_US' }&.fetch('Text', '') ||
+          items.first&.fetch('Text', '') || ''
+      end
+
+      def widget_type
+        object_type_id = IO::BsonCodec.extract_id(@widget.dig('Object', 'TypePointer'))
+        return unless object_type_id
+
+        @index.values.find do |document|
+          IO::BsonCodec.extract_id(document.dig('ObjectType', '$ID')) == object_type_id
+        end
+      end
+
+      def document_index
+        return @source.document_index if @source.is_a?(SourceModel)
+
+        {}.tap { |index| @source.documents.each { index_document(_1, index) } }
+      end
+
+      def index_document(value, index)
+        case value
+        when Hash
+          id = IO::BsonCodec.extract_id(value['$ID'])
+          index[id] = value if id
+          value.each_value { index_document(_1, index) }
+        when Array then value.each { index_document(_1, index) }
+        end
+      end
+    end # rubocop:enable Metrics/ClassLength
+  end
+end

data/lib/mxrb/compiler/generic_widget_bundle_compiler.rb

@@ -0,0 +1,281 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'zip'
+
+module Mxrb
+  module Compiler
+    # Compiles schema-described pluggable widgets whose properties use the standard client contracts.
+    # rubocop:disable Metrics
+    class GenericWidgetBundleCompiler
+      include ModelValues
+
+      attr_reader :component_name, :module_path
+
+      def initialize(source, page_name, widget, scope:, entity:, render_widgets: nil, key_prefix: 'p',
+                     action_property: nil)
+        @source = source
+        @page_name = page_name
+        @widget = widget
+        @scope = scope
+        @entity = entity.to_s
+        @render_widgets = render_widgets
+        @key_prefix = key_prefix
+        @action_property = action_property
+        @index = source.document_index
+        @widget_type = find_widget_type
+        @values = property_values(widget['Object'])
+        @list_data_source = @values.values.find { _1.first == 'DataSource' }&.last
+        @component_name = widget_id.to_s.split('.').last
+        @module_path = widget_id.to_s.tr('.', '/')
+      end
+
+      def supported?
+        present_identifier?(@component_name) && package_module? &&
+          @values.values.all? { supported_property?(_1) }
+      end
+
+      def render
+        properties = @values.each_with_object({}) do |(key, pair), result|
+          compiled = compile_property(pair)
+          result[key.to_sym] = compiled unless compiled.equal?(:undefined)
+        end
+        properties.merge!(key: widget_key, '$widgetId': widget_key, class: css_class)
+        "React.createElement($#{@component_name}, #{javascript(properties)})"
+      end
+
+      private
+
+      def widget_id = @widget_type&.fetch('WidgetId', nil)
+
+      def find_widget_type
+        object_type_id = IO::BsonCodec.extract_id(@widget.dig('Object', 'TypePointer'))
+        @index.values.find do |document|
+          IO::BsonCodec.extract_id(document.dig('ObjectType', '$ID')) == object_type_id
+        end
+      end
+
+      def property_values(object)
+        array(object&.fetch('Properties', nil)).filter_map do |property|
+          type = @index[IO::BsonCodec.extract_id(property['TypePointer'])]
+          next unless type
+
+          [type.fetch('PropertyKey'), [type.dig('ValueType', 'Type'), property['Value']]]
+        end.to_h
+      end
+
+      def supported_property?(pair)
+        type, value = pair
+        return true if %w[Boolean Integer Decimal Enumeration String System].include?(type)
+        return value['DataSource'].nil? || !database_list_property(value).nil? if type == 'DataSource'
+        return true if type == 'Association'
+        return true if type == 'Attribute' && value['AttributeRef'].nil?
+        return true if %w[Expression TextTemplate].include?(type) && expression_property(type, value)
+        return true if type == 'Attribute' && attribute_property(value)
+        return no_action?(value) || !compiled_action(value).nil? if type == 'Action'
+        return array(value['Widgets']).empty? || @render_widgets if type == 'Widgets'
+        return array(value['Objects']).empty? if type == 'Object'
+
+        false
+      end
+
+      def compile_property(pair)
+        type, value = pair
+        case type
+        when 'Boolean' then value['PrimitiveValue'] == 'true'
+        when 'Integer' then value['PrimitiveValue'].to_i
+        when 'Decimal' then value['PrimitiveValue'].to_f
+        when 'Enumeration', 'String' then value['PrimitiveValue'].to_s
+        when 'Expression', 'TextTemplate' then raw(expression_property(type, value))
+        when 'DataSource' then database_list_property(value)&.then { raw(_1) } || :undefined
+        when 'Action' then compiled_action(value)&.then { raw(_1) } || :undefined
+        when 'Association' then :undefined
+        when 'Attribute' then attribute_property(value)&.then { raw(_1) } || :undefined
+        when 'Widgets' then compile_widgets(value)
+        when 'Object' then []
+        else :undefined
+        end
+      end
+
+      def compile_widgets(value)
+        widgets = array(value['Widgets'])
+        return [] if widgets.empty?
+
+        @render_widgets.call(widgets)
+      end
+
+      def expression_property(type, value)
+        expression = type == 'Expression' ? compile_expression(value['Expression']) : compile_template(value)
+        return unless expression
+
+        args = expression_variables(expression).to_h do |variable|
+          [variable.to_sym, { widget: @scope, source: 'object' }]
+        end
+        property = @list_data_source ? 'ListExpressionProperty' : 'ExpressionProperty'
+        config = { expression: { expr: expression, args: } }
+        config[:dataSourceId] = widget_key if @list_data_source
+        "#{property}(#{javascript(config)})"
+      end
+
+      def database_list_property(value)
+        source = value['DataSource'] || {}
+        return unless source['$Type'] == 'CustomWidgets$CustomWidgetXPathSource'
+
+        entity = source.dig('EntityRef', 'Entity').to_s
+        return unless present_qualified_name?(entity)
+
+        config = {
+          dataSourceId: widget_key, entity:,
+          operationId: WebOperationCompiler.operation_id(@page_name, @widget['Name']),
+          sort: sort_items(source)
+        }
+        "DatabaseObjectListProperty(#{javascript(config)})"
+      end
+
+      def compiled_action(value)
+        action = value['Action'] || {}
+        return if action['$Type'].to_s.empty? || action['$Type'] == 'Forms$NoAction'
+
+        @action_property&.call(action)
+      end
+
+      def sort_items(source)
+        array(source.dig('SortBar', 'SortItems')).filter_map do |item|
+          attribute = item.dig('AttributeRef', 'Attribute').to_s.split('.').last
+          next unless present_identifier?(attribute)
+
+          [attribute, item['SortOrder'].to_s.casecmp('descending').zero? ? 'desc' : 'asc']
+        end
+      end
+
+      def compile_expression(source)
+        value = source.to_s.strip
+        return { type: 'literal', value: nil } if value.empty? || value == 'empty'
+        return variable_expression(value) if value.match?(%r{\A\$[A-Za-z_]\w*(?:/[A-Za-z_]\w*)*\z})
+        return { type: 'literalNumeric', value: } if value.match?(/\A-?\d+(?:\.\d+)?\z/)
+        return { type: 'literal', value: value == 'true' } if %w[true false].include?(value)
+        return { type: 'literal', value: value[1..-2] } if quoted?(value)
+
+        nil
+      end
+
+      def variable_expression(source)
+        _variable, *path = source.delete_prefix('$').split('/')
+        { type: 'variable', variable: 'currentObject' }.tap do |result|
+          result[:path] = path.join('/') unless path.empty?
+        end
+      end
+
+      def compile_template(value)
+        template = value['TextTemplate']
+        text = translated_text(template)
+        parameters = array(template&.fetch('Parameters', nil))
+        return { type: 'literal', value: text } if parameters.empty?
+
+        expressions = parameters.map { template_parameter(_1) }
+        return unless expressions.all?
+        return expressions.first if text == '{1}' && expressions.one?
+
+        format_expression(text, expressions)
+      end
+
+      def template_parameter(parameter)
+        attribute = parameter.dig('AttributeRef', 'Attribute').to_s
+        return compile_expression(parameter['Expression']) if attribute.empty?
+
+        name = attribute.split('.').last
+        variable = { type: 'variable', variable: 'currentObject', path: name }
+        enumeration = enumeration_name(attribute)
+        return variable unless enumeration
+
+        { type: 'function', name: 'getCaption',
+          parameters: [variable, { type: 'literal', value: enumeration }] }
+      end
+
+      def format_expression(text, expressions)
+        pieces = text.split(/(\{\d+\})/).filter_map do |piece|
+          index = piece[/\A\{(\d+)\}\z/, 1]
+          index ? expressions[index.to_i - 1] : ({ type: 'literal', value: piece } unless piece.empty?)
+        end
+        pieces.compact.reduce { |left, right| { type: 'function', name: '+', parameters: [left, right] } }
+      end
+
+      def attribute_property(value)
+        attribute = value.dig('AttributeRef', 'Attribute').to_s
+        return unless @scope && attribute.include?('.')
+
+        entity, _, name = attribute.rpartition('.')
+        "AttributeProperty(#{javascript(
+          scope: @scope, path: '', entity:, attribute: name,
+          onChange: { type: 'doNothing', argMap: {}, config: {}, disabledDuringExecution: true },
+          isList: false, validation: nil, formatting: {}
+        )})"
+      end
+
+      def expression_variables(expression)
+        case expression
+        when Hash
+          own = expression[:type] == 'variable' ? [expression[:variable]] : []
+          own + expression.values.flat_map { expression_variables(_1) }
+        when Array then expression.flat_map { expression_variables(_1) }
+        else []
+        end.uniq
+      end
+
+      def enumeration_name(attribute)
+        module_name, entity_name, attribute_name = attribute.split('.', 3)
+        domain = @source.units_of('DomainModels$DomainModel').find { _1.module_name == module_name }
+        entity = array(domain&.document&.fetch('Entities', nil)).find { _1['Name'] == entity_name }
+        member = array(entity&.fetch('Attributes', nil)).find { _1['Name'] == attribute_name }
+        member&.dig('NewType', 'Enumeration').to_s.then { _1.empty? ? nil : _1 }
+      end
+
+      def translated_text(template)
+        items = array(template&.dig('Template', 'Items'))
+        items.find { _1['LanguageCode'] == 'en_US' }&.fetch('Text', '') ||
+          items.first&.fetch('Text', '') || ''
+      end
+
+      def package_module?
+        root = File.dirname(@source.path)
+        direct = File.join(root, 'widgets', "#{@module_path}.mjs")
+        return true if File.file?(direct)
+
+        entry = "#{@module_path}.mjs"
+        Dir.glob(File.join(root, 'widgets', '*.mpk')).any? do |path|
+          Zip::File.open(path) { _1.find_entry(entry) }
+        rescue Zip::Error
+          false
+        end
+      end
+
+      def no_action?(value) = value['Action'].nil? || value.dig('Action', '$Type') == 'Forms$NoAction'
+      def widget_key = "#{@key_prefix}.#{@page_name}.#{@widget['Name']}"
+
+      def css_class
+        ["mx-name-#{@widget['Name']}", @widget.dig('Appearance', 'Class')]
+          .map(&:to_s).reject(&:empty?).uniq.join(' ')
+      end
+
+      def present_identifier?(value) = value.to_s.match?(/\A[A-Za-z_$][A-Za-z0-9_$]*\z/)
+
+      def present_qualified_name?(value)
+        value.to_s.split('.').length >= 2 && value.to_s.split('.').all? { present_identifier?(_1) }
+      end
+
+      def quoted?(value) = value.start_with?("'", '"') && value.end_with?(value[0])
+      def raw(value) = { '$raw' => value }
+
+      def javascript(value)
+        return value['$raw'] if value.is_a?(Hash) && value.key?('$raw')
+        return "[#{value.map { javascript(_1) }.join(', ')}]" if value.is_a?(Array)
+        if value.is_a?(Hash)
+          return "{ #{value.map { |key, item| "#{JSON.generate(key)}: #{javascript(item)}" }.join(', ')} }"
+        end
+
+        JSON.generate(value)
+      end
+    end
+    # rubocop:enable Metrics
+  end
+end

data/lib/mxrb/compiler/image_bundle_compiler.rb

@@ -0,0 +1,216 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module Mxrb
+  module Compiler
+    # Compiles the static-image subset of the official React Image widget.
+    # rubocop:disable Metrics
+    class ImageBundleCompiler
+      include ModelValues
+
+      WIDGET_ID = 'com.mendix.widget.web.image.Image'
+
+      def self.render_static(key, css_class, uri, options) # rubocop:disable Metrics/MethodLength
+        properties = {
+          key:, '$widgetId': key, datasource: 'image',
+          imageObject: raw("WebStaticImageProperty({ image: { uri: #{JSON.generate(uri)} } })"),
+          imageUrl: raw(expression('')), isBackgroundImage: false, onClickType: 'action',
+          alternativeText: raw(expression('')), widthUnit: unit(options[:width_unit]),
+          width: number(options[:width], 100), heightUnit: unit(options[:height_unit]),
+          height: number(options[:height], 100), iconSize: 14,
+          displayAs: 'fullImage', responsive: options[:responsive], minHeightUnit: 'none', minHeight: 0,
+          maxHeightUnit: 'none', maxHeight: 0, class: css_class
+        }
+        "React.createElement($Image, #{javascript(properties)})"
+      end # rubocop:enable Metrics/MethodLength
+
+      def self.expression(value)
+        "ExpressionProperty({ expression: { expr: { type: \"literal\", value: #{JSON.generate(value)} }, args: {} } })"
+      end
+
+      def self.raw(value) = { '$raw' => value }
+      def self.unit(value) = value.to_s.downcase.then { _1.empty? ? 'auto' : _1 }
+      def self.number(value, fallback) = Integer(value || fallback)
+
+      def self.javascript(value)
+        return value['$raw'] if value.is_a?(Hash) && value.key?('$raw')
+        return "[#{value.map { javascript(_1) }.join(', ')}]" if value.is_a?(Array)
+        if value.is_a?(Hash)
+          return "{ #{value.map { |key, item| "#{JSON.generate(key)}: #{javascript(item)}" }.join(', ')} }"
+        end
+
+        JSON.generate(value)
+      end
+
+      def initialize(source, page_name, widget, scope: nil, entity: nil, key_prefix: 'p', action_property: nil)
+        @source = source
+        @page_name = page_name
+        @widget = widget
+        @scope = scope
+        @entity = entity
+        @key_prefix = key_prefix
+        @action_property = action_property
+        @index = document_index
+        @values = property_values(widget['Object'])
+      end
+
+      def supported?
+        type = widget_type
+        type && type.fetch('WidgetId', nil) == WIDGET_ID && supported_source? && supported_action?
+      end
+
+      def render # rubocop:disable Metrics/AbcSize
+        values = primitive_properties.merge(
+          key: widget_key, '$widgetId': widget_key,
+          alternativeText: self.class.raw(self.class.expression(text_value('alternativeText'))),
+          class: css_class
+        )
+        if primitive('datasource') == 'image'
+          values[:imageObject] = self.class.raw(
+            "WebStaticImageProperty({ image: { uri: #{JSON.generate(image_uri)} } })"
+          )
+          values[:imageUrl] = self.class.raw(self.class.expression(text_value('imageUrl')))
+        else
+          values[:imageUrl] = self.class.raw(dynamic_image_url)
+        end
+        action = compiled_action
+        values[:onClick] = self.class.raw(action) if action
+        "React.createElement($Image, #{self.class.javascript(values)})"
+      end # rubocop:enable Metrics/AbcSize
+
+      private
+
+      def supported_source?
+        return !image_uri.nil? if primitive('datasource') == 'image'
+
+        primitive('datasource') == 'imageUrl' && !dynamic_image_url.nil?
+      end
+
+      def supported_action?
+        pair = @values['onClick']
+        action = pair&.last&.fetch('Action', nil)
+        action.nil? || action['$Type'] == 'Forms$NoAction' || !compiled_action.nil?
+      end
+
+      def compiled_action
+        pair = @values['onClick']
+        action = pair&.last&.fetch('Action', nil)
+        return if action.nil? || action['$Type'] == 'Forms$NoAction'
+
+        @action_property&.call(action)
+      end
+
+      def dynamic_image_url
+        parameter = image_url_parameter
+        attribute = parameter&.dig('AttributeRef', 'Attribute').to_s
+        return unless @scope && attribute.include?('.')
+
+        path = array(parameter.dig('AttributeRef', 'EntityRef', 'Steps')).flat_map do |step|
+          [step['Association'], step['DestinationEntity']]
+        end.map(&:to_s).reject(&:empty?).join('/')
+        member = [path, attribute.split('.').last].reject(&:empty?).join('/')
+        config = {
+          expression: {
+            expr: { type: 'variable', variable: 'currentObject', path: member },
+            args: { currentObject: { widget: @scope, source: 'object' } }
+          }
+        }
+        "ExpressionProperty(#{self.class.javascript(config)})"
+      end
+
+      def image_url_parameter
+        template = @values['imageUrl']&.last&.fetch('TextTemplate', nil)
+        parameters = array(template&.fetch('Parameters', nil))
+        parameters.one? ? parameters.first : nil
+      end
+
+      def primitive_properties
+        @values.each_with_object({}) do |(key, (type, value)), result|
+          compiled = case type
+                     when 'Boolean' then value['PrimitiveValue'] == 'true'
+                     when 'Integer' then value['PrimitiveValue'].to_i
+                     when 'Enumeration' then value['PrimitiveValue'].to_s
+                     end
+          result[key.to_sym] = compiled unless compiled.nil?
+        end
+      end
+
+      def primitive(key)
+        pair = @values[key]
+        return unless pair
+
+        pair.last.fetch('PrimitiveValue', nil)
+      end
+
+      def text_value(key)
+        pair = @values[key]
+        return translated_text(nil) unless pair
+
+        translated_text(pair.last.fetch('TextTemplate', nil))
+      end
+
+      def image_uri # rubocop:disable Metrics/AbcSize
+        pair = @values['imageObject']
+        reference = pair ? pair.last.fetch('Image', '').to_s : ''
+        module_name, collection_name, image_name = reference.split('.', 3)
+        unit = @source.units_of('Images$ImageCollection').find do |candidate|
+          candidate.module_name == module_name && candidate.document['Name'] == collection_name
+        end
+        return unless unit
+
+        image = array(unit.document['Images']).find { _1['Name'] == image_name }
+        return unless image
+
+        "img/#{[module_name, collection_name, image_name].join('$')}.#{image_format(image)}"
+      end # rubocop:enable Metrics/AbcSize
+
+      def translated_text(template)
+        items = template ? array(template.dig('Template', 'Items')) : []
+        items.find { _1['LanguageCode'] == 'en_US' }&.fetch('Text', '') ||
+          items.first&.fetch('Text', '') || ''
+      end
+
+      def widget_key = "#{@key_prefix}.#{@page_name}.#{@widget['Name']}"
+
+      def css_class
+        ["mx-name-#{@widget['Name']}", @widget.dig('Appearance', 'Class')]
+          .map(&:to_s).reject(&:empty?).uniq.join(' ')
+      end
+
+      def property_values(object)
+        properties = object ? array(object.fetch('Properties', nil)) : []
+        properties.filter_map do |property|
+          type = @index[IO::BsonCodec.extract_id(property['TypePointer'])]
+          next unless type
+
+          [type.fetch('PropertyKey'), [type.dig('ValueType', 'Type'), property['Value']]]
+        end.to_h
+      end
+
+      def widget_type
+        object_type_id = IO::BsonCodec.extract_id(@widget.dig('Object', 'TypePointer'))
+        @index.values.find do |document|
+          IO::BsonCodec.extract_id(document.dig('ObjectType', '$ID')) == object_type_id
+        end
+      end
+
+      def document_index
+        return @source.document_index if @source.is_a?(SourceModel)
+
+        {}.tap { |index| @source.documents.each { index_document(_1, index) } }
+      end
+
+      def index_document(value, index)
+        case value
+        when Hash
+          id = IO::BsonCodec.extract_id(value['$ID'])
+          index[id] = value if id
+          value.each_value { index_document(_1, index) }
+        when Array then value.each { index_document(_1, index) }
+        end
+      end
+    end
+    # rubocop:enable Metrics
+  end
+end