td-ai-tools 1.2.4 → 1.2.6

package/skills/shopify-lint/theme-check-theory/src/checks/unguarded-text-setting.test.ts

@@ -1,198 +0,0 @@
-import {
-  check,
-  runLiquidCheck,
-} from '@shopify/theme-check-common/dist/test/test-helper';
-import { describe, expect, it } from 'vitest';
-
-import { liquidSection } from '../test-utils';
-import {
-  DEFAULT_TEXTUAL_SETTING_TYPES,
-  UnguardedTextSetting,
-} from './unguarded-text-setting';
-
-describe('UnguardedTextSetting', () => {
-  it('reports raw outputs of all default text-like section and block setting types', async () => {
-    const settings = DEFAULT_TEXTUAL_SETTING_TYPES.map((type) => ({
-      type,
-      id: `section_${type}`,
-    }));
-    const blockSettings = DEFAULT_TEXTUAL_SETTING_TYPES.map((type) => ({
-      type,
-      id: `block_${type}`,
-    }));
-    const outputs = [
-      ...settings.map(({ id }) => `{{ section.settings.${id} }}`),
-      ...blockSettings.map(({ id }) => `{{ block.settings.${id} }}`),
-    ].join('\n');
-    const source = liquidSection(outputs, settings, [
-      { type: 'card', name: 'Card', settings: blockSettings },
-    ]);
-
-    const offenses = await runLiquidCheck(UnguardedTextSetting, source);
-
-    expect(offenses).toHaveLength(DEFAULT_TEXTUAL_SETTING_TYPES.length * 2);
-    expect(offenses[0].message).toBe(
-      "The text-like setting 'section_text' is output without a presence guard or default",
-    );
-  });
-
-  it('ignores non-textual settings by default', async () => {
-    const source = liquidSection(
-      `
-        {{ section.settings.enabled }}
-        {{ section.settings.spacing }}
-        {{ section.settings.image }}
-      `,
-      [
-        { type: 'checkbox', id: 'enabled' },
-        { type: 'range', id: 'spacing' },
-        { type: 'image_picker', id: 'image' },
-      ],
-    );
-
-    expect(await runLiquidCheck(UnguardedTextSetting, source)).toEqual([]);
-  });
-
-  it.each([
-    [
-      'if',
-      '{% if section.settings.heading %}{{ section.settings.heading }}{% endif %}',
-    ],
-    [
-      'unless',
-      '{% unless section.settings.heading == blank %}{{ section.settings.heading }}{% endunless %}',
-    ],
-    [
-      'elsif',
-      '{% if product %}x{% elsif section.settings.heading %}{{ section.settings.heading }}{% endif %}',
-    ],
-    [
-      'case',
-      '{% case section.settings.heading %}{% when "Hello" %}{{ section.settings.heading }}{% endcase %}',
-    ],
-  ])('accepts a setting tested in an %s conditional', async (_, liquid) => {
-    const source = liquidSection(liquid, [{ type: 'text', id: 'heading' }]);
-
-    expect(await runLiquidCheck(UnguardedTextSetting, source)).toEqual([]);
-  });
-
-  it('accepts logical and comparison presence tests', async () => {
-    const source = liquidSection(
-      `
-        {% if section.settings.heading != blank and section.settings.subtitle %}
-          {{ section.settings.heading }} {{ section.settings.subtitle }}
-        {% endif %}
-      `,
-      [
-        { type: 'text', id: 'heading' },
-        { type: 'textarea', id: 'subtitle' },
-      ],
-    );
-
-    expect(await runLiquidCheck(UnguardedTextSetting, source)).toEqual([]);
-  });
-
-  it('does not mistake an unrelated enclosing condition for a setting presence guard', async () => {
-    const source = liquidSection(
-      '{% if product.available %}{{ section.settings.heading }}{% endif %}',
-      [{ type: 'text', id: 'heading' }],
-    );
-
-    const offenses = await runLiquidCheck(UnguardedTextSetting, source);
-
-    expect(offenses).toHaveLength(1);
-  });
-
-  it('accepts output with a default filter', async () => {
-    const source = liquidSection(
-      "{{ section.settings.heading | strip | default: 'Welcome' }}",
-      [{ type: 'text', id: 'heading' }],
-    );
-
-    expect(await runLiquidCheck(UnguardedTextSetting, source)).toEqual([]);
-  });
-
-  it('does not treat use as another expression default as handling the setting', async () => {
-    const source = liquidSection(
-      "{{ product.title | default: section.settings.heading }} {{ section.settings.heading }}",
-      [{ type: 'text', id: 'heading' }],
-    );
-
-    const offenses = await runLiquidCheck(UnguardedTextSetting, source);
-
-    expect(offenses).toHaveLength(1);
-  });
-
-  it('applies handling coarsely to every output of that setting in the file', async () => {
-    const source = liquidSection(
-      `
-        {{ section.settings.heading }}
-        {% if section.settings.heading %}{{ section.settings.heading }}{% endif %}
-        {{ section.settings.heading }}
-      `,
-      [{ type: 'text', id: 'heading' }],
-    );
-
-    expect(await runLiquidCheck(UnguardedTextSetting, source)).toEqual([]);
-  });
-
-  it('reports every raw output when the setting is never handled', async () => {
-    const source = liquidSection(
-      '{{ section.settings.heading }} / {{ section.settings.heading | escape }}',
-      [{ type: 'text', id: 'heading' }],
-    );
-
-    const offenses = await runLiquidCheck(UnguardedTextSetting, source);
-
-    expect(offenses).toHaveLength(2);
-  });
-
-  it('only considers variable output tags, not assignments or echo tags', async () => {
-    const source = liquidSection(
-      '{% assign heading = section.settings.heading %}{% echo section.settings.heading %}',
-      [{ type: 'text', id: 'heading' }],
-    );
-
-    expect(await runLiquidCheck(UnguardedTextSetting, source)).toEqual([]);
-  });
-
-  it('supports textualSettingTypes configuration', async () => {
-    const source = liquidSection('{{ section.settings.image }}', [
-      { type: 'image_picker', id: 'image' },
-    ]);
-
-    const offenses = await check(
-      { 'sections/test.liquid': source },
-      [UnguardedTextSetting],
-      {},
-      {
-        UnguardedTextSetting: {
-          enabled: true,
-          textualSettingTypes: ['image_picker'],
-        },
-      },
-    );
-
-    expect(offenses).toHaveLength(1);
-  });
-
-  it('ignores dynamic output while still checking statically known outputs', async () => {
-    const source = liquidSection(
-      '{{ section.settings[key] }} {{ section.settings.heading }}',
-      [{ type: 'text', id: 'heading' }],
-    );
-
-    const offenses = await runLiquidCheck(UnguardedTextSetting, source);
-
-    expect(offenses).toHaveLength(1);
-    expect(offenses[0].message).toContain("'heading'");
-  });
-
-  it.each([
-    ['a file without schema', '{{ section.settings.heading }}'],
-    ['an invalid schema', '{{ section.settings.heading }}{% schema %}{ nope {% endschema %}'],
-  ])('stays silent for %s', async (_, source) => {
-    expect(await runLiquidCheck(UnguardedTextSetting, source)).toEqual([]);
-  });
-});
-

