@platformos/platformos-check-common 0.0.7 → 0.0.8

package/src/checks/empty-block-content/index.spec.ts

@@ -1,117 +0,0 @@
-import { expect, describe, it } from 'vitest';
-import { EmptyBlockContent } from '.';
-import { check, MockTheme } from '../../test';
-
-describe('Module: EmptyBlockContent', () => {
-  const paths = ['sections', 'blocks'];
-
-  paths.forEach((path) => {
-    it(`should not report offenses when the blocks array is not empty in ${path}`, async () => {
-      const theme: MockTheme = {
-        [`${path}/test_block.liquid`]: `
-          <div> 
-              {% content_for 'blocks' %}
-          </div>
-          {% schema %}
-          {
-              "name": "Test",
-              "blocks": [
-                {
-                  "type": "test-block"
-                }
-              ]
-          }
-          {% endschema %}
-        `,
-      };
-
-      const offenses = await check(theme, [EmptyBlockContent]);
-      expect(offenses).to.have.length(0);
-    });
-
-    it(`should report offenses when the blocks array is empty in ${path}`, async () => {
-      const theme: MockTheme = {
-        [`${path}/test_block.liquid`]: `
-          <div> 
-              {% content_for 'blocks' %}
-          </div>
-          {% schema %}
-          {
-              "name": "Test",
-              "blocks": []
-          }
-          {% endschema %}
-        `,
-      };
-
-      const offenses = await check(theme, [EmptyBlockContent]);
-      expect(offenses).to.have.length(1);
-      expect(offenses[0].message).to.equal(
-        `The 'content_for "blocks"' tag is present, but the blocks array is empty.`,
-      );
-    });
-
-    it(`should report offenses when the blocks array is empty with the correct indices in ${path}`, async () => {
-      const theme: MockTheme = {
-        [`${path}/test_block.liquid`]: `
-          <div> 
-              {% content_for 'blocks' %}
-          </div>
-          {% schema %}
-          {
-              "name": "Test",
-              "blocks": []
-          }
-          {% endschema %}
-        `,
-      };
-
-      const offenses = await check(theme, [EmptyBlockContent]);
-      expect(offenses).to.have.length(1);
-      const content = theme[`${path}/test_block.liquid`];
-      const erroredContent = content.slice(offenses[0].start.index, offenses[0].end.index);
-      expect(erroredContent).to.equal("{% content_for 'blocks' %}");
-    });
-
-    it(`should report offenses when the blocks array has not been defined in ${path}`, async () => {
-      const theme: MockTheme = {
-        [`${path}/test_block.liquid`]: `
-          <div> 
-              {% content_for 'blocks' %}
-          </div>
-          {% schema %}
-          {
-              "name": "Test"
-          }
-          {% endschema %}
-        `,
-      };
-
-      const offenses = await check(theme, [EmptyBlockContent]);
-      expect(offenses).to.have.length(1);
-      expect(offenses[0].message).to.equal(
-        `The 'content_for "blocks"' tag is present, but the blocks array is not defined.`,
-      );
-    });
-
-    it(`should not report offenses when 'content_for blocks' is not present in ${path}`, async () => {
-      const theme: MockTheme = {
-        [`${path}/test_block.liquid`]: `
-          {% schema %}
-          {
-              "name": "Test",
-              "blocks": [
-                  {
-                      "type": "test-block"
-                  }
-              ]
-          }
-          {% endschema %}
-        `,
-      };
-
-      const offenses = await check(theme, [EmptyBlockContent]);
-      expect(offenses).to.be.empty;
-    });
-  });
-});

package/src/checks/empty-block-content/index.ts

