@ohos-ports/dprint 0.57.4-beta.0

package/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2019 David Sherret
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,3 @@
+# dprint
+
+npm CLI distribution for [dprint](https://dprint.dev)—a pluggable and configurable code formatting platform.

package/bin.cjs

@@ -0,0 +1,45 @@
+#!/usr/bin/env node
+
+// @ts-check
+const path = require("path");
+const child_process = require("child_process");
+const os = require("os");
+const fs = require("fs");
+
+const exePath = path.join(__dirname, os.platform() === "win32" ? "dprint.exe" : "dprint");
+
+if (!fs.existsSync(exePath)) {
+  try {
+    const resolvedExePath = require("./install_api.cjs").runInstall();
+    runDprintExe(resolvedExePath);
+  } catch (err) {
+    if (err !== undefined && typeof err.message === "string") {
+      console.error(err.message);
+    } else {
+      console.error(err);
+    }
+    process.exit(1);
+  }
+} else {
+  runDprintExe(exePath);
+}
+
+/** @param exePath {string} */
+function runDprintExe(exePath) {
+  const result = child_process.spawnSync(
+    exePath,
+    process.argv.slice(2),
+    { stdio: "inherit" },
+  );
+  if (result.error) {
+    if (!fs.existsSync(exePath)) {
+      throw new Error(
+        "Could not find exe at path '" + exePath
+          + "'. Maybe try installing dprint again.",
+      );
+    }
+    throw result.error;
+  }
+
+  process.exit(result.status ?? 1);
+}

package/hashes.json

@@ -0,0 +1,17 @@
+{
+  "win32-x64": "a8ec907ca5d8209dcd21813ac7bcdaf2566e398f7b8b1357447849be95ffa3f7",
+  "win32-arm64": "8184d491b187b939e30d4f5f80c6a6f74d4c11341e01831e808dfd1028b41168",
+  "darwin-x64": "68773d368320d1f77839fcf555215a8dc12b1bbe8764e8c447f25e997161b193",
+  "darwin-arm64": "0057b28516b3f362b7ca6ca6c8e39a776a19d21532e4f3c3abfe46c2b427a541",
+  "linux-x64-glibc": "b74887f9292a5d3f9f1f027e0f4d6797630fb0be9e7e14f9672f72c0b1d7a672",
+  "linux-x64-musl": "658126efd9559d62e2cd97118a6b7a726ebd878000c7f49b8cdfa7d452ca40d8",
+  "linux-arm64-glibc": "b9560ba52e91b56cfec96d82487e41355981b9c46b172927a2adaefed8d14888",
+  "linux-arm64-musl": "bdc1c02243704b0885d124ca02ac2e34e037a0d59ca3bdfe27000c3168daf47a",
+  "linux-riscv64-glibc": "90b1e411465dcbdc5cd638601a4523940fc91a5532771539fbbab22f15623d0d",
+  "linux-loong64-glibc": "bd6fe25bd25208890657c2390b7f0fdf5fe2add780c0f55728d6651e13ee84b0",
+  "linux-loong64-musl": "54666d4b9b96d75bf623d4158a10652ecefe21616f5117003c7adc2706df040f",
+  "linux-ppc64-glibc": "59ff33c1ff835de4a0f6d4b173832d18ca9010c30f415e3903e4f60a671da43f",
+  "linux-ppc64-musl": "be8a21775a2f9810f2a3751699e820b672889c0c5cbe0012453c348aa7c8253a",
+  "android-arm64": "460cda654cda96c740f3a18deb9b1bbe1006d94d4143cd911d6692878754a780",
+  "android-x64": "9f059c8d7b38a2c3421323e0536a0f1453428647f01bcc517c04d8d9c36eb656"
+}

package/install.cjs

@@ -0,0 +1,61 @@
+// @ts-check
+"use strict";
+
+const os = require("os");
+const api = require("./install_api.cjs");
+
+/**
+ * Ensures the @ohos-ports/dprint-openharmony-arm64 optional dependency is
+ * installed. On HarmonyOS, npm skips optional dependencies whose declared
+ * `libc` (glibc/musl) does not match the runtime (HarmonyOS reports no
+ * libc at all), so the platform package is installed manually with
+ * `--force` when it is missing.
+ */
+function ensureOpenHarmonyPlatformPackage() {
+  if (os.platform() !== "openharmony") return;
+  const packageName = "@ohos-ports/dprint-openharmony-arm64";
+  try {
+    require.resolve(packageName + "/package.json");
+    return; // already installed
+  } catch {
+    // not installed yet
+  }
+  try {
+    const manifest = require("./package.json");
+    const spec = (manifest.optionalDependencies || {})[packageName];
+    if (spec == null) return;
+    require("child_process").execFileSync(
+      "npm",
+      [
+        "install",
+        packageName + "@" + spec,
+        "--force",
+        // npm's platform check rejects the package because HarmonyOS reports
+        // no libc (the package declares libc glibc/musl), so override the
+        // os/cpu/libc that npm uses for the check
+        "--os=linux",
+        "--cpu=arm64",
+        "--libc=glibc",
+        "--ignore-scripts",
+        "--no-save",
+        "--no-audit",
+        "--no-fund",
+      ],
+      { stdio: "inherit", shell: process.platform === "win32" },
+    );
+  } catch (err) {
+    // not fatal: runInstall() below falls back to downloading the binary
+    // from the registry tarball directly
+    if (process.env.DPRINT_DEBUG === "1") {
+      console.warn("[dprint] Failed to install " + packageName + ":", err);
+    }
+  }
+}
+
+ensureOpenHarmonyPlatformPackage();
+const exePath = api.runInstall();
+try {
+  api.replaceBinEntry(exePath);
+} catch (_err) {
+  // ignore - falls back to bin.cjs
+}

package/install_api.cjs

@@ -0,0 +1,534 @@
+// @ts-check
+"use strict";
+
+const fs = require("fs");
+const os = require("os");
+const path = require("path");
+/** @type {boolean | undefined} */
+let cachedIsMusl = undefined;
+
+module.exports = {
+  replaceBinEntry,
+  runInstall() {
+    const dprintFileName = os.platform() === "win32" ? "dprint.exe" : "dprint";
+    const targetExecutablePath = path.join(
+      __dirname,
+      dprintFileName,
+    );
+
+    if (fs.existsSync(targetExecutablePath)) {
+      return targetExecutablePath;
+    }
+
+    const target = getTarget();
+    const sourceExecutablePath = resolveSourceExecutablePath(target, dprintFileName);
+
+    if (sourceExecutablePath == null) {
+      // the @dprint/<target> optional dependency isn't installed (for example
+      // the user ran `npm install --omit=optional`), so download the binary
+      // directly from the registry like esbuild does
+      downloadExecutable(target, dprintFileName, targetExecutablePath);
+      if (os.platform() !== "win32") {
+        // chmod +x
+        chmodX(targetExecutablePath);
+      }
+      return targetExecutablePath;
+    }
+
+    try {
+      if (process.env.DPRINT_SIMULATED_READONLY_FILE_SYSTEM === "1") {
+        console.warn("Simulating readonly file system for testing.");
+        throw new Error("Throwing for testing purposes.");
+      }
+
+      // in order to make things faster the next time we run and to allow the
+      // dprint vscode extension to easily pick this up, copy the executable
+      // into the dprint package folder
+      hardLinkOrCopy(sourceExecutablePath, targetExecutablePath);
+      if (os.platform() !== "win32") {
+        // chmod +x
+        chmodX(targetExecutablePath);
+      }
+      return targetExecutablePath;
+    } catch (err) {
+      // this may fail on readonly file systems... in this case, fall
+      // back to using the resolved package path
+      if (process.env.DPRINT_DEBUG === "1") {
+        console.warn(
+          "Failed to copy executable from "
+            + sourceExecutablePath + " to " + targetExecutablePath
+            + ". Using resolved package path instead.",
+          err,
+        );
+      }
+      return sourceExecutablePath;
+    }
+  },
+};
+
+/**
+ * Resolves the path to the executable provided by the @dprint/<target>
+ * optional dependency, or undefined when that package isn't installed.
+ * @param target {string}
+ * @param dprintFileName {string}
+ * @returns {string | undefined}
+ */
+function resolveSourceExecutablePath(target, dprintFileName) {
+  // candidate packages to resolve the executable from, in priority order.
+  // The @dprint/openharmony-arm64 package does not exist on npm; the
+  // HarmonyOS openharmony-arm64 binary is published under the @ohos-ports
+  // scope instead (@ohos-ports/dprint-openharmony-arm64), so try that first.
+  const candidates = [];
+  if (target === "openharmony-arm64") {
+    candidates.push("@ohos-ports/dprint-" + target);
+  }
+  candidates.push("@dprint/" + target);
+  for (const packageName of candidates) {
+    try {
+      const sourcePackagePath = path.dirname(
+        require.resolve(packageName + "/package.json"),
+      );
+      const sourceExecutablePath = path.join(sourcePackagePath, dprintFileName);
+      if (fs.existsSync(sourceExecutablePath)) {
+        return sourceExecutablePath;
+      }
+    } catch {
+      // the optional dependency wasn't installed, try the next candidate
+    }
+  }
+  return undefined;
+}
+
+/**
+ * Downloads the binary tarball for the target from the registry and extracts
+ * the executable to the destination path.
+ * @param target {string}
+ * @param dprintFileName {string}
+ * @param destinationPath {string}
+ */
+function downloadExecutable(target, dprintFileName, destinationPath) {
+  const manifest = require("./package.json");
+  const registry = (process.env.npm_config_registry || "https://registry.npmjs.org")
+    .replace(/\/+$/, "");
+  // npm tarball urls drop the scope from the file name (e.g.
+  // https://registry.npmjs.org/@dprint/win32-x64/-/win32-x64-1.0.0.tgz)
+  // candidate packages to download the binary tarball from, in priority order.
+  // @dprint/openharmony-arm64 does not exist on npm, so for that target the
+  // binary is downloaded from @ohos-ports/dprint-openharmony-arm64 instead.
+  const candidates = [];
+  if (target === "openharmony-arm64") {
+    const versionRange = (manifest.optionalDependencies || {})["@ohos-ports/dprint-" + target];
+    candidates.push({
+      packageName: "@ohos-ports/dprint-" + target,
+      // tarball urls need an exact version, so strip any range prefix (^ ~)
+      version: versionRange == null ? manifest.version : versionRange.replace(/^[~^]\s*/, ""),
+      // hashes.json only contains hashes of official @dprint binaries, so
+      // skip the sha256 check for @ohos-ports published binaries
+      skipHashVerification: true,
+    });
+  }
+  candidates.push({
+    packageName: "@dprint/" + target,
+    version: manifest.version,
+    skipHashVerification: false,
+  });
+  let lastError;
+  for (const candidate of candidates) {
+    const tarballUrl = registry + "/" + candidate.packageName + "/-/"
+      + candidate.packageName.split("/")[1] + "-" + candidate.version + ".tgz";
+    console.error("[dprint] Optional dependency " + candidate.packageName
+      + " was not installed. Downloading from " + tarballUrl);
+    try {
+      const tarballBuffer = downloadBufferSync(tarballUrl);
+      // files inside an npm tarball live under the "package/" directory
+      const executableBuffer = extractFileFromTarGzip(tarballBuffer, "package/" + dprintFileName);
+      if (!candidate.skipHashVerification) {
+        verifyExecutableHash(target, executableBuffer);
+      }
+      atomicWriteFile(destinationPath, executableBuffer);
+      return;
+    } catch (err) {
+      lastError = err;
+    }
+  }
+  throw lastError;
+}
+
+/**
+ * Verifies the downloaded executable against the hash recorded at build time
+ * so that we only ever run the exact binary that was published.
+ * @param target {string}
+ * @param buffer {Buffer}
+ */
+function verifyExecutableHash(target, buffer) {
+  let hashes;
+  try {
+    hashes = require("./hashes.json");
+  } catch (err) {
+    throw new Error("Could not load hashes.json to verify the downloaded binary: " + (err && err.message || err));
+  }
+  const expected = hashes[target];
+  if (typeof expected !== "string") {
+    throw new Error("No known hash for @dprint/" + target + " to verify the download against.");
+  }
+  const actual = require("crypto").createHash("sha256").update(buffer).digest("hex");
+  if (actual !== expected) {
+    throw new Error(
+      "Integrity check failed for the downloaded @dprint/" + target + " binary.\n"
+        + "  Expected sha256: " + expected + "\n"
+        + "  Actual sha256:   " + actual,
+    );
+  }
+}
+
+/**
+ * Downloads a url to a buffer synchronously. Prefer curl since it transparently
+ * supports proxies (http_proxy/https_proxy/no_proxy and npm's proxy config),
+ * redirects and TLS, then fall back to node for environments without curl.
+ * @param url {string}
+ * @returns {Buffer}
+ */
+function downloadBufferSync(url) {
+  const fromCurl = downloadBufferWithCurl(url);
+  return fromCurl != null ? fromCurl : downloadBufferWithNode(url);
+}
+
+/**
+ * @param url {string}
+ * @returns {Buffer | undefined} undefined when curl isn't available
+ */
+function downloadBufferWithCurl(url) {
+  // -f: fail on http errors, -s: silent, -S: still show errors, -L: follow redirects
+  const args = ["-fsSL"];
+  const proxy = process.env.npm_config_https_proxy
+    || process.env.npm_config_proxy
+    || process.env.HTTPS_PROXY
+    || process.env.https_proxy;
+  if (proxy) {
+    args.push("--proxy", proxy);
+  }
+  const noProxy = process.env.npm_config_noproxy || process.env.NO_PROXY || process.env.no_proxy;
+  if (noProxy) {
+    args.push("--noproxy", noProxy);
+  }
+  args.push("-o", "-", url);
+  try {
+    return require("child_process").execFileSync("curl", args, { maxBuffer: 512 * 1024 * 1024 });
+  } catch (err) {
+    if (err && err.code === "ENOENT") {
+      // curl isn't installed, fall back to node
+      return undefined;
+    }
+    throw err;
+  }
+}
+
+/**
+ * Node has no synchronous https client, so spawn a child node process that
+ * streams the response to stdout. Does not support proxies.
+ * @param url {string}
+ * @returns {Buffer}
+ */
+function downloadBufferWithNode(url) {
+  const script = "const https=require('https');"
+    + "function f(u){https.get(u,r=>{"
+    + "const s=r.statusCode;"
+    + "if((s===301||s===302||s===303||s===307||s===308)&&r.headers.location){f(new URL(r.headers.location,u).toString());return;}"
+    + "if(s!==200){console.error('[dprint] Unexpected status code '+s+' downloading '+u);process.exit(1);}"
+    + "r.pipe(process.stdout);"
+    + "}).on('error',e=>{console.error(String(e&&e.message||e));process.exit(1);});}"
+    + "f(process.argv[1]);";
+  return require("child_process").execFileSync(
+    process.execPath,
+    ["-e", script, url],
+    { maxBuffer: 512 * 1024 * 1024 },
+  );
+}
+
+/**
+ * Extracts a single file from a gzipped tarball buffer.
+ * @param buffer {Buffer}
+ * @param subpath {string}
+ * @returns {Buffer}
+ */
+function extractFileFromTarGzip(buffer, subpath) {
+  const zlib = require("zlib");
+  let tar;
+  try {
+    tar = zlib.gunzipSync(buffer);
+  } catch (err) {
+    throw new Error("Invalid gzip data in downloaded tarball: " + (err && err.message || err));
+  }
+  let offset = 0;
+  while (offset < tar.length) {
+    const name = readTarString(tar, offset, 100);
+    const size = parseInt(readTarString(tar, offset + 124, 12).trim(), 8);
+    offset += 512;
+    if (!isNaN(size)) {
+      if (name === subpath) {
+        return tar.subarray(offset, offset + size);
+      }
+      // entries are padded to 512 byte boundaries
+      offset += (size + 511) & ~511;
+    }
+  }
+  throw new Error("Could not find " + JSON.stringify(subpath) + " in downloaded tarball");
+}
+
+/**
+ * @param buffer {Buffer}
+ * @param offset {number}
+ * @param length {number}
+ */
+function readTarString(buffer, offset, length) {
+  return buffer.toString("utf8", offset, offset + length).replace(/\0.*$/, "");
+}
+
+/**
+ * @param destinationPath {string}
+ * @param buffer {Buffer}
+ */
+function atomicWriteFile(destinationPath, buffer) {
+  const crypto = require("crypto");
+  const rand = crypto.randomBytes(4).toString("hex");
+  const tempFilePath = destinationPath + "." + rand;
+  fs.writeFileSync(tempFilePath, buffer);
+  try {
+    fs.renameSync(tempFilePath, destinationPath);
+  } catch (err) {
+    // will maybe throw when another process had already done this
+    // so just ignore and delete the created temporary file
+    try {
+      fs.unlinkSync(tempFilePath);
+    } catch (_err2) {
+      // ignore
+    }
+    throw err;
+  }
+}
+
+/** @filePath {string} */
+function chmodX(filePath) {
+  const fd = fs.openSync(filePath, "r");
+  try {
+    const perms = fs.fstatSync(fd).mode;
+    fs.fchmodSync(fd, perms | 0o111);
+  } finally {
+    fs.closeSync(fd);
+  }
+}
+
+function getTarget() {
+  const platform = os.platform();
+  if (platform === "linux") {
+    return platform + "-" + getArch() + "-" + getLinuxFamily();
+  } else {
+    return platform + "-" + getArch();
+  }
+}
+
+function getArch() {
+  const arch = os.arch();
+  if (arch !== "arm64" && arch !== "x64" && arch !== "riscv64" && arch !== "loong64" && arch !== "ppc64") {
+    throw new Error("Unsupported architecture " + os.arch() + ". Only x64, arm64, riscv64, loong64 and ppc64 binaries are available.");
+  }
+  return arch;
+}
+
+function getLinuxFamily() {
+  return getIsMusl() ? "musl" : "glibc";
+
+  function getIsMusl() {
+    // code adapted from https://github.com/napi-rs/package-template/blob/main/index.js
+    // which is in turn based on https://github.com/lovell/detect-libc (Apache 2.0 license)
+    if (cachedIsMusl == null) {
+      cachedIsMusl = innerGet();
+    }
+    return cachedIsMusl;
+
+    function innerGet() {
+      try {
+        if (os.platform() !== "linux") {
+          return false;
+        }
+        let musl = isMuslFromFilesystem();
+        if (musl == null) {
+          musl = isMuslFromReport();
+        }
+        if (musl == null) {
+          musl = isMuslFromChildProcess();
+        }
+        return musl;
+      } catch (err) {
+        // just in case
+        console.warn("Error checking if musl.", err);
+        return false;
+      }
+    }
+
+    function isMuslFromFilesystem() {
+      try {
+        return fs.readFileSync("/usr/bin/ldd", "utf-8").includes("musl");
+      } catch {
+        return null;
+      }
+    }
+
+    function isMuslFromReport() {
+      if (typeof process.report?.getReport !== "function") {
+        return null;
+      }
+      // excludeNetwork avoids a slow reverse DNS lookup while generating the
+      // report, but it's a global flag so restore it once we're done
+      const originalExcludeNetwork = process.report.excludeNetwork;
+      let rawReport;
+      try {
+        process.report.excludeNetwork = true;
+        rawReport = process.report.getReport();
+      } finally {
+        process.report.excludeNetwork = originalExcludeNetwork;
+      }
+      const report = typeof rawReport === "string" ? JSON.parse(rawReport) : rawReport;
+      if (!report) {
+        return null;
+      }
+      if (report.header && report.header.glibcVersionRuntime) {
+        return false;
+      }
+      if (Array.isArray(report.sharedObjects)) {
+        return report.sharedObjects.some(isFileMusl);
+      }
+      return false;
+    }
+
+    function isMuslFromChildProcess() {
+      try {
+        return require("child_process").execSync("ldd --version", { encoding: "utf8" }).includes("musl");
+      } catch {
+        return false;
+      }
+    }
+
+    function isFileMusl(f) {
+      return f.includes("libc.musl-") || f.includes("ld-musl-");
+    }
+  }
+}
+
+/**
+ * Replaces the bin entry in node_modules/.bin to point directly at the
+ * native binary, avoiding Node.js startup overhead on each invocation.
+ * @param exePath {string}
+ */
+function replaceBinEntry(exePath) {
+  const binDir = findBinDir();
+  if (binDir === undefined) return;
+
+  const relative = path.relative(binDir, exePath);
+  if (os.platform() === "win32") {
+    // rewrite .cmd and .ps1 wrappers to invoke the native binary directly
+    fs.writeFileSync(
+      path.join(binDir, "dprint.cmd"),
+      "@\"%~dp0" + relative + "\" %*\r\n",
+    );
+    fs.writeFileSync(
+      path.join(binDir, "dprint.ps1"),
+      "& \"$PSScriptRoot/" + relative.replace(/\\/g, "/")
+        + "\" $args\r\nexit $LASTEXITCODE\r\n",
+    );
+  } else {
+    // replace symlink to point directly at the native binary
+    const binDprint = path.join(binDir, "dprint");
+    fs.unlinkSync(binDprint);
+    fs.symlinkSync(relative, binDprint);
+  }
+}
+
+function findBinDir() {
+  // For global installs, npm sets npm_config_global=true and npm_config_prefix
+  // to the install prefix. The bin dir is {prefix}/bin on Linux/Mac or
+  // {prefix} on Windows (e.g. %APPDATA%\npm).
+  if (process.env.npm_config_global === "true") {
+    const prefix = process.env.npm_config_prefix;
+    if (prefix) {
+      const binDir = os.platform() === "win32"
+        ? prefix
+        : path.join(prefix, "bin");
+      if (isBinDirForThisPackage(binDir)) {
+        return binDir;
+      }
+    }
+  }
+
+  // For local installs, walk up looking for node_modules/.bin
+  let dir = __dirname;
+  for (let i = 0; i < 64; i++) {
+    const parent = path.dirname(dir);
+    if (parent === dir) {
+      break;
+    }
+    if (path.basename(parent) === "node_modules") {
+      const binDir = path.join(parent, ".bin");
+      if (isBinDirForThisPackage(binDir)) {
+        return binDir;
+      }
+    }
+    dir = parent;
+  }
+  return undefined;
+}
+
+function isBinDirForThisPackage(binDir) {
+  try {
+    if (os.platform() === "win32") {
+      // verify the .cmd wrapper references our bin.cjs
+      const content = fs.readFileSync(
+        path.join(binDir, "dprint.cmd"),
+        "utf8",
+      );
+      return content.includes("bin.cjs");
+    } else {
+      // verify the symlink points into our package directory
+      const linkTarget = fs.readlinkSync(path.join(binDir, "dprint"));
+      const resolved = path.resolve(binDir, linkTarget);
+      return resolved.endsWith("bin.cjs");
+    }
+  } catch (_err) {
+    return false;
+  }
+}
+
+/**
+ * @param sourcePath {string}
+ * @param destinationPath {string}
+ */
+function hardLinkOrCopy(sourcePath, destinationPath) {
+  try {
+    fs.linkSync(sourcePath, destinationPath);
+  } catch {
+    atomicCopyFile(sourcePath, destinationPath);
+  }
+}
+
+/**
+ * @param sourcePath {string}
+ * @param destinationPath {string}
+ */
+function atomicCopyFile(sourcePath, destinationPath) {
+  const crypto = require("crypto");
+  const rand = crypto.randomBytes(4).toString("hex");
+  const tempFilePath = destinationPath + "." + rand;
+  fs.copyFileSync(sourcePath, tempFilePath);
+  try {
+    fs.renameSync(tempFilePath, destinationPath);
+  } catch (err) {
+    // will maybe throw when another process had already done this
+    // so just ignore and delete the created temporary file
+    try {
+      fs.unlinkSync(tempFilePath);
+    } catch (_err2) {
+      // ignore
+    }
+    throw err;
+  }
+}

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "@ohos-ports/dprint",
+  "version": "0.57.4-beta.0",
+  "description": "Pluggable and configurable code formatting platform written in Rust.",
+  "bin": "bin.cjs",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ohos-ports/ohos-ports.git",
+    "directory": "ports/dprint/0.57.4"
+  },
+  "keywords": [
+    "code",
+    "formatter"
+  ],
+  "author": "David Sherret",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/ohos-ports/ohos-ports/issues"
+  },
+  "homepage": "https://github.com/ohos-ports/ohos-ports#readme",
+  "preferUnplugged": true,
+  "scripts": {
+    "postinstall": "node ./install.cjs"
+  },
+  "optionalDependencies": {
+    "@dprint/win32-x64": "0.57.4",
+    "@dprint/win32-arm64": "0.57.4",
+    "@dprint/darwin-x64": "0.57.4",
+    "@dprint/darwin-arm64": "0.57.4",
+    "@dprint/linux-x64-glibc": "0.57.4",
+    "@dprint/linux-x64-musl": "0.57.4",
+    "@dprint/linux-arm64-glibc": "0.57.4",
+    "@dprint/linux-arm64-musl": "0.57.4",
+    "@dprint/linux-riscv64-glibc": "0.57.4",
+    "@dprint/linux-loong64-glibc": "0.57.4",
+    "@dprint/linux-loong64-musl": "0.57.4",
+    "@dprint/linux-ppc64-glibc": "0.57.4",
+    "@dprint/linux-ppc64-musl": "0.57.4",
+    "@dprint/android-arm64": "0.57.4",
+    "@dprint/android-x64": "0.57.4",
+    "@ohos-ports/dprint-openharmony-arm64": "^0.57.4-beta.1"
+  }
+}