slicejs-web-framework 3.4.2 → 3.4.4

package/slicejs-cli/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/slicejs-cli/tests/client-launcher-contract.test.js

@@ -0,0 +1,211 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { parse } from '@babel/parser';
+import babelTraverse from '@babel/traverse';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const clientPath = path.join(__dirname, '..', 'client.js');
+const source = fs.readFileSync(clientPath, 'utf-8');
+const ast = parse(source, {
+  sourceType: 'module',
+  plugins: []
+});
+const traverse = babelTraverse.default || babelTraverse;
+
+function walk(node, visit) {
+  if (!node || typeof node !== 'object') {
+    return;
+  }
+
+  visit(node);
+
+  for (const value of Object.values(node)) {
+    if (Array.isArray(value)) {
+      for (const item of value) {
+        walk(item, visit);
+      }
+      continue;
+    }
+
+    walk(value, visit);
+  }
+}
+
+function getImportedBindings(fromSource) {
+  const bindings = new Map();
+
+  for (const statement of ast.program.body) {
+    if (statement.type !== 'ImportDeclaration') {
+      continue;
+    }
+
+    if (statement.source.value !== fromSource) {
+      continue;
+    }
+
+    for (const specifier of statement.specifiers) {
+      if (specifier.type === 'ImportSpecifier' && specifier.imported.type === 'Identifier') {
+        bindings.set(specifier.imported.name, specifier.local.name);
+      }
+    }
+  }
+
+  return bindings;
+}
+
+function getBoundImportedCallPositions(fromSource, importedName) {
+  const positions = [];
+  const importedBindings = getImportedBindings(fromSource);
+  const localName = importedBindings.get(importedName);
+
+  if (!localName) {
+    return positions;
+  }
+
+  traverse(ast, {
+    CallExpression(callPath) {
+      if (callPath.node.callee.type !== 'Identifier') {
+        return;
+      }
+
+      if (callPath.node.callee.name !== localName) {
+        return;
+      }
+
+      const binding = callPath.scope.getBinding(localName);
+      if (!binding) {
+        return;
+      }
+
+      if (binding.path.node.type !== 'ImportSpecifier') {
+        return;
+      }
+
+      if (binding.path.parent.type !== 'ImportDeclaration') {
+        return;
+      }
+
+      if (binding.path.parent.source.value !== fromSource) {
+        return;
+      }
+
+      if (binding.path.node.imported.type !== 'Identifier') {
+        return;
+      }
+
+      if (binding.path.node.imported.name !== importedName) {
+        return;
+      }
+
+      positions.push(callPath.node.start);
+    }
+  });
+
+  return positions;
+}
+
+function getCommandRegistrationPositions() {
+  const positions = [];
+
+  walk(ast.program, (node) => {
+    if (node.type !== 'CallExpression') {
+      return;
+    }
+
+    if (
+      node.callee.type === 'MemberExpression' &&
+      !node.callee.computed &&
+      node.callee.property.type === 'Identifier' &&
+      node.callee.property.name === 'command'
+    ) {
+      positions.push(node.start);
+    }
+  });
+
+  return positions;
+}
+
+const launcherModulePath = './commands/utils/LocalCliDelegation.js';
+const commandRegistrationPositions = getCommandRegistrationPositions();
+const firstCommandRegistrationPos = Math.min(...commandRegistrationPositions);
+
+test('client imports LocalCliDelegation utility', () => {
+  const importedBindings = getImportedBindings(launcherModulePath);
+
+  assert.ok(
+    importedBindings.size > 0,
+    'Contract clause failed: client.js must import launcher helpers from ./commands/utils/LocalCliDelegation.js'
+  );
+
+  for (const requiredImport of [
+    'isLocalDelegationDisabled',
+    'findNearestLocalCliEntry',
+    'shouldDelegateToLocalCli'
+  ]) {
+    assert.ok(
+      importedBindings.has(requiredImport),
+      `Contract clause failed: client.js must import ${requiredImport} from ${launcherModulePath}`
+    );
+  }
+});
+
+test('client checks SLICE_NO_LOCAL_DELEGATION behavior before command runtime', () => {
+  const isDisabledCalls = getBoundImportedCallPositions(
+    launcherModulePath,
+    'isLocalDelegationDisabled'
+  );
+
+  assert.ok(
+    isDisabledCalls.length > 0,
+    'Contract clause failed: client.js must call imported isLocalDelegationDisabled() in launcher path'
+  );
+
+  assert.ok(
+    commandRegistrationPositions.length > 0,
+    'Contract clause failed: client.js must define at least one .command(...) registration before launcher ordering checks'
+  );
+
+  assert.ok(
+    isDisabledCalls.some((pos) => pos < firstCommandRegistrationPos),
+    'Contract clause failed: isLocalDelegationDisabled() must be evaluated before command registration/runtime wiring'
+  );
+});
+
+test('client performs local candidate resolution and delegation decision', () => {
+  const findNearestCalls = getBoundImportedCallPositions(
+    launcherModulePath,
+    'findNearestLocalCliEntry'
+  );
+  const shouldDelegateCalls = getBoundImportedCallPositions(
+    launcherModulePath,
+    'shouldDelegateToLocalCli'
+  );
+
+  assert.ok(
+    findNearestCalls.length > 0,
+    'Contract clause failed: client.js must call imported findNearestLocalCliEntry() to resolve local CLI candidate in launcher path'
+  );
+
+  assert.ok(
+    shouldDelegateCalls.length > 0,
+    'Contract clause failed: client.js must call imported shouldDelegateToLocalCli() to gate delegation in launcher path'
+  );
+
+  assert.ok(
+    commandRegistrationPositions.length > 0,
+    'Contract clause failed: client.js must define at least one .command(...) registration before launcher ordering checks'
+  );
+
+  assert.ok(
+    findNearestCalls.some((pos) => pos < firstCommandRegistrationPos),
+    'Contract clause failed: findNearestLocalCliEntry() must execute before command registration/runtime wiring'
+  );
+
+  assert.ok(
+    shouldDelegateCalls.some((pos) => pos < firstCommandRegistrationPos),
+    'Contract clause failed: shouldDelegateToLocalCli() must execute before command registration/runtime wiring'
+  );
+});

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

