@augeo/smelt 1.2.2

package/vendor/theme-liquid-docs/tests/theme-settings/color_palette.spec.ts

@@ -0,0 +1,184 @@
+import { describe, expect, it } from 'vitest';
+import { validateSchema } from '../test-helpers';
+
+const validate = validateSchema();
+
+describe('Module: theme settings validation (config/settings_schema.json)', () => {
+  describe('Unit: color_palette', () => {
+    const colorPaletteSetting = {
+      type: 'color_palette',
+      id: 'color_palette',
+      default: {
+        background: '#ffffff',
+        foreground: '#000000',
+      },
+    };
+
+    const settings = (override: any) => `[
+      {
+        "name": "setting category",
+        "settings": [
+          ${JSON.stringify(Object.assign({}, colorPaletteSetting, override), null, 2)}
+        ]
+      }
+    ]`;
+
+    it('accepts a valid color_palette setting', async () => {
+      const diagnostics = await validate('config/settings_schema.json', settings({}));
+      expect(diagnostics).toHaveLength(0);
+    });
+
+    it('refuses the label property', async () => {
+      const diagnostics = await validate(
+        'config/settings_schema.json',
+        settings({ label: 'uh oh' }),
+      );
+      expect(diagnostics).toStrictEqual([
+        expect.objectContaining({
+          message: 'Property label is not allowed.',
+        }),
+      ]);
+    });
+
+    it('refuses the info property', async () => {
+      const diagnostics = await validate(
+        'config/settings_schema.json',
+        settings({ info: 'uh oh' }),
+      );
+      expect(diagnostics).toStrictEqual([
+        expect.objectContaining({
+          message: 'Property info is not allowed.',
+        }),
+      ]);
+    });
+
+    it('refuses the visible_if property', async () => {
+      const diagnostics = await validate(
+        'config/settings_schema.json',
+        settings({ visible_if: '{{ section.settings.show_palette }}' }),
+      );
+      expect(diagnostics).toStrictEqual([
+        expect.objectContaining({
+          message: 'Property visible_if is not allowed.',
+        }),
+      ]);
+    });
+
+    it('requires the default property', async () => {
+      const { default: _, ...settingWithoutDefault } = colorPaletteSetting;
+      const json = `[
+        {
+          "name": "setting category",
+          "settings": [
+            ${JSON.stringify(settingWithoutDefault, null, 2)}
+          ]
+        }
+      ]`;
+
+      const diagnostics = await validate('config/settings_schema.json', json);
+
+      expect(diagnostics).toStrictEqual([
+        expect.objectContaining({
+          message: 'Missing property "default".',
+        }),
+      ]);
+    });
+
+    it('requires the id property', async () => {
+      const { id: _, ...settingWithoutId } = colorPaletteSetting;
+      const json = `[
+        {
+          "name": "setting category",
+          "settings": [
+            ${JSON.stringify(settingWithoutId, null, 2)}
+          ]
+        }
+      ]`;
+
+      const diagnostics = await validate('config/settings_schema.json', json);
+
+      expect(diagnostics).toStrictEqual([
+        expect.objectContaining({
+          message: 'Missing property "id".',
+        }),
+      ]);
+    });
+
+    it('validates that default must be an object', async () => {
+      const diagnostics = await validate(
+        'config/settings_schema.json',
+        settings({ default: '#ffffff' }),
+      );
+      expect(diagnostics).toStrictEqual([
+        expect.objectContaining({
+          message: 'Incorrect type. Expected "object".',
+        }),
+      ]);
+    });
+
+    it('validates that default values must be strings', async () => {
+      const diagnostics = await validate(
+        'config/settings_schema.json',
+        settings({ default: { background: 123 } }),
+      );
+      expect(diagnostics).toStrictEqual([
+        expect.objectContaining({
+          message: 'Incorrect type. Expected "string".',
+        }),
+      ]);
+    });
+
+    it('refuses an empty default', async () => {
+      const diagnostics = await validate(
+        'config/settings_schema.json',
+        settings({ default: {} }),
+      );
+      expect(diagnostics).toStrictEqual([
+        expect.objectContaining({
+          message: 'Object has fewer properties than the required number of 1',
+        }),
+      ]);
+    });
+
+    it('refuses a default with more than 20 entries', async () => {
+      const tooMany = Object.fromEntries(
+        Array.from({ length: 21 }, (_, i) => [`color${i}`, '#000000']),
+      );
+      const diagnostics = await validate(
+        'config/settings_schema.json',
+        settings({ default: tooMany }),
+      );
+      expect(diagnostics).toStrictEqual([
+        expect.objectContaining({
+          message: 'Object has more properties than limit of 20.',
+        }),
+      ]);
+    });
+
+    it('refuses default keys with hyphens', async () => {
+      const diagnostics = await validate(
+        'config/settings_schema.json',
+        settings({ default: { 'primary-1': '#fff' } }),
+      );
+      expect(diagnostics).toStrictEqual([
+        expect.objectContaining({
+          message:
+            'Color palette names must start with a letter and contain only letters, digits, and underscores.',
+        }),
+      ]);
+    });
+
+    it('refuses default keys starting with a digit', async () => {
+      const diagnostics = await validate(
+        'config/settings_schema.json',
+        settings({ default: { '1bad': '#fff' } }),
+      );
+      expect(diagnostics).toStrictEqual([
+        expect.objectContaining({
+          message:
+            'Color palette names must start with a letter and contain only letters, digits, and underscores.',
+        }),
+      ]);
+    });
+  });
+});

