effect 2.0.0-next.5 → 2.0.0-next.50

package/internal/string-utils.esm.js

@@ -0,0 +1,66 @@
+/**
+ * Adapted from the `change-case` library.
+ *
+ * Copyright (c) 2014 Blake Embrey (hello@blakeembrey.com)
+ */
+
+/** @internal */
+const lowerCase = str => str.toLowerCase();
+
+/** @internal */
+const upperCase = str => str.toUpperCase();
+/**
+ * Replace `re` in the input string with the replacement value.
+ */
+const replace = (input, re, value) => re instanceof RegExp ? input.replace(re, value) : re.reduce((input, re) => input.replace(re, value), input);
+
+// Support camel case ("camelCase" -> "camel Case" and "CAMELCase" -> "CAMEL Case").
+const DEFAULT_SPLIT_REGEXP = [/([a-z0-9])([A-Z])/g, /([A-Z])([A-Z][a-z])/g];
+
+// Remove all non-word characters.
+const DEFAULT_STRIP_REGEXP = /[^A-Z0-9]+/gi;
+
+/**
+ * Normalize the string into something other libraries can manipulate easier.
+ */
+const noCase = (input, options = {}) => {
+  const {
+    delimiter = " ",
+    splitRegexp = DEFAULT_SPLIT_REGEXP,
+    stripRegexp = DEFAULT_STRIP_REGEXP,
+    transform = lowerCase
+  } = options;
+  const result = replace(replace(input, splitRegexp, "$1\0$2"), stripRegexp, "\0");
+  let start = 0;
+  let end = result.length;
+  // Trim the delimiter from around the output string.
+  while (result.charAt(start) === "\0") {
+    start++;
+  }
+  while (result.charAt(end - 1) === "\0") {
+    end--;
+  }
+  // Transform each token independently.
+  return result.slice(start, end).split("\0").map(transform).join(delimiter);
+};
+
+/** @internal */
+const constantCase = (input, options = {}) => noCase(input, {
+  delimiter: "_",
+  transform: upperCase,
+  ...options
+});
+
+/** @internal */
+const kebabCase = (input, options = {}) => noCase(input, {
+  delimiter: "-",
+  ...options
+});
+
+/** @internal */
+const snakeCase = (input, options = {}) => noCase(input, {
+  delimiter: "_",
+  ...options
+});
+
+export { constantCase, kebabCase, lowerCase, snakeCase, upperCase };

package/internal/subscriptionRef.esm.js

