@revideo/2d 0.4.0 → 0.4.1-cat.995

package/lib/components/Line.d.ts

@@ -1,15 +1,23 @@
-import { BBox, PossibleVector2, SignalValue, SimpleSignal, ThreadGenerator, TimingFunction, Vector2 } from '@revideo/core';
-import { CurveProfile } from '../curves';
-import { Curve, CurveProps } from './Curve';
+import {
+  BBox,
+  PossibleVector2,
+  SignalValue,
+  SimpleSignal,
+  ThreadGenerator,
+  TimingFunction,
+  Vector2,
+} from '@revideo/core';
+import {CurveProfile} from '../curves';
+import {Curve, CurveProps} from './Curve';
 export interface LineProps extends CurveProps {
-    /**
-     * {@inheritDoc Line.radius}
-     */
-    radius?: SignalValue<number>;
-    /**
-     * {@inheritDoc Line.points}
-     */
-    points?: SignalValue<SignalValue<PossibleVector2>[]>;
+  /**
+   * {@inheritDoc Line.radius}
+   */
+  radius?: SignalValue<number>;
+  /**
+   * {@inheritDoc Line.points}
+   */
+  points?: SignalValue<SignalValue<PossibleVector2>[]>;
 }
 /**
  * A node for drawing lines and polygons.
@@ -117,42 +125,46 @@ export interface LineProps extends CurveProps {
  * ```
  */
 export declare class Line extends Curve {
-    /**
-     * Rotate the points to minimize the overall distance traveled when tweening.
-     *
-     * @param points - The points to rotate.
-     * @param reference - The reference points to which the distance is measured.
-     * @param closed - Whether the points form a closed polygon.
-     */
-    private static rotatePoints;
-    /**
-     * Distribute additional points along the polyline.
-     *
-     * @param points - The points of a polyline along which new points should be
-     *                 distributed.
-     * @param count - The number of points to add.
-     */
-    private static distributePoints;
-    /**
-     * The radius of the line's corners.
-     */
-    readonly radius: SimpleSignal<number, this>;
-    /**
-     * The points of the line.
-     *
-     * @remarks
-     * When set to `null`, the Line will use the positions of its children as
-     * points.
-     */
-    readonly points: SimpleSignal<SignalValue<PossibleVector2>[] | null, this>;
-    protected tweenPoints(value: SignalValue<SignalValue<PossibleVector2>[] | null>, time: number, timingFunction: TimingFunction): ThreadGenerator;
-    private tweenedPoints;
-    constructor(props: LineProps);
-    protected childrenBBox(): BBox;
-    parsedPoints(): Vector2[];
-    profile(): CurveProfile;
-    protected lineWidthCoefficient(): number;
-    drawOverlay(context: CanvasRenderingContext2D, matrix: DOMMatrix): void;
-    private parsePoints;
+  /**
+   * Rotate the points to minimize the overall distance traveled when tweening.
+   *
+   * @param points - The points to rotate.
+   * @param reference - The reference points to which the distance is measured.
+   * @param closed - Whether the points form a closed polygon.
+   */
+  private static rotatePoints;
+  /**
+   * Distribute additional points along the polyline.
+   *
+   * @param points - The points of a polyline along which new points should be
+   *                 distributed.
+   * @param count - The number of points to add.
+   */
+  private static distributePoints;
+  /**
+   * The radius of the line's corners.
+   */
+  readonly radius: SimpleSignal<number, this>;
+  /**
+   * The points of the line.
+   *
+   * @remarks
+   * When set to `null`, the Line will use the positions of its children as
+   * points.
+   */
+  readonly points: SimpleSignal<SignalValue<PossibleVector2>[] | null, this>;
+  protected tweenPoints(
+    value: SignalValue<SignalValue<PossibleVector2>[] | null>,
+    time: number,
+    timingFunction: TimingFunction,
+  ): ThreadGenerator;
+  private tweenedPoints;
+  constructor(props: LineProps);
+  protected childrenBBox(): BBox;
+  parsedPoints(): Vector2[];
+  profile(): CurveProfile;
+  protected lineWidthCoefficient(): number;
+  drawOverlay(context: CanvasRenderingContext2D, matrix: DOMMatrix): void;
+  private parsePoints;
 }
