@converse/skeletor 0.0.8 → 0.0.9

package/src/types/helpers.d.ts

@@ -0,0 +1,62 @@
+export function guid(): string;
+export function inherits(protoProps: any, staticProps: any): any;
+export function getResolveablePromise(): Promise<any> & {
+    isResolved: boolean;
+    isPending: boolean;
+    isRejected: boolean;
+    resolve: Function;
+    reject: Function;
+};
+export function urlError(): void;
+export function wrapError(model: any, options: any): void;
+/**
+ * @typedef {import('./model.js').Model} Model
+ * @typedef {import('./collection.js').Collection} Collection
+ */
+/**
+ * @param {Model | Collection} model
+ */
+export function getSyncMethod(model: Model | Collection): any;
+/**
+ * @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
+ * model in question. By default makes a `fetch()` API call
+ * to the model's `url()`.
+ *
+ * Some possible customizations could be:
+ *
+ * - 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: "create" | "update" | "patch", model: import("./model.js").Model, options?: SyncOptions): Promise<Response>;
+/**
+ * Custom error for indicating timeouts
+ * @namespace _converse
+ */
+export class NotImplementedError extends Error {
+}
+export type Model = import("./model.js").Model;
+export type Collection = import("./collection.js").Collection;
+export type SyncOptions = {
+    url?: string;
+    data?: any;
+    attrs?: any;
+    success?: Function;
+    error?: Function;
+    xhr?: any;
+};
+//# sourceMappingURL=helpers.d.ts.map

package/src/types/helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"helpers.d.ts","sourceRoot":"","sources":["../helpers.js"],"names":[],"mappings":"AAkBA,+BAGC;AASD,iEA6BC;AAED;gBAGgB,OAAO;eACP,OAAO;gBACP,OAAO;;;EAwCtB;AAGD,iCAEC;AAGD,0DAMC;AAWD;;;GAGG;AAGH;;GAEG;AACH,qCAFW,KAAK,GAAG,UAAU,OAK5B;AAED;;;;;;;;GAQG;AAEH;;;;;;;;;;;;;;;GAeG;AACH,6BAJW,QAAQ,GAAC,QAAQ,GAAC,OAAO,SACzB,OAAO,YAAY,EAAE,KAAK,YAC1B,WAAW,qBAsBrB;AAxLD;;;GAGG;AACH;CAAiD;oBAyHpC,OAAO,YAAY,EAAE,KAAK;yBAC1B,OAAO,iBAAiB,EAAE,UAAU;;UAcnC,MAAM;WACN,GAAG;YACH,GAAG;;;UAGH,GAAG"}

package/src/types/index.d.ts

@@ -0,0 +1,19 @@
+export default skeletor;
+declare namespace skeletor {
+    let VERSION: string;
+    function noConflict(): {
+        Collection: typeof Collection;
+        ElementView: typeof ElementView;
+        EventEmitter: typeof EventEmitter;
+        Model: typeof Model;
+        sync: typeof sync;
+    };
+}
+import { Collection } from './collection.js';
+import ElementView from './element.js';
+import EventEmitter from './eventemitter.js';
+import { Model } from './model.js';
+import Storage from './storage.js';
+import { sync } from './helpers.js';
+export { Collection, ElementView, EventEmitter, Model, Storage, sync };
+//# sourceMappingURL=index.d.ts.map

package/src/types/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../index.js"],"names":[],"mappings":";;;IA+BA;;;;;;MAGC;;2BA9B0B,iBAAiB;wBAHpB,cAAc;yBACb,mBAAmB;sBAGtB,YAAY;oBAFd,cAAc;qBAGb,cAAc"}

package/src/types/listening.d.ts

