Variable libPresetExitsConst

Type declaration

• ~disappear: {
      defaultConfig: {};
      effectCompositionFrequency: "on-first-play-only";
      immutableConfig: {
          composite: "replace";
          duration: 0;
          easing: "linear";
      };
      composeEffect(): {};
  }

  Element disappears instantaneously.

  • defaultConfig: {}

  • effectCompositionFrequency: "on-first-play-only"

  • immutableConfig: {
        composite: "replace";
        duration: 0;
        easing: "linear";
    }

    • Readonlycomposite: "replace"

    • Readonlyduration: 0

    • Readonlyeasing: "linear"

  • composeEffect:function

    • composeEffect(): {}

    • Returns {}

• ~fade-out: {
      defaultConfig: {};
      effectCompositionFrequency: "on-first-play-only";
      immutableConfig: {
          composite: "replace";
      };
      composeEffect(): {
          forwardKeyframesGenerator: (() => ({
              opacity?: undefined;
          } | {
              opacity: string;
          })[]);
      };
  }

  Element fades out to 0 opacity.

  • defaultConfig: {}

  • effectCompositionFrequency: "on-first-play-only"

  • immutableConfig: {
        composite: "replace";
    }

    • Readonlycomposite: "replace"

  • composeEffect:function

    • composeEffect(): {
          forwardKeyframesGenerator: (() => ({
              opacity?: undefined;
          } | {
              opacity: string;
          })[]);
      }

    • Returns {
          forwardKeyframesGenerator: (() => ({
              opacity?: undefined;
          } | {
              opacity: string;
          })[]);
      }

      • ReadonlyforwardKeyframesGenerator: (() => ({
            opacity?: undefined;
        } | {
            opacity: string;
        })[])

        • • (): ({
                opacity?: undefined;
            } | {
                opacity: string;
            })[]

          • Returns ({
                opacity?: undefined;
            } | {
                opacity: string;
            })[]

• ~fly-out: {
      defaultConfig: {};
      effectCompositionFrequency: "on-first-play-only";
      immutableConfig: {
          composite: "accumulate";
      };
      composeEffect(direction?:
          | "to-left"
          | "to-top"
          | "to-bottom"
          | "to-right"
          | "to-top-left"
          | "to-top-right"
          | "to-bottom-left"
          | "to-bottom-right"): {
          forwardKeyframesGenerator: (() => {
              translate: string;
          }[]);
      };
  }

  Element flies offscreen towards the specified direction

  • defaultConfig: {}

  • effectCompositionFrequency: "on-first-play-only"

  • immutableConfig: {
        composite: "accumulate";
    }

    • Readonlycomposite: "accumulate"

  • composeEffect:function

    • composeEffect(direction?): {
          forwardKeyframesGenerator: (() => {
              translate: string;
          }[]);
      }

    • Parameters

      • direction:
            | "to-left"
            | "to-top"
            | "to-bottom"
            | "to-right"
            | "to-top-left"
            | "to-top-right"
            | "to-bottom-left"
            | "to-bottom-right" = 'to-bottom'

        direction to which the element should exit

      Returns {
          forwardKeyframesGenerator: (() => {
              translate: string;
          }[]);
      }

      • forwardKeyframesGenerator: (() => {
            translate: string;
        }[])

        • • (): {
                translate: string;
            }[]

          • Returns {
                translate: string;
            }[]

• ~pinwheel: {
      defaultConfig: {};
      effectCompositionFrequency: "on-first-play-only";
      immutableConfig: {};
      composeEffect(numSpins?: number, direction?: "clockwise" | "counterclockwise"): {
          forwardKeyframesGenerator: (() => ({
              opacity?: undefined;
              rotate?: undefined;
              scale?: undefined;
          } | {
              opacity: number;
              rotate: string;
              scale: number;
          })[]);
      };
  }

  Element spins and shrinks while fading out.

  • defaultConfig: {}

  • effectCompositionFrequency: "on-first-play-only"

  • immutableConfig: {}

  • composeEffect:function

    • composeEffect(numSpins?, direction?): {
          forwardKeyframesGenerator: (() => ({
              opacity?: undefined;
              rotate?: undefined;
              scale?: undefined;
          } | {
              opacity: number;
              rotate: string;
              scale: number;
          })[]);
      }

    • Parameters

      • numSpins: number = 2

        number of times the element will spin
      • direction: "clockwise" | "counterclockwise" = 'clockwise'

        direction of the spin

      Returns {
          forwardKeyframesGenerator: (() => ({
              opacity?: undefined;
              rotate?: undefined;
              scale?: undefined;
          } | {
              opacity: number;
              rotate: string;
              scale: number;
          })[]);
      }

      • ReadonlyforwardKeyframesGenerator: (() => ({
            opacity?: undefined;
            rotate?: undefined;
            scale?: undefined;
        } | {
            opacity: number;
            rotate: string;
            scale: number;
        })[])

        • • (): ({
                opacity?: undefined;
                rotate?: undefined;
                scale?: undefined;
            } | {
                opacity: number;
                rotate: string;
                scale: number;
            })[]

          • Returns ({
                opacity?: undefined;
                rotate?: undefined;
                scale?: undefined;
            } | {
                opacity: number;
                rotate: string;
                scale: number;
            })[]

