@cocreate/utils 1.42.0 → 1.42.2

package/dist/cjs/ObjectId.js

@@ -0,0 +1,54 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var ObjectId_exports = {};
+__export(ObjectId_exports, {
+  ObjectId: () => ObjectId
+});
+module.exports = __toCommonJS(ObjectId_exports);
+let counter = 0;
+function ObjectId(inputId) {
+  if (inputId && /^[0-9a-fA-F]{24}$/.test(inputId)) {
+    return {
+      timestamp: inputId.substring(0, 8),
+      processId: inputId.substring(8, 20),
+      counter: inputId.substring(20),
+      toString: function() {
+        return this.timestamp + this.processId + this.counter;
+      }
+    };
+  } else if (inputId) {
+    throw new Error("Invalid ObjectId provided.");
+  }
+  const timestampHex = Math.floor(
+    new Date((/* @__PURE__ */ new Date()).toISOString()).getTime() / 1e3
+  ).toString(16).padStart(8, "0");
+  const processIdHex = Math.floor(Math.random() * 17592186044416).toString(16).padStart(12, "0");
+  counter = (counter + 1) % 1e4;
+  if (counter < 2) {
+    counter = Math.floor(Math.random() * (5e3 - 100 + 1)) + 100;
+  }
+  const counterHex = counter.toString(16).padStart(4, "0");
+  return {
+    timestamp: timestampHex,
+    processId: processIdHex,
+    counter: counterHex,
+    toString: function() {
+      return this.timestamp + this.processId + this.counter;
+    }
+  };
+}

package/dist/cjs/attributes.js

@@ -0,0 +1,64 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var attributes_exports = {};
+__export(attributes_exports, {
+  getAttributeNames: () => getAttributeNames,
+  getAttributes: () => getAttributes,
+  setAttributeNames: () => setAttributeNames
+});
+module.exports = __toCommonJS(attributes_exports);
+function getAttributes(el) {
+  if (!el) return;
+  let attributes = window.CoCreateConfig.attributes;
+  let object = {};
+  for (let attribute of el.attributes) {
+    let variable = attributes[attribute.name];
+    if (variable) {
+      object[variable] = el.getAttribute(attribute.name);
+    }
+  }
+  return object;
+}
+function getAttributeNames(variables) {
+  let reversedObject = {};
+  for (const key of Object.keys(CoCreateConfig.attributes)) {
+    reversedObject[CoCreateConfig.attributes[key]] = key;
+  }
+  let attributes = [];
+  for (const variable of variables) {
+    let attribute = reversedObject[variable];
+    if (attribute) attributes.push(attribute);
+  }
+  return attributes;
+}
+function setAttributeNames(attributes, overWrite) {
+  let reversedObject = {};
+  for (const key of Object.keys(CoCreateConfig.attributes)) {
+    reversedObject[CoCreateConfig.attributes[key]] = key;
+  }
+  for (const attribute of Object.keys(attributes)) {
+    const variable = attributes[attribute];
+    if (!reversedObject[variable] || overWrite != false)
+      reversedObject[variable] = attribute;
+  }
+  let revertObject = {};
+  for (const key of Object.keys(reversedObject)) {
+    revertObject[reversedObject[key]] = key;
+  }
+  CoCreateConfig.attributes = revertObject;
+}

package/dist/cjs/checkValue.js

@@ -0,0 +1,26 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var checkValue_exports = {};
+__export(checkValue_exports, {
+  checkValue: () => checkValue
+});
+module.exports = __toCommonJS(checkValue_exports);
+function checkValue(value) {
+  if (/{{\s*([\w\W]+)\s*}}/g.test(value)) return false;
+  else return true;
+}

package/dist/cjs/clickedElement.js

@@ -0,0 +1,48 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var clickedElement_exports = {};
+__export(clickedElement_exports, {
+  clickedElement: () => clickedElement
+});
+module.exports = __toCommonJS(clickedElement_exports);
+function clickedElement() {
+  document.addEventListener("click", (e) => {
+    document.clickedElement = e.target;
+  });
+  try {
+    let frames = document.querySelectorAll("iframe");
+    for (let frame of frames) {
+      try {
+        let frameDocument = frame.contentDocument;
+        if (!frameDocument.clickedElementListenerAdded) {
+          frameDocument.addEventListener("click", (e) => {
+            frameDocument.clickedElement = e.target;
+          });
+          frameDocument.clickedElementListenerAdded = true;
+        }
+      } catch (iframeError) {
+        console.log(
+          `Cross-origin frame handling failed for: ${frame}`,
+          iframeError
+        );
+      }
+    }
+  } catch (e) {
+    console.log("Top-level frame document handling failed:", e);
+  }
+}

