Function fromMap

packages/effect/src/internal/configProvider.ts:153–199

(
  map: Map<string, string>,
  config?: Partial<ConfigProvider.ConfigProvider.FromMapConfig>
)

/** @internal */
export const fromMap = (
  map: Map<string, string>,
  config?: Partial<ConfigProvider.ConfigProvider.FromMapConfig>
): ConfigProvider.ConfigProvider => {
  const { pathDelim, seqDelim } = Object.assign({ seqDelim: ",", pathDelim: "." }, config)
  const makePathString = (path: ReadonlyArray<string>): string => pipe(path, Arr.join(pathDelim))
  const unmakePathString = (pathString: string): ReadonlyArray<string> => pathString.split(pathDelim)
  const mapWithIndexSplit = splitIndexInKeys(
    map,
    (str) => unmakePathString(str),
    makePathString
  )
  const load = <A>(
    path: ReadonlyArray<string>,
    primitive: Config.Config.Primitive<A>,
    split = true
  ): Effect.Effect<Array<A>, ConfigError.ConfigError> => {
    const pathString = makePathString(path)
    const valueOpt = mapWithIndexSplit.has(pathString) ?
      Option.some(mapWithIndexSplit.get(pathString)!) :
      Option.none()
    return pipe(
      valueOpt,
      core.mapError(() => configError.MissingData(path, `Expected ${pathString} to exist in the provided map`)),
      core.flatMap((value) => parsePrimitive(value, path, primitive, seqDelim, split))
    )
  }
  const enumerateChildren = (
    path: ReadonlyArray<string>
  ): Effect.Effect<HashSet.HashSet<string>, ConfigError.ConfigError> =>
    core.sync(() => {
      const keyPaths = Arr.fromIterable(mapWithIndexSplit.keys()).map(unmakePathString)
      const filteredKeyPaths = keyPaths.filter((keyPath) => {
        for (let i = 0; i < path.length; i++) {
          const pathComponent = pipe(path, Arr.unsafeGet(i))
          const currentElement = keyPath[i]
          if (currentElement === undefined || pathComponent !== currentElement) {
            return false
          }
        }
        return true
      }).flatMap((keyPath) => keyPath.slice(path.length, path.length + 1))
      return HashSet.fromIterable(filteredKeyPaths)
    })

  return fromFlat(makeFlat({ load, enumerateChildren, patch: pathPatch.empty }))
}

const extend = <A, B>(
  leftDef: (n: number) => A,