yummies 5.4.6 → 5.4.7

package/src/ms.ts

@@ -1,20 +0,0 @@
-export const unitsToMs = {
-  ms: 1,
-  sec: 1000,
-  min: 1000 * 60,
-  hour: 1000 * 60 * 60,
-  day: 1000 * 60 * 60 * 24,
-  week: 1000 * 60 * 60 * 24 * 7,
-} as const;
-
-/**
- * Переводит значение в юнитах в миллисекунды
- *
- * @example
- * ```ts
- * ms(1, 'min') // 60_000
- * ms(30, 'sec') // 30_000
- * ```
- */
-export const ms = (value: number, unit: keyof typeof unitsToMs = 'ms') =>
-  value * unitsToMs[unit];

package/src/number.ts

@@ -1,14 +0,0 @@
-/**
- * Works like `parseFloat(number.toFixed(4))` but performance better
- *
- * @example
- * round(191.212999999999999999999999, 4) // 191.213
- */
-export function round(value: number, decimalPlaces: number = 0): number {
-  if (!decimalPlaces) {
-    return Math.round(value);
-  }
-
-  const factor = 10 ** decimalPlaces;
-  return Math.round(value * factor) / factor;
-}

package/src/parser/number.test.ts

@@ -1,38 +0,0 @@
-import { describe, expect, test } from 'vitest';
-import { number } from './number';
-
-describe('parser.number', () => {
-  test('empty string should return 0', () => {
-    expect(number('')).toBe(0);
-  });
-
-  test('empty string with fallback should return fallback', () => {
-    expect(number('', { fallback: 'kek' })).toBe('kek');
-  });
-
-  test('Checking the logic of the function', () => {
-    expect(number(1)).toBe(1);
-    expect(number(100)).toBe(100);
-    expect(number(500)).toBe(500);
-    expect(number(1, { clamped: [400] })).toBe(400);
-    expect(number(1001, { clamped: [null, 1000] })).toBe(1000);
-  });
-
-  test('Rounding down', () => {
-    expect(number(5.9, { floor: true })).toBe(5);
-  });
-
-  test('Rounding up', () => {
-    expect(number(5.1, { ceil: true })).toBe(6);
-  });
-
-  test('Processing invalid values', () => {
-    expect(number(null)).toBe(0);
-    expect(number(undefined)).toBe(0);
-    expect(number('-')).toBe(0);
-    expect(number('test')).toBe(0);
-
-    expect(number(null, null)).toBe(0);
-    expect(number(undefined, undefined)).toBe(0);
-  });
-});

package/src/parser/number.ts

@@ -1,73 +0,0 @@
-import { skipSpaces } from '../format/skip-spaces.js';
-import { typeGuard } from '../type-guard/index.js';
-import type { Maybe } from '../utils/types.js';
-
-export interface NumberParserSettings<TFallback = number> {
-  digits?: number;
-  fallback?: TFallback;
-  /**
-   * Round to upper boundary
-   * 5.1 -> 6
-   */
-  ceil?: boolean;
-  /**
-   * Round to bottom boundary
-   * 5.9 -> 5
-   */
-  floor?: boolean;
-  clamped?: [min?: Maybe<number>, max?: Maybe<number>];
-}
-
-export const number = <TFallback = number>(
-  input: Maybe<unknown>,
-  userSettings?: Maybe<NumberParserSettings<TFallback>>,
-): number | TFallback => {
-  const settings = {
-    ...number.defaultSettings,
-    ...userSettings,
-  };
-
-  const fallback = settings?.fallback ?? 0;
-
-  let result: number;
-
-  if (typeGuard.isNumber(input)) {
-    result = input;
-  } else if (typeGuard.isString(input)) {
-    const formattedInput = skipSpaces(input).replace(',', '.');
-    if (formattedInput === '') {
-      result = fallback as any;
-    } else {
-      result = Number(formattedInput);
-    }
-  } else {
-    result = fallback as any;
-  }
-
-  if (typeGuard.isNumber(result)) {
-    if (settings?.clamped != null) {
-      result = Math.max(
-        settings.clamped[0] ?? -Infinity,
-        Math.min(result, settings.clamped[1] ?? Infinity),
-      );
-    }
-
-    if (settings?.ceil != null) {
-      result = Math.ceil(result);
-    }
-
-    if (settings?.floor != null) {
-      result = Math.floor(result);
-    }
-
-    if (settings?.digits != null) {
-      result = +result.toFixed(settings.digits);
-    }
-
-    return result;
-  } else {
-    return fallback;
-  }
-};
-
-number.defaultSettings = {} as NumberParserSettings;

