@adriansteffan/reactive 0.0.27 → 0.0.29

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);
     };
   }
 }

package/src/utils/bytecode.ts

@@ -1,178 +1,209 @@
 export type Store = Record<string, any>;
 
 type BaseTrialData = {
-    index: number;
-    trialNumber: number;
-    start: number;
-    end: number;
-    duration: number;
+  index: number;
+  trialNumber: number;
+  start: number;
+  end: number;
+  duration: number;
 };
 
 export type ComponentResultData = BaseTrialData & {
-    type: string;
-    name: string;
-    responseData?: any;
+  type: string;
+  name: string;
+  responseData?: any;
+  metadata?: Record<string, any>;
 };
 
 export type CanvasResultData = BaseTrialData & {
-    metadata?: Record<string, any>;
-    key: string | null;
-    reactionTime: number | null;
+  metadata?: Record<string, any>;
+  key: string | null;
+  reactionTime: number | null;
 };
 
 export type RefinedTrialData = ComponentResultData | CanvasResultData;
 
-export interface MarkerItem { type: 'MARKER'; id: string; }
+export interface MarkerItem {
+  type: 'MARKER';
+  id: string;
+}
 
 export type ConditionalFunction = (data?: RefinedTrialData[], store?: Store) => boolean;
 
 export type StoreUpdateFunction = (data?: RefinedTrialData[], store?: Store) => Record<string, any>;
 
-export interface IfGotoItem { type: 'IF_GOTO'; cond: ConditionalFunction; marker: string; }
-export interface UpdateStoreItem { type: 'UPDATE_STORE'; fun: StoreUpdateFunction; }
-export interface IfBlockItem { type: 'IF_BLOCK'; cond: ConditionalFunction; timeline: TimelineItem[]; }
-export interface WhileBlockItem { type: 'WHILE_BLOCK'; cond: ConditionalFunction; timeline: TimelineItem[]; }
-export type ControlFlowItem = MarkerItem | IfGotoItem | UpdateStoreItem | IfBlockItem | WhileBlockItem;
+export interface IfGotoItem {
+  type: 'IF_GOTO';
+  cond: ConditionalFunction;
+  marker: string;
+}
+export interface UpdateStoreItem {
+  type: 'UPDATE_STORE';
+  fun: StoreUpdateFunction;
+}
+export interface IfBlockItem {
+  type: 'IF_BLOCK';
+  cond: ConditionalFunction;
+  timeline: TimelineItem[];
+}
+export interface WhileBlockItem {
+  type: 'WHILE_BLOCK';
+  cond: ConditionalFunction;
+  timeline: TimelineItem[];
+}
+export type ControlFlowItem =
+  | MarkerItem
+  | IfGotoItem
+  | UpdateStoreItem
+  | IfBlockItem
+  | WhileBlockItem;
 export type TimelineItem = ControlFlowItem | any;
 
-export interface ExecuteContentInstruction { type: 'ExecuteContent'; content: any; }
+export interface ExecuteContentInstruction {
+  type: 'ExecuteContent';
+  content: any;
+}
 export interface IfGotoInstruction {
-    type: 'IfGoto';
-    cond: (store: Store, data: RefinedTrialData[]) => boolean;
-    marker: string;
+  type: 'IfGoto';
+  cond: (store: Store, data: RefinedTrialData[]) => boolean;
+  marker: string;
 }
 export interface UpdateStoreInstruction {
-    type: 'UpdateStore';
-    fun: (store: Store, data: RefinedTrialData[]) => Store;
+  type: 'UpdateStore';
+  fun: (store: Store, data: RefinedTrialData[]) => Store;
 }
-export type UnifiedBytecodeInstruction = ExecuteContentInstruction | IfGotoInstruction | UpdateStoreInstruction;
+export type UnifiedBytecodeInstruction =
+  | ExecuteContentInstruction
+  | IfGotoInstruction
+  | UpdateStoreInstruction;
 
 function prefixUserMarkers(marker: string): string {
-    return `user_${marker}`;
+  return `user_${marker}`;
 }
 