-//# sourceMappingURL=Line.d.ts.map
+//# sourceMappingURL=Line.d.ts.map

package/lib/components/Node.d.ts

@@ -231,7 +231,7 @@ export declare class Node implements Promisable<Node> {
     readonly composite: SimpleSignal<boolean, this>;
     readonly compositeOperation: SimpleSignal<GlobalCompositeOperation, this>;
     private readonly compositeOverride;
-    protected tweenCompositeOperation(value: SignalValue<GlobalCompositeOperation>, time: number, timingFunction: TimingFunction): Generator<void | ThreadGenerator | Promise<any> | Promisable<any>, void, any>;
+    protected tweenCompositeOperation(value: SignalValue<GlobalCompositeOperation>, time: number, timingFunction: TimingFunction): Generator<void | Promise<any> | ThreadGenerator | Promisable<any>, void, any>;
     /**
      * Represents the opacity of this node in the range 0-1.
      *

package/lib/components/Path.d.ts

@@ -12,7 +12,7 @@ export declare class Path extends Curve {
     protected childrenBBox(): BBox;
     protected lineWidthCoefficient(): number;
     protected processSubpath(path: Path2D, startPoint: Vector2 | null, endPoint: Vector2 | null): void;
-    protected tweenData(newPath: SignalValue<string>, time: number, timingFunction: TimingFunction): Generator<void | import("@revideo/core").ThreadGenerator | Promise<any> | import("@revideo/core").Promisable<any>, void, any>;
+    protected tweenData(newPath: SignalValue<string>, time: number, timingFunction: TimingFunction): Generator<void | Promise<any> | import("@revideo/core").ThreadGenerator | import("@revideo/core").Promisable<any>, void, any>;
     drawOverlay(context: CanvasRenderingContext2D, matrix: DOMMatrix): void;
 }
 //# sourceMappingURL=Path.d.ts.map

package/lib/components/Polygon.d.ts

@@ -1,16 +1,21 @@
-import { BBox, SerializedVector2, SignalValue, SimpleSignal } from '@revideo/core';
-import { CurveProfile } from '../curves';
-import { DesiredLength } from '../partials';
-import { Curve, CurveProps } from './Curve';
+import {
+  BBox,
+  SerializedVector2,
+  SignalValue,
+  SimpleSignal,
+} from '@revideo/core';
+import {CurveProfile} from '../curves';
+import {DesiredLength} from '../partials';
+import {Curve, CurveProps} from './Curve';
 export interface PolygonProps extends CurveProps {
-    /**
-     * {@inheritDoc Polygon.sides}
-     */
-    sides?: SignalValue<number>;
-    /**
-     * {@inheritDoc Polygon.radius}
-     */
-    radius?: SignalValue<number>;
+  /**
+   * {@inheritDoc Polygon.sides}
+   */
+  sides?: SignalValue<number>;
+  /**
+   * {@inheritDoc Polygon.radius}
+   */
+  radius?: SignalValue<number>;
 }
 /**
  * A node for drawing regular polygons.
@@ -65,47 +70,47 @@ export interface PolygonProps extends CurveProps {
  * ```
  */
 export declare class Polygon extends Curve {
-    /**
-     * The number of sides of the polygon.
-     *
-     * @remarks
-     * For example, a value of 6 creates a hexagon.
-     *
-     * @example
-     * ```tsx
-     * <Polygon
-     *   size={320}
-     *   sides={7}
-     *   stroke={'#fff'}
-     *   lineWidth={8}
-     *   fill={'lightseagreen'}
-     * />
-     * ```
-     */
-    readonly sides: SimpleSignal<number, this>;
-    /**
-     * The radius of the polygon's corners.
-     *
-     * @example
-     * ```tsx
-     * <Polygon
-     *   radius={30}
-     *   size={320}
-     *   sides={3}
-     *   stroke={'#fff'}
-     *   lineWidth={8}
-     * />
-     * ```
-     */
-    readonly radius: SimpleSignal<number, this>;
-    constructor(props: PolygonProps);
-    profile(): CurveProfile;
-    protected desiredSize(): SerializedVector2<DesiredLength>;
-    protected offsetComputedLayout(box: BBox): BBox;
-    protected childrenBBox(): BBox;
-    protected requiresProfile(): boolean;
-    protected getPath(): Path2D;
-    protected getRipplePath(): Path2D;
-    protected createPath(expand?: number): Path2D;
+  /**
+   * The number of sides of the polygon.
+   *
+   * @remarks
+   * For example, a value of 6 creates a hexagon.
+   *
+   * @example
+   * ```tsx
+   * <Polygon
+   *   size={320}
+   *   sides={7}
+   *   stroke={'#fff'}
+   *   lineWidth={8}
+   *   fill={'lightseagreen'}
+   * />
+   * ```
+   */
+  readonly sides: SimpleSignal<number, this>;
+  /**
+   * The radius of the polygon's corners.
+   *
+   * @example
+   * ```tsx
+   * <Polygon
+   *   radius={30}
+   *   size={320}
+   *   sides={3}
+   *   stroke={'#fff'}
+   *   lineWidth={8}
+   * />
+   * ```
+   */
+  readonly radius: SimpleSignal<number, this>;
+  constructor(props: PolygonProps);
+  profile(): CurveProfile;
+  protected desiredSize(): SerializedVector2<DesiredLength>;
+  protected offsetComputedLayout(box: BBox): BBox;
+  protected childrenBBox(): BBox;
+  protected requiresProfile(): boolean;
+  protected getPath(): Path2D;
+  protected getRipplePath(): Path2D;
+  protected createPath(expand?: number): Path2D;
 }
