@nethesis/phone-island 1.0.9 → 1.0.10-dev.1

package/dist/node_modules/motion-dom/dist/es/animation/generators/spring/find.mjs.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"find.mjs.js","sources":["../../../../../../../../node_modules/motion-dom/dist/es/animation/generators/spring/find.mjs"],"sourcesContent":["import { warning, secondsToMilliseconds, clamp, millisecondsToSeconds } from 'motion-utils';\nimport { springDefaults } from './defaults.mjs';\n\nconst safeMin = 0.001;\nfunction findSpring({ duration = springDefaults.duration, bounce = springDefaults.bounce, velocity = springDefaults.velocity, mass = springDefaults.mass, }) {\n    let envelope;\n    let derivative;\n    warning(duration <= secondsToMilliseconds(springDefaults.maxDuration), \"Spring duration must be 10 seconds or less\");\n    let dampingRatio = 1 - bounce;\n    /**\n     * Restrict dampingRatio and duration to within acceptable ranges.\n     */\n    dampingRatio = clamp(springDefaults.minDamping, springDefaults.maxDamping, dampingRatio);\n    duration = clamp(springDefaults.minDuration, springDefaults.maxDuration, millisecondsToSeconds(duration));\n    if (dampingRatio < 1) {\n        /**\n         * Underdamped spring\n         */\n        envelope = (undampedFreq) => {\n            const exponentialDecay = undampedFreq * dampingRatio;\n            const delta = exponentialDecay * duration;\n            const a = exponentialDecay - velocity;\n            const b = calcAngularFreq(undampedFreq, dampingRatio);\n            const c = Math.exp(-delta);\n            return safeMin - (a / b) * c;\n        };\n        derivative = (undampedFreq) => {\n            const exponentialDecay = undampedFreq * dampingRatio;\n            const delta = exponentialDecay * duration;\n            const d = delta * velocity + velocity;\n            const e = Math.pow(dampingRatio, 2) * Math.pow(undampedFreq, 2) * duration;\n            const f = Math.exp(-delta);\n            const g = calcAngularFreq(Math.pow(undampedFreq, 2), dampingRatio);\n            const factor = -envelope(undampedFreq) + safeMin > 0 ? -1 : 1;\n            return (factor * ((d - e) * f)) / g;\n        };\n    }\n    else {\n        /**\n         * Critically-damped spring\n         */\n        envelope = (undampedFreq) => {\n            const a = Math.exp(-undampedFreq * duration);\n            const b = (undampedFreq - velocity) * duration + 1;\n            return -safeMin + a * b;\n        };\n        derivative = (undampedFreq) => {\n            const a = Math.exp(-undampedFreq * duration);\n            const b = (velocity - undampedFreq) * (duration * duration);\n            return a * b;\n        };\n    }\n    const initialGuess = 5 / duration;\n    const undampedFreq = approximateRoot(envelope, derivative, initialGuess);\n    duration = secondsToMilliseconds(duration);\n    if (isNaN(undampedFreq)) {\n        return {\n            stiffness: springDefaults.stiffness,\n            damping: springDefaults.damping,\n            duration,\n        };\n    }\n    else {\n        const stiffness = Math.pow(undampedFreq, 2) * mass;\n        return {\n            stiffness,\n            damping: dampingRatio * 2 * Math.sqrt(mass * stiffness),\n            duration,\n        };\n    }\n}\nconst rootIterations = 12;\nfunction approximateRoot(envelope, derivative, initialGuess) {\n    let result = initialGuess;\n    for (let i = 1; i < rootIterations; i++) {\n        result = result - envelope(result) / derivative(result);\n    }\n    return result;\n}\nfunction calcAngularFreq(undampedFreq, dampingRatio) {\n    return undampedFreq * Math.sqrt(1 - dampingRatio * dampingRatio);\n}\n\nexport { calcAngularFreq, findSpring };\n"],"names":["safeMin","rootIterations","calcAngularFreq","undampedFreq","dampingRatio","Math","sqrt","_ref","envelope","derivative","duration","springDefaults","bounce","velocity","mass","warning","secondsToMilliseconds","maxDuration","clamp","minDamping","maxDamping","minDuration","millisecondsToSeconds","exponentialDecay","delta","a","b","c","exp","d","e","pow","f","g","initialGuess","result","i","approximateRoot","isNaN","stiffness","damping"],"mappings":"qTAGA,MAAMA,EAAU,KAoEhB,MAAMC,EAAiB,GAQvB,SAASC,EAAgBC,EAAcC,GACnC,OAAOD,EAAeE,KAAKC,KAAK,EAAIF,EAAeA,EACvD,8CA7EA,SAAmBG,GAA0I,IACrJC,EACAC,GAFYC,SAAEA,EAAWC,EAAcA,eAACD,SAAQE,OAAEA,EAASD,EAAcA,eAACC,OAAMC,SAAEA,EAAWF,EAAcA,eAACE,SAAQC,KAAEA,EAAOH,EAAcA,eAACG,MAAOP,EAGvJQ,EAAOA,QAACL,GAAYM,EAAqBA,sBAACL,EAAcA,eAACM,aAAc,8CACvE,IAAIb,EAAe,EAAIQ,EAIvBR,EAAec,EAAKA,MAACP,iBAAeQ,WAAYR,EAAAA,eAAeS,WAAYhB,GAC3EM,EAAWQ,EAAAA,MAAMP,EAAAA,eAAeU,YAAaV,EAAcA,eAACM,YAAaK,EAAAA,sBAAsBZ,IAC3FN,EAAe,GAIfI,EAAYL,IACR,MAAMoB,EAAmBpB,EAAeC,EAClCoB,EAAQD,EAAmBb,EAC3Be,EAAIF,EAAmBV,EACvBa,EAAIxB,EAAgBC,EAAcC,GAClCuB,EAAItB,KAAKuB,KAAKJ,GACpB,OAAOxB,EAAWyB,EAAIC,EAAKC,CAAC,EAEhClB,EAAcN,IACV,MACMqB,EADmBrB,EAAeC,EACPM,EAC3BmB,EAAIL,EAAQX,EAAWA,EACvBiB,EAAIzB,KAAK0B,IAAI3B,EAAc,GAAKC,KAAK0B,IAAI5B,EAAc,GAAKO,EAC5DsB,EAAI3B,KAAKuB,KAAKJ,GACdS,EAAI/B,EAAgBG,KAAK0B,IAAI5B,EAAc,GAAIC,GAErD,QADgBI,EAASL,GAAgBH,EAAU,GAAK,EAAI,KACzC6B,EAAIC,GAAKE,GAAMC,CAAC,IAOvCzB,EAAYL,GACEE,KAAKuB,KAAKzB,EAAeO,KACxBP,EAAeU,GAAYH,EAAW,GAC1C,KAEXD,EAAcN,GACAE,KAAKuB,KAAKzB,EAAeO,IACIA,EAAWA,GAAvCG,EAAWV,KAI9B,MACMA,EAmBV,SAAyBK,EAAUC,EAAYyB,GAC3C,IAAIC,EAASD,EACb,IAAK,IAAIE,EAAI,EAAGA,EAAInC,EAAgBmC,IAChCD,GAAkB3B,EAAS2B,GAAU1B,EAAW0B,GAEpD,OAAOA,CACX,CAzByBE,CAAgB7B,EAAUC,EAD1B,EAAIC,GAGzB,GADAA,EAAWM,EAAAA,sBAAsBN,GAC7B4B,MAAMnC,GACN,MAAO,CACHoC,UAAW5B,EAAcA,eAAC4B,UAC1BC,QAAS7B,EAAcA,eAAC6B,QACxB9B,YAGH,CACD,MAAM6B,EAAYlC,KAAK0B,IAAI5B,EAAc,GAAKW,EAC9C,MAAO,CACHyB,YACAC,QAAwB,EAAfpC,EAAmBC,KAAKC,KAAKQ,EAAOyB,GAC7C7B,WAER,CACJ"}

