// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license. // Copyright Joyent, Inc. and other Node contributors. // // 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. // This module ports: // - https://github.com/nodejs/node/blob/master/src/util-inl.h // - https://github.com/nodejs/node/blob/master/src/util.cc // - https://github.com/nodejs/node/blob/master/src/util.h // TODO(petamoriken): enable prefer-primordials for node polyfills // deno-lint-ignore-file prefer-primordials import { op_node_guess_handle_type } from "ext:core/ops"; const handleTypes = ["TCP", "TTY", "UDP", "FILE", "PIPE", "UNKNOWN"]; export function guessHandleType(fd: number): string { const type = op_node_guess_handle_type(fd); return handleTypes[type]; } export const ALL_PROPERTIES = 0; export const ONLY_WRITABLE = 1; export const ONLY_ENUMERABLE = 2; export const ONLY_CONFIGURABLE = 4; export const ONLY_ENUM_WRITABLE = 6; export const SKIP_STRINGS = 8; export const SKIP_SYMBOLS = 16; /** * Efficiently determine whether the provided property key is numeric * (and thus could be an array indexer) or not. * * Always returns true for values of type `'number'`. * * Otherwise, only returns true for strings that consist only of positive integers. * * Results are cached. */ const isNumericLookup: Record<string, boolean> = {}; export function isArrayIndex(value: unknown): value is number | string { switch (typeof value) { case "number": return value >= 0 && (value | 0) === value; case "string": { const result = isNumericLookup[value]; if (result !== void 0) { return result; } const length = value.length; if (length === 0) { return isNumericLookup[value] = false; } let ch = 0; let i = 0; for (; i < length; ++i) { ch = value.charCodeAt(i); if ( i === 0 && ch === 0x30 && length > 1 /* must not start with 0 */ || ch < 0x30 /* 0 */ || ch > 0x39 /* 9 */ ) { return isNumericLookup[value] = false; } } return isNumericLookup[value] = true; } default: return false; } } export function getOwnNonIndexProperties( obj: object, filter: number, ): (string | symbol)[] { let allProperties = [ ...Object.getOwnPropertyNames(obj), ...Object.getOwnPropertySymbols(obj), ]; if (Array.isArray(obj)) { allProperties = allProperties.filter((k) => !isArrayIndex(k)); } if (filter === ALL_PROPERTIES) { return allProperties; } const result: (string | symbol)[] = []; for (const key of allProperties) { const desc = Object.getOwnPropertyDescriptor(obj, key); if (desc === undefined) { continue; } if (filter & ONLY_WRITABLE && !desc.writable) { continue; } if (filter & ONLY_ENUMERABLE && !desc.enumerable) { continue; } if (filter & ONLY_CONFIGURABLE && !desc.configurable) { continue; } if (filter & SKIP_STRINGS && typeof key === "string") { continue; } if (filter & SKIP_SYMBOLS && typeof key === "symbol") { continue; } result.push(key); } return result; }