Common tools (ct, also @vyacheslav97/ct)

Common tools (hereinafter referred to as ct) - a common JavaScript data structures and associated processing procedures package (package repository).

Tip: questions bother your head? Feel free to contact me

Current version renewals (1.0.4) (see Prerequesites a bit below):

• Added several extra iterable converters: createMapToMap, createArrayToArray, createSetToSet, createStringToString
• Added two aliases, groupByKey, groupByKey for duplicates searcher procedure
• uniqueValuesSearcher procedure was implemented (see below)

Next scheduled major updates:

• Table class template
• Default pathfinder template based on BFS algorithm
• Default leveling step function based on DFS algorithm

Prerequisites

tsconfig.json moduleResolution has to be set to node

Module guts

• Universal iterable converter (UIC)
• Universal iterable converter (standard data structures, UICSDS)
• Graph abstract class
• Tree abstract class
• Mutations history template class
• ErrorWithData template class
• Binary search procedure template
• Duplicates search procedure template
• Unique values search procedure template
• isNumber
• Decimal integer RegExp
• Decimal float RegExp
• Exponential format number RegExp

Universal iterable converter (UIC)

UIC module provides a user with two functions: transformToIterable and its wrapper, createIterableTransformer. UIC module is represented by uic.ts file of original project.

transformToIterable is a core procedure - it defines the way an input iterable is converted to an output one. createIterableTransformer wraps transformToIterable to create an iterable convertor with encapsulated target iterable constructor.

transformToIterable algorithm essentials:

• Accepts 3 arguments: source iterable object, target iterable constructor and source iterable value converter (the last is optional)
• Sometimes source iterable can be consumed by target iterable constructor as it is, then source iterable value converter may be omitted
• Otherwise, a proxy iterable is created, that wraps source iterable values in source iterable value converter. Then this proxy iterable is passed to a target iterable constructor

Usage notes

UIC members can be imported as follows:

1import {createIterableTransformer, transformToIterable} from '@vyacheslav97/ct';

createIterableTransformer is highly recommended for usage instead of transformToIterable to avoid redundant target iterable constructor referencing. For example, lets inspect a createIterableTransformer application from uicsds.ts:

1/**
2 * Creates <u>**Array**</u> to <u>**Map**</u> converter
3 * @param arrayItemTransformer <u>**Array**</u> item transformer, derives key-value pair from array item
4 */
5export function createArrayToMap<ArrayItemType, K, V>(
6    arrayItemTransformer: SingleToPair<ArrayItemType, K, V>,
7) {
8    return createIterableTransformer<ArrayItemType[], [K, V], Map<K, V>>(Map, arrayItemTransformer);
9}

createArrayToMap creates an Array to Map transformer. All such transformer needs to be utilized is an array item transform function, which converts an array item to key-value pair for Map constructor. Here goes an createArrayToMap application example:

1
2// Clarifies the rule how to transform array item to a key-value pair list

3const shiftedArrayItemToMapItemTransformer: SingleToPair<number, number, number>
4    = (number): [number, number] => [number, number + 1];
5
6// Creates array to map converter with certain array item rule transformation

7const arrayToMapShifted = createArrayToMap<number, number, number>(shiftedArrayItemToMapItemTransformer);
8
9arrayToMapShifted([1, 2, 3]) //--> {1 -> 2, 2 -> 3, 3 -> 4} - final Map object content

Remember, you are able to create your own custom iterable transformers!

Universal iterable converter (standard data structures, UICSDS)

UICSDS module consists of createIterableTransformer applications to built-in JavaScript iterable datastructures. uicsds.ts represents UICSDS module content.

UICSDS module members can be imported as follows:

1import {createArrayToMap, createMapToSet} from '@vyacheslav97/ct';

Usage notes

It's pretty easy to use:

• first, just import caught your eye transformer creator
• then specify source iterable transformation function
• finally create your iterable converter

Example:

1// All needed type aliases for conversion laws can be imported as follows:
2import {
3  SingleToPair,
4  SingleToSingle,
5  PairToSingle
6} from "@vyacheslav97/ct";
7
8// Map item to a character transformer 
9const keyValuePairConcatenatedTransformer: PairToSingle<number, number, string>
10    = (pair) => pair.join('');
11
12// Create transformer itself 
13const keyValuePairConcatenated = createMapToString(keyValuePairConcatenatedTransformer);
14
15keyValuepairConcatenated(new Map([[1, 1], [2, 2]])); // results in '1122'
16

Graph abstract class

Graph abstract class implements directed graph abstraction with basic graph content manipulations: adding nodes, deleting nodes.

Graph node is represented via following generic interface:

1interface GraphNodeInterface<NodeData = void> {
2    nodeId: string, // unic graph node identifier
3    // set of other graph nodes ids, from which boundaries are received
4    incomingBoundaries: Map<string, string>,
5    // set of other graph nodes which receive boundaries from a given node
6    outgoingBoundaries: Map<string, string>,
7    // Extra node data, may be ommited
8    nodeData?: NodeData,
9}

Graph class itself implements next interface:

1interface GraphInterface<NodeData = void> {
2	// base data structure containing all graph nodes
3    nodes: Map<string, GraphNodeInterface<NodeData>>,
4    
5    getNode: (nodeId: string) => GraphNodeInterface<NodeData> | undefined,
6    getNodeData: (nodeId: string) => NodeData | undefined,
7
8	
9    hasNode: (nodeId: string) => boolean,
10    addNode: (node: GraphNodeInterface<NodeData>) => void,
11    removeNode: (nodeId: string) => GraphNodeInterface<NodeData> | undefined,
12
13    flatten: (startNodeId: string) => Iterable<GraphNodeInterface<NodeData>>,
14    buildPath: (startNodeId: string, endNodeId: string) => GraphNodeInterface<NodeData>[] | undefined,
15}

Some methods are not covered above:

• setFlattenProcedure - initializes flatten method via user defined leveling step function
• setPathFinderProcedure - initializes buildPath method via user defined pathfinder
• buildFlattenProcedure, buildPathFinder - are used for two previous method, it is highly recommended to avoid calling these methods
• clear - removes all nodes from a Graph instance (so nodes Map becomes empty)

Usage notes

Import Graph class:

1import {Graph} from '@vyacheslav97/ct';

Initialization

Graph can be initialized via its constructor if proper set of arguments is passed.

Graph constructor expects following arguments:

1constructor(
2    sourceIterable?: Iterable<[string, GraphNodeInterface<NodeData>]>,
3    config?: GraphConfig<NodeData>,
4)

Where GraphConfig:

1interface GraphConfig<NodeData = void> {
2    levelingStepFunction?: LevelingStepFunction<NodeData>,
3    pathFinder?: PathBuilder<NodeData>,
4}
5
6type LevelingStepFunction<NodeData = void> = (

7    currentNode: GraphNodeInterface<NodeData>,

8    sourceGraph: GraphInterface<NodeData>,
9) => GraphNodeInterface<NodeData> | null;
10
11type PathBuilder<NodeData = void> = (

12    startNode: GraphNodeInterface<NodeData>,

13    endNode: GraphNodeInterface<NodeData>,

14    sourceGraph: GraphInterface<NodeData>,
15) => GraphNodeInterface<NodeData>[];
16

Graph constructor utilizes addNode method under the hood: all nodes from sourceIterable are added keeping their input order. Particularly, if some input node references to inexistent node or has some other wrong data, error will be thrown

BE ADVISED!!! Graph constructor, as well as Tree constructor, as well as both classes addNode methods mutate their arguments.

If no constructor arguments are specified, empty graph instance is created.

Soon graph instance was created, nodes can be added to it via addMethod:

1/**
2 * Adds node to graph. Throws error if node of the same id already exists
3 * @param nodeToAdd node to add, GraphNodeInterface<**NodeData**>
4 */
5addNode(nodeToAdd: GraphNodeInterface<NodeData>)

addNode adds a node to graph instance and all specified within that node edges.

Any node of graph instance can be retrieved using getNode method:

1/**
2 * Returns graph node of specified id, if graph has node with such id
3 * @param nodeId target node id, **string**
4 */
5getNode(nodeId: string)

