@constellar/core/dist/index.js

state manipulation primitives

var T = Object.defineProperty;
var U = (t, e, n) => e in t ? T(t, e, { enumerable: !0, configurable: !0, writable: !0, value: n }) : t[e] = n;
var l = (t, e, n) => U(t, typeof e != "symbol" ? e + "" : e, n);
function F(t) {
  return typeof t == "string" ? (
    // Sendable type guarantees that resulting event is valid
    { type: t }
  ) : t;
}
function me(t) {
  return (e) => t(F(e));
}
function z(t, e) {
  return [t, ...e];
}
function j(t, e) {
  return [...e, t];
}
function he(t, e, n) {
  return t < 0 && (t += n.length), t < 0 || t > n.length ? n : [...n.slice(0, t), e, ...n.slice(t)];
}
function I(t, e, n) {
  return e < 0 && (e += n.length), e < 0 || e >= n.length || Object.is(n[e], t) ? n : [...n.slice(0, e), t, ...n.slice(e + 1)];
}
function G(t, e) {
  return t < 0 && (t += e.length), t < 0 || t >= e.length ? e : [...e.slice(0, t), ...e.slice(t + 1)];
}
function J(t, e) {
  for (const n of e)
    if (Object.is(n, t)) return e;
  return e.concat(t);
}
function K(t, e) {
  let n = !1;
  const r = [];
  for (const i of e)
    Object.is(i, t) ? n = !0 : r.push(i);
  return n ? r : e;
}
function pe(t, ...e) {
  return e.reduce((n, r) => r(n), t);
}
function g(t) {
  return typeof t == "function";
}
function w(t) {
  return t === void 0;
}
function m(t) {
  return !1;
}
const N = () => {
};
function k(t, e) {
  return t(e);
}
function c(t) {
  return t;
}
function E(t, e) {
  return t === c ? e : e === c ? t : (n) => e(t(n));
}
function S(t) {
  return g(t) ? t() : t;
}
function V(t) {
  return g(t) ? (e) => t(e) : () => t;
}
function Q(t) {
  if (!t) return !0;
  for (const e of Object.keys(t))
    return !1;
  return !0;
}
function ge(t) {
  return function(e) {
    return function(...n) {
      return t(e, ...n);
    };
  };
}
function Fe(t, ...e) {
  return (...n) => t(...e, ...n);
}
function be(t, ...e) {
  return e.reduce((n, r) => (i) => r(n(i)), t);
}
function W(t, e) {
  if (t === e)
    return !0;
  if (!(t instanceof Object) || !(e instanceof Object))
    return !1;
  let n = 0, r = 0;
  for (const i in t)
    if (n += 1, !Object.is(t[i], e[i]) || !(i in e))
      return !1;
  for (const i in e)
    r += 1;
  return n === r;
}
class X {
  constructor(e) {
    l(this, "last", /* @__PURE__ */ new Map());
    this.effectsHandlers = e;
  }
  foldSubState(e) {
    return (n, r, i) => {
      var f, u;
      if (this.effectsHandlers === void 0) return r;
      r.add(i);
      for (const s of Object.entries(this.effectsHandlers)) {
        const [o, a] = s, h = (f = n.effects) == null ? void 0 : f[o];
        let d = this.last.get(i);
        d || (d = /* @__PURE__ */ new Map(), this.last.set(i, d));
        const p = d.get(o);
        W(p == null ? void 0 : p.args, h) || ((u = p == null ? void 0 : p.unmount) == null || u.call(p), d.set(o, {
          args: h,
          unmount: h === void 0 ? void 0 : a(h, e)
        }));
      }
      return r;
    };
  }
  flush(e) {
    this.last.forEach((n, r) => {
      e != null && e.has(r) || (n.forEach(({ unmount: i }) => i == null ? void 0 : i()), n.clear());
    });
  }
  update(e, n) {
    this.flush(e(this.foldSubState(n), /* @__PURE__ */ new Set()));
  }
}
function Y(t) {
  return g(t) ? (e) => t(F(e)) : (e) => {
    const n = F(e);
    t[n.type](n);
  };
}
function ve() {
  return Z();
}
function Z() {
  return function({ derive: t, init: e, states: n }) {
    const r = V(e);
    function i(f) {
      for (; ; ) {
        let u = n[f.type].always;
        if (u === void 0 || (g(u) && (u = u(f)), u === void 0)) break;
        f = u;
      }
      return f;
    }
    return function(f) {
      return {
        getFinal: (u) => {
          const s = n[u.type];
          if (!s.always && !s.wildcard && Q(s.events))
            return u;
        },
        init: () => i(F(r(f))),
        reducer: (u, s, ...o) => {
          var p;
          const a = F(u), h = n[s.type];
          let d = (p = h == null ? void 0 : h.events) == null ? void 0 : p[a.type];
          if (g(d) ? d = d(a, s, ...o) : d === void 0 && (d = h == null ? void 0 : h.wildcard, g(d) && (d = d(a, s, ...o))), d !== void 0)
            return i(F(d));
        },
        transform: (u, ...s) => {
          const o = n[u.type].derive, a = o ? q(u, o, ...s) : u;
          return t ? q(a, t, ...s) : a;
        },
        visit: (u, s, o, ...a) => s(o, u, o.type, ...a)
      };
    };
  };
}
function q(t, e, ...n) {
  const r = g(e) ? e(t, ...n) : e;
  return { ...t, ...r };
}
function $(t, e, n) {
  let r = !1;
  const i = t.reducer(n, e, () => {
    r = !0;
  });
  return !r && i === void 0;
}
function x(t, e, n) {
  const r = t.reducer(n, e, () => {
  });
  return r === void 0 ? e : t.transform(r);
}
class A {
  constructor(e, n) {
    l(this, "effects");
    l(this, "onFinal");
    l(this, "onMessage");
    l(this, "queue", []);
    l(this, "final");
    l(this, "state");
    this.machine = e, this.onMessage = n != null && n.onMessage ? Y(n.onMessage) : () => {
    }, this.onFinal = n == null ? void 0 : n.onFinal, this.state = e.transform(e.init()), this.final = e.getFinal(this.state), n != null && n.events && (this.effects = new X(n.events), this.effects.update(this.visit.bind(this), this.send.bind(this)));
  }
  onChange() {
    if (!this.effects) return;
    const e = this.queue.length === 0;
    if (this.effects.update(this.visit.bind(this), this.send.bind(this)), !!e)
      for (; ; ) {
        const n = this.queue.shift();
        if (n === void 0) break;
        this.send(n);
      }
  }
  flush() {
    var e;
    (e = this.effects) == null || e.flush();
  }
  isDisabled(e) {
    return $(this.machine, this.state, e);
  }
  next(e) {
    return x(this.machine, this.state, e);
  }
  send(e) {
    const n = this.machine.reducer(e, this.state, this.onMessage);
    n !== void 0 && (this.state = this.machine.transform(n), this.final = this.machine.getFinal(this.state), this.onChange(), this.onFinal && this.final !== void 0 && this.onFinal(this.final));
  }
  visit(e, n) {
    return this.machine.visit(n, e, this.state);
  }
}
function ye(t, e) {
  return new A(t, e);
}
function we(t, e) {
  return new Promise((n) => {
    new A(t, { events: e, onFinal: n });
  });
}
function Ce() {
  return ee();
}
function ee() {
  return function({
    events: t,
    init: e,
    transform: n
  }, r) {
    return (i) => ({
      getFinal: r ?? (() => {
      }),
      init: () => V(e)(i),
      reducer: (f, u, ...s) => {
        const o = F(f);
        if ((r == null ? void 0 : r(u)) !== void 0) return;
        let a = t[o == null ? void 0 : o.type];
        if (a !== void 0)
          return g(a) && (a = a(o, u, ...s)), a;
      },
      transform: n ?? c,
      visit: (f, u, s, ...o) => u(s, f, "", ...o)
    });
  };
}
const te = (t) => {
  let e = 0;
  return function() {
    if (e !== t.length)
      return { index: e, part: t[e++] };
  };
};
function ne() {
  return {
    foldFn: (t, e) => (e.push(t), e),
    init: () => []
  };
}
function re(t) {
  return {
    foldFn: (e, n, { close: r }) => (r(), e),
    init: t
  };
}
const ie = { close: N };
function _(t, e, n, r, i) {
  const f = r(n);
  let u = !0;
  const s = {
    close: () => {
      i(), u = !1;
    },
    index: void 0,
    whole: n
  };
  for (; u; ) {
    const o = f();
    if (o === void 0) break;
    s.index = o.index, t = e(o.part, t, s);
  }
  return t;
}
const ue = Symbol("REMOVE");
function fe(t) {
  return t === ue;
}
function y(t, e) {
  throw new Error("forbidden");
}
class b {
  constructor(e) {
    l(this, "com");
    l(this, "getter");
    l(this, "isCommand");
    l(this, "isFailure");
    l(this, "mapper");
    l(this, "refold");
    l(this, "setter");
    this.com = e.com, this.getter = e.getter, this.isCommand = e.isCommand, this.isFailure = e.isFailure, this.mapper = e.mapper, this.refold = e.refold, this.setter = e.setter;
  }
  static eq() {
    return new b({
      com: c,
      getter: c,
      isCommand: m,
      isFailure: m,
      mapper: k,
      refold: c,
      setter: c
    });
  }
  command(e, n) {
    return this.com(e, n);
  }
  fold(e, n) {
    return this.refold(e.foldFn)(n, S(e.init), ie);
  }
  modify(e, n) {
    return this.mapper(e, n);
  }
  put(e, n) {
    return this.setter ? this.setter(e, n) : this.mapper(() => e, n);
  }
  update(e) {
    return this.isCommand(e) ? (n) => this.com(e, n) : g(e) ? (n) => this.modify(e, n) : (n) => this.put(e, n);
  }
  view(e, n) {
    const r = this.getter ? this.getter(e) : this.fold(re(void 0), e);
    return this.isFailure(r) ? g(n) ? n(r) : n : r;
  }
}
function Me() {
  return function(t) {
    return t(b.eq());
  };
}
function D(t, e, n) {
  if (!(!e || !n))
    return t === m ? E(e, n) : function(r) {
      const i = e(r);
      return t(i) ? i : n(i);
    };
}
function H(t, e) {
  if (t === m) return e;
  if (e === m || t === e) return t;
  throw new Error("unexpected failure value");
}
function L(t, e) {
  return t === k ? e : (n, r) => t((i) => e(n, i), r);
}
function C(t, e) {
  return t === c && e === c ? c : t === c ? (n, r) => n(e(r)) : e === c ? (n, r) => t(n(r), r) : (n, r) => t(n(e(r)), r);
}
function se(t, e, n, r) {
  if (!t || !e || !r) return;
  const i = e === c ? (f, u) => r(f, u) : (f, u, s) => e(r(f, u), s);
  return (f, u) => {
    const s = t(u);
    return n(s) ? u : i(f, s, u);
  };
}
function oe(t, e, n) {
  if (!t || !e || !n) return;
  const r = e === c ? (i) => n(i) : (i, f) => e(n(i), f);
  return (i, f) => r(i, f);
}
function P(t) {
  return function(e) {
    return new b({
      com: (n, r) => e.mapper((i) => t.command(n, i), r),
      getter: D(e.isFailure, e.getter, t.getter),
      isCommand: t.isCommand,
      isFailure: H(e.isFailure, t.isFailure),
      mapper: L(
        e.mapper,
        t.mapper ?? ((n, r) => {
          const i = t.getter(r);
          return t.isFailure(i) ? r : t.setter(n(i));
        })
      ),
      refold: E(
        t.refold ?? ((n) => (r, i, f) => {
          const u = t.getter(r);
          return t.isFailure(u) ? i : n(u, i, f);
        }),
        e.refold
      ),
      setter: oe(e.getter, e.setter, t.setter)
    });
  };
}
function M(t) {
  return function(e) {
    return new b({
      com: (n, r) => e.mapper((i) => t.command(n, i), r),
      getter: D(e.isFailure, e.getter, t.getter),
      isCommand: t.isCommand,
      isFailure: H(e.isFailure, t.isFailure),
      mapper: L(
        e.mapper,
        t.mapper ?? ((n, r) => {
          const i = t.getter(r);
          return t.isFailure(i) ? r : t.setter(n(i), r);
        })
      ),
      refold: E(
        t.refold ?? ((n) => (r, i, f) => {
          const u = t.getter(r);
          return t.isFailure(u) ? i : n(u, i, f);
        }),
        e.refold
      ),
      setter: se(e.getter, e.setter, e.isFailure, t.setter)
    });
  };
}
function R({
  getter: t,
  mapper: e,
  setter: n
}) {
  return P({
    command: y,
    getter: t,
    isCommand: m,
    isFailure: m,
    mapper: e ?? C(n, t),
    refold: t === c ? c : (r) => (i, f, u) => r(t(i), f, u),
    setter: n
  });
}
function O({
  getter: t,
  mapper: e,
  setter: n
}) {
  return M({
    command: y,
    getter: t,
    isCommand: m,
    isFailure: m,
    mapper: e ?? C(n, t),
    refold: t === c ? c : (r) => (i, f, u) => r(t(i), f, u),
    setter: n
  });
}
function B({
  getter: t,
  mapper: e,
  setter: n
}) {
  return P({
    command: y,
    getter: t,
    isCommand: m,
    isFailure: w,
    mapper: e,
    setter: n
  });
}
function ce({
  getter: t,
  mapper: e,
  setter: n
}) {
  return M({
    command: y,
    getter: t,
    isCommand: m,
    isFailure: w,
    mapper: e,
    setter: n
  });
}
function v({
  getter: t,
  mapper: e,
  remover: n,
  setter: r
}) {
  return M({
    command: (i, f) => n(f),
    getter: t,
    isCommand: fe,
    isFailure: w,
    mapper: e,
    setter: r
  });
}
function ae({
  coll: t,
  form: e
}) {
  return M({
    command: y,
    isCommand: m,
    isFailure: w,
    mapper: (n, r) => {
      const { foldFn: i, init: f } = e(), u = S(f);
      return _(
        u,
        (s, o, a) => i(n(s), o, a),
        r,
        t,
        N
      );
    },
    refold: (n) => function(r, i, { close: f }) {
      return _(i, n, r, t, f);
    }
  });
}
function Oe(t) {
  return function(e) {
    const n = (i) => Object.is(e.update(t)(i), i), r = (i, f) => i && !n(f) ? e.update(t)(f) : f;
    return new b({
      com: c,
      getter: n,
      isCommand: m,
      isFailure: m,
      mapper: C(r, n),
      refold: (i) => (f, u, s) => i(n(f), u, s),
      setter: r
    });
  };
}
function je(t) {
  return function(e) {
    if (!(e.getter && e.setter))
      throw new Error("valueOr don't work with traversals");
    const n = (r) => {
      const i = e.getter(r);
      return e.isFailure(i) ? S(t) : i;
    };
    return new b({
      com: e.com,
      getter: n,
      isCommand: e.isCommand,
      isFailure: m,
      mapper: C(e.setter, n),
      refold: (r) => {
        const i = e.refold(r);
        return (f, u, s) => e.isFailure(e.getter(f)) ? r(n(f), u, s) : i(f, u, s);
      },
      setter: e.setter
    });
  };
}
function Ee(t) {
  return ce({
    getter: t,
    setter: y
  });
}
function Se(t) {
  return R({
    getter: t,
    setter: c
    // optics-ts setter is equivalent to: `setter: (_v, a) => a`
  });
}
function de(t) {
  return O({
    getter: c,
    setter: t
  });
}
function qe(t = Object.is) {
  return de((e, n) => t(e, n) ? n : e);
}
function _e(t, e = 0) {
  return R({
    getter: (n) => t * n + e,
    setter: (n) => (n - e) / t
  });
}
function Ie(t) {
  return O({
    getter: (e) => e[t],
    setter: (e, n) => I(e, t, n)
  });
}
function Ne(t) {
  return O({
    getter: (e) => e.includes(t),
    setter: (e, n) => e ? J(t, n) : K(t, n)
  });
}
function ke(t) {
  return B({
    getter: (e) => t(e) ? e : void 0,
    setter: c
  });
}
function Ve() {
  return B({
    getter: (t) => {
      const e = parseInt(t);
      if (!isNaN(e))
        return e;
    },
    setter: (t) => String(t)
  });
}
function Ae(t) {
  return v({
    getter: (e) => e[t],
    remover: (e) => {
      if (!(t in e)) return e;
      const n = { ...e };
      return delete n[t], n;
    },
    setter: (e, n) => Object.is(n[t], e) && t in n ? n : { ...n, [t]: e }
  });
}
function De(t) {
  return v({
    getter: (e) => e.at(t),
    remover: (e) => G(t, e),
    setter: (e, n) => I(e, t, n)
  });
}
function He(t) {
  return v({
    getter: (e) => e.find(t),
    mapper: (e, n) => {
      const r = n.findIndex(t);
      if (r < 0) return n;
      const i = e(n[r]);
      return [...n.slice(0, r), i, ...n.slice(r + 1)];
    },
    remover: (e) => {
      const n = e.findIndex(t);
      return n < 0 ? e : [...e.slice(0, n), ...e.slice(n + 1)];
    },
    setter: (e, n) => {
      const r = n.findIndex(t);
      return r < 0 ? j(e, n) : [...n.slice(0, r), e, ...n.slice(r + 1)];
    }
  });
}
function Le(t) {
  return O({
    getter: (e) => e.filter(t),
    setter: (e, n) => {
      let r = !1;
      const i = [];
      let f = 0, u = 0, s = 0;
      for (f = 0; f < n.length; f++) {
        const o = n[f];
        t(o) ? u < e.length ? (r = r || !Object.is(e[u], o), i[s] = e[u], u++, s++) : r = !0 : (i[s] = o, s++);
      }
      for (; u < e.length; u++, s++)
        r = !0, i[s] = e[u];
      return r ? i : n;
    }
    // if needed, implementing a custom mapper could improve speed
  });
}
function Pe() {
  return v({
    getter: (t) => t.length ? t.slice(1) : void 0,
    remover: (t) => t.length ? t.slice(0, 1) : t,
    setter: (t, e) => e.length ? [e[0], ...t] : e
  });
}
function Re() {
  return v({
    getter: (t) => t.at(0),
    remover: (t) => t.length ? t.slice(1) : t,
    setter: z
  });
}
function Be() {
  return v({
    getter: (t) => t.at(-1),
    remover: (t) => t.length ? t.slice(0, -1) : t,
    setter: j
  });
}
function Te() {
  return v({
    getter: (t) => t.at(0),
    remover: (t) => t.length ? t.slice(1) : t,
    setter: j
  });
}
function Ue() {
  return ae({
    coll: te,
    form: ne
  });
}
export {
  b as COptic,
  X as MachineEffects,
  ue as REMOVE,
  j as append,
  k as apply,
  De as at,
  ie as ctxNull,
  Fe as curry,
  ge as curry1,
  qe as dedupe,
  Oe as disabled,
  Ue as elems,
  Le as findMany,
  He as findOne,
  pe as flow,
  Me as focus,
  y as forbidden,
  te as fromArray,
  S as fromInit,
  F as fromSendable,
  Re as head,
  c as id,
  Ne as includes,
  he as insert,
  J as insertValue,
  $ as isDisabled,
  Q as isEmpty,
  g as isFunction,
  m as isNever,
  w as isUndefined,
  R as iso,
  O as lens,
  _e as linear,
  Z as multiStateBaseMachine,
  ve as multiStateMachine,
  x as nextState,
  N as noop,
  Ie as nth,
  ye as objectMachine,
  M as opticNonPrism,
  P as opticPrism,
  ce as optional,
  be as pipe,
  E as pipe2,
  z as prepend,
  B as prism,
  we as promiseMachine,
  Ae as prop,
  Te as queue,
  v as removable,
  G as remove,
  K as removeValue,
  I as replace,
  Se as reread,
  de as rewrite,
  W as shallowEqual,
  ee as simpleStateBaseMachine,
  Ce as simpleStateMachine,
  Be as stack,
  Ve as strToNum,
  Pe as tail,
  Ee as to,
  ne as toArray,
  re as toFirst,
  V as toInit,
  Y as toListener,
  ae as traversal,
  je as valueOr,
  ke as when,
  me as withSend
};
//# sourceMappingURL=index.js.map