reacthub-pixitweenjs 0.2.109-alpha.5 → 0.3.0-alpha.3

package/dist/hooks/aep/index.d.ts

@@ -0,0 +1,22 @@
+export { easeNameFor } from './easeCache';
+export { buildLayerTimeline, planPropSegments, } from './buildLayerTimeline';
+export type { AepBuiltSegment, AepLayerTimelineBuild, AepTweenTarget, } from './buildLayerTimeline';
+export { useAepKeyframes } from './useAepKeyframes';
+export { useAepCurrentFrame } from './useAepCurrentFrame';
+export { useAepTextLayout } from './useAepTextLayout';
+export { useTypefaceMetrics } from './useTypefaceMetrics';
+export { sampleAnimatable, sampleScalar, sampleVec2, sampleColor, sampleAnimatedBezier, cubicBezierEase, lerpNumber, lerpVec2, lerpColor, } from './sampleAnimatable';
+export { useAepEffects } from './useAepEffects';
+export { useAepEffectKeyframes } from './useAepEffectKeyframes';
+export { useAepValueAnimator } from './useAepValueAnimator';
+export { useAepColorAnimator } from './useAepColorAnimator';
+export { useAepBezierPathAnimator } from './useAepBezierPathAnimator';
+export { useAepVec2Animator } from './useAepVec2Animator';
+export { buildVec2ValueTimeline, type AepVec2TimelineBuild, } from './buildVec2ValueTimeline';
+export { buildBezierPathTimeline, type AepAnimatableBezier, type AepBezierPathTimelineBuild, } from './buildBezierPathTimeline';
+export { interpolateBezierPath, clonePath, } from './interpolateBezierPath';
+export { buildScalarValueTimeline, type AepScalarTimelineBuild, } from './buildScalarValueTimeline';
+export { buildColorValueTimeline, parseHexColor, rgbaToHex, type AepColorTimelineBuild, type RgbaColor, } from './buildColorValueTimeline';
+export { getEffectHandler, registerEffectHandler, _listEffectHandlers, } from './effectRegistry';
+export * from './effects';
+export { buildAudioLevelTimeline, type AepAudioLevelBuild, type AudioLevelTarget, } from './buildAudioLevelTimeline';

package/dist/hooks/aep/interpolateBezierPath.d.ts

@@ -0,0 +1,3 @@
+import { AepBezierPath } from '../../types/aep';
+export declare function interpolateBezierPath(a: AepBezierPath, b: AepBezierPath, t: number): AepBezierPath;
+export declare function clonePath(p: AepBezierPath): AepBezierPath;

package/dist/hooks/aep/sampleAnimatable.d.ts

@@ -0,0 +1,13 @@
+import { AepAnimatable, AepBezierPath, AepEaseHandle } from '../../types/aep';
+export declare function cubicBezierEase(handles: AepEaseHandle, x: number): number;
+export declare function sampleAnimatable<T>(field: AepAnimatable<T> | undefined, fallback: T, frame: number, lerp: (a: T, b: T, k: number) => T): T;
+export declare const lerpNumber: (a: number, b: number, k: number) => number;
+export declare const lerpVec2: (a: [number, number], b: [number, number], k: number) => [number, number];
+export declare const lerpVec3: (a: [number, number, number], b: [number, number, number], k: number) => [number, number, number];
+export declare function sampleScalar(field: AepAnimatable<number> | undefined, fallback: number, frame: number): number;
+export declare function sampleVec2(field: AepAnimatable<[number, number]> | undefined, fallback: [number, number], frame: number): [number, number];
+export declare function sampleVec3(field: AepAnimatable<[number, number, number]> | undefined, fallback: [number, number, number], frame: number): [number, number, number];
+export declare const sampleEuler: typeof sampleVec3;
+export declare const lerpColor: (a: string, b: string, k: number) => string;
+export declare function sampleColor(field: AepAnimatable<string> | undefined, fallback: string, frame: number): string;
+export declare function sampleAnimatedBezier(field: AepAnimatable<AepBezierPath> | undefined, fallback: AepBezierPath, frame: number): AepBezierPath;

