npm - @dxtmisha/wiki - Versions diffs - 0.39.1 → 0.39.2 - Mend

@dxtmisha/wiki 0.39.1 → 0.39.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (1587) hide show

package/src/media/functional/en/cookieBlock.mdx DELETED Viewed

@@ -1,207 +0,0 @@
-import {Meta} from '@storybook/addon-docs/blocks'
-<Meta title='@dxtmisha/functional/en/Classes/CookieBlock'/>
-# CookieBlock Class
-Static class for managing cookie access status and privacy compliance. Provides a simple interface to block or allow cookies throughout the application, integrating with the Cookie class to ensure privacy regulations compliance like GDPR.
-## Key Features
-- **Global cookie control** — centralized control over cookie usage across entire application
-- **Privacy compliance** — helps implement GDPR, CCPA, and other privacy regulations
-- **Persistent settings** — uses DataStorage to remember user's cookie preferences
-- **Integration with Cookie class** — Cookie class automatically respects CookieBlock settings
-- **Simple API** — just two methods for getting and setting cookie block status
-- **Browser compatibility** — works safely in all environments
-## Basic Usage
-### `get`
-Gets current cookie block status.
-**Returns:** `boolean` — true if cookies are blocked, false if allowed
-```javascript
-import { CookieBlock } from '@dxtmisha/functional'
-// Check if cookies are currently blocked
-const isBlocked = CookieBlock.get()
-console.log('Cookies blocked:', isBlocked) // false by default
-if (isBlocked) {
-  console.log('Cookies are blocked by user preference')
-} else {
-  console.log('Cookies are allowed')
-}
-```
-### `set`
-Sets cookie block status and persists the setting.
-**Parameters:**
-- `value: boolean` — true to block cookies, false to allow
-```javascript
-// Block all cookies
-CookieBlock.set(true)
-console.log('Cookies blocked:', CookieBlock.get()) // true
-// Allow cookies
-CookieBlock.set(false)
-console.log('Cookies allowed:', CookieBlock.get()) // false
-// Setting persists across browser sessions
-// User preference is saved in localStorage
-```
-## Integration with Cookie Class
-The CookieBlock class automatically prevents Cookie operations when blocking is enabled:
-```javascript
-import { Cookie, CookieBlock } from '@dxtmisha/functional'
-// Create cookie instance
-const userPrefs = new Cookie('user-preferences')
-// Initially cookies are allowed
-CookieBlock.set(false)
-userPrefs.set({ theme: 'dark', language: 'en' })
-console.log('Stored preferences:', userPrefs.get()) // { theme: 'dark', language: 'en' }
-// Block cookies
-CookieBlock.set(true)
-// Cookie operations are now prevented
-userPrefs.set({ theme: 'light', language: 'es' }) // This won't actually set the cookie
-console.log('Preferences after blocking:', userPrefs.get()) // Still { theme: 'dark', language: 'en' }
-// Allow cookies again
-CookieBlock.set(false)
-userPrefs.set({ theme: 'light', language: 'es' }) // Now this works
-console.log('Updated preferences:', userPrefs.get()) // { theme: 'light', language: 'es' }
-```
-## Practical Examples
-### GDPR Cookie Consent
-```javascript
-class CookieConsent {
-  constructor() {
-    this.consentCookie = new Cookie('cookie-consent')
-  }
-  showConsentBanner() {
-    const consent = this.consentCookie.get()
-    if (consent === undefined) {
-      CookieBlock.set(true) // Block until consent
-      this.displayBanner()
-      return 'banner-shown'
-    } else {
-      CookieBlock.set(!consent.accepted)
-      return consent.accepted ? 'cookies-allowed' : 'cookies-blocked'
-    }
-  }
-  acceptCookies() {
-    this.consentCookie.set({
-      accepted: true,
-      timestamp: Date.now()
-    }, { age: 365 * 24 * 60 * 60 })
-    CookieBlock.set(false)
-    this.hideBanner()
-  }
-  rejectCookies() {
-    this.consentCookie.set({
-      accepted: false,
-      timestamp: Date.now()
-    }, { age: 365 * 24 * 60 * 60 })
-    CookieBlock.set(true)
-    this.hideBanner()
-  }
-}
-// Usage
-const consent = new CookieConsent()
-const status = consent.showConsentBanner()
-```
-### Privacy Settings Management
-```javascript
-class PrivacyManager {
-  constructor() {
-    this.privacySettings = new Cookie('privacy-settings')
-  }
-  updatePrivacySettings(settings) {
-    this.privacySettings.set(settings, { age: 365 * 24 * 60 * 60 })
-    const shouldBlock = !(settings.functional || settings.analytics || settings.marketing)
-    CookieBlock.set(shouldBlock)
-  }
-  hasConsentFor(category) {
-    const settings = this.privacySettings.get({ essential: true })
-    return settings[category] || false
-  }
-  acceptAll() {
-    this.updatePrivacySettings({
-      essential: true,
-      functional: true,
-      analytics: true,
-      marketing: true
-    })
-  }
-  rejectAll() {
-    this.updatePrivacySettings({
-      essential: true,
-      functional: false,
-      analytics: false,
-      marketing: false
-    })
-  }
-}
-// Usage
-const privacy = new PrivacyManager()
-privacy.acceptAll()
-console.log('Analytics allowed:', privacy.hasConsentFor('analytics'))
-```
-### Application Initialization
-```javascript
-class AppInitializer {
-  static initializeCookieCompliance() {
-    const consent = new Cookie('cookie-consent')
-    const consentData = consent.get()
-    if (!consentData) {
-      CookieBlock.set(true) // First visit
-      return 'pending-consent'
-    } else {
-      CookieBlock.set(!consentData.accepted)
-      return consentData.accepted ? 'cookies-allowed' : 'cookies-blocked'
-    }
-  }
-}
-// Application startup
-document.addEventListener('DOMContentLoaded', () => {
-  const status = AppInitializer.initializeCookieCompliance()
-  console.log('Cookie status:', status)
-})
-```
-The CookieBlock class helps ensure compliance with GDPR, CCPA, and other privacy laws by providing a foundation for implementing privacy-compliant cookie management.

