@claspo/common 7.3.1-dev.4 → 7.4.0-nonlinear

package/src/element/recursiveFindParentNodeByAttribute.ts

@@ -1,25 +0,0 @@
-export default function recursiveFindParentNodeByAttribute(
-  ref: Node | null,
-  attributeName: string,
-  attributeValue: string,
-  attributeValuePredicate?: (value: string | null) => boolean
-): Element | null {
-  const recursiveWalk = (node: Node | null): Element | null => {
-    const isFragment = node instanceof DocumentFragment ||
-      node?.nodeType === Node.DOCUMENT_FRAGMENT_NODE; // instanceof DocumentFragment is broken (returns false) in FF, so we have to make this workaround
-
-    let hostNode: any = isFragment ? (node as any).host : node;
-
-    const getAttributeCheckResult = () => attributeValuePredicate && typeof attributeValuePredicate === 'function' ?
-      attributeValuePredicate(hostNode.getAttribute(attributeName)) :
-      hostNode?.getAttribute?.(attributeName) === attributeValue;
-
-    if (hostNode && getAttributeCheckResult()) {
-      return hostNode;
-    } else {
-      return hostNode && hostNode.parentNode && recursiveWalk(hostNode.parentNode) || null;
-    }
-  };
-
-  return recursiveWalk(ref);
-}

package/src/flat.ts

@@ -1,16 +0,0 @@
-/**
- * Flattens a nested array to a specified depth.
- * Similar to Array.prototype.flat() but with broader browser support.
- * @typeParam T - The element type of the array
- * @param arr - The array to flatten
- * @param depth - The depth level to flatten (default: 1)
- * @returns A new flattened array
- * @example
- * flat([[1, 2], [3, [4, 5]]], 1); // [1, 2, 3, [4, 5]]
- * flat([[1, 2], [3, [4, 5]]], 2); // [1, 2, 3, 4, 5]
- */
-export function flat<T>(arr: (T | T[])[], depth: number = 1): T[] {
-  return arr.reduce((acc: T[], val: T | T[]) => Array.isArray(val) && depth >= 1
-    ? acc.concat(flat(val as (T | T[])[], depth - 1))
-    : acc.concat(val as T), []);
-}

package/src/handler/HandlerTypes.ts

@@ -1,4 +0,0 @@
-export enum HandlerTypes  {
-    CLICK = 'CLICK',
-    COMPONENT_EVENT = 'COMPONENT_EVENT'
-}

package/src/math/RandomDistributor.test.ts

@@ -1,35 +0,0 @@
-import RandomDistributor from "./RandomDistributor";
-
-describe('RandomDistributor', () => {
-
-  it('should calc', () => {
-
-    const randomDistributor = new RandomDistributor();
-    let options = [
-      {
-        id: 0,
-        weight: 1
-      },
-      {
-        id: 1,
-        weight: 1
-      }
-    ];
-
-
-    let vars: Record<number, number> = {};
-    let length = 1_000_000;
-
-    for (let i = 0; i < length; i++) {
-      let id = randomDistributor.calculateFromWeights(options)!.id as number;
-      if (!vars[id]) {
-        vars[id] = 1;
-      } else {
-        vars[id] += 1;
-      }
-
-    }
-    expect(vars[0] / length).toBeCloseTo(0.5, 2)
-    expect(vars[1] / length).toBeCloseTo(0.5, 2);
-  });
-});

package/src/math/RandomDistributor.ts

@@ -1,58 +0,0 @@
-import sum from "./sum";
-import generateRandomNumber from "../utils/generateRandomNumber";
-
-interface WeightedOption {
-  id: string | number;
-  weight: number;
-  [key: string]: any;
-}
-
-interface Range {
-  from: number;
-  to: number;
-  id: string | number;
-}
-
-export default class RandomDistributor {
-
-  calculateFromWeights(originOptions: WeightedOption[], multiplier = 1000): WeightedOption | undefined {
-    const options = originOptions.map(o => ({...o, weight: o.weight * multiplier}));
-
-    const sumResult = sum(options.map(o => parseFloat(String(o.weight))));
-
-    const targetValue = generateRandomNumber(1, sumResult);
-    let ranges = this._buildRanges(options);
-
-    const correspondingRule = this._getRangeByWeight(ranges, targetValue);
-    return options.find(o => o.id === correspondingRule?.id);
-
-  }
-
-  _getRangeByWeight(ranges: Range[], weight: number): Range | undefined {
-    return ranges.find(range => weight >= range.from && weight <= range.to);
-  }
-
-  _buildRanges(rules: WeightedOption[]): Range[] {
-    let ranges: Range[] = [];
-    for (let i = 0; i < rules.length; i++) {
-      const splitRule = rules[i];
-      if (i === 0) {
-        ranges.push({
-          from: 1,
-          to: parseFloat(String(splitRule.weight)),
-          id: splitRule.id,
-        });
-      } else {
-        const last = ranges[ranges.length - 1];
-        const from = last.to;
-        const to = from + parseFloat(String(splitRule.weight));
-        ranges.push({
-          from: from + 1,
-          to,
-          id: splitRule.id,
-        });
-      }
-    }
-    return ranges;
-  }
-}

