obsidian-plugin-config 1.0.2

package/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.js";
+
+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/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/src/index.ts

@@ -0,0 +1,6 @@
+// Auto-generated exports - DO NOT EDIT MANUALLY
+// Run 'npm run update-exports' to regenerate this file
+
+export * from './modals/index.js';
+export * from './tools/index.js';
+export * from './utils/index.js';

package/src/main_test.ts

@@ -0,0 +1,106 @@
+import {
+  App,
+  Plugin,
+  PluginSettingTab,
+  Setting,
+  Notice
+} from "obsidian";
+import { showConfirmModal } from "./modals/GenericConfirmModal.ts";
+import { showTestMessage, getRandomEmoji } from "obsidian-plugin-config/tools";
+
+interface MyPluginSettings {
+  mySetting: string;
+}
+
+const DEFAULT_SETTINGS: MyPluginSettings = {
+  mySetting: "default"
+};
+
+export default class MyPlugin extends Plugin {
+  settings: MyPluginSettings;
+
+  async onload(): Promise<void> {
+    console.log("loading plugin");
+    await this.loadSettings();
+
+    this.addCommand({
+      id: 'show-confirmation-modal',
+      name: 'Show Confirmation Modal (Local)',
+      callback: () => this.showConfirmationModal()
+    });
+
+    this.addCommand({
+      id: 'show-centralized-modal',
+      name: 'Show Confirmation Modal (Centralized)',
+      callback: () => this.showCentralizedModal()
+    });
+
+    this.addCommand({
+      id: 'test-tools',
+      name: 'Test Centralized Tools',
+      callback: () => {
+        const message = showTestMessage();
+        const emoji = getRandomEmoji();
+        new Notice(`${emoji} ${message}`);
+      }
+    });
+
+    this.addSettingTab(new SampleSettingTab(this.app, this));
+  }
+
+  private showConfirmationModal(): void {
+    showConfirmModal(this.app, {
+      title: "Confirmation requise",
+      message: "Êtes-vous sûr de vouloir effectuer cette action ? Cette action ne peut pas être annulée.",
+      confirmText: "Confirmer",
+      cancelText: "Annuler",
+      onConfirm: () => {
+        new Notice("Action confirmée !");
+        console.log("Action confirmée par l'utilisateur");
+      },
+      onCancel: () => {
+        new Notice("Action annulée.");
+        console.log("Action annulée par l'utilisateur");
+      }
+    });
+  }
+
+  private showCentralizedModal(): void {
+    showConfirmModal(this.app, {
+      title: "Centralized Modal Test",
+      message: "This modal comes from the centralized configuration! Pretty cool, right?",
+      confirmText: "Awesome!",
+      cancelText: "Not bad",
+      onConfirm: () => {
+        new Notice("Centralized modal confirmed! 🎉");
+      },
+      onCancel: () => {
+        new Notice("Centralized modal cancelled 😢");
+      }
+    });
+  }
+
+  async loadSettings(): Promise<void> {
+    this.settings = Object.assign({}, DEFAULT_SETTINGS, await this.loadData());
+  }
+
+  async saveSettings(): Promise<void> {
+    await this.saveData(this.settings);
+  }
+}
+
+class SampleSettingTab extends PluginSettingTab {
+  plugin: MyPlugin;
+
+  constructor(app: App, plugin: MyPlugin) {
+    super(app, plugin);
+    this.plugin = plugin;
+  }
+
+  display(): void {
+    const { containerEl } = this;
+    containerEl.empty();
+    new Setting(containerEl);
+  }
+}
+

package/src/modals/GenericConfirmModal.ts

@@ -0,0 +1,67 @@
+import { App, Modal } from "obsidian";
+import { capitalize } from "lodash";
+
+export interface ConfirmModalOptions {
+  title: string;
+  message: string;
+  confirmText?: string;
+  cancelText?: string;
+  onConfirm: () => void;
+  onCancel?: () => void;
+}
+
+export class GenericConfirmModal extends Modal {
+  private options: ConfirmModalOptions;
+
+  constructor(app: App, options: ConfirmModalOptions) {
+    super(app);
+    this.options = options;
+  }
+
+  onOpen(): void {
+    const { contentEl } = this;
+    contentEl.empty();
+
+    // Title (using lodash capitalize for demo)
+    contentEl.createEl("h2", { text: capitalize(this.options.title) });
+
+    // Message
+    contentEl.createEl("p", { text: this.options.message });
+
+    // Buttons container
+    const buttonContainer = contentEl.createDiv("modal-button-container");
+
+    // Cancel button
+    const cancelBtn = buttonContainer.createEl("button", {
+      text: this.options.cancelText || "Cancel",
+      cls: "mod-cta"
+    });
+    cancelBtn.addEventListener("click", () => {
+      this.options.onCancel?.();
+      this.close();
+    });
+
+    // Confirm button
+    const confirmBtn = buttonContainer.createEl("button", {
+      text: this.options.confirmText || "Confirm",
+      cls: "mod-cta mod-warning"
+    });
+    confirmBtn.addEventListener("click", () => {
+      this.options.onConfirm();
+      this.close();
+    });
+
+    // Focus on confirm button
+    confirmBtn.focus();
+  }
+
+  onClose(): void {
+    const { contentEl } = this;
+    contentEl.empty();
+  }
+}
+
+// Utility function for quick usage
+export function showConfirmModal(app: App, options: ConfirmModalOptions): void {
+  new GenericConfirmModal(app, options).open();
+}

