obsidian-plugin-config 1.0.2

package/test-plugin/scripts/release.ts

@@ -0,0 +1,97 @@
+import {
+  writeFile,
+  stat
+} from "fs/promises";
+import { execSync } from "child_process";
+import dedent from "dedent";
+import {
+  askQuestion,
+  askConfirmation,
+  createReadlineInterface
+} from "./utils.ts";
+
+const rl = createReadlineInterface();
+
+const body = ".github/workflows/release-body.md";
+
+async function checkOrCreateFile(filename: string): Promise<void> {
+  try {
+    await stat(filename);
+  } catch {
+    console.log(`Creating ${filename} because it doesn't exist. Avoid deleting it.`);
+    await writeFile(filename, "");
+  }
+}
+
+async function createReleaseNotesFile(tagMessage: string, tag: string): Promise<void> {
+  await writeFile(body, tagMessage);
+  console.log(`Release notes for tag ${tag} have been written to release-body.md`);
+}
+
+async function handleExistingTag(tag: string): Promise<boolean> {
+  const confirmed = await askConfirmation(`Tag ${tag} already exists. Do you want to replace it?`, rl);
+
+  if (!confirmed) {
+    console.log("Operation aborted");
+    return false;
+  }
+
+  execSync(`git tag -d ${tag}`);
+  execSync(`git push origin :refs/tags/${tag}`);
+  console.log(`Deleted existing tag ${tag} locally and remotely.`);
+  return true;
+}
+
+async function createTag(): Promise<void> {
+  const currentVersion = process.env.npm_package_version;
+  const tag = `${currentVersion}`;
+
+  await checkOrCreateFile(body);
+  const exists = execSync("git ls-remote --tags origin").toString().includes(`refs/tags/${tag}`);
+
+  if (exists && !(await handleExistingTag(tag))) {
+    rl.close();
+    return;
+  }
+  await doCommit(currentVersion, tag);
+}
+
+
+
+async function doCommit(currentVersion: string | undefined, tag: string): Promise<void> {
+  rl.question(`Enter the commit message for version ${currentVersion}: `, async (message) => {
+    doNextSteps(message, tag);
+    rl.close();
+  });
+}
+
+async function doNextSteps(message: string, tag: string): Promise<void> {
+  const messages = message.split("\\n");
+  const toShow = message.replace(/\\n/g, "\n");
+  await createReleaseNotesFile(toShow, tag);
+  const tagMessage = messages.map(m => `-m "${m}"`).join(" ");
+
+  try {
+    execSync("git add -A");
+    execSync("git commit -m \"update tag description\"");
+    execSync("git push");
+  } catch (error: any) {
+    console.error("Error:", error.message);
+  }
+  try {
+    execSync(`git tag -a ${tag} ${tagMessage}`);
+  } catch {
+    execSync(`git tag -d ${tag}`);
+    execSync(`git push origin :refs/tags/${tag}`);
+    console.log("Fixed");
+    execSync(`git tag -a ${tag} ${tagMessage}`);
+  }
+  execSync(`git push origin ${tag}`);
+  console.log(`Release ${tag} pushed to repo.`);
+  console.log(dedent`
+        with message:
+            ${toShow}
+    `);
+}
+
+createTag().catch(console.error);

package/test-plugin/scripts/update-version.ts

@@ -0,0 +1,102 @@
+import { readFile, writeFile } from "fs/promises";
+import dedent from "dedent";
+import { inc, valid } from "semver";
+import { askQuestion, createReadlineInterface, gitExec } from "./utils.ts";
+
+const rl = createReadlineInterface();
+
+async function getTargetVersion(currentVersion: string): Promise<string> {
+  const updateType = await askQuestion(dedent`
+        Current version: ${currentVersion}
+        Kind of update:
+            patch(1.0.1) -> type 1 or p
+            minor(1.1.0) -> type 2 or min
+            major(2.0.0) -> type 3 or maj
+            or version number (e.g. 2.0.0)
+        Enter choice: `, rl);
+
+  switch (updateType.trim()) {
+    case "p":
+    case "1":
+      return inc(currentVersion, "patch") || "";
+    case "min":
+    case "2":
+      return inc(currentVersion, "minor") || "";
+    case "maj":
+    case "3":
+      return inc(currentVersion, "major") || "";
+    default:
+      return valid(updateType.trim()) || "";
+  }
+}
+
+async function updateJsonFile(filename: string, updateFn: (json: any) => void): Promise<void> {
+  try {
+    const content = JSON.parse(await readFile(filename, "utf8"));
+    updateFn(content);
+    await writeFile(filename, JSON.stringify(content, null, "\t"));
+  } catch (error) {
+    console.error(`Error updating ${filename}:`, error instanceof Error ? error.message : String(error));
+    throw error;
+  }
+}
+
+async function updateManifestVersions(targetVersion: string): Promise<void> {
+  try {
+    const manifest = JSON.parse(await readFile("manifest.json", "utf8"));
+    const { minAppVersion } = manifest;
+
+    await Promise.all([
+      updateJsonFile("manifest.json", json => json.version = targetVersion),
+      updateJsonFile("versions.json", json => json[targetVersion] = minAppVersion),
+      updateJsonFile("package.json", json => json.version = targetVersion),
+      // updateJsonFile("package-lock.json", json => json.version = targetVersion)
+    ]);
+  } catch (error) {
+    console.error("Error updating manifest versions:", error instanceof Error ? error.message : String(error));
+    throw error;
+  }
+}
+
+async function updateVersion(): Promise<void> {
+  try {
+    const currentVersion = process.env.npm_package_version || "1.0.0";
+    const targetVersion = await getTargetVersion(currentVersion);
+
+    if (!targetVersion) {
+      console.log("Invalid version");
+      return;
+    }
+
+    try {
+      // Update all files first
+      await updateManifestVersions(targetVersion);
+      console.log(`Files updated to version ${targetVersion}`);
+      
+      // Add files to git
+      gitExec("git add manifest.json package.json versions.json");
+      gitExec(`git commit -m "Updated to version ${targetVersion}"`);
+      console.log("Changes committed");
+    } catch (error) {
+      console.error("Error during update or commit:", error instanceof Error ? error.message : String(error));
+      console.log("Operation failed.");
+      return;
+    }
+
+    try {
+      gitExec("git push");
+      console.log(`Version successfully updated to ${targetVersion} and pushed.`);
+    } catch (pushError) {
+      console.error("Failed to push version update:", pushError instanceof Error ? pushError.message : String(pushError));
+    }
+  } catch (error) {
+    console.error("Error:", error instanceof Error ? error.message : String(error));
+  } finally {
+    rl.close();
+  }
+}
+
+updateVersion().catch(console.error).finally(() => {
+  console.log("Exiting...");
+  process.exit();
+});