package/src/media/functional/en/dataStorage.mdx DELETED Viewed

@@ -1,216 +0,0 @@
-import {Meta} from '@storybook/addon-docs/blocks'
-<Meta title='@dxtmisha/functional/en/Classes/DataStorage'/>
-# DataStorage Class
-Class for working with browser localStorage and sessionStorage with automatic serialization, caching, and singleton pattern. Provides type-safe storage operations with cache time validation and automatic prefix management.
-## Key Features
-- **Type-safe storage** — full TypeScript support with generics for stored data
-- **Dual storage support** — works with both localStorage and sessionStorage
-- **Automatic serialization** — JSON serialization/deserialization handled automatically
-- **Cache time validation** — optional cache expiration with automatic cleanup
-- **Singleton pattern** — reuses instances for same storage keys
-- **Prefix management** — configurable prefix for all storage keys (default 'ui-storage')
-- **Function value support** — accepts functions as values for dynamic data generation
-- **Browser compatibility** — safe usage with server-side rendering
-## Configuration
-### `static setPrefix`
-Sets the global prefix for all storage keys. Should be called at application startup.
-**Parameters:**
-- `newPrefix: string` — new prefix for storage keys
-**Returns:** `void`
-```javascript
-import { DataStorage } from '@dxtmisha/functional'
-// Set application-wide prefix
-DataStorage.setPrefix('myapp-storage')
-// All storage keys will now use this prefix:
-// 'user-settings' → 'myapp-storage__user-settings'
-// Default prefix: 'ui-storage'
-```
-## Constructor
-### `constructor`
-Creates DataStorage instance for specified key. Uses singleton pattern.
-**Parameters:**
-- `name: string` — storage key name
-- `isSession?: boolean` — use sessionStorage instead of localStorage (default: false)
-**Returns:** `DataStorage<T>` — class instance (or existing from cache)
-```javascript
-// localStorage instance
-const userPrefs = new DataStorage('user-preferences')
-// sessionStorage instance
-const tempData = new DataStorage('temp-data', true)
-// Singleton behavior
-const sameInstance = new DataStorage('user-preferences')
-console.log(userPrefs === sameInstance) // true
-```
-## Data Operations
-### `get`
-Retrieves data from storage with optional default value and cache validation.
-**Parameters:**
-- `defaultValue?: T | (() => T)` — default value or function if no data found (optional)
-- `cache?: number` — cache time in **seconds** for validation (optional)
-**Returns:** `T | undefined` — stored data, default value, or undefined
-```javascript
-const settings = new DataStorage('app-settings')
-// Get data without default
-const theme = settings.get()
-console.log(theme) // undefined if no data stored
-// Get with default value
-const language = settings.get('en')
-console.log(language) // 'en' if no stored data, or stored value
-// Get with default function
-const config = settings.get(() => ({
-  theme: 'dark',
-  notifications: true,
-  created: Date.now()
-}))
-// Get with cache validation (600 seconds = 10 minutes)
-const cachedData = settings.get(null, 600)
-// Returns undefined if data older than 10 minutes
-// Returns stored data if cache is valid
-```
-### `set`
-Stores data in storage with automatic serialization.
-**Parameters:**
-- `value?: T | (() => T)` — value to store or function that returns value (optional)
-**Returns:** `T | undefined` — stored value
-```javascript
-const userStorage = new DataStorage('user-data')
-// Store simple value
-const stored = userStorage.set({ name: 'John', age: 30 })
-console.log(stored) // { name: 'John', age: 30 }
-// Store with function
-userStorage.set(() => ({
-  timestamp: Date.now(),
-  sessionId: Math.random().toString(36)
-}))
-// Store undefined to clear
-userStorage.set(undefined) // Removes from storage
-```
-### `remove`
-Removes data from storage.
-**Returns:** `this` — DataStorage instance for method chaining
-```javascript
-const userStorage = new DataStorage('user-data')
-// First set data
-userStorage.set({ name: 'John', preferences: { theme: 'dark' } })
-console.log(userStorage.get()) // { name: 'John', preferences: { theme: 'dark' } }
-// Remove
-userStorage.remove()
-console.log(userStorage.get()) // undefined
-// Method chaining
-userStorage
-  .set({ temp: 'data' })
-  .remove() // Removes just saved data
-```
-### `update`
-Updates data from storage by re-reading it.
-**Returns:** `this` — DataStorage instance for method chaining
-```javascript
-const storage = new DataStorage('shared-data')
-// Set data
-storage.set({ value: 'initial' })
-console.log(storage.get()) // { value: 'initial' }
-// Data changed in another tab/browser window
-// or directly via localStorage.setItem()
-// Update data from storage
-storage.update()
-console.log(storage.get()) // Gets actual data from storage
-// Method chaining
-storage.update().get() // Update and get fresh data
-```
-## Practical Examples
-### User Settings
-```javascript
-const settings = new DataStorage('user-settings')
-// Get with default value
-const theme = settings.get(() => 'light')
-console.log(theme) // 'light' or saved value
-// Save new value
-settings.set('dark')
-// Remove settings
-settings.remove()
-```
-### Data Cache with TTL
-```javascript
-async function fetchWithCache(url, cacheDuration = 300) {
-  const storage = new DataStorage(`api_${url}`)
-  // Try to get from cache (cacheDuration in seconds)
-  const cached = storage.get(undefined, cacheDuration)
-  if (cached) return cached
-  // Load fresh data
-  const response = await fetch(url)
-  const data = await response.json()
-  // Save to cache
-  storage.set(data)
-  return data
-}
-// Usage
-const users = await fetchWithCache('/api/users', 600) // Cache for 10 minutes
-```
-DataStorage class provides a unified interface for working with browser storage, ensuring type safety, automatic serialization, and flexible data lifetime management with singleton pattern support for efficient memory usage.

