@pkerschbaum/code-oss-file-service
Version:
VS Code ([microsoft/vscode](https://github.com/microsoft/vscode)) includes a rich "`FileService`" and "`DiskFileSystemProvider`" abstraction built on top of Node.js core modules (`fs`, `path`) and Electron's `shell` module. This package allows to use that
1,200 lines • 39.2 kB
JavaScript
"use strict";
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
if (kind === "m") throw new TypeError("Private method is not writable");
if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
};
var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
};
var _a, _b, _ReadonlyMapView_source;
Object.defineProperty(exports, "__esModule", { value: true });
exports.ReadonlyMapView = exports.LRUCache = exports.LinkedMap = exports.Touch = exports.ResourceMap = exports.TernarySearchTree = exports.UriIterator = exports.PathIterator = exports.ConfigKeysIterator = exports.StringIterator = exports.setToString = exports.mapToString = exports.getOrSet = void 0;
const arrays_1 = require("../../base/common/arrays");
const strings_1 = require("../../base/common/strings");
function getOrSet(map, key, value) {
let result = map.get(key);
if (result === undefined) {
result = value;
map.set(key, result);
}
return result;
}
exports.getOrSet = getOrSet;
function mapToString(map) {
const entries = [];
map.forEach((value, key) => {
entries.push(`${key} => ${value}`);
});
return `Map(${map.size}) {${entries.join(', ')}}`;
}
exports.mapToString = mapToString;
function setToString(set) {
const entries = [];
set.forEach(value => {
entries.push(value);
});
return `Set(${set.size}) {${entries.join(', ')}}`;
}
exports.setToString = setToString;
class StringIterator {
constructor() {
this._value = '';
this._pos = 0;
}
reset(key) {
this._value = key;
this._pos = 0;
return this;
}
next() {
this._pos += 1;
return this;
}
hasNext() {
return this._pos < this._value.length - 1;
}
cmp(a) {
const aCode = a.charCodeAt(0);
const thisCode = this._value.charCodeAt(this._pos);
return aCode - thisCode;
}
value() {
return this._value[this._pos];
}
}
exports.StringIterator = StringIterator;
class ConfigKeysIterator {
constructor(_caseSensitive = true) {
this._caseSensitive = _caseSensitive;
}
reset(key) {
this._value = key;
this._from = 0;
this._to = 0;
return this.next();
}
hasNext() {
return this._to < this._value.length;
}
next() {
// this._data = key.split(/[\\/]/).filter(s => !!s);
this._from = this._to;
let justSeps = true;
for (; this._to < this._value.length; this._to++) {
const ch = this._value.charCodeAt(this._to);
if (ch === 46 /* Period */) {
if (justSeps) {
this._from++;
}
else {
break;
}
}
else {
justSeps = false;
}
}
return this;
}
cmp(a) {
return this._caseSensitive
? (0, strings_1.compareSubstring)(a, this._value, 0, a.length, this._from, this._to)
: (0, strings_1.compareSubstringIgnoreCase)(a, this._value, 0, a.length, this._from, this._to);
}
value() {
return this._value.substring(this._from, this._to);
}
}
exports.ConfigKeysIterator = ConfigKeysIterator;
class PathIterator {
constructor(_splitOnBackslash = true, _caseSensitive = true) {
this._splitOnBackslash = _splitOnBackslash;
this._caseSensitive = _caseSensitive;
}
reset(key) {
this._from = 0;
this._to = 0;
this._value = key;
this._valueLen = key.length;
for (let pos = key.length - 1; pos >= 0; pos--, this._valueLen--) {
const ch = this._value.charCodeAt(pos);
if (!(ch === 47 /* Slash */ || this._splitOnBackslash && ch === 92 /* Backslash */)) {
break;
}
}
return this.next();
}
hasNext() {
return this._to < this._valueLen;
}
next() {
// this._data = key.split(/[\\/]/).filter(s => !!s);
this._from = this._to;
let justSeps = true;
for (; this._to < this._valueLen; this._to++) {
const ch = this._value.charCodeAt(this._to);
if (ch === 47 /* Slash */ || this._splitOnBackslash && ch === 92 /* Backslash */) {
if (justSeps) {
this._from++;
}
else {
break;
}
}
else {
justSeps = false;
}
}
return this;
}
cmp(a) {
return this._caseSensitive
? (0, strings_1.compareSubstring)(a, this._value, 0, a.length, this._from, this._to)
: (0, strings_1.compareSubstringIgnoreCase)(a, this._value, 0, a.length, this._from, this._to);
}
value() {
return this._value.substring(this._from, this._to);
}
}
exports.PathIterator = PathIterator;
var UriIteratorState;
(function (UriIteratorState) {
UriIteratorState[UriIteratorState["Scheme"] = 1] = "Scheme";
UriIteratorState[UriIteratorState["Authority"] = 2] = "Authority";
UriIteratorState[UriIteratorState["Path"] = 3] = "Path";
UriIteratorState[UriIteratorState["Query"] = 4] = "Query";
UriIteratorState[UriIteratorState["Fragment"] = 5] = "Fragment";
})(UriIteratorState || (UriIteratorState = {}));
class UriIterator {
constructor(_ignorePathCasing) {
this._ignorePathCasing = _ignorePathCasing;
this._states = [];
this._stateIdx = 0;
}
reset(key) {
this._value = key;
this._states = [];
if (this._value.scheme) {
this._states.push(1 /* Scheme */);
}
if (this._value.authority) {
this._states.push(2 /* Authority */);
}
if (this._value.path) {
this._pathIterator = new PathIterator(false, !this._ignorePathCasing(key));
this._pathIterator.reset(key.path);
if (this._pathIterator.value()) {
this._states.push(3 /* Path */);
}
}
if (this._value.query) {
this._states.push(4 /* Query */);
}
if (this._value.fragment) {
this._states.push(5 /* Fragment */);
}
this._stateIdx = 0;
return this;
}
next() {
if (this._states[this._stateIdx] === 3 /* Path */ && this._pathIterator.hasNext()) {
this._pathIterator.next();
}
else {
this._stateIdx += 1;
}
return this;
}
hasNext() {
return (this._states[this._stateIdx] === 3 /* Path */ && this._pathIterator.hasNext())
|| this._stateIdx < this._states.length - 1;
}
cmp(a) {
if (this._states[this._stateIdx] === 1 /* Scheme */) {
return (0, strings_1.compareIgnoreCase)(a, this._value.scheme);
}
else if (this._states[this._stateIdx] === 2 /* Authority */) {
return (0, strings_1.compareIgnoreCase)(a, this._value.authority);
}
else if (this._states[this._stateIdx] === 3 /* Path */) {
return this._pathIterator.cmp(a);
}
else if (this._states[this._stateIdx] === 4 /* Query */) {
return (0, strings_1.compare)(a, this._value.query);
}
else if (this._states[this._stateIdx] === 5 /* Fragment */) {
return (0, strings_1.compare)(a, this._value.fragment);
}
throw new Error();
}
value() {
if (this._states[this._stateIdx] === 1 /* Scheme */) {
return this._value.scheme;
}
else if (this._states[this._stateIdx] === 2 /* Authority */) {
return this._value.authority;
}
else if (this._states[this._stateIdx] === 3 /* Path */) {
return this._pathIterator.value();
}
else if (this._states[this._stateIdx] === 4 /* Query */) {
return this._value.query;
}
else if (this._states[this._stateIdx] === 5 /* Fragment */) {
return this._value.fragment;
}
throw new Error();
}
}
exports.UriIterator = UriIterator;
class TernarySearchTreeNode {
constructor() {
this.height = 1;
}
isEmpty() {
return !this.left && !this.mid && !this.right && !this.value;
}
rotateLeft() {
const tmp = this.right;
this.right = tmp.left;
tmp.left = this;
this.updateHeight();
tmp.updateHeight();
return tmp;
}
rotateRight() {
const tmp = this.left;
this.left = tmp.right;
tmp.right = this;
this.updateHeight();
tmp.updateHeight();
return tmp;
}
updateHeight() {
this.height = 1 + Math.max(this.heightLeft, this.heightRight);
}
balanceFactor() {
return this.heightRight - this.heightLeft;
}
get heightLeft() {
var _c, _d;
return (_d = (_c = this.left) === null || _c === void 0 ? void 0 : _c.height) !== null && _d !== void 0 ? _d : 0;
}
get heightRight() {
var _c, _d;
return (_d = (_c = this.right) === null || _c === void 0 ? void 0 : _c.height) !== null && _d !== void 0 ? _d : 0;
}
}
var Dir;
(function (Dir) {
Dir[Dir["Left"] = -1] = "Left";
Dir[Dir["Mid"] = 0] = "Mid";
Dir[Dir["Right"] = 1] = "Right";
})(Dir || (Dir = {}));
class TernarySearchTree {
constructor(segments) {
this._iter = segments;
}
static forUris(ignorePathCasing = () => false) {
return new TernarySearchTree(new UriIterator(ignorePathCasing));
}
static forPaths() {
return new TernarySearchTree(new PathIterator());
}
static forStrings() {
return new TernarySearchTree(new StringIterator());
}
static forConfigKeys() {
return new TernarySearchTree(new ConfigKeysIterator());
}
clear() {
this._root = undefined;
}
fill(values, keys) {
if (keys) {
const arr = keys.slice(0);
(0, arrays_1.shuffle)(arr);
for (let k of arr) {
this.set(k, values);
}
}
else {
const arr = values.slice(0);
(0, arrays_1.shuffle)(arr);
for (let entry of arr) {
this.set(entry[0], entry[1]);
}
}
}
set(key, element) {
const iter = this._iter.reset(key);
let node;
if (!this._root) {
this._root = new TernarySearchTreeNode();
this._root.segment = iter.value();
}
const stack = [];
// find insert_node
node = this._root;
while (true) {
const val = iter.cmp(node.segment);
if (val > 0) {
// left
if (!node.left) {
node.left = new TernarySearchTreeNode();
node.left.segment = iter.value();
}
stack.push([-1 /* Left */, node]);
node = node.left;
}
else if (val < 0) {
// right
if (!node.right) {
node.right = new TernarySearchTreeNode();
node.right.segment = iter.value();
}
stack.push([1 /* Right */, node]);
node = node.right;
}
else if (iter.hasNext()) {
// mid
iter.next();
if (!node.mid) {
node.mid = new TernarySearchTreeNode();
node.mid.segment = iter.value();
}
stack.push([0 /* Mid */, node]);
node = node.mid;
}
else {
break;
}
}
// set value
const oldElement = node.value;
node.value = element;
node.key = key;
// balance
for (let i = stack.length - 1; i >= 0; i--) {
const node = stack[i][1];
node.updateHeight();
const bf = node.balanceFactor();
if (bf < -1 || bf > 1) {
// needs rotate
const d1 = stack[i][0];
const d2 = stack[i + 1][0];
if (d1 === 1 /* Right */ && d2 === 1 /* Right */) {
//right, right -> rotate left
stack[i][1] = node.rotateLeft();
}
else if (d1 === -1 /* Left */ && d2 === -1 /* Left */) {
// left, left -> rotate right
stack[i][1] = node.rotateRight();
}
else if (d1 === 1 /* Right */ && d2 === -1 /* Left */) {
// right, left -> double rotate right, left
node.right = stack[i + 1][1] = stack[i + 1][1].rotateRight();
stack[i][1] = node.rotateLeft();
}
else if (d1 === -1 /* Left */ && d2 === 1 /* Right */) {
// left, right -> double rotate left, right
node.left = stack[i + 1][1] = stack[i + 1][1].rotateLeft();
stack[i][1] = node.rotateRight();
}
else {
throw new Error();
}
// patch path to parent
if (i > 0) {
switch (stack[i - 1][0]) {
case -1 /* Left */:
stack[i - 1][1].left = stack[i][1];
break;
case 1 /* Right */:
stack[i - 1][1].right = stack[i][1];
break;
case 0 /* Mid */:
stack[i - 1][1].mid = stack[i][1];
break;
}
}
else {
this._root = stack[0][1];
}
}
}
return oldElement;
}
get(key) {
var _c;
return (_c = this._getNode(key)) === null || _c === void 0 ? void 0 : _c.value;
}
_getNode(key) {
const iter = this._iter.reset(key);
let node = this._root;
while (node) {
const val = iter.cmp(node.segment);
if (val > 0) {
// left
node = node.left;
}
else if (val < 0) {
// right
node = node.right;
}
else if (iter.hasNext()) {
// mid
iter.next();
node = node.mid;
}
else {
break;
}
}
return node;
}
has(key) {
const node = this._getNode(key);
return !((node === null || node === void 0 ? void 0 : node.value) === undefined && (node === null || node === void 0 ? void 0 : node.mid) === undefined);
}
delete(key) {
return this._delete(key, false);
}
deleteSuperstr(key) {
return this._delete(key, true);
}
_delete(key, superStr) {
var _c;
const iter = this._iter.reset(key);
const stack = [];
let node = this._root;
// find node
while (node) {
const val = iter.cmp(node.segment);
if (val > 0) {
// left
stack.push([-1 /* Left */, node]);
node = node.left;
}
else if (val < 0) {
// right
stack.push([1 /* Right */, node]);
node = node.right;
}
else if (iter.hasNext()) {
// mid
iter.next();
stack.push([0 /* Mid */, node]);
node = node.mid;
}
else {
break;
}
}
if (!node) {
// node not found
return;
}
if (superStr) {
// removing children, reset height
node.left = undefined;
node.mid = undefined;
node.right = undefined;
node.height = 1;
}
else {
// removing element
node.key = undefined;
node.value = undefined;
}
// BST node removal
if (!node.mid && !node.value) {
if (node.left && node.right) {
// full node
const min = this._min(node.right);
const { key, value, segment } = min;
this._delete(min.key, false);
node.key = key;
node.value = value;
node.segment = segment;
}
else {
// empty or half empty
const newChild = (_c = node.left) !== null && _c !== void 0 ? _c : node.right;
if (stack.length > 0) {
const [dir, parent] = stack[stack.length - 1];
switch (dir) {
case -1 /* Left */:
parent.left = newChild;
break;
case 0 /* Mid */:
parent.mid = newChild;
break;
case 1 /* Right */:
parent.right = newChild;
break;
}
}
else {
this._root = newChild;
}
}
}
// AVL balance
for (let i = stack.length - 1; i >= 0; i--) {
const node = stack[i][1];
node.updateHeight();
const bf = node.balanceFactor();
if (bf > 1) {
// right heavy
if (node.right.balanceFactor() >= 0) {
// right, right -> rotate left
stack[i][1] = node.rotateLeft();
}
else {
// right, left -> double rotate
node.right = node.right.rotateRight();
stack[i][1] = node.rotateLeft();
}
}
else if (bf < -1) {
// left heavy
if (node.left.balanceFactor() <= 0) {
// left, left -> rotate right
stack[i][1] = node.rotateRight();
}
else {
// left, right -> double rotate
node.left = node.left.rotateLeft();
stack[i][1] = node.rotateRight();
}
}
// patch path to parent
if (i > 0) {
switch (stack[i - 1][0]) {
case -1 /* Left */:
stack[i - 1][1].left = stack[i][1];
break;
case 1 /* Right */:
stack[i - 1][1].right = stack[i][1];
break;
case 0 /* Mid */:
stack[i - 1][1].mid = stack[i][1];
break;
}
}
else {
this._root = stack[0][1];
}
}
}
_min(node) {
while (node.left) {
node = node.left;
}
return node;
}
findSubstr(key) {
const iter = this._iter.reset(key);
let node = this._root;
let candidate = undefined;
while (node) {
const val = iter.cmp(node.segment);
if (val > 0) {
// left
node = node.left;
}
else if (val < 0) {
// right
node = node.right;
}
else if (iter.hasNext()) {
// mid
iter.next();
candidate = node.value || candidate;
node = node.mid;
}
else {
break;
}
}
return node && node.value || candidate;
}
findSuperstr(key) {
const iter = this._iter.reset(key);
let node = this._root;
while (node) {
const val = iter.cmp(node.segment);
if (val > 0) {
// left
node = node.left;
}
else if (val < 0) {
// right
node = node.right;
}
else if (iter.hasNext()) {
// mid
iter.next();
node = node.mid;
}
else {
// collect
if (!node.mid) {
return undefined;
}
else {
return this._entries(node.mid);
}
}
}
return undefined;
}
forEach(callback) {
for (const [key, value] of this) {
callback(value, key);
}
}
*[Symbol.iterator]() {
yield* this._entries(this._root);
}
*_entries(node) {
// DFS
if (!node) {
return;
}
if (node.left) {
yield* this._entries(node.left);
}
if (node.value) {
yield [node.key, node.value];
}
if (node.mid) {
yield* this._entries(node.mid);
}
if (node.right) {
yield* this._entries(node.right);
}
}
// for debug/testing
_isBalanced() {
const nodeIsBalanced = (node) => {
if (!node) {
return true;
}
const bf = node.balanceFactor();
if (bf < -1 || bf > 1) {
return false;
}
return nodeIsBalanced(node.left) && nodeIsBalanced(node.right);
};
return nodeIsBalanced(this._root);
}
}
exports.TernarySearchTree = TernarySearchTree;
class ResourceMapEntry {
constructor(uri, value) {
this.uri = uri;
this.value = value;
}
}
class ResourceMap {
constructor(mapOrKeyFn, toKey) {
this[_a] = 'ResourceMap';
if (mapOrKeyFn instanceof ResourceMap) {
this.map = new Map(mapOrKeyFn.map);
this.toKey = toKey !== null && toKey !== void 0 ? toKey : ResourceMap.defaultToKey;
}
else {
this.map = new Map();
this.toKey = mapOrKeyFn !== null && mapOrKeyFn !== void 0 ? mapOrKeyFn : ResourceMap.defaultToKey;
}
}
set(resource, value) {
this.map.set(this.toKey(resource), new ResourceMapEntry(resource, value));
return this;
}
get(resource) {
var _c;
return (_c = this.map.get(this.toKey(resource))) === null || _c === void 0 ? void 0 : _c.value;
}
has(resource) {
return this.map.has(this.toKey(resource));
}
get size() {
return this.map.size;
}
clear() {
this.map.clear();
}
delete(resource) {
return this.map.delete(this.toKey(resource));
}
forEach(clb, thisArg) {
if (typeof thisArg !== 'undefined') {
clb = clb.bind(thisArg);
}
for (let [_, entry] of this.map) {
clb(entry.value, entry.uri, this);
}
}
*values() {
for (let entry of this.map.values()) {
yield entry.value;
}
}
*keys() {
for (let entry of this.map.values()) {
yield entry.uri;
}
}
*entries() {
for (let entry of this.map.values()) {
yield [entry.uri, entry.value];
}
}
*[(_a = Symbol.toStringTag, Symbol.iterator)]() {
for (let [, entry] of this.map) {
yield [entry.uri, entry.value];
}
}
}
exports.ResourceMap = ResourceMap;
ResourceMap.defaultToKey = (resource) => resource.toString();
var Touch;
(function (Touch) {
Touch[Touch["None"] = 0] = "None";
Touch[Touch["AsOld"] = 1] = "AsOld";
Touch[Touch["AsNew"] = 2] = "AsNew";
})(Touch = exports.Touch || (exports.Touch = {}));
class LinkedMap {
constructor() {
this[_b] = 'LinkedMap';
this._map = new Map();
this._head = undefined;
this._tail = undefined;
this._size = 0;
this._state = 0;
}
clear() {
this._map.clear();
this._head = undefined;
this._tail = undefined;
this._size = 0;
this._state++;
}
isEmpty() {
return !this._head && !this._tail;
}
get size() {
return this._size;
}
get first() {
var _c;
return (_c = this._head) === null || _c === void 0 ? void 0 : _c.value;
}
get last() {
var _c;
return (_c = this._tail) === null || _c === void 0 ? void 0 : _c.value;
}
has(key) {
return this._map.has(key);
}
get(key, touch = 0 /* None */) {
const item = this._map.get(key);
if (!item) {
return undefined;
}
if (touch !== 0 /* None */) {
this.touch(item, touch);
}
return item.value;
}
set(key, value, touch = 0 /* None */) {
let item = this._map.get(key);
if (item) {
item.value = value;
if (touch !== 0 /* None */) {
this.touch(item, touch);
}
}
else {
item = { key, value, next: undefined, previous: undefined };
switch (touch) {
case 0 /* None */:
this.addItemLast(item);
break;
case 1 /* AsOld */:
this.addItemFirst(item);
break;
case 2 /* AsNew */:
this.addItemLast(item);
break;
default:
this.addItemLast(item);
break;
}
this._map.set(key, item);
this._size++;
}
return this;
}
delete(key) {
return !!this.remove(key);
}
remove(key) {
const item = this._map.get(key);
if (!item) {
return undefined;
}
this._map.delete(key);
this.removeItem(item);
this._size--;
return item.value;
}
shift() {
if (!this._head && !this._tail) {
return undefined;
}
if (!this._head || !this._tail) {
throw new Error('Invalid list');
}
const item = this._head;
this._map.delete(item.key);
this.removeItem(item);
this._size--;
return item.value;
}
forEach(callbackfn, thisArg) {
const state = this._state;
let current = this._head;
while (current) {
if (thisArg) {
callbackfn.bind(thisArg)(current.value, current.key, this);
}
else {
callbackfn(current.value, current.key, this);
}
if (this._state !== state) {
throw new Error(`LinkedMap got modified during iteration.`);
}
current = current.next;
}
}
keys() {
const map = this;
const state = this._state;
let current = this._head;
const iterator = {
[Symbol.iterator]() {
return iterator;
},
next() {
if (map._state !== state) {
throw new Error(`LinkedMap got modified during iteration.`);
}
if (current) {
const result = { value: current.key, done: false };
current = current.next;
return result;
}
else {
return { value: undefined, done: true };
}
}
};
return iterator;
}
values() {
const map = this;
const state = this._state;
let current = this._head;
const iterator = {
[Symbol.iterator]() {
return iterator;
},
next() {
if (map._state !== state) {
throw new Error(`LinkedMap got modified during iteration.`);
}
if (current) {
const result = { value: current.value, done: false };
current = current.next;
return result;
}
else {
return { value: undefined, done: true };
}
}
};
return iterator;
}
entries() {
const map = this;
const state = this._state;
let current = this._head;
const iterator = {
[Symbol.iterator]() {
return iterator;
},
next() {
if (map._state !== state) {
throw new Error(`LinkedMap got modified during iteration.`);
}
if (current) {
const result = { value: [current.key, current.value], done: false };
current = current.next;
return result;
}
else {
return { value: undefined, done: true };
}
}
};
return iterator;
}
[(_b = Symbol.toStringTag, Symbol.iterator)]() {
return this.entries();
}
trimOld(newSize) {
if (newSize >= this.size) {
return;
}
if (newSize === 0) {
this.clear();
return;
}
let current = this._head;
let currentSize = this.size;
while (current && currentSize > newSize) {
this._map.delete(current.key);
current = current.next;
currentSize--;
}
this._head = current;
this._size = currentSize;
if (current) {
current.previous = undefined;
}
this._state++;
}
addItemFirst(item) {
// First time Insert
if (!this._head && !this._tail) {
this._tail = item;
}
else if (!this._head) {
throw new Error('Invalid list');
}
else {
item.next = this._head;
this._head.previous = item;
}
this._head = item;
this._state++;
}
addItemLast(item) {
// First time Insert
if (!this._head && !this._tail) {
this._head = item;
}
else if (!this._tail) {
throw new Error('Invalid list');
}
else {
item.previous = this._tail;
this._tail.next = item;
}
this._tail = item;
this._state++;
}
removeItem(item) {
if (item === this._head && item === this._tail) {
this._head = undefined;
this._tail = undefined;
}
else if (item === this._head) {
// This can only happen if size === 1 which is handled
// by the case above.
if (!item.next) {
throw new Error('Invalid list');
}
item.next.previous = undefined;
this._head = item.next;
}
else if (item === this._tail) {
// This can only happen if size === 1 which is handled
// by the case above.
if (!item.previous) {
throw new Error('Invalid list');
}
item.previous.next = undefined;
this._tail = item.previous;
}
else {
const next = item.next;
const previous = item.previous;
if (!next || !previous) {
throw new Error('Invalid list');
}
next.previous = previous;
previous.next = next;
}
item.next = undefined;
item.previous = undefined;
this._state++;
}
touch(item, touch) {
if (!this._head || !this._tail) {
throw new Error('Invalid list');
}
if ((touch !== 1 /* AsOld */ && touch !== 2 /* AsNew */)) {
return;
}
if (touch === 1 /* AsOld */) {
if (item === this._head) {
return;
}
const next = item.next;
const previous = item.previous;
// Unlink the item
if (item === this._tail) {
// previous must be defined since item was not head but is tail
// So there are more than on item in the map
previous.next = undefined;
this._tail = previous;
}
else {
// Both next and previous are not undefined since item was neither head nor tail.
next.previous = previous;
previous.next = next;
}
// Insert the node at head
item.previous = undefined;
item.next = this._head;
this._head.previous = item;
this._head = item;
this._state++;
}
else if (touch === 2 /* AsNew */) {
if (item === this._tail) {
return;
}
const next = item.next;
const previous = item.previous;
// Unlink the item.
if (item === this._head) {
// next must be defined since item was not tail but is head
// So there are more than on item in the map
next.previous = undefined;
this._head = next;
}
else {
// Both next and previous are not undefined since item was neither head nor tail.
next.previous = previous;
previous.next = next;
}
item.next = undefined;
item.previous = this._tail;
this._tail.next = item;
this._tail = item;
this._state++;
}
}
toJSON() {
const data = [];
this.forEach((value, key) => {
data.push([key, value]);
});
return data;
}
fromJSON(data) {
this.clear();
for (const [key, value] of data) {
this.set(key, value);
}
}
}
exports.LinkedMap = LinkedMap;
class LRUCache extends LinkedMap {
constructor(limit, ratio = 1) {
super();
this._limit = limit;
this._ratio = Math.min(Math.max(0, ratio), 1);
}
get limit() {
return this._limit;
}
set limit(limit) {
this._limit = limit;
this.checkTrim();
}
get ratio() {
return this._ratio;
}
set ratio(ratio) {
this._ratio = Math.min(Math.max(0, ratio), 1);
this.checkTrim();
}
get(key, touch = 2 /* AsNew */) {
return super.get(key, touch);
}
peek(key) {
return super.get(key, 0 /* None */);
}
set(key, value) {
super.set(key, value, 2 /* AsNew */);
this.checkTrim();
return this;
}
checkTrim() {
if (this.size > this._limit) {
this.trimOld(Math.round(this._limit * this._ratio));
}
}
}
exports.LRUCache = LRUCache;
/**
* Wraps the map in type that only implements readonly properties. Useful
* in the extension host to prevent the consumer from making any mutations.
*/
class ReadonlyMapView {
constructor(source) {
_ReadonlyMapView_source.set(this, void 0);
__classPrivateFieldSet(this, _ReadonlyMapView_source, source, "f");
}
get size() {
return __classPrivateFieldGet(this, _ReadonlyMapView_source, "f").size;
}
forEach(callbackfn, thisArg) {
__classPrivateFieldGet(this, _ReadonlyMapView_source, "f").forEach(callbackfn, thisArg);
}
get(key) {
return __classPrivateFieldGet(this, _ReadonlyMapView_source, "f").get(key);
}
has(key) {
return __classPrivateFieldGet(this, _ReadonlyMapView_source, "f").has(key);
}
entries() {
return __classPrivateFieldGet(this, _ReadonlyMapView_source, "f").entries();
}
keys() {
return __classPrivateFieldGet(this, _ReadonlyMapView_source, "f").keys();
}
values() {
return __classPrivateFieldGet(this, _ReadonlyMapView_source, "f").values();
}
[(_ReadonlyMapView_source = new WeakMap(), Symbol.iterator)]() {
return __classPrivateFieldGet(this, _ReadonlyMapView_source, "f").entries();
}
}
exports.ReadonlyMapView = ReadonlyMapView;
//# sourceMappingURL=map.js.map