@emeryld/rrroutes-export 1.0.20 → 1.0.21

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@emeryld/rrroutes-export",
   "description": "Finalized leaves export helpers and CLI for RRRoutes",
-  "version": "1.0.20",
+  "version": "1.0.21",
   "private": false,
   "type": "module",
   "main": "dist/index.cjs",

package/tools/finalized-leaves-viewer.html

@@ -378,6 +378,22 @@
         gap: 4px;
       }
 
+      .changelog-commit-separator {
+        margin-top: 12px;
+        padding-top: 10px;
+        border-top: 1px solid var(--accent);
+      }
+
+      .changelog-commit-separator:first-child {
+        margin-top: 0;
+      }
+
+      .changelog-commit-label {
+        color: var(--accent);
+        font-weight: 700;
+        font-size: 12px;
+      }
+
       .changelog-diff-line {
         display: flex;
         flex-wrap: wrap;
@@ -1758,21 +1774,96 @@
         return `${type}${schemaFlags(Boolean(entry.nullable), Boolean(entry.optional))}`
       }
 
+      function splitTypeOptions(type) {
+        if (typeof type !== 'string' || !type.includes('|')) return []
+        return type
+          .split('|')
+          .map((item) => item.trim())
+          .filter(Boolean)
+      }
+
+      function hasDefinedLiteral(entry) {
+        return (
+          entry &&
+          typeof entry === 'object' &&
+          Object.prototype.hasOwnProperty.call(entry, 'literal') &&
+          entry.literal !== undefined
+        )
+      }
+
+      function reduceEnumTypeDiff(beforeEntry, afterEntry) {
+        if (!beforeEntry || !afterEntry) return null
+        if (hasDefinedLiteral(beforeEntry) || hasDefinedLiteral(afterEntry)) {
+          return null
+        }
+
+        const beforeOptions = splitTypeOptions(beforeEntry.type)
+        const afterOptions = splitTypeOptions(afterEntry.type)
+        if (beforeOptions.length === 0 || afterOptions.length === 0) return null
+
+        const afterSet = new Set(afterOptions)
+        const beforeSet = new Set(beforeOptions)
+        const beforeOnly = beforeOptions.filter((option) => !afterSet.has(option))
+        const afterOnly = afterOptions.filter((option) => !beforeSet.has(option))
+        if (beforeOnly.length === 0 && afterOnly.length === 0) return null
+
+        const beforeType = `${beforeOnly.join('|') || 'none'}${schemaFlags(
+          Boolean(beforeEntry.nullable),
+          Boolean(beforeEntry.optional),
+        )}`
+        const afterType = `${afterOnly.join('|') || 'none'}${schemaFlags(
+          Boolean(afterEntry.nullable),
+          Boolean(afterEntry.optional),
+        )}`
+        return { beforeType, afterType }
+      }
+
       function formatPathLabel(path) {
         const basePath = typeof path === 'string' ? path : ''
         return basePath
       }
 
