@highstate/designer 0.4.5 → 0.4.6

package/.output/server/node_modules/pino-abstract-transport/package.json

@@ -1,40 +0,0 @@
-{
-  "name": "pino-abstract-transport",
-  "version": "2.0.0",
-  "description": "Write Pino transports easily",
-  "main": "index.js",
-  "scripts": {
-    "prepare": "husky install",
-    "test": "standard | snazzy && tap test/*.test.js  && tsd",
-    "test-ci": "standard | snazzy && tap test/*.test.js --coverage-report=lcovonly && tsd"
-  },
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/pinojs/pino-abstract-transport.git"
-  },
-  "keywords": [
-    "pino",
-    "transport"
-  ],
-  "author": "Matteo Collina <hello@matteocollina.com>",
-  "license": "MIT",
-  "bugs": {
-    "url": "https://github.com/pinojs/pino-abstract-transport/issues"
-  },
-  "homepage": "https://github.com/pinojs/pino-abstract-transport#readme",
-  "dependencies": {
-    "split2": "^4.0.0"
-  },
-  "devDependencies": {
-    "@types/node": "^20.1.0",
-    "husky": "^9.0.6",
-    "snazzy": "^9.0.0",
-    "standard": "^17.0.0",
-    "tap": "^16.0.0",
-    "thread-stream": "^2.6.0",
-    "tsd": "^0.31.0"
-  },
-  "tsd": {
-    "directory": "./test/types"
-  }
-}

package/.output/server/node_modules/pino-std-serializers/index.js

@@ -1,36 +0,0 @@
-'use strict'
-
-const errSerializer = require('./lib/err')
-const errWithCauseSerializer = require('./lib/err-with-cause')
-const reqSerializers = require('./lib/req')
-const resSerializers = require('./lib/res')
-
-module.exports = {
-  err: errSerializer,
-  errWithCause: errWithCauseSerializer,
-  mapHttpRequest: reqSerializers.mapHttpRequest,
-  mapHttpResponse: resSerializers.mapHttpResponse,
-  req: reqSerializers.reqSerializer,
-  res: resSerializers.resSerializer,
-
-  wrapErrorSerializer: function wrapErrorSerializer (customSerializer) {
-    if (customSerializer === errSerializer) return customSerializer
-    return function wrapErrSerializer (err) {
-      return customSerializer(errSerializer(err))
-    }
-  },
-
-  wrapRequestSerializer: function wrapRequestSerializer (customSerializer) {
-    if (customSerializer === reqSerializers.reqSerializer) return customSerializer
-    return function wrappedReqSerializer (req) {
-      return customSerializer(reqSerializers.reqSerializer(req))
-    }
-  },
-
-  wrapResponseSerializer: function wrapResponseSerializer (customSerializer) {
-    if (customSerializer === resSerializers.resSerializer) return customSerializer
-    return function wrappedResSerializer (res) {
-      return customSerializer(resSerializers.resSerializer(res))
-    }
-  }
-}

package/.output/server/node_modules/pino-std-serializers/lib/err-helpers.js

