@lightningjs/renderer 0.7.4 → 0.7.6

package/src/core/animations/CoreAnimationController.ts

@@ -1,148 +1,148 @@
-/*
- * 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 {
-  AnimationControllerState,
-  IAnimationController,
-} from '../../common/IAnimationController.js';
-import type { AnimationManager } from './AnimationManager.js';
-import type { CoreAnimation } from './CoreAnimation.js';
-import { assertTruthy } from '../../utils.js';
-
-export class CoreAnimationController implements IAnimationController {
-  startedPromise: Promise<void> | null = null;
-  /**
-   * If this is null, then the animation hasn't started yet.
-   */
-  startedResolve: ((scope?: any) => void) | null = null;
-
-  stoppedPromise: Promise<void> | null = null;
-  /**
-   * If this is null, then the animation is in a finished / stopped state.
-   */
-  stoppedResolve: (() => void) | null = null;
-
-  constructor(
-    private manager: AnimationManager,
-    private animation: CoreAnimation,
-  ) {
-    this.state = 'stopped';
-  }
-
-  state: AnimationControllerState;
-
-  start(): IAnimationController {
-    this.makeStartedPromise();
-    this.animation.once('start', this.started.bind(this));
-
-    this.makeStoppedPromise();
-    this.animation.once('finished', this.finished.bind(this));
-
-    // prevent registering the same animation twice
-    if (!this.manager.activeAnimations.has(this.animation)) {
-      this.manager.registerAnimation(this.animation);
-    }
-
-    this.state = 'running';
-    return this;
-  }
-
-  stop(): IAnimationController {
-    this.manager.unregisterAnimation(this.animation);
-    if (this.stoppedResolve !== null) {
-      this.stoppedResolve();
-      this.stoppedResolve = null;
-    }
-    this.animation.reset();
-    this.state = 'stopped';
-    return this;
-  }
-
-  pause(): IAnimationController {
-    this.manager.unregisterAnimation(this.animation);
-    this.state = 'paused';
-    return this;
-  }
-
-  restore(): IAnimationController {
-    this.stoppedResolve = null;
-    this.animation.restore();
-    return this;
-  }
-
-  waitUntilStarted(): Promise<void> {
-    this.makeStartedPromise();
-    const promise = this.startedPromise;
-    assertTruthy(promise);
-    return promise;
-  }
-
-  waitUntilStopped(): Promise<void> {
-    this.makeStoppedPromise();
-    const promise = this.stoppedPromise;
-    assertTruthy(promise);
-    return promise;
-  }
-
-  private makeStartedPromise(): void {
-    if (this.startedResolve === null) {
-      this.startedPromise = new Promise((resolve) => {
-        this.startedResolve = resolve;
-      });
-    }
-  }
-
-  private makeStoppedPromise(): void {
-    if (this.stoppedResolve === null) {
-      this.stoppedPromise = new Promise((resolve) => {
-        this.stoppedResolve = resolve;
-      });
-    }
-  }
-
-  private started(): void {
-    assertTruthy(this.startedResolve);
-    // resolve promise (and pass current this to continue to the chain)
-    this.startedResolve(this);
-    this.startedResolve = null;
-  }
-
-  private finished(): void {
-    assertTruthy(this.stoppedResolve);
-    // If the animation is looping, then we need to restart it.
-    const { loop, stopMethod } = this.animation.settings;
-
-    if (stopMethod === 'reverse') {
-      this.animation.reverse();
-      this.start();
-      return;
-    }
-
-    // resolve promise
-    this.stoppedResolve();
-    this.stoppedResolve = null;
-
-    if (loop) {
-      return;
-    }
-
-    // unregister animation
-    this.manager.unregisterAnimation(this.animation);
-  }
-}
+/*
+ * 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 {
+  AnimationControllerState,
+  IAnimationController,
+} from '../../common/IAnimationController.js';
+import type { AnimationManager } from './AnimationManager.js';
+import type { CoreAnimation } from './CoreAnimation.js';
+import { assertTruthy } from '../../utils.js';
+
+export class CoreAnimationController implements IAnimationController {
+  startedPromise: Promise<void> | null = null;
+  /**
+   * If this is null, then the animation hasn't started yet.
+   */
+  startedResolve: ((scope?: any) => void) | null = null;
+
+  stoppedPromise: Promise<void> | null = null;
+  /**
+   * If this is null, then the animation is in a finished / stopped state.
+   */
+  stoppedResolve: (() => void) | null = null;
+
+  constructor(
+    private manager: AnimationManager,
+    private animation: CoreAnimation,
+  ) {
+    this.state = 'stopped';
+  }
+
+  state: AnimationControllerState;
+
+  start(): IAnimationController {
+    this.makeStartedPromise();
+    this.animation.once('start', this.started.bind(this));
+
+    this.makeStoppedPromise();
+    this.animation.once('finished', this.finished.bind(this));
+
+    // prevent registering the same animation twice
+    if (!this.manager.activeAnimations.has(this.animation)) {
+      this.manager.registerAnimation(this.animation);
+    }
+
+    this.state = 'running';
+    return this;
+  }
+
+  stop(): IAnimationController {
+    this.manager.unregisterAnimation(this.animation);
+    if (this.stoppedResolve !== null) {
+      this.stoppedResolve();
+      this.stoppedResolve = null;
+    }
+    this.animation.reset();
+    this.state = 'stopped';
+    return this;
+  }
+
+  pause(): IAnimationController {
+    this.manager.unregisterAnimation(this.animation);
+    this.state = 'paused';
+    return this;
+  }
+
+  restore(): IAnimationController {
+    this.stoppedResolve = null;
+    this.animation.restore();
+    return this;
+  }
+
+  waitUntilStarted(): Promise<void> {
+    this.makeStartedPromise();
+    const promise = this.startedPromise;
+    assertTruthy(promise);
+    return promise;
+  }
+
+  waitUntilStopped(): Promise<void> {
+    this.makeStoppedPromise();
+    const promise = this.stoppedPromise;
+    assertTruthy(promise);
+    return promise;
+  }
+
+  private makeStartedPromise(): void {
+    if (this.startedResolve === null) {
+      this.startedPromise = new Promise((resolve) => {
+        this.startedResolve = resolve;
+      });
+    }
+  }
+
+  private makeStoppedPromise(): void {
+    if (this.stoppedResolve === null) {
+      this.stoppedPromise = new Promise((resolve) => {
+        this.stoppedResolve = resolve;
+      });
+    }
+  }
+
+  private started(): void {
+    assertTruthy(this.startedResolve);
+    // resolve promise (and pass current this to continue to the chain)
+    this.startedResolve(this);
+    this.startedResolve = null;
+  }
+
+  private finished(): void {
+    assertTruthy(this.stoppedResolve);
+    // If the animation is looping, then we need to restart it.
+    const { loop, stopMethod } = this.animation.settings;
+
+    if (stopMethod === 'reverse') {
+      this.animation.reverse();
+      this.start();
+      return;
+    }
+
+    // resolve promise
+    this.stoppedResolve();
+    this.stoppedResolve = null;
+
+    if (loop) {
+      return;
+    }
+
+    // unregister animation
+    this.manager.unregisterAnimation(this.animation);
+  }
+}

