@napi-rs/cli 2.15.2 → 3.0.0-alpha.0

package/src/utils/typegen.ts

@@ -0,0 +1,193 @@
+import { sortBy } from 'lodash-es'
+
+import { readFileAsync } from './misc.js'
+
+const TOP_LEVEL_NAMESPACE = '__TOP_LEVEL_MODULE__'
+export const DEFAULT_TYPE_DEF_HEADER = `/* auto-generated by NAPI-RS */
+/* eslint-disable */
+`
+
+enum TypeDefKind {
+  Const = 'const',
+  Enum = 'enum',
+  Interface = 'interface',
+  Fn = 'fn',
+  Struct = 'struct',
+  Impl = 'impl',
+}
+
+interface TypeDefLine {
+  kind: TypeDefKind
+  name: string
+  original_name?: string
+  def: string
+  js_doc?: string
+  js_mod?: string
+}
+
+function prettyPrint(line: TypeDefLine, ident: number): string {
+  let s = line.js_doc ?? ''
+  switch (line.kind) {
+    case TypeDefKind.Interface:
+      s += `export interface ${line.name} {\n${line.def}\n}`
+      break
+
+    case TypeDefKind.Enum:
+      s += `export const enum ${line.name} {\n${line.def}\n}`
+      break
+
+    case TypeDefKind.Struct:
+      s += `export class ${line.name} {\n${line.def}\n}`
+      if (line.original_name && line.original_name !== line.name) {
+        s += `\nexport type ${line.original_name} = ${line.name}`
+      }
+      break
+
+    default:
+      s += line.def
+  }
+
+  return correctStringIdent(s, ident)
+}
+
+export async function processTypeDef(
+  intermediateTypeFile: string,
+  header?: string,
+) {
+  const defs = await readIntermediateTypeFile(intermediateTypeFile)
+  const groupedDefs = preprocessTypeDef(defs)
+
+  header = header ? header + '\n' : ''
+  let dts = ''
+
+  sortBy(Array.from(groupedDefs), ([namespace]) => namespace).forEach(
+    ([namespace, defs]) => {
+      if (namespace === TOP_LEVEL_NAMESPACE) {
+        for (const def of defs) {
+          dts += prettyPrint(def, 0) + '\n\n'
+        }
+      } else {
+        dts += `export namespace ${namespace} {\n`
+        for (const def of defs) {
+          dts += prettyPrint(def, 2) + '\n'
+        }
+        dts += '}\n\n'
+      }
+    },
+  )
+
+  if (dts.indexOf('ExternalObject<') > -1) {
+    header += `
+export class ExternalObject<T> {
+  readonly '': {
+    readonly '': unique symbol
+    [K: symbol]: T
+  }
+}
+`
+  }
+
+  return header + dts
+}
+
+async function readIntermediateTypeFile(file: string) {
+  const content = await readFileAsync(file, 'utf8')
+  const defs = 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
+    })
+
+  // move all `struct` def to the very top
+  // and order the rest alphabetically.
+  return defs.sort((a, b) => {
+    if (a.kind === TypeDefKind.Struct) {
+      if (b.kind === TypeDefKind.Struct) {
+        return a.name.localeCompare(b.name)
+      }
+      return -1
+    } else if (b.kind === TypeDefKind.Struct) {
+      return 1
+    } else {
+      return a.name.localeCompare(b.name)
+    }
+  })
+}
+
+function preprocessTypeDef(defs: TypeDefLine[]): Map<string, TypeDefLine[]> {
+  const namespaceGrouped = new Map<string, TypeDefLine[]>()
+  const classDefs = new Map<string, TypeDefLine>()
+
+  for (const def of defs) {
+    const namespace = def.js_mod ?? TOP_LEVEL_NAMESPACE
+    if (!namespaceGrouped.has(namespace)) {
+      namespaceGrouped.set(namespace, [])
+    }
+
+    const group = namespaceGrouped.get(namespace)!
+
+    if (def.kind === TypeDefKind.Struct) {
+      group.push(def)
+      classDefs.set(def.name, def)
+    } else if (def.kind === TypeDefKind.Impl) {
+      // merge `impl` into class definition
+      const classDef = classDefs.get(def.name)
+      if (classDef) {
+        if (classDef.def) {
+          classDef.def += '\n'
+        }
+
+        classDef.def += def.def
+      }
+    } else {
+      group.push(def)
+    }
+  }
+
+  return namespaceGrouped
+}
+
+export function correctStringIdent(src: string, ident: number): string {
+  let bracketDepth = 0
+  const result = src
+    .split('\n')
+    .map((line) => {
+      line = line.trim()
+      if (line === '') {
+        return ''
+      }
+
+      const isInMultilineComment = line.startsWith('*')
+      const isClosingBracket = line.endsWith('}')
+      const isOpeningBracket = line.endsWith('{')
+
+      let rightIndent = ident
+      if (isOpeningBracket && !isInMultilineComment) {
+        bracketDepth += 1
+        rightIndent += (bracketDepth - 1) * 2
+      } else {
+        if (isClosingBracket && bracketDepth > 0 && !isInMultilineComment) {
+          bracketDepth -= 1
+        }
+        rightIndent += bracketDepth * 2
+      }
+
+      if (isInMultilineComment) {
+        rightIndent += 1
+      }
+
+      const s = `${' '.repeat(rightIndent)}${line}`
+
+      return s
+    })
+    .join('\n')
+
+  return result
+}

