@cocreate/utils 1.42.0 → 1.42.2

package/dist/esm/dataQuery.js

@@ -0,0 +1,261 @@
+import { getValueFromObject } from "./getValueFromObject.js";
+import { isValidDate } from "./isValidDate.js";
+function isEqualArray(arr1, arr2) {
+  if (arr1.length !== arr2.length) {
+    return false;
+  }
+  for (let i = 0; i < arr1.length; i++) {
+    if (!isEqualObject(arr1[i], arr2[i])) {
+      return false;
+    }
+  }
+  return true;
+}
+function isEqualObject(obj1, obj2) {
+  const keys1 = Object.keys(obj1);
+  const keys2 = Object.keys(obj2);
+  if (keys1.length !== keys2.length) {
+    return false;
+  }
+  for (const key of keys1) {
+    if (obj1[key] !== obj2[key]) {
+      return false;
+    }
+  }
+  return true;
+}
+function queryMatch(data, query) {
+  for (let key of Object.keys(query)) {
+    let dataValue;
+    try {
+      dataValue = getValueFromObject(data, key, true);
+    } catch (error) {
+      return false;
+    }
+    if (typeof query[key] === "string" || typeof query[key] === "number" || typeof query[key] === "boolean") {
+      if (Array.isArray(dataValue)) return dataValue.includes(query[key]);
+      else return dataValue === query[key];
+    } else if (Array.isArray(query[key])) {
+      if (Array.isArray(dataValue)) {
+        return isEqualArray(dataValue, query[key]);
+      } else {
+        return false;
+      }
+    } else {
+      for (let property of Object.keys(query[key])) {
+        if (property === "$options") continue;
+        if (!property.startsWith("$")) {
+          if (typeof dataValue !== "object") {
+            return false;
+          } else
+            return queryMatch(
+              { [property]: getValueFromObject(dataValue, property) },
+              { [property]: query[key][property] }
+            );
+        } else {
+          let queryValue = query[key][property];
+          if (isValidDate(queryValue) && isValidDate(dataValue)) {
+            queryValue = new Date(queryValue);
+            dataValue = new Date(dataValue);
+          }
+          let queryStatus = false;
+          switch (property) {
+            case "$eq":
+              if (Array.isArray(dataValue) && Array.isArray(queryValue)) {
+                queryStatus = isEqualArray(dataValue, queryValue);
+              } else {
+                queryStatus = dataValue === queryValue;
+              }
+              break;
+            case "$ne":
+              if (Array.isArray(dataValue) && Array.isArray(queryValue)) {
+                queryStatus = !isEqualArray(dataValue, queryValue);
+              } else {
+                queryStatus = dataValue !== queryValue;
+              }
+              break;
+            case "$not":
+              queryStatus = !queryMatch(data, {
+                [key]: query[key]["$not"]
+              });
+              break;
+            case "$lt":
+              queryStatus = dataValue < queryValue;
+              break;
+            case "$lte":
+              queryStatus = dataValue <= queryValue;
+              break;
+            case "$gt":
+              queryStatus = dataValue > queryValue;
+              break;
+            case "$gte":
+              queryStatus = dataValue >= queryValue;
+              break;
+            case "$in":
+              if (Array.isArray(dataValue)) {
+                queryStatus = dataValue.some(
+                  (element) => queryValue.includes(element)
+                );
+              } else {
+                queryStatus = queryValue.includes(dataValue);
+              }
+              break;
+            case "$nin":
+              if (Array.isArray(dataValue)) {
+                queryStatus = !dataValue.some(
+                  (element) => queryValue.includes(element)
+                );
+              } else {
+                queryStatus = !queryValue.includes(dataValue);
+              }
+              break;
+            case "$all":
+              if (Array.isArray(dataValue) && Array.isArray(queryValue)) {
+                queryStatus = queryValue.every(
+                  (element) => dataValue.includes(element)
+                );
+              }
+              break;
+            case "$elemMatch":
+              if (Array.isArray(data[key])) {
+                queryStatus = data[key].some(
+                  (element) => queryMatch(element, query[key][property])
+                );
+              }
+              break;
+            case "$size":
+              if (Array.isArray(dataValue)) {
+                queryStatus = dataValue.length === queryValue;
+              }
+              break;
+            case "$exists":
+              queryStatus = queryValue ? data.hasOwnProperty(key) : !data.hasOwnProperty(key);
+              break;
+            case "$regex":
+              if (typeof dataValue === "string") {
+                let regexFlag = query[key]["$options"] || "";
+                let regex = new RegExp(queryValue, regexFlag);
+                queryStatus = regex.test(dataValue);
+              }
+              break;
+            case "$type":
+              let dataType = typeof dataValue;
+              if (Array.isArray(dataValue)) {
+                dataType = "array";
+              }
+              queryStatus = dataType === queryValue;
+              break;
+            case "$mod":
+              if (typeof dataValue === "number" && Array.isArray(queryValue) && queryValue.length === 2) {
+                const [divisor, remainder] = queryValue;
+                queryStatus = dataValue % divisor === remainder;
+              }
+              break;
+            case "$where":
+              if (typeof queryValue === "function") {
+                try {
+                } catch (error) {
+                  console.error(
+                    "Error in queryData $where function:",
+                    error
+                  );
+                }
+              }
+              break;
+            default:
+              console.log("unknown operator");
+              break;
+          }
+          if (!queryStatus) return false;
+        }
+      }
+      return true;
+    }
+  }
+}
+function queryData(data, query) {
+  if (query.$and) {
+    for (let i = 0; i < query.$and.length; i++) {
+      if (!queryData(data, query.$and[i])) return false;
+    }
+  }
+  if (query.$nor) {
+    for (let i = 0; i < query.$nor.length; i++) {
+      if (queryData(data, query.$nor[i])) return false;
+    }
+  }
+  for (let key of Object.keys(query)) {
+    if (key === "$and" || key === "$or") continue;
+    if (!queryMatch(data, { [key]: query[key] })) return false;
+  }
+  if (query.$or) {
+    for (let i = 0; i < query.$or.length; i++) {
+      if (queryData(data, query.$or[i])) return true;
+    }
+  }
+  return true;
+}
+function searchData(data, search) {
+  if (!search) return true;
+  if (!Array.isArray(search)) search = [search];
+  for (let i = 0; i < search.length; i++) {
+    let searchValue = search[i].value;
+    if (!Array.isArray(searchValue)) searchValue = [searchValue];
+    for (let key in data) {
+      let value = data[key];
+      let status = false;
+      switch (typeof value) {
+        case "number":
+          value = value.toString();
+          break;
+        case "object":
+          value = JSON.stringify(value);
+          break;
+        case "function":
+          value = value.toString();
+          break;
+      }
+      if (search[i].caseSensitive != "true" || search[i].caseSensitive != true)
+        value = value.toLowerCase();
+      for (let i2 = 0; i2 < searchValue.length; i2++) {
+        let searchString = searchValue[i2];
+        if (search[i2].caseSensitive != "true" || search[i2].caseSensitive != true)
+          searchString = searchString.toLowerCase();
+        if (searchString === "" && search[i2].operator === "and") {
+          if (value !== "") return false;
+        }
+        if (value.indexOf(searchString) > -1) status = true;
+        if (status) return true;
+        else if (search[i2].operator == "and") return false;
+      }
+    }
+    if (search[i].value.length && search[i].operator == "or") return false;
+  }
+  return true;
+}
+function sortData(data, sort) {
+  return data.sort((a, b) => {
+    for (let i = 0; i < sort.length; i++) {
+      let key = sort[i].key;
+      if (a[key] == null && b[key] == null) continue;
+      if (a[key] == null) return sort[i].direction === "desc" ? -1 : 1;
+      if (b[key] == null) return sort[i].direction === "desc" ? 1 : -1;
+      if (typeof a[key] !== typeof b[key]) {
+        return typeof a[key] < typeof b[key] ? -1 : 1;
+      }
+      if (a[key] !== b[key]) {
+        if (typeof a[key] === "string") {
+          return sort[i].direction === "desc" ? b[key].localeCompare(a[key]) : a[key].localeCompare(b[key]);
+        } else {
+          return sort[i].direction === "desc" ? b[key] - a[key] : a[key] - b[key];
+        }
+      }
+    }
+    return 0;
+  });
+}
+export {
+  queryData,
+  searchData,
+  sortData
+};

