@rogolev/value 0.0.1

package/index.mjs

@@ -0,0 +1,37 @@
+export { default as is_array } from './src/helpers/is_array.mjs';
+export { default as is_bool } from './src/helpers/is_bool.mjs';
+export { default as is_boolean } from './src/helpers/is_boolean.mjs';
+export { default as is_function } from './src/helpers/is_function.mjs';
+export { default as is_class } from './src/helpers/is_class.mjs';
+export { default as is_float } from './src/helpers/is_float.mjs';
+export { default as is_int } from './src/helpers/is_int.mjs';
+export { default as is_integer } from './src/helpers/is_integer.mjs';
+export { default as is_bigint } from './src/helpers/is_bigint.mjs';
+export { default as is_null } from './src/helpers/is_null.mjs';
+export { default as is_number } from './src/helpers/is_number.mjs';
+export { default as is_numeric } from './src/helpers/is_numeric.mjs';
+export { default as is_object } from './src/helpers/is_object.mjs';
+export { default as is_string } from './src/helpers/is_string.mjs';
+export { default as is_symbol } from './src/helpers/is_symbol.mjs';
+export { default as is_undefined } from './src/helpers/is_undefined.mjs';
+export { default as is_nan } from './src/helpers/is_nan.mjs';
+export { default as is_infinity } from './src/helpers/is_infinity.mjs';
+export { default as gettype } from './src/helpers/gettype.mjs';
+export { default as is_scalar } from './src/helpers/is_scalar.mjs';
+export { default as array } from './src/helpers/array.mjs';
+export { default as is_list } from './src/helpers/is_list.mjs';
+export { default as is_assoc } from './src/helpers/is_assoc.mjs';
+export { default as to_array } from './src/helpers/to_array.mjs';
+export { default as to_bool } from './src/helpers/to_bool.mjs';
+export { default as to_boolean } from './src/helpers/to_boolean.mjs';
+export { default as to_float } from './src/helpers/to_float.mjs';
+export { default as to_int } from './src/helpers/to_int.mjs';
+export { default as to_integer } from './src/helpers/to_integer.mjs';
+export { default as to_string } from './src/helpers/to_string.mjs';
+export { default as to_object } from './src/helpers/to_object.mjs';
+export { default as to_list } from './src/helpers/to_list.mjs';
+export { default as to_assoc } from './src/helpers/to_assoc.mjs';
+export { default as empty } from './src/helpers/empty.mjs';
+export { default as settype } from './src/helpers/settype.mjs';
+export { default as print } from './src/helpers/print.mjs';
+export { default as print_type } from './src/helpers/print_type.mjs';

package/jest.config.mjs

@@ -0,0 +1,31 @@
+/**
+ * Для получения подробного объяснения каждого свойства конфигурации, посетите:
+ * https://jestjs.io/docs/configuration
+ */
+
+/** @type {import('jest').Config} */
+export default {
+    // Автоматически очищать вызовы mock, экземпляры, контексты и результаты перед каждым тестом
+    clearMocks: true,
+
+    // Среда тестирования, которая будет использоваться для тестирования
+    testEnvironment: 'jsdom',
+
+    // Глобальные переменные, которые должны быть доступны во всех тестовых средах
+    globals: {
+        'ts-jest': {
+            tsconfig: 'tsconfig.json',
+        },
+    },
+
+    // Паттерны glob, которые Jest использует для обнаружения тестовых файлов
+    testMatch: ['**/__tests__/**/*.[jt]s?(x)', '**/?(*.)+(spec|test).?(m)[tj]s?(x)'],
+
+    // Карта от регулярных выражений до путей к трансформерам
+    transform: {
+        '\\.m?[jt]sx?$': 'babel-jest',
+    },
+
+    // Указывает, следует ли сообщать о каждом отдельном тесте во время выполнения.
+    verbose: true,
+};

package/package.json

