elit 2.0.1 → 3.0.1

package/dist/chokidar.d.mts

@@ -0,0 +1,134 @@
+import { EventEmitter } from 'events';
+
+/**
+ * File watcher module with unified API across runtimes
+ * Pure implementation without external dependencies
+ * Compatible with 'chokidar' package API
+ * - Node.js: uses native fs.watch
+ * - Bun: uses native fs.watch with enhancements
+ * - Deno: uses Deno.watchFs
+ */
+
+/**
+ * Watch options
+ */
+interface WatchOptions {
+    /**
+     * Indicates whether the process should continue to run as long as files are being watched.
+     * If set to false, the process will continue running even if the watcher is closed.
+     */
+    persistent?: boolean;
+    /**
+     * Indicates whether to watch files that don't have read permissions.
+     */
+    ignorePermissionErrors?: boolean;
+    /**
+     * A function that takes one parameter (the path of the file/directory)
+     * and returns true to ignore or false to watch.
+     */
+    ignored?: string | RegExp | ((path: string) => boolean);
+    /**
+     * If set to false, only the parent directory will be watched for new files.
+     */
+    ignoreInitial?: boolean;
+    /**
+     * If set to true, symlinks will be followed.
+     */
+    followSymlinks?: boolean;
+    /**
+     * Interval of file system polling (in milliseconds).
+     */
+    interval?: number;
+    /**
+     * Interval of file system polling for binary files (in milliseconds).
+     */
+    binaryInterval?: number;
+    /**
+     * If set to true, will provide fs.Stats object as second argument
+     * in add, addDir, and change events.
+     */
+    alwaysStat?: boolean;
+    /**
+     * If set, limits how many levels of subdirectories will be traversed.
+     */
+    depth?: number;
+    /**
+     * By default, add event fires when a file first appears on disk.
+     * Setting this will wait for the write to finish before firing.
+     */
+    awaitWriteFinish?: boolean | {
+        stabilityThreshold?: number;
+        pollInterval?: number;
+    };
+    /**
+     * If set to true, will use fs.watchFile() (polling) instead of fs.watch().
+     */
+    usePolling?: boolean;
+    /**
+     * Whether to use fsevents watching on macOS (if available).
+     */
+    useFsEvents?: boolean;
+    /**
+     * The base path to watch.
+     */
+    cwd?: string;
+    /**
+     * Whether to disable globbing.
+     */
+    disableGlobbing?: boolean;
+    /**
+     * Automatically filter out artifacts that occur when using editors.
+     */
+    atomic?: boolean | number;
+}
+/**
+ * FSWatcher class - Compatible with chokidar
+ */
+declare class FSWatcher extends EventEmitter {
+    private _watcher;
+    private _closed;
+    private _watched;
+    constructor(options?: WatchOptions);
+    options: WatchOptions;
+    /**
+     * Add paths to be watched
+     */
+    add(paths: string | string[]): FSWatcher;
+    /**
+     * Stop watching paths
+     */
+    unwatch(paths: string | string[]): FSWatcher;
+    /**
+     * Close the watcher
+     */
+    close(): Promise<void>;
+    /**
+     * Get watched paths
+     */
+    getWatched(): {
+        [directory: string]: string[];
+    };
+    /**
+     * Internal method to set native watcher
+     * @internal
+     */
+    _setWatcher(watcher: any): void;
+}
+/**
+ * Watch files and directories
+ */
+declare function watch(paths: string | string[], options?: WatchOptions): FSWatcher;
+/**
+ * Get current runtime
+ */
+declare function getRuntime(): 'node' | 'bun' | 'deno';
+/**
+ * Default export
+ */
+declare const _default: {
+    watch: typeof watch;
+    FSWatcher: typeof FSWatcher;
+    getRuntime: typeof getRuntime;
+};
+
+export { FSWatcher, type WatchOptions, _default as default, getRuntime, watch };

package/dist/chokidar.d.ts

