@nextsparkjs/core 0.1.0-beta.2 → 0.1.0-beta.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nextsparkjs/core",
-  "version": "0.1.0-beta.2",
+  "version": "0.1.0-beta.4",
   "description": "NextSpark - The complete SaaS framework for Next.js",
   "license": "MIT",
   "author": "NextSpark <hello@nextspark.dev>",
@@ -44,6 +44,10 @@
       "types": "./dist/i18n.d.ts",
       "import": "./dist/i18n.js"
     },
+    "./config/protected-paths": {
+      "types": "./dist/config/protected-paths.d.ts",
+      "import": "./dist/config/protected-paths.js"
+    },
     "./globals.css": "./globals.css",
     "./theme-styles.css": "./theme-styles.css",
     "./styles/ui.css": {
@@ -206,21 +210,16 @@
     "tests/cypress/support",
     "tests/jest/setup.ts",
     "tests/jest/__mocks__",
-    "bin/dist",
     "globals.css",
     "theme-styles.css",
     "README.md",
     "scripts"
   ],
-  "bin": {
-    "nextspark": "./bin/dist/init.js"
-  },
   "scripts": {
-    "build": "tsup && pnpm build:dts && pnpm build:ui-css && pnpm build:cli",
+    "build": "tsup && pnpm build:dts && pnpm build:ui-css",
     "build:js": "tsup",
     "build:dts": "tsc -p tsconfig.dts.json || echo '⚠️  DTS generation completed with some type errors (partial coverage)'",
     "build:ui-css": "node scripts/build/build-ui-css.mjs",
-    "build:cli": "tsc -p bin/tsconfig.json",
     "dev": "tsup --watch",
     "test": "jest",
     "test:watch": "jest --watch",

package/scripts/build/registry/config.mjs

@@ -4,6 +4,11 @@
  * Central configuration for the registry build process.
  * Contains paths, flags, and content type definitions.
  *
+ * Supports three modes:
+ * 1. Monorepo mode: themes/plugins at repo root as workspace packages
+ * 2. NPM mode: @nextsparkjs/core installed in node_modules
+ * 3. User project mode: themes/plugins in contents/ directory
+ *
  * @module core/scripts/build/registry/config
  */
 
@@ -24,11 +29,37 @@ const __dirname = dirname(__filename)
 // Root directory (5 levels up from packages/core/scripts/build/registry/)
 export const rootDir = join(__dirname, '../../../../..')
 
+/**
+ * Detect monorepo root by searching for pnpm-workspace.yaml
+ * @param {string} startDir - Directory to start searching from
+ * @returns {string|null} Monorepo root path or null if not in monorepo
+ */
+export function detectMonorepoRoot(startDir = process.cwd()) {
+  let dir = startDir
+  const maxDepth = 10
+  let depth = 0
+
+  while (dir !== '/' && depth < maxDepth) {
+    if (existsSync(join(dir, 'pnpm-workspace.yaml'))) {
+      return dir
+    }
+    dir = dirname(dir)
+    depth++
+  }
+
+  return null
+}
+
 /**
  * Detect project root by searching for nextspark.config.ts or apps/dev in monorepo
  * @returns {string} Project root path
  */
 export function detectProjectRoot() {
+  // Check for explicit project root from CLI
+  if (process.env.NEXTSPARK_PROJECT_ROOT) {
+    return process.env.NEXTSPARK_PROJECT_ROOT
+  }
+
   let dir = process.cwd()
   const maxDepth = 10
   let depth = 0
@@ -72,6 +103,10 @@ export function getConfig(projectRoot = null) {
   // Check if running in npm mode
   const isNpmMode = isInstalledAsPackage(root)
 
+  // Check if running in monorepo mode
+  const monorepoRoot = detectMonorepoRoot(root)
+  const isMonorepoMode = !isNpmMode && monorepoRoot !== null
+
   // Determine paths based on mode
   const coreDir = isNpmMode
     ? join(root, 'node_modules/@nextsparkjs/core')
@@ -84,12 +119,33 @@ export function getConfig(projectRoot = null) {
   // Load nextspark.config.ts for features and other settings
   const nextsparkConfig = loadNextSparkConfigSync(root)
 
+  // Determine content directories based on mode
+  // Monorepo: themes/plugins at repo root as workspace packages
+  // User project: themes/plugins in contents/ directory
+  let contentsDir, themesDir, pluginsDir
+
+  if (isMonorepoMode) {
+    // Monorepo mode: themes and plugins are at the repo root
+    contentsDir = join(monorepoRoot, 'contents') // Legacy, kept for compatibility
+    themesDir = join(monorepoRoot, 'themes')
+    pluginsDir = join(monorepoRoot, 'plugins')
+  } else {
+    // User project mode (npm or standalone)
+    contentsDir = join(root, 'contents')
+    themesDir = join(root, 'contents/themes')
+    pluginsDir = join(root, 'contents/plugins')
+  }
+
   return {
     projectRoot: root,
+    monorepoRoot,
     isNpmMode,
+    isMonorepoMode,
     coreDir,
     outputDir,
-    contentsDir: join(root, 'contents'),
+    contentsDir,
+    themesDir,
+    pluginsDir,
     watchMode: process.argv.includes('--watch') && !process.argv.includes('--build'),
     buildMode: process.argv.includes('--build'),
     verbose: process.argv.includes('--verbose') || process.argv.includes('-v'),

package/scripts/build/registry/discovery/blocks.mjs

@@ -28,7 +28,7 @@ export async function discoverBlocks(config = DEFAULT_CONFIG) {
   }
 
   const themeName = config.activeTheme
-  const blocksDir = join(config.contentsDir, 'themes', themeName, 'blocks')
+  const blocksDir = join(config.themesDir, themeName, 'blocks')
 
   // Check if blocks directory exists
   try {

package/scripts/build/registry/discovery/middlewares.mjs

@@ -18,7 +18,7 @@ import { verbose } from '../../../utils/index.mjs'
  * @returns {Promise<Array>} Array of discovered middlewares
  */
 export async function discoverMiddlewares(config = DEFAULT_CONFIG) {
-  const themesDir = join(config.contentsDir, 'themes')
+  const themesDir = config.themesDir
   const middlewares = []
 
   // Only check the active theme if specified

package/scripts/build/registry/discovery/parent-child.mjs

@@ -29,11 +29,10 @@ export async function discoverParentChildRelations(config = DEFAULT_CONFIG) {
   const childTypeMappings = new Map()
 
   // Scan all discovered entities to find parent-child patterns in filesystem
-  const contentsDir = config.contentsDir
   const scanDirs = [
-    join(contentsDir, 'themes'),
-    join(contentsDir, 'plugins'),
-    join(contentsDir, 'entities')
+    config.themesDir,
+    config.pluginsDir,
+    join(config.contentsDir, 'entities')
   ]
 
   for (const baseDir of scanDirs) {

package/scripts/build/registry/discovery/permissions.mjs

@@ -159,7 +159,7 @@ export async function discoverPermissionsConfig(config = DEFAULT_CONFIG) {
     return null
   }
 
-  const permissionsPath = join(config.contentsDir, 'themes', themeName, 'config', 'permissions.config.ts')
+  const permissionsPath = join(config.themesDir, themeName, 'config', 'permissions.config.ts')
 
   if (!existsSync(permissionsPath)) {
     log(`No permissions.config.ts found for theme ${themeName}`, 'info')

package/scripts/build/registry/discovery/plugins.mjs

@@ -1,7 +1,9 @@
 /**
  * Plugin Discovery
  *
- * Discovers plugins and their API routes from contents/plugins
+ * Discovers plugins and their API routes.
+ * In monorepo mode: plugins/ at repo root
+ * In user project mode: contents/plugins/
  *
  * @module core/scripts/build/registry/discovery/plugins
  */
@@ -43,7 +45,7 @@ async function getActiveThemePlugins(config) {
     return null // null means no filtering
   }
 
-  const themeConfigPath = join(config.contentsDir, 'themes', config.activeTheme, 'config', 'theme.config.ts')
+  const themeConfigPath = join(config.themesDir, config.activeTheme, 'config', 'theme.config.ts')
 
   try {
     const configContent = await readFile(themeConfigPath, 'utf8')
@@ -63,7 +65,7 @@ async function getActiveThemePlugins(config) {
 }
 
 /**
- * Discover plugins from contents/plugins directory
+ * Discover plugins
  * @param {object} config - Optional configuration object (defaults to DEFAULT_CONFIG)
  * @returns {Promise<Array>} Array of discovered plugins
  */
@@ -71,7 +73,7 @@ export async function discoverPlugins(config = DEFAULT_CONFIG) {
   // Get plugins from nextspark.config.ts or theme config
   const allowedPlugins = await getActivePlugins(config)
 
-  const pluginsDir = join(config.contentsDir, 'plugins')
+  const pluginsDir = config.pluginsDir
   const plugins = []
 
   try {

package/scripts/build/registry/discovery/templates.mjs

@@ -23,7 +23,7 @@ import {
  */
 export async function discoverTemplates(config = DEFAULT_CONFIG) {
   log('Discovering template overrides...', 'info')
-  const themesDir = join(config.contentsDir, 'themes')
+  const themesDir = config.themesDir
   const templates = []
 
   // REQUIRED: Active theme must be specified

package/scripts/build/registry/discovery/themes.mjs

@@ -1,7 +1,9 @@
 /**
  * Theme Discovery
  *
- * Discovers themes and their configurations from contents/themes
+ * Discovers themes and their configurations.
+ * In monorepo mode: themes/ at repo root
+ * In user project mode: contents/themes/
  *
  * @module core/scripts/build/registry/discovery/themes
  */
@@ -15,12 +17,12 @@ import { verbose, extractExportName, extractHttpMethods } from '../../../utils/i
 import { discoverNestedEntities } from './entities.mjs'
 
 /**
- * Discover all themes in contents/themes/
+ * Discover all themes
  * @param {object} config - Optional configuration object (defaults to DEFAULT_CONFIG)
  * @returns {Promise<Array>} Array of discovered themes
  */
 export async function discoverThemes(config = DEFAULT_CONFIG) {
-  const themesDir = join(config.contentsDir, 'themes')
+  const themesDir = config.themesDir
   const themes = []
 
   // Only process the active theme if specified

package/scripts/build/registry/generators/billing-registry.mjs

@@ -109,13 +109,15 @@ export type { BillingConfig, PlanDefinition, FeatureDefinition, LimitDefinition
  */
 export async function generateBillingRegistry(activeTheme, contentsDir, config) {
   const themeName = activeTheme || 'default'
-  const billingConfigPath = join(contentsDir, 'themes', themeName, 'config', 'billing.config.ts')
+  // Use config.themesDir for monorepo support (contentsDir kept for backward compatibility)
+  const themesDir = config.themesDir || join(contentsDir, 'themes')
+  const billingConfigPath = join(themesDir, themeName, 'config', 'billing.config.ts')
 
   // Check if billing config exists for active theme
   if (!existsSync(billingConfigPath)) {
     log(`No billing config found for theme '${themeName}', using default`, 'warning')
     // Fall back to default theme
-    const defaultPath = join(contentsDir, 'themes', 'default', 'config', 'billing.config.ts')
+    const defaultPath = join(themesDir, 'default', 'config', 'billing.config.ts')
     if (!existsSync(defaultPath)) {
       log('No billing config found for default theme either!', 'error')
       return generateEmptyBillingRegistry(config)
@@ -125,7 +127,7 @@ export async function generateBillingRegistry(activeTheme, contentsDir, config)
   // Dynamically import the billing config at build time
   const themePath = existsSync(billingConfigPath) ? themeName : 'default'
   // Use file:// URL for ESM dynamic import
-  const absolutePath = join(contentsDir, 'themes', themePath, 'config', 'billing.config.ts')
+  const absolutePath = join(themesDir, themePath, 'config', 'billing.config.ts')
 
   let billingConfig
   try {

package/scripts/build/registry/generators/block-registry.mjs

@@ -27,12 +27,15 @@ export function generateBlockRegistry(blocks, config) {
  * DO NOT EDIT - This file is auto-generated by scripts/build-registry.mjs
  */
 
+import React from 'react'
 import type { BlockConfig } from '${convertCorePath('@/core/types/blocks', outputFilePath, config)}'
 
 export const BLOCK_REGISTRY: Record<string, BlockConfig> = {}
 
 export const BLOCK_CATEGORIES: string[] = []
 
+export const BLOCK_COMPONENTS: Record<string, React.LazyExoticComponent<React.ComponentType<any>>> = {}
+
 export const BLOCK_METADATA = {
   totalBlocks: 0,
   categories: [],

package/scripts/build/registry/generators/feature-registry.mjs

@@ -274,7 +274,7 @@ export interface FeatureEntry {
   key: string
   name: string
   description: string
-  category: 'core' | 'entities' | 'content' | 'settings' | 'admin'
+  category: 'core' | 'entities' | 'content' | 'settings' | 'admin' | 'public'
   icon: string
   tag: string
   testing: FeatureTesting
@@ -284,7 +284,7 @@ export interface FlowEntry {
   key: string
   name: string
   description: string
-  category: 'acquisition' | 'navigation' | 'content' | 'settings' | 'admin'
+  category: 'acquisition' | 'navigation' | 'content' | 'settings' | 'admin' | 'public'
   icon: string
   tag: string
   criticalPath?: boolean
@@ -369,12 +369,15 @@ export type FlowCategory = FlowEntry['category']
 /**
  * Main generator function - orchestrates the full generation
  * @param {string} themeName - Active theme name
- * @param {string} contentsDir - Path to contents directory
+ * @param {string} contentsDir - Path to contents directory (legacy, use config.themesDir instead)
  * @param {string} outputDir - Path for registry output
+ * @param {object} config - Optional configuration object from getConfig()
  * @returns {Object} Generation result
  */
-export async function generateFeatureRegistryFull(themeName, contentsDir, outputDir) {
-  const themePath = join(contentsDir, 'themes', themeName)
+export async function generateFeatureRegistryFull(themeName, contentsDir, outputDir, config = null) {
+  // Use config.themesDir for monorepo support, fall back to contentsDir/themes
+  const themesDir = config?.themesDir || join(contentsDir, 'themes')
+  const themePath = join(themesDir, themeName)
   const testsDir = join(themePath, 'tests', 'cypress', 'e2e')
 
   // Load configs
@@ -385,7 +388,7 @@ export async function generateFeatureRegistryFull(themeName, contentsDir, output
   const blocks = loadBlockSlugs(outputDir)
 
   // Discover tags from tests
-  const rootDir = join(contentsDir, '..')
+  const rootDir = config?.monorepoRoot || join(contentsDir, '..')
   const discoveredTags = discoverTestTags(testsDir, rootDir)
 
   // Validate (includes block tag validation)

package/scripts/build/registry/generators/route-handlers.mjs

@@ -22,9 +22,36 @@
  * @returns {string} Generated TypeScript content
  */
 export function generateRouteHandlersRegistry(plugins, themes, coreRoutes = [], entities = [], config) {
+  // Filter themes by activeTheme if set (monorepo optimization)
+  let filteredThemes = themes
+  let filteredPlugins = plugins
+  let requiredPluginNames = []
+
+  if (config.activeTheme) {
+    // Only include the active theme
+    filteredThemes = themes.filter(t => t.name === config.activeTheme)
+
+    // Get required plugins from the active theme's plugins array
+    const activeTheme = filteredThemes[0]
+    if (activeTheme && activeTheme.plugins && activeTheme.plugins.length > 0) {
+      // plugins can be full names like '@nextsparkjs/plugin-langchain' or just 'langchain'
+      requiredPluginNames = activeTheme.plugins.map(p =>
+        p.replace('@nextsparkjs/plugin-', '').replace(/['"]/g, '')
+      )
+    }
+
+    // Filter plugins to only include required ones by the active theme
+    if (requiredPluginNames.length > 0) {
+      filteredPlugins = plugins.filter(p => requiredPluginNames.includes(p.name))
+    } else {
+      // If no required plugins specified, don't include any plugin routes
+      filteredPlugins = []
+    }
+  }
+
   // Collect all route handlers from themes
   const themeRoutes = []
-  themes.forEach(theme => {
+  filteredThemes.forEach(theme => {
     if (theme.routeFiles && theme.routeFiles.length > 0) {
       theme.routeFiles.forEach(route => {
         const routeKey = route.relativePath === '/' ? '' : route.relativePath
@@ -41,7 +68,7 @@ export function generateRouteHandlersRegistry(plugins, themes, coreRoutes = [],
 
   // Collect all route handlers from plugins
   const pluginRoutes = []
-  plugins.forEach(plugin => {
+  filteredPlugins.forEach(plugin => {
     if (plugin.routeFiles && plugin.routeFiles.length > 0) {
       plugin.routeFiles.forEach(route => {
         const routeKey = route.relativePath === '/' ? '' : route.relativePath

package/scripts/build/registry/generators/translation-registry.mjs

@@ -3,12 +3,94 @@
  *
  * Generates translation-registry.ts
  *
+ * Dynamically discovers available locales by scanning messages/ directories
+ * and filtering against supportedLocales from the active theme's app.config.ts
+ *
  * @module core/scripts/build/registry/generators/translation-registry
  */
 
-import { existsSync, readdirSync, statSync } from 'fs'
+import { existsSync, readdirSync, readFileSync, statSync } from 'fs'
 import { join } from 'path'
 
+/**
+ * Extract supportedLocales from a theme's app.config.ts file
+ * Uses regex to parse the TypeScript file without requiring transpilation
+ *
+ * @param {string} themesDir - Path to themes directory
+ * @param {string} activeTheme - Name of the active theme
+ * @returns {string[]} Array of supported locale codes, or empty array if not found
+ */
+function getSupportedLocales(themesDir, activeTheme) {
+  if (!activeTheme) {
+    return []
+  }
+
+  const appConfigPath = join(themesDir, activeTheme, 'config', 'app.config.ts')
+
+  if (!existsSync(appConfigPath)) {
+    return []
+  }
+
+  try {
+    const content = readFileSync(appConfigPath, 'utf8')
+
+    // Match supportedLocales array using regex
+    // Handles formats like: supportedLocales: ['en', 'es', 'fr']
+    // or: supportedLocales: ["en", "es", "fr"]
+    const match = content.match(/supportedLocales\s*:\s*\[([\s\S]*?)\]/)
+
+    if (!match) {
+      return []
+    }
+
+    // Extract individual locale strings from the matched array content
+    const arrayContent = match[1]
+    const localeMatches = arrayContent.match(/['"]([a-zA-Z-]+)['"]/g)
+
+    if (!localeMatches) {
+      return []
+    }
+
+    // Clean up the matches (remove quotes)
+    return localeMatches.map(m => m.replace(/['"]/g, ''))
+  } catch (error) {
+    console.warn(`Warning: Could not read app.config.ts for theme ${activeTheme}: ${error.message}`)
+    return []
+  }
+}
+
+/**
+ * Get available locales for an entity by scanning its messages directory
+ * Only returns locales that exist in the directory AND are in supportedLocales
+ *
+ * @param {string} entityDir - Path to the entity directory
+ * @param {string[]} supportedLocales - Array of supported locale codes from app.config
+ * @returns {string[]} Array of available and supported locale codes
+ */
+function getEntityLocales(entityDir, supportedLocales) {
+  const messagesDir = join(entityDir, 'messages')
+
+  if (!existsSync(messagesDir)) {
+    return []
+  }
+
+  try {
+    const files = readdirSync(messagesDir)
+      .filter(f => f.endsWith('.json'))
+      .map(f => f.replace('.json', ''))
+
+    // Only return locales that exist AND are supported
+    // If supportedLocales is empty, return all found locales (fallback behavior)
+    if (supportedLocales.length === 0) {
+      return files
+    }
+
+    return files.filter(locale => supportedLocales.includes(locale))
+  } catch (error) {
+    return []
+  }
+}
+
 /**
  * Detect locale entries from a messages directory
  * Supports both directory pattern (en/, es/ with index.ts) and flat file pattern (en.json, es.json)
@@ -54,23 +136,36 @@ function detectLocales(messagesDir) {
  * Preserves i18n performance (only loads active locale)
  * Ensures ZERO runtime string interpolation in dynamic imports
  *
+ * Dynamically discovers available locales by:
+ * 1. Reading supportedLocales from active theme's app.config.ts
+ * 2. Scanning each entity's messages/ directory for .json files
+ * 3. Only generating loaders for locales that exist AND are supported
+ *
  * @param {Array} themes - Discovered themes
  * @param {object} config - Configuration object from getConfig()
  * @returns {string} Generated TypeScript content
  */
 export function generateTranslationRegistry(themes, config) {
+  // Get supported locales from active theme's app.config.ts
+  const supportedLocales = getSupportedLocales(config.themesDir, config.activeTheme)
+
   // Discover all translation files from themes
   const themeTranslations = []
   // Discover entity translations
   const entityTranslations = []
 
   themes.forEach(theme => {
-    const messagesDir = join(config.contentsDir, 'themes', theme.name, 'messages')
-    const entitiesDir = join(config.contentsDir, 'themes', theme.name, 'entities')
+    const messagesDir = join(config.themesDir, theme.name, 'messages')
+    const entitiesDir = join(config.themesDir, theme.name, 'entities')
 
     // Scan theme-level translations
     const locales = detectLocales(messagesDir)
     locales.forEach(({ locale, isDirectory }) => {
+      // Filter by supportedLocales if available
+      if (supportedLocales.length > 0 && !supportedLocales.includes(locale)) {
+        return
+      }
+
       // For directory pattern, import from the directory (index.ts)
       // For flat file pattern, import the .json file
       const filePath = isDirectory
@@ -86,7 +181,8 @@ export function generateTranslationRegistry(themes, config) {
       })
     })
 
-    // Scan entity-level translations
+    // Scan entity-level translations dynamically
+    // Instead of reading from entity configs, scan the messages/ directory
     if (existsSync(entitiesDir)) {
       const entityDirs = readdirSync(entitiesDir).filter(entry => {
         const entryPath = join(entitiesDir, entry)
@@ -94,21 +190,21 @@ export function generateTranslationRegistry(themes, config) {
       })
 
       entityDirs.forEach(entityName => {
-        const entityMessagesDir = join(entitiesDir, entityName, 'messages')
-        if (existsSync(entityMessagesDir)) {
-          const entityLocaleFiles = readdirSync(entityMessagesDir).filter(f => f.endsWith('.json'))
-
-          entityLocaleFiles.forEach(file => {
-            const locale = file.replace(/\.json$/, '')
-            entityTranslations.push({
-              themeName: theme.name,
-              entityName,
-              locale,
-              filePath: `@/contents/themes/${theme.name}/entities/${entityName}/messages/${file}`,
-              importKey: `entity_${theme.name.replace(/-/g, '_')}_${entityName.replace(/-/g, '_')}_${locale.replace(/-/g, '_')}`
-            })
+        const entityDir = join(entitiesDir, entityName)
+
+        // Use getEntityLocales to dynamically discover available locales
+        // This filters by both existence AND supportedLocales
+        const availableLocales = getEntityLocales(entityDir, supportedLocales)
+
+        availableLocales.forEach(locale => {
+          entityTranslations.push({
+            themeName: theme.name,
+            entityName,
+            locale,
+            filePath: `@/contents/themes/${theme.name}/entities/${entityName}/messages/${locale}.json`,
+            importKey: `entity_${theme.name.replace(/-/g, '_')}_${entityName.replace(/-/g, '_')}_${locale.replace(/-/g, '_')}`
           })
-        }
+        })
       })
     }
   })
@@ -165,6 +261,8 @@ export function generateTranslationRegistry(themes, config) {
  * Auto-generated Translation Registry
  *
  * Generated at: ${new Date().toISOString()}
+ * Active theme: ${config.activeTheme || 'none'}
+ * Supported locales: ${supportedLocales.length > 0 ? supportedLocales.join(', ') : 'all (no filter)'}
  * Themes with translations: ${Object.keys(loaderEntries).length}
  * Total theme translation files: ${themeTranslations.length}
  * Total entity translation files: ${entityTranslations.length}
@@ -172,6 +270,7 @@ export function generateTranslationRegistry(themes, config) {
  *
  * DO NOT EDIT - This file is auto-generated by scripts/build-registry.mjs
  *
+ * Locale discovery: Dynamically scans messages/ directories and filters by supportedLocales.
  * ZERO runtime string interpolation - all translation paths resolved at build time.
  * Preserves lazy-loading performance (only loads active locale).
  * Provides build-time validation and type safety.
@@ -210,6 +309,8 @@ export const TRANSLATION_METADATA = {
   totalEntityTranslations: ${entityTranslations.length},
   totalEntitiesWithTranslations: ${uniqueEntities.size},
   generatedAt: '${new Date().toISOString()}',
+  activeTheme: ${config.activeTheme ? `'${config.activeTheme}'` : 'null'},
+  supportedLocales: [${supportedLocales.map(l => `'${l}'`).join(', ')}],
   themes: [${Object.keys(loaderEntries).map(t => `'${t}'`).join(', ')}],
   entities: [${Array.from(uniqueEntities).map(e => `'${e}'`).join(', ')}]
 }