@effect/platform 0.0.0

package/src/FileSystem/File.ts

@@ -0,0 +1,125 @@
+/**
+ * @since 1.0.0
+ */
+import * as Brand from "@effect/data/Brand"
+import type { Option } from "@effect/data/Option"
+import type * as Effect from "@effect/io/Effect"
+import type { PlatformError } from "@effect/platform/Error"
+import type { Size } from "@effect/platform/FileSystem"
+
+/**
+ * @since 1.0.0
+ * @category type id
+ */
+export const FileTypeId: unique symbol = Symbol.for(
+  "@effect/platform/FileSystem/File"
+)
+
+/**
+ * @since 1.0.0
+ * @category type id
+ */
+export type FileTypeId = typeof FileTypeId
+
+/**
+ * @since 1.0.0
+ * @category guard
+ */
+export const isFile = (u: unknown): u is File => typeof u === "object" && u !== null && FileTypeId in u
+
+/**
+ * @since 1.0.0
+ * @category model
+ */
+export interface File {
+  readonly [FileTypeId]: FileTypeId
+  readonly fd: File.Descriptor
+  readonly stat: Effect.Effect<never, PlatformError, File.Info>
+  readonly read: (
+    buffer: Uint8Array,
+    options?: FileReadOptions
+  ) => Effect.Effect<never, PlatformError, Size>
+  readonly readAlloc: (
+    size: Size,
+    options?: FileReadOptions
+  ) => Effect.Effect<never, PlatformError, Option<Uint8Array>>
+  readonly truncate: (
+    length?: Size
+  ) => Effect.Effect<never, PlatformError, void>
+  readonly write: (
+    buffer: Uint8Array
+  ) => Effect.Effect<never, PlatformError, Size>
+  readonly writeAll: (
+    buffer: Uint8Array
+  ) => Effect.Effect<never, PlatformError, void>
+}
+
+/**
+ * @since 1.0.0
+ * @category constructor
+ */
+export const make = (impl: Omit<File, FileTypeId>): File => ({
+  [FileTypeId]: FileTypeId,
+  ...impl
+})
+
+/**
+ * @since 1.0.0
+ */
+export namespace File {
+  /**
+   * @since 1.0.0
+   * @category model
+   */
+  export type Descriptor = Brand.Branded<number, "FileDescriptor">
+
+  /**
+   * @since 1.0.0
+   * @category model
+   */
+  export type Type =
+    | "File"
+    | "Directory"
+    | "SymbolicLink"
+    | "BlockDevice"
+    | "CharacterDevice"
+    | "FIFO"
+    | "Socket"
+    | "Unknown"
+
+  /**
+   * @since 1.0.0
+   * @category model
+   */
+  export interface Info {
+    readonly type: Type
+    readonly mtime: Option<Date>
+    readonly atime: Option<Date>
+    readonly birthtime: Option<Date>
+    readonly dev: number
+    readonly ino: Option<number>
+    readonly mode: number
+    readonly nlink: Option<number>
+    readonly uid: Option<number>
+    readonly gid: Option<number>
+    readonly rdev: Option<number>
+    readonly size: Size
+    readonly blksize: Option<Size>
+    readonly blocks: Option<number>
+  }
+}
+
+/**
+ * @since 1.0.0
+ * @category constructor
+ */
+export const Descriptor = Brand.nominal<File.Descriptor>()
+
+/**
+ * @since 1.0.0
+ * @category model
+ */
+export interface FileReadOptions {
+  readonly offset?: Size
+  readonly length?: Size
+}

package/src/FileSystem.ts

