slicejs-cli 3.1.0 → 3.3.0

package/tests/local-cli-delegation.test.js

@@ -1,79 +1,79 @@
-import { test } from 'node:test';
-import assert from 'node:assert/strict';
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import {
-  findNearestLocalCliEntry,
-  resolveLocalCliCandidate,
-  shouldDelegateToLocalCli,
-  isLocalDelegationDisabled
-} from '../commands/utils/LocalCliDelegation.js';
-
-test('isLocalDelegationDisabled returns true when env flag is set', () => {
-  const env = { SLICE_NO_LOCAL_DELEGATION: '1' };
-  assert.equal(isLocalDelegationDisabled(env), true);
-});
-
-test('isLocalDelegationDisabled returns false when env flag is missing', () => {
-  const env = {};
-  assert.equal(isLocalDelegationDisabled(env), false);
-});
-
-test('shouldDelegateToLocalCli is false when candidate is null', () => {
-  assert.equal(shouldDelegateToLocalCli('/tmp/current/client.js', null), false);
-});
-
-test('shouldDelegateToLocalCli is false when candidate realpath equals current realpath', () => {
-  const same = '/tmp/current/client.js';
-  assert.equal(shouldDelegateToLocalCli(same, same), false);
-});
-
-test('shouldDelegateToLocalCli is true when candidate differs from current', () => {
-  const current = '/tmp/global/client.js';
-  const local = '/tmp/project/node_modules/slicejs-cli/client.js';
-  assert.equal(shouldDelegateToLocalCli(current, local), true);
-});
-
-test('findNearestLocalCliEntry returns null when no candidate resolver hits', () => {
-  const cwd = path.join('/tmp', 'slice-nonexistent-project');
-  const resolver = () => null;
-  const result = findNearestLocalCliEntry(cwd, resolver);
-  assert.equal(result, null);
-});
-
-test('findNearestLocalCliEntry returns first match while traversing upward', () => {
-  const cwd = '/repo/apps/web/src';
-  const calls = [];
-  const resolver = (dir) => {
-    calls.push(dir);
-    if (dir === '/repo/apps/web') {
-      return '/repo/apps/web/node_modules/slicejs-cli/client.js';
-    }
-    return null;
-  };
-
-  const result = findNearestLocalCliEntry(cwd, resolver);
-
-  assert.equal(result, '/repo/apps/web/node_modules/slicejs-cli/client.js');
-  assert.deepEqual(calls, ['/repo/apps/web/src', '/repo/apps/web']);
-});
-
-test('findNearestLocalCliEntry returns null when resolver is not a function', () => {
-  const result = findNearestLocalCliEntry('/repo/apps/web/src', null);
-  assert.equal(result, null);
-});
-
-test('resolveLocalCliCandidate returns null when candidate path is a directory', () => {
-  const tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'slice-cli-delegation-'));
-  const candidateDirectory = path.join(tempRoot, 'node_modules', 'slicejs-cli', 'client.js');
-
-  fs.mkdirSync(candidateDirectory, { recursive: true });
-
-  try {
-    const result = resolveLocalCliCandidate(tempRoot);
-    assert.equal(result, null);
-  } finally {
-    fs.rmSync(tempRoot, { recursive: true, force: true });
-  }
-});
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import {
+  findNearestLocalCliEntry,
+  resolveLocalCliCandidate,
+  shouldDelegateToLocalCli,
+  isLocalDelegationDisabled
+} from '../commands/utils/LocalCliDelegation.js';
+
+test('isLocalDelegationDisabled returns true when env flag is set', () => {
+  const env = { SLICE_NO_LOCAL_DELEGATION: '1' };
+  assert.equal(isLocalDelegationDisabled(env), true);
+});
+
+test('isLocalDelegationDisabled returns false when env flag is missing', () => {
+  const env = {};
+  assert.equal(isLocalDelegationDisabled(env), false);
+});
+
+test('shouldDelegateToLocalCli is false when candidate is null', () => {
+  assert.equal(shouldDelegateToLocalCli('/tmp/current/client.js', null), false);
+});
+
+test('shouldDelegateToLocalCli is false when candidate realpath equals current realpath', () => {
+  const same = '/tmp/current/client.js';
+  assert.equal(shouldDelegateToLocalCli(same, same), false);
+});
+
+test('shouldDelegateToLocalCli is true when candidate differs from current', () => {
+  const current = '/tmp/global/client.js';
+  const local = '/tmp/project/node_modules/slicejs-cli/client.js';
+  assert.equal(shouldDelegateToLocalCli(current, local), true);
+});
+
+test('findNearestLocalCliEntry returns null when no candidate resolver hits', () => {
+  const cwd = path.join('/tmp', 'slice-nonexistent-project');
+  const resolver = () => null;
+  const result = findNearestLocalCliEntry(cwd, resolver);
+  assert.equal(result, null);
+});
+
+test('findNearestLocalCliEntry returns first match while traversing upward', () => {
+  const cwd = '/repo/apps/web/src';
+  const calls = [];
+  const resolver = (dir) => {
+    calls.push(dir);
+    if (dir === '/repo/apps/web') {
+      return '/repo/apps/web/node_modules/slicejs-cli/client.js';
+    }
+    return null;
+  };
+
+  const result = findNearestLocalCliEntry(cwd, resolver);
+
+  assert.equal(result, '/repo/apps/web/node_modules/slicejs-cli/client.js');
+  assert.deepEqual(calls, ['/repo/apps/web/src', '/repo/apps/web']);
+});
+
+test('findNearestLocalCliEntry returns null when resolver is not a function', () => {
+  const result = findNearestLocalCliEntry('/repo/apps/web/src', null);
+  assert.equal(result, null);
+});
+
+test('resolveLocalCliCandidate returns null when candidate path is a directory', () => {
+  const tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'slice-cli-delegation-'));
+  const candidateDirectory = path.join(tempRoot, 'node_modules', 'slicejs-cli', 'client.js');
+
+  fs.mkdirSync(candidateDirectory, { recursive: true });
+
+  try {
+    const result = resolveLocalCliCandidate(tempRoot);
+    assert.equal(result, null);
+  } finally {
+    fs.rmSync(tempRoot, { recursive: true, force: true });
+  }
+});

