update

Author: hediet

.github/workflows/deploy.yml

@@ -21,7 +21,7 @@ jobs:
       - run: yarn run-script build-and-publish
         env:
           GH_TOKEN: ${{ secrets.GH_TOKEN }}
-          VSCE_TOKEN_DISABLED: ${{ secrets.MARKETPLACE_TOKEN }}
+          VSCE_PAT: ${{ secrets.MARKETPLACE_TOKEN }}
           GITHUB_RUN_NUMBER: ${{ github.run_number }}
       - name: Upload Artifacts
         uses: actions/upload-artifact@v4

package.json

@@ -4,6 +4,7 @@
 	"displayName": "Draw.io Integration",
 	"description": "This unofficial extension integrates Draw.io into VS Code.",
 	"version": "1.7.0",
+	"preRelease": true,
 	"license": "GPL-3.0",
 	"publisher": "hediet",
 	"keywords": [

scripts/build-and-publish.ts

@@ -1,51 +1,62 @@
-import { getChangelog } from "./shared";
 import { readFile, writeFile } from "fs/promises";
-import { resolve } from "path";
+import { join, resolve } from "path";
 import { SemanticVersion } from "@hediet/semver";
 import { context } from "@actions/github";
 import { exec } from "@actions/exec";
+import { readFileSync } from "fs";
+import { Changelog } from "./changelog";
 
 const packageJsonPath = resolve(__dirname, "../package.json");
 
 export async function run(): Promise<void> {
 	const changeLog = getChangelog();
 	const version = changeLog.latestVersion;
 
-	const packageJson = await readJsonFile<{ version: string }>(packageJsonPath);
+	const packageJson = await readJsonFile<{ version: string; preRelease?: boolean }>(packageJsonPath);
 	const stableVersion = SemanticVersion.parse(packageJson.version);
 
 	if (version.kind !== 'released' || version.version.toString() !== stableVersion.toString()) {
 		throw new Error("Version in package.json does not match latest version in changelog.");
 	}
 
+	if (stableVersion.patch !== 0) {
+		throw new Error("Patch version must be 0.");
+	}
+
 	const gh = new GitHubClient();
 
+	const isPreRelease = !!packageJson.preRelease;
+
 	const stableTag = `v${stableVersion}`;
-	if (!await gh.tagExists(context.repo, stableTag)) {
-		try {
-			await publish('stable', stableVersion);
-		} catch (e) { }
-		//await gh.createTag(context.repo, stableTag, context.sha);
+	const stableGhTagExists = await gh.tagExists(context.repo, stableTag);
+	if (!isPreRelease && !stableGhTagExists) {
+		await buildAndPublish('stable', stableVersion);
+		await gh.createTag(context.repo, stableTag, context.sha);
 	} else {
-		console.log(`GitHub tag for stable version ${stableTag} exists, skipping publish.`);
+		if (stableGhTagExists) {
+			console.log(`GitHub tag for stable version ${stableTag} exists, skipping publish.`);
+		}
+		if (isPreRelease) {
+			console.log("Pre-release version detected, skipping stable");
+		}
 	}
 
 	const runNumber = process.env.GITHUB_RUN_NUMBER;
-	const preReleaseNumber = `${new Date().toISOString().replace(/[^0-9]/g, '')}0${runNumber}`;
+	const preReleaseNumber = `${formatDate(new Date())}0${Number(runNumber)}`;
 	const previewVersion = stableVersion.with({ patch: Number(preReleaseNumber) });
 
 	const previewTag = `v${previewVersion}`;
-	if (!await gh.tagExists(context.repo, previewTag)) {
-		try {
-			await publish('preRelease', previewVersion);
-		} catch (e) { }
-		//await gh.createTag(context.repo, previewTag, context.sha);
+
+	const previewGhTagExists = await gh.tagExists(context.repo, previewTag);
+	if (!previewGhTagExists) {
+		await buildAndPublish('preRelease', previewVersion);
+		await gh.createTag(context.repo, previewTag, context.sha);
 	} else {
 		console.log(`GitHub tag for preview version ${previewTag} exists, skipping publish.`);
 	}
 }
 
-async function publish(releaseType: 'stable' | 'preRelease', version: SemanticVersion) {
+async function buildAndPublish(releaseType: 'stable' | 'preRelease', version: SemanticVersion) {
 	console.log(`Publishing ${releaseType} version ${version}...`);
 
 	const packageJson = await readJsonFile<any>(packageJsonPath);
@@ -62,11 +73,24 @@ async function publish(releaseType: 'stable' | 'preRelease', version: SemanticVe
 		"vsce",
 		"publish",
 		"--pat",
-		process.env.VSCE_TOKEN!,
+		process.env.VSCE_PAT!,
 		...(releaseType === 'preRelease' ? ['--pre-release'] : [])]
 	);
 }
 
+
+function padN(num: number, n: number): string {
+	return num.toString().padStart(n, '0');
+}
+
+function formatDate(date: Date): string {
+	const year = date.getUTCFullYear();
+	const month = date.getUTCMonth() + 1;
+	const day = date.getUTCDate();
+
+	return `${year}${padN(month, 2)}${padN(day, 2)}`;
+}
+
 interface IRepo {
 	owner: string;
 	repo: string;
@@ -119,3 +143,11 @@ async function writeJsonFile(path: string, data: unknown): Promise<void> {
 	const content = JSON.stringify(data, null, '\t');
 	await writeFile(path, content, 'utf-8');
 }
+
+function readTextFileSync(fileName: string): string {
+	return readFileSync(fileName, { encoding: "utf-8" });
+}
+
+function getChangelog(): Changelog {
+	return new Changelog(readTextFileSync(join(__dirname, "../CHANGELOG.md")));
+}

scripts/changelog.ts

@@ -0,0 +1,58 @@
+import { SemanticVersion } from "@hediet/semver";
+
+export class Changelog {
+    private readonly regex = /## \[(.*?)\]([ \t]*-[ \t]*(.*))?/;
+    public get latestVersion(): {
+        kind: "released";
+        version: SemanticVersion;
+        releaseDate: Date | undefined;
+    } |
+    { kind: "unreleased"; } {
+        const result = this.regex.exec(this.src);
+        if (!result) {
+            throw new Error("Invalid changelog");
+        }
+        if (result[1].toLowerCase() === "unreleased") {
+            return { kind: "unreleased" };
+        }
+
+        let date: Date | undefined;
+        if (result[3]) {
+            date = new Date(result[3].trim());
+        }
+        return {
+            kind: "released",
+            version: SemanticVersion.parse(result[1]),
+            releaseDate: date,
+        };
+    }
+
+    constructor(private src: string) { }
+
+    public setLatestVersion(
+        newVersion: SemanticVersion,
+        releaseDate: Date | undefined
+    ): void {
+        let dateStr = "";
+        if (releaseDate !== undefined) {
+            const year = releaseDate.getUTCFullYear();
+            const day = releaseDate.getUTCDate();
+            const month = releaseDate.getUTCMonth() + 1;
+            dateStr = ` - ${pad(year, 4)}-${pad(month, 2)}-${pad(day, 2)}`;
+        }
+        this.src = this.src.replace(
+            this.regex,
+            `## [${newVersion.toString()}]${dateStr}`
+        );
+    }
+
+    public toString(): string {
+        return this.src;
+    }
+}
+
+function pad(num: number, size: number): string {
+    let s = num + "";
+    while (s.length < size) s = "0" + s;
+    return s;
+}