package/dist/esm/dom.js

@@ -0,0 +1,10 @@
+import { domParser } from "./domParser.js";
+import { parseTextToHtml } from "./parseTextToHtml.js";
+import { escapeHtml } from "./escapeHtml.js";
+import { cssPath } from "./cssPath.js";
+export {
+  cssPath,
+  domParser,
+  escapeHtml,
+  parseTextToHtml
+};

package/dist/esm/domParser.js

@@ -0,0 +1,25 @@
+function domParser(str) {
+  try {
+    var mainTag = str.match(new RegExp("\\<(?<tag>[a-z0-9]+)(.*?)?\\>")).groups.tag;
+  } catch (e) {
+  }
+  let doc;
+  switch (mainTag) {
+    case "html":
+      doc = new DOMParser().parseFromString(str, "text/html");
+      return doc.documentElement;
+    case "body":
+      doc = new DOMParser().parseFromString(str, "text/html");
+      return doc.body;
+    case "head":
+      doc = new DOMParser().parseFromString(str, "text/html");
+      return doc.head;
+    default:
+      let con = document.createElement("dom-parser");
+      con.innerHTML = str;
+      return con;
+  }
+}
+export {
+  domParser
+};

package/dist/esm/dotNotationToObject.js

@@ -0,0 +1,84 @@
+function dotNotationToObject(data, obj = {}) {
+  try {
+    let arrayGroup = {};
+    for (const key of Object.keys(data)) {
+      let value = data[key];
+      let newObject = obj;
+      let oldObject = new Object(obj);
+      let keys = key.split(".");
+      let length = keys.length - 1;
+      for (let i = 0; i < keys.length; i++) {
+        if (keys[i].endsWith("]")) {
+          if (keys[i].endsWith("[]")) {
+            let baseKey = keys[i].slice(0, -2);
+            if (!Array.isArray(newObject[baseKey])) {
+              newObject[baseKey] = [];
+            }
+            if (length == i) {
+              if (Array.isArray(value)) {
+                newObject[baseKey].push(...value);
+              } else {
+                newObject[baseKey].push(value);
+              }
+            }
+          } else if (/\[([0-9]+)\]/g.test(keys[i])) {
+            let [k, index] = keys[i].split("[");
+            index = index.slice(0, -1);
+            if (!Array.isArray(newObject[k])) {
+              newObject[k] = [];
+            }
+            if (length == i) {
+              if (value === void 0) {
+                newObject[k].splice(index, 1);
+              } else {
+                newObject[k][index] = value;
+              }
+            } else {
+              newObject[k][index] = oldObject[k][index] || {};
+              newObject = newObject[k][index];
+              oldObject = oldObject[k][index];
+            }
+          } else if (/\[\w\]/g.test(keys[i])) {
+            let [k, group] = keys[i].split("[");
+            group = group.slice(0, -1);
+            if (!Array.isArray(newObject[k])) {
+              newObject[k] = [];
+            }
+            let index;
+            if (arrayGroup[keys.slice(0, i + 1).join(".")]) {
+              index = arrayGroup[keys.slice(0, i + 1).join(".")];
+            } else {
+              index = newObject[k].length;
+              arrayGroup[keys.slice(0, i + 1).join(".")] = index;
+              newObject[k][index] = {};
+            }
+            if (length == i) {
+              newObject[k][index] = value;
+            } else {
+              newObject = newObject[k][index];
+            }
+          }
+        } else {
+          if (length == i) {
+            if (value === void 0) {
+              delete newObject[keys[i]];
+            } else {
+              newObject[keys[i]] = value;
+            }
+          } else {
+            newObject[keys[i]] = oldObject[keys[i]] || {};
+            newObject = newObject[keys[i]];
+            oldObject = oldObject[keys[i]];
+          }
+        }
+      }
+    }
+    return obj;
+  } catch (error) {
+    console.log("Error converting dot notation to object", error);
+    return false;
+  }
+}
+export {
+  dotNotationToObject
+};

