code
stringlengths 28
313k
| docstring
stringlengths 25
85.3k
| func_name
stringlengths 1
74
| language
stringclasses 1
value | repo
stringlengths 5
60
| path
stringlengths 4
172
| url
stringlengths 44
218
| license
stringclasses 7
values |
|---|---|---|---|---|---|---|---|
function triggerNotImplemented(name, args) {
let error = `"${name}" not implemented`;
console.error(error, args);
throw new Error(error);
}
|
@param {string} name
@param {any[]} args
|
triggerNotImplemented
|
javascript
|
PepsRyuu/nollup
|
lib/impl/PluginLifecycle.js
|
https://github.com/PepsRyuu/nollup/blob/master/lib/impl/PluginLifecycle.js
|
MIT
|
function isExternal (config, name) {
if (config && config.external) {
let external = config.external;
if (Array.isArray(external)) {
return external.indexOf(name) > -1;
}
if (typeof external === 'function') {
return external(name, undefined, undefined);
}
}
return false;
}
|
@param {RollupConfigContainer} config
@param {string} name
@return {boolean | void}
|
isExternal
|
javascript
|
PepsRyuu/nollup
|
lib/impl/PluginLifecycle.js
|
https://github.com/PepsRyuu/nollup/blob/master/lib/impl/PluginLifecycle.js
|
MIT
|
async resolveIdImpl (container, id, parentFilePath, options = {}) {
options.isEntry = options.isEntry || false;
options.custom = options.hasOwnProperty('custom')? options.custom : {};
let __plugins = container.__plugins.filter(p => !this.resolveIdSkips.contains(p.execute, parentFilePath, id));
let hr = await callAsyncFirstHook(/** @type {PluginContainer} */ ({ __plugins, __config: container.__config }), 'resolveId', [id, parentFilePath, options]);
if (hr === false || isExternal(container.__config, id)) {
return {
id,
external: true
};
}
if (typeof hr === 'string') {
hr = {
id: path.isAbsolute(hr)? path.normalize(hr) : hr,
external: false
};
}
if (!hr) {
let parent = parentFilePath || path.resolve(process.cwd(), '__entry');
hr = {
id: path.normalize(resolvePath(id, parent)),
external: false
};
if (!fs.existsSync(hr.id)) {
hr.external = true;
hr.id = id;
}
}
handleMetaProperty(container, hr.id, hr.meta);
return hr;
}
|
@param {PluginContainer} container
@param {string} id
@param {string} parentFilePath
@return {Promise<RollupResolveIdResult>}
|
resolveIdImpl
|
javascript
|
PepsRyuu/nollup
|
lib/impl/PluginLifecycle.js
|
https://github.com/PepsRyuu/nollup/blob/master/lib/impl/PluginLifecycle.js
|
MIT
|
function prepareSourceMapChain (mapChain, original_code, filepath) {
mapChain = mapChain.filter(o => o.map && o.map.mappings).reverse();
if (mapChain.length > 1) {
mapChain.forEach((obj, index) => {
obj.map.version = 3;
obj.map.file = filepath + '_' + index;
// Check is in place because some transforms return sources, in particular multi-file sources.
obj.map.sources = obj.map.sources.length === 1? [filepath + '_' + (index + 1)] : obj.map.sources;
if(obj.map.sourcesContent && obj.map.sourcesContent.length === 1) {
obj.map.sourcesContent = [mapChain[index + 1] ? mapChain[index + 1].code : original_code]
}
});
}
return mapChain;
}
|
@param {NollupTransformMapEntry[]} mapChain
@param {string} original_code
@param {string} filepath
@return {NollupTransformMapEntry[]}
|
prepareSourceMapChain
|
javascript
|
PepsRyuu/nollup
|
lib/impl/PluginUtils.js
|
https://github.com/PepsRyuu/nollup/blob/master/lib/impl/PluginUtils.js
|
MIT
|
function generateSourceMap (mapChain, mapGenerator, original_code, filepath) {
let map;
if (mapChain.length > 1) {
// @ts-ignore
map = mapGenerator.toJSON();
} else {
map = mapChain.length > 0? mapChain[0].map : undefined;
}
if (map) {
map.file = filepath;
map.sources = [filepath];
map.sourcesContent = [original_code];
}
// @ts-ignore
return map;
}
|
@param {NollupTransformMapEntry[]} mapChain
@param {SourceMapGenerator} mapGenerator
@param {string} original_code
@param {string} filepath
@return {RollupSourceMap}
|
generateSourceMap
|
javascript
|
PepsRyuu/nollup
|
lib/impl/PluginUtils.js
|
https://github.com/PepsRyuu/nollup/blob/master/lib/impl/PluginUtils.js
|
MIT
|
function combineSourceMapChain (inputMapChain, original_code, filepath) {
let mapGenerator, mapChain = prepareSourceMapChain(inputMapChain, original_code, filepath);
if (mapChain.length > 1) {
// @ts-ignore
mapGenerator = SourceMap.SourceMapGenerator.fromSourceMap(new SourceMap.SourceMapConsumer(mapChain[0].map));
for (let i = 1; i < mapChain.length; i++) {
// @ts-ignore
mapGenerator.applySourceMap(new SourceMap.SourceMapConsumer(mapChain[i].map), undefined, undefined);
}
}
return generateSourceMap(mapChain, mapGenerator, original_code, filepath);
}
|
@param {NollupTransformMapEntry[]} inputMapChain
@param {string} original_code
@param {string} filepath
@return {RollupSourceMap}
|
combineSourceMapChain
|
javascript
|
PepsRyuu/nollup
|
lib/impl/PluginUtils.js
|
https://github.com/PepsRyuu/nollup/blob/master/lib/impl/PluginUtils.js
|
MIT
|
async function combineSourceMapChainFast (inputMapChain, original_code, filepath) {
let mapGenerator, mapChain = prepareSourceMapChain(inputMapChain, original_code, filepath);
if (mapChain.length > 1) {
mapGenerator = SourceMapFast.SourceMapGenerator.fromSourceMap(await new SourceMapFast.SourceMapConsumer(mapChain[0].map));
for (let i = 1; i < mapChain.length; i++) {
mapGenerator.applySourceMap(await new SourceMapFast.SourceMapConsumer(mapChain[i].map))
}
}
return generateSourceMap(mapChain, mapGenerator, original_code, filepath);
}
|
@param {NollupTransformMapEntry[]} inputMapChain
@param {string} original_code
@param {string} filepath
@return {Promise<RollupSourceMap>}
|
combineSourceMapChainFast
|
javascript
|
PepsRyuu/nollup
|
lib/impl/PluginUtils.js
|
https://github.com/PepsRyuu/nollup/blob/master/lib/impl/PluginUtils.js
|
MIT
|
function getModuleInfo (container, id) {
let response = container.__onGetModuleInfo(id);
return {
id: id,
code: response.code || null,
isEntry: response.isEntry || false,
isExternal: response.isExternal || false,
importers: response.importers || [],
importedIds: response.importedIds || [],
importedIdResolutions: response.importedIdResolutions || [],
meta: container.__meta[id] || {},
dynamicImporters: response.dynamicImporters || [],
dynamicallyImportedIds: response.dynamicallyImportedIds || [],
dynamicallyImportedIdResolutions: response.dynamicallyImportedIdResolutions || [],
ast: response.ast || null,
hasModuleSideEffects: response.hasModuleSideEffects || false,
syntheticNamedExports: response.syntheticNamedExports || false,
implicitlyLoadedAfterOneOf: response.implicitlyLoadedAfterOneOf || [],
implicitlyLoadedBefore: response.implicitlyLoadedBefore || [],
hasDefaultExport: response.hasDefaultExport,
isIncluded: response.isIncluded || false,
moduleSideEffects: response.moduleSideEffects || true
}
}
|
@param {PluginContainer} container
@param {string} id
@return {RollupModuleInfo}
|
getModuleInfo
|
javascript
|
PepsRyuu/nollup
|
lib/impl/PluginUtils.js
|
https://github.com/PepsRyuu/nollup/blob/master/lib/impl/PluginUtils.js
|
MIT
|
function callOutputOptionsHook (plugins, outputOptions) {
if (plugins) {
plugins.forEach(plugin => {
if (plugin.outputOptions) {
outputOptions = plugin.outputOptions.call({
meta: PluginMeta
}, outputOptions) || outputOptions;
}
});
}
return outputOptions;
}
|
@param {RollupPlugin[]} plugins
@param {RollupOutputOptions} outputOptions
|
callOutputOptionsHook
|
javascript
|
PepsRyuu/nollup
|
lib/impl/RollupConfigContainer.js
|
https://github.com/PepsRyuu/nollup/blob/master/lib/impl/RollupConfigContainer.js
|
MIT
|
function normalizeInput (input) {
if (typeof input === 'string') {
return [input];
}
if (Array.isArray(input)) {
return input;
}
return input;
}
|
@param {RollupInputOption} input
@return {string[]|Object<string, string>}
|
normalizeInput
|
javascript
|
PepsRyuu/nollup
|
lib/impl/RollupConfigContainer.js
|
https://github.com/PepsRyuu/nollup/blob/master/lib/impl/RollupConfigContainer.js
|
MIT
|
function findChildNodes (node) {
let children = [];
for (let prop in node) {
if (Array.isArray(node[prop]) && node[prop][0] && node[prop][0].constructor && node[prop][0].constructor.name === 'Node') {
children.push(...node[prop]);
}
if (node[prop] && node[prop].constructor && node[prop].constructor.name === 'Node') {
children.push(node[prop]);
}
}
return children;
}
|
@param {ESTree} node
@return {Array<ESTree>}
|
findChildNodes
|
javascript
|
PepsRyuu/nollup
|
lib/impl/utils.js
|
https://github.com/PepsRyuu/nollup/blob/master/lib/impl/utils.js
|
MIT
|
function resolvePath (target, current) {
if (path.isAbsolute(target)) {
return path.normalize(target);
} else {
// Plugins like CommonJS have namespaced imports.
let parts = target.split(':');
let namespace = parts.length === 2? parts[0] + ':' : '';
let file = parts.length === 2? parts[1] : parts[0];
let ext = path.extname(file);
return namespace + path.normalize(path.resolve(path.dirname(current), ext? file : file + '.js'));
}
}
|
@param {string} target
@param {string} current
@return {string}
|
resolvePath
|
javascript
|
PepsRyuu/nollup
|
lib/impl/utils.js
|
https://github.com/PepsRyuu/nollup/blob/master/lib/impl/utils.js
|
MIT
|
function formatFileName (format, fileName, pattern) {
let name = path.basename(fileName).replace(path.extname(fileName), '');
if (typeof pattern === 'string') {
return pattern.replace('[name]', name)
.replace('[extname]', path.extname(fileName))
.replace('[ext]', path.extname(fileName).substring(1))
.replace('[format]', format === 'es'? 'esm' : format);
}
// TODO: Function pattern implementation
return '';
}
|
@param {string} format
@param {string} fileName
@param {string|function(RollupPreRenderedFile): string} pattern
@return {string}
|
formatFileName
|
javascript
|
PepsRyuu/nollup
|
lib/impl/utils.js
|
https://github.com/PepsRyuu/nollup/blob/master/lib/impl/utils.js
|
MIT
|
async function logs (count = 1, timeout = 5000) {
let start = Date.now();
// Wait until we acquire the requested number of logs
while (logbuffer.length < count) {
await wait(100);
if (Date.now() - start > timeout) {
break;
}
}
// return the logs and clear it afterwards
return logbuffer.splice(0, logbuffer.length);
}
|
Returns a list of logs.
Waits until the number of requested logs have accumulated.
There's a timeout to force it to stop checking.
@param {Number} count
@param {Number} timeout
@returns {Promise<String[]>}
|
logs
|
javascript
|
PepsRyuu/nollup
|
test/utils/evaluator.js
|
https://github.com/PepsRyuu/nollup/blob/master/test/utils/evaluator.js
|
MIT
|
async function call (fn, arg) {
// TODO: Find deterministic way of handling this
await wait(100);
global._evaluatorInstance.send({ call: [fn, arg] });
await wait(100);
}
|
Call the global function in the VM.
@param {String} fn
@param {*} arg
|
call
|
javascript
|
PepsRyuu/nollup
|
test/utils/evaluator.js
|
https://github.com/PepsRyuu/nollup/blob/master/test/utils/evaluator.js
|
MIT
|
function invalidate (chunks) {
global._evaluatorInstance.send({ invalidate: true, chunks });
}
|
Sends updated bundle chunks to VM.
@param {Object[]} chunks
|
invalidate
|
javascript
|
PepsRyuu/nollup
|
test/utils/evaluator.js
|
https://github.com/PepsRyuu/nollup/blob/master/test/utils/evaluator.js
|
MIT
|
function init (format, entry, chunks, globals = {}, async = false) {
logbuffer = [];
return new Promise((resolve, reject) => {
let impl = (resolve, reject) => {
global._evaluatorResultListener = msg => {
if (msg.log) {
logbuffer.push(msg.log);
return;
}
if (msg.error) {
return reject(msg.error);
}
resolve({ globals: msg.globals, exports: msg.result });
};
global._evaluatorInstance.send({ format, entry, chunks, globals, async });
};
// The forked node may not be ready yet when the test starts.
// This will push the test into a backlog.
if (!global._evaluatorReady) {
global._evaluatorReadyListeners.push(() => impl(resolve, reject));
} else {
impl(resolve, reject);
}
});
}
|
Evaluates the VM with the provided code.
@param {String} format
@param {String} entry
@param {Object[]} chunks
@param {Object} globals
@param {Boolean} async
@returns {Object}
|
init
|
javascript
|
PepsRyuu/nollup
|
test/utils/evaluator.js
|
https://github.com/PepsRyuu/nollup/blob/master/test/utils/evaluator.js
|
MIT
|
constructor(capacity) {
this.capacity = capacity;
this.regExpMap = new Map();
// Since our capacity tends to be fairly small, `.shift()` will be fairly quick despite being O(n). We just use a
// normal array to keep it simple.
this.regExpQueue = [];
}
|
This is a reusable regular expression cache class. Given a certain maximum number of regular expressions we're
allowed to store in the cache, it provides a way to avoid recreating regular expression objects over and over.
When it needs to evict something, it evicts the oldest one.
|
constructor
|
javascript
|
i18next/i18next
|
src/utils.js
|
https://github.com/i18next/i18next/blob/master/src/utils.js
|
MIT
|
deepFind = (obj, path, keySeparator = '.') => {
if (!obj) return undefined;
if (obj[path]) {
if (!Object.prototype.hasOwnProperty.call(obj, path)) return undefined;
return obj[path];
}
const tokens = path.split(keySeparator);
let current = obj;
for (let i = 0; i < tokens.length; ) {
if (!current || typeof current !== 'object') {
return undefined;
}
let next;
let nextPath = '';
for (let j = i; j < tokens.length; ++j) {
if (j !== i) {
nextPath += keySeparator;
}
nextPath += tokens[j];
next = current[nextPath];
if (next !== undefined) {
if (['string', 'number', 'boolean'].indexOf(typeof next) > -1 && j < tokens.length - 1) {
continue;
}
i += j - i + 1;
break;
}
}
current = next;
}
return current;
}
|
Given
1. a top level object obj, and
2. a path to a deeply nested string or object within it
Find and return that deeply nested string or object. The caveat is that the keys of objects within the nesting chain
may contain period characters. Therefore, we need to DFS and explore all possible keys at each step until we find the
deeply nested string or object.
|
deepFind
|
javascript
|
i18next/i18next
|
src/utils.js
|
https://github.com/i18next/i18next/blob/master/src/utils.js
|
MIT
|
httpApiReadMockImplementation = (language, namespace, callback) => {
const namespacePath = `${__dirname}/locales/${language}/${namespace}.json`;
// console.info('httpApiReadMockImplementation', namespacePath);
if (fs.existsSync(namespacePath)) {
const data = JSON.parse(fs.readFileSync(namespacePath, 'utf-8'));
callback(null, data);
} else {
callback('File is not available in `locales` folder', null);
}
}
|
@param {string} language
@param {string} namespace
@param {import('i18next').ReadCallback} callback
@returns {void}
|
httpApiReadMockImplementation
|
javascript
|
i18next/i18next
|
test/compatibility/v1/v1.i18nInstance.js
|
https://github.com/i18next/i18next/blob/master/test/compatibility/v1/v1.i18nInstance.js
|
MIT
|
getI18nCompatibilityV1InitOptions = () => ({
compatibilityAPI: 'v1',
compatibilityJSON: 'v1',
lng: 'en-US',
load: 'all',
fallbackLng: 'dev',
fallbackNS: [],
fallbackOnNull: true,
fallbackOnEmpty: false,
preload: [],
lowerCaseLng: false,
ns: 'translation',
fallbackToDefaultNS: false,
resGetPath: 'http://localhost:9877/locales/__lng__/__ns__.json',
dynamicLoad: false,
useLocalStorage: false,
sendMissing: false,
resStore: false,
getAsync: true,
returnObjectTrees: false,
debug: false,
selectorAttr: 'data-i18n',
postProcess: '',
parseMissingKey: '',
interpolationPrefix: '__',
interpolationSuffix: '__',
defaultVariables: false,
shortcutFunction: 'sprintf',
objectTreeKeyHandler: null,
lngWhitelist: null,
resources: null,
})
|
using a function to have always a new object
|
getI18nCompatibilityV1InitOptions
|
javascript
|
i18next/i18next
|
test/compatibility/v1/v1.i18nInstance.js
|
https://github.com/i18next/i18next/blob/master/test/compatibility/v1/v1.i18nInstance.js
|
MIT
|
function distance(p1, p2) {
return Math.hypot(p1.x - p2.x, p1.y - p2.y);
}
|
Calculates distance between two points. Each point must have `x` and `y` property
@param {*} p1 point 1
@param {*} p2 point 2
@returns distance between two points
|
distance
|
javascript
|
puffinsoft/jscanify
|
src/jscanify-node.js
|
https://github.com/puffinsoft/jscanify/blob/master/src/jscanify-node.js
|
MIT
|
findPaperContour(img) {
const imgGray = new cv.Mat();
cv.Canny(img, imgGray, 50, 200);
const imgBlur = new cv.Mat();
cv.GaussianBlur(
imgGray,
imgBlur,
new cv.Size(3, 3),
0,
0,
cv.BORDER_DEFAULT
);
const imgThresh = new cv.Mat();
cv.threshold(imgBlur, imgThresh, 0, 255, cv.THRESH_BINARY + cv.THRESH_OTSU);
let contours = new cv.MatVector();
let hierarchy = new cv.Mat();
cv.findContours(
imgThresh,
contours,
hierarchy,
cv.RETR_CCOMP,
cv.CHAIN_APPROX_SIMPLE
);
let maxArea = 0;
let maxContourIndex = -1;
for (let i = 0; i < contours.size(); ++i) {
let contourArea = cv.contourArea(contours.get(i));
if (contourArea > maxArea) {
maxArea = contourArea;
maxContourIndex = i;
}
}
const maxContour =
maxContourIndex >= 0 ?
contours.get(maxContourIndex) :
null;
imgGray.delete();
imgBlur.delete();
imgThresh.delete();
contours.delete();
hierarchy.delete();
return maxContour;
}
|
Finds the contour of the paper within the image
@param {*} img image to process (cv.Mat)
@returns the biggest contour inside the image
|
findPaperContour
|
javascript
|
puffinsoft/jscanify
|
src/jscanify-node.js
|
https://github.com/puffinsoft/jscanify/blob/master/src/jscanify-node.js
|
MIT
|
highlightPaper(image, options) {
options = options || {};
options.color = options.color || "orange";
options.thickness = options.thickness || 10;
const canvas = createCanvas();
const ctx = canvas.getContext("2d");
const img = cv.imread(image);
const maxContour = this.findPaperContour(img);
cv.imshow(canvas, img);
if (maxContour) {
const {
topLeftCorner,
topRightCorner,
bottomLeftCorner,
bottomRightCorner,
} = this.getCornerPoints(maxContour, img);
if (
topLeftCorner &&
topRightCorner &&
bottomLeftCorner &&
bottomRightCorner
) {
ctx.strokeStyle = options.color;
ctx.lineWidth = options.thickness;
ctx.beginPath();
ctx.moveTo(...Object.values(topLeftCorner));
ctx.lineTo(...Object.values(topRightCorner));
ctx.lineTo(...Object.values(bottomRightCorner));
ctx.lineTo(...Object.values(bottomLeftCorner));
ctx.lineTo(...Object.values(topLeftCorner));
ctx.stroke();
}
}
img.delete();
return canvas;
}
|
Highlights the paper detected inside the image.
@param {*} image image to process
@param {*} options options for highlighting. Accepts `color` and `thickness` parameter
@returns `HTMLCanvasElement` with original image and paper highlighted
|
highlightPaper
|
javascript
|
puffinsoft/jscanify
|
src/jscanify-node.js
|
https://github.com/puffinsoft/jscanify/blob/master/src/jscanify-node.js
|
MIT
|
extractPaper(image, resultWidth, resultHeight, cornerPoints) {
const canvas = createCanvas();
const img = cv.imread(image);
const maxContour = cornerPoints ? null : this.findPaperContour(img);
if(maxContour == null && cornerPoints === undefined){
return null;
}
const {
topLeftCorner,
topRightCorner,
bottomLeftCorner,
bottomRightCorner,
} = cornerPoints || this.getCornerPoints(maxContour, img);
let warpedDst = new cv.Mat();
let dsize = new cv.Size(resultWidth, resultHeight);
let srcTri = cv.matFromArray(4, 1, cv.CV_32FC2, [
topLeftCorner.x,
topLeftCorner.y,
topRightCorner.x,
topRightCorner.y,
bottomLeftCorner.x,
bottomLeftCorner.y,
bottomRightCorner.x,
bottomRightCorner.y,
]);
let dstTri = cv.matFromArray(4, 1, cv.CV_32FC2, [
0,
0,
resultWidth,
0,
0,
resultHeight,
resultWidth,
resultHeight,
]);
let M = cv.getPerspectiveTransform(srcTri, dstTri);
cv.warpPerspective(
img,
warpedDst,
M,
dsize,
cv.INTER_LINEAR,
cv.BORDER_CONSTANT,
new cv.Scalar()
);
cv.imshow(canvas, warpedDst);
img.delete();
warpedDst.delete();
return canvas;
}
|
Extracts and undistorts the image detected within the frame.
Returns `null` if no paper is detected.
@param {*} image image to process
@param {*} resultWidth desired result paper width
@param {*} resultHeight desired result paper height
@param {*} cornerPoints optional custom corner points, in case automatic corner points are incorrect
@returns `HTMLCanvasElement` containing undistorted image
|
extractPaper
|
javascript
|
puffinsoft/jscanify
|
src/jscanify-node.js
|
https://github.com/puffinsoft/jscanify/blob/master/src/jscanify-node.js
|
MIT
|
getCornerPoints(contour) {
let rect = cv.minAreaRect(contour);
const center = rect.center;
let topLeftCorner;
let topLeftCornerDist = 0;
let topRightCorner;
let topRightCornerDist = 0;
let bottomLeftCorner;
let bottomLeftCornerDist = 0;
let bottomRightCorner;
let bottomRightCornerDist = 0;
for (let i = 0; i < contour.data32S.length; i += 2) {
const point = { x: contour.data32S[i], y: contour.data32S[i + 1] };
const dist = distance(point, center);
if (point.x < center.x && point.y < center.y) {
// top left
if (dist > topLeftCornerDist) {
topLeftCorner = point;
topLeftCornerDist = dist;
}
} else if (point.x > center.x && point.y < center.y) {
// top right
if (dist > topRightCornerDist) {
topRightCorner = point;
topRightCornerDist = dist;
}
} else if (point.x < center.x && point.y > center.y) {
// bottom left
if (dist > bottomLeftCornerDist) {
bottomLeftCorner = point;
bottomLeftCornerDist = dist;
}
} else if (point.x > center.x && point.y > center.y) {
// bottom right
if (dist > bottomRightCornerDist) {
bottomRightCorner = point;
bottomRightCornerDist = dist;
}
}
}
return {
topLeftCorner,
topRightCorner,
bottomLeftCorner,
bottomRightCorner,
};
}
|
Calculates the corner points of a contour.
@param {*} contour contour from {@link findPaperContour}
@returns object with properties `topLeftCorner`, `topRightCorner`, `bottomLeftCorner`, `bottomRightCorner`, each with `x` and `y` property
|
getCornerPoints
|
javascript
|
puffinsoft/jscanify
|
src/jscanify-node.js
|
https://github.com/puffinsoft/jscanify/blob/master/src/jscanify-node.js
|
MIT
|
extractPaper(image, resultWidth, resultHeight, cornerPoints) {
const canvas = document.createElement("canvas");
const img = cv.imread(image);
const maxContour = cornerPoints ? null : this.findPaperContour(img);
if(maxContour == null && cornerPoints === undefined){
return null;
}
const {
topLeftCorner,
topRightCorner,
bottomLeftCorner,
bottomRightCorner,
} = cornerPoints || this.getCornerPoints(maxContour, img);
let warpedDst = new cv.Mat();
let dsize = new cv.Size(resultWidth, resultHeight);
let srcTri = cv.matFromArray(4, 1, cv.CV_32FC2, [
topLeftCorner.x,
topLeftCorner.y,
topRightCorner.x,
topRightCorner.y,
bottomLeftCorner.x,
bottomLeftCorner.y,
bottomRightCorner.x,
bottomRightCorner.y,
]);
let dstTri = cv.matFromArray(4, 1, cv.CV_32FC2, [
0,
0,
resultWidth,
0,
0,
resultHeight,
resultWidth,
resultHeight,
]);
let M = cv.getPerspectiveTransform(srcTri, dstTri);
cv.warpPerspective(
img,
warpedDst,
M,
dsize,
cv.INTER_LINEAR,
cv.BORDER_CONSTANT,
new cv.Scalar()
);
cv.imshow(canvas, warpedDst);
img.delete()
warpedDst.delete()
return canvas;
}
|
Extracts and undistorts the image detected within the frame.
Returns `null` if no paper is detected.
@param {*} image image to process
@param {*} resultWidth desired result paper width
@param {*} resultHeight desired result paper height
@param {*} cornerPoints optional custom corner points, in case automatic corner points are incorrect
@returns `HTMLCanvasElement` containing undistorted image
|
extractPaper
|
javascript
|
puffinsoft/jscanify
|
src/jscanify.js
|
https://github.com/puffinsoft/jscanify/blob/master/src/jscanify.js
|
MIT
|
function processSegmentation(canvas, segmentation) {
var ctx = canvas.getContext('2d');
console.log(segmentation)
// Get data from our overlay canvas which is attempting to estimate background.
var imageData = ctx.getImageData(0, 0, canvas.width, canvas.height);
var data = imageData.data;
// Get data from the live webcam view which has all data.
var liveData = videoRenderCanvasCtx.getImageData(0, 0, canvas.width, canvas.height);
var dataL = liveData.data;
var minX = 100000;
var minY = 100000;
var maxX = 0;
var maxY = 0;
var foundBody = false;
// Go through pixels and figure out bounding box of body pixels.
for (let x = 0; x < canvas.width; x++) {
for (let y = 0; y < canvas.height; y++) {
let n = y * canvas.width + x;
// Human pixel found. Update bounds.
if (segmentation.data[n] !== 0) {
if(x < minX) {
minX = x;
}
if(y < minY) {
minY = y;
}
if(x > maxX) {
maxX = x;
}
if(y > maxY) {
maxY = y;
}
foundBody = true;
}
}
}
// Calculate dimensions of bounding box.
var width = maxX - minX;
var height = maxY - minY;
// Define scale factor to use to allow for false negatives around this region.
var scale = 1.3;
// Define scaled dimensions.
var newWidth = width * scale;
var newHeight = height * scale;
// Caculate the offset to place new bounding box so scaled from center of current bounding box.
var offsetX = (newWidth - width) / 2;
var offsetY = (newHeight - height) / 2;
var newXMin = minX - offsetX;
var newYMin = minY - offsetY;
// Now loop through update backgound understanding with new data
// if not inside a bounding box.
for (let x = 0; x < canvas.width; x++) {
for (let y = 0; y < canvas.height; y++) {
// If outside bounding box and we found a body, update background.
if (foundBody && (x < newXMin || x > newXMin + newWidth) || ( y < newYMin || y > newYMin + newHeight)) {
// Convert xy co-ords to array offset.
let n = y * canvas.width + x;
data[n * 4] = dataL[n * 4];
data[n * 4 + 1] = dataL[n * 4 + 1];
data[n * 4 + 2] = dataL[n * 4 + 2];
data[n * 4 + 3] = 255;
} else if (!foundBody) {
// No body found at all, update all pixels.
let n = y * canvas.width + x;
data[n * 4] = dataL[n * 4];
data[n * 4 + 1] = dataL[n * 4 + 1];
data[n * 4 + 2] = dataL[n * 4 + 2];
data[n * 4 + 3] = 255;
}
}
}
ctx.putImageData(imageData, 0, 0);
if (DEBUG) {
ctx.strokeStyle = "#00FF00"
ctx.beginPath();
ctx.rect(newXMin, newYMin, newWidth, newHeight);
ctx.stroke();
}
}
|
*****************************************************************
Real-Time-Person-Removal Created by Jason Mayes 2020.
Get latest code on my Github:
https://github.com/jasonmayes/Real-Time-Person-Removal
Got questions? Reach out to me on social:
Twitter: @jason_mayes
LinkedIn: https://www.linkedin.com/in/creativetech
******************************************************************
|
processSegmentation
|
javascript
|
jasonmayes/Real-Time-Person-Removal
|
script.js
|
https://github.com/jasonmayes/Real-Time-Person-Removal/blob/master/script.js
|
Apache-2.0
|
function hasGetUserMedia() {
return !!(navigator.mediaDevices &&
navigator.mediaDevices.getUserMedia);
}
|
*****************************************************************
// Continuously grab image from webcam stream and classify it.
******************************************************************
|
hasGetUserMedia
|
javascript
|
jasonmayes/Real-Time-Person-Removal
|
script.js
|
https://github.com/jasonmayes/Real-Time-Person-Removal/blob/master/script.js
|
Apache-2.0
|
Juggernaut = function(options){
this.options = options || {};
this.options.host = this.options.host || window.location.hostname;
this.options.port = this.options.port || 8080;
this.handlers = {};
this.meta = this.options.meta;
this.io = io.connect(this.options.host, this.options);
this.io.on("connect", this.proxy(this.onconnect));
this.io.on("message", this.proxy(this.onmessage));
this.io.on("disconnect", this.proxy(this.ondisconnect));
this.on("connect", this.proxy(this.writeMeta));
}
|
Add the transport to your public io.transports array.
@api private
|
Juggernaut
|
javascript
|
maccman/juggernaut
|
client.js
|
https://github.com/maccman/juggernaut/blob/master/client.js
|
MIT
|
banner = (format, addTypes) => {
const date = new Date();
return `/**
* anime.js - ${ format }
* @version v${ pkg.version }
* @author Julian Garnier
* @license MIT
* @copyright (c) ${ date.getFullYear() } Julian Garnier
* @see https://animejs.com
*/${addTypes ? jsDocTypes : ''}
`
}
|
@param {String} format
@param {Boolean} [addTypes]
@return {String}
|
banner
|
javascript
|
juliangarnier/anime
|
rollup.config.js
|
https://github.com/juliangarnier/anime/blob/master/rollup.config.js
|
MIT
|
getTotalWidth = (total, $el) => {
const style= getComputedStyle($el);
const marginsWidth = parseInt(style.marginLeft) + parseInt(style.marginRight);
return total + $el.offsetWidth + marginsWidth;
}
|
@param {Number} total
@param {HTMLElement} $el
@return {Number}
|
getTotalWidth
|
javascript
|
juliangarnier/anime
|
examples/draggable-infinite-auto-carousel/index.js
|
https://github.com/juliangarnier/anime/blob/master/examples/draggable-infinite-auto-carousel/index.js
|
MIT
|
parseNumber = str => isStr(str) ?
parseFloat(/** @type {String} */(str)) :
/** @type {Number} */(str)
|
@param {Number|String} str
@return {Number}
|
parseNumber
|
javascript
|
juliangarnier/anime
|
lib/anime.esm.js
|
https://github.com/juliangarnier/anime/blob/master/lib/anime.esm.js
|
MIT
|
round = (v, decimalLength) => {
if (decimalLength < 0) return v;
if (!decimalLength) return _round(v);
let p = powCache[decimalLength];
if (!p) p = powCache[decimalLength] = 10 ** decimalLength;
return _round(v * p) / p;
}
|
@param {Number} v
@param {Number} decimalLength
@return {Number}
|
round
|
javascript
|
juliangarnier/anime
|
lib/anime.esm.js
|
https://github.com/juliangarnier/anime/blob/master/lib/anime.esm.js
|
MIT
|
forEachChildren = (parent, callback, reverse, prevProp = '_prev', nextProp = '_next') => {
let next = parent._head;
let adjustedNextProp = nextProp;
if (reverse) {
next = parent._tail;
adjustedNextProp = prevProp;
}
while (next) {
const currentNext = next[adjustedNextProp];
callback(next);
next = currentNext;
}
}
|
@param {Object} parent
@param {Function} callback
@param {Boolean} [reverse]
@param {String} [prevProp]
@param {String} [nextProp]
@return {void}
|
forEachChildren
|
javascript
|
juliangarnier/anime
|
lib/anime.esm.js
|
https://github.com/juliangarnier/anime/blob/master/lib/anime.esm.js
|
MIT
|
removeChild = (parent, child, prevProp = '_prev', nextProp = '_next') => {
const prev = child[prevProp];
const next = child[nextProp];
prev ? prev[nextProp] = next : parent._head = next;
next ? next[prevProp] = prev : parent._tail = prev;
child[prevProp] = null;
child[nextProp] = null;
}
|
@param {Object} parent
@param {Object} child
@param {String} [prevProp]
@param {String} [nextProp]
@return {void}
|
removeChild
|
javascript
|
juliangarnier/anime
|
lib/anime.esm.js
|
https://github.com/juliangarnier/anime/blob/master/lib/anime.esm.js
|
MIT
|
addChild = (parent, child, sortMethod, prevProp = '_prev', nextProp = '_next') => {
let prev = parent._tail;
while (prev && sortMethod && sortMethod(prev, child)) prev = prev[prevProp];
const next = prev ? prev[nextProp] : parent._head;
prev ? prev[nextProp] = child : parent._head = child;
next ? next[prevProp] = child : parent._tail = child;
child[prevProp] = prev;
child[nextProp] = next;
}
|
@param {Object} parent
@param {Object} child
@param {Function} [sortMethod]
@param {String} prevProp
@param {String} nextProp
@return {void}
|
addChild
|
javascript
|
juliangarnier/anime
|
lib/anime.esm.js
|
https://github.com/juliangarnier/anime/blob/master/lib/anime.esm.js
|
MIT
|
render = (tickable, time, muteCallbacks, internalRender, tickMode) => {
const parent = tickable.parent;
const duration = tickable.duration;
const completed = tickable.completed;
const iterationDuration = tickable.iterationDuration;
const iterationCount = tickable.iterationCount;
const _currentIteration = tickable._currentIteration;
const _loopDelay = tickable._loopDelay;
const _reversed = tickable._reversed;
const _alternate = tickable._alternate;
const _hasChildren = tickable._hasChildren;
const tickableDelay = tickable._delay;
const tickablePrevAbsoluteTime = tickable._currentTime; // TODO: rename ._currentTime to ._absoluteCurrentTime
const tickableEndTime = tickableDelay + iterationDuration;
const tickableAbsoluteTime = time - tickableDelay;
const tickablePrevTime = clamp(tickablePrevAbsoluteTime, -tickableDelay, duration);
const tickableCurrentTime = clamp(tickableAbsoluteTime, -tickableDelay, duration);
const deltaTime = tickableAbsoluteTime - tickablePrevAbsoluteTime;
const isCurrentTimeAboveZero = tickableCurrentTime > 0;
const isCurrentTimeEqualOrAboveDuration = tickableCurrentTime >= duration;
const isSetter = duration <= minValue;
const forcedTick = tickMode === tickModes.FORCE;
let isOdd = 0;
let iterationElapsedTime = tickableAbsoluteTime;
// Render checks
// Used to also check if the children have rendered in order to trigger the onRender callback on the parent timer
let hasRendered = 0;
// Execute the "expensive" iterations calculations only when necessary
if (iterationCount > 1) {
// bitwise NOT operator seems to be generally faster than Math.floor() across browsers
const currentIteration = ~~(tickableCurrentTime / (iterationDuration + (isCurrentTimeEqualOrAboveDuration ? 0 : _loopDelay)));
tickable._currentIteration = clamp(currentIteration, 0, iterationCount);
// Prevent the iteration count to go above the max iterations when reaching the end of the animation
if (isCurrentTimeEqualOrAboveDuration) tickable._currentIteration--;
isOdd = tickable._currentIteration % 2;
iterationElapsedTime = tickableCurrentTime % (iterationDuration + _loopDelay) || 0;
}
// Checks if exactly one of _reversed and (_alternate && isOdd) is true
const isReversed = _reversed ^ (_alternate && isOdd);
const _ease = /** @type {Renderable} */(tickable)._ease;
let iterationTime = isCurrentTimeEqualOrAboveDuration ? isReversed ? 0 : duration : isReversed ? iterationDuration - iterationElapsedTime : iterationElapsedTime;
if (_ease) iterationTime = iterationDuration * _ease(iterationTime / iterationDuration) || 0;
const isRunningBackwards = (parent ? parent.backwards : tickableAbsoluteTime < tickablePrevAbsoluteTime) ? !isReversed : !!isReversed;
tickable._currentTime = tickableAbsoluteTime;
tickable._iterationTime = iterationTime;
tickable.backwards = isRunningBackwards;
if (isCurrentTimeAboveZero && !tickable.began) {
tickable.began = true;
if (!muteCallbacks && !(parent && (isRunningBackwards || !parent.began))) {
tickable.onBegin(/** @type {CallbackArgument} */(tickable));
}
} else if (tickableAbsoluteTime <= 0) {
tickable.began = false;
}
// Only triggers onLoop for tickable without children, otherwise call the the onLoop callback in the tick function
// Make sure to trigger the onLoop before rendering to allow .refresh() to pickup the current values
if (!muteCallbacks && !_hasChildren && isCurrentTimeAboveZero && tickable._currentIteration !== _currentIteration) {
tickable.onLoop(/** @type {CallbackArgument} */(tickable));
}
if (
forcedTick ||
tickMode === tickModes.AUTO && (
time >= tickableDelay && time <= tickableEndTime || // Normal render
time <= tickableDelay && tickablePrevTime > tickableDelay || // Playhead is before the animation start time so make sure the animation is at its initial state
time >= tickableEndTime && tickablePrevTime !== duration // Playhead is after the animation end time so make sure the animation is at its end state
) ||
iterationTime >= tickableEndTime && tickablePrevTime !== duration ||
iterationTime <= tickableDelay && tickablePrevTime > 0 ||
time <= tickablePrevTime && tickablePrevTime === duration && completed || // Force a render if a seek occurs on an completed animation
isCurrentTimeEqualOrAboveDuration && !completed && isSetter // This prevents 0 duration tickables to be skipped
) {
if (isCurrentTimeAboveZero) {
// Trigger onUpdate callback before rendering
tickable.computeDeltaTime(tickablePrevTime);
if (!muteCallbacks) tickable.onBeforeUpdate(/** @type {CallbackArgument} */(tickable));
}
// Start tweens rendering
if (!_hasChildren) {
// Time has jumped more than globals.tickThreshold so consider this tick manual
const forcedRender = forcedTick || (isRunningBackwards ? deltaTime * -1 : deltaTime) >= globals.tickThreshold;
const absoluteTime = tickable._offset + (parent ? parent._offset : 0) + tickableDelay + iterationTime;
// Only Animation can have tweens, Timer returns undefined
let tween = /** @type {Tween} */(/** @type {JSAnimation} */(tickable)._head);
let tweenTarget;
let tweenStyle;
let tweenTargetTransforms;
let tweenTargetTransformsProperties;
let tweenTransformsNeedUpdate = 0;
while (tween) {
const tweenComposition = tween._composition;
const tweenCurrentTime = tween._currentTime;
const tweenChangeDuration = tween._changeDuration;
const tweenAbsEndTime = tween._absoluteStartTime + tween._changeDuration;
const tweenNextRep = tween._nextRep;
const tweenPrevRep = tween._prevRep;
const tweenHasComposition = tweenComposition !== compositionTypes.none;
if ((forcedRender || (
(tweenCurrentTime !== tweenChangeDuration || absoluteTime <= tweenAbsEndTime + (tweenNextRep ? tweenNextRep._delay : 0)) &&
(tweenCurrentTime !== 0 || absoluteTime >= tween._absoluteStartTime)
)) && (!tweenHasComposition || (
!tween._isOverridden &&
(!tween._isOverlapped || absoluteTime <= tweenAbsEndTime) &&
(!tweenNextRep || (tweenNextRep._isOverridden || absoluteTime <= tweenNextRep._absoluteStartTime)) &&
(!tweenPrevRep || (tweenPrevRep._isOverridden || (absoluteTime >= (tweenPrevRep._absoluteStartTime + tweenPrevRep._changeDuration) + tween._delay)))
))
) {
const tweenNewTime = tween._currentTime = clamp(iterationTime - tween._startTime, 0, tweenChangeDuration);
const tweenProgress = tween._ease(tweenNewTime / tween._updateDuration);
const tweenModifier = tween._modifier;
const tweenValueType = tween._valueType;
const tweenType = tween._tweenType;
const tweenIsObject = tweenType === tweenTypes.OBJECT;
const tweenIsNumber = tweenValueType === valueTypes.NUMBER;
// Only round the in-between frames values if the final value is a string
const tweenPrecision = (tweenIsNumber && tweenIsObject) || tweenProgress === 0 || tweenProgress === 1 ? -1 : globals.precision;
// Recompose tween value
/** @type {String|Number} */
let value;
/** @type {Number} */
let number;
if (tweenIsNumber) {
value = number = /** @type {Number} */(tweenModifier(round(interpolate(tween._fromNumber, tween._toNumber, tweenProgress), tweenPrecision )));
} else if (tweenValueType === valueTypes.UNIT) {
// Rounding the values speed up string composition
number = /** @type {Number} */(tweenModifier(round(interpolate(tween._fromNumber, tween._toNumber, tweenProgress), tweenPrecision)));
value = `${number}${tween._unit}`;
} else if (tweenValueType === valueTypes.COLOR) {
const fn = tween._fromNumbers;
const tn = tween._toNumbers;
const r = round(clamp(/** @type {Number} */(tweenModifier(interpolate(fn[0], tn[0], tweenProgress))), 0, 255), 0);
const g = round(clamp(/** @type {Number} */(tweenModifier(interpolate(fn[1], tn[1], tweenProgress))), 0, 255), 0);
const b = round(clamp(/** @type {Number} */(tweenModifier(interpolate(fn[2], tn[2], tweenProgress))), 0, 255), 0);
const a = clamp(/** @type {Number} */(tweenModifier(round(interpolate(fn[3], tn[3], tweenProgress), tweenPrecision))), 0, 1);
value = `rgba(${r},${g},${b},${a})`;
if (tweenHasComposition) {
const ns = tween._numbers;
ns[0] = r;
ns[1] = g;
ns[2] = b;
ns[3] = a;
}
} else if (tweenValueType === valueTypes.COMPLEX) {
value = tween._strings[0];
for (let j = 0, l = tween._toNumbers.length; j < l; j++) {
const n = /** @type {Number} */(tweenModifier(round(interpolate(tween._fromNumbers[j], tween._toNumbers[j], tweenProgress), tweenPrecision)));
const s = tween._strings[j + 1];
value += `${s ? n + s : n}`;
if (tweenHasComposition) {
tween._numbers[j] = n;
}
}
}
// For additive tweens and Animatables
if (tweenHasComposition) {
tween._number = number;
}
if (!internalRender && tweenComposition !== compositionTypes.blend) {
const tweenProperty = tween.property;
tweenTarget = tween.target;
if (tweenIsObject) {
tweenTarget[tweenProperty] = value;
} else if (tweenType === tweenTypes.ATTRIBUTE) {
/** @type {DOMTarget} */(tweenTarget).setAttribute(tweenProperty, /** @type {String} */(value));
} else {
tweenStyle = /** @type {DOMTarget} */(tweenTarget).style;
if (tweenType === tweenTypes.TRANSFORM) {
if (tweenTarget !== tweenTargetTransforms) {
tweenTargetTransforms = tweenTarget;
// NOTE: Referencing the cachedTransforms in the tween property directly can be a little bit faster but appears to increase memory usage.
tweenTargetTransformsProperties = tweenTarget[transformsSymbol];
}
tweenTargetTransformsProperties[tweenProperty] = value;
tweenTransformsNeedUpdate = 1;
} else if (tweenType === tweenTypes.CSS) {
tweenStyle[tweenProperty] = value;
} else if (tweenType === tweenTypes.CSS_VAR) {
tweenStyle.setProperty(tweenProperty,/** @type {String} */(value));
}
}
if (isCurrentTimeAboveZero) hasRendered = 1;
} else {
// Used for composing timeline tweens without having to do a real render
tween._value = value;
}
}
// NOTE: Possible improvement: Use translate(x,y) / translate3d(x,y,z) syntax
// to reduce memory usage on string composition
if (tweenTransformsNeedUpdate && tween._renderTransforms) {
let str = emptyString;
for (let key in tweenTargetTransformsProperties) {
str += `${transformsFragmentStrings[key]}${tweenTargetTransformsProperties[key]}) `;
}
tweenStyle.transform = str;
tweenTransformsNeedUpdate = 0;
}
tween = tween._next;
}
if (!muteCallbacks && hasRendered) {
/** @type {JSAnimation} */(tickable).onRender(/** @type {JSAnimation} */(tickable));
}
}
if (!muteCallbacks && isCurrentTimeAboveZero) {
tickable.onUpdate(/** @type {CallbackArgument} */(tickable));
}
}
// End tweens rendering
// Handle setters on timeline differently and allow re-trigering the onComplete callback when seeking backwards
if (parent && isSetter) {
if (!muteCallbacks && (
(parent.began && !isRunningBackwards && tickableAbsoluteTime >= duration && !completed) ||
(isRunningBackwards && tickableAbsoluteTime <= minValue && completed)
)) {
tickable.onComplete(/** @type {CallbackArgument} */(tickable));
tickable.completed = !isRunningBackwards;
}
// If currentTime is both above 0 and at least equals to duration, handles normal onComplete or infinite loops
} else if (isCurrentTimeAboveZero && isCurrentTimeEqualOrAboveDuration) {
if (iterationCount === Infinity) {
// Offset the tickable _startTime with its duration to reset _currentTime to 0 and continue the infinite timer
tickable._startTime += tickable.duration;
} else if (tickable._currentIteration >= iterationCount - 1) {
// By setting paused to true, we tell the engine loop to not render this tickable and removes it from the list on the next tick
tickable.paused = true;
if (!completed && !_hasChildren) {
// If the tickable has children, triggers onComplete() only when all children have completed in the tick function
tickable.completed = true;
if (!muteCallbacks && !(parent && (isRunningBackwards || !parent.began))) {
tickable.onComplete(/** @type {CallbackArgument} */(tickable));
tickable._resolve(/** @type {CallbackArgument} */(tickable));
}
}
}
// Otherwise set the completed flag to false
} else {
tickable.completed = false;
}
// NOTE: hasRendered * direction (negative for backwards) this way we can remove the tickable.backwards property completly ?
return hasRendered;
}
|
@param {Tickable} tickable
@param {Number} time
@param {Number} muteCallbacks
@param {Number} internalRender
@param {tickModes} tickMode
@return {Number}
|
render
|
javascript
|
juliangarnier/anime
|
lib/anime.esm.js
|
https://github.com/juliangarnier/anime/blob/master/lib/anime.esm.js
|
MIT
|
tick = (tickable, time, muteCallbacks, internalRender, tickMode) => {
const _currentIteration = tickable._currentIteration;
render(tickable, time, muteCallbacks, internalRender, tickMode);
if (tickable._hasChildren) {
const tl = /** @type {Timeline} */(tickable);
const tlIsRunningBackwards = tl.backwards;
const tlChildrenTime = internalRender ? time : tl._iterationTime;
const tlCildrenTickTime = now();
let tlChildrenHasRendered = 0;
let tlChildrenHaveCompleted = true;
// If the timeline has looped forward, we need to manually triggers children skipped callbacks
if (!internalRender && tl._currentIteration !== _currentIteration) {
const tlIterationDuration = tl.iterationDuration;
forEachChildren(tl, (/** @type {JSAnimation} */child) => {
if (!tlIsRunningBackwards) {
// Force an internal render to trigger the callbacks if the child has not completed on loop
if (!child.completed && !child.backwards && child._currentTime < child.iterationDuration) {
render(child, tlIterationDuration, muteCallbacks, 1, tickModes.FORCE);
}
// Reset their began and completed flags to allow retrigering callbacks on the next iteration
child.began = false;
child.completed = false;
} else {
const childDuration = child.duration;
const childStartTime = child._offset + child._delay;
const childEndTime = childStartTime + childDuration;
// Triggers the onComplete callback on reverse for children on the edges of the timeline
if (!muteCallbacks && childDuration <= minValue && (!childStartTime || childEndTime === tlIterationDuration)) {
child.onComplete(child);
}
}
});
if (!muteCallbacks) tl.onLoop(/** @type {CallbackArgument} */(tl));
}
forEachChildren(tl, (/** @type {JSAnimation} */child) => {
const childTime = round((tlChildrenTime - child._offset) * child._speed, 12); // Rounding is needed when using seconds
const childTickMode = child._fps < tl._fps ? child.requestTick(tlCildrenTickTime) : tickMode;
tlChildrenHasRendered += render(child, childTime, muteCallbacks, internalRender, childTickMode);
if (!child.completed && tlChildrenHaveCompleted) tlChildrenHaveCompleted = false;
}, tlIsRunningBackwards);
// Renders on timeline are triggered by its children so it needs to be set after rendering the children
if (!muteCallbacks && tlChildrenHasRendered) tl.onRender(/** @type {CallbackArgument} */(tl));
// Triggers the timeline onComplete() once all chindren all completed and the current time has reached the end
if (tlChildrenHaveCompleted && tl._currentTime >= tl.duration) {
// Make sure the paused flag is false in case it has been skipped in the render function
tl.paused = true;
if (!tl.completed) {
tl.completed = true;
if (!muteCallbacks) {
tl.onComplete(/** @type {CallbackArgument} */(tl));
tl._resolve(/** @type {CallbackArgument} */(tl));
}
}
}
}
}
|
@param {Tickable} tickable
@param {Number} time
@param {Number} muteCallbacks
@param {Number} internalRender
@param {Number} tickMode
@return {void}
|
tick
|
javascript
|
juliangarnier/anime
|
lib/anime.esm.js
|
https://github.com/juliangarnier/anime/blob/master/lib/anime.esm.js
|
MIT
|
parseInlineTransforms = (target, propName, animationInlineStyles) => {
const inlineTransforms = target.style.transform;
let inlinedStylesPropertyValue;
if (inlineTransforms) {
const cachedTransforms = target[transformsSymbol];
let t; while (t = transformsExecRgx.exec(inlineTransforms)) {
const inlinePropertyName = t[1];
// const inlinePropertyValue = t[2];
const inlinePropertyValue = t[2].slice(1, -1);
cachedTransforms[inlinePropertyName] = inlinePropertyValue;
if (inlinePropertyName === propName) {
inlinedStylesPropertyValue = inlinePropertyValue;
// Store the new parsed inline styles if animationInlineStyles is provided
if (animationInlineStyles) {
animationInlineStyles[propName] = inlinePropertyValue;
}
}
}
}
return inlineTransforms && !isUnd(inlinedStylesPropertyValue) ? inlinedStylesPropertyValue :
stringStartsWith(propName, 'scale') ? '1' :
stringStartsWith(propName, 'rotate') || stringStartsWith(propName, 'skew') ? '0deg' : '0px';
}
|
@param {DOMTarget} target
@param {String} propName
@param {Object} animationInlineStyles
@return {String}
|
parseInlineTransforms
|
javascript
|
juliangarnier/anime
|
lib/anime.esm.js
|
https://github.com/juliangarnier/anime/blob/master/lib/anime.esm.js
|
MIT
|
function getNodeList(v) {
const n = isStr(v) ? globals.root.querySelectorAll(v) : v;
if (n instanceof NodeList || n instanceof HTMLCollection) return n;
}
|
@param {DOMTargetsParam|TargetsParam} v
@return {NodeList|HTMLCollection}
|
getNodeList
|
javascript
|
juliangarnier/anime
|
lib/anime.esm.js
|
https://github.com/juliangarnier/anime/blob/master/lib/anime.esm.js
|
MIT
|
function parseTargets(targets) {
if (isNil(targets)) return /** @type {TargetsArray} */([]);
if (isArr(targets)) {
const flattened = targets.flat(Infinity);
/** @type {TargetsArray} */
const parsed = [];
for (let i = 0, l = flattened.length; i < l; i++) {
const item = flattened[i];
if (!isNil(item)) {
const nodeList = getNodeList(item);
if (nodeList) {
for (let j = 0, jl = nodeList.length; j < jl; j++) {
const subItem = nodeList[j];
if (!isNil(subItem)) {
let isDuplicate = false;
for (let k = 0, kl = parsed.length; k < kl; k++) {
if (parsed[k] === subItem) {
isDuplicate = true;
break;
}
}
if (!isDuplicate) {
parsed.push(subItem);
}
}
}
} else {
let isDuplicate = false;
for (let j = 0, jl = parsed.length; j < jl; j++) {
if (parsed[j] === item) {
isDuplicate = true;
break;
}
}
if (!isDuplicate) {
parsed.push(item);
}
}
}
}
return parsed;
}
if (!isBrowser) return /** @type {JSTargetsArray} */([targets]);
const nodeList = getNodeList(targets);
if (nodeList) return /** @type {DOMTargetsArray} */(Array.from(nodeList));
return /** @type {TargetsArray} */([targets]);
}
|
@overload
@param {DOMTargetsParam} targets
@return {DOMTargetsArray}
@overload
@param {JSTargetsParam} targets
@return {JSTargetsArray}
@overload
@param {TargetsParam} targets
@return {TargetsArray}
@param {DOMTargetsParam|JSTargetsParam|TargetsParam} targets
|
parseTargets
|
javascript
|
juliangarnier/anime
|
lib/anime.esm.js
|
https://github.com/juliangarnier/anime/blob/master/lib/anime.esm.js
|
MIT
|
getPath = path => {
const parsedTargets = parseTargets(path);
const $parsedSvg = /** @type {SVGGeometryElement} */(parsedTargets[0]);
if (!$parsedSvg || !isSvg($parsedSvg)) return;
return $parsedSvg;
}
|
@param {TargetsParam} path
@return {SVGGeometryElement|undefined}
|
getPath
|
javascript
|
juliangarnier/anime
|
lib/anime.esm.js
|
https://github.com/juliangarnier/anime/blob/master/lib/anime.esm.js
|
MIT
|
morphTo = (path2, precision = .33) => ($path1) => {
const $path2 = /** @type {SVGGeometryElement} */(getPath(path2));
if (!$path2) return;
const isPath = $path1.tagName === 'path';
const separator = isPath ? ' ' : ',';
const previousPoints = $path1[morphPointsSymbol];
if (previousPoints) $path1.setAttribute(isPath ? 'd' : 'points', previousPoints);
let v1 = '', v2 = '';
if (!precision) {
v1 = $path1.getAttribute(isPath ? 'd' : 'points');
v2 = $path2.getAttribute(isPath ? 'd' : 'points');
} else {
const length1 = /** @type {SVGGeometryElement} */($path1).getTotalLength();
const length2 = $path2.getTotalLength();
const maxPoints = Math.max(Math.ceil(length1 * precision), Math.ceil(length2 * precision));
for (let i = 0; i < maxPoints; i++) {
const t = i / (maxPoints - 1);
const pointOnPath1 = /** @type {SVGGeometryElement} */($path1).getPointAtLength(length1 * t);
const pointOnPath2 = $path2.getPointAtLength(length2 * t);
const prefix = isPath ? (i === 0 ? 'M' : 'L') : '';
v1 += prefix + round(pointOnPath1.x, 3) + separator + pointOnPath1.y + ' ';
v2 += prefix + round(pointOnPath2.x, 3) + separator + pointOnPath2.y + ' ';
}
}
$path1[morphPointsSymbol] = v2;
return [v1, v2];
}
|
@param {TargetsParam} path2
@param {Number} [precision]
@return {FunctionValue}
|
morphTo
|
javascript
|
juliangarnier/anime
|
lib/anime.esm.js
|
https://github.com/juliangarnier/anime/blob/master/lib/anime.esm.js
|
MIT
|
createDrawableProxy = ($el, start, end) => {
const pathLength = K;
const computedStyles = getComputedStyle($el);
const strokeLineCap = computedStyles.strokeLinecap;
// @ts-ignore
const $scalled = computedStyles.vectorEffect === 'non-scaling-stroke' ? $el : null;
let currentCap = strokeLineCap;
const proxy = new Proxy($el, {
get(target, property) {
const value = target[property];
if (property === proxyTargetSymbol) return target;
if (property === 'setAttribute') {
return (...args) => {
if (args[0] === 'draw') {
const value = args[1];
const values = value.split(' ');
const v1 = +values[0];
const v2 = +values[1];
// TOTO: Benchmark if performing two slices is more performant than one split
// const spaceIndex = value.indexOf(' ');
// const v1 = round(+value.slice(0, spaceIndex), precision);
// const v2 = round(+value.slice(spaceIndex + 1), precision);
const scaleFactor = getScaleFactor($scalled);
const os = v1 * -1e3 * scaleFactor;
const d1 = (v2 * pathLength * scaleFactor) + os;
const d2 = (pathLength * scaleFactor +
((v1 === 0 && v2 === 1) || (v1 === 1 && v2 === 0) ? 0 : 10 * scaleFactor) - d1);
if (strokeLineCap !== 'butt') {
const newCap = v1 === v2 ? 'butt' : strokeLineCap;
if (currentCap !== newCap) {
target.style.strokeLinecap = `${newCap}`;
currentCap = newCap;
}
}
target.setAttribute('stroke-dashoffset', `${os}`);
target.setAttribute('stroke-dasharray', `${d1} ${d2}`);
}
return Reflect.apply(value, target, args);
};
}
if (isFnc(value)) {
return (...args) => Reflect.apply(value, target, args);
} else {
return value;
}
}
});
if ($el.getAttribute('pathLength') !== `${pathLength}`) {
$el.setAttribute('pathLength', `${pathLength}`);
proxy.setAttribute('draw', `${start} ${end}`);
}
return /** @type {DrawableSVGGeometry} */(proxy);
}
|
Creates a proxy that wraps an SVGGeometryElement and adds drawing functionality.
@param {SVGGeometryElement} $el - The SVG element to transform into a drawable
@param {number} start - Starting position (0-1)
@param {number} end - Ending position (0-1)
@return {DrawableSVGGeometry} - Returns a proxy that preserves the original element's type with additional 'draw' attribute functionality
|
createDrawableProxy
|
javascript
|
juliangarnier/anime
|
lib/anime.esm.js
|
https://github.com/juliangarnier/anime/blob/master/lib/anime.esm.js
|
MIT
|
createDrawable = (selector, start = 0, end = 0) => {
const els = parseTargets(selector);
return els.map($el => createDrawableProxy(
/** @type {SVGGeometryElement} */($el),
start,
end
));
}
|
Creates drawable proxies for multiple SVG elements.
@param {TargetsParam} selector - CSS selector, SVG element, or array of elements and selectors
@param {number} [start=0] - Starting position (0-1)
@param {number} [end=0] - Ending position (0-1)
@return {Array<DrawableSVGGeometry>} - Array of proxied elements with drawing functionality
|
createDrawable
|
javascript
|
juliangarnier/anime
|
lib/anime.esm.js
|
https://github.com/juliangarnier/anime/blob/master/lib/anime.esm.js
|
MIT
|
getPathPoint = ($path, progress, lookup = 0) => {
return $path.getPointAtLength(progress + lookup >= 1 ? progress + lookup : 0);
}
|
@param {SVGGeometryElement} $path
@param {Number} progress
@param {Number}lookup
@return {DOMPoint}
|
getPathPoint
|
javascript
|
juliangarnier/anime
|
lib/anime.esm.js
|
https://github.com/juliangarnier/anime/blob/master/lib/anime.esm.js
|
MIT
|
getPathProgess = ($path, pathProperty) => {
return $el => {
const totalLength = +($path.getTotalLength());
const inSvg = $el[isSvgSymbol];
const ctm = $path.getCTM();
/** @type {TweenObjectValue} */
return {
from: 0,
to: totalLength,
/** @type {TweenModifier} */
modifier: progress => {
if (pathProperty === 'a') {
const p0 = getPathPoint($path, progress, -1);
const p1 = getPathPoint($path, progress, 1);
return atan2(p1.y - p0.y, p1.x - p0.x) * 180 / PI;
} else {
const p = getPathPoint($path, progress, 0);
return pathProperty === 'x' ?
inSvg || !ctm ? p.x : p.x * ctm.a + p.y * ctm.c + ctm.e :
inSvg || !ctm ? p.y : p.x * ctm.b + p.y * ctm.d + ctm.f
}
}
}
}
}
|
@param {SVGGeometryElement} $path
@param {String} pathProperty
@return {FunctionValue}
|
getPathProgess
|
javascript
|
juliangarnier/anime
|
lib/anime.esm.js
|
https://github.com/juliangarnier/anime/blob/master/lib/anime.esm.js
|
MIT
|
isValidSVGAttribute = (el, propertyName) => {
// Return early and use CSS opacity animation instead (already better default values (opacity: 1 instead of 0)) and rotate should be considered a transform
if (cssReservedProperties.includes(propertyName)) return false;
if (el.getAttribute(propertyName) || propertyName in el) {
if (propertyName === 'scale') { // Scale
const elParentNode = /** @type {SVGGeometryElement} */(/** @type {DOMTarget} */(el).parentNode);
// Only consider scale as a valid SVG attribute on filter element
return elParentNode && elParentNode.tagName === 'filter';
}
return true;
}
}
|
@param {Target} el
@param {String} propertyName
@return {Boolean}
|
isValidSVGAttribute
|
javascript
|
juliangarnier/anime
|
lib/anime.esm.js
|
https://github.com/juliangarnier/anime/blob/master/lib/anime.esm.js
|
MIT
|
rgbToRgba = rgbValue => {
const rgba = rgbExecRgx.exec(rgbValue) || rgbaExecRgx.exec(rgbValue);
const a = !isUnd(rgba[4]) ? +rgba[4] : 1;
return [
+rgba[1],
+rgba[2],
+rgba[3],
a
]
}
|
RGB / RGBA Color value string -> RGBA values array
@param {String} rgbValue
@return {ColorArray}
|
rgbToRgba
|
javascript
|
juliangarnier/anime
|
lib/anime.esm.js
|
https://github.com/juliangarnier/anime/blob/master/lib/anime.esm.js
|
MIT
|
hexToRgba = hexValue => {
const hexLength = hexValue.length;
const isShort = hexLength === 4 || hexLength === 5;
return [
+('0x' + hexValue[1] + hexValue[isShort ? 1 : 2]),
+('0x' + hexValue[isShort ? 2 : 3] + hexValue[isShort ? 2 : 4]),
+('0x' + hexValue[isShort ? 3 : 5] + hexValue[isShort ? 3 : 6]),
((hexLength === 5 || hexLength === 9) ? +(+('0x' + hexValue[isShort ? 4 : 7] + hexValue[isShort ? 4 : 8]) / 255).toFixed(3) : 1)
]
}
|
HEX3 / HEX3A / HEX6 / HEX6A Color value string -> RGBA values array
@param {String} hexValue
@return {ColorArray}
|
hexToRgba
|
javascript
|
juliangarnier/anime
|
lib/anime.esm.js
|
https://github.com/juliangarnier/anime/blob/master/lib/anime.esm.js
|
MIT
|
hue2rgb = (p, q, t) => {
if (t < 0) t += 1;
if (t > 1) t -= 1;
return t < 1 / 6 ? p + (q - p) * 6 * t :
t < 1 / 2 ? q :
t < 2 / 3 ? p + (q - p) * (2 / 3 - t) * 6 :
p;
}
|
@param {Number} p
@param {Number} q
@param {Number} t
@return {Number}
|
hue2rgb
|
javascript
|
juliangarnier/anime
|
lib/anime.esm.js
|
https://github.com/juliangarnier/anime/blob/master/lib/anime.esm.js
|
MIT
|
hslToRgba = hslValue => {
const hsla = hslExecRgx.exec(hslValue) || hslaExecRgx.exec(hslValue);
const h = +hsla[1] / 360;
const s = +hsla[2] / 100;
const l = +hsla[3] / 100;
const a = !isUnd(hsla[4]) ? +hsla[4] : 1;
let r, g, b;
if (s === 0) {
r = g = b = l;
} else {
const q = l < .5 ? l * (1 + s) : l + s - l * s;
const p = 2 * l - q;
r = round(hue2rgb(p, q, h + 1 / 3) * 255, 0);
g = round(hue2rgb(p, q, h) * 255, 0);
b = round(hue2rgb(p, q, h - 1 / 3) * 255, 0);
}
return [r, g, b, a];
}
|
HSL / HSLA Color value string -> RGBA values array
@param {String} hslValue
@return {ColorArray}
|
hslToRgba
|
javascript
|
juliangarnier/anime
|
lib/anime.esm.js
|
https://github.com/juliangarnier/anime/blob/master/lib/anime.esm.js
|
MIT
|
convertColorStringValuesToRgbaArray = colorString => {
return isRgb(colorString) ? rgbToRgba(colorString) :
isHex(colorString) ? hexToRgba(colorString) :
isHsl(colorString) ? hslToRgba(colorString) :
[0, 0, 0, 1];
}
|
All in one color converter that converts a color string value into an array of RGBA values
@param {String} colorString
@return {ColorArray}
|
convertColorStringValuesToRgbaArray
|
javascript
|
juliangarnier/anime
|
lib/anime.esm.js
|
https://github.com/juliangarnier/anime/blob/master/lib/anime.esm.js
|
MIT
|
setValue = (targetValue, defaultValue) => {
return isUnd(targetValue) ? defaultValue : targetValue;
}
|
@template T, D
@param {T|undefined} targetValue
@param {D} defaultValue
@return {T|D}
|
setValue
|
javascript
|
juliangarnier/anime
|
lib/anime.esm.js
|
https://github.com/juliangarnier/anime/blob/master/lib/anime.esm.js
|
MIT
|
getFunctionValue = (value, target, index, total, store) => {
if (isFnc(value)) {
const func = () => {
const computed = /** @type {Function} */(value)(target, index, total);
// Fallback to 0 if the function returns undefined / NaN / null / false / 0
return !isNaN(+computed) ? +computed : computed || 0;
};
if (store) {
store.func = func;
}
return func();
} else {
return value;
}
}
|
@param {TweenPropValue} value
@param {Target} target
@param {Number} index
@param {Number} total
@param {Object} [store]
@return {any}
|
getFunctionValue
|
javascript
|
juliangarnier/anime
|
lib/anime.esm.js
|
https://github.com/juliangarnier/anime/blob/master/lib/anime.esm.js
|
MIT
|
getTweenType = (target, prop) => {
return !target[isDomSymbol] ? tweenTypes.OBJECT :
// Handle SVG attributes
target[isSvgSymbol] && isValidSVGAttribute(target, prop) ? tweenTypes.ATTRIBUTE :
// Handle CSS Transform properties differently than CSS to allow individual animations
validTransforms.includes(prop) || shortTransforms.get(prop) ? tweenTypes.TRANSFORM :
// CSS variables
stringStartsWith(prop, '--') ? tweenTypes.CSS_VAR :
// All other CSS properties
prop in /** @type {DOMTarget} */(target).style ? tweenTypes.CSS :
// Handle other DOM Attributes
prop in target ? tweenTypes.OBJECT :
tweenTypes.ATTRIBUTE;
}
|
@param {Target} target
@param {String} prop
@return {tweenTypes}
|
getTweenType
|
javascript
|
juliangarnier/anime
|
lib/anime.esm.js
|
https://github.com/juliangarnier/anime/blob/master/lib/anime.esm.js
|
MIT
|
getOriginalAnimatableValue = (target, propName, tweenType, animationInlineStyles) => {
const type = !isUnd(tweenType) ? tweenType : getTweenType(target, propName);
return type === tweenTypes.OBJECT ? target[propName] || 0 :
type === tweenTypes.ATTRIBUTE ? /** @type {DOMTarget} */(target).getAttribute(propName) :
type === tweenTypes.TRANSFORM ? parseInlineTransforms(/** @type {DOMTarget} */(target), propName, animationInlineStyles) :
type === tweenTypes.CSS_VAR ? getCSSValue(/** @type {DOMTarget} */(target), propName, animationInlineStyles).trimStart() :
getCSSValue(/** @type {DOMTarget} */(target), propName, animationInlineStyles);
}
|
@param {Target} target
@param {String} propName
@param {tweenTypes} [tweenType]
@param {Object|void} [animationInlineStyles]
@return {String|Number}
|
getOriginalAnimatableValue
|
javascript
|
juliangarnier/anime
|
lib/anime.esm.js
|
https://github.com/juliangarnier/anime/blob/master/lib/anime.esm.js
|
MIT
|
getRelativeValue = (x, y, operator) => {
return operator === '-' ? x - y :
operator === '+' ? x + y :
x * y;
}
|
@param {Number} x
@param {Number} y
@param {String} operator
@return {Number}
|
getRelativeValue
|
javascript
|
juliangarnier/anime
|
lib/anime.esm.js
|
https://github.com/juliangarnier/anime/blob/master/lib/anime.esm.js
|
MIT
|
decomposeRawValue = (rawValue, targetObject) => {
/** @type {valueTypes} */
targetObject.t = valueTypes.NUMBER;
targetObject.n = 0;
targetObject.u = null;
targetObject.o = null;
targetObject.d = null;
targetObject.s = null;
if (!rawValue) return targetObject;
const num = +rawValue;
if (!isNaN(num)) {
// It's a number
targetObject.n = num;
return targetObject;
} else {
// let str = /** @type {String} */(rawValue).trim();
let str = /** @type {String} */(rawValue);
// Parsing operators (+=, -=, *=) manually is much faster than using regex here
if (str[1] === '=') {
targetObject.o = str[0];
str = str.slice(2);
}
// Skip exec regex if the value type is complex or color to avoid long regex backtracking
const unitMatch = str.includes(' ') ? false : unitsExecRgx.exec(str);
if (unitMatch) {
// Has a number and a unit
targetObject.t = valueTypes.UNIT;
targetObject.n = +unitMatch[1];
targetObject.u = unitMatch[2];
return targetObject;
} else if (targetObject.o) {
// Has an operator (+=, -=, *=)
targetObject.n = +str;
return targetObject;
} else if (isCol(str)) {
// Is a color
targetObject.t = valueTypes.COLOR;
targetObject.d = convertColorStringValuesToRgbaArray(str);
return targetObject;
} else {
// Is a more complex string (generally svg coords, calc() or filters CSS values)
const matchedNumbers = str.match(digitWithExponentRgx);
targetObject.t = valueTypes.COMPLEX;
targetObject.d = matchedNumbers ? matchedNumbers.map(Number) : [];
targetObject.s = str.split(digitWithExponentRgx) || [];
return targetObject;
}
}
}
|
@param {String|Number} rawValue
@param {TweenDecomposedValue} targetObject
@return {TweenDecomposedValue}
|
decomposeRawValue
|
javascript
|
juliangarnier/anime
|
lib/anime.esm.js
|
https://github.com/juliangarnier/anime/blob/master/lib/anime.esm.js
|
MIT
|
decomposeTweenValue = (tween, targetObject) => {
targetObject.t = tween._valueType;
targetObject.n = tween._toNumber;
targetObject.u = tween._unit;
targetObject.o = null;
targetObject.d = cloneArray(tween._toNumbers);
targetObject.s = cloneArray(tween._strings);
return targetObject;
}
|
@param {Tween} tween
@param {TweenDecomposedValue} targetObject
@return {TweenDecomposedValue}
|
decomposeTweenValue
|
javascript
|
juliangarnier/anime
|
lib/anime.esm.js
|
https://github.com/juliangarnier/anime/blob/master/lib/anime.esm.js
|
MIT
|
getTweenSiblings = (target, property, lookup = '_rep') => {
const lookupMap = lookups[lookup];
let targetLookup = lookupMap.get(target);
if (!targetLookup) {
targetLookup = {};
lookupMap.set(target, targetLookup);
}
return targetLookup[property] ? targetLookup[property] : targetLookup[property] = {
_head: null,
_tail: null,
}
}
|
@param {Target} target
@param {String} property
@param {String} lookup
@return {TweenPropertySiblings}
|
getTweenSiblings
|
javascript
|
juliangarnier/anime
|
lib/anime.esm.js
|
https://github.com/juliangarnier/anime/blob/master/lib/anime.esm.js
|
MIT
|
addTweenSortMethod = (p, c) => {
return p._isOverridden || p._absoluteStartTime > c._absoluteStartTime;
}
|
@param {Tween} p
@param {Tween} c
@return {Number|Boolean}
|
addTweenSortMethod
|
javascript
|
juliangarnier/anime
|
lib/anime.esm.js
|
https://github.com/juliangarnier/anime/blob/master/lib/anime.esm.js
|
MIT
|
composeTween = (tween, siblings) => {
const tweenCompositionType = tween._composition;
// Handle replaced tweens
if (tweenCompositionType === compositionTypes.replace) {
const tweenAbsStartTime = tween._absoluteStartTime;
addChild(siblings, tween, addTweenSortMethod, '_prevRep', '_nextRep');
const prevSibling = tween._prevRep;
// Update the previous siblings for composition replace tweens
if (prevSibling) {
const prevParent = prevSibling.parent;
const prevAbsEndTime = prevSibling._absoluteStartTime + prevSibling._changeDuration;
// Handle looped animations tween
if (
// Check if the previous tween is from a different animation
tween.parent.id !== prevParent.id &&
// Check if the animation has loops
prevParent.iterationCount> 1 &&
// Check if _absoluteChangeEndTime of last loop overlaps the current tween
prevAbsEndTime + (prevParent.duration - prevParent.iterationDuration) > tweenAbsStartTime
) {
// TODO: Find a way to only override the iterations overlapping with the tween
overrideTween(prevSibling);
let prevPrevSibling = prevSibling._prevRep;
// If the tween was part of a set of keyframes, override its siblings
while (prevPrevSibling && prevPrevSibling.parent.id === prevParent.id) {
overrideTween(prevPrevSibling);
prevPrevSibling = prevPrevSibling._prevRep;
}
}
const absoluteUpdateStartTime = tweenAbsStartTime - tween._delay;
if (prevAbsEndTime > absoluteUpdateStartTime) {
const prevChangeStartTime = prevSibling._startTime;
const prevTLOffset = prevAbsEndTime - (prevChangeStartTime + prevSibling._updateDuration);
prevSibling._changeDuration = absoluteUpdateStartTime - prevTLOffset - prevChangeStartTime;
prevSibling._currentTime = prevSibling._changeDuration;
prevSibling._isOverlapped = 1;
if (prevSibling._changeDuration < minValue) {
overrideTween(prevSibling);
}
}
// Pause (and cancel) the parent if it only contains overlapped tweens
let pausePrevParentAnimation = true;
forEachChildren(prevParent, (/** @type Tween */t) => {
if (!t._isOverlapped) pausePrevParentAnimation = false;
});
if (pausePrevParentAnimation) {
const prevParentTL = prevParent.parent;
if (prevParentTL) {
let pausePrevParentTL = true;
forEachChildren(prevParentTL, (/** @type JSAnimation */a) => {
if (a !== prevParent) {
forEachChildren(a, (/** @type Tween */t) => {
if (!t._isOverlapped) pausePrevParentTL = false;
});
}
});
if (pausePrevParentTL) {
prevParentTL.cancel();
}
} else {
prevParent.cancel();
// Previously, calling .cancel() on a timeline child would affect the render order of other children
// Worked around this by marking it as .completed and using .pause() for safe removal in the engine loop
// This is no longer needed since timeline tween composition is now handled separatly
// Keeping this here for reference
// prevParent.completed = true;
// prevParent.pause();
}
}
}
// let nextSibling = tween._nextRep;
// // All the next siblings are automatically overridden
// if (nextSibling && nextSibling._absoluteStartTime >= tweenAbsStartTime) {
// while (nextSibling) {
// overrideTween(nextSibling);
// nextSibling = nextSibling._nextRep;
// }
// }
// if (nextSibling && nextSibling._absoluteStartTime < tweenAbsStartTime) {
// while (nextSibling) {
// overrideTween(nextSibling);
// console.log(tween.id, nextSibling.id);
// nextSibling = nextSibling._nextRep;
// }
// }
// Handle additive tweens composition
} else if (tweenCompositionType === compositionTypes.blend) {
const additiveTweenSiblings = getTweenSiblings(tween.target, tween.property, '_add');
const additiveAnimation = addAdditiveAnimation(lookups._add);
let lookupTween = additiveTweenSiblings._head;
if (!lookupTween) {
lookupTween = { ...tween };
lookupTween._composition = compositionTypes.replace;
lookupTween._updateDuration = minValue;
lookupTween._startTime = 0;
lookupTween._numbers = cloneArray(tween._fromNumbers);
lookupTween._number = 0;
lookupTween._next = null;
lookupTween._prev = null;
addChild(additiveTweenSiblings, lookupTween);
addChild(additiveAnimation, lookupTween);
}
// Convert the values of TO to FROM and set TO to 0
const toNumber = tween._toNumber;
tween._fromNumber = lookupTween._fromNumber - toNumber;
tween._toNumber = 0;
tween._numbers = cloneArray(tween._fromNumbers);
tween._number = 0;
lookupTween._fromNumber = toNumber;
if (tween._toNumbers) {
const toNumbers = cloneArray(tween._toNumbers);
if (toNumbers) {
toNumbers.forEach((value, i) => {
tween._fromNumbers[i] = lookupTween._fromNumbers[i] - value;
tween._toNumbers[i] = 0;
});
}
lookupTween._fromNumbers = toNumbers;
}
addChild(additiveTweenSiblings, tween, null, '_prevAdd', '_nextAdd');
}
return tween;
}
|
@param {Tween} tween
@param {TweenPropertySiblings} siblings
@return {Tween}
|
composeTween
|
javascript
|
juliangarnier/anime
|
lib/anime.esm.js
|
https://github.com/juliangarnier/anime/blob/master/lib/anime.esm.js
|
MIT
|
constructor(parameters = {}, parent = null, parentPosition = 0) {
super(0);
const {
id,
delay,
duration,
reversed,
alternate,
loop,
loopDelay,
autoplay,
frameRate,
playbackRate,
onComplete,
onLoop,
onPause,
onBegin,
onBeforeUpdate,
onUpdate,
} = parameters;
if (globals.scope) globals.scope.revertibles.push(this);
const timerInitTime = parent ? 0 : engine._elapsedTime;
const timerDefaults = parent ? parent.defaults : globals.defaults;
const timerDelay = /** @type {Number} */(isFnc(delay) || isUnd(delay) ? timerDefaults.delay : +delay);
const timerDuration = isFnc(duration) || isUnd(duration) ? Infinity : +duration;
const timerLoop = setValue(loop, timerDefaults.loop);
const timerLoopDelay = setValue(loopDelay, timerDefaults.loopDelay);
const timerIterationCount = timerLoop === true ||
timerLoop === Infinity ||
/** @type {Number} */(timerLoop) < 0 ? Infinity :
/** @type {Number} */(timerLoop) + 1;
let offsetPosition = 0;
if (parent) {
offsetPosition = parentPosition;
} else {
let startTime = now();
// Make sure to tick the engine once if suspended to avoid big gaps with the following offsetPosition calculation
if (engine.paused) {
engine.requestTick(startTime);
startTime = engine._elapsedTime;
}
offsetPosition = startTime - engine._startTime;
}
// Timer's parameters
this.id = !isUnd(id) ? id : ++timerId;
/** @type {Timeline} */
this.parent = parent;
// Total duration of the timer
this.duration = clampInfinity(((timerDuration + timerLoopDelay) * timerIterationCount) - timerLoopDelay) || minValue;
/** @type {Boolean} */
this.backwards = false;
/** @type {Boolean} */
this.paused = true;
/** @type {Boolean} */
this.began = false;
/** @type {Boolean} */
this.completed = false;
/** @type {Callback<this>} */
this.onBegin = onBegin || timerDefaults.onBegin;
/** @type {Callback<this>} */
this.onBeforeUpdate = onBeforeUpdate || timerDefaults.onBeforeUpdate;
/** @type {Callback<this>} */
this.onUpdate = onUpdate || timerDefaults.onUpdate;
/** @type {Callback<this>} */
this.onLoop = onLoop || timerDefaults.onLoop;
/** @type {Callback<this>} */
this.onPause = onPause || timerDefaults.onPause;
/** @type {Callback<this>} */
this.onComplete = onComplete || timerDefaults.onComplete;
/** @type {Number} */
this.iterationDuration = timerDuration; // Duration of one loop
/** @type {Number} */
this.iterationCount = timerIterationCount; // Number of loops
/** @type {Boolean|ScrollObserver} */
this._autoplay = parent ? false : setValue(autoplay, timerDefaults.autoplay);
/** @type {Number} */
this._offset = offsetPosition;
/** @type {Number} */
this._delay = timerDelay;
/** @type {Number} */
this._loopDelay = timerLoopDelay;
/** @type {Number} */
this._iterationTime = 0;
/** @type {Number} */
this._currentIteration = 0; // Current loop index
/** @type {Function} */
this._resolve = noop; // Used by .then()
/** @type {Boolean} */
this._running = false;
/** @type {Number} */
this._reversed = +setValue(reversed, timerDefaults.reversed);
/** @type {Number} */
this._reverse = this._reversed;
/** @type {Number} */
this._cancelled = 0;
/** @type {Boolean} */
this._alternate = setValue(alternate, timerDefaults.alternate);
/** @type {Renderable} */
this._prev = null;
/** @type {Renderable} */
this._next = null;
// Clock's parameters
/** @type {Number} */
this._elapsedTime = timerInitTime;
/** @type {Number} */
this._startTime = timerInitTime;
/** @type {Number} */
this._lastTime = timerInitTime;
/** @type {Number} */
this._fps = setValue(frameRate, timerDefaults.frameRate);
/** @type {Number} */
this._speed = setValue(playbackRate, timerDefaults.playbackRate);
}
|
@param {TimerParams} [parameters]
@param {Timeline} [parent]
@param {Number} [parentPosition]
|
constructor
|
javascript
|
juliangarnier/anime
|
lib/anime.esm.js
|
https://github.com/juliangarnier/anime/blob/master/lib/anime.esm.js
|
MIT
|
seek(time, muteCallbacks = 0, internalRender = 0) {
// Recompose the tween siblings in case the timer has been cancelled
reviveTimer(this);
// If you seek a completed animation, otherwise the next play will starts at 0
this.completed = false;
const isPaused = this.paused;
this.paused = true;
// timer, time, muteCallbacks, internalRender, tickMode
tick(this, time + this._delay, ~~muteCallbacks, ~~internalRender, tickModes.AUTO);
return isPaused ? this : this.resume();
}
|
@param {Number} time
@param {Boolean|Number} [muteCallbacks]
@param {Boolean|Number} [internalRender]
@return {this}
|
seek
|
javascript
|
juliangarnier/anime
|
lib/anime.esm.js
|
https://github.com/juliangarnier/anime/blob/master/lib/anime.esm.js
|
MIT
|
revert() {
tick(this, 0, 1, 0, tickModes.AUTO);
const ap = /** @type {ScrollObserver} */(this._autoplay);
if (ap && ap.linked && ap.linked === this) ap.revert();
return this.cancel();
}
|
Cancels the timer by seeking it back to 0 and reverting the attached scroller if necessary
@return {this}
|
revert
|
javascript
|
juliangarnier/anime
|
lib/anime.esm.js
|
https://github.com/juliangarnier/anime/blob/master/lib/anime.esm.js
|
MIT
|
complete() {
return this.seek(this.duration).cancel();
}
|
Imediatly completes the timer, cancels it and triggers the onComplete callback
@return {this}
|
complete
|
javascript
|
juliangarnier/anime
|
lib/anime.esm.js
|
https://github.com/juliangarnier/anime/blob/master/lib/anime.esm.js
|
MIT
|
then(callback = noop) {
const then = this.then;
const onResolve = () => {
// this.then = null prevents infinite recursion if returned by an async function
// https://github.com/juliangarnierorg/anime-beta/issues/26
this.then = null;
callback(this);
this.then = then;
this._resolve = noop;
};
return new Promise(r => {
this._resolve = () => r(onResolve());
// Make sure to resolve imediatly if the timer has already completed
if (this.completed) this._resolve();
return this;
});
}
|
@param {Callback<this>} [callback]
@return {Promise}
|
then
|
javascript
|
juliangarnier/anime
|
lib/anime.esm.js
|
https://github.com/juliangarnier/anime/blob/master/lib/anime.esm.js
|
MIT
|
binarySubdivide = (aX, mX1, mX2) => {
let aA = 0, aB = 1, currentX, currentT, i = 0;
do {
currentT = aA + (aB - aA) / 2;
currentX = calcBezier(currentT, mX1, mX2) - aX;
if (currentX > 0) {
aB = currentT;
} else {
aA = currentT;
}
} while (abs(currentX) > .0000001 && ++i < 100);
return currentT;
}
|
@param {Number} aX
@param {Number} mX1
@param {Number} mX2
@return {Number}
|
binarySubdivide
|
javascript
|
juliangarnier/anime
|
lib/anime.esm.js
|
https://github.com/juliangarnier/anime/blob/master/lib/anime.esm.js
|
MIT
|
cubicBezier = (mX1 = 0.5, mY1 = 0.0, mX2 = 0.5, mY2 = 1.0) => (mX1 === mY1 && mX2 === mY2) ? none :
t => t === 0 || t === 1 ? t :
calcBezier(binarySubdivide(t, mX1, mX2), mY1, mY2)
|
@param {Number} [mX1]
@param {Number} [mY1]
@param {Number} [mX2]
@param {Number} [mY2]
@return {EasingFunction}
|
cubicBezier
|
javascript
|
juliangarnier/anime
|
lib/anime.esm.js
|
https://github.com/juliangarnier/anime/blob/master/lib/anime.esm.js
|
MIT
|
linear = (...args) => {
const argsLength = args.length;
if (!argsLength) return none;
const totalPoints = argsLength - 1;
const firstArg = args[0];
const lastArg = args[totalPoints];
const xPoints = [0];
const yPoints = [parseNumber(firstArg)];
for (let i = 1; i < totalPoints; i++) {
const arg = args[i];
const splitValue = isStr(arg) ?
/** @type {String} */(arg).trim().split(' ') :
[arg];
const value = splitValue[0];
const percent = splitValue[1];
xPoints.push(!isUnd(percent) ? parseNumber(percent) / 100 : i / totalPoints);
yPoints.push(parseNumber(value));
}
yPoints.push(parseNumber(lastArg));
xPoints.push(1);
return function easeLinear(t) {
for (let i = 1, l = xPoints.length; i < l; i++) {
const currentX = xPoints[i];
if (t <= currentX) {
const prevX = xPoints[i - 1];
const prevY = yPoints[i - 1];
return prevY + (yPoints[i] - prevY) * (t - prevX) / (currentX - prevX);
}
}
return yPoints[yPoints.length - 1];
}
}
|
Without parameters, the linear function creates a non-eased transition.
Parameters, if used, creates a piecewise linear easing by interpolating linearly between the specified points.
@param {...String|Number} [args] - Points
@return {EasingFunction}
|
linear
|
javascript
|
juliangarnier/anime
|
lib/anime.esm.js
|
https://github.com/juliangarnier/anime/blob/master/lib/anime.esm.js
|
MIT
|
irregular = (length = 10, randomness = 1) => {
const values = [0];
const total = length - 1;
for (let i = 1; i < total; i++) {
const previousValue = values[i - 1];
const spacing = i / total;
const segmentEnd = (i + 1) / total;
const randomVariation = spacing + (segmentEnd - spacing) * Math.random();
// Mix the even spacing and random variation based on the randomness parameter
const randomValue = spacing * (1 - randomness) + randomVariation * randomness;
values.push(clamp(randomValue, previousValue, 1));
}
values.push(1);
return linear(...values);
}
|
Generate random steps
@param {Number} [length] - The number of steps
@param {Number} [randomness] - How strong the randomness is
@return {EasingFunction}
|
irregular
|
javascript
|
juliangarnier/anime
|
lib/anime.esm.js
|
https://github.com/juliangarnier/anime/blob/master/lib/anime.esm.js
|
MIT
|
parseEaseString = (string, easesFunctions, easesLookups) => {
if (easesLookups[string]) return easesLookups[string];
if (string.indexOf('(') <= -1) {
const hasParams = easeTypes[string] || string.includes('Back') || string.includes('Elastic');
const parsedFn = /** @type {EasingFunction} */(hasParams ? /** @type {EasesFactory} */(easesFunctions[string])() : easesFunctions[string]);
return parsedFn ? easesLookups[string] = parsedFn : none;
} else {
const split = string.slice(0, -1).split('(');
const parsedFn = /** @type {EasesFactory} */(easesFunctions[split[0]]);
return parsedFn ? easesLookups[string] = parsedFn(...split[1].split(',')) : none;
}
}
|
@param {String} string
@param {Record<String, EasesFactory|EasingFunction>} easesFunctions
@param {Object} easesLookups
@return {EasingFunction}
|
parseEaseString
|
javascript
|
juliangarnier/anime
|
lib/anime.esm.js
|
https://github.com/juliangarnier/anime/blob/master/lib/anime.esm.js
|
MIT
|
sanitizePropertyName = (propertyName, target, tweenType) => {
if (tweenType === tweenTypes.TRANSFORM) {
const t = shortTransforms.get(propertyName);
return t ? t : propertyName;
} else if (
tweenType === tweenTypes.CSS ||
// Handle special cases where properties like "strokeDashoffset" needs to be set as "stroke-dashoffset"
// but properties like "baseFrequency" should stay in lowerCamelCase
(tweenType === tweenTypes.ATTRIBUTE && (isSvg(target) && propertyName in /** @type {DOMTarget} */(target).style))
) {
const cachedPropertyName = propertyNamesCache[propertyName];
if (cachedPropertyName) {
return cachedPropertyName;
} else {
const lowerCaseName = propertyName ? toLowerCase(propertyName) : propertyName;
propertyNamesCache[propertyName] = lowerCaseName;
return lowerCaseName;
}
} else {
return propertyName;
}
}
|
@param {String} propertyName
@param {Target} target
@param {tweenTypes} tweenType
@return {String}
|
sanitizePropertyName
|
javascript
|
juliangarnier/anime
|
lib/anime.esm.js
|
https://github.com/juliangarnier/anime/blob/master/lib/anime.esm.js
|
MIT
|
convertValueUnit = (el, decomposedValue, unit, force = false) => {
const currentUnit = decomposedValue.u;
const currentNumber = decomposedValue.n;
if (decomposedValue.t === valueTypes.UNIT && currentUnit === unit) { // TODO: Check if checking against the same unit string is necessary
return decomposedValue;
}
const cachedKey = currentNumber + currentUnit + unit;
const cached = convertedValuesCache[cachedKey];
if (!isUnd(cached) && !force) {
decomposedValue.n = cached;
} else {
let convertedValue;
if (currentUnit in angleUnitsMap) {
convertedValue = currentNumber * angleUnitsMap[currentUnit] / angleUnitsMap[unit];
} else {
const baseline = 100;
const tempEl = /** @type {DOMTarget} */(el.cloneNode());
const parentNode = el.parentNode;
const parentEl = (parentNode && (parentNode !== doc)) ? parentNode : doc.body;
parentEl.appendChild(tempEl);
const elStyle = tempEl.style;
elStyle.width = baseline + currentUnit;
const currentUnitWidth = /** @type {HTMLElement} */(tempEl).offsetWidth || baseline;
elStyle.width = baseline + unit;
const newUnitWidth = /** @type {HTMLElement} */(tempEl).offsetWidth || baseline;
const factor = currentUnitWidth / newUnitWidth;
parentEl.removeChild(tempEl);
convertedValue = factor * currentNumber;
}
decomposedValue.n = convertedValue;
convertedValuesCache[cachedKey] = convertedValue;
}
decomposedValue.t === valueTypes.UNIT;
decomposedValue.u = unit;
return decomposedValue;
}
|
@param {DOMTarget} el
@param {TweenDecomposedValue} decomposedValue
@param {String} unit
@param {Boolean} [force]
@return {TweenDecomposedValue}
|
convertValueUnit
|
javascript
|
juliangarnier/anime
|
lib/anime.esm.js
|
https://github.com/juliangarnier/anime/blob/master/lib/anime.esm.js
|
MIT
|
generateKeyframes = (keyframes, parameters) => {
/** @type {AnimationParams} */
const properties = {};
if (isArr(keyframes)) {
const propertyNames = [].concat(.../** @type {DurationKeyframes} */(keyframes).map(key => Object.keys(key))).filter(isKey);
for (let i = 0, l = propertyNames.length; i < l; i++) {
const propName = propertyNames[i];
const propArray = /** @type {DurationKeyframes} */(keyframes).map(key => {
/** @type {TweenKeyValue} */
const newKey = {};
for (let p in key) {
const keyValue = /** @type {TweenPropValue} */(key[p]);
if (isKey(p)) {
if (p === propName) {
newKey.to = keyValue;
}
} else {
newKey[p] = keyValue;
}
}
return newKey;
});
properties[propName] = /** @type {ArraySyntaxValue} */(propArray);
}
} else {
const totalDuration = /** @type {Number} */(setValue(parameters.duration, globals.defaults.duration));
const keys = Object.keys(keyframes)
.map(key => { return {o: parseFloat(key) / 100, p: keyframes[key]} })
.sort((a, b) => a.o - b.o);
keys.forEach(key => {
const offset = key.o;
const prop = key.p;
for (let name in prop) {
if (isKey(name)) {
let propArray = /** @type {Array} */(properties[name]);
if (!propArray) propArray = properties[name] = [];
const duration = offset * totalDuration;
let length = propArray.length;
let prevKey = propArray[length - 1];
const keyObj = { to: prop[name] };
let durProgress = 0;
for (let i = 0; i < length; i++) {
durProgress += propArray[i].duration;
}
if (length === 1) {
keyObj.from = prevKey.to;
}
if (prop.ease) {
keyObj.ease = prop.ease;
}
keyObj.duration = duration - (length ? durProgress : 0);
propArray.push(keyObj);
}
}
return key;
});
for (let name in properties) {
const propArray = /** @type {Array} */(properties[name]);
let prevEase;
// let durProgress = 0
for (let i = 0, l = propArray.length; i < l; i++) {
const prop = propArray[i];
// Emulate WAPPI easing parameter position
const currentEase = prop.ease;
prop.ease = prevEase ? prevEase : undefined;
prevEase = currentEase;
// durProgress += prop.duration;
// if (i === l - 1 && durProgress !== totalDuration) {
// propArray.push({ from: prop.to, ease: prop.ease, duration: totalDuration - durProgress })
// }
}
if (!propArray[0].duration) {
propArray.shift();
}
}
}
return properties;
}
|
@param {DurationKeyframes | PercentageKeyframes} keyframes
@param {AnimationParams} parameters
@return {AnimationParams}
|
generateKeyframes
|
javascript
|
juliangarnier/anime
|
lib/anime.esm.js
|
https://github.com/juliangarnier/anime/blob/master/lib/anime.esm.js
|
MIT
|
constructor(
targets,
parameters,
parent,
parentPosition,
fastSet = false,
index = 0,
length = 0
) {
super(/** @type {TimerParams&AnimationParams} */(parameters), parent, parentPosition);
const parsedTargets = registerTargets(targets);
const targetsLength = parsedTargets.length;
// If the parameters object contains a "keyframes" property, convert all the keyframes values to regular properties
const kfParams = /** @type {AnimationParams} */(parameters).keyframes;
const params = /** @type {AnimationParams} */(kfParams ? mergeObjects(generateKeyframes(/** @type {DurationKeyframes} */(kfParams), parameters), parameters) : parameters);
const {
delay,
duration,
ease,
playbackEase,
modifier,
composition,
onRender,
} = params;
const animDefaults = parent ? parent.defaults : globals.defaults;
const animaPlaybackEase = setValue(playbackEase, animDefaults.playbackEase);
const animEase = animaPlaybackEase ? parseEasings(animaPlaybackEase) : null;
const hasSpring = !isUnd(ease) && !isUnd(/** @type {Spring} */(ease).ease);
const tEasing = hasSpring ? /** @type {Spring} */(ease).ease : setValue(ease, animEase ? 'linear' : animDefaults.ease);
const tDuration = hasSpring ? /** @type {Spring} */(ease).duration : setValue(duration, animDefaults.duration);
const tDelay = setValue(delay, animDefaults.delay);
const tModifier = modifier || animDefaults.modifier;
// If no composition is defined and the targets length is high (>= 1000) set the composition to 'none' (0) for faster tween creation
const tComposition = isUnd(composition) && targetsLength >= K ? compositionTypes.none : !isUnd(composition) ? composition : animDefaults.composition;
// TODO: Do not create an empty object until we know the animation will generate inline styles
const animInlineStyles = {};
// const absoluteOffsetTime = this._offset;
const absoluteOffsetTime = this._offset + (parent ? parent._offset : 0);
let iterationDuration = NaN;
let iterationDelay = NaN;
let animationAnimationLength = 0;
let shouldTriggerRender = 0;
for (let targetIndex = 0; targetIndex < targetsLength; targetIndex++) {
const target = parsedTargets[targetIndex];
const ti = index || targetIndex;
const tl = length || targetsLength;
let lastTransformGroupIndex = NaN;
let lastTransformGroupLength = NaN;
for (let p in params) {
if (isKey(p)) {
const tweenType = getTweenType(target, p);
const propName = sanitizePropertyName(p, target, tweenType);
let propValue = params[p];
const isPropValueArray = isArr(propValue);
if (fastSet && !isPropValueArray) {
fastSetValuesArray[0] = propValue;
fastSetValuesArray[1] = propValue;
propValue = fastSetValuesArray;
}
// TODO: Allow nested keyframes inside ObjectValue value (prop: { to: [.5, 1, .75, 2, 3] })
// Normalize property values to valid keyframe syntax:
// [x, y] to [{to: [x, y]}] or {to: x} to [{to: x}] or keep keys syntax [{}, {}, {}...]
// const keyframes = isArr(propValue) ? propValue.length === 2 && !isObj(propValue[0]) ? [{ to: propValue }] : propValue : [propValue];
if (isPropValueArray) {
const arrayLength = /** @type {Array} */(propValue).length;
const isNotObjectValue = !isObj(propValue[0]);
// Convert [x, y] to [{to: [x, y]}]
if (arrayLength === 2 && isNotObjectValue) {
keyObjectTarget.to = /** @type {TweenParamValue} */(/** @type {unknown} */(propValue));
keyframesTargetArray[0] = keyObjectTarget;
keyframes = keyframesTargetArray;
// Convert [x, y, z] to [[x, y], z]
} else if (arrayLength > 2 && isNotObjectValue) {
keyframes = [];
/** @type {Array.<Number>} */(propValue).forEach((v, i) => {
if (!i) {
fastSetValuesArray[0] = v;
} else if (i === 1) {
fastSetValuesArray[1] = v;
keyframes.push(fastSetValuesArray);
} else {
keyframes.push(v);
}
});
} else {
keyframes = /** @type {Array.<TweenKeyValue>} */(propValue);
}
} else {
keyframesTargetArray[0] = propValue;
keyframes = keyframesTargetArray;
}
let siblings = null;
let prevTween = null;
let firstTweenChangeStartTime = NaN;
let lastTweenChangeEndTime = 0;
let tweenIndex = 0;
for (let l = keyframes.length; tweenIndex < l; tweenIndex++) {
const keyframe = keyframes[tweenIndex];
if (isObj(keyframe)) {
key = keyframe;
} else {
keyObjectTarget.to = /** @type {TweenParamValue} */(keyframe);
key = keyObjectTarget;
}
toFunctionStore.func = null;
const computedToValue = getFunctionValue(key.to, target, ti, tl, toFunctionStore);
let tweenToValue;
// Allows function based values to return an object syntax value ({to: v})
if (isObj(computedToValue) && !isUnd(computedToValue.to)) {
key = computedToValue;
tweenToValue = computedToValue.to;
} else {
tweenToValue = computedToValue;
}
const tweenFromValue = getFunctionValue(key.from, target, ti, tl);
const keyEasing = key.ease;
const hasSpring = !isUnd(keyEasing) && !isUnd(/** @type {Spring} */(keyEasing).ease);
// Easing are treated differently and don't accept function based value to prevent having to pass a function wrapper that returns an other function all the time
const tweenEasing = hasSpring ? /** @type {Spring} */(keyEasing).ease : keyEasing || tEasing;
// Calculate default individual keyframe duration by dividing the tl of keyframes
const tweenDuration = hasSpring ? /** @type {Spring} */(keyEasing).duration : getFunctionValue(setValue(key.duration, (l > 1 ? getFunctionValue(tDuration, target, ti, tl) / l : tDuration)), target, ti, tl);
// Default delay value should only be applied to the first tween
const tweenDelay = getFunctionValue(setValue(key.delay, (!tweenIndex ? tDelay : 0)), target, ti, tl);
const computedComposition = getFunctionValue(setValue(key.composition, tComposition), target, ti, tl);
const tweenComposition = isNum(computedComposition) ? computedComposition : compositionTypes[computedComposition];
// Modifiers are treated differently and don't accept function based value to prevent having to pass a function wrapper
const tweenModifier = key.modifier || tModifier;
const hasFromvalue = !isUnd(tweenFromValue);
const hasToValue = !isUnd(tweenToValue);
const isFromToArray = isArr(tweenToValue);
const isFromToValue = isFromToArray || (hasFromvalue && hasToValue);
const tweenStartTime = prevTween ? lastTweenChangeEndTime + tweenDelay : tweenDelay;
const absoluteStartTime = absoluteOffsetTime + tweenStartTime;
// Force a onRender callback if the animation contains at least one from value and autoplay is set to false
if (!shouldTriggerRender && (hasFromvalue || isFromToArray)) shouldTriggerRender = 1;
let prevSibling = prevTween;
if (tweenComposition !== compositionTypes.none) {
if (!siblings) siblings = getTweenSiblings(target, propName);
let nextSibling = siblings._head;
// Iterate trough all the next siblings until we find a sibling with an equal or inferior start time
while (nextSibling && !nextSibling._isOverridden && nextSibling._absoluteStartTime <= absoluteStartTime) {
prevSibling = nextSibling;
nextSibling = nextSibling._nextRep;
// Overrides all the next siblings if the next sibling starts at the same time of after as the new tween start time
if (nextSibling && nextSibling._absoluteStartTime >= absoluteStartTime) {
while (nextSibling) {
overrideTween(nextSibling);
// This will ends both the current while loop and the upper one once all the next sibllings have been overriden
nextSibling = nextSibling._nextRep;
}
}
}
}
// Decompose values
if (isFromToValue) {
decomposeRawValue(isFromToArray ? getFunctionValue(tweenToValue[0], target, ti, tl) : tweenFromValue, fromTargetObject);
decomposeRawValue(isFromToArray ? getFunctionValue(tweenToValue[1], target, ti, tl, toFunctionStore) : tweenToValue, toTargetObject);
if (fromTargetObject.t === valueTypes.NUMBER) {
if (prevSibling) {
if (prevSibling._valueType === valueTypes.UNIT) {
fromTargetObject.t = valueTypes.UNIT;
fromTargetObject.u = prevSibling._unit;
}
} else {
decomposeRawValue(
getOriginalAnimatableValue(target, propName, tweenType, animInlineStyles),
decomposedOriginalValue
);
if (decomposedOriginalValue.t === valueTypes.UNIT) {
fromTargetObject.t = valueTypes.UNIT;
fromTargetObject.u = decomposedOriginalValue.u;
}
}
}
} else {
if (hasToValue) {
decomposeRawValue(tweenToValue, toTargetObject);
} else {
if (prevTween) {
decomposeTweenValue(prevTween, toTargetObject);
} else {
// No need to get and parse the original value if the tween is part of a timeline and has a previous sibling part of the same timeline
decomposeRawValue(parent && prevSibling && prevSibling.parent.parent === parent ? prevSibling._value :
getOriginalAnimatableValue(target, propName, tweenType, animInlineStyles), toTargetObject);
}
}
if (hasFromvalue) {
decomposeRawValue(tweenFromValue, fromTargetObject);
} else {
if (prevTween) {
decomposeTweenValue(prevTween, fromTargetObject);
} else {
decomposeRawValue(parent && prevSibling && prevSibling.parent.parent === parent ? prevSibling._value :
// No need to get and parse the original value if the tween is part of a timeline and has a previous sibling part of the same timeline
getOriginalAnimatableValue(target, propName, tweenType, animInlineStyles), fromTargetObject);
}
}
}
// Apply operators
if (fromTargetObject.o) {
fromTargetObject.n = getRelativeValue(
!prevSibling ? decomposeRawValue(
getOriginalAnimatableValue(target, propName, tweenType, animInlineStyles),
decomposedOriginalValue
).n : prevSibling._toNumber,
fromTargetObject.n,
fromTargetObject.o
);
}
if (toTargetObject.o) {
toTargetObject.n = getRelativeValue(fromTargetObject.n, toTargetObject.n, toTargetObject.o);
}
// Values omogenisation in cases of type difference between "from" and "to"
if (fromTargetObject.t !== toTargetObject.t) {
if (fromTargetObject.t === valueTypes.COMPLEX || toTargetObject.t === valueTypes.COMPLEX) {
const complexValue = fromTargetObject.t === valueTypes.COMPLEX ? fromTargetObject : toTargetObject;
const notComplexValue = fromTargetObject.t === valueTypes.COMPLEX ? toTargetObject : fromTargetObject;
notComplexValue.t = valueTypes.COMPLEX;
notComplexValue.s = cloneArray(complexValue.s);
notComplexValue.d = complexValue.d.map(() => notComplexValue.n);
} else if (fromTargetObject.t === valueTypes.UNIT || toTargetObject.t === valueTypes.UNIT) {
const unitValue = fromTargetObject.t === valueTypes.UNIT ? fromTargetObject : toTargetObject;
const notUnitValue = fromTargetObject.t === valueTypes.UNIT ? toTargetObject : fromTargetObject;
notUnitValue.t = valueTypes.UNIT;
notUnitValue.u = unitValue.u;
} else if (fromTargetObject.t === valueTypes.COLOR || toTargetObject.t === valueTypes.COLOR) {
const colorValue = fromTargetObject.t === valueTypes.COLOR ? fromTargetObject : toTargetObject;
const notColorValue = fromTargetObject.t === valueTypes.COLOR ? toTargetObject : fromTargetObject;
notColorValue.t = valueTypes.COLOR;
notColorValue.s = colorValue.s;
notColorValue.d = [0, 0, 0, 1];
}
}
// Unit conversion
if (fromTargetObject.u !== toTargetObject.u) {
let valueToConvert = toTargetObject.u ? fromTargetObject : toTargetObject;
valueToConvert = convertValueUnit(/** @type {DOMTarget} */(target), valueToConvert, toTargetObject.u ? toTargetObject.u : fromTargetObject.u, false);
// TODO:
// convertValueUnit(target, to.u ? from : to, to.u ? to.u : from.u);
}
// Fill in non existing complex values
if (toTargetObject.d && fromTargetObject.d && (toTargetObject.d.length !== fromTargetObject.d.length)) {
const longestValue = fromTargetObject.d.length > toTargetObject.d.length ? fromTargetObject : toTargetObject;
const shortestValue = longestValue === fromTargetObject ? toTargetObject : fromTargetObject;
// TODO: Check if n should be used instead of 0 for default complex values
shortestValue.d = longestValue.d.map((_, i) => isUnd(shortestValue.d[i]) ? 0 : shortestValue.d[i]);
shortestValue.s = cloneArray(longestValue.s);
}
// Tween factory
// Rounding is necessary here to minimize floating point errors
const tweenUpdateDuration = round(+tweenDuration || minValue, 12);
/** @type {Tween} */
const tween = {
parent: this,
id: tweenId++,
property: propName,
target: target,
_value: null,
_func: toFunctionStore.func,
_ease: parseEasings(tweenEasing),
_fromNumbers: cloneArray(fromTargetObject.d),
_toNumbers: cloneArray(toTargetObject.d),
_strings: cloneArray(toTargetObject.s),
_fromNumber: fromTargetObject.n,
_toNumber: toTargetObject.n,
_numbers: cloneArray(fromTargetObject.d), // For additive tween and animatables
_number: fromTargetObject.n, // For additive tween and animatables
_unit: toTargetObject.u,
_modifier: tweenModifier,
_currentTime: 0,
_startTime: tweenStartTime,
_delay: +tweenDelay,
_updateDuration: tweenUpdateDuration,
_changeDuration: tweenUpdateDuration,
_absoluteStartTime: absoluteStartTime,
// NOTE: Investigate bit packing to stores ENUM / BOOL
_tweenType: tweenType,
_valueType: toTargetObject.t,
_composition: tweenComposition,
_isOverlapped: 0,
_isOverridden: 0,
_renderTransforms: 0,
_prevRep: null, // For replaced tween
_nextRep: null, // For replaced tween
_prevAdd: null, // For additive tween
_nextAdd: null, // For additive tween
_prev: null,
_next: null,
};
if (tweenComposition !== compositionTypes.none) {
composeTween(tween, siblings);
}
if (isNaN(firstTweenChangeStartTime)) {
firstTweenChangeStartTime = tween._startTime;
}
// Rounding is necessary here to minimize floating point errors
lastTweenChangeEndTime = round(tweenStartTime + tweenUpdateDuration, 12);
prevTween = tween;
animationAnimationLength++;
addChild(this, tween);
}
// Update animation timings with the added tweens properties
if (isNaN(iterationDelay) || firstTweenChangeStartTime < iterationDelay) {
iterationDelay = firstTweenChangeStartTime;
}
if (isNaN(iterationDuration) || lastTweenChangeEndTime > iterationDuration) {
iterationDuration = lastTweenChangeEndTime;
}
// TODO: Find a way to inline tween._renderTransforms = 1 here
if (tweenType === tweenTypes.TRANSFORM) {
lastTransformGroupIndex = animationAnimationLength - tweenIndex;
lastTransformGroupLength = animationAnimationLength;
}
}
}
// Set _renderTransforms to last transform property to correctly render the transforms list
if (!isNaN(lastTransformGroupIndex)) {
let i = 0;
forEachChildren(this, (/** @type {Tween} */tween) => {
if (i >= lastTransformGroupIndex && i < lastTransformGroupLength) {
tween._renderTransforms = 1;
if (tween._composition === compositionTypes.blend) {
forEachChildren(additive.animation, (/** @type {Tween} */additiveTween) => {
if (additiveTween.id === tween.id) {
additiveTween._renderTransforms = 1;
}
});
}
}
i++;
});
}
}
if (!targetsLength) {
console.warn(`No target found. Make sure the element you're trying to animate is accessible before creating your animation.`);
}
if (iterationDelay) {
forEachChildren(this, (/** @type {Tween} */tween) => {
// If (startTime - delay) equals 0, this means the tween is at the begining of the animation so we need to trim the delay too
if (!(tween._startTime - tween._delay)) {
tween._delay -= iterationDelay;
}
tween._startTime -= iterationDelay;
});
iterationDuration -= iterationDelay;
} else {
iterationDelay = 0;
}
// Prevents iterationDuration to be NaN if no valid animatable props have been provided
// Prevents _iterationCount to be NaN if no valid animatable props have been provided
if (!iterationDuration) {
iterationDuration = minValue;
this.iterationCount = 0;
}
/** @type {TargetsArray} */
this.targets = parsedTargets;
/** @type {Number} */
this.duration = iterationDuration === minValue ? minValue : clampInfinity(((iterationDuration + this._loopDelay) * this.iterationCount) - this._loopDelay) || minValue;
/** @type {Callback<this>} */
this.onRender = onRender || animDefaults.onRender;
/** @type {EasingFunction} */
this._ease = animEase;
/** @type {Number} */
this._delay = iterationDelay;
// NOTE: I'm keeping delay values separated from offsets in timelines because delays can override previous tweens and it could be confusing to debug a timeline with overridden tweens and no associated visible delays.
// this._delay = parent ? 0 : iterationDelay;
// this._offset += parent ? iterationDelay : 0;
/** @type {Number} */
this.iterationDuration = iterationDuration;
/** @type {{}} */
this._inlineStyles = animInlineStyles;
if (!this._autoplay && shouldTriggerRender) this.onRender(this);
}
|
@param {TargetsParam} targets
@param {AnimationParams} parameters
@param {Timeline} [parent]
@param {Number} [parentPosition]
@param {Boolean} [fastSet=false]
@param {Number} [index=0]
@param {Number} [length=0]
|
constructor
|
javascript
|
juliangarnier/anime
|
lib/anime.esm.js
|
https://github.com/juliangarnier/anime/blob/master/lib/anime.esm.js
|
MIT
|
revert() {
super.revert();
return cleanInlineStyles(this);
}
|
Cancel the animation and revert all the values affected by this animation to their original state
@return {this}
|
revert
|
javascript
|
juliangarnier/anime
|
lib/anime.esm.js
|
https://github.com/juliangarnier/anime/blob/master/lib/anime.esm.js
|
MIT
|
easingToLinear = (fn, samples = 100) => {
const points = [];
for (let i = 0; i <= samples; i++) points.push(fn(i / samples));
return `linear(${points.join(', ')})`;
}
|
Converts an easing function into a valid CSS linear() timing function string
@param {EasingFunction} fn
@param {number} [samples=100]
@returns {string} CSS linear() timing function
|
easingToLinear
|
javascript
|
juliangarnier/anime
|
lib/anime.esm.js
|
https://github.com/juliangarnier/anime/blob/master/lib/anime.esm.js
|
MIT
|
registerTransformsProperties = () => {
if (transformsPropertiesRegistered) return;
validTransforms.forEach(t => {
const isSkew = stringStartsWith(t, 'skew');
const isScale = stringStartsWith(t, 'scale');
const isRotate = stringStartsWith(t, 'rotate');
const isTranslate = stringStartsWith(t, 'translate');
const isAngle = isRotate || isSkew;
const syntax = isAngle ? '<angle>' : isScale ? "<number>" : isTranslate ? "<length-percentage>" : "*";
try {
CSS.registerProperty({
name: '--' + t,
syntax,
inherits: false,
initialValue: isTranslate ? '0px' : isAngle ? '0deg' : isScale ? '1' : '0',
});
} catch {} });
transformsPropertiesRegistered = true;
}
|
@typedef {Record<String, WAAPIKeyframeValue | WAAPIAnimationOptions | Boolean | ScrollObserver | WAAPICallback | EasingParam | WAAPITweenOptions> & WAAPIAnimationOptions} WAAPIAnimationParams
|
registerTransformsProperties
|
javascript
|
juliangarnier/anime
|
lib/anime.esm.js
|
https://github.com/juliangarnier/anime/blob/master/lib/anime.esm.js
|
MIT
|
removeWAAPIAnimation = ($el, property, parent) => {
let nextLookup = WAAPIAnimationsLookups._head;
while (nextLookup) {
const next = nextLookup._next;
const matchTarget = nextLookup.$el === $el;
const matchProperty = !property || nextLookup.property === property;
const matchParent = !parent || nextLookup.parent === parent;
if (matchTarget && matchProperty && matchParent) {
const anim = nextLookup.animation;
try { anim.commitStyles(); } catch {} anim.cancel();
removeChild(WAAPIAnimationsLookups, nextLookup);
const lookupParent = nextLookup.parent;
if (lookupParent) {
lookupParent._completed++;
if (lookupParent.animations.length === lookupParent._completed) {
lookupParent.completed = true;
if (!lookupParent.muteCallbacks) {
lookupParent.paused = true;
lookupParent.onComplete(lookupParent);
lookupParent._resolve(lookupParent);
}
}
}
}
nextLookup = next;
}
}
|
@param {DOMTarget} $el
@param {String} [property]
@param {WAAPIAnimation} [parent]
|
removeWAAPIAnimation
|
javascript
|
juliangarnier/anime
|
lib/anime.esm.js
|
https://github.com/juliangarnier/anime/blob/master/lib/anime.esm.js
|
MIT
|
addWAAPIAnimation = (parent, $el, property, keyframes, params) => {
const animation = $el.animate(keyframes, params);
const animTotalDuration = params.delay + (+params.duration * params.iterations);
animation.playbackRate = parent._speed;
if (parent.paused) animation.pause();
if (parent.duration < animTotalDuration) {
parent.duration = animTotalDuration;
parent.controlAnimation = animation;
}
parent.animations.push(animation);
removeWAAPIAnimation($el, property);
addChild(WAAPIAnimationsLookups, { parent, animation, $el, property, _next: null, _prev: null });
const handleRemove = () => { removeWAAPIAnimation($el, property, parent); };
animation.onremove = handleRemove;
animation.onfinish = handleRemove;
return animation;
}
|
@param {WAAPIAnimation} parent
@param {DOMTarget} $el
@param {String} property
@param {PropertyIndexedKeyframes} keyframes
@param {KeyframeAnimationOptions} params
@retun {Animation}
|
addWAAPIAnimation
|
javascript
|
juliangarnier/anime
|
lib/anime.esm.js
|
https://github.com/juliangarnier/anime/blob/master/lib/anime.esm.js
|
MIT
|
normalizeTweenValue = (propName, value, $el, i, targetsLength) => {
let v = getFunctionValue(/** @type {any} */(value), $el, i, targetsLength);
if (!isNum(v)) return v;
if (commonDefaultPXProperties.includes(propName) || stringStartsWith(propName, 'translate')) return `${v}px`;
if (stringStartsWith(propName, 'rotate') || stringStartsWith(propName, 'skew')) return `${v}deg`;
return `${v}`;
}
|
@param {String} propName
@param {WAAPIKeyframeValue} value
@param {DOMTarget} $el
@param {Number} i
@param {Number} targetsLength
@return {String}
|
normalizeTweenValue
|
javascript
|
juliangarnier/anime
|
lib/anime.esm.js
|
https://github.com/juliangarnier/anime/blob/master/lib/anime.esm.js
|
MIT
|
parseIndividualTweenValue = ($el, propName, from, to, i, targetsLength) => {
/** @type {WAAPITweenValue} */
let tweenValue = '0';
const computedTo = !isUnd(to) ? normalizeTweenValue(propName, to, $el, i, targetsLength) : getComputedStyle($el)[propName];
if (!isUnd(from)) {
const computedFrom = normalizeTweenValue(propName, from, $el, i, targetsLength);
tweenValue = [computedFrom, computedTo];
} else {
tweenValue = isArr(to) ? to.map((/** @type {any} */v) => normalizeTweenValue(propName, v, $el, i, targetsLength)) : computedTo;
}
return tweenValue;
}
|
@param {DOMTarget} $el
@param {String} propName
@param {WAAPIKeyframeValue} from
@param {WAAPIKeyframeValue} to
@param {Number} i
@param {Number} targetsLength
@return {WAAPITweenValue}
|
parseIndividualTweenValue
|
javascript
|
juliangarnier/anime
|
lib/anime.esm.js
|
https://github.com/juliangarnier/anime/blob/master/lib/anime.esm.js
|
MIT
|
constructor(targets, params) {
if (globals.scope) globals.scope.revertibles.push(this);
registerTransformsProperties();
const parsedTargets = registerTargets(targets);
const targetsLength = parsedTargets.length;
if (!targetsLength) {
console.warn(`No target found. Make sure the element you're trying to animate is accessible before creating your animation.`);
}
const ease = setValue(params.ease, parseWAAPIEasing(globals.defaults.ease));
const spring = /** @type {Spring} */(ease).ease && ease;
const autoplay = setValue(params.autoplay, globals.defaults.autoplay);
const scroll = autoplay && /** @type {ScrollObserver} */(autoplay).link ? autoplay : false;
const alternate = params.alternate && /** @type {Boolean} */(params.alternate) === true;
const reversed = params.reversed && /** @type {Boolean} */(params.reversed) === true;
const loop = setValue(params.loop, globals.defaults.loop);
const iterations = /** @type {Number} */((loop === true || loop === Infinity) ? Infinity : isNum(loop) ? loop + 1 : 1);
/** @type {PlaybackDirection} */
const direction = alternate ? reversed ? 'alternate-reverse' : 'alternate' : reversed ? 'reverse' : 'normal';
/** @type {FillMode} */
const fill = 'forwards';
/** @type {String} */
const easing = parseWAAPIEasing(ease);
const timeScale = (globals.timeScale === 1 ? 1 : K);
/** @type {DOMTargetsArray}] */
this.targets = parsedTargets;
/** @type {Array<globalThis.Animation>}] */
this.animations = [];
/** @type {globalThis.Animation}] */
this.controlAnimation = null;
/** @type {Callback<this>} */
this.onComplete = params.onComplete || noop;
/** @type {Number} */
this.duration = 0;
/** @type {Boolean} */
this.muteCallbacks = false;
/** @type {Boolean} */
this.completed = false;
/** @type {Boolean} */
this.paused = !autoplay || scroll !== false;
/** @type {Boolean} */
this.reversed = reversed;
/** @type {Boolean|ScrollObserver} */
this.autoplay = autoplay;
/** @type {Number} */
this._speed = setValue(params.playbackRate, globals.defaults.playbackRate);
/** @type {Function} */
this._resolve = noop; // Used by .then()
/** @type {Number} */
this._completed = 0;
/** @type {Array<Object>}] */
this._inlineStyles = parsedTargets.map($el => $el.getAttribute('style'));
parsedTargets.forEach(($el, i) => {
const cachedTransforms = $el[transformsSymbol];
const hasIndividualTransforms = validIndividualTransforms.some(t => params.hasOwnProperty(t));
/** @type {Number} */
const duration = (spring ? /** @type {Spring} */(spring).duration : getFunctionValue(setValue(params.duration, globals.defaults.duration), $el, i, targetsLength)) * timeScale;
/** @type {Number} */
const delay = getFunctionValue(setValue(params.delay, globals.defaults.delay), $el, i, targetsLength) * timeScale;
/** @type {CompositeOperation} */
const composite = /** @type {CompositeOperation} */(setValue(params.composition, 'replace'));
for (let name in params) {
if (!isKey(name)) continue;
/** @type {PropertyIndexedKeyframes} */
const keyframes = {};
/** @type {KeyframeAnimationOptions} */
const tweenParams = { iterations, direction, fill, easing, duration, delay, composite };
const propertyValue = params[name];
const individualTransformProperty = hasIndividualTransforms ? validTransforms.includes(name) ? name : shortTransforms.get(name) : false;
let parsedPropertyValue;
if (isObj(propertyValue)) {
const tweenOptions = /** @type {WAAPITweenOptions} */(propertyValue);
const tweenOptionsEase = setValue(tweenOptions.ease, ease);
const tweenOptionsSpring = /** @type {Spring} */(tweenOptionsEase).ease && tweenOptionsEase;
const to = /** @type {WAAPITweenOptions} */(tweenOptions).to;
const from = /** @type {WAAPITweenOptions} */(tweenOptions).from;
/** @type {Number} */
tweenParams.duration = (tweenOptionsSpring ? /** @type {Spring} */(tweenOptionsSpring).duration : getFunctionValue(setValue(tweenOptions.duration, duration), $el, i, targetsLength)) * timeScale;
/** @type {Number} */
tweenParams.delay = getFunctionValue(setValue(tweenOptions.delay, delay), $el, i, targetsLength) * timeScale;
/** @type {CompositeOperation} */
tweenParams.composite = /** @type {CompositeOperation} */(setValue(tweenOptions.composition, composite));
/** @type {String} */
tweenParams.easing = parseWAAPIEasing(tweenOptionsEase);
parsedPropertyValue = parseIndividualTweenValue($el, name, from, to, i, targetsLength);
if (individualTransformProperty) {
keyframes[`--${individualTransformProperty}`] = parsedPropertyValue;
cachedTransforms[individualTransformProperty] = parsedPropertyValue;
} else {
keyframes[name] = parseIndividualTweenValue($el, name, from, to, i, targetsLength);
}
addWAAPIAnimation(this, $el, name, keyframes, tweenParams);
if (!isUnd(from)) {
if (!individualTransformProperty) {
$el.style[name] = keyframes[name][0];
} else {
const key = `--${individualTransformProperty}`;
$el.style.setProperty(key, keyframes[key][0]);
}
}
} else {
parsedPropertyValue = isArr(propertyValue) ?
propertyValue.map((/** @type {any} */v) => normalizeTweenValue(name, v, $el, i, targetsLength)) :
normalizeTweenValue(name, /** @type {any} */(propertyValue), $el, i, targetsLength);
if (individualTransformProperty) {
keyframes[`--${individualTransformProperty}`] = parsedPropertyValue;
cachedTransforms[individualTransformProperty] = parsedPropertyValue;
} else {
keyframes[name] = parsedPropertyValue;
}
addWAAPIAnimation(this, $el, name, keyframes, tweenParams);
}
}
if (hasIndividualTransforms) {
let transforms = emptyString;
for (let t in cachedTransforms) {
transforms += `${transformsFragmentStrings[t]}var(--${t})) `;
}
$el.style.transform = transforms;
}
});
if (scroll) {
/** @type {ScrollObserver} */(this.autoplay).link(this);
}
}
|
@param {DOMTargetsParam} targets
@param {WAAPIAnimationParams} params
|
constructor
|
javascript
|
juliangarnier/anime
|
lib/anime.esm.js
|
https://github.com/juliangarnier/anime/blob/master/lib/anime.esm.js
|
MIT
|
forEach(callback) {
const cb = isStr(callback) ? a => a[callback]() : callback;
this.animations.forEach(cb);
return this;
}
|
@param {forEachCallback|String} callback
@return {this}
|
forEach
|
javascript
|
juliangarnier/anime
|
lib/anime.esm.js
|
https://github.com/juliangarnier/anime/blob/master/lib/anime.esm.js
|
MIT
|
seek(time, muteCallbacks = false) {
if (muteCallbacks) this.muteCallbacks = true;
if (time < this.duration) this.completed = false;
this.currentTime = time;
this.muteCallbacks = false;
if (this.paused) this.pause();
return this;
}
|
@param {Number} time
@param {Boolean} muteCallbacks
|
seek
|
javascript
|
juliangarnier/anime
|
lib/anime.esm.js
|
https://github.com/juliangarnier/anime/blob/master/lib/anime.esm.js
|
MIT
|
sync = (callback = noop) => {
return new Timer({ duration: 1 * globals.timeScale, onComplete: callback }, null, 0).resume();
}
|
@param {Callback<Timer>} [callback]
@return {Timer}
|
sync
|
javascript
|
juliangarnier/anime
|
lib/anime.esm.js
|
https://github.com/juliangarnier/anime/blob/master/lib/anime.esm.js
|
MIT
|
function getTargetValue(targetSelector, propName, unit) {
const targets = registerTargets(targetSelector);
if (!targets.length) return;
const [ target ] = targets;
const tweenType = getTweenType(target, propName);
const normalizePropName = sanitizePropertyName(propName, target, tweenType);
let originalValue = getOriginalAnimatableValue(target, normalizePropName);
if (isUnd(unit)) {
return originalValue;
} else {
decomposeRawValue(originalValue, decomposedOriginalValue);
if (decomposedOriginalValue.t === valueTypes.NUMBER || decomposedOriginalValue.t === valueTypes.UNIT) {
if (unit === false) {
return decomposedOriginalValue.n;
} else {
const convertedValue = convertValueUnit(/** @type {DOMTarget} */(target), decomposedOriginalValue, /** @type {String} */(unit), false);
return `${round(convertedValue.n, globals.precision)}${convertedValue.u}`;
}
}
}
}
|
@overload
@param {DOMTargetSelector} targetSelector
@param {String} propName
@return {String}
@overload
@param {JSTargetsParam} targetSelector
@param {String} propName
@return {Number|String}
@overload
@param {DOMTargetsParam} targetSelector
@param {String} propName
@param {String} unit
@return {String}
@overload
@param {TargetsParam} targetSelector
@param {String} propName
@param {Boolean} unit
@return {Number}
@param {TargetsParam} targetSelector
@param {String} propName
@param {String|Boolean} [unit]
|
getTargetValue
|
javascript
|
juliangarnier/anime
|
lib/anime.esm.js
|
https://github.com/juliangarnier/anime/blob/master/lib/anime.esm.js
|
MIT
|
setTargetValues = (targets, parameters) => {
if (isUnd(parameters)) return;
parameters.duration = minValue;
// Do not overrides currently active tweens by default
parameters.composition = setValue(parameters.composition, compositionTypes.none);
// Skip init() and force rendering by playing the animation
return new JSAnimation(targets, parameters, null, 0, true).resume();
}
|
@param {TargetsParam} targets
@param {AnimationParams} parameters
@return {JSAnimation}
|
setTargetValues
|
javascript
|
juliangarnier/anime
|
lib/anime.esm.js
|
https://github.com/juliangarnier/anime/blob/master/lib/anime.esm.js
|
MIT
|
removeTargetsFromAnimation = (targetsArray, animation, propertyName) => {
let tweensMatchesTargets = false;
forEachChildren(animation, (/**@type {Tween} */tween) => {
const tweenTarget = tween.target;
if (targetsArray.includes(tweenTarget)) {
const tweenName = tween.property;
const tweenType = tween._tweenType;
const normalizePropName = sanitizePropertyName(propertyName, tweenTarget, tweenType);
if (!normalizePropName || normalizePropName && normalizePropName === tweenName) {
// Make sure to flag the previous CSS transform tween to renderTransform
if (tween.parent._tail === tween &&
tween._tweenType === tweenTypes.TRANSFORM &&
tween._prev &&
tween._prev._tweenType === tweenTypes.TRANSFORM
) {
tween._prev._renderTransforms = 1;
}
// Removes the tween from the selected animation
removeChild(animation, tween);
// Detach the tween from its siblings to make sure blended tweens are correctlly removed
removeTweenSliblings(tween);
tweensMatchesTargets = true;
}
}
}, true);
return tweensMatchesTargets;
}
|
@param {TargetsArray} targetsArray
@param {JSAnimation} animation
@param {String} [propertyName]
@return {Boolean}
|
removeTargetsFromAnimation
|
javascript
|
juliangarnier/anime
|
lib/anime.esm.js
|
https://github.com/juliangarnier/anime/blob/master/lib/anime.esm.js
|
MIT
|
remove = (targets, renderable, propertyName) => {
const targetsArray = parseTargets(targets);
const parent = /** @type {Renderable|typeof engine} **/(renderable ? renderable : engine);
const waapiAnimation = renderable && /** @type {WAAPIAnimation} */(renderable).controlAnimation && /** @type {WAAPIAnimation} */(renderable);
for (let i = 0, l = targetsArray.length; i < l; i++) {
const $el = /** @type {DOMTarget} */(targetsArray[i]);
removeWAAPIAnimation($el, propertyName, waapiAnimation);
}
let removeMatches;
if (parent._hasChildren) {
let iterationDuration = 0;
forEachChildren(parent, (/** @type {Renderable} */child) => {
if (!child._hasChildren) {
removeMatches = removeTargetsFromAnimation(targetsArray, /** @type {JSAnimation} */(child), propertyName);
// Remove the child from its parent if no tweens and no children left after the removal
if (removeMatches && !child._head) {
child.cancel();
removeChild(parent, child);
} else {
// Calculate the new iterationDuration value to handle onComplete with last child in render()
const childTLOffset = child._offset + child._delay;
const childDur = childTLOffset + child.duration;
if (childDur > iterationDuration) {
iterationDuration = childDur;
}
}
}
// Make sure to also remove engine's children targets
// NOTE: Avoid recursion?
if (child._head) {
remove(targets, child, propertyName);
} else {
child._hasChildren = false;
}
}, true);
// Update iterationDuration value to handle onComplete with last child in render()
if (!isUnd(/** @type {Renderable} */(parent).iterationDuration)) {
/** @type {Renderable} */(parent).iterationDuration = iterationDuration;
}
} else {
removeMatches = removeTargetsFromAnimation(
targetsArray,
/** @type {JSAnimation} */(parent),
propertyName
);
}
if (removeMatches && !parent._head) {
parent._hasChildren = false;
// Cancel the parent if there are no tweens and no children left after the removal
// We have to check if the .cancel() method exist to handle cases where the parent is the engine itself
if (/** @type {Renderable} */(parent).cancel) /** @type {Renderable} */(parent).cancel();
}
return targetsArray;
}
|
@param {TargetsParam} targets
@param {Renderable|WAAPIAnimation} [renderable]
@param {String} [propertyName]
@return {TargetsArray}
|
remove
|
javascript
|
juliangarnier/anime
|
lib/anime.esm.js
|
https://github.com/juliangarnier/anime/blob/master/lib/anime.esm.js
|
MIT
|
shuffle = items => {
let m = items.length, t, i;
while (m) { i = random(0, --m); t = items[m]; items[m] = items[i]; items[i] = t; }
return items;
}
|
Adapted from https://bost.ocks.org/mike/shuffle/
@param {Array} items
@return {Array}
|
shuffle
|
javascript
|
juliangarnier/anime
|
lib/anime.esm.js
|
https://github.com/juliangarnier/anime/blob/master/lib/anime.esm.js
|
MIT
|
lerp = (start, end, amount, renderable) => {
let dt = K / globals.defaults.frameRate;
if (renderable !== false) {
const ticker = /** @type Renderable */
(renderable) ||
(engine._hasChildren && engine);
if (ticker && ticker.deltaTime) {
dt = ticker.deltaTime;
}
}
const t = 1 - Math.exp(-amount * dt * .1);
return !amount ? start : amount === 1 ? end : (1 - t) * start + t * end;
}
|
https://www.rorydriscoll.com/2016/03/07/frame-rate-independent-damping-using-lerp/
@param {Number} start
@param {Number} end
@param {Number} amount
@param {Renderable|Boolean} [renderable]
@return {Number}
|
lerp
|
javascript
|
juliangarnier/anime
|
lib/anime.esm.js
|
https://github.com/juliangarnier/anime/blob/master/lib/anime.esm.js
|
MIT
|
chain = fn => {
return (...args) => {
const result = fn(...args);
return new Proxy(noop, {
apply: (_, __, [v]) => result(v),
get: (_, prop) => chain(/**@param {...Number|String} nextArgs */(...nextArgs) => {
const nextResult = utils[prop](...nextArgs);
return (/**@type {Number|String} */v) => nextResult(result(v));
})
});
}
}
|
@param {Function} fn
@return {function(...(Number|String))}
|
chain
|
javascript
|
juliangarnier/anime
|
lib/anime.esm.js
|
https://github.com/juliangarnier/anime/blob/master/lib/anime.esm.js
|
MIT
|
getPrevChildOffset = (timeline, timePosition) => {
if (stringStartsWith(timePosition, '<')) {
const goToPrevAnimationOffset = timePosition[1] === '<';
const prevAnimation = /** @type {Tickable} */(timeline._tail);
const prevOffset = prevAnimation ? prevAnimation._offset + prevAnimation._delay : 0;
return goToPrevAnimationOffset ? prevOffset : prevOffset + prevAnimation.duration;
}
}
|
Timeline's children offsets positions parser
@param {Timeline} timeline
@param {String} timePosition
@return {Number}
|
getPrevChildOffset
|
javascript
|
juliangarnier/anime
|
lib/anime.esm.js
|
https://github.com/juliangarnier/anime/blob/master/lib/anime.esm.js
|
MIT
|
parseTimelinePosition = (timeline, timePosition) => {
let tlDuration = timeline.iterationDuration;
if (tlDuration === minValue) tlDuration = 0;
if (isUnd(timePosition)) return tlDuration;
if (isNum(+timePosition)) return +timePosition;
const timePosStr = /** @type {String} */(timePosition);
const tlLabels = timeline ? timeline.labels : null;
const hasLabels = !isNil(tlLabels);
const prevOffset = getPrevChildOffset(timeline, timePosStr);
const hasSibling = !isUnd(prevOffset);
const matchedRelativeOperator = relativeValuesExecRgx.exec(timePosStr);
if (matchedRelativeOperator) {
const fullOperator = matchedRelativeOperator[0];
const split = timePosStr.split(fullOperator);
const labelOffset = hasLabels && split[0] ? tlLabels[split[0]] : tlDuration;
const parsedOffset = hasSibling ? prevOffset : hasLabels ? labelOffset : tlDuration;
const parsedNumericalOffset = +split[1];
return getRelativeValue(parsedOffset, parsedNumericalOffset, fullOperator[0]);
} else {
return hasSibling ? prevOffset :
hasLabels ? !isUnd(tlLabels[timePosStr]) ? tlLabels[timePosStr] :
tlDuration : tlDuration;
}
}
|
@param {Timeline} timeline
@param {TimePosition} [timePosition]
@return {Number}
|
parseTimelinePosition
|
javascript
|
juliangarnier/anime
|
lib/anime.esm.js
|
https://github.com/juliangarnier/anime/blob/master/lib/anime.esm.js
|
MIT
|
function addTlChild(childParams, tl, timePosition, targets, index, length) {
const isSetter = isNum(childParams.duration) && /** @type {Number} */(childParams.duration) <= minValue;
// Offset the tl position with -minValue for 0 duration animations or .set() calls in order to align their end value with the defined position
const adjustedPosition = isSetter ? timePosition - minValue : timePosition;
tick(tl, adjustedPosition, 1, 1, tickModes.AUTO);
const tlChild = targets ?
new JSAnimation(targets,/** @type {AnimationParams} */(childParams), tl, adjustedPosition, false, index, length) :
new Timer(/** @type {TimerParams} */(childParams), tl, adjustedPosition);
tlChild.init(1);
// TODO: Might be better to insert at a position relative to startTime?
addChild(tl, tlChild);
forEachChildren(tl, (/** @type {Renderable} */child) => {
const childTLOffset = child._offset + child._delay;
const childDur = childTLOffset + child.duration;
if (childDur > tl.iterationDuration) tl.iterationDuration = childDur;
});
tl.duration = getTimelineTotalDuration(tl);
return tl;
}
|
@overload
@param {TimerParams} childParams
@param {Timeline} tl
@param {Number} timePosition
@return {Timeline}
@overload
@param {AnimationParams} childParams
@param {Timeline} tl
@param {Number} timePosition
@param {TargetsParam} targets
@param {Number} [index]
@param {Number} [length]
@return {Timeline}
@param {TimerParams|AnimationParams} childParams
@param {Timeline} tl
@param {Number} timePosition
@param {TargetsParam} [targets]
@param {Number} [index]
@param {Number} [length]
|
addTlChild
|
javascript
|
juliangarnier/anime
|
lib/anime.esm.js
|
https://github.com/juliangarnier/anime/blob/master/lib/anime.esm.js
|
MIT
|
add(a1, a2, a3) {
const isAnim = isObj(a2);
const isTimer = isObj(a1);
if (isAnim || isTimer) {
this._hasChildren = true;
if (isAnim) {
const childParams = /** @type {AnimationParams} */(a2);
// Check for function for children stagger positions
if (isFnc(a3)) {
const staggeredPosition = /** @type {Function} */(a3);
const parsedTargetsArray = parseTargets(/** @type {TargetsParam} */(a1));
// Store initial duration before adding new children that will change the duration
const tlDuration = this.duration;
// Store initial _iterationDuration before adding new children that will change the duration
const tlIterationDuration = this.iterationDuration;
// Store the original id in order to add specific indexes to the new animations ids
const id = childParams.id;
let i = 0;
const parsedLength = parsedTargetsArray.length;
parsedTargetsArray.forEach((/** @type {Target} */target) => {
// Create a new parameter object for each staggered children
const staggeredChildParams = { ...childParams };
// Reset the duration of the timeline iteration before each stagger to prevent wrong start value calculation
this.duration = tlDuration;
this.iterationDuration = tlIterationDuration;
if (!isUnd(id)) staggeredChildParams.id = id + '-' + i;
addTlChild(
staggeredChildParams,
this,
staggeredPosition(target, i, parsedLength, this),
target,
i,
parsedLength
);
i++;
});
} else {
addTlChild(
childParams,
this,
parseTimelinePosition(this, a3),
/** @type {TargetsParam} */(a1),
);
}
} else {
// It's a Timer
addTlChild(
/** @type TimerParams */(a1),
this,
parseTimelinePosition(this,/** @type TimePosition */(a2)),
);
}
return this.init(1); // 1 = internalRender
}
}
|
@overload
@param {TargetsParam} a1
@param {AnimationParams} a2
@param {TimePosition} [a3]
@return {this}
@overload
@param {TimerParams} a1
@param {TimePosition} [a2]
@return {this}
@param {TargetsParam|TimerParams} a1
@param {AnimationParams|TimePosition} a2
@param {TimePosition} [a3]
|
add
|
javascript
|
juliangarnier/anime
|
lib/anime.esm.js
|
https://github.com/juliangarnier/anime/blob/master/lib/anime.esm.js
|
MIT
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.