fork-version 4.1.9 → 5.0.0

package/dist/files/install-shield-ism.js

@@ -0,0 +1,59 @@
+import { basename } from "node:path";
+import { readFileSync, writeFileSync } from "node:fs";
+import * as cheerio from "cheerio/slim";
+//#region src/files/install-shield-ism.ts
+/**
+* An InstallShield ISM file can be either XML or binary, only the XML format is supported
+* by this file manager. The XML format typically contains a "Property" table with a
+* "ProductVersion" property.
+*
+* @example
+* ```xml
+* <?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+* <?xml-stylesheet type="text/xsl" href="is.xsl" ?>
+* <!DOCTYPE msi [
+*  ...
+* ]>
+* <msi version="2.0" xmlns:dt="urn:schemas-microsoft-com:datatypes">
+*
+* 	<table name="Property">
+* 		<row><td>ProductVersion</td><td>1.2.3</td><td/></row>
+* 	</table>
+*
+* </msi>
+* ```
+*/
+var InstallShieldISM = class {
+	#logger;
+	constructor(logger) {
+		this.#logger = logger;
+	}
+	#cheerioOptions = {
+		xmlMode: true,
+		xml: { decodeEntities: false }
+	};
+	read(filePath) {
+		const fileName = basename(filePath);
+		const fileContents = readFileSync(filePath, "utf8");
+		const version = cheerio.load(fileContents, this.#cheerioOptions)("msi > table[name=\"Property\"] > row > td:contains(\"ProductVersion\")").next().text().trim();
+		if (version) return {
+			name: fileName,
+			path: filePath,
+			version
+		};
+		this.#logger.warn(`[File Manager] Unable to determine InstallShield ISM version: ${fileName}`);
+	}
+	write(fileState, newVersion) {
+		const fileContents = readFileSync(fileState.path, "utf8");
+		const $ = cheerio.load(fileContents, this.#cheerioOptions);
+		const versionCell = $("msi > table[name=\"Property\"] > row > td:contains(\"ProductVersion\")").next();
+		if (versionCell.length > 0) versionCell.text(newVersion);
+		const updatedContent = $.xml().replaceAll("\"/>", "\" />");
+		writeFileSync(fileState.path, updatedContent, "utf8");
+	}
+	isSupportedFile(fileName) {
+		return fileName.endsWith(".ism");
+	}
+};
+//#endregion
+export { InstallShieldISM };

package/dist/files/json-package.js

@@ -0,0 +1,68 @@
+import { basename } from "node:path";
+import { readFileSync, writeFileSync } from "node:fs";
+import { applyEdits, modify, parse as parse$1 } from "jsonc-parser";
+//#region src/files/json-package.ts
+/**
+* A json package file should have a version property, like what can be seen
+* in the package.json file in the root of this project.
+*
+* @example
+* ```json
+* {
+*   "name": "fork-version",
+*   "version": "1.2.3",
+*   "private": true,
+* }
+* ```
+*/
+var JSONPackage = class {
+	#logger;
+	constructor(logger) {
+		this.#logger = logger;
+	}
+	/** Options for parsing JSON and JSONC files. */
+	#jsoncOptions = {
+		allowEmptyContent: false,
+		allowTrailingComma: true,
+		disallowComments: false
+	};
+	/**
+	* Sets a new string value at the given path in a JSON or JSONC string.
+	* @param jsonc the JSON or JSONC string (the contents of a file)
+	* @param jsonPath path to the value to set, as an array of segments
+	* @param newString string to set the value to
+	* @returns the JSON or JSONC string with the value set
+	*/
+	#setStringInJsonc(jsonc, jsonPath, newString) {
+		return applyEdits(jsonc, modify(jsonc, jsonPath, newString, {}));
+	}
+	read(filePath) {
+		const fileName = basename(filePath);
+		const fileContents = readFileSync(filePath, "utf8");
+		const parseErrors = [];
+		const parsedJson = parse$1(fileContents, parseErrors, this.#jsoncOptions);
+		if (parsedJson?.version && parseErrors.length === 0) return {
+			name: fileName,
+			path: filePath,
+			version: parsedJson.version,
+			isPrivate: typeof parsedJson?.private === "boolean" ? parsedJson.private : true
+		};
+		this.#logger.warn(`[File Manager] Unable to determine json version: ${fileName}`);
+	}
+	write(fileState, newVersion) {
+		let fileContents = readFileSync(fileState.path, "utf8");
+		const parsedJson = parse$1(fileContents, [], this.#jsoncOptions);
+		fileContents = this.#setStringInJsonc(fileContents, ["version"], newVersion);
+		if (parsedJson?.packages?.[""]) fileContents = this.#setStringInJsonc(fileContents, [
+			"packages",
+			"",
+			"version"
+		], newVersion);
+		writeFileSync(fileState.path, fileContents, "utf8");
+	}
+	isSupportedFile(fileName) {
+		return fileName.endsWith(".json") || fileName.endsWith(".jsonc");
+	}
+};
+//#endregion
+export { JSONPackage };

package/dist/files/ms-build-project.js

