@cocreate/utils 1.42.0 → 1.42.2

package/dist/esm/operators.js

@@ -0,0 +1,461 @@
+import { ObjectId } from "./ObjectId.js";
+import { uid } from "./uid.js";
+import { queryElements } from "./queryElements.js";
+import { getValueFromObject } from "./getValueFromObject.js";
+const mathConstants = { PI: Math.PI, E: Math.E };
+const mathFunctions = {
+  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,
+  Number: (v) => Number(v)
+  // Explicit numeric casting
+};
+class Ref {
+  constructor(obj, prop) {
+    this.obj = obj;
+    this.prop = prop;
+  }
+  get() {
+    return this.obj ? this.obj[this.prop] : void 0;
+  }
+  set(val) {
+    if (this.obj) this.obj[this.prop] = val;
+    return val;
+  }
+}
+function unref(val) {
+  return val instanceof Ref ? val.get() : val;
+}
+function safeParse(expression, registry = /* @__PURE__ */ new Map()) {
+  if (typeof expression !== "string") return 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 parseAssignment();
+  }
+  function parseAssignment() {
+    let left = parseTernary();
+    if (peek() === "=") {
+      consume();
+      let right = unref(parseAssignment());
+      if (left instanceof Ref) {
+        return left.set(right);
+      }
+      return right;
+    }
+    return left;
+  }
+  function parseTernary() {
+    let left = parseLogical();
+    if (peek() === "?") {
+      consume();
+      let trueExpr = parseTernary();
+      if (peek() === ":") {
+        consume();
+        let falseExpr = parseTernary();
+        return unref(left) ? unref(trueExpr) : unref(falseExpr);
+      }
+    }
+    return left;
+  }
+  function parseLogical() {
+    let left = parseComparison();
+    while (peek() === "&&" || peek() === "||") {
+      let op = consume();
+      let right = parseComparison();
+      if (op === "&&") left = unref(left) && unref(right);
+      if (op === "||") left = unref(left) || unref(right);
+    }
+    return left;
+  }
+  function parseComparison() {
+    let left = parseAdditive();
+    while ([">", "<", ">=", "<=", "===", "!==", "==", "!="].includes(peek())) {
+      let op = consume();
+      let right = parseAdditive();
+      let l = unref(left), r = unref(right);
+      if (op === ">") left = l > r;
+      if (op === "<") left = l < r;
+      if (op === ">=") left = l >= r;
+      if (op === "<=") left = l <= r;
+      if (op === "===") left = l === r;
+      if (op === "!==") left = l !== r;
+      if (op === "==") left = l == r;
+      if (op === "!=") left = l != r;
+    }
+    return left;
+  }
+  function parseAdditive() {
+    let left = parseMultiplicative();
+    while (["+", "-"].includes(peek())) {
+      let op = consume();
+      let right = parseMultiplicative();
+      if (op === "+") left = unref(left) + unref(right);
+      if (op === "-") left = unref(left) - unref(right);
+    }
+    return left;
+  }
+  function parseMultiplicative() {
+    let left = parsePrimary();
+    while (["*", "/", "%"].includes(peek())) {
+      let op = consume();
+      let right = parsePrimary();
+      if (op === "*") left = unref(left) * unref(right);
+      if (op === "/") left = unref(left) / unref(right);
+      if (op === "%") left = unref(left) % unref(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 = unref(parse());
+      if (peek() === ")") consume();
+      return expr;
+    }
+    if (token === "-") return -unref(parsePrimary());
+    if (token === "!") return !unref(parsePrimary());
+    if (mathConstants.hasOwnProperty(token)) return mathConstants[token];
+    if (peek() === "(" && mathFunctions.hasOwnProperty(token)) {
+      consume();
+      let args = [];
+      if (peek() !== ")") {
+        args.push(unref(parse()));
+        while (peek() === ",") {
+          consume();
+          args.push(unref(parse()));
+        }
+      }
+      if (peek() === ")") consume();
+      return mathFunctions[token](...args);
+    }
+    let path = token.split(".");
+    let baseToken = path[0];
+    let val;
+    if (registry.has(baseToken)) {
+      val = registry.get(baseToken);
+    } else if (typeof window !== "undefined" && window[baseToken]) {
+      val = window[baseToken];
+    } else {
+      val = void 0;
+    }
+    if (path.length === 1) return val;
+    for (let i = 1; i < path.length - 1; i++) {
+      if (val !== null && val !== void 0) {
+        val = val[path[i]];
+      } else {
+        return void 0;
+      }
+    }
+    return new Ref(val, path[path.length - 1]);
+  }
+  try {
+    const result = parse();
+    return unref(result);
+  } catch (error) {
+    console.warn(`safeParse error: ${error.message} (Expr: "${expression}")`, error);
+    return null;
+  }
+}
+const customOperators = new Map(
+  Object.entries({
+    $organization_id: () => localStorage.getItem("organization_id"),
+    $user_id: () => localStorage.getItem("user_id"),
+    $clientId: () => localStorage.getItem("clientId"),
+    $session_id: () => localStorage.getItem("session_id"),
+    $this: (element) => element,
+    $value: (element) => element.getValue() || "",
+    $innerWidth: () => window.innerWidth,
+    $innerHeight: () => window.innerHeight,
+    $href: () => window.location.href.replace(/\/$/, ""),
+    $origin: () => window.location.origin,
+    $protocol: () => window.location.protocol,
+    $hostname: () => window.location.hostname,
+    $host: () => window.location.host,
+    $port: () => window.location.port,
+    $pathname: () => window.location.pathname.replace(/\/$/, ""),
+    $hash: () => window.location.hash,
+    $subdomain: () => getSubdomain() || "",
+    $object_id: () => ObjectId().toString(),
+    "ObjectId()": () => ObjectId().toString(),
+    // Unwrap query results if only one element is found
+    $query: (element, args) => {
+      const results = queryElements({ element, selector: args });
+      return results.length === 1 ? results[0] : results;
+    },
+    $eval: (element, args, context) => safeParse(args, context.registry),
+    $relativePath: () => {
+      let currentPath = window.location.pathname.replace(/\/[^\/]*$/, "");
+      let depth = currentPath.split("/").filter(Boolean).length;
+      return depth > 0 ? "../".repeat(depth) : "./";
+    },
+    $path: () => {
+      let path = window.location.pathname;
+      if (path.split("/").pop().includes(".")) path = path.replace(/\/[^\/]+$/, "/");
+      return path === "/" ? "" : path;
+    },
+    $param: (element, args) => args,
+    $getObjectValue: (element, args) => {
+      if (Array.isArray(args) && args.length >= 2) return getValueFromObject(args[0], args[1]);
+      return "";
+    },
+    $setValue: (element, args) => element.setValue(...args) || "",
+    $true: () => true,
+    $false: () => false,
+    $parse: (element, args) => {
+      let value = args || "";
+      try {
+        return JSON.parse(value);
+      } catch (e) {
+        return value;
+      }
+    },
+    $numberFormat: (element, args) => {
+      let number = parseFloat(args[0]);
+      if (!Array.isArray(args)) args = [args];
+      const locale = args[0] || void 0;
+      const options = args[1] || {};
+      const numCandidate = args[2] !== void 0 ? args[2] : args[0];
+      number = parseFloat(numCandidate);
+      if (isNaN(number)) return String(numCandidate != null ? numCandidate : "");
+      return new Intl.NumberFormat(locale, options).format(number);
+    },
+    $uid: (element, args) => uid(args[0]) || ""
+  })
+);
+const isConstructor = (func, name) => {
+  try {
+    if (typeof func !== "function") return false;
+    if (/^\s*class\s+/.test(func.toString())) return true;
+    if (!func.prototype) return false;
+    const n = name || func.name;
+    if (n && /^[A-Z]/.test(n)) return true;
+  } catch (e) {
+  }
+  return false;
+};
+const findBareOperatorInPath = (path) => {
+  const trimmedPath = path.trim();
+  const match = trimmedPath.match(/^(\$[\w\-]+)/);
+  if (match) {
+    const key = match[1];
+    const remaining = trimmedPath.substring(key.length);
+    if (remaining.length === 0 || /^\s|\[|\./.test(remaining)) return key;
+  }
+  return null;
+};
+const findInnermostFunctionCall = (expression) => {
+  let balance = 0, deepestStart = -1, deepestEnd = -1, deepestBalance = -1;
+  let inSingleQuote = false, inDoubleQuote = false;
+  for (let i = 0; i < expression.length; i++) {
+    const char = expression[i];
+    if (char === '"' && !inSingleQuote) {
+      inDoubleQuote = !inDoubleQuote;
+      continue;
+    } else if (char === "'" && !inDoubleQuote) {
+      inSingleQuote = !inDoubleQuote;
+      continue;
+    }
+    if (inSingleQuote || inDoubleQuote) continue;
+    if (char === "(") {
+      balance++;
+      if (balance > deepestBalance) {
+        deepestBalance = balance;
+        deepestStart = i;
+        deepestEnd = -1;
+      }
+    } else if (char === ")") {
+      if (balance === deepestBalance) deepestEnd = i;
+      balance--;
+    }
+  }
+  if (deepestStart === -1 || deepestEnd === -1 || deepestEnd <= deepestStart) return null;
+  const rawArgs = expression.substring(deepestStart + 1, deepestEnd).trim();
+  let operatorStart = -1, nonWhitespaceFound = false;
+  for (let i = deepestStart - 1; i >= 0; i--) {
+    const char = expression[i];
+    if (!nonWhitespaceFound) {
+      if (/\s/.test(char)) continue;
+      nonWhitespaceFound = true;
+    }
+    if (!/[\w\-\$]/.test(char)) {
+      operatorStart = i + 1;
+      break;
+    }
+    operatorStart = i;
+  }
+  if (operatorStart === -1) operatorStart = 0;
+  const operatorNameCandidate = expression.substring(operatorStart, deepestStart).trim();
+  if (/^\$[\w\-]+$/.test(operatorNameCandidate) || customOperators.has(operatorNameCandidate)) {
+    return { operator: operatorNameCandidate, args: rawArgs, fullMatch: expression.substring(operatorStart, deepestEnd + 1) };
+  }
+  return null;
+};
+const findInnermostOperator = (expression) => {
+  function stripParentheses(str) {
+    let result = str;
+    if (result.startsWith("(")) result = result.substring(1);
+    if (result.endsWith(")")) result = result.substring(0, result.length - 1);
+    return result;
+  }
+  const functionCall = findInnermostFunctionCall(expression);
+  if (functionCall) return { operator: functionCall.operator, args: stripParentheses(functionCall.args), rawContent: functionCall.args, fullMatch: functionCall.fullMatch };
+  const rawContent = expression.trim(), innermostOperator = findBareOperatorInPath(rawContent);
+  if (innermostOperator) return { operator: innermostOperator, args: stripParentheses(rawContent.substring(innermostOperator.length).trim()), rawContent };
+  return { operator: null, args: stripParentheses(rawContent), rawContent };
+};
+function processOperators(element, value, exclude = [], parent, params = [], objectRegistry = /* @__PURE__ */ new Map()) {
+  if (typeof value !== "string" || !value.includes("$") && !value.includes("ObjectId()")) return value;
+  let processedValue = value, hasPromise = false, unresolvedTokens = /* @__PURE__ */ new Map();
+  while (processedValue.includes("$") || processedValue.includes("ObjectId()")) {
+    const paramMatch = processedValue.match(/^\$\$PARAM_(\d+)\$\$/);
+    if (paramMatch && Array.isArray(params) && params.length > 0) {
+      const index = parseInt(paramMatch[1], 10);
+      if (index < params.length) {
+        processedValue = processedValue.replace(paramMatch[0], params[index]);
+        continue;
+      }
+    }
+    const { operator, args, rawContent, fullMatch } = findInnermostOperator(processedValue);
+    if (!operator || operator === "$param" && !args) break;
+    const textToReplace = fullMatch || rawContent;
+    if (exclude.includes(operator)) {
+      const token = `__UNRESOLVED_${unresolvedTokens.size}__`;
+      unresolvedTokens.set(token, textToReplace);
+      processedValue = processedValue.replace(textToReplace, token);
+      continue;
+    }
+    let resolvedValue = resolveOperator(element, operator, args, parent, params, objectRegistry);
+    if (resolvedValue === void 0) {
+      const token = `__UNRESOLVED_${unresolvedTokens.size}__`;
+      unresolvedTokens.set(token, textToReplace);
+      processedValue = processedValue.replace(textToReplace, token);
+      continue;
+    }
+    if (resolvedValue instanceof Promise) {
+      const paramIndex = params.length;
+      params.push(resolvedValue);
+      processedValue = processedValue.replace(textToReplace, `$$PARAM_${paramIndex}$$`);
+      hasPromise = true;
+      break;
+    }
+    if (params.some((p) => p instanceof Promise)) {
+      hasPromise = true;
+      break;
+    }
+    let replacement = "";
+    if (operator === "$param") params.push(resolvedValue);
+    else if (resolvedValue !== null && (typeof resolvedValue === "object" || typeof resolvedValue === "function")) {
+      const token = `__OBJ_${objectRegistry.size}__`;
+      objectRegistry.set(token, resolvedValue);
+      replacement = token;
+    } else replacement = resolvedValue != null ? resolvedValue : "";
+    if (processedValue === textToReplace) {
+      processedValue = replacement;
+      break;
+    }
+    processedValue = processedValue.replace(textToReplace, replacement);
+  }
+  for (const [token, originalText] of unresolvedTokens.entries()) processedValue = processedValue.replace(token, originalText);
+  if (typeof processedValue === "string") {
+    const exactMatch = processedValue.match(/^__OBJ_(\d+)__$/);
+    if (exactMatch && objectRegistry.has(processedValue)) processedValue = objectRegistry.get(processedValue);
+  }
+  if (hasPromise) return { value: processedValue, params, objectRegistry };
+  return processedValue;
+}
+async function processOperatorsAsync(element, value, exclude = [], parent, params = [], objectRegistry = /* @__PURE__ */ new Map()) {
+  let result = processOperators(element, value, exclude, parent, params, objectRegistry);
+  while (typeof result === "object" && result.params) {
+    const resolvedParams = await Promise.all(result.params);
+    result = processOperators(element, result.value, exclude, parent, resolvedParams, result.objectRegistry || objectRegistry);
+  }
+  return result;
+}
+function resolveOperator(element, operator, args, parent, params, objectRegistry) {
+  if (params.some((p) => p instanceof Promise)) return "";
+  if (args && typeof args === "string" && args.includes("$")) {
+    args = processOperators(element, args, [], operator, params, objectRegistry);
+  }
+  let targetElements = element ? [element] : [];
+  if (args && typeof args === "string") {
+    const objMatch = args.match(/^__OBJ_(\d+)__$/);
+    if (objMatch && objectRegistry.has(args)) {
+      targetElements = [objectRegistry.get(args)];
+    } else if (!customOperators.has(operator)) {
+      targetElements = queryElements({ element, selector: args });
+      if (!targetElements.length) return void 0;
+    }
+  }
+  let value = processValues(targetElements, operator, args, parent, objectRegistry);
+  if (value && typeof value === "string" && value.includes("$")) {
+    value = processOperators(element, value, [], parent, params, objectRegistry);
+  }
+  return value;
+}
+function processValues(elements, operator, args, parent, objectRegistry) {
+  let customOp = customOperators.get(operator);
+  let aggregatedString = "";
+  let hasValidProperty = customOp ? true : false;
+  const context = { registry: objectRegistry, element: elements[0] };
+  for (const el of elements) {
+    if (!el) continue;
+    let rawValue = customOp;
+    const propName = customOp ? null : operator.substring(1);
+    if (!customOp) {
+      if (propName in el) {
+        hasValidProperty = true;
+        rawValue = el[propName];
+      } else continue;
+    }
+    if (typeof rawValue === "function") {
+      if (customOp) rawValue = Array.isArray(args) ? rawValue(el, ...args, context) : rawValue(el, args, context);
+      else {
+        if (isConstructor(rawValue, propName)) rawValue = Array.isArray(args) ? new rawValue(...args) : new rawValue(args);
+        else rawValue = Array.isArray(args) ? rawValue.apply(el, args) : rawValue.call(el, args);
+      }
+    }
+    if (parent === "$param") {
+      if (rawValue !== void 0 && rawValue !== null) return rawValue;
+    } else {
+      if (rawValue instanceof Promise || typeof rawValue === "object" && rawValue !== null || typeof rawValue === "function") return rawValue;
+      aggregatedString += String(rawValue != null ? rawValue : "");
+    }
+  }
+  return hasValidProperty ? aggregatedString : void 0;
+}
+function getSubdomain() {
+  const hostname = window.location.hostname, parts = hostname.split(".");
+  if (parts.length > 2 && isNaN(parseInt(parts[parts.length - 1]))) return parts.slice(0, parts.length - 2).join(".");
+  return null;
+}
+export {
+  customOperators,
+  processOperators,
+  processOperatorsAsync
+};

package/dist/esm/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "module"
+}