@@ -0,0 +1,40 @@
+export default Listening;
+/**
+ * A listening class that tracks and cleans up memory bindings
+ * when all callbacks have been offed.
+ */
+declare class Listening {
+    /** @typedef {import('./eventemitter.js').default} EventEmitter */
+    /**
+     * @param {any} listener
+     * @param {any} obj
+     */
+    constructor(listener: any, obj: any);
+    id: any;
+    listener: any;
+    obj: any;
+    interop: boolean;
+    count: number;
+    _events: any;
+    /**
+     * @param {string} name
+     * @param {Function} callback
+     * @param {any} context
+     * @param {Listening} _listening
+     */
+    start(name: string, callback: Function, context: any, _listening: Listening): this;
+    /**
+     * Stop's listening to a callback (or several).
+     * 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: string, callback: Function): void;
+    /**
+     * Cleans up memory bindings between the listener and the listenee.
+     */
+    cleanup(): void;
+}
+//# sourceMappingURL=listening.d.ts.map

package/src/types/listening.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"listening.d.ts","sourceRoot":"","sources":["../listening.js"],"names":[],"mappings":";AAEA;;;GAGG;AACH;IAEE,kEAAkE;IAElE;;;OAGG;IACH,sBAHW,GAAG,OACH,GAAG,EASb;IANC,QAA4B;IAC5B,cAAwB;IACxB,SAAc;IACd,iBAAmB;IACnB,cAAc;IACd,aAAwB;IAG1B;;;;;OAKG;IACH,YALW,MAAM,+BAEN,GAAG,cACH,SAAS,QAmBnB;IAED;;;;;;;OAOG;IACH,WAHW,MAAM,4BAgBhB;IAED;;OAEG;IACH,gBAGC;CACF"}

package/src/types/model.d.ts

