@lightningjs/renderer 2.16.0 → 2.18.0

package/src/core/textures/Texture.ts

@@ -103,9 +103,7 @@ export interface TextureData {
 
 export type TextureState =
   | 'initial' // Before anything is loaded
-  | 'fetching' // Fetching or generating texture source
-  | 'fetched' // Texture source is ready
-  | 'loading' // Uploading to GPU
+  | 'loading' // Loading texture data and uploading to GPU
   | 'loaded' // Fully loaded and usable
   | 'failed' // Failed to load
   | 'freed'; // Released and must be reloaded
@@ -139,16 +137,10 @@ export abstract class Texture extends EventEmitter {
   private _dimensions: Dimensions | null = null;
   private _error: Error | null = null;
 
-  /**
-   * Texture states that are considered transitional and should be skipped during cleanup
-   */
-  public static readonly TRANSITIONAL_TEXTURE_STATES: readonly TextureState[] =
-    ['fetching', 'fetched', 'loading'];
-
   // aggregate state
   public state: TextureState = 'initial';
 
-  readonly renderableOwners = new Set<unknown>();
+  readonly renderableOwners: any[] = [];
 
   readonly renderable: boolean = false;
 
@@ -160,6 +152,34 @@ export abstract class Texture extends EventEmitter {
 
   public textureData: TextureData | null = null;
 
+  /**
+   * Memory used by this texture in bytes
+   *
+   * @remarks
+   * This is tracked by the TextureMemoryManager and updated when the texture
+   * is loaded/freed. Set to 0 when texture is not loaded.
+   */
+  public memUsed = 0;
+
+  public retryCount = 0;
+  public maxRetryCount: number | null = null;
+
+  /**
+   * Timestamp when texture was created (for startup grace period)
+   */
+  private createdAt: number = Date.now();
+
+  /**
+   * Flag to track if grace period has expired to avoid repeated Date.now() calls
+   */
+  private gracePeriodExpired: boolean = false;
+
+  /**
+   * Grace period in milliseconds to prevent premature cleanup during app startup
+   * This helps prevent race conditions when bounds calculation is delayed
+   */
+  private static readonly STARTUP_GRACE_PERIOD = 2000; // 2 seconds
+
   constructor(protected txManager: CoreTextureManager) {
     super();
   }
@@ -172,6 +192,59 @@ export abstract class Texture extends EventEmitter {
     return this._error;
   }
 
+  /**
+   * Checks if the texture is within the startup grace period.
+   * During this period, textures are protected from cleanup to prevent
+   * race conditions during app initialization.
+   */
+  isWithinStartupGracePeriod(): boolean {
+    // If grace period already expired, return false immediately
+    if (this.gracePeriodExpired) {
+      return false;
+    }
+
+    // Check if grace period has expired now
+    const hasExpired =
+      Date.now() - this.createdAt >= Texture.STARTUP_GRACE_PERIOD;
+
+    if (hasExpired) {
+      // Cache the result to avoid future Date.now() calls
+      this.gracePeriodExpired = true;
+      return false;
+    }
+
+    return true;
+  }
+
+  /**
+   * Checks if the texture can be safely cleaned up.
+   * Considers the renderable state, startup grace period, and renderable owners.
+   */
+  canBeCleanedUp(): boolean {
+    // Never cleanup if explicitly prevented
+    if (this.preventCleanup) {
+      return false;
+    }
+
+    // Don't cleanup if still within startup grace period
+    if (this.isWithinStartupGracePeriod()) {
+      return false;
+    }
+
+    // Don't cleanup if not renderable
+    if (this.renderable === true) {
+      return false;
+    }
+
+    // Don't cleanup if there are still renderable owners
+    if (this.renderableOwners.length > 0) {
+      return false;
+    }
+
+    // Safe to cleanup
+    return true;
+  }
+
   /**
    * Add/remove an owner to/from the Texture based on its renderability.
    *
@@ -186,33 +259,44 @@ export abstract class Texture extends EventEmitter {
    * @param owner
    * @param renderable
    */
-  setRenderableOwner(owner: unknown, renderable: boolean): void {
-    const oldSize = this.renderableOwners.size;
+  setRenderableOwner(owner: string | number, renderable: boolean): void {
+    const oldSize = this.renderableOwners.length;
+    const hasOwnerIndex = this.renderableOwners.indexOf(owner);
 
     if (renderable === true) {
-      if (this.renderableOwners.has(owner) === false) {
+      if (hasOwnerIndex === -1) {
         // Add the owner to the set
-        this.renderableOwners.add(owner);
+        this.renderableOwners.push(owner);
       }
 
-      const newSize = this.renderableOwners.size;
-      if (newSize > oldSize && newSize === 1) {
+      const newSize = this.renderableOwners.length;
+      if (oldSize !== newSize && newSize === 1) {
         (this.renderable as boolean) = true;
         this.onChangeIsRenderable?.(true);
         this.load();
       }
     } else {
-      this.renderableOwners.delete(owner);
-      const newSize = this.renderableOwners.size;
-      if (newSize < oldSize && newSize === 0) {
+      if (hasOwnerIndex !== -1) {
+        this.renderableOwners.splice(hasOwnerIndex, 1);
+      }
+
+      const newSize = this.renderableOwners.length;
+      if (oldSize !== newSize && newSize === 0) {
         (this.renderable as boolean) = false;
         this.onChangeIsRenderable?.(false);
-        this.txManager.orphanTexture(this);
+
+        // note, not doing a cleanup here, cleanup is managed by the Stage/TextureMemoryManager
+        // when it deems appropriate based on memory pressure
       }
     }
   }
 
   load(): void {
+    if (this.maxRetryCount !== null && this.retryCount > this.maxRetryCount) {
+      // We've exceeded the max retry count, do not attempt to load again
+      return;
+    }
+
     this.txManager.loadTexture(this);
   }
 
@@ -251,6 +335,18 @@ export abstract class Texture extends EventEmitter {
     this.ctxTexture?.free();
   }
 
+  /**
+   * Release the texture data and core context texture for this Texture without changing state.
+   *
+   * @remarks
+   * The ctxTexture is created by the renderer and lives on the GPU.
+   */
+  release(): void {
+    this.ctxTexture?.release();
+    this.ctxTexture = undefined;
+    this.freeTextureData();
+  }
+
   /**
    * Destroy the texture.
    *
@@ -276,7 +372,9 @@ export abstract class Texture extends EventEmitter {
    * e.g. ImageData that is downloaded from a URL.
    */
   freeTextureData(): void {
-    this.textureData = null;
+    queueMicrotask(() => {
+      this.textureData = null;
+    });
   }
 
   public setState(
@@ -289,6 +387,9 @@ export abstract class Texture extends EventEmitter {
 
     let payload: Error | Dimensions | null = null;
     if (state === 'loaded') {
+      // Clear any previous error when successfully loading
+      this._error = null;
+
       if (
         errorOrDimensions !== undefined &&
         'width' in errorOrDimensions === true &&
@@ -303,6 +404,22 @@ export abstract class Texture extends EventEmitter {
     } else if (state === 'failed') {
       this._error = errorOrDimensions as Error;
       payload = this._error;
+
+      // increment the retry count for the texture
+      // this is used to compare against maxRetryCount, if set
+      // to determine if we should try loading again
+      this.retryCount += 1;
+
+      queueMicrotask(() => {
+        this.release();
+      });
+    } else if (state === 'loading') {
+      // Clear error and reset dimensions when starting to load
+      // This ensures stale dimensions from previous loads don't persist
+      this._error = null;
+      this._dimensions = null;
+    } else {
+      this._error = null;
     }
 
     // emit the new state
@@ -373,4 +490,16 @@ export abstract class Texture extends EventEmitter {
   ): Record<string, unknown> {
     return {};
   }
+
+  /**
+   * Retry the texture by resetting retryCount and setting state to 'initial'.
+   *
+   * @remarks
+   * This allows the texture to be loaded again.
+   */
+  public retry(): void {
+    this.release();
+    this.retryCount = 0;
+    this.load();
+  }
 }

package/src/main-api/Inspector.ts

@@ -8,6 +8,8 @@ import type { AnimationSettings } from '../core/animations/CoreAnimation.js';
 import type { IAnimationController } from '../common/IAnimationController.js';
 import { isProductionEnvironment } from '../utils.js';
 import type { CoreTextNode, CoreTextNodeProps } from '../core/CoreTextNode.js';
+import type { Texture } from '../core/textures/Texture.js';
+import { TextureType } from '../core/textures/Texture.js';
 
 /**
  * Inspector
@@ -154,6 +156,22 @@ const gradientColorPropertyMap = [
   'colorBr',
 ];
 
+const textureTypeNames: Record<number, string> = {
+  [TextureType.generic]: 'generic',
+  [TextureType.color]: 'color',
+  [TextureType.image]: 'image',
+  [TextureType.noise]: 'noise',
+  [TextureType.renderToTexture]: 'renderToTexture',
+  [TextureType.subTexture]: 'subTexture',
+};
+
+interface TextureMetrics {
+  previousState: string;
+  loadedCount: number;
+  failedCount: number;
+  freedCount: number;
+}
+
 const knownProperties = new Set<string>([
   ...Object.keys(stylePropertyMap),
   ...Object.keys(domPropertyMap),
@@ -161,6 +179,7 @@ const knownProperties = new Set<string>([
   'src',
   'parent',
   'data',
+  'texture',
 ]);
 
 export class Inspector {
@@ -170,6 +189,7 @@ export class Inspector {
   private width = 1920;
   private scaleX = 1;
   private scaleY = 1;
+  private textureMetrics = new Map<Texture, TextureMetrics>();
 
   constructor(canvas: HTMLCanvasElement, settings: RendererMainSettings) {
     if (isProductionEnvironment()) return;
@@ -284,6 +304,79 @@ export class Inspector {
     node: CoreNode | CoreTextNode,
     div: HTMLElement,
   ): CoreNode | CoreTextNode {
+    // Store texture event listeners for cleanup
+    const textureListeners = new Map<
+      Texture,
+      {
+        onLoaded: () => void;
+        onFailed: () => void;
+        onFreed: () => void;
+      }
+    >();
+
+    // Helper function to setup texture event listeners
+    const setupTextureListeners = (texture: Texture | null) => {
+      // Clean up existing listeners first
+      textureListeners.forEach((listeners, oldTexture) => {
+        oldTexture.off('loaded', listeners.onLoaded);
+        oldTexture.off('failed', listeners.onFailed);
+        oldTexture.off('freed', listeners.onFreed);
+      });
+      textureListeners.clear();
+
+      // Setup new listeners if texture exists
+      if (texture) {
+        // Initialize metrics if not exists
+        if (!this.textureMetrics.has(texture)) {
+          this.textureMetrics.set(texture, {
+            previousState: texture.state,
+            loadedCount: 0,
+            failedCount: 0,
+            freedCount: 0,
+          });
+        }
+
+        const onLoaded = () => {
+          const metrics = this.textureMetrics.get(texture);
+          if (metrics) {
+            metrics.previousState =
+              metrics.previousState !== texture.state
+                ? metrics.previousState
+                : 'loading';
+            metrics.loadedCount++;
+          }
+          this.updateTextureAttributes(div, texture);
+        };
+        const onFailed = () => {
+          const metrics = this.textureMetrics.get(texture);
+          if (metrics) {
+            metrics.previousState =
+              metrics.previousState !== texture.state
+                ? metrics.previousState
+                : 'loading';
+            metrics.failedCount++;
+          }
+          this.updateTextureAttributes(div, texture);
+        };
+        const onFreed = () => {
+          const metrics = this.textureMetrics.get(texture);
+          if (metrics) {
+            metrics.previousState =
+              metrics.previousState !== texture.state
+                ? metrics.previousState
+                : texture.state;
+            metrics.freedCount++;
+          }
+          this.updateTextureAttributes(div, texture);
+        };
+
+        texture.on('loaded', onLoaded);
+        texture.on('failed', onFailed);
+        texture.on('freed', onFreed);
+
+        textureListeners.set(texture, { onLoaded, onFailed, onFreed });
+      }
+    };
     // Define traps for each property in knownProperties
     knownProperties.forEach((property) => {
       let originalProp = Object.getOwnPropertyDescriptor(node, property);
@@ -311,6 +404,15 @@ export class Inspector {
             value,
             node.props,
           );
+
+          // Setup texture event listeners if this is a texture property
+          if (property === 'texture') {
+            const textureValue =
+              value && typeof value === 'object' && 'state' in value
+                ? (value as Texture)
+                : null;
+            setupTextureListeners(textureValue);
+          }
         },
         configurable: true,
         enumerable: true,
@@ -320,11 +422,26 @@ export class Inspector {
     const originalDestroy = node.destroy;
     Object.defineProperty(node, 'destroy', {
       value: () => {
+        // Clean up texture event listeners and metrics
+        textureListeners.forEach((listeners, texture) => {
+          texture.off('loaded', listeners.onLoaded);
+          texture.off('failed', listeners.onFailed);
+          texture.off('freed', listeners.onFreed);
+          // Clean up metrics for this texture
+          this.textureMetrics.delete(texture);
+        });
+        textureListeners.clear();
+
         this.destroyNode(node.id);
         originalDestroy.call(node);
       },
     });
 
+    // Setup initial texture listeners if node already has a texture
+    if (node.texture) {
+      setupTextureListeners(node.texture);
+    }
+
     const originalAnimate = node.animate;
     Object.defineProperty(node, 'animate', {
       value: (
@@ -353,6 +470,75 @@ export class Inspector {
     div?.remove();
   }
 
+  updateTextureAttributes(div: HTMLElement, texture: Texture) {
+    // Update texture state
+    div.setAttribute('data-texture-state', texture.state);
+
+    // Update texture type
+    div.setAttribute(
+      'data-texture-type',
+      textureTypeNames[texture.type] || 'unknown',
+    );
+
+    // Update texture dimensions if available
+    if (texture.dimensions) {
+      div.setAttribute('data-texture-width', String(texture.dimensions.width));
+      div.setAttribute(
+        'data-texture-height',
+        String(texture.dimensions.height),
+      );
+    } else {
+      div.removeAttribute('data-texture-width');
+      div.removeAttribute('data-texture-height');
+    }
+
+    // Update renderable owners count
+    div.setAttribute(
+      'data-texture-owners',
+      String(texture.renderableOwners.length),
+    );
+
+    // Update retry count
+    div.setAttribute('data-texture-retry-count', String(texture.retryCount));
+
+    // Update max retry count if available
+    if (texture.maxRetryCount !== null) {
+      div.setAttribute(
+        'data-texture-max-retry-count',
+        String(texture.maxRetryCount),
+      );
+    } else {
+      div.removeAttribute('data-texture-max-retry-count');
+    }
+
+    // Update metrics if available
+    const metrics = this.textureMetrics.get(texture);
+    if (metrics) {
+      div.setAttribute('data-texture-previous-state', metrics.previousState);
+      div.setAttribute(
+        'data-texture-loaded-count',
+        String(metrics.loadedCount),
+      );
+      div.setAttribute(
+        'data-texture-failed-count',
+        String(metrics.failedCount),
+      );
+      div.setAttribute('data-texture-freed-count', String(metrics.freedCount));
+    } else {
+      div.removeAttribute('data-texture-previous-state');
+      div.removeAttribute('data-texture-loaded-count');
+      div.removeAttribute('data-texture-failed-count');
+      div.removeAttribute('data-texture-freed-count');
+    }
+
+    // Update error information if present
+    if (texture.error) {
+      div.setAttribute('data-texture-error', texture.error.message);
+    } else {
+      div.removeAttribute('data-texture-error');
+    }
+  }
+
   updateNodeProperty(
     div: HTMLElement,
     property: keyof CoreNodeProps | keyof CoreTextNodeProps,
@@ -413,6 +599,23 @@ export class Inspector {
       return;
     }
 
+    // special case for texture information
+    if (property === 'texture') {
+      if (value && typeof value === 'object' && 'state' in value) {
+        const texture = value as Texture;
+        this.updateTextureAttributes(div, texture);
+      } else {
+        // Remove all texture attributes when texture is null
+        div.removeAttribute('data-texture-state');
+        div.removeAttribute('data-texture-type');
+        div.removeAttribute('data-texture-width');
+        div.removeAttribute('data-texture-height');
+        div.removeAttribute('data-texture-owners');
+        div.removeAttribute('data-texture-error');
+      }
+      return;
+    }
+
     // CSS mappable attribute
     if (stylePropertyMap[property]) {
       const mappedStyleResponse = stylePropertyMap[property]?.(value);

package/src/main-api/Renderer.ts

@@ -739,8 +739,6 @@ export class RendererMain extends EventEmitter {
   /**
    * Cleanup textures that are not being used
    *
-   * @param aggressive - If true, will cleanup all textures, regardless of render status
-   *
    * @remarks
    * This can be used to free up GFX memory used by textures that are no longer
    * being displayed.
@@ -754,8 +752,8 @@ export class RendererMain extends EventEmitter {
    * **NOTE3**: This will not cleanup textures that are marked as `preventCleanup`.
    * **NOTE4**: This has nothing to do with the garbage collection of JavaScript.
    */
-  cleanup(aggressive: boolean = false) {
-    this.stage.cleanup(aggressive);
+  cleanup() {
+    this.stage.cleanup();
   }
 
   /**

package/dist/exports/canvas-shaders.d.ts

@@ -1,10 +0,0 @@
-export * from '../src/core/renderers/canvas/CanvasShaderNode.js';
-export { Rounded } from '../src/core/shaders/canvas/Rounded.js';
-export { RoundedWithBorder } from '../src/core/shaders/canvas/RoundedWithBorder.js';
-export { RoundedWithBorderAndShadow } from '../src/core/shaders/canvas/RoundedWithBorderAndShadow.js';
-export { RoundedWithShadow } from '../src/core/shaders/canvas/RoundedWithShadow.js';
-export { Border } from '../src/core/shaders/canvas/Border.js';
-export { Shadow } from '../src/core/shaders/canvas/Shadow.js';
-export { HolePunch } from '../src/core/shaders/canvas/HolePunch.js';
-export { LinearGradient } from '../src/core/shaders/canvas/LinearGradient.js';
-export { RadialGradient } from '../src/core/shaders/canvas/RadialGradient.js';

package/dist/exports/canvas-shaders.js

@@ -1,27 +0,0 @@
-/*
- * Copyright 2023 Comcast Cable Communications Management, LLC
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * SPDX-License-Identifier: Apache-2.0
- */
-export * from '../src/core/renderers/canvas/CanvasShaderNode.js';
-export { Rounded } from '../src/core/shaders/canvas/Rounded.js';
-export { RoundedWithBorder } from '../src/core/shaders/canvas/RoundedWithBorder.js';
-export { RoundedWithBorderAndShadow } from '../src/core/shaders/canvas/RoundedWithBorderAndShadow.js';
-export { RoundedWithShadow } from '../src/core/shaders/canvas/RoundedWithShadow.js';
-export { Border } from '../src/core/shaders/canvas/Border.js';
-export { Shadow } from '../src/core/shaders/canvas/Shadow.js';
-export { HolePunch } from '../src/core/shaders/canvas/HolePunch.js';
-export { LinearGradient } from '../src/core/shaders/canvas/LinearGradient.js';
-export { RadialGradient } from '../src/core/shaders/canvas/RadialGradient.js';
-//# sourceMappingURL=canvas-shaders.js.map

package/dist/exports/canvas-shaders.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"canvas-shaders.js","sourceRoot":"","sources":["../../exports/canvas-shaders.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,cAAc,kDAAkD,CAAC;AAEjE,OAAO,EAAE,OAAO,EAAE,MAAM,uCAAuC,CAAC;AAChE,OAAO,EAAE,iBAAiB,EAAE,MAAM,iDAAiD,CAAC;AACpF,OAAO,EAAE,0BAA0B,EAAE,MAAM,0DAA0D,CAAC;AACtG,OAAO,EAAE,iBAAiB,EAAE,MAAM,iDAAiD,CAAC;AACpF,OAAO,EAAE,MAAM,EAAE,MAAM,sCAAsC,CAAC;AAC9D,OAAO,EAAE,MAAM,EAAE,MAAM,sCAAsC,CAAC;AAC9D,OAAO,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AACpE,OAAO,EAAE,cAAc,EAAE,MAAM,8CAA8C,CAAC;AAC9E,OAAO,EAAE,cAAc,EAAE,MAAM,8CAA8C,CAAC"}

package/dist/exports/webgl-shaders.d.ts

@@ -1,11 +0,0 @@
-export * from '../src/core/renderers/webgl/WebGlShaderNode.js';
-export { Rounded } from '../src/core/shaders/webgl/Rounded.js';
-export { RoundedWithBorder } from '../src/core/shaders/webgl/RoundedWithBorder.js';
-export { RoundedWithBorderAndShadow } from '../src/core/shaders/webgl/RoundedWithBorderAndShadow.js';
-export { RoundedWithShadow } from '../src/core/shaders/webgl/RoundedWithShadow.js';
-export { Border } from '../src/core/shaders/webgl/Border.js';
-export { Shadow } from '../src/core/shaders/webgl/Shadow.js';
-export { HolePunch } from '../src/core/shaders/webgl/HolePunch.js';
-export { LinearGradient } from '../src/core/shaders/webgl/LinearGradient.js';
-export { RadialGradient } from '../src/core/shaders/webgl/RadialGradient.js';
-export { Default } from '../src/core/shaders/webgl/Default.js';

package/dist/exports/webgl-shaders.js

@@ -1,28 +0,0 @@
-/*
- * Copyright 2023 Comcast Cable Communications Management, LLC
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * SPDX-License-Identifier: Apache-2.0
- */
-export * from '../src/core/renderers/webgl/WebGlShaderNode.js';
-export { Rounded } from '../src/core/shaders/webgl/Rounded.js';
-export { RoundedWithBorder } from '../src/core/shaders/webgl/RoundedWithBorder.js';
-export { RoundedWithBorderAndShadow } from '../src/core/shaders/webgl/RoundedWithBorderAndShadow.js';
-export { RoundedWithShadow } from '../src/core/shaders/webgl/RoundedWithShadow.js';
-export { Border } from '../src/core/shaders/webgl/Border.js';
-export { Shadow } from '../src/core/shaders/webgl/Shadow.js';
-export { HolePunch } from '../src/core/shaders/webgl/HolePunch.js';
-export { LinearGradient } from '../src/core/shaders/webgl/LinearGradient.js';
-export { RadialGradient } from '../src/core/shaders/webgl/RadialGradient.js';
-export { Default } from '../src/core/shaders/webgl/Default.js';
-//# sourceMappingURL=webgl-shaders.js.map

package/dist/exports/webgl-shaders.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"webgl-shaders.js","sourceRoot":"","sources":["../../exports/webgl-shaders.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AACH,cAAc,gDAAgD,CAAC;AAE/D,OAAO,EAAE,OAAO,EAAE,MAAM,sCAAsC,CAAC;AAC/D,OAAO,EAAE,iBAAiB,EAAE,MAAM,gDAAgD,CAAC;AACnF,OAAO,EAAE,0BAA0B,EAAE,MAAM,yDAAyD,CAAC;AACrG,OAAO,EAAE,iBAAiB,EAAE,MAAM,gDAAgD,CAAC;AACnF,OAAO,EAAE,MAAM,EAAE,MAAM,qCAAqC,CAAC;AAC7D,OAAO,EAAE,MAAM,EAAE,MAAM,qCAAqC,CAAC;AAC7D,OAAO,EAAE,SAAS,EAAE,MAAM,wCAAwC,CAAC;AACnE,OAAO,EAAE,cAAc,EAAE,MAAM,6CAA6C,CAAC;AAC7E,OAAO,EAAE,cAAc,EAAE,MAAM,6CAA6C,CAAC;AAC7E,OAAO,EAAE,OAAO,EAAE,MAAM,sCAAsC,CAAC"}

package/dist/src/core/platforms/Platform.d.ts

@@ -1,37 +0,0 @@
-import { type Stage } from '../Stage.js';
-export declare abstract class Platform {
-    /**
-     * Creates a new canvas element.
-     * @returns The created HTMLCanvasElement.
-     */
-    abstract createCanvas(): HTMLCanvasElement;
-    /**
-     * Get a DOM element by ID
-     * @returns The DOM element (or null)
-     */
-    abstract getElementById(id: string): HTMLElement | null;
-    /**
-     * Starts the main rendering loop, calling the provided update function every frame.
-     * @param Stage - The stage for rendering
-     */
-    abstract startLoop(stage: Stage): void;
-    /**
-     * Abstracted createImageBitmap method.
-     * @param blob - The image source to create the ImageBitmap from.
-     * @param sxOrOptions - The source rectangle x coordinate or ImageBitmapOptions.
-     * @param sy - The source rectangle y coordinate.
-     * @param sw - The source rectangle width.
-     * @param sh - The source rectangle height.
-     * @param options - The ImageBitmapOptions.
-     * @returns A promise that resolves with the created ImageBitmap.
-     */
-    abstract createImageBitmap(blob: ImageBitmapSource): Promise<ImageBitmap>;
-    abstract createImageBitmap(blob: ImageBitmapSource, options: ImageBitmapOptions): Promise<ImageBitmap>;
-    abstract createImageBitmap(blob: ImageBitmapSource, sx: number, sy: number, sw: number, sh: number): Promise<ImageBitmap>;
-    abstract createImageBitmap(blob: ImageBitmapSource, sx: number, sy: number, sw: number, sh: number, options: ImageBitmapOptions): Promise<ImageBitmap>;
-    /**
-     * Retrieves the current timestamp.
-     * @returns The current timestamp.
-     */
-    abstract getTimeStamp(): number;
-}