simply-observe 1.0.0

package/dist/index.js

@@ -0,0 +1,703 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all2) => {
+  for (var name in all2)
+    __defProp(target, name, { get: all2[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  Observer: () => Observer,
+  ObserverLike: () => ObserverLike,
+  Subject: () => Subject,
+  all: () => all,
+  catchError: () => catchError,
+  debounce: () => debounce,
+  filter: () => filter,
+  flat: () => flat,
+  interval: () => interval,
+  latest: () => latest,
+  map: () => map,
+  of: () => of,
+  partial: () => partial,
+  race: () => race,
+  retry: () => retry,
+  sequent: () => sequent,
+  skip: () => skip,
+  take: () => take,
+  takeUntil: () => takeUntil,
+  tap: () => tap,
+  timeout: () => timeout,
+  toPipe: () => toPipe,
+  zip: () => zip
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/subscription.ts
+var Subscription = class Subscription2 {
+  constructor(_unsubscribe = () => true) {
+    this._unsubscribe = _unsubscribe;
+    this._ref = crypto.randomUUID();
+    this._linked = [];
+    this._parents = null;
+    this._closed = false;
+    this.unsubscribe = () => {
+      let error;
+      if (!this._closed) {
+        this._closed = true;
+        const parents = this._parents;
+        this._parents = null;
+        if (parents) {
+          for (let parent of parents) {
+            parent.remove(this);
+          }
+        }
+        try {
+          if (!this._unsubscribe()) throw Error("Error occurred during unsubscription");
+        } catch (err) {
+          error = err;
+        }
+        const linked = this._linked;
+        this._linked = [];
+        for (let subscription of linked) {
+          subscription.unsubscribe();
+        }
+      }
+      if (error) throw error;
+    };
+    this.add = (subscription) => {
+      if (subscription !== this) {
+        if (this._closed) subscription.unsubscribe();
+        else {
+          if (subscription.closed || subscription.hasParent(this)) return;
+          subscription.linkParent(this);
+          this._linked.push(subscription);
+        }
+      }
+    };
+    this.remove = (subscription) => {
+      if (subscription !== this) {
+        const index = this._linked.indexOf(subscription);
+        0 <= index && this._linked.splice(index, 1);
+        if (subscription.hasParent(this)) subscription.removeParent(this);
+      }
+    };
+    this.linkParent = (subscription) => {
+      if (!this._parents) this._parents = [];
+      if (this.hasParent(subscription)) return;
+      this._parents.push(subscription);
+    };
+    this.removeParent = (subscription) => {
+      if (!Array.isArray(this._parents)) return;
+      const index = this._parents.indexOf(subscription);
+      0 <= index && this._parents.splice(index, 1);
+      if (this._parents.length === 0) this._parents = null;
+    };
+    this.hasParent = (subscription) => {
+      var _a;
+      return (_a = this._parents) == null ? void 0 : _a.includes(subscription);
+    };
+  }
+  get ref() {
+    return this._ref;
+  }
+  get closed() {
+    return this._closed;
+  }
+  get parents() {
+    return this._parents;
+  }
+};
+var subscription_default = Subscription;
+
+// src/context.ts
+var ObserverContext = class ObserverContext2 {
+  constructor() {
+    this._invoked = false;
+    this._closed = false;
+    this._subscribers = /* @__PURE__ */ new Set();
+    this.update = (value) => {
+      if (!this.active) return;
+      for (let { next } of this._subscribers.values()) {
+        if (next || typeof next === "function") {
+          try {
+            next(value);
+          } catch (error) {
+            this.error(error);
+          }
+        }
+      }
+    };
+    this.error = (value) => {
+      if (!this.active) return;
+      this._closed = true;
+      const subscribers = [...this._subscribers.values()];
+      this._subscribers.clear();
+      for (let { error } of subscribers) {
+        if (error || typeof error === "function") {
+          error(value);
+        }
+      }
+      this.finalize();
+    };
+    this.complete = (final) => {
+      if (!this.active) return;
+      this._closed = true;
+      const subscribers = [...this._subscribers.values()];
+      this._subscribers.clear();
+      for (let { complete } of subscribers) {
+        if (complete || typeof complete === "function") {
+          complete(final);
+        }
+      }
+      this.finalize();
+    };
+  }
+  get active() {
+    return !this._closed;
+  }
+  get invoked() {
+    return this._invoked;
+  }
+  finalize() {
+    if (this._teardown && typeof this._teardown === "function") {
+      this._teardown();
+    }
+  }
+  add(subscriber) {
+    this._subscribers.add(subscriber);
+    return () => {
+      this._subscribers.delete(subscriber);
+      if (this._subscribers.size === 0) {
+        this.close();
+      }
+      return true;
+    };
+  }
+  invoke(task) {
+    this._invoked = true;
+    this._teardown = task(this.update, this.error, this.complete);
+  }
+  close() {
+    if (!this.active) return;
+    this._closed = true;
+    this._subscribers.clear();
+    this.finalize();
+  }
+};
+
+// src/pipes.ts
+function map(fn) {
+  return (source) => new Observer((next, error, complete) => {
+    const sub = source.subscribe(
+      (val) => next(fn(val)),
+      error,
+      complete
+    );
+    return () => sub.unsubscribe();
+  });
+}
+function filter(predicate) {
+  return (source) => new Observer((next, error, complete) => {
+    const sub = source.subscribe(
+      (val) => {
+        if (predicate(val)) next(val);
+      },
+      error,
+      complete
+    );
+    return () => sub.unsubscribe();
+  });
+}
+function tap(fn) {
+  return (source) => new Observer((next, error, complete) => {
+    const sub = source.subscribe(
+      (val) => {
+        fn(val);
+        next(val);
+      },
+      error,
+      complete
+    );
+    return () => sub.unsubscribe();
+  });
+}
+function catchError(handler) {
+  return (source) => new Observer((next, error, complete) => {
+    let inner = null;
+    const outerSub = source.subscribe(
+      next,
+      (err) => {
+        const fallback = handler(err);
+        inner = fallback.subscribe(next, error, complete);
+      },
+      complete
+    );
+    return () => {
+      outerSub.unsubscribe();
+      inner == null ? void 0 : inner.unsubscribe();
+    };
+  });
+}
+function retry(count) {
+  return (source) => new Observer((next, error, complete) => {
+    const onError = (err) => {
+      if (count <= 0) {
+        error(err);
+        return;
+      }
+      count--;
+      inner = source.subscribe(next, onError, complete);
+    };
+    let inner = null;
+    const outerSub = source.subscribe(
+      next,
+      onError,
+      complete
+    );
+    return () => {
+      outerSub.unsubscribe();
+      inner == null ? void 0 : inner.unsubscribe();
+    };
+  });
+}
+function take(count) {
+  return (source) => new Observer((next, error, complete) => {
+    const sub = source.subscribe(
+      (val) => {
+        if (count < 0) return;
+        if (count === 0) complete();
+        count--;
+        next(val);
+      },
+      error,
+      complete
+    );
+    return () => sub.unsubscribe();
+  });
+}
+function takeUntil(notifier) {
+  return (source) => new Observer((next, error, complete) => {
+    const notification = notifier.subscribe(() => complete());
+    const sub = source.subscribe(
+      (val) => next(val),
+      error,
+      complete
+    );
+    return () => {
+      sub.unsubscribe();
+      notification.unsubscribe();
+    };
+  });
+}
+function skip(count) {
+  return (source) => new Observer((next, error, complete) => {
+    const sub = source.subscribe(
+      (val) => {
+        if (count > 0) {
+          count--;
+          return;
+        }
+        ;
+        next(val);
+      },
+      error,
+      complete
+    );
+    return () => sub.unsubscribe();
+  });
+}
+function debounce(value) {
+  return (source) => new Observer((next, error, complete) => {
+    let timeout2;
+    const sub = source.subscribe(
+      (val) => {
+        if (timeout2) clearTimeout(timeout2);
+        timeout2 = setTimeout(() => {
+          next(val);
+        }, value);
+      },
+      (err) => {
+        clearTimeout(timeout2);
+        error(err);
+      },
+      () => {
+        clearTimeout(timeout2);
+        complete();
+      }
+    );
+    return () => {
+      clearTimeout(timeout2);
+      sub.unsubscribe();
+    };
+  });
+}
+function toPipe(operators) {
+  if (operators.length === 0) return (x) => x;
+  if (operators.length === 1) return operators[0];
+  return (source) => {
+    return operators.reduce((a, f) => f(a), source);
+  };
+}
+
+// src/observer.ts
+var ObserverLike = class {
+  constructor() {
+    this.ref = crypto.randomUUID();
+    this._context = new ObserverContext();
+  }
+  get closed() {
+    return !this._context.active;
+  }
+};
+var Observer = class Observer2 extends ObserverLike {
+  constructor(task) {
+    super();
+    this.task = task;
+  }
+  close() {
+    if (!this._context.active) return;
+    this._context.close();
+  }
+  subscribe(next, error, complete) {
+    if (!this._context.active) this._context = new ObserverContext();
+    const teardown = this._context.add({ next, error, complete });
+    if (!this._context.invoked) this._context.invoke(this.task);
+    return new Subscription(teardown);
+  }
+  pipe(...operators) {
+    return toPipe(operators)(this);
+  }
+};
+
+// src/subject.ts
+var Subject = class Subject2 extends ObserverLike {
+  constructor(initial) {
+    super();
+    this.value = initial;
+  }
+  next(value) {
+    if (!this._context.active) return;
+    this.value = value;
+    this._context.update(value);
+  }
+  error(value) {
+    if (!this._context.active) return;
+    this.terminal = { type: "error", value };
+    this._context.error(value);
+  }
+  complete(final) {
+    if (!this._context.active) return;
+    this.terminal = { type: "complete", value: final };
+    this._context.complete(final);
+  }
+  close() {
+    if (!this._context.active) return;
+    this.terminal = { type: "complete", value: void 0 };
+    this._context.close();
+  }
+  asObservable() {
+    return new Observer((next, error, complete) => {
+      const sub = this.subscribe(next, error, complete);
+      return () => sub.unsubscribe();
+    });
+  }
+  subscribe(next, error, complete) {
+    if (this.terminal) {
+      if (this.terminal.type === "error") error == null ? void 0 : error(this.terminal.value);
+      else complete == null ? void 0 : complete(this.terminal.value);
+      return new Subscription(() => true);
+    }
+    const sub = new Subscription(this._context.add({ next, error, complete }));
+    if (this.value !== void 0) next(this.value);
+    return sub;
+  }
+};
+
+// src/utils.ts
+function of(...args) {
+  return new Observer((next, _, complete) => {
+    for (let item of args) {
+      next(item);
+    }
+    complete();
+  });
+}
+function timeout(value, delay = 0) {
+  return new Observer((next, _, complete) => {
+    const t = setTimeout(() => {
+      next(value);
+      complete();
+    }, delay);
+    return () => clearTimeout(t);
+  });
+}
+function interval(delay = 0) {
+  return new Observer((next) => {
+    let count = 0;
+    const t = setInterval(() => next(count++), delay);
+    return () => clearInterval(t);
+  });
+}
+function all(observers) {
+  const task = (next, error, complete) => {
+    if (observers.length === 0) {
+      next([]);
+      complete();
+      return () => {
+      };
+    }
+    const root = new subscription_default();
+    const stream = Array(observers.length);
+    const completed = Array(observers.length).fill(false);
+    observers.forEach((obs, i) => {
+      const sub = obs.subscribe((val) => {
+        stream[i] = val;
+      }, (err) => {
+        root.unsubscribe();
+        error(err);
+      }, () => {
+        completed[i] = true;
+        if (isAllCompleted(completed)) {
+          root.unsubscribe();
+          next([...stream]);
+          complete();
+        }
+      });
+      root.add(sub);
+    });
+    return () => root.unsubscribe();
+  };
+  return new Observer(task);
+}
+function partial(observers) {
+  const task = (next, error, complete) => {
+    if (observers.length === 0) {
+      complete();
+      return () => {
+      };
+    }
+    const root = new subscription_default();
+    const stream = Array(observers.length);
+    const completed = Array(observers.length).fill(false);
+    observers.map((obs, i) => {
+      const sub = obs.subscribe((val) => {
+        stream[i] = val;
+      }, (err) => {
+        root.unsubscribe();
+        error(err);
+      }, () => {
+        completed[i] = true;
+        next([...stream]);
+        if (isAllCompleted(completed)) {
+          root.unsubscribe();
+          complete();
+        }
+        ;
+      });
+      root.add(sub);
+    });
+    return () => root.unsubscribe();
+  };
+  return new Observer(task);
+}
+function latest(observers) {
+  const task = (next, error, complete) => {
+    if (observers.length === 0) {
+      next([]);
+      complete();
+      return () => {
+      };
+    }
+    const root = new subscription_default();
+    const stream = Array(observers.length);
+    const completed = Array(observers.length).fill(false);
+    observers.forEach((obs, i) => {
+      const sub = obs.subscribe((val) => {
+        stream[i] = val;
+        next([...stream]);
+      }, (err) => {
+        root.unsubscribe();
+        error(err);
+      }, () => {
+        completed[i] = true;
+        if (isAllCompleted(completed)) {
+          root.unsubscribe();
+          complete();
+        }
+      });
+      root.add(sub);
+    });
+    return () => root.unsubscribe();
+  };
+  return new Observer(task);
+}
+function sequent(observers) {
+  const task = (next, error, complete) => {
+    if (observers.length === 0) {
+      complete();
+      return () => {
+      };
+    }
+    const root = new subscription_default();
+    const queue = [...observers];
+    const mountNext = () => {
+      let value;
+      let obs = queue.shift();
+      if (!obs) {
+        root.unsubscribe();
+        complete();
+        return;
+      }
+      const sub = obs.subscribe((val) => {
+        value = val;
+        next(value);
+      }, (err) => {
+        root.unsubscribe();
+        error(err);
+      }, () => {
+        mountNext();
+      });
+      root.add(sub);
+    };
+    mountNext();
+    return () => root.unsubscribe();
+  };
+  return new Observer(task);
+}
+function race(observers) {
+  const task = (next, error, complete) => {
+    if (observers.length === 0) {
+      complete();
+      return () => {
+      };
+    }
+    const root = new subscription_default();
+    let won = false;
+    observers.forEach((obs) => {
+      const sub = obs.subscribe((val) => {
+        if (won) return;
+        won = true;
+        root.unsubscribe();
+        next(val);
+        complete();
+      }, (err) => {
+        if (won) return;
+        won = true;
+        root.unsubscribe();
+        error(err);
+      }, () => {
+      });
+      root.add(sub);
+    });
+    return () => root.unsubscribe();
+  };
+  return new Observer(task);
+}
+function flat(observers) {
+  const task = (next, error, complete) => {
+    if (observers.length === 0) {
+      complete();
+      return () => {
+      };
+    }
+    const root = new subscription_default();
+    const completed = Array(observers.length).fill(false);
+    observers.forEach((obs, i) => {
+      const sub = obs.subscribe((val) => {
+        next(val);
+      }, (err) => {
+        root.unsubscribe();
+        error(err);
+      }, () => {
+        completed[i] = true;
+        if (isAllCompleted(completed)) {
+          root.unsubscribe();
+          complete();
+        }
+      });
+      root.add(sub);
+    });
+    return () => root.unsubscribe();
+  };
+  return new Observer(task);
+}
+function zip(observers) {
+  const task = (next, error, complete) => {
+    if (observers.length === 0) {
+      next([]);
+      complete();
+      return () => {
+      };
+    }
+    const root = new subscription_default();
+    const streams = observers.map(() => []);
+    const completed = Array(observers.length).fill(false);
+    const checkReady = () => {
+      const min = Math.min(...streams.map((s) => s.length));
+      if (min > 0) {
+        next(streams.map((stream) => stream.shift()));
+      }
+    };
+    observers.forEach((obs, i) => {
+      const sub = obs.subscribe((val) => {
+        streams[i].push(val);
+        checkReady();
+      }, (err) => {
+        root.unsubscribe();
+        error(err);
+      }, () => {
+        completed[i] = true;
+        if (isAllCompleted(completed)) {
+          root.unsubscribe();
+          complete();
+        }
+      });
+      root.add(sub);
+    });
+    return () => root.unsubscribe();
+  };
+  return new Observer(task);
+}
+var isAllCompleted = (completed) => {
+  return !completed.includes(false);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Observer,
+  ObserverLike,
+  Subject,
+  all,
+  catchError,
+  debounce,
+  filter,
+  flat,
+  interval,
+  latest,
+  map,
+  of,
+  partial,
+  race,
+  retry,
+  sequent,
+  skip,
+  take,
+  takeUntil,
+  tap,
+  timeout,
+  toPipe,
+  zip
+});
+//# sourceMappingURL=index.js.map