elit 2.0.1 → 3.0.0

package/dist/chokidar.mjs

@@ -0,0 +1,221 @@
+import {createRequire as __createRequire} from 'module';const require = __createRequire(import.meta.url);
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// src/chokidar.ts
+import { EventEmitter } from "events";
+
+// src/runtime.ts
+var runtime = (() => {
+  if (typeof Deno !== "undefined") return "deno";
+  if (typeof Bun !== "undefined") return "bun";
+  return "node";
+})();
+
+// src/chokidar.ts
+function normalizePath(path) {
+  return path.replace(/\\/g, "/");
+}
+function emitEvent(watcher, eventType, path) {
+  watcher.emit(eventType, path);
+  watcher.emit("all", eventType, path);
+}
+function matchesAnyPattern(path, patterns) {
+  return patterns.some((pattern) => matchesPattern(path, pattern));
+}
+function handleRenameEvent(watcher, fullPath, fs) {
+  try {
+    fs.statSync(fullPath);
+    emitEvent(watcher, "add", fullPath);
+  } catch {
+    emitEvent(watcher, "unlink", fullPath);
+  }
+}
+function setupFsWatch(watcher, baseDir, patterns, fs) {
+  try {
+    const nativeWatcher = fs.watch(baseDir, { recursive: true }, (eventType, filename) => {
+      if (!filename) return;
+      const fullPath = normalizePath(`${baseDir}/${filename}`);
+      if (!matchesAnyPattern(fullPath, patterns)) return;
+      if (eventType === "rename") {
+        handleRenameEvent(watcher, fullPath, fs);
+      } else if (eventType === "change") {
+        emitEvent(watcher, "change", fullPath);
+      }
+    });
+    watcher._setWatcher(nativeWatcher);
+    watcher["_watched"].add(baseDir);
+    queueMicrotask(() => watcher.emit("ready"));
+  } catch (error) {
+    watcher.emit("error", error);
+  }
+}
+var FSWatcher = class extends EventEmitter {
+  constructor(options) {
+    super();
+    this._closed = false;
+    this._watched = /* @__PURE__ */ new Set();
+    this.options = options || {};
+  }
+  /**
+   * Add paths to be watched
+   */
+  add(paths) {
+    if (this._closed) {
+      throw new Error("Watcher has been closed");
+    }
+    const pathArray = Array.isArray(paths) ? paths : [paths];
+    if (runtime === "node") {
+      if (this._watcher) {
+        this._watcher.add(pathArray);
+      }
+    } else {
+      pathArray.forEach((path) => this._watched.add(path));
+    }
+    return this;
+  }
+  /**
+   * Stop watching paths
+   */
+  unwatch(paths) {
+    if (this._closed) {
+      return this;
+    }
+    const pathArray = Array.isArray(paths) ? paths : [paths];
+    if (runtime === "node") {
+      if (this._watcher) {
+        this._watcher.unwatch(pathArray);
+      }
+    } else {
+      pathArray.forEach((path) => this._watched.delete(path));
+    }
+    return this;
+  }
+  /**
+   * Close the watcher
+   */
+  async close() {
+    if (this._closed) {
+      return;
+    }
+    this._closed = true;
+    if (runtime === "node") {
+      if (this._watcher) {
+        await this._watcher.close();
+      }
+    }
+    this.removeAllListeners();
+  }
+  /**
+   * Get watched paths
+   */
+  getWatched() {
+    if (runtime === "node" && this._watcher) {
+      return this._watcher.getWatched();
+    }
+    const result = {};
+    this._watched.forEach((path) => {
+      const dir = path.substring(0, path.lastIndexOf("/")) || ".";
+      const file = path.substring(path.lastIndexOf("/") + 1);
+      if (!result[dir]) {
+        result[dir] = [];
+      }
+      result[dir].push(file);
+    });
+    return result;
+  }
+  /**
+   * Internal method to set native watcher
+   * @internal
+   */
+  _setWatcher(watcher) {
+    this._watcher = watcher;
+  }
+};
+function getBaseDirectory(pattern) {
+  const parts = pattern.split(/[\\\/]/);
+  let baseDir = "";
+  for (const part of parts) {
+    if (part.includes("*") || part.includes("?")) {
+      break;
+    }
+    baseDir = baseDir ? `${baseDir}/${part}` : part;
+  }
+  return baseDir || ".";
+}
+function matchesPattern(filePath, pattern) {
+  const regexPattern = normalizePath(pattern).replace(/\*\*/g, ".*").replace(/\*/g, "[^/]*").replace(/\?/g, ".");
+  const regex = new RegExp(`^${regexPattern}$`);
+  const normalizedPath = normalizePath(filePath);
+  return regex.test(normalizedPath);
+}
+function watch(paths, options) {
+  const watcher = new FSWatcher(options);
+  const pathArray = Array.isArray(paths) ? paths : [paths];
+  const watchMap = /* @__PURE__ */ new Map();
+  pathArray.forEach((path) => {
+    const baseDir = getBaseDirectory(path);
+    if (!watchMap.has(baseDir)) {
+      watchMap.set(baseDir, []);
+    }
+    watchMap.get(baseDir).push(path);
+  });
+  if (runtime === "node") {
+    const fs = __require("fs");
+    watchMap.forEach((patterns, baseDir) => setupFsWatch(watcher, baseDir, patterns, fs));
+  } else if (runtime === "bun") {
+    const fs = __require("fs");
+    watchMap.forEach((patterns, baseDir) => setupFsWatch(watcher, baseDir, patterns, fs));
+  } else if (runtime === "deno") {
+    const baseDirs = Array.from(watchMap.keys());
+    const allPatterns = Array.from(watchMap.values()).flat();
+    (async () => {
+      try {
+        const denoWatcher = Deno.watchFs(baseDirs);
+        for await (const event of denoWatcher) {
+          if (watcher["_closed"]) break;
+          for (const path of event.paths) {
+            const normalizedPath = normalizePath(path);
+            if (!matchesAnyPattern(normalizedPath, allPatterns)) continue;
+            switch (event.kind) {
+              case "create":
+                emitEvent(watcher, "add", path);
+                break;
+              case "modify":
+                emitEvent(watcher, "change", path);
+                break;
+              case "remove":
+                emitEvent(watcher, "unlink", path);
+                break;
+            }
+          }
+        }
+      } catch (error) {
+        if (!watcher["_closed"]) {
+          watcher.emit("error", error);
+        }
+      }
+    })();
+    pathArray.forEach((path) => watcher.add(path));
+    queueMicrotask(() => watcher.emit("ready"));
+  }
+  return watcher;
+}
+function getRuntime() {
+  return runtime;
+}
+var chokidar_default = {
+  watch,
+  FSWatcher,
+  getRuntime
+};
+export {
+  FSWatcher,
+  chokidar_default as default,
+  getRuntime,
+  watch
+};