@effect/platform-node-shared 0.57.0 → 4.0.0-beta.0

package/src/NodeStream.ts

@@ -1,65 +1,97 @@
 /**
  * @since 1.0.0
  */
-import type { PlatformError } from "@effect/platform/Error"
-import type { SizeInput } from "@effect/platform/FileSystem"
-import type { Channel } from "effect/Channel"
-import type { Chunk } from "effect/Chunk"
-import type { Effect } from "effect/Effect"
-import type { LazyArg } from "effect/Function"
+import * as Arr from "effect/Array"
+import * as Cause from "effect/Cause"
+import * as Channel from "effect/Channel"
+import * as Effect from "effect/Effect"
+import * as Exit from "effect/Exit"
+import * as Fiber from "effect/Fiber"
+import type { SizeInput } from "effect/FileSystem"
+import { dual, type LazyArg } from "effect/Function"
+import * as MutableRef from "effect/MutableRef"
+import * as Pull from "effect/Pull"
+import * as Scope from "effect/Scope"
+import * as ServiceMap from "effect/ServiceMap"
 import * as Stream from "effect/Stream"
-import type { Duplex, Readable } from "node:stream"
-import * as internal from "./internal/stream.js"
+import type { Duplex } from "node:stream"
+import { Readable } from "node:stream"
+import { pullIntoWritable } from "./NodeSink.ts"
 
 /**
- * @category models
+ * @category constructors
  * @since 1.0.0
  */
-export interface FromReadableOptions {
-  /** Defaults to undefined, which lets Node.js decide the chunk size */
-  readonly chunkSize?: SizeInput
-  /** Default to true, which means the stream will be closed when done */
+export const fromReadable = <A = Uint8Array, E = Cause.UnknownError>(options: {
+  readonly evaluate: LazyArg<Readable | NodeJS.ReadableStream>
+  readonly onError?: (error: unknown) => E
+  readonly chunkSize?: number | undefined
+  readonly bufferSize?: number | undefined
   readonly closeOnDone?: boolean | undefined
-}
-
-/**
- * @category model
- * @since 1.0.0
- */
-export interface FromWritableOptions {
-  readonly endOnDone?: boolean
-  readonly encoding?: BufferEncoding
-}
+}): Stream.Stream<A, E> => Stream.fromChannel(fromReadableChannel<A, E>(options))
 
 /**
  * @category constructors
  * @since 1.0.0
  */
-export const fromReadable: <E, A = Uint8Array<ArrayBufferLike>>(
-  evaluate: LazyArg<Readable | NodeJS.ReadableStream>,
-  onError: (error: unknown) => E,
-  options?: FromReadableOptions
-) => Stream.Stream<A, E> = internal.fromReadable
+export const fromReadableChannel = <A = Uint8Array, E = Cause.UnknownError>(options: {
+  readonly evaluate: LazyArg<Readable | NodeJS.ReadableStream>
+  readonly onError?: (error: unknown) => E
+  readonly chunkSize?: number | undefined
+  readonly closeOnDone?: boolean | undefined
+}): Channel.Channel<Arr.NonEmptyReadonlyArray<A>, E> =>
+  Channel.fromTransform((_, scope) =>
+    readableToPullUnsafe({
+      scope,
+      readable: options.evaluate(),
+      onError: options.onError ?? defaultOnError as any,
+      chunkSize: options.chunkSize,
+      closeOnDone: options.closeOnDone
+    })
+  )
 
 /**
  * @category constructors
  * @since 1.0.0
  */
