pluto-http-client
Version:
HTTP client for NodeJS. Inspired in the Java JAX-RS spec so you can expect excellence, versatility and extensibility.
401 lines (400 loc) • 10.6 kB
JavaScript
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.List = exports.TreeMultiValueMap = exports.TreeMap = exports.AscendingOrderTreeMapIterator = exports.SubMapKeyIterator = exports.NumberComparator = exports.PrimitiveMultiValueMap = exports.WrappedPrimitive = exports.MultiValueMap = void 0;
class MultiValueMap {
constructor(_items = new Map) {
this._items = _items;
}
add(obj) {
var _a;
const k = obj.id().toLowerCase();
if (!this._items.has(k)) {
this._items.set(k, new List());
}
(_a = this._items.get(k)) === null || _a === void 0 ? void 0 : _a.push(obj);
return true;
}
get(key) {
return this._items.get(key.toLowerCase());
}
remove(key) {
return this._items.delete(key.toLowerCase());
}
clone() {
const newMap = new Map();
for (let [key, value] of this._items.entries()) {
newMap.set(key, value.clone());
}
return new MultiValueMap(newMap);
}
entries() {
return this._items.entries();
}
}
exports.MultiValueMap = MultiValueMap;
class WrappedPrimitive {
constructor(_key, _value) {
this._key = _key;
this._value = _value;
}
get key() {
return this._key;
}
value() {
return this._value;
}
clone() {
return new WrappedPrimitive(this._key, this._value);
}
equals(other) {
if (other instanceof WrappedPrimitive) {
return this._value === other._value;
}
return false;
}
id() {
return this._key.toString().toLowerCase();
}
}
exports.WrappedPrimitive = WrappedPrimitive;
class PrimitiveMultiValueMap {
constructor() {
this._map = new MultiValueMap();
}
add(key, value) {
return this._map.add(new WrappedPrimitive(key, value));
}
remove(key) {
return this._map.remove(key.toString());
}
entries() {
const o = {};
for (const [key, list] of this._map.entries()) {
let k = key;
const values = [];
for (const [_, p] of list.entries()) {
values.push(p.value());
k = p.key.toString();
}
o[k] = values;
}
return Object.entries(o)[Symbol.iterator]();
}
}
exports.PrimitiveMultiValueMap = PrimitiveMultiValueMap;
class Entry {
constructor(key, value, parent) {
this._key = key;
this._value = value;
this._parent = parent;
}
get key() {
return this._key;
}
get value() {
return this._value;
}
set value(value) {
this._value = value;
}
get left() {
return this._left;
}
set left(value) {
this._left = value;
}
get right() {
return this._right;
}
set right(value) {
this._right = value;
}
get parent() {
return this._parent;
}
}
class NumberComparator {
compare(a, b) {
return a - b;
}
}
exports.NumberComparator = NumberComparator;
class SubMapKeyIterator {
constructor(first, fence) {
this.fence = fence;
this._next = first;
}
next() {
var _a;
let t = this._next;
if (t === undefined || t.key == ((_a = this.fence) === null || _a === void 0 ? void 0 : _a.key))
return {
value: undefined,
done: true
};
else {
this._next = TreeMap.successor(t);
}
return {
value: t === null || t === void 0 ? void 0 : t.value,
done: false
};
}
}
exports.SubMapKeyIterator = SubMapKeyIterator;
class EntryIterator {
constructor(root) {
this.current = root;
}
next() {
let t = this.current;
if (t === undefined) {
return {
value: undefined,
done: true
};
}
else {
this.current = TreeMap.successor(t);
}
return {
value: t,
done: false
};
}
}
class AscendingOrderTreeMapIterator {
constructor(last) {
this.last = last;
this.current = last;
}
next() {
let t = this.current;
if (t === undefined) {
return {
value: undefined,
done: true
};
}
else {
this.current = TreeMap.successor(t);
}
return {
value: t === null || t === void 0 ? void 0 : t.value,
done: false
};
}
}
exports.AscendingOrderTreeMapIterator = AscendingOrderTreeMapIterator;
class TreeMap {
constructor(comparator) {
this.comparator = comparator;
this._size = 0;
}
[Symbol.iterator]() {
return new AscendingOrderTreeMapIterator(this.getFirstEntry());
}
getCeilingEntry(key) {
let p = this._root;
while (p != null) {
let cmp = this.comparator.compare(key, p.key);
if (cmp < 0) {
if (p.left != null)
p = p.left;
else
return p;
}
else if (cmp > 0) {
if (p.right != null) {
p = p.right;
}
else {
let parent = p.parent;
let ch = p;
while (parent != null && ch == parent.right) {
ch = parent;
parent = parent.parent;
}
return parent;
}
}
else
return p;
}
}
getHigherEntry(key) {
let p = this._root;
while (p != null) {
let cmp = this.comparator.compare(key, p.key);
if (cmp < 0) {
if (p.left != null)
p = p.left;
else
return p;
}
else {
if (p.right != null) {
p = p.right;
}
else {
let parent = p.parent;
let ch = p;
while (parent != null && ch == parent.right) {
ch = parent;
parent = parent.parent;
}
return parent;
}
}
}
}
tooHigh(key, hi, hiInclusive, toEnd) {
if (!toEnd) {
let c = this.comparator.compare(key, hi);
if (c > 0 || (c == 0 && !hiInclusive))
return true;
}
return false;
}
absLowest(fromKey, toKey, loInclusive, toInclusive, fromStart = false) {
let e = (fromStart ? this.getFirstEntry() :
(loInclusive ? this.getCeilingEntry(fromKey) :
this.getHigherEntry(fromKey)));
return (e == null || this.tooHigh(e.key, toKey, toInclusive, false)) ? undefined : e;
}
absHighFence(toEnd, hiInclusive, hi) {
return (toEnd ? undefined : (hiInclusive ?
this.getHigherEntry(hi) :
this.getCeilingEntry(hi)));
}
getFirstEntry() {
let p = this._root;
if (p !== undefined)
while (p.left !== undefined)
p = p.left;
return p;
}
subMap(fromKey, toKey, fromInclusive = true, toInclusive = true) {
return {
[Symbol.iterator]: () => new SubMapKeyIterator(this.absLowest(fromKey, toKey, fromInclusive, toInclusive), this.absHighFence(false, toInclusive, toKey))
};
}
entries() {
return {
[Symbol.iterator]: () => {
return new EntryIterator(this.getFirstEntry());
}
};
}
set(k, value) {
let t = this._root;
if (!t) {
this.comparator.compare(k, k);
this._root = new Entry(k, value);
this._size = 1;
return;
}
let cmp;
let parent;
do {
parent = t;
cmp = this.comparator.compare(k, t.key);
if (cmp < 0)
t = t.left;
else if (cmp > 0)
t = t.right;
else {
let old = t.value;
t.value = value;
return old;
}
} while (t !== undefined);
let e = new Entry(k, value, parent);
if (cmp < 0)
parent.left = e;
else
parent.right = e;
this._size++;
}
get size() {
return this._size;
}
static successor(t) {
if (t == null)
return undefined;
else if (t.right != null) {
let p = t.right;
while (p.left != null)
p = p.left;
return p;
}
else {
let p = t.parent;
let ch = t;
while (p != null && ch == p.right) {
ch = p;
p = p.parent;
}
return p;
}
}
}
exports.TreeMap = TreeMap;
class TreeMultiValueMap extends TreeMap {
put(k, value) {
const list = new List([value]);
const ret = super.set(k, list);
if (ret) {
for (const [_, v] of ret.entries()) {
list.push(v);
}
}
return ret;
}
clone() {
const clone = new TreeMultiValueMap(this.comparator);
for (const entry of this.entries()) {
for (const item of entry.value) {
clone.put(entry.key, item);
}
}
return clone;
}
}
exports.TreeMultiValueMap = TreeMultiValueMap;
class List extends Array {
constructor(elements = []) {
super();
this.push(...elements);
}
contains(obj) {
for (let storageElement of this) {
if (storageElement.equals(obj)) {
return true;
}
}
return false;
}
push(...items) {
return super.push(...items.filter(i => !this.contains(i)));
}
clone() {
const v = Array.from(this);
return new List(v);
}
equals(other) {
if (!other) {
return false;
}
if (!(other instanceof List)) {
return false;
}
for (const v of this) {
if (!other.contains(v)) {
return false;
}
}
return true;
}
}
exports.List = List;