@emeryld/rrroutes-export 1.0.20 → 1.0.22

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.22",
   "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(--muted);
+        font-weight: 700;
+        font-size: 12px;
+      }
+
       .changelog-diff-line {
         display: flex;
         flex-wrap: wrap;
@@ -657,6 +673,14 @@
               >
                 Changelog
               </button>
+              <button
+                id="tabChangelogGrouped"
+                class="field-chip"
+                type="button"
+                aria-pressed="false"
+              >
+                Grouped Changelog
+              </button>
             </div>
           </div>
         </div>
@@ -845,6 +869,7 @@
       const VIEW_IDS = {
         leaves: 'leaves',
         changelog: 'changelog',
+        changelogGrouped: 'changelogGrouped',
       }
 
       const VIEWER_MODE = {
@@ -879,6 +904,12 @@
             CHANGELOG_TIMELINE_FIELDS.map((field) => field.id),
           ),
         },
+        [VIEW_IDS.changelogGrouped]: {
+          fieldDefs: CHANGELOG_TIMELINE_FIELDS,
+          defaultSelected: new Set(
+            CHANGELOG_TIMELINE_FIELDS.map((field) => field.id),
+          ),
+        },
       }
 
       const state = {
@@ -896,6 +927,9 @@
           [VIEW_IDS.changelog]: new Set(
             TAB_CONFIG[VIEW_IDS.changelog].defaultSelected,
           ),
+          [VIEW_IDS.changelogGrouped]: new Set(
+            TAB_CONFIG[VIEW_IDS.changelogGrouped].defaultSelected,
+          ),
         },
       }
 
@@ -921,6 +955,9 @@
       const controlsEl = document.querySelector('.controls')
       const tabLeavesBtn = document.getElementById('tabLeaves')
       const tabChangelogBtn = document.getElementById('tabChangelog')
+      const tabChangelogGroupedBtn = document.getElementById(
+        'tabChangelogGrouped',
+      )
 
       const URL_PARAM_KEY = 'filters'
       let isHydratingFromUrl = false
@@ -1758,21 +1795,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 +1896,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 +1963,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 +1996,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 +2027,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 +2051,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 {
@@ -2022,6 +2158,18 @@
             ),
           )
         }
+        if (
+          Number.isInteger(options?.item?.dedupedRouteCount) &&
+          options.item.dedupedRouteCount > 0
+        ) {
+          card.appendChild(
+            el(
+              'div',
+              'meta',
+              `deduped route schema events: ${options.item.dedupedRouteCount}`,
+            ),
+          )
+        }
         return card
       }
 
@@ -2038,6 +2186,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')
@@ -2072,6 +2248,18 @@
             ),
           )
         }
+        if (
+          Number.isInteger(item?.dedupedRouteCount) &&
+          item.dedupedRouteCount > 0
+        ) {
+          row.appendChild(
+            el(
+              'div',
+              'meta mono',
+              `deduped route schema events: ${item.dedupedRouteCount}`,
+            ),
+          )
+        }
 
         return row
       }
@@ -2103,6 +2291,60 @@
         )
       }
 