-//# sourceMappingURL=Polygon.d.ts.map
+//# sourceMappingURL=Polygon.d.ts.map

package/lib/components/QuadBezier.d.ts

@@ -1,17 +1,17 @@
-import { PossibleVector2, SignalValue, Vector2Signal } from '@revideo/core';
-import { PolynomialSegment } from '../curves/PolynomialSegment';
-import { Bezier, BezierOverlayInfo } from './Bezier';
-import { CurveProps } from './Curve';
+import {PossibleVector2, SignalValue, Vector2Signal} from '@revideo/core';
+import {PolynomialSegment} from '../curves/PolynomialSegment';
+import {Bezier, BezierOverlayInfo} from './Bezier';
+import {CurveProps} from './Curve';
 export interface QuadBezierProps extends CurveProps {
-    p0?: SignalValue<PossibleVector2>;
-    p0X?: SignalValue<number>;
-    p0Y?: SignalValue<number>;
-    p1?: SignalValue<PossibleVector2>;
-    p1X?: SignalValue<number>;
-    p1Y?: SignalValue<number>;
-    p2?: SignalValue<PossibleVector2>;
-    p2X?: SignalValue<number>;
-    p2Y?: SignalValue<number>;
+  p0?: SignalValue<PossibleVector2>;
+  p0X?: SignalValue<number>;
+  p0Y?: SignalValue<number>;
+  p1?: SignalValue<PossibleVector2>;
+  p1X?: SignalValue<number>;
+  p1Y?: SignalValue<number>;
+  p2?: SignalValue<PossibleVector2>;
+  p2X?: SignalValue<number>;
+  p2Y?: SignalValue<number>;
 }
 /**
  * A node for drawing a quadratic Bézier curve.
@@ -42,20 +42,20 @@ export interface QuadBezierProps extends CurveProps {
  * ```
  */
 export declare class QuadBezier extends Bezier {
-    /**
-     * The start point of the Bézier curve.
-     */
-    readonly p0: Vector2Signal<this>;
-    /**
-     * The control point of the Bézier curve.
-     */
-    readonly p1: Vector2Signal<this>;
-    /**
-     * The end point of the Bézier curve.
-     */
-    readonly p2: Vector2Signal<this>;
-    constructor(props: QuadBezierProps);
-    protected segment(): PolynomialSegment;
-    protected overlayInfo(matrix: DOMMatrix): BezierOverlayInfo;
+  /**
+   * The start point of the Bézier curve.
+   */
+  readonly p0: Vector2Signal<this>;
+  /**
+   * The control point of the Bézier curve.
+   */
+  readonly p1: Vector2Signal<this>;
+  /**
+   * The end point of the Bézier curve.
+   */
+  readonly p2: Vector2Signal<this>;
+  constructor(props: QuadBezierProps);
+  protected segment(): PolynomialSegment;
+  protected overlayInfo(matrix: DOMMatrix): BezierOverlayInfo;
 }