package/vendor/theme-liquid-docs/tests/theme-settings/color_scheme_group.spec.ts

@@ -0,0 +1,143 @@
+import { describe, expect, it } from 'vitest';
+import { validateSchema } from '../test-helpers';
+
+const validate = validateSchema();
+
+describe('Module: theme settings validation (config/settings_schema.json)', () => {
+  describe('Unit: color_scheme_group', () => {
+    const colorSchemeSetting = {
+      type: 'color_scheme_group',
+      id: 'color_schemes',
+      definition: [],
+      role: {
+        text: 'text',
+        background: {
+          solid: 'background',
+          gradient: 'background_gradient',
+        },
+        links: 'secondary_button_label',
+        icons: 'text',
+        primary_button: 'button',
+        on_primary_button: 'button_label',
+        primary_button_border: 'button',
+        secondary_button: 'background',
+        on_secondary_button: 'secondary_button_label',
+        secondary_button_border: 'secondary_button_label',
+      },
+    };
+
+    const settings = (override: any) => `[
+      {
+        "name": "setting category",
+        "settings": [
+          ${JSON.stringify(Object.assign({}, colorSchemeSetting, override), null, 2)}
+        ]
+      }
+    ]`;
+
+    it('refuses the label property', async () => {
+      const diagnostics = await validate(
+        'config/settings_schema.json',
+        settings({ label: 'uh oh' }),
+      );
+      expect(diagnostics).toStrictEqual([
+        expect.objectContaining({
+          message: 'Property label is not allowed.',
+        }),
+      ]);
+    });
+
+    it('validates that the definition are of type header, color or color_background', async () => {
+      const diagnostics = await validate(
+        'config/settings_schema.json',
+        settings({ definition: [{ type: 'not good' }] }),
+      );
+      expect(diagnostics).toStrictEqual([
+        expect.objectContaining({
+          message: 'Value is not accepted. Valid values: "header", "color", "color_background".',
+        }),
+      ]);
+    });
+
+    it('validates that the definition are of type header, color or color_background (extra properties)', async () => {
+      const diagnostics = await validate(
+        'config/settings_schema.json',
+        settings({
+          definition: [
+            { type: 'header', content: 'ok', headerExtra: 'not allowed' },
+            {
+              type: 'color',
+              id: 'color',
+              label: 'my color',
+              default: '#000',
+              colorExtra: 'not allowed',
+            },
+            {
+              type: 'color_background',
+              id: 'color_bg',
+              label: 'my color background',
+              default: '#000',
+              colorBackgroundExtra: 'not allowed',
+            },
+          ],
+        }),
+      );
+      expect(diagnostics).toStrictEqual([
+        expect.objectContaining({
+          message: 'Property headerExtra is not allowed.',
+        }),
+        expect.objectContaining({
+          message: 'Property colorExtra is not allowed.',
+        }),
+        expect.objectContaining({
+          message: 'Property colorBackgroundExtra is not allowed.',
+        }),
+      ]);
+    });
+
+    it("validates that conditional settings (visible_if) is not allowed in color_scheme_group", async () => {
+      const diagnostics = await validate(
+        'config/settings_schema.json',
+        settings({ visible_if: '{{ section.settings.show_color_scheme_group }}',
+        }),
+      );
+    });
+
+    it("validates that conditional settings (visible_if) is not allowed in any nested definitions within color_scheme_group", async () => {
+      const diagnostics = await validate(
+        'config/settings_schema.json',
+        settings({
+          definition: [
+            { type: 'header', content: 'ok', visible_if: '{{ section.settings.show_color_scheme_group }}' },
+            {
+              type: 'color',
+              id: 'color',
+              label: 'my color',
+              default: '#000',
+              visible_if: '{{ section.settings.show_color_scheme_group }}',
+            },
+            {
+              type: 'color_background',
+              id: 'color_bg',
+              label: 'my color background',
+              default: '#000',
+              visible_if: '{{ section.settings.show_color_scheme_group }}',
+            },
+          ],
+        }),
+      );
+
+      expect(diagnostics).toStrictEqual([
+        expect.objectContaining({
+          message: 'The property visible_if is not allowed within color_scheme_group',
+        }),
+        expect.objectContaining({
+          message: 'The property visible_if is not allowed within color_scheme_group',
+        }),
+        expect.objectContaining({
+          message: 'The property visible_if is not allowed within color_scheme_group',
+        }),
+      ]);
+    });
+  });
+});

