@koehler8/cms 1.0.0-beta.10

package/scripts/patch-lru-cache-tla.js

@@ -0,0 +1,164 @@
+#!/usr/bin/env node
+/**
+ * Patches all nested lru-cache copies in node_modules to remove top-level
+ * await, which breaks Node 20's sync CJS loader when cssstyle (via jsdom, via
+ * vite-ssg) tries to `require()` @asamuzakjp/css-color.
+ *
+ * The fix:
+ *  1. Overwrite `dist/esm/diagnostics-channel.js` with a TLA-free no-op that
+ *     uses createRequire() for node:diagnostics_channel.
+ *  2. Rewrite each nested lru-cache `package.json` to point the `import`
+ *     conditional at `dist/esm/index.js` (non-minified), which imports from
+ *     our patched `diagnostics-channel.js` instead of inlining TLA.
+ *
+ * Safe to run repeatedly; idempotent.
+ */
+
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+// Prefer INIT_CWD (set by npm during postinstall to the consumer's project
+// root). Fall back to the parent of scripts/ (package root) or CWD.
+const candidateRoots = [
+  process.env.INIT_CWD,
+  path.resolve(__dirname, '..'),
+  process.cwd(),
+].filter(Boolean);
+
+let repoRoot;
+let nodeModules;
+for (const root of candidateRoots) {
+  const nm = path.join(root, 'node_modules');
+  if (fs.existsSync(nm)) {
+    repoRoot = root;
+    nodeModules = nm;
+    break;
+  }
+}
+
+if (!nodeModules) {
+  console.log('[patch-lru-cache-tla] node_modules not found; skipping');
+  process.exit(0);
+}
+
+const REPLACEMENT = `// Patched by scripts/patch-lru-cache-tla.js — removes top-level await.
+// Uses createRequire to load node:diagnostics_channel synchronously from ESM.
+import { createRequire } from 'node:module';
+const dummy = { hasSubscribers: false };
+let _metrics = dummy;
+let _tracing = dummy;
+try {
+    const require = createRequire(import.meta.url);
+    const dc = require('node:diagnostics_channel');
+    _metrics = dc.channel('lru-cache:metrics');
+    _tracing = dc.tracingChannel('lru-cache');
+} catch {
+    /* non-node runtime: keep dummy */
+}
+export const metrics = _metrics;
+export const tracing = _tracing;
+`;
+
+function findLruCacheDirs(root) {
+  const found = [];
+  function walk(dir) {
+    let entries;
+    try {
+      entries = fs.readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue;
+      const full = path.join(dir, entry.name);
+      if (entry.name === 'lru-cache' && fs.existsSync(path.join(full, 'package.json'))) {
+        found.push(full);
+        // don't recurse into lru-cache's own node_modules
+        continue;
+      }
+      if (entry.name === 'node_modules' || entry.name.startsWith('@')) {
+        walk(full);
+      } else if (entry.name === 'node_modules') {
+        walk(full);
+      } else {
+        // Only recurse into scoped/package dirs that could contain nested node_modules
+        const nested = path.join(full, 'node_modules');
+        if (fs.existsSync(nested)) walk(nested);
+      }
+    }
+  }
+  walk(root);
+  return found;
+}
+
+function patchLruCache(lruDir) {
+  const diagFile = path.join(lruDir, 'dist', 'esm', 'diagnostics-channel.js');
+  const pkgFile = path.join(lruDir, 'package.json');
+  const indexJs = path.join(lruDir, 'dist', 'esm', 'index.js');
+
+  if (!fs.existsSync(diagFile) || !fs.existsSync(pkgFile) || !fs.existsSync(indexJs)) {
+    return false;
+  }
+
+  let patched = false;
+
+  // 1. Overwrite diagnostics-channel.js if it still contains TLA
+  const current = fs.readFileSync(diagFile, 'utf-8');
+  if (current.includes('await import')) {
+    fs.writeFileSync(diagFile, REPLACEMENT, 'utf-8');
+    patched = true;
+  }
+
+  // 2. Rewrite package.json exports to use non-minified index.js
+  const pkg = JSON.parse(fs.readFileSync(pkgFile, 'utf-8'));
+  let pkgChanged = false;
+
+  const rewriteExports = (exports) => {
+    if (!exports || typeof exports !== 'object') return;
+    for (const key of Object.keys(exports)) {
+      const value = exports[key];
+      if (value && typeof value === 'object') {
+        if (value.import && typeof value.import === 'object' && value.import.default) {
+          if (value.import.default.includes('index.min.js')) {
+            value.import.default = value.import.default.replace('index.min.js', 'index.js');
+            pkgChanged = true;
+          }
+        } else if (typeof value.import === 'string' && value.import.includes('index.min.js')) {
+          value.import = value.import.replace('index.min.js', 'index.js');
+          pkgChanged = true;
+        }
+        rewriteExports(value);
+      }
+    }
+  };
+
+  rewriteExports(pkg.exports);
+
+  if (pkg.module && pkg.module.includes('index.min.js')) {
+    pkg.module = pkg.module.replace('index.min.js', 'index.js');
+    pkgChanged = true;
+  }
+
+  if (pkgChanged) {
+    fs.writeFileSync(pkgFile, JSON.stringify(pkg, null, 2) + '\n', 'utf-8');
+    patched = true;
+  }
+
+  return patched;
+}
+
+const lruDirs = findLruCacheDirs(nodeModules);
+let patchedCount = 0;
+for (const dir of lruDirs) {
+  if (patchLruCache(dir)) {
+    patchedCount++;
+    console.log(`[patch-lru-cache-tla] patched ${path.relative(repoRoot, dir)}`);
+  }
+}
+
+console.log(
+  `[patch-lru-cache-tla] processed ${lruDirs.length} lru-cache dirs, patched ${patchedCount}`
+);