@@ -0,0 +1,230 @@
+export type Collection = import("./collection.js").Collection;
+export type Attributes = Record<string, any>;
+export type Options = Record<string, any>;
+export type ModelOptions = Record<string, any>;
+declare const Model_base: {
+    new (...args: any[]): {
+        on(name: string, callback: (event: any, model: Model, collection: import("./collection.js").Collection, options: Record<string, any>) => any, context: any): /*elided*/ any;
+        _events: any;
+        _listeners: {};
+        listenTo(obj: any, name: string, callback?: (event: any, model: Model, collection: import("./collection.js").Collection, options: Record<string, any>) => any): /*elided*/ any;
+        _listeningTo: {};
+        _listenId: any;
+        off(name: string, callback: (event: any, model: Model, collection: import("./collection.js").Collection, options: Record<string, any>) => any, context?: any): /*elided*/ any;
+        stopListening(obj?: any, name?: string, callback?: (event: any, model: Model, collection: import("./collection.js").Collection, options: Record<string, any>) => any): /*elided*/ any;
+        once(name: string, callback: (event: any, model: Model, collection: import("./collection.js").Collection, options: Record<string, any>) => any, context: any): /*elided*/ any;
+        listenToOnce(obj: any, name: string, callback?: (event: any, model: Model, collection: import("./collection.js").Collection, options: Record<string, any>) => any): /*elided*/ any;
+        trigger(name: string, ...args: any[]): /*elided*/ any;
+    };
+} & ObjectConstructor;
+/**
+ * @typedef {import('./collection.js').Collection} Collection
+ * @typedef {Record.<string, any>} Attributes
+ *
+ * @typedef {Record.<string, any>} Options
+ * @property {boolean} [validate]
+ *
+ * @typedef {Record.<string, any>} ModelOptions
+ * @property {Collection} [collection]
+ * @property {boolean} [parse]
+ * @property {boolean} [unset]
+ * @property {boolean} [silent]
+ */
+/**
+ * **Models** are the basic data object in the framework --
+ * frequently representing a row in a table in a database on your server.
+ * A discrete chunk of data and a bunch of useful, related methods for
+ * performing computations and transformations on that data.
+ */
+export class Model extends Model_base {
+    /**
+     * Create a new model with the specified attributes. A client id (`cid`)
+     * is automatically generated and assigned for you.
+     * @param {Attributes} [attributes]
+     * @param {ModelOptions} [options]
+     */
+    constructor(attributes?: Attributes, options?: ModelOptions, ...args: any[]);
+    cid: any;
+    attributes: {};
+    validationError: string;
+    collection: any;
+    changed: {};
+    /**
+     * @param {Storage} storage
+     */
+    set browserStorage(storage: Storage);
+    /**
+     * @returns {Storage} storage
+     */
+    get browserStorage(): Storage;
+    _browserStorage: Storage;
+    /**
+     * The default name for the JSON `id` attribute is `"id"`. MongoDB and
+     * CouchDB users may want to set this to `"_id"` (by overriding this getter
+     * in a subclass).
+     */
+    get idAttribute(): string;
+    /**
+     * The prefix is used to create the client id which is used to identify models locally.
+     * You may want to override this if you're experiencing name clashes with model ids.
+     */
+    get cidPrefix(): string;
+    /**
+     * preinitialize is an empty function by default. You can override it with a function
+     * or object.  preinitialize will run before any instantiation logic is run in the Model.
+     */
+    preinitialize(): void;
+    /**
+     * Initialize is an empty function by default. Override it with your own
+     * initialization logic.
+     * @param {Attributes} [attrs]
+     * @param {ModelOptions} [options]
+     */
+    initialize(attrs?: Attributes, options?: ModelOptions): void;
+    /**
+     * @param {object} attrs
+     * @param {object} [options]
+     * @returns {string} The validation error message
+     */
+    validate(attrs: object, options?: object): string;
+    /**
+     * Return a copy of the model's `attributes` object.
+     */
+    toJSON(): any;
+    /**
+     * Override this if you need custom syncing semantics for *this* particular model.
+     * @param {'create'|'update'|'patch'|'delete'|'read'} method
+     * @param {Model} model
+     * @param {Options} options
+     */
+    sync(method: "create" | "update" | "patch" | "delete" | "read", model: Model, options: Options): any;
+    /**
+     * Get the value of an attribute.
+     * @param {string} attr
+     */
+    get(attr: string): any;
+    keys(): string[];
+    values(): any[];
+    pairs(): [string, any][];
+    entries(): [string, any][];
+    invert(): any;
+    pick(...args: any[]): any;
+    omit(...args: any[]): any;
+    isEmpty(): any;
+    /**
+     * Returns `true` if the attribute contains a value that is not null
+     * or undefined.
+     * @param {string} attr
+     */
+    has(attr: string): boolean;
+    /**
+     * Special-cased proxy to lodash's `matches` method.
+     * @param {Attributes} attrs
+     */
+    matches(attrs: Attributes): boolean;
+    /**
+     * Set a hash of model attributes on the object, firing `"change"`. This is
+     * the core primitive operation of a model, updating the data and notifying
+     * anyone who needs to know about the change in state. The heart of the beast.
+     * @param {string|Object} key
+     * @param {string|Object} [val]
+     * @param {Options} [options]
+     */
+    set(key: string | any, val?: string | any, options?: Options): false | this;
+    _changing: boolean;
+    _previousAttributes: any;
+    id: any;
+    _pending: boolean | Options;
+    /**
+     * Remove an attribute from the model, firing `"change"`. `unset` is a noop
+     * if the attribute doesn't exist.
+     * @param {string} attr
+     * @param {Options} [options]
+     */
+    unset(attr: string, options?: Options): false | this;
+    /**
+     * Clear all attributes on the model, firing `"change"`.
+     * @param {Options} options
+     */
+    clear(options: Options): false | this;
+    /**
+     * Determine if the model has changed since the last `"change"` event.
+     * If you specify an attribute name, determine if that attribute has changed.
+     * @param {string} [attr]
+     */
+    hasChanged(attr?: string): any;
+    /**
+     * Return an object containing all the attributes that have changed, or
+     * false if there are no changed attributes. Useful for determining what
+     * parts of a view need to be updated and/or what attributes need to be
+     * persisted to the server. Unset attributes will be set to undefined.
+     * You can also pass an attributes object to diff against the model,
+     * determining if there *would be* a change.
+     * @param {Object} diff
+     */
+    changedAttributes(diff: any): any;
+    /**
+     * Get the previous value of an attribute, recorded at the time the last
+     * `"change"` event was fired.
+     * @param {string} [attr]
+     */
+    previous(attr?: string): any;
+    /**
+     * Get all of the attributes of the model at the time of the previous
+     * `"change"` event.
+     */
+    previousAttributes(): any;
+    /**
+     * Fetch the model from the server, merging the response with the model's
+     * local attributes. Any changed attributes will trigger a "change" event.
+     * @param {Options} [options={}]
+     */
+    fetch(options?: Options): any;
+    /**
+     * Set a hash of model attributes, and sync the model to the server.
+     * If the server returns an attributes hash that differs, the model's
+     * state will be `set` again.
+     * @param {string|Attributes} [key]
+     * @param {boolean|number|string|Options} [val]
+     * @param {Options} [options]
+     */
+    save(key?: string | Attributes, val?: boolean | number | string | Options, options?: Options): any;
+    /**
+     * Destroy this model on the server if it was already persisted.
+     * Optimistically removes the model from its collection, if it has one.
+     * If `wait: true` is passed, waits for the server to respond before removal.
+     * @param {Options} [options]
+     */
+    destroy(options?: Options): boolean;
+    /**
+     * Default URL for the model's representation on the server -- if you're
+     * using Backbone's restful methods, override this to change the endpoint
+     * that will be called.
+     */
+    url(): any;
+    /**
+     * **parse** converts a response into the hash of attributes to be `set` on
+     * the model. The default implementation is just to pass the response along.
+     * @param {Options} resp
+     * @param {Options} [options]
+     */
+    parse(resp: Options, options?: Options): Options;
+    /**
+     * A model is new if it has never been saved to the server, and lacks an id.
+     */
+    isNew(): boolean;
+    /**
+     * Check if the model is currently in a valid state.
+     * @param {Options} [options]
+     */
+    isValid(options?: Options): boolean;
+    /**
+     * Run validation against the next complete set of model attributes,
+     * returning `true` if all is well. Otherwise, fire an `"invalid"` event.
+     * @param {Attributes} attrs
+     * @param {Options} [options]
+     */
+    _validate(attrs: Attributes, options?: Options): boolean;
+}
+export {};
+//# sourceMappingURL=model.d.ts.map