package/vendor/theme-liquid-docs/tests/theme-settings/general.spec.ts

@@ -0,0 +1,192 @@
+import { assert, describe, expect, it } from 'vitest';
+import { INPUT_SETTING_TYPES, SIDEBAR_SETTING_TYPES } from '../test-constants';
+import { complete, getService, hover, loadFixture, validateSchema } from '../test-helpers';
+
+const themeSettingsMetadata = loadFixture('theme-settings-metadata.json');
+const themeSettingsAllSettings = loadFixture('theme-settings-all-settings.json');
+const themeSettingsDawn = loadFixture('theme-settings-dawn.json');
+
+const validate = validateSchema();
+const service = getService();
+
+describe('Module: theme settings validation (config/settings_schema.json)', () => {
+  it('validates valid theme settings files', async () => {
+    const fixtures = [themeSettingsMetadata, themeSettingsAllSettings, themeSettingsDawn];
+    for (const fixture of fixtures) {
+      const diagnostics = await validate('config/settings_schema.json', fixture);
+      expect(diagnostics).toStrictEqual([]);
+    }
+  });
+
+  it('rejects objects at the top level', async () => {
+    const diagnostics = await validate('config/settings_schema.json', { invalid: 'value' });
+    expect(diagnostics).toStrictEqual([
+      {
+        message: 'Incorrect type. Expected "array".',
+        severity: 1,
+        range: expect.objectContaining({
+          start: expect.objectContaining({
+            character: expect.any(Number),
+            line: expect.any(Number),
+          }),
+          end: expect.objectContaining({
+            character: expect.any(Number),
+            line: expect.any(Number),
+          }),
+        }),
+      },
+    ]);
+  });
+
+  describe('Unit: Settings', () => {
+    it('should report invalid enum values', async () => {
+      // Using JSON to make a deep copy of one of the valid schemas to mutate safely.
+      const settings = `[
+        {
+          "name": "some category",
+          "settings": [
+            {
+              "type": "not good",
+              "id": "some_id",
+              "label": "Some Label"
+            }
+          ]
+        }
+      ]`;
+
+      const diagnostics = await validate('config/settings_schema.json', settings);
+      expect(diagnostics).toStrictEqual([
+        {
+          code: 1,
+          message: expect.stringContaining(
+            'Value is not accepted. Valid values: "article", "article_list", "blog"',
+          ),
+          severity: 1,
+          range: expect.objectContaining({
+            start: expect.objectContaining({
+              character: expect.any(Number),
+              line: expect.any(Number),
+            }),
+            end: expect.objectContaining({
+              character: expect.any(Number),
+              line: expect.any(Number),
+            }),
+          }),
+        },
+      ]);
+    });
+
+    it('has documentation for all input setting types that point to the input settings documentation', async () => {
+      for (const inputSetting of INPUT_SETTING_TYPES) {
+        const settings = `
+          [
+            {
+              "name": "some category",
+              "settings": [
+                {
+                  "type": "${inputSetting}█"
+                }
+              ]
+            }
+          ]`;
+        const result = await hover(service, 'config/settings_schema.json', settings);
+        assert(result);
+        expect(result.contents).toContainEqual(
+          expect.stringContaining(
+            'https://shopify.dev/docs/themes/architecture/settings/input-settings#' + inputSetting,
+          ),
+        );
+      }
+    });
+
+    it('has documentation for all sidebar setting types that point to the sidebar settings documentation', async () => {
+      for (const sidebarSetting of SIDEBAR_SETTING_TYPES) {
+        const settings = `
+          [
+            {
+              "name": "some category",
+              "settings": [
+                {
+                  "type": "${sidebarSetting}█"
+                }
+              ]
+            }
+          ]`;
+        const result = await hover(service, 'config/settings_schema.json', settings);
+        assert(result);
+        expect(result.contents).toContainEqual(
+          expect.stringContaining(
+            'https://shopify.dev/docs/themes/architecture/settings/sidebar-settings#' +
+              sidebarSetting,
+          ),
+        );
+      }
+    });
+
+    it('has standardized documentation for all setting types', async () => {
+      for (const setting of [...INPUT_SETTING_TYPES, ...SIDEBAR_SETTING_TYPES]) {
+        const settings = `
+          [
+            {
+              "name": "some category",
+              "settings": [
+                {
+                  "type": "${setting}█"
+                }
+              ]
+            }
+          ]`;
+        const result = await hover(service, 'config/settings_schema.json', settings);
+        assert(result);
+        expect(result.contents).toContainEqual(
+          expect.stringContaining('A setting of type `' + setting + '`'),
+        );
+      }
+    });
+
+    it('completes the type property with the generic documentation', async () => {
+      const settings = `[
+        {
+          "name": "some category",
+          "settings": [
+            {
+              "type█"
+            }
+          ]
+        }
+      ]`;
+      const result = await complete(service, 'config/settings_schema.json', settings);
+      assert(result);
+      expect(result.items).toContainEqual(
+        expect.objectContaining({
+          documentation: expect.stringContaining(
+            'This value determines the type of field that gets rendered into the editor.',
+          ),
+        }),
+      );
+    });
+
+    it('completes the type value with the setting type enums', async () => {
+      const settings = `[
+        {
+          "name": "some category",
+          "settings": [
+            {
+              "type": "█"
+            }
+          ]
+        }
+      ]`;
+      const result = await complete(service, 'config/settings_schema.json', settings);
+      assert(result);
+      expect(result.items).to.have.lengthOf(INPUT_SETTING_TYPES.length + SIDEBAR_SETTING_TYPES.length);
+      for (const setting of [...INPUT_SETTING_TYPES, ...SIDEBAR_SETTING_TYPES]) {
+        expect(result.items).toContainEqual(
+          expect.objectContaining({
+            label: `"${setting}"`,
+          }),
+        );
+      }
+    });
+  });
+});

