remove default export

Author: georapbox

CHAGELOG.md

@@ -1,5 +1,26 @@
 # CHANGELOG
 
+## v4.0.0
+
+### BREAKING CHANGES
+
+Remove default export in favor of named exports.
+
+The following is **NOT** working aymore:
+```js
+import immutableArrays from 'immutable-arrays';
+```
+
+Import the method you want to use instead:
+```js
+import { push } from 'immutable-arrays';
+```
+
+### OTHER CHANGES
+
+- Fix missing build file path for UMD bundling in rollup configuration file
+- Update `devDependencies`
+
 ## v3.0.1
 
 - Fixes issue #8

README.md

@@ -31,29 +31,25 @@ The library is exported in the following formats:
 <script src="immutable-arrays/dist/immutable-arrays.umd.min.js"></script>
 ```
 
-### Node.js
-
 ```js
-const immutableArrays = require('immutable-arrays');
+const push = immutableArrays.push;
 ```
 
-### ES2015 imports
-
-#### Import default export
+### Node.js
 
 ```js
-import immutableArrays from 'immutable-arrays';
+const push = require('immutable-arrays').push;
 ```
 
-#### Import a named export
+### ES2015 imports
 
 ```js
 import { push } from 'immutable-arrays';
 ```
 
 ## API
 
-### immutableArrays.push(array, ...elementN) ⇒ <code>Array</code>
+### push(array, ...elementN) ⇒ <code>Array</code>
 Adds one or more elements to the end of an array by returning
 a new array instead of mutating the original one.
 
@@ -67,12 +63,12 @@ a new array instead of mutating the original one.
 **Example**  
 ```js
 const originalArray = ['a', 'b', 'c', 'd', 'e'];
-const resultArray = immutableArrays.push(originalArray, 'f', 'g');
+const resultArray = push(originalArray, 'f', 'g');
 // -> originalArray ['a', 'b', 'c', 'd', 'e']
 // -> resultArray ['a', 'b', 'c', 'd', 'e', 'f', 'g']
 ```
 
-### immutableArrays.pop(array) ⇒ <code>Array</code>
+### pop(array) ⇒ <code>Array</code>
 Removes the last element from an array by returning
 a new array instead of mutating the original one.
 
@@ -85,12 +81,12 @@ a new array instead of mutating the original one.
 **Example**  
 ```js
 const originalArray = ['a', 'b', 'c', 'd', 'e'];
-const resultArray = immutableArrays.pop(originalArray);
+const resultArray = pop(originalArray);
 // -> originalArray ['a', 'b', 'c', 'd', 'e']
 // -> resultArray ['a', 'b', 'c', 'd']
 ```
 
-### immutableArrays.shift(array) ⇒ <code>Array</code>
+### shift(array) ⇒ <code>Array</code>
 Removes the first element from an array.
 
 **Returns**: <code>Array</code> - A new array with the first element removed.  
@@ -102,12 +98,12 @@ Removes the first element from an array.
 **Example**  
 ```js
 const originalArray = ['a', 'b', 'c', 'd', 'e'];
-const resultArray = immutableArrays.shift(originalArray);
+const resultArray = shift(originalArray);
 // -> originalArray ['a', 'b', 'c', 'd', 'e']
 // -> resultArray ['b', 'c', 'd', 'e']
 ```
 
-### immutableArrays.unshift(array, ...elementN) ⇒ <code>Array</code>
+### unshift(array, ...elementN) ⇒ <code>Array</code>
 Adds one or more elements to the beginning of an array.
 
 **Returns**: <code>Array</code> - A new array with the new elements added to the front.  
@@ -120,12 +116,12 @@ Adds one or more elements to the beginning of an array.
 **Example**  
 ```js
 const originalArray = ['a', 'b', 'c', 'd', 'e'];
-const resultArray = immutableArrays.unshift(originalArray, 'f', 'g');
+const resultArray = unshift(originalArray, 'f', 'g');
 // -> originalArray ['a', 'b', 'c', 'd', 'e']
 // -> resultArray ['f', 'g', 'a', 'b', 'c', 'd', 'e']
 ```
 
-### immutableArrays.reverse(array) ⇒ <code>Array</code>
+### reverse(array) ⇒ <code>Array</code>
 Reverses an array (not in place).
 The first array element becomes the last, and the last array element becomes the first.
 
@@ -138,12 +134,12 @@ The first array element becomes the last, and the last array element becomes the
 **Example**  
 ```js
 const originalArray = ['a', 'b', 'c', 'd', 'e'];
