hecks 3.9.1 → 3.11.0

data/lib/hecks/projections/site/cms_editor/color.rb

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+module Hecks
+  module Projections
+    module Site
+      module CmsEditor
+        # Colour arithmetic for the editor's theme: parsing and writing six-digit hex, moving
+        # between red-green-blue and hue-saturation-lightness, mixing, and the contrast ratio the
+        # web accessibility guidelines define. Pure functions of their inputs, so the theme the
+        # editor is generated with is the same on every run.
+        module Color
+          # A six-digit hex colour with its leading hash.
+          HEX = /\A#[0-9a-fA-F]{6}\z/
+
+          # The step by which `reach` moves a colour's lightness while it searches.
+          STEP = 0.01
+
+          module_function
+
+          # @param value [String] a colour such as `"#1f7a6d"`
+          # @return [Array<Float>] its red, green and blue, each from 0.0 to 1.0
+          def rgb(value) = value.delete_prefix("#").scan(/../).map { |pair| pair.hex / 255.0 }
+
+          # @param channels [Array<Float>] red, green and blue, each from 0.0 to 1.0
+          # @return [String] the colour as lower-case hex
+          def hex(channels)
+            channels.each_with_object(+"#") { |c, text| text << format("%02x", (c.clamp(0.0, 1.0) * 255).round) }
+          end
+
+          # @param value [String] a colour
+          # @return [Array<Float>] hue in degrees, then saturation and lightness from 0.0 to 1.0
+          def hsl(value)
+            red, green, blue = rgb(value)
+            high = [red, green, blue].max
+            low = [red, green, blue].min
+            light = (high + low) / 2.0
+            return [0.0, 0.0, light] if high == low
+
+            spread = high - low
+            sat = light > 0.5 ? spread / (2.0 - high - low) : spread / (high + low)
+            [angle(red, green, blue, high, spread), sat, light]
+          end
+
+          # @param hue [Float] degrees
+          # @param sat [Float] saturation from 0.0 to 1.0
+          # @param light [Float] lightness from 0.0 to 1.0
+          # @return [String] the colour as hex
+          def from_hsl(hue, sat, light)
+            chroma = (1 - ((2 * light) - 1).abs) * sat
+            shift = light - (chroma / 2)
+            hex(sector(hue % 360, chroma, second(hue % 360, chroma)).map { |channel| channel + shift })
+          end
+
+          # @return [Float] the second-largest channel of a colour of the given hue and chroma
+          def second(hue, chroma) = chroma * (1 - (((hue / 60.0) % 2) - 1).abs)
+
+          # @param one [String] a colour
+          # @param other [String] another colour
+          # @param share [Float] how much of `other` goes in, from 0.0 to 1.0
+          # @return [String] the colours mixed channel by channel
+          def mix(one, other, share) = hex(rgb(one).zip(rgb(other)).map { |a, b| (a * (1 - share)) + (b * share) })
+
+          # @param value [String] a colour
+          # @return [Float] its relative luminance as the accessibility guidelines define it
+          def luminance(value)
+            red, green, blue = rgb(value).map { |c| c <= 0.03928 ? c / 12.92 : ((c + 0.055) / 1.055)**2.4 }
+            (0.2126 * red) + (0.7152 * green) + (0.0722 * blue)
+          end
+
+          # @param one [String] a colour
+          # @param other [String] another colour
+          # @return [Float] the contrast ratio, from 1.0 to 21.0
+          def contrast(one, other)
+            high = [luminance(one), luminance(other)].max
+            low = [luminance(one), luminance(other)].min
+            (high + 0.05) / (low + 0.05)
+          end
+
+          # Moves a colour's lightness, a little at a time, until it reads against every background.
+          #
+          # @param value [String] where to start
+          # @param against [Array<String>] backgrounds the colour must read on
+          # @param ratio [Float] the least contrast to reach
+          # @param toward [Symbol] `:darker` or `:lighter`
+          # @return [String] `value` itself when it already reads, else the nearest such colour
+          def reach(value, against, ratio, toward)
+            hue, sat, light = hsl(value)
+            sign = toward == :darker ? -STEP : STEP
+            light += sign until light.round(2).clamp(0.0,
+                                                     1.0) != light.round(2) || reads?(from_hsl(hue, sat, light), against, ratio)
+            from_hsl(hue, sat, light.clamp(0.0, 1.0))
+          end
+
+          # @param value [String] a colour
+          # @param against [Array<String>] backgrounds
+          # @param ratio [Float] the least contrast
+          # @return [Boolean] whether `value` reaches `ratio` on every background
+          def reads?(value, against, ratio) = against.all? { |back| contrast(value, back) >= ratio }
+
+          # @param background [String] a fill
+          # @param light [String] a light foreground to try
+          # @param dark [String] a dark foreground to try
+          # @return [String] whichever reads better on `background`
+          def foreground(background, light, dark) = contrast(light, background) >= contrast(dark, background) ? light : dark
+
+          # @return [Float] the hue, in degrees, of a colour given by its channels
+          def angle(red, green, blue, high, spread)
+            degrees = if high == red then ((green - blue) / spread) % 6
+                      elsif high == green then ((blue - red) / spread) + 2
+                      else ((red - green) / spread) + 4
+                      end
+            degrees * 60.0
+          end
+
+          # @return [Array<Float>] the red, green and blue before lightness is added back
+          def sector(hue, chroma, mid)
+            [[chroma, mid, 0], [mid, chroma, 0], [0, chroma, mid], [0, mid, chroma], [mid, 0, chroma],
+             [chroma, 0, mid]][(hue / 60).floor % 6]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/hecks/projections/site/cms_editor/composition.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Hecks
+  module Projections
+    module Site
+      module CmsEditor
+        # Several chapters as one editor: each aggregate keeps the name its chapter gave it and is
+        # stamped with the chapter that declares it, so two aggregates of one name in different
+        # chapters are two aggregates. The stamps exist only when the editor spans more than one
+        # chapter (`chapter`), or when a chapter's roles are limited (`roles`), so an editor of one
+        # open chapter reads exactly as a chapter alone does.
+        module Composition
+          module_function
+
+          # @param chapters [Array<Bluebook::Chapter>] the chapters, in the order the row names them
+          # @param skip [Array<String>] `Name` (in every chapter) or `Chapter::Name` to leave out
+          # @param roles [Hash{String => Array<String>}] the roles each chapter is limited to
+          # @yieldparam aggregate [Bluebook::Aggregate] one aggregate to shape
+          # @yieldreturn [Hash{String => Object}] the aggregate as the editor reads it
+          # @return [Array<Hash{String => Object}>] the shaped aggregates, chapter by chapter
+          def aggregates(chapters, skip:, roles:)
+            many = chapters.size > 1
+            chapters.flat_map do |chapter|
+              kept(chapter, skip).map { |agg| stamp(yield(agg), many ? chapter.name : nil, roles[chapter.name]) }
+            end
+          end
+
+          # @return [Array<Bluebook::Aggregate>] the chapter's aggregates that are not skipped
+          def kept(chapter, skip)
+            chapter.aggregates.reject { |agg| skip.intersect?([agg.hecks_name, "#{chapter.name}::#{agg.hecks_name}"]) }
+          end
+
+          # @return [Hash{String => Object}] `shaped` with its chapter and roles after its name
+          def stamp(shaped, named, roles)
+            extra = { "chapter" => named, "roles" => roles }.compact
+            { "name" => shaped["name"], **extra, **shaped.except("name") }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/hecks/projections/site/cms_editor/destructive.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module Hecks
+  module Projections
+    module Site
+      module CmsEditor
+        # Which commands the editor asks a person to confirm before it runs them, and what colour
+        # each lifecycle state's badge has.
+        #
+        # A command is destructive when its first word is one of `WORDS` (`WithdrawOffer`,
+        # `DiscardDraft`), or when it is a lifecycle move into a state named for one of `STATES`.
+        # The test reads the bluebook's own words and structure, never a list of aggregates, so a
+        # domain with a different vocabulary confirms nothing it did not name that way. A move that
+        # can be undone, such as an archive with a restore, is not destructive by that alone.
+        #
+        # A state's tone is structural: the starting state is `neutral`, a state named for a
+        # destructive word is `danger`, and the others alternate `ok` and `info` in the order the
+        # moves reach them. The badge always carries the state's name; tone is never the only cue.
+        module Destructive
+          # The first words of a command that undoes or ends something.
+          WORDS = %w[withdraw retire discard delete cancel remove].freeze
+
+          # The states those commands move into.
+          STATES = %w[withdrawn retired discarded deleted cancelled canceled removed].freeze
+
+          module_function
+
+          # @param name [String] the command's name, such as `"DiscardDraft"`
+          # @param lifecycle [Hash{String => Object}, nil] the lifecycle as `Schema` reads it
+          # @return [Boolean] whether the editor confirms the command first
+          def command?(name, lifecycle)
+            return true if WORDS.include?(words(name).first)
+
+            move = lifecycle && lifecycle["transitions"].find { |transition| transition["verb"] == name }
+            !move.nil? && STATES.include?(move["to"].downcase)
+          end
+
+          # @param lifecycle [Hash{String => Object}, nil] the lifecycle as `Schema` reads it
+          # @return [Hash{String => String}] each state's tone, empty without a lifecycle
+          def tones(lifecycle)
+            return {} unless lifecycle
+
+            states = [lifecycle["default"], *lifecycle["transitions"].flat_map { |move| [*move["from"], move["to"]] }].uniq
+            cycle = %w[ok info].cycle
+            states.to_h { |state| [state, tone(state, lifecycle["default"], cycle)] }
+          end
+
+          # @return [String] the tone of one state; `cycle` hands out `ok` and `info` in turn
+          def tone(state, default, cycle)
+            return "neutral" if state == default
+
+            STATES.include?(state.downcase) ? "danger" : cycle.next
+          end
+
+          # @return [Array<String>] the lower-case words of a CamelCase or snake_case name
+          def words(name) = name.to_s.scan(/[A-Z][a-z0-9]*|[a-z0-9]+/).map(&:downcase)
+        end
+      end
+    end
+  end
+end

