effect-start 0.23.1 → 0.25.0

package/dist/Development.js

@@ -1,58 +1,94 @@
-import * as FileSystem from "./FileSystem.js";
-import * as Context from "effect/Context";
-import * as Effect from "effect/Effect";
-import * as Function from "effect/Function";
-import * as GlobalValue from "effect/GlobalValue";
-import * as Layer from "effect/Layer";
-import * as Option from "effect/Option";
-import * as PubSub from "effect/PubSub";
-import * as Stream from "effect/Stream";
+import * as FileSystem from "./FileSystem.js"
+import * as Context from "effect/Context"
+import * as Effect from "effect/Effect"
+import * as Function from "effect/Function"
+import * as GlobalValue from "effect/GlobalValue"
+import * as Layer from "effect/Layer"
+import * as Option from "effect/Option"
+import * as PubSub from "effect/PubSub"
+import * as Stream from "effect/Stream"
+
 const devState = GlobalValue.globalValue(Symbol.for("effect-start/Development"), () => ({
-    count: 0,
-    pubsub: null,
-}));
+  count: 0,
+  pubsub: null,
+}))
+
 /** @internal */
 export const _resetForTesting = () => {
-    devState.count = 0;
-    devState.pubsub = null;
-};
-export class Development extends Context.Tag("effect-start/Development")() {
+  devState.count = 0
+  devState.pubsub = null
 }
-const SOURCE_FILENAME = /\.(tsx?|jsx?|html?|css|json)$/;
+
+export class Development extends Context.Tag("effect-start/Development")() {}
+
+const SOURCE_FILENAME = /\.(tsx?|jsx?|html?|css|json)$/
+
 export const filterSourceFiles = (event) => {
-    return SOURCE_FILENAME.test(event.path);
-};
+  return SOURCE_FILENAME.test(event.path)
+}
+
 export const filterDirectory = (event) => {
-    return event.path.endsWith("/");
-};
+  return event.path.endsWith("/")
+}
+
 export const watchSource = (opts) => {
-    const baseDir = opts?.path ?? process.cwd();
-    const customFilter = opts?.filter;
-    return Function.pipe(Stream.unwrap(Effect.map(FileSystem.FileSystem, (fs) => fs.watch(baseDir, { recursive: opts?.recursive ?? true }))), customFilter ? Stream.filter(customFilter) : Function.identity, Stream.rechunk(1), Stream.throttle({
-        units: 1,
-        cost: () => 1,
-        duration: "400 millis",
-        strategy: "enforce",
-    }));
-};
-export const watch = (opts) => Effect.gen(function* () {
-    devState.count++;
+  const baseDir = opts?.path ?? process.cwd()
+  const customFilter = opts?.filter
+
+  return Function.pipe(
+    Stream.unwrap(
+      Effect.map(FileSystem.FileSystem, (fs) =>
+        fs.watch(baseDir, { recursive: opts?.recursive ?? true }),
+      ),
+    ),
+    customFilter ? Stream.filter(customFilter) : Function.identity,
+    Stream.rechunk(1),
+    Stream.throttle({
+      units: 1,
+      cost: () => 1,
+      duration: "400 millis",
+      strategy: "enforce",
+    }),
+  )
+}
+
+export const watch = (opts) =>
+  Effect.gen(function* () {
+    devState.count++
+
     if (devState.count === 1) {
-        const pubsub = yield* PubSub.unbounded();
-        devState.pubsub = pubsub;
-        yield* Function.pipe(watchSource({
-            path: opts?.path,
-            recursive: opts?.recursive,
-            filter: opts?.filter ?? filterSourceFiles,
-        }), Stream.runForEach((event) => PubSub.publish(pubsub, event)), Effect.fork);
-    }
-    else {
-        yield* PubSub.publish(devState.pubsub, { _tag: "Reload" });
+      const pubsub = yield* PubSub.unbounded()
+      devState.pubsub = pubsub
+
+      yield* Function.pipe(
+        watchSource({
+          path: opts?.path,
+          recursive: opts?.recursive,
+          filter: opts?.filter ?? filterSourceFiles,
+        }),
+        Stream.runForEach((event) => PubSub.publish(pubsub, event)),
+        Effect.fork,
+      )
+    } else {
+      yield* PubSub.publish(devState.pubsub, { _tag: "Reload" })
     }
-    return { events: devState.pubsub };
-});
-export const layerWatch = (opts) => Layer.scoped(Development, watch(opts));
-export const stream = () => Stream.unwrap(Function.pipe(Effect.serviceOption(Development), Effect.map(Option.match({
-    onNone: () => Stream.empty,
-    onSome: (dev) => Stream.fromPubSub(dev.events),
-}))));
+
+    return { events: devState.pubsub }
+  })
+
+export const layerWatch = (opts) => Layer.scoped(Development, watch(opts))
+
+export const option = Effect.serviceOption(Development)
+
+export const stream = () =>
+  Stream.unwrap(
+    Function.pipe(
+      option,
+      Effect.map(
+        Option.match({
+          onNone: () => Stream.empty,
+          onSome: (dev) => Stream.fromPubSub(dev.events),
+        }),
+      ),
+    ),
+  )