package/skills/shopify-lint/theme-check-theory/src/checks/unguarded-text-setting.ts

@@ -1,143 +0,0 @@
-import {
-  LiquidCheckDefinition,
-  SchemaProp,
-  Severity,
-  SourceCodeType,
-} from '@shopify/theme-check-common';
-import {
-  NodeTypes,
-} from '@shopify/liquid-html-parser';
-import type {
-  LiquidHtmlNode,
-  LiquidVariableOutput,
-  LiquidVariableLookup,
-} from '@shopify/liquid-html-parser';
-
-import {
-  getSettingDeclarations,
-  getSettingReference,
-  settingKey,
-} from '../utils/ast';
-import type { SettingDeclaration } from '../utils/ast';
-
-export const DEFAULT_TEXTUAL_SETTING_TYPES = [
-  'text',
-  'textarea',
-  'richtext',
-  'inline_richtext',
-  'html',
-  'liquid',
-  'url',
-] as const;
-
-const schema = {
-  textualSettingTypes: SchemaProp.array(
-    SchemaProp.string(),
-    [...DEFAULT_TEXTUAL_SETTING_TYPES],
-  ),
-};
-
-export const UnguardedTextSetting: LiquidCheckDefinition<typeof schema> = {
-  meta: {
-    code: 'UnguardedTextSetting',
-    name: 'Require guards for text-like settings',
-    docs: {
-      description: 'Reports text-like settings output without a presence guard or default filter.',
-      recommended: true,
-    },
-    type: SourceCodeType.LiquidHtml,
-    severity: Severity.WARNING,
-    schema,
-  },
-  create(context) {
-    const declarations: SettingDeclaration[] = [];
-    const handledSettings = new Set<string>();
-    const outputs: Array<{
-      id: string;
-      key: string;
-      node: LiquidVariableOutput;
-    }> = [];
-
-    return {
-      async LiquidRawTag(node) {
-        const schemaDeclarations = getSettingDeclarations(node);
-        if (schemaDeclarations) declarations.push(...schemaDeclarations);
-      },
-
-      async LiquidVariableOutput(node) {
-        if (typeof node.markup === 'string') return;
-
-        const expression = node.markup.expression;
-        if (expression.type !== NodeTypes.VariableLookup) return;
-
-        const reference = getSettingReference(expression);
-        if (!reference || reference.dynamic || !reference.id) return;
-
-        const key = settingKey({ id: reference.id, scope: reference.scope });
-        outputs.push({ id: reference.id, key, node });
-
-        if (node.markup.filters.some(({ name }) => name === 'default')) {
-          handledSettings.add(key);
-        }
-      },
-
-      async VariableLookup(node, ancestors) {
-        const reference = getSettingReference(node);
-        if (!reference || reference.dynamic || !reference.id) return;
-        if (!isConditionalTest(node, ancestors)) return;
-
-        handledSettings.add(settingKey({ id: reference.id, scope: reference.scope }));
-      },
-
-      async onCodePathEnd() {
-        const textualTypes = new Set(context.settings.textualSettingTypes);
-        const textualSettings = new Set(
-          declarations
-            .filter(({ type }) => textualTypes.has(type))
-            .map(settingKey),
-        );
-
-        for (const output of outputs) {
-          if (!textualSettings.has(output.key) || handledSettings.has(output.key)) continue;
-
-          context.report({
-            message:
-              `The text-like setting '${output.id}' is output without a presence guard or default`,
-            startIndex: output.node.position.start,
-            endIndex: output.node.position.end,
-          });
-        }
-      },
-    };
-  },
-};
-
-function isConditionalTest(node: LiquidVariableLookup, ancestors: LiquidHtmlNode[]): boolean {
-  return ancestors.some((ancestor) => {
-    if (ancestor.type === NodeTypes.LiquidTag) {
-      if (!['if', 'unless', 'case'].includes(ancestor.name)) return false;
-      return containsNode(ancestor.markup, node);
-    }
-
-    if (ancestor.type === NodeTypes.LiquidBranch && ancestor.name === 'elsif') {
-      return containsNode(ancestor.markup, node);
-    }
-
-    return false;
-  });
-}
-
-function containsNode(markup: unknown, node: LiquidVariableLookup): boolean {
-  if (!markup || typeof markup !== 'object' || !('position' in markup)) return false;
-
-  const position = (markup as { position?: { start: number; end: number } }).position;
-  return Boolean(
-    position &&
-      position.start <= node.position.start &&
-      position.end >= node.position.end,
-  );
-}
-
-// v1 intentionally records a guard for the entire file. A branch-precise
-// version can use the visitor `ancestors` argument to bind handling to the live
-// LiquidBranch containing each output.