@qntm-code/utils v2.18.3

@qntm-code/utils

A collection of useful utility functions with associated TypeScript types.

• @qntm-code/utils
  • Install
    • npm
    • yarn
  • Documentation
    • Generic Helpers
      • isNullOrUndefined
      • clone
        • instanceClone
        • clone performance comparison
      • merge
        • merge options
          • arrayMerge
          • isMergableObject
          • customMerge
        • Merge performance comparison
      • difference
      • formatTime
        • FormatTimeOptions
      • insertAtIndex
      • isBoolean
      • isDate
      • isEmpty
      • isNaNStrict
      • isNumber
      • isObject
      • isString
      • isEqual
        • isEqual performance comparison
        • EqualityType
        • IndividualEqualityType
      • isRegExp
      • isArguments
      • isBuffer
      • isError
      • isGeneratorObject
      • isPlainObject
      • isReactElement
      • typeOf
      • randomNumberBetweenRange
    • Async helpers
      • asyncEvery
      • asyncFilter
      • asyncForEach
      • asyncSome
      • delay
    • Date helpers
      • convertTimeUnit
      • msToUnit
      • unitToMs
      • compareDates
      • DateComparator
      • TimeUnit
      • isSameDate
      • addToDate
        • Special considerations for months and years
      • subtractFromDate
      • getToday
      • getWeekOfYear
      • getMonthNames
        • GetMonthNamesOptions
      • getEndOfDay
      • getEndOfHour
      • getEndOfMinute
      • getEndOfMonth
      • getEndOfSecond
      • getEndOfWeek
      • getEndOfYear
      • getStartOfDay
      • getStartOfHour
      • getStartOfMinute
      • getStartOfMonth
      • getStartOfSecond
      • getStartOfWeek
      • getStartOfYear
      • setEndOfDay
      • setEndOfHour
      • setEndOfMinute
      • setEndOfMonth
      • setEndOfSecond
      • setEndOfWeek
      • setEndOfYear
      • setStartOfDay
      • setStartOfHour
      • setStartOfMinute
      • setStartOfMonth
      • setStartOfSecond
      • setStartOfWeek
      • setStartOfYear
    • DOM helpers
      • getAncestors
      • getNonInlineParent
      • getPositionedParent
      • getScrollParent
      • isDisplayInline
      • isVisible
    • Types
      • Dictionary
  • Attribution

Install

You can install via npm or yarn.

npm

npm install --save @qntm-code/utils

yarn

yarn add @qntm-code/utils

Documentation

This documentation is written in TypeScript, however this library works fine in vanilla JavaScript too.

Generic Helpers

isNullOrUndefined

Determines whether a given value is null or undefined.

Method arguments:

Return type: boolean

Example:

import { isNullOrUndefined } from '@qntm-code/utils';

const value = getTheValue();

if (isNullOrUndefined(value)) {
  // Do something
}

clone

Recursively (deep) clones native types, like Object, Array, RegExp, Date, Map, Set, Symbol, Error, moment as well as primitives.

Method arguments:

Return type: T

instanceClone