@@ -0,0 +1,59 @@
+import { basename } from "node:path";
+import { readFileSync, writeFileSync } from "node:fs";
+import * as cheerio from "cheerio/slim";
+//#region src/files/ms-build-project.ts
+/**
+* A ms-build file is an xml file with a version property under the Project > PropertyGroup node.
+*
+* [Microsoft Learn - MSBuild Reference](https://learn.microsoft.com/en-us/visualstudio/msbuild/msbuild?view=vs-2022)
+*
+* @example
+* ```xml
+* <Project Sdk="Microsoft.NET.Sdk">
+*   <PropertyGroup>
+*     <Version>1.2.3</Version>
+*   </PropertyGroup>
+* </Project>
+* ```
+*/
+var MSBuildProject = class {
+	#logger;
+	constructor(logger) {
+		this.#logger = logger;
+	}
+	#cheerioOptions = {
+		xmlMode: true,
+		xml: { decodeEntities: false }
+	};
+	read(filePath) {
+		const fileName = basename(filePath);
+		const fileContents = readFileSync(filePath, "utf8");
+		const version = cheerio.load(fileContents, this.#cheerioOptions)("Project > PropertyGroup > Version").text();
+		if (version) return {
+			name: fileName,
+			path: filePath,
+			version
+		};
+		this.#logger.warn(`[File Manager] Unable to determine ms-build version: ${fileName}`);
+	}
+	write(fileState, newVersion) {
+		const fileContents = readFileSync(fileState.path, "utf8");
+		const $ = cheerio.load(fileContents, this.#cheerioOptions);
+		$("Project > PropertyGroup > Version").text(newVersion);
+		const updatedContent = $.xml().replaceAll("\"/>", "\" />");
+		writeFileSync(fileState.path, updatedContent, "utf8");
+	}
+	isSupportedFile(fileName) {
+		return [
+			".csproj",
+			".dbproj",
+			".esproj",
+			".fsproj",
+			".props",
+			".vbproj",
+			".vcxproj"
+		].findIndex((ext) => fileName.endsWith(ext)) !== -1;
+	}
+};
+//#endregion
+export { MSBuildProject };

package/dist/files/plain-text.js

@@ -0,0 +1,35 @@
+import { basename } from "node:path";
+import { readFileSync, writeFileSync } from "node:fs";
+//#region src/files/plain-text.ts
+/**
+* A plain text file will have just the version as the content.
+*
+* @example
+* ```txt
+* 1.2.3
+* ```
+*/
+var PlainText = class {
+	#logger;
+	constructor(logger) {
+		this.#logger = logger;
+	}
+	read(filePath) {
+		const fileName = basename(filePath);
+		const fileContents = readFileSync(filePath, "utf8").trim();
+		if (fileContents) return {
+			name: fileName,
+			path: filePath,
+			version: fileContents
+		};
+		this.#logger.warn(`[File Manager] Unable to determine plain text version: ${fileName}`);
+	}
+	write(fileState, newVersion) {
+		writeFileSync(fileState.path, newVersion, "utf8");
+	}
+	isSupportedFile(fileName) {
+		return fileName.endsWith("version.txt");
+	}
+};
+//#endregion
+export { PlainText };

package/dist/files/yaml-package.js

@@ -0,0 +1,61 @@
+import { basename } from "node:path";
+import { readFileSync, writeFileSync } from "node:fs";
+import { parse as parse$1, parseDocument } from "yaml";
+//#region src/files/yaml-package.ts
+/**
+* A yaml package file should have a version property on the top level, like what can be seen
+* in [this example project](https://github.com/eglavin/wordionary/blob/01ae9b9d604cecdf9d320ed6028a727be5e5349e/pubspec.yaml#L19C1-L19C17).
+*
+* @example
+* ```yaml
+* name: wordionary
+* description: "A Flutter project."
+* publish_to: 'none'
+* version: 1.2.3
+* ```
+*/
+var YAMLPackage = class {
+	#logger;
+	constructor(logger) {
+		this.#logger = logger;
+	}
+	/**
+	* If the version is returned with a "+" symbol in the value then the version might be from a
+	* flutter `pubspec.yaml` file, if so we want to retain the input builderNumber by splitting it
+	* and joining it again later.
+	*/
+	#handleBuildNumber(fileVersion) {
+		const [version, builderNumber] = fileVersion.split("+");
+		if (/^\d+$/.test(builderNumber)) return {
+			version,
+			builderNumber
+		};
+		return { version: fileVersion };
+	}
+	read(filePath) {
+		const fileName = basename(filePath);
+		const fileVersion = parse$1(readFileSync(filePath, "utf-8"))?.version;
+		if (fileVersion) {
+			const parsedVersion = this.#handleBuildNumber(fileVersion);
+			return {
+				name: fileName,
+				path: filePath,
+				version: parsedVersion.version || "",
+				builderNumber: parsedVersion.builderNumber ?? void 0
+			};
+		}
+		this.#logger.warn(`[File Manager] Unable to determine yaml version: ${fileName}`);
+	}
+	write(fileState, newVersion) {
+		const yamlDocument = parseDocument(readFileSync(fileState.path, "utf8"));
+		let newFileVersion = newVersion;
+		if (fileState.builderNumber !== void 0) newFileVersion += `+${fileState.builderNumber}`;
+		yamlDocument.set("version", newFileVersion);
+		writeFileSync(fileState.path, yamlDocument.toString(), "utf8");
+	}
+	isSupportedFile(fileName) {
+		return fileName.endsWith(".yaml") || fileName.endsWith(".yml");
+	}
+};
+//#endregion
+export { YAMLPackage };