package/src/math/sum.ts

@@ -1,3 +0,0 @@
-export default function sum(list: number[]): number {
-  return list.reduce((acc: number, value: number) => acc + value, 0);
-}

package/src/network/HttpClient.ts

@@ -1,28 +0,0 @@
-class HttpClient {
-  execute(
-    URL: string,
-    method: string = 'GET',
-    body: any = null,
-    headers?: Record<string, string>,
-    abortSignal?: AbortSignal,
-  ): Promise<Response> {
-    const requestParams: RequestInit = {
-      method,
-      headers: {
-        'Content-Type': 'text/plain',
-        ...(headers || {}),
-      },
-      credentials: 'same-origin',
-      body: null,
-      signal: abortSignal,
-    };
-
-    if (body) {
-      requestParams.body = typeof body === 'string' ? body : JSON.stringify(body);
-    }
-
-    return fetch(URL, requestParams);
-  }
-}
-
-export default new HttpClient();

package/src/network/HttpStatus.ts

@@ -1,4 +0,0 @@
-export enum HttpStatus {
-    EMPTY_RESPONSE = 204,
-    TOO_MANY_REQUESTS = 429,
-}

package/src/object/isDictionary.test.ts

@@ -1,24 +0,0 @@
-import isDictionary from './isDictionary';
-
-describe('isDictionary', () => {
-
-  it('should not pass primitives', () => {
-    expect(isDictionary(2)).toEqual(false);
-    expect(isDictionary('abc')).toEqual(false);
-    expect(isDictionary(true)).toEqual(false);
-  });
-
-  it('should not pass null', () => {
-    expect(isDictionary(null)).toEqual(false);
-  });
-
-  it('should not pass array', () => {
-    expect(isDictionary([])).toEqual(false);
-    expect(isDictionary([1])).toEqual(false);
-  });
-
-  it('should pass dictionary', () => {
-    expect(isDictionary({})).toEqual(true);
-    expect(isDictionary({a: [1]})).toEqual(true);
-  });
-});

package/src/object/isDictionary.ts

@@ -1,13 +0,0 @@
-/**
- * Checks if a value is a plain object (dictionary).
- * Returns true for objects that are not null and not arrays.
- * @param object - The value to check
- * @returns True if the value is a plain object, false otherwise
- * @example
- * isDictionary({a: 1});    // true
- * isDictionary([1, 2, 3]); // false
- * isDictionary(null);      // false
- */
-export default function isDictionary(object: unknown): boolean {
-  return typeof object === 'object' && object !== null && !Array.isArray(object);
-}

package/src/object/omitKeys.test.ts

@@ -1,19 +0,0 @@
-import omitKeys from "./omitKeys";
-
-describe('omitKeys', function () {
-  it('should omit', function () {
-    const map = {
-      key1: {a: true, b: 1},
-      key2: 'red',
-      key3: []
-    };
-
-    const actualResult = omitKeys(map, ['key2']);
-
-    expect(actualResult).toStrictEqual({
-      key1: {a: true, b: 1},
-      key3: []
-    });
-
-  });
-});

package/src/object/omitKeys.ts

