yummies 5.4.4 → 5.4.6

package/src/date-time.ts

@@ -0,0 +1,236 @@
+import dayjs, { type Dayjs, type ManipulateType } from 'dayjs';
+import duration from 'dayjs/plugin/duration.js';
+import relativeTime from 'dayjs/plugin/relativeTime.js';
+
+import { format } from './format/index.js';
+import { unitsToMs } from './ms.js';
+import { declension } from './text.js';
+import { typeGuard } from './type-guard/index.js';
+import type { Maybe } from './utils/types.js';
+
+import 'dayjs/locale/ru.js';
+
+dayjs.extend(relativeTime);
+dayjs.extend(duration);
+dayjs.locale('ru');
+
+const toLibFormat = (
+  value: Maybe<RawDateToFormat>,
+  asTime?: boolean,
+): Dayjs => {
+  if (typeGuard.isNumber(value)) {
+    if (asTime) {
+      return dayjs.duration(value) as unknown as Dayjs;
+    }
+    return dayjs(value);
+  } else if (dayjs.isDayjs(value)) {
+    return value;
+  } else {
+    return dayjs(value);
+  }
+};
+
+export type RawDateToFormat = Date | string | number | Dayjs;
+
+export const formatDate = (
+  value: Maybe<RawDateToFormat>,
+  settings?: Maybe<{
+    format?:
+      | 'human'
+      | 'full'
+      | 'short'
+      | 'day'
+      | 'day-only'
+      | 'date'
+      | 'month'
+      | 'spent-time'
+      | 'time'
+      | 'time-short';
+    pattern?: string;
+    asTime?: boolean;
+  }>,
+) => {
+  const dateFormat = settings?.format;
+  const datePattern = settings?.pattern;
+  const asTime = settings?.asTime;
+
+  value = toLibFormat(value, asTime);
+
+  if (typeGuard.isUndefined(value) || !value.isValid()) {
+    return format.NO_VALUE;
+  }
+
+  if (datePattern) {
+    return value.format(datePattern);
+  }
+
+  switch (dateFormat) {
+    case 'human': {
+      return value.fromNow();
+    }
+    case 'spent-time': {
+      return value.fromNow(true);
+    }
+    case 'full': {
+      return value.format('DD MMM YYYY HH:mm:ss');
+    }
+    case 'short': {
+      return value.format('DD MMM HH:mm');
+    }
+    case 'time': {
+      return value.format('HH:mm:ss');
+    }
+    case 'time-short': {
+      return value.format('HH:mm');
+    }
+    case 'day': {
+      return value.format('DD MMM YYYY');
+    }
+    case 'month': {
+      return value.format('MMMM YYYY');
+    }
+    default: {
+      return value.format('DD.MM.YYYY');
+    }
+  }
+};
+
+export const dayTimeDuration = (timeInMs: number) => {
+  let left = Math.max(timeInMs, 0);
+
+  const days = Math.floor(left / unitsToMs.day);
+  left = left % unitsToMs.day;
+
+  const hours = Math.floor(left / unitsToMs.hour);
+  left = left % unitsToMs.hour;
+
+  const minutes = Math.floor(left / unitsToMs.min);
+  left = left % unitsToMs.min;
+
+  const seconds = Math.floor(left / unitsToMs.sec);
+  left = left % unitsToMs.sec;
+
+  const milliseconds = Math.floor(left);
+
+  return {
+    days,
+    hours,
+    minutes,
+    seconds,
+    milliseconds,
+  };
+};
+
+type DateChangeParam = [amount: number, unit?: Maybe<ManipulateType>];
+
+export const changeDate = (
+  date: Maybe<RawDateToFormat>,
+  ...args: [
+    ...DateChangeParam,
+    ...Partial<DateChangeParam>,
+    ...Partial<DateChangeParam>,
+    ...Partial<DateChangeParam>,
+    ...Partial<DateChangeParam>,
+    ...Partial<DateChangeParam>,
+  ]
+) => {
+  let wrappedDate = toLibFormat(date);
+
+  for (let i = 0; i < args.length; i += 2) {
+    const amount = args[i] as DateChangeParam[0];
+    const unit = args[i + 1] as DateChangeParam[1];
+    if (unit != null) {
+      wrappedDate = wrappedDate.add(amount, unit);
+    }
+  }
+
+  return wrappedDate.toDate();
+};
+
+export const timeDuration = (timeInMs: number) => {
+  const { days, hours, milliseconds, minutes, seconds } =
+    dayTimeDuration(timeInMs);
+
+  return {
+    hours: hours + unitsToMs.day * days,
+    milliseconds,
+    minutes,
+    seconds,
+  };
+};
+
+const durationFormatLabels = {
+  days: { compact: 'д', full: ['день', 'дня', 'дней'] },
+  hours: { compact: 'ч', full: ['час', 'часа', 'часов'] },
+  minutes: { compact: 'мин', full: ['минута', 'минуты', 'минут'] },
+  seconds: { compact: 'сек', full: ['секунда', 'секунды', 'секунд'] },
+} as const;
+
+export function getFormatDuration(
+  dateA: Date,
+  dateB: Date,
+  compact?: boolean,
+): string;
+export function getFormatDuration(ms: number, compact?: boolean): string;
+
+export function getFormatDuration(...args: any[]): string {
+  let compact = false;
+  let diff = 0;
+
+  if (args[0] instanceof Date) {
+    const startedDate = dayjs(args[0]);
+    const endedDate = dayjs(args[1]);
+
+    diff = endedDate.diff(startedDate, 'ms');
+    compact = args[2] === true;
+  } else {
+    diff = args[0];
+    compact = args[1] === true;
+  }
+
+  const { days, hours, minutes, seconds } = dayTimeDuration(diff);
+
+  const formattedParts: string[] = [];
+
+  if (days) {
+    if (compact) {
+      formattedParts.push(`${days} ${durationFormatLabels.days.compact}`);
+    } else {
+      formattedParts.push(
+        `${days} ${declension(days, durationFormatLabels.days.full)}`,
+      );
+    }
+  }
+
+  if (hours) {
+    if (compact) {
+      formattedParts.push(`${hours} ${durationFormatLabels.hours.compact}`);
+    } else {
+      formattedParts.push(
+        `${hours} ${declension(hours, durationFormatLabels.hours.full)}`,
+      );
+    }
+  }
+
+  if (minutes) {
+    if (compact) {
+      formattedParts.push(`${minutes} ${durationFormatLabels.minutes.compact}`);
+    } else {
+      formattedParts.push(
+        `${minutes} ${declension(minutes, durationFormatLabels.minutes.full)}`,
+      );
+    }
+  }
+
+  if (seconds) {
+    if (compact) {
+      formattedParts.push(`${seconds} ${durationFormatLabels.seconds.compact}`);
+    } else {
+      formattedParts.push(
+        `${seconds} ${declension(seconds, durationFormatLabels.seconds.full)}`,
+      );
+    }
+  }
+
+  return formattedParts.join(' ');
+}