• ~sink-down: {
      defaultConfig: {};
      effectCompositionFrequency: "on-first-play-only";
      immutableConfig: {
          composite: "accumulate";
      };
      composeEffect(): {
          forwardKeyframesGenerator: (() => (
              | {
                  composite: "replace";
                  easing?: undefined;
                  offset?: undefined;
                  opacity: number;
                  translate?: undefined;
              }
              | {
                  composite?: undefined;
                  easing: string;
                  offset: number;
                  opacity?: undefined;
                  translate: string;
              }
              | {
                  composite?: undefined;
                  easing?: undefined;
                  offset: number;
                  opacity?: undefined;
                  translate: string;
              }
              | {
                  composite?: undefined;
                  easing?: undefined;
                  offset?: undefined;
                  opacity?: undefined;
                  translate: string;
              })[]);
          reverseKeyframesEffect: true;
      };
  }

  Element floats up slightly and then accelerates to the bottom of the screen.

  • defaultConfig: {}

  • effectCompositionFrequency: "on-first-play-only"

  • immutableConfig: {
        composite: "accumulate";
    }

    • Readonlycomposite: "accumulate"

  • composeEffect:function

    • composeEffect(): {
          forwardKeyframesGenerator: (() => (
              | {
                  composite: "replace";
                  easing?: undefined;
                  offset?: undefined;
                  opacity: number;
                  translate?: undefined;
              }
              | {
                  composite?: undefined;
                  easing: string;
                  offset: number;
                  opacity?: undefined;
                  translate: string;
              }
              | {
                  composite?: undefined;
                  easing?: undefined;
                  offset: number;
                  opacity?: undefined;
                  translate: string;
              }
              | {
                  composite?: undefined;
                  easing?: undefined;
                  offset?: undefined;
                  opacity?: undefined;
                  translate: string;
              })[]);
          reverseKeyframesEffect: true;
      }

    • Returns {
          forwardKeyframesGenerator: (() => (
              | {
                  composite: "replace";
                  easing?: undefined;
                  offset?: undefined;
                  opacity: number;
                  translate?: undefined;
              }
              | {
                  composite?: undefined;
                  easing: string;
                  offset: number;
                  opacity?: undefined;
                  translate: string;
              }
              | {
                  composite?: undefined;
                  easing?: undefined;
                  offset: number;
                  opacity?: undefined;
                  translate: string;
              }
              | {
                  composite?: undefined;
                  easing?: undefined;
                  offset?: undefined;
                  opacity?: undefined;
                  translate: string;
              })[]);
          reverseKeyframesEffect: true;
      }

      • forwardKeyframesGenerator: (() => (
            | {
                composite: "replace";
                easing?: undefined;
                offset?: undefined;
                opacity: number;
                translate?: undefined;
            }
            | {
                composite?: undefined;
                easing: string;
                offset: number;
                opacity?: undefined;
                translate: string;
            }
            | {
                composite?: undefined;
                easing?: undefined;
                offset: number;
                opacity?: undefined;
                translate: string;
            }
            | {
                composite?: undefined;
                easing?: undefined;
                offset?: undefined;
                opacity?: undefined;
                translate: string;
            })[])

        • • (): (
                | {
                    composite: "replace";
                    easing?: undefined;
                    offset?: undefined;
                    opacity: number;
                    translate?: undefined;
                }
                | {
                    composite?: undefined;
                    easing: string;
                    offset: number;
                    opacity?: undefined;
                    translate: string;
                }
                | {
                    composite?: undefined;
                    easing?: undefined;
                    offset: number;
                    opacity?: undefined;
                    translate: string;
                }
                | {
                    composite?: undefined;
                    easing?: undefined;
                    offset?: undefined;
                    opacity?: undefined;
                    translate: string;
                })[]

          • Returns (
                | {
                    composite: "replace";
                    easing?: undefined;
                    offset?: undefined;
                    opacity: number;
                    translate?: undefined;
                }
                | {
                    composite?: undefined;
                    easing: string;
                    offset: number;
                    opacity?: undefined;
                    translate: string;
                }
                | {
                    composite?: undefined;
                    easing?: undefined;
                    offset: number;
                    opacity?: undefined;
                    translate: string;
                }
                | {
                    composite?: undefined;
                    easing?: undefined;
                    offset?: undefined;
                    opacity?: undefined;
                    translate: string;
                })[]

      • reverseKeyframesEffect: true

