@neuxnet/neux-cli 0.2.3

package/src/core/compiler.js

@@ -0,0 +1,305 @@
+import path from 'node:path'
+import fs from 'node:fs/promises'
+import { pathToFileURL } from 'node:url'
+import { DiminaCliError } from './errors.js'
+import { inspectProject } from './project.js'
+import { copyDir, pathExists, readJson, resolvePath, writeJson } from './fs.js'
+import { defaultOut } from './defaults.js'
+import { brand } from './brand.js'
+
+const bundledCompilerPath = new URL('../../vendor/dimina-compiler/index.js', import.meta.url)
+const NEUX_FILE_TYPES = {
+  template: ['.nxml'],
+  style: ['.nxss'],
+}
+
+function compilerOptions(options = {}, extra = {}) {
+  return {
+    ...extra,
+    fileTypes: {
+      ...NEUX_FILE_TYPES,
+      ...(options.fileTypes || {}),
+      template: [...new Set([...(NEUX_FILE_TYPES.template || []), ...(options.fileTypes?.template || [])])],
+      style: [...new Set([...(NEUX_FILE_TYPES.style || []), ...(options.fileTypes?.style || [])])],
+    },
+    sourcemap: !!options.sourcemap,
+    lang: options.lang || process.env.NEUX_CLI_LANG || 'en',
+    signal: options.signal,
+  }
+}
+
+async function loadCompiler(moduleSpecifier) {
+  try {
+    if (moduleSpecifier) {
+      const resolved = path.isAbsolute(moduleSpecifier)
+        ? pathToFileURL(moduleSpecifier).href
+        : pathToFileURL(path.resolve(process.cwd(), moduleSpecifier)).href
+      return await import(resolved)
+    }
+    return await import(bundledCompilerPath.href)
+  }
+  catch (error) {
+    throw new DiminaCliError(
+      'DIMINA_COMPILER_NOT_FOUND',
+      `Unable to load bundled ${brand.compilerPackageName}. Run npm run sync:compiler before packing, or pass --compiler-module for a custom compiler.`,
+      { cause: error.message },
+    )
+  }
+}
+
+export async function buildProject(options = {}) {
+  const projectInfo = await inspectProject(options)
+  const out = resolvePath(options.out || options.output || defaultOut('build'))
+  const compilerModule = options.compiler || await loadCompiler(options.compilerModule || process.env.DIMINA_COMPILER_MODULE)
+  const build = compilerModule.default || compilerModule.build || compilerModule
+
+  if (typeof build !== 'function') {
+    throw new DiminaCliError('DIMINA_COMPILER_INVALID', `${brand.compilerPackageName} does not expose a callable build function`)
+  }
+
+  let compilerResult
+  const logs = []
+  const errors = []
+  const compilerInput = await prepareCompilerInput(projectInfo, out, options)
+  try {
+    compilerResult = await withCompilerLogCapture(options, logs, errors, () => build(
+      out,
+      compilerInput.projectPath,
+      options.appIdDir !== false,
+      compilerOptions(options),
+    ))
+  }
+  catch (error) {
+    errors.push(error.message)
+    throw new DiminaCliError('DIMINA_BUILD_FAILED', `Dimina compiler failed: ${error.message}`, {
+      cause: error.message,
+      compilerInputPath: compilerInput.projectPath,
+    })
+  }
+
+  if (compilerResult === undefined && options.strict !== false) {
+    throw new DiminaCliError('DIMINA_BUILD_FAILED', 'Dimina compiler finished without a build result', {
+      compilerInputPath: compilerInput.projectPath,
+    })
+  }
+
+  return {
+    ok: true,
+    command: 'build',
+    projectPath: projectInfo.projectPath,
+    sourceRoot: projectInfo.sourceRoot,
+    compilerInputPath: compilerInput.projectPath,
+    compilerInputCreated: compilerInput.created,
+    outputPath: out,
+    appId: projectInfo.appId,
+    compilerResult,
+    logs,
+    errors,
+  }
+}
+
+export async function buildStyleOnlyProject(options = {}) {
+  const projectInfo = await inspectProject(options)
+  const out = resolvePath(options.out || options.output || defaultOut('build'))
+  const compilerModule = options.compiler || await loadCompiler(options.compilerModule || process.env.DIMINA_COMPILER_MODULE)
+  const buildStyleOnly = compilerModule.buildStyleOnly
+
+  if (typeof buildStyleOnly !== 'function') {
+    throw new DiminaCliError('DIMINA_STYLE_BUILD_UNAVAILABLE', `${brand.compilerPackageName} does not expose buildStyleOnly`)
+  }
+
+  const logs = []
+  const errors = []
+  const compilerInput = await prepareCompilerInput(projectInfo, out, options)
+  let compilerResult
+  try {
+    compilerResult = await withCompilerLogCapture(options, logs, errors, () => buildStyleOnly(out, compilerInput.projectPath, options.appIdDir !== false, compilerOptions(options, {
+      changedPath: options.changedPath,
+    })))
+  }
+  catch (error) {
+    errors.push(error.message)
+    throw new DiminaCliError('DIMINA_STYLE_BUILD_FAILED', `Dimina style compiler failed: ${error.message}`, {
+      cause: error.message,
+      compilerInputPath: compilerInput.projectPath,
+    })
+  }
+
+  return {
+    ok: true,
+    command: 'build-style',
+    styleOnly: true,
+    projectPath: projectInfo.projectPath,
+    sourceRoot: projectInfo.sourceRoot,
+    compilerInputPath: compilerInput.projectPath,
+    compilerInputCreated: compilerInput.created,
+    outputPath: out,
+    appId: projectInfo.appId,
+    compilerResult,
+    logs,
+    errors,
+    ...compilerResult,
+  }
+}
+
+export async function buildViewOnlyProject(options = {}) {
+  const projectInfo = await inspectProject(options)
+  const out = resolvePath(options.out || options.output || defaultOut('build'))
+  const compilerModule = options.compiler || await loadCompiler(options.compilerModule || process.env.DIMINA_COMPILER_MODULE)
+  const buildViewOnly = compilerModule.buildViewOnly
+
+  if (typeof buildViewOnly !== 'function') {
+    throw new DiminaCliError('DIMINA_VIEW_BUILD_UNAVAILABLE', `${brand.compilerPackageName} does not expose buildViewOnly`)
+  }
+
+  const logs = []
+  const errors = []
+  const compilerInput = await prepareCompilerInput(projectInfo, out, options)
+  let compilerResult
+  try {
+    compilerResult = await withCompilerLogCapture(options, logs, errors, () => buildViewOnly(out, compilerInput.projectPath, options.appIdDir !== false, compilerOptions(options, {
+      changedPath: options.changedPath,
+    })))
+  }
+  catch (error) {
+    errors.push(error.message)
+    throw new DiminaCliError('DIMINA_VIEW_BUILD_FAILED', `Dimina view compiler failed: ${error.message}`, {
+      cause: error.message,
+      compilerInputPath: compilerInput.projectPath,
+    })
+  }
+
+  return {
+    ok: true,
+    command: 'build-view',
+    viewOnly: true,
+    projectPath: projectInfo.projectPath,
+    sourceRoot: projectInfo.sourceRoot,
+    compilerInputPath: compilerInput.projectPath,
+    compilerInputCreated: compilerInput.created,
+    outputPath: out,
+    appId: projectInfo.appId,
+    compilerResult,
+    logs,
+    errors,
+    ...compilerResult,
+  }
+}
+
+export async function buildLogicOnlyProject(options = {}) {
+  const projectInfo = await inspectProject(options)
+  const out = resolvePath(options.out || options.output || defaultOut('build'))
+  const compilerModule = options.compiler || await loadCompiler(options.compilerModule || process.env.DIMINA_COMPILER_MODULE)
+  const buildLogicOnly = compilerModule.buildLogicOnly
+
+  if (typeof buildLogicOnly !== 'function') {
+    throw new DiminaCliError('DIMINA_LOGIC_BUILD_UNAVAILABLE', `${brand.compilerPackageName} does not expose buildLogicOnly`)
+  }
+
+  const logs = []
+  const errors = []
+  const compilerInput = await prepareCompilerInput(projectInfo, out, options)
+  let compilerResult
+  try {
+    compilerResult = await withCompilerLogCapture(options, logs, errors, () => buildLogicOnly(out, compilerInput.projectPath, options.appIdDir !== false, compilerOptions(options, {
+      changedPath: options.changedPath,
+    })))
+  }
+  catch (error) {
+    errors.push(error.message)
+    throw new DiminaCliError('DIMINA_LOGIC_BUILD_FAILED', `Dimina logic compiler failed: ${error.message}`, {
+      cause: error.message,
+      compilerInputPath: compilerInput.projectPath,
+    })
+  }
+
+  return {
+    ok: true,
+    command: 'build-logic',
+    logicOnly: true,
+    projectPath: projectInfo.projectPath,
+    sourceRoot: projectInfo.sourceRoot,
+    compilerInputPath: compilerInput.projectPath,
+    compilerInputCreated: compilerInput.created,
+    outputPath: out,
+    appId: projectInfo.appId,
+    compilerResult,
+    logs,
+    errors,
+    ...compilerResult,
+  }
+}
+
+async function prepareCompilerInput(projectInfo, out, options) {
+  if (!projectInfo.miniprogramRoot || path.resolve(projectInfo.projectPath) === path.resolve(projectInfo.sourceRoot)) {
+    return {
+      projectPath: projectInfo.projectPath,
+      created: false,
+    }
+  }
+
+  const inputRoot = resolvePath(
+    options.compilerInputRoot,
+    path.join(path.dirname(out), `${path.basename(out)}.compiler-input`),
+  )
+  await fs.rm(inputRoot, { recursive: true, force: true })
+  await copyDir(projectInfo.sourceRoot, inputRoot)
+
+  const projectConfig = await readJson(projectInfo.projectConfigPath)
+  projectConfig.miniprogramRoot = ''
+  await writeJson(path.join(inputRoot, 'project.config.json'), projectConfig)
+
+  const privateConfigPath = path.join(projectInfo.projectPath, 'project.private.config.json')
+  if (await pathExists(privateConfigPath)) {
+    await fs.copyFile(privateConfigPath, path.join(inputRoot, 'project.private.config.json'))
+  }
+
+  return {
+    projectPath: inputRoot,
+    created: true,
+  }
+}
+
+async function withCompilerLogCapture(options, logs, errors, action) {
+  if (!options.captureLogs && typeof options.onLog !== 'function') {
+    return await action()
+  }
+
+  const restore = []
+  const capture = (stream, level) => {
+    const originalWrite = stream.write.bind(stream)
+    stream.write = (chunk, encoding, callback) => {
+      for (const message of normalizeLogLines(chunk)) {
+        const record = {
+          source: 'compiler',
+          level,
+          message,
+          timestamp: Date.now(),
+        }
+        logs.push(record)
+        if (level === 'error') errors.push(message)
+        options.onLog?.(record)
+      }
+      return originalWrite(chunk, encoding, callback)
+    }
+    restore.push(() => {
+      stream.write = originalWrite
+    })
+  }
+
+  capture(process.stdout, 'info')
+  capture(process.stderr, 'error')
+  try {
+    return await action()
+  }
+  finally {
+    for (const restoreWrite of restore.reverse()) restoreWrite()
+  }
+}
+
+function normalizeLogLines(chunk) {
+  return String(Buffer.isBuffer(chunk) ? chunk.toString('utf8') : chunk)
+    .split(/\r?\n/)
+    .map(line => line.trim())
+    .filter(Boolean)
+}

