WIP: bootstrap and partial real Solana watcher implementation
This commit is contained in:
@@ -0,0 +1,14 @@
|
||||
import type { TSESTree } from '@typescript-eslint/utils';
|
||||
import type { InferMessageIdsTypeFromRule, InferOptionsTypeFromRule } from '../util';
|
||||
declare const baseRule: import("@typescript-eslint/utils/ts-eslint").RuleModule<"unexpected", [], unknown, {
|
||||
'ClassBody:exit'(): void;
|
||||
'MethodDefinition, PropertyDefinition'(node: TSESTree.MethodDefinition | TSESTree.PropertyDefinition): void;
|
||||
ClassBody(): void;
|
||||
Program(): void;
|
||||
}>;
|
||||
export type Options = InferOptionsTypeFromRule<typeof baseRule>;
|
||||
export type MessageIds = InferMessageIdsTypeFromRule<typeof baseRule>;
|
||||
declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule<"unexpected", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
|
||||
name: string;
|
||||
};
|
||||
export default _default;
|
||||
@@ -0,0 +1,34 @@
|
||||
# escape-string-regexp [](https://travis-ci.org/sindresorhus/escape-string-regexp)
|
||||
|
||||
> Escape RegExp special characters
|
||||
|
||||
## Install
|
||||
|
||||
```
|
||||
$ npm install escape-string-regexp
|
||||
```
|
||||
|
||||
## Usage
|
||||
|
||||
```js
|
||||
const escapeStringRegexp = require('escape-string-regexp');
|
||||
|
||||
const escapedString = escapeStringRegexp('How much $ for a 🦄?');
|
||||
//=> 'How much \\$ for a 🦄\\?'
|
||||
|
||||
new RegExp(escapedString);
|
||||
```
|
||||
|
||||
You can also use this to escape a string that is inserted into the middle of a regex, for example, into a character class.
|
||||
|
||||
---
|
||||
|
||||
<div align="center">
|
||||
<b>
|
||||
<a href="https://tidelift.com/subscription/pkg/npm-escape-string-regexp?utm_source=npm-escape-string-regexp&utm_medium=referral&utm_campaign=readme">Get professional support for this package with a Tidelift subscription</a>
|
||||
</b>
|
||||
<br>
|
||||
<sub>
|
||||
Tidelift helps make open source sustainable for maintainers while giving companies<br>assurances about security, maintenance, and licensing for their dependencies.
|
||||
</sub>
|
||||
</div>
|
||||
@@ -0,0 +1,176 @@
|
||||
/**
|
||||
* @fileoverview Rule to disallow `\8` and `\9` escape sequences in string literals.
|
||||
* @author Milos Djermanovic
|
||||
*/
|
||||
|
||||
"use strict";
|
||||
|
||||
//------------------------------------------------------------------------------
|
||||
// Typedefs
|
||||
//------------------------------------------------------------------------------
|
||||
|
||||
/**
|
||||
* @import { SourceRange } from "@eslint/core";
|
||||
*/
|
||||
|
||||
//------------------------------------------------------------------------------
|
||||
// Helpers
|
||||
//------------------------------------------------------------------------------
|
||||
|
||||
const QUICK_TEST_REGEX = /\\[89]/u;
|
||||
|
||||
/**
|
||||
* Returns unicode escape sequence that represents the given character.
|
||||
* @param {string} character A single code unit.
|
||||
* @returns {string} "\uXXXX" sequence.
|
||||
*/
|
||||
function getUnicodeEscape(character) {
|
||||
return `\\u${character.charCodeAt(0).toString(16).padStart(4, "0")}`;
|
||||
}
|
||||
|
||||
//------------------------------------------------------------------------------
|
||||
// Rule Definition
|
||||
//------------------------------------------------------------------------------
|
||||
|
||||
/** @type {import('../types').Rule.RuleModule} */
|
||||
module.exports = {
|
||||
meta: {
|
||||
type: "suggestion",
|
||||
|
||||
docs: {
|
||||
description:
|
||||
"Disallow `\\8` and `\\9` escape sequences in string literals",
|
||||
recommended: true,
|
||||
url: "https://eslint.org/docs/latest/rules/no-nonoctal-decimal-escape",
|
||||
},
|
||||
|
||||
hasSuggestions: true,
|
||||
|
||||
schema: [],
|
||||
|
||||
messages: {
|
||||
decimalEscape: "Don't use '{{decimalEscape}}' escape sequence.",
|
||||
|
||||
// suggestions
|
||||
refactor:
|
||||
"Replace '{{original}}' with '{{replacement}}'. This maintains the current functionality.",
|
||||
escapeBackslash:
|
||||
"Replace '{{original}}' with '{{replacement}}' to include the actual backslash character.",
|
||||
},
|
||||
},
|
||||
|
||||
create(context) {
|
||||
const sourceCode = context.sourceCode;
|
||||
|
||||
/**
|
||||
* Creates a new Suggestion object.
|
||||
* @param {string} messageId "refactor" or "escapeBackslash".
|
||||
* @param {SourceRange} range The range to replace.
|
||||
* @param {string} replacement New text for the range.
|
||||
* @returns {Object} Suggestion
|
||||
*/
|
||||
function createSuggestion(messageId, range, replacement) {
|
||||
return {
|
||||
messageId,
|
||||
data: {
|
||||
original: sourceCode.getText().slice(...range),
|
||||
replacement,
|
||||
},
|
||||
fix(fixer) {
|
||||
return fixer.replaceTextRange(range, replacement);
|
||||
},
|
||||
};
|
||||
}
|
||||
|
||||
return {
|
||||
Literal(node) {
|
||||
if (typeof node.value !== "string") {
|
||||
return;
|
||||
}
|
||||
|
||||
if (!QUICK_TEST_REGEX.test(node.raw)) {
|
||||
return;
|
||||
}
|
||||
|
||||
const regex =
|
||||
/(?:[^\\]|(?<previousEscape>\\.))*?(?<decimalEscape>\\[89])/suy;
|
||||
let match;
|
||||
|
||||
while ((match = regex.exec(node.raw))) {
|
||||
const { previousEscape, decimalEscape } = match.groups;
|
||||
const decimalEscapeRangeEnd =
|
||||
node.range[0] + match.index + match[0].length;
|
||||
const decimalEscapeRangeStart =
|
||||
decimalEscapeRangeEnd - decimalEscape.length;
|
||||
const decimalEscapeRange = [
|
||||
decimalEscapeRangeStart,
|
||||
decimalEscapeRangeEnd,
|
||||
];
|
||||
const suggest = [];
|
||||
|
||||
// When `regex` is matched, `previousEscape` can only capture characters adjacent to `decimalEscape`
|
||||
if (previousEscape === "\\0") {
|
||||
/*
|
||||
* Now we have a NULL escape "\0" immediately followed by a decimal escape, e.g.: "\0\8".
|
||||
* Fixing this to "\08" would turn "\0" into a legacy octal escape. To avoid producing
|
||||
* an octal escape while fixing a decimal escape, we provide different suggestions.
|
||||
*/
|
||||
suggest.push(
|
||||
createSuggestion(
|
||||
// "\0\8" -> "\u00008"
|
||||
"refactor",
|
||||
[
|
||||
decimalEscapeRangeStart -
|
||||
previousEscape.length,
|
||||
decimalEscapeRangeEnd,
|
||||
],
|
||||
`${getUnicodeEscape("\0")}${decimalEscape[1]}`,
|
||||
),
|
||||
createSuggestion(
|
||||
// "\8" -> "\u0038"
|
||||
"refactor",
|
||||
decimalEscapeRange,
|
||||
getUnicodeEscape(decimalEscape[1]),
|
||||
),
|
||||
);
|
||||
} else {
|
||||
suggest.push(
|
||||
createSuggestion(
|
||||
// "\8" -> "8"
|
||||
"refactor",
|
||||
decimalEscapeRange,
|
||||
decimalEscape[1],
|
||||
),
|
||||
);
|
||||
}
|
||||
|
||||
suggest.push(
|
||||
createSuggestion(
|
||||
// "\8" -> "\\8"
|
||||
"escapeBackslash",
|
||||
decimalEscapeRange,
|
||||
`\\${decimalEscape}`,
|
||||
),
|
||||
);
|
||||
|
||||
context.report({
|
||||
node,
|
||||
loc: {
|
||||
start: sourceCode.getLocFromIndex(
|
||||
decimalEscapeRangeStart,
|
||||
),
|
||||
end: sourceCode.getLocFromIndex(
|
||||
decimalEscapeRangeEnd,
|
||||
),
|
||||
},
|
||||
messageId: "decimalEscape",
|
||||
data: {
|
||||
decimalEscape,
|
||||
},
|
||||
suggest,
|
||||
});
|
||||
}
|
||||
},
|
||||
};
|
||||
},
|
||||
};
|
||||
@@ -0,0 +1,4 @@
|
||||
{
|
||||
"main": "../../cjs/_create_for_of_iterator_helper_loose.cjs",
|
||||
"module": "../../esm/_create_for_of_iterator_helper_loose.js"
|
||||
}
|
||||
@@ -0,0 +1,5 @@
|
||||
function _assertThisInitialized(e) {
|
||||
if (void 0 === e) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
|
||||
return e;
|
||||
}
|
||||
module.exports = _assertThisInitialized, module.exports.__esModule = true, module.exports["default"] = module.exports;
|
||||
@@ -0,0 +1 @@
|
||||
/*.tgz
|
||||
@@ -0,0 +1,100 @@
|
||||
import * as vite from 'vite';
|
||||
import { resolveConfig as resolveConfig$1, mergeConfig } from 'vite';
|
||||
export { esbuildVersion, isCSSRequest, isFileLoadingAllowed, parseAst, parseAstAsync, rollupVersion, version as viteVersion } from 'vite';
|
||||
import { V as Vitest, a as VitestPlugin } from './chunks/cli-api.BK8pd4xc.js';
|
||||
export { F as ForksPoolWorker, G as GitNotFoundError, b as TestsNotFoundError, T as ThreadsPoolWorker, c as TypecheckPoolWorker, d as VitestPackageInstaller, e as VmForksPoolWorker, f as VmThreadsPoolWorker, g as createDebugger, h as createMethodsRPC, i as createViteLogger, j as createVitest, k as escapeTestName, l as experimental_getRunnerTask, m as getFilePoolName, n as isFileServingAllowed, o as isValidApiRequest, r as registerConsoleShortcuts, p as resolveFsAllow, s as startVitest } from './chunks/cli-api.BK8pd4xc.js';
|
||||
export { p as parseCLI } from './chunks/cac.DdICfEr1.js';
|
||||
import { r as resolveConfig$2 } from './chunks/coverage.DM_a_rWm.js';
|
||||
export { B as BaseCoverageProvider, a as BaseSequencer, b as resolveApiServerConfig } from './chunks/coverage.DM_a_rWm.js';
|
||||
import { slash, deepClone } from '@vitest/utils/helpers';
|
||||
import { a as any } from './chunks/index.og1WyBLx.js';
|
||||
import { resolve } from 'pathe';
|
||||
import { c as configFiles } from './chunks/constants.CPYnjOGj.js';
|
||||
export { M as AgentReporter, B as BenchmarkReporter, a as BenchmarkReportsMap, D as DefaultReporter, b as DotReporter, G as GithubActionsReporter, H as HangingProcessReporter, J as JUnitReporter, c as JsonReporter, M as MinimalReporter, R as ReportersMap, T as TapFlatReporter, d as TapReporter, V as VerboseBenchmarkReporter, e as VerboseReporter } from './chunks/index.UpGiHP7g.js';
|
||||
export { distDir, rootDir } from './path.js';
|
||||
export { generateFileHash } from '@vitest/runner/utils';
|
||||
import 'node:fs';
|
||||
import './chunks/coverage.CTzCuANN.js';
|
||||
import 'node:path';
|
||||
import './chunks/index.BCY_7LL2.js';
|
||||
import 'node:module';
|
||||
import 'node:process';
|
||||
import 'node:fs/promises';
|
||||
import 'node:url';
|
||||
import 'node:assert';
|
||||
import 'node:v8';
|
||||
import 'node:util';
|
||||
import 'node:os';
|
||||
import '@vitest/snapshot/manager';
|
||||
import '@vitest/utils/serialize';
|
||||
import './chunks/nativeModuleRunner.BIakptoF.js';
|
||||
import 'vite/module-runner';
|
||||
import './chunks/traces.DT5aQ62U.js';
|
||||
import 'obug';
|
||||
import 'tinyrainbow';
|
||||
import '#module-evaluator';
|
||||
import 'node:console';
|
||||
import './chunks/_commonjsHelpers.D26ty3Ew.js';
|
||||
import './chunks/utils.BS4fH3nR.js';
|
||||
import './chunks/env.D4Lgay0q.js';
|
||||
import 'std-env';
|
||||
import 'node:tty';
|
||||
import 'node:crypto';
|
||||
import 'node:events';
|
||||
import './chunks/index.Chj8NDwU.js';
|
||||
import './chunks/modules.BJuCwlRJ.js';
|
||||
import 'node:child_process';
|
||||
import 'node:worker_threads';
|
||||
import 'picomatch';
|
||||
import 'tinyglobby';
|
||||
import 'node:perf_hooks';
|
||||
import 'events';
|
||||
import 'https';
|
||||
import 'http';
|
||||
import 'net';
|
||||
import 'tls';
|
||||
import 'crypto';
|
||||
import 'stream';
|
||||
import 'url';
|
||||
import 'zlib';
|
||||
import 'buffer';
|
||||
import './chunks/defaults.9aQKnqFk.js';
|
||||
import 'magic-string';
|
||||
import '@vitest/mocker/node';
|
||||
import '@vitest/utils/constants';
|
||||
import '@vitest/utils/resolver';
|
||||
import 'es-module-lexer';
|
||||
import '@vitest/utils/source-map';
|
||||
import '@vitest/utils/source-map/node';
|
||||
import 'tinyexec';
|
||||
import 'node:readline';
|
||||
import 'readline';
|
||||
import 'node:stream';
|
||||
import '@vitest/utils/display';
|
||||
import '@vitest/utils/offset';
|
||||
|
||||
// this is only exported as a public function and not used inside vitest
|
||||
async function resolveConfig(options = {}, viteOverrides = {}) {
|
||||
const root = slash(resolve(options.root || process.cwd()));
|
||||
const configPath = options.config === false ? false : options.config ? resolve(root, options.config) : any(configFiles, { cwd: root });
|
||||
options.config = configPath;
|
||||
const vitest = new Vitest("test", deepClone(options));
|
||||
const config = await resolveConfig$1(mergeConfig({
|
||||
configFile: configPath,
|
||||
mode: options.mode || "test",
|
||||
plugins: [await VitestPlugin(options, vitest)]
|
||||
}, mergeConfig(viteOverrides, { root: options.root })), "serve");
|
||||
const vitestConfig = resolveConfig$2(vitest, Reflect.get(config, "_vitest"), config);
|
||||
await vitest.close();
|
||||
return {
|
||||
viteConfig: config,
|
||||
vitestConfig
|
||||
};
|
||||
}
|
||||
|
||||
const version = Vitest.version;
|
||||
const createViteServer = vite.createServer;
|
||||
// rolldownVersion is exported only by rolldown-vite
|
||||
const rolldownVersion = vite.rolldownVersion;
|
||||
|
||||
export { VitestPlugin, createViteServer, resolveConfig, rolldownVersion, version };
|
||||
@@ -0,0 +1,186 @@
|
||||
// @ts-ignore TS6133
|
||||
import { expect, test } from "vitest";
|
||||
|
||||
import * as z from "zod/v3";
|
||||
import { util } from "../helpers/util.js";
|
||||
|
||||
test("preprocess", () => {
|
||||
const schema = z.preprocess((data) => [data], z.string().array());
|
||||
|
||||
const value = schema.parse("asdf");
|
||||
expect(value).toEqual(["asdf"]);
|
||||
util.assertEqual<(typeof schema)["_input"], unknown>(true);
|
||||
});
|
||||
|
||||
test("async preprocess", async () => {
|
||||
const schema = z.preprocess(async (data) => [data], z.string().array());
|
||||
|
||||
const value = await schema.parseAsync("asdf");
|
||||
expect(value).toEqual(["asdf"]);
|
||||
});
|
||||
|
||||
test("preprocess ctx.addIssue with parse", () => {
|
||||
expect(() => {
|
||||
z.preprocess((data, ctx) => {
|
||||
ctx.addIssue({
|
||||
code: "custom",
|
||||
message: `${data} is not one of our allowed strings`,
|
||||
});
|
||||
return data;
|
||||
}, z.string()).parse("asdf");
|
||||
}).toThrow(
|
||||
JSON.stringify(
|
||||
[
|
||||
{
|
||||
code: "custom",
|
||||
message: "asdf is not one of our allowed strings",
|
||||
path: [],
|
||||
},
|
||||
],
|
||||
null,
|
||||
2
|
||||
)
|
||||
);
|
||||
});
|
||||
|
||||
test("preprocess ctx.addIssue non-fatal by default", () => {
|
||||
try {
|
||||
z.preprocess((data, ctx) => {
|
||||
ctx.addIssue({
|
||||
code: "custom",
|
||||
message: `custom error`,
|
||||
});
|
||||
return data;
|
||||
}, z.string()).parse(1234);
|
||||
} catch (err) {
|
||||
z.ZodError.assert(err);
|
||||
expect(err.issues.length).toEqual(2);
|
||||
}
|
||||
});
|
||||
|
||||
test("preprocess ctx.addIssue fatal true", () => {
|
||||
try {
|
||||
z.preprocess((data, ctx) => {
|
||||
ctx.addIssue({
|
||||
code: "custom",
|
||||
message: `custom error`,
|
||||
fatal: true,
|
||||
});
|
||||
return data;
|
||||
}, z.string()).parse(1234);
|
||||
} catch (err) {
|
||||
z.ZodError.assert(err);
|
||||
expect(err.issues.length).toEqual(1);
|
||||
}
|
||||
});
|
||||
|
||||
test("async preprocess ctx.addIssue with parse", async () => {
|
||||
const schema = z.preprocess(async (data, ctx) => {
|
||||
ctx.addIssue({
|
||||
code: "custom",
|
||||
message: `custom error`,
|
||||
});
|
||||
return data;
|
||||
}, z.string());
|
||||
|
||||
expect(await schema.safeParseAsync("asdf")).toMatchInlineSnapshot(`
|
||||
{
|
||||
"error": [ZodError: [
|
||||
{
|
||||
"code": "custom",
|
||||
"message": "custom error",
|
||||
"path": []
|
||||
}
|
||||
]],
|
||||
"success": false,
|
||||
}
|
||||
`);
|
||||
});
|
||||
|
||||
test("preprocess ctx.addIssue with parseAsync", async () => {
|
||||
const result = await z
|
||||
.preprocess(async (data, ctx) => {
|
||||
ctx.addIssue({
|
||||
code: "custom",
|
||||
message: `${data} is not one of our allowed strings`,
|
||||
});
|
||||
return data;
|
||||
}, z.string())
|
||||
.safeParseAsync("asdf");
|
||||
|
||||
expect(JSON.parse(JSON.stringify(result))).toEqual({
|
||||
success: false,
|
||||
error: {
|
||||
issues: [
|
||||
{
|
||||
code: "custom",
|
||||
message: "asdf is not one of our allowed strings",
|
||||
path: [],
|
||||
},
|
||||
],
|
||||
name: "ZodError",
|
||||
},
|
||||
});
|
||||
});
|
||||
|
||||
test("z.NEVER in preprocess", () => {
|
||||
const foo = z.preprocess((val, ctx) => {
|
||||
if (!val) {
|
||||
ctx.addIssue({ code: z.ZodIssueCode.custom, message: "bad" });
|
||||
return z.NEVER;
|
||||
}
|
||||
return val;
|
||||
}, z.number());
|
||||
|
||||
type foo = z.infer<typeof foo>;
|
||||
util.assertEqual<foo, number>(true);
|
||||
const arg = foo.safeParse(undefined);
|
||||
expect(arg.error!.issues).toHaveLength(2);
|
||||
expect(arg.error!.issues[0].message).toEqual("bad");
|
||||
});
|
||||
test("preprocess as the second property of object", () => {
|
||||
const schema = z.object({
|
||||
nonEmptyStr: z.string().min(1),
|
||||
positiveNum: z.preprocess((v) => Number(v), z.number().positive()),
|
||||
});
|
||||
const result = schema.safeParse({
|
||||
nonEmptyStr: "",
|
||||
positiveNum: "",
|
||||
});
|
||||
expect(result.success).toEqual(false);
|
||||
if (!result.success) {
|
||||
expect(result.error.issues.length).toEqual(2);
|
||||
expect(result.error.issues[0].code).toEqual(z.ZodIssueCode.too_small);
|
||||
expect(result.error.issues[1].code).toEqual(z.ZodIssueCode.too_small);
|
||||
}
|
||||
});
|
||||
|
||||
test("preprocess validates with sibling errors", () => {
|
||||
expect(() => {
|
||||
z.object({
|
||||
// Must be first
|
||||
missing: z.string().refine(() => false),
|
||||
preprocess: z.preprocess((data: any) => data?.trim(), z.string().regex(/ asdf/)),
|
||||
}).parse({ preprocess: " asdf" });
|
||||
}).toThrow(
|
||||
JSON.stringify(
|
||||
[
|
||||
{
|
||||
code: "invalid_type",
|
||||
expected: "string",
|
||||
received: "undefined",
|
||||
path: ["missing"],
|
||||
message: "Required",
|
||||
},
|
||||
{
|
||||
validation: "regex",
|
||||
code: "invalid_string",
|
||||
message: "Invalid",
|
||||
path: ["preprocess"],
|
||||
},
|
||||
],
|
||||
null,
|
||||
2
|
||||
)
|
||||
);
|
||||
});
|
||||
@@ -0,0 +1,484 @@
|
||||
/******************************************************************************
|
||||
Copyright (c) Microsoft Corporation.
|
||||
|
||||
Permission to use, copy, modify, and/or distribute this software for any
|
||||
purpose with or without fee is hereby granted.
|
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
|
||||
REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
|
||||
AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
|
||||
INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
|
||||
LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
|
||||
OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
|
||||
PERFORMANCE OF THIS SOFTWARE.
|
||||
***************************************************************************** */
|
||||
/* global global, define, Symbol, Reflect, Promise, SuppressedError, Iterator */
|
||||
var __extends;
|
||||
var __assign;
|
||||
var __rest;
|
||||
var __decorate;
|
||||
var __param;
|
||||
var __esDecorate;
|
||||
var __runInitializers;
|
||||
var __propKey;
|
||||
var __setFunctionName;
|
||||
var __metadata;
|
||||
var __awaiter;
|
||||
var __generator;
|
||||
var __exportStar;
|
||||
var __values;
|
||||
var __read;
|
||||
var __spread;
|
||||
var __spreadArrays;
|
||||
var __spreadArray;
|
||||
var __await;
|
||||
var __asyncGenerator;
|
||||
var __asyncDelegator;
|
||||
var __asyncValues;
|
||||
var __makeTemplateObject;
|
||||
var __importStar;
|
||||
var __importDefault;
|
||||
var __classPrivateFieldGet;
|
||||
var __classPrivateFieldSet;
|
||||
var __classPrivateFieldIn;
|
||||
var __createBinding;
|
||||
var __addDisposableResource;
|
||||
var __disposeResources;
|
||||
var __rewriteRelativeImportExtension;
|
||||
(function (factory) {
|
||||
var root = typeof global === "object" ? global : typeof self === "object" ? self : typeof this === "object" ? this : {};
|
||||
if (typeof define === "function" && define.amd) {
|
||||
define("tslib", ["exports"], function (exports) { factory(createExporter(root, createExporter(exports))); });
|
||||
}
|
||||
else if (typeof module === "object" && typeof module.exports === "object") {
|
||||
factory(createExporter(root, createExporter(module.exports)));
|
||||
}
|
||||
else {
|
||||
factory(createExporter(root));
|
||||
}
|
||||
function createExporter(exports, previous) {
|
||||
if (exports !== root) {
|
||||
if (typeof Object.create === "function") {
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
}
|
||||
else {
|
||||
exports.__esModule = true;
|
||||
}
|
||||
}
|
||||
return function (id, v) { return exports[id] = previous ? previous(id, v) : v; };
|
||||
}
|
||||
})
|
||||
(function (exporter) {
|
||||
var extendStatics = Object.setPrototypeOf ||
|
||||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
|
||||
function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
|
||||
|
||||
__extends = function (d, b) {
|
||||
if (typeof b !== "function" && b !== null)
|
||||
throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
|
||||
extendStatics(d, b);
|
||||
function __() { this.constructor = d; }
|
||||
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
|
||||
};
|
||||
|
||||
__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;
|
||||
};
|
||||
|
||||
__rest = function (s, e) {
|
||||
var t = {};
|
||||
for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
|
||||
t[p] = s[p];
|
||||
if (s != null && typeof Object.getOwnPropertySymbols === "function")
|
||||
for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
|
||||
if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
|
||||
t[p[i]] = s[p[i]];
|
||||
}
|
||||
return t;
|
||||
};
|
||||
|
||||
__decorate = function (decorators, target, key, desc) {
|
||||
var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
|
||||
if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
|
||||
else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
|
||||
return c > 3 && r && Object.defineProperty(target, key, r), r;
|
||||
};
|
||||
|
||||
__param = function (paramIndex, decorator) {
|
||||
return function (target, key) { decorator(target, key, paramIndex); }
|
||||
};
|
||||
|
||||
__esDecorate = function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
|
||||
function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
|
||||
var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
|
||||
var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
|
||||
var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
|
||||
var _, done = false;
|
||||
for (var i = decorators.length - 1; i >= 0; i--) {
|
||||
var context = {};
|
||||
for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
|
||||
for (var p in contextIn.access) context.access[p] = contextIn.access[p];
|
||||
context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
|
||||
var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
|
||||
if (kind === "accessor") {
|
||||
if (result === void 0) continue;
|
||||
if (result === null || typeof result !== "object") throw new TypeError("Object expected");
|
||||
if (_ = accept(result.get)) descriptor.get = _;
|
||||
if (_ = accept(result.set)) descriptor.set = _;
|
||||
if (_ = accept(result.init)) initializers.unshift(_);
|
||||
}
|
||||
else if (_ = accept(result)) {
|
||||
if (kind === "field") initializers.unshift(_);
|
||||
else descriptor[key] = _;
|
||||
}
|
||||
}
|
||||
if (target) Object.defineProperty(target, contextIn.name, descriptor);
|
||||
done = true;
|
||||
};
|
||||
|
||||
__runInitializers = function (thisArg, initializers, value) {
|
||||
var useValue = arguments.length > 2;
|
||||
for (var i = 0; i < initializers.length; i++) {
|
||||
value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
|
||||
}
|
||||
return useValue ? value : void 0;
|
||||
};
|
||||
|
||||
__propKey = function (x) {
|
||||
return typeof x === "symbol" ? x : "".concat(x);
|
||||
};
|
||||
|
||||
__setFunctionName = function (f, name, prefix) {
|
||||
if (typeof name === "symbol") name = name.description ? "[".concat(name.description, "]") : "";
|
||||
return Object.defineProperty(f, "name", { configurable: true, value: prefix ? "".concat(prefix, " ", name) : name });
|
||||
};
|
||||
|
||||
__metadata = function (metadataKey, metadataValue) {
|
||||
if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(metadataKey, metadataValue);
|
||||
};
|
||||
|
||||
__awaiter = function (thisArg, _arguments, P, generator) {
|
||||
function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
|
||||
return new (P || (P = Promise))(function (resolve, reject) {
|
||||
function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
|
||||
function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
|
||||
function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
|
||||
step((generator = generator.apply(thisArg, _arguments || [])).next());
|
||||
});
|
||||
};
|
||||
|
||||
__generator = function (thisArg, body) {
|
||||
var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
|
||||
return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
|
||||
function verb(n) { return function (v) { return step([n, v]); }; }
|
||||
function step(op) {
|
||||
if (f) throw new TypeError("Generator is already executing.");
|
||||
while (g && (g = 0, op[0] && (_ = 0)), _) try {
|
||||
if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
|
||||
if (y = 0, t) op = [op[0] & 2, t.value];
|
||||
switch (op[0]) {
|
||||
case 0: case 1: t = op; break;
|
||||
case 4: _.label++; return { value: op[1], done: false };
|
||||
case 5: _.label++; y = op[1]; op = [0]; continue;
|
||||
case 7: op = _.ops.pop(); _.trys.pop(); continue;
|
||||
default:
|
||||
if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
|
||||
if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
|
||||
if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
|
||||
if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
|
||||
if (t[2]) _.ops.pop();
|
||||
_.trys.pop(); continue;
|
||||
}
|
||||
op = body.call(thisArg, _);
|
||||
} catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
|
||||
if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
|
||||
}
|
||||
};
|
||||
|
||||
__exportStar = function(m, o) {
|
||||
for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(o, p)) __createBinding(o, m, p);
|
||||
};
|
||||
|
||||
__createBinding = Object.create ? (function(o, m, k, k2) {
|
||||
if (k2 === undefined) k2 = k;
|
||||
var desc = Object.getOwnPropertyDescriptor(m, k);
|
||||
if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
|
||||
desc = { enumerable: true, get: function() { return m[k]; } };
|
||||
}
|
||||
Object.defineProperty(o, k2, desc);
|
||||
}) : (function(o, m, k, k2) {
|
||||
if (k2 === undefined) k2 = k;
|
||||
o[k2] = m[k];
|
||||
});
|
||||
|
||||
__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.");
|
||||
};
|
||||
|
||||
__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;
|
||||
};
|
||||
|
||||
/** @deprecated */
|
||||
__spread = function () {
|
||||
for (var ar = [], i = 0; i < arguments.length; i++)
|
||||
ar = ar.concat(__read(arguments[i]));
|
||||
return ar;
|
||||
};
|
||||
|
||||
/** @deprecated */
|
||||
__spreadArrays = function () {
|
||||
for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;
|
||||
for (var r = Array(s), k = 0, i = 0; i < il; i++)
|
||||
for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)
|
||||
r[k] = a[j];
|
||||
return r;
|
||||
};
|
||||
|
||||
__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));
|
||||
};
|
||||
|
||||
__await = function (v) {
|
||||
return this instanceof __await ? (this.v = v, this) : new __await(v);
|
||||
};
|
||||
|
||||
__asyncGenerator = function (thisArg, _arguments, generator) {
|
||||
if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
|
||||
var g = generator.apply(thisArg, _arguments || []), i, q = [];
|
||||
return i = Object.create((typeof AsyncIterator === "function" ? AsyncIterator : Object).prototype), verb("next"), verb("throw"), verb("return", awaitReturn), i[Symbol.asyncIterator] = function () { return this; }, i;
|
||||
function awaitReturn(f) { return function (v) { return Promise.resolve(v).then(f, reject); }; }
|
||||
function verb(n, f) { if (g[n]) { i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; if (f) i[n] = f(i[n]); } }
|
||||
function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
|
||||
function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
|
||||
function fulfill(value) { resume("next", value); }
|
||||
function reject(value) { resume("throw", value); }
|
||||
function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
|
||||
};
|
||||
|
||||
__asyncDelegator = function (o) {
|
||||
var i, p;
|
||||
return i = {}, verb("next"), verb("throw", function (e) { throw e; }), verb("return"), i[Symbol.iterator] = function () { return this; }, i;
|
||||
function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: false } : f ? f(v) : v; } : f; }
|
||||
};
|
||||
|
||||
__asyncValues = function (o) {
|
||||
if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
|
||||
var m = o[Symbol.asyncIterator], i;
|
||||
return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
|
||||
function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
|
||||
function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
|
||||
};
|
||||
|
||||
__makeTemplateObject = function (cooked, raw) {
|
||||
if (Object.defineProperty) { Object.defineProperty(cooked, "raw", { value: raw }); } else { cooked.raw = raw; }
|
||||
return cooked;
|
||||
};
|
||||
|
||||
var __setModuleDefault = Object.create ? (function(o, v) {
|
||||
Object.defineProperty(o, "default", { enumerable: true, value: v });
|
||||
}) : function(o, v) {
|
||||
o["default"] = v;
|
||||
};
|
||||
|
||||
var ownKeys = function(o) {
|
||||
ownKeys = Object.getOwnPropertyNames || function (o) {
|
||||
var ar = [];
|
||||
for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
|
||||
return ar;
|
||||
};
|
||||
return ownKeys(o);
|
||||
};
|
||||
|
||||
__importStar = function (mod) {
|
||||
if (mod && mod.__esModule) return mod;
|
||||
var result = {};
|
||||
if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
|
||||
__setModuleDefault(result, mod);
|
||||
return result;
|
||||
};
|
||||
|
||||
__importDefault = function (mod) {
|
||||
return (mod && mod.__esModule) ? mod : { "default": mod };
|
||||
};
|
||||
|
||||
__classPrivateFieldGet = function (receiver, state, kind, f) {
|
||||
if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
|
||||
if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
|
||||
return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
|
||||
};
|
||||
|
||||
__classPrivateFieldSet = function (receiver, state, value, kind, f) {
|
||||
if (kind === "m") throw new TypeError("Private method is not writable");
|
||||
if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
|
||||
if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
|
||||
return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
|
||||
};
|
||||
|
||||
__classPrivateFieldIn = function (state, receiver) {
|
||||
if (receiver === null || (typeof receiver !== "object" && typeof receiver !== "function")) throw new TypeError("Cannot use 'in' operator on non-object");
|
||||
return typeof state === "function" ? receiver === state : state.has(receiver);
|
||||
};
|
||||
|
||||
__addDisposableResource = function (env, value, async) {
|
||||
if (value !== null && value !== void 0) {
|
||||
if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
|
||||
var dispose, inner;
|
||||
if (async) {
|
||||
if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
|
||||
dispose = value[Symbol.asyncDispose];
|
||||
}
|
||||
if (dispose === void 0) {
|
||||
if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
|
||||
dispose = value[Symbol.dispose];
|
||||
if (async) inner = dispose;
|
||||
}
|
||||
if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
|
||||
if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };
|
||||
env.stack.push({ value: value, dispose: dispose, async: async });
|
||||
}
|
||||
else if (async) {
|
||||
env.stack.push({ async: true });
|
||||
}
|
||||
return value;
|
||||
};
|
||||
|
||||
var _SuppressedError = typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
|
||||
var e = new Error(message);
|
||||
return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
|
||||
};
|
||||
|
||||
__disposeResources = function (env) {
|
||||
function fail(e) {
|
||||
env.error = env.hasError ? new _SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
|
||||
env.hasError = true;
|
||||
}
|
||||
var r, s = 0;
|
||||
function next() {
|
||||
while (r = env.stack.pop()) {
|
||||
try {
|
||||
if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
|
||||
if (r.dispose) {
|
||||
var result = r.dispose.call(r.value);
|
||||
if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
|
||||
}
|
||||
else s |= 1;
|
||||
}
|
||||
catch (e) {
|
||||
fail(e);
|
||||
}
|
||||
}
|
||||
if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
|
||||
if (env.hasError) throw env.error;
|
||||
}
|
||||
return next();
|
||||
};
|
||||
|
||||
__rewriteRelativeImportExtension = function (path, preserveJsx) {
|
||||
if (typeof path === "string" && /^\.\.?\//.test(path)) {
|
||||
return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
|
||||
return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
|
||||
});
|
||||
}
|
||||
return path;
|
||||
};
|
||||
|
||||
exporter("__extends", __extends);
|
||||
exporter("__assign", __assign);
|
||||
exporter("__rest", __rest);
|
||||
exporter("__decorate", __decorate);
|
||||
exporter("__param", __param);
|
||||
exporter("__esDecorate", __esDecorate);
|
||||
exporter("__runInitializers", __runInitializers);
|
||||
exporter("__propKey", __propKey);
|
||||
exporter("__setFunctionName", __setFunctionName);
|
||||
exporter("__metadata", __metadata);
|
||||
exporter("__awaiter", __awaiter);
|
||||
exporter("__generator", __generator);
|
||||
exporter("__exportStar", __exportStar);
|
||||
exporter("__createBinding", __createBinding);
|
||||
exporter("__values", __values);
|
||||
exporter("__read", __read);
|
||||
exporter("__spread", __spread);
|
||||
exporter("__spreadArrays", __spreadArrays);
|
||||
exporter("__spreadArray", __spreadArray);
|
||||
exporter("__await", __await);
|
||||
exporter("__asyncGenerator", __asyncGenerator);
|
||||
exporter("__asyncDelegator", __asyncDelegator);
|
||||
exporter("__asyncValues", __asyncValues);
|
||||
exporter("__makeTemplateObject", __makeTemplateObject);
|
||||
exporter("__importStar", __importStar);
|
||||
exporter("__importDefault", __importDefault);
|
||||
exporter("__classPrivateFieldGet", __classPrivateFieldGet);
|
||||
exporter("__classPrivateFieldSet", __classPrivateFieldSet);
|
||||
exporter("__classPrivateFieldIn", __classPrivateFieldIn);
|
||||
exporter("__addDisposableResource", __addDisposableResource);
|
||||
exporter("__disposeResources", __disposeResources);
|
||||
exporter("__rewriteRelativeImportExtension", __rewriteRelativeImportExtension);
|
||||
});
|
||||
|
||||
0 && (module.exports = {
|
||||
__extends: __extends,
|
||||
__assign: __assign,
|
||||
__rest: __rest,
|
||||
__decorate: __decorate,
|
||||
__param: __param,
|
||||
__esDecorate: __esDecorate,
|
||||
__runInitializers: __runInitializers,
|
||||
__propKey: __propKey,
|
||||
__setFunctionName: __setFunctionName,
|
||||
__metadata: __metadata,
|
||||
__awaiter: __awaiter,
|
||||
__generator: __generator,
|
||||
__exportStar: __exportStar,
|
||||
__createBinding: __createBinding,
|
||||
__values: __values,
|
||||
__read: __read,
|
||||
__spread: __spread,
|
||||
__spreadArrays: __spreadArrays,
|
||||
__spreadArray: __spreadArray,
|
||||
__await: __await,
|
||||
__asyncGenerator: __asyncGenerator,
|
||||
__asyncDelegator: __asyncDelegator,
|
||||
__asyncValues: __asyncValues,
|
||||
__makeTemplateObject: __makeTemplateObject,
|
||||
__importStar: __importStar,
|
||||
__importDefault: __importDefault,
|
||||
__classPrivateFieldGet: __classPrivateFieldGet,
|
||||
__classPrivateFieldSet: __classPrivateFieldSet,
|
||||
__classPrivateFieldIn: __classPrivateFieldIn,
|
||||
__addDisposableResource: __addDisposableResource,
|
||||
__disposeResources: __disposeResources,
|
||||
__rewriteRelativeImportExtension: __rewriteRelativeImportExtension,
|
||||
});
|
||||
@@ -0,0 +1,73 @@
|
||||
'use strict'
|
||||
|
||||
module.exports = prettifyMetadata
|
||||
|
||||
/**
|
||||
* @typedef {object} PrettifyMetadataParams
|
||||
* @property {object} log The log that may or may not contain metadata to
|
||||
* be prettified.
|
||||
* @property {PrettyContext} context The context object built from parsing
|
||||
* the options.
|
||||
*/
|
||||
|
||||
/**
|
||||
* Prettifies metadata that is usually present in a Pino log line. It looks for
|
||||
* fields `name`, `pid`, `hostname`, and `caller` and returns a formatted string using
|
||||
* the fields it finds.
|
||||
*
|
||||
* @param {PrettifyMetadataParams} input
|
||||
*
|
||||
* @returns {undefined|string} If no metadata is found then `undefined` is
|
||||
* returned. Otherwise, a string of prettified metadata is returned.
|
||||
*/
|
||||
function prettifyMetadata ({ log, context }) {
|
||||
const { customPrettifiers: prettifiers, colorizer } = context
|
||||
let line = ''
|
||||
|
||||
if (log.name || log.pid || log.hostname) {
|
||||
line += '('
|
||||
|
||||
if (log.name) {
|
||||
line += prettifiers.name
|
||||
? prettifiers.name(log.name, 'name', log, { colors: colorizer.colors })
|
||||
: log.name
|
||||
}
|
||||
|
||||
if (log.pid) {
|
||||
const prettyPid = prettifiers.pid
|
||||
? prettifiers.pid(log.pid, 'pid', log, { colors: colorizer.colors })
|
||||
: log.pid
|
||||
if (log.name && log.pid) {
|
||||
line += '/' + prettyPid
|
||||
} else {
|
||||
line += prettyPid
|
||||
}
|
||||
}
|
||||
|
||||
if (log.hostname) {
|
||||
// If `pid` and `name` were in the ignore keys list then we don't need
|
||||
// the leading space.
|
||||
const prettyHostname = prettifiers.hostname
|
||||
? prettifiers.hostname(log.hostname, 'hostname', log, { colors: colorizer.colors })
|
||||
: log.hostname
|
||||
|
||||
line += `${line === '(' ? 'on' : ' on'} ${prettyHostname}`
|
||||
}
|
||||
|
||||
line += ')'
|
||||
}
|
||||
|
||||
if (log.caller) {
|
||||
const prettyCaller = prettifiers.caller
|
||||
? prettifiers.caller(log.caller, 'caller', log, { colors: colorizer.colors })
|
||||
: log.caller
|
||||
|
||||
line += `${line === '' ? '' : ' '}<${prettyCaller}>`
|
||||
}
|
||||
|
||||
if (line === '') {
|
||||
return undefined
|
||||
} else {
|
||||
return line
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,9 @@
|
||||
import { _ as _array_without_holes } from "./_array_without_holes.js";
|
||||
import { _ as _iterable_to_array } from "./_iterable_to_array.js";
|
||||
import { _ as _non_iterable_spread } from "./_non_iterable_spread.js";
|
||||
import { _ as _unsupported_iterable_to_array } from "./_unsupported_iterable_to_array.js";
|
||||
|
||||
function _to_consumable_array(arr) {
|
||||
return _array_without_holes(arr) || _iterable_to_array(arr) || _unsupported_iterable_to_array(arr) || _non_iterable_spread();
|
||||
}
|
||||
export { _to_consumable_array as _ };
|
||||
@@ -0,0 +1,22 @@
|
||||
/*! *****************************************************************************
|
||||
Copyright (c) Microsoft Corporation. All rights reserved.
|
||||
Licensed under the Apache License, Version 2.0 (the "License"); you may not use
|
||||
this file except in compliance with the License. You may obtain a copy of the
|
||||
License at http://www.apache.org/licenses/LICENSE-2.0
|
||||
|
||||
THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
|
||||
KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
|
||||
WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
|
||||
MERCHANTABLITY OR NON-INFRINGEMENT.
|
||||
|
||||
See the Apache Version 2.0 License for specific language governing permissions
|
||||
and limitations under the License.
|
||||
***************************************************************************** */
|
||||
|
||||
|
||||
/// <reference no-default-lib="true"/>
|
||||
|
||||
/// <reference lib="es2022" />
|
||||
/// <reference lib="es2023.array" />
|
||||
/// <reference lib="es2023.collection" />
|
||||
/// <reference lib="es2023.intl" />
|
||||
@@ -0,0 +1,9 @@
|
||||
module.exports = function eachRecursive(obj, fn, path) {
|
||||
path = path ? path + '.' : '';
|
||||
for (var name in obj) {
|
||||
if (typeof obj === "object" && obj !== null) {
|
||||
eachRecursive(obj[name], fn, path + name);
|
||||
}
|
||||
fn(obj[name], path + name);
|
||||
}
|
||||
};
|
||||
@@ -0,0 +1,46 @@
|
||||
{
|
||||
"name": "levn",
|
||||
"version": "0.4.1",
|
||||
"author": "George Zahariev <z@georgezahariev.com>",
|
||||
"description": "Light ECMAScript (JavaScript) Value Notation - human written, concise, typed, flexible",
|
||||
"homepage": "https://github.com/gkz/levn",
|
||||
"keywords": [
|
||||
"levn",
|
||||
"light",
|
||||
"ecmascript",
|
||||
"value",
|
||||
"notation",
|
||||
"json",
|
||||
"typed",
|
||||
"human",
|
||||
"concise",
|
||||
"typed",
|
||||
"flexible"
|
||||
],
|
||||
"files": [
|
||||
"lib",
|
||||
"README.md",
|
||||
"LICENSE"
|
||||
],
|
||||
"main": "./lib/",
|
||||
"bugs": "https://github.com/gkz/levn/issues",
|
||||
"license": "MIT",
|
||||
"engines": {
|
||||
"node": ">= 0.8.0"
|
||||
},
|
||||
"repository": {
|
||||
"type": "git",
|
||||
"url": "git://github.com/gkz/levn.git"
|
||||
},
|
||||
"scripts": {
|
||||
"test": "make test"
|
||||
},
|
||||
"dependencies": {
|
||||
"prelude-ls": "^1.2.1",
|
||||
"type-check": "~0.4.0"
|
||||
},
|
||||
"devDependencies": {
|
||||
"livescript": "^1.6.0",
|
||||
"mocha": "^7.1.1"
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,558 @@
|
||||
declare module "node:util/types" {
|
||||
import { KeyObject, webcrypto } from "node:crypto";
|
||||
/**
|
||||
* Returns `true` if the value is a built-in [`ArrayBuffer`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer) or
|
||||
* [`SharedArrayBuffer`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/SharedArrayBuffer) instance.
|
||||
*
|
||||
* See also `util.types.isArrayBuffer()` and `util.types.isSharedArrayBuffer()`.
|
||||
*
|
||||
* ```js
|
||||
* util.types.isAnyArrayBuffer(new ArrayBuffer()); // Returns true
|
||||
* util.types.isAnyArrayBuffer(new SharedArrayBuffer()); // Returns true
|
||||
* ```
|
||||
* @since v10.0.0
|
||||
*/
|
||||
function isAnyArrayBuffer(object: unknown): object is ArrayBufferLike;
|
||||
/**
|
||||
* Returns `true` if the value is an `arguments` object.
|
||||
*
|
||||
* ```js
|
||||
* function foo() {
|
||||
* util.types.isArgumentsObject(arguments); // Returns true
|
||||
* }
|
||||
* ```
|
||||
* @since v10.0.0
|
||||
*/
|
||||
function isArgumentsObject(object: unknown): object is IArguments;
|
||||
/**
|
||||
* Returns `true` if the value is a built-in [`ArrayBuffer`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer) instance.
|
||||
* This does _not_ include [`SharedArrayBuffer`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/SharedArrayBuffer) instances. Usually, it is
|
||||
* desirable to test for both; See `util.types.isAnyArrayBuffer()` for that.
|
||||
*
|
||||
* ```js
|
||||
* util.types.isArrayBuffer(new ArrayBuffer()); // Returns true
|
||||
* util.types.isArrayBuffer(new SharedArrayBuffer()); // Returns false
|
||||
* ```
|
||||
* @since v10.0.0
|
||||
*/
|
||||
function isArrayBuffer(object: unknown): object is ArrayBuffer;
|
||||
/**
|
||||
* Returns `true` if the value is an instance of one of the [`ArrayBuffer`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer) views, such as typed
|
||||
* array objects or [`DataView`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DataView). Equivalent to
|
||||
* [`ArrayBuffer.isView()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer/isView).
|
||||
*
|
||||
* ```js
|
||||
* util.types.isArrayBufferView(new Int8Array()); // true
|
||||
* util.types.isArrayBufferView(Buffer.from('hello world')); // true
|
||||
* util.types.isArrayBufferView(new DataView(new ArrayBuffer(16))); // true
|
||||
* util.types.isArrayBufferView(new ArrayBuffer()); // false
|
||||
* ```
|
||||
* @since v10.0.0
|
||||
*/
|
||||
function isArrayBufferView(object: unknown): object is NodeJS.ArrayBufferView;
|
||||
/**
|
||||
* Returns `true` if the value is an [async function](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/async_function).
|
||||
* This only reports back what the JavaScript engine is seeing;
|
||||
* in particular, the return value may not match the original source code if
|
||||
* a transpilation tool was used.
|
||||
*
|
||||
* ```js
|
||||
* util.types.isAsyncFunction(function foo() {}); // Returns false
|
||||
* util.types.isAsyncFunction(async function foo() {}); // Returns true
|
||||
* ```
|
||||
* @since v10.0.0
|
||||
*/
|
||||
function isAsyncFunction(object: unknown): boolean;
|
||||
/**
|
||||
* Returns `true` if the value is a `BigInt64Array` instance.
|
||||
*
|
||||
* ```js
|
||||
* util.types.isBigInt64Array(new BigInt64Array()); // Returns true
|
||||
* util.types.isBigInt64Array(new BigUint64Array()); // Returns false
|
||||
* ```
|
||||
* @since v10.0.0
|
||||
*/
|
||||
function isBigInt64Array(value: unknown): value is BigInt64Array;
|
||||
/**
|
||||
* Returns `true` if the value is a BigInt object, e.g. created
|
||||
* by `Object(BigInt(123))`.
|
||||
*
|
||||
* ```js
|
||||
* util.types.isBigIntObject(Object(BigInt(123))); // Returns true
|
||||
* util.types.isBigIntObject(BigInt(123)); // Returns false
|
||||
* util.types.isBigIntObject(123); // Returns false
|
||||
* ```
|
||||
* @since v10.4.0
|
||||
*/
|
||||
function isBigIntObject(object: unknown): object is BigInt;
|
||||
/**
|
||||
* Returns `true` if the value is a `BigUint64Array` instance.
|
||||
*
|
||||
* ```js
|
||||
* util.types.isBigUint64Array(new BigInt64Array()); // Returns false
|
||||
* util.types.isBigUint64Array(new BigUint64Array()); // Returns true
|
||||
* ```
|
||||
* @since v10.0.0
|
||||
*/
|
||||
function isBigUint64Array(value: unknown): value is BigUint64Array;
|
||||
/**
|
||||
* Returns `true` if the value is a boolean object, e.g. created
|
||||
* by `new Boolean()`.
|
||||
*
|
||||
* ```js
|
||||
* util.types.isBooleanObject(false); // Returns false
|
||||
* util.types.isBooleanObject(true); // Returns false
|
||||
* util.types.isBooleanObject(new Boolean(false)); // Returns true
|
||||
* util.types.isBooleanObject(new Boolean(true)); // Returns true
|
||||
* util.types.isBooleanObject(Boolean(false)); // Returns false
|
||||
* util.types.isBooleanObject(Boolean(true)); // Returns false
|
||||
* ```
|
||||
* @since v10.0.0
|
||||
*/
|
||||
function isBooleanObject(object: unknown): object is Boolean;
|
||||
/**
|
||||
* Returns `true` if the value is any boxed primitive object, e.g. created
|
||||
* by `new Boolean()`, `new String()` or `Object(Symbol())`.
|
||||
*
|
||||
* For example:
|
||||
*
|
||||
* ```js
|
||||
* util.types.isBoxedPrimitive(false); // Returns false
|
||||
* util.types.isBoxedPrimitive(new Boolean(false)); // Returns true
|
||||
* util.types.isBoxedPrimitive(Symbol('foo')); // Returns false
|
||||
* util.types.isBoxedPrimitive(Object(Symbol('foo'))); // Returns true
|
||||
* util.types.isBoxedPrimitive(Object(BigInt(5))); // Returns true
|
||||
* ```
|
||||
* @since v10.11.0
|
||||
*/
|
||||
function isBoxedPrimitive(object: unknown): object is String | Number | BigInt | Boolean | Symbol;
|
||||
/**
|
||||
* Returns `true` if the value is a built-in [`DataView`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/DataView) instance.
|
||||
*
|
||||
* ```js
|
||||
* const ab = new ArrayBuffer(20);
|
||||
* util.types.isDataView(new DataView(ab)); // Returns true
|
||||
* util.types.isDataView(new Float64Array()); // Returns false
|
||||
* ```
|
||||
*
|
||||
* See also [`ArrayBuffer.isView()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer/isView).
|
||||
* @since v10.0.0
|
||||
*/
|
||||
function isDataView(object: unknown): object is DataView;
|
||||
/**
|
||||
* Returns `true` if the value is a built-in [`Date`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date) instance.
|
||||
*
|
||||
* ```js
|
||||
* util.types.isDate(new Date()); // Returns true
|
||||
* ```
|
||||
* @since v10.0.0
|
||||
*/
|
||||
function isDate(object: unknown): object is Date;
|
||||
/**
|
||||
* Returns `true` if the value is a native `External` value.
|
||||
*
|
||||
* A native `External` value is a special type of object that contains a
|
||||
* raw C++ pointer (`void*`) for access from native code, and has no other
|
||||
* properties. Such objects are created either by Node.js internals or native
|
||||
* addons. In JavaScript, they are
|
||||
* [frozen](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/freeze) objects with a
|
||||
* `null` prototype.
|
||||
*
|
||||
* ```c
|
||||
* #include <js_native_api.h>
|
||||
* #include <stdlib.h>
|
||||
* napi_value result;
|
||||
* static napi_value MyNapi(napi_env env, napi_callback_info info) {
|
||||
* int* raw = (int*) malloc(1024);
|
||||
* napi_status status = napi_create_external(env, (void*) raw, NULL, NULL, &result);
|
||||
* if (status != napi_ok) {
|
||||
* napi_throw_error(env, NULL, "napi_create_external failed");
|
||||
* return NULL;
|
||||
* }
|
||||
* return result;
|
||||
* }
|
||||
* ...
|
||||
* DECLARE_NAPI_PROPERTY("myNapi", MyNapi)
|
||||
* ...
|
||||
* ```
|
||||
*
|
||||
* ```js
|
||||
* import native from 'napi_addon.node';
|
||||
* import { types } from 'node:util';
|
||||
*
|
||||
* const data = native.myNapi();
|
||||
* types.isExternal(data); // returns true
|
||||
* types.isExternal(0); // returns false
|
||||
* types.isExternal(new String('foo')); // returns false
|
||||
* ```
|
||||
*
|
||||
* For further information on `napi_create_external`, refer to
|
||||
* [`napi_create_external()`](https://nodejs.org/docs/latest-v26.x/api/n-api.html#napi_create_external).
|
||||
* @since v10.0.0
|
||||
*/
|
||||
function isExternal(object: unknown): boolean;
|
||||
/**
|
||||
* Returns `true` if the value is a built-in [`Float16Array`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Float16Array) instance.
|
||||
*
|
||||
* ```js
|
||||
* util.types.isFloat16Array(new ArrayBuffer()); // Returns false
|
||||
* util.types.isFloat16Array(new Float16Array()); // Returns true
|
||||
* util.types.isFloat16Array(new Float32Array()); // Returns false
|
||||
* ```
|
||||
* @since v24.0.0
|
||||
*/
|
||||
function isFloat16Array(object: unknown): object is Float16Array;
|
||||
/**
|
||||
* Returns `true` if the value is a built-in [`Float32Array`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Float32Array) instance.
|
||||
*
|
||||
* ```js
|
||||
* util.types.isFloat32Array(new ArrayBuffer()); // Returns false
|
||||
* util.types.isFloat32Array(new Float32Array()); // Returns true
|
||||
* util.types.isFloat32Array(new Float64Array()); // Returns false
|
||||
* ```
|
||||
* @since v10.0.0
|
||||
*/
|
||||
function isFloat32Array(object: unknown): object is Float32Array;
|
||||
/**
|
||||
* Returns `true` if the value is a built-in [`Float64Array`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Float64Array) instance.
|
||||
*
|
||||
* ```js
|
||||
* util.types.isFloat64Array(new ArrayBuffer()); // Returns false
|
||||
* util.types.isFloat64Array(new Uint8Array()); // Returns false
|
||||
* util.types.isFloat64Array(new Float64Array()); // Returns true
|
||||
* ```
|
||||
* @since v10.0.0
|
||||
*/
|
||||
function isFloat64Array(object: unknown): object is Float64Array;
|
||||
/**
|
||||
* Returns `true` if the value is a generator function.
|
||||
* This only reports back what the JavaScript engine is seeing;
|
||||
* in particular, the return value may not match the original source code if
|
||||
* a transpilation tool was used.
|
||||
*
|
||||
* ```js
|
||||
* util.types.isGeneratorFunction(function foo() {}); // Returns false
|
||||
* util.types.isGeneratorFunction(function* foo() {}); // Returns true
|
||||
* ```
|
||||
* @since v10.0.0
|
||||
*/
|
||||
function isGeneratorFunction(object: unknown): object is GeneratorFunction;
|
||||
/**
|
||||
* Returns `true` if the value is a generator object as returned from a
|
||||
* built-in generator function.
|
||||
* This only reports back what the JavaScript engine is seeing;
|
||||
* in particular, the return value may not match the original source code if
|
||||
* a transpilation tool was used.
|
||||
*
|
||||
* ```js
|
||||
* function* foo() {}
|
||||
* const generator = foo();
|
||||
* util.types.isGeneratorObject(generator); // Returns true
|
||||
* ```
|
||||
* @since v10.0.0
|
||||
*/
|
||||
function isGeneratorObject(object: unknown): object is Generator;
|
||||
/**
|
||||
* Returns `true` if the value is a built-in [`Int8Array`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Int8Array) instance.
|
||||
*
|
||||
* ```js
|
||||
* util.types.isInt8Array(new ArrayBuffer()); // Returns false
|
||||
* util.types.isInt8Array(new Int8Array()); // Returns true
|
||||
* util.types.isInt8Array(new Float64Array()); // Returns false
|
||||
* ```
|
||||
* @since v10.0.0
|
||||
*/
|
||||
function isInt8Array(object: unknown): object is Int8Array;
|
||||
/**
|
||||
* Returns `true` if the value is a built-in [`Int16Array`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Int16Array) instance.
|
||||
*
|
||||
* ```js
|
||||
* util.types.isInt16Array(new ArrayBuffer()); // Returns false
|
||||
* util.types.isInt16Array(new Int16Array()); // Returns true
|
||||
* util.types.isInt16Array(new Float64Array()); // Returns false
|
||||
* ```
|
||||
* @since v10.0.0
|
||||
*/
|
||||
function isInt16Array(object: unknown): object is Int16Array;
|
||||
/**
|
||||
* Returns `true` if the value is a built-in [`Int32Array`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Int32Array) instance.
|
||||
*
|
||||
* ```js
|
||||
* util.types.isInt32Array(new ArrayBuffer()); // Returns false
|
||||
* util.types.isInt32Array(new Int32Array()); // Returns true
|
||||
* util.types.isInt32Array(new Float64Array()); // Returns false
|
||||
* ```
|
||||
* @since v10.0.0
|
||||
*/
|
||||
function isInt32Array(object: unknown): object is Int32Array;
|
||||
/**
|
||||
* Returns `true` if the value is a built-in [`Map`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map) instance.
|
||||
*
|
||||
* ```js
|
||||
* util.types.isMap(new Map()); // Returns true
|
||||
* ```
|
||||
* @since v10.0.0
|
||||
*/
|
||||
function isMap<T>(
|
||||
object: T | {},
|
||||
): object is T extends ReadonlyMap<any, any> ? (unknown extends T ? never : ReadonlyMap<any, any>)
|
||||
: Map<unknown, unknown>;
|
||||
/**
|
||||
* Returns `true` if the value is an iterator returned for a built-in [`Map`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map) instance.
|
||||
*
|
||||
* ```js
|
||||
* const map = new Map();
|
||||
* util.types.isMapIterator(map.keys()); // Returns true
|
||||
* util.types.isMapIterator(map.values()); // Returns true
|
||||
* util.types.isMapIterator(map.entries()); // Returns true
|
||||
* util.types.isMapIterator(map[Symbol.iterator]()); // Returns true
|
||||
* ```
|
||||
* @since v10.0.0
|
||||
*/
|
||||
function isMapIterator(object: unknown): boolean;
|
||||
/**
|
||||
* Returns `true` if the value is an instance of a [Module Namespace Object](https://tc39.github.io/ecma262/#sec-module-namespace-exotic-objects).
|
||||
*
|
||||
* ```js
|
||||
* import * as ns from './a.js';
|
||||
*
|
||||
* util.types.isModuleNamespaceObject(ns); // Returns true
|
||||
* ```
|
||||
* @since v10.0.0
|
||||
*/
|
||||
function isModuleNamespaceObject(value: unknown): boolean;
|
||||
/**
|
||||
* Returns `true` if the value was returned by the constructor of a
|
||||
* [built-in `Error` type](https://tc39.es/ecma262/#sec-error-objects).
|
||||
*
|
||||
* ```js
|
||||
* console.log(util.types.isNativeError(new Error())); // true
|
||||
* console.log(util.types.isNativeError(new TypeError())); // true
|
||||
* console.log(util.types.isNativeError(new RangeError())); // true
|
||||
* ```
|
||||
*
|
||||
* Subclasses of the native error types are also native errors:
|
||||
*
|
||||
* ```js
|
||||
* class MyError extends Error {}
|
||||
* console.log(util.types.isNativeError(new MyError())); // true
|
||||
* ```
|
||||
*
|
||||
* A value being `instanceof` a native error class is not equivalent to `isNativeError()`
|
||||
* returning `true` for that value. `isNativeError()` returns `true` for errors
|
||||
* which come from a different [realm](https://tc39.es/ecma262/#realm) while `instanceof Error` returns `false`
|
||||
* for these errors:
|
||||
*
|
||||
* ```js
|
||||
* import { createContext, runInContext } from 'node:vm';
|
||||
* import { types } from 'node:util';
|
||||
*
|
||||
* const context = createContext({});
|
||||
* const myError = runInContext('new Error()', context);
|
||||
* console.log(types.isNativeError(myError)); // true
|
||||
* console.log(myError instanceof Error); // false
|
||||
* ```
|
||||
*
|
||||
* Conversely, `isNativeError()` returns `false` for all objects which were not
|
||||
* returned by the constructor of a native error. That includes values
|
||||
* which are `instanceof` native errors:
|
||||
*
|
||||
* ```js
|
||||
* const myError = { __proto__: Error.prototype };
|
||||
* console.log(util.types.isNativeError(myError)); // false
|
||||
* console.log(myError instanceof Error); // true
|
||||
* ```
|
||||
* @since v10.0.0
|
||||
* @deprecated The `util.types.isNativeError` API is deprecated. Please use `Error.isError` instead.
|
||||
*/
|
||||
function isNativeError(object: unknown): object is Error;
|
||||
/**
|
||||
* Returns `true` if the value is a number object, e.g. created
|
||||
* by `new Number()`.
|
||||
*
|
||||
* ```js
|
||||
* util.types.isNumberObject(0); // Returns false
|
||||
* util.types.isNumberObject(new Number(0)); // Returns true
|
||||
* ```
|
||||
* @since v10.0.0
|
||||
*/
|
||||
function isNumberObject(object: unknown): object is Number;
|
||||
/**
|
||||
* Returns `true` if the value is a built-in [`Promise`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise).
|
||||
*
|
||||
* ```js
|
||||
* util.types.isPromise(Promise.resolve(42)); // Returns true
|
||||
* ```
|
||||
* @since v10.0.0
|
||||
*/
|
||||
function isPromise(object: unknown): object is Promise<unknown>;
|
||||
/**
|
||||
* Returns `true` if the value is a [`Proxy`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Proxy) instance.
|
||||
*
|
||||
* ```js
|
||||
* const target = {};
|
||||
* const proxy = new Proxy(target, {});
|
||||
* util.types.isProxy(target); // Returns false
|
||||
* util.types.isProxy(proxy); // Returns true
|
||||
* ```
|
||||
* @since v10.0.0
|
||||
*/
|
||||
function isProxy(object: unknown): boolean;
|
||||
/**
|
||||
* Returns `true` if the value is a regular expression object.
|
||||
*
|
||||
* ```js
|
||||
* util.types.isRegExp(/abc/); // Returns true
|
||||
* util.types.isRegExp(new RegExp('abc')); // Returns true
|
||||
* ```
|
||||
* @since v10.0.0
|
||||
*/
|
||||
function isRegExp(object: unknown): object is RegExp;
|
||||
/**
|
||||
* Returns `true` if the value is a built-in [`Set`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set) instance.
|
||||
*
|
||||
* ```js
|
||||
* util.types.isSet(new Set()); // Returns true
|
||||
* ```
|
||||
* @since v10.0.0
|
||||
*/
|
||||
function isSet<T>(
|
||||
object: T | {},
|
||||
): object is T extends ReadonlySet<any> ? (unknown extends T ? never : ReadonlySet<any>) : Set<unknown>;
|
||||
/**
|
||||
* Returns `true` if the value is an iterator returned for a built-in [`Set`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set) instance.
|
||||
*
|
||||
* ```js
|
||||
* const set = new Set();
|
||||
* util.types.isSetIterator(set.keys()); // Returns true
|
||||
* util.types.isSetIterator(set.values()); // Returns true
|
||||
* util.types.isSetIterator(set.entries()); // Returns true
|
||||
* util.types.isSetIterator(set[Symbol.iterator]()); // Returns true
|
||||
* ```
|
||||
* @since v10.0.0
|
||||
*/
|
||||
function isSetIterator(object: unknown): boolean;
|
||||
/**
|
||||
* Returns `true` if the value is a built-in [`SharedArrayBuffer`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/SharedArrayBuffer) instance.
|
||||
* This does _not_ include [`ArrayBuffer`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer) instances. Usually, it is
|
||||
* desirable to test for both; See `util.types.isAnyArrayBuffer()` for that.
|
||||
*
|
||||
* ```js
|
||||
* util.types.isSharedArrayBuffer(new ArrayBuffer()); // Returns false
|
||||
* util.types.isSharedArrayBuffer(new SharedArrayBuffer()); // Returns true
|
||||
* ```
|
||||
* @since v10.0.0
|
||||
*/
|
||||
function isSharedArrayBuffer(object: unknown): object is SharedArrayBuffer;
|
||||
/**
|
||||
* Returns `true` if the value is a string object, e.g. created
|
||||
* by `new String()`.
|
||||
*
|
||||
* ```js
|
||||
* util.types.isStringObject('foo'); // Returns false
|
||||
* util.types.isStringObject(new String('foo')); // Returns true
|
||||
* ```
|
||||
* @since v10.0.0
|
||||
*/
|
||||
function isStringObject(object: unknown): object is String;
|
||||
/**
|
||||
* Returns `true` if the value is a symbol object, created
|
||||
* by calling `Object()` on a `Symbol` primitive.
|
||||
*
|
||||
* ```js
|
||||
* const symbol = Symbol('foo');
|
||||
* util.types.isSymbolObject(symbol); // Returns false
|
||||
* util.types.isSymbolObject(Object(symbol)); // Returns true
|
||||
* ```
|
||||
* @since v10.0.0
|
||||
*/
|
||||
function isSymbolObject(object: unknown): object is Symbol;
|
||||
/**
|
||||
* Returns `true` if the value is a built-in [`TypedArray`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray) instance.
|
||||
*
|
||||
* ```js
|
||||
* util.types.isTypedArray(new ArrayBuffer()); // Returns false
|
||||
* util.types.isTypedArray(new Uint8Array()); // Returns true
|
||||
* util.types.isTypedArray(new Float64Array()); // Returns true
|
||||
* ```
|
||||
*
|
||||
* See also [`ArrayBuffer.isView()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer/isView).
|
||||
* @since v10.0.0
|
||||
*/
|
||||
function isTypedArray(object: unknown): object is NodeJS.TypedArray;
|
||||
/**
|
||||
* Returns `true` if the value is a built-in [`Uint8Array`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Uint8Array) instance.
|
||||
*
|
||||
* ```js
|
||||
* util.types.isUint8Array(new ArrayBuffer()); // Returns false
|
||||
* util.types.isUint8Array(new Uint8Array()); // Returns true
|
||||
* util.types.isUint8Array(new Float64Array()); // Returns false
|
||||
* ```
|
||||
* @since v10.0.0
|
||||
*/
|
||||
function isUint8Array(object: unknown): object is Uint8Array;
|
||||
/**
|
||||
* Returns `true` if the value is a built-in [`Uint8ClampedArray`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Uint8ClampedArray) instance.
|
||||
*
|
||||
* ```js
|
||||
* util.types.isUint8ClampedArray(new ArrayBuffer()); // Returns false
|
||||
* util.types.isUint8ClampedArray(new Uint8ClampedArray()); // Returns true
|
||||
* util.types.isUint8ClampedArray(new Float64Array()); // Returns false
|
||||
* ```
|
||||
* @since v10.0.0
|
||||
*/
|
||||
function isUint8ClampedArray(object: unknown): object is Uint8ClampedArray;
|
||||
/**
|
||||
* Returns `true` if the value is a built-in [`Uint16Array`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Uint16Array) instance.
|
||||
*
|
||||
* ```js
|
||||
* util.types.isUint16Array(new ArrayBuffer()); // Returns false
|
||||
* util.types.isUint16Array(new Uint16Array()); // Returns true
|
||||
* util.types.isUint16Array(new Float64Array()); // Returns false
|
||||
* ```
|
||||
* @since v10.0.0
|
||||
*/
|
||||
function isUint16Array(object: unknown): object is Uint16Array;
|
||||
/**
|
||||
* Returns `true` if the value is a built-in [`Uint32Array`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Uint32Array) instance.
|
||||
*
|
||||
* ```js
|
||||
* util.types.isUint32Array(new ArrayBuffer()); // Returns false
|
||||
* util.types.isUint32Array(new Uint32Array()); // Returns true
|
||||
* util.types.isUint32Array(new Float64Array()); // Returns false
|
||||
* ```
|
||||
* @since v10.0.0
|
||||
*/
|
||||
function isUint32Array(object: unknown): object is Uint32Array;
|
||||
/**
|
||||
* Returns `true` if the value is a built-in [`WeakMap`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WeakMap) instance.
|
||||
*
|
||||
* ```js
|
||||
* util.types.isWeakMap(new WeakMap()); // Returns true
|
||||
* ```
|
||||
* @since v10.0.0
|
||||
*/
|
||||
function isWeakMap(object: unknown): object is WeakMap<object, unknown>;
|
||||
/**
|
||||
* Returns `true` if the value is a built-in [`WeakSet`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WeakSet) instance.
|
||||
*
|
||||
* ```js
|
||||
* util.types.isWeakSet(new WeakSet()); // Returns true
|
||||
* ```
|
||||
* @since v10.0.0
|
||||
*/
|
||||
function isWeakSet(object: unknown): object is WeakSet<object>;
|
||||
/**
|
||||
* Returns `true` if `value` is a `KeyObject`, `false` otherwise.
|
||||
* @since v16.2.0
|
||||
*/
|
||||
function isKeyObject(object: unknown): object is KeyObject;
|
||||
/**
|
||||
* Returns `true` if `value` is a `CryptoKey`, `false` otherwise.
|
||||
* @since v16.2.0
|
||||
*/
|
||||
function isCryptoKey(object: unknown): object is webcrypto.CryptoKey;
|
||||
}
|
||||
declare module "util/types" {
|
||||
export * from "node:util/types";
|
||||
}
|
||||
@@ -0,0 +1,2 @@
|
||||
import type { LibDefinition } from '../variable';
|
||||
export declare const es2020_number: LibDefinition;
|
||||
@@ -0,0 +1,17 @@
|
||||
"use strict";
|
||||
|
||||
function _export_star(from, to) {
|
||||
Object.keys(from).forEach(function(k) {
|
||||
if (k !== "default" && !Object.prototype.hasOwnProperty.call(to, k)) {
|
||||
Object.defineProperty(to, k, {
|
||||
enumerable: true,
|
||||
get: function() {
|
||||
return from[k];
|
||||
}
|
||||
});
|
||||
}
|
||||
});
|
||||
|
||||
return from;
|
||||
}
|
||||
exports._ = _export_star;
|
||||
@@ -0,0 +1,2 @@
|
||||
import type { LibDefinition } from '../variable';
|
||||
export declare const webworker_asynciterable: LibDefinition;
|
||||
@@ -0,0 +1,2 @@
|
||||
import type { LibDefinition } from '../variable';
|
||||
export declare const esnext_bigint: LibDefinition;
|
||||
@@ -0,0 +1,37 @@
|
||||
'use strict'
|
||||
|
||||
const test = require('node:test')
|
||||
const assert = require('node:assert')
|
||||
|
||||
const { sink, once } = require('./helper')
|
||||
const stdSerializers = require('pino-std-serializers')
|
||||
const pino = require('../')
|
||||
|
||||
test('set the errorKey with error serializer', async () => {
|
||||
const stream = sink()
|
||||
const errorKey = 'error'
|
||||
const instance = pino({
|
||||
errorKey,
|
||||
serializers: { [errorKey]: stdSerializers.err }
|
||||
}, stream)
|
||||
instance.error(new ReferenceError('test'))
|
||||
const o = await once(stream, 'data')
|
||||
assert.equal(typeof o[errorKey], 'object')
|
||||
assert.equal(o[errorKey].type, 'ReferenceError')
|
||||
assert.equal(o[errorKey].message, 'test')
|
||||
assert.equal(typeof o[errorKey].stack, 'string')
|
||||
})
|
||||
|
||||
test('set the errorKey without error serializer', async () => {
|
||||
const stream = sink()
|
||||
const errorKey = 'error'
|
||||
const instance = pino({
|
||||
errorKey
|
||||
}, stream)
|
||||
instance.error(new ReferenceError('test'))
|
||||
const o = await once(stream, 'data')
|
||||
assert.equal(typeof o[errorKey], 'object')
|
||||
assert.equal(o[errorKey].type, 'ReferenceError')
|
||||
assert.equal(o[errorKey].message, 'test')
|
||||
assert.equal(typeof o[errorKey].stack, 'string')
|
||||
})
|
||||
@@ -0,0 +1,24 @@
|
||||
'use strict'
|
||||
|
||||
module.exports = match
|
||||
|
||||
/**
|
||||
* match is a bare-bones object shape matcher. We should be able to replace
|
||||
* this with `assert.partialDeepStrictEqual` when v22 is our minimum.
|
||||
*
|
||||
* @param {object} found
|
||||
* @param {object} expected
|
||||
*/
|
||||
function match (found, expected, { assert = require('node:assert') } = {}) {
|
||||
for (const [key, value] of Object.entries(expected)) {
|
||||
if (Object.prototype.toString.call(value) === '[object Object]') {
|
||||
match(found[key], value)
|
||||
continue
|
||||
}
|
||||
if (value !== found[key]) {
|
||||
throw Error(`expected "${value}" but found "${found[key]}"`)
|
||||
}
|
||||
}
|
||||
|
||||
assert.ok('passed')
|
||||
}
|
||||
@@ -0,0 +1,17 @@
|
||||
"use strict";
|
||||
// THIS CODE WAS AUTOMATICALLY GENERATED
|
||||
// DO NOT EDIT THIS CODE BY HAND
|
||||
// RUN THE FOLLOWING COMMAND FROM THE WORKSPACE ROOT TO REGENERATE:
|
||||
// npx nx generate-lib repo
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
exports.es2024_sharedmemory = void 0;
|
||||
const base_config_1 = require("./base-config");
|
||||
const es2020_bigint_1 = require("./es2020.bigint");
|
||||
exports.es2024_sharedmemory = {
|
||||
libs: [es2020_bigint_1.es2020_bigint],
|
||||
variables: [
|
||||
['Atomics', base_config_1.TYPE],
|
||||
['SharedArrayBuffer', base_config_1.TYPE],
|
||||
['SharedArrayBufferConstructor', base_config_1.TYPE],
|
||||
],
|
||||
};
|
||||
@@ -0,0 +1,155 @@
|
||||
'use strict'
|
||||
|
||||
const crypto = require('node:crypto')
|
||||
const { join } = require('node:path')
|
||||
const os = require('node:os')
|
||||
const { existsSync, readFileSync, statSync, unlinkSync } = require('node:fs')
|
||||
const writer = require('flush-write-stream')
|
||||
const split = require('split2')
|
||||
|
||||
const pid = process.pid
|
||||
const hostname = os.hostname()
|
||||
const { tmpdir } = os
|
||||
|
||||
const isWin = process.platform === 'win32'
|
||||
const isYarnPnp = process.versions.pnp !== undefined
|
||||
|
||||
function getPathToNull () {
|
||||
return isWin ? '\\\\.\\NUL' : '/dev/null'
|
||||
}
|
||||
|
||||
function once (emitter, name) {
|
||||
return new Promise((resolve, reject) => {
|
||||
if (name !== 'error') emitter.once('error', reject)
|
||||
emitter.once(name, (...args) => {
|
||||
emitter.removeListener('error', reject)
|
||||
resolve(...args)
|
||||
})
|
||||
})
|
||||
}
|
||||
|
||||
function sink (func) {
|
||||
const result = split((data) => {
|
||||
try {
|
||||
return JSON.parse(data)
|
||||
} catch (err) {
|
||||
console.log(err)
|
||||
console.log(data)
|
||||
}
|
||||
})
|
||||
if (func) result.pipe(writer.obj(func))
|
||||
return result
|
||||
}
|
||||
|
||||
function check (is, chunk, level, msg) {
|
||||
is(new Date(chunk.time) <= new Date(), true, 'time is greater than Date.now()')
|
||||
delete chunk.time
|
||||
is(chunk.pid, pid)
|
||||
is(chunk.hostname, hostname)
|
||||
is(chunk.level, level)
|
||||
is(chunk.msg, msg)
|
||||
}
|
||||
|
||||
function sleep (ms) {
|
||||
return new Promise((resolve) => {
|
||||
setTimeout(resolve, ms)
|
||||
})
|
||||
}
|
||||
|
||||
function watchFileCreated (filename) {
|
||||
return new Promise((resolve, reject) => {
|
||||
const TIMEOUT = process.env.PINO_TEST_WAIT_WATCHFILE_TIMEOUT || 10000
|
||||
const INTERVAL = 100
|
||||
const threshold = TIMEOUT / INTERVAL
|
||||
let counter = 0
|
||||
const interval = setInterval(() => {
|
||||
const exists = existsSync(filename)
|
||||
// On some CI runs file is created but not filled
|
||||
if (exists && statSync(filename).size !== 0) {
|
||||
clearInterval(interval)
|
||||
resolve()
|
||||
} else if (counter <= threshold) {
|
||||
counter++
|
||||
} else {
|
||||
clearInterval(interval)
|
||||
reject(new Error(
|
||||
`${filename} hasn't been created within ${TIMEOUT} ms. ` +
|
||||
(exists ? 'File exist, but still empty.' : 'File not yet created.')
|
||||
))
|
||||
}
|
||||
}, INTERVAL)
|
||||
})
|
||||
}
|
||||
|
||||
function watchForWrite (filename, testString) {
|
||||
return new Promise((resolve, reject) => {
|
||||
const TIMEOUT = process.env.PINO_TEST_WAIT_WRITE_TIMEOUT || 10000
|
||||
const INTERVAL = 100
|
||||
const threshold = TIMEOUT / INTERVAL
|
||||
let counter = 0
|
||||
const interval = setInterval(() => {
|
||||
if (readFileSync(filename).includes(testString)) {
|
||||
clearInterval(interval)
|
||||
resolve()
|
||||
} else if (counter <= threshold) {
|
||||
counter++
|
||||
} else {
|
||||
clearInterval(interval)
|
||||
reject(new Error(`'${testString}' hasn't been written to ${filename} within ${TIMEOUT} ms.`))
|
||||
}
|
||||
}, INTERVAL)
|
||||
})
|
||||
}
|
||||
|
||||
let files = []
|
||||
|
||||
function file () {
|
||||
const hash = crypto.randomBytes(12).toString('hex')
|
||||
const file = join(tmpdir(), `pino-${pid}-${hash}`)
|
||||
files.push(file)
|
||||
return file
|
||||
}
|
||||
|
||||
process.on('beforeExit', () => {
|
||||
if (files.length === 0) return
|
||||
for (const file of files) {
|
||||
try {
|
||||
unlinkSync(file)
|
||||
} catch (e) {
|
||||
}
|
||||
}
|
||||
files = []
|
||||
})
|
||||
|
||||
/**
|
||||
* match is a bare-bones object shape matcher. We should be able to replace
|
||||
* this with `assert.partialDeepStrictEqual` when v22 is our minimum.
|
||||
*
|
||||
* @param {object} found
|
||||
* @param {object} expected
|
||||
*/
|
||||
function match (found, expected) {
|
||||
for (const [key, value] of Object.entries(expected)) {
|
||||
if (Object.prototype.toString.call(value) === '[object Object]') {
|
||||
match(found[key], value)
|
||||
continue
|
||||
}
|
||||
if (value !== found[key]) {
|
||||
throw Error(`expected "${value}" but found "${found[key]}"`)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
module.exports = {
|
||||
check,
|
||||
file,
|
||||
getPathToNull,
|
||||
isWin,
|
||||
isYarnPnp,
|
||||
match,
|
||||
once,
|
||||
sink,
|
||||
sleep,
|
||||
watchFileCreated,
|
||||
watchForWrite
|
||||
}
|
||||
@@ -0,0 +1,2 @@
|
||||
export declare var CommentDirectiveType: any;
|
||||
//# sourceMappingURL=commentDirectiveType.d.ts.map
|
||||
Reference in New Issue
Block a user