ArturBaybulatov
10 years ago
parent
311b67f408
commit
595cb43dab
10 changed files with 17509 additions and 85 deletions
@ -1,46 +1,27 @@ |
|||||||
window.g = window |
//$('#realtyId').on('change', function(evt) {
|
||||||
|
// var realtyId = Number($(this).val())
|
||||||
var app = angular.module('app', []) |
//
|
||||||
|
// if (realtyId) {
|
||||||
|
// loadRealtyDetails(realtyId).then(function(res) {
|
||||||
app.config(['$interpolateProvider', '$httpProvider', |
// $('#realtyName').val(res.name)
|
||||||
function($interpolateProvider, $httpProvider) { |
// $('#realtyBuildingClassificationId').val(res.building_classification.id).change()
|
||||||
$interpolateProvider.startSymbol('{(') |
// $('#realtyConstructionTypeId').val(res.construction_type.id).change()
|
||||||
$interpolateProvider.endSymbol(')}') |
// $('#realtyLocationId').val(res.location.id).change()
|
||||||
|
// })
|
||||||
$httpProvider.defaults.xsrfCookieName = 'csrftoken' |
// } else {
|
||||||
$httpProvider.defaults.xsrfHeaderName = 'X-CSRFToken' |
// $('#realtyName').val('')
|
||||||
|
// $('#realtyBuildingClassificationId').val('').change()
|
||||||
$httpProvider.defaults.headers.common['X-Requested-With'] = 'XMLHttpRequest' |
// $('#realtyConstructionTypeId').val('').change()
|
||||||
|
// $('#realtyLocationId').val('').change()
|
||||||
//$routeProvider.when('/', {templateUrl: '.....'})
|
// }
|
||||||
}, |
//})
|
||||||
]) |
//
|
||||||
|
//function loadRealtyDetails(realtyId) {
|
||||||
|
// return $.ajax({
|
||||||
app.run(['$rootScope', '$timeout', '$http', |
// url: '/api/realties/' + realtyId + '/',
|
||||||
function run($rootScope, $timeout, $http) { |
// method: 'GET',
|
||||||
g.$http = $http // Debug
|
// dataType: 'json',
|
||||||
g.$timeout = $timeout // Debug
|
// })
|
||||||
}, |
// .then(function(res) {return res})
|
||||||
]) |
// .fail(function() {console.error('Failed', arguments)})
|
||||||
|
//}
|
||||||
|
|
||||||
app.controller('TestCtrl', ['$scope', '$http', function TestCtrl($scope, $http) { |
|
||||||
var test = g.test = this |
|
||||||
|
|
||||||
//$http.get('/api/users/?is_admin=False').then(function(res) {
|
|
||||||
// test.users = res.data.results
|
|
||||||
//})
|
|
||||||
|
|
||||||
test.x = null |
|
||||||
|
|
||||||
$scope.$watch( |
|
||||||
function() {return test.x}, |
|
||||||
|
|
||||||
function(newVal, oldVal) { |
|
||||||
if (newVal !== oldVal) |
|
||||||
console.log(test.x) |
|
||||||
} |
|
||||||
) |
|
||||||
}]) |
|
||||||
|
|||||||
@ -0,0 +1,990 @@ |
|||||||
|
(function webpackUniversalModuleDefinition(root, factory) { |
||||||
|
if(typeof exports === 'object' && typeof module === 'object') |
||||||
|
module.exports = factory(); |
||||||
|
else if(typeof define === 'function' && define.amd) |
||||||
|
define([], factory); |
||||||
|
else if(typeof exports === 'object') |
||||||
|
exports["fp"] = factory(); |
||||||
|
else |
||||||
|
root["fp"] = factory(); |
||||||
|
})(this, function() { |
||||||
|
return /******/ (function(modules) { // webpackBootstrap
|
||||||
|
/******/ // The module cache
|
||||||
|
/******/ var installedModules = {}; |
||||||
|
|
||||||
|
/******/ // The require function
|
||||||
|
/******/ function __webpack_require__(moduleId) { |
||||||
|
|
||||||
|
/******/ // Check if module is in cache
|
||||||
|
/******/ if(installedModules[moduleId]) |
||||||
|
/******/ return installedModules[moduleId].exports; |
||||||
|
|
||||||
|
/******/ // Create a new module (and put it into the cache)
|
||||||
|
/******/ var module = installedModules[moduleId] = { |
||||||
|
/******/ exports: {}, |
||||||
|
/******/ id: moduleId, |
||||||
|
/******/ loaded: false |
||||||
|
/******/ }; |
||||||
|
|
||||||
|
/******/ // Execute the module function
|
||||||
|
/******/ modules[moduleId].call(module.exports, module, module.exports, __webpack_require__); |
||||||
|
|
||||||
|
/******/ // Flag the module as loaded
|
||||||
|
/******/ module.loaded = true; |
||||||
|
|
||||||
|
/******/ // Return the exports of the module
|
||||||
|
/******/ return module.exports; |
||||||
|
/******/ } |
||||||
|
|
||||||
|
|
||||||
|
/******/ // expose the modules object (__webpack_modules__)
|
||||||
|
/******/ __webpack_require__.m = modules; |
||||||
|
|
||||||
|
/******/ // expose the module cache
|
||||||
|
/******/ __webpack_require__.c = installedModules; |
||||||
|
|
||||||
|
/******/ // __webpack_public_path__
|
||||||
|
/******/ __webpack_require__.p = ""; |
||||||
|
|
||||||
|
/******/ // Load entry module and return exports
|
||||||
|
/******/ return __webpack_require__(0); |
||||||
|
/******/ }) |
||||||
|
/************************************************************************/ |
||||||
|
/******/ ([ |
||||||
|
/* 0 */ |
||||||
|
/***/ function(module, exports, __webpack_require__) { |
||||||
|
|
||||||
|
var baseConvert = __webpack_require__(1); |
||||||
|
|
||||||
|
/** |
||||||
|
* Converts `lodash` to an immutable auto-curried iteratee-first data-last |
||||||
|
* version with conversion `options` applied. |
||||||
|
* |
||||||
|
* @param {Function} lodash The lodash function to convert. |
||||||
|
* @param {Object} [options] The options object. See `baseConvert` for more details. |
||||||
|
* @returns {Function} Returns the converted `lodash`. |
||||||
|
*/ |
||||||
|
function browserConvert(lodash, options) { |
||||||
|
return baseConvert(lodash, lodash, options); |
||||||
|
} |
||||||
|
|
||||||
|
if (typeof _ == 'function') { |
||||||
|
_ = browserConvert(_.runInContext()); |
||||||
|
} |
||||||
|
module.exports = browserConvert; |
||||||
|
|
||||||
|
|
||||||
|
/***/ }, |
||||||
|
/* 1 */ |
||||||
|
/***/ function(module, exports, __webpack_require__) { |
||||||
|
|
||||||
|
var mapping = __webpack_require__(2), |
||||||
|
mutateMap = mapping.mutate, |
||||||
|
fallbackHolder = __webpack_require__(3); |
||||||
|
|
||||||
|
/** |
||||||
|
* Creates a function, with an arity of `n`, that invokes `func` with the |
||||||
|
* arguments it receives. |
||||||
|
* |
||||||
|
* @private |
||||||
|
* @param {Function} func The function to wrap. |
||||||
|
* @param {number} n The arity of the new function. |
||||||
|
* @returns {Function} Returns the new function. |
||||||
|
*/ |
||||||
|
function baseArity(func, n) { |
||||||
|
return n == 2 |
||||||
|
? function(a, b) { return func.apply(undefined, arguments); } |
||||||
|
: function(a) { return func.apply(undefined, arguments); }; |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* Creates a function that invokes `func`, with up to `n` arguments, ignoring |
||||||
|
* any additional arguments. |
||||||
|
* |
||||||
|
* @private |
||||||
|
* @param {Function} func The function to cap arguments for. |
||||||
|
* @param {number} n The arity cap. |
||||||
|
* @returns {Function} Returns the new function. |
||||||
|
*/ |
||||||
|
function baseAry(func, n) { |
||||||
|
return n == 2 |
||||||
|
? function(a, b) { return func(a, b); } |
||||||
|
: function(a) { return func(a); }; |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* Creates a clone of `array`. |
||||||
|
* |
||||||
|
* @private |
||||||
|
* @param {Array} array The array to clone. |
||||||
|
* @returns {Array} Returns the cloned array. |
||||||
|
*/ |
||||||
|
function cloneArray(array) { |
||||||
|
var length = array ? array.length : 0, |
||||||
|
result = Array(length); |
||||||
|
|
||||||
|
while (length--) { |
||||||
|
result[length] = array[length]; |
||||||
|
} |
||||||
|
return result; |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* Creates a function that clones a given object using the assignment `func`. |
||||||
|
* |
||||||
|
* @private |
||||||
|
* @param {Function} func The assignment function. |
||||||
|
* @returns {Function} Returns the new cloner function. |
||||||
|
*/ |
||||||
|
function createCloner(func) { |
||||||
|
return function(object) { |
||||||
|
return func({}, object); |
||||||
|
}; |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* Creates a function that wraps `func` and uses `cloner` to clone the first |
||||||
|
* argument it receives. |
||||||
|
* |
||||||
|
* @private |
||||||
|
* @param {Function} func The function to wrap. |
||||||
|
* @param {Function} cloner The function to clone arguments. |
||||||
|
* @returns {Function} Returns the new immutable function. |
||||||
|
*/ |
||||||
|
function wrapImmutable(func, cloner) { |
||||||
|
return function() { |
||||||
|
var length = arguments.length; |
||||||
|
if (!length) { |
||||||
|
return; |
||||||
|
} |
||||||
|
var args = Array(length); |
||||||
|
while (length--) { |
||||||
|
args[length] = arguments[length]; |
||||||
|
} |
||||||
|
var result = args[0] = cloner.apply(undefined, args); |
||||||
|
func.apply(undefined, args); |
||||||
|
return result; |
||||||
|
}; |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* The base implementation of `convert` which accepts a `util` object of methods |
||||||
|
* required to perform conversions. |
||||||
|
* |
||||||
|
* @param {Object} util The util object. |
||||||
|
* @param {string} name The name of the function to convert. |
||||||
|
* @param {Function} func The function to convert. |
||||||
|
* @param {Object} [options] The options object. |
||||||
|
* @param {boolean} [options.cap=true] Specify capping iteratee arguments. |
||||||
|
* @param {boolean} [options.curry=true] Specify currying. |
||||||
|
* @param {boolean} [options.fixed=true] Specify fixed arity. |
||||||
|
* @param {boolean} [options.immutable=true] Specify immutable operations. |
||||||
|
* @param {boolean} [options.rearg=true] Specify rearranging arguments. |
||||||
|
* @returns {Function|Object} Returns the converted function or object. |
||||||
|
*/ |
||||||
|
function baseConvert(util, name, func, options) { |
||||||
|
var setPlaceholder, |
||||||
|
isLib = typeof name == 'function', |
||||||
|
isObj = name === Object(name); |
||||||
|
|
||||||
|
if (isObj) { |
||||||
|
options = func; |
||||||
|
func = name; |
||||||
|
name = undefined; |
||||||
|
} |
||||||
|
if (func == null) { |
||||||
|
throw new TypeError; |
||||||
|
} |
||||||
|
options || (options = {}); |
||||||
|
|
||||||
|
var config = { |
||||||
|
'cap': 'cap' in options ? options.cap : true, |
||||||
|
'curry': 'curry' in options ? options.curry : true, |
||||||
|
'fixed': 'fixed' in options ? options.fixed : true, |
||||||
|
'immutable': 'immutable' in options ? options.immutable : true, |
||||||
|
'rearg': 'rearg' in options ? options.rearg : true |
||||||
|
}; |
||||||
|
|
||||||
|
var forceCurry = ('curry' in options) && options.curry, |
||||||
|
forceFixed = ('fixed' in options) && options.fixed, |
||||||
|
forceRearg = ('rearg' in options) && options.rearg, |
||||||
|
placeholder = isLib ? func : fallbackHolder, |
||||||
|
pristine = isLib ? func.runInContext() : undefined; |
||||||
|
|
||||||
|
var helpers = isLib ? func : { |
||||||
|
'ary': util.ary, |
||||||
|
'assign': util.assign, |
||||||
|
'clone': util.clone, |
||||||
|
'curry': util.curry, |
||||||
|
'forEach': util.forEach, |
||||||
|
'isArray': util.isArray, |
||||||
|
'isFunction': util.isFunction, |
||||||
|
'iteratee': util.iteratee, |
||||||
|
'keys': util.keys, |
||||||
|
'rearg': util.rearg, |
||||||
|
'spread': util.spread, |
||||||
|
'toPath': util.toPath |
||||||
|
}; |
||||||
|
|
||||||
|
var ary = helpers.ary, |
||||||
|
assign = helpers.assign, |
||||||
|
clone = helpers.clone, |
||||||
|
curry = helpers.curry, |
||||||
|
each = helpers.forEach, |
||||||
|
isArray = helpers.isArray, |
||||||
|
isFunction = helpers.isFunction, |
||||||
|
keys = helpers.keys, |
||||||
|
rearg = helpers.rearg, |
||||||
|
spread = helpers.spread, |
||||||
|
toPath = helpers.toPath; |
||||||
|
|
||||||
|
var aryMethodKeys = keys(mapping.aryMethod); |
||||||
|
|
||||||
|
var wrappers = { |
||||||
|
'castArray': function(castArray) { |
||||||
|
return function() { |
||||||
|
var value = arguments[0]; |
||||||
|
return isArray(value) |
||||||
|
? castArray(cloneArray(value)) |
||||||
|
: castArray.apply(undefined, arguments); |
||||||
|
}; |
||||||
|
}, |
||||||
|
'iteratee': function(iteratee) { |
||||||
|
return function() { |
||||||
|
var func = arguments[0], |
||||||
|
arity = arguments[1], |
||||||
|
result = iteratee(func, arity), |
||||||
|
length = result.length; |
||||||
|
|
||||||
|
if (config.cap && typeof arity == 'number') { |
||||||
|
arity = arity > 2 ? (arity - 2) : 1; |
||||||
|
return (length && length <= arity) ? result : baseAry(result, arity); |
||||||
|
} |
||||||
|
return result; |
||||||
|
}; |
||||||
|
}, |
||||||
|
'mixin': function(mixin) { |
||||||
|
return function(source) { |
||||||
|
var func = this; |
||||||
|
if (!isFunction(func)) { |
||||||
|
return mixin(func, Object(source)); |
||||||
|
} |
||||||
|
var pairs = []; |
||||||
|
each(keys(source), function(key) { |
||||||
|
if (isFunction(source[key])) { |
||||||
|
pairs.push([key, func.prototype[key]]); |
||||||
|
} |
||||||
|
}); |
||||||
|
|
||||||
|
mixin(func, Object(source)); |
||||||
|
|
||||||
|
each(pairs, function(pair) { |
||||||
|
var value = pair[1]; |
||||||
|
if (isFunction(value)) { |
||||||
|
func.prototype[pair[0]] = value; |
||||||
|
} else { |
||||||
|
delete func.prototype[pair[0]]; |
||||||
|
} |
||||||
|
}); |
||||||
|
return func; |
||||||
|
}; |
||||||
|
}, |
||||||
|
'rearg': function(rearg) { |
||||||
|
return function(func, indexes) { |
||||||
|
var n = indexes ? indexes.length : 0; |
||||||
|
return curry(rearg(func, indexes), n); |
||||||
|
}; |
||||||
|
}, |
||||||
|
'runInContext': function(runInContext) { |
||||||
|
return function(context) { |
||||||
|
return baseConvert(util, runInContext(context), options); |
||||||
|
}; |
||||||
|
} |
||||||
|
}; |
||||||
|
|
||||||
|
/*--------------------------------------------------------------------------*/ |
||||||
|
|
||||||
|
/** |
||||||
|
* Casts `func` to a function with an arity capped iteratee if needed. |
||||||
|
* |
||||||
|
* @private |
||||||
|
* @param {string} name The name of the function to inspect. |
||||||
|
* @param {Function} func The function to inspect. |
||||||
|
* @returns {Function} Returns the cast function. |
||||||
|
*/ |
||||||
|
function castCap(name, func) { |
||||||
|
if (config.cap) { |
||||||
|
var indexes = mapping.iterateeRearg[name]; |
||||||
|
if (indexes) { |
||||||
|
return iterateeRearg(func, indexes); |
||||||
|
} |
||||||
|
var n = !isLib && mapping.iterateeAry[name]; |
||||||
|
if (n) { |
||||||
|
return iterateeAry(func, n); |
||||||
|
} |
||||||
|
} |
||||||
|
return func; |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* Casts `func` to a curried function if needed. |
||||||
|
* |
||||||
|
* @private |
||||||
|
* @param {string} name The name of the function to inspect. |
||||||
|
* @param {Function} func The function to inspect. |
||||||
|
* @param {number} n The arity of `func`. |
||||||
|
* @returns {Function} Returns the cast function. |
||||||
|
*/ |
||||||
|
function castCurry(name, func, n) { |
||||||
|
return (forceCurry || (config.curry && n > 1)) |
||||||
|
? curry(func, n) |
||||||
|
: func; |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* Casts `func` to a fixed arity function if needed. |
||||||
|
* |
||||||
|
* @private |
||||||
|
* @param {string} name The name of the function to inspect. |
||||||
|
* @param {Function} func The function to inspect. |
||||||
|
* @param {number} n The arity cap. |
||||||
|
* @returns {Function} Returns the cast function. |
||||||
|
*/ |
||||||
|
function castFixed(name, func, n) { |
||||||
|
if (config.fixed && (forceFixed || !mapping.skipFixed[name])) { |
||||||
|
var data = mapping.methodSpread[name], |
||||||
|
start = data && data.start; |
||||||
|
|
||||||
|
return start === undefined ? ary(func, n) : spread(func, start); |
||||||
|
} |
||||||
|
return func; |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* Casts `func` to an rearged function if needed. |
||||||
|
* |
||||||
|
* @private |
||||||
|
* @param {string} name The name of the function to inspect. |
||||||
|
* @param {Function} func The function to inspect. |
||||||
|
* @param {number} n The arity of `func`. |
||||||
|
* @returns {Function} Returns the cast function. |
||||||
|
*/ |
||||||
|
function castRearg(name, func, n) { |
||||||
|
return (config.rearg && n > 1 && (forceRearg || !mapping.skipRearg[name])) |
||||||
|
? rearg(func, mapping.methodRearg[name] || mapping.aryRearg[n]) |
||||||
|
: func; |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* Creates a clone of `object` by `path`. |
||||||
|
* |
||||||
|
* @private |
||||||
|
* @param {Object} object The object to clone. |
||||||
|
* @param {Array|string} path The path to clone by. |
||||||
|
* @returns {Object} Returns the cloned object. |
||||||
|
*/ |
||||||
|
function cloneByPath(object, path) { |
||||||
|
path = toPath(path); |
||||||
|
|
||||||
|
var index = -1, |
||||||
|
length = path.length, |
||||||
|
lastIndex = length - 1, |
||||||
|
result = clone(Object(object)), |
||||||
|
nested = result; |
||||||
|
|
||||||
|
while (nested != null && ++index < length) { |
||||||
|
var key = path[index], |
||||||
|
value = nested[key]; |
||||||
|
|
||||||
|
if (value != null) { |
||||||
|
nested[path[index]] = clone(index == lastIndex ? value : Object(value)); |
||||||
|
} |
||||||
|
nested = nested[key]; |
||||||
|
} |
||||||
|
return result; |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* Converts `lodash` to an immutable auto-curried iteratee-first data-last |
||||||
|
* version with conversion `options` applied. |
||||||
|
* |
||||||
|
* @param {Object} [options] The options object. See `baseConvert` for more details. |
||||||
|
* @returns {Function} Returns the converted `lodash`. |
||||||
|
*/ |
||||||
|
function convertLib(options) { |
||||||
|
return _.runInContext.convert(options)(undefined); |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* Create a converter function for `func` of `name`. |
||||||
|
* |
||||||
|
* @param {string} name The name of the function to convert. |
||||||
|
* @param {Function} func The function to convert. |
||||||
|
* @returns {Function} Returns the new converter function. |
||||||
|
*/ |
||||||
|
function createConverter(name, func) { |
||||||
|
var oldOptions = options; |
||||||
|
return function(options) { |
||||||
|
var newUtil = isLib ? pristine : helpers, |
||||||
|
newFunc = isLib ? pristine[name] : func, |
||||||
|
newOptions = assign(assign({}, oldOptions), options); |
||||||
|
|
||||||
|
return baseConvert(newUtil, name, newFunc, newOptions); |
||||||
|
}; |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* Creates a function that wraps `func` to invoke its iteratee, with up to `n` |
||||||
|
* arguments, ignoring any additional arguments. |
||||||
|
* |
||||||
|
* @private |
||||||
|
* @param {Function} func The function to cap iteratee arguments for. |
||||||
|
* @param {number} n The arity cap. |
||||||
|
* @returns {Function} Returns the new function. |
||||||
|
*/ |
||||||
|
function iterateeAry(func, n) { |
||||||
|
return overArg(func, function(func) { |
||||||
|
return typeof func == 'function' ? baseAry(func, n) : func; |
||||||
|
}); |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* Creates a function that wraps `func` to invoke its iteratee with arguments |
||||||
|
* arranged according to the specified `indexes` where the argument value at |
||||||
|
* the first index is provided as the first argument, the argument value at |
||||||
|
* the second index is provided as the second argument, and so on. |
||||||
|
* |
||||||
|
* @private |
||||||
|
* @param {Function} func The function to rearrange iteratee arguments for. |
||||||
|
* @param {number[]} indexes The arranged argument indexes. |
||||||
|
* @returns {Function} Returns the new function. |
||||||
|
*/ |
||||||
|
function iterateeRearg(func, indexes) { |
||||||
|
return overArg(func, function(func) { |
||||||
|
var n = indexes.length; |
||||||
|
return baseArity(rearg(baseAry(func, n), indexes), n); |
||||||
|
}); |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* Creates a function that invokes `func` with its first argument transformed. |
||||||
|
* |
||||||
|
* @private |
||||||
|
* @param {Function} func The function to wrap. |
||||||
|
* @param {Function} transform The argument transform. |
||||||
|
* @returns {Function} Returns the new function. |
||||||
|
*/ |
||||||
|
function overArg(func, transform) { |
||||||
|
return function() { |
||||||
|
var length = arguments.length; |
||||||
|
if (!length) { |
||||||
|
return func(); |
||||||
|
} |
||||||
|
var args = Array(length); |
||||||
|
while (length--) { |
||||||
|
args[length] = arguments[length]; |
||||||
|
} |
||||||
|
var index = config.rearg ? 0 : (length - 1); |
||||||
|
args[index] = transform(args[index]); |
||||||
|
return func.apply(undefined, args); |
||||||
|
}; |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* Creates a function that wraps `func` and applys the conversions |
||||||
|
* rules by `name`. |
||||||
|
* |
||||||
|
* @private |
||||||
|
* @param {string} name The name of the function to wrap. |
||||||
|
* @param {Function} func The function to wrap. |
||||||
|
* @returns {Function} Returns the converted function. |
||||||
|
*/ |
||||||
|
function wrap(name, func) { |
||||||
|
name = mapping.aliasToReal[name] || name; |
||||||
|
|
||||||
|
var result, |
||||||
|
wrapped = func, |
||||||
|
wrapper = wrappers[name]; |
||||||
|
|
||||||
|
if (wrapper) { |
||||||
|
wrapped = wrapper(func); |
||||||
|
} |
||||||
|
else if (config.immutable) { |
||||||
|
if (mutateMap.array[name]) { |
||||||
|
wrapped = wrapImmutable(func, cloneArray); |
||||||
|
} |
||||||
|
else if (mutateMap.object[name]) { |
||||||
|
wrapped = wrapImmutable(func, createCloner(func)); |
||||||
|
} |
||||||
|
else if (mutateMap.set[name]) { |
||||||
|
wrapped = wrapImmutable(func, cloneByPath); |
||||||
|
} |
||||||
|
} |
||||||
|
each(aryMethodKeys, function(aryKey) { |
||||||
|
each(mapping.aryMethod[aryKey], function(otherName) { |
||||||
|
if (name == otherName) { |
||||||
|
var spreadData = mapping.methodSpread[name], |
||||||
|
afterRearg = spreadData && spreadData.afterRearg; |
||||||
|
|
||||||
|
result = afterRearg |
||||||
|
? castFixed(name, castRearg(name, wrapped, aryKey), aryKey) |
||||||
|
: castRearg(name, castFixed(name, wrapped, aryKey), aryKey); |
||||||
|
|
||||||
|
result = castCap(name, result); |
||||||
|
result = castCurry(name, result, aryKey); |
||||||
|
return false; |
||||||
|
} |
||||||
|
}); |
||||||
|
return !result; |
||||||
|
}); |
||||||
|
|
||||||
|
result || (result = wrapped); |
||||||
|
if (result == func) { |
||||||
|
result = forceCurry ? curry(result, 1) : function() { |
||||||
|
return func.apply(this, arguments); |
||||||
|
}; |
||||||
|
} |
||||||
|
result.convert = createConverter(name, func); |
||||||
|
if (mapping.placeholder[name]) { |
||||||
|
setPlaceholder = true; |
||||||
|
result.placeholder = func.placeholder = placeholder; |
||||||
|
} |
||||||
|
return result; |
||||||
|
} |
||||||
|
|
||||||
|
/*--------------------------------------------------------------------------*/ |
||||||
|
|
||||||
|
if (!isObj) { |
||||||
|
return wrap(name, func); |
||||||
|
} |
||||||
|
var _ = func; |
||||||
|
|
||||||
|
// Convert methods by ary cap.
|
||||||
|
var pairs = []; |
||||||
|
each(aryMethodKeys, function(aryKey) { |
||||||
|
each(mapping.aryMethod[aryKey], function(key) { |
||||||
|
var func = _[mapping.remap[key] || key]; |
||||||
|
if (func) { |
||||||
|
pairs.push([key, wrap(key, func)]); |
||||||
|
} |
||||||
|
}); |
||||||
|
}); |
||||||
|
|
||||||
|
// Convert remaining methods.
|
||||||
|
each(keys(_), function(key) { |
||||||
|
var func = _[key]; |
||||||
|
if (typeof func == 'function') { |
||||||
|
var length = pairs.length; |
||||||
|
while (length--) { |
||||||
|
if (pairs[length][0] == key) { |
||||||
|
return; |
||||||
|
} |
||||||
|
} |
||||||
|
func.convert = createConverter(key, func); |
||||||
|
pairs.push([key, func]); |
||||||
|
} |
||||||
|
}); |
||||||
|
|
||||||
|
// Assign to `_` leaving `_.prototype` unchanged to allow chaining.
|
||||||
|
each(pairs, function(pair) { |
||||||
|
_[pair[0]] = pair[1]; |
||||||
|
}); |
||||||
|
|
||||||
|
_.convert = convertLib; |
||||||
|
if (setPlaceholder) { |
||||||
|
_.placeholder = placeholder; |
||||||
|
} |
||||||
|
// Assign aliases.
|
||||||
|
each(keys(_), function(key) { |
||||||
|
each(mapping.realToAlias[key] || [], function(alias) { |
||||||
|
_[alias] = _[key]; |
||||||
|
}); |
||||||
|
}); |
||||||
|
|
||||||
|
return _; |
||||||
|
} |
||||||
|
|
||||||
|
module.exports = baseConvert; |
||||||
|
|
||||||
|
|
||||||
|
/***/ }, |
||||||
|
/* 2 */ |
||||||
|
/***/ function(module, exports) { |
||||||
|
|
||||||
|
/** Used to map aliases to their real names. */ |
||||||
|
exports.aliasToReal = { |
||||||
|
|
||||||
|
// Lodash aliases.
|
||||||
|
'each': 'forEach', |
||||||
|
'eachRight': 'forEachRight', |
||||||
|
'entries': 'toPairs', |
||||||
|
'entriesIn': 'toPairsIn', |
||||||
|
'extend': 'assignIn', |
||||||
|
'extendAll': 'assignInAll', |
||||||
|
'extendAllWith': 'assignInAllWith', |
||||||
|
'extendWith': 'assignInWith', |
||||||
|
'first': 'head', |
||||||
|
|
||||||
|
// Methods that are curried variants of others.
|
||||||
|
'conforms': 'conformsTo', |
||||||
|
'matches': 'isMatch', |
||||||
|
'property': 'get', |
||||||
|
|
||||||
|
// Ramda aliases.
|
||||||
|
'__': 'placeholder', |
||||||
|
'F': 'stubFalse', |
||||||
|
'T': 'stubTrue', |
||||||
|
'all': 'every', |
||||||
|
'allPass': 'overEvery', |
||||||
|
'always': 'constant', |
||||||
|
'any': 'some', |
||||||
|
'anyPass': 'overSome', |
||||||
|
'apply': 'spread', |
||||||
|
'assoc': 'set', |
||||||
|
'assocPath': 'set', |
||||||
|
'complement': 'negate', |
||||||
|
'compose': 'flowRight', |
||||||
|
'contains': 'includes', |
||||||
|
'dissoc': 'unset', |
||||||
|
'dissocPath': 'unset', |
||||||
|
'dropLast': 'dropRight', |
||||||
|
'dropLastWhile': 'dropRightWhile', |
||||||
|
'equals': 'isEqual', |
||||||
|
'identical': 'eq', |
||||||
|
'indexBy': 'keyBy', |
||||||
|
'init': 'initial', |
||||||
|
'invertObj': 'invert', |
||||||
|
'juxt': 'over', |
||||||
|
'omitAll': 'omit', |
||||||
|
'nAry': 'ary', |
||||||
|
'path': 'get', |
||||||
|
'pathEq': 'matchesProperty', |
||||||
|
'pathOr': 'getOr', |
||||||
|
'paths': 'at', |
||||||
|
'pickAll': 'pick', |
||||||
|
'pipe': 'flow', |
||||||
|
'pluck': 'map', |
||||||
|
'prop': 'get', |
||||||
|
'propEq': 'matchesProperty', |
||||||
|
'propOr': 'getOr', |
||||||
|
'props': 'at', |
||||||
|
'symmetricDifference': 'xor', |
||||||
|
'symmetricDifferenceBy': 'xorBy', |
||||||
|
'symmetricDifferenceWith': 'xorWith', |
||||||
|
'takeLast': 'takeRight', |
||||||
|
'takeLastWhile': 'takeRightWhile', |
||||||
|
'unapply': 'rest', |
||||||
|
'unnest': 'flatten', |
||||||
|
'useWith': 'overArgs', |
||||||
|
'where': 'conformsTo', |
||||||
|
'whereEq': 'isMatch', |
||||||
|
'zipObj': 'zipObject' |
||||||
|
}; |
||||||
|
|
||||||
|
/** Used to map ary to method names. */ |
||||||
|
exports.aryMethod = { |
||||||
|
'1': [ |
||||||
|
'assignAll', 'assignInAll', 'attempt', 'castArray', 'ceil', 'create', |
||||||
|
'curry', 'curryRight', 'defaultsAll', 'defaultsDeepAll', 'floor', 'flow', |
||||||
|
'flowRight', 'fromPairs', 'invert', 'iteratee', 'memoize', 'method', |
||||||
|
'mergeAll', 'methodOf', 'mixin', 'over', 'overEvery', 'overSome', 'rest', |
||||||
|
'reverse', 'round', 'runInContext', 'spread', 'template', 'trim', 'trimEnd', |
||||||
|
'trimStart', 'uniqueId', 'words' |
||||||
|
], |
||||||
|
'2': [ |
||||||
|
'add', 'after', 'ary', 'assign', 'assignAllWith', 'assignIn', 'assignInAllWith', |
||||||
|
'at', 'before', 'bind', 'bindAll', 'bindKey', 'chunk', 'cloneDeepWith', |
||||||
|
'cloneWith', 'concat', 'conformsTo', 'countBy', 'curryN', 'curryRightN', |
||||||
|
'debounce', 'defaults', 'defaultsDeep', 'defaultTo', 'delay', 'difference', |
||||||
|
'divide', 'drop', 'dropRight', 'dropRightWhile', 'dropWhile', 'endsWith', 'eq', |
||||||
|
'every', 'filter', 'find', 'findIndex', 'findKey', 'findLast', 'findLastIndex', |
||||||
|
'findLastKey', 'flatMap', 'flatMapDeep', 'flattenDepth', 'forEach', |
||||||
|
'forEachRight', 'forIn', 'forInRight', 'forOwn', 'forOwnRight', 'get', |
||||||
|
'groupBy', 'gt', 'gte', 'has', 'hasIn', 'includes', 'indexOf', 'intersection', |
||||||
|
'invertBy', 'invoke', 'invokeMap', 'isEqual', 'isMatch', 'join', 'keyBy', |
||||||
|
'lastIndexOf', 'lt', 'lte', 'map', 'mapKeys', 'mapValues', 'matchesProperty', |
||||||
|
'maxBy', 'meanBy', 'merge', 'mergeAllWith', 'minBy', 'multiply', 'nth', 'omit', |
||||||
|
'omitBy', 'overArgs', 'pad', 'padEnd', 'padStart', 'parseInt', 'partial', |
||||||
|
'partialRight', 'partition', 'pick', 'pickBy', 'propertyOf', 'pull', 'pullAll', |
||||||
|
'pullAt', 'random', 'range', 'rangeRight', 'rearg', 'reject', 'remove', |
||||||
|
'repeat', 'restFrom', 'result', 'sampleSize', 'some', 'sortBy', 'sortedIndex', |
||||||
|
'sortedIndexOf', 'sortedLastIndex', 'sortedLastIndexOf', 'sortedUniqBy', |
||||||
|
'split', 'spreadFrom', 'startsWith', 'subtract', 'sumBy', 'take', 'takeRight', |
||||||
|
'takeRightWhile', 'takeWhile', 'tap', 'throttle', 'thru', 'times', 'trimChars', |
||||||
|
'trimCharsEnd', 'trimCharsStart', 'truncate', 'union', 'uniqBy', 'uniqWith', |
||||||
|
'unset', 'unzipWith', 'without', 'wrap', 'xor', 'zip', 'zipObject', |
||||||
|
'zipObjectDeep' |
||||||
|
], |
||||||
|
'3': [ |
||||||
|
'assignInWith', 'assignWith', 'clamp', 'differenceBy', 'differenceWith', |
||||||
|
'findFrom', 'findIndexFrom', 'findLastFrom', 'findLastIndexFrom', 'getOr', |
||||||
|
'includesFrom', 'indexOfFrom', 'inRange', 'intersectionBy', 'intersectionWith', |
||||||
|
'invokeArgs', 'invokeArgsMap', 'isEqualWith', 'isMatchWith', 'flatMapDepth', |
||||||
|
'lastIndexOfFrom', 'mergeWith', 'orderBy', 'padChars', 'padCharsEnd', |
||||||
|
'padCharsStart', 'pullAllBy', 'pullAllWith', 'reduce', 'reduceRight', 'replace', |
||||||
|
'set', 'slice', 'sortedIndexBy', 'sortedLastIndexBy', 'transform', 'unionBy', |
||||||
|
'unionWith', 'update', 'xorBy', 'xorWith', 'zipWith' |
||||||
|
], |
||||||
|
'4': [ |
||||||
|
'fill', 'setWith', 'updateWith' |
||||||
|
] |
||||||
|
}; |
||||||
|
|
||||||
|
/** Used to map ary to rearg configs. */ |
||||||
|
exports.aryRearg = { |
||||||
|
'2': [1, 0], |
||||||
|
'3': [2, 0, 1], |
||||||
|
'4': [3, 2, 0, 1] |
||||||
|
}; |
||||||
|
|
||||||
|
/** Used to map method names to their iteratee ary. */ |
||||||
|
exports.iterateeAry = { |
||||||
|
'dropRightWhile': 1, |
||||||
|
'dropWhile': 1, |
||||||
|
'every': 1, |
||||||
|
'filter': 1, |
||||||
|
'find': 1, |
||||||
|
'findFrom': 1, |
||||||
|
'findIndex': 1, |
||||||
|
'findIndexFrom': 1, |
||||||
|
'findKey': 1, |
||||||
|
'findLast': 1, |
||||||
|
'findLastFrom': 1, |
||||||
|
'findLastIndex': 1, |
||||||
|
'findLastIndexFrom': 1, |
||||||
|
'findLastKey': 1, |
||||||
|
'flatMap': 1, |
||||||
|
'flatMapDeep': 1, |
||||||
|
'flatMapDepth': 1, |
||||||
|
'forEach': 1, |
||||||
|
'forEachRight': 1, |
||||||
|
'forIn': 1, |
||||||
|
'forInRight': 1, |
||||||
|
'forOwn': 1, |
||||||
|
'forOwnRight': 1, |
||||||
|
'map': 1, |
||||||
|
'mapKeys': 1, |
||||||
|
'mapValues': 1, |
||||||
|
'partition': 1, |
||||||
|
'reduce': 2, |
||||||
|
'reduceRight': 2, |
||||||
|
'reject': 1, |
||||||
|
'remove': 1, |
||||||
|
'some': 1, |
||||||
|
'takeRightWhile': 1, |
||||||
|
'takeWhile': 1, |
||||||
|
'times': 1, |
||||||
|
'transform': 2 |
||||||
|
}; |
||||||
|
|
||||||
|
/** Used to map method names to iteratee rearg configs. */ |
||||||
|
exports.iterateeRearg = { |
||||||
|
'mapKeys': [1] |
||||||
|
}; |
||||||
|
|
||||||
|
/** Used to map method names to rearg configs. */ |
||||||
|
exports.methodRearg = { |
||||||
|
'assignInAllWith': [1, 2, 0], |
||||||
|
'assignInWith': [1, 2, 0], |
||||||
|
'assignAllWith': [1, 2, 0], |
||||||
|
'assignWith': [1, 2, 0], |
||||||
|
'differenceBy': [1, 2, 0], |
||||||
|
'differenceWith': [1, 2, 0], |
||||||
|
'getOr': [2, 1, 0], |
||||||
|
'intersectionBy': [1, 2, 0], |
||||||
|
'intersectionWith': [1, 2, 0], |
||||||
|
'isEqualWith': [1, 2, 0], |
||||||
|
'isMatchWith': [2, 1, 0], |
||||||
|
'mergeAllWith': [1, 2, 0], |
||||||
|
'mergeWith': [1, 2, 0], |
||||||
|
'padChars': [2, 1, 0], |
||||||
|
'padCharsEnd': [2, 1, 0], |
||||||
|
'padCharsStart': [2, 1, 0], |
||||||
|
'pullAllBy': [2, 1, 0], |
||||||
|
'pullAllWith': [2, 1, 0], |
||||||
|
'setWith': [3, 1, 2, 0], |
||||||
|
'sortedIndexBy': [2, 1, 0], |
||||||
|
'sortedLastIndexBy': [2, 1, 0], |
||||||
|
'unionBy': [1, 2, 0], |
||||||
|
'unionWith': [1, 2, 0], |
||||||
|
'updateWith': [3, 1, 2, 0], |
||||||
|
'xorBy': [1, 2, 0], |
||||||
|
'xorWith': [1, 2, 0], |
||||||
|
'zipWith': [1, 2, 0] |
||||||
|
}; |
||||||
|
|
||||||
|
/** Used to map method names to spread configs. */ |
||||||
|
exports.methodSpread = { |
||||||
|
'assignAll': { 'start': 0 }, |
||||||
|
'assignAllWith': { 'afterRearg': true, 'start': 1 }, |
||||||
|
'assignInAll': { 'start': 0 }, |
||||||
|
'assignInAllWith': { 'afterRearg': true, 'start': 1 }, |
||||||
|
'defaultsAll': { 'start': 0 }, |
||||||
|
'defaultsDeepAll': { 'start': 0 }, |
||||||
|
'invokeArgs': { 'start': 2 }, |
||||||
|
'invokeArgsMap': { 'start': 2 }, |
||||||
|
'mergeAll': { 'start': 0 }, |
||||||
|
'mergeAllWith': { 'afterRearg': true, 'start': 1 }, |
||||||
|
'partial': { 'start': 1 }, |
||||||
|
'partialRight': { 'start': 1 }, |
||||||
|
'without': { 'start': 1 } |
||||||
|
}; |
||||||
|
|
||||||
|
/** Used to identify methods which mutate arrays or objects. */ |
||||||
|
exports.mutate = { |
||||||
|
'array': { |
||||||
|
'fill': true, |
||||||
|
'pull': true, |
||||||
|
'pullAll': true, |
||||||
|
'pullAllBy': true, |
||||||
|
'pullAllWith': true, |
||||||
|
'pullAt': true, |
||||||
|
'remove': true, |
||||||
|
'reverse': true |
||||||
|
}, |
||||||
|
'object': { |
||||||
|
'assign': true, |
||||||
|
'assignAll': true, |
||||||
|
'assignAllWith': true, |
||||||
|
'assignIn': true, |
||||||
|
'assignInAll': true, |
||||||
|
'assignInAllWith': true, |
||||||
|
'assignInWith': true, |
||||||
|
'assignWith': true, |
||||||
|
'defaults': true, |
||||||
|
'defaultsAll': true, |
||||||
|
'defaultsDeep': true, |
||||||
|
'defaultsDeepAll': true, |
||||||
|
'merge': true, |
||||||
|
'mergeAll': true, |
||||||
|
'mergeAllWith': true, |
||||||
|
'mergeWith': true, |
||||||
|
}, |
||||||
|
'set': { |
||||||
|
'set': true, |
||||||
|
'setWith': true, |
||||||
|
'unset': true, |
||||||
|
'update': true, |
||||||
|
'updateWith': true |
||||||
|
} |
||||||
|
}; |
||||||
|
|
||||||
|
/** Used to track methods with placeholder support */ |
||||||
|
exports.placeholder = { |
||||||
|
'bind': true, |
||||||
|
'bindKey': true, |
||||||
|
'curry': true, |
||||||
|
'curryRight': true, |
||||||
|
'partial': true, |
||||||
|
'partialRight': true |
||||||
|
}; |
||||||
|
|
||||||
|
/** Used to map real names to their aliases. */ |
||||||
|
exports.realToAlias = (function() { |
||||||
|
var hasOwnProperty = Object.prototype.hasOwnProperty, |
||||||
|
object = exports.aliasToReal, |
||||||
|
result = {}; |
||||||
|
|
||||||
|
for (var key in object) { |
||||||
|
var value = object[key]; |
||||||
|
if (hasOwnProperty.call(result, value)) { |
||||||
|
result[value].push(key); |
||||||
|
} else { |
||||||
|
result[value] = [key]; |
||||||
|
} |
||||||
|
} |
||||||
|
return result; |
||||||
|
}()); |
||||||
|
|
||||||
|
/** Used to map method names to other names. */ |
||||||
|
exports.remap = { |
||||||
|
'assignAll': 'assign', |
||||||
|
'assignAllWith': 'assignWith', |
||||||
|
'assignInAll': 'assignIn', |
||||||
|
'assignInAllWith': 'assignInWith', |
||||||
|
'curryN': 'curry', |
||||||
|
'curryRightN': 'curryRight', |
||||||
|
'defaultsAll': 'defaults', |
||||||
|
'defaultsDeepAll': 'defaultsDeep', |
||||||
|
'findFrom': 'find', |
||||||
|
'findIndexFrom': 'findIndex', |
||||||
|
'findLastFrom': 'findLast', |
||||||
|
'findLastIndexFrom': 'findLastIndex', |
||||||
|
'getOr': 'get', |
||||||
|
'includesFrom': 'includes', |
||||||
|
'indexOfFrom': 'indexOf', |
||||||
|
'invokeArgs': 'invoke', |
||||||
|
'invokeArgsMap': 'invokeMap', |
||||||
|
'lastIndexOfFrom': 'lastIndexOf', |
||||||
|
'mergeAll': 'merge', |
||||||
|
'mergeAllWith': 'mergeWith', |
||||||
|
'padChars': 'pad', |
||||||
|
'padCharsEnd': 'padEnd', |
||||||
|
'padCharsStart': 'padStart', |
||||||
|
'propertyOf': 'get', |
||||||
|
'restFrom': 'rest', |
||||||
|
'spreadFrom': 'spread', |
||||||
|
'trimChars': 'trim', |
||||||
|
'trimCharsEnd': 'trimEnd', |
||||||
|
'trimCharsStart': 'trimStart' |
||||||
|
}; |
||||||
|
|
||||||
|
/** Used to track methods that skip fixing their arity. */ |
||||||
|
exports.skipFixed = { |
||||||
|
'castArray': true, |
||||||
|
'flow': true, |
||||||
|
'flowRight': true, |
||||||
|
'iteratee': true, |
||||||
|
'mixin': true, |
||||||
|
'rearg': true, |
||||||
|
'runInContext': true |
||||||
|
}; |
||||||
|
|
||||||
|
/** Used to track methods that skip rearranging arguments. */ |
||||||
|
exports.skipRearg = { |
||||||
|
'add': true, |
||||||
|
'assign': true, |
||||||
|
'assignIn': true, |
||||||
|
'bind': true, |
||||||
|
'bindKey': true, |
||||||
|
'concat': true, |
||||||
|
'difference': true, |
||||||
|
'divide': true, |
||||||
|
'eq': true, |
||||||
|
'gt': true, |
||||||
|
'gte': true, |
||||||
|
'isEqual': true, |
||||||
|
'lt': true, |
||||||
|
'lte': true, |
||||||
|
'matchesProperty': true, |
||||||
|
'merge': true, |
||||||
|
'multiply': true, |
||||||
|
'overArgs': true, |
||||||
|
'partial': true, |
||||||
|
'partialRight': true, |
||||||
|
'propertyOf': true, |
||||||
|
'random': true, |
||||||
|
'range': true, |
||||||
|
'rangeRight': true, |
||||||
|
'subtract': true, |
||||||
|
'zip': true, |
||||||
|
'zipObject': true |
||||||
|
}; |
||||||
|
|
||||||
|
|
||||||
|
/***/ }, |
||||||
|
/* 3 */ |
||||||
|
/***/ function(module, exports) { |
||||||
|
|
||||||
|
/** |
||||||
|
* The default argument placeholder value for methods. |
||||||
|
* |
||||||
|
* @type {Object} |
||||||
|
*/ |
||||||
|
module.exports = {}; |
||||||
|
|
||||||
|
|
||||||
|
/***/ } |
||||||
|
/******/ ]) |
||||||
|
}); |
||||||
|
; |
||||||
File diff suppressed because it is too large
Load Diff
@ -1,6 +1,5 @@ |
|||||||
{% extends 'partials/base.html' %} |
{% extends 'partials/base.html' %} |
||||||
|
|
||||||
{% block content %} |
{% block content %} |
||||||
<h1>project: {{ project }}</h1> |
<h1>Hello there</h1> |
||||||
<h1>object: {{ object }}</h1> |
|
||||||
{% endblock %} |
{% endblock %} |
||||||
|
|||||||
Loading…
Reference in new issue