@platformos/platformos-check-common 0.0.7 → 0.0.9

package/src/index.ts

@@ -1,13 +1,11 @@
-import { AugmentedThemeDocset } from './AugmentedThemeDocset';
+import { AugmentedPlatformOSDocset } from './AugmentedPlatformOSDocset';
 import { JSONValidator } from './JSONValidator';
 import {
   makeFileExists,
   makeFileSize,
   makeGetDefaultLocale,
-  makeGetDefaultSchemaLocale,
-  makeGetDefaultSchemaTranslations,
   makeGetDefaultTranslations,
-  makeGetMetafieldDefinitions,
+  makeGetTranslationsForBase,
 } from './context-utils';
 import { createDisabledChecksModule } from './disabled-checks';
 import { isIgnored } from './ignore';
@@ -35,22 +33,40 @@ import {
   Settings,
   SourceCode,
   SourceCodeType,
-  Theme,
+  App,
   ValidateJSON,
+  YAMLCheck,
+  YAMLSourceCode,
 } from './types';
 import { getPosition } from './utils';
 import { visitJSON, visitLiquid } from './visitors';
 
-export * from './AugmentedThemeDocset';
+export * from './AugmentedPlatformOSDocset';
+export * from './types/platformos-liquid-docs';
 export * from './checks';
 export * from './context-utils';
 export * from './find-root';
 export * from './fixes';
 export * from './ignore';
+export {
+  FILE_TYPE_DIRS,
+  getAppPaths,
+  getFileType,
+  getModulePaths,
+  isApiCall,
+  isAuthorization,
+  isEmail,
+  isKnownLiquidFile,
+  isLayout,
+  isMigration,
+  isPage,
+  isPartial,
+  isSms,
+  PlatformOSFileType,
+} from '@platformos/platformos-common';
 export * from './json';
 export * from './JSONValidator';
 export * as path from './path';
-export * from './to-schema';
 export * from './to-source-code';
 export * from './types';
 export * from './utils/error';
@@ -60,7 +76,6 @@ export * from './utils/types';
 export * from './utils/object';
 export * from './visitor';
 export * from './liquid-doc/liquidDoc';