package/dist/hooks/aep/useAepBezierPathAnimator.d.ts

@@ -0,0 +1,12 @@
+import { AepBezierPath } from '../../types/aep';
+import { AepAnimatableBezier } from './buildBezierPathTimeline';
+/**
+ * Drive an animatable bezier path through the master timeline. Fires
+ * `onChange(path)` per onUpdate, plus once at mount with the initial
+ * (keyframe-0) value. Static fields emit once and return.
+ *
+ * @deprecated AEP shape + mask paths now sample directly from
+ *   `ctx.currentFrame` (see `sampleAnimatedBezier`). This hook is
+ *   preserved for downstream consumers driving non-AEP path tweens.
+ */
+export declare function useAepBezierPathAnimator(field: AepAnimatableBezier | undefined, fps: number, inPointFrames: number, onChange: (path: AepBezierPath) => void): void;

package/dist/hooks/aep/useAepColorAnimator.d.ts

@@ -0,0 +1,11 @@
+import { AepAnimatable } from '../../types/aep';
+/**
+ * Drive an animatable hex-color field via a GSAP sub-timeline that
+ * interpolates RGBA floats and fires `onChange(hex)` per tick.
+ *
+ * @deprecated AEP shape fills / stroke colors / effect colors now
+ *   sample directly from `ctx.currentFrame` (see `sampleColor`). This
+ *   hook is preserved for downstream consumers driving non-AEP color
+ *   tweens through the master timeline.
+ */
+export declare function useAepColorAnimator(field: AepAnimatable<string> | undefined, fps: number, inPointFrames: number, onChange: (hex: string) => void): void;

package/dist/hooks/aep/useAepCurrentFrame.d.ts

@@ -0,0 +1 @@
+export declare function useAepCurrentFrame(fps: number): number;

package/dist/hooks/aep/useAepEffectKeyframes.d.ts

@@ -0,0 +1,4 @@
+import { Filter } from 'pixi.js';
+import { AepLayer } from '../../types/aep';
+import * as React from "react";
+export declare function useAepEffectKeyframes(layer: AepLayer, filters: ReadonlyArray<Filter>): React.ReactNode;

package/dist/hooks/aep/useAepEffects.d.ts

@@ -0,0 +1,3 @@
+import { AepLayer } from '../../types/aep';
+import type * as PIXI from "pixi.js";
+export declare function useAepEffects(layer: AepLayer): PIXI.Filter[];

package/dist/hooks/aep/useAepKeyframes.d.ts

@@ -0,0 +1,15 @@
+import { AepLayer } from '../../types/aep';
+import * as React from "react";
+import type * as PIXI from "pixi.js";
+/**
+ * Drives the layer's keyframe animation by attaching a GSAP sub-timeline
+ * to the master `tl.current` at `layer.inPoint / fps` seconds. Cleans up
+ * on unmount or when the layer / target ref changes.
+ *
+ * @deprecated Internal AEP rendering now samples transform keyframes
+ *   from `ctx.currentFrame` directly (see `useAepLayerTransform`). This
+ *   hook is preserved for downstream consumers that drive Pixi
+ *   containers via GSAP outside the AEP composition pipeline. For new
+ *   code, prefer `sampleScalar` / `sampleVec2` from `hooks/aep`.
+ */
+export declare function useAepKeyframes(layer: AepLayer, targetRef: React.RefObject<PIXI.Container | null>, fps: number, readyKey?: unknown): void;

package/dist/hooks/aep/useAepTextLayout.d.ts