data/lib/hecks/projections/site/cms_editor/drafts.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+require_relative "clearing"
+
+module Hecks
+  module Projections
+    module Site
+      module CmsEditor
+        # An aggregate that keeps a draft of its content beside the live one: the editor writes the
+        # draft as the person types and publishes it only when asked.
+        #
+        # A command on the aggregate whose every argument is `draft_<x>` (the aggregate holds
+        # both `draft_<x>` and `<x>`, of one type, and some `<x>` is a rich-text body, a block list
+        # or a value object, alone or in a list) saves the draft. A command with a
+        # `sets <x>, to: state(:draft_<x>)` mutation publishes it; one that only empties
+        # `draft_<x>` (see `Clearing`) discards it. A missing publishing or discarding command is
+        # left out.
+        module Drafts
+          # What a draft attribute's name starts with.
+          PREFIX = "draft_"
+
+          module_function
+
+          # @param agg [Bluebook::Aggregate] the aggregate
+          # @param attributes [Array<Hash{String => Object}>] its attributes as `Schema` shapes
+          #   them
+          # @return [Hash{String => String}, nil] `attribute` (the draft), `live`, `save`, and
+          #   `publish` and `discard` when the aggregate has them; nil when it keeps no drafts
+          def of(agg, attributes)
+            found = agg.commands.lazy.filter_map { |command| saving(command, agg, attributes) }.first
+            return nil unless found
+
+            found.merge("publish" => publishing(agg, found), "discard" => discarding(agg, found)).compact
+          end
+
+          # @return [Hash{String => String}, nil] the draft and live attributes `command` saves
+          def saving(command, agg, attributes)
+            return nil unless acts_on?(command, agg) && !command.attributes.empty?
+
+            lives = command.attributes.map { |argument| live_of(argument, agg) }
+            live = lives.all? ? lives.find { |name| draftable?(name, attributes) } : nil
+            live && { "attribute" => "#{PREFIX}#{live}", "live" => live, "save" => command.hecks_name }
+          end
+
+          # @return [Boolean] whether the command acts on an existing instance of the aggregate
+          def acts_on?(command, agg) = !command.creates? && command.references.to_s == agg.hecks_name
+
+          # @return [String, nil] the live attribute `argument` is the draft of, when it is one
+          def live_of(argument, agg)
+            name = argument.name.to_s
+            live = name.delete_prefix(PREFIX)
+            return nil unless name.start_with?(PREFIX) && same_type?(agg, name, live) && agg.attributes.any? do |held|
+              held.name.to_s == name
+            end
+
+            live
+          end
+
+          # @return [Boolean] whether the aggregate holds both attributes, of one type
+          def same_type?(agg, draft, live)
+            types = [draft, live].map { |name| agg.attributes.find { |held| held.name.to_s == name }&.type.to_s }
+            types.none?(&:empty?) && types.uniq.size == 1
+          end
+
+          # @return [Boolean] whether the named attribute is a rich-text body, a block list or a
+          #   value object (a page's fixed slots), alone or in a list
+          def draftable?(name, attributes)
+            attributes.any? do |attr|
+              attr["name"] == name && (attr["widget"] == "body" || attr.key?("blockList") || attr["kind"] == "object")
+            end
+          end
+
+          # @return [String, nil] the command that moves the draft into the live attribute
+          def publishing(agg, found)
+            agg.commands.find { |command| acts_on?(command, agg) && promotes?(command, found) }&.hecks_name
+          end
+
+          # @return [String, nil] the command that empties the draft and changes nothing live
+          def discarding(agg, found)
+            agg.commands.find { |command| acts_on?(command, agg) && empties?(command, agg, found) }&.hecks_name
+          end
+
+          def promotes?(command, found)
+            command.mutations.any? do |mutation|
+              mutation.target.to_s == found["live"] && mutation.source.is_a?(Hecks::StateRef) &&
+                mutation.source.name.to_s == found["attribute"]
+            end
+          end
+
+          def empties?(command, agg, found)
+            return false if command.hecks_name == found["save"] || targets_of(command) != [found["attribute"]]
+
+            clears = Clearing.of(command, agg).map { |argument| argument.name.to_s }
+            command.mutations.all? { |mutation| clears.include?(mutation.source.to_s) }
+          end
+
+          def targets_of(command) = command.mutations.map { |mutation| mutation.target.to_s }
+        end
+      end
+    end
+  end
+end