package/scripts/validate-extensions.mjs

@@ -0,0 +1,392 @@
+import { readdir, readFile } from 'node:fs/promises';
+import { join, resolve } from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+
+import { createRequire } from 'node:module';
+import Ajv from 'ajv/dist/2020.js';
+import addFormats from 'ajv-formats';
+
+const require = createRequire(import.meta.url);
+const packageJson = require('../package.json');
+import { compareVersions } from '../src/utils/semver.js';
+import { validateRequiredContentPaths } from '../src/utils/contentRequirements.js';
+
+const ROOT_DIR = resolve(fileURLToPath(new URL('..', import.meta.url)));
+const EXTENSIONS_DIR = join(ROOT_DIR, 'extensions');
+const SITES_DIR = join(ROOT_DIR, 'sites');
+
+const ajv = new Ajv({ allErrors: true, strict: false });
+addFormats(ajv);
+const APP_VERSION = process.env.VITE_APP_VERSION || packageJson.version || '0.0.0';
+const normalizeSlug = (value) => (value || '').toString().trim().toLowerCase();
+
+function isJsonFile(fileName) {
+  return fileName.toLowerCase().endsWith('.json');
+}
+
+async function collectExtensionPackages(dir) {
+  const entries = await readdir(dir, { withFileTypes: true });
+  const packages = [];
+
+  for (const entry of entries) {
+    if (entry.name.startsWith('.')) continue;
+    const absolute = join(dir, entry.name);
+    if (entry.isDirectory()) {
+      const nested = await collectExtensionPackages(absolute);
+      packages.push(...nested);
+      continue;
+    }
+    if (entry.name === 'extension.config.json') {
+      packages.push(absolute);
+    }
+  }
+
+  return packages;
+}
+
+async function loadJson(filePath) {
+  const raw = await readFile(filePath, 'utf-8');
+  return JSON.parse(raw);
+}
+
+async function loadExtensionRegistry() {
+  const manifestPaths = await collectExtensionPackages(EXTENSIONS_DIR);
+  const map = new Map();
+
+  for (const manifestPath of manifestPaths) {
+    const manifestDir = manifestPath.replace(/extension\.config\.json$/i, '');
+    const manifest = await loadJson(manifestPath);
+    const slug = manifest.slug || manifestDir;
+    map.set(slug, {
+      manifest,
+      dir: manifestDir,
+    });
+  }
+
+  return map;
+}
+
+async function importSchema(schemaPath) {
+  if (!schemaPath) return null;
+  const lower = schemaPath.toLowerCase();
+  if (lower.endsWith('.json')) {
+    const raw = await readFile(schemaPath, 'utf-8');
+    return JSON.parse(raw);
+  }
+  const url = pathToFileURL(schemaPath).href;
+  const module = await import(url);
+  return module?.default ?? module;
+}
+
+function buildComponentMaps(extensionRegistry) {
+  const componentMap = new Map();
+  const extensionNameToSources = new Map();
+
+  for (const { manifest, dir } of extensionRegistry.values()) {
+    if (!Array.isArray(manifest.components)) continue;
+    const slug = typeof manifest.slug === 'string' ? manifest.slug.trim() : '';
+    const normalizedSlug = slug ? slug.toLowerCase() : '';
+
+    for (const component of manifest.components) {
+      if (!component?.name) continue;
+      const entry = {
+        manifest,
+        dir,
+        component,
+        slug,
+        normalizedSlug,
+      };
+      if (normalizedSlug) {
+        const sourceKey = `${normalizedSlug}:${component.name}`;
+        componentMap.set(sourceKey, entry);
+        const existingSources = extensionNameToSources.get(component.name) || new Set();
+        existingSources.add(normalizedSlug);
+        extensionNameToSources.set(component.name, existingSources);
+      }
+    }
+  }
+
+  return {
+    componentMap,
+    extensionNameToSources,
+  };
+}
+
+async function collectSiteConfigs(dir) {
+  const configs = [];
+  const entries = await readdir(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    if (entry.name.startsWith('.')) continue;
+    const absolute = join(dir, entry.name);
+    if (entry.isDirectory()) {
+      const nested = await collectSiteConfigs(absolute);
+      configs.push(...nested);
+      continue;
+    }
+    if (isJsonFile(entry.name)) {
+      configs.push(absolute);
+    }
+  }
+  return configs;
+}
+
+async function validateConfigBlocks({
+  siteConfigPath,
+  siteConfig,
+  componentMap,
+  extensionNameToSources,
+  appVersion,
+}) {
+  const failures = [];
+
+  if (!siteConfig?.pages || typeof siteConfig.pages !== 'object') {
+    return failures;
+  }
+
+  for (const [pageKey, pageConfig] of Object.entries(siteConfig.pages)) {
+    if (!pageConfig || typeof pageConfig !== 'object') continue;
+    const components = Array.isArray(pageConfig.components) ? pageConfig.components : [];
+    const content = pageConfig.content && typeof pageConfig.content === 'object' ? pageConfig.content : {};
+    const normalizedPageKey = (pageKey || '').toString().trim().toLowerCase();
+
+    for (const entry of components) {
+      let name = '';
+      let configKeyOverride;
+      let enabled = true;
+      let source;
+
+      if (typeof entry === 'string') {
+        name = entry;
+      } else if (entry && typeof entry === 'object') {
+        enabled = entry.enabled !== false;
+        name = typeof entry.name === 'string' ? entry.name : '';
+        configKeyOverride = typeof entry.configKey === 'string' && entry.configKey.trim()
+          ? entry.configKey.trim()
+          : undefined;
+        source = typeof entry.source === 'string' ? entry.source : undefined;
+      } else {
+        continue;
+      }
+
+      if (typeof name === 'string') {
+        name = name.trim();
+      }
+
+      if (!enabled || !name) continue;
+
+      const normalizedSource = source ? normalizeSlug(source) : '';
+      const sourcesForName = extensionNameToSources.get(name);
+      const isExtensionName = Boolean(sourcesForName && sourcesForName.size);
+
+      if (isExtensionName && !normalizedSource) {
+        failures.push({
+          siteConfigPath,
+          pageKey,
+          componentName: name,
+          message: `Component comes from an extension and must specify "source". Available sources: ${Array.from(sourcesForName).join(', ')}`,
+        });
+        continue;
+      }
+
+      if (isExtensionName && normalizedSource && !sourcesForName.has(normalizedSource)) {
+        failures.push({
+          siteConfigPath,
+          pageKey,
+          componentName: name,
+          source: normalizedSource,
+          message: `Component is not provided by the "${normalizedSource}" extension.`,
+        });
+        continue;
+      }
+
+      if (!isExtensionName && normalizedSource) {
+        failures.push({
+          siteConfigPath,
+          pageKey,
+          componentName: name,
+          source: normalizedSource,
+          message: 'Component does not belong to an extension so "source" must be omitted.',
+        });
+        continue;
+      }
+
+      if (!isExtensionName) {
+        continue;
+      }
+
+      const lookupKey = `${normalizedSource}:${name}`;
+      const componentMeta = componentMap.get(lookupKey);
+      if (!componentMeta) {
+        failures.push({
+          siteConfigPath,
+          pageKey,
+          componentName: name,
+          source: normalizedSource,
+          message: 'Component metadata could not be resolved for the specified source.',
+        });
+        continue;
+      }
+      const { component, dir } = componentMeta;
+      const configKey = configKeyOverride || component.configKey;
+      if (!configKey) continue;
+      const block = content[configKey];
+
+      if (Array.isArray(component.allowedPages) && component.allowedPages.length) {
+        const allowed = component.allowedPages
+          .map((slug) => (slug || '').toString().trim().toLowerCase())
+          .filter(Boolean);
+        if (allowed.length && !allowed.includes(normalizedPageKey)) {
+          failures.push({
+            siteConfigPath,
+            pageKey,
+            componentName: name,
+            configKey,
+            source: normalizedSource || undefined,
+            message: `Component is not allowed on this page (allowed: ${allowed.join(', ')}).`,
+          });
+          continue;
+        }
+      }
+
+      if (component.minAppVersion && compareVersions(appVersion, component.minAppVersion) < 0) {
+        failures.push({
+          siteConfigPath,
+          pageKey,
+          componentName: name,
+          configKey,
+          source: normalizedSource || undefined,
+          message: `Component requires app version ${component.minAppVersion} or higher (current ${appVersion}).`,
+        });
+        continue;
+      }
+
+      if (Array.isArray(component.requiredContent) && component.requiredContent.length) {
+        const { isValid, missing } = validateRequiredContentPaths(block, component.requiredContent);
+        if (!isValid) {
+          failures.push({
+            siteConfigPath,
+            pageKey,
+            componentName: name,
+            configKey,
+            source: normalizedSource || undefined,
+            message: `Missing required content paths: ${missing.join(', ')}`,
+          });
+          continue;
+        }
+      }
+
+      const schemaRef = component.propsInterface;
+      if (!schemaRef) continue;
+
+      const schemaPath = join(dir, schemaRef.replace(/^\.\/+/, ''));
+      let schema;
+      let importFailed = false;
+      try {
+        schema = await importSchema(schemaPath);
+      } catch (error) {
+        importFailed = true;
+        if (!(/Cannot use import statement/.test(String(error)) || /Unexpected reserved word/.test(String(error)))) {
+          throw error;
+        }
+      }
+      if (importFailed) {
+        schema = await loadJson(schemaPath);
+      }
+      if (!schema) {
+        failures.push({
+          siteConfigPath,
+          pageKey,
+          componentName: name,
+          configKey,
+          source: normalizedSource || undefined,
+          message: `Schema "${schemaRef}" could not be loaded.`,
+        });
+        continue;
+      }
+
+      const validate = ajv.compile(schema);
+      const valid = validate(block);
+      if (!valid) {
+        failures.push({
+          siteConfigPath,
+          pageKey,
+          componentName: name,
+          configKey,
+          source: normalizedSource || undefined,
+          errors: validate.errors,
+        });
+      }
+    }
+  }
+
+  return failures;
+}
+
+async function main() {
+  const extensionRegistry = await loadExtensionRegistry();
+  if (!extensionRegistry.size) {
+    console.warn('No extension manifests found under /extensions.');
+    return;
+  }
+  const { componentMap, extensionNameToSources } = buildComponentMaps(extensionRegistry);
+
+  const siteConfigs = await collectSiteConfigs(SITES_DIR);
+  const failures = [];
+
+  for (const siteConfigPath of siteConfigs) {
+    let siteConfig;
+    try {
+      siteConfig = await loadJson(siteConfigPath);
+    } catch (error) {
+      failures.push({
+        siteConfigPath,
+        message: `Failed to parse JSON: ${error.message}`,
+      });
+      continue;
+    }
+    const blockFailures = await validateConfigBlocks({
+      siteConfigPath,
+      siteConfig,
+      componentMap,
+      extensionNameToSources,
+      appVersion: APP_VERSION,
+    });
+    failures.push(...blockFailures);
+  }
+
+  if (failures.length) {
+    console.error('Extension content validation failed:');
+    failures.forEach((failure) => {
+      console.error(`\n- ${failure.siteConfigPath}`);
+      if (failure.pageKey) {
+        console.error(`  Page: ${failure.pageKey}`);
+      }
+      if (failure.componentName) {
+        console.error(`  Component: ${failure.componentName}`);
+      }
+      if (failure.source) {
+        console.error(`  Source: ${failure.source}`);
+      }
+      if (failure.configKey) {
+        console.error(`  Config key: ${failure.configKey}`);
+      }
+      if (failure.message) {
+        console.error(`  Error: ${failure.message}`);
+      }
+      if (failure.errors) {
+        failure.errors.forEach((error) => {
+          console.error(`  • ${error.instancePath || '/'} ${error.message}`);
+        });
+      }
+    });
+    process.exitCode = 1;
+    return;
+  }
+
+  console.log('All extension content blocks validated successfully.');
+}
+
+main().catch((error) => {
+  console.error(error);
+  process.exitCode = 1;
+});