@@ -0,0 +1,47 @@
+{
+    "name": "@rogolev/value",
+    "version": "0.0.1",
+    "description": "Библиотека, переосмысливающая типы данных и работу с ними.",
+    "type": "module",
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/dmitry-rogolev/value.js.git"
+    },
+    "keywords": [
+        "rogolev",
+        "dmitry-rogolev",
+        "dmitryrogolev",
+        "dmitry",
+        "javascript",
+        "variables",
+        "data types",
+        "value",
+        "type"
+    ],
+    "author": {
+        "name": "Дмитрий Роголев",
+        "email": "drogolev@internet.ru",
+        "url": "https://github.com/dmitry-rogolev"
+    },
+    "license": "MIT",
+    "homepage": "https://github.com/dmitry-rogolev/value.js#readme",
+    "main": "index.mjs",
+    "devDependencies": {
+        "@babel/cli": "^7.26.4",
+        "@babel/core": "^7.26.0",
+        "@babel/preset-env": "^7.26.0",
+        "@eslint/js": "^9.18.0",
+        "core-js": "^3.40.0",
+        "eslint": "^9.18.0",
+        "eslint-config-prettier": "^9.1.0",
+        "eslint-plugin-prettier": "^5.2.1",
+        "jest": "^29.7.0",
+        "jest-environment-jsdom": "^29.7.0",
+        "prettier": "3.4.2"
+    },
+    "scripts": {
+        "prettier": "prettier . --write",
+        "eslint": "eslint",
+        "test": "jest"
+    }
+}

package/prettier.config.mjs

@@ -0,0 +1,224 @@
+/**
+ * @see https://prettier.io/docs/en/configuration.html
+ * @type {import("prettier").Config}
+ */
+export default {
+    /**
+     * Добавлять точку с запятой в конце операторов.
+     * @default true
+     *
+     * Допустимые варианты:
+     *
+     * - `true` - Добавлять точку с запятой в конце каждого оператора.
+     * - `false` - Добавлять точки с запятой только в начале строк,
+     *   которые могут привести к сбоям ASI.
+     */
+    semi: true,
+
+    /**
+     * Использовать одинарные кавычки вместо двойных.
+     * @default false
+     *
+     * Допустимые варианты:
+     *
+     * - `true` - Использовать одинарные кавычки.
+     * - `false` - Использовать двойные кавычки.
+     */
+    singleQuote: true,
+
+    /**
+     * Использовать одинарные кавычки в JSX.
+     * @default false
+     *
+     * Допустимые варианты:
+     *
+     * - `true` - Использовать одинарные кавычки в JSX.
+     * - `false` - Использовать двойные кавычки в JSX.
+     */
+    jsxSingleQuote: false,
+
+    /**
+     * Добавлять запятые в конце везде, где это возможно.
+     * @default "all"
+     *
+     * Допустимые варианты:
+     *
+     * - `none` - Без запятых в конце.
+     * - `es5` - Запятые в конце там, где это допустимо в ES5.
+     * - `all` - Запятые в конце везде, где это возможно.
+     */
+    trailingComma: 'all',
+
+    /**
+     * Печатать пробелы между скобками в литералах объектов.
+     * @default true
+     *
+     * Допустимые варианты:
+     *
+     * - `true` - Пример: { foo: bar }
+     * - `false` - Пример: {foo: bar}
+     */
+    bracketSpacing: true,
+
+    /**
+     * Разместить `>` многострочного HTML (HTML, JSX, Vue, Angular) элемента в конце последней строки, а не на отдельной строке.
+     * @default false
+     *
+     * Допустимые варианты:
+     *
+     * - `true` - Пример:
+     *   <div>
+     *     <span>Text</span></div>
+     * - `false` - Пример:
+     *   <div>
+     *     <span>Text</span>
+     *   </div>
+     */
+    bracketSameLine: false,
+
+    /**
+     * Форматировать только сегмент файла.
+     * @default 0
+     */
+    rangeStart: 0,
+
+    /**
+     * Форматировать только сегмент файла.
+     * @default Number.POSITIVE_INFINITY
+     */
+    rangeEnd: Number.POSITIVE_INFINITY,
+
+    /**
+     * Ограничить форматирование только файлами с прологом.
+     * @default false
+     */
+    requirePragma: false,
+
+    /**
+     * Вставить пролог в отформатированные файлы.
+     * @default false
+     */
+    insertPragma: false,
+
+    /**
+     * Заворачивать текст в Markdown файлах.
+     * @default "preserve"
+     *
+     * Допустимые варианты:
+     *
+     * - `always` - Оборачивать текст, если он превышает ширину печати.
+     * - `never` - Разворачивать каждый блок текста в одну строку.
+     * - `preserve` - Ничего не делать, оставлять текст как есть.
+     */
+    proseWrap: 'always',
+
+    /**
+     * Включить скобки вокруг единственного параметра стрелочной функции.
+     * @default "always"
+     *
+     * Допустимые варианты:
+     *
+     * - `avoid` - Исключать скобки, когда это возможно.
+     * - `always` - Всегда включать скобки.
+     */
+    arrowParens: 'always',
+
+    /**
+     * Чувствительность к пробелам в HTML.
+     * @default "css"
+     *
+     * Допустимые варианты:
+     *
+     * - `css` - Учитывать значение по умолчанию свойства CSS display.
+     * - `strict` - Пробелы (или их отсутствие) вокруг всех тегов считаются значимыми.
+     * - `ignore` - Пробелы (или их отсутствие) вокруг всех тегов считаются незначимыми.
+     */
+    htmlWhitespaceSensitivity: 'strict',
+
+    /**
+     * Использовать символы конца строки.
+     * @default "lf"
+     *
+     * Допустимые варианты:
+     *
+     * - `auto` - Сохранять существующие окончания строк.
+     * - `lf` - Только Line Feed (\n).
+     * - `crlf` - Символы Carriage Return + Line Feed (\r\n).
+     * - `cr` - Только символ Carriage Return (\r).
+     */
+    endOfLine: 'crlf',
+
+    /**
+     * Изменить, когда свойства в объектах заключаются в кавычки.
+     * @default "as-needed"
+     *
+     * Допустимые варианты:
+     *
+     * - `as-needed` - Добавлять кавычки вокруг свойств объектов только там, где это необходимо.
+     * - `consistent` - Если хотя бы одно свойство в объекте требует кавычек, заключать в кавычки все свойства.
+     * - `preserve` - Сохранять использование кавычек в свойствах объектов, как в исходном коде.
+     */
+    quoteProps: 'as-needed',
+
+    /**
+     * Отступы для тегов script и style в файлах Vue.
+     * @default false
+     *
+     * Допустимые варианты:
+     *
+     * - `true` - Делать отступы для тегов script и style в файлах Vue.
+     * - `false` - Не делать отступы для тегов script и style в файлах Vue.
+     */
+    vueIndentScriptAndStyle: true,
+
+    /**
+     * Форматирование встроенного языка.
+     * @default "auto"
+     *
+     * Допустимые варианты:
+     *
+     * - `auto` - Форматировать встроенный код, если Prettier может автоматически его определить.
+     * - `off` - Никогда не форматировать встроенный код автоматически.
+     */
+    embeddedLanguageFormatting: 'auto',
+
+    /**
+     * Один атрибут на строку в HTML, Vue и JSX.
+     * @default false
+     *
+     * Допустимые варианты:
+     *
+     * - `true` - Принуждать использовать один атрибут на строку.
+     * - `false` - Не принуждать использовать один атрибут на строку.
+     */
+    singleAttributePerLine: true,
+
+    /**
+     * Экспериментальные тернарные операторы.
+     * @default false
+     *
+     * Допустимые варианты:
+     *
+     * - `true` - Использовать любопытные тернарные операторы, с вопросительным знаком после условия.
+     * - `false` - Сохранить поведение тернарных операторов по умолчанию.
+     */
+    experimentalTernaries: true,
+
+    /**
+     * Максимальная длина строки.
+     * @default 80
+     */
+    printWidth: 100,
+
+    /**
+     * Ширина табуляции в пробелах.
+     * @default 2
+     */
+    tabWidth: 4,
+
+    /**
+     * Использовать пробелы вместо табуляции.
+     * @default false
+     */
+    useTabs: false,
+};