package/vendor/theme-liquid-docs/tests/theme-settings/metaobject.spec.ts

@@ -0,0 +1,94 @@
+import { describe, expect, it } from 'vitest';
+import { validateSchema } from '../test-helpers';
+
+const validate = validateSchema();
+
+describe('Module: theme settings validation (config/settings_schema.json)', () => {
+  describe('Unit: metaobject settings', () => {
+    it('metaobject setting requires a metaobject_type', async () => {
+      const settings = `[
+        {
+          "name": "some category",
+          "settings": [
+            {
+              "type": "metaobject",
+              "id": "metaobject",
+              "label": "Metaobject"
+            }
+          ]
+        }
+      ]`;
+
+      const diagnostics = await validate('config/settings_schema.json', settings);
+
+      expect(diagnostics).toStrictEqual([
+        expect.objectContaining({
+          message: `Missing property "metaobject_type".`,
+        }),
+      ]);
+    });
+
+    it('metaobject_list setting requires a metaobject_type', async () => {
+      const settings = `[
+        {
+          "name": "some category",
+          "settings": [
+            {
+              "type": "metaobject_list",
+              "id": "metaobject_list",
+              "label": "metaobject list"
+            }
+          ]
+        }
+      ]`;
+
+      const diagnostics = await validate('config/settings_schema.json', settings);
+
+      expect(diagnostics).toStrictEqual([
+        expect.objectContaining({
+          message: `Missing property "metaobject_type".`,
+        }),
+      ]);
+    });
+
+    it('metaobject setting allows a valid metaobject_type', async () => {
+      const settings = `[
+        {
+          "name": "some category",
+          "settings": [
+            {
+              "type": "metaobject",
+              "id": "metaobject",
+              "label": "Metaobject",
+              "metaobject_type": "author"
+            }
+          ]
+        }
+      ]`;
+
+      const diagnostics = await validate('config/settings_schema.json', settings);
+
+      expect(diagnostics).toHaveLength(0);
+    });
+
+    it('metaobject_list setting allows a valid metaobject_type', async () => {
+      const settings = `[
+        {
+          "name": "some category",
+          "settings": [
+            {
+              "type": "metaobject_list",
+              "id": "metaobject_list",
+              "label": "Metaobject list",
+              "metaobject_type": "author"
+            }
+          ]
+        }
+      ]`;
+
+      const diagnostics = await validate('config/settings_schema.json', settings);
+
+      expect(diagnostics).toHaveLength(0);
+    });
+  });
+});

