@platformos/platformos-check-common 0.0.7 → 0.0.8

package/src/checks/unique-static-block-id/index.spec.ts

@@ -1,55 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { runLiquidCheck } from '../../test';
-import { UniqueStaticBlockId } from './index';
-
-describe('Module: UniqueStaticBlockId', () => {
-  it('should report an error when two static blocks have the same id', async () => {
-    const sourceCode = `
-     {% content_for "block", type: "text", id: "static-block" %}
-     {% content_for "block", type: "text", id: "static-block" %}
-    `;
-
-    const offenses = await runLiquidCheck(UniqueStaticBlockId, sourceCode);
-
-    expect(offenses).to.have.length(1);
-    expect(offenses[0].message).to.equal(
-      "The id 'static-block' is already being used by another static block",
-    );
-  });
-
-  it('should not report an error when two static blocks have differnt id', async () => {
-    const sourceCode = `
-     {% content_for "block", type: "text", id: "static-block1" %}
-     {% content_for "block", type: "text", id: "static-block2" %}
-    `;
-
-    const offenses = await runLiquidCheck(UniqueStaticBlockId, sourceCode);
-
-    expect(offenses).to.have.length(0);
-  });
-
-  it('should report an error when two static blocks have same id and different types', async () => {
-    const sourceCode = `
-     {% content_for "block", type: "text", id: "static-block" %}
-     {% content_for "block", type: "url", id: "static-block" %}
-    `;
-
-    const offenses = await runLiquidCheck(UniqueStaticBlockId, sourceCode);
-
-    expect(offenses).to.have.length(1);
-    expect(offenses[0].message).to.equal(
-      "The id 'static-block' is already being used by another static block",
-    );
-  });
-
-  it('should not report an error when two static blocks have different id and different types', async () => {
-    const sourceCode = `
-     {% content_for "block", type: "text", id: "static-block1" %}
-     {% content_for "block", type: "url", id: "static-block2" %}
-    `;
-
-    const offenses = await runLiquidCheck(UniqueStaticBlockId, sourceCode);
-
-    expect(offenses).to.have.length(0);
-  });
-});

package/src/checks/unique-static-block-id/index.ts

