@nordcraft/search 1.0.85 → 1.0.87

package/src/rules/issues/formulas/legacyFormulaRule.ts

@@ -23,14 +23,19 @@ export const legacyFormulaRule: Rule<
     ) {
       return
     }
-    report(
-      data.path,
-      { name: data.value.name },
+    report({
+      path: data.path,
+      info: {
+        title: 'Legacy formula',
+        description: `**${data.value.name}** is deprecated. Replace it with the corresponding core formula.`,
+      },
+      details: { name: data.value.name },
       // The TYPE and BOOLEAN formulas cannot be autofixed since the logic has changed between the 2 implementations
-      data.value.name !== 'TYPE' && data.value.name !== 'BOOLEAN'
-        ? ['replace-legacy-formula']
-        : undefined,
-    )
+      fixes:
+        data.value.name !== 'TYPE' && data.value.name !== 'BOOLEAN'
+          ? ['replace-legacy-formula']
+          : undefined,
+    })
   },
   fixes: {
     'replace-legacy-formula': replaceLegacyFormula,

package/src/rules/issues/formulas/noReferenceComponentFormulaRule.ts

@@ -75,14 +75,21 @@ export const noReferenceComponentFormulaRule: Rule<{
         }
       }
     }
-    report(
-      args.path,
-      {
+    report({
+      path: args.path,
+      info: {
+        title: 'Unused component formula',
+        description:
+          contextSubscribers.length > 0
+            ? `**${value.name}** is never used but is subscribed to by: *${contextSubscribers.join('*, *')}*. Consider removing it and clean up the unused context subscriptions.`
+            : `**${value.name}** is never used. Consider removing it.`,
+      },
+      details: {
         contextSubscribers,
         name: value.name,
       },
-      ['delete-component-formula'],
-    )
+      fixes: ['delete-component-formula'],
+    })
   },
   fixes: {
     'delete-component-formula': removeFromPathFix,

package/src/rules/issues/formulas/noReferenceProjectFormulaRule.ts

@@ -85,7 +85,14 @@ export const noReferenceProjectFormulaRule: Rule<void> = {
         return
       }
     }
-    report(path, undefined, ['delete-project-formula'])
+    report({
+      path,
+      info: {
+        title: 'Unused global formula',
+        description: `Global formula is never used by any formula. Consider removing it.`,
+      },
+      fixes: ['delete-project-formula'],
+    })
   },
   fixes: {
     'delete-project-formula': removeFromPathFix,

package/src/rules/issues/formulas/unknownComponentFormulaInputRule.ts

@@ -32,7 +32,14 @@ export const unknownComponentFormulaInputRule: Rule<{
     const args = formula.arguments ?? []
     const argName = value.path[1]
     if (!isDefined(argName) || !args.some((arg) => arg.name === argName)) {
-      report(path, { name: argName })
+      report({
+        path,
+        info: {
+          title: 'Unknown component formula input',
+          description: `The formula input ${argName ?? ''} doesn't exist as an input for this formula.`,
+        },
+        details: { name: argName },
+      })
     }
   },
 }

package/src/rules/issues/formulas/unknownFormulaRule.ts

@@ -15,7 +15,14 @@ export const unknownFormulaRule: Rule<{
     const [, componentName] = path
     const component = files.components[componentName]
     if (!component?.formulas?.[value.name]) {
-      report(path, { name: value.name })
+      report({
+        path,
+        info: {
+          title: 'Unknown formula',
+          description: `**${value.name}** does not exist. Using an unknown formula will always return *Null*`,
+        },
+        details: { name: value.name },
+      })
     }
   },
 }

package/src/rules/issues/formulas/unknownProjectFormulaInputRule.ts

@@ -26,7 +26,14 @@ export const unknownProjectFormulaInputRule: Rule<{
     const args = formula.arguments ?? []
     const argName = value.path[1]
     if (!isDefined(argName) || !args.some((arg) => arg.name === argName)) {
-      report(path, { name: argName })
+      report({
+        path,
+        info: {
+          title: 'Unknown project formula input',
+          description: `The formula input ${argName ?? ''} doesn't exist as an input for this formula.`,
+        },
+        details: { name: argName },
+      })
     }
   },
 }

package/src/rules/issues/formulas/unknownProjectFormulaRule.ts

@@ -18,6 +18,13 @@ export const unknownProjectFormulaRule: Rule<{ name: string }> = {
     if (formula) {
       return
     }
-    report(path, { name: value.name })
+    report({
+      path,
+      info: {
+        title: 'Unknown global formula',
+        description: `**${value.name}** does not exist. Using an unknown formula will always return *Null*`,
+      },
+      details: { name: value.name },
+    })
   },
 }

