@converse/skeletor 4.0.0 → 4.0.1

package/dist/skeletor.js

@@ -1674,19 +1674,6 @@
       throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
   }
 
-  function __classPrivateFieldGet(receiver, state, kind, f) {
-      if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
-      if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
-      return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
-  }
-
-  function __classPrivateFieldSet(receiver, state, value, kind, f) {
-      if (kind === "m") throw new TypeError("Private method is not writable");
-      if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
-      if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
-      return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
-  }
-
   typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
       var e = new Error(message);
       return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
@@ -11014,7 +11001,47 @@
     return object == null ? {} : basePick(object, paths);
   });
 
-  var _Model_instances, _Model_computedCache, _Model_computedDefs, _Model_state, _Model_hydrate, _Model_doAutoSave, _Model_updateComputed, _Model_initComputed;
+  const INTERNALS = new WeakMap();
+  function internals(model) {
+      let priv = INTERNALS.get(model);
+      if (!priv) {
+          priv = { state: 'constructing' };
+          INTERNALS.set(model, priv);
+      }
+      return priv;
+  }
+  /** Load the model from storage, marking it ready whether or not the read succeeds. */
+  async function hydrate$1(model, priv) {
+      ensureUnloadListener(PersistentStorage);
+      try {
+          await model.fetch({ fromStorage: true, promise: true });
+      }
+      finally {
+          priv.state = 'ready';
+      }
+  }
+  /** Evaluate the model's declared computed properties once, seeding the cache. */
+  function initComputed(model, priv) {
+      const defs = result(model, 'computed');
+      if (!defs || isEmpty(defs))
+          return;
+      priv.computedDefs = defs;
+      priv.computedCache = {};
+      for (const [key, def] of Object.entries(defs)) {
+          priv.computedCache[key] = def.fn(model);
+      }
+  }
+  /** Recompute one computed property, firing `change:key` when its value changed. */
+  function updateComputed(model, priv, key, def, silent, options) {
+      const newVal = def.fn(model);
+      if (!isEqual(priv.computedCache[key], newVal)) {
+          priv.computedCache[key] = newVal;
+          if (!silent) {
+              model.changed[key] = newVal;
+              model.trigger('change:' + key, model, newVal, options);
+          }
+      }
+  }
   /**
    * @public
    * **Models** are the basic data object in the framework --
@@ -11029,15 +11056,12 @@
        */
       constructor(attributes, options) {
           super();
-          _Model_instances.add(this);
-          _Model_computedCache.set(this, void 0);
-          _Model_computedDefs.set(this, void 0);
-          _Model_state.set(this, 'constructing');
           this._changing = false;
           this._pending = false;
           this._url = '';
           this.changed = {};
           this.validationError = null;
+          const priv = internals(this);
           let attrs = attributes || {};
           options = options || {};
           this.preinitialize.apply(this, arguments);
@@ -11050,11 +11074,12 @@
           const default_attrs = result(this, 'defaults');
           attrs = defaults(Object.assign({}, default_attrs, attrs), default_attrs);
           this.set(attrs, options);
-          __classPrivateFieldGet(this, _Model_instances, "m", _Model_initComputed).call(this);
+          initComputed(this, priv);
           this.attrs = new Proxy(this.attributes, {
               get: (_target, key) => {
-                  if (typeof key !== 'symbol' && __classPrivateFieldGet(this, _Model_computedCache, "f") && key in __classPrivateFieldGet(this, _Model_computedCache, "f")) {
-                      return __classPrivateFieldGet(this, _Model_computedCache, "f")[key];
+                  const cache = priv.computedCache;
+                  if (typeof key !== 'symbol' && cache && key in cache) {
+                      return cache[key];
                   }
                   return this.attributes[key];
               },
@@ -11072,16 +11097,16 @@
           // otherwise it's already ready and resolves immediately.
           if (this.autoSync) {
               if (getStorage(this) && !this.isNew()) {
-                  __classPrivateFieldSet(this, _Model_state, 'hydrating', "f");
-                  this.hydrated = __classPrivateFieldGet(this, _Model_instances, "m", _Model_hydrate).call(this);
+                  priv.state = 'hydrating';
+                  this.hydrated = hydrate$1(this, priv);
               }
               else {
-                  __classPrivateFieldSet(this, _Model_state, 'ready', "f");
+                  priv.state = 'ready';
                   this.hydrated = Promise.resolve();
               }
           }
           else {
-              __classPrivateFieldSet(this, _Model_state, 'ready', "f");
+              priv.state = 'ready';
           }
       }
       /**
@@ -11180,8 +11205,9 @@
        * Get the value of an attribute, or a computed property.
        */
       get(attr) {
-          if (__classPrivateFieldGet(this, _Model_computedCache, "f") && attr in __classPrivateFieldGet(this, _Model_computedCache, "f")) {
-              return __classPrivateFieldGet(this, _Model_computedCache, "f")[attr];
+          const cache = internals(this).computedCache;
+          if (cache && attr in cache) {
+              return cache[attr];
           }
           return this.attributes[attr];
       }
@@ -11257,9 +11283,10 @@
               attrs[key] = val;
           }
           options = options || {};
+          const priv = internals(this);
           // Guard must come after arg normalization: when called as set(obj, opts),
           // fromStorage lives in `val` (second arg), not `options` (third arg).
-          if (this.autoSync && __classPrivateFieldGet(this, _Model_state, "f") === 'hydrating' && !options.fromStorage) {
+          if (this.autoSync && priv.state === 'hydrating' && !options.fromStorage) {
               throw new Error(`Skeletor: set() called on an autoSync model before hydration resolved. Await model.hydrated first.`);
           }
           // Run validation.
@@ -11303,10 +11330,10 @@
               }
           }
           // Recalculate computed properties whose deps changed.
-          if (changes.length && __classPrivateFieldGet(this, _Model_computedDefs, "f")) {
-              for (const [key, def] of Object.entries(__classPrivateFieldGet(this, _Model_computedDefs, "f"))) {
+          if (changes.length && priv.computedDefs) {
+              for (const [key, def] of Object.entries(priv.computedDefs)) {
                   if (def.deps.some((dep) => changes.includes(dep))) {
-                      __classPrivateFieldGet(this, _Model_instances, "m", _Model_updateComputed).call(this, key, def, silent, options);
+                      updateComputed(this, priv, key, def, silent, options);
                   }
               }
           }
@@ -11326,13 +11353,13 @@
           // Auto-save: schedule a debounced write when autoSync is on and there
           // were actual changes that originated from application code (not a
           // storage read or an explicit noAutoSave call).
-          if (__classPrivateFieldGet(this, _Model_state, "f") === 'ready' &&
+          if (priv.state === 'ready' &&
               this.autoSync &&
               getStorage(this) &&
               changes.length &&
               !options.fromStorage &&
               !options.noAutoSave) {
-              scheduleAutoSave(this, () => __classPrivateFieldGet(this, _Model_instances, "m", _Model_doAutoSave).call(this), this.autoSyncDelay);
+              scheduleAutoSave(this, () => this.save(null, { noAutoSave: true }), this.autoSyncDelay);
           }
           return this;
       }
@@ -11613,37 +11640,8 @@
           return false;
       }
   }
-  _Model_computedCache = new WeakMap(), _Model_computedDefs = new WeakMap(), _Model_state = new WeakMap(), _Model_instances = new WeakSet(), _Model_hydrate = async function _Model_hydrate() {
-      ensureUnloadListener(PersistentStorage);
-      try {
-          await this.fetch({ fromStorage: true, promise: true });
-      }
-      finally {
-          __classPrivateFieldSet(this, _Model_state, 'ready', "f");
-      }
-  }, _Model_doAutoSave = function _Model_doAutoSave() {
-      return this.save(null, { noAutoSave: true });
-  }, _Model_updateComputed = function _Model_updateComputed(key, def, silent, options) {
-      const newVal = def.fn(this);
-      if (!isEqual(__classPrivateFieldGet(this, _Model_computedCache, "f")[key], newVal)) {
-          __classPrivateFieldGet(this, _Model_computedCache, "f")[key] = newVal;
-          if (!silent) {
-              this.changed[key] = newVal;
-              this.trigger('change:' + key, this, newVal, options);
-          }
-      }
-  }, _Model_initComputed = function _Model_initComputed() {
-      const defs = result(this, 'computed');
-      if (!defs || isEmpty(defs))
-          return;
-      __classPrivateFieldSet(this, _Model_computedDefs, defs, "f");
-      __classPrivateFieldSet(this, _Model_computedCache, {}, "f");
-      for (const [key, def] of Object.entries(defs)) {
-          __classPrivateFieldGet(this, _Model_computedCache, "f")[key] = def.fn(this);
-      }
-  };
 
-  var _Collection_instances, _Collection_hydrate, _a;
+  var _a;
   // Default options for `Collection#set`.
   const setOptions = { add: true, remove: true, merge: true };
   const addOptions = { add: true, remove: false };
@@ -11664,6 +11662,18 @@
       const matcher = matches(pred);
       return (m) => matcher(m.attributes);
   }
+  /**
+   * Load the collection's members from storage. A module-level function rather
+   * than a `#private` method so the published declarations carry no private
+   * members, which TypeScript 6 rejects in anonymously extended classes (TS4094).
+   */
+  async function hydrate(collection) {
+      ensureUnloadListener(PersistentStorage);
+      // An empty store is a normal first-run state: findAll() returns [] and a
+      // missing model record resolves to null, so hydration resolves rather
+      // than rejecting.
+      await collection.fetch({ fromStorage: true, promise: true });
+  }
   /**
    * @public
    * If models tend to represent a single row of data, a Collection is
@@ -11681,7 +11691,6 @@
        */
       constructor(models, options) {
           super();
-          _Collection_instances.add(this);
           this._url = '';
           /**
            * @public
@@ -11703,7 +11712,7 @@
           // uniformly `await collection.hydrated`; it resolves immediately when
           // there's no storage to hydrate from.
           if (this.autoSync) {
-              this.hydrated = getStorage(this) ? __classPrivateFieldGet(this, _Collection_instances, "m", _Collection_hydrate).call(this) : Promise.resolve();
+              this.hydrated = getStorage(this) ? hydrate(this) : Promise.resolve();
           }
       }
       get comparator() {
@@ -12386,13 +12395,7 @@
           this.trigger.apply(this, arguments);
       }
   }
-  _Collection_instances = new WeakSet(), _Collection_hydrate = async function _Collection_hydrate() {
-      ensureUnloadListener(PersistentStorage);
-      // An empty store is a normal first-run state: findAll() returns [] and a
-      // missing model record resolves to null, so hydration resolves rather
-      // than rejecting.
-      await this.fetch({ fromStorage: true, promise: true });
-  }, _a = Symbol.iterator;
+  _a = Symbol.iterator;
   // This "enum" defines the three possible kinds of values which can be emitted
   // by a CollectionIterator that correspond to the values(), keys() and entries()
   // methods on Collection, respectively.