@@ -0,0 +1,65 @@
+import { map, all, makeSemaphore, zipLeft, flatMap, succeed, as } from '../Effect/dist/effect-Effect.esm.js';
+import { pipe, dual } from '../Function/dist/effect-Function.esm.js';
+import { synchronizedVariance } from './effect/circular.esm.js';
+import { refVariance } from './ref.esm.js';
+import { pipeArguments } from '../Pipeable/dist/effect-Pipeable.esm.js';
+import { unbounded, publish } from '../PubSub/dist/effect-PubSub.esm.js';
+import { get as get$1, make as make$1, set as set$1, RefTypeId } from '../Ref/dist/effect-Ref.esm.js';
+import { SynchronizedRefTypeId } from '../SynchronizedRef/dist/effect-SynchronizedRef.esm.js';
+import { unwrapScoped, fromPubSub, concat, make as make$2 } from './stream.esm.js';
+
+/** @internal */
+const SubscriptionRefSymbolKey = "effect/SubscriptionRef";
+
+/** @internal */
+const SubscriptionRefTypeId = /*#__PURE__*/Symbol.for(SubscriptionRefSymbolKey);
+
+/** @internal */
+const subscriptionRefVariance = {
+  _A: _ => _
+};
+
+/** @internal */
+class SubscriptionRefImpl {
+  // @ts-ignore
+  [RefTypeId] = refVariance;
+  // @ts-ignore
+  [SynchronizedRefTypeId] = synchronizedVariance;
+  [SubscriptionRefTypeId] = subscriptionRefVariance;
+  constructor(ref, pubsub, semaphore) {
+    this.ref = ref;
+    this.pubsub = pubsub;
+    this.semaphore = semaphore;
+  }
+  pipe() {
+    return pipeArguments(this, arguments);
+  }
+  get changes() {
+    return pipe(get$1(this.ref), flatMap(a => map(fromPubSub(this.pubsub, {
+      scoped: true
+    }), s => concat(make$2(a), s))), this.semaphore.withPermits(1), unwrapScoped);
+  }
+  modify(f) {
+    return this.modifyEffect(a => succeed(f(a)));
+  }
+  modifyEffect(f) {
+    return pipe(get$1(this.ref), flatMap(f), flatMap(([b, a]) => pipe(set$1(this.ref, a), as(b), zipLeft(publish(this.pubsub, a)))), this.semaphore.withPermits(1));
+  }
+}
+
+/** @internal */
+const get = self => get$1(self.ref);
+
+/** @internal */
+const make = value => pipe(all([unbounded(), make$1(value), makeSemaphore(1)]), map(([pubsub, ref, semaphore]) => new SubscriptionRefImpl(ref, pubsub, semaphore)));
+
+/** @internal */
+const modify = /*#__PURE__*/dual(2, (self, f) => self.modify(f));
+
+/** @internal */
+const modifyEffect = /*#__PURE__*/dual(2, (self, f) => self.modifyEffect(f));
+
+/** @internal */
+const set = /*#__PURE__*/dual(2, (self, value) => pipe(set$1(self.ref, value), zipLeft(publish(self.pubsub, value)), self.semaphore.withPermits(1)));
+
+export { SubscriptionRefTypeId, get, make, modify, modifyEffect, set };

package/internal/supervisor/patch.esm.js

