@lmvz-ds/components 0.12.3-alpha.4 → 0.12.3

package/dist/cjs/MutableQueue-Bk9tBfaK.js

@@ -0,0 +1,462 @@
+'use strict';
+
+var Effect = require('./Effect-CNhHt4Xb.js');
+
+/**
+ * Creates a new `Deferred`.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const make$1 = Effect.deferredMake;
+const _await = Effect.deferredAwait;
+/**
+ * Exits the `Deferred` with the specified `Exit` value, which will be
+ * propagated to all fibers waiting on the value of the `Deferred`.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const done = Effect.deferredDone;
+/**
+ * Fails the `Deferred` with the specified `Cause`, which will be propagated to
+ * all fibers waiting on the value of the `Deferred`.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const failCause$1 = Effect.deferredFailCause;
+/**
+ * Completes the `Deferred` with interruption. This will interrupt all fibers
+ * waiting on the value of the `Deferred` with the `FiberId` of the fiber
+ * calling this method.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const interrupt = Effect.deferredInterrupt;
+/**
+ * Returns `true` if this `Deferred` has already been completed with a value or
+ * an error, `false` otherwise.
+ *
+ * @since 2.0.0
+ * @category getters
+ */
+const isDone = Effect.deferredIsDone;
+/**
+ * Completes the `Deferred` with the specified value.
+ *
+ * @since 2.0.0
+ * @category utils
+ */
+const succeed$1 = Effect.deferredSucceed;
+/**
+ * Unsafely creates a new `Deferred` from the specified `FiberId`.
+ *
+ * @since 2.0.0
+ * @category unsafe
+ */
+const unsafeMake = Effect.deferredUnsafeMake;
+
+/**
+ * Returns `true` if the specified `Exit` is a `Failure`, `false` otherwise.
+ *
+ * @since 2.0.0
+ * @category refinements
+ */
+const isFailure = Effect.exitIsFailure;
+/**
+ * Returns `true` if the specified `Exit` is a `Success`, `false` otherwise.
+ *
+ * @since 2.0.0
+ * @category refinements
+ */
+const isSuccess = Effect.exitIsSuccess;
+/**
+ * Collects all of the specified exit values into a `Some<Exit<List<A>, E>>`. If
+ * the provided iterable contains no elements, `None` will be returned.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const all = Effect.exitCollectAll;
+/**
+ * Constructs a new `Exit.Failure` from the specified unrecoverable defect.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const die = Effect.exitDie;
+/**
+ * Constructs a new `Exit.Failure` from the specified recoverable error of type
+ * `E`.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const fail = Effect.exitFail;
+/**
+ * Constructs a new `Exit.Failure` from the specified `Cause` of type `E`.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const failCause = Effect.exitFailCause;
+/**
+ * Maps over the `Success` value of the specified exit using the provided
+ * function.
+ *
+ * @since 2.0.0
+ * @category mapping
+ */
+const map = Effect.exitMap;
+/**
+ * @since 2.0.0
+ * @category folding
+ */
+const match = Effect.exitMatch;
+/**
+ * Constructs a new `Exit.Success` containing the specified value of type `A`.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const succeed = Effect.exitSucceed;
+const void_ = Effect.exitVoid;
+/**
+ * Sequentially zips the this result with the specified result or else returns
+ * the failed `Cause<E | E2>`.
+ *
+ * @since 2.0.0
+ * @category zipping
+ */
+const zip = Effect.exitZip;
+/**
+ * Sequentially zips the this result with the specified result discarding the
+ * first element of the tuple or else returns the failed `Cause<E | E2>`.
+ *
+ * @since 2.0.0
+ * @category zipping
+ */
+const zipRight = Effect.exitZipRight;
+
+/**
+ * @since 2.0.0
+ */
+const TypeId$1 = /*#__PURE__*/Symbol.for("effect/MutableList");
+const MutableListProto = {
+  [TypeId$1]: TypeId$1,
+  [Symbol.iterator]() {
+    let done = false;
+    let head = this.head;
+    return {
+      next() {
+        if (done) {
+          return this.return();
+        }
+        if (head == null) {
+          done = true;
+          return this.return();
+        }
+        const value = head.value;
+        head = head.next;
+        return {
+          done,
+          value
+        };
+      },
+      return(value) {
+        if (!done) {
+          done = true;
+        }
+        return {
+          done: true,
+          value
+        };
+      }
+    };
+  },
+  toString() {
+    return Effect.format(this.toJSON());
+  },
+  toJSON() {
+    return {
+      _id: "MutableList",
+      values: Array.from(this).map(Effect.toJSON)
+    };
+  },
+  [Effect.NodeInspectSymbol]() {
+    return this.toJSON();
+  },
+  pipe() {
+    return Effect.pipeArguments(this, arguments);
+  }
+};
+/** @internal */
+const makeNode = value => ({
+  value,
+  removed: false,
+  prev: undefined,
+  next: undefined
+});
+/**
+ * Creates an empty `MutableList`.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const empty = () => {
+  const list = Object.create(MutableListProto);
+  list.head = undefined;
+  list.tail = undefined;
+  list._length = 0;
+  return list;
+};
+/**
+ * Returns `true` if the list contains zero elements, `false`, otherwise.
+ *
+ * @since 2.0.0
+ * @category getters
+ */
+const isEmpty$1 = self => length$1(self) === 0;
+/**
+ * Returns the length of the list.
+ *
+ * @since 2.0.0
+ * @category getters
+ */
+const length$1 = self => self._length;
+/**
+ * Appends the specified element to the end of the `MutableList`.
+ *
+ * @category concatenating
+ * @since 2.0.0
+ */
+const append = /*#__PURE__*/Effect.dual(2, (self, value) => {
+  const node = makeNode(value);
+  if (self.head === undefined) {
+    self.head = node;
+  }
+  if (self.tail === undefined) {
+    self.tail = node;
+  } else {
+    self.tail.next = node;
+    node.prev = self.tail;
+    self.tail = node;
+  }
+  self._length += 1;
+  return self;
+});
+/**
+ * Removes the first value from the list and returns it, if it exists.
+ *
+ * @since 0.0.1
+ */
+const shift = self => {
+  const head = self.head;
+  if (head !== undefined) {
+    remove(self, head);
+    return head.value;
+  }
+  return undefined;
+};
+const remove = (self, node) => {
+  if (node.removed) {
+    return;
+  }
+  node.removed = true;
+  if (node.prev !== undefined && node.next !== undefined) {
+    node.prev.next = node.next;
+    node.next.prev = node.prev;
+  } else if (node.prev !== undefined) {
+    self.tail = node.prev;
+    node.prev.next = undefined;
+  } else if (node.next !== undefined) {
+    self.head = node.next;
+    node.next.prev = undefined;
+  } else {
+    self.tail = undefined;
+    self.head = undefined;
+  }
+  if (self._length > 0) {
+    self._length -= 1;
+  }
+};
+
+/**
+ * @since 2.0.0
+ */
+const TypeId = /*#__PURE__*/Symbol.for("effect/MutableQueue");
+/**
+ * @since 2.0.0
+ * @category symbol
+ */
+const EmptyMutableQueue = /*#__PURE__*/Symbol.for("effect/mutable/MutableQueue/Empty");
+const MutableQueueProto = {
+  [TypeId]: TypeId,
+  [Symbol.iterator]() {
+    return Array.from(this.queue)[Symbol.iterator]();
+  },
+  toString() {
+    return Effect.format(this.toJSON());
+  },
+  toJSON() {
+    return {
+      _id: "MutableQueue",
+      values: Array.from(this).map(Effect.toJSON)
+    };
+  },
+  [Effect.NodeInspectSymbol]() {
+    return this.toJSON();
+  },
+  pipe() {
+    return Effect.pipeArguments(this, arguments);
+  }
+};
+const make = capacity => {
+  const queue = Object.create(MutableQueueProto);
+  queue.queue = empty();
+  queue.capacity = capacity;
+  return queue;
+};
+/**
+ * Creates a new bounded `MutableQueue`.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const bounded = capacity => make(capacity);
+/**
+ * Creates a new unbounded `MutableQueue`.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const unbounded = () => make(undefined);
+/**
+ * Returns the current number of elements in the queue.
+ *
+ * @since 2.0.0
+ * @category getters
+ */
+const length = self => length$1(self.queue);
+/**
+ * Returns `true` if the queue is empty, `false` otherwise.
+ *
+ * @since 2.0.0
+ * @category getters
+ */
+const isEmpty = self => isEmpty$1(self.queue);
+/**
+ * The **maximum** number of elements that a queue can hold.
+ *
+ * **Note**: unbounded queues can still implement this interface with
+ * `capacity = Infinity`.
+ *
+ * @since 2.0.0
+ * @category getters
+ */
+const capacity = self => self.capacity === undefined ? Infinity : self.capacity;
+/**
+ * Offers an element to the queue.
+ *
+ * Returns whether the enqueue was successful or not.
+ *
+ * @since 2.0.0
+ */
+const offer = /*#__PURE__*/Effect.dual(2, (self, value) => {
+  const queueLength = length$1(self.queue);
+  if (self.capacity !== undefined && queueLength === self.capacity) {
+    return false;
+  }
+  append(value)(self.queue);
+  return true;
+});
+/**
+ * Enqueues a collection of values into the queue.
+ *
+ * Returns a `Chunk` of the values that were **not** able to be enqueued.
+ *
+ * @since 2.0.0
+ */
+const offerAll = /*#__PURE__*/Effect.dual(2, (self, values) => {
+  const iterator = values[Symbol.iterator]();
+  let next;
+  let remainder = Effect.empty$2();
+  let offering = true;
+  while (offering && (next = iterator.next()) && !next.done) {
+    offering = offer(next.value)(self);
+  }
+  while (next != null && !next.done) {
+    remainder = Effect.prepend(next.value)(remainder);
+    next = iterator.next();
+  }
+  return Effect.reverse(remainder);
+});
+/**
+ * Dequeues an element from the queue.
+ *
+ * Returns either an element from the queue, or the `def` param.
+ *
+ * **Note**: if there is no meaningful default for your type, you can always
+ * use `poll(MutableQueue.EmptyMutableQueue)`.
+ *
+ * @since 2.0.0
+ */
+const poll = /*#__PURE__*/Effect.dual(2, (self, def) => {
+  if (isEmpty$1(self.queue)) {
+    return def;
+  }
+  return shift(self.queue);
+});
+/**
+ * Dequeues up to `n` elements from the queue.
+ *
+ * Returns a `List` of up to `n` elements.
+ *
+ * @since 2.0.0
+ */
+const pollUpTo = /*#__PURE__*/Effect.dual(2, (self, n) => {
+  let result = Effect.empty$2();
+  let count = 0;
+  while (count < n) {
+    const element = poll(EmptyMutableQueue)(self);
+    if (element === EmptyMutableQueue) {
+      break;
+    }
+    result = Effect.prepend(element)(result);
+    count += 1;
+  }
+  return Effect.reverse(result);
+});
+
+exports.EmptyMutableQueue = EmptyMutableQueue;
+exports._await = _await;
+exports.all = all;
+exports.bounded = bounded;
+exports.capacity = capacity;
+exports.die = die;
+exports.done = done;
+exports.fail = fail;
+exports.failCause = failCause;
+exports.failCause$1 = failCause$1;
+exports.interrupt = interrupt;
+exports.isDone = isDone;
+exports.isEmpty = isEmpty;
+exports.isFailure = isFailure;
+exports.isSuccess = isSuccess;
+exports.length = length;
+exports.make = make$1;
+exports.map = map;
+exports.match = match;
+exports.offer = offer;
+exports.offerAll = offerAll;
+exports.poll = poll;
+exports.pollUpTo = pollUpTo;
+exports.succeed = succeed;
+exports.succeed$1 = succeed$1;
+exports.unbounded = unbounded;
+exports.unsafeMake = unsafeMake;
+exports.void_ = void_;
+exports.zip = zip;
+exports.zipRight = zipRight;