package/src/rules/issues/formulas/unknownRepeatIndexFormulaRule.ts

@@ -16,7 +16,13 @@ export const unknownRepeatIndexFormulaRule: Rule = {
     }
     if (path[0] !== 'components' || path[2] !== 'nodes') {
       // Any use outside of a component node is invalid
-      return report(path)
+      return report({
+        path,
+        info: {
+          title: 'Unknown repeat index reference',
+          description: `The formula references a repeat index, but no repeat formula exist in any of its parent elements.`,
+        },
+      })
     }
     const [_components, componentName, _nodes, nodeId] = path as string[]
     const component = files.components[componentName]
@@ -44,7 +50,13 @@ export const unknownRepeatIndexFormulaRule: Rule = {
     }
     const parentWithRepeat = findParentWithRepeat([nodeId, node])
     if (!parentWithRepeat) {
-      report(path)
+      report({
+        path,
+        info: {
+          title: 'Unknown repeat index reference',
+          description: `The formula references a repeat index, but no repeat formula exist in any of its parent elements.`,
+        },
+      })
     }
   },
 }

package/src/rules/issues/formulas/unknownRepeatItemFormulaRule.ts

@@ -17,7 +17,13 @@ export const unknownRepeatItemFormulaRule: Rule = {
     if (path[0] !== 'components' || path[2] !== 'nodes') {
       // Any use outside of a component node is invalid
       // For instance in global formulas or in workflows
-      return report(path)
+      return report({
+        path,
+        info: {
+          title: 'Unknown repeat item reference',
+          description: `The formula references a repeat item, but no repeat formula exist in any of its parent elements.`,
+        },
+      })
     }
     const [_components, componentName, _nodes, nodeId] = path as string[]
     const component = files.components[componentName]
@@ -45,7 +51,13 @@ export const unknownRepeatItemFormulaRule: Rule = {
     }
     const parentWithRepeat = findParentWithRepeat([nodeId, node])
     if (!parentWithRepeat) {
-      report(path)
+      report({
+        path,
+        info: {
+          title: 'Unknown repeat item reference',
+          description: `The formula references a repeat item, but no repeat formula exist in any of its parent elements.`,
+        },
+      })
     }
   },
 }

package/src/rules/issues/logic/noStaticNodeCondition.ts

@@ -28,13 +28,24 @@ export const noStaticNodeCondition: Rule<{
     if (isStatic) {
       // - if truthy: "Condition is always true, you can safely remove the condition as it will always be rendered."
       // - if falsy: "Condition is always false, you can safely remove the entire node as it will never be rendered."
-      report(
+      report({
         path,
-        {
+        info: {
+          title:
+            Boolean(result) === true
+              ? `Unnecessary show/hide, value is always truthy`
+              : `Unnecessary show/hide, value is always falsy`,
+          description:
+            Boolean(result) === true
+              ? `Condition always evaluates to **show** the element. Consider removing the show/hide formula.`
+              : `Condition always evaluates to **hide** the element. Consider removing the element node.`,
+        },
+        details: {
           result,
         },
-        Boolean(result) === true ? ['remove-condition'] : ['remove-node'],
-      )
+        fixes:
+          Boolean(result) === true ? ['remove-condition'] : ['remove-node'],
+      })
     }
   },
   fixes: {

package/src/rules/issues/logic/noUnnecessaryConditionFalsy.ts

@@ -16,7 +16,14 @@ export const noUnnecessaryConditionFalsy: Rule = {
         return isStatic && Boolean(result) === false
       })
     ) {
-      report(path)
+      report({
+        path,
+        info: {
+          title: 'Unnecessary condition',
+          description:
+            '**And condition** is always falsy. Consider replacing it with a single *false* node.',
+        },
+      })
     }
   },
 }

package/src/rules/issues/logic/noUnnecessaryConditionTruthy.ts

@@ -21,7 +21,14 @@ export const noUnnecessaryConditionTruthy: Rule = {
         return isStatic && Boolean(result) === true
       })
     ) {
-      report(path)
+      report({
+        path,
+        info: {
+          title: 'Unnecessary condition',
+          description:
+            '**Or condition** is always truthy. Consider replacing it with a single *true* node.',
+        },
+      })
     }
   },
 }

package/src/rules/issues/miscellaneous/createStaticSizeConstraintRule.test.ts

