@neuxnet/neux-cli 0.2.3 → 0.2.5

package/src/core/init.js

@@ -3,7 +3,7 @@ import path from 'node:path'
 import { fileURLToPath } from 'node:url'
 import { DiminaCliError } from './errors.js'
 import { pathExists, resolvePath, writeJson } from './fs.js'
-import { getCliVersion } from './package-info.js'
+import { getCliPackageInfo } from './package-info.js'
 import { saveCliKey } from '../providers/service-config.js'
 import { promptLines, shouldPrompt } from './prompts.js'
 
@@ -12,7 +12,6 @@ const DEFAULT_LIB_VERSION = '3.3.3'
 export const DEFAULT_SERVER_URL = 'https://demo-c.paas.superapp.neuvision.cn'
 const CLI_PACKAGE_NAME = '@neuxnet/neux-cli'
 const TEMPLATE_ASSET_DIR = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '../../assets/init')
-const DEFAULT_DOCS_BASE_URL = `${DEFAULT_SERVER_URL}/miniappdoc`
 
 export async function initProject(options = {}) {
   const targetArg = options._?.[0] || options.project || '.'
@@ -25,8 +24,14 @@ export async function initProject(options = {}) {
   const appId = options.appId || prompts.appId || DEFAULT_APP_ID
   const serverUrl = options.serverUrl || prompts.serverUrl || DEFAULT_SERVER_URL
   const cliKey = options.key || prompts.cliKey
-  const cliVersion = await getCliVersion()
-  const files = createTemplateFiles({ appId, projectName, serverUrl, cliVersion })
+  const cliPackage = await getCliPackageInfo()
+  const files = createTemplateFiles({
+    appId,
+    projectName,
+    serverUrl,
+    cliVersion: cliPackage.version,
+    typesPackage: cliPackage.typesPackage,
+  })
 
   for (const file of files) {
     const filePath = path.join(projectPath, file.path)
@@ -36,9 +41,7 @@ export async function initProject(options = {}) {
       await fs.mkdir(path.dirname(filePath), { recursive: true })
       const sourcePath = path.join(TEMPLATE_ASSET_DIR, file.source)
       if (file.source === 'types/neux-api.d.ts') {
-        const docsBaseUrl = `${String(serverUrl || DEFAULT_SERVER_URL).replace(/\/+$/, '')}/miniappdoc`
-        const content = await fs.readFile(sourcePath, 'utf8')
-        await fs.writeFile(filePath, content.replaceAll(DEFAULT_DOCS_BASE_URL, docsBaseUrl), 'utf8')
+        await fs.writeFile(filePath, `/// <reference types="${file.typesPackage.name}" />\n`, 'utf8')
       }
       else await fs.copyFile(sourcePath, filePath)
     }
@@ -136,13 +139,45 @@ async function mergeJsonFile(filePath, generated) {
       ...(existing['files.associations'] || {}),
     }
   }
+  if (generated?.['json.schemas'] || existing?.['json.schemas']) {
+    const generatedSchemas = Array.isArray(generated?.['json.schemas']) ? generated['json.schemas'] : []
+    const existingSchemas = Array.isArray(existing?.['json.schemas']) ? existing['json.schemas'] : []
+    const keys = new Set()
+    merged['json.schemas'] = [...generatedSchemas, ...existingSchemas].filter(schema => {
+      const key = `${schema?.url || ''}|${JSON.stringify(schema?.fileMatch || [])}`
+      if (keys.has(key)) return false
+      keys.add(key)
+      return true
+    })
+  }
+  if (generated?.['html.customData'] || existing?.['html.customData']) {
+    merged['html.customData'] = [
+      ...new Set([
+        ...(Array.isArray(generated?.['html.customData']) ? generated['html.customData'] : []),
+        ...(Array.isArray(existing?.['html.customData']) ? existing['html.customData'] : []),
+      ]),
+    ]
+  }
   if (filePath.endsWith('neux.code-snippets')) {
     Object.assign(merged, generated || {}, existing || {})
   }
   await writeJson(filePath, merged)
 }
 
-function createTemplateFiles({ appId, projectName, serverUrl = DEFAULT_SERVER_URL, cliVersion }) {
+function createTemplateFiles({
+  appId,
+  projectName,
+  serverUrl = DEFAULT_SERVER_URL,
+  cliVersion,
+  typesPackage,
+}) {
+  if (!typesPackage?.name || !typesPackage?.versionRange) {
+    throw new DiminaCliError(
+      'NEUX_CLI_TYPES_PACKAGE_METADATA_MISSING',
+      'The CLI package does not declare a compatible miniapp types package.',
+    )
+  }
+
   return [
     {
       path: 'project.config.json',
@@ -198,6 +233,7 @@ function createTemplateFiles({ appId, projectName, serverUrl = DEFAULT_SERVER_UR
         },
         devDependencies: {
           [CLI_PACKAGE_NAME]: `^${cliVersion}`,
+          [typesPackage.name]: typesPackage.versionRange,
         },
       },
     },
@@ -260,8 +296,21 @@ function createTemplateFiles({ appId, projectName, serverUrl = DEFAULT_SERVER_UR
           '*.nxml': 'html',
           '*.nxss': 'css',
         },
+        'json.schemas': createJsonSchemaSettings(),
+        'html.customData': ['./.vscode/neux-html-data.json'],
       },
     },
+    {
+      path: '.vscode/neux-html-data.json',
+      kind: 'asset',
+      source: 'neux-html-data.json',
+    },
+    {
+      path: '.vscode/neux-components.code-snippets',
+      kind: 'asset',
+      source: 'neux-components.code-snippets',
+    },
+    ...createJsonSchemaFiles(),
     {
       path: '.vscode/neux.code-snippets',
       kind: 'merge-json',
@@ -276,11 +325,17 @@ function createTemplateFiles({ appId, projectName, serverUrl = DEFAULT_SERVER_UR
           checkJs: false,
           noEmit: true,
           target: 'ES2020',
+          types: [typesPackage.name],
         },
         include: ['**/*.js', '**/*.ts', 'types/**/*.d.ts'],
       },
     },
-    { path: 'types/neux-api.d.ts', kind: 'asset', source: 'types/neux-api.d.ts' },
+    {
+      path: 'types/neux-api.d.ts',
+      kind: 'asset',
+      source: 'types/neux-api.d.ts',
+      typesPackage,
+    },
     { path: 'assets/tabbar/home.png', kind: 'asset', source: 'tabbar/home.png' },
     { path: 'assets/tabbar/home-active.png', kind: 'asset', source: 'tabbar/home-active.png' },
     { path: 'assets/tabbar/list.png', kind: 'asset', source: 'tabbar/list.png' },
@@ -522,6 +577,30 @@ function createTemplateFiles({ appId, projectName, serverUrl = DEFAULT_SERVER_UR
   ]
 }
 
+function createJsonSchemaSettings() {
+  return [
+    { fileMatch: ['/app.json'], url: './.vscode/neux-json-schemas/app.schema.json' },
+    { fileMatch: ['/pages/**/*.json', '/components/**/*.json'], url: './.vscode/neux-json-schemas/page.schema.json' },
+    { fileMatch: ['/project.config.json'], url: './.vscode/neux-json-schemas/project-config.schema.json' },
+    { fileMatch: ['/project.private.config.json'], url: './.vscode/neux-json-schemas/project-private-config.schema.json' },
+    { fileMatch: ['/neux.config.json'], url: './.vscode/neux-json-schemas/neux-config.schema.json' },
+  ]
+}
+
+function createJsonSchemaFiles() {
+  return [
+    'app.schema.json',
+    'page.schema.json',
+    'project-config.schema.json',
+    'project-private-config.schema.json',
+    'neux-config.schema.json',
+  ].map(name => ({
+    path: `.vscode/neux-json-schemas/${name}`,
+    kind: 'asset',
+    source: `schemas/${name}`,
+  }))
+}
+
 function escapeJsString(value) {
   return String(value).replaceAll('\\', '\\\\').replaceAll("'", "\\'")
 }
@@ -759,13 +838,6 @@ function createNeuxCodeSnippets() {
       body: ['<view nx:if="{{${1:visible}}}">', '  ${0}', '</view>'],
       description: 'Render a view conditionally',
     },
-    'Tap Button': {
-      prefix: 'nxbutton',
-      scope: 'html',
-      include: ['**/*.nxml'],
-      body: ['<button bindtap="${1:handleTap}">${2:Button}</button>$0'],
-      description: 'Insert a button with a tap handler',
-    },
     'Page View': {
       prefix: 'nxview',
       scope: 'html',

package/src/core/package-info.js

@@ -15,6 +15,7 @@ export async function getCliPackageInfo() {
     packageName: packageJson.name || brand.packageName,
     version: packageJson.version,
     packageRoot,
+    typesPackage: packageJson.neux?.typesPackage || null,
   }
 }
 

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'