@shell-shock/plugin-upgrade 0.1.4 → 0.1.6

package/dist/components/upgrade-builtin.mjs

@@ -1,28 +1,39 @@
-import { createComponent, createIntrinsic, mergeProps } from "@alloy-js/core/jsx-runtime";
+import { createComponent, createIntrinsic, memo, mergeProps } from "@alloy-js/core/jsx-runtime";
+import defu from "defu";
 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 { usePowerlines } from "@powerlines/plugin-alloy/core/contexts/context";
 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() {
+	const context = usePowerlines();
 	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."
-				});
+				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(InterfaceMember, {
+						name: "isDependencyRequired",
+						optional: true,
+						type: "boolean",
+						doc: "Whether to only locate a package.json file if it contains the application as a dependency. If set to `true`, the function will check if the located package.json file has the application listed as a dependency in its dependencies, devDependencies, peerDependencies, or optionalDependencies before returning its path. This can be useful in monorepo setups where multiple package.json files may exist, but only the one that includes the application as a dependency is relevant for upgrade purposes."
+					})
+				];
 			}
 		}),
 		createComponent(Spacing, {}),
@@ -66,11 +77,32 @@ function LocatePackageJsonFunctionDeclaration() {
 					}),
 					createComponent(Spacing, {}),
 					code`while (parentPath !== currentPath && currentPath !== homePath && currentPath !== tempPath) { `,
+					createComponent(VarDeclaration, {
+						"const": true,
+						name: "packageJsonPath",
+						initializer: code`join(currentPath, "package.json"); `
+					}),
 					createComponent(IfStatement, {
-						condition: code`existsSync(join(currentPath, "package.json"))`,
-						children: code`return join(currentPath, "package.json"); `
+						condition: code`existsSync(packageJsonPath)`,
+						get children() {
+							return [createComponent(IfStatement, {
+								condition: code`options.isDependencyRequired`,
+								get children() {
+									return [createComponent(VarDeclaration, {
+										"const": true,
+										name: "packageJson",
+										initializer: code`JSON.parse(await readFile(packageJsonPath, "utf8")); `
+									}), createComponent(IfStatement, {
+										get condition() {
+											return code`Object.keys(packageJson.dependencies || {}).concat(Object.keys(packageJson.devDependencies || {})).concat(Object.keys(packageJson.peerDependencies || {})).concat(Object.keys(packageJson.optionalDependencies || {})).some(dep => dep === "${context.packageJson.name}" || dep.startsWith("${context.packageJson.name}@"))`;
+										},
+										children: code`return packageJsonPath; `
+									})];
+								}
+							}), createComponent(ElseClause, { children: code`return packageJsonPath; ` })];
+						}
 					}),