@@ -0,0 +1,156 @@
+import { of, isNonEmpty, headNonEmpty, prepend, tailNonEmpty } from '../../Chunk/dist/effect-Chunk.esm.js';
+import { make } from '../../Differ/dist/effect-Differ.esm.js';
+import { equals } from '../../Equal/dist/effect-Equal.esm.js';
+import { pipe } from '../../Function/dist/effect-Function.esm.js';
+import { reduce, difference, empty as empty$1, union, make as make$1 } from '../../HashSet/dist/effect-HashSet.esm.js';
+import { none, Zip } from '../supervisor.esm.js';
+
+/** @internal */
+
+/** @internal */
+const OP_EMPTY = "Empty";
+
+/** @internal */
+
+/** @internal */
+const OP_ADD_SUPERVISOR = "AddSupervisor";
+
+/** @internal */
+
+/** @internal */
+const OP_REMOVE_SUPERVISOR = "RemoveSupervisor";
+
+/** @internal */
+
+/** @internal */
+const OP_AND_THEN = "AndThen";
+
+/** @internal */
+
+/** @internal */
+
+/** @internal */
+
+/** @internal */
+
+/** @internal */
+
+/**
+ * The empty `SupervisorPatch`.
+ *
+ * @internal
+ */
+const empty = {
+  _tag: OP_EMPTY
+};
+
+/**
+ * Combines two patches to produce a new patch that describes applying the
+ * updates from this patch and then the updates from the specified patch.
+ *
+ * @internal
+ */
+const combine = (self, that) => {
+  return {
+    _tag: OP_AND_THEN,
+    first: self,
+    second: that
+  };
+};
+
+/**
+ * Applies a `SupervisorPatch` to a `Supervisor` to produce a new `Supervisor`.
+ *
+ * @internal
+ */
+const patch = (self, supervisor) => {
+  return patchLoop(supervisor, of(self));
+};
+
+/** @internal */
+const patchLoop = (_supervisor, _patches) => {
+  let supervisor = _supervisor;
+  let patches = _patches;
+  while (isNonEmpty(patches)) {
+    const head = headNonEmpty(patches);
+    switch (head._tag) {
+      case OP_EMPTY:
+        {
+          patches = tailNonEmpty(patches);
+          break;
+        }
+      case OP_ADD_SUPERVISOR:
+        {
+          supervisor = supervisor.zip(head.supervisor);
+          patches = tailNonEmpty(patches);
+          break;
+        }
+      case OP_REMOVE_SUPERVISOR:
+        {
+          supervisor = removeSupervisor(supervisor, head.supervisor);
+          patches = tailNonEmpty(patches);
+          break;
+        }
+      case OP_AND_THEN:
+        {
+          patches = prepend(head.first)(prepend(head.second)(tailNonEmpty(patches)));
+          break;
+        }
+    }
+  }
+  return supervisor;
+};
+
+/** @internal */
+const removeSupervisor = (self, that) => {
+  if (equals(self, that)) {
+    return none;
+  } else {
+    if (self instanceof Zip) {
+      return removeSupervisor(self.left, that).zip(removeSupervisor(self.right, that));
+    } else {
+      return self;
+    }
+  }
+};
+
+/** @internal */
+const toSet = self => {
+  if (equals(self, none)) {
+    return empty$1();
+  } else {
+    if (self instanceof Zip) {
+      return pipe(toSet(self.left), union(toSet(self.right)));
+    } else {
+      return make$1(self);
+    }
+  }
+};
+
+/** @internal */
+const diff = (oldValue, newValue) => {
+  if (equals(oldValue, newValue)) {
+    return empty;
+  }
+  const oldSupervisors = toSet(oldValue);
+  const newSupervisors = toSet(newValue);
+  const added = pipe(newSupervisors, difference(oldSupervisors), reduce(empty, (patch, supervisor) => combine(patch, {
+    _tag: OP_ADD_SUPERVISOR,
+    supervisor
+  })));
+  const removed = pipe(oldSupervisors, difference(newSupervisors), reduce(empty, (patch, supervisor) => combine(patch, {
+    _tag: OP_REMOVE_SUPERVISOR,
+    supervisor
+  })));
+  return combine(added, removed);
+};
+
+/** @internal */
+const differ = /*#__PURE__*/make({
+  empty,
+  patch,
+  combine,
+  diff
+});
+
+export { OP_ADD_SUPERVISOR, OP_AND_THEN, OP_EMPTY, OP_REMOVE_SUPERVISOR, combine, diff, differ, empty, patch };

package/internal/supervisor.esm.js

