hadar 0.1.0

data/lib/hadar/export/png_sequence.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "tmpdir"
+
+module Hadar
+  module Export
+    class PNGSequence
+      MAX_PIXELS = 32_000_000
+
+      def self.write(deck, directory, renderer: Renderer.new, width: 1280, height: 720)
+        raise TypeError, "deck must be a Hadar::Deck" unless deck.is_a?(Deck)
+        raise Error, "cannot export an empty deck" if deck.empty?
+        raise TypeError, "renderer must respond to build" unless renderer.respond_to?(:build)
+        raise ArgumentError, "directory must be a nonempty path" unless directory.is_a?(String) && !directory.empty?
+        unless [width, height].all? { |dimension| dimension.is_a?(Integer) && dimension.positive? } && width * height <= MAX_PIXELS
+          raise ArgumentError, "PNG dimensions must be positive integers totaling at most #{MAX_PIXELS} pixels"
+        end
+
+        output = File.expand_path(directory)
+        FileUtils.mkdir_p(output)
+        digits = [3, deck.length.to_s.length].max
+        names = deck.length.times.map { |index| format("slide-%0#{digits}d.png", index + 1) }
+        if (existing = names.find { |name| File.exist?(File.join(output, name)) || File.symlink?(File.join(output, name)) })
+          raise Error, "PNG sequence output already exists: #{existing}"
+        end
+
+        Dir.mktmpdir(".hadar-png-", output) do |staging|
+          write_frames(deck, renderer, width, height, staging, names)
+          commit_frames(output, staging, names)
+        end
+        names.map { |name| File.join(output, name) }.freeze
+      rescue SystemCallError => error
+        raise Error, "cannot write PNG sequence: #{error.message}"
+      end
+
+      def self.write_frames(deck, renderer, width, height, staging, names)
+        window = Zaniah::Platform.open_window(backend: :headless, width: width, height: height)
+        window.text_system = Zaniah::TextSystem::Renderer.new
+        deck.slides.each_with_index do |slide, index|
+          window.render(renderer.build(slide), clear: slide.theme.colors.fetch("background"))
+          window.write_png(File.join(staging, names[index]))
+        end
+      ensure
+        window&.close
+      end
+      private_class_method :write_frames
+
+      def self.commit_frames(output, staging, names)
+        created = []
+        names.each do |name|
+          target = File.join(output, name)
+          File.link(File.join(staging, name), target)
+          created << target
+        end
+      rescue SystemCallError
+        created.each { |path| File.unlink(path) if File.file?(path) }
+        raise
+      end
+      private_class_method :commit_frames
+    end
+  end
+end

