@platformos/platformos-check-common 0.0.7 → 0.0.8

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

@@ -1,98 +0,0 @@
-import { ContentForMarkup, NodeTypes } from '@platformos/liquid-html-parser';
-import { LiquidCheckDefinition, Severity, SourceCodeType } from '../../types';
-import {
-  CLOSEST_ARGUMENT,
-  REQUIRED_CONTENT_FOR_ARGUMENTS,
-  RESERVED_CONTENT_FOR_ARGUMENTS,
-} from '../../tags/content-for';
-
-export const ValidContentForArguments: LiquidCheckDefinition = {
-  meta: {
-    code: 'ValidContentForArguments',
-    name: 'Prevent the use of invalid arguments to the content_for tag',
-    docs: {
-      description:
-        'This check is aimed at preventing the use of invalid arguments for the content_for tag.',
-      url: 'https://shopify.dev/docs/storefronts/themes/tools/theme-check/checks/valid-content-for-arguments',
-      recommended: true,
-    },
-    type: SourceCodeType.LiquidHtml,
-    severity: Severity.ERROR,
-    schema: {},
-    targets: [],
-  },
-
-  create(context) {
-    const validationStrategies = {
-      blocks: (node: ContentForMarkup) => {
-        const problematicArguments = node.args.filter(
-          (arg) => !arg.name.startsWith(CLOSEST_ARGUMENT),
-        );
-
-        for (const arg of problematicArguments) {
-          context.report({
-            message: `{% content_for "blocks" %} only accepts 'closest.*' arguments`,
-            startIndex: arg.position.start,
-            endIndex: arg.position.end,
-          });
-        }
-      },
-
-      block: (node: ContentForMarkup) => {
-        // Make sure the id and string arguments are present and are strings
-        for (const requiredArgumentName of REQUIRED_CONTENT_FOR_ARGUMENTS) {
-          const arg = node.args.find((arg) => arg.name === requiredArgumentName);
-
-          if (!arg) {
-            context.report({
-              message: `{% content_for "block" %} requires a '${requiredArgumentName}' argument`,
-              startIndex: node.position.start,
-              endIndex: node.position.end,
-              suggest: [],
-            });
-            continue;
-          }
-
-          const argValueNode = arg.value;
-          if (argValueNode.type !== NodeTypes.String) {
-            context.report({
-              message: `The '${requiredArgumentName}' argument should be a string`,
-              startIndex: argValueNode.position.start,
-              endIndex: argValueNode.position.end,
-              suggest: [],
-            });
-          }
-        }
-
-        const problematicArguments = node.args.filter((arg) =>
-          RESERVED_CONTENT_FOR_ARGUMENTS.includes(arg.name),
-        );
-
-        for (const arg of problematicArguments) {
-          context.report({
-            message: `{% content_for "block" %} doesn't support '${arg.name}' because it's a reserved argument.`,
-            startIndex: arg.position.start,
-            endIndex: arg.position.end,
-          });
-        }
-      },
-    };
-
-    return {
-      async LiquidTag(node) {
-        if (node.name !== 'content_for' || typeof node.markup === 'string') {
-          return;
-        }
-
-        /** "block", "blocks", etc. */
-        const contentForType = node.markup.contentForType.value;
-        const validate = validationStrategies[contentForType as keyof typeof validationStrategies];
-        if (!validate) {
-          return;
-        }
-
-        validate(node.markup);
-      },
-    };
-  },
-};

package/src/checks/valid-local-blocks/index.spec.ts