package/src/core/defaults.js

@@ -0,0 +1,12 @@
+export const defaultOutputDirs = {
+  build: 'dist/release',
+  compile: 'dist/build',
+  dev: 'dist/dev',
+  pack: 'dist/pack',
+  preview: 'dist/preview',
+  web: 'dist/web',
+}
+
+export function defaultOut(command) {
+  return defaultOutputDirs[command] || 'dist'
+}

package/src/core/dev.js

@@ -0,0 +1,15 @@
+import { startWeb } from './web.js'
+
+export async function startDev(options = {}) {
+  const session = await startWeb({
+    ...options,
+    command: 'dev',
+    watch: true,
+  })
+
+  return {
+    ...session,
+    command: 'dev',
+    watch: true,
+  }
+}

package/src/core/errors.js

@@ -0,0 +1,17 @@
+export class DiminaCliError extends Error {
+  constructor(code, message, details = {}) {
+    super(message)
+    this.name = 'DiminaCliError'
+    this.code = code
+    this.details = details
+  }
+}
+
+export function toErrorPayload(error) {
+  return {
+    ok: false,
+    code: error?.code || 'DIMINA_UNKNOWN_ERROR',
+    message: error?.message || String(error),
+    details: error?.details || undefined,
+  }
+}

package/src/core/fs.js