package/dist/node_modules/motion-dom/dist/es/animation/generators/spring/index.mjs.js

@@ -1,2 +0,0 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:!0});var e=require("../../waapi/utils/linear.mjs.js"),s=require("../utils/calc-duration.mjs.js"),t=require("../utils/create-generator-easing.mjs.js"),n=require("../utils/velocity.mjs.js"),a=require("./defaults.mjs.js"),i=require("./find.mjs.js"),r=require("../../../../../../motion-utils/dist/es/time-conversion.mjs.js"),o=require("../../../../../../motion-utils/dist/es/clamp.mjs.js");const l=["duration","bounce"],u=["stiffness","damping","mass"];function c(e,s){return s.some((s=>void 0!==e[s]))}function f(){let t=arguments.length>0&&void 0!==arguments[0]?arguments[0]:a.springDefaults.visualDuration,f=arguments.length>1&&void 0!==arguments[1]?arguments[1]:a.springDefaults.bounce;const d="object"!=typeof t?{visualDuration:t,keyframes:[0,1],bounce:f}:t;let{restSpeed:m,restDelta:p}=d;const g=d.keyframes[0],D=d.keyframes[d.keyframes.length-1],h={done:!1,value:g},{stiffness:v,damping:M,mass:j,duration:y,velocity:q,isResolvedFromDuration:b}=function(e){let s={velocity:a.springDefaults.velocity,stiffness:a.springDefaults.stiffness,damping:a.springDefaults.damping,mass:a.springDefaults.mass,isResolvedFromDuration:!1,...e};if(!c(e,u)&&c(e,l))if(e.visualDuration){const t=e.visualDuration,n=2*Math.PI/(1.2*t),i=n*n,r=2*o.clamp(.05,1,1-(e.bounce||0))*Math.sqrt(i);s={...s,mass:a.springDefaults.mass,stiffness:i,damping:r}}else{const t=i.findSpring(e);s={...s,...t,mass:a.springDefaults.mass},s.isResolvedFromDuration=!0}return s}({...d,velocity:-r.millisecondsToSeconds(d.velocity||0)}),x=q||0,S=M/(2*Math.sqrt(v*j)),T=D-g,k=r.millisecondsToSeconds(Math.sqrt(v/j)),F=Math.abs(T)<5;let G;if(m||(m=F?a.springDefaults.restSpeed.granular:a.springDefaults.restSpeed.default),p||(p=F?a.springDefaults.restDelta.granular:a.springDefaults.restDelta.default),S<1){const e=i.calcAngularFreq(k,S);G=s=>{const t=Math.exp(-S*k*s);return D-t*((x+S*k*T)/e*Math.sin(e*s)+T*Math.cos(e*s))}}else if(1===S)G=e=>D-Math.exp(-k*e)*(T+(x+k*T)*e);else{const e=k*Math.sqrt(S*S-1);G=s=>{const t=Math.exp(-S*k*s),n=Math.min(e*s,300);return D-t*((x+S*k*T)*Math.sinh(n)+e*T*Math.cosh(n))/e}}const R={calculatedDuration:b&&y||null,next:e=>{const s=G(e);if(b)h.done=e>=y;else{let t=0===e?x:0;S<1&&(t=0===e?r.secondsToMilliseconds(x):n.calcGeneratorVelocity(G,e,s));const a=Math.abs(t)<=m,i=Math.abs(D-s)<=p;h.done=a&&i}return h.value=h.done?D:s,h},toString:()=>{const t=Math.min(s.calcGeneratorDuration(R),s.maxGeneratorDuration),n=e.generateLinearEasing((e=>R.next(t*e).value),t,30);return t+"ms "+n},toTransition:()=>{}};return R}f.applyToOptions=e=>{const s=t.createGeneratorEasing(e,100,f);return e.ease=s.ease,e.duration=r.secondsToMilliseconds(s.duration),e.type="keyframes",e},exports.spring=f;
-//# sourceMappingURL=index.mjs.js.map