@@ -1,20 +0,0 @@
-/**
- * Creates a new object with specified keys omitted.
- * @typeParam T - The source object type
- * @typeParam K - The keys to omit
- * @param kv - The source object
- * @param ignoreKeys - Array of keys to exclude from the result
- * @returns A new object without the specified keys
- * @example
- * const obj = { a: 1, b: 2, c: 3 };
- * omitKeys(obj, ['b']); // { a: 1, c: 3 }
- */
-export default function omitKeys<T extends Record<string, unknown>, K extends keyof T>(
-  kv: T,
-  ignoreKeys: K[]
-): Omit<T, K> {
-  return Object
-    .keys(kv)
-    .filter(keyName => !ignoreKeys.includes(keyName as K))
-    .reduce((acc, keyName) => ({...acc, [keyName]: kv[keyName]}), {}) as Omit<T, K>;
-}

package/src/storage/BaseCachingStorage.test.ts

@@ -1,70 +0,0 @@
-// @ts-nocheck
-import BaseCachingStorage from './BaseCachingStorage';
-
-class ConcreteStorage extends BaseCachingStorage {
-  store: Record<string, string | null> = {};
-
-  get(key: string): string | null {
-    const cached = this._getFromCache(key);
-    if (cached !== null) return cached;
-    return this._process(() => {
-      const val = this.store[key] ?? null;
-      this._setToCache(key, val);
-      return val;
-    });
-  }
-
-  set(key: string, value: string): void {
-    this._setToCache(key, value);
-    this._process(() => { this.store[key] = value; });
-  }
-
-  remove(key: string): void {
-    this._removeFromCache(key);
-    this._process(() => { delete this.store[key]; });
-  }
-}
-
-describe('BaseCachingStorage', () => {
-  let storage: ConcreteStorage;
-
-  beforeEach(() => {
-    storage = new ConcreteStorage();
-  });
-
-  it('returns value when set', () => {
-    storage.set('key', 'value');
-    expect(storage.get('key')).toBe('value');
-  });
-
-  it('returns cached value without re-reading storage within TTL', () => {
-    storage.set('key', 'value');
-    storage.store['key'] = 'changed-in-storage';
-    expect(storage.get('key')).toBe('value');
-  });
-
-  it('re-reads from storage after cache expires', () => {
-    jest.useFakeTimers();
-    storage.set('key', 'first');
-    jest.advanceTimersByTime(2001);
-    storage.store['key'] = 'second';
-    expect(storage.get('key')).toBe('second');
-    jest.useRealTimers();
-  });
-
-  it('returns null after remove', () => {
-    storage.set('key', 'value');
-    storage.remove('key');
-    expect(storage.get('key')).toBeNull();
-  });
-
-  it('returns null for unknown key', () => {
-    expect(storage.get('missing')).toBeNull();
-  });
-
-  it('does not throw when storage operation throws', () => {
-    const throwing = new ConcreteStorage();
-    jest.spyOn(throwing, '_process').mockImplementation(() => null);
-    expect(() => throwing.get('key')).not.toThrow();
-  });
-});

package/src/storage/BaseCachingStorage.ts

@@ -1,37 +0,0 @@
-interface CacheEntry {
-  value: string | null;
-  expiration: number;
-}
-
-export default abstract class BaseCachingStorage {
-  cache: Record<string, CacheEntry> = {};
-  cacheTimeMs = 2000;
-
-  protected _process(operationCallback: () => string | null): string | null {
-    try {
-      return operationCallback();
-    } catch (e) {
-      return null;
-    }
-  }
-
-  protected _getFromCache(key: string): string | null {
-    const currentTime = Date.now();
-    const cachedItem = this.cache[key];
-    if (cachedItem && currentTime < cachedItem.expiration) {
-      return cachedItem.value;
-    }
-    return null;
-  }
-
-  protected _setToCache(key: string, value: string | null): void {
-    this.cache[key] = {
-      value,
-      expiration: Date.now() + this.cacheTimeMs,
-    };
-  }
-
-  protected _removeFromCache(key: string): void {
-    delete this.cache[key];
-  }
-}

package/src/storage/CachingCookieStorage.test.ts