package/dist/cjs/core.js

@@ -0,0 +1,33 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var core_exports = {};
+__export(core_exports, {
+  ObjectId: () => import_ObjectId.ObjectId,
+  checkValue: () => import_checkValue.checkValue,
+  getRelativePath: () => import_getRelativePath.getRelativePath,
+  isValidDate: () => import_isValidDate.isValidDate,
+  objectToSearchParams: () => import_objectToSearchParams.objectToSearchParams,
+  uid: () => import_uid.uid
+});
+module.exports = __toCommonJS(core_exports);
+var import_getRelativePath = require("./getRelativePath.js");
+var import_ObjectId = require("./ObjectId.js");
+var import_uid = require("./uid.js");
+var import_checkValue = require("./checkValue.js");
+var import_isValidDate = require("./isValidDate.js");
+var import_objectToSearchParams = require("./objectToSearchParams.js");

package/dist/cjs/createUpdate.js

@@ -0,0 +1,188 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var createUpdate_exports = {};
+__export(createUpdate_exports, {
+  createUpdate: () => createUpdate,
+  dotNotationToObject: () => import_dotNotationToObject.dotNotationToObject,
+  getValueFromObject: () => import_getValueFromObject.getValueFromObject,
+  objectToDotNotation: () => import_objectToDotNotation.objectToDotNotation
+});
+module.exports = __toCommonJS(createUpdate_exports);
+var import_dotNotationToObject = require("./dotNotationToObject.js");
+var import_objectToDotNotation = require("./objectToDotNotation.js");
+var import_getValueFromObject = require("./getValueFromObject.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 dotNotationToObjectUpdate(data, object = {}) {
+  try {
+    for (const key of Object.keys(data)) {
+      let newObject = object;
+      let keys = key.replace(/\[(\d+)\]/g, ".$1").split(".").map((k) => isNaN(k) ? k : Number(k));
+      let value = data[key];
+      let operator;
+      if (keys[0].startsWith("$")) operator = keys.shift();
+      let length = keys.length - 1;
+      for (let i = 0; i < keys.length; i++) {
+        if (length == i) {
+          if (operator) {
+            let operators = [
+              "$rename",
+              "$inc",
+              "$push",
+              "$each",
+              "$splice",
+              "$unset",
+              "$delete",
+              "$slice",
+              "$pop",
+              "$shift",
+              "$addToSet",
+              "$pull"
+            ];
+            if (!operators.includes(operator)) continue;
+            if (operator === "$rename") {
+              newObject[value] = newObject[keys[i]];
+              delete newObject[keys[i]];
+            } else if (operator === "$delete" || operator === "$unset" || operator === "$slice") {
+              if (typeof keys[i] === "number") {
+                newObject.splice(keys[i], 1);
+              } else {
+                delete newObject[keys[i]];
+              }
+            } else if (operator === "$shift") {
+              newObject[keys[i]].shift();
+            } else if (operator === "$pop") {
+              newObject[keys[i]].pop();
+            } else if (operator === "$addToSet") {
+              if (!newObject[keys[i]]) newObject[keys[i]] = [];
+              let exists;
+              if (Array.isArray(value)) {
+                exists = newObject[keys[i]].some(
+                  (item) => Array.isArray(item) && isEqualArray(item, value)
+                );
+              } else if (typeof value === "object" && value !== null) {
+                exists = newObject[keys[i]].some(
+                  (item) => typeof item === "object" && isEqualObject(item, value)
+                );
+              } else {
+                exists = newObject[keys[i]].includes(value);
+              }
+              if (!exists) newObject[keys[i]].push(value);
+            } else if (operator === "$pull") {
+              if (!newObject[keys[i]]) continue;
+              if (Array.isArray(value)) {
+                newObject[keys[i]] = newObject[keys[i]].filter(
+                  (item) => !Array.isArray(item) || !isEqualArray(item, value)
+                );
+              } else if (typeof value === "object" && value !== null) {
+                newObject[keys[i]] = newObject[keys[i]].filter(
+                  (item) => typeof item !== "object" || !isEqualObject(item, value)
+                );
+              } else {
+                newObject[keys[i]] = newObject[keys[i]].filter(
+                  (item) => item !== value
+                );
+              }
+            } else if (operator === "$push" || operator === "$splice") {
+              if (typeof keys[i] === "number" && newObject.length >= keys[i])
+                newObject.splice(keys[i], 0, value);
+              else if (newObject[keys[i]]) newObject[keys[i]].push(value);
+              else newObject[keys[i]] = [value];
+            } else if (operator === "$each") {
+              if (!Array.isArray(value)) value = [value];
+              if (typeof keys[i] === "number")
+                newObject.splice(keys[i], 0, ...value);
+              else newObject[keys[i]].push(...value);
+            } else if (operator === "$inc") {
+              if (!newObject[keys[i]] || typeof newObject[keys[i]] !== "number")
+                newObject[keys[i]] = value;
+              else newObject[keys[i]] += value;
+            }
+          } else if (value === void 0) {
+            if (typeof keys[i] === "number") newObject.splice(keys[i], 1);
+            else delete newObject[keys[i]];
+          } else if (typeof keys[i] === "number") {
+            newObject.splice(keys[i], 0, value);
+          } else {
+            newObject[keys[i]] = value;
+          }
+        } else if (typeof keys[i + 1] === "number" && !Array.isArray(newObject[keys[i]])) {
+          newObject[keys[i]] = [];
+        } else {
+          newObject[keys[i]] = newObject[keys[i]] || {};
+        }
+        newObject = newObject[keys[i]];
+      }
+    }
+    return object;
+  } catch (error) {
+    console.log("Error converting dot notation to object", error);
+    return false;
+  }
+}
+function createUpdate(update, data, globalOpertors) {
+  let operatorKeys = {};
+  if (globalOpertors) operatorKeys = { ...globalOpertors };
+  Object.keys(data).forEach((key) => {
+    if (key.startsWith("$")) {
+      if (!key.includes("."))
+        for (let oldkey of Object.keys(data[key]))
+          operatorKeys[key + "." + oldkey] = data[key][oldkey];
+      else operatorKeys[key] = data[key];
+    } else if (typeof data[key] === "string" && data[key].startsWith("$")) {
+      operatorKeys[data[key] + "." + key] = data[key];
+    } else if (key.endsWith("]")) {
+      const regex = /^(.*(?:\[\d+\].*?)?)\[(.*?)\](?:\[\])?$/;
+      const match = key.match(regex);
+      if (match[2] === "") operatorKeys["$push." + match[1]] = data[key];
+      else {
+        let index = parseInt(match[2], 10);
+        if (Number.isNaN(index))
+          operatorKeys[match[2] + "." + match[1]] = data[key];
+        else operatorKeys[key] = data[key];
+      }
+    } else if (key.includes(".")) {
+      operatorKeys[key] = data[key];
+    } else if (data[key] === void 0) {
+      delete update[key];
+    } else update[key] = data[key];
+  });
+  return dotNotationToObjectUpdate(operatorKeys, update);
+}

