@smthrs/platform-bun 0.0.0-stage → 1.0.0-rc.13

package/dist/vendor/chunk-AMAL6TRE.js

@@ -0,0 +1,93 @@
+import {
+  fromReadable,
+  toArrayBuffer
+} from "./chunk-T5WDTZCE.js";
+import {
+  __export
+} from "./chunk-MLKGABMK.js";
+
+// ../../../../node_modules/.pnpm/@effect+platform-node@4.0.5_effect@4.0.5_redis@6.2.1_@opentelemetry+api@1.9.1_/node_modules/@effect/platform-node/dist/NodeHttpIncomingMessage.js
+var NodeHttpIncomingMessage_exports = {};
+__export(NodeHttpIncomingMessage_exports, {
+  NodeHttpIncomingMessage: () => NodeHttpIncomingMessage
+});
+import * as Effect from "effect/Effect";
+import * as Headers from "effect/http/Headers";
+import * as IncomingMessage from "effect/http/HttpIncomingMessage";
+import * as UrlParams from "effect/http/UrlParams";
+import * as Inspectable from "effect/Inspectable";
+import * as Option from "effect/Option";
+var textDecoder = /* @__PURE__ */ new TextDecoder();
+var NodeHttpIncomingMessage = class extends Inspectable.Class {
+  /**
+   * Marks this value as an HTTP incoming message for runtime guards.
+   *
+   * @since 4.0.0
+   */
+  [IncomingMessage.TypeId];
+  source;
+  onError;
+  remoteAddressOverride;
+  constructor(source, onError, remoteAddressOverride) {
+    super();
+    this[IncomingMessage.TypeId] = IncomingMessage.TypeId;
+    this.source = source;
+    this.onError = onError;
+    this.remoteAddressOverride = remoteAddressOverride;
+  }
+  get headers() {
+    return Headers.fromInput(this.source.headers);
+  }
+  get remoteAddress() {
+    return this.remoteAddressOverride ?? Option.fromNullishOr(this.source.socket?.remoteAddress);
+  }
+  textEffect;
+  get text() {
+    if (this.textEffect) {
+      return this.textEffect;
+    }
+    this.textEffect = Effect.map(this.arrayBuffer, (_) => textDecoder.decode(_));
+    return this.textEffect;
+  }
+  get textUnsafe() {
+    return Effect.runSync(this.text);
+  }
+  get json() {
+    return Effect.flatMap(this.text, (text) => Effect.try({
+      try: () => text === "" ? null : JSON.parse(text),
+      catch: this.onError
+    }));
+  }
+  get jsonUnsafe() {
+    return Effect.runSync(this.json);
+  }
+  get urlParamsBody() {
+    return Effect.flatMap(this.text, (_) => Effect.try({
+      try: () => UrlParams.fromInput(new URLSearchParams(_)),
+      catch: this.onError
+    }));
+  }
+  get stream() {
+    return fromReadable({
+      evaluate: () => this.source,
+      onError: this.onError
+    });
+  }
+  arrayBufferEffect;
+  get arrayBuffer() {
+    if (this.arrayBufferEffect) {
+      return this.arrayBufferEffect;
+    }
+    this.arrayBufferEffect = Effect.withFiber((fiber) => toArrayBuffer(() => this.source, {
+      onError: this.onError,
+      maxBytes: fiber.getRef(IncomingMessage.MaxBodySize)
+    })).pipe(Effect.cached, Effect.runSync);
+    this.textEffect = Effect.map(this.arrayBufferEffect, (_) => textDecoder.decode(_));
+    return this.arrayBufferEffect;
+  }
+};
+
+export {
+  NodeHttpIncomingMessage,
+  NodeHttpIncomingMessage_exports
+};

package/dist/vendor/chunk-AW6WQVI7.js

@@ -0,0 +1,29 @@
+import {
+  __export
+} from "./chunk-MLKGABMK.js";
+
+// ../../../../node_modules/.pnpm/@effect+platform-node-shared@4.0.5_effect@4.0.5/node_modules/@effect/platform-node-shared/dist/NodeAddressResolver.js
+var NodeAddressResolver_exports = {};
+__export(NodeAddressResolver_exports, {
+  layer: () => layer2
+});
+import * as Effect from "effect/Effect";
+import * as AddressResolver from "effect/net/AddressResolver";
+import * as NetAddress from "effect/net/NetAddress";
+import * as Os from "node:os";
+var scopeId = (name) => Effect.try({
+  try: () => NetAddress.scopeIdFromInterface(Os.networkInterfaces()[name]),
+  catch: (cause) => new NetAddress.NetAddressError({
+    input: name,
+    message: "cannot list network interfaces",
+    cause
+  })
+});
+var layer2 = /* @__PURE__ */ AddressResolver.layer({
+  scopeId
+});
+
+export {
+  layer2 as layer,
+  NodeAddressResolver_exports
+};

package/dist/vendor/chunk-BHV44Z6K.js

