slicejs-cli 3.5.0 → 3.5.1

package/tests/bundling-dependency-edges.test.js

@@ -0,0 +1,127 @@
+import { test, describe } from 'node:test';
+import assert from 'node:assert/strict';
+import { parse } from '@babel/parser';
+import BundleGenerator from '../commands/utils/bundling/BundleGenerator.js';
+
+const MODULE_URL = import.meta.url;
+
+function makeGenerator() {
+  const gen = new BundleGenerator(MODULE_URL, null, {});
+  gen.sliceConfig = {};
+  return gen;
+}
+
+function evalSnippet(code) {
+  // eslint-disable-next-line no-new-func
+  return new Function(code)();
+}
+
+// Build the dependency-exports object the bundler would emit for a single
+// shared module, then read back its keys at runtime.
+function evalDepExports(content, moduleName = 'shared/util.js') {
+  const gen = makeGenerator();
+  const block = gen.buildV2DependencyModuleBlockFromModules([{ name: moduleName, content }]);
+  // The block declares `const __sliceDepExports0 = {}` and fills it; expose it.
+  return evalSnippet(`${block}\nreturn typeof __sliceDepExports0 !== 'undefined' ? __sliceDepExports0 : {};`);
+}
+
+describe('shared dependency module transforms', () => {
+  test('plain named exports resolve', () => {
+    const d = evalDepExports('export const a = 1;\nexport const b = 2;');
+    assert.equal(d.a, 1);
+    assert.equal(d.b, 2);
+  });
+
+  test('multiline export list resolves every name', () => {
+    const d = evalDepExports('const a = 1;\nconst b = 2;\nconst c = 3;\nexport {\n  a,\n  b,\n  c\n};');
+    assert.deepEqual([d.a, d.b, d.c], [1, 2, 3]);
+  });
+
+  test('export { x as default } exposes a usable default', () => {
+    // A consumer doing `import def from '...'` resolves default via the runtime
+    // helper, which first checks `.default`. So the exports object should carry
+    // a `default` (or the basename-Data fallback) for the aliased-default form.
+    const d = evalDepExports('const x = 7;\nexport { x as default };', 'shared/util.js');
+    const resolvable = d.default !== undefined || d.utilData !== undefined;
+    assert.ok(resolvable, 'aliased default export is not resolvable by the bundle');
+  });
+
+  test('destructuring export does not silently drop the binding', () => {
+    // `export const { a } = obj` is a valid ESM export; the consumer expects `a`.
+    const d = evalDepExports('const obj = { a: 5 };\nexport const { a } = obj;');
+    assert.equal(d.a, 5, 'destructured export binding was dropped');
+  });
+
+  test('exports that reference one another resolve at runtime', () => {
+    // A helper export referencing a constant export must still find it — the
+    // transform has to keep a usable local binding, not only the exports field.
+    const d = evalDepExports(
+      "export const TAG = 'x';\nexport function badge(label) { return '[' + TAG + '] ' + label; }"
+    );
+    assert.equal(d.TAG, 'x');
+    assert.equal(typeof d.badge, 'function');
+    assert.equal(d.badge('hi'), '[x] hi');
+  });
+
+  test('a transitive dependency is inlined and bound (topological order)', () => {
+    const gen = makeGenerator();
+    // mid imports leaf; pass mid FIRST so the topological sort must reorder.
+    const block = gen.buildV2DependencyModuleBlockFromModules([
+      {
+        name: 'shared/mid.js',
+        content: "import { LEAF } from './leaf.js';\nexport function midValue() { return 'mid:' + LEAF; }",
+        moduleImports: [
+          { depName: 'shared/leaf.js', bindings: [{ type: 'named', importedName: 'LEAF', localName: 'LEAF' }] },
+        ],
+      },
+      { name: 'shared/leaf.js', content: "export const LEAF = 'leaf-value';", moduleImports: [] },
+    ]);
+    const deps = evalSnippet(`${block}\nreturn SLICE_BUNDLE_DEPENDENCIES;`);
+    assert.equal(deps['shared/leaf.js'].LEAF, 'leaf-value');
+    assert.equal(deps['shared/mid.js'].midValue(), 'mid:leaf-value');
+  });
+});
+
+describe('transitive dependencies of a shared module', () => {
+  function bundleWithDependency(depName, depContent, bindings) {
+    const gen = makeGenerator();
+    const comp = {
+      name: 'Widget',
+      category: 'Visual',
+      categoryType: 'Visual',
+      js: 'const C = class {};\nreturn C;',
+      hoistedImports: [],
+      html: '',
+      css: '',
+      externalDependencies: { [depName]: { content: depContent, bindings } },
+      size: 100,
+    };
+    return gen.generateBundleFileContent('slice-bundle.critical.js', 'critical', [comp]);
+  }
+
+  test('a relative import inside a shared module must not leak into the bundle', () => {
+    const code = bundleWithDependency(
+      'shared/helper.js',
+      "import deep from './deep.js';\nexport const helper = () => deep;",
+      [{ type: 'named', importedName: 'helper', localName: 'helper' }]
+    );
+    // Whatever the strategy, the emitted bundle must not contain an unresolved
+    // relative import — it would 404 / fail to resolve in production.
+    assert.ok(
+      !/import\s+[^;]*from\s+['"]\.\.?\//.test(code),
+      'unresolved relative import leaked from a transitive dependency'
+    );
+  });
+
+  test('a bare import inside a shared module must not leak into the bundle', () => {
+    const code = bundleWithDependency(
+      'shared/helper.js',
+      "import 'side-effect-polyfill';\nexport const helper = () => 1;",
+      [{ type: 'named', importedName: 'helper', localName: 'helper' }]
+    );
+    assert.ok(
+      !/import\s+['"][^'"]+['"]/.test(code),
+      'unresolved bare import leaked from a transitive dependency'
+    );
+  });
+});

package/tests/bundling-imports-unit.test.js

@@ -0,0 +1,267 @@
+import { test, describe } from 'node:test';
+import assert from 'node:assert/strict';
+import { parse } from '@babel/parser';
+import BundleGenerator from '../commands/utils/bundling/BundleGenerator.js';
+
+// These tests exercise the cross-module import / variable handling of the
+// bundler in isolation. They are written to assert *correct* behaviour, so a
+// failure here documents a real gap/bug in the bundler rather than the test.
+
+function makeGenerator(sliceConfig = {}) {
+  const gen = new BundleGenerator(import.meta.url, null, {});
+  gen.sliceConfig = sliceConfig;
+  return gen;
+}
+
+// Evaluate a generated JS snippet in a throwaway scope and return whatever the
+// trailing `return` yields. Used to verify the *runtime* behaviour of the code
+// the bundler emits (not just its shape).
+function evalSnippet(code) {
+  // eslint-disable-next-line no-new-func
+  return new Function(code)();
+}
+
+describe('classifyImport', () => {
+  const gen = makeGenerator({ publicFolders: ['/assets', '/Themes'] });
+  const publicFolders = gen.getConfiguredPublicFolders();
+
+  test('relative imports are dropped silently (no warning)', () => {
+    const r = gen.classifyImport('./Foo.js', publicFolders);
+    assert.equal(r.keep, false);
+    assert.equal(r.warning, null);
+  });
+
+  test('parent-relative imports are dropped silently', () => {
+    const r = gen.classifyImport('../shared/util.js', publicFolders);
+    assert.equal(r.keep, false);
+    assert.equal(r.warning, null);
+  });
+
+  test('absolute imports inside publicFolders are kept', () => {
+    const r = gen.classifyImport('/assets/lib/x.js', publicFolders);
+    assert.equal(r.keep, true);
+    assert.equal(r.warning, null);
+  });
+
+  test('absolute import exactly matching a publicFolder is kept', () => {
+    const r = gen.classifyImport('/assets', publicFolders);
+    assert.equal(r.keep, true);
+  });
+
+  test('absolute imports outside publicFolders are dropped with warning', () => {
+    const r = gen.classifyImport('/secret/key.js', publicFolders);
+    assert.equal(r.keep, false);
+    assert.match(r.warning, /outside publicFolders/);
+  });
+
+  test('a publicFolder name must not match by prefix only (/assetsX)', () => {
+    const r = gen.classifyImport('/assetsX/x.js', publicFolders);
+    assert.equal(r.keep, false, '/assetsX should NOT be treated as inside /assets');
+  });
+
+  test('bare specifier imports are dropped with warning', () => {
+    const r = gen.classifyImport('lodash', publicFolders);
+    assert.equal(r.keep, false);
+    assert.match(r.warning, /bare import/);
+  });
+
+  test('non-string import path is handled defensively', () => {
+    const r = gen.classifyImport(undefined, publicFolders);
+    assert.equal(r.keep, false);
+  });
+});
+
+describe('stripImports', () => {
+  test('removes relative + bare imports, keeps body intact', () => {
+    const gen = makeGenerator({ publicFolders: [] });
+    const code = [
+      "import Foo from './Foo.js';",
+      "import { x } from 'pkg';",
+      'const value = 42;',
+      'export default value;',
+    ].join('\n');
+    const out = gen.stripImports(code, { collectHoistedImports: true });
+    assert.ok(!out.code.includes("from './Foo.js'"));
+    assert.ok(!out.code.includes("from 'pkg'"));
+    assert.ok(out.code.includes('const value = 42;'));
+    assert.deepEqual(out.hoistedImports, []);
+  });
+
+  test('hoists kept public-folder imports instead of inlining them', () => {
+    const gen = makeGenerator({ publicFolders: ['/assets'] });
+    const code = "import lib from '/assets/lib.js';\nconst a = lib;";
+    const out = gen.stripImports(code, { collectHoistedImports: true });
+    assert.equal(out.hoistedImports.length, 1);
+    assert.match(out.hoistedImports[0], /\/assets\/lib\.js/);
+    // The hoisted import must NOT remain inline in the body.
+    assert.ok(!out.code.includes("import lib from '/assets/lib.js'"));
+  });
+
+  test('code with no imports is returned unchanged', () => {
+    const gen = makeGenerator();
+    const code = 'const a = 1;\nconst b = 2;';
+    const out = gen.stripImports(code, { collectHoistedImports: true });
+    assert.equal(out.code, code);
+  });
+
+  test('falls back to regex scanner when Babel cannot parse', () => {
+    const gen = makeGenerator({ publicFolders: [] });
+    // `@decorator` + class field syntax with no plugin -> Babel throws -> fallback.
+    const code = "import x from './x.js';\nconst valid = 1;\nthis is not ::: valid js @@@";
+    // Should not throw; relative import must still be stripped.
+    const out = gen.stripImports(code, { collectHoistedImports: true });
+    assert.ok(!out.code.includes("from './x.js'"));
+  });
+});
+
+describe('extractLocalBindingsFromImportStatement', () => {
+  const gen = makeGenerator();
+
+  test('default import', () => {
+    assert.deepEqual(gen.extractLocalBindingsFromImportStatement("import Foo from 'x';"), ['Foo']);
+  });
+
+  test('named imports', () => {
+    assert.deepEqual(
+      gen.extractLocalBindingsFromImportStatement("import { a, b } from 'x';").sort(),
+      ['a', 'b']
+    );
+  });
+
+  test('aliased named import uses the local name', () => {
+    assert.deepEqual(gen.extractLocalBindingsFromImportStatement("import { a as b } from 'x';"), ['b']);
+  });
+
+  test('namespace import', () => {
+    assert.deepEqual(gen.extractLocalBindingsFromImportStatement("import * as NS from 'x';"), ['NS']);
+  });
+
+  test('mixed default + named', () => {
+    assert.deepEqual(
+      gen.extractLocalBindingsFromImportStatement("import Foo, { a, b as c } from 'x';").sort(),
+      ['Foo', 'a', 'c']
+    );
+  });
+
+  test('side-effect import has no bindings', () => {
+    assert.deepEqual(gen.extractLocalBindingsFromImportStatement("import 'x';"), []);
+  });
+});
+
+describe('validateHoistedImportCollisions', () => {
+  const gen = makeGenerator();
+
+  test('throws on the same binding from two different statements', () => {
+    assert.throws(
+      () => gen.validateHoistedImportCollisions([
+        "import Foo from '/assets/a.js';",
+        "import Foo from '/assets/b.js';",
+      ]),
+      /binding collision/
+    );
+  });
+
+  test('does not throw when the identical statement appears twice', () => {
+    assert.doesNotThrow(() => gen.validateHoistedImportCollisions([
+      "import Foo from '/assets/a.js';",
+      "import Foo from '/assets/a.js';",
+    ]));
+  });
+
+  test('throws when a hoisted binding collides with a reserved identifier', () => {
+    assert.throws(
+      () => gen.validateHoistedImportCollisions(
+        ["import SLICE_BUNDLE_META from '/assets/a.js';"],
+        new Set(['SLICE_BUNDLE_META'])
+      ),
+      /reserved identifier collision/
+    );
+  });
+});
+
+describe('transformDependencyContent', () => {
+  const gen = makeGenerator();
+
+  function transformAndEval(content, moduleName = 'shared/util.js') {
+    const transformed = gen.transformDependencyContent(content, '__d', moduleName);
+    return evalSnippet(`const __d = {};\n${transformed}\nreturn __d;`);
+  }
+
+  test('export const / let / var are attached to the exports object', () => {
+    const d = transformAndEval('export const A = 1;\nexport let B = 2;\nexport var C = 3;');
+    assert.equal(d.A, 1);
+    assert.equal(d.B, 2);
+    assert.equal(d.C, 3);
+  });
+
+  test('export function is attached and callable', () => {
+    const d = transformAndEval('export function fn() { return 7; }');
+    assert.equal(typeof d.fn, 'function');
+    assert.equal(d.fn(), 7);
+  });
+
+  test('export default maps to the <basename>Data fallback key', () => {
+    const d = transformAndEval('export default 99;', 'shared/util.js');
+    assert.equal(d.utilData, 99);
+  });
+
+  test('plain export { a, b } re-exports local bindings', () => {
+    const d = transformAndEval('const a = 10;\nconst b = 20;\nexport { a, b };');
+    assert.equal(d.a, 10);
+    assert.equal(d.b, 20);
+  });
+
+  test('aliased export { internal as Public } exposes the PUBLIC name', () => {
+    // A consumer writes `import { Public } from '...'`, so the exports object
+    // must carry `Public`, mapped to the value of `internal`.
+    const d = transformAndEval('const internal = 55;\nexport { internal as Public };');
+    assert.equal(d.Public, 55, 'exported alias name should be the public key');
+  });
+});
+
+describe('default export resolver (__sliceResolveDefaultExport)', () => {
+  const gen = makeGenerator();
+  function buildResolver() {
+    const lines = gen.getDefaultExportResolverLines().join('\n');
+    return evalSnippet(`${lines}\nreturn __sliceResolveDefaultExport;`);
+  }
+
+  test('returns .default when present', () => {
+    const resolve = buildResolver();
+    assert.equal(resolve({ default: 5, other: 9 }, 'm', null), 5);
+  });
+
+  test('returns the single non-default key when only one exists', () => {
+    const resolve = buildResolver();
+    assert.equal(resolve({ only: 42 }, 'm', null), 42);
+  });
+
+  test('honours the preferred key', () => {
+    const resolve = buildResolver();
+    assert.equal(resolve({ a: 1, utilData: 2 }, 'm', 'utilData'), 2);
+  });
+
+  test('primitive dependency is returned as-is', () => {
+    const resolve = buildResolver();
+    assert.equal(resolve(7, 'm', null), 7);
+  });
+});
+
+describe('toSafeIdentifier', () => {
+  const gen = makeGenerator();
+
+  test('produces a valid JS identifier', () => {
+    const id = gen.toSafeIdentifier('My-Component');
+    assert.doesNotThrow(() => parse(`const ${id} = 1;`));
+  });
+
+  test('distinct component names must not collide to the same identifier', () => {
+    // Two registered components differing only by a non-alphanumeric char would
+    // otherwise emit two `const <id>` declarations -> duplicate-decl syntax error.
+    assert.notEqual(
+      gen.toSafeIdentifier('my-btn'),
+      gen.toSafeIdentifier('my_btn'),
+      'distinct names collapse to the same bundle identifier'
+    );
+  });
+});

package/tests/commands-component-crud.test.js

@@ -0,0 +1,102 @@
+import { test, describe } from 'node:test';
+import assert from 'node:assert/strict';
+import fs from 'fs-extra';
+import path from 'node:path';
+import { withTestProject } from './helpers/setup.js';
+import createComponent from '../commands/createComponent/createComponent.js';
+import deleteComponent from '../commands/deleteComponent/deleteComponent.js';
+import listComponentsReal from '../commands/listComponents/listComponents.js';
+
+const visualDir = (root, name) =>
+  path.join(root, 'src', 'Components', 'Visual', name);
+
+describe('component create', () => {
+  test('creates a Visual component with .js/.css/.html', async () => {
+    await withTestProject(async (root) => {
+      const ok = createComponent('Card', 'Visual');
+      assert.equal(ok, true);
+      const dir = visualDir(root, 'Card');
+      assert.ok(await fs.pathExists(path.join(dir, 'Card.js')));
+      assert.ok(await fs.pathExists(path.join(dir, 'Card.css')));
+      assert.ok(await fs.pathExists(path.join(dir, 'Card.html')));
+    });
+  });
+
+  test('creates a Service component with only a .js file', async () => {
+    await withTestProject(async (root) => {
+      const ok = createComponent('Api', 'Service');
+      assert.equal(ok, true);
+      const dir = path.join(root, 'src', 'Components', 'Service', 'Api');
+      assert.ok(await fs.pathExists(path.join(dir, 'Api.js')));
+      assert.equal(await fs.pathExists(path.join(dir, 'Api.css')), false);
+    });
+  });
+
+  test('rejects an invalid component name', async () => {
+    await withTestProject(() => {
+      assert.equal(createComponent('1Bad', 'Visual'), false);
+      assert.equal(createComponent('bad-name', 'Visual'), false);
+    });
+  });
+
+  test('rejects an unknown category', async () => {
+    await withTestProject(() => {
+      assert.equal(createComponent('Card', 'Nope'), false);
+    });
+  });
+
+  test('rejects when the component files already exist', async () => {
+    await withTestProject(() => {
+      assert.equal(createComponent('Card', 'Visual'), true);
+      // Second creation hits the on-disk existence guard.
+      assert.equal(createComponent('Card', 'Visual'), false);
+    });
+  });
+});
+
+describe('component delete', () => {
+  test('deletes an existing component directory', async () => {
+    await withTestProject(async (root) => {
+      createComponent('Card', 'Visual');
+      assert.ok(await fs.pathExists(visualDir(root, 'Card')));
+
+      const ok = deleteComponent('Card', 'Visual');
+      assert.equal(ok, true);
+      assert.equal(await fs.pathExists(visualDir(root, 'Card')), false);
+    });
+  });
+
+  test('returns false when the component does not exist', async () => {
+    await withTestProject(() => {
+      assert.equal(deleteComponent('DoesNotExist', 'Visual'), false);
+    });
+  });
+
+  // Components are PascalCase by convention: both create and delete normalize
+  // the initial to uppercase, so a lower-case name round-trips correctly.
+  test('create/delete round-trips a lower-case initial (PascalCase normalization)', async () => {
+    await withTestProject(async (root) => {
+      assert.equal(createComponent('card', 'Visual'), true);
+      assert.ok(await fs.pathExists(visualDir(root, 'Card')), 'folder is created in PascalCase');
+      assert.equal(deleteComponent('card', 'Visual'), true);
+      assert.equal(await fs.pathExists(visualDir(root, 'Card')), false);
+    });
+  });
+});
+
+describe('component list (registry regeneration)', () => {
+  test('regenerates components.js from the files on disk', async () => {
+    await withTestProject(async (root) => {
+      createComponent('Card', 'Visual');
+      listComponentsReal();
+
+      const registryPath = path.join(root, 'src', 'Components', 'components.js');
+      const content = await fs.readFile(registryPath, 'utf8');
+      const json = JSON.parse(content.match(/const components = ({[\s\S]*?});/)[1]);
+
+      assert.equal(json.Card, 'Visual');
+      // Starter AppComponents must still be present.
+      assert.equal(json.AppShell, 'AppComponents');
+    });
+  });
+});

package/tests/commands-doctor.test.js

@@ -0,0 +1,80 @@
+import { test, describe } from 'node:test';
+import assert from 'node:assert/strict';
+import fs from 'fs-extra';
+import path from 'node:path';
+import { withTestProject } from './helpers/setup.js';
+import {
+  checkNodeVersion,
+  checkDirectoryStructure,
+  checkConfig,
+  checkComponents,
+} from '../commands/doctor/doctor.js';
+
+describe('doctor checks', () => {
+  test('checkNodeVersion passes on the supported runtime', async () => {
+    const r = await checkNodeVersion();
+    assert.equal(r.pass, true);
+    assert.match(r.message, /Node\.js version/);
+  });
+
+  test('checkDirectoryStructure passes on the starter project', async () => {
+    await withTestProject(async () => {
+      const r = await checkDirectoryStructure();
+      assert.equal(r.pass, true);
+    });
+  });
+
+  test('checkDirectoryStructure fails when src/ is missing', async () => {
+    await withTestProject(async (root) => {
+      await fs.remove(path.join(root, 'src'));
+      const r = await checkDirectoryStructure();
+      assert.equal(r.pass, false);
+      assert.match(r.message, /Missing directories/);
+      assert.match(r.message, /src\//);
+    });
+  });
+
+  test('checkConfig passes for a valid sliceConfig.json', async () => {
+    await withTestProject(async () => {
+      const r = await checkConfig();
+      assert.equal(r.pass, true);
+    });
+  });
+
+  test('checkConfig fails on invalid JSON', async () => {
+    await withTestProject(async (root) => {
+      await fs.writeFile(path.join(root, 'src', 'sliceConfig.json'), '{ not valid json ');
+      const r = await checkConfig();
+      assert.equal(r.pass, false);
+      assert.match(r.message, /invalid JSON/);
+    });
+  });
+
+  test('checkConfig fails when paths.components is missing', async () => {
+    await withTestProject(async (root) => {
+      await fs.writeJson(path.join(root, 'src', 'sliceConfig.json'), { server: { port: 3000 } });
+      const r = await checkConfig();
+      assert.equal(r.pass, false);
+      assert.match(r.message, /missing paths\.components/);
+    });
+  });
+
+  test('checkComponents reports OK when every component folder has its .js', async () => {
+    await withTestProject(async () => {
+      const r = await checkComponents();
+      assert.equal(r.pass, true);
+      assert.match(r.message, /components checked/);
+    });
+  });
+
+  test('checkComponents warns when a component folder lacks its .js file', async () => {
+    await withTestProject(async (root) => {
+      // AppShell ships with AppShell.js; remove it to simulate a broken component.
+      const broken = path.join(root, 'src', 'Components', 'AppComponents', 'Broken');
+      await fs.ensureDir(broken); // directory with no Broken.js
+      const r = await checkComponents();
+      assert.equal(r.warn, true);
+      assert.match(r.message, /missing files/);
+    });
+  });
+});

package/tests/commands-version-checker.test.js

@@ -0,0 +1,37 @@
+import { test, describe } from 'node:test';
+import assert from 'node:assert/strict';
+import versionChecker from '../commands/utils/VersionChecker.js';
+
+describe('VersionChecker.compareVersions', () => {
+  test('detects an outdated version', () => {
+    assert.equal(versionChecker.compareVersions('1.0.0', '1.0.1'), 'outdated');
+    assert.equal(versionChecker.compareVersions('1.2.0', '2.0.0'), 'outdated');
+  });
+
+  test('detects a newer (local) version', () => {
+    assert.equal(versionChecker.compareVersions('2.0.0', '1.9.9'), 'newer');
+  });
+
+  test('detects an up-to-date version', () => {
+    assert.equal(versionChecker.compareVersions('3.5.0', '3.5.0'), 'current');
+  });
+
+  test('handles version strings of differing length', () => {
+    assert.equal(versionChecker.compareVersions('1.0', '1.0.0'), 'current');
+    assert.equal(versionChecker.compareVersions('1.0.0', '1.0.0.1'), 'outdated');
+    assert.equal(versionChecker.compareVersions('1.0.1', '1.0'), 'newer');
+  });
+
+  test('returns null when a version is missing', () => {
+    assert.equal(versionChecker.compareVersions(null, '1.0.0'), null);
+    assert.equal(versionChecker.compareVersions('1.0.0', undefined), null);
+  });
+});
+
+describe('VersionChecker.getCurrentVersions', () => {
+  test('reads the CLI version from the package.json (no network)', async () => {
+    const current = await versionChecker.getCurrentVersions();
+    assert.ok(current, 'should resolve current versions');
+    assert.match(current.cli, /^\d+\.\d+\.\d+/);
+  });
+});

package/tests/component-registry-parse.test.js

@@ -30,5 +30,5 @@ test('Validations componentExists with JSON.parse (no eval)', async () => {
     const validations = (await import('../commands/Validations.js')).default;
     assert.equal(validations.componentExists('Button'), true);
     assert.equal(validations.componentExists('NonExistent'), false);
-  });
+  }, { visualComponents: ['Button'] });
 });