yummies 5.4.4 → 5.4.6

package/src/complex/global-config.ts

@@ -0,0 +1,55 @@
+import type { AnyObject, Maybe } from '../utils/types.js';
+
+const createGlobalPoint = <TValue>(accessSymbol?: keyof any) => {
+  if (accessSymbol == null) {
+    let storedValue: TValue | undefined;
+    return {
+      get: (): TValue => storedValue!,
+      set: (value: TValue): TValue => {
+        storedValue = value;
+        return value;
+      },
+    };
+  }
+
+  const _globalThis = globalThis as AnyObject;
+
+  return {
+    get: (): TValue => _globalThis[accessSymbol],
+    set: (value: TValue): TValue => {
+      _globalThis[accessSymbol] = value;
+      return value;
+    },
+  };
+};
+
+/**
+ * Создает глобальный конфиг, который может быть доступен в любой точке в коде
+ */
+export const createGlobalConfig = <T extends AnyObject>(
+  defaultValue: T,
+  accessSymbol?: keyof any,
+) => {
+  const globalPoint = createGlobalPoint<T>(accessSymbol);
+  return globalPoint.get() || globalPoint.set(defaultValue);
+};
+
+export const createGlobalDynamicConfig = <T extends AnyObject>(
+  processFn: (change: Maybe<Partial<T>>, current: Maybe<T>) => T,
+  accessSymbol?: keyof any,
+) => {
+  const globalPoint = createGlobalPoint<T | null | undefined>(accessSymbol);
+
+  const getValue = () => {
+    return globalPoint.get() ?? globalPoint.set(processFn(null, null))!;
+  };
+
+  return {
+    get: getValue,
+    set: globalPoint.set,
+    update: (value: Partial<T>) => {
+      const currentValue = getValue();
+      Object.assign(currentValue, processFn(value, currentValue));
+    },
+  };
+};

package/src/complex/index.ts

@@ -0,0 +1,3 @@
+export * from './counter.js';
+export * from './global-config.js';
+export * from './modules-factory.js';

package/src/complex/modules-factory.ts

@@ -0,0 +1,65 @@
+import type {
+  AnyObject,
+  Class,
+  EmptyObject,
+  IsPartial,
+} from '../utils/types.js';
+
+type ModuleLoaderConfig<TPredefinedDeps extends AnyObject = EmptyObject> = {
+  factory<TInstance, TDeps extends TPredefinedDeps>(
+    moduleClass: Class<TInstance, [TDeps]>,
+    deps: TDeps,
+  ): TInstance;
+} & (TPredefinedDeps extends EmptyObject
+  ? { deps?: TPredefinedDeps }
+  : { deps: TPredefinedDeps });
+
+/**
+ * Класс `ModulesFactory` является универсальной фабрикой для создания экземпляров указанного класса с зависимостями.
+ * Он использует объект конфигурации для определения того, как эти экземпляры создаются.
+ *
+ * Важное примечание - эта сущность работает только с классами конструктор которых имеет один параметр
+ *
+ * @template TPredefinedDeps - Тип, расширяющий `AnyObject`, представляющий предопределенные зависимости, которые использует фабрика.
+ *
+ * @example
+ * ```
+ * const factory = new ModulesFactory({
+ *   factory: (MyClass, deps) => new MyClass(deps),
+ *   deps: { someDependency: new Dependency() }
+ * });
+ *
+ * const instance = factory.create(MyClass, { extraDependency: new ExtraDependency() });
+ * ```
+ */
+export class ModulesFactory<TPredefinedDeps extends AnyObject = EmptyObject> {
+  /**
+   * Создает новый экземпляр `ModulesFactory`.
+   *
+   * @param config - Объект конфигурации для фабрики, включающий функцию фабрики и необязательные зависимости.
+   */
+  constructor(private config: ModuleLoaderConfig<TPredefinedDeps>) {}
+
+  /**
+   * Создает экземпляр указанного класса, внедряя необходимые зависимости.
+   *
+   * @template TInstance - Тип создаваемого экземпляра.
+   * @template TDeps - Тип зависимостей, необходимых для экземпляра.
+   *
+   * @param Constructor - Конструктор класса для создаваемого экземпляра.
+   * @param args - Необязательные дополнительные зависимости для объединения с предопределенными зависимостями.
+   *
+   * @returns Экземпляр указанного класса с внедренными зависимостями.
+   */
+  create<TInstance, TDeps extends TPredefinedDeps = TPredefinedDeps>(
+    Constructor: Class<TInstance, [TDeps]>,
+    ...args: IsPartial<Omit<TDeps, keyof TPredefinedDeps>> extends true
+      ? [extraDeps?: Omit<TDeps, keyof TPredefinedDeps>]
+      : [extraDeps: Omit<TDeps, keyof TPredefinedDeps>]
+  ) {
+    return this.config.factory(Constructor, {
+      ...this.config.deps!,
+      ...args[0],
+    } as any);
+  }
+}