-export { getBlockName } from './liquid-doc/arguments';
 export * from './liquid-doc/utils';
 
 const defaultErrorHandler = (_error: Error): void => {
@@ -68,7 +83,7 @@ const defaultErrorHandler = (_error: Error): void => {
 };
 
 export async function check(
-  theme: Theme,
+  app: App,
   config: Config,
   injectedDependencies: Dependencies,
 ): Promise<Offense[]> {
@@ -78,15 +93,11 @@ export async function check(
   const { rootUri } = config;
   const dependencies: AugmentedDependencies = {
     ...injectedDependencies,
-    mode: config.context,
     fileExists: makeFileExists(fs),
     fileSize: makeFileSize(fs),
     getDefaultLocale: makeGetDefaultLocale(fs, rootUri),
-    getDefaultTranslations: makeGetDefaultTranslations(fs, theme, rootUri),
-    getDefaultSchemaLocale: makeGetDefaultSchemaLocale(fs, rootUri),
-    getDefaultSchemaTranslations: makeGetDefaultSchemaTranslations(fs, theme, rootUri),
-    getMetafieldDefinitions:
-      injectedDependencies.getMetafieldDefinitions ?? makeGetMetafieldDefinitions(fs),
+    getDefaultTranslations: makeGetDefaultTranslations(fs, app, rootUri),
+    getTranslationsForBase: makeGetTranslationsForBase(fs, app),
   };
 
   const { DisabledChecksVisitor, isDisabled } = createDisabledChecksModule();
@@ -94,14 +105,14 @@ export async function check(
   const validateJSON = jsonValidator?.validate;
 
   // We're memozing those deps here because they shouldn't change within a run.
-  if (dependencies.themeDocset && !dependencies.themeDocset.isAugmented) {
-    dependencies.themeDocset = new AugmentedThemeDocset(dependencies.themeDocset);
+  if (dependencies.platformosDocset && !dependencies.platformosDocset.isAugmented) {
+    dependencies.platformosDocset = new AugmentedPlatformOSDocset(dependencies.platformosDocset);
   }
 
   for (const type of Object.values(SourceCodeType)) {
     switch (type) {
       case SourceCodeType.JSON: {
-        const files = filesOfType(type, theme);
+        const files = filesOfType(type, app);
         const checkDefs = checksOfType(type, config.checks);
         for (const file of files) {
           for (const checkDef of checkDefs) {
@@ -113,7 +124,7 @@ export async function check(
         break;
       }
       case SourceCodeType.GraphQL: {
-        const files = filesOfType(type, theme);
+        const files = filesOfType(type, app);
         const checkDefs = checksOfType(type, config.checks);
         for (const file of files) {
           for (const checkDef of checkDefs) {
@@ -125,7 +136,7 @@ export async function check(
         break;
       }
       case SourceCodeType.LiquidHtml: {
-        const files = filesOfType(type, theme);
+        const files = filesOfType(type, app);
         const checkDefs = [DisabledChecksVisitor, ...checksOfType(type, config.checks)];
         for (const file of files) {
           for (const checkDef of checkDefs) {
@@ -136,6 +147,18 @@ export async function check(
         }
         break;
       }
+      case SourceCodeType.YAML: {
+        const files = filesOfType(type, app);
+        const checkDefs = checksOfType(type, config.checks);
+        for (const file of files) {
+          for (const checkDef of checkDefs) {
+            if (isIgnored(file.uri, config, checkDef)) continue;
+            const check = createCheck(checkDef, file, config, offenses, dependencies, validateJSON);
+            pipelines.push(checkYAMLFile(check, file));
+          }
+        }
+        break;
+      }
     }
   }
 
@@ -210,7 +233,7 @@ function createCheck<S extends SourceCodeType>(
   return check.create(context as any) as Check<S>;
 }
 
-function filesOfType<S extends SourceCodeType>(type: S, sourceCodes: Theme): SourceCode<S>[] {
+function filesOfType<S extends SourceCodeType>(type: S, sourceCodes: App): SourceCode<S>[] {
   return sourceCodes.filter((file): file is SourceCode<S> => file.type === type);
 }
 
@@ -232,3 +255,10 @@ async function checkLiquidFile(check: LiquidCheck, file: LiquidSourceCode): Prom
   if (Object.keys(check).length > 0) await visitLiquid(file.ast, check);
   if (check.onCodePathEnd) await check.onCodePathEnd(file as typeof file & { ast: LiquidHtmlNode });
 }
+
+async function checkYAMLFile(check: YAMLCheck, file: YAMLSourceCode): Promise<void> {
+  if (check.onCodePathStart) await check.onCodePathStart(file);
+  if (file.ast instanceof Error) return;
+  if (Object.keys(check).length > 0) await visitJSON(file.ast, check as any);
+  if (check.onCodePathEnd) await check.onCodePathEnd(file as typeof file & { ast: JSONNode });
+}

package/src/jsonc/parse.ts

@@ -20,7 +20,7 @@ export class JSONCParseErrors extends Error {
 }
 
 /**
- * At some point, we started supporting JSONC. Theme Check 2 was built on top of
+ * At some point, we started supporting JSONC. App Check 2 was built on top of
  * `json-to-ast` which does not support comments.
  *
  * This little adapter here will take a tree we get from `jsonc-parser` and

package/src/liquid-doc/arguments.spec.ts

@@ -1,7 +1,7 @@
 import { describe, expect, it } from 'vitest';
 import { applyFixToString, createCorrector } from '../fixes';
 import { makeAddArgumentCorrector, makeRemoveArgumentCorrector } from './arguments';
-import { ContentForMarkup, DocumentNode, LiquidTag } from '@platformos/liquid-html-parser';
+import { DocumentNode, LiquidTag, RenderMarkup } from '@platformos/liquid-html-parser';
 import { SourceCodeType, toLiquidHTMLAST } from '..';
 
 describe('Arguments', () => {
@@ -15,53 +15,45 @@ describe('Arguments', () => {
     };
 
     it('should suggest adding missing required arguments when none already exist', () => {
-      const node = makeContentForMarkup(
-        `{% content_for 'block', type: 'swatches', id: 'fake', some-arg: '' %}`,
-      );
+      const node = makeRenderMarkup(`{% render 'partial', some-arg: '' %}`);
 
       const fixer = createCorrector(SourceCodeType.LiquidHtml, node.source);
 
       makeAddArgumentCorrector(node, requiredParam)(fixer);
 
       expect(applyFixToString(node.source, fixer.fix)).toBe(
-        `{% content_for 'block', type: 'swatches', id: 'fake', some-arg: '', required_string: '' %}`,
+        `{% render 'partial', some-arg: '', required_string: '' %}`,
       );
     });
 
     it('should suggest adding missing required arguments and correcting trailing comma + whitespace', () => {
-      const node = makeContentForMarkup(
-        `{% content_for 'block', type: 'swatches', id: 'fake', some-arg: '',    %}`,
-      );
+      const node = makeRenderMarkup(`{% render 'partial', some-arg: '',    %}`);
 
       const fixer = createCorrector(SourceCodeType.LiquidHtml, node.source);
 
       makeAddArgumentCorrector(node, requiredParam)(fixer);
 
       expect(applyFixToString(node.source, fixer.fix)).toBe(
-        `{% content_for 'block', type: 'swatches', id: 'fake', some-arg: '', required_string: '' %}`,
+        `{% render 'partial', some-arg: '', required_string: '' %}`,
       );
     });
 
     it('should suggest adding missing required arguments and correcting trailing spaces + comma', () => {
-      const node = makeContentForMarkup(
-        `{% content_for 'block', type: 'swatches', id: 'fake', some-arg: ''    ,    %}`,
-      );
+      const node = makeRenderMarkup(`{% render 'partial', some-arg: ''    ,    %}`);
 
       const fixer = createCorrector(SourceCodeType.LiquidHtml, node.source);
 
       makeAddArgumentCorrector(node, requiredParam)(fixer);
 
       expect(applyFixToString(node.source, fixer.fix)).toBe(
-        `{% content_for 'block', type: 'swatches', id: 'fake', some-arg: '', required_string: '' %}`,
+        `{% render 'partial', some-arg: '', required_string: '' %}`,
       );
     });
   });
 
   describe('makeRemoveArgumentCorrector', () => {
     it("should remove the last argument and it's leading comma", () => {
-      const node = makeContentForMarkup(
-        `{% content_for 'block', type: 'swatches', id: 'fake', some-arg: '' %}`,
-      );
+      const node = makeRenderMarkup(`{% render 'partial', id: 'fake', some-arg: '' %}`);
 
       const argToRemove = node.args.at(-1)!;
 
@@ -69,15 +61,11 @@ describe('Arguments', () => {
 
       makeRemoveArgumentCorrector(node, argToRemove)(fixer);
 
-      expect(applyFixToString(node.source, fixer.fix)).toBe(
-        `{% content_for 'block', type: 'swatches', id: 'fake' %}`,
-      );
+      expect(applyFixToString(node.source, fixer.fix)).toBe(`{% render 'partial', id: 'fake' %}`);
     });
 
     it('should remove an argument in the middle', () => {
-      const node = makeContentForMarkup(
-        `{% content_for 'block', type: 'swatches', id: 'fake', some-arg: '' %}`,
-      );
+      const node = makeRenderMarkup(`{% render 'partial', id: 'fake', some-arg: '' %}`);
 
       const argToRemove = node.args.at(-2)!;
 
@@ -85,15 +73,11 @@ describe('Arguments', () => {
 
       makeRemoveArgumentCorrector(node, argToRemove)(fixer);
 
-      expect(applyFixToString(node.source, fixer.fix)).toBe(
-        `{% content_for 'block', type: 'swatches', some-arg: '' %}`,
-      );
+      expect(applyFixToString(node.source, fixer.fix)).toBe(`{% render 'partial', some-arg: '' %}`);
     });
 
     it('should remove an argument with trailing comma', () => {
-      const node = makeContentForMarkup(
-        `{% content_for 'block', type: 'swatches', id: 'fake', some-arg: '', %}`,
-      );
+      const node = makeRenderMarkup(`{% render 'partial', id: 'fake', some-arg: '', %}`);
 
       const argToRemove = node.args.at(-1)!;
 
@@ -101,16 +85,12 @@ describe('Arguments', () => {
 
       makeRemoveArgumentCorrector(node, argToRemove)(fixer);
 
-      expect(applyFixToString(node.source, fixer.fix)).toBe(
-        `{% content_for 'block', type: 'swatches', id: 'fake' %}`,
-      );
+      expect(applyFixToString(node.source, fixer.fix)).toBe(`{% render 'partial', id: 'fake' %}`);
     });
   });
 
   it('should remove an argument with trailing space', () => {
-    const node = makeContentForMarkup(
-      `{% content_for 'block', type: 'swatches', id: 'fake'     , some-arg: '' %}`,
-    );
+    const node = makeRenderMarkup(`{% render 'partial', id: 'fake'     , some-arg: '' %}`);
 
     const argToRemove = node.args.at(-2)!;
 
@@ -118,15 +98,11 @@ describe('Arguments', () => {
 
     makeRemoveArgumentCorrector(node, argToRemove)(fixer);
 
-    expect(applyFixToString(node.source, fixer.fix)).toBe(
-      `{% content_for 'block', type: 'swatches', some-arg: '' %}`,
-    );
+    expect(applyFixToString(node.source, fixer.fix)).toBe(`{% render 'partial', some-arg: '' %}`);
   });
 
   it('should remove an argument with leading space', () => {
-    const node = makeContentForMarkup(
-      `{% content_for 'block', type: 'swatches', id: 'fake',    some-arg: '' %}`,
-    );
+    const node = makeRenderMarkup(`{% render 'partial', id: 'fake',    some-arg: '' %}`);
 
     const argToRemove = node.args.at(-1)!;
 
@@ -134,13 +110,11 @@ describe('Arguments', () => {
 
     makeRemoveArgumentCorrector(node, argToRemove)(fixer);
 
-    expect(applyFixToString(node.source, fixer.fix)).toBe(
-      `{% content_for 'block', type: 'swatches', id: 'fake' %}`,
-    );
+    expect(applyFixToString(node.source, fixer.fix)).toBe(`{% render 'partial', id: 'fake' %}`);
   });
 });
 
-function makeContentForMarkup(source: string): ContentForMarkup {
+function makeRenderMarkup(source: string): RenderMarkup {
   const ast = toLiquidHTMLAST(source) as DocumentNode;
-  return (ast.children[0] as LiquidTag).markup as ContentForMarkup;
+  return (ast.children[0] as LiquidTag).markup as RenderMarkup;
 }

package/src/liquid-doc/arguments.ts

@@ -3,7 +3,6 @@
  * errors when LiquidDoc exists
  */
 import {
-  ContentForMarkup,
   RenderMarkup,
   FunctionMarkup,
   LiquidNamedArgument,
@@ -17,20 +16,21 @@ import {
   isTypeCompatible,
 } from './utils';
 import { isLiquidString } from '../checks/utils';
+import { DocumentsLocator } from '@platformos/platformos-common';
+import { URI } from 'vscode-uri';
+import { relative } from '../path';
 
 /**
  * Report error when unknown arguments are provided for `content_for` tag or `render` tag
  */
 export function reportUnknownArguments(
   context: Context<SourceCodeType.LiquidHtml>,
-  node: ContentForMarkup | RenderMarkup | FunctionMarkup,
+  node: RenderMarkup | FunctionMarkup,
   unknownProvidedArgs: LiquidNamedArgument[],
   name: string,
 ) {
   let errorOwnerMessage = '';
-  if (node.type === NodeTypes.ContentForMarkup) {
-    errorOwnerMessage = ` in content_for tag for static block '${name}'`;
-  } else if (node.type === NodeTypes.RenderMarkup) {
+  if (node.type === NodeTypes.RenderMarkup) {
     errorOwnerMessage = ` in render tag for partial '${name}'`;
   } else if (node.type === NodeTypes.FunctionMarkup) {
     errorOwnerMessage = ` in function tag for partial '${name}'`;
@@ -56,14 +56,12 @@ export function reportUnknownArguments(
  */
 export function reportMissingArguments(
   context: Context<SourceCodeType.LiquidHtml>,
-  node: ContentForMarkup | RenderMarkup | FunctionMarkup,
+  node: RenderMarkup | FunctionMarkup,
   missingRequiredArgs: LiquidDocParameter[],
   name: string,
 ) {
   let errorOwnerMessage = '';
-  if (node.type === NodeTypes.ContentForMarkup) {
-    errorOwnerMessage = ` in content_for tag for static block '${name}'`;
-  } else if (node.type === NodeTypes.RenderMarkup) {
+  if (node.type === NodeTypes.RenderMarkup) {
     errorOwnerMessage = ` in render tag for partial '${name}'`;
   } else if (node.type === NodeTypes.FunctionMarkup) {
     errorOwnerMessage = ` in function tag for partial '${name}'`;
@@ -86,14 +84,12 @@ export function reportMissingArguments(
 
 export function reportDuplicateArguments(
   context: Context<SourceCodeType.LiquidHtml>,
-  node: ContentForMarkup | RenderMarkup | FunctionMarkup,
+  node: RenderMarkup | FunctionMarkup,
   duplicateArgs: LiquidNamedArgument[],
   name: string,
 ) {
   let errorOwnerMessage = '';
-  if (node.type === NodeTypes.ContentForMarkup) {
-    errorOwnerMessage = ` in content_for tag for static block '${name}'`;
-  } else if (node.type === NodeTypes.RenderMarkup) {
+  if (node.type === NodeTypes.RenderMarkup) {
     errorOwnerMessage = ` in render tag for partial '${name}'`;
   } else if (node.type === NodeTypes.FunctionMarkup) {
     errorOwnerMessage = ` in function tag for partial '${name}'`;
@@ -125,7 +121,13 @@ export function findTypeMismatchParams(
   const typeMismatchParams: LiquidNamedArgument[] = [];
 
   for (const arg of providedParams) {
-    if (arg.value.type === NodeTypes.VariableLookup) {
+    // Skip if the value is a variable lookup (can't determine type statically)
+    // or if it has filters (graphql args may have filters, output type is unknown)
+    if (arg.value.type === NodeTypes.LiquidVariable) {
+      if (arg.value.expression.type === NodeTypes.VariableLookup || arg.value.filters.length > 0) {
+        continue;
+      }
+    } else if (arg.value.type === NodeTypes.VariableLookup) {
       continue;
     }
 
@@ -208,35 +210,18 @@ export function generateTypeMismatchSuggestions(
   return suggestions;
 }
 
-function isLastArg(
-  node: RenderMarkup | ContentForMarkup | FunctionMarkup,
-  arg: LiquidNamedArgument,
-): boolean {
+function isLastArg(node: RenderMarkup | FunctionMarkup, arg: LiquidNamedArgument): boolean {
   return (
     node.args.length == 1 || arg.position.start == node.args[node.args.length - 1].position.start
   );
 }
 
-export function getBlockName(node: ContentForMarkup) {
-  if (node.contentForType.value !== 'block') {
-    return;
-  }
-
-  const contentForTypeArg = node.args.find((arg) => arg.name == 'type')?.value;
-
-  if (!contentForTypeArg || !isLiquidString(contentForTypeArg)) {
-    return;
-  }
-
-  return contentForTypeArg.value;
-}
-
 export function getPartialName(node: RenderMarkup | FunctionMarkup): string | undefined {
   if (node.type === NodeTypes.RenderMarkup) {
-    if (!isLiquidString(node.snippet)) {
+    if (!isLiquidString(node.partial)) {
       return;
     }
-    return node.snippet.value;
+    return node.partial.value;
   }
 
   if (node.type === NodeTypes.FunctionMarkup) {
@@ -249,19 +234,27 @@ export function getPartialName(node: RenderMarkup | FunctionMarkup): string | un
 
 export async function getLiquidDocParams(
   context: Context<SourceCodeType.LiquidHtml>,
-  relativePath: string,
+  partialName: string,
 ) {
-  const docDefinition = context.getDocDefinition && (await context.getDocDefinition(relativePath));
-
-  if (!docDefinition?.liquidDoc?.parameters) {
-    return;
+  if (!context.getDocDefinition) return;
+
+  // Use DocumentsLocator to find the partial across all platformOS locations,
+  // including app/views/partials/, app/lib/, and module paths.
+  const locator = new DocumentsLocator(context.fs);
+  const fileUri = await locator.locate(URI.parse(context.config.rootUri), 'render', partialName);
+  if (!fileUri) return undefined;
+
+  const relativePath = relative(fileUri, context.config.rootUri);
+  const docDefinition = await context.getDocDefinition(relativePath);
+  if (docDefinition?.liquidDoc?.parameters) {
+    return new Map(docDefinition.liquidDoc.parameters.map((p) => [p.name, p]));
   }
 
-  return new Map(docDefinition.liquidDoc.parameters.map((p) => [p.name, p]));
+  return undefined;
 }
 
 export function makeRemoveArgumentCorrector(
-  node: ContentForMarkup | RenderMarkup | FunctionMarkup,
+  node: RenderMarkup | FunctionMarkup,
   arg: LiquidNamedArgument,
 ) {
   return (fixer: StringCorrector) => {
@@ -287,7 +280,7 @@ export function makeRemoveArgumentCorrector(
 }
 
 export function makeAddArgumentCorrector(
-  node: ContentForMarkup | RenderMarkup | FunctionMarkup,
+  node: RenderMarkup | FunctionMarkup,
   arg: LiquidDocParameter,
 ) {
   return (fixer: StringCorrector) => {

package/src/liquid-doc/liquidDoc.spec.ts

@@ -238,7 +238,7 @@ describe('Unit: extractDocDefinition', () => {
     });
   });
 
-  it('should return snippetDefinition without liquidDoc property if doc header is not present', async () => {
+  it('should return partialDefinition without liquidDoc property if doc header is not present', async () => {
     const ast = toAST(`
       <div>No doc header here</div>
     `);

package/src/liquid-doc/liquidDoc.ts

@@ -9,8 +9,7 @@ import {
 
 export type GetDocDefinitionForURI = (
   uri: UriString,
-  category: 'blocks' | 'app/views/partials',
-  name: string,
+  partialName: string,
 ) => Promise<DocDefinition | undefined>;
 
 export type DocDefinition = {

package/src/liquid-doc/utils.ts

@@ -1,13 +1,12 @@
-import { LiquidExpression, NodeTypes } from '@platformos/liquid-html-parser';
+import { LiquidExpression, LiquidVariable, NodeTypes } from '@platformos/liquid-html-parser';
 import { assertNever } from '../utils';
-import { isSnippet } from '../to-schema';
-import { isBlock } from '../to-schema';
+import { isPartial } from '../path';
 import { ObjectEntry, UriString } from '../types';
 
 /**
  * The base set of supported param types for LiquidDoc.
  *
- * This is used in conjunction with objects defined in [liquid docs](https://shopify.dev/docs/api/liquid/objects)
+ * This is used in conjunction with objects defined in [liquid docs](https://documentation.platformos.com/api-reference/liquid/objects)
  * to determine ALL supported param types for LiquidDoc.
  *
  * References `getValidParamTypes`
@@ -36,7 +35,7 @@ export function getDefaultValueForType(type: string | null) {
       return '0';
     case BasicParamTypes.Boolean:
       return 'false';
-    case BasicParamTypes.Object: // Objects don't have a sensible default value (maybe `theme`?)
+    case BasicParamTypes.Object: // Objects don't have a sensible default value
     default:
       return '';
   }
@@ -45,7 +44,15 @@ export function getDefaultValueForType(type: string | null) {
 /**
  * Casts the value of a LiquidNamedArgument to a string representing the type of the value.
  */
-export function inferArgumentType(arg: LiquidExpression): BasicParamTypes {
+export function inferArgumentType(arg: LiquidExpression | LiquidVariable): BasicParamTypes {
+  if (arg.type === NodeTypes.LiquidVariable) {
+    // A variable with filters — delegate to the base expression if there are no filters,
+    // otherwise we can't statically determine the filtered output type.
+    if (arg.filters.length > 0) return BasicParamTypes.Object;
+    const expr = arg.expression;
+    if (expr.type === NodeTypes.BooleanExpression) return BasicParamTypes.Object;
+    return inferArgumentType(expr);
+  }
   switch (arg.type) {
     case NodeTypes.String:
       return BasicParamTypes.String;
@@ -55,6 +62,8 @@ export function inferArgumentType(arg: LiquidExpression): BasicParamTypes {
       return BasicParamTypes.Boolean;
     case NodeTypes.Range:
     case NodeTypes.VariableLookup:
+    case NodeTypes.JsonHashLiteral:
+    case NodeTypes.JsonArrayLiteral:
       return BasicParamTypes.Object;
     default:
       // This ensures that we have a case for every possible type for arg.value
@@ -81,12 +90,12 @@ export function isTypeCompatible(expectedType: string, actualType: BasicParamTyp
  * Checks if the provided file path supports the LiquidDoc tag.
  */
 export function filePathSupportsLiquidDoc(uri: UriString) {
-  return isSnippet(uri) || isBlock(uri);
+  return isPartial(uri);
 }
 
 /**
  * Dynamically generates a map of LiquidDoc param types using object entries from
- * [liquid docs](https://shopify.dev/docs/api/liquid/objects).
+ * [liquid docs](https://documentation.platformos.com/api-reference/liquid/objects).
  *
  * This is used in conjunction with the base set of supported param.
  *

package/src/path.ts

@@ -1,5 +1,21 @@
 import { RelativePath, UriString } from './types';
 import { URI, Utils } from 'vscode-uri';
+export {
+  isPartial,
+  isLayout,
+  isPage,
+  isAuthorization,
+  isEmail,
+  isApiCall,
+  isSms,
+  isMigration,
+  isKnownLiquidFile,
+  getFileType,
+  getAppPaths,
+  getModulePaths,
+  PlatformOSFileType,
+  FILE_TYPE_DIRS,
+} from '@platformos/platformos-common';
 
 export { URI, Utils };
 

package/src/test/MockApp.ts

@@ -0,0 +1,17 @@
+/**
+ * @example
+ * {
+ *   'app/views/layouts/layout.liquid': `
+ *     <html>
+ *       {{ content_for_page }}
+ *     </html>
+ *   `,
+ *   'app/views/partials/snip.liquid': `
+ *     <b>'hello world'</b>
+ *   `,
+ * }
+ */
+
+export type MockApp = {
+  [relativePath in string]: string;
+};