package/dist/cjs/cssPath.js

@@ -0,0 +1,60 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var cssPath_exports = {};
+__export(cssPath_exports, {
+  cssPath: () => cssPath
+});
+module.exports = __toCommonJS(cssPath_exports);
+function cssPath(node, container) {
+  let pathSplits = [];
+  do {
+    if (!node || !node.tagName) return false;
+    let pathSplit = node.tagName.toLowerCase();
+    if (node.id) {
+      pathSplit += "#" + node.id;
+      node = "";
+    } else {
+      let eid = node.getAttribute("eid");
+      if (eid && !/{{\s*([\w\W]+)\s*}}/g.test(eid)) {
+        pathSplit += `[eid="${eid}"]`;
+        node = "";
+      } else if (node.parentNode && node.parentNode.children.length > 1) {
+        let children = [];
+        for (let child of node.parentNode.children) {
+          if (child.tagName == node.tagName) children.push(child);
+        }
+        let index = Array.prototype.indexOf.call(children, node);
+        pathSplit += `:nth-of-type(${index + 1})`;
+      }
+      node = node.parentNode;
+      if (node == null || node.tagName == "HTML" || node.tagName == "BODY" || node.tagName == "DOM-PARSER" || node.nodeName == "#document" || node.hasAttribute("contenteditable"))
+        node = "";
+    }
+    pathSplits.unshift(pathSplit);
+  } while (node);
+  let path = pathSplits.join(" > ");
+  if (path && path.includes("<")) {
+    let index = path.lastIndexOf(" >");
+    if (index != -1) path = path.slice(0, index);
+    else {
+      index = path.lastIndexOf("<");
+      path = path.slice(0, index);
+    }
+  }
+  return path;
+}