package/src/parser/percent.ts

@@ -1,11 +0,0 @@
-import type { Maybe } from '../utils/types.js';
-
-import { type NumberParserSettings, number } from './number.js';
-
-export const percent = <TFallback = number>(
-  value: Maybe<string | number>,
-  maxValue?: Maybe<string | number>,
-  settings?: Maybe<NumberParserSettings<TFallback>>,
-) => {
-  return number<TFallback>((Number(value) / Number(maxValue)) * 100, settings);
-};

package/src/parser/string.ts

@@ -1,29 +0,0 @@
-import { typeGuard } from '../type-guard/index.js';
-import type { Maybe } from '../utils/types.js';
-
-export interface StringParserSettings<TFallback = string> {
-  fallback?: TFallback;
-  prettyJson?: boolean;
-}
-
-export const string = <TFallback = string>(
-  input: Maybe<unknown>,
-  settings?: Maybe<StringParserSettings<TFallback>>,
-): string | TFallback => {
-  const fallback =
-    settings && 'fallback' in settings ? (settings.fallback as TFallback) : '';
-
-  if (input == null) {
-    return fallback;
-  }
-
-  if (typeGuard.isObject(input)) {
-    if (settings?.prettyJson) {
-      return JSON.stringify(input, null, 2);
-    }
-
-    return JSON.stringify(input);
-  }
-
-  return String(input);
-};

package/src/price.ts

@@ -1,33 +0,0 @@
-export interface PriceFormatOptions
-  extends Partial<Omit<Intl.NumberFormatOptions, 'currency'>> {
-  withoutSymbol?: boolean;
-  customSymbol?: string;
-}
-
-export const formatPrice = (
-  price: number,
-  locale: string,
-  currency?: string,
-  { withoutSymbol, customSymbol, ...options }: PriceFormatOptions = {},
-) => {
-  const priceFormatter = new Intl.NumberFormat(locale, {
-    style: 'currency',
-    currency,
-    minimumFractionDigits: 0,
-    currencyDisplay: 'narrowSymbol',
-    ...options,
-  });
-
-  const zeroPrice = priceFormatter.format(0);
-  const currencySymbol = zeroPrice.replace('0', '');
-  const rawPrice = priceFormatter.format(price);
-  const priceWithoutCurrency = rawPrice.replace(currencySymbol, '');
-
-  if (withoutSymbol) {
-    return priceWithoutCurrency;
-  }
-
-  return `${priceWithoutCurrency} ${
-    customSymbol ?? (currency === 'RUB' ? 'р' : currencySymbol)
-  }`.replace(/\s{2,}/, ' ');
-};

package/src/random.ts

@@ -1,27 +0,0 @@
-export const getRandomFloat = <T extends number = number>(
-  min = 0,
-  max = 1,
-): T => (Math.random() * (max - min) + min) as T;
-
-export const getRandomInt = <T extends number = number>(min = 0, max = 1): T =>
-  min === max ? (min as T) : (Math.round(getRandomFloat(min, max)) as T);
-
-export const getRandomChoice = <T>(arr: T[]): T =>
-  arr[getRandomInt(0, arr.length - 1)];
-
-export const getRandomSizeArray = (min = 0, max = 10) =>
-  Array.from({ length: getRandomInt(min, max) }).fill(null);
-
-export const getRandomBool = () => getRandomInt(0, 1) === 1;
-
-export const getMajorRandomBool = () => {
-  return getRandomInt(0, 10) <= 6;
-};
-
-export const getMinorRandomBool = () => {
-  return !getMajorRandomBool();
-};
-
-export const getFrequencyValue = (frequency: number) => {
-  return Math.random() < frequency;
-};

package/src/react/hooks/use-abort-controller.ts

@@ -1,15 +0,0 @@
-import { useEffect } from 'react';
-
-import { useConstant } from './use-constant.js';
-
-export const useAbortController = () => {
-  const controller = useConstant(() => new AbortController());
-
-  useEffect(() => {
-    return () => {
-      controller.abort();
-    };
-  }, []);
-
-  return controller;
-};

package/src/react/hooks/use-click-outside.ts

