qcobjects 2.4.105-ts → 2.4.108-ts

package/build/serviceLoader.js

@@ -0,0 +1,300 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.serviceLoader = void 0;
+const asyncLoad_1 = require("./asyncLoad");
+const ComplexStorageCache_1 = require("./ComplexStorageCache");
+const DataStringify_1 = require("./DataStringify");
+const Logger_1 = require("./Logger");
+const platform_1 = require("./platform");
+const top_1 = require("./top");
+/**
+ * Loads a simple component from a template
+ *
+ * @author: Jean Machuca <correojean@gmail.com>
+ * @param service a Service object
+ */
+const serviceLoader = function (service, _async = false) {
+    const _serviceLoaderInBrowser = function (service) {
+        var _promise = new Promise(function (resolve, reject) {
+            Logger_1.logger.debug("LOADING SERVICE DATA {{DATA}} FROM {{URL}}".replace("{{DATA}}", (0, DataStringify_1._DataStringify)(service.data)).replace("{{URL}}", service.url));
+            const xhr = new XMLHttpRequest();
+            xhr.withCredentials = service.withCredentials;
+            const xhrasync = true; // always async because xhr sync is deprecated
+            xhr.open(service.method, service.url, xhrasync);
+            for (const header in service.headers) {
+                try {
+                    if (typeof service.headers[header] !== "function") {
+                        xhr.setRequestHeader(header, service.headers[header]);
+                    }
+                }
+                catch (e) {
+                    Logger_1.logger.debug("Something went wrong when assign the header " + header);
+                    Logger_1.logger.debug(`An error ocurred: ${e}`);
+                }
+            }
+            xhr.onload = function () {
+                if (xhr.status === 200) {
+                    const response = xhr.responseText;
+                    Logger_1.logger.debug("Data received {{DATA}}".replace("{{DATA}}", (0, DataStringify_1._DataStringify)(response)));
+                    Logger_1.logger.debug("CREATING SERVICE {{NAME}}".replace("{{NAME}}", service.name));
+                    service.template = response;
+                    if (service.cached && (typeof cache !== "undefined")) {
+                        cache.save(service.name, service.template);
+                    }
+                    if (typeof service.done === "function") {
+                        var standardResponse = {
+                            "request": xhr,
+                            service
+                        };
+                        service.done.call(service, standardResponse);
+                        resolve.call(_promise, standardResponse);
+                    }
+                }
+                else {
+                    if (typeof service.fail === "function") {
+                        var standardResponse = {
+                            "request": xhr,
+                            service
+                        };
+                        service.fail.call(service, standardResponse);
+                        reject.call(_promise, standardResponse);
+                    }
+                }
+            };
+            const _directLoad = function () {
+                Logger_1.logger.debug("SENDING THE NORMAL REQUEST  ");
+                try {
+                    xhr.send((0, DataStringify_1._DataStringify)(service.data));
+                }
+                catch (e) {
+                    Logger_1.logger.debug("SOMETHING WRONG WITH REQUEST  ");
+                    Logger_1.logger.debug(`An error ocurred: ${e}`);
+                    reject.call(_promise, {
+                        request: xhr,
+                        service
+                    });
+                }
+            };
+            if (service.cached) {
+                var cache = new ComplexStorageCache_1.ComplexStorageCache({
+                    index: service.data,
+                    load() {
+                        _directLoad.call(this);
+                    },
+                    alternate(cacheController) {
+                        if (service.method === "GET") {
+                            service.template = cacheController.cache.getCached(service.name);
+                            if (typeof service.done === "function") {
+                                const standardResponse = {
+                                    "request": xhr,
+                                    service
+                                };
+                                service.done.call(service, standardResponse);
+                                resolve.call(_promise, standardResponse);
+                            }
+                        }
+                        else {
+                            _directLoad();
+                        }
+                    }
+                });
+                top_1._top.lastCache = cache;
+            }
+            else {
+                _directLoad();
+            }
+            return xhr;
+        });
+        return _promise;
+    };
+    const _serviceLoaderInNode = function (service) {
+        var _promise = new Promise(function (resolve, reject) {
+            if (typeof URL === "undefined") {
+                global.URL = ((0, platform_1._require_)("url")).URL;
+                // eslint-disable-next-line no-unused-vars
+                const URL = global.URL;
+            }
+            const serviceURL = new URL(service.url);
+            var req;
+            service.useHTTP2 = Object.hasOwn(service, "useHTTP2") && service.useHTTP2;
+            const captureEvents = function (req) {
+                Logger_1.logger.debug("LOADING SERVICE DATA (non-browser) {{DATA}} FROM {{URL}}".replace("{{DATA}}", (0, DataStringify_1._DataStringify)(service.data)).replace("{{URL}}", service.url));
+                let dataXML;
+                const standardResponse = {
+                    "http2Client": client,
+                    "request": req,
+                    service,
+                    "responseHeaders": null
+                };
+                if (typeof service.data === "object" && service.data !== null) {
+                    if (service.useHTTP2) {
+                        try {
+                            Logger_1.logger.debug("Sending data...");
+                            const buffer = new Buffer((0, DataStringify_1._DataStringify)(service.data));
+                            req.write(buffer);
+                        }
+                        catch (e) {
+                            Logger_1.logger.debug("It was not possible to send any data");
+                            Logger_1.logger.debug(`An error ocurred: ${e}`);
+                        }
+                    }
+                }
+                dataXML = "";
+                req.on("response", (responseHeaders) => {
+                    Logger_1.logger.debug("receiving response...");
+                    standardResponse.responseHeaders = responseHeaders;
+                    /*
+                    for (const name in responseHeaders) {
+                      logger.debug(`${name}: ${responseHeaders[name]}`);
+                    }
+                    */
+                    dataXML = "";
+                });
+                req.on("data", (chunk) => {
+                    Logger_1.logger.debug("receiving data...");
+                    // do something with the data
+                    dataXML += "" + chunk.toString();
+                    service.template = dataXML;
+                });
+                if (service.useHTTP2) {
+                    req.resume();
+                }
+                req.on("end", () => {
+                    Logger_1.logger.debug("ending call...");
+                    service.template = dataXML;
+                    if (Object.hasOwn(service, "useHTTP2") && service.useHTTP2) {
+                        client.destroy();
+                    }
+                    else {
+                        req.destroy();
+                    }
+                    service.done.call(service, standardResponse);
+                    resolve.call(_promise, standardResponse);
+                });
+                if (service.useHTTP2) {
+                    req.end();
+                }
+            };
+            try {
+                let requestOptions;
+                if (service.useHTTP2) {
+                    Logger_1.logger.debug("using http2");
+                    const http2 = (0, platform_1._require_)("http2");
+                    var client = (http2).connect(serviceURL.origin);
+                    requestOptions = Object.assign({
+                        ":method": service.method,
+                        ":path": serviceURL.pathname
+                    }, service.options);
+                    requestOptions = Object.assign(requestOptions, service.headers);
+                    req = client.request(requestOptions);
+                    req.setEncoding("utf8");
+                    captureEvents(req);
+                }
+                else {
+                    if (serviceURL.protocol === "http:") {
+                        const http = (0, platform_1._require_)("http");
+                        const request = (http).request;
+                        requestOptions = Object.assign({
+                            "url": service.url,
+                            headers: service.headers
+                        }, service.options);
+                        req = request(service.url);
+                        captureEvents(req);
+                    }
+                    else if (serviceURL.protocol === "https:") {
+                        const https = (0, platform_1._require_)("https");
+                        requestOptions = Object.assign({
+                            hostname: serviceURL.hostname,
+                            port: serviceURL.port,
+                            path: serviceURL.pathname,
+                            method: service.method,
+                            headers: service.headers
+                        }, service.options);
+                        const _req_ = (https).request(requestOptions, function (req) {
+                            captureEvents(req);
+                        });
+                        _req_.end();
+                    }
+                    else {
+                        const e = "Protocol not supported: " + serviceURL.protocol;
+                        Logger_1.logger.debug(e);
+                        throw new Error(e);
+                    }
+                }
+            }
+            catch (e) {
+                Logger_1.logger.debug(e);
+                service.fail.call(service, e);
+                reject.call(_promise, e);
+            }
+        }).catch((e) => {
+            Logger_1.logger.debug(`Something happened when trying to call the service: ${service.name}. Error: ${e}`);
+            service.fail.call(service, e);
+        });
+        return _promise;
+    };
+    const _serviceLoaderMockup = function (service) {
+        var _promise = new Promise(function (resolve) {
+            Logger_1.logger.debug(`Calling mockup service ${service.name} ...`);
+            const standardResponse = {
+                "request": null,
+                service,
+                "responseHeaders": service.responseHeaders
+            };
+            if (typeof service.mockup === "function") {
+                service.mockup.call(service, standardResponse);
+            }
+            else {
+                service.done.call(service, standardResponse);
+            }
+            resolve.call(_promise, standardResponse);
+        });
+        return _promise;
+    };
+    const _serviceLoaderLocal = function (service) {
+        var _promise = new Promise(function (resolve) {
+            Logger_1.logger.debug(`Calling local service ${service.name} ...`);
+            const standardResponse = {
+                "request": null,
+                service,
+                "responseHeaders": service.responseHeaders
+            };
+            if (typeof service.local === "function") {
+                service.local.call(service, standardResponse);
+            }
+            else {
+                service.done.call(service, standardResponse);
+            }
+            resolve.call(_promise, standardResponse);
+        });
+        return _promise;
+    };
+    let _ret_;
+    switch (service.kind) {
+        case "rest":
+            if (platform_1.isBrowser) {
+                if (typeof _async !== "undefined" && _async) {
+                    _ret_ = (0, asyncLoad_1.asyncLoad)(_serviceLoaderInBrowser, [service, _async]);
+                }
+                else {
+                    _ret_ = _serviceLoaderInBrowser(service);
+                }
+            }
+            else {
+                _ret_ = _serviceLoaderInNode(service);
+            }
+            break;
+        case "mockup":
+            _ret_ = _serviceLoaderMockup(service);
+            break;
+        case "local":
+            _ret_ = _serviceLoaderLocal(service);
+            break;
+        default:
+            Logger_1.logger.debug(`The value of the kind property of the service ${service.name} is not valid`);
+            _ret_ = Promise.resolve();
+            break;
+    }
+    return _ret_;
+};
+exports.serviceLoader = serviceLoader;

