ls-webbuilder/stdLib/require_define.js

Can be used by projects to build a full standalone web application. Orders, concats, uglifies and transpiles the js or ts source and append some other assets like referenced html and css/less files

(() => {
    if(typeof globalThis !== 'undefined' && globalThis.__lsBuild) {
        return;
    }

    let _global = (typeof globalThis !== 'undefined' && globalThis.globalThis === globalThis && globalThis) ||
        (typeof self === 'object' && self.self === self && self) ||
        (typeof global === 'object' && global.global === global && global) ||
        this;

    _global.globalThis = _global;
    _global.__lsBuild = true;

    let aliases = {};
    let definitions = {};
    let dependencyStore = {};
    let buffer = [];
    let staticBuffer = [];
    let runBuffer = [];

    let getDefinition = (name) => {
        let alias = aliases[name];
        if(alias) {
            name = alias;
        }
        return definitions[name];
    };

    class System {
        static register(name, dependencies, definition) {
            let obj = getDefinition(name);
            if(obj && 'initialized' in obj) {
                throw new Error('Module "' + name + '" already exists');
            }

            if(!obj) {
                obj = {};
                obj.name = name;
                definitions[name] = obj;
            }

            let exports = {};
            obj.exports = exports;
            let initialized = false;
            dependencies = dependencies || [];

            let {setters, execute} = definition((exportName, value) => {
                if(typeof exportName === 'object') {
                    Object.keys(exportName).forEach((exportKey) => {
                        let exportValue = exportName[exportKey];
                        if(typeof exportValue === 'undefined') {
                            return;
                        }
                        exports[exportKey] = exportValue;
                    });
                } else if(typeof exportName === 'string') {
                    exports[exportName] = value;
                } else {
                    return;
                }

                this._export(name, obj.exports);

                if(typeof exportName === 'object') {
                    return obj.exports;
                } else {
                    return value;
                }
            });

            dependencies.forEach((dependency, i) => {
                let obj = getDefinition(dependency);
                if(obj) {
                    obj.exports && setters[i](obj.exports);
                    if(obj.initialized) {
                        return;
                    }
                }

                let arr = dependencyStore[dependency];
                if(!arr) {
                    arr = [];
                    dependencyStore[dependency] = arr;
                }

                arr.push(setters[i]);
            });

            obj.definition = definition;
            obj.dependencies = dependencies;
            obj.setters = setters;
            obj.execute = execute;
            obj.initialized = initialized;
            buffer.push(obj);
        }

        static registerAlias(original, alias) {
            aliases[alias] = original;
        }

        static forcedImport(module, forcedImports) {
            let obj = getDefinition(module);
            if(!obj) {
                obj = {};
                obj.name = module;
                definitions[module] = obj;
            }

            obj.forcedImports = (obj.forcedImports || []).concat(forcedImports || []);
        }

        static addFile(module, content) {
            let obj = getDefinition(module);
            if(!obj) {
                obj = {};
                obj.name = module;
                definitions[module] = obj;
            }

            obj.initialized = true;
            obj.requested = true;
            obj.definition = null;
            obj.dependencies = [];
            obj.execute = null;
            obj.exports = {'default': content};
            this._export(module, obj.exports);
        }

        static addNodeModule(module) {
            if(module in definitions) {
                return;
            }

            let obj = {};
            obj.name = module;
            definitions[module] = obj;
            obj.exports = require(module);
            obj.initialized = true;
            this._export(module, obj.exports);
        }

        static start() {
            let buf = buffer;
            buffer = [];
            buf.forEach((obj) => {
                this._initDefinition(obj)
            });

            buf = staticBuffer;
            staticBuffer = [];
            buf.forEach((func) => {
                func();
            });

            buf = runBuffer;
            runBuffer = [];
            buf.forEach((func) => {
                func();
            });

            dependencyStore = {};
        }

        static _initDefinition(obj) {
            if(obj.requested || obj.initialized) {
                return;
            }

            obj.requested = true;

            let loadDependency = (obj) => {
                obj.dependencies.forEach((dependencyName) => {
                    let dependencyObj = getDefinition(dependencyName);
                    if(!dependencyObj) {
                        throw new Error('Dependency "' + dependencyName + '" of module "' + obj.name + '" does not exists');
                    }
                    this._initDefinition(dependencyObj);
                });
            };

            loadDependency(obj);

            this._forceInitialize(obj);
        }

        static _forceInitialize(obj) {
            if(obj.initialized) {
                return;
            }

            obj.initialized = true;

            (obj.forcedImports || []).forEach((dependency) => {
                this._forceInitialize(getDefinition(dependency));
            });

            obj.execute();
        }

        static _export(name, exports) {
            if(!exports) {
                return;
            }

            let arr = dependencyStore[name];
            if(!arr) {
                return;
            }

            arr.forEach((setter) => {
                setter(exports);
            });
        }

        static require(name) {
            let definition = getDefinition(name);
            this._forceInitialize(definition);
            return definition.exports;
        }

        static exists(name) {
            return !!getDefinition(name);
        }

        static _static(func) {
            this.static(func);
        }

        static static(func) {
            if(typeof func === typeof function() {}) {
                staticBuffer.push(func);
            }
        }

        static _run(func) {
            this.run(func);
        }

        static run(func) {
            if(typeof func === typeof function() {}) {
                runBuffer.push(func);
            }
        }
    }

    _global.System = System;
})();