@dxtmisha/functional-basic 0.1.1 → 0.1.4

package/src/classes/__tests__/MetaTwitter.test.ts

@@ -1,423 +0,0 @@
-/**
- * @vitest-environment jsdom
- */
-
-import { describe, it, expect, beforeEach, afterEach } from 'vitest'
-import { MetaTwitter } from '../MetaTwitter'
-import { MetaTwitterCard } from '../../types/metaTypes'
-
-describe('MetaTwitter', () => {
-  let metaTwitter: MetaTwitter
-
-  beforeEach(() => {
-    // Очистка DOM перед каждым тестом
-    document.head.innerHTML = ''
-
-    metaTwitter = new MetaTwitter()
-  })
-
-  afterEach(() => {
-    // Очистка после тестов
-    document.head.innerHTML = ''
-  })
-
-  describe('constructor', () => {
-    it('should create MetaTwitter instance', () => {
-      expect(metaTwitter).toBeInstanceOf(MetaTwitter)
-    })
-
-    it('should initialize with all Twitter Card tags', () => {
-      const listMeta = metaTwitter.getListMeta()
-
-      expect(listMeta).toContain('twitter:card')
-      expect(listMeta).toContain('twitter:site')
-      expect(listMeta).toContain('twitter:creator')
-      expect(listMeta).toContain('twitter:url')
-      expect(listMeta).toContain('twitter:title')
-      expect(listMeta).toContain('twitter:description')
-      expect(listMeta).toContain('twitter:image')
-    })
-
-    it('should read existing Twitter tags from DOM on initialization', () => {
-      // Создаем Twitter теги в DOM
-      const titleMeta = document.createElement('meta')
-      titleMeta.setAttribute('name', 'twitter:title')
-      titleMeta.setAttribute('content', 'Existing Twitter Title')
-      document.head.appendChild(titleMeta)
-
-      const descMeta = document.createElement('meta')
-      descMeta.setAttribute('name', 'twitter:description')
-      descMeta.setAttribute('content', 'Existing Twitter Description')
-      document.head.appendChild(descMeta)
-
-      // Создаем новый экземпляр
-      const newMetaTwitter = new MetaTwitter()
-
-      // Должен прочитать существующие теги
-      expect(newMetaTwitter.getTitle()).toBe('Existing Twitter Title')
-      expect(newMetaTwitter.getDescription()).toBe('Existing Twitter Description')
-    })
-  })
-
-  describe('getCard', () => {
-    it('should return empty string when card not set', () => {
-      expect(metaTwitter.getCard()).toBe('')
-    })
-
-    it('should return card type after setting', () => {
-      metaTwitter.setCard(MetaTwitterCard.summaryLargeImage)
-      expect(metaTwitter.getCard()).toBe(MetaTwitterCard.summaryLargeImage)
-    })
-  })
-
-  describe('getSite', () => {
-    it('should return empty string when site not set', () => {
-      expect(metaTwitter.getSite()).toBe('')
-    })
-
-    it('should return site after setting', () => {
-      metaTwitter.setSite('@mywebsite')
-      expect(metaTwitter.getSite()).toBe('@mywebsite')
-    })
-  })
-
-  describe('getCreator', () => {
-    it('should return empty string when creator not set', () => {
-      expect(metaTwitter.getCreator()).toBe('')
-    })
-
-    it('should return creator after setting', () => {
-      metaTwitter.setCreator('@author')
-      expect(metaTwitter.getCreator()).toBe('@author')
-    })
-  })
-
-  describe('getUrl', () => {
-    it('should return empty string when URL not set', () => {
-      expect(metaTwitter.getUrl()).toBe('')
-    })
-
-    it('should return URL after setting', () => {
-      metaTwitter.setUrl('https://example.com/page')
-      expect(metaTwitter.getUrl()).toBe('https://example.com/page')
-    })
-  })
-
-  describe('getTitle', () => {
-    it('should return empty string when title not set', () => {
-      expect(metaTwitter.getTitle()).toBe('')
-    })
-
-    it('should return title after setting', () => {
-      metaTwitter.setTitle('Twitter Card Title')
-      expect(metaTwitter.getTitle()).toBe('Twitter Card Title')
-    })
-  })
-
-  describe('getDescription', () => {
-    it('should return empty string when description not set', () => {
-      expect(metaTwitter.getDescription()).toBe('')
-    })
-
-    it('should return description after setting', () => {
-      metaTwitter.setDescription('Twitter Card Description')
-      expect(metaTwitter.getDescription()).toBe('Twitter Card Description')
-    })
-  })
-
-  describe('getImage', () => {
-    it('should return empty string when image not set', () => {
-      expect(metaTwitter.getImage()).toBe('')
-    })
-
-    it('should return image URL after setting', () => {
-      metaTwitter.setImage('https://example.com/twitter-image.jpg')
-      expect(metaTwitter.getImage()).toBe('https://example.com/twitter-image.jpg')
-    })
-  })
-
-  describe('setCard', () => {
-    it('should set Twitter card type', () => {
-      metaTwitter.setCard(MetaTwitterCard.summary)
-      expect(metaTwitter.getCard()).toBe(MetaTwitterCard.summary)
-    })
-
-    it('should create meta tag in DOM', () => {
-      metaTwitter.setCard(MetaTwitterCard.summaryLargeImage)
-
-      const element = document.querySelector('meta[name="twitter:card"]')
-      expect(element).toBeTruthy()
-      expect(element?.getAttribute('content')).toBe('summary_large_image')
-    })
-
-    it('should handle all Twitter Card types', () => {
-      const types = [
-        MetaTwitterCard.summary,
-        MetaTwitterCard.summaryLargeImage,
-        MetaTwitterCard.app,
-        MetaTwitterCard.player
-      ]
-
-      types.forEach((type) => {
-        metaTwitter.setCard(type)
-        expect(metaTwitter.getCard()).toBe(type)
-      })
-    })
-
-    it('should return this for chaining', () => {
-      const result = metaTwitter.setCard(MetaTwitterCard.summary)
-      expect(result).toBe(metaTwitter)
-    })
-  })
-
-  describe('setSite', () => {
-    it('should set Twitter site username', () => {
-      metaTwitter.setSite('@mysite')
-      expect(metaTwitter.getSite()).toBe('@mysite')
-    })
-
-    it('should create meta tag in DOM', () => {
-      metaTwitter.setSite('@example')
-
-      const element = document.querySelector('meta[name="twitter:site"]')
-      expect(element).toBeTruthy()
-      expect(element?.getAttribute('content')).toBe('@example')
-    })
-
-    it('should update existing meta tag', () => {
-      metaTwitter.setSite('@first')
-      metaTwitter.setSite('@second')
-
-      const elements = document.querySelectorAll('meta[name="twitter:site"]')
-      expect(elements.length).toBe(1)
-      expect(elements?.[0]?.getAttribute('content')).toBe('@second')
-    })
-
-    it('should return this for chaining', () => {
-      const result = metaTwitter.setSite('@test')
-      expect(result).toBe(metaTwitter)
-    })
-  })
-
-  describe('setCreator', () => {
-    it('should set Twitter creator username', () => {
-      metaTwitter.setCreator('@creator')
-      expect(metaTwitter.getCreator()).toBe('@creator')
-    })
-
-    it('should create meta tag in DOM', () => {
-      metaTwitter.setCreator('@author')
-
-      const element = document.querySelector('meta[name="twitter:creator"]')
-      expect(element).toBeTruthy()
-      expect(element?.getAttribute('content')).toBe('@author')
-    })
-
-    it('should handle usernames with and without @', () => {
-      metaTwitter.setCreator('username')
-      expect(metaTwitter.getCreator()).toBe('username')
-
-      metaTwitter.setCreator('@username')
-      expect(metaTwitter.getCreator()).toBe('@username')
-    })
-
-    it('should return this for chaining', () => {
-      const result = metaTwitter.setCreator('@test')
-      expect(result).toBe(metaTwitter)
-    })
-  })
-
-  describe('setUrl', () => {
-    it('should set Twitter card URL', () => {
-      metaTwitter.setUrl('https://example.com/article')
-      expect(metaTwitter.getUrl()).toBe('https://example.com/article')
-    })
-
-    it('should create meta tag in DOM', () => {
-      metaTwitter.setUrl('https://example.com/page')
-
-      const element = document.querySelector('meta[name="twitter:url"]')
-      expect(element).toBeTruthy()
-      expect(element?.getAttribute('content')).toBe('https://example.com/page')
-    })
-
-    it('should handle URLs with query parameters', () => {
-      const url = 'https://example.com/page?param=value&other=test'
-      metaTwitter.setUrl(url)
-      expect(metaTwitter.getUrl()).toBe(url)
-    })
-
-    it('should return this for chaining', () => {
-      const result = metaTwitter.setUrl('https://example.com')
-      expect(result).toBe(metaTwitter)
-    })
-  })
-
-  describe('setTitle', () => {
-    it('should set Twitter card title', () => {
-      metaTwitter.setTitle('Test Twitter Title')
-      expect(metaTwitter.getTitle()).toBe('Test Twitter Title')
-    })
-
-    it('should create meta tag in DOM', () => {
-      metaTwitter.setTitle('DOM Title Test')
-
-      const element = document.querySelector('meta[name="twitter:title"]')
-      expect(element).toBeTruthy()
-      expect(element?.getAttribute('content')).toBe('DOM Title Test')
-    })
-
-    it('should update existing meta tag', () => {
-      metaTwitter.setTitle('First Title')
-      metaTwitter.setTitle('Second Title')
-
-      const elements = document.querySelectorAll('meta[name="twitter:title"]')
-      expect(elements.length).toBe(1)
-      expect(elements?.[0]?.getAttribute('content')).toBe('Second Title')
-    })
-
-    it('should handle empty string', () => {
-      metaTwitter.setTitle('')
-      expect(metaTwitter.getTitle()).toBe('')
-    })
-
-    it('should handle special characters', () => {
-      metaTwitter.setTitle('Title with "quotes" & <tags>')
-      expect(metaTwitter.getTitle()).toBe('Title with "quotes" & <tags>')
-    })
-
-    it('should return this for chaining', () => {
-      const result = metaTwitter.setTitle('Chain Test')
-      expect(result).toBe(metaTwitter)
-    })
-  })
-
-  describe('setDescription', () => {
-    it('should set Twitter card description', () => {
-      metaTwitter.setDescription('Test Twitter Description')
-      expect(metaTwitter.getDescription()).toBe('Test Twitter Description')
-    })
-
-    it('should create meta tag in DOM', () => {
-      metaTwitter.setDescription('DOM Description Test')
-
-      const element = document.querySelector('meta[name="twitter:description"]')
-      expect(element).toBeTruthy()
-      expect(element?.getAttribute('content')).toBe('DOM Description Test')
-    })
-
-    it('should update existing meta tag', () => {
-      metaTwitter.setDescription('First Description')
-      metaTwitter.setDescription('Second Description')
-
-      const elements = document.querySelectorAll('meta[name="twitter:description"]')
-      expect(elements.length).toBe(1)
-      expect(elements?.[0]?.getAttribute('content')).toBe('Second Description')
-    })
-
-    it('should handle long descriptions', () => {
-      const longDesc = 'A'.repeat(200)
-      metaTwitter.setDescription(longDesc)
-      expect(metaTwitter.getDescription()).toBe(longDesc)
-    })
-
-    it('should return this for chaining', () => {
-      const result = metaTwitter.setDescription('Chain Test')
-      expect(result).toBe(metaTwitter)
-    })
-  })
-
-  describe('setImage', () => {
-    it('should set Twitter card image URL', () => {
-      metaTwitter.setImage('https://example.com/twitter-image.jpg')
-      expect(metaTwitter.getImage()).toBe('https://example.com/twitter-image.jpg')
-    })
-
-    it('should create meta tag in DOM', () => {
-      metaTwitter.setImage('https://example.com/twitter-card.png')
-
-      const element = document.querySelector('meta[name="twitter:image"]')
-      expect(element).toBeTruthy()
-      expect(element?.getAttribute('content')).toBe('https://example.com/twitter-card.png')
-    })
-
-    it('should handle different image formats', () => {
-      const formats = [
-        'https://example.com/image.jpg',
-        'https://example.com/image.png',
-        'https://example.com/image.webp',
-        'https://example.com/image.gif'
-      ]
-
-      formats.forEach((format) => {
-        metaTwitter.setImage(format)
-        expect(metaTwitter.getImage()).toBe(format)
-      })
-    })
-
-    it('should return this for chaining', () => {
-      const result = metaTwitter.setImage('https://example.com/img.jpg')
-      expect(result).toBe(metaTwitter)
-    })
-  })
-
-  describe('method chaining', () => {
-    it('should allow chaining multiple setter methods', () => {
-      const result = metaTwitter
-        .setCard(MetaTwitterCard.summaryLargeImage)
-        .setSite('@mysite')
-        .setCreator('@author')
-        .setUrl('https://example.com/article')
-        .setTitle('Chained Title')
-        .setDescription('Chained Description')
-        .setImage('https://example.com/image.jpg')
-
-      expect(result).toBe(metaTwitter)
-      expect(metaTwitter.getCard()).toBe(MetaTwitterCard.summaryLargeImage)
-      expect(metaTwitter.getSite()).toBe('@mysite')
-      expect(metaTwitter.getCreator()).toBe('@author')
-      expect(metaTwitter.getUrl()).toBe('https://example.com/article')
-      expect(metaTwitter.getTitle()).toBe('Chained Title')
-      expect(metaTwitter.getDescription()).toBe('Chained Description')
-      expect(metaTwitter.getImage()).toBe('https://example.com/image.jpg')
-    })
-
-    it('should create all meta tags in DOM when chaining', () => {
-      metaTwitter
-        .setCard(MetaTwitterCard.summary)
-        .setSite('@site')
-        .setTitle('Title')
-        .setDescription('Description')
-
-      expect(document.querySelector('meta[name="twitter:card"]')).toBeTruthy()
-      expect(document.querySelector('meta[name="twitter:site"]')).toBeTruthy()
-      expect(document.querySelector('meta[name="twitter:title"]')).toBeTruthy()
-      expect(document.querySelector('meta[name="twitter:description"]')).toBeTruthy()
-    })
-  })
-
-  describe('integration with DOM', () => {
-    it('should properly manage meta tags in document head', () => {
-      metaTwitter.setTitle('Test Title')
-      metaTwitter.setDescription('Test Description')
-      metaTwitter.setImage('https://example.com/image.jpg')
-
-      const titleElement = document.querySelector('meta[name="twitter:title"]')
-      const descElement = document.querySelector('meta[name="twitter:description"]')
-      const imageElement = document.querySelector('meta[name="twitter:image"]')
-
-      expect(titleElement?.parentElement).toBe(document.head)
-      expect(descElement?.parentElement).toBe(document.head)
-      expect(imageElement?.parentElement).toBe(document.head)
-    })
-
-    it('should not duplicate meta tags on multiple updates', () => {
-      metaTwitter.setTitle('First')
-      metaTwitter.setTitle('Second')
-      metaTwitter.setTitle('Third')
-
-      const elements = document.querySelectorAll('meta[name="twitter:title"]')
-      expect(elements.length).toBe(1)
-    })
-  })
-})