@@ -0,0 +1,205 @@
+import { pipe } from '../Function/dist/effect-Function.esm.js';
+import { globalValue } from '../GlobalValue/dist/effect-GlobalValue.esm.js';
+import { map, zip, sync, unit } from './core.esm.js';
+import { get, set } from '../MutableRef/dist/effect-MutableRef.esm.js';
+import { add, remove } from '../SortedSet/dist/effect-SortedSet.esm.js';
+
+/** @internal */
+const SupervisorSymbolKey = "effect/Supervisor";
+
+/** @internal */
+const SupervisorTypeId = /*#__PURE__*/Symbol.for(SupervisorSymbolKey);
+
+/** @internal */
+const supervisorVariance = {
+  _T: _ => _
+};
+
+/** @internal */
+class ProxySupervisor {
+  [SupervisorTypeId] = supervisorVariance;
+  constructor(underlying, value0) {
+    this.underlying = underlying;
+    this.value0 = value0;
+  }
+  value() {
+    return this.value0();
+  }
+  onStart(context, effect, parent, fiber) {
+    this.underlying.onStart(context, effect, parent, fiber);
+  }
+  onEnd(value, fiber) {
+    this.underlying.onEnd(value, fiber);
+  }
+  onEffect(fiber, effect) {
+    this.underlying.onEffect(fiber, effect);
+  }
+  onSuspend(fiber) {
+    this.underlying.onSuspend(fiber);
+  }
+  onResume(fiber) {
+    this.underlying.onResume(fiber);
+  }
+  map(f) {
+    return new ProxySupervisor(this, () => pipe(this.value(), map(f)));
+  }
+  zip(right) {
+    return new Zip(this, right);
+  }
+}
+
+/** @internal */
+class Zip {
+  [SupervisorTypeId] = supervisorVariance;
+  constructor(left, right) {
+    this.left = left;
+    this.right = right;
+  }
+  value() {
+    return zip(this.left.value(), this.right.value());
+  }
+  onStart(context, effect, parent, fiber) {
+    this.left.onStart(context, effect, parent, fiber);
+    this.right.onStart(context, effect, parent, fiber);
+  }
+  onEnd(value, fiber) {
+    this.left.onEnd(value, fiber);
+    this.right.onEnd(value, fiber);
+  }
+  onEffect(fiber, effect) {
+    this.left.onEffect(fiber, effect);
+    this.right.onEffect(fiber, effect);
+  }
+  onSuspend(fiber) {
+    this.left.onSuspend(fiber);
+    this.right.onSuspend(fiber);
+  }
+  onResume(fiber) {
+    this.left.onResume(fiber);
+    this.right.onResume(fiber);
+  }
+  map(f) {
+    return new ProxySupervisor(this, () => pipe(this.value(), map(f)));
+  }
+  zip(right) {
+    return new Zip(this, right);
+  }
+}
+class Track {
+  [SupervisorTypeId] = supervisorVariance;
+  fibers = new Set();
+  value() {
+    return sync(() => Array.from(this.fibers));
+  }
+  onStart(_context, _effect, _parent, fiber) {
+    this.fibers.add(fiber);
+  }
+  onEnd(_value, fiber) {
+    this.fibers.delete(fiber);
+  }
+  onEffect(_fiber, _effect) {
+    //
+  }
+  onSuspend(_fiber) {
+    //
+  }
+  onResume(_fiber) {
+    //
+  }
+  map(f) {
+    return new ProxySupervisor(this, () => pipe(this.value(), map(f)));
+  }
+  zip(right) {
+    return new Zip(this, right);
+  }
+  onRun(execution, _fiber) {
+    return execution();
+  }
+}
+class Const {
+  [SupervisorTypeId] = supervisorVariance;
+  constructor(effect) {
+    this.effect = effect;
+  }
+  value() {
+    return this.effect;
+  }
+  onStart(_context, _effect, _parent, _fiber) {
+    //
+  }
+  onEnd(_value, _fiber) {
+    //
+  }
+  onEffect(_fiber, _effect) {
+    //
+  }
+  onSuspend(_fiber) {
+    //
+  }
+  onResume(_fiber) {
+    //
+  }
+  map(f) {
+    return new ProxySupervisor(this, () => pipe(this.value(), map(f)));
+  }
+  zip(right) {
+    return new Zip(this, right);
+  }
+  onRun(execution, _fiber) {
+    return execution();
+  }
+}
+class FibersIn {
+  [SupervisorTypeId] = supervisorVariance;
+  constructor(ref) {
+    this.ref = ref;
+  }
+  value() {
+    return sync(() => get(this.ref));
+  }
+  onStart(_context, _effect, _parent, fiber) {
+    pipe(this.ref, set(pipe(get(this.ref), add(fiber))));
+  }
+  onEnd(_value, fiber) {
+    pipe(this.ref, set(pipe(get(this.ref), remove(fiber))));
+  }
+  onEffect(_fiber, _effect) {
+    //
+  }
+  onSuspend(_fiber) {
+    //
+  }
+  onResume(_fiber) {
+    //
+  }
+  map(f) {
+    return new ProxySupervisor(this, () => pipe(this.value(), map(f)));
+  }
+  zip(right) {
+    return new Zip(this, right);
+  }
+  onRun(execution, _fiber) {
+    return execution();
+  }
+}
+
+/** @internal */
+const unsafeTrack = () => {
+  return new Track();
+};
+
+/** @internal */
+const track = /*#__PURE__*/sync(unsafeTrack);
+
+/** @internal */
+const fromEffect = effect => {
+  return new Const(effect);
+};
+
+/** @internal */
+const none = /*#__PURE__*/globalValue("effect/Supervisor/none", () => fromEffect(unit));
+
+/** @internal */
+const fibersIn = ref => sync(() => new FibersIn(ref));
+
+export { Const, ProxySupervisor, SupervisorTypeId, Track, Zip, fibersIn, fromEffect, none, supervisorVariance, track, unsafeTrack };

