import util from 'node:util';

import { callbackify } from 'node:util';

async function fn() {
  return 'hello world';
}
const callbackFunction = callbackify(fn);

callbackFunction((err, ret) => {
  if (err) throw err;
  console.log(ret);
});

import util from 'node:util';

function fn() {
  return Promise.reject(null);
}
const callbackFunction = util.callbackify(fn);

callbackFunction((err, ret) => {
  // 当 Promise 被 `null` 拒绝时，它会被包装成一个 Error 并且
  // 原始值存储在 `reason` 中。
  err && Object.hasOwn(err, 'reason') && err.reason === null;  // true
});

import { convertProcessSignalToExitCode } from 'node:util';

console.log(convertProcessSignalToExitCode('SIGTERM')); // 143 (128 + 15)
console.log(convertProcessSignalToExitCode('SIGKILL')); // 137 (128 + 9)

import { debuglog } from 'node:util';
const log = debuglog('foo');

log('hello from foo [%d]', 123);

import { debuglog } from 'node:util';
const log = debuglog('foo-bar');

log('hi there, it\'s foo-bar [%d]', 2333);

import { debuglog } from 'node:util';
let log = debuglog('internals', (debug) => {
  // 替换为一个日志函数，优化掉
  // 测试 section 是否启用的过程
  log = debug;
});

import { debuglog } from 'node:util';
const enabled = debuglog('foo').enabled;
if (enabled) {
  console.log('hello from foo [%d]', 123);
}

import { deprecate } from 'node:util';

export const obsoleteFunction = deprecate(() => {
  // 在这里做一些事情。
}, 'obsoleteFunction() is deprecated. Use newShinyFunction() instead.');

import { deprecate } from 'node:util';

const fn1 = deprecate(
  () => 'a value',
  'deprecation message',
  'DEP0001',
);
const fn2 = deprecate(
  () => 'a  different value',
  'other dep message',
  'DEP0001',
);
fn1(); // 发出带有代码 DEP0001 的弃用警告
fn2(); // 不发出弃用警告，因为它具有相同的代码

import { getCallSites } from 'node:util';

function exampleFunction() {
  const callSites = getCallSites();

  console.log('调用站点：');
  callSites.forEach((callSite, index) => {
    console.log(`调用站点 ${index + 1}:`);
    console.log(`函数名称: ${callSite.functionName}`);
    console.log(`脚本名称: ${callSite.scriptName}`);
    console.log(`行号: ${callSite.lineNumber}`);
    console.log(`列号: ${callSite.columnNumber}`);
  });
  // 调用站点 1:
  // 函数名称: exampleFunction
  // 脚本名称: /home/example.js
  // 行号: 5
  // 列号: 26

  // 调用站点 2:
  // 函数名称: anotherFunction
  // 脚本名称: /home/example.js
  // 行号: 22
  // 列号: 3

  // ...
}

// 一个模拟另一个堆栈层的函数
function anotherFunction() {
  exampleFunction();
}

anotherFunction();

import { getCallSites } from 'node:util';

interface Foo {
  foo: string;
}

const callSites = getCallSites({ sourceMap: true });

// 使用 sourceMap:
// 函数名称: ''
// 脚本名称: example.js
// 行号: 7
// 列号: 26

// 不使用 sourceMap:
// 函数名称: ''
// 脚本名称: example.js
// 行号: 2
// 列号: 26

import EventEmitter from 'node:events';

class MyStream extends EventEmitter {
  write(data) {
    this.emit('data', data);
  }
}

const stream = new MyStream();

stream.on('data', (data) => {
  console.log(`接收到的数据: "${data}"`);
});
stream.write('With ES6');

import { inspect } from 'node:util';

const obj = {};
obj.a = [obj];
obj.b = {};
obj.b.inner = obj.b;
obj.b.obj = obj;

console.log(inspect(obj));
// <ref *1> {
//   a: [ [Circular *1] ],
//   b: <ref *2> { inner: [Circular *2], obj: [Circular *1] }
// }

import util from 'node:util';

console.log(util.inspect(util, { showHidden: true, depth: null }));

import { inspect } from 'node:util';

const o = {
  a: [1, 2, [[
    'Lorem ipsum dolor sit amet,\nconsectetur adipiscing elit, sed do ' +
      'eiusmod \ntempor incididunt ut labore et dolore magna aliqua.',
    'test',
    'foo']], 4],
  b: new Map([['za', 1], ['zb', 'test']]),
};
console.log(inspect(o, { compact: true, depth: 5, breakLength: 80 }));

// { a:
//   [ 1,
//     2,
//     [ [ 'Lorem ipsum dolor sit amet,\nconsectetur [...]', // 长行
//           'test',
//           'foo' ] ],
//     4 ],
//   b: Map(2) { 'za' => 1, 'zb' => 'test' } }

