redux-collector - npm Package Compare versions

Comparing version 0.1.1 to 0.1.2

lib/normalizers.js

@@ -125,6 +125,7 @@ 'use strict';
   }
-  if (indexes !== undefined && rest.query === undefined) {
-    rest.query = function (item, index) {
+  if (indexes !== undefined) {
+    var query = rest.query === undefined ? [] : [rest.query];
+    rest.query = [].concat(query, [function (item, index) {
       return (0, _lib.contains)(indexes, index);
-    };
+    }]);
   }
@@ -148,2 +149,2 @@ return _extends({ skip: toSkip, indexes: indexes, limit: toLimit }, rest);
 exports.normalizeTo = normalizeTo;
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package.json

 {
   "name": "redux-collector",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "description": "Easy Collection Reducers for Redux",
@@ -5,0 +5,0 @@ "main": "lib/redux-collector.js",

README.md

@@ -469,6 +469,133 @@ # Redux Collector [![Build Status](https://travis-ci.org/gtg092x/redux-collector.svg?branch=master)](https://travis-ci.org/gtg092x/redux-collector)
 
+Sort will make an effort to use the lodash method `_.orderBy`. It will incorporate [order](#order) if it exists in your action. Otherwise, it will just do the sorting. 
+
+```js
+function itemReducer(state, action) {
+  // reducer stuff
+}
+
+const myStore = createStore(
+  collectify(
+    [4, 3, 2, 1],
+    {
+      hydrate: 'HYDRATE_ITEMS',
+      sort: 'SORT_ITEMS'
+    }
+  )
+);
+
+
+myStore.dispatch({
+    type: 'SORT_ITEMS'
+});
+
+// state is [1, 2, 3, 4]
+
+myStore.dispatch({
+    type: 'HYDRATE_ITEMS',
+    [{num: 2}, {num: 3}, {num: 1}]
+});
+
+myStore.dispatch({
+    type: 'SORT_ITEMS',
+    sort: 'num'
+});
+
+// state is [{num: 1}, {num: 2}, {num: 3}]
+
+myStore.dispatch({
+    type: 'SORT_ITEMS',
+    sort: item => item.num
+});
+
+// Same as above
+
+myStore.dispatch({
+    type: 'SORT_ITEMS',
+    sort: () => Math.random()
+});
+
+// state is randomized
+
+// we'll also make an effort to infer order arguments
+
+myStore.dispatch({
+    type: 'SORT_ITEMS',
+    sort: {num: -1}
+});
+
+// state is [{num: 3}, {num: 2}, {num: 1}]
+```
+
 #### Move
 
+Move uses a `from` and a `to` argument to take an item or set of items and move them to another location in your array. 
+
+```js
+function itemReducer(state, action) {
+  // reducer stuff
+}
+
+const myStore = createStore(
+  collectify(
+    [4, 3, 2, 1],
+    {      
+      move: 'MOVE_ITEMS'
+    }
+  )
+);
+
+
+myStore.dispatch({
+    type: 'MOVE_ITEMS',
+    from: 0,
+    to: -1
+});
+
+// state is [3, 2, 1, 4]
+
+myStore.dispatch({
+    type: 'MOVE_ITEMS',
+    from: [0, 1],
+    to: -2
+});
+
+// state is [2, 1, 4, 3]
+```
+
+Your `to` argument should always be a single index. Full on movement mapping is a TODO.
+
 #### Swap
 
+Swap relies on an [index argument](#indexes) to get an array of indexes. The most common use case is two indexes, but sending more than one will result in values rotating like a carousel. 
+
+```js
+function itemReducer(state, action) {
+  // reducer stuff
+}
+
+const myStore = createStore(
+  collectify(
+    [4, 3, 2, 1],
+    {      
+      swap: 'SWAP_ITEMS'
+    }
+  )
+);
+
+
+myStore.dispatch({
+    type: 'SWAP_ITEMS',
+    indexes: [0, -1]
+});
+
+// state is [1, 3, 2, 4]
+
+myStore.dispatch({
+    type: 'SWAP_ITEMS',
+    range: [0, 2]
+});
+
+// state is [2, 1, 3, 4]
+
 ### Queries
@@ -475,0 +602,0 @@

test/collector.js

@@ -256,2 +256,3 @@ import collectify from '../src/redux-collector';
       assert.deepEqual(toSort.slice(0).reverse(), newArr);
+
     });
@@ -258,0 +259,0 @@

New alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Fixed alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Improved metrics

Total package byte prevSize

229495

increased by2.43%

Lines of code

1906

increased by0.05%

Number of lines in readme file

636

increased by24.95%

No dependency changes