@@ -1,75 +0,0 @@
-import CachingCookieStorage from './CachingCookieStorage';
-import getCookie from './getCookie';
-import setCookie from './setCookie';
-
-jest.mock('./getCookie', () => ({
-  __esModule: true,
-  default: jest.fn(),
-}));
-
-jest.mock('./setCookie', () => ({
-  __esModule: true,
-  default: jest.fn(),
-}));
-
-describe('CachingCookieStorage', () => {
-  beforeEach(() => {
-    CachingCookieStorage.cache = {};
-    jest.clearAllMocks();
-  });
-
-  describe('get', () => {
-    it('returns cookie value when cookie exists', () => {
-      (getCookie as jest.Mock).mockReturnValue('bar');
-
-      expect(CachingCookieStorage.get('foo')).toBe('bar');
-      expect(getCookie).toHaveBeenCalledWith('foo');
-    });
-
-    it('returns null when cookie does not exist', () => {
-      (getCookie as jest.Mock).mockReturnValue(undefined);
-
-      expect(CachingCookieStorage.get('unknown_key_xyz')).toBeNull();
-    });
-
-    it('returns cached value on second call without re-reading cookie', () => {
-      (getCookie as jest.Mock).mockReturnValue('original');
-
-      CachingCookieStorage.get('cached_key');
-      expect(CachingCookieStorage.get('cached_key')).toBe('original');
-      expect(getCookie).toHaveBeenCalledTimes(1);
-    });
-
-    it('returns null when getCookie returns undefined after failure', () => {
-      (getCookie as jest.Mock).mockReturnValue(undefined);
-
-      expect(CachingCookieStorage.get('key')).toBeNull();
-    });
-  });
-
-  describe('set', () => {
-    it('delegates string values to setCookie', () => {
-      CachingCookieStorage.set('key', 'value');
-
-      expect(setCookie).toHaveBeenCalledWith('key', 'value', {});
-    });
-
-    it('stringifies non-string values before delegating', () => {
-      CachingCookieStorage.set('key', { a: 1 });
-
-      expect(setCookie).toHaveBeenCalledWith('key', '{"a":1}', {});
-    });
-  });
-
-  describe('remove', () => {
-    it('removes value from cache after remove', () => {
-      (getCookie as jest.Mock).mockReturnValue('bar');
-
-      CachingCookieStorage.get('remove_test');
-      CachingCookieStorage.remove('remove_test');
-
-      expect(CachingCookieStorage.cache['remove_test']).toBeUndefined();
-      expect(setCookie).toHaveBeenCalledWith('remove_test', '', { expires: new Date(0) });
-    });
-  });
-});

package/src/storage/CachingCookieStorage.ts

@@ -1,36 +0,0 @@
-import BaseCachingStorage from './BaseCachingStorage';
-import getCookie from './getCookie';
-import setCookie, { CookieOptionsI } from './setCookie';
-
-class CachingCookieStorage extends BaseCachingStorage {
-  get(name: string): string | null {
-    const cached = this._getFromCache(name);
-    if (cached !== null) {
-      return cached;
-    }
-    return this._process(() => {
-      const value = getCookie(name) ?? null;
-      this._setToCache(name, value);
-      return value;
-    });
-  }
-
-  set(name: string, value: string | object, options: CookieOptionsI = {}): void {
-    const stringifiedValue = typeof value === 'string' ? value : this._process(() => JSON.stringify(value)) as string;
-    this._setToCache(name, stringifiedValue);
-    this._process(() => {
-      setCookie(name, stringifiedValue, options);
-      return null;
-    });
-  }
-
-  remove(name: string): void {
-    this._removeFromCache(name);
-    this._process(() => {
-      setCookie(name, '', { expires: new Date(0) });
-      return null;
-    });
-  }
-}
-
-export default new CachingCookieStorage();

package/src/storage/CachingLocalStorage.test.ts