@@ -1,60 +0,0 @@
-import { LiquidCheckDefinition, Severity, SourceCodeType } from '../../types';
-import { getSchema } from '../../to-schema';
-import { Position } from '@platformos/liquid-html-parser';
-
-export const EmptyBlockContent: LiquidCheckDefinition = {
-  meta: {
-    code: 'EmptyBlockContent',
-    name: 'Prevent empty block content',
-    docs: {
-      description:
-        'This check exists to warn you when the blocks array at the root level of the schema is empty.',
-      recommended: true,
-      url: 'https://shopify.dev/docs/storefronts/themes/tools/theme-check/checks/empty-block-content',
-    },
-    type: SourceCodeType.LiquidHtml,
-    severity: Severity.WARNING,
-    schema: {},
-    targets: [],
-  },
-
-  create(context) {
-    let isContentForBlocksLocationSet = false;
-    let contentForBlocksLocation: Position = { start: 0, end: 0 };
-
-    return {
-      async LiquidTag(node) {
-        if (node.name !== 'content_for') return;
-
-        const nodeMarkup = node.markup;
-        if (typeof nodeMarkup === 'object' && nodeMarkup.contentForType.value === 'blocks') {
-          contentForBlocksLocation.start = node.blockStartPosition.start;
-          contentForBlocksLocation.end = node.blockStartPosition.end;
-          isContentForBlocksLocationSet = true;
-        }
-      },
-
-      async onCodePathEnd() {
-        const schema = await getSchema(context);
-        const { validSchema, ast } = schema ?? {};
-        if (!validSchema || validSchema instanceof Error) return;
-        if (!ast || ast instanceof Error) return;
-
-        const blocks = validSchema.blocks;
-        if (isContentForBlocksLocationSet && !blocks) {
-          context.report({
-            message: `The 'content_for "blocks"' tag is present, but the blocks array is not defined.`,
-            startIndex: contentForBlocksLocation.start,
-            endIndex: contentForBlocksLocation.end,
-          });
-        } else if (isContentForBlocksLocationSet && blocks && blocks.length === 0) {
-          context.report({
-            message: `The 'content_for "blocks"' tag is present, but the blocks array is empty.`,
-            startIndex: contentForBlocksLocation.start,
-            endIndex: contentForBlocksLocation.end,
-          });
-        }
-      },
-    };
-  },
-};

package/src/checks/hardcoded-routes/index.spec.ts

@@ -1,58 +0,0 @@
-import { expect, describe, it } from 'vitest';
-import { HardcodedRoutes } from './index';
-import { runLiquidCheck, highlightedOffenses } from '../../test';
-
-describe('Module: HardcodedRoutes', () => {
-  it('should report offenses for hardcoded routes', async () => {
-    const sourceCode = `
-      <a href="/"></a>
-      <form action="/search"></form>
-      <a href="/account/login"></a>
-      <a href="/collections/{{ collection.handle }}"></a>
-      <a href="/cart/change?line={{ forloop.index }}&amp;quantity=0"></a>
-      <li>{{ 'Socks' | link_to: '/collections/socks' }}</li>
-      <li>{{ 'Home' | link_to: '/' }}</li>
-      <li>{{ 'Cart (' | append: cart.item_count | append: ')' | link_to: '/cart' }}</li>
-    `;
-
-    const offenses = await runLiquidCheck(HardcodedRoutes, sourceCode);
-    expect(offenses).to.have.length(8);
-
-    const errorMessages = offenses.map((offense) => offense.message);
-    expect(errorMessages).to.deep.equal([
-      'Use routes object {{ routes.root_url }} instead of hardcoding /',
-      'Use routes object {{ routes.search_url }} instead of hardcoding /search',
-      'Use routes object {{ routes.account_login_url }} instead of hardcoding /account/login',
-      'Use routes object {{ routes.collections_url }} instead of hardcoding /collections',
-      'Use routes object {{ routes.cart_change_url }} instead of hardcoding /cart/change',
-      'Use routes object {{ routes.collections_url }} instead of hardcoding /collections',
-      'Use routes object {{ routes.root_url }} instead of hardcoding /',
-      'Use routes object {{ routes.cart_url }} instead of hardcoding /cart',
-    ]);
-
-    const highlights = highlightedOffenses({ 'file.liquid': sourceCode }, offenses);
-    expect(highlights).to.deep.equal([
-      '/',
-      '/search',
-      '/account/login',
-      '/collections',
-      '/cart/change',
-      '/collections',
-      '/',
-      '/cart',
-    ]);
-  });
-
-  it('should not report offenses for route objects', async () => {
-    const sourceCode = `
-      <form action="{{ routes.search_url }}"></form>
-      <a href="/{{ blog.url }}"></a>  
-      <a href="/admin"></a>
-      <a href="#MainContent"></a>
-      <li>{{ 'About' | link_to: '/pages/about' }}</li>
-    `;
-
-    const offenses = await runLiquidCheck(HardcodedRoutes, sourceCode);
-    expect(offenses).to.have.length(0);
-  });
-});