package/tests/postinstall-command.test.js

@@ -0,0 +1,72 @@
+import { test, describe } from 'node:test';
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const clientPath = path.join(__dirname, '..', 'client.js');
+const source = fs.readFileSync(clientPath, 'utf-8');
+
+test('postinstall command is registered in client.js', () => {
+  const hasSetupCommand = source.includes('.command("postinstall")');
+  assert.ok(hasSetupCommand, 'client.js must register a "postinstall" command');
+});
+
+test('postinstall command has a description', () => {
+  const match = source.match(/\.command\(["']postinstall["']\)\s*\.description\(["']([^"']+)["']\)/);
+  assert.ok(match, 'postinstall command must have a .description() call');
+  assert.ok(match[1].length > 0, 'postinstall command description must not be empty');
+});
+
+test('postinstall command checks npm_config_global environment variable', () => {
+  const hasGlobalCheck = source.includes('npm_config_global');
+  assert.ok(hasGlobalCheck, 'postinstall command must check npm_config_global to detect global installation');
+});
+
+test('postinstall command prints global install warning', () => {
+  const hasGlobalWarning = source.includes('Global installation');
+  assert.ok(hasGlobalWarning, 'postinstall command must warn about global installation');
+});
+
+test('postinstall command prints local install success message', () => {
+  const hasSuccessMsg = source.includes('installed successfully');
+  assert.ok(hasSuccessMsg, 'postinstall command must show success message for local installs');
+});
+
+test('postinstall command uses getProjectRoot from PathHelper', () => {
+  const hasPathHelper = source.includes("getProjectRoot(import.meta.url)");
+  assert.ok(hasPathHelper, 'postinstall command must use getProjectRoot resolver');
+});
+
+test('postinstall command writes npm scripts to package.json via fs', () => {
+  const hasFsWrite = source.includes('writeFileSync(pkgPath');
+  assert.ok(hasFsWrite, 'postinstall command must write scripts to package.json');
+});
+
+test('postinstall command writes slice:dev script to package.json', () => {
+  const hasDevScript = source.includes("'slice:dev': 'slice dev'");
+  assert.ok(hasDevScript, 'postinstall command must add "slice:dev" script to package.json');
+});
+
+test('postinstall command writes all slice:* scripts to package.json', () => {
+  const scripts = [
+    'slice:dev', 'slice:start', 'slice:create', 'slice:list',
+    'slice:delete', 'slice:init', 'slice:get', 'slice:browse',
+    'slice:sync', 'slice:version', 'slice:update'
+  ];
+  for (const script of scripts) {
+    assert.ok(source.includes(script), `postinstall command must configure ${script} script`);
+  }
+});
+
+test('postinstall command action is a function', () => {
+  const SetupActionPattern = /\.command\(["']postinstall["']\)[\s\S]*?\.action\(\(\)\s*=>\s*\{[\s\S]*?\}\)/;
+  const match = source.match(SetupActionPattern);
+  assert.ok(match, 'postinstall command must have an .action() with arrow function');
+});
+
+test('postinstall command provides npm uninstall -g instruction for global installs', () => {
+  const hasUninstallInstruction = source.includes('npm uninstall -g slicejs-cli');
+  assert.ok(hasUninstallInstruction, 'postinstall command must tell users how to uninstall global CLI');
+});

package/tests/types-generator.test.js

@@ -0,0 +1,356 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+
+import {
+  ensureEditorConfigForTypes,
+  ensureNoCheckInPublicVendorFiles,
+  extractStaticPropsFromSource,
+  generateDeclarationContent,
+  generateTypesFile
+} from '../commands/types/types.js';
+
+test('extractStaticPropsFromSource reads static props definitions', () => {
+  const source = `
+    export default class Button extends HTMLElement {
+      static props = {
+        value: { type: 'string', default: 'Button', allowedValues: ['Button', 'Submit'] },
+        disabled: { type: 'boolean', default: false },
+        size: { type: 'number', allowedValues: [12, 16, 20] },
+        options: {
+          type: 'object',
+          schema: {
+            theme: {
+              type: 'object',
+              schema: {
+                mode: { type: 'string', allowedValues: ['light', 'dark'] }
+              }
+            }
+          }
+        },
+        steps: {
+          type: 'array',
+          items: {
+            type: 'object',
+            schema: {
+              id: { type: 'string', required: true },
+              enabled: { type: 'boolean', default: true }
+            }
+          }
+        },
+        onClickCallback: { type: 'function', required: true }
+      };
+    }
+  `;
+
+  const result = extractStaticPropsFromSource(source);
+
+  assert.deepEqual(result, {
+    value: { type: 'string', required: false, allowedValues: ['Button', 'Submit'] },
+    disabled: { type: 'boolean', required: false },
+    size: { type: 'number', required: false, allowedValues: [12, 16, 20] },
+    options: {
+      type: 'object',
+      required: false,
+      schema: {
+        theme: {
+          type: 'object',
+          required: false,
+          schema: {
+            mode: {
+              type: 'string',
+              required: false,
+              allowedValues: ['light', 'dark']
+            }
+          }
+        }
+      }
+    },
+    steps: {
+      type: 'array',
+      required: false,
+      items: {
+        type: 'object',
+        required: false,
+        schema: {
+          id: { type: 'string', required: true },
+          enabled: { type: 'boolean', required: false }
+        }
+      }
+    },
+    onClickCallback: { type: 'function', required: true }
+  });
+});
+
+test('generateDeclarationContent creates build typing map', () => {
+  const content = generateDeclarationContent({
+    Button: {
+      value: { type: 'string', required: false, allowedValues: ['primary', 'secondary', 'danger'] },
+      size: { type: 'number', required: false, allowedValues: [12, 16] },
+      disabled: { type: 'boolean', required: false },
+      status: { type: 'string', required: false, allowedValues: ['ok', 1] },
+      options: {
+        type: 'object',
+        required: false,
+        schema: {
+          mode: { type: 'string', required: false, allowedValues: ['light', 'dark'] }
+        }
+      },
+      steps: {
+        type: 'array',
+        required: false,
+        items: {
+          type: 'object',
+          required: false,
+          schema: {
+            id: { type: 'string', required: true }
+          }
+        }
+      }
+    },
+    FetchManager: {
+      baseUrl: { type: 'string', required: true }
+    }
+  });
+
+  assert.match(content, /export interface ButtonProps/);
+  assert.match(content, /\[key: string\]: unknown;/);
+  assert.match(content, /value\?: 'primary' \| 'secondary' \| 'danger';/);
+  assert.match(content, /size\?: 12 \| 16;/);
+  assert.match(content, /disabled\?: boolean;/);
+  assert.match(content, /status\?: string;/);
+  assert.match(content, /export interface FetchManagerProps/);
+  assert.match(content, /baseUrl: string;/);
+  assert.match(content, /export interface SliceComponentPropsMap/);
+  assert.match(content, /Button: ButtonProps;/);
+  assert.match(content, /FetchManager: FetchManagerProps;/);
+  assert.match(content, /options\?: \{/);
+  assert.match(content, /mode\?: 'light' \| 'dark';/);
+  assert.match(content, /steps\?: \{/);
+  assert.match(content, /id: string;/);
+  assert.match(content, /}\[\];/);
+  assert.match(content, /declare module 'slicejs-web-framework'/);
+  assert.match(content, /interface SliceApi \{/);
+  assert.match(content, /export type SliceDynamicElement = HTMLElement & Record<string, any>;/);
+  assert.match(content, /build<K extends SliceComponentName>/);
+  assert.match(content, /getComponent<T extends SliceDynamicElement = SliceDynamicElement>\(/);
+  assert.match(content, /componentSliceId: string/);
+  assert.match(content, /\): T \| undefined;/);
+  assert.match(content, /interface Element \{/);
+  assert.match(content, /querySelector<E extends Element = HTMLElement>\(selectors: string\): E \| null;/);
+  assert.match(content, /querySelectorAll<E extends Element = HTMLElement>\(selectors: string\): NodeListOf<E>;/);
+  assert.match(content, /interface HTMLElement \{/);
+  assert.match(content, /\[key: string\]: any;/);
+  assert.match(content, /const slice: SliceBuildApi & Record<string, any>;/);
+  assert.match(content, /interface EventTarget \{/);
+  assert.match(content, /interface Event \{/);
+  assert.match(content, /detail: any;/);
+  assert.match(content, /currentTarget: any;/);
+});
+
+test('generateTypesFile creates declaration file from local components', async () => {
+  const tmpRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'slice-types-'));
+  const srcDir = path.join(tmpRoot, 'src');
+  const visualDir = path.join(srcDir, 'Components', 'Visual', 'Button');
+  const noStaticDir = path.join(srcDir, 'Components', 'Visual', 'Tabs');
+  const serviceDir = path.join(srcDir, 'Components', 'Service', 'FetchManager');
+  const outputFile = path.join(srcDir, 'slice-build.generated.d.ts');
+
+  fs.mkdirSync(visualDir, { recursive: true });
+  fs.mkdirSync(noStaticDir, { recursive: true });
+  fs.mkdirSync(serviceDir, { recursive: true });
+
+  fs.writeFileSync(
+    path.join(srcDir, 'sliceConfig.json'),
+    JSON.stringify(
+      {
+        paths: {
+          components: {
+            Visual: { path: '/Components/Visual', type: 'Visual' },
+            Service: { path: '/Components/Service', type: 'Service' }
+          }
+        }
+      },
+      null,
+      2
+    ),
+    'utf8'
+  );
+
+  fs.writeFileSync(
+    path.join(srcDir, 'Components', 'components.js'),
+    `const components = {"Button": "Visual", "Tabs": "Visual", "FetchManager": "Service"};\n\nexport default components;\n`,
+    'utf8'
+  );
+
+  fs.writeFileSync(
+    path.join(visualDir, 'Button.js'),
+    `
+    export default class Button extends HTMLElement {
+      static props = {
+        value: { type: 'string', default: 'Button', allowedValues: ['Button', 'Submit'] },
+        size: { type: 'number', allowedValues: [12, 16] },
+        disabled: { type: 'boolean', default: false }
+      };
+    }
+    `,
+    'utf8'
+  );
+
+  fs.writeFileSync(
+    path.join(noStaticDir, 'Tabs.js'),
+    `
+    export default class Tabs extends HTMLElement {
+      constructor() {
+        super();
+      }
+    }
+    `,
+    'utf8'
+  );
+
+  fs.writeFileSync(
+    path.join(serviceDir, 'FetchManager.js'),
+    `
+    export default class FetchManager extends HTMLElement {
+      static props = {
+        baseUrl: { type: 'string', required: true }
+      };
+    }
+    `,
+    'utf8'
+  );
+
+  const result = await generateTypesFile({
+    projectRoot: tmpRoot,
+    outputPath: outputFile
+  });
+
+  assert.equal(result.componentsProcessed, 3);
+  assert.equal(fs.existsSync(result.outputPath), true);
+
+  const declaration = fs.readFileSync(result.outputPath, 'utf8');
+  assert.match(declaration, /export interface ButtonProps/);
+  assert.match(declaration, /value\?: 'Button' \| 'Submit';/);
+  assert.match(declaration, /size\?: 12 \| 16;/);
+  assert.match(declaration, /export interface TabsProps/);
+  assert.match(declaration, /\[key: string\]: unknown;/);
+  assert.match(declaration, /export interface FetchManagerProps/);
+  assert.match(declaration, /Tabs: TabsProps;/);
+  assert.match(declaration, /build<K extends SliceComponentName>/);
+});
+
+test('ensureEditorConfigForTypes creates jsconfig when missing', async () => {
+  const tmpRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'slice-types-jsconfig-create-'));
+  const outputFile = path.join(tmpRoot, 'src', 'slice-build.generated.d.ts');
+
+  fs.mkdirSync(path.dirname(outputFile), { recursive: true });
+  fs.writeFileSync(outputFile, 'export {};\n', 'utf8');
+
+  const result = await ensureEditorConfigForTypes({
+    projectRoot: tmpRoot,
+    outputPath: outputFile
+  });
+
+  assert.equal(result.mode, 'created_jsconfig');
+
+  const jsconfigPath = path.join(tmpRoot, 'jsconfig.json');
+  assert.equal(fs.existsSync(jsconfigPath), true);
+
+  const jsconfig = JSON.parse(fs.readFileSync(jsconfigPath, 'utf8'));
+  assert.equal(Array.isArray(jsconfig.include), true);
+  assert.equal(jsconfig.include.includes('src/Components/**/*.js'), true);
+  assert.equal(jsconfig.include.includes('src/**/*.d.ts'), true);
+  assert.equal(jsconfig.include.includes('api/**/*.js'), false);
+  assert.equal(jsconfig.include.includes('tests/**/*.js'), false);
+  assert.equal(jsconfig.include.includes('src/**/*.js'), false);
+  assert.equal(jsconfig.compilerOptions.checkJs, true);
+  assert.equal(jsconfig.compilerOptions.strictNullChecks, false);
+  assert.equal(jsconfig.compilerOptions.noImplicitAny, false);
+  assert.equal(jsconfig.compilerOptions.strict, false);
+  assert.equal(Array.isArray(jsconfig.exclude), true);
+  assert.equal(jsconfig.exclude.includes('src/libs/**'), true);
+  assert.equal(jsconfig.exclude.includes('tests/**'), true);
+});
+
+test('ensureNoCheckInPublicVendorFiles adds ts-nocheck to js files in publicFolders', async () => {
+  const tmpRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'slice-types-publicfolders-'));
+  const srcDir = path.join(tmpRoot, 'src');
+  const libsDir = path.join(srcDir, 'libs', 'vendor');
+  const assetsDir = path.join(srcDir, 'assets', 'scripts');
+
+  fs.mkdirSync(libsDir, { recursive: true });
+  fs.mkdirSync(assetsDir, { recursive: true });
+
+  fs.writeFileSync(
+    path.join(srcDir, 'sliceConfig.json'),
+    JSON.stringify(
+      {
+        publicFolders: ['/libs', '/assets'],
+        paths: { components: {} }
+      },
+      null,
+      2
+    ),
+    'utf8'
+  );
+
+  const vendorA = path.join(libsDir, 'a.js');
+  const vendorB = path.join(assetsDir, 'b.js');
+  fs.writeFileSync(vendorA, 'const a = 1;\n', 'utf8');
+  fs.writeFileSync(vendorB, '// @ts-nocheck\nconst b = 2;\n', 'utf8');
+
+  const result = await ensureNoCheckInPublicVendorFiles(tmpRoot);
+
+  assert.equal(result.scannedFiles, 2);
+  assert.equal(result.updatedFiles, 1);
+  assert.equal(fs.readFileSync(vendorA, 'utf8').startsWith('// @ts-nocheck\n'), true);
+  assert.equal(fs.readFileSync(vendorB, 'utf8').startsWith('// @ts-nocheck\n'), true);
+});
+
+test('ensureEditorConfigForTypes augments existing jsconfig include list', async () => {
+  const tmpRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'slice-types-jsconfig-update-'));
+  const outputFile = path.join(tmpRoot, 'src', 'slice-build.generated.d.ts');
+  const jsconfigPath = path.join(tmpRoot, 'jsconfig.json');
+
+  fs.mkdirSync(path.dirname(outputFile), { recursive: true });
+  fs.writeFileSync(outputFile, 'export {};\n', 'utf8');
+  fs.writeFileSync(
+    jsconfigPath,
+    JSON.stringify(
+      {
+        compilerOptions: {
+          allowJs: true
+        },
+        include: ['src/Components/**/*.js', 'src/**/*.js', 'api/**/*.js', 'tests/**/*.js']
+      },
+      null,
+      2
+    ),
+    'utf8'
+  );
+
+  const result = await ensureEditorConfigForTypes({
+    projectRoot: tmpRoot,
+    outputPath: outputFile
+  });
+
+  assert.equal(result.mode, 'updated_jsconfig');
+
+  const jsconfig = JSON.parse(fs.readFileSync(jsconfigPath, 'utf8'));
+  assert.equal(jsconfig.include.includes('src/Components/**/*.js'), true);
+  assert.equal(jsconfig.include.includes('src/**/*.d.ts'), true);
+  assert.equal(jsconfig.include.includes('src/**/*.js'), false);
+  assert.equal(jsconfig.include.includes('api/**/*.js'), false);
+  assert.equal(jsconfig.include.includes('tests/**/*.js'), false);
+  assert.equal(jsconfig.compilerOptions.allowJs, true);
+  assert.equal(jsconfig.compilerOptions.checkJs, true);
+  assert.equal(jsconfig.compilerOptions.noImplicitAny, false);
+  assert.equal(jsconfig.compilerOptions.strictNullChecks, false);
+  assert.equal(jsconfig.compilerOptions.strict, false);
+  assert.equal(Array.isArray(jsconfig.exclude), true);
+  assert.equal(jsconfig.exclude.includes('src/libs/**'), true);
+  assert.equal(jsconfig.exclude.includes('tests/**'), true);
+});