package/src/cookie.ts

@@ -0,0 +1,11 @@
+import type { AnyObject } from './utils/types.js';
+
+export const parseCookie = (cookiesString = document.cookie) => {
+  return cookiesString
+    .split(';')
+    .map((cookieString) => cookieString.trim().split('='))
+    .reduce<AnyObject>((acc, current) => {
+      acc[current[0]] = current[1];
+      return acc;
+    }, {});
+};

package/src/css.ts

@@ -0,0 +1,60 @@
+import { cva as cvaLib } from 'class-variance-authority';
+import clsx, { type ClassValue } from 'clsx';
+import { twMerge } from 'tailwind-merge';
+
+type ClassProp = {
+  class?: ClassValue;
+  className?: ClassValue;
+};
+
+type StringToBoolean<T> = T extends 'true' | 'false' ? boolean : T;
+
+/**
+ * Перевод значения в пикселях в rem строковое
+ */
+export const toRem = (px: number, remValue = 16) => `${px / remValue}rem`;
+
+/**
+ * classNames/clsx но с примесями tailwind-merge
+ */
+export const cx = (...args: Parameters<typeof clsx>) => twMerge(clsx(...args));
+
+type ConfigSchema = Record<string, Record<string, ClassValue>>;
+type ConfigVariants<T extends ConfigSchema> = {
+  [Variant in keyof T]?: StringToBoolean<keyof T[Variant]> | null | undefined;
+};
+type ConfigVariantsMulti<T extends ConfigSchema> = {
+  [Variant in keyof T]?:
+    | StringToBoolean<keyof T[Variant]>
+    | StringToBoolean<keyof T[Variant]>[]
+    | undefined;
+};
+type Config<T> = T extends ConfigSchema
+  ? {
+      variants?: T;
+      defaultVariants?: ConfigVariants<T>;
+      compoundVariants?: (T extends ConfigSchema
+        ? (ConfigVariants<T> | ConfigVariantsMulti<T>) & ClassProp
+        : ClassProp)[];
+    }
+  : never;
+
+type Props<T> = T extends ConfigSchema
+  ? ConfigVariants<T> & ClassProp
+  : ClassProp;
+
+/**
+ * Class Variance Authority но с примесями tailwind-merge
+ *
+ * https://cva.style/docs
+ */
+export const cva = ((...args: any[]) => {
+  const schema = cvaLib(...args);
+  return (...inputArgs: any[]) => twMerge(schema(...inputArgs));
+}) as any as <T>(
+  base?: ClassValue,
+  config?: Config<T>,
+) => (props?: Props<T>) => string;
+
+export type { VariantProps } from 'class-variance-authority';
+export type { ClassValue } from 'clsx';

package/src/data.test.ts