-const resultArray = immutableArrays.reverse(originalArray);
+const resultArray = reverse(originalArray);
 // -> originalArray ['a', 'b', 'c', 'd', 'e']
 // -> resultArray ['e', 'd', 'c', 'b', 'a']
 ```
 
-### immutableArrays.sort(array, [compareFunction]) ⇒ <code>Array</code>
+### sort(array, [compareFunction]) ⇒ <code>Array</code>
 Sorts the elements of an array (not in place) and returns a sorted array.
 
 **Returns**: <code>Array</code> - A new sorted array.
@@ -158,24 +154,24 @@ Sorts the elements of an array (not in place) and returns a sorted array.
 const numberArray = [20, 3, 4, 10, -3, 1, 0, 5];
 const stringArray = ['Blue', 'Humpback', 'Beluga'];
 
-const resultArray = immutableArrays.sort(numberArray, (a, b) => a - b);
+const resultArray = sort(numberArray, (a, b) => a - b);
 // -> numberArray [20, 3, 4, 10, -3, 1, 0, 5]
 // -> resultArray [-3, 0, 1, 3, 4, 5, 10, 20]
 
-const resultArray = immutableArrays.sort(numberArray, (a, b) => b - a);
+const resultArray = sort(numberArray, (a, b) => b - a);
 // -> numberArray [20, 3, 4, 10, -3, 1, 0, 5]
 // -> resultArray [20, 10, 5, 4, 3, 1, 0, -3]
 
-const resultArray = immutableArrays.sort(stringArray);
+const resultArray = sort(stringArray);
 // -> stringArray ['Blue', 'Humpback', 'Beluga']
 // -> resultArray ['Beluga', 'Blue', 'Humpback']
 
-const resultArray = immutableArrays.sort(stringArray, (a, b) => a.toLowerCase() < b.toLowerCase());
+const resultArray = sort(stringArray, (a, b) => a.toLowerCase() < b.toLowerCase());
 // -> stringArray ['Blue', 'Humpback', 'Beluga']
 // -> resultArray ['Humpback', 'Blue', 'Beluga']
 ```
 
-### immutableArrays.splice(array, [start], [deleteCount], [...elementN]) ⇒ <code>Array</code>
+### splice(array, [start], [deleteCount], [...elementN]) ⇒ <code>Array</code>
 Removes existing elements and/or adds new elements to an array.
 
 **Returns**: <code>Array</code> - The result array.  
