@egi/smart-log 1.0.0

package/smart-tools.js

@@ -0,0 +1,349 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tools = exports.SmartTools = void 0;
+var fs = require("node:fs");
+// noinspection JSUnusedGlobalSymbols
+var SmartTools = /** @class */ (function () {
+    function SmartTools() {
+    }
+    /**
+     * Captures the stack trace starting from the point just below the provided function.
+     *
+     * @param belowFn - A reference function to exclude from the stack trace.
+     * @returns An array of FrameData objects representing the captured stack trace.
+     */
+    SmartTools.prototype.getStackTrace = function (belowFn) {
+        var _a;
+        var myStackTrace = {};
+        var oldLimit = Error.stackTraceLimit;
+        Error.stackTraceLimit = Infinity;
+        var v8Handler = Error.prepareStackTrace;
+        Error.prepareStackTrace = function (_error, v8StackTrace) {
+            return v8StackTrace;
+        };
+        Error.captureStackTrace(myStackTrace, belowFn || this.getStackTrace);
+        // Extract the stack to avoid any changes by resetting operations below
+        var stack = (_a = myStackTrace.stack) !== null && _a !== void 0 ? _a : [];
+        Error.prepareStackTrace = v8Handler;
+        Error.stackTraceLimit = oldLimit;
+        return stack.map(function (callSite) {
+            return {
+                columnNumber: callSite.getColumnNumber(),
+                fileName: callSite.getFileName(),
+                functionName: callSite.getFunctionName(),
+                lineNumber: callSite.getLineNumber(),
+                methodName: callSite.getMethodName(),
+                native: callSite.isNative(),
+                typeName: callSite.getTypeName()
+            };
+        });
+    };
+    /**
+     * Parses an error's stack trace into an array of FrameData objects.
+     *
+     * @param err - An error object containing the stack trace.
+     * @returns An array of FrameData objects parsed from the error's stack trace.
+     */
+    SmartTools.prototype.parseStackTrace = function (err) {
+        var result = [];
+        if (err.stack) {
+            var lines = err.stack.split("\n").slice(1);
+            result = lines.map(function (line) {
+                var stackFrame = null;
+                if (line.match(/^\s*-{4,}$/)) {
+                    stackFrame = {
+                        fileName: line,
+                        lineNumber: null,
+                        functionName: null,
+                        typeName: null,
+                        methodName: null,
+                        columnNumber: null,
+                        native: null
+                    };
+                }
+                else {
+                    var matches = line.match(/at (?:(.+?)\s+\()?(?:(.+?):(\d+)(?::(\d+))?|([^)]+))\)?/);
+                    if (matches) {
+                        var object = null;
+                        var method = null;
+                        var functionName = null;
+                        var typeName = null;
+                        var methodName = null;
+                        var isNative = (matches[5] === "native");
+                        if (matches[1]) {
+                            functionName = matches[1];
+                            var methodStart = functionName.lastIndexOf('.');
+                            if (functionName[methodStart - 1] == ".")
+                                methodStart--;
+                            if (methodStart > 0) {
+                                object = functionName.substring(0, methodStart);
+                                method = functionName.substring(methodStart + 1);
+                                var objectEnd = object.indexOf('.Module');
+                                if (objectEnd > 0) {
+                                    functionName = functionName.substring(objectEnd + 1);
+                                    object = object.substring(0, objectEnd);
+                                }
+                            }
+                        }
+                        if (method) {
+                            typeName = object;
+                            methodName = method;
+                        }
+                        if (method === "<anonymous>") {
+                            methodName = null;
+                            functionName = null;
+                        }
+                        stackFrame = {
+                            fileName: matches[2],
+                            lineNumber: parseInt(matches[3], 10),
+                            functionName: functionName,
+                            typeName: typeName,
+                            methodName: methodName,
+                            columnNumber: parseInt(matches[4], 10),
+                            "native": isNative
+                        };
+                    }
+                }
+                return stackFrame;
+            }, this).filter(function (frameData) {
+                return !!frameData;
+            });
+        }
+        return result;
+    };
+    /**
+     * Retrieves caller information from the stack trace, excluding specified files or patterns.
+     *
+     * @param {Error | (() => Error)} [errorOrStackProvider] - An error object or function returning an error,
+     *     used to extract the stack trace. Defaults to capturing the current stack trace if omitted.
+     * @param options - Optional settings for filtering and formatting the caller information.
+     * @returns {string} A string with the format "fileName:lineNumber (functionName)",
+     *     or "unknown location" if caller information cannot be determined.
+     */
+    SmartTools.prototype.getCallerFromStack = function (errorOrStackProvider, options) {
+        if (options === void 0) { options = {}; }
+        var stack;
+        if (errorOrStackProvider instanceof Error) {
+            stack = this.parseStackTrace(errorOrStackProvider);
+        }
+        else if (typeof errorOrStackProvider == "function") {
+            stack = this.parseStackTrace(errorOrStackProvider());
+        }
+        else {
+            stack = this.getStackTrace();
+        }
+        var ignoreFiles = [fs.realpathSync(__filename)];
+        if (options.ignoreFiles) {
+            ignoreFiles.push.apply(ignoreFiles, __spreadArray([], __read(options.ignoreFiles), false));
+        }
+        var frame = stack.find(function (f) {
+            var method = f.functionName;
+            return !ignoreFiles.includes(f.fileName) && !(method === null || method === void 0 ? void 0 : method.match(/stackprovider/i));
+        });
+        var callerLine;
+        if (frame) {
+            var method = frame.functionName;
+            var fileName = frame.fileName.replace("file://", "");
+            if (options.projectRoot) {
+                fileName = fileName.replace(options.projectRoot, ".");
+            }
+            if (method) {
+                callerLine = "".concat(fileName, ":").concat(frame.lineNumber, " (").concat(method, ")");
+            }
+            else {
+                callerLine = "".concat(fileName, ":").concat(frame.lineNumber);
+            }
+        }
+        else {
+            // Unlikely to happen unless the stack trace is empty or malformed
+            callerLine = "unknown location";
+        }
+        return callerLine;
+    };
+    SmartTools.prototype.kebabCase = function (s) {
+        return this.splitWords(s).join("-");
+    };
+    SmartTools.prototype.snakeCase = function (s) {
+        return this.splitWords(s).join("_");
+    };
+    SmartTools.prototype.camelCase = function (s) {
+        var ret;
+        if (s) {
+            var words = this.splitWords(s);
+            ret = words.shift();
+            if (words.length > 0) {
+                ret += words.map(function (w) { return w[0].toUpperCase() + w.substring(1); }).join("");
+            }
+        }
+        else {
+            ret = "";
+        }
+        return ret;
+    };
+    SmartTools.prototype.pascalCase = function (s) {
+        var ret;
+        if (s) {
+            var words = this.splitWords(s);
+            ret = words.map(function (w) {
+                if (w.length > 0) {
+                    return w[0].toUpperCase() + w.substring(1);
+                }
+                else {
+                    return "";
+                }
+            }).join("");
+        }
+        else {
+            ret = "";
+        }
+        return ret;
+    };
+    SmartTools.prototype.titleCase = function (s) {
+        var ret;
+        if (s) {
+            ret = this.splitWords(s).map(function (w) { return w[0].toUpperCase() + w.substring(1); }).join(" ");
+        }
+        else {
+            ret = "";
+        }
+        return ret;
+    };
+    SmartTools.prototype.constantCase = function (s) {
+        return this.snakeCase(s).toUpperCase();
+    };
+    SmartTools.prototype.clone = function (obj) {
+        return __assign({}, obj);
+    };
+    SmartTools.prototype.cloneDeep = function (obj) {
+        var e_1, _a;
+        var _this = this;
+        if (obj === null || typeof obj !== "object") {
+            return obj; // Return primitive values directly
+        }
+        if (Array.isArray(obj)) {
+            return obj.map(function (item) { return _this.cloneDeep(item); });
+        }
+        var clonedObj = {};
+        try {
+            for (var _b = __values(Object.keys(obj)), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var key = _c.value;
+                clonedObj[key] = this.cloneDeep(obj[key]);
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        return clonedObj;
+    };
+    SmartTools.prototype.isSimpleObject = function (obj) {
+        return !!obj && obj.constructor === Object;
+    };
+    SmartTools.prototype.isObject = function (obj) {
+        return !!obj && obj === Object(obj);
+    };
+    SmartTools.prototype.isArray = function (obj) {
+        return Array.isArray(obj);
+    };
+    SmartTools.prototype.isString = function (obj) {
+        return typeof obj === "string" || obj instanceof String;
+    };
+    SmartTools.prototype.isNumber = function (obj) {
+        return typeof obj === 'number' && isFinite(obj);
+    };
+    SmartTools.prototype.isBoolean = function (obj) {
+        return typeof obj === "boolean";
+    };
+    SmartTools.prototype.isNull = function (obj) {
+        return obj === null;
+    };
+    SmartTools.prototype.isUndefined = function (obj) {
+        return obj === undefined;
+    };
+    SmartTools.prototype.isFunction = function (obj) {
+        return typeof obj === "function";
+    };
+    SmartTools.prototype.isDate = function (obj) {
+        return obj instanceof Date;
+    };
+    SmartTools.prototype.isRegExp = function (obj) {
+        return obj instanceof RegExp;
+    };
+    SmartTools.prototype.isError = function (obj) {
+        return obj instanceof Error;
+    };
+    SmartTools.prototype.isSymbol = function (obj) {
+        return typeof obj === "symbol";
+    };
+    SmartTools.prototype.isEmpty = function (obj) {
+        if (obj === null || obj === undefined) {
+            return true;
+        }
+        if (this.isString(obj) || this.isArray(obj)) {
+            return obj.length === 0;
+        }
+        if (this.isSimpleObject(obj)) {
+            return Object.keys(obj).length === 0;
+        }
+        return false;
+    };
+    SmartTools.prototype.isPrimitive = function (obj) {
+        return this.isString(obj) || this.isNumber(obj) || this.isBoolean(obj) || this.isNull(obj) || this.isUndefined(obj) || this.isSymbol(obj);
+    };
+    SmartTools.prototype.splitWords = function (s) {
+        return s.replace(/([a-z0-9])([A-Z])/g, "$1-$2").replace(/_/g, "-").toLowerCase().split("-");
+    };
+    return SmartTools;
+}());
+exports.SmartTools = SmartTools;
+exports.tools = new SmartTools();

package/tsconfig.pro.tsbuildinfo

@@ -0,0 +1 @@
+{"root":["../src/smart-error.ts","../src/smart-log-api.ts","../src/smart-log-date-utils.ts","../src/smart-log.ts","../src/smart-tools.ts"],"version":"5.6.3"}