yummies 5.4.6 → 5.4.7

package/src/encodings.ts

@@ -1,270 +0,0 @@
-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

@@ -1,40 +0,0 @@
-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

@@ -1,25 +0,0 @@
-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/number.test.ts

@@ -1,16 +0,0 @@
-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',
-    );
-  });
-});

package/src/format/number.ts

@@ -1,96 +0,0 @@
-import { number as toNumber } from '../parser/number.js';
-import { typeGuard } from '../type-guard/index.js';
-import type { Maybe } from '../utils/types.js';
-
-import { NO_VALUE } from './constants.js';
-
-export interface NumberFormatSettings {
-  delimiter?: string;
-  /**
-   * digitsOnlyForFloat - Show digits after decimal point only if they are not zeros after converting to number.
-   * Example: "0.00" -> "0", "0.10" -> "0.1", but "0.003" -> "0.003"
-   *
-   * @default true
-   */
-  digitsOnlyForFloat?: boolean;
-  /**
-   * Text which will be returned if the value is undefined, null, NaN, Infinity or empty string.
-   * Example: "–" will be returned if the value is undefined and emptyText is "–".
-   */
-  emptyText?: string;
-  /**
-   * Text to append to the end of the formatted number.
-   * Example: if value is 1000 and postfix is "₽", result will be "1 000₽".
-   */
-  postfix?: string;
-  /**
-   * Fixed number of digits after the decimal point (number.toFixed() method)
-   * If set to false, the truncation is ignored!
-   */
-  digits?: number | false;
-  /**
-   * Remove trailing zeros from the end of the number
-   * Example: 0.010000000000000000000000000000000000000000000 -> 0.01
-   */
-  cutZeros?: boolean;
-}
-
-export const number = (
-  rawValue: Maybe<string | number>,
-  userSettings?: Maybe<NumberFormatSettings>,
-): string => {
-  const settings = {
-    ...number.defaultSettings,
-    ...userSettings,
-  };
-
-  const digits = settings.digits ?? 0;
-  const cutZeros = settings?.cutZeros ?? false;
-  const delimiter = settings.delimiter ?? ' ';
-  const postfix = settings.postfix ?? '';
-  const emptyText = settings.emptyText ?? NO_VALUE;
-  const digitsOnlyForFloat = settings.digitsOnlyForFloat ?? true;
-
-  let value: Maybe<number>;
-
-  if (typeGuard.isString(rawValue)) {
-    value = toNumber(value, { fallback: undefined });
-  } else {
-    value = rawValue;
-  }
-
-  if (typeGuard.isNumber(value)) {
-    let raw: string = `${value}`;
-
-    if (digits !== false) {
-      raw = value.toFixed(digits);
-    }
-    if (cutZeros) {
-      raw = `${+raw}`;
-    }
-
-    const [integerPart, decimalPart] = raw.split('.', 2);
-
-    let formattedIntegerPart = integerPart;
-    let formattedDecimalPart = '';
-
-    if (decimalPart && (!digitsOnlyForFloat || !/^0+$/.test(decimalPart))) {
-      formattedDecimalPart = `.${decimalPart}`;
-    }
-
-    const rgx = /(\d+)(\d{3})/;
-
-    while (rgx.test(formattedIntegerPart) && delimiter) {
-      formattedIntegerPart = formattedIntegerPart.replace(
-        rgx,
-        `$1${delimiter}$2`,
-      );
-    }
-
-    return formattedIntegerPart + formattedDecimalPart + postfix;
-  }
-
-  return emptyText;
-};
-
-number.defaultSettings = {} as NumberFormatSettings;

package/src/format/percent.ts

@@ -1,40 +0,0 @@
-import { type NumberParserSettings, number } from '../parser/number.js';
-import { typeGuard } from '../type-guard/index.js';
-import type { Maybe } from '../utils/types.js';
-
-import { NO_VALUE } from './constants.js';
-
-export interface PercentFormatSettings
-  extends Omit<NumberParserSettings, 'fallback'> {
-  divider?: string;
-  delimiter?: string;
-  symbol?: string;
-  emptyText?: string;
-}
-
-/**
- * 100 -> 100%
- * 99.123214412 -> 99.12%
- * 99.123214412 -> 99,12%
- */
-export const percent = (
-  value: Maybe<number | string>,
-  settings?: PercentFormatSettings,
-) => {
-  const numericValue = number(value, {
-    ...settings,
-    digits: settings?.digits ?? 2,
-    fallback: Number.NaN,
-  });
-
-  if (typeGuard.isNumber(numericValue)) {
-    const divider = settings?.divider ?? '.';
-
-    const formattedPercent =
-      divider === '.' ? numericValue : `${numericValue}`.replace('.', divider);
-
-    return `${formattedPercent}${settings?.delimiter ?? ''}${settings?.symbol ?? '%'}`;
-  } else {
-    return settings?.emptyText ?? NO_VALUE;
-  }
-};

package/src/format/skip-spaces.ts

@@ -1,4 +0,0 @@
-/**
- * Removes all spaces in string
- */
-export const skipSpaces = (value: string) => value.replaceAll(/\s/g, '');