deno.land / std@0.173.0 / node / util.ts
نووسراو ببینە
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.import { promisify } from "./internal/util.mjs";import { callbackify } from "./_util/_util_callbackify.ts";import { debuglog } from "./internal/util/debuglog.ts";import { format, formatWithOptions, inspect, stripVTControlCharacters,} from "./internal/util/inspect.mjs";import { codes } from "./internal/error_codes.ts";import types from "./util/types.ts";import { Buffer } from "./buffer.ts";import { isDeepStrictEqual } from "./internal/util/comparisons.ts";import process from "./process.ts";import { validateString } from "./internal/validators.mjs";
export { callbackify, debuglog, format, formatWithOptions, inspect, promisify, stripVTControlCharacters, types,};
/** @deprecated - use `Array.isArray()` instead. */export function isArray(value: unknown): boolean { return Array.isArray(value);}
/** @deprecated - use `typeof value === "boolean" || value instanceof Boolean` instead. */export function isBoolean(value: unknown): boolean { return typeof value === "boolean" || value instanceof Boolean;}
/** @deprecated - use `value === null` instead. */export function isNull(value: unknown): boolean { return value === null;}
/** @deprecated - use `value === null || value === undefined` instead. */export function isNullOrUndefined(value: unknown): boolean { return value === null || value === undefined;}
/** @deprecated - use `typeof value === "number" || value instanceof Number` instead. */export function isNumber(value: unknown): boolean { return typeof value === "number" || value instanceof Number;}
/** @deprecated - use `typeof value === "string" || value instanceof String` instead. */export function isString(value: unknown): boolean { return typeof value === "string" || value instanceof String;}
/** @deprecated - use `typeof value === "symbol"` instead. */export function isSymbol(value: unknown): boolean { return typeof value === "symbol";}
/** @deprecated - use `value === undefined` instead. */export function isUndefined(value: unknown): boolean { return value === undefined;}
/** @deprecated - use `value !== null && typeof value === "object"` instead. */export function isObject(value: unknown): boolean { return value !== null && typeof value === "object";}
/** @deprecated - use `e instanceof Error` instead. */export function isError(e: unknown): boolean { return e instanceof Error;}
/** @deprecated - use `typeof value === "function"` instead. */export function isFunction(value: unknown): boolean { return typeof value === "function";}
/** @deprecated Use util.types.RegExp() instead. */export function isRegExp(value: unknown): boolean { return types.isRegExp(value);}
/** @deprecated Use util.types.isDate() instead. */export function isDate(value: unknown): boolean { return types.isDate(value);}
/** @deprecated - use `value === null || (typeof value !== "object" && typeof value !== "function")` instead. */export function isPrimitive(value: unknown): boolean { return ( value === null || (typeof value !== "object" && typeof value !== "function") );}
/** @deprecated Use Buffer.isBuffer() instead. */export function isBuffer(value: unknown): boolean { return Buffer.isBuffer(value);}
/** @deprecated Use Object.assign() instead. */export function _extend( target: Record<string, unknown>, source: unknown,): Record<string, unknown> { // Don't do anything if source isn't an object if (source === null || typeof source !== "object") return target;
const keys = Object.keys(source!); let i = keys.length; while (i--) { target[keys[i]] = (source as Record<string, unknown>)[keys[i]]; } return target;}
/** * https://nodejs.org/api/util.html#util_util_inherits_constructor_superconstructor * @param ctor Constructor function which needs to inherit the prototype. * @param superCtor Constructor function to inherit prototype from. */export function inherits<T, U>( ctor: new (...args: unknown[]) => T, superCtor: new (...args: unknown[]) => U,) { if (ctor === undefined || ctor === null) { throw new codes.ERR_INVALID_ARG_TYPE("ctor", "Function", ctor); }
if (superCtor === undefined || superCtor === null) { throw new codes.ERR_INVALID_ARG_TYPE("superCtor", "Function", superCtor); }
if (superCtor.prototype === undefined) { throw new codes.ERR_INVALID_ARG_TYPE( "superCtor.prototype", "Object", superCtor.prototype, ); } Object.defineProperty(ctor, "super_", { value: superCtor, writable: true, configurable: true, }); Object.setPrototypeOf(ctor.prototype, superCtor.prototype);}
import { _TextDecoder, _TextEncoder, getSystemErrorName } from "./_utils.ts";
/** The global TextDecoder */export type TextDecoder = import("./_utils.ts")._TextDecoder;export const TextDecoder = _TextDecoder;
/** The global TextEncoder */export type TextEncoder = import("./_utils.ts")._TextEncoder;export const TextEncoder = _TextEncoder;
function pad(n: number) { return n.toString().padStart(2, "0");}
const months = [ "Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec",];
/** * @returns 26 Feb 16:19:34 */function timestamp(): string { const d = new Date(); const t = [ pad(d.getHours()), pad(d.getMinutes()), pad(d.getSeconds()), ].join(":"); return `${(d.getDate())} ${months[(d).getMonth()]} ${t}`;}
/** * Log is just a thin wrapper to console.log that prepends a timestamp * @deprecated */// deno-lint-ignore no-explicit-anyexport function log(...args: any[]) { console.log("%s - %s", timestamp(), format(...args));}
// Keep a list of deprecation codes that have been warned on so we only warn on// each one once.const codesWarned = new Set();
// Mark that a method should not be used.// Returns a modified function which warns once by default.// If --no-deprecation is set, then it is a no-op.// deno-lint-ignore no-explicit-anyexport function deprecate(fn: any, msg: string, code?: any) { if (process.noDeprecation === true) { return fn; }
if (code !== undefined) { validateString(code, "code"); }
let warned = false; // deno-lint-ignore no-explicit-any function deprecated(this: any, ...args: any[]) { if (!warned) { warned = true; if (code !== undefined) { if (!codesWarned.has(code)) { process.emitWarning(msg, "DeprecationWarning", code, deprecated); codesWarned.add(code); } } else { // deno-lint-ignore no-explicit-any process.emitWarning(msg, "DeprecationWarning", deprecated as any); } } if (new.target) { return Reflect.construct(fn, args, new.target); } return Reflect.apply(fn, this, args); }
// The wrapper will keep the same prototype as fn to maintain prototype chain Object.setPrototypeOf(deprecated, fn); if (fn.prototype) { // Setting this (rather than using Object.setPrototype, as above) ensures // that calling the unwrapped constructor gives an instanceof the wrapped // constructor. deprecated.prototype = fn.prototype; }
return deprecated;}
export { getSystemErrorName, isDeepStrictEqual };
export default { format, formatWithOptions, inspect, isArray, isBoolean, isNull, isNullOrUndefined, isNumber, isString, isSymbol, isUndefined, isObject, isError, isFunction, isRegExp, isDate, isPrimitive, isBuffer, _extend, getSystemErrorName, deprecate, callbackify, promisify, inherits, types, stripVTControlCharacters, TextDecoder, TextEncoder, log, debuglog, isDeepStrictEqual,};
std
Version Info
a year ago