package/build/shortCode.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.shortCode = void 0;
+const Crypt_1 = require("./Crypt");
+const shortCode = function () {
+    const length = 1000;
+    const code1 = Crypt_1._Crypt.encrypt((Math.random() * length).toString().replace(".", ""), (new Date()).getTime().toString());
+    const code2 = Crypt_1._Crypt.encrypt((Math.random() * length).toString().replace(".", ""), (new Date((new Date()).getTime() - 1000 * 1000)).getTime().toString());
+    const shortCode = [...code2].map((o1, index) => {
+        return [...code1][index] === o1 ? null : o1;
+    }).filter((c) => c !== null).join("");
+    return shortCode;
+};
+exports.shortCode = shortCode;

package/build/subelements.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.subelements = void 0;
+const subelements = function subelements(query) {
+    const _self = this;
+    return [..._self.querySelectorAll(query)];
+};
+exports.subelements = subelements;

package/build/super.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports._super_ = void 0;
+const ClassFactory_1 = require("./ClassFactory");
+/**
+ * Returns a method from a superior QCObjects Class
+ * It is useful for Class Inheritance in the _new_ and __new__ method constructors
+ * @example _super_('MySuperClass','MySuperMethod').call(this,params) #where this is the current instance and params are method parameters
+ *
+ * @param {String} className
+ * @param {String} classMethodName
+ * @param {Object} params
+ */
+const _super_ = function (className, classMethodName) {
+    return ((0, ClassFactory_1.ClassFactory)(className))[classMethodName];
+};
+exports._super_ = _super_;
+exports._super_.prototype.toString = function () {
+    return "_super_(className,classMethodName,params) { [QCObjects native code] }";
+};

