tnp-core 16.5.1 → 16.5.7

package/client/fesm2022/tnp-core.mjs

@@ -26,6 +26,7 @@ function assertPath(path) {
         throw new TypeError('[firedev-core] Path must be a string. Received ' + JSON.stringify(path));
     }
 }
+/* \/\/ Resolves \. and \.\. elements in a path with directory names */
 function normalizeStringPosix(path, allowAboveRoot) {
     var res = '';
     var lastSegmentLength = 0;
@@ -41,6 +42,7 @@ function normalizeStringPosix(path, allowAboveRoot) {
             code = 47 /*/*/;
         if (code === 47 /*/*/) {
             if (lastSlash === i - 1 || dots === 1) {
+                /*         \/\/ NOOP */
             }
             else if (lastSlash !== i - 1 && dots === 2) {
                 if (res.length < 2 || lastSegmentLength !== 2 || res.charCodeAt(res.length - 1) !== 46 /*.*/ || res.charCodeAt(res.length - 2) !== 46 /*.*/) {
@@ -107,6 +109,7 @@ function _format(sep, pathObject) {
     return dir + sep + base;
 }
 const path$1 = {
+    /*   \/\/ path\.resolve\(\[from \.\.\.\], to\) */
     resolve: function resolve(pathToResovle) {
         return pathToResovle;
     },
@@ -116,6 +119,7 @@ const path$1 = {
             return '.';
         var isAbsolute = pathArg.charCodeAt(0) === 47 /*/*/;
         var trailingSeparator = pathArg.charCodeAt(pathArg.length - 1) === 47 /*/*/;
+        /*     \/\/ Normalize the path */
         pathArg = normalizeStringPosix(pathArg, !isAbsolute);
         if (pathArg.length === 0 && !isAbsolute)
             pathArg = '.';
@@ -156,6 +160,7 @@ const path$1 = {
         to = path$1.resolve(to);
         if (from === to)
             return '';
+        /*     \/\/ Trim any leading backslashes */
         var fromStart = 1;
         for (; fromStart < from.length; ++fromStart) {
             if (from.charCodeAt(fromStart) !== 47 /*/*/)
@@ -163,6 +168,7 @@ const path$1 = {
         }
         var fromEnd = from.length;
         var fromLen = fromEnd - fromStart;
+        /*     \/\/ Trim any leading backslashes */
         var toStart = 1;
         for (; toStart < to.length; ++toStart) {
             if (to.charCodeAt(toStart) !== 47 /*/*/)
@@ -170,6 +176,7 @@ const path$1 = {
         }
         var toEnd = to.length;
         var toLen = toEnd - toStart;
+        /*     \/\/ Compare paths to find the longest common path from root */
         var length = fromLen < toLen ? fromLen : toLen;
         var lastCommonSep = -1;
         var i = 0;
@@ -177,17 +184,25 @@ const path$1 = {
             if (i === length) {
                 if (toLen > length) {
                     if (to.charCodeAt(toStart + i) === 47 /*/*/) {
+                        /*             \/\/ We get here if `from` is the exact base path for `to`\. */
+                        /*             \/\/ For example: from='\/foo\/bar'; to='\/foo\/bar\/baz' */
                         return to.slice(toStart + i + 1);
                     }
                     else if (i === 0) {
+                        /*             \/\/ We get here if `from` is the root */
+                        /*             \/\/ For example: from='\/'; to='\/foo' */
                         return to.slice(toStart + i);
                     }
                 }
                 else if (fromLen > length) {
                     if (from.charCodeAt(fromStart + i) === 47 /*/*/) {
+                        /*             \/\/ We get here if `to` is the exact base path for `from`\. */
+                        /*             \/\/ For example: from='\/foo\/bar\/baz'; to='\/foo\/bar' */
                         lastCommonSep = i;
                     }
                     else if (i === 0) {
+                        /*             \/\/ We get here if `to` is the root\. */
+                        /*             \/\/ For example: from='\/foo'; to='\/' */
                         lastCommonSep = 0;
                     }
                 }
@@ -201,6 +216,8 @@ const path$1 = {
                 lastCommonSep = i;
         }
         var out = '';
+        /*     \/\/ Generate the relative path based on the path difference between `to` */
+        /*     \/\/ and `from` */
         for (i = fromStart + lastCommonSep + 1; i <= fromEnd; ++i) {
             if (i === fromEnd || from.charCodeAt(i) === 47 /*/*/) {
                 if (out.length === 0)
@@ -209,6 +226,8 @@ const path$1 = {
                     out += '/..';
             }
         }
+        /*     \/\/ Lastly, append the rest of the destination \(`to`\) path that comes after */
+        /*     \/\/ the common path parts */
         if (out.length > 0)
             return out + to.slice(toStart + lastCommonSep);
         else {
@@ -238,6 +257,7 @@ const path$1 = {
                 }
             }
             else {
+                /*         \/\/ We saw the first non\-path separator */
                 matchedSlash = false;
             }
         }
@@ -263,6 +283,8 @@ const path$1 = {
             for (i = pathArg.length - 1; i >= 0; --i) {
                 var code = pathArg.charCodeAt(i);
                 if (code === 47 /*/*/) {
+                    /*           \/\/ If we reached a path separator that was not part of a set of path */
+                    /*           \/\/ separators at the end of the string, stop now */
                     if (!matchedSlash) {
                         start = i + 1;
                         break;
@@ -270,16 +292,23 @@ const path$1 = {
                 }
                 else {
                     if (firstNonSlashEnd === -1) {
+                        /*             \/\/ We saw the first non\-path separator, remember this index in case */
+                        /*             \/\/ we need it if the extension ends up not matching */
                         matchedSlash = false;
                         firstNonSlashEnd = i + 1;
                     }
                     if (extIdx >= 0) {
+                        /*             \/\/ Try to match the explicit extension */
                         if (code === ext.charCodeAt(extIdx)) {
                             if (--extIdx === -1) {
+                                /*                 \/\/ We matched the extension, so mark this as the end of our path */
+                                /*                 \/\/ component */
                                 end = i;
                             }
                         }
                         else {
+                            /*               \/\/ Extension does not match, so our result is the entire path */
+                            /*               \/\/ component */
                             extIdx = -1;
                             end = firstNonSlashEnd;
                         }
@@ -295,12 +324,16 @@ const path$1 = {
         else {
             for (i = pathArg.length - 1; i >= 0; --i) {
                 if (pathArg.charCodeAt(i) === 47 /*/*/) {
+                    /*           \/\/ If we reached a path separator that was not part of a set of path */
+                    /*           \/\/ separators at the end of the string, stop now */
                     if (!matchedSlash) {
                         start = i + 1;
                         break;
                     }
                 }
                 else if (end === -1) {
+                    /*           \/\/ We saw the first non\-path separator, mark this as the end of our */
+                    /*           \/\/ path component */
                     matchedSlash = false;
                     end = i + 1;
                 }
@@ -316,10 +349,14 @@ const path$1 = {
         var startPart = 0;
         var end = -1;
         var matchedSlash = true;
+        /*     \/\/ Track the state of characters \(if any\) we see before our first dot and */
+        /*     \/\/ after any path separator we find */
         var preDotState = 0;
         for (var i = pathArg.length - 1; i >= 0; --i) {
             var code = pathArg.charCodeAt(i);
             if (code === 47 /*/*/) {
+                /*         \/\/ If we reached a path separator that was not part of a set of path */
+                /*         \/\/ separators at the end of the string, stop now */
                 if (!matchedSlash) {
                     startPart = i + 1;
                     break;
@@ -327,21 +364,28 @@ const path$1 = {
                 continue;
             }
             if (end === -1) {
+                /*         \/\/ We saw the first non\-path separator, mark this as the end of our */
+                /*         \/\/ extension */
                 matchedSlash = false;
                 end = i + 1;
             }
             if (code === 46 /*.*/) {
+                /*         \/\/ If this is our first dot, mark it as the start of our extension */
                 if (startDot === -1)
                     startDot = i;
                 else if (preDotState !== 1)
                     preDotState = 1;
             }
             else if (startDot !== -1) {
+                /*         \/\/ We saw a non\-dot and non\-path separator before our dot, so we should */
+                /*         \/\/ have a good chance at having a non\-empty extension */
                 preDotState = -1;
             }
         }
         if (startDot === -1 || end === -1 ||
+            /*       \/\/ We saw a non\-dot character immediately before the dot */
             preDotState === 0 ||
+            /*       \/\/ The \(right\-most\) trimmed path component is exactly '\.\.' */
             preDotState === 1 && startDot === end - 1 && startDot === startPart + 1) {
             return '';
         }
@@ -373,10 +417,15 @@ const path$1 = {
         var end = -1;
         var matchedSlash = true;
         var i = pathArg.length - 1;
+        /*     \/\/ Track the state of characters \(if any\) we see before our first dot and */
+        /*     \/\/ after any path separator we find */
         var preDotState = 0;
+        /*     \/\/ Get non\-dir info */
         for (; i >= start; --i) {
             code = pathArg.charCodeAt(i);
             if (code === 47 /*/*/) {
+                /*         \/\/ If we reached a path separator that was not part of a set of path */
+                /*         \/\/ separators at the end of the string, stop now */
                 if (!matchedSlash) {
                     startPart = i + 1;
                     break;
@@ -384,21 +433,28 @@ const path$1 = {
                 continue;
             }
             if (end === -1) {
+                /*         \/\/ We saw the first non\-path separator, mark this as the end of our */
+                /*         \/\/ extension */
                 matchedSlash = false;
                 end = i + 1;
             }
             if (code === 46 /*.*/) {
+                /*         \/\/ If this is our first dot, mark it as the start of our extension */
                 if (startDot === -1)
                     startDot = i;
                 else if (preDotState !== 1)
                     preDotState = 1;
             }
             else if (startDot !== -1) {
+                /*         \/\/ We saw a non\-dot and non\-path separator before our dot, so we should */
+                /*         \/\/ have a good chance at having a non\-empty extension */
                 preDotState = -1;
             }
         }
         if (startDot === -1 || end === -1 ||
+            /*       \/\/ We saw a non\-dot character immediately before the dot */
             preDotState === 0 ||
+            /*       \/\/ The \(right\-most\) trimmed path component is exactly '\.\.' */
             preDotState === 1 && startDot === end - 1 && startDot === startPart + 1) {
             if (end !== -1) {
                 if (startPart === 0 && isAbsolute)
@@ -436,6 +492,8 @@ const path$1 = {
 ;
 ({}); // @--end-of-file-for-module=tnp-core lib/node-path-mock.ts
 
+/* \/\/ TODO finish this MOCK @LAST */
+/* \/\/ const c:Chalk = void 0; */
 const allObj = {
     black(a) {
         console.log(a);
@@ -521,6 +579,7 @@ const crossPlatformPath = (pathStringOrPathParts) => {
 };
 ({}); // @--end-of-file-for-module=tnp-core lib/core-imports.ts
 
+/* \/\/ https:\/\/developer\.mozilla\.org\/en\-US\/docs\/Web\/HTTP\/Basics_of_HTTP\/MIME_types\/Common_types */
 const mimeTypes = {
     ".aac": "audio/aac",
     ".abw": "application/x-abiword",
@@ -653,6 +712,9 @@ class HelpersIsomorphic {
 /* */
 /* */
 /* */
+/* \/\/ import \{ config \} from 'tnp\-config'; */
+/* \/\/ import \{ PROGRESS_DATA \} from 'tnp\-models'; */
+/* \/\/ TODO handle global\.testMode \? */
 const KEY = {
     LAST_ERROR: Symbol(),
     LAST_INFO: Symbol(),
@@ -703,6 +765,34 @@ const KEY_IMPORTANTCE = {
 /* */
 /* */
 const LIMIT = 10;
+/* \/\/ export class Log \{ */
+/* \/\/   private static _instance: Log; */
+/* \/\/   public Instance\(\) \{ */
+/* \/\/     if \(!Log\._instance\) \{ */
+/* \/\/       Log\._instance = new Log\(\); */
+/* \/\/     \} */
+/* \/\/     return Log\._instance; */
+/* \/\/   \} */
+/* \/\/   create\(name: string, level\?: Level\) \{ */
+/* \/\/     if \(level === void 0\) \{ */
+/* \/\/       level = Level\.DATA; */
+/* \/\/     \} */
+/* \/\/     return \{ */
+/* \/\/       d\(details: string, debugLevel\?: number\) \{ */
+/* \/\/         return Helpers\.log\(`\[\$\{name\}\] \$\{details\}`, debugLevel\) */
+/* \/\/       \}, */
+/* \/\/       i\(details: string\) \{ */
+/* \/\/         return Helpers\.info\(`\[\$\{name\}\] \$\{details\}`\) */
+/* \/\/       \}, */
+/* \/\/       w\(details: string, noExit = false, noTrace = false\) \{ */
+/* \/\/         return Helpers\.error\(`\[\$\{name\}\] \$\{details\}`, noExit, noTrace\); */
+/* \/\/       \}, */
+/* \/\/       er\(details: string, \) \{ */
+/* \/\/         return Helpers\.info\(`\[\$\{name\}\] \$\{details\}`\) */
+/* \/\/       \}, */
+/* \/\/     \} */
+/* \/\/   \} */
+/* \/\/ \} */
 class HelpersMessages extends HelpersIsomorphic {
     msgCacheClear() {
         /* */
@@ -716,6 +806,7 @@ class HelpersMessages extends HelpersIsomorphic {
         /* */
         /* */
         /* */
+        /*     \/\/ TODO for FE */
         console.error(err);
     }
     error(details, noExit = false, noTrace = false) {
@@ -1219,6 +1310,7 @@ class HelpersCore extends HelpersMessages {
      * @returns
      */
     isBlob(maybeBlob) {
+        /*     \/\/ TODO is this needed hmmmm */
         return maybeBlob instanceof Blob; // || toString.call(maybeBlob) === '[object Blob]';
     }
     /**
@@ -1243,6 +1335,13 @@ class HelpersCore extends HelpersMessages {
      * stringify to pretty json string
      */
     stringify(inputObject) {
+        /*     \/\/ if \(_\.isString\(inputObject\)\) \{ */
+        /*     \/\/   return inputObject; */
+        /*     \/\/ \} */
+        /*     \/\/ if \(_\.isObject\(inputObject\)\) \{ */
+        /*     \/\/   config\.log\(inputObject\) */
+        /*     \/\/   Helpers\.error\(`\[tnp\-helpers\] trying to stringify not a object`, false, true\); */
+        /*     \/\/ \} */
         return JSON.stringify(inputObject, null, 2);
     }
     async runSyncOrAsync(fnOrOptions, ...firstArg) {
@@ -1262,9 +1361,12 @@ class HelpersCore extends HelpersMessages {
             // @ts-ignore
             promisOrValue = _.isArray(fnOrOptions) ? fnOrOptions[1][fnOrOptions[0]](...firstArg) : fnOrOptions(...firstArg);
         }
+        /*     \/\/ let wasPromise = false; */
         if (promisOrValue instanceof Promise) {
+            /*       \/\/ wasPromise = true; */
             promisOrValue = Promise.resolve(promisOrValue);
         }
+        /*     \/\/ console\.log\('was promis ', wasPromise\) */
         return promisOrValue;
     }
     /* */
@@ -1590,7 +1692,9 @@ class HelpersCore extends HelpersMessages {
     /* */
     /* */
     /* */
-    exists(folderOrFilePath) {
+    exists(folderOrFilePath
+    /*     \/\/ , allowUnexistedLinks = false */
+    ) {
         /* */
         /* */
         /* */
@@ -1627,6 +1731,7 @@ class HelpersCore extends HelpersMessages {
         return command;
     }
     command(command) {
+        /*     \/\/ console\.log\(\{ command \}\) */
         command = Helpers._fixCommand(command);
         return {
         /* */
@@ -1795,6 +1900,7 @@ class HelpersCore extends HelpersMessages {
     }
     run(command, options) {
         command = Helpers._fixCommand(command);
+        /*     \/\/ console\.log\(\{ command \}\) */
         /* */
         /* */
         /* */
@@ -2431,6 +2537,7 @@ class PROGRESS_DATA {
         if (checkSplit) {
             const split = chunk.split(/\r\n|\n|\r/);
             if (split.length > 1) {
+                /*         \/\/ console\.log\('split founded', split\) */
                 split.forEach(s => {
                     res = res.concat(this.resolveFrom(s, callbackOnFounded, false));
                 });
@@ -2532,6 +2639,7 @@ var Utils;
                 if (!m) {
                     throw new Error(`[firedev-framework][base64toBlob] Not a base64 blob [${base64Data}]`);
                 }
+                /*         \/\/ tslint:disable\-next\-line:prefer\-const */
                 var [__, contenttype, filebase64] = m;
                 content_type = contenttype;
                 file_base64 = filebase64;
@@ -2547,6 +2655,7 @@ var Utils;
                 const begin = sliceIndex * sliceSize;
                 const end = Math.min(begin + sliceSize, bytesLength);
                 const bytes = new Array(end - begin);
+                /*         \/\/ tslint:disable\-next\-line:one\-variable\-per\-declaration */
                 for (let offset = begin, i = 0; offset < end; ++i, ++offset) {
                     bytes[i] = byteCharacters[offset].charCodeAt(0);
                 }
@@ -2682,10 +2791,16 @@ var Utils;
         }
         binary.blobToText = blobToText;
         async function textToFile(text, fileRelativePathOrName) {
+            /*       \/\/ console\.log\(\{ path \}\) */
             const ext = path.extname(fileRelativePathOrName);
             const type = mimeTypes[ext];
             const blob = new Blob([text], { type });
             const file = await blobToFile(blob, fileRelativePathOrName);
+            /*       \/\/ console\.log\(\{ */
+            /*       \/\/   ext, */
+            /*       \/\/   blob, file */
+            /*       \/\/ \}\); */
+            /*       \/\/ debugger */
             return file;
         }
         binary.textToFile = textToFile;
@@ -2723,8 +2838,12 @@ var Utils;
          * @returns
          */
         function numValue(pixelsCss) {
+            /*       \/\/ tslint:disable\-next\-line:radix */
             return parseInt(pixelsCss
-                .replace('px', ''));
+                .replace('px', '')
+            /*         \/\/ \.replace\('pt', ''\) TOOD handle other types */
+            /*         \/\/ \.replace\('1rem', ''\) \/\/ to */
+            );
         }
         css.numValue = numValue;
     })(css = Utils.css || (Utils.css = {}));