package/src/helpers/array.mjs

@@ -0,0 +1,107 @@
+import is_array from './is_array.mjs';
+import is_assoc from './is_assoc.mjs';
+
+/**
+ * Создаёт массив из переданных значений, обрабатывая ассоциативные массивы (объекты с ключами).
+ *
+ * ### Параметры
+ *
+ * - `values` {...any}
+ *
+ *      Один или несколько элементов, которые могут быть массивами, объектами или другими значениями.
+ *
+ * ### Описание
+ *
+ * Функция принимает произвольное количество аргументов и возвращает массив, содержащий переданные значения.
+ * Если среди переданных значений есть ассоциативные массивы (объекты, не являющиеся массивами и с ненулевым прототипом),
+ * они преобразуются:
+ *
+ * - Создаётся новый объект без прототипа.
+ * - Добавляются все свойства исходного объекта.
+ * - Добавляется итератор, позволяющий использовать объект в цикле `for-of` для получения пар `[ключ, значение]`.
+ *
+ * Если передано только одно значение, и это массив, функция возвращает его напрямую.
+ *
+ * ### Возвращаемое значение
+ *
+ * Массив, содержащий переданные значения, с преобразованием ассоциативных массивов.
+ * Если передано одно значение и это массив, возвращается он сам.
+ *
+ * ### Примеры использования
+ *
+ * 1. Простые массивы:
+ *
+ *     ```js
+ *     const result = array([1, 2, 3]);
+ *     console.log(result); // [1, 2, 3]
+ *     ```
+ *
+ * 2. Ассоциативные массивы (объекты с ключами и значениями):
+ *
+ *     ```js
+ *     const result = array({ foo: 'bar', baz: 42 });
+ *     for (const [key, value] of result[0]) {
+ *         console.log(key, value);
+ *     }
+ *     // Вывод:
+ *     // foo bar
+ *     // baz 42
+ *     ```
+ *
+ * 3. Смешанные значения:
+ *
+ *     ```js
+ *     const result = array([1, 2, 3], { foo: 'bar' }, 'hello');
+ *     console.log(result);
+ *     // Вывод: [[1, 2, 3], { foo: 'bar' }, 'hello']
+ *     ```
+ *
+ * 4. Объекты, созданные без прототипа:
+ *
+ *     ```js
+ *     const noProtoObject = Object.create(null);
+ *     noProtoObject.foo = 'bar';
+ *     const result = array(noProtoObject);
+ *     for (const [key, value] of result[0]) {
+ *         console.log(key, value);
+ *     }
+ *     // Вывод:
+ *     // foo bar
+ *     ```
+ *
+ * @param {...any} values - Один или несколько элементов, которые могут быть массивами, объектами или другими значениями.
+ * @returns {Array|Object} Массив, содержащий переданные значения, с преобразованием ассоциативных массивов.
+ * Если передано одно значение и это массив, возвращается он сам.
+ */
+export default function array(...values) {
+    const result = [];
+
+    for (const value of values) {
+        if (is_assoc(value)) {
+            const assoc = Object.create(null);
+
+            Object.assign(assoc, value);
+
+            Object.defineProperty(assoc, Symbol.iterator, {
+                enumerable: false,
+                writable: true,
+                configurable: true,
+                *value() {
+                    for (const key in this) {
+                        yield [key, this[key]];
+                    }
+                },
+            });
+
+            result.push(assoc);
+        } else {
+            result.push(value);
+        }
+    }
+
+    if (result.length === 1 && is_array(result[0])) {
+        return result[0];
+    }
+
+    return result;
+}

