@xylabs/object 5.0.79 → 5.0.81

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xylabs/object",
-  "version": "5.0.79",
+  "version": "5.0.81",
   "description": "Base functionality used throughout XY Labs TypeScript/JavaScript libraries",
   "homepage": "https://xyo.network",
   "bugs": {
@@ -22,36 +22,32 @@
   "exports": {
     ".": {
       "types": "./dist/neutral/index.d.ts",
-      "source": "./src/index.ts",
       "default": "./dist/neutral/index.mjs"
     },
     "./index-un-deprecated": {
       "types": "./dist/neutral/index-un-deprecated.d.ts",
-      "source": "./src/index-un-deprecated.ts",
       "default": "./dist/neutral/index-un-deprecated.mjs"
     },
     "./package.json": "./package.json"
   },
   "module": "./dist/neutral/index.mjs",
-  "source": "./src/index.ts",
   "types": "./dist/neutral/index.d.ts",
   "files": [
     "dist",
-    "src",
     "!**/*.bench.*",
     "!**/*.spec.*",
     "!**/*.test.*"
   ],
   "dependencies": {
-    "@xylabs/assert": "~5.0.79",
-    "@xylabs/object-model": "~5.0.79",
-    "@xylabs/promise": "~5.0.79",
-    "@xylabs/typeof": "~5.0.79",
-    "@xylabs/zod": "~5.0.79"
+    "@xylabs/assert": "~5.0.81",
+    "@xylabs/object-model": "~5.0.81",
+    "@xylabs/promise": "~5.0.81",
+    "@xylabs/typeof": "~5.0.81",
+    "@xylabs/zod": "~5.0.81"
   },
   "devDependencies": {
-    "@xylabs/ts-scripts-yarn3": "~7.3.2",
-    "@xylabs/tsconfig": "~7.3.2",
+    "@xylabs/ts-scripts-yarn3": "~7.4.11",
+    "@xylabs/tsconfig": "~7.4.11",
     "typescript": "~5.9.3",
     "vitest": "~4.0.18",
     "zod": "^4.3.6"

package/src/AsObjectFactory.ts

@@ -1,13 +0,0 @@
-import type { TypeCheck } from '@xylabs/object-model'
-import type { TypedObject } from '@xylabs/typeof'
-
-import { AsTypeFactory } from './AsTypeFactory.ts'
-
-export const AsObjectFactory = {
-  create: <T extends TypedObject>(typeCheck: TypeCheck<T>) => {
-    return AsTypeFactory.create<T>(typeCheck)
-  },
-  createOptional: <T extends TypedObject>(typeCheck: TypeCheck<T>) => {
-    return AsTypeFactory.createOptional<T>(typeCheck)
-  },
-}

package/src/AsTypeFactory.ts

@@ -1,54 +0,0 @@
-import { assertDefinedEx } from '@xylabs/assert'
-import type {
-  AsTypeFunction,
-  StringOrAlertFunction, TypeCheck, TypeCheckConfig,
-  TypeCheckRequiredConfig,
-} from '@xylabs/object-model'
-import type { AnyNonPromise } from '@xylabs/promise'
-import { isPromise } from '@xylabs/promise'
-import { isTruthy } from '@xylabs/typeof'
-
-export const AsTypeFactory = {
-  create: <T extends AnyNonPromise>(typeCheck: TypeCheck<T>): AsTypeFunction<T> => {
-    const func = (
-      value: AnyNonPromise,
-      assertOrConfig?: StringOrAlertFunction<T> | TypeCheckConfig,
-      config?: TypeCheckConfig,
-    ): T | undefined => {
-      // when used as a predicate, it seems that the index is passed as the second parameter (filter,map)
-      const isPredicate = typeof assertOrConfig === 'number'
-      const resolvedAssert = isPredicate
-        ? undefined
-        : (typeof assertOrConfig === 'object' ? undefined : assertOrConfig) as (StringOrAlertFunction<T> | undefined)
-      const resolvedConfig = isPredicate ? undefined : typeof assertOrConfig === 'object' ? assertOrConfig : config
-
-      // only return undefined if not required
-      const required = isTruthy((resolvedConfig as (TypeCheckRequiredConfig | undefined))?.required)
-      if (!required && (value === undefined || value === null)) {
-        return undefined
-      }
-
-      if (isPromise(value)) {
-        throw new TypeError('un-awaited promises may not be sent to "as" functions')
-      }
-
-      const result = typeCheck(value, resolvedConfig) ? (value as T) : undefined
-
-      if (resolvedAssert !== undefined) {
-        return typeof resolvedAssert === 'function' ? assertDefinedEx<T>(result, resolvedAssert) : assertDefinedEx<T>(result, () => resolvedAssert)
-      }
-      return result
-    }
-    return func
-  },
-  createOptional: <T extends AnyNonPromise>(typeCheck: TypeCheck<T>) => {
-    const func = (value: AnyNonPromise): T | undefined => {
-      if (value === undefined || value === null) return undefined
-      if (isPromise(value)) {
-        throw new TypeError('un-awaited promises may not be sent to "as" functions')
-      }
-      return typeCheck(value) ? (value as T) : undefined
-    }
-    return func
-  },
-}

package/src/EmptyObject.ts

@@ -1 +0,0 @@
-export type { EmptyObject } from '@xylabs/object-model'

package/src/IsObjectFactory.ts

@@ -1,34 +0,0 @@
-import type { TypeCheck, TypeCheckConfig } from '@xylabs/object-model'
-import {
-  isObject, isTruthy,
-  type ObjectTypeShape, type TypedObject,
-} from '@xylabs/typeof'
-import { isType } from '@xylabs/typeof'
-
-export interface ObjectTypeConfig extends TypeCheckConfig {}
-
-export class IsObjectFactory<T extends TypedObject> {
-  create(shape?: ObjectTypeShape, additionalChecks?: TypeCheck<TypedObject>[]): TypeCheck<T> {
-    return (obj: unknown, config?: TypeCheckConfig | number): obj is T => {
-      if (!isObject(obj)) {
-        return false
-      }
-      const log = (typeof config === 'object') ? config.log : undefined
-      return (
-        // do primary check
-        Object.entries(shape ?? {}).filter(([key, type]) => {
-          // eslint-disable-next-line @typescript-eslint/no-explicit-any
-          const result = isType((obj as any)[key], type)
-          if (!result && isTruthy(log)) {
-            const logger = typeof log === 'object' ? log : console
-            logger.warn(`isType Failed: ${key}: ${type}`)
-          }
-          return !result
-        }).length === 0
-        // perform additional checks
-        // eslint-disable-next-line unicorn/no-array-reduce
-        && (additionalChecks?.reduce((prev, check) => prev && check(obj, { log }), true) ?? true)
-      )
-    }
-  }
-}

package/src/JsonObject.ts

@@ -1,37 +0,0 @@
-import {
-  zodAsFactory, zodIsFactory, zodToFactory,
-} from '@xylabs/zod'
-import * as z from 'zod'
-
-const JsonArrayZod = z.array(z.lazy(() => JsonValueZod))
-
-// Define recursive JSON value schema
-const JsonValueZod: z.ZodType<unknown> = z.lazy(() =>
-  z.union([
-    z.string(),
-    z.number(),
-    z.boolean(),
-    z.null(),
-    z.array(JsonValueZod),
-    z.record(z.string(), JsonValueZod), // object with string keys and JSON values
-  ]))
-
-// JSON object schema — top-level must be an object
-export const JsonObjectZod = z.record(z.string(), JsonValueZod)
-
-// TypeScript type for reference
-export type JsonValue = z.infer<typeof JsonValueZod>
-export type JsonObject = z.infer<typeof JsonObjectZod>
-export type JsonArray = z.infer<typeof JsonArrayZod>
-
-export const isJsonValue = zodIsFactory(JsonValueZod)
-export const asJsonValue = zodAsFactory(JsonValueZod, 'asJsonValue')
-export const toJsonValue = zodToFactory(JsonValueZod, 'toJsonValue')
-
-export const isJsonArray = zodIsFactory(JsonArrayZod)
-export const asJsonArray = zodAsFactory(JsonArrayZod, 'asJsonArray')
-export const toJsonArray = zodToFactory(JsonArrayZod, 'toJsonArray')
-
-export const isJsonObject = zodIsFactory(JsonObjectZod)
-export const asJsonObject = zodAsFactory(JsonObjectZod, 'asJsonObject')
-export const toJsonObject = zodToFactory(JsonObjectZod, 'toJsonObject')

package/src/ObjectWrapper.ts

@@ -1,13 +0,0 @@
-import type { EmptyObject } from './EmptyObject.ts'
-import type { StringKeyObject } from './StringKeyObject.ts'
-
-export abstract class ObjectWrapper<T extends EmptyObject = EmptyObject> {
-  readonly obj: T
-  constructor(obj: T) {
-    this.obj = obj
-  }
-
-  protected get stringKeyObj() {
-    return this.obj as StringKeyObject
-  }
-}

package/src/OmitStartsWith.ts

@@ -1,35 +0,0 @@
-import type { JsonValue } from './JsonObject.ts'
-
-export type OmitStartsWith<T, Prefix extends string> = {
-  [K in keyof T as K extends `${Prefix}${string}` ? never : K]: T[K];
-}
-
-export type DeepOmitStartsWith<T, Prefix extends string> = T extends (infer U)[]
-  ? DeepOmitStartsWith<U, Prefix>[] // Special handling for arrays
-  : T extends object
-    ? {
-        [K in keyof T as K extends string
-          ? K extends `${Prefix}${string}`
-            ? never
-            : K
-          : K]: DeepOmitStartsWith<T[K], Prefix>;
-      }
-    : T
-
-export type DeepRestrictToStringKeys<T> = {
-  [K in keyof T as K extends string ? K : never]: T[K] extends (infer U)[]
-    ? DeepRestrictToStringKeys<U>[] // Handle arrays recursively
-    : T[K] extends object
-      ? DeepRestrictToStringKeys<T[K]> // Handle objects recursively
-      : T[K]; // Leave other types untouched
-}
-
-export type DeepRestrictToJson<T> = {
-  [K in keyof T as K extends string ? K : never]: T[K] extends (infer U)[]
-    ? DeepRestrictToJson<U>[] // Handle arrays recursively
-    : T[K] extends object
-      ? DeepRestrictToJson<T[K]> // Handle objects recursively
-      : T[K] extends JsonValue
-        ? T[K] // Leave JsonValue types untouched
-        : never; // Exclude other types
-}

package/src/Optional.ts

@@ -1 +0,0 @@
-export type Optional<T extends object, F extends keyof T> = Omit<T, F> & Partial<Pick<T, F>>

package/src/Override.ts

@@ -1,3 +0,0 @@
-type Override<T1, T2> = Omit<T1, keyof T2> & T2
-
-export type { Override }

package/src/PartialRecord.ts

@@ -1,6 +0,0 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-
-/** @deprecated use Partial<Record<>> instead */
-export type PartialRecord<K extends keyof any, T> = {
-  [P in K]?: T
-}

package/src/PickStartsWith.ts

@@ -1,15 +0,0 @@
-export type PickStartsWith<T, Prefix extends string> = {
-  [K in keyof T as K extends `${Prefix}${string}` ? K : never]: T[K];
-}
-
-export type DeepPickStartsWith<T, Prefix extends string> = T extends (infer U)[]
-  ? DeepPickStartsWith<U, Prefix>[] // Special handling for arrays
-  : T extends object
-    ? {
-        [K in keyof T as K extends string
-          ? K extends `${Prefix}${string}`
-            ? K
-            : never
-          : K]: DeepPickStartsWith<T[K], Prefix>;
-      }
-    : T

package/src/Simplify.ts

@@ -1 +0,0 @@
-export type Simplify<T> = { [K in keyof T]: T[K] } & {}

package/src/StringKeyObject.ts

@@ -1 +0,0 @@
-export type StringKeyObject<T = unknown> = { [key: string]: T }

package/src/Validator.ts

@@ -1,13 +0,0 @@
-import type { AnyObject } from '@xylabs/object-model'
-import type { Promisable } from '@xylabs/promise'
-
-import type { EmptyObject } from './EmptyObject.ts'
-import { ObjectWrapper } from './ObjectWrapper.ts'
-
-export interface Validator<T extends EmptyObject = AnyObject> {
-  validate(payload: T): Promisable<Error[]>
-}
-
-export abstract class ValidatorBase<T extends EmptyObject = AnyObject> extends ObjectWrapper<Partial<T>> implements Validator<T> {
-  abstract validate(payload: T): Promisable<Error[]>
-}

package/src/WithAdditional.ts

@@ -1,4 +0,0 @@
-import type { EmptyObject } from './EmptyObject.ts'
-
-export type WithAdditional<T extends EmptyObject | void, TAdditional extends EmptyObject | void = void>
-  = TAdditional extends EmptyObject ? T & TAdditional : T

package/src/asObject.ts

@@ -1,6 +0,0 @@
-import type { AnyObject } from '@xylabs/object-model'
-import { isObject } from '@xylabs/typeof'
-
-import { AsObjectFactory } from './AsObjectFactory.ts'
-
-export const asAnyObject = (() => AsObjectFactory.create<AnyObject>(<T extends AnyObject>(obj: unknown): obj is T => isObject(obj)))()

package/src/deepMerge.ts

@@ -1,105 +0,0 @@
-import type { AnyObject } from '@xylabs/object-model'
-
-/**
- * Deeply merges two types into a new type.
- */
-type DeepMerge<A, B> = {
-  [K in keyof A | keyof B]:
-  K extends keyof B
-    ? K extends keyof A
-      ? A[K] extends object
-        ? B[K] extends object
-          ? DeepMerge<A[K], B[K]>
-          : B[K]
-        : B[K]
-      : B[K]
-    : K extends keyof A
-      ? A[K]
-      : never;
-}
-
-/**
- * Merges multiple types into a new type.
- */
-type MergeAll<T extends object[], R = {}>
-  = T extends [infer First extends object, ...infer Rest extends object[]]
-    ? MergeAll<Rest, DeepMerge<R, First>>
-    : R
-
-/**
- * Options for merging objects in the deep merge function.
- */
-type MergeOptions = {
-  /**
-   * Strategy for merging arrays.
-   * - 'overwrite': Overwrites the array with the last object's value.
-   * - 'concat': Concatenates arrays from all objects.
-   * @default 'overwrite'
-   */
-  arrayStrategy?: 'overwrite' | 'concat'
-  /**
-   * Mutate the first object in the list instead of creating a new one.
-   * @default false
-   */
-  mutate?: boolean
-}
-
-const isUnsafeKey = (key: string | symbol): boolean =>
-  key === '__proto__' || key === 'constructor' || key === 'prototype'
-
-function merge<T extends AnyObject>(target: AnyObject, source?: AnyObject, options?: MergeOptions): T {
-  if (!source || typeof source !== 'object') return target as T
-
-  for (const key of Reflect.ownKeys(source)) {
-    const value = source[key]
-    if (isUnsafeKey(key)) {
-      continue
-    } else if (Array.isArray(value)) {
-      target[key]
-      // If the value is an array, handle it based on the configured array strategy
-        = options?.arrayStrategy === 'concat' && Array.isArray(target[key])
-          ? [...target[key], ...value]
-          : value
-    } else if (value !== null && typeof value === 'object') {
-      // Recursively merge nested objects
-      if (!target[key] || typeof target[key] !== 'object') {
-        target[key] = {}
-      }
-      merge(target[key] as AnyObject, value as AnyObject, options)
-    } else {
-      // Overwrite with non-object values
-      target[key] = value
-    }
-  }
-
-  return target as T
-}
-
-/**
- * Creates a deep merge function with the specified options.
- * @param options Options for merging.
- * @returns A deep merge function configured for the specified options.
- */
-export function createDeepMerge(options: MergeOptions) {
-  return function deepMerge<T extends AnyObject[]>(...objects: T): MergeAll<T> {
-    const result = (options.mutate ? objects[0] ?? {} : {}) as MergeAll<T>
-    for (const obj of objects) {
-      merge(result, obj, options)
-    }
-    return result
-  }
-}
-
-/**
- * Deeply merges multiple objects into a new object.
- * @param objects Multiple objects to merge deeply.
- * The function merges properties from all objects into a new object.
- * If a property exists in multiple objects, the last object's value will be used.
- * If a property is an object, it will be merged recursively.
- * If a property is an array, it will be overwritten by the last object's value.
- * If a property is a primitive value, it will be overwritten by the last object's value.
- * If a property is undefined in the source, it will be skipped.
- * If a property is a symbol, it will be merged as well.
- * @returns A new object with the merged properties.
- */
-export const deepMerge = createDeepMerge({ arrayStrategy: 'overwrite', mutate: false })

package/src/index-deprecated.ts

@@ -1,2 +0,0 @@
-export * from './index-un-deprecated.ts'
-export * from './isType.ts'

package/src/index-un-deprecated.ts

@@ -1,22 +0,0 @@
-export * from './asObject.ts'
-export * from './AsObjectFactory.ts'
-export * from './AsTypeFactory.ts'
-export * from './deepMerge.ts'
-export * from './IsObjectFactory.ts'
-export * from './JsonObject.ts'
-export * from './ObjectWrapper.ts'
-export * from './omitBy.ts'
-export * from './OmitStartsWith.ts'
-export * from './Optional.ts'
-export * from './Override.ts'
-export * from './PartialRecord.ts'
-export * from './pickBy.ts'
-export * from './PickStartsWith.ts'
-export * from './removeFields.ts'
-export * from './Simplify.ts'
-export * from './StringKeyObject.ts'
-export * from './toSafeJson.ts'
-export * from './Validator.ts'
-export * from './WithAdditional.ts'
-export * from '@xylabs/object-model'
-export { isObject } from '@xylabs/typeof'

package/src/index.ts

@@ -1,2 +0,0 @@
-export * from './index-deprecated.ts'
-export * from './index-un-deprecated.ts'

package/src/isType.ts

@@ -1,28 +0,0 @@
-import type { FieldType } from '@xylabs/typeof'
-
-/** @deprecated use from @xylabs/typeof instead */
-export const isType = (value: unknown, expectedType: FieldType) => {
-  const typeofValue = typeof value
-  switch (expectedType) {
-    case 'array': {
-      return Array.isArray(value)
-    }
-    case 'null': {
-      return value === null
-    }
-    case 'undefined': {
-      return value === undefined
-    }
-    case 'object': {
-      // nulls resolve to objects, so exclude them
-      if (value === null) {
-        return false
-      }
-      // arrays resolve to objects, so exclude them
-      return typeofValue === 'object' && !Array.isArray(value)
-    }
-    default: {
-      return typeofValue === expectedType
-    }
-  }
-}

package/src/omitBy.ts

@@ -1,57 +0,0 @@
-import { assertEx } from '@xylabs/assert'
-
-import type { EmptyObject } from './EmptyObject.ts'
-import type { JsonObject } from './JsonObject.ts'
-import type { DeepOmitStartsWith } from './OmitStartsWith.ts'
-
-export type OmitByPredicate<T extends EmptyObject = Record<string, unknown>> = (value: T[keyof T], key: keyof T) => boolean
-
-const omitByArray = <T>(
-  obj: T[],
-  predicate: OmitByPredicate,
-  maxDepth: number,
-): T[] => {
-  return obj.map((value) => {
-    return (value !== null && typeof value === 'object') ? omitBy(value, predicate, maxDepth) : value
-  }) as T[]
-}
-
-const omitByObject = <T extends EmptyObject>(
-  obj: T,
-  predicate: OmitByPredicate,
-  maxDepth: number,
-): Partial<T> => {
-  const result: JsonObject = {}
-
-  for (const key in obj) {
-    if (Object.hasOwn(obj, key)) {
-      const value = obj[key]
-      if (!predicate(value, key)) {
-        result[key] = ((value !== null && typeof value === 'object') ? omitBy(value, predicate, maxDepth - 1) : value) as JsonObject
-      }
-    }
-  }
-
-  return result as T
-}
-
-export const omitBy = <T extends EmptyObject>(
-  obj: T,
-  predicate: OmitByPredicate,
-  maxDepth = 1,
-): Partial<T> => {
-  if (maxDepth <= 0) {
-    return obj
-  }
-
-  return Array.isArray(obj) ? omitByArray(obj, predicate, maxDepth - 1) as T : omitByObject(obj, predicate, maxDepth - 1) as T
-}
-
-const omitByPrefixPredicate = (prefix: string) => (_: unknown, key: string) => {
-  assertEx(typeof key === 'string', () => `Invalid key type [${key}, ${typeof key}]`)
-  return key.startsWith(prefix)
-}
-
-export const omitByPrefix = <T extends EmptyObject, P extends string>(payload: T, prefix: P, maxDepth = 100): DeepOmitStartsWith<T, P> => {
-  return omitBy(payload, omitByPrefixPredicate(prefix), maxDepth) as unknown as DeepOmitStartsWith<T, P>
-}

package/src/pickBy.ts

@@ -1,57 +0,0 @@
-import { assertEx } from '@xylabs/assert'
-
-import type { EmptyObject } from './EmptyObject.ts'
-import type { JsonObject } from './JsonObject.ts'
-import type { DeepPickStartsWith } from './PickStartsWith.ts'
-
-export type PickByPredicate<T extends EmptyObject = Record<string, unknown>> = (value: T[keyof T], key: keyof T) => boolean
-
-const pickByArray = <T>(
-  obj: T[],
-  predicate: PickByPredicate,
-  maxDepth: number,
-): T[] => {
-  return obj.map((value) => {
-    return (value !== null && typeof value === 'object') ? pickBy(value, predicate, maxDepth) : value
-  }) as T[]
-}
-
-const pickByObject = <T extends EmptyObject>(
-  obj: T,
-  predicate: PickByPredicate,
-  maxDepth: number,
-): Partial<T> => {
-  const result: JsonObject = {}
-
-  for (const key in obj) {
-    if (Object.hasOwn(obj, key)) {
-      const value = obj[key]
-      if (predicate(value, key)) {
-        result[key] = ((value !== null && typeof value === 'object') ? pickBy(value, predicate, maxDepth - 1) : value) as JsonObject
-      }
-    }
-  }
-
-  return result as T
-}
-
-export const pickBy = <T extends EmptyObject>(
-  obj: T,
-  predicate: PickByPredicate,
-  maxDepth = 1,
-): Partial<T> => {
-  if (maxDepth <= 0) {
-    return obj
-  }
-
-  return Array.isArray(obj) ? pickByArray(obj, predicate, maxDepth - 1) as T : pickByObject(obj, predicate, maxDepth - 1) as T
-}
-
-const pickByPrefixPredicate = (prefix: string) => (_: unknown, key: string) => {
-  assertEx(typeof key === 'string', () => `Invalid key type [${key}, ${typeof key}]`)
-  return key.startsWith(prefix)
-}
-
-export const pickByPrefix = <T extends EmptyObject, P extends string>(payload: T, prefix: P, maxDepth = 100): DeepPickStartsWith<T, P> => {
-  return pickBy(payload, pickByPrefixPredicate(prefix), maxDepth) as unknown as DeepPickStartsWith<T, P>
-}

package/src/removeFields.ts

@@ -1,9 +0,0 @@
-import type { EmptyObject } from './EmptyObject.ts'
-
-export const removeFields = <T extends EmptyObject, K extends keyof T>(obj: T, fields: K[]): Omit<T, K> => {
-  const clone = { ...obj }
-  for (const field of fields) {
-    delete clone[field]
-  }
-  return clone
-}

package/src/toSafeJson.ts

@@ -1,50 +0,0 @@
-import type {
-  JsonArray, JsonObject, JsonValue,
-} from './JsonObject.ts'
-
-export const toSafeJsonArray = (value: unknown[], cycleList?: unknown[], maxDepth = 3): JsonArray => {
-  return value.map(item => toSafeJsonValue(item, cycleList, maxDepth))
-}
-
-export const toSafeJsonObject = (value: object, cycleList?: unknown[], maxDepth = 3): JsonObject => {
-  const result: JsonObject = {}
-  for (const [key, entry] of Object.entries(value)) {
-    result[key] = value === undefined ? '[Undefined]' : toSafeJsonValue(entry, cycleList, maxDepth)
-  }
-  return result
-}
-
-export const toSafeJsonValue = (value: unknown, cycleList?: unknown[], maxDepth = 3): JsonValue => {
-  if (maxDepth <= 0 && typeof value === 'object') {
-    return '[MaxDepth]'
-  }
-  if (cycleList?.includes(value)) {
-    return '[Circular]'
-  }
-  switch (typeof value) {
-    case 'string':
-    case 'boolean':
-    case 'number': {
-      return value
-    }
-    case 'object': {
-      if (value === null) {
-        return null
-      }
-      const newCycleList = cycleList ?? []
-      newCycleList.push(value)
-      return Array.isArray(value) ? toSafeJsonArray(value, newCycleList, maxDepth - 1) : toSafeJsonObject(value, newCycleList, maxDepth - 1)
-    }
-    default: {
-      return `[${typeof value}]`
-    }
-  }
-}
-
-export const toSafeJsonString = (value: unknown, maxDepth = 3) => {
-  return JSON.stringify(toSafeJson(value, maxDepth), null, 2)
-}
-
-export const toSafeJson = (value: unknown, maxDepth = 3): JsonValue => {
-  return toSafeJsonValue(value, undefined, maxDepth)
-}