@@ -0,0 +1,36 @@
+import {
+  __export
+} from "./chunk-MLKGABMK.js";
+
+// ../../../../node_modules/.pnpm/@effect+platform-node-shared@4.0.5_effect@4.0.5/node_modules/@effect/platform-node-shared/dist/NodeRuntime.js
+var NodeRuntime_exports = {};
+__export(NodeRuntime_exports, {
+  runMain: () => runMain
+});
+import * as Runtime from "effect/Runtime";
+var runMain = /* @__PURE__ */ Runtime.makeRunMain(({
+  fiber,
+  teardown
+}) => {
+  let receivedSignal = false;
+  fiber.addObserver((exit) => {
+    process.removeListener("SIGINT", onSigint);
+    process.removeListener("SIGTERM", onSigint);
+    teardown(exit, (code) => {
+      if (receivedSignal || code !== 0) {
+        process.exit(code);
+      }
+    });
+  });
+  function onSigint() {
+    receivedSignal = true;
+    fiber.interruptUnsafe(fiber.id);
+  }
+  process.on("SIGINT", onSigint);
+  process.on("SIGTERM", onSigint);
+});
+
+export {
+  runMain,
+  NodeRuntime_exports
+};

package/dist/vendor/chunk-BIR74JJK.js

@@ -0,0 +1,93 @@
+import {
+  __export
+} from "./chunk-MLKGABMK.js";
+
+// ../../../../node_modules/.pnpm/@effect+platform-bun@4.0.5_effect@4.0.5/node_modules/@effect/platform-bun/dist/BunRedis.js
+var BunRedis_exports = {};
+__export(BunRedis_exports, {
+  BunRedis: () => BunRedis,
+  layer: () => layer,
+  layerConfig: () => layerConfig
+});
+import * as Config from "effect/Config";
+import * as Context from "effect/Context";
+import * as Deferred from "effect/Deferred";
+import * as Effect from "effect/Effect";
+import * as Fn from "effect/Function";
+import * as Layer from "effect/Layer";
+import * as Redis from "effect/persistence/Redis";
+import * as Scope from "effect/Scope";
+var BunRedis = class extends (/* @__PURE__ */ Context.Service()("@effect/platform-bun/BunRedis")) {
+};
+var make4 = /* @__PURE__ */ Effect.fnUntraced(function* (options) {
+  const {
+    RedisClient
+  } = yield* Effect.promise(() => import("bun"));
+  const scope2 = yield* Effect.scope;
+  yield* Scope.addFinalizer(scope2, Effect.sync(() => client.close()));
+  const client = new RedisClient(options?.url, options);
+  const use = (f) => Effect.tryPromise({
+    try: () => f(client),
+    catch: (cause) => new Redis.RedisError({
+      cause
+    })
+  });
+  const redis = yield* Redis.make({
+    send: (command, ...args) => Effect.tryPromise({
+      try: () => client.send(command, args),
+      catch: (cause) => new Redis.RedisError({
+        cause
+      })
+    }),
+    subscribe: (channel, onMessage) => Effect.gen(function* () {
+      const terminal = yield* Deferred.make();
+      yield* Effect.acquireRelease(Effect.tryPromise({
+        try: async () => {
+          const subscriber = new RedisClient(options?.url, {
+            ...options,
+            autoReconnect: false
+          });
+          subscriber.onclose = (cause) => {
+            Deferred.doneUnsafe(terminal, new Redis.RedisError({
+              cause
+            }));
+          };
+          try {
+            await subscriber.subscribe(channel, (message, channel2) => {
+              onMessage({
+                channel: channel2,
+                message
+              });
+            });
+            return subscriber;
+          } catch (cause) {
+            subscriber.onclose = null;
+            subscriber.close();
+            throw cause;
+          }
+        },
+        catch: (cause) => new Redis.RedisError({
+          cause
+        })
+      }), (subscriber) => Effect.sync(() => {
+        subscriber.onclose = null;
+        subscriber.close();
+      }));
+      return Deferred.await(terminal);
+    })
+  });
+  const bunRedis = Fn.identity({
+    client,
+    use
+  });
+  return Context.make(BunRedis, bunRedis).pipe(Context.add(Redis.Redis, redis));
+});
+var layer = (options) => Layer.effectContext(make4(options));
+var layerConfig = (options) => Layer.effectContext(Config.unwrap(options).pipe(Effect.flatMap(make4)));
+
+export {
+  BunRedis,
+  layer,
+  layerConfig,
+  BunRedis_exports
+};

package/dist/vendor/chunk-BTXZUHUI.js

@@ -0,0 +1,7 @@
+// ../../../../node_modules/.pnpm/@effect+platform-bun@4.0.5_effect@4.0.5/node_modules/@effect/platform-bun/dist/BunHttpClient.js
+var BunHttpClient_exports = {};
+export * from "effect/http/FetchHttpClient";
+
+export {
+  BunHttpClient_exports
+};