This paramater specifies whether or not to clone instances (objects that are from a custom class or are not created by the Object constructor. This value may be true or the function use for cloning instances.

When an instanceClone function is provided, it will be invoked to clone objects that are not "plain" objects (as defined by isPlainObject). If instanceClone is not specified, the function will not attempt to clone non-plain objects, and will simply copy the object reference.

Example:

import { clone } from '@qntm-code/utils';

const value: number[] = [1, 2, 3];
const clonedValues = clone(value);

clone performance comparison

The following benchmarks were run on a 2023 Macbook Pro with a M2 Pro chip and 32GB of RAM.

merge

Merges two objects x and y deeply, returning a new merged object with the elements from both x and y.

If an element at the same key is present for both x and y, the value from y will appear in the result.

Merging creates a new object, so that neither x or y is modified.

Note: By default, arrays are merged by concatenating them.

Method arguments:

merge options

arrayMerge

There are multiple ways to merge two arrays, below are a few examples but you can also create your own custom function.

Your arrayMerge function will be called with three arguments: a target array, the source array, and an options object with these properties:

• isMergeableObject(value)
• cloneUnlessOtherwiseSpecified(value, options)

example: overwrite target array:

Overwrites the existing array values completely rather than concatenating them:

import { merge } from '@qntm-code/utils';

const overwriteMerge = (destinationArray, sourceArray, options) => sourceArray;

merge([1, 2, 3], [3, 2, 1], { arrayMerge: overwriteMerge }); // => [3, 2, 1]

example: combine arrays:

Combines objects at the same index in the two arrays.

import { merge } from '@qntm-code/utils';

const combineMerge = (target, source, options) => {
  const destination = target.slice();

  source.forEach((item, index) => {
    if (typeof destination[index] === 'undefined') {
      destination[index] = options.cloneUnlessOtherwiseSpecified(item, options);
    } else if (options.isMergeableObject(item)) {
      destination[index] = merge(target[index], item, options);
    } else if (target.indexOf(item) === -1) {
      destination.push(item);
    }
  });
  return destination;
};

merge([{ a: true }], [{ b: true }, 'ah yup'], { arrayMerge: combineMerge }); // => [{ a: true, b: true }, 'ah yup']

isMergableObject

By default, merge clones every property from almost every kind of object.

You may not want this, if your objects are of special types, and you want to copy the whole object instead of just copying its properties.

You can accomplish this by passing in a function for the isMergeableObject option.

If you only want to clone properties of plain objects, and ignore all "special" kinds of instantiated objects, you probably want to drop in isPlainObject.

import { merge, isPlainObject } from '@qntm-code/utils';

function SuperSpecial() {
  this.special = 'oh yeah man totally';
}

const instantiatedSpecialObject = new SuperSpecial();

const target = {
  someProperty: {
    cool: 'oh for sure',
  },
};

const source = {
  someProperty: instantiatedSpecialObject,
};

const defaultOutput = merge(target, source);

defaultOutput.someProperty.cool; // => 'oh for sure'
defaultOutput.someProperty.special; // => 'oh yeah man totally'
defaultOutput.someProperty instanceof SuperSpecial; // => false

const customMergeOutput = merge(target, source, {
  isMergeableObject: isPlainObject,
});

customMergeOutput.someProperty.cool; // => undefined
customMergeOutput.someProperty.special; // => 'oh yeah man totally'
customMergeOutput.someProperty instanceof SuperSpecial; // => true

customMerge

Specifies a function which can be used to override the default merge behaviour for a property, based on the property name.

The customMerge function will be passed the key for each property, and should return the function which should be used to merge the values for that property.

It may also return undefined, in which case the default merge behaviour will be used.

const alex = {
  name: {
    first: 'Alex',
    last: 'Alexson',
  },
  pets: ['Cat', 'Parrot'],
};

const tony = {
  name: {
    first: 'Tony',
    last: 'Tonison',
  },
  pets: ['Dog'],
};

const mergeNames = (nameA, nameB) => `${nameA.first} and ${nameB.first}`;

const options = {
  customMerge: key => {
    if (key === 'name') {
      return mergeNames;
    }
  },
};

const result = merge(alex, tony, options);

result.name; // => 'Alex and Tony'
result.pets; // => ['Cat', 'Parrot', 'Dog']

Merge performance comparison

The following benchmarks go through the merge test suite and were run on a 2023 Macbook Pro with a M2 Pro chip and 32GB of RAM.

difference

Creates an array of array values not included in the other given array using isEqual for equality comparisons. The order and references of result values are determined by the first array.

Method arguments:

Return type: Array<any>

Example:

import { difference } from '@qntm-code/utils';

const diff = difference([1, 2], [2, 3]);
// returns [1]

formatTime

Formats a given time to a human readable string.

Method arguments:

Return type: string

Example:

import { formatTime } from '@qntm-code/utils';

const formattedTime = formatTime(71000, {
  hourSuffix: ' HOURS',
  minuteSuffix: ' MINUTES',
  secondSuffix: ' SECONDS',
});

// formattedTime = '00 HOUR 01 MINUTE 11 SECONDS'

FormatTimeOptions

insertAtIndex

Inserts a string value at a given index in a source string.

Method arguments:

Return type: string

import { insertAtIndex } from '@qntm-code/utils';

insertAtIndex('<strong>', '/', 1);

// returns '</strong>'

isBoolean

Checks if a given value is a boolean.

Method arguments:

Return type: boolean

Example:

import { isBoolean } from '@qntm-code/utils';

const value = getBoolean();

if (isBoolean(value)) {
  // Do something
}

isDate

Checks if a given value is a Date object.

Method arguments:

Return type: boolean

Example:

import { isDate } from '@qntm-code/utils';

const value = getDate();

if (isDate(value)) {
  // Do something
}

isEmpty

Checks if a given value is empty.

Method arguments:

Return type: boolean

Example:

import { isEmpty } from '@qntm-code/utils';

const value: string = getName();

if (isEmpty(value)) {
  // Do something
}

isNaNStrict

Determines whether a given value is a NaN instance

Method arguments:

Return type: boolean

Example:

import { isNaNStrict } from '@qntm-code/utils';

const value = getTheValue();

if (isNaNStrict(value)) {
  // Do something
}

isNumber

Determines whether a given value is a number

Method arguments:

Return type: boolean

Example:

import { isNumber } from '@qntm-code/utils';

const value = getTheValue();

if (isNumber(value)) {
  // Do something
}

isObject

Determines whether a given value is an object

Method arguments:

Return type: boolean

Example:

import { isObject } from '@qntm-code/utils';

const value = getTheValue();

if (isObject(value)) {
  // Do something
}

isString

Determines whether a given value is a string

Method arguments:

Return type: boolean

Example:

import { isString } from '@qntm-code/utils';

const value = getTheValue();

if (isString(value)) {
  // Do something
}

isEqual

Performs a deep comparison between two values to determine if they are equivalent.

Note: This method supports comparing nulls, undefineds, booleans, numbers, strings, Dates, objects, Functions, Arrays, RegExs, Maps, Sets, Typed Arrays, and Moments.

Object objects are compared by their own, not inherited, enumerable properties.

Functions and DOM nodes are compared by strict equality, i.e. ===.

The order of the array items must be the same for the arrays to be equal.

Method arguments:

Return type: boolean

Example:

import { isEqual } from '@qntm-code/utils';

const a: Array<number> = getSensorAReadings();
const b: Array<number> = getSensorBReadings();

if (isEqual(a, b)) {
  // Do a thing
}

isEqual performance comparison

The following benchmarks go through the isEqual test suite and were run on a 2023 Macbook Pro with a M2 Pro chip and 32GB of RAM.

To run the benchmarks yourself, clone the repo, install the dependencies and run yarn benchmark.

EqualityType

An EqualityType can be an IndividualEqualityType or an array of mixed IndividualEqualityTypes

IndividualEqualityType

The equality types allowed are:

• null
• undefined
• boolean
• number
• string
• Date
• object
• Function

isRegExp

Determines whether a given value is a regular expression

Method arguments:

Return type: boolean

Example:

import { isRegExp } from '@qntm-code/utils';

const value = getTheValue();

if (isRegExp(value)) {
  // Do something
}

isArguments

Determines whether a given value is an arguments object

Method arguments:

Return type: boolean

Example:

import { isArguments } from '@qntm-code/utils';

const value = getTheValue();

if (isArguments(value)) {
  // Do something
}

isBuffer

Determines whether a given value is a buffer

Method arguments:

Return type: boolean

Example:

import { isBuffer } from '@qntm-code/utils';

const value = getTheValue();

if (isBuffer(value)) {
  // Do something
}

isError

Determines whether a given value is an error

Method arguments:

Return type: boolean

Example:

import { isError } from '@qntm-code/utils';

const value = getTheValue();

if (isError(value)) {
  // Do something
}

isGeneratorObject

Determines whether a given value is a generator object

Method arguments:

Return type: boolean

Example:

import { isGeneratorObject } from '@qntm-code/utils';

const value = getTheValue();

if (isGeneratorObject(value)) {
  // Do something
}

isPlainObject

Determines whether a given value is a plain object

Method arguments:

Return type: boolean

Example:

import { isPlainObject } from '@qntm-code/utils';

const value = getTheValue();

if (isPlainObject(value)) {
  // Do something
}

isReactElement

Determines whether a given value is a React element

Method arguments:

Return type: boolean

Example:

import { isReactElement } from '@qntm-code/utils';

const value = getTheValue();

if (isReactElement(value)) {
  // Do something
}

typeOf

Returns the type of a given value

Method arguments:

Return type: ValueType | string

Example:

import { typeOf, ValueType } from '@qntm-code/utils';

const value = getTheValue();

if (typeOf(value) === ValueType.string) {
  // Do something
}

randomNumberBetweenRange

Returns a random whole number between a given range

Method arguments:

Return type: number

Example:

import { randomNumberBetweenRange } from '@qntm-code/utils';

const random = randomNumberBetweenRange(2, 10);

Async helpers

asyncEvery

Allows you to run Array.every() with an async predicate function and await the result.

Method arguments:

Callback arguments:

Return type:

Promise<boolean>;

Example:

import { asyncEvery } from '@qntm-code/utils';

async function doAThing(): Promise<void> {
  // Array of items to iterate over
  const items: Array<string> = ['a', 'b', 'c'];

  const result = await asyncEvery(items, async item => await someAsynchronousOperation(item));

  functionToRunWhenAllItemsAreProcessed(result);
}

asyncFilter

Allows you to run Array.filter() with an async predicate function and await the result.

Method arguments:

Callback arguments:

Return type:

Promise<T[]>;

Example:

import { asyncFilter } from '@qntm-code/utils';

async function doAThing(): Promise<void> {
  // Array of items to iterate over
  const items: Array<string> = ['a', 'b', 'c'];

  const results = await asyncFilter(items, async item => await someAsynchronousOperation(item));

  functionToRunWhenAllItemsAreProcessed(results);
}

asyncForEach

Allows you to iterate over an array asynchronously.

Method arguments:

Callback arguments:

Return type:

Promise<void>;

Example:

import { asyncForEach } from '@qntm-code/utils';

async function doAThing(): Promise<void> {
  // Array of items to iterate over
  const items: Array<string> = ['a', 'b', 'c'];

  await asyncForEach(items, async item => await someAsynchronousOperation(item));

  functionToRunWhenAllItemsAreProcessed();
}

asyncSome

Allows you to run Array.some() with an async predicate function and await the result.

Method arguments:

Callback arguments:

Return type:

Promise<boolean>;

Example:

import { asyncSome } from '@qntm-code/utils';

async function doAThing(): Promise<void> {
  // Array of items to iterate over
  const items: Array<string> = ['a', 'b', 'c'];

  const result = await asyncSome(items, async item => await someAsynchronousOperation(item));

  functionToRunWhenAllItemsAreProcessed(result);
}

delay

Delays an async function using await given an optionally provided duration.

Method arguments:

Return type:

Promise<void>;

Example:

import { delay } from '@qntm-code/utils';

async function doAThing(): Promise<void> {
  const value = calculateAThing();

  await delay(200);

  operateOnCalculatedValue(value);
}

Date helpers

convertTimeUnit

Converts a value of a given TimeUnit into another TimeUnit.

Method arguments:

Return type: number

Example:

import { convertTimeUnit, TimeUnit } from '@qntm-code/utils';

const weeks: number = 24;
const minutes: number = convertTimeUnit(weeks, TimeUnit.Weeks, TimeUnit.Minutes);

Vanilla JS Example:

import { convertTimeUnit } from '@qntm-code/utils';

const weeks = 24;
const minutes = convertTimeUnit(weeks, 'weeks', 'minutes');

msToUnit

Converts milliseconds into a TimeUnit.

Method arguments:

Return type: number

Example:

import { msToUnit, TimeUnit } from '@qntm-code/utils';

const milliseconds: number = 4567876;
const hours: number = msToUnit(milliseconds, TimeUnit.Hours);

Example:

import { msToUnit } from '@qntm-code/utils';

const milliseconds = 4567876;
const hours = msToUnit(milliseconds, 'hours');

unitToMs

Converts a TimeUnit into milliseconds.

Method arguments:

Return type: number

Example:

import { unitToMs, TimeUnit } from '@qntm-code/utils';

const days: number = 10;
const milliseconds: number = unitToMs(days, TimeUnit.Days);

Example:

import { unitToMs } from '@qntm-code/utils';

const days = 10;
const milliseconds = unitToMs(days, 'days');

compareDates

Determines if date a is before/before or same/same/after or same/or after to date b. If you want to limit the granularity to a unit other than milliseconds, pass it as the second parameter.

When including a second parameter, it will match all units equal or larger. For example, if passing in month will check month and year, or if passing in day will check day, month, and year.

Return type: boolean

Example:

import { compareDates, DateComparator, TimeUnit } from '@qntm-code/utils';

const a: Date = new Date(2023, 0, 1, 12, 0, 0, 0);
const b: Date = new Date(2023, 0, 1, 9, 0, 1, 12);

compareDates(a, DateComparator.Before, b, TimeUnit.Year); // false
compareDates(a, DateComparator.BeforeOrSame, b, TimeUnit.Day); // true
compareDates(a, DateComparator.Same, b, TimeUnit.Month); // true
compareDates(a, DateComparator.AfterOrSame, b, TimeUnit.Hour); // true
compareDates(a, DateComparator.After, b, TimeUnit.Minute); // false

DateComparator

A TypeScript enum of available options to provide to date comparison functions. For vanilla JS just use the string values from the value column.

TimeUnit

A TypeScript enum of available options to provide to time unit conversion functions. For vanilla JS just use the string values from the value column.

isSameDate

Determines if two dates are the same. If you want to limit the granularity to a unit other than milliseconds, pass it as the second parameter.

When including a second parameter, it will match all units equal or larger. For example, if passing in month will check month and year, or if passing in day will check day, month, and year.

Method arguments:

Return type: boolean

Example:

import { isSameDate, TimeUnit } from '@qntm-code/utils';

const a: Date = new Date(2023, 0, 1, 12, 0, 0, 0);
const b: Date = new Date(2023, 0, 1, 9, 0, 1, 12);
const c: Date = new Date(2023, 6, 1, 0, 0, 0, 0);

if (isSameDate(a, b)) {
  // This will not run as the dates are not the same
}

if (isSameDate(a, b, TimeUnit.Day)) {
  // This will run as the dates are the same day
}

if (isSameDate(a, b, TimeUnit.Hour)) {
  // This will not run as the dates are not the same hour
}

if (isSameDate(a, c, TimeUnit.Day)) {
  // This will not run because even though the dates are the same day, the months are not the same
}

addToDate

Returns a new date object with a given amount of a given TimeUnit added to it.

Example:

import { addToDate, TimeUnit } from '@qntm-code/utils';

const date: Date = new Date();

const thisTimeTomorrow: Date = addToDate(date, 1 TimeUnit.Day);

Special considerations for months and years

If the day of the month on the original date is greater than the number of days in the final month, the day of the month will change to the last day in the final month.

import { addToDate, TimeUnit } from '@qntm-code/utils';

const date: Date = new Date('2023-01-31'); // 31 January

const nextMonth: Date = addToDate(date, 1, TimeUnit.Month); // 28 February

There are also special considerations to keep in mind when adding time that crosses over daylight saving time. If you are adding years, months, weeks, or days, the original hour will always match the added hour.

Adding a month will add the specified number of months to the date.

const date = new Date('2023-02-28'); // February 28
const newDate = addToDate(date, 1, TimeUnit.Month); // March 28

const date = new Date('2023-03-25T06:00:00.000Z'); // The day before BST in the UK
date.getHours(); // 6
const newDate = addToDate(date, 1, TimeUnit.Day).getHours(); // 6

If you are adding hours, minutes, seconds, or milliseconds, the assumption is that you want precision to the hour, and will result in a different hour.

const date = new Date('2023-03-25T06:00:00.000Z'); // The day before BST in the UK
date.getHours(); // 6
const newDate = addToDate(date, 24, TimeUnit.Hours).getHours(); // 7

subtractFromDate

Returns a new date object with a given amount of a given TimeUnit subracted from it.

This is exactly the same as moment#add, only instead of addToDate, it subtracts time.

Example:

import { subtractFrom, TimeUnit } from '@qntm-code/utils';

const date: Date = new Date();

const thisTimeTomorrow: Date = subtractFrom(date, 1 TimeUnit.Day);

getToday

Gets a Date for the start of the given day.

Return type: Date

Example:

import { getToday } from '@qntm-code/utils';

const today: Date = getToday();

getWeekOfYear

Gets the week number of the year for the given date. It will use today's date if no date is provided.

Return type: number

Example:

import { getWeekOfYear } from '@qntm-code/utils';

const weekNumber: number = getWeekOfYear(new Date('2023-12-30')); // 52

getMonthNames

Gets the month names for the provided locale.

Return type: Array<string>

Example:

import { getMonthNames, GetMonthNamesOptions } from '@qntm-code/utils';

const options: GetMonthNamesOptions = {
  locale: 'en-GB',
  format: 'short',
};

const monthNames: Array<string> = getMonthNames(options); // ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', Dec']

GetMonthNamesOptions

getEndOfDay

Takes an optional date and returns a new Date object set to the end of the given/current day.

Return type: Date

Example:

import { getEndOfDay } from '@qntm-code/utils';

const endOfCurrentDay: Date = getEndOfDay();

getEndOfHour

Takes an optional date and returns a new Date object set to the end of the given/current hour.

Return type: Date

Example:

import { getEndOfHour } from '@qntm-code/utils';

const endOfCurrentHour: Date = getEndOfHour();

getEndOfMinute

Takes an optional date and returns a new Date object set to the end of the given/current minute.

Return type: Date

Example:

import { getEndOfMinute } from '@qntm-code/utils';

const endOfCurrentMinute: Date = getEndOfMinute();

getEndOfMonth

Takes an optional date and returns a new Date object set to the end of the given/current month.

Return type: Date

Example:

import { getEndOfMonth } from '@qntm-code/utils';

const endOfCurrentMonth: Date = getEndOfMonth();

getEndOfSecond

Takes an optional date and returns a new Date object set to the end of the given/current second.

Return type: Date

Example:

import { getEndOfSecond } from '@qntm-code/utils';

const endOfCurrentSecond: Date = getEndOfSecond();

getEndOfWeek

Takes an optional date and returns a new Date object set to the end of the given/current week.

Return type: Date

Example:

import { getEndOfWeek } from '@qntm-code/utils';

const endOfCurrentWeek: Date = getEndOfWeek();

getEndOfYear

Takes an optional date and returns a new Date object set to the end of the given/current year.

Return type: Date

Example:

import { getEndOfYear } from '@qntm-code/utils';

const endOfCurrentYear: Date = getEndOfYear();

getStartOfDay

Takes an optional date and returns a new Date object set to the start of the given/current day.

Return type: Date

Example:

import { getStartOfDay } from '@qntm-code/utils';

const startOfCurrentDay: Date = getStartOfDay();

getStartOfHour

Takes an optional date and returns a new Date object set to the start of the given/current hour.

Return type: Date

Example:

import { getStartOfHour } from '@qntm-code/utils';

const startOfCurrentHour: Date = getStartOfHour();

getStartOfMinute

Takes an optional date and returns a new Date object set to the start of the given/current minute.

Return type: Date

Example:

import { getStartOfMinute } from '@qntm-code/utils';

const startOfCurrentMinute: Date = getStartOfMinute();

getStartOfMonth

Takes an optional date and returns a new Date object set to the start of the given/current month.

Return type: Date

Example:

import { getStartOfMonth } from '@qntm-code/utils';

const startOfCurrentMonth: Date = getStartOfMonth();

getStartOfSecond

Takes an optional date and returns a new Date object set to the start of the given/current second.

Return type: Date

Example:

import { getStartOfSecond } from '@qntm-code/utils';

const startOfCurrentSecond: Date = getStartOfSecond();

getStartOfWeek

Takes an optional date and returns a new Date object set to the start of the given/current week.

Return type: Date

Example:

import { getStartOfWeek } from '@qntm-code/utils';

const startOfCurrentWeek: Date = getStartOfWeek();

getStartOfYear

Takes an optional date and returns a new Date object set to the start of the given/current year.

Return type: Date

Example:

import { getStartOfYear } from '@qntm-code/utils';

const startOfCurrentYear: Date = getStartOfYear();

setEndOfDay

Takes a given date and mutates it to the end of the given day.

Return type: Date

Example:

import { setEndOfDay } from '@qntm-code/utils';

const now: Date = new Date();
const endOfCurrentDay: Date = setEndOfDay(now);

setEndOfHour

Takes a given date and mutates it to the end of the given hour.

Return type: Date

Example:

import { setEndOfHour } from '@qntm-code/utils';

const now: Date = new Date();
const endOfCurrentHour: Date = setEndOfHour(now);

setEndOfMinute

Takes a given date and mutates it to the end of the given minute.

Return type: Date

Example:

import { setEndOfMinute } from '@qntm-code/utils';

const now: Date = new Date();
const endOfCurrentMinute: Date = setEndOfMinute(now);

setEndOfMonth

Takes a given date and mutates it to the end of the given month.

Return type: Date

Example:

import { setEndOfMonth } from '@qntm-code/utils';

const now: Date = new Date();
const endOfCurrentMonth: Date = setEndOfMonth(now);

setEndOfSecond

Takes a given date and mutates it to the end of the given second.

Return type: Date

Example:

import { setEndOfSecond } from '@qntm-code/utils';

const now: Date = new Date();
const endOfCurrentSecond: Date = setEndOfSecond(now);

setEndOfWeek

Takes a given date and mutates it to the end of the given week.

Return type: Date

Example:

import { setEndOfWeek } from '@qntm-code/utils';

const now: Date = new Date();
const endOfCurrentWeek: Date = setEndOfWeek(now);

setEndOfYear

Takes a given date and mutates it to the end of the given year.

Return type: Date

Example:

import { setEndOfYear } from '@qntm-code/utils';

const now: Date = new Date();
const endOfCurrentYear: Date = setEndOfYear(now);

setStartOfDay

Takes a given date and mutates it to the start of the given day.

Return type: Date

Example:

import { setStartOfDay } from '@qntm-code/utils';

const now: Date = new Date();
const startOfCurrentDay: Date = setStartOfDay(now);

setStartOfHour

Takes a given date and mutates it to the start of the given hour.

Return type: Date

Example:

import { setStartOfHour } from '@qntm-code/utils';

const now: Date = new Date();
const startOfCurrentHour: Date = setStartOfHour(now);

setStartOfMinute

Takes a given date and mutates it to the start of the given minute.

Return type: Date

Example:

import { setStartOfMinute } from '@qntm-code/utils';

const now: Date = new Date();
const startOfCurrentMinute: Date = setStartOfMinute(now);

setStartOfMonth

Takes a given date and mutates it to the start of the given month.

Return type: Date

Example:

import { setStartOfMonth } from '@qntm-code/utils';

const now: Date = new Date();
const startOfCurrentMonth: Date = setStartOfMonth(now);

setStartOfSecond

Takes a given date and mutates it to the start of the given second.

Return type: Date

Example:

import { setStartOfSecond } from '@qntm-code/utils';

const now: Date = new Date();
const startOfCurrentSecond: Date = setStartOfSecond(now);

setStartOfWeek

Takes a given date and mutates it to the start of the given week.

Return type: Date

Example:

import { setStartOfWeek } from '@qntm-code/utils';

const now: Date = new Date();
const startOfCurrentWeek: Date = setStartOfWeek(now);

setStartOfYear

Takes a given date and mutates it to the start of the given year.

Return type: Date

Example:

import { setStartOfYear } from '@qntm-code/utils';

const now: Date = new Date();
const startOfCurrentYear: Date = setStartOfYear(now);

DOM helpers

getAncestors

Gets all the elements that a given element is nested within

Example:

import { getAncestors } from '@qntm-code/utils';

const ancestors: HTMLElement[] = getAncestors(document.getElementById('my-element'));

getNonInlineParent

Gets the first parent of an element that isn't display: inline. Returns null if no matching element

Example:

import { getNonInlineParent } from '@qntm-code/utils';

const nonInlineParent: HTMLElement | null = getNonInlineParent(document.getElementById('my-element'));

getPositionedParent

Gets the first parent element with a relative or absolute position

Example:

import { getPositionedParent } from '@qntm-code/utils';

const ancestors: HTMLElement = getPositionedParent(document.getElementById('my-element'));

getScrollParent

Gets the scrollable parent element of a given element

Example:

import { getScrollParent } from '@qntm-code/utils';

const scrollParent: HTMLElement | null = getScrollParent(document.getElementById('my-element'));

isDisplayInline

Return whether an element is display: inline

Example:

import { isDisplayInline } from '@qntm-code/utils';

const inline: boolean = isDisplayInline(document.getElementById('my-element'));

isVisible

Return whether an element is practically visible, considering things like dimensions of 0, opacity, visibility: hidden and overflow: hidden, and whether the item is scrolled off screen

Example:

import { isVisible } from '@qntm-code/utils';

const visible: boolean = isVisible(document.getElementById('my-element'));

Types

Dictionary

Reusable dictionary type for typed maps

Example:

import { Dictionary } from '@qntm-code/utils';

const dictionary: Dictionary<string> = {
  a: 'yes',
  b: 'no',
};

Attribution

• isArguments, isBuffer, isError, isGeneratorObject, isRegExp, typeOf initially based off Jon Schlinkert's kind-of
• isPlainObject based off Jonschlinkert's is-plain-object
• clone initially based off Jonschlinkert's clone-deep and shallow-clone
• isEqual initially based off Evgeny Poberezkin's fast-deep-equal
• merge initially based off Josh Duff's deepmerge and is-mergeable-object