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

package/dist/components/PixiShapeLayer/PixiShapeLayer.d.ts

@@ -0,0 +1,43 @@
+import { PixiBaseSpriteProps, ForwardedRefResponse } from '../../types/BaseProps';
+import { AepAnimatable, AepShapePath, AepThemableColor } from '../../types/aep';
+import * as React from "react";
+import * as PIXI from "pixi.js";
+export interface PixiShapeLayerProps extends Omit<PixiBaseSpriteProps, "transformation"> {
+    path: AepShapePath;
+    fill?: AepThemableColor;
+    stroke?: {
+        color: AepAnimatable<string>;
+        width: AepAnimatable<number>;
+        cap?: "butt" | "round" | "square";
+        join?: "miter" | "round" | "bevel";
+    };
+    trimPath?: {
+        start: AepAnimatable<number>;
+        end: AepAnimatable<number>;
+        offset?: AepAnimatable<number>;
+    };
+    transformation: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+        anchor: number | {
+            x: number;
+            y: number;
+        };
+        rotation?: number;
+        alpha?: number;
+        scale?: number | [number, number];
+        tint?: number;
+        blendMode?: number;
+    };
+    fps?: number;
+    inPointFrames?: number;
+    onContainerRefReady?: (uniqueId: string, ref: React.MutableRefObject<PIXI.Container | null>) => void;
+    onSpriteRefReady?: (uniqueId: string, ref: React.MutableRefObject<PIXI.Container | null>) => void;
+}
+declare const PixiShapeLayerInner: ({ ref, ...props }: PixiShapeLayerProps & {
+    ref?: React.Ref<ForwardedRefResponse | null>;
+}) => import("react/jsx-runtime").JSX.Element;
+declare const PixiShapeLayer: typeof PixiShapeLayerInner;
+export default PixiShapeLayer;

package/dist/components/PixiShapeLayer/drawShape.d.ts

@@ -0,0 +1,20 @@
+import { AepShapePath } from '../../types/aep';
+import * as PIXI from "pixi.js";
+export interface AepStrokeSnapshot {
+    color: string;
+    width: number;
+    cap?: "butt" | "round" | "square";
+    join?: "miter" | "round" | "bevel";
+}
+export interface AepTrimSnapshot {
+    start: number;
+    end: number;
+    offset?: number;
+}
+export interface DrawShapeOpts {
+    path: AepShapePath;
+    fill?: string;
+    stroke?: AepStrokeSnapshot;
+    trim?: AepTrimSnapshot;
+}
+export declare function drawShape(g: PIXI.Graphics, opts: DrawShapeOpts): void;

package/dist/components/PixiShapeLayer/index.d.ts

@@ -0,0 +1,4 @@
+export { default as PixiShapeLayer } from './PixiShapeLayer';
+export type { PixiShapeLayerProps, } from './PixiShapeLayer';
+export { drawShape, type DrawShapeOpts, type AepStrokeSnapshot, type AepTrimSnapshot, } from './drawShape';
+export { samplePath, sampleBezierPath, trimPolyline, type Point, } from './samplePath';

package/dist/components/PixiShapeLayer/samplePath.d.ts

@@ -0,0 +1,5 @@
+import { AepBezierPath, AepShapePath } from '../../types/aep';
+export type Point = [number, number];
+export declare function sampleBezierPath(path: AepBezierPath, samplesPerSegment?: number): Point[];
+export declare function samplePath(path: AepShapePath, samples?: number): Point[];
+export declare function trimPolyline(poly: Point[], start: number, end: number, offset?: number): Point[];

package/dist/components/PixiTextSprite/PixiTextSplit.d.ts