@@ -0,0 +1,128 @@
+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');
+    });
+  });
+});
+
+describe('slice component delete via CLI (full command path)', () => {
+  test('deletes a component non-interactively without crashing', async () => {
+    // Regression: client.js used to call an undefined loadConfig() in this
+    // path (ReferenceError), which unit tests of deleteComponent never hit.
+    const { createTestProject, cleanupTestProject } = await import('./helpers/setup.js');
+    const { spawnSync } = await import('node:child_process');
+    const { fileURLToPath } = await import('node:url');
+    const dir = await createTestProject({ visualComponents: ['Button'] });
+    try {
+      const client = path.join(path.dirname(fileURLToPath(import.meta.url)), '..', 'client.js');
+      const result = spawnSync(process.execPath, [client, 'component', 'delete', 'Button', '--category', 'Visual', '--yes'], {
+        cwd: dir,
+        encoding: 'utf-8',
+        env: { ...process.env, INIT_CWD: dir, SLICE_NO_LOCAL_DELEGATION: '1' },
+        timeout: 60_000
+      });
+      const output = `${result.stdout}\n${result.stderr}`;
+      assert.equal(result.status, 0, `command must exit 0. Output:\n${output}`);
+      assert.ok(!output.includes('ReferenceError'), `must not crash:\n${output}`);
+      assert.ok(!(await fs.pathExists(path.join(dir, 'src', 'Components', 'Visual', 'Button'))), 'Button folder must be deleted');
+    } finally {
+      await cleanupTestProject(dir);
+    }
+  });
+});