tnp-core 16.0.15 → 16.0.18

package/websql/fesm2022/tnp-core.mjs

@@ -7,6 +7,7 @@ export { moment };
 import * as dateformat from 'dateformat';
 export { dateformat };
 import { Subject } from 'rxjs';
+import axios from 'axios';
 
 let isBrowser = false;
 isBrowser = true;
@@ -467,8 +468,8 @@ const all = Object.keys(allObj).map(key => {
 for (let i = 0; i < all.length; i++) {
     const e1 = all[i];
     for (let j = 0; j < all.length; j++) {
-        const e2 = all[j];
-        e1.prototype[map.get(e2)] = e2;
+        const e2 = all[j]; // @ts-ignore
+        e1[map.get(e2)] = e2;
     }
 }
 const chalk$1 = allObj;
@@ -495,7 +496,10 @@ function win32Path(p) {
     }
     return path.win32.normalize(p);
 }
-function crossPlatformPath(pathStringOrPathParts) {
+/**
+ * This funciton will replace // to /
+ */
+const crossPlatformPath = (pathStringOrPathParts) => {
     if (Array.isArray(pathStringOrPathParts)) {
         pathStringOrPathParts = pathStringOrPathParts.join('/');
     }
@@ -509,12 +513,98 @@ function crossPlatformPath(pathStringOrPathParts) {
     const isExtendedLengthPath = /^\\\\\?\\/.test(pathStringOrPathParts);
     const hasNonAscii = /[^\u0000-\u0080]+/.test(pathStringOrPathParts); // eslint-disable-line no-control-regex
     if (isExtendedLengthPath || hasNonAscii) {
-        return pathStringOrPathParts;
+        return pathStringOrPathParts?.replace(/\/\//g, '/');
     }
-    return pathStringOrPathParts.replace(/\\/g, '/');
-}
+    return pathStringOrPathParts.replace(/\\/g, '/').replace(/\/\//g, '/');
+};
 ({}); // @--end-of-file-for-module=tnp-core lib/core-imports.ts
 
+const mimeTypes = {
+    ".aac": "audio/aac",
+    ".abw": "application/x-abiword",
+    ".arc": "application/x-freearc",
+    ".avi": "video/x-msvideo",
+    ".azw": "application/vnd.amazon.ebook",
+    ".bin": "application/octet-stream",
+    ".bmp": "image/bmp",
+    ".bz": "application/x-bzip",
+    ".bz2": "application/x-bzip2",
+    ".csh": "application/x-csh",
+    ".css": "text/css",
+    ".csv": "text/csv",
+    ".doc": "application/msword",
+    ".docx": "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+    ".eot": "application/vnd.ms-fontobject",
+    ".epub": "application/epub+zip",
+    ".gz": "application/gzip",
+    ".gif": "image/gif",
+    ".htm": "text/html",
+    ".html": "text/html",
+    ".ico": "image/vnd.microsoft.icon",
+    ".ics": "text/calendar",
+    ".jar": "application/java-archive",
+    ".jpeg": "image/jpeg",
+    ".jpg": "image/jpeg",
+    ".js": "text/javascript",
+    ".json": "application/json",
+    ".jsonld": "application/ld+json",
+    ".mid": "application/midi",
+    ".midi": "application/midi",
+    ".mjs": "text/javascript",
+    ".mp3": "audio/mpeg",
+    ".mp4": "video/mp4",
+    ".mpeg": "video/mpeg",
+    ".mpkg": "application/vnd.apple.installer+xml",
+    ".odp": "application/vnd.oasis.opendocument.presentation",
+    ".ods": "application/vnd.oasis.opendocument.spreadsheet",
+    ".odt": "application/vnd.oasis.opendocument.text",
+    ".oga": "audio/ogg",
+    ".ogg": "audio/ogg",
+    ".ogv": "video/ogg",
+    ".ogx": "application/ogg",
+    ".opus": "audio/opus",
+    ".otf": "font/otf",
+    ".png": "image/png",
+    ".pdf": "application/pdf",
+    ".php": "application/php",
+    ".ppt": "application/vnd.ms-powerpoint",
+    ".pptx": "application/vnd.openxmlformats-officedocument.presentationml.presentation",
+    ".rar": "application/vnd.rar",
+    ".rtf": "application/rtf",
+    ".sh": "application/x-sh",
+    ".svg": "image/svg+xml",
+    ".swf": "application/x-shockwave-flash",
+    ".tar": "application/x-tar",
+    ".tif": "image/tiff",
+    ".tiff": "image/tiff",
+    ".ts": "video/mp2t",
+    ".ttf": "font/ttf",
+    ".txt": "text/plain",
+    ".vsd": "application/vnd.visio",
+    ".wav": "audio/wav",
+    ".weba": "audio/webm",
+    ".webm": "video/webm",
+    ".webp": "image/webp",
+    ".woff": "font/woff",
+    ".woff2": "font/woff2",
+    ".xhtml": "application/xhtml+xml",
+    ".xls": "application/vnd.ms-excel",
+    ".xlsx": "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+    ".xml": "application/xml",
+    ".xul": "application/vnd.mozilla.xul+xml",
+    ".zip": "application/zip",
+    ".3gp": "video/3gpp",
+    ".3g2": "video/3gpp2",
+    ".7z": "application/x-7z-compressed"
+};
+const MediaTypeAllArr = [
+    'text', 'image', 'audio', 'video', 'font',
+    'application', 'multipart', 'message', 'model'
+];
+var Files;
+(function (Files) {
+    Files.MimeTypesObj = mimeTypes;
+})(Files || (Files = {}));
 ;
 ({}); // @--end-of-file-for-module=tnp-core lib/core-models.ts
 
@@ -553,6 +643,10 @@ class HelpersIsomorphic {
 ;
 ({}); // @--end-of-file-for-module=tnp-core lib/helpers-isomorphic.ts
 
+/* */
+/* */
+/* */
+/* */
 /* */
 /* */
 /* */
@@ -614,6 +708,13 @@ class HelpersMessages extends HelpersIsomorphic {
         /* */
         /* */
     }
+    renderError(err) {
+        /* */
+        /* */
+        /* */
+        /* */
+        console.error(err);
+    }
     error(details, noExit = false, noTrace = false) {
         if (Helpers.isBrowser) {
             console.error(details);
@@ -1050,6 +1151,8 @@ function transformData(details) {
 ({}); // @--end-of-file-for-module=tnp-core lib/helpers-messages.ts
 
 const encoding = 'utf8';
+/* */
+/* */
 const WEBSQL_PROC_MOCK_PROCESSES_PID = {};
 const WEBSQL_PROC_MOCK_PROCESSES_PPID = {};
 class HelpersCore extends HelpersMessages {
@@ -1059,38 +1162,72 @@ class HelpersCore extends HelpersMessages {
         }
         return HelpersCore._instanceCore;
     }
+    /* */
+    /* */
+    /* */
+    /* */
+    /* */
+    /* */
+    /* */
+    /* */
+    /* */
+    /* */
+    /* */
     constructor() {
         super();
         /* */
         /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
-        /* */
         this.bigMaxBuffer = 2024 * 500;
         /* */
         /* */
         /* */
     }
+    mediaTypeFromSrc(src) {
+        const ext = path.extname(src);
+        const media = mimeTypes[ext];
+        return _.first(media?.split('/'));
+    }
+    /* */
+    /* */
+    /* */
+    /* */
+    /* */
+    /* */
+    /* */
+    /* */
+    /* */
+    /* */
+    /* */
+    /* */
+    /* */
+    /* */
+    /* */
+    /* */
+    /* */
+    /* */
+    /* */
+    /* */
+    /* */
+    /* */
+    /**
+     * check if data is nodejs/browser blob
+     *
+     * @param maybeBlob
+     * @returns
+     */
     isBlob(maybeBlob) {
         return maybeBlob instanceof Blob; // || toString.call(maybeBlob) === '[object Blob]';
     }
+    /**
+     * Check if data is nodejs buffer
+     *
+     * @param maybeNodejsBuffer
+     * @returns
+     */
+    /* */
+    /* */
+    /* */
+    /* */
     removeSlashAtEnd(s) {
         s = s?.endsWith(`/`) ? s.slice(0, s.length - 1) : s;
         return s;
@@ -1099,12 +1236,15 @@ class HelpersCore extends HelpersMessages {
         s = s?.startsWith(`/`) ? s.slice(1) : s;
         return s;
     }
+    /**
+     * stringify to pretty json string
+     */
     stringify(inputObject) {
         return JSON.stringify(inputObject, null, 2);
     }
     async runSyncOrAsync(fnOrOptions, ...firstArg) {
         if (_.isUndefined(fnOrOptions)) {
-            return;
+            return void 0;
         }
         let promisOrValue;
         const optionsMode = _.isObject(fnOrOptions)
@@ -1340,10 +1480,6 @@ class HelpersCore extends HelpersMessages {
     /* */
     /* */
     /* */
-    /* */
-    /* */
-    /* */
-    /* */
     /**
      * symlink may have existed or unexisted destiantion url
      * @param destUrl M
@@ -1445,6 +1581,7 @@ class HelpersCore extends HelpersMessages {
     /* */
     /* */
     /* */
+    /* */
     exists(folderOrFilePath) {
         /* */
         /* */
@@ -1467,6 +1604,9 @@ class HelpersCore extends HelpersMessages {
         /* */
         return (void 0);
     }
+    /**
+     * this is HACK for running procesess inside processes
+     */
     _fixCommand(command) {
         if ((command.startsWith('tnp ') || command.startsWith('firedev ')) // TODO every cli projects here that uses run and need to kill process easly!
             &&
@@ -1531,6 +1671,11 @@ class HelpersCore extends HelpersMessages {
         /* */
         /* */
         /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
         };
     }
     wait(second) {
@@ -1610,6 +1755,11 @@ class HelpersCore extends HelpersMessages {
     /* */
     /* */
     /* */
+    /* */
+    /* */
+    /* */
+    /* */
+    /* */
     killProcess(byPid) {
         /* */
         /* */
@@ -1668,6 +1818,9 @@ class HelpersCore extends HelpersMessages {
             /* */
             /* */
             /* */
+            /* */
+            /* */
+            /* */
             async(detach = false, mockFun) {
                 if (mockFun) {
                     const subStdoutSub = new Subject();
@@ -1746,6 +1899,7 @@ class HelpersCore extends HelpersMessages {
                 /* */
                 /* */
                 /* */
+                /* */
                 return (void 0);
             },
             /* */
@@ -1840,6 +1994,8 @@ class HelpersCore extends HelpersMessages {
             /* */
             /* */
             /* */
+            /* */
+            /* */
         };
     }
     /* */
@@ -2202,14 +2358,31 @@ class HelpersCore extends HelpersMessages {
     /* */
     /* */
     /* */
+    /* */
+    /* */
+    /* */
+    /* */
+    /* */
+    /* */
+    /* */
+    /* */
+    /* */
+    /* */
+    /* */
+    /* */
+    /* */
+    /* */
+    /* */
     /**
      * Quick fix for object values
+     * @deprecated
      */
     values(obj) {
         if (_.isObject(obj) && !Array.isArray(obj)) {
             const values = [];
             for (const key in obj) {
                 if (Object.prototype.hasOwnProperty.call(obj, key)) {
+                    // @ts-ignore
                     values.push(obj[key]);
                 }
             }
@@ -2278,6 +2451,277 @@ class PROGRESS_DATA {
 ;
 ({}); // @--end-of-file-for-module=tnp-core lib/progress-data.ts
 
+/* */
+/* */
+const BLOB_SUPPORTED_IN_SQLJS = false;
+var Utils;
+(function (Utils) {
+    let DbBinaryFormatEnum;
+    (function (DbBinaryFormatEnum) {
+        DbBinaryFormatEnum["Blob"] = "Blob";
+        DbBinaryFormatEnum["File"] = "File";
+        DbBinaryFormatEnum["string"] = "string";
+        /* */
+        /* */
+    })(DbBinaryFormatEnum = Utils.DbBinaryFormatEnum || (Utils.DbBinaryFormatEnum = {}));
+    /* */
+    /* */
+    let binary;
+    (function (binary) {
+        /**
+         * This is for BROWSER ONLY
+         *
+         * @param buffer
+         * @param contentType
+         * @returns
+         */
+        async function arrayBufferToBlob(buffer, contentType) {
+            // @ts-ignore
+            return new Blob([buffer], { type: contentType });
+        }
+        binary.arrayBufferToBlob = arrayBufferToBlob;
+        /**
+         * This is for BROWSER ONLY
+         * @param blob
+         * @returns
+         */
+        async function blobToArrayBuffer(blob) {
+            return await new Promise((resolve, reject) => {
+                const reader = new FileReader();
+                reader.addEventListener('loadend', () => {
+                    resolve(reader.result);
+                });
+                reader.addEventListener('error', reject); // @ts-ignore
+                reader.readAsArrayBuffer(blob);
+            });
+        }
+        binary.blobToArrayBuffer = blobToArrayBuffer;
+        /**
+         * it is revers to base64toBlob
+         * @param blob
+         * @returns
+         */
+        function blobToBase64(blob) {
+            return new Promise((resolve, _) => {
+                const reader = new FileReader();
+                reader.onloadend = () => resolve(reader.result); // @ts-ignore
+                reader.readAsDataURL(blob);
+            });
+        }
+        binary.blobToBase64 = blobToBase64;
+        /**
+         * it is revers to blobToBase64()
+         * @param base64Data
+         * @returns
+         */
+        async function base64toBlob(base64Data, contentTypeOverride) {
+            let content_type = void 0;
+            let file_base64 = void 0;
+            if (!contentTypeOverride) {
+                const m = /^data:(.+?);base64,(.+)$/.exec(base64Data);
+                if (!m) {
+                    throw new Error(`[firedev-framework][base64toBlob] Not a base64 blob [${base64Data}]`);
+                }
+                var [__, contenttype, filebase64] = m;
+                content_type = contenttype;
+                file_base64 = filebase64;
+            }
+            content_type = (contentTypeOverride ? contentTypeOverride : content_type || '');
+            base64Data = contentTypeOverride ? base64Data : file_base64;
+            const sliceSize = 1024;
+            const byteCharacters = atob(base64Data);
+            const bytesLength = byteCharacters.length;
+            const slicesCount = Math.ceil(bytesLength / sliceSize);
+            const byteArrays = new Array(slicesCount);
+            for (let sliceIndex = 0; sliceIndex < slicesCount; ++sliceIndex) {
+                const begin = sliceIndex * sliceSize;
+                const end = Math.min(begin + sliceSize, bytesLength);
+                const bytes = new Array(end - begin);
+                for (let offset = begin, i = 0; offset < end; ++i, ++offset) {
+                    bytes[i] = byteCharacters[offset].charCodeAt(0);
+                }
+                byteArrays[sliceIndex] = new Uint8Array(bytes);
+            }
+            return new Blob(byteArrays, { type: content_type });
+        }
+        binary.base64toBlob = base64toBlob;
+        async function base64toDbBinaryFormat(text) {
+            let result;
+            result = await (async () => {
+                if (BLOB_SUPPORTED_IN_SQLJS) {
+                    const blob = await base64toBlob(text);
+                    return blob;
+                }
+                return text;
+            })();
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            return result;
+        }
+        binary.base64toDbBinaryFormat = base64toDbBinaryFormat;
+        async function dbBinaryFormatToBase64(binaryFormat) {
+            let result;
+            result = await (async () => {
+                if (BLOB_SUPPORTED_IN_SQLJS) {
+                    const text = await blobToBase64(binaryFormat);
+                    return text;
+                }
+                return binaryFormat;
+            })();
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            return result;
+        }
+        binary.dbBinaryFormatToBase64 = dbBinaryFormatToBase64;
+        async function textToDbBinaryFormat(text) {
+            let result;
+            result = await (async () => {
+                if (BLOB_SUPPORTED_IN_SQLJS) {
+                    const blob = await textToBlob(text);
+                    return blob;
+                }
+                return text;
+            })();
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            return result;
+        }
+        binary.textToDbBinaryFormat = textToDbBinaryFormat;
+        async function dbBinaryFormatToText(binaryFormat) {
+            let result;
+            result = await (async () => {
+                if (BLOB_SUPPORTED_IN_SQLJS) {
+                    const text = await blobToText(binaryFormat);
+                    return text;
+                }
+                return binaryFormat;
+            })();
+            /* */
+            /* */
+            /* */
+            /* */
+            /* */
+            return result;
+        }
+        binary.dbBinaryFormatToText = dbBinaryFormatToText;
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        async function fileToBlob(file) {
+            return new Blob([new Uint8Array(await file.arrayBuffer())], { type: file.type });
+        }
+        binary.fileToBlob = fileToBlob;
+        ;
+        async function blobToFile(blob, nameForFile = 'my-file-name') {
+            if (!nameForFile) {
+                nameForFile = 'nonamefile' + (new Date()).getTime();
+            }
+            ;
+            // @ts-ignore
+            return new File([blob], nameForFile);
+        }
+        binary.blobToFile = blobToFile;
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        /* */
+        async function textToBlob(text, type = 'text/plain') {
+            const blob = new Blob([text], { type });
+            return blob;
+        }
+        binary.textToBlob = textToBlob;
+        async function blobToText(blob) {
+            return await blob.text();
+        }
+        binary.blobToText = blobToText;
+        async function textToFile(text, fileRelativePathOrName) {
+            const ext = path.extname(fileRelativePathOrName);
+            const type = mimeTypes[ext];
+            const blob = new Blob([text], { type });
+            const file = await blobToFile(blob, fileRelativePathOrName);
+            return file;
+        }
+        binary.textToFile = textToFile;
+        async function fileToText(file) {
+            return await file.text();
+        }
+        binary.fileToText = fileToText;
+        async function jsonToBlob(jsonObj) {
+            const blob = new Blob([JSON.stringify(jsonObj, null, 2)], { type: 'application/json' });
+            return blob;
+        }
+        binary.jsonToBlob = jsonToBlob;
+        /**
+         * TODO NOT TESTED
+         */
+        async function blobToJson(blob) {
+            return JSON.parse(await blob.text());
+        }
+        binary.blobToJson = blobToJson;
+        async function getBlobFrom(url) {
+            const response = await axios({
+                url,
+                method: 'get',
+                responseType: 'blob'
+            });
+            return response.data;
+        }
+        binary.getBlobFrom = getBlobFrom;
+    })(binary = Utils.binary || (Utils.binary = {}));
+    let css;
+    (function (css) {
+        /**
+         *
+         * @param pixelsCss pixels ex. 100px
+         * @returns
+         */
+        function numValue(pixelsCss) {
+            return parseInt(pixelsCss
+                .replace('px', ''));
+        }
+        css.numValue = numValue;
+    })(css = Utils.css || (Utils.css = {}));
+})(Utils || (Utils = {}));
+;
+({}); // @--end-of-file-for-module=tnp-core lib/utils.ts
+
 let Helpers = HelpersCore.InstanceCore;
 ;
 ({}); // @--end-of-file-for-module=tnp-core lib/index.ts
@@ -2286,5 +2730,5 @@ let Helpers = HelpersCore.InstanceCore;
  * Generated bundle index. Do not edit.
  */
 
-export { CoreConfig, HelpersCore as CoreHelpers, Helpers, PROGRESS_DATA, chalk, crossPlatformPath, frameworkName, frameworkNameBe, path, win32Path };
+export { CoreConfig, HelpersCore as CoreHelpers, Files, Helpers, MediaTypeAllArr, PROGRESS_DATA, Utils, chalk, crossPlatformPath, frameworkName, frameworkNameBe, mimeTypes, path, win32Path };
 //# sourceMappingURL=tnp-core.mjs.map