@@ -0,0 +1,26 @@
+import { AepLayer, AepTextAnimator } from '../../types/aep';
+import { AepTextLayoutGlyph } from '../../utils/textLayout';
+import * as React from "react";
+import * as PIXI from "pixi.js";
+type AepTextLayer = Extract<AepLayer, {
+    kind: "text";
+}>;
+export interface PixiTextSplitProps {
+    layer: AepTextLayer;
+    animators?: ReadonlyArray<AepTextAnimator>;
+    x: number;
+    y: number;
+    maxGlyphs?: number;
+}
+export declare class TextStyleCache {
+    private readonly capacity;
+    private readonly map;
+    hits: number;
+    misses: number;
+    constructor(capacity?: number);
+    get(key: string, build: () => PIXI.TextStyle): PIXI.TextStyle;
+    get hitRate(): number;
+}
+export declare function _textSplitStyleKey(glyph: AepTextLayoutGlyph, color: string): string;
+export declare const PixiTextSplit: React.FC<PixiTextSplitProps>;
+export {};

package/dist/components/PixiTextSprite/PixiTextSprite.d.ts

@@ -3,7 +3,7 @@ import { Effects } from '../../types/Effects';
 import { Animations } from '../../types';
 import * as React from "react";
 import * as PIXI from "pixi.js";
