@udixio/tailwind 1.2.1 → 1.4.0

package/dist/node.js

@@ -0,0 +1,332 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+import { T as TailwindImplPluginBrowser, m as main } from "./tailwind.plugin-BqW8MAYp.js";
+import { f, s } from "./tailwind.plugin-BqW8MAYp.js";
+import { PluginAbstract, FontPlugin } from "@udixio/theme";
+import * as fs from "fs";
+import * as console from "node:console";
+import { join, resolve, dirname, normalize } from "pathe";
+import chalk from "chalk";
+class TailwindPlugin extends PluginAbstract {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "dependencies", [FontPlugin]);
+    __publicField(this, "name", "tailwind");
+    __publicField(this, "pluginClass", TailwindImplPlugin);
+  }
+}
+class TailwindImplPlugin extends TailwindImplPluginBrowser {
+  isNodeJs() {
+    return typeof process !== "undefined" && process.versions != null && process.versions.node != null;
+  }
+  async onLoad() {
+    var _a;
+    if (!this.isNodeJs()) {
+      await super.onLoad();
+      return;
+    }
+    const { join: join2, resolve: resolve2 } = await import("pathe");
+    const {
+      createOrUpdateFile: createOrUpdateFile2,
+      findProjectRoot: findProjectRoot2,
+      findTailwindCssFile: findTailwindCssFile2,
+      getFileContent: getFileContent2,
+      replaceFileContent: replaceFileContent2
+    } = await Promise.resolve().then(() => file);
+    this.colors = {};
+    for (const isDark of [false, true]) {
+      this.api.themes.update({ isDark });
+      for (const [key, value] of this.api.colors.getColors().entries()) {
+        const newKey = key.replace(/([a-z0-9]|(?=[A-Z]))([A-Z])/g, "$1-$2").toLowerCase();
+        (_a = this.colors)[newKey] ?? (_a[newKey] = { light: "", dark: "" });
+        this.colors[newKey][isDark ? "dark" : "light"] = value.getHex();
+      }
+    }
+    let udixioCssPath = this.options.styleFilePath;
+    const projectRoot = await findProjectRoot2(resolve2());
+    if (!udixioCssPath) {
+      const searchPattern = /@import ["']tailwindcss["'];/;
+      const replacement = `@import 'tailwindcss';
+@import "./udixio.css";`;
+      const tailwindCssPath = await findTailwindCssFile2(
+        projectRoot,
+        searchPattern
+      );
+      udixioCssPath = join2(tailwindCssPath, "../udixio.css");
+      if (!await getFileContent2(tailwindCssPath, /@import\s+"\.\/udixio\.css";/)) {
+        await replaceFileContent2(tailwindCssPath, searchPattern, replacement);
+      }
+    }
+    const { fontStyles, fontFamily } = this.api.plugins.getPlugin(FontPlugin).getInstance().getFonts();
+    const configCss = {
+      colorKeys: Object.keys(this.colors).join(", "),
+      fontStyles: Object.entries(fontStyles).map(
+        ([fontRole, fontStyle]) => Object.entries(fontStyle).map(
+          ([fontSize, fontStyle2]) => `${fontRole}-${fontSize} ${Object.entries(fontStyle2).map(([name, value]) => `${name}[${value}]`).join(" ")}`
+        ).join(", ")
+      ).join(", "),
+      responsiveBreakPoints: Object.entries(
+        this.options.responsiveBreakPoints ?? {}
+      ).map(([key, value]) => `${key} ${value}`).join(", ")
+    };
+    this.outputCss += `@plugin "@udixio/tailwind" {
+  colorKeys: ${configCss.colorKeys};
+  fontStyles: ${configCss.fontStyles};
+  responsiveBreakPoints: ${configCss.responsiveBreakPoints};
+}`;
+    this.loadColor();
+    this.outputCss += `
+@theme {
+  ${Object.entries(fontFamily).map(
+      ([key, values]) => `--font-${key}: ${values.map((value) => `"${value}"`).join(", ")};`
+    ).join("\n  ")}
+}`;
+    await createOrUpdateFile2(udixioCssPath, this.outputCss);
+  }
+}
+const normalizePath = async (filePath) => {
+  const { fileURLToPath } = await import("url");
+  try {
+    if (filePath.startsWith("file://")) {
+      return normalize(fileURLToPath(filePath));
+    }
+    return normalize(filePath);
+  } catch (error) {
+    console.warn(
+      chalk.yellow(
+        `⚠️  Could not process path ${filePath}, treating as regular path`
+      )
+    );
+    return normalize(filePath);
+  }
+};
+const safeExistsSync = async (filePath) => {
+  return fs.existsSync(await normalizePath(filePath));
+};
+const safeReadFileSync = async (filePath, encoding = "utf8") => {
+  return fs.readFileSync(await normalizePath(filePath), encoding);
+};
+const safeWriteFileSync = async (filePath, data) => {
+  const normalizedPath = await normalizePath(filePath);
+  const dirPath = dirname(normalizedPath);
+  if (!fs.existsSync(dirPath)) {
+    fs.mkdirSync(dirPath, { recursive: true });
+  }
+  fs.writeFileSync(normalizedPath, data);
+};
+const createOrUpdateFile = async (filePath, content) => {
+  try {
+    const normalizedPath = normalizePath(filePath);
+    if (!await safeExistsSync(filePath)) {
+      await safeWriteFileSync(filePath, content);
+      console.log(
+        chalk.green(`📄 Created`) + chalk.gray(` • `) + chalk.cyan(normalizedPath)
+      );
+    } else {
+      console.log(
+        chalk.blue(`📝 Exists`) + chalk.gray(` • `) + chalk.cyan(normalizedPath)
+      );
+      await replaceFileContent(filePath, /[\s\S]*/, content);
+    }
+  } catch (error) {
+    console.error(
+      chalk.red(`🚨 Failed to create file`) + chalk.gray(` • `) + chalk.cyan(filePath)
+    );
+    console.error(
+      chalk.gray(`   `) + chalk.red(error instanceof Error ? error.message : error)
+    );
+  }
+};
+const getFileContent = async (filePath, searchPattern) => {
+  try {
+    const normalizedPath = normalizePath(filePath);
+    if (!await safeExistsSync(filePath)) {
+      console.error(
+        chalk.red(`❌ File not found`) + chalk.gray(` • `) + chalk.cyan(normalizedPath)
+      );
+      return null;
+    }
+    const fileContent = await safeReadFileSync(filePath);
+    if (searchPattern) {
+      if (typeof searchPattern === "string") {
+        const found = fileContent.includes(searchPattern) ? searchPattern : false;
+        if (found) {
+          console.log(
+            chalk.green(`🔍 Found`) + chalk.gray(` • `) + chalk.yellow(`"${searchPattern}"`)
+          );
+        } else {
+          console.log(
+            chalk.yellow(`🔍 Missing`) + chalk.gray(` • `) + chalk.yellow(`"${searchPattern}"`)
+          );
+        }
+        return found;
+      } else {
+        const match = fileContent.match(searchPattern);
+        if (match) {
+          console.log(
+            chalk.green(`🎯 Match`) + chalk.gray(` • `) + chalk.yellow(`"${match[0]}"`)
+          );
+          return match[0];
+        } else {
+          console.log(
+            chalk.yellow(`🎯 No match`) + chalk.gray(` • `) + chalk.magenta(searchPattern.toString())
+          );
+          return false;
+        }
+      }
+    }
+    console.log(
+      chalk.blue(`📖 Read`) + chalk.gray(` • `) + chalk.cyan(normalizedPath)
+    );
+    return fileContent;
+  } catch (error) {
+    console.error(
+      chalk.red(`🚨 Read failed`) + chalk.gray(` • `) + chalk.cyan(filePath)
+    );
+    console.error(
+      chalk.gray(`   `) + chalk.red(error instanceof Error ? error.message : error)
+    );
+    return null;
+  }
+};
+const replaceFileContent = async (filePath, searchPattern, replacement) => {
+  try {
+    const { replaceInFileSync } = await import("replace-in-file");
+    const normalizedPath = await normalizePath(filePath);
+    const results = replaceInFileSync({
+      files: normalizedPath,
+      from: searchPattern,
+      to: replacement
+    });
+    if (results.length > 0 && results[0].hasChanged) {
+      console.log(
+        chalk.green(`✏️  Updated`) + chalk.gray(` • `) + chalk.cyan(normalizedPath)
+      );
+    } else {
+      console.log(
+        chalk.yellow(`⏭️  Skipped`) + chalk.gray(` • `) + chalk.cyan(normalizedPath) + chalk.gray(` (no changes needed)`)
+      );
+    }
+  } catch (error) {
+    console.error(
+      chalk.red(`🚨 Update failed`) + chalk.gray(` • `) + chalk.cyan(filePath)
+    );
+    console.error(
+      chalk.gray(`   `) + chalk.red(error instanceof Error ? error.message : error)
+    );
+  }
+};
+const findTailwindCssFile = async (startDir, searchPattern) => {
+  const normalizedStartDir = await normalizePath(startDir);
+  console.log(chalk.blue(`🔎 Searching for CSS file...`));
+  console.log(
+    chalk.gray(`   Starting from: `) + chalk.cyan(normalizedStartDir)
+  );
+  const stack = [normalizedStartDir];
+  let filesScanned = 0;
+  while (stack.length > 0) {
+    const currentDir = stack.pop();
+    let files;
+    try {
+      files = fs.readdirSync(currentDir);
+    } catch (error) {
+      console.error(
+        chalk.gray(`   `) + chalk.red(`❌ Cannot read directory: `) + chalk.cyan(currentDir)
+      );
+      continue;
+    }
+    for (const file2 of files) {
+      const filePath = join(currentDir, file2);
+      let stats;
+      try {
+        stats = fs.statSync(filePath);
+      } catch (error) {
+        console.error(
+          chalk.gray(`   `) + chalk.red(`❌ Cannot access: `) + chalk.cyan(filePath)
+        );
+        continue;
+      }
+      if (stats.isDirectory()) {
+        if (file2 !== "node_modules" && !file2.startsWith(".")) {
+          stack.push(filePath);
+        }
+      } else if (stats.isFile() && (file2.endsWith(".css") || file2.endsWith(".scss") || file2.endsWith(".sass"))) {
+        try {
+          filesScanned++;
+          process.stdout.write(
+            chalk.gray(`   📂 Scanning: `) + chalk.yellow(file2) + `\r`
+          );
+          const content = await safeReadFileSync(filePath);
+          const hasMatch = typeof searchPattern === "string" ? content.includes(searchPattern) : searchPattern.test(content);
+          if (hasMatch) {
+            console.log(chalk.green(`
+🎯 Found target file!`));
+            console.log(chalk.gray(`   📍 Location: `) + chalk.cyan(filePath));
+            return filePath;
+          }
+        } catch (readError) {
+          console.error(
+            chalk.gray(`
+   `) + chalk.red(`❌ Cannot read: `) + chalk.cyan(filePath)
+          );
+        }
+      }
+    }
+  }
+  console.log(
+    chalk.blue(`
+📊 Scanned `) + chalk.white.bold(filesScanned.toString()) + chalk.blue(` CSS files`)
+  );
+  const errorMsg = chalk.red(`❌ No file found containing `) + chalk.yellow(`"${searchPattern}"`) + chalk.red(` in `) + chalk.cyan(`"${normalizedStartDir}"`);
+  throw new Error(errorMsg);
+};
+async function findProjectRoot(startPath) {
+  const normalizedStartPath = await normalizePath(startPath);
+  let currentPath = resolve(normalizedStartPath);
+  let levels = 0;
+  console.log(chalk.blue(`🏠 Finding project root...`));
+  console.log(
+    chalk.gray(`   Starting from: `) + chalk.cyan(normalizedStartPath)
+  );
+  while (!fs.existsSync(join(currentPath, "package.json"))) {
+    const parentPath = dirname(currentPath);
+    if (currentPath === parentPath) {
+      console.error(
+        chalk.red(`❌ Project root not found after checking `) + chalk.white.bold(levels.toString()) + chalk.red(` levels`)
+      );
+      throw new Error(
+        chalk.red("Unable to locate project root (no package.json found)")
+      );
+    }
+    currentPath = parentPath;
+    levels++;
+    if (levels > 10) {
+      console.error(
+        chalk.red(`❌ Stopped after `) + chalk.white.bold(levels.toString()) + chalk.red(` levels (too deep)`)
+      );
+      throw new Error(chalk.red("Project root search exceeded maximum depth"));
+    }
+  }
+  console.log(chalk.green(`📁 Project root: `) + chalk.cyan(currentPath));
+  return currentPath;
+}
+const file = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  createOrUpdateFile,
+  findProjectRoot,
+  findTailwindCssFile,
+  getFileContent,
+  replaceFileContent
+}, Symbol.toStringTag, { value: "Module" }));
+export {
+  TailwindPlugin,
+  createOrUpdateFile,
+  main as default,
+  findProjectRoot,
+  findTailwindCssFile,
+  f as font,
+  getFileContent,
+  replaceFileContent,
+  s as state
+};

