reacthub-pixitweenjs 0.2.6 → 0.2.8

package/src/components/PixiImageSprite/PixiImageSprite.tsx

@@ -1,114 +1,27 @@
 import * as React from "react";
-import { useContext, useEffect, useRef, useState } from "react";
-// @ts-ignore
-import PropTypes from "prop-types";
-import { GsapPixieContext } from "../../providers/GsapPixieContextProvider";
-import { Sprite, Container, withFilters } from "@pixi/react";
-import { AdjustmentFilter } from "@pixi/filter-adjustment";
+import { useRef } from "react";
+import { Sprite, Container } from "@pixi/react";
 import * as PIXI from "pixi.js";
-import gsap from "gsap";
-import PixiTransformer from "../../utils/PixiTransformer";
-
 // @ts-ignore
 import isEmpty from "lodash/isEmpty";
-import { getAnimByName } from "../../utils/GsapAnim";
-import { TransformationEnd } from "../../types/transformation";
-
-type PixiImageSpriteProps = {
-  uniqueId: string;
-  src: string;
-  startAt: number;
-  endAt: number;
-  initialAlpha: number;
-  transformation: {
-    x: number;
-    y: number;
-    width: number;
-    height: number;
-    anchor: number;
-    rotation?: number;
-    alpha?: number;
-    scale?: number | [number, number];
-    tint?: number;
-    blendMode?: number;
-    animation?: string;
-    colorCorrection?: {
-      enabled?: boolean;
-      temperature?: number;
-      hue?: number;
-      contrast?: number;
-      saturation?: number;
-      exposure?: number;
-      reset?: boolean;
-      sharpness?: number;
-      value?: number;
-      levels?: number;
-      luminance?: number;
-      enhance?: number;
-      blurRadius?: number;
-      red?: number;
-      green?: number;
-      blue?: number;
-      alpha?: number;
-      scaleInput?: number;
-    };
-    effect?: string;
-  };
-  pointerdown?: () => void;
-  pointerup?: () => void;
-  mousedown?: () => void;
-  mouseup?: () => void;
-  pointerover?: () => void;
-  mouseover?: () => void;
-  mouseout?: () => void;
-  applyTransformer?: boolean;
-  onAnchorTransformationEnd?: (endData: any) => void;
-};
-
-const Filters = withFilters(Container, {
-  blur: PIXI.filters.BlurFilter,
-  adjust: AdjustmentFilter,
-  matrix: PIXI.filters.ColorMatrixFilter,
-});
+// setup hocs
+import AbstractContainer from "../../hocs/AbstractContainer";
+import { PixiBaseSpriteProps } from "../../types/BaseProps";
 
