slicejs-cli 2.9.5 → 3.0.2

package/tests/bundle-generator.test.js

@@ -1,5 +1,8 @@
 import { test } from 'node:test';
 import assert from 'node:assert/strict';
+import fs from 'fs-extra';
+import os from 'node:os';
+import path from 'node:path';
 import BundleGenerator from '../commands/utils/bundling/BundleGenerator.js';
 
 const createComponent = (name, deps = []) => ({
@@ -36,3 +39,168 @@ test('computeBundleIntegrity changes with component dependencies', () => {
   // Assert
   assert.notEqual(baseIntegrity, changedIntegrity);
 });
+
+test('generateBundleConfig outputs V2 manifest fields', () => {
+  const generator = new BundleGenerator(import.meta.url, {
+    components: [],
+    routes: [],
+    metrics: {
+      totalComponents: 0,
+      totalRoutes: 0,
+      sharedPercentage: 0,
+      totalSize: 0
+    }
+  });
+
+  const config = generator.generateBundleConfig(null);
+
+  assert.equal(config.format, 'v2');
+  assert.ok(config.generated);
+  assert.ok(config.bundles);
+  assert.ok(['enabled', 'disabled'].includes(config.loadingPolicy));
+});
+
+test('loading policy is enabled when sliceConfig loading.enabled is true', () => {
+  const generator = new BundleGenerator(import.meta.url, {
+    components: [],
+    routes: [],
+    metrics: {
+      totalComponents: 0,
+      totalRoutes: 0,
+      sharedPercentage: 0,
+      totalSize: 0
+    },
+    sliceConfig: { loading: { enabled: true } }
+  });
+
+  const config = generator.generateBundleConfig(null);
+  assert.equal(config.loadingPolicy, 'enabled');
+});
+
+test('loading policy falls back to project sliceConfig when analysisData lacks sliceConfig', async () => {
+  const tempRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'slice-bundle-test-'));
+  const srcDir = path.join(tempRoot, 'src');
+  const previousInitCwd = process.env.INIT_CWD;
+
+  await fs.ensureDir(srcDir);
+  await fs.writeJson(path.join(srcDir, 'sliceConfig.json'), {
+    loading: { enabled: true }
+  });
+
+  process.env.INIT_CWD = tempRoot;
+
+  try {
+    const generator = new BundleGenerator(import.meta.url, {
+      components: [],
+      routes: [],
+      metrics: {
+        totalComponents: 0,
+        totalRoutes: 0,
+        sharedPercentage: 0,
+        totalSize: 0
+      }
+    });
+
+    const config = generator.generateBundleConfig(null);
+    assert.equal(config.loadingPolicy, 'enabled');
+  } finally {
+    if (previousInitCwd === undefined) {
+      delete process.env.INIT_CWD;
+    } else {
+      process.env.INIT_CWD = previousInitCwd;
+    }
+    await fs.remove(tempRoot);
+  }
+});
+
+test('loading enabled always includes Loading component in critical bundle', () => {
+  const loading = {
+    ...createComponent('Loading'),
+    routes: new Set(),
+    size: 100000
+  };
+  const home = {
+    ...createComponent('HomePage'),
+    routes: new Set(['/'])
+  };
+
+  const generator = new BundleGenerator(import.meta.url, {
+    components: [loading, home],
+    routes: [{ path: '/', component: 'HomePage' }],
+    metrics: {
+      totalComponents: 2,
+      totalRoutes: 1,
+      sharedPercentage: 0,
+      totalSize: 100010
+    },
+    sliceConfig: { loading: { enabled: true } }
+  });
+
+  generator.identifyCriticalComponents();
+
+  assert.ok(generator.bundles.critical.components.some((component) => component.name === 'Loading'));
+  assert.equal(generator.generateBundleConfig().loadingPolicy, 'enabled');
+});
+
+test('shared-core is wired as dependency for affected route bundles', () => {
+  const generator = new BundleGenerator(import.meta.url, {
+    components: [],
+    routes: [],
+    metrics: {
+      totalComponents: 0,
+      totalRoutes: 0,
+      sharedPercentage: 0,
+      totalSize: 0
+    }
+  });
+
+  generator.config.minSharedUsage = 2;
+
+  generator.bundles.routes = {
+    alpha: {
+      path: '/alpha',
+      components: [createComponent('SharedWidget'), createComponent('AlphaOnly')],
+      size: 20,
+      file: 'slice-bundle.alpha.js'
+    },
+    beta: {
+      path: '/beta',
+      components: [createComponent('SharedWidget'), createComponent('BetaOnly')],
+      size: 20,
+      file: 'slice-bundle.beta.js'
+    }
+  };
+
+  generator.extractSharedComponents(new Set());
+  const config = generator.generateBundleConfig();
+
+  assert.ok(config.bundles.routes['shared-core']);
+  assert.deepEqual(config.bundles.routes.alpha.dependencies, ['critical', 'shared-core']);
+  assert.deepEqual(config.bundles.routes.beta.dependencies, ['critical', 'shared-core']);
+  assert.deepEqual(config.routeBundles['/alpha'], ['critical', 'shared-core', 'alpha']);
+  assert.deepEqual(config.routeBundles['/beta'], ['critical', 'shared-core', 'beta']);
+});
+
+test('rebalance merge preserves and merges route path metadata deterministically', () => {
+  const generator = new BundleGenerator(import.meta.url, {
+    components: [],
+    routes: [],
+    metrics: {
+      totalComponents: 0,
+      totalRoutes: 0,
+      sharedPercentage: 0,
+      totalSize: 0
+    }
+  });
+
+  const bundles = {
+    alpha: { path: '/alpha', components: [createComponent('Alpha')], size: 10, file: 'slice-bundle.alpha.js' },
+    beta: { paths: ['/beta', '/beta-alt'], components: [createComponent('Beta')], size: 10, file: 'slice-bundle.beta.js' },
+    gamma: { path: '/gamma', components: [createComponent('Gamma')], size: 10, file: 'slice-bundle.gamma.js' }
+  };
+
+  generator.rebalanceBundlesByBudget(bundles, { maxBundleSize: 99999, maxRequests: 2 });
+
+  assert.equal(Object.keys(bundles).length, 2);
+  assert.deepEqual(bundles.beta.paths, ['/beta', '/beta-alt', '/gamma']);
+});