package/src/functions/anyToString.ts

@@ -1,36 +0,0 @@
-import { isArray } from './isArray'
-import { isObject } from './isObject'
-import { isString } from './isString'
-
-/**
- * Conversion of a value to a string.
- *
- * Преобразование значения в строку.
- * @param value values for conversion/ значения для преобразования
- */
-export function anyToString<V>(value: V): string {
-  if (isString(value)) {
-    return value.trim()
-  }
-
-  if (
-    isArray(value)
-    && value.findIndex(item => isObject(item)) === -1
-  ) {
-    return value.join(',')
-  }
-
-  if (isObject(value)) {
-    return JSON.stringify(value)
-  }
-
-  if (value === true) {
-    return '1'
-  }
-
-  if (value === false) {
-    return '0'
-  }
-
-  return value?.toString() ?? ''
-}

package/src/functions/applyTemplate.ts

@@ -1,63 +0,0 @@
-import { forEach } from './forEach'
-import { isObjectNotArray } from './isObjectNotArray'
-
-const LIST_NAME = [
-  'd',
-  'e',
-  'f',
-  'g',
-  'h',
-  'i',
-  'j',
-  'k',
-  'l',
-  'm',
-  'n',
-  'o',
-  'p',
-  'q',
-  'r',
-  's',
-  't',
-  'u',
-  'v'
-]
-
-/**
- * Applies a template to the text, replacing keys with values from the replacement object
- *
- * Применяет шаблон к тексту, заменяя ключи на значения из объекта замены
- * @param text text with a template containing keys in square brackets, for example "[key]"/
- * текст с шаблоном, содержащим ключи в квадратных скобках, например "[key]"
- * @param replacement an object containing key-value pairs for replacement/
- * объект, содержащий пары ключ-значение для замены
- */
-export const applyTemplate = (
-  text: string,
-  replacement: Record<string, string | number> | string[] = {}
-) => {
-  let content = String(text)
-
-  if (text.match(/%[a-z]/)) {
-    let code = 0
-
-    forEach(replacement, (value) => {
-      content = content.replace(new RegExp(`%${LIST_NAME[code++]}`, 'g'), String(value))
-    })
-  }
-
-  if (isObjectNotArray(replacement)) {
-    forEach(replacement, (value, key) => {
-      content = content
-        .replace(
-          new RegExp(`\\[${key}\\](.*?)\\[/${key}\\]`, 'g'),
-          (_: string, content: string) => {
-            return String(value).replace(/\[content]/g, content)
-          }
-        )
-        .replace(new RegExp(`\\[${key}\\]`, 'g'), String(value))
-    })
-  }
-
-  return content
-}

