@nocobase/plugin-idp-oauth 2.1.0-alpha.10

package/dist/node_modules/light-my-request/node_modules/process-warning/benchmarks/warn.js

@@ -0,0 +1,25 @@
+'use strict'
+
+const { Suite } = require('benchmark')
+const { createWarning } = require('..')
+
+const err1 = createWarning({
+  name: 'TestWarning',
+  code: 'TST_ERROR_CODE_1',
+  message: 'message'
+})
+const err2 = createWarning({
+  name: 'TestWarning',
+  code: 'TST_ERROR_CODE_2',
+  message: 'message'
+})
+
+new Suite()
+  .add('warn', function () {
+    err1()
+    err2()
+  })
+  .on('cycle', function (event) {
+    console.log(String(event.target))
+  })
+  .run()

package/dist/node_modules/light-my-request/node_modules/process-warning/eslint.config.js

@@ -0,0 +1,6 @@
+'use strict'
+
+module.exports = require('neostandard')({
+  ignores: require('neostandard').resolveIgnoresFromGitignore(),
+  ts: true
+})

package/dist/node_modules/light-my-request/node_modules/process-warning/examples/example.js

@@ -0,0 +1,11 @@
+'use strict'
+
+const { createWarning } = require('..')
+
+const CUSTDEP001 = createWarning({
+  name: 'DeprecationWarning',
+  code: 'CUSTDEP001',
+  message: 'This is a deprecation warning'
+})
+
+CUSTDEP001()

package/dist/node_modules/light-my-request/node_modules/process-warning/index.js

@@ -0,0 +1,124 @@
+'use strict'
+
+const { format } = require('node:util')
+
+/**
+ * @namespace processWarning
+ */
+
+/**
+ * Represents a warning item with details.
+ * @typedef {Function} WarningItem
+ * @param {*} [a] Possible message interpolation value.
+ * @param {*} [b] Possible message interpolation value.
+ * @param {*} [c] Possible message interpolation value.
+ * @property {string} name - The name of the warning.
+ * @property {string} code - The code associated with the warning.
+ * @property {string} message - The warning message.
+ * @property {boolean} emitted - Indicates if the warning has been emitted.
+ * @property {function} format - Formats the warning message.
+ */
+
+/**
+ * Options for creating a process warning.
+ * @typedef {Object} ProcessWarningOptions
+ * @property {string} name - The name of the warning.
+ * @property {string} code - The code associated with the warning.
+ * @property {string} message - The warning message.
+ * @property {boolean} [unlimited=false] - If true, allows unlimited emissions of the warning.
+ */
+
+/**
+ * Represents the process warning functionality.
+ * @typedef {Object} ProcessWarning
+ * @property {function} createWarning - Creates a warning item.
+ * @property {function} createDeprecation - Creates a deprecation warning item.
+ */
+
+/**
+ * Creates a deprecation warning item.
+ * @function
+ * @memberof processWarning
+ * @param {ProcessWarningOptions} params - Options for creating the warning.
+ * @returns {WarningItem} The created deprecation warning item.
+ */
+function createDeprecation (params) {
+  return createWarning({ ...params, name: 'DeprecationWarning' })
+}
+
+/**
+ * Creates a warning item.
+ * @function
+ * @memberof processWarning
+ * @param {ProcessWarningOptions} params - Options for creating the warning.
+ * @returns {WarningItem} The created warning item.
+ * @throws {Error} Throws an error if name, code, or message is empty, or if opts.unlimited is not a boolean.
+ */
+function createWarning ({ name, code, message, unlimited = false } = {}) {
+  if (!name) throw new Error('Warning name must not be empty')
+  if (!code) throw new Error('Warning code must not be empty')
+  if (!message) throw new Error('Warning message must not be empty')
+  if (typeof unlimited !== 'boolean') throw new Error('Warning opts.unlimited must be a boolean')
+
+  code = code.toUpperCase()
+
+  let warningContainer = {
+    [name]: function (a, b, c) {
+      if (warning.emitted === true && warning.unlimited !== true) {
+        return
+      }
+      warning.emitted = true
+      process.emitWarning(warning.format(a, b, c), warning.name, warning.code)
+    }
+  }
+  if (unlimited) {
+    warningContainer = {
+      [name]: function (a, b, c) {
+        warning.emitted = true
+        process.emitWarning(warning.format(a, b, c), warning.name, warning.code)
+      }
+    }
+  }
+
+  const warning = warningContainer[name]
+
+  warning.emitted = false
+  warning.message = message
+  warning.unlimited = unlimited
+  warning.code = code
+
+  /**
+   * Formats the warning message.
+   * @param {*} [a] Possible message interpolation value.
+   * @param {*} [b] Possible message interpolation value.
+   * @param {*} [c] Possible message interpolation value.
+   * @returns {string} The formatted warning message.
+   */
+  warning.format = function (a, b, c) {
+    let formatted
+    if (a && b && c) {
+      formatted = format(message, a, b, c)
+    } else if (a && b) {
+      formatted = format(message, a, b)
+    } else if (a) {
+      formatted = format(message, a)
+    } else {
+      formatted = message
+    }
+    return formatted
+  }
+
+  return warning
+}
+
+/**
+ * Module exports containing the process warning functionality.
+ * @namespace
+ * @property {function} createWarning - Creates a warning item.
+ * @property {function} createDeprecation - Creates a deprecation warning item.
+ * @property {ProcessWarning} processWarning - Represents the process warning functionality.
+ */
+const out = { createWarning, createDeprecation }
+module.exports = out
+module.exports.default = out
+module.exports.processWarning = out

