@mediacubeco/base 0.0.1

package/dist/utils/index.d.ts

@@ -0,0 +1,587 @@
+/**
+ * @packageDocumentation
+ * @description
+ * Общие утилитарные типы для проектов на TypeScript.
+ * Содержит типы для примитивов (Nullable, NotNullable), структур данных
+ * (BaseRecord, Entry, List), функций (Callback, AsyncCallback) и вспомогательные
+ * утилиты (KeyOf, ValueOf, Decrement, Increment и др.).
+ * Модуль не содержит рантайм-кода — только типы.
+ *
+ * @example
+ * ```typescript
+ * type User = { id: number; name?: string | null }
+ *
+ * type UserId = ValueOf<Pick<User, 'id'>>
+ * type SafeName = NotNullable<User['name']>
+ * ```
+ */
+type NullablePrimitive = undefined | null;
+/**
+ * Ключи объекта `Data`. Удобный псевдоним для `keyof`.
+ *
+ * @example
+ * ```typescript
+ * type UserKeys = KeyOf<{ id: number; name: string }> // 'id' | 'name'
+ * ```
+ */
+type KeyOf<Data> = keyof Data;
+/**
+ * Объединение всех возможных значений объекта `Data`.
+ *
+ * @example
+ * ```typescript
+ * type UserValue = ValueOf<{ id: number; name: string }> // number | string
+ * ```
+ */
+type ValueOf<Data> = Data[KeyOf<Data>];
+/**
+ * Тип, допускающий null или undefined (например для опциональных полей).
+ *
+ * @example
+ * ```typescript
+ * type MaybeName = Nullable<string> // string | null | undefined
+ * ```
+ */
+type Nullable<Data = undefined> = Data | NullablePrimitive;
+/**
+ * Тип, исключающий null и undefined (гарантированно заданное значение).
+ *
+ * @example
+ * ```typescript
+ * type Name = NotNullable<string | null | undefined> // string
+ * ```
+ */
+type NotNullable<Data = undefined> = Exclude<Data, NullablePrimitive>;
+/**
+ * Допустимые ключи объекта (как в Record).
+ *
+ * @example
+ * ```typescript
+ * type Key = BaseKey // string | number | symbol
+ * ```
+ */
+type BaseKey = string | number | symbol;
+/**
+ * Массив элементов (базовый тип для списков).
+ *
+ * @example
+ * ```typescript
+ * type IdList = BaseList<number> // number[]
+ * ```
+ */
+type BaseList<Item = unknown> = Item[];
+/**
+ * Объект с ключами Key и значениями Value (обобщение Record).
+ *
+ * @example
+ * ```typescript
+ * type UserMap = BaseRecord<string, 'name' | 'role'>
+ * ```
+ */
+type BaseRecord<Value = unknown, Key extends BaseKey = BaseKey> = Record<Key, Value>;
+/**
+ * Синхронная функция с заданным списком параметров и результатом.
+ * @template ParamList - кортеж типов аргументов
+ * @template Result - тип возвращаемого значения
+ *
+ * @example
+ * ```typescript
+ * type Sum = Callback<[number, number], number>
+ * ```
+ */
+type Callback<ParamList extends BaseList = BaseList, Result = void> = (...paramList: ParamList) => Result;
+/** Любая синхронная функция без ограничений на аргументы и результат. */
+type AnyCallback = Callback<any[], any>;
+/** Извлекает кортеж аргументов из типа функции. */
+type CallbackParamList<Callback> = Callback extends (...args: infer ParamList) => any ? ParamList : never;
+
+/**
+ * Асинхронная задержка на указанное количество миллисекунд.
+ * Удобна для пауз между ретраями, анимациями или батч-обработкой.
+ *
+ * @param delay - Длительность ожидания в миллисекундах
+ * @returns Promise, который выполнится через указанное время
+ *
+ * @example
+ * ```typescript
+ * await wait(300)
+ * ```
+ */
+declare const wait: (delay: number) => Promise<unknown>;
+/**
+ * Собирает объект из переданного значения и опционального исходного объекта.
+ * Поддерживает три сценария: вернуть объект как есть, слить два объекта или записать примитив по ключу.
+ *
+ * @param value - Объект целиком или значение для поля
+ * @param data - Исходный объект для объединения
+ * @param key - Ключ, в который нужно записать примитивное значение
+ * @returns Новый объект с объединёнными данными
+ *
+ * @example
+ * ```typescript
+ * compose({ name: 'John' }) // { name: 'John' }
+ * compose({ age: 18 }, { name: 'John' }) // { name: 'John', age: 18 }
+ * compose('John', { age: 18 }, 'name') // { age: 18, name: 'John' }
+ * ```
+ */
+declare function compose<Data extends object, Value extends Data>(value: Value): Value;
+declare function compose<Data extends object, Value extends Data>(value: Value, data: Data): Data & Value;
+declare function compose<Data extends object, Key extends KeyOf<Data>, Value extends Data[Key] | Data>(value: Value, data: Nullable<Partial<Data>>, key: Nullable<Key>): Data;
+/**
+ * Возвращает значение объекта по ключу.
+ * Если ключ отсутствует или равен null/undefined, может вернуть значение по умолчанию.
+ *
+ * @param key - Ключ поля
+ * @param data - Объект-источник
+ * @param defaultValue - Резервное значение, если ключ не задан или значение отсутствует
+ * @returns Значение по ключу или defaultValue
+ *
+ * @example
+ * ```typescript
+ * getValueByKey('name', { name: 'John' }) // 'John'
+ * getValueByKey('age', { name: 'John' }, 18) // 18
+ * ```
+ */
+declare function getValueByKey<Value, Key extends BaseKey>(key: Key, data: BaseRecord<Value, Key>): Value;
+declare function getValueByKey<Value, Key extends BaseKey, DefaultValue>(key: Nullable<Key>, data: Partial<BaseRecord<Value, Key>>, defaultValue: DefaultValue): Value | DefaultValue;
+/**
+ * Преобразует значения объекта, сохраняя его исходные ключи.
+ *
+ * @param data - Объект, который нужно обойти
+ * @param callback - Функция преобразования значения
+ * @returns Новый объект с теми же ключами и результатами callback
+ *
+ * @example
+ * ```typescript
+ * mapRecord({ a: 1, b: 2 }, (_, value) => value * 2) // { a: 2, b: 4 }
+ * ```
+ */
+declare const mapRecord: <ResultValue, Data extends object, Key extends KeyOf<Data>, Value extends ValueOf<Data>, Result = BaseRecord<ResultValue, Key>>(data: Data, callback: (key: Key, value: Value, index: number, list: [Key, Value][]) => ResultValue) => Result;
+/**
+ * Безопасно вызывает callback, если передано действительно вызываемое значение.
+ *
+ * @param callback - Функция для вызова
+ * @param paramList - Аргументы, которые будут переданы в callback
+ * @returns Результат callback или undefined, если callback не является функцией
+ *
+ * @example
+ * ```typescript
+ * runCallback((name: string) => `Hello, ${name}`, 'John') // 'Hello, John'
+ * runCallback(undefined, 'John') // undefined
+ * ```
+ */
+declare const runCallback: <Callback, Result = Callback extends AnyCallback ? ReturnType<Callback> : void>(callback: Callback, ...paramList: CallbackParamList<Callback>) => Result;
+
+/**
+ * Создаёт функцию с отложенным вызовом callback.
+ * Повторный вызов до истечения delay сбрасывает предыдущий таймер.
+ *
+ * @param callback - Функция, которую нужно вызывать с задержкой
+ * @param delay - Задержка в миллисекундах
+ * @returns Обёртка с debounce-поведением
+ *
+ * @example
+ * ```typescript
+ * const save = debounce(() => api.save(), 300)
+ * input.addEventListener('input', save)
+ * ```
+ */
+declare const debounce: <Callback>(callback: Callback, delay: number) => (...params: CallbackParamList<Callback>) => void;
+/**
+ * Создаёт функцию, которая допускает не более одного вызова за период delay.
+ *
+ * @param callback - Функция, которую нужно ограничить по частоте вызовов
+ * @param delay - Интервал блокировки в миллисекундах
+ * @returns Обёртка с throttle-поведением
+ *
+ * @example
+ * ```typescript
+ * const onScroll = throttle(() => console.log('scroll'), 100)
+ * window.addEventListener('scroll', onScroll)
+ * ```
+ */
+declare const throttle: <Callback>(callback: Callback, delay: number) => (...params: CallbackParamList<Callback>) => void;
+
+/**
+ * Фильтрует список объектов по булевому полю.
+ * Если у элемента нет указанного ключа, такой элемент сохраняется.
+ *
+ * @param list - Исходный список объектов
+ * @param key - Булево поле для фильтрации, по умолчанию `isVisible`
+ * @returns Новый список, содержащий только подходящие элементы
+ *
+ * @example
+ * ```typescript
+ * filterByKey([{ isVisible: true }, { isVisible: false }]) // [{ isVisible: true }]
+ * ```
+ */
+declare function filterByKey<Key extends KeyOf<Item>, Item extends object & BaseRecord<boolean, Key>>(list: Item[], key?: Key): Item[];
+/**
+ * Удаляет дубликаты из списка объектов по значению указанного ключа.
+ *
+ * @param data - Список объектов
+ * @param key - Ключ, по которому определяется уникальность
+ * @returns Новый список без повторяющихся значений key
+ *
+ * @example
+ * ```typescript
+ * filterDuplicateByKey([{ id: 1 }, { id: 1 }, { id: 2 }], 'id') // [{ id: 1 }, { id: 2 }]
+ * ```
+ */
+declare function filterDuplicateByKey<Key extends BaseKey, Item extends object & BaseRecord<any, Key>>(data: Item[], key: Key): Item[];
+/**
+ * Возвращает элементы первого списка, которые присутствуют во втором.
+ *
+ * @param inputList - Список для проверки
+ * @param list - Список значений, с которыми нужно сравнить
+ * @returns Пересечение двух списков
+ *
+ * @example
+ * ```typescript
+ * filterEqualValues([1, 2, 3], [2, 4]) // [2]
+ * ```
+ */
+declare function filterEqualValues<Item>(inputList: Item[], list: Item[]): Item[];
+/**
+ * Удаляет из списка `null` и `undefined`, одновременно сужая тип результата.
+ *
+ * @param list - Исходный список
+ * @returns Список только с непустыми значениями
+ *
+ * @example
+ * ```typescript
+ * filterNullableValues([1, null, 2, undefined]) // [1, 2]
+ * ```
+ */
+declare function filterNullableValues<Item>(list: Item[]): NotNullable<Item>[];
+
+/**
+ * Проверяет, что объект не содержит перечисляемых свойств.
+ *
+ * @param object - Объект для проверки
+ * @returns `true`, если объект пустой
+ *
+ * @example
+ * ```typescript
+ * isObjectEmpty({}) // true
+ * isObjectEmpty({ id: 1 }) // false
+ * ```
+ */
+declare function isObjectEmpty<Param extends object>(object: Param): boolean;
+/**
+ * Проверяет, что массив не содержит элементов.
+ *
+ * @param array - Массив для проверки
+ * @returns `true`, если массив пустой
+ *
+ * @example
+ * ```typescript
+ * isArrayEmpty([]) // true
+ * isArrayEmpty([1]) // false
+ * ```
+ */
+declare function isArrayEmpty<Param extends BaseList>(array: Param): boolean;
+/**
+ * Проверяет наличие ключа в объекте и сужает тип data при успешной проверке.
+ *
+ * @param key - Ключ, наличие которого нужно проверить
+ * @param data - Значение, которое предполагается объектом
+ * @returns `true`, если ключ существует в объекте
+ *
+ * @example
+ * ```typescript
+ * if (hasKey('name', payload)) {
+ *   console.log(payload.name)
+ * }
+ * ```
+ */
+declare function hasKey<Key extends BaseKey, Data, Value>(key: Key, data: Data): data is Data & BaseRecord<Value, Key>;
+/**
+ * Проверяет, есть ли у двух списков хотя бы одно общее значение.
+ *
+ * @param inputList - Первый список
+ * @param list - Второй список
+ * @returns `true`, если найдено хотя бы одно совпадение
+ *
+ * @example
+ * ```typescript
+ * hasEqualValues(['a', 'b'], ['c', 'b']) // true
+ * hasEqualValues(['a'], ['c']) // false
+ * ```
+ */
+declare function hasEqualValues<Item>(inputList: Item[], list: Item[]): boolean;
+
+/**
+ * Приводит значение к массиву: если передано одно значение — возвращает массив из одного элемента,
+ * если передан массив — возвращает его без изменений.
+ * Удобно для API, которые могут принимать как один элемент, так и массив.
+ *
+ * @param param - Один элемент или массив элементов
+ * @returns Массив элементов (всегда массив)
+ *
+ * @example
+ * ```typescript
+ * forceList(1)        // [1]
+ * forceList([1, 2])   // [1, 2]
+ * ```
+ *
+ * @example
+ * ```typescript
+ * const ids = forceList(query.id)  // query.id: string | string[]
+ * ids.forEach(processId)
+ * ```
+ */
+declare function forceList<Item>(param: Item | Item[]): Item[];
+/**
+ * Разбивает массив на подмассивы заданного размера (чанки).
+ * Последний чанк может быть меньше size, если длина массива не кратна size.
+ *
+ * @param list - Исходный массив
+ * @param size - Размер одного чанка (целое положительное число)
+ * @returns Массив чанков (массив массивов)
+ *
+ * @example
+ * ```typescript
+ * chunkList([1, 2, 3, 4, 5], 2)  // [[1, 2], [3, 4], [5]]
+ * chunkList([], 3)                // []
+ * ```
+ *
+ * @example
+ * ```typescript
+ * const pages = chunkList(items, PAGE_SIZE)
+ * for (const page of pages) {
+ *   await saveBatch(page)
+ * }
+ * ```
+ */
+declare function chunkList<Item>(list: Item[], size: number): Item[][];
+
+/**
+ * Проверяет, что значение равно `undefined`.
+ *
+ * @example
+ * ```typescript
+ * isUndefined(undefined) // true
+ * isUndefined(null) // false
+ * ```
+ */
+declare const isUndefined: (param: unknown) => param is undefined;
+/**
+ * Проверяет, что значение равно `null`.
+ *
+ * @example
+ * ```typescript
+ * isNull(null) // true
+ * isNull(undefined) // false
+ * ```
+ */
+declare const isNull: (param: unknown) => param is null;
+/**
+ * Проверяет, что значение равно `null` или `undefined`.
+ *
+ * @example
+ * ```typescript
+ * isNullable(undefined) // true
+ * isNullable('value') // false
+ * ```
+ */
+declare const isNullable: (param: unknown) => param is Nullable;
+/**
+ * Проверяет, что значение имеет тип `string`.
+ *
+ * @example
+ * ```typescript
+ * isString('hello') // true
+ * isString(42) // false
+ * ```
+ */
+declare const isString: (param: unknown) => param is string;
+/**
+ * Проверяет, что значение имеет тип `number`.
+ *
+ * @example
+ * ```typescript
+ * isNumber(42) // true
+ * isNumber('42') // false
+ * ```
+ */
+declare const isNumber: (param: unknown) => param is number;
+/**
+ * Проверяет, что значение имеет тип `bigint`.
+ *
+ * @example
+ * ```typescript
+ * isBigint(10n) // true
+ * isBigint(10) // false
+ * ```
+ */
+declare const isBigint: (param: unknown) => param is bigint;
+/**
+ * Проверяет, что значение является `NaN`.
+ *
+ * @example
+ * ```typescript
+ * isNaN(Number('foo')) // true
+ * isNaN(10) // false
+ * ```
+ */
+declare const isNaN: (param: unknown) => param is number;
+/**
+ * Проверяет, что значение имеет тип `boolean`.
+ *
+ * @example
+ * ```typescript
+ * isBoolean(true) // true
+ * isBoolean(0) // false
+ * ```
+ */
+declare const isBoolean: (param: unknown) => param is boolean;
+/**
+ * Проверяет, что значение имеет тип `symbol`.
+ *
+ * @example
+ * ```typescript
+ * isSymbol(Symbol('id')) // true
+ * isSymbol('id') // false
+ * ```
+ */
+declare const isSymbol: (param: unknown) => param is symbol;
+/**
+ * Проверяет, что значение относится к объектным типам JavaScript.
+ *
+ * @example
+ * ```typescript
+ * isAnyObject({}) // true
+ * isAnyObject(null) // true
+ * ```
+ */
+declare const isAnyObject: (param: unknown) => param is object;
+/**
+ * Проверяет, что значение является "простым" объектом, а не массивом, датой, ошибкой или другой специальной структурой.
+ *
+ * @param param - Значение для проверки
+ * @returns `true`, если значение можно трактовать как обычный объект
+ *
+ * @example
+ * ```typescript
+ * isObject({ id: 1 }) // true
+ * isObject([1, 2, 3]) // false
+ * ```
+ */
+declare const isObject: <Param = object>(param: unknown) => param is Param;
+/**
+ * Проверяет, что значение является массивом.
+ *
+ * @example
+ * ```typescript
+ * isArray([1, 2]) // true
+ * isArray({ length: 2 }) // false
+ * ```
+ */
+declare const isArray: <Param = unknown>(param: unknown) => param is Param[];
+/**
+ * Проверяет, что значение является `ArrayBuffer`.
+ *
+ * @example
+ * ```typescript
+ * isArrayBuffer(new ArrayBuffer(8)) // true
+ * ```
+ */
+declare const isArrayBuffer: (param: unknown) => param is ArrayBuffer;
+/**
+ * Проверяет, что значение является `Map`.
+ *
+ * @example
+ * ```typescript
+ * isMap(new Map()) // true
+ * ```
+ */
+declare const isMap: (param: unknown) => param is Map<unknown, unknown>;
+/**
+ * Проверяет, что значение является `Set`.
+ *
+ * @example
+ * ```typescript
+ * isSet(new Set()) // true
+ * ```
+ */
+declare const isSet: (param: unknown) => param is Set<unknown>;
+/**
+ * Проверяет, что значение является `WeakMap`.
+ *
+ * @example
+ * ```typescript
+ * isWeakMap(new WeakMap()) // true
+ * ```
+ */
+declare const isWeakMap: (param: unknown) => param is WeakMap<object, unknown>;
+/**
+ * Проверяет, что значение является `WeakSet`.
+ *
+ * @example
+ * ```typescript
+ * isWeakSet(new WeakSet()) // true
+ * ```
+ */
+declare const isWeakSet: (param: unknown) => param is WeakSet<object>;
+/**
+ * Проверяет, что значение является объектом `Date`.
+ *
+ * @example
+ * ```typescript
+ * isDate(new Date()) // true
+ * ```
+ */
+declare const isDate: (param: unknown) => param is Error;
+/**
+ * Проверяет, что значение является экземпляром `Error`.
+ *
+ * @example
+ * ```typescript
+ * isError(new Error('boom')) // true
+ * ```
+ */
+declare const isError: (param: unknown) => param is Error;
+/**
+ * Проверяет, что значение является `Proxy`.
+ *
+ * @example
+ * ```typescript
+ * const value = new Proxy({}, {})
+ * isProxy(value) // true
+ * ```
+ */
+declare const isProxy: (param: unknown) => param is ProxyConstructor;
+/**
+ * Проверяет, что значение является `RegExp`.
+ *
+ * @example
+ * ```typescript
+ * isRegExp(/test/) // true
+ * ```
+ */
+declare const isRegExp: (param: unknown) => param is RegExp;
+/**
+ * Проверяет, что значение является `Promise`.
+ *
+ * @example
+ * ```typescript
+ * isPromise(Promise.resolve()) // true
+ * ```
+ */
+declare const isPromise: (param: unknown) => param is Promise<typeof param>;
+/**
+ * Проверяет, что значение является функцией.
+ *
+ * @param param - Значение для проверки
+ * @returns `true`, если значение можно вызвать как функцию
+ *
+ * @example
+ * ```typescript
+ * isFunction(() => true) // true
+ * isFunction('callback') // false
+ * ```
+ */
+declare const isFunction: <Callback = <ParamList extends BaseList, Result>(...paramList: ParamList) => Result>(param: unknown) => param is Callback;
+
+export { chunkList, compose, debounce, filterByKey, filterDuplicateByKey, filterEqualValues, filterNullableValues, forceList, getValueByKey, hasEqualValues, hasKey, isAnyObject, isArray, isArrayBuffer, isArrayEmpty, isBigint, isBoolean, isDate, isError, isFunction, isMap, isNaN, isNull, isNullable, isNumber, isObject, isObjectEmpty, isPromise, isProxy, isRegExp, isSet, isString, isSymbol, isUndefined, isWeakMap, isWeakSet, mapRecord, runCallback, throttle, wait };