@@ -0,0 +1,237 @@
+/**
+ * @since 1.0.0
+ */
+import type * as Brand from "@effect/data/Brand"
+import type { Tag } from "@effect/data/Context"
+import type * as Effect from "@effect/io/Effect"
+import type { Scope } from "@effect/io/Scope"
+import type { PlatformError } from "@effect/platform/Error"
+import type { File } from "@effect/platform/FileSystem/File"
+import * as internal from "@effect/platform/internal/fileSystem"
+import type { Sink } from "@effect/stream/Sink"
+import type { Stream } from "@effect/stream/Stream"
+
+/**
+ * Represents a size in bytes.
+ *
+ * @since 1.0.0
+ * @category model
+ */
+export type Size = Brand.Branded<bigint, "Size">
+
+/**
+ * @since 1.0.0
+ * @category constructor
+ */
+export const Size: (bytes: number | bigint) => Size = internal.Size
+
+/**
+ * @since 1.0.0
+ * @category model
+ */
+export interface AccessFileOptions {
+  readonly ok?: boolean
+  readonly readable?: boolean
+  readonly writable?: boolean
+}
+
+/**
+ * @since 1.0.0
+ * @category model
+ */
+export interface MakeDirectoryOptions {
+  readonly recursive?: boolean
+  readonly mode?: number
+}
+
+/**
+ * @since 1.0.0
+ * @category model
+ */
+export interface MakeTempDirectoryOptions {
+  readonly directory?: string
+  readonly prefix?: string
+}
+
+/**
+ * @since 1.0.0
+ * @category model
+ */
+export interface MakeTempFileOptions {
+  readonly directory?: string
+  readonly prefix?: string
+}
+
+/**
+ * @since 1.0.0
+ * @category model
+ */
+export type OpenFlag =
+  | "r"
+  | "r+"
+  | "w"
+  | "wx"
+  | "w+"
+  | "wx+"
+  | "a"
+  | "ax"
+  | "a+"
+  | "ax+"
+
+/**
+ * @since 1.0.0
+ * @category model
+ */
+export interface OpenFileOptions {
+  readonly flag?: OpenFlag
+  readonly mode?: number
+}
+
+/**
+ * @since 1.0.0
+ * @category model
+ */
+export interface ReadDirectoryOptions {
+  readonly recursive?: boolean
+}
+
+/**
+ * @since 1.0.0
+ * @category model
+ */
+export interface RemoveOptions {
+  readonly recursive?: boolean
+}
+
+/**
+ * @since 1.0.0
+ * @category model
+ */
+export interface SinkOptions extends OpenFileOptions {}
+
+/**
+ * @since 1.0.0
+ * @category model
+ */
+export interface StreamOptions {
+  bufferSize?: number
+  bytesToRead?: Size
+  chunkSize?: Size
+  offset?: Size
+}
+
+/**
+ * @since 1.0.0
+ * @category model
+ */
+export interface WriteFileOptions {
+  readonly flag?: OpenFlag
+  readonly mode?: number
+}
+
+/**
+ * @since 1.0.0
+ * @category model
+ */
+export interface FileSystem {
+  readonly access: (
+    path: string,
+    options?: AccessFileOptions
+  ) => Effect.Effect<never, PlatformError, void>
+  readonly copyFile: (
+    fromPath: string,
+    toPath: string
+  ) => Effect.Effect<never, PlatformError, void>
+  readonly chmod: (
+    path: string,
+    mode: number
+  ) => Effect.Effect<never, PlatformError, void>
+  readonly chown: (
+    path: string,
+    uid: number,
+    gid: number
+  ) => Effect.Effect<never, PlatformError, void>
+  readonly link: (
+    fromPath: string,
+    toPath: string
+  ) => Effect.Effect<never, PlatformError, void>
+  readonly makeDirectory: (
+    path: string,
+    options?: MakeDirectoryOptions
+  ) => Effect.Effect<never, PlatformError, void>
+  readonly makeTempDirectory: (
+    options?: MakeTempDirectoryOptions
+  ) => Effect.Effect<never, PlatformError, string>
+  readonly makeTempDirectoryScoped: (
+    options?: MakeTempDirectoryOptions
+  ) => Effect.Effect<Scope, PlatformError, string>
+  readonly makeTempFile: (
+    options?: MakeTempFileOptions
+  ) => Effect.Effect<Scope, PlatformError, File>
+  readonly open: (
+    path: string,
+    options?: OpenFileOptions
+  ) => Effect.Effect<Scope, PlatformError, File>
+  readonly readDirectory: (
+    path: string,
+    options?: ReadDirectoryOptions
+  ) => Effect.Effect<never, PlatformError, ReadonlyArray<string>>
+  readonly readFile: (
+    path: string
+  ) => Effect.Effect<never, PlatformError, Uint8Array>
+  readonly readLink: (
+    path: string
+  ) => Effect.Effect<never, PlatformError, string>
+  readonly realPath: (
+    path: string
+  ) => Effect.Effect<never, PlatformError, string>
+  readonly remove: (
+    path: string,
+    options?: RemoveOptions
+  ) => Effect.Effect<never, PlatformError, void>
+  readonly rename: (
+    oldPath: string,
+    newPath: string
+  ) => Effect.Effect<never, PlatformError, void>
+  readonly sink: (
+    path: string,
+    options?: SinkOptions
+  ) => Sink<never, PlatformError, Uint8Array, never, void>
+  readonly stat: (
+    path: string
+  ) => Effect.Effect<never, PlatformError, File.Info>
+  readonly stream: (
+    path: string,
+    options?: StreamOptions
+  ) => Stream<never, PlatformError, Uint8Array>
+  readonly symlink: (
+    fromPath: string,
+    toPath: string
+  ) => Effect.Effect<never, PlatformError, void>
+  readonly truncate: (
+    path: string,
+    length?: Size
+  ) => Effect.Effect<never, PlatformError, void>
+  readonly utime: (
+    path: string,
+    atime: Date | number,
+    mtime: Date | number
+  ) => Effect.Effect<never, PlatformError, void>
+  readonly writeFile: (
+    path: string,
+    data: Uint8Array,
+    options?: WriteFileOptions
+  ) => Effect.Effect<never, PlatformError, void>
+}
+
+/**
+ * @since 1.0.0
+ * @category tag
+ */
+export const FileSystem: Tag<FileSystem, FileSystem> = internal.tag
+
+/**
+ * @since 1.0.0
+ * @category constructor
+ */
+export const make: (impl: Omit<FileSystem, "stream" | "sink">) => FileSystem = internal.make