package/src/types/model.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"model.d.ts","sourceRoot":"","sources":["../model.js"],"names":[],"mappings":"yBAgBa,OAAO,iBAAiB,EAAE,UAAU;yBACpC,MAAM,CAAE,MAAM,EAAE,GAAG,CAAC;sBAEpB,MAAM,CAAE,MAAM,EAAE,GAAG,CAAC;2BAGpB,MAAM,CAAE,MAAM,EAAE,GAAG,CAAC;;;;;;;;;;;;;;;;AAPjC;;;;;;;;;;;;GAYG;AAEH;;;;;GAKG;AACH;IACE;;;;;OAKG;IACH,yBAHW,UAAU,YACV,YAAY,kBAyBtB;IAlBC,SAAmC;IACnC,eAAoB;IAGpB,wBAA2B;IAEH,gBAAoC;IAW5D,YAAiB;IAGnB;;OAEG;IACH,4BAFW,OAAO,EAIjB;IAED;;OAEG;IACH,sBAFa,OAAO,CAInB;IARC,yBAA8B;IAUhC;;;;OAIG;IAEH,0BAEC;IAED;;;OAGG;IAEH,wBAEC;IAED;;;OAGG;IAEH,sBAAkB;IAElB;;;;;OAKG;IACH,mBAHW,UAAU,YACV,YAAY,QAEM;IAE7B;;;;OAIG;IACH,gBAJW,MAAM,YACN,MAAM,GACJ,MAAM,CAIlB;IAED;;OAEG;IACH,cAEC;IAED;;;;;OAKG;IAEH,aALW,QAAQ,GAAC,QAAQ,GAAC,OAAO,GAAC,QAAQ,GAAC,MAAM,SACzC,KAAK,WACL,OAAO,OAKjB;IAED;;;OAGG;IACH,UAFW,MAAM,OAIhB;IAED,iBAEC;IAED,gBAEC;IAED,yBAEC;IAED,2BAEC;IAED,cAEC;IAED,0BAKC;IAED,0BAKC;IAED,eAEC;IAED;;;;OAIG;IACH,UAFW,MAAM,WAIhB;IAED;;;OAGG;IACH,eAFW,UAAU,WAIpB;IAED;;;;;;;OAOG;IACH,SAJW,MAAM,MAAO,QACb,MAAM,MAAO,YACb,OAAO,gBAuEjB;IA/CC,mBAAqB;IAGnB,yBAAiD;IAqBpB,QAAoC;IAI7C,4BAAuB;IAqB/C;;;;;OAKG;IACH,YAHW,MAAM,YACN,OAAO,gBAIjB;IAED;;;OAGG;IACH,eAFW,OAAO,gBAMjB;IAED;;;;OAIG;IACH,kBAFW,MAAM,OAKhB;IAED;;;;;;;;OAQG;IACH,kCAeC;IAED;;;;OAIG;IACH,gBAFW,MAAM,OAKhB;IAED;;;OAGG;IACH,0BAEC;IAED;;;;OAIG;IACH,gBAFW,OAAO,OAgBjB;IAED;;;;;;;OAOG;IACH,WAJW,MAAM,GAAC,UAAU,QACjB,OAAO,GAAC,MAAM,GAAC,MAAM,GAAC,OAAO,YAC7B,OAAO,OAiEjB;IAED;;;;;OAKG;IACH,kBAFW,OAAO,WA2BjB;IAED;;;;OAIG;IACH,WAKC;IAED;;;;;OAKG;IACH,YAHW,OAAO,YACP,OAAO,WAIjB;IAED;;OAEG;IACH,iBAEC;IAED;;;OAGG;IACH,kBAFW,OAAO,WAIjB;IAED;;;;;OAKG;IACH,iBAHW,UAAU,YACV,OAAO,WASjB;CACF"}

