Socket
Socket
Sign inDemoInstall

@interactjs/inertia

Package Overview
Dependencies
Maintainers
2
Versions
137
Alerts
File Explorer

Advanced tools

License
Socket logo

Install Socket

Detect and block malicious and high-risk dependencies

Install

@interactjs/inertia - npm Package Compare versions

Comparing version 1.9.10 to 1.9.11

plugin.d.ts
plugin.js
plugin.js.map
plugin.min.js
plugin.min.js.map

67

index.d.ts

@@ -1,66 +0,1 @@

import Modification from '@interactjs/modifiers/Modification';
import * as modifiers from '@interactjs/modifiers/base';
declare module '@interactjs/core/InteractEvent' {
interface PhaseMap {
resume?: true;
inertiastart?: true;
}
}
declare module '@interactjs/core/Interaction' {
interface Interaction {
inertia?: InertiaState;
}
}
declare module '@interactjs/core/defaultOptions' {
interface PerActionDefaults {
inertia?: {
enabled?: boolean;
resistance?: number;
minSpeed?: number;
endSpeed?: number;
allowResume?: true;
smoothEndDuration?: number;
};
}
}
declare module '@interactjs/core/scope' {
interface SignalArgs {
'interactions:before-action-inertiastart': Omit<Interact.DoPhaseArg<Interact.ActionName, 'inertiastart'>, 'iEvent'>;
'interactions:action-inertiastart': Interact.DoPhaseArg<Interact.ActionName, 'inertiastart'>;
'interactions:after-action-inertiastart': Interact.DoPhaseArg<Interact.ActionName, 'inertiastart'>;
'interactions:before-action-resume': Omit<Interact.DoPhaseArg<Interact.ActionName, 'resume'>, 'iEvent'>;
'interactions:action-resume': Interact.DoPhaseArg<Interact.ActionName, 'resume'>;
'interactions:after-action-resume': Interact.DoPhaseArg<Interact.ActionName, 'resume'>;
}
}
export declare class InertiaState {
active: boolean;
isModified: boolean;
smoothEnd: boolean;
allowResume: boolean;
modification: Modification;
modifierCount: number;
modifierArg: modifiers.ModifierArg;
startCoords: Interact.Point;
t0: number;
v0: number;
te: number;
targetOffset: Interact.Point;
modifiedOffset: Interact.Point;
currentOffset: Interact.Point;
lambda_v0?: number;
one_ve_v0?: number;
timeout: number;
readonly interaction: Interact.Interaction;
constructor(interaction: Interact.Interaction);
start(event: Interact.PointerEventType): boolean;
startInertia(): void;
startSmoothEnd(): void;
inertiaTick(): void;
smoothEndTick(): void;
resume({ pointer, event, eventTarget }: Interact.SignalArgs['interactions:down']): void;
end(): void;
stop(): void;
}
declare const inertia: Interact.Plugin;
export default inertia;
export {};

392

index.js

@@ -1,388 +0,16 @@

