@amazon/vinyl-util 1.0.0

package/dist/types/current/util/collection/CacheMap.d.ts

@@ -0,0 +1,12 @@
+/**
+ * A CacheMap is a Map that notifies when an entry is evicted.
+ */
+export interface CacheMap<K, V> extends Map<K, V> {
+    /**
+     * When an entry is added when at capacity, the least recently used entry will be removed.
+     * This callback can be set to be notified with the element and key being evicted, which may be
+     * used for disposal.
+     */
+    onEvict: ((element: V, key: K, list: CacheMap<K, V>) => void) | null;
+}
+//# sourceMappingURL=CacheMap.d.ts.map

package/dist/types/current/util/collection/CacheMap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CacheMap.d.ts","sourceRoot":"","sources":["../../../../../src/util/collection/CacheMap.ts"],"names":[],"mappings":"AAKA;;GAEG;AACH,MAAM,WAAW,QAAQ,CAAC,CAAC,EAAE,CAAC,CAAE,SAAQ,GAAG,CAAC,CAAC,EAAE,CAAC,CAAC;IAC7C;;;;OAIG;IACH,OAAO,EAAE,CAAC,CAAC,OAAO,EAAE,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,IAAI,EAAE,QAAQ,CAAC,CAAC,EAAE,CAAC,CAAC,KAAK,IAAI,CAAC,GAAG,IAAI,CAAA;CACvE"}

package/dist/types/current/util/collection/CacheMap.js

@@ -0,0 +1,5 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+export {};

package/dist/types/current/util/collection/LinkedList.d.ts

@@ -0,0 +1,165 @@
+/**
+ * A doubly-linked node.
+ *
+ * If a node is to move from one list to another, it must be removed first.
+ */
+export interface LinkedNode<T> {
+    previous: LinkedNode<T> | null;
+    value: T;
+    removed: boolean;
+    next: LinkedNode<T> | null;
+}
+/**
+ * A standard doubly-linked list implementation.
+ */
+export declare class LinkedList<T> implements Iterable<T> {
+    private _head;
+    private _tail;
+    /**
+     * Returns the current head.
+     */
+    get head(): LinkedNode<T> | null;
+    /**
+     * Returns the current tail.
+     */
+    get tail(): LinkedNode<T> | null;
+    /**
+     * Returns true if the list is empty.
+     */
+    get empty(): boolean;
+    /**
+     * Creates a new node for the given value, adding it to the end of the list.
+     *
+     * @param value
+     * @return Returns the newly created node.
+     */
+    push(value: T): LinkedNode<T>;
+    /**
+     * Appends all given values to the end of this list.
+     *
+     * @param values
+     */
+    pushAll(...values: T[]): void;
+    /**
+     * Appends the given node to the tail of this list.
+     * If the node is already at the tail, it will no-op.
+     * If the node is in this list, it will be removed.
+     *
+     * @param node The node to add or move to the tail of this list.
+     */
+    pushNode(node: LinkedNode<T>): void;
+    /**
+     * Removes the last node (the tail), returning it.
+     * If this list is empty, null is returned.
+     */
+    pop(): LinkedNode<T> | null;
+    /**
+     * Creates a new node, adding it to the front of the list.
+     *
+     * @param value The value to box in a linked node.
+     * @return Returns the new node.
+     */
+    unshift(value: T): LinkedNode<T>;
+    /**
+     * Prepends all the given values to the head of this list.
+     * The values will maintain their order.
+     *
+     * E.g.
+     * ```
+     * list.unshiftAll(8, 9, 10)   // 8, 9, 10
+     * list.unshiftAll(4, 5, 6, 7) // 4, 5, 6, 7, 8, 9, 10
+     * list.unshiftAll(1, 2, 3)    // 1, 2, 3, 4, 5, 6, 7, 8, 9, 10
+     * ```
+     *
+     * @param values The values to box in linked nodes.
+     */
+    unshiftAll(...values: T[]): void;
+    /**
+     * Prepends the given node to the head of this list.
+     * - If the node is already at the head, it will no-op.
+     * - If the node is in this list, it will be removed.
+     *
+     * @param node The node to add or move to the head of this list.
+     */
+    unshiftNode(node: LinkedNode<T>): void;
+    /**
+     * Removes the first node (the head), returning it.
+     * - If this list is empty, null is returned.
+     */
+    shift(): LinkedNode<T> | null;
+    /**
+     * Removes the given linked node.
+     *
+     * @param node
+     */
+    remove(node: LinkedNode<T>): void;
+    /**
+     * Inserts the given node before pointer node.
+     *
+     * @param node The node to insert before pointer. If this node is currently in this list, it
+     * will first be removed.
+     * @param pointer The pointer node.
+     */
+    insertNodeBefore(node: LinkedNode<T>, pointer: LinkedNode<T>): void;
+    /**
+     * Inserts the given node after pointer node.
+     *
+     * @param node The node to insert after pointer. If this node is currently in this list, it
+     * will first be removed.
+     * @param pointer The pointer node.
+     */
+    insertNodeAfter(node: LinkedNode<T>, pointer: LinkedNode<T>): void;
+    /**
+     * Iterates over every element, invoking the given callback.
+     *
+     * @param callback
+     */
+    forEach(callback: (element: T) => void): void;
+    /**
+     * Similar to `Array.prototype.some`, returns true if at least one element passes the given
+     * predicate.
+     *
+     * @param predicate
+     */
+    some(predicate: (element: T) => boolean): boolean;
+    /**
+     * Returns the first node matching the given predicate.
+     *
+     * @param predicate A function where, when true is returned, returns the current node.
+     */
+    find(predicate: (element: T) => boolean): LinkedNode<T> | null;
+    /**
+     * Returns the last node matching the given predicate.
+     *
+     * @param predicate A function where, when true is returned, returns the current node.
+     */
+    findLast(predicate: (element: T) => boolean): LinkedNode<T> | null;
+    /**
+     * Clears this list.
+     */
+    clear(): void;
+    /**
+     * Returns a new iterator, starting at the head.
+     */
+    [Symbol.iterator](): IterableIterator<T>;
+    /**
+     * Returns a new reversed iterable where the iterator starts at the tail, moving backwards
+     * to the head.
+     */
+    reversed(): IterableIterator<T>;
+    /**
+     * Creates an iterable iterator, starting at the specified node, getting the next node from
+     * the next() function.
+     *
+     * Note that using iterators is not as performant as {@link some} or {@link forEach}
+     *
+     * @param start The starting node. (inclusive)
+     * @param end The ending node (exclusive).
+     * @param next A method that is given the current node, and returns the next node.
+     */
+    createIterator(start: LinkedNode<T> | null, end: LinkedNode<T> | null, next: (current: LinkedNode<T>) => LinkedNode<T> | null): {
+        [Symbol.iterator](): IterableIterator<T>;
+        next: () => IteratorResult<T>;
+    };
+}
+//# sourceMappingURL=LinkedList.d.ts.map