package/src/types/storage.d.ts

@@ -0,0 +1,35 @@
+export default Storage;
+declare class Storage {
+    constructor(id: any, type: any, batchedWrites?: boolean);
+    storeInitialized: Promise<void>;
+    store: any;
+    name: any;
+    /**
+     * @param {'local'|'session'|'indexed'|'in_memory'} type
+     * @param {boolean} batchedWrites
+     */
+    initStore(type: "local" | "session" | "indexed" | "in_memory", batchedWrites: boolean): Promise<void>;
+    flush(): any;
+    clear(): Promise<void>;
+    sync(): {
+        (method: any, model: any, options: any): Promise<void>;
+        __name__: string;
+    };
+    removeCollectionReference(model: any, collection: any): any;
+    addCollectionReference(model: any, collection: any): any;
+    getCollectionReferenceData(model: any): {};
+    save(model: any): Promise<any>;
+    create(model: any, options: any): Promise<any>;
+    update(model: any): Promise<any>;
+    find(model: any): any;
+    findAll(): Promise<any[]>;
+    destroy(model: any, collection: any): Promise<any>;
+    getStorageSize(): any;
+    getItemName(id: any): string;
+}
+declare namespace Storage {
+    export let sessionStorageInitialized: Promise<void>;
+    export { localForage };
+}
+import localForage from 'localforage';
+//# sourceMappingURL=storage.d.ts.map