-export const fromReadableChannel: <E, A = Uint8Array<ArrayBufferLike>>(
-  evaluate: LazyArg<Readable | NodeJS.ReadableStream>,
-  onError: (error: unknown) => E,
-  options?: FromReadableOptions | undefined
-) => Channel<Chunk<A>, unknown, E> = internal.fromReadableChannel
+export const fromDuplex = <IE, I = Uint8Array, O = Uint8Array, E = Cause.UnknownError>(
+  options: {
+    readonly evaluate: LazyArg<Duplex>
+    readonly onError?: (error: unknown) => E
+    readonly chunkSize?: number | undefined
+    readonly bufferSize?: number | undefined
+    readonly endOnDone?: boolean | undefined
+    readonly encoding?: BufferEncoding | undefined
+  }
+): Channel.Channel<Arr.NonEmptyReadonlyArray<O>, IE | E, void, Arr.NonEmptyReadonlyArray<I>, IE> =>
+  Channel.fromTransform((upstream, scope) => {
+    const duplex = options.evaluate()
+    const exit = MutableRef.make<Exit.Exit<never, IE | E | Cause.Done> | undefined>(undefined)
 
-/**
- * @category constructors
- * @since 1.0.0
- */
-export const fromDuplex: <IE, E, I = Uint8Array, O = Uint8Array>(
-  evaluate: LazyArg<Duplex>,
-  onError: (error: unknown) => E,
-  options?: FromReadableOptions & FromWritableOptions
-) => Channel<Chunk<O>, Chunk<I>, IE | E, IE, void, unknown> = internal.fromDuplex
+    return pullIntoWritable({
+      pull: upstream,
+      writable: duplex,
+      onError: options.onError ?? defaultOnError as any,
+      endOnDone: options.endOnDone,
+      encoding: options.encoding
+    }).pipe(
+      Effect.catchCause((cause) => {
+        if (Pull.isDoneCause(cause)) return Effect.void
+        exit.current = Exit.failCause(cause as Cause.Cause<IE | E | Cause.Done>)
+        return Effect.void
+      }),
+      Effect.forkIn(scope),
+      Effect.flatMap(() =>
+        readableToPullUnsafe({
+          scope,
+          exit,
+          readable: duplex,
+          onError: options.onError ?? defaultOnError as any,
+          chunkSize: options.chunkSize
+        })
+      )
+    )
+  })
 
 /**
  * @category combinators
@@ -70,22 +102,46 @@ export const pipeThroughDuplex: {
    * @category combinators
    * @since 1.0.0
    */
-  <E2, B = Uint8Array>(
-    duplex: LazyArg<Duplex>,
-    onError: (error: unknown) => E2,
-    options?: (FromReadableOptions & FromWritableOptions) | undefined
+  <B = Uint8Array, E2 = Cause.UnknownError>(
+    options: {
+      readonly evaluate: LazyArg<Duplex>
+      readonly onError?: (error: unknown) => E2
+      readonly chunkSize?: number | undefined
+      readonly bufferSize?: number | undefined
+      readonly endOnDone?: boolean | undefined
+      readonly encoding?: BufferEncoding | undefined
+    }
   ): <R, E, A>(self: Stream.Stream<A, E, R>) => Stream.Stream<B, E2 | E, R>
   /**
    * @category combinators
    * @since 1.0.0
    */
-  <R, E, A, E2, B = Uint8Array>(
+  <R, E, A, B = Uint8Array, E2 = Cause.UnknownError>(
     self: Stream.Stream<A, E, R>,
-    duplex: LazyArg<Duplex>,
-    onError: (error: unknown) => E2,
-    options?: (FromReadableOptions & FromWritableOptions) | undefined
+    options: {
+      readonly evaluate: LazyArg<Duplex>
+      readonly onError?: (error: unknown) => E2
+      readonly chunkSize?: number | undefined
+      readonly bufferSize?: number | undefined
+      readonly endOnDone?: boolean | undefined
+      readonly encoding?: BufferEncoding | undefined
+    }
   ): Stream.Stream<B, E | E2, R>
-} = internal.pipeThroughDuplex
+} = dual(2, <R, E, A, B = Uint8Array, E2 = Cause.UnknownError>(
+  self: Stream.Stream<A, E, R>,
+  options: {
+    readonly evaluate: LazyArg<Duplex>
+    readonly onError?: (error: unknown) => E2
+    readonly chunkSize?: number | undefined
+    readonly bufferSize?: number | undefined
+    readonly endOnDone?: boolean | undefined
+    readonly encoding?: BufferEncoding | undefined
+  }
+): Stream.Stream<B, E | E2, R> =>
+  Stream.pipeThroughChannelOrFail(
+    self,
+    fromDuplex(options)
+  ))
 
 /**
  * @category combinators
@@ -96,70 +152,255 @@ export const pipeThroughSimple: {
    * @category combinators
    * @since 1.0.0
    */
-  (duplex: LazyArg<Duplex>): <R, E>(self: Stream.Stream<string | Uint8Array, E, R>) => Stream.Stream<Uint8Array, E | PlatformError, R>
+  (duplex: LazyArg<Duplex>): <R, E>(self: Stream.Stream<string | Uint8Array, E, R>) => Stream.Stream<Uint8Array, E | Cause.UnknownError, R>
   /**
    * @category combinators
    * @since 1.0.0
    */
