@visulima/object 1.0.7 → 1.0.8

package/dist/index.mjs

@@ -1 +1,176 @@
-var L=Object.defineProperty;var o=(c,y)=>L(c,"name",{value:y,configurable:!0});import{default as w}from"./packem_shared/omit-BcaD2qRn.mjs";import{default as B}from"./packem_shared/pick-BxgLK1bH.mjs";import{deleteProperty as W,escapePath as z,getProperty as C,hasProperty as G,setProperty as H}from"./packem_shared/getProperty-D2xQpEOY.mjs";import{default as Q}from"./packem_shared/isPlainObject-CLTs8VdF.mjs";var s={},p={},D;function N(){if(D)return p;D=1;var c=Object.defineProperty,y=o((i,b)=>c(i,"name",{value:b,configurable:!0}),"t");Object.defineProperty(p,"__esModule",{value:!0}),p.isDocumentToRecurOn=p.flatten=p.unique=void 0;function u(i){return[...new Set(i)]}o(u,"unique"),y(u,"unique"),p.unique=u;function f(i){return[].concat(...i)}o(f,"flatten"),y(f,"flatten"),p.flatten=f;function m(i){return typeof i=="object"&&i!==null&&!Array.isArray(i)&&Object.keys(i).length}return o(m,"isDocumentToRecurOn"),y(m,"isDocumentToRecurOn"),p.isDocumentToRecurOn=m,p}o(N,"requireUtils");var K={},P;function R(){return P||(P=1,Object.defineProperty(K,"__esModule",{value:!0})),K}o(R,"requireTypes");var q;function k(){return q||(q=1,function(c){var y=Object.defineProperty,u=o((t,e)=>y(t,"name",{value:e,configurable:!0}),"i"),f=s&&s.__createBinding||(Object.create?function(t,e,r,a){a===void 0&&(a=r);var n=Object.getOwnPropertyDescriptor(e,r);(!n||("get"in n?!e.__esModule:n.writable||n.configurable))&&(n={enumerable:!0,get:u(function(){return e[r]},"get")}),Object.defineProperty(t,a,n)}:function(t,e,r,a){a===void 0&&(a=r),t[a]=e[r]}),m=s&&s.__setModuleDefault||(Object.create?function(t,e){Object.defineProperty(t,"default",{enumerable:!0,value:e})}:function(t,e){t.default=e}),i=s&&s.__importStar||function(t){if(t&&t.__esModule)return t;var e={};if(t!=null)for(var r in t)r!=="default"&&Object.prototype.hasOwnProperty.call(t,r)&&f(e,t,r);return m(e,t),e},b=s&&s.__exportStar||function(t,e){for(var r in t)r!=="default"&&!Object.prototype.hasOwnProperty.call(e,r)&&f(e,t,r)};Object.defineProperty(c,"__esModule",{value:!0}),c.deepKeysFromList=c.deepKeys=void 0;const l=i(N());b(R(),c);function O(t,e){const r=A(e);return typeof t=="object"&&t!==null?v("",t,r):[]}o(O,"deepKeys"),u(O,"deepKeys"),c.deepKeys=O;function g(t,e){const r=A(e);return t.map(a=>typeof a=="object"&&a!==null?O(a,r):[])}o(g,"deepKeysFromList"),u(g,"deepKeysFromList"),c.deepKeysFromList=g;function v(t,e,r){const a=Object.keys(e).map(n=>{const d=j(t,_(n,r));return r.expandNestedObjects&&l.isDocumentToRecurOn(e[n])||r.arrayIndexesAsKeys&&Array.isArray(e[n])&&e[n].length?v(d,e[n],r):r.expandArrayObjects&&Array.isArray(e[n])?h(e[n],d,r):r.ignoreEmptyArrays&&Array.isArray(e[n])&&!e[n].length?[]:d});return l.flatten(a)}o(v,"generateDeepKeysList"),u(v,"generateDeepKeysList");function h(t,e,r){let a=g(t,r);return t.length?t.length&&l.flatten(a).length===0?[e]:(a=a.map(n=>Array.isArray(n)&&n.length===0?[e]:n.map(d=>j(e,_(d,r)))),l.unique(l.flatten(a))):r.ignoreEmptyArraysWhenExpanding?[]:[e]}o(h,"processArrayKeys"),u(h,"processArrayKeys");function _(t,e){return e.escapeNestedDots?t.replace(/\./g,"\\."):t}o(_,"escapeNestedDotsIfSpecified"),u(_,"escapeNestedDotsIfSpecified");function j(t,e){return t?t+"."+e:e}o(j,"buildKeyName"),u(j,"buildKeyName");function A(t){return{arrayIndexesAsKeys:!1,expandNestedObjects:!0,expandArrayObjects:!1,ignoreEmptyArraysWhenExpanding:!1,escapeNestedDots:!1,ignoreEmptyArrays:!1,...t??{}}}o(A,"mergeOptions"),u(A,"mergeOptions")}(s)),s}o(k,"requireDeeks");var x=k();const M=x.deepKeys,S=x.deepKeysFromList;export{M as deepKeys,S as deepKeysFromList,W as deleteProperty,z as escapePath,C as getProperty,G as hasProperty,Q as isPlainObject,w as omit,B as pick,H as setProperty};
+export { default as omit } from './packem_shared/omit-Bz46-jv-.mjs';
+export { default as pick } from './packem_shared/pick-C9-E3eDJ.mjs';
+export { deleteProperty, escapePath, getProperty, hasProperty, setProperty } from './packem_shared/getProperty-CqSBQFGO.mjs';
+export { default as isPlainObject } from './packem_shared/isPlainObject-BEp1xndO.mjs';
+
+var deeks = {};
+
+var utils = {};
+
+var hasRequiredUtils;
+
+function requireUtils () {
+	if (hasRequiredUtils) return utils;
+	hasRequiredUtils = 1;
+	var __defProp = Object.defineProperty;
+	var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+	Object.defineProperty(utils, "__esModule", { value: true });
+	utils.isDocumentToRecurOn = utils.flatten = utils.unique = undefined;
+	function unique(array) {
+	  return [...new Set(array)];
+	}
+	__name(unique, "unique");
+	utils.unique = unique;
+	function flatten(array) {
+	  return [].concat(...array);
+	}
+	__name(flatten, "flatten");
+	utils.flatten = flatten;
+	function isDocumentToRecurOn(val) {
+	  return typeof val === "object" && val !== null && !Array.isArray(val) && Object.keys(val).length;
+	}
+	__name(isDocumentToRecurOn, "isDocumentToRecurOn");
+	utils.isDocumentToRecurOn = isDocumentToRecurOn;
+	return utils;
+}
+
+var types = {};
+
+var hasRequiredTypes;
+
+function requireTypes () {
+	if (hasRequiredTypes) return types;
+	hasRequiredTypes = 1;
+	Object.defineProperty(types, "__esModule", { value: true });
+	return types;
+}
+
+var hasRequiredDeeks;
+
+function requireDeeks () {
+	if (hasRequiredDeeks) return deeks;
+	hasRequiredDeeks = 1;
+	(function (exports) {
+		var __defProp = Object.defineProperty;
+		var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+		var __createBinding = deeks.__createBinding || (Object.create ? function(o, m, k, k2) {
+		  if (k2 === undefined) k2 = k;
+		  var desc = Object.getOwnPropertyDescriptor(m, k);
+		  if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+		    desc = { enumerable: true, get: /* @__PURE__ */ __name(function() {
+		      return m[k];
+		    }, "get") };
+		  }
+		  Object.defineProperty(o, k2, desc);
+		} : function(o, m, k, k2) {
+		  if (k2 === undefined) k2 = k;
+		  o[k2] = m[k];
+		});
+		var __setModuleDefault = deeks.__setModuleDefault || (Object.create ? function(o, v) {
+		  Object.defineProperty(o, "default", { enumerable: true, value: v });
+		} : function(o, v) {
+		  o["default"] = v;
+		});
+		var __importStar = deeks.__importStar || function(mod) {
+		  if (mod && mod.__esModule) return mod;
+		  var result = {};
+		  if (mod != null) {
+		    for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+		  }
+		  __setModuleDefault(result, mod);
+		  return result;
+		};
+		var __exportStar = deeks.__exportStar || function(m, exports2) {
+		  for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports2, p)) __createBinding(exports2, m, p);
+		};
+		Object.defineProperty(exports, "__esModule", { value: true });
+		exports.deepKeysFromList = exports.deepKeys = undefined;
+		const utils = __importStar(requireUtils());
+		__exportStar(requireTypes(), exports);
+		function deepKeys(object, options) {
+		  const parsedOptions = mergeOptions(options);
+		  if (typeof object === "object" && object !== null) {
+		    return generateDeepKeysList("", object, parsedOptions);
+		  }
+		  return [];
+		}
+		__name(deepKeys, "deepKeys");
+		exports.deepKeys = deepKeys;
+		function deepKeysFromList(list, options) {
+		  const parsedOptions = mergeOptions(options);
+		  return list.map((document) => {
+		    if (typeof document === "object" && document !== null) {
+		      return deepKeys(document, parsedOptions);
+		    }
+		    return [];
+		  });
+		}
+		__name(deepKeysFromList, "deepKeysFromList");
+		exports.deepKeysFromList = deepKeysFromList;
+		function generateDeepKeysList(heading, data, options) {
+		  const keys = Object.keys(data).map((currentKey) => {
+		    const keyName = buildKeyName(heading, escapeNestedDotsIfSpecified(currentKey, options));
+		    if (options.expandNestedObjects && utils.isDocumentToRecurOn(data[currentKey]) || options.arrayIndexesAsKeys && Array.isArray(data[currentKey]) && data[currentKey].length) {
+		      return generateDeepKeysList(keyName, data[currentKey], options);
+		    } else if (options.expandArrayObjects && Array.isArray(data[currentKey])) {
+		      return processArrayKeys(data[currentKey], keyName, options);
+		    } else if (options.ignoreEmptyArrays && Array.isArray(data[currentKey]) && !data[currentKey].length) {
+		      return [];
+		    }
+		    return keyName;
+		  });
+		  return utils.flatten(keys);
+		}
+		__name(generateDeepKeysList, "generateDeepKeysList");
+		function processArrayKeys(subArray, currentKeyPath, options) {
+		  let subArrayKeys = deepKeysFromList(subArray, options);
+		  if (!subArray.length) {
+		    return options.ignoreEmptyArraysWhenExpanding ? [] : [currentKeyPath];
+		  } else if (subArray.length && utils.flatten(subArrayKeys).length === 0) {
+		    return [currentKeyPath];
+		  } else {
+		    subArrayKeys = subArrayKeys.map((schemaKeys) => {
+		      if (Array.isArray(schemaKeys) && schemaKeys.length === 0) {
+		        return [currentKeyPath];
+		      }
+		      return schemaKeys.map((subKey) => buildKeyName(currentKeyPath, escapeNestedDotsIfSpecified(subKey, options)));
+		    });
+		    return utils.unique(utils.flatten(subArrayKeys));
+		  }
+		}
+		__name(processArrayKeys, "processArrayKeys");
+		function escapeNestedDotsIfSpecified(key, options) {
+		  if (options.escapeNestedDots) {
+		    return key.replace(/\./g, "\\.");
+		  }
+		  return key;
+		}
+		__name(escapeNestedDotsIfSpecified, "escapeNestedDotsIfSpecified");
+		function buildKeyName(upperKeyName, currentKeyName) {
+		  if (upperKeyName) {
+		    return upperKeyName + "." + currentKeyName;
+		  }
+		  return currentKeyName;
+		}
+		__name(buildKeyName, "buildKeyName");
+		function mergeOptions(options) {
+		  return {
+		    arrayIndexesAsKeys: false,
+		    expandNestedObjects: true,
+		    expandArrayObjects: false,
+		    ignoreEmptyArraysWhenExpanding: false,
+		    escapeNestedDots: false,
+		    ignoreEmptyArrays: false,
+		    ...options ?? {}
+		  };
+		}
+		__name(mergeOptions, "mergeOptions"); 
+	} (deeks));
+	return deeks;
+}
+
+var deeksExports = requireDeeks();
+
+const deepKeys = deeksExports.deepKeys;
+const deepKeysFromList = deeksExports.deepKeysFromList;
+export { deepKeys, deepKeysFromList };