package/dist/{index.js → tailwind.plugin-BqW8MAYp.js}

@@ -2,11 +2,6 @@ var __defProp = Object.defineProperty;
 var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
 import plugin from "tailwindcss/plugin";
-import * as fs from "fs";
-import * as path from "path";
-import path__default from "path";
-import { replaceInFileSync } from "replace-in-file";
-import * as console from "node:console";
 import { PluginAbstract, FontPlugin, PluginImplAbstract } from "@udixio/theme";
 const defaultConfig = {
   statePrefix: "state",
@@ -166,202 +161,59 @@ const main = plugin.withOptions((args) => {
     shadow.handler(api);
   };
 });
-const createOrUpdateFile = (filePath, content) => {
-  try {
-    if (!fs.existsSync(filePath)) {
-      const dirPath = path.dirname(filePath);
-      if (!fs.existsSync(dirPath)) {
-        fs.mkdirSync(dirPath, { recursive: true });
-      }
-      fs.writeFileSync(filePath, content);
-      console.log(`✅ File successfully created: ${filePath}`);
-    } else {
-      console.log(`⚠️ File already exists: ${filePath}`);
-      replaceFileContent(filePath, /[\s\S]*/, content);
-    }
-  } catch (error) {
-    console.error("❌ Error while creating the file:", error);
-  }
-};
-const getFileContent = (filePath, searchPattern) => {
-  try {
-    if (!fs.existsSync(filePath)) {
-      console.error(`❌ The specified file does not exist: ${filePath}`);
-      return null;
-    }
-    const fileContent = fs.readFileSync(filePath, "utf8");
-    if (searchPattern) {
-      if (typeof searchPattern === "string") {
-        const found = fileContent.includes(searchPattern) ? searchPattern : false;
-        console.log(
-          found ? `✅ The file contains the specified string: "${searchPattern}"` : `⚠️ The file does NOT contain the specified string: "${searchPattern}"`
-        );
-        return found;
-      } else {
-        const match = fileContent.match(searchPattern);
-        if (match) {
-          console.log(`✅ Found match: "${match[0]}"`);
-          return match[0];
-        } else {
-          console.log(
-            `⚠️ No match found for the pattern: "${searchPattern.toString()}"`
-          );
-          return false;
-        }
-      }
-    }
-    console.log(`✅ File content successfully retrieved.`);
-    return fileContent;
-  } catch (error) {
-    console.error("❌ An error occurred while processing the file:", error);
-    return null;
-  }
-};
-const replaceFileContent = (filePath, searchPattern, replacement) => {
-  try {
-    const results = replaceInFileSync({
-      files: filePath,
-      from: searchPattern,
-      to: replacement
-    });
-    if (results.length > 0 && results[0].hasChanged) {
-      console.log(`✅ Content successfully replaced in the file: ${filePath}`);
-    } else {
-      console.log(
-        `⚠️ No replacement made. Here are some possible reasons:
-- The pattern ${searchPattern} was not found.
-- The file might already contain the expected content.`
-      );
-    }
-  } catch (error) {
-    console.error("❌ Error while replacing the file content:", error);
-  }
-};
-const findTailwindCssFile = (startDir, searchPattern) => {
-  console.log("Recherche du fichier contenant le motif...", startDir);
-  const stack = [startDir];
-  while (stack.length > 0) {
-    const currentDir = stack.pop();
-    const files = fs.readdirSync(currentDir);
-    for (const file of files) {
-      const filePath = path.join(currentDir, file);
-      let stats;
-      try {
-        stats = fs.statSync(filePath);
-      } catch (error) {
-        console.error(`Erreur lors de l'accès à ${filePath}:`, error);
-        continue;
-      }
-      if (stats.isDirectory()) {
-        if (file !== "node_modules") stack.push(filePath);
-      } else if (stats.isFile() && (file.endsWith(".css") || file.endsWith(".scss") || file.endsWith(".sass"))) {
-        try {
-          console.log(`Analyse du fichier : ${filePath}`);
-          const content = fs.readFileSync(filePath, "utf8");
-          if (content.match(searchPattern)) {
-            console.log("Fichier trouvé :", filePath);
-            return filePath;
-          }
-        } catch (readError) {
-          console.error(`Erreur lors de la lecture de ${filePath}:`, readError);
-        }
-      }
-    }
-  }
-  throw new Error(
-    `Impossible de trouver un fichier contenant "${searchPattern}" dans "${startDir}".`
-  );
-};
-function findProjectRoot(startPath) {
-  let currentPath = startPath;
-  while (!fs.existsSync(path.join(currentPath, "package.json"))) {
-    const parentPath = path.dirname(currentPath);
-    if (currentPath === parentPath) {
-      throw new Error("Impossible de localiser la racine du projet.");
-    }
-    currentPath = parentPath;
-  }
-  return currentPath;
-}
 class TailwindPlugin extends PluginAbstract {
   constructor() {
     super(...arguments);
     __publicField(this, "dependencies", [FontPlugin]);
     __publicField(this, "name", "tailwind");
-    __publicField(this, "pluginClass", TailwindImplPlugin);
+    __publicField(this, "pluginClass", TailwindImplPluginBrowser);
   }
 }