package/src/checks/hardcoded-routes/index.ts

@@ -1,100 +0,0 @@
-import { NodeTypes } from '@platformos/liquid-html-parser';
-import { Severity, SourceCodeType, LiquidCheckDefinition } from '../../types';
-import { isAttr, isNodeOfType, isValuedHtmlAttribute, ValuedHtmlAttribute } from '../utils';
-
-const ROUTES: Record<string, string> = {
-  '/': 'root_url',
-  '/account': 'account_url',
-  '/account/addresses': 'account_addresses_url',
-  '/account/login': 'account_login_url',
-  '/account/logout': 'account_logout_url',
-  '/account/recover': 'account_recover_url',
-  '/account/register': 'account_register_url',
-  '/cart': 'cart_url',
-  '/cart/add': 'cart_add_url',
-  '/cart/change': 'cart_change_url',
-  '/cart/clear': 'cart_clear_url',
-  '/cart/update': 'cart_update_url',
-  '/collections': 'collections_url',
-  '/collections/all': 'all_products_collection_url',
-  '/customer_authentication/login': 'storefront_login_url',
-  '/recommendations/products': 'product_recommendations_url',
-  '/search': 'search_url',
-  '/search/suggest': 'predictive_search_url',
-};
-
-const HARDCODED_ROUTES = Object.keys(ROUTES).reverse();
-
-export const HardcodedRoutes: LiquidCheckDefinition = {
-  meta: {
-    code: 'HardcodedRoutes',
-    name: 'Hardcoded Routes',
-    docs: {
-      description: 'This check encourages using the routes object instead of hardcoding URLs.',
-      recommended: true,
-      url: 'https://shopify.dev/docs/storefronts/themes/tools/theme-check/checks/hardcoded-routes',
-    },
-    type: SourceCodeType.LiquidHtml,
-    severity: Severity.WARNING,
-    schema: {},
-    targets: [],
-  },
-
-  create(context) {
-    return {
-      async HtmlElement(node) {
-        // checks for hardcoded routes in href and action attributes
-        const attrWithHardcodedRoute: ValuedHtmlAttribute | undefined = node.attributes
-          .filter(isValuedHtmlAttribute)
-          .find((attr) => (isAttr(attr, 'action') || isAttr(attr, 'href')) && hardcodedRoute(attr));
-
-        if (attrWithHardcodedRoute) {
-          const attr = attrWithHardcodedRoute;
-          const route = hardcodedRoute(attr)!;
-          const routeURL = ROUTES[route];
-          const startIndex = attr.attributePosition.start;
-          const endIndex = startIndex + route.length;
-
-          context.report({
-            message: `Use routes object {{ routes.${routeURL} }} instead of hardcoding ${route}`,
-            startIndex,
-            endIndex,
-          });
-        }
-      },
-
-      async LiquidFilter(node) {
-        // checks for hardcoded routes in link_to values {{ 'Cart' | link_to: '/cart' }}
-        if (node.name !== 'link_to') return;
-
-        const linkToArg = node.args[0];
-        const linkToValue = linkToArg.type === 'String' ? linkToArg.value : '';
-        const route = HARDCODED_ROUTES.find((route) =>
-          route === '/' ? route === linkToValue : linkToValue.startsWith(route),
-        );
-
-        if (route) {
-          const routeURL = ROUTES[route];
-          // we add 1 to the start index to exclude the quotes
-          const startIndex = linkToArg.position.start + 1;
-
-          context.report({
-            message: `Use routes object {{ routes.${routeURL} }} instead of hardcoding ${route}`,
-            startIndex,
-            endIndex: startIndex + route.length,
-          });
-        }
-      },
-    };
-  },
-};
-
-function hardcodedRoute(attr: ValuedHtmlAttribute): string | undefined {
-  if (!isNodeOfType(NodeTypes.TextNode, attr.value[0])) return;
-
-  const value = attr.value[0].value;
-
-  return HARDCODED_ROUTES.find((route) =>
-    route === '/' ? route === value && attr.value.length === 1 : value.startsWith(route),
-  );
-}