uniweb 0.7.1 → 0.7.2

package/src/templates/processor.js

@@ -19,9 +19,6 @@ let partialsRegistered = false
 // Store for version data (set by registerVersions)
 let versionData = {}
 
-// Track missing versions during processing
-const missingVersions = new Set()
-
 // Default fallback version when a package version is unknown
 const DEFAULT_FALLBACK_VERSION = '^0.1.0'
 
@@ -32,23 +29,6 @@ const DEFAULT_FALLBACK_VERSION = '^0.1.0'
  */
 export function registerVersions(versions) {
   versionData = versions || {}
-  missingVersions.clear()
-}
-
-/**
- * Get the list of missing versions encountered during processing
- *
- * @returns {string[]} Array of package names that were missing versions
- */
-export function getMissingVersions() {
-  return [...missingVersions]
-}
-
-/**
- * Clear the missing versions set
- */
-export function clearMissingVersions() {
-  missingVersions.clear()
 }
 
 /**
@@ -100,8 +80,6 @@ Handlebars.registerHelper('version', function(packageName) {
     return versionData[`@uniweb/${packageName}`]
   }
 
-  // Track the missing version and return a fallback
-  missingVersions.add(packageName)
   return DEFAULT_FALLBACK_VERSION
 })
 
@@ -195,78 +173,29 @@ async function processFile(sourcePath, targetPath, data, options = {}) {
  * @param {string} targetPath - Destination directory
  * @param {Object} data - Template variables
  * @param {Object} options - Processing options
- * @param {string|null} options.variant - Template variant to use
- * @param {string|null} options.basePath - Base template to merge with (files copied first)
- * @param {boolean} options.isBase - Internal: true when processing base template (allows overwriting)
  * @param {Function} options.onWarning - Warning callback
  * @param {Function} options.onProgress - Progress callback
  */
 export async function copyTemplateDirectory(sourcePath, targetPath, data, options = {}) {
-  const { variant = null, basePath = null, isBase = false, onWarning, onProgress } = options
-
-  // If a base template is specified, copy it first (with isBase=true so main can overwrite)
-  if (basePath && existsSync(basePath)) {
-    await copyTemplateDirectory(basePath, targetPath, data, { variant, isBase: true, onWarning, onProgress })
-  }
+  const { onWarning, onProgress } = options
 
   await fs.mkdir(targetPath, { recursive: true })
   const entries = await fs.readdir(sourcePath, { withFileTypes: true })
 
-  // Build a set of base names that have variant-specific directories
-  const variantBases = new Set()
-  for (const entry of entries) {
-    if (entry.isDirectory()) {
-      const variantMatch = entry.name.match(/^(.+)\.([^.]+)$/)
-      if (variantMatch) {
-        variantBases.add(variantMatch[1]) // e.g., 'foundation' from 'foundation.tailwind4'
-      }
-    }
-  }
-
-  // Options for recursive calls (without basePath to avoid re-copying base at each level)
-  const recursionOptions = { variant, isBase, onWarning, onProgress }
-
   for (const entry of entries) {
     const sourceName = entry.name
 
-    // Check if this is a variant-specific item (e.g., "dir.variant")
-    const variantMatch = entry.isDirectory()
-      ? sourceName.match(/^(.+)\.([^.]+)$/)
-      : null
-
     if (entry.isDirectory()) {
-      if (variantMatch) {
-        const [, baseName, dirVariant] = variantMatch
-
-        // When no variant is specified, skip all variant directories
-        if (!variant) {
-          continue
-        }
-
-        // When variant is specified, skip directories that don't match
-        if (dirVariant !== variant) {
-          continue
-        }
-
-        // Use the base name without variant suffix for the target
-        const sourceFullPath = path.join(sourcePath, sourceName)
-        const targetFullPath = path.join(targetPath, baseName)
-
-        await copyTemplateDirectory(sourceFullPath, targetFullPath, data, recursionOptions)
-      } else {
-        // Regular directory - skip if a variant override exists and we're using that variant
-        if (variant && variantBases.has(sourceName)) {
-          // Skip this directory because a variant-specific version exists
-          continue
-        }
-
-        const sourceFullPath = path.join(sourcePath, sourceName)
-        const targetFullPath = path.join(targetPath, sourceName)
-
-        await copyTemplateDirectory(sourceFullPath, targetFullPath, data, recursionOptions)
-      }
+      const sourceFullPath = path.join(sourcePath, sourceName)
+      // Rename _prefix directories to .prefix (e.g., _vscode → .vscode)
+      // This allows dotfile directories to be committed without being gitignored
+      const targetName = sourceName.startsWith('_') && !sourceName.startsWith('__')
+        ? `.${sourceName.slice(1)}`
+        : sourceName
+      const targetFullPath = path.join(targetPath, targetName)
+
+      await copyTemplateDirectory(sourceFullPath, targetFullPath, data, { onWarning, onProgress })
     } else {
-      // File processing
       // Skip template.json as it's metadata for the template, not for the output
       if (sourceName === 'template.json') {
         continue
@@ -280,12 +209,6 @@ export async function copyTemplateDirectory(sourcePath, targetPath, data, option
       const sourceFullPath = path.join(sourcePath, sourceName)
       const targetFullPath = path.join(targetPath, targetName)
 
-      // When processing base template, skip if target exists (main template files take precedence)
-      // When processing main template, overwrite any files from base
-      if (isBase && existsSync(targetFullPath)) {
-        continue
-      }
-
       if (onProgress) {
         onProgress(`Creating ${targetName}`)
       }

package/src/templates/resolver.js

@@ -2,8 +2,8 @@
  * Template resolver - parses template identifiers and determines source type
  */
 
-// Built-in templates (file-based in cli/templates/)
-export const BUILTIN_TEMPLATES = ['single', 'multi']
+// Built-in templates (programmatic, not file-based)
+export const BUILTIN_TEMPLATES = ['blank']
 
 // Official templates from @uniweb/templates package (downloaded from GitHub releases)
 export const OFFICIAL_TEMPLATES = ['marketing', 'academic', 'docs', 'international', 'dynamic', 'store', 'extensions']
@@ -11,7 +11,7 @@ export const OFFICIAL_TEMPLATES = ['marketing', 'academic', 'docs', 'internation
 /**
  * Parse a template identifier and determine its source type
  *
- * @param {string} identifier - Template identifier (e.g., 'single', 'marketing', 'github:user/repo')
+ * @param {string} identifier - Template identifier (e.g., 'blank', 'marketing', 'github:user/repo')
  * @returns {Object} Parsed template info
  */
 export function parseTemplateId(identifier) {

package/src/templates/validator.js

@@ -91,7 +91,7 @@ export class ValidationError extends Error {
 export const ErrorCodes = {
   MISSING_TEMPLATE_JSON: 'MISSING_TEMPLATE_JSON',
   INVALID_TEMPLATE_JSON: 'INVALID_TEMPLATE_JSON',
-  MISSING_TEMPLATE_DIR: 'MISSING_TEMPLATE_DIR',
+  MISSING_CONTENT_DIR: 'MISSING_CONTENT_DIR',
   MISSING_REQUIRED_FIELD: 'MISSING_REQUIRED_FIELD',
   VERSION_MISMATCH: 'VERSION_MISMATCH',
 }
@@ -139,34 +139,76 @@ export async function validateTemplate(templateRoot, options = {}) {
     )
   }
 
-  // Check for template/ directory
-  const templateDir = path.join(templateRoot, 'template')
-  if (!existsSync(templateDir)) {
-    throw new ValidationError(
-      `Missing template/ directory in ${templateRoot}`,
-      ErrorCodes.MISSING_TEMPLATE_DIR,
-      { path: templateRoot }
-    )
-  }
-
-  // Check version compatibility
-  if (uniwebVersion && metadata.uniweb) {
-    if (!satisfiesVersion(uniwebVersion, metadata.uniweb)) {
+  // Check version compatibility (support both `compatible` and `uniweb` fields)
+  const versionRange = metadata.compatible || metadata.uniweb
+  if (uniwebVersion && versionRange) {
+    if (!satisfiesVersion(uniwebVersion, versionRange)) {
       throw new ValidationError(
-        `Template requires Uniweb ${metadata.uniweb}, but current version is ${uniwebVersion}`,
+        `Template requires Uniweb ${versionRange}, but current version is ${uniwebVersion}`,
         ErrorCodes.VERSION_MISMATCH,
-        { required: metadata.uniweb, current: uniwebVersion }
+        { required: versionRange, current: uniwebVersion }
       )
     }
   }
 
+  // Format 2: content template — foundation/ and/or site/ directories alongside template.json
+  const contentDirs = resolveContentDirs(templateRoot, metadata)
+
+  if (contentDirs.length === 0) {
+    throw new ValidationError(
+      `No content directories found in ${templateRoot}. Templates need foundation/ and/or site/ directories alongside template.json.`,
+      ErrorCodes.MISSING_CONTENT_DIR,
+      { path: templateRoot }
+    )
+  }
+
   return {
     ...metadata,
-    templateDir,
+    format: 2,
+    contentDirs,
     metadataPath
   }
 }
 
+/**
+ * Resolve content directories from a format 2 template
+ *
+ * @param {string} templateRoot - Root of the template (contains template.json)
+ * @param {Object} metadata - Parsed template.json
+ * @returns {Array<Object>} Content directories: [{ type, name, dir, foundation? }]
+ */
+export function resolveContentDirs(templateRoot, metadata) {
+  const dirs = []
+
+  if (metadata.packages) {
+    // Multi-package template: iterate declared packages
+    for (const pkg of metadata.packages) {
+      const dir = path.join(templateRoot, pkg.name)
+      if (existsSync(dir)) {
+        dirs.push({
+          type: pkg.type,
+          name: pkg.name,
+          dir,
+          ...(pkg.foundation ? { foundation: pkg.foundation } : {}),
+        })
+      }
+    }
+  } else {
+    // Standard template: look for foundation/ and site/
+    const foundationDir = path.join(templateRoot, 'foundation')
+    if (existsSync(foundationDir)) {
+      dirs.push({ type: 'foundation', name: 'foundation', dir: foundationDir })
+    }
+
+    const siteDir = path.join(templateRoot, 'site')
+    if (existsSync(siteDir)) {
+      dirs.push({ type: 'site', name: 'site', dir: siteDir })
+    }
+  }
+
+  return dirs
+}
+
 /**
  * Get list of available templates in a templates directory
  *

package/src/utils/config.js

@@ -0,0 +1,229 @@
+/**
+ * Workspace Config Management
+ *
+ * Read/write pnpm-workspace.yaml and root package.json.
+ * Used by both `create` and `add` commands.
+ */
+
+import { existsSync } from 'node:fs'
+import { readFile, writeFile } from 'node:fs/promises'
+import { join } from 'node:path'
+import yaml from 'js-yaml'
+
+/**
+ * Read pnpm-workspace.yaml
+ * @param {string} rootDir - Workspace root directory
+ * @returns {Promise<{packages: string[]}>}
+ */
+export async function readWorkspaceConfig(rootDir) {
+  const configPath = join(rootDir, 'pnpm-workspace.yaml')
+  if (!existsSync(configPath)) {
+    return { packages: [] }
+  }
+  const content = await readFile(configPath, 'utf-8')
+  const config = yaml.load(content)
+  return { packages: config?.packages || [] }
+}
+
+/**
+ * Write pnpm-workspace.yaml
+ * @param {string} rootDir - Workspace root directory
+ * @param {{packages: string[]}} config
+ */
+export async function writeWorkspaceConfig(rootDir, config) {
+  const configPath = join(rootDir, 'pnpm-workspace.yaml')
+  const content = yaml.dump(config, { flowLevel: -1, quotingType: '"' })
+  await writeFile(configPath, content)
+}
+
+/**
+ * Add a glob pattern to pnpm-workspace.yaml if not already present
+ * @param {string} rootDir - Workspace root directory
+ * @param {string} glob - Glob pattern to add
+ */
+export async function addWorkspaceGlob(rootDir, glob) {
+  const config = await readWorkspaceConfig(rootDir)
+  if (!config.packages.includes(glob)) {
+    config.packages.push(glob)
+    await writeWorkspaceConfig(rootDir, config)
+  }
+}
+
+/**
+ * Read root package.json
+ * @param {string} rootDir - Workspace root directory
+ * @returns {Promise<Object>}
+ */
+export async function readRootPackageJson(rootDir) {
+  const pkgPath = join(rootDir, 'package.json')
+  if (!existsSync(pkgPath)) {
+    return {}
+  }
+  return JSON.parse(await readFile(pkgPath, 'utf-8'))
+}
+
+/**
+ * Write root package.json (2-space indent)
+ * @param {string} rootDir - Workspace root directory
+ * @param {Object} pkg - Package.json object
+ */
+export async function writeRootPackageJson(rootDir, pkg) {
+  const pkgPath = join(rootDir, 'package.json')
+  await writeFile(pkgPath, JSON.stringify(pkg, null, 2) + '\n')
+}
+
+/**
+ * Compute root scripts based on discovered sites
+ * @param {Array<{name: string, path: string}>} sites - Discovered sites
+ * @returns {Object} Scripts object for package.json
+ */
+export function computeRootScripts(sites) {
+  const scripts = {
+    build: 'uniweb build',
+  }
+
+  if (sites.length === 0) {
+    return scripts
+  }
+
+  if (sites.length === 1) {
+    scripts.dev = `pnpm --filter ${sites[0].name} dev`
+    scripts.preview = `pnpm --filter ${sites[0].name} preview`
+  } else {
+    // First site gets unqualified dev/preview
+    scripts.dev = `pnpm --filter ${sites[0].name} dev`
+    scripts.preview = `pnpm --filter ${sites[0].name} preview`
+
+    // Subsequent sites get qualified dev:{name}/preview:{name}
+    for (let i = 1; i < sites.length; i++) {
+      scripts[`dev:${sites[i].name}`] = `pnpm --filter ${sites[i].name} dev`
+      scripts[`preview:${sites[i].name}`] = `pnpm --filter ${sites[i].name} preview`
+    }
+  }
+
+  return scripts
+}
+
+/**
+ * Update root scripts after adding a new site
+ * @param {string} rootDir - Workspace root directory
+ * @param {Array<{name: string, path: string}>} sites - All sites (including new one)
+ */
+export async function updateRootScripts(rootDir, sites) {
+  const pkg = await readRootPackageJson(rootDir)
+  const newScripts = computeRootScripts(sites)
+
+  // If we're adding a second site, rename existing dev/preview to dev:{firstName}
+  if (sites.length === 2 && pkg.scripts?.dev) {
+    const firstName = sites[0].name
+    // Only rename if the existing dev matches the first site
+    if (pkg.scripts.dev === `pnpm --filter ${firstName} dev`) {
+      pkg.scripts[`dev:${firstName}`] = pkg.scripts.dev
+      pkg.scripts[`preview:${firstName}`] = pkg.scripts.preview
+    }
+  }
+
+  pkg.scripts = { ...pkg.scripts, ...newScripts }
+  await writeRootPackageJson(rootDir, pkg)
+}
+
+/**
+ * Discover foundations in the workspace
+ * @param {string} rootDir - Workspace root directory
+ * @returns {Promise<Array<{name: string, path: string}>>}
+ */
+export async function discoverFoundations(rootDir) {
+  const { packages } = await readWorkspaceConfig(rootDir)
+  const foundations = []
+
+  for (const pattern of packages) {
+    const dirs = await resolveGlob(rootDir, pattern)
+    for (const dir of dirs) {
+      const pkgPath = join(rootDir, dir, 'package.json')
+      if (!existsSync(pkgPath)) continue
+      try {
+        const pkg = JSON.parse(await readFile(pkgPath, 'utf-8'))
+        // Foundation: has @uniweb/build in devDeps but NOT @uniweb/runtime in deps
+        if (pkg.devDependencies?.['@uniweb/build'] && !pkg.dependencies?.['@uniweb/runtime']) {
+          foundations.push({ name: pkg.name, path: dir })
+        }
+      } catch {
+        // skip
+      }
+    }
+  }
+
+  return foundations
+}
+
+/**
+ * Discover sites in the workspace
+ * @param {string} rootDir - Workspace root directory
+ * @returns {Promise<Array<{name: string, path: string}>>}
+ */
+export async function discoverSites(rootDir) {
+  const { packages } = await readWorkspaceConfig(rootDir)
+  const sites = []
+
+  for (const pattern of packages) {
+    const dirs = await resolveGlob(rootDir, pattern)
+    for (const dir of dirs) {
+      const pkgPath = join(rootDir, dir, 'package.json')
+      if (!existsSync(pkgPath)) continue
+      try {
+        const pkg = JSON.parse(await readFile(pkgPath, 'utf-8'))
+        // Site: has @uniweb/runtime in deps
+        if (pkg.dependencies?.['@uniweb/runtime']) {
+          sites.push({ name: pkg.name, path: dir })
+        }
+      } catch {
+        // skip
+      }
+    }
+  }
+
+  return sites
+}
+
+// Resolve a workspace glob pattern to actual directories
+async function resolveGlob(rootDir, pattern) {
+  const clean = pattern.replace(/^["']|["']$/g, '')
+
+  if (clean.endsWith('/*')) {
+    // Pattern like "foundations/*" - list subdirectories
+    const baseDir = clean.slice(0, -2)
+    const fullPath = join(rootDir, baseDir)
+    if (!existsSync(fullPath)) return []
+    try {
+      const { readdirSync } = await import('node:fs')
+      const entries = readdirSync(fullPath, { withFileTypes: true })
+      return entries
+        .filter(e => e.isDirectory() && !e.name.startsWith('.'))
+        .map(e => join(baseDir, e.name))
+    } catch {
+      return []
+    }
+  }
+
+  if (clean.startsWith('*/')) {
+    // Pattern like "*/foundation" - find subdirs with this child
+    const suffix = clean.slice(2)
+    const { readdirSync } = await import('node:fs')
+    try {
+      const entries = readdirSync(rootDir, { withFileTypes: true })
+      return entries
+        .filter(e => e.isDirectory() && !e.name.startsWith('.') && e.name !== 'node_modules')
+        .filter(e => existsSync(join(rootDir, e.name, suffix)))
+        .map(e => join(e.name, suffix))
+    } catch {
+      return []
+    }
+  }
+
+  // Direct path like "foundation" or "site"
+  if (existsSync(join(rootDir, clean))) {
+    return [clean]
+  }
+
+  return []
+}

package/src/utils/scaffold.js

@@ -0,0 +1,175 @@
+/**
+ * Scaffolding Utilities
+ *
+ * Shared scaffolding functions used by both `create` and `add` commands.
+ * Each function scaffolds a single package from its package template.
+ */
+
+import fs from 'node:fs/promises'
+import { existsSync, readdirSync } from 'node:fs'
+import { join, dirname } from 'node:path'
+import { fileURLToPath } from 'node:url'
+import { copyTemplateDirectory, registerVersions } from '../templates/processor.js'
+import { getVersionsForTemplates } from '../versions.js'
+
+const __dirname = dirname(fileURLToPath(import.meta.url))
+const TEMPLATES_DIR = join(__dirname, '..', '..', 'templates')
+const STARTER_DIR = join(__dirname, '..', '..', 'starter')
+
+/**
+ * Scaffold a workspace root from the workspace package template
+ *
+ * @param {string} targetDir - Target directory
+ * @param {Object} context - Template context
+ * @param {string} context.projectName - Workspace/project name
+ * @param {string[]} context.workspaceGlobs - Workspace glob patterns
+ * @param {Object} context.scripts - Root package.json scripts
+ * @param {Object} [options] - Processing options
+ */
+export async function scaffoldWorkspace(targetDir, context, options = {}) {
+  registerVersions(getVersionsForTemplates())
+
+  const templatePath = join(TEMPLATES_DIR, 'workspace')
+  await copyTemplateDirectory(templatePath, targetDir, context, {
+    onProgress: options.onProgress,
+    onWarning: options.onWarning,
+  })
+}
+
+/**
+ * Scaffold a foundation from the foundation package template
+ *
+ * @param {string} targetDir - Target directory for the foundation
+ * @param {Object} context - Template context
+ * @param {string} context.name - Package name
+ * @param {string} context.projectName - Workspace name
+ * @param {boolean} [context.isExtension] - Whether this is an extension
+ * @param {Object} [options] - Processing options
+ */
+export async function scaffoldFoundation(targetDir, context, options = {}) {
+  registerVersions(getVersionsForTemplates())
+
+  const templatePath = join(TEMPLATES_DIR, 'foundation')
+  await copyTemplateDirectory(templatePath, targetDir, context, {
+    onProgress: options.onProgress,
+    onWarning: options.onWarning,
+  })
+}
+
+/**
+ * Scaffold a site from the site package template
+ *
+ * @param {string} targetDir - Target directory for the site
+ * @param {Object} context - Template context
+ * @param {string} context.name - Package name
+ * @param {string} context.projectName - Workspace name
+ * @param {string} context.foundationName - Foundation package name
+ * @param {string} context.foundationPath - Relative file: path to foundation
+ * @param {string} [context.foundationRef] - Foundation ref for site.yml (when multiple foundations)
+ * @param {Object} [options] - Processing options
+ */
+export async function scaffoldSite(targetDir, context, options = {}) {
+  registerVersions(getVersionsForTemplates())
+
+  const templatePath = join(TEMPLATES_DIR, 'site')
+  await copyTemplateDirectory(templatePath, targetDir, context, {
+    onProgress: options.onProgress,
+    onWarning: options.onWarning,
+  })
+}
+
+/**
+ * Apply content overlay from a content directory onto a target
+ *
+ * Content files overwrite scaffolded defaults. Structural files
+ * (package.json, vite.config.js, main.js, index.html) are NOT overwritten.
+ *
+ * @param {string} contentDir - Source content directory (e.g., starter/foundation/)
+ * @param {string} targetDir - Target directory to overlay onto
+ * @param {Object} context - Handlebars context for .hbs files
+ * @param {Object} [options] - Processing options
+ */
+export async function applyContent(contentDir, targetDir, context, options = {}) {
+  if (!existsSync(contentDir)) return
+
+  registerVersions(getVersionsForTemplates())
+
+  // Structural files that content should never overwrite
+  const STRUCTURAL_FILES = new Set([
+    'package.json',
+    'vite.config.js',
+    'main.js',
+    'index.html',
+    '.gitignore',
+  ])
+
+  await copyContentRecursive(contentDir, targetDir, context, STRUCTURAL_FILES, options)
+}
+
+/**
+ * Recursively copy content files, skipping structural files
+ */
+async function copyContentRecursive(sourceDir, targetDir, context, structuralFiles, options) {
+  await fs.mkdir(targetDir, { recursive: true })
+
+  const entries = readdirSync(sourceDir, { withFileTypes: true })
+
+  for (const entry of entries) {
+    const sourcePath = join(sourceDir, entry.name)
+
+    if (entry.isDirectory()) {
+      const targetSubDir = join(targetDir, entry.name)
+      await copyContentRecursive(sourcePath, targetSubDir, context, structuralFiles, options)
+    } else {
+      // Determine the output filename (strip .hbs extension)
+      const outputName = entry.name.endsWith('.hbs')
+        ? entry.name.slice(0, -4)
+        : entry.name
+
+      // Skip structural files
+      if (structuralFiles.has(outputName)) continue
+
+      const targetPath = join(targetDir, outputName)
+
+      if (entry.name.endsWith('.hbs')) {
+        // Process through Handlebars
+        const Handlebars = (await import('handlebars')).default
+        const content = await fs.readFile(sourcePath, 'utf-8')
+        const template = Handlebars.compile(content)
+        const result = template(context)
+        await fs.writeFile(targetPath, result)
+      } else {
+        // Copy as-is
+        await fs.copyFile(sourcePath, targetPath)
+      }
+
+      if (options.onProgress) {
+        options.onProgress(`Creating ${outputName}`)
+      }
+    }
+  }
+}
+
+/**
+ * Apply the built-in starter content
+ *
+ * @param {string} projectDir - Root project directory
+ * @param {Object} context - Template context
+ * @param {Object} [options] - Processing options
+ * @param {string} [options.foundationDir] - Foundation directory name (default: 'foundation')
+ * @param {string} [options.siteDir] - Site directory name (default: 'site')
+ */
+export async function applyStarter(projectDir, context, options = {}) {
+  const foundationDir = options.foundationDir || 'foundation'
+  const siteDir = options.siteDir || 'site'
+
+  // Apply foundation starter content
+  const foundationContentDir = join(STARTER_DIR, 'foundation')
+  const foundationTargetDir = join(projectDir, foundationDir)
+  await applyContent(foundationContentDir, foundationTargetDir, context, options)
+
+  // Apply site starter content
+  const siteContentDir = join(STARTER_DIR, 'site')
+  const siteTargetDir = join(projectDir, siteDir)
+  await applyContent(siteContentDir, siteTargetDir, context, options)
+}

package/templates/{single/foundation → foundation}/package.json.hbs

@@ -1,7 +1,7 @@
 {
-  "name": "foundation",
+  "name": "{{name}}",
   "version": "0.1.0",
-  "description": "{{projectName}} foundation - Uniweb component library",
+  "description": "{{projectName}} foundation",
   "type": "module",
   "main": "./src/_entry.generated.js",
   "exports": {

package/templates/foundation/src/foundation.js.hbs

@@ -0,0 +1,7 @@
+{{#if isExtension}}
+export default {
+  extension: true,
+}
+{{else}}
+export default {}
+{{/if}}