@madronejs/core 1.0.16

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021 madronejs
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,92 @@
+# madrone (mah droh nuh)
+🌳
+
+Madrone is an easy way to make reactive objects in JS.
+
+## Installation
+```javascript
+// npm
+npm install madronejs --save
+
+// pnpm
+pnpm install madronejs
+
+// yarn
+yarn add madronejs
+```
+
+## Quick start
+
+### Reactivity
+
+```javascript
+import Madrone, { MadroneState } from '@madronejs/core'
+
+// add reactivity integration
+// MadroneVue2, and MadroneVue3 are also available
+Madrone.use(MadroneState);
+
+const PersonFactory = ({ name } = {}) => Madrone.auto({
+  // When using reactivity integration, getters become cached computeds
+  // that only get recomputed when a reactive data property changes.
+  // In this case, `name` is a reactive data property.
+  name,
+  get greeting() {
+    return `Hi, I'm ${this.name}`
+  },
+});
+
+const person = PersonFactory({ name: 'Greg' });
+const newVals = [];
+const oldVals = [];
+
+// Watch a reactive property when it changes. Any reactive property accessed
+// in the first argument will cause the watcher callback to trigger. Anything
+// returned from the first argument will define what the newVal/oldVal is.
+Madrone.watch(() => person.greeting, (newVal, oldVal) => {
+  newVals.push(newVal);
+  oldVals.push(oldVal);
+});
+
+person.name; // Greg
+person.greeting; // Hi, I'm Greg
+
+person.name = 'Not Greg';
+person.greeting; // Hi, I'm Not Greg
+
+// watcher is async...
+console.log('New Vals:', newVals); // ["Hi, I'm Not Greg"]
+console.log('Old Vals:', oldVals); // ["Hi, I'm  Greg"]
+```
+
+### Decorator support
+
+```javascript
+
+import Madrone, { MadroneState, computed, reactive } from '@madronejs/core'
+
+Madrone.use(MadroneState);
+
+class Person {
+  @reactive name: string;
+  @reactive age;
+
+  @computed get greeting() {
+    return `Hi, I'm ${this.name}`;
+  }
+
+  constructor(options) {
+    this.name = options?.name;
+    this.age = options?.age;
+  }
+}
+
+const person = new Person({ name: 'Greg' });
+
+
+person.name; // Greg
+person.greeting; // Hi, I'm Greg
+
+person.name = 'Not Greg';
+person.greeting; // Hi, I'm Not Greg
+```

package/dist/core.mjs

@@ -0,0 +1,617 @@
+const U = /* @__PURE__ */ new Set();
+let ee;
+function be() {
+  return [...U];
+}
+function we() {
+  return be().at(-1);
+}
+function te() {
+  ee = we();
+}
+function ne(e) {
+  e && (U.add(e), te());
+}
+function Oe(e) {
+  U.delete(e), te();
+}
+function P() {
+  return ee;
+}
+const re = /* @__PURE__ */ new WeakMap();
+function ce(e) {
+  var t;
+  return (((t = P()) == null ? void 0 : t.toRaw) ?? (() => e))(e);
+}
+function S(e) {
+  re.set(ce(e), Date.now());
+}
+function Ce(e) {
+  return re.get(ce(e));
+}
+function _(e, n, t) {
+  var a;
+  const r = P();
+  if (!r)
+    throw new Error("No integration specified");
+  typeof t.get == "function" && (r != null && r.defineComputed) ? r.defineComputed(e, n, {
+    get: t.get.bind(e),
+    set: (a = t.set) == null ? void 0 : a.bind(e),
+    enumerable: t.enumerable,
+    configurable: t.configurable,
+    cache: t.cache ?? !0
+  }) : !t.get && (r != null && r.defineProperty) && r.defineProperty(e, n, {
+    value: t.value,
+    enumerable: t.enumerable,
+    configurable: t.configurable,
+    deep: t.deep
+  });
+}
+function Re(e, n) {
+  var a, f;
+  const t = Object.getOwnPropertyDescriptors(e), r = (u, d) => {
+    var l;
+    return (l = n == null ? void 0 : n[u]) == null ? void 0 : l[d];
+  };
+  for (const [u, d] of Object.entries(t))
+    _(e, u, {
+      get: (a = d.get) == null ? void 0 : a.bind(e),
+      set: (f = d.set) == null ? void 0 : f.bind(e),
+      value: r(u, "value") ?? d.value,
+      enumerable: r(u, "enumerable") ?? d.enumerable,
+      configurable: r(u, "configurable") ?? d.configurable,
+      cache: r(u, "cache") ?? !0,
+      deep: r(u, "deep") ?? !0
+    });
+  return e;
+}
+function ye(e, n, t) {
+  var a;
+  const r = P();
+  return (a = r == null ? void 0 : r.watch) == null ? void 0 : a.call(r, e, n, t);
+}
+const Y = Symbol("keys"), D = Symbol("computed"), K = /* @__PURE__ */ new WeakMap(), X = /* @__PURE__ */ new WeakMap(), C = /* @__PURE__ */ new WeakMap(), R = /* @__PURE__ */ new WeakMap();
+let B = [], N = null;
+const Se = (e) => K.has(e), ae = (e) => X.has(e), k = (e) => K.get(e), Pe = (e) => X.get(e), Ie = (e) => ae(e) ? Pe(e) : e, Te = (e, n) => {
+  K.set(e, n), X.set(n, e);
+}, _e = () => {
+  N === null && (N = setTimeout(() => {
+    const e = B;
+    for (B = []; e.length > 0; )
+      e.shift()();
+    N = null;
+  }));
+}, Ee = (e) => {
+  B.push(e), _e();
+}, ue = (e, n) => {
+  const t = R.get(e), r = t == null ? void 0 : t.get(n);
+  if (r) {
+    for (const a of r)
+      C.get(a).delete(e);
+    r.clear(), t.delete(n), t.size === 0 && R.delete(e);
+  }
+}, se = (e, n) => {
+  const t = Me();
+  if (!t)
+    return;
+  R.has(t) || R.set(t, /* @__PURE__ */ new Map()), C.has(e) || C.set(e, /* @__PURE__ */ new Map());
+  const r = C.get(e), a = R.get(t);
+  r.has(n) || r.set(n, /* @__PURE__ */ new Set()), a.has(n) || a.set(n, /* @__PURE__ */ new Set());
+  const f = r.get(n), u = a.get(n);
+  f.add(t), u.add(e);
+}, ie = (e, n) => {
+  const t = k(e);
+  t && se(t, n);
+}, fe = (e, n) => {
+  const t = C.get(e);
+  if (t != null && t.get(n))
+    for (const r of t.get(n))
+      r.setDirty(), ue(r, n);
+}, y = (e, n) => {
+  fe(k(e), n);
+}, W = [];
+function Me() {
+  return W.at(-1);
+}
+class x {
+  static create(...n) {
+    return new x(...n);
+  }
+  constructor(n) {
+    this.name = n.name, this.get = n.get, this.set = n.set, this.cache = !!(n.cache ?? !0), this.alive = !0, this.dirty = !0, this.cachedVal = void 0, this.hooks = {
+      onGet: n.onGet,
+      onSet: n.onSet,
+      onChange: n.onChange,
+      onImmediateChange: n.onImmediateChange
+    };
+  }
+  callHook(n) {
+    typeof this.hooks[n] == "function" && this.hooks[n](this);
+  }
+  /**
+   * Stop observing and dispose of the observer
+   * @returns {void}
+   */
+  dispose() {
+    ue(this, D), this.alive = !1, this.dirty = !1, this.cachedVal = void 0, this.prev = void 0;
+  }
+  wrap(n) {
+    W.push(this);
+    const t = n();
+    return W.pop(), t;
+  }
+  setHook(n, t) {
+    this.hooks[n] = t;
+  }
+  setDirty() {
+    this.alive && !this.dirty && (this.dirty = !0, fe(this, D), this.prev = this.cachedVal, this.callHook(
+      "onImmediateChange"
+      /* onImmediateChange */
+    ), Ee(() => this.notifyChange()));
+  }
+  notifyChange() {
+    this.callHook(
+      "onChange"
+      /* onChange */
+    ), this.prev = void 0;
+  }
+  run() {
+    if (!this.alive)
+      return;
+    const n = this.wrap(() => ((this.cache && this.dirty || !this.cache) && (this.cachedVal = this.get(), this.dirty = !1), this.cachedVal));
+    return se(this, D), this.callHook(
+      "onGet"
+      /* onGet */
+    ), n;
+  }
+  /** The value of the observer */
+  get value() {
+    return this.run();
+  }
+  set value(n) {
+    if (typeof this.set == "function")
+      this.set(n), this.callHook(
+        "onSet"
+        /* onSet */
+      );
+    else
+      throw new TypeError(`No setter defined for "${this.name}"`);
+  }
+}
+function de(...e) {
+  return x.create(...e);
+}
+function Ae(e) {
+  return de(e);
+}
+const E = (e) => {
+  const {
+    name: n,
+    target: t,
+    key: r,
+    receiver: a,
+    value: f,
+    keysChanged: u = !1,
+    valueChanged: d = !1
+  } = e;
+  return {
+    name: n,
+    target: t,
+    key: r,
+    receiver: a,
+    value: f,
+    keysChanged: u,
+    valueChanged: d
+  };
+}, Ge = (e, n, t, r) => {
+  var a;
+  ie(n, t), (a = e == null ? void 0 : e.onGet) == null || a.call(
+    e,
+    E({
+      name: e.name,
+      target: n,
+      key: t,
+      receiver: r
+    })
+  );
+}, He = (e, n, t, r) => {
+  var l;
+  const a = n[t], f = Array.isArray(n);
+  let u = !1, d = !1;
+  t in n || (y(n, Y), d = !0, f && y(n, "length")), (a !== r || f) && (y(n, t), u = !0), (d || u) && ((l = e == null ? void 0 : e.onSet) == null || l.call(
+    e,
+    E({
+      name: e.name,
+      target: n,
+      key: t,
+      value: r,
+      keysChanged: d,
+      valueChanged: u
+    })
+  ));
+}, De = (e, n, t) => {
+  var r;
+  y(n, t), y(n, Y), (r = e == null ? void 0 : e.onDelete) == null || r.call(
+    e,
+    E({
+      name: e.name,
+      target: n,
+      key: t,
+      keysChanged: !0
+    })
+  );
+}, J = (e, n, t) => {
+  var r;
+  ie(n, Y), (r = e == null ? void 0 : e.onHas) == null || r.call(
+    e,
+    E({
+      name: e.name,
+      target: n,
+      key: t
+    })
+  );
+};
+function oe(e) {
+  const n = e.needsProxy || (() => !0);
+  return {
+    get: (t, r, a) => {
+      var u;
+      Ge(e, t, r, a);
+      const f = Reflect.get(t, r, a);
+      return n({ target: t, key: r, value: f }) && (e != null && e.deep) && ((u = Object.getOwnPropertyDescriptor(t, r)) != null && u.configurable) ? w(f, e) : f;
+    },
+    set: (t, r, a) => (He(e, t, r, a), Reflect.set(t, r, a)),
+    deleteProperty: (...t) => (De(e, ...t), Reflect.deleteProperty(...t)),
+    has: (t, r) => (J(e, t), Reflect.has(t, r)),
+    ownKeys: (t) => (J(e, t), Reflect.ownKeys(t)),
+    getPrototypeOf: (t) => Object.getPrototypeOf(t)
+  };
+}
+const Ne = (e) => ({
+  ...oe(e)
+}), Ve = (e) => ({
+  ...oe(e)
+}), I = Object.freeze({
+  object: Ne,
+  array: Ve
+  // set: setHandler,
+  // map: mapHandler,
+  // weakset: weaksetHandler,
+  // weakmap: weakmapHandler,
+});
+function w(e, n) {
+  if (Se(e))
+    return k(e);
+  if (ae(e))
+    return e;
+  const t = n || {}, r = { ...t, deep: (t == null ? void 0 : t.deep) ?? !0 }, a = w.getStringType(e);
+  if (!w.hasHandler(a))
+    return e;
+  const f = new Proxy(e, w.typeHandler(a, r));
+  return Te(e, f), f;
+}
+w.getStringType = (e) => Object.prototype.toString.call(e).slice(8, -1).toLowerCase();
+w.hasHandler = (e) => !!I[e];
+w.typeHandler = (e, n) => {
+  var t;
+  return (t = I[e]) == null ? void 0 : t.call(I, n);
+};
+function z(e, n, t) {
+  const r = de({
+    get: e,
+    onChange: ({ value: f, prev: u }) => n(f, u)
+  }), a = r.run();
+  return t != null && t.immediate && n(a), () => r.dispose();
+}
+function M(e, n, t) {
+  var f, u, d, l;
+  let r, a;
+  if (n.cache) {
+    const m = Ae({
+      ...n,
+      get: n.get,
+      name: e,
+      onImmediateChange: (f = t == null ? void 0 : t.computed) == null ? void 0 : f.onImmediateChange,
+      onChange: (u = t == null ? void 0 : t.computed) == null ? void 0 : u.onChange,
+      onGet: (d = t == null ? void 0 : t.computed) == null ? void 0 : d.onGet,
+      onSet: (l = t == null ? void 0 : t.computed) == null ? void 0 : l.onSet
+    });
+    r = function() {
+      return S(this), m.value;
+    }, a = function(g) {
+      m.value = g;
+    };
+  } else
+    r = function() {
+      return S(this), n.get.call(this);
+    }, a = function(...h) {
+      n.set.call(this, ...h);
+    };
+  return {
+    enumerable: n.enumerable,
+    configurable: n.configurable,
+    get: r,
+    set: a
+  };
+}
+function A(e, n, t) {
+  var f, u, d, l, m, h;
+  const r = { value: n.value }, a = w(r, {
+    name: e,
+    onGet: (f = t == null ? void 0 : t.reactive) == null ? void 0 : f.onGet,
+    onHas: (u = t == null ? void 0 : t.reactive) == null ? void 0 : u.onHas,
+    onSet: (d = t == null ? void 0 : t.reactive) == null ? void 0 : d.onSet,
+    onDelete: (l = t == null ? void 0 : t.reactive) == null ? void 0 : l.onDelete,
+    needsProxy: (m = t == null ? void 0 : t.reactive) == null ? void 0 : m.needsProxy,
+    deep: n.deep ?? ((h = t == null ? void 0 : t.reactive) == null ? void 0 : h.deep)
+  });
+  return {
+    configurable: n.configurable,
+    enumerable: n.enumerable,
+    get: function() {
+      S(this);
+      const { value: v } = a;
+      return Array.isArray(v) && Reflect.get(v, "length"), v;
+    },
+    set: function(v) {
+      a.value = v;
+    }
+  };
+}
+function F(e, n, t, r) {
+  Object.defineProperty(e, n, M(n, t, r));
+}
+function p(e, n, t, r) {
+  Object.defineProperty(e, n, A(n, t, r));
+}
+const q = {
+  toRaw: Ie,
+  watch: z,
+  describeProperty: A,
+  defineProperty: p,
+  describeComputed: M,
+  defineComputed: F
+}, V = /* @__PURE__ */ new Set(["__proto__", "__ob__"]), O = "value";
+function je(e) {
+  const { observable: n, set: t } = e, r = /* @__PURE__ */ new WeakMap(), a = (c, s) => {
+    let o = r.get(c);
+    o || (o = /* @__PURE__ */ new Map(), r.set(c, o));
+    let b = o.get(s);
+    return b || (b = n({ [O]: 0 }), o.set(s, b)), b;
+  }, f = t ? (c) => t(c, O, c[O] + 1) : (c) => {
+    c[O] += 1;
+  }, u = (c, s) => {
+    V.has(s) || Reflect.get(a(c, s), O);
+  }, d = (c, s) => {
+    V.has(s) || f(a(c, s));
+  }, l = (c, s) => {
+    const o = r.get(c);
+    o && d(o, s), r.delete(c);
+  }, g = {
+    computed: {
+      onGet: (c) => {
+        u(c, c.name);
+      },
+      onImmediateChange: (c) => {
+        d(c, c.name);
+      }
+    },
+    reactive: {
+      onGet: ({ target: c, key: s }) => {
+        S(c), u(c, s);
+      },
+      onHas: ({ target: c, key: s }) => {
+        u(c, s);
+      },
+      onDelete: ({ target: c, key: s }) => {
+        l(c, s);
+      },
+      onSet: ({ target: c, key: s, keysChanged: o }) => {
+        d(c, s), o && d(c);
+      },
+      needsProxy: ({ key: c }) => !V.has(c)
+    }
+  };
+  function v(c, s) {
+    return M(c, s, g);
+  }
+  function G(c, s) {
+    return A(c, s, g);
+  }
+  function H(c, s, o) {
+    return F(c, s, o, g);
+  }
+  function i(c, s, o) {
+    return p(c, s, o, g);
+  }
+  return {
+    toRaw: q.toRaw,
+    watch: z,
+    describeProperty: G,
+    defineProperty: i,
+    describeComputed: v,
+    defineComputed: H
+  };
+}
+const $ = /* @__PURE__ */ new Set(["__proto__", "__ob__"]), j = "value", $e = (e) => {
+  e[j] += 1;
+};
+function Ue({ reactive: e, toRaw: n } = {}) {
+  const t = n ?? ((i) => i), r = /* @__PURE__ */ new WeakMap(), a = (i, c) => {
+    const s = t(i);
+    let o = r.get(s);
+    o || (o = /* @__PURE__ */ new Map(), r.set(s, o));
+    let b = o.get(c);
+    return b || (b = e({ [j]: 0 }), o.set(c, b)), b;
+  }, f = (i, c) => {
+    $.has(c) || Reflect.get(a(i, c), j);
+  }, u = (i, c) => {
+    $.has(c) || $e(a(i, c));
+  }, d = (i, c) => {
+    const s = t(i), o = r.get(s);
+    o && u(o, c), r.delete(s);
+  }, h = {
+    computed: {
+      onGet: (i) => {
+        f(i, i.name);
+      },
+      onImmediateChange: (i) => {
+        u(i, i.name);
+      }
+    },
+    reactive: {
+      onGet: ({ target: i, key: c }) => {
+        S(i), f(i, c);
+      },
+      onHas: ({ target: i, key: c }) => {
+        f(i, c);
+      },
+      onDelete: ({ target: i, key: c }) => {
+        d(i, c);
+      },
+      onSet: ({ target: i, key: c, keysChanged: s }) => {
+        u(i, c), s && u(i);
+      },
+      needsProxy: ({ key: i }) => !$.has(i)
+    }
+  };
+  function g(i, c) {
+    return M(i, c, h);
+  }
+  function v(i, c) {
+    return A(i, c, h);
+  }
+  function G(i, c, s) {
+    return F(i, c, s, h);
+  }
+  function H(i, c, s) {
+    return p(i, c, s, h);
+  }
+  return {
+    toRaw: q.toRaw,
+    watch: z,
+    describeProperty: v,
+    defineProperty: H,
+    describeComputed: g,
+    defineComputed: G
+  };
+}
+function Le(...e) {
+  const n = {}, t = {};
+  for (const r of e) {
+    const a = typeof r == "function" ? r() : r;
+    Object.assign(n, Object.getOwnPropertyDescriptors(a ?? r ?? {}));
+  }
+  return Object.defineProperties(t, n), t;
+}
+function Be(e, n) {
+  Object.defineProperties(
+    e.prototype,
+    Object.getOwnPropertyDescriptors(Le(...[...n, e].map((t) => t.prototype)))
+  );
+}
+const T = /* @__PURE__ */ new WeakMap();
+function Ye(...e) {
+  return (n) => {
+    e != null && e.length && Be(n, e);
+  };
+}
+function le(e) {
+  T.has(e) || T.set(e, /* @__PURE__ */ new Set());
+}
+function he(e, n) {
+  return le(e), T.get(e).has(n);
+}
+function ge(e, n) {
+  le(e), T.get(e).add(n);
+}
+function Z(e, n, t, r) {
+  var f;
+  return P() && !he(e, n) ? (_(e, n, {
+    ...t,
+    get: t.get.bind(e),
+    set: (f = t.set) == null ? void 0 : f.bind(e),
+    enumerable: !0,
+    ...r == null ? void 0 : r.descriptors,
+    cache: !0
+  }), ge(e, n), !0) : !1;
+}
+function me(e, n, t, r) {
+  if (typeof t.get == "function") {
+    const a = {
+      ...t,
+      enumerable: !0,
+      configurable: !0
+    };
+    return a.get = function() {
+      return Z(this, n, t, r), this[n];
+    }, a.set = function(u) {
+      Z(this, n, t, r), this[n] = u;
+    }, a;
+  }
+  return t;
+}
+function We(e, n, t) {
+  return me(e, n, t);
+}
+We.configure = function(n) {
+  return (t, r, a) => me(t, r, a, { descriptors: n });
+};
+function L(e, n, t) {
+  return P() && !he(e, n) ? (ge(e, n), _(e, n, {
+    ...Object.getOwnPropertyDescriptor(e, n),
+    enumerable: !0,
+    ...t == null ? void 0 : t.descriptors
+  }), !0) : !1;
+}
+function Q(e, n, t) {
+  typeof e == "function" ? L(e, n) : Object.defineProperty(e, n, {
+    configurable: !0,
+    enumerable: !0,
+    get() {
+      if (L(this, n, t))
+        return this[n];
+    },
+    set(r) {
+      L(this, n, t) && (this[n] = r);
+    }
+  });
+}
+function ve(e, n) {
+  return Q(e, n);
+}
+ve.shallow = function(n, t) {
+  return Q(n, t, { descriptors: { deep: !1 } });
+};
+ve.configure = function(n) {
+  return (t, r) => Q(t, r, { descriptors: n });
+};
+ne(q);
+const Ke = {
+  /** Configure a global plugin */
+  use: ne,
+  /** Remove a global plugin */
+  unuse: Oe,
+  /** Create reactive objects */
+  auto: Re,
+  /** Define properties on objects */
+  define: _,
+  /** Watch reactive objects */
+  watch: ye,
+  /** Get the last time any reactive property was touched on a given object */
+  lastAccessed: Ce
+};
+export {
+  q as MadroneState,
+  je as MadroneVue2,
+  Ue as MadroneVue3,
+  Be as applyClassMixins,
+  Re as auto,
+  Ye as classMixin,
+  We as computed,
+  Ke as default,
+  Le as merge,
+  ve as reactive,
+  ce as toRaw,
+  ye as watch
+};