ArturBaybulatov
10 years ago
parent
311b67f408
commit
595cb43dab
10 changed files with 17509 additions and 85 deletions
@ -1,46 +1,27 @@ |
||||
window.g = window |
||||
|
||||
var app = angular.module('app', []) |
||||
|
||||
|
||||
app.config(['$interpolateProvider', '$httpProvider', |
||||
function($interpolateProvider, $httpProvider) { |
||||
$interpolateProvider.startSymbol('{(') |
||||
$interpolateProvider.endSymbol(')}') |
||||
|
||||
$httpProvider.defaults.xsrfCookieName = 'csrftoken' |
||||
$httpProvider.defaults.xsrfHeaderName = 'X-CSRFToken' |
||||
|
||||
$httpProvider.defaults.headers.common['X-Requested-With'] = 'XMLHttpRequest' |
||||
|
||||
//$routeProvider.when('/', {templateUrl: '.....'})
|
||||
}, |
||||
]) |
||||
|
||||
|
||||
app.run(['$rootScope', '$timeout', '$http', |
||||
function run($rootScope, $timeout, $http) { |
||||
g.$http = $http // Debug
|
||||
g.$timeout = $timeout // Debug
|
||||
}, |
||||
]) |
||||
|
||||
|
||||
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) |
||||
} |
||||
) |
||||
}]) |
||||
//$('#realtyId').on('change', function(evt) {
|
||||
// var realtyId = Number($(this).val())
|
||||
//
|
||||
// if (realtyId) {
|
||||
// loadRealtyDetails(realtyId).then(function(res) {
|
||||
// $('#realtyName').val(res.name)
|
||||
// $('#realtyBuildingClassificationId').val(res.building_classification.id).change()
|
||||
// $('#realtyConstructionTypeId').val(res.construction_type.id).change()
|
||||
// $('#realtyLocationId').val(res.location.id).change()
|
||||
// })
|
||||
// } else {
|
||||
// $('#realtyName').val('')
|
||||
// $('#realtyBuildingClassificationId').val('').change()
|
||||
// $('#realtyConstructionTypeId').val('').change()
|
||||
// $('#realtyLocationId').val('').change()
|
||||
// }
|
||||
//})
|
||||
//
|
||||
//function loadRealtyDetails(realtyId) {
|
||||
// return $.ajax({
|
||||
// url: '/api/realties/' + realtyId + '/',
|
||||
// method: 'GET',
|
||||
// dataType: 'json',
|
||||
// })
|
||||
// .then(function(res) {return res})
|
||||
// .fail(function() {console.error('Failed', arguments)})
|
||||
//}
|
||||
|
||||
@ -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' %} |
||||
|
||||
{% block content %} |
||||
<h1>project: {{ project }}</h1> |
||||
<h1>object: {{ object }}</h1> |
||||
<h1>Hello there</h1> |
||||
{% endblock %} |
||||
|
||||
Loading…
Reference in new issue