Tween mixin

import * as library from '../core/library.js';

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

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

import { releaseArray, requestArray } from '../helper/array-pool.js';

import { FUNCTION, PC, T_TICKER, ZERO_STR } from '../helper/shared-vars.js';

const TARGET_SECTIONS = ['artefact', 'group', 'animation', 'animationtickers', 'world', 'tween', 'styles', 'filter'];

const locateTarget = (item) => {

    if(item && item.substring) {

        let result;

        return (TARGET_SECTIONS.some(section => {

            result = library[section][item];
            return result;

        })) ? result : false;
    }
    return false;
};

export default function (P = Ωempty) {

    const defaultAttributes = {

        order: 1,

        ticker: ZERO_STR,

        targets: null,

        time: 0,

        action: null,

        reverseOnCycleEnd: false,

        reversed: false,
    };
    P.defs = mergeOver(P.defs, defaultAttributes);

    P.kill = function () {

        const ticker = this.ticker;

        if (ticker === `${this.name}_ticker`) {

            const t = animationtickers[ticker];

            if (t) t.kill(false);
        }
        else if (ticker) this.removeFromTicker(ticker);

        this.deregister();

        return true;
    };

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

    G.targets = function () {

        return [...this.targets];
    };

    S.targets = function (item) {

        this.setTargets(item);
    };

    S.action = function (item) {

        this.action = item;

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

    P.calculateEffectiveTime = function (item) {

        const [cType, cTime] = convertTime(xtGet(item, this.time));

        this.effectiveTime = 0;

        if (cType === PC && cTime <= 100) {

            if (this.ticker) {

                const ticker = animationtickers[this.ticker];

                if (ticker) this.effectiveTime = ticker.effectiveDuration * (cTime / 100);
            }
        }
        else this.effectiveTime = cTime;

        return this;
    };

    P.addToTicker = function (item) {

        if (item && !item.substring && item.name && item.type === T_TICKER) item = item.name;

        if (xt(item)) {

            const oldT = this.ticker,
                newT = animationtickers[item];

            if (oldT && oldT !== item) this.removeFromTicker(oldT);

            if (xt(newT)) {

                this.ticker = item;
                newT.subscribe(this.name);
            }
        }
        return this;
    };

    P.removeFromTicker = function (item) {

        if (item && !item.substring && item.name && item.type === T_TICKER) item = item.name;
        if (!item) item = this.ticker;

        if (item) {

            const tick = animationtickers[item];

            if (xt(tick)) {

                this.ticker = ZERO_STR;
                tick.unsubscribe(this.name);
            }
        }
        return this;
    };

    const populateTargetArrays = function (...args) {

        const targetnames = requestArray(),
            targets = requestArray();

        const items = args.flat(Infinity);

        items.forEach(item => {

            if (item != null) {

                if (isa_fn(item) && isa_fn(item.set)) targets.push(item);

                else if (item.substring && !targetnames.includes(item)) {

                    const result = locateTarget(item);

                    if (result) {

                        targetnames.push(item);
                        targets.push(result);
                    }
                }

                else if (isa_obj(item) && isa_fn(item.set) && item.name && !targetnames.includes(item.name)) {

                    targetnames.push(item.name);
                    targets.push(item);
                }
            }
        });
        releaseArray(targetnames);

        return targets;
    }

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

        const targets = populateTargetArrays(args);

        this.targets.length = 0;
        this.targets.push(...targets);

        releaseArray(targets);
    };

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

        const targets = populateTargetArrays(args);

        const currentTargets = [...this.targets];

        const currentTargetNames = currentTargets.map(t => t.name || '');

        targets.forEach(t => {

            if (!t.name) currentTargets.push(t);

            else if (!currentTargetNames.includes(t.name)) currentTargets.push(t);
        });

        this.targets.length = 0;
        this.targets.push(...currentTargets);

        releaseArray(targets);
    };

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

        const targets = populateTargetArrays(args),
            currentTargets = [...this.targets],
            currentTargetNames = currentTargets.map(t => t.name || '');

        const targetsToRemove = requestArray(),
            functionsToKeep = requestArray();

        targets.forEach(t => {

            if (!t.name) functionsToKeep.push(t);
            else if (currentTargetNames.includes(t.name)) targetsToRemove.push(t.name);
        });

        this.targets.length = 0;
        this.targets.push(...functionsToKeep);
        this.targets.push(...currentTargets.filter(t => {

            if (!t.name) return false;
            return !targetsToRemove.includes(t.name);
        }));

        releaseArray(targets, targetsToRemove, functionsToKeep);
    };

    P.checkForTarget = function (item) {

        if (item.substring) return this.targets.some(t => t.name === item);

        if (!item.name) return false

        return this.targets.some(t => t.name === item.name);
    };

    P.run = λnull;
    P.isRunning = λnull;
    P.halt = λnull;
    P.reverse = λnull;
    P.resume = λnull;
    P.seekTo = λnull;
    P.seekFor = λnull;
}