data/lib/hecks/projections/site/cms_editor/hints.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+require_relative "key_kinds"
+require_relative "moment"
+
+module Hecks
+  module Projections
+    module Site
+      module CmsEditor
+        # What one attribute's names, pattern and closed set say about how a value of it is
+        # entered: a moment (see `Moment`), a `<kind>:<slug>` key (see `KeyKinds`) or one of a
+        # closed set's members. A value object with a single plain part is entered as that part,
+        # so the part's pattern and the value object's names count; a value object of several
+        # parts has parts of its own, each read the same way.
+        class Hints
+          # @param objects [Hash{String => Bluebook::ValueObject}] the value objects by name
+          def initialize(objects)
+            @objects = objects
+          end
+
+          # @param attribute [Bluebook::Attribute] a declared attribute
+          # @return [Hash{String => Object}] `widget`, `keys` and `options` when the attribute has
+          #   them
+          def of(attribute)
+            leaf, names = leaf(attribute)
+            return {} unless leaf
+
+            { **moment(leaf, names), **keys(leaf), **options(attribute, leaf) }
+          end
+
+          private
+
+          # @return [Array(Bluebook::Attribute, Array<String>), nil] the attribute that holds the
+          #   value and the names it goes by, or nil for a reference or a value object of parts
+          def leaf(attribute)
+            return nil if attribute.type.is_a?(Bluebook::Reference)
+
+            object = @objects[attribute.type.to_s]
+            return [attribute, [attribute.name.to_s]] unless object
+
+            part = plain_part(object)
+            part && [part, [attribute.name.to_s, attribute.type.to_s, part.name.to_s]]
+          end
+
+          # @return [Bluebook::Attribute, nil] the one part of a value object that is a plain value
+          def plain_part(object)
+            part = object.attributes.first
+            part if object.attributes.size == 1 && !part.list? && !@objects.key?(part.type.to_s)
+          end
+
+          def moment(leaf, names)
+            widget = Moment.widget(names) if leaf.type.to_s == "Integer"
+            widget ? { "widget" => widget } : {}
+          end
+
+          # A value object declared a closed set (`one_of`) is entered by choosing one of its
+          # members.
+          def options(attribute, leaf)
+            object = @objects[attribute.type.to_s]
+            return {} unless object&.closed_set?
+
+            members = object.members.filter_map { |member| member[leaf.name] }.uniq
+            members.empty? ? {} : { "options" => members.map(&:to_s) }
+          end
+
+          def keys(leaf)
+            kinds = KeyKinds.of(leaf.pattern)
+            kinds.empty? ? {} : { "keys" => kinds }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/hecks/projections/site/cms_editor/icons.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+module Hecks
+  module Projections
+    module Site
+      module CmsEditor
+        # The editor's icons, drawn once here and emitted as one vector sprite
+        # (`src/ui/icons.ts`). Pages and the browser code refer to an icon by name with
+        # `<svg><use href="#i-name"/></svg>`, so there is no icon font, no request and no external
+        # file. Each is a 24 by 24 outline drawn with the current text colour.
+        module Icons
+          # Each icon's name and the drawing elements inside its symbol.
+          DRAWINGS = {
+            "menu"          => '<path d="M4 7h16M4 12h16M4 17h16"/>',
+            "close"         => '<path d="M6 6l12 12M18 6L6 18"/>',
+            "sun"           => '<circle cx="12" cy="12" r="4"/>' \
+                               '<path d="M12 3v2M12 19v2M3 12h2M19 12h2M5.6 5.6L7 7M17 17l1.4 1.4M5.6 18.4L7 17M17 7l1.4-1.4"/>',
+            "moon"          => '<path d="M20 14.5A8 8 0 019.5 4 8 8 0 1020 14.5z"/>',
+            "sign-out"      => '<path d="M10 4H5v16h5M15 8l4 4-4 4M19 12H9"/>',
+            "search"        => '<circle cx="11" cy="11" r="6"/><path d="M16 16l4 4"/>',
+            "plus"          => '<path d="M12 5v14M5 12h14"/>',
+            "copy"          => '<rect x="9" y="9" width="11" height="11" rx="2"/><path d="M5 15V6a2 2 0 012-2h8"/>',
+            "check"         => '<path d="M5 12.5l4.5 4.5L19 7.5"/>',
+            "chevron-up"    => '<path d="M6 14l6-6 6 6"/>',
+            "chevron-down"  => '<path d="M6 10l6 6 6-6"/>',
+            "chevron-right" => '<path d="M10 6l6 6-6 6"/>',
+            "arrow-up"      => '<path d="M12 19V5M6 11l6-6 6 6"/>',
+            "arrow-down"    => '<path d="M12 5v14M6 13l6 6 6-6"/>',
+            "sort"          => '<path d="M8 9l4-4 4 4M8 15l4 4 4-4"/>',
+            "trash"         => '<path d="M5 7h14M10 7V4h4v3M7 7l1 13h8l1-13M10 11v6M14 11v6"/>',
+            "pencil"        => '<path d="M5 19l1-4L16 5l3 3L9 18l-4 1zM14 7l3 3"/>',
+            "bold"          => '<path d="M7 5h6a3.5 3.5 0 010 7H7zM7 12h7a3.5 3.5 0 010 7H7z"/>',
+            "italic"        => '<path d="M10 5h8M6 19h8M14 5l-4 14"/>',
+            "underline"     => '<path d="M7 5v7a5 5 0 0010 0V5M5 20h14"/>',
+            "strike"        => '<path d="M4 12h16M16 7a4 3 0 00-4-2c-2.5 0-4 1.2-4 3s1.5 2.5 4 4 4 2 4 4-1.7 3-4.2 3' \
+                               'a5 4 0 01-4.3-2"/>',
+            "code"          => '<path d="M9 7l-5 5 5 5M15 7l5 5-5 5"/>',
+            "link"          => '<path d="M10 14a4 4 0 005.7 0l3-3a4 4 0 00-5.7-5.7l-1 1' \
+                               'M14 10a4 4 0 00-5.7 0l-3 3A4 4 0 0011 18.7l1-1"/>',
+            "unlink"        => '<path d="M10 14a4 4 0 005.7 0l3-3a4 4 0 00-5.7-5.7l-1 1' \
+                               'M14 10a4 4 0 00-5.7 0l-3 3A4 4 0 0011 18.7l1-1M4 4l16 16"/>',
+            "list-bullets"  => '<path d="M9 6h11M9 12h11M9 18h11"/><circle cx="4.5" cy="6" r="1"/>' \
+                               '<circle cx="4.5" cy="12" r="1"/><circle cx="4.5" cy="18" r="1"/>',
+            "list-numbers"  => '<path d="M10 6h10M10 12h10M10 18h10M4 5l1.5-1v4M4 11.5h3l-3 3h3M4 17.5h3v1.5H5M7 19v1.5H4"/>',
+            "indent"        => '<path d="M4 5h16M12 10h8M12 15h8M4 20h16M4 9l3 3-3 3"/>',
+            "outdent"       => '<path d="M4 5h16M12 10h8M12 15h8M4 20h16M7 9l-3 3 3 3"/>',
+            "align-left"    => '<path d="M4 6h16M4 10h10M4 14h16M4 18h10"/>',
+            "align-center"  => '<path d="M4 6h16M7 10h10M4 14h16M7 18h10"/>',
+            "align-right"   => '<path d="M4 6h16M10 10h10M4 14h16M10 18h10"/>',
+            "align-justify" => '<path d="M4 6h16M4 10h16M4 14h16M4 18h16"/>',
+            "image"         => '<rect x="4" y="5" width="16" height="14" rx="2"/><circle cx="9" cy="10" r="1.5"/>' \
+                               '<path d="M5 17l5-5 4 4 2-2 3 3"/>',
+            "divider"       => '<path d="M4 12h16M8 7h8M8 17h8" stroke-dasharray="0"/>',
+            "quote"         => '<path d="M5 17v-4a4 4 0 014-4M13 17v-4a4 4 0 014-4M5 17h4v-4H5M13 17h4v-4h-4"/>',
+            "line-break"    => '<path d="M5 6v6a3 3 0 003 3h10M14 11l4 4-4 4"/>',
+            "undo"          => '<path d="M9 7L4 12l5 5M4 12h10a5 5 0 010 10"/>',
+            "redo"          => '<path d="M15 7l5 5-5 5M20 12H10a5 5 0 000 10"/>',
+            "upload"        => '<path d="M12 16V5M7 10l5-5 5 5M5 19h14"/>',
+            "alert"         => '<path d="M12 4l9 16H3zM12 10v4M12 17v.5"/>',
+            "info"          => '<circle cx="12" cy="12" r="9"/><path d="M12 11v5M12 8v.5"/>',
+            "success"       => '<circle cx="12" cy="12" r="9"/><path d="M8 12.5l3 3 5-6"/>',
+            "clock"         => '<circle cx="12" cy="12" r="9"/><path d="M12 7v5l3 2"/>',
+            "dot"           => '<circle cx="12" cy="12" r="4"/>',
+            "inbox"         => '<path d="M4 13l2-8h12l2 8M4 13v6h16v-6M4 13h5l1 2h4l1-2h5"/>',
+            "eye"           => '<path d="M2.5 12S6 5.5 12 5.5 21.5 12 21.5 12 18 18.5 12 18.5 2.5 12 2.5 12z"/>' \
+                               '<circle cx="12" cy="12" r="3"/>',
+            "refresh"       => '<path d="M19 6v5h-5M5 18v-5h5M18.2 10A7 7 0 006 7.5M5.8 14A7 7 0 0018 16.5"/>',
+            "external"      => '<path d="M14 4h6v6M20 4l-9 9M18 14v5H5V6h5"/>',
+            "phone"         => '<rect x="7" y="3" width="10" height="18" rx="2"/><path d="M11 18h2"/>',
+            "tablet"        => '<rect x="5" y="3" width="14" height="18" rx="2"/><path d="M11 18h2"/>',
+            "desktop"       => '<rect x="3" y="4" width="18" height="12" rx="2"/><path d="M9 20h6M12 16v4"/>',
+            "calendar"      => '<rect x="4" y="5" width="16" height="15" rx="2"/><path d="M4 10h16M9 3v4M15 3v4"/>',
+            "arrow-left"    => '<path d="M19 12H5M11 6l-6 6 6 6"/>'
+          }.freeze
+
+          module_function
+
+          # @return [String] the symbols as one hidden sprite's body, each with an id `i-<name>`
+          def sprite
+            DRAWINGS.map { |name, drawing| %(<symbol id="i-#{name}" viewBox="0 0 24 24">#{drawing}</symbol>) }.join("\n")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/hecks/projections/site/cms_editor/key_kinds.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Hecks
+  module Projections
+    module Site
+      module CmsEditor
+        # The `<kind>:<slug>` key convention, read from an attribute's own `pattern:`.
+        #
+        # A key such as `post:hello` says what it names in its first part. The bluebook states the
+        # convention only when the attribute's pattern does: it must start `^kind:` or
+        # `^(kind|kind):`, with lower-case words of letters, digits and underscores. Anything
+        # else is not a convention the editor assumes.
+        module KeyKinds
+          # `^` then one word, or a group of words separated by `|`, then the `:`.
+          LEAD = /\A\^(?:\((?:\?:)?(?<kinds>\w+(?:\|\w+)*)\)|(?<kinds>\w+)):/
+
+          module_function
+
+          # @param pattern [String, nil] the attribute's declared pattern
+          # @return [Array<String>] the kinds the pattern allows before the colon; empty when none
+          def of(pattern)
+            found = LEAD.match(pattern.to_s)
+            return [] unless found
+
+            found[:kinds].split("|").grep(/\A[a-z][a-z0-9_]*\z/).uniq
+          end
+        end
+      end
+    end
+  end
+end

data/lib/hecks/projections/site/cms_editor/limits.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module Hecks
+  module Projections
+    module Site
+      module CmsEditor
+        # What a holder's rules say about how much an attribute may hold: a list's least and most
+        # rows (`chapters.size >= 1`, `parts.size <= 12`) and a text's most characters
+        # (`summary.to_s.size <= 600`). The rules are the domain's own, so the editor shows the
+        # limit it will be held to, and a text that may be long is entered in a writing box.
+        #
+        # The holder is a value object (its invariants), an aggregate (its invariants) or a command
+        # (its `given`s). A rule is read only when it is the whole of the invariant, or the whole
+        # of it after an `x.unset? ||` guard on the same part.
+        module Limits
+          # A list's size compared with a number.
+          LIST = /\A(\w+)\.size (<=|>=) (\d+)\z/
+
+          # A text's length bounded above (`to_s.size`, `size` or `length`), maybe after a guard.
+          TEXT = /\A(?:(\w+)\.unset\? \|\| )?(\w+)\.(?:to_s\.)?(?:size|length) <= (\d+)\z/
+
+          # A text that may be longer than this many characters is entered in a writing box.
+          MULTILINE_FROM = 200
+
+          module_function
+
+          # @param attributes [Array<Hash{String => Object}>] the holder's attributes as `Schema`
+          #   shapes them
+          # @param rules [Array<#canonical>] the holder's invariants or `given`s
+          # @return [Array<Hash{String => Object}>] the attributes, each with `min` and `max` when
+          #   it is a list a rule bounds, and `maxLength` (with `multiline` above `MULTILINE_FROM`)
+          #   when it is a text a rule bounds
+          def apply(attributes, rules)
+            texts = rules.map { |rule| rule.canonical.to_s }
+            lists = sizes(texts)
+            bound = lengths(texts)
+            attributes.map { |attr| attr.merge(listed(attr, lists), texted(attr, bound)) }
+          end
+
+          # @return [Hash{String => Hash{String => Integer}}] each list's `min` and `max`; where a
+          #   holder says several, the tightest wins
+          def sizes(texts)
+            texts.filter_map { |text| LIST.match(text) }.each_with_object({}) do |found, bounds|
+              held = (bounds[found[1]] ||= {})
+              kind = found[2] == "<=" ? "max" : "min"
+              held[kind] = [held[kind], found[3].to_i].compact.public_send(kind == "max" ? :min : :max)
+            end
+          end
+
+          # @return [Hash{String => Integer}] each text's most characters
+          def lengths(texts)
+            texts.filter_map { |text| TEXT.match(text) }
+                 .select { |found| found[1].nil? || found[1] == found[2] }
+                 .to_h { |found| [found[2], found[3].to_i] }
+          end
+
+          def listed(attr, lists)
+            found = attr["list"] ? lists[attr["name"]] : nil
+            found ? found.reject { |kind, size| kind == "min" && size < 1 } : {}
+          end
+
+          def texted(attr, bound)
+            most = attr["type"] == "String" && !attr["list"] ? bound[attr["name"]] : nil
+            return {} unless most
+
+            { "maxLength" => most, **(most > MULTILINE_FROM ? { "multiline" => true } : {}) }
+          end
+        end
+      end
+    end
+  end
+end