package/dist/esm/escapeHtml.js

@@ -0,0 +1,6 @@
+function escapeHtml(html) {
+  return html.replaceAll("&", "&amp").replaceAll("<", "&lt").replaceAll(">", "&gt;").replaceAll("'", "&#39;").replaceAll('"', "&quot;");
+}
+export {
+  escapeHtml
+};

package/dist/esm/getRelativePath.js

@@ -0,0 +1,20 @@
+function getRelativePath(path) {
+  const isBrowser = typeof window !== "undefined";
+  if (!path && isBrowser) {
+    path = window.location.pathname.replace(/\/[^\/]*$/, "");
+  }
+  if (isBrowser && (location.hostname === "localhost" || location.hostname === "127.0.0.1")) {
+    const srcIndex = path.indexOf("/src");
+    if (srcIndex !== -1) {
+      path = path.slice(srcIndex + 4);
+    }
+  }
+  if (!path.endsWith("/")) {
+    path += "/";
+  }
+  let depth = path.split("/").filter(Boolean).length;
+  return depth > 0 ? "../".repeat(depth) : "./";
+}
+export {
+  getRelativePath
+};

package/dist/esm/getValueFromObject.js

@@ -0,0 +1,22 @@
+function getValueFromObject(object = {}, path = "", throwError = false) {
+  try {
+    if (!Array.isArray(object) && !Object.keys(object).length || !path) {
+      if (throwError) throw new Error("Invalid input to getValueFromObject");
+      return;
+    }
+    path = path.replace(/\[(\d+)\]/g, ".$1").replace(/^\./, "");
+    let data = object, subpath = path.split(".");
+    for (let i = 0; i < subpath.length; i++) {
+      if (throwError && !(subpath[i] in data))
+        throw new Error("Key not found in object: " + subpath[i]);
+      data = data[subpath[i]];
+      if (!data) break;
+    }
+    return data;
+  } catch (error) {
+    if (throwError) throw error;
+  }
+}
+export {
+  getValueFromObject
+};