• ~slide-out: {
      defaultConfig: {
          duration: 100;
      };
      effectCompositionFrequency: "on-first-play-only";
      immutableConfig: {
          composite: "accumulate";
      };
      composeEffect(direction?:
          | "to-left"
          | "to-top"
          | "to-bottom"
          | "to-right"): {
          forwardKeyframesGenerator: (() => (
              | {
                  clipPath: string;
                  marginBottom?: undefined;
                  marginRight?: undefined;
                  translate: string;
              }
              | {
                  clipPath: string;
                  marginBottom: string;
                  marginRight?: undefined;
                  translate: string;
              }
              | {
                  clipPath: string;
                  marginBottom?: undefined;
                  marginRight: string;
                  translate: string;
              }
              | {
                  clipPath: string;
              })[]);
      };
  }

  Element slides out to the specified direction while also wiping. Particularly effective if the element is adjacent to a different element, making it look as if it is sliding into that element like a dropdown collapsing.

  • defaultConfig: {
        duration: 100;
    }

    • Readonlyduration: 100

  • effectCompositionFrequency: "on-first-play-only"

  • immutableConfig: {
        composite: "accumulate";
    }

    • Readonlycomposite: "accumulate"

  • composeEffect:function

    • composeEffect(direction?): {
          forwardKeyframesGenerator: (() => (
              | {
                  clipPath: string;
                  marginBottom?: undefined;
                  marginRight?: undefined;
                  translate: string;
              }
              | {
                  clipPath: string;
                  marginBottom: string;
                  marginRight?: undefined;
                  translate: string;
              }
              | {
                  clipPath: string;
                  marginBottom?: undefined;
                  marginRight: string;
                  translate: string;
              }
              | {
                  clipPath: string;
              })[]);
      }

    • Parameters

      • direction:
            | "to-left"
            | "to-top"
            | "to-bottom"
            | "to-right" = 'to-top'

        direction to which to slide

      Returns {
          forwardKeyframesGenerator: (() => (
              | {
                  clipPath: string;
                  marginBottom?: undefined;
                  marginRight?: undefined;
                  translate: string;
              }
              | {
                  clipPath: string;
                  marginBottom: string;
                  marginRight?: undefined;
                  translate: string;
              }
              | {
                  clipPath: string;
                  marginBottom?: undefined;
                  marginRight: string;
                  translate: string;
              }
              | {
                  clipPath: string;
              })[]);
      }

      • forwardKeyframesGenerator: (() => (
            | {
                clipPath: string;
                marginBottom?: undefined;
                marginRight?: undefined;
                translate: string;
            }
            | {
                clipPath: string;
                marginBottom: string;
                marginRight?: undefined;
                translate: string;
            }
            | {
                clipPath: string;
                marginBottom?: undefined;
                marginRight: string;
                translate: string;
            }
            | {
                clipPath: string;
            })[])

        • • (): (
                | {
                    clipPath: string;
                    marginBottom?: undefined;
                    marginRight?: undefined;
                    translate: string;
                }
                | {
                    clipPath: string;
                    marginBottom: string;
                    marginRight?: undefined;
                    translate: string;
                }
                | {
                    clipPath: string;
                    marginBottom?: undefined;
                    marginRight: string;
                    translate: string;
                }
                | {
                    clipPath: string;
                })[]

          • Returns (
                | {
                    clipPath: string;
                    marginBottom?: undefined;
                    marginRight?: undefined;
                    translate: string;
                }
                | {
                    clipPath: string;
                    marginBottom: string;
                    marginRight?: undefined;
                    translate: string;
                }
                | {
                    clipPath: string;
                    marginBottom?: undefined;
                    marginRight: string;
                    translate: string;
                }
                | {
                    clipPath: string;
                })[]

• ~wipe: {
      defaultConfig: {};
      effectCompositionFrequency: "on-first-play-only";
      immutableConfig: {
          composite: "replace";
      };
      composeEffect(direction?:
          | "from-left"
          | "from-top"
          | "from-bottom"
          | "from-right"): {
          forwardKeyframesGenerator: (() => Keyframe[]);
      };
  }

  Element is wiped off, starting from the specified direction.

  • defaultConfig: {}

  • effectCompositionFrequency: "on-first-play-only"

  • immutableConfig: {
        composite: "replace";
    }

    • Readonlycomposite: "replace"

  • composeEffect:function

    • composeEffect(direction?): {
          forwardKeyframesGenerator: (() => Keyframe[]);
      }

    • Parameters

      • direction:
            | "from-left"
            | "from-top"
            | "from-bottom"
            | "from-right" = 'from-bottom'

      Returns {
          forwardKeyframesGenerator: (() => Keyframe[]);
      }

      • forwardKeyframesGenerator: (() => Keyframe[])

        • • (): Keyframe[]

          • Returns Keyframe[]