import Modification from "../modifiers/Modification.js";
import * as modifiers from "../modifiers/base.js";
import offset from "../offset/index.js";
import * as dom from "../utils/domUtils.js";
import hypot from "../utils/hypot.js";
import * as is from "../utils/is.js";
import { copyCoords } from "../utils/pointerUtils.js";
import raf from "../utils/raf.js";
/* eslint-disable import/order, no-console, eol-last */
import interact, { init } from "../interact/index.js";
import plugin from "./plugin.js";
function install(scope) {
const {
defaults
} = scope;
scope.usePlugin(offset);
scope.usePlugin(modifiers.default);
scope.actions.phases.inertiastart = true;
scope.actions.phases.resume = true;
defaults.perAction.inertia = {
enabled: false,
resistance: 10,
// the lambda in exponential decay
minSpeed: 100,
// target speed must be above this for inertia to start
endSpeed: 10,
// the speed at which inertia is slow enough to stop
allowResume: true,
// allow resuming an action in inertia phase
smoothEndDuration: 300 // animate to snap/restrict endOnly if there's no inertia
if (typeof window === 'object' && !!window) {
init(window);
} // eslint-disable-next-line no-undef
};
}
export class InertiaState {
// eslint-disable-line camelcase
// eslint-disable-line camelcase
constructor(interaction) {
this.active = false;
this.isModified = false;
this.smoothEnd = false;
this.allowResume = false;
this.modification = null;
this.modifierCount = 0;
this.modifierArg = null;
this.startCoords = null;
this.t0 = 0;
this.v0 = 0;
this.te = 0;
this.targetOffset = null;
this.modifiedOffset = null;
this.currentOffset = null;
this.lambda_v0 = 0;
this.one_ve_v0 = 0;
this.timeout = null;
this.interaction = void 0;
this.interaction = interaction;
}
start(event) {
const {
interaction
} = this;
const options = getOptions(interaction);
if (!options || !options.enabled) {
return false;
}
const {
client: velocityClient
} = interaction.coords.velocity;
const pointerSpeed = hypot(velocityClient.x, velocityClient.y);
const modification = this.modification || (this.modification = new Modification(interaction));
modification.copyFrom(interaction.modification);
this.t0 = interaction._now();
this.allowResume = options.allowResume;
this.v0 = pointerSpeed;
this.currentOffset = {
x: 0,
y: 0
};
this.startCoords = interaction.coords.cur.page;
this.modifierArg = {
interaction,
interactable: interaction.interactable,
element: interaction.element,
rect: interaction.rect,
edges: interaction.edges,
pageCoords: this.startCoords,
preEnd: true,
phase: 'inertiastart'
};
const thrown = this.t0 - interaction.coords.cur.timeStamp < 50 && pointerSpeed > options.minSpeed && pointerSpeed > options.endSpeed;
if (thrown) {
this.startInertia();
} else {
modification.result = modification.setAll(this.modifierArg);
if (!modification.result.changed) {
return false;
}
this.startSmoothEnd();
} // force modification change
interaction.modification.result.rect = null; // bring inertiastart event to the target coords
interaction.offsetBy(this.targetOffset);
interaction._doPhase({
interaction,
event,
phase: 'inertiastart'
});
interaction.offsetBy({
x: -this.targetOffset.x,
y: -this.targetOffset.y
}); // force modification change
interaction.modification.result.rect = null;
this.active = true;
interaction.simulation = this;
return true;
}
startInertia() {
const startVelocity = this.interaction.coords.velocity.client;
const options = getOptions(this.interaction);
const lambda = options.resistance;
const inertiaDur = -Math.log(options.endSpeed / this.v0) / lambda;
this.targetOffset = {
x: (startVelocity.x - inertiaDur) / lambda,
y: (startVelocity.y - inertiaDur) / lambda
};
this.te = inertiaDur;
this.lambda_v0 = lambda / this.v0;
this.one_ve_v0 = 1 - options.endSpeed / this.v0;
const {
modification,
modifierArg
} = this;
modifierArg.pageCoords = {
x: this.startCoords.x + this.targetOffset.x,
y: this.startCoords.y + this.targetOffset.y
};
modification.result = modification.setAll(modifierArg);
if (modification.result.changed) {
this.isModified = true;
this.modifiedOffset = {
x: this.targetOffset.x + modification.result.delta.x,
y: this.targetOffset.y + modification.result.delta.y
};
}
this.timeout = raf.request(() => this.inertiaTick());
}
startSmoothEnd() {
this.smoothEnd = true;
this.isModified = true;
this.targetOffset = {
x: this.modification.result.delta.x,
y: this.modification.result.delta.y
};
this.timeout = raf.request(() => this.smoothEndTick());
}
inertiaTick() {
const {
interaction
} = this;
const options = getOptions(interaction);
const lambda = options.resistance;
const t = (interaction._now() - this.t0) / 1000;
if (t < this.te) {
const progress = 1 - (Math.exp(-lambda * t) - this.lambda_v0) / this.one_ve_v0;
let newOffset;
if (this.isModified) {
newOffset = getQuadraticCurvePoint(0, 0, this.targetOffset.x, this.targetOffset.y, this.modifiedOffset.x, this.modifiedOffset.y, progress);
} else {
newOffset = {
x: this.targetOffset.x * progress,
y: this.targetOffset.y * progress
};
}
const delta = {
x: newOffset.x - this.currentOffset.x,
y: newOffset.y - this.currentOffset.y
};
this.currentOffset.x += delta.x;
this.currentOffset.y += delta.y;
interaction.offsetBy(delta);
interaction.move();
this.timeout = raf.request(() => this.inertiaTick());
} else {
interaction.offsetBy({
x: this.modifiedOffset.x - this.currentOffset.x,
y: this.modifiedOffset.y - this.currentOffset.y
});
this.end();
}
}
smoothEndTick() {
const {
interaction
} = this;
const t = interaction._now() - this.t0;
const {
smoothEndDuration: duration
} = getOptions(interaction);
if (t < duration) {
const newOffset = {
x: easeOutQuad(t, 0, this.targetOffset.x, duration),
y: easeOutQuad(t, 0, this.targetOffset.y, duration)
};
const delta = {
x: newOffset.x - this.currentOffset.x,
y: newOffset.y - this.currentOffset.y
};
this.currentOffset.x += delta.x;
this.currentOffset.y += delta.y;
interaction.offsetBy(delta);
interaction.move({
skipModifiers: this.modifierCount
});
this.timeout = raf.request(() => this.smoothEndTick());
} else {
interaction.offsetBy({
x: this.targetOffset.x - this.currentOffset.x,
y: this.targetOffset.y - this.currentOffset.y
});
this.end();
}
}
resume({
pointer,
event,
eventTarget
}) {
const {
interaction
} = this; // undo inertia changes to interaction coords
interaction.offsetBy({
x: -this.currentOffset.x,
y: -this.currentOffset.y
}); // update pointer at pointer down position
interaction.updatePointer(pointer, event, eventTarget, true); // fire resume signals and event
interaction._doPhase({
interaction,
event,
phase: 'resume'
});
copyCoords(interaction.coords.prev, interaction.coords.cur);
this.stop();
}
end() {
this.interaction.move();
this.interaction.end();
this.stop();
}
stop() {
this.active = this.smoothEnd = false;
this.interaction.simulation = null;
raf.cancel(this.timeout);
}
if (("development" !== 'production' || true) && !interact.__warnedUseImport) {
interact.__warnedUseImport = true;
console.warn('[interact.js] The "@interactjs/*/index" packages are not quite stable yet. Use them with caution.');
}
function start({
interaction,
event
}) {
if (!interaction._interacting || interaction.simulation) {
return null;
}
const started = interaction.inertia.start(event); // prevent action end if inertia or smoothEnd
return started ? false : null;
} // Check if the down event hits the current inertia target
// control should be return to the user
function resume(arg) {
const {
interaction,
eventTarget
} = arg;
const state = interaction.inertia;
if (!state.active) {
return;
}
let element = eventTarget; // climb up the DOM tree from the event target
while (is.element(element)) {
// if interaction element is the current inertia target element
if (element === interaction.element) {
state.resume(arg);
break;
}
element = dom.parentNode(element);
}
}
function stop({
interaction
}) {
const state = interaction.inertia;
if (state.active) {
state.stop();
}
}
function getOptions({
interactable,
prepared
}) {
return interactable && interactable.options && prepared.name && interactable.options[prepared.name].inertia;
}
const inertia = {
id: 'inertia',
before: ['modifiers/base'],
install,
listeners: {
'interactions:new': ({
interaction
}) => {
interaction.inertia = new InertiaState(interaction);
},
'interactions:before-action-end': start,
'interactions:down': resume,
'interactions:stop': stop,
'interactions:before-action-resume': arg => {
const {
modification
} = arg.interaction;
modification.stop(arg);
modification.start(arg, arg.interaction.coords.cur.page);
modification.applyToInteraction(arg);
},
'interactions:before-action-inertiastart': arg => arg.interaction.modification.setAndApply(arg),
'interactions:action-resume': modifiers.addEventModifiers,
'interactions:action-inertiastart': modifiers.addEventModifiers,
'interactions:after-action-inertiastart': arg => arg.interaction.modification.restoreInteractionCoords(arg),
'interactions:after-action-resume': arg => arg.interaction.modification.restoreInteractionCoords(arg)
}
}; // http://stackoverflow.com/a/5634528/2280888
function _getQBezierValue(t, p1, p2, p3) {
const iT = 1 - t;
return iT * iT * p1 + 2 * iT * t * p2 + t * t * p3;
}
function getQuadraticCurvePoint(startX, startY, cpX, cpY, endX, endY, position) {
return {
x: _getQBezierValue(position, startX, cpX, endX),
y: _getQBezierValue(position, startY, cpY, endY)
};
} // http://gizma.com/easing/
function easeOutQuad(t, b, c, d) {
t /= d;
return -c * t * (t - 2) + b;
}
export default inertia;
interact.use(plugin);
//# sourceMappingURL=index.js.map

2

index.min.js

@@ -1,2 +0,2 @@

import t from"../modifiers/Modification.min.js";import*as i from"../modifiers/base.min.js";import e from"../offset/index.min.js";import*as s from"../utils/domUtils.min.js";import n from"../utils/hypot.min.js";import*as r from"../utils/is.min.js";import{copyCoords as o}from"../utils/pointerUtils.min.js";import a from"../utils/raf.min.js";export class InertiaState{constructor(t){this.active=!1,this.isModified=!1,this.smoothEnd=!1,this.allowResume=!1,this.modification=null,this.modifierCount=0,this.modifierArg=null,this.startCoords=null,this.t0=0,this.v0=0,this.te=0,this.targetOffset=null,this.modifiedOffset=null,this.currentOffset=null,this.lambda_v0=0,this.one_ve_v0=0,this.timeout=null,this.interaction=void 0,this.interaction=t}start(i){const{interaction:e}=this,s=f(e);if(!s||!s.enabled)return!1;const{client:r}=e.coords.velocity,o=n(r.x,r.y),a=this.modification||(this.modification=new t(e));if(a.copyFrom(e.modification),this.t0=e._now(),this.allowResume=s.allowResume,this.v0=o,this.currentOffset={x:0,y:0},this.startCoords=e.coords.cur.page,this.modifierArg={interaction:e,interactable:e.interactable,element:e.element,rect:e.rect,edges:e.edges,pageCoords:this.startCoords,preEnd:!0,phase:"inertiastart"},this.t0-e.coords.cur.timeStamp<50&&o>s.minSpeed&&o>s.endSpeed)this.startInertia();else{if(a.result=a.setAll(this.modifierArg),!a.result.changed)return!1;this.startSmoothEnd()}return e.modification.result.rect=null,e.offsetBy(this.targetOffset),e._doPhase({interaction:e,event:i,phase:"inertiastart"}),e.offsetBy({x:-this.targetOffset.x,y:-this.targetOffset.y}),e.modification.result.rect=null,this.active=!0,e.simulation=this,!0}startInertia(){const t=this.interaction.coords.velocity.client,i=f(this.interaction),e=i.resistance,s=-Math.log(i.endSpeed/this.v0)/e;this.targetOffset={x:(t.x-s)/e,y:(t.y-s)/e},this.te=s,this.lambda_v0=e/this.v0,this.one_ve_v0=1-i.endSpeed/this.v0;const{modification:n,modifierArg:r}=this;r.pageCoords={x:this.startCoords.x+this.targetOffset.x,y:this.startCoords.y+this.targetOffset.y},n.result=n.setAll(r),n.result.changed&&(this.isModified=!0,this.modifiedOffset={x:this.targetOffset.x+n.result.delta.x,y:this.targetOffset.y+n.result.delta.y}),this.timeout=a.request(()=>this.inertiaTick())}startSmoothEnd(){this.smoothEnd=!0,this.isModified=!0,this.targetOffset={x:this.modification.result.delta.x,y:this.modification.result.delta.y},this.timeout=a.request(()=>this.smoothEndTick())}inertiaTick(){const{interaction:t}=this,i=f(t).resistance,e=(t._now()-this.t0)/1e3;if(e<this.te){const f=1-(Math.exp(-i*e)-this.lambda_v0)/this.one_ve_v0;let u;this.isModified?(s=0,n=0,r=this.targetOffset.x,o=this.targetOffset.y,c=this.modifiedOffset.x,d=this.modifiedOffset.y,u={x:h(m=f,s,r,c),y:h(m,n,o,d)}):u={x:this.targetOffset.x*f,y:this.targetOffset.y*f};const l={x:u.x-this.currentOffset.x,y:u.y-this.currentOffset.y};this.currentOffset.x+=l.x,this.currentOffset.y+=l.y,t.offsetBy(l),t.move(),this.timeout=a.request(()=>this.inertiaTick())}else t.offsetBy({x:this.modifiedOffset.x-this.currentOffset.x,y:this.modifiedOffset.y-this.currentOffset.y}),this.end();var s,n,r,o,c,d,m}smoothEndTick(){const{interaction:t}=this,i=t._now()-this.t0,{smoothEndDuration:e}=f(t);if(i<e){const s={x:d(i,0,this.targetOffset.x,e),y:d(i,0,this.targetOffset.y,e)},n={x:s.x-this.currentOffset.x,y:s.y-this.currentOffset.y};this.currentOffset.x+=n.x,this.currentOffset.y+=n.y,t.offsetBy(n),t.move({skipModifiers:this.modifierCount}),this.timeout=a.request(()=>this.smoothEndTick())}else t.offsetBy({x:this.targetOffset.x-this.currentOffset.x,y:this.targetOffset.y-this.currentOffset.y}),this.end()}resume({pointer:t,event:i,eventTarget:e}){const{interaction:s}=this;s.offsetBy({x:-this.currentOffset.x,y:-this.currentOffset.y}),s.updatePointer(t,i,e,!0),s._doPhase({interaction:s,event:i,phase:"resume"}),o(s.coords.prev,s.coords.cur),this.stop()}end(){this.interaction.move(),this.interaction.end(),this.stop()}stop(){this.active=this.smoothEnd=!1,this.interaction.simulation=null,a.cancel(this.timeout)}}function f({interactable:t,prepared:i}){return t&&t.options&&i.name&&t.options[i.name].inertia}const c={id:"inertia",before:["modifiers/base"],install(t){const{defaults:s}=t;t.usePlugin(e),t.usePlugin(i.default),t.actions.phases.inertiastart=!0,t.actions.phases.resume=!0,s.perAction.inertia={enabled:!1,resistance:10,minSpeed:100,endSpeed:10,allowResume:!0,smoothEndDuration:300}},listeners:{"interactions:new"({interaction:t}){t.inertia=new InertiaState(t)},"interactions:before-action-end"({interaction:t,event:i}){return(!t._interacting||t.simulation||!t.inertia.start(i))&&null},"interactions:down"(t){const{interaction:i,eventTarget:e}=t,n=i.inertia;if(!n.active)return;let o=e;for(;r.element(o);){if(o===i.element){n.resume(t);break}o=s.parentNode(o)}},"interactions:stop"({interaction:t}){const i=t.inertia;i.active&&i.stop()},"interactions:before-action-resume"(t){const{modification:i}=t.interaction;i.stop(t),i.start(t,t.interaction.coords.cur.page),i.applyToInteraction(t)},"interactions:before-action-inertiastart"(t){return t.interaction.modification.setAndApply(t)},"interactions:action-resume":i.addEventModifiers,"interactions:action-inertiastart":i.addEventModifiers,"interactions:after-action-inertiastart"(t){return t.interaction.modification.restoreInteractionCoords(t)},"interactions:after-action-resume"(t){return t.interaction.modification.restoreInteractionCoords(t)}}};function h(t,i,e,s){const n=1-t;return n*n*i+2*n*t*e+t*t*s}function d(t,i,e,s){return-e*(t/=s)*(t-2)+i}export default c;
import e,{init as t}from"../interact/index.min.js";import n from"./plugin.min.js";"object"==typeof window&&window&&t(window),e.__warnedUseImport||(e.__warnedUseImport=!0,console.warn('[interact.js] The "@interactjs/*/index" packages are not quite stable yet. Use them with caution.')),e.use(n);
//# sourceMappingURL=index.min.js.map

17

package.json
{
"name": "@interactjs/inertia",
"version": "1.9.10",
"version": "1.9.11",
"license": "MIT",
"dependencies": {
"@interactjs/offset": "1.9.10"
"@interactjs/offset": "1.9.11"
},
"peerDependencies": {
"@interactjs/core": "1.9.10",
"@interactjs/modifiers": "1.9.10",
"@interactjs/utils": "1.9.10"
"@interactjs/core": "1.9.11",
"@interactjs/modifiers": "1.9.11",
"@interactjs/utils": "1.9.11"
},
"devDependencies": {
"@interactjs/actions": "1.9.10"
},
"optionalDependencies": {
"@interactjs/interact": "1.9.10"
"@interactjs/interact": "1.9.11"
},

@@ -22,3 +19,3 @@ "publishConfig": {

},
"gitHead": "0a55a5d5"
"gitHead": "6b07bf54"
}
use/index.d.ts
use/index.js
use/index.js.map
use/index.min.js
use/index.min.js.map
index.js.map

Sorry, the diff of this file is not supported yet

index.min.js.map

Sorry, the diff of this file is not supported yet

SocketSocket SOC 2 Logo

Product

  • Package Alerts
  • Integrations
  • Docs
  • Pricing
  • FAQ
  • Roadmap
  • Changelog

About

Packages

npm

Go

Maven

PyPI

Rubygems

Stay in touch

Get open source security insights delivered straight into your inbox.

  • Terms
  • Privacy
  • Security

Made with ⚡️ by Socket Inc