package/build/tag_filter.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports._tag_filter_ = void 0;
+exports._tag_filter_ = "quick-component:not([loaded]),component:not([loaded])";

package/build/top.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setConfigService = exports.configService = exports.buildComponentsStack = exports.resetTop = exports.componentsStack = exports._top = void 0;
+const ComponentFactory_1 = require("./ComponentFactory");
+exports._top = ((typeof self !== "undefined" && self) ||
+    (typeof window !== "undefined" && window) ||
+    (typeof global !== "undefined" && global) ||
+    this);
+exports._top.lastCache = undefined;
+exports.componentsStack = [];
+const resetTop = (_top_) => {
+    exports._top = _top_;
+};
+exports.resetTop = resetTop;
+const buildComponentsStack = () => {
+    exports.componentsStack = (0, ComponentFactory_1.buildComponents)(document);
+};
+exports.buildComponentsStack = buildComponentsStack;
+const setConfigService = (_configService) => {
+    exports._top.global.configService = _configService;
+    exports.configService = _configService;
+};
+exports.setConfigService = setConfigService;

package/build/uniqueID.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.uniqueId = void 0;
+const shortCode_1 = require("./shortCode");
+exports.uniqueId = shortCode_1.shortCode;

package/build/waitUntil.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.waitUntil = void 0;
+const Logger_1 = require("./Logger");
+const waitUntil = function (func, exp) {
+    const _waitUntil = function (func, exp) {
+        const maxWaitCycles = 2000;
+        let _w = 0;
+        var _t = setInterval(function () {
+            if (exp()) {
+                clearInterval(_t);
+                func();
+                Logger_1.logger.debug("Ejecuting " + func.name + " after wait");
+            }
+            else {
+                if (_w < maxWaitCycles) {
+                    _w += 1;
+                    Logger_1.logger.debug("WAIT UNTIL " + func.name + " is true, " + _w.toString() + " cycles");
+                }
+                else {
+                    Logger_1.logger.debug("Max execution time for " + func.name + " expression until true");
+                    clearInterval(_t);
+                }
+            }
+        }, 1);
+    };
+    setTimeout(function () {
+        _waitUntil(func, exp);
+    }, 1);
+};
+exports.waitUntil = waitUntil;

