@platformos/platformos-check-common 0.0.8 → 0.0.9

package/src/checks/liquid-html-syntax-error/index.ts

@@ -9,6 +9,8 @@ import { detectInvalidLoopArguments } from './checks/InvalidLoopArguments';
 import { detectConditionalNodeUnsupportedParenthesis } from './checks/InvalidConditionalNodeParenthesis';
 import { detectInvalidFilterName } from './checks/InvalidFilterName';
 import { detectInvalidPipeSyntax } from './checks/InvalidPipeSyntax';
+import { detectUnknownTag } from './checks/UnknownTag';
+import { detectInvalidTagSyntax } from './checks/InvalidTagSyntax';
 import { isWithinRawTagThatDoesNotParseItsContents } from '../utils';
 
 type LineColPosition = {
@@ -64,11 +66,21 @@ export const LiquidHTMLSyntaxError: LiquidCheckDefinition = {
         async LiquidTag(node, ancestors) {
           if (isWithinRawTagThatDoesNotParseItsContents(ancestors)) return;
 
+          const tags = (await tagsPromise) ?? [];
+
+          // Unknown tags are fatal — no point in further syntax checks.
+          const unknownTagProblem = detectUnknownTag(node, tags);
+          if (unknownTagProblem) {
+            context.report(unknownTagProblem);
+            return;
+          }
+
+          // Run specific sub-checks first — they provide better error messages and autofixes.
           const problems = [
             detectMultipleAssignValues(node),
             detectInvalidEchoValue(node),
             detectInvalidLoopRange(node),
-            detectInvalidLoopArguments(node, await tagsPromise),
+            detectInvalidLoopArguments(node, tags),
           ].filter(Boolean) as Problem<SourceCodeType.LiquidHtml>[];
 
           // Fixers for `detectConditionalNodeUnsupportedParenthesis` and `detectInvalidConditionalNode` consume
@@ -80,9 +92,18 @@ export const LiquidHTMLSyntaxError: LiquidCheckDefinition = {
             problems.push(conditionalNodeProblem);
           }
 
+          // InvalidTagSyntax is a catch-all for known tags with unparseable markup.
+          // Only fire it if no more specific sub-check already reported on this tag.
+          if (problems.length === 0) {
+            const invalidSyntaxProblem = detectInvalidTagSyntax(node, tags);
+            if (invalidSyntaxProblem) {
+              problems.push(invalidSyntaxProblem);
+            }
+          }
+
           problems.forEach(context.report);
 
-          const filterProblems = await detectInvalidFilterName(node, await filtersPromise);
+          const filterProblems = await detectInvalidFilterName(node, (await filtersPromise) ?? []);
           if (filterProblems.length > 0) {
             filterProblems.forEach((filterProblem) => context.report(filterProblem));
           }
@@ -108,7 +129,7 @@ export const LiquidHTMLSyntaxError: LiquidCheckDefinition = {
         async LiquidVariableOutput(node, ancestors) {
           if (isWithinRawTagThatDoesNotParseItsContents(ancestors)) return;
 
-          const filterProblems = await detectInvalidFilterName(node, await filtersPromise);
+          const filterProblems = await detectInvalidFilterName(node, (await filtersPromise) ?? []);
           if (filterProblems.length > 0) {
             filterProblems.forEach((problem) => context.report(problem));
           }

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

@@ -4,36 +4,36 @@ import { MatchingTranslations } from '../../checks/matching-translations/index';
 
 describe('Module: MatchingTranslations', async () => {
   it('should report offenses when the translation file is missing a key', async () => {
-    const theme = {
+    const app = {
       'app/translations/en.yml': 'en:\n  hello: Hello\n  world: World\n',
       'app/translations/pt-BR.yml': 'pt-BR:\n  hello: Olá\n',
     };
 
-    const offenses = await check(theme, [MatchingTranslations]);
+    const offenses = await check(app, [MatchingTranslations]);
 
     expect(offenses).to.be.of.length(1);
     expect(offenses).to.containOffense("The translation for 'world' is missing");
   });
 
   it('should report offenses when the default translation is missing a key', async () => {
-    const theme = {
+    const app = {
       'app/translations/en.yml': 'en:\n  hello: Hello\n',
       'app/translations/pt-BR.yml': 'pt-BR:\n  hello: Olá\n  world: Mundo\n',
     };
 
-    const offenses = await check(theme, [MatchingTranslations]);
+    const offenses = await check(app, [MatchingTranslations]);
 
     expect(offenses).to.be.of.length(1);
-    expect(offenses).to.containOffense("A default translation for 'world' does not exist");
+    expect(offenses).to.containOffense("A translation for 'world' does not exist in the en locale");
   });
 
   it('should report offenses when nested translation keys do not exist', async () => {
-    const theme = {
+    const app = {
       'app/translations/en.yml': 'en:\n  hello:\n    world: Hello, world!\n',
       'app/translations/pt-BR.yml': 'pt-BR:\n  hello: {}\n',
     };
 
-    const offenses = await check(theme, [MatchingTranslations]);
+    const offenses = await check(app, [MatchingTranslations]);
 
     expect(offenses).to.be.of.length(1);
     expect(offenses).to.containOffense({
@@ -43,16 +43,16 @@ describe('Module: MatchingTranslations', async () => {
   });
 
   it('should report offenses when translation shapes do not match', async () => {
-    const theme = {
+    const app = {
       'app/translations/en.yml': 'en:\n  hello:\n    world: Hello, world!\n',
       'app/translations/pt-BR.yml': 'pt-BR:\n  hello: Olá\n',
     };
 
-    const offenses = await check(theme, [MatchingTranslations]);
+    const offenses = await check(app, [MatchingTranslations]);
 
     expect(offenses).to.be.of.length(2);
     expect(offenses).to.containOffense({
-      message: "A default translation for 'hello' does not exist",
+      message: "A translation for 'hello' does not exist in the en locale",
       uri: `file:///app/translations/pt-BR.yml`,
     });
     expect(offenses).to.containOffense({
@@ -62,22 +62,22 @@ describe('Module: MatchingTranslations', async () => {
   });
 
   it('should report offenses when nested translation keys do not match', async () => {
-    const theme = {
+    const app = {
       'app/translations/en.yml': 'en:\n  hello:\n    world: Hello, world!\n',
       'app/translations/fr.yml': 'fr:\n  hello:\n    monde: Bonjour, monde\n',
       'app/translations/es-ES.yml':
         'es-ES:\n  hello:\n    world: Hello, world!\n    mundo:\n      hola: "¡Hola, mundo!"\n',
     };
 
-    const offenses = await check(theme, [MatchingTranslations]);
+    const offenses = await check(app, [MatchingTranslations]);
 
     expect(offenses).to.be.of.length(3);
     expect(offenses).to.containOffense({
-      message: "A default translation for 'hello.monde' does not exist",
+      message: "A translation for 'hello.monde' does not exist in the en locale",
       uri: `file:///app/translations/fr.yml`,
     });
     expect(offenses).to.containOffense({
-      message: "A default translation for 'hello.mundo.hola' does not exist",
+      message: "A translation for 'hello.mundo.hola' does not exist in the en locale",
       uri: `file:///app/translations/es-ES.yml`,
     });
     expect(offenses).to.containOffense({
@@ -87,57 +87,147 @@ describe('Module: MatchingTranslations', async () => {
   });
 
   it('should not report offenses when default translations do not exist (no en.yml)', async () => {
-    const theme = {
+    const app = {
       'app/translations/pt-BR.yml': 'pt-BR:\n  hello: Olá\n',
     };
 
-    const offenses = await check(theme, [MatchingTranslations]);
+    const offenses = await check(app, [MatchingTranslations]);
 
     expect(offenses).to.be.of.length(0);
   });
 
   it('should not report offenses when translations match', async () => {
-    const theme = {
+    const app = {
       'app/translations/en.yml': 'en:\n  hello: Hello\n  world: World\n',
       'app/translations/pt-BR.yml': 'pt-BR:\n  hello: Olá\n  world: Mundo\n',
     };
 
-    const offenses = await check(theme, [MatchingTranslations]);
+    const offenses = await check(app, [MatchingTranslations]);
 
     expect(offenses).to.be.of.length(0);
   });
 
   it('should not report offenses when nested translations match', async () => {
-    const theme = {
+    const app = {
       'app/translations/en.yml': 'en:\n  hello:\n    world: Hello, world!\n',
       'app/translations/pt-BR.yml': 'pt-BR:\n  hello:\n    world: Olá, mundo!\n',
       'app/translations/fr.yml': 'fr:\n  hello:\n    world: Bonjour, monde\n',
     };
 
-    const offenses = await check(theme, [MatchingTranslations]);
+    const offenses = await check(app, [MatchingTranslations]);
 
     expect(offenses).to.be.of.length(0);
   });
 
   it('should not report offenses and ignore pluralization', async () => {
-    const theme = {
+    const app = {
       'app/translations/en.yml': 'en:\n  hello:\n    one: Hello, you\n    other: "Hello, y\'all"\n',
       'app/translations/pt-BR.yml':
         'pt-BR:\n  hello:\n    zero: Estou sozinho :(\n    few: "Olá, galerinha :)"\n',
     };
 
-    const offenses = await check(theme, [MatchingTranslations]);
+    const offenses = await check(app, [MatchingTranslations]);
 
     expect(offenses).to.be.of.length(0);
   });
 
   it('should not highlight anything if the file is unparseable', async () => {
-    const theme = {
+    const app = {
       'app/translations/en.yml': 'en:\n  hello:\n    world: Hello, world!\n',
       'app/translations/pt-BR.yml': 'pt-BR:\n  hello: :\n  bad yaml',
     };
 
-    const offenses = await check(theme, [MatchingTranslations]);
+    const offenses = await check(app, [MatchingTranslations]);
+    expect(offenses).to.have.length(0);
+  });
+
+  // --- Multi-file / multi-scope tests ---
+
+  it('should not flag keys from a different translation scope (module vs app)', async () => {
+    // Module translations are auto-prefixed with their module name at runtime, so each
+    // module is its own isolated scope. The app scope should never need keys from
+    // modules/common-styling/public/translations/en.yml.
+    const app = {
+      'app/translations/en.yml': 'en:\n  hello: Hello\n',
+      'app/translations/pt-BR.yml': 'pt-BR:\n  hello: Olá\n',
+      'modules/common-styling/public/translations/en.yml':
+        'en:\n  password:\n    toggle_visibility: Toggle\n',
+    };
+
+    const offenses = await check(app, [MatchingTranslations]);
+    expect(offenses).to.have.length(0);
+  });
+
+  it('should report missing keys in a module non-en file against that module own en translations', async () => {
+    const app = {
+      'app/translations/en.yml': 'en:\n  hello: Hello\n',
+      'modules/common-styling/public/translations/en.yml':
+        'en:\n  password:\n    toggle_visibility: Toggle\n',
+      'modules/common-styling/public/translations/pt-BR.yml': 'pt-BR:\n  other: Outro\n',
+    };
+
+    const offenses = await check(app, [MatchingTranslations]);
+    expect(offenses).to.have.length(1);
+    expect(offenses).to.containOffense({
+      message: "The translation for 'password.toggle_visibility' is missing",
+      uri: 'file:///modules/common-styling/public/translations/pt-BR.yml',
+    });
+  });
+
+  it('should skip files inside the en/ locale sub-directory (they are English source files)', async () => {
+    // Files like app/translations/en/validation.yml are English — the check must not
+    // lint them as if they were a "non-English" locale file to compare.
+    const app = {
+      'app/translations/en/validation.yml': 'en:\n  required: Required\n',
+      'app/translations/pt-BR/validation.yml': 'pt-BR:\n  required: Obrigatório\n',
+    };
+
+    const offenses = await check(app, [MatchingTranslations]);
+    expect(offenses).to.have.length(0);
+  });
+
+  it('should aggregate multiple en/*.yml files within one scope as the reference set', async () => {
+    // Within the app scope, en/auth.yml and en/checkout.yml both contribute to the
+    // reference; pt-BR.yml must cover all of them.
+    const app = {
+      'app/translations/en/auth.yml': 'en:\n  login: Log in\n',
+      'app/translations/en/checkout.yml': 'en:\n  submit: Submit\n',
+      'app/translations/pt-BR.yml': 'pt-BR:\n  login: Entrar\n',
+    };
+
+    const offenses = await check(app, [MatchingTranslations]);
+    expect(offenses).to.have.length(1);
+    expect(offenses).to.containOffense({
+      message: "The translation for 'submit' is missing",
+      uri: 'file:///app/translations/pt-BR.yml',
+    });
+  });
+
+  it('should aggregate en.yml and en/*.yml together as the scope reference set', async () => {
+    const app = {
+      'app/translations/en.yml': 'en:\n  hello: Hello\n',
+      'app/translations/en/auth.yml': 'en:\n  login: Log in\n',
+      'app/translations/pt-BR.yml': 'pt-BR:\n  hello: Olá\n',
+    };
+
+    const offenses = await check(app, [MatchingTranslations]);
+    expect(offenses).to.have.length(1);
+    expect(offenses).to.containOffense({
+      message: "The translation for 'login' is missing",
+      uri: 'file:///app/translations/pt-BR.yml',
+    });
+  });
+
+  it('should not report a key as missing if it is covered by another file in the same locale scope', async () => {
+    // pt-BR/validation.yml covers 'required' — pt-BR.yml should not be blamed for it
+    const app = {
+      'app/translations/en.yml': 'en:\n  hello: Hello\n',
+      'app/translations/en/validation.yml': 'en:\n  required: Required\n',
+      'app/translations/pt-BR.yml': 'pt-BR:\n  hello: Olá\n',
+      'app/translations/pt-BR/validation.yml': 'pt-BR:\n  required: Obrigatório\n',
+    };
+
+    const offenses = await check(app, [MatchingTranslations]);
     expect(offenses).to.have.length(0);
   });
 });

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

@@ -5,10 +5,39 @@ import {
   Severity,
   SourceCodeType,
   PropertyNode,
+  ObjectNode,
 } from '../../types';
 
 const PLURALIZATION_KEYS = new Set(['zero', 'one', 'two', 'few', 'many', 'other']);
 
+/**
+ * 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',
@@ -25,48 +54,63 @@ export const MatchingTranslations: YAMLCheckDefinition = {
   },
 
   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 as YAMLSourceCode;
     const fileUri = file.uri;
     const relativePath = context.toRelativePath(fileUri);
     const ast = file.ast;
+
+    // ── Guard: only lint translation files ────────────────────────────────
     const isTranslationFile = relativePath.includes('/translations/');
-    // In platformOS, en.yml is the reference locale; skip running the check on it
-    const basename = fileUri.split('/').pop() ?? '';
-    const isDefaultTranslationsFile = basename.replace(/\.ya?ml$/, '') === 'en';
 
-    if (!isTranslationFile || isDefaultTranslationsFile || ast instanceof Error) {
-      // No need to lint a file that isn't a non-default translation file
+    // 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);
+    // ── 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).
@@ -74,90 +118,67 @@ export const MatchingTranslations: YAMLCheckDefinition = {
     // We want paths like 'hello', not 'en.hello'.
     const objectPath = (nodes: JSONNode[]) => {
       const props = nodes.filter((n): n is PropertyNode => n.type === 'Property');
-      if (props.length <= 1) return ''; // locale key itself, or empty
+      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 defaultTranslationPaths = await context.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; // skip the root locale key (e.g. 'pt-BR')
+        if (!path) return;
 
         nodesByPath.set(path, node);
 
-        if (!hasDefaultTranslations()) return;
         if (isPluralizationNode(node)) return;
         if (!isTerminalNode(node.value)) 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,
-        });
       },
 
       async onCodePathEnd() {
-        missingTranslations.forEach((path) => {
-          const closest = closestTranslationKey(path);
-
-          if (isPluralizationPath(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,
           });
-        });
+        }
       },
     };
   },

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

@@ -97,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-partial/index.ts

@@ -27,20 +27,20 @@ export const MissingPartial: 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/undefined-object/index.spec.ts

@@ -242,7 +242,7 @@ describe('Module: UndefinedObject', () => {
     }
   });
 
-  it('should report an offense when object is undefined in a "snippet" file with doc tags that are missing the associated param', async () => {
+  it('should report an offense when object is undefined in a "partial" file with doc tags that are missing the associated param', async () => {
     const sourceCode = `
     {% doc %}
     {% enddoc %}
@@ -259,7 +259,7 @@ describe('Module: UndefinedObject', () => {
     expect(offenses.map((e) => e.message)).toEqual(["Unknown object 'my_var' used."]);
   });
 
-  it('should not report an offense when object is defined with @param in a snippet file', async () => {
+  it('should not report an offense when object is defined with @param in a partial file', async () => {
     const sourceCode = `
       {% doc %}
         @param {string} text
@@ -410,4 +410,31 @@ describe('Module: UndefinedObject', () => {
     expect(offenses).toHaveLength(1);
     expect(offenses.map((e) => e.message)).toEqual(["Unknown object 'job_id' used."]);
   });
+
+  it('should not report an offense when object is defined with a parse_json tag', async () => {
+    const sourceCode = `
+      {% parse_json groups_data %}
+        { "hello": "world" }
+      {% endparse_json %}
+      {{ groups_data }}
+    `;
+
+    const offenses = await runLiquidCheck(UndefinedObject, sourceCode);
+
+    expect(offenses).toHaveLength(0);
+  });
+
+  it('should report an offense when parse_json variable is used before the tag', async () => {
+    const sourceCode = `
+      {{ groups_data }}
+      {% parse_json groups_data %}
+        { "hello": "world" }
+      {% endparse_json %}
+    `;
+
+    const offenses = await runLiquidCheck(UndefinedObject, sourceCode);
+
+    expect(offenses).toHaveLength(1);
+    expect(offenses[0].message).toBe("Unknown object 'groups_data' used.");
+  });
 });