@m2c2kit/core 0.3.6 → 0.3.7

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { Image, CanvasKit, FontMgr, Typeface, Canvas, Surface, EmbindObject, Font, Paint, ParagraphBuilder, Paragraph, Path, PaintStyle } from 'canvaskit-wasm';
+import { Image, CanvasKit, Canvas, Surface, FontMgr, Typeface, EmbindObject, Font, Paint, ParagraphBuilder, Paragraph, Path, PaintStyle } from 'canvaskit-wasm';
 
 declare class GlobalVariables {
     now: number;
@@ -78,6 +78,7 @@ interface JsonSchema {
     default?: any;
 }
 type JsonSchemaDataType = "string" | "number" | "integer" | "object" | "array" | "boolean" | "null";
+type JsonSchemaDataTypeScriptTypes = string | number | object | boolean | null | undefined | Array<string> | Array<number> | Array<object> | Array<boolean> | Array<null>;
 
 /**
  * All the data created by an activity.
@@ -100,7 +101,7 @@ interface ActivityResults {
  *
  * @remarks Event contains all the data created by an activity, with
  * separate properties for the newly created data. ActivityResultsEvent
- * inherts "data" from ActivityResults, which contains the complete data
+ * inherits "data" from ActivityResults, which contains the complete data
  * up to this point (both new and existing data).
  */
 interface ActivityResultsEvent extends ActivityEvent, ActivityResults {
@@ -108,7 +109,7 @@ interface ActivityResultsEvent extends ActivityEvent, ActivityResults {
     newData: ActivityKeyValueData;
     /** JSON schema describing the new data */
     newDataSchema: JsonSchema;
-    /** ISO 8601 timestamp of the event. Specifically, value of "new Date().toISOString()" executed on the device when the ActivityResultsEvent occured. */
+    /** ISO 8601 timestamp of the event. Specifically, value of "new Date().toISOString()" executed on the device when the ActivityResultsEvent occurred. */
     iso8601Timestamp: string;
 }
 
@@ -194,6 +195,8 @@ declare class ImageManager {
     private _scratchCanvas?;
     private ctx?;
     private scale?;
+    private session;
+    constructor(session: Session);
     /**
      * Returns a CanvasKit Image that was previously rendered by the ImageManager.
      *
@@ -267,367 +270,91 @@ declare class ImageManager {
     removeScratchCanvas(): void;
 }
 
-interface GameFontUrls {
-    uuid: string;
-    fontUrls: Array<string>;
-}
-
-/**
- * This class contains all the fonts for all the games in the activity.
- * Fonts have been converted to canvaskit Typeface
- */
-declare class GameTypefaces {
-    [gameUuid: string]: {
-        [fontFamily: string]: Typeface;
-    };
-}
-/**
- * Class for loading, preparing, and providing fonts to games.
- *
- * @remarks FOR INTERNAL USE ONLY
- */
-declare class FontManager {
-    canvasKit?: CanvasKit;
-    fontMgr?: FontMgr;
-    gameTypefaces: GameTypefaces;
-    private allGamesFontData?;
-    /**
-     * Gets a typeface that was previously loaded for the specified game.
-     *
-     * @param gameUuid
-     * @param fontFamily
-     * @returns the requested Typeface
-     */
-    getTypeface(gameUuid: string, fontFamily: string): Typeface;
-    /**
-     * Gets names of fonts loaded for the specified game.
-     *
-     * @param gameUuid
-     * @returns array of font family names
-     */
-    getFontNames(gameUuid: string): Array<string>;
-    /**
-     * Fetches all fonts for all games.
-     *
-     * @param allGamesFontUrls
-     * @returns
-     */
-    fetchFonts(allGamesFontUrls: Array<GameFontUrls>): Promise<void>;
-    /**
-     * Takes the fonts, which have been previously fetched and converted into
-     * Array Buffers using FontManager.fetchFonts(), and makes them available
-     * to our engine
-     */
-    loadAllGamesFontData(): void;
-    /**
-     * For the specified game, fetches all fonts in the array of urls and
-     * stores fonts as array buffers.
-     *
-     * @param gameUuid
-     * @param fontUrls - array of font urls
-     * @returns
-     */
-    private fetchGameFontsAsArrayBuffers;
-    /**
-     * For the specified game, loads all fonts from array buffers and makes
-     * fonts available within canvaskit as a Typeface
-     *
-     * @param gameUuid
-     * @param fonts - array of fonts in array buffer form
-     */
-    private loadGameFonts;
+interface FontData {
+    gameUuid: string;
+    fontUrl: string;
+    fontName: string;
+    fontFamilyName: string;
+    fontArrayBuffer: ArrayBuffer;
+    isDefault: boolean;
 }
 
+type EasingFunction = (
+/** elapsed time since start of action */
+t: number, 
+/** start value of value to be eased */
+b: number, 
+/** total change of value to be eased */
+c: number, 
+/** total duration of action */
+d: number) => number;
 /**
- * Notifies when an activity starts, ends, cancels, or
- * creates data.
+ * The Easings class has static methods for creating easings to be used in actions.
  */
-interface ActivityLifecycleEvent extends ActivityEvent {
-    results?: ActivityResults;
-}
-
-interface ActivityCallbacks {
-    /** Callback executed when the activity lifecycle changes, such as when it ends. */
-    onActivityLifecycle?: (event: ActivityLifecycleEvent) => void;
-    /** Callback executed when an activity creates some data. */
-    onActivityResults?: (event: ActivityResultsEvent) => void;
-}
-
-/** Base interface for all Session events. */
-interface SessionEvent extends EventBase {
-    target: Session;
+declare class Easings {
+    static none: EasingFunction;
+    static linear: EasingFunction;
+    static quadraticIn: EasingFunction;
+    static quadraticOut: EasingFunction;
+    static quadraticInOut: EasingFunction;
+    static cubicIn: EasingFunction;
+    static cubicOut: EasingFunction;
+    static cubicInOut: EasingFunction;
+    static quarticIn: EasingFunction;
+    static quarticOut: EasingFunction;
+    static quarticInOut: EasingFunction;
+    static quinticIn: EasingFunction;
+    static quinticOut: EasingFunction;
+    static quinticInOut: EasingFunction;
+    static sinusoidalIn: EasingFunction;
+    static sinusoidalOut: EasingFunction;
+    static sinusoidalInOut: EasingFunction;
+    static exponentialIn: EasingFunction;
+    static exponentialOut: EasingFunction;
+    static exponentialInOut: EasingFunction;
+    static circularIn: EasingFunction;
+    static circularOut: EasingFunction;
+    static circularInOut: EasingFunction;
 }
 
 /**
- * Notifies when a session starts, ends, or initializes.
+ * Position in two-dimensional space.
  */
-interface SessionLifecycleEvent extends SessionEvent {
-}
-
-interface SessionCallbacks {
-    /** Callback executed when the session lifecycle changes, such as when it is initialized. */
-    onSessionLifecycle?: (event: SessionLifecycleEvent) => void;
-}
-
-interface SessionOptions {
-    /** The activities that compose this session */
-    activities: Array<Activity>;
-    /** Callbacks executed when activity events occurs, such as when activity creates data or ends */
-    activityCallbacks?: ActivityCallbacks;
-    /** Callbacks executed when session events occur */
-    sessionCallbacks?: SessionCallbacks;
-    /** Url of the canvaskit.wasm binary. Always set to the default value of "assets/canvaskit.wasm" */
-    canvasKitWasmUrl: "assets/canvaskit.wasm";
-    /** Use a specified session UUID, rather than create a new one */
-    sessionUuid?: string;
-    /** NOT IMPLEMENTED YET: Orientation the screen should be locked to for this session. Value will be passed into the ScreenOrientation.lock() Web API. */
-    orientation?: "natural" | "landscape" | "portrait" | "portrait-primary" | "portrait-secondary" | "landscape-primary" | "landscape-secondary";
+interface Point {
+    /** Horizontal coordinate */
+    x: number;
+    /** Vertical coordinate */
+    y: number;
 }
 
-declare class Session {
-    options: SessionOptions;
-    fontManager: FontManager;
-    imageManager: ImageManager;
-    currentActivity?: Activity;
-    uuid: string;
-    dataStore?: IDataStore;
-    private sessionDictionary;
-    private canvasKit?;
-    private version;
-    /**
-     * A Session contains one or more activities. The session manages the start
-     * and stop of activities, and advancement to next activity
-     *
-     * @param options
-     */
-    constructor(options: SessionOptions);
-    /**
-     * Asynchronously initializes the m2c2kit engine and loads assets
-     */
-    init(): Promise<void>;
-    /**
-     * Starts the session and starts the first activity.
-     */
-    start(): Promise<void>;
-    /**
-     * Declares the session ended and sends callback.
-     */
-    end(): void;
-    private stop;
+interface IDrawable {
+    draw(canvas: Canvas): void;
+    warmup(canvas: Canvas): void;
     /**
-     * Frees up resources that were allocated to run the session.
+     * Frees up resources that were allocated for this drawable entity.
      *
      * @remarks This will be done automatically by the m2c2kit library;
      * the end-user must not call this.
      */
-    private dispose;
-    /**
-     * Stops the current activity and goes to the activity with the provided id.
-     *
-     * @param options
-     */
-    goToActivity(options: GoToActivityOptions): Promise<void>;
-    /**
-     * Stops the current activity and advances to next activity in the session.
-     * If there is no activity after the current activity, throws error.
-     */
-    goToNextActivity(): Promise<void>;
-    /**
-     * Stops the current activity and advances to next activity in the session.
-     * If there is no activity after the current activity, throws error.
-     *
-     * @deprecated Use goToNextActivity() instead.
-     */
-    advanceToNextActivity(): Promise<void>;
-    /**
-     * Gets the next activity after the current one, or undefined if
-     * this is the last activity.
-     */
-    get nextActivity(): Activity | undefined;
-    /**
-     * Saves an item to the session's key-value dictionary.
-     *
-     * @remarks The session dictionary is not persisted. It is available only
-     * during the actively running session. It is useful for storing temporary
-     * data to coordinate between activities.
-     *
-     * @param key - item key
-     * @param value - item value
-     */
-    dictionarySetItem(key: string, value: SessionDictionaryValues): void;
-    /**
-     * Gets an item value from the session's key-value dictionary.
-     *
-     * @remarks The session dictionary is not persisted. It is available only
-     * during the actively running session. It is useful for storing temporary
-     * data to coordinate between activities.
-     *
-     * @param key - item key
-     * @returns value of the item
-     */
-    dictionaryGetItem<T extends SessionDictionaryValues>(key: string): T;
-    /**
-     * Deletes an item value from the session's key-value dictionary.
-     *
-     * @remarks The session dictionary is not persisted. It is available only
-     * during the actively running session. It is useful for storing temporary
-     * data to coordinate between activities.
-     *
-     * @param key - item key
-     * @returns true if the item was deleted, false if it did not exist
-     */
-    dictionaryDeleteItem(key: string): boolean;
-    /**
-     * Determines if a key exists in the activity's key-value dictionary.
-     *
-     * @remarks The session dictionary is not persisted. It is available only
-     * during the actively running session. It is useful for storing temporary
-     * data to coordinate between activities.
-     *
-     * @param key - item key
-     * @returns true if the key exists, false otherwise
-     */
-    dictionaryItemExists(key: string): boolean;
-    /**
-     * Gets asynchronous assets, including initialization of canvaskit wasm,
-     * fetching of fonts from specified urls, and rendering and fetching
-     * of images
-     * @returns
-     */
-    private getAsynchronousAssets;
-    private loadCanvasKit;
-    private loadAssets;
-    private assignCanvasKit;
-    private getFontsConfigurationFromGames;
-    private getImagesConfigurationFromGames;
-}
-interface GoToActivityOptions {
-    /** ActivityId of the activity to go to. */
-    id: string;
-}
-/**
- * Types of values that can be stored in the session dictonary.
- */
-type SessionDictionaryValues = string | number | boolean | object | null | undefined;
-
-interface Activity {
-    /** The type of activity: Game or Survey */
-    type: ActivityType;
-    /** Initializes the activity. All code to create the activity's appearance and behavior must be placed in this method. This method is asynchronous, and must be awaited. When writing a new game by extending the `Game` class, this method will be overridden, but the base method must still be called with `await super.init()`. */
-    init(): Promise<void>;
-    /** Starts the activity */
-    start(): Promise<void>;
-    /** Stops the activity */
-    stop(): void;
-    /** The activity's parent session */
-    session: Session;
-    /** The activity's unique identifier. NOTE: This is newly generated each session. The uuid for an activity will vary across sessions. */
-    uuid: string;
-    /** Human-friendly name of this activity */
-    name: string;
-    /** Short identifier of this activity */
-    id: string;
-    /** The value of performance.now() immediately before the activity begins */
-    beginTimestamp: number;
-    /** The value of new Date().toISOString() immediately before the activity begins */
-    beginIso8601Timestamp: string;
-    /** Sets additional activity parameters if defaults are not sufficient. */
-    setParameters(additionalParameters: unknown): void;
-    /** Additional activity parameters that were set. */
-    readonly additionalParameters?: unknown;
-    /** Optional store to use for saving data. The implementation of the store is not provided by the \@m2c2kit/core library. */
-    dataStore?: IDataStore;
-}
-
-/**
- * Base interface for all m2c2kit events.
- *
- * @remarks I would have named it Event, but that would collide with
- * the existing DOM Event
- */
-interface EventBase {
-    /** Type of event. */
-    type: EventType;
-    /** The object on which the event occurred. */
-    target: Entity | Session | Activity;
-    /** Has the event been taken care of by the listener and not be dispatched to other targets? */
-    handled?: boolean;
-}
-/**
- * The different events that are dispatched by m2c2kit.
- */
-declare enum EventType {
-    SessionInitialize = "SessionInitialize",
-    SessionStart = "SessionStart",
-    SessionEnd = "SessionEnd",
-    ActivityStart = "ActivityStart",
-    ActivityEnd = "ActivityEnd",
-    ActivityCancel = "ActivityCancel",
-    ActivityData = "ActivityData",
-    TapDown = "TapDown",
-    TapUp = "TapUp",
-    TapUpAny = "TapUpAny",
-    TapLeave = "TapLeave",
-    PointerDown = "PointerDown",
-    PointerUp = "PointerUp",
-    PointerMove = "PointerMove",
-    Drag = "Drag",
-    DragStart = "DragStart",
-    DragEnd = "DragEnd",
-    CompositeCustom = "CompositeCustom"
-}
-
-/** Base interface for all Entity events. */
-interface EntityEvent extends EventBase {
-    /** The Entity on which the event occurred. */
-    target: Entity;
-    /** For composites that raise events, type of the composite custom event. */
-    compositeType?: string;
-}
-
-interface EntityEventListener {
-    type: EventType;
-    /** For composites that raise events, type of the composite custom event. */
-    compositeType?: string;
-    entityUuid: string;
-    callback: (event: EntityEvent) => void;
-}
-
-/**
- * Position in two-dimensional space.
- */
-interface Point {
-    /** Horizonal coordinate */
-    x: number;
-    /** Vertical coordinate */
-    y: number;
+    dispose(): void;
+    anchorPoint: Point;
+    zPosition: number;
 }
 
-/**
- * Describes an interaction between the pointer (mouse, touches) and an entity.
- *
- * @remarks I would have named it PointerEvent, but that would collide with
- * the existing DOM PointerEvent.
- */
-interface M2PointerEvent extends EntityEvent {
-    /** Point that was tapped on entity, relative to the entity coordinate system */
-    point: Point;
-    /** Buttons being pressed when event was fired. Taken from DOM MouseEvent.buttons */
-    buttons: number;
+declare enum EntityType {
+    Entity = "Entity",
+    Scene = "Scene",
+    Sprite = "Sprite",
+    Label = "Label",
+    TextLine = "TextLine",
+    Shape = "Shape",
+    Composite = "Composite"
 }
 
 /**
- * Desrcibes an interaction of a pointer (mouse, touches) pressing an entity.
- *
- * @remarks Unlike M2PointerEvent, TapEvent considers how the pointer, while
- * in the down state, moves in relation to the bounds of the entity.
+ * Color in red (0-255), green (0-255), blue (0-255), alpha (0-1) format. Must be numeric array of length 4.
  */
-interface TapEvent extends EntityEvent {
-    /** Point that was tapped on entity, relative to the entity coordinate system */
-    point: Point;
-    /** Buttons being pressed when event was fired. Taken from DOM MouseEvent.buttons */
-    buttons: number;
-}
+type RgbaColor = [number, number, number, number];
 
 interface DrawableOptions {
     /** Point within the entity that determines its position. Default is \{ x: 0.5, y: 0.5 \}, which centers the entity on its position */
@@ -666,123 +393,35 @@ interface Constraints {
 }
 
 /**
- * The Layout allows relative positioning via constraints.
- * This is not fully implemented yet: DO NOT USE!
- * We use it internally for instructions.
- */
-interface Layout {
-    height?: number;
-    width?: number;
-    marginStart?: number;
-    marginEnd?: number;
-    marginTop?: number;
-    marginBottom?: number;
-    constraints?: Constraints;
-}
-
-/**
- * Color in red (0-255), green (0-255), blue (0-255), alpha (0-1) format. Must be numeric array of length 4.
- */
-type RgbaColor = [number, number, number, number];
-
-interface TextOptions {
-    /** Text to be displayed */
-    text?: string;
-    /** Name of font to use for text. Must have been previously loaded */
-    fontName?: string;
-    /** Color of text. Default is Constants.DEFAULT_FONT_COLOR (WebColors.Black) */
-    fontColor?: RgbaColor;
-    /** Size of text. Default is Constants.DEFAULT_FONT_SIZE (16) */
-    fontSize?: number;
-}
-
-/**
- * Width and height on two-dimensional space
- */
-interface Size {
-    /** Horizonal width, x-axis */
-    width: number;
-    /** Vertical height, y-axis */
-    height: number;
-}
-
-interface EntityOptions {
-    /** Name of the entity. Only needed if the entity will be referred to by name in a later function */
-    name?: string;
-    /** Position of the entity within its parent coordinate system. Default is (0, 0) */
-    position?: Point;
-    /** Scale of the entity. Default is 1.0 */
-    scale?: number;
-    /** Does the entity respond to user events, such as taps? Default is false */
-    isUserInteractionEnabled?: boolean;
-    /** Can the entity be dragged? */
-    draggable?: boolean;
-    /** Is the entity, and its children, hidden? (not displayed). Default is false */
-    hidden?: boolean;
-    /** FOR INTERNAL USE ONLY */
-    layout?: Layout;
-}
-
-declare enum EntityType {
-    Entity = "Entity",
-    Scene = "Scene",
-    Sprite = "Sprite",
-    Label = "Label",
-    TextLine = "TextLine",
-    Shape = "Shape",
-    Composite = "Composite"
-}
-
-type EasingFunction = (
-/** elapsed time since start of action */
-t: number, 
-/** start value of value to be eased */
-b: number, 
-/** total change of value to be eased */
-c: number, 
-/** total duration of action */
-d: number) => number;
-/**
- * The Easings class has static methods for creating easings to be used in actions.
- */
-declare class Easings {
-    static none: EasingFunction;
-    static linear: EasingFunction;
-    static quadraticIn: EasingFunction;
-    static quadraticOut: EasingFunction;
-    static quadraticInOut: EasingFunction;
-    static cubicIn: EasingFunction;
-    static cubicOut: EasingFunction;
-    static cubicInOut: EasingFunction;
-    static quarticIn: EasingFunction;
-    static quarticOut: EasingFunction;
-    static quarticInOut: EasingFunction;
-    static quinticIn: EasingFunction;
-    static quinticOut: EasingFunction;
-    static quinticInOut: EasingFunction;
-    static sinusoidalIn: EasingFunction;
-    static sinusoidalOut: EasingFunction;
-    static sinusoidalInOut: EasingFunction;
-    static exponentialIn: EasingFunction;
-    static exponentialOut: EasingFunction;
-    static exponentialInOut: EasingFunction;
-    static circularIn: EasingFunction;
-    static circularOut: EasingFunction;
-    static circularInOut: EasingFunction;
+ * The Layout allows relative positioning via constraints.
+ * This is not fully implemented yet: DO NOT USE!
+ * We use it internally for instructions.
+ */
+interface Layout {
+    height?: number;
+    width?: number;
+    marginStart?: number;
+    marginEnd?: number;
+    marginTop?: number;
+    marginBottom?: number;
+    constraints?: Constraints;
 }
 
-interface IDrawable {
-    draw(canvas: Canvas): void;
-    warmup(canvas: Canvas): void;
-    /**
-     * Frees up resources that were allocated for this drawable entity.
-     *
-     * @remarks This will be done automatically by the m2c2kit library;
-     * the end-user must not call this.
-     */
-    dispose(): void;
-    anchorPoint: Point;
-    zPosition: number;
+interface EntityOptions {
+    /** Name of the entity. Only needed if the entity will be referred to by name in a later function */
+    name?: string;
+    /** Position of the entity within its parent coordinate system. Default is (0, 0) */
+    position?: Point;
+    /** Scale of the entity. Default is 1.0 */
+    scale?: number;
+    /** Does the entity respond to user events, such as taps? Default is false */
+    isUserInteractionEnabled?: boolean;
+    /** Can the entity be dragged? */
+    draggable?: boolean;
+    /** Is the entity, and its children, hidden? (not displayed). Default is false */
+    hidden?: boolean;
+    /** FOR INTERNAL USE ONLY */
+    layout?: Layout;
 }
 
 interface SceneOptions extends EntityOptions, DrawableOptions {
@@ -862,7 +501,7 @@ declare class Scene extends Entity implements IDrawable, SceneOptions {
 interface SlideTransitionOptions {
     /** Direction in which the slide action goes */
     direction: TransitionDirection;
-    /** Duration, in millis, of the transition */
+    /** Duration, in milliseconds, of the transition */
     duration: number;
     /** Easing function for movement; default is linear */
     easing?: EasingFunction;
@@ -915,6 +554,14 @@ declare class SceneTransition {
     constructor(scene: Scene, transition: Transition);
 }
 
+/** Base interface for all Entity events. */
+interface EntityEvent extends EventBase {
+    /** The Entity on which the event occurred. */
+    target: Entity;
+    /** For composites that raise events, type of the composite custom event. */
+    compositeType?: string;
+}
+
 /**
  * TrialSchema defines the data that are generated for each trial. They are
  * key-value pairs in which the key is the variable name, and the value is
@@ -961,6 +608,16 @@ interface Translations {
     };
 }
 
+/**
+ * Font asset to use in the game.
+ */
+interface FontAsset {
+    /** Name of the font to use when referring to it within m2c2kit */
+    fontName: string;
+    /** URL of font (TrueType font) to load */
+    url: string;
+}
+
 /**
  * Options to specify HTML canvas, set game canvas size, and load game assets.
  */
@@ -989,8 +646,8 @@ interface GameOptions {
     trialSchema?: TrialSchema;
     /** Default game parameters; JSON object where key is the game parameter, value is default value */
     parameters?: GameParameters;
-    /** String array of urls from which to load fonts. The first element will be the default font */
-    fontUrls?: Array<string>;
+    /** Font assets to use. The first element will be the default font */
+    fonts?: Array<FontAsset>;
     /** Array of BrowserImage objects to render and load */
     images?: Array<BrowserImage>;
     /** Show FPS in upper left corner? Default is false */
@@ -1009,6 +666,8 @@ interface GameOptions {
     translations?: Translations;
     /** Show logs for WebGl activity? */
     logWebGl?: boolean;
+    /** URL of game assets folder, if not the default location of "assets/id of game from GameOptions" */
+    assetsUrl?: string;
 }
 
 interface GameData extends ActivityKeyValueData {
@@ -1021,7 +680,7 @@ interface GameData extends ActivityKeyValueData {
 interface LocalizationOptions {
     /** Locale to use for localization, or "auto" to request from the environment. */
     locale: string;
-    /** Locale to use if requested locale translation is not availble, or if "auto" locale was requested and environment cannot provide a locale. */
+    /** Locale to use if requested locale translation is not available, or if "auto" locale was requested and environment cannot provide a locale. */
     fallbackLocale?: string;
     /** Font color for strings that are missing translation and use the fallback locale or untranslated string. */
     missingTranslationFontColor?: RgbaColor;
@@ -1069,6 +728,9 @@ declare class Game implements Activity {
     private loaderElementsRemoved;
     private _dataStore?;
     additionalParameters?: unknown;
+    staticTrialSchema: {
+        [key: string]: JsonSchemaDataTypeScriptTypes;
+    };
     /**
      * The base class for all games. New games should extend this class.
      *
@@ -1216,7 +878,7 @@ declare class Game implements Activity {
      *
      * @remarks Once added to the game, a free entity will always be drawn,
      * and it will not be part of any scene transitions. This is useful if
-     * an entity must persisently be drawn and not move with scene
+     * an entity must persistently be drawn and not move with scene
      * transitions. The appearance of the free entity must be managed
      * by the programmer. Note: internally, the free entities are part of a
      * special scene (named "__freeEntitiesScene"), but this scene is handled
@@ -1368,7 +1030,44 @@ declare class Game implements Activity {
      * @param variableName - variable to be set
      * @param value - value of the variable to set
      */
-    addTrialData(variableName: string, value: any): void;
+    addTrialData(variableName: string, value: JsonSchemaDataTypeScriptTypes): void;
+    /**
+     * Adds custom trial schema to the game's trialSchema object.
+     *
+     * @param schema - Trial schema to add
+     *
+     * @remarks This is useful if you want to add custom trial variables.
+     * This must be done before Session.start() is called, because
+     * Session.start() will call Game.start(), which will initialize
+     * the trial schema.
+     */
+    addTrialSchema(schema: TrialSchema): void;
+    /**
+     * Sets the value of a variable that will be the same for all trials.
+     *
+     * @remarks This sets the value of a variable that is the same across
+     * all trials ("static"). This is useful for variables that are not
+     * part of the trial schema, but that you want to save for each trial in
+     * your use case. For example, you might want to save the subject's
+     * participant ID for each trial, but this is not part of the trial schema.
+     * Rather than modify the source code for the game, you can do the following
+     * to ensure that the participant ID is saved for each trial:
+     *
+     *   game.addTrialSchema({
+     *     participant_id: {
+     *       type: "string",
+     *       description: "ID of the participant",
+     *     }
+     *   });
+     *   game.addStaticTrialData("participant_id", "12345");
+     *
+     *  When Game.trialComplete() is called, the participant_id variable will
+     *  be saved for the trial with the value "12345".
+     *
+     * @param variableName - variable to be set
+     * @param value - value of the variable to set
+     */
+    addStaticTrialData(variableName: string, value: JsonSchemaDataTypeScriptTypes): void;
     /**
      * Should be called when the current trial has completed. It will
      * also increment the trial index.
@@ -1446,85 +1145,443 @@ declare class Game implements Activity {
      * must be queued and completed once a draw cycle has completed. See
      * the loop() method.
      *
-     * @param sx - Upper left coordinate of screenshot
-     * @param sy - Upper right coordinate of screenshot
-     * @param sw - width of area to screenshot
-     * @param sh - hegith of area to screenshot
-     * @returns Promise of Uint8Array of image data
+     * @param sx - Upper left coordinate of screenshot
+     * @param sy - Upper right coordinate of screenshot
+     * @param sw - width of area to screenshot
+     * @param sh - height of area to screenshot
+     * @returns Promise of Uint8Array of image data
+     */
+    takeScreenshot(sx?: number, sy?: number, sw?: number, sh?: number): Promise<Uint8Array | null>;
+    private animateSceneTransition;
+    private drawFps;
+    /**
+     * Creates an event listener for an entity based on the entity name
+     *
+     * @remarks Typically, event listeners will be created using a method specific to the event, such as onTapDown(). This alternative allows creation with entity name.
+     *
+     * @param type - the type of event to listen for, e.g., "tapDown"
+     * @param entityName - the entity name for which an event will be listened
+     * @param callback
+     * @param replaceExistingCallback
+     */
+    createEventListener(type: EventType, entityName: string, callback: (event: EntityEvent) => void, replaceExistingCallback?: boolean): void;
+    /**
+     * Returns array of all entities that have been added to the game object.
+     */
+    get entities(): Array<Entity>;
+    /**
+     * Receives callback from DOM PointerDown event
+     *
+     * @param domPointerEvent - PointerEvent from the DOM
+     * @returns
+     */
+    private htmlCanvasPointerDownHandler;
+    private htmlCanvasPointerUpHandler;
+    private htmlCanvasPointerMoveHandler;
+    /**
+     * Adjusts dragging behavior when the pointer leaves the canvas
+     *
+     * @remarks This is necessary because the pointerup event is not fired when
+     * the pointer leaves the canvas. On desktop, this means that the user might
+     * lift the pointer outside the canvas, but the entity will still be dragged
+     * when the pointer is moved back into the canvas.
+     *
+     * @param domPointerEvent
+     * @returns
+     */
+    private htmlCanvasPointerLeaveHandler;
+    /**
+     * Determines if/how m2c2kit entities respond to the DOM PointerDown event
+     *
+     * @param entity - entity that might be affected by the DOM PointerDown event
+     * @param m2Event
+     * @param domPointerEvent
+     */
+    private processDomPointerDown;
+    private processDomPointerUp;
+    private processDomPointerMove;
+    private raiseM2PointerDownEvent;
+    private raiseTapDownEvent;
+    private raiseTapLeaveEvent;
+    private raiseM2PointerUpEvent;
+    private raiseTapUpEvent;
+    private raiseTapUpAny;
+    private raiseM2PointerMoveEvent;
+    private raiseM2DragStartEvent;
+    private raiseM2DragEvent;
+    private raiseM2DragEndEvent;
+    private calculatePointWithinEntityFromDomPointerEvent;
+    private raiseEventOnListeningEntities;
+    private sceneCanReceiveUserInteraction;
+    /**
+     *
+     * Checks if the given canvas point is within the entity's bounds.
+     *
+     * @param entity - entity to check bounds for
+     * @param x - x coordinate of the canvas point
+     * @param y - y coordinate of the canvas point
+     * @returns true if x, y point is within the entity's bounds
+     */
+    private IsCanvasPointWithinEntityBounds;
+    private calculateEntityAbsoluteBoundingBox;
+    prependAssetsGameIdUrl(url: string): string;
+}
+
+/**
+ * This class contains all the fonts for all the games in the activity.
+ * Fonts have been converted to canvaskit Typeface.
+ *
+ * @remarks fontName is how the user will refer to the font in the game.
+ * fontFamily is the name of the font as it was specified within the TTF file.
+ * We must retain the fontFamily name because we must provide fontFamily (not
+ * fontName!) to canvaskit when rendering paragraphs.
+ */
+declare class GameTypefaces {
+    [gameUuid: string]: {
+        [fontName: string]: {
+            fontFamily: string;
+            typeface: Typeface;
+            isDefault: boolean;
+        };
+    };
+}
+/**
+ * Class for loading, preparing, and providing fonts to games.
+ *
+ * @remarks FOR INTERNAL USE ONLY
+ */
+declare class FontManager {
+    canvasKit?: CanvasKit;
+    fontMgr?: FontMgr;
+    gameTypefaces: GameTypefaces;
+    fontData: Array<FontData>;
+    session: Session;
+    games?: Array<Game>;
+    constructor(session: Session);
+    /**
+     * Gets a typeface that was previously loaded for the specified game.
+     *
+     * @param gameUuid
+     * @param fontName
+     * @returns the requested Typeface
+     */
+    getTypeface(gameUuid: string, fontName: string): Typeface;
+    /**
+     * Gets names of fonts loaded for the specified game.
+     *
+     * @param gameUuid
+     * @returns array of font names
+     */
+    getFontNames(gameUuid: string): Array<string>;
+    /**
+     * Fetches all fonts games.
+     *
+     * @param games - array of games
+     * @returns
+     */
+    fetchFonts(games: Array<Game>): Promise<void[]>;
+    /**
+     * Takes the fonts, which have been previously fetched and converted into
+     * Array Buffers using FontManager.fetchFonts(), and makes them available
+     * to our engine by creating canvaskit Typefaces.
+     */
+    loadAllGamesFontData(): void;
+}
+
+/**
+ * Notifies when an activity starts, ends, cancels, or
+ * creates data.
+ */
+interface ActivityLifecycleEvent extends ActivityEvent {
+    results?: ActivityResults;
+}
+
+interface ActivityCallbacks {
+    /** Callback executed when the activity lifecycle changes, such as when it ends. */
+    onActivityLifecycle?: (event: ActivityLifecycleEvent) => void;
+    /** Callback executed when an activity creates some data. */
+    onActivityResults?: (event: ActivityResultsEvent) => void;
+}
+
+/** Base interface for all Session events. */
+interface SessionEvent extends EventBase {
+    target: Session;
+}
+
+/**
+ * Notifies when a session starts, ends, or initializes.
+ */
+interface SessionLifecycleEvent extends SessionEvent {
+}
+
+interface SessionCallbacks {
+    /** Callback executed when the session lifecycle changes, such as when it is initialized. */
+    onSessionLifecycle?: (event: SessionLifecycleEvent) => void;
+}
+
+interface SessionOptions {
+    /** The activities that compose this session */
+    activities: Array<Activity>;
+    /** Callbacks executed when activity events occurs, such as when activity creates data or ends */
+    activityCallbacks?: ActivityCallbacks;
+    /** Callbacks executed when session events occur */
+    sessionCallbacks?: SessionCallbacks;
+    /** Url of the canvaskit.wasm binary. Always set to the default value of "canvaskit.wasm" */
+    canvasKitWasmUrl: "canvaskit.wasm";
+    /** Use a specified session UUID, rather than create a new one */
+    sessionUuid?: string;
+    /** URL of session assets folder (which contains wasm binary), if not the default location of "assets" */
+    assetsUrl?: string;
+    /** NOT IMPLEMENTED YET: Orientation the screen should be locked to for this session. Value will be passed into the ScreenOrientation.lock() Web API. */
+    orientation?: "natural" | "landscape" | "portrait" | "portrait-primary" | "portrait-secondary" | "landscape-primary" | "landscape-secondary";
+}
+
+declare class Session {
+    options: SessionOptions;
+    fontManager: FontManager;
+    imageManager: ImageManager;
+    currentActivity?: Activity;
+    uuid: string;
+    dataStore?: IDataStore;
+    private sessionDictionary;
+    private canvasKit?;
+    private version;
+    /**
+     * A Session contains one or more activities. The session manages the start
+     * and stop of activities, and advancement to next activity
+     *
+     * @param options
+     */
+    constructor(options: SessionOptions);
+    /**
+     * Asynchronously initializes the m2c2kit engine and loads assets
+     */
+    init(): Promise<void>;
+    /**
+     * Starts the session and starts the first activity.
+     */
+    start(): Promise<void>;
+    /**
+     * Declares the session ended and sends callback.
+     */
+    end(): void;
+    private stop;
+    /**
+     * Frees up resources that were allocated to run the session.
+     *
+     * @remarks This will be done automatically by the m2c2kit library;
+     * the end-user must not call this.
      */
-    takeScreenshot(sx?: number, sy?: number, sw?: number, sh?: number): Promise<Uint8Array | null>;
-    private animateSceneTransition;
-    private drawFps;
+    private dispose;
     /**
-     * Creates an event listener for an entity based on the entity name
+     * Stops the current activity and goes to the activity with the provided id.
      *
-     * @remarks Typically, event listeners will be created using a method specific to the event, such as onTapDown(). This alternative allows creation with entity name.
+     * @param options
+     */
+    goToActivity(options: GoToActivityOptions): Promise<void>;
+    /**
+     * Stops the current activity and advances to next activity in the session.
+     * If there is no activity after the current activity, throws error.
+     */
+    goToNextActivity(): Promise<void>;
+    /**
+     * Stops the current activity and advances to next activity in the session.
+     * If there is no activity after the current activity, throws error.
      *
-     * @param type - the type of event to listen for, e.g., "tapdown"
-     * @param entityName - the entity name for which an event will be listened
-     * @param callback
-     * @param replaceExistingCallback
+     * @deprecated Use goToNextActivity() instead.
      */
-    createEventListener(type: EventType, entityName: string, callback: (event: EntityEvent) => void, replaceExistingCallback?: boolean): void;
+    advanceToNextActivity(): Promise<void>;
     /**
-     * Returns array of all entities that have been added to the game object.
+     * Gets the next activity after the current one, or undefined if
+     * this is the last activity.
      */
-    get entities(): Array<Entity>;
+    get nextActivity(): Activity | undefined;
     /**
-     * Receives callback from DOM PointerDown event
+     * Saves an item to the session's key-value dictionary.
      *
-     * @param domPointerEvent - PointerEvent from the DOM
-     * @returns
+     * @remarks The session dictionary is not persisted. It is available only
+     * during the actively running session. It is useful for storing temporary
+     * data to coordinate between activities.
+     *
+     * @param key - item key
+     * @param value - item value
      */
-    private htmlCanvasPointerDownHandler;
-    private htmlCanvasPointerUpHandler;
-    private htmlCanvasPointerMoveHandler;
+    dictionarySetItem(key: string, value: SessionDictionaryValues): void;
     /**
-     * Adjusts dragging behavior when the pointer leaves the canvas
+     * Gets an item value from the session's key-value dictionary.
      *
-     * @remarks This is necessary because the pointerup event is not fired when
-     * the pointer leaves the canvas. On desktop, this means that the user might
-     * lift the pointer outside the canvas, but the entity will still be dragged
-     * when the pointer is moved back into the canvas.
+     * @remarks The session dictionary is not persisted. It is available only
+     * during the actively running session. It is useful for storing temporary
+     * data to coordinate between activities.
      *
-     * @param domPointerEvent
-     * @returns
+     * @param key - item key
+     * @returns value of the item
      */
-    private htmlCanvasPointerLeaveHandler;
+    dictionaryGetItem<T extends SessionDictionaryValues>(key: string): T;
     /**
-     * Determines if/how m2c2kit entities respond to the DOM PointerDown event
+     * Deletes an item value from the session's key-value dictionary.
      *
-     * @param entity - entity that might be affected by the DOM PointerDown event
-     * @param m2Event
-     * @param domPointerEvent
+     * @remarks The session dictionary is not persisted. It is available only
+     * during the actively running session. It is useful for storing temporary
+     * data to coordinate between activities.
+     *
+     * @param key - item key
+     * @returns true if the item was deleted, false if it did not exist
      */
-    private processDomPointerDown;
-    private processDomPointerUp;
-    private processDomPointerMove;
-    private raiseM2PointerDownEvent;
-    private raiseTapDownEvent;
-    private raiseTapLeaveEvent;
-    private raiseM2PointerUpEvent;
-    private raiseTapUpEvent;
-    private raiseTapUpAny;
-    private raiseM2PointerMoveEvent;
-    private raiseM2DragStartEvent;
-    private raiseM2DragEvent;
-    private raiseM2DragEndEvent;
-    private calculatePointWithinEntityFromDomPointerEvent;
-    private raiseEventOnListeningEntities;
-    private sceneCanReceiveUserInteraction;
+    dictionaryDeleteItem(key: string): boolean;
     /**
+     * Determines if a key exists in the activity's key-value dictionary.
      *
-     * Checks if the given canvas point is within the entity's bounds.
+     * @remarks The session dictionary is not persisted. It is available only
+     * during the actively running session. It is useful for storing temporary
+     * data to coordinate between activities.
      *
-     * @param entity - entity to check bounds for
-     * @param x - x coordinate of the canvas point
-     * @param y - y coordinate of the canvas point
-     * @returns true if x, y point is within the entity's bounds
+     * @param key - item key
+     * @returns true if the key exists, false otherwise
      */
-    private IsCanvasPointWithinEntityBounds;
-    private calculateEntityAbsoluteBoundingBox;
+    dictionaryItemExists(key: string): boolean;
+    /**
+     * Gets asynchronous assets, including initialization of canvaskit wasm,
+     * fetching of fonts from specified urls, and rendering and fetching
+     * of images
+     * @returns
+     */
+    private getAsynchronousAssets;
+    private loadCanvasKit;
+    private loadAssets;
+    private assignCanvasKit;
+    private getImagesConfigurationFromGames;
+    prependAssetsUrl(url: string): string;
+}
+interface GoToActivityOptions {
+    /** ActivityId of the activity to go to. */
+    id: string;
+}
+/**
+ * Types of values that can be stored in the session dictionary.
+ */
+type SessionDictionaryValues = string | number | boolean | object | null | undefined;
+
+interface Activity {
+    /** The type of activity: Game or Survey */
+    type: ActivityType;
+    /** Initializes the activity. All code to create the activity's appearance and behavior must be placed in this method. This method is asynchronous, and must be awaited. When writing a new game by extending the `Game` class, this method will be overridden, but the base method must still be called with `await super.init()`. */
+    init(): Promise<void>;
+    /** Starts the activity */
+    start(): Promise<void>;
+    /** Stops the activity */
+    stop(): void;
+    /** The activity's parent session */
+    session: Session;
+    /** The activity's unique identifier. NOTE: This is newly generated each session. The uuid for an activity will vary across sessions. */
+    uuid: string;
+    /** Human-friendly name of this activity */
+    name: string;
+    /** Short identifier of this activity */
+    id: string;
+    /** The value of performance.now() immediately before the activity begins */
+    beginTimestamp: number;
+    /** The value of new Date().toISOString() immediately before the activity begins */
+    beginIso8601Timestamp: string;
+    /** Sets additional activity parameters if defaults are not sufficient. */
+    setParameters(additionalParameters: unknown): void;
+    /** Additional activity parameters that were set. */
+    readonly additionalParameters?: unknown;
+    /** Optional store to use for saving data. The implementation of the store is not provided by the \@m2c2kit/core library. */
+    dataStore?: IDataStore;
+}
+
+/**
+ * Base interface for all m2c2kit events.
+ *
+ * @remarks I would have named it Event, but that would collide with
+ * the existing DOM Event
+ */
+interface EventBase {
+    /** Type of event. */
+    type: EventType;
+    /** The object on which the event occurred. */
+    target: Entity | Session | Activity;
+    /** Has the event been taken care of by the listener and not be dispatched to other targets? */
+    handled?: boolean;
+}
+/**
+ * The different events that are dispatched by m2c2kit.
+ */
+declare enum EventType {
+    SessionInitialize = "SessionInitialize",
+    SessionStart = "SessionStart",
+    SessionEnd = "SessionEnd",
+    ActivityStart = "ActivityStart",
+    ActivityEnd = "ActivityEnd",
+    ActivityCancel = "ActivityCancel",
+    ActivityData = "ActivityData",
+    TapDown = "TapDown",
+    TapUp = "TapUp",
+    TapUpAny = "TapUpAny",
+    TapLeave = "TapLeave",
+    PointerDown = "PointerDown",
+    PointerUp = "PointerUp",
+    PointerMove = "PointerMove",
+    Drag = "Drag",
+    DragStart = "DragStart",
+    DragEnd = "DragEnd",
+    CompositeCustom = "CompositeCustom"
+}
+
+interface EntityEventListener {
+    type: EventType;
+    /** For composites that raise events, type of the composite custom event. */
+    compositeType?: string;
+    entityUuid: string;
+    callback: (event: EntityEvent) => void;
+}
+
+/**
+ * Describes an interaction between the pointer (mouse, touches) and an entity.
+ *
+ * @remarks I would have named it PointerEvent, but that would collide with
+ * the existing DOM PointerEvent.
+ */
+interface M2PointerEvent extends EntityEvent {
+    /** Point that was tapped on entity, relative to the entity coordinate system */
+    point: Point;
+    /** Buttons being pressed when event was fired. Taken from DOM MouseEvent.buttons */
+    buttons: number;
+}
+
+/**
+ * Describes an interaction of a pointer (mouse, touches) pressing an entity.
+ *
+ * @remarks Unlike M2PointerEvent, TapEvent considers how the pointer, while
+ * in the down state, moves in relation to the bounds of the entity.
+ */
+interface TapEvent extends EntityEvent {
+    /** Point that was tapped on entity, relative to the entity coordinate system */
+    point: Point;
+    /** Buttons being pressed when event was fired. Taken from DOM MouseEvent.buttons */
+    buttons: number;
+}
+
+interface TextOptions {
+    /** Text to be displayed */
+    text?: string;
+    /** Name of font to use for text. Must have been previously loaded */
+    fontName?: string;
+    /** Color of text. Default is Constants.DEFAULT_FONT_COLOR (WebColors.Black) */
+    fontColor?: RgbaColor;
+    /** Size of text. Default is Constants.DEFAULT_FONT_SIZE (16) */
+    fontSize?: number;
+}
+
+/**
+ * Width and height on two-dimensional space
+ */
+interface Size {
+    /** Horizontal width, x-axis */
+    width: number;
+    /** Vertical height, y-axis */
+    height: number;
 }
 
 /**
@@ -1599,7 +1656,7 @@ declare abstract class Entity implements EntityOptions {
      */
     toString: () => string;
     /**
-     * Adds a child to this parent entity. Thows exception if the child's name
+     * Adds a child to this parent entity. Throws exception if the child's name
      * is not unique with respect to other children of this parent.
      *
      * @param child - The child entity to add
@@ -1871,7 +1928,7 @@ interface MoveActionOptions {
     duration: number;
     /** Easing function for movement; default is linear */
     easing?: EasingFunction;
-    /** Should the action run during screen trnsitions? Default is no */
+    /** Should the action run during screen transitions? Default is no */
     runDuringTransition?: boolean;
 }
 
@@ -2130,7 +2187,7 @@ declare class Constants {
 }
 
 /**
- * This enum is used interally for processing the layout constraints. We use
+ * This enum is used internally for processing the layout constraints. We use
  * an enum to avoid magic strings. NOTE: the casing in ConstraintType must
  * match the casing in Constraints.ts. Thus, this enum's members are in
  * lowercase, which is not typical Typescript style.
@@ -2169,12 +2226,6 @@ declare class Equals {
     static rgbaColor(color1?: RgbaColor, color2?: RgbaColor): boolean;
 }
 
-interface FontData {
-    gameUuid: string;
-    fontUrl: string;
-    fontArrayBuffer: ArrayBuffer;
-}
-
 interface IText {
     text?: string;
     fontName?: string;
@@ -2195,6 +2246,8 @@ interface LabelOptions extends EntityOptions, DrawableOptions, TextOptions {
     preferredMaxLayoutWidth?: number;
     /** Background color  of label text. Default is no background color */
     backgroundColor?: RgbaColor;
+    /** Names of multiple fonts to use for text. For example, if a text font and an emoji font are to be used together. Must have been previously loaded */
+    fontNames?: Array<string>;
 }
 
 declare class Label extends Entity implements IDrawable, IText, LabelOptions {
@@ -2208,6 +2261,7 @@ declare class Label extends Entity implements IDrawable, IText, LabelOptions {
     zPosition: number;
     private _text;
     private _fontName;
+    private _fontNames;
     private _fontColor;
     private _fontSize;
     private _horizontalAlignmentMode;
@@ -2232,6 +2286,8 @@ declare class Label extends Entity implements IDrawable, IText, LabelOptions {
     get translatedText(): string;
     get fontName(): string | undefined;
     set fontName(fontName: string | undefined);
+    get fontNames(): Array<string> | undefined;
+    set fontNames(fontNames: Array<string> | undefined);
     get fontColor(): RgbaColor;
     set fontColor(fontColor: RgbaColor);
     get fontSize(): number;
@@ -2260,7 +2316,7 @@ declare class Label extends Entity implements IDrawable, IText, LabelOptions {
 
 /**
  * This class is used internally for processing layout constraints that
- * have been defined according to the Contraints interface.
+ * have been defined according to the Constraints interface.
  *
  * Imagine we have two entities, A and B. B's position is set
  * using its position property. A's position is set using the layout
@@ -2287,7 +2343,7 @@ declare class LayoutConstraint {
 interface M2Path {
     /** The subpath that compose up the path */
     subpaths: Array<Array<Point>>;
-    /** The size of the path. This is neeeded to properly position the shape that is drawn by the path */
+    /** The size of the path. This is needed to properly position the shape that is drawn by the path */
     size: Size;
 }
 
@@ -2406,13 +2462,13 @@ interface ShapeOptions extends EntityOptions, DrawableOptions {
     fillColor?: RgbaColor;
     /** Color with which to outline shape. Default is no color for rectangle and circle, red for path. */
     strokeColor?: RgbaColor;
-    /** Width of outline. Default is undefined for rectangle and cricle, 2 for path. */
+    /** Width of outline. Default is undefined for rectangle and circle, 2 for path. */
     lineWidth?: number;
     /** A path from which to create the shape */
     path?: M2Path | SvgStringPath;
-    /** Size of container "viewbox" for path shapes. Leave undefined for circle and rectangle shapes. */
+    /** Size of container "view box" for path shapes. Leave undefined for circle and rectangle shapes. */
     size?: Size;
-    /** Should the shape be drawn with antialiasing. Default is yes. */
+    /** Should the shape be drawn with anti-aliasing. Default is yes. */
     isAntialiased?: boolean;
 }
 
@@ -2621,7 +2677,7 @@ declare class Timer {
     private stopped;
     /**
      * cumulativeElapsed is a cumulative total of elapsed time while the timer
-     * was in previous started (running) states, NOT INCLUDING the possibily
+     * was in previous started (running) states, NOT INCLUDING the possibly
      * active run's duration
      */
     private cumulativeElapsed;