package/src/functions/arrFill.ts

@@ -1,10 +0,0 @@
-/**
- * The method creates an array of "count" elements with values equal to `value`.
- *
- * Метод создает массив из "count" элементов со значениями равными `value`.
- * @param value value to fill the array with/ значение, заполняющее массив
- * @param count the number of elements in that array/ число элементов этого массива
- */
-export function arrFill<T>(value: T, count: number): T[] {
-  return Array(count).fill(value) as T[]
-}

package/src/functions/copyObject.ts

@@ -1,10 +0,0 @@
-/**
- * Создает копию простого объекта.
- *
- * Creates a copy of a simple object.
- * @param value объект для копирования/ object for copying
- * @returns возвращает новую копию объекта/ returns a new copy of the object
- */
-export function copyObject<T>(value: T): T {
-  return JSON.parse(JSON.stringify(value)) as T
-}

package/src/functions/createElement.ts

@@ -1,40 +0,0 @@
-import { forEach } from './forEach'
-import { isDomRuntime } from './isDomRuntime'
-import { isObjectNotArray } from './isObjectNotArray'
-import { setElementItem } from './setElementItem'
-
-/**
- * In HTML documents, creates an element with the tag that is specified in the argument.
- *
- * В HTML-документах создаёт элемент с тегом, который указан в аргументе.
- * @param parentElement the DOM node's parent Element/ родитель для нового элемента
- * @param tagName A string that specifies the type of element to be created/ строка,
- * указывающая элемент какого типа должен быть создан
- * @param options an object with attributes or a function for processing an element/ объект
- * с атрибутами или функция для обработки элемента
- * @param referenceElement the node before which newNode is inserted/ элемент,
- * перед которым будет вставлен newElement
- */
-export function createElement<T extends HTMLElement>(
-  parentElement?: HTMLElement,
-  tagName = 'div',
-  options?: Partial<T> | Record<keyof T, T[keyof T]> | ((element: T) => void),
-  referenceElement?: HTMLElement
-): T | undefined {
-  if (!isDomRuntime()) {
-    return undefined
-  }
-
-  const element = document.createElement(tagName) as T
-
-  if (typeof options === 'function') {
-    options(element)
-  } else if (isObjectNotArray(options)) {
-    forEach(options as Record<string, any>, (value, key) => {
-      setElementItem(element, key as keyof T, value)
-    })
-  }
-
-  parentElement?.insertBefore<T>(element, referenceElement ?? null)
-  return element
-}

