@platformos/platformos-check-common 0.0.2

package/src/checks/deprecated-fonts-on-sections-and-blocks/index.ts

@@ -0,0 +1,284 @@
+import { getSchema } from '../../to-schema';
+import {
+  JSONNode,
+  LiquidCheckDefinition,
+  Section,
+  Severity,
+  Setting,
+  Preset,
+  SourceCodeType,
+  ThemeBlock,
+  Context,
+  ArrayNode,
+} from '../../types';
+import { getLocEnd, getLocStart, nodeAtPath } from '../../json';
+import { DEPRECATED_FONT_HANDLES } from './deprecated-fonts-data';
+
+export const DeprecatedFontsOnSectionsAndBlocks: LiquidCheckDefinition = {
+  meta: {
+    code: 'DeprecatedFontsOnSectionsAndBlocks',
+    name: 'Check for deprecated fonts in section and block schema settings values',
+    docs: {
+      description: 'Warns on deprecated fonts in section and block schema settings values.',
+      recommended: true,
+      url: 'https://shopify.dev/docs/storefronts/themes/tools/theme-check/checks/deprecated-fonts-on-sections-and-blocks',
+    },
+    type: SourceCodeType.LiquidHtml,
+    severity: Severity.WARNING,
+    schema: {},
+    targets: [],
+  },
+
+  create(context) {
+    return {
+      async LiquidRawTag(node) {
+        if (node.name !== 'schema' || node.body.kind !== 'json') {
+          return;
+        }
+
+        const schema = await getSchema(context);
+        const { validSchema, ast } = schema ?? {};
+        if (!validSchema || validSchema instanceof Error) return;
+        if (!ast || ast instanceof Error) return;
+
+        const offset = node.blockStartPosition.end;
+
+        // 1st: check schema settings for deprecated fonts
+        checkSchemaSettingsForDeprecatedFonts(validSchema, offset, ast, context);
+
+        // 2nd: check local blocks settings for deprecated fonts
+        checkLocalBlocksSettingsForDeprecatedFonts(validSchema, offset, ast, context);
+
+        // 3rd: check preset settings for deprecated fonts
+        await checkPresetsForDeprecatedFonts(validSchema, offset, ast, context);
+
+        // 4th: check schema default (sections only) for deprecated fonts
+        if ('default' in validSchema) {
+          await checkSchemaDefaultForDeprecatedFonts(
+            validSchema as Section.Schema,
+            offset,
+            ast,
+            context,
+          );
+        }
+      },
+    };
+  },
+};
+
+function checkSchemaSettingsForDeprecatedFonts(
+  schema: ThemeBlock.Schema | Section.Schema,
+  offset: number,
+  ast: JSONNode,
+  context: Context<SourceCodeType.LiquidHtml>,
+) {
+  const settings = schema.settings;
+  if (!settings) return;
+
+  checkSettingsForDeprecatedFonts(settings, offset, ast, ['settings'], context);
+}
+
+function checkSettingsForDeprecatedFonts(
+  settings: Setting.Any[],
+  offset: number,
+  ast: JSONNode,
+  warningAstPath: string[],
+  context: Context<SourceCodeType.LiquidHtml>,
+) {
+  settings.forEach((setting, index) => {
+    if (
+      setting.type === 'font_picker' &&
+      setting.default &&
+      DEPRECATED_FONT_HANDLES.has(setting.default)
+    ) {
+      const currentPath = warningAstPath.concat([String(index), 'default']);
+      reportWarning(
+        context,
+        offset,
+        ast as JSONNode,
+        currentPath,
+        `setting '${setting.id}' is using deprecated font '${setting.default}'`,
+      );
+    }
+  });
+}
+
+function checkLocalBlocksSettingsForDeprecatedFonts(
+  schema: ThemeBlock.Schema | Section.Schema,
+  offset: number,
+  ast: JSONNode,
+  context: Context<SourceCodeType.LiquidHtml>,
+) {
+  const blocks = schema.blocks;
+  if (!blocks) return;
+
+  blocks.forEach((block, index) => {
+    if ('settings' in block && block.settings) {
+      checkSettingsForDeprecatedFonts(
+        block.settings as Setting.Any[],
+        offset,
+        ast,
+        ['blocks', String(index), 'settings'],
+        context,
+      );
+    }
+  });
+}
+
+async function checkPresetsForDeprecatedFonts(
+  schema: ThemeBlock.Schema | Section.Schema,
+  offset: number,
+  ast: JSONNode,
+  context: Context<SourceCodeType.LiquidHtml>,
+) {
+  const presets = schema.presets;
+  if (!presets) return;
+
+  for (const [preset_index, preset] of presets.entries()) {
+    const warningAstPath = ['presets', String(preset_index)];
+    await checkSettingsAndBlocksForDeprecatedFonts(
+      preset.settings ?? {},
+      'blocks' in preset ? preset.blocks : undefined,
+      schema,
+      offset,
+      ast,
+      warningAstPath,
+      context,
+    );
+  }
+}
+
+async function checkSettingsAndBlocksForDeprecatedFonts(
+  settings: Setting.Values,
+  blocks:
+    | Preset.PresetBlockHash
+    | Preset.PresetBlockForArray[]
+    | Section.DefaultBlock[]
+    | undefined,
+  schema: ThemeBlock.Schema | Section.Schema,
+  offset: number,
+  ast: JSONNode,
+  warningAstPath: string[],
+  context: Context<SourceCodeType.LiquidHtml>,
+) {
+  // check settings for deprecated fonts
+  if (settings && typeof settings === 'object') {
+    Object.entries(settings).forEach(([settingKey, settingValue]) => {
+      if (
+        isFontPickerType(schema.settings ?? [], settingKey) &&
+        DEPRECATED_FONT_HANDLES.has(settingValue as string)
+      ) {
+        const currentPath = warningAstPath.concat(['settings', settingKey]);
+        reportWarning(
+          context,
+          offset,
+          ast,
+          currentPath,
+          `setting '${settingKey}' is using deprecated font '${settingValue}'`,
+        );
+      }
+    });
+  }
+
+  // check blocks for deprecated fonts
+  if (blocks) {
+    await checkBlocksForDeprecatedFonts(blocks, schema, offset, ast, context, warningAstPath);
+  }
+}
+
+async function checkBlocksForDeprecatedFonts(
+  blocks: Preset.PresetBlockHash | Preset.PresetBlockForArray[] | Section.DefaultBlock[],
+  schema: ThemeBlock.Schema | Section.Schema,
+  offset: number,
+  ast: JSONNode,
+  context: Context<SourceCodeType.LiquidHtml>,
+  nodePath: string[],
+) {
+  const iterator = Array.isArray(blocks) ? blocks.entries() : Object.entries(blocks!);
+
+  for (const [keyOrIndex, block] of iterator) {
+    const currentPath = nodePath.concat(['blocks', String(keyOrIndex)]);
+
+    // we'll need the schema to verify that the setting is a font_picker type
+    // local blocks don't have a schema coming from the another theme file, we need to get it from the schema of the section
+    // look in the schema blocks for the block type, if this block has a name, it's a local block, otherwise, it's a theme block
+    let validSchema = null;
+
+    schema.blocks?.forEach((schemaBlock) => {
+      if (schemaBlock.type === block.type && 'name' in schemaBlock) {
+        validSchema = schemaBlock;
+      }
+    });
+
+    if (!validSchema) {
+      const blockSchema = await context.getBlockSchema?.(block.type);
+      if (!blockSchema || blockSchema instanceof Error) continue;
+      validSchema = blockSchema.validSchema;
+      if (!validSchema || validSchema instanceof Error) continue;
+    }
+
+    // block_value is the hash which can have settings, blocks, etc.
+    for (const [settingKey, settingValue] of Object.entries(block.settings ?? {})) {
+      if (settingValue && DEPRECATED_FONT_HANDLES.has(settingValue as string)) {
+        // Check if the setting is a font_picker
+        const isFontPickerSetting = isFontPickerType(validSchema.settings ?? [], settingKey);
+        if (isFontPickerSetting) {
+          reportWarning(
+            context,
+            offset,
+            ast,
+            currentPath.concat(['settings', settingKey]),
+            `setting '${settingKey}' is using deprecated font '${settingValue}'`,
+          );
+        }
+      }
+    }
+
+    if ('blocks' in block && block.blocks) {
+      await checkBlocksForDeprecatedFonts(block.blocks, schema, offset, ast, context, currentPath);
+    }
+  }
+}
+
+async function checkSchemaDefaultForDeprecatedFonts(
+  schema: Section.Schema,
+  offset: number,
+  ast: JSONNode,
+  context: Context<SourceCodeType.LiquidHtml>,
+) {
+  const defaultValues = schema.default;
+  if (!defaultValues || typeof defaultValues !== 'object') return;
+
+  const warningAstPath = ['default'];
+  await checkSettingsAndBlocksForDeprecatedFonts(
+    defaultValues.settings ?? {},
+    'blocks' in defaultValues ? defaultValues.blocks : undefined,
+    schema,
+    offset,
+    ast,
+    warningAstPath,
+    context,
+  );
+}
+
+function isFontPickerType(settings: Setting.Any[], settingKey: string) {
+  return settings.some((setting) => setting.id === settingKey && setting.type === 'font_picker');
+}
+
+function reportWarning(
+  context: Context<SourceCodeType.LiquidHtml>,
+  offset: number,
+  ast: JSONNode,
+  ast_path: string[],
+  message: string,
+  fullHighlight: boolean = true,
+) {
+  const node = nodeAtPath(ast, ast_path)! as ArrayNode;
+  const startIndex = fullHighlight ? offset + getLocStart(node) : offset + getLocEnd(node) - 1; // start to finish of the node or last char of the node
+  const endIndex = offset + getLocEnd(node);
+  context.report({
+    message: message,
+    startIndex,
+    endIndex,
+  });
+}