@@ -0,0 +1,153 @@
+import { valueFormula } from '@nordcraft/core/dist/formula/formulaUtils'
+import { describe, expect, test } from 'bun:test'
+import { searchProject } from '../../../searchProject'
+import { createStaticSizeConstraintRule } from './createStaticSizeConstraintRule'
+
+describe('createStaticSizeConstraintRule', () => {
+  test('should calculate element size correctly for SVGs', () => {
+    const problems = Array.from(
+      searchProject({
+        files: {
+          formulas: {},
+          components: {
+            test: {
+              name: 'test',
+              nodes: {
+                root: {
+                  type: 'element',
+                  attrs: {},
+                  classes: {},
+                  events: {},
+                  tag: 'img',
+                  children: ['svg'],
+                  style: {},
+                },
+                svg: {
+                  type: 'element',
+                  attrs: {},
+                  classes: {},
+                  events: {},
+                  tag: 'svg',
+                  children: ['path'],
+                  style: {},
+                },
+                path: {
+                  type: 'element',
+                  attrs: {},
+                  classes: {},
+                  events: {},
+                  tag: 'path',
+                  children: [],
+                  style: {},
+                },
+              },
+              formulas: {},
+              apis: {},
+              attributes: {},
+              variables: {},
+            },
+          },
+        },
+        rules: [createStaticSizeConstraintRule('svg', 1)],
+      }),
+    )
+
+    expect(problems).toHaveLength(1)
+    expect(problems[0].code).toBe('size constraint')
+    expect(problems[0].path).toEqual(['components', 'test', 'nodes', 'svg'])
+    const expectedSize = new Blob(['<svg><path></path></svg>']).size
+    expect(problems[0].details.size).toEqual(expectedSize)
+  })
+  test('should calculate element size correctly for imgs', () => {
+    const problems = Array.from(
+      searchProject({
+        files: {
+          formulas: {},
+          components: {
+            test: {
+              name: 'test',
+              nodes: {
+                root: {
+                  type: 'element',
+                  attrs: {
+                    src: valueFormula(
+                      'data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAQAAAAEACAIAAADTED8xAAADMElEQVR4nOzVwQnAIBQFQYXff81RUkQCOyDj1YOPnbXWPmeTRef+/3O/OyBjzh3CD95BfqICMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMO0TAAD//2Anhf4QtqobAAAAAElFTkSuQmCC',
+                    ),
+                  },
+                  classes: {},
+                  events: {},
+                  tag: 'img',
+                  children: [],
+                  style: {},
+                },
+              },
+              formulas: {},
+              apis: {},
+              attributes: {},
+              variables: {},
+            },
+          },
+        },
+        rules: [createStaticSizeConstraintRule('img', 1)],
+      }),
+    )
+
+    expect(problems).toHaveLength(1)
+    expect(problems[0].code).toBe('size constraint')
+    expect(problems[0].path).toEqual(['components', 'test', 'nodes', 'root'])
+    const expectedSize = new Blob([
+      '<img src="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAQAAAAEACAIAAADTED8xAAADMElEQVR4nOzVwQnAIBQFQYXff81RUkQCOyDj1YOPnbXWPmeTRef+/3O/OyBjzh3CD95BfqICMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMK0CMO0TAAD//2Anhf4QtqobAAAAAElFTkSuQmCC" />',
+    ]).size
+    expect(problems[0].details.size).toEqual(expectedSize)
+  })
+  test('should ignore elements that are not too large', () => {
+    const problems = Array.from(
+      searchProject({
+        files: {
+          formulas: {},
+          components: {
+            test: {
+              name: 'test',
+              nodes: {
+                root: {
+                  type: 'element',
+                  attrs: {},
+                  classes: {},
+                  events: {},
+                  tag: 'img',
+                  children: ['svg'],
+                  style: {},
+                },
+                svg: {
+                  type: 'element',
+                  attrs: {},
+                  classes: {},
+                  events: {},
+                  tag: 'svg',
+                  children: ['path'],
+                  style: {},
+                },
+                path: {
+                  type: 'element',
+                  attrs: {},
+                  classes: {},
+                  events: {},
+                  tag: 'path',
+                  children: [],
+                  style: {},
+                },
+              },
+              formulas: {},
+              apis: {},
+              attributes: {},
+              variables: {},
+            },
+          },
+        },
+        rules: [createStaticSizeConstraintRule('svg', 100)],
+      }),
+    )
+
+    expect(problems).toHaveLength(0)
+  })
+})

package/src/rules/issues/miscellaneous/createStaticSizeConstraintRule.ts

