@napi-rs/cli 3.7.4 → 3.8.0

package/src/api/new.ts

@@ -13,19 +13,24 @@ import {
 } from '../def/new.js'
 import {
   AVAILABLE_TARGETS,
+  CLI_VERSION,
   debugFactory,
   DEFAULT_TARGETS,
+  getWasiTarget,
   mkdirAsync,
   parseTriple,
   readdirAsync,
   statAsync,
+  wasiTargetHasThreads,
   type SupportedPackageManager,
 } from '../utils/index.js'
 import {
   napiEngineRequirement,
   SUPPORTED_NAPI_VERSIONS,
+  restrictWasiNodeEngine,
 } from '../utils/version.js'
 import { renameProject } from './rename.js'
+import { createCjsBinding } from './templates/index.js'
 
 // Template imports removed as we're now using external templates
 
@@ -38,7 +43,117 @@ const TEMPLATE_REPOS = {
   pnpm: 'https://github.com/napi-rs/package-template-pnpm',
 } as const
 
-const WASI_TARGET = 'wasm32-wasip1-threads'
+const TEMPLATE_LOCKFILES: Record<SupportedPackageManager, string> = {
+  yarn: 'yarn.lock',
+  pnpm: 'pnpm-lock.yaml',
+}
+const WASI_CI_ARTIFACT_PATTERNS = [
+  'index.js',
+  'browser.js',
+  '*.wasi*.cjs',
+  '*.wasi*.d.cts',
+  '*.wasi*-browser.js',
+  '*.wasi*-deferred.js',
+  '*.wasi*-deferred.d.ts',
+  'wasi-worker*.mjs',
+]
+// Exported for tests.
+export const GENERATED_WASI_BINDING =
+  /(?:\.(?:wasi|wasip\d+)(?:-browser|-deferred)?\.(?:cjs|js|d\.[cm]?ts)|wasi-worker(?:-browser)?\.mjs)/
+const TYPE_DEF_FILE = /\.d\.[cm]?ts$/
+const GLOB_PATTERN = /[*?[\]{}]/
+
+function createWasiBrowserEntry(
+  packageName: string,
+  platformArchABI: string,
+  enableTypeDef: boolean,
+) {
+  const packageSpecifier = `${packageName}-${platformArchABI}`
+  return (
+    `export * from '${packageSpecifier}'\n` +
+    (enableTypeDef ? '' : `export { default } from '${packageSpecifier}'\n`)
+  )
+}
+
+function stripTypeConditions(
+  value: unknown,
+  typeDefPaths: Set<string>,
+): unknown {
+  if (Array.isArray(value)) {
+    const entries = value
+      .map((entry) => stripTypeConditions(entry, typeDefPaths))
+      .filter((entry) => entry !== undefined)
+    return entries.length > 0 ? entries : undefined
+  }
+  if (typeof value !== 'object' || value === null) {
+    return value
+  }
+
+  const result: Record<string, unknown> = {}
+  for (const [key, entry] of Object.entries(value)) {
+    if (key === 'types') {
+      if (typeof entry === 'string') {
+        typeDefPaths.add(entry)
+      }
+      continue
+    }
+    const stripped = stripTypeConditions(entry, typeDefPaths)
+    if (stripped !== undefined) {
+      result[key] = stripped
+    }
+  }
+  return Object.keys(result).length > 0 ? result : undefined
+}
+
+async function removeTypeDefOutput(
+  packageJson: Record<string, any>,
+  packageDir: string,
+) {
+  const typeDefPaths = new Set<string>(['index.d.ts'])
+  for (const field of ['types', 'typings']) {
+    if (typeof packageJson[field] === 'string') {
+      typeDefPaths.add(packageJson[field])
+    }
+    delete packageJson[field]
+  }
+  delete packageJson.typesVersions
+
+  if (packageJson.exports !== undefined) {
+    const exports = stripTypeConditions(packageJson.exports, typeDefPaths)
+    if (exports === undefined) {
+      delete packageJson.exports
+    } else {
+      packageJson.exports = exports
+    }
+  }
+
+  if (Array.isArray(packageJson.files)) {
+    packageJson.files = packageJson.files.filter((file: unknown) => {
+      if (typeof file !== 'string' || !TYPE_DEF_FILE.test(file)) {
+        return true
+      }
+      typeDefPaths.add(file)
+      return false
+    })
+  }
+
+  for (const typeDefPath of typeDefPaths) {
+    const relativePath = typeDefPath.replace(/^\.\//, '')
+    if (!TYPE_DEF_FILE.test(relativePath) || GLOB_PATTERN.test(relativePath)) {
+      continue
+    }
+    const absolutePath = path.resolve(packageDir, relativePath)
+    const relativeToPackage = path.relative(packageDir, absolutePath)
+    if (
+      relativeToPackage === '' ||
+      relativeToPackage.startsWith(`..${path.sep}`) ||
+      path.isAbsolute(relativeToPackage)
+    ) {
+      continue
+    }
+    await fs.rm(absolutePath, { force: true })
+  }
+}
 
 async function checkGitCommand(): Promise<boolean> {
   return new Promise<boolean>((resolve) => {
@@ -109,7 +224,7 @@ async function downloadTemplate(
 async function copyDirectory(
   src: string,
   dest: string,
-  includeWasiBindings: boolean,
+  hasWasiTargets: boolean,
 ): Promise<void> {
   await mkdirAsync(dest, { recursive: true })
   const entries = await fs.readdir(src, { withFileTypes: true })
@@ -124,15 +239,12 @@ async function copyDirectory(
     }
 
     if (entry.isDirectory()) {
-      await copyDirectory(srcPath, destPath, includeWasiBindings)
+      await copyDirectory(srcPath, destPath, hasWasiTargets)
     } else {
       if (
-        !includeWasiBindings &&
-        (entry.name.endsWith('.wasi-browser.js') ||
-          entry.name.endsWith('.wasi.cjs') ||
-          entry.name.endsWith('wasi-worker-browser.mjs') ||
-          entry.name.endsWith('wasi-worker.mjs') ||
-          entry.name === 'browser.js')
+        entry.name === 'browser.js' ||
+        GENERATED_WASI_BINDING.test(entry.name) ||
+        (hasWasiTargets && entry.name === 'index.js')
       ) {
         continue
       }
@@ -144,19 +256,83 @@ async function copyDirectory(
 async function filterTargetsInPackageJson(
   filePath: string,
   enabledTargets: string[],
+  enableTypeDef: boolean,
+  packageManager: SupportedPackageManager,
 ): Promise<void> {
   const content = await fs.readFile(filePath, 'utf-8')
   const packageJson = JSON.parse(content)
-  const includeWasiBindings = enabledTargets.includes(WASI_TARGET)
+  const wasiTargets = enabledTargets
+    .map(parseTriple)
+    .filter((target) => target.platform === 'wasi')
+  const includeWasiBindings = wasiTargets.length > 0
+  const includeThreadlessWasi = wasiTargets.some(
+    (target) => !wasiTargetHasThreads(target),
+  )
 
-  // Filter napi.targets
-  if (packageJson.napi?.targets) {
-    packageJson.napi.targets = packageJson.napi.targets.filter(
-      (target: string) => enabledTargets.includes(target),
+  // The external templates may not yet list newly supported targets. The
+  // requested target set is authoritative rather than a filter over the
+  // template's current contents.
+  packageJson.napi ??= {}
+  packageJson.napi.targets = enabledTargets
+
+  if (includeThreadlessWasi) {
+    packageJson.devDependencies ??= {}
+    packageJson.devDependencies['@napi-rs/cli'] = `^${CLI_VERSION}`
+    // Template lockfiles can pin an older CLI that predates this target even
+    // when package.json's range is updated. The first install must resolve a
+    // lockfile from the generated manifest.
+    await fs.rm(
+      path.join(path.dirname(filePath), TEMPLATE_LOCKFILES[packageManager]),
+      { force: true },
     )
   }
 
-  if (!includeWasiBindings) {
+  if (!enableTypeDef) {
+    await removeTypeDefOutput(packageJson, path.dirname(filePath))
+  }
+
+  if (includeWasiBindings) {
+    packageJson.browser = 'browser.js'
+    packageJson.files ??= []
+    if (!packageJson.files.includes('browser.js')) {
+      packageJson.files.push('browser.js')
+    }
+    const browserTarget =
+      wasiTargets.find(
+        (target) => getWasiTarget(target)?.flavor === 'single',
+      ) ?? wasiTargets[0]
+    await fs.writeFile(
+      path.join(path.dirname(filePath), 'browser.js'),
+      createWasiBrowserEntry(
+        packageJson.name,
+        browserTarget.platformArchABI,
+        enableTypeDef,
+      ),
+    )
+    if (!enableTypeDef) {
+      const wasiFlavors = [
+        ...wasiTargets.filter(wasiTargetHasThreads),
+        ...wasiTargets.filter((target) => !wasiTargetHasThreads(target)),
+      ].map((target) => target.platformArchABI)
+      packageJson.main = 'index.js'
+      if (
+        !packageJson.files.includes('index.js') &&
+        !packageJson.files.includes('./index.js')
+      ) {
+        packageJson.files.push('index.js')
+      }
+      await fs.writeFile(
+        path.join(path.dirname(filePath), 'index.js'),
+        createCjsBinding(
+          packageJson.napi.binaryName,
+          packageJson.napi.packageName ?? packageJson.name,
+          [],
+          packageJson.version,
+          wasiFlavors,
+        ),
+      )
+    }
+  } else {
     if (
       packageJson.browser === 'browser.js' ||
       packageJson.browser === './browser.js'
@@ -172,6 +348,49 @@ async function filterTargetsInPackageJson(
   }
 
   await fs.writeFile(filePath, JSON.stringify(packageJson, null, 2) + '\n')
+  await updateGeneratedWasiAttributes(
+    path.join(path.dirname(filePath), '.gitattributes'),
+    packageJson.napi.binaryName,
+    wasiTargets,
+  )
+}
+
+async function updateGeneratedWasiAttributes(
+  filePath: string,
+  binaryName: string,
+  wasiTargets: ReturnType<typeof parseTriple>[],
+) {
+  if (!existsSync(filePath)) {
+    return
+  }
+
+  const lines = (await fs.readFile(filePath, 'utf8'))
+    .split('\n')
+    .filter((line) => !GENERATED_WASI_BINDING.test(line))
+  const generatedFiles = new Set<string>()
+  for (const target of wasiTargets) {
+    const suffix = target.platformArchABI.replace(/^wasm32-/, '')
+    generatedFiles.add(`${binaryName}.${suffix}.cjs`)
+    generatedFiles.add(`${binaryName}.${suffix}.d.cts`)
+    generatedFiles.add(`${binaryName}.${suffix}-browser.js`)
+    if (getWasiTarget(target)?.flavor === 'threads') {
+      generatedFiles.add('wasi-worker.mjs')
+      generatedFiles.add('wasi-worker-browser.mjs')
+    } else {
+      generatedFiles.add(`${binaryName}.${suffix}-deferred.js`)
+      generatedFiles.add(`${binaryName}.${suffix}-deferred.d.ts`)
+    }
+  }
+  if (generatedFiles.size > 0) {
+    while (lines[lines.length - 1] === '') {
+      lines.pop()
+    }
+    lines.push(
+      '',
+      ...[...generatedFiles].map((file) => `${file} linguist-detectable=false`),
+    )
+  }
+  await fs.writeFile(filePath, `${lines.join('\n')}\n`)
 }
 
 async function updateCargoTomlTypeDef(
@@ -289,16 +508,70 @@ async function filterTargetsInGithubActions(
     const platform = parseTriple(target).platform
     return platform === 'darwin' || platform === 'win32'
   })
+  const wasiTargets = enabledTargets.filter((target) => getWasiTarget(target))
 
   // Filter the matrix configurations in the build job
   if (yaml?.jobs?.build?.strategy?.matrix?.settings) {
-    yaml.jobs.build.strategy.matrix.settings =
-      yaml.jobs.build.strategy.matrix.settings.filter((setting: any) => {
-        if (setting.target) {
-          return enabledTargets.includes(setting.target)
-        }
-        return true
-      })
+    const settings = yaml.jobs.build.strategy.matrix.settings
+    const wasiTemplate = settings.find(
+      (setting: any) => setting.target && getWasiTarget(setting.target),
+    )
+    const wasiTemplateTarget =
+      typeof wasiTemplate?.target === 'string' ? wasiTemplate.target : undefined
+    const wasiTargetComparison = wasiTemplateTarget
+      ? new RegExp(
+          `matrix\\.settings\\.target\\s*(==|!=)\\s*(['"])${wasiTemplateTarget.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\2`,
+        )
+      : undefined
+    const filteredSettings = settings.filter((setting: any) => {
+      if (setting.target && getWasiTarget(setting.target)) {
+        return false
+      }
+      if (setting.target) {
+        return enabledTargets.includes(setting.target)
+      }
+      return true
+    })
+    if (wasiTargets.length > 0 && !wasiTemplate) {
+      throw new Error('Template CI is missing a WASI build matrix entry')
+    }
+    for (const target of wasiTargets) {
+      const setting = { ...wasiTemplate }
+      const templateTarget = setting.target
+      setting.target = target
+      if (typeof setting.build === 'string') {
+        setting.build = setting.build.replaceAll(templateTarget, target)
+      }
+      filteredSettings.push(setting)
+    }
+    yaml.jobs.build.strategy.matrix.settings = filteredSettings
+
+    for (const step of yaml.jobs.build.steps ?? []) {
+      const operator =
+        typeof step.if === 'string' && wasiTargetComparison
+          ? step.if.match(wasiTargetComparison)?.[1]
+          : undefined
+      if (operator === '!=') {
+        step.if = "${{ !startsWith(matrix.settings.target, 'wasm32-') }}"
+      } else if (operator === '==') {
+        step.if = "${{ startsWith(matrix.settings.target, 'wasm32-') }}"
+      }
+      if (
+        wasiTargets.length > 0 &&
+        typeof step.uses === 'string' &&
+        step.uses.startsWith('actions/upload-artifact@') &&
+        typeof step.with?.path === 'string' &&
+        step.with.path.includes('.wasm')
+      ) {
+        const existingPatterns = step.with.path
+          .split('\n')
+          .map((pattern: string) => pattern.trim())
+          .filter(Boolean)
+        step.with.path = [
+          ...new Set([...existingPatterns, ...WASI_CI_ARTIFACT_PATTERNS]),
+        ].join('\n')
+      }
+    }
   }
 
   const jobsToRemove: string[] = []
@@ -342,8 +615,38 @@ async function filterTargetsInGithubActions(
     }
   }
 
-  if (!enabledTargets.includes(WASI_TARGET)) {
+  if (wasiTargets.length === 0) {
     jobsToRemove.push('test-wasi')
+  } else if (yaml.jobs?.['test-wasi']) {
+    const wasiJob = yaml.jobs['test-wasi']
+    if (wasiTargets.length > 1) {
+      wasiJob.strategy = {
+        'fail-fast': false,
+        matrix: {
+          target: wasiTargets,
+        },
+      }
+      wasiJob.name = 'Test WASI target - ${{ matrix.target }}'
+    }
+    const downloadStep = wasiJob.steps?.find(
+      (step: any) =>
+        typeof step.uses === 'string' &&
+        step.uses.startsWith('actions/download-artifact@'),
+    )
+    if (downloadStep?.with) {
+      downloadStep.with.name =
+        wasiTargets.length === 1
+          ? `bindings-${wasiTargets[0]}`
+          : 'bindings-${{ matrix.target }}'
+    }
+    for (const step of wasiJob.steps ?? []) {
+      if (
+        step.env &&
+        Object.prototype.hasOwnProperty.call(step.env, 'NAPI_RS_FORCE_WASI')
+      ) {
+        step.env.NAPI_RS_FORCE_WASI = 'true'
+      }
+    }
   }
 
   if (!enabledTargets.includes('x86_64-unknown-freebsd')) {
@@ -423,17 +726,21 @@ function processOptions(options: RawNewOptions) {
       throw new Error('At least one target must be enabled')
     }
   }
-  if (
-    options.targets.some((target) => target === 'wasm32-wasi-preview1-threads')
-  ) {
-    const out = execSync(`rustup target list`, {
-      encoding: 'utf8',
-    })
-    if (out.includes(WASI_TARGET)) {
-      options.targets = options.targets.map((target) =>
-        target === 'wasm32-wasi-preview1-threads' ? WASI_TARGET : target,
+  const requestedTargets = options.targets.map((target) => ({
+    target,
+    parsed: parseTriple(target),
+  }))
+  options.targets = requestedTargets.map(({ parsed }) => parsed.triple)
+  const outputTargets = new Map<string, string>()
+  for (const { target, parsed } of requestedTargets) {
+    const { platformArchABI } = parsed
+    const previous = outputTargets.get(platformArchABI)
+    if (previous) {
+      throw new Error(
+        `Targets ${previous} and ${target} produce the same ${platformArchABI} artifact set. Choose one target spelling.`,
       )
     }
+    outputTargets.set(platformArchABI, target)
   }
 
   return applyDefaultNewOptions(options) as NewOptions
@@ -471,7 +778,7 @@ export async function newProject(userOptions: RawNewOptions) {
       await copyDirectory(
         templatePath,
         options.path,
-        options.targets.includes(WASI_TARGET),
+        options.targets.some((target) => getWasiTarget(target) !== undefined),
       )
 
       // Rename project using the rename API
@@ -493,7 +800,12 @@ export async function newProject(userOptions: RawNewOptions) {
       // Filter targets in package.json
       const packageJsonPath = path.join(options.path, 'package.json')
       if (existsSync(packageJsonPath)) {
-        await filterTargetsInPackageJson(packageJsonPath, options.targets)
+        await filterTargetsInPackageJson(
+          packageJsonPath,
+          options.targets,
+          options.enableTypeDef,
+          packageManager,
+        )
       }
 
       // Filter targets in GitHub Actions CI
@@ -519,7 +831,14 @@ export async function newProject(userOptions: RawNewOptions) {
       if (!pkgJson.engines) {
         pkgJson.engines = {}
       }
-      pkgJson.engines.node = napiEngineRequirement(options.minNodeApiVersion)
+      const nodeEngineRequirement = napiEngineRequirement(
+        options.minNodeApiVersion,
+      )
+      pkgJson.engines.node = options.targets.every(
+        (target) => parseTriple(target).platform === 'wasi',
+      )
+        ? restrictWasiNodeEngine(nodeEngineRequirement)
+        : nodeEngineRequirement
 
       // Update license if different from template
       if (options.license && pkgJson.license !== options.license) {