@kubb/core 1.15.0-canary.20231026T131818 → 1.15.0-canary.20231026T182312

package/dist/utils.js

@@ -17,6 +17,36 @@ import isEqual from 'lodash.isequal';
 
 createRequire(import.meta.url);
   
+var __accessCheck = (obj, member, msg) => {
+  if (!member.has(obj))
+    throw TypeError("Cannot " + msg);
+};
+var __privateGet = (obj, member, getter) => {
+  __accessCheck(obj, member, "read from private field");
+  return getter ? getter.call(obj) : member.get(obj);
+};
+var __privateAdd = (obj, member, value) => {
+  if (member.has(obj))
+    throw TypeError("Cannot add the same private member more than once");
+  member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+};
+var __privateSet = (obj, member, value, setter) => {
+  __accessCheck(obj, member, "write to private field");
+  setter ? setter.call(obj, value) : member.set(obj, value);
+  return value;
+};
+var __privateWrapper = (obj, member, setter, getter) => ({
+  set _(value) {
+    __privateSet(obj, member, value, setter);
+  },
+  get _() {
+    return __privateGet(obj, member, getter);
+  }
+});
+var __privateMethod = (obj, member, method) => {
+  __accessCheck(obj, member, "access private method");
+  return method;
+};
 
 // src/utils/cache.ts
 function createPluginCache(Store = /* @__PURE__ */ Object.create(null)) {
@@ -49,9 +79,8 @@ async function clean(path2) {
   return remove(path2);
 }
 var FunctionParams = class {
-  type;
-  items = [];
   constructor(type) {
+    this.items = [];
     this.type = type;
     return this;
   }
@@ -140,88 +169,97 @@ function isPromiseFulfilledResult(result) {
 function isPromiseRejectedResult(result) {
   return result.status === "rejected";
 }
+var _emitter;
 var EventEmitter = class {
   constructor() {
-    this.#emitter.setMaxListeners(100);
+    __privateAdd(this, _emitter, new EventEmitter$1());
+    __privateGet(this, _emitter).setMaxListeners(100);
   }
-  #emitter = new EventEmitter$1();
   emit(eventName, ...eventArg) {
-    this.#emitter.emit(eventName, ...eventArg);
+    __privateGet(this, _emitter).emit(eventName, ...eventArg);
   }
   on(eventName, handler) {
-    this.#emitter.on(eventName, handler);
+    __privateGet(this, _emitter).on(eventName, handler);
   }
   off(eventName, handler) {
-    this.#emitter.off(eventName, handler);
+    __privateGet(this, _emitter).off(eventName, handler);
   }
   removeAll() {
-    this.#emitter.removeAllListeners();
+    __privateGet(this, _emitter).removeAllListeners();
   }
 };
+_emitter = new WeakMap();
 
 // src/utils/Queue.ts
+var _queue, _workerCount, _maxParallel, _debug, _work, work_fn;
 var Queue = class {
-  #queue = [];
-  eventEmitter = new EventEmitter();
-  #workerCount = 0;
-  #maxParallel;
-  #debug = false;
   constructor(maxParallel, debug = false) {
-    this.#maxParallel = maxParallel;
-    this.#debug = debug;
+    __privateAdd(this, _work);
+    __privateAdd(this, _queue, []);
+    this.eventEmitter = new EventEmitter();
+    __privateAdd(this, _workerCount, 0);
+    __privateAdd(this, _maxParallel, void 0);
+    __privateAdd(this, _debug, false);
+    __privateSet(this, _maxParallel, maxParallel);
+    __privateSet(this, _debug, debug);
   }
   run(job, options = { controller: new AbortController(), name: crypto.randomUUID(), description: "" }) {
     return new Promise((resolve2, reject) => {
       const item = { reject, resolve: resolve2, job, name: options.name, description: options.description || options.name };
       options.controller?.signal.addEventListener("abort", () => {
-        this.#queue = this.#queue.filter((queueItem) => queueItem.name === item.name);
+        __privateSet(this, _queue, __privateGet(this, _queue).filter((queueItem) => queueItem.name === item.name));
         reject("Aborted");
       });
-      this.#queue.push(item);
-      this.#work();
+      __privateGet(this, _queue).push(item);
+      __privateMethod(this, _work, work_fn).call(this);
     });
   }
   runSync(job, options = { controller: new AbortController(), name: crypto.randomUUID(), description: "" }) {
     new Promise((resolve2, reject) => {
       const item = { reject, resolve: resolve2, job, name: options.name, description: options.description || options.name };
       options.controller?.signal.addEventListener("abort", () => {
-        this.#queue = this.#queue.filter((queueItem) => queueItem.name === item.name);
+        __privateSet(this, _queue, __privateGet(this, _queue).filter((queueItem) => queueItem.name === item.name));
       });
-      this.#queue.push(item);
-      this.#work();
+      __privateGet(this, _queue).push(item);
+      __privateMethod(this, _work, work_fn).call(this);
     });
   }
   get hasJobs() {
-    return this.#workerCount > 0 || this.#queue.length > 0;
+    return __privateGet(this, _workerCount) > 0 || __privateGet(this, _queue).length > 0;
   }
   get count() {
-    return this.#workerCount;
+    return __privateGet(this, _workerCount);
   }
-  #work() {
-    if (this.#workerCount >= this.#maxParallel) {
-      return;
+};
+_queue = new WeakMap();
+_workerCount = new WeakMap();
+_maxParallel = new WeakMap();
+_debug = new WeakMap();
+_work = new WeakSet();
+work_fn = function() {
+  if (__privateGet(this, _workerCount) >= __privateGet(this, _maxParallel)) {
+    return;
+  }
+  __privateWrapper(this, _workerCount)._++;
+  let entry;
+  while (entry = __privateGet(this, _queue).shift()) {
+    const { reject, resolve: resolve2, job, name, description } = entry;
+    if (__privateGet(this, _debug)) {
+      performance.mark(name + "_start");
     }
-    this.#workerCount++;
-    let entry;
-    while (entry = this.#queue.shift()) {
-      const { reject, resolve: resolve2, job, name, description } = entry;
-      if (this.#debug) {
-        performance.mark(name + "_start");
+    job().then((result) => {
+      this.eventEmitter.emit("jobDone", result);
+      resolve2(result);
+      if (__privateGet(this, _debug)) {
+        performance.mark(name + "_stop");
+        performance.measure(description, name + "_start", name + "_stop");
       }
-      job().then((result) => {
-        this.eventEmitter.emit("jobDone", result);
-        resolve2(result);
-        if (this.#debug) {
-          performance.mark(name + "_stop");
-          performance.measure(description, name + "_start", name + "_stop");
-        }
-      }).catch((err) => {
-        this.eventEmitter.emit("jobFailed", err);
-        reject(err);
-      });
-    }
-    this.#workerCount--;
+    }).catch((err) => {
+      this.eventEmitter.emit("jobFailed", err);
+      reject(err);
+    });
   }
+  __privateWrapper(this, _workerCount)._--;
 };
 var defaultColours = ["black", "blue", "darkBlue", "cyan", "gray", "green", "darkGreen", "magenta", "red", "darkRed", "yellow", "darkYellow"];
 function randomColour(text, colours = defaultColours) {
@@ -597,14 +635,15 @@ async function write(data, path2) {
   }
   return writer(path2, data.trim());
 }
+var _options;
 var BarrelManager = class {
-  #options = {};
   constructor(options = {}) {
-    this.#options = options;
+    __privateAdd(this, _options, {});
+    __privateSet(this, _options, options);
     return this;
   }
   getIndexes(root, extName) {
-    const { treeNode = {}, isTypeOnly, filter, map, output, includeExt } = this.#options;
+    const { treeNode = {}, isTypeOnly, filter, map, output, includeExt } = __privateGet(this, _options);
     const extMapper = {
       ".ts": {
         extensions: /\.ts/,
@@ -673,50 +712,47 @@ var BarrelManager = class {
     return map ? filteredFiles.map(map) : filteredFiles;
   }
 };
+_options = new WeakMap();
 
 // src/FileManager.ts
-var FileManager = class _FileManager {
-  #cache = /* @__PURE__ */ new Map();
-  #task;
-  #isWriting = false;
-  /**
-   * Timeout between writes
-   */
-  #timeout = 0;
-  #queue;
+var _cache, _task, _isWriting, _timeout, _queue2, _validate, validate_fn, _add, add_fn, _addOrAppend, addOrAppend_fn;
+var _FileManager = class _FileManager {
   constructor(options) {
+    __privateAdd(this, _validate);
+    __privateAdd(this, _add);
+    __privateAdd(this, _addOrAppend);
+    __privateAdd(this, _cache, /* @__PURE__ */ new Map());
+    __privateAdd(this, _task, void 0);
+    __privateAdd(this, _isWriting, false);
+    /**
+     * Timeout between writes
+     */
+    __privateAdd(this, _timeout, 0);
+    __privateAdd(this, _queue2, void 0);
     if (options) {
-      this.#task = options.task;
-      this.#queue = options.queue;
-      this.#timeout = options.timeout || 0;
+      __privateSet(this, _task, options.task);
+      __privateSet(this, _queue2, options.queue);
+      __privateSet(this, _timeout, options.timeout || 0);
     }
     return this;
   }
   get files() {
     const files = [];
-    this.#cache.forEach((item) => {
+    __privateGet(this, _cache).forEach((item) => {
       files.push(...item.flat(1));
     });
     return files;
   }
   get isExecuting() {
-    return this.#queue?.hasJobs ?? this.#isWriting ?? false;
-  }
-  #validate(file) {
-    if (!file.validate) {
-      return;
-    }
-    if (!file.path.toLowerCase().endsWith(file.baseName.toLowerCase())) {
-      throw new Error(`${file.path} should end with the baseName ${file.baseName}`);
-    }
+    return __privateGet(this, _queue2)?.hasJobs ?? __privateGet(this, _isWriting) ?? false;
   }
   async add(...files) {
     const promises = files.map((file) => {
-      this.#validate(file);
+      __privateMethod(this, _validate, validate_fn).call(this, file);
       if (file.override) {
-        return this.#add(file);
+        return __privateMethod(this, _add, add_fn).call(this, file);
       }
-      return this.#addOrAppend(file);
+      return __privateMethod(this, _addOrAppend, addOrAppend_fn).call(this, file);
     });
     const resolvedFiles = await Promise.all(promises);
     if (files.length > 1) {
@@ -724,36 +760,6 @@ var FileManager = class _FileManager {
     }
     return resolvedFiles[0];
   }
-  async #add(file) {
-    const controller = new AbortController();
-    const resolvedFile = { id: crypto.randomUUID(), ...file };
-    this.#cache.set(resolvedFile.path, [{ cancel: () => controller.abort(), ...resolvedFile }]);
-    if (this.#queue) {
-      await this.#queue.run(
-        async () => {
-          return this.#task?.(resolvedFile);
-        },
-        { controller }
-      );
-    }
-    return resolvedFile;
-  }
-  async #addOrAppend(file) {
-    const previousCaches = this.#cache.get(file.path);
-    const previousCache = previousCaches ? previousCaches.at(previousCaches.length - 1) : void 0;
-    if (previousCache) {
-      this.#cache.delete(previousCache.path);
-      return this.#add({
-        ...file,
-        source: previousCache.source && file.source ? `${previousCache.source}
-${file.source}` : "",
-        imports: [...previousCache.imports || [], ...file.imports || []],
-        exports: [...previousCache.exports || [], ...file.exports || []],
-        env: { ...previousCache.env || {}, ...file.env || {} }
-      });
-    }
-    return this.#add(file);
-  }
   async addIndexes({ root, extName = ".ts", meta, options = {} }) {
     const barrelManager = new BarrelManager(options);
     const files = barrelManager.getIndexes(root, extName);
@@ -762,7 +768,7 @@ ${file.source}` : "",
     }
     return await Promise.all(
       files.map((file) => {
-        return this.#addOrAppend({
+        return __privateMethod(this, _addOrAppend, addOrAppend_fn).call(this, {
           ...file,
           meta: meta ? meta : file.meta
         });
@@ -771,29 +777,29 @@ ${file.source}` : "",
   }
   getCacheByUUID(UUID) {
     let cache;
-    this.#cache.forEach((files) => {
+    __privateGet(this, _cache).forEach((files) => {
       cache = files.find((item) => item.id === UUID);
     });
     return cache;
   }
   get(path2) {
-    return this.#cache.get(path2);
+    return __privateGet(this, _cache).get(path2);
   }
   remove(path2) {
     const cacheItem = this.get(path2);
     if (!cacheItem) {
       return;
     }
-    this.#cache.delete(path2);
+    __privateGet(this, _cache).delete(path2);
   }
   async write(...params) {
-    if (!this.#isWriting) {
-      this.#isWriting = true;
+    if (!__privateGet(this, _isWriting)) {
+      __privateSet(this, _isWriting, true);
       const text = await write(...params);
-      this.#isWriting = false;
+      __privateSet(this, _isWriting, false);
       return text;
     }
-    await timeout(this.#timeout);
+    await timeout(__privateGet(this, _timeout));
     return this.write(...params);
   }
   async read(...params) {
@@ -853,6 +859,54 @@ ${file.source}` : "",
     return _FileManager.extensions.some((extension) => baseName.endsWith(extension));
   }
 };
+_cache = new WeakMap();
+_task = new WeakMap();
+_isWriting = new WeakMap();
+_timeout = new WeakMap();
+_queue2 = new WeakMap();
+_validate = new WeakSet();
+validate_fn = function(file) {
+  if (!file.validate) {
+    return;
+  }
+  if (!file.path.toLowerCase().endsWith(file.baseName.toLowerCase())) {
+    throw new Error(`${file.path} should end with the baseName ${file.baseName}`);
+  }
+};
+_add = new WeakSet();
+add_fn = async function(file) {
+  const controller = new AbortController();
+  const resolvedFile = { id: crypto.randomUUID(), ...file };
+  __privateGet(this, _cache).set(resolvedFile.path, [{ cancel: () => controller.abort(), ...resolvedFile }]);
+  if (__privateGet(this, _queue2)) {
+    await __privateGet(this, _queue2).run(
+      async () => {
+        var _a;
+        return (_a = __privateGet(this, _task)) == null ? void 0 : _a.call(this, resolvedFile);
+      },
+      { controller }
+    );
+  }
+  return resolvedFile;
+};
+_addOrAppend = new WeakSet();
+addOrAppend_fn = async function(file) {
+  const previousCaches = __privateGet(this, _cache).get(file.path);
+  const previousCache = previousCaches ? previousCaches.at(previousCaches.length - 1) : void 0;
+  if (previousCache) {
+    __privateGet(this, _cache).delete(previousCache.path);
+    return __privateMethod(this, _add, add_fn).call(this, {
+      ...file,
+      source: previousCache.source && file.source ? `${previousCache.source}
+${file.source}` : "",
+      imports: [...previousCache.imports || [], ...file.imports || []],
+      exports: [...previousCache.exports || [], ...file.exports || []],
+      env: { ...previousCache.env || {}, ...file.env || {} }
+    });
+  }
+  return __privateMethod(this, _add, add_fn).call(this, file);
+};
+var FileManager = _FileManager;
 function combineExports(exports) {
   const combinedExports = orderBy(exports, [(v) => !v.isTypeOnly], ["asc"]).reduce((prev, curr) => {
     const name = curr.name;
@@ -951,10 +1005,8 @@ function getEnvSource(source, env) {
 
 // src/utils/TreeNode.ts
 var TreeNode = class _TreeNode {
-  data;
-  parent;
-  children = [];
   constructor(data, parent) {
+    this.children = [];
     this.data = data;
     this.parent = parent;
     return this;
@@ -1058,7 +1110,6 @@ function setUniqueName(originalName, data) {
   return originalName;
 }
 var URLPath = class {
-  path;
   constructor(path2) {
     this.path = path2;
     return this;