@@ -0,0 +1,12 @@
+import { AepLayer, AepThemeMap } from '../../types/aep';
+import { AepTextLayoutResult, AepTextMetricsProvider } from '../../utils/textLayout';
+type AepTextLayer = Extract<AepLayer, {
+    kind: "text";
+}>;
+interface UseAepTextLayoutOptions {
+    boxWidth?: number;
+    metrics?: AepTextMetricsProvider;
+    theme?: AepThemeMap;
+}
+export declare function useAepTextLayout(layer: AepTextLayer, currentFrame: number, options?: UseAepTextLayoutOptions): AepTextLayoutResult;
+export {};

package/dist/hooks/aep/useAepValueAnimator.d.ts

@@ -0,0 +1,2 @@
+import { AepAnimatable } from '../../types/aep';
+export declare function useAepValueAnimator(field: AepAnimatable<number> | undefined, fps: number, inPointFrames: number, onChange: (value: number) => void): void;

package/dist/hooks/aep/useAepVec2Animator.d.ts

@@ -0,0 +1,10 @@
+import { AepAnimatable } from '../../types/aep';
+/**
+ * Animatable [x, y] field driver. Fires `onChange(x, y)` per onUpdate
+ * and once at mount with the keyframe-0 value.
+ *
+ * @deprecated AEP effect-param vec2s now sample directly from
+ *   `ctx.currentFrame` (see `sampleVec2`). This hook is preserved for
+ *   downstream consumers driving non-AEP vec2 tweens.
+ */
+export declare function useAepVec2Animator(field: AepAnimatable<[number, number]> | undefined, fps: number, inPointFrames: number, onChange: (x: number, y: number) => void): void;

package/dist/hooks/aep/useTypefaceMetrics.d.ts

@@ -0,0 +1,2 @@
+import { AepTextMetricsProvider } from '../../utils/textLayout';
+export declare function useTypefaceMetrics(url: string | undefined): AepTextMetricsProvider | undefined;

package/dist/hooks/index.d.ts

@@ -1 +1,3 @@
 export * from './useGsapEffect';
+export * from './useSpriteFilters';
+export * from './aep';

package/dist/hooks/useSpriteFilters.d.ts

@@ -0,0 +1,39 @@
+import { Effects } from '../types/Effects';
+import * as PIXI from "pixi.js";
+export interface SpriteColorCorrection {
+    enabled?: boolean;
+    contrast?: number;
+    saturation?: number;
+    brightness?: number;
+    alpha?: number;
+    red?: number;
+    green?: number;
+    blue?: number;
+    gamma?: number;
+    blurRadius?: number;
+    temperature?: number;
+    hue?: number;
+    sharpness?: number;
+    vignette?: number;
+    noise?: number;
+}
+export interface SpriteEffectsInput {
+    name?: Effects | string;
+    intensity?: number;
+    params?: Record<string, unknown>;
+}
+export interface UseSpriteFiltersProps {
+    colorCorrection?: SpriteColorCorrection;
+    effects?: SpriteEffectsInput;
+}
+/**
+ * Hook that builds an ordered, memoized PIXI filter array from
+ * `{ colorCorrection, effects }`. Replaces ad-hoc filter array
+ * construction inside individual sprites.
+ *
+ * Order: temperature → sharpness → HSL → adjustment → effect(s) → blur → vignette → noise.
+ * Returns empty array when no filter applies (avoids the cost of
+ * `filters: []` allocating a render target on the sprite).
+ */
+export declare const useSpriteFilters: ({ colorCorrection, effects, }: UseSpriteFiltersProps) => PIXI.Filter[];
+export default useSpriteFilters;

package/dist/hooks/withFiltersHook.d.ts