package/dist/Effectify.js

@@ -1,19 +1,27 @@
 /*
  * Adapted from @effect/platform
  */
-import * as Effect from "effect/Effect";
-export const effectify = ((fn, onError, onSyncError) => (...args) => Effect.async((resume) => {
-    try {
-        fn(...args, (err, result) => {
+import * as Effect from "effect/Effect"
+
+export const effectify = ((
+  fn,
+  onError,
+  onSyncError,
+) =>
+  (...args) =>
+    Effect.async((resume) => {
+      try {
+        fn(
+          ...args,
+          (err, result) => {
             if (err) {
-                resume(Effect.fail(onError ? onError(err, args) : err));
+              resume(Effect.fail(onError ? onError(err, args) : err))
+            } else {
+              resume(Effect.succeed(result))
             }
-            else {
-                resume(Effect.succeed(result));
-            }
-        });
-    }
-    catch (err) {
-        resume(onSyncError ? Effect.fail(onSyncError(err, args)) : Effect.die(err));
-    }
-}));
+          },
+        )
+      } catch (err) {
+        resume(onSyncError ? Effect.fail(onSyncError(err, args)) : Effect.die(err))
+      }
+    }))

package/dist/Entity.js

@@ -1,224 +1,289 @@
-import * as Effect from "effect/Effect";
-import * as ParseResult from "effect/ParseResult";
-import * as Pipeable from "effect/Pipeable";
-import * as Predicate from "effect/Predicate";
-import * as Schema from "effect/Schema";
-import * as Stream from "effect/Stream";
-import * as StreamExtra from "./StreamExtra.js";
-import * as Values from "./Values.js";
-export const TypeId = Symbol.for("effect-start/Entity");
-const textDecoder = new TextDecoder();
-const textEncoder = new TextEncoder();
+import * as Effect from "effect/Effect"
+import * as ParseResult from "effect/ParseResult"
+import * as Pipeable from "effect/Pipeable"
+import * as Predicate from "effect/Predicate"
+import * as Schema from "effect/Schema"
+import * as Stream from "effect/Stream"
+import * as StreamExtra from "./StreamExtra.js"
+import * as Values from "./Values.js"
+
+export const TypeId = Symbol.for("effect-start/Entity")
+
+const textDecoder = new TextDecoder()
+const textEncoder = new TextEncoder()
+
 function isBinary(v) {
-    return v instanceof Uint8Array || v instanceof ArrayBuffer;
+  return v instanceof Uint8Array || v instanceof ArrayBuffer
 }
+
+/**
+ * Header keys are guaranteed to be lowercase.
+ */
+
 function parseJson(s) {
-    try {
-        return Effect.succeed(JSON.parse(s));
-    }
-    catch (e) {
-        return Effect.fail(new ParseResult.ParseError({
-            issue: new ParseResult.Type(Schema.Unknown.ast, s, e instanceof Error ? e.message : "Failed to parse JSON"),
-        }));
-    }
+  try {
+    return Effect.succeed(JSON.parse(s))
+  } catch (e) {
+    return Effect.fail(
+      new ParseResult.ParseError({
+        issue: new ParseResult.Type(
+          Schema.Unknown.ast,
+          s,
+          e instanceof Error ? e.message : "Failed to parse JSON",
+        ),
+      }),
+    )
+  }
 }
