vim-web 0.3.23 → 0.3.25

package/dist/types/react-viewer/webgl/webglComponent.d.ts

@@ -0,0 +1,41 @@
+/**
+ * @module public-api
+ */
+import '../style.css';
+import '../../webgl-viewer/style.css';
+import * as VIM from '../../webgl-viewer/index';
+import { PartialComponentSettings } from '../settings/settings';
+import { VimComponentContainer } from '../container';
+import { VimComponentRef } from './webglComponentRef';
+export * as VIM from '../../webgl-viewer/index';
+export * as THREE from 'three';
+export * as ContextMenu from '../panels/contextMenu';
+export * as BimInfo from '../bim/bimInfoData';
+export * as ControlBar from '../controlbar/controlBar';
+export * as Icons from '../panels/icons';
+export * from '../helpers/loadRequest';
+export * from './webglComponentRef';
+export { getLocalComponentSettings as getLocalSettings } from '../settings/settingsStorage';
+export { type ComponentSettings as Settings, type PartialComponentSettings as PartialSettings, defaultSettings } from '../settings/settings';
+export * from '../container';
+/**
+ * Creates a UI container along with a VIM.Viewer and its associated React component.
+ * @param container An optional container object. If none is provided, a container will be created.
+ * @param componentSettings UI Component settings.
+*  @param viewerSettings Viewer settings.
+ * @returns An object containing the resulting container, reactRoot, and viewer.
+ */
+export declare function createWebglComponent(container?: VimComponentContainer | HTMLElement, componentSettings?: PartialComponentSettings, viewerSettings?: VIM.PartialViewerSettings): Promise<VimComponentRef>;
+/**
+ * Represents a React component providing UI for the Vim viewer.
+ * @param container The container object containing root, gfx, and UI elements for the Vim viewer.
+ * @param viewer The Vim viewer instance for which UI is provided.
+ * @param onMount A callback function triggered when the component is mounted. Receives a reference to the Vim component.
+ * @param settings Optional settings for configuring the Vim component's behavior.
+ */
+export declare function VimComponent(props: {
+    container: VimComponentContainer;
+    viewer: VIM.Viewer;
+    onMount: (component: VimComponentRef) => void;
+    settings?: PartialComponentSettings;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/types/react-viewer/webgl/webglComponentRef.d.ts

@@ -0,0 +1,99 @@
+/**
+ * @module public-api
+ */
+import * as VIM from '../../webgl-viewer/index';
+import { ContextMenuCustomization } from '../panels/contextMenu';
+import { ComponentSettings } from '../settings/settings';
+import { Isolation } from '../helpers/isolation';
+import { ComponentCamera } from '../helpers/camera';
+import { VimComponentContainer } from '../container';
+import { BimInfoPanelRef } from '../bim/bimInfoData';
+import { ControlBarCustomization } from '../controlbar/controlBar';
+import { ComponentLoader } from './webglLoading';
+import { ModalRef } from '../panels/modal';
+/**
+* Settings API managing settings applied to the component.
+*/
+export type SettingsRef = {
+    /**
+     * Allows updating settings by providing a callback function.
+     * @param updater A function that updates the current settings.
+     */
+    update: (updater: (settings: ComponentSettings) => void) => void;
+    /**
+     * Registers a callback function to be notified when settings are updated.
+     * @param callback A function to be called when settings are updated, receiving the updated settings.
+     */
+    register: (callback: (settings: ComponentSettings) => void) => void;
+};
+export type ContextMenuRef = {
+    /**
+    * Defines a callback function to dynamically customize the context menu.
+    * @param customization The configuration object specifying the customization options for the context menu.
+    */
+    customize: (customization: ContextMenuCustomization) => void;
+};
+export type ControlBarRef = {
+    /**
+    * Defines a callback function to dynamically customize the control bar.
+    * @param customization The configuration object specifying the customization options for the control bar.
+    */
+    customize: (customization: ControlBarCustomization) => void;
+};
+export type HelpRef = {
+    /**
+     * Displays the help message.
+     * @param value Boolean value to show or hide the help message.
+     */
+    show(value: boolean): any;
+    /**
+     * Returns the current state of the help message.
+     */
+    isShow(): any;
+};
+/**
+ * Root-level API of the Vim component.
+ */
+export type VimComponentRef = {
+    /**
+     * HTML structure containing the component.
+     */
+    container: VimComponentContainer;
+    /**
+    * Vim WebGL viewer around which the WebGL component is built.
+    */
+    viewer: VIM.Viewer;
+    /**
+    * Vim WebGL loader to download VIMs.
+    */
+    loader: ComponentLoader;
+    /**
+    * Isolation API managing isolation state in the component.
+    */
+    isolation: Isolation;
+    /**
+    * Context menu API managing the content and behavior of the context menu.
+    */
+    contextMenu: ContextMenuRef;
+    /**
+  * Context menu API managing the content and behavior of the context menu.
+  */
+    controlBar: ControlBarRef;
+    /**
+    * Settings API managing settings applied to the component.
+    */
+    settings: SettingsRef;
+    /**
+    * Message API to interact with the loading box.
+    */
+    modal: ModalRef;
+    /**
+    * Camera API to interact with the viewer camera at a higher level.
+    */
+    camera: ComponentCamera;
+    /**
+     * API To interact with the BIM info panel.
+     */
+    bimInfo: BimInfoPanelRef;
+    dispose: () => void;
+};

package/dist/types/react-viewer/webgl/webglLoading.d.ts

@@ -0,0 +1,67 @@
+/**
+ * @module viw-webgl-react
+ */
+import * as VIM from '../../webgl-viewer/index';
+import { LoadRequest } from '../helpers/loadRequest';
+import { ModalRef } from '../panels/modal';
+type AddSettings = {
+    /**
+     * Controls whether to frame the camera on a vim everytime it is updated.
+     * Default: true
+     */
+    autoFrame?: boolean;
+    /**
+     * Controls whether to initially load the vim content or not.
+     * Default: false
+     */
+    loadEmpty?: boolean;
+};
+export type OpenSettings = VIM.VimPartialSettings & AddSettings;
+export type LoadingError = {
+    url: string;
+    error: string;
+};
+/**
+ * Provides functionality for asynchronously opening sources and tracking progress.
+ * Includes event emitters for progress updates and completion notifications.
+ */
+export declare class ComponentLoader {
+    private _viewer;
+    private _modal;
+    constructor(viewer: VIM.Viewer, modal: ModalRef);
+    /**
+     * Event emitter for progress updates.
+     */
+    onProgress(p: VIM.IProgressLogs): void;
+    /**
+       * Event emitter for completion notifications.
+     */
+    onDone(): void;
+    /**
+     * Event emitter for error notifications.
+     */
+    onError(e: LoadingError): void;
+    /**
+     * Asynchronously opens a vim at source, applying the provided settings.
+     * @param source The source to open, either as a string or ArrayBuffer.
+     * @param settings Partial settings to apply to the opened source.
+     * @param onProgress Optional callback function to track progress during opening.
+     * Receives progress logs as input.
+     */
+    open(source: VIM.RequestSource, settings: OpenSettings, onProgress?: (p: VIM.IProgressLogs) => void): Promise<VIM.Vim>;
+    /**
+     * Creates a new load request for the provided source and settings.
+     * @param source The url to the vim file or a buffer of the file.
+     * @param settings Settings to apply to vim file.
+     * @returns A new load request instance to track progress and get result.
+     */
+    request(source: VIM.RequestSource, settings: VIM.VimPartialSettings): LoadRequest;
+    add(vim: VIM.Vim, settings?: AddSettings): void;
+    /**
+     * Removes the vim from the viewer and disposes it.
+     * @param vim Vim to remove from the viewer.
+     */
+    remove(vim: VIM.Vim): void;
+    private initVim;
+}
+export {};

package/dist/types/ultra-viewer/ultraViewerIndex.d.ts

@@ -0,0 +1,8 @@
+export * from './viewer/viewer';
+export * as utils from './utils/promise';
+export * from './viewer/vim';
+export * from './viewer/vim';
+export * from './utils/math3d';
+export * from './viewer/color';
+export type { ILoadRequest, VimRequestErrorType } from './viewer/loadRequest';
+export type { ClientState } from './viewer/socketClient';

package/dist/types/ultra-viewer/utils/array.d.ts

@@ -0,0 +1,18 @@
+export declare function invertMap<K, V>(inputMap: Map<K, V>): Map<V, K[]>;
+/**
+ * Batches an array into smaller arrays of a specified size.
+ * @param array - The array to batch.
+ * @param batchSize - The size of each batch.
+ * @returns An array of arrays, each containing a batch of elements.
+ * @throws An error if the batch size is not a positive integer.
+ */
+export declare function batchArray<T>(array: T[], batchSize: number): T[][];
+/**
+ * Batches two arrays simultaneously, maintaining alignment between corresponding elements.
+ * @param array1 - The first array to batch.
+ * @param array2 - The second array to batch.
+ * @param batchSize - The size of each batch.
+ * @returns An array of objects, each containing a batch from each array.
+ * @throws An error if the input arrays are not of the same length.
+ */
+export declare function batchArrays<T, U>(array1: T[], array2: U[], batchSize: number): [T[], U[]][];

package/dist/types/ultra-viewer/utils/debounce.d.ts

@@ -0,0 +1 @@
+export declare function debounce<T extends (...args: any[]) => void>(func: T, delay: number): [(...args: Parameters<T>) => void, () => void];

package/dist/types/ultra-viewer/utils/deferredPromise.d.ts

@@ -0,0 +1,8 @@
+export declare class DeferredPromise<T> extends Promise<T> {
+    resolve: (value: T | PromiseLike<T>) => void;
+    reject: (reason: T | Error) => void;
+    initialCallStack: Error['stack'];
+    constructor(executor?: ConstructorParameters<typeof Promise<T>>[0]);
+    /** @throws error with amended call stack */
+    rejectWithError(error: Error): void;
+}

package/dist/types/ultra-viewer/utils/math3d.d.ts

@@ -0,0 +1,106 @@
+export declare class Vector3 {
+    x: number;
+    y: number;
+    z: number;
+    constructor(x?: number, y?: number, z?: number);
+    set(x: number, y: number, z: number): this;
+    copy(v: Vector3): this;
+    add(v: Vector3): this;
+    sub(v: Vector3): this;
+    multiplyScalar(scalar: number): this;
+    min(v: Vector3): this;
+    max(v: Vector3): this;
+    isValid(): boolean;
+    equals(v: Vector3): boolean;
+    toArray(): number[];
+}
+export declare class Vector2 {
+    x: number;
+    y: number;
+    constructor(x?: number, y?: number);
+    set(x: number, y: number): this;
+    copy(v: Vector2): this;
+    add(v: Vector2): this;
+    sub(v: Vector2): this;
+    multiplyScalar(scalar: number): this;
+    min(v: Vector2): this;
+    max(v: Vector2): this;
+    equals(v: Vector2): boolean;
+    isValid(): boolean;
+    almostEquals(v: Vector2, tolerance?: number): boolean;
+    toArray(): number[];
+    distanceTo(v: Vector2): number;
+    clamp01(): this;
+}
+export declare class Segment {
+    origin: Vector3;
+    target: Vector3;
+    constructor(origin?: Vector3, target?: Vector3);
+    static fromArray(array: number[]): Segment;
+    toArray(): number[];
+    isValid(): boolean;
+    equals(segment: Segment): boolean;
+}
+export declare class Box3 {
+    min: Vector3;
+    max: Vector3;
+    constructor(min?: Vector3, max?: Vector3);
+    static fromArray(array: number[]): Box3;
+    isValid(): boolean;
+    set(min: Vector3, max: Vector3): this;
+    setFromPoints(points: Vector3[]): this;
+    getCenter(target?: Vector3): Vector3;
+    getSize(target?: Vector3): Vector3;
+    containsPoint(point: Vector3): boolean;
+    intersectsBox(box: Box3): boolean;
+    expandByPoint(point: Vector3): this;
+    union(box: Box3): this;
+    toArray(): number[];
+}
+export declare class RGBA {
+    r: number;
+    g: number;
+    b: number;
+    a: number;
+    constructor(r: number, g: number, b: number, a?: number);
+    isValid(): boolean;
+    equals(color: RGBA): boolean;
+    static fromString(str: string): RGBA;
+}
+export declare class RGB {
+    r: number;
+    g: number;
+    b: number;
+    constructor(r: number, g: number, b: number);
+}
+export declare class RGBA32 {
+    readonly hex: number;
+    constructor(hex: number);
+    static fromInts(r: number, g: number, b: number, a?: number): RGBA32;
+    static fromFloats(r: number, g: number, b: number, a?: number): RGBA32;
+    static fromString(str: string): RGBA32;
+    /**
+     * The red component of the color in the range [0-255].
+     */
+    get r(): number;
+    /**
+     * The green component of the color in the range [0-255].
+     */
+    get g(): number;
+    /**
+     * The blue component of the color in the range [0-255].
+     */
+    get b(): number;
+    /**
+     * The alpha component of the color in the range [0-255].
+     */
+    get a(): number;
+}
+/**
+ * Remaps the given value from the range [0-1] to [0-max].
+ */
+export declare function remap(value: number, max: number): number;
+/**
+ * Clamps the given value between the given min and max.
+ */
+export declare function clamp(value: number, min: number, max: number): number;

package/dist/types/ultra-viewer/utils/promise.d.ts

@@ -0,0 +1,21 @@
+export interface IPromise<T> {
+    promise: Promise<T>;
+    resolve(value: T): void;
+    reject(reason?: string): void;
+}
+export declare class ControllablePromise<T> implements IPromise<T> {
+    private _resolve;
+    private _reject;
+    private _promise;
+    constructor();
+    get promise(): Promise<T>;
+    resolve(value: T): void;
+    reject(reason?: string): void;
+}
+export declare class ResolvedPromise<T> implements IPromise<T> {
+    private _value;
+    constructor(value: T);
+    get promise(): Promise<Awaited<T>>;
+    resolve(_: T): void;
+    reject(_?: string): void;
+}

package/dist/types/ultra-viewer/utils/result.d.ts

@@ -0,0 +1,11 @@
+export declare class Result<T, E> {
+    private readonly value;
+    private readonly error;
+    private constructor();
+    static ok<T, E>(value: T): Result<T, E>;
+    static error<T, E>(error: E): Result<T, E>;
+    isOk(): this is Result<T, undefined>;
+    isError(): this is Result<undefined, string>;
+    getValue(): T;
+    getError(): E;
+}

package/dist/types/ultra-viewer/utils/url.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Checks if the given string is a valid URL.
+ * @param str - The string to check.
+ * @returns True if the string is a valid URL; otherwise, false.
+ */
+export declare function isURL(str: string): boolean;
+export declare function isFileURI(inputString: string | null | undefined): boolean;
+export declare function isWebSocketUrl(input: string): boolean;

package/dist/types/ultra-viewer/utils/validation.d.ts

@@ -0,0 +1,28 @@
+import { Box3, RGB, RGBA, Segment, Vector2, Vector3 } from './math3d';
+export declare class Validation {
+    static isNumber(value: number): boolean;
+    static isPositiveNumber(value: number): boolean;
+    static isInteger(value: number): boolean;
+    static isPositiveInteger(value: number): boolean;
+    static isInRange01(value: number): boolean;
+    static areIntegers(values: number[]): boolean;
+    static isComponentHandle(handle: number): boolean;
+    static areComponentHandles(handles: number[]): boolean;
+    static isMaterialHandle(handle: number): boolean;
+    static isValidVector2(value: Vector2): boolean;
+    static isRelativeVector2(value: Vector2): boolean;
+    static isValidVector3(value: Vector3): boolean;
+    static isValidBox(box: Box3): boolean;
+    static isValidSegment(segment: Segment): boolean;
+    static isRelativeRGBA(color: RGBA): boolean;
+    static isRelativeRGB(color: RGB): boolean;
+    static isNonEmptyString(value: string): boolean;
+    static isURL(value: string): boolean;
+    static areSameLength<T1, T2>(array: T1[], array2: T2[]): boolean;
+    static isFullArray(array: any[]): boolean;
+    static clamp(min: number, max: number, value: number): number;
+    static clamp01(value: number): number;
+    static min0(value: number): number;
+    static clampRGBA01(value: RGBA): RGBA;
+    static clampRGB01(value: RGBA): RGBA;
+}

package/dist/types/ultra-viewer/viewer/camera.d.ts

@@ -0,0 +1,118 @@
+import { Box3, Segment } from '../utils/math3d';
+import { RpcSafeClient } from './rpcSafeClient';
+import { Vim } from './vim';
+/**
+ * Interface defining camera control operations in the 3D viewer
+ * @interface
+ */
+export interface ICamera {
+    /**
+     * Frames all Vim models in the viewer to fit within the camera view
+     * @param {number} [blendTime=0.5] - Animation duration in seconds
+     * @returns {Promise<Segment | undefined>} Promise resolving to the final camera position segment
+     */
+    frameAll(blendTime?: number): Promise<Segment | undefined>;
+    /**
+     * Frames a specified bounding box in the viewer
+     * @param {Box3} box - The 3D bounding box to frame
+     * @param {number} [blendTime=0.5] - Animation duration in seconds
+     * @returns {Promise<Segment | undefined>} Promise resolving to the final camera position segment
+     */
+    frameBox(box: Box3, blendTime?: number): Promise<Segment | undefined>;
+    /**
+     * Frames specified nodes of a Vim model in the camera view
+     * @param {Vim} vim - The target Vim model
+     * @param {number[] | 'all'} nodes - Array of node indices or 'all' for entire model
+     * @param {number} [blendTime=0.5] - Animation duration in seconds
+     * @returns {Promise<Segment | undefined>} Promise resolving to the final camera position segment
+     */
+    frameVim(vim: Vim, nodes: number[] | 'all', blendTime?: number): Promise<Segment | undefined>;
+    /**
+     * Saves the current camera position for later restoration
+     * @param {Segment} [segment] - Optional specific camera position to save
+     */
+    save(segment?: Segment): void;
+    /**
+     * Controls the rendering state of the viewer
+     * @param {boolean} value - True to pause, false to resume rendering
+     */
+    pause(value: boolean): void;
+    /**
+     * Restores the camera to its previously saved position
+     * Initially that will be the first call to a Frame method
+     * @param {number} [blendTime=0.5] - Animation duration in seconds
+     */
+    restoreSavedPosition(blendTime?: number): void;
+}
+/**
+ * Implements camera control operations for the 3D viewer
+ * @class
+ */
+export declare class Camera implements ICamera {
+    private _rpc;
+    private _lastPosition;
+    private _interval;
+    private _defaultBlendTime;
+    private _savedPosition;
+    /**
+     * Creates a new Camera instance
+     * @param rpc - RPC client for camera communication
+     */
+    constructor(rpc: RpcSafeClient);
+    /**
+     * Saves the current camera position for later restoration
+     * @param segment - Optional segment to save as the camera position
+     */
+    save(segment?: Segment): Promise<void>;
+    /**
+     * Resets the camera to the last saved position
+     */
+    restoreSavedPosition(blendTime?: number): void;
+    /**
+     * Restores the camera to its last tracked position
+     * @param blendTime - Duration of the camera animation in seconds
+     */
+    restoreLastPosition(blendTime?: number): void;
+    /**
+     * Handles camera initialization when connection is established
+     */
+    onConnect(): void;
+    /**
+     * Starts tracking camera position at regular intervals
+     */
+    startTracking(): void;
+    /**
+     * Stops tracking camera position
+     */
+    stopTracking(): void;
+    /**
+     * Updates the stored camera position
+     * @private
+     */
+    private update;
+    /**
+     * Pauses or resumes rendering
+     * @param value - True to pause rendering, false to resume
+     */
+    pause(value: boolean): void;
+    /**
+     * Frames all vims in the viewer to fit within the camera view
+     * @param blendTime - Duration of the camera animation in seconds (defaults to 0.5)
+     * @returns Promise that resolves when the framing animation is complete
+     */
+    frameAll(blendTime?: number): Promise<Segment | undefined>;
+    /**
+     * Frames a specific bounding box in the viewer
+     * @param box - The 3D bounding box to frame in the camera view
+     * @param blendTime - Duration of the camera animation in seconds (defaults to 0.5)
+     */
+    frameBox(box: Box3, blendTime?: number): Promise<Segment | undefined>;
+    /**
+     * Frames specific nodes of a Vim model in the camera view
+     * @param vim - The Vim model containing the nodes to frame
+     * @param nodes - Array of node indices to frame, or 'all' to frame the entire model
+     * @param blendTime - Duration of the camera animation in seconds (defaults to 0.5)
+     * @returns Promise that resolves when the framing animation is complete
+     */
+    frameVim(vim: Vim, nodes: number[] | 'all', blendTime?: number): Promise<Segment | undefined>;
+}

package/dist/types/ultra-viewer/viewer/color.d.ts

@@ -0,0 +1,57 @@
+import { RGBA32 } from "../utils/math3d";
+import { ColorManager } from "./colorManager";
+/**
+ * Represents a handle to a color in the color management system.
+ * This class provides access to color components and manages the lifecycle of color instances.
+ */
+export declare class ColorHandle {
+    private _manager;
+    /** Unique identifier for the color instance */
+    readonly id: number;
+    /** The RGBA color value */
+    readonly color: RGBA32;
+    private _disposed;
+    /**
+     * Indicates whether the color handle has been disposed.
+     * @returns {boolean} True if the color handle has been disposed, false otherwise.
+     */
+    get disposed(): boolean;
+    /**
+     * Gets the hexadecimal representation of the color.
+     * @returns {number} The color value as a hexadecimal number.
+     */
+    get hex(): number;
+    /**
+     * Gets the red component of the color.
+     * @returns {number} The red component value in the range [0-255].
+     */
+    get r(): number;
+    /**
+     * Gets the green component of the color.
+     * @returns {number} The green component value in the range [0-255].
+     */
+    get g(): number;
+    /**
+     * Gets the blue component of the color.
+     * @returns {number} The blue component value in the range [0-255].
+     */
+    get b(): number;
+    /**
+     * Gets the alpha (opacity) component of the color.
+     * @returns {number} The alpha component value in the range [0-255].
+     */
+    get a(): number;
+    /**
+     * Creates a new ColorHandle instance.
+     * @param {RGBA32} color - The RGBA color value.
+     * @param {number} serverId - The unique identifier assigned by the server.
+     * @param {ColorManager} manager - The color manager instance that manages this color handle.
+     */
+    constructor(color: RGBA32, serverId: number, manager: ColorManager);
+    /**
+     * Disposes of the color handle and releases associated resources.
+     * Once disposed, the color handle cannot be used anymore.
+     * Multiple calls to dispose are safely ignored.
+     */
+    dispose(): void;
+}

package/dist/types/ultra-viewer/viewer/colorManager.d.ts

@@ -0,0 +1,73 @@
+import { RpcSafeClient } from './rpcSafeClient';
+import { ColorHandle } from './color';
+import { RGBA32 } from '../utils/math3d';
+/**
+ * Manages the creation, caching, and deletion of color instances.
+ * Handles batched deletion of colors to optimize RPC calls.
+ */
+export declare class ColorManager {
+    private _rpc;
+    private _hexToColor;
+    private _idToColor;
+    private _toDelete;
+    private _deleteId;
+    /**
+     * Creates a new ColorManager instance.
+     * @param rpc - The RPC client used for communication with the rendering backend
+     */
+    constructor(rpc: RpcSafeClient);
+    /**
+     * Creates or retrieves a cached color instance for the given hex value.
+     * @param hex - The RGBA32 color value
+     * @returns Promise resolving to a ColorHandle, or undefined if creation fails
+     */
+    getColor(hex: RGBA32): Promise<ColorHandle | undefined>;
+    /**
+     * Creates or retrieves cached color instances for multiple hex values.
+     * @param c - Array of RGBA32 color values
+     * @returns Promise resolving to an array of ColorHandles in the same order as input, or undefined if creation fails
+     * @remarks Duplicate hex values will be mapped to the same color instance for efficiency
+     */
+    getColors(c: RGBA32[]): Promise<ColorHandle[]>;
+    /**
+     * Retrieves a color instance by its unique identifier.
+     * @param id - The unique identifier of the color
+     * @returns The ColorHandle associated with the ID, or undefined if not found
+     */
+    getFromId(id: number): ColorHandle;
+    /**
+     * Destroys a color instance and removes it from the cache.
+     * @param color - The ColorHandle to destroy
+     */
+    destroy(color: ColorHandle): void;
+    /**
+     * Destroys all color instances and clears the cache.
+     */
+    clear(): void;
+    /**
+     * Creates multiple color instances via RPC.
+     * @param colors - Array of RGBA32 color values to create
+     * @returns Promise resolving to an array of ColorHandles, or undefined if creation fails
+     * @private
+     */
+    private _createColors;
+    /**
+     * Creates a single color instance and adds it to the cache.
+     * @param color - The RGBA32 color value
+     * @param id - The unique identifier for the color instance
+     * @returns The created ColorHandle
+     * @private
+     */
+    private _createColor;
+    /**
+     * Queues a color for deletion in the next batch.
+     * @param color - The ColorHandle to delete
+     * @private
+     */
+    private _deleteColor;
+    /**
+     * Immediately deletes all queued colors.
+     * @private
+     */
+    private _deleteBatch;
+}