selective-option/dist/esm/selective.mjs.map

A simple selective option resolver

{"version":3,"file":"selective.mjs","sources":["../../src/tools/create-result.ts","../../src/tools/is.ts","../../src/tools/errors.ts","../../src/tools/value-nullish.ts","../../src/potential/function.ts","../../src/tools/resolve-key.ts","../../src/tools/resolve-polar-key.ts","../../src/potential/key-list.ts","../../src/potential/object.ts","../../src/potential/single-key.ts","../../src/potential/value.ts","../../src/tools/create-resolver.ts","../../src/resolvers/bool-based.ts","../../src/resolvers/value-based.ts"],"sourcesContent":["import type { KeyList, Resolved } from '../types/resolver-types';\n\nexport function createResult<K extends string, V>(keys: KeyList<K>, value: V): Resolved<K, V> {\n  const entries = keys.map<readonly [K, V]>((key) => {\n    return [key, value];\n  });\n  return Object.fromEntries(entries) as Resolved<K, V>;\n}\n\n/**\n * @deprecated\n */\n// eslint-disable-next-line @typescript-eslint/unified-signatures\nexport function deprecatedCreateResult<K extends string, V>(keys: KeyList<K>, value: V, input: undefined | Resolved<K, V>): Resolved<K, V>;\n\nexport function deprecatedCreateResult<K extends string, V>(keys: KeyList<K>, value: V): Resolved<K, V>;\nexport function deprecatedCreateResult<K extends string, V>(keys: KeyList<K>, value: V, input?: Resolved<K, V>): Resolved<K, V> {\n  const result = createResult(keys, value);\n  return { ...input, ...result };\n}\n\nexport function createResultGetValue<K extends string, V>(keys: KeyList<K>, getValue: (key: K) => V): Resolved<K, V> {\n  const entries = keys.map<readonly [K, V]>((key) => {\n    const value = getValue(key);\n    return [key, value];\n  });\n  return Object.fromEntries(entries) as Resolved<K, V>;\n}\n","/* eslint-disable @typescript-eslint/no-unnecessary-type-parameters */\nimport type { TypeCheckFunction } from '../types/private-types';\n\ninterface IsArrayFunction extends TypeCheckFunction<unknown[]>, TypeCheckFunction<readonly unknown[]> {\n  <T extends readonly unknown[]>(value: unknown): value is T;\n  <T extends unknown[]>(value: unknown): value is T;\n  <T>(value: unknown): value is (readonly T[] | T[]);\n}\n\ninterface ExtendedArrayConstructor extends ArrayConstructor {\n  isArray: IsArrayFunction;\n}\n\nexport const { isArray } = Array as ExtendedArrayConstructor;\n\nexport function is(value: unknown, type: 'object'): value is object | null;\nexport function is<T extends object | null | unknown[] | readonly unknown[]>(value: unknown, type: 'object'): value is T;\nexport function is(value: unknown, type: 'function'): value is CallableFunction;\nexport function is<T extends CallableFunction>(value: unknown, type: 'function'): value is T;\nexport function is(value: unknown, type: 'string'): value is string;\nexport function is(value: unknown, type: string): boolean {\n  return typeof value === type;\n}\n","import { is } from './is';\n\nexport function errorInvalidKey(key: unknown): Error {\n  return new Error(`\"${key}\" is not a valid key`);\n}\n\nexport function errorInvalidValue(value: unknown): Error {\n  const formattedValue = is(value, 'string') ? `\"${value}\"` : value;\n  return new Error(`${formattedValue} is not a valid value`);\n}\n","import type { Nullish, TypeCheckFunction, Void } from '../types/private-types';\nimport { errorInvalidValue } from './errors';\n\ntype ValueOrNullishResult<V extends boolean, T> = [isValid: V, value: T];\ntype IsValidResult<V> = ValueOrNullishResult<true, V>;\ntype IsNullishResult = ValueOrNullishResult<false, Nullish>;\n\nexport function validateValue<V>(value: unknown, isValidValue: TypeCheckFunction<V>): IsValidResult<V> | IsNullishResult | Void {\n\n  // return \"valid\" result if value is valid\n  if (isValidValue(value)) return [true, value];\n\n  // return \"nullish\" result if value is nullish\n  if (value == null) return [false, value];\n\n  // return nothing (undefined) if value is invalid\n  // return;\n\n}\n\nexport function validateValueOrThrow<V>(value: unknown, isValidValue: TypeCheckFunction<V>): IsValidResult<V> | IsNullishResult {\n\n  // resolve if value is valid or nullish\n  const resolved = validateValue(value, isValidValue);\n\n  // throw if not resolved\n  if (!resolved) throw errorInvalidValue(value);\n\n  // return resolved value\n  return resolved;\n\n}\n","import { createResultGetValue } from '../tools/create-result';\nimport { is } from '../tools/is';\nimport { validateValueOrThrow } from '../tools/value-nullish';\nimport type { FunctionOption } from '../types/input-types';\nimport type { TypeCheckFunction } from '../types/private-types';\nimport type { KeyList, PotentialResolver } from '../types/resolver-types';\n\nexport function createFunctionResolver<K extends string, V>(\n  keys: KeyList<K>,\n  isValidValue: TypeCheckFunction<V>,\n  defaultValue: V,\n): PotentialResolver<K, V>;\n\nexport function createFunctionResolver<K extends string, V, D = V>(\n  keys: KeyList<K>,\n  isValidValue: TypeCheckFunction<V>,\n  defaultValue: D,\n): PotentialResolver<K, V | D>;\n\nexport function createFunctionResolver<K extends string, V, D = V>(\n  keys: KeyList<K>,\n  isValidValue: TypeCheckFunction<V>,\n  defaultValue: D,\n): PotentialResolver<K, V | D> {\n\n  // return function resolver\n  return (input) => {\n\n    // exit if input is not a function\n    if (!is<FunctionOption<K, V>>(input, 'function')) return;\n\n    const getValue = (key: K) => {\n\n      // get value from input\n      const value = input(key);\n\n      // get data from value if it's valid or nullish\n      const [isValid, validatedValue] = validateValueOrThrow(value, isValidValue);\n\n      // return value if it's valid\n      if (isValid) return validatedValue;\n\n      // return default value if value is nullish\n      return defaultValue;\n\n    };\n\n    // return result\n    return createResultGetValue(\n      keys,\n      getValue,\n    );\n\n  };\n\n}\n","import type { AllowNullish, KeyResolved } from '../types/private-types';\nimport type { KeyList, SpecialKeys } from '../types/resolver-types';\n\nexport function resolveKey<K extends string>(key: string, keys: KeyList<K>, special: AllowNullish<Partial<SpecialKeys<string, K>>>): KeyResolved<K> | undefined {\n  if (keys.includes(key as never)) return [[key as K], false];\n  if (!special) return;\n  const specialResolved = special[key];\n  if (!specialResolved) return;\n  return [specialResolved, true];\n}\n","import type { AllowNullish, NegativeKeyPrefix, PolarKeyResolved, PositiveKeyPrefix } from '../types/private-types';\nimport type { KeyList, SpecialKeys } from '../types/resolver-types';\nimport { is } from './is';\nimport { resolveKey } from './resolve-key';\n\nconst polarityPrefixes = ['!', '+', '-'] as ReadonlyArray<PositiveKeyPrefix | NegativeKeyPrefix>;\n\nexport function resolvePolarKey<K extends string, S extends string>(key: unknown, keys: KeyList<K>, special?: AllowNullish<SpecialKeys<S, K>>): PolarKeyResolved<K> | undefined {\n\n  // throw if item is not a string\n  if (!is(key, 'string')) return;\n\n  // try to resolve positive key\n  const resolved = resolveKey(key, keys, special);\n\n  // return positive key result if resolved\n  if (resolved) {\n    const [resolvedKeys] = resolved;\n    return [resolvedKeys, true];\n  }\n\n  // get first character to test for key polarity\n  const sign = key.charAt(0);\n\n  // fail if first character in not a polarity prefix\n  if (!polarityPrefixes.includes(sign as never)) return;\n\n  // get key without polarity\n  const absoluteKey = key.slice(1) as K;\n\n  // try to resolve key\n  const absoluteResolved = resolveKey(absoluteKey, keys, special);\n\n  // fail if it can't be resolved\n  if (!absoluteResolved) return;\n\n  // return key result with polarity\n  const [resolvedKeys] = absoluteResolved;\n  return [resolvedKeys, sign === '+'];\n\n}\n","import { createResult } from '../tools/create-result';\nimport { errorInvalidKey } from '../tools/errors';\nimport { isArray } from '../tools/is';\nimport { resolvePolarKey } from '../tools/resolve-polar-key';\nimport type { AllowNullish, Nullish, PolarKeyResolved } from '../types/private-types';\nimport type { KeyList, PotentialResolver, Resolved, SpecialKeys } from '../types/resolver-types';\n\nfunction resolveKeyOrThrow<K extends string, S extends string>(key: unknown, keys: KeyList<K>, special?: AllowNullish<SpecialKeys<S, K>>): PolarKeyResolved<K> {\n\n  // try to resolve key\n  const resolvedKey = resolvePolarKey(key, keys, special);\n\n  // throw if it can't be resolved\n  if (!resolvedKey) throw errorInvalidKey(key);\n\n  // return resolved key\n  return resolvedKey;\n\n}\n\nexport function createKeyListResolver<K extends string, S extends string>(\n  keys: KeyList<K>,\n  special: SpecialKeys<S, K>,\n): PotentialResolver<K, boolean>;\n\nexport function createKeyListResolver<K extends string>(\n  keys: KeyList<K>,\n  special?: Nullish,\n): PotentialResolver<K, boolean>;\n\nexport function createKeyListResolver<K extends string, S extends string>(\n  keys: KeyList<K>,\n  special?: AllowNullish<SpecialKeys<S, K>>,\n): PotentialResolver<K, boolean>;\n\nexport function createKeyListResolver<K extends string, S extends string>(\n  keys: KeyList<K>,\n  special?: AllowNullish<SpecialKeys<S, K>>,\n): PotentialResolver<K, boolean> {\n\n  // return array resolver\n  return (input) => {\n\n    // exit if value is not an array\n    if (!isArray(input)) return;\n\n    // resolve to false if input array is empty\n    if (input.length === 0) return createResult(\n      keys,\n      false,\n    );\n\n    // get first key independently from the rest\n    const [first, ...rest] = input;\n\n    // resolve first key\n    const [firstKeys, firstPolarity] = resolveKeyOrThrow(first, keys, special);\n\n    // create result based on first key\n    const base = createResult(\n      keys,\n      !firstPolarity,\n    );\n\n    const override = createResult(\n      firstKeys,\n      firstPolarity,\n    );\n\n    const baseResult = { ...base, ...override };\n\n    // extend base result according to the rest of the items\n    return rest.reduce<Resolved<K, boolean>>((output, key) => {\n\n      // resolve key\n      const [resolvedKeys, resolvedPolarity] = resolveKeyOrThrow(key, keys, special);\n\n      // return updated result\n      const override = createResult(resolvedKeys, resolvedPolarity);\n      return { ...output, ...override };\n\n    }, baseResult);\n\n  };\n\n}\n","/* eslint-disable @typescript-eslint/no-unnecessary-type-parameters */\nimport { createResult } from '../tools/create-result';\nimport { errorInvalidKey } from '../tools/errors';\nimport { is, isArray } from '../tools/is';\nimport { resolveKey } from '../tools/resolve-key';\nimport { validateValueOrThrow } from '../tools/value-nullish';\nimport type { AllowNullish, Nullish, TypeCheckFunction } from '../types/private-types';\nimport type { KeyList, PotentialResolver, Resolved, SpecialKeys } from '../types/resolver-types';\n\ntype ObjectProcessed<K extends string, V, D> = [override: V | D, keys: Array<Resolved<K, V>>, special: Array<Resolved<K, V>>];\n\nfunction processInput<K extends string, S extends string, V, D = V>(\n  input: object,\n  isValidValue: TypeCheckFunction<V>,\n  defaultValue: D,\n  overrideKey: string,\n  keys: KeyList<K>,\n  special?: AllowNullish<SpecialKeys<S, K>>,\n): ObjectProcessed<K, V, D> {\n\n  // get input object keys\n  const objectKeys = Object.keys(input);\n\n  // return array containing processed data\n  return objectKeys.reduce<ObjectProcessed<K, V, D>>((output, key) => {\n\n    // get object key value\n    const value = input[key as never];\n\n    // get data from value if it's valid or nullish\n    const [isValid, validatedValue] = validateValueOrThrow(value, isValidValue);\n\n    // return output without changes if value is nullish\n    if (!isValid) return output;\n\n    // destructure output array\n    const [override, keysData, specialData] = output;\n\n    // set override value if key equals override key\n    if (key === overrideKey) return [validatedValue, keysData, specialData];\n\n    const keyResolved__ = resolveKey(key, keys, special);\n\n    if (!keyResolved__) throw errorInvalidKey(key);\n\n    const [keyResolved, isSpecial] = keyResolved__;\n    const item = createResult(keyResolved, validatedValue);\n\n    if (isSpecial) {\n      const newSpecialData = [...specialData, item];\n      return [override, keysData, newSpecialData];\n    }\n\n    const newKeysData = [...keysData, item];\n    return [override, newKeysData, specialData];\n\n    // // try to resolve key as regular key\n    // const keyResolved = resolveKey(key, keys);\n\n    // // extend regular key data if regular key resolved\n    // if (keyResolved) {\n    //   const item = createResult(keyResolved, validatedValue);\n    //   const newKeysData = [...keysData, item];\n    //   return [override, newKeysData, specialData];\n    // }\n\n    // // throw if special is not defined at this point\n    // if (!special) throw errorInvalidKey(key);\n\n    // // try to resolve key as special key\n    // const specialResolved = special[key as S] as K[] | undefined;\n\n    // // throw if key can't be resolved as special key\n    // if (!specialResolved) throw errorInvalidKey(key);\n\n    // // extend special key data if special key resolved\n    // const item = createResult(specialResolved, validatedValue);\n    // const newSpecialData = [...specialData, item];\n    // return [override, keysData, newSpecialData];\n\n  }, [defaultValue, [], []]);\n\n}\n\nfunction extendResolved<K extends string, V>(output: Resolved<K, V>, extension: Resolved<K, V>): Resolved<K, V> {\n  return { ...output, ...extension };\n}\n\nexport function createObjectResolver<K extends string, S extends string, V, O extends string, D = V>(\n  keys: KeyList<K>,\n  isValidValue: TypeCheckFunction<V>,\n  defaultValue: D,\n  overrideKey: O,\n  special: SpecialKeys<S, K>,\n): PotentialResolver<K, V | D>;\n\nexport function createObjectResolver<K extends string, V, O extends string, D = V>(\n  keys: KeyList<K>,\n  isValidValue: TypeCheckFunction<V>,\n  defaultValue: D,\n  overrideKey: O,\n  special?: Nullish,\n): PotentialResolver<K, V | D>;\n\nexport function createObjectResolver<K extends string, S extends string, V, O extends string>(\n  keys: KeyList<K>,\n  isValidValue: TypeCheckFunction<V>,\n  defaultValue: V,\n  overrideKey: O,\n  special: SpecialKeys<S, K>,\n): PotentialResolver<K, V>;\n\nexport function createObjectResolver<K extends string, V, O extends string>(\n  keys: KeyList<K>,\n  isValidValue: TypeCheckFunction<V>,\n  defaultValue: V,\n  overrideKey: O,\n  special?: Nullish,\n): PotentialResolver<K, V>;\n\nexport function createObjectResolver<K extends string, S extends string, V, O extends string, D = V>(\n  keys: KeyList<K>,\n  isValidValue: TypeCheckFunction<V>,\n  defaultValue: D,\n  overrideKey: O,\n  special?: AllowNullish<SpecialKeys<S, K>>,\n): PotentialResolver<K, V | D>;\n\nexport function createObjectResolver<K extends string, S extends string, V, O extends string, D = V>(\n  keys: KeyList<K>,\n  isValidValue: TypeCheckFunction<V>,\n  defaultValue: D,\n  overrideKey: O,\n  special?: AllowNullish<SpecialKeys<S, K>>,\n): PotentialResolver<K, V | D> {\n\n  // return object resolver\n  return (input) => {\n\n    // exit if it's not an object\n    if (!input || !is(input, 'object') || isArray(input)) return;\n\n    // process input object\n    const [overrideValue, keysData, specialData] = processInput(\n      input,\n      isValidValue,\n      defaultValue,\n      overrideKey,\n      keys,\n      special,\n    );\n\n    // return result create from processed input object\n    return keysData.reduce(\n      extendResolved,\n      specialData.reduce(\n        extendResolved,\n        createResult(keys, overrideValue),\n      ),\n    );\n\n  };\n\n}\n","import { createResult } from '../tools/create-result';\nimport { resolvePolarKey } from '../tools/resolve-polar-key';\nimport type { AllowNullish, Nullish } from '../types/private-types';\nimport type { KeyList, PotentialResolver, SpecialKeys } from '../types/resolver-types';\n\nexport function createKeyResolver<K extends string, S extends string>(\n  keys: KeyList<K>,\n  special: SpecialKeys<S, K>,\n): PotentialResolver<K, boolean>;\n\nexport function createKeyResolver<K extends string>(\n  keys: KeyList<K>,\n  special?: Nullish,\n): PotentialResolver<K, boolean>;\n\nexport function createKeyResolver<K extends string, S extends string>(\n  keys: KeyList<K>,\n  special?: AllowNullish<SpecialKeys<S, K>>,\n): PotentialResolver<K, boolean>;\n\nexport function createKeyResolver<K extends string, S extends string>(\n  keys: KeyList<K>,\n  special?: AllowNullish<SpecialKeys<S, K>>,\n): PotentialResolver<K, boolean> {\n\n  // return string resolver\n  return (input) => {\n\n    // try to resolve value as key or special key\n    const resolvedInput = resolvePolarKey(input, keys, special);\n\n    // exit if it can't be resolved\n    if (!resolvedInput) return;\n\n    // get data from resolved input\n    const [resolvedKeys, polarity] = resolvedInput;\n\n    // create base result\n    const base = createResult(\n      keys,\n      !polarity,\n    );\n\n    // create override result\n    const override = createResult(\n      resolvedKeys,\n      polarity,\n    );\n\n    // return result\n    return { ...base, ...override };\n\n  };\n\n}\n","import { createResult } from '../tools/create-result';\nimport { validateValue } from '../tools/value-nullish';\nimport type { TypeCheckFunction } from '../types/private-types';\nimport type { KeyList, PotentialResolver } from '../types/resolver-types';\n\nexport function createValueResolver<K extends string, V>(\n  keys: KeyList<K>,\n  isValidValue: TypeCheckFunction<V>,\n  defaultValue: V,\n): PotentialResolver<K, V>;\n\nexport function createValueResolver<K extends string, V, D = V>(\n  keys: KeyList<K>,\n  isValidValue: TypeCheckFunction<V>,\n  defaultValue: D,\n): PotentialResolver<K, V | D>;\n\nexport function createValueResolver<K extends string, V, D = V>(\n  keys: KeyList<K>,\n  isValidValue: TypeCheckFunction<V>,\n  defaultValue: D,\n): PotentialResolver<K, V | D> {\n\n  // return value resolver\n  return (input) => {\n\n    // check if value is valid or nullish\n    const validated = validateValue(input, isValidValue);\n\n    // exit if value is not valid nor nullish\n    if (!validated) return;\n\n    // get data from resolved value\n    const [isValid, validatedValue] = validated;\n\n    // return result using value if it's valid\n    if (isValid) return createResult(\n      keys,\n      validatedValue,\n    );\n\n    // return result using default value\n    return createResult(\n      keys,\n      defaultValue,\n    );\n\n  };\n\n}\n","import type { PotentialResolver, Resolver } from '../types/resolver-types';\nimport { errorInvalidValue } from './errors';\n\nexport function createResolver<K extends string, V, I = unknown>(...resolvers: Array<PotentialResolver<K, V>>): Resolver<K, V, I>;\nexport function createResolver<K extends string, V, I = unknown>(...resolvers: Array<PotentialResolver<K, V>>): Resolver<K, V, I> {\n\n  // return resolver\n  return (input) => {\n\n    // iterate through resolvers\n    for (const resolve of resolvers) {\n\n      // execute resolver\n      const result = resolve(input);\n\n      // return result if it's resolved\n      if (result) return result;\n    }\n\n    // throw Error if input can't be resolved\n    throw errorInvalidValue(input);\n\n  };\n\n}\n","import { createFunctionResolver } from '../potential/function';\nimport { createKeyListResolver } from '../potential/key-list';\nimport { createObjectResolver } from '../potential/object';\nimport { createKeyResolver } from '../potential/single-key';\nimport { createValueResolver } from '../potential/value';\nimport { createResolver } from '../tools/create-resolver';\nimport type { BoolBasedSelectiveOption } from '../types/input-types';\nimport type { AllowNullish, Nullish, TypeCheckFunction } from '../types/private-types';\nimport type { BoolBasedResolver, KeyList, SpecialKeys } from '../types/resolver-types';\n\nfunction wrapValueValidator<V>(isValidValue: AllowNullish<TypeCheckFunction<V>>): TypeCheckFunction<V | boolean> {\n  const isBoolean: TypeCheckFunction<boolean> = (value) => {\n    return value === true || value === false;\n  };\n  if (!isValidValue) return isBoolean;\n  const isValueOrBool: TypeCheckFunction<V | boolean> = (value) => {\n    return isValidValue(value) || isBoolean(value);\n  };\n  return isValueOrBool;\n}\n\nexport function createBoolBasedResolver<K extends string, S extends string, V, O extends string, D = V>(\n  keys: KeyList<K>,\n  isValidValue: TypeCheckFunction<V>,\n  defaultValue: D,\n  overrideKey: O,\n  special: SpecialKeys<S, K>,\n): BoolBasedResolver<K, S, V | boolean, O, D>;\n\nexport function createBoolBasedResolver<K extends string, V, O extends string, D = V>(\n  keys: KeyList<K>,\n  isValidValue: TypeCheckFunction<V>,\n  defaultValue: D,\n  overrideKey: O,\n  special?: Nullish,\n): BoolBasedResolver<K, never, V | boolean, O, D>;\n\nexport function createBoolBasedResolver<K extends string, S extends string, O extends string, D>(\n  keys: KeyList<K>,\n  isValidValue: Nullish,\n  defaultValue: D,\n  overrideKey: O,\n  special: SpecialKeys<S, K>,\n): BoolBasedResolver<K, S, boolean, O, D>;\n\nexport function createBoolBasedResolver<K extends string, O extends string, D>(\n  keys: KeyList<K>,\n  isValidValue: Nullish,\n  defaultValue: D,\n  overrideKey: O,\n  special?: Nullish,\n): BoolBasedResolver<K, never, boolean, O, D>;\n\nexport function createBoolBasedResolver<K extends string, S extends string, V, O extends string>(\n  keys: KeyList<K>,\n  isValidValue: TypeCheckFunction<V>,\n  defaultValue: V | boolean,\n  overrideKey: O,\n  special: SpecialKeys<S, K>,\n): BoolBasedResolver<K, S, V | boolean, O>;\n\nexport function createBoolBasedResolver<K extends string, V, O extends string>(\n  keys: KeyList<K>,\n  isValidValue: TypeCheckFunction<V>,\n  defaultValue: V | boolean,\n  overrideKey: O,\n  special?: Nullish,\n): BoolBasedResolver<K, never, V | boolean, O>;\n\nexport function createBoolBasedResolver<K extends string, S extends string, O extends string>(\n  keys: KeyList<K>,\n  isValidValue: Nullish,\n  defaultValue: boolean,\n  overrideKey: O,\n  special: SpecialKeys<S, K>,\n): BoolBasedResolver<K, S, boolean, O>;\n\nexport function createBoolBasedResolver<K extends string, O extends string>(\n  keys: KeyList<K>,\n  isValidValue: Nullish,\n  defaultValue: boolean,\n  overrideKey: O,\n  special?: Nullish,\n): BoolBasedResolver<K, never, boolean, O>;\n\nexport function createBoolBasedResolver<K extends string, S extends string, V, O extends string, D = V>(\n  keys: KeyList<K>,\n  isValidValue: AllowNullish<TypeCheckFunction<V>>,\n  defaultValue: D,\n  overrideKey: O,\n  special?: AllowNullish<SpecialKeys<S, K>>,\n): BoolBasedResolver<K, S, V | boolean, O, D>;\n\nexport function createBoolBasedResolver<K extends string, S extends string, V, O extends string, D = V>(\n  keys: KeyList<K>,\n  isValidValue: AllowNullish<TypeCheckFunction<V>>,\n  defaultValue: D,\n  overrideKey: O,\n  special?: AllowNullish<SpecialKeys<S, K>>,\n): BoolBasedResolver<K, S, V | boolean, O, D> {\n\n  // create boolean value validator\n  const isValueOrBool = wrapValueValidator(isValidValue);\n\n  // create potential resolvers\n  const resolveValue = createValueResolver(keys, isValueOrBool, defaultValue);\n  const resolveFunction = createFunctionResolver(keys, isValueOrBool, defaultValue);\n  const resolveSingleKey = createKeyResolver(keys, special);\n  const resolveKeyList = createKeyListResolver(keys, special);\n  const resolveObject = createObjectResolver(keys, isValueOrBool, defaultValue, overrideKey, special);\n\n  // return compiled resolver\n  return createResolver<K, boolean | V | D, BoolBasedSelectiveOption<K, S, boolean | V, O>>(\n    resolveValue,\n    resolveFunction,\n    resolveSingleKey,\n    resolveKeyList,\n    resolveObject,\n  );\n\n}\n","import { createFunctionResolver } from '../potential/function';\nimport { createObjectResolver } from '../potential/object';\nimport { createValueResolver } from '../potential/value';\nimport { createResolver } from '../tools/create-resolver';\nimport type { ValueBasedSelectiveOption } from '../types/input-types';\nimport type { AllowNullish, Nullish, TypeCheckFunction } from '../types/private-types';\nimport type { KeyList, SpecialKeys, ValueBasedResolver } from '../types/resolver-types';\n\nexport function createValueBasedResolver<K extends string, S extends string, V, O extends string, D = V>(\n  keys: KeyList<K>,\n  isValidValue: TypeCheckFunction<V>,\n  defaultValue: D,\n  overrideKey: O,\n  special: SpecialKeys<S, K>,\n): ValueBasedResolver<K, S | O, V, D>;\n\nexport function createValueBasedResolver<K extends string, V, O extends string, D = V>(\n  keys: KeyList<K>,\n  isValidValue: TypeCheckFunction<V>,\n  defaultValue: D,\n  overrideKey: O,\n  special?: Nullish,\n): ValueBasedResolver<K, O, V, D>;\n\nexport function createValueBasedResolver<K extends string, S extends string, V, O extends string>(\n  keys: KeyList<K>,\n  isValidValue: TypeCheckFunction<V>,\n  defaultValue: V,\n  overrideKey: O,\n  special: SpecialKeys<S, K>,\n): ValueBasedResolver<K, S | O, V>;\n\nexport function createValueBasedResolver<K extends string, V, O extends string>(\n  keys: KeyList<K>,\n  isValidValue: TypeCheckFunction<V>,\n  defaultValue: V,\n  overrideKey: O,\n  special?: Nullish,\n): ValueBasedResolver<K, O, V>;\n\nexport function createValueBasedResolver<K extends string, S extends string, V, O extends string>(\n  keys: KeyList<K>,\n  isValidValue: TypeCheckFunction<V>,\n  defaultValue: V,\n  overrideKey: O,\n  special?: AllowNullish<SpecialKeys<S, K>>,\n): ValueBasedResolver<K, S | O, V>;\n\nexport function createValueBasedResolver<K extends string, S extends string, V, O extends string, D = V>(\n  keys: KeyList<K>,\n  isValidValue: TypeCheckFunction<V>,\n  defaultValue: D,\n  overrideKey: O,\n  special?: AllowNullish<SpecialKeys<S, K>>,\n): ValueBasedResolver<K, S | O, V, D> {\n\n  // create potential resolvers\n  const resolveValue = createValueResolver(keys, isValidValue, defaultValue);\n  const resolveFunction = createFunctionResolver(keys, isValidValue, defaultValue);\n  const resolveObject = createObjectResolver(keys, isValidValue, defaultValue, overrideKey, special);\n\n  // return compiled resolver\n  return createResolver<K, V | D, ValueBasedSelectiveOption<K, O | S, V>>(\n    resolveValue,\n    resolveFunction,\n    resolveObject,\n  );\n\n}\n"],"names":["createResult","keys","value","entries","map","key","Object","fromEntries","deprecatedCreateResult","input","result","assign","createResultGetValue","getValue","isArray","Array","is","type","errorInvalidKey","Error","errorInvalidValue","formattedValue","validateValue","isValidValue","validateValueOrThrow","resolved","createFunctionResolver","defaultValue","_validateValueOrThrow","_validateValueOrThrow2","_maybeArrayLike","_slicedToArray","isValid","validatedValue","resolveKey","special","includes","specialResolved","polarityPrefixes","resolvePolarKey","_resolved","resolvedKeys","sign","charAt","absoluteKey","slice","absoluteResolved","_absoluteResolved","resolveKeyOrThrow","resolvedKey","createKeyListResolver","length","_input","_toArray","first","rest","_resolveKeyOrThrow","_resolveKeyOrThrow2","firstKeys","firstPolarity","base","override","baseResult","reduce","output","_resolveKeyOrThrow3","_resolveKeyOrThrow4","resolvedPolarity","processInput","overrideKey","objectKeys","_output","keysData","specialData","keyResolved__","_keyResolved__","keyResolved","isSpecial","item","newSpecialData","concat","_toConsumableArray","newKeysData","extendResolved","extension","createObjectResolver","_processInput","_processInput2","overrideValue","createKeyResolver","resolvedInput","_resolvedInput","polarity","createValueResolver","validated","_validated","createResolver","_len","arguments","resolvers","_key","_i","_resolvers","resolve","wrapValueValidator","isBoolean","isValueOrBool","createBoolBasedResolver","resolveValue","resolveFunction","resolveSingleKey","resolveKeyList","resolveObject","createValueBasedResolver"],"mappings":"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"}