• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1// Copyright Joyent, Inc. and other Node contributors.
2//
3// Permission is hereby granted, free of charge, to any person obtaining a
4// copy of this software and associated documentation files (the
5// "Software"), to deal in the Software without restriction, including
6// without limitation the rights to use, copy, modify, merge, publish,
7// distribute, sublicense, and/or sell copies of the Software, and to permit
8// persons to whom the Software is furnished to do so, subject to the
9// following conditions:
10//
11// The above copyright notice and this permission notice shall be included
12// in all copies or substantial portions of the Software.
13//
14// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
15// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
16// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
17// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
18// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
19// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
20// USE OR OTHER DEALINGS IN THE SOFTWARE.
21
22'use strict';
23
24const {
25  ArrayIsArray,
26  ArrayPrototypeJoin,
27  ArrayPrototypePop,
28  Date,
29  DatePrototypeGetDate,
30  DatePrototypeGetHours,
31  DatePrototypeGetMinutes,
32  DatePrototypeGetMonth,
33  DatePrototypeGetSeconds,
34  Error,
35  FunctionPrototypeBind,
36  NumberIsSafeInteger,
37  ObjectDefineProperties,
38  ObjectDefineProperty,
39  ObjectGetOwnPropertyDescriptors,
40  ObjectKeys,
41  ObjectPrototypeToString,
42  ObjectSetPrototypeOf,
43  ObjectValues,
44  ReflectApply,
45  StringPrototypePadStart,
46} = primordials;
47
48const {
49  codes: {
50    ERR_FALSY_VALUE_REJECTION,
51    ERR_INVALID_ARG_TYPE,
52    ERR_OUT_OF_RANGE,
53  },
54  errnoException,
55  exceptionWithHostPort,
56  hideStackFrames,
57} = require('internal/errors');
58const {
59  format,
60  formatWithOptions,
61  inspect,
62  stripVTControlCharacters,
63} = require('internal/util/inspect');
64const { debuglog } = require('internal/util/debuglog');
65const { parseArgs } = require('internal/util/parse_args/parse_args');
66const {
67  validateFunction,
68  validateNumber,
69} = require('internal/validators');
70const { TextDecoder, TextEncoder } = require('internal/encoding');
71const { MIMEType, MIMEParams } = require('internal/mime');
72const { isBuffer } = require('buffer').Buffer;
73const types = require('internal/util/types');
74
75const {
76  deprecate,
77  getSystemErrorMap,
78  getSystemErrorName: internalErrorName,
79  promisify,
80  toUSVString,
81} = require('internal/util');
82
83let abortController;
84
85function lazyAbortController() {
86  abortController ??= require('internal/abort_controller');
87  return abortController;
88}
89
90let internalDeepEqual;
91
92/**
93 * @deprecated since v4.0.0
94 * @param {any} arg
95 * @returns {arg is boolean}
96 */
97function isBoolean(arg) {
98  return typeof arg === 'boolean';
99}
100
101/**
102 * @deprecated since v4.0.0
103 * @param {any} arg
104 * @returns {arg is null}
105 */
106function isNull(arg) {
107  return arg === null;
108}
109
110/**
111 * @deprecated since v4.0.0
112 * @param {any} arg
113 * @returns {arg is (null | undefined)}
114 */
115function isNullOrUndefined(arg) {
116  return arg === null || arg === undefined;
117}
118
119/**
120 * @deprecated since v4.0.0
121 * @param {any} arg
122 * @returns {arg is number}
123 */
124function isNumber(arg) {
125  return typeof arg === 'number';
126}
127
128/**
129 * @param {any} arg
130 * @returns {arg is string}
131 */
132function isString(arg) {
133  return typeof arg === 'string';
134}
135
136/**
137 * @deprecated since v4.0.0
138 * @param {any} arg
139 * @returns {arg is symbol}
140 */
141function isSymbol(arg) {
142  return typeof arg === 'symbol';
143}
144
145/**
146 * @deprecated since v4.0.0
147 * @param {any} arg
148 * @returns {arg is undefined}
149 */
150function isUndefined(arg) {
151  return arg === undefined;
152}
153
154/**
155 * @deprecated since v4.0.0
156 * @param {any} arg
157 * @returns {a is NonNullable<object>}
158 */
159function isObject(arg) {
160  return arg !== null && typeof arg === 'object';
161}
162
163/**
164 * @deprecated since v4.0.0
165 * @param {any} e
166 * @returns {arg is Error}
167 */
168function isError(e) {
169  return ObjectPrototypeToString(e) === '[object Error]' || e instanceof Error;
170}
171
172/**
173 * @deprecated since v4.0.0
174 * @param {any} arg
175 * @returns {arg is Function}
176 */
177function isFunction(arg) {
178  return typeof arg === 'function';
179}
180
181/**
182 * @deprecated since v4.0.0
183 * @param {any} arg
184 * @returns {arg is (boolean | null | number | string | symbol | undefined)}
185 */
186function isPrimitive(arg) {
187  return arg === null ||
188         (typeof arg !== 'object' && typeof arg !== 'function');
189}
190
191/**
192 * @param {number} n
193 * @returns {string}
194 */
195function pad(n) {
196  return StringPrototypePadStart(n.toString(), 2, '0');
197}
198
199const months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep',
200                'Oct', 'Nov', 'Dec'];
201
202/**
203 * @returns {string}  26 Feb 16:19:34
204 */
205function timestamp() {
206  const d = new Date();
207  const t = ArrayPrototypeJoin([
208    pad(DatePrototypeGetHours(d)),
209    pad(DatePrototypeGetMinutes(d)),
210    pad(DatePrototypeGetSeconds(d)),
211  ], ':');
212  return `${DatePrototypeGetDate(d)} ${months[DatePrototypeGetMonth(d)]} ${t}`;
213}
214
215let console;
216/**
217 * Log is just a thin wrapper to console.log that prepends a timestamp
218 * @deprecated since v6.0.0
219 * @type {(...args: any[]) => void}
220 */
221function log(...args) {
222  if (!console) {
223    console = require('internal/console/global');
224  }
225  console.log('%s - %s', timestamp(), format(...args));
226}
227
228/**
229 * Inherit the prototype methods from one constructor into another.
230 *
231 * The Function.prototype.inherits from lang.js rewritten as a standalone
232 * function (not on Function.prototype). NOTE: If this file is to be loaded
233 * during bootstrapping this function needs to be rewritten using some native
234 * functions as prototype setup using normal JavaScript does not work as
235 * expected during bootstrapping (see mirror.js in r114903).
236 * @param {Function} ctor Constructor function which needs to inherit the
237 *     prototype.
238 * @param {Function} superCtor Constructor function to inherit prototype from.
239 * @throws {TypeError} Will error if either constructor is null, or if
240 *     the super constructor lacks a prototype.
241 */
242function inherits(ctor, superCtor) {
243
244  if (ctor === undefined || ctor === null)
245    throw new ERR_INVALID_ARG_TYPE('ctor', 'Function', ctor);
246
247  if (superCtor === undefined || superCtor === null)
248    throw new ERR_INVALID_ARG_TYPE('superCtor', 'Function', superCtor);
249
250  if (superCtor.prototype === undefined) {
251    throw new ERR_INVALID_ARG_TYPE('superCtor.prototype',
252                                   'Object', superCtor.prototype);
253  }
254  ObjectDefineProperty(ctor, 'super_', {
255    __proto__: null,
256    value: superCtor,
257    writable: true,
258    configurable: true,
259  });
260  ObjectSetPrototypeOf(ctor.prototype, superCtor.prototype);
261}
262
263/**
264 * @deprecated since v6.0.0
265 * @template T
266 * @template S
267 * @param {T} target
268 * @param {S} source
269 * @returns {S extends null ? T : (T & S)}
270 */
271function _extend(target, source) {
272  // Don't do anything if source isn't an object
273  if (source === null || typeof source !== 'object') return target;
274
275  const keys = ObjectKeys(source);
276  let i = keys.length;
277  while (i--) {
278    target[keys[i]] = source[keys[i]];
279  }
280  return target;
281}
282
283const callbackifyOnRejected = hideStackFrames((reason, cb) => {
284  // `!reason` guard inspired by bluebird (Ref: https://goo.gl/t5IS6M).
285  // Because `null` is a special error value in callbacks which means "no error
286  // occurred", we error-wrap so the callback consumer can distinguish between
287  // "the promise rejected with null" or "the promise fulfilled with undefined".
288  if (!reason) {
289    reason = new ERR_FALSY_VALUE_REJECTION(reason);
290  }
291  return cb(reason);
292});
293
294/**
295 * @template {(...args: any[]) => Promise<any>} T
296 * @param {T} original
297 * @returns {T extends (...args: infer TArgs) => Promise<infer TReturn> ?
298 *   ((...params: [...TArgs, ((err: Error, ret: TReturn) => any)]) => void) :
299 *   never
300 * }
301 */
302function callbackify(original) {
303  validateFunction(original, 'original');
304
305  // We DO NOT return the promise as it gives the user a false sense that
306  // the promise is actually somehow related to the callback's execution
307  // and that the callback throwing will reject the promise.
308  function callbackified(...args) {
309    const maybeCb = ArrayPrototypePop(args);
310    validateFunction(maybeCb, 'last argument');
311    const cb = FunctionPrototypeBind(maybeCb, this);
312    // In true node style we process the callback on `nextTick` with all the
313    // implications (stack, `uncaughtException`, `async_hooks`)
314    ReflectApply(original, this, args)
315      .then((ret) => process.nextTick(cb, null, ret),
316            (rej) => process.nextTick(callbackifyOnRejected, rej, cb));
317  }
318
319  const descriptors = ObjectGetOwnPropertyDescriptors(original);
320  // It is possible to manipulate a functions `length` or `name` property. This
321  // guards against the manipulation.
322  if (typeof descriptors.length.value === 'number') {
323    descriptors.length.value++;
324  }
325  if (typeof descriptors.name.value === 'string') {
326    descriptors.name.value += 'Callbackified';
327  }
328  const propertiesValues = ObjectValues(descriptors);
329  for (let i = 0; i < propertiesValues.length; i++) {
330  // We want to use null-prototype objects to not rely on globally mutable
331  // %Object.prototype%.
332    ObjectSetPrototypeOf(propertiesValues[i], null);
333  }
334  ObjectDefineProperties(callbackified, descriptors);
335  return callbackified;
336}
337
338/**
339 * @param {number} err
340 * @returns {string}
341 */
342function getSystemErrorName(err) {
343  validateNumber(err, 'err');
344  if (err >= 0 || !NumberIsSafeInteger(err)) {
345    throw new ERR_OUT_OF_RANGE('err', 'a negative integer', err);
346  }
347  return internalErrorName(err);
348}
349
350// Keep the `exports =` so that various functions can still be monkeypatched
351module.exports = {
352  _errnoException: errnoException,
353  _exceptionWithHostPort: exceptionWithHostPort,
354  _extend,
355  callbackify,
356  debug: debuglog,
357  debuglog,
358  deprecate,
359  format,
360  formatWithOptions,
361  getSystemErrorMap,
362  getSystemErrorName,
363  inherits,
364  inspect,
365  isArray: ArrayIsArray,
366  isBoolean,
367  isBuffer,
368  isDeepStrictEqual(a, b) {
369    if (internalDeepEqual === undefined) {
370      internalDeepEqual = require('internal/util/comparisons')
371        .isDeepStrictEqual;
372    }
373    return internalDeepEqual(a, b);
374  },
375  isNull,
376  isNullOrUndefined,
377  isNumber,
378  isString,
379  isSymbol,
380  isUndefined,
381  isRegExp: types.isRegExp,
382  isObject,
383  isDate: types.isDate,
384  isError,
385  isFunction,
386  isPrimitive,
387  log,
388  MIMEType,
389  MIMEParams,
390  parseArgs,
391  promisify,
392  stripVTControlCharacters,
393  toUSVString,
394  TextDecoder,
395  TextEncoder,
396  get transferableAbortSignal() {
397    return lazyAbortController().transferableAbortSignal;
398  },
399  get transferableAbortController() {
400    return lazyAbortController().transferableAbortController;
401  },
402  get aborted() {
403    return lazyAbortController().aborted;
404  },
405  types,
406};
407