package/test-plugin/scripts/utils.ts

@@ -0,0 +1,117 @@
+import {
+  access,
+  mkdir,
+  copyFile,
+  rm
+} from "fs/promises";
+import path from "path";
+import * as readline from "readline";
+import { execSync } from "child_process";
+
+export function createReadlineInterface(): readline.Interface {
+  return readline.createInterface({
+    input: process.stdin as NodeJS.ReadableStream,
+    output: process.stdout as NodeJS.WritableStream,
+  });
+}
+
+export const askQuestion = async (question: string, rl: readline.Interface): Promise<string> => {
+  try {
+    return await new Promise(resolve => rl.question(question, input => resolve(input.trim())));
+  } catch (error) {
+    console.error("Error asking question:", error);
+    throw error;
+  }
+};
+
+/**
+ * Ask a yes/no confirmation question with standardized logic
+ * Accepts: y, yes, Y, YES, or empty (default to yes)
+ * Rejects: n, no, N, NO
+ * Invalid input defaults to no for safety
+ */
+export const askConfirmation = async (question: string, rl: readline.Interface): Promise<boolean> => {
+  const answer = await askQuestion(`${question} [Y/n]: `, rl);
+  const response = answer.toLowerCase();
+
+  // Accept: y, yes, Y, YES, or empty (default to yes)
+  // Reject: n, no, N, NO
+  const isYes = response === '' || response === 'y' || response === 'yes';
+  const isNo = response === 'n' || response === 'no';
+
+  if (isNo) {
+    return false;
+  } else if (isYes) {
+    return true;
+  } else {
+    console.log("Please answer Y (yes) or n (no). Defaulting to no for safety.");
+    return false;
+  }
+};
+
+export const cleanInput = (inputStr: string): string => {
+  if (!inputStr) return "";
+  return inputStr.trim().replace(/["`]/g, "'").replace(/\r\n/g, "\n");
+};
+
+export const isValidPath = async (pathToCheck: string): Promise<boolean> => {
+  if (!pathToCheck) return false;
+
+  try {
+    // Using async fs.access is preferred over synchronous existsSync
+    // as it doesn't block the main thread/event loop
+    await access(pathToCheck.trim());
+    return true;
+  } catch {
+    return false;
+  }
+};
+
+export async function copyFilesToTargetDir(buildPath: string): Promise<void> {
+  const manifestDest = path.join(buildPath, "manifest.json");
+  const cssDest = path.join(buildPath, "styles.css");
+  const folderToRemove = path.join(buildPath, "_.._");
+
+  try {
+    await mkdir(buildPath);
+  } catch (error: any) {
+    if (error.code !== "EEXIST") {
+      console.error(`Error creating directory: ${error.message}`);
+    }
+  }
+
+  // Copy manifest
+  try {
+    await copyFile("./manifest.json", manifestDest);
+  } catch (error: any) {
+    console.error(`Error copying manifest: ${error.message}`);
+  }
+
+  // Copy CSS
+  try {
+    // First check if CSS exists in src/styles.css
+    if (await isValidPath("./src/styles.css")) {
+      await copyFile("./src/styles.css", cssDest);
+    }
+    // Otherwise, check if it exists in the root
+    else if (await isValidPath("./styles.css")) {
+      await copyFile("./styles.css", cssDest);
+      if (await isValidPath(folderToRemove)) {
+        await rm(folderToRemove, { recursive: true });
+      }
+    } else {
+      return;
+    }
+  } catch (error: any) {
+    console.error(`Error copying CSS: ${error.message}`);
+  }
+}
+
+export function gitExec(command: string): void {
+  try {
+    execSync(command, { stdio: "inherit" });
+  } catch (error: any) {
+    console.error(`Error executing '${command}':`, error.message);
+    throw error;
+  }
+}

package/test-plugin/src/main.ts

@@ -0,0 +1,11 @@
+import { Plugin } from 'obsidian';
+
+export default class TestPlugin extends Plugin {
+  async onload() {
+    console.log('Test Plugin loaded');
+  }
+
+  onunload() {
+    console.log('Test Plugin unloaded');
+  }
+}