@@ -1,286 +0,0 @@
-import { expect, describe, it } from 'vitest';
-import { ValidLocalBlocks } from './index';
-import { check, MockTheme } from '../../test';
-
-describe('ValidLocalBlocks with array-style blocks', () => {
-  it('should report errors when root level local blocks are defined in a block bucket', async () => {
-    const theme: MockTheme = {
-      'blocks/local-blocks.liquid': `
-        {% schema %}
-        {
-            "name": "Block name",
-            "blocks": [
-            {
-                "type": "local_block",
-                "name": "Local Block"
-            }
-            ]
-        }
-        {% endschema %}
-        `,
-    };
-
-    const offenses = await check(theme, [ValidLocalBlocks]);
-    expect(offenses).to.have.length(1);
-    expect(offenses[0].message).to.equal('Local scoped blocks are not supported in theme blocks.');
-  });
-
-  it('should report errors when sections use theme blocks together with locally scoped blocks in root level', async () => {
-    const theme: MockTheme = {
-      'blocks/text.liquid': '',
-      'sections/local-blocks.liquid': `
-        {% schema %}
-        {
-            "name": "Section name",
-            "blocks": [
-            {
-                "type": "text"
-            },
-            {
-                "type": "local_block",
-                "name": "Local Block"
-            }
-            ]
-        }
-        {% endschema %}
-        `,
-    };
-    const offenses = await check(theme, [ValidLocalBlocks]);
-    expect(offenses).to.have.length(1);
-    expect(offenses[0].message).to.equal(
-      'Sections cannot use theme blocks together with locally scoped blocks.',
-    );
-  });
-
-  it('should report errors when sections use static theme blocks together with locally scoped blocks', async () => {
-    const theme: MockTheme = {
-      'sections/local-blocks.liquid': `
-            {% schema %}
-            {
-                "name": "Section name",
-                "blocks": [
-                {
-                    "type": "local_block",
-                    "name": "Local Block"
-                }
-                ],
-                "presets": [
-                {
-                    "name": "Default",
-                    "blocks": [
-                    {
-                        "id": "static_block",
-                        "type": "static_block",
-                        "static": true
-                    }
-                    ]
-                }
-                ]
-            }
-            {% endschema %}
-            `,
-    };
-    const offenses = await check(theme, [ValidLocalBlocks]);
-    expect(offenses).to.have.length(1);
-    expect(offenses[0].message).to.equal(
-      'Sections cannot use static theme blocks together with locally scoped blocks.',
-    );
-  });
-
-  it('should report errors with correct indices when sections use static theme blocks together with locally scoped blocks', async () => {
-    const theme: MockTheme = {
-      'sections/local-blocks.liquid': `
-                {% schema %}
-                {
-                "name": "Section name",
-                "blocks": [
-                    {
-                    "type": "local_block",
-                    "name": "Local Block"
-                    }
-                ],
-                "presets": [
-                    {
-                    "name": "Default",
-                    "blocks": [
-                        {
-                        "id": "static_block",
-                        "type": "static_block",
-                        "static": true
-                        }
-                    ]
-                    }
-                ]
-                }
-                {% endschema %}
-            `,
-    };
-    const offenses = await check(theme, [ValidLocalBlocks]);
-    expect(offenses).to.have.length(1);
-
-    const content = theme['sections/local-blocks.liquid'];
-    const errorContent = content.slice(offenses[0].start.index, offenses[0].end.index);
-    expect(errorContent).to.equal('"static_block"');
-  });
-});
-
-describe('ValidLocalBlocks on edge cases', () => {
-  it('should not report errors for block setting types', async () => {
-    const theme: MockTheme = {
-      'sections/local-blocks.liquid': `
-        {% schema %}
-        {
-          "name": "Section name",
-          "blocks": [
-            {
-              "type": "@app"
-            },
-            {
-              "type": "link_list",
-              "name": "Link list",
-              "settings": [
-                {
-                  "type": "inline_richtext",
-                  "id": "heading",
-                  "default": "Heading"
-                },
-                {
-                  "type": "link_list",
-                  "id": "menu",
-                  "default": "Footer"
-                }
-              ]
-            }
-          ]
-        }
-        {% endschema %}
-      `,
-    };
-
-    const offenses = await check(theme, [ValidLocalBlocks]);
-    expect(offenses).to.be.empty;
-  });
-
-  it('should not report errors when @app is used alongside static blocks', async () => {
-    const theme: MockTheme = {
-      'sections/local-blocks.liquid': `
-        {% schema %}
-        {
-          "name": "Section name",
-          "blocks": [
-            {
-              "type": "@app"
-            },
-            {
-              "type": "static_block",
-              "static": true
-            }
-          ]
-        }
-        {% endschema %}
-      `,
-    };
-
-    const offenses = await check(theme, [ValidLocalBlocks]);
-    expect(offenses).to.be.empty;
-  });
-
-  it('should not report errors on themes that define local blocks at the root level and use them in presets', async () => {
-    const theme: MockTheme = {
-      'sections/local-blocks.liquid': `
-        {% schema %}
-        {
-          "name": "Section name",
-          "blocks": [
-            {
-              "type": "local_block",
-              "name": "Local Block"
-            }
-          ],
-          "presets": [
-            {
-              "name": "Default",
-              "blocks": [
-                {
-                  "type": "local_block"
-                }
-              ]
-            }
-          ]
-        }
-        {% endschema %}
-      `,
-    };
-
-    const offenses = await check(theme, [ValidLocalBlocks]);
-    expect(offenses).to.be.empty;
-  });
-
-  it('should not report errors on older themes that define local blocks at the root level and use them in hash-style presets', async () => {
-    const theme: MockTheme = {
-      'sections/local-blocks.liquid': `
-        {% schema %}
-        {
-          "name": "Section name",
-          "blocks": [
-            {
-              "type": "local_block",
-              "name": "Local Block"
-            }
-          ],
-          "presets": [
-            {
-              "name": "Default",
-              "blocks": {
-                "local_block": {
-                  "type": "local_block"
-                }
-              }
-            }
-          ]
-        }
-        {% endschema %}
-      `,
-    };
-    const offenses = await check(theme, [ValidLocalBlocks]);
-    expect(offenses).to.be.empty;
-  });
-
-  it('should not report errors when preset blocks have a name property', async () => {
-    const theme: MockTheme = {
-      'blocks/product-grid.liquid': `
-      {% schema %}
-      {
-        "name": "Product grid",
-        "blocks": [{ "type": "product-card" }],
-        "presets": [
-          {
-            "name": "Product grid",
-            "blocks": {
-              "product-grid-card": {
-                "type": "product-card",
-                "static": true,
-                "blocks": {
-                  "card_gallery_eK4Hr7": {
-                    "type": "card-gallery",
-                    "name": "potato",
-                  },
-                  "group_4RMFLV": {
-                    "type": "group"
-                  }
-                },
-                "block_order": ["card_gallery_eK4Hr7", "group_4RMFLV"]
-              }
-            }
-          }
-        ]
-      }
-      {% endschema %}
-
-      `,
-    };
-
-    const offenses = await check(theme, [ValidLocalBlocks]);
-    expect(offenses).to.be.empty;
-  });
-});

