@lightningjs/renderer 3.0.0-beta4 → 3.0.0-beta5

package/src/core/shaders/canvas/Rounded.ts

@@ -1,55 +1,55 @@
-/*
- * 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
- */
-
-import { calcFactoredRadiusArray } from '../../lib/utils.js';
-import type { CanvasShaderType } from '../../renderers/canvas/CanvasShaderNode.js';
-import type { Vec4 } from '../../renderers/webgl/internal/ShaderUtils.js';
-import {
-  RoundedTemplate,
-  type RoundedProps,
-} from '../templates/RoundedTemplate.js';
-import { roundRect } from './utils/render.js';
-
-export interface ComputedRoundedValues {
-  radius: Vec4;
-}
-
-export const Rounded: CanvasShaderType<RoundedProps, ComputedRoundedValues> = {
-  props: RoundedTemplate.props,
-  saveAndRestore: true,
-  update(node) {
-    this.computed.radius = calcFactoredRadiusArray(
-      this.props!.radius as Vec4,
-      node.width,
-      node.height,
-    );
-  },
-  render(ctx, quad, renderContext) {
-    const path = new Path2D();
-    roundRect(
-      path,
-      quad.tx,
-      quad.ty,
-      quad.width,
-      quad.height,
-      this.computed.radius!,
-    );
-    ctx.clip(path);
-
-    renderContext();
-  },
-};
+/*
+ * 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
+ */
+
+import { calcFactoredRadiusArray } from '../../lib/utils.js';
+import type { CanvasShaderType } from '../../renderers/canvas/CanvasShaderNode.js';
+import type { Vec4 } from '../../renderers/webgl/internal/ShaderUtils.js';
+import {
+  RoundedTemplate,
+  type RoundedProps,
+} from '../templates/RoundedTemplate.js';
+import { roundRect } from './utils/render.js';
+
+export interface ComputedRoundedValues {
+  radius: Vec4;
+}
+
+export const Rounded: CanvasShaderType<RoundedProps, ComputedRoundedValues> = {
+  props: RoundedTemplate.props,
+  saveAndRestore: true,
+  update(node) {
+    this.computed.radius = calcFactoredRadiusArray(
+      this.props!.radius as Vec4,
+      node.width,
+      node.height,
+    );
+  },
+  render(ctx, quad, renderContext) {
+    const path = new Path2D();
+    roundRect(
+      path,
+      quad.tx,
+      quad.ty,
+      quad.width,
+      quad.height,
+      this.computed.radius!,
+    );
+    ctx.clip(path);
+
+    renderContext();
+  },
+};

package/src/core/shaders/canvas/RoundedWithBorder.ts