-/** CYAN Filters */
-const CYAN = [1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0];
-
-const PixiImageSprite: React.FC<PixiImageSpriteProps> = (props) => {
+const PixiImageSprite: React.FC<PixiBaseSpriteProps> = (props) => {
   //// State
-  const [isMounted, setIsMounted] = React.useState(false);
-  const [, setIsTransformerDragging] = useState(false);
-  const [, setIsMouseOverTransformer] = useState(false);
 
-  console.log("allProps", props);
   //// Refs
   const imageRef = useRef<PIXI.Sprite>(null);
-  const containerRef = useRef<PIXI.Container>(null);
-  const parentNode = useRef<PIXI.Container>(null);
   const imgGroupRef = useRef<PIXI.Container>(null);
-  const transformerRef = useRef<PIXI.Container>(null);
 
   //// Context
-  const { tl } = useContext(GsapPixieContext);
 
   /// 1001
   // console.log("contxt Values", tl);
   const {
-    uniqueId,
     src,
-    startAt,
-    endAt,
-    initialAlpha,
-    transformation: {
-      x,
-      y,
-      width,
-      height,
-      anchor,
-      animation,
-      colorCorrection,
-      effect,
-    },
+    transformation: { x, y, width, height, anchor },
     pointerdown,
     pointerup,
     mousedown,
@@ -116,193 +29,31 @@ const PixiImageSprite: React.FC<PixiImageSpriteProps> = (props) => {
     pointerover,
     mouseover,
     mouseout,
-    applyTransformer,
-    onAnchorTransformationEnd,
   } = props;
 
-  // color corrections
-  const {
-    contrast = 1,
-    saturation = 1,
-    exposure = 1,
-    blurRadius = 0,
-    alpha = 1,
-  } = colorCorrection || {};
-
-  /** adjustment filter */
-  const adjustments = {
-    brightness: exposure,
-    contrast,
-    saturation,
-    alpha,
-  };
-
-  /** handle on tranformer onchange */
-  const handleOnTransformChange = React.useCallback(() => {
-    setIsTransformerDragging(true);
-  }, []);
-
-  // transformer to handle sprite transformation
-  const handleOnTransformEnd = React.useCallback(
-    (endData: TransformationEnd) => {
-      console.log("changeEnd", endData);
-      if (onAnchorTransformationEnd) {
-        console.log("running onAnchorTransformationEnd");
-        onAnchorTransformationEnd(endData);
-      }
-    },
-    []
-  );
-
-  useEffect(() => {
-    let ctx = gsap.context(() => {});
-    if (containerRef.current && tl.current) {
-      const data = {
-        duration: Number(endAt) - Number(startAt),
-      };
-
-      const ease = getAnimByName(animation || "None");
-      ctx = gsap.context(() => {
-        if (!isEmpty(ease.from)) {
-          tl.current
-            .from(containerRef.current, { ...ease.from }, startAt)
-            .to(imgGroupRef.current, { alpha: 1, duration: 0.2 }, startAt)
-            .from(imgGroupRef.current, { ...data }, startAt)
-            .to(containerRef.current, { alpha: 0, duration: 0.2 }, endAt - 0.2);
-        } else if (!isEmpty(ease.to)) {
-          tl.current
-            .to(
-              containerRef.current,
-              { alpha: 1, duration: 0.2, ...ease.to },
-              startAt
-            )
-            .from(imgGroupRef.current, { ...data }, startAt)
-            .to(containerRef.current, { alpha: 0, duration: 0.2 }, endAt - 0.2);
-        } else if (!isEmpty(ease.fromTo)) {
-          tl.current
-            .fromTo(
-              containerRef.current,
-              ease.fromTo?.from,
-              ease.fromTo?.to,
-              startAt
-            )
-            .from(imgGroupRef.current, { ...data }, startAt)
-            .to(containerRef.current, { alpha: 0, duration: 0.2 }, endAt - 0.2);
-        } else {
-          tl.current
-            .to(containerRef.current, { alpha: 1, duration: 0.01 }, startAt)
-            .from(imgGroupRef.current, { ...data }, startAt)
-            .to(
-              containerRef.current,
-              { alpha: 0, duration: 0.1 },
-              Number(endAt) - Number(0.1)
-            );
-        }
-      });
-    }
-    return () => ctx.revert(); // cleanup!
-  }, [animation, startAt, endAt]);
-
-  React.useEffect(() => {
-    if (containerRef.current) {
-      setIsMounted(true);
-    }
-  }, []);
-
   return (
-    // @ts-ignore
-    <Container ref={parentNode}>
-      {/* @ts-ignore */}
-      <Container
-        ref={containerRef}
-        alpha={initialAlpha}
-        position={[x, y]}
-        pivot={[x, y]}
-        width={width}
-        height={height}
-      >
-        {colorCorrection && colorCorrection.enabled ? (
-          <Filters
-            scale={1}
-            blur={{ blur: blurRadius, quality: 4 }}
-            adjust={adjustments}
-            apply={({ matrix }: { matrix: any }) => {
-              if (effect === "BlackAndWhite") {
-                matrix.desaturate();
-              } else if (effect === "Sepia") {
-                matrix.sepia();
-              } else if (effect === "RetroVintage") {
-                matrix.negative();
-              } else if (effect === "NightVision") {
-                matrix.negative();
-              } else if (effect === "Normal") {
-                matrix.reset();
-              }
-            }}
-            matrix={{
-              enabled: true,
-              // @ts-ignore
-              matrix: CYAN,
-            }}
-          >
-            {/* @ts-ignore */}
-            <Container ref={imgGroupRef}>
-              <Sprite
-                image={src}
-                width={width}
-                height={height}
-                anchor={anchor}
-                ref={imageRef}
-                x={x}
-                y={y}
-                // @ts-ignore
-                interactive={true}
-                pointerdown={pointerdown}
-                pointerup={pointerup}
-                pointerover={pointerover}
-                mousedown={mousedown}
-                mouseup={mouseup}
-                mouseover={mouseover}
-                mouseout={mouseout}
-              />
-            </Container>
-          </Filters>
-        ) : (
+    <AbstractContainer {...props}>
+      <Container ref={imgGroupRef}>
+        <Sprite
+          image={src}
+          width={width}
+          height={height}
+          anchor={anchor}
+          ref={imageRef}
+          x={x}
+          y={y}
           // @ts-ignore
-          <Container ref={imgGroupRef}>
-            <Sprite
-              image={src}
-              width={width}
-              height={height}
-              anchor={anchor}
-              ref={imageRef}
-              x={x}
-              y={y}
-              // @ts-ignore
-              interactive={true}
-              pointerdown={pointerdown}
-              pointerup={pointerup}
-              pointerover={pointerover}
-              mousedown={mousedown}
-              mouseup={mouseup}
-              mouseover={mouseover}
-              mouseout={mouseout}
-            />
-          </Container>
-        )}
-      </Container>
-      {applyTransformer && (
-        <PixiTransformer
-          pixiTransformerRef={transformerRef}
-          imageRef={containerRef}
-          isMounted={isMounted}
-          transformCommit={handleOnTransformEnd}
-          transformChange={handleOnTransformChange}
-          mouseoverEvent={setIsMouseOverTransformer}
-          uniqueId={uniqueId}
+          interactive={true}
+          pointerdown={pointerdown}
+          pointerup={pointerup}
+          pointerover={pointerover}
+          mousedown={mousedown}
+          mouseup={mouseup}
+          mouseover={mouseover}
+          mouseout={mouseout}
         />
-      )}
-    </Container>
+      </Container>
+    </AbstractContainer>
   );
 };
 

package/src/components/PixiSVGSprite/PixiSvgPathSprite.stories.tsx

@@ -84,11 +84,14 @@ export const Normal: Story = {
   args: {
     uniqueId: "svg001", // uniqueId of the sprite
     path: "M 100 100 L 300 100 L 200 300 z",
+    applyTransformer: false,
+    startAt: 0,
+    endAt: 10,
     transformation: {
-      x: 100,
-      y: 100,
-      width: 150,
-      height: 150,
+      x: 200,
+      y: 200,
+      width: 200,
+      height: 200,
       anchor: 0.5,
       rotation: 0,
       alpha: 1,
@@ -98,9 +101,6 @@ export const Normal: Story = {
       colorCorrection: {},
       fill: "#FFC0CB",
     },
-    applyTransformer: false,
-    startAt: 0,
-    endAt: 10,
     initialAlpha: 1,
   },
 };
@@ -114,11 +114,14 @@ export const FadeIn: Story = {
   args: {
     uniqueId: "surya002", // uniqueId of the sprite
     path: "M 100, 100 m -75, 0 a 75,75 0 1,0 150,0 a 75,75 0 1,0 -150,0",
+    applyTransformer: false,
+    startAt: 0,
+    endAt: 10,
     transformation: {
-      x: 100,
-      y: 100,
-      width: 150,
-      height: 150,
+      x: 200,
+      y: 200,
+      width: 200,
+      height: 200,
       anchor: 0.5,
       rotation: 0,
       alpha: 1,
@@ -129,9 +132,43 @@ export const FadeIn: Story = {
       colorCorrection: {},
       fill: "#fe2c54",
     },
+    initialAlpha: 0,
+  },
+};
+
+// More on writing stories with args: https://storybook.js.org/docs/react/writing-stories/args
+export const Filters: Story = {
+  render: (args: any) => (
+    <AppStateContextProvider {...args}>
+      <PixiSvgPathSprite {...args} />
+    </AppStateContextProvider>
+  ),
+  args: {
+    uniqueId: "svgfilters001", // uniqueId of the sprite
+    path: "M 100 100 L 300 100 L 200 300 z",
     applyTransformer: false,
     startAt: 0,
     endAt: 10,
-    initialAlpha: 0,
+    transformation: {
+      x: 200,
+      y: 200,
+      width: 200,
+      height: 200,
+      anchor: 0.5,
+      rotation: 0,
+      alpha: 1,
+      scale: 1,
+      tint: 0xffffff,
+      blendMode: 0,
+      colorCorrection: {
+        enabled: true,
+        contrast: 1,
+        saturation: 2,
+        exposure: 1,
+        blurRadius: 3,
+      },
+      fill: "#FFC0CB",
+    },
+    initialAlpha: 1,
   },
 };