@converse/skeletor 4.0.0 → 4.0.1

package/dist/skeletor.esm.js

@@ -1668,19 +1668,6 @@ function __values(o) {
     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;
@@ -11008,7 +10995,47 @@ var pick = flatRest(function(object, paths) {
   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 --
@@ -11023,15 +11050,12 @@ class Model extends EventEmitterObject {
      */
     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);
@@ -11044,11 +11068,12 @@ class Model extends EventEmitterObject {
         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];
             },
@@ -11066,16 +11091,16 @@ class Model extends EventEmitterObject {
         // 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';
         }
     }
     /**
@@ -11174,8 +11199,9 @@ class Model extends EventEmitterObject {
      * 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];
     }
@@ -11251,9 +11277,10 @@ class Model extends EventEmitterObject {
             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.
@@ -11297,10 +11324,10 @@ class Model extends EventEmitterObject {
             }
         }
         // 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);
                 }
             }
         }
@@ -11320,13 +11347,13 @@ class Model extends EventEmitterObject {
         // 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;
     }
@@ -11607,37 +11634,8 @@ class Model extends EventEmitterObject {
         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 };
@@ -11658,6 +11656,18 @@ function toModelPredicate(pred) {
     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
@@ -11675,7 +11685,6 @@ class Collection extends EventEmitterObject {
      */
     constructor(models, options) {
         super();
-        _Collection_instances.add(this);
         this._url = '';
         /**
          * @public
@@ -11697,7 +11706,7 @@ class Collection extends EventEmitterObject {
         // 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() {
@@ -12380,13 +12389,7 @@ class Collection extends EventEmitterObject {
         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.