@symbo.ls/utils 3.2.3 → 3.14.0

package/dist/cjs/state.js

@@ -0,0 +1,173 @@
+"use strict";
+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 state_exports = {};
+__export(state_exports, {
+  applyDependentState: () => applyDependentState,
+  checkForStateTypes: () => checkForStateTypes,
+  checkIfInherits: () => checkIfInherits,
+  createInheritedState: () => createInheritedState,
+  createNestedObjectByKeyPath: () => createNestedObjectByKeyPath,
+  findInheritedState: () => findInheritedState,
+  getChildStateInKey: () => getChildStateInKey,
+  getParentStateInKey: () => getParentStateInKey,
+  getRootStateInKey: () => getRootStateInKey,
+  isState: () => isState,
+  overwriteState: () => overwriteState
+});
+module.exports = __toCommonJS(state_exports);
+var import_array = require("./array.js");
+var import_keys = require("./keys.js");
+var import_object = require("./object.js");
+var import_types = require("./types.js");
+const checkForStateTypes = (element) => {
+  const { state: orig, props, __ref: ref } = element;
+  const state = props?.state || orig;
+  if ((0, import_types.is)(state)("string", "number")) {
+    ref.__state = state;
+    return { value: state };
+  } else if (state === true) {
+    ref.__state = element.key;
+    return {};
+  } else if (state) {
+    ref.__hasRootState = true;
+    return state;
+  } else {
+    return false;
+  }
+};
+const getRootStateInKey = (stateKey, parentState) => {
+  if (!stateKey.includes("~/")) return;
+  const arr = stateKey.split("~/");
+  if (arr.length > 1) return parentState.root;
+};
+const getParentStateInKey = (stateKey, parentState) => {
+  if (!stateKey.includes("../")) return;
+  const arr = stateKey.split("../");
+  const arrLength = arr.length - 1;
+  for (let i = 0; i < arrLength; i++) {
+    if (!parentState.parent) return null;
+    parentState = parentState.parent;
+  }
+  return parentState;
+};
+const getChildStateInKey = (stateKey, parentState, options = {}) => {
+  const arr = (0, import_types.isString)(stateKey) ? stateKey.split("/") : [stateKey];
+  const arrLength = arr.length - 1;
+  for (let i = 0; i < arrLength; i++) {
+    const childKey = arr[i];
+    const grandChildKey = arr[i + 1];
+    if (childKey === "__proto__" || grandChildKey === "__proto__") return;
+    let childInParent = parentState[childKey];
+    if (!childInParent) childInParent = parentState[childKey] = {};
+    if (!childInParent[grandChildKey]) childInParent[grandChildKey] = {};
+    stateKey = grandChildKey;
+    parentState = childInParent;
+  }
+  if (options.returnParent) return parentState;
+  return parentState[stateKey];
+};
+const findInheritedState = (element, parent, options = {}) => {
+  const ref = element.__ref;
+  let stateKey = ref.__state;
+  if (!checkIfInherits(element)) return;
+  const rootState = getRootStateInKey(stateKey, parent.state);
+  let parentState = parent.state;
+  if (rootState) {
+    parentState = rootState;
+    stateKey = stateKey.replaceAll("~/", "");
+  } else {
+    const findGrandParentState = getParentStateInKey(stateKey, parent.state);
+    if (findGrandParentState) {
+      parentState = findGrandParentState;
+      stateKey = stateKey.replaceAll("../", "");
+    }
+  }
+  if (!parentState) return;
+  return getChildStateInKey(stateKey, parentState, options);
+};
+const createInheritedState = (element, parent) => {
+  const ref = element.__ref;
+  const inheritedState = findInheritedState(element, parent);
+  if (inheritedState === void 0) return element.state;
+  if ((0, import_types.is)(inheritedState)("object", "array")) {
+    return (0, import_object.deepClone)(inheritedState);
+  } else if ((0, import_types.is)(inheritedState)("string", "number", "boolean")) {
+    ref.__stateType = typeof inheritedState;
+    return { value: inheritedState };
+  }
+  console.warn(ref.__state, "is not present. Replacing with", {});
+};
+const checkIfInherits = (element) => {
+  const { __ref: ref } = element;
+  const stateKey = ref?.__state;
+  if (stateKey && (0, import_types.is)(stateKey)("number", "string", "boolean")) return true;
+  return false;
+};
+const isState = function(state) {
+  if (!(0, import_types.isObjectLike)(state)) return false;
+  return Boolean(
+    state.update && state.parse && state.clean && state.create && state.parent && state.destroy && state.rootUpdate && state.parentUpdate && state.keys && state.values && state.toggle && state.replace && state.quietUpdate && state.quietReplace && state.add && state.apply && state.applyReplace && state.setByPath && state.setPathCollection && state.removeByPath && state.removePathCollection && state.getByPath && state.applyFunction && state.__element && state.__children
+  );
+};
+const createNestedObjectByKeyPath = (path, value) => {
+  if (!path) {
+    return value || {};
+  }
+  const keys = path.split("/");
+  const obj = {};
+  let ref = obj;
+  const lastIdx = keys.length - 1;
+  for (let i = 0; i <= lastIdx; i++) {
+    ref[keys[i]] = i === lastIdx ? value || {} : {};
+    ref = ref[keys[i]];
+  }
+  return obj;
+};
+const applyDependentState = (element, state) => {
+  const { __element } = state;
+  const origState = __element?.state;
+  if (!origState) return;
+  const dependentState = (0, import_object.deepClone)(origState, import_keys.STATE_METHODS);
+  const newDepends = { [element.key]: dependentState };
+  const __depends = (0, import_types.isObject)(origState.__depends) ? { ...origState.__depends, ...newDepends } : newDepends;
+  if (Array.isArray(origState)) {
+    (0, import_array.addProtoToArray)(origState, {
+      ...Object.getPrototypeOf(origState),
+      __depends
+    });
+  } else {
+    Object.setPrototypeOf(origState, {
+      ...Object.getPrototypeOf(origState),
+      __depends
+    });
+  }
+  return dependentState;
+};
+const overwriteState = (state, obj, options = {}) => {
+  const { overwrite } = options;
+  if (!overwrite) return;
+  const shallow = overwrite === "shallow";
+  const merge = overwrite === "merge";
+  if (merge) {
+    (0, import_object.deepMerge)(state, obj, import_keys.STATE_METHODS);
+    return;
+  }
+  const overwriteFunc = shallow ? import_object.overwriteShallow : import_object.overwriteDeep;
+  overwriteFunc(state, obj, import_keys.STATE_METHODS);
+};

