lodash{' '}
+ Designed to work with any other utility library. lodash{" "}
and ramda work great. lodash/fp works best.
@@ -145,8 +145,8 @@ export default memo(({ dispatch }: { dispatch: (any) => {} }) => (
lodash{' '}
+ Designed to work with any other utility library. lodash{" "}
and ramda work great. lodash/fp works
best.
-
-
- futil-js
--
-
- View on GitHub -
- Issues -
-
-
+
+
+
+
+
-
+
-
+
+ futil-js
+-
+
- + View on GitHub + +
- + Issues + +
+
+
+
-
-
-
+
diff --git a/karma.conf.js b/karma.conf.js
index 3a534980..8123af41 100644
--- a/karma.conf.js
+++ b/karma.conf.js
@@ -4,63 +4,63 @@
let local = false
module.exports = function (config) {
- 'use strict'
+ "use strict"
let browsers
let reporters
let jsonReporter = {
stdout: false,
- outputFile: 'browser-results.json', // defaults to none
+ outputFile: "browser-results.json", // defaults to none
}
switch (process.env.TEST_ENV) {
- case 'browser':
+ case "browser":
browsers = Object.keys(customLaunchers)
- reporters = ['dots', 'json', 'saucelabs']
+ reporters = ["dots", "json", "saucelabs"]
break
// default is local
default:
local = true
- browsers = ['Chrome']
- reporters = ['progress', 'json']
+ browsers = ["Chrome"]
+ reporters = ["progress", "json"]
}
config.set({
// base path that will be used to resolve all patterns (eg. files, exclude)
- basePath: '',
+ basePath: "",
// frameworks to use
// available frameworks: https://npmjs.org/browse/keyword/karma-adapter
- frameworks: ['mocha', 'chai'],
+ frameworks: ["mocha", "chai"],
// list of files / patterns to load in the browser
files: [
// Load the babel polyfill
- 'node_modules/babel-polyfill/dist/polyfill.js',
+ "node_modules/babel-polyfill/dist/polyfill.js",
// We need to use singl entry file to avoid circular import error between
// `aspect.js` and `conversion.js`
- 'src/index.js',
- 'test/*.spec.js',
+ "src/index.js",
+ "test/*.spec.js",
],
webpack: {
// kind of a copy of your webpack config
- devtool: 'inline-source-map', // just do inline source maps instead of the default
- mode: 'production',
+ devtool: "inline-source-map", // just do inline source maps instead of the default
+ mode: "production",
module: {
rules: [
{
test: /(\.jsx|\.js)$/,
exclude: /(node_modules|bower_components)/,
use: {
- loader: 'babel-loader',
+ loader: "babel-loader",
},
},
{
// We need to transpile chai-as-promised to ES5
- test: require.resolve('chai-as-promised'),
+ test: require.resolve("chai-as-promised"),
use: {
- loader: 'babel-loader',
+ loader: "babel-loader",
},
},
],
@@ -71,10 +71,10 @@ module.exports = function (config) {
// available preprocessors: https://npmjs.org/browse/keyword/karma-preprocessor
preprocessors: {
// add webpack as preprocessor
- 'src/*.js': ['webpack', 'sourcemap'],
- 'test/*.js': ['webpack', 'sourcemap'],
+ "src/*.js": ["webpack", "sourcemap"],
+ "test/*.js": ["webpack", "sourcemap"],
// We need to transpile chai-as-promised to ES5
- [require.resolve('chai-as-promised')]: ['webpack'],
+ [require.resolve("chai-as-promised")]: ["webpack"],
},
// test results reporter to use
@@ -101,7 +101,7 @@ module.exports = function (config) {
// available browser launchers: https://npmjs.org/browse/keyword/karma-launcher
// browsers: ['Chrome'],
sauceLabs: {
- testName: 'Futil-js browser tests',
+ testName: "Futil-js browser tests",
recordVideo: local,
recordScreenshots: local,
},
@@ -127,34 +127,34 @@ module.exports = function (config) {
// UPDATED to match angular's config https://github.com/angular/angular.js/blob/master/karma-shared.conf.js
let customLaunchers = {
SL_Chrome: {
- base: 'SauceLabs',
- browserName: 'chrome',
- version: 'latest',
+ base: "SauceLabs",
+ browserName: "chrome",
+ version: "latest",
},
- 'SL_Chrome-1': {
- base: 'SauceLabs',
- browserName: 'chrome',
- version: 'latest-1',
+ "SL_Chrome-1": {
+ base: "SauceLabs",
+ browserName: "chrome",
+ version: "latest-1",
},
SL_Firefox: {
- base: 'SauceLabs',
- browserName: 'firefox',
- version: 'latest',
+ base: "SauceLabs",
+ browserName: "firefox",
+ version: "latest",
},
- 'SL_Firefox-1': {
- base: 'SauceLabs',
- browserName: 'firefox',
- version: 'latest-1',
+ "SL_Firefox-1": {
+ base: "SauceLabs",
+ browserName: "firefox",
+ version: "latest-1",
},
- 'SL_Safari-1': {
- base: 'SauceLabs',
- browserName: 'safari',
- version: 'latest-1',
+ "SL_Safari-1": {
+ base: "SauceLabs",
+ browserName: "safari",
+ version: "latest-1",
},
SL_Safari: {
- base: 'SauceLabs',
- browserName: 'safari',
- version: 'latest',
+ base: "SauceLabs",
+ browserName: "safari",
+ version: "latest",
},
// 'SL_IE_9': {
// base: 'SauceLabs',
@@ -164,31 +164,31 @@ let customLaunchers = {
// },
SL_IE_11: {
- base: 'SauceLabs',
- browserName: 'internet explorer',
- platform: 'Windows 8.1',
- version: '11',
+ base: "SauceLabs",
+ browserName: "internet explorer",
+ platform: "Windows 8.1",
+ version: "11",
},
SL_EDGE: {
- base: 'SauceLabs',
- browserName: 'microsoftedge',
- platform: 'Windows 10',
- version: 'latest',
+ base: "SauceLabs",
+ browserName: "microsoftedge",
+ platform: "Windows 10",
+ version: "latest",
},
- 'SL_EDGE-1': {
- base: 'SauceLabs',
- browserName: 'microsoftedge',
- platform: 'Windows 10',
- version: 'latest-1',
+ "SL_EDGE-1": {
+ base: "SauceLabs",
+ browserName: "microsoftedge",
+ platform: "Windows 10",
+ version: "latest-1",
},
SL_iOS: {
- base: 'SauceLabs',
- browserName: 'iphone',
- version: 'latest',
+ base: "SauceLabs",
+ browserName: "iphone",
+ version: "latest",
},
- 'SL_iOS-1': {
- base: 'SauceLabs',
- browserName: 'iphone',
- version: 'latest-1',
+ "SL_iOS-1": {
+ base: "SauceLabs",
+ browserName: "iphone",
+ version: "latest-1",
},
}
diff --git a/renamePackage.js b/renamePackage.js
index 9863964a..d52bb017 100644
--- a/renamePackage.js
+++ b/renamePackage.js
@@ -1,11 +1,11 @@
-let _ = require('lodash/fp')
-let readPkg = require('read-pkg')
-let writePkg = require('write-pkg')
+let _ = require("lodash/fp")
+let readPkg = require("read-pkg")
+let writePkg = require("write-pkg")
-let rename = async (name = 'futil-js') => {
+let rename = async (name = "futil-js") => {
let current = await readPkg()
writePkg(
- _.omit(['_id'], {
+ _.omit(["_id"], {
...current,
name,
})
diff --git a/runkit.example.js b/runkit.example.js
index 825176cd..1b718446 100644
--- a/runkit.example.js
+++ b/runkit.example.js
@@ -1,8 +1,8 @@
-var F = require('futil-js')
+var F = require("futil-js")
-var cities = ['London', 'Boston', 'Lisbon']
+var cities = ["London", "Boston", "Lisbon"]
-F.dotJoinWith((c) => c.startsWith('L'))(cities)
+F.dotJoinWith((c) => c.startsWith("L"))(cities)
// "London.Lisbon"
F.arrayToObject(
diff --git a/scripts/copy-docs.js b/scripts/copy-docs.js
index a07538bc..d512e970 100644
--- a/scripts/copy-docs.js
+++ b/scripts/copy-docs.js
@@ -1,13 +1,16 @@
// This script exists to workaround create-react-app's limitation around importing outside /src
// Once this moves out of docs/beta, we could just drive readme generation out of docs/src/data instead of docs/data and not copy
-import { copyFile, mkdir } from 'fs/promises'
+import { copyFile, mkdir } from "fs/promises"
let run = async () => {
- await mkdir('./docs/beta/src/data', { recursive: true })
- await copyFile('./docs/data/docs.json', './docs/beta/src/data/docs.json')
- await copyFile('./docs/data/tag-docs.json', './docs/beta/src/data/tag-docs.json')
- await copyFile('./docs/data/tests.json', './docs/beta/src/data/tests.json')
+ await mkdir("./docs/beta/src/data", { recursive: true })
+ await copyFile("./docs/data/docs.json", "./docs/beta/src/data/docs.json")
+ await copyFile(
+ "./docs/data/tag-docs.json",
+ "./docs/beta/src/data/tag-docs.json"
+ )
+ await copyFile("./docs/data/tests.json", "./docs/beta/src/data/tests.json")
}
-run()
\ No newline at end of file
+run()
diff --git a/scripts/docs-folder.js b/scripts/docs-folder.js
index 611f75e1..3b6957c6 100644
--- a/scripts/docs-folder.js
+++ b/scripts/docs-folder.js
@@ -1,5 +1,5 @@
-import { mkdir } from 'fs/promises'
+import { mkdir } from "fs/promises"
-let run = async () => await mkdir('./docs/data', { recursive: true })
+let run = async () => await mkdir("./docs/data", { recursive: true })
-run()
\ No newline at end of file
+run()
diff --git a/scripts/generate-docs.js b/scripts/generate-docs.js
index 51be2710..2ab4e175 100644
--- a/scripts/generate-docs.js
+++ b/scripts/generate-docs.js
@@ -1,47 +1,47 @@
-import _ from 'lodash/fp'
-import { writeFile, readFile } from 'fs/promises'
-import docs from '../docs/data/jsdoc.json'
-import { stringify, getTag } from './utils'
+import _ from "lodash/fp"
+import { writeFile, readFile } from "fs/promises"
+import docs from "../docs/data/jsdoc.json"
+import { stringify, getTag } from "./utils"
-let outputDir = './docs/data/'
+let outputDir = "./docs/data/"
-let githubSrcUrl = 'https://github.com/smartprocure/futil-js/blob/master/src/'
+let githubSrcUrl = "https://github.com/smartprocure/futil-js/blob/master/src/"
let getNameFromDoc = _.flow(
- _.get('longname'),
+ _.get("longname"),
// Cases:
// "longname": "module:aspect~aspects.logs",
// "longname": "module:lang.throws",
- _.replace(/module:\w*(~|\.)/, ''),
+ _.replace(/module:\w*(~|\.)/, ""),
// "longname": "convert(_In).hasIn",
- x => _.last(x.split(').'))
+ (x) => _.last(x.split(")."))
)
let seenTags = []
// Memoize so we only read each file once
-let readSourceFile = _.memoize(path => readFile(path, { encoding: 'utf8' }))
+let readSourceFile = _.memoize((path) => readFile(path, { encoding: "utf8" }))
let getDocs = async () => {
let jsDocToJson = _.flow(
- _.reject('undocumented'),
- _.reject({ kind: 'module' }),
- _.filter('name'),
- _.map(async x => {
- let path = x.meta.path + '/' + x.meta.filename
+ _.reject("undocumented"),
+ _.reject({ kind: "module" }),
+ _.filter("name"),
+ _.map(async (x) => {
+ let path = x.meta.path + "/" + x.meta.filename
let file = await readSourceFile(path)
let source = file.slice(...x.meta.range).slice(7)
- let lineCount = _.size(_.split('\n', source))
+ let lineCount = _.size(_.split("\n", source))
// TODO: change to @category or something similar
- let tags = [getTag('tags', x) || x.meta.filename.slice(0, -3)]
+ let tags = [getTag("tags", x) || x.meta.filename.slice(0, -3)]
// Track tags that are new for this method (to insert tag docs)
let unseenTags = _.difference(tags, seenTags)
seenTags = _.uniq(_.concat(seenTags, tags))
return {
name: getNameFromDoc(x),
deprecated: x.deprecated,
- aliases: getTag('aliases', x),
- signature: getTag('signature', x),
+ aliases: getTag("aliases", x),
+ signature: getTag("signature", x),
description: x.description,
- note: getTag('note', x),
+ note: getTag("note", x),
example: _.head(x.examples), // todo: support more?
tags,
unseenTags,
@@ -50,51 +50,51 @@ let getDocs = async () => {
lineno: x.meta.lineno,
// https://github.com/smartprocure/futil-js/blob/master/src/array.js#L20-L25
link: `${githubSrcUrl}${x.meta.filename}#L${x.meta.lineno}${
- lineCount === 1 ? '' : `-L${x.meta.lineno + lineCount - 1}`
+ lineCount === 1 ? "" : `-L${x.meta.lineno + lineCount - 1}`
}`,
}
}),
- x => Promise.all(x)
+ (x) => Promise.all(x)
)
let jsDocToTagDocs = _.flow(
- _.filter({ kind: 'module' }),
+ _.filter({ kind: "module" }),
// Cases:
// "longname": "convert(_In)~inversions",
// "longname": "module:lens"
- _.keyBy(x => _.last(x.longname.split(':'))),
- _.mapValues('description')
+ _.keyBy((x) => _.last(x.longname.split(":"))),
+ _.mapValues("description")
)
let readmeOrder = [
- 'function',
- 'iterators',
- 'logic',
- 'collection',
- 'convert',
- 'convert(_In)',
- 'convert(_On)',
- 'convert(_Indexed)',
- 'array',
- 'object',
- 'string',
- 'regex',
- 'math',
- 'lang',
- 'lens',
- 'aspect',
- 'tree',
+ "function",
+ "iterators",
+ "logic",
+ "collection",
+ "convert",
+ "convert(_In)",
+ "convert(_On)",
+ "convert(_Indexed)",
+ "array",
+ "object",
+ "string",
+ "regex",
+ "math",
+ "lang",
+ "lens",
+ "aspect",
+ "tree",
]
let sortTagsByReadmeOrder = _.sortBy(({ tags }) =>
- _.findIndex(x => x == _.first(tags), readmeOrder)
+ _.findIndex((x) => x == _.first(tags), readmeOrder)
)
let result = sortTagsByReadmeOrder(await jsDocToJson(docs))
- await writeFile(`${outputDir}docs.json`, stringify(result), { flag: 'w' })
+ await writeFile(`${outputDir}docs.json`, stringify(result), { flag: "w" })
let tagDocs = jsDocToTagDocs(docs)
await writeFile(`${outputDir}tag-docs.json`, stringify(tagDocs), {
- flag: 'w',
+ flag: "w",
})
}
diff --git a/scripts/generate-readme.js b/scripts/generate-readme.js
index eb2d0519..ea470653 100644
--- a/scripts/generate-readme.js
+++ b/scripts/generate-readme.js
@@ -1,28 +1,25 @@
-import _ from 'lodash/fp'
-import { writeFile, readFile } from 'fs/promises'
-import docs from '../docs/data/docs.json'
-import tagDocs from '../docs/data/tag-docs.json'
-import { maybeWrap, joinWith } from './utils'
+import _ from "lodash/fp"
+import { writeFile, readFile } from "fs/promises"
+import docs from "../docs/data/docs.json"
+import tagDocs from "../docs/data/tag-docs.json"
+import { maybeWrap, joinWith } from "./utils"
// Renderers for doc fields
-let signature = maybeWrap('`', '`\n')
-let example = maybeWrap('\n\nExample:\n```jsx\n', '\n```')
-let alias = maybeWrap(' (alias: ', ')')
-let note = maybeWrap('\n**Note:** ', '')
+let signature = maybeWrap("`", "`\n")
+let example = maybeWrap("\n\nExample:\n```jsx\n", "\n```")
+let alias = maybeWrap(" (alias: ", ")")
+let note = maybeWrap("\n**Note:** ", "")
-let tag = _.flow(
- _.upperFirst,
- maybeWrap('\n\n## ', '\n')
-)
+let tag = _.flow(_.upperFirst, maybeWrap("\n\n## ", "\n"))
let tagDoc = _.flow(
// getIn is in futil, but simpler to not create nested dependency here
- x => _.get(x, tagDocs),
- maybeWrap('', '\n')
+ (x) => _.get(x, tagDocs),
+ maybeWrap("", "\n")
)
-let tags = joinWith(x => `${tag(x)}${tagDoc(x)}`)
+let tags = joinWith((x) => `${tag(x)}${tagDoc(x)}`)
let apiDocs = joinWith(
- doc => `${tags(doc.unseenTags)}
+ (doc) => `${tags(doc.unseenTags)}
### ${doc.name}${alias(doc.aliases)}
${signature(doc.signature)}${doc.description}${example(doc.example)}${note(
doc.note
@@ -31,9 +28,9 @@ ${signature(doc.signature)}${doc.description}${example(doc.example)}${note(
)
let run = async () => {
- let readmeHeader = await readFile('./scripts/readme-preamble.md')
+ let readmeHeader = await readFile("./scripts/readme-preamble.md")
let markdown = `${readmeHeader}\n# API${apiDocs(docs)}`
- return writeFile('./README.md', markdown, { flag: 'w' })
+ return writeFile("./README.md", markdown, { flag: "w" })
}
run()
diff --git a/scripts/generate-tests-json.js b/scripts/generate-tests-json.js
index 496133d7..eb4b2d8a 100644
--- a/scripts/generate-tests-json.js
+++ b/scripts/generate-tests-json.js
@@ -1,7 +1,7 @@
-import _ from 'lodash/fp'
-import prettier from 'prettier'
-import { readdir, writeFile } from 'fs/promises'
-import { stringify } from './utils'
+import _ from "lodash/fp"
+import prettier from "prettier"
+import { readdir, writeFile } from "fs/promises"
+import { stringify } from "./utils"
let getTests = async () => {
// Collect tests into an object by overriding global test fns
@@ -10,7 +10,7 @@ let getTests = async () => {
global.describe = (name, fn) => fn()
// Capture the tests in an object
global.it = (name, fn) => {
- tests[_.replace('should ', '', name)] = fn
+ tests[_.replace("should ", "", name)] = fn
return {
timeout: () => {},
}
@@ -18,10 +18,10 @@ let getTests = async () => {
// Dynamically import tests to fill the test object
await _.flow(
- _.filter(x => x.match(/spec\.js$/)),
- _.map(path => import(`../test/${path}`)),
- x => Promise.all(x)
- )(await readdir('./test'))
+ _.filter((x) => x.match(/spec\.js$/)),
+ _.map((path) => import(`../test/${path}`)),
+ (x) => Promise.all(x)
+ )(await readdir("./test"))
return tests
}
@@ -45,11 +45,11 @@ let removeTestWrappers = _.flow(
),
_.replace(
/expect\((\(\) => )?(.+?)\)(\.not)?\.to\.throw\((.*?)\)/g,
- (a, b, c, d, e) => `${c}\n/* => throws ${e || 'exception'} */`
+ (a, b, c, d, e) => `${c}\n/* => throws ${e || "exception"} */`
),
_.replace(
/expect\((.+?)\)(\.not)?\.to\.be\.rejectedWith\((.*?)\)/g,
- (a, b, c, d) => `${b}\n/* => throws ${d || 'exception'} */`
+ (a, b, c, d) => `${b}\n/* => throws ${d || "exception"} */`
),
_.replace(
/expect\((.+?)\)(\.not)?\.to(\.deep)?(\.equal|\.eql)\((.+?)\)/gs,
@@ -59,26 +59,26 @@ let removeTestWrappers = _.flow(
let cleanup = _.flow(
_.toString,
- _.split('\n'),
+ _.split("\n"),
// Remove the fn wrapper
- x => x.slice(1, -1),
- _.join('\n'),
+ (x) => x.slice(1, -1),
+ _.join("\n"),
// remove newlines after `{` to force objects as compact as possible
- _.replace(/{\n|\r/g, '{')
+ _.replace(/{\n|\r/g, "{")
)
-let format = code =>
+let format = (code) =>
prettier.format(code, {
semi: false,
singleQuote: true,
- parser: 'babel',
- arrowParens: 'avoid',
+ parser: "babel",
+ arrowParens: "avoid",
})
let run = async () => {
let tests = await getTests()
- let content = _.mapValues(test => {
+ let content = _.mapValues((test) => {
let code = format(cleanup(test))
try {
// Attempt to remove test wrappers but fallback if prettier explodes due to invalid JS
@@ -88,7 +88,7 @@ let run = async () => {
}
}, tests)
- let outputDir = './docs/data/'
+ let outputDir = "./docs/data/"
return writeFile(`${outputDir}tests.json`, stringify(content))
}
diff --git a/scripts/readme-preamble.md b/scripts/readme-preamble.md
index ccce2110..4a2a95f0 100644
--- a/scripts/readme-preamble.md
+++ b/scripts/readme-preamble.md
@@ -19,20 +19,23 @@ A collection of F(unctional) Util(ities). Resistance is futile.
Mostly, these are generic utilities that could conceivably be part of a library like [lodash/fp](https://github.com/lodash/lodash/wiki/FP-Guide), but for one reason or another are not.
# Docs
+
https://smartprocure.github.io/futil-js/
# Version History/Changelog
+
See our [changelog](https://github.com/smartprocure/futil-js/blob/master/CHANGELOG.md)
# Installing
+
`npm i -S futil`
or
`npm i -S futil-js`
-
This package requires `lodash/fp`, so make sure that's available in your app.
# Usage
+
`import * as F from 'futil'`
or
`import F from 'futil'`
diff --git a/scripts/utils.js b/scripts/utils.js
index 52e02b82..646278e8 100644
--- a/scripts/utils.js
+++ b/scripts/utils.js
@@ -1,18 +1,13 @@
-import _ from 'lodash/fp'
+import _ from "lodash/fp"
-export let stringify = data => JSON.stringify(data, 0, 2)
+export let stringify = (data) => JSON.stringify(data, 0, 2)
-export let joinWith = _.curry((f, data) =>
- _.flow(
- _.map,
- _.join('')
- )(f, data)
-)
+export let joinWith = _.curry((f, data) => _.flow(_.map, _.join(""))(f, data))
// Gets a tag value from a jsdoc entry
-export let getTag = (tag, x) => _.get('text', _.find({ title: tag }, x.tags))
+export let getTag = (tag, x) => _.get("text", _.find({ title: tag }, x.tags))
/// TODO::: replace `wrap` with this
export let maybeWrap = _.curry((left, right, center) =>
- center ? left + center + right : ''
+ center ? left + center + right : ""
)
diff --git a/src/array.js b/src/array.js
index 70ff0c8e..b881205c 100644
--- a/src/array.js
+++ b/src/array.js
@@ -1,7 +1,7 @@
-import _ from 'lodash/fp'
-import { callOrReturn } from './function'
-import { insertAtIndex } from './collection'
-import { reduceIndexed } from './conversion'
+import _ from "lodash/fp"
+import { callOrReturn } from "./function"
+import { insertAtIndex } from "./collection"
+import { reduceIndexed } from "./conversion"
// TODO: Move to proper files and expose
let callUnless = (check) => (failFn) => (fn) => (x, y) =>
@@ -24,14 +24,14 @@ export let compactJoin = _.curry((join, x) => _.compact(x).join(join))
*
* @signature [string1, string2, ...stringN] -> string1 + '.' + string2 + '.' ... + stringN
*/
-export let dotJoin = compactJoin('.')
+export let dotJoin = compactJoin(".")
/**
* Compacts an array by the provided function, then joins it with `.`
*
* @signature filterFunction -> [string1, string2, ...stringN] -> string1 + '.' + string2 + '.' ... + stringN
*/
-export let dotJoinWith = (fn) => (x) => _.filter(fn, x).join('.')
+export let dotJoinWith = (fn) => (x) => _.filter(fn, x).join(".")
/**
* Returns an array of elements that are repeated in the array.
@@ -142,14 +142,14 @@ export let encoder = (separator) => ({
*
* @signature { encode: ['a', 'b'] -> 'a.b', decode: 'a.b' -> ['a', 'b'] }
*/
-export let dotEncoder = encoder('.')
+export let dotEncoder = encoder(".")
/**
* An encoder using `/` as the separator
*
* @signature { encode: ['a', 'b'] -> 'a/b', decode: 'a/b' -> ['a', 'b'] }
*/
-export let slashEncoder = encoder('/')
+export let slashEncoder = encoder("/")
/**
* Takes a predicate function and an array, and returns an array of arrays where each element has one or more elements of the original array. Similar to Haskell's [groupBy](http://zvon.org/other/haskell/Outputlist/groupBy_f.html).
diff --git a/src/aspect.js b/src/aspect.js
index 7f01d489..8f7d1538 100644
--- a/src/aspect.js
+++ b/src/aspect.js
@@ -16,9 +16,9 @@
* @module aspect
*/
-import _ from 'lodash/fp'
-import { defaultsOn, setOn } from './conversion'
-import { throws, tapError } from './lang'
+import _ from "lodash/fp"
+import { defaultsOn, setOn } from "./conversion"
+import { throws, tapError } from "./lang"
/**
* The aspect api takes an options object and returns a function which takes a function to wrap.
@@ -50,7 +50,7 @@ Options supports the following parameters:
*/
export let aspect =
({
- name = 'aspect',
+ name = "aspect",
init = _.noop,
after = _.noop,
before = _.noop,
@@ -95,7 +95,7 @@ export let aspect =
*/
export let aspectSync =
({
- name = 'aspect',
+ name = "aspect",
init = _.noop,
after = _.noop,
before = _.noop,
@@ -131,19 +131,19 @@ let logs = (extend = defaultsOn) =>
aspect({
init: extend({ logs: [] }),
after: (result, state) => state.logs.push(result),
- name: 'logs',
+ name: "logs",
})
let error = (extend = defaultsOn) =>
aspect({
init: extend({ error: null }),
- onError: setOn('error'),
- name: 'error',
+ onError: setOn("error"),
+ name: "error",
})
let errors = (extend = defaultsOn) =>
aspect({
init: extend({ errors: [] }),
onError: (e, state) => state.errors.push(e),
- name: 'errors',
+ name: "errors",
})
let status = (extend = defaultsOn) =>
aspect({
@@ -155,21 +155,21 @@ let status = (extend = defaultsOn) =>
// Computed get/set properties don't work, probably because lodash extend methods don't support copying them
setStatus(x) {
this.status = x
- this.failed = x === 'failed'
- this.succeeded = x === 'succeeded'
- this.processing = x === 'processing'
+ this.failed = x === "failed"
+ this.succeeded = x === "succeeded"
+ this.processing = x === "processing"
},
}),
before(params, state) {
- state.setStatus('processing')
+ state.setStatus("processing")
},
after(result, state) {
- state.setStatus('succeeded')
+ state.setStatus("succeeded")
},
onError: tapError((e, state) => {
- state.setStatus('failed')
+ state.setStatus("failed")
}),
- name: 'status',
+ name: "status",
})
let clearStatus = (timeout = 500) =>
aspect({
@@ -180,17 +180,17 @@ let clearStatus = (timeout = 500) =>
}, timeout)
}
},
- name: 'clearStatus',
+ name: "clearStatus",
})
// This is a function just for consistency
let concurrency = () =>
aspect({
before(params, state) {
if (state.processing) {
- throw Error('Concurrent Runs Not Allowed')
+ throw Error("Concurrent Runs Not Allowed")
}
},
- name: 'concurrency',
+ name: "concurrency",
})
let command = (extend, timeout) =>
@@ -205,9 +205,9 @@ let deprecate = (subject, version, alternative) =>
aspectSync({
before: () =>
console.warn(
- `\`${subject}\` is deprecated${version ? ` as of ${version}` : ''}${
- alternative ? ` in favor of \`${alternative}\`` : ''
- } ${_.trim((Error().stack || '').split('\n')[3])}`
+ `\`${subject}\` is deprecated${version ? ` as of ${version}` : ""}${
+ alternative ? ` in favor of \`${alternative}\`` : ""
+ } ${_.trim((Error().stack || "").split("\n")[3])}`
),
init(state) {
state.isDeprecated = true
diff --git a/src/collection.js b/src/collection.js
index d79f0ee3..77c951a9 100644
--- a/src/collection.js
+++ b/src/collection.js
@@ -1,5 +1,5 @@
-import _ from 'lodash/fp'
-import { isTraversable } from './tree'
+import _ from "lodash/fp"
+import { isTraversable } from "./tree"
/**
* Maps a flow of `f1, f2, ...fn` over a collection.
diff --git a/src/conversion.js b/src/conversion.js
index d63c5d9f..b2deb2a0 100644
--- a/src/conversion.js
+++ b/src/conversion.js
@@ -1,5 +1,5 @@
-import _ from 'lodash/fp'
-import { aspects } from './aspect'
+import _ from "lodash/fp"
+import { aspects } from "./aspect"
const noRearg = _.convert({ rearg: false })
const mutable = _.convert({ immutable: false })
@@ -119,19 +119,19 @@ export const updateOn = mutable.update
// Un-prefixed Deprecated
export const reduce = aspects.deprecate(
- 'reduce',
- '1.28.0',
- 'reduceIndexed'
+ "reduce",
+ "1.28.0",
+ "reduceIndexed"
)(noCap.reduce)
export const mapValues = aspects.deprecate(
- 'mapValues',
- '1.28.0',
- 'mapValuesIndexed'
+ "mapValues",
+ "1.28.0",
+ "mapValuesIndexed"
)(noCap.mapValues)
export const each = aspects.deprecate(
- 'each',
- '1.28.0',
- 'eachIndexed'
+ "each",
+ "1.28.0",
+ "eachIndexed"
)(noCap.each)
/**
diff --git a/src/function.js b/src/function.js
index fe299a6c..172fd455 100644
--- a/src/function.js
+++ b/src/function.js
@@ -1,4 +1,4 @@
-import _ from 'lodash/fp'
+import _ from "lodash/fp"
/**
* If `fn` is a function, call the function with the passed-in arguments. Otherwise, return `false`.
diff --git a/src/index.js b/src/index.js
index cec49999..beef707f 100644
--- a/src/index.js
+++ b/src/index.js
@@ -1,32 +1,32 @@
-import _ from 'lodash/fp'
+import _ from "lodash/fp"
-export * from './conversion'
-export * from './collection'
-export * from './function'
-export * from './string'
-export * from './object'
-export * from './aspect'
-export * from './array'
-export * from './logic'
-export * from './regex'
-export * from './lang'
-export * from './lens'
-export * from './tree'
-export * from './iterators'
+export * from "./conversion"
+export * from "./collection"
+export * from "./function"
+export * from "./string"
+export * from "./object"
+export * from "./aspect"
+export * from "./array"
+export * from "./logic"
+export * from "./regex"
+export * from "./lang"
+export * from "./lens"
+export * from "./tree"
+export * from "./iterators"
-import * as conversion from './conversion'
-import * as collection from './collection'
-import * as fn from './function'
-import * as string from './string'
-import * as object from './object'
-import * as aspect from './aspect'
-import * as array from './array'
-import * as logic from './logic'
-import * as regex from './regex'
-import * as lang from './lang'
-import * as lens from './lens'
-import * as tree from './tree'
-import * as iterators from './iterators'
+import * as conversion from "./conversion"
+import * as collection from "./collection"
+import * as fn from "./function"
+import * as string from "./string"
+import * as object from "./object"
+import * as aspect from "./aspect"
+import * as array from "./array"
+import * as logic from "./logic"
+import * as regex from "./regex"
+import * as lang from "./lang"
+import * as lens from "./lens"
+import * as tree from "./tree"
+import * as iterators from "./iterators"
// Math
// ----
@@ -50,8 +50,8 @@ export const greaterThanOne = _.lt(1)
*/
export const isPromise = (obj) =>
!!obj &&
- (typeof obj === 'object' || typeof obj === 'function') &&
- typeof obj.then === 'function'
+ (typeof obj === "object" || typeof obj === "function") &&
+ typeof obj.then === "function"
// Version
// ----
diff --git a/src/iterators.js b/src/iterators.js
index 4ddefdca..ea5be5da 100644
--- a/src/iterators.js
+++ b/src/iterators.js
@@ -1,4 +1,4 @@
-import _ from 'lodash/fp'
+import _ from "lodash/fp"
/**
* Creates an iterator that handles the last item differently for use in any function that passes `(value, index, list)` (e.g. `mapIndexed`, `eachIndexed`, etc). Both the two handlers and the result are iterator functions that take `(value, index, list)`.
diff --git a/src/lang.js b/src/lang.js
index a738cc00..0d255351 100644
--- a/src/lang.js
+++ b/src/lang.js
@@ -3,8 +3,8 @@
* @module lang
*/
-import _ from 'lodash/fp'
-import { tree } from './tree'
+import _ from "lodash/fp"
+import { tree } from "./tree"
/**
* Just throws whatever it is passed.
@@ -54,7 +54,7 @@ export let append = _.curry((x, y) => y + x)
*/
export let isBlank = _.overSome([
_.isNil,
- _.isEqual(''),
+ _.isEqual(""),
_.isEqual([]),
_.isEqual({}),
])
diff --git a/src/lens.js b/src/lens.js
index 6c401e3e..9188e5e9 100644
--- a/src/lens.js
+++ b/src/lens.js
@@ -37,10 +37,10 @@
* @module lens
*/
-import _ from 'lodash/fp'
-import { setOn } from './conversion'
-import { toggleElementBy } from './array'
-import { when } from './logic'
+import _ from "lodash/fp"
+import { setOn } from "./conversion"
+import { toggleElementBy } from "./array"
+import { when } from "./logic"
// Stubs
@@ -223,14 +223,14 @@ export let domLens = {
* return
* }
*/
- value: targetBinding('value'),
+ value: targetBinding("value"),
/**
* Creates an includeLens and maps view to checked and set to `onChange` (set with `e.target.checked` or `e` if that path isn't present)
*
* @signature (value, lens) -> {checked, onChange}
*/
- checkboxValues: _.flow(includeLens, targetBinding('checked')),
+ checkboxValues: _.flow(includeLens, targetBinding("checked")),
/**
* Takes a lens and returns on onMouseEnter which calls `on` on the lens and onMouseLeave which calls `off`. Models a mapping of "hovering" to a boolean.
diff --git a/src/logic.js b/src/logic.js
index 36b4a7ec..c2bb7316 100644
--- a/src/logic.js
+++ b/src/logic.js
@@ -1,6 +1,6 @@
-import _ from 'lodash/fp'
-import { callOrReturn } from './function'
-import { exists } from './lang'
+import _ from "lodash/fp"
+import { callOrReturn } from "./function"
+import { exists } from "./lang"
/**
* Creates a function that checks if none of the array of predicates passed in returns truthy for `x`
diff --git a/src/object.js b/src/object.js
index 76a3422e..8471157b 100644
--- a/src/object.js
+++ b/src/object.js
@@ -1,7 +1,7 @@
-import _ from 'lodash/fp'
-import { dotJoinWith, zipObjectDeepWith } from './array'
-import { overNone, ifElse } from './logic'
-import { isNotNil, isBlank } from './lang'
+import _ from "lodash/fp"
+import { dotJoinWith, zipObjectDeepWith } from "./array"
+import { overNone, ifElse } from "./logic"
+import { isNotNil, isBlank } from "./lang"
import {
reduceIndexed,
pickIn,
@@ -9,10 +9,10 @@ import {
hasIn,
mapIndexed,
mapValuesIndexed,
-} from './conversion'
-import { findApply } from './collection'
-import { aspects } from './aspect'
-import { mapArgs } from './function'
+} from "./conversion"
+import { findApply } from "./collection"
+import { aspects } from "./aspect"
+import { mapArgs } from "./function"
const noCap = _.convert({ cap: false })
/**
@@ -168,9 +168,9 @@ export const compareDeep = _.curry(
* @deprecated 1.46.0
*/
export const mapProp = aspects.deprecate(
- 'mapProp',
- '1.46.0',
- '_.update'
+ "mapProp",
+ "1.46.0",
+ "_.update"
)(noCap.update)
/**
@@ -252,7 +252,7 @@ export let simpleDiff = (original, deltas) => {
*
* @signature (from, to) -> [simpleDiffChanges]
*/
-export let simpleDiffArray = _.flow(simpleDiff, unkeyBy('field'))
+export let simpleDiffArray = _.flow(simpleDiff, unkeyBy("field"))
/**
* Same as `simpleDiff`, but also takes in count deleted properties.
@@ -275,7 +275,7 @@ export let diff = (original, deltas) => {
* @signature (from, to) -> [diffChanges]
* @note We're considering not maintaining this in the long term, so you might probably have more success with any existing library for this purpose.
*/
-export let diffArray = _.flow(diff, unkeyBy('field'))
+export let diffArray = _.flow(diff, unkeyBy("field"))
/**
* A `_.pick` that mutates the object
diff --git a/src/regex.js b/src/regex.js
index d273b2b9..3ebb28b4 100644
--- a/src/regex.js
+++ b/src/regex.js
@@ -1,6 +1,6 @@
-import _ from 'lodash/fp'
-import { push, mergeRanges } from './array'
-import { insertAtIndex } from './collection'
+import _ from "lodash/fp"
+import { push, mergeRanges } from "./array"
+import { insertAtIndex } from "./collection"
/**
* Just like ramda test, creates a function to test a regex on a string.
@@ -23,18 +23,18 @@ export const makeRegex = (options) => (text) => RegExp(text, options)
*/
export const makeAndTest = (options) => _.flow(makeRegex(options), testRegex)
-export const anyWordToRegexp = _.flow(_.words, _.join('|'))
+export const anyWordToRegexp = _.flow(_.words, _.join("|"))
export const wordsToRegexp = _.flow(
_.words,
_.map((x) => `(?=.*${x}.*)`),
- _.join(''),
+ _.join(""),
(x) => `.*${x}.*`
)
const matchWords = _.curry((buildRegex, x) => {
// Not inlining so that we don't create the regexp every time
- const regexp = RegExp(buildRegex(x), 'gi')
+ const regexp = RegExp(buildRegex(x), "gi")
return (y) => !!(y && y.match(regexp))
})
@@ -60,7 +60,7 @@ export const matchAnyWord = matchWords(anyWordToRegexp)
*/
export const allMatches = _.curry((regexStr, str) => {
let matched
- const regex = new RegExp(regexStr, 'g')
+ const regex = new RegExp(regexStr, "g")
const result = []
while ((matched = regex.exec(str)) !== null) {
@@ -82,7 +82,7 @@ export const allMatches = _.curry((regexStr, str) => {
export const postings = _.curry((regex, str) => {
var match = regex.exec(str)
let result = []
- if (regex.flags.indexOf('g') < 0 && match) {
+ if (regex.flags.indexOf("g") < 0 && match) {
result.push([match.index, match.index + match[0].length])
} else {
while (match) {
@@ -105,7 +105,7 @@ export const postings = _.curry((regex, str) => {
*/
export const postingsForWords = _.curry((string, str) =>
_.reduce(
- (result, word) => push(postings(RegExp(word, 'gi'), str), result),
+ (result, word) => push(postings(RegExp(word, "gi"), str), result),
[]
)(_.words(string))
)
diff --git a/src/string.js b/src/string.js
index 13e92765..b4f02c05 100644
--- a/src/string.js
+++ b/src/string.js
@@ -1,11 +1,11 @@
-import { map } from './collection'
-import _ from 'lodash/fp'
-import { when } from './logic'
-import { intersperse } from './array'
-import { differentLast } from './iterators'
+import { map } from "./collection"
+import _ from "lodash/fp"
+import { when } from "./logic"
+import { intersperse } from "./array"
+import { differentLast } from "./iterators"
export const wrap = (pre, post, content) =>
- (pre || '') + content + (post || pre || '')
+ (pre || "") + content + (post || pre || "")
export const quote = _.partial(wrap, ['"', '"'])
/**
@@ -13,8 +13,8 @@ export const quote = _.partial(wrap, ['"', '"'])
*
* @signature 'asdf' -> '(asdf)'
*/
-export const parens = _.partial(wrap, ['(', ')'])
-export const concatStrings = _.flow(_.compact, _.map(_.trim), _.join(' '))
+export const parens = _.partial(wrap, ["(", ")"])
+export const concatStrings = _.flow(_.compact, _.map(_.trim), _.join(" "))
/**
* Maps `_.trim` through all the strings of a given object or array.
@@ -61,7 +61,7 @@ export let toSentenceWith = _.curry((separator, lastSeparator, array) =>
() => lastSeparator
)
),
- _.join('')
+ _.join("")
)(array)
)
@@ -71,7 +71,7 @@ export let toSentenceWith = _.curry((separator, lastSeparator, array) =>
* @signature array => string
* @example ['a', 'b', 'c'] -> 'a, b and c'
*/
-export let toSentence = toSentenceWith(', ', ' and ')
+export let toSentence = toSentenceWith(", ", " and ")
/**
* Allows passing a "cachizer" function (`array -> object`) to override the way `uniqueString`'s initial array is converted into a cache object. Can be curried to create a custom `uniqueString` function, eg: `let myUniqueString = uniqueStringWith(myFunc)`
diff --git a/src/tree.js b/src/tree.js
index 42387833..5ed9ddf7 100644
--- a/src/tree.js
+++ b/src/tree.js
@@ -5,9 +5,9 @@
* @module tree
*/
-import _ from 'lodash/fp'
-import { findIndexed } from './conversion'
-import { push, dotEncoder, slashEncoder } from './array'
+import _ from "lodash/fp"
+import { findIndexed } from "./conversion"
+import { push, dotEncoder, slashEncoder } from "./array"
/**
* A default check if something can be traversed - currently it is arrays and plain objects.
diff --git a/test/array.spec.js b/test/array.spec.js
index 122e2a9d..1f7a1d10 100644
--- a/test/array.spec.js
+++ b/test/array.spec.js
@@ -1,45 +1,45 @@
-import chai from 'chai'
-import F from '../src/'
+import chai from "chai"
+import F from "../src/"
chai.expect()
const expect = chai.expect
-describe('Array Functions', () => {
- it('compactJoin', () => {
- expect(F.compactJoin(',', [1, undefined, 2, null, 3])).to.equal('1,2,3')
- expect(F.compactJoin(' and ', [null, 'Alice', 'Bob', false])).to.equal(
- 'Alice and Bob'
+describe("Array Functions", () => {
+ it("compactJoin", () => {
+ expect(F.compactJoin(",", [1, undefined, 2, null, 3])).to.equal("1,2,3")
+ expect(F.compactJoin(" and ", [null, "Alice", "Bob", false])).to.equal(
+ "Alice and Bob"
)
})
- it('dotJoin', () => {
- expect(F.dotJoin([1, undefined, 2, null, 3])).to.equal('1.2.3')
- expect(F.dotJoin([null, 'Alice', 'Bob', false])).to.equal('Alice.Bob')
+ it("dotJoin", () => {
+ expect(F.dotJoin([1, undefined, 2, null, 3])).to.equal("1.2.3")
+ expect(F.dotJoin([null, "Alice", "Bob", false])).to.equal("Alice.Bob")
})
- it('repeated', () => {
+ it("repeated", () => {
expect(F.repeated([1, 1, 2, 3, 3, 4])).to.deep.equal([1, 3])
- expect(F.repeated(['a', 'b', 'b'])).to.deep.equal(['b'])
+ expect(F.repeated(["a", "b", "b"])).to.deep.equal(["b"])
})
- it('push', () => {
+ it("push", () => {
let arr = [1, 2, 3]
expect(F.push(4)(arr)).to.deep.equal([1, 2, 3, 4])
expect(arr).to.deep.equal([1, 2, 3])
})
- it('pushIn', () => {
+ it("pushIn", () => {
let arr = [1, 2, 3]
expect(F.pushIn(arr)(4)).to.deep.equal([1, 2, 3, 4])
expect(arr).to.deep.equal([1, 2, 3])
})
- it('pushOn', () => {
+ it("pushOn", () => {
let arr = [1, 2, 3]
expect(F.pushOn(arr)(4)).to.deep.equal([1, 2, 3, 4])
expect(arr).to.deep.equal([1, 2, 3, 4])
})
- it('moveIndex', () => {
+ it("moveIndex", () => {
let arr = [1, 2, 3]
let x = F.moveIndex(1, 0, arr)
expect(x).to.deep.equal([2, 1, 3])
expect(arr).to.deep.equal([1, 2, 3])
})
- it('mergeRanges', () => {
+ it("mergeRanges", () => {
// arrays need to be sorted in ascending order
expect(
F.mergeRanges([
@@ -57,7 +57,7 @@ describe('Array Functions', () => {
])
).to.deep.equal([[0, 5]])
})
- it('cycle', () => {
+ it("cycle", () => {
let cycle = F.cycle([1, 2, 3])
expect(cycle(1)).to.equal(2)
expect(cycle(2)).to.equal(3)
@@ -71,54 +71,54 @@ describe('Array Functions', () => {
expect(F.cycle([true, false], true)).to.be.false
})
- it('arrayToObject', () => {
+ it("arrayToObject", () => {
expect(
F.arrayToObject(
(x) => `key${x}`,
(x) => `val${x}`,
- ['a', 'b', 'c']
+ ["a", "b", "c"]
)
- ).to.deep.equal({ keya: 'vala', keyb: 'valb', keyc: 'valc' })
+ ).to.deep.equal({ keya: "vala", keyb: "valb", keyc: "valc" })
})
- it('zipObjectDeepWith', () => {
- expect(F.zipObjectDeepWith(['a', 'b'], () => 1)).to.deep.equal({
+ it("zipObjectDeepWith", () => {
+ expect(F.zipObjectDeepWith(["a", "b"], () => 1)).to.deep.equal({
a: 1,
b: 1,
})
})
- it('flags', () => {
- expect(F.flags(['a', 'b', 'c'])).to.deep.equal({
+ it("flags", () => {
+ expect(F.flags(["a", "b", "c"])).to.deep.equal({
a: true,
b: true,
c: true,
})
})
- it('prefixes', () => {
- expect(F.prefixes(['root', 'criteria', 'someNode'])).to.deep.equal([
- ['root'],
- ['root', 'criteria'],
- ['root', 'criteria', 'someNode'],
+ it("prefixes", () => {
+ expect(F.prefixes(["root", "criteria", "someNode"])).to.deep.equal([
+ ["root"],
+ ["root", "criteria"],
+ ["root", "criteria", "someNode"],
])
- expect(F.prefixes('abc')).to.deep.equal([
- ['a'],
- ['a', 'b'],
- ['a', 'b', 'c'],
+ expect(F.prefixes("abc")).to.deep.equal([
+ ["a"],
+ ["a", "b"],
+ ["a", "b", "c"],
])
})
- it('encoder', () => {
- let encoder = F.encoder('->')
- expect(encoder.encode(['a', 'b'])).to.equal('a->b')
- expect(encoder.decode('a->b')).to.deep.equal(['a', 'b'])
+ it("encoder", () => {
+ let encoder = F.encoder("->")
+ expect(encoder.encode(["a", "b"])).to.equal("a->b")
+ expect(encoder.decode("a->b")).to.deep.equal(["a", "b"])
})
- it('dotEncoder', () => {
- expect(F.dotEncoder.encode(['a', 'b'])).to.equal('a.b')
- expect(F.dotEncoder.decode('a.b')).to.deep.equal(['a', 'b'])
+ it("dotEncoder", () => {
+ expect(F.dotEncoder.encode(["a", "b"])).to.equal("a.b")
+ expect(F.dotEncoder.decode("a.b")).to.deep.equal(["a", "b"])
})
- it('slashEncoder', () => {
- expect(F.slashEncoder.encode(['a', 'b'])).to.equal('a/b')
- expect(F.slashEncoder.decode('a/b')).to.deep.equal(['a', 'b'])
+ it("slashEncoder", () => {
+ expect(F.slashEncoder.encode(["a", "b"])).to.equal("a/b")
+ expect(F.slashEncoder.decode("a/b")).to.deep.equal(["a", "b"])
})
- it('chunkBy', () => {
+ it("chunkBy", () => {
expect(
F.chunkBy(([a], b) => b % a === 0, [2, 2, 2, 3, 2, 2])
).to.deep.equal([[2, 2, 2], [3], [2, 2]])
@@ -133,50 +133,50 @@ describe('Array Functions', () => {
expect(F.chunkBy(() => false, undefined)).to.deep.equal([])
expect(F.chunkBy(() => false, [])).to.deep.equal([])
})
- it('toggleElement', () => {
- expect(F.toggleElement('b', ['a', 'b', 'c', 'd'])).to.deep.equal([
- 'a',
- 'c',
- 'd',
+ it("toggleElement", () => {
+ expect(F.toggleElement("b", ["a", "b", "c", "d"])).to.deep.equal([
+ "a",
+ "c",
+ "d",
])
- expect(F.toggleElement('b', ['a', 'c', 'd'])).to.deep.equal([
- 'a',
- 'c',
- 'd',
- 'b',
+ expect(F.toggleElement("b", ["a", "c", "d"])).to.deep.equal([
+ "a",
+ "c",
+ "d",
+ "b",
])
})
- it('toggleElementBy', () => {
- let list = ['a', 'b', 'c']
- let valueToToggle = 'b'
+ it("toggleElementBy", () => {
+ let list = ["a", "b", "c"]
+ let valueToToggle = "b"
let toggleB = (shouldAdd) =>
F.toggleElementBy(!shouldAdd, valueToToggle, list)
- expect(toggleB(true)).to.deep.equal(['a', 'b', 'c', 'b'])
- expect(toggleB(false)).to.deep.equal(['a', 'c'])
+ expect(toggleB(true)).to.deep.equal(["a", "b", "c", "b"])
+ expect(toggleB(false)).to.deep.equal(["a", "c"])
})
- it('intersperse', () => {
+ it("intersperse", () => {
expect(
F.intersperse(
- (acc, i, xs) => (i === xs.length - 1 ? 'and finally' : 'and'),
+ (acc, i, xs) => (i === xs.length - 1 ? "and finally" : "and"),
[1, 2, 3, 4]
)
- ).to.deep.equal([1, 'and', 2, 'and', 3, 'and finally', 4])
- expect(F.intersperse('and', [1, 2, 3])).to.deep.equal([
+ ).to.deep.equal([1, "and", 2, "and", 3, "and finally", 4])
+ expect(F.intersperse("and", [1, 2, 3])).to.deep.equal([
1,
- 'and',
+ "and",
2,
- 'and',
+ "and",
3,
])
})
- it('replaceElementBy', () => {
+ it("replaceElementBy", () => {
expect(F.replaceElementBy((c) => c > 10, 0, [1, 11, 3, 5])).to.deep.equal([
1, 0, 3, 5,
])
})
- it('replaceElement', () => {
+ it("replaceElement", () => {
expect(F.replaceElement(11, 0, [1, 11, 3, 5])).to.deep.equal([1, 0, 3, 5])
})
})
diff --git a/test/aspect.spec.js b/test/aspect.spec.js
index 6352a367..56918f14 100644
--- a/test/aspect.spec.js
+++ b/test/aspect.spec.js
@@ -1,14 +1,14 @@
-import _ from 'lodash/fp'
-import chai from 'chai'
-import chaiAsPromised from 'chai-as-promised'
-import { aspects, aspect, aspectSync } from '../src'
-import Promise from 'bluebird'
+import _ from "lodash/fp"
+import chai from "chai"
+import chaiAsPromised from "chai-as-promised"
+import { aspects, aspect, aspectSync } from "../src"
+import Promise from "bluebird"
chai.use(chaiAsPromised)
chai.expect()
const expect = chai.expect
-describe('Aspect Functions', () => {
+describe("Aspect Functions", () => {
// Example Aspect composition
let Command = _.flow(
aspects.status(),
@@ -17,7 +17,7 @@ describe('Aspect Functions', () => {
aspects.errors()
)
- it('should combine aspect states', async () => {
+ it("should combine aspect states", async () => {
let f = Command(() => 6)
expect(f.state.status).to.equal(null)
expect(f.state.processing).to.be.false
@@ -26,49 +26,49 @@ describe('Aspect Functions', () => {
expect(f.state.logs).to.deep.equal([])
expect(f.state.errors).to.deep.equal([])
})
- it('should support .after calls (`logs` aspect)', async () => {
+ it("should support .after calls (`logs` aspect)", async () => {
let f = Command(() => 6)
await f()
expect(f.state.logs).to.deep.equal([6])
await f()
expect(f.state.logs).to.deep.equal([6, 6])
})
- it('should support .onError and before (`concurrency`, `errors`, and `status` aspects)', async () => {
+ it("should support .onError and before (`concurrency`, `errors`, and `status` aspects)", async () => {
let g = Command(() => {
throw Error(5)
})
expect(g.state.processing).to.be.false
await g()
- expect(g.state.errors[0].message).to.equal('5')
+ expect(g.state.errors[0].message).to.equal("5")
expect(g.state.processing).to.be.false
// Should be blocked as a concurrent run since it's still processing
g.state.processing = true
await g()
- expect(g.state.errors[1].message).to.equal('Concurrent Runs Not Allowed')
+ expect(g.state.errors[1].message).to.equal("Concurrent Runs Not Allowed")
})
- it('should support throwing in onError', async () => {
+ it("should support throwing in onError", async () => {
// Use the single error object to avoid 'Unhandled promise rejection' in
// some browsers.
- let theException = new Error('hi from aspect')
+ let theException = new Error("hi from aspect")
let ThrowHi = aspect({
onError() {
throw theException
},
})
let throwsHi = ThrowHi(() => {
- throw Error('Not hi')
+ throw Error("Not hi")
})
expect(throwsHi()).to.be.rejectedWith(theException)
})
- it('should support single error', async () => {
+ it("should support single error", async () => {
let throwsHi = aspects.error()(() => {
- throw Error('Hi')
+ throw Error("Hi")
})
await throwsHi()
- expect(throwsHi.state.error.message).to.equal('Hi')
+ expect(throwsHi.state.error.message).to.equal("Hi")
})
- it('should support status and clearing status', async () => {
+ it("should support status and clearing status", async () => {
// Increase the timeout/delay to hundreds ms to make testing IE9/10/11 more
// stable & avoid exception:
// AssertionError: expected null to equal 'processing'
@@ -76,18 +76,18 @@ describe('Aspect Functions', () => {
let f = clearingStatus(async () => Promise.delay(200))
let result = f()
await Promise.delay(100)
- expect(f.state.status).to.equal('processing')
+ expect(f.state.status).to.equal("processing")
expect(f.state.processing).to.be.true
await result
- expect(f.state.status).to.equal('succeeded')
+ expect(f.state.status).to.equal("succeeded")
expect(f.state.succeeded).to.be.true
await Promise.delay(300)
expect(f.state.status).to.equal(null)
let g = clearingStatus(async () => {
- throw Error('error')
+ throw Error("error")
})
await g()
- expect(g.state.status).to.equal('failed')
+ expect(g.state.status).to.equal("failed")
expect(g.state.failed).to.be.true
await Promise.delay(15)
expect(f.state.status).to.equal(null)
@@ -96,7 +96,7 @@ describe('Aspect Functions', () => {
// Timeout of 2000ms exceeded. For async tests and hooks, ensure "done()"
// is called; if returning a Promise, ensure it resolves.
.timeout(10000)
- it('should support synchronous aspects', () => {
+ it("should support synchronous aspects", () => {
let x = 1
let y = 0
let firstIncrementX = aspectSync({
@@ -110,8 +110,8 @@ describe('Aspect Functions', () => {
f()
expect(y).to.equal(2)
})
- it('should mark deprecated methods on state', () => {
- let fn = aspects.deprecate('test', '1.2.3', 'something else')(() => {})
+ it("should mark deprecated methods on state", () => {
+ let fn = aspects.deprecate("test", "1.2.3", "something else")(() => {})
expect(fn.state.isDeprecated).to.be.true
})
diff --git a/test/collections.spec.js b/test/collections.spec.js
index 74fcd49e..ed86ddc5 100644
--- a/test/collections.spec.js
+++ b/test/collections.spec.js
@@ -1,12 +1,12 @@
-import chai from 'chai'
-import F from '../src/'
-import _ from 'lodash/fp'
+import chai from "chai"
+import F from "../src/"
+import _ from "lodash/fp"
chai.expect()
const expect = chai.expect
-describe('Collections Functions', () => {
- it('flowMap', () => {
+describe("Collections Functions", () => {
+ it("flowMap", () => {
expect(
F.flowMap(
(n) => n + n,
@@ -16,24 +16,24 @@ describe('Collections Functions', () => {
expect(
F.flowMap(
(s) => s.toUpperCase(),
- (s) => s.split(''),
+ (s) => s.split(""),
(s) => s.reverse(),
- (s) => s.join('')
- )(['Smart', 'Procure'])
- ).to.deep.equal(['TRAMS', 'ERUCORP'])
+ (s) => s.join("")
+ )(["Smart", "Procure"])
+ ).to.deep.equal(["TRAMS", "ERUCORP"])
})
- it('findApply', () => {
+ it("findApply", () => {
let x = {
a: 1,
}
- expect(F.findApply((f) => x[f], ['b', 'c', 'a'])).to.equal(1)
- expect(F.findApply((f) => x[f], ['b', 'c'])).to.equal(undefined)
+ expect(F.findApply((f) => x[f], ["b", "c", "a"])).to.equal(1)
+ expect(F.findApply((f) => x[f], ["b", "c"])).to.equal(undefined)
let xs = [{ b: 2 }, { c: 3 }, { a: 1 }]
expect(F.findApply((f) => f.a, xs)).to.equal(1)
- expect(F.findApply('a', xs)).to.equal(1)
- expect(F.findApply('d', xs)).to.equal(undefined)
+ expect(F.findApply("a", xs)).to.equal(1)
+ expect(F.findApply("d", xs)).to.equal(undefined)
})
- it('map', () => {
+ it("map", () => {
// map plain arrays
expect(F.map((x) => x * x, [1, 2, 3])).to.deep.equal([1, 4, 9])
// map plain objects
@@ -43,8 +43,8 @@ describe('Collections Functions', () => {
c: 9,
})
})
- describe('deepMap', () => {
- it('deepMap arrays', () => {
+ describe("deepMap", () => {
+ it("deepMap arrays", () => {
// arrays
const arr = [0, [1, [2, []]]]
const arrBackup = _.cloneDeep(arr)
@@ -53,7 +53,7 @@ describe('Collections Functions', () => {
expect(arr).to.deep.equal(arrBackup)
expect(arrMutated).to.deep.equal([0, [1, [2, [101], 101], 101]])
})
- it('deepMap plain objects', () => {
+ it("deepMap plain objects", () => {
const objA = {
a: {
match: {
@@ -72,7 +72,7 @@ describe('Collections Functions', () => {
},
}
const objABackup = _.cloneDeep(objA)
- const pathA = 'match.matched'
+ const pathA = "match.matched"
const setMatchedA = (e) => e.match && _.set(pathA, true, e)
const objAMutated = F.deepMap((e) => setMatchedA(e) || e)(objA)
// Checking immutability
@@ -98,7 +98,7 @@ describe('Collections Functions', () => {
},
})
})
- it('deepMap with plain objects with arrays with objects', () => {
+ it("deepMap with plain objects with arrays with objects", () => {
const objB = {
a: {
array: [0, [1, [2, [{ match: { id: 0 } }]]]],
@@ -118,7 +118,7 @@ describe('Collections Functions', () => {
},
}
const objBBackup = _.cloneDeep(objB)
- const pathB = 'match.matched'
+ const pathB = "match.matched"
const setMatchedB = (e) => e.match && _.set(pathB, true, e)
const push101 = (e) => _.isArray(e) && e.concat(101)
const objBMutated = F.deepMap((e) => push101(e) || setMatchedB(e) || e)(
@@ -153,32 +153,32 @@ describe('Collections Functions', () => {
})
})
})
- it('insertAtIndex', () => {
+ it("insertAtIndex", () => {
let arr = [1, 2, 3]
let x = F.insertAtIndex(1, 5, arr)
expect(x).to.deep.equal([1, 5, 2, 3])
expect(arr).to.deep.equal([1, 2, 3])
- expect(F.insertAtIndex(1, 'z', 'abc')).to.equal('azbc')
+ expect(F.insertAtIndex(1, "z", "abc")).to.equal("azbc")
- var result = F.insertAtIndex(0, '', 'pretty please')
- expect(result).to.equal('pretty please')
+ var result = F.insertAtIndex(0, "", "pretty please")
+ expect(result).to.equal("pretty please")
})
- it('compactMap', () => {
- let names = ['adam', 'betty', 'carlos', 'doug', 'emily']
- let exceptDoug = (fn) => (x) => x === 'doug' ? undefined : fn(x)
+ it("compactMap", () => {
+ let names = ["adam", "betty", "carlos", "doug", "emily"]
+ let exceptDoug = (fn) => (x) => x === "doug" ? undefined : fn(x)
expect(F.compactMap(_.capitalize, names)).to.deep.equal([
- 'Adam',
- 'Betty',
- 'Carlos',
- 'Doug',
- 'Emily',
+ "Adam",
+ "Betty",
+ "Carlos",
+ "Doug",
+ "Emily",
])
expect(F.compactMap(exceptDoug(_.capitalize), names)).to.deep.equal([
- 'Adam',
- 'Betty',
- 'Carlos',
- 'Emily',
+ "Adam",
+ "Betty",
+ "Carlos",
+ "Emily",
])
expect(F.compactMap((x) => x - 2, [0, 1, 2, 3])).to.deep.equal([-2, -1, 1])
})
diff --git a/test/conversions.spec.js b/test/conversions.spec.js
index b21280ac..b65e218c 100644
--- a/test/conversions.spec.js
+++ b/test/conversions.spec.js
@@ -1,88 +1,88 @@
-import _ from 'lodash/fp'
-import chai from 'chai'
-import * as F from '../src'
+import _ from "lodash/fp"
+import chai from "chai"
+import * as F from "../src"
chai.expect()
const expect = chai.expect
-describe('Converted Functions', () => {
- describe('Flips', () => {
- it('getIn', () => {
+describe("Converted Functions", () => {
+ describe("Flips", () => {
+ it("getIn", () => {
let hero = {
- name: 'Heracles',
- father: 'Zeus',
- bornAt: 'Thebes',
+ name: "Heracles",
+ father: "Zeus",
+ bornAt: "Thebes",
}
- expect(F.getIn(hero, 'name')).to.equal('Heracles')
- expect(F.getIn(hero, 'Zeus')).to.equal(undefined)
+ expect(F.getIn(hero, "name")).to.equal("Heracles")
+ expect(F.getIn(hero, "Zeus")).to.equal(undefined)
const obj = { a: 1 }
- expect(F.inversions.getIn(obj)('a')).to.equal(1)
- expect(F.getIn(obj)('a')).to.equal(1)
+ expect(F.inversions.getIn(obj)("a")).to.equal(1)
+ expect(F.getIn(obj)("a")).to.equal(1)
})
- it('getIn consistent with _.get', () => {
+ it("getIn consistent with _.get", () => {
let hero = {
- name: 'Heracles',
- father: 'Zeus',
- bornAt: 'Thebes',
+ name: "Heracles",
+ father: "Zeus",
+ bornAt: "Thebes",
}
- expect(F.getIn(hero, 'name')).to.equal(_.get('name', hero))
+ expect(F.getIn(hero, "name")).to.equal(_.get("name", hero))
})
- it('hasIn', () => {
+ it("hasIn", () => {
let hero = {
- name: 'Heracles',
- father: 'Zeus',
- bornAt: 'Thebes',
+ name: "Heracles",
+ father: "Zeus",
+ bornAt: "Thebes",
}
- expect(F.hasIn(hero, 'father')).to.be.true
- expect(F.hasIn(hero, 'Zeus')).to.be.false
+ expect(F.hasIn(hero, "father")).to.be.true
+ expect(F.hasIn(hero, "Zeus")).to.be.false
})
- it('pickIn', () => {
+ it("pickIn", () => {
let hero = {
- name: 'Heracles',
- father: 'Zeus',
- bornAt: 'Thebes',
+ name: "Heracles",
+ father: "Zeus",
+ bornAt: "Thebes",
}
- expect(F.pickIn(hero, 'name')).to.deep.equal({ name: 'Heracles' })
- expect(F.pickIn(hero, ['name', 'father'])).to.deep.equal({
- name: 'Heracles',
- father: 'Zeus',
+ expect(F.pickIn(hero, "name")).to.deep.equal({ name: "Heracles" })
+ expect(F.pickIn(hero, ["name", "father"])).to.deep.equal({
+ name: "Heracles",
+ father: "Zeus",
})
})
- it('pickIn consistent with _.pick', () => {
+ it("pickIn consistent with _.pick", () => {
let hero = {
- name: 'Heracles',
- father: 'Zeus',
- bornAt: 'Thebes',
+ name: "Heracles",
+ father: "Zeus",
+ bornAt: "Thebes",
}
- expect(F.pickIn(hero, 'name')).to.deep.equal(_.pick('name', hero))
- expect(F.pickIn(hero, ['name', 'father'])).to.deep.equal(
- _.pick(['name', 'father'], hero)
+ expect(F.pickIn(hero, "name")).to.deep.equal(_.pick("name", hero))
+ expect(F.pickIn(hero, ["name", "father"])).to.deep.equal(
+ _.pick(["name", "father"], hero)
)
})
- it('includesIn', () => {
+ it("includesIn", () => {
let hero = {
- name: 'Heracles',
- father: 'Zeus',
- bornAt: 'Thebes',
+ name: "Heracles",
+ father: "Zeus",
+ bornAt: "Thebes",
}
- expect(F.includesIn(hero, 'Heracles')).to.be.true
- expect(F.includesIn(hero, 'name')).to.be.false
+ expect(F.includesIn(hero, "Heracles")).to.be.true
+ expect(F.includesIn(hero, "name")).to.be.false
})
- it('includesIn consistent with _.includes', () => {
+ it("includesIn consistent with _.includes", () => {
let hero = {
- name: 'Heracles',
- father: 'Zeus',
- bornAt: 'Thebes',
+ name: "Heracles",
+ father: "Zeus",
+ bornAt: "Thebes",
}
let expectDeepEqual = (obj, name) =>
expect(F.includesIn(obj, name)).to.deep.equal(_.includes(name, obj))
- expectDeepEqual(hero, 'name')
- expectDeepEqual(hero, 'Heracles')
- expectDeepEqual(hero, 'Zeus')
+ expectDeepEqual(hero, "name")
+ expectDeepEqual(hero, "Heracles")
+ expectDeepEqual(hero, "Zeus")
})
})
- describe('Mutables', () => {
- it('extendOn', () => {
+ describe("Mutables", () => {
+ it("extendOn", () => {
expect(
F.extendOn(
{
@@ -100,18 +100,18 @@ describe('Converted Functions', () => {
c: 4,
})
})
- it('extendOn consistent with _.extend', () => {
+ it("extendOn consistent with _.extend", () => {
let hero = {
- name: 'Heracles',
- father: 'Zeus',
- bornAt: 'Thebes',
+ name: "Heracles",
+ father: "Zeus",
+ bornAt: "Thebes",
}
let expectDeepEqual = (clone, obj) =>
expect(F.extendOn(clone, obj)).to.deep.equal(_.extend(obj, clone))
- expectDeepEqual(_.clone(hero), { name: 'Hercules' })
- expectDeepEqual(_.clone(hero), { consort: 'Auge' })
+ expectDeepEqual(_.clone(hero), { name: "Hercules" })
+ expectDeepEqual(_.clone(hero), { consort: "Auge" })
})
- it('defaultsOn', () => {
+ it("defaultsOn", () => {
expect(
F.defaultsOn(
{
@@ -129,50 +129,50 @@ describe('Converted Functions', () => {
c: 4,
})
})
- it('defaultsOn consistent with _.defaults', () => {
+ it("defaultsOn consistent with _.defaults", () => {
let hero = {
- name: 'Heracles',
- father: 'Zeus',
- bornAt: 'Thebes',
+ name: "Heracles",
+ father: "Zeus",
+ bornAt: "Thebes",
}
let clone = _.clone(hero)
- expect(F.defaultsOn(clone, { consort: 'Auge' })).to.deep.equal(
- _.defaults({ consort: 'Auge' }, clone)
+ expect(F.defaultsOn(clone, { consort: "Auge" })).to.deep.equal(
+ _.defaults({ consort: "Auge" }, clone)
)
})
- it('mergeOn', () => {
+ it("mergeOn", () => {
let hero = {
- name: 'Heracles',
+ name: "Heracles",
}
- expect(F.mergeOn(hero, { consort: 'Auge' })).to.deep.equal({
- name: 'Heracles',
- consort: 'Auge',
+ expect(F.mergeOn(hero, { consort: "Auge" })).to.deep.equal({
+ name: "Heracles",
+ consort: "Auge",
})
- expect(hero).to.deep.equal({ name: 'Heracles', consort: 'Auge' })
+ expect(hero).to.deep.equal({ name: "Heracles", consort: "Auge" })
})
- it('setOn', () => {
+ it("setOn", () => {
let object = { a: [{ b: { c: 3 } }] }
- expect(F.setOn('a[0].b.c', 15)(object)).to.deep.equal({
+ expect(F.setOn("a[0].b.c", 15)(object)).to.deep.equal({
a: [{ b: { c: 15 } }],
})
expect(object).to.deep.equal({
a: [{ b: { c: 15 } }],
})
})
- it('unsetOn', () => {
+ it("unsetOn", () => {
let object = { a: [{ b: { c: 3 } }] }
- expect(F.unsetOn('a[0].b.c')(object)).to.be.true
+ expect(F.unsetOn("a[0].b.c")(object)).to.be.true
expect(object).to.deep.equal({ a: [{ b: {} }] })
})
- it('pullOn', () => {
- let array = ['a', 'b', 'c', 'a', 'b', 'c', 'd']
- expect(F.pullOn('b')(array)).to.deep.equal(['a', 'c', 'a', 'c', 'd'])
- expect(array).to.deep.equal(['a', 'c', 'a', 'c', 'd'])
+ it("pullOn", () => {
+ let array = ["a", "b", "c", "a", "b", "c", "d"]
+ expect(F.pullOn("b")(array)).to.deep.equal(["a", "c", "a", "c", "d"])
+ expect(array).to.deep.equal(["a", "c", "a", "c", "d"])
})
- it('updateOn', () => {
+ it("updateOn", () => {
let object = { a: [{ b: { c: 3 } }] }
- expect(F.updateOn('a[0].b.c', (x) => x * x)(object)).to.deep.equal({
+ expect(F.updateOn("a[0].b.c", (x) => x * x)(object)).to.deep.equal({
a: [{ b: { c: 9 } }],
})
expect(object).to.deep.equal({
diff --git a/test/function.spec.js b/test/function.spec.js
index 3840ee3a..bf7173a9 100644
--- a/test/function.spec.js
+++ b/test/function.spec.js
@@ -1,13 +1,13 @@
-import * as F from '../src'
-import _ from 'lodash/fp'
-import chai from 'chai'
-import sinon from 'sinon'
-import sinonChai from 'sinon-chai'
+import * as F from "../src"
+import _ from "lodash/fp"
+import chai from "chai"
+import sinon from "sinon"
+import sinonChai from "sinon-chai"
const expect = chai.expect
chai.use(sinonChai)
-describe('Function Functions', () => {
- it('maybeCall', () => {
+describe("Function Functions", () => {
+ it("maybeCall", () => {
expect(F.maybeCall(() => 5)).to.equal(5)
expect(F.maybeCall(null)).to.be.false
const fn = (x, y) => x + y
@@ -15,7 +15,7 @@ describe('Function Functions', () => {
// maybeCall should call fn with parameters
expect(F.maybeCall(fn, 5, 6)).to.equal(fn(5, 6))
})
- it('callOrReturn', () => {
+ it("callOrReturn", () => {
expect(F.callOrReturn(() => 5)).to.equal(5)
expect(F.callOrReturn(5)).to.equal(5)
expect(F.callOrReturn(null)).to.equal(null)
@@ -24,36 +24,36 @@ describe('Function Functions', () => {
// callOrReturn should call fn with parameters
expect(F.callOrReturn(fn, 5, 6)).to.equal(fn(5, 6))
})
- it('boundMethod', () => {
+ it("boundMethod", () => {
// boundMethod should bind a method of an object to it's object
let obj = {
- name: 'Wade Watts',
+ name: "Wade Watts",
greet() {
return `Welcome, ${this.name}`
},
}
- expect(obj.greet.call({ name: 'John Henry' })).to.equal(
- 'Welcome, John Henry'
+ expect(obj.greet.call({ name: "John Henry" })).to.equal(
+ "Welcome, John Henry"
)
- expect(F.boundMethod('greet', obj)()).to.equal('Welcome, Wade Watts')
+ expect(F.boundMethod("greet", obj)()).to.equal("Welcome, Wade Watts")
})
- it('converge', () => {
+ it("converge", () => {
let divide = (arr) => arr[0] / arr[1]
let sum = (arr) => _.sum(arr)
let length = (arr) => arr.length
// average
expect(F.converge(divide, [sum, length])([5, 10, 15])).to.equal(10)
})
- it('composeApply', () => {
+ it("composeApply", () => {
let fn1 = (lastResult) => (x) => lastResult / x
let fn2 = (x) => x + 5
expect(F.composeApply(fn1, fn2)(5)).to.equal(2)
})
- it('comply', () => {
+ it("comply", () => {
// F.append(x => x * 2)(5) => (5 * 2) + 5
expect(F.comply(F.append, (x) => x * 2)(5)).to.equal(15)
})
- it('defer', () => {
+ it("defer", () => {
let delay = (ms) => {
let resolver = F.defer()
let now = Date.now()
@@ -67,8 +67,8 @@ describe('Function Functions', () => {
expect(ms).is.at.least(500)
})
})
- describe('debounceAsync', () => {
- it('debounceAsync', async () => {
+ describe("debounceAsync", () => {
+ it("debounceAsync", async () => {
let inner = sinon.spy((x) => x + 10)
let fn = F.debounceAsync(10, inner)
let result = await Promise.all([fn(1), fn(2), fn(3)])
@@ -77,7 +77,7 @@ describe('Function Functions', () => {
let secondResult = await Promise.all([fn(11), fn(12), fn(13)])
expect(secondResult).to.deep.equal([23, 23, 23])
})
- it('should demonstrate failing with regular debounce', async () => {
+ it("should demonstrate failing with regular debounce", async () => {
let inner2 = sinon.spy((x) => x + 10)
let fn2 = _.debounce(10, inner2)
let result2 = await Promise.all([fn2(1), fn2(2), fn2(3)])
@@ -87,7 +87,7 @@ describe('Function Functions', () => {
expect(thirdResult).to.deep.equal([undefined, undefined, undefined])
})
})
- it('flurry', () => {
+ it("flurry", () => {
let add = (x, y) => x + y
let double = (x) => x * 2
// Passing all args
@@ -95,7 +95,7 @@ describe('Function Functions', () => {
// Passing 1 at a time
expect(F.flurry(add, double)(1)(4)).to.equal(10)
})
- it('mapArgs', () => {
+ it("mapArgs", () => {
let add = (x, y) => x + y
let double = (x) => x * 2
let doubledAdd = F.mapArgs(double, add)
diff --git a/test/init.js b/test/init.js
index b1efa571..b5c9cc12 100644
--- a/test/init.js
+++ b/test/init.js
@@ -1 +1 @@
-global.__VERSION__ = '1.0.0'
+global.__VERSION__ = "1.0.0"
diff --git a/test/iterators.spec.js b/test/iterators.spec.js
index 00f4d425..e2e248dc 100644
--- a/test/iterators.spec.js
+++ b/test/iterators.spec.js
@@ -1,12 +1,12 @@
-import chai from 'chai'
-import F from '../src/'
+import chai from "chai"
+import F from "../src/"
chai.expect()
const expect = chai.expect
-describe('Iterator Generators', () => {
- it('differentLast', () => {
+describe("Iterator Generators", () => {
+ it("differentLast", () => {
expect(
- F.mapIndexed(F.differentLast('a', 'b'), [
+ F.mapIndexed(F.differentLast("a", "b"), [
{ a: 1, b: 2 },
{ a: 1, b: 2 },
{ a: 1, b: 2 },
diff --git a/test/lang.spec.js b/test/lang.spec.js
index 9db06ecb..086f5898 100644
--- a/test/lang.spec.js
+++ b/test/lang.spec.js
@@ -1,98 +1,98 @@
-import chai from 'chai'
-import * as F from '../src'
-import _ from 'lodash/fp'
+import chai from "chai"
+import * as F from "../src"
+import _ from "lodash/fp"
chai.expect()
const expect = chai.expect
-describe('Lang Functions', () => {
- it('throws', () => {
- expect(() => F.throws(Error('oops'))).to.throw()
+describe("Lang Functions", () => {
+ it("throws", () => {
+ expect(() => F.throws(Error("oops"))).to.throw()
})
- it('tapError', () => {
- let total = ''
+ it("tapError", () => {
+ let total = ""
let errorFn = (e, pre, post) => (total = `${e}. The total is ${pre + post}`)
- let errorOfMine = new Error('myError')
+ let errorOfMine = new Error("myError")
try {
F.tapError(errorFn)(errorOfMine, 20, 45)
} catch (e) {
- expect(total).to.equal('Error: myError. The total is 65')
+ expect(total).to.equal("Error: myError. The total is 65")
expect(e).to.equal(errorOfMine)
}
})
- it('isNotNil', () => {
+ it("isNotNil", () => {
expect(F.isNotNil(null)).to.be.false
expect(F.isNotNil(undefined)).to.be.false
expect(F.isNotNil(0)).to.be.true
- expect(F.isNotNil('')).to.be.true
+ expect(F.isNotNil("")).to.be.true
expect(F.isNotNil([])).to.be.true
expect(F.isNotNil).to.equal(F.exists)
})
- it('exists', () => {
+ it("exists", () => {
expect(F.exists(null)).to.be.false
expect(F.exists(undefined)).to.be.false
expect(F.exists(0)).to.be.true
- expect(F.exists('')).to.be.true
+ expect(F.exists("")).to.be.true
expect(F.exists([])).to.be.true
})
- it('isMultiple', () => {
- expect(F.isMultiple([''])).to.be.false
- expect(F.isMultiple(['', ''])).to.be.true
- expect(F.isMultiple('a')).to.be.false
- expect(F.isMultiple('asdf')).to.be.true
+ it("isMultiple", () => {
+ expect(F.isMultiple([""])).to.be.false
+ expect(F.isMultiple(["", ""])).to.be.true
+ expect(F.isMultiple("a")).to.be.false
+ expect(F.isMultiple("asdf")).to.be.true
expect(F.isMultiple({ x: 1, y: 2 })).to.be.false
expect(F.isMultiple({ x: 1, y: 2, length: 2 })).to.be.true
})
- it('append', () => {
- expect(F.append('a', 'b')).to.equal('ba')
+ it("append", () => {
+ expect(F.append("a", "b")).to.equal("ba")
expect(F.append(1, 4)).to.equal(5)
})
- it('isBlank', () => {
+ it("isBlank", () => {
expect(F.isBlank(1)).to.be.false
- expect(F.isBlank('asdf')).to.be.false
+ expect(F.isBlank("asdf")).to.be.false
expect(F.isBlank({ a: 1 })).to.be.false
expect(F.isBlank([3, 4])).to.be.false
expect(F.isBlank(new Date())).to.be.false
expect(
F.isBlank({
a: 1,
- b: 'as',
+ b: "as",
})
).to.be.false
expect(F.isBlank(null)).to.be.true
expect(F.isBlank(undefined)).to.be.true
- expect(F.isBlank('')).to.be.true
+ expect(F.isBlank("")).to.be.true
expect(F.isBlank([])).to.be.true
expect(F.isBlank({})).to.be.true
})
- it('isNotBlank', () => {
+ it("isNotBlank", () => {
expect(F.isNotBlank(1)).to.be.true
- expect(F.isNotBlank('asdf')).to.be.true
+ expect(F.isNotBlank("asdf")).to.be.true
expect(F.isNotBlank({ a: 1 })).to.be.true
expect(F.isNotBlank([3, 4])).to.be.true
expect(F.isNotBlank(new Date())).to.be.true
expect(F.isNotBlank(null)).to.be.false
expect(F.isNotBlank(undefined)).to.be.false
- expect(F.isNotBlank('')).to.be.false
+ expect(F.isNotBlank("")).to.be.false
expect(F.isNotBlank([])).to.be.false
expect(F.isNotBlank({})).to.be.false
})
- it('isBlankDeep', () => {
+ it("isBlankDeep", () => {
expect(F.isBlankDeep(_.every)(1)).to.be.false
expect(F.isBlankDeep(_.every)(false)).to.be.false
- expect(F.isBlankDeep(_.every)('')).to.be.true
+ expect(F.isBlankDeep(_.every)("")).to.be.true
expect(
F.isBlankDeep(_.every)({
a: 1,
- b: 'as',
+ b: "as",
})
).to.be.false
expect(
F.isBlankDeep(_.every)({
a: null,
- b: '',
+ b: "",
c: [],
d: {
- b: '',
+ b: "",
},
})
).to.be.true
diff --git a/test/lens.spec.js b/test/lens.spec.js
index 755dd1c7..ba39cc6b 100644
--- a/test/lens.spec.js
+++ b/test/lens.spec.js
@@ -1,50 +1,50 @@
-import chai from 'chai'
-import _ from 'lodash/fp'
-import * as F from '../src'
+import chai from "chai"
+import _ from "lodash/fp"
+import * as F from "../src"
chai.expect()
const expect = chai.expect
-describe('Lens Functions', () => {
- describe('Stubs', () => {
- it('functionLens', () => {
+describe("Lens Functions", () => {
+ describe("Stubs", () => {
+ it("functionLens", () => {
let l = F.functionLens(1)
expect(l()).to.equal(1)
l(5)
expect(l()).to.equal(5)
})
- it('objectLens', () => {
+ it("objectLens", () => {
let l = F.objectLens(1)
expect(l.get()).to.equal(1)
l.set(5)
expect(l.get()).to.equal(5)
})
})
- describe('Conversion', () => {
- it('fnToObj', () => {
+ describe("Conversion", () => {
+ it("fnToObj", () => {
let l = F.fnToObj(F.functionLens(1))
expect(l.get()).to.equal(1)
l.set(5)
expect(l.get()).to.equal(5)
})
- it('objToFn', () => {
+ it("objToFn", () => {
let l = F.objToFn(F.objectLens(1))
expect(l()).to.equal(1)
l(5)
expect(l()).to.equal(5)
})
})
- describe('Construction', () => {
- it('lensProp', () => {
- let l = F.lensProp('x', {
+ describe("Construction", () => {
+ it("lensProp", () => {
+ let l = F.lensProp("x", {
x: 1,
})
expect(l.get()).to.equal(1)
l.set(5)
expect(l.get()).to.equal(5)
})
- it('lensProp deep', () => {
- let l = F.lensProp('x.a', {
+ it("lensProp deep", () => {
+ let l = F.lensProp("x.a", {
x: {
a: 1,
},
@@ -53,7 +53,7 @@ describe('Lens Functions', () => {
l.set(5)
expect(l.get()).to.equal(5)
})
- it('lensOf', () => {
+ it("lensOf", () => {
let l = F.lensOf({
a: 1,
})
@@ -61,38 +61,38 @@ describe('Lens Functions', () => {
l.a.set(5)
expect(l.a.get()).to.equal(5)
})
- it('includeLens', () => {
+ it("includeLens", () => {
let object = {
- arr: ['a', 'b', 'c', 'd'],
+ arr: ["a", "b", "c", "d"],
}
- let includesB = F.includeLens('b', 'arr', object)
+ let includesB = F.includeLens("b", "arr", object)
expect(F.view(includesB)).to.be.true
F.off(includesB)()
expect(F.view(includesB)).to.be.false
- expect(object.arr).to.deep.equal(['a', 'c', 'd'])
+ expect(object.arr).to.deep.equal(["a", "c", "d"])
F.on(includesB)()
expect(F.view(includesB)).to.be.true
- expect(object.arr).to.deep.equal(['a', 'c', 'd', 'b'])
+ expect(object.arr).to.deep.equal(["a", "c", "d", "b"])
// Subsequent calls don't result in multiple `b`s because of _.uniq
F.on(includesB)()
expect(F.view(includesB)).to.be.true
- expect(object.arr).to.deep.equal(['a', 'c', 'd', 'b'])
+ expect(object.arr).to.deep.equal(["a", "c", "d", "b"])
})
})
- describe('Manipulation', () => {
- it('view', () => {
+ describe("Manipulation", () => {
+ it("view", () => {
let fl = F.functionLens(1)
let ol = F.objectLens(1)
expect(F.view(fl)).to.equal(1)
expect(F.view(ol)).to.equal(1)
})
- it('views', () => {
+ it("views", () => {
let fl = F.functionLens(1)
let ol = F.objectLens(1)
expect(F.views(fl)()).to.equal(1)
expect(F.views(ol)()).to.equal(1)
})
- it('set', () => {
+ it("set", () => {
let object = {
a: 1,
}
@@ -100,7 +100,7 @@ describe('Lens Functions', () => {
F.set(5, l.a)
expect(object.a).to.equal(5)
})
- it('sets', () => {
+ it("sets", () => {
let object = {
a: 1,
}
@@ -108,15 +108,15 @@ describe('Lens Functions', () => {
F.sets(5, l.a)()
expect(object.a).to.equal(5)
})
- it('setsWith', () => {
+ it("setsWith", () => {
let object = {
a: 1,
}
- let setter = F.setsWith((x) => x * 2, 'a', object)
+ let setter = F.setsWith((x) => x * 2, "a", object)
setter(5)
expect(object.a).to.equal(10)
})
- it('flip', () => {
+ it("flip", () => {
let object = {
a: 1,
}
@@ -124,7 +124,7 @@ describe('Lens Functions', () => {
F.flip(l.a)()
expect(object.a).to.be.false
})
- it('on', () => {
+ it("on", () => {
let object = {
a: 1,
}
@@ -132,7 +132,7 @@ describe('Lens Functions', () => {
F.on(l.a)()
expect(object.a).to.be.true
})
- it('off', () => {
+ it("off", () => {
let object = {
a: 1,
}
@@ -141,61 +141,61 @@ describe('Lens Functions', () => {
expect(object.a).to.be.false
})
})
- describe('Implicit Lens Prop', () => {
- it('view', () => {
+ describe("Implicit Lens Prop", () => {
+ it("view", () => {
let x = {
a: 1,
b: 2,
}
- expect(F.view('a', x)).to.equal(1)
+ expect(F.view("a", x)).to.equal(1)
})
- it('views', () => {
+ it("views", () => {
let x = {
a: 1,
b: 2,
}
- expect(F.views('a', x)()).to.equal(1)
+ expect(F.views("a", x)()).to.equal(1)
})
- it('set', () => {
+ it("set", () => {
let x = {
a: 1,
b: 2,
}
- F.set(5, 'a', x)
+ F.set(5, "a", x)
expect(x.a).to.equal(5)
})
- it('sets', () => {
+ it("sets", () => {
let x = {
a: 1,
b: 2,
}
- F.sets(5, 'a', x)()
+ F.sets(5, "a", x)()
expect(x.a).to.equal(5)
})
- it('flip', () => {
+ it("flip", () => {
let object = {
a: 1,
}
- F.flip('a', object)()
+ F.flip("a", object)()
expect(object.a).to.be.false
})
- it('on', () => {
+ it("on", () => {
let object = {
a: 1,
}
- F.on('a', object)()
+ F.on("a", object)()
expect(object.a).to.be.true
})
- it('off', () => {
+ it("off", () => {
let object = {
a: 1,
}
- F.off('a', object)()
+ F.off("a", object)()
expect(object.a).to.be.false
})
})
- describe('additional implicit lens formats', () => {
- it('arrayLens', () => {
+ describe("additional implicit lens formats", () => {
+ it("arrayLens", () => {
let arrayLens = (val) => {
let result = [val]
result.push((x) => {
@@ -211,7 +211,7 @@ describe('Lens Functions', () => {
F.flip(lens)()
expect(lens[0]).to.be.true
})
- it('functionPairLens', () => {
+ it("functionPairLens", () => {
let object = {
a: false,
}
@@ -227,81 +227,81 @@ describe('Lens Functions', () => {
expect(object.a).to.be.true
})
})
- describe('domLens', () => {
- it('value', () => {
+ describe("domLens", () => {
+ it("value", () => {
let state = {
a: 1,
}
- let props = F.domLens.value('a', state)
+ let props = F.domLens.value("a", state)
expect(props.value).to.equal(1)
props.onChange({ target: { value: 5 } })
expect(state.a).to.equal(5)
})
- it('non-native value', () => {
+ it("non-native value", () => {
let state = {
a: 1,
}
- let props = F.domLens.value('a', state)
+ let props = F.domLens.value("a", state)
expect(props.value).to.equal(1)
props.onChange(5)
expect(state.a).to.equal(5)
})
- it('checkboxValues', () => {
+ it("checkboxValues", () => {
let state = {
- a: ['x', 'y', 'z'],
+ a: ["x", "y", "z"],
}
// Props for if `x` is in the list
- let props = F.domLens.checkboxValues('x', 'a', state)
+ let props = F.domLens.checkboxValues("x", "a", state)
expect(props.checked).to.be.true
// uncheck
props.onChange({ target: { value: false } })
- expect(_.includes('a', state.a)).to.be.false
+ expect(_.includes("a", state.a)).to.be.false
})
- it('hover', () => {
+ it("hover", () => {
let state = {
hovering: false,
}
- let props = F.domLens.hover('hovering', state)
+ let props = F.domLens.hover("hovering", state)
props.onMouseEnter()
expect(state.hovering).to.be.true
props.onMouseLeave()
expect(state.hovering).to.be.false
})
- it('focus', () => {
+ it("focus", () => {
let state = {
focusing: false,
}
- let props = F.domLens.focus('focusing', state)
+ let props = F.domLens.focus("focusing", state)
props.onFocus()
expect(state.focusing).to.be.true
props.onBlur()
expect(state.focusing).to.be.false
})
- it('targetBinding', () => {
- let state = { color: 'red' }
- let props = F.domLens.targetBinding('x')('color', state)
- expect(props.x).to.equal('red')
- props.onChange({ target: { x: 'green' } })
- expect(state.color).to.equal('green')
+ it("targetBinding", () => {
+ let state = { color: "red" }
+ let props = F.domLens.targetBinding("x")("color", state)
+ expect(props.x).to.equal("red")
+ props.onChange({ target: { x: "green" } })
+ expect(state.color).to.equal("green")
// should handle objects with `target` as an inherited property
function Event() {}
Event.prototype.target = {}
- Event.prototype.target.x = 'blue'
+ Event.prototype.target.x = "blue"
props.onChange(new Event())
- expect(state.color).to.equal('blue')
+ expect(state.color).to.equal("blue")
// should handle targetless arguments
- props.onChange('purple')
- expect(state.color).to.equal('purple')
+ props.onChange("purple")
+ expect(state.color).to.equal("purple")
})
- it('binding', () => {
+ it("binding", () => {
let state = {
- selectedItem: 'item1',
+ selectedItem: "item1",
}
- let weirdSelect = F.domLens.binding('selected', (e) => e.newSelectedValue)
- let props = weirdSelect('selectedItem', state)
- expect(props.selected).to.equal('item1')
- props.onChange({ newSelectedValue: 'newItem' })
- expect(state.selectedItem).to.equal('newItem')
+ let weirdSelect = F.domLens.binding("selected", (e) => e.newSelectedValue)
+ let props = weirdSelect("selectedItem", state)
+ expect(props.selected).to.equal("item1")
+ props.onChange({ newSelectedValue: "newItem" })
+ expect(state.selectedItem).to.equal("newItem")
})
})
})
diff --git a/test/logic.spec.js b/test/logic.spec.js
index 41843af0..40d8fb86 100644
--- a/test/logic.spec.js
+++ b/test/logic.spec.js
@@ -1,19 +1,19 @@
-import chai from 'chai'
-import * as F from '../src'
-import _ from 'lodash/fp'
+import chai from "chai"
+import * as F from "../src"
+import _ from "lodash/fp"
chai.expect()
const expect = chai.expect
-describe('Logic Functions', () => {
- it('overNone', () => {
+describe("Logic Functions", () => {
+ it("overNone", () => {
let ten = (x) => x > 10
let twenty = (x) => x > 20
let thirty = (x) => x > 30
expect(F.overNone([ten, twenty, thirty])(5)).to.be.true
expect(F.overNone([ten, twenty, thirty])(15)).to.be.false
})
- describe('ifElse', () => {
- it('should handle functions', () => {
+ describe("ifElse", () => {
+ it("should handle functions", () => {
let clamp5 = F.ifElse(
(x) => x > 5,
() => 5,
@@ -23,20 +23,20 @@ describe('Logic Functions', () => {
expect(clamp5(5)).to.equal(5)
expect(clamp5(13)).to.equal(5)
})
- it('should handle passing boolean conditions', () => {
+ it("should handle passing boolean conditions", () => {
let fn = F.ifElse(
true,
(x) => `success ${x}`,
(x) => `fail ${x}`
)
- expect(fn(1)).to.equal('success 1')
+ expect(fn(1)).to.equal("success 1")
})
- it('should handle fancy shorthand', () => {
- let fancyShortHand = F.ifElse({ a: 1 }, 'Has a1', () => 'No a1')
- expect(fancyShortHand({ a: 1 })).to.equal('Has a1')
- expect(fancyShortHand({ a: 2 })).to.equal('No a1')
+ it("should handle fancy shorthand", () => {
+ let fancyShortHand = F.ifElse({ a: 1 }, "Has a1", () => "No a1")
+ expect(fancyShortHand({ a: 1 })).to.equal("Has a1")
+ expect(fancyShortHand({ a: 2 })).to.equal("No a1")
})
- it('should be fully curried', () => {
+ it("should be fully curried", () => {
expect(
F.ifElse(
(x) => x % 2,
@@ -44,10 +44,10 @@ describe('Logic Functions', () => {
(x) => `${x} is even!`,
6
)
- ).to.equal('6 is even!')
+ ).to.equal("6 is even!")
})
})
- it('when', () => {
+ it("when", () => {
let clamp5 = F.when(
(x) => x > 5,
() => 5
@@ -67,7 +67,7 @@ describe('Logic Functions', () => {
])
expect(_.map(nullConvertIndex, [0, 1, 2, 3])).to.deep.equal([0, 1, 2, 3])
})
- it('unless', () => {
+ it("unless", () => {
let clamp5 = F.unless(
(x) => x < 5,
() => 5
@@ -76,13 +76,13 @@ describe('Logic Functions', () => {
expect(clamp5(5)).to.equal(5)
expect(clamp5(13)).to.equal(5)
})
- it('whenExists', () => {
+ it("whenExists", () => {
let fn = F.whenExists(5)
expect(fn(3)).to.equal(5)
expect(fn(null)).to.equal(null)
expect(fn(false)).to.equal(5)
})
- it('whenTruthy', () => {
+ it("whenTruthy", () => {
let fn = F.whenTruthy(5)
expect(fn(3)).to.equal(5)
expect(fn(null)).to.equal(null)
diff --git a/test/misc.spec.js b/test/misc.spec.js
index 910b892e..8eb9179e 100644
--- a/test/misc.spec.js
+++ b/test/misc.spec.js
@@ -1,18 +1,18 @@
-import chai from 'chai'
-import F from '../src'
+import chai from "chai"
+import F from "../src"
chai.expect()
const expect = chai.expect
-describe('Math Functions', () => {
- it('greaterThanOne', () => {
+describe("Math Functions", () => {
+ it("greaterThanOne", () => {
for (let i = -10; i < 10; i++) {
expect(F.greaterThanOne(i)).to.equal(i > 1)
}
})
})
-describe('Promise Functions', () => {
- it('isPromise', () => {
+describe("Promise Functions", () => {
+ it("isPromise", () => {
expect(F.isPromise(Promise.resolve())).to.be.true
expect(F.isPromise({ then() {} })).to.be.true
expect(F.isPromise(null)).to.be.false
@@ -21,8 +21,8 @@ describe('Promise Functions', () => {
})
})
-describe('Version Injection', () => {
- it('should export the VERSION', () => {
+describe("Version Injection", () => {
+ it("should export the VERSION", () => {
expect(F.VERSION).to.equal(global.__VERSION__)
})
})
diff --git a/test/objects.spec.js b/test/objects.spec.js
index d0b208ec..25c0df9b 100644
--- a/test/objects.spec.js
+++ b/test/objects.spec.js
@@ -1,22 +1,22 @@
-import chai from 'chai'
-import * as F from '../src'
-import _ from 'lodash/fp'
+import chai from "chai"
+import * as F from "../src"
+import _ from "lodash/fp"
chai.expect()
const expect = chai.expect
-describe('Object Functions', () => {
- it('singleObject', () => {
- expect(F.singleObject('a', 'b')).to.deep.equal({
- a: 'b',
+describe("Object Functions", () => {
+ it("singleObject", () => {
+ expect(F.singleObject("a", "b")).to.deep.equal({
+ a: "b",
})
})
- it('singleObjectR', () => {
- expect(F.singleObjectR('a', 'b')).to.deep.equal({
- b: 'a',
+ it("singleObjectR", () => {
+ expect(F.singleObjectR("a", "b")).to.deep.equal({
+ b: "a",
})
})
- it('chunkObject', () => {
+ it("chunkObject", () => {
expect(F.chunkObject([1])).to.deep.equal([1])
expect(
F.chunkObject({
@@ -32,7 +32,7 @@ describe('Object Functions', () => {
},
])
})
- it('compactObject', () => {
+ it("compactObject", () => {
expect(
F.compactObject({
a: 1,
@@ -43,17 +43,17 @@ describe('Object Functions', () => {
a: 1,
})
})
- it('isEmptyObject', () => {
+ it("isEmptyObject", () => {
let expectEqual = (obj, v) => expect(F.isEmptyObject(obj)).to.equal(v)
expectEqual({ a: 1 }, false)
expectEqual({}, true)
})
- it('isNotEmptyObject', () => {
+ it("isNotEmptyObject", () => {
let expectEqual = (obj, v) => expect(F.isNotEmptyObject(obj)).to.equal(v)
expectEqual({ a: 1 }, true)
expectEqual({}, false)
})
- it('stripEmptyObjects', () => {
+ it("stripEmptyObjects", () => {
expect(
F.stripEmptyObjects({
a: 1,
@@ -65,13 +65,13 @@ describe('Object Functions', () => {
c: 2,
})
})
- it('pickInto', () => {
+ it("pickInto", () => {
expect(
F.pickInto(
{
- a: ['a'],
- b: ['b'],
- c: ['c'],
+ a: ["a"],
+ b: ["b"],
+ c: ["c"],
},
{ a: 1, b: 2 }
)
@@ -81,57 +81,57 @@ describe('Object Functions', () => {
c: {},
})
})
- it('unwind', () => {
- expect(F.unwind('x', { x: ['a', 'b'], y: 1 })).to.deep.equal([
- { x: 'a', y: 1 },
- { x: 'b', y: 1 },
+ it("unwind", () => {
+ expect(F.unwind("x", { x: ["a", "b"], y: 1 })).to.deep.equal([
+ { x: "a", y: 1 },
+ { x: "b", y: 1 },
])
// should unwind undefined values
- expect(F.unwind('x', { x: ['a', undefined, 'b'], y: 1 })).to.deep.equal([
- { x: 'a', y: 1 },
+ expect(F.unwind("x", { x: ["a", undefined, "b"], y: 1 })).to.deep.equal([
+ { x: "a", y: 1 },
{ x: undefined, y: 1 },
- { x: 'b', y: 1 },
+ { x: "b", y: 1 },
])
// should return an empty array for keys that are not present on the object
- expect(F.unwind('z', { x: 'foo', y: 1 })).to.deep.equal([])
+ expect(F.unwind("z", { x: "foo", y: 1 })).to.deep.equal([])
// should also return an empty array for keys whose values can't be unwound
- expect(F.unwind('y', { x: 'foo', y: 1 })).to.deep.equal([])
- expect(F.unwind('y', { x: 'foo', y: undefined })).to.deep.equal([])
- expect(F.unwind('y', { x: 'foo', y: [] })).to.deep.equal([])
+ expect(F.unwind("y", { x: "foo", y: 1 })).to.deep.equal([])
+ expect(F.unwind("y", { x: "foo", y: undefined })).to.deep.equal([])
+ expect(F.unwind("y", { x: "foo", y: [] })).to.deep.equal([])
// should not unwind strings
- expect(F.unwind('x', { x: 'foo', y: 1 })).to.deep.equal([])
+ expect(F.unwind("x", { x: "foo", y: 1 })).to.deep.equal([])
// duplicate objects are fine (we don't run _.uniq on the array to unwind)
- expect(F.unwind('x', { x: [7, 7, 7], y: 1 })).to.deep.equal([
+ expect(F.unwind("x", { x: [7, 7, 7], y: 1 })).to.deep.equal([
{ x: 7, y: 1 },
{ x: 7, y: 1 },
{ x: 7, y: 1 },
])
})
- it('unwindArray', () => {
+ it("unwindArray", () => {
expect(
- F.unwindArray('x', [
- { x: ['a', 'b'], y: 1 },
- { x: ['a', 'c'], y: 2 },
+ F.unwindArray("x", [
+ { x: ["a", "b"], y: 1 },
+ { x: ["a", "c"], y: 2 },
// since `unwind` returns an empty array for non-unwindable values,
// this should _not_ be present on the result of `unwindArray`
- { x: 'd', y: 3 },
+ { x: "d", y: 3 },
])
).to.deep.equal([
- { x: 'a', y: 1 },
- { x: 'b', y: 1 },
- { x: 'a', y: 2 },
- { x: 'c', y: 2 },
+ { x: "a", y: 1 },
+ { x: "b", y: 1 },
+ { x: "a", y: 2 },
+ { x: "c", y: 2 },
// { x: 'd', y: 3 }, not present
])
// should not unwind strings
expect(
- F.unwindArray('x', [
- { x: 'foo', y: 1 },
- { x: 'bar', y: 2 },
+ F.unwindArray("x", [
+ { x: "foo", y: 1 },
+ { x: "bar", y: 2 },
])
).to.deep.equal([])
expect(
- F.unwindArray('x', [
+ F.unwindArray("x", [
{ x: [7, 7, 7], y: 1 },
{ x: [1, 1], y: 2 },
])
@@ -143,7 +143,7 @@ describe('Object Functions', () => {
{ x: 1, y: 2 },
])
})
- it('flattenObject', () => {
+ it("flattenObject", () => {
expect(
F.flattenObject({
a: {
@@ -153,7 +153,7 @@ describe('Object Functions', () => {
},
})
).to.deep.equal({
- 'a.b.c': 1,
+ "a.b.c": 1,
})
expect(
F.flattenObject([
@@ -168,13 +168,13 @@ describe('Object Functions', () => {
},
])
).to.deep.equal({
- '0.a.b.0.c': 1,
+ "0.a.b.0.c": 1,
})
})
- it('unflattenObject', () => {
+ it("unflattenObject", () => {
expect(
F.unflattenObject({
- 'a.b.c': 1,
+ "a.b.c": 1,
})
).to.deep.equal({
a: {
@@ -184,114 +184,114 @@ describe('Object Functions', () => {
},
})
})
- it('renameProperty', () => {
+ it("renameProperty", () => {
const o = { a: 1 }
- const newO = F.renameProperty('a', 'b', o)
+ const newO = F.renameProperty("a", "b", o)
expect(newO).not.to.deep.equal(o)
expect(newO).to.deep.equal({ b: 1 })
- const new1 = F.renameProperty('c', 'b', o)
+ const new1 = F.renameProperty("c", "b", o)
expect(new1).to.deep.equal({ a: 1 })
})
- it('matchesSignature', () => {
+ it("matchesSignature", () => {
expect(F.matchesSignature([], 0)).to.be.false
- expect(F.matchesSignature([], '')).to.be.false
+ expect(F.matchesSignature([], "")).to.be.false
expect(F.matchesSignature([], (x) => x)).to.be.true
expect(F.matchesSignature([], [])).to.be.true
expect(F.matchesSignature([], { a: 1 })).to.be.false
- expect(F.matchesSignature(['a'], { a: 1 })).to.be.true
- expect(F.matchesSignature(['b'], { a: 1 })).to.be.false
- expect(F.matchesSignature(['a'], { a: 1, b: 2 })).to.be.false
- expect(F.matchesSignature(['a'], { a: undefined, b: undefined })).to.be
+ expect(F.matchesSignature(["a"], { a: 1 })).to.be.true
+ expect(F.matchesSignature(["b"], { a: 1 })).to.be.false
+ expect(F.matchesSignature(["a"], { a: 1, b: 2 })).to.be.false
+ expect(F.matchesSignature(["a"], { a: undefined, b: undefined })).to.be
.false
- expect(F.matchesSignature(['a', 'b'], { a: undefined })).to.be.true
+ expect(F.matchesSignature(["a", "b"], { a: undefined })).to.be.true
})
- it('matchesSome', () => {
+ it("matchesSome", () => {
expect(F.matchesSome({ a: 1, b: 2 })({ a: 1, b: 2, c: 3 })).to.be.true
expect(F.matchesSome({ a: 1, b: 20 })({ a: 1, b: 2, c: 3 })).to.be.true
expect(F.matchesSome({ a: 10, b: 2 })({ a: 1, b: 2, c: 3 })).to.be.true
expect(F.matchesSome({ a: 10, b: 20 })({ a: 1, b: 2, c: 3 })).to.be.false
})
- it('compareDeep', () => {
+ it("compareDeep", () => {
const o = { a: { b: { c: 1 } } }
- expect(F.compareDeep('a.b.c', o, 1)).to.be.true
- expect(F.compareDeep('a.b.c', o, 2)).to.be.false
- expect(F.compareDeep('a.b.c')(o, '1')).to.be.false
- expect(F.compareDeep('a.b.c')(o)('1')).to.be.false
+ expect(F.compareDeep("a.b.c", o, 1)).to.be.true
+ expect(F.compareDeep("a.b.c", o, 2)).to.be.false
+ expect(F.compareDeep("a.b.c")(o, "1")).to.be.false
+ expect(F.compareDeep("a.b.c")(o)("1")).to.be.false
})
// it('mapProp', () => {
// const a = F.mapProp('a', val => val * val, { a: 2, b: 1 })
// expect(a).to.deep.equal({ a: 4, b: 1 })
// })
- it('getOrReturn', () => {
- expect(F.getOrReturn('x', { a: 1 })).to.deep.equal({ a: 1 })
+ it("getOrReturn", () => {
+ expect(F.getOrReturn("x", { a: 1 })).to.deep.equal({ a: 1 })
})
- it('alias', () => {
- expect(F.alias('x', { a: 1 })).to.equal('x')
+ it("alias", () => {
+ expect(F.alias("x", { a: 1 })).to.equal("x")
})
- it('aliasIn', () => {
- expect(F.aliasIn({ a: 1 }, 'x')).to.equal('x')
+ it("aliasIn", () => {
+ expect(F.aliasIn({ a: 1 }, "x")).to.equal("x")
})
- it('cascade', () => {
- expect(F.cascade(['x', 'y'], { a: 1, y: 2 })).to.equal(2)
- expect(F.cascade(['x', 'c'], { a: 1, y: 2 }, 2)).to.equal(2)
- expect(F.cascade(['x', (x) => x.y], { a: 1, y: 2 })).to.equal(2)
- expect(F.cascade(['x', 'y'], { a: 1, x: null, y: 2 })).to.equal(2)
+ it("cascade", () => {
+ expect(F.cascade(["x", "y"], { a: 1, y: 2 })).to.equal(2)
+ expect(F.cascade(["x", "c"], { a: 1, y: 2 }, 2)).to.equal(2)
+ expect(F.cascade(["x", (x) => x.y], { a: 1, y: 2 })).to.equal(2)
+ expect(F.cascade(["x", "y"], { a: 1, x: null, y: 2 })).to.equal(2)
})
- it('cascadeIn', () => {
- expect(F.cascadeIn({ a: 1, y: 2 }, ['x', 'y'])).to.equal(2)
+ it("cascadeIn", () => {
+ expect(F.cascadeIn({ a: 1, y: 2 }, ["x", "y"])).to.equal(2)
})
- it('cascadeKey', () => {
- expect(F.cascadeKey(['x', 'y'], { a: 1, x: 2 })).to.equal('x')
+ it("cascadeKey", () => {
+ expect(F.cascadeKey(["x", "y"], { a: 1, x: 2 })).to.equal("x")
})
- it('cascadePropKey', () => {
- expect(F.cascadePropKey(['x', 'y'], { a: 1, x: null, y: 2 })).to.equal('x')
+ it("cascadePropKey", () => {
+ expect(F.cascadePropKey(["x", "y"], { a: 1, x: null, y: 2 })).to.equal("x")
})
- it('cascadeProp', () => {
- expect(F.cascadeProp(['x', 'y'], { a: 1, x: null, y: 2 })).to.equal(null)
+ it("cascadeProp", () => {
+ expect(F.cascadeProp(["x", "y"], { a: 1, x: null, y: 2 })).to.equal(null)
})
- it('unkeyBy', () => {
+ it("unkeyBy", () => {
expect(
- F.unkeyBy('field', {
+ F.unkeyBy("field", {
a: {
x: 1,
},
- 'd.e': {
+ "d.e": {
x: 5,
},
})
).to.deep.equal([
{
x: 1,
- field: 'a',
+ field: "a",
},
{
x: 5,
- field: 'd.e',
+ field: "d.e",
},
])
})
- it('unkeyBy', () => {
+ it("unkeyBy", () => {
expect(
- F.unkeyBy('', {
+ F.unkeyBy("", {
a: {
x: 1,
},
- 'd.e': {
+ "d.e": {
x: 5,
},
})
).to.deep.equal([
{
x: 1,
- a: 'a',
+ a: "a",
},
{
x: 5,
- 'd.e': 'd.e',
+ "d.e": "d.e",
},
])
})
- it('simpleDiff', () => {
+ it("simpleDiff", () => {
expect(
F.simpleDiff(
{
@@ -328,7 +328,7 @@ describe('Object Functions', () => {
from: undefined,
to: 3,
},
- 'd.e': {
+ "d.e": {
from: undefined,
to: 5,
},
@@ -342,7 +342,7 @@ describe('Object Functions', () => {
},
})
})
- it('simpleDiffArray', () => {
+ it("simpleDiffArray", () => {
expect(
F.simpleDiffArray(
{
@@ -368,38 +368,38 @@ describe('Object Functions', () => {
)
).to.deep.equal([
{
- field: 'a',
+ field: "a",
from: 3,
to: 1,
},
{
- field: 'b',
+ field: "b",
from: undefined,
to: 2,
},
{
- field: 'c',
+ field: "c",
from: undefined,
to: 3,
},
{
- field: 'd.e',
+ field: "d.e",
from: undefined,
to: 5,
},
{
- field: 'price',
+ field: "price",
from: 20,
to: undefined,
},
{
- field: 'amount',
+ field: "amount",
from: undefined,
to: 20,
},
])
})
- it('diff', () => {
+ it("diff", () => {
expect(
F.diff(
{
@@ -437,11 +437,11 @@ describe('Object Functions', () => {
from: undefined,
to: 3,
},
- 'd.e': {
+ "d.e": {
from: undefined,
to: 5,
},
- 'd.f': {
+ "d.f": {
from: 6,
to: undefined,
},
@@ -455,7 +455,7 @@ describe('Object Functions', () => {
},
})
})
- it('diffArray', () => {
+ it("diffArray", () => {
expect(
F.diffArray(
{
@@ -488,63 +488,63 @@ describe('Object Functions', () => {
)
).to.deep.equal([
{
- field: 'a',
+ field: "a",
from: 3,
to: 1,
},
{
- field: 'd.f',
+ field: "d.f",
from: 6,
to: undefined,
},
{
- field: 'price',
+ field: "price",
from: 20,
to: undefined,
},
{
- field: 'collection1.0.b',
+ field: "collection1.0.b",
from: 2,
to: undefined,
},
{
- field: 'collection2.0.a',
+ field: "collection2.0.a",
from: 1,
to: undefined,
},
{
- field: 'collection2.0.b',
+ field: "collection2.0.b",
from: 2,
to: undefined,
},
{
- field: 'z.zz',
+ field: "z.zz",
from: undefined,
to: 1,
},
{
- field: 'b',
+ field: "b",
from: undefined,
to: 2,
},
{
- field: 'c',
+ field: "c",
from: undefined,
to: 3,
},
{
- field: 'd.e',
+ field: "d.e",
from: undefined,
to: 5,
},
{
- field: 'amount',
+ field: "amount",
from: undefined,
to: 20,
},
])
})
- it('mergeAllArrays', () => {
+ it("mergeAllArrays", () => {
expect(
F.mergeAllArrays([
{
@@ -565,21 +565,21 @@ describe('Object Functions', () => {
b: 5,
})
})
- it('invertByArray', () => {
+ it("invertByArray", () => {
expect(
F.invertByArray({
- a: ['x', 'y', 'z'],
- b: ['x'],
+ a: ["x", "y", "z"],
+ b: ["x"],
})
).to.deep.equal({
- x: ['a', 'b'],
- y: ['a'],
- z: ['a'],
+ x: ["a", "b"],
+ y: ["a"],
+ z: ["a"],
})
})
- it('stampKey', () => {
+ it("stampKey", () => {
expect(
- F.stampKey('type', {
+ F.stampKey("type", {
foo: {
a: 1,
b: 2,
@@ -590,51 +590,51 @@ describe('Object Functions', () => {
foo: {
a: 1,
b: 2,
- type: 'foo',
+ type: "foo",
},
bar: {
- type: 'bar',
+ type: "bar",
},
})
})
- it('omitNil', () => {
- expect(F.omitNil({ a: 1, b: 'c', d: null, e: undefined })).to.deep.equal({
+ it("omitNil", () => {
+ expect(F.omitNil({ a: 1, b: "c", d: null, e: undefined })).to.deep.equal({
a: 1,
- b: 'c',
+ b: "c",
})
})
- it('omitNull', () => {
- expect(F.omitNull({ a: 1, b: 'c', d: null, e: undefined })).to.deep.equal({
+ it("omitNull", () => {
+ expect(F.omitNull({ a: 1, b: "c", d: null, e: undefined })).to.deep.equal({
a: 1,
- b: 'c',
+ b: "c",
e: undefined,
})
})
- it('omitBlank', () => {
+ it("omitBlank", () => {
expect(
- F.omitBlank({ a: 1, b: 'c', d: null, e: undefined, f: [], g: {}, h: '' })
+ F.omitBlank({ a: 1, b: "c", d: null, e: undefined, f: [], g: {}, h: "" })
).to.deep.equal({
a: 1,
- b: 'c',
+ b: "c",
})
})
- it('omitEmpty', () => {
+ it("omitEmpty", () => {
expect(
- F.omitEmpty({ a: 1, b: 'c', d: null, e: undefined, f: [], g: {}, h: '' })
+ F.omitEmpty({ a: 1, b: "c", d: null, e: undefined, f: [], g: {}, h: "" })
).to.deep.equal({
- b: 'c',
+ b: "c",
})
})
- it('mergeOverAll', () => {
- let foo = (x) => ({ [x]: 'foo' })
- let bar = (x) => ({ bar: x, [x]: 'bar' })
- expect(F.mergeOverAll([foo, bar])('a')).to.deep.equal({
- a: 'bar',
- bar: 'a',
+ it("mergeOverAll", () => {
+ let foo = (x) => ({ [x]: "foo" })
+ let bar = (x) => ({ bar: x, [x]: "bar" })
+ expect(F.mergeOverAll([foo, bar])("a")).to.deep.equal({
+ a: "bar",
+ bar: "a",
})
- expect(F.mergeOverAll([bar, foo])('a')).to.deep.equal({
- a: 'foo',
- bar: 'a',
+ expect(F.mergeOverAll([bar, foo])("a")).to.deep.equal({
+ a: "foo",
+ bar: "a",
})
// should NOT merge arrays
let qux = (a) => ({ x: a.map((x) => x + 3) })
@@ -645,13 +645,13 @@ describe('Object Functions', () => {
expect(F.mergeOverAll(undefined, undefined)).to.deep.equal({})
expect(F.mergeOverAll(undefined)(undefined)).to.deep.equal({})
expect(F.mergeOverAll([])(undefined)).to.deep.equal(undefined)
- expect(F.mergeOverAll([(x) => x, (x, y) => y])('abc', 'de')).to.deep.equal({
- 0: 'd',
- 1: 'e',
- 2: 'c',
+ expect(F.mergeOverAll([(x) => x, (x, y) => y])("abc", "de")).to.deep.equal({
+ 0: "d",
+ 1: "e",
+ 2: "c",
})
})
- it('mergeOverAllWith', () => {
+ it("mergeOverAllWith", () => {
let reverseArrayCustomizer = (objValue, srcValue) =>
srcValue.length ? srcValue.reverse() : srcValue
let qux = (a) => ({ x: a.map((x) => x + 3) })
@@ -659,7 +659,7 @@ describe('Object Functions', () => {
F.mergeOverAllWith(reverseArrayCustomizer, [() => ({}), qux])([1, 2, 3])
).to.deep.equal({ x: [6, 5, 4] })
})
- it('mergeOverAllArrays', () => {
+ it("mergeOverAllArrays", () => {
// should merge arrays
let qux = (a) => ({ x: a.map((x) => x + 3) })
expect(
@@ -668,17 +668,17 @@ describe('Object Functions', () => {
x: [1, 2, 3, 4, 5, 6],
})
})
- it('getWith', () => {
+ it("getWith", () => {
let square = (x) => x * x
let getWithSquare = F.getWith(square)
let foo = { a: 1, b: 3, c: 5 }
- expect(getWithSquare('c', foo)).to.equal(25)
- expect(F.getWith((x) => x + 1, 'b', foo)).to.equal(4)
+ expect(getWithSquare("c", foo)).to.equal(25)
+ expect(F.getWith((x) => x + 1, "b", foo)).to.equal(4)
// edge case: throws when customizer is not a function
- expect(() => F.getWith(undefined, 'b', foo)).to.throw(TypeError)
+ expect(() => F.getWith(undefined, "b", foo)).to.throw(TypeError)
})
- it('expandObject', () => {
- let foo = { a: 1, b: 2, c: 'a' }
+ it("expandObject", () => {
+ let foo = { a: 1, b: 2, c: "a" }
// should expand object
let toOptions = F.mapIndexed((v, k) => ({ label: k, value: v }))
expect(
@@ -686,43 +686,43 @@ describe('Object Functions', () => {
).to.deep.equal({
a: 1,
b: 2,
- c: 'a',
+ c: "a",
options: [
- { label: 'a', value: 1 },
- { label: 'b', value: 2 },
- { label: 'c', value: 'a' },
+ { label: "a", value: 1 },
+ { label: "b", value: 2 },
+ { label: "c", value: "a" },
],
})
// should override keys
expect(F.expandObject(_.invert, foo)).to.deep.equal({
- 1: 'a',
- 2: 'b',
- a: 'c',
+ 1: "a",
+ 2: "b",
+ a: "c",
b: 2,
- c: 'a',
+ c: "a",
})
})
- it('expandObjectBy', () => {
- let primeFactorization = (x) => (x === 42 ? { 2: 1, 3: 1, 7: 1 } : 'dunno')
+ it("expandObjectBy", () => {
+ let primeFactorization = (x) => (x === 42 ? { 2: 1, 3: 1, 7: 1 } : "dunno")
let foo = { a: 1, b: 42 }
- expect(F.expandObjectBy('b', primeFactorization, foo)).to.deep.equal({
+ expect(F.expandObjectBy("b", primeFactorization, foo)).to.deep.equal({
a: 1,
b: 42,
2: 1,
3: 1,
7: 1,
})
- expect(F.expandObjectBy('a', primeFactorization, foo)).to.deep.equal({
- 0: 'd',
- 1: 'u',
- 2: 'n',
- 3: 'n',
- 4: 'o',
+ expect(F.expandObjectBy("a", primeFactorization, foo)).to.deep.equal({
+ 0: "d",
+ 1: "u",
+ 2: "n",
+ 3: "n",
+ 4: "o",
a: 1,
b: 42,
})
})
- it('commonKeys', () => {
+ it("commonKeys", () => {
let providers = {
mongo: {},
elasticsearch: {},
@@ -734,15 +734,15 @@ describe('Object Functions', () => {
}
expect(F.commonKeys(providers, schema)).to.deep.equal([
- 'elasticsearch',
- 'mongo',
+ "elasticsearch",
+ "mongo",
])
expect(F.commonKeys(providers)(schema)).to.deep.equal([
- 'elasticsearch',
- 'mongo',
+ "elasticsearch",
+ "mongo",
])
})
- it('firstCommonKey', () => {
+ it("firstCommonKey", () => {
let providers = {
mongo: {},
elasticsearch: {},
@@ -753,6 +753,6 @@ describe('Object Functions', () => {
mongo: {},
}
- expect(F.firstCommonKey(providers, schema)).to.equal('elasticsearch')
+ expect(F.firstCommonKey(providers, schema)).to.equal("elasticsearch")
})
})
diff --git a/test/regex.spec.js b/test/regex.spec.js
index 0d660720..7e994f15 100644
--- a/test/regex.spec.js
+++ b/test/regex.spec.js
@@ -1,81 +1,81 @@
-import chai from 'chai'
-import * as F from '../src/regex'
+import chai from "chai"
+import * as F from "../src/regex"
chai.expect()
const expect = chai.expect
-describe('Regexp Functions', () => {
- it('testRegex', () => {
- expect(F.testRegex(/smart/i)('SmartProcure')).to.be.true
- expect(F.testRegex(/smart/)('SmartProcure')).to.be.false
+describe("Regexp Functions", () => {
+ it("testRegex", () => {
+ expect(F.testRegex(/smart/i)("SmartProcure")).to.be.true
+ expect(F.testRegex(/smart/)("SmartProcure")).to.be.false
})
- it('makeRegExp', () => {
- const reText = 'Some text'
- const options = 'gi'
+ it("makeRegExp", () => {
+ const reText = "Some text"
+ const options = "gi"
expect(F.makeRegex(options)(reText)).to.deep.equal(RegExp(reText, options))
})
- it('makeAndTest', () => {
- const reText = 'Some text'
- const options = 'gi'
- const text = 'Here is some text to test'
+ it("makeAndTest", () => {
+ const reText = "Some text"
+ const options = "gi"
+ const text = "Here is some text to test"
const regex = RegExp(reText, options)
expect(F.makeAndTest(options)(reText)(text)).to.deep.equal(regex.test(text))
})
- it('anyWordToRegexp', () => {
- expect(F.anyWordToRegexp('Any word to regexp')).to.equal(
- 'Any|word|to|regexp'
+ it("anyWordToRegexp", () => {
+ expect(F.anyWordToRegexp("Any word to regexp")).to.equal(
+ "Any|word|to|regexp"
)
})
- it('wordsToRegexp', () => {
- expect(F.wordsToRegexp('my three words')).to.equal(
- '.*(?=.*my.*)(?=.*three.*)(?=.*words.*).*'
+ it("wordsToRegexp", () => {
+ expect(F.wordsToRegexp("my three words")).to.equal(
+ ".*(?=.*my.*)(?=.*three.*)(?=.*words.*).*"
)
})
- it('matchAllWords', () => {
- const reText = 'Some text'
- const text = 'Here is some to test'
+ it("matchAllWords", () => {
+ const reText = "Some text"
+ const text = "Here is some to test"
const match = F.matchAllWords(reText)
expect(match(text)).to.be.false
})
- it('matchAnyWord', () => {
- const reText = 'Some text'
- const text = 'Here is some text to test'
+ it("matchAnyWord", () => {
+ const reText = "Some text"
+ const text = "Here is some text to test"
const match = F.matchAnyWord(reText)
expect(match(text)).to.be.true
})
- it('allMatches', () => {
- const re = '(\\d+)'
+ it("allMatches", () => {
+ const re = "(\\d+)"
const text = `1 22 333 a bb ccc 4444`
const matches = F.allMatches(re, text)
expect(matches).to.deep.equal([
- { text: '1', start: 0, end: 1 },
- { text: '22', start: 2, end: 4 },
- { text: '333', start: 5, end: 8 },
- { text: '4444', start: 18, end: 22 },
+ { text: "1", start: 0, end: 1 },
+ { text: "22", start: 2, end: 4 },
+ { text: "333", start: 5, end: 8 },
+ { text: "4444", start: 18, end: 22 },
])
})
})
-describe('Posting Highlight Functions', () => {
- it('postings', () => {
- var result = F.postings(RegExp('p', 'gi'), 'pretty please')
+describe("Posting Highlight Functions", () => {
+ it("postings", () => {
+ var result = F.postings(RegExp("p", "gi"), "pretty please")
expect(result).to.deep.equal([
[0, 1],
[7, 8],
])
})
- it('postingsForWords', () => {
- var result = F.postingsForWords('pret pr t ', 'pretty prease')
+ it("postingsForWords", () => {
+ var result = F.postingsForWords("pret pr t ", "pretty prease")
expect(result).to.deep.equal([
[[0, 4]],
[
@@ -89,21 +89,21 @@ describe('Posting Highlight Functions', () => {
])
})
- describe('highlightFromPostings', () => {
+ describe("highlightFromPostings", () => {
let start = ''
- let end = ''
+ let end = ""
- it('highlightFromPostings', () => {
- let input = 'pretty please'
- let postings = F.postings(RegExp('p', 'gi'), input)
+ it("highlightFromPostings", () => {
+ let input = "pretty please"
+ let postings = F.postings(RegExp("p", "gi"), input)
let expected =
'pretty please'
expect(F.highlightFromPostings(start, end, postings, input)).to.equal(
expected
)
})
- it('should highlight backwards postings', () => {
- let input = 'pretty please'
+ it("should highlight backwards postings", () => {
+ let input = "pretty please"
let expected =
'pretty please'
expect(
@@ -119,20 +119,20 @@ describe('Posting Highlight Functions', () => {
).to.equal(expected)
})
})
- describe('highlight', () => {
- it('highlight', () => {
+ describe("highlight", () => {
+ it("highlight", () => {
let start = ''
- let end = ''
- let input = 'pretty please'
- let pattern = 'pr pl'
+ let end = ""
+ let input = "pretty please"
+ let pattern = "pr pl"
let expected =
'pretty please'
expect(F.highlight(start, end, pattern, input)).to.equal(expected)
})
- it('should highlight from regexp', () => {
+ it("should highlight from regexp", () => {
let start = ''
- let end = ''
- let input = 'pretty please nope'
+ let end = ""
+ let input = "pretty please nope"
let pattern = /\bp\w/g
let expected =
'pretty please nope'
diff --git a/test/string.spec.js b/test/string.spec.js
index fae46e18..c3cbccea 100644
--- a/test/string.spec.js
+++ b/test/string.spec.js
@@ -1,108 +1,108 @@
-import chai from 'chai'
-import _ from 'lodash/fp'
-import * as F from '../src'
+import chai from "chai"
+import _ from "lodash/fp"
+import * as F from "../src"
chai.expect()
const expect = chai.expect
-describe('String Functions', () => {
- it('wrap', () => {
- expect(F.wrap('(', ')', 'asdf')).to.equal('(asdf)')
- expect(F.wrap(null, null, 'asdf')).to.equal('asdf')
+describe("String Functions", () => {
+ it("wrap", () => {
+ expect(F.wrap("(", ")", "asdf")).to.equal("(asdf)")
+ expect(F.wrap(null, null, "asdf")).to.equal("asdf")
})
- it('quote', () => {
- expect(F.quote('asdf')).to.equal('"asdf"')
+ it("quote", () => {
+ expect(F.quote("asdf")).to.equal('"asdf"')
})
- it('parens', () => {
- expect(F.parens('asdf')).to.equal('(asdf)')
+ it("parens", () => {
+ expect(F.parens("asdf")).to.equal("(asdf)")
})
- it('concatStrings', () => {
+ it("concatStrings", () => {
expect(
- F.concatStrings(['This ', ' is a ', null, '', 'sentence!'])
- ).to.equal('This is a sentence!')
+ F.concatStrings(["This ", " is a ", null, "", "sentence!"])
+ ).to.equal("This is a sentence!")
})
- it('trimStrings', () => {
+ it("trimStrings", () => {
expect(
- F.trimStrings(['This ', ' is a ', null, '', 'sentence!'])
- ).to.deep.equal(['This', 'is a', null, '', 'sentence!'])
+ F.trimStrings(["This ", " is a ", null, "", "sentence!"])
+ ).to.deep.equal(["This", "is a", null, "", "sentence!"])
expect(
- F.trimStrings({ a: 'a', b: ' b ', c: 'c ', d: ' d', e: 5 })
- ).to.deep.equal({ a: 'a', b: 'b', c: 'c', d: 'd', e: 5 })
+ F.trimStrings({ a: "a", b: " b ", c: "c ", d: " d", e: 5 })
+ ).to.deep.equal({ a: "a", b: "b", c: "c", d: "d", e: 5 })
})
- it('autoLabel', () => {
+ it("autoLabel", () => {
let tests = [
[
- 'whatDoYouThinkOfThisHTML5Stuff? IThinkItIsREALLYCool',
- 'What Do You Think Of This HTML 5 Stuff I Think It Is REALLY Cool',
+ "whatDoYouThinkOfThisHTML5Stuff? IThinkItIsREALLYCool",
+ "What Do You Think Of This HTML 5 Stuff I Think It Is REALLY Cool",
],
- ['thisIsAVariable', 'This Is A Variable'],
+ ["thisIsAVariable", "This Is A Variable"],
[
- 'thisIs_startCaseWithACRONYMSAndNumbersLike123and4',
- 'This Is Start Case With ACRONYMS And Numbers Like 123 And 4',
+ "thisIs_startCaseWithACRONYMSAndNumbersLike123and4",
+ "This Is Start Case With ACRONYMS And Numbers Like 123 And 4",
],
// Passive aggressive example of how to better auto generate PR titles from branch names...
- ['Feature/AutoLabel#126', 'Feature Auto Label 126'],
+ ["Feature/AutoLabel#126", "Feature Auto Label 126"],
]
F.eachIndexed(
([input, output]) => expect(F.autoLabel(input)).to.equal(output),
tests
)
})
- it('autoLabelOption', () => {
- expect(F.autoLabelOption('someValue')).to.deep.equal({
- value: 'someValue',
- label: 'Some Value',
+ it("autoLabelOption", () => {
+ expect(F.autoLabelOption("someValue")).to.deep.equal({
+ value: "someValue",
+ label: "Some Value",
})
})
- it('autoLabelOptions', () => {
+ it("autoLabelOptions", () => {
expect(
F.autoLabelOptions([
- { value: '', label: 'Empty String Value' },
- 'someValue',
- { value: 'justAValue' },
- { value: 'bothValueAndLabel', label: 'Custom Label' },
+ { value: "", label: "Empty String Value" },
+ "someValue",
+ { value: "justAValue" },
+ { value: "bothValueAndLabel", label: "Custom Label" },
])
).to.deep.equal([
- { value: '', label: 'Empty String Value' },
- { value: 'someValue', label: 'Some Value' },
- { value: 'justAValue', label: 'Just A Value' },
- { value: 'bothValueAndLabel', label: 'Custom Label' },
+ { value: "", label: "Empty String Value" },
+ { value: "someValue", label: "Some Value" },
+ { value: "justAValue", label: "Just A Value" },
+ { value: "bothValueAndLabel", label: "Custom Label" },
])
})
- it('toSentenceWith', () => {
+ it("toSentenceWith", () => {
expect(
- F.toSentenceWith(' - ', ' or ', ['first', 'second', 'third'])
- ).to.equal('first - second or third')
+ F.toSentenceWith(" - ", " or ", ["first", "second", "third"])
+ ).to.equal("first - second or third")
})
- it('toSentence', () => {
- expect(F.toSentence(['first', 'second', 'third'])).to.equal(
- 'first, second and third'
+ it("toSentence", () => {
+ expect(F.toSentence(["first", "second", "third"])).to.equal(
+ "first, second and third"
)
})
- it('uniqueStringWith', () => {
- let a = ['foo20', 'foo21', 'foo23', 'foo24', 'foo25']
- let stripDigits = F.arrayToObject(_.replace(/(\d+)$/, ''), () => 1)
+ it("uniqueStringWith", () => {
+ let a = ["foo20", "foo21", "foo23", "foo24", "foo25"]
+ let stripDigits = F.arrayToObject(_.replace(/(\d+)$/, ""), () => 1)
let uniqueStringStripDigits = F.uniqueStringWith(stripDigits, a)
expect(uniqueStringStripDigits.cache).to.deep.equal({ foo: 1 })
- expect(uniqueStringStripDigits('foo')).to.equal('foo1')
+ expect(uniqueStringStripDigits("foo")).to.equal("foo1")
// Should work with appending other stuff if you really want to
- let appendHiForSomeReason = F.arrayToObject(_.identity, () => 'hi')
+ let appendHiForSomeReason = F.arrayToObject(_.identity, () => "hi")
expect(
- _.map(F.uniqueStringWith(appendHiForSomeReason, ['foo']), [
- 'foo',
- 'foo',
- 'bar',
+ _.map(F.uniqueStringWith(appendHiForSomeReason, ["foo"]), [
+ "foo",
+ "foo",
+ "bar",
])
- ).to.deep.equal(['foohi', 'foohi1', 'bar'])
+ ).to.deep.equal(["foohi", "foohi1", "bar"])
})
- it('uniqueString', () => {
+ it("uniqueString", () => {
let dedupe = F.uniqueString([])
expect(dedupe.cache).to.deep.equal({})
expect(
_.map(
dedupe,
- _.times(() => 'foo', 5)
+ _.times(() => "foo", 5)
)
- ).to.deep.equal(['foo', 'foo1', 'foo2', 'foo3', 'foo4'])
+ ).to.deep.equal(["foo", "foo1", "foo2", "foo3", "foo4"])
expect(dedupe.cache).to.deep.equal({
foo: 5,
foo1: 1,
@@ -110,18 +110,18 @@ describe('String Functions', () => {
foo3: 1,
foo4: 1,
})
- expect(F.uniqueString(_.keys(dedupe.cache))('foo')).to.equal('foo5')
+ expect(F.uniqueString(_.keys(dedupe.cache))("foo")).to.equal("foo5")
// should cache result strings to avoid conflicts with user-specified strings that
// would have matched a uniqueString result
- let badFoos = ['foo', 'foo1', 'foo', 'foo2', 'foo', 'foo3', 'foo']
+ let badFoos = ["foo", "foo1", "foo", "foo2", "foo", "foo3", "foo"]
expect(_.map(F.uniqueString([]), badFoos)).to.deep.equal([
- 'foo',
- 'foo1',
- 'foo2',
- 'foo21',
- 'foo3',
- 'foo31',
- 'foo4',
+ "foo",
+ "foo1",
+ "foo2",
+ "foo21",
+ "foo3",
+ "foo31",
+ "foo4",
])
let text = _.words(`
Creates a function that invokes func with the arguments of the created function. If
@@ -136,8 +136,8 @@ describe('String Functions', () => {
dedupe.clear()
expect(dedupe.cache).to.deep.equal({})
// should handle calling with no arguments
- expect(F.uniqueString(null)('test')).to.be.a('string')
- expect(F.uniqueString(undefined)('test')).to.be.a('string')
- expect(F.uniqueString()('test')).to.be.a('string')
+ expect(F.uniqueString(null)("test")).to.be.a("string")
+ expect(F.uniqueString(undefined)("test")).to.be.a("string")
+ expect(F.uniqueString()("test")).to.be.a("string")
})
})
diff --git a/test/tree.spec.js b/test/tree.spec.js
index 2f90faea..b86067f7 100644
--- a/test/tree.spec.js
+++ b/test/tree.spec.js
@@ -1,19 +1,19 @@
-import chai from 'chai'
-import * as F from '../src'
-import _ from 'lodash/fp'
-import Promise from 'bluebird'
+import chai from "chai"
+import * as F from "../src"
+import _ from "lodash/fp"
+import Promise from "bluebird"
chai.expect()
const expect = chai.expect
-describe('Tree Functions', () => {
- it('isTraversable', () => {
+describe("Tree Functions", () => {
+ it("isTraversable", () => {
expect(F.isTraversable([])).to.be.true
expect(F.isTraversable({})).to.be.true
- expect(F.isTraversable('')).to.be.false
+ expect(F.isTraversable("")).to.be.false
expect(F.isTraversable(5)).to.be.false
})
- it('traverse', () => {
+ it("traverse", () => {
let x = {
a: 1,
b: {
@@ -22,7 +22,7 @@ describe('Tree Functions', () => {
}
expect(F.traverse(x)).to.deep.equal(x)
})
- describe('walk', () => {
+ describe("walk", () => {
let x = {
a: 1,
b: {
@@ -30,13 +30,13 @@ describe('Tree Functions', () => {
},
}
let values = []
- it('pre-order traversal', () => {
+ it("pre-order traversal", () => {
F.walk()((tree) => {
values.push(tree)
})(x)
expect(values).to.deep.equal([x, x.a, x.b, x.b.c])
})
- it('post-order traversal', () => {
+ it("post-order traversal", () => {
let values = []
F.walk()(
() => {},
@@ -46,7 +46,7 @@ describe('Tree Functions', () => {
)(x)
expect(values).to.deep.equal([x.a, x.b.c, x.b, x])
})
- it('halting', () => {
+ it("halting", () => {
let values = []
let r = F.walk()((tree) => {
values.push(tree)
@@ -55,7 +55,7 @@ describe('Tree Functions', () => {
expect(values).to.deep.equal([x, x.a])
expect(r).to.equal(x.a)
})
- it('halting with tree return', () => {
+ it("halting with tree return", () => {
let values = []
let r = F.walk()(
() => {},
@@ -67,20 +67,20 @@ describe('Tree Functions', () => {
expect(values).to.deep.equal([x.a, x.b.c, x.b, x])
expect(r).to.equal(x)
})
- it('should retain parent stack and indices', () => {
+ it("should retain parent stack and indices", () => {
let values = []
F.walk()((x, i, parents) => {
values.push([x, parents, i])
})(x)
expect(values).to.deep.equal([
[x, [], undefined],
- [x.a, [x], 'a'],
- [x.b, [x], 'b'],
- [x.b.c, [x.b, x], 'c'],
+ [x.a, [x], "a"],
+ [x.b, [x], "b"],
+ [x.b.c, [x.b, x], "c"],
])
})
})
- it('reduceTree', () => {
+ it("reduceTree", () => {
let x = {
a: 1,
b: {
@@ -94,7 +94,7 @@ describe('Tree Functions', () => {
x.b.c,
])
})
- it('treeToArray', () => {
+ it("treeToArray", () => {
let x = {
a: 1,
b: {
@@ -103,7 +103,7 @@ describe('Tree Functions', () => {
}
expect(F.treeToArray()(x)).to.deep.equal([x, x.a, x.b, x.b.c])
})
- it('treeToArrayBy', () => {
+ it("treeToArrayBy", () => {
let x = {
a: 1,
b: {
@@ -114,7 +114,7 @@ describe('Tree Functions', () => {
F.treeToArrayBy()((i) => (_.isNumber(i) ? i * 2 : i), x)
).to.deep.equal([x, x.a * 2, x.b, x.b.c * 2])
})
- it('leaves', () => {
+ it("leaves", () => {
let x = {
a: 1,
b: {
@@ -123,7 +123,7 @@ describe('Tree Functions', () => {
}
expect(F.leaves()(x)).to.deep.equal([1, 2])
})
- it('tree', () => {
+ it("tree", () => {
let x = {
a: 1,
b: {
@@ -133,7 +133,7 @@ describe('Tree Functions', () => {
let tree = F.tree()
expect(tree.toArray(x)).to.deep.equal([x, x.a, x.b, x.b.c])
})
- it('lookup', () => {
+ it("lookup", () => {
let x = {
a: 1,
items: [
@@ -158,24 +158,24 @@ describe('Tree Functions', () => {
expect(tree.lookup([{ a: 2 }, { a: 4 }], x)).to.equal(x.items[0].items[1])
})
- it('lookup with path', () => {
+ it("lookup with path", () => {
let x = {
- a: '1',
+ a: "1",
items: [
{
- a: '2',
+ a: "2",
items: [
{
- a: '3',
+ a: "3",
},
{
- a: '4',
+ a: "4",
b: 4,
},
],
},
{
- a: '5',
+ a: "5",
},
],
}
@@ -183,100 +183,100 @@ describe('Tree Functions', () => {
(x) => x.items,
(a) => ({ a })
)
- expect(tree.lookup(['2', '4'], x)).to.equal(x.items[0].items[1])
+ expect(tree.lookup(["2", "4"], x)).to.equal(x.items[0].items[1])
})
- it('transform', () => {
+ it("transform", () => {
let x = {
- a: '1',
+ a: "1",
items: [
{
- a: '2',
+ a: "2",
items: [
{
- a: '3',
+ a: "3",
},
{
- a: '4',
+ a: "4",
b: 4,
},
],
},
{
- a: '5',
+ a: "5",
},
],
}
expect(
F.transformTree((x) => x.items)((x) => {
- x.b = 'transformed'
+ x.b = "transformed"
}, x)
).to.deep.equal({
- a: '1',
- b: 'transformed',
+ a: "1",
+ b: "transformed",
items: [
{
- a: '2',
- b: 'transformed',
+ a: "2",
+ b: "transformed",
items: [
{
- a: '3',
- b: 'transformed',
+ a: "3",
+ b: "transformed",
},
{
- a: '4',
- b: 'transformed',
+ a: "4",
+ b: "transformed",
},
],
},
{
- a: '5',
- b: 'transformed',
+ a: "5",
+ b: "transformed",
},
],
})
expect(x).to.deep.equal({
- a: '1',
+ a: "1",
items: [
{
- a: '2',
+ a: "2",
items: [
{
- a: '3',
+ a: "3",
},
{
- a: '4',
+ a: "4",
b: 4,
},
],
},
{
- a: '5',
+ a: "5",
},
],
})
})
- it('keyByWith', () => {
+ it("keyByWith", () => {
let x = {
- a: 'first',
+ a: "first",
items: [
{
- a: 'second',
+ a: "second",
items: [
{
- a: 'first',
+ a: "first",
},
{
- a: 'second',
+ a: "second",
b: 4,
},
{
- a: 'second',
+ a: "second",
b: 6,
},
],
},
{
- a: 'second',
+ a: "second",
},
],
}
@@ -287,95 +287,95 @@ describe('Tree Functions', () => {
(x, matches, group) => {
if (matches) x.type = `${group} type`
},
- 'a',
+ "a",
x
)
).to.deep.equal({
first: {
- a: 'first',
- type: 'first type',
+ a: "first",
+ type: "first type",
items: [
{
- a: 'second',
+ a: "second",
items: [
{
- a: 'first',
- type: 'first type',
+ a: "first",
+ type: "first type",
},
{
- a: 'second',
+ a: "second",
b: 4,
},
{
- a: 'second',
+ a: "second",
b: 6,
},
],
},
{
- a: 'second',
+ a: "second",
},
],
},
second: {
- a: 'first',
+ a: "first",
items: [
{
- a: 'second',
- type: 'second type',
+ a: "second",
+ type: "second type",
items: [
{
- a: 'first',
+ a: "first",
},
{
- a: 'second',
- type: 'second type',
+ a: "second",
+ type: "second type",
b: 4,
},
{
- a: 'second',
- type: 'second type',
+ a: "second",
+ type: "second type",
b: 6,
},
],
},
{
- a: 'second',
- type: 'second type',
+ a: "second",
+ type: "second type",
},
],
},
})
})
- it('flattenTree', () => {
+ it("flattenTree", () => {
let properties = {
Field1: {
- type: 'text',
+ type: "text",
},
Field2: {
properties: {
Field2A: {
properties: {
Field2A1: {
- type: 'text',
+ type: "text",
},
Field2A2: {
- type: 'text',
+ type: "text",
},
Field2A3: {
properties: {
Field2A3a: {
- type: 'text',
+ type: "text",
},
},
},
},
},
Field2B: {
- type: 'text',
+ type: "text",
},
Field2C: {
- type: 'text',
+ type: "text",
},
},
},
@@ -384,43 +384,43 @@ describe('Tree Functions', () => {
let result = _.flow(Tree.flatten(), _.omitBy(Tree.traverse))({ properties })
expect(result).to.deep.equal({
Field1: {
- type: 'text',
+ type: "text",
},
- 'Field2.Field2A.Field2A1': {
- type: 'text',
+ "Field2.Field2A.Field2A1": {
+ type: "text",
},
- 'Field2.Field2A.Field2A2': {
- type: 'text',
+ "Field2.Field2A.Field2A2": {
+ type: "text",
},
- 'Field2.Field2A.Field2A3.Field2A3a': {
- type: 'text',
+ "Field2.Field2A.Field2A3.Field2A3a": {
+ type: "text",
},
- 'Field2.Field2B': {
- type: 'text',
+ "Field2.Field2B": {
+ type: "text",
},
- 'Field2.Field2C': {
- type: 'text',
+ "Field2.Field2C": {
+ type: "text",
},
})
})
- it('flattenTree with propTreePath', () => {
+ it("flattenTree with propTreePath", () => {
let Tree = F.tree((x) => x.children)
- let result = Tree.flatten(F.propTreePath('key'))({
- key: 'root',
+ let result = Tree.flatten(F.propTreePath("key"))({
+ key: "root",
children: [
{
- key: 'criteria',
+ key: "criteria",
children: [
{
- key: 'filter',
+ key: "filter",
},
],
},
{
- key: 'analysis',
+ key: "analysis",
children: [
{
- key: 'results',
+ key: "results",
},
],
},
@@ -428,59 +428,59 @@ describe('Tree Functions', () => {
})
expect(result).to.deep.equal({
root: {
- key: 'root',
+ key: "root",
children: [
{
- key: 'criteria',
+ key: "criteria",
children: [
{
- key: 'filter',
+ key: "filter",
},
],
},
{
- key: 'analysis',
+ key: "analysis",
children: [
{
- key: 'results',
+ key: "results",
},
],
},
],
},
- 'root/analysis': {
- key: 'analysis',
+ "root/analysis": {
+ key: "analysis",
children: [
{
- key: 'results',
+ key: "results",
},
],
},
- 'root/analysis/results': {
- key: 'results',
+ "root/analysis/results": {
+ key: "results",
},
- 'root/criteria': {
- key: 'criteria',
+ "root/criteria": {
+ key: "criteria",
children: [
{
- key: 'filter',
+ key: "filter",
},
],
},
- 'root/criteria/filter': {
- key: 'filter',
+ "root/criteria/filter": {
+ key: "filter",
},
})
expect(Tree.flatLeaves(result)).to.deep.equal([
{
- key: 'filter',
+ key: "filter",
},
{
- key: 'results',
+ key: "results",
},
])
})
- it('findIndexedAsync', async () => {
+ it("findIndexedAsync", async () => {
let findIndexedAsyncTest = await F.findIndexedAsync(
async (x) => {
await Promise.delay(10)
@@ -490,7 +490,7 @@ describe('Tree Functions', () => {
)
expect(findIndexedAsyncTest).to.equal(2)
})
- it('walkAsync', async () => {
+ it("walkAsync", async () => {
let tree = {
a: {
b: {
@@ -506,7 +506,7 @@ describe('Tree Functions', () => {
await walkAsyncTest
expect(tree.a.b.c.length).to.equal(4)
})
- it('walkAsync with sync', async () => {
+ it("walkAsync with sync", async () => {
let tree = {
a: {
b: {
@@ -521,19 +521,19 @@ describe('Tree Functions', () => {
await walkAsyncTest
expect(tree.a.b.c.length).to.equal(4)
})
- it('mapTreeLeaves', () => {
+ it("mapTreeLeaves", () => {
let tree = { a: { b: { c: [1, 2, 3] } } }
let double = (x) => x * 2
let result = F.mapTreeLeaves()(double, tree)
expect(tree).to.deep.equal({ a: { b: { c: [1, 2, 3] } } })
expect(result).to.deep.equal({ a: { b: { c: [2, 4, 6] } } })
})
- it('mapTreeLeaves contexture tree', () => {
+ it("mapTreeLeaves contexture tree", () => {
let tree = {
- key: 'root',
+ key: "root",
children: [
- { key: 'criteria', children: [{ key: 'filter' }, { key: 'f2' }] },
- { key: 'analysis', children: [{ key: 'results' }] },
+ { key: "criteria", children: [{ key: "filter" }, { key: "f2" }] },
+ { key: "analysis", children: [{ key: "results" }] },
],
}
let getChildren = (x) => x.children
@@ -542,44 +542,44 @@ describe('Tree Functions', () => {
// parent.children[index] = node
// }
let mapLeaves = F.mapTreeLeaves(getChildren) //, writeChild)
- let result = mapLeaves((node) => ({ ...node, value: 'test' }), tree)
+ let result = mapLeaves((node) => ({ ...node, value: "test" }), tree)
expect(result).to.deep.equal({
- key: 'root',
+ key: "root",
children: [
{
- key: 'criteria',
+ key: "criteria",
children: [
- { key: 'filter', value: 'test' },
- { key: 'f2', value: 'test' },
+ { key: "filter", value: "test" },
+ { key: "f2", value: "test" },
],
},
- { key: 'analysis', children: [{ key: 'results', value: 'test' }] },
+ { key: "analysis", children: [{ key: "results", value: "test" }] },
],
})
})
- it('mapTree on JSON schema', () => {
+ it("mapTree on JSON schema", () => {
let tree = {
- type: 'object',
+ type: "object",
additionalProperties: false,
- required: ['email', 'subscriptionType'],
+ required: ["email", "subscriptionType"],
properties: {
- _id: { type: 'objectId' },
- email: { type: 'string' },
- password: { type: 'string' },
- name: { type: 'string' },
- organization: { type: 'objectId' },
- permissions: { type: 'array', items: { type: 'string' } },
- subscriptionType: { type: 'string', enum: ['basic', 'premium'] },
- createdAt: { type: 'date' },
- updatedAt: { type: 'date' },
+ _id: { type: "objectId" },
+ email: { type: "string" },
+ password: { type: "string" },
+ name: { type: "string" },
+ organization: { type: "objectId" },
+ permissions: { type: "array", items: { type: "string" } },
+ subscriptionType: { type: "string", enum: ["basic", "premium"] },
+ createdAt: { type: "date" },
+ updatedAt: { type: "date" },
metrics: {
- type: 'object',
+ type: "object",
additionalProperties: false,
properties: {
- sessionsCount: { type: 'number' },
- totalSessionLength: { type: 'number' },
- firstSession: { type: 'date' },
- lastSession: { type: 'date' },
+ sessionsCount: { type: "number" },
+ totalSessionLength: { type: "number" },
+ firstSession: { type: "date" },
+ lastSession: { type: "date" },
},
},
},
@@ -589,33 +589,33 @@ describe('Tree Functions', () => {
let { map } = F.tree(getChildren)
let jsonSchemaToMongoSchema = _.flow(
- F.renameProperty('type', 'bsonType'),
- F.renameProperty('items.type', 'items.bsonType')
+ F.renameProperty("type", "bsonType"),
+ F.renameProperty("items.type", "items.bsonType")
)
let result = map(jsonSchemaToMongoSchema, tree)
expect(result).to.deep.equal({
- bsonType: 'object',
+ bsonType: "object",
additionalProperties: false,
- required: ['email', 'subscriptionType'],
+ required: ["email", "subscriptionType"],
properties: {
- _id: { bsonType: 'objectId' },
- email: { bsonType: 'string' },
- password: { bsonType: 'string' },
- name: { bsonType: 'string' },
- organization: { bsonType: 'objectId' },
- permissions: { bsonType: 'array', items: { bsonType: 'string' } },
- subscriptionType: { bsonType: 'string', enum: ['basic', 'premium'] },
- createdAt: { bsonType: 'date' },
- updatedAt: { bsonType: 'date' },
+ _id: { bsonType: "objectId" },
+ email: { bsonType: "string" },
+ password: { bsonType: "string" },
+ name: { bsonType: "string" },
+ organization: { bsonType: "objectId" },
+ permissions: { bsonType: "array", items: { bsonType: "string" } },
+ subscriptionType: { bsonType: "string", enum: ["basic", "premium"] },
+ createdAt: { bsonType: "date" },
+ updatedAt: { bsonType: "date" },
metrics: {
- bsonType: 'object',
+ bsonType: "object",
additionalProperties: false,
properties: {
- sessionsCount: { bsonType: 'number' },
- totalSessionLength: { bsonType: 'number' },
- firstSession: { bsonType: 'date' },
- lastSession: { bsonType: 'date' },
+ sessionsCount: { bsonType: "number" },
+ totalSessionLength: { bsonType: "number" },
+ firstSession: { bsonType: "date" },
+ lastSession: { bsonType: "date" },
},
},
},
diff --git a/webpack.config.js b/webpack.config.js
index bca13902..befd8675 100644
--- a/webpack.config.js
+++ b/webpack.config.js
@@ -1,20 +1,20 @@
-var path = require('path')
-var webpack = require('webpack')
-var packageMetadata = require('./package.json')
+var path = require("path")
+var webpack = require("webpack")
+var packageMetadata = require("./package.json")
var libraryName = packageMetadata.name
var libraryVersion = packageMetadata.version
-var outputFile = libraryName + '.js'
+var outputFile = libraryName + ".js"
module.exports = {
- devtool: 'source-map',
- mode: 'production',
- entry: path.join(__dirname, 'src/index.js'),
+ devtool: "source-map",
+ mode: "production",
+ entry: path.join(__dirname, "src/index.js"),
output: {
- path: path.join(__dirname, 'lib'),
+ path: path.join(__dirname, "lib"),
filename: outputFile,
library: libraryName,
- libraryTarget: 'umd',
- globalObject: 'this',
+ libraryTarget: "umd",
+ globalObject: "this",
},
module: {
rules: [
@@ -22,17 +22,17 @@ module.exports = {
test: /(\.jsx|\.js)$/,
exclude: /(node_modules|bower_components)/,
use: {
- loader: 'babel-loader',
+ loader: "babel-loader",
},
},
],
},
externals: {
- 'lodash/fp': 'lodash/fp',
+ "lodash/fp": "lodash/fp",
},
plugins: [
new webpack.DefinePlugin({
- 'global.__VERSION__': JSON.stringify(libraryVersion),
+ "global.__VERSION__": JSON.stringify(libraryVersion),
}),
],
}