@nordcraft/search 1.0.84 → 1.0.86

package/src/rules/issues/attributes/noReferenceAttributeInInstanceRule.ts

@@ -5,7 +5,7 @@ import { componentIsReferenced } from '../components/noReferenceComponentRule'
 
 export const noReferenceAttributeInInstanceRule: Rule<void> = {
   code: 'no-reference attribute in instance',
-  level: 'warning',
+  level: 'info',
   category: 'No References',
   visit: (report, args, state) => {
     if (
@@ -46,7 +46,14 @@ export const noReferenceAttributeInInstanceRule: Rule<void> = {
     if (attrs.has([component.name, attributeKey].join('/'))) {
       return
     }
-    report(args.path, undefined, ['delete-attribute'])
+    report({
+      path: args.path,
+      info: {
+        title: 'Attribute is never set on any instance',
+        description: `The attribute **${attributeKey}** is never set on any component instance. Consider removing the attribute as any usage will always be *null*.`,
+      },
+      fixes: ['delete-attribute'],
+    })
   },
   fixes: {
     'delete-attribute': removeFromPathFix,

package/src/rules/issues/attributes/noReferenceAttributeRule.ts

@@ -32,7 +32,14 @@ export const noReferenceAttributeRule: Rule<void> = {
     if (attrs.has(attributeKey)) {
       return
     }
-    report(args.path, undefined, ['delete-attribute'])
+    report({
+      path: args.path,
+      info: {
+        title: 'Unused attribute',
+        description: `**${attributeKey}** is never used in any formula. Consider removing it.`,
+      },
+      fixes: ['delete-attribute'],
+    })
   },
   fixes: {
     'delete-attribute': removeFromPathFix,

package/src/rules/issues/attributes/unknownAttributeRule.ts

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

package/src/rules/issues/attributes/unknownComponentAttributeRule.ts

@@ -24,9 +24,15 @@ export const unknownComponentAttributeRule: Rule<{
       return
     }
     if (!isDefined(component.attributes?.[value.key])) {
-      report(path, { name: value.key, componentName: node.name }, [
-        'delete-component-attribute',
-      ])
+      report({
+        path,
+        info: {
+          title: 'Unknown component attribute',
+          description: `**${value.key}** is not a valid attribute for the "${node.name}" component.`,
+        },
+        details: { name: value.key, componentName: node.name },
+        fixes: ['delete-component-attribute'],
+      })
     }
   },
   fixes: {

package/src/rules/issues/components/invalidComponentStructureRule.ts

@@ -145,14 +145,18 @@ export const invalidComponentStructureRule: Rule<
         case 'custom':
           break
       }
-      report(
-        [...data.path, ...issuePath],
-        {
+      report({
+        path: [...data.path, ...issuePath],
+        info: {
+          title: 'Invalid component structure',
+          description: issue.message,
+        },
+        details: {
           message: issue.message,
           issue,
         },
-        fixes.size > 0 ? Array.from(fixes) : undefined,
-      )
+        fixes: fixes.size > 0 ? Array.from(fixes) : undefined,
+      })
     })
   },
   fixes: {

package/src/rules/issues/components/noReferenceComponentRule.ts

@@ -24,7 +24,15 @@ export const noReferenceComponentRule: Rule<void> = {
       return
     }
 
-    report(data.path, undefined, ['delete-component'])
+    report({
+      path: data.path,
+      info: {
+        title: 'Unused component',
+        description:
+          '**Component** is never used by any page or component. Consider removing it.',
+      },
+      fixes: ['delete-component'],
+    })
   },
   fixes: {
     'delete-component': removeFromPathFix,

package/src/rules/issues/components/unknownComponentRule.ts

@@ -19,6 +19,13 @@ export const unknownComponentRule: Rule<{
     ) {
       return
     }
-    report(path, { name: value.name })
+    report({
+      path,
+      info: {
+        title: 'Unknown component',
+        description: `**${value.name}** does not exist in this project.`,
+      },
+      details: { name: value.name },
+    })
   },
 }

package/src/rules/issues/context/noContextConsumersRule.ts

@@ -36,6 +36,13 @@ export const noContextConsumersRule: Rule<{
     if (hasComponents) {
       return
     }
-    report(path)
+    report({
+      path,
+      info: {
+        title: 'No context consumers',
+        description:
+          'Component has no child components or slots, but exposes formulas or workflows in context. Exposed formulas and workflows can only be consumed by child components or slots. Consider unchecking the "Expose in context" option or adding a child component or slot.',
+      },
+    })
   },
 }

package/src/rules/issues/context/unknownContextFormulaRule.ts

@@ -22,9 +22,16 @@ export const unknownContextFormulaRule: Rule<{
       return
     }
 
-    report(path, {
-      providerName: value.path[1],
-      formulaName: value.path[2],
+    report({
+      path,
+      info: {
+        title: 'Unknown context formula',
+        description: `**${value.path[2]}** is not subscribed. Make sure to subscribe to it in the component context section before using it.`,
+      },
+      details: {
+        providerName: value.path[1],
+        formulaName: value.path[2],
+      },
     })
   },
 }