@@ -1,118 +0,0 @@
-'use strict'
-
-// **************************************************************
-// * Code initially copied/adapted from "pony-cause" npm module *
-// * Please upstream improvements there                         *
-// **************************************************************
-
-const isErrorLike = (err) => {
-  return err && typeof err.message === 'string'
-}
-
-/**
- * @param {Error|{ cause?: unknown|(()=>err)}} err
- * @returns {Error|Object|undefined}
- */
-const getErrorCause = (err) => {
-  if (!err) return
-
-  /** @type {unknown} */
-  // @ts-ignore
-  const cause = err.cause
-
-  // VError / NError style causes
-  if (typeof cause === 'function') {
-    // @ts-ignore
-    const causeResult = err.cause()
-
-    return isErrorLike(causeResult)
-      ? causeResult
-      : undefined
-  } else {
-    return isErrorLike(cause)
-      ? cause
-      : undefined
-  }
-}
-
-/**
- * Internal method that keeps a track of which error we have already added, to avoid circular recursion
- *
- * @private
- * @param {Error} err
- * @param {Set<Error>} seen
- * @returns {string}
- */
-const _stackWithCauses = (err, seen) => {
-  if (!isErrorLike(err)) return ''
-
-  const stack = err.stack || ''
-
-  // Ensure we don't go circular or crazily deep
-  if (seen.has(err)) {
-    return stack + '\ncauses have become circular...'
-  }
-
-  const cause = getErrorCause(err)
-
-  if (cause) {
-    seen.add(err)
-    return (stack + '\ncaused by: ' + _stackWithCauses(cause, seen))
-  } else {
-    return stack
-  }
-}
-
-/**
- * @param {Error} err
- * @returns {string}
- */
-const stackWithCauses = (err) => _stackWithCauses(err, new Set())
-
-/**
- * Internal method that keeps a track of which error we have already added, to avoid circular recursion
- *
- * @private
- * @param {Error} err
- * @param {Set<Error>} seen
- * @param {boolean} [skip]
- * @returns {string}
- */
-const _messageWithCauses = (err, seen, skip) => {
-  if (!isErrorLike(err)) return ''
-
-  const message = skip ? '' : (err.message || '')
-
-  // Ensure we don't go circular or crazily deep
-  if (seen.has(err)) {
-    return message + ': ...'
-  }
-
-  const cause = getErrorCause(err)
-
-  if (cause) {
-    seen.add(err)
-
-    // @ts-ignore
-    const skipIfVErrorStyleCause = typeof err.cause === 'function'
-
-    return (message +
-      (skipIfVErrorStyleCause ? '' : ': ') +
-      _messageWithCauses(cause, seen, skipIfVErrorStyleCause))
-  } else {
-    return message
-  }
-}
-
-/**
- * @param {Error} err
- * @returns {string}
- */
-const messageWithCauses = (err) => _messageWithCauses(err, new Set())
-
-module.exports = {
-  isErrorLike,
-  getErrorCause,
-  stackWithCauses,
-  messageWithCauses
-}

package/.output/server/node_modules/pino-std-serializers/lib/err-proto.js

@@ -1,48 +0,0 @@
-'use strict'
-
-const seen = Symbol('circular-ref-tag')
-const rawSymbol = Symbol('pino-raw-err-ref')
-
-const pinoErrProto = Object.create({}, {
-  type: {
-    enumerable: true,
-    writable: true,
-    value: undefined
-  },
-  message: {
-    enumerable: true,
-    writable: true,
-    value: undefined
-  },
-  stack: {
-    enumerable: true,
-    writable: true,
-    value: undefined
-  },
-  aggregateErrors: {
-    enumerable: true,
-    writable: true,
-    value: undefined
-  },
-  raw: {
-    enumerable: false,
-    get: function () {
-      return this[rawSymbol]
-    },
-    set: function (val) {
-      this[rawSymbol] = val
-    }
-  }
-})
-Object.defineProperty(pinoErrProto, rawSymbol, {
-  writable: true,
-  value: {}
-})
-
-module.exports = {
-  pinoErrProto,
-  pinoErrorSymbols: {
-    seen,
-    rawSymbol
-  }
-}

package/.output/server/node_modules/pino-std-serializers/lib/err-with-cause.js

@@ -1,48 +0,0 @@
-'use strict'
-
-module.exports = errWithCauseSerializer
-
-const { isErrorLike } = require('./err-helpers')
-const { pinoErrProto, pinoErrorSymbols } = require('./err-proto')
-const { seen } = pinoErrorSymbols
-
-const { toString } = Object.prototype
-
-function errWithCauseSerializer (err) {
-  if (!isErrorLike(err)) {
-    return err
-  }
-
-  err[seen] = undefined // tag to prevent re-looking at this
-  const _err = Object.create(pinoErrProto)
-  _err.type = toString.call(err.constructor) === '[object Function]'
-    ? err.constructor.name
-    : err.name
-  _err.message = err.message
-  _err.stack = err.stack
-
-  if (Array.isArray(err.errors)) {
-    _err.aggregateErrors = err.errors.map(err => errWithCauseSerializer(err))
-  }
-
-  if (isErrorLike(err.cause) && !Object.prototype.hasOwnProperty.call(err.cause, seen)) {
-    _err.cause = errWithCauseSerializer(err.cause)
-  }
-
-  for (const key in err) {
-    if (_err[key] === undefined) {
-      const val = err[key]
-      if (isErrorLike(val)) {
-        if (!Object.prototype.hasOwnProperty.call(val, seen)) {
-          _err[key] = errWithCauseSerializer(val)
-        }
-      } else {
-        _err[key] = val
-      }
-    }
-  }
-
-  delete err[seen] // clean up tag in case err is serialized again later
-  _err.raw = err
-  return _err
-}

