npm package discovery and stats viewer.

Discover Tips

  • General search

    [free text search, go nuts!]

  • Package details

    pkg:[package-name]

  • User packages

    @[username]

Sponsor

Optimize Toolset

I’ve always been into building performant and accessible sites, but lately I’ve been taking it extremely seriously. So much so that I’ve been building a tool to help me optimize and monitor the sites that I build to make sure that I’m making an attempt to offer the best experience to those who visit them. If you’re into performant, accessible and SEO friendly sites, you might like it too! You can check it out at Optimize Toolset.

About

Hi, 👋, I’m Ryan Hefner  and I built this site for me, and you! The goal of this site was to provide an easy way for me to check the stats on my npm packages, both for prioritizing issues and updates, and to give me a little kick in the pants to keep up on stuff.

As I was building it, I realized that I was actually using the tool to build the tool, and figured I might as well put this out there and hopefully others will find it to be a fast and useful way to search and browse npm packages as I have.

If you’re interested in other things I’m working on, follow me on Twitter or check out the open source projects I’ve been publishing on GitHub.

I am also working on a Twitter bot for this site to tweet the most popular, newest, random packages from npm. Please follow that account now and it will start sending out packages soon–ish.

Open Software & Tools

This site wouldn’t be possible without the immense generosity and tireless efforts from the people who make contributions to the world and share their work via open source initiatives. Thank you 🙏

© 2024 – Pkg Stats / Ryan Hefner

@vyacheslav97/ct

v1.0.4

Published

