@tauri-apps/cli 1.0.0-beta.8 → 1.0.0-rc.2

package/index.js

@@ -0,0 +1,241 @@
+const { existsSync, readFileSync } = require('fs')
+const { join } = require('path')
+
+const { platform, arch } = process
+
+let nativeBinding = null
+let localFileExisted = false
+let loadError = null
+
+function isMusl() {
+  // For Node 10
+  if (!process.report || typeof process.report.getReport !== 'function') {
+    try {
+      return readFileSync('/usr/bin/ldd', 'utf8').includes('musl')
+    } catch (e) {
+      return true
+    }
+  } else {
+    const { glibcVersionRuntime } = process.report.getReport().header
+    return !glibcVersionRuntime
+  }
+}
+
+switch (platform) {
+  case 'android':
+    switch (arch) {
+      case 'arm64':
+        localFileExisted = existsSync(join(__dirname, 'cli.android-arm64.node'))
+        try {
+          if (localFileExisted) {
+            nativeBinding = require('./cli.android-arm64.node')
+          } else {
+            nativeBinding = require('@tauri-apps/cli-android-arm64')
+          }
+        } catch (e) {
+          loadError = e
+        }
+        break
+      case 'arm':
+        localFileExisted = existsSync(join(__dirname, 'cli.android-arm-eabi.node'))
+        try {
+          if (localFileExisted) {
+            nativeBinding = require('./cli.android-arm-eabi.node')
+          } else {
+            nativeBinding = require('@tauri-apps/cli-android-arm-eabi')
+          }
+        } catch (e) {
+          loadError = e
+        }
+        break
+      default:
+        throw new Error(`Unsupported architecture on Android ${arch}`)
+    }
+    break
+  case 'win32':
+    switch (arch) {
+      case 'x64':
+        localFileExisted = existsSync(
+          join(__dirname, 'cli.win32-x64-msvc.node')
+        )
+        try {
+          if (localFileExisted) {
+            nativeBinding = require('./cli.win32-x64-msvc.node')
+          } else {
+            nativeBinding = require('@tauri-apps/cli-win32-x64-msvc')
+          }
+        } catch (e) {
+          loadError = e
+        }
+        break
+      case 'ia32':
+        localFileExisted = existsSync(
+          join(__dirname, 'cli.win32-ia32-msvc.node')
+        )
+        try {
+          if (localFileExisted) {
+            nativeBinding = require('./cli.win32-ia32-msvc.node')
+          } else {
+            nativeBinding = require('@tauri-apps/cli-win32-ia32-msvc')
+          }
+        } catch (e) {
+          loadError = e
+        }
+        break
+      case 'arm64':
+        localFileExisted = existsSync(
+          join(__dirname, 'cli.win32-arm64-msvc.node')
+        )
+        try {
+          if (localFileExisted) {
+            nativeBinding = require('./cli.win32-arm64-msvc.node')
+          } else {
+            nativeBinding = require('@tauri-apps/cli-win32-arm64-msvc')
+          }
+        } catch (e) {
+          loadError = e
+        }
+        break
+      default:
+        throw new Error(`Unsupported architecture on Windows: ${arch}`)
+    }
+    break
+  case 'darwin':
+    switch (arch) {
+      case 'x64':
+        localFileExisted = existsSync(join(__dirname, 'cli.darwin-x64.node'))
+        try {
+          if (localFileExisted) {
+            nativeBinding = require('./cli.darwin-x64.node')
+          } else {
+            nativeBinding = require('@tauri-apps/cli-darwin-x64')
+          }
+        } catch (e) {
+          loadError = e
+        }
+        break
+      case 'arm64':
+        localFileExisted = existsSync(
+          join(__dirname, 'cli.darwin-arm64.node')
+        )
+        try {
+          if (localFileExisted) {
+            nativeBinding = require('./cli.darwin-arm64.node')
+          } else {
+            nativeBinding = require('@tauri-apps/cli-darwin-arm64')
+          }
+        } catch (e) {
+          loadError = e
+        }
+        break
+      default:
+        throw new Error(`Unsupported architecture on macOS: ${arch}`)
+    }
+    break
+  case 'freebsd':
+    if (arch !== 'x64') {
+      throw new Error(`Unsupported architecture on FreeBSD: ${arch}`)
+    }
+    localFileExisted = existsSync(join(__dirname, 'cli.freebsd-x64.node'))
+    try {
+      if (localFileExisted) {
+        nativeBinding = require('./cli.freebsd-x64.node')
+      } else {
+        nativeBinding = require('@tauri-apps/cli-freebsd-x64')
+      }
+    } catch (e) {
+      loadError = e
+    }
+    break
+  case 'linux':
+    switch (arch) {
+      case 'x64':
+        if (isMusl()) {
+          localFileExisted = existsSync(
+            join(__dirname, 'cli.linux-x64-musl.node')
+          )
+          try {
+            if (localFileExisted) {
+              nativeBinding = require('./cli.linux-x64-musl.node')
+            } else {
+              nativeBinding = require('@tauri-apps/cli-linux-x64-musl')
+            }
+          } catch (e) {
+            loadError = e
+          }
+        } else {
+          localFileExisted = existsSync(
+            join(__dirname, 'cli.linux-x64-gnu.node')
+          )
+          try {
+            if (localFileExisted) {
+              nativeBinding = require('./cli.linux-x64-gnu.node')
+            } else {
+              nativeBinding = require('@tauri-apps/cli-linux-x64-gnu')
+            }
+          } catch (e) {
+            loadError = e
+          }
+        }
+        break
+      case 'arm64':
+        if (isMusl()) {
+          localFileExisted = existsSync(
+            join(__dirname, 'cli.linux-arm64-musl.node')
+          )
+          try {
+            if (localFileExisted) {
+              nativeBinding = require('./cli.linux-arm64-musl.node')
+            } else {
+              nativeBinding = require('@tauri-apps/cli-linux-arm64-musl')
+            }
+          } catch (e) {
+            loadError = e
+          }
+        } else {
+          localFileExisted = existsSync(
+            join(__dirname, 'cli.linux-arm64-gnu.node')
+          )
+          try {
+            if (localFileExisted) {
+              nativeBinding = require('./cli.linux-arm64-gnu.node')
+            } else {
+              nativeBinding = require('@tauri-apps/cli-linux-arm64-gnu')
+            }
+          } catch (e) {
+            loadError = e
+          }
+        }
+        break
+      case 'arm':
+        localFileExisted = existsSync(
+          join(__dirname, 'cli.linux-arm-gnueabihf.node')
+        )
+        try {
+          if (localFileExisted) {
+            nativeBinding = require('./cli.linux-arm-gnueabihf.node')
+          } else {
+            nativeBinding = require('@tauri-apps/cli-linux-arm-gnueabihf')
+          }
+        } catch (e) {
+          loadError = e
+        }
+        break
+      default:
+        throw new Error(`Unsupported architecture on Linux: ${arch}`)
+    }
+    break
+  default:
+    throw new Error(`Unsupported OS: ${platform}, architecture: ${arch}`)
+}
+
+if (!nativeBinding) {
+  if (loadError) {
+    throw loadError
+  }
+  throw new Error(`Failed to load native binding`)
+}
+
+const { run } = nativeBinding
+
+module.exports.run = run