package/src/device.ts

@@ -0,0 +1,42 @@
+export const getUserAgent = () =>
+  (
+    navigator.userAgent ||
+    navigator.vendor ||
+    // @ts-expect-error skip opera
+    globalThis.opera ||
+    ''
+  ).toLowerCase();
+
+export const checkIsMobileDevice = () => {
+  const userAgent = getUserAgent();
+
+  if (
+    /(android|bb\d+|meego).+mobile|avantgo|bada\/|blackberry|blazer|compal|elaine|fennec|hiptop|iemobile|ip(hone|od)|iris|kindle|lge |maemo|midp|mmp|mobile.+firefox|netfront|opera m(ob|in)i|palm( os)?|phone|p(ixi|re)\/|plucker|pocket|psp|series(4|6)0|symbian|treo|up\.(browser|link)|vodafone|wap|windows ce|xda|xiino/i.test(
+      userAgent || '',
+    ) ||
+    /1207|6310|6590|3gso|4thp|50[1-6]i|770s|802s|a wa|abac|ac(er|oo|s-)|ai(ko|rn)|al(av|ca|co)|amoi|an(ex|ny|yw)|aptu|ar(ch|go)|as(te|us)|attw|au(di|-m|r |s )|avan|be(ck|ll|nq)|bi(lb|rd)|bl(ac|az)|br(e|v)w|bumb|bw-(n|u)|c55\/|capi|ccwa|cdm-|cell|chtm|cldc|cmd-|co(mp|nd)|craw|da(it|ll|ng)|dbte|dc-s|devi|dica|dmob|do(c|p)o|ds(12|-d)|el(49|ai)|em(l2|ul)|er(ic|k0)|esl8|ez([4-7]0|os|wa|ze)|fetc|fly(-|_)|g1 u|g560|gene|gf-5|g-mo|go(\.w|od)|gr(ad|un)|haie|hcit|hd-(m|p|t)|hei-|hi(pt|ta)|hp( i|ip)|hs-c|ht(c(-| |_|a|g|p|s|t)|tp)|hu(aw|tc)|i-(20|go|ma)|i230|iac( |-|\/)|ibro|idea|ig01|ikom|im1k|inno|ipaq|iris|ja(t|v)a|jbro|jemu|jigs|kddi|keji|kgt( |\/)|klon|kpt |kwc-|kyo(c|k)|le(no|xi)|lg( g|\/(k|l|u)|50|54|-[a-w])|libw|lynx|m1-w|m3ga|m50\/|ma(te|ui|xo)|mc(01|21|ca)|m-cr|me(rc|ri)|mi(o8|oa|ts)|mmef|mo(01|02|bi|de|do|t(-| |o|v)|zz)|mt(50|p1|v )|mwbp|mywa|n10[0-2]|n20[2-3]|n30(0|2)|n50(0|2|5)|n7(0(0|1)|10)|ne((c|m)-|on|tf|wf|wg|wt)|nok(6|i)|nzph|o2im|op(ti|wv)|oran|owg1|p800|pan(a|d|t)|pdxg|pg(13|-([1-8]|c))|phil|pire|pl(ay|uc)|pn-2|po(ck|rt|se)|prox|psio|pt-g|qa-a|qc(07|12|21|32|60|-[2-7]|i-)|qtek|r380|r600|raks|rim9|ro(ve|zo)|s55\/|sa(ge|ma|mm|ms|ny|va)|sc(01|h-|oo|p-)|sdk\/|se(c(-|0|1)|47|mc|nd|ri)|sgh-|shar|sie(-|m)|sk-0|sl(45|id)|sm(al|ar|b3|it|t5)|so(ft|ny)|sp(01|h-|v-|v )|sy(01|mb)|t2(18|50)|t6(00|10|18)|ta(gt|lk)|tcl-|tdg-|tel(i|m)|tim-|t-mo|to(pl|sh)|ts(70|m-|m3|m5)|tx-9|up(\.b|g1|si)|utst|v400|v750|veri|vi(rg|te)|vk(40|5[0-3]|-v)|vm40|voda|vulc|vx(52|53|60|61|70|80|81|83|85|98)|w3c(-| )|webc|whit|wi(g |nc|nw)|wmlb|wonu|x700|yas-|your|zeto|zte-/i.test(
+      (userAgent || '').slice(0, 4),
+    )
+  ) {
+    return true;
+  }
+
+  return false;
+};
+
+export const checkIsTabletDevice = () => {
+  const userAgent = getUserAgent();
+
+  return /(ipad|tablet|(android(?!.*mobile))|(windows(?!.*phone)(.*touch))|kindle|playbook|silk|(puffin(?!.*(IP|AP|WP))))/.test(
+    userAgent,
+  );
+};
+
+export const checkIsTouchDevice = () =>
+  checkIsMobileDevice() || checkIsTabletDevice();
+
+export const isMobileDevice = checkIsMobileDevice();
+
+export const isTabletDevice = checkIsTabletDevice();
+
+export const isTouchDevice = isMobileDevice || isTabletDevice;