-  <R, E>(self: Stream.Stream<string | Uint8Array, E, R>, duplex: LazyArg<Duplex>): Stream.Stream<Uint8Array, PlatformError | E, R>
-} = internal.pipeThroughSimple
+  <R, E>(self: Stream.Stream<string | Uint8Array, E, R>, duplex: LazyArg<Duplex>): Stream.Stream<Uint8Array, Cause.UnknownError | E, R>
+} = dual(2, <R, E>(
+  self: Stream.Stream<string | Uint8Array, E, R>,
+  duplex: LazyArg<Duplex>
+): Stream.Stream<Uint8Array, Cause.UnknownError | E, R> => pipeThroughDuplex(self, { evaluate: duplex }))
 
 /**
  * @since 1.0.0
  * @category conversions
  */
-export const toReadable: <E, R>(stream: Stream.Stream<string | Uint8Array, E, R>) => Effect<Readable, never, R> =
-  internal.toReadable
+export const toReadable = <E, R>(stream: Stream.Stream<string | Uint8Array, E, R>): Effect.Effect<Readable, never, R> =>
+  Effect.map(
+    Effect.services<R>(),
+    (context) => new StreamAdapter(context, stream)
+  )
 
 /**
  * @since 1.0.0
  * @category conversions
  */
-export const toReadableNever: <E>(stream: Stream.Stream<string | Uint8Array, E, never>) => Readable =
-  internal.toReadableNever
+export const toReadableNever = <E>(stream: Stream.Stream<string | Uint8Array, E, never>): Readable =>
+  new StreamAdapter(
+    ServiceMap.empty(),
+    stream
+  )
 
 /**
  * @since 1.0.0
  * @category conversions
  */