package/jest.config.js

@@ -0,0 +1,14 @@
+module.exports = {
+  setupFilesAfterEnv: ['<rootDir>/test/jest/jest.setup.js'],
+  testMatch: [
+    '<rootDir>/test/jest/__tests__/**/*.spec.js',
+    '<rootDir>/test/jest/__tests__/**/*.test.js'
+  ],
+  moduleFileExtensions: ['ts', 'js', 'json'],
+  moduleNameMapper: {
+    '^~/(.*)$': '<rootDir>/$1'
+  },
+  transform: {
+    '\\.toml$': 'jest-transform-toml'
+  }
+}

package/package.json

@@ -1,32 +1,11 @@
 {
   "name": "@tauri-apps/cli",
-  "version": "1.0.0-beta.8",
+  "version": "1.0.0-rc.2",
   "description": "Command line interface for building Tauri apps",
-  "bin": {
-    "tauri": "./bin/tauri.js"
-  },
-  "files": [
-    "bin",
-    "dist",
-    "scripts"
-  ],
   "funding": {
     "type": "opencollective",
     "url": "https://opencollective.com/tauri"
   },
-  "scripts": {
-    "build": "rimraf ./dist && webpack --progress",
-    "build-release": "rimraf ./dist && cross-env NODE_ENV=production webpack",
-    "test": "jest --runInBand --no-cache --testPathIgnorePatterns=\"(build|dev)\"",
-    "pretest": "yarn build",
-    "prepublishOnly": "yarn build-release",
-    "test:local": "jest --runInBand",
-    "lint": "eslint --ext ts \"./src/**/*.ts\"",
-    "lint-fix": "eslint --fix --ext ts \"./src/**/*.ts\"",
-    "lint:lockfile": "lockfile-lint --path yarn.lock --type yarn --validate-https --allowed-hosts npm yarn",
-    "format": "prettier --write --end-of-line=auto \"./**/*.{cjs,js,jsx,ts,tsx,html,css,json}\" --ignore-path .gitignore",
-    "format:check": "prettier --check --end-of-line=auto \"./**/*.{cjs,js,jsx,ts,tsx,html,css,json}\" --ignore-path .gitignore"
-  },
   "repository": {
     "type": "git",
     "url": "git+https://github.com/tauri-apps/tauri.git"
@@ -42,72 +21,53 @@
   "publishConfig": {
     "access": "public"
   },
-  "engines": {
-    "node": ">= 12.13.0",
-    "npm": ">= 6.6.0",
-    "yarn": ">= 1.19.1"
+  "main": "index.js",
+  "types": "index.d.ts",
+  "napi": {
+    "name": "cli",
+    "triples": {
+      "additional": [
+        "aarch64-apple-darwin",
+        "aarch64-unknown-linux-gnu",
+        "aarch64-unknown-linux-musl",
+        "armv7-unknown-linux-gnueabihf",
+        "x86_64-unknown-linux-musl"
+      ]
+    }
   },
-  "dependencies": {
-    "@tauri-apps/toml": "2.2.4",
-    "chalk": "4.1.2",
-    "cross-env": "7.0.3",
+  "devDependencies": {
+    "@napi-rs/cli": "2.4.2",
     "cross-spawn": "7.0.3",
     "fs-extra": "10.0.0",
-    "global-agent": "3.0.0",
-    "got": "11.8.2",
-    "imagemin": "8.0.1",
-    "imagemin-optipng": "8.0.0",
-    "imagemin-zopfli": "7.0.0",
-    "inquirer": "8.1.2",
-    "is-png": "3.0.0",
-    "minimist": "1.2.5",
-    "ms": "2.1.3",
-    "png2icons": "2.0.1",
-    "read-chunk": "3.2.0",
-    "semver": "7.3.5",
-    "sharp": "0.28.3",
-    "update-notifier": "5.1.0"
-  },
-  "devDependencies": {
-    "@babel/core": "7.15.0",
-    "@babel/preset-env": "7.15.0",
-    "@babel/preset-typescript": "7.15.0",
-    "@types/cross-spawn": "6.0.2",
-    "@types/fs-extra": "9.0.12",
-    "@types/global-agent": "2.1.1",
-    "@types/imagemin": "7.0.1",
-    "@types/imagemin-optipng": "5.2.1",
-    "@types/inquirer": "7.3.3",
-    "@types/ms": "0.7.31",
-    "@types/semver": "7.3.8",
-    "@types/sharp": "0.28.5",
-    "@typescript-eslint/eslint-plugin": "4.29.1",
-    "@typescript-eslint/parser": "4.29.1",
-    "babel-jest": "27.0.6",
-    "eslint": "7.32.0",
-    "eslint-config-prettier": "8.3.0",
-    "eslint-config-standard-with-typescript": "20.0.0",
-    "eslint-plugin-import": "2.24.0",
-    "eslint-plugin-lodash-template": "0.19.0",
-    "eslint-plugin-node": "11.1.0",
-    "eslint-plugin-promise": "5.1.0",
-    "eslint-plugin-security": "1.4.0",
-    "is-running": "2.1.0",
-    "jest": "27.0.6",
+    "jest": "27.5.1",
     "jest-transform-toml": "1.0.0",
-    "lockfile-lint": "4.6.2",
-    "prettier": "2.3.2",
-    "promise": "8.1.0",
-    "raw-loader": "4.0.2",
-    "rimraf": "3.0.2",
-    "toml-loader": "1.0.0",
-    "ts-loader": "9.2.5",
-    "typescript": "4.3.5",
-    "webpack": "5.50.0",
-    "webpack-cli": "4.7.2",
-    "webpack-node-externals": "3.0.0"
+    "prettier": "2.5.1"
+  },
+  "engines": {
+    "node": ">= 10"
+  },
+  "bin": {
+    "tauri": "./tauri.js"
+  },
+  "scripts": {
+    "artifacts": "napi artifacts",
+    "build": "napi build --platform --release",
+    "build:debug": "napi build --platform",
+    "prepublishOnly": "napi prepublish -t npm",
+    "test": "jest --runInBand --forceExit --no-cache",
+    "version": "napi version",
+    "tauri": "node ./tauri.js",
+    "format": "prettier --write ./package.json ./tauri.js",
+    "format:check": "prettier --check ./package.json ./tauri.js"
   },
-  "resolutions": {
-    "**/trim-newlines": "4.0.2"
+  "optionalDependencies": {
+    "@tauri-apps/cli-win32-x64-msvc": "1.0.0-rc.2",
+    "@tauri-apps/cli-darwin-x64": "1.0.0-rc.2",
+    "@tauri-apps/cli-linux-x64-gnu": "1.0.0-rc.2",
+    "@tauri-apps/cli-darwin-arm64": "1.0.0-rc.2",
+    "@tauri-apps/cli-linux-arm64-gnu": "1.0.0-rc.2",
+    "@tauri-apps/cli-linux-arm64-musl": "1.0.0-rc.2",
+    "@tauri-apps/cli-linux-arm-gnueabihf": "1.0.0-rc.2",
+    "@tauri-apps/cli-linux-x64-musl": "1.0.0-rc.2"
   }
-}
+}

package/src/lib.rs

@@ -0,0 +1,10 @@
+// Copyright 2019-2021 Tauri Programme within The Commons Conservancy
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-License-Identifier: MIT
+
+use napi::{Error, Result, Status};
+
+#[napi_derive::napi]
+pub fn run(args: Vec<String>, bin_name: Option<String>) -> Result<()> {
+  tauri_cli::run(args, bin_name).map_err(|e| Error::new(Status::GenericFailure, e.to_string()))
+}

package/tauri.js

@@ -0,0 +1,50 @@
+#!/usr/bin/env node
+
+const cli = require('./index')
+const path = require('path')
+
+const [bin, script, ...arguments] = process.argv
+const binStem = path.parse(bin).name.toLowerCase()
+
+// We want to make a helpful binary name for the underlying CLI helper, if we
+// can successfully detect what command likely started the execution.
+let binName
+
+// Even if started by a package manager, the binary will be NodeJS.
+// Some distribution still use "nodejs" as the binary name.
+if (binStem === 'node' || binStem === 'nodejs') {
+  const managerStem = process.env.npm_execpath
+    ? path.parse(process.env.npm_execpath).name.toLowerCase()
+    : null
+  if (managerStem) {
+    let manager
+    switch (managerStem) {
+      // Only supported package manager that has a different filename is npm.
+      case 'npm-cli':
+        manager = 'npm'
+        break
+
+      // Yarn and pnpm have the same stem name as their bin.
+      // We assume all unknown package managers do as well.
+      default:
+        manager = managerStem
+        break
+    }
+
+    binName = `${manager} run ${process.env.npm_lifecycle_event}`
+  } else {
+    // Assume running NodeJS if we didn't detect a manager from the env.
+    // We normalize the path to prevent the script's absolute path being used.
+    const scriptNormal = path.normalize(path.relative(process.cwd(), script))
+    binName = `${binStem} ${scriptNormal}`
+  }
+} else {
+  // We don't know what started it, assume it's already stripped.
+  arguments.unshift(bin)
+}
+
+try {
+  cli.run(arguments, binName)
+} catch (e) {
+  console.log(`Error running CLI: ${e.message}`)
+}

package/test/jest/__tests__/template.spec.js

@@ -0,0 +1,41 @@
+const fixtureSetup = require('../fixtures/app-test-setup.js')
+const { resolve } = require('path')
+const { existsSync, readFileSync, writeFileSync } = require('fs')
+const { move } = require('fs-extra')
+const cli = require('~/index.js')
+
+const currentDirName = __dirname
+
+describe('[CLI] cli.js template', () => {
+  it('init a project and builds it', async () => {
+    const cwd = process.cwd()
+    const fixturePath = resolve(currentDirName, '../fixtures/empty')
+    const tauriFixturePath = resolve(fixturePath, 'src-tauri')
+    const outPath = resolve(tauriFixturePath, 'target')
+    const cacheOutPath = resolve(fixturePath, 'target')
+
+    fixtureSetup.initJest('empty')
+
+    process.chdir(fixturePath)
+
+    const outExists = existsSync(outPath)
+    if (outExists) {
+      await move(outPath, cacheOutPath)
+    }
+
+    cli.run(['init', '--directory', process.cwd(), '--force', '--tauri-path', resolve(currentDirName, '../../../../../..'), '--ci'])
+
+    if (outExists) {
+      await move(cacheOutPath, outPath)
+    }
+
+    process.chdir(tauriFixturePath)
+
+    const manifestPath = resolve(tauriFixturePath, 'Cargo.toml')
+    const manifestFile = readFileSync(manifestPath).toString()
+    writeFileSync(manifestPath, `workspace = { }\n${manifestFile}`)
+
+    cli.run(['build', '--verbose'])
+    process.chdir(cwd)
+  })
+})

package/test/jest/fixtures/app/dist/index.html

@@ -0,0 +1,140 @@
+<!DOCTYPE html>
+<html>
+  <body>
+    <script>
+      function callBackEnd(route, args) {
+        console.log(route)
+        console.log(args)
+        window.__TAURI__.http
+          .fetch('http://localhost:7000/' + route, {
+            method: 'POST',
+            body: window.__TAURI__.http.Body.json(args),
+            responseType: window.__TAURI__.http.ResponseType.Binary
+          })
+          .catch(console.error)
+      }
+
+      function reply(args) {
+        return callBackEnd('reply', args)
+      }
+
+      function sendError(error) {
+        return callBackEnd('error', error)
+      }
+
+      function testFs(dir) {
+        var contents = 'TAURI E2E TEST FILE'
+        var commandSuffix = dir ? 'WithDir' : ''
+
+        var options = {
+          dir: dir || null
+        }
+
+        return window.__TAURI__.fs
+          .writeFile(
+            {
+              path: 'tauri-test.txt',
+              contents: contents
+            },
+            options
+          )
+          .then(function (res) {
+            reply({
+              cmd: 'writeFile' + commandSuffix
+            })
+            return window.__TAURI__.fs
+              .readTextFile('tauri-test.txt', options)
+              .then(function (res) {
+                if (res === contents) {
+                  reply({
+                    cmd: 'readFile' + commandSuffix
+                  })
+
+                  return window.__TAURI__.fs
+                    .readDir('.', options)
+                    .then((res) => {
+                      reply({
+                        cmd: 'readDir' + commandSuffix
+                      })
+
+                      return window.__TAURI__.fs
+                        .copyFile(
+                          'tauri-test.txt',
+                          'tauri-test-copy.txt',
+                          options
+                        )
+                        .then(function (res) {
+                          reply({
+                            cmd: 'copyFile' + commandSuffix
+                          })
+
+                          return window.__TAURI__.fs
+                            .createDir('tauri-test-dir', options)
+                            .then(function (res) {
+                              reply({
+                                cmd: 'createDir' + commandSuffix
+                              })
+                              return window.__TAURI__.fs
+                                .removeDir('tauri-test-dir', options)
+                                .then(function (res) {
+                                  reply({
+                                    cmd: 'removeDir' + commandSuffix
+                                  })
+                                })
+                            })
+                            .then(function (res) {
+                              return window.__TAURI__.fs
+                                .renameFile(
+                                  'tauri-test.txt',
+                                  'tauri.testt.txt',
+                                  options
+                                )
+                                .then(function (res) {
+                                  reply({
+                                    cmd: 'renameFile' + commandSuffix
+                                  })
+                                  return Promise.all([
+                                    window.__TAURI__.fs.removeFile(
+                                      'tauri.testt.txt',
+                                      options
+                                    ),
+                                    window.__TAURI__.fs.removeFile(
+                                      'tauri-test-copy.txt',
+                                      options
+                                    )
+                                  ]).then(function (res) {
+                                    reply({
+                                      cmd: 'removeFile' + commandSuffix
+                                    })
+                                  })
+                                })
+                            })
+                        })
+                    })
+                } else {
+                  sendError('expected "' + contents + '" found "' + res + '"')
+                }
+              })
+          })
+          .catch(sendError)
+      }
+
+      window.__TAURI__.event.listen('reply', function (res) {
+        reply({
+          cmd: 'listen'
+        })
+      })
+      window.onTauriInit = function () {
+        window.__TAURI__.event.emit('hello')
+      }
+
+      testFs(null).then(function () {
+        testFs(window.__TAURI__.fs.Dir.Config)
+      })
+
+      setTimeout(function () {
+        window.__TAURI__.invoke('exit')
+      }, 15000)
+    </script>
+  </body>
+</html>