package/src/rules/issues/context/unknownContextProviderFormulaRule.ts

@@ -25,9 +25,16 @@ export const unknownContextProviderFormulaRule: Rule<{
     }
     for (const formulaName of value.formulas) {
       if (component.formulas?.[formulaName]?.exposeInContext !== true) {
-        report(path, {
-          providerName: value.componentName,
-          formulaName,
+        report({
+          path,
+          info: {
+            title: 'Unknown context provider formula',
+            description: `**${formulaName}** does not exist on the context provider **${value.componentName}**. Using an unknown formula will always return *Null*. Make sure to define it before using it.`,
+          },
+          details: {
+            providerName: value.componentName,
+            formulaName,
+          },
         })
       }
     }

package/src/rules/issues/context/unknownContextProviderRule.ts

@@ -25,6 +25,13 @@ export const unknownContextProviderRule: Rule<{ componentName: string }> = {
       }
     }
 
-    report(path, { componentName: value.componentName })
+    report({
+      path,
+      info: {
+        title: 'Unknown context provider',
+        description: `**${value.componentName}** component or page does not exist and cannot be subscribed. Make sure to define it before using it.`,
+      },
+      details: { componentName: value.componentName },
+    })
   },
 }

package/src/rules/issues/dom/createRequiredDirectChildRule.ts

@@ -30,10 +30,17 @@ export function createRequiredDirectChildRule(
           childNode?.type === 'element' &&
           !childTags.includes(childNode.tag)
         ) {
-          report([...path.slice(0, 3), childId], {
-            parentTag: value.tag,
-            childTag: childNode.tag,
-            allowedChildTags: childTags,
+          report({
+            path: [...path.slice(0, 3), childId],
+            info: {
+              title: 'Invalid child element',
+              description: `**${childNode.tag}** should not be a direct first decedent of **${value.tag}**. Valid children are: *${childTags.join('*, *')}*.`,
+            },
+            details: {
+              parentTag: value.tag,
+              childTag: childNode.tag,
+              allowedChildTags: childTags,
+            },
           })
         }
       })

package/src/rules/issues/dom/createRequiredDirectParentRule.ts

@@ -26,10 +26,17 @@ export function createRequiredDirectParentRule(
         (node) => node.type === 'element' && node.children.includes(nodeId),
       )
       if (parent?.type === 'element' && !parentTags.includes(parent.tag)) {
-        report(path, {
-          parentTag: parent.tag,
-          childTag: value.tag,
-          allowedParentTags: parentTags,
+        report({
+          path,
+          info: {
+            title: 'Invalid parent element',
+            description: `**${value.tag}** should not have a direct parent of type **${parent.tag}**. Valid parents are: *${parentTags.join('*, *')}*.`,
+          },
+          details: {
+            parentTag: parent.tag,
+            childTag: value.tag,
+            allowedParentTags: parentTags,
+          },
         })
       }
     },

package/src/rules/issues/dom/createRequiredElementAttributeRule.ts

@@ -56,7 +56,14 @@ export function createRequiredElementAttributeRule({
           return
         }
 
-        report(path, { tag, attribute: mainAttribute })
+        report({
+          path,
+          info: {
+            title: 'Missing required attribute',
+            description: `**${mainAttribute}** is a required attribute on **${tag}** elements.\n[Learn more](https://developer.mozilla.org/en-US/docs/Web/HTML/Attributes)`,
+          },
+          details: { tag, attribute: mainAttribute },
+        })
       }
     },
   }

package/src/rules/issues/dom/createRequiredMetaTagRule.ts

@@ -26,7 +26,20 @@ export function createRequiredMetaTagRule(
         !formula ||
         (formula.type === 'value' && !formula.value)
       ) {
-        report(path, { tag: tag })
+        report({
+          path,
+          info: {
+            title: 'Missing meta tag',
+            description: `**${tag}** is a required tag on page **${
+              path[1]
+            }**. Missing tags may impact SEO performance. \n[Learn more](${
+              tag === 'title'
+                ? 'https://developer.mozilla.org/en-US/docs/Web/HTML/Reference/Elements/title'
+                : 'https://developer.mozilla.org/en-US/docs/Web/HTML/Reference/Elements/meta'
+            })`,
+          },
+          details: { tag: tag },
+        })
       }
     },
   }

package/src/rules/issues/dom/elementWithoutInteractiveContentRule.ts