-export interface PixiTextSpriteProps extends PixiBaseSpriteProps {
+export interface PixiTextSpriteProps extends Omit<PixiBaseSpriteProps, "transformation"> {
     text: string;
     startAt: number;
     endAt: number;
@@ -13,7 +13,10 @@ export interface PixiTextSpriteProps extends PixiBaseSpriteProps {
         y: number;
         width: number;
         height: number;
-        anchor: number;
+        anchor: number | {
+            x: number;
+            y: number;
+        };
         rotation?: number;
         alpha?: number;
         scale?: number | [number, number];
@@ -33,7 +36,6 @@ export interface PixiTextSpriteProps extends PixiBaseSpriteProps {
         wordWrapWidth?: number;
         leading?: number;
         padding?: number;
-        border?: string;
         dropShadow?: boolean;
         dropShadowColor?: string | number;
         shadowOffsetX?: number;
@@ -49,6 +51,12 @@ export interface PixiTextSpriteProps extends PixiBaseSpriteProps {
         textBaseline?: string;
         trim?: boolean;
         backgroundColor?: string;
+        /**
+         * Pixi v8.16+ tagged text. Keys are tag names (e.g. `bold`,
+         * `highlight`); values are partial TextStyle options applied to
+         * any substring wrapped in `<tag>…</tag>` in `text`.
+         */
+        tagStyles?: Record<string, Partial<PIXI.TextStyleOptions>>;
         colorCorrection?: {
             enabled?: boolean;
             temperature?: number;
@@ -83,7 +91,11 @@ export interface PixiTextSpriteProps extends PixiBaseSpriteProps {
     onAnchorTransformationEnd?: (endData: any) => void;
     onDobuleClick?: () => void;
     onContainerRefReady?: (uniqueId: string, ref: React.MutableRefObject<PIXI.Container | null>) => void;
+    onTextRefReady?: (uniqueId: string, ref: React.MutableRefObject<PIXI.Text | null>) => void;
     onSpriteRefReady?: (uniqueId: string, ref: React.MutableRefObject<PIXI.Container | null>) => void;
 }
-declare const PixiTextSprite: React.ForwardRefExoticComponent<PixiTextSpriteProps & React.RefAttributes<ForwardedRefResponse | null>>;
-export default PixiTextSprite;
+declare const PixiTextSprite: ({ ref, ...props }: PixiTextSpriteProps & {
+    ref?: React.Ref<ForwardedRefResponse | null>;
+}) => import("react/jsx-runtime").JSX.Element;
+declare const MemoizedPixiTextSprite: typeof PixiTextSprite;
+export default MemoizedPixiTextSprite;

package/dist/components/PixiTextSprite/index.d.ts

@@ -1 +1,4 @@
 export { default as PixiTextSprite } from './PixiTextSprite';
+export { PixiTextSplit, type PixiTextSplitProps } from './PixiTextSplit';
+export { composeAnimators, selectorPerChar, rangeShapeValue, type AepCharOffset, } from './textAnimator';
+export { resolveTextSplitFills, type AepTextSplitFills, } from './resolveTextSplitFills';

package/dist/components/PixiTextSprite/resolveTextSplitFills.d.ts

@@ -0,0 +1,27 @@
+import { AepLayer, AepThemeMap } from '../../types/aep';
+type AepTextLayer = Extract<AepLayer, {
+    kind: "text";
+}>;
+/**
+ * Per-frame fill resolution for the split-text path. Hoists the work out
+ * of the per-glyph render loop and out of the React tree so it can be
+ * verified in isolation.
+ *
+ *   layerHex  — `style.fill` flattened against `theme` (theme refs
+ *               resolved, fallbacks honored) and then sampled at `frame`.
+ *               `undefined` when `style.fill` is missing.
+ *   runHexes  — same treatment for each entry in `style.runs[*].fill`
+ *               (plain hex animatable today; future work may admit
+ *               theme refs at this level too). Indexed by runIndex.
+ *               `undefined` entries mean "inherit from layer."
+ *
+ * The fallback color is intentionally `#ffffff` (engine default for
+ * text); callers may pass a different one if their renderer's default
+ * differs.
+ */
+export interface AepTextSplitFills {
+    layerHex: string | undefined;
+    runHexes: ReadonlyArray<string | undefined>;
+}
+export declare function resolveTextSplitFills(layer: AepTextLayer, theme: AepThemeMap | undefined, frame: number, fallback?: string): AepTextSplitFills;
+export {};

package/dist/components/PixiTextSprite/textAnimator.d.ts

@@ -0,0 +1,22 @@
+import { AepAnimatable, AepRangeShape, AepTextAnimator, AepTextRangeSelector } from '../../types/aep';
+export declare function staticOf<T>(field: AepAnimatable<T> | undefined, fallback: T): T;
+export declare function rangeShapeValue(shape: AepRangeShape, t: number): number;
+export declare function selectorPerChar(range: AepTextRangeSelector, animatorAmount: number, count: number): number[];
+export interface AnimatorGlyphIndex {
+    charIndex: number;
+    wordIndex: number;
+    lineIndex: number;
+}
+export declare function selectorPerGlyph(range: AepTextRangeSelector, animatorAmount: number, glyphs: ReadonlyArray<AnimatorGlyphIndex>): number[];
+export interface AepCharOffset {
+    position: [number, number];
+    scale: [number, number];
+    rotation: number;
+    opacity: number;
+    fillMix: {
+        color: string;
+        amount: number;
+    } | null;
+}
+export declare function composeAnimators(animators: ReadonlyArray<AepTextAnimator>, glyphsOrCount: number | ReadonlyArray<AnimatorGlyphIndex>, amountOverrides?: ReadonlyArray<number>): AepCharOffset[];
+export declare const _identityCharOffset: AepCharOffset;

package/dist/components/PixiThreeSprite/PixiThreeSprite.d.ts

@@ -0,0 +1,14 @@
+import * as React from "react";
+export interface PixiThreeSpriteProps {
+    width?: number | string;
+    height?: number | string;
+    background?: string;
+    camera?: {
+        position?: [number, number, number];
+        fov?: number;
+    };
+    /** Add the default ambient + directional rig. Set false for custom lighting. */
+    defaultLights?: boolean;
+    children: React.ReactNode;
+}
+export declare const PixiThreeSprite: React.FC<PixiThreeSpriteProps>;

package/dist/components/PixiThreeSprite/index.d.ts

@@ -0,0 +1,2 @@
+export { PixiThreeSprite } from './PixiThreeSprite';
+export type { PixiThreeSpriteProps } from './PixiThreeSprite';

package/dist/components/PixiUnifiedTransformer/PixiUnifiedTransformer.d.ts

@@ -1,15 +1,16 @@
-import * as React from "react";
-import * as PIXI from "pixi.js";
+import * as React from 'react';
+import type * as PIXI from 'pixi.js';
 type RefsMap = Record<string, React.MutableRefObject<PIXI.Container | null>>;
+type MouseOverTransformerRef = React.MutableRefObject<{
+    isMouseOver?: boolean;
+    isDragging?: boolean;
+    dragType?: string | null;
+} | null>;
 type PixiUnifiedTransformerProps = {
     selectedElementIds: string[];
     containerRefsMap: RefsMap;
     spriteHelperRef?: React.MutableRefObject<any>;
-    mouseOverTransformerRef?: React.MutableRefObject<{
-        isMouseOver?: boolean;
-        isDragging?: boolean;
-        dragType?: string | null;
-    } | null>;
+    mouseOverTransformerRef?: MouseOverTransformerRef;
     isMultiSelect?: boolean;
     selectedGroupId?: string | null;
     selectedElementIdInGroup?: string | null;
@@ -20,7 +21,18 @@ type PixiUnifiedTransformerProps = {
     getRotationByElementId?: (uniqueId: string) => number | undefined;
     onDoubleClickElement?: (uniqueId: string) => void;
     onTransformChange?: (uniqueId: string) => void;
-    onTransformCommit?: (uniqueId: string, endData: any) => void;
+    onTransformCommit?: (uniqueId: string, endData: unknown) => void;
+    rotateEnabled?: boolean;
+    scaleEnabled?: boolean;
+    translateEnabled?: boolean;
+    skewEnabled?: boolean;
+    boxScalingEnabled?: boolean;
+    boxRotationEnabled?: boolean;
+    showNonFocusedBorders?: boolean;
+    focusedElementIndex?: number;
+    individualBorderColor?: number;
+    individualBorderThickness?: number;
+    individualBorderAlpha?: number;
 };
 declare const PixiUnifiedTransformer: React.FC<PixiUnifiedTransformerProps>;
 export default PixiUnifiedTransformer;

package/dist/components/PixiVideoSprite/PixiVideoCanvasSync.d.ts

@@ -22,5 +22,7 @@ export interface PixiVideoSpriteProps extends PixiBaseSpriteProps {
     onAnchorTransformationEnd?: (endData: any) => void;
     canvasImageRef?: CanvasImageProps;
 }
-declare const PixiVideoCanvasSyncSprite: React.ForwardRefExoticComponent<PixiVideoSpriteProps & React.RefAttributes<ForwardedRefResponse | null>>;
+declare const PixiVideoCanvasSyncSprite: ({ ref, ...props }: PixiVideoSpriteProps & {
+    ref?: React.Ref<ForwardedRefResponse | null>;
+}) => import("react/jsx-runtime").JSX.Element;
 export default PixiVideoCanvasSyncSprite;

package/dist/components/PixiVideoSprite/PixiVideoSprite.d.ts

@@ -21,5 +21,8 @@ export interface PixiVideoSpriteProps extends PixiBaseSpriteProps {
     onContainerRefReady?: (uniqueId: string, ref: React.MutableRefObject<PIXI.Container | null>) => void;
     onSpriteRefReady?: (uniqueId: string, ref: React.MutableRefObject<PIXI.Container | null>) => void;
 }
-declare const PixiVideoSprite: React.ForwardRefExoticComponent<PixiVideoSpriteProps & React.RefAttributes<ForwardedRefResponse | null>>;
-export default PixiVideoSprite;
+declare const PixiVideoSprite: ({ ref, ...props }: PixiVideoSpriteProps & {
+    ref?: React.Ref<ForwardedRefResponse | null>;
+}) => import("react/jsx-runtime").JSX.Element;
+declare const MemoizedPixiVideoSprite: typeof PixiVideoSprite;
+export default MemoizedPixiVideoSprite;

package/dist/components/index.d.ts

@@ -9,3 +9,8 @@ export * from './PixiSequence';
 export * from './PixiRemotionSprite';
 export * from './PixiLottieSprite';
 export * from './PixiUnifiedTransformer';
+export * from './PixiShapeLayer';
+export * from './PixiNullObject';
+export * from './PixiPreComp';
+export * from './AepMask';
+export * from './AepComposition';

package/dist/events/Events.d.ts

@@ -1,5 +1,4 @@
 import { DependencyList } from 'react';
-
 export declare function useCustomEventListener<T>(eventName: string, eventHandler: (data: T) => void, deps?: DependencyList): (el: HTMLElement | null) => void;
 export declare function emitCustomEvent<T>(eventName: string, data?: T): void;
 export declare function newCustomEventEmitter(): {

package/dist/hocs/AbstractContainer.d.ts

@@ -26,5 +26,7 @@ interface AbstractContainerProps extends PixiBaseSpriteProps {
      */
     onSpriteRefReady?: (uniqueId: string, ref: React.MutableRefObject<PIXI.Container | null>) => void;
 }
-declare const AbstractContainer: React.ForwardRefExoticComponent<AbstractContainerProps & React.RefAttributes<ForwardedRefResponse | null>>;
+declare const AbstractContainer: ({ ref, ...props }: AbstractContainerProps & {
+    ref?: React.Ref<ForwardedRefResponse | null>;
+}) => import("react/jsx-runtime").JSX.Element;
 export default AbstractContainer;

package/dist/hocs/BorderMaskContainer.d.ts

@@ -0,0 +1,28 @@
+import { Container } from 'pixi.js';
+import { MaskTypes } from '../types/MaskTypes';
+import * as React from "react";
+export interface BorderConfig {
+    width: number;
+    color: number | string | null;
+}
+export interface BorderMaskContainerProps {
+    x?: number;
+    y?: number;
+    width?: number;
+    height?: number;
+    border?: BorderConfig;
+    roundedCorners?: boolean | number;
+    maskShape?: MaskTypes;
+    spriteRef?: React.RefObject<Container | null>;
+    children: React.ReactNode;
+}
+/**
+ * BorderMaskContainer — wraps a sprite child with an optional stroke
+ * border and/or a Graphics mask (rounded rect or named shape).
+ *
+ * Mask attaches imperatively to `spriteRef.current` (Container/Sprite).
+ * Cleans up on unmount or shape change.
+ */
+declare const BorderMaskContainer: React.FC<BorderMaskContainerProps>;
+export default BorderMaskContainer;
+export { BorderMaskContainer };

package/dist/hocs/OverlayTilingSprite.d.ts

@@ -1,4 +1,4 @@
-export declare enum OverlayTypes {
+export declare enum OverlayTilingSpriteTypes {
     NONE = "none",
     NORMAL = "normal",
     LENSFLARE = "lensflare",
@@ -20,11 +20,11 @@ export interface Overlays {
 }
 export declare const overlays: Overlays;
 interface PixiOverlayProps {
-    overlay: OverlayTypes;
+    overlay: OverlayTilingSpriteTypes;
     width: number;
     height: number;
     x: number;
     y: number;
 }
-export declare const PixiOverlayTilingSprite: (props: PixiOverlayProps) => import("react/jsx-runtime").JSX.Element;
+export declare const PixiOverlayTilingSprite: (props: PixiOverlayProps) => import("react/jsx-runtime").JSX.Element | null;
 export {};

package/dist/hocs/drawMaskShape.d.ts

@@ -0,0 +1,3 @@
+import { Graphics } from 'pixi.js';
+import { MaskType } from '../types/MaskTypes';
+export declare function drawMaskShape(g: Graphics, shape: MaskType, cx: number, cy: number, w: number, h: number): void;

package/dist/hocs/index.d.ts

@@ -0,0 +1,5 @@
+export { default as AbstractContainer } from './AbstractContainer';
+export { default as BorderMaskContainer } from './BorderMaskContainer';
+export type { BorderMaskContainerProps, BorderConfig } from './BorderMaskContainer';
+export { drawMaskShape } from './drawMaskShape';
+export * from './OverlayTilingSprite';

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

@@ -0,0 +1,7 @@
+import { AepAnimatable } from '../../types/aep';
+import { AepScalarTimelineBuild } from './buildScalarValueTimeline';
+export type AepAudioLevelBuild = AepScalarTimelineBuild;
+export interface AudioLevelTarget {
+    level: number;
+}
+export declare function buildAudioLevelTimeline(level: AepAnimatable<number> | undefined, fps: number, inPointFrames: number, target: AudioLevelTarget): AepAudioLevelBuild;

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

@@ -0,0 +1,13 @@
+import { AepBezierPath, AepKeyframe } from '../../types/aep';
+export interface AepBezierPathTimelineBuild {
+    timeline: gsap.core.Timeline;
+    hasAnimation: boolean;
+    initial: AepBezierPath;
+}
+export type AepAnimatableBezier = AepBezierPath | AepKeyframe<AepBezierPath>[];
+/**
+ * @deprecated AEP bezier-path animation now flows via React-side
+ *   `sampleAnimatedBezier`. Preserved for downstream GSAP consumers and
+ *   the internal `useAepBezierPathAnimator` (also deprecated).
+ */
+export declare function buildBezierPathTimeline(field: AepAnimatableBezier | undefined, fps: number, inPointFrames: number, onPath: (path: AepBezierPath) => void): AepBezierPathTimelineBuild;

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

@@ -0,0 +1,24 @@
+import { AepAnimatable } from '../../types/aep';
+export interface RgbaColor {
+    r: number;
+    g: number;
+    b: number;
+    a: number;
+}
+export declare function parseHexColor(hex: string): RgbaColor;
+export declare function rgbaToHex(c: RgbaColor): string;
+export interface AepColorTimelineBuild {
+    timeline: gsap.core.Timeline;
+    hasAnimation: boolean;
+    target: RgbaColor;
+}
+/**
+ * Color → gsap subtimeline. Each segment tweens RGBA floats; the
+ * consumer reads `target` inside onUpdate and recomposes to a hex
+ * string for the renderer.
+ *
+ * @deprecated AEP color animation now flows via React-side
+ *   `sampleColor`. Preserved for downstream GSAP consumers and the
+ *   internal `useAepColorAnimator` (also deprecated).
+ */
+export declare function buildColorValueTimeline(field: AepAnimatable<string> | undefined, fps: number, inPointFrames: number): AepColorTimelineBuild;

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

@@ -0,0 +1,20 @@
+import { AepLayer, AepTransform } from '../../types/aep';
+export type AepTweenTarget = Record<string, unknown>;
+export interface AepBuiltSegment {
+    at: number;
+    op: "to" | "set";
+    vars: Record<string, unknown>;
+    props: string[];
+}
+export declare function planPropSegments(prop: keyof AepTransform, field: unknown, fps: number, inPointFrames: number): AepBuiltSegment[];
+export interface AepLayerTimelineBuild {
+    timeline: gsap.core.Timeline;
+    segments: AepBuiltSegment[];
+}
+/**
+ * @deprecated The AEP runtime no longer builds GSAP sub-timelines for
+ *   layer transforms — `useAepLayerTransform` samples them directly
+ *   from `ctx.currentFrame`. Preserved for parity with downstream
+ *   consumers and the existing vitest coverage of segment planning.
+ */
+export declare function buildLayerTimeline(layer: AepLayer, target: AepTweenTarget, fps: number): AepLayerTimelineBuild;

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

@@ -0,0 +1,6 @@
+import { AepAnimatable } from '../../types/aep';
+export interface AepScalarTimelineBuild {
+    timeline: gsap.core.Timeline;
+    hasAnimation: boolean;
+}
+export declare function buildScalarValueTimeline(field: AepAnimatable<number> | undefined, fps: number, inPointFrames: number, target: Record<string, number>, prop: string): AepScalarTimelineBuild;

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

@@ -0,0 +1,17 @@
+import { AepAnimatable } from '../../types/aep';
+export interface AepVec2TimelineBuild {
+    timeline: gsap.core.Timeline;
+    hasAnimation: boolean;
+    target: {
+        x: number;
+        y: number;
+    };
+}
+type Vec2 = [number, number];
+/**
+ * @deprecated AEP vec2 animation now flows via React-side `sampleVec2`.
+ *   Preserved for downstream GSAP consumers and the internal
+ *   `useAepVec2Animator` (also deprecated).
+ */
+export declare function buildVec2ValueTimeline(field: AepAnimatable<Vec2> | undefined, fps: number, inPointFrames: number): AepVec2TimelineBuild;
+export {};

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

@@ -0,0 +1,3 @@
+export declare function easeNameFor(handles: readonly [number, number, number, number] | undefined | null): string;
+export declare function _resetEaseCache(): void;
+export declare function _easeCacheSize(): number;

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

@@ -0,0 +1,5 @@
+import { AepEffectHandler } from './effects/types';
+export declare function getEffectHandler(name: string): AepEffectHandler | undefined;
+export declare function registerEffectHandler(handler: AepEffectHandler): void;
+export declare function _resetEffectRegistry(): void;
+export declare function _listEffectHandlers(): string[];

package/dist/hooks/aep/effects/brightnessContrast.d.ts

@@ -0,0 +1,2 @@
+import { AepEffectHandler } from './types';
+export declare const brightnessContrastHandler: AepEffectHandler;

package/dist/hooks/aep/effects/dropShadow.d.ts

@@ -0,0 +1,2 @@
+import { AepEffectHandler } from './types';
+export declare const dropShadowHandler: AepEffectHandler;

package/dist/hooks/aep/effects/fastBoxBlur.d.ts

@@ -0,0 +1,2 @@
+import { AepEffectHandler } from './types';
+export declare const fastBoxBlurHandler: AepEffectHandler;

package/dist/hooks/aep/effects/gaussianBlur.d.ts

@@ -0,0 +1,2 @@
+import { AepEffectHandler } from './types';
+export declare const gaussianBlurHandler: AepEffectHandler;

package/dist/hooks/aep/effects/glow.d.ts

@@ -0,0 +1,2 @@
+import { AepEffectHandler } from './types';
+export declare const glowHandler: AepEffectHandler;

package/dist/hooks/aep/effects/hueSaturation.d.ts

@@ -0,0 +1,2 @@
+import { AepEffectHandler } from './types';
+export declare const hueSaturationHandler: AepEffectHandler;

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

@@ -0,0 +1,9 @@
+export { gaussianBlurHandler } from './gaussianBlur';
+export { dropShadowHandler } from './dropShadow';
+export { glowHandler } from './glow';
+export { hueSaturationHandler } from './hueSaturation';
+export { levelsHandler } from './levels';
+export { tintHandler } from './tint';
+export { brightnessContrastHandler } from './brightnessContrast';
+export { fastBoxBlurHandler } from './fastBoxBlur';
+export { staticParam, type AepEffectHandler, type AepEffectParamSnapshot } from './types';

package/dist/hooks/aep/effects/levels.d.ts

@@ -0,0 +1,2 @@
+import { AepEffectHandler } from './types';
+export declare const levelsHandler: AepEffectHandler;

package/dist/hooks/aep/effects/tint.d.ts

@@ -0,0 +1,2 @@
+import { AepEffectHandler } from './types';
+export declare const tintHandler: AepEffectHandler;

package/dist/hooks/aep/effects/types.d.ts

@@ -0,0 +1,8 @@
+import { Filter } from 'pixi.js';
+export type AepEffectParamSnapshot = Record<string, unknown>;
+export interface AepEffectHandler {
+    name: string;
+    build(snapshot: AepEffectParamSnapshot): Filter;
+    apply(filter: Filter, snapshot: AepEffectParamSnapshot): void;
+}
+export declare function staticParam<T = unknown>(snapshot: AepEffectParamSnapshot, key: string, fallback: T): T;

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;