@@ -28,7 +28,7 @@ export declare const withFiltersHook: (props: FiltersProps) => {
     temperatureFilter: PIXI.ColorMatrixFilter;
     vignetteFilter: PixiFilters.OldFilmFilter;
     noiseFilter: PIXI.NoiseFilter;
-    effectFilter: PixiFilters.HslAdjustmentFilter | PIXI.ColorMatrixFilter | PixiFilters.OldFilmFilter | (PIXI.ColorMatrixFilter | PixiFilters.GlowFilter)[] | null;
+    effectFilter: PIXI.ColorMatrixFilter | PixiFilters.HslAdjustmentFilter | PixiFilters.OldFilmFilter | (PIXI.ColorMatrixFilter | PixiFilters.GlowFilter)[] | null;
     blackAndWhiteFilter: PixiFilters.HslAdjustmentFilter;
     sepiaFilter: PIXI.ColorMatrixFilter;
     retroVintageFilter: PIXI.ColorMatrixFilter;

package/dist/importers/aep/bodymovin-color-controls.d.ts

@@ -0,0 +1,23 @@
+import { LottieLayerBase } from './bodymovin-layer';
+export interface ColorControlExtraction {
+    theme: Record<string, string>;
+    sourceLayerIds: Set<string>;
+    resolveToken: (layerName: string, effectName: string) => string | undefined;
+}
+export interface LottieEffect {
+    mn?: string;
+    nm?: string;
+    ef?: Array<{
+        ty?: number;
+        v?: {
+            k?: number[];
+        };
+    }>;
+}
+export declare function extractColorControls(layers: ReadonlyArray<LottieLayerBase & {
+    ef?: LottieEffect[];
+}>, layerIdFor: (l: LottieLayerBase) => string): ColorControlExtraction;
+export declare function parseColorControlExpression(x: string): {
+    layerName: string;
+    effectName: string;
+} | null;

package/dist/importers/aep/bodymovin-color.d.ts

@@ -0,0 +1 @@
+export declare function lottieColorToHex(rgba: number[]): string;

package/dist/importers/aep/bodymovin-keyframe.d.ts

@@ -0,0 +1,42 @@
+import { AepKeyframe, AepBezierPath } from '../../types/aep';
+export interface LottieKeyframe {
+    t: number;
+    s?: number | number[];
+    o?: {
+        x: number | number[];
+        y: number | number[];
+    };
+    i?: {
+        x: number | number[];
+        y: number | number[];
+    };
+    h?: number;
+}
+export interface LottieProperty {
+    a: 0 | 1;
+    k: number | number[] | LottieKeyframe[];
+}
+export type KeyframeValueShape<T> = (raw: number | number[]) => T;
+export declare function convertProperty<T>(prop: LottieProperty | undefined, shape: KeyframeValueShape<T>): T | AepKeyframe<T>[] | undefined;
+export declare const asNumber: KeyframeValueShape<number>;
+export declare const asVec2: KeyframeValueShape<[number, number]>;
+export declare const asScale: KeyframeValueShape<[number, number]>;
+export declare const asOpacity: KeyframeValueShape<number>;
+interface LottieBezier {
+    v?: Array<[number, number]>;
+    i?: Array<[number, number]>;
+    o?: Array<[number, number]>;
+    c?: boolean;
+}
+interface LottieBezierProperty {
+    a: 0 | 1;
+    k: LottieBezier | Array<{
+        t: number;
+        s?: LottieBezier[] | LottieBezier;
+        o?: LottieKeyframe["o"];
+        i?: LottieKeyframe["i"];
+        h?: number;
+    }>;
+}
+export declare function convertBezierProperty(prop: LottieBezierProperty | undefined): AepBezierPath | AepKeyframe<AepBezierPath>[] | undefined;
+export {};

package/dist/importers/aep/bodymovin-layer.d.ts

@@ -0,0 +1,84 @@
+import { AepLayer } from '../../types/aep';
+import { LottieTransform } from './bodymovin-transform';
+import { LottieProperty } from './bodymovin-keyframe';
+export interface LottieLayerBase {
+    ddd?: 0 | 1;
+    ind?: number;
+    ty: number;
+    nm?: string;
+    ks?: LottieTransform;
+    ip: number;
+    op: number;
+    st?: number;
+    parent?: number;
+    hd?: 0 | 1;
+    tt?: number;
+    td?: number;
+}
+interface LottieShapeItem {
+    ty: string;
+    nm?: string;
+    it?: LottieShapeItem[];
+    p?: LottieProperty;
+    s?: LottieProperty;
+    r?: LottieProperty;
+    c?: LottieProperty;
+    o?: LottieProperty;
+    sy?: 1 | 2;
+    pt?: LottieProperty;
+    ir?: LottieProperty;
+    or?: LottieProperty;
+    ks?: unknown;
+}
+export interface LottieShapeLayer extends LottieLayerBase {
+    ty: 4;
+    shapes: LottieShapeItem[];
+}
+export interface LottieSolidLayer extends LottieLayerBase {
+    ty: 1;
+    sc: string;
+    sw: number;
+    sh: number;
+}
+export interface LottieTextLayer extends LottieLayerBase {
+    ty: 5;
+    t: {
+        d: {
+            k: Array<{
+                s: LottieTextDoc;
+            }>;
+        };
+    };
+}
+export interface LottieNullLayer extends LottieLayerBase {
+    ty: 3;
+}
+export interface LottieImageLayer extends LottieLayerBase {
+    ty: 2;
+    refId: string;
+}
+export interface LottiePrecompLayer extends LottieLayerBase {
+    ty: 0;
+    refId: string;
+    w: number;
+    h: number;
+}
+interface LottieTextDoc {
+    t: string;
+    f: string;
+    s: number;
+    fc?: [number, number, number];
+    sc?: [number, number, number];
+    sw?: number;
+    lh?: number;
+    tr?: number;
+    j?: number;
+}
+export type LottieLayer = LottieShapeLayer | LottieSolidLayer | LottieTextLayer | LottieNullLayer | LottieImageLayer | LottiePrecompLayer | LottieLayerBase;
+export declare function layerIdFor(layer: LottieLayerBase): string;
+export interface ConvertLayerContext {
+    matteSourceId?: string;
+    resolveColorControl?: (hostLayerName: string, expression: string) => string | undefined;
+}
+export declare function convertLayer(layer: LottieLayer, ctx?: ConvertLayerContext): AepLayer[];
+export {};

package/dist/importers/aep/bodymovin-transform.d.ts

@@ -0,0 +1,12 @@
+import { AepTransform } from '../../types/aep';
+import { LottieProperty } from './bodymovin-keyframe';
+export interface LottieTransform {
+    p?: LottieProperty;
+    a?: LottieProperty;
+    s?: LottieProperty;
+    r?: LottieProperty;
+    o?: LottieProperty;
+    sk?: LottieProperty;
+    sa?: LottieProperty;
+}
+export declare function convertTransform(ks: LottieTransform | undefined): AepTransform;

package/dist/importers/aep/bodymovin.d.ts

@@ -0,0 +1,7 @@
+import { AepCompositionJson } from '../../types/aep';
+export type BodymovinLintMode = "strict" | "warn" | "off";
+export interface BodymovinToAepOptions {
+    lint?: BodymovinLintMode;
+    disabledRules?: string[];
+}
+export declare function bodymovinToAep(lottieJson: unknown, options?: BodymovinToAepOptions): AepCompositionJson;

package/dist/importers/aep/bodymovinCameras.d.ts

@@ -0,0 +1,34 @@
+import { AepCameraLayer, AepLightLayer, AepTransform3D } from '../../types/aep';
+import { LottieProperty } from './bodymovin-keyframe';
+import { LottieLayerBase } from './bodymovin-layer';
+export interface LottieTransform3D {
+    p?: LottieProperty;
+    a?: LottieProperty;
+    s?: LottieProperty;
+    r?: LottieProperty;
+    rx?: LottieProperty;
+    ry?: LottieProperty;
+    rz?: LottieProperty;
+    or?: LottieProperty;
+    o?: LottieProperty;
+}
+export interface LottieCameraLayer extends LottieLayerBase {
+    ty: 13;
+    pe?: LottieProperty;
+    ks?: LottieTransform3D;
+}
+export interface LottieLightLayer extends LottieLayerBase {
+    ty: 14;
+    lt?: 1 | 2 | 3 | 4;
+    in?: LottieProperty;
+    cl?: LottieProperty;
+    ca?: LottieProperty;
+    cf?: LottieProperty;
+    ks?: LottieTransform3D;
+}
+export declare function isLottieCameraLayer(layer: LottieLayerBase): boolean;
+export declare function isLottieLightLayer(layer: LottieLayerBase): boolean;
+export declare function isLottie3DLayer(layer: LottieLayerBase): boolean;
+export declare function transform3DFromKs(ks: LottieTransform3D | undefined): AepTransform3D;
+export declare function convertCameraLayer(layer: LottieCameraLayer, id: string): AepCameraLayer;
+export declare function convertLightLayer(layer: LottieLightLayer, id: string): AepLightLayer;

package/dist/importers/aep/bodymovinExtensions.d.ts

@@ -0,0 +1,3 @@
+import { AepExtrusion, AepPostFx } from '../../types/aep';
+export declare function readPostFxExtension(lottieJson: unknown): AepPostFx[] | undefined;
+export declare function readExtrusionExtension(lottieLayer: unknown): AepExtrusion | undefined;

package/dist/importers/aep/bodymovinTextRuns.d.ts

@@ -0,0 +1,13 @@
+import { AepTextStyleRun } from '../../types/aep';
+export interface LottieTextRunExtension {
+    from: number;
+    to: number;
+    font?: string;
+    size?: number;
+    fc?: [number, number, number];
+    weight?: number | string;
+    italic?: boolean;
+    tr?: number;
+    bs?: number;
+}
+export declare function extractBodymovinTextRuns(doc: unknown): AepTextStyleRun[] | undefined;

package/dist/importers/aep/index.d.ts

@@ -0,0 +1,7 @@
+export { bodymovinToAep } from './bodymovin';
+export { convertLayer, layerIdFor } from './bodymovin-layer';
+export { convertTransform } from './bodymovin-transform';
+export { convertProperty, asNumber, asVec2, asScale, asOpacity, } from './bodymovin-keyframe';
+export { lottieColorToHex } from './bodymovin-color';
+export { lintBodymovinJson, LottieLintError, type LintFinding, type LintReport, type LintSeverity, type LintOptions, } from './lottieLint';
+export { readPostFxExtension, readExtrusionExtension, } from './bodymovinExtensions';

package/dist/importers/aep/lottieLint.d.ts

@@ -0,0 +1,23 @@
+export type LintSeverity = "error" | "warn" | "info";
+export interface LintFinding {
+    ruleId: string;
+    severity: LintSeverity;
+    message: string;
+    layerIndex?: number;
+    layerName?: string;
+    path?: string;
+}
+export interface LintReport {
+    findings: LintFinding[];
+    hasErrors: boolean;
+    hasWarnings: boolean;
+}
+export interface LintOptions {
+    disabledRules?: string[];
+}
+export declare class LottieLintError extends Error {
+    readonly report: LintReport;
+    constructor(report: LintReport);
+}
+export declare function lintBodymovinJson(json: unknown, options?: LintOptions): LintReport;
+export declare function isSuppressed(layer: unknown, ruleId: string): boolean;

package/dist/importers/aep/lottieLint.rules.d.ts

@@ -0,0 +1,6 @@
+import { LintFinding } from './lottieLint';
+export interface LintRule {
+    id: string;
+    check: (json: unknown) => Omit<LintFinding, "ruleId">[];
+}
+export declare const lottieLintRules: LintRule[];

package/dist/index.d.ts

@@ -3,3 +3,6 @@ export * from './providers';
 export * from './types';
 export * from './events';
 export * from './hooks';
+export * from './hocs';
+export * from './utils';
+export * from './importers/aep';