@lightningjs/renderer 2.9.0-beta4 → 2.9.0

package/src/common/IAnimationController.ts

@@ -1,92 +1,92 @@
-/*
- * If not stated otherwise in this file or this component's LICENSE file the
- * following copyright and licenses apply:
- *
- * 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.
- */
-import type { IEventEmitter } from './IEventEmitter.js';
-
-export type AnimationControllerState =
-  | 'scheduled'
-  | 'running'
-  | 'paused'
-  | 'stopped';
-
-/**
- * Animation Controller interface
- *
- * @remarks
- * This interface is used to control animations. It provides methods to start,
- * stop, pause, and restore animations. It also provides a way to wait for the
- * animation to stop.
- *
- * This interface extends the `IEventEmitter` interface, which means you can
- * listen to these events emitted by the animation controller:
- * - `animating` - Emitted when the animation finishes it's delay phase and
- *   starts animating.
- * - `stopped` - Emitted when the animation stops either by calling the `stop()`
- *    method or when the animation finishes naturally.
- */
-export interface IAnimationController extends IEventEmitter {
-  /**
-   * Start the animation
-   *
-   * @remarks
-   * If the animation is paused this method will resume the animation.
-   */
-  start(): IAnimationController;
-  /**
-   * Stop the animation
-   *
-   * @remarks
-   * Resets the animation to the start state
-   */
-  stop(): IAnimationController;
-  /**
-   * Pause the animation
-   */
-  pause(): IAnimationController;
-  /**
-   * Restore the animation to the original values
-   */
-  restore(): IAnimationController;
-
-  /**
-   * Promise that resolves when the last active animation is stopped (including
-   * when the animation finishes naturally).
-   *
-   * @remarks
-   * The Promise returned by this method is reset every time the animation
-   * enters a new start/stop cycle. This means you must call `start()` before
-   * calling this method if you want to wait for the animation to stop.
-   *
-   * This method always returns a resolved promise if the animation is currently
-   * in a stopped state.
-   *
-   * @returns
-   */
-  waitUntilStopped(): Promise<void>;
-
-  /**
-   * Current state of the animation
-   *
-   * @remarks
-   * - `stopped` - The animation is currently stopped (at the beggining or end
-   *   of the animation)
-   * - `running` - The animation is currently running
-   * - `paused` - The animation is currently paused
-   */
-  readonly state: AnimationControllerState;
-}
+/*
+ * If not stated otherwise in this file or this component's LICENSE file the
+ * following copyright and licenses apply:
+ *
+ * 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.
+ */
+import type { IEventEmitter } from './IEventEmitter.js';
+
+export type AnimationControllerState =
+  | 'scheduled'
+  | 'running'
+  | 'paused'
+  | 'stopped';
+
+/**
+ * Animation Controller interface
+ *
+ * @remarks
+ * This interface is used to control animations. It provides methods to start,
+ * stop, pause, and restore animations. It also provides a way to wait for the
+ * animation to stop.
+ *
+ * This interface extends the `IEventEmitter` interface, which means you can
+ * listen to these events emitted by the animation controller:
+ * - `animating` - Emitted when the animation finishes it's delay phase and
+ *   starts animating.
+ * - `stopped` - Emitted when the animation stops either by calling the `stop()`
+ *    method or when the animation finishes naturally.
+ */
+export interface IAnimationController extends IEventEmitter {
+  /**
+   * Start the animation
+   *
+   * @remarks
+   * If the animation is paused this method will resume the animation.
+   */
+  start(): IAnimationController;
+  /**
+   * Stop the animation
+   *
+   * @remarks
+   * Resets the animation to the start state
+   */
+  stop(): IAnimationController;
+  /**
+   * Pause the animation
+   */
+  pause(): IAnimationController;
+  /**
+   * Restore the animation to the original values
+   */
+  restore(): IAnimationController;
+
+  /**
+   * Promise that resolves when the last active animation is stopped (including
+   * when the animation finishes naturally).
+   *
+   * @remarks
+   * The Promise returned by this method is reset every time the animation
+   * enters a new start/stop cycle. This means you must call `start()` before
+   * calling this method if you want to wait for the animation to stop.
+   *
+   * This method always returns a resolved promise if the animation is currently
+   * in a stopped state.
+   *
+   * @returns
+   */
+  waitUntilStopped(): Promise<void>;
+
+  /**
+   * Current state of the animation
+   *
+   * @remarks
+   * - `stopped` - The animation is currently stopped (at the beggining or end
+   *   of the animation)
+   * - `running` - The animation is currently running
+   * - `paused` - The animation is currently paused
+   */
+  readonly state: AnimationControllerState;
+}