package/src/checks/valid-local-blocks/index.ts

@@ -1,100 +0,0 @@
-import {
-  LiquidCheckDefinition,
-  Preset,
-  Severity,
-  SourceCodeType,
-  Section,
-  LiteralNode,
-} from '../../types';
-import { nodeAtPath } from '../../json';
-import { getSchema } from '../../to-schema';
-import { isBlock, isSection } from '../../to-schema';
-import { getBlocks, reportWarning } from './valid-block-utils';
-
-type BlockNodeWithPath = {
-  node: Section.Block | Preset.Block;
-  path: string[];
-};
-
-export const ValidLocalBlocks: LiquidCheckDefinition = {
-  meta: {
-    code: 'ValidLocalBlocks',
-    name: 'Prevent mixing static and local blocks in non-theme sections',
-    docs: {
-      description:
-        'Ensures sections without theme block support do not mix static and local blocks',
-      recommended: true,
-      url: 'https://shopify.dev/docs/storefronts/themes/tools/theme-check/checks/valid-local-blocks',
-    },
-    type: SourceCodeType.LiquidHtml,
-    severity: Severity.ERROR,
-    schema: {},
-    targets: [],
-  },
-
-  create(context) {
-    return {
-      async LiquidRawTag(node) {
-        if (node.name !== 'schema' || node.body.kind !== 'json') return;
-
-        const offset = node.blockStartPosition.end;
-        const schema = await getSchema(context);
-        const { validSchema, ast } = schema ?? {};
-        if (!validSchema || validSchema instanceof Error) return;
-        if (!ast || ast instanceof Error) return;
-        if (!schema) return;
-
-        const {
-          staticBlockLocations,
-          localBlockLocations,
-          themeBlockLocations,
-          hasRootLevelThemeBlocks,
-        } = getBlocks(validSchema);
-
-        if (isSection(context.file.uri)) {
-          if (staticBlockLocations.length > 0 && localBlockLocations.length > 0) {
-            staticBlockLocations.forEach((blockWithPath: BlockNodeWithPath) => {
-              const astNode = nodeAtPath(ast, blockWithPath.path)! as LiteralNode;
-              reportWarning(
-                `Sections cannot use static theme blocks together with locally scoped blocks.`,
-                offset,
-                astNode,
-                context,
-              );
-            });
-          }
-
-          if (
-            hasRootLevelThemeBlocks &&
-            localBlockLocations.length > 0 &&
-            themeBlockLocations.length > 0
-          ) {
-            localBlockLocations.forEach((blockWithPath: BlockNodeWithPath) => {
-              const astNode = nodeAtPath(ast, blockWithPath.path)! as LiteralNode;
-              reportWarning(
-                'Sections cannot use theme blocks together with locally scoped blocks.',
-                offset,
-                astNode,
-                context,
-              );
-            });
-          }
-        }
-
-        if (isBlock(context.file.uri)) {
-          if (localBlockLocations.length > 0) {
-            localBlockLocations.forEach((blockWithPath: BlockNodeWithPath) => {
-              const astNode = nodeAtPath(ast, blockWithPath.path)! as LiteralNode;
-              reportWarning(
-                'Local scoped blocks are not supported in theme blocks.',
-                offset,
-                astNode,
-                context,
-              );
-            });
-          }
-        }
-      },
-    };
-  },
-};