@@ -190,52 +186,52 @@ Removes existing elements and/or adds new elements to an array.
 **Example**  
 ```js
 const originalArray = ['a', 'b', 'c', 'd', 'e'];
-const resultArray = immutableArrays.splice(originalArray, 0);
+const resultArray = splice(originalArray, 0);
 // -> originalArray ['a', 'b', 'c', 'd', 'e']
 // -> resultArray []
 
 const originalArray = ['a', 'b', 'c', 'd', 'e'];
-const resultArray = immutableArrays.splice(originalArray, 0, 1);
+const resultArray = splice(originalArray, 0, 1);
 // -> originalArray ['a', 'b', 'c', 'd', 'e']
 // -> resultArray ['b', 'c', 'd', 'e']
 
 const originalArray = ['a', 'b', 'c', 'd', 'e'];
-const resultArray = immutableArrays.splice(originalArray, 0, 3);
+const resultArray = splice(originalArray, 0, 3);
 // -> originalArray ['a', 'b', 'c', 'd', 'e']
 // -> resultArray ['d', 'e']
 
 const originalArray = ['a', 'b', 'c', 'd', 'e'];
-const resultArray = immutableArrays.splice(originalArray, 0, originalArray.length);
+const resultArray = splice(originalArray, 0, originalArray.length);
 // -> originalArray ['a', 'b', 'c', 'd', 'e']
 // -> resultArray []
 
 const originalArray = ['a', 'b', 'c', 'd', 'e'];
-const resultArray = immutableArrays.splice(originalArray, 0, -3);
+const resultArray = splice(originalArray, 0, -3);
 // -> originalArray ['a', 'b', 'c', 'd', 'e']
 // -> resultArray ['a', 'b', 'c', 'd', 'e']
 
 const originalArray = ['a', 'b', 'c', 'd', 'e'];
-const resultArray = immutableArrays.splice(originalArray, 0, 0, 'lorem', 'ipsum');
+const resultArray = splice(originalArray, 0, 0, 'lorem', 'ipsum');
 // -> originalArray ['a', 'b', 'c', 'd', 'e']
 // -> resultArray ['lorem', 'ipsum', 'a', 'b', 'c', 'd', 'e']
 
 const originalArray = ['a', 'b', 'c', 'd', 'e'];
-const resultArray = immutableArrays.splice(originalArray, originalArray.length, 0, 'lorem', 'ipsum');
+const resultArray = splice(originalArray, originalArray.length, 0, 'lorem', 'ipsum');
 // -> originalArray ['a', 'b', 'c', 'd', 'e']
 // -> resultArray ['a', 'b', 'c', 'd', 'e', 'lorem', 'ipsum']
 
 const originalArray = ['a', 'b', 'c', 'd', 'e'];
-const resultArray = immutableArrays.splice(originalArray, 0, 2, 'lorem', 'ipsum');
+const resultArray = splice(originalArray, 0, 2, 'lorem', 'ipsum');
 // -> originalArray ['a', 'b', 'c', 'd', 'e']
 // -> resultArray ['lorem', 'ipsum', 'c', 'd', 'e']
 
 const originalArray = ['a', 'b', 'c', 'd', 'e'];
-const resultArray = immutableArrays.splice(originalArray, originalArray.length - 2, 2, 'lorem', 'ipsum');
+const resultArray = splice(originalArray, originalArray.length - 2, 2, 'lorem', 'ipsum');
 // -> originalArray ['a', 'b', 'c', 'd', 'e']
 // -> resultArray ['a', 'b', 'c', 'lorem', 'ipsum']
 ```
 
-### immutableArrays.del(array, index) ⇒ <code>Array</code>
+### del(array, index) ⇒ <code>Array</code>
 Deletes an element from an array by its index in the array.
 
 **Returns**: <code>Array</code> - A new array with the element removed.  
@@ -248,11 +244,11 @@ Deletes an element from an array by its index in the array.
 **Example**  
 ```js
 const originalArray = ['a', 'b', 'c', 'd', 'e'];
-const resultArray = immutableArrays.del(originalArray, 2);
+const resultArray = del(originalArray, 2);
 // -> originalArray ['a', 'b', 'c', 'd', 'e']
 // -> resultArray ['a', 'b', 'd', 'e']
 
-const resultArray2 = immutableArrays.del(originalArray, -1);
+const resultArray2 = del(originalArray, -1);
 // -> originalArray ['a', 'b', 'c', 'd', 'e']
 // -> resultArray2 ['a', 'b', 'c', 'd', 'e']
 ```

src/del.js

@@ -7,14 +7,14 @@
  * @example
  *
  * const originalArray = ['a', 'b', 'c', 'd', 'e'];
- * const resultArray = immutableArrays.del(originalArray, 2);
+ * const resultArray = del(originalArray, 2);
  * // -> originalArray ['a', 'b', 'c', 'd', 'e']
  * // -> resultArray ['a', 'b', 'd', 'e']
  *
- * const resultArray2 = immutableArrays.del(originalArray, -1);
+ * const resultArray2 = del(originalArray, -1);
  * // -> originalArray ['a', 'b', 'c', 'd', 'e']
  * // -> resultArray2 ['a', 'b', 'c', 'd', 'e']
  */