// 将 `compact` 设置为 false 或整数会创建更易读的输出。
console.log(inspect(o, { compact: false, depth: 5, breakLength: 80 }));

// {
//   a: [
//     1,
//     2,
//     [
//       [
//         'Lorem ipsum dolor sit amet,\n' +
//           'consectetur adipiscing elit, sed do eiusmod \n' +
//           'tempor incididunt ut labore et dolore magna aliqua.',
//         'test',
//         'foo'
//       ]
//     ],
//     4
//   ],
//   b: Map(2) {
//     'za' => 1,
//     'zb' => 'test'
//   }
// }

// 将 `breakLength` 设置为例如 150 将在单行中打印 "Lorem ipsum" 文本。

import { inspect } from 'node:util';

const obj = { a: 1 };
const obj2 = { b: 2 };
const weakSet = new WeakSet([obj, obj2]);

console.log(inspect(weakSet, { showHidden: true }));
// WeakSet { { a: 1 }, { b: 2 } }

import { inspect } from 'node:util';
import assert from 'node:assert';

const o1 = {
  b: [2, 3, 1],
  a: '`a` comes before `b`',
  c: new Set([2, 3, 1]),
};
console.log(inspect(o1, { sorted: true }));
// { a: '`a` comes before `b`', b: [ 2, 3, 1 ], c: Set(3) { 1, 2, 3 } }
console.log(inspect(o1, { sorted: (a, b) => b.localeCompare(a) }));
// { c: Set(3) { 3, 2, 1 }, b: [ 2, 3, 1 ], a: '`a` comes before `b`' }

const o2 = {
  c: new Set([2, 1, 3]),
  a: '`a` comes before `b`',
  b: [2, 3, 1],
};
assert.strict.equal(
  inspect(o1, { sorted: true }),
  inspect(o2, { sorted: true }),
);

import { inspect } from 'node:util';

const thousand = 1000;
const million = 1000000;
const bigNumber = 123456789n;
const bigDecimal = 1234.12345;

console.log(inspect(thousand, { numericSeparator: true }));
// 1_000
console.log(inspect(million, { numericSeparator: true }));
// 1_000_000
console.log(inspect(bigNumber, { numericSeparator: true }));
// 123_456_789n
console.log(inspect(bigDecimal, { numericSeparator: true }));
// 1_234.123_45

import { inspect } from 'node:util';

class Box {
  constructor(value) {
    this.value = value;
  }

  [inspect.custom](depth, options, inspect) {
    if (depth < 0) {
      return options.stylize('[Box]', 'special');
    }

    const newOptions = Object.assign({}, options, {
      depth: options.depth === null ? null : options.depth - 1,
    });

    // 五个空格填充，因为那是 "Box< " 的大小。
    const padding = ' '.repeat(5);
    const inner = inspect(this.value, newOptions)
                  .replace(/\n/g, `\n${padding}`);
    return `${options.stylize('Box', 'special')}< ${inner} >`;
  }
}

const box = new Box(true);

console.log(inspect(box));
// "Box< true >"

import { inspect } from 'node:util';

const obj = { foo: 'this will not show up in the inspect() output' };
obj[inspect.custom] = (depth) => {
  return { bar: 'baz' };
};

console.log(inspect(obj));
// "{ bar: 'baz' }"

import { inspect } from 'node:util';
const arr = Array(156).fill(0);

console.log(arr); // 记录被截断的数组
inspect.defaultOptions.maxArrayLength = null;
console.log(arr); // 记录完整数组

import { MIMEType } from 'node:util';

const myMIME = new MIMEType('text/plain');

import { MIMEType } from 'node:util';
const myMIME = new MIMEType({ toString: () => 'text/plain' });
console.log(String(myMIME));
// 输出：text/plain

import { MIMEType } from 'node:util';

const myMIME = new MIMEType('text/javascript');
console.log(myMIME.type);
// 输出：text
myMIME.type = 'application';
console.log(myMIME.type);
// 输出：application
console.log(String(myMIME));
// 输出：application/javascript

import { MIMEType } from 'node:util';

const myMIME = new MIMEType('text/ecmascript');
console.log(myMIME.subtype);
// 输出：ecmascript
myMIME.subtype = 'javascript';
console.log(myMIME.subtype);
// 输出：javascript
console.log(String(myMIME));
// 输出：text/javascript

import { MIMEType } from 'node:util';

const myMIME = new MIMEType('text/javascript;key=value');
console.log(myMIME.essence);
// 输出：text/javascript
myMIME.type = 'application';
console.log(myMIME.essence);
// 输出：application/javascript
console.log(String(myMIME));
// 输出：application/javascript;key=value

import { MIMEType } from 'node:util';

const myMIMES = [
  new MIMEType('image/png'),
  new MIMEType('image/gif'),
];
console.log(JSON.stringify(myMIMES));
// 输出：["image/png", "image/gif"]

