3055 lines
115 KiB
TypeScript
3055 lines
115 KiB
TypeScript
declare module "kute.js/src/objects/supportedProperties" {
|
|
export default supportedProperties;
|
|
const supportedProperties: {};
|
|
}
|
|
declare module "kute.js/src/objects/defaultValues" {
|
|
export default defaultValues;
|
|
const defaultValues: {};
|
|
}
|
|
declare module "kute.js/src/objects/defaultOptions" {
|
|
export default defaultOptions;
|
|
namespace defaultOptions {
|
|
const duration: number;
|
|
const delay: number;
|
|
const easing: string;
|
|
const repeat: number;
|
|
const repeatDelay: number;
|
|
const yoyo: boolean;
|
|
const resetStart: boolean;
|
|
const offset: number;
|
|
}
|
|
}
|
|
declare module "kute.js/src/objects/prepareProperty" {
|
|
export default prepareProperty;
|
|
const prepareProperty: {};
|
|
}
|
|
declare module "kute.js/src/objects/prepareStart" {
|
|
export default prepareStart;
|
|
const prepareStart: {};
|
|
}
|
|
declare module "kute.js/src/objects/onStart" {
|
|
export default onStart;
|
|
const onStart: {};
|
|
}
|
|
declare module "kute.js/src/objects/onComplete" {
|
|
export default onComplete;
|
|
const onComplete: {};
|
|
}
|
|
declare module "kute.js/src/objects/crossCheck" {
|
|
export default crossCheck;
|
|
const crossCheck: {};
|
|
}
|
|
declare module "kute.js/src/objects/linkProperty" {
|
|
export default linkProperty;
|
|
const linkProperty: {};
|
|
}
|
|
declare module "kute.js/src/objects/util" {
|
|
export default Util;
|
|
const Util: {};
|
|
}
|
|
declare module "kute.js/src/objects/interpolate" {
|
|
export default interpolate;
|
|
const interpolate: {};
|
|
}
|
|
declare module "kute.js/src/animation/animation" {
|
|
/**
|
|
* Animation Class
|
|
*
|
|
* Registers components by populating KUTE.js objects and makes sure
|
|
* no duplicate component / property is allowed.
|
|
*/
|
|
export default class Animation {
|
|
/**
|
|
* @constructor
|
|
* @param {KUTE.fullComponent} Component
|
|
*/
|
|
constructor(Component: KUTE.fullComponent);
|
|
}
|
|
}
|
|
declare module "kute.js/src/animation/animationBase" {
|
|
/**
|
|
* Animation Base Class
|
|
*
|
|
* Registers components by populating KUTE.js objects and makes sure
|
|
* no duplicate component / property is allowed.
|
|
*
|
|
* This class only registers the minimal amount of component information
|
|
* required to enable components animation, which means value processing
|
|
* as well as `to()` and `allTo()` methods are not supported.
|
|
*/
|
|
export default class AnimationBase {
|
|
/**
|
|
* @class
|
|
* @param {KUTE.baseComponent} Component
|
|
*/
|
|
constructor(Component: KUTE.baseComponent);
|
|
_: number;
|
|
}
|
|
}
|
|
declare module "kute.js/src/animation/animationDevelopment" {
|
|
/**
|
|
* Animation Development Class
|
|
*
|
|
* Registers components by populating KUTE.js objects and makes sure
|
|
* no duplicate component / property is allowed.
|
|
*
|
|
* In addition to the default class, this one provides more component
|
|
* information to help you with custom component development.
|
|
*/
|
|
export default class AnimationDevelopment extends Animation {
|
|
/**
|
|
*
|
|
* @param {KUTE.fullComponent} args
|
|
*/
|
|
constructor(Component: any);
|
|
}
|
|
import Animation from "kute.js/src/animation/animation";
|
|
}
|
|
declare module "kute.js/src/process/getStyleForProperty" {
|
|
/**
|
|
* getStyleForProperty
|
|
*
|
|
* Returns the computed style property for element for .to() method.
|
|
* Used by for the `.to()` static method.
|
|
*
|
|
* @param {Element} elem
|
|
* @param {string} propertyName
|
|
* @returns {string}
|
|
*/
|
|
export default function getStyleForProperty(elem: Element, propertyName: string): string;
|
|
}
|
|
declare module "kute.js/src/interpolation/numbers" {
|
|
/**
|
|
* Numbers Interpolation Function.
|
|
*
|
|
* @param {number} a start value
|
|
* @param {number} b end value
|
|
* @param {number} v progress
|
|
* @returns {number} the interpolated number
|
|
*/
|
|
export default function numbers(a: number, b: number, v: number): number;
|
|
}
|
|
declare module "kute.js/src/util/trueDimension" {
|
|
export default trueDimension;
|
|
/**
|
|
* trueDimension
|
|
*
|
|
* Returns the string value of a specific CSS property converted into a nice
|
|
* { v = value, u = unit } object.
|
|
*
|
|
* @param {string} dimValue the property string value
|
|
* @param {boolean | number} isAngle sets the utility to investigate angles
|
|
* @returns {{v: number, u: string}} the true {value, unit} tuple
|
|
*/
|
|
function trueDimension(dimValue: string, isAngle: boolean | number): {
|
|
v: number;
|
|
u: string;
|
|
};
|
|
}
|
|
declare module "kute.js/src/objects/kute" {
|
|
export default KEC;
|
|
/**
|
|
* The KUTE.js Execution Context
|
|
*/
|
|
const KEC: {};
|
|
}
|
|
declare module "kute.js/src/components/backgroundPositionBase" {
|
|
/**
|
|
* Sets the property update function.
|
|
* @param {string} prop the property name
|
|
*/
|
|
export function onStartBgPos(prop: string): void;
|
|
export default BackgroundPositionBase;
|
|
namespace BackgroundPositionBase {
|
|
const component: string;
|
|
const property: string;
|
|
namespace Interpolate {
|
|
export { numbers };
|
|
}
|
|
namespace functions {
|
|
export { onStartBgPos as onStart };
|
|
}
|
|
}
|
|
import numbers from "kute.js/src/interpolation/numbers";
|
|
}
|
|
declare module "kute.js/src/components/backgroundPosition" {
|
|
export default BackgroundPosition;
|
|
namespace BackgroundPosition {
|
|
export const component: string;
|
|
export const property: string;
|
|
export const defaultValue: number[];
|
|
export namespace Interpolate {
|
|
export { numbers };
|
|
}
|
|
export { bgPositionFunctions as functions };
|
|
export namespace Util {
|
|
export { trueDimension };
|
|
}
|
|
}
|
|
import numbers from "kute.js/src/interpolation/numbers";
|
|
namespace bgPositionFunctions {
|
|
export { getBgPos as prepareStart };
|
|
export { prepareBgPos as prepareProperty };
|
|
export { onStartBgPos as onStart };
|
|
}
|
|
import trueDimension from "kute.js/src/util/trueDimension";
|
|
/**
|
|
* Returns the property computed style.
|
|
* @param {string} prop the property
|
|
* @returns {string} the property computed style
|
|
*/
|
|
function getBgPos(prop: string): string;
|
|
/**
|
|
* Returns the property tween object.
|
|
* @param {string} _ the property name
|
|
* @param {string} value the property value
|
|
* @returns {number[]} the property tween object
|
|
*/
|
|
function prepareBgPos(_: string, value: string): number[];
|
|
import { onStartBgPos } from "kute.js/src/components/backgroundPositionBase";
|
|
}
|
|
declare module "kute.js/src/interpolation/units" {
|
|
/**
|
|
* Units Interpolation Function.
|
|
*
|
|
* @param {number} a start value
|
|
* @param {number} b end value
|
|
* @param {string} u unit
|
|
* @param {number} v progress
|
|
* @returns {string} the interpolated value + unit string
|
|
*/
|
|
export default function units(a: number, b: number, u: string, v: number): string;
|
|
}
|
|
declare module "kute.js/src/components/borderRadiusBase" {
|
|
/**
|
|
* Sets the property update function.
|
|
* @param {string} tweenProp the property name
|
|
*/
|
|
export function radiusOnStartFn(tweenProp: string): void;
|
|
export default BorderRadiusBase;
|
|
namespace BorderRadiusBase {
|
|
const component: string;
|
|
const category: string;
|
|
namespace Interpolate {
|
|
export { units };
|
|
}
|
|
namespace functions {
|
|
export { radiusOnStart as onStart };
|
|
}
|
|
}
|
|
import units from "kute.js/src/interpolation/units";
|
|
const radiusOnStart: {};
|
|
}
|
|
declare module "kute.js/src/components/borderRadius" {
|
|
/**
|
|
* Returns the current property computed style.
|
|
* @param {string} tweenProp the property name
|
|
* @returns {string} the property computed style
|
|
*/
|
|
export function getRadius(tweenProp: string): string;
|
|
/**
|
|
* Returns the property tween object.
|
|
* @param {string} value the property value
|
|
* @returns {{v: number, u: string}} the property tween object
|
|
*/
|
|
export function prepareRadius(_: any, value: string): {
|
|
v: number;
|
|
u: string;
|
|
};
|
|
export namespace radiusFunctions {
|
|
export { getRadius as prepareStart };
|
|
export { prepareRadius as prepareProperty };
|
|
export { radiusOnStart as onStart };
|
|
}
|
|
export default BorderRadius;
|
|
const radiusOnStart: {};
|
|
namespace BorderRadius {
|
|
export const component: string;
|
|
export const category: string;
|
|
export { radiusProps as properties };
|
|
export { radiusValues as defaultValues };
|
|
export namespace Interpolate {
|
|
export { units };
|
|
}
|
|
export { radiusFunctions as functions };
|
|
export namespace Util {
|
|
export { trueDimension };
|
|
}
|
|
}
|
|
const radiusProps: string[];
|
|
const radiusValues: {};
|
|
import units from "kute.js/src/interpolation/units";
|
|
import trueDimension from "kute.js/src/util/trueDimension";
|
|
}
|
|
declare module "kute.js/src/components/boxModelBase" {
|
|
/**
|
|
* Sets the update function for the property.
|
|
* @param {string} tweenProp the property name
|
|
*/
|
|
export function boxModelOnStart(tweenProp: string): void;
|
|
export default BoxModelBase;
|
|
namespace BoxModelBase {
|
|
export const component: string;
|
|
export const category: string;
|
|
export { baseBoxProps as properties };
|
|
export namespace Interpolate {
|
|
export { numbers };
|
|
}
|
|
export namespace functions {
|
|
export { baseBoxOnStart as onStart };
|
|
}
|
|
}
|
|
const baseBoxProps: string[];
|
|
import numbers from "kute.js/src/interpolation/numbers";
|
|
const baseBoxOnStart: {};
|
|
}
|
|
declare module "kute.js/src/components/boxModel" {
|
|
export default BoxModel;
|
|
namespace BoxModel {
|
|
export const component: string;
|
|
export const category: string;
|
|
export { boxModelProperties as properties };
|
|
export { boxModelValues as defaultValues };
|
|
export namespace Interpolate {
|
|
export { numbers };
|
|
}
|
|
export { boxModelFunctions as functions };
|
|
}
|
|
const boxModelProperties: string[];
|
|
const boxModelValues: {};
|
|
import numbers from "kute.js/src/interpolation/numbers";
|
|
namespace boxModelFunctions {
|
|
export { getBoxModel as prepareStart };
|
|
export { prepareBoxModel as prepareProperty };
|
|
export { boxPropsOnStart as onStart };
|
|
}
|
|
/**
|
|
* Returns the current property computed style.
|
|
* @param {string} tweenProp the property name
|
|
* @returns {string} computed style for property
|
|
*/
|
|
function getBoxModel(tweenProp: string): string;
|
|
/**
|
|
* Returns the property tween object.
|
|
* @param {string} tweenProp the property name
|
|
* @param {string} value the property value
|
|
* @returns {number} the property tween object
|
|
*/
|
|
function prepareBoxModel(tweenProp: string, value: string): number;
|
|
const boxPropsOnStart: {};
|
|
}
|
|
declare module "kute.js/src/components/boxModelEssential" {
|
|
export default BoxModelEssential;
|
|
namespace BoxModelEssential {
|
|
export const component: string;
|
|
export const category: string;
|
|
export { essentialBoxProps as properties };
|
|
export { essentialBoxPropsValues as defaultValues };
|
|
export namespace Interpolate {
|
|
export { numbers };
|
|
}
|
|
export { essentialBoxModelFunctions as functions };
|
|
export namespace Util {
|
|
export { trueDimension };
|
|
}
|
|
}
|
|
const essentialBoxProps: string[];
|
|
namespace essentialBoxPropsValues {
|
|
const top: number;
|
|
const left: number;
|
|
const width: number;
|
|
const height: number;
|
|
}
|
|
import numbers from "kute.js/src/interpolation/numbers";
|
|
namespace essentialBoxModelFunctions {
|
|
export { getBoxModel as prepareStart };
|
|
export { prepareBoxModel as prepareProperty };
|
|
export { essentialBoxOnStart as onStart };
|
|
}
|
|
import trueDimension from "kute.js/src/util/trueDimension";
|
|
/**
|
|
* Returns the current property computed style.
|
|
* @param {string} tweenProp the property name
|
|
* @returns {string} computed style for property
|
|
*/
|
|
function getBoxModel(tweenProp: string): string;
|
|
/**
|
|
* Returns the property tween object.
|
|
* @param {string} tweenProp the property name
|
|
* @param {string} value the property name
|
|
* @returns {number} the property tween object
|
|
*/
|
|
function prepareBoxModel(tweenProp: string, value: string): number;
|
|
const essentialBoxOnStart: {};
|
|
}
|
|
declare module "kute.js/src/components/clipPropertyBase" {
|
|
/**
|
|
* Sets the property update function.
|
|
* @param {string} tweenProp the property name
|
|
*/
|
|
export function onStartClip(tweenProp: string): void;
|
|
export default ClipPropertyBase;
|
|
namespace ClipPropertyBase {
|
|
const component: string;
|
|
const property: string;
|
|
namespace Interpolate {
|
|
export { numbers };
|
|
}
|
|
namespace functions {
|
|
export { onStartClip as onStart };
|
|
}
|
|
}
|
|
import numbers from "kute.js/src/interpolation/numbers";
|
|
}
|
|
declare module "kute.js/src/components/clipProperty" {
|
|
export default ClipProperty;
|
|
namespace ClipProperty {
|
|
export const component: string;
|
|
export const property: string;
|
|
export const defaultValue: number[];
|
|
export namespace Interpolate {
|
|
export { numbers };
|
|
}
|
|
export { clipFunctions as functions };
|
|
export namespace Util {
|
|
export { trueDimension };
|
|
}
|
|
}
|
|
import numbers from "kute.js/src/interpolation/numbers";
|
|
namespace clipFunctions {
|
|
export { getClip as prepareStart };
|
|
export { prepareClip as prepareProperty };
|
|
export { onStartClip as onStart };
|
|
}
|
|
import trueDimension from "kute.js/src/util/trueDimension";
|
|
/**
|
|
* Returns the current property computed style.
|
|
* @param {string} tweenProp the property name
|
|
* @returns {string | number[]} computed style for property
|
|
*/
|
|
function getClip(tweenProp: string): string | number[];
|
|
/**
|
|
* Returns the property tween object.
|
|
* @param {string} _ the property name
|
|
* @param {string} value the property value
|
|
* @returns {number[]} the property tween object
|
|
*/
|
|
function prepareClip(_: string, value: string): number[];
|
|
import { onStartClip } from "kute.js/src/components/clipPropertyBase";
|
|
}
|
|
declare module "kute.js/src/util/hexToRGB" {
|
|
export default hexToRGB;
|
|
/**
|
|
* hexToRGB
|
|
*
|
|
* Converts a #HEX color format into RGB
|
|
* and returns a color object {r,g,b}.
|
|
*
|
|
* @param {string} hex the degree angle
|
|
* @returns {KUTE.colorObject | null} the radian angle
|
|
*/
|
|
function hexToRGB(hex: string): KUTE.colorObject | null;
|
|
}
|
|
declare module "kute.js/src/util/trueColor" {
|
|
export default trueColor;
|
|
/**
|
|
* trueColor
|
|
*
|
|
* Transform any color to rgba()/rgb() and return a nice RGB(a) object.
|
|
*
|
|
* @param {string} colorString the color input
|
|
* @returns {KUTE.colorObject} the {r,g,b,a} color object
|
|
*/
|
|
function trueColor(colorString: string): KUTE.colorObject;
|
|
}
|
|
declare module "kute.js/src/interpolation/colors" {
|
|
/**
|
|
* Color Interpolation Function.
|
|
*
|
|
* @param {KUTE.colorObject} a start color
|
|
* @param {KUTE.colorObject} b end color
|
|
* @param {number} v progress
|
|
* @returns {string} the resulting color
|
|
*/
|
|
export default function colors(a: KUTE.colorObject, b: KUTE.colorObject, v: number): string;
|
|
}
|
|
declare module "kute.js/src/components/colorPropertiesBase" {
|
|
/**
|
|
* Sets the property update function.
|
|
* @param {string} tweenProp the property name
|
|
*/
|
|
export function onStartColors(tweenProp: string): void;
|
|
export namespace baseColors {
|
|
const component: string;
|
|
const category: string;
|
|
namespace Interpolate {
|
|
export { numbers };
|
|
export { colors };
|
|
}
|
|
namespace functions {
|
|
export { colorsOnStart as onStart };
|
|
}
|
|
}
|
|
export default baseColors;
|
|
import numbers from "kute.js/src/interpolation/numbers";
|
|
import colors from "kute.js/src/interpolation/colors";
|
|
const colorsOnStart: {};
|
|
}
|
|
declare module "kute.js/src/components/colorProperties" {
|
|
export default colorProperties;
|
|
namespace colorProperties {
|
|
export const component: string;
|
|
export const category: string;
|
|
export { supportedColors as properties };
|
|
export { defaultColors as defaultValues };
|
|
export namespace Interpolate {
|
|
export { numbers };
|
|
export { colors };
|
|
}
|
|
export { colorFunctions as functions };
|
|
export namespace Util {
|
|
export { trueColor };
|
|
}
|
|
}
|
|
const supportedColors: string[];
|
|
const defaultColors: {};
|
|
import numbers from "kute.js/src/interpolation/numbers";
|
|
import colors from "kute.js/src/interpolation/colors";
|
|
namespace colorFunctions {
|
|
export { getColor as prepareStart };
|
|
export { prepareColor as prepareProperty };
|
|
export { colorsOnStart as onStart };
|
|
}
|
|
import trueColor from "kute.js/src/util/trueColor";
|
|
/**
|
|
* Returns the current property computed style.
|
|
* @param {string} prop the property name
|
|
* @returns {string} property computed style
|
|
*/
|
|
function getColor(prop: string): string;
|
|
/**
|
|
* Returns the property tween object.
|
|
* @param {string} _ the property name
|
|
* @param {string} value the property value
|
|
* @returns {KUTE.colorObject} the property tween object
|
|
*/
|
|
function prepareColor(_: string, value: string): KUTE.colorObject;
|
|
const colorsOnStart: {};
|
|
}
|
|
declare module "kute.js/src/process/getInlineStyle" {
|
|
/**
|
|
* getInlineStyle
|
|
* Returns the transform style for element from
|
|
* cssText. Used by for the `.to()` static method.
|
|
*
|
|
* @param {Element} el target element
|
|
* @returns {object}
|
|
*/
|
|
export default function getInlineStyle(el: Element): object;
|
|
}
|
|
declare module "kute.js/src/util/getPrefix" {
|
|
export default getPrefix;
|
|
/**
|
|
* getPrefix
|
|
*
|
|
* Returns browser CSS3 prefix. Keep `for()`
|
|
* for wider browser support.
|
|
*
|
|
* @returns {?string} the browser prefix
|
|
*/
|
|
function getPrefix(): string | null;
|
|
}
|
|
declare module "kute.js/src/util/trueProperty" {
|
|
export default trueProperty;
|
|
/**
|
|
* trueProperty
|
|
*
|
|
* Returns prefixed property name in a legacy browser
|
|
* or the regular name in modern browsers.
|
|
*
|
|
* @param {string} property the property name
|
|
* @returns {string} the right property name for every browser
|
|
*/
|
|
function trueProperty(property: string): string;
|
|
}
|
|
declare module "kute.js/src/components/crossBrowserMove" {
|
|
/**
|
|
* Sets the property update function.
|
|
* @param {string} tweenProp the `path` property
|
|
*/
|
|
export function onStartComponent(tweenProp: string): void;
|
|
export namespace baseCrossBrowserMove {
|
|
const component: string;
|
|
const property: string;
|
|
namespace Interpolate {
|
|
export { numbers };
|
|
}
|
|
namespace functions {
|
|
export { onStartComponent as onStart };
|
|
}
|
|
}
|
|
export default crossBrowserMove;
|
|
import numbers from "kute.js/src/interpolation/numbers";
|
|
namespace crossBrowserMove {
|
|
const component_1: string;
|
|
export { component_1 as component };
|
|
const property_1: string;
|
|
export { property_1 as property };
|
|
export const defaultValue: number[];
|
|
export namespace Interpolate_1 {
|
|
export { numbers };
|
|
}
|
|
export { Interpolate_1 as Interpolate };
|
|
export { componentFunctions as functions };
|
|
export namespace Util {
|
|
export { trueProperty };
|
|
}
|
|
}
|
|
namespace componentFunctions {
|
|
export { getComponentCurrentValue as prepareStart };
|
|
export { prepareComponentValue as prepareProperty };
|
|
export { onStartComponent as onStart };
|
|
}
|
|
import trueProperty from "kute.js/src/util/trueProperty";
|
|
/**
|
|
* Returns the property current style.
|
|
*/
|
|
function getComponentCurrentValue(): number[];
|
|
/**
|
|
* Returns the property tween object.
|
|
* @param {string} _ property name
|
|
* @param {string} value property value
|
|
* @returns {number[]} the property tween object
|
|
*/
|
|
function prepareComponentValue(_: string, value: string): number[];
|
|
}
|
|
declare module "kute.js/src/components/filterEffectsBase" {
|
|
/**
|
|
* Sets the `drop-shadow` sub-property update function.
|
|
* * disimbiguation `dropshadow` interpolation function and `dropShadow` property
|
|
* @param {string} tweenProp the property name
|
|
*/
|
|
export function dropshadow(a: any, b: any, v: any): string;
|
|
/**
|
|
* Sets the property update function.
|
|
* @param {string} tweenProp the property name
|
|
*/
|
|
export function onStartFilter(tweenProp: string): void;
|
|
export default baseFilter;
|
|
namespace baseFilter {
|
|
const component: string;
|
|
const property: string;
|
|
namespace Interpolate {
|
|
export { numbers as opacity };
|
|
export { numbers as blur };
|
|
export { numbers as saturate };
|
|
export { numbers as grayscale };
|
|
export { numbers as brightness };
|
|
export { numbers as contrast };
|
|
export { numbers as sepia };
|
|
export { numbers as invert };
|
|
export { numbers as hueRotate };
|
|
export namespace dropShadow {
|
|
export { numbers };
|
|
export { colors };
|
|
export { dropshadow };
|
|
}
|
|
}
|
|
namespace functions {
|
|
export { onStartFilter as onStart };
|
|
}
|
|
}
|
|
import numbers from "kute.js/src/interpolation/numbers";
|
|
import colors from "kute.js/src/interpolation/colors";
|
|
}
|
|
declare module "kute.js/src/components/filterEffects" {
|
|
export default filterEffects;
|
|
namespace filterEffects {
|
|
export const component: string;
|
|
export const property: string;
|
|
export namespace defaultValue {
|
|
const opacity: number;
|
|
const blur: number;
|
|
const saturate: number;
|
|
const grayscale: number;
|
|
const brightness: number;
|
|
const contrast: number;
|
|
const sepia: number;
|
|
const invert: number;
|
|
const hueRotate: number;
|
|
const dropShadow: (number | {
|
|
r: number;
|
|
g: number;
|
|
b: number;
|
|
})[];
|
|
const url: string;
|
|
}
|
|
export namespace Interpolate {
|
|
export { numbers as opacity };
|
|
export { numbers as blur };
|
|
export { numbers as saturate };
|
|
export { numbers as grayscale };
|
|
export { numbers as brightness };
|
|
export { numbers as contrast };
|
|
export { numbers as sepia };
|
|
export { numbers as invert };
|
|
export { numbers as hueRotate };
|
|
export namespace dropShadow_1 {
|
|
export { numbers };
|
|
export { colors };
|
|
export { dropshadow };
|
|
}
|
|
export { dropShadow_1 as dropShadow };
|
|
}
|
|
export { filterFunctions as functions };
|
|
export namespace Util {
|
|
export { parseDropShadow };
|
|
export { parseFilterString };
|
|
export { replaceDashNamespace };
|
|
export { trueColor };
|
|
}
|
|
}
|
|
import numbers from "kute.js/src/interpolation/numbers";
|
|
import colors from "kute.js/src/interpolation/colors";
|
|
import { dropshadow } from "kute.js/src/components/filterEffectsBase";
|
|
namespace filterFunctions {
|
|
export { getFilter as prepareStart };
|
|
export { prepareFilter as prepareProperty };
|
|
export { onStartFilter as onStart };
|
|
export { crossCheckFilter as crossCheck };
|
|
}
|
|
/**
|
|
* Returns `drop-shadow` sub-property object.
|
|
* @param {(string | number)[]} shadow and `Array` with `drop-shadow` parameters
|
|
* @returns {KUTE.filterList['dropShadow']} the expected `drop-shadow` values
|
|
*/
|
|
function parseDropShadow(shadow: (string | number)[]): KUTE.filterList['dropShadow'];
|
|
/**
|
|
* Returns an array with current filter sub-properties values.
|
|
* @param {string} currentStyle the current filter computed style
|
|
* @returns {{[x: string]: number}} the filter tuple
|
|
*/
|
|
function parseFilterString(currentStyle: string): {
|
|
[x: string]: number;
|
|
};
|
|
/**
|
|
* Returns camelCase filter sub-property.
|
|
* @param {string} str source string
|
|
* @returns {string} camelCase property name
|
|
*/
|
|
function replaceDashNamespace(str: string): string;
|
|
import trueColor from "kute.js/src/util/trueColor";
|
|
/**
|
|
* Returns the current property computed style.
|
|
* @param {string} tweenProp the property name
|
|
* @param {string} value the property value
|
|
* @returns {string} computed style for property
|
|
*/
|
|
function getFilter(tweenProp: string, value: string): string;
|
|
/**
|
|
* Returns the property tween object.
|
|
* @param {string} _ the property name
|
|
* @param {string} value the property name
|
|
* @returns {KUTE.filterList} the property tween object
|
|
*/
|
|
function prepareFilter(_: string, value: string): KUTE.filterList;
|
|
import { onStartFilter } from "kute.js/src/components/filterEffectsBase";
|
|
/**
|
|
* Adds missing sub-properties in `valuesEnd` from `valuesStart`.
|
|
* @param {string} tweenProp the property name
|
|
*/
|
|
function crossCheckFilter(tweenProp: string): void;
|
|
}
|
|
declare module "kute.js/src/components/htmlAttributesBase" {
|
|
export namespace onStartAttr {
|
|
/**
|
|
* onStartAttr.attr
|
|
*
|
|
* Sets the sub-property update function.
|
|
* @param {string} tweenProp the property name
|
|
*/
|
|
function attr(tweenProp: string): void;
|
|
/**
|
|
* onStartAttr.attr
|
|
*
|
|
* Sets the sub-property update function.
|
|
* @param {string} tweenProp the property name
|
|
*/
|
|
function attr(tweenProp: string): void;
|
|
/**
|
|
* onStartAttr.attributes
|
|
*
|
|
* Sets the update function for the property.
|
|
* @param {string} tweenProp the property name
|
|
*/
|
|
function attributes(tweenProp: string): void;
|
|
/**
|
|
* onStartAttr.attributes
|
|
*
|
|
* Sets the update function for the property.
|
|
* @param {string} tweenProp the property name
|
|
*/
|
|
function attributes(tweenProp: string): void;
|
|
}
|
|
export default baseAttributes;
|
|
export const attributes: {};
|
|
namespace baseAttributes {
|
|
export { ComponentName as component };
|
|
export const property: string;
|
|
export namespace Interpolate {
|
|
export { numbers };
|
|
export { colors };
|
|
}
|
|
export namespace functions {
|
|
export { onStartAttr as onStart };
|
|
}
|
|
}
|
|
const ComponentName: "baseHTMLAttributes";
|
|
import numbers from "kute.js/src/interpolation/numbers";
|
|
import colors from "kute.js/src/interpolation/colors";
|
|
}
|
|
declare module "kute.js/src/components/htmlAttributes" {
|
|
/**
|
|
* Returns the current attribute value.
|
|
* @param {string} _ the property name
|
|
* @param {string} value the property value
|
|
* @returns {{[x:string]: string}} attribute value
|
|
*/
|
|
export function getAttr(_: string, value: string): {
|
|
[x: string]: string;
|
|
};
|
|
/**
|
|
* Returns the property tween object.
|
|
* @param {string} tweenProp the property name
|
|
* @param {string} attrObj the property value
|
|
* @returns {number} the property tween object
|
|
*/
|
|
export function prepareAttr(tweenProp: string, attrObj: string): number;
|
|
export default htmlAttributes;
|
|
namespace htmlAttributes {
|
|
export { ComponentName as component };
|
|
export const property: string;
|
|
export const subProperties: string[];
|
|
export const defaultValue: {
|
|
fill: string;
|
|
stroke: string;
|
|
'stop-color': string;
|
|
opacity: number;
|
|
'stroke-opacity': number;
|
|
'fill-opacity': number;
|
|
};
|
|
export namespace Interpolate {
|
|
export { numbers };
|
|
export { colors };
|
|
}
|
|
export { attrFunctions as functions };
|
|
export namespace Util {
|
|
export { replaceUppercase };
|
|
export { trueColor };
|
|
export { trueDimension };
|
|
}
|
|
}
|
|
const ComponentName: "htmlAttributes";
|
|
import numbers from "kute.js/src/interpolation/numbers";
|
|
import colors from "kute.js/src/interpolation/colors";
|
|
namespace attrFunctions {
|
|
export { getAttr as prepareStart };
|
|
export { prepareAttr as prepareProperty };
|
|
export { onStartAttr as onStart };
|
|
}
|
|
/**
|
|
* Returns non-camelcase property name.
|
|
* @param {string} a the camelcase property name
|
|
* @returns {string} the non-camelcase property name
|
|
*/
|
|
function replaceUppercase(a: string): string;
|
|
import trueColor from "kute.js/src/util/trueColor";
|
|
import trueDimension from "kute.js/src/util/trueDimension";
|
|
import { onStartAttr } from "kute.js/src/components/htmlAttributesBase";
|
|
}
|
|
declare module "kute.js/src/components/opacityPropertyBase" {
|
|
/**
|
|
* Sets the property update function.
|
|
* @param {string} tweenProp the property name
|
|
*/
|
|
export function onStartOpacity(tweenProp: string): void;
|
|
export default OpacityPropertyBase;
|
|
namespace OpacityPropertyBase {
|
|
const component: string;
|
|
const property: string;
|
|
namespace Interpolate {
|
|
export { numbers };
|
|
}
|
|
namespace functions {
|
|
export { onStartOpacity as onStart };
|
|
}
|
|
}
|
|
import numbers from "kute.js/src/interpolation/numbers";
|
|
}
|
|
declare module "kute.js/src/components/opacityProperty" {
|
|
export default OpacityProperty;
|
|
namespace OpacityProperty {
|
|
export const component: string;
|
|
export const property: string;
|
|
export const defaultValue: number;
|
|
export namespace Interpolate {
|
|
export { numbers };
|
|
}
|
|
export { opacityFunctions as functions };
|
|
}
|
|
import numbers from "kute.js/src/interpolation/numbers";
|
|
namespace opacityFunctions {
|
|
export { getOpacity as prepareStart };
|
|
export { prepareOpacity as prepareProperty };
|
|
export { onStartOpacity as onStart };
|
|
}
|
|
/**
|
|
* Returns the current property computed style.
|
|
* @param {string} tweenProp the property name
|
|
* @returns {string} computed style for property
|
|
*/
|
|
function getOpacity(tweenProp: string): string;
|
|
/**
|
|
* Returns the property tween object.
|
|
* @param {string} _ the property name
|
|
* @param {string} value the property value
|
|
* @returns {number} the property tween object
|
|
*/
|
|
function prepareOpacity(_: string, value: string): number;
|
|
import { onStartOpacity } from "kute.js/src/components/opacityPropertyBase";
|
|
}
|
|
declare module "kute.js/src/components/scrollPropertyBase" {
|
|
/**
|
|
* Prevent further scroll events until scroll animation is over.
|
|
* @param {Event} e event object
|
|
*/
|
|
export function preventScroll(e: Event): void;
|
|
/**
|
|
* Returns the scroll element / target.
|
|
* @returns {{el: Element, st: Element}}
|
|
*/
|
|
export function getScrollTargets(): {
|
|
el: Element;
|
|
st: Element;
|
|
};
|
|
/**
|
|
* Toggles scroll prevention callback on scroll events.
|
|
* @param {string} action addEventListener / removeEventListener
|
|
* @param {Element} element target
|
|
*/
|
|
export function toggleScrollEvents(action: string, element: Element): void;
|
|
/**
|
|
* Action performed before scroll animation start.
|
|
*/
|
|
export function scrollIn(): void;
|
|
/**
|
|
* Action performed when scroll animation ends.
|
|
*/
|
|
export function scrollOut(): void;
|
|
/**
|
|
* * Sets the scroll target.
|
|
* * Adds the scroll prevention event listener.
|
|
* * Sets the property update function.
|
|
* @param {string} tweenProp the property name
|
|
*/
|
|
export function onStartScroll(tweenProp: string): void;
|
|
export class onStartScroll {
|
|
/**
|
|
* * Sets the scroll target.
|
|
* * Adds the scroll prevention event listener.
|
|
* * Sets the property update function.
|
|
* @param {string} tweenProp the property name
|
|
*/
|
|
constructor(tweenProp: string);
|
|
element: HTMLElement | undefined;
|
|
}
|
|
/**
|
|
* Removes the scroll prevention event listener.
|
|
*/
|
|
export function onCompleteScroll(): void;
|
|
export const scrollContainer: HTMLElement;
|
|
export default ScrollPropertyBase;
|
|
namespace ScrollPropertyBase {
|
|
const component: string;
|
|
const property: string;
|
|
namespace Interpolate {
|
|
export { numbers };
|
|
}
|
|
namespace functions {
|
|
export { onStartScroll as onStart };
|
|
export { onCompleteScroll as onComplete };
|
|
}
|
|
namespace Util {
|
|
export { preventScroll };
|
|
export { scrollIn };
|
|
export { scrollOut };
|
|
export { getScrollTargets };
|
|
}
|
|
}
|
|
import numbers from "kute.js/src/interpolation/numbers";
|
|
}
|
|
declare module "kute.js/src/components/scrollProperty" {
|
|
export default ScrollProperty;
|
|
namespace ScrollProperty {
|
|
export const component: string;
|
|
export const property: string;
|
|
export const defaultValue: number;
|
|
export namespace Interpolate {
|
|
export { numbers };
|
|
}
|
|
export { scrollFunctions as functions };
|
|
export namespace Util {
|
|
export { preventScroll };
|
|
export { scrollIn };
|
|
export { scrollOut };
|
|
export { getScrollTargets };
|
|
export { toggleScrollEvents };
|
|
}
|
|
}
|
|
import numbers from "kute.js/src/interpolation/numbers";
|
|
namespace scrollFunctions {
|
|
export { getScroll as prepareStart };
|
|
export { prepareScroll as prepareProperty };
|
|
export { onStartScroll as onStart };
|
|
export { onCompleteScroll as onComplete };
|
|
}
|
|
import { preventScroll } from "kute.js/src/components/scrollPropertyBase";
|
|
import { scrollIn } from "kute.js/src/components/scrollPropertyBase";
|
|
import { scrollOut } from "kute.js/src/components/scrollPropertyBase";
|
|
import { getScrollTargets } from "kute.js/src/components/scrollPropertyBase";
|
|
import { toggleScrollEvents } from "kute.js/src/components/scrollPropertyBase";
|
|
/**
|
|
* Returns the current property computed style.
|
|
* @returns {number} computed style for property
|
|
*/
|
|
function getScroll(): number;
|
|
class getScroll {
|
|
element: HTMLElement | undefined;
|
|
}
|
|
/**
|
|
* Returns the property tween object.
|
|
* @param {string} _ the property name
|
|
* @param {string} value the property value
|
|
* @returns {number} the property tween object
|
|
*/
|
|
function prepareScroll(_: string, value: string): number;
|
|
import { onStartScroll } from "kute.js/src/components/scrollPropertyBase";
|
|
import { onCompleteScroll } from "kute.js/src/components/scrollPropertyBase";
|
|
}
|
|
declare module "kute.js/src/components/shadowPropertiesBase" {
|
|
/**
|
|
* Sets the property update function.
|
|
* @param {string} tweenProp the property name
|
|
*/
|
|
export function onStartShadow(tweenProp: string): void;
|
|
export default ShadowPropertiesBase;
|
|
namespace ShadowPropertiesBase {
|
|
const component: string;
|
|
namespace Interpolate {
|
|
export { numbers };
|
|
export { colors };
|
|
}
|
|
namespace functions {
|
|
export { shadowPropOnStart as onStart };
|
|
}
|
|
}
|
|
import numbers from "kute.js/src/interpolation/numbers";
|
|
import colors from "kute.js/src/interpolation/colors";
|
|
const shadowPropOnStart: {};
|
|
}
|
|
declare module "kute.js/src/components/shadowProperties" {
|
|
/**
|
|
* Returns the current property computed style.
|
|
* @param {string} tweenProp the property name
|
|
* @returns {string} computed style for property
|
|
*/
|
|
export function getShadow(tweenProp: string): string;
|
|
/**
|
|
* Returns the property tween object.
|
|
* @param {string} tweenProp the property name
|
|
* @param {string} propValue the property value
|
|
* @returns {KUTE.shadowObject} the property tween object
|
|
*/
|
|
export function prepareShadow(tweenProp: string, propValue: string): KUTE.shadowObject;
|
|
export default ShadowProperties;
|
|
namespace ShadowProperties {
|
|
export const component: string;
|
|
export { shadowProps as properties };
|
|
export namespace defaultValues {
|
|
const boxShadow: string;
|
|
const textShadow: string;
|
|
}
|
|
export namespace Interpolate {
|
|
export { numbers };
|
|
export { colors };
|
|
}
|
|
export { shadowFunctions as functions };
|
|
export namespace Util {
|
|
export { processShadowArray };
|
|
export { trueColor };
|
|
}
|
|
}
|
|
const shadowProps: string[];
|
|
import numbers from "kute.js/src/interpolation/numbers";
|
|
import colors from "kute.js/src/interpolation/colors";
|
|
namespace shadowFunctions {
|
|
export { getShadow as prepareStart };
|
|
export { prepareShadow as prepareProperty };
|
|
export { shadowPropOnStart as onStart };
|
|
}
|
|
/**
|
|
* Return the box-shadow / text-shadow tween object.
|
|
* * box-shadow: none | h-shadow v-shadow blur spread color inset|initial|inherit
|
|
* * text-shadow: none | offset-x offset-y blur-radius color |initial|inherit
|
|
* * numbers must be floats and color must be rgb object
|
|
*
|
|
* @param {(number | string)[]} shadow an `Array` with shadow parameters
|
|
* @param {string} tweenProp the property name
|
|
* @returns {KUTE.shadowObject} the property tween object
|
|
*/
|
|
function processShadowArray(shadow: (number | string)[], tweenProp: string): KUTE.shadowObject;
|
|
import trueColor from "kute.js/src/util/trueColor";
|
|
const shadowPropOnStart: {};
|
|
}
|
|
declare module "kute.js/src/components/svgCubicMorphBase" {
|
|
/**
|
|
* Sets the property update function.
|
|
* @param {string} tweenProp the `path` property
|
|
*/
|
|
export function onStartCubicMorph(tweenProp: string): void;
|
|
export default baseSvgCubicMorph;
|
|
namespace baseSvgCubicMorph {
|
|
const component: string;
|
|
const property: string;
|
|
namespace Interpolate {
|
|
export { numbers };
|
|
export { pathToString };
|
|
}
|
|
namespace functions {
|
|
export { onStartCubicMorph as onStart };
|
|
}
|
|
}
|
|
import numbers from "kute.js/src/interpolation/numbers";
|
|
import pathToString from "svg-path-commander/src/convert/pathToString";
|
|
}
|
|
declare module "kute.js/src/util/selector" {
|
|
/**
|
|
* selector
|
|
*
|
|
* A selector utility for KUTE.js.
|
|
*
|
|
* @param {KUTE.selectorType} el target(s) or string selector
|
|
* @param {boolean | number} multi when true returns an array/collection of elements
|
|
* @returns {Element | Element[] | null}
|
|
*/
|
|
export default function selector(el: KUTE.selectorType, multi: boolean | number): Element | Element[] | null;
|
|
}
|
|
declare module "kute.js/src/components/svgCubicMorph" {
|
|
export default svgCubicMorph;
|
|
namespace svgCubicMorph {
|
|
export const component: string;
|
|
export const property: string;
|
|
export const defaultValue: never[];
|
|
export namespace Interpolate {
|
|
export { numbers };
|
|
export { pathToString };
|
|
}
|
|
export { svgCubicMorphFunctions as functions };
|
|
export namespace Util {
|
|
export { pathToCurve };
|
|
export { pathToAbsolute };
|
|
export { pathToString };
|
|
export { parsePathString };
|
|
export { getRotatedCurve };
|
|
export { getRotations };
|
|
export { equalizeSegments };
|
|
export { reverseCurve };
|
|
export { clonePath };
|
|
export { getDrawDirection };
|
|
export { segmentCubicFactory };
|
|
export { splitCubic };
|
|
export { splitPath };
|
|
export { fixPath };
|
|
export { getCurveArray };
|
|
}
|
|
}
|
|
import numbers from "kute.js/src/interpolation/numbers";
|
|
import pathToString from "svg-path-commander/src/convert/pathToString";
|
|
namespace svgCubicMorphFunctions {
|
|
export { getCubicMorph as prepareStart };
|
|
export { prepareCubicMorph as prepareProperty };
|
|
export { onStartCubicMorph as onStart };
|
|
export { crossCheckCubicMorph as crossCheck };
|
|
}
|
|
import pathToCurve from "svg-path-commander/src/convert/pathToCurve";
|
|
import pathToAbsolute from "svg-path-commander/src/convert/pathToAbsolute";
|
|
import parsePathString from "svg-path-commander/src/parser/parsePathString";
|
|
/**
|
|
* Returns the `curveArray` rotation for the best morphing animation.
|
|
* @param {SVGPathCommander.curveArray} a the target `curveArray`
|
|
* @param {SVGPathCommander.curveArray} b the reference `curveArray`
|
|
* @returns {SVGPathCommander.curveArray} the best `a` rotation
|
|
*/
|
|
function getRotatedCurve(a: import("svg-path-commander").curveArray, b: import("svg-path-commander").curveArray): import("svg-path-commander").curveArray;
|
|
/**
|
|
* Returns all possible path rotations for `curveArray`.
|
|
* @param {SVGPathCommander.curveArray} a the source `curveArray`
|
|
* @returns {SVGPathCommander.curveArray[]} all rotations for source
|
|
*/
|
|
function getRotations(a: import("svg-path-commander").curveArray): import("svg-path-commander").curveArray[];
|
|
/**
|
|
* Returns two `curveArray` with same amount of segments.
|
|
* @param {SVGPathCommander.curveArray} path1 the first `curveArray`
|
|
* @param {SVGPathCommander.curveArray} path2 the second `curveArray`
|
|
* @param {number} TL the maximum `curveArray` length
|
|
* @returns {SVGPathCommander.curveArray[]} equalized segments
|
|
*/
|
|
function equalizeSegments(path1: import("svg-path-commander").curveArray, path2: import("svg-path-commander").curveArray, TL: number): import("svg-path-commander").curveArray[];
|
|
import reverseCurve from "svg-path-commander/src/process/reverseCurve";
|
|
import clonePath from "svg-path-commander/src/process/clonePath";
|
|
import getDrawDirection from "svg-path-commander/src/util/getDrawDirection";
|
|
import segmentCubicFactory from "svg-path-commander/src/util/segmentCubicFactory";
|
|
import splitCubic from "svg-path-commander/src/process/splitCubic";
|
|
import splitPath from "svg-path-commander/src/process/splitPath";
|
|
import fixPath from "svg-path-commander/src/process/fixPath";
|
|
/**
|
|
* Returns first `pathArray` from multi-paths path.
|
|
* @param {SVGPathCommander.pathArray | string} source the source `pathArray` or string
|
|
* @returns {KUTE.curveSpecs[]} an `Array` with a custom tuple for `equalizeSegments`
|
|
*/
|
|
function getCurveArray(source: import("svg-path-commander").pathArray | string): KUTE.curveSpecs[];
|
|
/**
|
|
* Returns the current `d` attribute value.
|
|
* @returns {string}
|
|
*/
|
|
function getCubicMorph(): string;
|
|
/**
|
|
* Returns the property tween object.
|
|
* @see KUTE.curveObject
|
|
*
|
|
* @param {string} _ is the `path` property name, not needed
|
|
* @param {string | KUTE.curveObject} value the `path` property value
|
|
* @returns {KUTE.curveObject}
|
|
*/
|
|
function prepareCubicMorph(_: string, value: string | KUTE.curveObject): KUTE.curveObject;
|
|
import { onStartCubicMorph } from "kute.js/src/components/svgCubicMorphBase";
|
|
/**
|
|
* Enables the `to()` method by preparing the tween object in advance.
|
|
* @param {string} tweenProp is `path` tween property, but it's not needed
|
|
*/
|
|
function crossCheckCubicMorph(tweenProp: string): void;
|
|
}
|
|
declare module "kute.js/src/components/svgDrawBase" {
|
|
/**
|
|
* Sets the property update function.
|
|
* @param {string} tweenProp the property name
|
|
*/
|
|
export function onStartDraw(tweenProp: string): void;
|
|
export default SvgDrawBase;
|
|
namespace SvgDrawBase {
|
|
const component: string;
|
|
const property: string;
|
|
namespace Interpolate {
|
|
export { numbers };
|
|
}
|
|
namespace functions {
|
|
export { onStartDraw as onStart };
|
|
}
|
|
}
|
|
import numbers from "kute.js/src/interpolation/numbers";
|
|
}
|
|
declare module "kute.js/src/components/svgDraw" {
|
|
export default SvgDrawProperty;
|
|
namespace SvgDrawProperty {
|
|
export const component: string;
|
|
export const property: string;
|
|
export const defaultValue: string;
|
|
export namespace Interpolate {
|
|
export { numbers };
|
|
}
|
|
export { svgDrawFunctions as functions };
|
|
export namespace Util {
|
|
export { getRectLength };
|
|
export { getPolyLength };
|
|
export { getLineLength };
|
|
export { getCircleLength };
|
|
export { getEllipseLength };
|
|
export { getTotalLength };
|
|
export { resetDraw };
|
|
export { getDraw };
|
|
export { percent };
|
|
}
|
|
}
|
|
import numbers from "kute.js/src/interpolation/numbers";
|
|
namespace svgDrawFunctions {
|
|
export { getDrawValue as prepareStart };
|
|
export { prepareDraw as prepareProperty };
|
|
export { onStartDraw as onStart };
|
|
}
|
|
/**
|
|
* Returns the `<rect>` length.
|
|
* It doesn't compute `rx` and / or `ry` of the element.
|
|
* @see http://stackoverflow.com/a/30376660
|
|
* @param {SVGRectElement} el target element
|
|
* @returns {number} the `<rect>` length
|
|
*/
|
|
function getRectLength(el: SVGRectElement): number;
|
|
/**
|
|
* Returns the `<polyline>` / `<polygon>` length.
|
|
* @param {SVGPolylineElement | SVGPolygonElement} el target element
|
|
* @returns {number} the element length
|
|
*/
|
|
function getPolyLength(el: SVGPolylineElement | SVGPolygonElement): number;
|
|
/**
|
|
* Returns the `<line>` length.
|
|
* @param {SVGLineElement} el target element
|
|
* @returns {number} the element length
|
|
*/
|
|
function getLineLength(el: SVGLineElement): number;
|
|
/**
|
|
* Returns the `<circle>` length.
|
|
* @param {SVGCircleElement} el target element
|
|
* @returns {number} the element length
|
|
*/
|
|
function getCircleLength(el: SVGCircleElement): number;
|
|
/**
|
|
* Returns the `<ellipse>` length.
|
|
* @param {SVGEllipseElement} el target element
|
|
* @returns {number} the element length
|
|
*/
|
|
function getEllipseLength(el: SVGEllipseElement): number;
|
|
/**
|
|
* Returns the shape length.
|
|
* @param {SVGPathCommander.shapeTypes} el target element
|
|
* @returns {number} the element length
|
|
*/
|
|
function getTotalLength(el: SVGPathCommander.shapeTypes): number;
|
|
/**
|
|
* Reset CSS properties associated with the `draw` property.
|
|
* @param {SVGPathCommander.shapeTypes} element target
|
|
*/
|
|
function resetDraw(elem: any): void;
|
|
/**
|
|
* Returns the property tween object.
|
|
* @param {SVGPathCommander.shapeTypes} element the target element
|
|
* @param {string | KUTE.drawObject} value the property value
|
|
* @returns {KUTE.drawObject} the property tween object
|
|
*/
|
|
function getDraw(element: SVGPathCommander.shapeTypes, value: string | KUTE.drawObject): KUTE.drawObject;
|
|
/**
|
|
* Convert a `<path>` length percent value to absolute.
|
|
* @param {string} v raw value
|
|
* @param {number} l length value
|
|
* @returns {number} the absolute value
|
|
*/
|
|
function percent(v: string, l: number): number;
|
|
/**
|
|
* Returns the property tween object.
|
|
* @returns {KUTE.drawObject} the property tween object
|
|
*/
|
|
function getDrawValue(): KUTE.drawObject;
|
|
/**
|
|
* Returns the property tween object.
|
|
* @param {string} _ the property name
|
|
* @param {string | KUTE.drawObject} value the property value
|
|
* @returns {KUTE.drawObject} the property tween object
|
|
*/
|
|
function prepareDraw(_: string, value: string | KUTE.drawObject): KUTE.drawObject;
|
|
import { onStartDraw } from "kute.js/src/components/svgDrawBase";
|
|
}
|
|
declare module "kute.js/src/interpolation/coords" {
|
|
/**
|
|
* Coordinates Interpolation Function.
|
|
*
|
|
* @param {number[][]} a start coordinates
|
|
* @param {number[][]} b end coordinates
|
|
* @param {string} l amount of coordinates
|
|
* @param {number} v progress
|
|
* @returns {number[][]} the interpolated coordinates
|
|
*/
|
|
export default function coords(a: number[][], b: number[][], l: string, v: number): number[][];
|
|
}
|
|
declare module "kute.js/src/components/svgMorphBase" {
|
|
/**
|
|
* Sets the property update function.
|
|
* @param {string} tweenProp the property name
|
|
*/
|
|
export function onStartSVGMorph(tweenProp: string): void;
|
|
export default SVGMorphBase;
|
|
namespace SVGMorphBase {
|
|
export const component: string;
|
|
export const property: string;
|
|
export { coords as Interpolate };
|
|
export namespace functions {
|
|
export { onStartSVGMorph as onStart };
|
|
}
|
|
}
|
|
import coords from "kute.js/src/interpolation/coords";
|
|
}
|
|
declare module "kute.js/src/components/svgMorph" {
|
|
export default SVGMorph;
|
|
namespace SVGMorph {
|
|
export const component: string;
|
|
export const property: string;
|
|
export const defaultValue: never[];
|
|
export { coords as Interpolate };
|
|
export namespace defaultOptions {
|
|
const morphPrecision: number;
|
|
}
|
|
export { svgMorphFunctions as functions };
|
|
export namespace Util {
|
|
export { addPoints };
|
|
export { bisect };
|
|
export { getPolygon };
|
|
export { validPolygon };
|
|
export { getInterpolationPoints };
|
|
export { pathStringToPolygon };
|
|
export { distanceSquareRoot };
|
|
export { midPoint };
|
|
export { approximatePolygon };
|
|
export { rotatePolygon };
|
|
export { pathToString };
|
|
export { pathToCurve };
|
|
export { getTotalLength };
|
|
export { getPointAtLength };
|
|
export { polygonArea };
|
|
export { roundPath };
|
|
}
|
|
}
|
|
import coords from "kute.js/src/interpolation/coords";
|
|
namespace svgMorphFunctions {
|
|
export { getSVGMorph as prepareStart };
|
|
export { prepareSVGMorph as prepareProperty };
|
|
export { onStartSVGMorph as onStart };
|
|
export { crossCheckSVGMorph as crossCheck };
|
|
}
|
|
/**
|
|
* Sample additional points for a polygon to better match its pair.
|
|
* @param {KUTE.polygonObject} polygon the target polygon
|
|
* @param {number} numPoints the amount of points needed
|
|
*/
|
|
function addPoints(polygon: KUTE.polygonObject, numPoints: number): void;
|
|
/**
|
|
* Split segments of a polygon until it reaches a certain
|
|
* amount of points.
|
|
* @param {number[][]} polygon the target polygon
|
|
* @param {number} maxSegmentLength the maximum amount of points
|
|
*/
|
|
function bisect(polygon: number[][], maxSegmentLength?: number): void;
|
|
/**
|
|
* Returns a new polygon and its length from string or another `Array`.
|
|
* @param {KUTE.polygonMorph | string} input the target polygon
|
|
* @param {number} maxSegmentLength the maximum amount of points
|
|
* @returns {KUTE.polygonMorph} normalized polygon
|
|
*/
|
|
function getPolygon(input: import("kute.js/types").polygonMorph | string, maxSegmentLength: number): import("kute.js/types").polygonMorph;
|
|
/**
|
|
* Checks the validity of a polygon.
|
|
* @param {KUTE.polygonMorph} polygon the target polygon
|
|
* @returns {boolean} the result of the check
|
|
*/
|
|
function validPolygon(polygon: import("kute.js/types").polygonMorph): boolean;
|
|
/**
|
|
* Returns two new polygons ready to tween.
|
|
* @param {string} path1 the first path string
|
|
* @param {string} path2 the second path string
|
|
* @param {number} precision the morphPrecision option value
|
|
* @returns {KUTE.polygonMorph[]} the two polygons
|
|
*/
|
|
function getInterpolationPoints(path1: string, path2: string, precision: number): import("kute.js/types").polygonMorph[];
|
|
/**
|
|
* Parses a path string and returns a polygon array.
|
|
* @param {string} str path string
|
|
* @param {number} maxLength maximum amount of points
|
|
* @returns {KUTE.exactPolygon} the polygon array we need
|
|
*/
|
|
function pathStringToPolygon(str: string, maxLength: number): KUTE.exactPolygon;
|
|
import distanceSquareRoot from "svg-path-commander/src/math/distanceSquareRoot";
|
|
import midPoint from "svg-path-commander/src/math/midPoint";
|
|
/**
|
|
* Returns a new polygon polygon.
|
|
* @param {SVGPathCommander.pathArray} parsed target `pathArray`
|
|
* @param {number} maxLength the maximum segment length
|
|
* @returns {KUTE.exactPolygon} the resulted polygon
|
|
*/
|
|
function approximatePolygon(parsed: import("svg-path-commander").pathArray, maxLength: number): KUTE.exactPolygon;
|
|
/**
|
|
* Rotates a polygon to better match its pair.
|
|
* @param {KUTE.polygonMorph} polygon the target polygon
|
|
* @param {KUTE.polygonMorph} vs the reference polygon
|
|
*/
|
|
function rotatePolygon(polygon: import("kute.js/types").polygonMorph, vs: import("kute.js/types").polygonMorph): void;
|
|
import pathToString from "svg-path-commander/src/convert/pathToString";
|
|
import pathToCurve from "svg-path-commander/src/convert/pathToCurve";
|
|
import getTotalLength from "svg-path-commander/src/util/getTotalLength";
|
|
import getPointAtLength from "svg-path-commander/src/util/getPointAtLength";
|
|
import polygonArea from "svg-path-commander/src/math/polygonArea";
|
|
import roundPath from "svg-path-commander/src/process/roundPath";
|
|
/**
|
|
* Returns the current `d` attribute value.
|
|
* @returns {string} the `d` attribute value
|
|
*/
|
|
function getSVGMorph(): string;
|
|
/**
|
|
* Returns the property tween object.
|
|
* @param {string} _ the property name
|
|
* @param {string | KUTE.polygonObject} value the property value
|
|
* @returns {KUTE.polygonObject} the property tween object
|
|
*/
|
|
function prepareSVGMorph(_: string, value: string | KUTE.polygonObject): KUTE.polygonObject;
|
|
import { onStartSVGMorph } from "kute.js/src/components/svgMorphBase";
|
|
/**
|
|
* Enables the `to()` method by preparing the tween object in advance.
|
|
* @param {string} prop the `path` property name
|
|
*/
|
|
function crossCheckSVGMorph(prop: string): void;
|
|
/**
|
|
* Returns an existing polygon or false if it's not a polygon.
|
|
* @param {SVGPathCommander.pathArray} pathArray target `pathArray`
|
|
* @returns {KUTE.exactPolygon | false} the resulted polygon
|
|
*/
|
|
function exactPolygon(pathArray: import("svg-path-commander").pathArray): KUTE.exactPolygon | false;
|
|
}
|
|
declare module "kute.js/src/components/svgTransformBase" {
|
|
/**
|
|
* Sets the property update function.
|
|
* @param {string} tweenProp the property name
|
|
*/
|
|
export function svgTransformOnStart(tweenProp: string): void;
|
|
export default baseSVGTransform;
|
|
namespace baseSVGTransform {
|
|
const component: string;
|
|
const property: string;
|
|
namespace defaultOptions {
|
|
const transformOrigin: string;
|
|
}
|
|
namespace Interpolate {
|
|
export { numbers };
|
|
}
|
|
namespace functions {
|
|
export { svgTransformOnStart as onStart };
|
|
}
|
|
}
|
|
import numbers from "kute.js/src/interpolation/numbers";
|
|
}
|
|
declare module "kute.js/src/components/svgTransform" {
|
|
export namespace svgTransformFunctions {
|
|
export { getStartSvgTransform as prepareStart };
|
|
export { prepareSvgTransform as prepareProperty };
|
|
export { svgTransformOnStart as onStart };
|
|
export { svgTransformCrossCheck as crossCheck };
|
|
}
|
|
export namespace svgTransform {
|
|
export const component: string;
|
|
export const property: string;
|
|
export namespace defaultOptions {
|
|
const transformOrigin: string;
|
|
}
|
|
export namespace defaultValue {
|
|
const translate: number;
|
|
const rotate: number;
|
|
const skewX: number;
|
|
const skewY: number;
|
|
const scale: number;
|
|
}
|
|
export namespace Interpolate {
|
|
export { numbers };
|
|
}
|
|
export { svgTransformFunctions as functions };
|
|
export namespace Util {
|
|
export { parseStringOrigin };
|
|
export { parseTransformString };
|
|
export { parseTransformSVG };
|
|
}
|
|
}
|
|
export default svgTransform;
|
|
/**
|
|
* Returns an object with the current transform attribute value.
|
|
* @param {string} _ the property name
|
|
* @param {string} value the property value
|
|
* @returns {string} current transform object
|
|
*/
|
|
function getStartSvgTransform(_: string, value: string): string;
|
|
/**
|
|
* Returns the property tween object.
|
|
* @param {string} prop the property name
|
|
* @param {string} value the property value
|
|
* @returns {KUTE.transformSVGObject} the property tween object
|
|
*/
|
|
function prepareSvgTransform(prop: string, value: string): KUTE.transformSVGObject;
|
|
import { svgTransformOnStart } from "kute.js/src/components/svgTransformBase";
|
|
function svgTransformCrossCheck(prop: any): void;
|
|
import numbers from "kute.js/src/interpolation/numbers";
|
|
/**
|
|
* Returns a correct transform origin consistent with the shape bounding box.
|
|
* @param {string} origin transform origin string
|
|
* @param {SVGPathCommander.pathBBox} bbox path bounding box
|
|
* @returns {number}
|
|
*/
|
|
function parseStringOrigin(origin: string, bbox: SVGPathCommander.pathBBox): number;
|
|
/**
|
|
* Parse SVG transform string and return an object.
|
|
* @param {string} a transform string
|
|
* @returns {Object<string, (string | number)>}
|
|
*/
|
|
function parseTransformString(a: string): {
|
|
[x: string]: (string | number);
|
|
};
|
|
/**
|
|
* Returns the SVG transform tween object.
|
|
* @param {string} _ property name
|
|
* @param {Object<string, (string | number)>} v property value object
|
|
* @returns {KUTE.transformSVGObject} the SVG transform tween object
|
|
*/
|
|
function parseTransformSVG(_: string, v: {
|
|
[x: string]: (string | number);
|
|
}): KUTE.transformSVGObject;
|
|
}
|
|
declare module "kute.js/src/components/textPropertiesBase" {
|
|
/**
|
|
* Sets the property update function.
|
|
* @param {string} tweenProp the property name
|
|
*/
|
|
export function textPropOnStart(tweenProp: string): void;
|
|
export default TextPropertiesBase;
|
|
namespace TextPropertiesBase {
|
|
const component: string;
|
|
const category: string;
|
|
namespace Interpolate {
|
|
export { units };
|
|
}
|
|
namespace functions {
|
|
export { textOnStart as onStart };
|
|
}
|
|
}
|
|
import units from "kute.js/src/interpolation/units";
|
|
const textOnStart: {};
|
|
}
|
|
declare module "kute.js/src/components/textProperties" {
|
|
/**
|
|
* Returns the current property computed style.
|
|
* @param {string} prop the property name
|
|
* @returns {string} computed style for property
|
|
*/
|
|
export function getTextProp(prop: string): string;
|
|
/**
|
|
* Returns the property tween object.
|
|
* @param {string} _ the property name
|
|
* @param {string} value the property value
|
|
* @returns {number} the property tween object
|
|
*/
|
|
export function prepareTextProp(_: string, value: string): number;
|
|
export default TextProperties;
|
|
namespace TextProperties {
|
|
export const component: string;
|
|
export const category: string;
|
|
export { textProps as properties };
|
|
export namespace defaultValues {
|
|
const fontSize: number;
|
|
const lineHeight: number;
|
|
const letterSpacing: number;
|
|
const wordSpacing: number;
|
|
}
|
|
export namespace Interpolate {
|
|
export { units };
|
|
}
|
|
export { textPropFunctions as functions };
|
|
export namespace Util {
|
|
export { trueDimension };
|
|
}
|
|
}
|
|
const textProps: string[];
|
|
import units from "kute.js/src/interpolation/units";
|
|
namespace textPropFunctions {
|
|
export { getTextProp as prepareStart };
|
|
export { prepareTextProp as prepareProperty };
|
|
export { textOnStart as onStart };
|
|
}
|
|
import trueDimension from "kute.js/src/util/trueDimension";
|
|
const textOnStart: {};
|
|
}
|
|
declare module "kute.js/src/objects/connect" {
|
|
export default connect;
|
|
namespace connect {
|
|
const tween: KUTE.TweenBase | KUTE.Tween | KUTE.TweenExtra;
|
|
const processEasing: any;
|
|
}
|
|
}
|
|
declare module "kute.js/src/components/textWriteBase" {
|
|
export namespace onStartWrite {
|
|
/**
|
|
* onStartWrite.text
|
|
*
|
|
* Sets the property update function.
|
|
* @param {string} tweenProp the property name
|
|
*/
|
|
function text(tweenProp: string): void;
|
|
/**
|
|
* onStartWrite.text
|
|
*
|
|
* Sets the property update function.
|
|
* @param {string} tweenProp the property name
|
|
*/
|
|
function text(tweenProp: string): void;
|
|
/**
|
|
* onStartWrite.number
|
|
*
|
|
* Sets the property update function.
|
|
* @param {string} tweenProp the property name
|
|
*/
|
|
function number(tweenProp: string): void;
|
|
/**
|
|
* onStartWrite.number
|
|
*
|
|
* Sets the property update function.
|
|
* @param {string} tweenProp the property name
|
|
*/
|
|
function number(tweenProp: string): void;
|
|
}
|
|
export namespace TextWriteBase {
|
|
const component: string;
|
|
const category: string;
|
|
namespace defaultOptions {
|
|
const textChars: string;
|
|
}
|
|
namespace Interpolate {
|
|
export { numbers };
|
|
}
|
|
namespace functions {
|
|
export { onStartWrite as onStart };
|
|
}
|
|
namespace Util {
|
|
export { charSet };
|
|
}
|
|
}
|
|
export default TextWriteBase;
|
|
export namespace charSet {
|
|
export { lowerCaseAlpha as alpha };
|
|
export { upperCaseAlpha as upper };
|
|
export { nonAlpha as symbols };
|
|
export { numeric };
|
|
export { alphaNumeric as alphanumeric };
|
|
export { allTypes as all };
|
|
}
|
|
import numbers from "kute.js/src/interpolation/numbers";
|
|
const lowerCaseAlpha: string[];
|
|
const upperCaseAlpha: string[];
|
|
const nonAlpha: string[];
|
|
const numeric: string[];
|
|
const alphaNumeric: string[];
|
|
const allTypes: string[];
|
|
}
|
|
declare module "kute.js/src/components/textWrite" {
|
|
export function createTextTweens(target: any, newText: any, ops: any): false | any[];
|
|
export namespace textWriteFunctions {
|
|
export { getWrite as prepareStart };
|
|
export { prepareText as prepareProperty };
|
|
export { onStartWrite as onStart };
|
|
}
|
|
export namespace TextWrite {
|
|
export const component: string;
|
|
export const category: string;
|
|
export const properties: string[];
|
|
export namespace defaultValues {
|
|
const text: string;
|
|
const number: string;
|
|
}
|
|
export namespace defaultOptions {
|
|
const textChars: string;
|
|
}
|
|
export namespace Interpolate {
|
|
export { numbers };
|
|
}
|
|
export { textWriteFunctions as functions };
|
|
export namespace Util {
|
|
export { charSet };
|
|
export { createTextTweens };
|
|
}
|
|
}
|
|
export default TextWrite;
|
|
/**
|
|
* Returns the current element `innerHTML`.
|
|
* @returns {string} computed style for property
|
|
*/
|
|
function getWrite(): string;
|
|
/**
|
|
* Returns the property tween object.
|
|
* @param {string} tweenProp the property name
|
|
* @param {string} value the property value
|
|
* @returns {number | string} the property tween object
|
|
*/
|
|
function prepareText(tweenProp: string, value: string): number | string;
|
|
import { onStartWrite } from "kute.js/src/components/textWriteBase";
|
|
import numbers from "kute.js/src/interpolation/numbers";
|
|
import { charSet } from "kute.js/src/components/textWriteBase";
|
|
}
|
|
declare module "kute.js/src/interpolation/perspective" {
|
|
/**
|
|
* Perspective Interpolation Function.
|
|
*
|
|
* @param {number} a start value
|
|
* @param {number} b end value
|
|
* @param {string} u unit
|
|
* @param {number} v progress
|
|
* @returns {string} the perspective function in string format
|
|
*/
|
|
export default function perspective(a: number, b: number, u: string, v: number): string;
|
|
}
|
|
declare module "kute.js/src/interpolation/translate3d" {
|
|
/**
|
|
* Translate 3D Interpolation Function.
|
|
*
|
|
* @param {number[]} a start [x,y,z] position
|
|
* @param {number[]} b end [x,y,z] position
|
|
* @param {string} u unit, usually `px` degrees
|
|
* @param {number} v progress
|
|
* @returns {string} the interpolated 3D translation string
|
|
*/
|
|
export default function translate3d(a: number[], b: number[], u: string, v: number): string;
|
|
}
|
|
declare module "kute.js/src/interpolation/rotate3d" {
|
|
/**
|
|
* 3D Rotation Interpolation Function.
|
|
*
|
|
* @param {number} a start [x,y,z] angles
|
|
* @param {number} b end [x,y,z] angles
|
|
* @param {string} u unit, usually `deg` degrees
|
|
* @param {number} v progress
|
|
* @returns {string} the interpolated 3D rotation string
|
|
*/
|
|
export default function rotate3d(a: number, b: number, u: string, v: number): string;
|
|
}
|
|
declare module "kute.js/src/interpolation/translate" {
|
|
/**
|
|
* Translate 2D Interpolation Function.
|
|
*
|
|
* @param {number[]} a start [x,y] position
|
|
* @param {number[]} b end [x,y] position
|
|
* @param {string} u unit, usually `px` degrees
|
|
* @param {number} v progress
|
|
* @returns {string} the interpolated 2D translation string
|
|
*/
|
|
export default function translate(a: number[], b: number[], u: string, v: number): string;
|
|
}
|
|
declare module "kute.js/src/interpolation/rotate" {
|
|
/**
|
|
* 2D Rotation Interpolation Function.
|
|
*
|
|
* @param {number} a start angle
|
|
* @param {number} b end angle
|
|
* @param {string} u unit, usually `deg` degrees
|
|
* @param {number} v progress
|
|
* @returns {string} the interpolated rotation
|
|
*/
|
|
export default function rotate(a: number, b: number, u: string, v: number): string;
|
|
}
|
|
declare module "kute.js/src/interpolation/scale" {
|
|
/**
|
|
* Scale Interpolation Function.
|
|
*
|
|
* @param {number} a start scale
|
|
* @param {number} b end scale
|
|
* @param {number} v progress
|
|
* @returns {string} the interpolated scale
|
|
*/
|
|
export default function scale(a: number, b: number, v: number): string;
|
|
}
|
|
declare module "kute.js/src/interpolation/skew" {
|
|
/**
|
|
* Skew Interpolation Function.
|
|
*
|
|
* @param {number} a start {x,y} angles
|
|
* @param {number} b end {x,y} angles
|
|
* @param {string} u unit, usually `deg` degrees
|
|
* @param {number} v progress
|
|
* @returns {string} the interpolated string value of skew(s)
|
|
*/
|
|
export default function skew(a: number, b: number, u: string, v: number): string;
|
|
}
|
|
declare module "kute.js/src/components/transformFunctionsBase" {
|
|
/**
|
|
* Sets the property update function.
|
|
* * same to svgTransform, htmlAttributes
|
|
* @param {string} tweenProp the property name
|
|
*/
|
|
export function onStartTransform(tweenProp: string): void;
|
|
export default TransformFunctionsBase;
|
|
namespace TransformFunctionsBase {
|
|
const component: string;
|
|
const property: string;
|
|
namespace functions {
|
|
export { onStartTransform as onStart };
|
|
}
|
|
namespace Interpolate {
|
|
export { perspective };
|
|
export { translate3d };
|
|
export { rotate3d };
|
|
export { translate };
|
|
export { rotate };
|
|
export { scale };
|
|
export { skew };
|
|
}
|
|
}
|
|
import perspective from "kute.js/src/interpolation/perspective";
|
|
import translate3d from "kute.js/src/interpolation/translate3d";
|
|
import rotate3d from "kute.js/src/interpolation/rotate3d";
|
|
import translate from "kute.js/src/interpolation/translate";
|
|
import rotate from "kute.js/src/interpolation/rotate";
|
|
import scale from "kute.js/src/interpolation/scale";
|
|
import skew from "kute.js/src/interpolation/skew";
|
|
}
|
|
declare module "kute.js/src/components/transformFunctions" {
|
|
export default TransformFunctions;
|
|
namespace TransformFunctions {
|
|
export const component: string;
|
|
export const property: string;
|
|
export { supportedTransformProperties as subProperties };
|
|
export { defaultTransformValues as defaultValues };
|
|
export { transformFunctions as functions };
|
|
export namespace Interpolate {
|
|
export { perspective };
|
|
export { translate3d };
|
|
export { rotate3d };
|
|
export { translate };
|
|
export { rotate };
|
|
export { scale };
|
|
export { skew };
|
|
}
|
|
}
|
|
const supportedTransformProperties: string[];
|
|
namespace defaultTransformValues {
|
|
const perspective_1: number;
|
|
export { perspective_1 as perspective };
|
|
const translate3d_1: number[];
|
|
export { translate3d_1 as translate3d };
|
|
export const translateX: number;
|
|
export const translateY: number;
|
|
export const translateZ: number;
|
|
const translate_1: number[];
|
|
export { translate_1 as translate };
|
|
const rotate3d_1: number[];
|
|
export { rotate3d_1 as rotate3d };
|
|
export const rotateX: number;
|
|
export const rotateY: number;
|
|
export const rotateZ: number;
|
|
const rotate_1: number;
|
|
export { rotate_1 as rotate };
|
|
export const skewX: number;
|
|
export const skewY: number;
|
|
const skew_1: number[];
|
|
export { skew_1 as skew };
|
|
const scale_1: number;
|
|
export { scale_1 as scale };
|
|
}
|
|
namespace transformFunctions {
|
|
export { getTransform as prepareStart };
|
|
export { prepareTransform as prepareProperty };
|
|
export { onStartTransform as onStart };
|
|
export { crossCheckTransform as crossCheck };
|
|
}
|
|
import perspective from "kute.js/src/interpolation/perspective";
|
|
import translate3d from "kute.js/src/interpolation/translate3d";
|
|
import rotate3d from "kute.js/src/interpolation/rotate3d";
|
|
import translate from "kute.js/src/interpolation/translate";
|
|
import rotate from "kute.js/src/interpolation/rotate";
|
|
import scale from "kute.js/src/interpolation/scale";
|
|
import skew from "kute.js/src/interpolation/skew";
|
|
/**
|
|
* Returns the current property inline style.
|
|
* @param {string} tweenProp the property name
|
|
* @returns {string} inline style for property
|
|
*/
|
|
function getTransform(tweenProp: string): string;
|
|
/**
|
|
* Returns the property tween object.
|
|
* @param {string} _ the property name
|
|
* @param {Object<string, string | number | (string | number)[]>} obj the property value
|
|
* @returns {KUTE.transformFObject} the property tween object
|
|
*/
|
|
function prepareTransform(_: string, obj: {
|
|
[x: string]: string | number | (string | number)[];
|
|
}): KUTE.transformFObject;
|
|
import { onStartTransform } from "kute.js/src/components/transformFunctionsBase";
|
|
/**
|
|
* Prepare tween object in advance for `to()` method.
|
|
* @param {string} tweenProp the property name
|
|
*/
|
|
function crossCheckTransform(tweenProp: string): void;
|
|
}
|
|
declare module "kute.js/src/util/transformProperty" {
|
|
export default transformProperty;
|
|
/** the `transform` string for legacy browsers */
|
|
const transformProperty: string;
|
|
}
|
|
declare module "kute.js/src/process/getInlineStyleLegacy" {
|
|
/**
|
|
* getInlineStyle
|
|
*
|
|
* Returns the transform style for element from cssText.
|
|
* Used by for the `.to()` static method on legacy browsers.
|
|
*
|
|
* @param {Element} el target element
|
|
* @returns {object} a transform object
|
|
*/
|
|
export default function getInlineStyleLegacy(el: Element): object;
|
|
}
|
|
declare module "kute.js/src/util/supportLegacyTransform" {
|
|
export default supportTransform;
|
|
/** check if transform is supported via prefixed property */
|
|
const supportTransform: boolean;
|
|
}
|
|
declare module "kute.js/src/components/transformLegacyBase" {
|
|
/**
|
|
* Sets the property update function.
|
|
* @param {string} tweenProp the property name
|
|
*/
|
|
export function onStartLegacyTransform(tweenProp: string): void;
|
|
export default BaseLegacyTransform;
|
|
namespace BaseLegacyTransform {
|
|
const component: string;
|
|
const property: string;
|
|
namespace functions {
|
|
export { onStartLegacyTransform as onStart };
|
|
}
|
|
namespace Interpolate {
|
|
export { perspective };
|
|
export { translate3d };
|
|
export { rotate3d };
|
|
export { translate };
|
|
export { rotate };
|
|
export { scale };
|
|
export { skew };
|
|
}
|
|
namespace Util {
|
|
export { transformProperty };
|
|
}
|
|
}
|
|
import perspective from "kute.js/src/interpolation/perspective";
|
|
import translate3d from "kute.js/src/interpolation/translate3d";
|
|
import rotate3d from "kute.js/src/interpolation/rotate3d";
|
|
import translate from "kute.js/src/interpolation/translate";
|
|
import rotate from "kute.js/src/interpolation/rotate";
|
|
import scale from "kute.js/src/interpolation/scale";
|
|
import skew from "kute.js/src/interpolation/skew";
|
|
import transformProperty from "kute.js/src/util/transformProperty";
|
|
}
|
|
declare module "kute.js/src/components/transformLegacy" {
|
|
export default transformLegacyComponent;
|
|
namespace transformLegacyComponent {
|
|
export const component: string;
|
|
export const property: string;
|
|
export { legacyTransformProperties as subProperties };
|
|
export { legacyTransformValues as defaultValues };
|
|
export { transformLegacyFunctions as functions };
|
|
export namespace Interpolate {
|
|
export { perspective };
|
|
export { translate3d };
|
|
export { rotate3d };
|
|
export { translate };
|
|
export { rotate };
|
|
export { scale };
|
|
export { skew };
|
|
}
|
|
export const Util: string[];
|
|
}
|
|
const legacyTransformProperties: string[];
|
|
namespace legacyTransformValues {
|
|
const perspective_1: number;
|
|
export { perspective_1 as perspective };
|
|
const translate3d_1: number[];
|
|
export { translate3d_1 as translate3d };
|
|
export const translateX: number;
|
|
export const translateY: number;
|
|
export const translateZ: number;
|
|
const translate_1: number[];
|
|
export { translate_1 as translate };
|
|
const rotate3d_1: number[];
|
|
export { rotate3d_1 as rotate3d };
|
|
export const rotateX: number;
|
|
export const rotateY: number;
|
|
export const rotateZ: number;
|
|
const rotate_1: number;
|
|
export { rotate_1 as rotate };
|
|
export const skewX: number;
|
|
export const skewY: number;
|
|
const skew_1: number[];
|
|
export { skew_1 as skew };
|
|
const scale_1: number;
|
|
export { scale_1 as scale };
|
|
}
|
|
namespace transformLegacyFunctions {
|
|
export { getLegacyTransform as prepareStart };
|
|
export { prepareLegacyTransform as prepareProperty };
|
|
export { onStartLegacyTransform as onStart };
|
|
export { crossCheckLegacyTransform as crossCheck };
|
|
}
|
|
import perspective from "kute.js/src/interpolation/perspective";
|
|
import translate3d from "kute.js/src/interpolation/translate3d";
|
|
import rotate3d from "kute.js/src/interpolation/rotate3d";
|
|
import translate from "kute.js/src/interpolation/translate";
|
|
import rotate from "kute.js/src/interpolation/rotate";
|
|
import scale from "kute.js/src/interpolation/scale";
|
|
import skew from "kute.js/src/interpolation/skew";
|
|
/**
|
|
* Returns the current property inline style.
|
|
* @param {string} tweenProperty the property name
|
|
* @returns {string} inline style for property
|
|
*/
|
|
function getLegacyTransform(tweenProperty: string): string;
|
|
/**
|
|
* Returns the property tween object.
|
|
* @param {string} _ the property name
|
|
* @param {Object<string, string | number | (string | number)[]>} obj the property value
|
|
* @returns {KUTE.transformFObject} the property tween object
|
|
*/
|
|
function prepareLegacyTransform(_: string, obj: {
|
|
[x: string]: string | number | (string | number)[];
|
|
}): KUTE.transformFObject;
|
|
import { onStartLegacyTransform } from "kute.js/src/components/transformLegacyBase";
|
|
/**
|
|
* Prepare tween object in advance for `to()` method.
|
|
* @param {string} tweenProp the property name
|
|
*/
|
|
function crossCheckLegacyTransform(tweenProp: string): void;
|
|
}
|
|
declare module "kute.js/src/interpolation/arrays" {
|
|
/**
|
|
* Array Interpolation Function.
|
|
*
|
|
* @param {number[]} a start array
|
|
* @param {number[]} b end array
|
|
* @param {number} v progress
|
|
* @returns {number[]} the resulting array
|
|
*/
|
|
export default function arrays(a: number[], b: number[], v: number): number[];
|
|
}
|
|
declare module "kute.js/src/components/transformMatrixBase" {
|
|
export namespace onStartTransform {
|
|
/**
|
|
* Sets the property update function.
|
|
* @param {string} tweenProp the property name
|
|
*/
|
|
function transform(tweenProp: string): void;
|
|
/**
|
|
* Sets the property update function.
|
|
* @param {string} tweenProp the property name
|
|
*/
|
|
function transform(tweenProp: string): void;
|
|
/**
|
|
* onStartTransform.CSS3Matrix
|
|
*
|
|
* Sets the update function for the property.
|
|
* @param {string} prop the property name
|
|
*/
|
|
function CSS3Matrix(prop: string): void;
|
|
/**
|
|
* onStartTransform.CSS3Matrix
|
|
*
|
|
* Sets the update function for the property.
|
|
* @param {string} prop the property name
|
|
*/
|
|
function CSS3Matrix(prop: string): void;
|
|
}
|
|
export namespace TransformMatrixBase {
|
|
export { matrixComponent as component };
|
|
export const property: string;
|
|
export namespace functions {
|
|
export { onStartTransform as onStart };
|
|
}
|
|
export namespace Interpolate {
|
|
export { numbers as perspective };
|
|
export { arrays as translate3d };
|
|
export { arrays as rotate3d };
|
|
export { arrays as skew };
|
|
export { arrays as scale3d };
|
|
}
|
|
}
|
|
export default TransformMatrixBase;
|
|
const matrixComponent: "transformMatrixBase";
|
|
import numbers from "kute.js/src/interpolation/numbers";
|
|
import arrays from "kute.js/src/interpolation/arrays";
|
|
}
|
|
declare module "kute.js/src/components/transformMatrix" {
|
|
export default matrixTransform;
|
|
namespace matrixTransform {
|
|
export { matrixComponent as component };
|
|
export const property: string;
|
|
export namespace defaultValue {
|
|
const perspective: number;
|
|
const translate3d: number[];
|
|
const translateX: number;
|
|
const translateY: number;
|
|
const translateZ: number;
|
|
const rotate3d: number[];
|
|
const rotateX: number;
|
|
const rotateY: number;
|
|
const rotateZ: number;
|
|
const skew: number[];
|
|
const skewX: number;
|
|
const skewY: number;
|
|
const scale3d: number[];
|
|
const scaleX: number;
|
|
const scaleY: number;
|
|
const scaleZ: number;
|
|
}
|
|
export { matrixFunctions as functions };
|
|
export namespace Interpolate {
|
|
export { numbers as perspective };
|
|
export { arrays as translate3d };
|
|
export { arrays as rotate3d };
|
|
export { arrays as skew };
|
|
export { arrays as scale3d };
|
|
}
|
|
}
|
|
const matrixComponent: "transformMatrix";
|
|
namespace matrixFunctions {
|
|
export { getTransform as prepareStart };
|
|
export { prepareTransform as prepareProperty };
|
|
export { onStartTransform as onStart };
|
|
export { onCompleteTransform as onComplete };
|
|
export { crossCheckTransform as crossCheck };
|
|
}
|
|
import numbers from "kute.js/src/interpolation/numbers";
|
|
import arrays from "kute.js/src/interpolation/arrays";
|
|
/**
|
|
* Returns the current transform object.
|
|
* @param {string} _ the property name
|
|
* @param {string} value the property value
|
|
* @returns {KUTE.transformMObject} transform object
|
|
*/
|
|
function getTransform(_: string, value: string): KUTE.transformMObject;
|
|
/**
|
|
* Returns the property tween object.
|
|
* @param {string} _ the property name
|
|
* @param {Object<string, string | number | (string | number)[]>} obj the property value
|
|
* @returns {KUTE.transformMObject} the property tween object
|
|
*/
|
|
function prepareTransform(_: string, value: any): KUTE.transformMObject;
|
|
import { onStartTransform } from "kute.js/src/components/transformMatrixBase";
|
|
/**
|
|
* Sets the end values for the next `to()` method call.
|
|
* @param {string} tweenProp the property name
|
|
*/
|
|
function onCompleteTransform(tweenProp: string): void;
|
|
/**
|
|
* Prepare tween object in advance for `to()` method.
|
|
* @param {string} tweenProp the property name
|
|
*/
|
|
function crossCheckTransform(tweenProp: string): void;
|
|
}
|
|
declare module "kute.js/src/objects/tweens" {
|
|
export default Tweens;
|
|
const Tweens: any[];
|
|
}
|
|
declare module "kute.js/src/core/add" {
|
|
export default add;
|
|
/**
|
|
* KUTE.add(Tween)
|
|
*
|
|
* @param {KUTE.Tween} tw a new tween to add
|
|
*/
|
|
function add(tw: KUTE.Tween): number;
|
|
}
|
|
declare module "kute.js/src/core/getAll" {
|
|
export default getAll;
|
|
/**
|
|
* KUTE.add(Tween)
|
|
*
|
|
* @return {KUTE.Tween[]} tw a new tween to add
|
|
*/
|
|
function getAll(): KUTE.Tween[];
|
|
}
|
|
declare module "kute.js/src/core/remove" {
|
|
export default remove;
|
|
/**
|
|
* KUTE.remove(Tween)
|
|
*
|
|
* @param {KUTE.Tween} tw a new tween to add
|
|
*/
|
|
function remove(tw: KUTE.Tween): void;
|
|
}
|
|
declare module "kute.js/src/core/removeAll" {
|
|
export default removeAll;
|
|
/**
|
|
* KUTE.removeAll()
|
|
*/
|
|
function removeAll(): void;
|
|
}
|
|
declare module "kute.js/src/objects/globalObject" {
|
|
export default globalObject;
|
|
const globalObject: {};
|
|
}
|
|
declare module "kute.js/src/util/now" {
|
|
export default now;
|
|
function now(): number;
|
|
}
|
|
declare module "kute.js/src/core/render" {
|
|
export function stop(): void;
|
|
export default Render;
|
|
export let Tick: number;
|
|
/**
|
|
*
|
|
* @param {number | Date} time
|
|
*/
|
|
export function Ticker(time: number | Date): void;
|
|
namespace Render {
|
|
export { Tick };
|
|
export { Ticker };
|
|
export { Tweens };
|
|
export { Time };
|
|
}
|
|
import Tweens from "kute.js/src/objects/tweens";
|
|
namespace Time {
|
|
export { now };
|
|
}
|
|
import now from "kute.js/src/util/now";
|
|
}
|
|
declare module "kute.js/src/core/linkInterpolation" {
|
|
/**
|
|
* linkInterpolation
|
|
* @this {KUTE.Tween}
|
|
*/
|
|
export default function linkInterpolation(): void;
|
|
}
|
|
declare module "kute.js/src/core/internals" {
|
|
export default internals;
|
|
namespace internals {
|
|
export { add };
|
|
export { remove };
|
|
export { getAll };
|
|
export { removeAll };
|
|
export { stop };
|
|
export { linkInterpolation };
|
|
}
|
|
import add from "kute.js/src/core/add";
|
|
import remove from "kute.js/src/core/remove";
|
|
import getAll from "kute.js/src/core/getAll";
|
|
import removeAll from "kute.js/src/core/removeAll";
|
|
import { stop } from "kute.js/src/core/render";
|
|
import linkInterpolation from "kute.js/src/core/linkInterpolation";
|
|
}
|
|
declare module "kute.js/src/core/queueStart" {
|
|
export default function queueStart(): void;
|
|
}
|
|
declare module "kute.js/src/easing/easing-base" {
|
|
export default Easing;
|
|
namespace Easing {
|
|
const linear: KUTE.easingFunction;
|
|
const easingQuadraticIn: KUTE.easingFunction;
|
|
const easingQuadraticOut: KUTE.easingFunction;
|
|
const easingQuadraticInOut: KUTE.easingFunction;
|
|
const easingCubicIn: KUTE.easingFunction;
|
|
const easingCubicOut: KUTE.easingFunction;
|
|
const easingCubicInOut: KUTE.easingFunction;
|
|
const easingCircularIn: KUTE.easingFunction;
|
|
const easingCircularOut: KUTE.easingFunction;
|
|
const easingCircularInOut: KUTE.easingFunction;
|
|
const easingBackIn: KUTE.easingFunction;
|
|
const easingBackOut: KUTE.easingFunction;
|
|
const easingBackInOut: KUTE.easingFunction;
|
|
}
|
|
}
|
|
declare module "kute.js/src/easing/easing-bezier" {
|
|
export default Easing;
|
|
namespace Easing {
|
|
const linear: CubicBezier;
|
|
const easingSinusoidalIn: CubicBezier;
|
|
const easingSinusoidalOut: CubicBezier;
|
|
const easingSinusoidalInOut: CubicBezier;
|
|
const easingQuadraticIn: CubicBezier;
|
|
const easingQuadraticOut: CubicBezier;
|
|
const easingQuadraticInOut: CubicBezier;
|
|
const easingCubicIn: CubicBezier;
|
|
const easingCubicOut: CubicBezier;
|
|
const easingCubicInOut: CubicBezier;
|
|
const easingQuarticIn: CubicBezier;
|
|
const easingQuarticOut: CubicBezier;
|
|
const easingQuarticInOut: CubicBezier;
|
|
const easingQuinticIn: CubicBezier;
|
|
const easingQuinticOut: CubicBezier;
|
|
const easingQuinticInOut: CubicBezier;
|
|
const easingExponentialIn: CubicBezier;
|
|
const easingExponentialOut: CubicBezier;
|
|
const easingExponentialInOut: CubicBezier;
|
|
const easingCircularIn: CubicBezier;
|
|
const easingCircularOut: CubicBezier;
|
|
const easingCircularInOut: CubicBezier;
|
|
const easingBackIn: CubicBezier;
|
|
const easingBackOut: CubicBezier;
|
|
const easingBackInOut: CubicBezier;
|
|
}
|
|
import CubicBezier from "cubic-bezier-easing";
|
|
}
|
|
declare module "kute.js/src/easing/easing" {
|
|
export default Easing;
|
|
namespace Easing {
|
|
const linear: KUTE.easingFunction;
|
|
const easingSinusoidalIn: KUTE.easingFunction;
|
|
const easingSinusoidalOut: KUTE.easingFunction;
|
|
const easingSinusoidalInOut: KUTE.easingFunction;
|
|
const easingQuadraticIn: KUTE.easingFunction;
|
|
const easingQuadraticOut: KUTE.easingFunction;
|
|
const easingQuadraticInOut: KUTE.easingFunction;
|
|
const easingCubicIn: KUTE.easingFunction;
|
|
const easingCubicOut: KUTE.easingFunction;
|
|
const easingCubicInOut: KUTE.easingFunction;
|
|
const easingQuarticIn: KUTE.easingFunction;
|
|
const easingQuarticOut: KUTE.easingFunction;
|
|
const easingQuarticInOut: KUTE.easingFunction;
|
|
const easingQuinticIn: KUTE.easingFunction;
|
|
const easingQuinticOut: KUTE.easingFunction;
|
|
const easingQuinticInOut: KUTE.easingFunction;
|
|
const easingCircularIn: KUTE.easingFunction;
|
|
const easingCircularOut: KUTE.easingFunction;
|
|
const easingCircularInOut: KUTE.easingFunction;
|
|
const easingExponentialIn: KUTE.easingFunction;
|
|
const easingExponentialOut: KUTE.easingFunction;
|
|
const easingExponentialInOut: KUTE.easingFunction;
|
|
const easingBackIn: KUTE.easingFunction;
|
|
const easingBackOut: KUTE.easingFunction;
|
|
const easingBackInOut: KUTE.easingFunction;
|
|
const easingElasticIn: KUTE.easingFunction;
|
|
const easingElasticOut: KUTE.easingFunction;
|
|
const easingElasticInOut: KUTE.easingFunction;
|
|
const easingBounceIn: KUTE.easingFunction;
|
|
const easingBounceOut: KUTE.easingFunction;
|
|
const easingBounceInOut: KUTE.easingFunction;
|
|
}
|
|
}
|
|
declare module "kute.js/src/tween/tweenCollection" {
|
|
/**
|
|
* The static method creates a new `Tween` object for each `HTMLElement`
|
|
* from and `Array`, `HTMLCollection` or `NodeList`.
|
|
*/
|
|
export default class TweenCollection {
|
|
/**
|
|
*
|
|
* @param {Element[] | HTMLCollection | NodeList} els target elements
|
|
* @param {KUTE.tweenProps} vS the start values
|
|
* @param {KUTE.tweenProps} vE the end values
|
|
* @param {KUTE.tweenOptions} Options tween options
|
|
* @returns {TweenCollection} the Tween object collection
|
|
*/
|
|
constructor(els: Element[] | HTMLCollection | NodeList, vS: import("kute.js/types").tweenProps, vE: import("kute.js/types").tweenProps, Options: KUTE.tweenOptions);
|
|
/** @type {KUTE.twCollection[]} */
|
|
tweens: import("kute.js/types").twCollection[];
|
|
/** @type {number?} */
|
|
length: number | null;
|
|
/**
|
|
* Starts tweening, all targets
|
|
* @param {number?} time the tween start time
|
|
* @returns {TweenCollection} this instance
|
|
*/
|
|
start(time: number | null): TweenCollection;
|
|
/**
|
|
* Stops tweening, all targets and their chains
|
|
* @returns {TweenCollection} this instance
|
|
*/
|
|
stop(): TweenCollection;
|
|
/**
|
|
* Pause tweening, all targets
|
|
* @returns {TweenCollection} this instance
|
|
*/
|
|
pause(): TweenCollection;
|
|
/**
|
|
* Resume tweening, all targets
|
|
* @returns {TweenCollection} this instance
|
|
*/
|
|
resume(): TweenCollection;
|
|
/**
|
|
* Schedule another tween or collection to start after
|
|
* this one is complete.
|
|
* @param {number?} args the tween start time
|
|
* @returns {TweenCollection} this instance
|
|
*/
|
|
chain(args: number | null): TweenCollection;
|
|
/**
|
|
* Check if any tween instance is playing
|
|
* @param {number?} time the tween start time
|
|
* @returns {TweenCollection} this instance
|
|
*/
|
|
playing(): TweenCollection;
|
|
/**
|
|
* Remove all tweens in the collection
|
|
*/
|
|
removeTweens(): void;
|
|
/**
|
|
* Returns the maximum animation duration
|
|
* @returns {number} this instance
|
|
*/
|
|
getMaxDuration(): number;
|
|
}
|
|
}
|
|
declare module "kute.js/src/interface/allFromTo" {
|
|
/**
|
|
* The `KUTE.allFromTo()` static method creates a new Tween object
|
|
* for multiple `HTMLElement`s, `HTMLCollection` or `NodeListat`
|
|
* at a given state.
|
|
*
|
|
* @param {Element[] | HTMLCollection | NodeList} elements target elements
|
|
* @param {KUTE.tweenProps} startObject
|
|
* @param {KUTE.tweenProps} endObject
|
|
* @param {KUTE.tweenOptions} optionsObj tween options
|
|
* @returns {TweenCollection} the Tween object collection
|
|
*/
|
|
export default function allFromTo(elements: Element[] | HTMLCollection | NodeList, startObject: import("kute.js/types").tweenProps, endObject: import("kute.js/types").tweenProps, optionsObj: KUTE.tweenOptions): TweenCollection;
|
|
import TweenCollection from "kute.js/src/tween/tweenCollection";
|
|
}
|
|
declare module "kute.js/src/interface/allTo" {
|
|
/**
|
|
* The `KUTE.allTo()` static method creates a new Tween object
|
|
* for multiple `HTMLElement`s, `HTMLCollection` or `NodeListat`
|
|
* at their current state.
|
|
*
|
|
* @param {Element[] | HTMLCollection | NodeList} elements target elements
|
|
* @param {KUTE.tweenProps} endObject
|
|
* @param {KUTE.tweenProps} optionsObj progress
|
|
* @returns {TweenCollection} the Tween object collection
|
|
*/
|
|
export default function allTo(elements: Element[] | HTMLCollection | NodeList, endObject: import("kute.js/types").tweenProps, optionsObj: import("kute.js/types").tweenProps): TweenCollection;
|
|
import TweenCollection from "kute.js/src/tween/tweenCollection";
|
|
}
|
|
declare module "kute.js/src/interface/fromTo" {
|
|
/**
|
|
* The `KUTE.fromTo()` static method returns a new Tween object
|
|
* for a single `HTMLElement` at a given state.
|
|
*
|
|
* @param {Element} element target element
|
|
* @param {KUTE.tweenProps} startObject
|
|
* @param {KUTE.tweenProps} endObject
|
|
* @param {KUTE.tweenOptions} optionsObj tween options
|
|
* @returns {KUTE.Tween} the resulting Tween object
|
|
*/
|
|
export default function fromTo(element: Element, startObject: import("kute.js/types").tweenProps, endObject: import("kute.js/types").tweenProps, optionsObj: KUTE.tweenOptions): KUTE.Tween;
|
|
}
|
|
declare module "kute.js/src/interface/to" {
|
|
/**
|
|
* The `KUTE.to()` static method returns a new Tween object
|
|
* for a single `HTMLElement` at its current state.
|
|
*
|
|
* @param {Element} element target element
|
|
* @param {KUTE.tweenProps} endObject
|
|
* @param {KUTE.tweenOptions} optionsObj tween options
|
|
* @returns {KUTE.Tween} the resulting Tween object
|
|
*/
|
|
export default function to(element: Element, endObject: import("kute.js/types").tweenProps, optionsObj: KUTE.tweenOptions): KUTE.Tween;
|
|
}
|
|
declare module "kute.js/src/interpolation/skewX" {
|
|
/**
|
|
* SkewX Interpolation Function.
|
|
*
|
|
* @param {number} a start angle
|
|
* @param {number} b end angle
|
|
* @param {string} u unit, usually `deg` degrees
|
|
* @param {number} v progress
|
|
* @returns {string} the interpolated skewX
|
|
*/
|
|
export default function skewX(a: number, b: number, u: string, v: number): string;
|
|
}
|
|
declare module "kute.js/src/interpolation/skewY" {
|
|
/**
|
|
* SkewY Interpolation Function.
|
|
*
|
|
* @param {number} a start angle
|
|
* @param {number} b end angle
|
|
* @param {string} u unit, usually `deg` degrees
|
|
* @param {number} v progress
|
|
* @returns {string} the interpolated skewY
|
|
*/
|
|
export default function skewY(a: number, b: number, u: string, v: number): string;
|
|
}
|
|
declare module "kute.js/src/objects/componentsBase" {
|
|
export default Components;
|
|
namespace Components {
|
|
const Transform: Animation;
|
|
const BoxModel: Animation;
|
|
const Opacity: Animation;
|
|
}
|
|
import Animation from "kute.js/src/animation/animationBase";
|
|
}
|
|
declare module "kute.js/src/objects/componentsDefault" {
|
|
export default Components;
|
|
namespace Components {
|
|
export { EssentialBoxModel };
|
|
export { ColorsProperties };
|
|
export { HTMLAttributes };
|
|
export { OpacityProperty };
|
|
export { TextWriteProp };
|
|
export { TransformFunctions };
|
|
export { SVGDraw };
|
|
export { SVGMorph };
|
|
}
|
|
import EssentialBoxModel from "kute.js/src/components/boxModelEssential";
|
|
import ColorsProperties from "kute.js/src/components/colorProperties";
|
|
import HTMLAttributes from "kute.js/src/components/htmlAttributes";
|
|
import OpacityProperty from "kute.js/src/components/opacityProperty";
|
|
import TextWriteProp from "kute.js/src/components/textWrite";
|
|
import TransformFunctions from "kute.js/src/components/transformFunctions";
|
|
import SVGDraw from "kute.js/src/components/svgDraw";
|
|
import SVGMorph from "kute.js/src/components/svgMorph";
|
|
}
|
|
declare module "kute.js/src/objects/componentsExtra" {
|
|
export default Components;
|
|
namespace Components {
|
|
export { BackgroundPosition };
|
|
export { BorderRadius };
|
|
export { BoxModel };
|
|
export { ClipProperty };
|
|
export { ColorProperties };
|
|
export { FilterEffects };
|
|
export { HTMLAttributes };
|
|
export { OpacityProperty };
|
|
export { SVGDraw };
|
|
export { SVGCubicMorph };
|
|
export { SVGTransform };
|
|
export { ScrollProperty };
|
|
export { ShadowProperties };
|
|
export { TextProperties };
|
|
export { TextWriteProperties };
|
|
export { MatrixTransform };
|
|
}
|
|
import BackgroundPosition from "kute.js/src/components/backgroundPosition";
|
|
import BorderRadius from "kute.js/src/components/borderRadius";
|
|
import BoxModel from "kute.js/src/components/boxModel";
|
|
import ClipProperty from "kute.js/src/components/clipProperty";
|
|
import ColorProperties from "kute.js/src/components/colorProperties";
|
|
import FilterEffects from "kute.js/src/components/filterEffects";
|
|
import HTMLAttributes from "kute.js/src/components/htmlAttributes";
|
|
import OpacityProperty from "kute.js/src/components/opacityProperty";
|
|
import SVGDraw from "kute.js/src/components/svgDraw";
|
|
import SVGCubicMorph from "kute.js/src/components/svgCubicMorph";
|
|
import SVGTransform from "kute.js/src/components/svgTransform";
|
|
import ScrollProperty from "kute.js/src/components/scrollProperty";
|
|
import ShadowProperties from "kute.js/src/components/shadowProperties";
|
|
import TextProperties from "kute.js/src/components/textProperties";
|
|
import TextWriteProperties from "kute.js/src/components/textWrite";
|
|
import MatrixTransform from "kute.js/src/components/transformMatrix";
|
|
}
|
|
declare module "kute.js/src/objects/objects" {
|
|
export default Objects;
|
|
namespace Objects {
|
|
export { supportedProperties };
|
|
export { defaultValues };
|
|
export { defaultOptions };
|
|
export { prepareProperty };
|
|
export { prepareStart };
|
|
export { crossCheck };
|
|
export { onStart };
|
|
export { onComplete };
|
|
export { linkProperty };
|
|
}
|
|
import supportedProperties from "kute.js/src/objects/supportedProperties";
|
|
import defaultValues from "kute.js/src/objects/defaultValues";
|
|
import defaultOptions from "kute.js/src/objects/defaultOptions";
|
|
import prepareProperty from "kute.js/src/objects/prepareProperty";
|
|
import prepareStart from "kute.js/src/objects/prepareStart";
|
|
import crossCheck from "kute.js/src/objects/crossCheck";
|
|
import onStart from "kute.js/src/objects/onStart";
|
|
import onComplete from "kute.js/src/objects/onComplete";
|
|
import linkProperty from "kute.js/src/objects/linkProperty";
|
|
}
|
|
declare module "kute.js/src/objects/objectsBase" {
|
|
export default Objects;
|
|
namespace Objects {
|
|
export { defaultOptions };
|
|
export { linkProperty };
|
|
export { onStart };
|
|
export { onComplete };
|
|
}
|
|
import defaultOptions from "kute.js/src/objects/defaultOptions";
|
|
import linkProperty from "kute.js/src/objects/linkProperty";
|
|
import onStart from "kute.js/src/objects/onStart";
|
|
import onComplete from "kute.js/src/objects/onComplete";
|
|
}
|
|
declare module "kute.js/src/process/prepareObject" {
|
|
/**
|
|
* prepareObject
|
|
*
|
|
* Returns all processed valuesStart / valuesEnd.
|
|
*
|
|
* @param {Element} obj the values start/end object
|
|
* @param {string} fn toggles between the two
|
|
*/
|
|
export default function prepareObject(obj: Element, fn: string): void;
|
|
}
|
|
declare module "kute.js/src/process/getStartValues" {
|
|
/**
|
|
* getStartValues
|
|
*
|
|
* Returns the start values for to() method.
|
|
* Used by for the `.to()` static method.
|
|
*
|
|
* @this {KUTE.Tween} the tween instance
|
|
*/
|
|
export default function getStartValues(): void;
|
|
export default class getStartValues {
|
|
valuesStart: {};
|
|
}
|
|
}
|
|
declare module "kute.js/src/process/process" {
|
|
namespace _default {
|
|
export { getInlineStyle };
|
|
export { getStyleForProperty };
|
|
export { getStartValues };
|
|
export { prepareObject };
|
|
}
|
|
export default _default;
|
|
import getInlineStyle from "kute.js/src/process/getInlineStyle";
|
|
import getStyleForProperty from "kute.js/src/process/getStyleForProperty";
|
|
import getStartValues from "kute.js/src/process/getStartValues";
|
|
import prepareObject from "kute.js/src/process/prepareObject";
|
|
}
|
|
declare module "kute.js/src/tween/tweenBase" {
|
|
/**
|
|
* The `TweenBase` constructor creates a new `Tween` object
|
|
* for a single `HTMLElement` and returns it.
|
|
*
|
|
* `TweenBase` is meant to be used with pre-processed values.
|
|
*/
|
|
export default class TweenBase {
|
|
/**
|
|
* @param {Element} targetElement the target element
|
|
* @param {KUTE.tweenProps} startObject the start values
|
|
* @param {KUTE.tweenProps} endObject the end values
|
|
* @param {KUTE.tweenOptions} opsObject the end values
|
|
* @returns {TweenBase} the resulting Tween object
|
|
*/
|
|
constructor(targetElement: Element, startObject: import("kute.js/types").tweenProps, endObject: import("kute.js/types").tweenProps, opsObject: KUTE.tweenOptions);
|
|
element: Element;
|
|
/** @type {boolean} */
|
|
playing: boolean;
|
|
/** @type {number?} */
|
|
_startTime: number | null;
|
|
/** @type {boolean} */
|
|
_startFired: boolean;
|
|
valuesEnd: import("kute.js/types").tweenProps;
|
|
valuesStart: import("kute.js/types").tweenProps;
|
|
_resetStart: any;
|
|
/** @type {KUTE.easingOption} */
|
|
_easing: KUTE.easingOption;
|
|
/** @type {number} */
|
|
_duration: number;
|
|
/** @type {number} */
|
|
_delay: number;
|
|
/**
|
|
* Starts tweening
|
|
* @param {number?} time the tween start time
|
|
* @returns {TweenBase} this instance
|
|
*/
|
|
start(time: number | null): TweenBase;
|
|
/**
|
|
* Stops tweening
|
|
* @returns {TweenBase} this instance
|
|
*/
|
|
stop(): TweenBase;
|
|
/**
|
|
* Trigger internal completion callbacks.
|
|
*/
|
|
close(): void;
|
|
/**
|
|
* Schedule another tween instance to start once this one completes.
|
|
* @param {KUTE.chainOption} args the tween animation start time
|
|
* @returns {TweenBase} this instance
|
|
*/
|
|
chain(args: KUTE.chainOption): TweenBase;
|
|
_chain: any;
|
|
/**
|
|
* Stop tweening the chained tween instances.
|
|
*/
|
|
stopChainedTweens(): void;
|
|
/**
|
|
* Update the tween on each tick.
|
|
* @param {number} time the tick time
|
|
* @returns {boolean} this instance
|
|
*/
|
|
update(time: number): boolean;
|
|
}
|
|
}
|
|
declare module "kute.js/src/tween/tween" {
|
|
/**
|
|
* The `KUTE.Tween()` constructor creates a new `Tween` object
|
|
* for a single `HTMLElement` and returns it.
|
|
*
|
|
* This constructor adds additional functionality and is the default
|
|
* Tween object constructor in KUTE.js.
|
|
*/
|
|
export default class Tween extends TweenBase {
|
|
/** @type {boolean} */
|
|
paused: boolean;
|
|
/** @type {number?} */
|
|
_pauseTime: number | null;
|
|
/** @type {number?} */
|
|
_repeat: number | null;
|
|
/** @type {number?} */
|
|
_repeatDelay: number | null;
|
|
/** @type {number?} */
|
|
_repeatOption: number | null;
|
|
/** @type {KUTE.tweenProps} */
|
|
valuesRepeat: import("kute.js/types").tweenProps;
|
|
/** @type {boolean} */
|
|
_yoyo: boolean;
|
|
/** @type {boolean} */
|
|
_reversed: boolean;
|
|
/**
|
|
* Resume tweening
|
|
* @returns {Tween} this instance
|
|
*/
|
|
resume(): Tween;
|
|
/**
|
|
* Pause tweening
|
|
* @returns {Tween} this instance
|
|
*/
|
|
pause(): Tween;
|
|
/**
|
|
* Reverses start values with end values
|
|
*/
|
|
reverse(): void;
|
|
}
|
|
import TweenBase from "kute.js/src/tween/tweenBase";
|
|
}
|
|
declare module "kute.js/src/tween/tweenExtra" {
|
|
/**
|
|
* The `KUTE.TweenExtra()` constructor creates a new `Tween` object
|
|
* for a single `HTMLElement` and returns it.
|
|
*
|
|
* This constructor is intended for experiments or testing of new features.
|
|
*/
|
|
export default class TweenExtra extends Tween {
|
|
/**
|
|
* Method to add callbacks on the fly.
|
|
* @param {string} name callback name
|
|
* @param {Function} fn callback function
|
|
* @returns {TweenExtra}
|
|
*/
|
|
on(name: string, fn: Function): TweenExtra;
|
|
/**
|
|
* Method to set options on the fly.
|
|
* * accepting [repeat,yoyo,delay,repeatDelay,easing]
|
|
*
|
|
* @param {string} option the tick time
|
|
* @param {string | number | number[]} value the tick time
|
|
* @returns {TweenExtra}
|
|
*/
|
|
option(option: string, value: string | number | number[]): TweenExtra;
|
|
}
|
|
import Tween from "kute.js/src/tween/tween";
|
|
}
|
|
declare module "kute.js/src/util/degToRad" {
|
|
export default degToRad;
|
|
/**
|
|
* degToRad
|
|
*
|
|
* Returns the value of a degree angle in radian.
|
|
*
|
|
* @param {number} a the degree angle
|
|
* @returns {number} the radian angle
|
|
*/
|
|
function degToRad(a: number): number;
|
|
}
|
|
declare module "kute.js/src/util/fromJSON" {
|
|
export default fromJSON;
|
|
/**
|
|
* fromJSON
|
|
*
|
|
* Returns the {valuesStart, valuesEnd} objects
|
|
* from a Tween instance.
|
|
*
|
|
* @param {string} str the JSON string
|
|
* @returns {JSON} the JSON object
|
|
*/
|
|
function fromJSON(str: string): JSON;
|
|
}
|
|
declare module "kute.js/src/util/progressBar" {
|
|
/**
|
|
* ProgressBar
|
|
*
|
|
* @class
|
|
* A progress bar utility for KUTE.js that will connect
|
|
* a target `<input type="slider">`. with a Tween instance
|
|
* allowing it to control the progress of the Tween.
|
|
*/
|
|
export default class ProgressBar {
|
|
/**
|
|
* @constructor
|
|
* @param {HTMLElement} el target or string selector
|
|
* @param {KUTE.Tween} multi when true returns an array of elements
|
|
*/
|
|
constructor(element: any, tween: any);
|
|
element: HTMLInputElement;
|
|
updateBar(): void;
|
|
toggleEvents(action: any): void;
|
|
updateTween(): void;
|
|
moveAction(): void;
|
|
downAction(): void;
|
|
upAction(): void;
|
|
}
|
|
}
|
|
declare module "kute.js/src/util/radToDeg" {
|
|
export default radToDeg;
|
|
/**
|
|
* radToDeg
|
|
*
|
|
* Returns the value of a radian in degrees.
|
|
*
|
|
* @param {number} a the value in radian
|
|
* @returns {number} the value in degrees
|
|
*/
|
|
function radToDeg(a: number): number;
|
|
}
|
|
declare module "kute.js/src/util/rgbToHex" {
|
|
export default rgbToHex;
|
|
/**
|
|
* rgbToHex
|
|
*
|
|
* Converts an {r,g,b} color `Object` into #HEX string color format.
|
|
* Webkit browsers ignore HEX, always use RGB/RGBA.
|
|
*
|
|
* @param {number} r the red value
|
|
* @param {number} g the green value
|
|
* @param {number} b the blue value
|
|
* @returns {string} the #HEX string
|
|
*/
|
|
function rgbToHex(r: number, g: number, b: number): string;
|
|
}
|
|
declare module "kute.js/src/util/toJSON" {
|
|
export default toJSON;
|
|
/**
|
|
* toJSON
|
|
*
|
|
* Returns the {valuesStart, valuesEnd} objects
|
|
* from a Tween instance in JSON string format.
|
|
*
|
|
* @param {KUTE.Tween} tween the Tween instance
|
|
* @returns {string} the JSON string
|
|
*/
|
|
function toJSON(tween: KUTE.Tween): string;
|
|
}
|
|
declare module "kute.js/src/util/version" {
|
|
export default Version;
|
|
/**
|
|
* A global namespace for library version.
|
|
* @type {string}
|
|
*/
|
|
const Version: string;
|
|
}
|
|
declare module "kute.js/types/more/kute" {
|
|
export { default as Animation } from "kute.js/src/animation/animation";
|
|
export { default as AnimationBase } from "kute.js/src/animation/animationBase";
|
|
export { default as AnimationDevelopment } from "kute.js/src/animation/animationDevelopment";
|
|
export { default as backgroundPosition } from "kute.js/src/components/backgroundPosition";
|
|
export { default as backgroundPositionBase } from "kute.js/src/components/backgroundPositionBase";
|
|
export { default as borderRadius } from "kute.js/src/components/borderRadius";
|
|
export { default as borderRadiusBase } from "kute.js/src/components/borderRadiusBase";
|
|
export { default as boxModel } from "kute.js/src/components/boxModel";
|
|
export { default as boxModelBase } from "kute.js/src/components/boxModelBase";
|
|
export { default as boxModelEssential } from "kute.js/src/components/boxModelEssential";
|
|
export { default as clipProperty } from "kute.js/src/components/clipProperty";
|
|
export { default as clipPropertyBase } from "kute.js/src/components/clipPropertyBase";
|
|
export { default as colorProperties } from "kute.js/src/components/colorProperties";
|
|
export { default as colorPropertiesBase } from "kute.js/src/components/colorPropertiesBase";
|
|
export { default as crossBrowserMove } from "kute.js/src/components/crossBrowserMove";
|
|
export { default as filterEffects } from "kute.js/src/components/filterEffects";
|
|
export { default as filterEffectsBase } from "kute.js/src/components/filterEffectsBase";
|
|
export { default as htmlAttributes } from "kute.js/src/components/htmlAttributes";
|
|
export { default as htmlAttributesBase } from "kute.js/src/components/htmlAttributesBase";
|
|
export { default as opacityProperty } from "kute.js/src/components/opacityProperty";
|
|
export { default as opacityPropertyBase } from "kute.js/src/components/opacityPropertyBase";
|
|
export { default as scrollProperty } from "kute.js/src/components/scrollProperty";
|
|
export { default as scrollPropertyBase } from "kute.js/src/components/scrollPropertyBase";
|
|
export { default as shadowProperties } from "kute.js/src/components/shadowProperties";
|
|
export { default as shadowPropertiesBase } from "kute.js/src/components/shadowPropertiesBase";
|
|
export { default as svgCubicMorph } from "kute.js/src/components/svgCubicMorph";
|
|
export { default as svgCubicMorphBase } from "kute.js/src/components/svgCubicMorphBase";
|
|
export { default as svgDraw } from "kute.js/src/components/svgDraw";
|
|
export { default as svgDrawBase } from "kute.js/src/components/svgDrawBase";
|
|
export { default as svgMorph } from "kute.js/src/components/svgMorph";
|
|
export { default as svgMorphBase } from "kute.js/src/components/svgMorphBase";
|
|
export { default as svgTransform } from "kute.js/src/components/svgTransform";
|
|
export { default as svgTransformBase } from "kute.js/src/components/svgTransformBase";
|
|
export { default as textProperties } from "kute.js/src/components/textProperties";
|
|
export { default as textPropertiesBase } from "kute.js/src/components/textPropertiesBase";
|
|
export { default as textWrite } from "kute.js/src/components/textWrite";
|
|
export { default as textWriteBase } from "kute.js/src/components/textWriteBase";
|
|
export { default as transformFunctions } from "kute.js/src/components/transformFunctions";
|
|
export { default as transformFunctionsBase } from "kute.js/src/components/transformFunctionsBase";
|
|
export { default as transformLegacy } from "kute.js/src/components/transformLegacy";
|
|
export { default as transformLegacyBase } from "kute.js/src/components/transformLegacyBase";
|
|
export { default as transformMatrix } from "kute.js/src/components/transformMatrix";
|
|
export { default as transformMatrixBase } from "kute.js/src/components/transformMatrixBase";
|
|
export { default as add } from "kute.js/src/core/add";
|
|
export { default as getAll } from "kute.js/src/core/getAll";
|
|
export { default as Internals } from "kute.js/src/core/internals";
|
|
export { default as linkInterpolation } from "kute.js/src/core/linkInterpolation";
|
|
export { default as queueStart } from "kute.js/src/core/queueStart";
|
|
export { default as remove } from "kute.js/src/core/remove";
|
|
export { default as removeAll } from "kute.js/src/core/removeAll";
|
|
export { default as Render } from "kute.js/src/core/render";
|
|
export { default as EasingBase } from "kute.js/src/easing/easing-base";
|
|
export { default as EasingBezier } from "kute.js/src/easing/easing-bezier";
|
|
export { default as Easing } from "kute.js/src/easing/easing";
|
|
export { default as allFromTo } from "kute.js/src/interface/allFromTo";
|
|
export { default as allTo } from "kute.js/src/interface/allTo";
|
|
export { default as fromTo } from "kute.js/src/interface/fromTo";
|
|
export { default as to } from "kute.js/src/interface/to";
|
|
export { default as arrays } from "kute.js/src/interpolation/arrays";
|
|
export { default as colors } from "kute.js/src/interpolation/colors";
|
|
export { default as coords } from "kute.js/src/interpolation/coords";
|
|
export { default as numbers } from "kute.js/src/interpolation/numbers";
|
|
export { default as perspective } from "kute.js/src/interpolation/perspective";
|
|
export { default as rotate } from "kute.js/src/interpolation/rotate";
|
|
export { default as rotate3d } from "kute.js/src/interpolation/rotate3d";
|
|
export { default as scale } from "kute.js/src/interpolation/scale";
|
|
export { default as skew } from "kute.js/src/interpolation/skew";
|
|
export { default as skewX } from "kute.js/src/interpolation/skewX";
|
|
export { default as skewY } from "kute.js/src/interpolation/skewY";
|
|
export { default as translate } from "kute.js/src/interpolation/translate";
|
|
export { default as translate3d } from "kute.js/src/interpolation/translate3d";
|
|
export { default as units } from "kute.js/src/interpolation/units";
|
|
export { default as ComponentsBase } from "kute.js/src/objects/componentsBase";
|
|
export { default as ComponentsDefault } from "kute.js/src/objects/componentsDefault";
|
|
export { default as ComponentsExtra } from "kute.js/src/objects/componentsExtra";
|
|
export { default as connect } from "kute.js/src/objects/connect";
|
|
export { default as crossCheck } from "kute.js/src/objects/crossCheck";
|
|
export { default as defaultOptions } from "kute.js/src/objects/defaultOptions";
|
|
export { default as defaultValues } from "kute.js/src/objects/defaultValues";
|
|
export { default as globalObject } from "kute.js/src/objects/globalObject";
|
|
export { default as Interpolate } from "kute.js/src/objects/interpolate";
|
|
export { default as KEC } from "kute.js/src/objects/kute";
|
|
export { default as linkProperty } from "kute.js/src/objects/linkProperty";
|
|
export { default as Objects } from "kute.js/src/objects/objects";
|
|
export { default as ObjectsBase } from "kute.js/src/objects/objectsBase";
|
|
export { default as onComplete } from "kute.js/src/objects/onComplete";
|
|
export { default as onStart } from "kute.js/src/objects/onStart";
|
|
export { default as prepareProperty } from "kute.js/src/objects/prepareProperty";
|
|
export { default as prepareStart } from "kute.js/src/objects/prepareStart";
|
|
export { default as supportedProperties } from "kute.js/src/objects/supportedProperties";
|
|
export { default as Tweens } from "kute.js/src/objects/tweens";
|
|
export { default as Util } from "kute.js/src/objects/util";
|
|
export { default as getInlineStyle } from "kute.js/src/process/getInlineStyle";
|
|
export { default as getInlineStyleLegacy } from "kute.js/src/process/getInlineStyleLegacy";
|
|
export { default as getStartValues } from "kute.js/src/process/getStartValues";
|
|
export { default as getStyleForProperty } from "kute.js/src/process/getStyleForProperty";
|
|
export { default as prepareObject } from "kute.js/src/process/prepareObject";
|
|
export { default as Process } from "kute.js/src/process/process";
|
|
export { default as Tween } from "kute.js/src/tween/tween";
|
|
export { default as TweenBase } from "kute.js/src/tween/tweenBase";
|
|
export { default as TweenCollection } from "kute.js/src/tween/tweenCollection";
|
|
export { default as TweenExtra } from "kute.js/src/tween/tweenExtra";
|
|
export { default as degToRad } from "kute.js/src/util/degToRad";
|
|
export { default as fromJSON } from "kute.js/src/util/fromJSON";
|
|
export { default as getPrefix } from "kute.js/src/util/getPrefix";
|
|
export { default as hexToRGB } from "kute.js/src/util/hexToRGB";
|
|
export { default as now } from "kute.js/src/util/now";
|
|
export { default as ProgressBar } from "kute.js/src/util/progressBar";
|
|
export { default as radToDeg } from "kute.js/src/util/radToDeg";
|
|
export { default as rgbToHex } from "kute.js/src/util/rgbToHex";
|
|
export { default as selector } from "kute.js/src/util/selector";
|
|
export { default as supportLegacyTransform } from "kute.js/src/util/supportLegacyTransform";
|
|
export { default as toJSON } from "kute.js/src/util/toJSON";
|
|
export { default as transformProperty } from "kute.js/src/util/transformProperty";
|
|
export { default as trueColor } from "kute.js/src/util/trueColor";
|
|
export { default as trueDimension } from "kute.js/src/util/trueDimension";
|
|
export { default as trueProperty } from "kute.js/src/util/trueProperty";
|
|
export { default as Version } from "kute.js/src/util/version";
|
|
}
|