hecks 3.9.1 → 3.11.0

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

@@ -0,0 +1,150 @@
+# frozen_string_literal: true
+
+module Hecks
+  module Projections
+    module Site
+      module CmsEditor
+        # An aggregate whose records are actions to run later, found by shape. The editor makes
+        # and changes the records and never runs an action: a runner elsewhere does.
+        #
+        # It has a **subject** (a plain `<kind>:<slug>` key, see `KeyKinds`), an **action** from
+        # a closed set (`one_of`), a **due time** that is a moment (see `Moment`), a
+        # **lifecycle** whose first state moves to at least two states that move nowhere, and a
+        # **creating command** that takes the three. The command that reschedules takes the due
+        # time; the one that cancels is a destructive move from the first state to a final one;
+        # the reason is the first optional plain text left over; the query takes the subject
+        # alone. The first such aggregate is the one.
+        module Scheduling
+          # What a scheduling aggregate's attributes are called in its record: `subject`,
+          # `action`, `due`.
+          ROLES = %w[subject action due].freeze
+
+          # The widgets of an integer that is a moment.
+          MOMENTS = %w[date datetime].freeze
+
+          module_function
+
+          # @param aggregates [Array<Hash{String => Object}>] the aggregates as `Pickers` leaves
+          #   them
+          # @return [Hash{String => Object}, nil] the scheduling aggregate and its parts; nil when
+          #   none
+          def read(aggregates)
+            aggregates.lazy.filter_map { |agg| shape(agg) }.first
+          end
+
+          # @return [Hash{String => Object}, nil] `agg` as the scheduling aggregate, or nil
+          def shape(agg)
+            parts = parts_of(agg)
+            schedule = parts && endings(agg["lifecycle"]).size > 1 && creating(agg, parts)
+            return nil unless schedule
+
+            { "aggregate" => agg["name"], "chapter" => agg["chapter"], **parts, "pending" => agg.dig("lifecycle", "default"),
+              "schedule" => schedule["name"], **optional(agg, parts, schedule) }.compact
+          end
+
+          # @return [Hash{String => Object}, nil] the subject, action, actions and due time, or nil
+          def parts_of(agg)
+            return nil unless agg["lifecycle"]
+
+            plain = agg["attributes"].reject { |attr| attr["list"] }
+            found = [subject_of(agg, plain), plain.find { |attr| attr["options"] }, plain.find { |attr| moment?(attr) }]
+            describe(*found) if found.all?
+          end
+
+          # @return [Boolean] whether the attribute is an integer that is a moment
+          def moment?(attr) = MOMENTS.include?(attr["widget"])
+
+          # @return [Hash{String => Object}] the three attributes' names, and the action's members
+          def describe(subject, action, due)
+            { "subject" => subject["name"], "action" => action["name"], "actions" => action["options"], "due" => due["name"] }
+          end
+
+          # @return [Hash{String => Object}, nil] the attribute that is a key of a kind, the
+          #   identity last
+          def subject_of(agg, plain)
+            plain.select { |attr| attr.dig("picker", "kinds") }.min_by { |attr| attr["name"] == agg["identity"] ? 1 : 0 }
+          end
+
+          # @return [Array<String>] the final states the first state moves to: states nothing
+          #   moves out of
+          def endings(lifecycle)
+            moves = lifecycle["transitions"]
+            first = moves.select { |move| move["from"].include?(lifecycle["default"]) }.map { |move| move["to"] }.uniq
+            first - moves.flat_map { |move| move["from"] }
+          end
+
+          # @return [Hash{String => Object}, nil] the creating command that takes the subject,
+          #   action and due time
+          def creating(agg, parts)
+            agg["commands"].find { |cmd| cmd["creates"] && takes?(cmd, parts.values_at(*ROLES)) }
+          end
+
+          # @return [Boolean] whether the command takes every one of the named attributes
+          def takes?(cmd, names) = (names - cmd["attributes"].map { |attr| attr["name"] }).empty?
+
+          # @return [Hash{String => Object}] the commands, query and reason that may be missing
+          def optional(agg, parts, schedule)
+            { "reschedule" => rescheduling(agg, parts), "cancel" => cancelling(agg), "query" => querying(agg, parts),
+              "reason" => reason(agg, parts), "generated" => generated?(agg, parts, schedule) }
+          end
+
+          # @return [String, nil] the command on a record, not a lifecycle move, that takes the
+          #   due time
+          def rescheduling(agg, parts)
+            agg["commands"].find { |cmd| !cmd["creates"] && !move?(agg, cmd) && takes?(cmd, [parts["due"]]) }&.fetch("name")
+          end
+
+          # @return [String, nil] the destructive lifecycle move from the first state to a final
+          #   one
+          def cancelling(agg)
+            agg["commands"].find { |cmd| cmd["destructive"] && ends?(agg, cmd) }&.fetch("name")
+          end
+
+          # @return [String, nil] the query whose one argument is the subject
+          def querying(agg, parts)
+            agg["queries"].find { |query| query["attributes"].map { |attr| attr["name"] } == [parts["subject"]] }&.fetch("name")
+          end
+
+          # @return [Boolean] whether the command is a lifecycle move
+          def move?(agg, cmd) = agg["lifecycle"]["transitions"].any? { |move| move["verb"] == cmd["name"] }
+
+          # @return [Boolean] whether the command moves a first-state record to a final state
+          def ends?(agg, cmd)
+            lifecycle = agg["lifecycle"]
+            final = endings(lifecycle)
+            lifecycle["transitions"].any? do |move|
+              move["verb"] == cmd["name"] && move["from"].include?(lifecycle["default"]) && final.include?(move["to"])
+            end
+          end
+
+          # @return [String, nil] the first optional plain text attribute no other part uses
+          def reason(agg, parts)
+            used = [agg["identity"], *parts.values_at(*ROLES)]
+            spare = agg["attributes"].find { |attr| attr["optional"] && !used.include?(attr["name"]) && plain_text?(agg, attr) }
+            spare&.fetch("name")
+          end
+
+          # @return [Boolean] whether the attribute is one plain text, alone or as a value
+          #   object's only part
+          def plain_text?(agg, attr)
+            return false if %w[list picker options widget].any? { |key| attr[key] }
+
+            parts = agg["valueObjects"][attr["type"]]
+            parts ? lone_text?(parts) : attr["kind"] == "text"
+          end
+
+          # @return [Boolean] whether the parts are one plain text
+          def lone_text?(parts) = parts.size == 1 && parts.first["kind"] == "text" && !parts.first["list"]
+
+          # @return [true, nil] whether the creating command takes an identity that is not the
+          #   subject,
+          #   which the editor then makes itself
+          def generated?(agg, parts, schedule)
+            taken = schedule["attributes"].any? { |attr| attr["name"] == agg["identity"] }
+            true if taken && agg["identity"] != parts["subject"]
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,161 @@
+# frozen_string_literal: true
+
+require_relative "attributes"
+require_relative "blocks"
+require_relative "clearing"
+require_relative "composition"
+require_relative "destructive"
+require_relative "drafts"
+require_relative "limits"
+require_relative "media"
+require_relative "pickers"
+require_relative "relations"
+require_relative "scheduling"
+
+module Hecks
+  module Projections
+    module Site
+      module CmsEditor
+        # What the editor reads of a domain chapter, as plain data: each aggregate with its
+        # identity, attributes, value objects, lifecycle, commands and queries. The editor's
+        # `schema.ts` is this hash as a typed constant, and nothing else about the domain reaches
+        # the generated files, so the output is a pure function of the chapter.
+        #
+        # An aggregate that registers pictures (see `Media`) is also named under `media`, so the
+        # editor can offer an upload; a chapter with none has no such key.
+        #
+        # A query that `returns` a value object is answered outside the domain and is left out: the
+        # host refuses it, so a list cannot be built from it.
+        class Schema
+          # @param chapters [Bluebook::Chapter, Array<Bluebook::Chapter>] the chapter, or the
+          #   chapters in the order the row names them; the first names the domain addressed
+          # @param skip [Array<String>] aggregates to leave out: `Name`, or `Chapter::Name`
+          # @param pictures [Bluebook::Chapter, nil] another chapter whose picture aggregate the
+          #   editor's pictures use, in place of any in `chapters`
+          # @param roles [Hash{String => Array<String>}] the roles each chapter is limited to
+          # @return [Hash{String => Object}] the domain's name and its aggregates; `chapters` too
+          #   when there are several
+          # @raise [ArgumentError] when no aggregate is left, or `pictures` has no picture aggregate
+          def self.read(chapters, skip: [], pictures: nil, roles: {})
+            list = chapters.is_a?(Array) ? chapters : [chapters]
+            shaped = Composition.aggregates(list, skip: skip, roles: roles) { |agg| new(agg).to_h }
+            raise ArgumentError, "the #{list.map(&:name).join(", ")} chapter has no aggregate to edit" if shaped.empty?
+
+            media = pictures ? elsewhere(pictures) : within(shaped, list.first.name)
+            assemble(list, Relations.apply(Pickers.apply(shaped, media), media), media)
+          end
+
+          # @return [Hash{String => Object}] the schema: the domain, the chapters when several, the
+          #   aggregates, and the picture and scheduling aggregates when there are such
+          def self.assemble(list, aggregates, media)
+            chapters = list.size > 1 ? { "chapters" => list.map(&:name) } : {}
+            scheduling = Scheduling.read(aggregates)
+            { "domain" => list.first.name, **chapters, "aggregates" => aggregates, **(media ? { "media" => media } : {}),
+              **(scheduling ? { "scheduling" => scheduling } : {}) }
+          end
+
+          # The picture aggregate among the editor's own, with the chapter that holds it when that
+          # is not the first, since the host is addressed by chapter.
+          #
+          # @return [Hash{String => Object}, nil] the picture aggregate, as `Media` describes it
+          def self.within(shaped, first)
+            found = Media.read(shaped)
+            chapter = found&.delete("chapter")
+            chapter && chapter != first ? found.merge("domain" => chapter) : found
+          end
+
+          # The picture aggregate of another chapter: the same record as one in the editor's own
+          # chapter, with the chapter's name and the aggregate itself, since the editor's own
+          # aggregates do not hold it.
+          #
+          # @return [Hash{String => Object}] the picture aggregate, as `Media` describes it
+          # @raise [ArgumentError] when the chapter has no aggregate that registers pictures
+          def self.elsewhere(chapter)
+            shaped = chapter.aggregates.map { |agg| new(agg).to_h }
+            found = Media.read(shaped)
+            raise ArgumentError, "the #{chapter.name} chapter has no aggregate that registers pictures" unless found
+
+            found.merge("domain" => chapter.name, "definition" => shaped.find { |agg| agg["name"] == found["aggregate"] })
+          end
+
+          # @param aggregate [Bluebook::Aggregate] one aggregate of the chapter
+          def initialize(aggregate)
+            @agg = aggregate
+            @attributes = Attributes.new(aggregate.value_objects)
+          end
+
+          # @return [Hash{String => Object}] the aggregate as the editor reads it
+          def to_h
+            held = aggregate_attributes
+            drafts = Drafts.of(@agg, held)
+            { "name" => @agg.hecks_name, "description" => @agg.description, "identity" => @agg.identified_by.to_s,
+              "lifecycle" => lifecycle, "attributes" => held, "valueObjects" => value_objects,
+              "commands" => @agg.commands.map { |command| command(command) }, "queries" => queries,
+              **(drafts ? { "drafts" => drafts } : {}) }
+          end
+
+          private
+
+          def lifecycle_field = @agg.lifecycle&.field
+
+          # The aggregate's own attributes, bounded by the aggregate's invariants (see `Limits`).
+          def aggregate_attributes
+            bounded(attributes(@agg.attributes.reject { |a| a.name == lifecycle_field }), @agg.invariants)
+          end
+
+          def attributes(list) = list.map { |attribute| limited(@attributes.of(attribute)) }
+
+          # `list` with what the holder's rules say about the most each may hold (see `Limits`).
+          def bounded(list, rules) = Limits.apply(list, rules)
+
+          # `attr` with the most its block list may hold, when a command's `given` says.
+          def limited(attr)
+            most = attr.key?("blockList") ? Blocks.maximum(@agg.commands, attr["name"]) : nil
+            most ? attr.merge("max" => most) : attr
+          end
+
+          def value_objects
+            @agg.value_objects.to_h do |object|
+              [object.hecks_name, bounded(attributes(object.attributes), object.invariants)]
+            end
+          end
+
+          def lifecycle
+            @lifecycle ||= shaped_lifecycle
+          end
+
+          def shaped_lifecycle
+            lifecycle = @agg.lifecycle
+            return nil unless lifecycle
+
+            shaped = { "field" => lifecycle.field.to_s, "default" => lifecycle.default,
+                       "transitions" => lifecycle.transitions.map { |verb, move| transition(verb, move) } }
+            shaped.merge("tones" => Destructive.tones(shaped))
+          end
+
+          def transition(verb, move)
+            { "verb" => verb, "from" => Array(move.from), "to" => move.target }
+          end
+
+          def command(command)
+            { "name" => command.hecks_name, "goal" => command.goal, "role" => command.role, "creates" => command.creates?,
+              "on" => command.creates? ? nil : command.references.to_s,
+              "destructive" => Destructive.command?(command.hecks_name, lifecycle),
+              "attributes" => bounded(attributes(command.attributes), command.givens) }
+              .then { |shaped| clearing(shaped, command) }
+          end
+
+          # Leaves the arguments that only clear (see `Clearing`) out of the command's form, and
+          # names those that are lists as `empty`, for the editor to send as empty lists.
+          def clearing(shaped, command) = Clearing.apply(shaped, Clearing.of(command, @agg))
+
+          def queries
+            @agg.queries.reject(&:returns).map do |query|
+              { "name" => query.name, "description" => query.description, "attributes" => attributes(query.attributes) }
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+require "json"
+require_relative "../root_rows"
+require_relative "../routes_ts"
+require_relative "checks"
+require_relative "preview"
+require_relative "../../../version"
+
+module Hecks
+  module Projections
+    module Site
+      module CmsEditor
+        # The project's `Editor` row, checked: which domain chapter the editor edits, where the
+        # editor is served, the session cookie it keeps, and the host and sign-in it reads.
+        #
+        # `docs/site-routes.md` lists the fields. A project that declares no row has no editor to
+        # project.
+        class Setting
+          # The `Editor` row: its fields, which are required and what the others default to.
+          ROW = RootRows.new(
+            "Editor",
+            fields:   { domain: String, chapter: String, base_path: String, sso_path: String, session_cookie: String,
+                        host_cookie: String, host_env: String, host_default: String, roles: String, login: String,
+                        title: String, brand: String, accent: String, logo: String, skip: String, media: String,
+                        media_dir: String, media_max_bytes: String, chapter_roles: String, page_size: [String, Integer],
+                        preview: String },
+            required: %i[domain chapter host_env login],
+            defaults: { base_path: "/editor", session_cookie: "hecks_editor", host_cookie: "hecks_session",
+                        host_default: "http://127.0.0.1:4322", roles: "Admin,Owner", title: "Editor", brand: "",
+                        accent: "", logo: "", skip: "", media: "", media_dir: "media", media_max_bytes: "5242880",
+                        chapter_roles: "", page_size: "25", preview: "" }
+          )
+
+          # @return [Hash{Symbol => String}] the checked row, defaults filled
+          attr_reader :row
+
+          # Reads and checks the row a chapter declares.
+          #
+          # @param chapter [Bluebook::Chapter] the chapter that declares the route table
+          # @param table [Table, nil] the checked route table, to check the login page against
+          # @return [Setting, nil] the checked setting, or nil when the chapter declares no row
+          # @raise [Table::Invalid] when the row is refused
+          def self.read(chapter, table: nil)
+            row = ROW.read(chapter).first
+            row && new(row, table: table)
+          end
+
+          # @param row [Hash{Symbol => String}] the row, defaults filled
+          # @param table [Table, nil] the checked route table
+          # @raise [Table::Invalid] naming every problem when there is one
+          def initialize(row, table: nil)
+            @row = { sso_path: "#{row[:base_path]}/api/sso" }.merge(row, page_size: row[:page_size].to_s)
+            problems = Checks.problems(@row, roles, table)
+            return if problems.empty?
+
+            raise Table::Invalid, "the Editor row is refused:\n#{problems.map { |line| "  - #{line}" }.join("\n")}"
+          end
+
+          # @return [String] the domain's directory, relative to the project
+          def domain = row.fetch(:domain)
+
+          # @return [String] the first chapter the editor edits, which names the generated package
+          def chapter = chapters.first.to_s
+
+          # @return [Array<String>] every chapter the editor edits, in the order the row names them:
+          #   `chapter` is one name or several, comma separated
+          def chapters = row.fetch(:chapter).split(",").map(&:strip).reject(&:empty?)
+
+          # @return [Hash{String => Array<String>}] the roles a chapter's aggregates are limited to,
+          #   from `Chapter=Role,Role;Chapter=Role`; a chapter not named is open to every role the
+          #   editor admits
+          def chapter_roles
+            row.fetch(:chapter_roles).split(";").map(&:strip).reject(&:empty?).to_h do |entry|
+              name, roles = entry.split("=", 2)
+              [name.to_s.strip, roles.to_s.split(",").map(&:strip).reject(&:empty?)]
+            end
+          end
+
+          # @return [String, nil] the URL template a record is previewed at, or nil for no preview
+          def preview = row.fetch(:preview).strip.then { |template| template.empty? ? nil : template }
+
+          # @return [Integer] how many instances a list shows to a page
+          def page_size = row.fetch(:page_size).to_i
+
+          # @return [String, nil] the other chapter whose picture aggregate the editor's pictures
+          #   use, or nil when the pictures (if any) are in the editor's own chapter
+          def media_chapter = row.fetch(:media).strip.then { |name| name.empty? ? nil : name }
+
+          # @return [String, nil] the product name the header shows, or nil for the domain's name
+          def brand = row.fetch(:brand).strip.then { |name| name.empty? ? nil : name }
+
+          # @return [String, nil] the accent colour as hex, or nil for the default theme
+          def accent = row.fetch(:accent).strip.then { |hex| hex.empty? ? nil : hex }
+
+          # @return [Array<String>] the aggregates left out: `Name`, or `Chapter::Name`
+          def skip = row.fetch(:skip).split(",").map(&:strip).reject(&:empty?)
+
+          # @return [Array<String>] the roles that count as an editor
+          def roles = row.fetch(:roles).split(",").map(&:strip).reject(&:empty?)
+
+          # @return [String] the generated package's name
+          def package = "#{chapter.gsub(/([a-z])([A-Z])/, '\1-\2').tr("_", "-").downcase}-editor"
+
+          # @return [Hash{String => String}] each placeholder to the text that replaces it
+          def tokens
+            { "__BANNER__" => RoutesTs::BANNER, "__PACKAGE__" => package, "__ROLES__" => RoutesTs.literal(roles),
+              "__MEDIA_MAX_BYTES__" => row.fetch(:media_max_bytes), "__PAGE_SIZE__" => page_size.to_s,
+              "__CLIENT_VERSION__" => Hecks::VERSION, **preview_tokens, **quoted }
+          end
+
+          # @return [Hash{String => String}] the preview template as a literal, and the policy line
+          #   that lets the editor frame its origin, which is empty when there is no preview
+          def preview_tokens
+            source = Preview.frame_source(row.fetch(:preview).strip)
+            { "__PREVIEW__" => JSON.generate(preview), "__FRAME_POLICY__" => source ? "  \"frame-src #{source}\"," : "" }
+          end
+
+          # @return [Hash{String => String}] each text field's placeholder to the field as JSON
+          def quoted
+            { "TITLE" => :title, "BASE_PATH" => :base_path, "SSO_PATH" => :sso_path, "LOGIN" => :login,
+              "SESSION_COOKIE" => :session_cookie, "HOST_COOKIE" => :host_cookie, "HOST_ENV" => :host_env,
+              "HOST_DEFAULT" => :host_default, "MEDIA_DIR" => :media_dir, "LOGO" => :logo }
+              .to_h { |token, field| ["__#{token}__", JSON.generate(row.fetch(field))] }
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+module Hecks
+  module Projections
+    module Site
+      module CmsEditor
+        # The aggregates an attribute can name, found among the aggregates of one editor, and what
+        # a picker needs to know about each: its key, the attribute that labels it and the query
+        # that lists the ones to offer.
+        class Targets
+          # The attribute names that label an instance, in the order they are tried; an aggregate
+          # with none is labelled by its identity.
+          LABELS = %w[title name label].freeze
+
+          # The zero-argument queries that list what is on offer, tried in this order: ones that
+          # list everything, then the one that lists what is in use.
+          LISTINGS = %w[all list listing active].freeze
+
+          # @param aggregates [Array<Hash{String => Object}>] the aggregates as `Schema` shapes them
+          # @param media [Hash{String => Object}, nil] the picture aggregate, as `Media` says
+          def initialize(aggregates, media = nil)
+            @aggregates = aggregates
+            @media = media
+          end
+
+          # @return [Hash{String => Object}, nil] the aggregate named `name`, as a picker names it
+          def named(name, from)
+            pick(@aggregates.select { |agg| agg["name"] == name }, from)
+          end
+
+          # @return [Hash{String => Object}, nil] the aggregate whose identity is of type `stem`, or
+          #   that is named `stem`, as a picker names it
+          def keyed_by(stem, from)
+            pick(@aggregates.select { |agg| identity_type(agg) == stem }, from) || named(stem, from)
+          end
+
+          # @return [Hash{String => Object}, nil] the aggregate that is `word` in snake case
+          def kind(word, from)
+            pick(@aggregates.select { |agg| snake(agg["name"]) == word }, from)
+          end
+
+          # @return [Hash{String => Object}, nil] the picture aggregate, which offers keys and
+          #   accepts any other text as well, since a picture may be named by an address
+          def pictures
+            return nil unless @media
+
+            agg = @media["definition"] || @aggregates.find { |candidate| candidate["name"] == @media["aggregate"] }
+            return nil unless agg
+
+            described = describe(agg, agg["chapter"] || @media["domain"], @media["listing"])
+            described.merge("label" => @media.dig("fields", "alt", "name"), "strict" => false)
+          end
+
+          private
+
+          def pick(found, from)
+            own = found.select { |agg| agg["chapter"] == from["chapter"] }
+            chosen = own.first || (found.first if found.size == 1)
+            chosen && describe(chosen, chosen["chapter"], listing(chosen)).merge("strict" => true)
+          end
+
+          def describe(agg, chapter, listing)
+            { "target" => agg["name"], "chapter" => chapter, "key" => agg["identity"], "label" => label(agg),
+              "listing" => listing }.compact
+          end
+
+          def identity_type(agg)
+            agg["attributes"].find { |attr| attr["name"] == agg["identity"] }&.fetch("type", nil)
+          end
+
+          def label(agg)
+            plain = agg["attributes"].reject { |attr| attr["list"] || attr["widget"] == "body" }.map { |attr| attr["name"] }
+            LABELS.find { |name| plain.include?(name) } || agg["identity"]
+          end
+
+          def listing(agg)
+            named = agg["queries"].select { |query| query["attributes"].empty? }.map { |query| query["name"] }
+            LISTINGS.filter_map { |word| named.find { |name| name.downcase == word } }.first
+          end
+
+          def snake(name) = name.gsub(/([a-z0-9])([A-Z])/, "\\1_\\2").downcase
+        end
+      end
+    end
+  end
+end

