@adriansteffan/reactive 0.0.26 → 0.0.27

package/dist/mod.d.ts

@@ -1,14 +1,56 @@
 import { ComponentType } from 'react';
+import { default as default_2 } from 'react';
 import { JSX as JSX_2 } from 'react/jsx-runtime';
 import { ReactNode } from 'react';
 
 export declare interface BaseComponentProps {
-    next: (data: object) => void;
+    next: (data?: object, actualStartTime?: number, actualStopTime?: number) => void;
     data: TrialData[];
     store?: Store;
     updateStore: (mergeIn: Store) => void;
 }
 
+declare type BaseTrialData = {
+    index: number;
+    trialNumber: number;
+    start: number;
+    end: number;
+    duration: number;
+};
+
+export declare function CanvasBlock({ next, updateStore, timeline, width, height, store, styleCanvas, initCanvas, }: CanvasBlockProps): JSX_2.Element;
+
+declare type CanvasBlockProps = {
+    timeline: TimelineItem[];
+    width?: number | string;
+    height?: number | string;
+    styleCanvas?: (ctx: CanvasRenderingContext2D, width: number, height: number) => void;
+    initCanvas?: (ctx: CanvasRenderingContext2D, width: number, height: number) => void;
+} & BaseComponentProps;
+
+export declare function canvasCountdown(seconds: number): {
+    draw: (ctx: CanvasRenderingContext2D, w: number, h: number) => void;
+    displayDuration: number;
+    ignoreData: boolean;
+}[];
+
+declare type CanvasResultData = BaseTrialData & {
+    metadata?: Record<string, any>;
+    key: string | null;
+    reactionTime: number | null;
+};
+
+export declare function CheckDevice({ check, content, data, store, updateStore, next, }: {
+    check: (deviceInfo: DeviceInfo, data: any, store: any) => boolean;
+    content?: React.ReactNode;
+} & BaseComponentProps): JSX_2.Element | null;
+
+declare type ComponentResultData = BaseTrialData & {
+    type: string;
+    name: string;
+    responseData?: any;
+};
+
 declare type ComponentsMap = {
     [key: string]: ComponentType<any>;
 };
@@ -17,63 +59,86 @@ declare type ComponentsMap_2 = {
     [key: string]: ComponentType<any>;
 };
 