To retrieve nodeData you can use method getNodeData, which expects target node id as an argument.

To check whether graph possesses a node, use hasNode method (expects node id as an argument).

To remove some specific node, use removeNode method:

1/**
2 * Removes node of given id. Does nothing if wrong id is provided
3 * @param nodeId id of node to remove, **string**
4 */
5removeNode(nodeId: string)

If graph is needed to be flattened, use flatten method. It returns an iterable, which can be used to convert a graph instance into array.

To find path between two specific nodes of given graph, use buildPath method.

flatten and builtPath have own peculiarities: both can be overridden, but only flatten has default behavior - it returns nodes field values iterable if no custom flatten procedure is specified.

To override flatten procedure, use setFlattenProcedure method.

Example:

1// Has to gain one node from another. If it turns impossible - returns null
2const levelingStepFunction: LevelingStepFunction<unknown> = ( // function for "linked list"
3    currentNode: GraphNodeInterface<unknown>,
4    graph: GraphInterface<unknown>,
5) => {
6    const {
7        outgoingBoundaries,
8    } = currentNode;
9    const firstOutgoingBoundary = [...outgoingBoundaries]?.[0]?.[0];
10
11    return graph.getNode(firstOutgoingBoundary) || null;
12
13};
14
15const graph = new Graph();
16
17graph.setFlattenProcedure(levelingStepFunction);
18
19// then call [...graph.flatten('someStartNodeId')], for example, or use for ... of, or whatever
20

To initialize or override buildPath method, call setPathFinderProcedure method.

Example:

1// Simple pathfinder for "linked list" 
2const pathFinder: PathBuilder<unknown> = (
3    startNode: GraphNodeInterface<unknown>,
4    endNode: GraphNodeInterface<unknown>,
5    graph: GraphInterface<unknown>,
6) => {
7
8    let currentNode: GraphNodeInterface<unknown> = startNode;
9    const result: GraphNodeInterface<unknown>[] = [];
10
11    do {
12        result.push(currentNode);
13        currentNode = graph.getNode([...currentNode.outgoingBoundaries]?.[0]?.[0])!;
14    } while(result[result.length - 1]?.nodeId !== endNode.nodeId)
15
16    return result;
17
18};
19
20const graph = new Graph();
21graph.setPathFinderProcedure(pathFinder);
22
23// here you go, call graph.buildPath('startNodeId', 'endNodeId');
24// BUT REMEMBER: invalid node ids (e.g. absent one) will trigger an error
25

buildPath call with no initialization triggers an error.

Tree abstract class

Import Tree class:

1import {Tree} from '@vyacheslav97/ct';

Tree abstract class extends Graph abstract class. This extension brings in following mutations:

• addNode:

  1/**
  2 * Adds node to a tree instance, avoiding loops generation
  3 * @param nodeToAdd node data to add
  4 *
  5 * Throws error, if:
  6 * - Has more than one incoming or outgoing boundary
  7 * - First added node has **parentNodeId**
  8 * - Node of the same **nodeId** already exists on a tree instance
  9 * - Node has **parentNodeId** out of its **incomingBoundaries** or **outgoingBoundaries**
  10 */
  11addNode(nodeToAdd: GraphNodeInterface<NodeData>)

• removeNode:

  1/**
  2 * Removes a node from a tree instance (and the node whole subtree by default)
  3 * Doesn't remove a node if it doesn't exist on the tree instance
  4 * @param nodeId id of node to remove
  5 * @param deleteSubTree if true (by default) node and its subtree are removed
  6 */
  7removeNode(nodeId: string, deleteSubTree = true)

• rootNodeId added - it contains tree root node id

• nodeData field becomes mandatory (but remains extensible): it has to contain parentNodeId field for each tree node except root one

• clear method calls Graph class clear method and sets rootNodeId = '' (empty string)

• Tree constructor adds nodes using its addNode method

• Each leaf node now has isLeaf nodeData property, set to true. It is handled automatically, so no needs to mess with it manually.

Mutations history template class

MutationsHistory template class import:

1import {MutationsHistory} from '@vyacheslav97/ct';

