@sse-ui/builder 1.3.1 → 1.3.2

package/README.md

@@ -27,6 +27,7 @@ Once installed, you can access the utility via the `sse-tools` command.
 
 | Command         | Description                                                                          |
 | --------------- | ------------------------------------------------------------------------------------ |
+| `init`          | To initializes the package with the required configuration files                     |
 | `build`         | Compiles the package for production using Babel or esbuild.                          |
 | `watch`         | Starts an incremental rebuild watcher for rapid development.                         |
 | `typecheck`     | Validates TypeScript types across the project without emitting files.                |
@@ -35,6 +36,7 @@ Once installed, you can access the utility via the `sse-tools` command.
 | `publish`       | Publishes the built package directly from your specified build directory.            |
 | `info`          | Displays size and file statistics for your built package.                            |
 | `clean`         | Safely removes the build directory to ensure a fresh start.                          |
+| `remove`        | Safely removes all configuration files and dependencies added by the init command    |
 
 ## ⚙️ Configuration
 

package/dist/cli.js

@@ -11,8 +11,8 @@ import {
 } from "./chunk-N46AJ2OI.js";
 
 // src/cli.ts
-import chalk11 from "chalk";
-import { Command as Command11 } from "commander";
+import chalk13 from "chalk";
+import { Command as Command13 } from "commander";
 
 // src/core/build.ts
 import { findWorkspacesRoot } from "find-workspaces";
