@verdocs/web-sdk 6.10.4 → 6.10.6

package/dist/esm/verdocs-status-indicator.entry.js

@@ -4476,7 +4476,6 @@ const Animator = {
 	timeouts: new Queue(),
 	immediates: new Queue(),
 	timer: () => globals.window.performance || globals.window.Date,
-	transforms: [],
 	frame(fn) {
 		const node = Animator.frames.push({ run: fn });
 		if (Animator.nextDraw === null) Animator.nextDraw = globals.window.requestAnimationFrame(Animator._draw);
@@ -4553,7 +4552,12 @@ var Timeline = class extends EventTarget {
 		return !!this._nextFrame;
 	}
 	finish() {
-		this.time(this.getEndTimeOfTimeline() + 1);
+		this._finishing = true;
+		try {
+			this.time(this.getEndTimeOfTimeline() + 1);
+		} finally {
+			this._finishing = false;
+		}
 		return this.pause();
 	}
 	getEndTime() {
@@ -4612,6 +4616,7 @@ var Timeline = class extends EventTarget {
 		} else throw new Error("Invalid value for the \"when\" parameter");
 		runner.unschedule();
 		runner.timeline(this);
+		runner._retired = false;
 		const persist = runner.persist();
 		const runnerInfo = {
 			persist: persist === null ? this._persist : persist,
@@ -4619,6 +4624,7 @@ var Timeline = class extends EventTarget {
 			runner
 		};
 		this._lastRunnerId = runner.id;
+		runner._runnerInfo = runnerInfo;
 		this._runners.push(runnerInfo);
 		this._runners.sort((a, b) => a.start - b.start);
 		this._runnerIds = this._runners.map((info) => info.runner.id);
@@ -4653,6 +4659,8 @@ var Timeline = class extends EventTarget {
 		this._runners.splice(index, 1);
 		this._runnerIds.splice(index, 1);
 		runner.timeline(null);
+		runner._runnerInfo = null;
+		runner._retired = true;
 		return this;
 	}
 	updateTime() {
@@ -4668,6 +4676,7 @@ var Timeline = class extends EventTarget {
 		return this;
 	}
 	_stepFn(immediateStep = false) {
+		const generation = this._generation;
 		const time = this._timeSource();
 		let dtSource = time - this._lastSourceTime;
 		if (immediateStep) dtSource = 0;
@@ -4679,31 +4688,37 @@ var Timeline = class extends EventTarget {
 		}
 		this._lastStepTime = this._time;
 		this.fire("time", this._time);
-		for (let k = this._runners.length; k--;) {
-			const runnerInfo = this._runners[k];
+		const scheduled = this._runners.slice();
+		for (let k = scheduled.length; k--;) {
+			const runnerInfo = scheduled[k];
+			if (runnerInfo.runner._runnerInfo !== runnerInfo) continue;
 			const runner = runnerInfo.runner;
-			if (this._time - runnerInfo.start <= 0) runner.reset();
+			if (this._time - runnerInfo.start < 0) runner.reset(true);
 		}
 		let runnersLeft = false;
-		for (let i = 0, len = this._runners.length; i < len; i++) {
-			const runnerInfo = this._runners[i];
+		for (const runnerInfo of this._runners.slice()) {
+			if (runnerInfo.runner._runnerInfo !== runnerInfo) continue;
 			const runner = runnerInfo.runner;
 			let dt = dtTime;
 			const dtToStart = this._time - runnerInfo.start;
-			if (dtToStart <= 0) {
+			if (dtToStart < 0) {
+				runnersLeft = true;
+				continue;
+			} else if (dtToStart === 0) {
+				runner.reset();
 				runnersLeft = true;
 				continue;
 			} else if (dtToStart < dt) dt = dtToStart;
 			if (!runner.active()) continue;
-			if (!runner.step(dt).done) runnersLeft = true;
+			const finished = (this._finishing && runner._isDeclarative ? runner.finish() : runner.step(dt)).done;
+			if (runner._runnerInfo !== runnerInfo) continue;
+			if (!finished) runnersLeft = true;
 			else if (runnerInfo.persist !== true) {
-				if (runner.duration() - runner.time() + this._time + runnerInfo.persist < this._time) {
-					runner.unschedule();
-					--i;
-					--len;
-				}
+				if (runner.duration() - runner.time() + this._time + runnerInfo.persist <= this._time) runner.unschedule();
 			}
 		}
+		if (generation !== this._generation) return this;
+		if (!runnersLeft) runnersLeft = this._runners.some(({ start, runner }) => start >= this._time || runner.active() && !runner.done);
 		if (runnersLeft && !(this._speed < 0 && this._time === 0) || this._runnerIds.length && this._speed < 0 && this._time > 0) this._continue();
 		else {
 			this.pause();
@@ -4712,11 +4727,18 @@ var Timeline = class extends EventTarget {
 		return this;
 	}
 	terminate() {
+		Animator.cancelFrame(this._nextFrame);
+		this._generation = (this._generation || 0) + 1;
 		this._startTime = 0;
 		this._speed = 1;
 		this._persist = 0;
+		for (const { runner } of this._runners || []) {
+			runner._retired = true;
+			runner._runnerInfo = null;
+		}
 		this._nextFrame = null;
 		this._paused = true;
+		this._finishing = false;
 		this._runners = [];
 		this._runnerIds = [];
 		this._lastRunnerId = -1;
@@ -4747,6 +4769,7 @@ var Runner = class Runner extends EventTarget {
 		options = typeof options === "function" ? new Controller(options) : options;
 		this._element = null;
 		this._timeline = null;
+		this._runnerInfo = null;
 		this.done = false;
 		this._queue = [];
 		this._duration = typeof options === "number" && options;
@@ -4758,14 +4781,15 @@ var Runner = class Runner extends EventTarget {
 		this._lastTime = 0;
 		this._reseted = true;
 		this.transforms = new Matrix();
-		this.transformId = 1;
-		this._haveReversed = false;
+		this._isAbsoluteTransform = false;
+		this._hasTransform = false;
+		this._transformInitialised = false;
+		this._transformActive = false;
+		this._retired = false;
 		this._reverse = false;
-		this._loopsDone = 0;
 		this._swing = false;
 		this._wait = 0;
 		this._times = 1;
-		this._frameId = null;
 		this._persist = this._isDeclarative ? true : null;
 	}
 	static sanitise(duration, delay, when) {
@@ -4799,6 +4823,8 @@ var Runner = class Runner extends EventTarget {
 	}
 	addTransform(transform) {
 		this.transforms.lmultiplyO(transform);
+		this._transformInitialised = true;
+		this._transformActive = true;
 		return this;
 	}
 	after(fn) {
@@ -4815,12 +4841,6 @@ var Runner = class Runner extends EventTarget {
 		this.transforms = new Matrix();
 		return this;
 	}
-	clearTransformsFromQueue() {
-		var _context;
-		if (!this.done || !this._timeline || !(0, import_includes.default)(_context = this._timeline._runnerIds).call(_context, this.id)) this._queue = this._queue.filter((item) => {
-			return !item.isTransform;
-		});
-	}
 	delay(delay) {
 		return this.animate(0, delay);
 	}
@@ -4841,7 +4861,11 @@ var Runner = class Runner extends EventTarget {
 		return this;
 	}
 	finish() {
-		return this.step(Infinity);
+		if (!this._isDeclarative) return this.time(this.duration());
+		const time = this._time;
+		this.step(Infinity);
+		this._time = time;
+		return this;
 	}
 	loop(times, swing, wait) {
 		if (typeof times === "object") {
@@ -4901,6 +4925,7 @@ var Runner = class Runner extends EventTarget {
 		return this.time(p * this.duration());
 	}
 	queue(initFn, runFn, retargetFn, isTransform) {
+		if (this._isDeclarative) this.done = false;
 		this._queue.push({
 			initialiser: initFn || noop,
 			runner: runFn || noop,
@@ -4912,10 +4937,28 @@ var Runner = class Runner extends EventTarget {
 		this.timeline() && this.timeline()._continue();
 		return this;
 	}
-	reset() {
-		if (this._reseted) return this;
-		this.time(0);
-		this._reseted = true;
+	reset(deactivateTransform = false) {
+		if (this._reseted) {
+			const transformActive = !deactivateTransform && this._hasTransform && this.position() !== 0;
+			if (transformActive && !this._transformInitialised) {
+				this.step(0);
+				this._reseted = true;
+				return this;
+			}
+			if (transformActive !== this._transformActive) {
+				this._transformActive = transformActive;
+				this._element && this._element._addRunner(this);
+			}
+			return this;
+		}
+		if (!this._reseted) {
+			this.time(0);
+			this._reseted = true;
+		}
+		if (deactivateTransform && this._transformActive) {
+			this._transformActive = false;
+			this._element && this._element._addRunner(this);
+		}
 		return this;
 	}
 	reverse(reverse) {
@@ -4934,6 +4977,7 @@ var Runner = class Runner extends EventTarget {
 	}
 	step(dt) {
 		if (!this.enabled) return this;
+		const wasDone = this.done;
 		dt = dt == null ? 16 : dt;
 		this._time += dt;
 		const position = this.position();
@@ -4941,21 +4985,23 @@ var Runner = class Runner extends EventTarget {
 		this._lastPosition = position;
 		const duration = this.duration();
 		const justStarted = this._lastTime <= 0 && this._time > 0;
-		const justFinished = this._lastTime < duration && this._time >= duration;
 		this._lastTime = this._time;
 		if (justStarted) this.fire("start", this);
 		const declarative = this._isDeclarative;
-		this.done = !declarative && !justFinished && this._time >= duration;
+		this.done = !declarative && this._time >= duration;
 		this._reseted = false;
+		const transformActive = this._hasTransform && (this._time > 0 || position !== 0);
+		this._transformActive = transformActive;
 		let converged = false;
 		if (running || declarative) {
 			this._initialise(running);
 			this.transforms = new Matrix();
 			converged = this._run(declarative ? dt : position);
+			this._transformActive = transformActive;
 			this.fire("step", this);
 		}
 		this.done = this.done || converged && declarative;
-		if (justFinished) this.fire("finished", this);
+		if (this.done && !wasDone) this.fire("finished", this);
 		return this;
 	}
 	time(time) {
@@ -5000,6 +5046,7 @@ var Runner = class Runner extends EventTarget {
 		let allfinished = true;
 		for (let i = 0, len = this._queue.length; i < len; ++i) {
 			const current = this._queue[i];
+			if (this._isDeclarative && current.finished && !current.isTransform) continue;
 			const converged = current.runner.call(this, positionOrDt);
 			current.finished = current.finished || converged === true;
 			allfinished = allfinished && current.finished;
@@ -5016,6 +5063,7 @@ var Runner = class Runner extends EventTarget {
 			if (this._history[method].caller.retarget) this._history[method].caller.retarget.call(this, target, extra);
 			else this._history[method].morpher.to(target);
 			this._history[method].caller.finished = false;
+			if (this._isDeclarative) this.done = false;
 			const timeline = this.timeline();
 			timeline && timeline.play();
 			return true;
@@ -5025,20 +5073,29 @@ var Runner = class Runner extends EventTarget {
 };
 Runner.id = 0;
 var FakeRunner = class {
-	constructor(transforms = new Matrix(), id = -1, done = true) {
+	constructor(transforms = new Matrix(), id = -1, done = true, isAbsoluteTransform = false) {
 		this.transforms = transforms;
 		this.id = id;
 		this.done = done;
+		this._isAbsoluteTransform = isAbsoluteTransform;
+		this._transformActive = true;
+		this._retired = true;
 	}
-	clearTransformsFromQueue() {}
 };
 extend([Runner, FakeRunner], { mergeWith(runner) {
-	return new FakeRunner(runner.transforms.lmultiply(this.transforms), runner.id);
+	return new FakeRunner(this._isAbsoluteTransform ? this.transforms : runner.transforms.lmultiply(this.transforms), runner.id, true, runner._isAbsoluteTransform || this._isAbsoluteTransform);
 } });
 const lmultiply = (last, curr) => last.lmultiplyO(curr);
 const getRunnerTransform = (runner) => runner.transforms;
+const isActiveTransform = (runner) => runner._transformActive;
+function activeTransformRunners(runners) {
+	const activeRunners = runners.filter(isActiveTransform);
+	let firstRunner = 0;
+	for (let i = 0; i < activeRunners.length; ++i) if (activeRunners[i]._isAbsoluteTransform) firstRunner = i;
+	return activeRunners.slice(firstRunner);
+}
 function mergeTransforms() {
-	const netTransform = this._transformationRunners.runners.map(getRunnerTransform).reduce(lmultiply, new Matrix());
+	const netTransform = activeTransformRunners(this._transformationRunners.runners).map(getRunnerTransform).reduce(lmultiply, new Matrix());
 	this.transform(netTransform);
 	this._transformationRunners.merge();
 	if (this._transformationRunners.length() === 1) this._frameId = null;
@@ -5046,40 +5103,29 @@ function mergeTransforms() {
 var RunnerArray = class {
 	constructor() {
 		this.runners = [];
-		this.ids = [];
 	}
 	add(runner) {
-		var _context2;
-		if ((0, import_includes.default)(_context2 = this.runners).call(_context2, runner)) return;
-		const id = runner.id + 1;
+		var _context;
+		if ((0, import_includes.default)(_context = this.runners).call(_context, runner)) return;
 		this.runners.push(runner);
-		this.ids.push(id);
-		return this;
-	}
-	clearBefore(id) {
-		const deleteCnt = this.ids.indexOf(id + 1) || 1;
-		this.ids.splice(0, deleteCnt, 0);
-		this.runners.splice(0, deleteCnt, new FakeRunner()).forEach((r) => r.clearTransformsFromQueue());
 		return this;
 	}
 	edit(id, newRunner) {
-		const index = this.ids.indexOf(id + 1);
-		this.ids.splice(index, 1, id + 1);
-		this.runners.splice(index, 1, newRunner);
+		const index = this.runners.findIndex((runner) => runner.id === id);
+		if (index >= 0) this.runners.splice(index, 1, newRunner);
 		return this;
 	}
 	getByID(id) {
-		return this.runners[this.ids.indexOf(id + 1)];
+		return this.runners.find((runner) => runner.id === id);
 	}
 	length() {
-		return this.ids.length;
+		return this.runners.length;
 	}
 	merge() {
 		let lastRunner = null;
 		for (let i = 0; i < this.runners.length; ++i) {
-			var _context3, _context4;
 			const runner = this.runners[i];
-			if (lastRunner && runner.done && lastRunner.done && (!runner._timeline || !(0, import_includes.default)(_context3 = runner._timeline._runnerIds).call(_context3, runner.id)) && (!lastRunner._timeline || !(0, import_includes.default)(_context4 = lastRunner._timeline._runnerIds).call(_context4, lastRunner.id))) {
+			if (lastRunner && runner.done && lastRunner.done && runner._retired && lastRunner._retired) {
 				this.remove(runner.id);
 				const newRunner = runner.mergeWith(lastRunner);
 				this.edit(lastRunner.id, newRunner);
@@ -5090,9 +5136,8 @@ var RunnerArray = class {
 		return this;
 	}
 	remove(id) {
-		const index = this.ids.indexOf(id + 1);
-		this.ids.splice(index, 1);
-		this.runners.splice(index, 1);
+		const index = this.runners.findIndex((runner) => runner.id === id);
+		if (index >= 0) this.runners.splice(index, 1);
 		return this;
 	}
 };
@@ -5105,13 +5150,13 @@ registerMethods({ Element: {
 	delay(by, when) {
 		return this.animate(0, by, when);
 	},
-	_clearTransformRunnersBefore(currentRunner) {
-		this._transformationRunners.clearBefore(currentRunner.id);
-	},
 	_currentTransform(current) {
-		return this._transformationRunners.runners.filter((runner) => runner.id <= current.id).map(getRunnerTransform).reduce(lmultiply, new Matrix());
+		const runners = this._transformationRunners.runners;
+		const currentIndex = runners.indexOf(current);
+		return activeTransformRunners(runners.slice(0, currentIndex + 1)).map(getRunnerTransform).reduce(lmultiply, new Matrix());
 	},
 	_addRunner(runner) {
+		if (this._transformationRunners.length() === 1 && this._transformationRunners.runners[0].id === -1) this._transformationRunners.runners[0].transforms = new Matrix(this);
 		this._transformationRunners.add(runner);
 		Animator.cancelImmediate(this._frameId);
 		this._frameId = Animator.immediate(mergeTransforms.bind(this));
@@ -5180,10 +5225,13 @@ extend(Runner, {
 	**/
 	transform(transforms, relative, affine) {
 		relative = transforms.relative || relative;
+		this._hasTransform = true;
+		this._isAbsoluteTransform = this._isAbsoluteTransform || !relative;
 		if (this._isDeclarative && !relative && this._tryRetarget("transform", transforms)) return this;
 		const isMatrix = Matrix.isMatrixLike(transforms);
 		affine = transforms.affine != null ? transforms.affine : affine != null ? affine : !isMatrix;
 		const morpher = new Morphable(this._stepper).type(affine ? TransformBag : Matrix);
+		const matrixMorpher = affine ? new Morphable(this._stepper).type(Matrix) : morpher;
 		let origin;
 		let element;
 		let current;
@@ -5194,7 +5242,6 @@ extend(Runner, {
 			origin = origin || getOrigin(transforms, element);
 			startTransform = new Matrix(relative ? void 0 : element);
 			element._addRunner(this);
-			if (!relative) element._clearTransformRunnersBefore(this);
 		}
 		function run(pos) {
 			if (!relative) this.clearTransform();
@@ -5206,40 +5253,43 @@ extend(Runner, {
 			if (targetTransforms.relative === true) delete targetTransforms.relative;
 			let target = new Matrix(targetTransforms);
 			let start = this._isDeclarative && current ? current : startTransform;
+			let activeMorpher = morpher;
 			if (affine) {
-				target = target.decompose(x, y);
-				start = start.decompose(x, y);
-				const rTarget = target.rotate;
-				const rCurrent = start.rotate;
-				const possibilities = [
-					rTarget - 360,
-					rTarget,
-					rTarget + 360
-				];
-				const distances = possibilities.map((a) => Math.abs(a - rCurrent));
-				const shortest = Math.min(...distances);
-				const index = distances.indexOf(shortest);
-				target.rotate = possibilities[index];
+				const targetParameters = target.decompose(x, y);
+				const startParameters = start.decompose(x, y);
+				if (!new TransformBag(targetParameters).toArray().concat(new TransformBag(startParameters).toArray()).every(Number.isFinite)) activeMorpher = matrixMorpher;
+				else {
+					target = targetParameters;
+					start = startParameters;
+					const rTarget = target.rotate;
+					const rCurrent = start.rotate;
+					const possibilities = [
+						rTarget - 360,
+						rTarget,
+						rTarget + 360
+					];
+					const distances = possibilities.map((a) => Math.abs(a - rCurrent));
+					const shortest = Math.min(...distances);
+					const index = distances.indexOf(shortest);
+					target.rotate = possibilities[index];
+				}
 			}
-			if (relative) {
+			if (relative && activeMorpher === morpher) {
 				if (!isMatrix) target.rotate = transforms.rotate || 0;
 				if (this._isDeclarative && currentAngle) start.rotate = currentAngle;
 			}
-			morpher.from(start);
-			morpher.to(target);
-			const affineParameters = morpher.at(pos);
+			activeMorpher.from(start);
+			activeMorpher.to(target);
+			const affineParameters = activeMorpher.at(pos);
 			currentAngle = affineParameters.rotate;
 			current = new Matrix(affineParameters);
 			this.addTransform(current);
 			element._addRunner(this);
-			return morpher.done();
+			return activeMorpher.done();
 		}
 		function retarget(newTransforms) {
-			if ((newTransforms.origin || "center").toString() !== (transforms.origin || "center").toString()) origin = getOrigin(newTransforms, element);
-			transforms = {
-				...newTransforms,
-				origin
-			};
+			origin = getOrigin(newTransforms, element);
+			transforms = { ...newTransforms };
 		}
 		this.queue(setup, run, retarget, true);
 		this._isDeclarative && this._rememberMorpher("transform", morpher);