-function getText(self) {
-    const v = self.body;
-    if (StreamExtra.isStream(v)) {
-        return Stream.mkString(Stream.decodeText(v));
-    }
-    if (Effect.isEffect(v)) {
-        return Effect.flatMap(v, (inner) => {
-            if (isEntity(inner)) {
-                return inner.text;
-            }
-            if (typeof inner === "string") {
-                return Effect.succeed(inner);
-            }
-            if (isBinary(inner)) {
-                return Effect.succeed(textDecoder.decode(inner));
-            }
-            return Effect.fail(mismatch(Schema.String, inner));
-        });
-    }
-    if (typeof v === "string") {
-        return Effect.succeed(v);
-    }
-    if (isBinary(v)) {
-        return Effect.succeed(textDecoder.decode(v));
-    }
-    return Effect.fail(mismatch(Schema.String, v));
+
+function getText(
+  self,
+) {
+  const v = self.body
+  if (StreamExtra.isStream(v)) {
+    return Stream.mkString(Stream.decodeText(v))
+  }
+  if (Effect.isEffect(v)) {
+    return Effect.flatMap(
+      v,
+      (inner) => {
+        if (isEntity(inner)) {
+          return inner.text
+        }
+        if (typeof inner === "string") {
+          return Effect.succeed(inner)
+        }
+        if (isBinary(inner)) {
+          return Effect.succeed(textDecoder.decode(inner))
+        }
+        return Effect.fail(mismatch(Schema.String, inner))
+      },
+    )
+  }
+  if (typeof v === "string") {
+    return Effect.succeed(v)
+  }
+  if (isBinary(v)) {
+    return Effect.succeed(textDecoder.decode(v))
+  }
+  return Effect.fail(mismatch(Schema.String, v))
 }
-function getJson(self) {
-    const v = self.body;
-    if (StreamExtra.isStream(v)) {
-        return Effect.flatMap(getText(self), parseJson);
-    }
-    if (Effect.isEffect(v)) {
-        return Effect.flatMap(v, (inner) => {
-            if (isEntity(inner)) {
-                return inner.json;
-            }
-            if (typeof inner === "object" && inner !== null && !isBinary(inner)) {
-                return Effect.succeed(inner);
-            }
-            if (typeof inner === "string") {
-                return parseJson(inner);
-            }
-            if (isBinary(inner)) {
-                return parseJson(textDecoder.decode(inner));
-            }
-            return Effect.fail(mismatch(Schema.Unknown, inner));
-        });
-    }
-    if (typeof v === "object" && v !== null && !isBinary(v)) {
-        return Effect.succeed(v);
-    }
-    if (typeof v === "string") {
-        return parseJson(v);
-    }
-    if (isBinary(v)) {
-        return parseJson(textDecoder.decode(v));
-    }
-    return Effect.fail(mismatch(Schema.Unknown, v));
+
+function getJson(
+  self,
+) {
+  const v = self.body
+  if (StreamExtra.isStream(v)) {
+    return Effect.flatMap(getText(self), parseJson)
+  }
+  if (Effect.isEffect(v)) {
+    return Effect.flatMap(
+      v,
+      (inner) => {
+        if (isEntity(inner)) {
+          return inner.json
+        }
+        if (typeof inner === "object" && inner !== null && !isBinary(inner)) {
+          return Effect.succeed(inner)
+        }
+        if (typeof inner === "string") {
+          return parseJson(inner)
+        }
+        if (isBinary(inner)) {
+          return parseJson(textDecoder.decode(inner))
+        }
+        return Effect.fail(mismatch(Schema.Unknown, inner))
+      },
+    )
+  }
+  if (typeof v === "object" && v !== null && !isBinary(v)) {
+    return Effect.succeed(v)
+  }
+  if (typeof v === "string") {
+    return parseJson(v)
+  }
+  if (isBinary(v)) {
+    return parseJson(textDecoder.decode(v))
+  }
+  return Effect.fail(mismatch(Schema.Unknown, v))
 }
-function getBytes(self) {
-    const v = self.body;
-    if (StreamExtra.isStream(v)) {
-        return Stream.runFold(v, new Uint8Array(0), Values.concatBytes);
-    }
-    if (Effect.isEffect(v)) {
-        return Effect.flatMap(v, (inner) => {
-            if (isEntity(inner)) {
-                return inner.bytes;
-            }
-            if (inner instanceof Uint8Array) {
-                return Effect.succeed(inner);
-            }
-            if (inner instanceof ArrayBuffer) {
-                return Effect.succeed(new Uint8Array(inner));
-            }
-            if (typeof inner === "string") {
-                return Effect.succeed(textEncoder.encode(inner));
-            }
-            return Effect.fail(mismatch(Schema.Uint8ArrayFromSelf, inner));
-        });
-    }
-    if (v instanceof Uint8Array) {
-        return Effect.succeed(v);
-    }
-    if (v instanceof ArrayBuffer) {
-        return Effect.succeed(new Uint8Array(v));
-    }
-    if (typeof v === "string") {
-        return Effect.succeed(textEncoder.encode(v));
-    }
-    // Allows entity.stream to work when body is a JSON object
-    if (typeof v === "object" && v !== null && !isBinary(v)) {
-        return Effect.succeed(textEncoder.encode(JSON.stringify(v)));
-    }
-    return Effect.fail(mismatch(Schema.Uint8ArrayFromSelf, v));
+
+function getBytes(
+  self,
+) {
+  const v = self.body
+  if (StreamExtra.isStream(v)) {
+    return Stream.runFold(
+      v,
+      new Uint8Array(0),
+      Values.concatBytes,
+    )
+  }
+  if (Effect.isEffect(v)) {
+    return Effect.flatMap(
+      v,
+      (inner) => {
+        if (isEntity(inner)) {
+          return inner.bytes
+        }
+        if (inner instanceof Uint8Array) {
+          return Effect.succeed(inner)
+        }
+        if (inner instanceof ArrayBuffer) {
+          return Effect.succeed(new Uint8Array(inner))
+        }
+        if (typeof inner === "string") {
+          return Effect.succeed(textEncoder.encode(inner))
+        }
+        return Effect.fail(mismatch(Schema.Uint8ArrayFromSelf, inner))
+      },
+    )
+  }
+  if (v instanceof Uint8Array) {
+    return Effect.succeed(v)
+  }
+  if (v instanceof ArrayBuffer) {
+    return Effect.succeed(new Uint8Array(v))
+  }
+  if (typeof v === "string") {
+    return Effect.succeed(textEncoder.encode(v))
+  }
+  // Allows entity.stream to work when body is a JSON object
+  if (typeof v === "object" && v !== null && !isBinary(v)) {
+    return Effect.succeed(textEncoder.encode(JSON.stringify(v)))
+  }
+  return Effect.fail(mismatch(Schema.Uint8ArrayFromSelf, v))
 }
+
 function getStream(self) {
-    const v = self.body;
-    if (StreamExtra.isStream(v)) {
-        return v;
-    }
-    if (Effect.isEffect(v)) {
-        return Stream.unwrap(Effect.map(v, (inner) => {
-            if (isEntity(inner)) {
-                return inner.stream;
-            }
-            return Stream.fromEffect(getBytes(make(inner)));
-        }));
-    }
-    return Stream.fromEffect(getBytes(self));
+  const v = self.body
+  if (StreamExtra.isStream(v)) {
+    return v
+  }
+  if (Effect.isEffect(v)) {
+    return Stream.unwrap(
+      Effect.map(v, (inner) => {
+        if (isEntity(inner)) {
+          return inner.stream
+        }
+        return Stream.fromEffect(getBytes(make(inner)))
+      }),
+    )
+  }
+  return Stream.fromEffect(getBytes(self))
 }
+
 const Proto = Object.defineProperties(Object.create(null), {
-    [TypeId]: { value: TypeId },
-    pipe: {
-        value: function () {
-            return Pipeable.pipeArguments(this, arguments);
-        },
+  [TypeId]: { value: TypeId },
+  pipe: {
+    value: function () {
+      return Pipeable.pipeArguments(this, arguments)
     },
-    text: {
-        get() {
-            return getText(this);
-        },
+  },
+  text: {
+    get() {
+      return getText(this)
     },
-    json: {
-        get() {
-            return getJson(this);
-        },
+  },
+  json: {
+    get() {
+      return getJson(this)
     },
-    bytes: {
-        get() {
-            return getBytes(this);
-        },
+  },
+  bytes: {
+    get() {
+      return getBytes(this)
     },
-    stream: {
-        get() {
-            return getStream(this);
-        },
+  },
+  stream: {
+    get() {
+      return getStream(this)
     },
-});
+  },
+})
+
 export function isEntity(input) {
-    return Predicate.hasProperty(input, TypeId);
+  return Predicate.hasProperty(input, TypeId)
 }
+
 export function make(body, options) {
-    return Object.assign(Object.create(Proto), {
-        body,
-        headers: options?.headers ?? {},
-        url: options?.url,
-        status: options?.status,
-    });
+  return Object.assign(Object.create(Proto), {
+    body,
+    headers: options?.headers ?? {},
+    url: options?.url,
+    status: options?.status,
+  })
 }
+
 export function effect(body) {
-    return make(body);
+  return make(body)
 }
+
 export function resolve(entity) {
-    const body = entity.body;
-    if (Effect.isEffect(body)) {
-        return Effect.map(body, (inner) => isEntity(inner)
-            ? inner
-            : make(inner, {
-                status: entity.status,
-                headers: entity.headers,
-                url: entity.url,
-            }));
-    }
-    return Effect.succeed(entity);
+  const body = entity.body
+  if (Effect.isEffect(body)) {
+    return Effect.map(body, (inner) =>
+      isEntity(inner)
+        ? (inner)
+        : (make(inner, {
+            status: entity.status,
+            headers: entity.headers,
+            url: entity.url,
+          })),
+    )
+  }
+  return Effect.succeed(entity)
 }
+
 export function type(self) {
-    const h = self.headers;
-    if (h["content-type"]) {
-        return h["content-type"];
-    }
-    const v = self.body;
-    if (typeof v === "string") {
-        return "text/plain";
-    }
-    if (typeof v === "object" && v !== null && !isBinary(v)) {
-        return "application/json";
-    }
-    return "application/octet-stream";
+  const h = self.headers
+  if (h["content-type"]) {
+    return h["content-type"]
+  }
+  const v = self.body
+  if (typeof v === "string") {
+    return "text/plain"
+  }
+  if (typeof v === "object" && v !== null && !isBinary(v)) {
+    return "application/json"
+  }
+  return "application/octet-stream"
 }
+
 export function length(self) {
-    const h = self.headers;
-    if (h["content-length"]) {
-        return parseInt(h["content-length"], 10);
-    }
-    const v = self.body;
-    if (typeof v === "string") {
-        return textEncoder.encode(v).byteLength;
-    }
-    if (isBinary(v)) {
-        return v.byteLength;
-    }
-    return undefined;
+  const h = self.headers
+  if (h["content-length"]) {
+    return parseInt(h["content-length"], 10)
+  }
+  const v = self.body
+  if (typeof v === "string") {
+    return textEncoder.encode(v).byteLength
+  }
+  if (isBinary(v)) {
+    return v.byteLength
+  }
+  return undefined
 }
+
+export function fromResponse(
+  response,
+  request,
+) {
+  return make(
+    Effect.tryPromise({
+      try: () => response.arrayBuffer().then((buf) => new Uint8Array(buf)),
+      catch: (e) => (e instanceof Error ? e : new Error(String(e))),
+    }),
+    {
+      headers: Object.fromEntries(response.headers.entries()),
+      status: response.status,
+      url: response.url || request?.url,
+    },
+  )
+}
+
 function mismatch(expected, actual) {
-    return new ParseResult.ParseError({
-        issue: new ParseResult.Type(expected.ast, actual),
-    });
+  return new ParseResult.ParseError({
+    issue: new ParseResult.Type(expected.ast, actual),
+  })
 }