mirror of
https://github.com/swc-project/swc.git
synced 2024-12-18 19:21:33 +03:00
710 lines
35 KiB
JavaScript
710 lines
35 KiB
JavaScript
(function() {
|
|
var Backbone, root1 = this, previousBackbone = root1.Backbone, slice = [].slice;
|
|
(Backbone = "undefined" != typeof exports ? exports : root1.Backbone = {
|
|
}).VERSION = "1.1.0";
|
|
var _ = root1._;
|
|
_ || "undefined" == typeof require || (_ = require("underscore")), Backbone.$ = root1.jQuery || root1.Zepto || root1.ender || root1.$, Backbone.noConflict = function() {
|
|
return root1.Backbone = previousBackbone, this;
|
|
}, Backbone.emulateHTTP = !1, Backbone.emulateJSON = !1;
|
|
var Events = Backbone.Events = {
|
|
on: function(name, callback, context) {
|
|
return eventsApi(this, "on", name, [
|
|
callback,
|
|
context
|
|
]) && callback && (this._events || (this._events = {
|
|
}), (this._events[name] || (this._events[name] = [])).push({
|
|
callback: callback,
|
|
context: context,
|
|
ctx: context || this
|
|
})), this;
|
|
},
|
|
once: function(name, callback, context) {
|
|
if (!eventsApi(this, "once", name, [
|
|
callback,
|
|
context
|
|
]) || !callback) return this;
|
|
var self = this, once = _.once(function() {
|
|
self.off(name, once), callback.apply(this, arguments);
|
|
});
|
|
return once._callback = callback, this.on(name, once, context);
|
|
},
|
|
off: function(name, callback, context) {
|
|
var retain, ev, events, names, i, l, j, k;
|
|
if (!this._events || !eventsApi(this, "off", name, [
|
|
callback,
|
|
context
|
|
])) return this;
|
|
if (!name && !callback && !context) return this._events = {
|
|
}, this;
|
|
for(i = 0, l = (names = name ? [
|
|
name
|
|
] : _.keys(this._events)).length; i < l; i++)if (name = names[i], events = this._events[name]) {
|
|
if (this._events[name] = retain = [], callback || context) for(j = 0, k = events.length; j < k; j++)ev = events[j], (callback && callback !== ev.callback && callback !== ev.callback._callback || context && context !== ev.context) && retain.push(ev);
|
|
retain.length || delete this._events[name];
|
|
}
|
|
return this;
|
|
},
|
|
trigger: function(name) {
|
|
if (!this._events) return this;
|
|
var args = slice.call(arguments, 1);
|
|
if (!eventsApi(this, "trigger", name, args)) return this;
|
|
var events = this._events[name], allEvents = this._events.all;
|
|
return events && triggerEvents(events, args), allEvents && triggerEvents(allEvents, arguments), this;
|
|
},
|
|
stopListening: function(obj, name, callback) {
|
|
var listeningTo = this._listeningTo;
|
|
if (!listeningTo) return this;
|
|
var remove = !name && !callback;
|
|
for(var id in callback || "object" != typeof name || (callback = this), obj && ((listeningTo = {
|
|
})[obj._listenId] = obj), listeningTo)(obj = listeningTo[id]).off(name, callback, this), (remove || _.isEmpty(obj._events)) && delete this._listeningTo[id];
|
|
return this;
|
|
}
|
|
}, eventSplitter = /\s+/, eventsApi = function(obj, action, name, rest) {
|
|
if (!name) return !0;
|
|
if ("object" == typeof name) {
|
|
for(var key in name)obj[action].apply(obj, [
|
|
key,
|
|
name[key]
|
|
].concat(rest));
|
|
return !1;
|
|
}
|
|
if (eventSplitter.test(name)) {
|
|
for(var names = name.split(eventSplitter), i = 0, l = names.length; i < l; i++)obj[action].apply(obj, [
|
|
names[i]
|
|
].concat(rest));
|
|
return !1;
|
|
}
|
|
return !0;
|
|
}, 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:
|
|
for(; ++i < l;)(ev = events[i]).callback.call(ev.ctx);
|
|
return;
|
|
case 1:
|
|
for(; ++i < l;)(ev = events[i]).callback.call(ev.ctx, a1);
|
|
return;
|
|
case 2:
|
|
for(; ++i < l;)(ev = events[i]).callback.call(ev.ctx, a1, a2);
|
|
return;
|
|
case 3:
|
|
for(; ++i < l;)(ev = events[i]).callback.call(ev.ctx, a1, a2, a3);
|
|
return;
|
|
default:
|
|
for(; ++i < l;)(ev = events[i]).callback.apply(ev.ctx, args);
|
|
}
|
|
};
|
|
_.each({
|
|
listenTo: "on",
|
|
listenToOnce: "once"
|
|
}, function(implementation, method) {
|
|
Events[method] = function(obj, name, callback) {
|
|
return (this._listeningTo || (this._listeningTo = {
|
|
}))[obj._listenId || (obj._listenId = _.uniqueId("l"))] = obj, callback || "object" != typeof name || (callback = this), obj[implementation](name, callback, this), this;
|
|
};
|
|
}), Events.bind = Events.on, Events.unbind = Events.off, _.extend(Backbone, Events);
|
|
var Model = Backbone.Model = function(attributes, options) {
|
|
var attrs = attributes || {
|
|
};
|
|
options || (options = {
|
|
}), this.cid = _.uniqueId("c"), this.attributes = {
|
|
}, options.collection && (this.collection = options.collection), options.parse && (attrs = this.parse(attrs, options) || {
|
|
}), attrs = _.defaults({
|
|
}, attrs, _.result(this, "defaults")), this.set(attrs, options), this.changed = {
|
|
}, this.initialize.apply(this, arguments);
|
|
};
|
|
_.extend(Model.prototype, Events, {
|
|
changed: null,
|
|
validationError: null,
|
|
idAttribute: "id",
|
|
initialize: function() {
|
|
},
|
|
toJSON: function(options) {
|
|
return _.clone(this.attributes);
|
|
},
|
|
sync: function() {
|
|
return Backbone.sync.apply(this, arguments);
|
|
},
|
|
get: function(attr) {
|
|
return this.attributes[attr];
|
|
},
|
|
escape: function(attr) {
|
|
return _.escape(this.get(attr));
|
|
},
|
|
has: function(attr) {
|
|
return null != this.get(attr);
|
|
},
|
|
set: function(key, val, options) {
|
|
var attr, attrs, unset, changes, silent, changing, prev, current;
|
|
if (null == key) return this;
|
|
if ("object" == typeof key ? (attrs = key, options = val) : (attrs = {
|
|
})[key] = val, options || (options = {
|
|
}), !this._validate(attrs, options)) return !1;
|
|
for(attr in unset = options.unset, silent = options.silent, changes = [], changing = this._changing, this._changing = !0, changing || (this._previousAttributes = _.clone(this.attributes), this.changed = {
|
|
}), current = this.attributes, prev = this._previousAttributes, this.idAttribute in attrs && (this.id = attrs[this.idAttribute]), attrs)val = attrs[attr], _.isEqual(current[attr], val) || changes.push(attr), _.isEqual(prev[attr], val) ? delete this.changed[attr] : this.changed[attr] = val, unset ? delete current[attr] : current[attr] = val;
|
|
if (!silent) {
|
|
changes.length && (this._pending = !0);
|
|
for(var i = 0, l = changes.length; i < l; i++)this.trigger("change:" + changes[i], this, current[changes[i]], options);
|
|
}
|
|
if (changing) return this;
|
|
if (!silent) for(; this._pending;)this._pending = !1, this.trigger("change", this, options);
|
|
return this._pending = !1, this._changing = !1, this;
|
|
},
|
|
unset: function(attr, options) {
|
|
return this.set(attr, void 0, _.extend({
|
|
}, options, {
|
|
unset: !0
|
|
}));
|
|
},
|
|
clear: function(options) {
|
|
var attrs = {
|
|
};
|
|
for(var key in this.attributes)attrs[key] = void 0;
|
|
return this.set(attrs, _.extend({
|
|
}, options, {
|
|
unset: !0
|
|
}));
|
|
},
|
|
hasChanged: function(attr) {
|
|
return null == attr ? !_.isEmpty(this.changed) : _.has(this.changed, attr);
|
|
},
|
|
changedAttributes: function(diff) {
|
|
if (!diff) return !!this.hasChanged() && _.clone(this.changed);
|
|
var val, changed = !1, old = this._changing ? this._previousAttributes : this.attributes;
|
|
for(var attr in diff)_.isEqual(old[attr], val = diff[attr]) || ((changed || (changed = {
|
|
}))[attr] = val);
|
|
return changed;
|
|
},
|
|
previous: function(attr) {
|
|
return null != attr && this._previousAttributes ? this._previousAttributes[attr] : null;
|
|
},
|
|
previousAttributes: function() {
|
|
return _.clone(this._previousAttributes);
|
|
},
|
|
fetch: function(options) {
|
|
void 0 === (options = options ? _.clone(options) : {
|
|
}).parse && (options.parse = !0);
|
|
var model = this, success = options.success;
|
|
return options.success = function(resp) {
|
|
if (!model.set(model.parse(resp, options), options)) return !1;
|
|
success && success(model, resp, options), model.trigger("sync", model, resp, options);
|
|
}, wrapError(this, options), this.sync("read", this, options);
|
|
},
|
|
save: function(key, val, options) {
|
|
var attrs, method, xhr, attributes = this.attributes;
|
|
if (null == key || "object" == typeof key ? (attrs = key, options = val) : (attrs = {
|
|
})[key] = val, options = _.extend({
|
|
validate: !0
|
|
}, options), attrs && !options.wait) {
|
|
if (!this.set(attrs, options)) return !1;
|
|
} else if (!this._validate(attrs, options)) return !1;
|
|
attrs && options.wait && (this.attributes = _.extend({
|
|
}, attributes, attrs)), void 0 === options.parse && (options.parse = !0);
|
|
var model = this, success = options.success;
|
|
return options.success = function(resp) {
|
|
model.attributes = attributes;
|
|
var serverAttrs = model.parse(resp, options);
|
|
if (options.wait && (serverAttrs = _.extend(attrs || {
|
|
}, serverAttrs)), _.isObject(serverAttrs) && !model.set(serverAttrs, options)) return !1;
|
|
success && success(model, resp, options), model.trigger("sync", model, resp, options);
|
|
}, wrapError(this, options), "patch" == (method = this.isNew() ? "create" : options.patch ? "patch" : "update") && (options.attrs = attrs), xhr = this.sync(method, this, options), attrs && options.wait && (this.attributes = attributes), xhr;
|
|
},
|
|
destroy: function(options) {
|
|
options = options ? _.clone(options) : {
|
|
};
|
|
var model = this, success = options.success, destroy = function() {
|
|
model.trigger("destroy", model, model.collection, options);
|
|
};
|
|
if (options.success = function(resp) {
|
|
(options.wait || model.isNew()) && destroy(), success && success(model, resp, options), model.isNew() || model.trigger("sync", model, resp, options);
|
|
}, this.isNew()) return options.success(), !1;
|
|
wrapError(this, options);
|
|
var xhr = this.sync("delete", this, options);
|
|
return options.wait || destroy(), xhr;
|
|
},
|
|
url: function() {
|
|
var base = _.result(this, "urlRoot") || _.result(this.collection, "url") || urlError();
|
|
return this.isNew() ? base : base + ("/" === base.charAt(base.length - 1) ? "" : "/") + encodeURIComponent(this.id);
|
|
},
|
|
parse: function(resp, options) {
|
|
return resp;
|
|
},
|
|
clone: function() {
|
|
return new this.constructor(this.attributes);
|
|
},
|
|
isNew: function() {
|
|
return null == this.id;
|
|
},
|
|
isValid: function(options) {
|
|
return this._validate({
|
|
}, _.extend(options || {
|
|
}, {
|
|
validate: !0
|
|
}));
|
|
},
|
|
_validate: function(attrs, options) {
|
|
if (!options.validate || !this.validate) return !0;
|
|
attrs = _.extend({
|
|
}, this.attributes, attrs);
|
|
var error = this.validationError = this.validate(attrs, options) || null;
|
|
return !error || (this.trigger("invalid", this, error, _.extend(options, {
|
|
validationError: error
|
|
})), !1);
|
|
}
|
|
}), _.each([
|
|
"keys",
|
|
"values",
|
|
"pairs",
|
|
"invert",
|
|
"pick",
|
|
"omit"
|
|
], function(method) {
|
|
Model.prototype[method] = function() {
|
|
var args = slice.call(arguments);
|
|
return args.unshift(this.attributes), _[method].apply(_, args);
|
|
};
|
|
});
|
|
var Collection = Backbone.Collection = function(models, options) {
|
|
options || (options = {
|
|
}), options.model && (this.model = options.model), void 0 !== options.comparator && (this.comparator = options.comparator), this._reset(), this.initialize.apply(this, arguments), models && this.reset(models, _.extend({
|
|
silent: !0
|
|
}, options));
|
|
}, setOptions = {
|
|
add: !0,
|
|
remove: !0,
|
|
merge: !0
|
|
}, addOptions = {
|
|
add: !0,
|
|
remove: !1
|
|
};
|
|
_.extend(Collection.prototype, Events, {
|
|
model: Model,
|
|
initialize: function() {
|
|
},
|
|
toJSON: function(options) {
|
|
return this.map(function(model) {
|
|
return model.toJSON(options);
|
|
});
|
|
},
|
|
sync: function() {
|
|
return Backbone.sync.apply(this, arguments);
|
|
},
|
|
add: function(models, options) {
|
|
return this.set(models, _.extend({
|
|
merge: !1
|
|
}, options, addOptions));
|
|
},
|
|
remove: function(models, options) {
|
|
var i, l, index, model, singular = !_.isArray(models);
|
|
for(options || (options = {
|
|
}), i = 0, l = (models = singular ? [
|
|
models
|
|
] : _.clone(models)).length; i < l; i++)(model = models[i] = this.get(models[i])) && (delete this._byId[model.id], delete this._byId[model.cid], index = this.indexOf(model), this.models.splice(index, 1), this.length--, options.silent || (options.index = index, model.trigger("remove", model, this, options)), this._removeReference(model));
|
|
return singular ? models[0] : models;
|
|
},
|
|
set: function(models, options) {
|
|
(options = _.defaults({
|
|
}, options, setOptions)).parse && (models = this.parse(models, options));
|
|
var i, l, id, model, attrs, existing, sort, singular = !_.isArray(models);
|
|
models = singular ? models ? [
|
|
models
|
|
] : [] : _.clone(models);
|
|
var at = options.at, targetModel = this.model, sortable = this.comparator && null == at && !1 !== options.sort, sortAttr = _.isString(this.comparator) ? this.comparator : null, toAdd = [], toRemove = [], modelMap = {
|
|
}, add = options.add, merge = options.merge, remove = options.remove, order = !sortable && !!add && !!remove && [];
|
|
for(i = 0, l = models.length; i < l; i++){
|
|
if (id = (attrs = models[i]) instanceof Model ? model = attrs : attrs[targetModel.prototype.idAttribute], existing = this.get(id)) remove && (modelMap[existing.cid] = !0), merge && (attrs = attrs === model ? model.attributes : attrs, options.parse && (attrs = existing.parse(attrs, options)), existing.set(attrs, options), sortable && !sort && existing.hasChanged(sortAttr) && (sort = !0)), models[i] = existing;
|
|
else if (add) {
|
|
if (!(model = models[i] = this._prepareModel(attrs, options))) continue;
|
|
toAdd.push(model), model.on("all", this._onModelEvent, this), this._byId[model.cid] = model, null != model.id && (this._byId[model.id] = model);
|
|
}
|
|
order && order.push(existing || model);
|
|
}
|
|
if (remove) {
|
|
for(i = 0, l = this.length; i < l; ++i)modelMap[(model = this.models[i]).cid] || toRemove.push(model);
|
|
toRemove.length && this.remove(toRemove, options);
|
|
}
|
|
if (toAdd.length || order && order.length) if (sortable && (sort = !0), this.length += toAdd.length, null != at) for(i = 0, l = toAdd.length; i < l; i++)this.models.splice(at + i, 0, toAdd[i]);
|
|
else {
|
|
order && (this.models.length = 0);
|
|
var orderedModels = order || toAdd;
|
|
for(i = 0, l = orderedModels.length; i < l; i++)this.models.push(orderedModels[i]);
|
|
}
|
|
if (sort && this.sort({
|
|
silent: !0
|
|
}), !options.silent) {
|
|
for(i = 0, l = toAdd.length; i < l; i++)(model = toAdd[i]).trigger("add", model, this, options);
|
|
(sort || order && order.length) && this.trigger("sort", this, options);
|
|
}
|
|
return singular ? models[0] : models;
|
|
},
|
|
reset: function(models, options) {
|
|
options || (options = {
|
|
});
|
|
for(var i = 0, l = this.models.length; i < l; i++)this._removeReference(this.models[i]);
|
|
return options.previousModels = this.models, this._reset(), models = this.add(models, _.extend({
|
|
silent: !0
|
|
}, options)), options.silent || this.trigger("reset", this, options), models;
|
|
},
|
|
push: function(model, options) {
|
|
return this.add(model, _.extend({
|
|
at: this.length
|
|
}, options));
|
|
},
|
|
pop: function(options) {
|
|
var model = this.at(this.length - 1);
|
|
return this.remove(model, options), model;
|
|
},
|
|
unshift: function(model, options) {
|
|
return this.add(model, _.extend({
|
|
at: 0
|
|
}, options));
|
|
},
|
|
shift: function(options) {
|
|
var model = this.at(0);
|
|
return this.remove(model, options), model;
|
|
},
|
|
slice: function() {
|
|
return slice.apply(this.models, arguments);
|
|
},
|
|
get: function(obj) {
|
|
if (null != obj) return this._byId[obj.id] || this._byId[obj.cid] || this._byId[obj];
|
|
},
|
|
at: function(index) {
|
|
return this.models[index];
|
|
},
|
|
where: function(attrs, first) {
|
|
return _.isEmpty(attrs) ? first ? void 0 : [] : this[first ? "find" : "filter"](function(model) {
|
|
for(var key in attrs)if (attrs[key] !== model.get(key)) return !1;
|
|
return !0;
|
|
});
|
|
},
|
|
findWhere: function(attrs) {
|
|
return this.where(attrs, !0);
|
|
},
|
|
sort: function(options) {
|
|
if (!this.comparator) throw new Error("Cannot sort a set without a comparator");
|
|
return options || (options = {
|
|
}), _.isString(this.comparator) || 1 === this.comparator.length ? this.models = this.sortBy(this.comparator, this) : this.models.sort(_.bind(this.comparator, this)), options.silent || this.trigger("sort", this, options), this;
|
|
},
|
|
pluck: function(attr) {
|
|
return _.invoke(this.models, "get", attr);
|
|
},
|
|
fetch: function(options) {
|
|
void 0 === (options = options ? _.clone(options) : {
|
|
}).parse && (options.parse = !0);
|
|
var success = options.success, collection = this;
|
|
return options.success = function(resp) {
|
|
collection[options.reset ? "reset" : "set"](resp, options), success && success(collection, resp, options), collection.trigger("sync", collection, resp, options);
|
|
}, wrapError(this, options), this.sync("read", this, options);
|
|
},
|
|
create: function(model1, options1) {
|
|
if (options1 = options1 ? _.clone(options1) : {
|
|
}, !(model1 = this._prepareModel(model1, options1))) return !1;
|
|
options1.wait || this.add(model1, options1);
|
|
var collection = this, success = options1.success;
|
|
return options1.success = function(model, resp, options) {
|
|
options.wait && collection.add(model, options), success && success(model, resp, options);
|
|
}, model1.save(null, options1), model1;
|
|
},
|
|
parse: function(resp, options) {
|
|
return resp;
|
|
},
|
|
clone: function() {
|
|
return new this.constructor(this.models);
|
|
},
|
|
_reset: function() {
|
|
this.length = 0, this.models = [], this._byId = {
|
|
};
|
|
},
|
|
_prepareModel: function(attrs, options) {
|
|
if (attrs instanceof Model) return attrs.collection || (attrs.collection = this), attrs;
|
|
(options = options ? _.clone(options) : {
|
|
}).collection = this;
|
|
var model = new this.model(attrs, options);
|
|
return model.validationError ? (this.trigger("invalid", this, model.validationError, options), !1) : model;
|
|
},
|
|
_removeReference: function(model) {
|
|
this === model.collection && delete model.collection, model.off("all", this._onModelEvent, this);
|
|
},
|
|
_onModelEvent: function(event, model, collection, options) {
|
|
("add" !== event && "remove" !== event || collection === this) && ("destroy" === event && this.remove(model, options), model && event === "change:" + model.idAttribute && (delete this._byId[model.previous(model.idAttribute)], null != model.id && (this._byId[model.id] = model)), this.trigger.apply(this, arguments));
|
|
}
|
|
}), _.each([
|
|
"forEach",
|
|
"each",
|
|
"map",
|
|
"collect",
|
|
"reduce",
|
|
"foldl",
|
|
"inject",
|
|
"reduceRight",
|
|
"foldr",
|
|
"find",
|
|
"detect",
|
|
"filter",
|
|
"select",
|
|
"reject",
|
|
"every",
|
|
"all",
|
|
"some",
|
|
"any",
|
|
"include",
|
|
"contains",
|
|
"invoke",
|
|
"max",
|
|
"min",
|
|
"toArray",
|
|
"size",
|
|
"first",
|
|
"head",
|
|
"take",
|
|
"initial",
|
|
"rest",
|
|
"tail",
|
|
"drop",
|
|
"last",
|
|
"without",
|
|
"difference",
|
|
"indexOf",
|
|
"shuffle",
|
|
"lastIndexOf",
|
|
"isEmpty",
|
|
"chain"
|
|
], function(method) {
|
|
Collection.prototype[method] = function() {
|
|
var args = slice.call(arguments);
|
|
return args.unshift(this.models), _[method].apply(_, args);
|
|
};
|
|
}), _.each([
|
|
"groupBy",
|
|
"countBy",
|
|
"sortBy"
|
|
], function(method) {
|
|
Collection.prototype[method] = function(value, context) {
|
|
var iterator = _.isFunction(value) ? value : function(model) {
|
|
return model.get(value);
|
|
};
|
|
return _[method](this.models, iterator, context);
|
|
};
|
|
});
|
|
var View = Backbone.View = function(options) {
|
|
this.cid = _.uniqueId("view"), options || (options = {
|
|
}), _.extend(this, _.pick(options, viewOptions)), this._ensureElement(), this.initialize.apply(this, arguments), this.delegateEvents();
|
|
}, delegateEventSplitter = /^(\S+)\s*(.*)$/, viewOptions = [
|
|
"model",
|
|
"collection",
|
|
"el",
|
|
"id",
|
|
"attributes",
|
|
"className",
|
|
"tagName",
|
|
"events"
|
|
];
|
|
_.extend(View.prototype, Events, {
|
|
tagName: "div",
|
|
$: function(selector) {
|
|
return this.$el.find(selector);
|
|
},
|
|
initialize: function() {
|
|
},
|
|
render: function() {
|
|
return this;
|
|
},
|
|
remove: function() {
|
|
return this.$el.remove(), this.stopListening(), this;
|
|
},
|
|
setElement: function(element, delegate) {
|
|
return this.$el && this.undelegateEvents(), this.$el = element instanceof Backbone.$ ? element : Backbone.$(element), this.el = this.$el[0], !1 !== delegate && this.delegateEvents(), this;
|
|
},
|
|
delegateEvents: function(events) {
|
|
if (!(events || (events = _.result(this, "events")))) return this;
|
|
for(var key in this.undelegateEvents(), events){
|
|
var method = events[key];
|
|
if (_.isFunction(method) || (method = this[events[key]]), method) {
|
|
var match = key.match(delegateEventSplitter), eventName = match[1], selector = match[2];
|
|
method = _.bind(method, this), eventName += ".delegateEvents" + this.cid, "" === selector ? this.$el.on(eventName, method) : this.$el.on(eventName, selector, method);
|
|
}
|
|
}
|
|
return this;
|
|
},
|
|
undelegateEvents: function() {
|
|
return this.$el.off(".delegateEvents" + this.cid), this;
|
|
},
|
|
_ensureElement: function() {
|
|
if (this.el) this.setElement(_.result(this, "el"), !1);
|
|
else {
|
|
var attrs = _.extend({
|
|
}, _.result(this, "attributes"));
|
|
this.id && (attrs.id = _.result(this, "id")), this.className && (attrs.class = _.result(this, "className"));
|
|
var $el = Backbone.$("<" + _.result(this, "tagName") + ">").attr(attrs);
|
|
this.setElement($el, !1);
|
|
}
|
|
}
|
|
}), Backbone.sync = function(method, model, options) {
|
|
var type = methodMap[method];
|
|
_.defaults(options || (options = {
|
|
}), {
|
|
emulateHTTP: Backbone.emulateHTTP,
|
|
emulateJSON: Backbone.emulateJSON
|
|
});
|
|
var params = {
|
|
type: type,
|
|
dataType: "json"
|
|
};
|
|
if (options.url || (params.url = _.result(model, "url") || urlError()), null == options.data && model && ("create" === method || "update" === method || "patch" === method) && (params.contentType = "application/json", params.data = JSON.stringify(options.attrs || model.toJSON(options))), options.emulateJSON && (params.contentType = "application/x-www-form-urlencoded", params.data = params.data ? {
|
|
model: params.data
|
|
} : {
|
|
}), options.emulateHTTP && ("PUT" === type || "DELETE" === type || "PATCH" === type)) {
|
|
params.type = "POST", options.emulateJSON && (params.data._method = type);
|
|
var beforeSend = options.beforeSend;
|
|
options.beforeSend = function(xhr) {
|
|
if (xhr.setRequestHeader("X-HTTP-Method-Override", type), beforeSend) return beforeSend.apply(this, arguments);
|
|
};
|
|
}
|
|
"GET" === params.type || options.emulateJSON || (params.processData = !1), "PATCH" === params.type && noXhrPatch && (params.xhr = function() {
|
|
return new ActiveXObject("Microsoft.XMLHTTP");
|
|
});
|
|
var xhr1 = options.xhr = Backbone.ajax(_.extend(params, options));
|
|
return model.trigger("request", model, xhr1, options), xhr1;
|
|
};
|
|
var noXhrPatch = "undefined" != typeof window && !!window.ActiveXObject && !(window.XMLHttpRequest && (new XMLHttpRequest).dispatchEvent), methodMap = {
|
|
create: "POST",
|
|
update: "PUT",
|
|
patch: "PATCH",
|
|
"delete": "DELETE",
|
|
read: "GET"
|
|
};
|
|
Backbone.ajax = function() {
|
|
return Backbone.$.ajax.apply(Backbone.$, arguments);
|
|
};
|
|
var Router = Backbone.Router = function(options) {
|
|
options || (options = {
|
|
}), options.routes && (this.routes = options.routes), this._bindRoutes(), this.initialize.apply(this, arguments);
|
|
}, optionalParam = /\((.*?)\)/g, namedParam = /(\(\?)?:\w+/g, splatParam = /\*\w+/g, escapeRegExp = /[\-{}\[\]+?.,\\\^$|#\s]/g;
|
|
_.extend(Router.prototype, Events, {
|
|
initialize: function() {
|
|
},
|
|
route: function(route, name, callback) {
|
|
_.isRegExp(route) || (route = this._routeToRegExp(route)), _.isFunction(name) && (callback = name, name = ""), callback || (callback = this[name]);
|
|
var router = this;
|
|
return Backbone.history.route(route, function(fragment) {
|
|
var args = router._extractParameters(route, fragment);
|
|
callback && callback.apply(router, args), router.trigger.apply(router, [
|
|
"route:" + name
|
|
].concat(args)), router.trigger("route", name, args), Backbone.history.trigger("route", router, name, args);
|
|
}), this;
|
|
},
|
|
navigate: function(fragment, options) {
|
|
return Backbone.history.navigate(fragment, options), this;
|
|
},
|
|
_bindRoutes: function() {
|
|
if (this.routes) {
|
|
this.routes = _.result(this, "routes");
|
|
for(var route, routes = _.keys(this.routes); null != (route = routes.pop());)this.route(route, this.routes[route]);
|
|
}
|
|
},
|
|
_routeToRegExp: function(route) {
|
|
return route = route.replace(escapeRegExp, "\\$&").replace(optionalParam, "(?:$1)?").replace(namedParam, function(match, optional) {
|
|
return optional ? match : "([^/]+)";
|
|
}).replace(splatParam, "(.*?)"), new RegExp("^" + route + "$");
|
|
},
|
|
_extractParameters: function(route, fragment) {
|
|
var params = route.exec(fragment).slice(1);
|
|
return _.map(params, function(param) {
|
|
return param ? decodeURIComponent(param) : null;
|
|
});
|
|
}
|
|
});
|
|
var History = Backbone.History = function() {
|
|
this.handlers = [], _.bindAll(this, "checkUrl"), "undefined" != typeof window && (this.location = window.location, this.history = window.history);
|
|
}, routeStripper = /^[#\/]|\s+$/g, rootStripper = /^\/+|\/+$/g, isExplorer = /msie [\w.]+/, trailingSlash = /\/$/, pathStripper = /[?#].*$/;
|
|
History.started = !1, _.extend(History.prototype, Events, {
|
|
interval: 50,
|
|
getHash: function(window) {
|
|
var match = (window || this).location.href.match(/#(.*)$/);
|
|
return match ? match[1] : "";
|
|
},
|
|
getFragment: function(fragment, forcePushState) {
|
|
if (null == fragment) if (this._hasPushState || !this._wantsHashChange || forcePushState) {
|
|
fragment = this.location.pathname;
|
|
var root = this.root.replace(trailingSlash, "");
|
|
fragment.indexOf(root) || (fragment = fragment.slice(root.length));
|
|
} else fragment = this.getHash();
|
|
return fragment.replace(routeStripper, "");
|
|
},
|
|
start: function(options) {
|
|
if (History.started) throw new Error("Backbone.history has already been started");
|
|
History.started = !0, this.options = _.extend({
|
|
root: "/"
|
|
}, this.options, options), this.root = this.options.root, this._wantsHashChange = !1 !== this.options.hashChange, this._wantsPushState = !!this.options.pushState, this._hasPushState = !!(this.options.pushState && this.history && this.history.pushState);
|
|
var fragment = this.getFragment(), docMode = document.documentMode, oldIE = isExplorer.exec(navigator.userAgent.toLowerCase()) && (!docMode || docMode <= 7);
|
|
this.root = ("/" + this.root + "/").replace(rootStripper, "/"), oldIE && this._wantsHashChange && (this.iframe = Backbone.$("<iframe src=\"javascript:0\" tabindex=\"-1\" />").hide().appendTo("body")[0].contentWindow, this.navigate(fragment)), this._hasPushState ? Backbone.$(window).on("popstate", this.checkUrl) : this._wantsHashChange && "onhashchange" in window && !oldIE ? Backbone.$(window).on("hashchange", this.checkUrl) : this._wantsHashChange && (this._checkUrlInterval = setInterval(this.checkUrl, this.interval)), this.fragment = fragment;
|
|
var loc = this.location, atRoot = loc.pathname.replace(/[^\/]$/, "$&/") === this.root;
|
|
if (this._wantsHashChange && this._wantsPushState) {
|
|
if (!this._hasPushState && !atRoot) return this.fragment = this.getFragment(null, !0), this.location.replace(this.root + this.location.search + "#" + this.fragment), !0;
|
|
this._hasPushState && atRoot && loc.hash && (this.fragment = this.getHash().replace(routeStripper, ""), this.history.replaceState({
|
|
}, document.title, this.root + this.fragment + loc.search));
|
|
}
|
|
if (!this.options.silent) return this.loadUrl();
|
|
},
|
|
stop: function() {
|
|
Backbone.$(window).off("popstate", this.checkUrl).off("hashchange", this.checkUrl), clearInterval(this._checkUrlInterval), History.started = !1;
|
|
},
|
|
route: function(route, callback) {
|
|
this.handlers.unshift({
|
|
route: route,
|
|
callback: callback
|
|
});
|
|
},
|
|
checkUrl: function(e) {
|
|
var current = this.getFragment();
|
|
if (current === this.fragment && this.iframe && (current = this.getFragment(this.getHash(this.iframe))), current === this.fragment) return !1;
|
|
this.iframe && this.navigate(current), this.loadUrl();
|
|
},
|
|
loadUrl: function(fragment) {
|
|
return fragment = this.fragment = this.getFragment(fragment), _.any(this.handlers, function(handler) {
|
|
if (handler.route.test(fragment)) return handler.callback(fragment), !0;
|
|
});
|
|
},
|
|
navigate: function(fragment, options) {
|
|
if (!History.started) return !1;
|
|
options && !0 !== options || (options = {
|
|
trigger: !!options
|
|
});
|
|
var url = this.root + (fragment = this.getFragment(fragment || ""));
|
|
if (fragment = fragment.replace(pathStripper, ""), this.fragment !== fragment) {
|
|
if (this.fragment = fragment, "" === fragment && "/" !== url && (url = url.slice(0, -1)), this._hasPushState) this.history[options.replace ? "replaceState" : "pushState"]({
|
|
}, document.title, url);
|
|
else {
|
|
if (!this._wantsHashChange) return this.location.assign(url);
|
|
this._updateHash(this.location, fragment, options.replace), this.iframe && fragment !== this.getFragment(this.getHash(this.iframe)) && (options.replace || this.iframe.document.open().close(), this._updateHash(this.iframe.location, fragment, options.replace));
|
|
}
|
|
if (options.trigger) return this.loadUrl(fragment);
|
|
}
|
|
},
|
|
_updateHash: function(location, fragment, replace) {
|
|
if (replace) {
|
|
var href = location.href.replace(/(javascript:|#).*$/, "");
|
|
location.replace(href + "#" + fragment);
|
|
} else location.hash = "#" + fragment;
|
|
}
|
|
}), Backbone.history = new History, Model.extend = Collection.extend = Router.extend = View.extend = History.extend = function(protoProps, staticProps) {
|
|
var child, parent = this;
|
|
child = protoProps && _.has(protoProps, "constructor") ? protoProps.constructor : function() {
|
|
return parent.apply(this, arguments);
|
|
}, _.extend(child, parent, staticProps);
|
|
var Surrogate = function() {
|
|
this.constructor = child;
|
|
};
|
|
return Surrogate.prototype = parent.prototype, child.prototype = new Surrogate, protoProps && _.extend(child.prototype, protoProps), child.__super__ = parent.prototype, child;
|
|
};
|
|
var urlError = function() {
|
|
throw new Error("A \"url\" property or function must be specified");
|
|
}, wrapError = function(model, options) {
|
|
var error = options.error;
|
|
options.error = function(resp) {
|
|
error && error(model, resp, options), model.trigger("error", model, resp, options);
|
|
};
|
|
};
|
|
}).call(this);
|