package/dist/types/current/util/collection/LinkedList.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"LinkedList.d.ts","sourceRoot":"","sources":["../../../../../src/util/collection/LinkedList.ts"],"names":[],"mappings":"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"}

package/dist/types/current/util/collection/LinkedList.js

@@ -0,0 +1,332 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * A standard doubly-linked list implementation.
+ */
+export class LinkedList {
+    _head = null;
+    _tail = null;
+    /**
+     * Returns the current head.
+     */
+    get head() {
+        return this._head;
+    }
+    /**
+     * Returns the current tail.
+     */
+    get tail() {
+        return this._tail;
+    }
+    /**
+     * Returns true if the list is empty.
+     */
+    get empty() {
+        return this._head === null;
+    }
+    /**
+     * Creates a new node for the given value, adding it to the end of the list.
+     *
+     * @param value
+     * @return Returns the newly created node.
+     */
+    push(value) {
+        const node = {
+            previous: this._tail,
+            value,
+            removed: false,
+            next: null,
+        };
+        this.pushNode(node);
+        return node;
+    }
+    /**
+     * Appends all given values to the end of this list.
+     *
+     * @param values
+     */
+    pushAll(...values) {
+        for (const value of values) {
+            this.push(value);
+        }
+    }
+    /**
+     * Appends the given node to the tail of this list.
+     * If the node is already at the tail, it will no-op.
+     * If the node is in this list, it will be removed.
+     *
+     * @param node The node to add or move to the tail of this list.
+     */
+    pushNode(node) {
+        if (this._tail === node)
+            return;
+        this.remove(node);
+        node.removed = false;
+        node.next = null;
+        node.previous = this._tail;
+        if (this._tail)
+            this._tail.next = node;
+        this._tail = node;
+        if (!this._head)
+            this._head = node;
+    }
+    /**
+     * Removes the last node (the tail), returning it.
+     * If this list is empty, null is returned.
+     */
+    pop() {
+        const node = this._tail;
+        if (!node)
+            return null;
+        this.remove(node);
+        return node;
+    }
+    /**
+     * Creates a new node, adding it to the front of the list.
+     *
+     * @param value The value to box in a linked node.
+     * @return Returns the new node.
+     */
+    unshift(value) {
+        const node = {
+            previous: null,
+            value,
+            removed: true,
+            next: this._head,
+        };
+        this.unshiftNode(node);
+        return node;
+    }
+    /**
+     * Prepends all the given values to the head of this list.
+     * The values will maintain their order.
+     *
+     * E.g.
+     * ```
+     * list.unshiftAll(8, 9, 10)   // 8, 9, 10
+     * list.unshiftAll(4, 5, 6, 7) // 4, 5, 6, 7, 8, 9, 10
+     * list.unshiftAll(1, 2, 3)    // 1, 2, 3, 4, 5, 6, 7, 8, 9, 10
+     * ```
+     *
+     * @param values The values to box in linked nodes.
+     */
+    unshiftAll(...values) {
+        for (let i = values.length - 1; i >= 0; i--) {
+            this.unshift(values[i]);
+        }
+    }
+    /**
+     * Prepends the given node to the head of this list.
+     * - If the node is already at the head, it will no-op.
+     * - If the node is in this list, it will be removed.
+     *
+     * @param node The node to add or move to the head of this list.
+     */
+    unshiftNode(node) {
+        if (this._head === node)
+            return;
+        this.remove(node);
+        node.removed = false;
+        node.previous = null;
+        node.next = this._head;
+        if (this._head)
+            this._head.previous = node;
+        this._head = node;
+        if (!this._tail)
+            this._tail = node;
+    }
+    /**
+     * Removes the first node (the head), returning it.
+     * - If this list is empty, null is returned.
+     */
+    shift() {
+        const node = this._head;
+        if (!node)
+            return null;
+        this.remove(node);
+        return node;
+    }
+    /**
+     * Removes the given linked node.
+     *
+     * @param node
+     */
+    remove(node) {
+        if (node.removed)
+            return;
+        node.removed = true;
+        if (node.previous)
+            node.previous.next = node.next;
+        if (node.next)
+            node.next.previous = node.previous;
+        if (this._head === node)
+            this._head = node.next;
+        if (this._tail === node)
+            this._tail = node.previous;
+    }
+    /**
+     * Inserts the given node before pointer node.
+     *
+     * @param node The node to insert before pointer. If this node is currently in this list, it
+     * will first be removed.
+     * @param pointer The pointer node.
+     */
+    insertNodeBefore(node, pointer) {
+        if (!node.removed && node.next === pointer)
+            return;
+        this.remove(node);
+        node.removed = false;
+        if (pointer.previous) {
+            pointer.previous.next = node;
+            node.previous = pointer.previous;
+        }
+        else {
+            this._head = node;
+            node.previous = null;
+        }
+        node.next = pointer;
+        pointer.previous = node;
+    }
+    /**
+     * Inserts the given node after pointer node.
+     *
+     * @param node The node to insert after pointer. If this node is currently in this list, it
+     * will first be removed.
+     * @param pointer The pointer node.
+     */
+    insertNodeAfter(node, pointer) {
+        if (!node.removed && node.previous === pointer)
+            return;
+        this.remove(node);
+        node.removed = false;
+        if (pointer.next) {
+            pointer.next.previous = node;
+            node.next = pointer.next;
+        }
+        else {
+            this._tail = node;
+            node.next = null;
+        }
+        node.previous = pointer;
+        pointer.next = node;
+    }
+    /**
+     * Iterates over every element, invoking the given callback.
+     *
+     * @param callback
+     */
+    forEach(callback) {
+        let current = this._head;
+        while (current) {
+            if (!current.removed)
+                callback(current.value);
+            current = current.next;
+        }
+    }
+    /**
+     * Similar to `Array.prototype.some`, returns true if at least one element passes the given
+     * predicate.
+     *
+     * @param predicate
+     */
+    some(predicate) {
+        let current = this._head;
+        while (current) {
+            if (!current.removed && predicate(current.value))
+                return true;
+            current = current.next;
+        }
+        return false;
+    }
+    /**
+     * Returns the first node matching the given predicate.
+     *
+     * @param predicate A function where, when true is returned, returns the current node.
+     */
+    find(predicate) {
+        let current = this._head;
+        while (current) {
+            if (!current.removed && predicate(current.value))
+                return current;
+            current = current.next;
+        }
+        return null;
+    }
+    /**
+     * Returns the last node matching the given predicate.
+     *
+     * @param predicate A function where, when true is returned, returns the current node.
+     */
+    findLast(predicate) {
+        let current = this._tail;
+        while (current) {
+            if (!current.removed && predicate(current.value))
+                return current;
+            current = current.previous;
+        }
+        return null;
+    }
+    /**
+     * Clears this list.
+     */
+    clear() {
+        let current = this._head;
+        while (current != null) {
+            const next = current.next;
+            current.removed = true;
+            current = next;
+        }
+        this._head = null;
+        this._tail = null;
+    }
+    /**
+     * Returns a new iterator, starting at the head.
+     */
+    [Symbol.iterator]() {
+        return this.createIterator(this._head, null, (node) => node.next);
+    }
+    /**
+     * Returns a new reversed iterable where the iterator starts at the tail, moving backwards
+     * to the head.
+     */
+    reversed() {
+        return this.createIterator(this._tail, null, (node) => node.previous);
+    }
+    /**
+     * Creates an iterable iterator, starting at the specified node, getting the next node from
+     * the next() function.
+     *
+     * Note that using iterators is not as performant as {@link some} or {@link forEach}
+     *
+     * @param start The starting node. (inclusive)
+     * @param end The ending node (exclusive).
+     * @param next A method that is given the current node, and returns the next node.
+     */
+    createIterator(start, end, next) {
+        let current = start;
+        return {
+            [Symbol.iterator]() {
+                return this;
+            },
+            next: () => {
+                if (current === end || !current) {
+                    return {
+                        value: undefined,
+                        done: true,
+                    };
+                }
+                const result = {
+                    value: current.value,
+                    done: false,
+                };
+                current = next(current);
+                while (current?.removed) {
+                    current = next(current);
+                }
+                return result;
+            },
+        };
+    }
+}