package/.output/server/node_modules/pino-std-serializers/lib/err.js

@@ -1,45 +0,0 @@
-'use strict'
-
-module.exports = errSerializer
-
-const { messageWithCauses, stackWithCauses, isErrorLike } = require('./err-helpers')
-const { pinoErrProto, pinoErrorSymbols } = require('./err-proto')
-const { seen } = pinoErrorSymbols
-
-const { toString } = Object.prototype
-
-function errSerializer (err) {
-  if (!isErrorLike(err)) {
-    return err
-  }
-
-  err[seen] = undefined // tag to prevent re-looking at this
-  const _err = Object.create(pinoErrProto)
-  _err.type = toString.call(err.constructor) === '[object Function]'
-    ? err.constructor.name
-    : err.name
-  _err.message = messageWithCauses(err)
-  _err.stack = stackWithCauses(err)
-
-  if (Array.isArray(err.errors)) {
-    _err.aggregateErrors = err.errors.map(err => errSerializer(err))
-  }
-
-  for (const key in err) {
-    if (_err[key] === undefined) {
-      const val = err[key]
-      if (isErrorLike(val)) {
-        // We append cause messages and stacks to _err, therefore skipping causes here
-        if (key !== 'cause' && !Object.prototype.hasOwnProperty.call(val, seen)) {
-          _err[key] = errSerializer(val)
-        }
-      } else {
-        _err[key] = val
-      }
-    }
-  }
-
-  delete err[seen] // clean up tag in case err is serialized again later
-  _err.raw = err
-  return _err
-}

package/.output/server/node_modules/pino-std-serializers/lib/req.js

@@ -1,100 +0,0 @@
-'use strict'
-
-module.exports = {
-  mapHttpRequest,
-  reqSerializer
-}
-
-const rawSymbol = Symbol('pino-raw-req-ref')
-const pinoReqProto = Object.create({}, {
-  id: {
-    enumerable: true,
-    writable: true,
-    value: ''
-  },
-  method: {
-    enumerable: true,
-    writable: true,
-    value: ''
-  },
-  url: {
-    enumerable: true,
-    writable: true,
-    value: ''
-  },
-  query: {
-    enumerable: true,
-    writable: true,
-    value: ''
-  },
-  params: {
-    enumerable: true,
-    writable: true,
-    value: ''
-  },
-  headers: {
-    enumerable: true,
-    writable: true,
-    value: {}
-  },
-  remoteAddress: {
-    enumerable: true,
-    writable: true,
-    value: ''
-  },
-  remotePort: {
-    enumerable: true,
-    writable: true,
-    value: ''
-  },
-  raw: {
-    enumerable: false,
-    get: function () {
-      return this[rawSymbol]
-    },
-    set: function (val) {
-      this[rawSymbol] = val
-    }
-  }
-})
-Object.defineProperty(pinoReqProto, rawSymbol, {
-  writable: true,
-  value: {}
-})
-
-function reqSerializer (req) {
-  // req.info is for hapi compat.
-  const connection = req.info || req.socket
-  const _req = Object.create(pinoReqProto)
-  _req.id = (typeof req.id === 'function' ? req.id() : (req.id || (req.info ? req.info.id : undefined)))
-  _req.method = req.method
-  // req.originalUrl is for expressjs compat.
-  if (req.originalUrl) {
-    _req.url = req.originalUrl
-  } else {
-    const path = req.path
-    // path for safe hapi compat.
-    _req.url = typeof path === 'string' ? path : (req.url ? req.url.path || req.url : undefined)
-  }
-
-  if (req.query) {
-    _req.query = req.query
-  }
-
-  if (req.params) {
-    _req.params = req.params
-  }
-
-  _req.headers = req.headers
-  _req.remoteAddress = connection && connection.remoteAddress
-  _req.remotePort = connection && connection.remotePort
-  // req.raw is  for hapi compat/equivalence
-  _req.raw = req.raw || req
-  return _req
-}
-
-function mapHttpRequest (req) {
-  return {
-    req: reqSerializer(req)
-  }
-}

package/.output/server/node_modules/pino-std-serializers/lib/res.js