package/dist/node_modules/light-my-request/node_modules/process-warning/package.json

@@ -0,0 +1,73 @@
+{
+  "name": "process-warning",
+  "version": "4.0.1",
+  "description": "A small utility for creating warnings and emitting them.",
+  "main": "index.js",
+  "type": "commonjs",
+  "types": "types/index.d.ts",
+  "scripts": {
+    "lint": "eslint",
+    "lint:fix": "eslint --fix",
+    "test": "npm run test:unit && npm run test:jest && npm run test:typescript",
+    "test:jest": "jest jest.test.js",
+    "test:unit": "tap",
+    "test:typescript": "tsd"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/fastify/process-warning.git"
+  },
+  "keywords": [
+    "fastify",
+    "error",
+    "warning",
+    "utility",
+    "plugin",
+    "emit",
+    "once"
+  ],
+  "author": "Tomas Della Vedova",
+  "contributors": [
+    {
+      "name": "Matteo Collina",
+      "email": "hello@matteocollina.com"
+    },
+    {
+      "name": "Manuel Spigolon",
+      "email": "behemoth89@gmail.com"
+    },
+    {
+      "name": "James Sumners",
+      "url": "https://james.sumners.info"
+    },
+    {
+      "name": "Frazer Smith",
+      "email": "frazer.dev@icloud.com",
+      "url": "https://github.com/fdawgs"
+    }
+  ],
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/fastify/fastify-warning/issues"
+  },
+  "homepage": "https://github.com/fastify/fastify-warning#readme",
+  "funding": [
+    {
+      "type": "github",
+      "url": "https://github.com/sponsors/fastify"
+    },
+    {
+      "type": "opencollective",
+      "url": "https://opencollective.com/fastify"
+    }
+  ],
+  "devDependencies": {
+    "@fastify/pre-commit": "^2.1.0",
+    "benchmark": "^2.1.4",
+    "eslint": "^9.17.0",
+    "jest": "^29.7.0",
+    "neostandard": "^0.12.0",
+    "tap": "^18.7.2",
+    "tsd": "^0.31.0"
+  }
+}

package/dist/node_modules/light-my-request/node_modules/process-warning/test/emit-interpolated-string.test.js

@@ -0,0 +1,29 @@
+'use strict'
+
+const test = require('tap').test
+const { createWarning } = require('..')
+
+test('emit with interpolated string', t => {
+  t.plan(4)
+
+  process.on('warning', onWarning)
+  function onWarning (warning) {
+    t.equal(warning.name, 'TestDeprecation')
+    t.equal(warning.code, 'CODE')
+    t.equal(warning.message, 'Hello world')
+    t.ok(codeWarning.emitted)
+  }
+
+  const codeWarning = createWarning({
+    name: 'TestDeprecation',
+    code: 'CODE',
+    message: 'Hello %s'
+  })
+  codeWarning('world')
+  codeWarning('world')
+
+  setImmediate(() => {
+    process.removeListener('warning', onWarning)
+    t.end()
+  })
+})