-class TailwindImplPlugin extends PluginImplAbstract {
+class TailwindImplPluginBrowser extends PluginImplAbstract {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "outputCss", "");
+    __publicField(this, "colors", {});
+  }
   onInit() {
     var _a;
     (_a = this.options).responsiveBreakPoints ?? (_a.responsiveBreakPoints = {
       lg: 1.125
     });
   }
-  onLoad() {
-    let udixioCssPath = this.options.styleFilePath;
-    const projectRoot = findProjectRoot(path__default.resolve());
-    if (!udixioCssPath) {
-      const searchPattern = /@import ["']tailwindcss["'];/;
-      const replacement = `@import 'tailwindcss';
-@import "./udixio.css";`;
-      const tailwindCssPath = findTailwindCssFile(projectRoot, searchPattern);
-      udixioCssPath = path__default.join(tailwindCssPath, "../udixio.css");
-      if (!getFileContent(tailwindCssPath, /@import\s+"\.\/udixio\.css";/)) {
-        replaceFileContent(tailwindCssPath, searchPattern, replacement);
-      }
-    }
-    const colors = {};
-    for (const isDark of [false, true]) {
-      this.api.themes.update({ isDark });
-      for (const [key, value] of this.api.colors.getColors().entries()) {
-        const newKey = key.replace(/([a-z0-9]|(?=[A-Z]))([A-Z])/g, "$1-$2").toLowerCase();
-        colors[newKey] ?? (colors[newKey] = { light: "", dark: "" });
-        colors[newKey][isDark ? "dark" : "light"] = value.getHex();
-      }
-    }
-    const { fontStyles, fontFamily } = this.api.plugins.getPlugin(FontPlugin).getInstance().getFonts();
-    const configCss = {
-      colorKeys: Object.keys(colors).join(", "),
-      fontStyles: Object.entries(fontStyles).map(
-        ([fontRole, fontStyle]) => Object.entries(fontStyle).map(
-          ([fontSize, fontStyle2]) => `${fontRole}-${fontSize} ${Object.entries(fontStyle2).map(([name, value]) => `${name}[${value}]`).join(" ")}`
-        ).join(", ")
-      ).join(", "),
-      responsiveBreakPoints: Object.entries(
-        this.options.responsiveBreakPoints ?? {}
-      ).map(([key, value]) => `${key} ${value}`).join(", ")
-    };
-    createOrUpdateFile(
-      udixioCssPath,
-      `
-@plugin "@udixio/tailwind" {
-  colorKeys: ${configCss.colorKeys};
-  fontStyles: ${configCss.fontStyles};
-  responsiveBreakPoints: ${configCss.responsiveBreakPoints};
-}
+  loadColor() {
+    this.outputCss += `
 @custom-variant dark (&:where(.dark, .dark *));
 @theme {
   --color-*: initial;
-  ${Object.entries(colors).map(([key, value]) => `--color-${key}: ${value.light};`).join("\n  ")}
+  ${Object.entries(this.colors).map(([key, value]) => `--color-${key}: ${value.light};`).join("\n  ")}
 }
 @layer theme {
   .dark {
-  ${Object.entries(colors).map(([key, value]) => `--color-${key}: ${value.dark};`).join("\n  ")}
+  ${Object.entries(this.colors).map(([key, value]) => `--color-${key}: ${value.dark};`).join("\n  ")}
   }
 }
-@theme {
-  ${Object.entries(fontFamily).map(
-        ([key, values]) => `--font-${key}: ${values.map((value) => `"${value}"`).join(", ")};`
-      ).join("\n  ")}
-}
-`
-    );
+`;
+  }
+  async onLoad() {
+    var _a;
+    this.colors = {};
+    for (const isDark of [false, true]) {
+      this.api.themes.update({ isDark });
+      for (const [key, value] of this.api.colors.getColors().entries()) {
+        const newKey = key.replace(/([a-z0-9]|(?=[A-Z]))([A-Z])/g, "$1-$2").toLowerCase();
+        (_a = this.colors)[newKey] ?? (_a[newKey] = { light: "", dark: "" });
+        this.colors[newKey][isDark ? "dark" : "light"] = value.getHex();
+      }
+    }
+    await import("@tailwindcss/browser");
+    this.loadColor();
   }
 }
 export {
-  TailwindPlugin,
-  main as default,
-  font,
-  state
+  TailwindImplPluginBrowser as T,
+  TailwindPlugin as a,
+  font as f,
+  main as m,
+  state as s
 };