@symbo.ls/utils 3.14.0 → 3.14.1

package/dist/esm/array.js

@@ -1,148 +0,0 @@
-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

@@ -1,14 +0,0 @@
-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

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

package/dist/esm/cdn.js

@@ -1,65 +0,0 @@
-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

@@ -1,25 +0,0 @@
-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

@@ -1,55 +0,0 @@
-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

@@ -1,11 +0,0 @@
-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

@@ -1,42 +0,0 @@
-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
-};

package/dist/esm/element.js

@@ -1,116 +0,0 @@
-import { createExtends } from "./extends.js";
-import { createKey } from "./key.js";
-import { isNode } from "./node.js";
-import { createProps } from "./props.js";
-import { HTML_TAGS } from "./tags.js";
-import { is, isFunction } from "./types.js";
-const ENV = process.env.NODE_ENV;
-const returnValueAsText = (element, parent, key) => {
-  const childExtendsTag = parent.childExtends && parent.childExtends.tag;
-  const childPropsTag = parent.childProps && parent.childProps.tag;
-  const isKeyValidHTMLTag = HTML_TAGS.body.has(key) && key;
-  return {
-    text: element,
-    tag: childExtendsTag || childPropsTag || isKeyValidHTMLTag || "string"
-  };
-};
-const createBasedOnType = (element, parent, key) => {
-  if (element === void 0) {
-    if (ENV === "test" || ENV === "development") {
-      console.warn(
-        key,
-        "element is undefined in",
-        parent?.__ref?.path
-      );
-    }
-    return {};
-  }
-  if (element === null) return;
-  if (element === true) return {};
-  if (is(element)("string", "number")) {
-    return returnValueAsText(element, parent, key);
-  }
-  if (isFunction(element)) {
-    return { props: element };
-  }
-  return element;
-};
-const addRef = (element, parent) => {
-  const ref = {};
-  ref.origin = element;
-  ref.parent = parent;
-  return ref;
-};
-const createParent = (element, parent, key, options, root) => {
-  if (!parent) return root;
-  if (isNode(parent)) {
-    const parentNodeWrapper = { key: ":root", node: parent };
-    root[`${key}_parent`] = parentNodeWrapper;
-    return parentNodeWrapper;
-  }
-  return parent;
-};
-const createRoot = (element, parent) => {
-  const { __ref: ref } = element;
-  const { __ref: parentRef } = parent;
-  const hasRoot = parent && parent.key === ":root";
-  if (!ref?.root) {
-    ref.root = hasRoot ? element : parentRef?.root;
-  }
-};
-const createPath = (element, parent, key) => {
-  let { __ref: parentRef } = parent;
-  if (!parentRef) parentRef = parent.ref = {};
-  if (!parentRef.path) parentRef.path = [];
-  return parentRef.path.concat(key);
-};
-const addContext = (element, parent, key, options, root) => {
-  const forcedOptionsContext = options.context && !root.context && !element.context;
-  if (forcedOptionsContext) root.context = options.context;
-  return options.context || parent.context || root.context || element.context;
-};
-const addCaching = (element, parent, key) => {
-  const ref = addRef(element, parent);
-  element.__ref = ref;
-  if (!ref.__defineCache) ref.__defineCache = {};
-  if (!ref.__exec) ref.__exec = {};
-  if (!ref.__execProps) ref.__execProps = {};
-  if (!ref.__class) ref.__class = {};
-  if (!ref.__classNames) ref.__classNames = {};
-  if (!ref.__attr) ref.__attr = {};
-  if (!ref.__changes) ref.__changes = [];
-  if (!ref.__children) ref.__children = [];
-  ref.__extends = createExtends(element, parent, key);
-  ref.path = createPath(element, parent, key);
-  return ref;
-};
-const createElement = (passedProps, parentEl, passedKey, opts, root) => {
-  const hashed = passedProps?.__hash;
-  const element = hashed ? { extends: [passedProps] } : createBasedOnType(passedProps, parentEl, passedKey);
-  if (!element) return;
-  const parent = createParent(element, parentEl, passedKey, opts, root);
-  const key = createKey(element, parent, passedKey);
-  addCaching(element, parent, key);
-  const props = createProps(element, parent, key);
-  const context = addContext(element, parent, key, opts, root);
-  const on = element.on || {};
-  return {
-    ...element,
-    key,
-    props,
-    parent,
-    context,
-    on
-  };
-};
-export {
-  addCaching,
-  addContext,
-  addRef,
-  createBasedOnType,
-  createElement,
-  createParent,
-  createPath,
-  createRoot,
-  returnValueAsText
-};

package/dist/esm/env.js

@@ -1,23 +0,0 @@
-// @preserve-env
-const NODE_ENV = process.env.NODE_ENV;
-const ENV = NODE_ENV;
-const isProduction = (env = NODE_ENV) => env === "production";
-const isTest = (env = NODE_ENV) => env === "testing" || env === "test";
-const isTesting = isTest;
-const isStaging = (env = NODE_ENV) => env === "staging";
-const isLocal = (env = NODE_ENV) => env === "local";
-const isDevelopment = (env = NODE_ENV) => env === "development" || env === "dev" || env === "local";
-const getNev = (key, env = NODE_ENV) => env[key];
-const isNotProduction = (env = NODE_ENV) => !isProduction(env);
-export {
-  ENV,
-  NODE_ENV,
-  getNev,
-  isDevelopment,
-  isLocal,
-  isNotProduction,
-  isProduction,
-  isStaging,
-  isTest,
-  isTesting
-};

package/dist/esm/events.js

@@ -1,19 +0,0 @@
-import { lowercaseFirstLetter } from "./string.js";
-import { isFunction } from "./types.js";
-function addEventFromProps(key, obj) {
-  const { props, on } = obj;
-  const eventName = lowercaseFirstLetter(key.split("on")[1]);
-  const origEvent = on[eventName];
-  const funcFromProps = props[key];
-  if (isFunction(origEvent)) {
-    on[eventName] = (...args) => {
-      const originalEventRetunrs = origEvent(...args);
-      if (originalEventRetunrs !== false) {
-        if (isFunction(funcFromProps)) return funcFromProps(...args);
-      }
-    };
-  } else on[eventName] = funcFromProps;
-}
-export {
-  addEventFromProps
-};