package/vendor/theme-liquid-docs/tests/theme-settings/resource_list.spec.ts

@@ -0,0 +1,58 @@
+import { describe, expect, it } from 'vitest';
+import { validateSchema } from '../test-helpers';
+import { RESOURCE_LIST_SETTING_TYPES } from '../test-constants';
+
+const validate = validateSchema();
+
+describe('Module: theme settings validation (config/settings_schema.json)', () => {
+  describe.each(RESOURCE_LIST_SETTING_TYPES)('Resource list setting: %s', (setting_type) => {
+    it(`${setting_type} does not require a limit`, async () => {
+      const metaobject_type =
+        setting_type === 'metaobject_list' ? `, "metaobject_type": "author"` : '';
+      const settings = `[
+        {
+          "name": "some category",
+          "settings": [
+            {
+              "type": "${setting_type}",
+              "id": "${setting_type}",
+              "label": "${setting_type}"
+              ${metaobject_type}
+            }
+          ]
+        }
+      ]`;
+
+      const diagnostics = await validate('config/settings_schema.json', settings);
+
+      expect(diagnostics).toHaveLength(0);
+    });
+
+    it(`${setting_type} allows having a numeric limit`, async () => {
+      const metaobject_type =
+        setting_type === 'metaobject_list' ? `, "metaobject_type": "author"` : '';
+      const settings = `[
+        {
+          "name": "some category",
+          "settings": [
+            {
+              "type": "${setting_type}",
+              "id": "${setting_type}",
+              "label": "${setting_type}",
+              "limit": 10
+              ${metaobject_type}
+            }
+          ]
+        }
+      ]`;
+
+      const diagnostics = await validate('config/settings_schema.json', settings);
+
+      expect(diagnostics).not.toContainEqual(
+        expect.objectContaining({
+          message: expect.stringContaining('limit'),
+        }),
+      );
+    });
+  });
+});