-//# sourceMappingURL=QuadBezier.d.ts.map
+//# sourceMappingURL=QuadBezier.d.ts.map

package/lib/components/Ray.d.ts

@@ -1,19 +1,19 @@
-import { BBox, PossibleVector2, SignalValue, Vector2Signal } from '@revideo/core';
-import { CurveProfile } from '../curves';
-import { Curve, CurveProps } from './Curve';
+import {BBox, PossibleVector2, SignalValue, Vector2Signal} from '@revideo/core';
+import {CurveProfile} from '../curves';
+import {Curve, CurveProps} from './Curve';
 export interface RayProps extends CurveProps {
-    /**
-     * {@inheritDoc Ray.from}
-     */
-    from?: SignalValue<PossibleVector2>;
-    fromX?: SignalValue<number>;
-    fromY?: SignalValue<number>;
-    /**
-     * {@inheritDoc Ray.to}
-     */
-    to?: SignalValue<PossibleVector2>;
-    toX?: SignalValue<number>;
-    toY?: SignalValue<number>;
+  /**
+   * {@inheritDoc Ray.from}
+   */
+  from?: SignalValue<PossibleVector2>;
+  fromX?: SignalValue<number>;
+  fromY?: SignalValue<number>;
+  /**
+   * {@inheritDoc Ray.to}
+   */
+  to?: SignalValue<PossibleVector2>;
+  toX?: SignalValue<number>;
+  toY?: SignalValue<number>;
 }
 /**
  * A node for drawing an individual line segment.
@@ -44,17 +44,17 @@ export interface RayProps extends CurveProps {
  * ```
  */
 export declare class Ray extends Curve {
-    /**
-     * The starting point of the ray.
-     */
-    readonly from: Vector2Signal<this>;
-    /**
-     * The ending point of the ray.
-     */
-    readonly to: Vector2Signal<this>;
-    constructor(props: RayProps);
-    protected childrenBBox(): BBox;
-    profile(): CurveProfile;
-    drawOverlay(context: CanvasRenderingContext2D, matrix: DOMMatrix): void;
+  /**
+   * The starting point of the ray.
+   */
+  readonly from: Vector2Signal<this>;
+  /**
+   * The ending point of the ray.
+   */
+  readonly to: Vector2Signal<this>;
+  constructor(props: RayProps);
+  protected childrenBBox(): BBox;
+  profile(): CurveProfile;
+  drawOverlay(context: CanvasRenderingContext2D, matrix: DOMMatrix): void;
 }
-//# sourceMappingURL=Ray.d.ts.map
+//# sourceMappingURL=Ray.d.ts.map

package/lib/components/Rect.d.ts

