xcraft-core-utils 4.3.7 → 4.3.8

package/.editorconfig

@@ -1,9 +1,9 @@
-root = true
-
-[*.{js,jsx,json}]
-indent_style = space
-indent_size = 2
-charset = utf-8
-trim_trailing_whitespace = true
-insert_final_newline = true
-max_line_length = 80
+root = true
+
+[*.{js,jsx,json}]
+indent_style = space
+indent_size = 2
+charset = utf-8
+trim_trailing_whitespace = true
+insert_final_newline = true
+max_line_length = 80

package/.zou-flow

@@ -0,0 +1,3 @@
+[update-version]
+	freezed = true
+	package-json = package.json

package/lib/locks.js

@@ -1,106 +1,106 @@
-'use strict';
-
-const watt = require('gigawatts');
-const locks = require('locks');
-
-class Semaphore {
-  constructor(initialValue = 1) {
-    this._sem = locks.createSemaphore(initialValue);
-    watt.wrapAll(this, 'wait');
-  }
-
-  *wait(next) {
-    yield this._sem.wait(next);
-  }
-
-  signal() {
-    this._sem.signal();
-  }
-}
-
-class Mutex {
-  constructor() {
-    this._mutex = locks.createMutex();
-    watt.wrapAll(this, 'lock');
-  }
-
-  *lock(next) {
-    yield this._mutex.lock(next.arg(0));
-  }
-
-  unlock() {
-    this._mutex.unlock();
-  }
-}
-
-class RecursiveMutex extends Mutex {
-  constructor() {
-    super();
-    this._owner = null;
-    this._refCount = 0;
-    watt.wrapAll(this, 'lock');
-  }
-
-  *lock(owner, next) {
-    if (!owner) {
-      throw new Error('owner missing');
-    }
-
-    if (this._mutex.isLocked && owner === this._owner) {
-      ++this._refCount;
-      return; /* Same owner, continue because already locked */
-    }
-
-    yield* super.lock(next);
-    this._owner = owner;
-    ++this._refCount;
-  }
-
-  unlock(owner) {
-    if (owner !== this._owner) {
-      throw new Error('bad owner');
-    }
-
-    --this._refCount;
-    if (this._refCount < 1) {
-      this._owner = null;
-      super.unlock();
-    }
-  }
-}
-
-class GetMutex {
-  constructor() {
-    this._mutexes = {};
-    watt.wrapAll(this, 'lock');
-  }
-
-  _cleanupMutex(key) {
-    if (!this._mutexes[key] || this._mutexes[key].isLocked) {
-      return;
-    }
-    delete this._mutexes[key];
-  }
-
-  *lock(key, next) {
-    if (this._mutexes[key]) {
-      yield this._mutexes[key].lock(next.arg(0));
-      return;
-    }
-
-    this._mutexes[key] = locks.createMutex();
-    yield this._mutexes[key].lock(next.arg(0));
-  }
-
-  unlock(key) {
-    this._mutexes[key].unlock();
-    this._cleanupMutex(key);
-  }
-}
-
-module.exports = {
-  Mutex,
-  RecursiveMutex,
-  Semaphore,
-  getMutex: new GetMutex(),
-};
+'use strict';
+
+const watt = require('gigawatts');
+const locks = require('locks');
+
+class Semaphore {
+  constructor(initialValue = 1) {
+    this._sem = locks.createSemaphore(initialValue);
+    watt.wrapAll(this, 'wait');
+  }
+
+  *wait(next) {
+    yield this._sem.wait(next);
+  }
+
+  signal() {
+    this._sem.signal();
+  }
+}
+
+class Mutex {
+  constructor() {
+    this._mutex = locks.createMutex();
+    watt.wrapAll(this, 'lock');
+  }
+
+  *lock(next) {
+    yield this._mutex.lock(next.arg(0));
+  }
+
+  unlock() {
+    this._mutex.unlock();
+  }
+}
+
+class RecursiveMutex extends Mutex {
+  constructor() {
+    super();
+    this._owner = null;
+    this._refCount = 0;
+    watt.wrapAll(this, 'lock');
+  }
+
+  *lock(owner, next) {
+    if (!owner) {
+      throw new Error('owner missing');
+    }
+
+    if (this._mutex.isLocked && owner === this._owner) {
+      ++this._refCount;
+      return; /* Same owner, continue because already locked */
+    }
+
+    yield* super.lock(next);
+    this._owner = owner;
+    ++this._refCount;
+  }
+
+  unlock(owner) {
+    if (owner !== this._owner) {
+      throw new Error('bad owner');
+    }
+
+    --this._refCount;
+    if (this._refCount < 1) {
+      this._owner = null;
+      super.unlock();
+    }
+  }
+}
+
+class GetMutex {
+  constructor() {
+    this._mutexes = {};
+    watt.wrapAll(this, 'lock');
+  }
+
+  _cleanupMutex(key) {
+    if (!this._mutexes[key] || this._mutexes[key].isLocked) {
+      return;
+    }
+    delete this._mutexes[key];
+  }
+
+  *lock(key, next) {
+    if (this._mutexes[key]) {
+      yield this._mutexes[key].lock(next.arg(0));
+      return;
+    }
+
+    this._mutexes[key] = locks.createMutex();
+    yield this._mutexes[key].lock(next.arg(0));
+  }
+
+  unlock(key) {
+    this._mutexes[key].unlock();
+    this._cleanupMutex(key);
+  }
+}
+
+module.exports = {
+  Mutex,
+  RecursiveMutex,
+  Semaphore,
+  getMutex: new GetMutex(),
+};