package/src/modals/index.ts

@@ -0,0 +1,3 @@
+// Export all modals for easy importing
+export { GenericConfirmModal, showConfirmModal } from './GenericConfirmModal.js';
+export type { ConfirmModalOptions } from './GenericConfirmModal.js';

package/src/test-centralized-utils.ts

@@ -0,0 +1,23 @@
+// Simple test file to verify centralized utils work
+import { NoticeHelper } from "obsidian-plugin-config/utils";
+
+export function testCentralizedUtils(): void {
+    console.log("🧪 Testing centralized utils...");
+    
+    // Test different notice types
+    NoticeHelper.success("✅ Centralized utils are working!");
+    
+    setTimeout(() => {
+        NoticeHelper.info("ℹ️ This notice comes from the centralized config");
+    }, 1000);
+    
+    setTimeout(() => {
+        NoticeHelper.warning("⚠️ This is a warning from centralized utils");
+    }, 2000);
+    
+    setTimeout(() => {
+        NoticeHelper.custom("🚀", "Custom notice with rocket emoji!");
+    }, 3000);
+    
+    console.log("✅ All centralized utils tests completed!");
+}

package/src/tools/index.ts

@@ -0,0 +1,9 @@
+// Simple tools for testing
+export function showTestMessage(): string {
+    return "✅ CENTRALIZED TOOLS WORK! This comes from obsidian-plugin-config!";
+}
+
+export function getRandomEmoji(): string {
+    const emojis = ["🚀", "🎉", "✨", "🔥", "💯", "⚡", "🎯", "🌟"];
+    return emojis[Math.floor(Math.random() * emojis.length)];
+}

package/src/utils/NoticeHelper.ts

@@ -0,0 +1,102 @@
+import { Notice } from "obsidian";
+
+/**
+ * Enhanced Notice helper with different types and durations
+ */
+export class NoticeHelper {
+    private static readonly DEFAULT_DURATION = 5000;
+    private static readonly SUCCESS_DURATION = 3000;
+    private static readonly ERROR_DURATION = 8000;
+    private static readonly WARNING_DURATION = 6000;
+
+    /**
+     * Show a success notice with green styling
+     */
+    static success(message: string, duration?: number): Notice {
+        const notice = new Notice(
+            `✅ ${message}`,
+            duration ?? this.SUCCESS_DURATION
+        );
+        return notice;
+    }
+
+    /**
+     * Show an error notice with red styling
+     */
+    static error(message: string, duration?: number): Notice {
+        const notice = new Notice(
+            `❌ ${message}`,
+            duration ?? this.ERROR_DURATION
+        );
+        return notice;
+    }
+
+    /**
+     * Show a warning notice with yellow styling
+     */
+    static warning(message: string, duration?: number): Notice {
+        const notice = new Notice(
+            `⚠️ ${message}`,
+            duration ?? this.WARNING_DURATION
+        );
+        return notice;
+    }
+
+    /**
+     * Show an info notice with blue styling
+     */
+    static info(message: string, duration?: number): Notice {
+        const notice = new Notice(
+            `ℹ️ ${message}`,
+            duration ?? this.DEFAULT_DURATION
+        );
+        return notice;
+    }
+
+    /**
+     * Show a loading notice that can be updated
+     */
+    static loading(message: string): Notice {
+        return new Notice(`⏳ ${message}`, 0); // 0 = permanent until manually hidden
+    }
+
+    /**
+     * Update a loading notice to success and auto-hide
+     */
+    static updateToSuccess(notice: Notice, message: string): void {
+        notice.setMessage(`✅ ${message}`);
+        setTimeout(() => notice.hide(), this.SUCCESS_DURATION);
+    }
+
+    /**
+     * Update a loading notice to error and auto-hide
+     */
+    static updateToError(notice: Notice, message: string): void {
+        notice.setMessage(`❌ ${message}`);
+        setTimeout(() => notice.hide(), this.ERROR_DURATION);
+    }
+
+    /**
+     * Show a notice with custom emoji and duration
+     */
+    static custom(emoji: string, message: string, duration?: number): Notice {
+        return new Notice(
+            `${emoji} ${message}`,
+            duration ?? this.DEFAULT_DURATION
+        );
+    }
+
+    /**
+     * Show a progress notice for long operations
+     */
+    static progress(message: string, current: number, total: number): Notice {
+        const percentage = Math.round((current / total) * 100);
+        const progressBar = "█".repeat(Math.floor(percentage / 5)) + 
+                           "░".repeat(20 - Math.floor(percentage / 5));
+        
+        return new Notice(
+            `🔄 ${message}\n[${progressBar}] ${percentage}%`,
+            0
+        );
+    }
+}