Tween factory

import { animationtickers, constructors } from '../core/library.js';

import { convertTime, doCreate, easeEngines, isa_fn, mergeOver, pushUnique, xt, xtGet, xto, λnull, Ωempty } from '../helper/utilities.js';

import { makeTicker } from './ticker.js';

import baseMix from '../mixin/base.js';
import tweenMix from '../mixin/tween.js';

import { _isArray, _keys, _round, FUNCTION, LINEAR, NAME, PC, T_GROUP, T_TICKER, T_TWEEN, TWEEN, UNDEF, ZERO_STR } from '../helper/shared-vars.js';

const setObjectsHold = {};

const getSetObjectKey = (defs) => {

    if (!defs || !defs.length) return '|';

    return '|' + defs.map(d => d.attribute).join('|') + '|';
};

const getSetObject = (key) => {

    if (setObjectsHold[key]) return setObjectsHold[key];

    if (key.substring) {

        setObjectsHold[key] = {};
        return setObjectsHold[key];
    }
    return {};
};

const Tween = function (items = Ωempty) {

    this.makeName(items.name);
    this.register();

    this.targets = [];
    this.definitions = [];

    this.set(this.defs);

    const t = items.ticker;
    if (t && !t.substring && t.name && t.type === T_TICKER) items.ticker = t.name;

    this.set(items);

    this.setObj = getSetObjectKey(this.definitions);

    this.status = -1;
    this.calculateEffectiveTime();
    this.calculateEffectiveDuration();

    if (animationtickers[items.ticker]) this.addToTicker(items.ticker);
    else {

        const tn = `${this.name}_ticker`;

        makeTicker({
            name: tn,
            order: this.order,
            subscribers: this.name,
            duration: this.effectiveDuration,
            cycles: xtGet(items.cycles, 1),
            killOnComplete: xtGet(items.killOnComplete, false),
            observer: items.observer,
        });

        this.ticker = tn;

        animationtickers[tn].recalculateEffectiveDuration();
    }
    return this;
};

const P = Tween.prototype = doCreate();
P.type = T_TWEEN;
P.lib = TWEEN;
P.isArtefact = false;
P.isAsset = false;

baseMix(P);
tweenMix(P);

const defaultAttributes = {

    duration: 0,

    killOnComplete: false,

    commenceAction: null,
    onRun: null,
    onHalt: null,
    onResume: null,
    onReverse: null,
    onSeekTo: null,
    onSeekFor: null,
    completeAction: null,

};
P.defs = mergeOver(P.defs, defaultAttributes);

P.packetExclusions = pushUnique(P.packetExclusions, ['definitions', 'targets']);
P.packetFunctions = pushUnique(P.packetFunctions, ['commenceAction', 'completeAction', 'onRun', 'onHalt', 'onResume', 'onReverse', 'onSeekTo', 'onSeekFor', 'action']);

P.finalizePacketOut = function (copy) {

    copy.targets = this.targets.map(t => t.name);

    copy.definitions = this.definitions.map(d => {

        const res = {};
        res.attribute = d.attribute;
        res.start = d.start;
        res.end = d.end;

        if (d.engine && d.engine.substring) res.engine = d.engine;
        else {

            if (xt(d.engine) && d.engine != null) {

                const e = this.stringifyFunction(d.engine);

                if (e) {

                    res.engine = e;
                    res.engineIsFunction = true;
                }
            }
        }
        return res;
    });
    return copy;
};

P.postCloneAction = function(clone, items) {

    if (items.useNewTicker) {

        const ticker = animationtickers[this.ticker];

        if (xt(items.cycles)) clone.cycles = items.cycles;
        else if (ticker) clone.cycles = ticker.cycles;
        else clone.cycles = 1;

        const cloneTicker = animationtickers[clone.ticker];
        cloneTicker.cycles = clone.cycles;

        if (xt(items.duration)) {

            clone.duration = items.duration;
            clone.calculateEffectiveDuration();

            if (cloneTicker) cloneTicker.recalculateEffectiveDuration();
        }
    }

    if (_isArray(clone.definitions)) {

        clone.definitions.forEach((def, index) => {

            if (def.engineIsFunction) def.engine = this.definitions[index].engine;
        });
    }

    return clone;
};

