A lightweight TypeScript library for managing various queue and stack structures.
npm install @typescript-package/queueimport {
// Class.
Elements,
Processing,
TaskQueue,
Tasks,
// Abstract.
Queue,
Stack
} from '@typescript-package/queue';Array state elements in data structures such as Stack and Queue.
import { Elements } from '@typescript-package/queue';
let elements = new Elements(
[1, 2, 3, 4], // Array type elements.
15 // Maximum size of the elements.
);
// Appends the value at the end of an array state.
elements.append(5);
console.log(elements.state); // Output: [1, 2, 3, 4, 5]
// Inserts the value at the specified index into the array state.
elements.insert(2, 10);
console.log(elements.state); // Output: [1, 2, 10, 3, 4, 5]
// Adds the values at the beginning of array state.
elements.prepend(0);
console.log(elements.state); // Output: [0, 1, 2, 10, 3, 4, 5]
// Updates the value at the index in the array state.
elements.update(0, 127);
console.log(elements.state); // Output: [127, 1, 2, 10, 3, 4, 5]Class designed for asynchronous processing the promises of void.
import { Processing } from '@typescript-package/queue';
console.group(`Processing`);
let processing = new Processing();
// Adds the promise to the processing and on finally remove.
processing.add(new Promise((resolve, reject) => resolve()));
// Adds the promise to the processing without removing.
processing.add(new Promise((resolve, reject) => resolve()));
// Returns the first process.
console.log(`first, `, processing.first);
// Returns the last process.
console.log(`last, `, processing.last);
// Removes the first process.
processing.delete();
console.groupEnd();A task queue that processes elements concurrently with a specified concurrency limit.
import { TaskQueue } from '@typescript-package/queue';
console.group(`TaskQueue`);
// Initialize the `TaskQueue`.
taskQueue = new TaskQueue(
3, // concurrency
10, // size
1, 2, 3 // items
);
// The maximum number of elements that can be processed concurrently.
console.log(`concurrency, `, taskQueue.concurrency); // Output: 2
// A set containing all elements that have been successfully processed.
console.log(`processed, `, taskQueue.processed); // Output: Set(0)
// Checks whether the queue is empty.
console.log(`isEmpty(), `, taskQueue.isEmpty()); // Output: false
// Checks whether the queue is full.
console.log(`isFull(), `, taskQueue.isFull()); // Output: false
// The maximum queue size.
console.log(`size, `, taskQueue.size); // Output: 10
// The actual queue Elements state - raw array state of the queue.
console.log(`state, `, taskQueue.state); // Output: [1, 2, 3]
// The actual queue length.
console.log(`length, `, taskQueue.length); // Output: 3
// Adds a new element to the queue.
console.log(`enqueue(4), `, taskQueue.enqueue(4));
// The actual queue length.
console.log(`length, `, taskQueue.length); // Output: 4
// Returns the first element in the queue.
console.log(`peek(), `, taskQueue.peek()); // Output: 1
// Returns the first element in the queue.
console.log(`dequeue(), `, taskQueue.dequeue()); // Output: 1
// The actual queue length.
console.log(`length, `, taskQueue.length); // Output: 3
// Adds to the full.
taskQueue.enqueue(5).enqueue(6).enqueue(7).enqueue(8).enqueue(9).enqueue(10).enqueue(11);
// The actual queue Elements state - raw array state of the queue.
console.log(`state, `, taskQueue.state); // Output: [2, 3, 4, 5, 6, 7, 8, 9, 10, 11]
// Waits for all elements in the queue to be processed and returns the set of processed elements.
taskQueue.onCompleted().then(
processed => console.log(`TaskQueue completed`, processed), // Output: Completed Set(10)
reason => console.log(reason)
);
// Starts processing elements in the queue using the provided callback function.
// processingQueue.run(element => console.log(`Processed. `, element)); // Output: Processed {element}
taskQueue.asyncRun(element => console.log(`TaskQueue processed. `, element)).finally(() => console.log(`TaskQueue async Run Completed.`)); // Output: Processed {element}
// A set containing all elements that have been successfully processed.
console.log(`processed, `, taskQueue.processed); // Output: Set(10)
console.groupEnd();A class designed to manage and execute a collection of asynchronous tasks with concurrently control or synchronous tasks.
import { Tasks } from '@typescript-package/queue';
console.group(`Tasks`);
let tasks = new Tasks<number>(true, 3);
tasks.debug().asyncRun(
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20],
element => {},
() => {},
element => {},
'default'
).then(processed => {
console.log(`then()`, processed);
}).finally(() => {
console.log(`finally()`);
})
console.groupEnd();A standard FIFO (First In, First Out) queue.
import { Queue } from '@typescript-package/queue';
// Initialize the new `Queue`.
let queue = new Queue(
10, // size
1, 2, 3 // item
);
// Adds a new element to the queue.
queue.enqueue(4);
// The actual queue Elements state - raw array state of the queue.
console.log(`state,`, queue.state); // Output: [1, 2, 3, 4]
// Returns the first element in the queue.
console.log(`peek(), `, queue.peek()); // Output: 1
// Checks if the queue is empty.
console.log(`isEmpty(),`, queue.isEmpty()); // Output: false
// The maximum queue size.
console.log(`size,`, queue.size); // Output: 10
// The actual queue Elements state - raw array state of the queue.
console.log(`state,`, queue.state); // Output: [1, 2, 3, 4]
// Adds to the full.
queue.enqueue(5).enqueue(6).enqueue(7).enqueue(8).enqueue(9).enqueue(10);
// Checks whether the queue is full.
console.log(`isFull(), `, queue.isFull()); // Output: true
try {
queue.enqueue(11);
} catch(error) {
console.log(error); // Error: Queue is full.
}
// Clears the queue.
console.log(`clear(), `, queue.clear());
// Checks if the queue is empty.
console.log(`isEmpty(),`, queue.isEmpty()); // Output: true
// The actual queue Elements state - raw array state of the queue.
console.log(`state,`, queue.state); // Output: []A standard LIFO (Last In, First Out) queue.
import { Stack } from '@typescript-package/queue';
// Initialize the `Stack`.
let stack = new Stack(
10, // size
1, 2, 3 // items
);
// The actual stack length.
console.log(`length, `, stack.length); // Output: 3
// Adds a new element on the stack.
stack.push(4);
// The maximum stack size.
console.log(`size, `, stack.size); // Output: 10
// The actual stack length.
console.log(`length, `, stack.length); // Output: 4
// Returns the top element on the stack.
console.log(`peek(), `, stack.peek()); // Output: 4
// The actual stack `Elements` state.
console.log(`state, `, stack.state); // Output: [1, 2, 3, 4]
// Removes and returns the top element from the stack.
console.log(`pop(), `, stack.pop()); // Output: 4
// The actual stack `Elements` state.
console.log(`state, `, stack.state); // Output: [1, 2, 3]
// Adds to the full.
stack.push(4).push(5).push(6).push(7).push(8).push(9).push(10);
// The actual stack `Elements` state.
console.log(`state, `, stack.state); // Output: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
// Checks if the stack is full.
console.log(`isFull(), `, stack.isFull()); // Output: true
// Clears the queue.
stack.clear()
// The actual stack `Elements` state.
console.log(`state, `, stack.state); // Output: []
console.log(`isEmpty(), `, stack.isEmpty()); // Output: trueGiven a version number MAJOR.MINOR.PATCH, increment the:
- MAJOR version when you make incompatible API changes,
- MINOR version when you add functionality in a backwards-compatible manner, and
- PATCH version when you make backwards-compatible bug fixes.
Additional labels for pre-release and build metadata are available as extensions to the MAJOR.MINOR.PATCH format.
FAQ How should I deal with revisions in the 0.y.z initial development phase?
The simplest thing to do is start your initial development release at 0.1.0 and then increment the minor version for each subsequent release.
How do I know when to release 1.0.0?
If your software is being used in production, it should probably already be 1.0.0. If you have a stable API on which users have come to depend, you should be 1.0.0. If you’re worrying a lot about backwards compatibility, you should probably already be 1.0.0.
MIT © typescript-package (license)