@@ -1,27 +0,0 @@
-import type { MutableRefObject } from 'react';
-import { useEventListener } from './use-event-listener.js';
-
-type ClickOutsideInput = {
-  contentRef: MutableRefObject<HTMLElement | null>;
-  onClick: VoidFunction;
-  options?: AddEventListenerOptions;
-};
-
-export const useClickOutside = ({
-  contentRef,
-  onClick,
-  options,
-}: ClickOutsideInput) => {
-  useEventListener({
-    event: 'mousedown',
-    handler: (event) => {
-      if (
-        contentRef.current &&
-        !contentRef.current.contains(event.target as Node)
-      ) {
-        onClick();
-      }
-    },
-    options,
-  });
-};

package/src/react/hooks/use-element-ref.ts

@@ -1,11 +0,0 @@
-import { useLayoutEffect, useRef } from 'react';
-
-export const useElementRef = <T extends HTMLElement>(selector: () => T) => {
-  const ref = useRef<T>();
-
-  useLayoutEffect(() => {
-    ref.current = selector();
-  }, []);
-
-  return ref;
-};

package/src/react/hooks/use-event-listener.ts

@@ -1,29 +0,0 @@
-/* eslint-disable @typescript-eslint/ban-ts-comment */
-import { useEffect } from 'react';
-import { useSyncRef } from './use-sync-ref.js';
-
-export const useEventListener = <EventName extends keyof HTMLElementEventMap>({
-  event,
-  handler,
-  options,
-  deps = [],
-  node = document,
-}: {
-  event: EventName;
-  handler: (e: HTMLElementEventMap[EventName]) => void;
-  options?: boolean | AddEventListenerOptions;
-  deps?: unknown[];
-  node?: HTMLElement | Document | Window;
-}) => {
-  const handlerRef = useSyncRef(handler);
-
-  useEffect(() => {
-    const handleEvent = (e: HTMLElementEventMap[EventName]) =>
-      handlerRef.current(e);
-
-    // @ts-expect-error
-    node.addEventListener(event, handleEvent, options);
-    // @ts-expect-error
-    return () => node.removeEventListener(event, handleEvent, options);
-  }, deps);
-};

package/src/react/hooks/use-event.ts

@@ -1,23 +0,0 @@
-/**
- * A Hook to define an event handler with an always-stable function identity.
- *
- * borrowed from @gaeron
- * https://github.com/reactjs/rfcs/blob/useevent/text/0000-useevent.md
- */
-import { useCallback, useLayoutEffect, useRef } from 'react';
-import type { AnyFunction } from '../../utils/types.js';
-
-export const useEvent = <H extends AnyFunction>(handler: H): H => {
-  const handlerRef = useRef<H>(handler);
-
-  // In a real implementation, this would run before layout effects
-  useLayoutEffect(() => {
-    handlerRef.current = handler;
-  });
-
-  return useCallback((...args: unknown[]) => {
-    // In a real implementation, this would throw if called during render
-    const fn = handlerRef.current as AnyFunction;
-    return fn(...args);
-  }, []) as unknown as H;
-};

package/src/react/hooks/use-flag.ts

@@ -1,27 +0,0 @@
-import { useCallback, useRef, useState } from 'react';
-
-export interface FlagHook {
-  enabled: boolean;
-  toggle: VoidFunction;
-  enable: VoidFunction;
-  disable: VoidFunction;
-}
-
-export const useFlag = (defaultValue = false): FlagHook => {
-  const [enabled, setEnabled] = useState(defaultValue);
-
-  const toggle = useCallback(() => setEnabled((value) => !value), []);
-  const enable = useCallback(() => setEnabled(true), []);
-  const disable = useCallback(() => setEnabled(false), []);
-
-  const flagObjRef = useRef<FlagHook>({
-    enabled,
-    toggle,
-    enable,
-    disable,
-  });
-
-  flagObjRef.current.enabled = enabled;
-
-  return flagObjRef.current;
-};

package/src/react/hooks/use-force-update.ts

@@ -1,9 +0,0 @@
-import { useCallback, useState } from 'react';
-
-export const useForceUpdate = () => {
-  const [, setState] = useState<unknown>(null);
-
-  return useCallback(() => {
-    setState({});
-  }, []);
-};

package/src/react/hooks/use-initial-height.ts

@@ -1,16 +0,0 @@
-import { useEffect, useRef, useState } from 'react';
-
-export const useInitialHeight = <T extends HTMLElement>() => {
-  const ref = useRef<T | null>(null);
-  const [initialHeight, setInitialHeight] = useState<number | undefined>(
-    undefined,
-  );
-
-  useEffect(() => {
-    if (ref.current && !initialHeight) {
-      setInitialHeight(ref.current.offsetHeight);
-    }
-  }, [initialHeight]);
-
-  return { ref, initialHeight };
-};

