AnP/Public/ecma/Drivers/URLPathDriver.ecma.js

"use strict";

import {Utils} from "../Utils/Utils.ecma.js";
import {Check} from "../Utils/Check.ecma.js";

/**
 * @typedef {import("../Application/AnP.ecma.js").AnP} AnP
 */

/**
 * @callback anp_url_path_driver_default_callback
 * @returns {void}
 */

/**
 * @callback anp_url_path_driver_callback
 * @param {?string} response 
 * @param {!number} status 
 * @param {!number} state 
 * @param {!boolean} ok 
 * @param {!string} message 
 * @returns {void}
 */

/**
 * @callback anp_url_path_driver_ajax_end_callback
 * @param {!string} message 
 * @returns {void}
 */

/**
 * @callback anp_url_path_driver_load_json_each_callback
 * @param {?any} item 
 * @param {!anp_url_path_driver_default_callback} calback 
 * @returns {void}
 */

/**
 * @class
 * @constructor
 * @param {!AnP} anp 
 * @returns {void}
 * @access public
 */
export const URLPathDriver = (function(){

    /**
     * @constructs URLPathDriver
     * @param {!AnP} anp 
     * @returns {void}
     * @access private
     */
    const URLPathDriver = function(anp){

        /** @type {URLPathDriver} */
        const self = this;
        /** @type {boolean} */
        let started = false, 
            /** @type {boolean} */
            default_timeout = false;

        /**
         * @returns {void}
         * @access public
         */
        this.set_basics = () => {

            default_timeout = anp.settings.get(["ajax_timeout", "timeout"], null, default_timeout);

        };

        /**
         * @returns {void}
         * @access private
         */
        const constructor = () => {

            self.set_basics();

        };

        /**
         * @param {?anp_start_callback} callback 
         * @returns {boolean}
         * @access public
         */
        this.start = (callback = null) => {

            /** @type {!anp_start_callback} */
            const end = ok => {
                Utils.execute(callback, ok);
                return ok;
            };

            return end(started ? false : started = true);
        };

        /**
         * @param {!XMLHttpRequest} ajax 
         * @param {!anp_url_path_driver_callback} callback 
         * @param {?(Object.<string, any|null>|Array.<any|null>)} inputs 
         * @param {?(string|Object.<string, any|null>|Array.<any|null>)} [data = null] 
         * @returns {XMLHttpRequest}
         * @access private
         */
        const execute = (ajax, callback, inputs, data = null) => {

            let ended = false;
            const date = Date.now(), 
                  timeout = Utils.get_value(["ajax_timeout", "timeout"], inputs, default_timeout), 
                  end = message => {
                      !ended && (ended = true) && Utils.execute(
                          callback, ajax.responseText, ajax.status, ajax.readyState, message == "OK", message
                      );
                  };

            ajax.timeout = timeout;
            ajax.onreadystatechange = () => {
                if(ended)
                    return;
                if(ajax.readyState == 4)
                    end((ajax.status >= 200 && ajax.status < 300) || [301, 302, 304].includes(ajax.status) ? "OK" : "HTTP_ERROR");
                else if(timeout && Date.now() - date > timeout)
                    end("FORCED_TIMEOUT");
            };

            ajax.onabort = () => end("ABORTED");
            ajax.onerror = () => end("ERROR");
            ajax.ontimeout = () => end("TIMEOUT");

            ajax.send(data);

            return ajax;
        };

        /**
         * @param {!string} url 
         * @param {!anp_url_path_driver_callback} callback 
         * @param {?(object.<string, any|null>|Array.<any|null>)} [inputs = null] 
         * @returns {XMLHttpRequest}
         * @access public
         */
        this.get = (url, callback = null, inputs = null) => {

            /** @type {XMLHttpRequest} */
            const ajax = new XMLHttpRequest();

            ajax.open("get", url, true);

            return execute(ajax, callback, inputs);
        };

        /**
         * @param {!(string|Object.<string, any|null>|Array.<any|null>)} inputs 
         * @param {!anp_url_path_driver_default_callback} each_callback 
         * @param {?anp_url_path_driver_default_callback} [end_callback = null] 
         * @param {!boolean} [only_dictionaries = true] 
         * @returns {void}
         * @access public
         */
        this.load_json = (inputs, each_callback, end_callback = null, only_dictionaries = true) => {
            if(Check.is_string(inputs)){

                /** @type {Object.<string, any|null>|Array.<any|null>|null} */
                let json;

                try{
                    json = JSON.parse(inputs);
                }catch(exception){};

                if(json)
                    self.load_json(json, each_callback, end_callback, only_dictionaries);
                else 
                    self.get(inputs, (response, status, state, ok, message) => {
                        try{
                            json = JSON.parse(response);
                        }catch(exception){};
                        self.load_json(json, each_callback, end_callback, only_dictionaries);
                    });

            }else if(Check.is_array(inputs)){
                if(only_dictionaries)
                    Utils.execute_items(inputs, (item, callback) => {
                        self.load_json(item, each_callback, callback, only_dictionaries);
                    }, end_callback);
                else 
                    Utils.execute(each_callback, inputs, end_callback);
            }else if(Check.is_dictionary(inputs))
                Utils.execute(each_callback, inputs, end_callback);
            else 
                Utils.execute(end_callback);
        };

        constructor();

    };

    return URLPathDriver;
})();