package/src/helpers/empty.mjs

@@ -0,0 +1,70 @@
+import to_bool from './to_bool.mjs';
+
+/**
+ * Проверяет, является ли переменная пустой.
+ *
+ * ### Описание
+ *
+ * Функция `empty` используется для проверки, является ли переменная пустой. Пустыми считаются значения `null`, `undefined`, пустая строка, `0`, `false`, пустой массив и пустой объект.
+ *
+ * ### Параметры
+ *
+ * - `value` (any)
+ *      Переменная, которую необходимо проверить на пустоту.
+ *
+ * ### Возвращаемое значение
+ *
+ * Возвращает `true`, если переменная пустая, и `false` в противном случае.
+ *
+ * ### Примеры использования
+ *
+ * 1. Проверка пустых значений:
+ *
+ *    ```js
+ *    const result1 = empty(null);
+ *    // Результат: true
+ *
+ *    const result2 = empty(undefined);
+ *    // Результат: true
+ *
+ *    const result3 = empty('');
+ *    // Результат: true
+ *
+ *    const result4 = empty(0);
+ *    // Результат: true
+ *
+ *    const result5 = empty(false);
+ *    // Результат: true
+ *
+ *    const result6 = empty([]);
+ *    // Результат: true
+ *
+ *    const result7 = empty({});
+ *    // Результат: true
+ *    ```
+ *
+ * 2. Проверка непустых значений:
+ *
+ *    ```js
+ *    const result1 = empty('example');
+ *    // Результат: false
+ *
+ *    const result2 = empty(123);
+ *    // Результат: false
+ *
+ *    const result3 = empty(true);
+ *    // Результат: false
+ *
+ *    const result4 = empty([1, 2, 3]);
+ *    // Результат: false
+ *
+ *    const result5 = empty({ key: 'value' });
+ *    // Результат: false
+ *    ```
+ *
+ * @param {any} value Переменная, которую необходимо проверить на пустоту.
+ * @returns {boolean} Возвращает `true`, если переменная пустая, и `false` в противном случае.
+ */
+export default function empty(value) {
+    return !to_bool(value);
+}

