@farthershore/cli 0.3.10 → 0.3.11

package/node_modules/@pinojs/redact/index.js

@@ -1,529 +0,0 @@
-'use strict'
-
-function deepClone (obj) {
-  if (obj === null || typeof obj !== 'object') {
-    return obj
-  }
-
-  if (obj instanceof Date) {
-    return new Date(obj.getTime())
-  }
-
-  if (obj instanceof Array) {
-    const cloned = []
-    for (let i = 0; i < obj.length; i++) {
-      cloned[i] = deepClone(obj[i])
-    }
-    return cloned
-  }
-
-  if (typeof obj === 'object') {
-    const cloned = Object.create(Object.getPrototypeOf(obj))
-    for (const key in obj) {
-      if (Object.prototype.hasOwnProperty.call(obj, key)) {
-        cloned[key] = deepClone(obj[key])
-      }
-    }
-    return cloned
-  }
-
-  return obj
-}
-
-function parsePath (path) {
-  const parts = []
-  let current = ''
-  let inBrackets = false
-  let inQuotes = false
-  let quoteChar = ''
-
-  for (let i = 0; i < path.length; i++) {
-    const char = path[i]
-
-    if (!inBrackets && char === '.') {
-      if (current) {
-        parts.push(current)
-        current = ''
-      }
-    } else if (char === '[') {
-      if (current) {
-        parts.push(current)
-        current = ''
-      }
-      inBrackets = true
-    } else if (char === ']' && inBrackets) {
-      // Always push the current value when closing brackets, even if it's an empty string
-      parts.push(current)
-      current = ''
-      inBrackets = false
-      inQuotes = false
-    } else if ((char === '"' || char === "'") && inBrackets) {
-      if (!inQuotes) {
-        inQuotes = true
-        quoteChar = char
-      } else if (char === quoteChar) {
-        inQuotes = false
-        quoteChar = ''
-      } else {
-        current += char
-      }
-    } else {
-      current += char
-    }
-  }
-
-  if (current) {
-    parts.push(current)
-  }
-
-  return parts
-}
-
-function setValue (obj, parts, value) {
-  let current = obj
-
-  for (let i = 0; i < parts.length - 1; i++) {
-    const key = parts[i]
-    // Type safety: Check if current is an object before using 'in' operator
-    if (typeof current !== 'object' || current === null || !(key in current)) {
-      return false // Path doesn't exist, don't create it
-    }
-    if (typeof current[key] !== 'object' || current[key] === null) {
-      return false // Path doesn't exist properly
-    }
-    current = current[key]
-  }
-
-  const lastKey = parts[parts.length - 1]
-  if (lastKey === '*') {
-    if (Array.isArray(current)) {
-      for (let i = 0; i < current.length; i++) {
-        current[i] = value
-      }
-    } else if (typeof current === 'object' && current !== null) {
-      for (const key in current) {
-        if (Object.prototype.hasOwnProperty.call(current, key)) {
-          current[key] = value
-        }
-      }
-    }
-  } else {
-    // Type safety: Check if current is an object before using 'in' operator
-    if (typeof current === 'object' && current !== null && lastKey in current && Object.prototype.hasOwnProperty.call(current, lastKey)) {
-      current[lastKey] = value
-    }
-  }
-  return true
-}
-
-function removeKey (obj, parts) {
-  let current = obj
-
-  for (let i = 0; i < parts.length - 1; i++) {
-    const key = parts[i]
-    // Type safety: Check if current is an object before using 'in' operator
-    if (typeof current !== 'object' || current === null || !(key in current)) {
-      return false // Path doesn't exist, don't create it
-    }
-    if (typeof current[key] !== 'object' || current[key] === null) {
-      return false // Path doesn't exist properly
-    }
-    current = current[key]
-  }
-
-  const lastKey = parts[parts.length - 1]
-  if (lastKey === '*') {
-    if (Array.isArray(current)) {
-      // For arrays, we can't really "remove" all items as that would change indices
-      // Instead, we set them to undefined which will be omitted by JSON.stringify
-      for (let i = 0; i < current.length; i++) {
-        current[i] = undefined
-      }
-    } else if (typeof current === 'object' && current !== null) {
-      for (const key in current) {
-        if (Object.prototype.hasOwnProperty.call(current, key)) {
-          delete current[key]
-        }
-      }
-    }
-  } else {
-    // Type safety: Check if current is an object before using 'in' operator
-    if (typeof current === 'object' && current !== null && lastKey in current && Object.prototype.hasOwnProperty.call(current, lastKey)) {
-      delete current[lastKey]
-    }
-  }
-  return true
-}
-
-// Sentinel object to distinguish between undefined value and non-existent path
-const PATH_NOT_FOUND = Symbol('PATH_NOT_FOUND')
-
-function getValueIfExists (obj, parts) {
-  let current = obj
-
-  for (const part of parts) {
-    if (current === null || current === undefined) {
-      return PATH_NOT_FOUND
-    }
-    // Type safety: Check if current is an object before property access
-    if (typeof current !== 'object' || current === null) {
-      return PATH_NOT_FOUND
-    }
-    // Check if the property exists before accessing it
-    if (!(part in current)) {
-      return PATH_NOT_FOUND
-    }
-    current = current[part]
-  }
-
-  return current
-}
-
-function getValue (obj, parts) {
-  let current = obj
-
-  for (const part of parts) {
-    if (current === null || current === undefined) {
-      return undefined
-    }
-    // Type safety: Check if current is an object before property access
-    if (typeof current !== 'object' || current === null) {
-      return undefined
-    }
-    current = current[part]
-  }
-
-  return current
-}
-
-function redactPaths (obj, paths, censor, remove = false) {
-  for (const path of paths) {
-    const parts = parsePath(path)
-
-    if (parts.includes('*')) {
-      redactWildcardPath(obj, parts, censor, path, remove)
-    } else {
-      if (remove) {
-        removeKey(obj, parts)
-      } else {
-        // Get value only if path exists - single traversal
-        const value = getValueIfExists(obj, parts)
-        if (value === PATH_NOT_FOUND) {
-          continue
-        }
-
-        const actualCensor = typeof censor === 'function'
-          ? censor(value, parts)
-          : censor
-        setValue(obj, parts, actualCensor)
-      }
-    }
-  }
-}
-
-function redactWildcardPath (obj, parts, censor, originalPath, remove = false) {
-  const wildcardIndex = parts.indexOf('*')
-
-  if (wildcardIndex === parts.length - 1) {
-    const parentParts = parts.slice(0, -1)
-    let current = obj
-
-    for (const part of parentParts) {
-      if (current === null || current === undefined) return
-      // Type safety: Check if current is an object before property access
-      if (typeof current !== 'object' || current === null) return
-      current = current[part]
-    }
-
-    if (Array.isArray(current)) {
-      if (remove) {
-        // For arrays, set all items to undefined which will be omitted by JSON.stringify
-        for (let i = 0; i < current.length; i++) {
-          current[i] = undefined
-        }
-      } else {
-        for (let i = 0; i < current.length; i++) {
-          const indexPath = [...parentParts, i.toString()]
-          const actualCensor = typeof censor === 'function'
-            ? censor(current[i], indexPath)
-            : censor
-          current[i] = actualCensor
-        }
-      }
-    } else if (typeof current === 'object' && current !== null) {
-      if (remove) {
-        // Collect keys to delete to avoid issues with deleting during iteration
-        const keysToDelete = []
-        for (const key in current) {
-          if (Object.prototype.hasOwnProperty.call(current, key)) {
-            keysToDelete.push(key)
-          }
-        }
-        for (const key of keysToDelete) {
-          delete current[key]
-        }
-      } else {
-        for (const key in current) {
-          const keyPath = [...parentParts, key]
-          const actualCensor = typeof censor === 'function'
-            ? censor(current[key], keyPath)
-            : censor
-          current[key] = actualCensor
-        }
-      }
-    }
-  } else {
-    redactIntermediateWildcard(obj, parts, censor, wildcardIndex, originalPath, remove)
-  }
-}
-
-function redactIntermediateWildcard (obj, parts, censor, wildcardIndex, originalPath, remove = false) {
-  const beforeWildcard = parts.slice(0, wildcardIndex)
-  const afterWildcard = parts.slice(wildcardIndex + 1)
-  const pathArray = [] // Cached array to avoid allocations
-
-  function traverse (current, pathLength) {
-    if (pathLength === beforeWildcard.length) {
-      if (Array.isArray(current)) {
-        for (let i = 0; i < current.length; i++) {
-          pathArray[pathLength] = i.toString()
-          traverse(current[i], pathLength + 1)
-        }
-      } else if (typeof current === 'object' && current !== null) {
-        for (const key in current) {
-          pathArray[pathLength] = key
-          traverse(current[key], pathLength + 1)
-        }
-      }
-    } else if (pathLength < beforeWildcard.length) {
-      const nextKey = beforeWildcard[pathLength]
-      // Type safety: Check if current is an object before using 'in' operator
-      if (current && typeof current === 'object' && current !== null && nextKey in current) {
-        pathArray[pathLength] = nextKey
-        traverse(current[nextKey], pathLength + 1)
-      }
-    } else {
-      // Check if afterWildcard contains more wildcards
-      if (afterWildcard.includes('*')) {
-        // Recursively handle remaining wildcards
-        // Wrap censor to prepend current path context
-        const wrappedCensor = typeof censor === 'function'
-          ? (value, path) => {
-              const fullPath = [...pathArray.slice(0, pathLength), ...path]
-              return censor(value, fullPath)
-            }
-          : censor
-        redactWildcardPath(current, afterWildcard, wrappedCensor, originalPath, remove)
-      } else {
-        // No more wildcards, apply the redaction directly
-        if (remove) {
-          removeKey(current, afterWildcard)
-        } else {
-          const actualCensor = typeof censor === 'function'
-            ? censor(getValue(current, afterWildcard), [...pathArray.slice(0, pathLength), ...afterWildcard])
-            : censor
-          setValue(current, afterWildcard, actualCensor)
-        }
-      }
-    }
-  }
-
-  if (beforeWildcard.length === 0) {
-    traverse(obj, 0)
-  } else {
-    let current = obj
-    for (let i = 0; i < beforeWildcard.length; i++) {
-      const part = beforeWildcard[i]
-      if (current === null || current === undefined) return
-      // Type safety: Check if current is an object before property access
-      if (typeof current !== 'object' || current === null) return
-      current = current[part]
-      pathArray[i] = part
-    }
-    if (current !== null && current !== undefined) {
-      traverse(current, beforeWildcard.length)
-    }
-  }
-}
-
-function buildPathStructure (pathsToClone) {
-  if (pathsToClone.length === 0) {
-    return null // No paths to redact
-  }
-
-  // Parse all paths and organize by depth
-  const pathStructure = new Map()
-  for (const path of pathsToClone) {
-    const parts = parsePath(path)
-    let current = pathStructure
-    for (let i = 0; i < parts.length; i++) {
-      const part = parts[i]
-      if (!current.has(part)) {
-        current.set(part, new Map())
-      }
-      current = current.get(part)
-    }
-  }
-  return pathStructure
-}
-
-function selectiveClone (obj, pathStructure) {
-  if (!pathStructure) {
-    return obj // No paths to redact, return original
-  }
-
-  function cloneSelectively (source, pathMap, depth = 0) {
-    if (!pathMap || pathMap.size === 0) {
-      return source // No more paths to clone, return reference
-    }
-
-    if (source === null || typeof source !== 'object') {
-      return source
-    }
-
-    if (source instanceof Date) {
-      return new Date(source.getTime())
-    }
-
-    if (Array.isArray(source)) {
-      const cloned = []
-      for (let i = 0; i < source.length; i++) {
-        const indexStr = i.toString()
-        if (pathMap.has(indexStr) || pathMap.has('*')) {
-          cloned[i] = cloneSelectively(source[i], pathMap.get(indexStr) || pathMap.get('*'))
-        } else {
-          cloned[i] = source[i] // Share reference for non-redacted items
-        }
-      }
-      return cloned
-    }
-
-    // Handle objects
-    const cloned = Object.create(Object.getPrototypeOf(source))
-    for (const key in source) {
-      if (Object.prototype.hasOwnProperty.call(source, key)) {
-        if (pathMap.has(key) || pathMap.has('*')) {
-          cloned[key] = cloneSelectively(source[key], pathMap.get(key) || pathMap.get('*'))
-        } else {
-          cloned[key] = source[key] // Share reference for non-redacted properties
-        }
-      }
-    }
-    return cloned
-  }
-
-  return cloneSelectively(obj, pathStructure)
-}
-
-function validatePath (path) {
-  if (typeof path !== 'string') {
-    throw new Error('Paths must be (non-empty) strings')
-  }
-
-  if (path === '') {
-    throw new Error('Invalid redaction path ()')
-  }
-
-  // Check for double dots
-  if (path.includes('..')) {
-    throw new Error(`Invalid redaction path (${path})`)
-  }
-
-  // Check for comma-separated paths (invalid syntax)
-  if (path.includes(',')) {
-    throw new Error(`Invalid redaction path (${path})`)
-  }
-
-  // Check for unmatched brackets
-  let bracketCount = 0
-  let inQuotes = false
-  let quoteChar = ''
-
-  for (let i = 0; i < path.length; i++) {
-    const char = path[i]
-
-    if ((char === '"' || char === "'") && bracketCount > 0) {
-      if (!inQuotes) {
-        inQuotes = true
-        quoteChar = char
-      } else if (char === quoteChar) {
-        inQuotes = false
-        quoteChar = ''
-      }
-    } else if (char === '[' && !inQuotes) {
-      bracketCount++
-    } else if (char === ']' && !inQuotes) {
-      bracketCount--
-      if (bracketCount < 0) {
-        throw new Error(`Invalid redaction path (${path})`)
-      }
-    }
-  }
-
-  if (bracketCount !== 0) {
-    throw new Error(`Invalid redaction path (${path})`)
-  }
-}
-
-function validatePaths (paths) {
-  if (!Array.isArray(paths)) {
-    throw new TypeError('paths must be an array')
-  }
-
-  for (const path of paths) {
-    validatePath(path)
-  }
-}
-
-function slowRedact (options = {}) {
-  const {
-    paths = [],
-    censor = '[REDACTED]',
-    serialize = JSON.stringify,
-    strict = true,
-    remove = false
-  } = options
-
-  // Validate paths upfront to match fast-redact behavior
-  validatePaths(paths)
-
-  // Build path structure once during setup, not on every call
-  const pathStructure = buildPathStructure(paths)
-
-  return function redact (obj) {
-    if (strict && (obj === null || typeof obj !== 'object')) {
-      if (obj === null || obj === undefined) {
-        return serialize ? serialize(obj) : obj
-      }
-      if (typeof obj !== 'object') {
-        return serialize ? serialize(obj) : obj
-      }
-    }
-
-    // Only clone paths that need redaction
-    const cloned = selectiveClone(obj, pathStructure)
-    const original = obj // Keep reference to original for restore
-
-    let actualCensor = censor
-    if (typeof censor === 'function') {
-      actualCensor = censor
-    }
-
-    redactPaths(cloned, paths, actualCensor, remove)
-
-    if (serialize === false) {
-      cloned.restore = function () {
-        return deepClone(original) // Full clone only when restore is called
-      }
-      return cloned
-    }
-
-    if (typeof serialize === 'function') {
-      return serialize(cloned)
-    }
-
-    return JSON.stringify(cloned)
-  }
-}
-
-module.exports = slowRedact

