@domql/utils 2.5.156 → 2.5.161

package/dist/esm/string.js

@@ -0,0 +1,124 @@
+const stringIncludesAny = (str, characters) => {
+  for (const char of characters) {
+    if (str.includes(char)) {
+      return true;
+    }
+  }
+  return false;
+};
+const trimStringFromSymbols = (str, characters) => {
+  const pattern = new RegExp(`[${characters.join("\\")}]`, "g");
+  return str.replace(pattern, "");
+};
+const brackRegex = {
+  2: /\{\{\s*((?:\.\.\/)+)?([^}\s]+)\s*\}\}/g,
+  3: /\{\{\{\s*((?:\.\.\/)+)?([^}\s]+)\s*\}\}\}/g
+};
+const replaceLiteralsWithObjectFields = (str, state, options = {}) => {
+  if (!str.includes(options.bracketsLength === 3 ? "{{{" : "{{"))
+    return str;
+  const reg = brackRegex[options.bracketsLength || 2];
+  return str.replace(reg, (_, parentPath, variable) => {
+    if (parentPath) {
+      const parentLevels = parentPath.match(options.bracketsLength === 3 ? /\.\.\.\//g : /\.\.\//g).length;
+      let parentState = state;
+      for (let i = 0; i < parentLevels; i++) {
+        parentState = parentState.parent;
+        if (!parentState) {
+          return "";
+        }
+      }
+      const value = parentState[variable.trim()];
+      return value !== void 0 ? `${value}` : "";
+    } else {
+      const value = state[variable.trim()];
+      return value !== void 0 ? `${value}` : "";
+    }
+  });
+};
+const lowercaseFirstLetter = (inputString) => {
+  return `${inputString.charAt(0).toLowerCase()}${inputString.slice(1)}`;
+};
+const findKeyPosition = (str, key) => {
+  const lines = str.split("\n");
+  let startLineNumber = -1;
+  let endLineNumber = -1;
+  let startColumn = -1;
+  let endColumn = -1;
+  const keyPattern = new RegExp(`\\b${key}\\b\\s*:\\s*`);
+  let braceCount = 0;
+  let foundKey = false;
+  for (let i = 0; i < lines.length; i++) {
+    if (keyPattern.test(lines[i]) && !foundKey) {
+      foundKey = true;
+      startLineNumber = i + 1;
+      startColumn = lines[i].indexOf(key) + 1;
+      if (lines[i].includes("{}")) {
+        endLineNumber = startLineNumber;
+        endColumn = lines[i].indexOf("{}") + 3;
+        break;
+      }
+      const line = lines[i].slice(startColumn + key.length);
+      if (line.includes("{") || line.includes("[")) {
+        braceCount = 1;
+      } else {
+        endLineNumber = i + 1;
+        endColumn = lines[i].length + 1;
+        break;
+      }
+    } else if (foundKey) {
+      braceCount += (lines[i].match(/{/g) || []).length;
+      braceCount += (lines[i].match(/\[/g) || []).length;
+      braceCount -= (lines[i].match(/}/g) || []).length;
+      braceCount -= (lines[i].match(/]/g) || []).length;
+      if (braceCount === 0) {
+        endLineNumber = i + 1;
+        endColumn = lines[i].lastIndexOf("}") !== -1 ? lines[i].lastIndexOf("}") + 2 : lines[i].length + 1;
+        break;
+      }
+    }
+  }
+  return {
+    startColumn,
+    endColumn,
+    startLineNumber,
+    endLineNumber
+  };
+};
+const replaceOctalEscapeSequences = (str) => {
+  const octalRegex = /\\([0-7]{1,3})/g;
+  return str.replace(octalRegex, (match, p1) => {
+    const octalValue = parseInt(p1, 8);
+    const char = String.fromCharCode(octalValue);
+    return char;
+  });
+};
+const encodeNewlines = (str) => {
+  return str.split("\n").join("/////n").split("`").join("/////tilde").split("$").join("/////dlrsgn");
+};
+const decodeNewlines = (encodedStr) => {
+  return encodedStr.split("/////n").join("\n").split("/////tilde").join("`").split("/////dlrsgn").join("$");
+};
+const customEncodeURIComponent = (str) => {
+  return str.split("").map((char) => {
+    if (/[^a-zA-Z0-9\s]/.test(char)) {
+      return "%" + char.charCodeAt(0).toString(16).toUpperCase();
+    }
+    return char;
+  }).join("");
+};
+const customDecodeURIComponent = (encodedStr) => {
+  return encodedStr.replace(/%[0-9A-Fa-f]{2}/g, (match) => String.fromCharCode(parseInt(match.slice(1), 16)));
+};
+export {
+  customDecodeURIComponent,
+  customEncodeURIComponent,
+  decodeNewlines,
+  encodeNewlines,
+  findKeyPosition,
+  lowercaseFirstLetter,
+  replaceLiteralsWithObjectFields,
+  replaceOctalEscapeSequences,
+  stringIncludesAny,
+  trimStringFromSymbols
+};

package/dist/esm/tags.js

@@ -0,0 +1,145 @@
+const HTML_TAGS = {
+  root: [
+    "body",
+    "html"
+  ],
+  head: [
+    "title",
+    "base",
+    "meta",
+    "style",
+    "noscript",
+    "script"
+  ],
+  body: [
+    "string",
+    "style",
+    "fragment",
+    "a",
+    "abbr",
+    "acronym",
+    "address",
+    "applet",
+    "area",
+    "article",
+    "aside",
+    "audio",
+    "b",
+    "basefont",
+    "bdi",
+    "bdo",
+    "big",
+    "blockquote",
+    "br",
+    "button",
+    "canvas",
+    "caption",
+    "center",
+    "cite",
+    "code",
+    "search",
+    "col",
+    "colgroup",
+    "data",
+    "datalist",
+    "dd",
+    "del",
+    "details",
+    "dfn",
+    "dialog",
+    "dir",
+    "div",
+    "dl",
+    "dt",
+    "em",
+    "embed",
+    "fieldset",
+    "figcaption",
+    "figure",
+    "font",
+    "footer",
+    "form",
+    "frame",
+    "frameset",
+    "h1",
+    "h2",
+    "h3",
+    "h4",
+    "h5",
+    "h6",
+    "head",
+    "header",
+    "hr",
+    "i",
+    "iframe",
+    "img",
+    "input",
+    "ins",
+    "kbd",
+    "label",
+    "legend",
+    "li",
+    "link",
+    "main",
+    "map",
+    "mark",
+    "meter",
+    "nav",
+    "noframes",
+    "noscript",
+    "object",
+    "ol",
+    "optgroup",
+    "option",
+    "output",
+    "p",
+    "param",
+    "picture",
+    "pre",
+    "progress",
+    "hgroup",
+    "q",
+    "rp",
+    "rt",
+    "ruby",
+    "s",
+    "samp",
+    "script",
+    "section",
+    "select",
+    "small",
+    "source",
+    "span",
+    "strike",
+    "strong",
+    "sub",
+    "summary",
+    "sup",
+    "table",
+    "tbody",
+    "td",
+    "template",
+    "hgroup",
+    "textarea",
+    "tfoot",
+    "th",
+    "thead",
+    "time",
+    "tr",
+    "track",
+    "tt",
+    "u",
+    "ul",
+    "var",
+    "video",
+    "wbr",
+    // SVG
+    "svg",
+    "path"
+  ]
+};
+const isValidHtmlTag = (arg) => HTML_TAGS.body.includes(arg);
+export {
+  HTML_TAGS,
+  isValidHtmlTag
+};

package/dist/esm/types.js

@@ -0,0 +1,64 @@
+import { isHtmlElement, isNode } from "./node";
+const isObject = (arg) => {
+  if (arg === null)
+    return false;
+  return typeof arg === "object" && arg.constructor === Object;
+};
+const isString = (arg) => typeof arg === "string";
+const isNumber = (arg) => typeof arg === "number";
+const isFunction = (arg) => typeof arg === "function";
+const isBoolean = (arg) => arg === true || arg === false;
+const isNull = (arg) => arg === null;
+const isArray = (arg) => Array.isArray(arg);
+const isDate = (d) => d instanceof Date;
+const isObjectLike = (arg) => {
+  if (arg === null)
+    return false;
+  return typeof arg === "object";
+};
+const isDefined = (arg) => {
+  return isObject(arg) || isObjectLike(arg) || isString(arg) || isNumber(arg) || isFunction(arg) || isArray(arg) || isObjectLike(arg) || isBoolean(arg) || isDate(arg) || isNull(arg);
+};
+const isUndefined = (arg) => {
+  return arg === void 0;
+};
+const TYPES = {
+  boolean: isBoolean,
+  array: isArray,
+  object: isObject,
+  string: isString,
+  date: isDate,
+  number: isNumber,
+  null: isNull,
+  function: isFunction,
+  objectLike: isObjectLike,
+  node: isNode,
+  htmlElement: isHtmlElement,
+  defined: isDefined
+};
+const is = (arg) => {
+  return (...args) => {
+    return args.map((val) => TYPES[val](arg)).filter((v) => v).length > 0;
+  };
+};
+const isNot = (arg) => {
+  return (...args) => {
+    return args.map((val) => TYPES[val](arg)).filter((v) => v).length === 0;
+  };
+};
+export {
+  TYPES,
+  is,
+  isArray,
+  isBoolean,
+  isDate,
+  isDefined,
+  isFunction,
+  isNot,
+  isNull,
+  isNumber,
+  isObject,
+  isObjectLike,
+  isString,
+  isUndefined
+};

package/object.js

@@ -74,142 +74,96 @@ export const clone = (obj, excludeFrom = []) => {
   return o
 }
 
-// Clone anything deeply but excludeFrom keys given in 'excludeFrom'
-export const deepCloneExclude = (obj, excludeFrom = []) => {
-  if (isArray(obj)) {
-    return obj.map(x => deepCloneExclude(x, excludeFrom))
-  }
-
-  const o = {}
-  for (const k in obj) {
-    const hasOwnProperty = Object.prototype.hasOwnProperty.call(obj, k)
-    if (!hasOwnProperty || excludeFrom.includes(k) || k.startsWith('__')) continue
-
-    let v = obj[k]
-
-    if (k === 'extend' && isArray(v)) {
-      v = mergeArrayExclude(v, excludeFrom)
-    }
-
-    if (isArray(v)) {
-      o[k] = v.map(x => deepCloneExclude(x, excludeFrom))
-    } else if (isObject(v)) {
-      o[k] = deepCloneExclude(v, excludeFrom)
-    } else o[k] = v
-  }
-
-  return o
-}
-
 // Merge array, but exclude keys listed in 'excl'z
-export const mergeArrayExclude = (arr, excl = []) => {
-  return arr.reduce((acc, curr) => deepMerge(acc, deepCloneExclude(curr, excl)), {})
+export const mergeArrayExclude = (arr, exclude = []) => {
+  return arr.reduce((acc, curr) => deepMerge(acc, deepClone(curr, { exclude })), {})
 }
-
 /**
- * Deep cloning of object
+ * Enhanced deep clone function that combines features from multiple implementations
+ * @param {any} obj - Object to clone
+ * @param {Object} options - Configuration options
+ * @param {string[]} options.exclude - Properties to exclude from cloning
+ * @param {boolean} options.cleanUndefined - Remove undefined values
+ * @param {boolean} options.cleanNull - Remove null values
+ * @param {Window} options.window - Window object for cross-frame cloning
+ * @param {WeakMap} options.visited - WeakMap for tracking circular references
+ * @param {boolean} options.handleExtend - Whether to handle 'extend' arrays specially
+ * @returns {any} Cloned object
  */
-export const deepClone = (obj, exclude = [], cleanUndefined = false, visited = new WeakMap()) => {
-  // Handle non-object types, null, and ignored types
-  if (!isObjectLike(obj) || isDOMNode(obj)) return obj
-
-  // Check for circular references
-  if (visited.has(obj)) return visited.get(obj)
-
-  // Create a new object or array
-  const clone = isArray(obj) ? [] : {}
+export const deepClone = (obj, options = {}) => {
+  const {
+    exclude = [],
+    cleanUndefined = false,
+    cleanNull = false,
+    window: targetWindow,
+    visited = new WeakMap(),
+    handleExtend = false
+  } = options
 
-  // Store the clone in the WeakMap to handle circular references
-  visited.set(obj, clone)
-
-  // Iterate over the properties of the object
-  for (const key in obj) {
-    if (Object.prototype.hasOwnProperty.call(obj, key) && !exclude.includes(key)) {
-      const value = obj[key]
-
-      if (isDOMNode(value)) {
-        // Skip cloning for DOM nodes
-        clone[key] = value
-      } else if (key === 'extend' && isArray(value)) {
-        clone[key] = mergeArray(value, exclude)
-      } else if (isObjectLike(value)) {
-        clone[key] = deepClone(value, exclude, cleanUndefined, visited)
-      } else {
-        clone[key] = value
-      }
-    }
+  // Handle non-object types and special cases
+  if (!isObjectLike(obj) || isDOMNode(obj)) {
+    return obj
   }
 
-  return clone
-}
-// export const deepClone = (obj, excludeFrom = [], cleanUndefined = false) => {
-//   const o = isArray(obj) ? [] : {}
-//   for (const prop in obj) {
-//     if (!Object.prototype.hasOwnProperty.call(obj, prop)) continue
-//     // if (prop === 'node' || prop === 'parent' || prop === 'root' || prop === '__element') {
-//     //   console.warn('recursive clonning is called', obj)
-//     //   continue
-//     // }
-//     if (prop === '__proto__') continue
-//     if (excludeFrom.includes(prop) || prop.startsWith('__')) continue
-//     let objProp = obj[prop]
-//     if (cleanUndefined && isUndefined(objProp)) continue
-//     if (prop === 'extend' && isArray(objProp)) {
-//       objProp = mergeArray(objProp)
-//     }
-//     if (isObjectLike(objProp)) {
-//       // queueMicrotask(() => {
-//       o[prop] = deepClone(objProp, excludeFrom, cleanUndefined)
-//       // })
-//     } else o[prop] = objProp
-//   }
-//   return o
-// }
-
-/**
- * Deep cloning of object
- */
-export const deepCloneWithExtend = (obj, excludeFrom = ['node'], options = {}, visited = new WeakSet()) => {
-  // Check if the value is object-like before trying to track it in visited
-  if (isObjectLike(obj)) {
-    if (visited.has(obj)) {
-      return obj // Return the object if it was already cloned
-    }
-    visited.add(obj) // Add to visited set only if it's an object
+  // Handle circular references
+  if (visited.has(obj)) {
+    return visited.get(obj)
   }
 
-  const o = options.window
+  // Create appropriate container based on type and window context
+  const clone = targetWindow
     ? isArray(obj)
-      ? new options.window.Array([])
-      : new options.window.Object({})
+      ? new targetWindow.Array()
+      : new targetWindow.Object()
     : isArray(obj)
       ? []
       : {}
 
-  for (const prop in obj) {
-    if (!Object.prototype.hasOwnProperty.call(obj, prop)) continue
+  // Store the clone to handle circular references
+  visited.set(obj, clone)
 
-    const objProp = obj[prop]
+  // Clone properties
+  for (const key in obj) {
+    if (!Object.prototype.hasOwnProperty.call(obj, key)) continue
+
+    // Skip excluded properties
+    if (exclude.includes(key) || key.startsWith('__') || key === '__proto__') continue
 
-    if (
-      excludeFrom.includes(prop) ||
-      prop.startsWith('__') ||
-      (options.cleanUndefined && isUndefined(objProp)) ||
-      (options.cleanNull && isNull(objProp))
-    ) {
+    const value = obj[key]
+
+    // Skip based on cleanup options
+    if ((cleanUndefined && isUndefined(value)) || (cleanNull && isNull(value))) continue
+
+    // Handle special cases
+    if (isDOMNode(value)) {
+      clone[key] = value
+      continue
+    }
+
+    // Handle 'extend' array if enabled
+    if (handleExtend && key === 'extend' && isArray(value)) {
+      clone[key] = mergeArray(value, exclude)
       continue
     }
 
-    if (isObjectLike(objProp)) {
-      o[prop] = deepCloneWithExtend(objProp, excludeFrom, options, visited)
-    } else if (isFunction(objProp) && options.window) {
-      o[prop] = (options.window || window).eval('(' + objProp.toString() + ')')
+    // Handle functions in cross-frame scenario
+    if (isFunction(value) && targetWindow) {
+      clone[key] = targetWindow.eval('(' + value.toString() + ')')
+      continue
+    }
+
+    // Recursively clone objects
+    if (isObjectLike(value)) {
+      clone[key] = deepClone(value, {
+        ...options,
+        visited
+      })
     } else {
-      o[prop] = objProp
+      clone[key] = value
     }
   }
 
-  return o
+  return clone
 }
 
 /**

package/package.json

@@ -1,15 +1,15 @@
 {
   "name": "@domql/utils",
-  "version": "2.5.156",
+  "version": "2.5.161",
   "license": "MIT",
   "type": "module",
   "module": "index.js",
   "main": "index.js",
   "exports": {
     ".": {
-      "kalduna": "./index.js",
+      "kalduna": "./dist/esm/index.js",
       "default": "./dist/cjs/index.js",
-      "import": "./index.js",
+      "import": "./dist/esm/index.js",
       "require": "./dist/cjs/index.js"
     }
   },
@@ -22,10 +22,10 @@
     "copy:package:cjs": "cp ../../build/package-cjs.json dist/cjs/package.json",
     "build:esm": "npx esbuild *.js --target=es2017 --format=esm --outdir=dist/esm",
     "build:cjs": "npx esbuild *.js --target=node16 --format=cjs --outdir=dist/cjs",
-    "build": "yarn build:cjs",
-    "prepublish": "rimraf -I dist && yarn build && yarn copy:package:cjs"
+    "build": "yarn build:cjs; yarn build:esm",
+    "prepublish": "rimraf -I dist; yarn build; yarn copy:package:cjs"
   },
-  "gitHead": "7e5943ccb3e1b2dd5386d2cfb31474ef446e1521",
+  "gitHead": "39a7af3d77c6b0257d5e1a0d6110850926d83c19",
   "devDependencies": {
     "@babel/core": "^7.12.0"
   }