const G = P.getters,
    S = P.setters;

G.definitions = function() {

    return [...this.definitions];
};

S.definitions = function (item) {

    if (item) this.setDefinitions(item);
};

S.commenceAction = function (item) {

    this.commenceAction = item;

    if (typeof this.commenceAction != FUNCTION) this.commenceAction = λnull;
};

S.completeAction = function (item) {

    this.completeAction = item;

    if (typeof this.completeAction != FUNCTION) this.completeAction = λnull;
};

P.set = function (items = Ωempty) {

    const t = items.ticker;
    if (t && !t.substring && t.name && t.type === T_TICKER) items.ticker = t.name;

    const setters = this.setters,
        keys = _keys(items),
        d = this.defs,
        ticker = (xt(items.ticker)) ? this.ticker : false;

    let key, i, iz, s;

    for (i = 0, iz = keys.length; i < iz; i++) {

        key = keys[i];

        if (key != NAME) {

            s = setters[key];

            if (s) s.call(this, items[key]);
            else if (typeof d[key] != UNDEF) this[key] = items[key];
        }
    }

    if (ticker) {

        this.ticker = ticker;
        this.addToTicker(items.ticker);
    }
    else if (xto(items.time, items.duration)) {

        this.calculateEffectiveTime();
        this.calculateEffectiveDuration();
    }
    return this;
};

P.getEndTime = function () {

    return this.effectiveTime + this.effectiveDuration;
};

P.calculateEffectiveDuration = function (item) {

    const tweenDuration = xtGet(item, this.duration),
        calculatedDur = convertTime(tweenDuration),
        cDur = calculatedDur[1],
        cType = calculatedDur[0],
        ticker = this.ticker;

    let myticker,
        tickerDuration = 0;

    this.effectiveDuration = 0;

    if (cType === PC) {

        if (ticker) {

            myticker = animationtickers[ticker];

            if (myticker) {

                tickerDuration = myticker.effectiveDuration;
                this.effectiveDuration = tickerDuration * (cDur / 100);
            }
        }
    }
    else this.effectiveDuration = cDur;

    return this;
};

P.update = function (items = Ωempty) {

    const tick = items.tick || 0,
        revTick = items.reverseTick || 0,
        effectiveTime = this.effectiveTime,
        effectiveDuration = this.effectiveDuration,
        reversed = this.reversed;

    let starts, ends,
        status = 0;

    if (!reversed) {

        starts = effectiveTime;
        ends = effectiveTime + effectiveDuration;

        if (tick < starts) status = -1;
        else if (tick > ends) status = 1;
    }
    else {

        starts = effectiveTime + effectiveDuration;
        ends = effectiveTime;

        if (revTick > starts) status = 1;
        else if (revTick < ends) status = -1;
    }

    if (effectiveDuration) {

        if (!status || status != this.status) {

            this.status = status;
            this.doSimpleUpdate(items);

            if (!items.next) this.status = (reversed) ? -1 : 1;
        }
    }

    else {

        if (status != this.status) {

            this.status = status;
            this.doSimpleUpdate(items);

            if (!items.next) this.status = (reversed) ? -1 : 1;
        }
    }

    if (items.willLoop) {

        if (this.reverseOnCycleEnd) this.reversed = !reversed;
        else this.status = -1;
    }
};

P.doSimpleUpdate = function (items = Ωempty) {

    const starts = this.effectiveTime,
        effectiveDuration = this.effectiveDuration,
        status = this.status,
        definitions = this.definitions,
        targets = this.targets,
        action = this.action,
        setObj = getSetObject(this.setObj);

    let progress;

    const end = starts + effectiveDuration;
    let elapsed;

    if (this.reversed) elapsed = end - items.tick;
    else elapsed = items.tick - starts;

    if (effectiveDuration && !status) {

        if (elapsed <= 0) progress = 0;
        else if (elapsed >= effectiveDuration) progress = 1;
        else progress = (elapsed / effectiveDuration);
    }
    else progress = (status > 0) ? 1 : 0;

    for (let i = 0, iz = definitions.length, val, def; i < iz; i++) {

        def = definitions[i];
        val = def.compute(progress);
        setObj[def.attribute] = val;
    }

    for (let j = 0, jz = targets.length, t; j < jz; j++) {

        t = targets[j];

        if (T_GROUP === t.type) t.setArtefacts(setObj);
        else t.set(setObj);
    }

    if (action) action();
};

