@joint/core 4.0.0

package/src/mvc/Events.mjs

@@ -0,0 +1,337 @@
+import {
+    isEmpty,
+    uniqueId 
+} from '../util/util.mjs';
+
+// Events
+// ---------------
+
+// A module that can be mixed in to *any object* in order to provide it with
+// a custom event channel. You may bind a callback to an event with `on` or
+// remove with `off`; `trigger`-ing an event fires all callbacks in
+// succession.
+//
+//     const object = {};
+//     assign(object, Events);
+//     object.on('expand', function(){ alert('expanded'); });
+//     object.trigger('expand');
+//
+export var Events = {};
+
+// Regular expression used to split event strings.
+var eventSplitter = /\s+/;
+
+// A private global variable to share between listeners and listenees.
+var _listening;
+
+// 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}`).
+var eventsApi = function(iteratee, events, name, callback, opts) {
+    var i = 0, names;
+    if (name && typeof name === 'object') {
+    // Handle event maps.
+        if (callback !== void 0 && 'context' in opts && opts.context === void 0) opts.context = callback;
+        for (names = Object.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;
+};
+
+// Bind an event to a `callback` function. Passing `"all"` will bind
+// the callback to all events fired.
+Events.on = function(name, callback, context) {
+    this._events = eventsApi(onApi, this._events || {}, name, callback, {
+        context: context,
+        ctx: this,
+        listening: _listening
+    });
+
+    if (_listening) {
+        var listeners = this._listeners || (this._listeners = {});
+        listeners[_listening.id] = _listening;
+        // Allow the listening to use a counter, instead of tracking
+        // callbacks for library interop
+        _listening.interop = false;
+    }
+
+    return this;
+};
+
+// Inversion-of-control versions of `on`. Tell *this* object to listen to
+// an event in another object... keeping track of what it's listening to
+// for easier unbinding later.
+Events.listenTo = function(obj, name, callback) {
+    if (!obj) return this;
+    var id = obj._listenId || (obj._listenId = uniqueId('l'));
+    var listeningTo = this._listeningTo || (this._listeningTo = {});
+    var listening = _listening = listeningTo[id];
+
+    // This object is not listening to any other events on `obj` yet.
+    // Setup the necessary references to track the listening callbacks.
+    if (!listening) {
+        this._listenId || (this._listenId = uniqueId('l'));
+        listening = _listening = listeningTo[id] = new Listening(this, obj);
+    }
+
+    // Bind callbacks on obj.
+    var error = tryCatchOn(obj, name, callback, this);
+    _listening = void 0;
+
+    if (error) throw error;
+    // If the target obj is not Events, track events manually.
+    if (listening.interop) listening.on(name, callback);
+
+    return this;
+};
+
+// The reducing API that adds a callback to the `events` object.
+var onApi = function(events, name, callback, options) {
+    if (callback) {
+        var handlers = events[name] || (events[name] = []);
+        var context = options.context, ctx = options.ctx, listening = options.listening;
+        if (listening) listening.count++;
+
+        handlers.push({ callback: callback, context: context, ctx: context || ctx, listening: listening });
+    }
+    return events;
+};
+
+// An try-catch guarded #on function, to prevent poisoning the global
+// `_listening` variable.
+var tryCatchOn = function(obj, name, callback, context) {
+    try {
+        obj.on(name, callback, context);
+    } catch (e) {
+        return e;
+    }
+};
+
+// Remove one or many callbacks. If `context` is null, removes all
+// callbacks with that function. If `callback` is null, removes all
+// callbacks for the event. If `name` is null, removes all bound
+// callbacks for all events.
+Events.off = function(name, callback, context) {
+    if (!this._events) return this;
+    this._events = eventsApi(offApi, this._events, name, callback, {
+        context: context,
+        listeners: this._listeners
+    });
+
+    return this;
+};
+
+// Tell this object to stop listening to either specific events ... or
+// to every object it's currently listening to.
+Events.stopListening = function(obj, name, callback) {
+    var listeningTo = this._listeningTo;
+    if (!listeningTo) return this;
+
+    var ids = obj ? [obj._listenId] : Object.keys(listeningTo);
+    for (var i = 0; i < ids.length; i++) {
+        var listening = listeningTo[ids[i]];
+
+        // If listening doesn't exist, this object is not currently
+        // listening to obj. Break out early.
+        if (!listening) break;
+
+        listening.obj.off(name, callback, this);
+        if (listening.interop) listening.off(name, callback);
+    }
+    if (isEmpty(listeningTo)) this._listeningTo = void 0;
+
+    return this;
+};
+
+// The reducing API that removes a callback from the `events` object.
+var offApi = function(events, name, callback, options) {
+    if (!events) return;
+
+    var context = options.context, listeners = options.listeners;
+    var i = 0, names;
+
+    // Delete all event listeners and "drop" events.
+    if (!name && !context && !callback) {
+        if(listeners != null) {
+            for (names = Object.keys(listeners); i < names.length; i++) {
+                listeners[names[i]].cleanup();
+            }
+        }
+        return;
+    }
+    names = name ? [name] : Object.keys(events);
+    for (; i < names.length; i++) {
+        name = names[i];
+        var handlers = events[name];
+
+        // Bail out if there are no events stored.
+        if (!handlers) break;
+
+        // Find any remaining events.
+        var remaining = [];
+        for (var j = 0; j < handlers.length; j++) {
+            var handler = handlers[j];
+            if (
+                callback && callback !== handler.callback &&
+        callback !== handler.callback._callback ||
+          context && context !== handler.context
+            ) {
+                remaining.push(handler);
+            } else {
+                var listening = handler.listening;
+                if (listening) listening.off(name, callback);
+            }
+        }
+
+        // Replace events if there are any remaining.  Otherwise, clean up.
+        if (remaining.length) {
+            events[name] = remaining;
+        } else {
+            delete events[name];
+        }
+    }
+
+    return events;
+};
+
+// Bind an event to only be triggered a single time. After the first time
+// the callback is invoked, its listener will be removed. If multiple events
+// are passed in using the space-separated syntax, the handler will fire
+// once for each event, not once for a combination of all events.
+Events.once = function(name, callback, context) {
+// Map the event into a `{event: once}` object.
+    var events = eventsApi(onceMap, {}, name, callback, this.off.bind(this));
+    if (typeof name === 'string' && context == null) callback = void 0;
+    return this.on(events, callback, context);
+};
+
+// Inversion-of-control versions of `once`.
+Events.listenToOnce = function(obj, name, callback) {
+// Map the event into a `{event: once}` object.
+    var events = eventsApi(onceMap, {}, name, callback, this.stopListening.bind(this, obj));
+    return this.listenTo(obj, events);
+};
+
+// Reduces the event callbacks into a map of `{event: onceWrapper}`.
+// `offer` unbinds the `onceWrapper` after it has been called.
+var onceMap = function(map, name, callback, offer) {
+    if (callback) {
+        var once = map[name] = onceInvoke(function() {
+            offer(name, once);
+            callback.apply(this, arguments);
+        });
+        once._callback = callback;
+    }
+    return map;
+};
+
+// Creates a function that is restricted to invoking 'func' once.
+// Repeat calls to the function return the value of the first invocation.
+var onceInvoke = function(func) {
+    var result;
+    if (typeof func != 'function') {
+        throw new TypeError('Expected a function');
+    }
+    var n = 2;
+    return function() {
+        if (--n > 0) {
+            result = func.apply(this, arguments);
+        }
+        if (n <= 1) {
+            func = undefined;
+        }
+        return result;
+    };
+};
+
+// Trigger one or many events, firing all bound callbacks. Callbacks are
+// passed the same arguments as `trigger` is, apart from the event name
+// (unless you're listening on `"all"`, which will cause your callback to
+// receive the true name of the event as the first argument).
+Events.trigger = function(name) {
+    if (!this._events) return this;
+
+    var length = Math.max(0, arguments.length - 1);
+    var args = Array(length);
+    for (var i = 0; i < length; i++) args[i] = arguments[i + 1];
+
+    eventsApi(triggerApi, this._events, name, void 0, args);
+    return this;
+};
+
+// Handles triggering the appropriate event callbacks.
+var triggerApi = function(objEvents, name, callback, args) {
+    if (objEvents) {
+        var events = objEvents[name];
+        var 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
+// events have 3 arguments).
+var triggerEvents = function(events, args) {
+    var ev, i = -1, 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;
+    }
+};
+
+// A listening class that tracks and cleans up memory bindings
+// when all callbacks have been offed.
+var Listening = function(listener, obj) {
+    this.id = listener._listenId;
+    this.listener = listener;
+    this.obj = obj;
+    this.interop = true;
+    this.count = 0;
+    this._events = void 0;
+};
+
+Listening.prototype.on = Events.on;
+
+// Offs a callback (or several).
+// Uses an optimized counter if the listenee uses Events.
+// Otherwise, falls back to manual tracking to support events
+// library interop.
+Listening.prototype.off = function(name, callback) {
+    var cleanup;
+    if (this.interop) {
+        this._events = eventsApi(offApi, this._events, name, callback, {
+            context: void 0,
+            listeners: void 0
+        });
+        cleanup = !this._events;
+    } else {
+        this.count--;
+        cleanup = this.count === 0;
+    }
+    if (cleanup) this.cleanup();
+};
+
+// Cleans up memory bindings between the listener and the listenee.
+Listening.prototype.cleanup = function() {
+    delete this.listener._listeningTo[this.obj._listenId];
+    if (!this.interop) delete this.obj._listeners[this.id];
+};
+
+// Aliases for backwards compatibility.
+Events.bind   = Events.on;
+Events.unbind = Events.off;

package/src/mvc/Listener.mjs

@@ -0,0 +1,33 @@
+import V from '../V/index.mjs';
+import { Events } from './Events.mjs';
+
+export class Listener {
+    constructor(...callbackArguments) {
+        this.callbackArguments = callbackArguments;
+    }
+
+    listenTo(object, evt, ...args) {
+        const { callbackArguments } = this;
+        // signature 1 - (object, eventHashMap, context)
+        if (V.isObject(evt)) {
+            const [context = null] = args;
+            Object.entries(evt).forEach(([eventName, cb]) => {
+                if (typeof cb !== 'function') return;
+                // Invoke the callback with callbackArguments passed first
+                if (context || callbackArguments.length > 0) cb = cb.bind(context, ...callbackArguments);
+                Events.listenTo.call(this, object, eventName, cb);
+            });
+        }
+        // signature 2 - (object, event, callback, context)
+        else if (typeof evt === 'string' && typeof args[0] === 'function') {
+            let [cb, context = null] = args;
+            // Invoke the callback with callbackArguments passed first
+            if (context || callbackArguments.length > 0) cb = cb.bind(context, ...callbackArguments);
+            Events.listenTo.call(this, object, evt, cb);
+        }
+    }
+
+    stopListening() {
+        Events.stopListening.call(this);
+    }
+}

package/src/mvc/Model.mjs

@@ -0,0 +1,239 @@
+import { Events } from './Events.mjs';
+import { extend } from './mvcUtils.mjs';
+import {
+    assign,
+    clone,
+    defaults,
+    has,
+    isEqual,
+    isEmpty,
+    result,
+    uniqueId
+} from '../util/util.mjs';
+
+// Model
+// --------------
+
+// **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.
+
+// Create a new model with the specified attributes. A client id (`cid`)
+// is automatically generated and assigned for you.
+
+export var Model = function(attributes, options) {
+    var attrs = attributes || {};
+    options || (options = {});
+    this.preinitialize.apply(this, arguments);
+    this.cid = uniqueId(this.cidPrefix);
+    this.attributes = {};
+    if (options.collection) this.collection = options.collection;
+    var attributeDefaults = result(this, 'defaults');
+
+    // Just _.defaults would work fine, but the additional _.extends
+    // is in there for historical reasons. See #3843.
+    attrs = defaults(assign({}, attributeDefaults, attrs), attributeDefaults);
+
+    this.set(attrs, options);
+    this.changed = {};
+    this.initialize.apply(this, arguments);
+};
+
+// Attach all inheritable methods to the Model prototype.
+assign(Model.prototype, Events, {
+
+    // A hash of attributes whose current and previous value differ.
+    changed: null,
+
+    // The value returned during the last failed validation.
+    validationError: null,
+
+    // The default name for the JSON `id` attribute is `"id"`. MongoDB and
+    // CouchDB users may want to set this to `"_id"`.
+    idAttribute: 'id',
+
+    // 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.
+    cidPrefix: 'c',
+
+    // 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: function(){},
+
+    // Initialize is an empty function by default. Override it with your own
+    // initialization logic.
+    initialize: function(){},
+
+    // Return a copy of the model's `attributes` object.
+    toJSON: function(options) {
+        return clone(this.attributes);
+    },
+
+    // Get the value of an attribute.
+    get: function(attr) {
+        return this.attributes[attr];
+    },
+
+    // Returns `true` if the attribute contains a value that is not null
+    // or undefined.
+    has: function(attr) {
+        return this.get(attr) != null;
+    },
+
+    // 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.
+    set: function(key, val, options) {
+        if (key == null) return this;
+
+        // Handle both `"key", value` and `{key: value}` -style arguments.
+        var attrs;
+        if (typeof key === 'object') {
+            attrs = key;
+            options = val;
+        } else {
+            (attrs = {})[key] = val;
+        }
+
+        options || (options = {});
+
+        // Run validation.
+        if (!this._validate(attrs, options)) return false;
+
+        // Extract attributes and options.
+        var unset      = options.unset;
+        var silent     = options.silent;
+        var changes    = [];
+        var changing   = this._changing;
+        this._changing = true;
+
+        if (!changing) {
+            this._previousAttributes = clone(this.attributes);
+            this.changed = {};
+        }
+
+        var current = this.attributes;
+        var changed = this.changed;
+        var prev    = this._previousAttributes;
+
+        // For each `set` attribute, update or delete the current value.
+        for (var attr in attrs) {
+            val = attrs[attr];
+            if (!isEqual(current[attr], val)) changes.push(attr);
+            if (!isEqual(prev[attr], val)) {
+                changed[attr] = val;
+            } else {
+                delete changed[attr];
+            }
+            unset ? delete current[attr] : current[attr] = val;
+        }
+
+        // Update the `id`.
+        if (this.idAttribute in attrs) {
+            var prevId = this.id;
+            this.id = this.get(this.idAttribute);
+            this.trigger('changeId', this, prevId, options);
+        }
+
+        // Trigger all relevant attribute changes.
+        if (!silent) {
+            if (changes.length) this._pending = options;
+            for (var i = 0; i < changes.length; i++) {
+                this.trigger('change:' + changes[i], this, current[changes[i]], options);
+            }
+        }
+
+        // You might be wondering why there's a `while` loop here. Changes can
+        // be recursively nested within `"change"` events.
+        if (changing) return this;
+        if (!silent) {
+            while (this._pending) {
+                options = this._pending;
+                this._pending = false;
+                this.trigger('change', this, options);
+            }
+        }
+        this._pending = false;
+        this._changing = false;
+        return this;
+    },
+
+    // Remove an attribute from the model, firing `"change"`. `unset` is a noop
+    // if the attribute doesn't exist.
+    unset: function(attr, options) {
+        return this.set(attr, void 0, assign({}, options, { unset: true }));
+    },
+
+    // Clear all attributes on the model, firing `"change"`.
+    clear: function(options) {
+        var attrs = {};
+        for (var key in this.attributes) attrs[key] = void 0;
+        return this.set(attrs, assign({}, options, { unset: true }));
+    },
+
+    // Determine if the model has changed since the last `"change"` event.
+    // If you specify an attribute name, determine if that attribute has changed.
+    hasChanged: function(attr) {
+        if (attr == null) return !isEmpty(this.changed);
+        return has(this.changed, attr);
+    },
+
+    // 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.
+    changedAttributes: function(diff) {
+        if (!diff) return this.hasChanged() ? clone(this.changed) : false;
+        var old = this._changing ? this._previousAttributes : this.attributes;
+        var changed = {};
+        var hasChanged;
+        for (var attr in diff) {
+            var val = diff[attr];
+            if (isEqual(old[attr], val)) continue;
+            changed[attr] = val;
+            hasChanged = true;
+        }
+        return hasChanged ? changed : false;
+    },
+
+    // Get the previous value of an attribute, recorded at the time the last
+    // `"change"` event was fired.
+    previous: function(attr) {
+        if (attr == null || !this._previousAttributes) return null;
+        return this._previousAttributes[attr];
+    },
+
+    // Get all of the attributes of the model at the time of the previous
+    // `"change"` event.
+    previousAttributes: function() {
+        return clone(this._previousAttributes);
+    },
+
+    // Create a new model with identical attributes to this one.
+    clone: function() {
+        return new this.constructor(this.attributes);
+    },
+
+    // Check if the model is currently in a valid state.
+    isValid: function(options) {
+        return this._validate({}, assign({}, options, { validate: true }));
+    },
+
+    // Run validation against the next complete set of model attributes,
+    // returning `true` if all is well. Otherwise, fire an `"invalid"` event.
+    _validate: function(attrs, options) {
+        if (!options.validate || !this.validate) return true;
+        attrs = assign({}, this.attributes, attrs);
+        var error = this.validationError = this.validate(attrs, options) || null;
+        if (!error) return true;
+        this.trigger('invalid', this, error, assign(options, { validationError: error }));
+        return false;
+    }
+
+});
+
+// Set up inheritance for the model.
+Model.extend = extend;