@madronejs/core 1.0.16 → 1.0.18

package/README.md

@@ -1,92 +1,4 @@
 # 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
-```
+Please follow the docs at https://madronejs.github.io/docs/core/

package/dist/core.js

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