reacthub-pixitweenjs 0.2.6 → 0.2.8

package/src/components/PixiSVGSprite/PixiSvgPathSprite.tsx

@@ -1,22 +1,19 @@
 import * as React from "react";
-import { useContext, useEffect, useRef, useState } from "react";
+import { useRef } from "react";
 // @ts-ignore
 import PropTypes from "prop-types";
-import { GsapPixieContext } from "../../providers/GsapPixieContextProvider";
-import { Sprite, Container, useApp, withFilters } from "@pixi/react";
-import { AdjustmentFilter } from "@pixi/filter-adjustment";
+import { Sprite, Container, useApp } from "@pixi/react";
 import * as PIXI from "pixi.js";
-import gsap from "gsap";
 import { SVG } from "pixi-svg";
-import PixiTransformer from "../../utils/PixiTransformer";
 // @ts-ignore
 import svgpath from "svgpath";
 // @ts-ignore
 import isEmpty from "lodash/isEmpty";
-import { getAnimByName } from "../../utils/GsapAnim";
-import { TransformationEnd } from "../../types/transformation";
+import { PixiBaseSpriteProps } from "../../types/BaseProps";
+import AbstractContainer from "../../hocs/AbstractContainer";
+import { Effects } from "../../types/Effects";
 
-type PixiSvgPathSpriteProps = {
+interface PixiSvgPathSpriteProps extends PixiBaseSpriteProps {
   uniqueId: string;
   path: string;
   startAt: number;
@@ -60,7 +57,7 @@ type PixiSvgPathSpriteProps = {
       alpha?: number;
       scaleInput?: number;
     };
-    effect?: string;
+    effect?: Effects;
   };
   pointerdown?: () => void;
   pointerup?: () => void;
@@ -71,55 +68,32 @@ type PixiSvgPathSpriteProps = {
   mouseout?: () => void;
   applyTransformer?: boolean;
   onAnchorTransformationEnd?: (endData: any) => void;
-};
-
-const Filters = withFilters(Container, {
-  blur: PIXI.filters.BlurFilter,
-  adjust: AdjustmentFilter,
-  matrix: PIXI.filters.ColorMatrixFilter,
-});
-
-/** 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 PixiSvgPathSprite: React.FC<PixiSvgPathSpriteProps> = (props) => {
   //// State
-  const [isMounted, setIsMounted] = React.useState(false);
-  const [, setIsTransformerDragging] = useState(false);
-  const [, setIsMouseOverTransformer] = useState(false);
   const [texture, setTexture] = React.useState<any>(null);
 
   //// 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,
     path,
-    startAt,
-    endAt,
-    initialAlpha,
     transformation: {
       x,
       y,
       width,
       height,
       anchor,
-      animation,
-      colorCorrection,
-      effect,
       fill,
       stroke = "none",
       strokeWidth = 0,
-      blurRadius = 0,
     },
     pointerdown,
     pointerup,
@@ -128,102 +102,12 @@ const PixiSvgPathSprite: React.FC<PixiSvgPathSpriteProps> = (props) => {
     pointerover,
     mouseover,
     mouseout,
-    applyTransformer,
-    onAnchorTransformationEnd,
   } = props;
 
-  // color corrections
-  const {
-    contrast = 1,
-    saturation = 1,
-    exposure = 1,
-    alpha = 1,
-  } = colorCorrection || {};
-
   const app = useApp();
 
-  /** adjustment filter */
-  const adjustments = {
-    brightness: exposure,
-    contrast,
-    saturation,
-    alpha,
-  };
-
   // const fillColor = PIXI.utils.string2hex(fill || "#262730");
 
-  /** 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);
-    }
-  }, []);
-
   React.useEffect(() => {
     const transformedPath = svgpath(path).scale(5).translate(0, 0).toString();
     // console.log('path', path);
@@ -242,104 +126,32 @@ const PixiSvgPathSprite: React.FC<PixiSvgPathSpriteProps> = (props) => {
   }, [app, path, stroke, strokeWidth, fill]);
 
   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,
+    <AbstractContainer {...props}>
+      <Container ref={parentNode}>
+        <Container ref={imgGroupRef}>
+          {texture && (
+            <Sprite
+              texture={texture}
+              width={width}
+              height={height}
+              anchor={anchor}
+              ref={imageRef}
+              x={x}
+              y={y}
               // @ts-ignore
-              matrix: CYAN,
-            }}
-          >
-            {/* @ts-ignore */}
-
-            <Container ref={imgGroupRef}>
-              {texture && (
-                <Sprite
-                  texture={texture}
-                  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>
-        ) : (
-          // @ts-ignore
-          <Container ref={imgGroupRef}>
-            {texture && (
-              <Sprite
-                texture={texture}
-                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>
-        )}
+              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}
-        />
-      )}
-    </Container>
+    </AbstractContainer>
   );
 };
 

package/src/components/PixiTextSprite/PixiTextSprite.stories.tsx

@@ -96,10 +96,10 @@ export const Normal: Story = {
     locked: false,
     applyTransformer: false,
     transformation: {
-      x: 100,
-      y: 100,
-      width: 150,
-      height: 150,
+      x: 200,
+      y: 200,
+      width: 200,
+      height: 200,
       anchor: 0.5,
       rotation: 0,
       alpha: 1,
@@ -141,10 +141,10 @@ export const FadeIn: Story = {
     locked: false,
     applyTransformer: false,
     transformation: {
-      x: 100,
-      y: 100,
-      width: 150,
-      height: 150,
+      x: 200,
+      y: 200,
+      width: 200,
+      height: 200,
       anchor: 0.5,
       rotation: 0,
       alpha: 1,
@@ -174,3 +174,55 @@ export const FadeIn: Story = {
     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}>
+      <PixiTextSprite {...args} />
+    </AppStateContextProvider>
+  ),
+  args: {
+    uniqueId: "TextSpritexx001", // uniqueId of the sprite
+    text: "Hello Welcome to PixiJS",
+    locked: false,
+    applyTransformer: false,
+    transformation: {
+      x: 200,
+      y: 200,
+      width: 200,
+      height: 200,
+      anchor: 0.5,
+      rotation: 0,
+      alpha: 1,
+      scale: 1,
+      blendMode: 0,
+      colorCorrection: {
+        enabled: true,
+        contrast: 2,
+        saturation: 2,
+        exposure: 2,
+        blurRadius: 1,
+      },
+      fill: "#00ff99",
+      fontSize: 80,
+      fontFamily: "Arial",
+      align: "center",
+      stroke: "#522d2d",
+      strokeThickness: 0,
+      letterSpacing: 0,
+      lineHeight: 0,
+      dropShadow: false,
+      dropShadowColor: "#522d2d",
+      dropShadowBlur: 0,
+      wordWrap: false,
+      wordWrapWidth: 5000000,
+      padding: 10,
+      textBaseline: "alphabetic",
+      trim: false,
+    },
+    startAt: 0,
+    endAt: 10,
+    initialAlpha: 1,
+  },
+};