package/dist/utils/index.mjs

@@ -0,0 +1 @@
+const n=n=>void 0===n,t=n=>null===n,e=e=>n(e)||t(e),r=n=>"string"==typeof n,o=n=>"number"==typeof n,i=n=>"bigint"==typeof n,u=n=>Number.isNaN(n),c=n=>"boolean"==typeof n,f=n=>"symbol"==typeof n,s=n=>"object"==typeof n,a=n=>{const t=[l,m,p,y,b,g,h,j,d,x,A].some(t=>t(n));return!!n&&"object"==typeof n&&!t},l=n=>Array.isArray(n),m=n=>n instanceof ArrayBuffer,p=n=>n instanceof Map,y=n=>n instanceof Set,b=n=>n instanceof Map,g=n=>n instanceof Set,h=n=>n instanceof Date,j=n=>n instanceof Error,T=n=>n instanceof Proxy,d=n=>n instanceof RegExp,x=n=>n instanceof Promise,A=n=>n instanceof Function,E=n=>new Promise(t=>setTimeout(t,n));function N(n,t,r){const o=!a(n);return!e(r)&&{...t,...o?{[r]:n}:n}||!e(t)&&{...t,...n}||{...n}}function P(n,t,r){return e(n)?r:2===arguments.length?t[n]:t[n]??r}const M=(n,t)=>{const e=Object.entries(n);return Object.fromEntries(e.map(([n,e],r,o)=>[n,t(n,e,r,o)]))},O=(n,...t)=>{if(A(n))return n(...t)},S=(n,t)=>{let e;return(...r)=>{e&&clearTimeout(e),e=setTimeout(()=>O(n,...r),t)}},v=(n,t)=>{let e=!0;return(...r)=>{e&&(O(n,...r),e=!1),setTimeout(()=>e=!0,t)}};function w(n){for(const t in n)return!1;return!0}function B(n){return 0===n.length}function D(n,t){return!(!s(t)||!(n in t))}function F(n,t){return!!k(n,t).length}function R(n,t="isVisible"){return n.filter(n=>!D(t,n)||n[t])}function V(n,t){return n.reduce((n,e)=>n.some(n=>n[t]===e[t])?n:[...n,e],[])}function k(n,t){return n.filter(n=>t.includes(n))}function q(n){return n.filter(n=>!e(n))}function z(n){return l(n)?n:[n]}function C(n,t){const e=[];for(let r=0;r<n.length;r+=t)e.push(n.slice(r,r+t));return e}export{C as chunkList,N as compose,S as debounce,R as filterByKey,V as filterDuplicateByKey,k as filterEqualValues,q as filterNullableValues,z as forceList,P as getValueByKey,F as hasEqualValues,D as hasKey,s as isAnyObject,l as isArray,m as isArrayBuffer,B as isArrayEmpty,i as isBigint,c as isBoolean,h as isDate,j as isError,A as isFunction,p as isMap,u as isNaN,t as isNull,e as isNullable,o as isNumber,a as isObject,w as isObjectEmpty,x as isPromise,T as isProxy,d as isRegExp,y as isSet,r as isString,f as isSymbol,n as isUndefined,b as isWeakMap,g as isWeakSet,M as mapRecord,O as runCallback,v as throttle,E as wait};