package/dist/packem_shared/getProperty-BuSUBWTY.cjs

@@ -0,0 +1,278 @@
+'use strict';
+
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: 'Module' } });
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+const isObject = /* @__PURE__ */ __name((value) => {
+  const type = typeof value;
+  return value !== null && (type === "object" || type === "function");
+}, "isObject");
+const isEmptyObject = /* @__PURE__ */ __name((value) => isObject(value) && Object.keys(value).length === 0, "isEmptyObject");
+const disallowedKeys = /* @__PURE__ */ new Set([
+  "__proto__",
+  "prototype",
+  "constructor"
+]);
+const digits = new Set("0123456789");
+function getPathSegments(path) {
+  const parts = [];
+  let currentSegment = "";
+  let currentPart = "start";
+  let isIgnoring = false;
+  for (const character of path) {
+    switch (character) {
+      case "\\": {
+        if (currentPart === "index") {
+          throw new Error("Invalid character in an index");
+        }
+        if (currentPart === "indexEnd") {
+          throw new Error("Invalid character after an index");
+        }
+        if (isIgnoring) {
+          currentSegment += character;
+        }
+        currentPart = "property";
+        isIgnoring = !isIgnoring;
+        break;
+      }
+      case ".": {
+        if (currentPart === "index") {
+          throw new Error("Invalid character in an index");
+        }
+        if (currentPart === "indexEnd") {
+          currentPart = "property";
+          break;
+        }
+        if (isIgnoring) {
+          isIgnoring = false;
+          currentSegment += character;
+          break;
+        }
+        if (disallowedKeys.has(currentSegment)) {
+          return [];
+        }
+        parts.push(currentSegment);
+        currentSegment = "";
+        currentPart = "property";
+        break;
+      }
+      case "[": {
+        if (currentPart === "index") {
+          throw new Error("Invalid character in an index");
+        }
+        if (currentPart === "indexEnd") {
+          currentPart = "index";
+          break;
+        }
+        if (isIgnoring) {
+          isIgnoring = false;
+          currentSegment += character;
+          break;
+        }
+        if (currentPart === "property") {
+          if (disallowedKeys.has(currentSegment)) {
+            return [];
+          }
+          parts.push(currentSegment);
+          currentSegment = "";
+        }
+        currentPart = "index";
+        break;
+      }
+      case "]": {
+        if (currentPart === "index") {
+          parts.push(Number.parseInt(currentSegment, 10));
+          currentSegment = "";
+          currentPart = "indexEnd";
+          break;
+        }
+        if (currentPart === "indexEnd") {
+          throw new Error("Invalid character after an index");
+        }
+      }
+      default: {
+        if (currentPart === "index" && !digits.has(character)) {
+          throw new Error("Invalid character in an index");
+        }
+        if (currentPart === "indexEnd") {
+          throw new Error("Invalid character after an index");
+        }
+        if (currentPart === "start") {
+          currentPart = "property";
+        }
+        if (isIgnoring) {
+          isIgnoring = false;
+          currentSegment += "\\";
+        }
+        currentSegment += character;
+      }
+    }
+  }
+  if (isIgnoring) {
+    currentSegment += "\\";
+  }
+  switch (currentPart) {
+    case "property": {
+      if (disallowedKeys.has(currentSegment)) {
+        return [];
+      }
+      parts.push(currentSegment);
+      break;
+    }
+    case "index": {
+      throw new Error("Index was not closed");
+    }
+    case "start": {
+      parts.push("");
+      break;
+    }
+  }
+  return parts;
+}
+__name(getPathSegments, "getPathSegments");
+function isStringIndex(object, key) {
+  if (typeof key !== "number" && Array.isArray(object)) {
+    const index = Number.parseInt(key, 10);
+    return Number.isInteger(index) && object[index] === object[key];
+  }
+  return false;
+}
+__name(isStringIndex, "isStringIndex");
+function assertNotStringIndex(object, key) {
+  if (isStringIndex(object, key)) {
+    throw new Error("Cannot use string index");
+  }
+}
+__name(assertNotStringIndex, "assertNotStringIndex");
+function getProperty(object, path, value) {
+  if (!isObject(object) || typeof path !== "string") {
+    return value === undefined ? object : value;
+  }
+  const pathArray = getPathSegments(path);
+  if (pathArray.length === 0) {
+    return value;
+  }
+  for (let index = 0; index < pathArray.length; index++) {
+    const key = pathArray[index];
+    if (isStringIndex(object, key)) {
+      object = index === pathArray.length - 1 ? undefined : null;
+    } else {
+      object = object[key];
+    }
+    if (object === undefined || object === null) {
+      if (index !== pathArray.length - 1) {
+        return value;
+      }
+      break;
+    }
+  }
+  return object === undefined ? value : object;
+}
+__name(getProperty, "getProperty");
+function setProperty(object, path, value) {
+  if (!isObject(object) || typeof path !== "string") {
+    return object;
+  }
+  const root = object;
+  const pathArray = getPathSegments(path);
+  for (let index = 0; index < pathArray.length; index++) {
+    const key = pathArray[index];
+    assertNotStringIndex(object, key);
+    if (index === pathArray.length - 1) {
+      object[key] = value;
+    } else if (!isObject(object[key])) {
+      object[key] = typeof pathArray[index + 1] === "number" ? [] : {};
+    }
+    object = object[key];
+  }
+  return root;
+}
+__name(setProperty, "setProperty");
+function deleteProperty(object, path) {
+  if (!isObject(object) || typeof path !== "string") {
+    return false;
+  }
+  const pathArray = getPathSegments(path);
+  for (let index = 0; index < pathArray.length; index++) {
+    const key = pathArray[index];
+    assertNotStringIndex(object, key);
+    if (index === pathArray.length - 1) {
+      delete object[key];
+      return true;
+    }
+    object = object[key];
+    if (!isObject(object)) {
+      return false;
+    }
+  }
+}
+__name(deleteProperty, "deleteProperty");
+function hasProperty(object, path) {
+  if (!isObject(object) || typeof path !== "string") {
+    return false;
+  }
+  const pathArray = getPathSegments(path);
+  if (pathArray.length === 0) {
+    return false;
+  }
+  for (const key of pathArray) {
+    if (!isObject(object) || !(key in object) || isStringIndex(object, key)) {
+      return false;
+    }
+    object = object[key];
+  }
+  return true;
+}
+__name(hasProperty, "hasProperty");
+function escapePath(path) {
+  if (typeof path !== "string") {
+    throw new TypeError("Expected a string");
+  }
+  return path.replaceAll(/[\\.[]/g, "\\$&");
+}
+__name(escapePath, "escapePath");
+function entries(value) {
+  const result = Object.entries(value);
+  if (Array.isArray(value)) {
+    return result.map(([key, value2]) => [Number(key), value2]);
+  }
+  return result;
+}
+__name(entries, "entries");
+function stringifyPath(pathSegments) {
+  let result = "";
+  for (let [index, segment] of entries(pathSegments)) {
+    if (typeof segment === "number") {
+      result += `[${segment}]`;
+    } else {
+      segment = escapePath(segment);
+      result += index === 0 ? segment : `.${segment}`;
+    }
+  }
+  return result;
+}
+__name(stringifyPath, "stringifyPath");
+function* deepKeysIterator(object, currentPath = []) {
+  if (!isObject(object) || isEmptyObject(object)) {
+    if (currentPath.length > 0) {
+      yield stringifyPath(currentPath);
+    }
+    return;
+  }
+  for (const [key, value] of entries(object)) {
+    yield* deepKeysIterator(value, [...currentPath, key]);
+  }
+}
+__name(deepKeysIterator, "deepKeysIterator");
+function deepKeys(object) {
+  return [...deepKeysIterator(object)];
+}
+__name(deepKeys, "deepKeys");
+
+exports.deepKeys = deepKeys;
+exports.deleteProperty = deleteProperty;
+exports.escapePath = escapePath;
+exports.getProperty = getProperty;
+exports.hasProperty = hasProperty;
+exports.setProperty = setProperty;