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

package/dist/utils/typegen.js

@@ -0,0 +1,158 @@
+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 */
+`;
+var TypeDefKind;
+(function (TypeDefKind) {
+    TypeDefKind["Const"] = "const";
+    TypeDefKind["Enum"] = "enum";
+    TypeDefKind["Interface"] = "interface";
+    TypeDefKind["Fn"] = "fn";
+    TypeDefKind["Struct"] = "struct";
+    TypeDefKind["Impl"] = "impl";
+})(TypeDefKind || (TypeDefKind = {}));
+function prettyPrint(line, ident) {
+    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, header) {
+    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) {
+    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);
+    });
+    // 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) {
+    const namespaceGrouped = new Map();
+    const classDefs = new Map();
+    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, ident) {
+    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/dist/utils/version.d.ts

@@ -0,0 +1,11 @@
+export declare enum NapiVersion {
+    Napi1 = 1,
+    Napi2 = 2,
+    Napi3 = 3,
+    Napi4 = 4,
+    Napi5 = 5,
+    Napi6 = 6,
+    Napi7 = 7,
+    Napi8 = 8
+}
+export declare function napiEngineRequirement(napiVersion: NapiVersion): string;

package/dist/utils/version.js

@@ -0,0 +1,59 @@
+export var NapiVersion;
+(function (NapiVersion) {
+    NapiVersion[NapiVersion["Napi1"] = 1] = "Napi1";
+    NapiVersion[NapiVersion["Napi2"] = 2] = "Napi2";
+    NapiVersion[NapiVersion["Napi3"] = 3] = "Napi3";
+    NapiVersion[NapiVersion["Napi4"] = 4] = "Napi4";
+    NapiVersion[NapiVersion["Napi5"] = 5] = "Napi5";
+    NapiVersion[NapiVersion["Napi6"] = 6] = "Napi6";
+    NapiVersion[NapiVersion["Napi7"] = 7] = "Napi7";
+    NapiVersion[NapiVersion["Napi8"] = 8] = "Napi8";
+})(NapiVersion = NapiVersion || (NapiVersion = {}));
+/// 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.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'],
+]);
+function parseNodeVersion(v) {
+    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) {
+    const requirement = NAPI_VERSION_MATRIX.get(napiVersion);
+    if (!requirement) {
+        return [parseNodeVersion('10.0.0')];
+    }
+    return requirement.split('|').map(parseNodeVersion);
+}
+function toEngineRequirement(versions) {
+    const requirements = [];
+    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) {
+    return toEngineRequirement(requiredNodeVersions(napiVersion));
+}

package/package.json

@@ -1,31 +1,58 @@
 {
   "name": "@napi-rs/cli",
-  "version": "2.15.1",
+  "version": "3.0.0-alpha.0",
   "description": "Cli tools for napi-rs",
-  "keywords": [
-    "cli",
-    "rust",
-    "napi",
-    "n-api",
-    "neon"
-  ],
   "author": "LongYinan <lynweklm@gmail.com>",
   "homepage": "https://github.com/napi-rs/napi-rs",
   "license": "MIT",
+  "type": "module",
+  "engines": {
+    "node": ">= 16"
+  },
   "bin": {
-    "napi": "./scripts/index.js"
+    "napi": "./dist/cli.js",
+    "napi-raw": "./cli.mjs"
+  },
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "exports": {
+    ".": {
+      "import": {
+        "default": "./dist/index.js",
+        "types": "./dist/index.d.ts"
+      },
+      "require": {
+        "default": "./dist/index.cjs",
+        "types": "./dist/index.d.ts"
+      }
+    },
+    "./package.json": {
+      "import": "./package.json",
+      "require": "./package.json"
+    }
   },
   "files": [
-    "scripts"
+    "dist",
+    "src"
+  ],
+  "keywords": [
+    "cli",
+    "rust",
+    "napi",
+    "n-api",
+    "node-api",
+    "node-addon",
+    "neon"
   ],
-  "engines": {
-    "node": ">= 10"
-  },
   "maintainers": [
     {
       "name": "LongYinan",
       "email": "lynweklm@gmail.com",
       "homepage": "https://github.com/Brooooooklyn"
+    },
+    {
+      "name": "forehalo",
+      "homepage": "https://github.com/forehalo"
     }
   ],
   "repository": {
@@ -39,26 +66,35 @@
   "bugs": {
     "url": "https://github.com/napi-rs/napi-rs/issues"
   },
-  "devDependencies": {
-    "@octokit/rest": "^19.0.5",
-    "@types/inquirer": "^9.0.3",
-    "@types/js-yaml": "^4.0.5",
-    "@types/lodash-es": "^4.17.6",
-    "clipanion": "^3.1.0",
+  "dependencies": {
+    "@octokit/rest": "^19.0.7",
+    "clipanion": "^3.2.0",
     "colorette": "^2.0.19",
-    "core-js": "^3.27.1",
     "debug": "^4.3.4",
-    "env-paths": "^3.0.0",
-    "fdir": "^5.3.0",
-    "inquirer": "^9.1.4",
+    "inquirer": "^9.1.5",
     "js-yaml": "^4.1.0",
-    "lodash-es": "4.17.21",
-    "toml": "^3.0.0",
-    "tslib": "^2.4.1",
+    "lodash-es": "^4.17.21",
     "typanion": "^3.12.1"
   },
+  "devDependencies": {
+    "@types/inquirer": "^9.0.3",
+    "@types/js-yaml": "^4.0.5",
+    "@types/lodash-es": "^4.17.6",
+    "ava": "^5.2.0",
+    "esbuild": "^0.17.14",
+    "prettier": "^2.8.7",
+    "ts-node": "^10.9.1",
+    "typescript": "^4.9.4"
+  },
   "funding": {
     "type": "github",
     "url": "https://github.com/sponsors/Brooooooklyn"
-  }
+  },
+  "scripts": {
+    "codegen": "node --loader ts-node/esm/transpile-only ./codegen/index.ts",
+    "build": "tsc && yarn build:cjs",
+    "build:cjs": "node ./esbuild.mjs",
+    "test": "ava"
+  },
+  "gitHead": "7c9a4bae2da98752dbf683b1d8c9add81f30a61e"
 }

package/src/api/artifacts.ts

@@ -0,0 +1,93 @@
+import { join, parse, resolve } from 'path'
+
+import * as colors from 'colorette'
+
+import {
+  applyDefaultArtifactsOptions,
+  ArtifactsOptions,
+} from '../def/artifacts.js'
+import {
+  readNapiConfig,
+  debugFactory,
+  readFileAsync,
+  writeFileAsync,
+  UniArchsByPlatform,
+  readdirAsync,
+} from '../utils/index.js'
+
+const debug = debugFactory('artifacts')
+
+export async function collectArtifacts(userOptions: ArtifactsOptions) {
+  const options = applyDefaultArtifactsOptions(userOptions)
+
+  const packageJsonPath = resolve(options.cwd, options.packageJsonPath)
+  const { targets, binaryName } = await readNapiConfig(packageJsonPath)
+
+  const distDirs = targets.map((platform) =>
+    resolve(options.cwd, options.npmDir, platform.platformArchABI),
+  )
+
+  const universalSourceBins = new Set(
+    targets
+      .filter((platform) => platform.arch === 'universal')
+      .flatMap((p) =>
+        UniArchsByPlatform[p.platform]?.map((a) => `${p.platform}-${a}`),
+      )
+      .filter(Boolean) as string[],
+  )
+
+  await collectNodeBinaries(resolve(options.cwd, options.outputDir)).then(
+    (output) =>
+      Promise.all(
+        output.map(async (filePath) => {
+          debug.info(`Read [${colors.yellowBright(filePath)}]`)
+          const sourceContent = await readFileAsync(filePath)
+          const parsedName = parse(filePath)
+          const [_binaryName, platformArchABI] = parsedName.name.split('.')
+          if (_binaryName !== binaryName) {
+            debug.warn(
+              `[${_binaryName}] is not matched with [${binaryName}], skip`,
+            )
+            return
+          }
+          const dir = distDirs.find((dir) => dir.includes(platformArchABI))
+          if (!dir && universalSourceBins.has(platformArchABI)) {
+            debug.warn(
+              `[${platformArchABI}] has no dist dir but it is source bin for universal arch, skip`,
+            )
+            return
+          }
+          if (!dir) {
+            throw new Error(`No dist dir found for ${filePath}`)
+          }
+
+          const distFilePath = join(dir, parsedName.base)
+          debug.info(
+            `Write file content to [${colors.yellowBright(distFilePath)}]`,
+          )
+          await writeFileAsync(distFilePath, sourceContent)
+          const distFilePathLocal = join(
+            parse(packageJsonPath).dir,
+            parsedName.base,
+          )
+          debug.info(
+            `Write file content to [${colors.yellowBright(distFilePathLocal)}]`,
+          )
+          await writeFileAsync(distFilePathLocal, sourceContent)
+        }),
+      ),
+  )
+}
+
+async function collectNodeBinaries(root: string) {
+  const files = await readdirAsync(root, { withFileTypes: true })
+  const nodeBinaries = files
+    .filter((file) => file.isFile() && file.name.endsWith('.node'))
+    .map((file) => join(root, file.name))
+
+  const dirs = files.filter((file) => file.isDirectory())
+  for (const dir of dirs) {
+    nodeBinaries.push(...(await collectNodeBinaries(join(root, dir.name))))
+  }
+  return nodeBinaries
+}