data/lib/hadar/layout.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module Hadar
+  module Layout
+    Definition = Data.define(:name, :slots)
+
+    DEFINITIONS = [
+      Definition.new(:title, %i[title subtitle]),
+      Definition.new(:title_body, %i[title body]),
+      Definition.new(:two_column, %i[title left right]),
+      Definition.new(:image_text, %i[title text image]),
+      Definition.new(:full_bleed_image, %i[image]),
+      Definition.new(:quote, %i[quote attribution]),
+      Definition.new(:code, %i[title code]),
+      Definition.new(:blank, [])
+    ].freeze
+    private_constant :Definition
+
+    NAMES = DEFINITIONS.map(&:name).freeze
+    ALIASES = {
+      "title+body" => :title_body,
+      "title-body" => :title_body,
+      "two-column" => :two_column,
+      "image+text" => :image_text,
+      "image-text" => :image_text,
+      "full-bleed-image" => :full_bleed_image
+    }.freeze
+
+    def self.fetch(name)
+      normalized = normalize(name)
+      DEFINITIONS.find { |definition| definition.name == normalized } ||
+        raise(ArgumentError, "unknown slide layout: #{name.inspect}")
+    end
+
+    def self.select(nodes, requested: nil)
+      return fetch(requested).name if requested && !requested.to_s.empty?
+
+      types = nodes.map(&:type)
+      div_names = nodes.select { |node| node.type == :directive && node.attributes[:kind] == :div }
+        .map { |node| node.attributes[:name] }
+      return :two_column if div_names.include?("left") || div_names.include?("right")
+      return :quote if types.include?(:block_quote)
+      return :code if types.include?(:code_block) && (types - %i[heading code_block]).empty?
+
+      images = nodes.any? { |node| contains_type?(node, :image) }
+      text = nodes.any? { |node| text?(node) }
+      return :image_text if images && text
+      return :full_bleed_image if images
+      return :blank if nodes.empty?
+
+      headings = nodes.count { |node| node.type == :heading }
+      return :title if headings.between?(1, 2) && nodes.all? { |node| node.type == :heading }
+
+      :title_body
+    end
+
+    def self.normalize(name)
+      key = name.to_s.strip.downcase
+      ALIASES.fetch(key) { key.tr("-", "_").to_sym }
+    end
+    private_class_method :normalize
+
+    def self.contains_type?(node, type)
+      node.type == type || node.children.any? { |child| contains_type?(child, type) }
+    end
+    private_class_method :contains_type?
+
+    def self.text?(node)
+      return false if node.type == :image
+      if node.type == :text
+        text = node.attributes.fetch(:text, "")
+        return !text.strip.empty?
+      end
+      return true if %i[code_block html_block].include?(node.type)
+
+      node.children.any? { |child| text?(child) }
+    end
+    private_class_method :text?
+  end
+end

data/lib/hadar/presenter.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module Hadar
+  class Presenter
+    attr_reader :deck, :current_index, :started_at
+
+    def initialize(deck, renderer: Renderer.new, clock: Zaniah::MONOTONIC_CLOCK)
+      raise TypeError, "deck must be a Hadar::Deck" unless deck.is_a?(Deck)
+      raise TypeError, "renderer must respond to build" unless renderer.respond_to?(:build)
+      raise TypeError, "clock must be callable" unless clock.respond_to?(:call)
+
+      @deck, @renderer, @clock = deck, renderer, clock
+      @current_index = deck.empty? ? nil : 0
+    end
+
+    def start(index: current_index)
+      validate_index!(index)
+      @current_index = index
+      @started_at = @clock.call
+      self
+    end
+
+    def go_to(index)
+      validate_index!(index)
+      @current_index = index
+      self
+    end
+
+    def stop
+      @started_at = nil
+      self
+    end
+
+    def started? = !started_at.nil?
+
+    def current_slide
+      current_index && deck.slide(current_index)
+    end
+
+    def next_slide
+      return if current_index.nil? || current_index + 1 >= deck.length
+
+      deck.slide(current_index + 1)
+    end
+
+    def notes = current_slide&.notes
+
+    def elapsed_seconds
+      return 0.0 unless started?
+
+      [@clock.call - started_at, 0.0].max
+    end
+
+    def elapsed_text
+      seconds = elapsed_seconds.floor
+      format("%d:%02d", seconds / 60, seconds % 60)
+    end
+
+    def slide_view
+      return Zaniah::UI::Label.new("No slides") unless current_slide
+
+      @renderer.build(current_slide)
+    end
+
+    def presenter_view
+      following = next_slide
+      Zaniah::Div.new.flex_col.gap(12)
+        .child(Zaniah::UI::Label.new("Next slide", size: :lg))
+        .child(following ? @renderer.build(following) : Zaniah::UI::Label.new("End of deck", tone: :muted))
+        .child(Zaniah::UI::Label.new("Speaker notes", size: :lg))
+        .child(Zaniah::UI::Label.new(notes || "No speaker notes", wrap: :word))
+        .child(Zaniah::UI::Label.new("Elapsed: #{elapsed_text}", tone: :muted))
+    end
+
+    def reconcile!
+      if deck.empty?
+        @current_index = nil
+        @started_at = nil
+      else
+        @current_index = [[current_index || 0, 0].max, deck.length - 1].min
+      end
+      self
+    end
+
+    private
+
+    def validate_index!(index)
+      raise IndexError, "cannot start a presentation without slides" if deck.empty?
+      raise IndexError, "slide index is outside the deck" unless index.is_a?(Integer) && (0...deck.length).cover?(index)
+    end
+  end
+end

