get-node/build/src/archive/p7z.js

Download a specific version of Node.js

import{createWriteStream}from"node:fs";
import{unlink}from"node:fs/promises";
import{delimiter,normalize}from"node:path";
import{env}from"node:process";
import{pipeline}from"node:stream/promises";

import{execa}from"execa";
import memoize from"memoize";
import pathKey from"path-key";
import semver from"semver";

import{fetchNodeUrl,promiseOrFetchError,writeNodeBinary}from"../fetch.js";





export const shouldUse7z=(version)=>versionHas7z(version)&&has7zBinary();

const versionHas7z=(version)=>semver.satisfies(version,P7Z_VERSION_RANGE);

const P7Z_VERSION_RANGE="^4.5.0 || >=6.2.1";

const mHas7zBinary=async()=>{
const{failed}=await execa("7z",{
reject:false,
stdio:"ignore",
env:getEnv()
});
return!failed
};

const has7zBinary=memoize(mHas7zBinary);




export const download7z=async({version,tmpFile,arch,fetchOpts})=>{
const filepath=get7zFilepath(version,arch);
const tmp7zFile=`${tmpFile}.7z`;

const{response,checksumError}=await fetchNodeUrl(
version,
`${filepath}.7z`,
fetchOpts
);
await pipeline(response,createWriteStream(tmp7zFile));
const subprocess=execa(
"7z",
["x","-so",`-i!${filepath}/node.exe`,tmp7zFile],
{
stdin:"ignore",
stdout:["pipe",writeNodeBinary(tmpFile)],
stderr:"ignore",
buffer:false,
env:getEnv()
}
);

try{
await promiseOrFetchError(subprocess,response)
}finally{
await cleanup(tmp7zFile,subprocess)
}

return checksumError
};

const get7zFilepath=(version,arch)=>`node-v${version}-win-${arch}`;


const getEnv=()=>{
const path=`${env[PATH_KEY]}${delimiter}${P7Z_PATH}`;
return{Path:path,PATH:path}
};

const P7Z_PATH=normalize("/Program Files/7-Zip");
const PATH_KEY=pathKey();

const cleanup=async(tmp7zFile,subprocess)=>{
await unlink(tmp7zFile);
subprocess.kill()
};