package/lib/ranked-cache.js

@@ -1,87 +1,87 @@
-'use strict';
-
-const EventEmitter = require('events');
-const LinkedList = require('linked-list');
-
-class RankedCache extends EventEmitter {
-  constructor(limit) {
-    super();
-
-    this._limit = limit;
-    this._size = 0;
-    this._linkedList = new LinkedList();
-  }
-
-  /**
-   * Push a new payload or an existing item in the linked cache.
-   *
-   * If the limit is reached, the older item is sent by event emitter to the
-   * `out` topic.
-   *
-   * Note that a RankedCache with a limit <= 0 will just return null.
-   *
-   * @param {*} item - Push an item in the linked cache.
-   * @returns {*} the ranked item (always wrapper in an Item).
-   */
-  rank(item) {
-    if (this._limit <= 0) {
-      return null;
-    }
-
-    const isNew = !(item instanceof LinkedList.Item);
-
-    /* Create the item on the fly if necessary. */
-    if (isNew) {
-      const _item = new LinkedList.Item();
-      _item.payload = item;
-      item = _item;
-    }
-
-    /* Limit the cache to this._limit entries. The less used item is deleted
-     * when the limit is reached.
-     */
-    if (this._size === this._limit) {
-      const prevItem = this._linkedList.head;
-      prevItem.detach();
-      this._size--;
-      this.emit('out', prevItem);
-    }
-
-    if (item.list) {
-      /* When an existing style is used, detach from its current position
-       * and move of one step in the linked-list. The goal is to keep the less
-       * used items in front of the list (head).
-       */
-      const nextItem = item.next;
-      if (nextItem) {
-        item.detach();
-        nextItem.append(item);
-      }
-    } else {
-      /* Add the item to the end of the list. Here, it's still not possible to
-       * be sure that this item will be often used. Anyway, if it's not used
-       * anymore, it will move one-by-one to the front of the list.
-       */
-      this._linkedList.append(item);
-      this._size++;
-    }
-
-    return item;
-  }
-
-  /**
-   * Clear the whole RankedCache.
-   *
-   * All items are sent to the 'out' event.
-   */
-  clear() {
-    let item;
-    while ((item = this._linkedList.head)) {
-      item.detach();
-      this._size--;
-      this.emit('out', item);
-    }
-  }
-}
-
-module.exports = RankedCache;
+'use strict';
+
+const EventEmitter = require('events');
+const LinkedList = require('linked-list');
+
+class RankedCache extends EventEmitter {
+  constructor(limit) {
+    super();
+
+    this._limit = limit;
+    this._size = 0;
+    this._linkedList = new LinkedList();
+  }
+
+  /**
+   * Push a new payload or an existing item in the linked cache.
+   *
+   * If the limit is reached, the older item is sent by event emitter to the
+   * `out` topic.
+   *
+   * Note that a RankedCache with a limit <= 0 will just return null.
+   *
+   * @param {*} item - Push an item in the linked cache.
+   * @returns {*} the ranked item (always wrapper in an Item).
+   */
+  rank(item) {
+    if (this._limit <= 0) {
+      return null;
+    }
+
+    const isNew = !(item instanceof LinkedList.Item);
+
+    /* Create the item on the fly if necessary. */
+    if (isNew) {
+      const _item = new LinkedList.Item();
+      _item.payload = item;
+      item = _item;
+    }
+
+    /* Limit the cache to this._limit entries. The less used item is deleted
+     * when the limit is reached.
+     */
+    if (this._size === this._limit) {
+      const prevItem = this._linkedList.head;
+      prevItem.detach();
+      this._size--;
+      this.emit('out', prevItem);
+    }
+
+    if (item.list) {
+      /* When an existing style is used, detach from its current position
+       * and move of one step in the linked-list. The goal is to keep the less
+       * used items in front of the list (head).
+       */
+      const nextItem = item.next;
+      if (nextItem) {
+        item.detach();
+        nextItem.append(item);
+      }
+    } else {
+      /* Add the item to the end of the list. Here, it's still not possible to
+       * be sure that this item will be often used. Anyway, if it's not used
+       * anymore, it will move one-by-one to the front of the list.
+       */
+      this._linkedList.append(item);
+      this._size++;
+    }
+
+    return item;
+  }
+
+  /**
+   * Clear the whole RankedCache.
+   *
+   * All items are sent to the 'out' event.
+   */
+  clear() {
+    let item;
+    while ((item = this._linkedList.head)) {
+      item.detach();
+      this._size--;
+      this.emit('out', item);
+    }
+  }
+}
+
+module.exports = RankedCache;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "xcraft-core-utils",
-  "version": "4.3.7",
+  "version": "4.3.8",
   "description": "Xcraft utils",
   "main": "index.js",
   "engines": {