package/src/helpers/gettype.mjs

@@ -0,0 +1,133 @@
+import is_array from './is_array.mjs';
+import is_class from './is_class.mjs';
+import is_float from './is_float.mjs';
+import is_infinity from './is_infinity.mjs';
+import is_int from './is_int.mjs';
+import is_nan from './is_nan.mjs';
+import is_null from './is_null.mjs';
+import is_object from './is_object.mjs';
+import is_bigint from './is_bigint.mjs';
+import is_undefined from './is_undefined.mjs';
+import is_bool from './is_bool.mjs';
+import is_string from './is_string.mjs';
+import is_symbol from './is_symbol.mjs';
+import is_function from './is_function.mjs';
+
+/**
+ * Определяет тип переданного значения.
+ *
+ * ### Параметры
+ *
+ * - `value` (any)
+ *      Значение, тип которого необходимо определить.
+ *
+ * ### Описание
+ *
+ * Функция `gettype` определяет тип переданного значения, используя различные проверки.
+ *
+ * Она выполняет следующие проверки:
+ *
+ * 1. **Null**: Проверяет, является ли значение `null`.
+ * 2. **NaN**: Проверяет, является ли значение `NaN`.
+ * 3. **Undefined**: Проверяет, является ли значение `undefined`.
+ * 4. **Infinity**: Проверяет, является ли значение бесконечностью.
+ * 5. **Boolean**: Проверяет, является ли значение логическим.
+ * 6. **Integer**: Проверяет, является ли значение целым числом.
+ * 7. **BigInt**: Проверяет, является ли значение типом BigInt.
+ * 8. **Float**: Проверяет, является ли значение числом с плавающей точкой.
+ * 9. **String**: Проверяет, является ли значение строкой.
+ * 10. **Symbol**: Проверяет, является ли значение символом.
+ * 11. **Class**: Проверяет, является ли значение классом.
+ * 12. **Function**: Проверяет, является ли значение функцией.
+ * 13. **Array**: Проверяет, является ли значение массивом.
+ * 14. **Object**: Проверяет, является ли значение объектом.
+ *
+ * Если значение не соответствует ни одному из этих типов, функция возвращает результат `typeof value`.
+ *
+ * ### Возвращаемое значение
+ *
+ * Возвращает строку, представляющую тип значения.
+ *
+ * ### Примеры использования
+ *
+ * ```js
+ * class MyClass {}
+ *
+ * gettype(null); // "null"
+ * gettype(NaN); // "NaN"
+ * gettype(undefined); // "undefined"
+ * gettype(Infinity); // "infinity"
+ * gettype(true); // "boolean"
+ * gettype(42); // "integer"
+ * gettype(BigInt(123456)); // "bigint"
+ * gettype(3.14); // "float"
+ * gettype('hello'); // "string"
+ * gettype(Symbol('symbol')); // "symbol"
+ * gettype(MyClass); // "class"
+ * gettype(() => {}); // "function"
+ * gettype([]); // "array"
+ * gettype(new MyClass()); // "object"
+ * ```
+ *
+ * @param {any} value Значение, тип которого необходимо определить.
+ * @returns {string} Возвращает строку, представляющую тип значения.
+ */
+export default function gettype(value) {
+    if (is_null(value)) {
+        return 'null';
+    }
+
+    if (is_nan(value)) {
+        return 'NaN';
+    }
+
+    if (is_undefined(value)) {
+        return 'undefined';
+    }
+
+    if (is_infinity(value)) {
+        return 'infinity';
+    }
+
+    if (is_bool(value)) {
+        return 'boolean';
+    }
+
+    if (is_int(value)) {
+        return 'integer';
+    }
+
+    if (is_bigint(value)) {
+        return 'bigint';
+    }
+
+    if (is_float(value)) {
+        return 'float';
+    }
+
+    if (is_string(value)) {
+        return 'string';
+    }
+
+    if (is_symbol(value)) {
+        return 'symbol';
+    }
+
+    if (is_class(value)) {
+        return 'class';
+    }
+
+    if (is_function(value)) {
+        return 'function';
+    }
+
+    if (is_array(value)) {
+        return 'array';
+    }
+
+    if (is_object(value)) {
+        return 'object';
+    }
+
+    return typeof value;
+}