@domql/utils 2.5.154 → 2.5.159

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

@@ -295,7 +295,7 @@ export const objectToString = (obj = {}, indent = 0) => {
     if (isArray(value)) {
       str += '[\n'
       for (const element of value) {
-        if (isObject(element) && element !== null) {
+        if (isObjectLike(element) && element !== null) {
           str += `${spaces}    ${objectToString(element, indent + 2)},\n`
         } else if (isString(element)) {
           // if (element.includes('\n')) str += spaces + '    ' + '`' + element + '`,\n'

package/package.json

@@ -1,15 +1,15 @@
 {
   "name": "@domql/utils",
-  "version": "2.5.154",
+  "version": "2.5.159",
   "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": "3971150df707cdc497b898f2f772946c1deb1fc1",
+  "gitHead": "7595b1077d3096c3ee7b1da5eef02aa9248f2ed6",
   "devDependencies": {
     "@babel/core": "^7.12.0"
   }