package/src/utils/version.ts

@@ -0,0 +1,76 @@
+export enum NapiVersion {
+  Napi1 = 1,
+  Napi2,
+  Napi3,
+  Napi4,
+  Napi5,
+  Napi6,
+  Napi7,
+  Napi8,
+}
+
+/// because node support new napi version in some minor version updates, so we might meet such situation:
+/// `node v10.20.0` supports `napi5` and `napi6`, but `node v12.0.0` only support `napi4`,
+/// by which, we can not tell directly napi version supportness from node version directly.
+const NAPI_VERSION_MATRIX = new Map<NapiVersion, string>([
+  [NapiVersion.Napi1, '8.6.0'],
+  [NapiVersion.Napi2, '8.10.0 | 9.3.0'],
+  [NapiVersion.Napi3, '6.14.2 | 8.11.2 | 9.11.0'],
+  [NapiVersion.Napi4, '10.16.0 | 11.8.0'],
+  [NapiVersion.Napi5, '10.17.0 | 12.11.0'],
+  [NapiVersion.Napi6, '10.20.0 | 12.17.0 | 14.0.0'],
+  [NapiVersion.Napi7, '10.23.0 | 12.19.0 | 14.12.0'],
+  [NapiVersion.Napi8, '12.22.0 | 14.17.0 | 15.12.0'],
+])
+
+interface NodeVersion {
+  major: number
+  minor: number
+  patch: number
+}
+
+function parseNodeVersion(v: string): NodeVersion {
+  const matches = v.match(/v?([0-9]+)\.([0-9]+)\.([0-9]+)/i)
+
+  if (!matches) {
+    throw new Error('Unknown node version number: ' + v)
+  }
+
+  const [, major, minor, patch] = matches
+
+  return {
+    major: parseInt(major),
+    minor: parseInt(minor),
+    patch: parseInt(patch),
+  }
+}
+
+function requiredNodeVersions(napiVersion: NapiVersion): NodeVersion[] {
+  const requirement = NAPI_VERSION_MATRIX.get(napiVersion)
+
+  if (!requirement) {
+    return [parseNodeVersion('10.0.0')]
+  }
+
+  return requirement.split('|').map(parseNodeVersion)
+}
+
+function toEngineRequirement(versions: NodeVersion[]): string {
+  const requirements: string[] = []
+  versions.forEach((v, i) => {
+    let req = ''
+    if (i !== 0) {
+      const lastVersion = versions[i - 1]
+      req += `< ${lastVersion.major + 1}`
+    }
+
+    req += `${i === 0 ? '' : ' || '}>= ${v.major}.${v.minor}.${v.patch}`
+    requirements.push(req)
+  })
+
+  return requirements.join(' && ')
+}
+
+export function napiEngineRequirement(napiVersion: NapiVersion): string {
+  return toEngineRequirement(requiredNodeVersions(napiVersion))
+}