package/dist/node_modules/light-my-request/node_modules/process-warning/test/emit-once-only.test.js

@@ -0,0 +1,28 @@
+'use strict'
+
+const test = require('tap').test
+const { createWarning } = require('..')
+
+test('emit should emit a given code only once', t => {
+  t.plan(4)
+
+  process.on('warning', onWarning)
+  function onWarning (warning) {
+    t.equal(warning.name, 'TestDeprecation')
+    t.equal(warning.code, 'CODE')
+    t.equal(warning.message, 'Hello world')
+    t.ok(warn.emitted)
+  }
+
+  const warn = createWarning({
+    name: 'TestDeprecation',
+    code: 'CODE',
+    message: 'Hello world'
+  })
+  warn()
+  warn()
+  setImmediate(() => {
+    process.removeListener('warning', onWarning)
+    t.end()
+  })
+})

package/dist/node_modules/light-my-request/node_modules/process-warning/test/emit-reset.test.js

@@ -0,0 +1,36 @@
+'use strict'
+
+const test = require('tap').test
+const { createWarning } = require('../')
+
+test('a limited warning can be re-set', t => {
+  t.plan(4)
+
+  let count = 0
+  process.on('warning', onWarning)
+  function onWarning () {
+    count++
+  }
+
+  const warn = createWarning({
+    name: 'TestDeprecation',
+    code: 'CODE',
+    message: 'Hello world'
+  })
+
+  warn()
+  t.ok(warn.emitted)
+
+  warn()
+  t.ok(warn.emitted)
+
+  warn.emitted = false
+  warn()
+  t.ok(warn.emitted)
+
+  setImmediate(() => {
+    t.equal(count, 2)
+    process.removeListener('warning', onWarning)
+    t.end()
+  })
+})

package/dist/node_modules/light-my-request/node_modules/process-warning/test/emit-set.test.js

@@ -0,0 +1,30 @@
+'use strict'
+
+const test = require('tap').test
+const { createWarning } = require('../')
+
+test('emit should set the emitted state', t => {
+  t.plan(3)
+
+  process.on('warning', onWarning)
+  function onWarning () {
+    t.fail('should not be called')
+  }
+
+  const warn = createWarning({
+    name: 'TestDeprecation',
+    code: 'CODE',
+    message: 'Hello world'
+  })
+  t.notOk(warn.emitted)
+  warn.emitted = true
+  t.ok(warn.emitted)
+
+  warn()
+  t.ok(warn.emitted)
+
+  setImmediate(() => {
+    process.removeListener('warning', onWarning)
+    t.end()
+  })
+})

package/dist/node_modules/light-my-request/node_modules/process-warning/test/emit-unlimited.test.js

@@ -0,0 +1,37 @@
+'use strict'
+
+const test = require('tap').test
+const { createWarning } = require('..')
+
+test('emit should emit a given code unlimited times', t => {
+  t.plan(50)
+
+  let runs = 0
+  const expectedRun = []
+  const times = 10
+
+  process.on('warning', onWarning)
+  function onWarning (warning) {
+    t.equal(warning.name, 'TestDeprecation')
+    t.equal(warning.code, 'CODE')
+    t.equal(warning.message, 'Hello world')
+    t.ok(warn.emitted)
+    t.equal(runs++, expectedRun.shift())
+  }
+
+  const warn = createWarning({
+    name: 'TestDeprecation',
+    code: 'CODE',
+    message: 'Hello world',
+    unlimited: true
+  })
+
+  for (let i = 0; i < times; i++) {
+    expectedRun.push(i)
+    warn()
+  }
+  setImmediate(() => {
+    process.removeListener('warning', onWarning)
+    t.end()
+  })
+})

package/dist/node_modules/light-my-request/node_modules/process-warning/test/index.test.js