package/src/checks/deprecated-fonts-on-settings-schema/index.spec.ts

@@ -0,0 +1,102 @@
+import { describe, it, expect } from 'vitest';
+import { DeprecatedFontsOnSettingsSchema } from './index';
+import { runJSONCheck } from '../../test';
+
+describe('Module: DeprecatedFontsOnSettingsSchema', () => {
+  it('reports a warning when settings_schema.json has a deprecated font', async () => {
+    const sourceCode = `[
+      {
+        "name": "Fonts",
+        "settings": [
+          {
+            "type": "font_picker",
+            "id": "heading_font",
+            "label": "Heading font",
+            "default": "helvetica_n4"
+          }
+        ]
+      }
+    ]`;
+
+    const offenses = await runJSONCheck(
+      DeprecatedFontsOnSettingsSchema,
+      sourceCode,
+      'config/settings_schema.json',
+    );
+
+    expect(offenses).toHaveLength(1);
+    expect(offenses[0].message).toEqual('The font "helvetica_n4" is deprecated');
+  });
+
+  it('reports no warning when settings_schema.json has non-deprecated fonts', async () => {
+    const sourceCode = `[
+      {
+        "name": "Fonts",
+        "settings": [
+          {
+            "type": "font_picker",
+            "id": "heading_font",
+            "label": "Heading font",
+            "default": "alegreya_n4"
+          }
+        ]
+      }
+    ]`;
+
+    const offenses = await runJSONCheck(
+      DeprecatedFontsOnSettingsSchema,
+      sourceCode,
+      'config/settings_schema.json',
+    );
+
+    expect(offenses).toHaveLength(0);
+  });
+
+  it('reports no warning for non-font_picker settings', async () => {
+    const sourceCode = `[
+      {
+        "name": "Fonts",
+        "settings": [
+          {
+            "type": "text",
+            "id": "heading_text",
+            "label": "Heading text",
+            "default": "helvetica_n4"
+          }
+        ]
+      }
+    ]`;
+
+    const offenses = await runJSONCheck(
+      DeprecatedFontsOnSettingsSchema,
+      sourceCode,
+      'config/settings_schema.json',
+    );
+
+    expect(offenses).toHaveLength(0);
+  });
+
+  it('does not run check on files other than settings_schema.json', async () => {
+    const sourceCode = `[
+      {
+        "name": "Fonts",
+        "settings": [
+          {
+            "type": "font_picker",
+            "id": "heading_font",
+            "label": "Heading font",
+            "default": "helvetica_n4"
+          }
+        ]
+      }
+    ]`;
+
+    const offenses = await runJSONCheck(
+      DeprecatedFontsOnSettingsSchema,
+      sourceCode,
+      'config/other_file.json',
+    );
+
+    expect(offenses).toHaveLength(0);
+  });
+});