MutationsHistory implements changes history abstract mechanism. It is described via following interface:

1interface MutationsHistoryInterface<HistoryUnitType> {
2
3    lastSavedChangeIndex: number,
4
5    commitedMutations: HistoryUnitType[],
6    canceledMutations: HistoryUnitType[],
7
8    getCurrentMutation: () => HistoryUnitType | undefined,
9
10    addMutation: (mutation: HistoryUnitType) => void,
11    cancelLastMutation: () => void,
12    restoreCanceledMutation: () => void,
13    saveCurrentMutation: () => void,
14    backToSavedMutation: () => void,
15
16
17    saveAndClear: () => void,
18    clearHistory: () => void,
19
20}

MutationshHistory API

Data:

• commitedMutations stack - stack of committed changes
• canceledMutations stack - stack of canceled changes
• lastSavedChangeIndex - index of last saved change

Methods:

• getCurrentMutation - returns the most recent committed change
• addMutation - adds a fresh mutation to commitedMutations stack. Devastates filled canceledMutations stack
• cancelLastMutation - removes the most recent mutation from commitedMutations stack and places it in canceledMutations stack
• restoreCanceledMutation - if there are canceled mutations, then removes fresh mutation from canceledMutations stack and moves it to commitedMutations stack
• saveCurrentMutation - updates lastSavedChangeIndex with commitedMutations.length - 1
• backToSavedMutation - cancels or restores all mutations up to the last saved
• saveAndClear - saves the most recent commited mutation and demolishes the rest (canceled inclusive)
• clearHistory - clears history

A MutationsHistory instance can be created using predefined committed history list via MutationsHistory class constructor:

1constructor(sourceIterable?: Iterable<HistoryUnitType>) {
2
3    this.commitedMutations = sourceIterable ? [...sourceIterable]: [];
4    this.canceledMutations = [];
5    this.lastSavedChangeIndex = this.commitedMutations.length - 1;
6}

MutationsHistory is able to store whatever you plan it to: from changed objects itself to actions that mutate certain data structure. But a whole template, that rules history rules, remains the same.

ErrorWithData template class

ErrorWithData template class can be imported as follows:

1import {
2	ErrorWithData,
3} from '@vyacheslav97/ct';

This class implements interface:

1export interface ErrorBaseData {
2  message: string;
3}
4
5export interface ErrorWithDataInterface<DataType extends ErrorBaseData> extends Error {
6  errorData?: DataType;
7}

It allows a user to provide an error some extra data of sophisticated shape

Except mentioned above, ErrorWithData reproduces built in JS Error class behaviour

Usage example

1interface TestErrorData extends ErrorBaseData {
2  code: number;
3}
4
5const errorData: TestErrorData = { message: 'Test error', code: 404 };
6const error = new ErrorWithData<TestErrorData>(errorData);
7
8throw error;

Binary search procedure template

Binary search template procedure import:

1import {
2    binarySearch, 
3    buildBinarySearch,
4} from '@vyacheslav97/ct';

NOTE: it is highly recommended to prefer buildBinarySearch over binarySearch.

binarySearch implements well-known binary search algorithm for array of arbitrary content. It receives:

• sourceList - list of data for binary search (list cotains data of the same arbitrary type)

• target - binary search target

• comparator - function that compares array elements and has a result described via following interface:

  1interface ComparatorResult {
  2    equal?: boolean,
  3    less?: boolean,
  4    greater?: boolean,
  5}

binarySearch returns target index, if target does exist on given array or undefined otherwise.

buildBinarySearch creates binarySearch instance with a given comparator:

1
2const numbersComparator = (x: number, y: number): ComparatorResult => ({
3    less: x < y,
4    greater: x > y,
5    equal: x === y,
6});
7
8const numericalBinarySearch = buildBinarySearch(numbersComparator);
9
10numericalBinarySearch([], 5); // undefined
11numericalBinarySearch([1, 2, 3, 4, 5], 2); // 1
12

Duplicates search procedure template

Duplicates search procedure template import:

1import {
2    duplicatesSearcher,
3    buildDuplicatesSearcher,
4} from '@vyacheslav97/ct';

