@oscarpalmer/atoms 0.160.0 → 0.162.0

package/dist/array/index.js

@@ -5,21 +5,23 @@ import { find } from "./find.js";
 import { flatten } from "./flatten.js";
 import { range, times } from "./from.js";
 import { getArray } from "./get.js";
-import { indexOf } from "./index-of.js";
 import { chunk } from "../internal/array/chunk.js";
 import { compact } from "../internal/array/compact.js";
+import { indexOf } from "../internal/array/index-of.js";
 import { shuffle } from "../internal/array/shuffle.js";
 import { insert } from "./insert.js";
 import { intersection } from "./intersection.js";
-import { partition } from "./partition.js";
 import { endsWithArray, getArrayPosition, includesArray, indexOfArray, startsWithArray } from "./position.js";
+import { move } from "./move.js";
+import { partition } from "./partition.js";
 import { push } from "./push.js";
 import { select } from "./select.js";
 import { drop, slice, take } from "./slice.js";
 import { sort } from "./sort.js";
 import { splice } from "./splice.js";
+import { swap } from "./swap.js";
 import { toSet } from "./to-set.js";
 import { toggle } from "./toggle.js";
 import { union } from "./union.js";
 import { update } from "./update.js";
-export { chunk, compact, difference, drop, endsWithArray, exists, filter, find, flatten, getArray, getArrayPosition, includesArray, indexOf, indexOfArray, insert, intersection, partition, push, range, select, shuffle, slice, sort, splice, startsWithArray, take, times, toSet, toggle, union, update };
+export { chunk, compact, difference, drop, endsWithArray, exists, filter, find, flatten, getArray, getArrayPosition, includesArray, indexOf, indexOfArray, insert, intersection, move, partition, push, range, select, shuffle, slice, sort, splice, startsWithArray, swap, take, times, toSet, toggle, union, update };

package/dist/array/insert.js

@@ -1,7 +1,7 @@
-import { insertValues } from "../internal/array/insert.js";
+import { INSERT_TYPE_INSERT, insertValues } from "../internal/array/insert.js";
 //#region src/array/insert.ts
 function insert(array, indexOrItems, items) {
-	return insertValues("insert", array, items == null ? indexOrItems : items, typeof indexOrItems === "number" ? indexOrItems : array?.length, 0);
+	return insertValues(INSERT_TYPE_INSERT, array, items == null ? indexOrItems : items, typeof indexOrItems === "number" ? indexOrItems : array?.length, 0);
 }
 //#endregion
 export { insert };

package/dist/array/move.js

@@ -0,0 +1,64 @@
+import { arraysOverlap } from "../internal/array/overlap.js";
+import { indexOfArray } from "./position.js";
+//#region src/array/move.ts
+function move(array, from, to, key) {
+	if (!Array.isArray(array)) return [];
+	const firstArray = Array.isArray(from) ? from : [from];
+	const secondArray = Array.isArray(to) ? to : [to];
+	if (firstArray.length === 0 || secondArray.length === 0) return array;
+	const firstPosition = indexOfArray(array, firstArray, key);
+	const secondPosition = indexOfArray(array, secondArray, key);
+	if (firstPosition === -1 || secondPosition === -1 || firstPosition === secondPosition) return array;
+	const { overlap } = arraysOverlap({
+		array: firstArray,
+		index: firstPosition
+	}, {
+		array: secondArray,
+		index: secondPosition
+	});
+	if (overlap) return array;
+	array.splice(firstPosition, firstArray.length);
+	const next = secondPosition < firstPosition ? secondPosition : secondPosition + secondArray.length - firstArray.length;
+	if (next >= array.length) array.push(...firstArray);
+	else array.splice(next, 0, ...firstArray);
+	return array;
+}
+move.indices = moveIndices;
+move.toIndex = moveToIndex;
+/**
+* Move an item from one index to another within an array
+*
+* If the from index is out of bounds, the array will be returned unchanged
+* @param array Array to move within
+* @param from Index to move from
+* @param to Index to move to
+* @returns Original array with item moved _(or unchanged if unable to move)_
+*/
+function moveIndices(array, from, to) {
+	if (!Array.isArray(array)) return [];
+	const { length } = array;
+	if (length === 0 || typeof from !== "number" || typeof to !== "number") return array;
+	const fromIndex = from < 0 ? length + from : from;
+	const toIndex = to < 0 ? length + to : to;
+	if (fromIndex === toIndex || fromIndex >= length || toIndex >= length) return array;
+	const spliced = array.splice(fromIndex, 1);
+	if (toIndex >= array.length) array.push(...spliced);
+	else array.splice(toIndex, 0, ...spliced);
+	return array;
+}
+function moveToIndex(array, value, index, key) {
+	if (!Array.isArray(array)) return [];
+	const { length } = array;
+	if (length === 0 || typeof index !== "number") return array;
+	const next = index < 0 ? length + index : index;
+	if (next >= length) return array;
+	const values = Array.isArray(value) ? value : [value];
+	const position = indexOfArray(array, values, key);
+	if (position === -1 || position === next) return array;
+	array.splice(position, values.length);
+	if (next >= array.length) array.push(...values);
+	else array.splice(next, 0, ...values);
+	return array;
+}
+//#endregion
+export { move };

package/dist/array/push.js