package/src/checks/deprecated-fonts-on-settings-schema/index.ts

@@ -0,0 +1,66 @@
+import {
+  JSONCheckDefinition,
+  Severity,
+  SourceCodeType,
+  isArrayNode,
+  isObjectNode,
+} from '../../types';
+import { getLocStart, getLocEnd } from '../../json';
+import { DEPRECATED_FONT_HANDLES } from '../deprecated-fonts-on-sections-and-blocks/deprecated-fonts-data';
+
+export const DeprecatedFontsOnSettingsSchema: JSONCheckDefinition = {
+  meta: {
+    code: 'DeprecatedFontsOnSettingsSchema',
+    name: 'Check for deprecated fonts in settings_schema settings values',
+    docs: {
+      description: 'Warns on deprecated fonts in settings_schema settings values.',
+      recommended: true,
+      url: 'https://shopify.dev/docs/storefronts/themes/tools/theme-check/checks/deprecated-fonts-on-settings-schema',
+    },
+    type: SourceCodeType.JSON,
+    severity: Severity.WARNING,
+    schema: {},
+    targets: [],
+  },
+
+  create(context) {
+    const relativePath = context.toRelativePath(context.file.uri);
+    if (relativePath !== 'config/settings_schema.json') return {};
+
+    return {
+      async Property(node) {
+        if (node.key.value === 'settings' && isArrayNode(node.value)) {
+          for (const setting of node.value.children) {
+            if (isObjectNode(setting)) {
+              const typeProperty = setting.children.find((prop) => prop.key.value === 'type');
+              if (
+                typeProperty &&
+                typeProperty.value.type === 'Literal' &&
+                typeProperty.value.value === 'font_picker'
+              ) {
+                // Check if this font_picker has a default value that's deprecated
+                const defaultProperty = setting.children.find(
+                  (prop) => prop.key.value === 'default',
+                );
+                if (
+                  defaultProperty &&
+                  defaultProperty.value.type === 'Literal' &&
+                  typeof defaultProperty.value.value === 'string'
+                ) {
+                  const defaultFont = defaultProperty.value.value;
+                  if (DEPRECATED_FONT_HANDLES.has(defaultFont)) {
+                    context.report({
+                      message: `The font "${defaultFont}" is deprecated`,
+                      startIndex: getLocStart(defaultProperty.value),
+                      endIndex: getLocEnd(defaultProperty.value),
+                    });
+                  }
+                }
+              }
+            }
+          }
+        }
+      },
+    };
+  },
+};

