pioarduino-node-helpers/dist/index.js

Collection of Node.JS helpers for PlatformIO fork pioarduino

!function(A,e){"object"==typeof exports&&"object"==typeof module?module.exports=e(require("global-agent"),require("got"),require("ws"),require("jsonrpc-lite"),require("tcp-port-used"),require("semver"),require("tar")):"function"==typeof define&&define.amd?define("pioarduino-node-helpers",["global-agent","got","ws","jsonrpc-lite","tcp-port-used","semver","tar"],e):"object"==typeof exports?exports["pioarduino-node-helpers"]=e(require("global-agent"),require("got"),require("ws"),require("jsonrpc-lite"),require("tcp-port-used"),require("semver"),require("tar")):A["pioarduino-node-helpers"]=e(A["global-agent"],A.got,A.ws,A["jsonrpc-lite"],A["tcp-port-used"],A.semver,A.tar)}(global,(A,e,n,t,s,r,c)=>(()=>{"use strict";var v={317:A=>{A.exports=require("child_process")},303:e=>{e.exports=A},810:A=>{A.exports=e},852:A=>{A.exports=t},924:A=>{A.exports=r},871:A=>{A.exports=c},65:A=>{A.exports=s},2:A=>{A.exports=n}},f={};function o(A){var e=f[A];if(void 0!==e)return e.exports;var n=f[A]={exports:{}};return v[A](n,n.exports,o),n.exports}o.n=A=>{var e=A&&A.__esModule?()=>A.default:()=>A;return o.d(e,{a:e}),e},o.d=(A,e)=>{for(var n in e)o.o(e,n)&&!o.o(A,n)&&Object.defineProperty(A,n,{enumerable:!0,get:e[n]})},o.o=(A,e)=>Object.prototype.hasOwnProperty.call(A,e),o.r=A=>{"undefined"!=typeof Symbol&&Symbol.toStringTag&&Object.defineProperty(A,Symbol.toStringTag,{value:"Module"}),Object.defineProperty(A,"__esModule",{value:!0})};var d={};o.r(d),o.d(d,{core:()=>i,home:()=>w,installer:()=>qA,misc:()=>a,proc:()=>u,project:()=>KA});var u={};o.r(u),o.d(u,{IS_WINDOWS:()=>h,extendOSEnvironPath:()=>z,getCommandOutput:()=>x,getSysType:()=>p,patchOSEnviron:()=>L,runCommand:()=>y,terminateCmdsInQueue:()=>g,whereIsProgram:()=>Z});var i={};o.r(i),o.d(i,{getCacheDir:()=>E,getCoreDir:()=>O,getCorePythonCommandOutput:()=>G,getCorePythonExe:()=>V,getCoreState:()=>W,getEnvBinDir:()=>Q,getEnvDir:()=>M,getPIOCommandOutput:()=>N,getTmpDir:()=>T,runPIOCommand:()=>Y,setCoreState:()=>F});var a={};o.r(a),o.d(a,{PEPverToSemver:()=>K,arrayRemove:()=>J,disposeSubscriptions:()=>q,getErrorReportUrl:()=>$,loadJSON:()=>U,reportError:()=>_,sleep:()=>k});var w={};o.r(w),o.d(w,{constructServerUrl:()=>lA,ensureServerStarted:()=>hA,getFrontendUrl:()=>PA,getFrontendVersion:()=>HA,isServerStarted:()=>bA,showAtStartup:()=>gA,shutdownAllServers:()=>zA,shutdownServer:()=>LA});var B=o(303);const l=require("fs");var P=o.n(l);const H=require("path");var X=o.n(H);const{spawn:b}=o(317),h=process.platform.startsWith("win");function p(){const A=`${process.platform}_${process.arch}`;return{win32_x64:"windows_amd64",win32_x32:"windows_x86",win32_ia32:"windows_x86",darwin_x64:"darwin_x86_64",darwin_x32:"darwin_i686",darwin_arm64:"darwin_arm64",linux_x64:"linux_x86_64",linux_x32:"linux_i686",linux_arm:"linux_armv6l",linux_arm64:"linux_aarch64",freebsd_x64:"freebsd_amd64"}[A]||A}function L({caller:A,extraPath:e,extraVars:n}){process.env.PLATFORMIO_CALLER=A,"darwin"===process.platform&&(process.env.LC_ALL="en_US.UTF-8"),"atom"===A&&(process.env.PLATFORMIO_DISABLE_PROGRESSBAR="true"),n&&Object.keys(n).forEach(A=>process.env[A]=n[A]),process.env.PLATFORMIO_PATH=process.env.PATH,process.env.Path&&(process.env.PLATFORMIO_PATH?process.env.PLATFORMIO_PATH+=X().delimiter+process.env.Path:process.env.PLATFORMIO_PATH=process.env.Path),e&&z("PLATFORMIO_PATH",e.split(X().delimiter));const t=/\%([^\%]+)\%/g,s=[];for(;h;){const A=t.exec(process.env.PLATFORMIO_PATH);if(!A||s.includes(A[1]))break;s.push(A[1]),process.env.PLATFORMIO_PATH=process.env.PLATFORMIO_PATH.replace(A[0],process.env[A[1]]||"")}process.env.NO_PROXY="127.0.0.1"+(process.env.NO_PROXY?`,${process.env.NO_PROXY}`:""),(process.env.HTTP_PROXY||process.env.HTTPS_PROXY||process.env.ALL_PROXY)&&(process.env.GLOBAL_AGENT_ENVIRONMENT_VARIABLE_NAMESPACE="",(0,B.bootstrap)())}function z(A,e,n=!0){e.reverse().forEach(e=>{process.env[A].includes(e)||(process.env[A]=(n?[e,process.env[A]]:[process.env[A],e]).join(X().delimiter))})}const j=[];function g(){for(;j.length;){const A=j.pop()[2];A&&A(-1,void 0,new Error("Terminated by user"))}}function y(A,e,n=void 0,t={}){if((t=t||{})._id||(t._id=`${A}-${Math.random()}`),!(t.runInQueue&&(console.info("Put command in queue",A,e,t),j.push([A,e,n,t]),j.length>1)))return D(A,e,n,t)}function D(A,e,n,t){console.info("runCommand",A,e,t);const s=[],r=[];let c=!1;function v(A){if(c)return;if(t.runInQueue&&(function(A){const e=j.findIndex(e=>e[3]._id===A);e>-1&&j.splice(e,1)}(t._id),j.length>0&&D(...j.pop())),!n)return;c=!0;const e=s.join(""),v=r.join("");n(A,e,v)}t.spawnOptions=t.spawnOptions||{},t.projectDir&&(t.spawnOptions.cwd=t.projectDir);const f=Object.assign({},t.spawnOptions.env||process.env);process.env.PLATFORMIO_PATH&&(f.PATH=process.env.PLATFORMIO_PATH,f.Path=process.env.PLATFORMIO_PATH),t.spawnOptions.env=f;try{const n=b(A,e,t.spawnOptions);t.onProcCreated&&t.onProcCreated(n),n.stdout.on("data",A=>{s.push(A.toString()),t.onProcStdout&&t.onProcStdout(A)}),n.stderr.on("data",A=>{r.push(A.toString()),t.onProcStderr&&t.onProcStderr(A)}),n.on("close",v),n.on("error",A=>{r.push(A.toString()),v(-1)})}catch(A){r.push(A.toString()),v(-1)}}function x(A,e,n={}){return new Promise((t,s)=>{y(A,e,(A,e,n)=>{if(0===A)return t(e);{const A=new Error(e?`${n} -> ${e}`:n);return A.stderr=n,A.stdout=e,s(A)}},n)})}function Z(A){const e=process.env.PLATFORMIO_PATH||process.env.PATH;for(const n of e.split(X().delimiter)){const e=X().normalize(X().join(n,A)).replace(/"/g,"");try{if(P().existsSync(e))return e}catch(A){}}return null}let m;function F(A){m=A}function W(){return m||{}}function O(){if(W().core_dir)return W().core_dir;let A=process.env.HOME||"~";h&&(process.env.USERPROFILE?A=process.env.USERPROFILE:process.env.HOMEPATH&&(A=X().join(process.env.HOMEDRIVE||"",process.env.HOMEPATH)));const e=process.env.PLATFORMIO_CORE_DIR||process.env.PLATFORMIO_HOME_DIR||X().join(A,".platformio");if(!h)return e;const n=X().parse(e),t=X().format({root:n.root,dir:n.root,base:".platformio",name:".platformio"});try{return P().accessSync(t),t}catch(A){}for(const A of e)if(A.charCodeAt(0)>127)return t;return e}function E(){if(W().cache_dir)return W().cache_dir;const A=X().join(O(),".cache");try{P().accessSync(A)}catch(e){P().mkdirSync(A,{recursive:!0})}return A}function T(){const A=X().join(E(),"tmp");try{P().accessSync(A)}catch(e){P().mkdirSync(A,{recursive:!0})}return A}function M(){return W().penv_dir?W().penv_dir:"PLATFORMIO_PENV_DIR"in process.env?process.env.PLATFORMIO_PENV_DIR:X().join(O(),"penv")}function Q(){return W().penv_bin_dir?W().penv_bin_dir:X().join(M(),h?"Scripts":"bin")}async function V(){const A=W().python_exe;if(!A)throw new Error("pioarduino Core is not installed");return A}async function G(A,e){return await x(await V(),A,e)}async function N(A,e={}){const n=["-m","platformio"];return process.env.PLATFORMIO_CALLER&&n.push("-c",process.env.PLATFORMIO_CALLER),await G([...n,...A],e)}async function Y(A,e,n={}){const t=["-m","platformio"];process.env.PLATFORMIO_CALLER&&t.push("-c",process.env.PLATFORMIO_CALLER),y(await V(),[...t,...A],e,n)}var S=o(810),C=o.n(S);const I=require("os");var R=o.n(I);function k(A){return new Promise(e=>setTimeout(e,A))}async function U(A){try{return await l.promises.access(A),JSON.parse(await l.promises.readFile(A,{encoding:"utf-8"}))}catch(A){return console.error(A),null}}function J(A,e){return A.splice(A.indexOf(e),1)}function q(A){for(;A.length;)A.pop().dispose()}function K(A){return A.replace(/(\.\d+)\.?(dev|a|b|rc|post)/,"$1-$2.")}async function _(A){const e=new URLSearchParams;e.set("v",1),e.set("tid","UA-1768265-13"),e.set("cid",function(){const A=()=>Math.floor(65536*(1+Math.random())).toString(16).substring(1);return`${A()}${A()}-${A()}-${A()}-${A()}-${A()}${A()}${A()}`}()),e.set("aid","node.helpers"),e.set("av","11.4.1"),e.set("an",`${R().type()}, ${R().release()}, ${R().arch()}`),e.set("t","exception"),e.set("exd",A.toString()),e.set("exf",1),process.env.PLATFORMIO_CALLER&&e.set("cd1",process.env.PLATFORMIO_CALLER),await C().post("https://www.google-analytics.com/collect",{body:e.toString(),timeout:2e3})}function $(A,e){const n=[["Multiple requests to rebuild the project","https://bit.ly/3mMTOgB"],["WindowsError: [Error 5]","https://bit.ly/3GTAtlG"],["[WinError 5]","https://bit.ly/3GTAtlG"],["[WinError 225]","https://bit.ly/3GTAtlG"],["Could not start PIO Home server: Error: timeout","https://bit.ly/2Yfl65C"],["`venv` module","https://bit.ly/3bK6zlH"],["after connection broken by","https://bit.ly/3q6StTV"],["subprocess.CalledProcessError","https://bit.ly/3EFlxWq"],["Can not find Python Interpreter","https://bit.ly/3wkz0Qv"],["platformio-ide.useBuiltinPIOCore","https://bit.ly/3AhJHHe"],["Could not start PIO Home server: Timeout error","https://bit.ly/3m2Tbl9"],["Could not create PIO Core Virtual Environment","https://bit.ly/43hNh04"],["Compatible pioarduino Core not found","https://bit.ly/43tNj4C"],["Could not find a version that satisfies the requirement","https://bit.ly/3TOcnBK"],["PIO IDE: v2.","https://bit.ly/3H70AHl"]];for(const A of n)if(e.includes(A[0]))return A[1];let t=`${process.env.PLATFORMIO_CALLER||"vscode"}-ide`;A.includes("Installation Manager")&&(t="core-installer");const s=new URLSearchParams;return s.set("title",A),s.set("body",e),s.set("labels","auto"),`https://github.com/platformio/platformio-${t}/issues/new?${s.toString()}`}var AA=o(2),eA=o.n(AA);const nA=require("crypto");var tA=o.n(nA),sA=o(852),rA=o.n(sA),cA=o(65),vA=o.n(cA);const fA=30,oA=3600,dA=45e3,uA=45999,iA=tA().createHash("sha1").update(tA().randomBytes(512)).digest("hex");let aA="127.0.0.1",wA=0,BA=0;function lA({scheme:A="http",host:e,port:n,path:t,query:s,includeSID:r=!0}={}){let c=`${A}://${e||aA}:${n||wA}`;if(r&&(c+=`/session/${iA}`),c+=t||"/",s){const A=new URLSearchParams;Object.keys(s).forEach(e=>A.set(e,s[e])),c+=`?${A.toString()}`}return c}function PA(A){const e=(jA()||{}).storage||{},n={start:A.start||"/",theme:e.theme||A.theme,workspace:e.workspace||A.workspace};return Object.keys(n).forEach(A=>{[void 0,null].includes(n[A])&&delete n[A]}),lA({query:n})}async function HA(){try{return(await C()(lA({path:"/package.json"}),{timeout:1e3}).json()).version}catch(A){}}async function XA(A,e){return new Promise(n=>{vA().check(A,e).then(A=>n(A),()=>n(!1))})}async function bA(){return!!await XA(wA,aA)&&!!await HA()}async function hA(A={}){let e,n=0;for(;n<3;){try{return await pA(A)}catch(A){wA=0,e=A,console.warn(A)}n++}throw _(e),e}async function pA(A={}){return 0===wA&&(wA=A.port||await async function(){let A=0;for(;A<13;){const e=Math.floor(Math.random()*(uA-dA)+dA);if(!await XA(e,aA))return e;A++}return 0}()),A.host&&(aA=A.host),await bA()||await new Promise((A,e)=>{const n=setTimeout(()=>e(new Error("Could not start PIO Home server: Timeout error")),1e3*fA);let t="";Y(["home","--port",wA,"--host",aA,"--session-id",iA,"--shutdown-timeout",oA,"--no-open"],(A,n,t)=>{if(0!==A)return wA=0,e(new Error(t))},{onProcStdout:e=>{t+=e.toString(),t.includes("PIO Home has been started")&&(clearTimeout(n),A(!0))}})}),A.onIDECommand&&async function(A){if(BA>0)return;const e=new(eA())(lA({scheme:"ws",path:"/wsrpc"}),{perMessageDeflate:!1});e.on("open",()=>{BA=1,e.send(JSON.stringify(rA().request(Math.random().toString(),"core.version")))}),e.on("close",()=>{BA=0}),e.on("message",async n=>{try{const t=rA().parse(n.toString());if("success"===t.type&&t.payload.result.method){const n=await A(t.payload.result.method,t.payload.result.params);e.send(JSON.stringify(rA().request(Math.random().toString(),"ide.on_command_result",[t.payload.result.id,n])))}else"error"===t.type&&console.error("Errored WS result: ",t.payload)}catch(A){console.error("Invalid RPC message: ",A)}e.send(JSON.stringify(rA().request(Math.random().toString(),"ide.listen_commands")))})}(A.onIDECommand),{host:aA,port:wA,sessionId:iA}}async function LA(){if(wA)try{await C().post(lA({path:"/__shutdown__"}),{timeout:1e3})}catch(A){}}async function zA(){let A=dA;for(;A<uA;){try{C()(lA({port:A,includeSID:!1,query:{__shutdown__:"1"}}),{timeout:1e3,throwHttpErrors:!1}).then(()=>{},()=>{})}catch(A){}A++}await k(2e3)}function jA(){try{return JSON.parse(P().readFileSync(X().join(O(),"homestate.json"),{encoding:"utf-8"}))}catch(A){}}function gA(A){const e=jA();return!e||!e.storage||!e.storage.showOnStartup||!(A in e.storage.showOnStartup)||e.storage.showOnStartup[A]}class yA{static generalTasks=[{name:"Build",args:["run"],multienv:!0},{name:"Upload",args:["run","--target","upload"],optionalArgs:["--upload-port"],multienv:!0},{name:"Monitor",args:["device","monitor"],optionalArgs:["--port"],multienv:!0},{name:"Upload and Monitor",args:["run","--target","upload","--target","monitor"],optionalArgs:["--upload-port","--monitor-port"],multienv:!0},{name:"Devices",args:["device","list"]},{name:"Clean",args:["run","--target","clean"],multienv:!0},{name:"Full Clean",description:"Clean a build environment and installed library dependencies",args:["run","--target","fullclean"],multienv:!0},{name:"List",args:["pkg","list"],group:"Dependencies",multienv:!0},{name:"Outdated",args:["pkg","outdated"],group:"Dependencies",multienv:!0},{name:"Update",args:["pkg","update"],group:"Dependencies",multienv:!0},{name:"Test",args:["test"],optionalArgs:["--upload-port","--test-port"],group:"Advanced",multienv:!0},{name:"Check",args:["check"],group:"Advanced",multienv:!0},{name:"Pre-Debug",description:"Build in debug mode",args:["debug"],group:"Advanced",multienv:!0},{name:"Verbose Build",args:["run","--verbose"],group:"Advanced",multienv:!0},{name:"Verbose Upload",args:["run","--verbose","--target","upload"],optionalArgs:["--upload-port"],group:"Advanced",multienv:!0},{name:"Verbose Test",args:["test","--verbose"],group:"Advanced",multienv:!0},{name:"Verbose Check",args:["check","--verbose"],group:"Advanced",multienv:!0},{name:"Compilation Database",description:"Generate compilation database `compile_commands.json`",args:["run","--target","compiledb"],group:"Advanced",multienv:!0},{name:"Remote Upload",args:["remote","run","--target","upload"],group:"Remote",multienv:!0},{name:"Remote Monitor",args:["remote","device","monitor"],group:"Remote"},{name:"Remote Devices",args:["remote","device","list"],group:"Remote"},{name:"Remote Test",args:["remote","test"],group:"Remote",multienv:!0},{name:"Upgrade pioarduino Core",args:["upgrade"],group:"Miscellaneous"}];constructor(A,e){this.projectDir=A,this.ide=e}async getDefaultTasks(){return yA.generalTasks.map(A=>{const e=new DA(A.name,A.args.slice(0),A.group);return e.description=A.description,e.multienv=!!A.multienv,e.optionalArgs=A.optionalArgs,e})}async fetchEnvTasks(A){const e=[],n=[];for(const t of yA.generalTasks){if(!t.multienv)continue;n.push(t.name);const s=new DA(t.name,[...t.args.slice(0),"--environment",A],t.group);s.description=t.description,s.multienv=!0,s.optionalArgs=t.optionalArgs,e.push(s)}const t=new DA("Rebuild IntelliSense Index",["project","init","--ide",this.ide,"--environment",A],"Miscellaneous");t.multienv=!0,e.push(t);try{for(const t of await this.fetchEnvTargets(A)){if(n.includes(t.title))continue;const s=new DA(t.title||t.name,["run","--target",t.name,"--environment",A],t.group);s.description=t.description,s.multienv=!0,e.push(s)}}catch(e){console.error(`Could not fetch project targets for '${A}' environment => ${e}`)}return e}async fetchEnvTargets(A){const e=`\nimport json\nimport os\nfrom platformio.public import load_build_metadata\n\nprint(json.dumps(load_build_metadata(os.getcwd(), '${A}', cache=True)["targets"]))\n  `,n=await G(["-c",e],{projectDir:this.projectDir,runInQueue:!0});return JSON.parse(n.trim())}}class DA{constructor(A,e,n="General"){this.name=A,this.args=e,this.group=n,this.description=void 0,this.multienv=!1,this.optionalArgs=void 0}isBuild(){return this.name.startsWith("Build")}isClean(){return this.name.startsWith("Clean")}isTest(){return this.name.startsWith("Test")}get coreTarget(){if("run"!==this.args[0])return this.args[0];const A=this.args.indexOf("--target");return-1!==A?this.args[A+1]:"build"}get coreEnv(){const A=this.args.indexOf("--environment");return-1!==A?this.args[A+1]:void 0}get id(){const A=this.coreEnv;return A?`${this.name} (${A})`:this.name}get title(){const A=this.coreEnv,e=this.description||this.name;return A?`${e} (${A})`:e}getCoreArgs(A={}){const e=this.args.slice(0);return this.optionalArgs&&A.port&&this.optionalArgs.filter(A=>A.endsWith("-port")).forEach(n=>{e.push(n),e.push(A.port)}),e}}class xA{static STATUS_CHECKING=0;static STATUS_INSTALLING=1;static STATUS_SUCCESSED=2;static STATUS_FAILED=3;constructor(A,e,n={}){this.stateStorage=A,this.onStatusChange=e,this.params=n,this._status=xA.STATUS_CHECKING}get name(){return"Stage"}get status(){return this._status}set status(A){this._status=A,this.onStatusChange()}get stateKey(){return this.name.toLocaleLowerCase().replace(/\s+/g,"-")}get state(){return this.stateStorage.getValue(this.stateKey)}set state(A){this.stateStorage.setValue(this.stateKey,A)}check(){throw new Error("Stage must implement a `check` method")}install(){throw new Error("Stage must implement an `install` method")}destroy(){}}class ZA{constructor(A){this.projectDir=A,this._data=void 0}async read(){const A=await G(["-c",'\nimport json\nfrom platformio.public import ProjectConfig\n\nconfig = ProjectConfig()\nenvs = config.envs()\n\nprint(json.dumps(dict(\n  envs=envs,\n  default_envs=config.default_envs(),\n  default_env=config.get_default_env(),\n  env_platforms={env:config.get(f"env:{env}", "platform", default=None) for env in envs}\n)))\n'],{projectDir:this.projectDir});this._data=JSON.parse(A.trim())}envs(){return this._data.envs}defaultEnvs(){return this._data.default_envs}defaultEnv(){return this._data.default_env}getEnvPlatform(A){return this._data.env_platforms[A]}}class mA{static AUTO_REBUILD_DELAY=3;static FLOOD_TIME_WINDOW=600;static FLOOD_MAX_ATTEMPTS=30;constructor(A,e,n){this.projectDir=A,this.options=e,this.observer=n,this._rebuildTimeout=void 0,this._inProgress=!1,this._floodStartedAt=Date.now(),this._floodAttempts=0}dispose(){this._rebuildTimeout&&clearTimeout(this._rebuildTimeout)}requestRebuild(){if(Date.now()-this._floodStartedAt<1e3*mA.FLOOD_TIME_WINDOW?this._floodAttempts++:(this._floodAttempts=0,this._floodStartedAt=Date.now()),this._rebuildTimeout&&(clearTimeout(this._rebuildTimeout),this._rebuildTimeout=void 0),this._floodAttempts>=mA.FLOOD_MAX_ATTEMPTS){if(this._floodAttempts===mA.FLOOD_MAX_ATTEMPTS&&this.options.api.onDidNotifyError){const A=`Multiple requests to rebuild the project "${X().basename(this.projectDir)}" index have been received!\nAutomatic index rebuilding process has been terminated for ${mA.FLOOD_TIME_WINDOW/60} minutes.`;this.options.api.onDidNotifyError(A,new Error(A))}}else this._rebuildTimeout=setTimeout(this.rebuild.bind(this),1e3*mA.AUTO_REBUILD_DELAY)}rebuild(){if(!this._inProgress)return this.options.api.withIndexRebuildingProgress(this._rebuildWithProgress.bind(this))}async _rebuildWithProgress(A=void 0,e=void 0){A||(A=()=>{}),this._inProgress=!0,this.options.api.logOutputChannel&&this.options.api.logOutputChannel.clear();const n=(e,n=!1)=>{A(e.toString().trim()),this.options.api.logOutputChannel&&(this.options.api.logOutputChannel.append(e.toString()),n&&this.options.api.logOutputChannel.show(),n&&this.options.api.logOutputChannel.appendLine(""))};try{const A=["project","init","--ide",this.options.ide];this.observer.getSelectedEnv()&&A.push("--environment",this.observer.getSelectedEnv()),await N(A,{projectDir:this.projectDir,runInQueue:!0,onProcCreated:A=>{e&&e.onCancellationRequested(()=>{n("Configuration process has been terminated!",!0),g(),A.kill()})},onProcStdout:A=>n(A),onProcStderr:A=>n(A,!0)})}catch(A){console.warn(A),e||e.isCancellationRequested||n(A,!0)}this._inProgress=!1}}class FA{static WATCH_DIRS_UPDATE_DELAY=1e4;constructor(A,e){this.projectDir=A,this.options=e,this.subscriptions=[],this.dirWatchSubscriptions=[],this._cache=new Map,this._config=void 0,this._indexer=void 0,this._projectTasks=new yA(this.projectDir,this.options.ide),this._updateDirWatchersTimeout=void 0,this._selectedEnv=void 0,this._apiConfigChangedTimeout=void 0,this.getSetting("autoRebuild")&&this.setupFSWatchers()}dispose(){q(this.dirWatchSubscriptions),q(this.subscriptions),this._updateDirWatchersTimeout&&clearTimeout(this._updateDirWatchersTimeout),this._indexer&&this._indexer.dispose(),this.resetCache()}activate(){console.info("Activating project",this.projectDir),this.rebuildIndex()}deactivate(){console.info("Deactivating project",this.projectDir)}getSetting(A){return(this.options.settings||{})[A]}resetCache(){this._cache.clear()}async getConfig(){return this._config||(this._config=new ZA(this.projectDir),await this._config.read()),this._config}rebuildIndex({force:A=!1,delayed:e=!1}={}){if(A||this.getSetting("autoRebuild"))return this._indexer||(this._indexer=new mA(this.projectDir,this.options,this)),e?this._indexer.requestRebuild():this._indexer.rebuild()}async switchProjectEnv(A){(await this.getConfig()).envs().includes(A)||(A=void 0),this._selectedEnv=A}getSelectedEnv(){return this._selectedEnv}async revealActiveEnvironment(){return this._selectedEnv?this._selectedEnv:(await this.getConfig()).defaultEnv()}async getDefaultTasks(){return this._projectTasks.getDefaultTasks()}async getLoadedEnvTasks(A,e={preload:!1}){const n=`envTasks${A}`;return this._cache.has(n)?this._cache.get(n):e.preload||this.getSetting("autoPreloadEnvTasks")||this._selectedEnv===A||1===(await this.getConfig()).envs().length?await this.loadEnvTasks(A):void 0}async loadEnvTasks(A){const e=`envTasks${A}`;return this._cache.has(e)||(this._cache.set(e,[]),this._cache.set(e,await this.options.api.withTasksLoadingProgress(async()=>await this._projectTasks.fetchEnvTasks(A)))),this._cache.get(e)}onDidChangeProjectConfig(){this._config=void 0,this.resetCache(),this.requestUpdateDirWatchers(),(this.options.api||{}).onDidChangeProjectConfig&&this.options.api.onDidChangeProjectConfig(X().join(this.projectDir,"platformio.ini"))}onDidChangeLibDirs(){this.rebuildIndex({delayed:!0})}setupFSWatchers(){const A=this.options.api.createFileSystemWatcher(X().join(this.projectDir,"platformio.ini"));this.subscriptions.push(A,A.onDidCreate(()=>this.onDidChangeProjectConfig()),A.onDidChange(()=>this.onDidChangeProjectConfig())),this.requestUpdateDirWatchers()}requestUpdateDirWatchers(){this._updateDirWatchersTimeout&&clearTimeout(this._updateDirWatchersTimeout),this._updateDirWatchersTimeout=setTimeout(this.updateDirWatchers.bind(this),FA.WATCH_DIRS_UPDATE_DELAY)}async updateDirWatchers(){q(this.dirWatchSubscriptions);try{(await this.fetchLibDirs()).forEach(A=>{const e=this.options.api.createDirSystemWatcher(A);this.dirWatchSubscriptions.push(e,e.onDidCreate(()=>this.onDidChangeLibDirs()),e.onDidChange(()=>this.onDidChangeLibDirs()),e.onDidDelete(()=>this.onDidChangeLibDirs()))})}catch(A){console.warn(A)}}async fetchLibDirs(){const A=await G(["-c","\nimport json\nfrom platformio.public import get_project_watch_lib_dirs\nprint(json.dumps(get_project_watch_lib_dirs()))\n"],{projectDir:this.projectDir});return JSON.parse(A.trim())}}const WA='\n# Copyright (c) 2014-present PlatformIO <contact@platformio.org>\n#\n# Licensed under the Apache License, Version 2.0 (the "License");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n#    http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an "AS IS" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n\n# pylint:disable=bad-option-value,import-outside-toplevel\n\nimport os\nimport shutil\nimport sys\nimport tempfile\nfrom base64 import b64decode\n\nDEPENDENCIES = b"""\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