WIP: bootstrap and partial real Solana watcher implementation
This commit is contained in:
@@ -0,0 +1,67 @@
|
||||
/**
|
||||
* Internal helpers for u64. BigUint64Array is too slow as per 2025, so we implement it using Uint32Array.
|
||||
* @todo re-check https://issues.chromium.org/issues/42212588
|
||||
* @module
|
||||
*/
|
||||
const U32_MASK64 = /* @__PURE__ */ BigInt(2 ** 32 - 1);
|
||||
const _32n = /* @__PURE__ */ BigInt(32);
|
||||
function fromBig(n, le = false) {
|
||||
if (le)
|
||||
return { h: Number(n & U32_MASK64), l: Number((n >> _32n) & U32_MASK64) };
|
||||
return { h: Number((n >> _32n) & U32_MASK64) | 0, l: Number(n & U32_MASK64) | 0 };
|
||||
}
|
||||
function split(lst, le = false) {
|
||||
const len = lst.length;
|
||||
let Ah = new Uint32Array(len);
|
||||
let Al = new Uint32Array(len);
|
||||
for (let i = 0; i < len; i++) {
|
||||
const { h, l } = fromBig(lst[i], le);
|
||||
[Ah[i], Al[i]] = [h, l];
|
||||
}
|
||||
return [Ah, Al];
|
||||
}
|
||||
const toBig = (h, l) => (BigInt(h >>> 0) << _32n) | BigInt(l >>> 0);
|
||||
// for Shift in [0, 32)
|
||||
const shrSH = (h, _l, s) => h >>> s;
|
||||
const shrSL = (h, l, s) => (h << (32 - s)) | (l >>> s);
|
||||
// Right rotate for Shift in [1, 32)
|
||||
const rotrSH = (h, l, s) => (h >>> s) | (l << (32 - s));
|
||||
const rotrSL = (h, l, s) => (h << (32 - s)) | (l >>> s);
|
||||
// Right rotate for Shift in (32, 64), NOTE: 32 is special case.
|
||||
const rotrBH = (h, l, s) => (h << (64 - s)) | (l >>> (s - 32));
|
||||
const rotrBL = (h, l, s) => (h >>> (s - 32)) | (l << (64 - s));
|
||||
// Right rotate for shift===32 (just swaps l&h)
|
||||
const rotr32H = (_h, l) => l;
|
||||
const rotr32L = (h, _l) => h;
|
||||
// Left rotate for Shift in [1, 32)
|
||||
const rotlSH = (h, l, s) => (h << s) | (l >>> (32 - s));
|
||||
const rotlSL = (h, l, s) => (l << s) | (h >>> (32 - s));
|
||||
// Left rotate for Shift in (32, 64), NOTE: 32 is special case.
|
||||
const rotlBH = (h, l, s) => (l << (s - 32)) | (h >>> (64 - s));
|
||||
const rotlBL = (h, l, s) => (h << (s - 32)) | (l >>> (64 - s));
|
||||
// JS uses 32-bit signed integers for bitwise operations which means we cannot
|
||||
// simple take carry out of low bit sum by shift, we need to use division.
|
||||
function add(Ah, Al, Bh, Bl) {
|
||||
const l = (Al >>> 0) + (Bl >>> 0);
|
||||
return { h: (Ah + Bh + ((l / 2 ** 32) | 0)) | 0, l: l | 0 };
|
||||
}
|
||||
// Addition with more than 2 elements
|
||||
const add3L = (Al, Bl, Cl) => (Al >>> 0) + (Bl >>> 0) + (Cl >>> 0);
|
||||
const add3H = (low, Ah, Bh, Ch) => (Ah + Bh + Ch + ((low / 2 ** 32) | 0)) | 0;
|
||||
const add4L = (Al, Bl, Cl, Dl) => (Al >>> 0) + (Bl >>> 0) + (Cl >>> 0) + (Dl >>> 0);
|
||||
const add4H = (low, Ah, Bh, Ch, Dh) => (Ah + Bh + Ch + Dh + ((low / 2 ** 32) | 0)) | 0;
|
||||
const add5L = (Al, Bl, Cl, Dl, El) => (Al >>> 0) + (Bl >>> 0) + (Cl >>> 0) + (Dl >>> 0) + (El >>> 0);
|
||||
const add5H = (low, Ah, Bh, Ch, Dh, Eh) => (Ah + Bh + Ch + Dh + Eh + ((low / 2 ** 32) | 0)) | 0;
|
||||
// prettier-ignore
|
||||
export { add, add3H, add3L, add4H, add4L, add5H, add5L, fromBig, rotlBH, rotlBL, rotlSH, rotlSL, rotr32H, rotr32L, rotrBH, rotrBL, rotrSH, rotrSL, shrSH, shrSL, split, toBig };
|
||||
// prettier-ignore
|
||||
const u64 = {
|
||||
fromBig, split, toBig,
|
||||
shrSH, shrSL,
|
||||
rotrSH, rotrSL, rotrBH, rotrBL,
|
||||
rotr32H, rotr32L,
|
||||
rotlSH, rotlSL, rotlBH, rotlBL,
|
||||
add, add3L, add3H, add4L, add4H, add5H, add5L,
|
||||
};
|
||||
export default u64;
|
||||
//# sourceMappingURL=_u64.js.map
|
||||
@@ -0,0 +1,7 @@
|
||||
function _classApplyDescriptorSet(e, t, l) {
|
||||
if (t.set) t.set.call(e, l);else {
|
||||
if (!t.writable) throw new TypeError("attempted to set read only private field");
|
||||
t.value = l;
|
||||
}
|
||||
}
|
||||
module.exports = _classApplyDescriptorSet, module.exports.__esModule = true, module.exports["default"] = module.exports;
|
||||
@@ -0,0 +1 @@
|
||||
export { _ as default } from "../esm/_ts_values.js";
|
||||
@@ -0,0 +1,37 @@
|
||||
import {PublicKey} from './publickey';
|
||||
|
||||
export const SYSVAR_CLOCK_PUBKEY = new PublicKey(
|
||||
'SysvarC1ock11111111111111111111111111111111',
|
||||
);
|
||||
|
||||
export const SYSVAR_EPOCH_SCHEDULE_PUBKEY = new PublicKey(
|
||||
'SysvarEpochSchedu1e111111111111111111111111',
|
||||
);
|
||||
|
||||
export const SYSVAR_INSTRUCTIONS_PUBKEY = new PublicKey(
|
||||
'Sysvar1nstructions1111111111111111111111111',
|
||||
);
|
||||
|
||||
export const SYSVAR_RECENT_BLOCKHASHES_PUBKEY = new PublicKey(
|
||||
'SysvarRecentB1ockHashes11111111111111111111',
|
||||
);
|
||||
|
||||
export const SYSVAR_RENT_PUBKEY = new PublicKey(
|
||||
'SysvarRent111111111111111111111111111111111',
|
||||
);
|
||||
|
||||
export const SYSVAR_REWARDS_PUBKEY = new PublicKey(
|
||||
'SysvarRewards111111111111111111111111111111',
|
||||
);
|
||||
|
||||
export const SYSVAR_SLOT_HASHES_PUBKEY = new PublicKey(
|
||||
'SysvarS1otHashes111111111111111111111111111',
|
||||
);
|
||||
|
||||
export const SYSVAR_SLOT_HISTORY_PUBKEY = new PublicKey(
|
||||
'SysvarS1otHistory11111111111111111111111111',
|
||||
);
|
||||
|
||||
export const SYSVAR_STAKE_HISTORY_PUBKEY = new PublicKey(
|
||||
'SysvarStakeHistory1111111111111111111111111',
|
||||
);
|
||||
@@ -0,0 +1,119 @@
|
||||
/*! *****************************************************************************
|
||||
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,
|
||||
MERCHANTABILITY OR NON-INFRINGEMENT.
|
||||
|
||||
See the Apache Version 2.0 License for specific language governing permissions
|
||||
and limitations under the License.
|
||||
***************************************************************************** */
|
||||
|
||||
|
||||
interface Array<T> {
|
||||
/**
|
||||
* Returns the item located at the specified index.
|
||||
* @param index The zero-based index of the desired code unit. A negative index will count back from the last item.
|
||||
*/
|
||||
at(index: number): T | undefined;
|
||||
}
|
||||
|
||||
interface ReadonlyArray<T> {
|
||||
/**
|
||||
* Returns the item located at the specified index.
|
||||
* @param index The zero-based index of the desired code unit. A negative index will count back from the last item.
|
||||
*/
|
||||
at(index: number): T | undefined;
|
||||
}
|
||||
|
||||
interface Int8Array<TArrayBuffer extends ArrayBufferLike> {
|
||||
/**
|
||||
* Returns the item located at the specified index.
|
||||
* @param index The zero-based index of the desired code unit. A negative index will count back from the last item.
|
||||
*/
|
||||
at(index: number): number | undefined;
|
||||
}
|
||||
|
||||
interface Uint8Array<TArrayBuffer extends ArrayBufferLike> {
|
||||
/**
|
||||
* Returns the item located at the specified index.
|
||||
* @param index The zero-based index of the desired code unit. A negative index will count back from the last item.
|
||||
*/
|
||||
at(index: number): number | undefined;
|
||||
}
|
||||
|
||||
interface Uint8ClampedArray<TArrayBuffer extends ArrayBufferLike> {
|
||||
/**
|
||||
* Returns the item located at the specified index.
|
||||
* @param index The zero-based index of the desired code unit. A negative index will count back from the last item.
|
||||
*/
|
||||
at(index: number): number | undefined;
|
||||
}
|
||||
|
||||
interface Int16Array<TArrayBuffer extends ArrayBufferLike> {
|
||||
/**
|
||||
* Returns the item located at the specified index.
|
||||
* @param index The zero-based index of the desired code unit. A negative index will count back from the last item.
|
||||
*/
|
||||
at(index: number): number | undefined;
|
||||
}
|
||||
|
||||
interface Uint16Array<TArrayBuffer extends ArrayBufferLike> {
|
||||
/**
|
||||
* Returns the item located at the specified index.
|
||||
* @param index The zero-based index of the desired code unit. A negative index will count back from the last item.
|
||||
*/
|
||||
at(index: number): number | undefined;
|
||||
}
|
||||
|
||||
interface Int32Array<TArrayBuffer extends ArrayBufferLike> {
|
||||
/**
|
||||
* Returns the item located at the specified index.
|
||||
* @param index The zero-based index of the desired code unit. A negative index will count back from the last item.
|
||||
*/
|
||||
at(index: number): number | undefined;
|
||||
}
|
||||
|
||||
interface Uint32Array<TArrayBuffer extends ArrayBufferLike> {
|
||||
/**
|
||||
* Returns the item located at the specified index.
|
||||
* @param index The zero-based index of the desired code unit. A negative index will count back from the last item.
|
||||
*/
|
||||
at(index: number): number | undefined;
|
||||
}
|
||||
|
||||
interface Float32Array<TArrayBuffer extends ArrayBufferLike> {
|
||||
/**
|
||||
* Returns the item located at the specified index.
|
||||
* @param index The zero-based index of the desired code unit. A negative index will count back from the last item.
|
||||
*/
|
||||
at(index: number): number | undefined;
|
||||
}
|
||||
|
||||
interface Float64Array<TArrayBuffer extends ArrayBufferLike> {
|
||||
/**
|
||||
* Returns the item located at the specified index.
|
||||
* @param index The zero-based index of the desired code unit. A negative index will count back from the last item.
|
||||
*/
|
||||
at(index: number): number | undefined;
|
||||
}
|
||||
|
||||
interface BigInt64Array<TArrayBuffer extends ArrayBufferLike> {
|
||||
/**
|
||||
* Returns the item located at the specified index.
|
||||
* @param index The zero-based index of the desired code unit. A negative index will count back from the last item.
|
||||
*/
|
||||
at(index: number): bigint | undefined;
|
||||
}
|
||||
|
||||
interface BigUint64Array<TArrayBuffer extends ArrayBufferLike> {
|
||||
/**
|
||||
* Returns the item located at the specified index.
|
||||
* @param index The zero-based index of the desired code unit. A negative index will count back from the last item.
|
||||
*/
|
||||
at(index: number): bigint | undefined;
|
||||
}
|
||||
@@ -0,0 +1,34 @@
|
||||
/**
|
||||
* SHA2-512 a.k.a. sha512 and sha384. It is slower than sha256 in js because u64 operations are slow.
|
||||
*
|
||||
* Check out [RFC 4634](https://datatracker.ietf.org/doc/html/rfc4634) and
|
||||
* [the paper on truncated SHA512/256](https://eprint.iacr.org/2010/548.pdf).
|
||||
* @module
|
||||
* @deprecated
|
||||
*/
|
||||
import {
|
||||
SHA384 as SHA384n,
|
||||
sha384 as sha384n,
|
||||
sha512_224 as sha512_224n,
|
||||
SHA512_224 as SHA512_224n,
|
||||
sha512_256 as sha512_256n,
|
||||
SHA512_256 as SHA512_256n,
|
||||
SHA512 as SHA512n,
|
||||
sha512 as sha512n,
|
||||
} from './sha2.ts';
|
||||
/** @deprecated Use import from `noble/hashes/sha2` module */
|
||||
export const SHA512: typeof SHA512n = SHA512n;
|
||||
/** @deprecated Use import from `noble/hashes/sha2` module */
|
||||
export const sha512: typeof sha512n = sha512n;
|
||||
/** @deprecated Use import from `noble/hashes/sha2` module */
|
||||
export const SHA384: typeof SHA384n = SHA384n;
|
||||
/** @deprecated Use import from `noble/hashes/sha2` module */
|
||||
export const sha384: typeof sha384n = sha384n;
|
||||
/** @deprecated Use import from `noble/hashes/sha2` module */
|
||||
export const SHA512_224: typeof SHA512_224n = SHA512_224n;
|
||||
/** @deprecated Use import from `noble/hashes/sha2` module */
|
||||
export const sha512_224: typeof sha512_224n = sha512_224n;
|
||||
/** @deprecated Use import from `noble/hashes/sha2` module */
|
||||
export const SHA512_256: typeof SHA512_256n = SHA512_256n;
|
||||
/** @deprecated Use import from `noble/hashes/sha2` module */
|
||||
export const sha512_256: typeof sha512_256n = sha512_256n;
|
||||
@@ -0,0 +1 @@
|
||||
!function(t,e){"object"==typeof exports&&"undefined"!=typeof module?module.exports=e():"function"==typeof define&&define.amd?define(e):(t="undefined"!=typeof globalThis?globalThis:t||self).uuidv4=e()}(this,(function(){"use strict";var t,e=new Uint8Array(16);function o(){if(!t&&!(t="undefined"!=typeof crypto&&crypto.getRandomValues&&crypto.getRandomValues.bind(crypto)||"undefined"!=typeof msCrypto&&"function"==typeof msCrypto.getRandomValues&&msCrypto.getRandomValues.bind(msCrypto)))throw new Error("crypto.getRandomValues() not supported. See https://github.com/uuidjs/uuid#getrandomvalues-not-supported");return t(e)}var n=/^(?:[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}|00000000-0000-0000-0000-000000000000)$/i;function r(t){return"string"==typeof t&&n.test(t)}for(var i=[],u=0;u<256;++u)i.push((u+256).toString(16).substr(1));return function(t,e,n){var u=(t=t||{}).random||(t.rng||o)();if(u[6]=15&u[6]|64,u[8]=63&u[8]|128,e){n=n||0;for(var f=0;f<16;++f)e[n+f]=u[f];return e}return function(t){var e=arguments.length>1&&void 0!==arguments[1]?arguments[1]:0,o=(i[t[e+0]]+i[t[e+1]]+i[t[e+2]]+i[t[e+3]]+"-"+i[t[e+4]]+i[t[e+5]]+"-"+i[t[e+6]]+i[t[e+7]]+"-"+i[t[e+8]]+i[t[e+9]]+"-"+i[t[e+10]]+i[t[e+11]]+i[t[e+12]]+i[t[e+13]]+i[t[e+14]]+i[t[e+15]]).toLowerCase();if(!r(o))throw TypeError("Stringified UUID is invalid");return o}(u)}}));
|
||||
@@ -0,0 +1,22 @@
|
||||
/**
|
||||
Regular expression for matching a [shebang](https://en.wikipedia.org/wiki/Shebang_(Unix)) line.
|
||||
|
||||
@example
|
||||
```
|
||||
import shebangRegex = require('shebang-regex');
|
||||
|
||||
const string = '#!/usr/bin/env node\nconsole.log("unicorns");';
|
||||
|
||||
shebangRegex.test(string);
|
||||
//=> true
|
||||
|
||||
shebangRegex.exec(string)[0];
|
||||
//=> '#!/usr/bin/env node'
|
||||
|
||||
shebangRegex.exec(string)[1];
|
||||
//=> '/usr/bin/env node'
|
||||
```
|
||||
*/
|
||||
declare const shebangRegex: RegExp;
|
||||
|
||||
export = shebangRegex;
|
||||
@@ -0,0 +1,733 @@
|
||||
'use strict'
|
||||
|
||||
const fs = require('fs')
|
||||
const EventEmitter = require('events')
|
||||
const inherits = require('util').inherits
|
||||
const path = require('path')
|
||||
const sleep = require('atomic-sleep')
|
||||
const assert = require('assert')
|
||||
|
||||
const BUSY_WRITE_TIMEOUT = 100
|
||||
const kEmptyBuffer = Buffer.allocUnsafe(0)
|
||||
|
||||
// 16 KB. Don't write more than docker buffer size.
|
||||
// https://github.com/moby/moby/blob/513ec73831269947d38a644c278ce3cac36783b2/daemon/logger/copier.go#L13
|
||||
const MAX_WRITE = 16 * 1024
|
||||
|
||||
const kContentModeBuffer = 'buffer'
|
||||
const kContentModeUtf8 = 'utf8'
|
||||
|
||||
const [major, minor] = (process.versions.node || '0.0').split('.').map(Number)
|
||||
const kCopyBuffer = major >= 22 && minor >= 7
|
||||
|
||||
function openFile (file, sonic) {
|
||||
sonic._opening = true
|
||||
sonic._writing = true
|
||||
sonic._asyncDrainScheduled = false
|
||||
|
||||
// NOTE: 'error' and 'ready' events emitted below only relevant when sonic.sync===false
|
||||
// for sync mode, there is no way to add a listener that will receive these
|
||||
|
||||
function fileOpened (err, fd) {
|
||||
if (err) {
|
||||
sonic._reopening = false
|
||||
sonic._writing = false
|
||||
sonic._opening = false
|
||||
|
||||
if (sonic.sync) {
|
||||
process.nextTick(() => {
|
||||
if (sonic.listenerCount('error') > 0) {
|
||||
sonic.emit('error', err)
|
||||
}
|
||||
})
|
||||
} else {
|
||||
sonic.emit('error', err)
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
const reopening = sonic._reopening
|
||||
|
||||
sonic.fd = fd
|
||||
sonic.file = file
|
||||
sonic._reopening = false
|
||||
sonic._opening = false
|
||||
sonic._writing = false
|
||||
|
||||
if (sonic.sync) {
|
||||
process.nextTick(() => sonic.emit('ready'))
|
||||
} else {
|
||||
sonic.emit('ready')
|
||||
}
|
||||
|
||||
if (sonic.destroyed) {
|
||||
return
|
||||
}
|
||||
|
||||
// start
|
||||
if ((!sonic._writing && sonic._len > sonic.minLength) || sonic._flushPending) {
|
||||
sonic._actualWrite()
|
||||
} else if (reopening) {
|
||||
process.nextTick(() => sonic.emit('drain'))
|
||||
}
|
||||
}
|
||||
|
||||
const flags = sonic.append ? 'a' : 'w'
|
||||
const mode = sonic.mode
|
||||
|
||||
if (sonic.sync) {
|
||||
try {
|
||||
if (sonic.mkdir) fs.mkdirSync(path.dirname(file), { recursive: true })
|
||||
const fd = fs.openSync(file, flags, mode)
|
||||
fileOpened(null, fd)
|
||||
} catch (err) {
|
||||
fileOpened(err)
|
||||
throw err
|
||||
}
|
||||
} else if (sonic.mkdir) {
|
||||
fs.mkdir(path.dirname(file), { recursive: true }, (err) => {
|
||||
if (err) return fileOpened(err)
|
||||
fs.open(file, flags, mode, fileOpened)
|
||||
})
|
||||
} else {
|
||||
fs.open(file, flags, mode, fileOpened)
|
||||
}
|
||||
}
|
||||
|
||||
function SonicBoom (opts) {
|
||||
if (!(this instanceof SonicBoom)) {
|
||||
return new SonicBoom(opts)
|
||||
}
|
||||
|
||||
let { fd, dest, minLength, maxLength, maxWrite, periodicFlush, sync, append = true, mkdir, retryEAGAIN, fsync, contentMode, mode } = opts || {}
|
||||
|
||||
fd = fd || dest
|
||||
|
||||
this._len = 0
|
||||
this.fd = -1
|
||||
this._bufs = []
|
||||
this._lens = []
|
||||
this._writing = false
|
||||
this._ending = false
|
||||
this._reopening = false
|
||||
this._asyncDrainScheduled = false
|
||||
this._flushPending = false
|
||||
this._hwm = Math.max(minLength || 0, 16387)
|
||||
this.file = null
|
||||
this.destroyed = false
|
||||
this.minLength = minLength || 0
|
||||
this.maxLength = maxLength || 0
|
||||
this.maxWrite = maxWrite || MAX_WRITE
|
||||
this._periodicFlush = periodicFlush || 0
|
||||
this._periodicFlushTimer = undefined
|
||||
this.sync = sync || false
|
||||
this.writable = true
|
||||
this._fsync = fsync || false
|
||||
this.append = append || false
|
||||
this.mode = mode
|
||||
this.retryEAGAIN = retryEAGAIN || (() => true)
|
||||
this.mkdir = mkdir || false
|
||||
|
||||
let fsWriteSync
|
||||
let fsWrite
|
||||
if (contentMode === kContentModeBuffer) {
|
||||
this._writingBuf = kEmptyBuffer
|
||||
this.write = writeBuffer
|
||||
this.flush = flushBuffer
|
||||
this.flushSync = flushBufferSync
|
||||
this._actualWrite = actualWriteBuffer
|
||||
fsWriteSync = () => fs.writeSync(this.fd, this._writingBuf)
|
||||
fsWrite = () => fs.write(this.fd, this._writingBuf, this.release)
|
||||
} else if (contentMode === undefined || contentMode === kContentModeUtf8) {
|
||||
this._writingBuf = ''
|
||||
this.write = write
|
||||
this.flush = flush
|
||||
this.flushSync = flushSync
|
||||
this._actualWrite = actualWrite
|
||||
fsWriteSync = () => {
|
||||
if (Buffer.isBuffer(this._writingBuf)) {
|
||||
return fs.writeSync(this.fd, this._writingBuf)
|
||||
}
|
||||
return fs.writeSync(this.fd, this._writingBuf, 'utf8')
|
||||
}
|
||||
fsWrite = () => {
|
||||
if (Buffer.isBuffer(this._writingBuf)) {
|
||||
return fs.write(this.fd, this._writingBuf, this.release)
|
||||
}
|
||||
return fs.write(this.fd, this._writingBuf, 'utf8', this.release)
|
||||
}
|
||||
} else {
|
||||
throw new Error(`SonicBoom supports "${kContentModeUtf8}" and "${kContentModeBuffer}", but passed ${contentMode}`)
|
||||
}
|
||||
|
||||
if (typeof fd === 'number') {
|
||||
this.fd = fd
|
||||
process.nextTick(() => this.emit('ready'))
|
||||
} else if (typeof fd === 'string') {
|
||||
openFile(fd, this)
|
||||
} else {
|
||||
throw new Error('SonicBoom supports only file descriptors and files')
|
||||
}
|
||||
if (this.minLength >= this.maxWrite) {
|
||||
throw new Error(`minLength should be smaller than maxWrite (${this.maxWrite})`)
|
||||
}
|
||||
|
||||
this.release = (err, n) => {
|
||||
if (err) {
|
||||
if ((err.code === 'EAGAIN' || err.code === 'EBUSY') && this.retryEAGAIN(err, this._writingBuf.length, this._len - this._writingBuf.length)) {
|
||||
if (this.sync) {
|
||||
// This error code should not happen in sync mode, because it is
|
||||
// not using the underlining operating system asynchronous functions.
|
||||
// However it happens, and so we handle it.
|
||||
// Ref: https://github.com/pinojs/pino/issues/783
|
||||
try {
|
||||
sleep(BUSY_WRITE_TIMEOUT)
|
||||
this.release(undefined, 0)
|
||||
} catch (err) {
|
||||
this.release(err)
|
||||
}
|
||||
} else {
|
||||
// Let's give the destination some time to process the chunk.
|
||||
setTimeout(fsWrite, BUSY_WRITE_TIMEOUT)
|
||||
}
|
||||
} else {
|
||||
this._writing = false
|
||||
|
||||
this.emit('error', err)
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
this.emit('write', n)
|
||||
const releasedBufObj = releaseWritingBuf(this._writingBuf, this._len, n)
|
||||
this._len = releasedBufObj.len
|
||||
this._writingBuf = releasedBufObj.writingBuf
|
||||
|
||||
if (this._writingBuf.length) {
|
||||
if (!this.sync) {
|
||||
fsWrite()
|
||||
return
|
||||
}
|
||||
|
||||
try {
|
||||
do {
|
||||
const n = fsWriteSync()
|
||||
const releasedBufObj = releaseWritingBuf(this._writingBuf, this._len, n)
|
||||
this._len = releasedBufObj.len
|
||||
this._writingBuf = releasedBufObj.writingBuf
|
||||
} while (this._writingBuf.length)
|
||||
} catch (err) {
|
||||
this.release(err)
|
||||
return
|
||||
}
|
||||
}
|
||||
|
||||
if (this._fsync) {
|
||||
fs.fsyncSync(this.fd)
|
||||
}
|
||||
|
||||
const len = this._len
|
||||
if (this._reopening) {
|
||||
this._writing = false
|
||||
this._reopening = false
|
||||
this.reopen()
|
||||
} else if (len > this.minLength) {
|
||||
this._actualWrite()
|
||||
} else if (this._ending) {
|
||||
if (len > 0) {
|
||||
this._actualWrite()
|
||||
} else {
|
||||
this._writing = false
|
||||
actualClose(this)
|
||||
}
|
||||
} else {
|
||||
this._writing = false
|
||||
if (this.sync) {
|
||||
if (!this._asyncDrainScheduled) {
|
||||
this._asyncDrainScheduled = true
|
||||
process.nextTick(emitDrain, this)
|
||||
}
|
||||
} else {
|
||||
this.emit('drain')
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
this.on('newListener', function (name) {
|
||||
if (name === 'drain') {
|
||||
this._asyncDrainScheduled = false
|
||||
}
|
||||
})
|
||||
|
||||
if (this._periodicFlush !== 0) {
|
||||
this._periodicFlushTimer = setInterval(() => this.flush(null), this._periodicFlush)
|
||||
this._periodicFlushTimer.unref()
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Release the writingBuf after fs.write n bytes data
|
||||
* @param {string | Buffer} writingBuf - currently writing buffer, usually be instance._writingBuf.
|
||||
* @param {number} len - currently buffer length, usually be instance._len.
|
||||
* @param {number} n - number of bytes fs already written
|
||||
* @returns {{writingBuf: string | Buffer, len: number}} released writingBuf and length
|
||||
*/
|
||||
function releaseWritingBuf (writingBuf, len, n) {
|
||||
if (typeof writingBuf === 'string') {
|
||||
writingBuf = Buffer.from(writingBuf)
|
||||
}
|
||||
|
||||
len = Math.max(len - n, 0)
|
||||
writingBuf = writingBuf.subarray(n)
|
||||
return { writingBuf, len }
|
||||
}
|
||||
|
||||
function emitDrain (sonic) {
|
||||
const hasListeners = sonic.listenerCount('drain') > 0
|
||||
if (!hasListeners) return
|
||||
sonic._asyncDrainScheduled = false
|
||||
sonic.emit('drain')
|
||||
}
|
||||
|
||||
inherits(SonicBoom, EventEmitter)
|
||||
|
||||
function mergeBuf (bufs, len) {
|
||||
if (bufs.length === 0) {
|
||||
return kEmptyBuffer
|
||||
}
|
||||
|
||||
if (bufs.length === 1) {
|
||||
return bufs[0]
|
||||
}
|
||||
|
||||
return Buffer.concat(bufs, len)
|
||||
}
|
||||
|
||||
function write (data) {
|
||||
if (this.destroyed) {
|
||||
throw new Error('SonicBoom destroyed')
|
||||
}
|
||||
|
||||
data = '' + data
|
||||
const dataLen = Buffer.byteLength(data)
|
||||
const len = this._len + dataLen
|
||||
const bufs = this._bufs
|
||||
|
||||
if (this.maxLength && len > this.maxLength) {
|
||||
this.emit('drop', data)
|
||||
return this._len < this._hwm
|
||||
}
|
||||
|
||||
if (
|
||||
bufs.length === 0 ||
|
||||
Buffer.byteLength(bufs[bufs.length - 1]) + dataLen > this.maxWrite
|
||||
) {
|
||||
bufs.push(data)
|
||||
} else {
|
||||
bufs[bufs.length - 1] += data
|
||||
}
|
||||
|
||||
this._len = len
|
||||
|
||||
if (!this._writing && this._len >= this.minLength) {
|
||||
this._actualWrite()
|
||||
}
|
||||
|
||||
return this._len < this._hwm
|
||||
}
|
||||
|
||||
function writeBuffer (data) {
|
||||
if (this.destroyed) {
|
||||
throw new Error('SonicBoom destroyed')
|
||||
}
|
||||
|
||||
const len = this._len + data.length
|
||||
const bufs = this._bufs
|
||||
const lens = this._lens
|
||||
|
||||
if (this.maxLength && len > this.maxLength) {
|
||||
this.emit('drop', data)
|
||||
return this._len < this._hwm
|
||||
}
|
||||
|
||||
if (
|
||||
bufs.length === 0 ||
|
||||
lens[lens.length - 1] + data.length > this.maxWrite
|
||||
) {
|
||||
bufs.push([data])
|
||||
lens.push(data.length)
|
||||
} else {
|
||||
bufs[bufs.length - 1].push(data)
|
||||
lens[lens.length - 1] += data.length
|
||||
}
|
||||
|
||||
this._len = len
|
||||
|
||||
if (!this._writing && this._len >= this.minLength) {
|
||||
this._actualWrite()
|
||||
}
|
||||
|
||||
return this._len < this._hwm
|
||||
}
|
||||
|
||||
function callFlushCallbackOnDrain (cb) {
|
||||
this._flushPending = true
|
||||
const onDrain = () => {
|
||||
// only if _fsync is false to avoid double fsync
|
||||
if (!this._fsync) {
|
||||
try {
|
||||
fs.fsync(this.fd, (err) => {
|
||||
this._flushPending = false
|
||||
cb(err)
|
||||
})
|
||||
} catch (err) {
|
||||
cb(err)
|
||||
}
|
||||
} else {
|
||||
this._flushPending = false
|
||||
cb()
|
||||
}
|
||||
this.off('error', onError)
|
||||
}
|
||||
const onError = (err) => {
|
||||
this._flushPending = false
|
||||
cb(err)
|
||||
this.off('drain', onDrain)
|
||||
}
|
||||
|
||||
this.once('drain', onDrain)
|
||||
this.once('error', onError)
|
||||
}
|
||||
|
||||
function flush (cb) {
|
||||
if (cb != null && typeof cb !== 'function') {
|
||||
throw new Error('flush cb must be a function')
|
||||
}
|
||||
|
||||
if (this.destroyed) {
|
||||
const error = new Error('SonicBoom destroyed')
|
||||
if (cb) {
|
||||
cb(error)
|
||||
return
|
||||
}
|
||||
|
||||
throw error
|
||||
}
|
||||
|
||||
if (this.minLength <= 0) {
|
||||
cb?.()
|
||||
return
|
||||
}
|
||||
|
||||
if (cb) {
|
||||
callFlushCallbackOnDrain.call(this, cb)
|
||||
}
|
||||
|
||||
if (this._writing) {
|
||||
return
|
||||
}
|
||||
|
||||
if (this._bufs.length === 0) {
|
||||
this._bufs.push('')
|
||||
}
|
||||
|
||||
this._actualWrite()
|
||||
}
|
||||
|
||||
function flushBuffer (cb) {
|
||||
if (cb != null && typeof cb !== 'function') {
|
||||
throw new Error('flush cb must be a function')
|
||||
}
|
||||
|
||||
if (this.destroyed) {
|
||||
const error = new Error('SonicBoom destroyed')
|
||||
if (cb) {
|
||||
cb(error)
|
||||
return
|
||||
}
|
||||
|
||||
throw error
|
||||
}
|
||||
|
||||
if (this.minLength <= 0) {
|
||||
cb?.()
|
||||
return
|
||||
}
|
||||
|
||||
if (cb) {
|
||||
callFlushCallbackOnDrain.call(this, cb)
|
||||
}
|
||||
|
||||
if (this._writing) {
|
||||
return
|
||||
}
|
||||
|
||||
if (this._bufs.length === 0) {
|
||||
this._bufs.push([])
|
||||
this._lens.push(0)
|
||||
}
|
||||
|
||||
this._actualWrite()
|
||||
}
|
||||
|
||||
SonicBoom.prototype.reopen = function (file) {
|
||||
if (this.destroyed) {
|
||||
throw new Error('SonicBoom destroyed')
|
||||
}
|
||||
|
||||
if (this._opening) {
|
||||
this.once('ready', () => {
|
||||
this.reopen(file)
|
||||
})
|
||||
return
|
||||
}
|
||||
|
||||
if (this._ending) {
|
||||
return
|
||||
}
|
||||
|
||||
if (!this.file) {
|
||||
throw new Error('Unable to reopen a file descriptor, you must pass a file to SonicBoom')
|
||||
}
|
||||
|
||||
if (file) {
|
||||
this.file = file
|
||||
}
|
||||
this._reopening = true
|
||||
|
||||
if (this._writing) {
|
||||
return
|
||||
}
|
||||
|
||||
const fd = this.fd
|
||||
this.once('ready', () => {
|
||||
if (fd !== this.fd) {
|
||||
fs.close(fd, (err) => {
|
||||
if (err) {
|
||||
return this.emit('error', err)
|
||||
}
|
||||
})
|
||||
}
|
||||
})
|
||||
|
||||
openFile(this.file, this)
|
||||
}
|
||||
|
||||
SonicBoom.prototype.end = function () {
|
||||
if (this.destroyed) {
|
||||
throw new Error('SonicBoom destroyed')
|
||||
}
|
||||
|
||||
if (this._opening) {
|
||||
this.once('ready', () => {
|
||||
this.end()
|
||||
})
|
||||
return
|
||||
}
|
||||
|
||||
if (this._ending) {
|
||||
return
|
||||
}
|
||||
|
||||
this._ending = true
|
||||
|
||||
if (this._writing) {
|
||||
return
|
||||
}
|
||||
|
||||
if (this._len > 0 && this.fd >= 0) {
|
||||
this._actualWrite()
|
||||
} else {
|
||||
actualClose(this)
|
||||
}
|
||||
}
|
||||
|
||||
function flushSync () {
|
||||
if (this.destroyed) {
|
||||
throw new Error('SonicBoom destroyed')
|
||||
}
|
||||
|
||||
if (this.fd < 0) {
|
||||
throw new Error('sonic boom is not ready yet')
|
||||
}
|
||||
|
||||
if (!this._writing && this._writingBuf.length > 0) {
|
||||
this._bufs.unshift(this._writingBuf)
|
||||
this._writingBuf = ''
|
||||
}
|
||||
|
||||
let buf = ''
|
||||
while (this._bufs.length || buf.length) {
|
||||
if (buf.length <= 0) {
|
||||
buf = this._bufs[0]
|
||||
}
|
||||
try {
|
||||
const n = Buffer.isBuffer(buf)
|
||||
? fs.writeSync(this.fd, buf)
|
||||
: fs.writeSync(this.fd, buf, 'utf8')
|
||||
const releasedBufObj = releaseWritingBuf(buf, this._len, n)
|
||||
buf = releasedBufObj.writingBuf
|
||||
this._len = releasedBufObj.len
|
||||
if (buf.length <= 0) {
|
||||
this._bufs.shift()
|
||||
}
|
||||
} catch (err) {
|
||||
const shouldRetry = err.code === 'EAGAIN' || err.code === 'EBUSY'
|
||||
if (shouldRetry && !this.retryEAGAIN(err, buf.length, this._len - buf.length)) {
|
||||
throw err
|
||||
}
|
||||
|
||||
sleep(BUSY_WRITE_TIMEOUT)
|
||||
}
|
||||
}
|
||||
|
||||
try {
|
||||
fs.fsyncSync(this.fd)
|
||||
} catch {
|
||||
// Skip the error. The fd might not support fsync.
|
||||
}
|
||||
}
|
||||
|
||||
function flushBufferSync () {
|
||||
if (this.destroyed) {
|
||||
throw new Error('SonicBoom destroyed')
|
||||
}
|
||||
|
||||
if (this.fd < 0) {
|
||||
throw new Error('sonic boom is not ready yet')
|
||||
}
|
||||
|
||||
if (!this._writing && this._writingBuf.length > 0) {
|
||||
this._bufs.unshift([this._writingBuf])
|
||||
this._writingBuf = kEmptyBuffer
|
||||
}
|
||||
|
||||
let buf = kEmptyBuffer
|
||||
while (this._bufs.length || buf.length) {
|
||||
if (buf.length <= 0) {
|
||||
buf = mergeBuf(this._bufs[0], this._lens[0])
|
||||
}
|
||||
try {
|
||||
const n = fs.writeSync(this.fd, buf)
|
||||
buf = buf.subarray(n)
|
||||
this._len = Math.max(this._len - n, 0)
|
||||
if (buf.length <= 0) {
|
||||
this._bufs.shift()
|
||||
this._lens.shift()
|
||||
}
|
||||
} catch (err) {
|
||||
const shouldRetry = err.code === 'EAGAIN' || err.code === 'EBUSY'
|
||||
if (shouldRetry && !this.retryEAGAIN(err, buf.length, this._len - buf.length)) {
|
||||
throw err
|
||||
}
|
||||
|
||||
sleep(BUSY_WRITE_TIMEOUT)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
SonicBoom.prototype.destroy = function () {
|
||||
if (this.destroyed) {
|
||||
return
|
||||
}
|
||||
actualClose(this)
|
||||
}
|
||||
|
||||
function actualWrite () {
|
||||
const release = this.release
|
||||
this._writing = true
|
||||
this._writingBuf = this._writingBuf.length ? this._writingBuf : this._bufs.shift() || ''
|
||||
|
||||
if (this.sync) {
|
||||
try {
|
||||
const written = Buffer.isBuffer(this._writingBuf)
|
||||
? fs.writeSync(this.fd, this._writingBuf)
|
||||
: fs.writeSync(this.fd, this._writingBuf, 'utf8')
|
||||
release(null, written)
|
||||
} catch (err) {
|
||||
release(err)
|
||||
}
|
||||
} else {
|
||||
fs.write(this.fd, this._writingBuf, release)
|
||||
}
|
||||
}
|
||||
|
||||
function actualWriteBuffer () {
|
||||
const release = this.release
|
||||
this._writing = true
|
||||
this._writingBuf = this._writingBuf.length ? this._writingBuf : mergeBuf(this._bufs.shift(), this._lens.shift())
|
||||
|
||||
if (this.sync) {
|
||||
try {
|
||||
const written = fs.writeSync(this.fd, this._writingBuf)
|
||||
release(null, written)
|
||||
} catch (err) {
|
||||
release(err)
|
||||
}
|
||||
} else {
|
||||
// fs.write will need to copy string to buffer anyway so
|
||||
// we do it here to avoid the overhead of calculating the buffer size
|
||||
// in releaseWritingBuf.
|
||||
if (kCopyBuffer) {
|
||||
this._writingBuf = Buffer.from(this._writingBuf)
|
||||
}
|
||||
fs.write(this.fd, this._writingBuf, release)
|
||||
}
|
||||
}
|
||||
|
||||
function actualClose (sonic) {
|
||||
if (sonic.fd === -1) {
|
||||
sonic.once('ready', actualClose.bind(null, sonic))
|
||||
return
|
||||
}
|
||||
|
||||
if (sonic._periodicFlushTimer !== undefined) {
|
||||
clearInterval(sonic._periodicFlushTimer)
|
||||
}
|
||||
|
||||
sonic.destroyed = true
|
||||
sonic._bufs = []
|
||||
sonic._lens = []
|
||||
|
||||
assert(typeof sonic.fd === 'number', `sonic.fd must be a number, got ${typeof sonic.fd}`)
|
||||
try {
|
||||
fs.fsync(sonic.fd, closeWrapped)
|
||||
} catch {
|
||||
}
|
||||
|
||||
function closeWrapped () {
|
||||
// We skip errors in fsync
|
||||
|
||||
if (sonic.fd !== 1 && sonic.fd !== 2) {
|
||||
fs.close(sonic.fd, done)
|
||||
} else {
|
||||
done()
|
||||
}
|
||||
}
|
||||
|
||||
function done (err) {
|
||||
if (err) {
|
||||
sonic.emit('error', err)
|
||||
return
|
||||
}
|
||||
|
||||
if (sonic._ending && !sonic._writing) {
|
||||
sonic.emit('finish')
|
||||
}
|
||||
sonic.emit('close')
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* These export configurations enable JS and TS developers
|
||||
* to consumer SonicBoom in whatever way best suits their needs.
|
||||
* Some examples of supported import syntax includes:
|
||||
* - `const SonicBoom = require('SonicBoom')`
|
||||
* - `const { SonicBoom } = require('SonicBoom')`
|
||||
* - `import * as SonicBoom from 'SonicBoom'`
|
||||
* - `import { SonicBoom } from 'SonicBoom'`
|
||||
* - `import SonicBoom from 'SonicBoom'`
|
||||
*/
|
||||
SonicBoom.SonicBoom = SonicBoom
|
||||
SonicBoom.default = SonicBoom
|
||||
module.exports = SonicBoom
|
||||
@@ -0,0 +1,61 @@
|
||||
"use strict";
|
||||
// THIS CODE WAS AUTOMATICALLY GENERATED
|
||||
// DO NOT EDIT THIS CODE BY HAND
|
||||
// SEE https://typescript-eslint.io/users/configs
|
||||
//
|
||||
// For developers working in the typescript-eslint monorepo:
|
||||
// You can regenerate it using `pnpm run generate-configs`
|
||||
var __importDefault = (this && this.__importDefault) || function (mod) {
|
||||
return (mod && mod.__esModule) ? mod : { "default": mod };
|
||||
};
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
const base_1 = __importDefault(require("./base"));
|
||||
const eslint_recommended_1 = __importDefault(require("./eslint-recommended"));
|
||||
/**
|
||||
* Contains all of `recommended`, as well as additional strict rules that can also catch bugs.
|
||||
* @see {@link https://typescript-eslint.io/users/configs#strict}
|
||||
*/
|
||||
exports.default = (plugin, parser) => [
|
||||
(0, base_1.default)(plugin, parser),
|
||||
(0, eslint_recommended_1.default)(plugin, parser),
|
||||
{
|
||||
name: 'typescript-eslint/strict',
|
||||
rules: {
|
||||
'@typescript-eslint/ban-ts-comment': [
|
||||
'error',
|
||||
{ minimumDescriptionLength: 10 },
|
||||
],
|
||||
'no-array-constructor': 'off',
|
||||
'@typescript-eslint/no-array-constructor': 'error',
|
||||
'@typescript-eslint/no-duplicate-enum-values': 'error',
|
||||
'@typescript-eslint/no-dynamic-delete': 'error',
|
||||
'@typescript-eslint/no-empty-object-type': 'error',
|
||||
'@typescript-eslint/no-explicit-any': 'error',
|
||||
'@typescript-eslint/no-extra-non-null-assertion': 'error',
|
||||
'@typescript-eslint/no-extraneous-class': 'error',
|
||||
'@typescript-eslint/no-invalid-void-type': 'error',
|
||||
'@typescript-eslint/no-misused-new': 'error',
|
||||
'@typescript-eslint/no-namespace': 'error',
|
||||
'@typescript-eslint/no-non-null-asserted-nullish-coalescing': 'error',
|
||||
'@typescript-eslint/no-non-null-asserted-optional-chain': 'error',
|
||||
'@typescript-eslint/no-non-null-assertion': 'error',
|
||||
'@typescript-eslint/no-require-imports': 'error',
|
||||
'@typescript-eslint/no-this-alias': 'error',
|
||||
'@typescript-eslint/no-unnecessary-type-constraint': 'error',
|
||||
'@typescript-eslint/no-unsafe-declaration-merging': 'error',
|
||||
'@typescript-eslint/no-unsafe-function-type': 'error',
|
||||
'no-unused-expressions': 'off',
|
||||
'@typescript-eslint/no-unused-expressions': 'error',
|
||||
'no-unused-vars': 'off',
|
||||
'@typescript-eslint/no-unused-vars': 'error',
|
||||
'no-useless-constructor': 'off',
|
||||
'@typescript-eslint/no-useless-constructor': 'error',
|
||||
'@typescript-eslint/no-wrapper-object-types': 'error',
|
||||
'@typescript-eslint/prefer-as-const': 'error',
|
||||
'@typescript-eslint/prefer-literal-enum-member': 'error',
|
||||
'@typescript-eslint/prefer-namespace-keyword': 'error',
|
||||
'@typescript-eslint/triple-slash-reference': 'error',
|
||||
'@typescript-eslint/unified-signatures': 'error',
|
||||
},
|
||||
},
|
||||
];
|
||||
@@ -0,0 +1,22 @@
|
||||
The MIT License (MIT)
|
||||
Copyright (c) 2020 David Mark Clements
|
||||
|
||||
|
||||
Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
of this software and associated documentation files (the "Software"), to deal
|
||||
in the Software without restriction, including without limitation the rights
|
||||
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
copies of the Software, and to permit persons to whom the Software is
|
||||
furnished to do so, subject to the following conditions:
|
||||
|
||||
The above copyright notice and this permission notice shall be included in all
|
||||
copies or substantial portions of the Software.
|
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
||||
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
||||
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
|
||||
IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
|
||||
DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
|
||||
OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE
|
||||
OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
|
||||
@@ -0,0 +1,76 @@
|
||||
/**
|
||||
* @fileoverview A rule to disallow calls to the Object constructor
|
||||
* @author Matt DuVall <http://www.mattduvall.com/>
|
||||
* @deprecated in ESLint v8.50.0
|
||||
*/
|
||||
|
||||
"use strict";
|
||||
|
||||
//------------------------------------------------------------------------------
|
||||
// Requirements
|
||||
//------------------------------------------------------------------------------
|
||||
|
||||
const astUtils = require("./utils/ast-utils");
|
||||
|
||||
//------------------------------------------------------------------------------
|
||||
// Rule Definition
|
||||
//------------------------------------------------------------------------------
|
||||
|
||||
/** @type {import('../types').Rule.RuleModule} */
|
||||
module.exports = {
|
||||
meta: {
|
||||
type: "suggestion",
|
||||
|
||||
docs: {
|
||||
description: "Disallow `Object` constructors",
|
||||
recommended: false,
|
||||
url: "https://eslint.org/docs/latest/rules/no-new-object",
|
||||
},
|
||||
|
||||
deprecated: {
|
||||
message:
|
||||
"The new rule flags more situations where object literal syntax can be used, and it does not report a problem when the `Object` constructor is invoked with an argument.",
|
||||
url: "https://eslint.org/blog/2023/09/eslint-v8.50.0-released/",
|
||||
deprecatedSince: "8.50.0",
|
||||
availableUntil: "11.0.0",
|
||||
replacedBy: [
|
||||
{
|
||||
rule: {
|
||||
name: "no-object-constructor",
|
||||
url: "https://eslint.org/docs/rules/no-object-constructor",
|
||||
},
|
||||
},
|
||||
],
|
||||
},
|
||||
|
||||
schema: [],
|
||||
|
||||
messages: {
|
||||
preferLiteral: "The object literal notation {} is preferable.",
|
||||
},
|
||||
},
|
||||
|
||||
create(context) {
|
||||
const sourceCode = context.sourceCode;
|
||||
|
||||
return {
|
||||
NewExpression(node) {
|
||||
const variable = astUtils.getVariableByName(
|
||||
sourceCode.getScope(node),
|
||||
node.callee.name,
|
||||
);
|
||||
|
||||
if (variable && variable.identifiers.length > 0) {
|
||||
return;
|
||||
}
|
||||
|
||||
if (node.callee.name === "Object") {
|
||||
context.report({
|
||||
node,
|
||||
messageId: "preferLiteral",
|
||||
});
|
||||
}
|
||||
},
|
||||
};
|
||||
},
|
||||
};
|
||||
File diff suppressed because one or more lines are too long
@@ -0,0 +1,30 @@
|
||||
export const PROTOCOL_VERSION = 5;
|
||||
export const HEADER_OFFSET_METADATA = 0;
|
||||
export const HEADER_OFFSET_HASH_LO0 = 4;
|
||||
export const HEADER_OFFSET_HASH_LO1 = 8;
|
||||
export const HEADER_OFFSET_HASH_HI0 = 12;
|
||||
export const HEADER_OFFSET_HASH_HI1 = 16;
|
||||
export const HEADER_OFFSET_PARSE_OPTIONS = 20;
|
||||
export const HEADER_OFFSET_STRING_TABLE_OFFSETS = 24;
|
||||
export const HEADER_OFFSET_STRING_TABLE = 28;
|
||||
export const HEADER_OFFSET_EXTENDED_DATA = 32;
|
||||
export const HEADER_OFFSET_STRUCTURED_DATA = 36;
|
||||
export const HEADER_OFFSET_NODES = 40;
|
||||
export const HEADER_SIZE = 44;
|
||||
export const NODE_LEN = 28;
|
||||
export const NODE_OFFSET_KIND = 0;
|
||||
export const NODE_OFFSET_POS = 4;
|
||||
export const NODE_OFFSET_END = 8;
|
||||
export const NODE_OFFSET_NEXT = 12;
|
||||
export const NODE_OFFSET_PARENT = 16;
|
||||
export const NODE_OFFSET_DATA = 20;
|
||||
export const NODE_OFFSET_FLAGS = 24;
|
||||
export const KIND_NODE_LIST = 0xFFFFFFFF;
|
||||
export const NODE_DATA_TYPE_CHILDREN = 0x00000000;
|
||||
export const NODE_DATA_TYPE_STRING = 0x40000000;
|
||||
export const NODE_DATA_TYPE_EXTENDED = 0x80000000;
|
||||
export const NODE_STRING_INDEX_MASK = 0x00FFFFFF;
|
||||
export const NODE_EXTENDED_DATA_MASK = 0x00FFFFFF;
|
||||
// Re-export generated child properties
|
||||
export { childProperties, singleChildNodePropertyNames } from "./protocol.generated.js";
|
||||
//# sourceMappingURL=protocol.js.map
|
||||
@@ -0,0 +1,184 @@
|
||||
"use strict";
|
||||
var __createBinding = (this && this.__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];
|
||||
}));
|
||||
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
|
||||
Object.defineProperty(o, "default", { enumerable: true, value: v });
|
||||
}) : function(o, v) {
|
||||
o["default"] = v;
|
||||
});
|
||||
var __importStar = (this && this.__importStar) || (function () {
|
||||
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);
|
||||
};
|
||||
return 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;
|
||||
};
|
||||
})();
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
const tsutils = __importStar(require("ts-api-utils"));
|
||||
const ts = __importStar(require("typescript"));
|
||||
const util_1 = require("../util");
|
||||
const getParentFunctionNode_1 = require("../util/getParentFunctionNode");
|
||||
exports.default = (0, util_1.createRule)({
|
||||
name: 'no-unsafe-return',
|
||||
meta: {
|
||||
type: 'problem',
|
||||
docs: {
|
||||
description: 'Disallow returning a value with type `any` from a function',
|
||||
recommended: 'recommended',
|
||||
requiresTypeChecking: true,
|
||||
},
|
||||
messages: {
|
||||
unsafeReturn: 'Unsafe return of a value of type {{type}}.',
|
||||
unsafeReturnAssignment: 'Unsafe return of type `{{sender}}` from function with return type `{{receiver}}`.',
|
||||
unsafeReturnThis: [
|
||||
'Unsafe return of a value of type `{{type}}`. `this` is typed as `any`.',
|
||||
'You can try to fix this by turning on the `noImplicitThis` compiler option, or adding a `this` parameter to the function.',
|
||||
].join('\n'),
|
||||
},
|
||||
schema: [],
|
||||
},
|
||||
defaultOptions: [],
|
||||
create(context) {
|
||||
const services = (0, util_1.getParserServices)(context);
|
||||
const checker = services.program.getTypeChecker();
|
||||
const compilerOptions = services.program.getCompilerOptions();
|
||||
const isNoImplicitThis = tsutils.isStrictCompilerOptionEnabled(compilerOptions, 'noImplicitThis');
|
||||
function checkReturn(returnNode, reportingNode = returnNode) {
|
||||
const functionNode = (0, getParentFunctionNode_1.getParentFunctionNode)(returnNode);
|
||||
/* istanbul ignore if */ if (!functionNode) {
|
||||
return;
|
||||
}
|
||||
const tsNode = services.esTreeNodeToTSNodeMap.get(returnNode);
|
||||
const type = checker.getTypeAtLocation(tsNode);
|
||||
const anyType = (0, util_1.discriminateAnyType)(type, checker, services.program, tsNode);
|
||||
// function has an explicit return type, so ensure it's a safe return
|
||||
const returnNodeType = services.getTypeAtLocation(returnNode);
|
||||
const constrainedReturnNodeType = (0, util_1.getConstrainedTypeAtLocation)(services, returnNode);
|
||||
const functionTSNode = services.esTreeNodeToTSNodeMap.get(functionNode);
|
||||
// function expressions will not have their return type modified based on receiver typing
|
||||
// so we have to use the contextual typing in these cases, i.e.
|
||||
// const foo1: () => Set<string> = () => new Set<any>();
|
||||
// the return type of the arrow function is Set<any> even though the variable is typed as Set<string>
|
||||
let functionType = ts.isFunctionExpression(functionTSNode) ||
|
||||
ts.isArrowFunction(functionTSNode)
|
||||
? (0, util_1.getContextualType)(checker, functionTSNode)
|
||||
: services.getTypeAtLocation(functionNode);
|
||||
functionType ??= services.getTypeAtLocation(functionNode);
|
||||
const callSignatures = tsutils.getCallSignaturesOfType(functionType);
|
||||
// If there is an explicit type annotation *and* that type matches the actual
|
||||
// function return type, we shouldn't complain (it's intentional, even if unsafe)
|
||||
if (functionTSNode.type) {
|
||||
for (const signature of callSignatures) {
|
||||
const signatureReturnType = signature.getReturnType();
|
||||
if (returnNodeType === signatureReturnType ||
|
||||
(0, util_1.isTypeFlagSet)(signatureReturnType, ts.TypeFlags.Any | ts.TypeFlags.Unknown)) {
|
||||
return;
|
||||
}
|
||||
if (functionNode.async) {
|
||||
const awaitedSignatureReturnType = checker.getAwaitedType(signatureReturnType);
|
||||
const awaitedReturnNodeType = checker.getAwaitedType(returnNodeType);
|
||||
if (awaitedReturnNodeType === awaitedSignatureReturnType ||
|
||||
(awaitedSignatureReturnType &&
|
||||
(0, util_1.isTypeFlagSet)(awaitedSignatureReturnType, ts.TypeFlags.Any | ts.TypeFlags.Unknown))) {
|
||||
return;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
if (anyType !== util_1.AnyType.Safe) {
|
||||
// Allow cases when the declared return type of the function is either unknown or unknown[]
|
||||
// and the function is returning any or any[].
|
||||
for (const signature of callSignatures) {
|
||||
const functionReturnType = signature.getReturnType();
|
||||
if (anyType === util_1.AnyType.Any &&
|
||||
(0, util_1.isTypeUnknownType)(functionReturnType)) {
|
||||
return;
|
||||
}
|
||||
if (anyType === util_1.AnyType.AnyArray &&
|
||||
(0, util_1.isTypeUnknownArrayType)(functionReturnType, checker)) {
|
||||
return;
|
||||
}
|
||||
const awaitedType = checker.getAwaitedType(functionReturnType);
|
||||
if (awaitedType &&
|
||||
anyType === util_1.AnyType.PromiseAny &&
|
||||
(0, util_1.isTypeUnknownType)(awaitedType)) {
|
||||
return;
|
||||
}
|
||||
}
|
||||
if (anyType === util_1.AnyType.PromiseAny && !functionNode.async) {
|
||||
return;
|
||||
}
|
||||
let messageId = 'unsafeReturn';
|
||||
const isErrorType = tsutils.isIntrinsicErrorType(constrainedReturnNodeType);
|
||||
if (!isNoImplicitThis) {
|
||||
// `return this`
|
||||
const thisExpression = (0, util_1.getThisExpression)(returnNode);
|
||||
if (thisExpression &&
|
||||
(0, util_1.isTypeAnyType)((0, util_1.getConstrainedTypeAtLocation)(services, thisExpression))) {
|
||||
messageId = 'unsafeReturnThis';
|
||||
}
|
||||
}
|
||||
// If the function return type was not unknown/unknown[], mark usage as unsafeReturn.
|
||||
return context.report({
|
||||
node: reportingNode,
|
||||
messageId,
|
||||
data: {
|
||||
type: isErrorType
|
||||
? 'error'
|
||||
: anyType === util_1.AnyType.Any
|
||||
? '`any`'
|
||||
: anyType === util_1.AnyType.PromiseAny
|
||||
? '`Promise<any>`'
|
||||
: '`any[]`',
|
||||
},
|
||||
});
|
||||
}
|
||||
const signature = functionType.getCallSignatures().at(0);
|
||||
if (signature) {
|
||||
const functionReturnType = signature.getReturnType();
|
||||
const result = (0, util_1.isUnsafeAssignment)(returnNodeType, functionReturnType, checker, returnNode);
|
||||
if (!result) {
|
||||
return;
|
||||
}
|
||||
const { receiver, sender } = result;
|
||||
return context.report({
|
||||
node: reportingNode,
|
||||
messageId: 'unsafeReturnAssignment',
|
||||
data: {
|
||||
receiver: checker.typeToString(receiver),
|
||||
sender: checker.typeToString(sender),
|
||||
},
|
||||
});
|
||||
}
|
||||
}
|
||||
return {
|
||||
'ArrowFunctionExpression > :not(BlockStatement).body': checkReturn,
|
||||
ReturnStatement(node) {
|
||||
const argument = node.argument;
|
||||
if (!argument) {
|
||||
return;
|
||||
}
|
||||
checkReturn(argument, node);
|
||||
},
|
||||
};
|
||||
},
|
||||
});
|
||||
@@ -0,0 +1,2 @@
|
||||
#!/bin/bash
|
||||
time node --allow-natives-syntax --trace_opt --trace_deopt --code_comments --print_code bench.js | less
|
||||
@@ -0,0 +1,203 @@
|
||||
'use strict'
|
||||
|
||||
const metadata = Symbol.for('pino.metadata')
|
||||
const { DEFAULT_LEVELS } = require('./constants')
|
||||
|
||||
const DEFAULT_INFO_LEVEL = DEFAULT_LEVELS.info
|
||||
|
||||
function multistream (streamsArray, opts) {
|
||||
streamsArray = streamsArray || []
|
||||
opts = opts || { dedupe: false }
|
||||
|
||||
const streamLevels = Object.create(DEFAULT_LEVELS)
|
||||
streamLevels.silent = Infinity
|
||||
if (opts.levels && typeof opts.levels === 'object') {
|
||||
Object.keys(opts.levels).forEach(i => {
|
||||
streamLevels[i] = opts.levels[i]
|
||||
})
|
||||
}
|
||||
|
||||
const res = {
|
||||
write,
|
||||
add,
|
||||
remove,
|
||||
emit,
|
||||
flushSync,
|
||||
end,
|
||||
minLevel: 0,
|
||||
lastId: 0,
|
||||
streams: [],
|
||||
clone,
|
||||
[metadata]: true,
|
||||
streamLevels
|
||||
}
|
||||
|
||||
if (Array.isArray(streamsArray)) {
|
||||
streamsArray.forEach(add, res)
|
||||
} else {
|
||||
add.call(res, streamsArray)
|
||||
}
|
||||
|
||||
// clean this object up
|
||||
// or it will stay allocated forever
|
||||
// as it is closed on the following closures
|
||||
streamsArray = null
|
||||
|
||||
return res
|
||||
|
||||
// we can exit early because the streams are ordered by level
|
||||
function write (data) {
|
||||
let dest
|
||||
const level = this.lastLevel
|
||||
const { streams } = this
|
||||
// for handling situation when several streams has the same level
|
||||
let recordedLevel = 0
|
||||
let stream
|
||||
|
||||
// if dedupe set to true we send logs to the stream with the highest level
|
||||
// therefore, we have to change sorting order
|
||||
for (let i = initLoopVar(streams.length, opts.dedupe); checkLoopVar(i, streams.length, opts.dedupe); i = adjustLoopVar(i, opts.dedupe)) {
|
||||
dest = streams[i]
|
||||
if (dest.level <= level) {
|
||||
if (recordedLevel !== 0 && recordedLevel !== dest.level) {
|
||||
break
|
||||
}
|
||||
stream = dest.stream
|
||||
if (stream[metadata]) {
|
||||
const { lastTime, lastMsg, lastObj, lastLogger } = this
|
||||
stream.lastLevel = level
|
||||
stream.lastTime = lastTime
|
||||
stream.lastMsg = lastMsg
|
||||
stream.lastObj = lastObj
|
||||
stream.lastLogger = lastLogger
|
||||
}
|
||||
stream.write(data)
|
||||
if (opts.dedupe) {
|
||||
recordedLevel = dest.level
|
||||
}
|
||||
} else if (!opts.dedupe) {
|
||||
break
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
function emit (...args) {
|
||||
for (const { stream } of this.streams) {
|
||||
if (typeof stream.emit === 'function') {
|
||||
stream.emit(...args)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
function flushSync () {
|
||||
for (const { stream } of this.streams) {
|
||||
if (typeof stream.flushSync === 'function') {
|
||||
stream.flushSync()
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
function add (dest) {
|
||||
if (!dest) {
|
||||
return res
|
||||
}
|
||||
|
||||
// Check that dest implements either StreamEntry or DestinationStream
|
||||
const isStream = typeof dest.write === 'function' || dest.stream
|
||||
const stream_ = dest.write ? dest : dest.stream
|
||||
// This is necessary to provide a meaningful error message, otherwise it throws somewhere inside write()
|
||||
if (!isStream) {
|
||||
throw Error('stream object needs to implement either StreamEntry or DestinationStream interface')
|
||||
}
|
||||
|
||||
const { streams, streamLevels } = this
|
||||
|
||||
let level
|
||||
if (typeof dest.levelVal === 'number') {
|
||||
level = dest.levelVal
|
||||
} else if (typeof dest.level === 'string') {
|
||||
level = streamLevels[dest.level]
|
||||
} else if (typeof dest.level === 'number') {
|
||||
level = dest.level
|
||||
} else {
|
||||
level = DEFAULT_INFO_LEVEL
|
||||
}
|
||||
|
||||
const dest_ = {
|
||||
stream: stream_,
|
||||
level,
|
||||
levelVal: undefined,
|
||||
id: ++res.lastId
|
||||
}
|
||||
|
||||
streams.unshift(dest_)
|
||||
streams.sort(compareByLevel)
|
||||
|
||||
this.minLevel = streams[0].level
|
||||
|
||||
return res
|
||||
}
|
||||
|
||||
function remove (id) {
|
||||
const { streams } = this
|
||||
const index = streams.findIndex(s => s.id === id)
|
||||
|
||||
if (index >= 0) {
|
||||
streams.splice(index, 1)
|
||||
streams.sort(compareByLevel)
|
||||
this.minLevel = streams.length > 0 ? streams[0].level : -1
|
||||
}
|
||||
|
||||
return res
|
||||
}
|
||||
|
||||
function end () {
|
||||
for (const { stream } of this.streams) {
|
||||
if (typeof stream.flushSync === 'function') {
|
||||
stream.flushSync()
|
||||
}
|
||||
stream.end()
|
||||
}
|
||||
}
|
||||
|
||||
function clone (level) {
|
||||
const streams = new Array(this.streams.length)
|
||||
|
||||
for (let i = 0; i < streams.length; i++) {
|
||||
streams[i] = {
|
||||
level,
|
||||
stream: this.streams[i].stream
|
||||
}
|
||||
}
|
||||
|
||||
return {
|
||||
write,
|
||||
add,
|
||||
remove,
|
||||
minLevel: level,
|
||||
streams,
|
||||
clone,
|
||||
emit,
|
||||
flushSync,
|
||||
[metadata]: true
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
function compareByLevel (a, b) {
|
||||
return a.level - b.level
|
||||
}
|
||||
|
||||
function initLoopVar (length, dedupe) {
|
||||
return dedupe ? length - 1 : 0
|
||||
}
|
||||
|
||||
function adjustLoopVar (i, dedupe) {
|
||||
return dedupe ? i - 1 : i + 1
|
||||
}
|
||||
|
||||
function checkLoopVar (i, length, dedupe) {
|
||||
return dedupe ? i >= 0 : i < length
|
||||
}
|
||||
|
||||
module.exports = multistream
|
||||
@@ -0,0 +1,60 @@
|
||||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
const utils_1 = require("@typescript-eslint/utils");
|
||||
const util_1 = require("../util");
|
||||
const classNames = new Set([
|
||||
'BigInt',
|
||||
// eslint-disable-next-line @typescript-eslint/internal/prefer-ast-types-enum
|
||||
'Boolean',
|
||||
'Number',
|
||||
'Object',
|
||||
// eslint-disable-next-line @typescript-eslint/internal/prefer-ast-types-enum
|
||||
'String',
|
||||
'Symbol',
|
||||
]);
|
||||
exports.default = (0, util_1.createRule)({
|
||||
name: 'no-wrapper-object-types',
|
||||
meta: {
|
||||
type: 'problem',
|
||||
docs: {
|
||||
description: 'Disallow using confusing built-in primitive class wrappers',
|
||||
recommended: 'recommended',
|
||||
},
|
||||
fixable: 'code',
|
||||
messages: {
|
||||
bannedClassType: 'Prefer using the primitive `{{preferred}}` as a type name, rather than the upper-cased `{{typeName}}`.',
|
||||
},
|
||||
schema: [],
|
||||
},
|
||||
defaultOptions: [],
|
||||
create(context) {
|
||||
function checkBannedTypes(node, includeFix) {
|
||||
const typeName = node.type === utils_1.AST_NODE_TYPES.Identifier && node.name;
|
||||
if (!typeName ||
|
||||
!classNames.has(typeName) ||
|
||||
!(0, util_1.isReferenceToGlobalFunction)(typeName, node, context.sourceCode)) {
|
||||
return;
|
||||
}
|
||||
const preferred = typeName.toLowerCase();
|
||||
context.report({
|
||||
node,
|
||||
messageId: 'bannedClassType',
|
||||
data: { preferred, typeName },
|
||||
fix: includeFix
|
||||
? (fixer) => fixer.replaceText(node, preferred)
|
||||
: undefined,
|
||||
});
|
||||
}
|
||||
return {
|
||||
TSClassImplements(node) {
|
||||
checkBannedTypes(node.expression, false);
|
||||
},
|
||||
TSInterfaceHeritage(node) {
|
||||
checkBannedTypes(node.expression, false);
|
||||
},
|
||||
TSTypeReference(node) {
|
||||
checkBannedTypes(node.typeName, true);
|
||||
},
|
||||
};
|
||||
},
|
||||
});
|
||||
@@ -0,0 +1,85 @@
|
||||
/*! ieee754. BSD-3-Clause License. Feross Aboukhadijeh <https://feross.org/opensource> */
|
||||
exports.read = function (buffer, offset, isLE, mLen, nBytes) {
|
||||
var e, m
|
||||
var eLen = (nBytes * 8) - mLen - 1
|
||||
var eMax = (1 << eLen) - 1
|
||||
var eBias = eMax >> 1
|
||||
var nBits = -7
|
||||
var i = isLE ? (nBytes - 1) : 0
|
||||
var d = isLE ? -1 : 1
|
||||
var s = buffer[offset + i]
|
||||
|
||||
i += d
|
||||
|
||||
e = s & ((1 << (-nBits)) - 1)
|
||||
s >>= (-nBits)
|
||||
nBits += eLen
|
||||
for (; nBits > 0; e = (e * 256) + buffer[offset + i], i += d, nBits -= 8) {}
|
||||
|
||||
m = e & ((1 << (-nBits)) - 1)
|
||||
e >>= (-nBits)
|
||||
nBits += mLen
|
||||
for (; nBits > 0; m = (m * 256) + buffer[offset + i], i += d, nBits -= 8) {}
|
||||
|
||||
if (e === 0) {
|
||||
e = 1 - eBias
|
||||
} else if (e === eMax) {
|
||||
return m ? NaN : ((s ? -1 : 1) * Infinity)
|
||||
} else {
|
||||
m = m + Math.pow(2, mLen)
|
||||
e = e - eBias
|
||||
}
|
||||
return (s ? -1 : 1) * m * Math.pow(2, e - mLen)
|
||||
}
|
||||
|
||||
exports.write = function (buffer, value, offset, isLE, mLen, nBytes) {
|
||||
var e, m, c
|
||||
var eLen = (nBytes * 8) - mLen - 1
|
||||
var eMax = (1 << eLen) - 1
|
||||
var eBias = eMax >> 1
|
||||
var rt = (mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0)
|
||||
var i = isLE ? 0 : (nBytes - 1)
|
||||
var d = isLE ? 1 : -1
|
||||
var s = value < 0 || (value === 0 && 1 / value < 0) ? 1 : 0
|
||||
|
||||
value = Math.abs(value)
|
||||
|
||||
if (isNaN(value) || value === Infinity) {
|
||||
m = isNaN(value) ? 1 : 0
|
||||
e = eMax
|
||||
} else {
|
||||
e = Math.floor(Math.log(value) / Math.LN2)
|
||||
if (value * (c = Math.pow(2, -e)) < 1) {
|
||||
e--
|
||||
c *= 2
|
||||
}
|
||||
if (e + eBias >= 1) {
|
||||
value += rt / c
|
||||
} else {
|
||||
value += rt * Math.pow(2, 1 - eBias)
|
||||
}
|
||||
if (value * c >= 2) {
|
||||
e++
|
||||
c /= 2
|
||||
}
|
||||
|
||||
if (e + eBias >= eMax) {
|
||||
m = 0
|
||||
e = eMax
|
||||
} else if (e + eBias >= 1) {
|
||||
m = ((value * c) - 1) * Math.pow(2, mLen)
|
||||
e = e + eBias
|
||||
} else {
|
||||
m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen)
|
||||
e = 0
|
||||
}
|
||||
}
|
||||
|
||||
for (; mLen >= 8; buffer[offset + i] = m & 0xff, i += d, m /= 256, mLen -= 8) {}
|
||||
|
||||
e = (e << mLen) | m
|
||||
eLen += mLen
|
||||
for (; eLen > 0; buffer[offset + i] = e & 0xff, i += d, e /= 256, eLen -= 8) {}
|
||||
|
||||
buffer[offset + i - d] |= s * 128
|
||||
}
|
||||
@@ -0,0 +1,7 @@
|
||||
# @vitest/runner
|
||||
|
||||
[](https://npmx.dev/package/@vitest/runner)
|
||||
|
||||
Vitest mechanism to collect and run tests.
|
||||
|
||||
[GitHub](https://github.com/vitest-dev/vitest/tree/main/packages/runner) | [Documentation](https://vitest.dev/api/advanced/runner)
|
||||
@@ -0,0 +1,23 @@
|
||||
"use strict";
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Copyright (c) Microsoft Corporation. All rights reserved.
|
||||
* Licensed under the MIT License. See License.txt in the project root for license information.
|
||||
* ------------------------------------------------------------------------------------------ */
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
let _ral;
|
||||
function RAL() {
|
||||
if (_ral === undefined) {
|
||||
throw new Error(`No runtime abstraction layer installed`);
|
||||
}
|
||||
return _ral;
|
||||
}
|
||||
(function (RAL) {
|
||||
function install(ral) {
|
||||
if (ral === undefined) {
|
||||
throw new Error(`No runtime abstraction layer provided`);
|
||||
}
|
||||
_ral = ral;
|
||||
}
|
||||
RAL.install = install;
|
||||
})(RAL || (RAL = {}));
|
||||
exports.default = RAL;
|
||||
@@ -0,0 +1,26 @@
|
||||
function asyncGeneratorStep(n, t, e, r, o, a, c) {
|
||||
try {
|
||||
var i = n[a](c),
|
||||
u = i.value;
|
||||
} catch (n) {
|
||||
return void e(n);
|
||||
}
|
||||
i.done ? t(u) : Promise.resolve(u).then(r, o);
|
||||
}
|
||||
function _asyncToGenerator(n) {
|
||||
return function () {
|
||||
var t = this,
|
||||
e = arguments;
|
||||
return new Promise(function (r, o) {
|
||||
var a = n.apply(t, e);
|
||||
function _next(n) {
|
||||
asyncGeneratorStep(a, r, o, _next, _throw, "next", n);
|
||||
}
|
||||
function _throw(n) {
|
||||
asyncGeneratorStep(a, r, o, _next, _throw, "throw", n);
|
||||
}
|
||||
_next(void 0);
|
||||
});
|
||||
};
|
||||
}
|
||||
export { _asyncToGenerator as default };
|
||||
@@ -0,0 +1,80 @@
|
||||
import Benchmark from "benchmark";
|
||||
|
||||
import { z } from "zod/v3";
|
||||
|
||||
const doubleSuite = new Benchmark.Suite("z.discriminatedUnion: double");
|
||||
const manySuite = new Benchmark.Suite("z.discriminatedUnion: many");
|
||||
|
||||
const aSchema = z.object({
|
||||
type: z.literal("a"),
|
||||
});
|
||||
const objA = {
|
||||
type: "a",
|
||||
};
|
||||
|
||||
const bSchema = z.object({
|
||||
type: z.literal("b"),
|
||||
});
|
||||
const objB = {
|
||||
type: "b",
|
||||
};
|
||||
|
||||
const cSchema = z.object({
|
||||
type: z.literal("c"),
|
||||
});
|
||||
const objC = {
|
||||
type: "c",
|
||||
};
|
||||
|
||||
const dSchema = z.object({
|
||||
type: z.literal("d"),
|
||||
});
|
||||
|
||||
const double = z.discriminatedUnion("type", [aSchema, bSchema]);
|
||||
const many = z.discriminatedUnion("type", [aSchema, bSchema, cSchema, dSchema]);
|
||||
|
||||
doubleSuite
|
||||
.add("valid: a", () => {
|
||||
double.parse(objA);
|
||||
})
|
||||
.add("valid: b", () => {
|
||||
double.parse(objB);
|
||||
})
|
||||
.add("invalid: null", () => {
|
||||
try {
|
||||
double.parse(null);
|
||||
} catch (_err) {}
|
||||
})
|
||||
.add("invalid: wrong shape", () => {
|
||||
try {
|
||||
double.parse(objC);
|
||||
} catch (_err) {}
|
||||
})
|
||||
.on("cycle", (e: Benchmark.Event) => {
|
||||
console.log(`${(doubleSuite as any).name}: ${e.target}`);
|
||||
});
|
||||
|
||||
manySuite
|
||||
.add("valid: a", () => {
|
||||
many.parse(objA);
|
||||
})
|
||||
.add("valid: c", () => {
|
||||
many.parse(objC);
|
||||
})
|
||||
.add("invalid: null", () => {
|
||||
try {
|
||||
many.parse(null);
|
||||
} catch (_err) {}
|
||||
})
|
||||
.add("invalid: wrong shape", () => {
|
||||
try {
|
||||
many.parse({ type: "unknown" });
|
||||
} catch (_err) {}
|
||||
})
|
||||
.on("cycle", (e: Benchmark.Event) => {
|
||||
console.log(`${(manySuite as any).name}: ${e.target}`);
|
||||
});
|
||||
|
||||
export default {
|
||||
suites: [doubleSuite, manySuite],
|
||||
};
|
||||
@@ -0,0 +1,12 @@
|
||||
# `@typescript-eslint/project-service`
|
||||
|
||||
> Standalone TypeScript project service wrapper for linting.
|
||||
|
||||
[](https://www.npmjs.com/package/@typescript-eslint/project-service)
|
||||
[](https://www.npmjs.com/package/@typescript-eslint/project-service)
|
||||
|
||||
A standalone export of the "Project Service" that powers typed linting for typescript-eslint.
|
||||
|
||||
> See https://typescript-eslint.io for general documentation on typescript-eslint, the tooling that allows you to run ESLint and Prettier on TypeScript code.
|
||||
|
||||
<!-- Local path for docs: docs/packages/Project_Service.mdx -->
|
||||
@@ -0,0 +1,432 @@
|
||||
declare module "node:cluster" {
|
||||
import * as child_process from "node:child_process";
|
||||
import { EventEmitter, InternalEventEmitter } from "node:events";
|
||||
class Worker implements EventEmitter {
|
||||
constructor(options?: cluster.WorkerOptions);
|
||||
/**
|
||||
* Each new worker is given its own unique id, this id is stored in the `id`.
|
||||
*
|
||||
* While a worker is alive, this is the key that indexes it in `cluster.workers`.
|
||||
* @since v0.8.0
|
||||
*/
|
||||
id: number;
|
||||
/**
|
||||
* All workers are created using [`child_process.fork()`](https://nodejs.org/docs/latest-v26.x/api/child_process.html#child_processforkmodulepath-args-options), the returned object
|
||||
* from this function is stored as `.process`. In a worker, the global `process` is stored.
|
||||
*
|
||||
* See: [Child Process module](https://nodejs.org/docs/latest-v26.x/api/child_process.html#child_processforkmodulepath-args-options).
|
||||
*
|
||||
* Workers will call `process.exit(0)` if the `'disconnect'` event occurs
|
||||
* on `process` and `.exitedAfterDisconnect` is not `true`. This protects against
|
||||
* accidental disconnection.
|
||||
* @since v0.7.0
|
||||
*/
|
||||
process: child_process.ChildProcess;
|
||||
/**
|
||||
* Send a message to a worker or primary, optionally with a handle.
|
||||
*
|
||||
* In the primary, this sends a message to a specific worker. It is identical to [`ChildProcess.send()`](https://nodejs.org/docs/latest-v26.x/api/child_process.html#subprocesssendmessage-sendhandle-options-callback).
|
||||
*
|
||||
* In a worker, this sends a message to the primary. It is identical to `process.send()`.
|
||||
*
|
||||
* This example will echo back all messages from the primary:
|
||||
*
|
||||
* ```js
|
||||
* if (cluster.isPrimary) {
|
||||
* const worker = cluster.fork();
|
||||
* worker.send('hi there');
|
||||
*
|
||||
* } else if (cluster.isWorker) {
|
||||
* process.on('message', (msg) => {
|
||||
* process.send(msg);
|
||||
* });
|
||||
* }
|
||||
* ```
|
||||
* @since v0.7.0
|
||||
* @param options The `options` argument, if present, is an object used to parameterize the sending of certain types of handles.
|
||||
*/
|
||||
send(message: child_process.Serializable, callback?: (error: Error | null) => void): boolean;
|
||||
send(
|
||||
message: child_process.Serializable,
|
||||
sendHandle: child_process.SendHandle,
|
||||
callback?: (error: Error | null) => void,
|
||||
): boolean;
|
||||
send(
|
||||
message: child_process.Serializable,
|
||||
sendHandle: child_process.SendHandle,
|
||||
options?: child_process.MessageOptions,
|
||||
callback?: (error: Error | null) => void,
|
||||
): boolean;
|
||||
/**
|
||||
* This function will kill the worker. In the primary worker, it does this by
|
||||
* disconnecting the `worker.process`, and once disconnected, killing with `signal`. In the worker, it does it by killing the process with `signal`.
|
||||
*
|
||||
* The `kill()` function kills the worker process without waiting for a graceful
|
||||
* disconnect, it has the same behavior as `worker.process.kill()`.
|
||||
*
|
||||
* This method is aliased as `worker.destroy()` for backwards compatibility.
|
||||
*
|
||||
* In a worker, `process.kill()` exists, but it is not this function;
|
||||
* it is [`kill()`](https://nodejs.org/docs/latest-v26.x/api/process.html#processkillpid-signal).
|
||||
* @since v0.9.12
|
||||
* @param [signal='SIGTERM'] Name of the kill signal to send to the worker process.
|
||||
*/
|
||||
kill(signal?: string): void;
|
||||
destroy(signal?: string): void;
|
||||
/**
|
||||
* In a worker, this function will close all servers, wait for the `'close'` event
|
||||
* on those servers, and then disconnect the IPC channel.
|
||||
*
|
||||
* In the primary, an internal message is sent to the worker causing it to call `.disconnect()` on itself.
|
||||
*
|
||||
* Causes `.exitedAfterDisconnect` to be set.
|
||||
*
|
||||
* After a server is closed, it will no longer accept new connections,
|
||||
* but connections may be accepted by any other listening worker. Existing
|
||||
* connections will be allowed to close as usual. When no more connections exist,
|
||||
* see `server.close()`, the IPC channel to the worker will close allowing it
|
||||
* to die gracefully.
|
||||
*
|
||||
* The above applies _only_ to server connections, client connections are not
|
||||
* automatically closed by workers, and disconnect does not wait for them to close
|
||||
* before exiting.
|
||||
*
|
||||
* In a worker, `process.disconnect` exists, but it is not this function;
|
||||
* it is `disconnect()`.
|
||||
*
|
||||
* Because long living server connections may block workers from disconnecting, it
|
||||
* may be useful to send a message, so application specific actions may be taken to
|
||||
* close them. It also may be useful to implement a timeout, killing a worker if
|
||||
* the `'disconnect'` event has not been emitted after some time.
|
||||
*
|
||||
* ```js
|
||||
* import net from 'node:net';
|
||||
*
|
||||
* if (cluster.isPrimary) {
|
||||
* const worker = cluster.fork();
|
||||
* let timeout;
|
||||
*
|
||||
* worker.on('listening', (address) => {
|
||||
* worker.send('shutdown');
|
||||
* worker.disconnect();
|
||||
* timeout = setTimeout(() => {
|
||||
* worker.kill();
|
||||
* }, 2000);
|
||||
* });
|
||||
*
|
||||
* worker.on('disconnect', () => {
|
||||
* clearTimeout(timeout);
|
||||
* });
|
||||
*
|
||||
* } else if (cluster.isWorker) {
|
||||
* const server = net.createServer((socket) => {
|
||||
* // Connections never end
|
||||
* });
|
||||
*
|
||||
* server.listen(8000);
|
||||
*
|
||||
* process.on('message', (msg) => {
|
||||
* if (msg === 'shutdown') {
|
||||
* // Initiate graceful close of any connections to server
|
||||
* }
|
||||
* });
|
||||
* }
|
||||
* ```
|
||||
* @since v0.7.7
|
||||
* @return A reference to `worker`.
|
||||
*/
|
||||
disconnect(): this;
|
||||
/**
|
||||
* This function returns `true` if the worker is connected to its primary via its
|
||||
* IPC channel, `false` otherwise. A worker is connected to its primary after it
|
||||
* has been created. It is disconnected after the `'disconnect'` event is emitted.
|
||||
* @since v0.11.14
|
||||
*/
|
||||
isConnected(): boolean;
|
||||
/**
|
||||
* This function returns `true` if the worker's process has terminated (either
|
||||
* because of exiting or being signaled). Otherwise, it returns `false`.
|
||||
*
|
||||
* ```js
|
||||
* import cluster from 'node:cluster';
|
||||
* import http from 'node:http';
|
||||
* import { availableParallelism } from 'node:os';
|
||||
* import process from 'node:process';
|
||||
*
|
||||
* const numCPUs = availableParallelism();
|
||||
*
|
||||
* if (cluster.isPrimary) {
|
||||
* console.log(`Primary ${process.pid} is running`);
|
||||
*
|
||||
* // Fork workers.
|
||||
* for (let i = 0; i < numCPUs; i++) {
|
||||
* cluster.fork();
|
||||
* }
|
||||
*
|
||||
* cluster.on('fork', (worker) => {
|
||||
* console.log('worker is dead:', worker.isDead());
|
||||
* });
|
||||
*
|
||||
* cluster.on('exit', (worker, code, signal) => {
|
||||
* console.log('worker is dead:', worker.isDead());
|
||||
* });
|
||||
* } else {
|
||||
* // Workers can share any TCP connection. In this case, it is an HTTP server.
|
||||
* http.createServer((req, res) => {
|
||||
* res.writeHead(200);
|
||||
* res.end(`Current process\n ${process.pid}`);
|
||||
* process.kill(process.pid);
|
||||
* }).listen(8000);
|
||||
* }
|
||||
* ```
|
||||
* @since v0.11.14
|
||||
*/
|
||||
isDead(): boolean;
|
||||
/**
|
||||
* This property is `true` if the worker exited due to `.disconnect()`.
|
||||
* If the worker exited any other way, it is `false`. If the
|
||||
* worker has not exited, it is `undefined`.
|
||||
*
|
||||
* The boolean `worker.exitedAfterDisconnect` allows distinguishing between
|
||||
* voluntary and accidental exit, the primary may choose not to respawn a worker
|
||||
* based on this value.
|
||||
*
|
||||
* ```js
|
||||
* cluster.on('exit', (worker, code, signal) => {
|
||||
* if (worker.exitedAfterDisconnect === true) {
|
||||
* console.log('Oh, it was just voluntary – no need to worry');
|
||||
* }
|
||||
* });
|
||||
*
|
||||
* // kill worker
|
||||
* worker.kill();
|
||||
* ```
|
||||
* @since v6.0.0
|
||||
*/
|
||||
exitedAfterDisconnect: boolean;
|
||||
}
|
||||
interface Worker extends InternalEventEmitter<cluster.WorkerEventMap> {}
|
||||
type _Worker = Worker;
|
||||
namespace cluster {
|
||||
interface Worker extends _Worker {}
|
||||
interface WorkerOptions {
|
||||
id?: number | undefined;
|
||||
process?: child_process.ChildProcess | undefined;
|
||||
state?: string | undefined;
|
||||
}
|
||||
interface WorkerEventMap {
|
||||
"disconnect": [];
|
||||
"error": [error: Error];
|
||||
"exit": [code: number, signal: string];
|
||||
"listening": [address: Address];
|
||||
"message": [message: any, handle: child_process.SendHandle];
|
||||
"online": [];
|
||||
}
|
||||
interface ClusterSettings {
|
||||
/**
|
||||
* List of string arguments passed to the Node.js executable.
|
||||
* @default process.execArgv
|
||||
*/
|
||||
execArgv?: string[] | undefined;
|
||||
/**
|
||||
* File path to worker file.
|
||||
* @default process.argv[1]
|
||||
*/
|
||||
exec?: string | undefined;
|
||||
/**
|
||||
* String arguments passed to worker.
|
||||
* @default process.argv.slice(2)
|
||||
*/
|
||||
args?: readonly string[] | undefined;
|
||||
/**
|
||||
* Whether or not to send output to parent's stdio.
|
||||
* @default false
|
||||
*/
|
||||
silent?: boolean | undefined;
|
||||
/**
|
||||
* Configures the stdio of forked processes. Because the cluster module relies on IPC to function, this configuration must
|
||||
* contain an `'ipc'` entry. When this option is provided, it overrides `silent`. See [`child_prcess.spawn()`](https://nodejs.org/docs/latest-v26.x/api/child_process.html#child_processspawncommand-args-options)'s
|
||||
* [`stdio`](https://nodejs.org/docs/latest-v26.x/api/child_process.html#optionsstdio).
|
||||
*/
|
||||
stdio?: any[] | undefined;
|
||||
/**
|
||||
* Sets the user identity of the process. (See [`setuid(2)`](https://man7.org/linux/man-pages/man2/setuid.2.html).)
|
||||
*/
|
||||
uid?: number | undefined;
|
||||
/**
|
||||
* Sets the group identity of the process. (See [`setgid(2)`](https://man7.org/linux/man-pages/man2/setgid.2.html).)
|
||||
*/
|
||||
gid?: number | undefined;
|
||||
/**
|
||||
* Sets inspector port of worker. This can be a number, or a function that takes no arguments and returns a number.
|
||||
* By default each worker gets its own port, incremented from the primary's `process.debugPort`.
|
||||
*/
|
||||
inspectPort?: number | (() => number) | undefined;
|
||||
/**
|
||||
* Specify the kind of serialization used for sending messages between processes. Possible values are `'json'` and `'advanced'`.
|
||||
* See [Advanced serialization for `child_process`](https://nodejs.org/docs/latest-v26.x/api/child_process.html#advanced-serialization) for more details.
|
||||
* @default false
|
||||
*/
|
||||
serialization?: "json" | "advanced" | undefined;
|
||||
/**
|
||||
* Current working directory of the worker process.
|
||||
* @default undefined (inherits from parent process)
|
||||
*/
|
||||
cwd?: string | undefined;
|
||||
/**
|
||||
* Hide the forked processes console window that would normally be created on Windows systems.
|
||||
* @default false
|
||||
*/
|
||||
windowsHide?: boolean | undefined;
|
||||
}
|
||||
interface Address {
|
||||
address: string;
|
||||
port: number;
|
||||
/**
|
||||
* The `addressType` is one of:
|
||||
*
|
||||
* * `4` (TCPv4)
|
||||
* * `6` (TCPv6)
|
||||
* * `-1` (Unix domain socket)
|
||||
* * `'udp4'` or `'udp6'` (UDPv4 or UDPv6)
|
||||
*/
|
||||
addressType: 4 | 6 | -1 | "udp4" | "udp6";
|
||||
}
|
||||
interface ClusterEventMap {
|
||||
"disconnect": [worker: Worker];
|
||||
"exit": [worker: Worker, code: number, signal: string];
|
||||
"fork": [worker: Worker];
|
||||
"listening": [worker: Worker, address: Address];
|
||||
"message": [worker: Worker, message: any, handle: child_process.SendHandle];
|
||||
"online": [worker: Worker];
|
||||
"setup": [settings: ClusterSettings];
|
||||
}
|
||||
interface Cluster extends InternalEventEmitter<ClusterEventMap> {
|
||||
/**
|
||||
* A `Worker` object contains all public information and method about a worker.
|
||||
* In the primary it can be obtained using `cluster.workers`. In a worker
|
||||
* it can be obtained using `cluster.worker`.
|
||||
* @since v0.7.0
|
||||
*/
|
||||
Worker: typeof Worker;
|
||||
disconnect(callback?: () => void): void;
|
||||
/**
|
||||
* Spawn a new worker process.
|
||||
*
|
||||
* This can only be called from the primary process.
|
||||
* @param env Key/value pairs to add to worker process environment.
|
||||
* @since v0.6.0
|
||||
*/
|
||||
fork(env?: any): Worker;
|
||||
/** @deprecated since v16.0.0 - use isPrimary. */
|
||||
readonly isMaster: boolean;
|
||||
/**
|
||||
* True if the process is a primary. This is determined by the `process.env.NODE_UNIQUE_ID`. If `process.env.NODE_UNIQUE_ID`
|
||||
* is undefined, then `isPrimary` is `true`.
|
||||
* @since v16.0.0
|
||||
*/
|
||||
readonly isPrimary: boolean;
|
||||
/**
|
||||
* True if the process is not a primary (it is the negation of `cluster.isPrimary`).
|
||||
* @since v0.6.0
|
||||
*/
|
||||
readonly isWorker: boolean;
|
||||
/**
|
||||
* The scheduling policy, either `cluster.SCHED_RR` for round-robin or `cluster.SCHED_NONE` to leave it to the operating system. This is a
|
||||
* global setting and effectively frozen once either the first worker is spawned, or [`.setupPrimary()`](https://nodejs.org/docs/latest-v26.x/api/cluster.html#clustersetupprimarysettings)
|
||||
* is called, whichever comes first.
|
||||
*
|
||||
* `SCHED_RR` is the default on all operating systems except Windows. Windows will change to `SCHED_RR` once libuv is able to effectively distribute
|
||||
* IOCP handles without incurring a large performance hit.
|
||||
*
|
||||
* `cluster.schedulingPolicy` can also be set through the `NODE_CLUSTER_SCHED_POLICY` environment variable. Valid values are `'rr'` and `'none'`.
|
||||
* @since v0.11.2
|
||||
*/
|
||||
schedulingPolicy: number;
|
||||
/**
|
||||
* After calling [`.setupPrimary()`](https://nodejs.org/docs/latest-v26.x/api/cluster.html#clustersetupprimarysettings)
|
||||
* (or [`.fork()`](https://nodejs.org/docs/latest-v26.x/api/cluster.html#clusterforkenv)) this settings object will contain
|
||||
* the settings, including the default values.
|
||||
*
|
||||
* This object is not intended to be changed or set manually.
|
||||
* @since v0.7.1
|
||||
*/
|
||||
readonly settings: ClusterSettings;
|
||||
/** @deprecated since v16.0.0 - use [`.setupPrimary()`](https://nodejs.org/docs/latest-v26.x/api/cluster.html#clustersetupprimarysettings) instead. */
|
||||
setupMaster(settings?: ClusterSettings): void;
|
||||
/**
|
||||
* `setupPrimary` is used to change the default 'fork' behavior. Once called, the settings will be present in `cluster.settings`.
|
||||
*
|
||||
* Any settings changes only affect future calls to [`.fork()`](https://nodejs.org/docs/latest-v26.x/api/cluster.html#clusterforkenv)
|
||||
* and have no effect on workers that are already running.
|
||||
*
|
||||
* The only attribute of a worker that cannot be set via `.setupPrimary()` is the `env` passed to
|
||||
* [`.fork()`](https://nodejs.org/docs/latest-v26.x/api/cluster.html#clusterforkenv).
|
||||
*
|
||||
* The defaults above apply to the first call only; the defaults for later calls are the current values at the time of
|
||||
* `cluster.setupPrimary()` is called.
|
||||
*
|
||||
* ```js
|
||||
* import cluster from 'node:cluster';
|
||||
*
|
||||
* cluster.setupPrimary({
|
||||
* exec: 'worker.js',
|
||||
* args: ['--use', 'https'],
|
||||
* silent: true,
|
||||
* });
|
||||
* cluster.fork(); // https worker
|
||||
* cluster.setupPrimary({
|
||||
* exec: 'worker.js',
|
||||
* args: ['--use', 'http'],
|
||||
* });
|
||||
* cluster.fork(); // http worker
|
||||
* ```
|
||||
*
|
||||
* This can only be called from the primary process.
|
||||
* @since v16.0.0
|
||||
*/
|
||||
setupPrimary(settings?: ClusterSettings): void;
|
||||
/**
|
||||
* A reference to the current worker object. Not available in the primary process.
|
||||
*
|
||||
* ```js
|
||||
* import cluster from 'node:cluster';
|
||||
*
|
||||
* if (cluster.isPrimary) {
|
||||
* console.log('I am primary');
|
||||
* cluster.fork();
|
||||
* cluster.fork();
|
||||
* } else if (cluster.isWorker) {
|
||||
* console.log(`I am worker #${cluster.worker.id}`);
|
||||
* }
|
||||
* ```
|
||||
* @since v0.7.0
|
||||
*/
|
||||
readonly worker?: Worker;
|
||||
/**
|
||||
* A hash that stores the active worker objects, keyed by `id` field. This makes it easy to loop through all the workers. It is only available in the primary process.
|
||||
*
|
||||
* A worker is removed from `cluster.workers` after the worker has disconnected _and_ exited. The order between these two events cannot be determined in advance. However, it
|
||||
* is guaranteed that the removal from the `cluster.workers` list happens before the last `'disconnect'` or `'exit'` event is emitted.
|
||||
*
|
||||
* ```js
|
||||
* import cluster from 'node:cluster';
|
||||
*
|
||||
* for (const worker of Object.values(cluster.workers)) {
|
||||
* worker.send('big announcement to all workers');
|
||||
* }
|
||||
* ```
|
||||
* @since v0.7.0
|
||||
*/
|
||||
readonly workers?: NodeJS.Dict<Worker>;
|
||||
readonly SCHED_NONE: number;
|
||||
readonly SCHED_RR: number;
|
||||
}
|
||||
}
|
||||
var cluster: cluster.Cluster;
|
||||
export = cluster;
|
||||
}
|
||||
declare module "cluster" {
|
||||
import cluster = require("node:cluster");
|
||||
export = cluster;
|
||||
}
|
||||
@@ -0,0 +1,16 @@
|
||||
import { _ as _type_of } from "./_type_of.js";
|
||||
|
||||
function _to_primitive(input, hint) {
|
||||
if (_type_of(input) !== "object" || input === null) return input;
|
||||
|
||||
var prim = input[Symbol.toPrimitive];
|
||||
|
||||
if (prim !== undefined) {
|
||||
var res = prim.call(input, hint || "default");
|
||||
if (_type_of(res) !== "object") return res;
|
||||
throw new TypeError("@@toPrimitive must return a primitive value.");
|
||||
}
|
||||
|
||||
return (hint === "string" ? String : Number)(input);
|
||||
}
|
||||
export { _to_primitive as _ };
|
||||
@@ -0,0 +1,73 @@
|
||||
'use strict'
|
||||
|
||||
const bench = require('fastbench')
|
||||
const pino = require('../')
|
||||
const bunyan = require('bunyan')
|
||||
const bole = require('bole')('bench')
|
||||
const fs = require('node:fs')
|
||||
const dest = fs.createWriteStream('/dev/null')
|
||||
const plogNodeStream = pino(dest)
|
||||
const plogDest = pino(pino.destination(('/dev/null')))
|
||||
delete require.cache[require.resolve('../')]
|
||||
const plogMinLength = require('../')(pino.destination({ dest: '/dev/null', sync: false, minLength: 4096 }))
|
||||
|
||||
const max = 10
|
||||
const blog = bunyan.createLogger({
|
||||
name: 'myapp',
|
||||
streams: [{
|
||||
level: 'trace',
|
||||
stream: dest
|
||||
}]
|
||||
})
|
||||
|
||||
require('bole').output({
|
||||
level: 'info',
|
||||
stream: dest
|
||||
}).setFastTime(true)
|
||||
|
||||
const run = bench([
|
||||
function benchBunyanCreation (cb) {
|
||||
const child = blog.child({ a: 'property' })
|
||||
for (var i = 0; i < max; i++) {
|
||||
child.info({ hello: 'world' })
|
||||
}
|
||||
setImmediate(cb)
|
||||
},
|
||||
function benchBoleCreation (cb) {
|
||||
const child = bole('child')
|
||||
for (var i = 0; i < max; i++) {
|
||||
child.info({ hello: 'world' })
|
||||
}
|
||||
setImmediate(cb)
|
||||
},
|
||||
function benchPinoCreation (cb) {
|
||||
const child = plogDest.child({ a: 'property' })
|
||||
for (var i = 0; i < max; i++) {
|
||||
child.info({ hello: 'world' })
|
||||
}
|
||||
setImmediate(cb)
|
||||
},
|
||||
function benchPinoMinLengthCreation (cb) {
|
||||
const child = plogMinLength.child({ a: 'property' })
|
||||
for (var i = 0; i < max; i++) {
|
||||
child.info({ hello: 'world' })
|
||||
}
|
||||
setImmediate(cb)
|
||||
},
|
||||
function benchPinoNodeStreamCreation (cb) {
|
||||
const child = plogNodeStream.child({ a: 'property' })
|
||||
for (var i = 0; i < max; i++) {
|
||||
child.info({ hello: 'world' })
|
||||
}
|
||||
setImmediate(cb)
|
||||
},
|
||||
function benchPinoCreationWithOption (cb) {
|
||||
const child = plogDest.child({ a: 'property' }, { redact: [] })
|
||||
for (var i = 0; i < max; i++) {
|
||||
child.info({ hello: 'world' })
|
||||
}
|
||||
setImmediate(cb)
|
||||
}
|
||||
], 10000)
|
||||
|
||||
run(run)
|
||||
Reference in New Issue
Block a user