package/src/checks/deprecated-tag/index.spec.ts

@@ -0,0 +1,68 @@
+import { expect, describe, it } from 'vitest';
+import { highlightedOffenses, runLiquidCheck } from '../../test';
+import { DeprecatedTag } from './index';
+
+describe.skip('Module: DeprecatedTag', () => {
+  it('should report an offense when include tag is used', async () => {
+    const sourceCode = `
+      {% include 'templates/foo.liquid' %}
+    `;
+    const offenses = await runLiquidCheck(DeprecatedTag, sourceCode);
+
+    expect(offenses).toHaveLength(1);
+    expect(offenses[0].message).toEqual(`Use the 'render' tag instead of 'include'`);
+
+    const highlights = highlightedOffenses({ 'file.liquid': sourceCode }, offenses);
+    expect(highlights).toEqual(['include']);
+  });
+
+  it('should not report an offense when render tag is used', async () => {
+    const sourceCode = `
+      {% render 'templates/foo.liquid' %}
+    `;
+    const offenses = await runLiquidCheck(DeprecatedTag, sourceCode);
+
+    expect(offenses).toHaveLength(0);
+
+    const highlights = highlightedOffenses({ 'file.liquid': sourceCode }, offenses);
+    expect(highlights).toHaveLength(0);
+  });
+
+  it('should suggest replacing include tag with render tag', async () => {
+    const sourceCode = `
+      {% include 'foo.liquid' %}
+      {% assign greeting = "hello world" %}
+      {% include 'greeting.liquid' %}
+    `;
+    const offenses = await runLiquidCheck(DeprecatedTag, sourceCode);
+
+    expect(offenses).toHaveLength(2);
+    if (!offenses[0].suggest || !offenses[1].suggest) return;
+
+    expect(offenses[0].suggest[0].message).toEqual(`Replace 'include' with 'render'`);
+    expect(offenses[1].suggest[0].message).toEqual(`Replace 'include' with 'render'`);
+
+    const highlights = highlightedOffenses({ 'file.liquid': sourceCode }, offenses);
+    expect(highlights).toHaveLength(2);
+    expect(highlights[0]).toBe('include');
+    expect(highlights[1]).toBe('include');
+  });
+
+  it('should report multiple offenses when multiple include tags are used in the same line', async () => {
+    const sourceCode = "{% include 'foo.liquid' %} Some text {% include 'bar.liquid' %}";
+    const offenses = await runLiquidCheck(DeprecatedTag, sourceCode);
+
+    expect(offenses).toHaveLength(2);
+  });
+
+  it('should report offenses when include tags are nested', async () => {
+    const sourceCode = "{% if true %} {% include 'foo.liquid' %} {% endif %}";
+    const offenses = await runLiquidCheck(DeprecatedTag, sourceCode);
+
+    expect(offenses).toHaveLength(1);
+    expect(offenses[0].message).toEqual(`Use the 'render' tag instead of 'include'`);
+
+    const highlights = highlightedOffenses({ 'file.liquid': sourceCode }, offenses);
+    expect(highlights).toEqual(['include']);
+  });
+});

