@adriansteffan/reactive 0.0.27 → 0.0.28

package/dist/{web-DOFokKz7.js → web-B_I1xy51.js}

@@ -1,4 +1,4 @@
-import { W as P, b as x, E } from "./mod-CbGhKi2f.js";
+import { W as P, b as x, E } from "./mod-CjZm1Ta9.js";
 function m(w) {
   const e = w.split("/").filter((t) => t !== "."), r = [];
   return e.forEach((t) => {

package/dist/{web-BFGLx41c.js → web-DfpITFBR.js}

@@ -1,4 +1,4 @@
-import { W as e } from "./mod-CbGhKi2f.js";
+import { W as e } from "./mod-CjZm1Ta9.js";
 class s extends e {
   async enable() {
     console.log("Immersive mode is only available on Android");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adriansteffan/reactive",
-  "version": "0.0.27",
+  "version": "0.0.28",
   "type": "module",
   "scripts": {
     "dev": "vite",

package/src/utils/array.ts

@@ -3,46 +3,52 @@ declare global {
     /**
      * Returns random elements from the array
      * @param n Number of random elements to return (defaults to 1)
-     * @returns Array of randomly selected elements
      */
     sample(n?: number): Array<T>;
-
+    
     /**
      * Shuffles array elements using Fisher-Yates algorithm
-     * @returns A new shuffled array
      */
     shuffle(): Array<T>;
+    
+    /**
+     * Applies a function to the array
+     * @param fn Function to apply to the array
+     */
+    pipe<U>(fn: (arr: Array<T>) => U): U;
+    
+    /**
+     * Splits array into chunks
+     * @param n Number of chunks to create
+     */
+    chunk(n: number): Array<Array<T>>;
   }
 }
 
 /**
  * Returns random elements from an array
- * @param array The source array
- * @param n Number of random elements to return (defaults to 1)
- * @returns Array of randomly selected elements
  */
 export function sample<T>(array: T[], n: number = 1): T[] {
   const result: T[] = [];
-
+  
   if (array.length === 0) {
     return result;
   }
-
+  
   for (let i = 0; i < n; i++) {
     const randomIndex = Math.floor(Math.random() * array.length);
     result.push(array[randomIndex]);
   }
-
+  
   return result;
 }
 
 /**
  * Shuffles array elements using Fisher-Yates algorithm
- * @param array The source array
- * @returns A new shuffled array
  */
 export function shuffle<T>(array: T[]): T[] {
-  const result = [...array]; 
+  const result = [...array];
+  
   for (let i = result.length - 1; i >= 0; i--) {
     const j = Math.floor(Math.random() * (i + 1));
     [result[i], result[j]] = [result[j], result[i]];
@@ -50,6 +56,23 @@ export function shuffle<T>(array: T[]): T[] {
   return result;
 }
 
+/**
+ * Applies a function to an array
+ */
+export function pipe<T, U>(array: T[], fn: (arr: T[]) => U): U {
+  return fn(array);
+}
+
+/**
+ * Splits array into chunks
+ */
+export function chunk<T>(array: T[], n: number): T[][] {
+  const size = Math.ceil(array.length / n);
+  return Array.from({ length: Math.ceil(array.length / size) }, (_, i) =>
+    array.slice(i * size, i * size + size),
+  );
+}
+
 /**
  * Registers array methods on the Array prototype.
  * Call this function once to make array methods available globally.
@@ -59,7 +82,6 @@ export function shuffle<T>(array: T[]): T[] {
  * import { registerArrayExtensions } from '@adriansteffan/reactive/array';
  * registerArrayExtensions();
  * 
- * // Now you can use the methods
  * const myArray = [1, 2, 3, 4, 5];
  * myArray.shuffle();
  * ```
@@ -70,10 +92,22 @@ export function registerArrayExtensions(): void {
       return sample(this, n);
     };
   }
-
+  
   if (typeof Array.prototype.shuffle !== 'function') {
     Array.prototype.shuffle = function <T>(this: T[]): T[] {
-      return shuffle(this); 
+      return shuffle(this);
+    };
+  }
+  
+  if (typeof Array.prototype.pipe !== 'function') {
+    Array.prototype.pipe = function <T, U>(this: T[], fn: (arr: T[]) => U): U {
+      return pipe(this, fn);
+    };
+  }
+  
+  if (typeof Array.prototype.chunk !== 'function') {
+    Array.prototype.chunk = function <T>(this: T[], n: number): T[][] {
+      return chunk(this, n);
     };
   }
 }