@@ -0,0 +1,99 @@
+'use strict'
+
+const test = require('tap').test
+const { createWarning, createDeprecation } = require('..')
+
+process.removeAllListeners('warning')
+
+test('Create warning with zero parameter', t => {
+  t.plan(3)
+
+  const warnItem = createWarning({
+    name: 'TestWarning',
+    code: 'CODE',
+    message: 'Not available'
+  })
+  t.equal(warnItem.name, 'TestWarning')
+  t.equal(warnItem.message, 'Not available')
+  t.equal(warnItem.code, 'CODE')
+})
+
+test('Create error with 1 parameter', t => {
+  t.plan(3)
+
+  const warnItem = createWarning({
+    name: 'TestWarning',
+    code: 'CODE',
+    message: 'hey %s'
+  })
+  t.equal(warnItem.name, 'TestWarning')
+  t.equal(warnItem.format('alice'), 'hey alice')
+  t.equal(warnItem.code, 'CODE')
+})
+
+test('Create error with 2 parameters', t => {
+  t.plan(3)
+
+  const warnItem = createWarning({
+    name: 'TestWarning',
+    code: 'CODE',
+    message: 'hey %s, I like your %s'
+  })
+  t.equal(warnItem.name, 'TestWarning')
+  t.equal(warnItem.format('alice', 'attitude'), 'hey alice, I like your attitude')
+  t.equal(warnItem.code, 'CODE')
+})
+
+test('Create error with 3 parameters', t => {
+  t.plan(3)
+
+  const warnItem = createWarning({
+    name: 'TestWarning',
+    code: 'CODE',
+    message: 'hey %s, I like your %s %s'
+  })
+  t.equal(warnItem.name, 'TestWarning')
+  t.equal(warnItem.format('alice', 'attitude', 'see you'), 'hey alice, I like your attitude see you')
+  t.equal(warnItem.code, 'CODE')
+})
+
+test('Creates a deprecation warning', t => {
+  t.plan(3)
+
+  const deprecationItem = createDeprecation({
+    name: 'DeprecationWarning',
+    code: 'CODE',
+    message: 'hello %s'
+  })
+  t.equal(deprecationItem.name, 'DeprecationWarning')
+  t.equal(deprecationItem.format('world'), 'hello world')
+  t.equal(deprecationItem.code, 'CODE')
+})
+
+test('Should throw when error code has no name', t => {
+  t.plan(1)
+  t.throws(() => createWarning(), new Error('Warning name must not be empty'))
+})
+
+test('Should throw when error has no code', t => {
+  t.plan(1)
+  t.throws(() => createWarning({ name: 'name' }), new Error('Warning code must not be empty'))
+})
+
+test('Should throw when error has no message', t => {
+  t.plan(1)
+  t.throws(() => createWarning({
+    name: 'name',
+    code: 'code'
+  }), new Error('Warning message must not be empty'))
+})
+
+test('Cannot set unlimited other than boolean', t => {
+  t.plan(1)
+  t.throws(() => createWarning({
+    name: 'name',
+    code: 'code',
+    message: 'message',
+    unlimited: 'unlimited'
+  }), new Error('Warning opts.unlimited must be a boolean'))
+})

package/dist/node_modules/light-my-request/node_modules/process-warning/test/issue-88.test.js

@@ -0,0 +1,33 @@
+'use strict'
+
+const { test } = require('tap')
+const { createWarning } = require('..')
+
+test('Must not overwrite config', t => {
+  t.plan(1)
+
+  function onWarning (warning) {
+    t.equal(warning.code, 'CODE_1')
+  }
+
+  const a = createWarning({
+    name: 'TestWarning',
+    code: 'CODE_1',
+    message: 'Msg'
+  })
+  createWarning({
+    name: 'TestWarning',
+    code: 'CODE_2',
+    message: 'Msg',
+    unlimited: true
+  })
+
+  process.on('warning', onWarning)
+  a('CODE_1')
+  a('CODE_1')
+
+  setImmediate(() => {
+    process.removeListener('warning', onWarning)
+    t.end()
+  })
+})

package/dist/node_modules/light-my-request/node_modules/process-warning/test/jest.test.js