package/scripts/validate-themes.mjs

@@ -0,0 +1,64 @@
+import { readdir } from 'node:fs/promises';
+import { join, resolve } from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+import { validateThemeManifest } from '../src/themes/themeValidator.js';
+
+const MANIFEST_PATTERN = /theme\.config\.(js|mjs|json)$/;
+const ROOT_DIR = resolve(fileURLToPath(new URL('..', import.meta.url)));
+const THEMES_DIR = join(ROOT_DIR, 'themes');
+
+async function collectManifestPaths(dir) {
+  const entries = await readdir(dir, { withFileTypes: true });
+  const paths = [];
+  for (const entry of entries) {
+    if (entry.name.startsWith('.')) continue;
+    const absolutePath = join(dir, entry.name);
+    if (entry.isDirectory()) {
+      const nested = await collectManifestPaths(absolutePath);
+      paths.push(...nested);
+    } else if (MANIFEST_PATTERN.test(entry.name)) {
+      paths.push(absolutePath);
+    }
+  }
+  return paths;
+}
+
+async function loadManifestFromPath(filePath) {
+  const module = await import(pathToFileURL(filePath).href);
+  return module?.default ?? module;
+}
+
+async function main() {
+  const manifestPaths = await collectManifestPaths(THEMES_DIR);
+  if (!manifestPaths.length) {
+    console.warn('No theme manifests found under /themes.');
+    return;
+  }
+  const failures = [];
+  for (const manifestPath of manifestPaths) {
+    const manifest = await loadManifestFromPath(manifestPath);
+    const { valid, errors } = validateThemeManifest(manifest, { throwOnError: false });
+    if (!valid) {
+      failures.push({ path: manifestPath, errors });
+    } else {
+      console.log(`✓ ${manifest.slug || manifestPath}`);
+    }
+  }
+
+  if (failures.length) {
+    console.error('\nTheme manifest validation failed:');
+    failures.forEach(({ path, errors }) => {
+      console.error(`\n- ${path}`);
+      errors.forEach((error) => console.error(`  • ${error}`));
+    });
+    process.exitCode = 1;
+    return;
+  }
+
+  console.log('\nAll theme manifests validated successfully.');
+}
+
+main().catch((error) => {
+  console.error(error);
+  process.exitCode = 1;
+});

package/src/App.vue

@@ -0,0 +1,3 @@
+<template>
+  <router-view />
+</template>