package/src/encodings.ts

@@ -0,0 +1,270 @@
+import type { AnyObject } from './utils/types.js';
+
+const DMap: AnyObject = {
+  0: 0,
+  1: 1,
+  2: 2,
+  3: 3,
+  4: 4,
+  5: 5,
+  6: 6,
+  7: 7,
+  8: 8,
+  9: 9,
+  10: 10,
+  11: 11,
+  12: 12,
+  13: 13,
+  14: 14,
+  15: 15,
+  16: 16,
+  17: 17,
+  18: 18,
+  19: 19,
+  20: 20,
+  21: 21,
+  22: 22,
+  23: 23,
+  24: 24,
+  25: 25,
+  26: 26,
+  27: 27,
+  28: 28,
+  29: 29,
+  30: 30,
+  31: 31,
+  32: 32,
+  33: 33,
+  34: 34,
+  35: 35,
+  36: 36,
+  37: 37,
+  38: 38,
+  39: 39,
+  40: 40,
+  41: 41,
+  42: 42,
+  43: 43,
+  44: 44,
+  45: 45,
+  46: 46,
+  47: 47,
+  48: 48,
+  49: 49,
+  50: 50,
+  51: 51,
+  52: 52,
+  53: 53,
+  54: 54,
+  55: 55,
+  56: 56,
+  57: 57,
+  58: 58,
+  59: 59,
+  60: 60,
+  61: 61,
+  62: 62,
+  63: 63,
+  64: 64,
+  65: 65,
+  66: 66,
+  67: 67,
+  68: 68,
+  69: 69,
+  70: 70,
+  71: 71,
+  72: 72,
+  73: 73,
+  74: 74,
+  75: 75,
+  76: 76,
+  77: 77,
+  78: 78,
+  79: 79,
+  80: 80,
+  81: 81,
+  82: 82,
+  83: 83,
+  84: 84,
+  85: 85,
+  86: 86,
+  87: 87,
+  88: 88,
+  89: 89,
+  90: 90,
+  91: 91,
+  92: 92,
+  93: 93,
+  94: 94,
+  95: 95,
+  96: 96,
+  97: 97,
+  98: 98,
+  99: 99,
+  100: 100,
+  101: 101,
+  102: 102,
+  103: 103,
+  104: 104,
+  105: 105,
+  106: 106,
+  107: 107,
+  108: 108,
+  109: 109,
+  110: 110,
+  111: 111,
+  112: 112,
+  113: 113,
+  114: 114,
+  115: 115,
+  116: 116,
+  117: 117,
+  118: 118,
+  119: 119,
+  120: 120,
+  121: 121,
+  122: 122,
+  123: 123,
+  124: 124,
+  125: 125,
+  126: 126,
+  127: 127,
+  1027: 129,
+  8225: 135,
+  1046: 198,
+  8222: 132,
+  1047: 199,
+  1168: 165,
+  1048: 200,
+  1113: 154,
+  1049: 201,
+  1045: 197,
+  1050: 202,
+  1028: 170,
+  160: 160,
+  1040: 192,
+  1051: 203,
+  164: 164,
+  166: 166,
+  167: 167,
+  169: 169,
+  171: 171,
+  172: 172,
+  173: 173,
+  174: 174,
+  1053: 205,
+  176: 176,
+  177: 177,
+  1114: 156,
+  181: 181,
+  182: 182,
+  183: 183,
+  8221: 148,
+  187: 187,
+  1029: 189,
+  1056: 208,
+  1057: 209,
+  1058: 210,
+  8364: 136,
+  1112: 188,
+  1115: 158,
+  1059: 211,
+  1060: 212,
+  1030: 178,
+  1061: 213,
+  1062: 214,
+  1063: 215,
+  1116: 157,
+  1064: 216,
+  1065: 217,
+  1031: 175,
+  1066: 218,
+  1067: 219,
+  1068: 220,
+  1069: 221,
+  1070: 222,
+  1032: 163,
+  8226: 149,
+  1071: 223,
+  1072: 224,
+  8482: 153,
+  1073: 225,
+  8240: 137,
+  1118: 162,
+  1074: 226,
+  1110: 179,
+  8230: 133,
+  1075: 227,
+  1033: 138,
+  1076: 228,
+  1077: 229,
+  8211: 150,
+  1078: 230,
+  1119: 159,
+  1079: 231,
+  1042: 194,
+  1080: 232,
+  1034: 140,
+  1025: 168,
+  1081: 233,
+  1082: 234,
+  8212: 151,
+  1083: 235,
+  1169: 180,
+  1084: 236,
+  1052: 204,
+  1085: 237,
+  1035: 142,
+  1086: 238,
+  1087: 239,
+  1088: 240,
+  1089: 241,
+  1090: 242,
+  1036: 141,
+  1041: 193,
+  1091: 243,
+  1092: 244,
+  8224: 134,
+  1093: 245,
+  8470: 185,
+  1094: 246,
+  1054: 206,
+  1095: 247,
+  1096: 248,
+  8249: 139,
+  1097: 249,
+  1098: 250,
+  1044: 196,
+  1099: 251,
+  1111: 191,
+  1055: 207,
+  1100: 252,
+  1038: 161,
+  8220: 147,
+  1101: 253,
+  8250: 155,
+  1102: 254,
+  8216: 145,
+  1103: 255,
+  1043: 195,
+  1105: 184,
+  1039: 143,
+  1026: 128,
+  1106: 144,
+  8218: 130,
+  1107: 131,
+  8217: 146,
+  1108: 186,
+  1109: 190,
+};
+
+export function unicodeToWin1251(s: string) {
+  const L = [];
+  for (let i = 0; i < s.length; i++) {
+    const ord = s.charCodeAt(i);
+    if (!(ord in DMap))
+      throw new Error(`Character ${s.charAt(i)} isn't supported by win1251!`);
+    L.push(String.fromCharCode(DMap[ord]));
+  }
+  return L.join('');
+}