@@ -0,0 +1,22 @@
+/* global test, expect */
+'use strict'
+
+const { createWarning } = require('..')
+
+test('works with jest', done => {
+  const code = createWarning({
+    name: 'TestDeprecation',
+    code: 'CODE',
+    message: 'Hello world'
+  })
+  code('world')
+
+  // we cannot actually listen to process warning event
+  // because jest messes with it (that's the point of this test)
+  // we can only test it was emitted indirectly
+  // and test no exception is raised
+  setImmediate(() => {
+    expect(code.emitted).toBeTruthy()
+    done()
+  })
+})

package/dist/node_modules/light-my-request/node_modules/process-warning/test/no-warnings.test.js

@@ -0,0 +1,80 @@
+'use strict'
+
+const { test } = require('tap')
+const { spawnSync } = require('node:child_process')
+const { resolve } = require('node:path')
+
+const entry = resolve(__dirname, '../examples', 'example.js')
+
+test('--no-warnings is set in cli', t => {
+  t.plan(1)
+  const child = spawnSync(process.execPath, [
+    '--no-warnings',
+    entry
+  ])
+
+  const stderr = child.stderr.toString()
+  t.equal(stderr, '')
+})
+
+test('--no-warnings is not set in cli', t => {
+  t.plan(1)
+  const child = spawnSync(process.execPath, [
+    entry
+  ])
+
+  const stderr = child.stderr.toString()
+  t.match(stderr, /\[CUSTDEP001\] DeprecationWarning: This is a deprecation warning/)
+})
+
+test('NODE_NO_WARNINGS is set to 1', t => {
+  t.plan(1)
+  const child = spawnSync(process.execPath, [
+    entry
+  ], {
+    env: {
+      NODE_NO_WARNINGS: '1'
+    }
+  })
+
+  const stderr = child.stderr.toString()
+  t.equal(stderr, '')
+})
+
+test('NODE_NO_WARNINGS is set to 0', t => {
+  t.plan(1)
+  const child = spawnSync(process.execPath, [
+    entry
+  ], {
+    env: {
+      NODE_NO_WARNINGS: '0'
+    }
+  })
+
+  const stderr = child.stderr.toString()
+  t.match(stderr, /\[CUSTDEP001\] DeprecationWarning: This is a deprecation warning/)
+})
+
+test('NODE_NO_WARNINGS is not set', t => {
+  t.plan(1)
+  const child = spawnSync(process.execPath, [
+    entry
+  ])
+
+  const stderr = child.stderr.toString()
+  t.match(stderr, /\[CUSTDEP001\] DeprecationWarning: This is a deprecation warning/)
+})
+
+test('NODE_Options contains --no-warnings', t => {
+  t.plan(1)
+  const child = spawnSync(process.execPath, [
+    entry
+  ], {
+    env: {
+      NODE_OPTIONS: '--no-warnings'
+    }
+  })
+
+  const stderr = child.stderr.toString()
+  t.equal(stderr, '')
+})

package/dist/node_modules/light-my-request/node_modules/process-warning/types/index.d.ts

@@ -0,0 +1,37 @@
+declare namespace processWarning {
+  export interface WarningItem {
+    (a?: any, b?: any, c?: any): void;
+    name: string;
+    code: string;
+    message: string;
+    emitted: boolean;
+    unlimited: boolean;
+    format(a?: any, b?: any, c?: any): string;
+  }
+
+  export type WarningOptions = {
+    name: string;
+    code: string;
+    message: string;
+    unlimited?: boolean;
+  }
+
+  export type DeprecationOptions = Omit<WarningOptions, 'name'>
+
+  export type ProcessWarningOptions = {
+    unlimited?: boolean;
+  }
+
+  export type ProcessWarning = {
+    createWarning(params: WarningOptions): WarningItem;
+    createDeprecation(params: DeprecationOptions): WarningItem;
+  }
+
+  export function createWarning (params: WarningOptions): WarningItem
+  export function createDeprecation (params: DeprecationOptions): WarningItem
+
+  const processWarning: ProcessWarning
+  export { processWarning as default }
+}
+
+export = processWarning