@symbo.ls/utils 3.2.3 → 3.14.0

package/dist/esm/string.js

@@ -0,0 +1,163 @@
+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*((?:\.\.\/)*)([\w\d.]+)\s*(?:\|\s*([\w\d.]+))?\s*}}/g,
+  3: /{{{(\s*(?:\.\.\/)*)([\w\d.]+)\s*(?:\|\s*([\w\d.]+))?\s*}}}/g
+};
+const getNestedValue = (obj, path) => {
+  return path.split(".").reduce((acc, part) => {
+    return acc?.[part];
+  }, obj);
+};
+function replaceLiteralsWithObjectFields(str, state, options = {}) {
+  const { bracketsLength = 2 } = options;
+  const bracketPattern = bracketsLength === 3 ? "{{{" : "{{";
+  if (!str.includes(bracketPattern)) return str;
+  const reg = brackRegex[bracketsLength];
+  const obj = state || this.state || {};
+  const element = this;
+  return str.replace(reg, (_, parentPath, variable, filter) => {
+    const key = variable.trim();
+    if (filter) {
+      const ctx = element?.context;
+      const filterFn = ctx?.functions?.[filter] || ctx?.utils?.[filter] || ctx?.methods?.[filter] || ctx?.snippets?.[filter] || element?.[filter];
+      if (filterFn && typeof filterFn === "function") {
+        try {
+          return String(filterFn.call(element, key) ?? "");
+        } catch (e) {
+          return "";
+        }
+      }
+      return "";
+    }
+    if (parentPath) {
+      const parentLevels = (parentPath.match(/\.\.\//g) || []).length;
+      let parentState = obj;
+      for (let i = 0; i < parentLevels; i++) {
+        if (!parentState || !parentState.parent) return "";
+        parentState = parentState.parent;
+      }
+      if (key === "parent") {
+        return String(parentState.value ?? "");
+      }
+      const value = getNestedValue(parentState, key);
+      return String(value ?? "");
+    } else {
+      const value = getNestedValue(obj, key);
+      if (value != null) return String(value);
+      const poly = element?.context?.polyglot;
+      if (poly?.translations) {
+        const lang = obj?.root?.lang || obj?.lang || element?.context?.state?.lang || poly.defaultLang || "en";
+        const langT = poly.translations[lang];
+        if (langT) {
+          const tValue = getNestedValue(langT, key);
+          if (tValue != null && typeof tValue !== "object") return String(tValue);
+          for (const section in langT) {
+            const sectionData = langT[section];
+            if (sectionData && typeof sectionData === "object" && !Array.isArray(sectionData)) {
+              const nested = getNestedValue(sectionData, key);
+              if (nested != null && typeof nested !== "object") return String(nested);
+            }
+          }
+        }
+        const topValue = getNestedValue(poly.translations, key);
+        if (topValue != null && typeof topValue !== "object") return String(topValue);
+      }
+      return "";
+    }
+  });
+}
+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 RE_OCTAL = /\\([0-7]{1,3})/g;
+const replaceOctalEscapeSequences = (str) => {
+  return str.replace(RE_OCTAL, (_, p1) => String.fromCharCode(parseInt(p1, 8)));
+};
+const encodeNewlines = (str) => {
+  return str.replace(/\n/g, "/////n").replace(/`/g, "/////tilde").replace(/\$/g, "/////dlrsgn");
+};
+const decodeNewlines = (encodedStr) => {
+  return encodedStr.replace(/\/\/\/\/\/n/g, "\n").replace(/\/\/\/\/\/tilde/g, "`").replace(/\/\/\/\/\/dlrsgn/g, "$");
+};
+const RE_NON_ALNUM = /[^a-zA-Z0-9\s]/g;
+const customEncodeURIComponent = (str) => {
+  return str.replace(
+    RE_NON_ALNUM,
+    (char) => "%" + char.charCodeAt(0).toString(16).toUpperCase()
+  );
+};
+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/style.js

@@ -0,0 +1,20 @@
+const getEmotionStylesheet = () => {
+  const stylesheet = document.styleSheets[0];
+  let str = "";
+  if (stylesheet) {
+    try {
+      const cssRules = stylesheet.cssRules || stylesheet.rules;
+      for (let i = 0; i < cssRules.length; i++) {
+        str += cssRules[i].cssText;
+      }
+    } catch (error) {
+      console.error("Unable to access CSS rules. This may be due to CORS restrictions:", error);
+    }
+  } else {
+    console.log("No stylesheets found in document.styleSheets[0].");
+  }
+  return str;
+};
+export {
+  getEmotionStylesheet
+};

package/dist/esm/tags.js

@@ -0,0 +1,200 @@
+const HTML_TAGS = {
+  root: ["body", "html"],
+  head: ["title", "base", "meta", "style", "noscript", "script"],
+  body: /* @__PURE__ */ new Set([
+    "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",
+    "circle",
+    "ellipse",
+    "line",
+    "polygon",
+    "polyline",
+    "rect",
+    "g",
+    "defs",
+    "symbol",
+    "use",
+    "text",
+    "tspan",
+    "image",
+    "clipPath",
+    "mask",
+    "pattern",
+    "marker",
+    "linearGradient",
+    "radialGradient",
+    "stop",
+    "filter",
+    "feGaussianBlur",
+    "feOffset",
+    "feMerge",
+    "feMergeNode",
+    "feBlend",
+    "feColorMatrix",
+    "feFlood",
+    "feComposite",
+    "foreignObject"
+  ])
+};
+const SVG_TAGS = /* @__PURE__ */ new Set([
+  "svg",
+  "path",
+  "circle",
+  "ellipse",
+  "line",
+  "polygon",
+  "polyline",
+  "rect",
+  "g",
+  "defs",
+  "symbol",
+  "use",
+  "text",
+  "tspan",
+  "image",
+  "clipPath",
+  "mask",
+  "pattern",
+  "marker",
+  "linearGradient",
+  "radialGradient",
+  "stop",
+  "filter",
+  "feGaussianBlur",
+  "feOffset",
+  "feMerge",
+  "feMergeNode",
+  "feBlend",
+  "feColorMatrix",
+  "feFlood",
+  "feComposite",
+  "foreignObject"
+]);
+const isValidHtmlTag = (arg) => HTML_TAGS.body.has(arg);
+export {
+  HTML_TAGS,
+  SVG_TAGS,
+  isValidHtmlTag
+};

package/dist/esm/triggerEvent.js

@@ -0,0 +1,92 @@
+import { isFunction } from "./types.js";
+import { resolveHandler, runPluginHook } from "./function.js";
+const getOnOrPropsEvent = (param, element) => {
+  const propKey = "on" + param.charAt(0).toUpperCase() + param.slice(1);
+  return element[propKey];
+};
+const applyEvent = (param, element, state, context, options) => {
+  param = resolveHandler(param, element);
+  if (!isFunction(param)) return;
+  try {
+    const result = param.call(
+      element,
+      element,
+      state || element.state,
+      context || element.context,
+      options
+    );
+    if (result && typeof result.then === "function") {
+      result.catch((err) => {
+        element.error = err;
+        if (err instanceof ReferenceError) console.warn("[DOMQL] Async event warning:", err.message);
+        else console.error("[DOMQL] Async event error:", err);
+      });
+    }
+    return result;
+  } catch (err) {
+    element.error = err;
+    if (err instanceof ReferenceError) {
+      console.warn("[DOMQL] Event handler warning:", err.message);
+    } else {
+      console.error("[DOMQL] Event handler error:", err);
+    }
+    if (element.context?.strictMode) throw err;
+  }
+};
+const triggerEventOn = (param, element, options) => {
+  if (!element) {
+    throw new Error("Element is required");
+  }
+  runPluginHook(param, element, options);
+  const appliedFunction = getOnOrPropsEvent(param, element);
+  if (appliedFunction) {
+    const { state, context } = element;
+    return applyEvent(appliedFunction, element, state, context, options);
+  }
+};
+const applyEventUpdate = (param, updatedObj, element, state, context, options) => {
+  param = resolveHandler(param, element);
+  if (!isFunction(param)) return;
+  try {
+    const result = param.call(
+      element,
+      updatedObj,
+      element,
+      state || element.state,
+      context || element.context,
+      options
+    );
+    if (result && typeof result.then === "function") {
+      result.catch((err) => {
+        element.error = err;
+        console.error("[DOMQL] Async event update error:", err);
+      });
+    }
+    return result;
+  } catch (err) {
+    element.error = err;
+    console.error("[DOMQL] Event update error:", err);
+    if (element.context?.strictMode) throw err;
+  }
+};
+const triggerEventOnUpdate = (param, updatedObj, element, options) => {
+  runPluginHook(param, element, updatedObj, options);
+  const appliedFunction = getOnOrPropsEvent(param, element);
+  if (appliedFunction) {
+    const { state, context } = element;
+    return applyEventUpdate(
+      appliedFunction,
+      updatedObj,
+      element,
+      state,
+      context,
+      options
+    );
+  }
+};
+export {
+  applyEvent,
+  applyEventUpdate,
+  triggerEventOn,
+  triggerEventOnUpdate
+};

package/dist/esm/types.js

@@ -0,0 +1,54 @@
+import { isHtmlElement, isNode } from "./node.js";
+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) => arg !== void 0;
+const isUndefined = (arg) => 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) => args.some((val) => TYPES[val](arg));
+};
+const isNot = (arg) => {
+  return (...args) => !args.some((val) => TYPES[val](arg));
+};
+export {
+  TYPES,
+  is,
+  isArray,
+  isBoolean,
+  isDate,
+  isDefined,
+  isFunction,
+  isNot,
+  isNull,
+  isNumber,
+  isObject,
+  isObjectLike,
+  isString,
+  isUndefined
+};

package/dist/esm/update.js

@@ -0,0 +1,22 @@
+import { createSnapshotId } from "./key.js";
+const snapshot = {
+  snapshotId: createSnapshotId
+};
+const captureSnapshot = (element, options) => {
+  const ref = element.__ref;
+  const { currentSnapshot, calleeElement } = options;
+  const isCallee = calleeElement === element;
+  if (!calleeElement || isCallee) {
+    const createdStanpshot = snapshot.snapshotId();
+    ref.__currentSnapshot = createdStanpshot;
+    return [createdStanpshot, element];
+  }
+  const snapshotOnCallee = calleeElement.__ref.__currentSnapshot;
+  if (currentSnapshot < snapshotOnCallee) {
+    return [snapshotOnCallee, calleeElement, true];
+  }
+  return [snapshotOnCallee, calleeElement];
+};
+export {
+  captureSnapshot
+};