P.setDefinitions = function (...args) {

    this.definitions.length = 0;
    this.definitions.push(...args.flat(Infinity));
    this.setObj = getSetObjectKey(this.definitions);

    this.setDefinitionsValues();
};

P.clearDefinitions = function () {

    this.definitions.length = 0;
    this.setObj = getSetObjectKey(this.definitions);
};

P.setDefinitionsValues = function () {

    const parseDefinitionsValue = this.parseDefinitionsValue,
        definitions = this.definitions;

    let i, iz, temp, def;

    for (i = 0, iz = definitions.length; i < iz; i++) {

        def = definitions[i];

        if (def) {

            temp = parseDefinitionsValue(def.start);
            def.effectiveStart = temp[1];
            def.suffix = temp[0];

            temp = parseDefinitionsValue(def.end);
            def.effectiveEnd = temp[1];

            def.effectiveChange = def.effectiveEnd - def.effectiveStart;

            const start  = def.effectiveStart;
            const change = def.effectiveChange;
            const integer = !!def.integer;
            const suffix  = def.suffix;

            let compute, easing;

            if (!xt(def.engine)) {

                easing = easeEngines[LINEAR];
                compute = (p) => {

                    let v = start + change * easing(p);
                    if (integer) v = _round(v);
                    return suffix ? (v + suffix) : v;
                };

                def.engine = LINEAR;
            }
            else if (def.engine.substring) {

                easing = easeEngines[def.engine] || easeEngines[LINEAR];
                compute = (p) => {

                    let v = start + change * easing(p);
                    if (integer) v = _round(v);
                    return suffix ? (v + suffix) : v;
                };
            }
            else if (isa_fn(def.engine)) {

                easing = def.engine;
                compute = (p) => {

                    let v = easing(start, change, p);
                    if (integer) v = _round(v);
                    return suffix ? (v + suffix) : v;
                };
            }
            else {

                const easing = easeEngines[LINEAR];
                compute = (p) => {

                    let v = start + change * easing(p);
                    if (integer) v = _round(v);
                    return suffix ? (v + suffix) : v;
                };
            }
            def.compute = compute;
        }
    }
    return this;
};

P.parseDefinitionsValue = function (item) {

    const result = [ZERO_STR, 0];

    if (xt(item)) {

        if (item.toFixed) result[1] = item;
        else if (item.substring) {

            const m = item.match(/^(-?\d*\.?\d+)(\D*)$/);

            if (m) {

                result[1] = parseFloat(m[1]);
                result[0] = m[2] || ZERO_STR;
            }
        }
    }
    return result;
};

P.run = function () {

    const t = animationtickers[this.ticker];

    if (t) {

        this.commenceAction();
        t.run();

        if (typeof this.onRun === FUNCTION) this.onRun();
    }
    return this;
};

P.isRunning = function () {

    const tick = animationtickers[this.ticker];

    if (tick) return tick.isRunning();
    return false;
};

P.halt = function() {

    const t = animationtickers[this.ticker];

    if (t) {

        t.halt();

        if (typeof this.onHalt === FUNCTION) this.onHalt();
    }
    return this;
};

P.reverse = function() {

    const t = animationtickers[this.ticker];

    if (t) {

        t.reverse();

        if (typeof this.onReverse === FUNCTION) this.onReverse();
    }
    return this;
};

P.resume = function() {

    const t = animationtickers[this.ticker];

    if (t) {

        t.resume();

        if (typeof this.onResume === FUNCTION) this.onResume();
    }
    return this;
};

P.seekTo = function(milliseconds) {

    const t = animationtickers[this.ticker];

    if (t) {

        t.seekTo(milliseconds);

        if (typeof this.onSeekTo === FUNCTION) this.onSeekTo();
    }
    return this;
};

P.seekFor = function(milliseconds) {

    const t = animationtickers[this.ticker];

    if (t) {

        t.seekFor(milliseconds);

        if (typeof this.onSeekFor === FUNCTION) this.onSeekFor();
    }
    return this;
};

export const makeTween = function (items) {

    if (!items) return false;
    return new Tween(items);
};

constructors.Tween = Tween;