@wovin/core 0.0.1-RC5 → 0.0.1-RC6

package/dist/chunk-TYTIT5QO.js

@@ -0,0 +1,768 @@
+import {
+  __publicField
+} from "./chunk-F3FYYIAV.js";
+
+// src/data/applog-utils.ts
+import { Logger } from "besonders-logger/src";
+import { isBefore } from "date-fns";
+import { comparer } from "mobx";
+import stringify from "safe-stable-stringify";
+var { WARN, LOG, DEBUG, VERBOSE, ERROR } = Logger.setup(Logger.DEBUG);
+var isoDateStrCompare = (strA, strB, dir = "asc") => dir === "asc" ? strA.localeCompare(strB, "en-US") : strB.localeCompare(strA, "en-US");
+function sortApplogsByTs(appLogArray, dir = "asc") {
+  return appLogArray.sort((a, b) => isoDateStrCompare(a.ts, b.ts, dir));
+}
+var isTsBefore = (log, logToCompare) => isBefore(new Date(log.ts), new Date(logToCompare.ts));
+var uniqueEnFromAppLogs = (appLogArray) => [...new Set(appLogArray.map((eachLog) => eachLog.en))];
+var areApplogsEqual = (logA, logB) => comparer.structural(logA, logB);
+var removeDuplicateAppLogs = (appLogArray) => {
+  const logMap = /* @__PURE__ */ new Map();
+  for (const eachLog of appLogArray) {
+    if (!eachLog) {
+      ERROR(`falsy entry in applogs`, appLogArray);
+      throw new Error(`falsy entry in applogs`);
+    }
+    logMap.set(stringify(eachLog), eachLog);
+  }
+  return Array.from(logMap.values());
+};
+var getHashID = (stringifiable, lngth = 8) => cyrb53hash(stringify(stringifiable), 31, lngth);
+function isVariable(x) {
+  return typeof x === "string" && x.startsWith("?");
+}
+function variableNameWithoutQuestionmark(str) {
+  return str.slice(1);
+}
+function isStaticPattern(x) {
+  if (!["string", "boolean", "number", "function"].includes(typeof x))
+    WARN(`Unhandled pattern value type:`, typeof x, x);
+  return !isVariable(x) && ["string", "boolean", "number"].includes(typeof x);
+}
+function resolveOrRemoveVariables(pattern, candidate) {
+  let variablesToFill = {};
+  const newPattern = Object.entries(pattern).reduce((acc, [patternKey, patternValue]) => {
+    if (isVariable(patternValue)) {
+      const varName = variableNameWithoutQuestionmark(patternValue);
+      const candidateValue = candidate[varName];
+      if (candidateValue) {
+        acc[patternKey] = candidateValue;
+      } else {
+        variablesToFill[patternKey] = varName;
+      }
+    } else {
+      acc[patternKey] = patternValue;
+    }
+    return acc;
+  }, {});
+  return [newPattern, variablesToFill];
+}
+function matchVariable(variable, triplePart, context) {
+  if (context.hasOwnProperty(variable)) {
+    const bound = context[variable];
+    const match = matchPart(bound, triplePart, context);
+    VERBOSE("[matchVariable] match?", variable, bound, match);
+    return match;
+  }
+  VERBOSE("[matchVariable] initializing variable", variable, "to", triplePart);
+  return { ...context, [variable]: triplePart };
+}
+function matchPartStatic(field, patternPart, atomPart) {
+  VERBOSE("[matchPartStatic]", field, patternPart, patternPart === atomPart ? "===" : "!==", atomPart);
+  const result = (() => {
+    if (typeof patternPart === "function") {
+      return patternPart(atomPart);
+    }
+    if (Array.isArray(patternPart) && !Array.isArray(atomPart)) {
+      return patternPart.includes(atomPart);
+    }
+    return patternPart === atomPart;
+  })();
+  VERBOSE("[matchPartStatic] =>", field.startsWith("!") ? "!" : "", result);
+  if (field.startsWith("!")) {
+    return !result;
+  } else {
+    return result;
+  }
+}
+function matchPart(patternPart, atomPart, context) {
+  if (!context) {
+    VERBOSE("[matchPart] no context");
+    return null;
+  }
+  if (typeof patternPart === "string") {
+    if (isVariable(patternPart)) {
+      return matchVariable(patternPart, atomPart, context);
+    }
+  }
+  VERBOSE("[matchPart]", patternPart, patternPart === atomPart ? "===" : "!==", atomPart);
+  if (typeof patternPart === "function") {
+    return patternPart(atomPart) ? context : null;
+  }
+  return patternPart === atomPart ? context : null;
+}
+function matchPattern(pattern, applog, context) {
+  return Object.entries(pattern).reduce((context2, [field, patternValue]) => {
+    const applogValue = applog[field];
+    const patternValT = patternValue;
+    return matchPart(patternValT, applogValue, context2);
+  }, context);
+}
+function actualize(context, find) {
+  return Object.fromEntries(find.map((findField) => {
+    if (context === null) {
+      throw new Error(`actualize context is null ${find}`);
+    }
+    return [
+      isVariable(findField) ? findField.replace(/^\?/, "") : findField,
+      isVariable(findField) ? context[findField] : findField
+    ];
+  }));
+}
+var sum = function sum2(array) {
+  var num = 0;
+  for (var i = 0, l = array.length; i < l; i++)
+    num += array[i];
+  return num;
+};
+var mean = function mean2(array) {
+  return sum(array) / array.length;
+};
+var arrStats = {
+  max: function(array) {
+    return Math.max.apply(null, array);
+  },
+  min: function(array) {
+    return Math.min.apply(null, array);
+  },
+  range: function(array) {
+    return arrStats.max(array) - arrStats.min(array);
+  },
+  midrange: function(array) {
+    return arrStats.range(array) / 2;
+  },
+  sum,
+  mean,
+  average: mean,
+  median: function(array) {
+    array.sort(function(a, b) {
+      return a - b;
+    });
+    var mid = array.length / 2;
+    return mid % 1 ? array[mid - 0.5] : (array[mid - 1] + array[mid]) / 2;
+  },
+  modes: function(array) {
+    if (!array.length)
+      return [];
+    var modeMap = {}, maxCount = 0, modes = [];
+    array.forEach(function(val) {
+      if (!modeMap[val])
+        modeMap[val] = 1;
+      else
+        modeMap[val]++;
+      if (modeMap[val] > maxCount) {
+        modes = [val];
+        maxCount = modeMap[val];
+      } else if (modeMap[val] === maxCount) {
+        modes.push(val);
+        maxCount = modeMap[val];
+      }
+    });
+    return modes;
+  },
+  variance: function(array) {
+    var mean3 = arrStats.mean(array);
+    return arrStats.mean(array.map(function(num) {
+      return Math.pow(num - mean3, 2);
+    }));
+  },
+  standardDeviation: function(array) {
+    return Math.sqrt(arrStats.variance(array));
+  },
+  meanAbsoluteDeviation: function(array) {
+    var mean3 = arrStats.mean(array);
+    return arrStats.mean(array.map(function(num) {
+      return Math.abs(num - mean3);
+    }));
+  },
+  zScores: function(array) {
+    var mean3 = arrStats.mean(array);
+    var standardDeviation = arrStats.standardDeviation(array);
+    return array.map(function(num) {
+      return (num - mean3) / standardDeviation;
+    });
+  }
+};
+arrStats.average = arrStats.mean;
+var tsNearlySame = (timeA, timeB) => timeB.startsWith(timeA.slice(0, timeA.length - 4));
+var cyrb53hash = function(str, seed = 13, strLength) {
+  if (!str?.length) {
+    throw new Error(`Empty string: ${str}`);
+  }
+  let h1 = 3735928559 ^ seed;
+  let h2 = 1103547991 ^ seed;
+  for (let i = 0, ch; i < str.length; i++) {
+    ch = str.charCodeAt(i);
+    h1 = Math.imul(h1 ^ ch, 2654435761);
+    h2 = Math.imul(h2 ^ ch, 1597334677);
+  }
+  h1 = Math.imul(h1 ^ h1 >>> 16, 2246822507) ^ Math.imul(h2 ^ h2 >>> 13, 3266489909);
+  h2 = Math.imul(h2 ^ h2 >>> 16, 2246822507) ^ Math.imul(h1 ^ h1 >>> 13, 3266489909);
+  const asHex = (4294967296 * (2097151 & h2) + (h1 >>> 0)).toString(16);
+  return asHex.slice(-strLength).padStart(strLength, "0");
+};
+function arraysContainSameElements(arr1, arr2) {
+  if (arr1.length !== arr2.length) {
+    return false;
+  }
+  const sortedArr1 = [...arr1].sort();
+  const sortedArr2 = [...arr2].sort();
+  for (let i = 0; i < sortedArr1.length; i++) {
+    if (sortedArr1[i] !== sortedArr2[i]) {
+      return false;
+    }
+  }
+  return true;
+}
+function dateNowIso() {
+  const now = /* @__PURE__ */ new Date();
+  return now.toISOString();
+}
+
+// src/mobx/mobx-utils.ts
+import { Logger as Logger2 } from "besonders-logger/src";
+import {
+  _getGlobalState,
+  _isComputingDerivation,
+  comparer as comparer2,
+  computed,
+  configure,
+  getDependencyTree,
+  getObserverTree,
+  isAction,
+  observable,
+  onBecomeUnobserved,
+  Reaction,
+  runInAction,
+  spy,
+  trace,
+  untracked
+} from "mobx";
+import stringify2 from "safe-stable-stringify";
+var { WARN: WARN2, LOG: LOG2, DEBUG: DEBUG2, VERBOSE: VERBOSE2, ERROR: ERROR2 } = Logger2.setup(Logger2.INFO);
+configure({
+  enforceActions: "always"
+  // disableErrorBoundaries: true // (i) this can be useful in case of exceptions to see where they were caused - https://mobx.js.org/configuration.html#disableerrorboundaries-boolean
+  // computedRequiresReaction: true,
+  // reactionRequiresObservable: true,
+  // observableRequiresReaction: true,
+});
+if (!new class {
+  constructor() {
+    __publicField(this, "xyz");
+  }
+}().hasOwnProperty("xyz"))
+  throw new Error("Transpiler is not configured correctly");
+if (typeof window === "object") {
+  window.getDependencyTree = getDependencyTree;
+  window.getObserverTree = getObserverTree;
+}
+VERBOSE2.isDisabled || spy((event) => {
+  VERBOSE2(`[mobx]`, event);
+});
+var createDebugName = ({ caller, stream, pattern: args }) => {
+  const str = `${stream?.name ? stream.name + " | " : ""}${caller ?? "caller?"}${args ? `{${typeof args === "string" ? args : stringify2(args)}}` : ""}`;
+  return str;
+};
+var createDebugNameObj = (args) => {
+  return { name: createDebugName(args) };
+};
+function computedStructuralComparer(a, b) {
+  return untracked(() => comparer2.structural(a.get(), b.get()));
+}
+function applogStreamComparer(a, b) {
+  return comparer2.shallow(a.applogs, b.applogs);
+}
+function queryNodesComparer(a, b) {
+  if (a.size !== b.size)
+    return false;
+  for (let i = 0; i < a.size; i++) {
+    const nodeA = a.nodes[i];
+    const nodeB = b.nodes[i];
+    VERBOSE2(`queryNodesComparer`, i, nodeA, nodeB);
+    if (!comparer2.structural(nodeA.variables, nodeB.variables)) {
+      return false;
+    }
+    if (!applogStreamComparer(nodeA.logsOfThisNode, nodeB.logsOfThisNode)) {
+      return false;
+    }
+  }
+  return true;
+}
+var observableArrayMapID = 0;
+function observableArrayMap(fn, { name, equals } = {}) {
+  VERBOSE2(`[observableArrayMap] create`, { fnname: fn.name, fn, name, equals });
+  const debugName = `observableArrayMap@${++observableArrayMapID}{${name}}`;
+  let observableArr;
+  let items;
+  function runAndTrack() {
+    reaction2.track(() => {
+      DEBUG2(`[${debugName}] runAndTrack:`, { name: name ?? fn.name, fn });
+      items = fn();
+      VERBOSE2(`[${debugName}] runAndTrack =>`, items);
+    });
+  }
+  const reaction2 = new Reaction(debugName, (...args) => {
+    VERBOSE2(`[${debugName}] reaction.invalidate`, args);
+    runAndTrack();
+    runInAction(() => {
+      if (!(equals ?? comparer2.structural)(observableArr, items)) {
+        observableArr.replace(items);
+      }
+    });
+  });
+  runAndTrack();
+  observableArr = observable.array(
+    items,
+    /* ['NEVER'] as T[] */
+    { deep: false, name }
+  );
+  VERBOSE2(`[${debugName}] deps of reaction`, getDependencyTree(reaction2), "array:", getDependencyTree(observableArr), {
+    reaction: reaction2,
+    observableArr
+  });
+  const unobserveUnobserving = onBecomeUnobserved(observableArr, () => {
+    VERBOSE2(`[observableArrayMap] dispose`);
+    reaction2.dispose();
+    unobserveUnobserving();
+  });
+  return observableArr;
+}
+function computedFnDeepCompare(fn, keepAliveOrOptions = false) {
+  if (isAction(fn))
+    throw new Error("computedFnDeepCompare shouldn't be used on actions");
+  let memoWarned = false;
+  let i = 0;
+  const opts = typeof keepAliveOrOptions === "boolean" ? { keepAlive: keepAliveOrOptions } : keepAliveOrOptions;
+  const map = /* @__PURE__ */ new Map();
+  return function(...args) {
+    let existing;
+    const untrackedArgs = untracked(() => args);
+    const debugName = `computedFnDeepCompare(${opts.name || fn.name}#${++i})${opts.argsDebugName ? `{${opts.argsDebugName(...args)}}` : ""}`;
+    for (let [existingArgs, computation2] of map.entries()) {
+      if (comparer2.structural(existingArgs, untrackedArgs)) {
+        existing = computation2;
+        break;
+      }
+    }
+    if (existing) {
+      const cachedResult = existing.get();
+      VERBOSE2(`[${debugName}] cache hit`, { untrackedArgs, cachedResult });
+      return cachedResult;
+    }
+    if (!opts.keepAlive && !_isComputingDerivation()) {
+      if (!memoWarned && _getGlobalState().computedRequiresReaction) {
+        console.warn(
+          "invoking a computedFn from outside an reactive context won't be memoized, unless keepAlive is set"
+        );
+        memoWarned = true;
+      }
+      return fn.apply(this, args);
+    }
+    VERBOSE2(`[${debugName}] new computation`, { untrackedArgs });
+    let latestValue;
+    const computation = computed(
+      () => {
+        VERBOSE2(`[${debugName}] update->rerun`, untracked(() => ({ args })), fn);
+        VERBOSE2.isDisabled || trace();
+        return latestValue = fn.apply(this, args);
+      },
+      {
+        ...opts,
+        name: debugName
+      }
+    );
+    VERBOSE2(`[${debugName}] deps`, getDependencyTree(computation), { untrackedArgs });
+    map.set(untrackedArgs, computation);
+    if (!opts.keepAlive) {
+      const unobserveUnobserving = onBecomeUnobserved(computation, () => {
+        VERBOSE2(`[${debugName}] dispose`, computation);
+        map.delete(untrackedArgs);
+        if (opts.onCleanup)
+          opts.onCleanup(latestValue, ...args);
+        latestValue = void 0;
+        unobserveUnobserving();
+      });
+    }
+    return computation.get();
+  };
+}
+function prettifyStreamName(input) {
+  let depth = 0;
+  let result = "";
+  let insideCurlyBraces = 0;
+  for (let i = 0; i < input.length; i++) {
+    const char = input[i];
+    if (char === "(") {
+      result += char + "\n" + "	".repeat(++depth);
+    } else if (char === ")") {
+      result += "\n" + "	".repeat(--depth) + char;
+    } else if (char === "," && insideCurlyBraces === 0) {
+      result += char + "\n" + "	".repeat(depth);
+    } else if (char === "{" && insideCurlyBraces === 0) {
+      insideCurlyBraces++;
+      result += char + "\n" + "	".repeat(depth + 1);
+    } else if (char === "}" && insideCurlyBraces === 1) {
+      insideCurlyBraces--;
+      result += "\n" + "	".repeat(depth) + char;
+    } else if (char === "{" && insideCurlyBraces > 0) {
+      insideCurlyBraces++;
+      result += char;
+    } else if (char === "}" && insideCurlyBraces > 1) {
+      insideCurlyBraces--;
+      result += char;
+    } else {
+      result += char;
+    }
+  }
+  return result;
+}
+
+// src/stream/basic.ts
+import { computed as computed2, makeObservable, untracked as untracked2 } from "mobx";
+import { Logger as Logger3 } from "besonders-logger/src";
+var { WARN: WARN3, LOG: LOG3, DEBUG: DEBUG3, VERBOSE: VERBOSE3, ERROR: ERROR3 } = Logger3.setup(Logger3.INFO, { prefix: "[stream]" });
+function isInitEvent(event) {
+  return event.init !== void 0;
+}
+var ApplogStream = class {
+  constructor(parents, filters, _applogs = [], name) {
+    this._applogs = _applogs;
+    this.name = name;
+    __publicField(this, "filters");
+    __publicField(this, "parents");
+    __publicField(this, "_subscribers", []);
+    this.parents = parents && !Array.isArray(parents) ? [parents] : parents;
+    this.filters = filters;
+    if (this.parents?.length === 0) {
+      throw new Error(`Unhandled: empty parents`);
+    }
+    makeObservable(this, {
+      // applogs: computed, //observable.shallow,
+      // applogsSorted: computed,
+      size: computed2,
+      isEmpty: computed2,
+      firstLog: computed2,
+      latestLog: computed2
+    }, { name: `Stream{${name}}` });
+  }
+  subscribe(callback) {
+    this._subscribers.push(callback);
+    return this.unsubscribe.bind(this, callback);
+  }
+  unsubscribe(callback) {
+    const index = this._subscribers.indexOf(callback);
+    if (index !== -1) {
+      this._subscribers.splice(index, 1);
+    } else
+      WARN3(`unsubscribe called for non-existent`, callback);
+  }
+  notifySubscribers(event) {
+    DEBUG3(`[stream: ${this.name}] notifying`, this._subscribers.length, "subscribers of", { ...event, subs: this._subscribers });
+    for (const subscriber of this._subscribers) {
+      subscriber(event);
+    }
+  }
+  get applogs() {
+    return this._applogs;
+  }
+  map(fn) {
+    if (!this.applogs.map)
+      ERROR3(`applogs arr?!`, this.applogs);
+    return this.applogs.map(fn);
+  }
+  get firstLog() {
+    return this.applogs[0];
+  }
+  get latestLog() {
+    return this.applogs[this.applogs.length - 1];
+  }
+  hasApplog(applog, byRef) {
+    if (byRef) {
+      return this.applogs.includes(applog);
+    } else {
+      const keySet = Object.keys(applog);
+      return !!this.applogs.find((log) => {
+        if (!arraysContainSameElements(keySet, Object.keys(log))) {
+          throw ERROR3(`[hasApplog] field set mismatch:`, { applog, log });
+        }
+        return areApplogsEqual(log, applog);
+      });
+    }
+  }
+  hasApplogWithDiffTs(applog) {
+    return this.applogs.find((existing) => existing.en === applog.en && existing.at === applog.at && existing.vl === applog.vl && existing.ag === applog.ag);
+  }
+  get isEmpty() {
+    return this.size === 0;
+  }
+  get size() {
+    return this.applogs.length;
+  }
+  get untrackedSize() {
+    return untracked2(() => this.size);
+  }
+  get nameAndSizeUntracked() {
+    return untracked2(() => `${this.name} (${this.size})`);
+  }
+  get prettyName() {
+    return prettifyStreamName(this.name);
+  }
+};
+
+// src/stream/mapped.ts
+import { Logger as Logger4 } from "besonders-logger/src";
+import { sortedIndexBy } from "lodash-es";
+import { action, getDependencyTree as getDependencyTree2, makeObservable as makeObservable2, observable as observable2, toJS, untracked as untracked3 } from "mobx";
+var { WARN: WARN4, LOG: LOG4, DEBUG: DEBUG4, VERBOSE: VERBOSE4, ERROR: ERROR4 } = Logger4.setup(Logger4.INFO);
+var MappedApplogStream = class extends ApplogStream {
+  constructor(parents, filters, _initialLogs, _eventMapper, name) {
+    super(
+      parents,
+      filters,
+      observable2.array([..._initialLogs], { deep: false, name: `${name}.array` }),
+      // ? not sure if array clone is totally necessary - but I also don't want to risk weird bugs
+      name
+    );
+    this._initialLogs = _initialLogs;
+    this._eventMapper = _eventMapper;
+    this.name = name;
+    __publicField(this, "_parentSubscriptions", /* @__PURE__ */ new Map());
+    makeObservable2(this, {
+      // @ts-expect-error bc it's private
+      onParentUpdate: action
+    });
+    this.subscribeToParent();
+  }
+  get readOnly() {
+    if (this.parents.length !== 1)
+      return true;
+    return this.parents[0].readOnly;
+  }
+  subscribeToParent() {
+    if (!this.parents.length) {
+      WARN4(`MappedStream has no parents`, this);
+    }
+    if (this._parentSubscriptions.size) {
+      throw ERROR4(`parents subs must not be called twice`, this);
+    }
+    VERBOSE4(`[MappedStream: ${this.name}] subscribing to parents:`, this.parents.map((p) => p.name));
+    this.parents.forEach((p) => {
+      const sub = this.onParentUpdate.bind(this, p);
+      p.subscribe(sub);
+      this._parentSubscriptions.set(p, sub);
+    });
+  }
+  /**
+   * // HACK to trigger remap on pattern change in rollingFilter
+   * should not be used lightly
+   */
+  triggerRemap() {
+    VERBOSE4(`MappedStream{${this.nameAndSizeUntracked}} triggerRemap`);
+    this.parents.forEach((p) => {
+      this.onParentUpdate(p, { init: untracked3(() => toJS(p.applogs)) });
+    });
+  }
+  onParentUpdate(stream, event) {
+    VERBOSE4(`MappedStream{${this.nameAndSizeUntracked}} parentUpdate`, event);
+    const mapResult = this._eventMapper(event, stream);
+    VERBOSE4(`MappedStream{${this.nameAndSizeUntracked}} parentUpdate => mapped`, mapResult);
+    if (isInitEvent(mapResult)) {
+      ;
+      this._applogs.replace([...mapResult.init]);
+    } else {
+      for (const log of mapResult.added) {
+        this._applogs.splice(sortedIndexBy(this._applogs, log, "ts"), 0, log);
+      }
+      if (mapResult.removed) {
+        for (const toRemove of mapResult.removed) {
+          if (!this._applogs.remove(toRemove)) {
+            if (!isInitEvent(event) && event.removed?.includes(toRemove)) {
+              DEBUG4(`Ignoring remove event for non-existent because it was part of parent event's removed`, toRemove, event);
+            } else {
+              throw ERROR4(`MappedStream{${this.name}} toRemove contained log that doesn't exist`, toRemove, {
+                stream: this,
+                event,
+                mapResult
+              });
+            }
+          }
+        }
+      }
+    }
+    VERBOSE4(`MappedStream{${this.nameAndSizeUntracked}} parentUpdate => deps?`, getDependencyTree2(this._applogs));
+    this.notifySubscribers(mapResult);
+  }
+};
+
+// src/stream/filters.ts
+import { Logger as Logger5 } from "besonders-logger/src";
+import { action as action2, observable as observable3, onBecomeUnobserved as onBecomeUnobserved2, reaction, toJS as toJS2, untracked as untracked4 } from "mobx";
+import stringify3 from "safe-stable-stringify";
+var { WARN: WARN5, LOG: LOG5, DEBUG: DEBUG5, VERBOSE: VERBOSE5, ERROR: ERROR5 } = Logger5.setup(Logger5.INFO);
+var rollingFilter = computedFnDeepCompare(function rollingFilter2(stream, pattern, opts = {}) {
+  let untrackedPattern = getUntrackedPattern(pattern);
+  let filter = makeFilter(untrackedPattern);
+  const observableArr = observable3.array(
+    untracked4(() => filter(stream.applogs)),
+    { deep: false, name: `${stream.name} | ${opts.name || `rollingFilter.array{${stringify3(untrackedPattern)}}`}` }
+  );
+  const filterAdded = (event) => {
+    let mappedEvent;
+    if (isInitEvent(event)) {
+      mappedEvent = { init: filter(event.init) };
+    } else {
+      mappedEvent = {
+        added: filter(event.added),
+        removed: event.removed
+        // whatever's removed shall be removed
+      };
+    }
+    VERBOSE5(
+      `rollingFilter{${stream.nameAndSizeUntracked} | ${opts.name ? ` '${opts.name}'}` : ""} parentUpdate`,
+      untrackedPattern,
+      event,
+      "=>",
+      mappedEvent
+    );
+    return mappedEvent;
+  };
+  const mappedStream = new MappedApplogStream(
+    stream,
+    [...stream.filters, ...opts.extraFilterName ? [opts.extraFilterName] : []],
+    observableArr,
+    filterAdded,
+    `${stream.name} | ${opts.name || `rollingFilter{${stringify3(untrackedPattern)}}`}`
+  );
+  const cancelPatternReaction = reaction(() => JSON.parse(JSON.stringify(pattern)), (pat) => {
+    VERBOSE5(
+      `rollingFilter<${stream.nameAndSizeUntracked}>${opts.name ? ` '${opts.name}'` : ""} patternUpdate`,
+      untrackedPattern,
+      "=>",
+      pat
+      /* , getDependencyTree(pat) */
+    );
+    untrackedPattern = pat;
+    filter = makeFilter(untrackedPattern);
+    mappedStream.triggerRemap();
+  });
+  const unobserveUnobserving = onBecomeUnobserved2(observableArr, () => {
+    VERBOSE5(`rollingFilter<${stream.nameAndSizeUntracked}>${opts.name ? ` '${opts.name}'` : ""} unobserve`, untrackedPattern);
+    cancelPatternReaction();
+    unobserveUnobserving();
+  });
+  return mappedStream;
+}, { equals: applogStreamComparer, argsDebugName: (_, pattern, opts) => `${stringify3(pattern)}, ${stringify3(opts)}` });
+var rollingMapper = computedFnDeepCompare(function rollingMapper2(stream, eventMapper, opts = {}) {
+  const initialMapResult = untracked4(() => eventMapper.call(null, { init: stream.applogs }, stream));
+  if (!isInitEvent(initialMapResult)) {
+    throw ERROR5("Initial run must return init event");
+  }
+  const initialLogs = initialMapResult.init;
+  return new MappedApplogStream(
+    stream,
+    [...stream.filters, ...opts.extraFilterName ? [opts.extraFilterName] : []],
+    initialLogs,
+    eventMapper,
+    `${stream.name} | ${opts.name || `rollingMapper`}`
+  );
+}, { equals: applogStreamComparer, argsDebugName: (_, pattern, opts) => `${stringify3(pattern)}, ${stringify3(opts)}` });
+var rollingAcc = computedFnDeepCompare(function rollingAcc2(stream, acc, eventMapper) {
+  eventMapper = action2(eventMapper);
+  eventMapper({ init: stream.applogs }, acc);
+  stream.subscribe((event) => {
+    eventMapper(event, acc);
+  });
+  return acc;
+}, { argsDebugName: (stream) => `rollingAcc{${stream.nameAndSizeUntracked}}` });
+var getUntrackedPattern = function getUntrackedPattern2(pattern) {
+  const untrackedPattern = untracked4(() => Object.fromEntries(Object.entries(toJS2(pattern)).map(([k, v]) => [toJS2(k), toJS2(v)])));
+  if (!Object.entries(untrackedPattern).length) {
+    throw new Error(`Pattern is empty`);
+  }
+  return untrackedPattern;
+};
+function makeFilter(pattern) {
+  return (logs) => logs.filter((applog) => {
+    for (const [field, patternValue] of Object.entries(pattern)) {
+      const applogValue = applog[field.startsWith("!") ? field.slice(1) : field];
+      const patternValT = patternValue;
+      if (!matchPartStatic(field, patternValT, applogValue)) {
+        return false;
+      }
+    }
+    return true;
+  });
+}
+var getUntrackedFilterResults = function getUntrackedFilterResults2(stream, pattern, opts = {}) {
+  const untrackedPattern = getUntrackedPattern(pattern);
+  const filter = makeFilter(untrackedPattern);
+  return untracked4(() => filter(stream.applogs));
+};
+function hasFilter(stream, filter) {
+  return stream.filters.includes(filter);
+}
+function assertRaw(stream) {
+  if (stream.filters.length) {
+    throw ERROR5(`should be unfiltered stream, but is:`, stream.filters);
+  }
+  return stream;
+}
+function assertOnlyCurrent(stream) {
+  if (!hasFilter(stream, "withoutHistory") || !hasFilter(stream, "withoutDeleted"))
+    throw ERROR5(`should be filtered stream, but is:`, stream.filters);
+  return stream;
+}
+
+export {
+  isoDateStrCompare,
+  sortApplogsByTs,
+  isTsBefore,
+  uniqueEnFromAppLogs,
+  areApplogsEqual,
+  removeDuplicateAppLogs,
+  getHashID,
+  isVariable,
+  variableNameWithoutQuestionmark,
+  isStaticPattern,
+  resolveOrRemoveVariables,
+  matchPartStatic,
+  matchPart,
+  matchPattern,
+  actualize,
+  arrStats,
+  tsNearlySame,
+  cyrb53hash,
+  arraysContainSameElements,
+  dateNowIso,
+  createDebugName,
+  createDebugNameObj,
+  computedStructuralComparer,
+  applogStreamComparer,
+  queryNodesComparer,
+  observableArrayMap,
+  computedFnDeepCompare,
+  prettifyStreamName,
+  isInitEvent,
+  ApplogStream,
+  MappedApplogStream,
+  rollingFilter,
+  rollingMapper,
+  rollingAcc,
+  getUntrackedPattern,
+  makeFilter,
+  getUntrackedFilterResults,
+  hasFilter,
+  assertRaw,
+  assertOnlyCurrent
+};
+//# sourceMappingURL=chunk-TYTIT5QO.js.map