quantajs/dist/index.mjs

A compact, scalable, and developer-friendly state management library designed for any JavaScript environment. It includes a reactivity system that enables efficient and flexible data handling, making complex state management easy.

var v = Object.defineProperty;
var S = (n, e, t) => e in n ? v(n, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : n[e] = t;
var h = (n, e, t) => S(n, typeof e != "symbol" ? e + "" : e, t);
class w {
  constructor() {
    h(this, "subscribers");
    this.subscribers = /* @__PURE__ */ new Set();
  }
  depend(e) {
    e && this.subscribers.add(e);
  }
  notify() {
    this.subscribers.forEach((e) => e());
  }
  remove(e) {
    this.subscribers.delete(e);
  }
  clear() {
    this.subscribers.clear();
  }
  get getSubscribers() {
    return this.subscribers;
  }
}
const y = /* @__PURE__ */ new WeakMap();
let d = null;
const l = [];
function o(n, e) {
  const t = y.get(n);
  t && t[e] && t[e].getSubscribers.forEach((s) => {
    {
      if (l.includes(s)) {
        console.error(
          `Circular dependency detected: Effect "${s}" triggered itself.`
        );
        return;
      }
      s();
    }
  });
}
function i(n, e) {
  let t = y.get(n);
  t || y.set(n, t = {}), t[e] || (t[e] = new w()), d && t[e].depend(d);
}
function g(n) {
  const e = () => {
    if (l.includes(n)) {
      console.error(
        `Circular dependency detected: Effect "${n}" triggered itself.`
      );
      return;
    }
    try {
      l.push(n), d = n, n();
    } finally {
      l.pop(), d = l[l.length - 1] || null;
    }
  };
  return e(), e;
}
const E = (n) => {
  let e, t = !0;
  const c = g(() => {
    e = n(), t = !1;
  }), s = {
    get value() {
      return t && c(), i(s, "value"), e;
    }
  };
  return s;
};
function z(n) {
  return new Proxy(n, {
    get(e, t) {
      if (t === "size")
        return i(e, "size"), e.size;
      if (t === "get") {
        const c = Reflect.get(e, t);
        return (s) => {
          const r = c.call(e, s);
          return i(e, s), r;
        };
      }
      if (t === "set" || t === "add" || t === "delete") {
        const c = Reflect.get(e, t);
        return (...s) => {
          const r = c.apply(e, s);
          if (o(e, "size"), t === "set") {
            const [f] = s;
            o(e, f);
          }
          return r;
        };
      }
      if (t === "clear") {
        const c = Reflect.get(e, t);
        return () => {
          const s = c.apply(e);
          return o(e, "size"), s;
        };
      }
      return i(e, t), Reflect.get(e, t);
    }
  });
}
function b(n) {
  return n instanceof Map || n instanceof Set ? z(n) : new Proxy(n, {
    get(e, t, c) {
      const s = Reflect.get(e, t, c);
      return t === "size" && (e instanceof Map || e instanceof Set) ? (i(e, "size"), s) : (i(e, t), typeof s == "object" && s !== null ? b(s) : s);
    },
    set(e, t, c, s) {
      const r = e[t], f = Reflect.set(e, t, c, s);
      return (r !== c || isNaN(r) && isNaN(c)) && o(e, t), f;
    },
    deleteProperty(e, t) {
      const c = t in e, s = Reflect.deleteProperty(e, t);
      return c && o(e, t), s;
    },
    has(e, t) {
      return i(e, t), Reflect.has(e, t);
    },
    ownKeys(e) {
      return i(e, "keys"), Reflect.ownKeys(e);
    },
    getOwnPropertyDescriptor(e, t) {
      return i(e, t), Reflect.getOwnPropertyDescriptor(e, t);
    }
  });
}
const M = (n) => b(n), x = (n, e) => {
  g(() => {
    const t = n();
    e(t);
  });
}, P = (n) => new Proxy(n, {
  get(e, t, c) {
    if (t in e.state)
      return Reflect.get(e.state, t);
    if (t in e.getters) {
      const s = Reflect.get(e.getters, t);
      return s && typeof s == "object" && "value" in s ? s.value : s;
    }
    return t in e.actions ? Reflect.get(e.actions, t) : Reflect.get(e, t, c);
  },
  set(e, t, c, s) {
    return t in e.state ? Reflect.set(e.state, t, c) : Reflect.set(e, t, c, s);
  }
}), R = /* @__PURE__ */ new Map(), k = (n, e) => {
  if (R.has(n))
    throw new Error(`Store with name "${n}" already exists.`);
  const t = M(e.state()), c = new w(), s = {};
  if (e.getters)
    for (const u in e.getters) {
      const a = e.getters[u];
      s[u] = E(
        () => a(t)
      );
    }
  const r = {
    state: t,
    getters: s,
    actions: {},
    subscribe: (u) => (c.depend(u), () => c.remove(u))
  }, f = P(r);
  if (e.actions)
    for (const u in e.actions) {
      const a = e.actions[u];
      r.actions[u] = a.bind(
        f
      );
    }
  return R.set(n, f), f;
};
export {
  E as computed,
  k as createStore,
  M as reactive,
  x as watch
};