package/src/media/functional/en/dataUtils.mdx DELETED Viewed

@@ -1,282 +0,0 @@
-import {Meta} from '@storybook/addon-docs/blocks'
-<Meta title='@dxtmisha/functional/en/Data Utils'/>
-# Data Utilities
-A set of functions for data processing, iteration and management.
-## `arrFill`
-Creates an array of a specified number of elements filled with the same value.
-**Parameters:**
-- `value: T` — value to fill the array with
-- `count: number` — number of elements in the array
-```javascript
-import { arrFill } from '@dxtmisha/functional'
-arrFill('hello', 3) // ['hello', 'hello', 'hello']
-arrFill(0, 5) // [0, 0, 0, 0, 0]
-arrFill({ id: 1 }, 2) // [{ id: 1 }, { id: 1 }]
-```
-## `copyObject`
-Creates a deep copy of an object via JSON serialization.
-**Parameters:**
-- `value: T` — object to copy
-```javascript
-import { copyObject } from '@dxtmisha/functional'
-const original = { name: 'John', data: { age: 30 } }
-const copy = copyObject(original)
-copy.data.age = 25 // original.data.age remains 30
-```
-## `copyObjectLite`
-Creates a shallow copy of a simple object. If the `source` parameter is passed, creates a new object and merges `value` and `source`.
-**Parameters:**
-- `value: T` — object to copy
-- `source?: any` — additional properties to copy (optional)
-```javascript
-import { copyObjectLite } from '@dxtmisha/functional'
-const original = { name: 'John', age: 30 }
-const copy = copyObjectLite(original) // { name: 'John', age: 30 }
-// With additional properties
-const extended = copyObjectLite(original, { city: 'Moscow' })
-// { name: 'John', age: 30, city: 'Moscow' }
-// Overriding properties
-const overridden = copyObjectLite(original, { age: 25 })
-// { name: 'John', age: 25 }
-```
-**Note:** This is a shallow copy — nested objects retain references to the originals. For deep cloning use `copyObject`, `structuredClone` or `_.cloneDeep`.
-## `forEach`
-Universal iteration function for arrays, objects and Map.
-**Parameters:**
-- `data: D` — object to iterate (array, object or Map)
-- `callback: (item: T, key: K, dataMain: typeof data) => R` — function called for each element
-```javascript
-import { forEach } from '@dxtmisha/functional'
-forEach([1, 2, 3], (item, index) => item * 2) // [2, 4, 6]
-forEach({ a: 1, b: 2 }, (value, key) => `${key}=${value}`) // ['a=1', 'b=2']
-forEach(new Map([['x', 10]]), (value, key) => `${key}:${value}`) // ['x:10']
-```
-## `getClipboardData`
-Asynchronously gets text data from clipboard.
-**Parameters:**
-- `event?: ClipboardEvent` — clipboard event (optional)
-```javascript
-import { getClipboardData } from '@dxtmisha/functional'
-const text = await getClipboardData(event) // from paste event
-const clipboardText = await getClipboardData() // direct read
-```
-## `getColumn`
-Extracts values of a specific column from array of objects.
-**Parameters:**
-- `array: ObjectOrArray<T>` — array of objects to process
-- `column: K` — column key to extract
-```javascript
-import { getColumn } from '@dxtmisha/functional'
-const users = [{ id: 1, name: 'Alice' }, { id: 2, name: 'Bob' }]
-const names = getColumn(users, 'name') // ['Alice', 'Bob']
-```
-## `getExp`
-Creates a regular expression for safe text search with escaping.
-**Parameters:**
-- `value: string` — text to search for
-- `flags: string` — regular expression flags (default `'ig'`)
-- `pattern: string` — pattern (default `:value`)
-```javascript
-import { getExp } from '@dxtmisha/functional'
-const regex = getExp('hello') // /hello/ig
-const regexSpecial = getExp('$100') // /\$100/ig (escaped)
-```
-## `getItemByPath`
-Gets value from nested object by string path.
-**Parameters:**
-- `item: T` — object to traverse
-- `path: string` — path through dots (e.g., `'user.profile.name'`)
-```javascript
-import { getItemByPath } from '@dxtmisha/functional'
-const data = { user: { profile: { name: 'John' } } }
-const name = getItemByPath(data, 'user.profile.name') // 'John'
-```
-## `getLengthOfAllArray`
-Returns array with lengths of all strings.
-**Parameters:**
-- `value: ObjectOrArray<string>` — array of strings or object
-```javascript
-import { getLengthOfAllArray } from '@dxtmisha/functional'
-getLengthOfAllArray(['hello', 'world']) // [5, 5]
-```
-## `getMaxLengthAllArray`
-Finds maximum string length in array.
-**Parameters:**
-- `data: ObjectOrArray<string>` — array of strings or object
-```javascript
-import { getMaxLengthAllArray } from '@dxtmisha/functional'
-getMaxLengthAllArray(['hello', 'world']) // 5
-```
-## `getMinLengthAllArray`
-Finds minimum string length in array.
-**Parameters:**
-- `data: ObjectOrArray<string>` — array of strings or object
-```javascript
-import { getMinLengthAllArray } from '@dxtmisha/functional'
-getMinLengthAllArray(['hello', 'hi']) // 2
-```
-## `getObjectByKeys`
-Returns new object with specified keys from source object.
-**Parameters:**
-- `data: Record<string, any>` — source object
-- `keys: string[]` — list of keys to extract
-```javascript
-import { getObjectByKeys } from '@dxtmisha/functional'
-const obj = { a: 1, b: 2, c: 3 }
-const filtered = getObjectByKeys(obj, ['a', 'c']) // { a: 1, c: 3 }
-```
-## `getObjectNoUndefined`
-Removes all properties with specified value (default undefined) from object.
-**Parameters:**
-- `data: T` — object to process
-- `exception: any` — value to exclude (default undefined)
-```javascript
-import { getObjectNoUndefined } from '@dxtmisha/functional'
-const obj = { a: 1, b: undefined, c: 3 }
-const cleaned = getObjectNoUndefined(obj) // { a: 1, c: 3 }
-```
-## `getObjectOrNone`
-Returns object if it's not empty, otherwise returns undefined.
-**Parameters:**
-- `data: T` — object to check
-```javascript
-import { getObjectOrNone } from '@dxtmisha/functional'
-getObjectOrNone({ a: 1 }) // { a: 1 }
-getObjectOrNone({}) // undefined
-```
-## `setValues`
-Sets values in object by specified paths.
-**Parameters:**
-- `target: Record<string, any>` — target object
-- `values: Record<string, any>` — object with values to set
-```javascript
-import { setValues } from '@dxtmisha/functional'
-const obj = {}
-setValues(obj, { 'user.name': 'John', 'user.age': 30 })
-// obj is now { user: { name: 'John', age: 30 } }
-```
-## `splice`
-Removes elements from array and returns new array.
-**Parameters:**
-- `array: T[]` — source array
-- `index: number` — start index for removal
-- `deleteCount?: number` — number of elements to remove
-```javascript
-import { splice } from '@dxtmisha/functional'
-splice([1, 2, 3, 4], 1, 2) // [1, 4]
-splice(['a', 'b', 'c'], 0, 1) // ['b', 'c']
-```
-## `uniqueArray`
-Removes duplicates from array.
-**Parameters:**
-- `array: T[]` — array to process
-```javascript
-import { uniqueArray } from '@dxtmisha/functional'
-uniqueArray([1, 2, 2, 3, 1]) // [1, 2, 3]
-uniqueArray(['a', 'b', 'a', 'c']) // ['a', 'b', 'c']
-```
-## `writeClipboardData`
-Writes data to clipboard.
-**Parameters:**
-- `data: string` — data to write to clipboard
-```javascript
-import { writeClipboardData } from '@dxtmisha/functional'
-await writeClipboardData('Hello, World!') // writes text to clipboard
-await writeClipboardData(JSON.stringify({key: 'value'})) // writes JSON
-```