obsidian-plugin-config 1.1.15 → 1.1.17

package/README.md

@@ -62,6 +62,9 @@ yarn inject-prompt "../my-plugin"
 obsidian-inject ../my-plugin --yes
 yarn inject-path ../my-plugin --yes
 
+# SASS injection (includes esbuild-sass-plugin)
+yarn inject-sass ../my-plugin --yes
+
 # Verification only
 yarn check-plugin ../my-plugin
 ```
@@ -73,6 +76,7 @@ yarn check-plugin ../my-plugin
 - ✅ **tsconfig.json template**: modern optimized TypeScript configuration
 - ✅ **Automatic installation** of dependencies with yarn
 - ✅ **Traceability file**: `.injection-info.json` (version, injection date)
+- 🎨 **SASS support**: Optional SASS/SCSS compilation with `--sass` option
 
 ## Commands available after injection
 
@@ -88,6 +92,28 @@ yarn release        # GitHub release
 yarn help           # Full help
 ```
 
+## SASS Support
+
+For plugins that use SASS/SCSS styling:
+
+```bash
+# Inject with SASS support
+yarn inject-sass ../my-plugin --yes
+
+# What gets added:
+# - esbuild-sass-plugin dependency
+# - SASS compilation in esbuild.config.ts
+# - Automatic .scss file detection
+# - CSS cleanup after compilation
+```
+
+**SASS Features:**
+
+- ✅ **Automatic detection** of `.scss` files in `src/` directory
+- ✅ **Priority order**: `src/styles.scss` > `src/styles.css` > `styles.css`
+- ✅ **Clean compilation** with automatic main.css removal
+- ✅ **Error handling** with helpful messages
+
 ## Architecture
 
 The plugin becomes **100% STANDALONE** after injection:

package/bin/obsidian-inject.js

@@ -3,7 +3,7 @@
 /**
  * Obsidian Plugin Config - CLI Entry Point
  * Global command: obsidian-inject
- * Version: 1.1.15
+ * Version: 1.1.17
  */
 
 import { execSync } from 'child_process';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "obsidian-plugin-config",
-  "version": "1.1.15",
+  "version": "1.1.17",
   "description": "Système d'injection pour plugins Obsidian autonomes",
   "type": "module",
   "main": "src/index.ts",
@@ -32,6 +32,7 @@
     "lint": "eslint . --ext .ts",
     "lint:fix": "eslint . --ext .ts --fix",
     "inject-path": "tsx scripts/inject-path.ts",
+    "inject-sass": "tsx scripts/inject-path.ts --sass",
     "inject-prompt": "tsx scripts/inject-prompt.ts",
     "inject": "tsx scripts/inject-prompt.ts",
     "check-plugin": "tsx scripts/inject-path.ts --dry-run",

package/scripts/build-npm.ts

