@effect/platform 0.22.0 → 0.23.0

package/Worker/dist/effect-platform-Worker.cjs.d.mts

@@ -0,0 +1,2 @@
+export * from "../../dist/declarations/src/Worker.js";
+//# sourceMappingURL=effect-platform-Worker.cjs.d.mts.map

package/Worker/dist/effect-platform-Worker.cjs.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"effect-platform-Worker.cjs.d.mts","sourceRoot":"","sources":["../../dist/declarations/src/Worker.d.ts"],"names":[],"mappings":"AAAA"}

package/Worker/dist/effect-platform-Worker.cjs.d.ts

@@ -0,0 +1,2 @@
+export * from "../../dist/declarations/src/Worker";
+//# sourceMappingURL=effect-platform-Worker.cjs.d.ts.map

package/Worker/dist/effect-platform-Worker.cjs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"effect-platform-Worker.cjs.d.ts","sourceRoot":"","sources":["../../dist/declarations/src/Worker.d.ts"],"names":[],"mappings":"AAAA"}

package/Worker/dist/effect-platform-Worker.cjs.dev.js

@@ -0,0 +1,291 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var Context = require('effect/Context');
+var Deferred = require('effect/Deferred');
+var Effect = require('effect/Effect');
+var Exit = require('effect/Exit');
+var Fiber = require('effect/Fiber');
+var Function = require('effect/Function');
+var Layer = require('effect/Layer');
+var Pool = require('effect/Pool');
+var Queue = require('effect/Queue');
+var Stream = require('effect/Stream');
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n["default"] = e;
+  return Object.freeze(n);
+}
+
+var Context__namespace = /*#__PURE__*/_interopNamespace(Context);
+var Deferred__namespace = /*#__PURE__*/_interopNamespace(Deferred);
+var Effect__namespace = /*#__PURE__*/_interopNamespace(Effect);
+var Exit__namespace = /*#__PURE__*/_interopNamespace(Exit);
+var Fiber__namespace = /*#__PURE__*/_interopNamespace(Fiber);
+var Layer__namespace = /*#__PURE__*/_interopNamespace(Layer);
+var Pool__namespace = /*#__PURE__*/_interopNamespace(Pool);
+var Queue__namespace = /*#__PURE__*/_interopNamespace(Queue);
+var Stream__namespace = /*#__PURE__*/_interopNamespace(Stream);
+
+/** @internal */
+const defaultQueue = () => Effect__namespace.map(Queue__namespace.unbounded(), queue => ({
+  offer: (id, item) => Queue__namespace.offer(queue, [id, item]),
+  take: Queue__namespace.take(queue),
+  shutdown: Queue__namespace.shutdown(queue)
+}));
+
+/** @internal */
+const PlatformWorkerTypeId$1 = /*#__PURE__*/Symbol.for("@effect/platform/Worker/PlatformWorker");
+
+/** @internal */
+const PlatformWorker$1 = /*#__PURE__*/Context__namespace.Tag(PlatformWorkerTypeId$1);
+
+/** @internal */
+const WorkerManagerTypeId$1 = /*#__PURE__*/Symbol.for("@effect/platform/Worker/WorkerManager");
+
+/** @internal */
+const WorkerManager$1 = /*#__PURE__*/Context__namespace.Tag(WorkerManagerTypeId$1);
+
+/** @internal */
+const makeManager$1 = /*#__PURE__*/Effect__namespace.gen(function* (_) {
+  const platform = yield* _(PlatformWorker$1);
+  let idCounter = 0;
+  return WorkerManager$1.of({
+    [WorkerManagerTypeId$1]: WorkerManagerTypeId$1,
+    spawn({
+      permits = 1,
+      queue,
+      spawn,
+      transfers = _ => []
+    }) {
+      return Effect__namespace.gen(function* (_) {
+        const id = idCounter++;
+        const fiberId = yield* _(Effect__namespace.fiberId);
+        let requestIdCounter = 0;
+        const readyLatch = yield* _(Deferred__namespace.make());
+        const semaphore = yield* _(Effect__namespace.makeSemaphore(permits));
+        const requestMap = new Map();
+        const outbound = queue ?? (yield* _(defaultQueue()));
+        yield* _(Effect__namespace.addFinalizer(() => outbound.shutdown));
+        const backing = yield* _(platform.spawn(spawn(id)));
+        yield* _(Effect__namespace.addFinalizer(() => Effect__namespace.zipRight(Effect__namespace.forEach(requestMap.values(), ([queue]) => Queue__namespace.shutdown(queue), {
+          discard: true
+        }), Effect__namespace.sync(() => requestMap.clear()))));
+        const handleMessage = msg => Effect__namespace.suspend(() => {
+          switch (msg[0]) {
+            case 0:
+              {
+                return Deferred__namespace.complete(readyLatch, Effect__namespace.unit);
+              }
+            case 1:
+              {
+                const response = msg[1];
+                const queue = requestMap.get(response[0]);
+                if (!queue) return Effect__namespace.unit;
+                switch (response[1]) {
+                  // data
+                  case 0:
+                    {
+                      return Queue__namespace.offer(queue[0], Exit__namespace.succeed(response[2]));
+                    }
+                  // end
+                  case 1:
+                    {
+                      return response.length === 2 ? Queue__namespace.shutdown(queue[0]) : Effect__namespace.zipRight(Queue__namespace.offer(queue[0], Exit__namespace.succeed(response[2])), Queue__namespace.shutdown(queue[0]));
+                    }
+                  // error / defect
+                  case 2:
+                  case 3:
+                    {
+                      return Effect__namespace.zipRight(Queue__namespace.offer(queue[0], response[1] === 2 ? Exit__namespace.fail(response[2]) : Exit__namespace.die(response[2])), Queue__namespace.shutdown(queue[0]));
+                    }
+                }
+              }
+          }
+        });
+        const executeAcquire = request => Effect__namespace.tap(Effect__namespace.all([Effect__namespace.sync(() => requestIdCounter++), Queue__namespace.unbounded(), Deferred__namespace.make()]), ([id, queue, deferred]) => Effect__namespace.suspend(() => {
+          requestMap.set(id, [queue, deferred]);
+          return outbound.offer(id, request);
+        }));
+        const executeRelease = ([id,, deferred], exit) => {
+          const release = Effect__namespace.zipRight(Deferred__namespace.complete(deferred, Effect__namespace.unit), Effect__namespace.sync(() => requestMap.delete(id)));
+          return Exit__namespace.isInterrupted(exit) ? Effect__namespace.zipRight(backing.send([id, 1]), release) : release;
+        };
+        const execute = request => Stream__namespace.flatMap(Stream__namespace.acquireRelease(executeAcquire(request), executeRelease), ([, queue]) => Stream__namespace.flatten(Stream__namespace.fromQueue(queue)));
+        const executeEffect = request => Effect__namespace.acquireUseRelease(executeAcquire(request), ([, queue]) => Effect__namespace.flatten(Queue__namespace.take(queue)), executeRelease);
+        const handleMessages = yield* _(Queue__namespace.take(backing.queue), Effect__namespace.flatMap(handleMessage), Effect__namespace.forever, Effect__namespace.forkDaemon);
+        yield* _(Effect__namespace.addFinalizer(() => handleMessages.interruptAsFork(fiberId)));
+        const postMessages = yield* _(semaphore.take(1), Effect__namespace.zipRight(outbound.take), Effect__namespace.flatMap(([id, request]) => Function.pipe(Effect__namespace.suspend(() => {
+          const result = requestMap.get(id);
+          if (!result) return Effect__namespace.unit;
+          const transferables = transfers(request);
+          return Effect__namespace.zipRight(backing.send([id, 0, request], transferables), Deferred__namespace.await(result[1]));
+        }), Effect__namespace.ensuring(semaphore.release(1)), Effect__namespace.fork)), Effect__namespace.forever, Effect__namespace.forkDaemon);
+        yield* _(Effect__namespace.addFinalizer(() => postMessages.interruptAsFork(fiberId)));
+        const join = Effect__namespace.race(Fiber__namespace.joinAll([handleMessages, postMessages]), backing.join);
+        return {
+          id,
+          join,
+          execute,
+          executeEffect
+        };
+      });
+    }
+  });
+});
+
+/** @internal */
+const layerManager$1 = /*#__PURE__*/Layer__namespace.effect(WorkerManager$1, makeManager$1);
+
+/** @internal */
+const makePool$1 = () => options => Effect__namespace.gen(function* (_) {
+  const manager = yield* _(WorkerManager$1);
+  const backing = yield* _("timeToLive" in options ? Pool__namespace.makeWithTTL({
+    acquire: manager.spawn(options),
+    min: options.minSize,
+    max: options.maxSize,
+    timeToLive: options.timeToLive
+  }) : Pool__namespace.make({
+    acquire: manager.spawn(options),
+    size: options.size
+  }));
+  const pool = {
+    backing,
+    execute: message => Stream__namespace.unwrap(Effect__namespace.map(Effect__namespace.scoped(backing.get()), worker => worker.execute(message))),
+    executeEffect: message => Effect__namespace.flatMap(Effect__namespace.scoped(backing.get()), worker => worker.executeEffect(message))
+  };
+  return pool;
+});
+
+/** @internal */
+const makePoolLayer$1 = managerLayer => (tag, options) => Layer__namespace.provide(managerLayer, Layer__namespace.scoped(tag, makePool$1()(options)));
+
+/**
+ * @since 1.0.0
+ */
+
+/**
+ * @since 1.0.0
+ * @category models
+ */
+
+/**
+ * @since 1.0.0
+ * @category models
+ */
+
+/**
+ * @since 1.0.0
+ * @category type ids
+ */
+const PlatformWorkerTypeId = PlatformWorkerTypeId$1;
+
+/**
+ * @since 1.0.0
+ * @category type ids
+ */
+
+/**
+ * @since 1.0.0
+ * @category models
+ */
+
+/**
+ * @since 1.0.0
+ * @category tags
+ */
+const PlatformWorker = PlatformWorker$1;
+
+/**
+ * @since 1.0.0
+ * @category models
+ */
+
+/**
+ * @since 1.0.0
+ * @category models
+ */
+
+/**
+ * @since 1.0.0
+ * @category models
+ */
+
+/**
+ * @since 1.0.0
+ * @category models
+ */
+
+/**
+ * @category models
+ * @since 1.0.0
+ */
+
+/**
+ * @since 1.0.0
+ * @category type ids
+ */
+const WorkerManagerTypeId = WorkerManagerTypeId$1;
+
+/**
+ * @since 1.0.0
+ * @category type ids
+ */
+
+/**
+ * @since 1.0.0
+ * @category models
+ */
+
+/**
+ * @since 1.0.0
+ * @category tags
+ */
+const WorkerManager = WorkerManager$1;
+
+/**
+ * @since 1.0.0
+ * @category constructors
+ */
+const makeManager = makeManager$1;
+
+/**
+ * @since 1.0.0
+ * @category layers
+ */
+const layerManager = layerManager$1;
+
+/**
+ * @since 1.0.0
+ * @category constructors
+ */
+const makePool = makePool$1;
+
+/**
+ * @since 1.0.0
+ * @category constructors
+ */
+const makePoolLayer = makePoolLayer$1;
+
+exports.PlatformWorker = PlatformWorker;
+exports.PlatformWorkerTypeId = PlatformWorkerTypeId;
+exports.WorkerManager = WorkerManager;
+exports.WorkerManagerTypeId = WorkerManagerTypeId;
+exports.layerManager = layerManager;
+exports.makeManager = makeManager;
+exports.makePool = makePool;
+exports.makePoolLayer = makePoolLayer;

