@jay-js/system/state/module/State.js

A powerful and flexible TypeScript library for UI, state management, lazy loading, routing and managing draggable elements in modern web applications.

function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
    try {
        var info = gen[key](arg);
        var value = info.value;
    } catch (error) {
        reject(error);
        return;
    }
    if (info.done) {
        resolve(value);
    } else {
        Promise.resolve(value).then(_next, _throw);
    }
}
function _async_to_generator(fn) {
    return function() {
        var self = this, args = arguments;
        return new Promise(function(resolve, reject) {
            var gen = fn.apply(self, args);
            function _next(value) {
                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
            }
            function _throw(err) {
                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
            }
            _next(undefined);
        });
    };
}
let _subscriber = null;
function fn_hash(func) {
    const funcString = func.toString();
    let hash = 0;
    for(let i = 0; i < funcString.length; i++){
        const char = funcString.charCodeAt(i);
        hash = (hash << 5) - hash + char;
        hash |= 0;
    }
    return Math.abs(hash).toString(16);
}
export const State = (data)=>{
    const state = {
        set: (newData1, options)=>{
            if (typeof newData1 === "function") {
                data = newData1(data);
            } else {
                data = newData1;
            }
            if (options === null || options === void 0 ? void 0 : options.silent) {
                return;
            }
            if (state.effects.size === 0) {
                return;
            }
            if (options === null || options === void 0 ? void 0 : options.target) {
                if (Array.isArray(options.target)) {
                    options.target.forEach((item)=>{
                        const effect = state.effects.get(item);
                        if (effect) {
                            effect(data);
                        }
                    });
                    return;
                }
                const effect = state.effects.get(options.target);
                if (effect) {
                    effect(data);
                }
                return;
            }
            state.effects.forEach((item)=>item(data));
        },
        get: (callback)=>{
            if (callback) {
                callback(data);
            }
            return data;
        },
        sub: (id, effect, run = false)=>{
            state.effects.set(id, effect);
            if (run) {
                return effect(data);
            }
        },
        unsub: (id)=>{
            state.effects.delete(id);
        },
        trigger: (id)=>{
            if (state.effects.size === 0) {
                return;
            }
            if (id) {
                const effect = state.effects.get(id);
                if (effect) {
                    effect(data);
                }
                return;
            }
            state.effects.forEach((item)=>item(data));
        },
        clear: (newData1)=>{
            if (typeof newData1 === "function") {
                data = newData1(data);
            } else if (newData1) {
                data = newData1;
            } else {
                data = undefined;
            }
            state.effects.clear();
        },
        effects: new Map(),
        get value () {
            if (_subscriber) {
                let hash = fn_hash(_subscriber);
                if (_subscriber.name.includes("_setValue") && _subscriber._fn) {
                    hash = fn_hash(_subscriber._fn);
                }
                state.sub(hash, _subscriber);
            }
            return this.get();
        },
        set value (newData){
            this.set(newData);
        }
    };
    return state;
};
export function Effect(fn) {
    _subscriber = fn;
    fn();
    _subscriber = null;
}
export function Values(fn) {
    const _setValue = function() {
        var _ref = _async_to_generator(function*() {
            if (_setValue._path.length > 0) {
                let target = _setValue._object;
                for(let i = 0; i < _setValue._path.length - 1; i++){
                    target = target[_setValue._path[i]];
                }
                const lastKey = _setValue._path[_setValue._path.length - 1];
                target[lastKey] = yield _setValue._fn();
                return;
            }
            _setValue._object = yield _setValue._fn();
        });
        return function _setValue() {
            return _ref.apply(this, arguments);
        };
    }();
    _setValue._object = undefined;
    _setValue._path = [];
    _setValue._fn = fn;
    function _set_value_effect(object) {
        return __set_value_effect.apply(this, arguments);
    }
    function __set_value_effect() {
        __set_value_effect = _async_to_generator(function*(object, ...path) {
            _setValue._object = object;
            _setValue._path = path;
            _subscriber = _setValue;
            yield _setValue();
            _subscriber = null;
        });
        return __set_value_effect.apply(this, arguments);
    }
    return _set_value_effect;
}