package/node_modules/@pinojs/redact/index.test-d.ts

@@ -1,22 +0,0 @@
-import { expectType, expectAssignable } from "tsd";
-import slowRedact from ".";
-import type { redactFn, redactFnNoSerialize } from ".";
-
-// should return redactFn
-expectType<redactFn>(slowRedact());
-expectType<redactFn>(slowRedact({ paths: [] }));
-expectType<redactFn>(slowRedact({ paths: ["some.path"] }));
-expectType<redactFn>(slowRedact({ paths: [], censor: "[REDACTED]" }));
-expectType<redactFn>(slowRedact({ paths: [], strict: true }));
-expectType<redactFn>(slowRedact({ paths: [], serialize: JSON.stringify }));
-expectType<redactFn>(slowRedact({ paths: [], serialize: true }));
-expectType<redactFnNoSerialize>(slowRedact({ paths: [], serialize: false }));
-expectType<redactFn>(slowRedact({ paths: [], remove: true }));
-
-// should return string
-expectType<string>(slowRedact()(""));
-
-// should return string or T
-expectAssignable<string | { someField: string }>(
-  slowRedact()({ someField: "someValue" })
-);

package/node_modules/@pinojs/redact/package.json

@@ -1,37 +0,0 @@
-{
-  "name": "@pinojs/redact",
-  "version": "0.4.0",
-  "description": "Redact JS objects",
-  "main": "index.js",
-  "types": "index.d.ts",
-  "scripts": {
-    "test": "node --test && npm run test:types",
-    "test:integration": "node --test test/integration.test.js",
-    "test:types": "tsd",
-    "test:all": "node --test test/*.test.js",
-    "lint": "eslint .",
-    "lint:fix": "eslint . --fix",
-    "bench": "node benchmarks/basic.js"
-  },
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/pinojs/redact.git"
-  },
-  "keywords": [
-    "redact"
-  ],
-  "author": "Matteo Collina <hello@matteocollina.com>",
-  "license": "MIT",
-  "bugs": {
-    "url": "https://github.com/pinojs/redact/issues"
-  },
-  "homepage": "https://github.com/pinojs/redact#readme",
-  "devDependencies": {
-    "eslint": "^9.36.0",
-    "fast-redact": "^3.5.0",
-    "mitata": "^1.0.34",
-    "neostandard": "^0.12.2",
-    "tsd": "^0.33.0",
-    "typescript": "^5.9.2"
-  }
-}

package/node_modules/@pinojs/redact/scripts/sync-version.mjs

@@ -1,20 +0,0 @@
-import fs from 'node:fs'
-import path from 'node:path'
-
-const packageJsonPath = path.resolve(import.meta.dirname, '../package.json')
-let { version } = JSON.parse(fs.readFileSync(packageJsonPath, 'utf-8'))
-
-let passedVersion = process.argv[2]
-
-if (passedVersion) {
-  passedVersion = passedVersion.trim().replace(/^v/, '')
-  if (version !== passedVersion) {
-    console.log(`Syncing version from ${version} to ${passedVersion}`)
-    version = passedVersion
-    const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf-8'))
-    packageJson.version = version
-    fs.writeFileSync(path.resolve('./package.json'), JSON.stringify(packageJson, null, 2) + '\n', { encoding: 'utf-8' })
-  }
-} else {
-  throw new Error('Version argument is required')
-}