data/lib/hecks/projections/site/cms_editor/templates/package.json.tmpl

@@ -0,0 +1,36 @@
+{
+  "name": "__PACKAGE__",
+  "private": true,
+  "type": "module",
+  "engines": {
+    "node": ">=22.18"
+  },
+  "scripts": {
+    "clean": "node -e \"fs.rmSync('dist', { recursive: true, force: true })\"",
+    "build": "npm run clean && npm run build:css && npm run build:js",
+    "build:css": "tailwindcss --input src/browser/app.css --output dist/editor.css --minify",
+    "build:js": "esbuild src/browser/main.js --bundle --splitting --format=esm --target=es2022 --minify --outdir=dist --entry-names=editor --chunk-names=[name]-[hash]",
+    "prestart": "npm run build",
+    "start": "node src/server.ts",
+    "check": "tsc -p tsconfig.json"
+  },
+  "dependencies": {
+    "@hecks/client": "^__CLIENT_VERSION__",
+    "@tiptap/core": "3.31.4",
+    "@tiptap/extension-blockquote": "3.31.4",
+    "@tiptap/extension-image": "3.31.4",
+    "@tiptap/extensions": "3.31.4",
+    "@tiptap/pm": "3.31.4",
+    "@tiptap/starter-kit": "3.31.4",
+    "tiptap-extension-flat-list": "0.4.0"
+  },
+  "devDependencies": {
+    "@tailwindcss/cli": "4.3.3",
+    "@tailwindcss/typography": "0.5.20",
+    "@types/node": "^22.10.0",
+    "daisyui": "5.7.47",
+    "esbuild": "0.28.2",
+    "tailwindcss": "4.3.3",
+    "typescript": "^5.8.0"
+  }
+}