@@ -1,68 +1,68 @@
-/*
- * 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
- */
-
-import { calcFactoredRadiusArray, valuesAreEqual } from '../../lib/utils.js';
-import type { CanvasShaderType } from '../../renderers/canvas/CanvasShaderNode.js';
-import type { Vec4 } from '../../renderers/webgl/internal/ShaderUtils.js';
-import {
-  RoundedWithBorderTemplate,
-  type RoundedWithBorderProps,
-} from '../templates/RoundedWithBorderTemplate.js';
-import type { ComputedBorderValues } from './Border.js';
-import type { ComputedRoundedValues } from './Rounded.js';
-import { roundedRectWithBorder } from './utils/render.js';
-
-type ComputedValues = ComputedRoundedValues & ComputedBorderValues;
-
-export const RoundedWithBorder: CanvasShaderType<
-  RoundedWithBorderProps,
-  ComputedValues
-> = {
-  props: RoundedWithBorderTemplate.props,
-  saveAndRestore: true,
-  update(node) {
-    const radius = calcFactoredRadiusArray(
-      this.props!.radius as Vec4,
-      node.width,
-      node.height,
-    );
-    this.computed.radius = radius;
-    this.computed.borderColor = this.toColorString(this.props!['border-color']);
-    this.computed.borderAsym = !valuesAreEqual(
-      this.props!['border-width'] as number[],
-    );
-    const borderWidth = this.props!['border-width'] as Vec4;
-    this.computed.borderRadius = radius.map((value, index) =>
-      Math.max(0, value - borderWidth[index]! * 0.5),
-    ) as Vec4;
-  },
-  render(ctx, quad, renderContext) {
-    roundedRectWithBorder(
-      ctx,
-      quad.tx,
-      quad.ty,
-      quad.width,
-      quad.height,
-      this.computed.radius!,
-      this.props!['border-width'] as Vec4,
-      this.computed.borderRadius!,
-      this.computed.borderColor!,
-      this.computed.borderAsym!,
-      renderContext,
-    );
-  },
-};
+/*
+ * 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
+ */
+
+import { calcFactoredRadiusArray, valuesAreEqual } from '../../lib/utils.js';
+import type { CanvasShaderType } from '../../renderers/canvas/CanvasShaderNode.js';
+import type { Vec4 } from '../../renderers/webgl/internal/ShaderUtils.js';
+import {
+  RoundedWithBorderTemplate,
+  type RoundedWithBorderProps,
+} from '../templates/RoundedWithBorderTemplate.js';
+import type { ComputedBorderValues } from './Border.js';
+import type { ComputedRoundedValues } from './Rounded.js';
+import { roundedRectWithBorder } from './utils/render.js';
+
+type ComputedValues = ComputedRoundedValues & ComputedBorderValues;
+
+export const RoundedWithBorder: CanvasShaderType<
+  RoundedWithBorderProps,
+  ComputedValues
+> = {
+  props: RoundedWithBorderTemplate.props,
+  saveAndRestore: true,
+  update(node) {
+    const radius = calcFactoredRadiusArray(
+      this.props!.radius as Vec4,
+      node.width,
+      node.height,
+    );
+    this.computed.radius = radius;
+    this.computed.borderColor = this.toColorString(this.props!['border-color']);
+    this.computed.borderAsym = !valuesAreEqual(
+      this.props!['border-width'] as number[],
+    );
+    const borderWidth = this.props!['border-width'] as Vec4;
+    this.computed.borderRadius = radius.map((value, index) =>
+      Math.max(0, value - borderWidth[index]! * 0.5),
+    ) as Vec4;
+  },
+  render(ctx, quad, renderContext) {
+    roundedRectWithBorder(
+      ctx,
+      quad.tx,
+      quad.ty,
+      quad.width,
+      quad.height,
+      this.computed.radius!,
+      this.props!['border-width'] as Vec4,
+      this.computed.borderRadius!,
+      this.computed.borderColor!,
+      this.computed.borderAsym!,
+      renderContext,
+    );
+  },
+};

package/src/core/shaders/canvas/RoundedWithBorderAndShadow.ts

