rslog 1.2.1 → 1.2.2
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/dist/index.cjs +334 -6
- package/dist/index.mjs +296 -6
- package/package.json +1 -1
package/dist/index.cjs
CHANGED
|
@@ -1,6 +1,334 @@
|
|
|
1
|
-
"use strict";
|
|
2
|
-
|
|
3
|
-
|
|
4
|
-
|
|
5
|
-
|
|
6
|
-
|
|
1
|
+
"use strict";
|
|
2
|
+
var __create = Object.create;
|
|
3
|
+
var __defProp = Object.defineProperty;
|
|
4
|
+
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
|
|
5
|
+
var __getOwnPropNames = Object.getOwnPropertyNames;
|
|
6
|
+
var __getProtoOf = Object.getPrototypeOf;
|
|
7
|
+
var __hasOwnProp = Object.prototype.hasOwnProperty;
|
|
8
|
+
var __export = (target, all) => {
|
|
9
|
+
for (var name in all)
|
|
10
|
+
__defProp(target, name, { get: all[name], enumerable: true });
|
|
11
|
+
};
|
|
12
|
+
var __copyProps = (to, from, except, desc) => {
|
|
13
|
+
if (from && typeof from === "object" || typeof from === "function") {
|
|
14
|
+
for (let key of __getOwnPropNames(from))
|
|
15
|
+
if (!__hasOwnProp.call(to, key) && key !== except)
|
|
16
|
+
__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
|
|
17
|
+
}
|
|
18
|
+
return to;
|
|
19
|
+
};
|
|
20
|
+
var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
|
|
21
|
+
// If the importer is in node compatibility mode or this is not an ESM
|
|
22
|
+
// file that has been converted to a CommonJS file using a Babel-
|
|
23
|
+
// compatible transform (i.e. "__esModule" has not been set), then set
|
|
24
|
+
// "default" to the CommonJS "module.exports" for node compatibility.
|
|
25
|
+
isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
|
|
26
|
+
mod
|
|
27
|
+
));
|
|
28
|
+
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
|
|
29
|
+
|
|
30
|
+
// src/index.ts
|
|
31
|
+
var src_exports = {};
|
|
32
|
+
__export(src_exports, {
|
|
33
|
+
createLogger: () => createLogger,
|
|
34
|
+
logger: () => logger
|
|
35
|
+
});
|
|
36
|
+
module.exports = __toCommonJS(src_exports);
|
|
37
|
+
|
|
38
|
+
// node_modules/.pnpm/supports-color@9.4.0/node_modules/supports-color/index.js
|
|
39
|
+
var import_node_process = __toESM(require("process"));
|
|
40
|
+
var import_node_os = __toESM(require("os"));
|
|
41
|
+
var import_node_tty = __toESM(require("tty"));
|
|
42
|
+
function hasFlag(flag, argv = globalThis.Deno ? globalThis.Deno.args : import_node_process.default.argv) {
|
|
43
|
+
const prefix = flag.startsWith("-") ? "" : flag.length === 1 ? "-" : "--";
|
|
44
|
+
const position = argv.indexOf(prefix + flag);
|
|
45
|
+
const terminatorPosition = argv.indexOf("--");
|
|
46
|
+
return position !== -1 && (terminatorPosition === -1 || position < terminatorPosition);
|
|
47
|
+
}
|
|
48
|
+
var { env } = import_node_process.default;
|
|
49
|
+
var flagForceColor;
|
|
50
|
+
if (hasFlag("no-color") || hasFlag("no-colors") || hasFlag("color=false") || hasFlag("color=never")) {
|
|
51
|
+
flagForceColor = 0;
|
|
52
|
+
} else if (hasFlag("color") || hasFlag("colors") || hasFlag("color=true") || hasFlag("color=always")) {
|
|
53
|
+
flagForceColor = 1;
|
|
54
|
+
}
|
|
55
|
+
function envForceColor() {
|
|
56
|
+
if ("FORCE_COLOR" in env) {
|
|
57
|
+
if (env.FORCE_COLOR === "true") {
|
|
58
|
+
return 1;
|
|
59
|
+
}
|
|
60
|
+
if (env.FORCE_COLOR === "false") {
|
|
61
|
+
return 0;
|
|
62
|
+
}
|
|
63
|
+
return env.FORCE_COLOR.length === 0 ? 1 : Math.min(Number.parseInt(env.FORCE_COLOR, 10), 3);
|
|
64
|
+
}
|
|
65
|
+
}
|
|
66
|
+
function translateLevel(level) {
|
|
67
|
+
if (level === 0) {
|
|
68
|
+
return false;
|
|
69
|
+
}
|
|
70
|
+
return {
|
|
71
|
+
level,
|
|
72
|
+
hasBasic: true,
|
|
73
|
+
has256: level >= 2,
|
|
74
|
+
has16m: level >= 3
|
|
75
|
+
};
|
|
76
|
+
}
|
|
77
|
+
function _supportsColor(haveStream, { streamIsTTY, sniffFlags = true } = {}) {
|
|
78
|
+
const noFlagForceColor = envForceColor();
|
|
79
|
+
if (noFlagForceColor !== void 0) {
|
|
80
|
+
flagForceColor = noFlagForceColor;
|
|
81
|
+
}
|
|
82
|
+
const forceColor = sniffFlags ? flagForceColor : noFlagForceColor;
|
|
83
|
+
if (forceColor === 0) {
|
|
84
|
+
return 0;
|
|
85
|
+
}
|
|
86
|
+
if (sniffFlags) {
|
|
87
|
+
if (hasFlag("color=16m") || hasFlag("color=full") || hasFlag("color=truecolor")) {
|
|
88
|
+
return 3;
|
|
89
|
+
}
|
|
90
|
+
if (hasFlag("color=256")) {
|
|
91
|
+
return 2;
|
|
92
|
+
}
|
|
93
|
+
}
|
|
94
|
+
if ("TF_BUILD" in env && "AGENT_NAME" in env) {
|
|
95
|
+
return 1;
|
|
96
|
+
}
|
|
97
|
+
if (haveStream && !streamIsTTY && forceColor === void 0) {
|
|
98
|
+
return 0;
|
|
99
|
+
}
|
|
100
|
+
const min = forceColor || 0;
|
|
101
|
+
if (env.TERM === "dumb") {
|
|
102
|
+
return min;
|
|
103
|
+
}
|
|
104
|
+
if (import_node_process.default.platform === "win32") {
|
|
105
|
+
const osRelease = import_node_os.default.release().split(".");
|
|
106
|
+
if (Number(osRelease[0]) >= 10 && Number(osRelease[2]) >= 10586) {
|
|
107
|
+
return Number(osRelease[2]) >= 14931 ? 3 : 2;
|
|
108
|
+
}
|
|
109
|
+
return 1;
|
|
110
|
+
}
|
|
111
|
+
if ("CI" in env) {
|
|
112
|
+
if ("GITHUB_ACTIONS" in env || "GITEA_ACTIONS" in env) {
|
|
113
|
+
return 3;
|
|
114
|
+
}
|
|
115
|
+
if (["TRAVIS", "CIRCLECI", "APPVEYOR", "GITLAB_CI", "BUILDKITE", "DRONE"].some((sign) => sign in env) || env.CI_NAME === "codeship") {
|
|
116
|
+
return 1;
|
|
117
|
+
}
|
|
118
|
+
return min;
|
|
119
|
+
}
|
|
120
|
+
if ("TEAMCITY_VERSION" in env) {
|
|
121
|
+
return /^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(env.TEAMCITY_VERSION) ? 1 : 0;
|
|
122
|
+
}
|
|
123
|
+
if (env.COLORTERM === "truecolor") {
|
|
124
|
+
return 3;
|
|
125
|
+
}
|
|
126
|
+
if (env.TERM === "xterm-kitty") {
|
|
127
|
+
return 3;
|
|
128
|
+
}
|
|
129
|
+
if ("TERM_PROGRAM" in env) {
|
|
130
|
+
const version = Number.parseInt((env.TERM_PROGRAM_VERSION || "").split(".")[0], 10);
|
|
131
|
+
switch (env.TERM_PROGRAM) {
|
|
132
|
+
case "iTerm.app": {
|
|
133
|
+
return version >= 3 ? 3 : 2;
|
|
134
|
+
}
|
|
135
|
+
case "Apple_Terminal": {
|
|
136
|
+
return 2;
|
|
137
|
+
}
|
|
138
|
+
}
|
|
139
|
+
}
|
|
140
|
+
if (/-256(color)?$/i.test(env.TERM)) {
|
|
141
|
+
return 2;
|
|
142
|
+
}
|
|
143
|
+
if (/^screen|^xterm|^vt100|^vt220|^rxvt|color|ansi|cygwin|linux/i.test(env.TERM)) {
|
|
144
|
+
return 1;
|
|
145
|
+
}
|
|
146
|
+
if ("COLORTERM" in env) {
|
|
147
|
+
return 1;
|
|
148
|
+
}
|
|
149
|
+
return min;
|
|
150
|
+
}
|
|
151
|
+
function createSupportsColor(stream, options = {}) {
|
|
152
|
+
const level = _supportsColor(stream, {
|
|
153
|
+
streamIsTTY: stream && stream.isTTY,
|
|
154
|
+
...options
|
|
155
|
+
});
|
|
156
|
+
return translateLevel(level);
|
|
157
|
+
}
|
|
158
|
+
var supportsColor = {
|
|
159
|
+
stdout: createSupportsColor({ isTTY: import_node_tty.default.isatty(1) }),
|
|
160
|
+
stderr: createSupportsColor({ isTTY: import_node_tty.default.isatty(2) })
|
|
161
|
+
};
|
|
162
|
+
var supports_color_default = supportsColor;
|
|
163
|
+
|
|
164
|
+
// src/utils.ts
|
|
165
|
+
var colorLevel = supports_color_default.stdout ? supports_color_default.stdout.level : 0;
|
|
166
|
+
var errorStackRegExp = /at\s.*:\d+:\d+[\s\)]*$/;
|
|
167
|
+
var anonymousErrorStackRegExp = /^\s*at\s.*\(<anonymous>\)$/;
|
|
168
|
+
var isErrorStackMessage = (message) => errorStackRegExp.test(message) || anonymousErrorStackRegExp.test(message);
|
|
169
|
+
|
|
170
|
+
// src/color.ts
|
|
171
|
+
var formatter = (open, close, replace = open) => colorLevel >= 2 ? (input) => {
|
|
172
|
+
let string = "" + input;
|
|
173
|
+
let index = string.indexOf(close, open.length);
|
|
174
|
+
return ~index ? open + replaceClose(string, close, replace, index) + close : open + string + close;
|
|
175
|
+
} : String;
|
|
176
|
+
var replaceClose = (string, close, replace, index) => {
|
|
177
|
+
let start = string.substring(0, index) + replace;
|
|
178
|
+
let end = string.substring(index + close.length);
|
|
179
|
+
let nextIndex = end.indexOf(close);
|
|
180
|
+
return ~nextIndex ? start + replaceClose(end, close, replace, nextIndex) : start + end;
|
|
181
|
+
};
|
|
182
|
+
var bold = formatter("\x1B[1m", "\x1B[22m", "\x1B[22m\x1B[1m");
|
|
183
|
+
var red = formatter("\x1B[31m", "\x1B[39m");
|
|
184
|
+
var green = formatter("\x1B[32m", "\x1B[39m");
|
|
185
|
+
var yellow = formatter("\x1B[33m", "\x1B[39m");
|
|
186
|
+
var magenta = formatter("\x1B[35m", "\x1B[39m");
|
|
187
|
+
var cyan = formatter("\x1B[36m", "\x1B[39m");
|
|
188
|
+
var gray = formatter("\x1B[90m", "\x1B[39m");
|
|
189
|
+
|
|
190
|
+
// src/gradient.ts
|
|
191
|
+
var startColor = [189, 255, 243];
|
|
192
|
+
var endColor = [74, 194, 154];
|
|
193
|
+
var isWord = (char) => !/[\s\n]/.test(char);
|
|
194
|
+
var gradient = (message) => {
|
|
195
|
+
if (colorLevel < 3) {
|
|
196
|
+
return colorLevel === 2 ? bold(cyan(message)) : message;
|
|
197
|
+
}
|
|
198
|
+
let chars = [...message];
|
|
199
|
+
let steps = chars.filter(isWord).length;
|
|
200
|
+
let r = startColor[0];
|
|
201
|
+
let g = startColor[1];
|
|
202
|
+
let b = startColor[2];
|
|
203
|
+
let rStep = (endColor[0] - r) / steps;
|
|
204
|
+
let gStep = (endColor[1] - g) / steps;
|
|
205
|
+
let bStep = (endColor[2] - b) / steps;
|
|
206
|
+
let output = "";
|
|
207
|
+
for (let char of chars) {
|
|
208
|
+
if (isWord(char)) {
|
|
209
|
+
r += rStep;
|
|
210
|
+
g += gStep;
|
|
211
|
+
b += bStep;
|
|
212
|
+
}
|
|
213
|
+
output += `\x1B[38;2;${Math.round(r)};${Math.round(g)};${Math.round(
|
|
214
|
+
b
|
|
215
|
+
)}m${char}\x1B[39m`;
|
|
216
|
+
}
|
|
217
|
+
return bold(output);
|
|
218
|
+
};
|
|
219
|
+
|
|
220
|
+
// src/constants.ts
|
|
221
|
+
var LOG_LEVEL = {
|
|
222
|
+
error: 0,
|
|
223
|
+
warn: 1,
|
|
224
|
+
info: 2,
|
|
225
|
+
log: 3,
|
|
226
|
+
verbose: 4
|
|
227
|
+
};
|
|
228
|
+
var LOG_TYPES = {
|
|
229
|
+
// Level error
|
|
230
|
+
error: {
|
|
231
|
+
label: "error",
|
|
232
|
+
level: "error",
|
|
233
|
+
color: red
|
|
234
|
+
},
|
|
235
|
+
// Level warn
|
|
236
|
+
warn: {
|
|
237
|
+
label: "warn",
|
|
238
|
+
level: "warn",
|
|
239
|
+
color: yellow
|
|
240
|
+
},
|
|
241
|
+
// Level info
|
|
242
|
+
info: {
|
|
243
|
+
label: "info",
|
|
244
|
+
level: "info",
|
|
245
|
+
color: cyan
|
|
246
|
+
},
|
|
247
|
+
start: {
|
|
248
|
+
label: "start",
|
|
249
|
+
level: "info",
|
|
250
|
+
color: cyan
|
|
251
|
+
},
|
|
252
|
+
ready: {
|
|
253
|
+
label: "ready",
|
|
254
|
+
level: "info",
|
|
255
|
+
color: green
|
|
256
|
+
},
|
|
257
|
+
success: {
|
|
258
|
+
label: "success",
|
|
259
|
+
level: "info",
|
|
260
|
+
color: green
|
|
261
|
+
},
|
|
262
|
+
// Level log
|
|
263
|
+
log: {
|
|
264
|
+
level: "log"
|
|
265
|
+
},
|
|
266
|
+
// Level debug
|
|
267
|
+
debug: {
|
|
268
|
+
label: "debug",
|
|
269
|
+
level: "verbose",
|
|
270
|
+
color: magenta
|
|
271
|
+
}
|
|
272
|
+
};
|
|
273
|
+
|
|
274
|
+
// src/createLogger.ts
|
|
275
|
+
var createLogger = (options = {}) => {
|
|
276
|
+
let maxLevel = options.level || "log";
|
|
277
|
+
let log = (type, message, ...args) => {
|
|
278
|
+
if (LOG_LEVEL[LOG_TYPES[type].level] > LOG_LEVEL[maxLevel]) {
|
|
279
|
+
return;
|
|
280
|
+
}
|
|
281
|
+
if (message === void 0 || message === null) {
|
|
282
|
+
return console.log();
|
|
283
|
+
}
|
|
284
|
+
let logType = LOG_TYPES[type];
|
|
285
|
+
let label = "";
|
|
286
|
+
let text = "";
|
|
287
|
+
if ("label" in logType) {
|
|
288
|
+
label = (logType.label || "").padEnd(7);
|
|
289
|
+
label = bold(logType.color ? logType.color(label) : label);
|
|
290
|
+
}
|
|
291
|
+
if (message instanceof Error) {
|
|
292
|
+
if (message.stack) {
|
|
293
|
+
let [name, ...rest] = message.stack.split("\n");
|
|
294
|
+
if (name.startsWith("Error: ")) {
|
|
295
|
+
name = name.slice(7);
|
|
296
|
+
}
|
|
297
|
+
text = `${name}
|
|
298
|
+
${gray(rest.join("\n"))}`;
|
|
299
|
+
} else {
|
|
300
|
+
text = message.message;
|
|
301
|
+
}
|
|
302
|
+
} else if (logType.level === "error" && typeof message === "string") {
|
|
303
|
+
let lines = message.split("\n");
|
|
304
|
+
text = lines.map((line) => isErrorStackMessage(line) ? gray(line) : line).join("\n");
|
|
305
|
+
} else {
|
|
306
|
+
text = `${message}`;
|
|
307
|
+
}
|
|
308
|
+
console.log(label.length ? `${label} ${text}` : text, ...args);
|
|
309
|
+
};
|
|
310
|
+
let logger2 = {
|
|
311
|
+
greet: (message) => log("log", gradient(message))
|
|
312
|
+
};
|
|
313
|
+
Object.keys(LOG_TYPES).forEach((key) => {
|
|
314
|
+
logger2[key] = (...args) => log(key, ...args);
|
|
315
|
+
});
|
|
316
|
+
Object.defineProperty(logger2, "level", {
|
|
317
|
+
get: () => maxLevel,
|
|
318
|
+
set(val) {
|
|
319
|
+
maxLevel = val;
|
|
320
|
+
}
|
|
321
|
+
});
|
|
322
|
+
logger2.override = (customLogger) => {
|
|
323
|
+
Object.assign(logger2, customLogger);
|
|
324
|
+
};
|
|
325
|
+
return logger2;
|
|
326
|
+
};
|
|
327
|
+
|
|
328
|
+
// src/index.ts
|
|
329
|
+
var logger = createLogger();
|
|
330
|
+
// Annotate the CommonJS export names for ESM import in node:
|
|
331
|
+
0 && (module.exports = {
|
|
332
|
+
createLogger,
|
|
333
|
+
logger
|
|
334
|
+
});
|
package/dist/index.mjs
CHANGED
|
@@ -1,6 +1,296 @@
|
|
|
1
|
-
|
|
2
|
-
|
|
3
|
-
|
|
4
|
-
|
|
5
|
-
|
|
6
|
-
|
|
1
|
+
// node_modules/.pnpm/supports-color@9.4.0/node_modules/supports-color/index.js
|
|
2
|
+
import process from "process";
|
|
3
|
+
import os from "os";
|
|
4
|
+
import tty from "tty";
|
|
5
|
+
function hasFlag(flag, argv = globalThis.Deno ? globalThis.Deno.args : process.argv) {
|
|
6
|
+
const prefix = flag.startsWith("-") ? "" : flag.length === 1 ? "-" : "--";
|
|
7
|
+
const position = argv.indexOf(prefix + flag);
|
|
8
|
+
const terminatorPosition = argv.indexOf("--");
|
|
9
|
+
return position !== -1 && (terminatorPosition === -1 || position < terminatorPosition);
|
|
10
|
+
}
|
|
11
|
+
var { env } = process;
|
|
12
|
+
var flagForceColor;
|
|
13
|
+
if (hasFlag("no-color") || hasFlag("no-colors") || hasFlag("color=false") || hasFlag("color=never")) {
|
|
14
|
+
flagForceColor = 0;
|
|
15
|
+
} else if (hasFlag("color") || hasFlag("colors") || hasFlag("color=true") || hasFlag("color=always")) {
|
|
16
|
+
flagForceColor = 1;
|
|
17
|
+
}
|
|
18
|
+
function envForceColor() {
|
|
19
|
+
if ("FORCE_COLOR" in env) {
|
|
20
|
+
if (env.FORCE_COLOR === "true") {
|
|
21
|
+
return 1;
|
|
22
|
+
}
|
|
23
|
+
if (env.FORCE_COLOR === "false") {
|
|
24
|
+
return 0;
|
|
25
|
+
}
|
|
26
|
+
return env.FORCE_COLOR.length === 0 ? 1 : Math.min(Number.parseInt(env.FORCE_COLOR, 10), 3);
|
|
27
|
+
}
|
|
28
|
+
}
|
|
29
|
+
function translateLevel(level) {
|
|
30
|
+
if (level === 0) {
|
|
31
|
+
return false;
|
|
32
|
+
}
|
|
33
|
+
return {
|
|
34
|
+
level,
|
|
35
|
+
hasBasic: true,
|
|
36
|
+
has256: level >= 2,
|
|
37
|
+
has16m: level >= 3
|
|
38
|
+
};
|
|
39
|
+
}
|
|
40
|
+
function _supportsColor(haveStream, { streamIsTTY, sniffFlags = true } = {}) {
|
|
41
|
+
const noFlagForceColor = envForceColor();
|
|
42
|
+
if (noFlagForceColor !== void 0) {
|
|
43
|
+
flagForceColor = noFlagForceColor;
|
|
44
|
+
}
|
|
45
|
+
const forceColor = sniffFlags ? flagForceColor : noFlagForceColor;
|
|
46
|
+
if (forceColor === 0) {
|
|
47
|
+
return 0;
|
|
48
|
+
}
|
|
49
|
+
if (sniffFlags) {
|
|
50
|
+
if (hasFlag("color=16m") || hasFlag("color=full") || hasFlag("color=truecolor")) {
|
|
51
|
+
return 3;
|
|
52
|
+
}
|
|
53
|
+
if (hasFlag("color=256")) {
|
|
54
|
+
return 2;
|
|
55
|
+
}
|
|
56
|
+
}
|
|
57
|
+
if ("TF_BUILD" in env && "AGENT_NAME" in env) {
|
|
58
|
+
return 1;
|
|
59
|
+
}
|
|
60
|
+
if (haveStream && !streamIsTTY && forceColor === void 0) {
|
|
61
|
+
return 0;
|
|
62
|
+
}
|
|
63
|
+
const min = forceColor || 0;
|
|
64
|
+
if (env.TERM === "dumb") {
|
|
65
|
+
return min;
|
|
66
|
+
}
|
|
67
|
+
if (process.platform === "win32") {
|
|
68
|
+
const osRelease = os.release().split(".");
|
|
69
|
+
if (Number(osRelease[0]) >= 10 && Number(osRelease[2]) >= 10586) {
|
|
70
|
+
return Number(osRelease[2]) >= 14931 ? 3 : 2;
|
|
71
|
+
}
|
|
72
|
+
return 1;
|
|
73
|
+
}
|
|
74
|
+
if ("CI" in env) {
|
|
75
|
+
if ("GITHUB_ACTIONS" in env || "GITEA_ACTIONS" in env) {
|
|
76
|
+
return 3;
|
|
77
|
+
}
|
|
78
|
+
if (["TRAVIS", "CIRCLECI", "APPVEYOR", "GITLAB_CI", "BUILDKITE", "DRONE"].some((sign) => sign in env) || env.CI_NAME === "codeship") {
|
|
79
|
+
return 1;
|
|
80
|
+
}
|
|
81
|
+
return min;
|
|
82
|
+
}
|
|
83
|
+
if ("TEAMCITY_VERSION" in env) {
|
|
84
|
+
return /^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(env.TEAMCITY_VERSION) ? 1 : 0;
|
|
85
|
+
}
|
|
86
|
+
if (env.COLORTERM === "truecolor") {
|
|
87
|
+
return 3;
|
|
88
|
+
}
|
|
89
|
+
if (env.TERM === "xterm-kitty") {
|
|
90
|
+
return 3;
|
|
91
|
+
}
|
|
92
|
+
if ("TERM_PROGRAM" in env) {
|
|
93
|
+
const version = Number.parseInt((env.TERM_PROGRAM_VERSION || "").split(".")[0], 10);
|
|
94
|
+
switch (env.TERM_PROGRAM) {
|
|
95
|
+
case "iTerm.app": {
|
|
96
|
+
return version >= 3 ? 3 : 2;
|
|
97
|
+
}
|
|
98
|
+
case "Apple_Terminal": {
|
|
99
|
+
return 2;
|
|
100
|
+
}
|
|
101
|
+
}
|
|
102
|
+
}
|
|
103
|
+
if (/-256(color)?$/i.test(env.TERM)) {
|
|
104
|
+
return 2;
|
|
105
|
+
}
|
|
106
|
+
if (/^screen|^xterm|^vt100|^vt220|^rxvt|color|ansi|cygwin|linux/i.test(env.TERM)) {
|
|
107
|
+
return 1;
|
|
108
|
+
}
|
|
109
|
+
if ("COLORTERM" in env) {
|
|
110
|
+
return 1;
|
|
111
|
+
}
|
|
112
|
+
return min;
|
|
113
|
+
}
|
|
114
|
+
function createSupportsColor(stream, options = {}) {
|
|
115
|
+
const level = _supportsColor(stream, {
|
|
116
|
+
streamIsTTY: stream && stream.isTTY,
|
|
117
|
+
...options
|
|
118
|
+
});
|
|
119
|
+
return translateLevel(level);
|
|
120
|
+
}
|
|
121
|
+
var supportsColor = {
|
|
122
|
+
stdout: createSupportsColor({ isTTY: tty.isatty(1) }),
|
|
123
|
+
stderr: createSupportsColor({ isTTY: tty.isatty(2) })
|
|
124
|
+
};
|
|
125
|
+
var supports_color_default = supportsColor;
|
|
126
|
+
|
|
127
|
+
// src/utils.ts
|
|
128
|
+
var colorLevel = supports_color_default.stdout ? supports_color_default.stdout.level : 0;
|
|
129
|
+
var errorStackRegExp = /at\s.*:\d+:\d+[\s\)]*$/;
|
|
130
|
+
var anonymousErrorStackRegExp = /^\s*at\s.*\(<anonymous>\)$/;
|
|
131
|
+
var isErrorStackMessage = (message) => errorStackRegExp.test(message) || anonymousErrorStackRegExp.test(message);
|
|
132
|
+
|
|
133
|
+
// src/color.ts
|
|
134
|
+
var formatter = (open, close, replace = open) => colorLevel >= 2 ? (input) => {
|
|
135
|
+
let string = "" + input;
|
|
136
|
+
let index = string.indexOf(close, open.length);
|
|
137
|
+
return ~index ? open + replaceClose(string, close, replace, index) + close : open + string + close;
|
|
138
|
+
} : String;
|
|
139
|
+
var replaceClose = (string, close, replace, index) => {
|
|
140
|
+
let start = string.substring(0, index) + replace;
|
|
141
|
+
let end = string.substring(index + close.length);
|
|
142
|
+
let nextIndex = end.indexOf(close);
|
|
143
|
+
return ~nextIndex ? start + replaceClose(end, close, replace, nextIndex) : start + end;
|
|
144
|
+
};
|
|
145
|
+
var bold = formatter("\x1B[1m", "\x1B[22m", "\x1B[22m\x1B[1m");
|
|
146
|
+
var red = formatter("\x1B[31m", "\x1B[39m");
|
|
147
|
+
var green = formatter("\x1B[32m", "\x1B[39m");
|
|
148
|
+
var yellow = formatter("\x1B[33m", "\x1B[39m");
|
|
149
|
+
var magenta = formatter("\x1B[35m", "\x1B[39m");
|
|
150
|
+
var cyan = formatter("\x1B[36m", "\x1B[39m");
|
|
151
|
+
var gray = formatter("\x1B[90m", "\x1B[39m");
|
|
152
|
+
|
|
153
|
+
// src/gradient.ts
|
|
154
|
+
var startColor = [189, 255, 243];
|
|
155
|
+
var endColor = [74, 194, 154];
|
|
156
|
+
var isWord = (char) => !/[\s\n]/.test(char);
|
|
157
|
+
var gradient = (message) => {
|
|
158
|
+
if (colorLevel < 3) {
|
|
159
|
+
return colorLevel === 2 ? bold(cyan(message)) : message;
|
|
160
|
+
}
|
|
161
|
+
let chars = [...message];
|
|
162
|
+
let steps = chars.filter(isWord).length;
|
|
163
|
+
let r = startColor[0];
|
|
164
|
+
let g = startColor[1];
|
|
165
|
+
let b = startColor[2];
|
|
166
|
+
let rStep = (endColor[0] - r) / steps;
|
|
167
|
+
let gStep = (endColor[1] - g) / steps;
|
|
168
|
+
let bStep = (endColor[2] - b) / steps;
|
|
169
|
+
let output = "";
|
|
170
|
+
for (let char of chars) {
|
|
171
|
+
if (isWord(char)) {
|
|
172
|
+
r += rStep;
|
|
173
|
+
g += gStep;
|
|
174
|
+
b += bStep;
|
|
175
|
+
}
|
|
176
|
+
output += `\x1B[38;2;${Math.round(r)};${Math.round(g)};${Math.round(
|
|
177
|
+
b
|
|
178
|
+
)}m${char}\x1B[39m`;
|
|
179
|
+
}
|
|
180
|
+
return bold(output);
|
|
181
|
+
};
|
|
182
|
+
|
|
183
|
+
// src/constants.ts
|
|
184
|
+
var LOG_LEVEL = {
|
|
185
|
+
error: 0,
|
|
186
|
+
warn: 1,
|
|
187
|
+
info: 2,
|
|
188
|
+
log: 3,
|
|
189
|
+
verbose: 4
|
|
190
|
+
};
|
|
191
|
+
var LOG_TYPES = {
|
|
192
|
+
// Level error
|
|
193
|
+
error: {
|
|
194
|
+
label: "error",
|
|
195
|
+
level: "error",
|
|
196
|
+
color: red
|
|
197
|
+
},
|
|
198
|
+
// Level warn
|
|
199
|
+
warn: {
|
|
200
|
+
label: "warn",
|
|
201
|
+
level: "warn",
|
|
202
|
+
color: yellow
|
|
203
|
+
},
|
|
204
|
+
// Level info
|
|
205
|
+
info: {
|
|
206
|
+
label: "info",
|
|
207
|
+
level: "info",
|
|
208
|
+
color: cyan
|
|
209
|
+
},
|
|
210
|
+
start: {
|
|
211
|
+
label: "start",
|
|
212
|
+
level: "info",
|
|
213
|
+
color: cyan
|
|
214
|
+
},
|
|
215
|
+
ready: {
|
|
216
|
+
label: "ready",
|
|
217
|
+
level: "info",
|
|
218
|
+
color: green
|
|
219
|
+
},
|
|
220
|
+
success: {
|
|
221
|
+
label: "success",
|
|
222
|
+
level: "info",
|
|
223
|
+
color: green
|
|
224
|
+
},
|
|
225
|
+
// Level log
|
|
226
|
+
log: {
|
|
227
|
+
level: "log"
|
|
228
|
+
},
|
|
229
|
+
// Level debug
|
|
230
|
+
debug: {
|
|
231
|
+
label: "debug",
|
|
232
|
+
level: "verbose",
|
|
233
|
+
color: magenta
|
|
234
|
+
}
|
|
235
|
+
};
|
|
236
|
+
|
|
237
|
+
// src/createLogger.ts
|
|
238
|
+
var createLogger = (options = {}) => {
|
|
239
|
+
let maxLevel = options.level || "log";
|
|
240
|
+
let log = (type, message, ...args) => {
|
|
241
|
+
if (LOG_LEVEL[LOG_TYPES[type].level] > LOG_LEVEL[maxLevel]) {
|
|
242
|
+
return;
|
|
243
|
+
}
|
|
244
|
+
if (message === void 0 || message === null) {
|
|
245
|
+
return console.log();
|
|
246
|
+
}
|
|
247
|
+
let logType = LOG_TYPES[type];
|
|
248
|
+
let label = "";
|
|
249
|
+
let text = "";
|
|
250
|
+
if ("label" in logType) {
|
|
251
|
+
label = (logType.label || "").padEnd(7);
|
|
252
|
+
label = bold(logType.color ? logType.color(label) : label);
|
|
253
|
+
}
|
|
254
|
+
if (message instanceof Error) {
|
|
255
|
+
if (message.stack) {
|
|
256
|
+
let [name, ...rest] = message.stack.split("\n");
|
|
257
|
+
if (name.startsWith("Error: ")) {
|
|
258
|
+
name = name.slice(7);
|
|
259
|
+
}
|
|
260
|
+
text = `${name}
|
|
261
|
+
${gray(rest.join("\n"))}`;
|
|
262
|
+
} else {
|
|
263
|
+
text = message.message;
|
|
264
|
+
}
|
|
265
|
+
} else if (logType.level === "error" && typeof message === "string") {
|
|
266
|
+
let lines = message.split("\n");
|
|
267
|
+
text = lines.map((line) => isErrorStackMessage(line) ? gray(line) : line).join("\n");
|
|
268
|
+
} else {
|
|
269
|
+
text = `${message}`;
|
|
270
|
+
}
|
|
271
|
+
console.log(label.length ? `${label} ${text}` : text, ...args);
|
|
272
|
+
};
|
|
273
|
+
let logger2 = {
|
|
274
|
+
greet: (message) => log("log", gradient(message))
|
|
275
|
+
};
|
|
276
|
+
Object.keys(LOG_TYPES).forEach((key) => {
|
|
277
|
+
logger2[key] = (...args) => log(key, ...args);
|
|
278
|
+
});
|
|
279
|
+
Object.defineProperty(logger2, "level", {
|
|
280
|
+
get: () => maxLevel,
|
|
281
|
+
set(val) {
|
|
282
|
+
maxLevel = val;
|
|
283
|
+
}
|
|
284
|
+
});
|
|
285
|
+
logger2.override = (customLogger) => {
|
|
286
|
+
Object.assign(logger2, customLogger);
|
|
287
|
+
};
|
|
288
|
+
return logger2;
|
|
289
|
+
};
|
|
290
|
+
|
|
291
|
+
// src/index.ts
|
|
292
|
+
var logger = createLogger();
|
|
293
|
+
export {
|
|
294
|
+
createLogger,
|
|
295
|
+
logger
|
|
296
|
+
};
|