@@ -1054,7 +1054,7 @@ var ReaddirpStream = class extends Readable {
     this._directoryFilter = normalizeFilter(opts.directoryFilter);
     const statMethod = opts.lstat ? lstat : stat5;
     if (wantBigintFsStats) {
-      this._stat = (path10) => statMethod(path10, { bigint: true });
+      this._stat = (path12) => statMethod(path12, { bigint: true });
     } else {
       this._stat = statMethod;
     }
@@ -1079,8 +1079,8 @@ var ReaddirpStream = class extends Readable {
         const par = this.parent;
         const fil = par && par.files;
         if (fil && fil.length > 0) {
-          const { path: path10, depth } = par;
-          const slice = fil.splice(0, batch).map((dirent) => this._formatEntry(dirent, path10));
+          const { path: path12, depth } = par;
+          const slice = fil.splice(0, batch).map((dirent) => this._formatEntry(dirent, path12));
           const awaited = await Promise.all(slice);
           for (const entry of awaited) {
             if (!entry)
@@ -1120,20 +1120,20 @@ var ReaddirpStream = class extends Readable {
       this.reading = false;
     }
   }
-  async _exploreDir(path10, depth) {
+  async _exploreDir(path12, depth) {
     let files;
     try {
-      files = await readdir2(path10, this._rdOptions);
+      files = await readdir2(path12, this._rdOptions);
     } catch (error) {
       this._onError(error);
     }
-    return { files, depth, path: path10 };
+    return { files, depth, path: path12 };
   }
-  async _formatEntry(dirent, path10) {
+  async _formatEntry(dirent, path12) {
     let entry;
     const basename4 = this._isDirent ? dirent.name : dirent;
     try {
-      const fullPath = presolve(pjoin(path10, basename4));
+      const fullPath = presolve(pjoin(path12, basename4));
       entry = { path: prelative(this._root, fullPath), fullPath, basename: basename4 };
       entry[this._statsProp] = this._isDirent ? dirent : await this._stat(fullPath);
     } catch (err) {
@@ -1533,16 +1533,16 @@ var delFromSet = (main2, prop, item) => {
 };
 var isEmptySet = (val) => val instanceof Set ? val.size === 0 : !val;
 var FsWatchInstances = /* @__PURE__ */ new Map();
-function createFsWatchInstance(path10, options, listener, errHandler, emitRaw) {
+function createFsWatchInstance(path12, options, listener, errHandler, emitRaw) {
   const handleEvent = (rawEvent, evPath) => {
-    listener(path10);
-    emitRaw(rawEvent, evPath, { watchedPath: path10 });
-    if (evPath && path10 !== evPath) {
-      fsWatchBroadcast(sp.resolve(path10, evPath), KEY_LISTENERS, sp.join(path10, evPath));
+    listener(path12);
+    emitRaw(rawEvent, evPath, { watchedPath: path12 });
+    if (evPath && path12 !== evPath) {
+      fsWatchBroadcast(sp.resolve(path12, evPath), KEY_LISTENERS, sp.join(path12, evPath));
     }
   };
   try {
-    return fs_watch(path10, {
+    return fs_watch(path12, {
       persistent: options.persistent
     }, handleEvent);
   } catch (error) {
@@ -1558,12 +1558,12 @@ var fsWatchBroadcast = (fullPath, listenerType, val1, val2, val3) => {
     listener(val1, val2, val3);
   });
 };
-var setFsWatchListener = (path10, fullPath, options, handlers) => {
+var setFsWatchListener = (path12, fullPath, options, handlers) => {
   const { listener, errHandler, rawEmitter } = handlers;
   let cont = FsWatchInstances.get(fullPath);
   let watcher;
   if (!options.persistent) {
-    watcher = createFsWatchInstance(path10, options, listener, errHandler, rawEmitter);
+    watcher = createFsWatchInstance(path12, options, listener, errHandler, rawEmitter);
     if (!watcher)
       return;
     return watcher.close.bind(watcher);
@@ -1574,7 +1574,7 @@ var setFsWatchListener = (path10, fullPath, options, handlers) => {
     addAndConvert(cont, KEY_RAW, rawEmitter);
   } else {
     watcher = createFsWatchInstance(
-      path10,
+      path12,
       options,
       fsWatchBroadcast.bind(null, fullPath, KEY_LISTENERS),
       errHandler,
@@ -1589,7 +1589,7 @@ var setFsWatchListener = (path10, fullPath, options, handlers) => {
         cont.watcherUnusable = true;
       if (isWindows && error.code === "EPERM") {
         try {
-          const fd = await open(path10, "r");
+          const fd = await open(path12, "r");
           await fd.close();
           broadcastErr(error);
         } catch (err) {
@@ -1620,7 +1620,7 @@ var setFsWatchListener = (path10, fullPath, options, handlers) => {
   };
 };
 var FsWatchFileInstances = /* @__PURE__ */ new Map();
-var setFsWatchFileListener = (path10, fullPath, options, handlers) => {
+var setFsWatchFileListener = (path12, fullPath, options, handlers) => {
   const { listener, rawEmitter } = handlers;
   let cont = FsWatchFileInstances.get(fullPath);
   const copts = cont && cont.options;
@@ -1642,7 +1642,7 @@ var setFsWatchFileListener = (path10, fullPath, options, handlers) => {
         });
         const currmtime = curr.mtimeMs;
         if (curr.size !== prev.size || currmtime > prev.mtimeMs || currmtime === 0) {
-          foreach(cont.listeners, (listener2) => listener2(path10, curr));
+          foreach(cont.listeners, (listener2) => listener2(path12, curr));
         }
       })
     };
@@ -1672,13 +1672,13 @@ var NodeFsHandler = class {
    * @param listener on fs change
    * @returns closer for the watcher instance
    */
-  _watchWithNodeFs(path10, listener) {
+  _watchWithNodeFs(path12, listener) {
     const opts = this.fsw.options;
-    const directory = sp.dirname(path10);
-    const basename4 = sp.basename(path10);
+    const directory = sp.dirname(path12);
+    const basename4 = sp.basename(path12);
     const parent = this.fsw._getWatchedDir(directory);
     parent.add(basename4);
-    const absolutePath = sp.resolve(path10);
+    const absolutePath = sp.resolve(path12);
     const options = {
       persistent: opts.persistent
     };
@@ -1688,12 +1688,12 @@ var NodeFsHandler = class {
     if (opts.usePolling) {
       const enableBin = opts.interval !== opts.binaryInterval;
       options.interval = enableBin && isBinaryPath(basename4) ? opts.binaryInterval : opts.interval;
-      closer = setFsWatchFileListener(path10, absolutePath, options, {
+      closer = setFsWatchFileListener(path12, absolutePath, options, {
         listener,
         rawEmitter: this.fsw._emitRaw
       });
     } else {
-      closer = setFsWatchListener(path10, absolutePath, options, {
+      closer = setFsWatchListener(path12, absolutePath, options, {
         listener,
         errHandler: this._boundHandleError,
         rawEmitter: this.fsw._emitRaw
@@ -1715,7 +1715,7 @@ var NodeFsHandler = class {
     let prevStats = stats;
     if (parent.has(basename4))
       return;
-    const listener = async (path10, newStats) => {
+    const listener = async (path12, newStats) => {
       if (!this.fsw._throttle(THROTTLE_MODE_WATCH, file, 5))
         return;
       if (!newStats || newStats.mtimeMs === 0) {
@@ -1729,11 +1729,11 @@ var NodeFsHandler = class {
             this.fsw._emit(EV.CHANGE, file, newStats2);
           }
           if ((isMacos || isLinux || isFreeBSD) && prevStats.ino !== newStats2.ino) {
-            this.fsw._closeFile(path10);
+            this.fsw._closeFile(path12);
             prevStats = newStats2;
             const closer2 = this._watchWithNodeFs(file, listener);
             if (closer2)
-              this.fsw._addPathCloser(path10, closer2);
+              this.fsw._addPathCloser(path12, closer2);
           } else {
             prevStats = newStats2;
           }
@@ -1765,7 +1765,7 @@ var NodeFsHandler = class {
    * @param item basename of this item
    * @returns true if no more processing is needed for this entry.
    */
-  async _handleSymlink(entry, directory, path10, item) {
+  async _handleSymlink(entry, directory, path12, item) {
     if (this.fsw.closed) {
       return;
     }
@@ -1775,7 +1775,7 @@ var NodeFsHandler = class {
       this.fsw._incrReadyCount();
       let linkPath;
       try {
-        linkPath = await fsrealpath(path10);
+        linkPath = await fsrealpath(path12);
       } catch (e) {
         this.fsw._emitReady();
         return true;
@@ -1785,12 +1785,12 @@ var NodeFsHandler = class {
       if (dir.has(item)) {
         if (this.fsw._symlinkPaths.get(full) !== linkPath) {
           this.fsw._symlinkPaths.set(full, linkPath);
-          this.fsw._emit(EV.CHANGE, path10, entry.stats);
+          this.fsw._emit(EV.CHANGE, path12, entry.stats);
         }
       } else {
         dir.add(item);
         this.fsw._symlinkPaths.set(full, linkPath);
-        this.fsw._emit(EV.ADD, path10, entry.stats);
+        this.fsw._emit(EV.ADD, path12, entry.stats);
       }
       this.fsw._emitReady();
       return true;
@@ -1820,9 +1820,9 @@ var NodeFsHandler = class {
         return;
       }
       const item = entry.path;
-      let path10 = sp.join(directory, item);
+      let path12 = sp.join(directory, item);
       current.add(item);
-      if (entry.stats.isSymbolicLink() && await this._handleSymlink(entry, directory, path10, item)) {
+      if (entry.stats.isSymbolicLink() && await this._handleSymlink(entry, directory, path12, item)) {
         return;
       }
       if (this.fsw.closed) {
@@ -1831,8 +1831,8 @@ var NodeFsHandler = class {
       }
       if (item === target || !target && !previous.has(item)) {
         this.fsw._incrReadyCount();
-        path10 = sp.join(dir, sp.relative(dir, path10));
-        this._addToNodeFs(path10, initialAdd, wh, depth + 1);
+        path12 = sp.join(dir, sp.relative(dir, path12));
+        this._addToNodeFs(path12, initialAdd, wh, depth + 1);
       }
     }).on(EV.ERROR, this._boundHandleError);
     return new Promise((resolve4, reject) => {
@@ -1901,13 +1901,13 @@ var NodeFsHandler = class {
    * @param depth Child path actually targeted for watch
    * @param target Child path actually targeted for watch
    */
-  async _addToNodeFs(path10, initialAdd, priorWh, depth, target) {
+  async _addToNodeFs(path12, initialAdd, priorWh, depth, target) {
     const ready = this.fsw._emitReady;
-    if (this.fsw._isIgnored(path10) || this.fsw.closed) {
+    if (this.fsw._isIgnored(path12) || this.fsw.closed) {
       ready();
       return false;
     }
-    const wh = this.fsw._getWatchHelpers(path10);
+    const wh = this.fsw._getWatchHelpers(path12);
     if (priorWh) {
       wh.filterPath = (entry) => priorWh.filterPath(entry);
       wh.filterDir = (entry) => priorWh.filterDir(entry);
@@ -1923,8 +1923,8 @@ var NodeFsHandler = class {
       const follow = this.fsw.options.followSymlinks;
       let closer;
       if (stats.isDirectory()) {
-        const absPath = sp.resolve(path10);
-        const targetPath = follow ? await fsrealpath(path10) : path10;
+        const absPath = sp.resolve(path12);
+        const targetPath = follow ? await fsrealpath(path12) : path12;
         if (this.fsw.closed)
           return;
         closer = await this._handleDir(wh.watchPath, stats, initialAdd, depth, target, wh, targetPath);
@@ -1934,29 +1934,29 @@ var NodeFsHandler = class {
           this.fsw._symlinkPaths.set(absPath, targetPath);
         }
       } else if (stats.isSymbolicLink()) {
-        const targetPath = follow ? await fsrealpath(path10) : path10;
+        const targetPath = follow ? await fsrealpath(path12) : path12;
         if (this.fsw.closed)
           return;
         const parent = sp.dirname(wh.watchPath);
         this.fsw._getWatchedDir(parent).add(wh.watchPath);
         this.fsw._emit(EV.ADD, wh.watchPath, stats);
-        closer = await this._handleDir(parent, stats, initialAdd, depth, path10, wh, targetPath);
+        closer = await this._handleDir(parent, stats, initialAdd, depth, path12, wh, targetPath);
         if (this.fsw.closed)
           return;
         if (targetPath !== void 0) {
-          this.fsw._symlinkPaths.set(sp.resolve(path10), targetPath);
+          this.fsw._symlinkPaths.set(sp.resolve(path12), targetPath);
         }
       } else {
         closer = this._handleFile(wh.watchPath, stats, initialAdd);
       }
       ready();
       if (closer)
-        this.fsw._addPathCloser(path10, closer);
+        this.fsw._addPathCloser(path12, closer);
       return false;
     } catch (error) {
       if (this.fsw._handleError(error)) {
         ready();
-        return path10;
+        return path12;
       }
     }
   }
@@ -1999,24 +1999,24 @@ function createPattern(matcher) {
   }
   return () => false;
 }
-function normalizePath(path10) {
-  if (typeof path10 !== "string")
+function normalizePath(path12) {
+  if (typeof path12 !== "string")
     throw new Error("string expected");
-  path10 = sp2.normalize(path10);
-  path10 = path10.replace(/\\/g, "/");
+  path12 = sp2.normalize(path12);
+  path12 = path12.replace(/\\/g, "/");
   let prepend = false;
-  if (path10.startsWith("//"))
+  if (path12.startsWith("//"))
     prepend = true;
-  path10 = path10.replace(DOUBLE_SLASH_RE, "/");
+  path12 = path12.replace(DOUBLE_SLASH_RE, "/");
   if (prepend)
-    path10 = "/" + path10;
-  return path10;
+    path12 = "/" + path12;
+  return path12;
 }
 function matchPatterns(patterns, testString, stats) {
-  const path10 = normalizePath(testString);
+  const path12 = normalizePath(testString);
   for (let index = 0; index < patterns.length; index++) {
     const pattern = patterns[index];
-    if (pattern(path10, stats)) {
+    if (pattern(path12, stats)) {
       return true;
     }
   }
@@ -2054,19 +2054,19 @@ var toUnix = (string) => {
   }
   return str;
 };
-var normalizePathToUnix = (path10) => toUnix(sp2.normalize(toUnix(path10)));
-var normalizeIgnored = (cwd = "") => (path10) => {
-  if (typeof path10 === "string") {
-    return normalizePathToUnix(sp2.isAbsolute(path10) ? path10 : sp2.join(cwd, path10));
+var normalizePathToUnix = (path12) => toUnix(sp2.normalize(toUnix(path12)));
+var normalizeIgnored = (cwd = "") => (path12) => {
+  if (typeof path12 === "string") {
+    return normalizePathToUnix(sp2.isAbsolute(path12) ? path12 : sp2.join(cwd, path12));
   } else {
-    return path10;
+    return path12;
   }
 };
-var getAbsolutePath = (path10, cwd) => {
-  if (sp2.isAbsolute(path10)) {
-    return path10;
+var getAbsolutePath = (path12, cwd) => {
+  if (sp2.isAbsolute(path12)) {
+    return path12;
   }
-  return sp2.join(cwd, path10);
+  return sp2.join(cwd, path12);
 };
 var EMPTY_SET = Object.freeze(/* @__PURE__ */ new Set());
 var DirEntry = class {
@@ -2131,10 +2131,10 @@ var WatchHelper = class {
   dirParts;
   followSymlinks;
   statMethod;
-  constructor(path10, follow, fsw) {
+  constructor(path12, follow, fsw) {
     this.fsw = fsw;
-    const watchPath = path10;
-    this.path = path10 = path10.replace(REPLACER_RE, "");
+    const watchPath = path12;
+    this.path = path12 = path12.replace(REPLACER_RE, "");
     this.watchPath = watchPath;
     this.fullWatchPath = sp2.resolve(watchPath);
     this.dirParts = [];
@@ -2274,20 +2274,20 @@ var FSWatcher = class extends EventEmitter {
     this._closePromise = void 0;
     let paths = unifyPaths(paths_);
     if (cwd) {
-      paths = paths.map((path10) => {
-        const absPath = getAbsolutePath(path10, cwd);
+      paths = paths.map((path12) => {
+        const absPath = getAbsolutePath(path12, cwd);
         return absPath;
       });
     }
-    paths.forEach((path10) => {
-      this._removeIgnoredPath(path10);
+    paths.forEach((path12) => {
+      this._removeIgnoredPath(path12);
     });
     this._userIgnored = void 0;
     if (!this._readyCount)
       this._readyCount = 0;
     this._readyCount += paths.length;
-    Promise.all(paths.map(async (path10) => {
-      const res = await this._nodeFsHandler._addToNodeFs(path10, !_internal, void 0, 0, _origAdd);
+    Promise.all(paths.map(async (path12) => {
+      const res = await this._nodeFsHandler._addToNodeFs(path12, !_internal, void 0, 0, _origAdd);
       if (res)
         this._emitReady();
       return res;
@@ -2309,17 +2309,17 @@ var FSWatcher = class extends EventEmitter {
       return this;
     const paths = unifyPaths(paths_);
     const { cwd } = this.options;
-    paths.forEach((path10) => {
-      if (!sp2.isAbsolute(path10) && !this._closers.has(path10)) {
+    paths.forEach((path12) => {
+      if (!sp2.isAbsolute(path12) && !this._closers.has(path12)) {
         if (cwd)
-          path10 = sp2.join(cwd, path10);
-        path10 = sp2.resolve(path10);
+          path12 = sp2.join(cwd, path12);
+        path12 = sp2.resolve(path12);
       }
-      this._closePath(path10);
-      this._addIgnoredPath(path10);
-      if (this._watched.has(path10)) {
+      this._closePath(path12);
+      this._addIgnoredPath(path12);
+      if (this._watched.has(path12)) {
         this._addIgnoredPath({
-          path: path10,
+          path: path12,
           recursive: true
         });
       }
@@ -2383,38 +2383,38 @@ var FSWatcher = class extends EventEmitter {
    * @param stats arguments to be passed with event
    * @returns the error if defined, otherwise the value of the FSWatcher instance's `closed` flag
    */
-  async _emit(event, path10, stats) {
+  async _emit(event, path12, stats) {
     if (this.closed)
       return;
     const opts = this.options;
     if (isWindows)
-      path10 = sp2.normalize(path10);
+      path12 = sp2.normalize(path12);
     if (opts.cwd)
-      path10 = sp2.relative(opts.cwd, path10);
-    const args = [path10];
+      path12 = sp2.relative(opts.cwd, path12);
+    const args = [path12];
     if (stats != null)
       args.push(stats);
     const awf = opts.awaitWriteFinish;
     let pw;
-    if (awf && (pw = this._pendingWrites.get(path10))) {
+    if (awf && (pw = this._pendingWrites.get(path12))) {
       pw.lastChange = /* @__PURE__ */ new Date();
       return this;
     }
     if (opts.atomic) {
       if (event === EVENTS.UNLINK) {
-        this._pendingUnlinks.set(path10, [event, ...args]);
+        this._pendingUnlinks.set(path12, [event, ...args]);
         setTimeout(() => {
-          this._pendingUnlinks.forEach((entry, path11) => {
+          this._pendingUnlinks.forEach((entry, path13) => {
             this.emit(...entry);
             this.emit(EVENTS.ALL, ...entry);
-            this._pendingUnlinks.delete(path11);
+            this._pendingUnlinks.delete(path13);
           });
         }, typeof opts.atomic === "number" ? opts.atomic : 100);
         return this;
       }
-      if (event === EVENTS.ADD && this._pendingUnlinks.has(path10)) {
+      if (event === EVENTS.ADD && this._pendingUnlinks.has(path12)) {
         event = EVENTS.CHANGE;
-        this._pendingUnlinks.delete(path10);
+        this._pendingUnlinks.delete(path12);
       }
     }
     if (awf && (event === EVENTS.ADD || event === EVENTS.CHANGE) && this._readyEmitted) {
@@ -2432,16 +2432,16 @@ var FSWatcher = class extends EventEmitter {
           this.emitWithAll(event, args);
         }
       };
-      this._awaitWriteFinish(path10, awf.stabilityThreshold, event, awfEmit);
+      this._awaitWriteFinish(path12, awf.stabilityThreshold, event, awfEmit);
       return this;
     }
     if (event === EVENTS.CHANGE) {
-      const isThrottled = !this._throttle(EVENTS.CHANGE, path10, 50);
+      const isThrottled = !this._throttle(EVENTS.CHANGE, path12, 50);
       if (isThrottled)
         return this;
     }
     if (opts.alwaysStat && stats === void 0 && (event === EVENTS.ADD || event === EVENTS.ADD_DIR || event === EVENTS.CHANGE)) {
-      const fullPath = opts.cwd ? sp2.join(opts.cwd, path10) : path10;
+      const fullPath = opts.cwd ? sp2.join(opts.cwd, path12) : path12;
       let stats2;
       try {
         stats2 = await stat7(fullPath);
@@ -2472,23 +2472,23 @@ var FSWatcher = class extends EventEmitter {
    * @param timeout duration of time to suppress duplicate actions
    * @returns tracking object or false if action should be suppressed
    */
-  _throttle(actionType, path10, timeout) {
+  _throttle(actionType, path12, timeout) {
     if (!this._throttled.has(actionType)) {
       this._throttled.set(actionType, /* @__PURE__ */ new Map());
     }
     const action = this._throttled.get(actionType);
     if (!action)
       throw new Error("invalid throttle");
-    const actionPath = action.get(path10);
+    const actionPath = action.get(path12);
     if (actionPath) {
       actionPath.count++;
       return false;
     }
     let timeoutObject;
     const clear = () => {
-      const item = action.get(path10);
+      const item = action.get(path12);
       const count = item ? item.count : 0;
-      action.delete(path10);
+      action.delete(path12);
       clearTimeout(timeoutObject);
       if (item)
         clearTimeout(item.timeoutObject);
@@ -2496,7 +2496,7 @@ var FSWatcher = class extends EventEmitter {
     };
     timeoutObject = setTimeout(clear, timeout);
     const thr = { timeoutObject, clear, count: 0 };
-    action.set(path10, thr);
+    action.set(path12, thr);
     return thr;
   }
   _incrReadyCount() {
@@ -2510,44 +2510,44 @@ var FSWatcher = class extends EventEmitter {
    * @param event
    * @param awfEmit Callback to be called when ready for event to be emitted.
    */
-  _awaitWriteFinish(path10, threshold, event, awfEmit) {
+  _awaitWriteFinish(path12, threshold, event, awfEmit) {
     const awf = this.options.awaitWriteFinish;
     if (typeof awf !== "object")
       return;
     const pollInterval = awf.pollInterval;
     let timeoutHandler;
-    let fullPath = path10;
-    if (this.options.cwd && !sp2.isAbsolute(path10)) {
-      fullPath = sp2.join(this.options.cwd, path10);
+    let fullPath = path12;
+    if (this.options.cwd && !sp2.isAbsolute(path12)) {
+      fullPath = sp2.join(this.options.cwd, path12);
     }
     const now = /* @__PURE__ */ new Date();
     const writes = this._pendingWrites;
     function awaitWriteFinishFn(prevStat) {
       statcb(fullPath, (err, curStat) => {
-        if (err || !writes.has(path10)) {
+        if (err || !writes.has(path12)) {
           if (err && err.code !== "ENOENT")
             awfEmit(err);
           return;
         }
         const now2 = Number(/* @__PURE__ */ new Date());
         if (prevStat && curStat.size !== prevStat.size) {
-          writes.get(path10).lastChange = now2;
+          writes.get(path12).lastChange = now2;
         }
-        const pw = writes.get(path10);
+        const pw = writes.get(path12);
         const df = now2 - pw.lastChange;
         if (df >= threshold) {
-          writes.delete(path10);
+          writes.delete(path12);
           awfEmit(void 0, curStat);
         } else {
           timeoutHandler = setTimeout(awaitWriteFinishFn, pollInterval, curStat);
         }
       });
     }
-    if (!writes.has(path10)) {
-      writes.set(path10, {
+    if (!writes.has(path12)) {
+      writes.set(path12, {
         lastChange: now,
         cancelWait: () => {
-          writes.delete(path10);
+          writes.delete(path12);
           clearTimeout(timeoutHandler);
           return event;
         }
@@ -2558,8 +2558,8 @@ var FSWatcher = class extends EventEmitter {
   /**
    * Determines whether user has asked to ignore this path.
    */
-  _isIgnored(path10, stats) {
-    if (this.options.atomic && DOT_RE.test(path10))
+  _isIgnored(path12, stats) {
+    if (this.options.atomic && DOT_RE.test(path12))
       return true;
     if (!this._userIgnored) {
       const { cwd } = this.options;
@@ -2569,17 +2569,17 @@ var FSWatcher = class extends EventEmitter {
       const list = [...ignoredPaths.map(normalizeIgnored(cwd)), ...ignored];
       this._userIgnored = anymatch(list, void 0);
     }
-    return this._userIgnored(path10, stats);
+    return this._userIgnored(path12, stats);
   }
-  _isntIgnored(path10, stat9) {
-    return !this._isIgnored(path10, stat9);
+  _isntIgnored(path12, stat10) {
+    return !this._isIgnored(path12, stat10);
   }
   /**
    * Provides a set of common helpers and properties relating to symlink handling.
    * @param path file or directory pattern being watched
    */
-  _getWatchHelpers(path10) {
-    return new WatchHelper(path10, this.options.followSymlinks, this);
+  _getWatchHelpers(path12) {
+    return new WatchHelper(path12, this.options.followSymlinks, this);
   }
   // Directory helpers
   // -----------------
@@ -2611,63 +2611,63 @@ var FSWatcher = class extends EventEmitter {
    * @param item      base path of item/directory
    */
   _remove(directory, item, isDirectory) {
-    const path10 = sp2.join(directory, item);
-    const fullPath = sp2.resolve(path10);
-    isDirectory = isDirectory != null ? isDirectory : this._watched.has(path10) || this._watched.has(fullPath);
-    if (!this._throttle("remove", path10, 100))
+    const path12 = sp2.join(directory, item);
+    const fullPath = sp2.resolve(path12);
+    isDirectory = isDirectory != null ? isDirectory : this._watched.has(path12) || this._watched.has(fullPath);
+    if (!this._throttle("remove", path12, 100))
       return;
     if (!isDirectory && this._watched.size === 1) {
       this.add(directory, item, true);
     }
-    const wp = this._getWatchedDir(path10);
+    const wp = this._getWatchedDir(path12);
     const nestedDirectoryChildren = wp.getChildren();
-    nestedDirectoryChildren.forEach((nested) => this._remove(path10, nested));
+    nestedDirectoryChildren.forEach((nested) => this._remove(path12, nested));
     const parent = this._getWatchedDir(directory);
     const wasTracked = parent.has(item);
     parent.remove(item);
     if (this._symlinkPaths.has(fullPath)) {
       this._symlinkPaths.delete(fullPath);
     }
-    let relPath = path10;
+    let relPath = path12;
     if (this.options.cwd)
-      relPath = sp2.relative(this.options.cwd, path10);
+      relPath = sp2.relative(this.options.cwd, path12);
     if (this.options.awaitWriteFinish && this._pendingWrites.has(relPath)) {
       const event = this._pendingWrites.get(relPath).cancelWait();
       if (event === EVENTS.ADD)
         return;
     }
-    this._watched.delete(path10);
+    this._watched.delete(path12);
     this._watched.delete(fullPath);
     const eventName = isDirectory ? EVENTS.UNLINK_DIR : EVENTS.UNLINK;
-    if (wasTracked && !this._isIgnored(path10))
-      this._emit(eventName, path10);
-    this._closePath(path10);
+    if (wasTracked && !this._isIgnored(path12))
+      this._emit(eventName, path12);
+    this._closePath(path12);
   }
   /**
    * Closes all watchers for a path
    */
-  _closePath(path10) {
-    this._closeFile(path10);
-    const dir = sp2.dirname(path10);
-    this._getWatchedDir(dir).remove(sp2.basename(path10));
+  _closePath(path12) {
+    this._closeFile(path12);
+    const dir = sp2.dirname(path12);
+    this._getWatchedDir(dir).remove(sp2.basename(path12));
   }
   /**
    * Closes only file-specific watchers
    */
-  _closeFile(path10) {
-    const closers = this._closers.get(path10);
+  _closeFile(path12) {
+    const closers = this._closers.get(path12);
     if (!closers)
       return;
     closers.forEach((closer) => closer());
-    this._closers.delete(path10);
+    this._closers.delete(path12);
   }
-  _addPathCloser(path10, closer) {
+  _addPathCloser(path12, closer) {
     if (!closer)
       return;
-    let list = this._closers.get(path10);
+    let list = this._closers.get(path12);
     if (!list) {
       list = [];
-      this._closers.set(path10, list);
+      this._closers.set(path12, list);
     }
     list.push(closer);
   }
@@ -2924,17 +2924,314 @@ var watchCommand = new Command10("watch").description(
   await startWatcher();
 });
 
+// src/core/init.ts
+import * as fs10 from "fs/promises";
+import * as path10 from "path";
+import { Command as Command11 } from "commander";
+import enquirer2 from "enquirer";
+import chalk11 from "chalk";
+import { $ as $8 } from "execa";
+import { findWorkspacesRoot as findWorkspacesRoot3 } from "find-workspaces";
+var initCommand = new Command11("init").description("Initializes the package with the required configuration files").action(async () => {
+  const cwd = process.cwd();
+  const pkgJsonPath = path10.join(cwd, "package.json");
+  try {
+    const pkgExists = await fs10.stat(pkgJsonPath).then(() => true).catch(() => false);
+    if (!pkgExists) {
+      throw new Error("No package.json found in the current directory.");
+    }
+    const packageJsonContent = await fs10.readFile(pkgJsonPath, "utf8");
+    const packageJson = JSON.parse(packageJsonContent);
+    const { builder } = await enquirer2.prompt({
+      type: "select",
+      name: "builder",
+      message: "Which bundler would you like to use?",
+      choices: ["babel", "esbuild"]
+    });
+    const { buildDir } = await enquirer2.prompt({
+      type: "input",
+      name: "buildDir",
+      message: "What is your build output directory?",
+      initial: "build"
+    });
+    const { dts } = await enquirer2.prompt({
+      type: "confirm",
+      name: "dts",
+      message: "Want .d.ts output also",
+      initial: true
+    });
+    let esbuildEntry = "src/index.ts";
+    if (builder === "esbuild") {
+      const response = await enquirer2.prompt({
+        type: "input",
+        name: "entry",
+        message: "What is your esbuild entry point?",
+        initial: "src/index.ts"
+      });
+      esbuildEntry = response.entry;
+    }
+    console.log(chalk11.blue("\n\u2699\uFE0F  Applying configuration..."));
+    packageJson.publishConfig = packageJson.publishConfig || {};
+    packageJson.publishConfig.directory = buildDir;
+    await fs10.writeFile(
+      pkgJsonPath,
+      JSON.stringify(packageJson, null, 2) + "\n",
+      "utf8"
+    );
+    console.log(
+      chalk11.gray(
+        `\u{1F4DD} Updated publishConfig.directory to "${buildDir}" in package.json`
+      )
+    );
+    const configPath = path10.join(cwd, "sse.config.ts");
+    let configContent = `import { defineConfig } from "@sse-ui/builder/config";
+
+export default defineConfig({
+`;
+    if (builder === "esbuild") {
+      configContent += `  bundle: ["esm", "cjs"],
+`;
+      configContent += `  buildTypes: ${dts},
+`;
+      configContent += `  esbuild: {
+    entry: "${esbuildEntry}",
+    external: [],
+  },
+`;
+    } else {
+      configContent += `  bundle: ["esm", "cjs"],
+`;
+      configContent += `  buildTypes: ${dts},
+`;
+      configContent += `  babel: {
+  //   enableReactCompiler: false
+  // }
+`;
+    }
+    configContent += `});
+`;
+    await fs10.writeFile(configPath, configContent, "utf8");
+    console.log(chalk11.gray(`\u{1F4DD} Created sse.config.ts`));
+    const tsconfigBuildPath = path10.join(cwd, "tsconfig.build.json");
+    const tsconfigBuildExists = await fs10.stat(tsconfigBuildPath).then(() => true).catch(() => false);
+    if (!tsconfigBuildExists) {
+      await fs10.writeFile(
+        tsconfigBuildPath,
+        `{
+  "extends": "./tsconfig.json",
+, "compilerOptions": {
+    "types": [],
+  }}
+`,
+        "utf8"
+      );
+      console.log(chalk11.gray(`\u{1F4DD} Created tsconfig.build.json`));
+    }
+    if (builder === "babel") {
+      const workspaceDir = await findWorkspacesRoot3(cwd);
+      const rootDir = workspaceDir ? workspaceDir.location : cwd;
+      let hasBabelConfig = false;
+      for (const ext of [".js", ".mjs"]) {
+        if (await fs10.stat(path10.join(rootDir, `babel.config${ext}`)).then(() => true).catch(() => false)) {
+          hasBabelConfig = true;
+          break;
+        }
+      }
+      if (!hasBabelConfig) {
+        const babelConfigPath = path10.join(rootDir, "babel.config.mjs");
+        const babelConfigContent = `import getBaseConfig from "@sse-ui/builder/babel-config";
+
+export default function getBabelConfig(api) {
+  const baseConfig = getBaseConfig(api);
+
+  return {
+    ...baseConfig,
+    // Add custom overrides here if needed
+  };
+}
+`;
+        await fs10.writeFile(babelConfigPath, babelConfigContent, "utf8");
+        console.log(
+          chalk11.gray(
+            `\u{1F4DD} Created babel.config.mjs in ${workspaceDir ? "workspace root" : "project root"}`
+          )
+        );
+      } else {
+        console.log(
+          chalk11.gray(
+            `\u2139\uFE0F  Babel config already exists in ${workspaceDir ? "workspace root" : "project root"}, skipping creation.`
+          )
+        );
+      }
+      const pm = getPackageManager();
+      console.log(
+        chalk11.cyan(`
+\u23F3 Installing @babel/runtime using ${pm}...`)
+      );
+      try {
+        const ora = (await import("ora")).default;
+        const spinner = ora(`Installing dependencies...`).start();
+        if (pm === "yarn") {
+          await $8`${pm} add @babel/runtime`;
+        } else {
+          await $8`${pm} install @babel/runtime`;
+        }
+        spinner.succeed("Installed @babel/runtime successfully");
+      } catch (installError) {
+        console.log(chalk11.gray(`Falling back to silent install...`));
+        const args = pm === "yarn" ? ["add", "@babel/runtime"] : ["install", "@babel/runtime"];
+        await $8({ stdio: "ignore" })`${pm} ${args}`;
+        console.log(chalk11.green(`\u2705 Installed @babel/runtime successfully`));
+      }
+    }
+    console.log(
+      chalk11.green.bold(
+        "\n\u2728 Initialization complete! You are ready to build."
+      )
+    );
+  } catch (error) {
+    console.error(chalk11.red("\n\u274C Error initializing project:"));
+    if (error instanceof Error) {
+      console.error(chalk11.red(error.message));
+    }
+    process.exit(1);
+  }
+});
+
+// src/core/remove.ts
+import * as fs11 from "fs/promises";
+import * as path11 from "path";
+import { Command as Command12 } from "commander";
+import enquirer3 from "enquirer";
+import chalk12 from "chalk";
+import { $ as $9 } from "execa";
+import { findWorkspacesRoot as findWorkspacesRoot4 } from "find-workspaces";
+var removeCommand = new Command12("remove").description(
+  "Removes all configuration files and dependencies added by the init command"
+).action(async () => {
+  const cwd = process.cwd();
+  const pkgJsonPath = path11.join(cwd, "package.json");
+  try {
+    const { confirm } = await enquirer3.prompt({
+      type: "confirm",
+      name: "confirm",
+      message: chalk12.yellow(
+        "Are you sure you want to remove all sse-tools configurations and the build directory?"
+      ),
+      initial: false
+    });
+    if (!confirm) {
+      console.log(chalk12.gray("Operation cancelled."));
+      return;
+    }
+    console.log(
+      chalk12.blue("\n\u{1F9F9} Removing configurations and build files...")
+    );
+    const configExts = [".ts", ".js", ".mjs", ".cjs"];
+    for (const ext of configExts) {
+      const configPath = path11.join(cwd, `sse.config${ext}`);
+      try {
+        await fs11.unlink(configPath);
+        console.log(chalk12.gray(`\u{1F5D1}\uFE0F  Removed sse.config${ext}`));
+      } catch (e) {
+      }
+    }
+    try {
+      await fs11.unlink(path11.join(cwd, "tsconfig.build.json"));
+      console.log(chalk12.gray(`\u{1F5D1}\uFE0F  Removed tsconfig.build.json`));
+    } catch (e) {
+    }
+    try {
+      const workspaceDir = await findWorkspacesRoot4(cwd);
+      const rootDir = workspaceDir ? workspaceDir.location : cwd;
+      const babelConfigPath = path11.join(rootDir, "babel.config.mjs");
+      const content = await fs11.readFile(babelConfigPath, "utf8");
+      if (content.includes("@sse-ui/builder/babel-config")) {
+        await fs11.unlink(babelConfigPath);
+        console.log(
+          chalk12.gray(
+            `\u{1F5D1}\uFE0F  Removed babel.config.mjs from ${workspaceDir ? "workspace root" : "project root"}`
+          )
+        );
+      }
+    } catch (e) {
+    }
+    try {
+      const packageJsonContent = await fs11.readFile(pkgJsonPath, "utf8");
+      const packageJson = JSON.parse(packageJsonContent);
+      let pkgModified = false;
+      const buildDirBase = packageJson.publishConfig?.directory || "build";
+      const buildDir = path11.join(cwd, buildDirBase);
+      try {
+        await fs11.rm(buildDir, { recursive: true, force: true });
+        console.log(
+          chalk12.gray(`\u{1F5D1}\uFE0F  Removed build directory: ./${buildDirBase}`)
+        );
+      } catch (e) {
+      }
+      if (packageJson.publishConfig?.directory) {
+        delete packageJson.publishConfig.directory;
+        if (Object.keys(packageJson.publishConfig).length === 0) {
+          delete packageJson.publishConfig;
+        }
+        pkgModified = true;
+        console.log(
+          chalk12.gray(`\u{1F4DD} Removed publishConfig.directory from package.json`)
+        );
+      }
+      if (pkgModified) {
+        await fs11.writeFile(
+          pkgJsonPath,
+          JSON.stringify(packageJson, null, 2) + "\n",
+          "utf8"
+        );
+      }
+      const hasBabelRuntime = packageJson.dependencies?.["@babel/runtime"] || packageJson.devDependencies?.["@babel/runtime"];
+      if (hasBabelRuntime) {
+        const pm = getPackageManager();
+        console.log(
+          chalk12.cyan(`
+\u23F3 Uninstalling @babel/runtime using ${pm}...`)
+        );
+        const args = pm === "yarn" ? ["remove", "@babel/runtime"] : ["uninstall", "@babel/runtime"];
+        try {
+          const ora = (await import("ora")).default;
+          const spinner = ora(`Uninstalling dependencies...`).start();
+          await $9({ stdio: "ignore" })`${pm} ${args}`;
+          spinner.succeed("Uninstalled @babel/runtime successfully");
+        } catch (err) {
+          console.log(chalk12.gray(`Falling back to silent uninstall...`));
+          await $9({ stdio: "ignore" })`${pm} ${args}`;
+          console.log(
+            chalk12.green(`\u2705 Uninstalled @babel/runtime successfully`)
+          );
+        }
+      }
+    } catch (e) {
+      console.error(chalk12.red("\u26A0\uFE0F Could not read or update package.json"));
+    }
+    console.log(chalk12.green.bold("\n\u2728 Clean up complete!"));
+  } catch (error) {
+    console.error(chalk12.red("\n\u274C Error removing configuration:"));
+    if (error instanceof Error) {
+      console.error(chalk12.red(error.message));
+    }
+    process.exit(1);
+  }
+});
+
 // src/cli.ts
 async function main() {
-  const program = new Command11();
+  const program = new Command13();
   program.name("sse-tools").description(
-    chalk11.cyan("CLI utilities for managing and building SSE packages")
+    chalk13.cyan("CLI utilities for managing and building SSE packages")
   ).version("1.0.0").option("-v, --verbose", "Enable verbose logging across all commands");
   program.hook("preAction", (thisCommand) => {
     if (thisCommand.opts().verbose) {
       process.env.SSE_BUILD_VERBOSE = "true";
     }
   });
+  program.addCommand(initCommand);
   program.addCommand(buildCommand);
   program.addCommand(publishCommand);
   program.addCommand(cleanCommand);
@@ -2945,6 +3242,7 @@ async function main() {
   program.addCommand(linkCommand);
   program.addCommand(checkExportsCommand);
   program.addCommand(watchCommand);
+  program.addCommand(removeCommand);
   try {
     await program.parseAsync(process.argv);
   } catch (error) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sse-ui/builder",
-  "version": "1.3.1",
+  "version": "1.3.2",
   "description": "Builder By SSE",
   "type": "module",
   "scripts": {
@@ -55,6 +55,7 @@
     "jiti": "^2.6.1",
     "minimatch": "^10.2.4",
     "mismatch": "^1.2.0",
+    "ora": "^9.3.0",
     "semver": "^7.7.4"
   },
   "repository": {