-      function parseSignatureTypeLabel(signature) {
+      function parseSignatureEntry(signature) {
         if (typeof signature !== 'string') return null
         const typeMatch = signature.match(/(?:^|,\s*)type=([^,]+)/)
-        const nullableMatch = signature.match(/(?:^|,\s*)nullable=(true|false)/)
-        const optionalMatch = signature.match(/(?:^|,\s*)optional=(true|false)/)
-        if (!typeMatch) return null
-        const type = typeMatch[1]
-        const nullable = nullableMatch?.[1] === 'true'
-        const optional = optionalMatch?.[1] === 'true'
-        return `${type}${schemaFlags(nullable, optional)}`
+        if (typeMatch) {
+          const nullableMatch = signature.match(
+            /(?:^|,\s*)nullable=(true|false)/,
+          )
+          const optionalMatch = signature.match(
+            /(?:^|,\s*)optional=(true|false)/,
+          )
+          return {
+            type: typeMatch[1],
+            nullable: nullableMatch?.[1] === 'true',
+            optional: optionalMatch?.[1] === 'true',
+            literal: undefined,
+          }
+        }
+        try {
+          const parsed = JSON.parse(signature)
+          if (!parsed || typeof parsed !== 'object') return null
+          if (typeof parsed.type !== 'string') return null
+          return {
+            type: parsed.type,
+            nullable: Boolean(parsed.nullable),
+            optional: Boolean(parsed.optional),
+            literal: Object.prototype.hasOwnProperty.call(parsed, 'literal')
+              ? parsed.literal
+              : undefined,
+          }
+        } catch {
+          return null
+        }
+      }
+
+      function parseSignatureTypeLabel(signature) {
+        const entry = parseSignatureEntry(signature)
+        if (!entry) return null
+        return `${entry.type}${schemaFlags(
+          Boolean(entry.nullable),
+          Boolean(entry.optional),
+        )}`
       }
 
       function formatSourceTypeLabel(signatures) {
@@ -1784,6 +1875,18 @@
         return labels.join(' | ')
       }
 
+      function formatSourceChangedTypes(beforeSignatures, afterSignatures) {
+        if (!Array.isArray(beforeSignatures) || !Array.isArray(afterSignatures)) {
+          return null
+        }
+        if (beforeSignatures.length !== 1 || afterSignatures.length !== 1) {
+          return null
+        }
+        const beforeEntry = parseSignatureEntry(beforeSignatures[0])
+        const afterEntry = parseSignatureEntry(afterSignatures[0])
+        return reduceEnumTypeDiff(beforeEntry, afterEntry)
+      }
+
       function schemaDiffOperation(op) {
         if (op === 'added') {
           return { symbol: '+', word: 'added', className: 'added' }
@@ -1839,8 +1942,9 @@
               `removed ${location}: ${JSON.stringify(delta.before || [])}`,
             )
           }
-          const beforeType = formatSourceTypeLabel(delta.before)
-          const afterType = formatSourceTypeLabel(delta.after)
+          const reducedTypes = formatSourceChangedTypes(delta.before, delta.after)
+          const beforeType = reducedTypes?.beforeType || formatSourceTypeLabel(delta.before)
+          const afterType = reducedTypes?.afterType || formatSourceTypeLabel(delta.after)
           if (beforeType || afterType) {
             return buildSchemaDiffLine(
               delta.op,
@@ -1871,8 +1975,11 @@
               `removed ${delta.path}: ${formatRouteSchemaEntry(delta.before)}`,
             )
           }
-          const beforeType = formatEntryTypeLabel(delta.before) || 'unknown'
-          const afterType = formatEntryTypeLabel(delta.after) || 'unknown'
+          const reducedTypes = reduceEnumTypeDiff(delta.before, delta.after)
+          const beforeType =
+            reducedTypes?.beforeType || formatEntryTypeLabel(delta.before) || 'unknown'
+          const afterType =
+            reducedTypes?.afterType || formatEntryTypeLabel(delta.after) || 'unknown'
           const pathLabel =
             formatPathLabel(delta.path) || delta.path
           return buildSchemaDiffLine(delta.op, beforeType, pathLabel, afterType)
@@ -1899,10 +2006,14 @@
       function eventVisualByType(type) {
         switch (type) {
           case 'route_added':
-            return { actionText: 'added', actionClass: 'event-action-added', icon: 'route' }
+            return {
+              actionText: 'added route',
+              actionClass: 'event-action-added',
+              icon: 'route',
+            }
           case 'route_removed':
             return {
-              actionText: 'removed',
+              actionText: 'removed route',
               actionClass: 'event-action-removed',
               icon: 'route',
             }
@@ -1919,18 +2030,22 @@
               icon: 'config',
             }
           case 'source_object_added':
-            return { actionText: 'added', actionClass: 'event-action-added', icon: 'source' }
+            return {
+              actionText: 'added source object',
+              actionClass: 'event-action-added',
+              icon: 'source',
+            }
           case 'source_object_removed':
             return {
-              actionText: 'removed',
+              actionText: 'removed source object',
               actionClass: 'event-action-removed',
               icon: 'source',
             }
           case 'source_schema_changed':
             return {
-              actionText: 'modified source object',
+              actionText: 'modified schema',
               actionClass: 'event-action-modified',
-              icon: 'source',
+              icon: 'schema',
             }
           default:
             return {
@@ -2038,6 +2153,34 @@
           .join(' - ')
       }
 
+      function renderCommitSeparator(commitSha, commitBySha) {
+        const box = el('div', 'changelog-commit-separator')
+        const commit = commitBySha.get(commitSha)
+        const commitDateTime = formatCommitDateTime(commit?.authorDate)
+        const label = `commit ${String(commitSha || '').slice(0, 12)}`
+        const meta = [commitDateTime, commit?.authorName || null, commit?.subject || null]
+          .filter(Boolean)
+          .join(' - ')
+        box.appendChild(el('div', 'changelog-commit-label mono', label))
+        if (meta) {
+          box.appendChild(el('div', 'meta', meta))
+        }
+        return box
+      }
+
+      function renderChangelogWithCommitSeparators(items, commitBySha, renderItem) {
+        if (!Array.isArray(items) || items.length === 0) return
+        let previousCommitSha = null
+        items.forEach((item) => {
+          const currentCommitSha = item?.event?.commitSha || null
+          if (currentCommitSha !== previousCommitSha) {
+            resultsEl.appendChild(renderCommitSeparator(currentCommitSha, commitBySha))
+            previousCommitSha = currentCommitSha
+          }
+          resultsEl.appendChild(renderItem(item))
+        })
+      }
+
       function renderChangelogEventLines(item, commitBySha) {
         const event = item.event
         const row = el('div', 'changelog-line-item')
@@ -2247,30 +2390,26 @@
               commit,
             ]),
           )
-          if (state.viewerMode === VIEWER_MODE.changelog) {
-            renderCollection(
-              filtered,
-              (item) => renderChangelogEventLines(item, commitBySha),
-              'No matches.',
+          if (filtered.length === 0) {
+            resultsEl.appendChild(el('div', 'empty', 'No matches.'))
+          } else if (state.viewerMode === VIEWER_MODE.changelog) {
+            renderChangelogWithCommitSeparators(filtered, commitBySha, (item) =>
+              renderChangelogEventLines(item, commitBySha),
             )
           } else {
-            renderCollection(
-              filtered,
-              (item) => {
-                const details = el('details', 'leaf')
-                const summary = el('summary')
-                summary.appendChild(renderEventTitle(item))
-                details.appendChild(summary)
-                details.appendChild(
-                  renderEventCard(item.event, commitBySha, {
-                    showTitle: false,
-                    item,
-                  }),
-                )
-                return details
-              },
-              'No matches.',
-            )
+            renderChangelogWithCommitSeparators(filtered, commitBySha, (item) => {
+              const details = el('details', 'leaf')
+              const summary = el('summary')
+              summary.appendChild(renderEventTitle(item))
+              details.appendChild(summary)
+              details.appendChild(
+                renderEventCard(item.event, commitBySha, {
+                  showTitle: false,
+                  item,
+                }),
+              )
+              return details
+            })
           }
         }
         syncFilterStateToUrl()