package/dist/types/current/util/collection/LruCache.d.ts

@@ -0,0 +1,93 @@
+import type { CacheMap } from './CacheMap';
+/**
+ * An LRU Cache implementation.
+ * An LRU (Least Recently Used) Cache is a Map with a fixed capacity. When the capacity is
+ * exceeded, the least recently used element will be removed.
+ * An element is considered to be used when it has been retrieved via `get`, or when it's been
+ * `set`.
+ * Iteration does not affect ordering.
+ */
+export declare class LruCache<K, V> implements CacheMap<K, V> {
+    /**
+     * A map of the list nodes.
+     *
+     * @private
+     */
+    private cache;
+    /**
+     * Most recently used elements are at the tail, least recently used are at the head.
+     * @private
+     */
+    private list;
+    /**
+     * An element is about to be removed. Should return true if the element may be evicted,
+     * otherwise false.
+     * If false is returned for all elements, an IllegalStateError is thrown.
+     */
+    onEvicting: ((element: V, key: K, list: CacheMap<K, V>) => boolean) | null;
+    /**
+     * When an element is added when at capacity, the least recently used element will be removed.
+     * This callback can be set to be notified with the element being evicted, which may be used
+     * for disposal.
+     */
+    onEvict: ((element: V, key: K, list: CacheMap<K, V>) => void) | null;
+    private _capacity;
+    constructor(initialCapacity: number);
+    get capacity(): number;
+    set capacity(value: number);
+    /**
+     * @returns the number of elements in the Map.
+     */
+    get size(): number;
+    /**
+     * @returns boolean indicating whether an element with the specified key exists or not.
+     */
+    has(key: K): boolean;
+    /**
+     * Returns the mapped value for the given key, and moves the element to the most recently
+     * used position.
+     *
+     * @returns Returns the element associated with the given key, or undefined if no such
+     * element exists.
+     */
+    get(key: K): V | undefined;
+    /**
+     * Adds a new element with a specified key and value to the Map. If an element with the
+     * same key already exists, the element will be updated and position moved to most recently
+     * used.
+     */
+    set(key: K, value: V): this;
+    private evictLeastRecentlyUsed;
+    /**
+     * Clears all elements from the cache.
+     */
+    clear(): void;
+    /**
+     * @returns true if an element in the Map existed and has been removed, or false if the element does not exist.
+     */
+    delete(key: K): boolean;
+    /**
+     * Executes a provided function once per each key/value pair in the Map, in insertion order.
+     *
+     * @param callback A callback to invoke for every element in the cache.
+     * @param thisArg Value to use as this when executing callback
+     */
+    forEach(callback: (value: V, key: K, map: this) => void, thisArg?: any): void;
+    /**
+     * Returns an iterable of key, value pairs for every entry in the map.
+     */
+    entries(): IterableIterator<[K, V]>;
+    /**
+     * Returns an iterable of keys in the map. This will be ordered from least recently used to
+     * most.
+     */
+    keys(): IterableIterator<K>;
+    /**
+     * Returns an iterable of values in the map. This will be ordered from least recently used to
+     * most.
+     */
+    values(): IterableIterator<V>;
+    [Symbol.iterator](): IterableIterator<[K, V]>;
+    get [Symbol.toStringTag](): string;
+}
+//# sourceMappingURL=LruCache.d.ts.map