package/build-esbuild.js

@@ -0,0 +1,62 @@
+// build.js
+const esbuild = require("esbuild");
+const alias = require("esbuild-plugin-alias");
+const path = require("path");
+
+const baseSettings = {
+    entryPoints: ["src/*.ts", "src/*.mts", "src/*.cts"], // Your entry file
+    bundle: true,
+    outdir: "public/cjs", // Output dir
+    format: "cjs", // or "esm" depending on your module system    
+    target: ["esnext"], // Adjust based on your target environment
+    tsconfig: "tsconfig.json", // Path to your tsconfig.json,
+    globalName: "global",
+    minify:false,
+    keepNames: true,
+    sourcemap: true,
+    splitting: false,
+    chunkNames: "chunks/[name]-[hash]",
+    plugins: [
+        alias({
+            "types": path.join(__dirname, "src/types/global/index.d.ts")
+        })
+    ]    
+};
+
+const cjsSettings = {...baseSettings,
+    entryPoints: ["src/*.cts"], // Your entry file
+    outdir: "public/cjs", // Output dir
+    format: "cjs", // or "esm" depending on your module system    
+    platform: "node", // or "browser" depending on your target environment
+    outExtension: {
+        ".js":".cjs"
+    }
+
+};
+
+const esmSettings = {...baseSettings,
+    entryPoints: ["src/*.mts"], // Your entry file
+    outdir: "public/esm", // Output dir
+    format: "esm", // or "esm" depending on your module system    
+    platform: "neutral", // or "browser" depending on your target environment
+    outExtension: {
+        ".js":".mjs"
+    }
+
+};
+
+const browserSettings = {...baseSettings,
+    entryPoints: ["src/*.mts"], // Your entry file
+    outdir: "public/browser", // Output dir
+    format: "iife", // or "esm" depending on your module system    
+    platform: "browser", // or "browser" depending on your target environment
+    outExtension: {
+        ".js":".js"
+    }
+};
+
+const logError = (e) => {console.log(e);process.exit(1);};
+
+esbuild.build(cjsSettings).catch(logError);
+esbuild.build(esmSettings).catch(logError);
+esbuild.build(browserSettings).catch(logError);