+      function schemaEntrySignature(entry) {
+        if (!entry || typeof entry !== 'object') return ''
+        return JSON.stringify({
+          type: typeof entry.type === 'string' ? entry.type : 'unknown',
+          nullable: Boolean(entry.nullable),
+          optional: Boolean(entry.optional),
+          literal: entry.literal,
+        })
+      }
+
+      function normalizeSignatureToken(signature) {
+        if (typeof signature !== 'string') return ''
+        const parsed = parseSignatureEntry(signature)
+        if (!parsed) return signature
+        return schemaEntrySignature(parsed)
+      }
+
+      function normalizedSchemaDeltaParts(delta) {
+        if (!delta || typeof delta !== 'object') return null
+        const op = String(delta.op || 'changed')
+        if ('path' in delta) {
+          const location = String(delta.path || '')
+          const before = delta.before ? [schemaEntrySignature(delta.before)] : []
+          const after = delta.after ? [schemaEntrySignature(delta.after)] : []
+          return { op, location, before, after }
+        }
+        if ('section' in delta) {
+          const location = `${delta.section}.${delta.path}`
+          const before = Array.isArray(delta.before)
+            ? delta.before.map((item) => normalizeSignatureToken(item)).filter(Boolean)
+            : []
+          const after = Array.isArray(delta.after)
+            ? delta.after.map((item) => normalizeSignatureToken(item)).filter(Boolean)
+            : []
+          before.sort()
+          after.sort()
+          return { op, location, before, after }
+        }
+        return null
+      }
+
+      function schemaDiffFingerprint(schemaDiff) {
+        if (!Array.isArray(schemaDiff) || schemaDiff.length === 0) return ''
+        const lines = schemaDiff
+          .map((delta) => normalizedSchemaDeltaParts(delta))
+          .filter(Boolean)
+          .map(
+            (part) =>
+              `${part.op}|${part.location}|${part.before.join('&')}|${part.after.join('&')}`,
+          )
+          .sort()
+        return lines.join('||')
+      }
+
       function buildChronologicalEvents(payload) {
         if (!payload) return []
         const commitBySha = new Map(
@@ -2113,9 +2355,43 @@
         )
         const rows = []
         let sequence = 0
+        const sourceSchemaCoverage = new Map()
+
+        Object.entries(payload.bySourceObject || {}).forEach(
+          ([sourceObjectId, events]) => {
+            ;(events || []).forEach((event) => {
+              if (event?.type !== 'source_schema_changed') return
+              const fingerprint = schemaDiffFingerprint(event.schemaDiff)
+              if (!fingerprint) return
+              const key = `${event.commitSha}|${fingerprint}`
+              let coverage = sourceSchemaCoverage.get(key)
+              if (!coverage) {
+                coverage = {
+                  sourceObjectIds: new Set(),
+                  impactedRoutes: new Set(),
+                  dedupedRouteKeys: new Set(),
+                }
+                sourceSchemaCoverage.set(key, coverage)
+              }
+              coverage.sourceObjectIds.add(sourceObjectId)
+              ;(event.impactedRoutes || []).forEach((routeKey) => {
+                coverage.impactedRoutes.add(routeKey)
+              })
+            })
+          },
+        )
 
         Object.entries(payload.byRoute || {}).forEach(([routeKey, events]) => {
           ;(events || []).forEach((event) => {
+            if (event?.type === 'schema_changed') {
+              const fingerprint = schemaDiffFingerprint(event.schemaDiff)
+              const key = `${event.commitSha}|${fingerprint}`
+              const coverage = sourceSchemaCoverage.get(key)
+              if (coverage && coverage.impactedRoutes.has(routeKey)) {
+                coverage.dedupedRouteKeys.add(routeKey)
+                return
+              }
+            }
             rows.push({
               eventKind: 'route',
               routeKey,
@@ -2131,10 +2407,21 @@
         Object.entries(payload.bySourceObject || {}).forEach(
           ([sourceObjectId, events]) => {
             ;(events || []).forEach((event) => {
+              const fingerprint =
+                event?.type === 'source_schema_changed'
+                  ? schemaDiffFingerprint(event.schemaDiff)
+                  : ''
+              const coverage = sourceSchemaCoverage.get(
+                `${event.commitSha}|${fingerprint}`,
+              )
               rows.push({
                 eventKind: 'source',
                 sourceObjectId,
                 displayName: event.displayName || sourceObjectId,
+                dedupedRouteCount:
+                  event?.type === 'source_schema_changed'
+                    ? coverage?.dedupedRouteKeys.size || 0
+                    : 0,
                 event,
                 commit: commitBySha.get(event.commitSha),
                 commitSort: commitTimestamp(commitBySha.get(event.commitSha)),
@@ -2158,7 +2445,10 @@
       function changelogItemsByTab(tabId) {
         const payload = state.changelogPayload
         if (!payload) return []
-        if (tabId === VIEW_IDS.changelog) {
+        if (
+          tabId === VIEW_IDS.changelog ||
+          tabId === VIEW_IDS.changelogGrouped
+        ) {
           return buildChronologicalEvents(payload)
         }
         return []
@@ -2187,6 +2477,10 @@
       function renderTabButtons() {
         setPressed(tabLeavesBtn, state.activeTab === VIEW_IDS.leaves)
         setPressed(tabChangelogBtn, state.activeTab === VIEW_IDS.changelog)
+        setPressed(
+          tabChangelogGroupedBtn,
+          state.activeTab === VIEW_IDS.changelogGrouped,
+        )
         tabLeavesBtn.style.display = state.availableTabs.has(VIEW_IDS.leaves)
           ? ''
           : 'none'
@@ -2195,6 +2489,11 @@
         )
           ? ''
           : 'none'
+        tabChangelogGroupedBtn.style.display = state.availableTabs.has(
+          VIEW_IDS.changelogGrouped,
+        )
+          ? ''
+          : 'none'
         const isLeavesTab = state.activeTab === VIEW_IDS.leaves
         coreFieldsBtn.style.display = isLeavesTab ? '' : 'none'
         schemasOnlyFieldsBtn.style.display = isLeavesTab ? '' : 'none'
@@ -2247,30 +2546,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.activeTab === VIEW_IDS.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()
@@ -2296,7 +2591,8 @@
                 {
                   id: 'tabFields',
                   label:
-                    state.activeTab === VIEW_IDS.changelog
+                    state.activeTab === VIEW_IDS.changelog ||
+                    state.activeTab === VIEW_IDS.changelogGrouped
                       ? 'Changelog fields'
                       : 'Source fields',
                   fieldIds: fieldDefs.map((field) => field.id),
@@ -2484,7 +2780,8 @@
           isHydratingFromUrl = true
           if (
             parsed.activeTab === VIEW_IDS.leaves ||
-            parsed.activeTab === VIEW_IDS.changelog
+            parsed.activeTab === VIEW_IDS.changelog ||
+            parsed.activeTab === VIEW_IDS.changelogGrouped
           ) {
             state.activeTab = parsed.activeTab
           }
@@ -2573,12 +2870,19 @@
         }
         if (state.changelogPayload) {
           state.availableTabs.add(VIEW_IDS.changelog)
+          if (state.viewerMode === VIEWER_MODE.bundle) {
+            state.availableTabs.add(VIEW_IDS.changelogGrouped)
+          }
         }
 
         if (!state.availableTabs.has(state.activeTab)) {
-          state.activeTab = state.availableTabs.has(VIEW_IDS.leaves)
-            ? VIEW_IDS.leaves
-            : VIEW_IDS.changelog
+          if (state.availableTabs.has(VIEW_IDS.leaves)) {
+            state.activeTab = VIEW_IDS.leaves
+          } else if (state.availableTabs.has(VIEW_IDS.changelog)) {
+            state.activeTab = VIEW_IDS.changelog
+          } else {
+            state.activeTab = VIEW_IDS.changelogGrouped
+          }
         }
 
         if (state.leavesPayload && state.changelogPayload) {
@@ -2641,6 +2945,9 @@
       tabChangelogBtn.addEventListener('click', () =>
         setActiveTab(VIEW_IDS.changelog),
       )
+      tabChangelogGroupedBtn.addEventListener('click', () =>
+        setActiveTab(VIEW_IDS.changelogGrouped),
+      )
 
       selectAllFieldsBtn.addEventListener('click', () =>
         setFieldSelection(new Set(currentFieldDefs().map((field) => field.id))),