@@ -0,0 +1,134 @@
+import { EventEmitter } from 'events';
+
+/**
+ * File watcher module with unified API across runtimes
+ * Pure implementation without external dependencies
+ * Compatible with 'chokidar' package API
+ * - Node.js: uses native fs.watch
+ * - Bun: uses native fs.watch with enhancements
+ * - Deno: uses Deno.watchFs
+ */
+
+/**
+ * Watch options
+ */
+interface WatchOptions {
+    /**
+     * Indicates whether the process should continue to run as long as files are being watched.
+     * If set to false, the process will continue running even if the watcher is closed.
+     */
+    persistent?: boolean;
+    /**
+     * Indicates whether to watch files that don't have read permissions.
+     */
+    ignorePermissionErrors?: boolean;
+    /**
+     * A function that takes one parameter (the path of the file/directory)
+     * and returns true to ignore or false to watch.
+     */
+    ignored?: string | RegExp | ((path: string) => boolean);
+    /**
+     * If set to false, only the parent directory will be watched for new files.
+     */
+    ignoreInitial?: boolean;
+    /**
+     * If set to true, symlinks will be followed.
+     */
+    followSymlinks?: boolean;
+    /**
+     * Interval of file system polling (in milliseconds).
+     */
+    interval?: number;
+    /**
+     * Interval of file system polling for binary files (in milliseconds).
+     */
+    binaryInterval?: number;
+    /**
+     * If set to true, will provide fs.Stats object as second argument
+     * in add, addDir, and change events.
+     */
+    alwaysStat?: boolean;
+    /**
+     * If set, limits how many levels of subdirectories will be traversed.
+     */
+    depth?: number;
+    /**
+     * By default, add event fires when a file first appears on disk.
+     * Setting this will wait for the write to finish before firing.
+     */
+    awaitWriteFinish?: boolean | {
+        stabilityThreshold?: number;
+        pollInterval?: number;
+    };
+    /**
+     * If set to true, will use fs.watchFile() (polling) instead of fs.watch().
+     */
+    usePolling?: boolean;
+    /**
+     * Whether to use fsevents watching on macOS (if available).
+     */
+    useFsEvents?: boolean;
+    /**
+     * The base path to watch.
+     */
+    cwd?: string;
+    /**
+     * Whether to disable globbing.
+     */
+    disableGlobbing?: boolean;
+    /**
+     * Automatically filter out artifacts that occur when using editors.
+     */
+    atomic?: boolean | number;
+}
+/**
+ * FSWatcher class - Compatible with chokidar
+ */
+declare class FSWatcher extends EventEmitter {
+    private _watcher;
+    private _closed;
+    private _watched;
+    constructor(options?: WatchOptions);
+    options: WatchOptions;
+    /**
+     * Add paths to be watched
+     */
+    add(paths: string | string[]): FSWatcher;
+    /**
+     * Stop watching paths
+     */
+    unwatch(paths: string | string[]): FSWatcher;
+    /**
+     * Close the watcher
+     */
+    close(): Promise<void>;
+    /**
+     * Get watched paths
+     */
+    getWatched(): {
+        [directory: string]: string[];
+    };
+    /**
+     * Internal method to set native watcher
+     * @internal
+     */
+    _setWatcher(watcher: any): void;
+}
+/**
+ * Watch files and directories
+ */
+declare function watch(paths: string | string[], options?: WatchOptions): FSWatcher;
+/**
+ * Get current runtime
+ */
+declare function getRuntime(): 'node' | 'bun' | 'deno';
+/**
+ * Default export
+ */
+declare const _default: {
+    watch: typeof watch;
+    FSWatcher: typeof FSWatcher;
+    getRuntime: typeof getRuntime;
+};
+
+export { FSWatcher, type WatchOptions, _default as default, getRuntime, watch };

package/dist/chokidar.js

@@ -0,0 +1,240 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/chokidar.ts
+var chokidar_exports = {};
+__export(chokidar_exports, {
+  FSWatcher: () => FSWatcher,
+  default: () => chokidar_default,
+  getRuntime: () => getRuntime,
+  watch: () => watch
+});
+module.exports = __toCommonJS(chokidar_exports);
+var import_events = require("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 import_events.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
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  FSWatcher,
+  getRuntime,
+  watch
+});