import { MIMEParams } from 'node:util';

const myParams = new MIMEParams();

import { MIMEType } from 'node:util';

const { params } = new MIMEType('text/plain;foo=0;bar=1');
for (const name of params.keys()) {
  console.log(name);
}
// 输出：
//   foo
//   bar

import { MIMEType } from 'node:util';

const { params } = new MIMEType('text/plain;foo=0;bar=1');
params.set('foo', 'def');
params.set('baz', 'xyz');
console.log(params.toString());
// 输出：foo=def;bar=1;baz=xyz

import { MIMEType } from 'node:util';

const { params } = new MIMEType('text/plain;foo=bar;xyz=baz');
for (const [name, value] of params) {
  console.log(name, value);
}
// 输出：
//   foo bar
//   xyz baz

import { parseArgs } from 'node:util';
const args = ['-f', '--bar', 'b'];
const options = {
  foo: {
    type: 'boolean',
    short: 'f',
  },
  bar: {
    type: 'string',
  },
};
const {
  values,
  positionals,
} = parseArgs({ args, options });
console.log(values, positionals);
// 输出：[Object: null prototype] { foo: true, bar: 'b' } []

import { parseArgs } from 'node:util';

const options = {
  'color': { type: 'boolean' },
  'no-color': { type: 'boolean' },
  'logfile': { type: 'string' },
  'no-logfile': { type: 'boolean' },
};
const { values, tokens } = parseArgs({ options, tokens: true });

// 重新处理选项令牌并覆盖返回的值。
tokens
  .filter((token) => token.kind === 'option')
  .forEach((token) => {
    if (token.name.startsWith('no-')) {
      // 为 --no-foo 存储 foo:false
      const positiveName = token.name.slice(3);
      values[positiveName] = false;
      delete values[token.name];
    } else {
      // 重新保存值，以便如果同时存在 --foo 和 --no-foo，则最后一个生效。
      values[token.name] = token.value ?? true;
    }
  });

const color = values.color;
const logfile = values.logfile ?? 'default.log';

console.log({ logfile, color });

const { parseEnv } = require('node:util');

parseEnv('HELLO=world\nHELLO=oh my\n');
// 返回：{ HELLO: 'oh my' }

import { promisify } from 'node:util';
import { stat } from 'node:fs';

const promisifiedStat = promisify(stat);
promisifiedStat('.').then((stats) => {
  // 对 `stats` 做一些事情
}).catch((error) => {
  // 处理错误。
});

import { promisify } from 'node:util';
import { stat } from 'node:fs';

const promisifiedStat = promisify(stat);

async function callStat() {
  const stats = await promisifiedStat('.');
  console.log(`此目录归属于 ${stats.uid}`);
}

callStat();

import { promisify } from 'node:util';

class Foo {
  constructor() {
    this.a = 42;
  }

  bar(callback) {
    callback(null, this.a);
  }
}

const foo = new Foo();

const naiveBar = promisify(foo.bar);
// TypeError: 无法读取 undefined 的属性 (读取 'a')
// naiveBar().then(a => console.log(a));

naiveBar.call(foo).then((a) => console.log(a)); // '42'

const bindBar = naiveBar.bind(foo);
bindBar().then((a) => console.log(a)); // '42'

import { styleText } from 'node:util';
import { stderr } from 'node:process';

const successMessage = styleText('green', 'Success!');
console.log(successMessage);

const errorMessage = styleText(
  'red',
  'Error! Error!',
  // 验证 process.stderr 是否有 TTY
  { stream: stderr },
);
console.error(errorMessage);

import { styleText } from 'node:util';

// 6 位十六进制颜色
console.log(styleText('#ff5733', 'Orange text'));

// 3 位十六进制颜色（简写）
console.log(styleText('#f00', 'Red text'));

const { aborted } = require('node:util');

// 获取一个带有可中止信号的对象，例如自定义资源或操作。
const dependent = obtainSomethingAbortable();

// 将 `dependent` 作为资源传递，表示 promise 应该只在
// 信号中止时 `dependent` 仍在内存中才解析。
aborted(dependent.signal, dependent).then(() => {

  // 当 `dependent` 被中止时运行此代码。
  console.log('Dependent resource was aborted.');
});

// 模拟触发中止的事件。
dependent.on('event', () => {
  dependent.abort(); // 这将导致 `aborted` promise 解析。
});

#include <js_native_api.h>
#include <stdlib.h>
napi_value result;
static napi_value MyNapi(struct napi_env env, napi_callback_info info) {
  int* raw = (int*) malloc(1024);
  napi_status status = napi_create_external(env, (void*) raw, NULL, NULL, &result);
  if (status != napi_ok) {
    napi_throw_error(env, NULL, "napi_create_external failed");
    return NULL;
  }
  return result;
}
...
DECLARE_NAPI_PROPERTY("myNapi", MyNapi)
...