@platformos/platformos-check-common 0.0.7 → 0.0.9

package/src/checks/matching-translations/index.ts

@@ -1,174 +1,184 @@
 import {
-  JSONCheckDefinition,
+  YAMLCheckDefinition,
   JSONNode,
-  JSONSourceCode,
+  YAMLSourceCode,
   Severity,
   SourceCodeType,
   PropertyNode,
+  ObjectNode,
 } from '../../types';
 
 const PLURALIZATION_KEYS = new Set(['zero', 'one', 'two', 'few', 'many', 'other']);
 
-export const MatchingTranslations: JSONCheckDefinition = {
+/**
+ * Returns the locale declared in a YAML translation file by reading its first
+ * top-level key (e.g. `en`, `pt-BR`, `fr`).  platformOS determines a file's
+ * locale from content, not from its path.
+ */
+function getLocaleFromAst(ast: JSONNode | Error): string | null {
+  if (ast instanceof Error) return null;
+  if (ast.type !== 'Object') return null;
+  const firstProp = (ast as ObjectNode).children[0];
+  if (!firstProp || firstProp.type !== 'Property') return null;
+  return firstProp.key.value || null;
+}
+
+/**
+ * Extracts the translations base directory from a relative file path.
+ *
+ * e.g. `app/translations/pt-BR.yml`           → `app/translations`
+ *      `app/translations/pt-BR/validation.yml` → `app/translations`
+ *      `modules/x/public/translations/en.yml`  → `modules/x/public/translations`
+ *
+ * Returns `null` if the path doesn't contain a `/translations/` segment.
+ */
+function getTranslationRelativeBase(relativePath: string): string | null {
+  const idx = relativePath.lastIndexOf('/translations/');
+  if (idx === -1) return null;
+  return relativePath.substring(0, idx + '/translations'.length);
+}
+
+export const MatchingTranslations: YAMLCheckDefinition = {
   meta: {
     code: 'MatchingTranslations',
     name: 'Translation files should have the same keys',
     docs: {
       description: 'TODO',
       recommended: true,
-      url: 'https://shopify.dev/docs/storefronts/themes/tools/theme-check/checks/matching-translations',
+      url: 'https://documentation.platformos.com/developer-guide/platformos-check/checks/matching-translations',
     },
-    type: SourceCodeType.JSON,
+    type: SourceCodeType.YAML,
     severity: Severity.ERROR,
     schema: {},
     targets: [],
   },
 
   create(context) {
-    // State
-    const defaultTranslations = new Set<string>();
-    const missingTranslations = new Set<string>();
+    // ── State ──────────────────────────────────────────────────────────────
+    const enTranslations = new Set<string>(); // keys present in the en scope
+    const missingFromLocale = new Set<string>(); // en keys absent from the entire locale scope
     const nodesByPath = new Map<string, PropertyNode>();
-    const file = context.file;
+
+    const file = context.file as YAMLSourceCode;
     const fileUri = file.uri;
     const relativePath = context.toRelativePath(fileUri);
     const ast = file.ast;
-    const isLocaleFile = relativePath.startsWith('locales/');
-    const isDefaultTranslationsFile =
-      fileUri.endsWith('.default.json') || fileUri.endsWith('.default.schema.json');
-    const isSchemaTranslationFile = fileUri.endsWith('.schema.json');
-
-    if (!isLocaleFile || isDefaultTranslationsFile || ast instanceof Error) {
-      // No need to lint a file that isn't a translation file, we return an
-      // empty object as the check for those.
+
+    // ── Guard: only lint translation files ────────────────────────────────
+    const isTranslationFile = relativePath.includes('/translations/');
+
+    // The locale is always the first top-level key in the YAML file (e.g. `en`,
+    // `pt-BR`). platformOS resolves locale from content, not from the file path.
+    const locale = getLocaleFromAst(ast);
+
+    if (!isTranslationFile || !locale || locale === 'en' || ast instanceof Error) {
       return {};
     }
 
-    // Helpers
-    const hasDefaultTranslations = () => defaultTranslations.size > 0;
-    const isTerminalNode = ({ type }: JSONNode) => type === 'Literal';
-    const isPluralizationNode = (node: PropertyNode) => PLURALIZATION_KEYS.has(node.key.value);
-    const isShopifyPath = (path: string) => path.startsWith('shopify.');
+    // ── Derive scope (translation base URI) ──────────────────────────────
+    const relativeBase = getTranslationRelativeBase(relativePath);
+    if (!relativeBase) return {};
+
+    const translationBaseUri = context.toUri(relativeBase);
 
-    const hasDefaultTranslation = (translationPath: string) =>
-      defaultTranslations.has(translationPath) ?? false;
+    // A "primary" locale file is the top-level `{locale}.yml` (not inside a
+    // locale sub-directory like `pt-BR/`).  Only the primary file reports
+    // missing translations to avoid duplicate offenses across split files.
+    const pathAfterBase = relativePath.substring(relativeBase.length + 1);
+    const isPrimaryLocaleFile = !pathAfterBase.includes('/');
 
+    // ── Helpers ───────────────────────────────────────────────────────────
+    const isTerminalNode = ({ type }: JSONNode) => type === 'Literal';
+    const isPluralizationNode = (node: PropertyNode) => PLURALIZATION_KEYS.has(node.key.value);
     const isPluralizationPath = (path: string) =>
       [...PLURALIZATION_KEYS].some((key) => path.endsWith(key));
 
-    const jsonPaths = (json: any): string[] => {
-      const keys = Object.keys(json);
+    const countCommonParts = (a: string[], b: string[]): number => {
+      const min = Math.min(a.length, b.length);
+      for (let i = 0; i < min; i++) if (a[i] !== b[i]) return i;
+      return min;
+    };
 
-      return keys.reduce((acc: string[], key: string) => {
-        if (typeof json[key] !== 'object') {
-          return acc.concat(key);
+    const closestTranslationKey = (key: string) => {
+      const keyParts = key.split('.');
+      let closest = '';
+      let max = 0;
+      for (const path of nodesByPath.keys()) {
+        const common = countCommonParts(path.split('.'), keyParts);
+        if (common > max) {
+          max = common;
+          closest = path;
         }
-
-        const childJson = json[key];
-        const childPaths = jsonPaths(childJson);
-
-        return acc.concat(childPaths.map((path) => `${key}.${path}`));
-      }, []);
+      }
+      return nodesByPath.get(closest) ?? ast;
     };
 
+    // Strip the locale prefix (first Property in the ancestors chain).
+    // YAML files wrap content under a locale key: { en: { hello: 'Hello' } }
+    // We want paths like 'hello', not 'en.hello'.
     const objectPath = (nodes: JSONNode[]) => {
-      return nodes
-        .filter((node): node is PropertyNode => node.type === 'Property')
-        .reduce((acc: string[], val) => acc.concat(val.key.value), [])
+      const props = nodes.filter((n): n is PropertyNode => n.type === 'Property');
+      if (props.length <= 1) return '';
+      return props
+        .slice(1)
+        .map((p) => p.key.value)
         .join('.');
     };
 
-    const countCommonParts = (arrayA: string[], arrayB: string[]): number => {
-      const minLength = Math.min(arrayA.length, arrayB.length);
-
-      for (let i = 0; i < minLength; i++) {
-        if (arrayA[i] !== arrayB[i]) {
-          return i;
-        }
-      }
-
-      return minLength;
-    };
-
-    const closestTranslationKey = (translationKey: string) => {
-      const translationKeyParts = translationKey.split('.');
-      let closestMatch = '';
-      let maxCommonParts = 0;
-
-      for (const path of nodesByPath.keys()) {
-        const pathParts = path.split('.');
-        const commonParts = countCommonParts(pathParts, translationKeyParts);
-
-        if (commonParts > maxCommonParts) {
-          maxCommonParts = commonParts;
-          closestMatch = path;
-        }
-      }
-
-      return nodesByPath.get(closestMatch) ?? ast;
-    };
+    const jsonPaths = (json: any): string[] =>
+      Object.keys(json).reduce((acc: string[], key: string) => {
+        if (typeof json[key] !== 'object') return acc.concat(key);
+        return acc.concat(jsonPaths(json[key]).map((p) => `${key}.${p}`));
+      }, []);
 
     return {
       async onCodePathStart() {
-        const getDefaultTranslations = isSchemaTranslationFile
-          ? context.getDefaultSchemaTranslations
-          : context.getDefaultTranslations;
-        const defaultTranslationPaths = await getDefaultTranslations().then(jsonPaths);
-        defaultTranslationPaths.forEach(Set.prototype.add, defaultTranslations);
-
-        // At the `onCodePathStart`, we assume that all translations are missing,
-        // and remove translation paths while traversing through the file.
-        defaultTranslationPaths.forEach(Set.prototype.add, missingTranslations);
+        // Aggregate ALL en translations in this scope (en.yml + en/*.yml)
+        const en = await context.getTranslationsForBase(translationBaseUri, 'en');
+        jsonPaths(en).forEach(Set.prototype.add, enTranslations);
+
+        if (!isPrimaryLocaleFile) return;
+
+        // For the primary locale file: pre-compute which en keys are absent
+        // from the entire locale scope (locale.yml + locale/*.yml).
+        const localeAgg = await context.getTranslationsForBase(translationBaseUri, locale);
+        const localeKeys = new Set(jsonPaths(localeAgg));
+        for (const key of enTranslations) {
+          if (!localeKeys.has(key)) missingFromLocale.add(key);
+        }
       },
 
       async Property(node, ancestors) {
         const path = objectPath(ancestors.concat(node));
+        if (!path) return;
 
         nodesByPath.set(path, node);
 
-        if (!hasDefaultTranslations()) return;
         if (isPluralizationNode(node)) return;
         if (!isTerminalNode(node.value)) return;
-        if (isShopifyPath(path)) return;
+        if (!enTranslations.size) return; // no en reference — skip
 
-        if (hasDefaultTranslation(path)) {
-          // As `path` is present, we remove it from the
-          // `missingTranslationsPerFile` bucket.
-          missingTranslations.delete(path);
-          return;
+        if (!enTranslations.has(path)) {
+          context.report({
+            message: `A translation for '${path}' does not exist in the en locale`,
+            startIndex: node.loc!.start.offset,
+            endIndex: node.loc!.end.offset,
+          });
         }
-
-        context.report({
-          message: `A default translation for '${path}' does not exist`,
-          startIndex: node.loc!.start.offset,
-          endIndex: node.loc!.end.offset,
-          suggest: [
-            {
-              message: 'Delete unneeded translation key',
-              fix(corrector) {
-                corrector.remove(path);
-              },
-            },
-          ],
-        });
       },
 
       async onCodePathEnd() {
-        missingTranslations.forEach((path) => {
-          const closest = closestTranslationKey(path);
-
-          if (isPluralizationPath(path)) return;
-          if (isShopifyPath(path)) return;
+        if (!isPrimaryLocaleFile) return;
 
+        for (const key of missingFromLocale) {
+          if (isPluralizationPath(key)) continue;
+          const closest = closestTranslationKey(key);
           context.report({
-            message: `The translation for '${path}' is missing`,
+            message: `The translation for '${key}' is missing`,
             startIndex: closest.loc!.start.offset,
             endIndex: closest.loc!.end.offset,
-            fix(corrector) {
-              corrector.add(path, 'TODO');
-            },
           });
-        });
+        }
       },
     };
   },

package/src/checks/metadata-params/index.ts

@@ -3,7 +3,6 @@ import yaml from 'js-yaml';
 import { DocumentsLocator, DocumentType } from '@platformos/platformos-common';
 import { URI } from 'vscode-uri';
 import { LiquidNamedArgument, Position } from '@platformos/liquid-html-parser';
-import { getLiquidDocParams } from '../../liquid-doc/arguments';
 import { relative } from '../../path';
 
 type Metadata = {
@@ -64,12 +63,11 @@ export const MetadataParamsCheck: LiquidCheckDefinition = {
       }
       let params = extractMetadataParams(await context.fs.readFile(locatedFile));
       if (!params) {
-        const liquidDocParameters = await getLiquidDocParams(
-          context,
-          relative(locatedFile, context.config.rootUri),
-        );
-
-        if (!liquidDocParameters) return;
+        if (!context.getDocDefinition) return;
+        const relativePath = relative(locatedFile, context.config.rootUri);
+        const docDef = await context.getDocDefinition(relativePath);
+        if (!docDef?.liquidDoc?.parameters) return;
+        const liquidDocParameters = new Map(docDef.liquidDoc.parameters.map((p) => [p.name, p]));
 
         params = Array.from(liquidDocParameters.values())
           .filter((p) => p.required)
@@ -99,7 +97,7 @@ export const MetadataParamsCheck: LiquidCheckDefinition = {
 
     return {
       async RenderMarkup(node) {
-        const targetFile = 'value' in node.snippet ? node.snippet.value : node.snippet.name;
+        const targetFile = 'value' in node.partial ? node.partial.value : node.partial.name;
         if (!targetFile) {
           return;
         }

package/src/checks/missing-asset/index.ts

@@ -11,7 +11,7 @@ export const MissingAsset: LiquidCheckDefinition = {
     docs: {
       description: 'Reports missing asset files',
       recommended: true,
-      url: 'https://shopify.dev/docs/storefronts/themes/tools/theme-check/checks/missing-asset',
+      url: 'https://documentation.platformos.com/developer-guide/platformos-check/checks/missing-asset',
     },
     type: SourceCodeType.LiquidHtml,
     severity: Severity.ERROR,

package/src/checks/{missing-template → missing-partial}/index.spec.ts

@@ -1,9 +1,9 @@
 import { expect, describe, it } from 'vitest';
-import { MissingTemplate } from '.';
+import { MissingPartial } from '.';
 import { check } from '../../test';
 
-describe('Module: MissingTemplate', () => {
-  it('should report missing template errors', async () => {
+describe('Module: MissingPartial', () => {
+  it('should report missing partial errors', async () => {
     const testCases = [
       {
         testCase: 'should report the missing partial to be rendered with "render"',
@@ -12,7 +12,7 @@ describe('Module: MissingTemplate', () => {
         {% render myvariable %}
       `,
         expected: {
-          check: 'MissingTemplate',
+          check: 'MissingPartial',
           end: {
             character: 27,
             index: 28,
@@ -49,11 +49,11 @@ describe('Module: MissingTemplate', () => {
       },
     ];
     for (const { testCase, file, expected, filesWith } of testCases) {
-      const offenses = await check(filesWith(file), [MissingTemplate]);
+      const offenses = await check(filesWith(file), [MissingPartial]);
 
       expect(offenses).to.have.length(1);
       expect(offenses, testCase).to.containOffense({
-        check: MissingTemplate.meta.code,
+        check: MissingPartial.meta.code,
         ...expected,
       });
     }

package/src/checks/{missing-template → missing-partial}/index.ts

@@ -1,19 +1,5 @@
-import {
-  LiquidTag,
-  LiquidTagNamed,
-  NamedTags,
-  NodeTypes,
-  Position,
-} from '@platformos/liquid-html-parser';
-import { minimatch } from 'minimatch';
-import {
-  LiquidCheckDefinition,
-  RelativePath,
-  SchemaProp,
-  Severity,
-  SourceCodeType,
-} from '../../types';
-import { doesFileExist } from '../../utils/file-utils';
+import { NodeTypes } from '@platformos/liquid-html-parser';
+import { LiquidCheckDefinition, SchemaProp, Severity, SourceCodeType } from '../../types';
 import { DocumentsLocator } from '@platformos/platformos-common';
 import { URI } from 'vscode-uri';
 
@@ -21,14 +7,14 @@ const schema = {
   ignoreMissing: SchemaProp.array(SchemaProp.string(), []),
 };
 
-export const MissingTemplate: LiquidCheckDefinition<typeof schema> = {
+export const MissingPartial: LiquidCheckDefinition<typeof schema> = {
   meta: {
-    code: 'MissingTemplate',
-    name: 'Avoid rendering missing templates',
+    code: 'MissingPartial',
+    name: 'Avoid rendering missing partials',
     docs: {
       description: 'Reports missing partial liquid file',
       recommended: true,
-      url: 'https://shopify.dev/docs/storefronts/themes/tools/theme-check/checks/missing-template',
+      url: 'https://documentation.platformos.com/developer-guide/platformos-check/checks/missing-partial',
     },
     type: SourceCodeType.LiquidHtml,
     severity: Severity.ERROR,
@@ -41,20 +27,20 @@ export const MissingTemplate: LiquidCheckDefinition<typeof schema> = {
 
     return {
       async RenderMarkup(node) {
-        if (node.snippet.type === NodeTypes.VariableLookup) return;
+        if (node.partial.type === NodeTypes.VariableLookup) return;
 
-        const snippet = node.snippet;
+        const partial = node.partial;
         const location = await locator.locate(
           URI.parse(context.config.rootUri),
           'render',
-          snippet.value,
+          partial.value,
         );
 
         if (!location) {
           context.report({
-            message: `'${snippet.value}' does not exist`,
-            startIndex: node.snippet.position.start,
-            endIndex: node.snippet.position.end,
+            message: `'${partial.value}' does not exist`,
+            startIndex: node.partial.position.start,
+            endIndex: node.partial.position.end,
           });
         }
       },

package/src/checks/orphaned-partial/index.ts

@@ -1,4 +1,4 @@
-import { isPartial } from '../../to-schema';
+import { isPartial } from '../../path';
 import { LiquidCheckDefinition, Severity, SourceCodeType } from '../../types';
 
 export const OrphanedPartial: LiquidCheckDefinition = {
@@ -6,9 +6,9 @@ export const OrphanedPartial: LiquidCheckDefinition = {
     code: 'OrphanedPartial',
     name: 'Prevent orphaned partials',
     docs: {
-      description: 'This check exists to prevent orphaned partials in themes.',
+      description: 'This check exists to prevent orphaned partials in platformOS apps.',
       recommended: true,
-      url: 'https://shopify.dev/docs/storefronts/themes/tools/theme-check/checks/orphaned-partial',
+      url: 'https://documentation.platformos.com/developer-guide/platformos-check/checks/orphaned-partial',
     },
     type: SourceCodeType.LiquidHtml,
     severity: Severity.WARNING,

package/src/checks/parser-blocking-script/index.spec.ts

@@ -3,26 +3,6 @@ import { ParserBlockingScript } from '.';
 import { applySuggestions, check as reportOffenses } from '../../test';
 
 describe('Module: ParserBlockingScript', () => {
-  it('should report the correct offense for the Liquid filter', async () => {
-    const file = "{{ 'asset' | script_tag }}";
-    const startIndex = file.indexOf('script_tag');
-    const endIndex = startIndex + 'script_tag'.length;
-
-    const offenses = await reportOffenses(
-      {
-        'code.liquid': file,
-      },
-      [ParserBlockingScript],
-    );
-
-    expect(offenses).to.have.length(1);
-    const { check, message, start, end } = offenses[0];
-    expect(check).to.equal(ParserBlockingScript.meta.code);
-    expect(message).to.contain('Use a <script> tag with async');
-    expect(start.index).to.equal(startIndex);
-    expect(end.index).to.equal(endIndex);
-  });
-
   it('should report the correct offense when using the script tag', async () => {
     const file = `
         <script src="https://foo.bar/baz.js"></script>
@@ -45,104 +25,6 @@ describe('Module: ParserBlockingScript', () => {
     expect(end.index).to.equal(endIndex);
   });
 
-  describe('Case: LiquidFilter corrections', () => {
-    it('should suggest to replace a LiquidVariableOutput with a script tag that has the expression as URL', async () => {
-      const file = "{{ 'asset' | script_tag }}";
-      const offenses = await reportOffenses(
-        {
-          'code.liquid': file,
-        },
-        [ParserBlockingScript],
-      );
-
-      expect(offenses).to.have.length(1);
-      const offense = offenses[0]!;
-      expect(offense).to.suggest(file, `Use an HTML script tag with the defer attribute instead`, {
-        startIndex: 0,
-        endIndex: file.length,
-        insert: `<script src="{{ 'asset' }}" defer></script>`,
-      });
-      expect(offense).to.suggest(file, `Use an HTML script tag with the async attribute instead`, {
-        startIndex: 0,
-        endIndex: file.length,
-        insert: `<script src="{{ 'asset' }}" async></script>`,
-      });
-
-      const suggestions = applySuggestions(file, offense);
-      expect(suggestions).to.include(`<script src="{{ 'asset' }}" defer></script>`);
-      expect(suggestions).to.include(`<script src="{{ 'asset' }}" async></script>`);
-    });
-
-    it('should suggest to replace a LiquidVariableOutput with a script tag that has the expression and previous filters as URL', async () => {
-      const file = "{{ 'asset' | asset_url | script_tag }}";
-      const offenses = await reportOffenses(
-        {
-          'code.liquid': file,
-        },
-        [ParserBlockingScript],
-      );
-
-      expect(offenses).to.have.length(1);
-      const offense = offenses[0];
-      expect(offense).to.suggest(file, `Use an HTML script tag with the defer attribute instead`, {
-        startIndex: 0,
-        endIndex: file.length,
-        insert: `<script src="{{ 'asset' | asset_url }}" defer></script>`,
-      });
-      expect(offense).to.suggest(file, `Use an HTML script tag with the async attribute instead`, {
-        startIndex: 0,
-        endIndex: file.length,
-        insert: `<script src="{{ 'asset' | asset_url }}" async></script>`,
-      });
-
-      const suggestions = applySuggestions(file, offense);
-      expect(suggestions).to.include(`<script src="{{ 'asset' | asset_url }}" defer></script>`);
-      expect(suggestions).to.include(`<script src="{{ 'asset' | asset_url }}" async></script>`);
-    });
-
-    it('should not suggest anything if the script_tag appears in an echo tag', async () => {
-      const file = "{% echo 'asset' | asset_url | script_tag %}";
-      const offenses = await reportOffenses(
-        {
-          'code.liquid': file,
-        },
-        [ParserBlockingScript],
-      );
-
-      expect(offenses).to.have.length(1);
-      const { suggest } = offenses[0];
-      expect(suggest).not.to.exist;
-    });
-
-    it('should not suggest anything if the script_tag appears in an assign tag', async () => {
-      const file = "{% assign script = 'asset' | asset_url | script_tag %}";
-      const offenses = await reportOffenses(
-        {
-          'code.liquid': file,
-        },
-        [ParserBlockingScript],
-      );
-
-      expect(offenses).to.have.length(1);
-      const { suggest } = offenses[0];
-      expect(suggest).not.to.exist;
-    });
-
-    it('should not suggest anything if the script_tag appears in a liquid tag', async () => {
-      const file = "{% liquid\necho 'asset' | asset_url | script_tag %}";
-      const offenses = await reportOffenses(
-        {
-          'code.liquid': file,
-        },
-        [ParserBlockingScript],
-      );
-
-      expect(offenses).to.have.length(1);
-      const { suggest } = offenses[0];
-      expect(suggest).not.to.exist;
-    });
-  });
-
   describe('Case: script tag suggestion', () => {
     it('should suggest adding both attributes at the end', async () => {
       const file = `<script src="a.js"></script>`;

package/src/checks/parser-blocking-script/index.ts

@@ -1,8 +1,6 @@
-import { NodeTypes } from '@platformos/liquid-html-parser';
 import { LiquidCheckDefinition, Severity, SourceCodeType } from '../../types';
-import { last } from '../../utils';
 import { hasAttributeValueOf, isAttr, isHtmlAttribute, isValuedHtmlAttribute } from '../utils';
-import { liquidFilterSuggestion, scriptTagSuggestion } from './suggestions';
+import { scriptTagSuggestion } from './suggestions';
 
 export const ParserBlockingScript: LiquidCheckDefinition = {
   meta: {
@@ -10,9 +8,9 @@ export const ParserBlockingScript: LiquidCheckDefinition = {
     aliases: ['ParserBlockingScriptTag'],
     name: 'Avoid parser blocking scripts',
     docs: {
-      description: 'They are bad ok?',
+      description: 'Parser-blocking scripts delay page rendering by blocking the HTML parser.',
       recommended: true,
-      url: 'https://shopify.dev/docs/storefronts/themes/tools/theme-check/checks/parser-blocking-javascript',
+      url: 'https://documentation.platformos.com/developer-guide/platformos-check/checks/parser-blocking-script',
     },
     type: SourceCodeType.LiquidHtml,
     severity: Severity.ERROR,
@@ -22,34 +20,6 @@ export const ParserBlockingScript: LiquidCheckDefinition = {
 
   create(context) {
     return {
-      // {{ 'asset' | asset_url | script_tag }}
-      LiquidFilter: async (node, ancestors) => {
-        if (node.name !== 'script_tag') return;
-
-        const filterString = node.source.slice(node.position.start, node.position.end);
-        const offset = filterString.indexOf('script_tag');
-        const parentNode = last(ancestors);
-        const grandParentNode = last(ancestors, -1);
-
-        context.report({
-          message:
-            'The script_tag filter is parser-blocking. Use a <script> tag with async or defer for better performance',
-          startIndex: node.position.start + offset,
-          endIndex: node.position.end,
-          suggest:
-            grandParentNode &&
-            grandParentNode.type === NodeTypes.LiquidVariableOutput &&
-            parentNode &&
-            parentNode.type === NodeTypes.LiquidVariable &&
-            last(parentNode.filters) === node
-              ? [
-                  liquidFilterSuggestion('defer', node, parentNode, grandParentNode),
-                  liquidFilterSuggestion('async', node, parentNode, grandParentNode),
-                ]
-              : undefined,
-        });
-      },
-
       // <script src="...">
       HtmlRawNode: async (node) => {
         if (node.name !== 'script') {