@nyuccl/smile 0.2.0-beta.0

package/dist/runtime/components/ui/tooltip/TooltipTrigger.d.vue.ts

@@ -0,0 +1,38 @@
+declare const _default: typeof __VLS_export;
+export default _default;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+type __VLS_WithSlots<T, S> = T & (new () => {
+    $slots: S;
+});
+declare const __VLS_base: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    reference: {
+        type: null;
+        required: false;
+    };
+    asChild: {
+        type: BooleanConstructor;
+        required: false;
+    };
+    as: {
+        type: null;
+        required: false;
+    };
+}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    reference: {
+        type: null;
+        required: false;
+    };
+    asChild: {
+        type: BooleanConstructor;
+        required: false;
+    };
+    as: {
+        type: null;
+        required: false;
+    };
+}>> & Readonly<{}>, {
+    asChild: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+type __VLS_Slots = {
+    default?: ((props: {}) => any) | undefined;
+};

package/dist/runtime/components/ui/tooltip/TooltipTrigger.vue

@@ -0,0 +1,17 @@
+<script setup>
+import { TooltipTrigger } from "reka-ui";
+const props = defineProps({
+  reference: { type: null, required: false },
+  asChild: { type: Boolean, required: false },
+  as: { type: null, required: false }
+});
+</script>
+
+<template>
+  <TooltipTrigger
+    data-slot="tooltip-trigger"
+    v-bind="props"
+  >
+    <slot />
+  </TooltipTrigger>
+</template>

package/dist/runtime/components/ui/tooltip/TooltipTrigger.vue.d.ts

@@ -0,0 +1,38 @@
+declare const _default: typeof __VLS_export;
+export default _default;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+type __VLS_WithSlots<T, S> = T & (new () => {
+    $slots: S;
+});
+declare const __VLS_base: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    reference: {
+        type: null;
+        required: false;
+    };
+    asChild: {
+        type: BooleanConstructor;
+        required: false;
+    };
+    as: {
+        type: null;
+        required: false;
+    };
+}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    reference: {
+        type: null;
+        required: false;
+    };
+    asChild: {
+        type: BooleanConstructor;
+        required: false;
+    };
+    as: {
+        type: null;
+        required: false;
+    };
+}>> & Readonly<{}>, {
+    asChild: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+type __VLS_Slots = {
+    default?: ((props: {}) => any) | undefined;
+};

package/dist/runtime/components/ui/tooltip/index.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/runtime/components/ui/tooltip/index.js

@@ -0,0 +1,4 @@
+export { default as Tooltip } from './Tooltip.vue'
+export { default as TooltipContent } from './TooltipContent.vue'
+export { default as TooltipProvider } from './TooltipProvider.vue'
+export { default as TooltipTrigger } from './TooltipTrigger.vue'

package/dist/runtime/composables/useAPI.d.ts

@@ -0,0 +1,463 @@
+/**
+ * Creates and returns a reactive SmileAPI instance with necessary dependencies
+ * @returns {SmileAPI} A reactive SmileAPI instance with timeline, routing and store functionality
+ */
+export default function useAPI(): SmileAPI;
+/**
+ * SmileAPI class provides core functionality for SMILE experiments
+ * @class
+ * @description Main API class that provides access to store data, logging, routing, timeline management,
+ * and other core functionality needed for running SMILE experiments. It serves as the primary interface
+ * between experiment components and the underlying application infrastructure.
+ *
+ * @property {object} store - Smile store instance containing application state
+ * @property {object} logStore - Logging store for application logging
+ * @property {object} route - Vue Router route object for current route
+ * @property {object} router - Vue Router instance for navigation
+ * @property {object} timeline - Timeline instance for managing view sequence
+ * @property {object} config - Application configuration from store
+ * @property {object} data - Application data from store
+ * @property {object} private - Private data from store
+ * @property {object} all_data - Combined private and public data
+ * @property {object} all_config - Combined bro, dev, github and main configs
+ * @property {Object} urls - Global URL configurations
+ * @property {Object} log - Logging methods interface
+ */
+export class SmileAPI {
+    /**
+     * Creates a new SmileAPI instance
+     * @param {object} store - The Smile store instance containing application state
+     * @param {object} logStore - The logging store for application logging
+     * @param {object} route - Vue Router route object for current route
+     * @param {object} router - Vue Router instance for navigation
+     * @param {object} timeline - Timeline instance for managing view sequence
+     * @param {object} runtimeConfig - Nuxt runtime config object
+     */
+    constructor(store: object, logStore: object, route: object, router: object, timeline: object, runtimeConfig: object);
+    store: object;
+    logStore: object;
+    route: object;
+    router: object;
+    timeline: object;
+    runtimeConfig: object;
+    config: any;
+    data: any;
+    private: any;
+    all_data: {
+        private: any;
+        data: any;
+    };
+    all_config: {
+        browserPersisted: any;
+        dev: any;
+        code: any;
+        config: any;
+    };
+    urls: any;
+    /**
+     * Logging methods for the application
+     * @property {object} log - Object containing logging methods
+     * @property {Function} log.debug - Log debug level messages
+     * @property {Function} log.log - Log standard messages
+     * @property {Function} log.warn - Log warning messages
+     * @property {Function} log.error - Log error messages
+     * @property {Function} log.success - Log success messages
+     * @property {Function} log.clearPageHistory - Clear the page history log
+     * @property {Function} log.addToHistory - Add an entry to the page history log
+     */
+    log: {
+        debug: (...args: any[]) => any;
+        log: (...args: any[]) => any;
+        warn: (...args: any[]) => any;
+        error: (...args: any[]) => any;
+        success: (...args: any[]) => any;
+        clearPageHistory: () => any;
+        addToHistory: (...args: any[]) => any;
+    };
+    /**
+     * Navigate to the next view in the timeline sequence
+     * @param {boolean} [resetScroll] - Whether to reset scroll position to top after navigation
+     * @returns {void}
+     * @memberof SmileAPI
+     * @instance
+     */
+    goNextView: (resetScroll?: boolean) => void;
+    /**
+     * Navigate to the previous view in the timeline sequence
+     * @param {boolean} [resetScroll] - Whether to reset scroll position to top after navigation
+     * @returns {void}
+     * @memberof SmileAPI
+     * @instance
+     */
+    goPrevView: (resetScroll?: boolean) => void;
+    /**
+     * Navigate to a specific view in the application
+     * @param {string} view - The name of the view to navigate to
+     * @param {boolean} [force] - Whether to force navigation by temporarily disabling navigation guards
+     * @param {boolean} [resetScroll] - Whether to reset scroll position to top after navigation
+     * @returns {Promise<void>}
+     * @memberof SmileAPI
+     * @instance
+     */
+    goToView: (view: string, force?: boolean, resetScroll?: boolean) => Promise<void>;
+    /**
+     * Check if there is a next view available in the sequential navigation
+     * @returns {boolean} True if there is a next view and sequential navigation is enabled
+     */
+    hasNextView: () => boolean;
+    /**
+     * Check if there is a previous view available in the sequential navigation
+     * @returns {boolean} True if there is a previous view and sequential navigation is enabled
+     */
+    hasPrevView: () => boolean;
+    /**
+     * Get the next view in the navigation sequence
+     * @returns {object | null} Route object with name and query params, or null if no next view
+     */
+    nextView: () => object | null;
+    /**
+     * Get the previous view in the navigation sequence
+     * @returns {object | null} Route object with name and query params, or null if no previous view
+     */
+    prevView: () => object | null;
+    /**
+     * Scrolls the main content container to the top
+     * @returns {void}
+     */
+    scrollToTop(): void;
+    /**
+     * Collection of faker distributions for generating random data
+     * @type {object} fakerDistributions
+     */
+    faker: object;
+    /**
+     * Generate a random integer between min and max (inclusive)
+     * @param {number} min - The minimum value
+     * @param {number} max - The maximum value
+     * @returns {number} A random integer between min and max
+     */
+    randomInt: typeof randomInt;
+    /**
+     * Randomly reorder elements in an array
+     * @param {Array} array - The array to shuffle
+     * @returns {Array} A new array with elements in random order
+     */
+    shuffle: typeof shuffle;
+    /**
+     * Sample elements from an array with replacement
+     * @param {Array} array - The array to sample from
+     * @param {number} n - Number of elements to sample
+     * @returns {Array} Array of n randomly sampled elements
+     */
+    sampleWithReplacement: typeof sampleWithReplacement;
+    /**
+     * Sample elements from an array without replacement
+     * @param {Array} array - The array to sample from
+     * @param {number} n - Number of elements to sample
+     * @returns {Array} Array of n unique randomly sampled elements
+     */
+    sampleWithoutReplacement: typeof sampleWithoutReplacement;
+    /**
+     * Get the URL for a public asset using the deployment base path
+     * @param {string} name - The name/path of the public asset
+     * @returns {string} The complete URL for the public asset
+     */
+    getPublicUrl: (name: string) => string;
+    /**
+     * Get the URL for a core static asset from the core assets directory
+     * @param {string} name - The name/path of the core static asset
+     * @returns {string} The complete URL for the core static asset
+     */
+    getCoreStaticUrl: (name: string) => string;
+    /**
+     * Get the URL for a user static asset from the user assets directory
+     * @param {string} name - The name/path of the user static asset
+     * @returns {string} The complete URL for the user static asset
+     */
+    getStaticUrl: (name: string) => string;
+    /**
+     * Reset the entire application state
+     * @returns {void}
+     */
+    resetApp: () => void;
+    /**
+     * Check if the application is in reset state
+     * @returns {boolean} True if app is reset, false otherwise
+     */
+    isResetApp: () => boolean;
+    /**
+     * Reset just the store state
+     * @returns {void}
+     */
+    resetStore: () => void;
+    /**
+     * Reset local storage state and reload the application
+     * Removes local storage data, resets store state, and refreshes page
+     * @returns {void}
+     */
+    resetLocalState(): void;
+    /**
+     * Reloads the current browser window/page
+     * Forces a fresh reload of the current page by calling window.location.reload()
+     * @returns {void}
+     */
+    reloadBrowser(): void;
+    /**
+     * Set a global app component that can be accessed throughout the application
+     * @param {string} key - The key/identifier for the component
+     * @param {object} value - The component to store globally
+     * @returns {void}
+     */
+    setAppComponent(key: string, value: object): void;
+    /**
+     * Get a global app component by its key identifier
+     * @param {string} key - The key/identifier of the component to retrieve
+     * @returns {object | undefined} The component if found, undefined otherwise
+     */
+    getAppComponent(key: string): object | undefined;
+    /**
+     * Sets a runtime configuration value. If the key exists in the main config,
+     * updates it there. Otherwise stores it in the runtime config object.
+     * Also updates the smileConfig in store data without global components.
+     * @param {string} key - The configuration key to set
+     * @param {*} value - The value to set for the configuration key
+     * @returns {void}
+     */
+    setRuntimeConfig(key: string, value: any): void;
+    /**
+     * Gets a configuration value by key, checking both main config and runtime config
+     * @param {string} key - The configuration key to retrieve
+     * @returns {*|null} The configuration value if found, null otherwise
+     */
+    getConfig(key: string): any | null;
+    /**
+     * Sets the user as known in the store. This is typically called when a user first visits the site.
+     * @returns {Promise<void>} A promise that resolves when the known status is set
+     */
+    setKnown(): Promise<void>;
+    /**
+     * Marks the current task/experiment as completed in the store
+     * @returns {void}
+     */
+    setDone(): void;
+    /**
+     * Records that the user has provided consent in the store
+     * @returns {void}
+     */
+    setConsented(): void;
+    /**
+     * Ensures the user is known and consented, creating a server-side record if needed.
+     * @returns {Promise<void>}
+     */
+    connectDB(): Promise<void>;
+    /**
+     * Records that the user has withdrawn from the study and stores their withdrawal form info
+     * @param {object} forminfo - The withdrawal form information provided by the user
+     * @returns {void}
+     */
+    setWithdrawn(forminfo: object): void;
+    /**
+     * Sets whether the browser window visibility has been verified
+     * @param {boolean} value - True if visibility is verified, false otherwise
+     * @returns {void}
+     */
+    verifyVisibility(value: boolean): void;
+    /**
+     * Records a form submission in the store
+     * @deprecated Use recordPageData() instead. This method will be removed in a future version.
+     * @param {string} name - The name/identifier of the form
+     * @param {*} data - The form data to store
+     * @returns {void}
+     */
+    recordForm(name: string, data: any): void;
+    /**
+     * Records a named property in the store
+     * @param {string} name - The name of the property
+     * @param {*} data - The property value to store
+     * @returns {void}
+     */
+    recordProperty(name: string, data: any): void;
+    /**
+     * Validates data structure for safe storage.
+     * Rejects:
+     * - Nested arrays (arrays containing arrays)
+     * - Functions or Symbols
+     * - Keys containing ".", "/", "[", "]", or "*"
+     *
+     * @param {*} value - The value to validate
+     * @param {string} [path] - Current path for error messages
+     * @returns {{valid: boolean, error: string|null}} Validation result
+     * @private
+     */
+    private validateData;
+    /**
+     * Records data associated with a specific page/route.
+     * Data is organized by visit number using visit_N keys (visit_0, visit_1, etc.).
+     * Multiple calls within the same visit append to that visit's timestamps and data arrays.
+     *
+     * Note: Data must be Firestore-compatible. Arrays at the top level are not allowed
+     * because they would create nested arrays when stored. Use an object wrapper instead.
+     *
+     * @param {object} data - The data to record for this page (must be an object, not an array)
+     * @param {string} [routeName] - Optional route name override. Uses current route if not provided
+     * @returns {boolean} True if data was recorded successfully, false if validation failed
+     *
+     * @example
+     * // Record data for current page (uses current route name)
+     * api.recordPageData({ response: 'yes', rt: 1234 })
+     *
+     * // Record data with explicit route name
+     * api.recordPageData({ response: 'no' }, 'custom_page')
+     *
+     * // Data structure after multiple visits:
+     * // pageData_trial: {
+     * //   visit_0: { timestamps: [...], data: [...] },
+     * //   visit_1: { timestamps: [...], data: [...] }
+     * // }
+     *
+     * // WRONG: Don't pass arrays directly (will be rejected)
+     * api.recordPageData([1, 2, 3]) // Error: use { items: [1, 2, 3] } instead
+     */
+    recordPageData(data: object, routeName?: string): boolean;
+    /**
+     * Gets whether browser window visibility has been verified
+     * @returns {boolean} True if visibility is verified, false otherwise
+     */
+    getVerifiedVisibility(): boolean;
+    /**
+     * Checks if the browser window dimensions are smaller than the required dimensions
+     * @param {number} width - The current width to check against minimum requirements
+     * @param {number} height - The current height to check against minimum requirements
+     * @returns {boolean} True if browser window is too small, false otherwise
+     */
+    isBrowserTooSmall(width: number, height: number): boolean;
+    /**
+     * Sets an autofill function for development mode
+     * @param {Function} autofill - The autofill function to register
+     * @returns {void}
+     */
+    setAutofill(autofill: Function): void;
+    /**
+     * Removes the registered autofill function in development mode
+     * @returns {void}
+     */
+    removeAutofill(): void;
+    /**
+     * Sets the completion code for the study
+     * @param {string} code - The completion code to set
+     * @returns {void}
+     */
+    setCompletionCode(code: string): void;
+    /**
+     * Computes a unique completion code based on study data.
+     * Creates a hash of all pageData_* fields and appends status indicators.
+     * Falls back to studyData for backward compatibility if no pageData fields exist.
+     *
+     * @returns {string} A unique completion code with status suffix
+     */
+    computeCompletionCode(): string;
+    /**
+     * Gets the recruitment service being used (e.g. Prolific, MTurk)
+     * @returns {string} The name of the recruitment service
+     */
+    getRecruitmentService(): string;
+    /**
+     * Checks if an autofill function is registered
+     * @returns {boolean} True if autofill function exists, false otherwise
+     */
+    hasAutofill(): boolean;
+    /**
+     * Executes the registered autofill function
+     * @returns {*} The result of the autofill function
+     */
+    autofill(): any;
+    /**
+     * Gets the name of the current route from the timeline.
+     * In Nuxt, Vue Router route names are catch-all names (e.g. 'dev-slug'),
+     * so we resolve the actual timeline route name from the path.
+     * @returns {string|undefined} The current timeline route name
+     */
+    currentRouteName(): string | undefined;
+    /**
+     * Gets the info of the current route
+     * @returns {object} The current route info
+     */
+    currentRouteInfo(): object;
+    /**
+     * Gets the name of the current view from the timeline.
+     * @returns {string|undefined} The current view name
+     */
+    currentViewName(): string | undefined;
+    /**
+     * Resolves the timeline route for the current path by stripping
+     * any /dev/ or /presentation/ prefix and looking up in $timeline.
+     * @returns {object | null} The timeline route config
+     * @private
+     */
+    private _resolveTimelineRoute;
+    /**
+     * Gets a condition by its name
+     * @param {string} name - The name of the condition to get
+     * @returns {*} The condition value
+     */
+    getConditionByName(name: string): any;
+    /**
+     * Gets the browser fingerprint
+     * @returns {string} The browser fingerprint
+     */
+    getBrowserFingerprint(): string;
+    /**
+     * Records a window event
+     * @param {string} type - The type of window event
+     * @param {*} event_data - Additional event data (optional)
+     * @returns {void}
+     */
+    recordWindowEvent(type: string, event_data?: any): void;
+    /**
+     * Saves the current data
+     * @param {boolean} force - Whether to force save
+     * @returns {void}
+     */
+    saveData(force: boolean): void;
+    /**
+     * Records trial data and increments trial counter
+     * @deprecated Use recordPageData() instead. The studyData array will be maintained for backward compatibility but is deprecated.
+     * @param {*} data - The trial data to record
+     * @returns {void}
+     */
+    recordData(data: any): void;
+    /**
+     * Sets a random seed for the random number generator
+     * @param {string} [seed] - The seed to use, defaults to a random UUID
+     * @returns {void}
+     */
+    randomSeed(seed?: string): void;
+    /**
+     * Randomly assigns a condition from a set of possible conditions
+     * @param {object} conditionObject - Object containing condition name and possible values
+     * @param {string[]} conditionObject[name] - Array of possible condition values
+     * @param {number[]} [conditionObject.weights] - Optional weights for sampling conditions
+     * @returns {string|null} The assigned condition value, or null if error
+     */
+    randomAssignCondition(conditionObject: object): string | null;
+    /**
+     * Preloads all images from the user assets directory
+     * @returns {void}
+     */
+    preloadAllImages(): void;
+    /**
+     * Preloads all videos from the user assets directory
+     * @returns {void}
+     */
+    preloadAllVideos(): void;
+    /**
+     * Completes the consent process by setting consented status and known user if needed
+     * @returns {Promise<void>}
+     */
+    completeConsent(): Promise<void>;
+    #private;
+}
+import { randomInt } from '../utils/randomization.js';
+import { shuffle } from '../utils/randomization.js';
+import { sampleWithReplacement } from '../utils/randomization.js';
+import { sampleWithoutReplacement } from '../utils/randomization.js';