package/src/Runtime.ts

@@ -0,0 +1,36 @@
+/**
+ * @since 1.0.0
+ */
+import * as Cause from "@effect/io/Cause"
+import type { Effect } from "@effect/io/Effect"
+import * as Exit from "@effect/io/Exit"
+
+/**
+ * @category model
+ * @since 1.0.0
+ */
+export interface Teardown {
+  <E, A>(exit: Exit.Exit<E, A>, onExit: (code: number) => void): void
+}
+
+/**
+ * @category teardown
+ * @since 1.0.0
+ */
+export const defaultTeardown: Teardown = <E, A>(
+  exit: Exit.Exit<E, A>,
+  onExit: (code: number) => void
+) => {
+  onExit(Exit.isFailure(exit) && !Cause.isInterruptedOnly(exit.cause) ? 1 : 0)
+}
+
+/**
+ * @category model
+ * @since 1.0.0
+ */
+export interface RunMain {
+  <E, A>(
+    effect: Effect<never, E, A>,
+    teardown?: Teardown
+  ): void
+}

package/src/internal/console.ts

@@ -0,0 +1,105 @@
+import { Tag } from "@effect/data/Context"
+import * as Effect from "@effect/io/Effect"
+import * as Layer from "@effect/io/Layer"
+import type { Console as Console_ } from "@effect/platform/Console"
+
+/**
+ * @since 1.0.0
+ * @category tag
+ */
+export const Console = Tag<Console_>()
+
+/** @internal */
+const consoleImpl = Console.of({
+  assert(condition, ...args) {
+    return Effect.sync(() => {
+      console.assert(condition, ...args)
+    })
+  },
+  clear() {
+    return Effect.sync(() => {
+      console.clear()
+    })
+  },
+  count(label) {
+    return Effect.sync(() => {
+      console.count(label)
+    })
+  },
+  countReset(label) {
+    return Effect.sync(() => {
+      console.countReset(label)
+    })
+  },
+  debug(...args) {
+    return Effect.sync(() => {
+      console.debug(...args)
+    })
+  },
+  dir(...args) {
+    return Effect.sync(() => {
+      console.dir(...args)
+    })
+  },
+  dirxml(...args) {
+    return Effect.sync(() => {
+      console.dirxml(...args)
+    })
+  },
+  error(...args) {
+    return Effect.sync(() => {
+      console.error(...args)
+    })
+  },
+  group(options) {
+    return (self) =>
+      Effect.acquireUseRelease(
+        options?.collapsed ?
+          Effect.sync(() => console.groupCollapsed(options?.label)) :
+          Effect.sync(() => console.group(options?.label)),
+        () => self,
+        () => Effect.sync(() => console.groupEnd())
+      )
+  },
+  info(...args) {
+    return Effect.sync(() => {
+      console.info(...args)
+    })
+  },
+  log(...args) {
+    return Effect.sync(() => {
+      console.log(...args)
+    })
+  },
+  table(tabularData, properties) {
+    return Effect.sync(() => {
+      console.table(tabularData, properties)
+    })
+  },
+  time(label) {
+    return (self) =>
+      Effect.acquireUseRelease(
+        Effect.sync(() => console.time(label)),
+        () => self,
+        () => Effect.sync(() => console.timeEnd(label))
+      )
+  },
+  timeLog(label, ...args) {
+    return Effect.sync(() => {
+      console.timeLog(label, ...args)
+    })
+  },
+  trace(...args) {
+    return Effect.sync(() => {
+      console.trace(...args)
+    })
+  },
+  warn(...args) {
+    return Effect.sync(() => {
+      console.warn(...args)
+    })
+  }
+})
+
+/** @internal */
+export const layer = Layer.succeed(Console, consoleImpl)