package/internal/synchronizedRef.esm.js

@@ -0,0 +1,53 @@
+import { dual, pipe } from '../Function/dist/effect-Function.esm.js';
+import { map, succeed } from './core.esm.js';
+import { getOrElse } from '../Option/dist/effect-Option.esm.js';
+
+/** @internal */
+const getAndUpdateEffect = /*#__PURE__*/dual(2, (self, f) => self.modifyEffect(value => map(f(value), result => [value, result])));
+
+/** @internal */
+const getAndUpdateSomeEffect = /*#__PURE__*/dual(2, (self, pf) => self.modifyEffect(value => {
+  const result = pf(value);
+  switch (result._tag) {
+    case "None":
+      {
+        return succeed([value, value]);
+      }
+    case "Some":
+      {
+        return map(result.value, newValue => [value, newValue]);
+      }
+  }
+}));
+
+/** @internal */
+const modify = /*#__PURE__*/dual(2, (self, f) => self.modify(f));
+
+/** @internal */
+const modifyEffect = /*#__PURE__*/dual(2, (self, f) => self.modifyEffect(f));
+
+/** @internal */
+const modifySomeEffect = /*#__PURE__*/dual(3, (self, fallback, pf) => self.modifyEffect(value => pipe(pf(value), getOrElse(() => succeed([fallback, value])))));
+
+/** @internal */
+const updateEffect = /*#__PURE__*/dual(2, (self, f) => self.modifyEffect(value => map(f(value), result => [undefined, result])));
+
+/** @internal */
+const updateAndGetEffect = /*#__PURE__*/dual(2, (self, f) => self.modifyEffect(value => map(f(value), result => [result, result])));
+
+/** @internal */
+const updateSomeEffect = /*#__PURE__*/dual(2, (self, pf) => self.modifyEffect(value => {
+  const result = pf(value);
+  switch (result._tag) {
+    case "None":
+      {
+        return succeed([void 0, value]);
+      }
+    case "Some":
+      {
+        return map(result.value, a => [void 0, a]);
+      }
+  }
+}));
+
+export { getAndUpdateEffect, getAndUpdateSomeEffect, modify, modifyEffect, modifySomeEffect, updateAndGetEffect, updateEffect, updateSomeEffect };

package/internal/take.esm.js