@@ -70,9 +70,32 @@ export const elementWithoutInteractiveContentRule: Rule<{
     const childTags = searchChildren(component, value.children)
     if (childTags.length > 0) {
       childTags.forEach((ic) =>
-        report(path, {
-          parentTag: value.tag,
-          invalidChild: ic,
+        report({
+          path,
+          info: {
+            title: `${value.tag} includes interactive content element(s)`,
+            description: `\`${
+              value.tag
+            }\` elements are not allowed to include [interactive content](https://developer.mozilla.org/en-US/docs/Web/HTML/Guides/Content_categories#interactive_content) elements.
+This ${value.tag} element could potentially include a \`${ic.tag}\` element${
+              'whenAttributeIsPresent' in ic
+                ? ` with the \`${ic.whenAttributeIsPresent}\` attribute present`
+                : ''
+            }${
+              'whenAttributeIsNot' in ic
+                ? ` where the \`${ic.whenAttributeIsNot.attribute}\` attribute is not \`${ic.whenAttributeIsNot.value}\``
+                : ''
+            }.
+Learn more about permitted content for the \`${
+              value.tag
+            }\` element on [MDN](https://developer.mozilla.org/en-US/docs/Web/HTML/Reference/Elements/${
+              value.tag
+            }#technical_summary)`,
+          },
+          details: {
+            parentTag: value.tag,
+            invalidChild: ic,
+          },
         }),
       )
     }

package/src/rules/issues/dom/imageWithoutDimensionRule.ts

@@ -54,7 +54,14 @@ export const imageWithoutDimensionRule: Rule = {
       return
     }
 
-    report(path)
+    report({
+      path,
+      info: {
+        title: 'Image dimension missing',
+        description:
+          '**Image elements** should have explicit width and height to prevent layout shifts.\n[Learn more](https://web.dev/articles/serve-images-with-correct-dimensions#avoid_layout_shifts_by_specifying_dimensions)',
+      },
+    })
   },
 }
 

package/src/rules/issues/dom/nonEmptyVoidElementRule.ts

@@ -17,6 +17,13 @@ export const nonEmptyVoidElementRule: Rule<{ tag: string }> = {
     ) {
       return
     }
-    report(path, { tag: value.tag })
+    report({
+      path,
+      info: {
+        title: 'Non-empty void element',
+        description: `The **${value.tag}** element has child element(s), but ${value.tag} elements do not [support child elements](https://developer.mozilla.org/en-US/docs/Glossary/Void_element).`,
+      },
+      details: { tag: value.tag },
+    })
   },
 }

package/src/rules/issues/events/duplicateEventTriggerRule.ts

@@ -16,7 +16,14 @@ export const duplicateEventTriggerRule: Rule<{ trigger: string }> = {
         return
       }
       if (eventTriggers.has(event.trigger)) {
-        report([...path, 'events', key], { trigger: event.trigger })
+        report({
+          path: [...path, 'events', key],
+          info: {
+            title: 'Duplicate event trigger',
+            description: `**${event.trigger}** is used as a trigger in multiple events. Consider consolidating them into a single event.`,
+          },
+          details: { trigger: event.trigger },
+        })
       }
       eventTriggers.add(event.trigger)
     })

package/src/rules/issues/events/noReferenceEventRule.ts

@@ -41,7 +41,15 @@ export const noReferenceEventRule: Rule<{ name: string }> = {
     if (events.has(event.name)) {
       return
     }
-    report(args.path, { name: args.value.event.name }, ['delete-event'])
+    report({
+      path: args.path,
+      info: {
+        title: 'Unused event',
+        description: `**${event.name}** is never triggered. Consider removing it and clean up any usages.`,
+      },
+      details: { name: event.name },
+      fixes: ['delete-event'],
+    })
   },
   fixes: {
     'delete-event': removeFromPathFix,

package/src/rules/issues/events/unknownEventRule.ts

@@ -25,7 +25,14 @@ export const unknownEventRule: Rule<{
     )
     Object.entries(value.events).forEach(([eventKey, event]) => {
       if (isDefined(event) && !componentEvents.has(event.trigger)) {
-        report([...path, 'events', eventKey], { name: event.trigger })
+        report({
+          path: [...path, 'events', eventKey],
+          info: {
+            title: 'Unknown event',
+            description: `**${event.trigger}** does not exist. Calling an unknown event will have no effect.`,
+          },
+          details: { name: event.trigger },
+        })
       }
     })
   },

package/src/rules/issues/events/unknownTriggerEventRule.ts

@@ -14,7 +14,14 @@ export const unknownTriggerEventRule: Rule<{
     const [, componentName] = path
     const component = files.components[componentName]
     if (!component?.events?.some((e) => e.name === value.event)) {
-      report(path, { name: value.event })
+      report({
+        path,
+        info: {
+          title: 'Unknown event trigger',
+          description: `Event **${value.event}** does not exist. Make sure to define it before triggering it.`,
+        },
+        details: { name: value.event },
+      })
     }
   },
 }

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

@@ -13,7 +13,14 @@ export const duplicateFormulaArgumentNameRule: Rule<{
     const argumentNames = new Set<string>()
     value.arguments?.forEach((arg) => {
       if (argumentNames.has(arg.name)) {
-        report(path, { name: arg.name })
+        report({
+          path,
+          info: {
+            title: 'Duplicate formula argument name',
+            description: `Multiple arguments with the name **${arg.name}** exist. Ensure argument names are unique.`,
+          },
+          details: { name: arg.name },
+        })
       }
       argumentNames.add(arg.name)
     })

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.`,
+        },
+      })
     }
   },
 }