@nordcraft/search 1.0.85 → 1.0.87

package/src/rules/issues/apis/invalidApiProxyBodySettingRule.ts

@@ -20,6 +20,13 @@ export const invalidApiProxyBodySettingRule: Rule<{ api: string }> = {
       return
     }
     // Report an issue if useTemplatesInBody is set to true while the API is not set to be proxied
-    report(path, { api: value.name })
+    report({
+      path,
+      info: {
+        title: 'Invalid API setting for cookies in body',
+        description: `The API **${value.name}** has enabled the setting for injecting cookies in the proxied API body, but the API does not have proxying enabled.`,
+      },
+      details: { api: value.name },
+    })
   },
 }

package/src/rules/issues/apis/invalidApiProxyCookieSettingRule.ts

@@ -32,6 +32,13 @@ export const invalidApiProxyCookieSettingRule: Rule<{ api: string }> = {
       return
     }
     // Report an issue if the 'Get Http-Only Cookie' formula is used in a non-proxied API
-    report(path, { api: api.name })
+    report({
+      path,
+      info: {
+        title: 'Proxy specific formula used in non-proxied API',
+        description: `The **"Get Http-Only Cookie"** formula is used in the **${api.name}** API, but the API is not proxied. This will often lead to issues with the API when [the template value for the cookie](https://docs.nordcraft.com/connecting-data/authentication#adding-authentication-to-api-requests) is not replaced correctly.`,
+      },
+      details: { api: api.name },
+    })
   },
 }

package/src/rules/issues/apis/legacyApiRule.ts

@@ -11,6 +11,13 @@ export const legacyApiRule: Rule<{
     if (nodeType !== 'component-api' || !isLegacyApi(value)) {
       return
     }
-    report(path, { name: value.name })
+    report({
+      path,
+      info: {
+        title: 'Legacy API',
+        description: `The API **${value.name}** could be upgraded to the new API format.`,
+      },
+      details: { name: value.name },
+    })
   },
 }

package/src/rules/issues/apis/noReferenceApiInputRule.ts

@@ -37,6 +37,13 @@ export const noReferenceApiInputRule: Rule<{ inputName: string }> = {
     if (referencedApiInputs.has(inputKey)) {
       return
     }
-    report(path, { inputName: inputKey })
+    report({
+      path,
+      info: {
+        title: 'Unused API input',
+        description: `**${inputKey}** is never used by any formulas in the API. Consider removing it.`,
+      },
+      details: { inputName: inputKey },
+    })
   },
 }

package/src/rules/issues/apis/noReferenceApiRule.ts

@@ -67,7 +67,14 @@ export const noReferenceApiRule: Rule<void> = {
     if (componentApiReferences.has(value.name)) {
       return
     }
-    report(args.path, undefined, ['delete-api'])
+    report({
+      path: args.path,
+      info: {
+        title: 'Unused API',
+        description: `**${value.name}** is never used in any formulas and is not called in any workflows. Consider removing it.`,
+      },
+      fixes: ['delete-api'],
+    })
   },
   fixes: {
     'delete-api': removeFromPathFix,

package/src/rules/issues/apis/noReferenceApiServiceRule.ts

@@ -33,7 +33,15 @@ export const noReferenceApiServiceRule: Rule<{ serviceName: string }> = {
     if (apiServiceReferences.has(value.name)) {
       return
     }
-    report(args.path, { serviceName }, ['delete-api-service'])
+    report({
+      path: args.path,
+      info: {
+        title: 'Unused API Service',
+        description: `**${serviceName}** is never used by any API. Consider removing it.`,
+      },
+      details: { serviceName },
+      fixes: ['delete-api-service'],
+    })
   },
   fixes: {
     'delete-api-service': removeFromPathFix,

package/src/rules/issues/apis/unknownApiInputRule.ts

@@ -27,7 +27,14 @@ export const unknownApiInputRule: Rule<{
         | undefined
     )?.inputs?.[value.path[1]]
     if (!apiInput) {
-      report(path, { name: value.path[1] })
+      report({
+        path,
+        info: {
+          title: 'Unknown API input',
+          description: `**${value.path[1]}** does not exist as an input on the API. Using an unknown input will always return *Null*. Make sure to define it before using it.`,
+        },
+        details: { name: value.path[1] },
+      })
     }
   },
 }

package/src/rules/issues/apis/unknownApiRule.ts

@@ -22,11 +22,25 @@ export const unknownApiRule: Rule<{
     if (isApiFormula) {
       const [, apiKey] = value.path
       if (!component?.apis?.[apiKey]) {
-        report(path, { name: apiKey })
+        report({
+          path,
+          info: {
+            title: 'Unknown API',
+            description: `**${apiKey}** does not exist. Using an unknown API will have no effect. Define the API before calling it.`,
+          },
+          details: { name: apiKey },
+        })
       }
     } else if (isApiAction) {
       if (!component?.apis?.[value.api]) {
-        report(path, { name: value.api })
+        report({
+          path,
+          info: {
+            title: 'Unknown API',
+            description: `**${value.api}** does not exist. Using an unknown API will have no effect. Define the API before calling it.`,
+          },
+          details: { name: value.api },
+        })
       }
     }
   },

package/src/rules/issues/apis/unknownApiServiceRule.ts

@@ -19,11 +19,15 @@ export const unknownApiServiceRule: Rule<{
     ) {
       return
     }
-    report(
-      [...args.path, 'service'],
-      { apiName: args.value.name, serviceName: args.value.service },
-      ['delete-api-service-reference'],
-    )
+    report({
+      path: [...args.path, 'service'],
+      info: {
+        title: 'Unknown Service',
+        description: `**${args.value.service}** does not exist. The "${args.value.name}" API will not benefit from any information provided by the service. The service might have been deleted.`,
+      },
+      details: { apiName: args.value.name, serviceName: args.value.service },
+      fixes: ['delete-api-service-reference'],
+    })
   },
   fixes: {
     'delete-api-service-reference': removeFromPathFix,

package/src/rules/issues/apis/unknownFetchInputRule.ts

@@ -33,7 +33,15 @@ export const unknownFetchInputRule: Rule<
     const validInputs = new Set(Object.keys(targetApi.inputs ?? {}))
     for (const inputName of Object.keys(value.inputs ?? {})) {
       if (!validInputs.has(inputName)) {
-        report(path, { name: inputName }, ['delete-fetch-input'])
+        report({
+          path,
+          info: {
+            title: 'Unknown API input override',
+            description: `**${inputName}** does not exist as an input on the API. Either add the input on the API, or delete the override.`,
+          },
+          details: { name: inputName },
+          fixes: ['delete-fetch-input'],
+        })
       }
     }
   },

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)
     })