@@ -0,0 +1,90 @@
+import type { NodeModel } from '@nordcraft/core/dist/component/component.types'
+import { isDefined } from '@nordcraft/core/dist/utils/util'
+import { VOID_HTML_ELEMENTS } from '@nordcraft/ssr/dist/const'
+import type { Level, Rule } from '../../../types'
+
+export function createStaticSizeConstraintRule(
+  tag: string,
+  maxSize: number,
+  level: Level = 'info',
+): Rule<{
+  tag: string
+  size: number
+}> {
+  return {
+    code: 'size constraint',
+    category: 'Performance',
+    level: level,
+    visit: (report, args) => {
+      if (
+        args.nodeType === 'component-node' &&
+        args.value.type === 'element' &&
+        args.value.tag === tag
+      ) {
+        let size = 0
+        const component = args.component
+        const evaluateElement = (element?: NodeModel): string => {
+          if (
+            !element ||
+            ['element', 'text', 'slot', 'component'].includes(element.type) ===
+              false
+          ) {
+            return ''
+          }
+          const children = (element.children ?? []).map((child) =>
+            evaluateElement(component.nodes?.[child]),
+          )
+          const tag = element.type === 'element' ? element.tag : 'span'
+          const attributes: Record<string, string> = {}
+          if (element.type === 'element' || element.type === 'component') {
+            Object.entries(element.attrs ?? {}).forEach(([key, value]) => {
+              if (value?.type === 'value' && isDefined(value.value)) {
+                attributes[key] = String(value.value)
+              }
+            })
+          }
+          const attributeString = Object.entries(attributes)
+            .map(([key, value]) => `${key}="${value}"`)
+            .join(' ')
+          if (VOID_HTML_ELEMENTS.includes(tag)) {
+            return attributeString
+              ? `<${tag} ${attributeString} />`
+              : `<${tag} />`
+          } else {
+            const openingTag = attributeString
+              ? `<${tag} ${attributeString}>`
+              : `<${tag}>`
+            return `${openingTag}${children.join('')}</${tag}>`
+          }
+        }
+        const staticElement = evaluateElement(args.value)
+        size = new Blob([staticElement]).size
+        if (size > maxSize) {
+          report({
+            path: args.path,
+            info: {
+              title: `Element size exceeds the suggested maximum allowed size of ${sizeFormatter(maxSize)}`,
+              description: `The <${tag}> element has a size of ${sizeFormatter(size)}, which exceeds the suggested limit of ${sizeFormatter(maxSize)}. Consider simplifying the content or structure of this element to reduce its size and improve performance.`,
+            },
+            details: { tag, size },
+          })
+        }
+      }
+    },
+  }
+}
+
+const sizeFormatter = (sizeInBytes: number) => {
+  const units = ['byte', 'KB', 'MB', 'GB', 'TB']
+  let unitIndex = 0
+  let size = sizeInBytes
+
+  while (size >= 1024 && unitIndex < units.length - 1) {
+    size /= 1024
+    unitIndex++
+  }
+  const unit = unitIndex === 0 && size !== 1 ? 'bytes' : units[unitIndex]
+  return `${new Intl.NumberFormat(undefined, {
+    maximumFractionDigits: unitIndex === 0 ? 0 : 2,
+  }).format(size)} ${unit}`
+}

package/src/rules/issues/miscellaneous/miscRules.index.ts

@@ -1,5 +1,14 @@
+import { createStaticSizeConstraintRule } from './createStaticSizeConstraintRule'
 import { noReferenceNodeRule } from './noReferenceNodeRule'
 import { requireExtensionRule } from './requireExtensionRule'
 import { unknownCookieRule } from './unknownCookieRule'
 
-export default [noReferenceNodeRule, requireExtensionRule, unknownCookieRule]
+export default [
+  noReferenceNodeRule,
+  requireExtensionRule,
+  unknownCookieRule,
+  // 100 KB is a large SVG
+  createStaticSizeConstraintRule('svg', 100 * 1024),
+  // 50 KB is a large img element (with potential base64 encoded image)
+  createStaticSizeConstraintRule('img', 50 * 1024),
+]

package/src/rules/issues/miscellaneous/noReferenceNodeRule.ts

@@ -25,7 +25,15 @@ export const noReferenceNodeRule: Rule<{ node: string }> = {
     )
 
     if (nodeId !== 'root' && !referencedNodesInComponent.has(nodeId)) {
-      report(path, { node: nodeId }, ['delete-orphan-node'])
+      report({
+        path,
+        info: {
+          title: `Orphan node/element was found`,
+          description: `A node is declared, but it is not included in any other element, including the root element. This node can safely be removed.`,
+        },
+        details: { node: nodeId },
+        fixes: ['delete-orphan-node'],
+      })
     }
   },
   fixes: {

package/src/rules/issues/miscellaneous/requireExtensionRule.ts

@@ -16,6 +16,13 @@ export const requireExtensionRule: Rule<{
     ) {
       return
     }
-    report(path)
+    report({
+      path,
+      info: {
+        title: 'Browser plugin recommended',
+        description:
+          '**Toddle browser plugin** is recommended for working with cookies. [Install extension](https://chromewebstore.google.com/detail/toddle/hfhgjncckomifajhndceigiaiojhlllp?hl=en)',
+      },
+    })
   },
 }