@@ -1,47 +0,0 @@
-'use strict'
-
-module.exports = {
-  mapHttpResponse,
-  resSerializer
-}
-
-const rawSymbol = Symbol('pino-raw-res-ref')
-const pinoResProto = Object.create({}, {
-  statusCode: {
-    enumerable: true,
-    writable: true,
-    value: 0
-  },
-  headers: {
-    enumerable: true,
-    writable: true,
-    value: ''
-  },
-  raw: {
-    enumerable: false,
-    get: function () {
-      return this[rawSymbol]
-    },
-    set: function (val) {
-      this[rawSymbol] = val
-    }
-  }
-})
-Object.defineProperty(pinoResProto, rawSymbol, {
-  writable: true,
-  value: {}
-})
-
-function resSerializer (res) {
-  const _res = Object.create(pinoResProto)
-  _res.statusCode = res.headersSent ? res.statusCode : null
-  _res.headers = res.getHeaders ? res.getHeaders() : res._headers
-  _res.raw = res
-  return _res
-}
-
-function mapHttpResponse (res) {
-  return {
-    res: resSerializer(res)
-  }
-}

package/.output/server/node_modules/pino-std-serializers/package.json

@@ -1,47 +0,0 @@
-{
-  "name": "pino-std-serializers",
-  "version": "7.0.0",
-  "description": "A collection of standard object serializers for Pino",
-  "main": "index.js",
-  "type": "commonjs",
-  "types": "index.d.ts",
-  "scripts": {
-    "lint": "standard | snazzy",
-    "lint-ci": "standard",
-    "test": "borp -p 'test/**/*.js'",
-    "test-ci": "borp --coverage -p 'test/**/*.js'",
-    "test-types": "tsc && tsd"
-  },
-  "repository": {
-    "type": "git",
-    "url": "git+ssh://git@github.com/pinojs/pino-std-serializers.git"
-  },
-  "keywords": [
-    "pino",
-    "logging"
-  ],
-  "author": "James Sumners <james.sumners@gmail.com>",
-  "license": "MIT",
-  "bugs": {
-    "url": "https://github.com/pinojs/pino-std-serializers/issues"
-  },
-  "homepage": "https://github.com/pinojs/pino-std-serializers#readme",
-  "precommit": [
-    "lint",
-    "test",
-    "test-types"
-  ],
-  "devDependencies": {
-    "@matteo.collina/tspl": "^0.1.1",
-    "@types/node": "^20.11.17",
-    "borp": "^0.9.1",
-    "pre-commit": "^1.2.2",
-    "snazzy": "^9.0.0",
-    "standard": "^17.1.0",
-    "tsd": "^0.31.0",
-    "typescript": "^5.3.3"
-  },
-  "tsd": {
-    "directory": "test/types"
-  }
-}

package/.output/server/node_modules/pkg-types/dist/index.mjs