package/src/errors.ts

@@ -0,0 +1,40 @@
+import { typeGuard } from './type-guard/index.js';
+import type { Maybe } from './utils/types.js';
+
+type GetErrorTextEnhancer = (error: any) => string;
+type GetErrorTextFormatErrorFn = (error: Error) => string;
+
+/**
+ * Universal function for transforming any errors into readable error text
+ *
+ * This function can be enhanced with custom handlers using:
+ * - `getErrorText.unknownErrorText`
+ * - `getErrorText.formatError`
+ * - `getErrorText.enhance`
+ */
+export const getErrorText = (error: unknown) => {
+  if (!error) {
+    return getErrorText.unknownErrorText;
+  }
+
+  if (typeGuard.isString(error)) {
+    return error || getErrorText.unknownErrorText;
+  }
+
+  if (error instanceof Error) {
+    return (
+      (getErrorText.formatError?.(error) ?? error.message) ||
+      getErrorText.unknownErrorText
+    );
+  }
+
+  if (getErrorText.enhance) {
+    return getErrorText.enhance(error) ?? getErrorText.unknownErrorText;
+  } else {
+    return getErrorText.unknownErrorText;
+  }
+};
+
+getErrorText.unknownErrorText = '';
+getErrorText.formatError = null as Maybe<GetErrorTextFormatErrorFn>;
+getErrorText.enhance = null as Maybe<GetErrorTextEnhancer>;