package/src/checks/deprecated-tag/index.ts

@@ -0,0 +1,46 @@
+import { Severity, SourceCodeType, LiquidCheckDefinition } from '../../types';
+
+export const DeprecatedTag: LiquidCheckDefinition = {
+  meta: {
+    code: 'DeprecatedTag',
+    aliases: ['DeprecatedTags'],
+    name: 'Deprecated Tag',
+    docs: {
+      description: 'This check is aimed at eliminating the use of deprecated tags.',
+      url: 'https://shopify.dev/docs/storefronts/themes/tools/theme-check/checks/deprecated-tag',
+      recommended: true,
+    },
+    type: SourceCodeType.LiquidHtml,
+    severity: Severity.WARNING,
+    schema: {},
+    targets: [],
+  },
+
+  create(context) {
+    return {
+      async LiquidTag(node) {
+        // commenting this out to stop include from getting flagged
+        // if (node.name === 'include') {
+        //   const start = node.source.substring(node.position.start);
+        //   const includeStartIndex = start.indexOf('include');
+        //   const includeEndIndex = includeStartIndex + 'include'.length;
+        //   const includeStart = node.position.start + includeStartIndex;
+        //   const includeEnd = node.position.start + includeEndIndex;
+        //   context.report({
+        //     message: `Use the 'render' tag instead of 'include'`,
+        //     startIndex: includeStart,
+        //     endIndex: includeEnd,
+        //     suggest: [
+        //       {
+        //         message: `Replace 'include' with 'render'`,
+        //         fix: (corrector) => {
+        //           corrector.replace(includeStart, includeEnd, 'render');
+        //         },
+        //       },
+        //     ],
+        //   });
+        // }
+      },
+    };
+  },
+};

package/src/checks/duplicate-content-for-arguments/index.spec.ts