@@ -0,0 +1,130 @@
+import { RuntimeException, map as map$1, flipCauseOption } from '../Cause/dist/effect-Cause.esm.js';
+import { of as of$1, map as map$3 } from '../Chunk/dist/effect-Chunk.esm.js';
+import { suspend, matchCause, asUnit } from '../Effect/dist/effect-Effect.esm.js';
+import { succeed, die as die$1, fail as fail$1, failCause as failCause$1, mapBoth, match as match$2, matchEffect as matchEffect$1, map as map$2, forEachEffect } from '../Exit/dist/effect-Exit.esm.js';
+import { pipe, constFalse, constTrue, dual } from '../Function/dist/effect-Function.esm.js';
+import { none, some, match as match$1, isNone, isSome } from '../Option/dist/effect-Option.esm.js';
+import { pipeArguments } from '../Pipeable/dist/effect-Pipeable.esm.js';
+
+/** @internal */
+const TakeSymbolKey = "effect/Take";
+
+/** @internal */
+const TakeTypeId = /*#__PURE__*/Symbol.for(TakeSymbolKey);
+
+/** @internal */
+const takeVariance = {
+  _E: _ => _,
+  _A: _ => _
+};
+
+/** @internal */
+class TakeImpl {
+  [TakeTypeId] = takeVariance;
+  constructor(exit) {
+    this.exit = exit;
+  }
+  pipe() {
+    return pipeArguments(this, arguments);
+  }
+}
+
+/** @internal */
+const chunk = chunk => new TakeImpl(succeed(chunk));
+
+/** @internal */
+const die = defect => new TakeImpl(die$1(defect));
+
+/** @internal */
+const dieMessage = message => new TakeImpl(die$1(RuntimeException(message)));
+
+/** @internal */
+const done = self => suspend(() => self.exit);
+
+/** @internal */
+const end = /*#__PURE__*/new TakeImpl( /*#__PURE__*/fail$1( /*#__PURE__*/none()));
+
+/** @internal */
+const fail = error => new TakeImpl(fail$1(some(error)));
+
+/** @internal */
+const failCause = cause => new TakeImpl(failCause$1(pipe(cause, map$1(some))));
+
+/** @internal */
+const fromEffect = effect => matchCause(effect, {
+  onFailure: failCause,
+  onSuccess: of
+});
+
+/** @internal */
+const fromExit = exit => new TakeImpl(pipe(exit, mapBoth({
+  onFailure: some,
+  onSuccess: of$1
+})));
+
+/** @internal */
+const fromPull = pull => matchCause(pull, {
+  onFailure: cause => match$1(flipCauseOption(cause), {
+    onNone: () => end,
+    onSome: failCause
+  }),
+  onSuccess: chunk
+});
+
+/** @internal */
+const isDone = self => match$2(self.exit, {
+  onFailure: cause => isNone(flipCauseOption(cause)),
+  onSuccess: constFalse
+});
+
+/** @internal */
+const isFailure = self => match$2(self.exit, {
+  onFailure: cause => isSome(flipCauseOption(cause)),
+  onSuccess: constFalse
+});
+
+/** @internal */
+const isSuccess = self => match$2(self.exit, {
+  onFailure: constFalse,
+  onSuccess: constTrue
+});
+
+/** @internal */
+const make = exit => new TakeImpl(exit);
+
+/** @internal */
+const match = /*#__PURE__*/dual(2, (self, {
+  onEnd,
+  onFailure,
+  onSuccess
+}) => match$2(self.exit, {
+  onFailure: cause => match$1(flipCauseOption(cause), {
+    onNone: onEnd,
+    onSome: onFailure
+  }),
+  onSuccess
+}));
+
+/** @internal */
+const matchEffect = /*#__PURE__*/dual(2, (self, {
+  onEnd,
+  onFailure,
+  onSuccess
+}) => matchEffect$1(self.exit, {
+  onFailure: cause => match$1(flipCauseOption(cause), {
+    onNone: onEnd,
+    onSome: onFailure
+  }),
+  onSuccess
+}));
+
+/** @internal */
+const map = /*#__PURE__*/dual(2, (self, f) => new TakeImpl(pipe(self.exit, map$2(map$3(f)))));
+
+/** @internal */
+const of = value => new TakeImpl(succeed(of$1(value)));
+
+/** @internal */
+const tap = /*#__PURE__*/dual(2, (self, f) => pipe(self.exit, forEachEffect(f), asUnit));
+
+export { TakeImpl, TakeTypeId, chunk, die, dieMessage, done, end, fail, failCause, fromEffect, fromExit, fromPull, isDone, isFailure, isSuccess, make, map, match, matchEffect, of, tap };