-declare interface ComponentTrial {
-    name: string;
-    type: string;
-    props?: Record<string, any> | ((store: Store, data: TrialData[]) => Record<string, any>);
+declare type ConditionalFunction = (data?: RefinedTrialData[], store?: Store_2) => boolean;
+
+declare type ControlFlowItem = MarkerItem | IfGotoItem | UpdateStoreItem | IfBlockItem | WhileBlockItem;
+
+declare type CSVBuilder = {
+    filename?: string;
+    trials?: string[];
+    fun?: (row: Record<string, any>) => Record<string, any>;
+};
+
+declare interface DeviceInfo {
+    windowWidth: number;
+    windowHeight: number;
+    screenWidth: number;
+    screenHeight: number;
+    browser: string;
+    browserVersion: string;
+    isMobile: boolean;
+    operatingSystem: string;
+    hasWebAudio: boolean;
+    hasFullscreen: boolean;
+    hasWebcam: boolean;
+    hasMicrophone: boolean;
 }
 
-export declare function EnterFullscreen({ content, buttonText, next, }: {
+export declare function EnterFullscreen({ content, buttonText, next, data, updateStore, delayMs, }: {
     prolificCode?: string;
-    content?: React.ReactNode;
+    content?: default_2.ReactNode;
     buttonText?: string;
-} & BaseComponentProps): JSX_2.Element;
+    delayMs?: number;
+} & BaseComponentProps): JSX_2.Element | null;
 
-export declare function ExitFullscreen({ next }: BaseComponentProps): JSX_2.Element;
-
-export declare function Experiment({ timeline, config, components, questions, }: {
-    timeline: ExperimentTrial[];
-    config?: ExperimentConfig;
-    components?: ComponentsMap_2;
-    questions?: ComponentsMap_2;
-}): JSX_2.Element;
+export declare function ExitFullscreen({ next, delayMs, }: {
+    delayMs?: number;
+} & BaseComponentProps): null;
 
 export declare interface ExperimentConfig {
     showProgressBar: boolean;
 }
 
-export declare function ExperimentProvider({ children }: {
+export declare function ExperimentProvider({ children, disableSettings }: {
     children: ReactNode;
+    disableSettings?: boolean;
 }): JSX_2.Element;
 
-declare type ExperimentTrial = MarkerTrial | IfGotoTrial | UpdateStoreTrial | IfBlockTrial | WhileBlockTrial | ComponentTrial;
+export declare function ExperimentRunner({ timeline, config, components, questions, }: {
+    timeline: TimelineItem[];
+    config?: ExperimentConfig;
+    components?: ComponentsMap_2;
+    questions?: ComponentsMap_2;
+}): JSX_2.Element;
 
 export declare interface FileUpload {
     filename: string;
     content: string;
-    encoding: 'base64' | 'utf8';
+    encoding?: 'base64' | 'utf8';
 }
 
-export declare function getParam<T extends ParamType>(name: string, defaultValue: ParamValue<T> | undefined, type?: T): ParamValue<T> | undefined;
+export declare function getParam<T extends ParamType>(name: string, defaultValue: ParamValue<T>, type?: T, description?: string): ParamValue<T>;
 
 export declare const getPlatform: () => Platform;
 
-declare interface IfBlockTrial {
-    type: 'IF_BLOCK' | string;
-    cond: (store: Store, data: TrialData[]) => boolean;
-    timeline: ExperimentTrial[];
+declare interface IfBlockItem {
+    type: 'IF_BLOCK';
+    cond: ConditionalFunction;
+    timeline: TimelineItem[];
 }
 
-declare interface IfGotoTrial {
-    type: 'IF_GOTO' | string;
-    cond: (store: Store, data: TrialData[]) => boolean;
+declare interface IfGotoItem {
+    type: 'IF_GOTO';
+    cond: ConditionalFunction;
     marker: string;
 }
 
 export declare function isDesktop(): boolean;
 
-declare interface MarkerTrial {
-    type: 'MARKER' | string;
+export declare function isFullscreen(): boolean;
+
+declare interface MarkerItem {
+    type: 'MARKER';
     id: string;
 }
 
@@ -83,12 +148,19 @@ export declare const MicCheck: ({ next }: {
 
 export declare function now(): number;
 
+export declare class Param {
+    static getRegistry(): any[];
+    static getTimelineRepresentation(): {
+        type: string;
+        name?: string;
+    }[];
+}
+
 declare type ParamType = 'string' | 'number' | 'boolean' | 'array' | 'json';
 
-declare type ParamValue<T extends ParamType> = T extends 'number' ? number | undefined : T extends 'boolean' ? boolean | undefined : T extends 'array' | 'json' ? any | undefined : string | undefined;
+declare type ParamValue<T extends ParamType> = T extends 'number' ? number : T extends 'boolean' ? boolean : T extends 'array' | 'json' ? any : string;
 
-export declare function PlainInput({ content, buttonText, className, next, updateStore, animate, storeupdate, // user defined function
-    placeholder, }: BaseComponentProps & {
+export declare function PlainInput({ content, buttonText, className, next, updateStore, animate, storeupdate, placeholder, }: BaseComponentProps & {
     content: React.ReactNode;
     buttonText?: string;
     onButtonClick?: () => void;
@@ -102,62 +174,128 @@ export declare function PlainInput({ content, buttonText, className, next, updat
 
 export declare type Platform = 'desktop' | 'mobile' | 'web';
 
-export declare function ProlificEnding({ prolificCode, }: {
+export declare function ProlificEnding({ prolificCode, data, updateStore }: {
     prolificCode?: string;
 } & BaseComponentProps): JSX_2.Element;
 
-export declare function Quest({ next, surveyJson, customQuestions }: {
+export declare function Quest({ next, surveyJson, customQuestions, }: {
     next: (data: object) => void;
     surveyJson: object;
     customQuestions?: ComponentsMap;
 }): JSX_2.Element;
 
-export declare function RequestFilePermission({ next }: BaseComponentProps): JSX_2.Element;
+declare type RefinedTrialData = ComponentResultData | CanvasResultData;
+
+/**
+ * Registers array methods on the Array prototype.
+ * Call this function once to make array methods available globally.
+ *
+ * Example:
+ * ```
+ * import { registerArrayExtensions } from '@adriansteffan/reactive/array';
+ * registerArrayExtensions();
+ *
+ * // Now you can use the methods
+ * const myArray = [1, 2, 3, 4, 5];
+ * myArray.shuffle();
+ * ```
+ */
+export declare function registerArrayExtensions(): void;
+
+export declare function registerComponentParams(type: string, params: {
+    name: string;
+    defaultValue: any;
+    type: string;
+    description?: string;
+}[]): void;
+
+export declare function registerExperimentParams(experiment: any[]): void;
 
-export declare function shuffle(array: any[]): any[];
+export declare function RequestFilePermission({ next }: BaseComponentProps): JSX_2.Element | null;
+
+/**
+ * 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 declare function sample<T>(array: T[], n?: number): T[];
+
+/**
+ * Shuffles array elements using Fisher-Yates algorithm
+ * @param array The source array
+ * @returns A new shuffled array
+ */
+export declare function shuffle<T>(array: T[]): T[];
 
 export declare interface Store {
     [key: string]: any;
 }
 
-declare function Text_2({ content, buttonText, className, next, animate, }: {
-    content: React.ReactNode;
+declare type Store_2 = Record<string, any>;
+
+declare type StoreUpdateFunction = (data?: RefinedTrialData[], store?: Store_2) => Record<string, any>;
+
+export declare function subsetExperimentByParam(experiment: any[]): any[];
+
+declare function Text_2({ content, buttonText, className, next, animate, allowedKeys, }: {
+    content: default_2.ReactNode;
     buttonText?: string;
     onButtonClick?: () => void;
     className?: string;
-    next: (newData: object) => void;
     animate?: boolean;
-}): JSX_2.Element;
+    allowedKeys?: string[] | boolean;
+} & BaseComponentProps): JSX_2.Element;
 export { Text_2 as Text }
 
+declare type TimelineItem = ControlFlowItem | any;
+
 export declare interface TrialData {
     index: number;
     trialNumber: number;
     type: string;
     name: string;
-    data: any;
+    responseData: any;
     start: number;
     end: number;
     duration: number;
 }
 
-declare interface UpdateStoreTrial {
-    type: 'UPDATE_STORE' | string;
-    fun: (store: Store, data: TrialData[]) => Store;
+declare interface UpdateStoreItem {
+    type: 'UPDATE_STORE';
+    fun: StoreUpdateFunction;
 }
 
-export declare function Upload({ data, next, store, sessionID, generateFiles, uploadRaw, autoUpload, androidFolderName, }: BaseComponentProps & {
+export declare function Upload({ data, next, store, sessionID, generateFiles, sessionCSVBuilder, trialCSVBuilders, uploadRaw, autoUpload, androidFolderName, }: BaseComponentProps & {
     sessionID?: string | null;
     generateFiles: (sessionID: string, data: TrialData[], store?: Store) => FileUpload[];
+    sessionCSVBuilder: CSVBuilder;
+    trialCSVBuilders: CSVBuilder[];
     uploadRaw: boolean;
     autoUpload: boolean;
     androidFolderName?: string;
 }): JSX_2.Element;
 
-declare interface WhileBlockTrial {
-    type: 'WHILE_BLOCK' | string;
-    cond: (store: Store, data: TrialData[]) => boolean;
-    timeline: ExperimentTrial[];
+declare interface WhileBlockItem {
+    type: 'WHILE_BLOCK';
+    cond: ConditionalFunction;
+    timeline: TimelineItem[];
 }
 
 export { }
+
+declare global {
+    interface Array<T> {
+        /**
+         * 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>;
+    }
+}

package/dist/reactive.es.js

@@ -1,19 +1,29 @@
-import { a, c as i, d as r, e as t, M as n, f as l, P as o, Q as P, R as c, T as f, U as m, g as p, h as u, i as x, n as E, s as d } from "./mod-Dqf5zajq.js";
+import { C as e, t as r, m as n, o as t, p as i, q as o, M as l, P as m, k as c, l as p, Q as P, R as u, T as x, U as E, j as g, g as f, d as C, c as d, i as k, n as h, r as v, f as F, e as R, s as q, a as w, h as y } from "./mod-CbGhKi2f.js";
 export {
-  a as EnterFullscreen,
-  i as ExitFullscreen,
-  r as Experiment,
-  t as ExperimentProvider,
-  n as MicCheck,
-  l as PlainInput,
-  o as ProlificEnding,
+  e as CanvasBlock,
+  r as CheckDevice,
+  n as EnterFullscreen,
+  t as ExitFullscreen,
+  i as ExperimentProvider,
+  o as ExperimentRunner,
+  l as MicCheck,
+  m as Param,
+  c as PlainInput,
+  p as ProlificEnding,
   P as Quest,
-  c as RequestFilePermission,
-  f as Text,
-  m as Upload,
-  p as getParam,
-  u as getPlatform,
-  x as isDesktop,
-  E as now,
-  d as shuffle
+  u as RequestFilePermission,
+  x as Text,
+  E as Upload,
+  g as canvasCountdown,
+  f as getParam,
+  C as getPlatform,
+  d as isDesktop,
+  k as isFullscreen,
+  h as now,
+  v as registerArrayExtensions,
+  F as registerComponentParams,
+  R as registerExperimentParams,
+  q as sample,
+  w as shuffle,
+  y as subsetExperimentByParam
 };