@@ -1,88 +1,88 @@
-/*
- * 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
- */
-
-import { calcFactoredRadiusArray, valuesAreEqual } from '../../lib/utils.js';
-import type { CanvasShaderType } from '../../renderers/canvas/CanvasShaderNode.js';
-import type { Vec4 } from '../../renderers/webgl/internal/ShaderUtils.js';
-import {
-  RoundedWithBorderAndShadowTemplate,
-  type RoundedWithBorderAndShadowProps,
-} from '../templates/RoundedWithBorderAndShadowTemplate.js';
-import type { ComputedBorderValues } from './Border.js';
-import type { ComputedRoundedValues } from './Rounded.js';
-import type { ComputedShadowValues } from './Shadow.js';
-import * as render from './utils/render.js';
-
-type ComputedValues = ComputedRoundedValues &
-  ComputedBorderValues &
-  ComputedShadowValues;
-
-export const RoundedWithBorderAndShadow: CanvasShaderType<
-  RoundedWithBorderAndShadowProps,
-  ComputedValues
-> = {
-  props: RoundedWithBorderAndShadowTemplate.props,
-  saveAndRestore: true,
-  update(node) {
-    const radius = calcFactoredRadiusArray(
-      this.props!.radius as Vec4,
-      node.width,
-      node.height,
-    );
-    this.computed.radius = radius;
-    this.computed.borderColor = this.toColorString(this.props!['border-color']);
-    this.computed.borderAsym = !valuesAreEqual(
-      this.props!['border-width'] as number[],
-    );
-    const borderWidth = this.props!['border-width'] as Vec4;
-    this.computed.borderRadius = radius.map((value, index) =>
-      Math.max(0, value - borderWidth[index]! * 0.5),
-    ) as Vec4;
-
-    this.computed.shadowColor = this.toColorString(this.props!['shadow-color']);
-    this.computed.shadowRadius = radius.map(
-      (value) => value + this.props!['shadow-blur'],
-    ) as Vec4;
-  },
-  render(ctx, quad, renderContext) {
-    const { tx, ty, width, height } = quad;
-    render.shadow(
-      ctx,
-      tx,
-      ty,
-      height,
-      width,
-      this.computed.shadowColor!,
-      this.props!['shadow-projection'],
-      this.computed.shadowRadius!,
-      this.stage.pixelRatio,
-    );
-    render.roundedRectWithBorder(
-      ctx,
-      quad.tx,
-      quad.ty,
-      quad.width,
-      quad.height,
-      this.computed.radius!,
-      this.props!['border-width'] as Vec4,
-      this.computed.borderRadius!,
-      this.computed.borderColor!,
-      this.computed.borderAsym!,
-      renderContext,
-    );
-  },
-};
+/*
+ * 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
+ */
+
+import { calcFactoredRadiusArray, valuesAreEqual } from '../../lib/utils.js';
+import type { CanvasShaderType } from '../../renderers/canvas/CanvasShaderNode.js';
+import type { Vec4 } from '../../renderers/webgl/internal/ShaderUtils.js';
+import {
+  RoundedWithBorderAndShadowTemplate,
+  type RoundedWithBorderAndShadowProps,
+} from '../templates/RoundedWithBorderAndShadowTemplate.js';
+import type { ComputedBorderValues } from './Border.js';
+import type { ComputedRoundedValues } from './Rounded.js';
+import type { ComputedShadowValues } from './Shadow.js';
+import * as render from './utils/render.js';
+
+type ComputedValues = ComputedRoundedValues &
+  ComputedBorderValues &
+  ComputedShadowValues;
+
+export const RoundedWithBorderAndShadow: CanvasShaderType<
+  RoundedWithBorderAndShadowProps,
+  ComputedValues
+> = {
+  props: RoundedWithBorderAndShadowTemplate.props,
+  saveAndRestore: true,
+  update(node) {
+    const radius = calcFactoredRadiusArray(
+      this.props!.radius as Vec4,
+      node.width,
+      node.height,
+    );
+    this.computed.radius = radius;
+    this.computed.borderColor = this.toColorString(this.props!['border-color']);
+    this.computed.borderAsym = !valuesAreEqual(
+      this.props!['border-width'] as number[],
+    );
+    const borderWidth = this.props!['border-width'] as Vec4;
+    this.computed.borderRadius = radius.map((value, index) =>
+      Math.max(0, value - borderWidth[index]! * 0.5),
+    ) as Vec4;
+
+    this.computed.shadowColor = this.toColorString(this.props!['shadow-color']);
+    this.computed.shadowRadius = radius.map(
+      (value) => value + this.props!['shadow-blur'],
+    ) as Vec4;
+  },
+  render(ctx, quad, renderContext) {
+    const { tx, ty, width, height } = quad;
+    render.shadow(
+      ctx,
+      tx,
+      ty,
+      height,
+      width,
+      this.computed.shadowColor!,
+      this.props!['shadow-projection'],
+      this.computed.shadowRadius!,
+      this.stage.pixelRatio,
+    );
+    render.roundedRectWithBorder(
+      ctx,
+      quad.tx,
+      quad.ty,
+      quad.width,
+      quad.height,
+      this.computed.radius!,
+      this.props!['border-width'] as Vec4,
+      this.computed.borderRadius!,
+      this.computed.borderColor!,
+      this.computed.borderAsym!,
+      renderContext,
+    );
+  },
+};

package/src/core/shaders/canvas/RoundedWithShadow.ts