-export default function immutableDelete(array, index) {
+export function del(array, index) {
   return index >= 0 ? [...array.slice(0, index), ...array.slice(index + 1)] : [...array];
 }

src/index.js

@@ -1,28 +1,8 @@
-import immutableDelete from './del';
-import immutablePop from './pop';
-import immutablePush from './push';
-import immutableReverse from './reverse';
-import immutableShift from './shift';
-import immutableSort from './sort';
-import immutableSplice from './splice';
-import immutableUnshift from './unshift';
-
-export const del = immutableDelete;
-export const pop = immutablePop;
-export const push = immutablePush;
-export const reverse = immutableReverse;
-export const shift = immutableShift;
-export const sort = immutableSort;
-export const splice = immutableSplice;
-export const unshift = immutableUnshift;
-
-export default {
-  push: immutablePush,
-  pop: immutablePop,
-  shift: immutableShift,
-  unshift: immutableUnshift,
-  splice: immutableSplice,
-  reverse: immutableReverse,
-  sort: immutableSort,
-  del: immutableDelete
-};
+export { del } from './del';
+export { pop } from './pop';
+export { push } from './push';
+export { reverse } from './reverse';
+export { shift } from './shift';
+export { sort } from './sort';
+export { splice } from './splice';
+export { unshift } from './unshift';

src/pop.js

@@ -7,10 +7,10 @@
  * @example
  *
  * const originalArray = ['a', 'b', 'c', 'd', 'e'];
- * const resultArray = immutablePop(originalArray);
+ * const resultArray = pop(originalArray);
  * // -> originalArray ['a', 'b', 'c', 'd', 'e']
  * // -> resultArray ['a', 'b', 'c', 'd']
  */
-export default function immutablePop(array) {
+export function pop(array) {
   return array.slice(0, -1);
 }

src/push.js

@@ -8,10 +8,10 @@
  * @example
  *
  * const originalArray = ['a', 'b', 'c', 'd', 'e'];
- * const resultArray = immutablePush(originalArray, 'f', 'g');
+ * const resultArray = push(originalArray, 'f', 'g');
  * // -> originalArray ['a', 'b', 'c', 'd', 'e']
  * // -> resultArray ['a', 'b', 'c', 'd', 'e', 'f', 'g']
  */
-export default function immutablePush(array, ...elementN) {
+export function push(array, ...elementN) {
   return [...array, ...elementN];
 }

src/reverse.js

@@ -7,10 +7,10 @@
  * @example
  *
  * const originalArray = ['a', 'b', 'c', 'd', 'e'];
- * const resultArray = immutableReverse(originalArray);
+ * const resultArray = reverse(originalArray);
  * // -> originalArray ['a', 'b', 'c', 'd', 'e']
  * // -> resultArray ['e', 'd', 'c', 'b', 'a']
  */
-export default function immutableReverse(array) {
+export function reverse(array) {
   return [...array].reverse();
 }

src/shift.js

@@ -6,10 +6,10 @@
  * @example
  *
  * const originalArray = ['a', 'b', 'c', 'd', 'e'];
- * const resultArray = immutableShift(originalArray);
+ * const resultArray = shift(originalArray);
  * // -> originalArray ['a', 'b', 'c', 'd', 'e']
  * // -> resultArray ['b', 'c', 'd', 'e']
  */
-export default function immutableShift(array) {
+export function shift(array) {
   return array.slice(1);
 }

src/sort.js

@@ -10,22 +10,22 @@
  * const numberArray = [20, 3, 4, 10, -3, 1, 0, 5];
  * const stringArray = ['Blue', 'Humpback', 'Beluga'];
  *
- * const resultArray = immutableSort(numberArray, (a, b) => a - b);
+ * const resultArray = sort(numberArray, (a, b) => a - b);
  * // -> numberArray [20, 3, 4, 10, -3, 1, 0, 5]
  * // -> resultArray [-3, 0, 1, 3, 4, 5, 10, 20]
  *
- * const resultArray = immutableSort(numberArray, (a, b) => b - a);
+ * const resultArray = sort(numberArray, (a, b) => b - a);
  * // -> numberArray [20, 3, 4, 10, -3, 1, 0, 5]
  * // -> resultArray [20, 10, 5, 4, 3, 1, 0, -3]
  *
- * const resultArray = immutableSort(stringArray);
+ * const resultArray = sort(stringArray);
  * // -> stringArray ['Blue', 'Humpback', 'Beluga']
  * // -> resultArray ['Beluga', 'Blue', 'Humpback']
  *
- * const resultArray = immutableSort(stringArray, (a, b) => a.toLowerCase() < b.toLowerCase());
+ * const resultArray = sort(stringArray, (a, b) => a.toLowerCase() < b.toLowerCase());
  * // -> stringArray ['Blue', 'Humpback', 'Beluga']
  * // -> resultArray ['Humpback', 'Blue', 'Beluga']
  */
-export default function immutableSort(array, compareFunction) {
+export function sort(array, compareFunction) {
   return [...array].sort(compareFunction);
 }