2021-02-22 17:27:16 +07:00
/******/ ( ( ) => { // webpackBootstrap
2019-11-24 06:44:53 +07:00
/******/ "use strict" ;
2021-02-22 17:27:16 +07:00
/******/ var _ _webpack _modules _ _ = ( {
2021-04-26 16:42:09 +07:00
/***/ 88 :
2021-02-22 17:27:16 +07:00
/***/ ( function ( _ _unused _webpack _module , exports , _ _nccwpck _require _ _ ) {
2021-04-26 16:42:09 +07:00
var _ _createBinding = ( this && this . _ _createBinding ) || ( Object . create ? ( function ( o , m , k , k2 ) {
if ( k2 === undefined ) k2 = k ;
Object . defineProperty ( o , k2 , { enumerable : true , get : function ( ) { return m [ k ] ; } } ) ;
} ) : ( function ( o , m , k , k2 ) {
if ( k2 === undefined ) k2 = k ;
o [ k2 ] = m [ k ] ;
} ) ) ;
var _ _setModuleDefault = ( this && this . _ _setModuleDefault ) || ( Object . create ? ( function ( o , v ) {
Object . defineProperty ( o , "default" , { enumerable : true , value : v } ) ;
} ) : function ( o , v ) {
o [ "default" ] = v ;
} ) ;
2021-02-22 17:27:16 +07:00
var _ _importStar = ( this && this . _ _importStar ) || function ( mod ) {
if ( mod && mod . _ _esModule ) return mod ;
var result = { } ;
2021-04-26 16:42:09 +07:00
if ( mod != null ) for ( var k in mod ) if ( k !== "default" && Object . prototype . hasOwnProperty . call ( mod , k ) ) _ _createBinding ( result , mod , k ) ;
_ _setModuleDefault ( result , mod ) ;
2021-02-22 17:27:16 +07:00
return result ;
} ;
Object . defineProperty ( exports , "__esModule" , ( { value : true } ) ) ;
2021-04-26 16:42:09 +07:00
exports . addINIValues = exports . addINIValuesWindows = exports . addINIValuesUnix = void 0 ;
const utils = _ _importStar ( _ _nccwpck _require _ _ ( 918 ) ) ;
async function addINIValuesUnix ( ini _values _csv ) {
const ini _values = await utils . CSVArray ( ini _values _csv ) ;
let script = '' ;
await utils . asyncForEach ( ini _values , async function ( line ) {
script +=
'\n' + ( await utils . addLog ( '$tick' , line , 'Added to php.ini' , 'linux' ) ) ;
} ) ;
return ( 'echo "' +
ini _values . join ( '\n' ) +
'" | sudo tee -a "${pecl_file:-${ini_file[@]}}" >/dev/null 2>&1' +
script ) ;
2021-02-22 17:27:16 +07:00
}
2021-04-26 16:42:09 +07:00
exports . addINIValuesUnix = addINIValuesUnix ;
async function addINIValuesWindows ( ini _values _csv ) {
const ini _values = await utils . CSVArray ( ini _values _csv ) ;
let script = '\n' ;
await utils . asyncForEach ( ini _values , async function ( line ) {
script +=
( await utils . addLog ( '$tick' , line , 'Added to php.ini' , 'win32' ) ) + '\n' ;
} ) ;
return ( 'Add-Content "$php_dir\\php.ini" "' + ini _values . join ( '\n' ) + '"' + script ) ;
2021-02-22 17:27:16 +07:00
}
2021-04-26 16:42:09 +07:00
exports . addINIValuesWindows = addINIValuesWindows ;
async function addINIValues ( ini _values _csv , os _version , no _step = false ) {
let script = '\n' ;
switch ( no _step ) {
case true :
script +=
( await utils . stepLog ( 'Add php.ini values' , os _version ) ) +
( await utils . suppressOutput ( os _version ) ) +
'\n' ;
break ;
case false :
default :
script += ( await utils . stepLog ( 'Add php.ini values' , os _version ) ) + '\n' ;
break ;
2021-02-22 17:27:16 +07:00
}
2021-04-26 16:42:09 +07:00
switch ( os _version ) {
case 'win32' :
return script + ( await addINIValuesWindows ( ini _values _csv ) ) ;
case 'darwin' :
case 'linux' :
return script + ( await addINIValuesUnix ( ini _values _csv ) ) ;
default :
return await utils . log ( 'Platform ' + os _version + ' is not supported' , os _version , 'error' ) ;
2021-02-22 17:27:16 +07:00
}
}
2021-04-26 16:42:09 +07:00
exports . addINIValues = addINIValues ;
2021-05-31 06:51:18 +07:00
//# sourceMappingURL=config.js.map
2021-02-22 17:27:16 +07:00
/***/ } ) ,
2019-11-24 06:44:53 +07:00
2021-04-26 16:42:09 +07:00
/***/ 730 :
2021-02-22 17:27:16 +07:00
/***/ ( function ( _ _unused _webpack _module , exports , _ _nccwpck _require _ _ ) {
2019-12-10 06:52:33 +07:00
2021-04-26 16:42:09 +07:00
var _ _createBinding = ( this && this . _ _createBinding ) || ( Object . create ? ( function ( o , m , k , k2 ) {
if ( k2 === undefined ) k2 = k ;
Object . defineProperty ( o , k2 , { enumerable : true , get : function ( ) { return m [ k ] ; } } ) ;
} ) : ( function ( o , m , k , k2 ) {
if ( k2 === undefined ) k2 = k ;
o [ k2 ] = m [ k ] ;
} ) ) ;
var _ _setModuleDefault = ( this && this . _ _setModuleDefault ) || ( Object . create ? ( function ( o , v ) {
Object . defineProperty ( o , "default" , { enumerable : true , value : v } ) ;
} ) : function ( o , v ) {
o [ "default" ] = v ;
} ) ;
2021-02-22 17:27:16 +07:00
var _ _importStar = ( this && this . _ _importStar ) || function ( mod ) {
if ( mod && mod . _ _esModule ) return mod ;
var result = { } ;
2021-04-26 16:42:09 +07:00
if ( mod != null ) for ( var k in mod ) if ( k !== "default" && Object . prototype . hasOwnProperty . call ( mod , k ) ) _ _createBinding ( result , mod , k ) ;
_ _setModuleDefault ( result , mod ) ;
2021-02-22 17:27:16 +07:00
return result ;
} ;
Object . defineProperty ( exports , "__esModule" , ( { value : true } ) ) ;
2021-04-26 16:42:09 +07:00
exports . addCoverage = exports . disableCoverage = exports . addCoveragePCOV = exports . addCoverageXdebug = void 0 ;
const utils = _ _importStar ( _ _nccwpck _require _ _ ( 918 ) ) ;
const extensions = _ _importStar ( _ _nccwpck _require _ _ ( 390 ) ) ;
const config = _ _importStar ( _ _nccwpck _require _ _ ( 88 ) ) ;
async function addCoverageXdebug ( extension , version , os _version , pipe ) {
let script = '\n' ;
script +=
( await extensions . addExtension ( ':pcov' , version , os _version , true ) ) + pipe ;
script +=
( await extensions . addExtension ( extension , version , os _version , true ) ) +
pipe ;
script += await utils . addLog ( '$tick' , extension , 'Xdebug enabled as coverage driver' , os _version ) ;
return script ;
2021-02-22 17:27:16 +07:00
}
2021-04-26 16:42:09 +07:00
exports . addCoverageXdebug = addCoverageXdebug ;
async function addCoveragePCOV ( version , os _version , pipe ) {
let script = '\n' ;
switch ( true ) {
default :
script +=
( await extensions . addExtension ( ':xdebug' , version , os _version , true ) ) +
pipe ;
script +=
( await extensions . addExtension ( 'pcov' , version , os _version , true ) ) +
pipe ;
script +=
( await config . addINIValues ( 'pcov.enabled=1' , os _version , true ) ) + '\n' ;
script += await utils . addLog ( '$tick' , 'coverage: pcov' , 'PCOV enabled as coverage driver' , os _version ) ;
break ;
case /5\.[3-6]|7\.0/ . test ( version ) :
script += await utils . addLog ( '$cross' , 'pcov' , 'PHP 7.1 or newer is required' , os _version ) ;
break ;
2021-02-22 17:27:16 +07:00
}
2021-04-26 16:42:09 +07:00
return script ;
2021-02-22 17:27:16 +07:00
}
2021-04-26 16:42:09 +07:00
exports . addCoveragePCOV = addCoveragePCOV ;
async function disableCoverage ( version , os _version , pipe ) {
let script = '\n' ;
script +=
( await extensions . addExtension ( ':pcov' , version , os _version , true ) ) + pipe ;
script +=
( await extensions . addExtension ( ':xdebug' , version , os _version , true ) ) +
pipe ;
script += await utils . addLog ( '$tick' , 'none' , 'Disabled Xdebug and PCOV' , os _version ) ;
return script ;
2019-12-10 06:52:33 +07:00
}
2021-04-26 16:42:09 +07:00
exports . disableCoverage = disableCoverage ;
async function addCoverage ( coverage _driver , version , os _version ) {
coverage _driver = coverage _driver . toLowerCase ( ) ;
const script = '\n' + ( await utils . stepLog ( 'Setup Coverage' , os _version ) ) ;
const pipe = ( await utils . suppressOutput ( os _version ) ) + '\n' ;
switch ( coverage _driver ) {
case 'pcov' :
return script + ( await addCoveragePCOV ( version , os _version , pipe ) ) ;
case 'xdebug' :
case 'xdebug3' :
return ( script + ( await addCoverageXdebug ( 'xdebug' , version , os _version , pipe ) ) ) ;
case 'xdebug2' :
return ( script + ( await addCoverageXdebug ( 'xdebug2' , version , os _version , pipe ) ) ) ;
case 'none' :
return script + ( await disableCoverage ( version , os _version , pipe ) ) ;
default :
return '' ;
2021-02-22 17:27:16 +07:00
}
}
2021-04-26 16:42:09 +07:00
exports . addCoverage = addCoverage ;
2021-05-31 06:51:18 +07:00
//# sourceMappingURL=coverage.js.map
2021-02-22 17:27:16 +07:00
/***/ } ) ,
2021-04-26 16:42:09 +07:00
/***/ 390 :
2021-02-22 17:27:16 +07:00
/***/ ( function ( _ _unused _webpack _module , exports , _ _nccwpck _require _ _ ) {
2021-04-26 16:42:09 +07:00
var _ _createBinding = ( this && this . _ _createBinding ) || ( Object . create ? ( function ( o , m , k , k2 ) {
if ( k2 === undefined ) k2 = k ;
Object . defineProperty ( o , k2 , { enumerable : true , get : function ( ) { return m [ k ] ; } } ) ;
} ) : ( function ( o , m , k , k2 ) {
if ( k2 === undefined ) k2 = k ;
o [ k2 ] = m [ k ] ;
} ) ) ;
var _ _setModuleDefault = ( this && this . _ _setModuleDefault ) || ( Object . create ? ( function ( o , v ) {
Object . defineProperty ( o , "default" , { enumerable : true , value : v } ) ;
} ) : function ( o , v ) {
o [ "default" ] = v ;
} ) ;
2021-02-22 17:27:16 +07:00
var _ _importStar = ( this && this . _ _importStar ) || function ( mod ) {
if ( mod && mod . _ _esModule ) return mod ;
var result = { } ;
2021-04-26 16:42:09 +07:00
if ( mod != null ) for ( var k in mod ) if ( k !== "default" && Object . prototype . hasOwnProperty . call ( mod , k ) ) _ _createBinding ( result , mod , k ) ;
_ _setModuleDefault ( result , mod ) ;
2021-02-22 17:27:16 +07:00
return result ;
} ;
Object . defineProperty ( exports , "__esModule" , ( { value : true } ) ) ;
2021-04-26 16:42:09 +07:00
exports . addExtension = exports . addExtensionLinux = exports . addExtensionWindows = exports . addExtensionDarwin = void 0 ;
const utils = _ _importStar ( _ _nccwpck _require _ _ ( 918 ) ) ;
async function addExtensionDarwin ( extension _csv , version ) {
const extensions = await utils . extensionArray ( extension _csv ) ;
let add _script = '\n' ;
let remove _script = '' ;
await utils . asyncForEach ( extensions , async function ( extension ) {
const version _extension = version + extension ;
const [ ext _name , ext _version ] = extension . split ( '-' ) ;
const ext _prefix = await utils . getExtensionPrefix ( ext _name ) ;
switch ( true ) {
case /^:/ . test ( ext _name ) :
remove _script += '\nremove_extension ' + ext _name . slice ( 1 ) ;
return ;
case /.+-.+\/.+@.+/ . test ( extension ) :
add _script += await utils . parseExtensionSource ( extension , ext _prefix ) ;
return ;
case /^(5\.[3-6]|7\.[0-4]|8\.0)blackfire(-\d+\.\d+\.\d+)?$/ . test ( version _extension ) :
case /^couchbase$|^geos$|^pdo_oci$|^oci8$|^(pecl_)?http|^pdo_firebird$/ . test ( extension ) :
case /^(5\.[3-6]|7\.[0-4])ioncube$/ . test ( version _extension ) :
add _script += await utils . customPackage ( ext _name , 'ext' , extension , 'darwin' ) ;
return ;
case /.+-(stable|beta|alpha|devel|snapshot|rc|preview)/ . test ( extension ) :
add _script += await utils . joins ( '\nadd_unstable_extension' , ext _name , ext _version , ext _prefix ) ;
return ;
case /.+-\d+\.\d+\.\d+.*/ . test ( extension ) :
add _script += await utils . joins ( '\nadd_pecl_extension' , ext _name , ext _version , ext _prefix ) ;
return ;
case /(5\.[3-6]|7\.0)pcov/ . test ( version _extension ) :
add _script += await utils . getUnsupportedLog ( 'pcov' , version , 'darwin' ) ;
return ;
2021-06-16 01:26:55 +07:00
case /(?<!5\.[3-5])(amqp|apcu|grpc|igbinary|imagick|imap|memcache|memcached|msgpack|protobuf|psr|raphf|rdkafka|redis|swoole|xdebug|xdebug2|zmq)/ . test ( version _extension ) :
2021-04-26 16:42:09 +07:00
case /(5\.6|7\.[0-4])propro/ . test ( version _extension ) :
case /(?<!5\.[3-6]|7\.0)pcov/ . test ( version _extension ) :
case /(5\.6|7\.[0-3])phalcon3|7\.[2-4]phalcon4/ . test ( version _extension ) :
add _script += await utils . joins ( '\nadd_brew_extension' , ext _name , ext _prefix ) ;
return ;
case /^sqlite$/ . test ( extension ) :
extension = 'sqlite3' ;
break ;
default :
break ;
2019-12-10 06:52:33 +07:00
}
2021-04-26 16:42:09 +07:00
add _script += await utils . joins ( '\nadd_extension' , extension , ext _prefix ) ;
2019-12-10 06:52:33 +07:00
} ) ;
2021-04-26 16:42:09 +07:00
return add _script + remove _script ;
2019-12-10 06:52:33 +07:00
}
2021-04-26 16:42:09 +07:00
exports . addExtensionDarwin = addExtensionDarwin ;
async function addExtensionWindows ( extension _csv , version ) {
const extensions = await utils . extensionArray ( extension _csv ) ;
let add _script = '\n' ;
let remove _script = '' ;
await utils . asyncForEach ( extensions , async function ( extension ) {
const [ ext _name , ext _version ] = extension . split ( '-' ) ;
const version _extension = version + extension ;
let matches ;
switch ( true ) {
case /^:/ . test ( ext _name ) :
remove _script += '\nRemove-Extension ' + ext _name . slice ( 1 ) ;
break ;
case /^(5\.[3-6]|7\.[0-4]|8\.0)blackfire(-\d+\.\d+\.\d+)?$/ . test ( version _extension ) :
case /^pdo_oci$|^oci8$|^pdo_firebird$/ . test ( extension ) :
case /^(5\.[3-6]|7\.[0-4])ioncube$/ . test ( version _extension ) :
case /^7\.[0-3]phalcon3$|^7\.[2-4]phalcon4$/ . test ( version _extension ) :
case /^(7\.[1-4]|8\.0)(pecl_)?http/ . test ( version _extension ) :
add _script += await utils . customPackage ( ext _name , 'ext' , extension , 'win32' ) ;
return ;
case /.+-(stable|beta|alpha|devel|snapshot)/ . test ( extension ) :
add _script += await utils . joins ( '\nAdd-Extension' , ext _name , ext _version . replace ( 'stable' , '' ) ) ;
break ;
case /.+-.+\/.+@.+/ . test ( extension ) :
add _script += await utils . getUnsupportedLog ( extension , version , 'win32' ) ;
break ;
case /.+-\d+\.\d+\.\d+$/ . test ( extension ) :
add _script += await utils . joins ( '\nAdd-Extension' , ext _name , 'stable' , ext _version ) ;
break ;
case /.+-\d+\.\d+\.\d+[a-zA-Z]+\d*/ . test ( extension ) :
matches = /.+-(\d+\.\d+\.\d+)([a-zA-Z]+)\d*/ . exec ( version _extension ) ;
add _script += await utils . joins ( '\nAdd-Extension' , ext _name , matches [ 2 ] . replace ( 'preview' , 'devel' ) , matches [ 1 ] ) ;
break ;
case /7\.[2-4]xdebug2/ . test ( version _extension ) :
add _script += '\nAdd-Extension xdebug stable 2.9.8' ;
break ;
case /(5\.[3-6]|7\.0)pcov/ . test ( version _extension ) :
add _script += await utils . getUnsupportedLog ( 'pcov' , version , 'win32' ) ;
break ;
2021-04-27 16:47:29 +07:00
case /^5\.[3-6](?<!pdo_)(mysql|mysqli|mysqlnd)$/ . test ( version _extension ) :
2021-04-26 16:42:09 +07:00
add _script +=
'\nAdd-Extension mysql\nAdd-Extension mysqli\nAdd-Extension mysqlnd' ;
break ;
2021-04-27 16:47:29 +07:00
case /(?<!5\.[3-6])(?<!pdo_)(mysql|mysqli|mysqlnd)$/ . test ( version _extension ) :
2021-04-26 16:42:09 +07:00
add _script += '\nAdd-Extension mysqli\nAdd-Extension mysqlnd' ;
break ;
case /^sqlite$/ . test ( extension ) :
extension = 'sqlite3' ;
add _script += await utils . joins ( '\nAdd-Extension' , extension ) ;
break ;
default :
add _script += '\nAdd-Extension ' + extension ;
break ;
}
} ) ;
return add _script + remove _script ;
}
exports . addExtensionWindows = addExtensionWindows ;
async function addExtensionLinux ( extension _csv , version ) {
const extensions = await utils . extensionArray ( extension _csv ) ;
let add _script = '\n' ;
let remove _script = '' ;
await utils . asyncForEach ( extensions , async function ( extension ) {
const version _extension = version + extension ;
const [ ext _name , ext _version ] = extension . split ( '-' ) ;
const ext _prefix = await utils . getExtensionPrefix ( ext _name ) ;
switch ( true ) {
case /^:/ . test ( ext _name ) :
remove _script += '\nremove_extension ' + ext _name . slice ( 1 ) ;
return ;
case /.+-.+\/.+@.+/ . test ( extension ) :
add _script += await utils . parseExtensionSource ( extension , ext _prefix ) ;
return ;
case /^(5\.[3-6]|7\.[0-4]|8\.0)blackfire(-\d+\.\d+\.\d+)?$/ . test ( version _extension ) :
case /^((5\.[3-6])|(7\.[0-2]))pdo_cubrid$|^((5\.[3-6])|(7\.[0-4]))cubrid$/ . test ( version _extension ) :
case /^couchbase$|^gearman$|^geos$|^pdo_oci$|^oci8$|^(pecl_)?http|^pdo_firebird$/ . test ( extension ) :
case /(?<!5\.[3-5])intl-[\d]+\.[\d]+$/ . test ( version _extension ) :
case /^(5\.[3-6]|7\.[0-4])ioncube$/ . test ( version _extension ) :
case /^7\.[0-3]phalcon3$|^7\.[2-4]phalcon4$/ . test ( version _extension ) :
add _script += await utils . customPackage ( ext _name , 'ext' , extension , 'linux' ) ;
return ;
case /.+-(stable|beta|alpha|devel|snapshot|rc|preview)/ . test ( extension ) :
add _script += await utils . joins ( '\nadd_unstable_extension' , ext _name , ext _version , ext _prefix ) ;
return ;
case /.+-\d+\.\d+\.\d+.*/ . test ( extension ) :
add _script += await utils . joins ( '\nadd_pecl_extension' , ext _name , ext _version , ext _prefix ) ;
return ;
case /(5\.[3-6]|7\.0)pcov/ . test ( version _extension ) :
add _script += await utils . getUnsupportedLog ( 'pcov' , version , 'linux' ) ;
return ;
case /^7\.[2-4]xdebug2$/ . test ( version _extension ) :
add _script += await utils . joins ( '\nadd_pecl_extension' , 'xdebug' , '2.9.8' , ext _prefix ) ;
return ;
case /^pdo[_-].+/ . test ( extension ) :
extension = extension . replace ( /pdo[_-]|3/ , '' ) ;
add _script += '\nadd_pdo_extension ' + extension ;
return ;
case /^sqlite$/ . test ( extension ) :
extension = 'sqlite3' ;
break ;
default :
break ;
}
add _script += await utils . joins ( '\nadd_extension' , extension , ext _prefix ) ;
} ) ;
return add _script + remove _script ;
}
exports . addExtensionLinux = addExtensionLinux ;
async function addExtension ( extension _csv , version , os _version , no _step = false ) {
const log = await utils . stepLog ( 'Setup Extensions' , os _version ) ;
let script = '\n' ;
switch ( no _step ) {
case true :
script += log + ( await utils . suppressOutput ( os _version ) ) ;
break ;
case false :
default :
script += log ;
break ;
}
switch ( os _version ) {
case 'win32' :
return script + ( await addExtensionWindows ( extension _csv , version ) ) ;
case 'darwin' :
return script + ( await addExtensionDarwin ( extension _csv , version ) ) ;
case 'linux' :
return script + ( await addExtensionLinux ( extension _csv , version ) ) ;
default :
return await utils . log ( 'Platform ' + os _version + ' is not supported' , os _version , 'error' ) ;
}
}
exports . addExtension = addExtension ;
2021-05-31 06:51:18 +07:00
//# sourceMappingURL=extensions.js.map
2019-12-10 06:52:33 +07:00
/***/ } ) ,
2021-04-26 16:42:09 +07:00
/***/ 39 :
2021-02-22 17:27:16 +07:00
/***/ ( function ( _ _unused _webpack _module , exports , _ _nccwpck _require _ _ ) {
2019-11-24 06:44:53 +07:00
2021-04-26 16:42:09 +07:00
var _ _createBinding = ( this && this . _ _createBinding ) || ( Object . create ? ( function ( o , m , k , k2 ) {
if ( k2 === undefined ) k2 = k ;
Object . defineProperty ( o , k2 , { enumerable : true , get : function ( ) { return m [ k ] ; } } ) ;
} ) : ( function ( o , m , k , k2 ) {
if ( k2 === undefined ) k2 = k ;
o [ k2 ] = m [ k ] ;
} ) ) ;
var _ _setModuleDefault = ( this && this . _ _setModuleDefault ) || ( Object . create ? ( function ( o , v ) {
Object . defineProperty ( o , "default" , { enumerable : true , value : v } ) ;
} ) : function ( o , v ) {
o [ "default" ] = v ;
} ) ;
2020-05-07 04:57:00 +07:00
var _ _importStar = ( this && this . _ _importStar ) || function ( mod ) {
if ( mod && mod . _ _esModule ) return mod ;
var result = { } ;
2021-04-26 16:42:09 +07:00
if ( mod != null ) for ( var k in mod ) if ( k !== "default" && Object . prototype . hasOwnProperty . call ( mod , k ) ) _ _createBinding ( result , mod , k ) ;
_ _setModuleDefault ( result , mod ) ;
2020-05-07 04:57:00 +07:00
return result ;
} ;
2021-02-22 17:27:16 +07:00
Object . defineProperty ( exports , "__esModule" , ( { value : true } ) ) ;
2021-04-26 16:42:09 +07:00
exports . run = exports . getScript = void 0 ;
const exec _1 = _ _nccwpck _require _ _ ( 514 ) ;
const core = _ _importStar ( _ _nccwpck _require _ _ ( 186 ) ) ;
const config = _ _importStar ( _ _nccwpck _require _ _ ( 88 ) ) ;
const coverage = _ _importStar ( _ _nccwpck _require _ _ ( 730 ) ) ;
const extensions = _ _importStar ( _ _nccwpck _require _ _ ( 390 ) ) ;
const tools = _ _importStar ( _ _nccwpck _require _ _ ( 740 ) ) ;
const utils = _ _importStar ( _ _nccwpck _require _ _ ( 918 ) ) ;
async function getScript ( filename , version , os _version ) {
const name = 'setup-php' ;
const url = 'https://setup-php.com/support' ;
process . env [ 'fail_fast' ] = await utils . getInput ( 'fail-fast' , false ) ;
const extension _csv = await utils . getInput ( 'extensions' , false ) ;
const ini _values _csv = await utils . getInput ( 'ini-values' , false ) ;
const coverage _driver = await utils . getInput ( 'coverage' , false ) ;
const tools _csv = await utils . getInput ( 'tools' , false ) ;
2021-07-05 17:33:10 +07:00
let script = await utils . readFile ( filename , 'src/scripts' ) ;
2021-04-26 16:42:09 +07:00
script += await tools . addTools ( tools _csv , version , os _version ) ;
if ( extension _csv ) {
script += await extensions . addExtension ( extension _csv , version , os _version ) ;
}
if ( coverage _driver ) {
script += await coverage . addCoverage ( coverage _driver , version , os _version ) ;
}
if ( ini _values _csv ) {
script += await config . addINIValues ( ini _values _csv , os _version ) ;
}
script += '\n' + ( await utils . stepLog ( 'Support this project' , os _version ) ) ;
script += '\n' + ( await utils . addLog ( '$tick' , name , url , os _version ) ) ;
return await utils . writeScript ( filename , script ) ;
}
exports . getScript = getScript ;
async function run ( ) {
try {
2021-05-05 01:13:26 +07:00
if ( ( await utils . readEnv ( 'ImageOS' ) ) == 'ubuntu16' ) {
core . warning ( 'Ubuntu 16.04 is deprecated.\nPlease upgrade to Ubuntu 18.04 or Ubuntu 20.04 - https://setup-php.com/i/452' ) ;
}
2021-04-26 16:42:09 +07:00
const version = await utils . parseVersion ( await utils . getInput ( 'php-version' , true ) ) ;
if ( version ) {
const os _version = process . platform ;
const tool = await utils . scriptTool ( os _version ) ;
const script = os _version + ( await utils . scriptExtension ( os _version ) ) ;
const location = await getScript ( script , version , os _version ) ;
await exec _1 . exec ( await utils . joins ( tool , location , version , _ _dirname ) ) ;
2019-11-24 06:44:53 +07:00
}
else {
2021-04-26 16:42:09 +07:00
core . setFailed ( 'Unable to get the PHP version' ) ;
2019-11-24 06:44:53 +07:00
}
}
2021-04-26 16:42:09 +07:00
catch ( error ) {
core . setFailed ( error . message ) ;
2019-11-24 06:44:53 +07:00
}
2021-04-26 16:42:09 +07:00
}
exports . run = run ;
( async ( ) => {
await run ( ) ;
} ) ( ) . catch ( error => {
core . setFailed ( error . message ) ;
} ) ;
2021-05-31 06:51:18 +07:00
//# sourceMappingURL=install.js.map
2021-04-26 16:42:09 +07:00
/***/ } ) ,
/***/ 740 :
/***/ ( function ( _ _unused _webpack _module , exports , _ _nccwpck _require _ _ ) {
var _ _createBinding = ( this && this . _ _createBinding ) || ( Object . create ? ( function ( o , m , k , k2 ) {
if ( k2 === undefined ) k2 = k ;
Object . defineProperty ( o , k2 , { enumerable : true , get : function ( ) { return m [ k ] ; } } ) ;
} ) : ( function ( o , m , k , k2 ) {
if ( k2 === undefined ) k2 = k ;
o [ k2 ] = m [ k ] ;
} ) ) ;
var _ _setModuleDefault = ( this && this . _ _setModuleDefault ) || ( Object . create ? ( function ( o , v ) {
Object . defineProperty ( o , "default" , { enumerable : true , value : v } ) ;
} ) : function ( o , v ) {
o [ "default" ] = v ;
} ) ;
var _ _importStar = ( this && this . _ _importStar ) || function ( mod ) {
if ( mod && mod . _ _esModule ) return mod ;
var result = { } ;
if ( mod != null ) for ( var k in mod ) if ( k !== "default" && Object . prototype . hasOwnProperty . call ( mod , k ) ) _ _createBinding ( result , mod , k ) ;
_ _setModuleDefault ( result , mod ) ;
return result ;
} ;
Object . defineProperty ( exports , "__esModule" , ( { value : true } ) ) ;
2021-07-05 17:42:58 +07:00
exports . addTools = exports . initToolData = exports . functionRecord = exports . addWPCLI = exports . addSymfony = exports . addPHPUnitTools = exports . addPhive = exports . addPhing = exports . addPECL = exports . addDevTools = exports . addDeployer = exports . addComposer = exports . addBlackfirePlayer = exports . addPackage = exports . addArchive = exports . getPharUrl = exports . getUrl = exports . filterList = exports . parseRelease = exports . getToolVersion = exports . getToolSemver = void 0 ;
2021-04-26 16:42:09 +07:00
const utils = _ _importStar ( _ _nccwpck _require _ _ ( 918 ) ) ;
2021-07-05 17:42:58 +07:00
async function getToolSemver ( data ) {
2021-07-09 12:56:38 +07:00
var _a ;
const ref = data [ 'version_prefix' ] + data [ 'version' ] ;
const url = ` https://api.github.com/repos/ ${ data [ 'repository' ] } /git/matching-refs/tags%2F ${ ref } . ` ;
const token = await utils . readEnv ( 'COMPOSER_TOKEN' ) ;
const response = await utils . fetch ( url , token ) ;
if ( response . error || response . data === '[]' ) {
data [ 'error' ] = ( _a = response . error ) !== null && _a !== void 0 ? _a : ` No version found with prefix ${ ref } . ` ;
return data [ 'version' ] ;
}
else {
2021-07-10 03:40:33 +07:00
const tag = JSON . parse ( response [ 'data' ] ) . pop ( ) [ 'ref' ] . split ( '/' ) . pop ( ) ;
return tag . replace ( /^v(\d)/ , '$1' ) ;
2021-07-09 12:56:38 +07:00
}
2021-07-05 17:42:58 +07:00
}
exports . getToolSemver = getToolSemver ;
async function getToolVersion ( data ) {
2021-04-26 16:42:09 +07:00
const semver _regex = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-((?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\.(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?(?:\+([0-9a-zA-Z-]+(?:\.[0-9a-zA-Z-]+)*))?$/ ;
const composer _regex = /^stable$|^preview$|^snapshot$|^v?[1|2]$/ ;
2021-07-05 17:42:58 +07:00
const major _minor _regex = /^v?\d+(\.\d+)?$/ ;
const version = data [ 'version' ]
. replace ( /[><=^]*/ , '' )
. replace ( /^v(\d)/ , '$1' ) ;
2021-04-26 16:42:09 +07:00
switch ( true ) {
2021-07-05 17:42:58 +07:00
case data [ 'tool' ] === 'composer' && composer _regex . test ( version ) :
return version ;
case data [ 'repository' ] && major _minor _regex . test ( version ) :
return await getToolSemver ( data ) ;
2021-04-26 16:42:09 +07:00
case semver _regex . test ( version ) :
return version ;
default :
return 'latest' ;
2019-11-24 06:44:53 +07:00
}
2021-04-26 16:42:09 +07:00
}
exports . getToolVersion = getToolVersion ;
2021-07-05 17:33:10 +07:00
async function parseRelease ( release , data ) {
2021-04-26 16:42:09 +07:00
const parts = release . split ( ':' ) ;
const tool = parts [ 0 ] ;
const version = parts [ 1 ] ;
2021-07-05 17:33:10 +07:00
release = release . includes ( '/' )
? release . split ( '/' ) [ 1 ] . replace ( /\s+/ , '' )
: release ;
release = release . includes ( ':' )
? [ data [ 'tool' ] , release . split ( ':' ) [ 1 ] ] . join ( ':' )
: data [ 'tool' ] ;
2021-04-26 16:42:09 +07:00
switch ( true ) {
case version === undefined :
2021-07-05 17:42:58 +07:00
data [ 'release' ] = release ;
data [ 'version' ] = 'latest' ;
break ;
2021-04-26 16:42:09 +07:00
case /^[\w.-]+\/[\w.-]+$/ . test ( tool ) :
2021-07-05 17:42:58 +07:00
data [ 'release' ] = release ;
data [ 'version' ] = version ;
break ;
2021-04-26 16:42:09 +07:00
default :
2021-07-05 17:42:58 +07:00
data [ 'release' ] = release ;
data [ 'version' ] = version ;
data [ 'version' ] = await getToolVersion ( data ) ;
break ;
2019-11-24 06:44:53 +07:00
}
2021-07-05 17:42:58 +07:00
return data ;
2021-04-26 16:42:09 +07:00
}
2021-07-05 17:33:10 +07:00
exports . parseRelease = parseRelease ;
async function filterList ( tools _list ) {
const regex _any = /^composer($|:.*)/ ;
const regex _valid = /^composer:?($|preview$|snapshot$|v?[1-2]$|v?\d+\.\d+\.\d+[\w-]*$)/ ;
const matches = tools _list . filter ( tool => regex _valid . test ( tool ) ) ;
let composer = 'composer' ;
tools _list = tools _list . filter ( tool => ! regex _any . test ( tool ) ) ;
2021-04-26 16:42:09 +07:00
switch ( true ) {
2021-07-05 17:33:10 +07:00
case matches [ 0 ] == undefined :
2021-04-26 16:42:09 +07:00
break ;
default :
2021-07-05 17:33:10 +07:00
composer = matches [ matches . length - 1 ] . replace ( /v(\d\S*)/ , '$1' ) ;
break ;
2019-11-24 06:44:53 +07:00
}
2021-07-05 17:33:10 +07:00
tools _list . unshift ( composer ) ;
return tools _list ;
2021-04-26 16:42:09 +07:00
}
2021-07-05 17:33:10 +07:00
exports . filterList = filterList ;
async function getUrl ( data ) {
if ( data [ 'version' ] === 'latest' ) {
return [
data [ 'domain' ] ,
data [ 'repository' ] ,
data [ 'prefix' ] ,
data [ 'version' ] ,
data [ 'verb' ] ,
data [ 'tool' ] + data [ 'extension' ]
]
. filter ( Boolean )
. join ( '/' ) ;
}
else {
return [
data [ 'domain' ] ,
data [ 'repository' ] ,
data [ 'prefix' ] ,
data [ 'verb' ] ,
data [ 'version_prefix' ] + data [ 'version' ] ,
data [ 'tool' ] + data [ 'extension' ]
]
. filter ( Boolean )
. join ( '/' ) ;
}
}
exports . getUrl = getUrl ;
async function getPharUrl ( data ) {
if ( data [ 'version' ] === 'latest' ) {
return data [ 'domain' ] + '/' + data [ 'tool' ] + '.phar' ;
}
else {
return ( data [ 'domain' ] +
'/' +
data [ 'tool' ] +
'-' +
data [ 'version_prefix' ] +
data [ 'version' ] +
'.phar' ) ;
2019-11-24 06:44:53 +07:00
}
2021-04-26 16:42:09 +07:00
}
exports . getPharUrl = getPharUrl ;
2021-07-05 17:33:10 +07:00
async function addArchive ( data ) {
return ( ( await utils . getCommand ( data [ 'os_version' ] , 'tool' ) ) +
( await utils . joins ( data [ 'url' ] , data [ 'tool' ] , data [ 'version_parameter' ] ) ) ) ;
}
exports . addArchive = addArchive ;
async function addPackage ( data ) {
const command = await utils . getCommand ( data [ 'os_version' ] , 'composertool' ) ;
const parts = data [ 'repository' ] . split ( '/' ) ;
return command + parts [ 1 ] + ' ' + data [ 'release' ] + ' ' + parts [ 0 ] + '/' ;
}
exports . addPackage = addPackage ;
async function addBlackfirePlayer ( data ) {
if ( /5\.[5-6]|7\.0/ . test ( data [ 'php_version' ] ) &&
data [ 'version' ] == 'latest' ) {
data [ 'version' ] = '1.9.3' ;
}
data [ 'url' ] = await getPharUrl ( data ) ;
return addArchive ( data ) ;
}
exports . addBlackfirePlayer = addBlackfirePlayer ;
async function addComposer ( data ) {
const github = data [ 'github' ] ;
const getcomposer = data [ 'domain' ] ;
let cache _url = ` ${ github } /shivammathur/composer-cache/releases/latest/download/composer- ${ data [ 'version' ] . replace ( 'latest' , 'stable' ) } .phar ` ;
let source _url = ` ${ getcomposer } /composer.phar ` ;
2021-04-26 16:42:09 +07:00
switch ( true ) {
2021-07-05 17:33:10 +07:00
case /^snapshot$/ . test ( data [ 'version' ] ) :
2021-04-26 16:42:09 +07:00
break ;
2021-07-05 17:33:10 +07:00
case /^preview$|^[1-2]$/ . test ( data [ 'version' ] ) :
source _url = ` ${ getcomposer } /composer- ${ data [ 'version' ] } .phar ` ;
break ;
case /^\d+\.\d+\.\d+[\w-]*$/ . test ( data [ 'version' ] ) :
cache _url = ` ${ github } / ${ data [ 'repository' ] } /releases/download/ ${ data [ 'version' ] } /composer.phar ` ;
source _url = ` ${ getcomposer } /composer- ${ data [ 'version' ] } .phar ` ;
2021-04-26 16:42:09 +07:00
break ;
2021-07-05 17:33:10 +07:00
default :
source _url = ` ${ getcomposer } /composer-stable.phar ` ;
2019-11-24 06:44:53 +07:00
}
2021-07-05 17:33:10 +07:00
data [ 'url' ] = ` ${ cache _url } , ${ source _url } ` ;
data [ 'version_parameter' ] = data [ 'version' ] ;
return await addArchive ( data ) ;
2021-04-26 16:42:09 +07:00
}
2021-07-05 17:33:10 +07:00
exports . addComposer = addComposer ;
async function addDeployer ( data ) {
if ( data [ 'version' ] === 'latest' ) {
data [ 'url' ] = data [ 'domain' ] + '/deployer.phar' ;
}
else {
data [ 'url' ] =
data [ 'domain' ] + '/releases/v' + data [ 'version' ] + '/deployer.phar' ;
2019-11-24 06:44:53 +07:00
}
2021-07-05 17:33:10 +07:00
return await addArchive ( data ) ;
2021-04-26 16:42:09 +07:00
}
2021-07-05 17:33:10 +07:00
exports . addDeployer = addDeployer ;
async function addDevTools ( data ) {
switch ( data [ 'os_version' ] ) {
2021-04-26 16:42:09 +07:00
case 'linux' :
case 'darwin' :
2021-07-05 17:33:10 +07:00
return 'add_devtools ' + data [ 'tool' ] ;
2021-04-26 16:42:09 +07:00
case 'win32' :
2021-07-05 17:33:10 +07:00
return await utils . addLog ( '$tick' , data [ 'tool' ] , data [ 'tool' ] + ' is not a windows tool' , 'win32' ) ;
2021-04-26 16:42:09 +07:00
default :
2021-07-05 17:33:10 +07:00
return await utils . log ( 'Platform ' + data [ 'os_version' ] + ' is not supported' , data [ 'os_version' ] , 'error' ) ;
2019-11-24 06:44:53 +07:00
}
}
2021-07-05 17:33:10 +07:00
exports . addDevTools = addDevTools ;
async function addPECL ( data ) {
return await utils . getCommand ( data [ 'os_version' ] , 'pecl' ) ;
2021-04-26 16:42:09 +07:00
}
2021-07-05 17:33:10 +07:00
exports . addPECL = addPECL ;
async function addPhing ( data ) {
data [ 'url' ] =
data [ 'domain' ] + '/get/phing-' + data [ 'version' ] + data [ 'extension' ] ;
return await addArchive ( data ) ;
}
exports . addPhing = addPhing ;
async function addPhive ( data ) {
2021-04-26 16:42:09 +07:00
switch ( true ) {
2021-07-05 17:33:10 +07:00
case /5\.[3-5]/ . test ( data [ 'php_version' ] ) :
return await utils . addLog ( '$cross' , 'phive' , 'Phive is not supported on PHP ' + data [ 'php_version' ] , data [ 'os_version' ] ) ;
case /5\.6|7\.0/ . test ( data [ 'php_version' ] ) :
data [ 'version' ] = data [ 'version' ] . replace ( 'latest' , '0.12.1' ) ;
2021-04-26 16:42:09 +07:00
break ;
2021-07-05 17:33:10 +07:00
case /7\.1/ . test ( data [ 'php_version' ] ) :
data [ 'version' ] = data [ 'version' ] . replace ( 'latest' , '0.13.5' ) ;
2021-04-26 16:42:09 +07:00
break ;
2019-11-24 06:44:53 +07:00
}
2021-07-05 17:33:10 +07:00
if ( data [ 'version' ] === 'latest' ) {
data [ 'domain' ] = data [ 'domain' ] + '/releases' ;
2019-11-24 06:44:53 +07:00
}
2021-07-05 17:33:10 +07:00
else {
data [ 'domain' ] = [
data [ 'github' ] ,
data [ 'repository' ] ,
'releases/download' ,
data [ 'version' ]
] . join ( '/' ) ;
}
data [ 'url' ] = await getPharUrl ( data ) ;
return await addArchive ( data ) ;
2019-11-24 06:44:53 +07:00
}
2021-07-05 17:33:10 +07:00
exports . addPhive = addPhive ;
async function addPHPUnitTools ( data ) {
data [ 'url' ] = await getPharUrl ( data ) ;
return await addArchive ( data ) ;
}
exports . addPHPUnitTools = addPHPUnitTools ;
async function addSymfony ( data ) {
let filename ;
switch ( data [ 'os_version' ] ) {
2021-04-26 16:42:09 +07:00
case 'linux' :
case 'darwin' :
2021-07-05 17:33:10 +07:00
filename = 'symfony_' + data [ 'os_version' ] + '_amd64' ;
break ;
2021-04-26 16:42:09 +07:00
case 'win32' :
2021-07-05 17:33:10 +07:00
filename = 'symfony_windows_amd64.exe' ;
break ;
2021-04-26 16:42:09 +07:00
default :
2021-07-05 17:33:10 +07:00
return await utils . log ( 'Platform ' + data [ 'os_version' ] + ' is not supported' , data [ 'os_version' ] , 'error' ) ;
2019-11-24 06:44:53 +07:00
}
2021-07-05 17:33:10 +07:00
if ( data [ 'version' ] === 'latest' ) {
data [ 'uri' ] = [ 'releases/latest/download' , filename ] . join ( '/' ) ;
}
else {
data [ 'uri' ] = [ 'releases/download' , 'v' + data [ 'version' ] , filename ] . join ( '/' ) ;
}
data [ 'url' ] = [ data [ 'domain' ] , data [ 'repository' ] , data [ 'uri' ] ] . join ( '/' ) ;
return await addArchive ( data ) ;
2021-04-26 16:42:09 +07:00
}
2021-07-05 17:33:10 +07:00
exports . addSymfony = addSymfony ;
async function addWPCLI ( data ) {
if ( data [ 'version' ] === 'latest' ) {
data [ 'uri' ] = 'wp-cli/builds/blob/gh-pages/phar/wp-cli.phar?raw=true' ;
data [ 'url' ] = [ data [ 'domain' ] , data [ 'uri' ] ] . join ( '/' ) ;
}
else {
data [ 'extension' ] = '-' + data [ 'version' ] + data [ 'extension' ] ;
data [ 'url' ] = await getUrl ( data ) ;
}
return await addArchive ( data ) ;
}
exports . addWPCLI = addWPCLI ;
exports . functionRecord = {
composer : addComposer ,
deployer : addDeployer ,
dev _tools : addDevTools ,
phive : addPhive ,
blackfire _player : addBlackfirePlayer ,
pecl : addPECL ,
phing : addPhing ,
phpunit : addPHPUnitTools ,
phpcpd : addPHPUnitTools ,
symfony : addSymfony ,
wp _cli : addWPCLI
} ;
async function initToolData ( data , release , php _version , os _version ) {
2021-07-05 17:42:58 +07:00
data = await parseRelease ( release , data ) ;
2021-07-05 17:33:10 +07:00
data [ 'version_parameter' ] = JSON . stringify ( data [ 'version_parameter' ] ) ;
data [ 'os_version' ] = os _version ;
data [ 'php_version' ] = php _version ;
data [ 'github' ] = 'https://github.com' ;
if ( data [ 'github' ] === data [ 'domain' ] ) {
data [ 'prefix' ] = 'releases' ;
data [ 'verb' ] = 'download' ;
}
return data ;
}
exports . initToolData = initToolData ;
2021-04-26 16:42:09 +07:00
async function addTools ( tools _csv , php _version , os _version ) {
let script = '\n' ;
if ( tools _csv === 'none' ) {
return '' ;
2019-11-24 06:44:53 +07:00
}
2021-04-26 16:42:09 +07:00
else {
script += await utils . stepLog ( 'Setup Tools' , os _version ) ;
2019-11-24 06:44:53 +07:00
}
2021-07-05 17:33:10 +07:00
const tools _list = await filterList ( await utils . CSVArray ( tools _csv ) ) ;
2021-04-26 16:42:09 +07:00
await utils . asyncForEach ( tools _list , async function ( release ) {
2021-07-05 17:33:10 +07:00
const data = await initToolData ( await utils . getToolData ( release . split ( ':' ) [ 0 ] ) , release , php _version , os _version ) ;
2021-04-26 16:42:09 +07:00
script += '\n' ;
switch ( true ) {
2021-07-09 12:56:38 +07:00
case data [ 'error' ] !== undefined :
script += await utils . addLog ( '$cross' , data [ 'tool' ] , data [ 'error' ] , data [ 'os_version' ] ) ;
break ;
2021-07-05 17:33:10 +07:00
case 'phar' === data [ 'type' ] :
data [ 'url' ] = await getUrl ( data ) ;
script += await addArchive ( data ) ;
2021-04-26 16:42:09 +07:00
break ;
2021-07-05 17:33:10 +07:00
case 'composer' === data [ 'type' ] :
case /^[\w.-]+\/[\w.-]+$/ . test ( data [ 'tool' ] ) :
script += await addPackage ( data ) ;
2021-04-26 16:42:09 +07:00
break ;
2021-07-05 17:33:10 +07:00
case 'custom-package' === data [ 'type' ] :
script += await utils . customPackage ( data [ 'tool' ] . split ( '-' ) [ 0 ] , 'tools' , data [ 'version' ] , data [ 'os_version' ] ) ;
2021-04-26 16:42:09 +07:00
break ;
2021-07-05 17:33:10 +07:00
case 'custom-function' === data [ 'type' ] :
script += await exports . functionRecord [ data [ 'function' ] ] ( data ) ;
2021-04-26 16:42:09 +07:00
break ;
2021-07-05 17:33:10 +07:00
case /^none$/ . test ( data [ 'tool' ] ) :
2021-04-26 16:42:09 +07:00
break ;
default :
2021-07-09 12:56:38 +07:00
script += await utils . addLog ( '$cross' , data [ 'tool' ] , 'Tool ' + data [ 'tool' ] + ' is not supported' , data [ 'os_version' ] ) ;
2021-04-26 16:42:09 +07:00
break ;
2019-11-24 06:44:53 +07:00
}
2021-04-26 16:42:09 +07:00
} ) ;
return script ;
2019-11-24 06:44:53 +07:00
}
2021-04-26 16:42:09 +07:00
exports . addTools = addTools ;
2021-05-31 06:51:18 +07:00
//# sourceMappingURL=tools.js.map
2019-11-24 06:44:53 +07:00
2019-12-19 04:08:12 +07:00
/***/ } ) ,
2021-04-26 16:42:09 +07:00
/***/ 918 :
2021-02-22 17:27:16 +07:00
/***/ ( function ( _ _unused _webpack _module , exports , _ _nccwpck _require _ _ ) {
2020-10-02 05:56:51 +07:00
2021-04-26 16:42:09 +07:00
var _ _createBinding = ( this && this . _ _createBinding ) || ( Object . create ? ( function ( o , m , k , k2 ) {
if ( k2 === undefined ) k2 = k ;
Object . defineProperty ( o , k2 , { enumerable : true , get : function ( ) { return m [ k ] ; } } ) ;
} ) : ( function ( o , m , k , k2 ) {
if ( k2 === undefined ) k2 = k ;
o [ k2 ] = m [ k ] ;
} ) ) ;
var _ _setModuleDefault = ( this && this . _ _setModuleDefault ) || ( Object . create ? ( function ( o , v ) {
Object . defineProperty ( o , "default" , { enumerable : true , value : v } ) ;
} ) : function ( o , v ) {
o [ "default" ] = v ;
} ) ;
var _ _importStar = ( this && this . _ _importStar ) || function ( mod ) {
if ( mod && mod . _ _esModule ) return mod ;
var result = { } ;
if ( mod != null ) for ( var k in mod ) if ( k !== "default" && Object . prototype . hasOwnProperty . call ( mod , k ) ) _ _createBinding ( result , mod , k ) ;
_ _setModuleDefault ( result , mod ) ;
return result ;
2020-10-02 05:56:51 +07:00
} ;
2021-02-22 17:27:16 +07:00
Object . defineProperty ( exports , "__esModule" , ( { value : true } ) ) ;
2021-07-09 12:56:38 +07:00
exports . parseExtensionSource = exports . customPackage = exports . scriptTool = exports . scriptExtension = exports . joins = exports . getCommand = exports . getUnsupportedLog = exports . suppressOutput = exports . getExtensionPrefix = exports . CSVArray = exports . extensionArray = exports . getToolData = exports . writeScript = exports . readFile = exports . addLog = exports . stepLog = exports . log = exports . color = exports . asyncForEach = exports . parseVersion = exports . getManifestURL = exports . fetch = exports . getInput = exports . readEnv = void 0 ;
2021-04-26 16:42:09 +07:00
const fs = _ _importStar ( _ _nccwpck _require _ _ ( 747 ) ) ;
const https = _ _importStar ( _ _nccwpck _require _ _ ( 211 ) ) ;
const path = _ _importStar ( _ _nccwpck _require _ _ ( 622 ) ) ;
2021-07-05 17:42:58 +07:00
const url = _ _importStar ( _ _nccwpck _require _ _ ( 835 ) ) ;
2021-04-26 16:42:09 +07:00
const core = _ _importStar ( _ _nccwpck _require _ _ ( 186 ) ) ;
async function readEnv ( property ) {
const value = process . env [ property ] ;
switch ( value ) {
case undefined :
return '' ;
default :
return value ;
}
2020-10-02 05:56:51 +07:00
}
2021-04-26 16:42:09 +07:00
exports . readEnv = readEnv ;
async function getInput ( name , mandatory ) {
const input = core . getInput ( name ) ;
const env _input = await readEnv ( name ) ;
switch ( true ) {
case input != '' :
return input ;
case input == '' && env _input != '' :
return env _input ;
case input == '' && env _input == '' && mandatory :
throw new Error ( ` Input required and not supplied: ${ name } ` ) ;
default :
return '' ;
}
}
exports . getInput = getInput ;
2021-07-09 12:56:38 +07:00
async function fetch ( input _url , auth _token ) {
2021-04-26 16:42:09 +07:00
const fetch _promise = new Promise ( resolve => {
2021-07-05 17:42:58 +07:00
const url _object = new url . URL ( input _url ) ;
2021-07-09 12:56:38 +07:00
const headers = {
'User-Agent' : ` Mozilla/5.0 ( ${ process . platform } ${ process . arch } ) setup-php `
} ;
if ( auth _token ) {
headers . authorization = 'Bearer ' + auth _token ;
}
2021-07-05 17:42:58 +07:00
const options = {
hostname : url _object . hostname ,
path : url _object . pathname ,
2021-07-09 12:56:38 +07:00
headers : headers
2021-07-05 17:42:58 +07:00
} ;
const req = https . get ( options , ( res ) => {
2021-07-09 12:56:38 +07:00
if ( res . statusCode != 200 ) {
resolve ( { error : ` ${ res . statusCode } : ${ res . statusMessage } ` } ) ;
}
else {
let body = '' ;
res . setEncoding ( 'utf8' ) ;
res . on ( 'data' , chunk => ( body += chunk ) ) ;
res . on ( 'end' , ( ) => resolve ( { data : ` ${ body } ` } ) ) ;
}
2021-04-26 16:42:09 +07:00
} ) ;
req . end ( ) ;
2021-02-22 17:27:16 +07:00
} ) ;
2021-04-26 16:42:09 +07:00
return await fetch _promise ;
2021-02-22 17:27:16 +07:00
}
2021-04-26 16:42:09 +07:00
exports . fetch = fetch ;
2021-07-09 12:56:38 +07:00
async function getManifestURL ( ) {
return 'https://raw.githubusercontent.com/shivammathur/setup-php/develop/src/configs/php-versions.json' ;
}
exports . getManifestURL = getManifestURL ;
2021-04-26 16:42:09 +07:00
async function parseVersion ( version ) {
2021-07-09 12:56:38 +07:00
const manifest = await getManifestURL ( ) ;
2021-04-26 16:42:09 +07:00
switch ( true ) {
case /^(latest|\d+\.x)$/ . test ( version ) :
2021-07-09 12:56:38 +07:00
return JSON . parse ( ( await fetch ( manifest ) ) [ 'data' ] ) [ version ] ;
2021-04-26 16:42:09 +07:00
default :
switch ( true ) {
case version . length > 1 :
return version . slice ( 0 , 3 ) ;
default :
return version + '.0' ;
}
2021-02-22 17:27:16 +07:00
}
2021-04-26 16:42:09 +07:00
}
exports . parseVersion = parseVersion ;
async function asyncForEach ( array , callback ) {
for ( let index = 0 ; index < array . length ; index ++ ) {
await callback ( array [ index ] , index , array ) ;
2020-10-03 03:09:43 +07:00
}
}
2021-04-26 16:42:09 +07:00
exports . asyncForEach = asyncForEach ;
async function color ( type ) {
switch ( type ) {
case 'error' :
return '31' ;
default :
case 'success' :
return '32' ;
case 'warning' :
return '33' ;
}
2021-01-16 12:46:13 +07:00
}
2021-04-26 16:42:09 +07:00
exports . color = color ;
async function log ( message , os _version , log _type ) {
switch ( os _version ) {
case 'win32' :
return ( 'printf "\\033[' +
( await color ( log _type ) ) +
';1m' +
message +
' \\033[0m"' ) ;
case 'linux' :
case 'darwin' :
default :
return ( 'echo "\\033[' + ( await color ( log _type ) ) + ';1m' + message + '\\033[0m"' ) ;
}
2020-10-02 16:21:40 +07:00
}
2021-04-26 16:42:09 +07:00
exports . log = log ;
async function stepLog ( message , os _version ) {
switch ( os _version ) {
case 'win32' :
return 'Step-Log "' + message + '"' ;
case 'linux' :
case 'darwin' :
return 'step_log "' + message + '"' ;
default :
return await log ( 'Platform ' + os _version + ' is not supported' , os _version , 'error' ) ;
2020-03-12 09:27:40 +07:00
}
2019-11-24 06:44:53 +07:00
}
2021-04-26 16:42:09 +07:00
exports . stepLog = stepLog ;
async function addLog ( mark , subject , message , os _version ) {
switch ( os _version ) {
case 'win32' :
return 'Add-Log "' + mark + '" "' + subject + '" "' + message + '"' ;
case 'linux' :
case 'darwin' :
return 'add_log "' + mark + '" "' + subject + '" "' + message + '"' ;
default :
return await log ( 'Platform ' + os _version + ' is not supported' , os _version , 'error' ) ;
}
2021-02-22 17:27:16 +07:00
}
2021-04-26 16:42:09 +07:00
exports . addLog = addLog ;
2021-07-05 17:33:10 +07:00
async function readFile ( filename , directory ) {
return fs . readFileSync ( path . join ( _ _dirname , '../' + directory , filename ) , 'utf8' ) ;
2019-11-24 06:44:53 +07:00
}
2021-07-05 17:33:10 +07:00
exports . readFile = readFile ;
2021-04-26 16:42:09 +07:00
async function writeScript ( filename , script ) {
const runner _dir = await getInput ( 'RUNNER_TOOL_CACHE' , false ) ;
const script _path = path . join ( runner _dir , filename ) ;
fs . writeFileSync ( script _path , script , { mode : 0o755 } ) ;
return script _path ;
2019-11-24 06:44:53 +07:00
}
2021-04-26 16:42:09 +07:00
exports . writeScript = writeScript ;
2021-07-05 17:33:10 +07:00
async function getToolData ( tool ) {
const tools _json = await readFile ( 'tools.json' , 'src/configs' ) ;
const json _data = JSON . parse ( tools _json ) ;
let tool _data ;
const tools = Object . keys ( json _data ) ;
if ( tools . includes ( tool ) ) {
tool _data = json _data [ tool ] ;
tool _data [ 'tool' ] = tool ;
}
else {
const tool _key = Object . keys ( json _data ) . find ( ( key ) => {
return ( json _data [ key ] [ 'alias' ] == tool ||
json _data [ key ] [ 'repository' ] == tool ) ;
} ) ;
if ( tool _key ) {
tool _data = json _data [ tool _key ] ;
tool _data [ 'tool' ] = tool _key ;
}
else {
tool _data = { tool : tool } ;
}
}
return tool _data ;
}
exports . getToolData = getToolData ;
2021-04-26 16:42:09 +07:00
async function extensionArray ( extension _csv ) {
switch ( extension _csv ) {
case '' :
case ' ' :
return [ ] ;
default :
return extension _csv
. split ( ',' )
. map ( function ( extension ) {
if ( /.+-.+\/.+@.+/ . test ( extension ) ) {
return extension ;
2021-02-22 17:27:16 +07:00
}
2021-04-26 16:42:09 +07:00
return extension
. trim ( )
. toLowerCase ( )
. replace ( /^php[-_]/ , '' ) ;
} )
. filter ( Boolean ) ;
}
2019-11-24 06:44:53 +07:00
}
2021-04-26 16:42:09 +07:00
exports . extensionArray = extensionArray ;
async function CSVArray ( values _csv ) {
switch ( values _csv ) {
case '' :
case ' ' :
return [ ] ;
default :
return values _csv
. split ( /,(?=(?:(?:[^"']*["']){2})*[^"']*$)/ )
. map ( function ( value ) {
return value
. trim ( )
. replace ( /^["']|["']$|(?<==)["']/g , '' )
. replace ( /=(((?!E_).)*[?{}|&~![()^]+((?!E_).)+)/ , "='$1'" ) ;
} )
. filter ( Boolean ) ;
}
}
exports . CSVArray = CSVArray ;
async function getExtensionPrefix ( extension ) {
switch ( true ) {
default :
return 'extension' ;
case /xdebug([2-3])?$|opcache|ioncube|eaccelerator/ . test ( extension ) :
return 'zend_extension' ;
}
}
exports . getExtensionPrefix = getExtensionPrefix ;
async function suppressOutput ( os _version ) {
switch ( os _version ) {
case 'win32' :
return ' >$null 2>&1' ;
case 'linux' :
case 'darwin' :
return ' >/dev/null 2>&1' ;
default :
return await log ( 'Platform ' + os _version + ' is not supported' , os _version , 'error' ) ;
}
}
exports . suppressOutput = suppressOutput ;
async function getUnsupportedLog ( extension , version , os _version ) {
return ( '\n' +
( await addLog ( '$cross' , extension , [ extension , 'is not supported on PHP' , version ] . join ( ' ' ) , os _version ) ) +
'\n' ) ;
}
exports . getUnsupportedLog = getUnsupportedLog ;
async function getCommand ( os _version , suffix ) {
switch ( os _version ) {
case 'linux' :
case 'darwin' :
return 'add_' + suffix + ' ' ;
case 'win32' :
return 'Add-' + suffix . charAt ( 0 ) . toUpperCase ( ) + suffix . slice ( 1 ) + ' ' ;
default :
return await log ( 'Platform ' + os _version + ' is not supported' , os _version , 'error' ) ;
}
2019-11-24 06:44:53 +07:00
}
2021-04-26 16:42:09 +07:00
exports . getCommand = getCommand ;
async function joins ( ... str ) {
return [ ... str ] . join ( ' ' ) ;
2019-11-24 06:44:53 +07:00
}
2021-04-26 16:42:09 +07:00
exports . joins = joins ;
async function scriptExtension ( os _version ) {
switch ( os _version ) {
case 'win32' :
return '.ps1' ;
case 'linux' :
case 'darwin' :
return '.sh' ;
default :
return await log ( 'Platform ' + os _version + ' is not supported' , os _version , 'error' ) ;
}
2019-11-24 06:44:53 +07:00
}
2021-04-26 16:42:09 +07:00
exports . scriptExtension = scriptExtension ;
async function scriptTool ( os _version ) {
switch ( os _version ) {
case 'win32' :
return 'pwsh' ;
case 'linux' :
case 'darwin' :
return 'bash' ;
default :
return await log ( 'Platform ' + os _version + ' is not supported' , os _version , 'error' ) ;
}
2019-11-24 06:44:53 +07:00
}
2021-04-26 16:42:09 +07:00
exports . scriptTool = scriptTool ;
async function customPackage ( pkg , type , version , os _version ) {
const pkg _name = pkg . replace ( /\d+|(pdo|pecl)[_-]/ , '' ) ;
const script _extension = await scriptExtension ( os _version ) ;
const script = path . join ( _ _dirname , '../src/scripts/' + type + '/' + pkg _name + script _extension ) ;
const command = await getCommand ( os _version , pkg _name ) ;
return '\n. ' + script + '\n' + command + version ;
2019-11-24 06:44:53 +07:00
}
2021-04-26 16:42:09 +07:00
exports . customPackage = customPackage ;
async function parseExtensionSource ( extension , prefix ) {
const regex = /(\w+)-(.+:\/\/.+(?:[.:].+)+\/)?([\w.-]+)\/([\w.-]+)@(.+)/ ;
const matches = regex . exec ( extension ) ;
matches [ 2 ] = matches [ 2 ] ? matches [ 2 ] . slice ( 0 , - 1 ) : 'https://github.com' ;
return await joins ( '\nadd_extension_from_source' , ... matches . splice ( 1 , matches . length ) , prefix ) ;
}
exports . parseExtensionSource = parseExtensionSource ;
2021-05-31 06:51:18 +07:00
//# sourceMappingURL=utils.js.map
2021-02-22 17:27:16 +07:00
/***/ } ) ,
2021-04-26 16:42:09 +07:00
/***/ 241 :
2021-02-22 17:27:16 +07:00
/***/ ( function ( _ _unused _webpack _module , exports , _ _nccwpck _require _ _ ) {
2021-05-31 06:51:18 +07:00
var _ _createBinding = ( this && this . _ _createBinding ) || ( Object . create ? ( function ( o , m , k , k2 ) {
if ( k2 === undefined ) k2 = k ;
Object . defineProperty ( o , k2 , { enumerable : true , get : function ( ) { return m [ k ] ; } } ) ;
} ) : ( function ( o , m , k , k2 ) {
if ( k2 === undefined ) k2 = k ;
o [ k2 ] = m [ k ] ;
} ) ) ;
var _ _setModuleDefault = ( this && this . _ _setModuleDefault ) || ( Object . create ? ( function ( o , v ) {
Object . defineProperty ( o , "default" , { enumerable : true , value : v } ) ;
} ) : function ( o , v ) {
o [ "default" ] = v ;
} ) ;
2021-02-22 17:27:16 +07:00
var _ _importStar = ( this && this . _ _importStar ) || function ( mod ) {
if ( mod && mod . _ _esModule ) return mod ;
var result = { } ;
2021-05-31 06:51:18 +07:00
if ( mod != null ) for ( var k in mod ) if ( k !== "default" && Object . hasOwnProperty . call ( mod , k ) ) _ _createBinding ( result , mod , k ) ;
_ _setModuleDefault ( result , mod ) ;
2021-02-22 17:27:16 +07:00
return result ;
} ;
Object . defineProperty ( exports , "__esModule" , ( { value : true } ) ) ;
2021-05-31 06:51:18 +07:00
exports . issue = exports . issueCommand = void 0 ;
2021-04-26 16:42:09 +07:00
const os = _ _importStar ( _ _nccwpck _require _ _ ( 87 ) ) ;
const utils _1 = _ _nccwpck _require _ _ ( 278 ) ;
2019-11-24 06:44:53 +07:00
/ * *
2021-04-26 16:42:09 +07:00
* Commands
2019-11-24 06:44:53 +07:00
*
2021-04-26 16:42:09 +07:00
* Command Format :
* : : name key = value , key = value : : message
2020-07-24 11:58:48 +07:00
*
2021-04-26 16:42:09 +07:00
* Examples :
* : : warning : : This is the message
* : : set - env name = MY _VAR : : some value
2020-07-24 11:58:48 +07:00
* /
2021-04-26 16:42:09 +07:00
function issueCommand ( command , properties , message ) {
const cmd = new Command ( command , properties , message ) ;
process . stdout . write ( cmd . toString ( ) + os . EOL ) ;
2020-07-24 11:58:48 +07:00
}
2021-04-26 16:42:09 +07:00
exports . issueCommand = issueCommand ;
function issue ( name , message = '' ) {
issueCommand ( name , { } , message ) ;
}
exports . issue = issue ;
const CMD _STRING = '::' ;
class Command {
constructor ( command , properties , message ) {
if ( ! command ) {
command = 'missing.command' ;
}
this . command = command ;
this . properties = properties ;
this . message = message ;
2020-08-06 17:03:58 +07:00
}
2021-04-26 16:42:09 +07:00
toString ( ) {
let cmdStr = CMD _STRING + this . command ;
if ( this . properties && Object . keys ( this . properties ) . length > 0 ) {
cmdStr += ' ' ;
let first = true ;
for ( const key in this . properties ) {
if ( this . properties . hasOwnProperty ( key ) ) {
const val = this . properties [ key ] ;
if ( val ) {
if ( first ) {
first = false ;
}
else {
cmdStr += ',' ;
}
cmdStr += ` ${ key } = ${ escapeProperty ( val ) } ` ;
}
}
}
}
cmdStr += ` ${ CMD _STRING } ${ escapeData ( this . message ) } ` ;
return cmdStr ;
2020-10-04 18:33:02 +07:00
}
}
2021-04-26 16:42:09 +07:00
function escapeData ( s ) {
return utils _1 . toCommandValue ( s )
. replace ( /%/g , '%25' )
. replace ( /\r/g , '%0D' )
. replace ( /\n/g , '%0A' ) ;
}
function escapeProperty ( s ) {
return utils _1 . toCommandValue ( s )
. replace ( /%/g , '%25' )
. replace ( /\r/g , '%0D' )
. replace ( /\n/g , '%0A' )
. replace ( /:/g , '%3A' )
. replace ( /,/g , '%2C' ) ;
}
//# sourceMappingURL=command.js.map
2019-12-10 06:52:33 +07:00
2019-11-24 06:44:53 +07:00
/***/ } ) ,
2021-04-26 16:42:09 +07:00
/***/ 186 :
2021-02-22 17:27:16 +07:00
/***/ ( function ( _ _unused _webpack _module , exports , _ _nccwpck _require _ _ ) {
2019-11-24 06:44:53 +07:00
2021-05-31 06:51:18 +07:00
var _ _createBinding = ( this && this . _ _createBinding ) || ( Object . create ? ( function ( o , m , k , k2 ) {
if ( k2 === undefined ) k2 = k ;
Object . defineProperty ( o , k2 , { enumerable : true , get : function ( ) { return m [ k ] ; } } ) ;
} ) : ( function ( o , m , k , k2 ) {
if ( k2 === undefined ) k2 = k ;
o [ k2 ] = m [ k ] ;
} ) ) ;
var _ _setModuleDefault = ( this && this . _ _setModuleDefault ) || ( Object . create ? ( function ( o , v ) {
Object . defineProperty ( o , "default" , { enumerable : true , value : v } ) ;
} ) : function ( o , v ) {
o [ "default" ] = v ;
} ) ;
var _ _importStar = ( this && this . _ _importStar ) || function ( mod ) {
if ( mod && mod . _ _esModule ) return mod ;
var result = { } ;
if ( mod != null ) for ( var k in mod ) if ( k !== "default" && Object . hasOwnProperty . call ( mod , k ) ) _ _createBinding ( result , mod , k ) ;
_ _setModuleDefault ( result , mod ) ;
return result ;
} ;
2021-04-26 16:42:09 +07:00
var _ _awaiter = ( this && this . _ _awaiter ) || function ( thisArg , _arguments , P , generator ) {
function adopt ( value ) { return value instanceof P ? value : new P ( function ( resolve ) { resolve ( value ) ; } ) ; }
return new ( P || ( P = Promise ) ) ( function ( resolve , reject ) {
function fulfilled ( value ) { try { step ( generator . next ( value ) ) ; } catch ( e ) { reject ( e ) ; } }
function rejected ( value ) { try { step ( generator [ "throw" ] ( value ) ) ; } catch ( e ) { reject ( e ) ; } }
function step ( result ) { result . done ? resolve ( result . value ) : adopt ( result . value ) . then ( fulfilled , rejected ) ; }
step ( ( generator = generator . apply ( thisArg , _arguments || [ ] ) ) . next ( ) ) ;
} ) ;
} ;
2021-02-22 17:27:16 +07:00
Object . defineProperty ( exports , "__esModule" , ( { value : true } ) ) ;
2021-05-31 06:51:18 +07:00
exports . getState = exports . saveState = exports . group = exports . endGroup = exports . startGroup = exports . info = exports . warning = exports . error = exports . debug = exports . isDebug = exports . setFailed = exports . setCommandEcho = exports . setOutput = exports . getBooleanInput = exports . getInput = exports . addPath = exports . setSecret = exports . exportVariable = exports . ExitCode = void 0 ;
2021-04-26 16:42:09 +07:00
const command _1 = _ _nccwpck _require _ _ ( 241 ) ;
const file _command _1 = _ _nccwpck _require _ _ ( 717 ) ;
const utils _1 = _ _nccwpck _require _ _ ( 278 ) ;
const os = _ _importStar ( _ _nccwpck _require _ _ ( 87 ) ) ;
const path = _ _importStar ( _ _nccwpck _require _ _ ( 622 ) ) ;
2019-11-24 06:44:53 +07:00
/ * *
2021-04-26 16:42:09 +07:00
* The code to exit an action
2019-11-24 06:44:53 +07:00
* /
2021-04-26 16:42:09 +07:00
var ExitCode ;
( function ( ExitCode ) {
/ * *
* A code indicating that the action was successful
* /
ExitCode [ ExitCode [ "Success" ] = 0 ] = "Success" ;
/ * *
* A code indicating that the action was a failure
* /
ExitCode [ ExitCode [ "Failure" ] = 1 ] = "Failure" ;
} ) ( ExitCode = exports . ExitCode || ( exports . ExitCode = { } ) ) ;
//-----------------------------------------------------------------------
// Variables
//-----------------------------------------------------------------------
/ * *
* Sets env variable for this action and future actions in the job
* @ param name the name of the variable to set
* @ param val the value of the variable . Non - string values will be converted to a string via JSON . stringify
* /
// eslint-disable-next-line @typescript-eslint/no-explicit-any
function exportVariable ( name , val ) {
const convertedVal = utils _1 . toCommandValue ( val ) ;
process . env [ name ] = convertedVal ;
const filePath = process . env [ 'GITHUB_ENV' ] || '' ;
if ( filePath ) {
const delimiter = '_GitHubActionsFileCommandDelimeter_' ;
const commandValue = ` ${ name } << ${ delimiter } ${ os . EOL } ${ convertedVal } ${ os . EOL } ${ delimiter } ` ;
file _command _1 . issueCommand ( 'ENV' , commandValue ) ;
}
else {
command _1 . issueCommand ( 'set-env' , { name } , convertedVal ) ;
}
2019-11-24 06:44:53 +07:00
}
2021-04-26 16:42:09 +07:00
exports . exportVariable = exportVariable ;
/ * *
* Registers a secret which will get masked from logs
* @ param secret value of the secret
* /
function setSecret ( secret ) {
command _1 . issueCommand ( 'add-mask' , { } , secret ) ;
}
exports . setSecret = setSecret ;
/ * *
* Prepends inputPath to the PATH ( for this action and future actions )
* @ param inputPath
* /
function addPath ( inputPath ) {
const filePath = process . env [ 'GITHUB_PATH' ] || '' ;
if ( filePath ) {
file _command _1 . issueCommand ( 'PATH' , inputPath ) ;
}
else {
command _1 . issueCommand ( 'add-path' , { } , inputPath ) ;
}
process . env [ 'PATH' ] = ` ${ inputPath } ${ path . delimiter } ${ process . env [ 'PATH' ] } ` ;
}
exports . addPath = addPath ;
2021-02-22 17:27:16 +07:00
/ * *
2021-05-31 06:51:18 +07:00
* Gets the value of an input .
* Unless trimWhitespace is set to false in InputOptions , the value is also trimmed .
* Returns an empty string if the value is not defined .
2021-02-22 17:27:16 +07:00
*
2021-04-26 16:42:09 +07:00
* @ param name name of the input to get
* @ param options optional . See InputOptions .
* @ returns string
2021-02-22 17:27:16 +07:00
* /
2021-04-26 16:42:09 +07:00
function getInput ( name , options ) {
const val = process . env [ ` INPUT_ ${ name . replace ( / /g , '_' ) . toUpperCase ( ) } ` ] || '' ;
if ( options && options . required && ! val ) {
throw new Error ( ` Input required and not supplied: ${ name } ` ) ;
2019-11-24 06:44:53 +07:00
}
2021-05-31 06:51:18 +07:00
if ( options && options . trimWhitespace === false ) {
return val ;
}
2021-04-26 16:42:09 +07:00
return val . trim ( ) ;
}
exports . getInput = getInput ;
2021-05-31 06:51:18 +07:00
/ * *
* Gets the input value of the boolean type in the YAML 1.2 "core schema" specification .
* Support boolean input list : ` true | True | TRUE | false | False | FALSE ` .
* The return value is also in boolean type .
* ref : https : //yaml.org/spec/1.2/spec.html#id2804923
*
* @ param name name of the input to get
* @ param options optional . See InputOptions .
* @ returns boolean
* /
function getBooleanInput ( name , options ) {
const trueValue = [ 'true' , 'True' , 'TRUE' ] ;
const falseValue = [ 'false' , 'False' , 'FALSE' ] ;
const val = getInput ( name , options ) ;
if ( trueValue . includes ( val ) )
return true ;
if ( falseValue . includes ( val ) )
return false ;
throw new TypeError ( ` Input does not meet YAML 1.2 "Core Schema" specification: ${ name } \n ` +
` Support boolean input list: \` true | True | TRUE | false | False | FALSE \` ` ) ;
}
exports . getBooleanInput = getBooleanInput ;
2021-04-26 16:42:09 +07:00
/ * *
* Sets the value of an output .
*
* @ param name name of the output to set
* @ param value value to store . Non - string values will be converted to a string via JSON . stringify
* /
// eslint-disable-next-line @typescript-eslint/no-explicit-any
function setOutput ( name , value ) {
process . stdout . write ( os . EOL ) ;
command _1 . issueCommand ( 'set-output' , { name } , value ) ;
}
exports . setOutput = setOutput ;
/ * *
* Enables or disables the echoing of commands into stdout for the rest of the step .
* Echoing is disabled by default if ACTIONS _STEP _DEBUG is not set .
*
* /
function setCommandEcho ( enabled ) {
command _1 . issue ( 'echo' , enabled ? 'on' : 'off' ) ;
}
exports . setCommandEcho = setCommandEcho ;
//-----------------------------------------------------------------------
// Results
//-----------------------------------------------------------------------
/ * *
* Sets the action status to failed .
* When the action exits it will be with an exit code of 1
* @ param message add error issue message
* /
function setFailed ( message ) {
process . exitCode = ExitCode . Failure ;
error ( message ) ;
}
exports . setFailed = setFailed ;
//-----------------------------------------------------------------------
// Logging Commands
//-----------------------------------------------------------------------
/ * *
* Gets whether Actions Step Debug is on or not
* /
function isDebug ( ) {
return process . env [ 'RUNNER_DEBUG' ] === '1' ;
}
exports . isDebug = isDebug ;
/ * *
* Writes debug message to user log
* @ param message debug message
* /
function debug ( message ) {
command _1 . issueCommand ( 'debug' , { } , message ) ;
}
exports . debug = debug ;
/ * *
* Adds an error issue
* @ param message error issue message . Errors will be converted to string via toString ( )
* /
function error ( message ) {
command _1 . issue ( 'error' , message instanceof Error ? message . toString ( ) : message ) ;
}
exports . error = error ;
/ * *
* Adds an warning issue
* @ param message warning issue message . Errors will be converted to string via toString ( )
* /
function warning ( message ) {
command _1 . issue ( 'warning' , message instanceof Error ? message . toString ( ) : message ) ;
}
exports . warning = warning ;
/ * *
* Writes info to log with console . log .
* @ param message info message
* /
function info ( message ) {
process . stdout . write ( message + os . EOL ) ;
}
exports . info = info ;
/ * *
* Begin an output group .
*
* Output until the next ` groupEnd ` will be foldable in this group
*
* @ param name The name of the output group
* /
function startGroup ( name ) {
command _1 . issue ( 'group' , name ) ;
}
exports . startGroup = startGroup ;
/ * *
* End an output group .
* /
function endGroup ( ) {
command _1 . issue ( 'endgroup' ) ;
}
exports . endGroup = endGroup ;
/ * *
* Wrap an asynchronous function call in a group .
*
* Returns the same type as the function itself .
*
* @ param name The name of the group
* @ param fn The function to wrap in the group
* /
function group ( name , fn ) {
return _ _awaiter ( this , void 0 , void 0 , function * ( ) {
startGroup ( name ) ;
let result ;
try {
result = yield fn ( ) ;
}
finally {
endGroup ( ) ;
}
return result ;
} ) ;
2019-11-24 06:44:53 +07:00
}
2021-04-26 16:42:09 +07:00
exports . group = group ;
//-----------------------------------------------------------------------
// Wrapper action state
//-----------------------------------------------------------------------
2021-02-22 17:27:16 +07:00
/ * *
2021-04-26 16:42:09 +07:00
* Saves state for current action , the state can only be retrieved by this action ' s post job execution .
2021-02-22 17:27:16 +07:00
*
2021-04-26 16:42:09 +07:00
* @ param name name of the state to store
* @ param value value to store . Non - string values will be converted to a string via JSON . stringify
2021-02-22 17:27:16 +07:00
* /
2021-04-26 16:42:09 +07:00
// eslint-disable-next-line @typescript-eslint/no-explicit-any
function saveState ( name , value ) {
command _1 . issueCommand ( 'save-state' , { name } , value ) ;
2019-11-24 06:44:53 +07:00
}
2021-04-26 16:42:09 +07:00
exports . saveState = saveState ;
2021-02-22 17:27:16 +07:00
/ * *
2021-04-26 16:42:09 +07:00
* Gets the value of an state set by this action ' s main execution .
2021-02-22 17:27:16 +07:00
*
2021-04-26 16:42:09 +07:00
* @ param name name of the state to get
* @ returns string
2021-02-22 17:27:16 +07:00
* /
2021-04-26 16:42:09 +07:00
function getState ( name ) {
return process . env [ ` STATE_ ${ name } ` ] || '' ;
2019-11-24 06:44:53 +07:00
}
2021-04-26 16:42:09 +07:00
exports . getState = getState ;
//# sourceMappingURL=core.js.map
2019-11-24 06:44:53 +07:00
/***/ } ) ,
2021-04-26 16:42:09 +07:00
/***/ 717 :
2021-02-22 17:27:16 +07:00
/***/ ( function ( _ _unused _webpack _module , exports , _ _nccwpck _require _ _ ) {
2019-11-24 06:44:53 +07:00
2021-04-26 16:42:09 +07:00
// For internal use, subject to change.
2021-05-31 06:51:18 +07:00
var _ _createBinding = ( this && this . _ _createBinding ) || ( Object . create ? ( function ( o , m , k , k2 ) {
if ( k2 === undefined ) k2 = k ;
Object . defineProperty ( o , k2 , { enumerable : true , get : function ( ) { return m [ k ] ; } } ) ;
} ) : ( function ( o , m , k , k2 ) {
if ( k2 === undefined ) k2 = k ;
o [ k2 ] = m [ k ] ;
} ) ) ;
var _ _setModuleDefault = ( this && this . _ _setModuleDefault ) || ( Object . create ? ( function ( o , v ) {
Object . defineProperty ( o , "default" , { enumerable : true , value : v } ) ;
} ) : function ( o , v ) {
o [ "default" ] = v ;
} ) ;
2020-01-26 17:55:58 +07:00
var _ _importStar = ( this && this . _ _importStar ) || function ( mod ) {
if ( mod && mod . _ _esModule ) return mod ;
var result = { } ;
2021-05-31 06:51:18 +07:00
if ( mod != null ) for ( var k in mod ) if ( k !== "default" && Object . hasOwnProperty . call ( mod , k ) ) _ _createBinding ( result , mod , k ) ;
_ _setModuleDefault ( result , mod ) ;
2020-01-26 17:55:58 +07:00
return result ;
} ;
2021-02-22 17:27:16 +07:00
Object . defineProperty ( exports , "__esModule" , ( { value : true } ) ) ;
2021-05-31 06:51:18 +07:00
exports . issueCommand = void 0 ;
2021-04-26 16:42:09 +07:00
// We use any as a valid input type
/* eslint-disable @typescript-eslint/no-explicit-any */
const fs = _ _importStar ( _ _nccwpck _require _ _ ( 747 ) ) ;
const os = _ _importStar ( _ _nccwpck _require _ _ ( 87 ) ) ;
const utils _1 = _ _nccwpck _require _ _ ( 278 ) ;
function issueCommand ( command , message ) {
const filePath = process . env [ ` GITHUB_ ${ command } ` ] ;
if ( ! filePath ) {
throw new Error ( ` Unable to find environment variable for file command ${ command } ` ) ;
}
if ( ! fs . existsSync ( filePath ) ) {
throw new Error ( ` Missing file at path: ${ filePath } ` ) ;
}
fs . appendFileSync ( filePath , ` ${ utils _1 . toCommandValue ( message ) } ${ os . EOL } ` , {
encoding : 'utf8'
2021-02-22 17:27:16 +07:00
} ) ;
2019-11-24 06:44:53 +07:00
}
2021-04-26 16:42:09 +07:00
exports . issueCommand = issueCommand ;
//# sourceMappingURL=file-command.js.map
/***/ } ) ,
/***/ 278 :
/***/ ( ( _ _unused _webpack _module , exports ) => {
// We use any as a valid input type
/* eslint-disable @typescript-eslint/no-explicit-any */
Object . defineProperty ( exports , "__esModule" , ( { value : true } ) ) ;
2021-05-31 06:51:18 +07:00
exports . toCommandValue = void 0 ;
2019-11-24 06:44:53 +07:00
/ * *
2021-04-26 16:42:09 +07:00
* Sanitizes an input into a string so it can be passed into issueCommand safely
* @ param input input to sanitize into a string
2019-11-24 06:44:53 +07:00
* /
2021-04-26 16:42:09 +07:00
function toCommandValue ( input ) {
if ( input === null || input === undefined ) {
return '' ;
2021-02-22 17:27:16 +07:00
}
2021-04-26 16:42:09 +07:00
else if ( typeof input === 'string' || input instanceof String ) {
return input ;
2021-02-22 17:27:16 +07:00
}
2021-04-26 16:42:09 +07:00
return JSON . stringify ( input ) ;
2019-11-24 06:44:53 +07:00
}
2021-04-26 16:42:09 +07:00
exports . toCommandValue = toCommandValue ;
//# sourceMappingURL=utils.js.map
2021-02-22 17:27:16 +07:00
/***/ } ) ,
2021-04-26 16:42:09 +07:00
/***/ 514 :
2021-02-22 17:27:16 +07:00
/***/ ( function ( _ _unused _webpack _module , exports , _ _nccwpck _require _ _ ) {
2021-04-26 16:42:09 +07:00
var _ _awaiter = ( this && this . _ _awaiter ) || function ( thisArg , _arguments , P , generator ) {
function adopt ( value ) { return value instanceof P ? value : new P ( function ( resolve ) { resolve ( value ) ; } ) ; }
return new ( P || ( P = Promise ) ) ( function ( resolve , reject ) {
function fulfilled ( value ) { try { step ( generator . next ( value ) ) ; } catch ( e ) { reject ( e ) ; } }
function rejected ( value ) { try { step ( generator [ "throw" ] ( value ) ) ; } catch ( e ) { reject ( e ) ; } }
function step ( result ) { result . done ? resolve ( result . value ) : adopt ( result . value ) . then ( fulfilled , rejected ) ; }
step ( ( generator = generator . apply ( thisArg , _arguments || [ ] ) ) . next ( ) ) ;
} ) ;
} ;
2021-02-22 17:27:16 +07:00
var _ _importStar = ( this && this . _ _importStar ) || function ( mod ) {
if ( mod && mod . _ _esModule ) return mod ;
var result = { } ;
2021-04-26 16:42:09 +07:00
if ( mod != null ) for ( var k in mod ) if ( Object . hasOwnProperty . call ( mod , k ) ) result [ k ] = mod [ k ] ;
result [ "default" ] = mod ;
2021-02-22 17:27:16 +07:00
return result ;
} ;
Object . defineProperty ( exports , "__esModule" , ( { value : true } ) ) ;
2021-04-26 16:42:09 +07:00
const tr = _ _importStar ( _ _nccwpck _require _ _ ( 159 ) ) ;
2019-11-24 06:44:53 +07:00
/ * *
2021-04-26 16:42:09 +07:00
* Exec a command .
* Output will be streamed to the live console .
* Returns promise with return code
2019-11-24 06:44:53 +07:00
*
2021-04-26 16:42:09 +07:00
* @ param commandLine command to execute ( can include additional args ) . Must be correctly escaped .
* @ param args optional arguments for tool . Escaping is handled by the lib .
* @ param options optional exec options . See ExecOptions
* @ returns Promise < number > exit code
2019-11-24 06:44:53 +07:00
* /
2021-04-26 16:42:09 +07:00
function exec ( commandLine , args , options ) {
return _ _awaiter ( this , void 0 , void 0 , function * ( ) {
const commandArgs = tr . argStringToArray ( commandLine ) ;
if ( commandArgs . length === 0 ) {
throw new Error ( ` Parameter 'commandLine' cannot be null or empty. ` ) ;
2019-11-24 06:44:53 +07:00
}
2021-04-26 16:42:09 +07:00
// Path to tool to execute should be first arg
const toolPath = commandArgs [ 0 ] ;
args = commandArgs . slice ( 1 ) . concat ( args || [ ] ) ;
const runner = new tr . ToolRunner ( toolPath , args , options ) ;
return runner . exec ( ) ;
} ) ;
2019-11-24 06:44:53 +07:00
}
2021-04-26 16:42:09 +07:00
exports . exec = exec ;
//# sourceMappingURL=exec.js.map
2019-11-24 06:44:53 +07:00
2019-12-27 08:26:49 +07:00
/***/ } ) ,
2021-04-26 16:42:09 +07:00
/***/ 159 :
2021-02-22 17:27:16 +07:00
/***/ ( function ( _ _unused _webpack _module , exports , _ _nccwpck _require _ _ ) {
2019-12-27 08:26:49 +07:00
2021-04-26 16:42:09 +07:00
var _ _awaiter = ( this && this . _ _awaiter ) || function ( thisArg , _arguments , P , generator ) {
function adopt ( value ) { return value instanceof P ? value : new P ( function ( resolve ) { resolve ( value ) ; } ) ; }
return new ( P || ( P = Promise ) ) ( function ( resolve , reject ) {
function fulfilled ( value ) { try { step ( generator . next ( value ) ) ; } catch ( e ) { reject ( e ) ; } }
function rejected ( value ) { try { step ( generator [ "throw" ] ( value ) ) ; } catch ( e ) { reject ( e ) ; } }
function step ( result ) { result . done ? resolve ( result . value ) : adopt ( result . value ) . then ( fulfilled , rejected ) ; }
step ( ( generator = generator . apply ( thisArg , _arguments || [ ] ) ) . next ( ) ) ;
} ) ;
} ;
2019-12-27 08:26:49 +07:00
var _ _importStar = ( this && this . _ _importStar ) || function ( mod ) {
if ( mod && mod . _ _esModule ) return mod ;
var result = { } ;
2021-04-26 16:42:09 +07:00
if ( mod != null ) for ( var k in mod ) if ( Object . hasOwnProperty . call ( mod , k ) ) result [ k ] = mod [ k ] ;
result [ "default" ] = mod ;
2019-12-27 08:26:49 +07:00
return result ;
} ;
2021-02-22 17:27:16 +07:00
Object . defineProperty ( exports , "__esModule" , ( { value : true } ) ) ;
2021-04-26 16:42:09 +07:00
const os = _ _importStar ( _ _nccwpck _require _ _ ( 87 ) ) ;
const events = _ _importStar ( _ _nccwpck _require _ _ ( 614 ) ) ;
const child = _ _importStar ( _ _nccwpck _require _ _ ( 129 ) ) ;
const path = _ _importStar ( _ _nccwpck _require _ _ ( 622 ) ) ;
const io = _ _importStar ( _ _nccwpck _require _ _ ( 351 ) ) ;
const ioUtil = _ _importStar ( _ _nccwpck _require _ _ ( 962 ) ) ;
/* eslint-disable @typescript-eslint/unbound-method */
const IS _WINDOWS = process . platform === 'win32' ;
/ *
* Class for running command line tools . Handles quoting and arg parsing in a platform agnostic way .
2020-01-07 09:36:14 +07:00
* /
2021-04-26 16:42:09 +07:00
class ToolRunner extends events . EventEmitter {
constructor ( toolPath , args , options ) {
super ( ) ;
if ( ! toolPath ) {
throw new Error ( "Parameter 'toolPath' cannot be null or empty." ) ;
}
this . toolPath = toolPath ;
this . args = args || [ ] ;
this . options = options || { } ;
2020-03-12 09:27:40 +07:00
}
2021-04-26 16:42:09 +07:00
_debug ( message ) {
if ( this . options . listeners && this . options . listeners . debug ) {
this . options . listeners . debug ( message ) ;
}
2020-03-12 09:27:40 +07:00
}
2021-04-26 16:42:09 +07:00
_getCommandString ( options , noPrefix ) {
const toolPath = this . _getSpawnFileName ( ) ;
const args = this . _getSpawnArgs ( options ) ;
let cmd = noPrefix ? '' : '[command]' ; // omit prefix when piped to a second tool
if ( IS _WINDOWS ) {
// Windows + cmd file
if ( this . _isCmdFile ( ) ) {
cmd += toolPath ;
for ( const a of args ) {
cmd += ` ${ a } ` ;
}
}
// Windows + verbatim
else if ( options . windowsVerbatimArguments ) {
cmd += ` " ${ toolPath } " ` ;
for ( const a of args ) {
cmd += ` ${ a } ` ;
}
}
// Windows (regular)
else {
cmd += this . _windowsQuoteCmdArg ( toolPath ) ;
for ( const a of args ) {
cmd += ` ${ this . _windowsQuoteCmdArg ( a ) } ` ;
}
}
}
else {
// OSX/Linux - this can likely be improved with some form of quoting.
// creating processes on Unix is fundamentally different than Windows.
// on Unix, execvp() takes an arg array.
cmd += toolPath ;
for ( const a of args ) {
cmd += ` ${ a } ` ;
}
}
return cmd ;
2020-03-12 09:27:40 +07:00
}
2021-04-26 16:42:09 +07:00
_processLineBuffer ( data , strBuffer , onLine ) {
try {
let s = strBuffer + data . toString ( ) ;
let n = s . indexOf ( os . EOL ) ;
while ( n > - 1 ) {
const line = s . substring ( 0 , n ) ;
onLine ( line ) ;
// the rest of the string ...
s = s . substring ( n + os . EOL . length ) ;
n = s . indexOf ( os . EOL ) ;
}
strBuffer = s ;
}
catch ( err ) {
// streaming lines to console is best effort. Don't fail a build.
this . _debug ( ` error processing line. Failed with error ${ err } ` ) ;
}
2020-12-14 16:07:12 +07:00
}
2021-04-26 16:42:09 +07:00
_getSpawnFileName ( ) {
if ( IS _WINDOWS ) {
if ( this . _isCmdFile ( ) ) {
return process . env [ 'COMSPEC' ] || 'cmd.exe' ;
}
}
return this . toolPath ;
2020-03-12 09:27:40 +07:00
}
2021-04-26 16:42:09 +07:00
_getSpawnArgs ( options ) {
if ( IS _WINDOWS ) {
if ( this . _isCmdFile ( ) ) {
let argline = ` /D /S /C " ${ this . _windowsQuoteCmdArg ( this . toolPath ) } ` ;
for ( const a of this . args ) {
argline += ' ' ;
argline += options . windowsVerbatimArguments
? a
: this . _windowsQuoteCmdArg ( a ) ;
}
argline += '"' ;
return [ argline ] ;
}
}
return this . args ;
2020-03-12 09:27:40 +07:00
}
2021-04-26 16:42:09 +07:00
_endsWith ( str , end ) {
return str . endsWith ( end ) ;
2020-10-30 12:05:13 +07:00
}
2021-04-26 16:42:09 +07:00
_isCmdFile ( ) {
const upperToolPath = this . toolPath . toUpperCase ( ) ;
return ( this . _endsWith ( upperToolPath , '.CMD' ) ||
this . _endsWith ( upperToolPath , '.BAT' ) ) ;
2020-03-12 09:27:40 +07:00
}
2021-04-26 16:42:09 +07:00
_windowsQuoteCmdArg ( arg ) {
// for .exe, apply the normal quoting rules that libuv applies
if ( ! this . _isCmdFile ( ) ) {
return this . _uvQuoteCmdArg ( arg ) ;
}
// otherwise apply quoting rules specific to the cmd.exe command line parser.
// the libuv rules are generic and are not designed specifically for cmd.exe
// command line parser.
//
// for a detailed description of the cmd.exe command line parser, refer to
// http://stackoverflow.com/questions/4094699/how-does-the-windows-command-interpreter-cmd-exe-parse-scripts/7970912#7970912
// need quotes for empty arg
if ( ! arg ) {
return '""' ;
}
// determine whether the arg needs to be quoted
const cmdSpecialChars = [
' ' ,
'\t' ,
'&' ,
'(' ,
')' ,
'[' ,
']' ,
'{' ,
'}' ,
'^' ,
'=' ,
';' ,
'!' ,
"'" ,
'+' ,
',' ,
'`' ,
'~' ,
'|' ,
'<' ,
'>' ,
'"'
] ;
let needsQuotes = false ;
for ( const char of arg ) {
if ( cmdSpecialChars . some ( x => x === char ) ) {
needsQuotes = true ;
break ;
}
}
// short-circuit if quotes not needed
if ( ! needsQuotes ) {
return arg ;
}
// the following quoting rules are very similar to the rules that by libuv applies.
//
// 1) wrap the string in quotes
//
// 2) double-up quotes - i.e. " => ""
//
// this is different from the libuv quoting rules. libuv replaces " with \", which unfortunately
// doesn't work well with a cmd.exe command line.
//
// note, replacing " with "" also works well if the arg is passed to a downstream .NET console app.
// for example, the command line:
// foo.exe "myarg:""my val"""
// is parsed by a .NET console app into an arg array:
// [ "myarg:\"my val\"" ]
// which is the same end result when applying libuv quoting rules. although the actual
// command line from libuv quoting rules would look like:
// foo.exe "myarg:\"my val\""
//
// 3) double-up slashes that precede a quote,
// e.g. hello \world => "hello \world"
// hello\"world => "hello\\""world"
// hello\\"world => "hello\\\\""world"
// hello world\ => "hello world\\"
//
// technically this is not required for a cmd.exe command line, or the batch argument parser.
// the reasons for including this as a .cmd quoting rule are:
//
// a) this is optimized for the scenario where the argument is passed from the .cmd file to an
// external program. many programs (e.g. .NET console apps) rely on the slash-doubling rule.
//
// b) it's what we've been doing previously (by deferring to node default behavior) and we
// haven't heard any complaints about that aspect.
//
// note, a weakness of the quoting rules chosen here, is that % is not escaped. in fact, % cannot be
// escaped when used on the command line directly - even though within a .cmd file % can be escaped
// by using %%.
//
// the saving grace is, on the command line, %var% is left as-is if var is not defined. this contrasts
// the line parsing rules within a .cmd file, where if var is not defined it is replaced with nothing.
//
// one option that was explored was replacing % with ^% - i.e. %var% => ^%var^%. this hack would
// often work, since it is unlikely that var^ would exist, and the ^ character is removed when the
// variable is used. the problem, however, is that ^ is not removed when %* is used to pass the args
// to an external program.
//
// an unexplored potential solution for the % escaping problem, is to create a wrapper .cmd file.
// % can be escaped within a .cmd file.
let reverse = '"' ;
let quoteHit = true ;
for ( let i = arg . length ; i > 0 ; i -- ) {
// walk the string in reverse
reverse += arg [ i - 1 ] ;
if ( quoteHit && arg [ i - 1 ] === '\\' ) {
reverse += '\\' ; // double the slash
}
else if ( arg [ i - 1 ] === '"' ) {
quoteHit = true ;
reverse += '"' ; // double the quote
}
else {
quoteHit = false ;
}
}
reverse += '"' ;
return reverse
. split ( '' )
. reverse ( )
. join ( '' ) ;
2020-03-12 09:27:40 +07:00
}
2021-04-26 16:42:09 +07:00
_uvQuoteCmdArg ( arg ) {
// Tool runner wraps child_process.spawn() and needs to apply the same quoting as
// Node in certain cases where the undocumented spawn option windowsVerbatimArguments
// is used.
//
// Since this function is a port of quote_cmd_arg from Node 4.x (technically, lib UV,
// see https://github.com/nodejs/node/blob/v4.x/deps/uv/src/win/process.c for details),
// pasting copyright notice from Node within this function:
//
// Copyright Joyent, Inc. and other Node contributors. All rights reserved.
//
// 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.
if ( ! arg ) {
// Need double quotation for empty argument
return '""' ;
}
if ( ! arg . includes ( ' ' ) && ! arg . includes ( '\t' ) && ! arg . includes ( '"' ) ) {
// No quotation needed
return arg ;
}
if ( ! arg . includes ( '"' ) && ! arg . includes ( '\\' ) ) {
// No embedded double quotes or backslashes, so I can just wrap
// quote marks around the whole thing.
return ` " ${ arg } " ` ;
}
// Expected input/output:
// input : hello"world
// output: "hello\"world"
// input : hello""world
// output: "hello\"\"world"
// input : hello\world
// output: hello\world
// input : hello\\world
// output: hello\\world
// input : hello\"world
// output: "hello\\\"world"
// input : hello\\"world
// output: "hello\\\\\"world"
// input : hello world\
// output: "hello world\\" - note the comment in libuv actually reads "hello world\"
// but it appears the comment is wrong, it should be "hello world\\"
let reverse = '"' ;
let quoteHit = true ;
for ( let i = arg . length ; i > 0 ; i -- ) {
// walk the string in reverse
reverse += arg [ i - 1 ] ;
if ( quoteHit && arg [ i - 1 ] === '\\' ) {
reverse += '\\' ;
}
else if ( arg [ i - 1 ] === '"' ) {
quoteHit = true ;
reverse += '\\' ;
}
else {
quoteHit = false ;
}
}
reverse += '"' ;
return reverse
. split ( '' )
. reverse ( )
. join ( '' ) ;
2020-03-12 09:27:40 +07:00
}
2021-04-26 16:42:09 +07:00
_cloneExecOptions ( options ) {
options = options || { } ;
const result = {
cwd : options . cwd || process . cwd ( ) ,
env : options . env || process . env ,
silent : options . silent || false ,
windowsVerbatimArguments : options . windowsVerbatimArguments || false ,
failOnStdErr : options . failOnStdErr || false ,
ignoreReturnCode : options . ignoreReturnCode || false ,
delay : options . delay || 10000
} ;
result . outStream = options . outStream || process . stdout ;
result . errStream = options . errStream || process . stderr ;
return result ;
2020-03-12 09:27:40 +07:00
}
2021-04-26 16:42:09 +07:00
_getSpawnOptions ( options , toolPath ) {
options = options || { } ;
const result = { } ;
result . cwd = options . cwd ;
result . env = options . env ;
result [ 'windowsVerbatimArguments' ] =
options . windowsVerbatimArguments || this . _isCmdFile ( ) ;
if ( options . windowsVerbatimArguments ) {
result . argv0 = ` " ${ toolPath } " ` ;
}
return result ;
2020-03-12 09:27:40 +07:00
}
2021-04-26 16:42:09 +07:00
/ * *
* Exec a tool .
* Output will be streamed to the live console .
* Returns promise with return code
*
* @ param tool path to tool to exec
* @ param options optional exec options . See ExecOptions
* @ returns number
* /
exec ( ) {
return _ _awaiter ( this , void 0 , void 0 , function * ( ) {
// root the tool path if it is unrooted and contains relative pathing
if ( ! ioUtil . isRooted ( this . toolPath ) &&
( this . toolPath . includes ( '/' ) ||
( IS _WINDOWS && this . toolPath . includes ( '\\' ) ) ) ) {
// prefer options.cwd if it is specified, however options.cwd may also need to be rooted
this . toolPath = path . resolve ( process . cwd ( ) , this . options . cwd || process . cwd ( ) , this . toolPath ) ;
}
// if the tool is only a file name, then resolve it from the PATH
// otherwise verify it exists (add extension on Windows if necessary)
this . toolPath = yield io . which ( this . toolPath , true ) ;
return new Promise ( ( resolve , reject ) => {
this . _debug ( ` exec tool: ${ this . toolPath } ` ) ;
this . _debug ( 'arguments:' ) ;
for ( const arg of this . args ) {
this . _debug ( ` ${ arg } ` ) ;
}
const optionsNonNull = this . _cloneExecOptions ( this . options ) ;
if ( ! optionsNonNull . silent && optionsNonNull . outStream ) {
optionsNonNull . outStream . write ( this . _getCommandString ( optionsNonNull ) + os . EOL ) ;
}
const state = new ExecState ( optionsNonNull , this . toolPath ) ;
state . on ( 'debug' , ( message ) => {
this . _debug ( message ) ;
} ) ;
const fileName = this . _getSpawnFileName ( ) ;
const cp = child . spawn ( fileName , this . _getSpawnArgs ( optionsNonNull ) , this . _getSpawnOptions ( this . options , fileName ) ) ;
const stdbuffer = '' ;
if ( cp . stdout ) {
cp . stdout . on ( 'data' , ( data ) => {
if ( this . options . listeners && this . options . listeners . stdout ) {
this . options . listeners . stdout ( data ) ;
}
if ( ! optionsNonNull . silent && optionsNonNull . outStream ) {
optionsNonNull . outStream . write ( data ) ;
}
this . _processLineBuffer ( data , stdbuffer , ( line ) => {
if ( this . options . listeners && this . options . listeners . stdline ) {
this . options . listeners . stdline ( line ) ;
}
} ) ;
} ) ;
}
const errbuffer = '' ;
if ( cp . stderr ) {
cp . stderr . on ( 'data' , ( data ) => {
state . processStderr = true ;
if ( this . options . listeners && this . options . listeners . stderr ) {
this . options . listeners . stderr ( data ) ;
}
if ( ! optionsNonNull . silent &&
optionsNonNull . errStream &&
optionsNonNull . outStream ) {
const s = optionsNonNull . failOnStdErr
? optionsNonNull . errStream
: optionsNonNull . outStream ;
s . write ( data ) ;
}
this . _processLineBuffer ( data , errbuffer , ( line ) => {
if ( this . options . listeners && this . options . listeners . errline ) {
this . options . listeners . errline ( line ) ;
}
} ) ;
} ) ;
}
cp . on ( 'error' , ( err ) => {
state . processError = err . message ;
state . processExited = true ;
state . processClosed = true ;
state . CheckComplete ( ) ;
} ) ;
cp . on ( 'exit' , ( code ) => {
state . processExitCode = code ;
state . processExited = true ;
this . _debug ( ` Exit code ${ code } received from tool ' ${ this . toolPath } ' ` ) ;
state . CheckComplete ( ) ;
} ) ;
cp . on ( 'close' , ( code ) => {
state . processExitCode = code ;
state . processExited = true ;
state . processClosed = true ;
this . _debug ( ` STDIO streams have closed for tool ' ${ this . toolPath } ' ` ) ;
state . CheckComplete ( ) ;
} ) ;
state . on ( 'done' , ( error , exitCode ) => {
if ( stdbuffer . length > 0 ) {
this . emit ( 'stdline' , stdbuffer ) ;
}
if ( errbuffer . length > 0 ) {
this . emit ( 'errline' , errbuffer ) ;
}
cp . removeAllListeners ( ) ;
if ( error ) {
reject ( error ) ;
}
else {
resolve ( exitCode ) ;
}
} ) ;
if ( this . options . input ) {
if ( ! cp . stdin ) {
throw new Error ( 'child process missing stdin' ) ;
}
cp . stdin . end ( this . options . input ) ;
}
} ) ;
} ) ;
2020-06-03 16:21:22 +07:00
}
}
2021-04-26 16:42:09 +07:00
exports . ToolRunner = ToolRunner ;
2020-01-17 14:28:28 +07:00
/ * *
2021-04-26 16:42:09 +07:00
* Convert an arg string to an array of args . Handles escaping
2020-01-17 14:28:28 +07:00
*
2021-04-26 16:42:09 +07:00
* @ param argString string of arguments
* @ returns string [ ] array of arguments
2020-01-17 14:28:28 +07:00
* /
2021-04-26 16:42:09 +07:00
function argStringToArray ( argString ) {
const args = [ ] ;
let inQuotes = false ;
let escaped = false ;
let arg = '' ;
function append ( c ) {
// we only escape double quotes.
if ( escaped && c !== '"' ) {
arg += '\\' ;
}
arg += c ;
escaped = false ;
2020-03-12 09:27:40 +07:00
}
2021-04-26 16:42:09 +07:00
for ( let i = 0 ; i < argString . length ; i ++ ) {
const c = argString . charAt ( i ) ;
if ( c === '"' ) {
if ( ! escaped ) {
inQuotes = ! inQuotes ;
}
else {
append ( c ) ;
}
continue ;
}
if ( c === '\\' && escaped ) {
append ( c ) ;
continue ;
}
if ( c === '\\' && inQuotes ) {
escaped = true ;
continue ;
}
if ( c === ' ' && ! inQuotes ) {
if ( arg . length > 0 ) {
args . push ( arg ) ;
arg = '' ;
}
continue ;
}
append ( c ) ;
2021-04-21 18:41:24 +07:00
}
2021-04-26 16:42:09 +07:00
if ( arg . length > 0 ) {
args . push ( arg . trim ( ) ) ;
2021-04-21 18:41:24 +07:00
}
2021-04-26 16:42:09 +07:00
return args ;
}
exports . argStringToArray = argStringToArray ;
class ExecState extends events . EventEmitter {
constructor ( options , toolPath ) {
super ( ) ;
this . processClosed = false ; // tracks whether the process has exited and stdio is closed
this . processError = '' ;
this . processExitCode = 0 ;
this . processExited = false ; // tracks whether the process has exited
this . processStderr = false ; // tracks whether stderr was written to
this . delay = 10000 ; // 10 seconds
this . done = false ;
this . timeout = null ;
if ( ! toolPath ) {
throw new Error ( 'toolPath must not be empty' ) ;
}
this . options = options ;
this . toolPath = toolPath ;
if ( options . delay ) {
this . delay = options . delay ;
}
}
CheckComplete ( ) {
if ( this . done ) {
return ;
2021-02-22 17:27:16 +07:00
}
2021-04-26 16:42:09 +07:00
if ( this . processClosed ) {
this . _setResult ( ) ;
}
else if ( this . processExited ) {
this . timeout = setTimeout ( ExecState . HandleTimeout , this . delay , this ) ;
}
}
_debug ( message ) {
this . emit ( 'debug' , message ) ;
}
_setResult ( ) {
// determine whether there is an error
let error ;
if ( this . processExited ) {
if ( this . processError ) {
error = new Error ( ` There was an error when attempting to execute the process ' ${ this . toolPath } '. This may indicate the process failed to start. Error: ${ this . processError } ` ) ;
}
else if ( this . processExitCode !== 0 && ! this . options . ignoreReturnCode ) {
error = new Error ( ` The process ' ${ this . toolPath } ' failed with exit code ${ this . processExitCode } ` ) ;
}
else if ( this . processStderr && this . options . failOnStdErr ) {
error = new Error ( ` The process ' ${ this . toolPath } ' failed because one or more lines were written to the STDERR stream ` ) ;
}
}
// clear the timeout
if ( this . timeout ) {
clearTimeout ( this . timeout ) ;
this . timeout = null ;
}
this . done = true ;
this . emit ( 'done' , error , this . processExitCode ) ;
}
static HandleTimeout ( state ) {
if ( state . done ) {
return ;
}
if ( ! state . processClosed && state . processExited ) {
const message = ` The STDIO streams did not close within ${ state . delay /
1000 } seconds of the exit event from process '${state.toolPath}' . This may indicate a child process inherited the STDIO streams and has not yet exited . ` ;
state . _debug ( message ) ;
}
state . _setResult ( ) ;
}
2019-11-24 06:44:53 +07:00
}
2021-04-26 16:42:09 +07:00
//# sourceMappingURL=toolrunner.js.map
2019-11-24 06:44:53 +07:00
/***/ } ) ,
2021-04-26 16:42:09 +07:00
/***/ 962 :
2021-02-22 17:27:16 +07:00
/***/ ( function ( _ _unused _webpack _module , exports , _ _nccwpck _require _ _ ) {
2019-11-24 06:44:53 +07:00
2021-04-26 16:42:09 +07:00
var _ _awaiter = ( this && this . _ _awaiter ) || function ( thisArg , _arguments , P , generator ) {
function adopt ( value ) { return value instanceof P ? value : new P ( function ( resolve ) { resolve ( value ) ; } ) ; }
return new ( P || ( P = Promise ) ) ( function ( resolve , reject ) {
function fulfilled ( value ) { try { step ( generator . next ( value ) ) ; } catch ( e ) { reject ( e ) ; } }
function rejected ( value ) { try { step ( generator [ "throw" ] ( value ) ) ; } catch ( e ) { reject ( e ) ; } }
function step ( result ) { result . done ? resolve ( result . value ) : adopt ( result . value ) . then ( fulfilled , rejected ) ; }
step ( ( generator = generator . apply ( thisArg , _arguments || [ ] ) ) . next ( ) ) ;
} ) ;
} ;
2019-11-24 06:44:53 +07:00
var _ _importStar = ( this && this . _ _importStar ) || function ( mod ) {
if ( mod && mod . _ _esModule ) return mod ;
var result = { } ;
2021-04-26 16:42:09 +07:00
if ( mod != null ) for ( var k in mod ) if ( Object . hasOwnProperty . call ( mod , k ) ) result [ k ] = mod [ k ] ;
result [ "default" ] = mod ;
2019-11-24 06:44:53 +07:00
return result ;
} ;
2021-04-26 16:42:09 +07:00
var _a ;
2021-02-22 17:27:16 +07:00
Object . defineProperty ( exports , "__esModule" , ( { value : true } ) ) ;
2021-04-26 16:42:09 +07:00
const assert _1 = _ _nccwpck _require _ _ ( 357 ) ;
2021-02-22 17:27:16 +07:00
const fs = _ _importStar ( _ _nccwpck _require _ _ ( 747 ) ) ;
const path = _ _importStar ( _ _nccwpck _require _ _ ( 622 ) ) ;
2021-04-26 16:42:09 +07:00
_a = fs . promises , exports . chmod = _a . chmod , exports . copyFile = _a . copyFile , exports . lstat = _a . lstat , exports . mkdir = _a . mkdir , exports . readdir = _a . readdir , exports . readlink = _a . readlink , exports . rename = _a . rename , exports . rmdir = _a . rmdir , exports . stat = _a . stat , exports . symlink = _a . symlink , exports . unlink = _a . unlink ;
exports . IS _WINDOWS = process . platform === 'win32' ;
function exists ( fsPath ) {
return _ _awaiter ( this , void 0 , void 0 , function * ( ) {
try {
yield exports . stat ( fsPath ) ;
}
catch ( err ) {
if ( err . code === 'ENOENT' ) {
return false ;
2021-02-22 17:27:16 +07:00
}
2021-04-26 16:42:09 +07:00
throw err ;
}
return true ;
} ) ;
2019-12-10 06:52:33 +07:00
}
2021-04-26 16:42:09 +07:00
exports . exists = exists ;
function isDirectory ( fsPath , useStat = false ) {
return _ _awaiter ( this , void 0 , void 0 , function * ( ) {
const stats = useStat ? yield exports . stat ( fsPath ) : yield exports . lstat ( fsPath ) ;
return stats . isDirectory ( ) ;
} ) ;
2021-02-22 17:27:16 +07:00
}
2021-04-26 16:42:09 +07:00
exports . isDirectory = isDirectory ;
2021-02-22 17:27:16 +07:00
/ * *
2021-04-26 16:42:09 +07:00
* On OSX / Linux , true if path starts with '/' . On Windows , true for paths like :
* \ , \ hello , \ \ hello \ share , C : , and C : \ hello ( and corresponding alternate separator cases ) .
2021-02-22 17:27:16 +07:00
* /
2021-04-26 16:42:09 +07:00
function isRooted ( p ) {
p = normalizeSeparators ( p ) ;
if ( ! p ) {
throw new Error ( 'isRooted() parameter "p" cannot be empty' ) ;
}
if ( exports . IS _WINDOWS ) {
return ( p . startsWith ( '\\' ) || /^[A-Z]:/i . test ( p ) // e.g. \ or \hello or \\hello
) ; // e.g. C: or C:\hello
}
return p . startsWith ( '/' ) ;
2021-02-22 17:27:16 +07:00
}
2021-04-26 16:42:09 +07:00
exports . isRooted = isRooted ;
2021-02-22 17:27:16 +07:00
/ * *
2021-04-26 16:42:09 +07:00
* Recursively create a directory at ` fsPath ` .
*
* This implementation is optimistic , meaning it attempts to create the full
* path first , and backs up the path stack from there .
2021-02-22 17:27:16 +07:00
*
2021-04-26 16:42:09 +07:00
* @ param fsPath The path to create
* @ param maxDepth The maximum recursion depth
* @ param depth The current recursion depth
2021-02-22 17:27:16 +07:00
* /
2021-04-26 16:42:09 +07:00
function mkdirP ( fsPath , maxDepth = 1000 , depth = 1 ) {
return _ _awaiter ( this , void 0 , void 0 , function * ( ) {
assert _1 . ok ( fsPath , 'a path argument must be provided' ) ;
fsPath = path . resolve ( fsPath ) ;
if ( depth >= maxDepth )
return exports . mkdir ( fsPath ) ;
try {
yield exports . mkdir ( fsPath ) ;
return ;
}
catch ( err ) {
switch ( err . code ) {
case 'ENOENT' : {
yield mkdirP ( path . dirname ( fsPath ) , maxDepth , depth + 1 ) ;
yield exports . mkdir ( fsPath ) ;
return ;
2021-04-21 06:08:37 +07:00
}
2021-04-26 16:42:09 +07:00
default : {
let stats ;
try {
stats = yield exports . stat ( fsPath ) ;
}
catch ( err2 ) {
throw err ;
}
if ( ! stats . isDirectory ( ) )
throw err ;
}
}
}
} ) ;
2019-12-10 06:52:33 +07:00
}
2021-04-26 16:42:09 +07:00
exports . mkdirP = mkdirP ;
2021-02-22 17:27:16 +07:00
/ * *
2021-04-26 16:42:09 +07:00
* Best effort attempt to determine whether a file exists and is executable .
* @ param filePath file path to check
* @ param extensions additional file extensions to try
* @ return if file exists and is executable , returns the file path . otherwise empty string .
2021-02-22 17:27:16 +07:00
* /
2021-04-26 16:42:09 +07:00
function tryGetExecutablePath ( filePath , extensions ) {
return _ _awaiter ( this , void 0 , void 0 , function * ( ) {
let stats = undefined ;
try {
// test file exists
stats = yield exports . stat ( filePath ) ;
}
catch ( err ) {
if ( err . code !== 'ENOENT' ) {
// eslint-disable-next-line no-console
console . log ( ` Unexpected error attempting to determine if executable file exists ' ${ filePath } ': ${ err } ` ) ;
}
}
if ( stats && stats . isFile ( ) ) {
if ( exports . IS _WINDOWS ) {
// on Windows, test for valid extension
const upperExt = path . extname ( filePath ) . toUpperCase ( ) ;
if ( extensions . some ( validExt => validExt . toUpperCase ( ) === upperExt ) ) {
return filePath ;
}
}
else {
if ( isUnixExecutable ( stats ) ) {
return filePath ;
}
}
}
// try each extension
const originalFilePath = filePath ;
for ( const extension of extensions ) {
filePath = originalFilePath + extension ;
stats = undefined ;
try {
stats = yield exports . stat ( filePath ) ;
}
catch ( err ) {
if ( err . code !== 'ENOENT' ) {
// eslint-disable-next-line no-console
console . log ( ` Unexpected error attempting to determine if executable file exists ' ${ filePath } ': ${ err } ` ) ;
}
}
if ( stats && stats . isFile ( ) ) {
if ( exports . IS _WINDOWS ) {
// preserve the case of the actual file (since an extension was appended)
try {
const directory = path . dirname ( filePath ) ;
const upperName = path . basename ( filePath ) . toUpperCase ( ) ;
for ( const actualName of yield exports . readdir ( directory ) ) {
if ( upperName === actualName . toUpperCase ( ) ) {
filePath = path . join ( directory , actualName ) ;
break ;
}
}
}
catch ( err ) {
// eslint-disable-next-line no-console
console . log ( ` Unexpected error attempting to determine the actual case of the file ' ${ filePath } ': ${ err } ` ) ;
}
return filePath ;
}
else {
if ( isUnixExecutable ( stats ) ) {
return filePath ;
}
}
}
}
return '' ;
} ) ;
2019-12-10 06:52:33 +07:00
}
2021-04-26 16:42:09 +07:00
exports . tryGetExecutablePath = tryGetExecutablePath ;
function normalizeSeparators ( p ) {
p = p || '' ;
if ( exports . IS _WINDOWS ) {
// convert slashes on Windows
p = p . replace ( /\//g , '\\' ) ;
// remove redundant slashes
return p . replace ( /\\\\+/g , '\\' ) ;
2021-02-22 17:27:16 +07:00
}
2021-04-26 16:42:09 +07:00
// remove redundant slashes
return p . replace ( /\/\/+/g , '/' ) ;
2019-11-24 06:44:53 +07:00
}
2021-04-26 16:42:09 +07:00
// on Mac/Linux, test the execute bit
// R W X R W X R W X
// 256 128 64 32 16 8 4 2 1
function isUnixExecutable ( stats ) {
return ( ( stats . mode & 1 ) > 0 ||
( ( stats . mode & 8 ) > 0 && stats . gid === process . getgid ( ) ) ||
( ( stats . mode & 64 ) > 0 && stats . uid === process . getuid ( ) ) ) ;
}
//# sourceMappingURL=io-util.js.map
/***/ } ) ,
/***/ 351 :
/***/ ( function ( _ _unused _webpack _module , exports , _ _nccwpck _require _ _ ) {
var _ _awaiter = ( this && this . _ _awaiter ) || function ( thisArg , _arguments , P , generator ) {
function adopt ( value ) { return value instanceof P ? value : new P ( function ( resolve ) { resolve ( value ) ; } ) ; }
return new ( P || ( P = Promise ) ) ( function ( resolve , reject ) {
function fulfilled ( value ) { try { step ( generator . next ( value ) ) ; } catch ( e ) { reject ( e ) ; } }
function rejected ( value ) { try { step ( generator [ "throw" ] ( value ) ) ; } catch ( e ) { reject ( e ) ; } }
function step ( result ) { result . done ? resolve ( result . value ) : adopt ( result . value ) . then ( fulfilled , rejected ) ; }
step ( ( generator = generator . apply ( thisArg , _arguments || [ ] ) ) . next ( ) ) ;
} ) ;
} ;
var _ _importStar = ( this && this . _ _importStar ) || function ( mod ) {
if ( mod && mod . _ _esModule ) return mod ;
var result = { } ;
if ( mod != null ) for ( var k in mod ) if ( Object . hasOwnProperty . call ( mod , k ) ) result [ k ] = mod [ k ] ;
result [ "default" ] = mod ;
return result ;
} ;
Object . defineProperty ( exports , "__esModule" , ( { value : true } ) ) ;
const childProcess = _ _importStar ( _ _nccwpck _require _ _ ( 129 ) ) ;
const path = _ _importStar ( _ _nccwpck _require _ _ ( 622 ) ) ;
const util _1 = _ _nccwpck _require _ _ ( 669 ) ;
const ioUtil = _ _importStar ( _ _nccwpck _require _ _ ( 962 ) ) ;
const exec = util _1 . promisify ( childProcess . exec ) ;
2019-11-24 06:44:53 +07:00
/ * *
2021-04-26 16:42:09 +07:00
* Copies a file or folder .
* Based off of shelljs - https : //github.com/shelljs/shelljs/blob/9237f66c52e5daa40458f94f9565e18e8132f5a6/src/cp.js
2019-11-24 06:44:53 +07:00
*
2021-04-26 16:42:09 +07:00
* @ param source source path
* @ param dest destination path
* @ param options optional . See CopyOptions .
2019-11-24 06:44:53 +07:00
* /
2021-04-26 16:42:09 +07:00
function cp ( source , dest , options = { } ) {
return _ _awaiter ( this , void 0 , void 0 , function * ( ) {
const { force , recursive } = readCopyOptions ( options ) ;
const destStat = ( yield ioUtil . exists ( dest ) ) ? yield ioUtil . stat ( dest ) : null ;
// Dest is an existing file, but not forcing
if ( destStat && destStat . isFile ( ) && ! force ) {
return ;
}
// If dest is an existing directory, should copy inside.
const newDest = destStat && destStat . isDirectory ( )
? path . join ( dest , path . basename ( source ) )
: dest ;
if ( ! ( yield ioUtil . exists ( source ) ) ) {
throw new Error ( ` no such file or directory: ${ source } ` ) ;
}
const sourceStat = yield ioUtil . stat ( source ) ;
if ( sourceStat . isDirectory ( ) ) {
if ( ! recursive ) {
throw new Error ( ` Failed to copy. ${ source } is a directory, but tried to copy without recursive flag. ` ) ;
}
else {
yield cpDirRecursive ( source , newDest , 0 , force ) ;
}
}
else {
if ( path . relative ( source , newDest ) === '' ) {
// a file cannot be copied to itself
throw new Error ( ` ' ${ newDest } ' and ' ${ source } ' are the same file ` ) ;
}
yield copyFile ( source , newDest , force ) ;
}
} ) ;
2019-11-24 06:44:53 +07:00
}
2021-04-26 16:42:09 +07:00
exports . cp = cp ;
2019-11-24 06:44:53 +07:00
/ * *
2021-04-26 16:42:09 +07:00
* Moves a path .
2019-11-24 06:44:53 +07:00
*
2021-04-26 16:42:09 +07:00
* @ param source source path
* @ param dest destination path
* @ param options optional . See MoveOptions .
2019-11-24 06:44:53 +07:00
* /
2021-04-26 16:42:09 +07:00
function mv ( source , dest , options = { } ) {
return _ _awaiter ( this , void 0 , void 0 , function * ( ) {
if ( yield ioUtil . exists ( dest ) ) {
let destExists = true ;
if ( yield ioUtil . isDirectory ( dest ) ) {
// If dest is directory copy src into dest
dest = path . join ( dest , path . basename ( source ) ) ;
destExists = yield ioUtil . exists ( dest ) ;
}
if ( destExists ) {
if ( options . force == null || options . force ) {
yield rmRF ( dest ) ;
}
else {
throw new Error ( 'Destination already exists' ) ;
}
}
}
yield mkdirP ( path . dirname ( dest ) ) ;
yield ioUtil . rename ( source , dest ) ;
} ) ;
2019-11-24 06:44:53 +07:00
}
2021-04-26 16:42:09 +07:00
exports . mv = mv ;
2019-11-24 06:44:53 +07:00
/ * *
2021-04-26 16:42:09 +07:00
* Remove a path recursively with force
2019-11-24 06:44:53 +07:00
*
2021-04-26 16:42:09 +07:00
* @ param inputPath path to remove
2019-11-24 06:44:53 +07:00
* /
2021-04-26 16:42:09 +07:00
function rmRF ( inputPath ) {
return _ _awaiter ( this , void 0 , void 0 , function * ( ) {
if ( ioUtil . IS _WINDOWS ) {
// Node doesn't provide a delete operation, only an unlink function. This means that if the file is being used by another
// program (e.g. antivirus), it won't be deleted. To address this, we shell out the work to rd/del.
try {
if ( yield ioUtil . isDirectory ( inputPath , true ) ) {
yield exec ( ` rd /s /q " ${ inputPath } " ` ) ;
}
else {
yield exec ( ` del /f /a " ${ inputPath } " ` ) ;
}
}
catch ( err ) {
// if you try to delete a file that doesn't exist, desired result is achieved
// other errors are valid
if ( err . code !== 'ENOENT' )
throw err ;
}
// Shelling out fails to remove a symlink folder with missing source, this unlink catches that
try {
yield ioUtil . unlink ( inputPath ) ;
}
catch ( err ) {
// if you try to delete a file that doesn't exist, desired result is achieved
// other errors are valid
if ( err . code !== 'ENOENT' )
throw err ;
}
}
else {
let isDir = false ;
try {
isDir = yield ioUtil . isDirectory ( inputPath ) ;
}
catch ( err ) {
// if you try to delete a file that doesn't exist, desired result is achieved
// other errors are valid
if ( err . code !== 'ENOENT' )
throw err ;
return ;
}
if ( isDir ) {
yield exec ( ` rm -rf " ${ inputPath } " ` ) ;
}
else {
yield ioUtil . unlink ( inputPath ) ;
}
}
} ) ;
2021-02-22 17:27:16 +07:00
}
2021-04-26 16:42:09 +07:00
exports . rmRF = rmRF ;
2021-02-22 17:27:16 +07:00
/ * *
2021-04-26 16:42:09 +07:00
* Make a directory . Creates the full path with folders in between
* Will throw if it fails
2021-02-22 17:27:16 +07:00
*
2021-04-26 16:42:09 +07:00
* @ param fsPath path to create
* @ returns Promise < void >
2021-02-22 17:27:16 +07:00
* /
2021-04-26 16:42:09 +07:00
function mkdirP ( fsPath ) {
return _ _awaiter ( this , void 0 , void 0 , function * ( ) {
yield ioUtil . mkdirP ( fsPath ) ;
} ) ;
2021-02-22 17:27:16 +07:00
}
2021-04-26 16:42:09 +07:00
exports . mkdirP = mkdirP ;
2021-02-22 17:27:16 +07:00
/ * *
2021-04-26 16:42:09 +07:00
* Returns path of a tool had the tool actually been invoked . Resolves via paths .
* If you check and the tool does not exist , it will throw .
2021-02-22 17:27:16 +07:00
*
2021-04-26 16:42:09 +07:00
* @ param tool name of the tool
* @ param check whether to check if tool exists
* @ returns Promise < string > path to tool
2021-02-22 17:27:16 +07:00
* /
2021-04-26 16:42:09 +07:00
function which ( tool , check ) {
return _ _awaiter ( this , void 0 , void 0 , function * ( ) {
if ( ! tool ) {
throw new Error ( "parameter 'tool' is required" ) ;
}
// recursive when check=true
if ( check ) {
const result = yield which ( tool , false ) ;
if ( ! result ) {
if ( ioUtil . IS _WINDOWS ) {
throw new Error ( ` Unable to locate executable file: ${ tool } . Please verify either the file path exists or the file can be found within a directory specified by the PATH environment variable. Also verify the file has a valid extension for an executable file. ` ) ;
}
else {
throw new Error ( ` Unable to locate executable file: ${ tool } . Please verify either the file path exists or the file can be found within a directory specified by the PATH environment variable. Also check the file mode to verify the file is executable. ` ) ;
}
}
return result ;
}
const matches = yield findInPath ( tool ) ;
if ( matches && matches . length > 0 ) {
return matches [ 0 ] ;
}
return '' ;
} ) ;
2021-02-22 17:27:16 +07:00
}
2021-04-26 16:42:09 +07:00
exports . which = which ;
2021-02-22 17:27:16 +07:00
/ * *
2021-04-26 16:42:09 +07:00
* Returns a list of all occurrences of the given tool on the system path .
2021-02-22 17:27:16 +07:00
*
2021-04-26 16:42:09 +07:00
* @ returns Promise < string [ ] > the paths of the tool
2021-02-22 17:27:16 +07:00
* /
2021-04-26 16:42:09 +07:00
function findInPath ( tool ) {
return _ _awaiter ( this , void 0 , void 0 , function * ( ) {
if ( ! tool ) {
throw new Error ( "parameter 'tool' is required" ) ;
}
// build the list of extensions to try
const extensions = [ ] ;
if ( ioUtil . IS _WINDOWS && process . env [ 'PATHEXT' ] ) {
for ( const extension of process . env [ 'PATHEXT' ] . split ( path . delimiter ) ) {
if ( extension ) {
extensions . push ( extension ) ;
}
}
}
// if it's rooted, return it if exists. otherwise return empty.
if ( ioUtil . isRooted ( tool ) ) {
const filePath = yield ioUtil . tryGetExecutablePath ( tool , extensions ) ;
if ( filePath ) {
return [ filePath ] ;
}
return [ ] ;
}
// if any path separators, return empty
if ( tool . includes ( path . sep ) ) {
return [ ] ;
}
// build the list of directories
//
// Note, technically "where" checks the current directory on Windows. From a toolkit perspective,
// it feels like we should not do this. Checking the current directory seems like more of a use
// case of a shell, and the which() function exposed by the toolkit should strive for consistency
// across platforms.
const directories = [ ] ;
if ( process . env . PATH ) {
for ( const p of process . env . PATH . split ( path . delimiter ) ) {
if ( p ) {
directories . push ( p ) ;
}
}
}
// find all matches
const matches = [ ] ;
for ( const directory of directories ) {
const filePath = yield ioUtil . tryGetExecutablePath ( path . join ( directory , tool ) , extensions ) ;
if ( filePath ) {
matches . push ( filePath ) ;
}
}
return matches ;
} ) ;
2019-11-24 06:44:53 +07:00
}
2021-04-26 16:42:09 +07:00
exports . findInPath = findInPath ;
function readCopyOptions ( options ) {
const force = options . force == null ? true : options . force ;
const recursive = Boolean ( options . recursive ) ;
return { force , recursive } ;
2021-02-22 17:27:16 +07:00
}
2021-04-26 16:42:09 +07:00
function cpDirRecursive ( sourceDir , destDir , currentDepth , force ) {
return _ _awaiter ( this , void 0 , void 0 , function * ( ) {
// Ensure there is not a run away recursive copy
if ( currentDepth >= 255 )
return ;
currentDepth ++ ;
yield mkdirP ( destDir ) ;
const files = yield ioUtil . readdir ( sourceDir ) ;
for ( const fileName of files ) {
const srcFile = ` ${ sourceDir } / ${ fileName } ` ;
const destFile = ` ${ destDir } / ${ fileName } ` ;
const srcFileStat = yield ioUtil . lstat ( srcFile ) ;
if ( srcFileStat . isDirectory ( ) ) {
// Recurse
yield cpDirRecursive ( srcFile , destFile , currentDepth , force ) ;
}
else {
yield copyFile ( srcFile , destFile , force ) ;
}
}
// Change the mode for the newly created directory
yield ioUtil . chmod ( destDir , ( yield ioUtil . stat ( sourceDir ) ) . mode ) ;
} ) ;
2021-03-17 06:18:19 +07:00
}
2021-04-26 16:42:09 +07:00
// Buffered file copy
function copyFile ( srcFile , destFile , force ) {
return _ _awaiter ( this , void 0 , void 0 , function * ( ) {
if ( ( yield ioUtil . lstat ( srcFile ) ) . isSymbolicLink ( ) ) {
// unlink/re-link it
try {
yield ioUtil . lstat ( destFile ) ;
yield ioUtil . unlink ( destFile ) ;
}
catch ( e ) {
// Try to override file permission
if ( e . code === 'EPERM' ) {
yield ioUtil . chmod ( destFile , '0666' ) ;
yield ioUtil . unlink ( destFile ) ;
}
// other errors = it doesn't exist, no work to do
}
// Copy over symlink
const symlinkFull = yield ioUtil . readlink ( srcFile ) ;
yield ioUtil . symlink ( symlinkFull , destFile , ioUtil . IS _WINDOWS ? 'junction' : null ) ;
}
else if ( ! ( yield ioUtil . exists ( destFile ) ) || force ) {
yield ioUtil . copyFile ( srcFile , destFile ) ;
}
} ) ;
}
//# sourceMappingURL=io.js.map
2019-11-24 06:44:53 +07:00
/***/ } ) ,
2021-02-22 17:27:16 +07:00
/***/ 357 :
/***/ ( ( module ) => {
2019-11-24 06:44:53 +07:00
2021-02-22 17:27:16 +07:00
module . exports = require ( "assert" ) ; ;
2019-11-24 06:44:53 +07:00
2021-02-22 17:27:16 +07:00
/***/ } ) ,
/***/ 129 :
/***/ ( ( module ) => {
module . exports = require ( "child_process" ) ; ;
/***/ } ) ,
/***/ 614 :
/***/ ( ( module ) => {
module . exports = require ( "events" ) ; ;
/***/ } ) ,
/***/ 747 :
/***/ ( ( module ) => {
module . exports = require ( "fs" ) ; ;
/***/ } ) ,
/***/ 211 :
/***/ ( ( module ) => {
module . exports = require ( "https" ) ; ;
/***/ } ) ,
/***/ 87 :
/***/ ( ( module ) => {
module . exports = require ( "os" ) ; ;
/***/ } ) ,
/***/ 622 :
/***/ ( ( module ) => {
module . exports = require ( "path" ) ; ;
/***/ } ) ,
2021-07-05 17:42:58 +07:00
/***/ 835 :
/***/ ( ( module ) => {
module . exports = require ( "url" ) ; ;
/***/ } ) ,
2021-02-22 17:27:16 +07:00
/***/ 669 :
/***/ ( ( module ) => {
module . exports = require ( "util" ) ; ;
2019-11-24 06:44:53 +07:00
/***/ } )
2021-02-22 17:27:16 +07:00
/******/ } ) ;
/************************************************************************/
/******/ // The module cache
/******/ var _ _webpack _module _cache _ _ = { } ;
/******/
/******/ // The require function
/******/ function _ _nccwpck _require _ _ ( moduleId ) {
/******/ // Check if module is in cache
2021-04-26 16:42:09 +07:00
/******/ var cachedModule = _ _webpack _module _cache _ _ [ moduleId ] ;
/******/ if ( cachedModule !== undefined ) {
/******/ return cachedModule . exports ;
2021-02-22 17:27:16 +07:00
/******/ }
/******/ // Create a new module (and put it into the cache)
/******/ var module = _ _webpack _module _cache _ _ [ moduleId ] = {
/******/ // no module.id needed
/******/ // no module.loaded needed
/******/ exports : { }
/******/ } ;
/******/
/******/ // Execute the module function
/******/ var threw = true ;
/******/ try {
/******/ _ _webpack _modules _ _ [ moduleId ] . call ( module . exports , module , module . exports , _ _nccwpck _require _ _ ) ;
/******/ threw = false ;
/******/ } finally {
/******/ if ( threw ) delete _ _webpack _module _cache _ _ [ moduleId ] ;
/******/ }
/******/
/******/ // Return the exports of the module
/******/ return module . exports ;
/******/ }
/******/
/************************************************************************/
/******/ /* webpack/runtime/compat */
/******/
2021-04-26 16:42:09 +07:00
/******/ if ( typeof _ _nccwpck _require _ _ !== 'undefined' ) _ _nccwpck _require _ _ . ab = _ _dirname + "/" ; /************************************************************************/
/******/
2021-02-22 17:27:16 +07:00
/******/ // startup
/******/ // Load entry module and return exports
2021-04-26 16:42:09 +07:00
/******/ // This entry module is referenced by other modules so it can't be inlined
/******/ var _ _webpack _exports _ _ = _ _nccwpck _require _ _ ( 39 ) ;
/******/ module . exports = _ _webpack _exports _ _ ;
/******/
2021-02-22 17:27:16 +07:00
/******/ } ) ( )
;