@batijs/cli 0.0.293 → 0.0.294

package/dist/index.js

@@ -4,13 +4,13 @@ import {
   consola
 } from "./chunk-FWD3UPBV.js";
 import {
-  M8e,
-  YGr,
-  ags,
+  LKr,
+  Qas,
+  dnt,
   export_which,
-  lnt,
-  tas
-} from "./chunk-VJJDTBIT.js";
+  nys,
+  q8e
+} from "./chunk-K3LH2C5T.js";
 import "./chunk-LU7IBQI7.js";
 
 // index.ts
@@ -34,8 +34,8 @@ async function mergeDts({
   filepath,
   meta
 }) {
-  const previousAst = M8e(previousContent);
-  const currentAst = M8e(fileContent);
+  const previousAst = q8e(previousContent);
+  const currentAst = q8e(fileContent);
   for (const imp of previousAst.imports.$items) {
     currentAst.imports[imp.local] = imp;
   }
@@ -52,7 +52,7 @@ async function mergeDts({
       currentAst.$ast.body.splice(index, 0, node);
     }
   }
-  const res = await tas(currentAst.generate().code, meta, {
+  const res = await Qas(currentAst.generate().code, meta, {
     filepath
   });
   return res.code;
@@ -63,7 +63,7 @@ async function executeOperationFile(op, {
 }) {
   const code = await readFile(op.sourceAbsolute, { encoding: "utf-8" });
   const filepath = relative(op.source, op.sourceAbsolute);
-  const result = await tas(code, meta, {
+  const result = await Qas(code, meta, {
     filepath
   });
   let fileContent = result.code;
@@ -97,7 +97,7 @@ async function transformFileAfterExec(filepath, fileContent) {
       case ".js":
       case ".tsx":
       case ".jsx":
-        return lnt(fileContent, {
+        return dnt(fileContent, {
           filepath
         });
       case ".env":
@@ -2542,7 +2542,7 @@ var createDefaultQueryTester = function(query, options) {
 // package.json
 var package_default = {
   name: "@batijs/cli",
-  version: "0.0.293",
+  version: "0.0.294",
   type: "module",
   scripts: {
     "check-types": "tsc --noEmit",
@@ -2646,7 +2646,7 @@ Choose one of them, or simply remove selected Server`
 var __filename = fileURLToPath(import.meta.url);
 var __dirname = dirname(__filename);
 var isWin2 = process.platform === "win32";
-var pm = ags();
+var pm = nys();
 function boilerplatesDir() {
   if (existsSync2(join(__dirname, "boilerplates", "boilerplates.json"))) {
     return join(__dirname, "boilerplates");
@@ -2680,10 +2680,10 @@ function findDescription(key) {
   }
 }
 function printOK(dist, flags2) {
-  const arrow0 = YGr("\u2192", blueBright);
-  const book0 = YGr("\u{1F4DA}", blueBright);
-  const list3 = YGr("-", void 0, 3);
-  const cmd3 = YGr("$", gray, 3);
+  const arrow0 = LKr("\u2192", blueBright);
+  const book0 = LKr("\u{1F4DA}", blueBright);
+  const list3 = LKr("-", void 0, 3);
+  const cmd3 = LKr("$", gray, 3);
   console.log(bold(`${green("\u2713")} Project created at ${cyan(dist)} with:`));
   console.log(list3(green("Vike")));
   for (const key of flags2) {

package/dist/src-ZXRHWERC-5GKONSS7.js

@@ -0,0 +1,406 @@
+#!/usr/bin/env node
+import {
+  n
+} from "./chunk-LU7IBQI7.js";
+
+// ../core/dist/src-ZXRHWERC.js
+import { createRequire } from "module";
+import { fileURLToPath as BATI_fileURLToPath } from "node:url";
+import { dirname as BATI_dirname } from "node:path";
+import w from "node:path";
+import _ from "node:fs/promises";
+import { fileURLToPath as d } from "node:url";
+var require2 = createRequire(import.meta.url);
+var __filename = BATI_fileURLToPath(import.meta.url);
+var __dirname = BATI_dirname(__filename);
+function i(s) {
+  if (!s || !(s instanceof URL) && typeof s != "string") throw new TypeError("Path must be a non-empty string or URL.");
+}
+function M(s) {
+  if (typeof s != "string" && !(s instanceof ArrayBuffer) && !ArrayBuffer.isView(s)) throw new TypeError("File contents must be a string, ArrayBuffer, or ArrayBuffer view.");
+}
+function U(s) {
+  if (s instanceof Uint8Array) return s;
+  if (typeof s == "string") return j.encode(s);
+  if (s instanceof ArrayBuffer) return new Uint8Array(s);
+  if (ArrayBuffer.isView(s)) {
+    let t = s.buffer.slice(s.byteOffset, s.byteOffset + s.byteLength);
+    return new Uint8Array(t);
+  }
+  throw new TypeError("Invalid contents type. Expected string or ArrayBuffer.");
+}
+var v;
+var j;
+var E;
+var T;
+var A;
+var g;
+var u;
+var F = n(() => {
+  "use strict";
+  v = new TextDecoder(), j = new TextEncoder(), E = class extends Error {
+    constructor(t) {
+      super(`Method "${t}" does not exist on impl.`);
+    }
+  }, T = class extends Error {
+    constructor(t) {
+      super(`Method "${t}" is not supported on this impl.`);
+    }
+  }, A = class extends Error {
+    constructor() {
+      super("Implementation already set.");
+    }
+  };
+  g = class {
+    type;
+    data;
+    timestamp = Date.now();
+    constructor(t, e) {
+      this.type = t, this.data = e;
+    }
+  }, u = class {
+    #t;
+    #e;
+    #i = /* @__PURE__ */ new Map();
+    constructor({ impl: t }) {
+      this.#t = t, this.#e = t;
+    }
+    #s(t, ...e) {
+      for (let r of this.#i.values()) r.push(new g("call", { methodName: t, args: e }));
+    }
+    logStart(t) {
+      if (!t || typeof t != "string") throw new TypeError("Log name must be a non-empty string.");
+      if (this.#i.has(t)) throw new Error(`Log "${t}" already exists.`);
+      this.#i.set(t, []);
+    }
+    logEnd(t) {
+      if (this.#i.has(t)) {
+        let e = this.#i.get(t);
+        return this.#i.delete(t), e;
+      }
+      throw new Error(`Log "${t}" does not exist.`);
+    }
+    isBaseImpl() {
+      return this.#e === this.#t;
+    }
+    setImpl(t) {
+      if (this.#s("implSet", t), this.#e !== this.#t) throw new A();
+      this.#e = t;
+    }
+    resetImpl() {
+      this.#s("implReset"), this.#e = this.#t;
+    }
+    #n(t) {
+      if (typeof this.#e[t] != "function") throw new E(t);
+    }
+    #o(t, e) {
+      if (typeof this.#e[t] != "function") throw new T(e);
+    }
+    #r(t, ...e) {
+      return this.#s(t, ...e), this.#n(t), this.#e[t](...e);
+    }
+    #c(t, ...e) {
+      return this.#n(t), this.#e[t](...e);
+    }
+    #a(t, e, ...r) {
+      return this.#s(e, ...r), this.#o(t, e), this.#e[t](...r);
+    }
+    async text(t) {
+      i(t);
+      let e = await this.#a("bytes", "text", t);
+      return e ? v.decode(e) : void 0;
+    }
+    async json(t) {
+      i(t);
+      let e = await this.#a("bytes", "json", t);
+      return e ? JSON.parse(v.decode(e)) : void 0;
+    }
+    async arrayBuffer(t) {
+      return i(t), (await this.#a("bytes", "arrayBuffer", t))?.buffer;
+    }
+    async bytes(t) {
+      return i(t), this.#r("bytes", t);
+    }
+    async write(t, e) {
+      i(t), M(e), this.#s("write", t, e);
+      let r = U(e);
+      return this.#c("write", t, r);
+    }
+    async append(t, e) {
+      i(t), M(e), this.#s("append", t, e);
+      let r = U(e);
+      return this.#c("append", t, r);
+    }
+    async isFile(t) {
+      return i(t), this.#r("isFile", t);
+    }
+    async isDirectory(t) {
+      return i(t), this.#r("isDirectory", t);
+    }
+    async createDirectory(t) {
+      return i(t), this.#r("createDirectory", t);
+    }
+    async delete(t) {
+      return i(t), this.#r("delete", t);
+    }
+    async deleteAll(t) {
+      return i(t), this.#r("deleteAll", t);
+    }
+    async *list(t) {
+      i(t), yield* await this.#r("list", t);
+    }
+    async *walk(t, { directoryFilter: e = () => true, entryFilter: r = () => true } = {}) {
+      i(t), this.#s("walk", t, { directoryFilter: e, entryFilter: r });
+      let n2 = async function* (o, { directoryFilter: c, entryFilter: l, parentPath: L = "", depth: S = 1 }) {
+        for await (let f of this.#c("list", o)) {
+          let h = { path: f.name, depth: S, ...f };
+          L && (h.path = `${L}/${h.path}`);
+          let p = l(h);
+          if (p.then && (p = await p), p && (yield h), f.isDirectory) {
+            let y = c(h);
+            if (y.then && (y = await y), !y) continue;
+            let k = o instanceof URL ? new URL(f.name, o.href.endsWith("/") ? o.href : `${o.href}/`) : `${o.endsWith("/") ? o : `${o}/`}${f.name}`;
+            yield* n2(k, { directoryFilter: c, entryFilter: l, parentPath: h.path, depth: S + 1 });
+          }
+        }
+      }.bind(this);
+      yield* n2(t, { directoryFilter: e, entryFilter: r });
+    }
+    async size(t) {
+      return i(t), this.#r("size", t);
+    }
+    async lastModified(t) {
+      return i(t), this.#r("lastModified", t);
+    }
+    async copy(t, e) {
+      return i(t), i(e), this.#r("copy", t, e);
+    }
+    async copyAll(t, e) {
+      return i(t), i(e), this.#r("copyAll", t, e);
+    }
+    async move(t, e) {
+      return i(t), i(e), this.#r("move", t, e);
+    }
+    async moveAll(t, e) {
+      return i(t), i(e), this.#r("moveAll", t, e);
+    }
+  };
+});
+var O = n(() => {
+  "use strict";
+});
+var $ = n(() => {
+  "use strict";
+});
+var x = n(() => {
+  "use strict";
+  F();
+  O();
+  $();
+});
+function z(s, t) {
+  let e = Date.now() - s.lastAttempt, r = Math.max(s.lastAttempt - s.timestamp, 1), n2 = Math.min(r * 1.2, t);
+  return e >= n2;
+}
+function W(s, t) {
+  return s.age > t;
+}
+var b;
+var m;
+var N = n(() => {
+  "use strict";
+  b = class {
+    id = Math.random().toString(36).slice(2);
+    fn;
+    error;
+    timestamp = Date.now();
+    lastAttempt = this.timestamp;
+    resolve;
+    reject;
+    signal;
+    constructor(t, e, r, n2, o) {
+      this.fn = t, this.error = e, this.timestamp = Date.now(), this.lastAttempt = Date.now(), this.resolve = r, this.reject = n2, this.signal = o;
+    }
+    get age() {
+      return Date.now() - this.timestamp;
+    }
+  }, m = class {
+    #t = [];
+    #e;
+    #i;
+    #s;
+    #n;
+    constructor(t, { timeout: e = 6e4, maxDelay: r = 100 } = {}) {
+      if (typeof t != "function") throw new Error("Missing function to check errors");
+      this.#n = t, this.#e = e, this.#i = r;
+    }
+    retry(t, { signal: e } = {}) {
+      e?.throwIfAborted();
+      let r;
+      try {
+        r = t();
+      } catch (n2) {
+        return Promise.reject(new Error(`Synchronous error: ${n2.message}`, { cause: n2 }));
+      }
+      return !r || typeof r.then != "function" ? Promise.reject(new Error("Result is not a promise.")) : Promise.resolve(r).catch((n2) => {
+        if (!this.#n(n2)) throw n2;
+        return new Promise((o, c) => {
+          this.#t.push(new b(t, n2, o, c, e)), e?.addEventListener("abort", () => {
+            c(e.reason);
+          }), this.#o();
+        });
+      });
+    }
+    #o() {
+      clearTimeout(this.#s), this.#s = void 0;
+      let t = this.#t.shift();
+      if (!t) return;
+      let e = () => {
+        this.#s = setTimeout(() => this.#o(), 0);
+      };
+      if (W(t, this.#e)) {
+        t.reject(t.error), e();
+        return;
+      }
+      if (!z(t, this.#i)) {
+        this.#t.push(t), e();
+        return;
+      }
+      t.lastAttempt = Date.now(), Promise.resolve(t.fn()).then((r) => t.resolve(r)).catch((r) => {
+        if (!this.#n(r)) {
+          t.reject(r);
+          return;
+        }
+        t.lastAttempt = Date.now(), this.#t.push(t);
+      }).finally(() => this.#o());
+    }
+  };
+});
+var V;
+var D;
+var R;
+var I;
+var it;
+var B = n(() => {
+  "use strict";
+  x();
+  N();
+  V = /* @__PURE__ */ new Set(["ENFILE", "EMFILE"]), D = class {
+    name;
+    isFile;
+    isDirectory;
+    isSymlink;
+    constructor(t) {
+      this.name = t.name, this.isFile = t.isFile(), this.isDirectory = t.isDirectory(), this.isSymlink = t.isSymbolicLink();
+    }
+  }, R = class {
+    #t;
+    #e;
+    constructor({ fsp: t = _ } = {}) {
+      this.#t = t, this.#e = new m((e) => V.has(e.code));
+    }
+    bytes(t) {
+      return this.#e.retry(() => this.#t.readFile(t)).then((e) => new Uint8Array(e.buffer)).catch((e) => {
+        if (e.code !== "ENOENT") throw e;
+      });
+    }
+    async write(t, e) {
+      let r = Buffer.from(e);
+      return this.#e.retry(() => this.#t.writeFile(t, r)).catch((n2) => {
+        if (n2.code === "ENOENT") {
+          let o = w.dirname(t instanceof URL ? d(t) : t);
+          return this.#t.mkdir(o, { recursive: true }).then(() => this.#t.writeFile(t, r));
+        }
+        throw n2;
+      });
+    }
+    async append(t, e) {
+      let r = Buffer.from(e);
+      return this.#e.retry(() => this.#t.appendFile(t, r)).catch((n2) => {
+        if (n2.code === "ENOENT") {
+          let o = w.dirname(t instanceof URL ? d(t) : t);
+          return this.#t.mkdir(o, { recursive: true }).then(() => this.#t.appendFile(t, r));
+        }
+        throw n2;
+      });
+    }
+    isFile(t) {
+      return this.#t.stat(t).then((e) => e.isFile()).catch((e) => {
+        if (e.code === "ENOENT") return false;
+        throw e;
+      });
+    }
+    isDirectory(t) {
+      return this.#t.stat(t).then((e) => e.isDirectory()).catch((e) => {
+        if (e.code === "ENOENT") return false;
+        throw e;
+      });
+    }
+    async createDirectory(t) {
+      await this.#t.mkdir(t, { recursive: true });
+    }
+    delete(t) {
+      return this.#t.rm(t).then(() => true).catch((e) => {
+        if (e.code === "ERR_FS_EISDIR") return this.#t.rmdir(t).then(() => true);
+        if (e.code === "ENOENT") return false;
+        throw e;
+      });
+    }
+    deleteAll(t) {
+      return this.#t.rm(t, { recursive: true }).then(() => true).catch((e) => {
+        if (e.code === "ENOENT") return false;
+        throw e;
+      });
+    }
+    async *list(t) {
+      let e = await this.#t.readdir(t, { withFileTypes: true });
+      for (let r of e) yield new D(r);
+    }
+    size(t) {
+      return this.#t.stat(t).then((e) => e.size).catch((e) => {
+        if (e.code !== "ENOENT") throw e;
+      });
+    }
+    lastModified(t) {
+      return this.#t.stat(t).then((e) => e.mtime).catch((e) => {
+        if (e.code !== "ENOENT") throw e;
+      });
+    }
+    copy(t, e) {
+      return this.#t.copyFile(t, e);
+    }
+    async copyAll(t, e) {
+      if (await this.isFile(t)) return this.copy(t, e);
+      let r = t instanceof URL ? d(t) : t, n2 = e instanceof URL ? d(e) : e;
+      await this.createDirectory(e);
+      for await (let o of this.list(t)) {
+        let c = w.join(r, o.name), l = w.join(n2, o.name);
+        o.isDirectory ? await this.copyAll(c, l) : await this.copy(c, l);
+      }
+    }
+    move(t, e) {
+      return this.#t.stat(t).then((r) => {
+        if (r.isDirectory()) throw new Error(`EISDIR: illegal operation on a directory, move '${t}' -> '${e}'`);
+        return this.#t.rename(t, e);
+      });
+    }
+    async moveAll(t, e) {
+      return this.#t.rename(t, e);
+    }
+  }, I = class extends u {
+    constructor({ fsp: t } = {}) {
+      super({ impl: new R({ fsp: t }) });
+    }
+  }, it = new I();
+});
+var Y = n(() => {
+  B();
+  x();
+});
+Y();
+export {
+  u as Hfs,
+  I as NodeHfs,
+  R as NodeHfsImpl,
+  it as hfs
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@batijs/cli",
-  "version": "0.0.293",
+  "version": "0.0.294",
   "type": "module",
   "keywords": [],
   "description": "Next-gen scaffolder. Get started with fully-functional apps, and choose any tool you want",
@@ -20,12 +20,12 @@
     "typescript": "^5.6.2",
     "unplugin-purge-polyfills": "^0.0.7",
     "vite": "^5.4.8",
-    "@batijs/build": "0.0.293",
-    "@batijs/compile": "0.0.293"
+    "@batijs/build": "0.0.294",
+    "@batijs/compile": "0.0.294"
   },
   "dependencies": {
-    "@batijs/core": "0.0.293",
-    "@batijs/features": "0.0.293"
+    "@batijs/core": "0.0.294",
+    "@batijs/features": "0.0.294"
   },
   "bin": "./dist/index.js",
   "exports": {