@@ -1,157 +0,0 @@
-import { statSync, promises } from 'node:fs';
-import { resolve, join, isAbsolute, dirname } from 'pathe';
-import { resolvePath } from 'mlly';
-import { parseJSON, parseJSONC, stringifyJSON, stringifyJSONC } from 'confbox';
-
-const defaultFindOptions = {
-  startingFrom: ".",
-  rootPattern: /^node_modules$/,
-  reverse: false,
-  test: (filePath) => {
-    try {
-      if (statSync(filePath).isFile()) {
-        return true;
-      }
-    } catch {
-    }
-  }
-};
-async function findFile(filename, _options = {}) {
-  const filenames = Array.isArray(filename) ? filename : [filename];
-  const options = { ...defaultFindOptions, ..._options };
-  const basePath = resolve(options.startingFrom);
-  const leadingSlash = basePath[0] === "/";
-  const segments = basePath.split("/").filter(Boolean);
-  if (leadingSlash) {
-    segments[0] = "/" + segments[0];
-  }
-  let root = segments.findIndex((r) => r.match(options.rootPattern));
-  if (root === -1) {
-    root = 0;
-  }
-  if (options.reverse) {
-    for (let index = root + 1; index <= segments.length; index++) {
-      for (const filename2 of filenames) {
-        const filePath = join(...segments.slice(0, index), filename2);
-        if (await options.test(filePath)) {
-          return filePath;
-        }
-      }
-    }
-  } else {
-    for (let index = segments.length; index > root; index--) {
-      for (const filename2 of filenames) {
-        const filePath = join(...segments.slice(0, index), filename2);
-        if (await options.test(filePath)) {
-          return filePath;
-        }
-      }
-    }
-  }
-  throw new Error(
-    `Cannot find matching ${filename} in ${options.startingFrom} or parent directories`
-  );
-}
-function findNearestFile(filename, _options = {}) {
-  return findFile(filename, _options);
-}
-function findFarthestFile(filename, _options = {}) {
-  return findFile(filename, { ..._options, reverse: true });
-}
-
-function definePackageJSON(package_) {
-  return package_;
-}
-function defineTSConfig(tsconfig) {
-  return tsconfig;
-}
-const FileCache = /* @__PURE__ */ new Map();
-async function readPackageJSON(id, options = {}) {
-  const resolvedPath = await resolvePackageJSON(id, options);
-  const cache = options.cache && typeof options.cache !== "boolean" ? options.cache : FileCache;
-  if (options.cache && cache.has(resolvedPath)) {
-    return cache.get(resolvedPath);
-  }
-  const blob = await promises.readFile(resolvedPath, "utf8");
-  let parsed;
-  try {
-    parsed = parseJSON(blob);
-  } catch {
-    parsed = parseJSONC(blob);
-  }
-  cache.set(resolvedPath, parsed);
-  return parsed;
-}
-async function writePackageJSON(path, package_) {
-  await promises.writeFile(path, stringifyJSON(package_));
-}
-async function readTSConfig(id, options = {}) {
-  const resolvedPath = await resolveTSConfig(id, options);
-  const cache = options.cache && typeof options.cache !== "boolean" ? options.cache : FileCache;
-  if (options.cache && cache.has(resolvedPath)) {
-    return cache.get(resolvedPath);
-  }
-  const text = await promises.readFile(resolvedPath, "utf8");
-  const parsed = parseJSONC(text);
-  cache.set(resolvedPath, parsed);
-  return parsed;
-}
-async function writeTSConfig(path, tsconfig) {
-  await promises.writeFile(path, stringifyJSONC(tsconfig));
-}
-async function resolvePackageJSON(id = process.cwd(), options = {}) {
-  const resolvedPath = isAbsolute(id) ? id : await resolvePath(id, options);
-  return findNearestFile("package.json", {
-    startingFrom: resolvedPath,
-    ...options
-  });
-}
-async function resolveTSConfig(id = process.cwd(), options = {}) {
-  const resolvedPath = isAbsolute(id) ? id : await resolvePath(id, options);
-  return findNearestFile("tsconfig.json", {
-    startingFrom: resolvedPath,
-    ...options
-  });
-}
-const lockFiles = [
-  "yarn.lock",
-  "package-lock.json",
-  "pnpm-lock.yaml",
-  "npm-shrinkwrap.json",
-  "bun.lockb",
-  "bun.lock"
-];
-async function resolveLockfile(id = process.cwd(), options = {}) {
-  const resolvedPath = isAbsolute(id) ? id : await resolvePath(id, options);
-  const _options = { startingFrom: resolvedPath, ...options };
-  try {
-    return await findNearestFile(lockFiles, _options);
-  } catch {
-  }
-  throw new Error("No lockfile found from " + id);
-}
-async function findWorkspaceDir(id = process.cwd(), options = {}) {
-  const resolvedPath = isAbsolute(id) ? id : await resolvePath(id, options);
-  const _options = { startingFrom: resolvedPath, ...options };
-  try {
-    const r = await findNearestFile(".git/config", _options);
-    return resolve(r, "../..");
-  } catch {
-  }
-  try {
-    const r = await resolveLockfile(resolvedPath, {
-      ..._options,
-      reverse: true
-    });
-    return dirname(r);
-  } catch {
-  }
-  try {
-    const r = await findFile(resolvedPath, _options);
-    return dirname(r);
-  } catch {
-  }
-  throw new Error("Cannot detect workspace root from " + id);
-}
-
-export { definePackageJSON, defineTSConfig, findFarthestFile, findFile, findNearestFile, findWorkspaceDir, readPackageJSON, readTSConfig, resolveLockfile, resolvePackageJSON, resolveTSConfig, writePackageJSON, writeTSConfig };