package/src/common/IEventEmitter.ts

@@ -1,28 +1,28 @@
-/*
- * 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 interface IEventEmitter<
-  T extends object = { [s: string]: (target: any, data: any) => void },
-> {
-  on<K extends keyof T>(event: Extract<K, string>, listener: T[K]): void;
-  once<K extends keyof T>(event: Extract<K, string>, listener: T[K]): void;
-  off<K extends keyof T>(event: Extract<K, string>, listener: T[K]): void;
-  emit<K extends keyof T>(
-    event: Extract<K, string>,
-    data: Parameters<any>[1],
-  ): void;
-}
+/*
+ * 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 interface IEventEmitter<
+  T extends object = { [s: string]: (target: any, data: any) => void },
+> {
+  on<K extends keyof T>(event: Extract<K, string>, listener: T[K]): void;
+  once<K extends keyof T>(event: Extract<K, string>, listener: T[K]): void;
+  off<K extends keyof T>(event: Extract<K, string>, listener: T[K]): void;
+  emit<K extends keyof T>(
+    event: Extract<K, string>,
+    data: Parameters<any>[1],
+  ): void;
+}

package/src/core/CoreNode.test.ts

@@ -1,199 +1,199 @@
-/*
- * If not stated otherwise in this file or this component's LICENSE file the
- * following copyright and licenses apply:
- *
- * 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.
- */
-
-import { describe, expect, it, vi } from 'vitest';
-import { CoreNode, type CoreNodeProps, UpdateType } from './CoreNode.js';
-import { Stage } from './Stage.js';
-import { mock } from 'vitest-mock-extended';
-import { type TextureOptions } from './CoreTextureManager.js';
-import { type BaseShaderController } from '../main-api/ShaderController';
-import { createBound } from './lib/utils.js';
-import { ImageTexture } from './textures/ImageTexture.js';
-
-const defaultProps: CoreNodeProps = {
-  alpha: 0,
-  autosize: false,
-  clipping: false,
-  color: 0,
-  colorBl: 0,
-  colorBottom: 0,
-  colorBr: 0,
-  colorLeft: 0,
-  colorRight: 0,
-  colorTl: 0,
-  colorTop: 0,
-  colorTr: 0,
-  height: 0,
-  mount: 0,
-  mountX: 0,
-  mountY: 0,
-  parent: null,
-  pivot: 0,
-  pivotX: 0,
-  pivotY: 0,
-  rotation: 0,
-  rtt: false,
-  scale: 0,
-  scaleX: 0,
-  scaleY: 0,
-  shader: mock<BaseShaderController>(),
-  src: '',
-  texture: null,
-  textureOptions: {} as TextureOptions,
-  width: 0,
-  x: 0,
-  y: 0,
-  zIndex: 0,
-  zIndexLocked: 0,
-  preventCleanup: false,
-  strictBounds: false,
-};
-
-const clippingRect = {
-  x: 0,
-  y: 0,
-  width: 200,
-  height: 200,
-  valid: false,
-};
-
-const stage = mock<Stage>({
-  strictBound: createBound(0, 0, 200, 200),
-  preloadBound: createBound(0, 0, 200, 200),
-  defaultTexture: {
-    state: 'loaded',
-  },
-});
-
-describe('set color()', () => {
-  it('should set all color subcomponents.', () => {
-    const node = new CoreNode(stage, defaultProps);
-    node.colorBl = 0x99aabbff;
-    node.colorBr = 0xaabbccff;
-    node.colorTl = 0xbbcceeff;
-    node.colorTr = 0xcceeffff;
-
-    node.color = 0xffffffff;
-
-    expect(node.color).toBe(0xffffffff);
-    expect(node.colorBl).toBe(0xffffffff);
-    expect(node.colorBr).toBe(0xffffffff);
-    expect(node.colorTl).toBe(0xffffffff);
-    expect(node.colorTr).toBe(0xffffffff);
-    expect(node.colorLeft).toBe(0xffffffff);
-    expect(node.colorRight).toBe(0xffffffff);
-    expect(node.colorTop).toBe(0xffffffff);
-    expect(node.colorBottom).toBe(0xffffffff);
-  });
-
-  it('should set update type.', () => {
-    const node = new CoreNode(stage, defaultProps);
-    node.updateType = 0;
-
-    node.color = 0xffffffff;
-
-    expect(node.updateType).toBe(UpdateType.PremultipliedColors);
-  });
-});
-
-describe('isRenderable checks', () => {
-  it('should return false if node is not renderable', () => {
-    const node = new CoreNode(stage, defaultProps);
-    expect(node.isRenderable).toBe(false);
-  });
-
-  it('visible node that is a color texture', () => {
-    const node = new CoreNode(stage, defaultProps);
-    node.alpha = 1;
-    node.x = 0;
-    node.y = 0;
-    node.width = 100;
-    node.height = 100;
-    node.color = 0xffffffff;
-
-    node.update(0, clippingRect);
-    expect(node.isRenderable).toBe(true);
-  });
-
-  it('visible node that is a texture', () => {
-    const node = new CoreNode(stage, defaultProps);
-    node.alpha = 1;
-    node.x = 0;
-    node.y = 0;
-    node.width = 100;
-    node.height = 100;
-    node.texture = mock<ImageTexture>({
-      state: 'initial',
-    });
-
-    node.update(0, clippingRect);
-    expect(node.isRenderable).toBe(false);
-
-    node.texture.state = 'loaded';
-    node.setUpdateType(UpdateType.IsRenderable);
-    node.update(1, clippingRect);
-
-    expect(node.isRenderable).toBe(true);
-  });
-
-  it('a node with a texture with alpha 0 should not be renderable', () => {
-    const node = new CoreNode(stage, defaultProps);
-    node.alpha = 0;
-    node.x = 0;
-    node.y = 0;
-    node.width = 100;
-    node.height = 100;
-    node.texture = mock<ImageTexture>({
-      state: 'loaded',
-    });
-
-    node.update(0, clippingRect);
-    expect(node.isRenderable).toBe(false);
-  });
-
-  it('a node with a texture that is OutOfBounds should not be renderable', () => {
-    const node = new CoreNode(stage, defaultProps);
-    node.alpha = 1;
-    node.x = 300;
-    node.y = 300;
-    node.width = 100;
-    node.height = 100;
-    node.texture = mock<ImageTexture>({
-      state: 'loaded',
-    });
-
-    node.update(0, clippingRect);
-    expect(node.isRenderable).toBe(false);
-  });
-
-  it('a node with a freed texture should not be renderable', () => {
-    const node = new CoreNode(stage, defaultProps);
-    node.alpha = 1;
-    node.x = 0;
-    node.y = 0;
-    node.width = 100;
-    node.height = 100;
-    node.texture = mock<ImageTexture>({
-      state: 'freed',
-    });
-
-    node.update(0, clippingRect);
-    expect(node.isRenderable).toBe(false);
-  });
-});
+/*
+ * If not stated otherwise in this file or this component's LICENSE file the
+ * following copyright and licenses apply:
+ *
+ * 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.
+ */
+
+import { describe, expect, it, vi } from 'vitest';
+import { CoreNode, type CoreNodeProps, UpdateType } from './CoreNode.js';
+import { Stage } from './Stage.js';
+import { mock } from 'vitest-mock-extended';
+import { type TextureOptions } from './CoreTextureManager.js';
+import { type BaseShaderController } from '../main-api/ShaderController';
+import { createBound } from './lib/utils.js';
+import { ImageTexture } from './textures/ImageTexture.js';
+
+const defaultProps: CoreNodeProps = {
+  alpha: 0,
+  autosize: false,
+  clipping: false,
+  color: 0,
+  colorBl: 0,
+  colorBottom: 0,
+  colorBr: 0,
+  colorLeft: 0,
+  colorRight: 0,
+  colorTl: 0,
+  colorTop: 0,
+  colorTr: 0,
+  height: 0,
+  mount: 0,
+  mountX: 0,
+  mountY: 0,
+  parent: null,
+  pivot: 0,
+  pivotX: 0,
+  pivotY: 0,
+  rotation: 0,
+  rtt: false,
+  scale: 0,
+  scaleX: 0,
+  scaleY: 0,
+  shader: mock<BaseShaderController>(),
+  src: '',
+  texture: null,
+  textureOptions: {} as TextureOptions,
+  width: 0,
+  x: 0,
+  y: 0,
+  zIndex: 0,
+  zIndexLocked: 0,
+  preventCleanup: false,
+  strictBounds: false,
+};
+
+const clippingRect = {
+  x: 0,
+  y: 0,
+  width: 200,
+  height: 200,
+  valid: false,
+};
+
+const stage = mock<Stage>({
+  strictBound: createBound(0, 0, 200, 200),
+  preloadBound: createBound(0, 0, 200, 200),
+  defaultTexture: {
+    state: 'loaded',
+  },
+});
+
+describe('set color()', () => {
+  it('should set all color subcomponents.', () => {
+    const node = new CoreNode(stage, defaultProps);
+    node.colorBl = 0x99aabbff;
+    node.colorBr = 0xaabbccff;
+    node.colorTl = 0xbbcceeff;
+    node.colorTr = 0xcceeffff;
+
+    node.color = 0xffffffff;
+
+    expect(node.color).toBe(0xffffffff);
+    expect(node.colorBl).toBe(0xffffffff);
+    expect(node.colorBr).toBe(0xffffffff);
+    expect(node.colorTl).toBe(0xffffffff);
+    expect(node.colorTr).toBe(0xffffffff);
+    expect(node.colorLeft).toBe(0xffffffff);
+    expect(node.colorRight).toBe(0xffffffff);
+    expect(node.colorTop).toBe(0xffffffff);
+    expect(node.colorBottom).toBe(0xffffffff);
+  });
+
+  it('should set update type.', () => {
+    const node = new CoreNode(stage, defaultProps);
+    node.updateType = 0;
+
+    node.color = 0xffffffff;
+
+    expect(node.updateType).toBe(UpdateType.PremultipliedColors);
+  });
+});
+
+describe('isRenderable checks', () => {
+  it('should return false if node is not renderable', () => {
+    const node = new CoreNode(stage, defaultProps);
+    expect(node.isRenderable).toBe(false);
+  });
+
+  it('visible node that is a color texture', () => {
+    const node = new CoreNode(stage, defaultProps);
+    node.alpha = 1;
+    node.x = 0;
+    node.y = 0;
+    node.width = 100;
+    node.height = 100;
+    node.color = 0xffffffff;
+
+    node.update(0, clippingRect);
+    expect(node.isRenderable).toBe(true);
+  });
+
+  it('visible node that is a texture', () => {
+    const node = new CoreNode(stage, defaultProps);
+    node.alpha = 1;
+    node.x = 0;
+    node.y = 0;
+    node.width = 100;
+    node.height = 100;
+    node.texture = mock<ImageTexture>({
+      state: 'initial',
+    });
+
+    node.update(0, clippingRect);
+    expect(node.isRenderable).toBe(false);
+
+    node.texture.state = 'loaded';
+    node.setUpdateType(UpdateType.IsRenderable);
+    node.update(1, clippingRect);
+
+    expect(node.isRenderable).toBe(true);
+  });
+
+  it('a node with a texture with alpha 0 should not be renderable', () => {
+    const node = new CoreNode(stage, defaultProps);
+    node.alpha = 0;
+    node.x = 0;
+    node.y = 0;
+    node.width = 100;
+    node.height = 100;
+    node.texture = mock<ImageTexture>({
+      state: 'loaded',
+    });
+
+    node.update(0, clippingRect);
+    expect(node.isRenderable).toBe(false);
+  });
+
+  it('a node with a texture that is OutOfBounds should not be renderable', () => {
+    const node = new CoreNode(stage, defaultProps);
+    node.alpha = 1;
+    node.x = 300;
+    node.y = 300;
+    node.width = 100;
+    node.height = 100;
+    node.texture = mock<ImageTexture>({
+      state: 'loaded',
+    });
+
+    node.update(0, clippingRect);
+    expect(node.isRenderable).toBe(false);
+  });
+
+  it('a node with a freed texture should not be renderable', () => {
+    const node = new CoreNode(stage, defaultProps);
+    node.alpha = 1;
+    node.x = 0;
+    node.y = 0;
+    node.width = 100;
+    node.height = 100;
+    node.texture = mock<ImageTexture>({
+      state: 'freed',
+    });
+
+    node.update(0, clippingRect);
+    expect(node.isRenderable).toBe(false);
+  });
+});