@cocreate/utils 1.42.0 → 1.42.2

package/dist/cjs/safeParse.js

@@ -0,0 +1,169 @@
+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 safeParse_exports = {};
+__export(safeParse_exports, {
+  safeParse: () => safeParse
+});
+module.exports = __toCommonJS(safeParse_exports);
+const constants = { PI: Math.PI, E: Math.E };
+const functions = {
+  abs: Math.abs,
+  ceil: Math.ceil,
+  floor: Math.floor,
+  round: Math.round,
+  max: Math.max,
+  min: Math.min,
+  pow: Math.pow,
+  sqrt: Math.sqrt,
+  log: Math.log,
+  sin: Math.sin,
+  cos: Math.cos,
+  tan: Math.tan
+};
+function safeParse(expression, context = {}) {
+  if (typeof expression !== "string") {
+    expression = String(expression);
+  }
+  let currentExpr = expression.trim();
+  if (!currentExpr) return null;
+  const tokenizerRegex = /('[^']*'|"[^"]*"|\d+(?:\.\d+)?|>=|<=|===|!==|==|!=|&&|\|\||[a-zA-Z_][a-zA-Z0-9_\.]*|[\+\-\*\/\%\(\)\?\:\>\<\!\,\=])/g;
+  const tokens = currentExpr.match(tokenizerRegex) || [];
+  let pos = 0;
+  function peek() {
+    return tokens[pos];
+  }
+  function consume() {
+    return tokens[pos++];
+  }
+  function parse() {
+    return parseTernary();
+  }
+  function parseTernary() {
+    let left = parseLogical();
+    if (peek() === "?") {
+      consume();
+      let trueExpr = parseTernary();
+      if (peek() === ":") {
+        consume();
+        let falseExpr = parseTernary();
+        return left ? trueExpr : falseExpr;
+      }
+    }
+    return left;
+  }
+  function parseLogical() {
+    let left = parseComparison();
+    while (peek() === "&&" || peek() === "||") {
+      let op = consume();
+      let right = parseComparison();
+      if (op === "&&") left = left && right;
+      if (op === "||") left = left || right;
+    }
+    return left;
+  }
+  function parseComparison() {
+    let left = parseAdditive();
+    while ([">", "<", ">=", "<=", "===", "!==", "==", "!="].includes(peek())) {
+      let op = consume();
+      let right = parseAdditive();
+      if (op === ">") left = left > right;
+      if (op === "<") left = left < right;
+      if (op === ">=") left = left >= right;
+      if (op === "<=") left = left <= right;
+      if (op === "===") left = left === right;
+      if (op === "!==") left = left !== right;
+      if (op === "==") left = left == right;
+      if (op === "!=") left = left != right;
+    }
+    return left;
+  }
+  function parseAdditive() {
+    let left = parseMultiplicative();
+    while (["+", "-"].includes(peek())) {
+      let op = consume();
+      let right = parseMultiplicative();
+      if (op === "+") left = left + right;
+      if (op === "-") left = left - right;
+    }
+    return left;
+  }
+  function parseMultiplicative() {
+    let left = parsePrimary();
+    while (["*", "/", "%"].includes(peek())) {
+      let op = consume();
+      let right = parsePrimary();
+      if (op === "*") left = left * right;
+      if (op === "/") left = left / right;
+      if (op === "%") left = left % right;
+    }
+    return left;
+  }
+  function parsePrimary() {
+    let token = consume();
+    if (!token) return void 0;
+    if (/^\d/.test(token)) return parseFloat(token);
+    if (token.startsWith("'") || token.startsWith('"')) {
+      return token.slice(1, -1);
+    }
+    if (token === "true") return true;
+    if (token === "false") return false;
+    if (token === "(") {
+      let expr = parse();
+      if (peek() === ")") consume();
+      return expr;
+    }
+    if (token === "-") return -parsePrimary();
+    if (token === "!") return !parsePrimary();
+    if (constants.hasOwnProperty(token)) {
+      return constants[token];
+    }
+    if (peek() === "(" && functions.hasOwnProperty(token)) {
+      consume();
+      let args = [];
+      if (peek() !== ")") {
+        args.push(parse());
+        while (peek() === ",") {
+          consume();
+          args.push(parse());
+        }
+      }
+      if (peek() === ")") consume();
+      return functions[token](...args);
+    }
+    let path = token.split(".");
+    let val = context;
+    for (let part of path) {
+      if (val !== null && typeof val === "object" && part in val) {
+        val = val[part];
+      } else {
+        return void 0;
+      }
+    }
+    return val;
+  }
+  try {
+    const result = parse();
+    return result !== void 0 ? result : null;
+  } catch (error) {
+    console.warn(
+      `Unexpected parsing error: ${error.message} (Expression context: "${expression}")`,
+      error
+    );
+    return null;
+  }
+}

package/dist/cjs/uid.js

@@ -0,0 +1,34 @@
+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 uid_exports = {};
+__export(uid_exports, {
+  uid: () => uid
+});
+module.exports = __toCommonJS(uid_exports);
+function uid(length = 36) {
+  let pattern = "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx";
+  if (length > 36) {
+    length = 36;
+  }
+  let uuid = pattern.replace(/[xy]/g, function(c) {
+    var r = Math.random() * 16 | 0;
+    var v = c === "x" ? r : r & 3 | 8;
+    return v.toString(16);
+  }).substring(0, length);
+  return uuid;
+}

package/dist/esm/ObjectId.js

@@ -0,0 +1,35 @@
+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;
+    }
+  };
+}
+export {
+  ObjectId
+};

package/dist/esm/attributes.js

@@ -0,0 +1,45 @@
+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;
+}
+export {
+  getAttributeNames,
+  getAttributes,
+  setAttributeNames
+};

package/dist/esm/checkValue.js

@@ -0,0 +1,7 @@
+function checkValue(value) {
+  if (/{{\s*([\w\W]+)\s*}}/g.test(value)) return false;
+  else return true;
+}
+export {
+  checkValue
+};

package/dist/esm/clickedElement.js

@@ -0,0 +1,29 @@
+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);
+  }
+}
+export {
+  clickedElement
+};

package/dist/esm/core.js

@@ -0,0 +1,14 @@
+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";
+export {
+  ObjectId,
+  checkValue,
+  getRelativePath,
+  isValidDate,
+  objectToSearchParams,
+  uid
+};

package/dist/esm/createUpdate.js

@@ -0,0 +1,185 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+import { dotNotationToObject } from "./dotNotationToObject.js";
+import { objectToDotNotation } from "./objectToDotNotation.js";
+import { getValueFromObject } from "./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 = __spreadValues({}, 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);
+}
+export {
+  createUpdate,
+  dotNotationToObject,
+  getValueFromObject,
+  objectToDotNotation
+};

package/dist/esm/cssPath.js

@@ -0,0 +1,41 @@
+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;
+}
+export {
+  cssPath
+};