package/eslint.config.mjs

@@ -0,0 +1,87 @@
+import globals from "globals";
+import pluginJs from "@eslint/js";
+import tseslint from "typescript-eslint";
+
+import * as parser from '@typescript-eslint/parser';
+
+
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import js from "@eslint/js";
+import { FlatCompat } from "@eslint/eslintrc";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const compat = new FlatCompat({
+    baseDirectory: __dirname,
+    recommendedConfig: js.configs.recommended,
+    allConfig: js.configs.all
+});
+
+export default [
+    { languageOptions: {
+        globals: {
+            ...globals.browser,
+            ...globals.node,
+            Atomics: "readonly",
+            SharedArrayBuffer: "readonly",
+        },
+
+        ecmaVersion: "latest",
+        sourceType: "module",
+        parserOptions: {
+            projectService: true,
+            tsconfigRootDir: import.meta.dirname,
+            programs: [parser.createProgram('tsconfig.json')],
+        }
+        ,        
+
+    } },
+    pluginJs.configs.recommended,
+    ...tseslint.configs.recommended,
+    ...tseslint.configs.recommendedTypeChecked,
+    { files: ["**/*.{js,mjs,cjs,ts}"] }
+    ,{
+    ignores: [
+        "**/*.js",
+        "spec/**/*",
+        "src/*.js",
+        "src/**/*.js",
+        "node_modules/**/*",
+        "**/node_modules"   
+    ],
+}, ...compat.extends("eslint:recommended"), 
+{    rules: {
+    semi: ["error", "always"],
+    quotes: ["error", "double"],
+    "@typescript-eslint/no-explicit-any": "off",
+    "@typescript-eslint/no-this-alias": "off",
+    "@typescript-eslint/no-unused-vars": "off",
+    "@typescript-eslint/ban-types": "off",
+    "array-callback-return": "warn",
+    "no-useless-call": "off",
+    camelcase: "off",
+    "no-var": "off",
+}},
+{
+    files: ["**/*.ts", "**/*.d.ts", "**/*.d.tsx", "**/*.tsx"]
+},
+{   files: ["**/*.d.ts"],
+    rules: {
+        "no-unused-vars":"off"
+    }
+},
+{
+    files: ["**/*.ts", "**/*.d.ts"],
+    rules: {
+        "no-dupe-class-members":"off",
+        "@typescript-eslint/no-unsafe-function-type":"off",
+        "no-redeclare": "off",
+        "@typescript-eslint/no-unsafe-member-access":"off",
+        "@typescript-eslint/no-unsafe-assignment":"off",
+        "@typescript-eslint/no-unsafe-call":"off",
+        "@typescript-eslint/no-unsafe-argument":"off"
+
+    }
+}
+];

package/package.json

