@ohos-rs/oxk 0.5.0 → 0.7.0

package/bin/format.js

@@ -1,236 +1,8 @@
-const { existsSync, readFileSync, writeFileSync } = require('node:fs')
-const path = require('node:path')
-const { glob } = require('glob')
+const { formatFiles: nativeFormatFiles } = require('../format.js')
 
-const { format } = require('../format.js')
-
-const CONFIG_FILES = ['.oxfmtrc.json', '.oxfmtrc.jsonc']
-const RECOVERABLE_ERROR_PATTERNS = [
-  'Unsupported file type',
-  'requires external formatter support',
-  'External formatter is required',
-]
-
-function stripJsonComments(text) {
-  let result = ''
-  let inString = false
-  let stringQuote = ''
-  let isEscaped = false
-  let inLineComment = false
-  let inBlockComment = false
-
-  for (let index = 0; index < text.length; index += 1) {
-    const char = text[index]
-    const next = text[index + 1]
-
-    if (inLineComment) {
-      if (char === '\n') {
-        inLineComment = false
-        result += char
-      }
-      continue
-    }
-
-    if (inBlockComment) {
-      if (char === '*' && next === '/') {
-        inBlockComment = false
-        index += 1
-      }
-      continue
-    }
-
-    if (inString) {
-      result += char
-      if (isEscaped) {
-        isEscaped = false
-      } else if (char === '\\') {
-        isEscaped = true
-      } else if (char === stringQuote) {
-        inString = false
-        stringQuote = ''
-      }
-      continue
-    }
-
-    if (char === '"' || char === "'") {
-      inString = true
-      stringQuote = char
-      result += char
-      continue
-    }
-
-    if (char === '/' && next === '/') {
-      inLineComment = true
-      index += 1
-      continue
-    }
-
-    if (char === '/' && next === '*') {
-      inBlockComment = true
-      index += 1
-      continue
-    }
-
-    result += char
-  }
-
-  return result
-}
-
-function resolveConfigPath(cwd, explicitPath) {
-  if (explicitPath) {
-    const resolved = path.resolve(cwd, explicitPath)
-    if (!existsSync(resolved)) {
-      throw new Error(`Failed to read ${resolved}: File not found`)
-    }
-    return resolved
-  }
-
-  let current = cwd
-  for (;;) {
-    for (const filename of CONFIG_FILES) {
-      const candidate = path.join(current, filename)
-      if (existsSync(candidate)) {
-        return candidate
-      }
-    }
-
-    const parent = path.dirname(current)
-    if (parent === current) {
-      return undefined
-    }
-    current = parent
-  }
-}
-
-function loadConfig(cwd, explicitPath) {
-  const configPath = resolveConfigPath(cwd, explicitPath)
-  if (!configPath) {
-    return { config: {}, ignorePatterns: [] }
-  }
-
-  const raw = readFileSync(configPath, 'utf8')
-  const parsed = JSON.parse(stripJsonComments(raw))
-  const ignorePatterns = Array.isArray(parsed.ignorePatterns) ? parsed.ignorePatterns : []
-  return { config: parsed, ignorePatterns }
-}
-
-function mergeConfig(baseConfig, cliOptions) {
-  return { ...baseConfig, ...cliOptions }
-}
-
-async function expandPatterns(patterns, cwd) {
-  const results = new Set()
-
-  for (const pattern of patterns) {
-    const absolutePattern = path.resolve(cwd, pattern)
-    const matches = await glob(absolutePattern, {
-      absolute: true,
-      dot: true,
-      nodir: true,
-      follow: false,
-    })
-
-    for (const match of matches) {
-      results.add(path.resolve(match))
-    }
-  }
-
-  return results
-}
-
-function isRecoverableError(errors) {
-  return errors.every((error) => RECOVERABLE_ERROR_PATTERNS.some((pattern) => error.includes(pattern)))
-}
-
-async function runWithConcurrency(items, limit, worker) {
-  let index = 0
-  const workers = Array.from({ length: Math.max(1, Math.min(limit, items.length || 1)) }, async () => {
-    for (;;) {
-      const current = index
-      index += 1
-      if (current >= items.length) {
-        return
-      }
-      await worker(items[current])
-    }
-  })
-
-  await Promise.all(workers)
-}
-
-function printErrors(filePath, errors, prefix) {
-  console.error(`${prefix} ${filePath}:`)
-  for (const error of errors) {
-    console.error(`  ${error}`)
-  }
-}
-
-async function formatFiles({ patterns, configPath, excludes, threadCount, cliOptions }) {
-  const cwd = process.cwd()
-
-  if (patterns.length === 0) {
-    throw new Error('Missing file pattern')
-  }
-
-  const { config, ignorePatterns } = loadConfig(cwd, configPath)
-  const mergedConfig = mergeConfig(config, cliOptions)
-  const allExcludes = excludes.concat(ignorePatterns)
-
-  const files = await expandPatterns(patterns, cwd)
-  if (allExcludes.length > 0) {
-    const excludedFiles = await expandPatterns(allExcludes, cwd)
-    for (const excluded of excludedFiles) {
-      files.delete(excluded)
-    }
-  }
-
-  const sortedFiles = Array.from(files).sort()
-  if (sortedFiles.length === 0) {
-    throw new Error('No files matched the provided patterns (after excludes)')
-  }
-
-  let formattedCount = 0
-  let hasRecoverableErrors = false
-  let fatalError = null
-
-  await runWithConcurrency(sortedFiles, threadCount, async (filePath) => {
-    if (fatalError) {
-      return
-    }
-
-    const sourceText = readFileSync(filePath, 'utf8')
-    if (sourceText.length === 0) {
-      return
-    }
-
-    const displayPath = path.relative(cwd, filePath) || filePath
-    const result = await format(displayPath, sourceText, mergedConfig)
-
-    if (result.errors.length === 0) {
-      writeFileSync(filePath, result.code, 'utf8')
-      console.log(`Formatted: ${displayPath}`)
-      formattedCount += 1
-      return
-    }
-
-    if (isRecoverableError(result.errors)) {
-      printErrors(displayPath, result.errors, 'Warning formatting')
-      hasRecoverableErrors = true
-      return
-    }
-
-    fatalError = { filePath: displayPath, errors: result.errors }
-  })
-
-  if (fatalError) {
-    printErrors(fatalError.filePath, fatalError.errors, 'Error formatting')
-    process.exitCode = 1
-    return
-  }
-
-  console.log(`\nFormatted ${formattedCount} file(s)`)
-  if (hasRecoverableErrors) {
+async function formatFiles(args) {
+  const success = await nativeFormatFiles(args)
+  if (!success) {
     process.exitCode = 1
   }
 }

package/bin/oxk.js

@@ -2,6 +2,7 @@
 
 const VERSION = require('../package.json').version
 const { formatFiles } = require('./format.js')
+const { formatLsp } = require('../index.js')
 const { lint } = require('../lint.js')
 
 function parseBoolean(value, flagName) {
@@ -55,9 +56,12 @@ Lint Options:
   Run "oxk lint --help" for the full lint option list.
 
 Format Options:
+  --lsp
   --config PATH
   --thread, -t THREAD
   --exclude PATTERN
+  --ignore-path PATH
+  --with-node-modules
   --indent-style STYLE
   --indent-width WIDTH
   --line-ending ENDING
@@ -92,8 +96,11 @@ function parseFormatArgs(args) {
   const formatArgs = {
     patterns: [],
     excludes: [],
+    ignorePaths: [],
+    withNodeModules: false,
     threadCount: 1,
     configPath: undefined,
+    lsp: false,
     cliOptions: {},
   }
 
@@ -110,6 +117,10 @@ function parseFormatArgs(args) {
     }
 
     switch (token.split('=')[0]) {
+      case '--lsp': {
+        formatArgs.lsp = true
+        break
+      }
       case '--config': {
         const { value, nextIndex } = parseOptionValue(args, index, token)
         formatArgs.configPath = value
@@ -129,6 +140,16 @@ function parseFormatArgs(args) {
         index = nextIndex
         break
       }
+      case '--ignore-path': {
+        const { value, nextIndex } = parseOptionValue(args, index, token)
+        formatArgs.ignorePaths.push(value)
+        index = nextIndex
+        break
+      }
+      case '--with-node-modules': {
+        formatArgs.withNodeModules = true
+        break
+      }
       case '--indent-style': {
         const { value, nextIndex } = parseOptionValue(args, index, token)
         if (value !== 'tab' && value !== 'space') {
@@ -298,6 +319,14 @@ async function main() {
       process.exit(0)
     }
 
+    if (formatArgs.lsp) {
+      if (typeof formatLsp !== 'function') {
+        throw new Error('oxk format --lsp requires the native oxk binding')
+      }
+      await formatLsp()
+      return
+    }
+
     await formatFiles(formatArgs)
   } catch (error) {
     console.error(error instanceof Error ? error.message : String(error))