data/lib/hadar/renderer.rb

@@ -0,0 +1,238 @@
+# frozen_string_literal: true
+
+module Hadar
+  class Renderer
+    def initialize
+      @font_db = nil
+      @fonts = {}
+      @vocabulary = build_vocabulary
+    end
+
+    def describe(slide)
+      raise TypeError, "slide must be a Hadar::Slide" unless slide.is_a?(Slide)
+
+      children = Array(content_for(slide)).compact
+      Zaniah::Describe::Node.new(:slide, {
+        background: slide_theme(slide).colors.fetch("background"),
+        margin: slide_theme(slide).spacing.fetch("margin"),
+        gap: slide_theme(slide).spacing.fetch("gap")
+      }, children, "slide-#{slide.index}")
+    end
+
+    def build(slide)
+      Zaniah::Describe.build(describe(slide), vocabulary: @vocabulary,
+        on_event: ->(_id, _payload) {})
+    end
+
+    def surface(slide)
+      Zaniah::Describe::Surface.new(vocabulary: @vocabulary,
+        on_event: ->(_id, _payload) {}).replace(describe(slide))
+    end
+
+    private
+
+    def build_vocabulary
+      db = self
+      Zaniah::Describe::Vocabulary.build do
+        node :slide, props: {background: :string, margin: :number, gap: :number} do |props, children|
+          Zaniah::Element.new.flex_col.w_full.h_full.bg(props.fetch(:background))
+            .p(props.fetch(:margin)).style(gap: props.fetch(:gap)).children(children)
+        end
+        node :stack, props: {gap: :number} do |props, children|
+          Zaniah::Element.new.flex_col.style(gap: props.fetch(:gap)).children(children)
+        end
+        node :columns, props: {gap: :number} do |props, children|
+          Zaniah::Element.new.flex_row.style(gap: props.fetch(:gap)).children(children)
+        end
+        node :text, props: {text: :string, size: :number, color: :string,
+          family: :string}, children: :none do |props, _children|
+          font = db.send(:font, props.fetch(:family))
+          Zaniah::Text.new(props.fetch(:text), size: props.fetch(:size),
+            color: props.fetch(:color), font: font, wrap: :word)
+        end
+        node :image, props: {path: :string}, children: :none do |props, _children|
+          path = props.fetch(:path)
+          begin
+            Zaniah::Image.new(path).w_full
+          rescue StandardError => error
+            raise Error, "cannot render image #{path.inspect}: #{error.message}"
+          end
+        end
+        node :table, props: {rows: :array, alignments: :array, size: :number,
+          family: :string, text_color: :string, header_color: :string, border_color: :string}, children: :none do |props, _children|
+          rows = props.fetch(:rows).each_with_index.map do |row, row_index|
+            cells = row.each_with_index.map do |value, column|
+              alignment = {left: :start, center: :center, right: :end}[props.fetch(:alignments)[column]] || :start
+              color = row_index.zero? ? props.fetch(:header_color) : props.fetch(:text_color)
+              Zaniah::Text.new(value, size: props.fetch(:size), color: color,
+                font: db.send(:font, props.fetch(:family)), wrap: :word, align: alignment)
+                .flex_1.p(6).border(1).border_color(props.fetch(:border_color))
+            end
+            Zaniah::Element.new.flex_row.w_full.children(cells)
+          end
+          Zaniah::Element.new.flex_col.w_full.children(rows)
+        end
+        node :code_block, props: {language: :string} do |_props, children|
+          Zaniah::Element.new.flex_col.w_full.children(children)
+        end
+        node :code_line, props: {} do |_props, children|
+          Zaniah::Element.new.flex_row.children(children)
+        end
+        node :code_token, props: {text: :string, color: :string, size: :number}, children: :none do |props, _children|
+          Zaniah::Text.new(props.fetch(:text), size: props.fetch(:size), color: props.fetch(:color),
+            font: db.send(:font, "monospace"), wrap: :none)
+        end
+      end
+    end
+
+    def font(family)
+      @fonts[family] ||= begin
+        @font_db ||= Zaniah::TextSystem::FontDB.new
+        @font_db.find(family: family == "sans-serif" ? nil : family)
+      end
+    end
+
+    def content_for(slide)
+      theme = slide_theme(slide)
+      gap = theme.spacing.fetch("gap")
+      case slide.layout
+      when :title
+        stack([
+          text_node(slide.slot(:title).text, theme.font.fetch("title_size"), theme),
+          text_node(slide.slot(:subtitle).text, theme.font.fetch("body_size"), theme, color: theme.colors.fetch("muted"))
+        ].reject(&:nil?), gap)
+      when :two_column
+        heading = text_node(slide.slot(:title).text, theme.font.fetch("title_size"), theme)
+        columns = node(:columns, {gap: gap}, [
+          stack(render_blocks(slide.slot(:left), theme), gap),
+          stack(render_blocks(slide.slot(:right), theme), gap)
+        ])
+        [heading, columns].compact
+      when :image_text
+        [text_node(slide.slot(:title).text, theme.font.fetch("title_size"), theme),
+          *render_blocks(slide.slot(:text), theme),
+          image_node(slide.slot(:image))].compact
+      when :full_bleed_image
+        [image_node(slide.slot(:image))].compact
+      when :quote
+        [*text_nodes(slide.slot(:quote).text, theme, size: theme.font.fetch("title_size")),
+          *text_nodes(slide.slot(:attribution).text, theme, size: theme.font.fetch("body_size"), color: theme.colors.fetch("muted"))]
+      when :code
+        [text_node(slide.slot(:title).text, theme.font.fetch("title_size"), theme),
+          *render_blocks(slide.slot(:code), theme)].compact
+      when :blank
+        []
+      else
+        [text_node(slide.slot(:title).text, theme.font.fetch("title_size"), theme),
+          *render_blocks(slide.slot(:body), theme)].compact
+      end
+    end
+
+    def render_blocks(slot, theme)
+      table_index = code_index = 0
+      slot.nodes.flat_map do |source_node|
+        case source_node.type
+        when :table
+          result = table_node(slot, source_node, table_index, theme)
+          table_index += 1
+          [result]
+        when :code_block
+          result = code_node(slot, source_node, code_index, theme)
+          code_index += 1
+          [result]
+        else
+          text_nodes(slot.text_for(source_node), theme)
+        end
+      end
+    end
+
+    def table_node(slot, source_node, index, theme)
+      node(:table, {
+        rows: slot.table_rows(table: index),
+        alignments: source_node.attributes.fetch(:alignments, []),
+        size: theme.font.fetch("body_size"),
+        family: theme.font.fetch("family"),
+        text_color: theme.colors.fetch("text"),
+        header_color: theme.colors.fetch("accent"),
+        border_color: theme.colors.fetch("muted")
+      }, [], "slide-#{slot.slide_index}-table-#{index}")
+    end
+
+    def code_node(slot, source_node, index, theme)
+      source = slot.text_for(source_node)
+      language = source_node.attributes.fetch(:info, "").split.first.to_s
+      lines = source.scan(/.*?(?:\r\n|\r|\n|\z)/m).reject(&:empty?)
+      lines = [""] if lines.empty?
+      lexer = language.empty? ? nil : Rouge::Lexer.find(language)
+      rows = code_tokens(lines, lexer)
+      line_nodes = rows.each_with_index.map do |tokens, line_index|
+        line = lines.fetch(line_index)
+        body = line.sub(/\r\n\z|\r\z|\n\z/, "")
+        visible_bytes = body.bytesize
+        offset = 0
+        token_nodes = tokens.filter_map do |kind, text|
+          size = [text.bytesize, visible_bytes - offset].min
+          offset += text.bytesize
+          next if size <= 0
+
+          node(:code_token, {text: text.byteslice(0, size), color: token_color(kind, theme),
+            size: theme.font.fetch("body_size")}, [])
+        end
+        token_nodes << node(:code_token, {text: " ", color: theme.colors.fetch("text"),
+          size: theme.font.fetch("body_size")}, []) if token_nodes.empty?
+        node(:code_line, {}, token_nodes, "line-#{line_index}")
+      end
+      node(:code_block, {language: language}, line_nodes, "slide-#{slot.slide_index}-code-#{index}")
+    end
+
+    def code_tokens(lines, lexer)
+      return lines.map { |line| [[nil, line]] } unless lexer
+
+      lexer_lines = lines.map do |line|
+        line.match?(/(?:\r\n|\r|\n)\z/) ? line.sub(/\r\n\z|\r\z|\n\z/, "\n") : line
+      end
+      highlighter = Antares::Highlighter.new(lexer: lexer.new,
+        lines: ->(index) { lexer_lines.fetch(index) }, line_count: -> { lexer_lines.length })
+      lexer_lines.each_index.map { |index| highlighter.tokens_for(index) }
+    end
+
+    def token_color(kind, theme)
+      name = kind&.qualname.to_s
+      return theme.colors.fetch("muted") if name.start_with?("Comment")
+      return theme.colors.fetch("accent") if name.start_with?("Keyword", "Literal.Number", "Literal.String", "Name.Builtin")
+
+      theme.colors.fetch("text")
+    end
+
+    def text_nodes(text, theme, size: theme.font.fetch("body_size"), color: theme.colors.fetch("text"), family: theme.font.fetch("family"))
+      return [] if text.nil? || text.empty?
+
+      text.split(/\n+/).reject(&:empty?).map do |part|
+        text_node(part, size, theme, color: color, family: family)
+      end
+    end
+
+    def text_node(text, size, theme, color: theme.colors.fetch("text"), family: theme.font.fetch("family"))
+      return if text.nil? || text.empty?
+
+      node(:text, {text: text, size: size, color: color, family: family}, [])
+    end
+
+    def stack(children, gap)
+      node(:stack, {gap: gap}, children)
+    end
+
+    def node(type, props, children, key = nil)
+      Zaniah::Describe::Node.new(type, props, children, key)
+    end
+
+    def image_node(slot)
+      return if slot.empty?
+
+      path = slot.resolved_image_path
+      node(:image, {path: path}, [], "slide-#{slot.slide_index}-#{slot.name}-image")
+    end
+
+    def slide_theme(slide) = slide.theme
+  end
+end

