@cocreate/lazy-loader 1.8.0 → 1.10.0

package/CHANGELOG.md

@@ -1,3 +1,18 @@
+# [1.10.0](https://github.com/CoCreate-app/CoCreate-lazy-loader/compare/v1.9.0...v1.10.0) (2023-12-01)
+
+
+### Features
+
+* get config using CoCreate-config ([8e0b9fc](https://github.com/CoCreate-app/CoCreate-lazy-loader/commit/8e0b9fce220c493a1db250cf424345d7708a2e08))
+* lazyload client and server modules ([80e25d6](https://github.com/CoCreate-app/CoCreate-lazy-loader/commit/80e25d67d729eaec18775a43bf1ef10cb9141aa8))
+
+# [1.9.0](https://github.com/CoCreate-app/CoCreate-lazy-loader/compare/v1.8.0...v1.9.0) (2023-11-25)
+
+
+### Features
+
+* upgrade dependencies for latest features and fixes ([bc5e0b5](https://github.com/CoCreate-app/CoCreate-lazy-loader/commit/bc5e0b5a622f9bc871ef18914f6d7466d5a05a30))
+
 # [1.8.0](https://github.com/CoCreate-app/CoCreate-lazy-loader/compare/v1.7.0...v1.8.0) (2023-11-25)
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cocreate/lazy-loader",
-  "version": "1.8.0",
+  "version": "1.10.0",
   "description": "A simple lazy-loader component in vanilla javascript. Easily configured using HTML5 data-attributes and/or JavaScript API.",
   "keywords": [
     "lazy-loader",
@@ -58,6 +58,6 @@
     "webpack-log": "^3.0.1"
   },
   "dependencies": {
-    "@cocreate/observer": "^1.13.0"
+    "@cocreate/observer": "^1.14.0"
   }
 }

package/src/client.js

@@ -0,0 +1,61 @@
+import observer from '@cocreate/observer';
+
+function listen(callback, selector) {
+
+    function observerCallback({ target }) {
+        // let isInit = target.querySelector(selector)/testtt
+        // if (isInit) {
+        callback()
+        // console.log('lazyloaded', selector)
+        observer.uninit(observerCallback)
+        // }
+    }
+
+    observer.init({
+        name: 'lazyloadObserver',
+        observe: ['childList'],
+        target: selector,
+        callback: observerCallback
+    })
+
+    let selectorAttributes = [];
+    let attributes = selector.split(",")
+    for (let attribute of attributes) {
+        let attr = attribute.trim()
+        if (attr.startsWith("[")) {
+            let pos = attr.indexOf("*")
+            if (pos == -1)
+                pos = attr.indexOf("=")
+            if (pos !== -1) {
+                attr = attr.slice(1, pos)
+            } else {
+                attr = attr.slice(1, -1)
+            }
+            selectorAttributes.push(attr)
+        }
+
+    }
+    if (selectorAttributes.length > 0)
+        observer.init({
+            name: 'lazyloadAttributeObserver',
+            observe: ['attributes'],
+            attributeName: selectorAttributes,
+            target: selector,
+            callback: observerCallback
+        });
+
+}
+
+export async function lazyLoad(name, selector, callback) {
+    if (document.querySelector(selector))
+        await dependency(name, await callback())
+    else
+        listen(callback, selector)
+}
+
+export async function dependency(name, promise) {
+    let component = await promise;
+    Object.assign(window.CoCreate, {
+        [name]: component.default
+    });
+}

package/src/index.js

@@ -1,61 +1,14 @@
-import observer from '@cocreate/observer';
-
-function listen(callback, selector) {
-
-    function observerCallback({ target }) {
-        // let isInit = target.querySelector(selector)
-        // if (isInit) {
-        callback()
-        // console.log('lazyloaded', selector)
-        observer.uninit(observerCallback)
-        // }
-    }
-
-    observer.init({
-        name: 'lazyloadObserver',
-        observe: ['childList'],
-        target: selector,
-        callback: observerCallback
-    })
-
-    let selectorAttributes = [];
-    let attributes = selector.split(",")
-    for (let attribute of attributes) {
-        let attr = attribute.trim()
-        if (attr.startsWith("[")) {
-            let pos = attr.indexOf("*")
-            if (pos == -1)
-                pos = attr.indexOf("=")
-            if (pos !== -1) {
-                attr = attr.slice(1, pos)
-            } else {
-                attr = attr.slice(1, -1)
-            }
-            selectorAttributes.push(attr)
-        }
-
-    }
-    if (selectorAttributes.length > 0)
-        observer.init({
-            name: 'lazyloadAttributeObserver',
-            observe: ['attributes'],
-            attributeName: selectorAttributes,
-            target: selector,
-            callback: observerCallback
+(function (root, factory) {
+    if (typeof define === 'function' && define.amd) {
+        define(["./client"], function (CoCreateLazyLoader) {
+            return factory(CoCreateLazyLoader)
         });
-
-}
-
-export async function lazyLoad(name, selector, callback) {
-    if (document.querySelector(selector))
-        await dependency(name, await callback())
-    else
-        listen(callback, selector)
-}
-
-export async function dependency(name, promise) {
-    let component = await promise;
-    Object.assign(window.CoCreate, {
-        [name]: component.default
-    });
-}
+    } else if (typeof module === 'object' && module.exports) {
+        const CoCreateLazyLoader = require("./server.js")
+        module.exports = factory(CoCreateLazyLoader);
+    } else {
+        root.returnExports = factory(root["./client.js"]);
+    }
+}(typeof self !== 'undefined' ? self : this, function (CoCreateLazyLoader) {
+    return CoCreateLazyLoader;
+}));

package/src/server.js

@@ -0,0 +1,184 @@
+const EventEmitter = require('events');
+const eventEmitter = new EventEmitter();
+const fs = require('fs').promises;
+const path = require('path');
+const vm = require('vm');
+const Config = require("@cocreate/config");
+
+class CoCreateLazyLoader {
+    constructor(crud) {
+        this.wsManager = crud.wsManager
+        this.crud = crud
+        this.exclusion = { ...require.cache };
+        this.modules = {};
+        this.init()
+    }
+
+    async init() {
+        // Function to create the scripts directory if it doesn't exist
+        async function createScriptsDirectory() {
+            try {
+                const scriptsDirectory = './scripts';
+                await fs.mkdir(scriptsDirectory, { recursive: true });
+                console.log(`Scripts directory created at ${scriptsDirectory}`);
+            } catch (error) {
+                console.error('Error creating scripts directory:', error);
+                throw error; // Halt execution if directory creation fails
+            }
+        }
+
+        // Call this function at the start of your application
+        createScriptsDirectory();
+
+        const config = await Config('lazyload', false, false)
+        if (!config)
+            return
+
+        for (let key of Object.keys(config.lazyload)) {
+            let moduleConfig = config.lazyload[key];
+            eventEmitter.on(moduleConfig.event, async () => {
+                this.executeScriptWithTimeout(key, moduleConfig)
+            });
+        }
+
+        // eventEmitter.emit('openai');
+
+    }
+
+    async executeScriptWithTimeout(moduleName, moduleConfig) {
+        try {
+            if (!moduleConfig.content) {
+                if (moduleConfig.path)
+                    moduleConfig.content = await require(moduleConfig.path)
+                else {
+                    try {
+                        const scriptPath = path.join(scriptsDirectory, `${moduleName}.js`);
+                        await fs.access(scriptPath);
+                        moduleConfig.content = await fs.readFile(scriptPath, 'utf8');
+                    } catch {
+                        moduleConfig.content = await fetchScriptFromDatabaseAndSave(moduleName, moduleConfig);
+                    }
+                }
+            }
+
+            if (moduleConfig.unload === false || moduleConfig.unload === 'false')
+                return
+            else if (moduleConfig.unload === true || moduleConfig.unload === 'true')
+                console.log('config should unload after completeion ')
+            else if (moduleConfig.unload = parseInt(moduleConfig.unload, 10)) {
+                // Check if the script is already loaded
+                if (moduleConfig.timeout) {
+                    clearTimeout(moduleConfig.timeout);
+                } else if (!moduleConfig.path) {
+                    // Execute the script
+                    moduleConfig.context = new vm.createContext({});
+                    const script = new vm.Script(moduleConfig.context);
+                    script.runInContext(context);
+                }
+
+                // Reset or set the timeout
+                const timeout = setTimeout(() => {
+                    delete this.modules[moduleName]
+                    delete moduleConfig.timeout
+                    delete moduleConfig.context
+                    delete moduleConfig.content
+                    console.log(`Module ${moduleName} removed due to inactivity.`);
+                    clearModuleCache(moduleName);
+
+                }, moduleConfig.unload);
+
+                moduleConfig.timeout = timeout
+            }
+        } catch (error) {
+            console.log(error)
+        }
+    }
+
+}
+
+function getModuleDependencies(modulePath) {
+    let moduleObj = require.cache[modulePath];
+    if (!moduleObj) {
+        return [];
+    }
+
+    // Get all child module paths
+    return moduleObj.children.map(child => child.id);
+}
+
+function isModuleUsedElsewhere(modulePath, moduleName) {
+    return Object.keys(require.cache).some(path => {
+        const moduleObj = require.cache[path];
+        // return moduleObj.children.some(child => child.id === modulePath && path !== modulePath);
+        return moduleObj.children.some(child => {
+            // let test = child.id === modulePath && path !== modulePath
+            // if (test)
+            //     return test
+            return child.id === modulePath && path !== modulePath
+        });
+    });
+}
+
+function clearModuleCache(moduleName) {
+    try {
+        const modulePath = require.resolve(moduleName);
+        const dependencies = getModuleDependencies(modulePath);
+
+        // Check if the module is a dependency of other modules
+        // const moduleObj = require.cache[modulePath];
+        // if (moduleObj && moduleObj.parent) {
+        //     console.log(`Module ${moduleName} is a dependency of other modules.`);
+        //     return;
+        // }
+
+        // Check if the module is used by other modules
+        if (isModuleUsedElsewhere(modulePath, moduleName)) {
+            console.log(`Module ${moduleName} is a dependency of other modules.`);
+            return;
+        }
+
+        // Remove the module from the cache
+        delete require.cache[modulePath];
+        console.log(`Module ${moduleName} has been removed from cache.`);
+        // Recursively clear dependencies from cache
+        dependencies.forEach(depPath => {
+            clearModuleCache(depPath);
+        });
+
+    } catch (error) {
+        console.error(`Error clearing module cache for ${moduleName}: ${error.message}`);
+    }
+}
+
+// Function to fetch script from database and save to disk
+async function fetchScriptFromDatabaseAndSave(moduleName, moduleConfig) {
+    let data = {
+        method: 'object.read',
+        array: moduleConfig.array,
+        $filter: {
+            query: [
+                { key: "host", value: [moduleConfig.object.hostname, '*'], operator: "$in" },
+                { key: "pathname", value: moduleConfig.object.pathname, operator: "$eq" }
+            ],
+            limit: 1
+        },
+        organization_id
+    };
+
+    let file = await crud.send(data);
+    let src;
+
+    if (file && file.object && file.object[0]) {
+        src = file.object[0].src;
+    } else {
+        throw new Error('Script not found in database');
+    }
+
+    // Save to disk for future use
+    const scriptPath = path.join(scriptsDirectory, `${moduleName}.js`);
+    await fs.writeFile(scriptPath, src);
+
+    return src;
+}
+
+module.exports = CoCreateLazyLoader;