package/src/functions/domQuerySelector.ts

@@ -1,15 +0,0 @@
-import { isDomRuntime } from './isDomRuntime'
-
-/**
- * Selects the first element that matches the specified selectors.
- *
- * Выбирает первый элемент, который соответствует указанным селекторам.
- * @param selectors selectors/ селекторы
- */
-export function domQuerySelector<E extends Element = Element>(selectors: string): E | undefined {
-  if (isDomRuntime()) {
-    return document.querySelector<E>(selectors) ?? undefined
-  }
-
-  return undefined
-}

package/src/functions/domQuerySelectorAll.ts

@@ -1,15 +0,0 @@
-import { isDomRuntime } from './isDomRuntime'
-
-/**
- * Selects all elements that match the specified selectors.
- *
- * Выбирает все элементы, которые соответствуют указанным селекторам.
- * @param selectors selectors/ селекторы
- */
-export function domQuerySelectorAll<E extends Element = Element>(selectors: string): NodeListOf<E> | undefined {
-  if (isDomRuntime()) {
-    return document.querySelectorAll<E>(selectors)
-  }
-
-  return undefined
-}

package/src/functions/encodeAttribute.ts

@@ -1,15 +0,0 @@
-/**
- * Encodes special characters in a string for safe use in HTML attributes.
- *
- * Кодирует специальные символы в строке для безопасного использования в HTML-атрибутах.
- * @param text text to encode / текст для кодирования
- */
-export function encodeAttribute(text: string): string {
-  return text
-    .replace(/&/g, '&')
-    .replace(/</g, '&lt;')
-    .replace(/>/g, '&gt;')
-    .replace(/"/g, '&quot;')
-    .replace(/'/g, '&#39;')
-    .trim()
-}

package/src/functions/eventStopPropagation.ts

@@ -1,10 +0,0 @@
-/**
- * Stop listening to events in depth.
- *
- * Остановить прослушивания события в глубину.
- * @param event event instance/ экземпляр события
- */
-export function eventStopPropagation(event: Event): void {
-  event.preventDefault()
-  event.stopPropagation()
-}

package/src/functions/executeFunction.ts

@@ -1,13 +0,0 @@
-import { isFunction } from './isFunction'
-
-import { type FunctionArgs } from '../types/basicTypes'
-
-/**
- * The function is executed and returns its result. Or returns the input data, if it is not a function.
- *
- * Выполняется функция и возвращает ее результат. Или возвращает входные данные, если это не функция
- * @param callback function or any value/ функция или любое значение
- */
-export function executeFunction<T>(callback: T | FunctionArgs<any, T>): T {
-  return isFunction(callback) ? callback() : callback
-}

package/src/functions/executePromise.ts

@@ -1,19 +0,0 @@
-import { executeFunction } from './executeFunction'
-
-/**
- * Returns the execution result of an asynchronous function.
- *
- * Возвращает выполнение асинхронной функции.
- * @param callback function or any value/ функция или любое значение
- */
-export async function executePromise<T>(
-  callback: (() => Promise<T>) | (() => T) | T
-): Promise<T> {
-  const data = executeFunction<Promise<T> | T>(callback)
-
-  if (data instanceof Promise) {
-    return (await data)
-  }
-
-  return data as T
-}