package/src/file.ts

@@ -0,0 +1,25 @@
+export const getBase64FromFile = (file: File) => {
+  return new Promise<string>((resolve, reject) => {
+    const reader = new FileReader();
+    reader.readAsDataURL(file);
+    reader.onload = () => {
+      resolve(reader.result!.toString());
+    };
+    reader.onerror = (error) => {
+      reject(error);
+    };
+  });
+};
+
+export const getTextFromFile = (file: File, encoding?: string) => {
+  return new Promise<string>((resolve, reject) => {
+    const reader = new FileReader();
+    reader.readAsText(file, encoding);
+    reader.onload = () => {
+      resolve(reader.result!.toString());
+    };
+    reader.onerror = (error) => {
+      reject(error);
+    };
+  });
+};

package/src/format/_exports.ts

@@ -0,0 +1,4 @@
+export * from './constants.js';
+export * from './number.js';
+export * from './percent.js';
+export * from './skip-spaces.js';

package/{dist/format/constants.js → src/format/constants.ts}

@@ -1,3 +1,5 @@
 export const NO_VALUE = '–'; // en-dash
+
 export const HYPHEN = '-';
+
 export const INFINITY = '∞';

package/{dist/format/index.js → src/format/index.ts}

@@ -1,4 +1,5 @@
 // This way is more treeshakable than collecting
 // it into one exportable object export const format
-import * as format from "./_exports.js";
+import * as format from './_exports.js';
+
 export { format };

package/src/format/number.test.ts

@@ -0,0 +1,16 @@
+import { describe, expect, test } from 'vitest';
+
+import { number } from './number';
+
+describe('format.number', () => {
+  test('[BUG] Infinite formatting of the number 23162 with an empty delimiter', () => {
+    expect(number(23_162, { digits: 4, cutZeros: true, delimiter: '' })).toBe(
+      '23162',
+    );
+  });
+  test('Formatting the number 23162', () => {
+    expect(number(23_162, { digits: 4, cutZeros: true, delimiter: '_' })).toBe(
+      '23_162',
+    );
+  });
+});