package/src/internal/effectify.ts

@@ -0,0 +1,31 @@
+import * as Effect from "@effect/io/Effect"
+import type { Effectify, EffectifyError } from "@effect/platform/Effectify"
+
+/** @internal */
+export const effectify: {
+  <F extends (...args: Array<any>) => any>(fn: F): Effectify<F, EffectifyError<F>>
+  <F extends (...args: Array<any>) => any, E>(
+    fn: F,
+    onError: (error: EffectifyError<F>, args: Parameters<F>) => E
+  ): Effectify<F, E>
+  <F extends (...args: Array<any>) => any, E, E2>(
+    fn: F,
+    onError: (error: EffectifyError<F>, args: Parameters<F>) => E,
+    onSyncError: (error: unknown, args: Parameters<F>) => E2
+  ): Effectify<F, E | E2>
+} =
+  (<A>(fn: Function, onError?: (e: any, args: any) => any, onSyncError?: (e: any, args: any) => any) =>
+    (...args: Array<any>) =>
+      Effect.async<never, Error, A>((resume) => {
+        try {
+          fn(...args, (err: Error | null, result: A) => {
+            if (err) {
+              resume(Effect.fail(onError ? onError(err, args) : err))
+            } else {
+              resume(Effect.succeed(result))
+            }
+          })
+        } catch (err) {
+          resume(onSyncError ? Effect.fail(onSyncError(err, args)) : Effect.die(err))
+        }
+      })) as any

package/src/internal/error.ts

@@ -0,0 +1,21 @@
+import * as Data from "@effect/data/Data"
+import type * as Error from "@effect/platform/Error"
+
+/** @internal */
+export const PlatformErrorTypeId: Error.PlatformErrorTypeId = Symbol.for(
+  "@effect/platform/Error/PlatformErrorTypeId"
+) as Error.PlatformErrorTypeId
+
+const make = <A extends Error.PlatformError>(tag: A["_tag"]) =>
+  (props: Omit<A, Error.PlatformError.ProvidedFields>): A =>
+    Data.struct({
+      [PlatformErrorTypeId]: PlatformErrorTypeId,
+      _tag: tag,
+      ...props
+    } as A)
+
+/** @internal */
+export const badArgument = make<Error.BadArgument>("BadArgument")
+
+/** @internal */
+export const systemError = make<Error.SystemError>("SystemError")