package/package.json

@@ -0,0 +1,51 @@
+{
+  "private": false,
+  "version": "0.0.1",
+  "name": "@mediacubeco/base",
+  "description": "Base by Mediacube developers",
+  "license": "MIT",
+  "type": "module",
+  "files": [
+    "dist"
+  ],
+  "keywords": [
+    "mediacube",
+    "mediacubeco",
+    "base"
+  ],
+  "devDependencies": {
+    "eslint": "^9.39.1",
+    "prettier": "^3.8.1",
+    "typescript": "^5.9.3",
+    "@mediacubeco/prettier-config": "0.0.1",
+    "@mediacubeco/eslint-config": "0.0.1",
+    "@mediacubeco/typescript-config": "0.0.1"
+  },
+  "exports": {
+    ".": {
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.cjs",
+      "types": "./dist/index.d.ts"
+    },
+    "./helpers": {
+      "require": "./dist/helpers/index.cjs",
+      "import": "./dist/helpers/index.mjs",
+      "types": "./dist/helpers/index.d.ts"
+    },
+    "./services": {
+      "import": "./dist/services/index.mjs",
+      "require": "./dist/services/index.cjs",
+      "types": "./dist/services/index.d.ts"
+    },
+    "./types": {
+      "import": "./dist/types/index.mjs",
+      "require": "./dist/types/index.cjs",
+      "types": "./dist/types/index.d.ts"
+    },
+    "./utils": {
+      "import": "./dist/utils/index.mjs",
+      "require": "./dist/utils/index.cjs",
+      "types": "./dist/utils/index.d.ts"
+    }
+  }
+}