@@ -0,0 +1,98 @@
+import { describe, it, expect } from 'vitest';
+import { DuplicateContentForArguments } from '.';
+import { runLiquidCheck, applySuggestions } from '../../test';
+
+describe('Module: DuplicateContentForArguments', () => {
+  function runCheck(sourceCode: string) {
+    return runLiquidCheck(DuplicateContentForArguments, sourceCode);
+  }
+
+  describe('detection', () => {
+    it('should report duplicate arguments in content_for tags', async () => {
+      const sourceCode = `
+        {% content_for 'block', type: 'fake-block', param1: 'value1', param2: 'value2', param1: 'value3' %}
+      `;
+
+      const offenses = await runCheck(sourceCode);
+
+      expect(offenses).toHaveLength(1);
+      expect(offenses[0].message).toMatch(/Duplicate argument 'param1'/);
+      expect(offenses[0].suggest).toBeDefined();
+      expect(offenses[0].suggest!.length).toBe(1);
+      expect(offenses[0].suggest![0].message).toBe("Remove duplicate argument 'param1'");
+    });
+
+    it('should report multiple duplicate arguments in content_for tags', async () => {
+      const sourceCode = `
+        {% content_for 'block', type: 'fake-block', param1: 'value1', param2: 'value2', param1: 'value3', param2: 'value4', param1: 'value5' %}
+      `;
+
+      const offenses = await runCheck(sourceCode);
+
+      expect(offenses).toHaveLength(3);
+      expect(offenses[0].message).toMatch(/Duplicate argument 'param1'/);
+      expect(offenses[0].start.index).toBe(sourceCode.indexOf("param1: 'value3'"));
+      expect(offenses[1].message).toMatch(/Duplicate argument 'param2'/);
+      expect(offenses[1].start.index).toBe(sourceCode.indexOf("param2: 'value4'"));
+      expect(offenses[2].message).toMatch(/Duplicate argument 'param1'/);
+      expect(offenses[2].start.index).toBe(sourceCode.indexOf("param1: 'value5'"));
+    });
+  });
+
+  describe('suggestions', () => {
+    it('should correctly suggest fixing all duplicate arguments except for the first', async () => {
+      const sourceCode = `{% content_for 'block', type: 'fake-block', param1: 'value1', param2: 'value2', param1: 'value3', param1: 'value4' %}`;
+      const offenses = await runCheck(sourceCode);
+
+      expect(offenses).toHaveLength(2);
+      expect(offenses[0].start.index).toBe(sourceCode.indexOf("param1: 'value3'"));
+      expect(offenses[1].start.index).toBe(sourceCode.indexOf("param1: 'value4'"));
+      const suggestionResult = applySuggestions(sourceCode, offenses[0]);
+      expect(suggestionResult).toEqual([
+        `{% content_for 'block', type: 'fake-block', param1: 'value1', param2: 'value2', param1: 'value4' %}`,
+      ]);
+    });
+  });
+
+  describe('edge cases', () => {
+    it('should not report when there are no duplicate arguments', async () => {
+      const sourceCode = `
+        {% content_for 'block', type: 'fake-block', param1: 'value1', param2: 'value2', param3: 'value3' %}
+      `;
+
+      const offenses = await runCheck(sourceCode);
+
+      expect(offenses).toHaveLength(0);
+    });
+
+    it('should not report for variable render tags where partial name is a variable', async () => {
+      const sourceCode = `
+        {% render my_variable, param1: 'value1', param1: 'value2' %}
+      `;
+
+      const offenses = await runCheck(sourceCode);
+
+      expect(offenses).toHaveLength(0);
+    });
+
+    it('should handle remove duplicate param when there are multiple render tags', async () => {
+      const sourceCode = `
+        {% content_for 'block', type: 'fake-block', param1: 'value1', param2: 'value2', param3: 'value3' %}
+        {% content_for 'block', type: 'fake-block', param1: 'value4', param2: 'value5', param1: 'value6' %}
+       `;
+
+      const offenses = await runCheck(sourceCode);
+
+      expect(offenses).toHaveLength(1);
+      expect(offenses[0].message).toMatch(/Duplicate argument 'param1'/);
+      expect(offenses[0].start.index).toBe(sourceCode.indexOf("param1: 'value6'"));
+      const suggestionResult = applySuggestions(sourceCode, offenses[0]);
+      expect(suggestionResult).toEqual([
+        `
+        {% content_for 'block', type: 'fake-block', param1: 'value1', param2: 'value2', param3: 'value3' %}
+        {% content_for 'block', type: 'fake-block', param1: 'value4', param2: 'value5' %}
+       `,
+      ]);
+    });
+  });
+});