package/dist/types/current/util/collection/LruCache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"LruCache.d.ts","sourceRoot":"","sources":["../../../../../src/util/collection/LruCache.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAA;AAM1C;;;;;;;GAOG;AACH,qBAAa,QAAQ,CAAC,CAAC,EAAE,CAAC,CAAE,YAAW,QAAQ,CAAC,CAAC,EAAE,CAAC,CAAC;IACjD;;;;OAIG;IACH,OAAO,CAAC,KAAK,CAAwC;IAErD;;;OAGG;IACH,OAAO,CAAC,IAAI,CAA2B;IAEvC;;;;OAIG;IACH,UAAU,EAAE,CAAC,CAAC,OAAO,EAAE,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,IAAI,EAAE,QAAQ,CAAC,CAAC,EAAE,CAAC,CAAC,KAAK,OAAO,CAAC,GAAG,IAAI,CAClE;IAER;;;;OAIG;IACH,OAAO,EAAE,CAAC,CAAC,OAAO,EAAE,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,IAAI,EAAE,QAAQ,CAAC,CAAC,EAAE,CAAC,CAAC,KAAK,IAAI,CAAC,GAAG,IAAI,CAAO;IAE3E,OAAO,CAAC,SAAS,CAAI;gBAET,eAAe,EAAE,MAAM;IAInC,IAAI,QAAQ,IAAI,MAAM,CAErB;IAED,IAAI,QAAQ,CAAC,KAAK,EAAE,MAAM,EAKzB;IAED;;OAEG;IACH,IAAI,IAAI,IAAI,MAAM,CAEjB;IAED;;OAEG;IACH,GAAG,CAAC,GAAG,EAAE,CAAC,GAAG,OAAO;IAIpB;;;;;;OAMG;IACH,GAAG,CAAC,GAAG,EAAE,CAAC,GAAG,CAAC,GAAG,SAAS;IAO1B;;;;OAIG;IACH,GAAG,CAAC,GAAG,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,IAAI;IAe3B,OAAO,CAAC,sBAAsB;IAmB9B;;OAEG;IACH,KAAK,IAAI,IAAI;IAKb;;OAEG;IACH,MAAM,CAAC,GAAG,EAAE,CAAC,GAAG,OAAO;IAQvB;;;;;OAKG;IACH,OAAO,CACH,QAAQ,EAAE,CAAC,KAAK,EAAE,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,GAAG,EAAE,IAAI,KAAK,IAAI,EAC/C,OAAO,CAAC,EAAE,GAAG,GACd,IAAI;IAMP;;OAEG;IACH,OAAO,IAAI,gBAAgB,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;IAInC;;;OAGG;IACH,IAAI,IAAI,gBAAgB,CAAC,CAAC,CAAC;IAI3B;;;OAGG;IACH,MAAM,IAAI,gBAAgB,CAAC,CAAC,CAAC;IAI7B,CAAC,MAAM,CAAC,QAAQ,CAAC,IAAI,gBAAgB,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;IAI7C,IAAI,CAAC,MAAM,CAAC,WAAW,CAAC,IAAI,MAAM,CAEjC;CACJ"}