@@ -1,60 +0,0 @@
-import { NamedTags, NodeTypes } from '@platformos/liquid-html-parser';
-import { LiquidCheckDefinition, Severity, SourceCodeType } from '../../types';
-import { isContentForBlock } from '../../utils/markup';
-
-export const UniqueStaticBlockId: LiquidCheckDefinition = {
-  meta: {
-    code: 'UniqueStaticBlockId',
-    name: 'Prevent use of duplicated ids for blocks rendered statically',
-    docs: {
-      description:
-        'This check is aimed at preventing the use of duplicated ids for blocks rendered statically.',
-      url: 'https://shopify.dev/docs/storefronts/themes/tools/theme-check/checks/unique-static-block-id',
-      recommended: true,
-    },
-    type: SourceCodeType.LiquidHtml,
-    severity: Severity.ERROR,
-    schema: {},
-    targets: [],
-  },
-
-  create(context) {
-    const usedIds: Set<string> = new Set();
-    const idRegex = /id:\s*["'](\S+)["']/;
-    return {
-      async LiquidTag(node) {
-        if (node.name !== NamedTags.content_for) {
-          return;
-        }
-
-        if (!isContentForBlock(node.markup)) {
-          return;
-        }
-
-        const idNode = node.markup.args.find((arg) => arg.name === 'id');
-
-        if (!idNode) {
-          return; // covered by VariableContentForArguments
-        }
-
-        const idValueNode = idNode.value;
-        if (idValueNode.type !== NodeTypes.String) {
-          return; // covered by VariableContentForArguments
-        }
-
-        const id = idValueNode.value;
-
-        if (usedIds.has(id)) {
-          context.report({
-            message: `The id '${id}' is already being used by another static block`,
-            startIndex: idValueNode.position.start,
-            endIndex: idValueNode.position.end,
-            suggest: [],
-          });
-        } else {
-          usedIds.add(id);
-        }
-      },
-    };
-  },
-};

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

@@ -1,145 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { runLiquidCheck } from '../../test';
-import { UnrecognizedContentForArguments } from '.';
-import { RESERVED_CONTENT_FOR_ARGUMENTS } from '../../tags/content-for';
-
-function check(snippet: string, source: string) {
-  return runLiquidCheck(
-    UnrecognizedContentForArguments,
-    source,
-    undefined,
-    {},
-    {
-      'blocks/card.liquid': snippet,
-    },
-  );
-}
-
-const defaultSnippet = `
-  {% doc %}
-    @param {string} required_string - A required string
-    @param {number} required_number - A required number
-    @param {boolean} required_boolean - A required boolean
-    @param {object} required_object - A required object
-    @param {string} [optional_string] - An optional string
-    @param {number} [optional_number] - An optional number
-    @param {object} [optional_object] - An optional object
-    @param {boolean} [optional_boolean] - An optional boolean
-  {% enddoc %}
-`;
-
-describe('Module: UnrecognizedContentForArguments', () => {
-  describe('unknown arguments', () => {
-    it('should report unknown arguments that are provided in the content_for markup', async () => {
-      const sourceCode = `
-        {% content_for 'block',
-        type: 'card',
-        required_string: 'My Card',
-        required_number: 1,
-        required_boolean: true,
-        required_object: product,
-        unknown_param: 'unknown',
-        second_unknown_param: 'second unknown',
-        %}
-        `;
-      const offenses = await check(defaultSnippet, sourceCode);
-
-      expect(offenses).toHaveLength(2);
-      expect(offenses[0].message).toBe(
-        "Unknown argument 'unknown_param' in content_for tag for static block 'card'.",
-      );
-      expect(offenses[1].message).toBe(
-        "Unknown argument 'second_unknown_param' in content_for tag for static block 'card'.",
-      );
-    });
-  });
-
-  describe('edge cases', () => {
-    it('should not report when static block has no doc comment', async () => {
-      const sourceCode = `{% content_for 'block', type: 'card', title: 'My Card' %}`;
-      const offenses = await runLiquidCheck(
-        UnrecognizedContentForArguments,
-        sourceCode,
-        undefined,
-        {},
-        {
-          'blocks/card.liquid': `<h1>This block has no doc comment</h1>`,
-        },
-      );
-
-      expect(offenses).toHaveLength(0);
-    });
-
-    it('should not report when LiquidDoc definition has no defined params', async () => {
-      const sourceCode = `{% content_for 'block', type: 'card', title: 'My Card' %}`;
-      const offenses = await runLiquidCheck(
-        UnrecognizedContentForArguments,
-        sourceCode,
-        undefined,
-        {},
-        {
-          'blocks/card.liquid': `
-              {% doc %}
-                @description this is a description
-                @example this is an example
-              {% enddoc %}
-              <div>{{ title }}</div>
-              <div>{{ description }}</div>
-            `,
-        },
-      );
-
-      expect(offenses).toHaveLength(0);
-    });
-
-    it('should not report when block name is a VariableLookup', async () => {
-      const sourceCode = `{% assign block_name = 'card' %}{% content_for 'block', type: block_name, title: 'My Card' %}`;
-      const offenses = await runLiquidCheck(
-        UnrecognizedContentForArguments,
-        sourceCode,
-        undefined,
-        {},
-        {
-          'blocks/card.liquid': `
-              {% doc %}
-                @param {string} title - The title of the card
-                @param {string} description - The description of the card
-              {% enddoc %}
-              <div>{{ title }}</div>
-              <div>{{ description }}</div>
-            `,
-        },
-      );
-
-      expect(offenses).toHaveLength(0);
-    });
-
-    it('should not report when argument begins with `.closest`', async () => {
-      const offenses = await check(
-        `
-        {% doc %}
-          @param {string} title - The title of the card
-        {% enddoc %}
-        <div>{{ title }}</div>
-        `,
-        `{% content_for 'block', type: 'card', id: '123', closest.product: product %}`,
-      );
-
-      expect(offenses).toHaveLength(0);
-    });
-
-    it('should not report when argument is a reserved word', async () => {
-      const offenses = await check(
-        `
-        {% doc %}
-          @param {string} title - The title of the card
-        {% enddoc %}
-        <div>{{ title }}</div>
-        `,
-        `{% content_for 'block', type: 'card', id: '123', ${RESERVED_CONTENT_FOR_ARGUMENTS[0]}: product %}`,
-      );
-
-      expect(offenses).toHaveLength(0);
-    });
-  });
-});

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

@@ -1,55 +0,0 @@
-import { LiquidCheckDefinition, Severity, SourceCodeType } from '../../types';
-import { ContentForMarkup } from '@platformos/liquid-html-parser';
-import {
-  getBlockName,
-  getLiquidDocParams,
-  reportUnknownArguments,
-} from '../../liquid-doc/arguments';
-import {
-  CLOSEST_ARGUMENT,
-  REQUIRED_CONTENT_FOR_ARGUMENTS,
-  RESERVED_CONTENT_FOR_ARGUMENTS,
-} from '../../tags/content-for';
-
-export const UnrecognizedContentForArguments: LiquidCheckDefinition = {
-  meta: {
-    code: 'UnrecognizedContentForArguments',
-    name: 'Unrecognized ContentFor Arguments',
-    docs: {
-      description:
-        'This check ensures that no unknown arguments are used when rendering a static block.',
-      recommended: true,
-      url: 'https://shopify.dev/docs/storefronts/themes/tools/theme-check/checks/unrecognized-content-for-arguments',
-    },
-    type: SourceCodeType.LiquidHtml,
-    severity: Severity.WARNING,
-    schema: {},
-    targets: [],
-  },
-
-  create(context) {
-    const DEFAULT_CONTENT_FOR_ARGS = new Set([
-      ...RESERVED_CONTENT_FOR_ARGUMENTS,
-      ...REQUIRED_CONTENT_FOR_ARGUMENTS,
-    ]);
-
-    return {
-      async ContentForMarkup(node: ContentForMarkup) {
-        const blockName = getBlockName(node);
-
-        if (!blockName) return;
-
-        const liquidDocParameters = await getLiquidDocParams(context, `blocks/${blockName}.liquid`);
-
-        if (!liquidDocParameters) return;
-
-        const unknownProvidedParams = node.args
-          .filter((p) => !liquidDocParameters.has(p.name))
-          .filter((p) => !DEFAULT_CONTENT_FOR_ARGS.has(p.name))
-          .filter((p) => !p.name.startsWith(CLOSEST_ARGUMENT));
-
-        reportUnknownArguments(context, node, unknownProvidedParams, blockName);
-      },
-    };
-  },
-};