package/dist/esm/parseTextToHtml.js

@@ -0,0 +1,8 @@
+function parseTextToHtml(text) {
+  let doc = new DOMParser().parseFromString(text, "text/html");
+  if (doc.head.children[0]) return doc.head.children[0];
+  else return doc.body.children[0];
+}
+export {
+  parseTextToHtml
+};

package/dist/esm/queryElements.js

@@ -0,0 +1,136 @@
+const queryTypes = [
+  "$closest",
+  "$parent",
+  "$next",
+  "$previous",
+  "$document",
+  "$frame",
+  "$top"
+];
+const regexPatternString = `(?:${queryTypes.map((type) => type.replace("$", "\\$")).join("|")})`;
+const queryTypesRegex = new RegExp(regexPatternString);
+const mediaRanges = {
+  xs: [0, 575],
+  sm: [576, 768],
+  md: [769, 992],
+  lg: [993, 1200],
+  xl: [1201, 0]
+};
+function checkMediaQueries(selector) {
+  if (selector && selector.includes("@")) {
+    const viewportWidth = window.innerWidth;
+    let mediaViewport = false;
+    let screenSizes = selector.split("@");
+    selector = screenSizes.shift();
+    for (let screenSize of screenSizes) {
+      if (mediaRanges.hasOwnProperty(screenSize)) {
+        const [minWidth, maxWidth] = mediaRanges[screenSize];
+        if (viewportWidth >= minWidth && viewportWidth <= maxWidth) {
+          mediaViewport = true;
+          break;
+        }
+      }
+    }
+    if (!mediaViewport) return false;
+  }
+  return selector;
+}
+function queryType(element, type) {
+  if (!element) return null;
+  switch (type) {
+    case "$top":
+      return window.top.document;
+    case "$frame":
+      if (element.nodeType === 9) return window.frameElement;
+      return element;
+    case "$document":
+      return element.nodeType === 9 ? element : element.ownerDocument;
+    case "$closest":
+      return element.nodeType === 9 ? element : element.ownerDocument;
+    case "$parent":
+      if (element.nodeType === 9) {
+        return element.defaultView !== window.top ? element.defaultView.parent.document : null;
+      }
+      return element.parentElement;
+    case "$next":
+      return element.nextElementSibling;
+    case "$previous":
+      return element.previousElementSibling;
+    default:
+      return null;
+  }
+}
+function querySelector(element, selector) {
+  if (!element) return null;
+  return selector.endsWith("[]") ? element.querySelectorAll(selector.slice(0, -2)) : element.querySelector(selector);
+}
+function queryElements({ element = document, prefix, selector }) {
+  try {
+    let elements = /* @__PURE__ */ new Set();
+    if (!selector && element.nodeType === 1) {
+      if (!prefix) {
+        for (let attr of element.attributes) {
+          if (attr.name.endsWith("-query") || attr.name.endsWith(".query")) {
+            prefix = attr.name.slice(0, -6);
+          }
+        }
+        if (!prefix) return [];
+      }
+      selector = element.getAttribute(prefix + "-query") || element.getAttribute(prefix + ".query");
+      if (!selector) return [];
+    }
+    let selectors = selector.split(/,(?![^()\[\]]*[)\]])/g);
+    for (let i = 0; i < selectors.length; i++) {
+      if (!selectors[i]) continue;
+      let queriedElement = element;
+      if (selectors[i].includes("@")) {
+        selectors[i] = checkMediaQueries(selectors[i]);
+        if (selectors[i] === false) continue;
+      }
+      let remainingSelector = selectors[i].trim();
+      let match;
+      while ((match = queryTypesRegex.exec(remainingSelector)) !== null) {
+        const matchIndex = match.index;
+        const operator = match[0];
+        const part = remainingSelector.substring(0, matchIndex).trim().replace(/,$/, "");
+        if (part) {
+          queriedElement = querySelector(queriedElement, part);
+          if (!queriedElement) break;
+        }
+        remainingSelector = remainingSelector.substring(matchIndex + operator.length).trim();
+        if (operator === "$closest") {
+          let [closest, remaining = ""] = remainingSelector.split(/\s+/, 2);
+          queriedElement = queriedElement.closest(closest);
+          remainingSelector = remaining.trim();
+        } else {
+          queriedElement = queryType(queriedElement, operator);
+        }
+        if (!queriedElement) break;
+      }
+      if (!queriedElement) continue;
+      if (remainingSelector) {
+        queriedElement = querySelector(queriedElement, remainingSelector);
+      }
+      if (Array.isArray(queriedElement) || queriedElement instanceof HTMLCollection || queriedElement instanceof NodeList) {
+        for (let el of queriedElement) {
+          if (el instanceof Element) {
+            elements.add(el);
+          }
+        }
+      } else if (queriedElement instanceof Element) {
+        elements.add(queriedElement);
+      }
+    }
+    return Array.from(elements);
+  } catch (e) {
+    console.error(
+      `CoCreate: Error in queryElements with selector: "${selector}".`,
+      e
+    );
+    return [];
+  }
+}
+export {
+  checkMediaQueries,
+  queryElements
+};