package/src/react/hooks/use-intersection-observer.ts

@@ -1,18 +0,0 @@
-import { useEffect, useState } from 'react';
-
-export const useIntersectionObserver = (
-  callback: IntersectionObserverCallback,
-  options?: IntersectionObserverInit,
-) => {
-  const [intersectionObserver] = useState(
-    () => new IntersectionObserver(callback, options),
-  );
-
-  useEffect(() => {
-    return () => {
-      intersectionObserver.disconnect();
-    };
-  }, []);
-
-  return intersectionObserver;
-};

package/src/react/hooks/use-last-defined-value.ts

@@ -1,9 +0,0 @@
-import { useRef } from 'react';
-
-export const useLastDefinedValue = <T>(value: T) => {
-  const ref = useRef(value);
-  if (value != null) {
-    ref.current = value;
-  }
-  return ref.current;
-};

package/src/react/hooks/use-last-value-ref.ts

@@ -1,11 +0,0 @@
-import { useRef } from 'react';
-
-export const useLastValueRef = <T>(value: T | null | undefined) => {
-  const ref = useRef(value);
-
-  if (value != null) {
-    ref.current = value;
-  }
-
-  return ref;
-};

package/src/react/hooks/use-life-cycle.ts

@@ -1,17 +0,0 @@
-import { useEffect } from 'react';
-import { useSyncRef } from './use-sync-ref.js';
-
-export const useLifeCycle = (
-  fn: () => {
-    mount?: VoidFunction;
-    unmount?: VoidFunction;
-  },
-) => {
-  const fnRef = useSyncRef(fn);
-
-  useEffect(() => {
-    const fnOperation = fnRef.current();
-    fnOperation.mount?.();
-    return fnOperation.unmount?.();
-  }, []);
-};

package/src/react/hooks/use-resize-observer.ts

@@ -1,14 +0,0 @@
-import { useLayoutEffect } from 'react';
-import { useDefineRef } from './use-define-ref.js';
-
-export const useResizeObserver = (callback: ResizeObserverCallback) => {
-  const resizeObserverRef = useDefineRef(() => new ResizeObserver(callback));
-
-  useLayoutEffect(() => {
-    return () => {
-      resizeObserverRef.current.disconnect();
-    };
-  }, []);
-
-  return resizeObserverRef;
-};

package/src/react/hooks/use-sync-ref.ts

@@ -1,7 +0,0 @@
-import { useRef } from 'react';
-
-export const useSyncRef = <T>(value: T) => {
-  const ref = useRef(value);
-  ref.current = value;
-  return ref;
-};

package/src/react/hooks/use-toggle.ts

@@ -1,9 +0,0 @@
-import { useCallback, useState } from 'react';
-
-export const useToggle = (initialState?: boolean) => {
-  const [toggled, setToggled] = useState(!!initialState);
-
-  const toggle = useCallback(() => setToggled((toggled) => !toggled), []);
-
-  return [toggled, toggle, setToggled] as const;
-};

package/src/react/hooks/use-value.ts

@@ -1,10 +0,0 @@
-import { useState } from 'react';
-
-export const useValue = <T>(defaults: T | (() => T)) => {
-  const [value, setValue] = useState<T>(defaults);
-
-  return {
-    value,
-    set: setValue,
-  };
-};

package/src/react/hooks/use-visibility-state.ts

@@ -1,19 +0,0 @@
-import { useEffect, useState } from 'react';
-
-export const useVisibilityState = () => {
-  const [state, setState] = useState<DocumentVisibilityState>();
-
-  useEffect(() => {
-    const handleVisibilityChange = () => {
-      setState(document.visibilityState);
-    };
-
-    document.addEventListener('visibilitychange', handleVisibilityChange);
-
-    return () => {
-      document.removeEventListener('visibilitychange', handleVisibilityChange);
-    };
-  }, []);
-
-  return state;
-};

package/src/sound.ts

@@ -1,15 +0,0 @@
-/**
- * Воспроизводит звук из файла
- */
-export const playSound = async (
-  file: string,
-  { volume = 1 }: { volume?: number } = {},
-) => {
-  let audio = new Audio(file);
-  audio.volume = volume;
-  audio.muted = !volume;
-  await audio.play();
-  audio.remove();
-  // @ts-expect-error
-  audio = null;
-};