package/src/internal/fileSystem.ts

@@ -0,0 +1,60 @@
+import { Tag } from "@effect/data/Context"
+import { pipe } from "@effect/data/Function"
+import * as Option from "@effect/data/Option"
+import * as Effect from "@effect/io/Effect"
+import type { FileSystem, Size as Size_, StreamOptions } from "@effect/platform/FileSystem"
+import type { File } from "@effect/platform/FileSystem/File"
+import * as Sink from "@effect/stream/Sink"
+import * as Stream from "@effect/stream/Stream"
+
+/** @internal */
+export const tag = Tag<FileSystem>()
+
+/** @internal */
+export const Size = (bytes: number | bigint) => typeof bytes === "bigint" ? bytes as Size_ : BigInt(bytes) as Size_
+
+/** @internal */
+export const make = (impl: Omit<FileSystem, "stream" | "sink">): FileSystem => {
+  return tag.of({
+    ...impl,
+    stream: (path, options) =>
+      pipe(
+        impl.open(path, { flag: "r" }),
+        Effect.map((file) => stream(file, options)),
+        Stream.unwrapScoped
+      ),
+    sink: (path, options) =>
+      pipe(
+        impl.open(path, { flag: "w", ...options }),
+        Effect.map((file) => Sink.forEach((_: Uint8Array) => file.writeAll(_))),
+        Sink.unwrapScoped
+      )
+  })
+}
+
+/** @internal */
+const stream = (file: File, {
+  bufferSize = 4,
+  bytesToRead,
+  chunkSize = Size(16n * 1024n),
+  offset = Size(0n)
+}: StreamOptions = {}) =>
+  Stream.bufferChunks(
+    Stream.unfoldEffect(offset, (position) => {
+      if (bytesToRead !== undefined && bytesToRead <= position - offset) {
+        return Effect.succeedNone()
+      }
+
+      const toRead = bytesToRead !== undefined && bytesToRead - (position - offset) < chunkSize
+        ? bytesToRead - (position - offset)
+        : chunkSize
+
+      return pipe(
+        file.readAlloc(toRead as Size_, { offset: position }),
+        Effect.map(
+          Option.map((buf) => [buf, Size(position + BigInt(buf.length))] as const)
+        )
+      )
+    }),
+    bufferSize
+  )

package/tsconfig.build.json

@@ -0,0 +1,10 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "outDir": "build/esm",
+    "declarationDir": "build/dts",
+    "tsBuildInfoFile": "build/tsbuildinfo/esm.tsbuildinfo",
+    "rootDir": "src"
+  },
+  "include": ["src/**/*.ts"]
+}

package/tsconfig.examples.json

@@ -0,0 +1,11 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "tsBuildInfoFile": "build/tsbuildinfo/examples.tsbuildinfo",
+    "rootDir": "examples",
+    "module": "CommonJS",
+    "outDir": "build/examples"
+  },
+  "include": ["examples/**/*.ts"],
+  "references": [{ "path": "./tsconfig.build.json" }]
+}

package/tsconfig.json

@@ -0,0 +1,11 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "tsBuildInfoFile": "build/tsbuildinfo/tsconfig.tsbuildinfo"
+  },
+  "references": [
+    { "path": "./tsconfig.build.json" },
+    { "path": "./tsconfig.test.json" },
+    { "path": "./tsconfig.examples.json" }
+  ]
+}

package/tsconfig.test.json

@@ -0,0 +1,17 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "outDir": "build/test",
+    "declarationDir": "build/test-dts",
+    "tsBuildInfoFile": "build/tsbuildinfo/test.tsbuildinfo",
+    "rootDir": "test",
+    "noEmit": true,
+    "types": ["vitest/globals"]
+  },
+  "include": ["test/**/*.ts"],
+  "references": [
+    {
+      "path": "./tsconfig.build.json"
+    }
+  ]
+}