@neuxnet/neux-cli 0.2.4 → 0.2.5

package/src/core/project.js

@@ -27,9 +27,16 @@ export async function inspectProject(options = {}) {
   const appName = options.name || effectiveProjectConfig.projectname || effectiveProjectConfig.projectName || `App ${appId || 'unknown'}`
   const entryPath = options.entryPath || appConfig.entryPagePath || pages[0] || 'pages/index'
   const hasPrivateConfig = await pathExists(projectPrivateConfigPath)
+  const diagnostics = await validateProjectConfiguration({
+    projectPath,
+    miniprogramRoot,
+    sourceRoot,
+    appConfig,
+    pages,
+  })
 
   return {
-    ok: true,
+    ok: diagnostics.every(item => item.severity !== 'error'),
     command: 'inspect',
     projectPath,
     sourceRoot,
@@ -48,7 +55,137 @@ export async function inspectProject(options = {}) {
     condition: effectiveProjectConfig.condition || {},
     neuxCli: effectiveProjectConfig.neuxCli || {},
     cliConfig,
+    diagnostics,
+  }
+}
+
+export async function validateProjectConfiguration({ projectPath, miniprogramRoot = '', sourceRoot, appConfig = {}, pages = [] } = {}) {
+  const diagnostics = []
+  projectPath ||= sourceRoot
+  const add = (severity, code, message, pathName, details = {}) => {
+    diagnostics.push({ severity, code, message, path: pathName, ...details })
+  }
+  const pageSet = new Set(pages.map(normalizeProjectPath))
+  const entryPagePath = normalizeProjectPath(appConfig.entryPagePath || pages[0])
+
+  if (!sourceRoot) {
+    add('error', 'NEUX_SOURCE_ROOT_INVALID', 'A source root is required for project validation', 'project.config.json')
+    return diagnostics
+  }
+  if (miniprogramRoot && path.isAbsolute(String(miniprogramRoot))) {
+    add('error', 'NEUX_MINIPROGRAM_ROOT_INVALID', 'miniprogramRoot must be a relative path', 'project.config.json', { value: miniprogramRoot })
+  }
+  const normalizedRoot = normalizeProjectPath(miniprogramRoot)
+  if (normalizedRoot && !isWithinProjectRoot(projectPath, sourceRoot)) {
+    add('error', 'NEUX_MINIPROGRAM_ROOT_OUTSIDE_PROJECT', 'miniprogramRoot resolves outside the project directory', 'project.config.json', { value: miniprogramRoot })
+  }
+  if (normalizedRoot && !(await pathExists(sourceRoot))) {
+    add('error', 'NEUX_MINIPROGRAM_ROOT_NOT_FOUND', `miniprogramRoot does not exist: ${miniprogramRoot}`, 'project.config.json', { value: miniprogramRoot })
+  }
+  if (appConfig.entryPagePath && !pageSet.has(entryPagePath)) {
+    add('error', 'NEUX_ENTRY_PAGE_NOT_DECLARED', `Entry page is not declared in pages: ${appConfig.entryPagePath}`, 'app.json', { value: appConfig.entryPagePath })
+  }
+
+  for (const page of pages) {
+    const normalized = normalizeProjectPath(page)
+    if (!(await hasAnyProjectFile(sourceRoot, normalized, ['.json', '.nxml', '.nxss', '.js', '.ts', '.wxml', '.wxss']))) {
+      add('error', 'NEUX_PAGE_NOT_FOUND', `Page does not exist: ${page}`, 'app.json', { value: page })
+      continue
+    }
+    const pageConfigPath = path.join(sourceRoot, `${normalized}.json`)
+    const pageConfig = await readJson(pageConfigPath, {})
+    await validateUsingComponents(pageConfig.usingComponents, path.dirname(pageConfigPath), sourceRoot, `${page}.json`, add)
   }
+
+  const tabItems = Array.isArray(appConfig.tabBar?.list) ? appConfig.tabBar.list : []
+  if (appConfig.tabBar && !Array.isArray(appConfig.tabBar.list)) {
+    add('error', 'NEUX_TABBAR_LIST_INVALID', 'tabBar.list must be an array', 'app.json')
+  }
+  if (tabItems.length > 5) add('error', 'NEUX_TABBAR_TOO_MANY_ITEMS', 'tabBar.list cannot contain more than 5 items', 'app.json', { count: tabItems.length })
+  if (appConfig.tabBar && tabItems.length === 0) add('error', 'NEUX_TABBAR_LIST_EMPTY', 'tabBar.list must contain at least one item', 'app.json')
+  for (const [index, item] of tabItems.entries()) {
+    const pagePath = normalizeProjectPath(item?.pagePath)
+    if (!pagePath) {
+      add('error', 'NEUX_TABBAR_PAGE_INVALID', `tabBar.list[${index}].pagePath must be a non-empty string`, 'app.json')
+    } else if (!pageSet.has(pagePath)) {
+      add('error', 'NEUX_TABBAR_PAGE_NOT_DECLARED', `TabBar page is not declared in pages: ${item.pagePath}`, 'app.json', { value: item.pagePath })
+    }
+    for (const field of ['iconPath', 'selectedIconPath']) {
+      if (item?.[field] && !(await pathExists(path.resolve(sourceRoot, item[field])))) {
+        add('error', 'NEUX_ASSET_NOT_FOUND', `TabBar asset does not exist: ${item[field]}`, 'app.json', { value: item[field], field })
+      }
+    }
+  }
+
+  await validateUsingComponents(appConfig.usingComponents, sourceRoot, sourceRoot, 'app.json', add)
+  const subPackages = appConfig.subPackages || appConfig.subpackages
+  if (Array.isArray(subPackages)) {
+    const roots = new Set()
+    for (const [index, subPackage] of subPackages.entries()) {
+      const root = normalizeProjectPath(subPackage?.root)
+      if (!root) {
+        add('error', 'NEUX_SUBPACKAGE_ROOT_INVALID', `subPackages[${index}].root must be a non-empty string`, 'app.json')
+        continue
+      }
+      if (roots.has(root)) add('error', 'NEUX_SUBPACKAGE_ROOT_DUPLICATE', `Duplicate subpackage root: ${root}`, 'app.json', { value: root })
+      roots.add(root)
+      for (const page of Array.isArray(subPackage.pages) ? subPackage.pages : []) {
+        const pagePath = normalizeProjectPath(path.posix.join(root, page))
+        if (pageSet.has(pagePath)) {
+          add('error', 'NEUX_PAGE_IN_MULTIPLE_PACKAGES', `Page is declared in both the main package and a subpackage: ${pagePath}`, 'app.json', { value: pagePath })
+        }
+        if (!(await hasAnyProjectFile(sourceRoot, pagePath, ['.json', '.nxml', '.nxss', '.js', '.ts', '.wxml', '.wxss']))) {
+          add('error', 'NEUX_SUBPACKAGE_PAGE_NOT_FOUND', `Subpackage page does not exist: ${pagePath}`, 'app.json', { value: pagePath })
+        }
+      }
+    }
+    const rootEntries = [...roots]
+    for (let i = 0; i < rootEntries.length; i += 1) {
+      for (let j = i + 1; j < rootEntries.length; j += 1) {
+        if (rootEntries[i].startsWith(`${rootEntries[j]}/`) || rootEntries[j].startsWith(`${rootEntries[i]}/`)) {
+          add('error', 'NEUX_SUBPACKAGE_ROOT_OVERLAP', `Subpackage roots overlap: ${rootEntries[i]} and ${rootEntries[j]}`, 'app.json')
+        }
+      }
+    }
+  }
+  return diagnostics
+}
+
+async function validateUsingComponents(usingComponents, ownerDir, sourceRoot, configPath, add) {
+  if (!usingComponents || typeof usingComponents !== 'object' || Array.isArray(usingComponents)) return
+  for (const [name, target] of Object.entries(usingComponents)) {
+    if (typeof target !== 'string' || !target.trim()) {
+      add('error', 'NEUX_COMPONENT_PATH_INVALID', `Component path must be a non-empty string: ${name}`, configPath, { value: target })
+      continue
+    }
+    if (target.startsWith('plugin://') || target.startsWith('npm:') || (!target.startsWith('.') && !target.startsWith('/'))) continue
+    const normalized = target.startsWith('/') ? target.slice(1) : path.relative(sourceRoot, path.resolve(ownerDir, target))
+    if (!(await hasAnyProjectFile(sourceRoot, normalizeProjectPath(normalized), ['.json', '.nxml', '.nxss', '.js', '.ts', '.wxml', '.wxss']))) {
+      add('error', 'NEUX_COMPONENT_NOT_FOUND', `Component does not exist: ${target}`, configPath, { value: target, component: name })
+    }
+  }
+}
+
+async function hasAnyProjectFile(sourceRoot, basePath, extensions) {
+  const candidates = [basePath]
+  const basename = path.posix.basename(basePath)
+  candidates.push(path.posix.join(basePath, basename))
+  for (const candidate of candidates) {
+    for (const extension of extensions) {
+      if (await pathExists(path.join(sourceRoot, `${candidate}${extension}`))) return true
+    }
+  }
+  return false
+}
+
+function normalizeProjectPath(value) {
+  return String(value || '').replaceAll('\\', '/').replace(/^\/+|\/+$/g, '')
+}
+
+function isWithinProjectRoot(projectPath, sourceRoot) {
+  const root = path.resolve(projectPath || sourceRoot)
+  const candidate = path.resolve(sourceRoot)
+  return candidate === root || candidate.startsWith(`${root}${path.sep}`)
 }
 
 function mergeProjectConfig(projectConfig = {}, privateConfig = {}) {

package/src/index.js

@@ -1,6 +1,6 @@
 export { buildProject, buildStyleOnlyProject, buildViewOnlyProject, buildLogicOnlyProject } from './core/compiler.js'
 export { DEFAULT_SERVER_URL, initProject } from './core/init.js'
-export { inspectProject } from './core/project.js'
+export { inspectProject, validateProjectConfiguration } from './core/project.js'
 export { packProject } from './core/pack.js'
 export { startPreview } from './core/preview-server.js'
 export { startDev } from './core/dev.js'