obsidian-plugin-config 1.0.2

package/test-plugin-v2/scripts/esbuild.config.ts

@@ -0,0 +1,165 @@
+import esbuild from "esbuild";
+import process from "process";
+import builtins from "builtin-modules";
+import { config } from "dotenv";
+import path from "path";
+import { readFileSync } from "fs";
+import { rm } from "fs/promises";
+import { isValidPath, copyFilesToTargetDir } from "./utils.ts";
+
+// Determine the plugin directory (where the script is called from)
+const pluginDir = process.cwd();
+const manifestPath = path.join(pluginDir, "manifest.json");
+const manifest = JSON.parse(readFileSync(manifestPath, "utf-8"));
+
+config();
+
+const EXTERNAL_DEPS = [
+  "obsidian",
+  "electron",
+  "@codemirror/autocomplete",
+  "@codemirror/collab",
+  "@codemirror/commands",
+  "@codemirror/language",
+  "@codemirror/lint",
+  "@codemirror/search",
+  "@codemirror/state",
+  "@codemirror/view",
+  "@lezer/common",
+  "@lezer/highlight",
+  "@lezer/lr",
+  ...builtins
+];
+
+const BANNER = `/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/`;
+
+async function validateEnvironment(): Promise<void> {
+  const srcMainPath = path.join(pluginDir, "src/main.ts");
+  if (!await isValidPath(srcMainPath)) {
+    throw new Error("Invalid path for src/main.ts. main.ts must be in the src directory");
+  }
+  if (!await isValidPath(manifestPath)) {
+    throw new Error("Invalid path for manifest.json");
+  }
+}
+
+function getBuildPath(isProd: boolean): string {
+  // If production build without redirection, return plugin directory
+  if (isProd && !process.argv.includes("-r")) {
+    return pluginDir;
+  }
+
+  // Determine which path to use
+  const envKey = process.argv.includes("-r") ? "REAL_VAULT" : "TEST_VAULT";
+  const vaultPath = process.env[envKey]?.trim();
+
+  // If empty or undefined, we're already in the plugin folder
+  if (!vaultPath) {
+    return pluginDir;
+  }
+
+  // Check if the path already contains the plugins directory path
+  const pluginsPath = path.join(".obsidian", "plugins");
+  if (vaultPath.includes(pluginsPath)) {
+    // Just add the manifest id to complete the path
+    return path.join(vaultPath, manifest.id);
+  }
+
+  // Otherwise, complete the full path
+  return path.join(vaultPath, ".obsidian", "plugins", manifest.id);
+}
+
+async function createBuildContext(buildPath: string, isProd: boolean, entryPoints: string[]): Promise<esbuild.BuildContext> {
+  return await esbuild.context({
+    banner: { js: BANNER },
+    minify: isProd,
+    entryPoints,
+    bundle: true,
+    external: EXTERNAL_DEPS,
+    format: "cjs",
+    target: "esNext",
+    platform: "node",
+    logLevel: "info",
+    sourcemap: isProd ? false : "inline",
+    treeShaking: true,
+    outdir: buildPath,
+    outbase: path.join(pluginDir, "src"),
+    plugins: [
+      // Plugin pour gérer les alias de chemin
+      {
+        name: "path-alias",
+        setup: (build): void => {
+          build.onResolve({ filter: /^@config\// }, (args) => {
+            const relativePath = args.path.replace(/^@config\//, "");
+            return {
+              path: path.resolve("../obsidian-plugin-config/src", relativePath)
+            };
+          });
+
+          build.onResolve({ filter: /^@config-scripts\// }, (args) => {
+            const relativePath = args.path.replace(/^@config-scripts\//, "");
+            return {
+              path: path.resolve("../obsidian-plugin-config/scripts", relativePath)
+            };
+          });
+        }
+      },
+      {
+        name: "copy-to-plugins-folder",
+        setup: (build): void => {
+          build.onEnd(async () => {
+            // if real or build
+            if (isProd) {
+              if (process.argv.includes("-r")) {
+                await copyFilesToTargetDir(buildPath);
+                console.log(`Successfully installed in ${buildPath}`);
+              } else {
+                const folderToRemove = path.join(buildPath, "_.._");
+                if (await isValidPath(folderToRemove)) {
+                  await rm(folderToRemove, { recursive: true });
+                }
+                console.log("Built done in initial folder");
+              }
+            }
+            // if watch (dev)
+            else {
+              await copyFilesToTargetDir(buildPath);
+            }
+          });
+        }
+      }
+    ]
+  });
+}
+
+async function main(): Promise<void> {
+  try {
+    await validateEnvironment();
+    const isProd = process.argv[2] === "production";
+    const buildPath = getBuildPath(isProd);
+    console.log(buildPath === pluginDir
+      ? "Building in initial folder"
+      : `Building in ${buildPath}`);
+    const srcStylesPath = path.join(pluginDir, "src/styles.css");
+    const rootStylesPath = path.join(pluginDir, "styles.css");
+    const stylePath = await isValidPath(srcStylesPath) ? srcStylesPath : await isValidPath(rootStylesPath) ? rootStylesPath : "";
+    const mainTsPath = path.join(pluginDir, "src/main.ts");
+    const entryPoints = stylePath ? [mainTsPath, stylePath] : [mainTsPath];
+    const context = await createBuildContext(buildPath, isProd, entryPoints);
+
+    if (isProd) {
+      await context.rebuild();
+      process.exit(0);
+    } else {
+      await context.watch();
+    }
+  } catch (error) {
+    console.error("Build failed:", error);
+    process.exit(1);
+  }
+}
+
+main().catch(console.error);

package/test-plugin-v2/scripts/help.ts

@@ -0,0 +1,29 @@
+#!/usr/bin/env tsx
+
+console.log(`
+Obsidian Plugin Config - Command Reference
+(Run these commands from obsidian-plugin-config directory)
+
+MIGRATION:
+  yarn migrate, m <path>           Migrate plugin to centralized architecture
+  yarn migrate --dry-run           Preview changes without applying (debugging)
+  yarn migrate -i, --interactive   Interactive plugin selection
+
+MAINTENANCE:
+  yarn start                       Install dependencies and update exports
+  yarn acp                         Add, commit, and push changes (with exports update)
+  yarn acp -ne, --no-exports       Add, commit, and push without updating exports
+  yarn update-version, v           Update version in centralized config
+  yarn help, h                     Show this help
+
+USAGE EXAMPLES:
+  yarn migrate "C:\\Users\\dev\\plugins\\my-plugin"
+  yarn migrate ../existing-plugin --dry-run
+  yarn m -i                        # Short interactive mode
+
+PATH CONVENTIONS:
+  - Windows absolute paths: Use quotes "C:\\path\\to\\plugin"
+  - Relative paths: No quotes needed ../plugin-name
+
+For detailed documentation: ARCHITECTURE-SUMMARY.md
+`);

package/test-plugin-v2/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-v2/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-v2/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-v2/src/main.ts

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

package/test-plugin-v2/tsconfig.json

@@ -0,0 +1,31 @@
+{
+  "compilerOptions": {
+    "baseUrl": ".",
+    "strict": true,
+    "strictPropertyInitialization": false,
+    "allowJs": true,
+    "esModuleInterop": true,
+    "forceConsistentCasingInFileNames": true,
+    "importHelpers": true,
+    "lib": [
+      "DOM",
+      "ES2020"
+    ],
+    "types": [
+      "node"
+    ],
+    "isolatedModules": true,
+    "module": "ESNext",
+    "moduleResolution": "node",
+    "resolveJsonModule": true,
+    "noEmit": true,
+    "target": "ES2018",
+    "skipLibCheck": true
+  },
+  "include": [
+    "./src/**/*.ts"
+  ],
+  "exclude": [
+    "node_modules"
+  ]
+}