package/tests/bundle-v2-register-output.test.js

@@ -0,0 +1,141 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import BundleGenerator from '../commands/utils/bundling/BundleGenerator.js';
+
+test('generated V2 bundle includes meta and registerAll exports', () => {
+  const generator = new BundleGenerator(import.meta.url, {
+    components: [],
+    routes: [],
+    metrics: {
+      totalComponents: 0,
+      totalRoutes: 0,
+      sharedPercentage: 0,
+      totalSize: 0
+    }
+  }, { output: 'src' });
+
+  const source = generator.generateBundleFileContent(
+    'slice-bundle.test.js',
+    'route',
+    [{ name: 'Button', category: 'Visual', categoryType: 'Visual', dependencies: new Set(), size: 100, js: '', html: '', css: '' }],
+    '/test'
+  );
+
+  assert.match(source, /export const SLICE_BUNDLE_META/);
+  assert.match(source, /export async function registerAll\(/);
+});
+
+test('generateBundleFileContent deduplicates components by name', () => {
+  const generator = new BundleGenerator(import.meta.url, {
+    components: [],
+    routes: [],
+    metrics: {
+      totalComponents: 0,
+      totalRoutes: 0,
+      sharedPercentage: 0,
+      totalSize: 0
+    }
+  }, { output: 'src' });
+
+  const source = generator.generateBundleFileContent(
+    'slice-bundle.test.js',
+    'route',
+    [
+      { name: 'Button', category: 'Visual', categoryType: 'Visual', dependencies: new Set(), size: 100, js: '', html: '', css: '' },
+      { name: 'Button', category: 'Visual', categoryType: 'Visual', dependencies: new Set(), size: 100, js: '', html: '', css: '' }
+    ],
+    '/test'
+  );
+
+  assert.equal((source.match(/const SLICE_CLASS_FACTORY_SliceComponent_Button/g) || []).length, 1);
+  assert.equal((source.match(/if \(!controller\.classes\.has\("Button"\)\) \{\s*controller\.classes\.set\("Button", SLICE_CLASS_FACTORY_SliceComponent_Button\(\)\);\s*\}/g) || []).length, 1);
+});
+
+test('registerAll guards class, template, style, and category writes', () => {
+  const generator = new BundleGenerator(import.meta.url, {
+    components: [],
+    routes: [],
+    metrics: {
+      totalComponents: 0,
+      totalRoutes: 0,
+      sharedPercentage: 0,
+      totalSize: 0
+    }
+  }, { output: 'src' });
+
+  const source = generator.generateBundleFileContent(
+    'slice-bundle.test.js',
+    'route',
+    [{ name: 'Button', category: 'Visual', categoryType: 'Visual', dependencies: new Set(), size: 100, js: '', html: '<button>ok</button>', css: '.btn{}' }],
+    '/test'
+  );
+
+  assert.match(source, /if \(!controller\.classes\.has\("Button"\)\) \{\s*controller\.classes\.set\("Button", SLICE_CLASS_FACTORY_SliceComponent_Button\(\)\);\s*\}/);
+  assert.match(source, /if \(!controller\.templates\.has\("Button"\)\) \{\s*controller\.templates\.set\("Button", __templateElement_SliceComponent_Button\);\s*\}/);
+  assert.match(source, /if \(!stylesManager\.__sliceRegisteredComponentStyles\) \{\s*stylesManager\.__sliceRegisteredComponentStyles = new Set\(\);\s*\}/);
+  assert.match(source, /if \(!stylesManager\.__sliceRegisteredComponentStyles\.has\("Button"\)\) \{\s*stylesManager\.registerComponentStyles\("Button", ".*"\);\s*stylesManager\.__sliceRegisteredComponentStyles\.add\("Button"\);\s*\}/);
+  assert.match(source, /if \(!controller\.componentCategories\.has\("Button"\)\) \{\s*controller\.componentCategories\.set\("Button", "Visual"\);\s*\}/);
+});
+
+test('registerAll stores templates as template elements', () => {
+  const generator = new BundleGenerator(import.meta.url, {
+    components: [],
+    routes: [],
+    metrics: {
+      totalComponents: 0,
+      totalRoutes: 0,
+      sharedPercentage: 0,
+      totalSize: 0
+    }
+  }, { output: 'src' });
+
+  const source = generator.generateBundleFileContent(
+    'slice-bundle.test.js',
+    'route',
+    [{ name: 'DocumentationPage', category: 'AppComponents', categoryType: 'Visual', dependencies: new Set(), size: 100, js: '', html: '<div>docs</div>', css: '' }],
+    '/docs'
+  );
+
+  assert.match(source, /const __templateElement_SliceComponent_DocumentationPage = document\.createElement\('template'\);/);
+  assert.match(source, /__templateElement_SliceComponent_DocumentationPage\.innerHTML = "<div>docs<\/div>";/);
+  assert.match(source, /controller\.templates\.set\("DocumentationPage", __templateElement_SliceComponent_DocumentationPage\);/);
+});
+
+test('bundle output inlines dependency modules and binds imported symbols in class factories', () => {
+  const generator = new BundleGenerator(import.meta.url, {
+    components: [],
+    routes: [],
+    metrics: {
+      totalComponents: 0,
+      totalRoutes: 0,
+      sharedPercentage: 0,
+      totalSize: 0
+    }
+  }, { output: 'src' });
+
+  const source = generator.generateBundleFileContent(
+    'slice-bundle.test.js',
+    'route',
+    [{
+      name: 'DocumentationPage',
+      category: 'AppComponents',
+      categoryType: 'Visual',
+      dependencies: new Set(),
+      size: 100,
+      js: 'class DocumentationPage extends HTMLElement { connectedCallback(){ return documentationRoutes.length; } }\nwindow.DocumentationPage = DocumentationPage;\nreturn DocumentationPage;',
+      html: '',
+      css: '',
+      externalDependencies: {
+        'App/documentationRoutes.js': {
+          content: 'export const documentationRoutes = ["/docs"];',
+          bindings: [{ type: 'named', importedName: 'documentationRoutes', localName: 'documentationRoutes' }]
+        }
+      }
+    }],
+    '/docs'
+  );
+
+  assert.match(source, /const SLICE_BUNDLE_DEPENDENCIES = \{\};/);
+  assert.match(source, /SLICE_BUNDLE_DEPENDENCIES\["App\/documentationRoutes\.js"\] = __sliceDepExports0;/);
+  assert.match(source, /const documentationRoutes = SLICE_BUNDLE_DEPENDENCIES\["App\/documentationRoutes\.js"\]\.documentationRoutes;/);
+});

package/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'
+  );
+});