package/src/types/storage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"storage.d.ts","sourceRoot":"","sources":["../storage.js"],"names":[],"mappings":";AAkBA;IACE,yDAgBC;IATG,gCAA2D;IAE3D,WAAiB;IAMnB,UAAc;IAGhB;;;OAGG;IACH,gBAHW,OAAO,GAAC,SAAS,GAAC,SAAS,GAAC,WAAW,iBACvC,OAAO,iBAgBjB;IAED,aAEC;IAED,uBAMC;IAED;;;MAiFC;IAED,4DAOC;IAED,yDAUC;IAED,2CAYC;IAED,+BAYC;IAED,+CASC;IAED,iCAEC;IAED,sBAEC;IAED,0BASC;IAED,mDAKC;IAED,sBAEC;IAED,6BAEC;CACF;;;;;wBA/OuB,aAAa"}

package/src/types/utils/events.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Iterates over the standard `event, callback` (as well as the fancy multiple
+ * space-separated events `"change blur", callback` and jQuery-style event
+ * maps `{event: callback}`).
+ */
+export function eventsApi(iteratee: any, events: any, name: any, callback: any, opts: any): any;
+export function onApi(events: any, name: any, callback: any, options: any): any;
+/**
+ * An try-catch guarded #on function, to prevent poisoning the global
+ * `_listening` variable.
+ * @param {any} obj
+ * @param {string} name
+ * @param {Function} callback
+ * @param {any} context
+ */
+export function tryCatchOn(obj: any, name: string, callback: Function, context: any): any;
+/**
+ * The reducing API that removes a callback from the `events` object.
+ */
+export function offApi(events: any, name: any, callback: any, options: any): any;
+/**
+ * Reduces the event callbacks into a map of `{event: onceWrapper}`.
+ * `offer` unbinds the `onceWrapper` after it has been called.
+ */
+export function onceMap(map: any, name: any, callback: any, offer: any): any;
+/** Handles triggering the appropriate event callbacks. */
+export function triggerApi(objEvents: any, name: any, callback: any, args: any): any;
+//# sourceMappingURL=events.d.ts.map

package/src/types/utils/events.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"events.d.ts","sourceRoot":"","sources":["../../utils/events.js"],"names":[],"mappings":"AAMA;;;;GAIG;AACH,gGAmBC;AAGD,gFAWC;AAED;;;;;;;GAOG;AACH,gCALW,GAAG,QACH,MAAM,+BAEN,GAAG,OAQb;AAED;;GAEG;AACH,iFAkDC;AAED;;;GAGG;AACH,6EASC;AAED,0DAA0D;AAC1D,qFASC"}

package/src/utils/events.js