data/lib/hadar/rich_text_projection.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+module Hadar
+  class RichTextProjection
+    Segment = Data.define(:start, :finish, :text, :node, :style, :wrappers, :list_item, :list_level)
+    attr_reader :document, :text, :segments, :list_context, :paragraph_styles
+
+    def initialize(slot)
+      @document = slot.document
+      @list_context = {}
+      @parts = join(slot.nodes.map { |node| project(node, {}, [], -1, nil) }, "\n")
+      @text = @parts.map(&:first).join.freeze
+      offset = 0
+      @segments = @parts.map do |part, node, style, wrappers, list_item, list_level|
+        segment = Segment.new(offset, offset + part.bytesize, part, node, style.freeze, wrappers.freeze, list_item, list_level)
+        offset += part.bytesize
+        segment
+      end.freeze
+      @paragraph_styles = Array.new(@text.count("\n") + 1) { {} }
+      @segments.each do |segment|
+        next unless segment.list_level
+
+        first = @text.byteslice(0...segment.start).to_s.count("\n")
+        last = @text.byteslice(0...segment.finish).to_s.count("\n")
+        (first..last).each { |line| @paragraph_styles[line] = {level: segment.list_level} }
+      end
+      raise Error, "slot content is not representable as rich text" unless @text == slot.text
+    end
+
+    def build(editable: true)
+      runs = @parts.map { |part, _node, style, _wrappers, _item, _level| {text: part, **style} }
+      value = Zaniah::UI::RichText.new(runs, selectable: true, editable: editable)
+      line_start = 0
+      @paragraph_styles.each_with_index do |style, index|
+        line_end = @text.b.index("\n".b, line_start) || @text.bytesize
+        value.paragraph_style(line_start...line_end, level: style[:level]) if style.key?(:level)
+        line_start = line_end + 1
+      end
+      value
+    end
+
+    def replace(value)
+      RichTextWriteback.new(self, value).replace
+    end
+
+    private
+
+    def project(node, style, wrappers, list_level, parent_item)
+      case node.type
+      when :text
+        leaf(node.attributes.fetch(:text, ""), node, style, wrappers, parent_item, list_level)
+      when :code_span
+        leaf(node.attributes.fetch(:text, ""), node, style.merge(font: "monospace"), wrappers, parent_item, list_level)
+      when :image
+        leaf(node.attributes.fetch(:label, ""), node, style, wrappers, parent_item, list_level)
+      when :break, :softbreak
+        leaf("\n", node, style, wrappers, parent_item, list_level)
+      when :strong
+        children(node.children, style.merge(bold: true), wrappers + [[:bold, node]], list_level, parent_item)
+      when :emphasis
+        children(node.children, style.merge(italic: true), wrappers + [[:italic, node]], list_level, parent_item)
+      when :link
+        children(node.children, style.merge(link: node.attributes.fetch(:destination)), wrappers, list_level, parent_item)
+      when :paragraph, :heading
+        children(node.children, style, wrappers, list_level, parent_item)
+      when :block_quote
+        join(node.children.map { |child| project(child, style, wrappers, list_level, parent_item) }, "\n")
+      when :list, :ordered_list
+        level = list_level + 1
+        items = node.children.each_with_index.map do |item, index|
+          @list_context[item.object_id] = {level: level, list: node, previous: node.children[index - 1],
+            parent: parent_item}
+          marker = if item.attributes[:task]
+            item.attributes[:checked] ? "☑ " : "☐ "
+          elsif item.attributes[:ordered]
+            "#{item.attributes[:start] || index + 1}. "
+          else
+            "• "
+          end
+          [[marker, item, {}, [], item, level], *project(item, style, wrappers, level, item)]
+        end
+        join(items, "\n")
+      when :list_item
+        join(node.children.map { |child| project(child, style, wrappers, list_level, node) }, "\n")
+      when :footnote_reference, :task_checkbox, :front_matter, :directive, :thematic_break
+        []
+      when :strikethrough
+        raise Error, "strikethrough has no Zaniah rich-text style"
+      else
+        raise Error, "#{node.type} slots are not supported by rich-text editing"
+      end
+    end
+
+    def children(nodes, style, wrappers, list_level, parent_item)
+      nodes.flat_map { |node| project(node, style, wrappers, list_level, parent_item) }
+    end
+
+    def leaf(text, node, style, wrappers, list_item, list_level)
+      text.empty? ? [] : [[text, node, style, wrappers, list_item, list_item ? list_level : nil]]
+    end
+
+    def join(groups, separator)
+      groups.reject { |parts| parts.empty? || parts.all? { |part, _node, _style, _wrappers, _item, _level| part.empty? } }
+        .each_with_object([]) do |parts, result|
+          result << [separator, nil, {}, [], nil, nil] unless result.empty?
+          result.concat(parts)
+        end
+    end
+  end
+end