@converse/skeletor 4.0.1 → 4.0.2

package/CHANGES.md

@@ -1,5 +1,19 @@
 # Changelog
 
+## 4.0.2 (2026-11-05)
+
+- Subclasses of `Model` and `Collection` now type-check for consumers with `strict: true` and
+  `skipLibCheck: false`. (#67)
+  - A subclass that declares `computed` still satisfies `T extends Model` (TS2344).
+  - `Collection#model` and `Collection#comparator` are no longer accessors, so subclasses can
+    override them as instance properties (`model = Contact`) as well as accessors (TS2610).
+  - `model` accepts model classes whose constructors take required or narrower attributes and
+    options (TS2416).
+  - `EventHandlersMap` no longer conflicts with its own index signature (TS2411).
+
+  `Collection` still falls back to `Model` when `model` is unset. The protected `_model` and
+  `_comparator` fields are gone; use `model` and `comparator`.
+
 ## 4.0.1 (2026-10-27)
 
 - The declarations for `Model` and `Collection` no longer contain `#private` members, so mixins

package/dist/skeletor.d.ts

@@ -309,6 +309,22 @@ declare class PersistentStorage {
     getItemName(id: string | number): string;
 }
 
+/**
+ * `model` and `comparator` are declared on an interface merged with the class
+ * rather than on the class itself, so that subclasses may override them either
+ * as instance properties (`model = Contact`) or as accessors (`get model()`).
+ * TypeScript rejects the one form overriding the other (TS2610, TS2611) only
+ * when the base member is declared on a class.
+ */
+interface Collection<T extends Model = Model> {
+    /**
+     * The model class to instantiate when raw attributes are added. Defaults to
+     * `Model` when unset. Typed loosely so that model classes whose constructors
+     * take required or narrower attributes and options fit.
+     */
+    model: new (attributes?: any, options?: any) => T;
+    comparator: Comparator<T>;
+}
 /**
  * @public
  * If models tend to represent a single row of data, a Collection is
@@ -321,20 +337,16 @@ declare class PersistentStorage {
 declare class Collection<T extends Model = Model> extends EventEmitterObject {
     [key: symbol]: () => CollectionIterator<T>;
     _storage?: PersistentStorage;
-    _comparator?: Comparator<T>;
     _url: string;
     hydrated?: Promise<void>;
     models: T[];
     protected _byId: Record<string, T>;
-    protected _model?: new (attributes?: Partial<ModelAttributes>, options?: ModelOptions) => T;
     /**
      * Create a new **Collection**, perhaps to contain a specific type of `model`.
      * If a `comparator` is specified, the Collection will maintain
      * its models in sort order, as they're added and removed.
      */
     constructor(models?: T[] | ModelAttributes[] | T | ModelAttributes, options?: CollectionOptions<T>);
-    get comparator(): Comparator<T>;
-    set comparator(c: Comparator<T>);
     /**
      * The canonical storage accessor. Set to a `PersistentStorage` instance
      * to enable local persistence for this collection.
@@ -358,12 +370,6 @@ declare class Collection<T extends Model = Model> extends EventEmitterObject {
      * record. A collection-level write would be redundant with that.
      */
     get autoSync(): boolean;
-    /**
-     * The default model for a collection is just a **Model**.
-     * This should be overridden in most cases.
-     */
-    get model(): new (attributes?: Partial<ModelAttributes>, options?: ModelOptions) => T | Model;
-    set model(model: new (attributes?: Partial<ModelAttributes>, options?: ModelOptions) => T);
     get length(): number;
     get url(): string;
     set url(url: string);
@@ -630,10 +636,7 @@ type EventListenerMap = Record<string, ListeningType>;
 /**
  * @public
  */
-interface EventHandlersMap {
-    all?: EventHandler[];
-    [name: string]: EventHandler[];
-}
+type EventHandlersMap = Record<string, EventHandler[]>;
 /**
  * @public
  */
@@ -692,7 +695,7 @@ type Comparator<T extends Model = Model> = string | boolean | ((a: T, b: T) => n
  */
 type ComputedProperty<M> = {
     deps: string[];
-    fn: (model: M) => any;
+    fn(model: M): any;
 };
 /**
  * @public
@@ -719,7 +722,7 @@ type FetchOrCreateOptions = Options & {
  * @public
  */
 type CollectionOptions<T extends Model = Model> = Options & {
-    model?: new (attributes?: Partial<ModelAttributes>, options?: ModelOptions) => T;
+    model?: new (attributes?: any, options?: any) => T;
     comparator?: Comparator<T>;
     previousModels?: Model[];
 };

package/dist/skeletor.esm.js

@@ -11677,6 +11677,7 @@ async function hydrate(collection) {
  * belonging to this particular author, and so on. Collections maintain
  * indexes of their models, both in order, and for lookup by `id`.
  */
+// eslint-disable-next-line @typescript-eslint/no-unsafe-declaration-merging -- see the interface above
 class Collection extends EventEmitterObject {
     /**
      * Create a new **Collection**, perhaps to contain a specific type of `model`.
@@ -11694,7 +11695,7 @@ class Collection extends EventEmitterObject {
         options = options || {};
         this.preinitialize.apply(this, arguments);
         if (options.model)
-            this._model = options.model;
+            this.model = options.model;
         if (options.comparator !== undefined)
             this.comparator = options.comparator;
         this._reset();
@@ -11709,12 +11710,6 @@ class Collection extends EventEmitterObject {
             this.hydrated = getStorage(this) ? hydrate(this) : Promise.resolve();
         }
     }
-    get comparator() {
-        return this._comparator;
-    }
-    set comparator(c) {
-        this._comparator = c;
-    }
     /**
      * The canonical storage accessor. Set to a `PersistentStorage` instance
      * to enable local persistence for this collection.
@@ -11750,16 +11745,6 @@ class Collection extends EventEmitterObject {
     get autoSync() {
         return false;
     }
-    /**
-     * The default model for a collection is just a **Model**.
-     * This should be overridden in most cases.
-     */
-    get model() {
-        return this._model ?? Model;
-    }
-    set model(model) {
-        this._model = model;
-    }
     get length() {
         return this.models.length;
     }
@@ -12263,7 +12248,7 @@ class Collection extends EventEmitterObject {
      * Define how to uniquely identify models in the collection.
      */
     modelId(attrs) {
-        return attrs[this.model.prototype?.idAttribute || 'id'];
+        return attrs[(this.model ?? Model).prototype?.idAttribute || 'id'];
     }
     /** Get an iterator of all models in this collection. */
     values() {
@@ -12286,7 +12271,7 @@ class Collection extends EventEmitterObject {
         this._byId = {};
     }
     createModel(attrs, options) {
-        const Klass = this.model;
+        const Klass = this.model ?? Model;
         return new Klass(attrs, options);
     }
     /**