@@ -201,7 +201,7 @@ function buildAndPublishNpm(): void {
     console.log(`\n📤 Step 2/6: Committing and pushing changes...`);
     try {
       execSync('echo "Prepare NPM package publication" | tsx scripts/acp.ts -b', { stdio: 'inherit' });
-    } catch (acpError) {
+    } catch {
       console.log(`   ℹ️  No additional changes to commit`);
     }
 

package/scripts/help.ts

@@ -26,6 +26,7 @@ BUILD & TESTING:
 INJECTION (Development phase):
   yarn inject-prompt <path>       # Interactive injection (recommended)
   yarn inject-path <path> --yes   # Direct injection with auto-confirm
+  yarn inject-sass <path> --yes   # Injection with SASS support
   yarn inject, check-plugin       # Injection shortcuts
 
 NPM PUBLISHING:
@@ -57,6 +58,7 @@ Injection Usage (Development phase):
   Usage:
     yarn inject-prompt ../my-plugin  # Interactive (recommended)
     yarn inject-path ../my-plugin    # Direct injection
+    yarn inject-sass ../my-plugin    # Injection with SASS support
     yarn check-plugin ../my-plugin   # Verification only
 
 ═══════════════════════════════════════════════════════════════════

package/scripts/inject-path.ts

@@ -67,13 +67,14 @@ async function analyzePlugin(pluginPath: string): Promise<InjectionPlan> {
 /**
  * Display injection plan and ask for confirmation
  */
-async function showInjectionPlan(plan: InjectionPlan, autoConfirm: boolean = false): Promise<boolean> {
+async function showInjectionPlan(plan: InjectionPlan, autoConfirm: boolean = false, useSass: boolean = false): Promise<boolean> {
   console.log(`\n🎯 Injection Plan for: ${plan.targetPath}`);
   console.log(`📁 Target: ${path.basename(plan.targetPath)}`);
   console.log(`📦 Package.json: ${plan.hasPackageJson ? '✅' : '❌'}`);
   console.log(`📋 Manifest.json: ${plan.hasManifest ? '✅' : '❌'}`);
   console.log(`📂 Scripts folder: ${plan.hasScriptsFolder ? '✅ (will be updated)' : '❌ (will be created)'}`);
   console.log(`🔌 Obsidian plugin: ${plan.isObsidianPlugin ? '✅' : '❌'}`);
+  console.log(`🎨 SASS support: ${useSass ? '✅ (esbuild-sass-plugin will be added)' : '❌'}`);
 
   if (!plan.isObsidianPlugin) {
     console.log(`\n⚠️  Warning: This doesn't appear to be a valid Obsidian plugin`);
@@ -246,7 +247,7 @@ async function cleanOldLintFiles(targetPath: string): Promise<void> {
 /**
  * Inject scripts from local files
  */
-async function injectScripts(targetPath: string): Promise<void> {
+async function injectScripts(targetPath: string, useSass: boolean = false): Promise<void> {
   const scriptsPath = path.join(targetPath, "scripts");
 
   // Create scripts directory if it doesn't exist
@@ -263,7 +264,7 @@ async function injectScripts(targetPath: string): Promise<void> {
 
   const scriptFiles = [
     "templates/scripts/utils.ts",
-    "templates/scripts/esbuild.config.ts",
+    useSass ? "templates/scripts/esbuild.config-sass.ts" : "templates/scripts/esbuild.config.ts",
     "templates/scripts/acp.ts",
     "templates/scripts/update-version.ts",
     "templates/scripts/release.ts",
@@ -286,7 +287,13 @@ async function injectScripts(targetPath: string): Promise<void> {
   for (const scriptFile of scriptFiles) {
     try {
       const content = copyFromLocal(scriptFile);
-      const fileName = path.basename(scriptFile);
+      let fileName = path.basename(scriptFile);
+
+      // Handle SASS template renaming
+      if (fileName === 'esbuild.config-sass.ts') {
+        fileName = 'esbuild.config.ts';
+      }
+
       const targetFile = path.join(scriptsPath, fileName);
 
       fs.writeFileSync(targetFile, content, 'utf8');
@@ -353,7 +360,7 @@ async function injectScripts(targetPath: string): Promise<void> {
 /**
  * Update package.json with autonomous configuration
  */
-async function updatePackageJson(targetPath: string): Promise<void> {
+async function updatePackageJson(targetPath: string, useSass: boolean = false): Promise<void> {
   const packageJsonPath = path.join(targetPath, "package.json");
 
   if (!await isValidPath(packageJsonPath)) {
@@ -411,7 +418,8 @@ async function updatePackageJson(targetPath: string): Promise<void> {
       "obsidian-typings": "^3.9.5",
       "semver": "^7.7.2",
       "tsx": "^4.19.4",
-      "typescript": "^5.8.2"
+      "typescript": "^5.8.2",
+      ...(useSass ? { "esbuild-sass-plugin": "^3.3.1" } : {})
     };
 
     // Force update TypeScript to compatible version
@@ -669,7 +677,7 @@ async function runYarnInstall(targetPath: string): Promise<void> {
 /**
  * Main injection function
  */
-export async function performInjection(targetPath: string): Promise<void> {
+export async function performInjection(targetPath: string, useSass: boolean = false): Promise<void> {
   console.log(`\n🚀 Starting injection process...`);
 
   try {
@@ -680,11 +688,11 @@ export async function performInjection(targetPath: string): Promise<void> {
     await ensureTsxInstalled(targetPath);
 
     // Step 3: Inject scripts
-    await injectScripts(targetPath);
+    await injectScripts(targetPath, useSass);
 
     // Step 4: Update package.json
     console.log(`\n📦 Updating package.json...`);
-    await updatePackageJson(targetPath);
+    await updatePackageJson(targetPath, useSass);
 
     // Step 5: Analyze centralized imports (without modifying)
     await analyzeCentralizedImports(targetPath);
@@ -731,6 +739,7 @@ async function main(): Promise<void> {
     const args = process.argv.slice(2);
     const autoConfirm = args.includes('--yes') || args.includes('-y');
     const dryRun = args.includes('--dry-run') || args.includes('--check');
+    const useSass = args.includes('--sass');
     const targetPath = args.find(arg => !arg.startsWith('-'));
 
     if (!targetPath) {
@@ -739,6 +748,7 @@ async function main(): Promise<void> {
       console.error(`   Options:`);
       console.error(`     --yes, -y       Auto-confirm injection`);
       console.error(`     --dry-run       Check only (no injection)`);
+      console.error(`     --sass          Use SASS templates (includes esbuild-sass-plugin)`);
       console.error(`   Shortcuts:`);
       console.error(`     yarn check-plugin ../plugin    # Verification only`);
       console.error(`     yarn verify-plugin ../plugin   # Alias pour check-plugin`);
@@ -767,6 +777,7 @@ async function main(): Promise<void> {
       console.log(`📋 Manifest.json: ${plan.hasManifest ? '✅' : '❌'}`);
       console.log(`📂 Scripts folder: ${plan.hasScriptsFolder ? '✅ (will be updated)' : '❌ (will be created)'}`);
       console.log(`🔌 Obsidian plugin: ${plan.isObsidianPlugin ? '✅' : '❌'}`);
+      console.log(`🎨 SASS support: ${useSass ? '✅ (esbuild-sass-plugin will be added)' : '❌'}`);
 
       if (!plan.isObsidianPlugin) {
         console.log(`\n⚠️  Warning: This doesn't appear to be a valid Obsidian plugin`);
@@ -824,7 +835,7 @@ async function main(): Promise<void> {
     console.log(`\n🔍 Checking plugin-config repository status...`);
     await ensurePluginConfigClean();
 
-    const confirmed = await showInjectionPlan(plan, autoConfirm);
+    const confirmed = await showInjectionPlan(plan, autoConfirm, useSass);
 
     if (!confirmed) {
       console.log(`❌ Injection cancelled by user`);
@@ -832,7 +843,7 @@ async function main(): Promise<void> {
     }
 
     // Perform injection
-    await performInjection(resolvedPath);
+    await performInjection(resolvedPath, useSass);
 
   } catch (error) {
     console.error(`💥 Error: ${error instanceof Error ? error.message : String(error)}`);

package/templates/package-versions-sass.json

@@ -0,0 +1,29 @@
+{
+  "devDependencies": {
+    "@types/node": "^16.11.6",
+    "eslint": "^9.0.0",
+    "obsidian": "latest",
+    "obsidian-typings": "latest",
+    "typescript": "^5.8.2",
+    "tsx": "^4.19.4",
+    "esbuild-sass-plugin": "^3.3.1"
+  },
+  "engines": {
+    "npm": "please-use-yarn",
+    "yarn": ">=1.22.0"
+  },
+  "scripts": {
+    "start": "yarn install && yarn dev",
+    "dev": "tsx ../obsidian-plugin-config/scripts/esbuild.config.ts",
+    "build": "tsc -noEmit -skipLibCheck && tsx ../obsidian-plugin-config/scripts/esbuild.config.ts production",
+    "real": "tsx ../obsidian-plugin-config/scripts/esbuild.config.ts production real",
+    "acp": "tsx ../obsidian-plugin-config/scripts/acp.ts",
+    "bacp": "tsx ../obsidian-plugin-config/scripts/acp.ts -b",
+    "update-version": "tsx ../obsidian-plugin-config/scripts/update-version.ts",
+    "v": "tsx ../obsidian-plugin-config/scripts/update-version.ts",
+    "release": "tsx ../obsidian-plugin-config/scripts/release.ts",
+    "r": "tsx ../obsidian-plugin-config/scripts/release.ts",
+    "help": "tsx ../obsidian-plugin-config/templates/help-plugin.ts",
+    "h": "tsx ../obsidian-plugin-config/templates/help-plugin.ts"
+  }
+}

package/templates/scripts/esbuild.config-sass.ts

@@ -0,0 +1,294 @@
+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 fs from "fs";
+// @ts-ignore - esbuild-sass-plugin is installed during SASS injection
+import { sassPlugin } from "esbuild-sass-plugin";
+import { isValidPath, copyFilesToTargetDir, askQuestion, createReadlineInterface, removeMainCss } from "./utils.js";
+
+// Determine the plugin directory (where the script is called from)
+const pluginDir = process.cwd();
+
+// Create readline interface for prompts
+const rl = createReadlineInterface();
+
+async function promptForVaultPath(envKey: string): Promise<string> {
+  const vaultType = envKey === "REAL_VAULT" ? "real" : "test";
+  const usage = envKey === "REAL_VAULT"
+    ? "for final plugin installation"
+    : "for development and testing";
+
+  console.log(`❓ ${envKey} path is required ${usage}`);
+  const path = await askQuestion(`📝 Enter your ${vaultType} vault path (or Ctrl+C to cancel): `, rl);
+
+  if (!path) {
+    console.log('❌ No path provided, exiting...');
+    process.exit(1);
+  }
+
+  return path;
+}
+
+
+
+async function updateEnvFile(envKey: string, vaultPath: string): Promise<void> {
+  const envPath = path.join(pluginDir, '.env');
+  let envContent = '';
+
+  // Read existing .env if it exists
+  try {
+    envContent = readFileSync(envPath, 'utf8');
+  } catch {
+    // File doesn't exist, start with empty content
+  }
+
+  // Update or add the variable
+  const regex = new RegExp(`^${envKey}=.*$`, 'm');
+  const newLine = `${envKey}=${vaultPath}`;
+
+  if (regex.test(envContent)) {
+    envContent = envContent.replace(regex, newLine);
+  } else {
+    if (envContent.length > 0 && !envContent.endsWith('\n')) {
+      envContent += '\n';
+    }
+    envContent += newLine + '\n';
+  }
+
+  // Write back to .env
+  fs.writeFileSync(envPath, envContent);
+  console.log(`✅ Updated ${envKey} in .env file`);
+}
+
+function validateVaultPath(vaultPath: string): boolean {
+  // Check if the path contains .obsidian directory
+  const obsidianPath = path.join(vaultPath, ".obsidian");
+  const pluginsPath = path.join(vaultPath, ".obsidian", "plugins");
+
+  return fs.existsSync(obsidianPath) && fs.existsSync(pluginsPath);
+}
+
+function getVaultPath(vaultPath: string): string {
+  // Validate that this is a proper vault path
+  if (!validateVaultPath(vaultPath)) {
+    console.error(`❌ Invalid vault path: ${vaultPath}`);
+    console.error(`   The path must contain a .obsidian/plugins directory`);
+    console.error(`   Please enter a valid Obsidian vault path`);
+    process.exit(1);
+  }
+
+  // Check if the path already contains the plugins directory path
+  const pluginsPath = path.join(".obsidian", "plugins");
+  if (vaultPath.includes(pluginsPath)) {
+    return path.join(vaultPath, manifest.id);
+  } else {
+    return path.join(vaultPath, ".obsidian", "plugins", manifest.id);
+  }
+}
+
+const manifestPath = path.join(pluginDir, "manifest.json");
+
+// Check if manifest exists (for plugin-config itself, it might not exist)
+if (!fs.existsSync(manifestPath)) {
+  console.log("⚠️  No manifest.json found - this script is designed for Obsidian plugins");
+  console.log("   If you're building plugin-config itself, use 'tsc' instead");
+  process.exit(0);
+}
+
+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");
+  }
+}
+
+async function getBuildPath(isProd: boolean): Promise<string> {
+  // Check if we should use real vault (either -r flag or "real" argument)
+  const useRealVault = process.argv.includes("-r") || process.argv.includes("real");
+
+  // If production build without redirection, return plugin directory
+  if (isProd && !useRealVault) {
+    return pluginDir;
+  }
+
+  // Determine which path to use
+  const envKey = useRealVault ? "REAL_VAULT" : "TEST_VAULT";
+  const vaultPath = process.env[envKey]?.trim();
+
+  // If empty or undefined, we're already in the plugin folder
+  if (!vaultPath) {
+    // Check if we're in Obsidian plugins folder
+    const currentPath = process.cwd();
+    const isInObsidianPlugins = currentPath.includes('.obsidian/plugins') ||
+      currentPath.includes('.obsidian\\plugins');
+
+    if (isInObsidianPlugins) {
+      // In obsidian/plugins: allow in-place development
+      console.log(`ℹ️  Building in Obsidian plugins folder (in-place development)`);
+      return pluginDir;
+    } else {
+      // External development: prompt for missing vault path
+      const newPath = await promptForVaultPath(envKey);
+      await updateEnvFile(envKey, newPath);
+      config();
+      return getVaultPath(newPath);
+    }
+  }
+
+  // If we reach here, use the vault path directly
+  return getVaultPath(vaultPath);
+}
+
+async function createBuildContext(buildPath: string, isProd: boolean, entryPoints: string[], hasSass: boolean): Promise<esbuild.BuildContext> {
+  const plugins = [
+    // Add SASS plugin if SCSS files are detected
+    ...(hasSass ? [
+      sassPlugin({
+        syntax: 'scss',
+        style: 'expanded',
+      }),
+      {
+        name: 'remove-main-css',
+        setup(build: esbuild.PluginBuild): void {
+          build.onEnd(async (result) => {
+            if (result.errors.length === 0) {
+              await removeMainCss(buildPath);
+            }
+          });
+        },
+      }
+    ] : []),
+    // Plugin pour gérer les alias de chemin
+    {
+      name: "path-alias",
+      setup: (build: esbuild.PluginBuild): 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: esbuild.PluginBuild): void => {
+        build.onEnd(async () => {
+          // if real or build
+          if (isProd) {
+            if (process.argv.includes("-r") || process.argv.includes("real")) {
+              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);
+          }
+        });
+      }
+    }
+  ];
+
+  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
+  });
+}
+
+async function main(): Promise<void> {
+  try {
+    await validateEnvironment();
+    const isProd = process.argv[2] === "production";
+    const buildPath = await getBuildPath(isProd);
+    console.log(buildPath === pluginDir
+      ? "Building in initial folder"
+      : `Building in ${buildPath}`);
+
+    // Check for SCSS first, then CSS in src, then in root
+    const srcStylesScssPath = path.join(pluginDir, "src/styles.scss");
+    const srcStylesPath = path.join(pluginDir, "src/styles.css");
+    const rootStylesPath = path.join(pluginDir, "styles.css");
+
+    const scssExists = await isValidPath(srcStylesScssPath);
+    const stylePath = scssExists ? srcStylesScssPath :
+      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, scssExists);
+
+    if (isProd) {
+      await context.rebuild();
+      rl.close();
+      process.exit(0);
+    } else {
+      await context.watch();
+    }
+  } catch (error) {
+    console.error("Build failed:", error);
+    rl.close();
+    process.exit(1);
+  }
+}
+
+main().catch(console.error);

package/templates/scripts/esbuild.config.ts

@@ -6,7 +6,7 @@ import path from "path";
 import { readFileSync } from "fs";
 import { rm } from "fs/promises";
 import fs from "fs";
-import { isValidPath, copyFilesToTargetDir, askQuestion, createReadlineInterface } from "./utils.js";
+import { isValidPath, copyFilesToTargetDir, askQuestion, createReadlineInterface, removeMainCss } from "./utils.js";
 
 // Determine the plugin directory (where the script is called from)
 const pluginDir = process.cwd();
@@ -167,7 +167,80 @@ async function getBuildPath(isProd: boolean): Promise<string> {
   return getVaultPath(vaultPath);
 }
 
-async function createBuildContext(buildPath: string, isProd: boolean, entryPoints: string[]): Promise<esbuild.BuildContext> {
+async function createBuildContext(buildPath: string, isProd: boolean, entryPoints: string[], hasSass: boolean): Promise<esbuild.BuildContext> {
+  const plugins = [
+    // Add SASS plugin if SCSS files are detected
+    ...(hasSass ? [
+      // Dynamic import for SASS plugin to avoid dependency issues when not needed
+      await (async () => {
+        try {
+          // @ts-ignore - esbuild-sass-plugin is installed during injection
+          const { sassPlugin } = await import('esbuild-sass-plugin');
+          return sassPlugin({
+            syntax: 'scss',
+            style: 'expanded',
+          });
+        } catch (error) {
+          console.warn('⚠️  esbuild-sass-plugin not found. Install it with: yarn add -D esbuild-sass-plugin');
+          throw error;
+        }
+      })(),
+      {
+        name: 'remove-main-css',
+        setup(build: esbuild.PluginBuild): void {
+          build.onEnd(async (result) => {
+            if (result.errors.length === 0) {
+              await removeMainCss(buildPath);
+            }
+          });
+        },
+      }
+    ] : []),
+    // Plugin pour gérer les alias de chemin
+    {
+      name: "path-alias",
+      setup: (build: esbuild.PluginBuild): 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: esbuild.PluginBuild): void => {
+        build.onEnd(async () => {
+          // if real or build
+          if (isProd) {
+            if (process.argv.includes("-r") || process.argv.includes("real")) {
+              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);
+          }
+        });
+      }
+    }
+  ];
+
   return await esbuild.context({
     banner: { js: BANNER },
     minify: isProd,
@@ -182,51 +255,7 @@ async function createBuildContext(buildPath: string, isProd: boolean, entryPoint
     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") || process.argv.includes("real")) {
-                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);
-            }
-          });
-        }
-      }
-    ]
+    plugins
   });
 }
 
@@ -238,12 +267,20 @@ async function main(): Promise<void> {
     console.log(buildPath === pluginDir
       ? "Building in initial folder"
       : `Building in ${buildPath}`);
+
+    // Check for SCSS first, then CSS in src, then in root
+    const srcStylesScssPath = path.join(pluginDir, "src/styles.scss");
     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 scssExists = await isValidPath(srcStylesScssPath);
+    const stylePath = scssExists ? srcStylesScssPath :
+      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);
+    const context = await createBuildContext(buildPath, isProd, entryPoints, scssExists);
 
     if (isProd) {
       await context.rebuild();

package/templates/scripts/utils.ts

@@ -145,4 +145,19 @@ export async function ensureGitSync(): Promise<void> {
     console.error(`❌ Git sync failed: ${error.message}`);
     throw error;
   }
+}
+
+/**
+ * Remove main.css file generated by esbuild when compiling SCSS
+ * This prevents the unwanted main.css from being included in the plugin
+ */
+export async function removeMainCss(outdir: string): Promise<void> {
+  const mainCssPath = path.join(outdir, 'main.css');
+  try {
+    await rm(mainCssPath);
+  } catch (error: any) {
+    if (error.code !== 'ENOENT') {
+      console.warn(`Warning: Could not remove main.css: ${error.message}`);
+    }
+  }
 }

package/versions.json

@@ -19,5 +19,7 @@
 	"1.1.12": "1.8.9",
 	"1.1.13": "1.8.9",
 	"1.1.14": "1.8.9",
-	"1.1.15": "1.8.9"
+	"1.1.15": "1.8.9",
+	"1.1.16": "1.8.9",
+	"1.1.17": "1.8.9"
 }