@@ -0,0 +1,66 @@
+import fs from 'node:fs/promises'
+import path from 'node:path'
+
+export function resolvePath(value, fallback = process.cwd()) {
+  return path.resolve(value || fallback)
+}
+
+export async function pathExists(filePath) {
+  try {
+    await fs.access(filePath)
+    return true
+  }
+  catch {
+    return false
+  }
+}
+
+export async function readJson(filePath, fallback = null) {
+  try {
+    return JSON.parse(await fs.readFile(filePath, 'utf8'))
+  }
+  catch (error) {
+    if (fallback !== null && error.code === 'ENOENT') return fallback
+    throw error
+  }
+}
+
+export async function writeJson(filePath, value) {
+  await fs.mkdir(path.dirname(filePath), { recursive: true })
+  await fs.writeFile(filePath, `${JSON.stringify(value, null, 2)}\n`, 'utf8')
+}
+
+export async function copyDir(sourceDir, targetDir) {
+  const entries = await fs.readdir(sourceDir, { withFileTypes: true })
+  await fs.mkdir(targetDir, { recursive: true })
+  for (const entry of entries) {
+    const sourcePath = path.join(sourceDir, entry.name)
+    const targetPath = path.join(targetDir, entry.name)
+    if (entry.isDirectory()) {
+      await copyDir(sourcePath, targetPath)
+    }
+    else if (entry.isFile()) {
+      await fs.copyFile(sourcePath, targetPath)
+    }
+  }
+}
+
+export async function listFiles(rootDir) {
+  const files = []
+
+  async function walk(currentDir) {
+    const entries = await fs.readdir(currentDir, { withFileTypes: true })
+    for (const entry of entries) {
+      const absolute = path.join(currentDir, entry.name)
+      if (entry.isDirectory()) {
+        await walk(absolute)
+      }
+      else if (entry.isFile()) {
+        files.push(absolute)
+      }
+    }
+  }
+
+  await walk(rootDir)
+  return files.sort()
+}

package/src/core/i18n.js

@@ -0,0 +1,37 @@
+const messages = {
+  en: {
+    usage: 'Usage',
+    commands: 'Commands',
+    commonOptions: 'Common options',
+    initOk: 'init ok',
+    outputPath: 'outputPath',
+    outputDir: 'outputDir',
+    packagePath: 'packagePath',
+    serverUrl: 'serverUrl',
+    suggestedFixes: 'Suggested fixes:',
+  },
+  'zh-CN': {
+    usage: '用法',
+    commands: '命令',
+    commonOptions: '通用选项',
+    initOk: 'init 完成',
+    outputPath: '输出路径',
+    outputDir: '输出目录',
+    packagePath: '包路径',
+    serverUrl: '服务地址',
+    suggestedFixes: '建议处理方式：',
+  },
+}
+
+export function normalizeLocale(value) {
+  return String(value || '').toLowerCase().startsWith('zh') ? 'zh-CN' : 'en'
+}
+
+export function resolveLocale(options = {}) {
+  return normalizeLocale(options.lang || process.env.NEUX_CLI_LANG || 'en')
+}
+
+export function translate(locale, key) {
+  const dictionary = messages[normalizeLocale(locale)] || messages.en
+  return dictionary[key] || messages.en[key] || key
+}