@platformos/platformos-check-common 0.0.6 → 0.0.8

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

@@ -1,284 +0,0 @@
-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

@@ -1,102 +0,0 @@
-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

@@ -1,66 +0,0 @@
-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/duplicate-content-for-arguments/index.spec.ts

@@ -1,98 +0,0 @@
-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' %}
-       `,
-      ]);
-    });
-  });
-});

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

@@ -1,43 +0,0 @@
-import { LiquidCheckDefinition, Severity, SourceCodeType } from '../../types';
-import { ContentForMarkup, LiquidNamedArgument } from '@platformos/liquid-html-parser';
-import { getBlockName, reportDuplicateArguments } from '../../liquid-doc/arguments';
-
-export const DuplicateContentForArguments: LiquidCheckDefinition = {
-  meta: {
-    code: 'DuplicateContentForArguments',
-    name: 'Duplicate ContentFor Arguments',
-    docs: {
-      description:
-        'This check ensures that no duplicate argument names are provided when rendering a static block.',
-      recommended: true,
-      url: 'https://shopify.dev/docs/storefronts/themes/tools/theme-check/checks/duplicate-content-for-arguments',
-    },
-    type: SourceCodeType.LiquidHtml,
-    severity: Severity.WARNING,
-    schema: {},
-    targets: [],
-  },
-
-  create(context) {
-    return {
-      async ContentForMarkup(node: ContentForMarkup) {
-        const blockName = getBlockName(node);
-
-        if (!blockName) return;
-
-        const encounteredArgNames = new Set<string>();
-        const duplicateArgs: LiquidNamedArgument[] = [];
-
-        for (const param of node.args) {
-          if (encounteredArgNames.has(param.name)) {
-            duplicateArgs.push(param);
-          }
-
-          encounteredArgNames.add(param.name);
-        }
-
-        reportDuplicateArguments(context, node, duplicateArgs, blockName);
-      },
-    };
-  },
-};