package/src/checks/valid-local-blocks/valid-block-utils.ts

@@ -1,97 +0,0 @@
-import { getLocEnd, getLocStart } from '../../json';
-import { Preset, ThemeBlock, Section, Context, SourceCodeType, LiteralNode } from '../../types';
-
-type BlockNodeWithPath = {
-  node: Section.Block | ThemeBlock.Block | Preset.Block;
-  path: string[];
-};
-
-export function getBlocks(validSchema: ThemeBlock.Schema | Section.Schema): {
-  staticBlockLocations: BlockNodeWithPath[];
-  localBlockLocations: BlockNodeWithPath[];
-  themeBlockLocations: BlockNodeWithPath[];
-  hasRootLevelThemeBlocks: boolean;
-} {
-  const staticBlockLocations: BlockNodeWithPath[] = [];
-  const localBlockLocations: BlockNodeWithPath[] = [];
-  const themeBlockLocations: BlockNodeWithPath[] = [];
-
-  const rootLevelBlocks = validSchema.blocks;
-  const presets = validSchema.presets;
-
-  function categorizeBlock(
-    block: Section.Block | ThemeBlock.Block | Preset.Block,
-    currentPath: string[],
-    inPreset: boolean = false,
-  ) {
-    if (!block) return;
-    const hasStatic = 'static' in block;
-    const hasName = 'name' in block;
-
-    if (hasStatic) {
-      staticBlockLocations.push({ node: block, path: currentPath.concat('type') });
-    } else if (hasName && !inPreset) {
-      localBlockLocations.push({ node: block, path: currentPath.concat('type') });
-    } else if (block.type !== '@app') {
-      themeBlockLocations.push({ node: block, path: currentPath.concat('type') });
-    }
-
-    if ('blocks' in block) {
-      if (Array.isArray(block.blocks)) {
-        block.blocks.forEach((nestedBlock: Preset.PresetBlockForArray, index: number) => {
-          categorizeBlock(nestedBlock, currentPath.concat('blocks', String(index)), inPreset);
-        });
-      } else if (typeof block.blocks === 'object' && block.blocks !== null) {
-        Object.entries(block.blocks).forEach(([key, nestedBlock]) => {
-          categorizeBlock(nestedBlock, currentPath.concat('blocks', key), inPreset);
-        });
-      }
-    }
-  }
-
-  if (Array.isArray(rootLevelBlocks)) {
-    rootLevelBlocks.forEach((block, index) => {
-      categorizeBlock(block, ['blocks', String(index)]);
-    });
-  }
-
-  if (presets) {
-    presets.forEach((preset: Preset.Preset, presetIndex: number) => {
-      if ('blocks' in preset && preset.blocks) {
-        if (Array.isArray(preset.blocks)) {
-          preset.blocks.forEach((block: Preset.PresetBlockForArray, blockIndex: number) => {
-            categorizeBlock(
-              block,
-              ['presets', String(presetIndex), 'blocks', String(blockIndex)],
-              true,
-            );
-          });
-        } else if (typeof preset.blocks === 'object') {
-          Object.entries(preset.blocks).forEach(([key, block]) => {
-            categorizeBlock(block, ['presets', String(presetIndex), 'blocks', key], true);
-          });
-        }
-      }
-    });
-  }
-
-  return {
-    staticBlockLocations,
-    localBlockLocations,
-    themeBlockLocations,
-    hasRootLevelThemeBlocks: themeBlockLocations.some((block) => block.path[0] === 'blocks'),
-  };
-}
-
-export function reportWarning(
-  message: string,
-  offset: number,
-  astNode: LiteralNode,
-  context: Context<SourceCodeType.LiquidHtml>,
-) {
-  context.report({
-    message,
-    startIndex: offset + getLocStart(astNode),
-    endIndex: offset + getLocEnd(astNode),
-  });
-}