@@ -1,112 +1,119 @@
-import { BBox, PossibleSpacing, SerializedVector2, SignalValue, SimpleSignal, SpacingSignal } from '@revideo/core';
-import { DesiredLength } from '../partials';
-import { Curve, CurveProps } from './Curve';
+import {
+  BBox,
+  PossibleSpacing,
+  SerializedVector2,
+  SignalValue,
+  SimpleSignal,
+  SpacingSignal,
+} from '@revideo/core';
+import {DesiredLength} from '../partials';
+import {Curve, CurveProps} from './Curve';
 export interface RectProps extends CurveProps {
-    /**
-     * {@inheritDoc Rect.radius}
-     */
-    radius?: SignalValue<PossibleSpacing>;
-    /**
-     * {@inheritDoc Rect.smoothCorners}
-     */
-    smoothCorners?: SignalValue<boolean>;
-    /**
-     * {@inheritDoc Rect.cornerSharpness}
-     */
-    cornerSharpness?: SignalValue<number>;
+  /**
+   * {@inheritDoc Rect.radius}
+   */
+  radius?: SignalValue<PossibleSpacing>;
+  /**
+   * {@inheritDoc Rect.smoothCorners}
+   */
+  smoothCorners?: SignalValue<boolean>;
+  /**
+   * {@inheritDoc Rect.cornerSharpness}
+   */
+  cornerSharpness?: SignalValue<number>;
 }
 export declare class Rect extends Curve {
-    /**
-     * Rounds the corners of this rectangle.
-     *
-     * @remarks
-     * The value represents the radius of the quarter circle that is used to round
-     * the corners. If the value is a number, the same radius is used for all
-     * corners. Passing an array of two to four numbers will set individual radii
-     * for each corner. Individual radii correspond to different corners depending
-     * on the number of values passed:
-     *
-     * ```ts
-     * // top-left-and-bottom-right | top-right-and-bottom-left
-     * [10, 30]
-     * // top-left | top-right-and-bottom-left | bottom-right
-     * [10, 20, 30]
-     * // top-left | top-right | bottom-right | bottom-left
-     * [10, 20, 30, 40]
-     * ```
-     *
-     * @example
-     * One uniform radius:
-     * ```tsx
-     * <Rect
-     *   size={320}
-     *   radius={40}
-     *   fill={'white'}
-     * />
-     * ```
-     * @example
-     * Individual radii for each corner:
-     * ```tsx
-     * <Rect
-     *   size={320}
-     *   radius={[10, 20, 30, 40]}
-     *   fill={'white'}
-     * />
-     * ```
-     */
-    readonly radius: SpacingSignal<this>;
-    /**
-     * Enables corner smoothing.
-     *
-     * @remarks
-     * This property only affects the way rounded corners are drawn. To control
-     * the corner radius use the {@link radius} property.
-     *
-     * When enabled, rounded corners are drawn continuously using Bézier curves
-     * rather than quarter circles. The sharpness of the curve can be controlled
-     * with {@link cornerSharpness}.
-     *
-     * You can read more about corner smoothing in
-     * [this article by Nick Lawrence](https://uxplanet.org/ui-ux-design-corner-smoothing-720509d1ae48).
-     *
-     * @example
-     * ```tsx
-     * <Rect
-     *   width={300}
-     *   height={300}
-     *   smoothCorners={true}
-     * />
-     * ```
-     */
-    readonly smoothCorners: SimpleSignal<boolean, this>;
-    /**
-     * Controls the sharpness of {@link smoothCorners}.
-     *
-     * @remarks
-     * This property only affects the way rounded corners are drawn. To control
-     * the corner radius use the {@link radius} property.
-     *
-     * Requires {@link smoothCorners} to be enabled to have any effect.
-     * By default, corner sharpness is set to `0.6` which represents a smooth,
-     * circle-like rounding. At `0` the edges are squared off.
-     *
-     * @example
-     * ```tsx
-     * <Rect
-     *   size={300}
-     *   smoothCorners={true}
-     *   cornerSharpness={0.7}
-     * />
-     * ```
-     */
-    readonly cornerSharpness: SimpleSignal<number, this>;
-    constructor(props: RectProps);
-    profile(): import("..").CurveProfile;
-    protected desiredSize(): SerializedVector2<DesiredLength>;
-    protected offsetComputedLayout(box: BBox): BBox;
-    protected childrenBBox(): BBox;
-    protected getPath(): Path2D;
-    protected getCacheBBox(): BBox;
-    protected getRipplePath(): Path2D;
+  /**
+   * Rounds the corners of this rectangle.
+   *
+   * @remarks
+   * The value represents the radius of the quarter circle that is used to round
+   * the corners. If the value is a number, the same radius is used for all
+   * corners. Passing an array of two to four numbers will set individual radii
+   * for each corner. Individual radii correspond to different corners depending
+   * on the number of values passed:
+   *
+   * ```ts
+   * // top-left-and-bottom-right | top-right-and-bottom-left
+   * [10, 30]
+   * // top-left | top-right-and-bottom-left | bottom-right
+   * [10, 20, 30]
+   * // top-left | top-right | bottom-right | bottom-left
+   * [10, 20, 30, 40]
+   * ```
+   *
+   * @example
+   * One uniform radius:
+   * ```tsx
+   * <Rect
+   *   size={320}
+   *   radius={40}
+   *   fill={'white'}
+   * />
+   * ```
+   * @example
+   * Individual radii for each corner:
+   * ```tsx
+   * <Rect
+   *   size={320}
+   *   radius={[10, 20, 30, 40]}
+   *   fill={'white'}
+   * />
+   * ```
+   */
+  readonly radius: SpacingSignal<this>;
+  /**
+   * Enables corner smoothing.
+   *
+   * @remarks
+   * This property only affects the way rounded corners are drawn. To control
+   * the corner radius use the {@link radius} property.
+   *
+   * When enabled, rounded corners are drawn continuously using Bézier curves
+   * rather than quarter circles. The sharpness of the curve can be controlled
+   * with {@link cornerSharpness}.
+   *
+   * You can read more about corner smoothing in
+   * [this article by Nick Lawrence](https://uxplanet.org/ui-ux-design-corner-smoothing-720509d1ae48).
+   *
+   * @example
+   * ```tsx
+   * <Rect
+   *   width={300}
+   *   height={300}
+   *   smoothCorners={true}
+   * />
+   * ```
+   */
+  readonly smoothCorners: SimpleSignal<boolean, this>;
+  /**
+   * Controls the sharpness of {@link smoothCorners}.
+   *
+   * @remarks
+   * This property only affects the way rounded corners are drawn. To control
+   * the corner radius use the {@link radius} property.
+   *
+   * Requires {@link smoothCorners} to be enabled to have any effect.
+   * By default, corner sharpness is set to `0.6` which represents a smooth,
+   * circle-like rounding. At `0` the edges are squared off.
+   *
+   * @example
+   * ```tsx
+   * <Rect
+   *   size={300}
+   *   smoothCorners={true}
+   *   cornerSharpness={0.7}
+   * />
+   * ```
+   */
+  readonly cornerSharpness: SimpleSignal<number, this>;
+  constructor(props: RectProps);
+  profile(): import('..').CurveProfile;
+  protected desiredSize(): SerializedVector2<DesiredLength>;
+  protected offsetComputedLayout(box: BBox): BBox;
+  protected childrenBBox(): BBox;
+  protected getPath(): Path2D;
+  protected getCacheBBox(): BBox;
+  protected getRipplePath(): Path2D;
 }