-export function compileTimeline(
-    timeline: TimelineItem[]
-): {
-    instructions: UnifiedBytecodeInstruction[];
-    markers: { [key: string]: number };
+export function compileTimeline(timeline: TimelineItem[]): {
+  instructions: UnifiedBytecodeInstruction[];
+  markers: { [key: string]: number };
 } {
-    const instructions: UnifiedBytecodeInstruction[] = [];
-    const markers: { [key: string]: number } = {};
-    let uniqueMarkerCounterForThisRun = 0;
-
-    function getUniqueMarker(prefix: string): string {
-        return `${prefix}_auto_${uniqueMarkerCounterForThisRun++}`;
-    }
-
-    function adaptCondition(
-        userCondition: ConditionalFunction
-    ): (store: Store, data: RefinedTrialData[]) => boolean {
-        return (runtimeStore: Store, runtimeData: RefinedTrialData[]): boolean => {
-            return userCondition(runtimeData, runtimeStore);
-        };
-    }
-
-    function adaptUpdate(
-        userUpdateFunction: StoreUpdateFunction
-    ): (store: Store, data: RefinedTrialData[]) => Store {
-        return (runtimeStore: Store, runtimeData: RefinedTrialData[]): Store => {
-            const updates = userUpdateFunction(runtimeData, runtimeStore);
-            if (typeof updates === 'object' && updates !== null) {
-                return {
-                    ...runtimeStore,
-                    ...updates,
-                };
-            } else {
-                console.warn("Store update function did not return an object. Store remains unchanged.", { data: runtimeData, store: runtimeStore });
-                return runtimeStore;
-            }
+  const instructions: UnifiedBytecodeInstruction[] = [];
+  const markers: { [key: string]: number } = {};
+  let uniqueMarkerCounterForThisRun = 0;
+
+  function getUniqueMarker(prefix: string): string {
+    return `${prefix}_auto_${uniqueMarkerCounterForThisRun++}`;
+  }
+
+  function adaptCondition(
+    userCondition: ConditionalFunction,
+  ): (store: Store, data: RefinedTrialData[]) => boolean {
+    return (runtimeStore: Store, runtimeData: RefinedTrialData[]): boolean => {
+      return userCondition(runtimeData, runtimeStore);
+    };
+  }
+
+  function adaptUpdate(
+    userUpdateFunction: StoreUpdateFunction,
+  ): (store: Store, data: RefinedTrialData[]) => Store {
+    return (runtimeStore: Store, runtimeData: RefinedTrialData[]): Store => {
+      const updates = userUpdateFunction(runtimeData, runtimeStore);
+      if (typeof updates === 'object' && updates !== null) {
+        return {
+          ...runtimeStore,
+          ...updates,
         };
-    }
-
-    function processTimeline(items: TimelineItem[]) {
-        for (const item of items) {
-            let isControlFlow = false;
-
-            if (typeof item === 'object' && item !== null && 'type' in item) {
-                const itemType = item.type;
-
-                switch (itemType) {
-                    case 'MARKER': {
-                        const markerItem = item as MarkerItem;
-                        markers[prefixUserMarkers(markerItem.id)] = instructions.length;
-                        isControlFlow = true;
-                        break;
-                    }
-                    case 'IF_GOTO': {
-                        const ifGotoItem = item as IfGotoItem;
-                        const runtimeConditionFunc = adaptCondition(ifGotoItem.cond);
-                        instructions.push({
-                            type: 'IfGoto',
-                            cond: runtimeConditionFunc,
-                            marker: prefixUserMarkers(ifGotoItem.marker),
-                        });
-                        isControlFlow = true;
-                        break;
-                    }
-                    case 'UPDATE_STORE': {
-                        const updateStoreItem = item as UpdateStoreItem;
-                        const runtimeUpdateFunc = adaptUpdate(updateStoreItem.fun);
-                        instructions.push({
-                            type: 'UpdateStore',
-                            fun: runtimeUpdateFunc,
-                        });
-                        isControlFlow = true;
-                        break;
-                    }
-                    case 'IF_BLOCK': {
-                        const ifBlockItem = item as IfBlockItem;
-                        const endMarker = getUniqueMarker('if_end');
-                        const runtimeConditionFunc = adaptCondition(ifBlockItem.cond);
-                        instructions.push({
-                            type: 'IfGoto',
-                            cond: (store, data) => !runtimeConditionFunc(store, data),
-                            marker: endMarker,
-                        });
-                        processTimeline(ifBlockItem.timeline);
-                        markers[endMarker] = instructions.length;
-                        isControlFlow = true;
-                        break;
-                    }
-                    case 'WHILE_BLOCK': {
-                        const whileBlockItem = item as WhileBlockItem;
-                        const startMarker = getUniqueMarker('while_start');
-                        const endMarker = getUniqueMarker('while_end');
-                        const runtimeConditionFunc = adaptCondition(whileBlockItem.cond);
-                        markers[startMarker] = instructions.length;
-                        instructions.push({
-                            type: 'IfGoto',
-                            cond: (store, data) => !runtimeConditionFunc(store, data),
-                            marker: endMarker,
-                        });
-                        processTimeline(whileBlockItem.timeline);
-                        instructions.push({
-                            type: 'IfGoto',
-                            cond: () => true,
-                            marker: startMarker,
-                        });
-                        markers[endMarker] = instructions.length;
-                        isControlFlow = true;
-                        break;
-                    }
-                }
-            }
-
-            if (!isControlFlow) {
-                instructions.push({
-                    type: 'ExecuteContent',
-                    content: item,
-                });
-            }
+      } else {
+        console.warn('Store update function did not return an object. Store remains unchanged.', {
+          data: runtimeData,
+          store: runtimeStore,
+        });
+        return runtimeStore;
+      }
+    };
+  }
+
+  function processTimeline(items: TimelineItem[]) {
+    for (const item of items) {
+      let isControlFlow = false;
+
+      if (typeof item === 'object' && item !== null && 'type' in item) {
+        const itemType = item.type;
+
+        switch (itemType) {
+          case 'MARKER': {
+            const markerItem = item as MarkerItem;
+            markers[prefixUserMarkers(markerItem.id)] = instructions.length;
+            isControlFlow = true;
+            break;
+          }
+          case 'IF_GOTO': {
+            const ifGotoItem = item as IfGotoItem;
+            const runtimeConditionFunc = adaptCondition(ifGotoItem.cond);
+            instructions.push({
+              type: 'IfGoto',
+              cond: runtimeConditionFunc,
+              marker: prefixUserMarkers(ifGotoItem.marker),
+            });
+            isControlFlow = true;
+            break;
+          }
+          case 'UPDATE_STORE': {
+            const updateStoreItem = item as UpdateStoreItem;
+            const runtimeUpdateFunc = adaptUpdate(updateStoreItem.fun);
+            instructions.push({
+              type: 'UpdateStore',
+              fun: runtimeUpdateFunc,
+            });
+            isControlFlow = true;
+            break;
+          }
+          case 'IF_BLOCK': {
+            const ifBlockItem = item as IfBlockItem;
+            const endMarker = getUniqueMarker('if_end');
+            const runtimeConditionFunc = adaptCondition(ifBlockItem.cond);
+            instructions.push({
+              type: 'IfGoto',
+              cond: (store, data) => !runtimeConditionFunc(store, data),
+              marker: endMarker,
+            });
+            processTimeline(ifBlockItem.timeline);
+            markers[endMarker] = instructions.length;
+            isControlFlow = true;
+            break;
+          }
+          case 'WHILE_BLOCK': {
+            const whileBlockItem = item as WhileBlockItem;
+            const startMarker = getUniqueMarker('while_start');
+            const endMarker = getUniqueMarker('while_end');
+            const runtimeConditionFunc = adaptCondition(whileBlockItem.cond);
+            markers[startMarker] = instructions.length;
+            instructions.push({
+              type: 'IfGoto',
+              cond: (store, data) => !runtimeConditionFunc(store, data),
+              marker: endMarker,
+            });
+            processTimeline(whileBlockItem.timeline);
+            instructions.push({
+              type: 'IfGoto',
+              cond: () => true,
+              marker: startMarker,
+            });
+            markers[endMarker] = instructions.length;
+            isControlFlow = true;
+            break;
+          }
         }
+      }
+
+      if (!isControlFlow) {
+        instructions.push({
+          type: 'ExecuteContent',
+          content: item,
+        });
+      }
     }
+  }
 
-    processTimeline(timeline);
+  processTimeline(timeline);
 
-    return { instructions, markers };
-}
+  return { instructions, markers };
+}