summaryrefslogtreecommitdiffstats
path: root/node_modules/mpath/lib
diff options
context:
space:
mode:
Diffstat (limited to 'node_modules/mpath/lib')
-rw-r--r--node_modules/mpath/lib/index.js308
1 files changed, 308 insertions, 0 deletions
diff --git a/node_modules/mpath/lib/index.js b/node_modules/mpath/lib/index.js
new file mode 100644
index 0000000..e5479de
--- /dev/null
+++ b/node_modules/mpath/lib/index.js
@@ -0,0 +1,308 @@
+// These properties are special and can open client libraries to security
+// issues
+var ignoreProperties = ['__proto__', 'constructor', 'prototype'];
+
+/**
+ * Returns the value of object `o` at the given `path`.
+ *
+ * ####Example:
+ *
+ * var obj = {
+ * comments: [
+ * { title: 'exciting!', _doc: { title: 'great!' }}
+ * , { title: 'number dos' }
+ * ]
+ * }
+ *
+ * mpath.get('comments.0.title', o) // 'exciting!'
+ * mpath.get('comments.0.title', o, '_doc') // 'great!'
+ * mpath.get('comments.title', o) // ['exciting!', 'number dos']
+ *
+ * // summary
+ * mpath.get(path, o)
+ * mpath.get(path, o, special)
+ * mpath.get(path, o, map)
+ * mpath.get(path, o, special, map)
+ *
+ * @param {String} path
+ * @param {Object} o
+ * @param {String} [special] When this property name is present on any object in the path, walking will continue on the value of this property.
+ * @param {Function} [map] Optional function which receives each individual found value. The value returned from `map` is used in the original values place.
+ */
+
+exports.get = function (path, o, special, map) {
+ var lookup;
+
+ if ('function' == typeof special) {
+ if (special.length < 2) {
+ map = special;
+ special = undefined;
+ } else {
+ lookup = special;
+ special = undefined;
+ }
+ }
+
+ map || (map = K);
+
+ var parts = 'string' == typeof path
+ ? path.split('.')
+ : path
+
+ if (!Array.isArray(parts)) {
+ throw new TypeError('Invalid `path`. Must be either string or array');
+ }
+
+ var obj = o
+ , part;
+
+ for (var i = 0; i < parts.length; ++i) {
+ part = parts[i];
+
+ if (Array.isArray(obj) && !/^\d+$/.test(part)) {
+ // reading a property from the array items
+ var paths = parts.slice(i);
+
+ // Need to `concat()` to avoid `map()` calling a constructor of an array
+ // subclass
+ return [].concat(obj).map(function (item) {
+ return item
+ ? exports.get(paths, item, special || lookup, map)
+ : map(undefined);
+ });
+ }
+
+ if (lookup) {
+ obj = lookup(obj, part);
+ } else {
+ var _from = special && obj[special] ? obj[special] : obj;
+ obj = _from instanceof Map ?
+ _from.get(part) :
+ _from[part];
+ }
+
+ if (!obj) return map(obj);
+ }
+
+ return map(obj);
+};
+
+/**
+ * Returns true if `in` returns true for every piece of the path
+ *
+ * @param {String} path
+ * @param {Object} o
+ */
+
+exports.has = function (path, o) {
+ var parts = typeof path === 'string' ?
+ path.split('.') :
+ path;
+
+ if (!Array.isArray(parts)) {
+ throw new TypeError('Invalid `path`. Must be either string or array');
+ }
+
+ var len = parts.length;
+ var cur = o;
+ for (var i = 0; i < len; ++i) {
+ if (cur == null || typeof cur !== 'object' || !(parts[i] in cur)) {
+ return false;
+ }
+ cur = cur[parts[i]];
+ }
+
+ return true;
+};
+
+/**
+ * Deletes the last piece of `path`
+ *
+ * @param {String} path
+ * @param {Object} o
+ */
+
+exports.unset = function (path, o) {
+ var parts = typeof path === 'string' ?
+ path.split('.') :
+ path;
+
+ if (!Array.isArray(parts)) {
+ throw new TypeError('Invalid `path`. Must be either string or array');
+ }
+
+ var len = parts.length;
+ var cur = o;
+ for (var i = 0; i < len; ++i) {
+ if (cur == null || typeof cur !== 'object' || !(parts[i] in cur)) {
+ return false;
+ }
+ // Disallow any updates to __proto__ or special properties.
+ if (ignoreProperties.indexOf(parts[i]) !== -1) {
+ return false;
+ }
+ if (i === len - 1) {
+ delete cur[parts[i]];
+ return true;
+ }
+ cur = cur instanceof Map ? cur.get(parts[i]) : cur[parts[i]];
+ }
+
+ return true;
+};
+
+/**
+ * Sets the `val` at the given `path` of object `o`.
+ *
+ * @param {String} path
+ * @param {Anything} val
+ * @param {Object} o
+ * @param {String} [special] When this property name is present on any object in the path, walking will continue on the value of this property.
+ * @param {Function} [map] Optional function which is passed each individual value before setting it. The value returned from `map` is used in the original values place.
+ */
+
+exports.set = function (path, val, o, special, map, _copying) {
+ var lookup;
+
+ if ('function' == typeof special) {
+ if (special.length < 2) {
+ map = special;
+ special = undefined;
+ } else {
+ lookup = special;
+ special = undefined;
+ }
+ }
+
+ map || (map = K);
+
+ var parts = 'string' == typeof path
+ ? path.split('.')
+ : path
+
+ if (!Array.isArray(parts)) {
+ throw new TypeError('Invalid `path`. Must be either string or array');
+ }
+
+ if (null == o) return;
+
+ for (var i = 0; i < parts.length; ++i) {
+ // Silently ignore any updates to `__proto__`, these are potentially
+ // dangerous if using mpath with unsanitized data.
+ if (ignoreProperties.indexOf(parts[i]) !== -1) {
+ return;
+ }
+ }
+
+ // the existance of $ in a path tells us if the user desires
+ // the copying of an array instead of setting each value of
+ // the array to the one by one to matching positions of the
+ // current array. Unless the user explicitly opted out by passing
+ // false, see Automattic/mongoose#6273
+ var copy = _copying || (/\$/.test(path) && _copying !== false)
+ , obj = o
+ , part
+
+ for (var i = 0, len = parts.length - 1; i < len; ++i) {
+ part = parts[i];
+
+ if ('$' == part) {
+ if (i == len - 1) {
+ break;
+ } else {
+ continue;
+ }
+ }
+
+ if (Array.isArray(obj) && !/^\d+$/.test(part)) {
+ var paths = parts.slice(i);
+ if (!copy && Array.isArray(val)) {
+ for (var j = 0; j < obj.length && j < val.length; ++j) {
+ // assignment of single values of array
+ exports.set(paths, val[j], obj[j], special || lookup, map, copy);
+ }
+ } else {
+ for (var j = 0; j < obj.length; ++j) {
+ // assignment of entire value
+ exports.set(paths, val, obj[j], special || lookup, map, copy);
+ }
+ }
+ return;
+ }
+
+ if (lookup) {
+ obj = lookup(obj, part);
+ } else {
+ var _to = special && obj[special] ? obj[special] : obj;
+ obj = _to instanceof Map ?
+ _to.get(part) :
+ _to[part];
+ }
+
+ if (!obj) return;
+ }
+
+ // process the last property of the path
+
+ part = parts[len];
+
+ // use the special property if exists
+ if (special && obj[special]) {
+ obj = obj[special];
+ }
+
+ // set the value on the last branch
+ if (Array.isArray(obj) && !/^\d+$/.test(part)) {
+ if (!copy && Array.isArray(val)) {
+ _setArray(obj, val, part, lookup, special, map);
+ } else {
+ for (var j = 0; j < obj.length; ++j) {
+ item = obj[j];
+ if (item) {
+ if (lookup) {
+ lookup(item, part, map(val));
+ } else {
+ if (item[special]) item = item[special];
+ item[part] = map(val);
+ }
+ }
+ }
+ }
+ } else {
+ if (lookup) {
+ lookup(obj, part, map(val));
+ } else if (obj instanceof Map) {
+ obj.set(part, map(val));
+ } else {
+ obj[part] = map(val);
+ }
+ }
+}
+
+/*!
+ * Recursively set nested arrays
+ */
+
+function _setArray(obj, val, part, lookup, special, map) {
+ for (var item, j = 0; j < obj.length && j < val.length; ++j) {
+ item = obj[j];
+ if (Array.isArray(item) && Array.isArray(val[j])) {
+ _setArray(item, val[j], part, lookup, special, map);
+ } else if (item) {
+ if (lookup) {
+ lookup(item, part, map(val[j]));
+ } else {
+ if (item[special]) item = item[special];
+ item[part] = map(val[j]);
+ }
+ }
+ }
+}
+
+/*!
+ * Returns the value passed to it.
+ */
+
+function K (v) {
+ return v;
+}
generated by cgit v1.2.3 (git 2.25.1) at 2025-08-23 15:38:47 +0000