@@ -0,0 +1,174 @@
+import once from 'lodash-es/once.js';
+import keys from 'lodash-es/keys.js';
+
+// Regular expression used to split event strings.
+const eventSplitter = /\s+/;
+
+/**
+ * Iterates over the standard `event, callback` (as well as the fancy multiple
+ * space-separated events `"change blur", callback` and jQuery-style event
+ * maps `{event: callback}`).
+ */
+export function eventsApi(iteratee, events, name, callback, opts) {
+  let i = 0,
+    names;
+  if (name && typeof name === 'object') {
+    // Handle event maps.
+    if (callback !== undefined && 'context' in opts && opts.context === undefined) opts.context = callback;
+    for (names = keys(name); i < names.length; i++) {
+      events = eventsApi(iteratee, events, names[i], name[names[i]], opts);
+    }
+  } else if (name && eventSplitter.test(name)) {
+    // Handle space-separated event names by delegating them individually.
+    for (names = name.split(eventSplitter); i < names.length; i++) {
+      events = iteratee(events, names[i], callback, opts);
+    }
+  } else {
+    // Finally, standard events.
+    events = iteratee(events, name, callback, opts);
+  }
+  return events;
+}
+
+// The reducing API that adds a callback to the `events` object.
+export function onApi(events, name, callback, options) {
+  if (callback) {
+    const handlers = events[name] || (events[name] = []);
+    const context = options.context,
+      ctx = options.ctx,
+      listening = options.listening;
+    if (listening) listening.count++;
+
+    handlers.push({ callback, context, ctx: context || ctx, listening });
+  }
+  return events;
+}
+
+/**
+ * An try-catch guarded #on function, to prevent poisoning the global
+ * `_listening` variable.
+ * @param {any} obj
+ * @param {string} name
+ * @param {Function} callback
+ * @param {any} context
+ */
+export function tryCatchOn(obj, name, callback, context) {
+  try {
+    obj.on(name, callback, context);
+  } catch (e) {
+    return e;
+  }
+}
+
+/**
+ * The reducing API that removes a callback from the `events` object.
+ */
+export function offApi(events, name, callback, options) {
+  if (!events) return;
+
+  const context = options.context,
+    listeners = options.listeners;
+  let i = 0,
+    names;
+
+  // Delete all event listeners and "drop" events.
+  if (!name && !context && !callback) {
+    for (names = keys(listeners); i < names.length; i++) {
+      listeners[names[i]].cleanup();
+    }
+    return;
+  }
+
+  names = name ? [name] : keys(events);
+  for (; i < names.length; i++) {
+    name = names[i];
+    const handlers = events[name];
+
+    // Bail out if there are no events stored.
+    if (!handlers) {
+      break;
+    }
+
+    // Find any remaining events.
+    const remaining = [];
+    for (let j = 0; j < handlers.length; j++) {
+      const handler = handlers[j];
+      if (
+        (callback && callback !== handler.callback && callback !== handler.callback._callback) ||
+        (context && context !== handler.context)
+      ) {
+        remaining.push(handler);
+      } else {
+        const listening = handler.listening;
+        if (listening) listening.stop(name, callback);
+      }
+    }
+
+    // Replace events if there are any remaining.  Otherwise, clean up.
+    if (remaining.length) {
+      events[name] = remaining;
+    } else {
+      delete events[name];
+    }
+  }
+
+  return events;
+}
+
+/**
+ * Reduces the event callbacks into a map of `{event: onceWrapper}`.
+ * `offer` unbinds the `onceWrapper` after it has been called.
+ */
+export function onceMap(map, name, callback, offer) {
+  if (callback) {
+    const _once = (map[name] = once(function () {
+      offer(name, _once);
+      callback.apply(this, arguments);
+    }));
+    _once._callback = callback;
+  }
+  return map;
+}
+
+/** Handles triggering the appropriate event callbacks. */
+export function triggerApi(objEvents, name, callback, args) {
+  if (objEvents) {
+    const events = objEvents[name];
+    let allEvents = objEvents.all;
+    if (events && allEvents) allEvents = allEvents.slice();
+    if (events) triggerEvents(events, args);
+    if (allEvents) triggerEvents(allEvents, [name].concat(args));
+  }
+  return objEvents;
+}
+
+/**
+ * A difficult-to-believe, but optimized internal dispatch function for
+ * triggering events. Tries to keep the usual cases speedy (most internal
+ * Backbone events have 3 arguments).
+ */
+function triggerEvents(events, args) {
+  let ev,
+    i = -1;
+  const l = events.length,
+    a1 = args[0],
+    a2 = args[1],
+    a3 = args[2];
+  switch (args.length) {
+    case 0:
+      while (++i < l) (ev = events[i]).callback.call(ev.ctx);
+      return;
+    case 1:
+      while (++i < l) (ev = events[i]).callback.call(ev.ctx, a1);
+      return;
+    case 2:
+      while (++i < l) (ev = events[i]).callback.call(ev.ctx, a1, a2);
+      return;
+    case 3:
+      while (++i < l) (ev = events[i]).callback.call(ev.ctx, a1, a2, a3);
+      return;
+    default:
+      while (++i < l) (ev = events[i]).callback.apply(ev.ctx, args);
+      return;
+  }
+}