duplicatesSearcher function looks for duplicates within a given array of data. It accepts following arguments:

• source – duplications source iterable

• valueExtractor – optional function, derives a primitive according which two values are considered as duplicates

• Returns Map, which keys are valueExtractor values, values are lists of DuplicateData:

  1interface DuplicateData<T> {
  2    duplicateIndex: number;
  3    duplicateValue: T;
  4}

  Note: duplicatesSearcher returns empty Map only if source iterable is empty, otherwise it has maximum size equal to source iterable values amount.

buildDuplicatesSearcher builds a duplicatesSearcher instance with a given valueExtractor:

1interface SimpleObjectData {
2    value: string,
3}
4
5const valueExtractor = (data: SimpleObjectData) => data.value;
6
7
8const numericalDuplicatesSearcher = buildDuplicatesSearcher<number>();
9numericalDuplicatesSearcher([1, 2, 3, 4, 5]);
10
11export const objectDuplicatesSearcher = buildDuplicatesSearcher(valueExtractor);
12
13objectDuplicatesSearcher([
14    {
15        value: 'a',
16    },
17    {
18        value: 'a',
19    },
20    {
21        value: 'c',
22    },
23]);
24
25
26

Unique values search procedure template

Unique values search procedure template import:

1import {
2    uniqueValuesSearcher,
3    createUniqueValuesSearcher,
4} from '@vyacheslav97/ct';

uniqueValuesSearcher accepts a uniform array and filters unique values out of it. This function requires two arguments:

• sourceArray - source array to filter unique values out of it

• uniqueFeatureValueExtractor - a function, that derives a value of uniqueness feature (according to this value two objects are considered as identical)

  It is recommended to use createUniqueValuesSearcher over uniqueValuesSearcher. createUniqueValuesSearcher creates an instance of uniqueValuesSearcher using a particular uniqueness feature value extractor function

isNumber

isNumber validator import:

1import isNumber from '@vyacheslav97/ct';

isNumber represents a simple method to check whether its argument actually number or not. It based on two consequent test:

• Ensures, that typeof input argument is number
• Examines result of Number.isNaN call on input argument

Decimal integer RegExp

Regular expressions for decimal integers testing import:

1import {
2    integerNumberRegex,
3    unsignedIntegerNumberRegex,
4    negativeIntegerNumberRegex,
5} from '@vyacheslav97/ct';

All expressions are aimed to detangle whether a whole given string is an integer or not.

Particularly:

• integerNumberRegex checks, whether an input string has signed or unsigned integer number: string optionally starts with a single + or -, followed by digits sequence, which starts with any digits except 0, or single usingned 0
• unsignedIntegerNumberRegex almost copies integerNumberRegex, but start signs are not allowed
• negativeIntegerNumberRegex almost copies integerNumberRegex, but start sign must be -

Decimal float RegExp

Regular expressions for decimal floats testing import:

1import {
2	floatNumberRegex,
3	unsignedFloatNumberRegex,
4	negativeFloatingPointNumberRegex,
5} from '@vyacheslav97/ct';

All expressions are aimed to detangle whether a whole given string is a float number or not.

Particularly:

• floatNumberRegex checks, whether an input string has signed or unsigned float number: string optionally starts with a single + or -, followed by digits sequence, which first digit can't be 0, or single 0 with no sign. All this stuff is accompanied with optional single dot and that dot has optional digits sequence. So, following numbers are correct: 0, 0., 0.241253, -1.24, 3, -5, +12 .
• unsignedFloatNumberRegex resembles floatNumberRegex, but denies starting sign, positive or negative
• negativeFloatingPointNumberRegex mimics floatNumberRegex, but requires - as a starting sign

Exponential format number RegExp

Regular expression for number of exponential format testing import:

1import {
2	exponentialNumberFormatRegex,
3} from '@vyacheslav97/ct';

This expression is aimed to detangle whether an entire given string is a number of exponential format or not.

exponentialNumberFormatRegex unites three checks:

• e or E separator between right part and left part of number
• right part must be a decimal integer number with optional - sign
• left part must be a decimal float number with optional sign