-					createComponent(ElseClause, { children: code`currentPath = pathParent;
+					createComponent(ElseClause, { children: code`currentPath = parentPath;
           parentPath = resolve(currentPath, ".."); ` }),
 					code` }
 
@@ -115,7 +147,6 @@ function LocateLockfileFunctionDeclaration() {
 		}),
 		createComponent(FunctionDeclaration, {
 			"export": true,
-			async: true,
 			name: "locateLockfile",
 			parameters: [{
 				name: "options",
@@ -160,7 +191,7 @@ function LocateLockfileFunctionDeclaration() {
 						condition: code`lockfile`,
 						children: code`return lockfile; `
 					}),
-					createComponent(ElseClause, { children: code`currentPath = pathParent;
+					createComponent(ElseClause, { children: code`currentPath = parentPath;
           parentPath = resolve(currentPath, ".."); ` }),
 					code` }
 
@@ -175,6 +206,15 @@ function LocateLockfileFunctionDeclaration() {
 */
 function GetPackageManagerFunctionDeclaration() {
 	return [
+		code`declare global {
+        var Bun: any;
+        namespace NodeJS {
+          interface ProcessVersions {
+            bun?: string;
+          }
+        }
+      } `,
+		createComponent(Spacing, {}),
 		createComponent(TypeDeclaration, {
 			"export": true,
 			name: "GetPackageManagerOptions",
@@ -205,7 +245,7 @@ function GetPackageManagerFunctionDeclaration() {
 				type: "GetPackageManagerOptions",
 				default: "{}"
 			}],
-			returnType: code`Promise<"npm" | "yarn" | "deno" | "pnpm" | "bun">`,
+			returnType: code`"npm" | "yarn" | "deno" | "pnpm" | "bun"`,
 			get children() {
 				return [
 					createComponent(VarDeclaration, {
@@ -263,7 +303,7 @@ function GetPackageManagerFunctionDeclaration() {
 									createComponent(VarDeclaration, {
 										"const": true,
 										name: "packageJsonPath",
-										initializer: code`locatePackageJson(options); `
+										initializer: code`await locatePackageJson(options); `
 									}),
 									createComponent(IfStatement, {
 										condition: code`packageJsonPath && existsSync(packageJsonPath)`,
@@ -490,7 +530,7 @@ function FetchNpmPackageFunctionDeclaration() {
 				name: "packageName",
 				type: "string"
 			}],
-			returnType: code`Promise<NpmPackage | undefined>`,
+			returnType: code`NpmPackage | undefined`,
 			get children() {
 				return [
 					createComponent(VarDeclaration, {
@@ -510,9 +550,10 @@ function FetchNpmPackageFunctionDeclaration() {
 	];
 }
 /**
-* The `getLatest` handler function declaration code for the Shell Shock project.
+* The `getLatestVersion` handler function declaration code for the Shell Shock project.
 */
-function GetLatestFunctionDeclaration() {
+function GetLatestVersionFunctionDeclaration() {
+	const context = usePowerlines();
 	return [createComponent(TSDoc, {
 		heading: "Get the latest version of the application from the npm registry.",
 		get children() {
@@ -529,45 +570,124 @@ function GetLatestFunctionDeclaration() {
 	}), createComponent(FunctionDeclaration, {
 		"export": true,
 		async: true,
-		name: "getLatest",
+		name: "getLatestVersion",
+		get parameters() {
+			return [{
+				name: "packageName",
+				default: `"${context.packageJson.name}"`
+			}];
+		},
+		returnType: code`string | undefined`,
+		get children() {
+			return [
+				createComponent(VarDeclaration, {
+					"const": true,
+					name: "result",
+					initializer: code`await fetchNpmPackage(packageName); `
+				}),
+				createComponent(Spacing, {}),
+				code`return result?.version; `
+			];
+		}
+	})];
+}
+/**
+* The `upgrade` handler function declaration code for the Shell Shock project.
+*/
+function GetUpgradeCommandFunctionDeclaration() {
+	const context = usePowerlines();
+	return [createComponent(TSDoc, {
+		heading: "A function to get the upgrade command for a specific package manager.",
+		get children() {
+			return [
+				createComponent(TSDocRemarks, { children: `This function is used to get the appropriate upgrade command for a specific package manager. It can be used in the CLI upgrade command to determine which command to run based on the package manager being used by the application.` }),
+				createComponent(Spacing, {}),
+				createComponent(TSDocParam, {
+					name: "packageManager",
+					children: `The name of the package manager to get the upgrade command for. This should be one of "npm", "yarn", "pnpm", "deno", or "bun".`
+				}),
+				createComponent(TSDocParam, {
+					name: "cwd",
+					children: `The current working directory to use when determining the upgrade command. This can be used to locate the appropriate package.json and lockfile to determine how to run the upgrade command. If not provided, the process's current working directory will be used.`
+				}),
+				createComponent(TSDocReturns, { children: `An array of strings representing the command and its arguments to run in order to upgrade the application dependencies using the specified package manager.` })
+			];
+		}
+	}), createComponent(FunctionDeclaration, {
+		"export": true,
+		async: true,
+		name: "getUpgradeCommand",
 		parameters: [{
-			name: "packageName",
+			name: "packageManager",
 			type: "string"
+		}, {
+			name: "cwd",
+			type: "string",
+			default: "process.cwd()"
 		}],
+		returnType: "string[]",
 		get children() {
 			return [
 				createComponent(VarDeclaration, {
 					"const": true,
-					name: "package",
-					initializer: code`await fetchNpmPackage(packageName); `
+					name: "version",
+					get initializer() {
+						return code`(await getLatestVersion("${context.packageJson.name}")) || "latest"; `;
+					}
 				}),
 				createComponent(Spacing, {}),
-				code`return package?.version; `
+				createComponent(IfStatement, {
+					condition: code`packageManager === "yarn"`,
+					get children() {
+						return code`return ["upgrade", \`${context.packageJson.name}@\${version}\`]; `;
+					}
+				}),
+				createComponent(ElseIfClause, {
+					condition: code`packageManager === "pnpm"`,
+					get children() {
+						return code`return ["update", \`${context.packageJson.name}@\${version}\`]; `;
+					}
+				}),
+				createComponent(ElseIfClause, {
+					condition: code`packageManager === "deno"`,
+					get children() {
+						return code`return ["outdated", "--update", \`${context.packageJson.name}@\${version}\`]; `;
+					}
+				}),
+				createComponent(ElseIfClause, {
+					condition: code`packageManager === "bun"`,
+					get children() {
+						return code`return ["update", "--save",  \`${context.packageJson.name}@\${version}\`]; `;
+					}
+				}),
+				createComponent(ElseClause, { get children() {
+					return code`return ["update", "--save", "--bin-links", \`${context.packageJson.name}@\${version}\`]; `;
+				} })
 			];
 		}
 	})];
 }
 /**
-* The `install` handler function declaration code for the Shell Shock project.
+* The `upgrade` handler function declaration code for the Shell Shock project.
 */
-function InstallFunctionDeclaration() {
+function UpgradeFunctionDeclaration() {
 	return [
 		createComponent(InterfaceDeclaration, {
-			name: "InstallBaseOptions",
-			doc: "Options for the `install` handler function.",
+			name: "UpgradeBaseOptions",
+			doc: "Options for the `upgrade` handler function.",
 			get children() {
 				return [
 					createComponent(InterfaceMember, {
 						name: "stdout",
 						optional: true,
-						type: "(string) => void",
+						type: "(data: 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",
+						type: "(err: string) => void",
 						doc: "A callback function that is called with the stderr output of the command."
 					})
 				];
@@ -576,32 +696,32 @@ function InstallFunctionDeclaration() {
 		createComponent(Spacing, {}),
 		createComponent(TypeDeclaration, {
 			"export": true,
-			name: "InstallOptions",
-			doc: "Options for the `install` handler function.",
-			children: code`InstallBaseOptions & Parameters<typeof spawn>[2];`
+			name: "UpgradeOptions",
+			doc: "Options for the `upgrade` handler function.",
+			children: code`UpgradeBaseOptions & GetPackageManagerOptions & Parameters<typeof spawn>[2];`
 		}),
 		createComponent(Spacing, {}),
 		createComponent(TSDoc, {
-			heading: "Install the application dependencies.",
+			heading: "Upgrade 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(TSDocRemarks, { children: `This function is used to upgrade the application dependencies. It can be used in the CLI upgrade command to ensure that all necessary dependencies are up-to-date.` }),
 					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.`
+						children: `The options for the \`upgrade\` 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(TSDocReturns, { children: `A promise that resolves when the upgrade of dependencies is complete.` })
 				];
 			}
 		}),
 		createComponent(FunctionDeclaration, {
 			"export": true,
 			async: true,
-			name: "install",
+			name: "upgrade",
 			parameters: [{
 				name: "options",
-				type: "InstallOptions",
+				type: "UpgradeOptions",
 				default: "{}"
 			}],
 			get children() {
@@ -609,9 +729,15 @@ function InstallFunctionDeclaration() {
 					createComponent(VarDeclaration, {
 						"const": true,
 						name: "packageManager",
-						initializer: code`getPackageManager(); `
+						initializer: code`await getPackageManager(options); `
 					}),
 					createComponent(Spacing, {}),
+					createComponent(VarDeclaration, {
+						"const": true,
+						name: "args",
+						initializer: code`await getUpgradeCommand(packageManager, options.cwd); `
+					}),
+					createIntrinsic("hbr", {}),
 					createComponent(VarDeclaration, {
 						"let": true,
 						name: "output",
@@ -620,9 +746,9 @@ function InstallFunctionDeclaration() {
 					createIntrinsic("hbr", {}),
 					code`await spawn(
           \`\${packageManager}\${isWindows && packageManager !== "bun" ? ".cmd" : ""}\`,
-          ["install"],
+          [args.join(" ")],
           {
-            ...options
+            ...options,
             env: {
               ...options.env,
               ...(packageManager === "pnpm" ? { npm_config_strict_peer_dependencies: false } : null),
@@ -642,6 +768,240 @@ function InstallFunctionDeclaration() {
 	];
 }
 /**
+* The `updateVersionCheckFile` handler function declaration code for the Shell Shock project.
+*/
+function UpdateVersionCheckFileFunctionDeclaration() {
+	return [createComponent(TSDoc, {
+		heading: "A helper function that updates the version check file.",
+		get children() {
+			return [
+				createComponent(TSDocRemarks, { children: `This function is used to update the version check file with the current timestamp. It can be used in the CLI upgrade command to record the last time a check for updates was performed. The function writes a "version-check.json" file in the data directory, which contains a timestamp of the last check for updates.` }),
+				createComponent(Spacing, {}),
+				createComponent(TSDocReturns, { children: `A promise that resolves to a boolean indicating whether a check for updates is required.` })
+			];
+		}
+	}), createComponent(FunctionDeclaration, {
+		"export": true,
+		async: true,
+		name: "updateVersionCheckFile",
+		returnType: "void",
+		get children() {
+			return [createComponent(IfStatement, {
+				condition: code`!existsSync(paths.data)`,
+				children: code`await mkdir(paths.data, { recursive: true }); `
+			}), code`await writeFile(join(paths.data, "version-check.json"), JSON.stringify({ timestamp: new Date().getTime() }), "utf8"); `];
+		}
+	})];
+}
+/**
+* The `isCheckForUpdatesRequired` handler function declaration code for the Shell Shock project.
+*/
+function IsCheckForUpdatesRequiredFunctionDeclaration() {
+	const context = usePowerlines();
+	return [createComponent(TSDoc, {
+		heading: "A helper function that verifies if a check for updates is required.",
+		get children() {
+			return [
+				createComponent(TSDocRemarks, { children: `This function is used to determine if a check for updates is required based on the last time a check was performed. It can be used in the CLI upgrade command to avoid unnecessary checks for updates if one was recently performed. The function checks for the existence of a "version-check.json" file in the data directory, which contains a timestamp of the last check for updates. If the file does not exist or if the timestamp is older than a specified stale time, the function will return true, indicating that a check for updates is required. Otherwise, it will return false.` }),
+				createComponent(Spacing, {}),
+				createComponent(TSDocReturns, { children: `A promise that resolves to a boolean indicating whether a check for updates is required.` })
+			];
+		}
+	}), createComponent(FunctionDeclaration, {
+		"export": true,
+		async: true,
+		name: "isCheckForUpdatesRequired",
+		get children() {
+			return [
+				createComponent(IfStatement, {
+					condition: code`!isInteractive || isCI || env.SKIP_VERSION_CHECK`,
+					children: code`return false; `
+				}),
+				createComponent(Spacing, {}),
+				createComponent(VarDeclaration, {
+					"const": true,
+					name: "filePath",
+					initializer: code`join(paths.data, "version-check.json"); `
+				}),
+				createComponent(IfStatement, {
+					condition: code`existsSync(filePath)`,
+					get children() {
+						return [
+							createComponent(VarDeclaration, {
+								"const": true,
+								name: "file",
+								type: "{ timestamp: number; }",
+								initializer: code` JSON.parse(await readFile(filePath, "utf8")); `
+							}),
+							createComponent(IfStatement, {
+								condition: code`!file.timestamp`,
+								children: code`await updateVersionCheckFile();
+            return true; `
+							}),
+							createComponent(ElseIfClause, {
+								get condition() {
+									return code`new Date().getTime() - file.timestamp < ${context.config.upgrade.staleTime}`;
+								},
+								children: code`return false; `
+							})
+						];
+					}
+				}),
+				createComponent(ElseClause, { children: code`await updateVersionCheckFile();
+          return true; ` })
+			];
+		}
+	})];
+}
+/**
+* The `checkForUpdates` handler function declaration code for the Shell Shock project.
+*/
+function CheckForUpdatesFunctionDeclaration() {
+	const context = usePowerlines();
+	return [
+		createComponent(InterfaceDeclaration, {
+			"export": true,
+			name: "CheckForUpdatesOptions",
+			"extends": "GetPackageManagerOptions",
+			doc: "Options for the `checkForUpdates` handler function.",
+			get children() {
+				return createComponent(InterfaceMember, {
+					name: "force",
+					optional: true,
+					type: "boolean",
+					doc: "Whether to force a check for updates regardless of the last check timestamp. If set to `true`, the function will bypass the timestamp check and perform a check for updates, updating the timestamp in the process. This can be useful if you want to ensure that a check for updates is performed even if one was recently done, such as when the user explicitly requests it or when certain conditions are met that warrant an immediate check."
+				});
+			}
+		}),
+		createComponent(Spacing, {}),
+		createComponent(InterfaceDeclaration, {
+			name: "CheckForUpdatesBaseResult",
+			get children() {
+				return createComponent(InterfaceMember, {
+					name: "isError",
+					type: "boolean",
+					optional: true,
+					doc: "Indicates whether an error occurred while checking for updates."
+				});
+			}
+		}),
+		createComponent(Spacing, {}),
+		createComponent(InterfaceDeclaration, {
+			name: "CheckForUpdatesSuccessResult",
+			"extends": "CheckForUpdatesBaseResult",
+			get children() {
+				return [
+					createComponent(InterfaceMember, {
+						name: "latestVersion",
+						type: "string",
+						doc: "The latest version of the application dependencies."
+					}),
+					createIntrinsic("hbr", {}),
+					createComponent(InterfaceMember, {
+						name: "currentVersion",
+						type: "string",
+						doc: "The current version of the application dependencies."
+					}),
+					createIntrinsic("hbr", {}),
+					createComponent(InterfaceMember, {
+						name: "isUpToDate",
+						type: "boolean",
+						doc: "Indicates whether the application dependencies are up-to-date."
+					}),
+					createIntrinsic("hbr", {}),
+					createComponent(InterfaceMember, {
+						name: "package",
+						type: "NpmPackage",
+						optional: true,
+						doc: "The npm package that was checked for updates."
+					})
+				];
+			}
+		}),
+		createComponent(Spacing, {}),
+		createComponent(InterfaceDeclaration, {
+			name: "CheckForUpdatesErrorResult",
+			"extends": "CheckForUpdatesBaseResult",
+			get children() {
+				return createComponent(InterfaceMember, {
+					name: "error",
+					type: "Error",
+					doc: "The error that occurred while checking for updates."
+				});
+			}
+		}),
+		createComponent(Spacing, {}),
+		createComponent(TypeDeclaration, {
+			"export": true,
+			name: "CheckForUpdatesResult",
+			doc: "The result for the `checkForUpdates` handler function.",
+			children: code`CheckForUpdatesSuccessResult | CheckForUpdatesErrorResult;`
+		}),
+		createComponent(Spacing, {}),
+		createComponent(TSDoc, {
+			heading: "Check for updates to the application dependencies.",
+			get children() {
+				return [
+					createComponent(TSDocRemarks, { children: `This function is used to check for updates to the application dependencies. It can be used in the CLI upgrade command to ensure that all necessary dependencies are up-to-date.` }),
+					createComponent(Spacing, {}),
+					createComponent(TSDocParam, {
+						name: "options",
+						children: `The options for the \`checkForUpdates\` function. Currently, there are no options available, but this parameter is included for future extensibility.`
+					}),
+					createComponent(TSDocReturns, { children: `A promise that resolves when the check for updates is complete or undefined if the check was not performed.` })
+				];
+			}
+		}),
+		createComponent(FunctionDeclaration, {
+			"export": true,
+			async: true,
+			name: "checkForUpdates",
+			parameters: [{
+				name: "options",
+				type: "CheckForUpdatesOptions",
+				default: "{}"
+			}],
+			returnType: "CheckForUpdatesResult",
+			get children() {
+				return [
+					createComponent(IfStatement, {
+						condition: code`!options.force && !(await isCheckForUpdatesRequired())`,
+						get children() {
+							return code`return {
+            latestVersion: "${context.packageJson.version}",
+            currentVersion: "${context.packageJson.version}",
+            isUpToDate: true,
+            isError: false,
+          }; `;
+						}
+					}),
+					createComponent(Spacing, {}),
+					code`try { `,
+					createComponent(VarDeclaration, {
+						"const": true,
+						name: "pkg",
+						get initializer() {
+							return code`await fetchNpmPackage("${context.packageJson.name}"); `;
+						}
+					}),
+					createComponent(Spacing, {}),
+					memo(() => code`
+          return {
+            latestVersion: pkg?.version || "${context.packageJson.version}",
+            currentVersion: "${context.packageJson.version}",
+            isUpToDate: pkg ? "${context.packageJson.version}" === pkg.version : true,
+            package: pkg,
+            isError: false,
+          };
+        } catch (err) {
+          return { isError: true, error: err instanceof Error ? err : new Error(String(err)) };
+        } `)
+				];
+			}
+		})
+	];
+}
+/**
 * A built-in upgrade module for Shell Shock.
 */
 function UpgradeBuiltin(props) {
@@ -655,7 +1015,11 @@ function UpgradeBuiltin(props) {
 				"node:os": "os",
 				"node:path": ["join", "resolve"],
 				"node:fs": ["existsSync"],
-				"node:fs/promises": ["readFile", "writeFile"],
+				"node:fs/promises": [
+					"readFile",
+					"writeFile",
+					"mkdir"
+				],
 				"node:process": "process"
 			});
 		},
@@ -666,8 +1030,17 @@ function UpgradeBuiltin(props) {
 					"verbose",
 					"writeLine"
 				],
-				env: ["paths", "isWindows"],
-				utils: ["isColorSupported", "spawn"]
+				env: [
+					"paths",
+					"isWindows",
+					"isCI",
+					"env"
+				],
+				utils: [
+					"isColorSupported",
+					"isInteractive",
+					"spawn"
+				]
 			});
 		},
 		get children() {
@@ -686,15 +1059,25 @@ function UpgradeBuiltin(props) {
 					initializer: code`os.tmpdir(); `
 				}),
 				createComponent(Spacing, {}),
+				createComponent(LocatePackageJsonFunctionDeclaration, {}),
+				createComponent(Spacing, {}),
 				createComponent(LocateLockfileFunctionDeclaration, {}),
 				createComponent(Spacing, {}),
 				createComponent(GetPackageManagerFunctionDeclaration, {}),
 				createComponent(Spacing, {}),
 				createComponent(FetchNpmPackageFunctionDeclaration, {}),
 				createComponent(Spacing, {}),
-				createComponent(GetLatestFunctionDeclaration, {}),
+				createComponent(GetLatestVersionFunctionDeclaration, {}),
+				createComponent(Spacing, {}),
+				createComponent(GetUpgradeCommandFunctionDeclaration, {}),
+				createComponent(Spacing, {}),
+				createComponent(UpgradeFunctionDeclaration, {}),
+				createComponent(Spacing, {}),
+				createComponent(CheckForUpdatesFunctionDeclaration, {}),
+				createComponent(Spacing, {}),
+				createComponent(IsCheckForUpdatesRequiredFunctionDeclaration, {}),
 				createComponent(Spacing, {}),
-				createComponent(InstallFunctionDeclaration, {}),
+				createComponent(UpdateVersionCheckFileFunctionDeclaration, {}),
 				createComponent(Spacing, {}),
 				createComponent(Show, {
 					get when() {
@@ -708,5 +1091,5 @@ function UpgradeBuiltin(props) {
 }
 
 //#endregion
-export { FetchNpmPackageFunctionDeclaration, GetLatestFunctionDeclaration, GetPackageManagerFunctionDeclaration, InstallFunctionDeclaration, LocateLockfileFunctionDeclaration, LocatePackageJsonFunctionDeclaration, UpgradeBuiltin };
+export { CheckForUpdatesFunctionDeclaration, FetchNpmPackageFunctionDeclaration, GetLatestVersionFunctionDeclaration, GetPackageManagerFunctionDeclaration, GetUpgradeCommandFunctionDeclaration, IsCheckForUpdatesRequiredFunctionDeclaration, LocateLockfileFunctionDeclaration, LocatePackageJsonFunctionDeclaration, UpdateVersionCheckFileFunctionDeclaration, UpgradeBuiltin, UpgradeFunctionDeclaration };
 //# sourceMappingURL=upgrade-builtin.mjs.map