-export const toString: <E>(
+export const toString = <E = Cause.UnknownError>(
   readable: LazyArg<Readable | NodeJS.ReadableStream>,
-  options: {
-    readonly onFailure: (error: unknown) => E
+  options?: {
+    readonly onError?: (error: unknown) => E
     readonly encoding?: BufferEncoding | undefined
     readonly maxBytes?: SizeInput | undefined
   }
-) => Effect<string, E> = internal.toString
+): Effect.Effect<string, E> => {
+  const maxBytesNumber = options?.maxBytes ? Number(options.maxBytes) : undefined
+  const onError = options?.onError ?? defaultOnError
+  const encoding = options?.encoding ?? "utf8"
+  return Effect.callback((resume) => {
+    const stream = readable() as Readable
+    stream.setEncoding(encoding)
+
+    stream.once("error", (err) => {
+      if ("closed" in stream && !stream.closed) {
+        stream.destroy()
+      }
+      resume(Effect.fail(onError(err) as E))
+    })
+    stream.once("error", (err) => {
+      resume(Effect.fail(onError(err) as E))
+    })
+
+    let string = ""
+    let bytes = 0
+    stream.once("end", () => {
+      resume(Effect.succeed(string))
+    })
+    stream.on("data", (chunk) => {
+      string += chunk
+      bytes += Buffer.byteLength(chunk)
+      if (maxBytesNumber && bytes > maxBytesNumber) {
+        resume(Effect.fail(onError(new Error("maxBytes exceeded")) as E))
+      }
+    })
+    return Effect.sync(() => {
+      if ("closed" in stream && !stream.closed) {
+        stream.destroy()
+      }
+    })
+  })
+}
 
 /**
  * @since 1.0.0
  * @category conversions
  */
-export const toUint8Array: <E>(
+export const toArrayBuffer = <E = Cause.UnknownError>(
   readable: LazyArg<Readable | NodeJS.ReadableStream>,
-  options: { readonly onFailure: (error: unknown) => E; readonly maxBytes?: SizeInput | undefined }
-) => Effect<Uint8Array, E> = internal.toUint8Array
+  options?: {
+    readonly onError?: (error: unknown) => E
+    readonly maxBytes?: SizeInput | undefined
+  }
+): Effect.Effect<ArrayBuffer, E> => {
+  const maxBytesNumber = options?.maxBytes ? Number(options.maxBytes) : undefined
+  const onError = options?.onError ?? defaultOnError
+  return Effect.callback((resume) => {
+    const stream = readable() as Readable
+    let buffer = Buffer.alloc(0)
+    let bytes = 0
+    stream.once("error", (err) => {
+      if ("closed" in stream && !stream.closed) {
+        stream.destroy()
+      }
+      resume(Effect.fail(onError(err) as E))
+    })
+    stream.once("end", () => {
+      if (buffer.buffer.byteLength === buffer.byteLength) {
+        return resume(Effect.succeed(buffer.buffer))
+      }
+      resume(Effect.succeed(buffer.buffer.slice(buffer.byteOffset, buffer.byteOffset + buffer.byteLength)))
+    })
+    stream.on("data", (chunk) => {
+      buffer = Buffer.concat([buffer, chunk])
+      bytes += chunk.length
+      if (maxBytesNumber && bytes > maxBytesNumber) {
+        resume(Effect.fail(onError(new Error("maxBytes exceeded")) as E))
+      }
+    })
+    return Effect.sync(() => {
+      if ("closed" in stream && !stream.closed) {
+        stream.destroy()
+      }
+    })
+  })
+}
 
 /**
  * @since 1.0.0
- * @category stdio
+ * @category conversions
  */
-export const stdin: Stream.Stream<Uint8Array> = internal.fromReadable(() => process.stdin, (err) => err, {
-  closeOnDone: false
-}).pipe(Stream.orDie)
+export const toUint8Array = <E = Cause.UnknownError>(
+  readable: LazyArg<Readable | NodeJS.ReadableStream>,
+  options?: {
+    readonly onError?: (error: unknown) => E
+    readonly maxBytes?: SizeInput | undefined
+  }
+): Effect.Effect<Uint8Array, E> => Effect.map(toArrayBuffer(readable, options), (buffer) => new Uint8Array(buffer))
 
-/**
- * @since 1.0.0
- * @category stdio
- */
-export const stdout: Stream.Stream<Uint8Array> = internal.fromReadable(() => process.stdout, (err) => err, {
-  closeOnDone: false
-}).pipe(Stream.orDie)
+// ----------------------------------------------------------------------------
+// internal
+// ----------------------------------------------------------------------------
 
-/**
- * @since 1.0.0
- * @category stdio
- */
-export const stderr: Stream.Stream<Uint8Array> = internal.fromReadable(() => process.stderr, (err) => err, {
-  closeOnDone: false
-}).pipe(Stream.orDie)
+const readableToPullUnsafe = <A, E>(options: {
+  readonly scope: Scope.Scope
+  readonly exit?: MutableRef.MutableRef<Exit.Exit<never, E | Cause.Done> | undefined> | undefined
+  readonly readable: Readable | NodeJS.ReadableStream
+  readonly onError: (error: unknown) => E
+  readonly chunkSize: number | undefined
+  readonly closeOnDone?: boolean | undefined
+}) => {
+  const readable = options.readable as Readable
+  const closeOnDone = options.closeOnDone ?? true
+  const exit = options.exit ?? MutableRef.make(undefined)
+  const latch = Effect.makeLatchUnsafe(false)
+  function onReadable() {
+    latch.openUnsafe()
+  }
+  function onError(error: unknown) {
+    exit.current = Exit.fail(options.onError(error))
+    latch.openUnsafe()
+  }
+  function onEnd() {
+    exit.current = Exit.fail(Cause.Done())
+    latch.openUnsafe()
+  }
+  readable.on("readable", onReadable)
+  readable.once("error", onError)
+  readable.once("end", onEnd)
+
+  const pull = Effect.suspend(function loop(): Pull.Pull<Arr.NonEmptyReadonlyArray<A>, E> {
+    let item = options.readable.read(options.chunkSize) as A | null
+    if (item === null) {
+      if (exit.current) {
+        return exit.current
+      }
+      latch.closeUnsafe()
+      return Effect.flatMap(latch.await, loop)
+    }
+    const chunk = Arr.of(item as A)
+    while (true) {
+      item = options.readable.read(options.chunkSize)
+      if (item === null) break
+      chunk.push(item)
+    }
+    return Effect.succeed(chunk)
+  })
+
+  return Effect.as(
+    Scope.addFinalizer(
+      options.scope,
+      Effect.sync(() => {
+        readable.off("readable", onReadable)
+        readable.off("error", onError)
+        readable.off("end", onEnd)
+        if (closeOnDone && "closed" in options.readable && !options.readable.closed) {
+          options.readable.destroy()
+        }
+      })
+    ),
+    pull
+  )
+}
+
+class StreamAdapter<E, R> extends Readable {
+  private readonly readLatch: Effect.Latch
+  private fiber: Fiber.Fiber<void, E> | undefined = undefined
+
+  constructor(
+    context: ServiceMap.ServiceMap<R>,
+    stream: Stream.Stream<Uint8Array | string, E, R>
+  ) {
+    super({})
+    this.readLatch = Effect.makeLatchUnsafe(false)
+    this.fiber = Stream.runForEachArray(stream, (chunk) =>
+      this.readLatch.whenOpen(Effect.sync(() => {
+        this.readLatch.closeUnsafe()
+        for (let i = 0; i < chunk.length; i++) {
+          const item = chunk[i]
+          if (typeof item === "string") {
+            this.push(item, "utf8")
+          } else {
+            this.push(item)
+          }
+        }
+      }))).pipe(
+        this.readLatch.whenOpen,
+        Effect.provideServices(context),
+        Effect.runFork
+      )
+    this.fiber.addObserver((exit) => {
+      this.fiber = undefined
+      if (Exit.isSuccess(exit)) {
+        this.push(null)
+      } else {
+        this.destroy(Cause.squash(exit.cause) as any)
+      }
+    })
+  }
+
+  override _read(_size: number): void {
+    this.readLatch.openUnsafe()
+  }
+
+  override _destroy(error: Error | null, callback: (error?: Error | null | undefined) => void): void {
+    if (!this.fiber) {
+      return callback(error)
+    }
+    Effect.runFork(Fiber.interrupt(this.fiber)).addObserver((exit) => {
+      callback(exit._tag === "Failure" ? Cause.squash(exit.cause) as any : error)
+    })
+  }
+}
+
+const defaultOnError = (error: unknown): Cause.UnknownError => new Cause.UnknownError(error)

package/src/NodeTerminal.ts

@@ -1,20 +1,111 @@
 /**
  * @since 1.0.0
  */
-import type { Terminal, UserInput } from "@effect/platform/Terminal"
-import type { Effect } from "effect/Effect"
-import type { Layer } from "effect/Layer"
-import type { Scope } from "effect/Scope"
-import * as InternalTerminal from "./internal/terminal.js"
+import type * as Cause from "effect/Cause"
+import * as Effect from "effect/Effect"
+import * as Layer from "effect/Layer"
+import { badArgument, type PlatformError } from "effect/PlatformError"
+import * as Predicate from "effect/Predicate"
+import * as Queue from "effect/Queue"
+import * as RcRef from "effect/RcRef"
+import type * as Scope from "effect/Scope"
+import * as Terminal from "effect/Terminal"
+import * as readline from "node:readline"
+
 /**
  * @since 1.0.0
  * @category constructors
  */
-export const make: (shouldQuit?: (input: UserInput) => boolean) => Effect<Terminal, never, Scope> =
-  InternalTerminal.make
+export const make: (
+  shouldQuit?: (input: Terminal.UserInput) => boolean
+) => Effect.Effect<Terminal.Terminal, never, Scope.Scope> = Effect.fnUntraced(
+  function*(shouldQuit: (input: Terminal.UserInput) => boolean = defaultShouldQuit) {
+    const stdin = process.stdin
+    const stdout = process.stdout
+
+    // Acquire readline interface with TTY setup/cleanup inside the scope
+    const rlRef = yield* RcRef.make({
+      acquire: Effect.acquireRelease(
+        Effect.sync(() => {
+          const rl = readline.createInterface({ input: stdin, escapeCodeTimeout: 50 })
+          readline.emitKeypressEvents(stdin, rl)
+
+          if (stdin.isTTY) {
+            stdin.setRawMode(true)
+          }
+          return rl
+        }),
+        (rl) =>
+          Effect.sync(() => {
+            if (stdin.isTTY) {
+              stdin.setRawMode(false)
+            }
+            rl.close()
+          })
+      )
+    })
+
+    const columns = Effect.sync(() => stdout.columns ?? 0)
+
+    const readInput = Effect.gen(function*() {
+      yield* RcRef.get(rlRef)
+      const queue = yield* Queue.make<Terminal.UserInput, Cause.Done>()
+      const handleKeypress = (s: string | undefined, k: readline.Key) => {
+        const userInput = {
+          input: s,
+          key: { name: k.name ?? "", ctrl: !!k.ctrl, meta: !!k.meta, shift: !!k.shift }
+        }
+        Queue.offerUnsafe(queue, userInput)
+        if (shouldQuit(userInput)) {
+          Queue.endUnsafe(queue)
+        }
+      }
+      yield* Effect.addFinalizer(() => Effect.sync(() => stdin.off("keypress", handleKeypress)))
+      stdin.on("keypress", handleKeypress)
+      return queue as Queue.Dequeue<Terminal.UserInput, Cause.Done>
+    })
+
+    const readLine = Effect.scoped(
+      Effect.flatMap(RcRef.get(rlRef), (readlineInterface) =>
+        Effect.callback<string, Terminal.QuitError>((resume) => {
+          const onLine = (line: string) => resume(Effect.succeed(line))
+          readlineInterface.once("line", onLine)
+          return Effect.sync(() => readlineInterface.off("line", onLine))
+        }))
+    )
+
+    const display = (prompt: string) =>
+      Effect.uninterruptible(
+        Effect.callback<void, PlatformError>((resume) => {
+          stdout.write(prompt, (err) =>
+            Predicate.isNullish(err)
+              ? resume(Effect.void)
+              : resume(Effect.fail(
+                badArgument({
+                  module: "Terminal",
+                  method: "display",
+                  description: "Failed to write prompt to stdout",
+                  cause: err
+                })
+              )))
+        })
+      )
+
+    return Terminal.make({
+      columns,
+      readInput,
+      readLine,
+      display
+    })
+  }
+)
 
 /**
  * @since 1.0.0
- * @category layer
+ * @category layers
  */
-export const layer: Layer<Terminal> = InternalTerminal.layer
+export const layer: Layer.Layer<Terminal.Terminal> = Layer.effect(Terminal.Terminal, make(defaultShouldQuit))
+
+function defaultShouldQuit(input: Terminal.UserInput) {
+  return input.key.ctrl && (input.key.name === "c" || input.key.name === "d")
+}

package/src/internal/{error.ts → utils.ts}

@@ -1,5 +1,5 @@
-import type { PlatformError, SystemErrorReason } from "@effect/platform/Error"
-import { SystemError } from "@effect/platform/Error"
+import type { SystemError, SystemErrorKind } from "effect/PlatformError"
+import * as PlatformError from "effect/PlatformError"
 import type { PathLike } from "node:fs"
 
 /** @internal */
@@ -7,8 +7,8 @@ export const handleErrnoException = (module: SystemError["module"], method: stri
 (
   err: NodeJS.ErrnoException,
   [path]: [path: PathLike | number, ...args: Array<any>]
-): PlatformError => {
-  let reason: SystemErrorReason = "Unknown"
+): PlatformError.PlatformError => {
+  let reason: SystemErrorKind = "Unknown"
 
   switch (err.code) {
     case "ENOENT":
@@ -40,13 +40,12 @@ export const handleErrnoException = (module: SystemError["module"], method: stri
       break
   }
 
-  return new SystemError({
-    reason,
+  return PlatformError.systemError({
+    kind: reason,
     module,
     method,
     pathOrDescriptor: path as string | number,
     syscall: err.syscall,
-    description: err.message,
     cause: err
   })
 }

package/NodeClusterSocket/package.json

@@ -1,6 +0,0 @@
-{
-  "sideEffects": [],
-  "main": "../dist/cjs/NodeClusterSocket.js",
-  "module": "../dist/esm/NodeClusterSocket.js",
-  "types": "../dist/dts/NodeClusterSocket.d.ts"
-}

package/NodeCommandExecutor/package.json

@@ -1,6 +0,0 @@
-{
-  "sideEffects": [],
-  "main": "../dist/cjs/NodeCommandExecutor.js",
-  "module": "../dist/esm/NodeCommandExecutor.js",
-  "types": "../dist/dts/NodeCommandExecutor.d.ts"
-}

package/NodeFileSystem/ParcelWatcher/package.json

@@ -1,6 +0,0 @@
-{
-  "sideEffects": [],
-  "main": "../../dist/cjs/NodeFileSystem/ParcelWatcher.js",
-  "module": "../../dist/esm/NodeFileSystem/ParcelWatcher.js",
-  "types": "../../dist/dts/NodeFileSystem/ParcelWatcher.d.ts"
-}

package/NodeFileSystem/package.json

@@ -1,6 +0,0 @@
-{
-  "sideEffects": [],
-  "main": "../dist/cjs/NodeFileSystem.js",
-  "module": "../dist/esm/NodeFileSystem.js",
-  "types": "../dist/dts/NodeFileSystem.d.ts"
-}

package/NodeKeyValueStore/package.json

@@ -1,6 +0,0 @@
-{
-  "sideEffects": [],
-  "main": "../dist/cjs/NodeKeyValueStore.js",
-  "module": "../dist/esm/NodeKeyValueStore.js",
-  "types": "../dist/dts/NodeKeyValueStore.d.ts"
-}