@effect/platform-node-shared 0.3.29 → 0.4.1

package/src/internal/fileSystem.ts

@@ -1,8 +1,7 @@
 import { effectify } from "@effect/platform/Effectify"
 import * as Error from "@effect/platform/Error"
 import * as FileSystem from "@effect/platform/FileSystem"
-import type * as ParcelWatcher from "@parcel/watcher"
-import * as Chunk from "effect/Chunk"
+import type * as Context from "effect/Context"
 import * as Effect from "effect/Effect"
 import { pipe } from "effect/Function"
 import * as Layer from "effect/Layer"
@@ -349,7 +348,7 @@ const makeFile = (() => {
             this.position = this.position + BigInt(bytesWritten)
           }
 
-          return bytesWritten < buffer.length ? this.writeAllChunk(buffer.subarray(bytesWritten)) : Effect.unit
+          return bytesWritten < buffer.length ? this.writeAllChunk(buffer.subarray(bytesWritten)) : Effect.void
         }
       )
     }
@@ -524,49 +523,6 @@ const utimes = (() => {
 
 // == watch
 
-const watchParcel = (Watcher: typeof ParcelWatcher, path: string) =>
-  Stream.asyncScoped<FileSystem.WatchEvent, Error.PlatformError>((emit) =>
-    Effect.acquireRelease(
-      Effect.tryPromise({
-        try: () =>
-          Watcher.subscribe(path, (error, events) => {
-            if (error) {
-              emit.fail(Error.SystemError({
-                reason: "Unknown",
-                module: "FileSystem",
-                method: "watch",
-                pathOrDescriptor: path,
-                message: error.message
-              }))
-            } else {
-              emit.chunk(Chunk.unsafeFromArray(events.map((event) => {
-                switch (event.type) {
-                  case "create": {
-                    return FileSystem.WatchEventCreate({ path: event.path })
-                  }
-                  case "update": {
-                    return FileSystem.WatchEventUpdate({ path: event.path })
-                  }
-                  case "delete": {
-                    return FileSystem.WatchEventRemove({ path: event.path })
-                  }
-                }
-              })))
-            }
-          }),
-        catch: (error) =>
-          Error.SystemError({
-            reason: "Unknown",
-            module: "FileSystem",
-            method: "watch",
-            pathOrDescriptor: path,
-            message: (error as Error).message
-          })
-      }),
-      (sub) => Effect.promise(() => sub.unsubscribe())
-    )
-  )
-
 const watchNode = (path: string) =>
   Stream.asyncScoped<FileSystem.WatchEvent, Error.PlatformError>((emit) =>
     Effect.acquireRelease(
@@ -605,15 +561,13 @@ const watchNode = (path: string) =>
     )
   )
 
-const watch = (path: string) =>
+const watch = (backend: Option.Option<Context.Tag.Service<FileSystem.WatchBackend>>, path: string) =>
   stat(path).pipe(
-    Effect.flatMap((stat) =>
-      stat.type === "Directory" ?
-        Effect.matchCause(Effect.promise(() => import("@parcel/watcher")), {
-          onSuccess: (Watcher) => watchParcel(Watcher, path),
-          onFailure: (_) => watchNode(path)
-        }) :
-        Effect.succeed(watchNode(path))
+    Effect.map((stat) =>
+      backend.pipe(
+        Option.flatMap((_) => _.register(path, stat)),
+        Option.getOrElse(() => watchNode(path))
+      )
     ),
     Stream.unwrap
   )
@@ -631,7 +585,7 @@ const writeFile = (path: string, data: Uint8Array, options?: FileSystem.WriteFil
         if (err) {
           resume(Effect.fail(handleErrnoException("FileSystem", "writeFile")(err, [path])))
         } else {
-          resume(Effect.unit)
+          resume(Effect.void)
         }
       })
     } catch (err) {
@@ -639,32 +593,35 @@ const writeFile = (path: string, data: Uint8Array, options?: FileSystem.WriteFil
     }
   })
 
-const fileSystemImpl = FileSystem.make({
-  access,
-  chmod,
-  chown,
-  copy,
-  copyFile,
-  link,
-  makeDirectory,
-  makeTempDirectory,
-  makeTempDirectoryScoped,
-  makeTempFile,
-  makeTempFileScoped,
-  open,
-  readDirectory,
-  readFile,
-  readLink,
-  realPath,
-  remove,
-  rename,
-  stat,
-  symlink,
-  truncate,
-  utimes,
-  watch,
-  writeFile
-})
+const makeFileSystem = Effect.map(Effect.serviceOption(FileSystem.WatchBackend), (backend) =>
+  FileSystem.make({
+    access,
+    chmod,
+    chown,
+    copy,
+    copyFile,
+    link,
+    makeDirectory,
+    makeTempDirectory,
+    makeTempDirectoryScoped,
+    makeTempFile,
+    makeTempFileScoped,
+    open,
+    readDirectory,
+    readFile,
+    readLink,
+    realPath,
+    remove,
+    rename,
+    stat,
+    symlink,
+    truncate,
+    utimes,
+    watch(path) {
+      return watch(backend, path)
+    },
+    writeFile
+  }))
 
 /** @internal */