@@ -1,4 +1,4 @@
-import { insertValues } from "../internal/array/insert.js";
+import { INSERT_TYPE_PUSH, insertValues } from "../internal/array/insert.js";
 //#region src/array/push.ts
 /**
 * Push items into an array _(at the end)_
@@ -7,7 +7,7 @@ import { insertValues } from "../internal/array/insert.js";
 * @returns New length of the array
 */
 function push(array, pushed) {
-	return insertValues("push", array, pushed, array.length, 0);
+	return insertValues(INSERT_TYPE_PUSH, array, pushed, array.length, 0);
 }
 //#endregion
 export { push };

package/dist/array/sort.js

@@ -33,7 +33,7 @@ function getSorter(value, modifier) {
 function sort(array, first, second) {
 	if (!Array.isArray(array)) return [];
 	if (array.length < 2) return array;
-	const modifier = (first === true || second === true ? "desc" : "asc") === "asc" ? 1 : -1;
+	const modifier = (first === true || second === true ? "descending" : "ascending") === "ascending" ? 1 : -1;
 	const sorters = (Array.isArray(first) ? first : [first]).map((item) => getSorter(item, modifier)).filter((sorter) => sorter != null).filter((current, index, filtered) => filtered.findIndex((next) => next.identifier === current.identifier) === index);
 	const { length } = sorters;
 	if (length === 0) return array.sort((firstItem, secondItem) => compare(firstItem, secondItem) * modifier);
@@ -58,5 +58,7 @@ function sort(array, first, second) {
 		return 0;
 	});
 }
+var SORT_DIRECTION_ASCENDING = "ascending";
+var SORT_DIRECTION_DESCENDING = "descending";
 //#endregion
-export { sort };
+export { SORT_DIRECTION_ASCENDING, SORT_DIRECTION_DESCENDING, sort };

package/dist/array/splice.js

@@ -1,7 +1,7 @@
-import { insertValues } from "../internal/array/insert.js";
+import { INSERT_TYPE_SPLICE, insertValues } from "../internal/array/insert.js";
 //#region src/array/splice.ts
 function splice(array, start, deleteCountOrItems, items) {
-	return insertValues("splice", array, typeof deleteCountOrItems === "number" ? items : deleteCountOrItems, start, typeof deleteCountOrItems === "number" ? deleteCountOrItems : 0);
+	return insertValues(INSERT_TYPE_SPLICE, array, typeof deleteCountOrItems === "number" ? items : deleteCountOrItems, start, typeof deleteCountOrItems === "number" ? deleteCountOrItems : 0);
 }
 //#endregion
 export { splice };

package/dist/array/swap.js

@@ -0,0 +1,59 @@
+import { getArrayCallback } from "../internal/array/callbacks.js";
+import { indexOf } from "../internal/array/index-of.js";
+import { arraysOverlap } from "../internal/array/overlap.js";
+import { indexOfArray } from "./position.js";
+//#region src/array/swap.ts
+function swap(array, first, second, third) {
+	if (!Array.isArray(array)) return [];
+	if (array.length === 0) return array;
+	if (Array.isArray(first) && Array.isArray(second)) return swapArrays(array, first, second, third);
+	return swapValues(array, first, second, third);
+}
+swap.indices = swapIndices;
+function swapArrays(array, from, to, key) {
+	if (from.length === 0 || to.length === 0) return array;
+	if (from.length === 1 && to.length === 1) return swapValues(array, from[0], to[0], key);
+	const fromIndex = indexOfArray(array, from, key);
+	const toIndex = indexOfArray(array, to, key);
+	if (fromIndex === -1 || toIndex === -1) return array;
+	const { first, second, overlap } = arraysOverlap({
+		array: from,
+		index: fromIndex
+	}, {
+		array: to,
+		index: toIndex
+	});
+	if (overlap) return array;
+	array.splice(first.index, first.array.length, ...second.array);
+	array.splice(second.index + (second.array.length - first.array.length), second.array.length, ...first.array);
+	return array;
+}
+/**
+* Swap two indiced items in an array
+*
+* If either index is out of bounds, the array will be returned unchanged
+* @param array Array of items to swap
+* @param first First index _(can be negative to count from the end)_
+* @param second Second index _(can be negative to count from the end)_
+* @returns Original array with items swapped _(or unchanged if unable to swap)_
+*/
+function swapIndices(array, first, second) {
+	if (!Array.isArray(array) || array.length === 0) return [];
+	if (typeof first !== "number" || typeof second !== "number") return array;
+	const firstIndex = first < 0 ? array.length + first : first;
+	const secondIndex = second < 0 ? array.length + second : second;
+	if (firstIndex === secondIndex || firstIndex >= array.length || secondIndex >= array.length) return array;
+	const temp = array[firstIndex];
+	array[firstIndex] = array[secondIndex];
+	array[secondIndex] = temp;
+	return array;
+}
+function swapValues(array, from, to, key) {
+	const callback = getArrayCallback(key);
+	const first = callback == null ? array.indexOf(from) : indexOf(array, callback, callback(from, void 0, []));
+	const second = callback == null ? array.indexOf(to) : indexOf(array, callback, callback(to, void 0, []));
+	if (first === second || first === -1 || second === -1) return array;
+	return swapIndices(array, first, second);
+}
+//#endregion
+export { swap };