@@ -1,69 +1,69 @@
-/*
- * 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
- */
-
-import { calcFactoredRadiusArray } from '../../lib/utils.js';
-import type { CanvasShaderType } from '../../renderers/canvas/CanvasShaderNode.js';
-import type { Vec4 } from '../../renderers/webgl/internal/ShaderUtils.js';
-import {
-  RoundedWithShadowTemplate,
-  type RoundedWithShadowProps,
-} from '../templates/RoundedWithShadowTemplate.js';
-import type { ComputedRoundedValues } from './Rounded.js';
-import type { ComputedShadowValues } from './Shadow.js';
-import * as render from './utils/render.js';
-
-type ComputedValues = ComputedRoundedValues & ComputedShadowValues;
-
-export const RoundedWithShadow: CanvasShaderType<
-  RoundedWithShadowProps,
-  ComputedValues
-> = {
-  props: RoundedWithShadowTemplate.props,
-  saveAndRestore: true,
-  update(node) {
-    const radius = calcFactoredRadiusArray(
-      this.props!.radius as Vec4,
-      node.width,
-      node.height,
-    );
-    this.computed.radius = radius;
-    this.computed.shadowColor = this.toColorString(this.props!['shadow-color']);
-    this.computed.shadowRadius = radius.map(
-      (value) => value + this.props!['shadow-blur'],
-    ) as Vec4;
-  },
-  render(ctx, quad, renderContext) {
-    const { tx, ty, width, height } = quad;
-
-    render.shadow(
-      ctx,
-      tx,
-      ty,
-      width,
-      height,
-      this.computed.shadowColor!,
-      this.props!['shadow-projection'],
-      this.computed.shadowRadius!,
-      this.stage.pixelRatio,
-    );
-
-    const path = new Path2D();
-    render.roundRect(path, tx, ty, width, height, this.computed.radius!);
-    ctx.clip(path);
-    renderContext();
-  },
-};
+/*
+ * 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
+ */
+
+import { calcFactoredRadiusArray } from '../../lib/utils.js';
+import type { CanvasShaderType } from '../../renderers/canvas/CanvasShaderNode.js';
+import type { Vec4 } from '../../renderers/webgl/internal/ShaderUtils.js';
+import {
+  RoundedWithShadowTemplate,
+  type RoundedWithShadowProps,
+} from '../templates/RoundedWithShadowTemplate.js';
+import type { ComputedRoundedValues } from './Rounded.js';
+import type { ComputedShadowValues } from './Shadow.js';
+import * as render from './utils/render.js';
+
+type ComputedValues = ComputedRoundedValues & ComputedShadowValues;
+
+export const RoundedWithShadow: CanvasShaderType<
+  RoundedWithShadowProps,
+  ComputedValues
+> = {
+  props: RoundedWithShadowTemplate.props,
+  saveAndRestore: true,
+  update(node) {
+    const radius = calcFactoredRadiusArray(
+      this.props!.radius as Vec4,
+      node.width,
+      node.height,
+    );
+    this.computed.radius = radius;
+    this.computed.shadowColor = this.toColorString(this.props!['shadow-color']);
+    this.computed.shadowRadius = radius.map(
+      (value) => value + this.props!['shadow-blur'],
+    ) as Vec4;
+  },
+  render(ctx, quad, renderContext) {
+    const { tx, ty, width, height } = quad;
+
+    render.shadow(
+      ctx,
+      tx,
+      ty,
+      width,
+      height,
+      this.computed.shadowColor!,
+      this.props!['shadow-projection'],
+      this.computed.shadowRadius!,
+      this.stage.pixelRatio,
+    );
+
+    const path = new Path2D();
+    render.roundRect(path, tx, ty, width, height, this.computed.radius!);
+    ctx.clip(path);
+    renderContext();
+  },
+};

package/src/core/shaders/canvas/Shadow.ts

@@ -1,52 +1,52 @@
-/*
- * 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
- */
-
-import type { CanvasShaderType } from '../../renderers/canvas/CanvasShaderNode.js';
-import type { Vec4 } from '../../renderers/webgl/internal/ShaderUtils.js';
-import {
-  ShadowTemplate,
-  type ShadowProps,
-} from '../templates/ShadowTemplate.js';
-import { shadow } from './utils/render.js';
-
-export interface ComputedShadowValues {
-  shadowColor: string;
-  shadowRadius: Vec4;
-}
-
-export const Shadow: CanvasShaderType<ShadowProps, ComputedShadowValues> = {
-  props: ShadowTemplate.props,
-  update() {
-    this.computed.shadowColor = this.toColorString(this.props!['color']);
-    const blur = this.props!['blur'];
-    this.computed.shadowRadius = [blur, blur, blur, blur];
-  },
-  render(ctx, quad, renderContext) {
-    shadow(
-      ctx,
-      quad.tx,
-      quad.ty,
-      quad.width,
-      quad.height,
-      this.computed.shadowColor!,
-      this.props!['projection'],
-      this.computed.shadowRadius!,
-      this.stage.pixelRatio,
-    );
-    renderContext();
-  },
-};
+/*
+ * 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
+ */
+
+import type { CanvasShaderType } from '../../renderers/canvas/CanvasShaderNode.js';
+import type { Vec4 } from '../../renderers/webgl/internal/ShaderUtils.js';
+import {
+  ShadowTemplate,
+  type ShadowProps,
+} from '../templates/ShadowTemplate.js';
+import { shadow } from './utils/render.js';
+
+export interface ComputedShadowValues {
+  shadowColor: string;
+  shadowRadius: Vec4;
+}
+
+export const Shadow: CanvasShaderType<ShadowProps, ComputedShadowValues> = {
+  props: ShadowTemplate.props,
+  update() {
+    this.computed.shadowColor = this.toColorString(this.props!['color']);
+    const blur = this.props!['blur'];
+    this.computed.shadowRadius = [blur, blur, blur, blur];
+  },
+  render(ctx, quad, renderContext) {
+    shadow(
+      ctx,
+      quad.tx,
+      quad.ty,
+      quad.width,
+      quad.height,
+      this.computed.shadowColor!,
+      this.props!['projection'],
+      this.computed.shadowRadius!,
+      this.stage.pixelRatio,
+    );
+    renderContext();
+  },
+};