@converse/skeletor 0.0.9 → 1.0.0

package/src/{helpers.js → helpers.ts}

@@ -1,9 +1,12 @@
-//     (c) 2010-2019 Jeremy Ashkenas and DocumentCloud
-
-import create from 'lodash-es/create.js';
-import extend from 'lodash-es/extend.js';
-import has from 'lodash-es/has.js';
-import result from 'lodash-es/result.js';
+// (c) 2010-2019 Jeremy Ashkenas and DocumentCloud
+// (c) 2018-2025 JC Brand
+import create from 'lodash-es/create';
+import extend from 'lodash-es/extend';
+import has from 'lodash-es/has';
+import result from 'lodash-es/result';
+import { Model } from './model';
+import { Collection } from './collection';
+import { type SyncOptions, SyncOperation } from './types';
 
 /**
  * Custom error for indicating timeouts
@@ -11,12 +14,12 @@ import result from 'lodash-es/result.js';
  */
 export class NotImplementedError extends Error {}
 
-function S4() {
+function S4(): string {
   // Generate four random hex digits.
   return (((1 + Math.random()) * 0x10000) | 0).toString(16).substring(1);
 }
 
-export function guid() {
+export function guid(): string {
   // Generate a pseudo-GUID by concatenating random hexadecimal.
   return S4() + S4() + '-' + S4() + '-' + S4() + '-' + S4() + '-' + S4() + S4() + S4();
 }
@@ -28,10 +31,13 @@ export function guid() {
 // Similar to `goog.inherits`, but uses a hash of prototype properties and
 // class properties to be extended.
 //
-export function inherits(protoProps, staticProps) {
+export function inherits<T extends new (...args: any[]) => any>(
+  protoProps: Record<string, any> | null,
+  staticProps?: Record<string, any>
+): T {
   // eslint-disable-next-line @typescript-eslint/no-this-alias
   const parent = this;
-  let child;
+  let child: T;
 
   // The constructor function for the new subclass is either defined by you
   // (the "constructor" property in your `extend` definition), or defaulted
@@ -39,9 +45,9 @@ export function inherits(protoProps, staticProps) {
   if (protoProps && has(protoProps, 'constructor')) {
     child = protoProps.constructor;
   } else {
-    child = function () {
-      return parent.apply(this, arguments);
-    };
+    child = function (this: any, ...args: any[]) {
+      return parent.apply(this, args);
+    } as unknown as T;
   }
 
   // Add static properties to the constructor function, if supplied.
@@ -54,23 +60,23 @@ export function inherits(protoProps, staticProps) {
 
   // Set a convenience property in case the parent's prototype is needed
   // later.
-  child.__super__ = parent.prototype;
+  (child as any).__super__ = parent.prototype;
 
   return child;
 }
 
-export function getResolveablePromise() {
-  /**
-   * @typedef {Object} PromiseWrapper
-   * @property {boolean} isResolved
-   * @property {boolean} isPending
-   * @property {boolean} isRejected
-   * @property {Function} resolve
-   * @property {Function} reject
-   */
-
-  /** @type {PromiseWrapper} */
-  const wrapper = {
+interface PromiseWrapper {
+  isResolved: boolean;
+  isPending: boolean;
+  isRejected: boolean;
+  resolve: ((value?: any) => void) | null;
+  reject: ((reason?: any) => void) | null;
+}
+
+type ResolveablePromise = Promise<any> & PromiseWrapper;
+
+export function getResolveablePromise(): ResolveablePromise {
+  const wrapper: PromiseWrapper = {
     isResolved: false,
     isPending: true,
     isRejected: false,
@@ -78,16 +84,11 @@ export function getResolveablePromise() {
     reject: null,
   };
 
-  /**
-   * @typedef {Promise & PromiseWrapper} ResolveablePromise
-   */
+  const promise = new Promise((resolve, reject) => {
+    wrapper.resolve = resolve;
+    wrapper.reject = reject;
+  }) as ResolveablePromise;
 
-  const promise = /** @type {ResolveablePromise} */ (
-    new Promise((resolve, reject) => {
-      wrapper.resolve = resolve;
-      wrapper.reject = reject;
-    })
-  );
   Object.assign(promise, wrapper);
   promise.then(
     function (v) {
@@ -101,27 +102,27 @@ export function getResolveablePromise() {
       promise.isPending = false;
       promise.isRejected = true;
       throw e;
-    },
+    }
   );
   return promise;
 }
 
 // Throw an error when a URL is needed, and none is supplied.
-export function urlError() {
+export function urlError(): never {
   throw new Error('A "url" property or function must be specified');
 }
 
 // Wrap an optional error callback with a fallback error event.
-export function wrapError(model, options) {
+export function wrapError(model: Model<any> | Collection<any>, options: any): void {
   const error = options.error;
-  options.error = function (resp) {
+  options.error = function (resp: any) {
     if (error) error.call(options.context, model, resp, options);
     model.trigger('error', model, resp, options);
   };
 }
 
 // Map from CRUD to HTTP for our default `sync` implementation.
-const methodMap = {
+const methodMap: Record<string, string> = {
   create: 'POST',
   update: 'PUT',
   patch: 'PATCH',
@@ -129,30 +130,11 @@ const methodMap = {
   read: 'GET',
 };
 
-/**
- * @typedef {import('./model.js').Model} Model
- * @typedef {import('./collection.js').Collection} Collection
- */
-
-
-/**
- * @param {Model | Collection} model
- */
-export function getSyncMethod(model) {
-  const store = result(model, 'browserStorage') || result(/** @type {Model} */(model).collection, 'browserStorage');
-  return store ? store.sync() : sync;
+export function getSyncMethod(model: Model | Collection<any>): typeof sync & { __name__?: string } {
+  const store = result(model, 'browserStorage') || result((model as Model).collection, 'browserStorage');
+  return store ? (store as any).sync() : sync;
 }
 
-/**
- * @typedef {Object} SyncOptions
- * @property {string} [url]
- * @property {any} [data]
- * @property {any} [attrs]
- * @property {Function} [success]
- * @property {Function} [error]
- * @property {any} [xhr]
- */
-
 /**
  * Override this function to change the manner in which Backbone persists
  * models to the server. You will be passed the type of request, and the
@@ -164,12 +146,11 @@ export function getSyncMethod(model) {
  * - Use `setTimeout` to batch rapid-fire updates into a single request.
  * - Persist models via WebSockets instead of Ajax.
  * - Persist models to browser storage
- *
- * @param {'create'|'update'|'patch'} method
- * @param {import('./model.js').Model} model
- * @param {SyncOptions} [options]
  */
-export function sync(method, model, options = {}) {
+/**
+ * @public
+ */
+export function sync(method: SyncOperation, model: Model | Collection<any>, options: SyncOptions = {}): Promise<any> {
   let data = options.data;
 
   // Ensure that we have the appropriate request data.
@@ -178,15 +159,21 @@ export function sync(method, model, options = {}) {
   }
 
   const type = methodMap[method];
-  const params = {
+  const params: RequestInit & { success?: any; error?: any } = {
     method: type,
     body: data ? JSON.stringify(data) : '',
+    headers: {
+      'Content-Type': 'application/json',
+    },
     success: options.success,
     error: options.error,
   };
 
   const url = options.url || result(model, 'url') || urlError();
-  const xhr = (options.xhr = fetch(url, params));
+  const xhr = fetch(url, params);
+  if (options) {
+    options.xhr = xhr;
+  }
   model.trigger('request', model, xhr, { ...params, xhr });
   return xhr;
 }

package/src/index.ts

@@ -0,0 +1,84 @@
+/* global global */
+import { EventEmitter } from './eventemitter';
+import Storage from './storage';
+import { Collection } from './collection';
+import { Model } from './model';
+import { sync } from './helpers';
+
+/**
+ * @public
+ */
+interface SkeletorType {
+  Collection: typeof Collection;
+  EventEmitter: typeof EventEmitter;
+  Model: typeof Model;
+  sync: typeof sync;
+  VERSION?: string;
+  noConflict?: () => SkeletorType;
+}
+
+/**
+ * @public
+ */
+const skeletor: SkeletorType = {
+  Collection,
+  EventEmitter,
+  Model,
+  sync,
+};
+
+// Establish the root object, `window` (`self`) in the browser, or `global` on the server.
+// We use `self` instead of `window` for `WebWorker` support.
+const root =
+  (typeof self == 'object' && self.self === self && self) ||
+  (typeof global == 'object' && global.global === global && global);
+
+// Current version of the library. Keep in sync with `package.json`.
+skeletor.VERSION = '0.0.1';
+
+// Save the previous value of the `Skeletor` variable, so that it can be
+// restored later on, if `noConflict` is used.
+const previousSkeletor = root.Skeletor;
+
+// Runs Skeletor.js in *noConflict* mode, returning the `Skeletor` variable
+// to its previous owner. Returns a reference to this Skeletor object.
+/**
+ * @public
+ */
+function noConflict() {
+  root.Skeletor = previousSkeletor;
+  return this;
+}
+skeletor.noConflict = noConflict;
+
+root.Skeletor = skeletor;
+export default skeletor;
+
+export { noConflict, Collection, EventEmitter, Model, Storage, sync };
+
+export type { LocalForageWithExtensions } from './storage';
+export type {
+  ClassConstructor,
+  CollectionOptions,
+  Comparator,
+  EventCallback,
+  EventCallbackMap,
+  EventContext,
+  EventHandlersMap,
+  EventListenerMap,
+  ModelAttributes,
+  ModelOptions,
+  ObjectListenedTo,
+  ObjectWithId,
+  Options,
+  SyncOperation,
+  SyncOptions,
+  EventHandler,
+  ListeningType,
+  IEventEmitter,
+  ListeningMap,
+} from './types';
+
+export type { CollectionIterator } from './collection';
+export type { SkeletorType };
+export type { EventEmitterObject } from './eventemitter';

package/src/{listening.js → listening.ts}

@@ -1,19 +1,26 @@
-import { eventsApi, onApi, offApi } from './utils/events.js';
+import { eventsApi, onApi, offApi } from './utils/events';
+import type {
+  EventCallback,
+  IEventEmitter,
+  EventCallbackMap,
+  EventsApiOptions,
+  ListeningType,
+} from './types';
 
 /**
  * A listening class that tracks and cleans up memory bindings
  * when all callbacks have been offed.
  */
-class Listening {
+class Listening implements ListeningType {
+  id: string;
+  listener: IEventEmitter;
+  obj: any;
+  interop: boolean;
+  count: number;
+  _events?: EventCallbackMap;
 
-  /** @typedef {import('./eventemitter.js').default} EventEmitter */
-
-  /**
-   * @param {any} listener
-   * @param {any} obj
-   */
-  constructor(listener, obj) {
-    this.id = listener._listenId;
+  constructor(listener: IEventEmitter, obj: any) {
+    this.id = listener._listenId!;
     this.listener = listener;
     this.obj = obj;
     this.interop = true;
@@ -21,18 +28,14 @@ class Listening {
     this._events = undefined;
   }
 
-  /**
-   * @param {string} name
-   * @param {Function} callback
-   * @param {any} context
-   * @param {Listening} _listening
-   */
-  start(name, callback, context, _listening) {
-    this._events = eventsApi(onApi, this._events || {}, name, callback, {
+  start(name: string | EventCallbackMap, callback: EventCallback, context: any, _listening: ListeningType): this {
+    const options: EventsApiOptions = {
       context: this.obj,
       ctx: context,
       listening: _listening,
-    });
+    };
+
+    this._events = eventsApi(onApi, this._events || {}, name, callback, options) as EventCallbackMap;
 
     if (_listening) {
       const listeners = this.obj._listeners || (this.obj._listeners = {});
@@ -51,16 +54,14 @@ class Listening {
    * Uses an optimized counter if the listenee uses Backbone.Events.
    * Otherwise, falls back to manual tracking to support events
    * library interop.
-   * @param {string} name
-   * @param {Function} callback
    */
-  stop(name, callback) {
-    let cleanup;
+  stop(name: string | EventCallbackMap, callback: EventCallback): void {
+    let cleanup: boolean;
     if (this.interop) {
       this._events = eventsApi(offApi, this._events, name, callback, {
         context: undefined,
         listeners: undefined,
-      });
+      }) as EventCallbackMap;
       cleanup = !this._events;
     } else {
       this.count--;
@@ -72,9 +73,13 @@ class Listening {
   /**
    * Cleans up memory bindings between the listener and the listenee.
    */
-  cleanup() {
-    delete this.listener._listeningTo[this.obj._listenId];
-    if (!this.interop) delete this.obj._listeners[this.id];
+  cleanup(): void {
+    if (this.listener._listeningTo) {
+      delete this.listener._listeningTo[this.obj._listenId!];
+    }
+    if (!this.interop && this.obj._listeners) {
+      delete this.obj._listeners[this.id];
+    }
   }
 }