effect 2.4.18 → 3.0.0

package/src/internal/configProvider.ts

@@ -1,3 +1,4 @@
+import * as Array from "../Array.js"
 import type * as Config from "../Config.js"
 import type * as ConfigError from "../ConfigError.js"
 import type * as ConfigProvider from "../ConfigProvider.js"
@@ -12,7 +13,7 @@ import * as HashSet from "../HashSet.js"
 import * as number from "../Number.js"
 import * as Option from "../Option.js"
 import { pipeArguments } from "../Pipeable.js"
-import * as ReadonlyArray from "../ReadonlyArray.js"
+import * as regexp from "../RegExp.js"
 import type * as _config from "./config.js"
 import * as configError from "./configError.js"
 import * as pathPatch from "./configProvider/pathPatch.js"
@@ -84,12 +85,12 @@ export const makeFlat = (
 export const fromFlat = (flat: ConfigProvider.ConfigProvider.Flat): ConfigProvider.ConfigProvider =>
   make({
     load: (config) =>
-      core.flatMap(fromFlatLoop(flat, ReadonlyArray.empty(), config, false), (chunk) =>
-        Option.match(ReadonlyArray.head(chunk), {
+      core.flatMap(fromFlatLoop(flat, Array.empty(), config, false), (chunk) =>
+        Option.match(Array.head(chunk), {
           onNone: () =>
             core.fail(
               configError.MissingData(
-                ReadonlyArray.empty(),
+                Array.empty(),
                 `Expected a single value having structure: ${config}`
               )
             ),
@@ -103,7 +104,7 @@ export const fromEnv = (
   config?: Partial<ConfigProvider.ConfigProvider.FromEnvConfig>
 ): ConfigProvider.ConfigProvider => {
   const { pathDelim, seqDelim } = Object.assign({}, { pathDelim: "_", seqDelim: "," }, config)
-  const makePathString = (path: ReadonlyArray<string>): string => pipe(path, ReadonlyArray.join(pathDelim))
+  const makePathString = (path: ReadonlyArray<string>): string => pipe(path, Array.join(pathDelim))
   const unmakePathString = (pathString: string): ReadonlyArray<string> => pathString.split(pathDelim)
 
   const getEnv = () =>
@@ -130,10 +131,10 @@ export const fromEnv = (
     core.sync(() => {
       const current = getEnv()
       const keys = Object.keys(current)
-      const keyPaths = Array.from(keys).map((value) => unmakePathString(value.toUpperCase()))
+      const keyPaths = keys.map((value) => unmakePathString(value.toUpperCase()))
       const filteredKeyPaths = keyPaths.filter((keyPath) => {
         for (let i = 0; i < path.length; i++) {
-          const pathComponent = pipe(path, ReadonlyArray.unsafeGet(i))
+          const pathComponent = pipe(path, Array.unsafeGet(i))
           const currentElement = keyPath[i]
           if (currentElement === undefined || pathComponent !== currentElement) {
             return false
@@ -153,11 +154,11 @@ export const fromMap = (
   config?: Partial<ConfigProvider.ConfigProvider.FromMapConfig>
 ): ConfigProvider.ConfigProvider => {
   const { pathDelim, seqDelim } = Object.assign({ seqDelim: ",", pathDelim: "." }, config)
-  const makePathString = (path: ReadonlyArray<string>): string => pipe(path, ReadonlyArray.join(pathDelim))
+  const makePathString = (path: ReadonlyArray<string>): string => pipe(path, Array.join(pathDelim))
   const unmakePathString = (pathString: string): ReadonlyArray<string> => pathString.split(pathDelim)
   const mapWithIndexSplit = splitIndexInKeys(
     map,
-    (str) => Array.from(unmakePathString(str)),
+    (str) => unmakePathString(str),
     makePathString
   )
   const load = <A>(
@@ -179,10 +180,10 @@ export const fromMap = (
     path: ReadonlyArray<string>
   ): Effect.Effect<HashSet.HashSet<string>, ConfigError.ConfigError> =>
     core.sync(() => {
-      const keyPaths = Array.from(mapWithIndexSplit.keys()).map(unmakePathString)
+      const keyPaths = Array.fromIterable(mapWithIndexSplit.keys()).map(unmakePathString)
       const filteredKeyPaths = keyPaths.filter((keyPath) => {
         for (let i = 0; i < path.length; i++) {
-          const pathComponent = pipe(path, ReadonlyArray.unsafeGet(i))
+          const pathComponent = pipe(path, Array.unsafeGet(i))
           const currentElement = keyPath[i]
           if (currentElement === undefined || pathComponent !== currentElement) {
             return false
@@ -202,14 +203,14 @@ const extend = <A, B>(
   left: ReadonlyArray<A>,
   right: ReadonlyArray<B>
 ): [ReadonlyArray<A>, ReadonlyArray<B>] => {
-  const leftPad = ReadonlyArray.unfold(
+  const leftPad = Array.unfold(
     left.length,
     (index) =>
       index >= right.length ?
         Option.none() :
         Option.some([leftDef(index), index + 1])
   )
-  const rightPad = ReadonlyArray.unfold(
+  const rightPad = Array.unfold(
     right.length,
     (index) =>
       index >= left.length ?
@@ -243,7 +244,7 @@ const fromFlatLoop = <A>(
   const op = config as _config.ConfigPrimitive
   switch (op._tag) {
     case OpCodes.OP_CONSTANT: {
-      return core.succeed(ReadonlyArray.of(op.value)) as Effect.Effect<ReadonlyArray<A>, ConfigError.ConfigError>
+      return core.succeed(Array.of(op.value)) as Effect.Effect<ReadonlyArray<A>, ConfigError.ConfigError>
     }
     case OpCodes.OP_DESCRIBED: {
       return core.suspend(
@@ -295,7 +296,7 @@ const fromFlatLoop = <A>(
       return core.suspend(() =>
         fromFlatLoop(
           flat,
-          concat(prefix, ReadonlyArray.of(op.name)),
+          concat(prefix, Array.of(op.name)),
           op.config,
           split
         )
@@ -309,7 +310,7 @@ const fromFlatLoop = <A>(
             flat.load(prefix, op, split),
             core.flatMap((values) => {
               if (values.length === 0) {
-                const name = pipe(ReadonlyArray.last(prefix), Option.getOrElse(() => "<n/a>"))
+                const name = pipe(Array.last(prefix), Option.getOrElse(() => "<n/a>"))
                 return core.fail(configError.MissingData([], `Expected ${op.description} with name ${name}`))
               }
               return core.succeed(values)
@@ -328,20 +329,20 @@ const fromFlatLoop = <A>(
             core.flatMap((indices) => {
               if (indices.length === 0) {
                 return core.suspend(() =>
-                  core.map(fromFlatLoop(flat, patchedPrefix, op.config, true), ReadonlyArray.of)
+                  core.map(fromFlatLoop(flat, patchedPrefix, op.config, true), Array.of)
                 ) as unknown as Effect.Effect<ReadonlyArray<A>, ConfigError.ConfigError>
               }
               return pipe(
                 core.forEachSequential(
                   indices,
-                  (index) => fromFlatLoop(flat, ReadonlyArray.append(prefix, `[${index}]`), op.config, true)
+                  (index) => fromFlatLoop(flat, Array.append(prefix, `[${index}]`), op.config, true)
                 ),
                 core.map((chunkChunk) => {
-                  const flattened = ReadonlyArray.flatten(chunkChunk)
+                  const flattened = Array.flatten(chunkChunk)
                   if (flattened.length === 0) {
-                    return ReadonlyArray.of(ReadonlyArray.empty<A>())
+                    return Array.of(Array.empty<A>())
                   }
-                  return ReadonlyArray.of(flattened)
+                  return Array.of(flattened)
                 })
               ) as unknown as Effect.Effect<ReadonlyArray<A>, ConfigError.ConfigError>
             })
@@ -362,21 +363,18 @@ const fromFlatLoop = <A>(
                   core.forEachSequential((key) =>
                     fromFlatLoop(
                       flat,
-                      concat(prefix, ReadonlyArray.of(key)),
+                      concat(prefix, Array.of(key)),
                       op.valueConfig,
                       split
                     )
                   ),
-                  core.map((values) => {
-                    if (values.length === 0) {
-                      return ReadonlyArray.of(HashMap.empty())
+                  core.map((matrix) => {
+                    if (matrix.length === 0) {
+                      return Array.of(HashMap.empty())
                     }
-                    const matrix = values.map((x) => Array.from(x))
                     return pipe(
                       transpose(matrix),
-                      ReadonlyArray.map((values) =>
-                        HashMap.fromIterable(ReadonlyArray.zip(ReadonlyArray.fromIterable(keys), values))
-                      )
+                      Array.map((values) => HashMap.fromIterable(Array.zip(Array.fromIterable(keys), values)))
                     )
                   })
                 )
@@ -406,17 +404,17 @@ const fromFlatLoop = <A>(
                   return core.fail(right.left)
                 }
                 if (Either.isRight(left) && Either.isRight(right)) {
-                  const path = pipe(prefix, ReadonlyArray.join("."))
+                  const path = pipe(prefix, Array.join("."))
                   const fail = fromFlatLoopFail(prefix, path)
                   const [lefts, rights] = extend(
                     fail,
                     fail,
-                    pipe(left.right, ReadonlyArray.map(Either.right)),
-                    pipe(right.right, ReadonlyArray.map(Either.right))
+                    pipe(left.right, Array.map(Either.right)),
+                    pipe(right.right, Array.map(Either.right))
                   )
                   return pipe(
                     lefts,
-                    ReadonlyArray.zip(rights),
+                    Array.zip(rights),
                     core.forEachSequential(([left, right]) =>
                       pipe(
                         core.zip(left, right),
@@ -589,13 +587,13 @@ export const within = dual<
     f: (self: ConfigProvider.ConfigProvider) => ConfigProvider.ConfigProvider
   ) => ConfigProvider.ConfigProvider
 >(3, (self, path, f) => {
-  const unnest = ReadonlyArray.reduce(path, self, (provider, name) => unnested(provider, name))
-  const nest = ReadonlyArray.reduceRight(path, f(unnest), (provider, name) => nested(provider, name))
+  const unnest = Array.reduce(path, self, (provider, name) => unnested(provider, name))
+  const nest = Array.reduceRight(path, f(unnest), (provider, name) => nested(provider, name))
   return orElse(nest, () => self)
 })
 
 const splitPathString = (text: string, delim: string): ReadonlyArray<string> => {
-  const split = text.split(new RegExp(`\\s*${escapeRegex(delim)}\\s*`))
+  const split = text.split(new RegExp(`\\s*${regexp.escape(delim)}\\s*`))
   return split
 }
 
@@ -611,7 +609,7 @@ const parsePrimitive = <A>(
       primitive.parse(text),
       core.mapBoth({
         onFailure: configError.prefixed(path),
-        onSuccess: ReadonlyArray.of
+        onSuccess: Array.of
       })
     )
   }
@@ -626,14 +624,12 @@ const transpose = <A>(array: ReadonlyArray<ReadonlyArray<A>>): ReadonlyArray<Rea
   return Object.keys(array[0]).map((column) => array.map((row) => row[column as any]))
 }
 
-const escapeRegex = (string: string): string => string.replace(/[/\-\\^$*+?.()|[\]{}]/g, "\\$&")
-
 const indicesFrom = (quotedIndices: HashSet.HashSet<string>): Effect.Effect<ReadonlyArray<number>> =>
   pipe(
     core.forEachSequential(quotedIndices, parseQuotedIndex),
     core.mapBoth({
-      onFailure: () => ReadonlyArray.empty<number>(),
-      onSuccess: ReadonlyArray.sort(number.Order)
+      onFailure: () => Array.empty<number>(),
+      onSuccess: Array.sort(number.Order)
     }),
     core.either,
     core.map(Either.merge)
@@ -665,10 +661,10 @@ const splitIndexInKeys = (
   for (const [pathString, value] of map) {
     const keyWithIndex = pipe(
       unmakePathString(pathString),
-      ReadonlyArray.flatMap((key) =>
+      Array.flatMap((key) =>
         Option.match(splitIndexFrom(key), {
-          onNone: () => ReadonlyArray.of(key),
-          onSome: ([key, index]) => ReadonlyArray.make(key, `[${index}]`)
+          onNone: () => Array.of(key),
+          onSome: ([key, index]) => Array.make(key, `[${index}]`)
         })
       )
     )
@@ -721,7 +717,7 @@ interface JsonArray extends Array<string | number | boolean | null | JsonArray |
 /** @internal */
 export const fromJson = (json: unknown): ConfigProvider.ConfigProvider => {
   const hiddenDelimiter = "\ufeff"
-  const indexedEntries = ReadonlyArray.map(
+  const indexedEntries = Array.map(
     getIndexedEntries(json as JsonMap),
     ([key, value]): [string, string] => [configPathToString(key).join(hiddenDelimiter), value]
   )
@@ -763,10 +759,10 @@ const getIndexedEntries = (
     value: string | number | boolean | JsonMap | JsonArray | null
   ): ReadonlyArray<[path: ReadonlyArray<KeyComponent>, value: string]> => {
     if (typeof value === "string") {
-      return ReadonlyArray.make([path, value] as [ReadonlyArray<KeyComponent>, string])
+      return Array.make([path, value] as [ReadonlyArray<KeyComponent>, string])
     }
     if (typeof value === "number" || typeof value === "boolean") {
-      return ReadonlyArray.make([path, String(value)] as [ReadonlyArray<KeyComponent>, string])
+      return Array.make([path, String(value)] as [ReadonlyArray<KeyComponent>, string])
     }
     if (Array.isArray(value)) {
       return loopArray(path, value)
@@ -774,27 +770,27 @@ const getIndexedEntries = (
     if (typeof value === "object" && value !== null) {
       return loopObject(path, value)
     }
-    return ReadonlyArray.empty<[ReadonlyArray<KeyComponent>, string]>()
+    return Array.empty<[ReadonlyArray<KeyComponent>, string]>()
   }
   const loopArray = (
     path: ReadonlyArray<KeyComponent>,
     values: JsonArray
   ): ReadonlyArray<[path: ReadonlyArray<KeyComponent>, value: string]> =>
-    ReadonlyArray.match(values, {
-      onEmpty: () => ReadonlyArray.make([path, "<nil>"] as [ReadonlyArray<KeyComponent>, string]),
-      onNonEmpty: ReadonlyArray.flatMap((value, index) => loopAny(ReadonlyArray.append(path, keyIndex(index)), value))
+    Array.match(values, {
+      onEmpty: () => Array.make([path, "<nil>"] as [ReadonlyArray<KeyComponent>, string]),
+      onNonEmpty: Array.flatMap((value, index) => loopAny(Array.append(path, keyIndex(index)), value))
     })
   const loopObject = (
     path: ReadonlyArray<KeyComponent>,
     value: JsonMap
   ): ReadonlyArray<[path: ReadonlyArray<KeyComponent>, value: string]> =>
     Object.entries(value).flatMap(([key, value]) => {
-      const newPath = ReadonlyArray.append(path, keyName(key))
+      const newPath = Array.append(path, keyName(key))
       const result = loopAny(newPath, value)
-      if (ReadonlyArray.isEmptyReadonlyArray(result)) {
-        return ReadonlyArray.make([newPath, ""] as [ReadonlyArray<KeyComponent>, string])
+      if (Array.isEmptyReadonlyArray(result)) {
+        return Array.make([newPath, ""] as [ReadonlyArray<KeyComponent>, string])
       }
       return result
     })
-  return loopObject(ReadonlyArray.empty(), config)
+  return loopObject(Array.empty(), config)
 }