package/dist/esm/index.js

@@ -0,0 +1,93 @@
+import { getRelativePath } from "./getRelativePath.js";
+import { ObjectId } from "./ObjectId.js";
+import { uid } from "./uid.js";
+import { checkValue } from "./checkValue.js";
+import { isValidDate } from "./isValidDate.js";
+import { objectToSearchParams } from "./objectToSearchParams.js";
+import { dotNotationToObject } from "./dotNotationToObject.js";
+import { objectToDotNotation } from "./objectToDotNotation.js";
+import { getValueFromObject } from "./getValueFromObject.js";
+import { createUpdate } from "./createUpdate.js";
+import { domParser } from "./domParser.js";
+import { parseTextToHtml } from "./parseTextToHtml.js";
+import { escapeHtml } from "./escapeHtml.js";
+import { cssPath } from "./cssPath.js";
+import { queryElements, checkMediaQueries } from "./queryElements.js";
+import { queryData, searchData, sortData } from "./dataQuery.js";
+import { getAttributes, getAttributeNames, setAttributeNames } from "./attributes.js";
+import { clickedElement } from "./clickedElement.js";
+import { processOperators, processOperatorsAsync } from "./operators.js";
+import { getRelativePath as getRelativePath2 } from "./getRelativePath.js";
+import { ObjectId as ObjectId2 } from "./ObjectId.js";
+import { uid as uid2 } from "./uid.js";
+import { checkValue as checkValue2 } from "./checkValue.js";
+import { isValidDate as isValidDate2 } from "./isValidDate.js";
+import { objectToSearchParams as objectToSearchParams2 } from "./objectToSearchParams.js";
+import { dotNotationToObject as dotNotationToObject2 } from "./dotNotationToObject.js";
+import { objectToDotNotation as objectToDotNotation2 } from "./objectToDotNotation.js";
+import { getValueFromObject as getValueFromObject2 } from "./getValueFromObject.js";
+import { createUpdate as createUpdate2 } from "./createUpdate.js";
+import { domParser as domParser2 } from "./domParser.js";
+import { parseTextToHtml as parseTextToHtml2 } from "./parseTextToHtml.js";
+import { escapeHtml as escapeHtml2 } from "./escapeHtml.js";
+import { cssPath as cssPath2 } from "./cssPath.js";
+import { queryElements as queryElements2, checkMediaQueries as checkMediaQueries2 } from "./queryElements.js";
+import { queryData as queryData2, searchData as searchData2, sortData as sortData2 } from "./dataQuery.js";
+import { getAttributes as getAttributes2, getAttributeNames as getAttributeNames2, setAttributeNames as setAttributeNames2 } from "./attributes.js";
+import { processOperators as processOperators2, processOperatorsAsync as processOperatorsAsync2 } from "./operators.js";
+const utils = {
+  getRelativePath: getRelativePath2,
+  ObjectId: ObjectId2,
+  uid: uid2,
+  checkValue: checkValue2,
+  isValidDate: isValidDate2,
+  dotNotationToObject: dotNotationToObject2,
+  objectToDotNotation: objectToDotNotation2,
+  getValueFromObject: getValueFromObject2,
+  objectToSearchParams: objectToSearchParams2,
+  domParser: domParser2,
+  parseTextToHtml: parseTextToHtml2,
+  escapeHtml: escapeHtml2,
+  cssPath: cssPath2,
+  queryElements: queryElements2,
+  checkMediaQueries: checkMediaQueries2,
+  queryData: queryData2,
+  searchData: searchData2,
+  sortData: sortData2,
+  createUpdate: createUpdate2,
+  getAttributes: getAttributes2,
+  setAttributeNames: setAttributeNames2,
+  getAttributeNames: getAttributeNames2,
+  // safeParse,
+  processOperators: processOperators2,
+  processOperatorsAsync: processOperatorsAsync2
+};
+var index_default = utils;
+export {
+  ObjectId,
+  checkMediaQueries,
+  checkValue,
+  clickedElement,
+  createUpdate,
+  cssPath,
+  index_default as default,
+  domParser,
+  dotNotationToObject,
+  escapeHtml,
+  getAttributeNames,
+  getAttributes,
+  getRelativePath,
+  getValueFromObject,
+  isValidDate,
+  objectToDotNotation,
+  objectToSearchParams,
+  parseTextToHtml,
+  processOperators,
+  processOperatorsAsync,
+  queryData,
+  queryElements,
+  searchData,
+  setAttributeNames,
+  sortData,
+  uid
+};

