@napi-rs/cli 3.0.0-alpha.80 → 3.0.0-alpha.82

package/src/utils/metadata.ts

@@ -1,4 +1,4 @@
-import { spawnSync } from 'node:child_process'
+import { spawn } from 'node:child_process'
 import fs from 'node:fs'
 
 export type CrateTargetKind =
@@ -48,24 +48,37 @@ export interface CargoWorkspaceMetadata {
   workspace_root: string
 }
 
-export function parseMetadata(manifestPath: string) {
+export async function parseMetadata(manifestPath: string) {
   if (!fs.existsSync(manifestPath)) {
     throw new Error(`No crate found in manifest: ${manifestPath}`)
   }
 
-  const { stdout, stderr, status, error } = spawnSync(
+  const childProcess = spawn(
     'cargo',
-    [
-      'metadata',
-      '--manifest-path',
-      manifestPath,
-      '--format-version',
-      '1',
-      '--no-deps',
-    ],
-    { encoding: 'utf-8' },
+    ['metadata', '--manifest-path', manifestPath, '--format-version', '1'],
+    { stdio: 'pipe' },
   )
 
+  let stdout = ''
+  let stderr = ''
+  let status = 0
+  let error = null
+
+  childProcess.stdout.on('data', (data) => {
+    stdout += data
+  })
+
+  childProcess.stderr.on('data', (data) => {
+    stderr += data
+  })
+
+  await new Promise<void>((resolve) => {
+    childProcess.on('close', (code) => {
+      status = code ?? 0
+      resolve()
+    })
+  })
+
   if (error) {
     throw new Error('cargo metadata failed to run', { cause: error })
   }

package/src/utils/misc.ts

@@ -7,19 +7,11 @@ import {
   stat,
   readdir,
 } from 'node:fs'
-import { createRequire } from 'node:module'
 import { promisify } from 'node:util'
 
+import pkgJson from '../../package.json' with { type: 'json' }
 import { debug } from './log.js'
 
-const require = createRequire(import.meta.url)
-// NOTE:
-//   import pkgJson from '@napi-rs/cli/package.json' assert { type: 'json' }
-//   is experimental feature now, avoid using it.
-//   see: https://nodejs.org/api/esm.html#import-assertions
-// eslint-disable-next-line import/no-extraneous-dependencies
-const pkgJson = require('@napi-rs/cli/package.json')
-
 export const readFileAsync = promisify(readFile)
 export const writeFileAsync = promisify(writeFile)
 export const unlinkAsync = promisify(unlink)
@@ -35,6 +27,15 @@ export async function fileExists(path: string) {
   return exists
 }
 
+export async function dirExistsAsync(path: string) {
+  try {
+    const stats = await statAsync(path)
+    return stats.isDirectory()
+  } catch {
+    return false
+  }
+}
+
 export function pick<O, K extends keyof O>(o: O, ...keys: K[]): Pick<O, K> {
   return keys.reduce((acc, key) => {
     acc[key] = o[key]

package/src/utils/typegen.ts

@@ -1,4 +1,4 @@
-import { sortBy, unionWith, isEqual } from 'lodash-es'
+import { sortBy } from 'lodash-es'
 
 import { readFileAsync } from './misc.js'
 
@@ -85,14 +85,11 @@ function exportDeclare(ambient: boolean): string {
 export async function processTypeDef(
   intermediateTypeFile: string,
   constEnum: boolean,
-  header?: string,
 ) {
   const exports: string[] = []
   const defs = await readIntermediateTypeFile(intermediateTypeFile)
   const groupedDefs = preprocessTypeDef(defs)
 
-  header = header ?? ''
-
   const dts =
     sortBy(Array.from(groupedDefs), ([namespace]) => namespace)
       .map(([namespace, defs]) => {
@@ -130,41 +127,22 @@ export async function processTypeDef(
       })
       .join('\n\n') + '\n'
 
-  if (dts.indexOf('ExternalObject<') > -1) {
-    header += `
-export declare class ExternalObject<T> {
-  readonly '': {
-    readonly '': unique symbol
-    [K: symbol]: T
-  }
-}
-`
-  }
-
   return {
-    dts: header + dts,
+    dts,
     exports,
   }
 }
 
 async function readIntermediateTypeFile(file: string) {
   const content = await readFileAsync(file, 'utf8')
-  const defs = unionWith(
-    content
-      .split('\n')
-      .filter(Boolean)
-      .map((line) => {
-        line = line.trim()
-        if (!line.startsWith('{')) {
-          // crateName:{ "def": "", ... }
-          const start = line.indexOf(':') + 1
-          line = line.slice(start)
-        }
-        return JSON.parse(line) as TypeDefLine
-      })
-      .filter((def) => !!def.kind),
-    (a, b) => isEqual(a, b),
-  )
+
+  const defs = content
+    .split('\n')
+    .filter(Boolean)
+    .map((line) => {
+      line = line.trim()
+      return JSON.parse(line) as TypeDefLine
+    })
 
   // move all `struct` def to the very top
   // and order the rest alphabetically.