package/src/rules/issues/miscellaneous/unknownCookieRule.ts

@@ -27,7 +27,14 @@ export const unknownCookieRule: Rule<{
     }
     const cookie = state.cookiesAvailable?.find((c) => c.name === formula.value)
     if (!cookie) {
-      report(path, { name: formula.value })
+      report({
+        path,
+        info: {
+          title: 'Unknown cookie',
+          description: `**${formula.value}** is not found in the browser extension cookies.`,
+        },
+        details: { name: formula.value },
+      })
     }
   },
 }

package/src/rules/issues/routing/duplicateRouteRule.ts

@@ -40,12 +40,24 @@ export const duplicateRouteRule: Rule<{
     })
     const match = allRoutes.get(getRouteKey(value.route?.path))
     if (match && match.length > 1) {
-      report([...path, 'route', 'path'], {
-        name: value.name,
-        type: 'page',
-        duplicates: match
-          .filter((m) => m !== value.name)
-          .map((name) => ({ name, type: 'page' })),
+      const duplicates = match
+        .filter((m) => m !== value.name)
+        .map((name) => ({ name, type: 'page' as const }))
+      report({
+        path: [...path, 'route', 'path'],
+        info: {
+          title: 'Duplicate route declaration',
+          description: `The page **${
+            value.name
+          }** has the same route/path declared as the pages/routes below. Route declarations must be unique.${duplicates
+            .map((d) => `\n- ${d.name} (${d.type})`)
+            .join('')}`,
+        },
+        details: {
+          name: value.name,
+          type: 'page',
+          duplicates,
+        },
       })
     }
   },

package/src/rules/issues/routing/duplicateUrlParameterRule.ts

@@ -17,13 +17,27 @@ export const duplicateUrlParameterRule: Rule<{ name: string }> = {
     const pathNames = new Set<string>()
     value.route.path.forEach((p, i) => {
       if (pathNames.has(p.name)) {
-        report([...path, 'route', 'path', i], { name: p.name })
+        report({
+          path: [...path, 'route', 'path', i],
+          info: {
+            title: 'Duplicate URL parameter',
+            description: `**${p.name}** appears multiple times in the path/query parameters. This may lead to unexpected behavior. Consider consolidating them into a single parameter or renaming them.`,
+          },
+          details: { name: p.name },
+        })
       }
       pathNames.add(p.name)
     })
     Object.keys(value.route.query).forEach((key) => {
       if (pathNames.has(key)) {
-        report([...path, 'route', 'query', key], { name: key })
+        report({
+          path: [...path, 'route', 'query', key],
+          info: {
+            title: 'Duplicate URL parameter',
+            description: `**${key}** appears multiple times in the path/query parameters. This may lead to unexpected behavior. Consider consolidating them into a single parameter or renaming them.`,
+          },
+          details: { name: key },
+        })
       }
     })
   },

package/src/rules/issues/routing/unknownSetUrlParameterRule.ts

@@ -27,7 +27,14 @@ export const unknownSetUrlParameterRule: Rule<{
       )
     const parameterName = args.value.parameter
     if (!isValidParameter(parameterName)) {
-      report(args.path, { name: parameterName })
+      report({
+        path: args.path,
+        info: {
+          title: 'Unknown URL parameter update',
+          description: `**${parameterName}** does not exist as a path- or query-parameter and cannot be set/updated.`,
+        },
+        details: { name: parameterName },
+      })
     }
   },
 }

package/src/rules/issues/routing/unknownSetUrlParametersRule.ts

@@ -27,7 +27,14 @@ export const unknownSetUrlParametersRule: Rule<{
       )
     for (const key of Object.keys(args.value.parameters ?? {})) {
       if (!isValidParameter(key)) {
-        report([...args.path, 'parameters', key], { name: key })
+        report({
+          path: [...args.path, 'parameters', key],
+          info: {
+            title: 'Unknown URL parameter update',
+            description: `**${key}** does not exist as a path- or query-parameter and cannot be set/updated.`,
+          },
+          details: { name: key },
+        })
       }
     }
   },