@blorkfield/overlay-core 0.3.0

package/dist/index.d.ts

@@ -0,0 +1,700 @@
+import opentype from 'opentype.js';
+
+interface OverlaySceneConfig {
+    bounds: Bounds;
+    gravity?: number;
+    wrapHorizontal?: boolean;
+    debug?: boolean;
+    background?: string;
+    /** @deprecated Use floorConfig instead. Pressure threshold for the floor boundary. */
+    floorThreshold?: number;
+    /** Distance below floor (as fraction of container height) at which objects despawn. Default: 1.0 (100%) */
+    despawnBelowFloor?: number;
+    /** Configuration for floor segments and thresholds */
+    floorConfig?: FloorConfig;
+}
+/**
+ * Configuration for floor segments and pressure thresholds.
+ * When provided, floor can be divided into segments with individual collapse behavior.
+ */
+interface FloorConfig {
+    /**
+     * Number of segments to divide the floor into.
+     * If not provided or 1, floor is a single strip.
+     */
+    segments?: number;
+    /**
+     * Pressure threshold(s) for floor segments:
+     * - number: Same threshold for all segments
+     * - number[]: Per-segment thresholds (segment 0 uses value[0], etc.)
+     * If not provided, segments have infinite capacity.
+     */
+    threshold?: number | number[];
+}
+interface Bounds {
+    top: number;
+    bottom: number;
+    left: number;
+    right: number;
+}
+type ShapePreset = 'circle' | 'rectangle' | 'polygon' | 'hexagon' | 'octagon' | 'triangle' | 'pentagon';
+interface ShapeConfig {
+    /** Shape type - preset name or 'polygon' for n-gon. Image shape extraction is automatic when imageUrl provided */
+    type: ShapePreset;
+    /** For rectangle: aspect ratio (width/height). Default 1 */
+    aspectRatio?: number;
+    /** Number of sides for polygon shapes. Required for 'polygon', optional override for presets */
+    sides?: number;
+    /** Custom vertices (overrides type). Array of {x, y} relative to center */
+    vertices?: Array<{
+        x: number;
+        y: number;
+    }>;
+}
+/**
+ * Configuration for despawn effects (placeholder for future custom effects)
+ */
+interface DespawnEffectConfig {
+    /** Effect type identifier for future use */
+    type?: string;
+}
+/**
+ * Unified configuration for spawning scene objects.
+ * Objects are configured via tags that define their behavior:
+ * - 'falling': Object is dynamic and affected by gravity (without this tag, object is static)
+ * - 'follow': Object follows mouse position when grounded
+ * - 'grabable': Object can be dragged via mouse constraint
+ */
+interface ObjectConfig {
+    x: number;
+    y: number;
+    /** Radius for circle/polygon shapes */
+    radius?: number;
+    /** Width for rectangle objects (ignored if imageUrl is provided) */
+    width?: number;
+    /** Height for rectangle objects (ignored if imageUrl is provided) */
+    height?: number;
+    /** Image URL for image-based shapes */
+    imageUrl?: string;
+    /** Size of the object when using imageUrl (diameter) */
+    size?: number;
+    /** Fill style color */
+    fillStyle?: string;
+    /** Tags that define object behavior */
+    tags?: string[];
+    /** Shape configuration. Defaults to circle if radius provided, rectangle otherwise */
+    shape?: ShapeConfig;
+    /** Time-to-live in milliseconds. If not set, object lives forever */
+    ttl?: number;
+    /** Configuration for despawn effect (future use) */
+    despawnEffect?: DespawnEffectConfig;
+    /** Weight for pressure calculation (default: 1). Higher weight = more pressure contribution */
+    weight?: number;
+}
+/**
+ * Dynamic object data passed to update callbacks.
+ * Only objects with the 'falling' tag (dynamic objects) are included.
+ */
+interface DynamicObject {
+    id: string;
+    x: number;
+    y: number;
+    angle: number;
+    tags: string[];
+}
+interface UpdateCallbackData {
+    /** All dynamic objects (objects with 'falling' tag) */
+    objects: DynamicObject[];
+}
+type UpdateCallback = (data: UpdateCallbackData) => void;
+interface ContainerOptions {
+    width?: number;
+    height?: number;
+    fullscreen?: boolean;
+}
+/**
+ * Configuration for an object type that can be spawned by an effect.
+ * Effects can spawn multiple object types with different probabilities.
+ */
+interface EffectObjectConfig {
+    /** Partial object config - x, y will be set by the effect */
+    objectConfig: Omit<ObjectConfig, 'x' | 'y' | 'radius'> & {
+        radius?: number;
+    };
+    /** Probability weight for this object type (relative to others in the effect) */
+    probability: number;
+    /** Minimum scale multiplier for radius */
+    minScale: number;
+    /** Maximum scale multiplier for radius */
+    maxScale: number;
+    /** Base radius for the object (default: 20) */
+    baseRadius?: number;
+}
+/**
+ * Base configuration shared by all effect types
+ */
+interface BaseEffectConfig {
+    /** Unique identifier for this effect */
+    id: string;
+    /** Whether the effect is currently active */
+    enabled: boolean;
+    /** Object configurations with their spawn probabilities */
+    objectConfigs: EffectObjectConfig[];
+}
+/**
+ * Burst effect - spawns entities from a point that explode outward
+ */
+interface BurstEffectConfig extends BaseEffectConfig {
+    type: 'burst';
+    /** How often a burst occurs (in milliseconds) */
+    burstInterval: number;
+    /** Number of entities spawned per burst */
+    burstCount: number;
+    /** Velocity magnitude for burst entities */
+    burstForce: number;
+    /** Optional fixed origin point. If not specified, random position is used */
+    origin?: {
+        x: number;
+        y: number;
+    };
+}
+/**
+ * Rain effect - continuously spawns entities from the top that fall down
+ */
+interface RainEffectConfig extends BaseEffectConfig {
+    type: 'rain';
+    /** How many entities to spawn per second */
+    spawnRate: number;
+    /** Portion of screen width to spawn across (0-1, default: 1) */
+    spawnWidth?: number;
+}
+/**
+ * Stream effect - emits entities from a point in a configurable direction with cone spread
+ */
+interface StreamEffectConfig extends BaseEffectConfig {
+    type: 'stream';
+    /** Origin point where entities are emitted from (can be outside bounds) */
+    origin: {
+        x: number;
+        y: number;
+    };
+    /** Direction vector (will be normalized). e.g., { x: 0, y: 1 } for downward */
+    direction: {
+        x: number;
+        y: number;
+    };
+    /** How many entities to spawn per second */
+    spawnRate: number;
+    /** Initial velocity/force magnitude for spawned entities */
+    force: number;
+    /** Cone angle in radians - spread from center direction (0 = laser, Math.PI/4 = 45° cone) */
+    coneAngle: number;
+}
+type EffectConfig = BurstEffectConfig | RainEffectConfig | StreamEffectConfig;
+type EffectType = EffectConfig['type'];
+/**
+ * Configuration for pressure-based collapse of obstacles.
+ * When pressure (number of objects resting on an obstacle) reaches the threshold,
+ * the obstacle converts to dynamic (falling).
+ */
+interface PressureThresholdConfig {
+    /**
+     * Threshold value(s):
+     * - number: Single threshold applied per-letter (or word total if wordCollapse is true)
+     * - number[]: Per-letter thresholds by index (letter 0 uses value[0], etc.)
+     */
+    value: number | number[];
+    /**
+     * When true and value is a single number:
+     * - Tracks total pressure across all letters in the word
+     * - When total reaches threshold, ALL letters in the word collapse together
+     * When false or undefined (default):
+     * - Each letter tracks its own pressure
+     * - Only the letter that reaches threshold collapses
+     */
+    wordCollapse?: boolean;
+}
+/**
+ * Configuration for weight of obstacles (used when they collapse and become falling objects).
+ * Weight determines how much pressure an object contributes when resting on something.
+ */
+interface WeightConfig {
+    /**
+     * Weight value(s):
+     * - number: Single weight applied to all letters
+     * - number[]: Per-letter weights by index (letter 0 uses value[0], etc.)
+     */
+    value: number | number[];
+}
+/**
+ * Configuration for shadow left behind when an obstacle collapses.
+ * When enabled, a static washed-out version of the obstacle remains at its original position.
+ */
+interface ShadowConfig {
+    /**
+     * Opacity of the shadow (0-1). Default: 0.3
+     */
+    opacity?: number;
+}
+/**
+ * Configuration for click to fall behavior.
+ * When enabled, obstacles collapse after being clicked a specified number of times.
+ */
+interface ClickToFallConfig {
+    /**
+     * Number of clicks required before the obstacle falls.
+     * Each click decrements the counter; when it reaches zero, the obstacle collapses.
+     */
+    clicks: number;
+}
+/**
+ * Configuration for creating text objects from strings
+ */
+interface TextObstacleConfig {
+    /** The text to create objects from (A-Z, 0-9 supported, supports \n for multiline) */
+    text: string;
+    /** X position of the first letter's center */
+    x: number;
+    /** Y position of the letter centers */
+    y: number;
+    /** Size of each letter (width/height) */
+    letterSize: number;
+    /** Spacing between letter centers (default: letterSize) */
+    letterSpacing?: number;
+    /** Font name - corresponds to directory under /fonts/ (default: 'handwritten') */
+    fontName?: string;
+    /** Base URL path for fonts directory (default: '/fonts/') */
+    fontsBasePath?: string;
+    /** Tags to apply to all letters (use 'falling' for dynamic objects) */
+    tags?: string[];
+    /** Tag for the entire string (for releasing whole string). Auto-generated if not provided */
+    stringTag?: string;
+    /** Time-to-live in milliseconds */
+    ttl?: number;
+    /** Color to tint the letters (CSS color string). If not set, original image colors are used */
+    letterColor?: string;
+    /** Line height for multiline text (default: letterSize * 1.2) */
+    lineHeight?: number;
+    /** Pressure threshold config - when reached, letters collapse */
+    pressureThreshold?: PressureThresholdConfig;
+    /** Weight config - when letters collapse, this is their pressure contribution */
+    weight?: WeightConfig;
+    /** Shadow config - when enabled, a washed-out version remains after collapse */
+    shadow?: ShadowConfig;
+    /** Click to fall config - when set, letters collapse after being clicked N times */
+    clickToFall?: ClickToFallConfig;
+}
+/**
+ * Debug information for a single letter's positioning
+ */
+interface LetterDebugInfo {
+    /** Letter character */
+    char: string;
+    /** Obstacle ID */
+    id: string;
+    /** Original PNG dimensions (before scaling) */
+    originalWidth: number;
+    originalHeight: number;
+    /** Scaled dimensions at letterSize */
+    scaledWidth: number;
+    scaledHeight: number;
+    /** Position of the letter's original dimension box (top-left corner) */
+    boxX: number;
+    boxY: number;
+    /** Center position of the letter */
+    centerX: number;
+    centerY: number;
+}
+/**
+ * Result of creating text obstacles
+ */
+interface TextObstacleResult {
+    /** IDs of all created letter obstacles */
+    letterIds: string[];
+    /** Tag for the entire string (all letters) */
+    stringTag: string;
+    /** Tags for each individual word (space/newline separated) */
+    wordTags: string[];
+    /** Map of character to obstacle ID for individual control */
+    letterMap: Map<string, string>;
+    /** Debug info for each letter (for drawing original dimension boxes) */
+    letterDebugInfo: LetterDebugInfo[];
+}
+/**
+ * Configuration for creating text objects from a TTF font
+ */
+interface TTFTextObstacleConfig {
+    /** Text to display (supports \n for multiline) */
+    text: string;
+    /** X position of the start of text */
+    x: number;
+    /** Y position of the text baseline */
+    y: number;
+    /** Font size in pixels */
+    fontSize: number;
+    /** URL path to the TTF/OTF font file */
+    fontUrl: string;
+    /** Tags to apply to all letters (use 'falling' for dynamic objects) */
+    tags?: string[];
+    /** Tag for the entire string (for releasing whole string). Auto-generated if not provided */
+    stringTag?: string;
+    /** Time-to-live in milliseconds */
+    ttl?: number;
+    /** Fill color for the letters (CSS color string, default: '#ffffff') */
+    fillColor?: string;
+    /** Line height for multiline text (default: fontSize * 1.2) */
+    lineHeight?: number;
+    /** Pressure threshold config - when reached, letters collapse */
+    pressureThreshold?: PressureThresholdConfig;
+    /** Weight config - when letters collapse, this is their pressure contribution */
+    weight?: WeightConfig;
+    /** Shadow config - when enabled, a washed-out version remains after collapse */
+    shadow?: ShadowConfig;
+    /** Click to fall config - when set, letters collapse after being clicked N times */
+    clickToFall?: ClickToFallConfig;
+}
+/**
+ * Information about an available font
+ */
+interface FontInfo {
+    /** Font name (directory name under /fonts/) */
+    name: string;
+    /** Available characters in this font (e.g., "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789") */
+    characters: string;
+    /** Font type: 'png' for image-based, 'ttf' for TrueType fonts */
+    type: 'png' | 'ttf';
+    /** For TTF fonts: relative URL path to the font file */
+    fontUrl?: string;
+}
+/**
+ * Font manifest structure loaded from fonts.json
+ */
+interface FontManifest {
+    fonts: FontInfo[];
+}
+
+declare class OverlayScene {
+    private engine;
+    private render;
+    private runner;
+    private canvas;
+    /** All scene objects (unified - no more entity/obstacle distinction) */
+    private objects;
+    private boundaries;
+    private updateCallbacks;
+    private mouseX;
+    private config;
+    private animationFrameId;
+    private mouse;
+    private mouseConstraint;
+    private effectManager;
+    private fonts;
+    private fontsInitialized;
+    private letterDebugInfo;
+    private obstaclePressure;
+    private previousPressure;
+    private pressureLogTimer;
+    private floorSegments;
+    private floorSegmentPressure;
+    private collapsedSegments;
+    static createContainer(parent: HTMLElement, options?: ContainerOptions): {
+        canvas: HTMLCanvasElement;
+        bounds: Bounds;
+    };
+    constructor(canvas: HTMLCanvasElement, config: OverlaySceneConfig);
+    /** Filter drag events - only allow grabbing objects with 'grabable' tag */
+    private handleStartDrag;
+    /** Handle canvas clicks for click-to-fall behavior */
+    private handleCanvasClick;
+    /** Get a display name for an obstacle (letter char or short ID) */
+    private getObstacleDisplayName;
+    /** Update pressure tracking - check which dynamic objects rest on static obstacles */
+    private updatePressure;
+    /** Update pressure tracking for each floor segment */
+    private updateFloorSegmentPressure;
+    /** Check floor segment thresholds and collapse segments that exceed them */
+    private checkFloorSegmentThresholds;
+    /** Collapse a single floor segment */
+    private collapseFloorSegment;
+    /** Log a summary of pressure on all obstacles, grouped by word */
+    private logPressureSummary;
+    /** Calculate weighted pressure from a set of object IDs */
+    private calculateWeightedPressure;
+    /** Check pressure thresholds and collapse obstacles that exceed them */
+    private checkPressureThresholds;
+    /** Convert a static obstacle to dynamic (make it fall) */
+    private collapseObstacle;
+    /** Create a static shadow copy of an obstacle at its original position */
+    private createShadow;
+    /** Apply opacity to a CSS color string */
+    private applyOpacityToColor;
+    /** Find an object entry by its Matter.js body (handles compound body parts) */
+    private findObjectByBody;
+    /** Check if a body is grounded (low vertical velocity indicates resting on something) */
+    private isGrounded;
+    start(): void;
+    stop(): void;
+    destroy(): void;
+    setDebug(enabled: boolean): void;
+    resize(width: number, height: number): void;
+    /**
+     * Spawn an object synchronously.
+     * Object behavior is determined by tags:
+     * - 'falling': Object is dynamic (affected by gravity)
+     * - 'follow': Object follows mouse when grounded
+     * - 'grabable': Object can be dragged
+     * Without 'falling' tag, object is static.
+     */
+    spawnObject(config: ObjectConfig): string;
+    /**
+     * Spawn an object asynchronously. Required for image-based shapes that need
+     * shape extraction from image alpha channel.
+     */
+    spawnObjectAsync(config: ObjectConfig): Promise<string>;
+    /**
+     * Add 'falling' tag to an object, making it dynamic (affected by gravity).
+     * Also adds 'grabable' tag so released objects can be dragged.
+     * This is the tag-based replacement for releaseObstacle().
+     */
+    addFallingTag(id: string): void;
+    /**
+     * Add a tag to an object.
+     */
+    addTag(id: string, tag: string): void;
+    /**
+     * Remove a tag from an object.
+     */
+    removeTag(id: string, tag: string): void;
+    /**
+     * Release an object (add 'falling' tag to make it dynamic).
+     * Convenience method - equivalent to addFallingTag().
+     */
+    releaseObject(id: string): void;
+    /**
+     * Release multiple objects by their IDs.
+     */
+    releaseObjects(ids: string[]): void;
+    /**
+     * Release all static objects (add 'falling' and 'grabable' tags).
+     */
+    releaseAllObjects(): void;
+    /**
+     * Release objects by tag (add 'falling' and 'grabable' tags to matching objects).
+     */
+    releaseObjectsByTag(tag: string): void;
+    removeObject(id: string): void;
+    removeObjects(ids: string[]): void;
+    removeAllObjects(): void;
+    removeObjectsByTag(tag: string): void;
+    getObjectIds(): string[];
+    getObjectIdsByTag(tag: string): string[];
+    /**
+     * Get all unique tags currently in use by objects in the scene.
+     */
+    getAllTags(): string[];
+    setMousePosition(x: number, _y: number): void;
+    /**
+     * Get the current pressure (number of objects resting) on an obstacle.
+     * @param obstacleId - The ID of the obstacle
+     * @returns Number of objects currently resting on the obstacle
+     */
+    getPressure(obstacleId: string): number;
+    /**
+     * Get the IDs of all objects currently resting on an obstacle.
+     * @param obstacleId - The ID of the obstacle
+     * @returns Array of object IDs resting on the obstacle
+     */
+    getObjectsRestingOn(obstacleId: string): string[];
+    /**
+     * Get all obstacles that have pressure (at least one object resting on them).
+     * @returns Map of obstacle ID -> pressure count
+     */
+    getAllPressure(): Map<string, number>;
+    /**
+     * Get pressure summary for all obstacles with their display names (letters).
+     * Useful for debugging and visualization.
+     * @returns Array of { id, name, pressure } objects
+     */
+    getPressureSummary(): {
+        id: string;
+        name: string;
+        pressure: number;
+    }[];
+    /**
+     * Initialize fonts by loading the font manifest.
+     * Should be called before using text obstacles if you want automatic font detection.
+     * @param fontsBasePath Base URL path for fonts directory (default: '/fonts/')
+     */
+    initializeFonts(fontsBasePath?: string): Promise<void>;
+    /**
+     * Get list of available fonts.
+     * Returns empty array if fonts have not been initialized.
+     */
+    getAvailableFonts(): FontInfo[];
+    /**
+     * Get font by index. Returns undefined if index is out of bounds.
+     * @param index Font index (0-based)
+     */
+    getFontByIndex(index: number): FontInfo | undefined;
+    /**
+     * Get font by name. Returns undefined if font not found.
+     * @param name Font name to find
+     */
+    getFontByName(name: string): FontInfo | undefined;
+    /**
+     * Get the default font (first available font).
+     * Returns undefined if no fonts are available.
+     */
+    getDefaultFont(): FontInfo | undefined;
+    /**
+     * Check if fonts have been initialized.
+     */
+    areFontsInitialized(): boolean;
+    /**
+     * Create text obstacles from a string. Each character becomes an individual obstacle
+     * with shape extracted from the corresponding letter PNG image.
+     * Supported characters: A-Z, a-z, 0-9 (spaces handled, unsupported chars skipped)
+     * Case is preserved: uses lowercase PNG if available, falls back to uppercase (and vice versa).
+     * Supports multiline text with \n characters.
+     *
+     * Letter positioning is based on original PNG dimensions:
+     * - Each letter's PNG width controls its horizontal spacing
+     * - The clipped shape is positioned correctly within the original bounds
+     * - This allows fine control of letter spacing via PNG canvas size
+     */
+    addTextObstacles(config: TextObstacleConfig): Promise<TextObstacleResult>;
+    /**
+     * Spawn falling text objects from a string.
+     * Same as addTextObstacles but with 'falling' tag (objects fall with gravity).
+     */
+    spawnFallingTextObstacles(config: TextObstacleConfig): Promise<TextObstacleResult>;
+    /**
+     * Release all letters in a word (add 'falling' tag so they fall).
+     * @param wordTag - The word tag returned from addTextObstacles
+     */
+    releaseTextObstacles(wordTag: string): void;
+    /**
+     * Release letters one by one with a delay between each.
+     * @param wordTag - The word tag returned from addTextObstacles
+     * @param delayMs - Delay between releasing each letter (default: 100ms)
+     * @param reverse - If true, release from end to start (default: false)
+     */
+    releaseTextObstaclesSequentially(wordTag: string, delayMs?: number, reverse?: boolean): Promise<void>;
+    /**
+     * Get letter debug info for a word.
+     * Returns the debug info array for the given word tag, or undefined if not found.
+     * Debug info includes original dimension boxes for each letter.
+     */
+    getLetterDebugInfo(wordTag: string): LetterDebugInfo[] | undefined;
+    /**
+     * Get all stored letter debug info (all words).
+     * Returns a map of wordTag -> debug info array.
+     */
+    getAllLetterDebugInfo(): Map<string, LetterDebugInfo[]>;
+    /**
+     * Create text obstacles from a TTF/OTF font file.
+     * Uses proper font metrics for spacing, kerning, and glyph outlines for collision.
+     * Supports multiline text with \n characters.
+     */
+    addTTFTextObstacles(config: TTFTextObstacleConfig): Promise<TextObstacleResult>;
+    /**
+     * Spawn falling TTF text objects.
+     * Same as addTTFTextObstacles but with 'falling' tag (objects fall with gravity).
+     */
+    spawnFallingTTFTextObstacles(config: TTFTextObstacleConfig): Promise<TextObstacleResult>;
+    removeAllByTag(tag: string): void;
+    removeAll(): void;
+    onUpdate(callback: UpdateCallback): void;
+    /**
+     * Add or update an effect configuration.
+     * Effects are persistent spawning mechanisms that run until disabled.
+     */
+    setEffect(config: EffectConfig): void;
+    /**
+     * Remove an effect by ID
+     */
+    removeEffect(id: string): void;
+    /**
+     * Enable or disable an effect
+     */
+    setEffectEnabled(id: string, enabled: boolean): void;
+    /**
+     * Get an effect configuration by ID
+     */
+    getEffect(id: string): EffectConfig | undefined;
+    /**
+     * Get all effect IDs
+     */
+    getEffectIds(): string[];
+    /**
+     * Check if an effect is currently enabled
+     */
+    isEffectEnabled(id: string): boolean;
+    private loop;
+    /**
+     * Draw debug overlays for letter original dimension boxes
+     */
+    private drawDebugOverlays;
+    /**
+     * Draw TTF glyphs using canvas fillText for clean text rendering
+     */
+    private drawTTFGlyphs;
+    private checkTTLExpiration;
+    /** Despawn objects that have fallen below the floor by the configured distance */
+    private checkDespawnBelowFloor;
+    private fireUpdateCallbacks;
+}
+
+type LogLevel = 'debug' | 'info' | 'warn' | 'error';
+declare function setLogLevel(level: LogLevel): void;
+declare function getLogLevel(): LogLevel;
+declare const logger: {
+    debug(prefix: string, message: string, data?: unknown): void;
+    info(prefix: string, message: string, data?: unknown): void;
+    warn(prefix: string, message: string, data?: unknown): void;
+    error(prefix: string, message: string, data?: unknown): void;
+};
+
+interface Vector2D {
+    x: number;
+    y: number;
+}
+interface GlyphData {
+    vertices: Vector2D[];
+    advanceWidth: number;
+    leftSideBearing: number;
+    boundingBox: {
+        x1: number;
+        y1: number;
+        x2: number;
+        y2: number;
+    } | null;
+}
+interface LoadedFont {
+    font: opentype.Font;
+    unitsPerEm: number;
+    ascender: number;
+    descender: number;
+}
+/**
+ * Load a TTF/OTF font from a URL
+ */
+declare function loadFont(fontUrl: string): Promise<LoadedFont>;
+/**
+ * Get glyph data for a character including vertices and metrics
+ */
+declare function getGlyphData(loadedFont: LoadedFont, char: string, fontSize: number): GlyphData;
+/**
+ * Get kerning adjustment between two characters
+ */
+declare function getKerning(loadedFont: LoadedFont, char1: string, char2: string, fontSize: number): number;
+/**
+ * Calculate total width of a string with proper spacing and kerning
+ */
+declare function measureText(loadedFont: LoadedFont, text: string, fontSize: number): number;
+/**
+ * Clear the font cache
+ */
+declare function clearFontCache(): void;
+
+export { type BaseEffectConfig, type Bounds, type BurstEffectConfig, type ClickToFallConfig, type ContainerOptions, type DespawnEffectConfig, type DynamicObject, type EffectConfig, type EffectObjectConfig, type EffectType, type FloorConfig, type FontInfo, type FontManifest, type GlyphData, type LoadedFont, type ObjectConfig, OverlayScene, type OverlaySceneConfig, type PressureThresholdConfig, type RainEffectConfig, type ShadowConfig, type ShapeConfig, type ShapePreset, type StreamEffectConfig, type TTFTextObstacleConfig, type TextObstacleConfig, type TextObstacleResult, type UpdateCallback, type UpdateCallbackData, type WeightConfig, clearFontCache, getGlyphData, getKerning, getLogLevel, loadFont, logger, measureText, setLogLevel };