package/Worker/dist/effect-platform-Worker.cjs.js

@@ -0,0 +1,7 @@
+'use strict';
+
+if (process.env.NODE_ENV === "production") {
+  module.exports = require("./effect-platform-Worker.cjs.prod.js");
+} else {
+  module.exports = require("./effect-platform-Worker.cjs.dev.js");
+}

package/Worker/dist/effect-platform-Worker.cjs.mjs

@@ -0,0 +1,10 @@
+export {
+  PlatformWorker,
+  PlatformWorkerTypeId,
+  WorkerManager,
+  WorkerManagerTypeId,
+  layerManager,
+  makeManager,
+  makePool,
+  makePoolLayer
+} from "./effect-platform-Worker.cjs.js";

package/Worker/dist/effect-platform-Worker.cjs.prod.js

@@ -0,0 +1,291 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var Context = require('effect/Context');
+var Deferred = require('effect/Deferred');
+var Effect = require('effect/Effect');
+var Exit = require('effect/Exit');
+var Fiber = require('effect/Fiber');
+var Function = require('effect/Function');
+var Layer = require('effect/Layer');
+var Pool = require('effect/Pool');
+var Queue = require('effect/Queue');
+var Stream = require('effect/Stream');
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n["default"] = e;
+  return Object.freeze(n);
+}
+
+var Context__namespace = /*#__PURE__*/_interopNamespace(Context);
+var Deferred__namespace = /*#__PURE__*/_interopNamespace(Deferred);
+var Effect__namespace = /*#__PURE__*/_interopNamespace(Effect);
+var Exit__namespace = /*#__PURE__*/_interopNamespace(Exit);
+var Fiber__namespace = /*#__PURE__*/_interopNamespace(Fiber);
+var Layer__namespace = /*#__PURE__*/_interopNamespace(Layer);
+var Pool__namespace = /*#__PURE__*/_interopNamespace(Pool);
+var Queue__namespace = /*#__PURE__*/_interopNamespace(Queue);
+var Stream__namespace = /*#__PURE__*/_interopNamespace(Stream);
+
+/** @internal */
+const defaultQueue = () => Effect__namespace.map(Queue__namespace.unbounded(), queue => ({
+  offer: (id, item) => Queue__namespace.offer(queue, [id, item]),
+  take: Queue__namespace.take(queue),
+  shutdown: Queue__namespace.shutdown(queue)
+}));
+
+/** @internal */
+const PlatformWorkerTypeId$1 = /*#__PURE__*/Symbol.for("@effect/platform/Worker/PlatformWorker");
+
+/** @internal */
+const PlatformWorker$1 = /*#__PURE__*/Context__namespace.Tag(PlatformWorkerTypeId$1);
+
+/** @internal */
+const WorkerManagerTypeId$1 = /*#__PURE__*/Symbol.for("@effect/platform/Worker/WorkerManager");
+
+/** @internal */
+const WorkerManager$1 = /*#__PURE__*/Context__namespace.Tag(WorkerManagerTypeId$1);
+
+/** @internal */
+const makeManager$1 = /*#__PURE__*/Effect__namespace.gen(function* (_) {
+  const platform = yield* _(PlatformWorker$1);
+  let idCounter = 0;
+  return WorkerManager$1.of({
+    [WorkerManagerTypeId$1]: WorkerManagerTypeId$1,
+    spawn({
+      permits = 1,
+      queue,
+      spawn,
+      transfers = _ => []
+    }) {
+      return Effect__namespace.gen(function* (_) {
+        const id = idCounter++;
+        const fiberId = yield* _(Effect__namespace.fiberId);
+        let requestIdCounter = 0;
+        const readyLatch = yield* _(Deferred__namespace.make());
+        const semaphore = yield* _(Effect__namespace.makeSemaphore(permits));
+        const requestMap = new Map();
+        const outbound = queue ?? (yield* _(defaultQueue()));
+        yield* _(Effect__namespace.addFinalizer(() => outbound.shutdown));
+        const backing = yield* _(platform.spawn(spawn(id)));
+        yield* _(Effect__namespace.addFinalizer(() => Effect__namespace.zipRight(Effect__namespace.forEach(requestMap.values(), ([queue]) => Queue__namespace.shutdown(queue), {
+          discard: true
+        }), Effect__namespace.sync(() => requestMap.clear()))));
+        const handleMessage = msg => Effect__namespace.suspend(() => {
+          switch (msg[0]) {
+            case 0:
+              {
+                return Deferred__namespace.complete(readyLatch, Effect__namespace.unit);
+              }
+            case 1:
+              {
+                const response = msg[1];
+                const queue = requestMap.get(response[0]);
+                if (!queue) return Effect__namespace.unit;
+                switch (response[1]) {
+                  // data
+                  case 0:
+                    {
+                      return Queue__namespace.offer(queue[0], Exit__namespace.succeed(response[2]));
+                    }
+                  // end
+                  case 1:
+                    {
+                      return response.length === 2 ? Queue__namespace.shutdown(queue[0]) : Effect__namespace.zipRight(Queue__namespace.offer(queue[0], Exit__namespace.succeed(response[2])), Queue__namespace.shutdown(queue[0]));
+                    }
+                  // error / defect
+                  case 2:
+                  case 3:
+                    {
+                      return Effect__namespace.zipRight(Queue__namespace.offer(queue[0], response[1] === 2 ? Exit__namespace.fail(response[2]) : Exit__namespace.die(response[2])), Queue__namespace.shutdown(queue[0]));
+                    }
+                }
+              }
+          }
+        });
+        const executeAcquire = request => Effect__namespace.tap(Effect__namespace.all([Effect__namespace.sync(() => requestIdCounter++), Queue__namespace.unbounded(), Deferred__namespace.make()]), ([id, queue, deferred]) => Effect__namespace.suspend(() => {
+          requestMap.set(id, [queue, deferred]);
+          return outbound.offer(id, request);
+        }));
+        const executeRelease = ([id,, deferred], exit) => {
+          const release = Effect__namespace.zipRight(Deferred__namespace.complete(deferred, Effect__namespace.unit), Effect__namespace.sync(() => requestMap.delete(id)));
+          return Exit__namespace.isInterrupted(exit) ? Effect__namespace.zipRight(backing.send([id, 1]), release) : release;
+        };
+        const execute = request => Stream__namespace.flatMap(Stream__namespace.acquireRelease(executeAcquire(request), executeRelease), ([, queue]) => Stream__namespace.flatten(Stream__namespace.fromQueue(queue)));
+        const executeEffect = request => Effect__namespace.acquireUseRelease(executeAcquire(request), ([, queue]) => Effect__namespace.flatten(Queue__namespace.take(queue)), executeRelease);
+        const handleMessages = yield* _(Queue__namespace.take(backing.queue), Effect__namespace.flatMap(handleMessage), Effect__namespace.forever, Effect__namespace.forkDaemon);
+        yield* _(Effect__namespace.addFinalizer(() => handleMessages.interruptAsFork(fiberId)));
+        const postMessages = yield* _(semaphore.take(1), Effect__namespace.zipRight(outbound.take), Effect__namespace.flatMap(([id, request]) => Function.pipe(Effect__namespace.suspend(() => {
+          const result = requestMap.get(id);
+          if (!result) return Effect__namespace.unit;
+          const transferables = transfers(request);
+          return Effect__namespace.zipRight(backing.send([id, 0, request], transferables), Deferred__namespace.await(result[1]));
+        }), Effect__namespace.ensuring(semaphore.release(1)), Effect__namespace.fork)), Effect__namespace.forever, Effect__namespace.forkDaemon);
+        yield* _(Effect__namespace.addFinalizer(() => postMessages.interruptAsFork(fiberId)));
+        const join = Effect__namespace.race(Fiber__namespace.joinAll([handleMessages, postMessages]), backing.join);
+        return {
+          id,
+          join,
+          execute,
+          executeEffect
+        };
+      });
+    }
+  });
+});
+
+/** @internal */
+const layerManager$1 = /*#__PURE__*/Layer__namespace.effect(WorkerManager$1, makeManager$1);
+
+/** @internal */
+const makePool$1 = () => options => Effect__namespace.gen(function* (_) {
+  const manager = yield* _(WorkerManager$1);
+  const backing = yield* _("timeToLive" in options ? Pool__namespace.makeWithTTL({
+    acquire: manager.spawn(options),
+    min: options.minSize,
+    max: options.maxSize,
+    timeToLive: options.timeToLive
+  }) : Pool__namespace.make({
+    acquire: manager.spawn(options),
+    size: options.size
+  }));
+  const pool = {
+    backing,
+    execute: message => Stream__namespace.unwrap(Effect__namespace.map(Effect__namespace.scoped(backing.get()), worker => worker.execute(message))),
+    executeEffect: message => Effect__namespace.flatMap(Effect__namespace.scoped(backing.get()), worker => worker.executeEffect(message))
+  };
+  return pool;
+});
+
+/** @internal */
+const makePoolLayer$1 = managerLayer => (tag, options) => Layer__namespace.provide(managerLayer, Layer__namespace.scoped(tag, makePool$1()(options)));
+
+/**
+ * @since 1.0.0
+ */
+
+/**
+ * @since 1.0.0
+ * @category models
+ */
+
+/**
+ * @since 1.0.0
+ * @category models
+ */
+
+/**
+ * @since 1.0.0
+ * @category type ids
+ */
+const PlatformWorkerTypeId = PlatformWorkerTypeId$1;
+
+/**
+ * @since 1.0.0
+ * @category type ids
+ */
+
+/**
+ * @since 1.0.0
+ * @category models
+ */
+
+/**
+ * @since 1.0.0
+ * @category tags
+ */
+const PlatformWorker = PlatformWorker$1;
+
+/**
+ * @since 1.0.0
+ * @category models
+ */
+
+/**
+ * @since 1.0.0
+ * @category models
+ */
+
+/**
+ * @since 1.0.0
+ * @category models
+ */
+
+/**
+ * @since 1.0.0
+ * @category models
+ */
+
+/**
+ * @category models
+ * @since 1.0.0
+ */
+
+/**
+ * @since 1.0.0
+ * @category type ids
+ */
+const WorkerManagerTypeId = WorkerManagerTypeId$1;
+
+/**
+ * @since 1.0.0
+ * @category type ids
+ */
+
+/**
+ * @since 1.0.0
+ * @category models
+ */
+
+/**
+ * @since 1.0.0
+ * @category tags
+ */
+const WorkerManager = WorkerManager$1;
+
+/**
+ * @since 1.0.0
+ * @category constructors
+ */
+const makeManager = makeManager$1;
+
+/**
+ * @since 1.0.0
+ * @category layers
+ */
+const layerManager = layerManager$1;
+
+/**
+ * @since 1.0.0
+ * @category constructors
+ */
+const makePool = makePool$1;
+
+/**
+ * @since 1.0.0
+ * @category constructors
+ */
+const makePoolLayer = makePoolLayer$1;
+
+exports.PlatformWorker = PlatformWorker;
+exports.PlatformWorkerTypeId = PlatformWorkerTypeId;
+exports.WorkerManager = WorkerManager;
+exports.WorkerManagerTypeId = WorkerManagerTypeId;
+exports.layerManager = layerManager;
+exports.makeManager = makeManager;
+exports.makePool = makePool;
+exports.makePoolLayer = makePoolLayer;