@@ -0,0 +1,99 @@
+import { describe } from 'node:test';
+import { expect, it } from 'vitest';
+
+import { isShallowEqual } from './data';
+
+describe('data tests', () => {
+  describe('isShallowEqual', () => {
+    it('two nulls', () => {
+      expect(isShallowEqual(null, null)).toBeTruthy();
+    });
+
+    it('two undefineds', () => {
+      expect(isShallowEqual(undefined, undefined)).toBeTruthy();
+    });
+
+    it('two empty objects', () => {
+      expect(isShallowEqual({}, {})).toBeTruthy();
+    });
+
+    it('two empty arrays', () => {
+      expect(isShallowEqual([], [])).toBeTruthy();
+    });
+
+    it('two empty arrays with different length', () => {
+      expect(isShallowEqual([1], [])).toBeFalsy();
+    });
+
+    it('two arrays with same values', () => {
+      expect(isShallowEqual([1, 2, 3], [1, 2, 3])).toBeTruthy();
+    });
+
+    it('two arrays with different order', () => {
+      expect(isShallowEqual([1, 2, 3], [3, 2, 1])).toBeFalsy();
+    });
+
+    it('two arrays with different length', () => {
+      expect(isShallowEqual([1, 2, 3], [1, 2, 3, 4])).toBeFalsy();
+    });
+
+    it('two objects with same keys and values', () => {
+      expect(isShallowEqual({ a: 1, b: 2 }, { a: 1, b: 2 })).toBeTruthy();
+    });
+
+    it('two objects with same keys and values in different order', () => {
+      expect(isShallowEqual({ a: 1, b: 2 }, { b: 2, a: 1 })).toBeTruthy();
+    });
+
+    it('two objects with different keys', () => {
+      expect(isShallowEqual({ a: 1, b: 2 }, { a: 1, c: 2 })).toBeFalsy();
+    });
+
+    it('two objects with same keys and different values', () => {
+      expect(isShallowEqual({ a: 1, b: 2 }, { a: 1, b: 3 })).toBeFalsy();
+    });
+
+    it('two objects with same keys, different values and different order', () => {
+      expect(isShallowEqual({ a: 1, b: 2 }, { b: 3, a: 1 })).toBeFalsy();
+    });
+
+    it('two objects with extra key on first object', () => {
+      expect(isShallowEqual({ a: 1, b: 2, c: 3 }, { a: 1, b: 2 })).toBeFalsy();
+    });
+
+    it('two objects with extra key on second object', () => {
+      expect(isShallowEqual({ a: 1, b: 2 }, { a: 1, b: 2, c: 3 })).toBeFalsy();
+    });
+    it('first is null, second is object', () => {
+      expect(isShallowEqual(null, { a: 1 })).toBeFalsy();
+    });
+
+    it('first is object, second is null', () => {
+      expect(isShallowEqual({ a: 1 }, null)).toBeFalsy();
+    });
+
+    it('first is undefined, second is object', () => {
+      expect(isShallowEqual(undefined, { a: 1 })).toBeFalsy();
+    });
+
+    it('first is object, second is undefined', () => {
+      expect(isShallowEqual({ a: 1 }, undefined)).toBeFalsy();
+    });
+
+    it('two objects with different class but same keys and values', () => {
+      class A {
+        constructor(
+          public a: number,
+          public b: number,
+        ) {}
+      }
+      class B {
+        constructor(
+          public a: number,
+          public b: number,
+        ) {}
+      }
+      expect(isShallowEqual(new A(1, 2), new B(1, 2))).toBeFalsy();
+    });
+  });
+});

package/src/data.ts

@@ -0,0 +1,65 @@
+import type { AnyObject } from './utils/types.js';
+
+export const isShallowEqual = (a: unknown, b: unknown): boolean => {
+  if (a === b) return true;
+
+  if (
+    typeof a !== 'object' ||
+    typeof b !== 'object' ||
+    a === null ||
+    b === null
+  ) {
+    return false;
+  }
+
+  if (a.constructor !== b.constructor) return false;
+
+  const isArrayA = Array.isArray(a);
+
+  if (isArrayA !== Array.isArray(b)) return false;
+
+  if (isArrayA) {
+    const arrA = a as unknown[];
+    const arrB = b as unknown[];
+    if (arrA.length !== arrB.length) return false;
+
+    for (const [i, element] of arrA.entries()) {
+      if (element !== arrB[i]) return false;
+    }
+    return true;
+  }
+
+  if (a instanceof Date) return a.getTime() === (b as Date).getTime();
+
+  if (a instanceof RegExp) return a.toString() === (b as RegExp).toString();
+
+  const aKeys = Object.keys(a);
+  const bKeys = Object.keys(b);
+
+  if (aKeys.length !== bKeys.length) return false;
+
+  const bObj = b as AnyObject;
+  for (const key of aKeys) {
+    if (!Object.hasOwn(bObj, key) || (a as AnyObject)[key] !== bObj[key]) {
+      return false;
+    }
+  }
+
+  return true;
+};
+
+export const flatMapDeep = <TSource, TNewValue>(
+  arr: TSource | TSource[],
+  fn: (value: TSource, i: number, arr: TSource[]) => TNewValue,
+): TNewValue[] =>
+  Array.isArray(arr)
+    ? arr.flatMap((c: TSource): TNewValue[] => flatMapDeep(c, fn))
+    : [fn(arr, 0, [arr])];
+
+export const safeJsonParse = (json: string) => {
+  try {
+    return JSON.parse(json);
+  } catch {
+    return null;
+  }
+};

