collavre 0.1.0

data/app/helpers/collavre/creatives_helper.rb

@@ -0,0 +1,343 @@
+require "base64"
+require "securerandom"
+require "nokogiri"
+
+module Collavre
+  module CreativesHelper
+    # Shared toggle button symbol helper
+    def toggle_button_symbol(expanded: false)
+      expanded ? "\u25BC" : "\u25B6" # ▼ or ▶
+    end
+
+    def render_tags(labels, class_name = nil, name_only = false)
+      return "" if labels&.empty? or labels.nil?
+
+      index = 0
+      safe_join(labels.map do |label|
+        suffix = " 🗓#{label.target_date}" if label.type == "Plan" and !name_only
+        index += 1
+        content_tag(:span, class: "tag") do
+          (index == 1 ? "" : " ").html_safe +
+          link_to("##{strip_tags(label.name)}", collavre.creatives_path(tags: [ label.id ]), class: class_name ? class_name: "", title: strip_tags(label.name)) + suffix
+        end
+      end)
+    end
+
+    def render_creative_tags(creative)
+      labels = creative.tags&.includes(:label)&.map(&:label)&.compact
+      return "" if labels&.empty?
+      content_tag(:div, class: "creative-tags", style: "display: none;") do
+        render_tags(labels, "unstyled-link", true)
+      end
+    end
+
+    def render_creative_progress(creative, select_mode: false)
+      progress_value = if params[:tags].present?
+        tag_ids = Array(params[:tags]).map(&:to_s)
+        creative.filtered_progress || creative.progress_for_tags(tag_ids) || 0
+      else
+        creative.progress
+      end
+
+      content_tag(:div, class: "creative-row-end") do
+        comment_part = if creative.has_permission?(Current.user, :feedback)
+          origin = creative.effective_origin
+          comments_count = origin.comments.size
+          pointer = CommentReadPointer.find_by(user: Current.user, creative: origin)
+          last_read_id = pointer&.last_read_comment_id
+          unread_count = last_read_id ? origin.comments.where("id > ? and private = ?", last_read_id, false).count : comments_count
+          if Current.user && CommentPresenceStore.list(origin.id).include?(Current.user.id)
+            unread_count = 0
+          end
+          classes = [ "comments-btn", "creative-action-btn" ]
+          classes << "no-comments" if comments_count.zero?
+          comment_icon = svg_tag(
+            "comment.svg",
+            class: "comment-icon"
+          )
+          badge_id = "comment-badge-#{origin.id}"
+          stream = turbo_stream_from [ Current.user, origin, :comment_badge ]
+          badge = render(
+            Inbox::BadgeComponent.new(
+              count: unread_count,
+              badge_id: badge_id,
+              show_zero: comments_count.positive?
+            )
+          )
+          stream + button_tag(
+            comment_icon + badge,
+            name: "show-comments-btn",
+            data: { creative_id: creative.id, can_comment: true, creative_snippet: creative.creative_snippet },
+            class: classes.join(" ")
+          )
+        else
+          "".html_safe
+        end
+        render_progress_value(progress_value) + comment_part + "<br />".html_safe + (creative.tags ? render_creative_tags(creative) : "".html_safe)
+      end
+    end
+
+    def render_progress_value(value)
+      text = number_to_percentage(value * 100, precision: 0)
+      if value == 1 && !Current.user&.completion_mark.nil?
+        text = Current.user.completion_mark
+      end
+      content_tag(
+        :span,
+        text,
+        class: "creative-progress-#{value == 1 ? 'complete' : 'incomplete'}"
+      )
+    end
+
+    def expanded_from_expanded_state(creative_id, expanded_state_map)
+      !!(expanded_state_map && expanded_state_map[creative_id.to_s])
+    end
+
+    def render_creative_tree_markdown(creatives, level = 1, with_progress = false)
+      return "" if creatives.blank?
+      md = ""
+      creatives.each do |creative|
+        desc = creative.effective_description(nil, true)
+        if with_progress && creative.respond_to?(:progress) && !creative.progress.nil?
+          pct = (creative.progress.to_f * 100).round
+          desc = "#{desc} (#{pct}%)"
+        end
+        raw_html = desc.gsub(/<!--.*?-->/m, "").strip
+        markdown_content = html_links_to_markdown(raw_html)
+        cleaned_markdown = markdown_content.strip
+        rendered_table_block = false
+
+        table_match = cleaned_markdown.match(/^<div[^>]*>\s*<div[^>]*>\s*(\|.*?\|(?:\n\|.*?\|)*)\s*<\/div>\s*<\/div>$/m)
+        if level <= 4 && table_match
+          table_content = table_match[1].strip
+          if markdown_table_block?(table_content)
+            md += "#{table_content}\n\n"
+            rendered_table_block = true
+          end
+        elsif level <= 4 && markdown_table_block?(cleaned_markdown)
+          md += "#{cleaned_markdown}\n\n"
+          rendered_table_block = true
+        elsif level <= 4
+          md += "#{'#' * level} #{ActionView::Base.full_sanitizer.sanitize(markdown_content).strip}\n\n"
+        else
+          inner_html = begin
+            fragment = Nokogiri::HTML.fragment(raw_html)
+            wrapper = fragment.at_css("div.trix-content")
+            if wrapper
+              wrapper.inner_html.strip
+            else
+              ActionView::Base.full_sanitizer.sanitize(markdown_content).strip
+            end
+          end
+          inner = ActionView::Base.full_sanitizer.sanitize(inner_html)
+          indent = "  " * (level - 5)
+          md += "#{indent}* #{inner}\n"
+        end
+        children = creative.linked_children
+        if children.present?
+          md += render_creative_tree_markdown(children, level + 1, with_progress)
+        end
+        md += "\n" if level <= 4 && !rendered_table_block
+      end
+      md
+    end
+
+    def markdown_links_to_html(text, image_refs = {})
+      return "" if text.nil?
+      html = text.dup
+
+      html.gsub!(/^\s*\[([^\]]+)\]:\s*<\s*(data:image\/[^>]+)\s*>\s*$/) do
+        image_refs[$1] = $2.strip
+        ""
+      end
+
+      html.gsub!(/(?<!\\)!\[([^\]]*)\]\[([^\]]+)\]/) do
+        if (data_url = image_refs[$2])
+          convert_data_image_to_attachment(data_url, $1)
+        else
+          "![#{$1}][#{$2}]"
+        end
+      end
+
+      html.gsub!(/(?<!\\)!\[([^\]]*)\]\((data:image\/[^)]+)\)/) do
+        convert_data_image_to_attachment($2, $1)
+      end
+      html.gsub!(/(?<!\\)\[([^\]]+)\]\(([^)]+)\)/) do
+        "<a href=\"#{$2}\">#{$1}</a>"
+      end
+      html.gsub!(/(?<!\\)(\*\*|__)(.+?)\1/m) do
+        "<strong>#{$2}</strong>"
+      end
+      html.gsub!(/\\([\\*_\[\]()!#~+\-])/, '\\1')
+      html.gsub!(/\\\\/, "\\")
+      html.strip!
+      html
+    end
+
+    def html_links_to_markdown(text)
+      return "" if text.nil?
+      markdown = text.dup
+      placeholders = {}
+      index = 0
+      markdown.gsub!(%r{<table\b[^>]*>.*?</table>}im) do |match|
+        token = "__TABLE#{index}__"; index += 1
+        placeholders[token] = html_table_to_markdown(match)
+        token
+      end
+      markdown.gsub!(%r{<action-text-attachment ([^>]+)>(?:</action-text-attachment>)?}) do |match|
+        attrs = Hash[$1.scan(/(\S+?)="([^"]*)"/)]
+        sgid = attrs["sgid"]
+        caption = attrs["caption"] || ""
+        if (blob = GlobalID::Locator.locate_signed(sgid, for: "attachable"))
+          data = Base64.strict_encode64(blob.download)
+          token = "__IMG#{index}__"; index += 1
+          placeholders[token] = "![#{caption}](data:#{blob.content_type};base64,#{data})"
+          token
+        else
+          ""
+        end
+      end
+      markdown.gsub!(%r{<img [^>]*src=["'](/rails/active_storage/blobs/[^"']+)["'][^>]*alt=["']([^"']*)["'][^>]*>}) do |match|
+        blob_path = $1
+        alt_text = $2
+        if blob_path =~ %r{/rails/active_storage/blobs/(?:redirect|proxy)/([^/]+)/}
+          signed_id = $1
+          begin
+            blob = ActiveStorage::Blob.find_signed(signed_id)
+            data = Base64.strict_encode64(blob.download)
+            token = "__IMG#{index}__"; index += 1
+            placeholders[token] = "![#{alt_text}](data:#{blob.content_type};base64,#{data})"
+            token
+          rescue
+            match
+          end
+        else
+          match
+        end
+      end
+      markdown.gsub!(/<img [^>]*src=['"](data:[^'"]+)['"][^>]*alt=['"]([^'"]*)['"][^>]*>/) do
+        token = "__IMG#{index}__"; index += 1
+        placeholders[token] = "![#{$2}](#{$1})"
+        token
+      end
+      markdown.gsub!(/<img [^>]*alt=['"]([^'"]*)['"][^>]*src=['"](data:[^'"]+)['"][^>]*>/) do
+        token = "__IMG#{index}__"; index += 1
+        placeholders[token] = "![#{$1}](#{$2})"
+        token
+      end
+      markdown.gsub!(/<a [^>]*href=['"]([^'"]+)['"][^>]*>(.*?)<\/a>/m) do
+        inner = ActionView::Base.full_sanitizer.sanitize($2)
+        token = "__LINK#{index}__"; index += 1
+        placeholders[token] = "[#{inner}](#{$1})"
+        token
+      end
+      markdown.gsub!(/<(strong|b)(?:\s+[^>]*)?>(.*?)<\/\1>/im) do
+        token = "__BOLD#{index}__"; index += 1
+        placeholders[token] = "**#{$2.strip}**"
+        token
+      end
+      markdown.gsub!(/([\\*\[\]()!#~+\-])/) { "\\#{$1}" }
+      placeholders.each { |k, v| markdown.gsub!(k, v) }
+      markdown.gsub!(/<[^>]+>/, "")
+      markdown
+    end
+
+    private
+
+    def markdown_table_block?(text)
+      lines = text.to_s.strip.split("\n")
+      return false if lines.length < 2
+
+      header_line = lines[0]
+      alignment_line = lines[1]
+      return false unless header_line.match?(/\A\|.*\|\z/)
+      return false unless alignment_line.match?(/\A\|[ \-:\|]+\|\z/)
+
+      true
+    end
+
+    def convert_data_image_to_attachment(data_url, alt)
+      if data_url =~ %r{\Adata:(image/[\w.+-]+);base64,(.+)\z}
+        content_type = Regexp.last_match(1)
+        data = Base64.decode64(Regexp.last_match(2))
+        ext = Mime::Type.lookup(content_type).symbol.to_s
+        filename = "import-#{SecureRandom.hex}.#{ext}"
+        blob = ActiveStorage::Blob.create_and_upload!(io: StringIO.new(data), filename: filename, content_type: content_type)
+        "<img src=\"#{Rails.application.routes.url_helpers.rails_blob_url(blob, only_path: true)}\" alt=\"#{alt}\" />"
+      else
+        "<img src=\"#{data_url}\" alt=\"#{alt}\" />"
+      end
+    end
+
+    def html_table_to_markdown(table_html)
+      fragment = Nokogiri::HTML::DocumentFragment.parse(table_html)
+      table = fragment.at_css("table")
+      return "" unless table
+
+      header_row = table.at_css("thead tr") || table.css("tr").first
+      return "" unless header_row
+
+      header_cells = header_row.css("th,td")
+      headers = header_cells.map { |cell| escape_markdown_table_cell(html_links_to_markdown(cell.inner_html).strip) }
+
+      alignments = header_cells.map { |cell| alignment_from_html_cell(cell) }
+
+      body_rows = table.css("tbody tr")
+      if body_rows.empty?
+        all_rows = table.css("tr")
+        body_rows = all_rows.drop(1)
+      end
+
+      body_lines = body_rows.map do |row|
+        cells = row.css("th,td").map { |cell| escape_markdown_table_cell(html_links_to_markdown(cell.inner_html).strip) }
+        normalized = normalize_row_cells(cells, headers.length)
+        "| #{normalized.join(' | ')} |"
+      end
+
+      alignment_cells = normalize_row_cells(alignments, headers.length).map { |align| alignment_to_markdown(align) }
+      header_line = "| #{headers.map(&:strip).join(' | ')} |"
+      alignment_line = "| #{alignment_cells.join(' | ')} |"
+
+      ([ header_line, alignment_line ] + body_lines).join("\n")
+    end
+
+    def escape_markdown_table_cell(text)
+      text.to_s.gsub(/(?<!\\)\|/, '\\|')
+    end
+
+    def alignment_from_html_cell(cell)
+      style = cell["style"].to_s
+      align = cell["align"].to_s
+      case
+      when style =~ /text-align\s*:\s*center/i || align =~ /center/i
+        :center
+      when style =~ /text-align\s*:\s*right/i || align =~ /right/i
+        :right
+      when style =~ /text-align\s*:\s*left/i || align =~ /left/i
+        :left
+      else
+        nil
+      end
+    end
+
+    def alignment_to_markdown(alignment)
+      case alignment
+      when :center
+        ":---:"
+      when :right
+        "---:"
+      when :left
+        ":---"
+      else
+        "---"
+      end
+    end
+
+    def normalize_row_cells(cells, expected_length)
+      values = cells.dup
+      values = values.first(expected_length)
+      values.fill("", values.length...expected_length)
+      values
+    end
+  end
+end

data/app/helpers/collavre/navigation_helper.rb

@@ -0,0 +1,163 @@
+# frozen_string_literal: true
+
+module Collavre
+  module NavigationHelper
+    # Get visible navigation items for a section
+    def navigation_items_for(section, desktop: true)
+      Navigation::Registry.instance
+        .items_for_section(section)
+        .select { |item| navigation_item_visible?(item, desktop: desktop) }
+    end
+
+    # Check if a navigation item should be visible
+    def navigation_item_visible?(item, desktop: true)
+      return false if desktop && !item[:desktop]
+      return false if !desktop && !item[:mobile]
+      return false if item[:requires_auth] && !authenticated?
+      return false if item[:requires_user] && Current.user.nil?
+
+      if item[:visible].is_a?(Proc)
+        return false unless resolve_nav_value(item[:visible])
+      end
+
+      true
+    end
+
+    # Render a single navigation item
+    def render_navigation_item(item, mobile: false)
+      return unless navigation_item_visible?(item, desktop: !mobile)
+
+      case item[:type]
+      when :button
+        render_nav_button(item)
+      when :link
+        render_nav_link(item)
+      when :component
+        render_nav_component(item)
+      when :partial
+        render_nav_partial(item)
+      when :divider
+        render_nav_divider(item)
+      when :raw
+        render_nav_raw(item)
+      else
+        raise ArgumentError, "Unknown navigation item type: #{item[:type]}"
+      end
+    end
+
+    def render_mobile_navigation_item(item)
+      content = render_navigation_item(item, mobile: true)
+      return if content.blank?
+      content_tag(:div, content)
+    end
+
+    def render_navigation_item_with_children(item, mobile: false)
+      return unless navigation_item_visible?(item, desktop: !mobile)
+
+      if item[:children].present?
+        render_nav_dropdown(item, mobile: mobile)
+      else
+        render_navigation_item(item, mobile: mobile)
+      end
+    end
+
+    def resolve_nav_value(value)
+      value.is_a?(Proc) ? instance_exec(&value) : value
+    end
+
+    private
+
+    def render_nav_button(item)
+      path = resolve_nav_value(item[:path])
+      label = resolve_nav_label(item[:label])
+      method = item[:method] || :get
+      html_options = build_html_options(item)
+      button_to(label, path, method: method, **html_options)
+    end
+
+    def render_nav_link(item)
+      path = resolve_nav_value(item[:path])
+      label = resolve_nav_label(item[:label])
+      html_options = build_html_options(item)
+      link_to(label, path, **html_options)
+    end
+
+    def render_nav_component(item)
+      component_class = item[:component]
+      args = resolve_component_args(item[:component_args] || {})
+      render(component_class.new(**args))
+    end
+
+    def render_nav_partial(item)
+      partial = item[:partial]
+      locals = resolve_component_args(item[:locals] || {})
+      render(partial: partial, locals: locals)
+    end
+
+    def render_nav_divider(item)
+      html_options = build_html_options(item)
+      content_tag(:hr, nil, **html_options)
+    end
+
+    def render_nav_raw(item)
+      content = resolve_nav_value(item[:content])
+      return "".html_safe if content.nil?
+      content.respond_to?(:html_safe?) && content.html_safe? ? content : ERB::Util.html_escape(content)
+    end
+
+    def render_nav_dropdown(item, mobile: false)
+      button_content = resolve_nav_value(item[:button_content]) || resolve_nav_label(item[:label])
+      menu_id = item[:menu_id] || "#{item[:key]}-menu"
+      align = item[:align] || :right
+      children = (item[:children] || []).select { |c| navigation_item_visible?(c, desktop: !mobile) }
+
+      render(PopupMenuComponent.new(
+               button_content: button_content,
+               menu_id: menu_id,
+               align: align
+             )) do
+        safe_join(children.map { |child| render_dropdown_child(child, mobile: mobile) })
+      end
+    end
+
+    def render_dropdown_child(item, mobile: false)
+      content = render_navigation_item(item, mobile: mobile)
+      return if content.blank?
+      content_tag(:div, content)
+    end
+
+    def resolve_nav_label(label)
+      return "" if label.blank?
+      if label.is_a?(String) && label.include?(".")
+        I18n.t(label, default: label)
+      else
+        label.to_s
+      end
+    end
+
+    def resolve_component_args(args)
+      deep_resolve_procs(args)
+    end
+
+    def deep_resolve_procs(value)
+      case value
+      when Proc
+        instance_exec(&value)
+      when Hash
+        value.transform_values { |v| deep_resolve_procs(v) }
+      when Array
+        value.map { |v| deep_resolve_procs(v) }
+      else
+        value
+      end
+    end
+
+    def build_html_options(item)
+      options = {}
+      options[:class] = item[:html_class] if item[:html_class]
+      options[:id] = item[:html_id] if item[:html_id]
+      options[:data] = item[:data] if item[:data]
+      options
+    end
+  end
+end

data/app/helpers/collavre/user_themes_helper.rb

@@ -0,0 +1,4 @@
+module Collavre
+  module UserThemesHelper
+  end
+end

data/app/javascript/collavre.js

@@ -0,0 +1,26 @@
+// Collavre Engine - Main Entry Point
+// This file imports all Collavre modules and exports the controller registration function
+
+// Import side-effect modules
+import "./modules/creatives"
+import "./modules/plans_timeline"
+import "./modules/creative_row_swipe"
+import "./modules/mention_menu"
+import "./modules/export_to_markdown"
+import "./modules/plans_menu"
+import "./modules/inbox_panel"
+import "./modules/creative_guide"
+import "./modules/share_modal"
+import "./modules/share_user_popup"
+import "./modules/creative_row_editor"
+import "./modules/slide_view"
+
+// Import components
+import "./components/creative_tree_row"
+
+// Import and re-export lib utilities
+import "./lib/apply_lexical_styles"
+import "./lib/turbo_stream_actions"
+
+// Export controller registration
+export { registerControllers } from "./controllers"