-//# sourceMappingURL=Rect.d.ts.map
+//# sourceMappingURL=Rect.d.ts.map

package/lib/components/SVG.d.ts

@@ -95,7 +95,7 @@ export declare class SVG extends Shape {
      * @param timing - The timing function.
      */
     protected generateTransformer(from: Node, to: Node, duration: number, timing: TimingFunction): Generator<ThreadGenerator>;
-    protected tweenSvg(value: SignalValue<string>, time: number, timingFunction: TimingFunction): Generator<void | ThreadGenerator | Promise<any> | import("@revideo/core").Promisable<any>, void, any>;
+    protected tweenSvg(value: SignalValue<string>, time: number, timingFunction: TimingFunction): Generator<void | Promise<any> | ThreadGenerator | import("@revideo/core").Promisable<any>, void, any>;
     private wrapperScale;
     /**
      * Get the current `SVGDocument`.

package/lib/components/Shape.d.ts

@@ -34,6 +34,6 @@ export declare abstract class Shape extends Layout {
     protected getPath(): Path2D;
     protected getRipplePath(): Path2D;
     protected drawRipple(context: CanvasRenderingContext2D): void;
-    ripple(duration?: number): Generator<void | import("@revideo/core").ThreadGenerator | Promise<any> | import("@revideo/core").Promisable<any>, void, any>;
+    ripple(duration?: number): Generator<void | Promise<any> | import("@revideo/core").ThreadGenerator | import("@revideo/core").Promisable<any>, void, any>;
 }
 //# sourceMappingURL=Shape.d.ts.map