package/dist/cjs/string-extra.js

@@ -0,0 +1,72 @@
+"use strict";
+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 string_extra_exports = {};
+__export(string_extra_exports, {
+  arrayzeValue: () => arrayzeValue,
+  copyJavaScriptToClipboard: () => copyJavaScriptToClipboard,
+  copyStringToClipboard: () => copyStringToClipboard,
+  removeChars: () => removeChars,
+  toCamelCase: () => toCamelCase,
+  toDashCase: () => toDashCase,
+  toDescriptionCase: () => toDescriptionCase,
+  toTitleCase: () => toTitleCase
+});
+module.exports = __toCommonJS(string_extra_exports);
+var import_types = require("./types.js");
+const copyStringToClipboard = async (str) => {
+  try {
+    await navigator.clipboard.writeText(str);
+  } catch (err) {
+    console.warn("Failed to copy text: ", err);
+  }
+};
+const copyJavaScriptToClipboard = async (jsCode) => {
+  try {
+    const blob = new Blob([jsCode], { type: "text/javascript" });
+    const clipboardItem = new window.ClipboardItem({ "text/plain": blob });
+    await navigator.clipboard.write([clipboardItem]);
+    console.log("JavaScript code copied to clipboard as text/javascript");
+  } catch (err) {
+    console.error("Failed to copy JavaScript code: ", err);
+  }
+};
+const removeChars = (str) => {
+  return str.replace(/[^a-zA-Z0-9_]/g, "");
+};
+const toCamelCase = (str) => {
+  if (typeof str !== "string") str = String(str || "");
+  return str.replace(/(?:^\w|[A-Z]|\b\w)/g, function(word, index) {
+    return index === 0 ? word.toLowerCase() : word.toUpperCase();
+  }).replace(/\s+/g, "");
+};
+const toTitleCase = (str) => str && str.replace(/\w\S*/g, (txt) => {
+  return txt.charAt(0).toUpperCase() + txt.substr(1).toLowerCase();
+});
+const toDashCase = (val) => val.replace(/[^a-zA-Z0-9]/g, " ").trim().toLowerCase().replace(/\s+/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
+const toDescriptionCase = (str = "") => {
+  if (typeof str !== "string") return;
+  const result = str.replace(/([A-Z])/g, " $1");
+  return result.charAt(0).toUpperCase() + result.slice(1);
+};
+const arrayzeValue = (val) => {
+  if ((0, import_types.isArray)(val)) return val;
+  if ((0, import_types.isString)(val)) return val.split(" ");
+  if ((0, import_types.isObject)(val)) return Object.values(val);
+  if ((0, import_types.isNumber)(val)) return [val];
+};

package/dist/cjs/string.js

@@ -0,0 +1,183 @@
+"use strict";
+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 string_exports = {};
+__export(string_exports, {
+  customDecodeURIComponent: () => customDecodeURIComponent,
+  customEncodeURIComponent: () => customEncodeURIComponent,
+  decodeNewlines: () => decodeNewlines,
+  encodeNewlines: () => encodeNewlines,
+  findKeyPosition: () => findKeyPosition,
+  lowercaseFirstLetter: () => lowercaseFirstLetter,
+  replaceLiteralsWithObjectFields: () => replaceLiteralsWithObjectFields,
+  replaceOctalEscapeSequences: () => replaceOctalEscapeSequences,
+  stringIncludesAny: () => stringIncludesAny,
+  trimStringFromSymbols: () => trimStringFromSymbols
+});
+module.exports = __toCommonJS(string_exports);
+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))
+  );
+};

package/dist/cjs/style.js

@@ -16,14 +16,12 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/style.js
 var style_exports = {};
 __export(style_exports, {
   getEmotionStylesheet: () => getEmotionStylesheet
 });
 module.exports = __toCommonJS(style_exports);
-var getEmotionStylesheet = () => {
+const getEmotionStylesheet = () => {
   const stylesheet = document.styleSheets[0];
   let str = "";
   if (stylesheet) {

package/dist/cjs/tags.js

@@ -0,0 +1,220 @@
+"use strict";
+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 tags_exports = {};
+__export(tags_exports, {
+  HTML_TAGS: () => HTML_TAGS,
+  SVG_TAGS: () => SVG_TAGS,
+  isValidHtmlTag: () => isValidHtmlTag
+});
+module.exports = __toCommonJS(tags_exports);
+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);