@@ -1,18 +1,18 @@
 {
   "name": "qcobjects",
-  "version": "2.4.105-ts",
+  "version": "2.4.108-ts",
   "description": "QCObjects is an Open-source framework that empowers full-stack developers to make micro-services and micro-frontends into an N-Tier architecture.",
-  "main": "build/index.cjs",
-  "module": "build/index.mjs",
-  "browser": "browser/index.js",
+  "main": "public/cjs/index.cjs",
+  "module": "public/esm/index.mjs",
+  "browser": "public/browser/index.js",
   "type": "commonjs",
   "types": "build/index.d.ts",
   "exports": {
     ".": {
-      "require": "./build/index.cjs",
-      "import": "./build/index.mjs",
-      "types": "./build/index.d.ts"
+      "require": "./public/cjs/index.cjs",
+      "import": "./public/esm/index.mjs"
     },
+    "./types/*": "./types/*",
     "./package.json": "./package.json"
   },
   "license": "LGPL-3.0",
@@ -20,10 +20,13 @@
     "build": "npm run build:ts-types && npm run build:ts && npm run build:browser",
     "build:ts": "npm test && npx tsc",
     "build:ts-types": "npx tsc --project tsconfig.d.json",
-    "build:browser": "npx -y esbuild@0.17.19 build/*.js --bundle --outdir=browser --keep-names --minify --global-name=global --sourcemap --splitting --chunk-names=chunks/[name]-[hash] --format=esm --target=es2021",
+    "build:browser": "npm run build:esbuild",
+    "build:esbuild": "node ./build-esbuild.js",
     "start": "qcobjects-shell",
-    "test": "(npm run lint && (npx jasmine))",
-    "lint": "(npx -y eslint@8.40.0 src/**/*.ts --fix --ext ts)",
+    "test:ts-types": "npx tsc --project ./tsconfig.jasmine.json ",
+    "test:jasmine": "npm run test:ts-types && npx ts-node --project ./tsconfig.jasmine.json ./node_modules/jasmine/bin/jasmine",
+    "test": "(npm run lint && npm run test:jasmine)",
+    "lint": "(npx -y eslint@latest src/**/*.ts --fix )",
     "preversion": "npm cache verify && npm test",
     "sync": "git add . && git commit -am ",
     "postversion": "git push && git push --tags",
@@ -100,31 +103,31 @@
   },
   "homepage": "https://qcobjects.com",
   "devDependencies": {
-    "@types/qcobjects": "github:QCObjects/-types-qcobjects",
-    "@types/qcobjects-sdk": "github:QCObjects/-types-qcobjects-sdk",
+    "@eslint/eslintrc": "^3.1.0",
+    "@eslint/js": "^9.13.0",
+    "@types/jasmine": "^5.1.4",
+    "@types/node": "^22.8.1",
     "@typescript-eslint/eslint-plugin": "^5.58.0",
     "@typescript-eslint/parser": "^5.58.0",
-    "eslint": "^8.40.0",
+    "esbuild": "^0.24.0",
+    "esbuild-plugin-alias": "^0.2.1",
+    "eslint": "^8.57.1",
     "eslint-config-prettier": "^8.10.0",
     "eslint-config-semistandard": "^17.0.0",
     "eslint-config-standard": "^17.1.0",
     "eslint-plugin-import": "^2.27.5",
     "eslint-plugin-n": "^15.7.0",
     "eslint-plugin-promise": "^6.1.1",
+    "globals": "^15.11.0",
     "hint": "^2.0.0",
+    "install": "^0.13.0",
     "jasmine": "^3.7.0",
+    "ts-node": "^10.9.2",
     "typescript": "^5.6.3",
-    "qcobjects-sdk": "^2.4.66",
-    "qcobjects-tsconfig": "^2.4.10"
+    "typescript-eslint": "^8.11.0"
   },
-  "peerDependencies": {
-    "@types/qcobjects": "github:QCObjects/-types-qcobjects",
-    "@types/qcobjects-sdk": "github:QCObjects/-types-qcobjects-sdk",
-    "qcobjects-sdk": ">=2.4.64"
-  },
-  "dependencies": {},
   "engines": {
     "npm": ">=10",
-    "node": ">=20"
+    "node": ">=22"
   }
 }