@shell-shock/plugin-upgrade 0.1.0

package/dist/components/upgrade-builtin.mjs

@@ -0,0 +1,728 @@
+import { createComponent, createIntrinsic, mergeProps } from "@alloy-js/core/jsx-runtime";
+import { Show, code, splitProps } from "@alloy-js/core";
+import { ElseClause, ElseIfClause, FunctionDeclaration, IfStatement, InterfaceDeclaration, VarDeclaration } from "@alloy-js/typescript";
+import { Spacing } from "@powerlines/plugin-alloy/core/components/spacing";
+import { InterfaceMember, TSDoc, TSDocParam, TSDocRemarks, TSDocReturns, TypeDeclaration } from "@powerlines/plugin-alloy/typescript";
+import { BuiltinFile } from "@powerlines/plugin-alloy/typescript/components/builtin-file";
+import defu from "defu";
+
+//#region src/components/upgrade-builtin.tsx
+/**
+* The `locatePackageJson` handler function declaration code for the Shell Shock project.
+*/
+function LocatePackageJsonFunctionDeclaration() {
+	return [
+		createComponent(InterfaceDeclaration, {
+			"export": true,
+			name: "LocatePackageJsonOptions",
+			doc: "Options for the `locatePackageJson` handler function.",
+			get children() {
+				return createComponent(InterfaceMember, {
+					name: "cwd",
+					optional: true,
+					type: "string",
+					doc: "The current working directory to use. If not provided, the process's current working directory will be used."
+				});
+			}
+		}),
+		createComponent(Spacing, {}),
+		createComponent(TSDoc, {
+			heading: "Locate the package.json file currently being used by the command-line/workspace.",
+			get children() {
+				return [
+					createComponent(TSDocRemarks, { children: `This function is used to determine the package.json file currently being used by the command-line/workspace. It can be used in the CLI upgrade command to check if the application is using npm, yarn, or another package manager.` }),
+					createComponent(Spacing, {}),
+					createComponent(TSDocParam, {
+						name: "options",
+						children: `The options for the \`locatePackageJson\` function. Currently, there are no options available, but this parameter is included for future extensibility.`
+					}),
+					createComponent(TSDocReturns, { children: `A promise that resolves to the package.json file currently being used by the command-line/workspace as a string.` })
+				];
+			}
+		}),
+		createComponent(FunctionDeclaration, {
+			"export": true,
+			async: true,
+			name: "locatePackageJson",
+			parameters: [{
+				name: "options",
+				type: "LocatePackageJsonOptions",
+				default: "{}"
+			}],
+			returnType: "string | undefined",
+			get children() {
+				return [
+					createComponent(VarDeclaration, {
+						"let": true,
+						name: "currentPath",
+						type: "string",
+						initializer: code`options.cwd ?? process.cwd(); `
+					}),
+					createIntrinsic("hbr", {}),
+					createComponent(VarDeclaration, {
+						"let": true,
+						name: "parentPath",
+						initializer: code`resolve(currentPath, ".."); `
+					}),
+					createComponent(Spacing, {}),
+					code`while (parentPath !== currentPath && currentPath !== homePath && currentPath !== tempPath) { `,
+					createComponent(IfStatement, {
+						condition: code`existsSync(join(currentPath, "package.json"))`,
+						children: code`return join(currentPath, "package.json"); `
+					}),
+					createComponent(ElseClause, { children: code`currentPath = pathParent;
+          parentPath = resolve(currentPath, ".."); ` }),
+					code` }
+
+        return undefined; `
+				];
+			}
+		})
+	];
+}
+/**
+* The `locateLockfile` handler function declaration code for the Shell Shock project.
+*/
+function LocateLockfileFunctionDeclaration() {
+	return [
+		createComponent(InterfaceDeclaration, {
+			"export": true,
+			name: "LocateLockfileOptions",
+			doc: "Options for the `locateLockfile` handler function.",
+			get children() {
+				return createComponent(InterfaceMember, {
+					name: "cwd",
+					optional: true,
+					type: "string",
+					doc: "The current working directory to use. If not provided, the process's current working directory will be used."
+				});
+			}
+		}),
+		createComponent(Spacing, {}),
+		createComponent(TSDoc, {
+			heading: "Locate the lockfile currently being used by the command-line/workspace.",
+			get children() {
+				return [
+					createComponent(TSDocRemarks, { children: `This function is used to determine the lockfile currently being used by the command-line/workspace. It can be used in the CLI upgrade command to check if the application is using npm, yarn, or another package manager.` }),
+					createComponent(Spacing, {}),
+					createComponent(TSDocParam, {
+						name: "options",
+						children: `The options for the \`locateLockfile\` function. Currently, there are no options available, but this parameter is included for future extensibility.`
+					}),
+					createComponent(TSDocReturns, { children: `A promise that resolves to the lockfile currently being used by the command-line/workspace as a string.` })
+				];
+			}
+		}),
+		createComponent(FunctionDeclaration, {
+			"export": true,
+			async: true,
+			name: "locateLockfile",
+			parameters: [{
+				name: "options",
+				type: "LocateLockfileOptions",
+				default: "{}"
+			}],
+			returnType: "string | undefined",
+			get children() {
+				return [
+					createComponent(VarDeclaration, {
+						"let": true,
+						name: "currentPath",
+						type: "string",
+						initializer: code`options.cwd ?? process.cwd(); `
+					}),
+					createIntrinsic("hbr", {}),
+					createComponent(VarDeclaration, {
+						"let": true,
+						name: "parentPath",
+						initializer: code`resolve(currentPath, ".."); `
+					}),
+					createComponent(Spacing, {}),
+					code`while (parentPath !== currentPath && currentPath !== homePath && currentPath !== tempPath) { `,
+					createComponent(VarDeclaration, {
+						"const": true,
+						name: "lockfile",
+						initializer: code`[
+            "package-lock.json",
+            "npm-shrinkwrap.json",
+            "yarn.lock",
+            "pnpm-lock.yaml",
+            "pnpm-workspace.yaml",
+            "deno.lock",
+            "deno.json",
+            "deno.jsonc",
+            "bun.lock",
+            "bun.lockb"
+          ].find(lf => existsSync(join(currentPath, lf))); `
+					}),
+					createIntrinsic("hbr", {}),
+					createComponent(IfStatement, {
+						condition: code`lockfile`,
+						children: code`return lockfile; `
+					}),
+					createComponent(ElseClause, { children: code`currentPath = pathParent;
+          parentPath = resolve(currentPath, ".."); ` }),
+					code` }
+
+        return undefined; `
+				];
+			}
+		})
+	];
+}
+/**
+* The `getPackageManager` handler function declaration code for the Shell Shock project.
+*/
+function GetPackageManagerFunctionDeclaration() {
+	return [
+		createComponent(TypeDeclaration, {
+			"export": true,
+			name: "GetPackageManagerOptions",
+			doc: "Options for the `getPackageManager` handler function.",
+			children: code`LocateLockfileOptions;`
+		}),
+		createComponent(Spacing, {}),
+		createComponent(TSDoc, {
+			heading: "Get the package manager currently being used by the command-line/workspace.",
+			get children() {
+				return [
+					createComponent(TSDocRemarks, { children: `This function is used to determine the package manager currently being used by the command-line/workspace. It can be used in the CLI upgrade command to check if the application is using npm, yarn, or another package manager.` }),
+					createComponent(Spacing, {}),
+					createComponent(TSDocParam, {
+						name: "options",
+						children: `The options for the \`getPackageManager\` function. Currently, there are no options available, but this parameter is included for future extensibility.`
+					}),
+					createComponent(TSDocReturns, { children: `A promise that resolves to the package manager currently being used by the command-line/workspace as a string.` })
+				];
+			}
+		}),
+		createComponent(FunctionDeclaration, {
+			"export": true,
+			async: true,
+			name: "getPackageManager",
+			parameters: [{
+				name: "options",
+				type: "GetPackageManagerOptions",
+				default: "{}"
+			}],
+			returnType: code`Promise<"npm" | "yarn" | "deno" | "pnpm" | "bun">`,
+			get children() {
+				return [
+					createComponent(VarDeclaration, {
+						"const": true,
+						name: "userAgent",
+						type: "string",
+						initializer: code`process.env.npm_config_user_agent ?? ""; `
+					}),
+					createIntrinsic("hbr", {}),
+					createComponent(VarDeclaration, {
+						"const": true,
+						name: "execPath",
+						type: "string",
+						initializer: code`process.env.npm_execpath ?? ""; `
+					}),
+					createComponent(Spacing, {}),
+					createComponent(IfStatement, {
+						condition: code`userAgent.startsWith("yarn") || execPath.includes("yarn")`,
+						children: code`return "yarn"; `
+					}),
+					createComponent(ElseIfClause, {
+						condition: code`userAgent.startsWith("pnpm") || execPath.includes("pnpm")`,
+						children: code`return "pnpm"; `
+					}),
+					createComponent(ElseIfClause, {
+						condition: code`userAgent.startsWith("bun") || execPath.includes("bun") || typeof Bun !== "undefined" || process.versions.bun`,
+						children: code`return "bun"; `
+					}),
+					createComponent(ElseClause, { get children() {
+						return [
+							createComponent(VarDeclaration, {
+								"const": true,
+								name: "lockfilePath",
+								initializer: code`locateLockfile(options); `
+							}),
+							createComponent(Spacing, {}),
+							createComponent(IfStatement, {
+								condition: code`lockfilePath === "yarn.lock"`,
+								children: code`return "yarn"; `
+							}),
+							createComponent(ElseIfClause, {
+								condition: code`lockfilePath === "deno.lock" || lockfilePath === "deno.json" || lockfilePath === "deno.jsonc"`,
+								children: code`return "deno"; `
+							}),
+							createComponent(ElseIfClause, {
+								condition: code`lockfilePath === "pnpm-lock.yaml" || lockfilePath === "pnpm-workspace.yaml"`,
+								children: code`return "pnpm"; `
+							}),
+							createComponent(ElseIfClause, {
+								condition: code`lockfilePath === "bun.lock" || lockfilePath === "bun.lockb"`,
+								children: code`return "bun"; `
+							}),
+							createComponent(ElseClause, { get children() {
+								return [
+									createComponent(VarDeclaration, {
+										"const": true,
+										name: "packageJsonPath",
+										initializer: code`locatePackageJson(options); `
+									}),
+									createComponent(IfStatement, {
+										condition: code`packageJsonPath && existsSync(packageJsonPath)`,
+										get children() {
+											return [
+												createComponent(VarDeclaration, {
+													"const": true,
+													name: "packageJson",
+													initializer: code`JSON.parse(await readFile(packageJsonPath, "utf8")); `
+												}),
+												createComponent(IfStatement, {
+													condition: code`packageJson.devEngines?.packageManager?.name && typeof packageJson.devEngines.packageManager.name === "string" && ["npm", "yarn", "pnpm", "deno", "bun"].includes(packageJson.devEngines.packageManager.name)`,
+													children: code`return packageJson.devEngines.packageManager.name; `
+												}),
+												createComponent(Spacing, {}),
+												createComponent(VarDeclaration, {
+													"const": true,
+													name: "dependencies",
+													initializer: code`{
+                ...packageJson.dependencies,
+                ...packageJson.devDependencies,
+                ...packageJson.peerDependencies,
+                ...packageJson.optionalDependencies,
+              }; `
+												}),
+												createComponent(IfStatement, {
+													condition: code`Object.keys(dependencies).some(dep => dep === "yarn" || dep.startsWith("yarn@") || dep === "yarnpkg" || dep.startsWith("yarnpkg@"))`,
+													children: code`return "yarn"; `
+												}),
+												createComponent(ElseIfClause, {
+													condition: code`Object.keys(dependencies).some(dep => dep === "bun" || dep.startsWith("bun@"))`,
+													children: code`return "bun"; `
+												}),
+												createComponent(ElseIfClause, {
+													condition: code`Object.keys(dependencies).some(dep => dep === "pnpm" || dep.startsWith("pnpm@"))`,
+													children: code`return "pnpm"; `
+												}),
+												createComponent(ElseIfClause, {
+													condition: code`Object.keys(dependencies).some(dep => dep === "deno" || dep.startsWith("deno@"))`,
+													children: code`return "deno"; `
+												})
+											];
+										}
+									}),
+									createComponent(Spacing, {}),
+									code`return "npm"; `
+								];
+							} })
+						];
+					} })
+				];
+			}
+		})
+	];
+}
+/**
+* The `fetchNpmPackage` handler function declaration code for the Shell Shock project.
+*/
+function FetchNpmPackageFunctionDeclaration() {
+	return [
+		createComponent(InterfaceDeclaration, {
+			"export": true,
+			name: "NpmPackageMaintainer",
+			doc: "Represents a maintainer of an npm package.",
+			get children() {
+				return [
+					createComponent(InterfaceMember, {
+						name: "email",
+						type: "string",
+						doc: "The email of the npm package maintainer."
+					}),
+					createIntrinsic("hbr", {}),
+					createComponent(InterfaceMember, {
+						name: "username",
+						type: "string",
+						doc: "The username of the npm package maintainer."
+					})
+				];
+			}
+		}),
+		createComponent(Spacing, {}),
+		createComponent(InterfaceDeclaration, {
+			"export": true,
+			name: "NpmPackageLinks",
+			doc: "Represents the links of an npm package.",
+			get children() {
+				return [
+					createComponent(InterfaceMember, {
+						name: "homepage",
+						type: "string",
+						optional: true,
+						doc: "The homepage of the npm package."
+					}),
+					createIntrinsic("hbr", {}),
+					createComponent(InterfaceMember, {
+						name: "repository",
+						type: "string",
+						optional: true,
+						doc: "The repository of the npm package."
+					}),
+					createIntrinsic("hbr", {}),
+					createComponent(InterfaceMember, {
+						name: "bugs",
+						type: "string",
+						optional: true,
+						doc: "The bugs page of the npm package."
+					}),
+					createIntrinsic("hbr", {}),
+					createComponent(InterfaceMember, {
+						name: "npm",
+						type: "string",
+						optional: true,
+						doc: "The npm page of the npm package."
+					})
+				];
+			}
+		}),
+		createComponent(Spacing, {}),
+		createComponent(InterfaceDeclaration, {
+			"export": true,
+			name: "NpmPackage",
+			doc: "Represents an npm package.",
+			get children() {
+				return [
+					createComponent(InterfaceMember, {
+						name: "name",
+						type: "string",
+						doc: "The name of the npm package."
+					}),
+					createIntrinsic("hbr", {}),
+					createComponent(InterfaceMember, {
+						name: "date",
+						type: "Date",
+						doc: "The date when the npm package was last updated."
+					}),
+					createIntrinsic("hbr", {}),
+					createComponent(InterfaceMember, {
+						name: "version",
+						type: "string",
+						doc: "The version of the npm package."
+					}),
+					createIntrinsic("hbr", {}),
+					createComponent(InterfaceMember, {
+						name: "description",
+						type: "string",
+						optional: true,
+						doc: "The description of the npm package."
+					}),
+					createIntrinsic("hbr", {}),
+					createComponent(InterfaceMember, {
+						name: "keywords",
+						type: "string[]",
+						doc: "A list of keywords associated with the npm package."
+					}),
+					createIntrinsic("hbr", {}),
+					createComponent(InterfaceMember, {
+						name: "license",
+						type: "string",
+						optional: true,
+						doc: "The license of the npm package."
+					}),
+					createIntrinsic("hbr", {}),
+					createComponent(InterfaceMember, {
+						name: "maintainers",
+						type: "NpmPackageMaintainer[]",
+						doc: "The maintainers of the npm package."
+					}),
+					createIntrinsic("hbr", {}),
+					createComponent(InterfaceMember, {
+						name: "links",
+						type: "NpmPackageLinks",
+						doc: "The links of the npm package."
+					}),
+					createIntrinsic("hbr", {})
+				];
+			}
+		}),
+		createComponent(Spacing, {}),
+		createComponent(InterfaceDeclaration, {
+			"export": true,
+			name: "NpmPackageSearchResultItem",
+			doc: "Represents an npm package search result item.",
+			get children() {
+				return createComponent(InterfaceMember, {
+					name: "package",
+					type: "NpmPackage",
+					doc: "The npm package details."
+				});
+			}
+		}),
+		createComponent(Spacing, {}),
+		createComponent(InterfaceDeclaration, {
+			"export": true,
+			name: "NpmPackageSearchResult",
+			doc: "Represents an npm package search result.",
+			get children() {
+				return createComponent(InterfaceMember, {
+					name: "objects",
+					type: "NpmPackageSearchResultItem[]",
+					doc: "The list of npm package search result items."
+				});
+			}
+		}),
+		createComponent(Spacing, {}),
+		createComponent(TSDoc, {
+			heading: "Fetch details of an npm package.",
+			get children() {
+				return [
+					createComponent(TSDocRemarks, { children: `This function is used to fetch an npm package. It can be used in the CLI upgrade command to check if the application is using npm, yarn, or another package manager.` }),
+					createComponent(Spacing, {}),
+					createComponent(TSDocParam, {
+						name: "packageName",
+						children: `The name of the npm package to fetch.`
+					}),
+					createComponent(TSDocReturns, { children: `A promise that resolves to the npm package details or undefined if the package is not found.` })
+				];
+			}
+		}),
+		createComponent(FunctionDeclaration, {
+			"export": true,
+			async: true,
+			name: "fetchNpmPackage",
+			parameters: [{
+				name: "packageName",
+				type: "string"
+			}],
+			returnType: code`Promise<NpmPackage | undefined>`,
+			get children() {
+				return [
+					createComponent(VarDeclaration, {
+						"const": true,
+						name: "result",
+						initializer: code` await fetch(\`https://registry.npmjs.com/-/v1/search?text=\${packageName}&size=1\`).then(res => res.json()) as NpmPackageSearchResult; `
+					}),
+					createIntrinsic("hbr", {}),
+					createComponent(IfStatement, {
+						condition: code`result.objects && result.objects.length > 0 && result.objects[0].package && result.objects[0].package.name === packageName`,
+						children: code`return result.objects[0].package; `
+					}),
+					createComponent(ElseClause, { children: code`return undefined; ` })
+				];
+			}
+		})
+	];
+}
+/**
+* The `getLatest` handler function declaration code for the Shell Shock project.
+*/
+function GetLatestFunctionDeclaration() {
+	return [createComponent(TSDoc, {
+		heading: "Get the latest version of the application from the npm registry.",
+		get children() {
+			return [
+				createComponent(TSDocRemarks, { children: `This function is used to retrieve the latest version of the application from the npm registry. It can be used in the CLI upgrade command to check if there is a newer version of the application available.` }),
+				createComponent(Spacing, {}),
+				createComponent(TSDocParam, {
+					name: "packageName",
+					children: `The name of the npm package to fetch.`
+				}),
+				createComponent(TSDocReturns, { children: `A promise that resolves to the latest version of the specified npm package as a string.` })
+			];
+		}
+	}), createComponent(FunctionDeclaration, {
+		"export": true,
+		async: true,
+		name: "getLatest",
+		parameters: [{
+			name: "packageName",
+			type: "string"
+		}],
+		get children() {
+			return [
+				createComponent(VarDeclaration, {
+					"const": true,
+					name: "package",
+					initializer: code`await fetchNpmPackage(packageName); `
+				}),
+				createComponent(Spacing, {}),
+				code`return package?.version; `
+			];
+		}
+	})];
+}
+/**
+* The `install` handler function declaration code for the Shell Shock project.
+*/
+function InstallFunctionDeclaration() {
+	return [
+		createComponent(InterfaceDeclaration, {
+			"export": true,
+			name: "InstallOptions",
+			doc: "Options for the `install` handler function.",
+			get children() {
+				return [
+					createComponent(InterfaceMember, {
+						name: "stdout",
+						optional: true,
+						type: "(string) => void",
+						doc: "A callback function that is called with the stdout output of the command."
+					}),
+					createIntrinsic("hbr", {}),
+					createComponent(InterfaceMember, {
+						name: "stderr",
+						optional: true,
+						type: "(string) => void",
+						doc: "A callback function that is called with the stderr output of the command."
+					}),
+					createIntrinsic("hbr", {}),
+					createComponent(InterfaceMember, {
+						name: "color",
+						optional: true,
+						type: "boolean",
+						doc: "Whether to enable color output in the command. If not provided, color output will be enabled by default."
+					})
+				];
+			}
+		}),
+		createComponent(Spacing, {}),
+		createComponent(TSDoc, {
+			heading: "Install the application dependencies.",
+			get children() {
+				return [
+					createComponent(TSDocRemarks, { children: `This function is used to install the application dependencies. It can be used in the CLI upgrade command to ensure that all necessary dependencies are installed.` }),
+					createComponent(Spacing, {}),
+					createComponent(TSDocParam, {
+						name: "options",
+						children: `The options for the \`install\` function. Currently, there are no options available, but this parameter is included for future extensibility.`
+					}),
+					createComponent(TSDocReturns, { children: `A promise that resolves when the installation of dependencies is complete.` })
+				];
+			}
+		}),
+		createComponent(FunctionDeclaration, {
+			"export": true,
+			async: true,
+			name: "install",
+			parameters: [{
+				name: "options",
+				type: "InstallOptions",
+				default: "{}"
+			}],
+			returnType: "Promise<string>",
+			get children() {
+				return [
+					createComponent(VarDeclaration, {
+						"const": true,
+						name: "packageManager",
+						initializer: code`getPackageManager(); `
+					}),
+					createIntrinsic("hbr", {}),
+					createComponent(VarDeclaration, {
+						"let": true,
+						name: "output",
+						initializer: code`""; `
+					}),
+					createIntrinsic("hbr", {}),
+					code`try {
+            // await spawn(
+            //   \`\${packageManager}\${isWindows && packageManager !== "bun" ? ".cmd" : ""}\`,
+            //   ["install"],
+            //   {
+            //     stdout: (data: string) => {
+            //       options.stdout?.(data);
+            //       output += data;
+            //     },
+            //     stderr: (data: string) => {
+            //       options.stderr?.(data);
+            //     },
+            //   },
+            //   {
+            //     cwd: options.cwd ?? process.cwd(),
+            //     env: {
+            //       ...process.env,
+            //       ...(options.color !== false ? { FORCE_COLOR: true } : null),
+            //       // With spawn, pnpm install will fail with ERR_PNPM_PEER_DEP_ISSUES  Unmet peer dependencies.
+            //       // When pnpm install is run directly from the terminal, this error does not occur.
+            //       // When pnpm install is run from a simple spawn script, this error does not occur.
+            //       // The issue only seems to be when pnpm install is executed from npm-check-updates, but it's not clear what configuration or environmental factors are causing this.
+            //       // For now, turn off strict-peer-dependencies on pnpm auto-install.
+            //       // See: https://github.com/raineorshine/npm-check-updates/issues/1191
+            //       ...(packageManager === 'pnpm' ? { npm_config_strict_peer_dependencies: false } : null),
+            //     },
+            //   },
+            // );
+          } catch (err) {
+            console.error("Error executing install command:", err);
+            throw err;
+          }
+          `
+				];
+			}
+		})
+	];
+}
+/**
+* A built-in upgrade module for Shell Shock.
+*/
+function UpgradeBuiltin(props) {
+	const [{ children }, rest] = splitProps(props, ["children"]);
+	return createComponent(BuiltinFile, mergeProps({
+		id: "upgrade",
+		description: "A collection of application upgrade utility functions for Shell Shock."
+	}, rest, {
+		get imports() {
+			return defu(rest.imports ?? {}, {
+				"node:os": "os",
+				"node:path": ["join", "resolve"],
+				"node:fs": ["existsSync"],
+				"node:fs/promises": ["readFile", "writeFile"],
+				"node:process": "process"
+			});
+		},
+		get builtinImports() {
+			return defu(rest.builtinImports ?? {}, {
+				console: [
+					"error",
+					"verbose",
+					"writeLine"
+				],
+				env: ["paths", "isWindows"]
+			});
+		},
+		get children() {
+			return [
+				createComponent(VarDeclaration, {
+					"const": true,
+					name: "homePath",
+					type: "string",
+					initializer: code`os.homedir(); `
+				}),
+				createComponent(Spacing, {}),
+				createComponent(VarDeclaration, {
+					"const": true,
+					name: "tempPath",
+					type: "string",
+					initializer: code`os.tmpdir(); `
+				}),
+				createComponent(Spacing, {}),
+				createComponent(LocateLockfileFunctionDeclaration, {}),
+				createComponent(Spacing, {}),
+				createComponent(GetPackageManagerFunctionDeclaration, {}),
+				createComponent(Spacing, {}),
+				createComponent(FetchNpmPackageFunctionDeclaration, {}),
+				createComponent(Spacing, {}),
+				createComponent(GetLatestFunctionDeclaration, {}),
+				createComponent(Spacing, {}),
+				createComponent(InstallFunctionDeclaration, {}),
+				createComponent(Spacing, {}),
+				createComponent(Show, {
+					get when() {
+						return Boolean(children);
+					},
+					children
+				})
+			];
+		}
+	}));
+}
+
+//#endregion
+export { FetchNpmPackageFunctionDeclaration, GetLatestFunctionDeclaration, GetPackageManagerFunctionDeclaration, InstallFunctionDeclaration, LocateLockfileFunctionDeclaration, LocatePackageJsonFunctionDeclaration, UpgradeBuiltin };
+//# sourceMappingURL=upgrade-builtin.mjs.map