package/src/date-time.test.ts

@@ -0,0 +1,119 @@
+import { describe, expect, test } from 'vitest';
+
+import {
+  changeDate,
+  dayTimeDuration,
+  getFormatDuration,
+  timeDuration,
+} from './date-time.js';
+import { unitsToMs } from './ms.js';
+
+describe('date-time', () => {
+  describe('dayTimeDuration', () => {
+    test('-1 minute', () => {
+      expect(dayTimeDuration(-unitsToMs.min)).toStrictEqual({
+        days: 0,
+        hours: 0,
+        seconds: 0,
+        minutes: 0,
+        milliseconds: 0,
+      });
+    });
+
+    test('1 minute', () => {
+      expect(dayTimeDuration(unitsToMs.min)).toStrictEqual({
+        days: 0,
+        hours: 0,
+        seconds: 0,
+        minutes: 1,
+        milliseconds: 0,
+      });
+    });
+
+    test('30 minutes 45 seconds', () => {
+      expect(
+        dayTimeDuration(unitsToMs.min * 30 + unitsToMs.sec * 45),
+      ).toStrictEqual({
+        days: 0,
+        hours: 0,
+        seconds: 45,
+        minutes: 30,
+        milliseconds: 0,
+      });
+    });
+
+    test('34 days 59 minutes 59 seconds', () => {
+      expect(
+        dayTimeDuration(
+          34 * unitsToMs.day + unitsToMs.min * 59 + unitsToMs.sec * 59,
+        ),
+      ).toStrictEqual({
+        days: 34,
+        hours: 0,
+        minutes: 59,
+        seconds: 59,
+        milliseconds: 0,
+      });
+    });
+  });
+  describe('timeDuration', () => {
+    test('-1 minute', () => {
+      expect(timeDuration(-unitsToMs.min)).toStrictEqual({
+        hours: 0,
+        seconds: 0,
+        minutes: 0,
+        milliseconds: 0,
+      });
+    });
+
+    test('1 minute', () => {
+      expect(timeDuration(unitsToMs.min)).toStrictEqual({
+        hours: 0,
+        seconds: 0,
+        minutes: 1,
+        milliseconds: 0,
+      });
+    });
+
+    test('30 minutes 45 seconds', () => {
+      expect(
+        timeDuration(unitsToMs.min * 30 + unitsToMs.sec * 45),
+      ).toStrictEqual({
+        hours: 0,
+        seconds: 45,
+        minutes: 30,
+        milliseconds: 0,
+      });
+    });
+
+    test('34 days 59 minutes 59 seconds', () => {
+      expect(
+        timeDuration(
+          34 * unitsToMs.day + unitsToMs.min * 59 + unitsToMs.sec * 59,
+        ),
+      ).toStrictEqual({
+        hours: 2_937_600_000,
+        minutes: 59,
+        seconds: 59,
+        milliseconds: 0,
+      });
+    });
+  });
+  describe('getFormatDuration', () => {
+    test('30 minutes', () => {
+      const dateA = new Date(`2025-02-10T09:53:00.000Z`);
+      const dateB = changeDate(dateA, 30, 'minutes');
+      expect(getFormatDuration(dateA, dateB)).toBe('30 минут');
+    });
+    test('2 hours 45 minutes 10 seconds', () => {
+      const dateA = new Date(`2025-02-10T09:53:00.000Z`);
+      const dateB = changeDate(dateA, 2, 'hours', 45, 'minutes', 10, 'seconds');
+      expect(getFormatDuration(dateA, dateB)).toBe('2 часа 45 минут 10 секунд');
+    });
+    test('2 hours 45 minutes 10 seconds (compact)', () => {
+      const dateA = new Date(`2025-02-10T09:53:00.000Z`);
+      const dateB = changeDate(dateA, 2, 'hours', 45, 'minutes', 10, 'seconds');
+      expect(getFormatDuration(dateA, dateB, true)).toBe('2 ч 45 мин 10 сек');
+    });
+  });
+});