Common tools (hereinafter referred to as **ct**) - a common JavaScript data structures and associated processing procedures package ([package repository](https://github.com/VyacheslavMishin/ct/tree/master)).

Downloads

236

Readme

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)

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:

import {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:

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

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:


// Clarifies the rule how to transform array item to a key-value pair list
const shiftedArrayItemToMapItemTransformer: SingleToPair<number, number, number>
    = (number): [number, number] => [number, number + 1];

// Creates array to map converter with certain array item rule transformation
const arrayToMapShifted = createArrayToMap<number, number, number>(shiftedArrayItemToMapItemTransformer);

arrayToMapShifted([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:

import {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:

// All needed type aliases for conversion laws can be imported as follows:
import {
  SingleToPair,
  SingleToSingle,
  PairToSingle
} from "@vyacheslav97/ct";

// Map item to a character transformer 
const keyValuePairConcatenatedTransformer: PairToSingle<number, number, string>
    = (pair) => pair.join('');

// Create transformer itself 
const keyValuePairConcatenated = createMapToString(keyValuePairConcatenatedTransformer);

keyValuepairConcatenated(new Map([[1, 1], [2, 2]])); // results in '1122'

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:

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

Graph class itself implements next interface:

interface GraphInterface<NodeData = void> {
	// base data structure containing all graph nodes
    nodes: Map<string, GraphNodeInterface<NodeData>>,
    
    getNode: (nodeId: string) => GraphNodeInterface<NodeData> | undefined,
    getNodeData: (nodeId: string) => NodeData | undefined,

	
    hasNode: (nodeId: string) => boolean,
    addNode: (node: GraphNodeInterface<NodeData>) => void,
    removeNode: (nodeId: string) => GraphNodeInterface<NodeData> | undefined,

    flatten: (startNodeId: string) => Iterable<GraphNodeInterface<NodeData>>,
    buildPath: (startNodeId: string, endNodeId: string) => GraphNodeInterface<NodeData>[] | undefined,
}

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:

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

Initialization

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

Graph constructor expects following arguments:

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

Where GraphConfig:

interface GraphConfig<NodeData = void> {
    levelingStepFunction?: LevelingStepFunction<NodeData>,
    pathFinder?: PathBuilder<NodeData>,
}

type LevelingStepFunction<NodeData = void> = (
    currentNode: GraphNodeInterface<NodeData>,
    sourceGraph: GraphInterface<NodeData>,
) => GraphNodeInterface<NodeData> | null;

type PathBuilder<NodeData = void> = (
    startNode: GraphNodeInterface<NodeData>,
    endNode: GraphNodeInterface<NodeData>,
    sourceGraph: GraphInterface<NodeData>,
) => GraphNodeInterface<NodeData>[];

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:

/**
 * Adds node to graph. Throws error if node of the same id already exists
 * @param nodeToAdd node to add, GraphNodeInterface<**NodeData**>
 */
addNode(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:

/**
 * Returns graph node of specified id, if graph has node with such id
 * @param nodeId target node id, **string**
 */
getNode(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:

/**
 * Removes node of given id. Does nothing if wrong id is provided
 * @param nodeId id of node to remove, **string**
 */
removeNode(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:

// Has to gain one node from another. If it turns impossible - returns null
const levelingStepFunction: LevelingStepFunction<unknown> = ( // function for "linked list"
    currentNode: GraphNodeInterface<unknown>,
    graph: GraphInterface<unknown>,
) => {
    const {
        outgoingBoundaries,
    } = currentNode;
    const firstOutgoingBoundary = [...outgoingBoundaries]?.[0]?.[0];

    return graph.getNode(firstOutgoingBoundary) || null;

};

const graph = new Graph();

graph.setFlattenProcedure(levelingStepFunction);

// then call [...graph.flatten('someStartNodeId')], for example, or use for ... of, or whatever

To initialize or override buildPath method, call setPathFinderProcedure method.

Example:

// Simple pathfinder for "linked list" 
const pathFinder: PathBuilder<unknown> = (
    startNode: GraphNodeInterface<unknown>,
    endNode: GraphNodeInterface<unknown>,
    graph: GraphInterface<unknown>,
) => {

    let currentNode: GraphNodeInterface<unknown> = startNode;
    const result: GraphNodeInterface<unknown>[] = [];

    do {
        result.push(currentNode);
        currentNode = graph.getNode([...currentNode.outgoingBoundaries]?.[0]?.[0])!;
    } while(result[result.length - 1]?.nodeId !== endNode.nodeId)

    return result;

};

const graph = new Graph();
graph.setPathFinderProcedure(pathFinder);

// here you go, call graph.buildPath('startNodeId', 'endNodeId');
// BUT REMEMBER: invalid node ids (e.g. absent one) will trigger an error

buildPath call with no initialization triggers an error.

Tree abstract class

Import Tree class:

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

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

  • addNode:

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

    /**
     * Removes a node from a tree instance (and the node whole subtree by default)
     * Doesn't remove a node if it doesn't exist on the tree instance
     * @param nodeId id of node to remove
     * @param deleteSubTree if true (by default) node and its subtree are removed
     */
    removeNode(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:

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

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

interface MutationsHistoryInterface<HistoryUnitType> {

    lastSavedChangeIndex: number,

    commitedMutations: HistoryUnitType[],
    canceledMutations: HistoryUnitType[],

    getCurrentMutation: () => HistoryUnitType | undefined,

    addMutation: (mutation: HistoryUnitType) => void,
    cancelLastMutation: () => void,
    restoreCanceledMutation: () => void,
    saveCurrentMutation: () => void,
    backToSavedMutation: () => void,


    saveAndClear: () => void,
    clearHistory: () => void,

}

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:

constructor(sourceIterable?: Iterable<HistoryUnitType>) {

    this.commitedMutations = sourceIterable ? [...sourceIterable]: [];
    this.canceledMutations = [];
    this.lastSavedChangeIndex = this.commitedMutations.length - 1;
}

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:

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

This class implements interface:

export interface ErrorBaseData {
  message: string;
}

export interface ErrorWithDataInterface<DataType extends ErrorBaseData> extends Error {
  errorData?: DataType;
}

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

interface TestErrorData extends ErrorBaseData {
  code: number;
}

const errorData: TestErrorData = { message: 'Test error', code: 404 };
const error = new ErrorWithData<TestErrorData>(errorData);

throw error;

Binary search procedure template

Binary search template procedure import:

import {
    binarySearch, 
    buildBinarySearch,
} 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:

    interface ComparatorResult {
        equal?: boolean,
        less?: boolean,
        greater?: boolean,
    }

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

buildBinarySearch creates binarySearch instance with a given comparator:


const numbersComparator = (x: number, y: number): ComparatorResult => ({
    less: x < y,
    greater: x > y,
    equal: x === y,
});

const numericalBinarySearch = buildBinarySearch(numbersComparator);

numericalBinarySearch([], 5); // undefined
numericalBinarySearch([1, 2, 3, 4, 5], 2); // 1

Duplicates search procedure template

Duplicates search procedure template import:

import {
    duplicatesSearcher,
    buildDuplicatesSearcher,
} 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:

    interface DuplicateData<T> {
        duplicateIndex: number;
        duplicateValue: T;
    }

    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:

interface SimpleObjectData {
    value: string,
}

const valueExtractor = (data: SimpleObjectData) => data.value;


const numericalDuplicatesSearcher = buildDuplicatesSearcher<number>();
numericalDuplicatesSearcher([1, 2, 3, 4, 5]);

export const objectDuplicatesSearcher = buildDuplicatesSearcher(valueExtractor);

objectDuplicatesSearcher([
    {
        value: 'a',
    },
    {
        value: 'a',
    },
    {
        value: 'c',
    },
]);


Unique values search procedure template

Unique values search procedure template import:

import {
    uniqueValuesSearcher,
    createUniqueValuesSearcher,
} 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:

import 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:

import {
    integerNumberRegex,
    unsignedIntegerNumberRegex,
    negativeIntegerNumberRegex,
} 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:

import {
	floatNumberRegex,
	unsignedFloatNumberRegex,
	negativeFloatingPointNumberRegex,
} 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:

import {
	exponentialNumberFormatRegex,
} 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