-export const layer = Layer.succeed(FileSystem.FileSystem, fileSystemImpl)
+export const layer = Layer.effect(FileSystem.FileSystem, makeFileSystem)

package/src/internal/runtime.ts

@@ -15,7 +15,7 @@ export const runMain: RunMain = (
       effect :
       Effect.tapErrorCause(effect, (cause) => {
         if (Cause.isInterruptedOnly(cause)) {
-          return Effect.unit
+          return Effect.void
         }
         return Effect.logError(cause)
       })

package/src/internal/sink.ts

@@ -33,7 +33,7 @@ export const fromWritableChannel = <IE, OE, A>(
           writable,
           (cause) => Deferred.failCause(deferred, cause),
           options,
-          Deferred.complete(deferred, Effect.unit)
+          Deferred.complete(deferred, Effect.void)
         )
       )
   )

package/src/internal/stream.ts

@@ -224,21 +224,21 @@ export const writeInput = <IE, A>(
   writable: Writable | NodeJS.WritableStream,
   onFailure: (cause: Cause.Cause<IE>) => Effect.Effect<void>,
   { encoding, endOnDone = true }: FromWritableOptions = {},
-  onDone = Effect.unit
+  onDone = Effect.void
 ): AsyncInput.AsyncInputProducer<IE, Chunk.Chunk<A>, unknown> => {
   const write = writeEffect(writable, encoding)
   const close = endOnDone
     ? Effect.async<void>((resume) => {
       if ("closed" in writable && writable.closed) {
-        resume(Effect.unit)
+        resume(Effect.void)
       } else {
-        writable.once("finish", () => resume(Effect.unit))
+        writable.once("finish", () => resume(Effect.void))
         writable.end()
       }
     })
-    : Effect.unit
+    : Effect.void
   return {
-    awaitRead: () => Effect.unit,
+    awaitRead: () => Effect.void,
     emit: write,
     error: (cause) => Effect.zipRight(close, onFailure(cause)),
     done: (_) => Effect.zipRight(close, onDone)
@@ -252,7 +252,7 @@ export const writeEffect = <A>(
 ) =>
 (chunk: Chunk.Chunk<A>) =>
   chunk.length === 0 ?
-    Effect.unit :
+    Effect.void :
     Effect.async<void>((resume) => {
       const iterator = chunk[Symbol.iterator]()
       let next = iterator.next()
@@ -261,7 +261,7 @@ export const writeEffect = <A>(
         next = iterator.next()
         const success = writable.write(item.value, encoding as any)
         if (next.done) {
-          resume(Effect.unit)
+          resume(Effect.void)
         } else if (success) {
           loop()
         } else {
@@ -287,7 +287,7 @@ const readableOffer = <E>(
       queue.unsafeOffer(Either.left(Exit.fail(onError(err))))
     })
     readable.on("end", () => {
-      queue.unsafeOffer(Either.left(Exit.unit))
+      queue.unsafeOffer(Either.left(Exit.void))
     })
     if (readable.readable) {
       queue.unsafeOffer(Either.right(void 0))
@@ -305,7 +305,7 @@ const readableTake = <E, A>(
     Either.match({
       onLeft: Exit.match({
         onFailure: Channel.failCause,
-        onSuccess: (_) => Channel.unit
+        onSuccess: (_) => Channel.void
       }),
       onRight: (_) => Channel.flatMap(read, () => loop)
     })
@@ -376,7 +376,7 @@ class StreamAdapter<E, R> extends Readable {
   }
 
   _destroy(_error: Error | null, callback: (error?: Error | null | undefined) => void): void {
-    Runtime.runFork(this.runtime)(Scope.close(this.scope, Exit.unit)).addObserver((exit) => {
+    Runtime.runFork(this.runtime)(Scope.close(this.scope, Exit.void)).addObserver((exit) => {
       callback(exit._tag === "Failure" ? Cause.squash(exit.cause) as any : null)
     })
   }

package/src/internal/terminal.ts

@@ -102,7 +102,7 @@ export const make = (
                 message: (err as Error).message ?? String(err)
               })))
             }
-            resume(Effect.unit)
+            resume(Effect.void)
           })
         })
       )