buxlabs / pure-utilities Goto Github PK

It would be nice to add a utility to sort objects by key, something like:

const { isPlainObject } = require('pure-conditions')

const recursiveSort = (object) => {
  const newObject = {}
  Object.keys(object).sort().forEach(key => {
    const value = object[key]
    if (isPlainObject(value)) {
      newObject[key] = recursiveSort(value)
    } else {
      newObject[key] = value
    }
  })
  return newObject
}

module.exports = {
  recursiveSort
}

Acceptance criteria

• add a recsort method to object/recsort.js
• add specs
• add docs
• the method is pure (does not throw in any case)

Useful links

https://stackoverflow.com/questions/5467129/sort-javascript-object-by-key

e.g. 1024 -> 1 KiB

e.g. something like

function hash () {
  return (((1 + Math.random()) * 0x10000) | 0).toString(16).substring(1);
}

function guid () {
  return hash() + hash() + '-' + hash() + '-' + hash() + '-' + hash() + '-' + hash() + hash() + hash()
}

hours => returns the hour part from the date
minutes => returns the minutes from the date
seconds => returns the seconds from the date

Acceptance criteria

• occurences method in collection.js
• works for arrays (e.g. occurences(["foo", "foo", "bar"], "foo") returns 2)
• works for strings (e.g. occurences("foo foo bar", "foo") returns 2)
• tests
• docs
• examples

Acceptance criteria

• unique method should work correctly for objects within an array

here's a naive implementation, there's probably a better solution

return Array.from(new Set(array.map(item => JSON.stringify(item)))).map(JSON.parse)

https://stackoverflow.com/questions/1349404/generate-random-string-characters-in-javascript

Acceptance criteria

• add partition method to array.js
• add tests
• add docs
• add examples
• method is side effect free (e.g. cannot throw)

Useful links

https://lodash.com/docs/4.17.15#partition
https://stackoverflow.com/questions/11345296/partitioning-in-javascript

Story

As a developer, I'd like to import a function per file so that the bundler I use has less work to do.

Acceptance criteria

• create directories per type (array, string, collection etc.)
• create a file per function (e.g. deepclone, capitalize etc. are in separate files)
• create an index file (array/index.js) that requires all deps from given dir and exports them
• tests should work as they do now

Sometimes we need to define the size of file in bytes, but it is hard to read how many kilobytes or megabytes is has the the file without using calculators or comments.

 // max file size is 400 kB
 const MAX_FILE_SIZE = 409600

 const MAX_FILE_SIZE = prettysize('400KB')

So we could pass to the method string with specific unit for example '10KB' and it would be converted to bytes.

Maybe the better idea is passing to the method a configuration object.

It should join an array elements with comma , separator. The second parameter should be spacing (default set to 0)

Acceptance criteria

• converts more complex strings to number

"100,01" -> 100.01
"100 000,01" -> 100000.01
"100000.01" -> 100000.01
"100000.01" -> 100000.01
"100,000.01" -> 100000.01

Context

In the README, we're stating that the methods are side effect free. Unfortunately it's not true in all of the cases yet.

function deepclone (object) {
  return JSON.parse(JSON.stringify(object))
}

deepclone fn would throw if you'd pass undefined or when the parsed object has circular references.

Acceptance criteria

• ensure deepclone does not throw
• add more tests

We probably need to add a default:

function deepclone (object = {}) {}

and wrap the fn body with try catch. The simplest thing to do is probably just return an empty object if there's an exception.

By definition, all functions should have no side effects. It means that we should never throw.

Acceptance criteria

• do not throw inside of the append/prepend/methods
• append/prepend return the collection instead of throwing
• prettydate returns an empty string instead of throwing

Acceptance criteria

• add mean method to math.js
• add tests
• add docs
• add examples
• method is side effect free (e.g. cannot throw)

Useful links

https://lodash.com/docs/4.17.15#mean

Acceptance criteria

• file per method
• dir -> files, e.g. object -> recsort.js

It doesn't seem to work when ! is used. Probably doesn't work for other special characters too.

occurences("!!oo", "!")
occurences("!!foo", "!")
occurences("!foo bar", "foo")

Newest ava requires unique test names, so they should be adjusted as a part of this task.

Acceptance

• update ava to the latest version
• make names of the tests unique (based on what the test really does)
• tests/linter is passing npm test, npm run lint
• code coverage should still work npm run coverage

When the day number is smaller than 10, the format method should prepend the number with the zero

Acceptance criteria

• the htmlstrip method does not have a risky regexp anymore
• the method still works for simple conditions
• the method does not need to handle all possible edge cases
• mention in docs that stripping html is not a secure method against xss

We're breaking the pure rule in many cases, e.g. in the simple method:

function first (array) {
  return array[0]
}

the following code would throw when there's no array, or something else was passed.

Acceptance criteria

• add default values to functions in array.js, collection.js etc.
• add tests against the undefined case (which is probably the most common one)

Remove ava/nyc to pass the npm audit

Acceptance criteria

• add union method to array.js
• add tests
• add docs
• add examples
• method is side effect free (e.g. cannot throw)

Useful links

https://lodash.com/docs/4.17.15#union

intersection, duplicates, symdifference, difference
https://stackoverflow.com/questions/1187518/how-to-get-the-difference-between-two-arrays-in-javascript/33034768#33034768

• similar implementation like underscore
• add more specs
• bump package
• reuse in es6-to-amd

We'd like to have a utility method for regrouping nested arrays.

Acceptance criteria

• add a zip method array/zip.js
• add specs
• add docs
• the method does not throw in any case

Useful links

https://lodash.com/docs/4.17.15#zip

We can add a new helper which may be helpful in some situations.
For example we sometimes do some operations on collections and later when we want to filter null values we need to use e.g. filter.Boolean()

compactmap should make transformations on elements but omits undefined and null values.
We can add also a strict flag or something similar to remove all falsy values

https://www.avanderlee.com/swift/compactmap-flatmap-differences-explained/
https://www.npmjs.com/package/compact-map