@symbo.ls/utils 3.2.3 → 3.14.0

package/dist/cjs/triggerEvent.js

@@ -0,0 +1,112 @@
+"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 triggerEvent_exports = {};
+__export(triggerEvent_exports, {
+  applyEvent: () => applyEvent,
+  applyEventUpdate: () => applyEventUpdate,
+  triggerEventOn: () => triggerEventOn,
+  triggerEventOnUpdate: () => triggerEventOnUpdate
+});
+module.exports = __toCommonJS(triggerEvent_exports);
+var import_types = require("./types.js");
+var import_function = require("./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 = (0, import_function.resolveHandler)(param, element);
+  if (!(0, import_types.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");
+  }
+  (0, import_function.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 = (0, import_function.resolveHandler)(param, element);
+  if (!(0, import_types.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) => {
+  (0, import_function.runPluginHook)(param, element, updatedObj, options);
+  const appliedFunction = getOnOrPropsEvent(param, element);
+  if (appliedFunction) {
+    const { state, context } = element;
+    return applyEventUpdate(
+      appliedFunction,
+      updatedObj,
+      element,
+      state,
+      context,
+      options
+    );
+  }
+};

package/dist/cjs/types.js

@@ -0,0 +1,74 @@
+"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 types_exports = {};
+__export(types_exports, {
+  TYPES: () => TYPES,
+  is: () => is,
+  isArray: () => isArray,
+  isBoolean: () => isBoolean,
+  isDate: () => isDate,
+  isDefined: () => isDefined,
+  isFunction: () => isFunction,
+  isNot: () => isNot,
+  isNull: () => isNull,
+  isNumber: () => isNumber,
+  isObject: () => isObject,
+  isObjectLike: () => isObjectLike,
+  isString: () => isString,
+  isUndefined: () => isUndefined
+});
+module.exports = __toCommonJS(types_exports);
+var import_node = require("./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: import_node.isNode,
+  htmlElement: import_node.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));
+};

package/dist/cjs/update.js

@@ -0,0 +1,42 @@
+"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 update_exports = {};
+__export(update_exports, {
+  captureSnapshot: () => captureSnapshot
+});
+module.exports = __toCommonJS(update_exports);
+var import_key = require("./key.js");
+const snapshot = {
+  snapshotId: import_key.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];
+};

package/dist/esm/array.js

@@ -0,0 +1,148 @@
+import { deepClone, deepMerge } from "./object.js";
+import { isArray, isNumber, isString } from "./types.js";
+const arrayContainsOtherArray = (arr1, arr2) => {
+  return arr2.every((val) => arr1.includes(val));
+};
+const getFrequencyInArray = (arr, value) => {
+  let count = 0;
+  for (let i = 0; i < arr.length; i++) {
+    if (arr[i] === value) count++;
+  }
+  return count;
+};
+const removeFromArray = (arr, index) => {
+  if (isString(index)) index = parseInt(index);
+  if (isNumber(index)) {
+    if (index < 0 || index >= arr.length || isNaN(index)) {
+      throw new Error("Invalid index");
+    }
+    arr.splice(index, 1);
+  } else {
+    throw new Error("Invalid index");
+  }
+  return arr;
+};
+const swapItemsInArray = (arr, i, j) => {
+  if (i < 0 || j < 0 || i >= arr.length || j >= arr.length) return;
+  [arr[i], arr[j]] = [arr[j], arr[i]];
+};
+const joinArrays = (...arrays) => {
+  return [].concat(...arrays);
+};
+const unstackArrayOfObjects = (arr, exclude = []) => {
+  return arr.reduce(
+    (a, c) => deepMerge(a, deepClone(c, { exclude }), exclude),
+    {}
+  );
+};
+const cutArrayBeforeValue = (arr, value) => {
+  const index = arr.indexOf(value);
+  if (index !== -1) {
+    return arr.slice(0, index);
+  }
+  return arr;
+};
+const cutArrayAfterValue = (arr, value) => {
+  if (!isArray(arr)) return;
+  const index = arr.indexOf(value);
+  if (index !== -1) {
+    return arr.slice(index + 1);
+  }
+  return arr;
+};
+const removeValueFromArray = (arr, value) => {
+  const index = arr.indexOf(value);
+  if (index > -1) {
+    const newArray = [...arr];
+    newArray.splice(index, 1);
+    return newArray;
+  }
+  return arr;
+};
+const removeValueFromArrayAll = (arr, value) => {
+  return arr.filter((item) => item !== value);
+};
+const addItemAfterEveryElement = (array, item) => {
+  const result = [];
+  for (let i = 0; i < array.length; i++) {
+    result.push(array[i]);
+    if (i < array.length - 1) {
+      result.push(item);
+    }
+  }
+  return result;
+};
+const reorderArrayByValues = (array, valueToMove, insertBeforeValue) => {
+  const newArray = [...array];
+  const indexToMove = newArray.indexOf(valueToMove);
+  const indexToInsertBefore = newArray.indexOf(insertBeforeValue);
+  if (indexToMove !== -1 && indexToInsertBefore !== -1) {
+    const removedItem = newArray.splice(indexToMove, 1)[0];
+    const insertIndex = indexToInsertBefore < indexToMove ? indexToInsertBefore : indexToInsertBefore + 1;
+    newArray.splice(insertIndex, 0, removedItem);
+  }
+  return newArray;
+};
+const arraysEqual = (arr1, arr2) => {
+  if (arr1.length !== arr2.length) {
+    return false;
+  }
+  for (let i = 0; i < arr1.length; i++) {
+    if (arr1[i] !== arr2[i]) {
+      return false;
+    }
+  }
+  return true;
+};
+const filterArrays = (sourceArr, excludeArr) => {
+  return sourceArr.filter((item) => !excludeArr.includes(item));
+};
+const filterArraysFast = (sourceArr, excludeArr) => {
+  const excludeSet = new Set(excludeArr);
+  return sourceArr.filter((item) => !excludeSet.has(item));
+};
+const checkIfStringIsInArray = (string, arr) => {
+  if (!string) return 0;
+  let count = 0;
+  for (let i = 0; i < arr.length; i++) {
+    if (string.includes(arr[i])) count++;
+  }
+  return count;
+};
+const removeDuplicatesInArray = (arr) => {
+  if (!isArray(arr)) return arr;
+  return [...new Set(arr)];
+};
+const addProtoToArray = (state, proto) => {
+  for (const key in proto) {
+    Object.defineProperty(state, key, {
+      value: proto[key],
+      enumerable: false,
+      // Set this to true if you want the method to appear in for...in loops
+      configurable: true,
+      // Set this to true if you want to allow redefining/removing the property later
+      writable: true
+      // Set this to true if you want to allow changing the function later
+    });
+  }
+};
+export {
+  addItemAfterEveryElement,
+  addProtoToArray,
+  arrayContainsOtherArray,
+  arraysEqual,
+  checkIfStringIsInArray,
+  cutArrayAfterValue,
+  cutArrayBeforeValue,
+  filterArrays,
+  filterArraysFast,
+  getFrequencyInArray,
+  joinArrays,
+  removeDuplicatesInArray,
+  removeFromArray,
+  removeValueFromArray,
+  removeValueFromArrayAll,
+  reorderArrayByValues,
+  swapItemsInArray,
+  unstackArrayOfObjects
+};

package/dist/esm/browser.js

@@ -0,0 +1,14 @@
+async function toggleFullscreen(opts) {
+  if (!document.fullscreenElement) {
+    try {
+      await (this.node || document).requestFullscreen();
+    } catch (err) {
+      console.warn(`Error attempting to enable fullscreen mode: ${err.message} (${err.name})`);
+    }
+  } else {
+    await document.exitFullscreen();
+  }
+}
+export {
+  toggleFullscreen
+};

package/dist/esm/cache.js

@@ -0,0 +1,6 @@
+const cache = {};
+const OPTIONS = {};
+export {
+  OPTIONS,
+  cache
+};

package/dist/esm/cdn.js

@@ -0,0 +1,65 @@
+function onlyDotsAndNumbers(str) {
+  return /^[0-9.]+$/.test(str) && str !== "";
+}
+const CDN_PROVIDERS = {
+  skypack: {
+    url: "https://cdn.skypack.dev",
+    formatUrl: (pkg, version) => `${CDN_PROVIDERS.skypack.url}/${pkg}${version !== "latest" ? `@${version}` : ""}`
+  },
+  esmsh: {
+    url: "https://esm.sh",
+    formatUrl: (pkg, version) => `${CDN_PROVIDERS.esmsh.url}/${pkg}${version !== "latest" ? `@${version}` : ""}`
+  },
+  unpkg: {
+    url: "https://unpkg.com",
+    formatUrl: (pkg, version) => `${CDN_PROVIDERS.unpkg.url}/${pkg}${version !== "latest" ? `@${version}` : ""}?module`
+  },
+  jsdelivr: {
+    url: "https://cdn.jsdelivr.net/npm",
+    formatUrl: (pkg, version) => `${CDN_PROVIDERS.jsdelivr.url}/${pkg}${version !== "latest" ? `@${version}` : ""}/+esm`
+  },
+  symbols: {
+    url: "https://pkg.symbo.ls",
+    formatUrl: (pkg, version) => {
+      if (pkg.split("/").length > 2 || !onlyDotsAndNumbers(version)) {
+        return `${CDN_PROVIDERS.symbols.url}/${pkg}`;
+      }
+      return `${CDN_PROVIDERS.symbols.url}/${pkg}/${version}.js`;
+    }
+  }
+};
+const PACKAGE_MANAGER_TO_CDN = {
+  "esm.sh": "esmsh",
+  "unpkg": "unpkg",
+  "skypack": "skypack",
+  "jsdelivr": "jsdelivr",
+  "pkg.symbo.ls": "symbols"
+};
+const getCdnProviderFromConfig = (symbolsConfig = {}) => {
+  const { packageManager } = symbolsConfig;
+  return PACKAGE_MANAGER_TO_CDN[packageManager] || null;
+};
+const getCDNUrl = (packageName, version = "latest", provider = "esmsh") => {
+  const cdnConfig = CDN_PROVIDERS[provider] || CDN_PROVIDERS.esmsh;
+  return cdnConfig.formatUrl(packageName, version);
+};
+const getImportMapScript = (data, defaultProvider = "skypack") => {
+  const dependencies = data.dependencies || {};
+  const keys = Object.keys(dependencies);
+  if (!keys.length) return "";
+  const imports = {};
+  for (const pkgName of keys) {
+    const version = dependencies[pkgName] || "latest";
+    imports[pkgName] = getCDNUrl(pkgName, version, defaultProvider);
+  }
+  return `<script type="importmap">{
+    "imports": ${JSON.stringify(imports, null, 2)}
+  }<\/script>`;
+};
+export {
+  CDN_PROVIDERS,
+  PACKAGE_MANAGER_TO_CDN,
+  getCDNUrl,
+  getCdnProviderFromConfig,
+  getImportMapScript
+};

package/dist/esm/component.js

@@ -0,0 +1,25 @@
+import { createExtendsFromKeys } from "./extends.js";
+import { isString } from "./types.js";
+const matchesComponentNaming = (key) => {
+  if (!isString(key) || !key.length) return false;
+  const code = key.charCodeAt(0);
+  return code >= 65 && code <= 90;
+};
+function getCapitalCaseKeys(obj) {
+  return Object.keys(obj).filter((key) => /^[A-Z]/.test(key));
+}
+function getSpreadChildren(obj) {
+  return Object.keys(obj).filter((key) => /^\d+$/.test(key));
+}
+function isContextComponent(element, parent, passedKey) {
+  const { context } = parent || {};
+  const [extendsKey] = createExtendsFromKeys(passedKey);
+  const key = passedKey || extendsKey;
+  return context?.components?.[key] || context?.pages?.[key];
+}
+export {
+  getCapitalCaseKeys,
+  getSpreadChildren,
+  isContextComponent,
+  matchesComponentNaming
+};

package/dist/esm/cookie.js

@@ -0,0 +1,55 @@
+import { isUndefined } from "./types.js";
+import { document } from "./globals.js";
+const isMobile = (() => typeof navigator === "undefined" ? false : /Mobi/.test(navigator.userAgent))();
+const setCookie = (cname, cvalue, exdays = 365) => {
+  if (isUndefined(document) || isUndefined(document.cookie)) return;
+  const d = /* @__PURE__ */ new Date();
+  d.setTime(d.getTime() + exdays * 24 * 60 * 60 * 1e3);
+  const expires = `expires=${d.toUTCString()}`;
+  document.cookie = `${cname}=${cvalue};${expires};path=/`;
+};
+const getCookie = (cname) => {
+  if (isUndefined(document) || isUndefined(document.cookie)) return;
+  const name = `${cname}=`;
+  const decodedCookie = decodeURIComponent(document.cookie);
+  const ca = decodedCookie.split(";");
+  for (let i = 0; i < ca.length; i++) {
+    let c = ca[i];
+    while (c.charAt(0) === " ") c = c.substring(1);
+    if (c.indexOf(name) === 0) return c.substring(name.length, c.length);
+  }
+  return "";
+};
+const removeCookie = (cname) => {
+  if (isUndefined(document) || isUndefined(document.cookie)) return;
+  document.cookie = cname + "=; expires=Thu, 01 Jan 1970 00:00:00 UTC; path=/;";
+};
+function getLocalStorage(key) {
+  if (!window.localStorage) {
+    return void 0;
+  }
+  const item = window.localStorage.getItem(key);
+  if (item === null) {
+    return void 0;
+  }
+  try {
+    return JSON.parse(item);
+  } catch (e) {
+    return void 0;
+  }
+}
+function setLocalStorage(key, data) {
+  if (!window.localStorage || data === void 0 || data === null) {
+    return;
+  }
+  const value = typeof data === "object" ? JSON.stringify(data) : data;
+  window.localStorage.setItem(key, value);
+}
+export {
+  getCookie,
+  getLocalStorage,
+  isMobile,
+  removeCookie,
+  setCookie,
+  setLocalStorage
+};

package/dist/esm/date.js

@@ -0,0 +1,11 @@
+const formatDate = (timestamp) => {
+  if (!timestamp) return "";
+  const d = new Date(timestamp);
+  const ye = new Intl.DateTimeFormat("en", { year: "numeric" }).format(d);
+  const mo = new Intl.DateTimeFormat("en", { month: "short" }).format(d);
+  const da = new Intl.DateTimeFormat("en", { day: "2-digit" }).format(d);
+  return `${da} ${mo}, ${ye}`;
+};
+export {
+  formatDate
+};

package/dist/esm/detectHeight.js

@@ -0,0 +1,42 @@
+const detectHeightOnInit = (element, state) => {
+  const heightTimeout = setTimeout(() => {
+    const { props } = element;
+    if (!state.clientHeight) {
+      const {
+        node: { clientHeight }
+      } = element;
+      if (clientHeight) {
+        state.clientHeight = clientHeight;
+      }
+    }
+    if (state.active) {
+      if (props.height === "auto") return;
+      element.update(
+        {
+          height: state.clientHeight
+        },
+        { preventBeforeUpdateListener: true, preventChildrenUpdate: true }
+      );
+      const setAutoTimeout = setTimeout(() => {
+        element.update(
+          {
+            height: "auto"
+          },
+          { preventBeforeUpdateListener: true, preventChildrenUpdate: true }
+        );
+        clearTimeout(setAutoTimeout);
+      }, 450);
+    } else {
+      element.update(
+        {
+          height: "0"
+        },
+        { preventBeforeUpdateListener: true, preventChildrenUpdate: true }
+      );
+    }
+    clearTimeout(heightTimeout);
+  });
+};
+export {
+  detectHeightOnInit
+};