package/dist/esm/init-browser.js

@@ -0,0 +1,4 @@
+import { clickedElement } from "./clickedElement.js";
+if (typeof window !== "undefined" && typeof document !== "undefined") {
+  clickedElement();
+}

package/dist/esm/isValidDate.js

@@ -0,0 +1,13 @@
+function isValidDate(value) {
+  if (typeof value === "string" && value.length >= 20 && value.length <= 24) {
+    if (/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d{3})?([-+]\d{2}:\d{2}|Z)?$/i.test(
+      value
+    )) {
+      return true;
+    }
+  }
+  return false;
+}
+export {
+  isValidDate
+};

package/dist/esm/objectToDotNotation.js

@@ -0,0 +1,34 @@
+function objectToDotNotation(input) {
+  const results = {};
+  function traverse(currentValue, path) {
+    if (typeof currentValue !== "object" || currentValue === null) {
+      if (path !== void 0 && path !== null && path !== "") {
+        results[path] = currentValue;
+      }
+      return;
+    }
+    if (Array.isArray(currentValue)) {
+      if (currentValue.length > 0) {
+        currentValue.forEach((item, index) => {
+          const nextPath = `${path}[${index}]`;
+          traverse(item, nextPath);
+        });
+      } else if (path) {
+      }
+    } else {
+      const keys = Object.keys(currentValue);
+      if (keys.length > 0) {
+        keys.forEach((key) => {
+          const nextPath = path ? `${path}.${key}` : key;
+          traverse(currentValue[key], nextPath);
+        });
+      } else if (path) {
+      }
+    }
+  }
+  traverse(input, "");
+  return results;
+}
+export {
+  objectToDotNotation
+};

package/dist/esm/objectToSearchParams.js

@@ -0,0 +1,23 @@
+function objectToSearchParams(paramsObj) {
+  if (!paramsObj || typeof paramsObj !== "object" || Array.isArray(paramsObj)) {
+    return "";
+  }
+  const filteredObj = {};
+  for (const key in paramsObj) {
+    if (Object.hasOwn(paramsObj, key)) {
+      const value = paramsObj[key];
+      if (value !== null && value !== void 0) {
+        filteredObj[key] = value;
+      }
+    }
+  }
+  if (Object.keys(filteredObj).length === 0) {
+    return "";
+  }
+  const searchParams = new URLSearchParams(filteredObj);
+  const queryString = searchParams.toString();
+  return queryString ? `?${queryString}` : "";
+}
+export {
+  objectToSearchParams
+};