@@ -1,59 +0,0 @@
-// @ts-nocheck
-import CachingLocalStorage from './CachingLocalStorage';
-
-describe('CachingLocalStorage', () => {
-  beforeEach(() => {
-    CachingLocalStorage.cache = {};
-    localStorage.clear();
-  });
-
-  describe('get', () => {
-    it('returns value when key exists', () => {
-      localStorage.setItem('key', 'hello');
-      expect(CachingLocalStorage.get('key')).toBe('hello');
-    });
-
-    it('returns null when key does not exist', () => {
-      expect(CachingLocalStorage.get('missing')).toBeNull();
-    });
-
-    it('returns cached value on second call without re-reading localStorage', () => {
-      localStorage.setItem('key', 'original');
-      CachingLocalStorage.get('key');
-      localStorage.setItem('key', 'modified');
-      expect(CachingLocalStorage.get('key')).toBe('original');
-    });
-
-    it('returns null when localStorage.getItem throws', () => {
-      jest.spyOn(Storage.prototype, 'getItem').mockImplementation(() => { throw new Error('blocked'); });
-      expect(CachingLocalStorage.get('key')).toBeNull();
-    });
-  });
-
-  describe('set', () => {
-    it('stores value in localStorage', () => {
-      CachingLocalStorage.set('key', 'value');
-      expect(localStorage.getItem('key')).toBe('value');
-    });
-
-    it('stringifies non-string values', () => {
-      CachingLocalStorage.set('key', { a: 1 });
-      expect(localStorage.getItem('key')).toBe('{"a":1}');
-    });
-  });
-
-  describe('remove', () => {
-    it('removes value from localStorage', () => {
-      localStorage.setItem('key', 'value');
-      CachingLocalStorage.remove('key');
-      expect(localStorage.getItem('key')).toBeNull();
-    });
-
-    it('removes value from cache after remove', () => {
-      localStorage.setItem('key', 'value');
-      CachingLocalStorage.get('key');
-      CachingLocalStorage.remove('key');
-      expect(CachingLocalStorage.cache['key']).toBeUndefined();
-    });
-  });
-});

package/src/storage/CachingLocalStorage.ts

@@ -1,34 +0,0 @@
-import BaseCachingStorage from './BaseCachingStorage';
-
-class CachingLocalStorage extends BaseCachingStorage {
-  get(key: string): string | null {
-    const cached = this._getFromCache(key);
-    if (cached !== null) {
-      return cached;
-    }
-    return this._process(() => {
-      const value = localStorage.getItem(key);
-      this._setToCache(key, value);
-      return value;
-    });
-  }
-
-  set(key: string, value: string | object): void {
-    const stringifiedValue = typeof value === 'string' ? value : this._process(() => JSON.stringify(value)) as string;
-    this._setToCache(key, stringifiedValue);
-    this._process(() => {
-      localStorage.setItem(key, stringifiedValue);
-      return null;
-    });
-  }
-
-  remove(key: string): void {
-    this._removeFromCache(key);
-    this._process(() => {
-      localStorage.removeItem(key);
-      return null;
-    });
-  }
-}
-
-export default new CachingLocalStorage();

package/src/storage/getCookie.test.ts

@@ -1,53 +0,0 @@
-import getCookie from './getCookie';
-
-describe('getCookie', () => {
-  let originalDescriptor: PropertyDescriptor | undefined;
-
-  beforeEach(() => {
-    originalDescriptor = Object.getOwnPropertyDescriptor(Document.prototype, 'cookie');
-  });
-
-  afterEach(() => {
-    if (originalDescriptor) {
-      Object.defineProperty(document, 'cookie', originalDescriptor);
-    }
-  });
-
-  it('returns cookie value when cookie exists', () => {
-    Object.defineProperty(document, 'cookie', {
-      get: () => 'foo=bar; x=y',
-      configurable: true,
-    });
-
-    expect(getCookie('foo')).toBe('bar');
-  });
-
-  it('returns undefined when cookie does not exist', () => {
-    Object.defineProperty(document, 'cookie', {
-      get: () => 'foo=bar',
-      configurable: true,
-    });
-
-    expect(getCookie('unknown_key_xyz')).toBeUndefined();
-  });
-
-  it('decodes URI-encoded cookie values', () => {
-    Object.defineProperty(document, 'cookie', {
-      get: () => 'encoded_val=' + encodeURIComponent('hello world'),
-      configurable: true,
-    });
-
-    expect(getCookie('encoded_val')).toBe('hello world');
-  });
-
-  it('returns undefined when document.cookie access throws', () => {
-    Object.defineProperty(document, 'cookie', {
-      get: () => {
-        throw new Error('blocked');
-      },
-      configurable: true,
-    });
-
-    expect(getCookie('key')).toBeUndefined();
-  });
-});

package/src/storage/getCookie.ts

@@ -1,10 +0,0 @@
-export default function getCookie(name: string): string | undefined {
-  try {
-    const matches = document.cookie.match(new RegExp(
-      '(?:^|; )' + name.replace(/([\.$?*|{}\(\)\[\]\\\/\+^])/g, '\\$1') + '=([^;]*)'
-    ));
-    return matches ? decodeURIComponent(matches[1]) : undefined;
-  } catch (e) {
-    return undefined;
-  }
-}