@sociallane/elements 1.0.12 → 1.0.14

package/scripts/publish-widget-packages.js

@@ -9,6 +9,7 @@ import { readdirSync, existsSync } from 'fs';
 import path from 'path';
 import { fileURLToPath } from 'url';
 import { spawnSync } from 'child_process';
+import { readWidgetManifest } from './lib/widgets-manifest.js';
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const pluginRoot = path.resolve(__dirname, '..');
@@ -19,10 +20,27 @@ if (!existsSync(npmWidgetsDir)) {
   process.exit(1);
 }
 
-const dirs = readdirSync(npmWidgetsDir, { withFileTypes: true })
+const manifest = readWidgetManifest(pluginRoot);
+if (!manifest || !Array.isArray(manifest.widgets) || manifest.widgets.length === 0) {
+  console.error('Widget manifest not found or empty. Run npm run sync-widgets first.');
+  process.exit(1);
+}
+
+const manifestSlugs = manifest.widgets.map((widget) => widget.slug).sort((a, b) => a.localeCompare(b));
+const availableDirs = readdirSync(npmWidgetsDir, { withFileTypes: true })
   .filter((d) => d.isDirectory())
-  .map((d) => d.name)
-  .sort((a, b) => a.localeCompare(b));
+  .map((d) => d.name);
+const dirs = manifestSlugs.filter((slug) => availableDirs.includes(slug));
+
+const missingBuiltPackages = manifestSlugs.filter((slug) => !availableDirs.includes(slug));
+if (missingBuiltPackages.length > 0) {
+  console.error(
+    'Missing built widget packages in packages/npm-widgets/:',
+    missingBuiltPackages.slice(0, 20).join(', ') + (missingBuiltPackages.length > 20 ? '...' : '')
+  );
+  console.error('Run npm run build:widget-packages first.');
+  process.exit(1);
+}
 
 if (dirs.length === 0) {
   console.error('No widget packages in packages/npm-widgets/');

package/scripts/release-gate.js

@@ -0,0 +1,200 @@
+#!/usr/bin/env node
+/**
+ * Release gate checks:
+ * - canonical widget manifest exists and matches widget folders
+ * - CLI sample slugs in install.js exist in manifest
+ * - npm registry versions match root package version (strict mode)
+ *
+ * Usage:
+ *   node scripts/release-gate.js --strict
+ *   node scripts/release-gate.js --strict --skip-registry
+ */
+
+import { existsSync, readFileSync } from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { spawnSync } from 'child_process';
+import { getWidgetSlugsFromSource, readWidgetManifest, syncWidgetManifest } from './lib/widgets-manifest.js';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const pluginRoot = path.resolve(__dirname, '..');
+const args = process.argv.slice(2);
+const strict = args.includes('--strict');
+const skipRegistry = args.includes('--skip-registry');
+
+function runNpmViewVersion(pkgName) {
+  const npmCmd = process.platform === 'win32' ? 'npm.cmd' : 'npm';
+  const result = spawnSync(
+    npmCmd,
+    ['view', pkgName, 'version', '--registry=https://registry.npmjs.org', '--loglevel=error'],
+    {
+      cwd: pluginRoot,
+      encoding: 'utf8',
+      shell: true,
+    }
+  );
+
+  if (result.status !== 0) {
+    const stderr = (result.stderr || '')
+      .split('\n')
+      .map((line) => line.trim())
+      .find((line) => line !== '');
+    return { ok: false, version: null, error: stderr || 'npm view failed' };
+  }
+
+  const version = (result.stdout || '').trim().split('\n').pop().trim();
+  if (!version) {
+    return { ok: false, version: null, error: 'empty version response' };
+  }
+
+  return { ok: true, version, error: null };
+}
+
+function getRootVersion() {
+  const packageJsonPath = path.join(pluginRoot, 'package.json');
+  const pkg = JSON.parse(readFileSync(packageJsonPath, 'utf8'));
+  return typeof pkg.version === 'string' ? pkg.version : '';
+}
+
+function checkCliExampleSlugs(manifestSlugs, issues) {
+  const installScriptPath = path.join(pluginRoot, 'scripts', 'install.js');
+  if (!existsSync(installScriptPath)) {
+    issues.push('scripts/install.js not found for CLI example validation.');
+    return;
+  }
+
+  const content = readFileSync(installScriptPath, 'utf8');
+  const expectedSampleSlugs = ['faq-stacked', 'hero-split', 'content-block'];
+
+  for (const slug of expectedSampleSlugs) {
+    if (!manifestSlugs.includes(slug)) {
+      issues.push(`CLI sample slug "${slug}" is not present in canonical widget manifest.`);
+    }
+  }
+
+  if (!content.includes('npx @sociallane/elements add')) {
+    issues.push('CLI help examples do not include add command examples.');
+  }
+}
+
+function checkDocumentationExamples(manifestSlugs, manifestPackages, issues) {
+  const docsFiles = [
+    path.join(pluginRoot, 'docs', 'install-new-instance.md'),
+    path.join(pluginRoot, 'docs', 'package-installation.md'),
+    path.join(pluginRoot, 'docs', 'npm-widget-cheatsheet.md'),
+  ];
+
+  for (const docsFile of docsFiles) {
+    if (!existsSync(docsFile)) {
+      continue;
+    }
+
+    const content = readFileSync(docsFile, 'utf8');
+
+    // Validate widget package references in docs.
+    const packageMatches = content.match(/@sociallane\/widget-[a-z0-9-]+/g) || [];
+    for (const pkg of packageMatches) {
+      if (!manifestPackages.has(pkg)) {
+        issues.push(`Docs reference unknown widget package "${pkg}" (${path.basename(docsFile)}).`);
+      }
+    }
+
+    // Validate npx add slug examples in docs.
+    const addCommandMatches =
+      content.match(/npx\s+@sociallane\/elements\s+add(?:\s+--[a-z-]+(?:\s+[^\s`]+)?)*\s+[a-z0-9-][^\n`]*/g) || [];
+    for (const cmd of addCommandMatches) {
+      const parts = cmd.split(/\s+/).slice(3); // strip: npx @sociallane/elements add
+      const slugs = parts.filter((part, idx) => {
+        if (!part || part.startsWith('--')) return false;
+        // Skip values for --target
+        const prev = parts[idx - 1];
+        if (prev === '--target') return false;
+        return /^[a-z0-9-]+$/.test(part);
+      });
+
+      for (const slug of slugs) {
+        if (/^slug\d*$/i.test(slug)) {
+          continue; // placeholder tokens in docs examples
+        }
+        if (!manifestSlugs.has(slug)) {
+          issues.push(`Docs add command references unknown slug "${slug}" (${path.basename(docsFile)}).`);
+        }
+      }
+    }
+  }
+}
+
+function main() {
+  const issues = [];
+
+  // Keep manifest current as part of the gate.
+  syncWidgetManifest(pluginRoot);
+  const manifest = readWidgetManifest(pluginRoot);
+  if (!manifest || !Array.isArray(manifest.widgets) || manifest.widgets.length === 0) {
+    issues.push('Widget manifest is missing or empty. Run npm run manifest:widgets.');
+  }
+
+  const manifestSlugs = manifest ? manifest.widgets.map((widget) => widget.slug) : [];
+  const manifestSlugSet = new Set(manifestSlugs);
+  const manifestPackageSet = new Set((manifest?.widgets ?? []).map((widget) => widget.package));
+  const sourceSlugs = getWidgetSlugsFromSource(pluginRoot);
+
+  if (manifestSlugs.length !== sourceSlugs.length) {
+    issues.push(
+      `Manifest/source widget count mismatch (manifest=${manifestSlugs.length}, source=${sourceSlugs.length}).`
+    );
+  }
+
+  const missingInManifest = sourceSlugs.filter((slug) => !manifestSlugs.includes(slug));
+  if (missingInManifest.length > 0) {
+    issues.push(`Widget slugs missing in manifest: ${missingInManifest.slice(0, 20).join(', ')}`);
+  }
+
+  const missingInSource = manifestSlugs.filter((slug) => !sourceSlugs.includes(slug));
+  if (missingInSource.length > 0) {
+    issues.push(`Manifest contains missing widget folders: ${missingInSource.slice(0, 20).join(', ')}`);
+  }
+
+  checkCliExampleSlugs(manifestSlugs, issues);
+  checkDocumentationExamples(manifestSlugSet, manifestPackageSet, issues);
+
+  const rootVersion = getRootVersion();
+  if (!rootVersion) {
+    issues.push('Could not determine root package version from package.json.');
+  }
+
+  if (strict && !skipRegistry) {
+    console.log(`Checking npm registry versions against @sociallane/elements@${rootVersion}...`);
+
+    const rootPkg = '@sociallane/elements';
+    const rootVersionCheck = runNpmViewVersion(rootPkg);
+    if (!rootVersionCheck.ok) {
+      issues.push(`${rootPkg}: ${rootVersionCheck.error}`);
+    } else if (rootVersionCheck.version !== rootVersion) {
+      issues.push(`${rootPkg} version mismatch (registry=${rootVersionCheck.version}, local=${rootVersion}).`);
+    }
+
+    for (const widget of manifest?.widgets ?? []) {
+      const view = runNpmViewVersion(widget.package);
+      if (!view.ok) {
+        issues.push(`${widget.package}: ${view.error}`);
+        continue;
+      }
+      if (view.version !== rootVersion) {
+        issues.push(`${widget.package} version mismatch (registry=${view.version}, expected=${rootVersion}).`);
+      }
+    }
+  }
+
+  if (issues.length > 0) {
+    console.error('Release gate failed:');
+    for (const issue of issues) {
+      console.error(`- ${issue}`);
+    }
+    process.exit(1);
+  }
+
+  console.log(`Release gate passed (${manifestSlugs.length} widgets validated).`);
+}
+
+main();

package/scripts/sync-widgets.js

@@ -10,28 +10,15 @@
 import fs from 'fs';
 import path from 'path';
 import { fileURLToPath } from 'url';
+import { getWidgetSlugsFromSource, syncWidgetManifest } from './lib/widgets-manifest.js';
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 
 const PLUGIN_ROOT = path.resolve(__dirname, '..');
-const WIDGETS_DIR = path.join(PLUGIN_ROOT, 'packages', 'widgets');
 const WIDGETS_JSON = path.join(PLUGIN_ROOT, 'widgets.json');
 
 function getSlugsOnDisk() {
-	if (!fs.existsSync(WIDGETS_DIR)) {
-		return [];
-	}
-	const entries = fs.readdirSync(WIDGETS_DIR, { withFileTypes: true });
-	const slugs = [];
-	for (const ent of entries) {
-		if (!ent.isDirectory()) continue;
-		const slug = ent.name;
-		const phpFile = path.join(WIDGETS_DIR, slug, `${slug}.php`);
-		if (fs.existsSync(phpFile)) {
-			slugs.push(slug);
-		}
-	}
-	return slugs.sort((a, b) => a.localeCompare(b));
+	return getWidgetSlugsFromSource(PLUGIN_ROOT);
 }
 
 function getExistingSlugs() {
@@ -64,6 +51,11 @@ function main() {
 	if (added > 0 || removed > 0) {
 		console.log(`widgets.json updated: ${added} added, ${removed} removed. Total: ${widgets.length}`);
 	}
+
+	const manifest = syncWidgetManifest(PLUGIN_ROOT);
+	if (added > 0 || removed > 0) {
+		console.log(`widget manifest synced: ${manifest.widgets.length} widgets.`);
+	}
 }
 
 main();

package/scripts/test-cli-smoke.js

@@ -0,0 +1,141 @@
+#!/usr/bin/env node
+/**
+ * CLI smoke tests for scripts/install.js.
+ * Uses a fake npm binary so tests run quickly and offline.
+ */
+
+import assert from 'assert/strict';
+import { chmodSync, existsSync, mkdtempSync, mkdirSync, readFileSync, readdirSync, rmSync, writeFileSync } from 'fs';
+import os from 'os';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { spawnSync } from 'child_process';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const pluginRoot = path.resolve(__dirname, '..');
+const cliPath = path.join(pluginRoot, 'scripts', 'install.js');
+
+function fail(message, extra = '') {
+  const details = extra ? `\n${extra}` : '';
+  throw new Error(`${message}${details}`);
+}
+
+function runCli(args, options = {}) {
+  const result = spawnSync(process.execPath, [cliPath, ...args], {
+    cwd: options.cwd || pluginRoot,
+    env: options.env || process.env,
+    encoding: 'utf8',
+  });
+  return result;
+}
+
+function createFakeNpmBin(rootDir) {
+  const binDir = path.join(rootDir, 'fake-bin');
+  mkdirSync(binDir, { recursive: true });
+
+  const npmPath = path.join(binDir, 'npm');
+  writeFileSync(
+    npmPath,
+    [
+      '#!/usr/bin/env sh',
+      'echo "fake npm $@" >> "$FAKE_NPM_LOG"',
+      'exit 0',
+      '',
+    ].join('\n'),
+    'utf8'
+  );
+  chmodSync(npmPath, 0o755);
+
+  return binDir;
+}
+
+function main() {
+  const tempRoot = mkdtempSync(path.join(os.tmpdir(), 'sociallane-cli-smoke-'));
+
+  try {
+    const fakeLog = path.join(tempRoot, 'fake-npm.log');
+    const fakeBin = createFakeNpmBin(tempRoot);
+    const env = {
+      ...process.env,
+      PATH: `${fakeBin}${path.delimiter}${process.env.PATH || ''}`,
+      FAKE_NPM_LOG: fakeLog,
+      SOCIALLANE_SKIP_SYNC_WIDGETS: '1',
+    };
+
+    // 1) help exits successfully
+    const help = runCli(['--help'], { env });
+    assert.equal(help.status, 0, `--help failed: ${help.stderr}`);
+    assert.match(help.stdout, /SocialLane Elements CLI/, '--help output missing CLI header');
+
+    // 2) unknown flag fails
+    const bad = runCli(['--not-a-real-flag'], { env });
+    assert.notEqual(bad.status, 0, 'Unknown flag should fail');
+
+    // 3) base install creates plugin with empty widgets.json and no imported widgets
+    const wpRoot = path.join(tempRoot, 'site');
+    const pluginDir = path.join(wpRoot, 'wp-content', 'plugins', 'sociallane-elements');
+    const base = runCli(['--base', pluginDir], { cwd: tempRoot, env });
+    assert.equal(base.status, 0, `--base failed:\n${base.stdout}\n${base.stderr}`);
+
+    const widgetsJsonPath = path.join(pluginDir, 'widgets.json');
+    assert.equal(existsSync(path.join(pluginDir, 'sociallane-elements.php')), true, 'Plugin bootstrap missing');
+    assert.equal(existsSync(widgetsJsonPath), true, 'widgets.json missing after base install');
+
+    const widgetsJson = JSON.parse(readFileSync(widgetsJsonPath, 'utf8'));
+    assert.deepEqual(widgetsJson.widgets, [], 'Base install should keep widgets.json empty');
+
+    const widgetsPackagesDir = path.join(pluginDir, 'packages', 'widgets');
+    assert.equal(existsSync(widgetsPackagesDir), true, 'packages/widgets should exist after base install');
+    const widgetsAfterBase = readdirSync(widgetsPackagesDir, { withFileTypes: true }).filter((entry) =>
+      entry.isDirectory()
+    );
+    assert.equal(widgetsAfterBase.length, 0, 'Base install should not import widget component folders');
+
+    // 4) add with explicit --target from one directory above plugins
+    const fromWpContent = path.join(wpRoot, 'wp-content');
+    const addTarget = runCli(['add', '--target', pluginDir, 'faq-stacked', 'hero-split'], {
+      cwd: fromWpContent,
+      env,
+    });
+    assert.equal(addTarget.status, 0, `add --target failed:\n${addTarget.stdout}\n${addTarget.stderr}`);
+
+    const widgetsJsonAfterAdd = JSON.parse(readFileSync(widgetsJsonPath, 'utf8'));
+    assert.deepEqual(
+      widgetsJsonAfterAdd.widgets,
+      ['faq-stacked', 'hero-split'],
+      'add --target should set selected slugs'
+    );
+
+    assert.equal(
+      existsSync(path.join(pluginDir, 'packages', 'widgets', 'faq-stacked', 'faq-stacked.php')),
+      true,
+      'faq-stacked folder missing after add'
+    );
+    assert.equal(
+      existsSync(path.join(pluginDir, 'packages', 'widgets', 'hero-split', 'hero-split.php')),
+      true,
+      'hero-split folder missing after add'
+    );
+
+    // 5) add without --target from wp-content should auto-resolve plugin dir
+    const addAuto = runCli(['add', 'content-block'], { cwd: fromWpContent, env });
+    assert.equal(addAuto.status, 0, `add (auto target) failed:\n${addAuto.stdout}\n${addAuto.stderr}`);
+
+    const widgetsJsonAfterAuto = JSON.parse(readFileSync(widgetsJsonPath, 'utf8'));
+    assert.deepEqual(
+      widgetsJsonAfterAuto.widgets,
+      ['faq-stacked', 'hero-split', 'content-block'],
+      'auto target add should append slug'
+    );
+
+    if (!existsSync(fakeLog)) {
+      fail('Fake npm was never invoked');
+    }
+
+    console.log('CLI smoke tests passed.');
+  } finally {
+    rmSync(tempRoot, { recursive: true, force: true });
+  }
+}
+
+main();

package/scripts/widget-installer.js

@@ -1,18 +1,17 @@
 #!/usr/bin/env node
 /**
  * Per-widget installer: run from a @sociallane/widget-<slug> package (npx).
- * Ensures SocialLane Elements plugin is installed, then copies this package's widget/
- * into the plugin's packages/widgets/<slug>, runs sync-widgets and npm install.
+ * Ensures SocialLane Elements plugin is installed in base mode, then delegates
+ * widget import to the main CLI add command.
  */
 
-import { cpSync, existsSync, mkdirSync, readFileSync } from 'fs';
+import { existsSync, readFileSync } from 'fs';
 import { spawnSync } from 'child_process';
 import path from 'path';
 import { fileURLToPath } from 'url';
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const packageRoot = path.resolve(__dirname);
-const widgetDir = path.join(packageRoot, 'widget');
 
 function getSlugFromPackage() {
   const pkgPath = path.join(packageRoot, 'package.json');
@@ -56,62 +55,29 @@ function resolvePluginDir() {
   return path.join(cwd, 'wp-content', 'plugins', 'sociallane-elements');
 }
 
-function main() {
-  const slug = getSlugFromPackage();
-  if (!existsSync(widgetDir)) {
-    console.error('Widget folder not found:', widgetDir);
-    process.exit(1);
-  }
-  if (!existsSync(path.join(widgetDir, `${slug}.php`))) {
-    console.error('Invalid widget: missing', path.join(widgetDir, `${slug}.php`));
-    process.exit(1);
+function runNpx(args, cwd) {
+  const r = spawnSync('npx', ['--yes', ...args], {
+    cwd,
+    stdio: 'inherit',
+    shell: true,
+  });
+  if (r.status !== 0) {
+    process.exit(r.status ?? 1);
   }
+}
 
+function main() {
+  const slug = getSlugFromPackage();
   const pluginDir = resolvePluginDir();
-  const widgetsDest = path.join(pluginDir, 'packages', 'widgets');
   const pluginExists = existsSync(path.join(pluginDir, 'sociallane-elements.php'));
 
   if (!pluginExists) {
     console.log('SocialLane Elements not found. Installing base plugin...');
-    const r = spawnSync('npx', ['--yes', '@sociallane/elements', '--minimal'], {
-      cwd: path.dirname(pluginDir),
-      stdio: 'inherit',
-      shell: true,
-    });
-    if (r.status !== 0) {
-      process.exit(r.status ?? 1);
-    }
+    runNpx(['@sociallane/elements', '--base', pluginDir], path.dirname(pluginDir));
   }
 
-  if (!existsSync(widgetsDest)) {
-    mkdirSync(widgetsDest, { recursive: true });
-  }
-
-  const dest = path.join(widgetsDest, slug);
-  cpSync(widgetDir, dest, { recursive: true, force: true });
-  console.log('Added widget:', slug);
-
-  console.log('Updating widgets.json and building...');
-  const syncResult = spawnSync('node', [path.join(pluginDir, 'scripts', 'sync-widgets.js')], {
-    cwd: pluginDir,
-    stdio: 'inherit',
-  });
-  if (syncResult.status !== 0) {
-    process.exit(syncResult.status ?? 1);
-  }
-
-  const npmCmd = process.platform === 'win32' ? 'npm.cmd' : 'npm';
-  const installResult = spawnSync(npmCmd, ['install'], {
-    cwd: pluginDir,
-    stdio: 'inherit',
-    shell: true,
-  });
-  if (installResult.status !== 0) {
-    if (installResult.error) {
-      console.error('Failed to run npm:', installResult.error.message);
-    }
-    process.exit(installResult.status ?? 1);
-  }
+  console.log('Adding widget:', slug);
+  runNpx(['@sociallane/elements', 'add', '--target', pluginDir, slug], path.dirname(pluginDir));
 
   console.log('');
   console.log('Done. Widget', slug, 'installed. Activate the plugin in WordPress → Plugins if needed.');