package/src/core/lib/ContextSpy.ts

@@ -1,41 +1,41 @@
-/*
- * 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.
- */
-
-/**
- * Class that keeps track of the invocations of Context methods when
- * the `enableContextSpy` renderer option is enabled.
- */
-export class ContextSpy {
-  private data: Record<string, number> = {};
-
-  reset() {
-    this.data = {};
-  }
-
-  increment(name: string) {
-    if (!this.data[name]) {
-      this.data[name] = 0;
-    }
-    this.data[name]++;
-  }
-
-  getData() {
-    return { ...this.data };
-  }
-}
+/*
+ * 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.
+ */
+
+/**
+ * Class that keeps track of the invocations of Context methods when
+ * the `enableContextSpy` renderer option is enabled.
+ */
+export class ContextSpy {
+  private data: Record<string, number> = {};
+
+  reset() {
+    this.data = {};
+  }
+
+  increment(name: string) {
+    if (!this.data[name]) {
+      this.data[name] = 0;
+    }
+    this.data[name]++;
+  }
+
+  getData() {
+    return { ...this.data };
+  }
+}

package/src/core/lib/ImageWorker.ts

@@ -1,135 +1,149 @@
-/*
- * 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 TextureData } from '../textures/Texture.js';
-
-type MessageCallback = [(value: any) => void, (reason: any) => void];
-
-export class ImageWorkerManager {
-  isWorkerSupported = !!self.Worker;
-  imageWorkersEnabled = true;
-  messageManager: Record<string, MessageCallback> = {};
-  workers: Worker[] = [];
-  workerIndex = 0;
-
-  constructor(numImageWorkers: number) {
-    if (this.isWorkerSupported && numImageWorkers > 0) {
-      this.workers = this.createWorkers(numImageWorkers);
-      this.workers.forEach((worker) => {
-        worker.onmessage = this.handleMessage.bind(this);
-      });
-    } else {
-      this.imageWorkersEnabled = false;
-    }
-  }
-
-  private handleMessage(event: MessageEvent) {
-    const { src, data, error } = event.data as {
-      src: string;
-      data?: any;
-      error?: string;
-    };
-    const msg = this.messageManager[src];
-    if (msg) {
-      const [resolve, reject] = msg;
-      delete this.messageManager[src];
-      if (error) {
-        reject(new Error(error));
-      } else {
-        resolve(data);
-      }
-    }
-  }
-
-  private createWorkers(numWorkers = 1): Worker[] {
-    const workerCode = `
-      function hasAlphaChannel(mimeType) {
-          return (mimeType.indexOf("image/png") !== -1);
-      }
-
-      async function getImage(src, premultiplyAlpha) {
-        const response = await fetch(src);
-        const blob = await response.blob();
-        const hasAlphaChannel = premultiplyAlpha ?? this.hasAlphaChannel(blob.type);
-
-        const data = await createImageBitmap(blob, {
-          premultiplyAlpha: hasAlphaChannel ? 'premultiply' : 'none',
-          colorSpaceConversion: 'none',
-          imageOrientation: 'none',
-        });
-
-        return { data, premultiplyAlpha };
-      }
-
-      self.onmessage = async (event) => {
-        const { src, premultiplyAlpha } = event.data;
-
-        try {
-          const data = await getImage(src, premultiplyAlpha);
-          self.postMessage({ src, data }, [data.data]);
-        } catch (error) {
-          self.postMessage({ src, error: error.message });
-        }
-      };
-    `;
-
-    const blob: Blob = new Blob([workerCode.replace('"use strict";', '')], {
-      type: 'application/javascript',
-    });
-    const blobURL: string = (window.URL ? URL : webkitURL).createObjectURL(
-      blob,
-    );
-    const workers: Worker[] = [];
-    for (let i = 0; i < numWorkers; i++) {
-      workers.push(new Worker(blobURL));
-    }
-    return workers;
-  }
-
-  private getNextWorker(): Worker {
-    const worker = this.workers[this.workerIndex];
-    this.workerIndex = (this.workerIndex + 1) % this.workers.length;
-    return worker!;
-  }
-
-  private convertUrlToAbsolute(url: string): string {
-    const absoluteUrl = new URL(url, self.location.href);
-    return absoluteUrl.href;
-  }
-
-  getImage(
-    src: string,
-    premultiplyAlpha: boolean | null,
-  ): Promise<TextureData> {
-    return new Promise((resolve, reject) => {
-      try {
-        if (this.workers) {
-          const absoluteSrcUrl = this.convertUrlToAbsolute(src);
-          this.messageManager[absoluteSrcUrl] = [resolve, reject];
-          this.getNextWorker().postMessage({
-            src: absoluteSrcUrl,
-            premultiplyAlpha,
-          });
-        }
-      } catch (error) {
-        reject(error);
-      }
-    });
-  }
-}
+/*
+ * 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 TextureData } from '../textures/Texture.js';
+
+type MessageCallback = [(value: any) => void, (reason: any) => void];
+
+export class ImageWorkerManager {
+  imageWorkersEnabled = true;
+  messageManager: Record<string, MessageCallback> = {};
+  workers: Worker[] = [];
+  workerIndex = 0;
+
+  constructor(numImageWorkers: number) {
+    this.workers = this.createWorkers(numImageWorkers);
+    this.workers.forEach((worker) => {
+      worker.onmessage = this.handleMessage.bind(this);
+    });
+  }
+
+  private handleMessage(event: MessageEvent) {
+    const { src, data, error } = event.data as {
+      src: string;
+      data?: any;
+      error?: string;
+    };
+    const msg = this.messageManager[src];
+    if (msg) {
+      const [resolve, reject] = msg;
+      delete this.messageManager[src];
+      if (error) {
+        reject(new Error(error));
+      } else {
+        resolve(data);
+      }
+    }
+  }
+
+  private createWorkers(numWorkers = 1): Worker[] {
+    const workerCode = `
+      function hasAlphaChannel(mimeType) {
+          return (mimeType.indexOf("image/png") !== -1);
+      }
+
+      async function getImage(src, premultiplyAlpha) {
+        return new Promise(function(resolve, reject) {
+          var xhr = new XMLHttpRequest();
+          xhr.open('GET', src, true);
+          xhr.responseType = 'blob';
+
+          xhr.onload = function() {
+            if (xhr.status === 200) {
+              var blob = xhr.response;
+              var hasAlphaChannel = premultiplyAlpha !== undefined ? premultiplyAlpha : hasAlphaChannel(blob.type);
+
+              createImageBitmap(blob, {
+                premultiplyAlpha: hasAlphaChannel ? 'premultiply' : 'none',
+                colorSpaceConversion: 'none',
+                imageOrientation: 'none'
+              }).then(function(data) {
+                resolve({ data: data, premultiplyAlpha: premultiplyAlpha });
+              }).catch(function(error) {
+                reject(error);
+              });
+            } else {
+              reject(new Error('Failed to load image: ' + xhr.statusText));
+            }
+          };
+
+          xhr.onerror = function() {
+            reject(new Error('Network error occurred while trying to fetch the image.'));
+          };
+
+          xhr.send();
+        });
+      }
+
+      self.onmessage = async (event) => {
+        var src = event.data.src;
+        var premultiplyAlpha = event.data.premultiplyAlpha;
+
+        getImage(src, premultiplyAlpha)
+          .then(function(data) {
+              self.postMessage({ src: src, data: data }, [data.data]);
+          })
+          .catch(function(error) {
+              self.postMessage({ src: src, error: error.message });
+          });
+      };
+    `;
+
+    const blob: Blob = new Blob([workerCode.replace('"use strict";', '')], {
+      type: 'application/javascript',
+    });
+    const blobURL: string = (self.URL ? URL : webkitURL).createObjectURL(blob);
+    const workers: Worker[] = [];
+    for (let i = 0; i < numWorkers; i++) {
+      workers.push(new Worker(blobURL));
+    }
+    return workers;
+  }
+
+  private getNextWorker(): Worker {
+    const worker = this.workers[this.workerIndex];
+    this.workerIndex = (this.workerIndex + 1) % this.workers.length;
+    return worker!;
+  }
+
+  private convertUrlToAbsolute(url: string): string {
+    const absoluteUrl = new URL(url, self.location.href);
+    return absoluteUrl.href;
+  }
+
+  getImage(
+    src: string,
+    premultiplyAlpha: boolean | null,
+  ): Promise<TextureData> {
+    return new Promise((resolve, reject) => {
+      try {
+        if (this.workers) {
+          const absoluteSrcUrl = this.convertUrlToAbsolute(src);
+          this.messageManager[absoluteSrcUrl] = [resolve, reject];
+          this.getNextWorker().postMessage({
+            src: absoluteSrcUrl,
+            premultiplyAlpha,
+          });
+        }
+      } catch (error) {
+        reject(error);
+      }
+    });
+  }
+}