@emeryld/rrroutes-contract 2.7.5 → 2.7.7

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@emeryld/rrroutes-contract",
   "description": "TypeScript contract definitions for RRRoutes",
-  "version": "2.7.5",
+  "version": "2.7.7",
   "private": false,
   "type": "module",
   "main": "dist/index.cjs",
@@ -14,11 +14,16 @@
       "require": "./dist/index.cjs"
     }
   },
+  "bin": {
+    "rrroutes-export-finalized-leaves": "./bin/rrroutes-export-finalized-leaves.mjs"
+  },
   "files": [
     "dist",
-    "tools/finalized-leaves-viewer.html"
+    "tools/finalized-leaves-viewer.html",
+    "bin/rrroutes-export-finalized-leaves.mjs"
   ],
   "dependencies": {
+    "typescript": "^5.9.3",
     "zod": "^4.3.6"
   },
   "devDependencies": {

package/tools/finalized-leaves-viewer.html

@@ -156,6 +156,12 @@
         color: var(--muted);
       }
 
+      .kv .k a {
+        color: inherit;
+        text-decoration: underline;
+        text-underline-offset: 2px;
+      }
+
       .kv .v {
         margin-top: 2px;
         word-break: break-word;
@@ -312,6 +318,10 @@
               <option value="exact">exact</option>
             </select>
           </label>
+          <label class="field-item">
+            <input id="schemaRowsMatchOnly" type="checkbox" />
+            <span>schema rows match filter</span>
+          </label>
         </div>
 
         <div id="fieldCheckboxes" class="field-row"></div>
@@ -346,6 +356,31 @@
         { id: 'tags', label: 'tags', get: (leaf) => leaf.cfg?.tags || [] },
         { id: 'stability', label: 'stability', get: (leaf) => [leaf.cfg?.stability] },
         { id: 'docsMeta', label: 'docsMeta', get: (leaf) => [leaf.cfg?.docsMeta] },
+        {
+          id: 'sourceDefinition',
+          label: 'source definition',
+          get: (leaf, schemaFlatByLeaf, payload) => {
+            const source = payload?.sourceByLeaf?.[leaf.key]?.definition
+            if (!source) return []
+            return [`${source.file}:${source.line}:${source.column}`]
+          },
+        },
+        {
+          id: 'sourceSchemas',
+          label: 'source schemas',
+          get: (leaf, schemaFlatByLeaf, payload) => {
+            const schemas = payload?.sourceByLeaf?.[leaf.key]?.schemas
+            if (!schemas || typeof schemas !== 'object') return []
+            return Object.values(schemas).flatMap((schema) => {
+              if (!schema || typeof schema !== 'object') return []
+              const tokens = []
+              if (schema.sourceName) tokens.push(schema.sourceName)
+              if (schema.tag) tokens.push(schema.tag)
+              tokens.push(`${schema.file}:${schema.line}:${schema.column}`)
+              return tokens
+            })
+          },
+        },
         {
           id: 'types',
           label: 'types',
@@ -390,6 +425,7 @@
       const caseSensitiveInput = document.getElementById('caseSensitive')
       const regexSearchInput = document.getElementById('regexSearch')
       const typeMatchModeInput = document.getElementById('typeMatchMode')
+      const schemaRowsMatchOnlyInput = document.getElementById('schemaRowsMatchOnly')
       const fieldCheckboxes = document.getElementById('fieldCheckboxes')
       const activeFilterChips = document.getElementById('activeFilterChips')
       const selectAllFieldsBtn = document.getElementById('selectAllFields')
@@ -557,6 +593,63 @@
         return Array.from(tokens)
       }
 
+      function schemaEntryTokens(path, info) {
+        const tokens = new Set()
+
+        if (path) {
+          tokens.add(path)
+          path.split('.').forEach((segment) => {
+            if (segment) tokens.add(segment)
+          })
+        }
+
+        if (info && typeof info === 'object') {
+          tokens.add(JSON.stringify(info))
+          if (info.type) tokens.add(String(info.type))
+          if (info.kind) tokens.add(String(info.kind))
+          if (info.description) tokens.add(String(info.description))
+          if (Array.isArray(info.enumValues)) {
+            info.enumValues.forEach((value) => tokens.add(String(value)))
+          }
+        } else if (info !== null && info !== undefined) {
+          tokens.add(String(info))
+        }
+
+        return Array.from(tokens)
+      }
+
+      function schemaEntryMatchesActiveFilter(sectionName, fullPath, info, engine, selectedIds) {
+        if (!engine.active) return true
+
+        let matched = false
+        if (selectedIds.includes(sectionName)) {
+          matched = schemaEntryTokens(fullPath, info).some((token) => engine.test(token))
+        }
+
+        if (!matched && selectedIds.includes('types')) {
+          const typeTokens = []
+          if (info && typeof info === 'object') {
+            if (info.type) typeTokens.push(String(info.type))
+            if (info.kind) typeTokens.push(String(info.kind))
+            if (Array.isArray(info.enumValues)) {
+              info.enumValues.forEach((value) => typeTokens.push(String(value)))
+            }
+          }
+
+          if (typeMatchModeInput.value === 'exact' && !engine.regex) {
+            const needle = engine.caseSensitive ? engine.query : engine.query.toLowerCase()
+            const normalized = engine.caseSensitive
+              ? typeTokens
+              : typeTokens.map((token) => token.toLowerCase())
+            matched = normalized.includes(needle)
+          } else {
+            matched = typeTokens.some((token) => engine.test(token))
+          }
+        }
+
+        return matched
+      }
+
       function selectedFieldIds() {
         return SEARCH_FIELDS.filter((field) => {
           const input = document.getElementById(`field-${field.id}`)
@@ -568,10 +661,11 @@
         if (!engine.active) return true
         if (selectedIds.length === 0) return false
         const schemaFlatByLeaf = state.payload?.schemaFlatByLeaf || {}
+        const payload = state.payload || {}
 
         return SEARCH_FIELDS.some((field) => {
           if (!selectedIds.includes(field.id)) return false
-          const tokens = toTokens(field.get(leaf, schemaFlatByLeaf))
+          const tokens = toTokens(field.get(leaf, schemaFlatByLeaf, payload))
           if (field.id === 'types' && typeMatchModeInput.value === 'exact' && !engine.regex) {
             const needle = engine.caseSensitive ? engine.query : engine.query.toLowerCase()
             const normalized = engine.caseSensitive
@@ -629,6 +723,40 @@
         return row
       }
 
+      function sourceHref(source) {
+        if (!source || !source.file) return undefined
+        const normalizedPath = String(source.file).replace(/\\/g, '/')
+        const prefix = normalizedPath.startsWith('/') ? 'file://' : 'file:///'
+        return `${prefix}${encodeURI(normalizedPath)}`
+      }
+
+      function createSourceRow(key, source, engine) {
+        const box = el('div', 'kv')
+        const keyNode = el('div', 'k')
+        const valueNode = el('div', 'v mono')
+
+        if (!source || !source.file) {
+          setHighlighted(keyNode, key, engine)
+          box.appendChild(keyNode)
+          setHighlighted(valueNode, '—', engine)
+          box.appendChild(valueNode)
+          return box
+        }
+
+        const href = sourceHref(source)
+        const keyLink = document.createElement('a')
+        keyLink.href = href
+        keyLink.target = '_blank'
+        keyLink.rel = 'noopener noreferrer'
+        keyLink.textContent = key
+        keyNode.appendChild(keyLink)
+
+        setHighlighted(valueNode, `${source.file}:${source.line}:${source.column}`, engine)
+        box.appendChild(keyNode)
+        box.appendChild(valueNode)
+        return box
+      }
+
       function splitFlatSchemaBySection(flatSchema) {
         const result = {
           params: {},
@@ -737,17 +865,27 @@
         return row
       }
 
-      function renderSeparatedSchemas(flatSchema, engine) {
+      function renderSeparatedSchemas(flatSchema, engine, selectedIds) {
         if (!flatSchema || typeof flatSchema !== 'object') return null
         const section = el('div', 'section')
         section.appendChild(el('h3', '', 'Schemas (separated by section)'))
 
         const grouped = splitFlatSchemaBySection(flatSchema)
         let hasAnySchemaEntries = false
+        const limitToMatchedRows = schemaRowsMatchOnlyInput.checked && engine.active
 
         SCHEMA_SECTIONS.forEach((sectionName) => {
-          const entries = grouped[sectionName]
-          if (!entries || Object.keys(entries).length === 0) return
+          const rawEntries = grouped[sectionName]
+          if (!rawEntries || Object.keys(rawEntries).length === 0) return
+
+          const entries = limitToMatchedRows
+            ? Object.fromEntries(
+                Object.entries(rawEntries).filter(([fullPath, info]) =>
+                  schemaEntryMatchesActiveFilter(sectionName, fullPath, info, engine, selectedIds),
+                ),
+              )
+            : rawEntries
+          if (Object.keys(entries).length === 0) return
 
           hasAnySchemaEntries = true
           const block = el('div', 'schema-block')
@@ -764,7 +902,7 @@
         return hasAnySchemaEntries ? section : null
       }
 
-      function renderLeaf(leaf, engine) {
+      function renderLeaf(leaf, engine, selectedIds) {
         const details = el('details', 'leaf')
         const summary = el('summary')
         setHighlighted(summary, `${String(leaf.method || '').toUpperCase()} ${leaf.path || ''}`, engine)
@@ -823,7 +961,32 @@
           content.appendChild(files)
         }
 
-        const separatedSchemas = renderSeparatedSchemas(flatSchema, engine)
+        const sourceByLeaf = state.payload?.sourceByLeaf || {}
+        const source = sourceByLeaf[leaf.key]
+        if (source) {
+          const sourceSection = el('div', 'section')
+          sourceSection.appendChild(el('h3', '', 'Source'))
+          sourceSection.appendChild(createSourceRow('definition', source.definition, engine))
+
+          const schemaSources = source.schemas || {}
+          const schemaEntries = Object.entries(schemaSources)
+          if (schemaEntries.length > 0) {
+            const schemaGrid = el('div', 'grid-2')
+            schemaEntries.forEach(([schemaName, schemaSource]) => {
+              const display = schemaSource?.sourceName
+                ? `${schemaName}: ${schemaSource.sourceName}`
+                : schemaSource?.tag
+                  ? `${schemaName}: ${schemaSource.tag}`
+                  : schemaName
+              schemaGrid.appendChild(createSourceRow(display, schemaSource, engine))
+            })
+            sourceSection.appendChild(schemaGrid)
+          }
+
+          content.appendChild(sourceSection)
+        }
+
+        const separatedSchemas = renderSeparatedSchemas(flatSchema, engine, selectedIds)
         if (separatedSchemas) {
           content.appendChild(separatedSchemas)
         }
@@ -863,7 +1026,7 @@
         }
 
         filtered.forEach((leaf) => {
-          resultsEl.appendChild(renderLeaf(leaf, engine))
+          resultsEl.appendChild(renderLeaf(leaf, engine, selectedIds))
         })
         syncFilterStateToUrl()
       }
@@ -897,6 +1060,7 @@
         caseSensitiveInput.checked = false
         regexSearchInput.checked = false
         typeMatchModeInput.value = 'contains'
+        schemaRowsMatchOnlyInput.checked = false
         setFieldSelection(new Set(SEARCH_FIELDS.map((field) => field.id)))
       }
 
@@ -908,6 +1072,7 @@
 
         if (searchValue) chips.push(`search: ${searchValue}`)
         if (typeMatchModeInput.value === 'exact') chips.push('type mode: exact')
+        if (schemaRowsMatchOnlyInput.checked) chips.push('schema rows: matched only')
         if (caseSensitiveInput.checked) chips.push('case sensitive')
         if (regexSearchInput.checked) chips.push('regex')
         if (hasRegexError) chips.push('regex error')
@@ -935,6 +1100,7 @@
           caseSensitive: caseSensitiveInput.checked,
           regex: regexSearchInput.checked,
           typeMatchMode: typeMatchModeInput.value === 'exact' ? 'exact' : 'contains',
+          schemaRowsMatchOnly: schemaRowsMatchOnlyInput.checked,
           selectedFields: selectedFieldIds(),
         }
       }
@@ -966,6 +1132,7 @@
           if (parsed.typeMatchMode === 'exact' || parsed.typeMatchMode === 'contains') {
             typeMatchModeInput.value = parsed.typeMatchMode
           }
+          schemaRowsMatchOnlyInput.checked = Boolean(parsed.schemaRowsMatchOnly)
 
           if (Array.isArray(parsed.selectedFields)) {
             const allowed = new Set(parsed.selectedFields)
@@ -1020,6 +1187,7 @@
       caseSensitiveInput.addEventListener('change', renderResults)
       regexSearchInput.addEventListener('change', renderResults)
       typeMatchModeInput.addEventListener('change', renderResults)
+      schemaRowsMatchOnlyInput.addEventListener('change', renderResults)
 
       selectAllFieldsBtn.addEventListener('click', () =>
         setFieldSelection(new Set(SEARCH_FIELDS.map((field) => field.id))),