Merge branch feature/example into master

ui2code · ui2code · commit b1121efc51ef · 2020-07-23T16:34:26.000-03:00
::SUMMARY:: Branch feature/example commits: feat: add methods feat: add dependency Branch master commits: * * * * * * * * * * * * * * * * * * * * * * * * * ::DETAILS:: commit > 4274e7a Author: Hemerson Vianna <hemerson.lourenco@gmail.com> Date: Thu Jul 23 16:33:16 2020 -0300 feat: add methods commit > 096d390 Author: Hemerson Vianna <hemerson.lourenco@gmail.com> Date: Thu Jul 23 15:45:20 2020 -0300 feat: add dependency
diff --git a/.nvmrc b/.nvmrc
@@ -1 +1 @@
-10.15.3
+v12.18.2
diff --git a/README.md b/README.md
@@ -10,8 +10,8 @@
 
 ## Prerequisites
 
-- [Node = v10.15.x](https://nodejs.org/en/)
-- NPM >= v6.4.x
+- [Node = v12.18.x](https://nodejs.org/en/)
+- NPM >= v6.14.x
 - [Yarn >= v1.22.0](https://yarnpkg.com/en/docs/install#linux-tab) or `npm install -g yarn`
 
 ## Log
diff --git a/package.json b/package.json
@@ -19,5 +19,7 @@
   "devDependencies": {
     "release-it": "12.4.3"
   },
-  "dependencies": {}
+  "dependencies": {
+    "immutable": "4.0.0-rc.12"
+  }
 }
diff --git a/source/collection.js b/source/collection.js
@@ -0,0 +1,19 @@
+// Collection
+
+// Collection.Keyed
+
+// Collection.Keyed<K, V>(collection: Iterable<[K, V]>): Collection.Keyed<K, V>
+// Collection.Keyed<V>(obj: {[key: string]: V}): Collection.Keyed<string, V>
+
+// Collection.Indexed
+
+// Collection.Indexed<T>(collection: Iterable<T>): Collection.Indexed<T>
+
+// Collection.Set
+
+const { Collection } = require('immutable')
+const seq = Collection.Set([ 'A', 'B', 'C' ])
+// Seq { "A", "B", "C" }
+seq.forEach((v, k) =>
+ assert.equal(v, k)
+)
diff --git a/source/from-js.js b/source/from-js.js
@@ -0,0 +1,14 @@
+// fromJS(
+//   jsValue: any,
+//   reviver?: (
+//   key: string | number,
+//   sequence: Collection.Keyed<string, any> | Collection.Indexed<any>,
+//   path?: Array<string | number>
+//   ) => any
+//   ): any
+
+const { fromJS, isKeyed } = require('immutable')
+fromJS({ a: {b: [10, 20, 30]}, c: 40}, function (key, value, path) {
+  console.log(key, value, path)
+  return isKeyed(value) ? value.toOrderedMap() : value.toList()
+})
diff --git a/source/get.js b/source/get.js
@@ -0,0 +1,17 @@
+// get<K, V>(collection: Collection<K, V>, key: K): V | undefined
+// get<K, V, NSV>(collection: Collection<K, V>, key: K, notSetValue: NSV): V | NSV
+// get<TProps, K>(record: Record<TProps>, key: K, notSetValue: any): TProps[K]
+// get<V>(collection: Array<V>, key: number): V | undefined
+// get<V, NSV>(collection: Array<V>, key: number, notSetValue: NSV): V | NSV
+// get<C, K>(object: C, key: K, notSetValue: any): C[K]
+// get<V>(collection: {[key: string]: V}, key: string): V | undefined
+// get<V, NSV>(
+// collection: {[key: string]: V},
+// key: string,
+// notSetValue: NSV
+// ): V | NSV
+
+const { get } = require("immutable");
+get(["dog", "frog", "cat"], 2); // 'frog'
+get({ x: 123, y: 456 }, "x"); // 123
+get({ x: 123, y: 456 }, "z", "ifNotSet"); // 'ifNotSet'
diff --git a/source/has.js b/source/has.js
@@ -0,0 +1,5 @@
+const { has } = require("immutable");
+has(["dog", "frog", "cat"], 2); // true
+has(["dog", "frog", "cat"], 5); // false
+has({ x: 123, y: 456 }, "x"); // true
+has({ x: 123, y: 456 }, "z"); // false
diff --git a/source/hash.js b/source/hash.js
@@ -0,0 +1 @@
+// hash(value: any): number
diff --git a/source/in.js b/source/in.js
@@ -0,0 +1,44 @@
+// getIn()
+
+const { getIn } = require('immutable')
+getIn({ x: { y: { z: 123 }}}, ['x', 'y', 'z']) // 123
+getIn({ x: { y: { z: 123 }}}, ['x', 'q', 'p'], 'ifNotSet') // 'ifNotSet'
+
+// hasIn()
+
+const { hasIn } = require('immutable')
+hasIn({ x: { y: { z: 123 }}}, ['x', 'y', 'z']) // true
+hasIn({ x: { y: { z: 123 }}}, ['x', 'q', 'p']) // false
+
+// removeIn()
+
+const { removeIn } = require('immutable')
+const original = { x: { y: { z: 123 }}}
+removeIn(original, ['x', 'y', 'z']) // { x: { y: {}}}
+console.log(original) // { x: { y: { z: 123 }}}
+
+// setIn()
+
+const { setIn } = require('immutable')
+const original = { x: { y: { z: 123 }}}
+setIn(original, ['x', 'y', 'z'], 456) // { x: { y: { z: 456 }}}
+console.log(original) // { x: { y: { z: 123 }}}
+
+// updateIn()
+
+// updateIn<C>(
+//   collection: C,
+//   keyPath: Iterable<any>,
+//   updater: (value: any) => any
+//   ): C
+//   updateIn<C>(
+//   collection: C,
+//   keyPath: Iterable<any>,
+//   notSetValue: any,
+//   updater: (value: any) => any
+//   ): C
+
+const { updateIn } = require('immutable')
+const original = { x: { y: { z: 123 }}}
+updateIn(original, ['x', 'y', 'z'], val => val * 6) // { x: { y: { z: 738 }}}
+console.log(original) // { x: { y: { z: 123 }}}
diff --git a/source/is.js b/source/is.js
@@ -0,0 +1,102 @@
+// is
+
+const { Map, is } = require('immutable')
+const map1 = Map({ a: 1, b: 1, c: 1 })
+const map2 = Map({ a: 1, b: 1, c: 1 })
+assert.equal(map1 !== map2, true)
+assert.equal(Object.is(map1, map2), false)
+assert.equal(is(map1, map2), true)
+
+// isImmutable()
+
+const { isImmutable, Map, List, Stack } = require('immutable');
+isImmutable([]); // false
+isImmutable({}); // false
+isImmutable(Map()); // true
+isImmutable(List()); // true
+isImmutable(Stack()); // true
+isImmutable(Map().asMutable()); // true
+
+// isCollection()
+
+const { isCollection, Map, List, Stack } = require('immutable');
+isCollection([]); // false
+isCollection({}); // false
+isCollection(Map()); // true
+isCollection(List()); // true
+isCollection(Stack()); // true
+
+// isKeyed()
+
+const { isKeyed, Map, List, Stack } = require('immutable');
+isKeyed([]); // false
+isKeyed({}); // false
+isKeyed(Map()); // true
+isKeyed(List()); // false
+isKeyed(Stack()); // false
+
+// isIndexed()
+
+const { isIndexed, Map, List, Stack, Set } = require('immutable');
+isIndexed([]); // false
+isIndexed({}); // false
+isIndexed(Map()); // false
+isIndexed(List()); // true
+isIndexed(Stack()); // true
+isIndexed(Set()); // false
+
+// isAssociative()
+
+const { isAssociative, Map, List, Stack, Set } = require('immutable');
+isAssociative([]); // false
+isAssociative({}); // false
+isAssociative(Map()); // true
+isAssociative(List()); // true
+isAssociative(Stack()); // true
+isAssociative(Set()); // false
+
+// isOrdered()
+
+const { isOrdered, Map, OrderedMap, List, Set } = require('immutable');
+isOrdered([]); // false
+isOrdered({}); // false
+isOrdered(Map()); // false
+isOrdered(OrderedMap()); // true
+isOrdered(List()); // true
+isOrdered(Set()); // false
+
+// isValueObject()
+// isSeq()
+// isList()
+// isMap()
+// isOrderedMap()
+// isStack()
+// isSet()
+// isOrderedSet()
+// isRecord()
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/source/list.js b/source/list.js
@@ -0,0 +1,24 @@
+// List(): List<any>
+// List<T>(): List<T>
+// List<T>(collection: Iterable<T>): List<T>
+
+const { List, Set } = require('immutable')
+
+const emptyList = List()
+// List []
+
+const plainArray = [ 1, 2, 3, 4 ]
+const listFromPlainArray = List(plainArray)
+// List [ 1, 2, 3, 4 ]
+
+const plainSet = Set([ 1, 2, 3, 4 ])
+const listFromPlainSet = List(plainSet)
+// List [ 1, 2, 3, 4 ]
+
+const arrayIterator = plainArray[Symbol.iterator]()
+const listFromCollectionArray = List(arrayIterator)
+// List [ 1, 2, 3, 4 ]
+
+listFromPlainArray.equals(listFromCollectionArray) // true
+listFromPlainSet.equals(listFromCollectionArray) // true
+listFromPlainSet.equals(listFromPlainArray) // true
diff --git a/source/map.js b/source/map.js
@@ -0,0 +1,15 @@
+// Map<K, V>(collection: Iterable<[K, V]>): Map<K, V>
+// Map<V>(obj: {[key: string]: V}): Map<string, V>
+// Map<K, V>(): Map<K, V>
+// Map(): Map<any, any>
+
+const { Map } = require('immutable')
+Map({ key: "value" })
+Map([ [ "key", "value" ] ])
+
+let obj = { 1: "one" }
+Object.keys(obj) // [ "1" ]
+assert.equal(obj["1"], obj[1]) // "one" === "one"
+
+let map = Map(obj)
+assert.notEqual(map.get("1"), map.get(1)) // "one" !== undefined
diff --git a/source/merge.js b/source/merge.js
@@ -0,0 +1,57 @@
+// merge
+
+// merge<C>(
+//   collection: C,
+//   ...collections: Array<Iterable<any> | Iterable<[any, any]> | {[key: string]: any}>
+//   ): C
+
+const { merge } = require('immutable')
+const original = { x: 123, y: 456 }
+merge(original, { y: 789, z: 'abc' }) // { x: 123, y: 789, z: 'abc' }
+console.log(original) // { x: 123, y: 456 }
+
+// mergeWith()
+
+// mergeWith<C>(
+//   merger: (oldVal: any, newVal: any, key: any) => any,
+//   collection: C,
+//   ...collections: Array<Iterable<any> | Iterable<[any, any]> | {[key: string]: any}>
+//   ): C
+
+const { mergeWith } = require('immutable')
+const original = { x: 123, y: 456 }
+mergeWith(
+  (oldVal, newVal) => oldVal + newVal,
+  original,
+  { y: 789, z: 'abc' }
+) // { x: 123, y: 1245, z: 'abc' }
+console.log(original) // { x: 123, y: 456 }
+
+// mergeDeep()
+
+// mergeDeep<C>(
+//   collection: C,
+//   ...collections: Array<Iterable<any> | Iterable<[any, any]> | {[key: string]: any}>
+//   ): C
+
+const { mergeDeep } = require('immutable')
+const original = { x: { y: 123 }}
+mergeDeep(original, { x: { z: 456 }}) // { x: { y: 123, z: 456 }}
+console.log(original) // { x: { y: 123 }}
+
+// mergeDeepWith()
+
+// mergeDeepWith<C>(
+//   merger: (oldVal: any, newVal: any, key: any) => any,
+//   collection: C,
+//   ...collections: Array<Iterable<any> | Iterable<[any, any]> | {[key: string]: any}>
+//   ): C
+
+const { mergeDeepWith } = require('immutable')
+const original = { x: { y: 123 }}
+mergeDeepWith(
+  (oldVal, newVal) => oldVal + newVal,
+  original,
+  { x: { y: 456 }}
+) // { x: { y: 579 }}
+console.log(original) // { x: { y: 123 }}
diff --git a/source/ordered.js b/source/ordered.js
@@ -0,0 +1,15 @@
+// OrderedMap
+
+// OrderedMap<K, V>(collection: Iterable<[K, V]>): OrderedMap<K, V>
+// OrderedMap<V>(obj: {[key: string]: V}): OrderedMap<string, V>
+// OrderedMap<K, V>(): OrderedMap<K, V>
+// OrderedMap(): OrderedMap<any, any>
+
+let newOrderedMap = OrderedMap({key: "value"})
+let newOrderedMap = OrderedMap([["key", "value"]])
+
+// OrderedSet
+
+// OrderedSet(): OrderedSet<any>
+// OrderedSet<T>(): OrderedSet<T>
+// OrderedSet<T>(collection: Iterable<T>): OrderedSet<T>
diff --git a/source/range.js b/source/range.js
@@ -0,0 +1,7 @@
+const { Range } = require('immutable')
+Range() // [ 0, 1, 2, 3, ... ]
+Range(10) // [ 10, 11, 12, 13, ... ]
+Range(10, 15) // [ 10, 11, 12, 13, 14 ]
+Range(10, 30, 5) // [ 10, 15, 20, 25 ]
+Range(30, 10, 5) // [ 30, 25, 20, 15 ]
+Range(30, 30, 5) // []
diff --git a/source/record.js b/source/record.js
@@ -0,0 +1,19 @@
+// Record
+
+const { Record } = require('immutable')
+const ABRecord = Record({ a: 1, b: 2 })
+const myRecord = ABRecord({ b: 3 })
+
+// Record.Factory
+
+// makePerson is a Record Factory function
+const makePerson = Record({ name: null, favoriteColor: 'unknown' });
+
+// alan is a Record instance
+const alan = makePerson({ name: 'Alan' });
+
+// Use the Record API
+console.log('Record API: ' + alan.get('name'))
+
+// Or direct property access (Readonly)
+console.log('property access: ' + alan.name)
diff --git a/source/remove.js b/source/remove.js
@@ -0,0 +1,13 @@
+// remove<K, C>(collection: C, key: K): C
+// remove<TProps, C, K>(collection: C, key: K): C
+// remove<C>(collection: C, key: number): C
+// remove<C, K>(collection: C, key: K): C
+// remove<C, K>(collection: C, key: K): C
+
+const { remove } = require('immutable')
+const originalArray = [ 'dog', 'frog', 'cat' ]
+remove(originalArray, 1) // [ 'dog', 'cat' ]
+console.log(originalArray) // [ 'dog', 'frog', 'cat' ]
+const originalObject = { x: 123, y: 456 }
+remove(originalObject, 'x') // { y: 456 }
+console.log(originalObject) // { x: 123, y: 456 }
diff --git a/source/repeat.js b/source/repeat.js
@@ -0,0 +1,3 @@
+const { Repeat } = require('immutable')
+Repeat('foo') // [ 'foo', 'foo', 'foo', ... ]
+Repeat('bar', 4) // [ 'bar', 'bar', 'bar', 'bar' ]
diff --git a/source/seq.js b/source/seq.js
diff --git a/source/set.js b/source/set.js
diff --git a/source/stack.js b/source/stack.js
diff --git a/source/update.js b/source/update.js
diff --git a/source/value-object.js b/source/value-object.js
diff --git a/yarn.lock b/yarn.lock

Original file line number	Diff line number	Diff line change
`@@ -19,5 +19,7 @@`
`19`	`19`	`"devDependencies": {`
`20`	`20`	`"release-it": "12.4.3"`
`21`	`21`	`},`
`22`		`- "dependencies": {}`
	`22`	`+ "dependencies": {`
	`23`	`+ "immutable": "4.0.0-rc.12"`
	`24`	`+ }`
`23`	`25`	`}`