package/dist/node_modules/motion-dom/dist/es/animation/generators/spring/index.mjs.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.mjs.js","sources":["../../../../../../../../node_modules/motion-dom/dist/es/animation/generators/spring/index.mjs"],"sourcesContent":["import { millisecondsToSeconds, secondsToMilliseconds, clamp } from 'motion-utils';\nimport { generateLinearEasing } from '../../waapi/utils/linear.mjs';\nimport { calcGeneratorDuration, maxGeneratorDuration } from '../utils/calc-duration.mjs';\nimport { createGeneratorEasing } from '../utils/create-generator-easing.mjs';\nimport { calcGeneratorVelocity } from '../utils/velocity.mjs';\nimport { springDefaults } from './defaults.mjs';\nimport { findSpring, calcAngularFreq } from './find.mjs';\n\nconst durationKeys = [\"duration\", \"bounce\"];\nconst physicsKeys = [\"stiffness\", \"damping\", \"mass\"];\nfunction isSpringType(options, keys) {\n    return keys.some((key) => options[key] !== undefined);\n}\nfunction getSpringOptions(options) {\n    let springOptions = {\n        velocity: springDefaults.velocity,\n        stiffness: springDefaults.stiffness,\n        damping: springDefaults.damping,\n        mass: springDefaults.mass,\n        isResolvedFromDuration: false,\n        ...options,\n    };\n    // stiffness/damping/mass overrides duration/bounce\n    if (!isSpringType(options, physicsKeys) &&\n        isSpringType(options, durationKeys)) {\n        if (options.visualDuration) {\n            const visualDuration = options.visualDuration;\n            const root = (2 * Math.PI) / (visualDuration * 1.2);\n            const stiffness = root * root;\n            const damping = 2 *\n                clamp(0.05, 1, 1 - (options.bounce || 0)) *\n                Math.sqrt(stiffness);\n            springOptions = {\n                ...springOptions,\n                mass: springDefaults.mass,\n                stiffness,\n                damping,\n            };\n        }\n        else {\n            const derived = findSpring(options);\n            springOptions = {\n                ...springOptions,\n                ...derived,\n                mass: springDefaults.mass,\n            };\n            springOptions.isResolvedFromDuration = true;\n        }\n    }\n    return springOptions;\n}\nfunction spring(optionsOrVisualDuration = springDefaults.visualDuration, bounce = springDefaults.bounce) {\n    const options = typeof optionsOrVisualDuration !== \"object\"\n        ? {\n            visualDuration: optionsOrVisualDuration,\n            keyframes: [0, 1],\n            bounce,\n        }\n        : optionsOrVisualDuration;\n    let { restSpeed, restDelta } = options;\n    const origin = options.keyframes[0];\n    const target = options.keyframes[options.keyframes.length - 1];\n    /**\n     * This is the Iterator-spec return value. We ensure it's mutable rather than using a generator\n     * to reduce GC during animation.\n     */\n    const state = { done: false, value: origin };\n    const { stiffness, damping, mass, duration, velocity, isResolvedFromDuration, } = getSpringOptions({\n        ...options,\n        velocity: -millisecondsToSeconds(options.velocity || 0),\n    });\n    const initialVelocity = velocity || 0.0;\n    const dampingRatio = damping / (2 * Math.sqrt(stiffness * mass));\n    const initialDelta = target - origin;\n    const undampedAngularFreq = millisecondsToSeconds(Math.sqrt(stiffness / mass));\n    /**\n     * If we're working on a granular scale, use smaller defaults for determining\n     * when the spring is finished.\n     *\n     * These defaults have been selected emprically based on what strikes a good\n     * ratio between feeling good and finishing as soon as changes are imperceptible.\n     */\n    const isGranularScale = Math.abs(initialDelta) < 5;\n    restSpeed || (restSpeed = isGranularScale\n        ? springDefaults.restSpeed.granular\n        : springDefaults.restSpeed.default);\n    restDelta || (restDelta = isGranularScale\n        ? springDefaults.restDelta.granular\n        : springDefaults.restDelta.default);\n    let resolveSpring;\n    if (dampingRatio < 1) {\n        const angularFreq = calcAngularFreq(undampedAngularFreq, dampingRatio);\n        // Underdamped spring\n        resolveSpring = (t) => {\n            const envelope = Math.exp(-dampingRatio * undampedAngularFreq * t);\n            return (target -\n                envelope *\n                    (((initialVelocity +\n                        dampingRatio * undampedAngularFreq * initialDelta) /\n                        angularFreq) *\n                        Math.sin(angularFreq * t) +\n                        initialDelta * Math.cos(angularFreq * t)));\n        };\n    }\n    else if (dampingRatio === 1) {\n        // Critically damped spring\n        resolveSpring = (t) => target -\n            Math.exp(-undampedAngularFreq * t) *\n                (initialDelta +\n                    (initialVelocity + undampedAngularFreq * initialDelta) * t);\n    }\n    else {\n        // Overdamped spring\n        const dampedAngularFreq = undampedAngularFreq * Math.sqrt(dampingRatio * dampingRatio - 1);\n        resolveSpring = (t) => {\n            const envelope = Math.exp(-dampingRatio * undampedAngularFreq * t);\n            // When performing sinh or cosh values can hit Infinity so we cap them here\n            const freqForT = Math.min(dampedAngularFreq * t, 300);\n            return (target -\n                (envelope *\n                    ((initialVelocity +\n                        dampingRatio * undampedAngularFreq * initialDelta) *\n                        Math.sinh(freqForT) +\n                        dampedAngularFreq *\n                            initialDelta *\n                            Math.cosh(freqForT))) /\n                    dampedAngularFreq);\n        };\n    }\n    const generator = {\n        calculatedDuration: isResolvedFromDuration ? duration || null : null,\n        next: (t) => {\n            const current = resolveSpring(t);\n            if (!isResolvedFromDuration) {\n                let currentVelocity = t === 0 ? initialVelocity : 0.0;\n                /**\n                 * We only need to calculate velocity for under-damped springs\n                 * as over- and critically-damped springs can't overshoot, so\n                 * checking only for displacement is enough.\n                 */\n                if (dampingRatio < 1) {\n                    currentVelocity =\n                        t === 0\n                            ? secondsToMilliseconds(initialVelocity)\n                            : calcGeneratorVelocity(resolveSpring, t, current);\n                }\n                const isBelowVelocityThreshold = Math.abs(currentVelocity) <= restSpeed;\n                const isBelowDisplacementThreshold = Math.abs(target - current) <= restDelta;\n                state.done =\n                    isBelowVelocityThreshold && isBelowDisplacementThreshold;\n            }\n            else {\n                state.done = t >= duration;\n            }\n            state.value = state.done ? target : current;\n            return state;\n        },\n        toString: () => {\n            const calculatedDuration = Math.min(calcGeneratorDuration(generator), maxGeneratorDuration);\n            const easing = generateLinearEasing((progress) => generator.next(calculatedDuration * progress).value, calculatedDuration, 30);\n            return calculatedDuration + \"ms \" + easing;\n        },\n        toTransition: () => { },\n    };\n    return generator;\n}\nspring.applyToOptions = (options) => {\n    const generatorOptions = createGeneratorEasing(options, 100, spring);\n    options.ease = generatorOptions.ease;\n    options.duration = secondsToMilliseconds(generatorOptions.duration);\n    options.type = \"keyframes\";\n    return options;\n};\n\nexport { spring };\n"],"names":["durationKeys","physicsKeys","isSpringType","options","keys","some","key","undefined","spring","optionsOrVisualDuration","arguments","length","springDefaults","visualDuration","bounce","keyframes","restSpeed","restDelta","origin","target","state","done","value","stiffness","damping","mass","duration","velocity","isResolvedFromDuration","springOptions","root","Math","PI","clamp","sqrt","derived","findSpring","getSpringOptions","millisecondsToSeconds","initialVelocity","dampingRatio","initialDelta","undampedAngularFreq","isGranularScale","abs","resolveSpring","granular","default","angularFreq","calcAngularFreq","t","envelope","exp","sin","cos","dampedAngularFreq","freqForT","min","sinh","cosh","generator","calculatedDuration","next","current","currentVelocity","secondsToMilliseconds","calcGeneratorVelocity","isBelowVelocityThreshold","isBelowDisplacementThreshold","toString","calcGeneratorDuration","maxGeneratorDuration","easing","generateLinearEasing","progress","toTransition","applyToOptions","generatorOptions","createGeneratorEasing","ease","type"],"mappings":"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"}