@glissandoo/lib 1.17.4 → 1.17.6

package/helpers/audios.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.audioExtensionToMimeType = exports.audioMimeTypes = exports.audioExtensions = void 0;
 const lodash_1 = require("lodash");
-const ts_extras_1 = require("ts-extras");
+const ts_extras_1 = require("./ts-extras");
 const extensionToMimetype = {
     '.abs': 'audio/x-mpeg',
     '.aif': 'audio/x-aiff',
@@ -28,7 +28,7 @@ const extensionToMimetype = {
     '.ulw': 'audio/basic',
     '.wav': 'audio/x-wav',
 };
-exports.audioExtensions = ts_extras_1.objectKeys(extensionToMimetype);
-exports.audioMimeTypes = lodash_1.uniq(Object.values(extensionToMimetype));
+exports.audioExtensions = (0, ts_extras_1.objectKeys)(extensionToMimetype);
+exports.audioMimeTypes = (0, lodash_1.uniq)(Object.values(extensionToMimetype));
 const audioExtensionToMimeType = (ext) => extensionToMimetype[ext];
 exports.audioExtensionToMimeType = audioExtensionToMimeType;

package/helpers/auth.d.ts

@@ -17,10 +17,10 @@ export declare enum AuthErrors {
     NoPartnerhispAdmin = "error.auth.noPartnershipAdmin",
     Unauthenticated = "error.auth.unauthenticated"
 }
-export interface AuthURLParams {
+export type AuthURLParams = {
     error?: string;
     return_to?: string;
     callbackFbName?: FbFunctionName;
     callbackFbParam?: string;
-}
-export declare const getAuthURL: (path: string, lang: LanguagesTypes, params?: AuthURLParams | undefined) => string;
+};
+export declare const getAuthURL: (path: string, lang: LanguagesTypes, params?: AuthURLParams) => string;

package/helpers/badges.d.ts

@@ -18,4 +18,4 @@ export declare const getLevelsDataBadge: (field: BadgesTypes) => {
     [level: number]: BadgeDataLevel;
 };
 export declare const getLevelsCountBadge: (field: BadgesTypes) => number[];
-export declare const getImageLevelBadge: (field: BadgesTypes, level: number, disabled?: boolean | undefined) => string;
+export declare const getImageLevelBadge: (field: BadgesTypes, level: number, disabled?: boolean) => string;

package/helpers/badges.js

@@ -147,12 +147,12 @@ const getLevelsDataBadge = (field) => {
 };
 exports.getLevelsDataBadge = getLevelsDataBadge;
 const getLevelsCountBadge = (field) => {
-    const data = exports.getLevelsDataBadge(field);
+    const data = (0, exports.getLevelsDataBadge)(field);
     return Object.values(data).map((item) => item.count);
 };
 exports.getLevelsCountBadge = getLevelsCountBadge;
 const getImageLevelBadge = (field, level, disabled) => {
-    const imagePath = get_1.default(exports.badgesLevels, [
+    const imagePath = (0, get_1.default)(exports.badgesLevels, [
         field,
         level,
         disabled ? 'imagePathDisabled' : 'imagePath',

package/helpers/fileSections/orders.js

@@ -14,7 +14,7 @@ const getOrderByMusicStyle = (musicStyle) => {
 };
 exports.getOrderByMusicStyle = getOrderByMusicStyle;
 const orderByMusicStyle = (list, field, musicStyle) => {
-    const order = exports.getOrderByMusicStyle(musicStyle);
-    return utils_1.orderByMatch(list, field, order);
+    const order = (0, exports.getOrderByMusicStyle)(musicStyle);
+    return (0, utils_1.orderByMatch)(list, field, order);
 };
 exports.orderByMusicStyle = orderByMusicStyle;

package/helpers/musicStyles/index.d.ts

@@ -13,6 +13,6 @@ export declare enum MusicStyleId {
     Choir = "coro"
 }
 export declare const MusicStylesCover: Record<MusicStyleId, string>;
-export declare type MusicStyleType = MusicStyleId | string;
+export type MusicStyleType = MusicStyleId | string;
 export declare const musicStyleByCountry: Record<LanguagesTypes, MusicStyleId[]>;
 export declare const list: (lang: LanguagesTypes, filteredByCountry?: boolean) => MusicStyle[];

package/helpers/musicStyles/orders.js

@@ -187,7 +187,7 @@ const getInstrumentsOrderByMusicStyle = (musicStyle) => {
 };
 exports.getInstrumentsOrderByMusicStyle = getInstrumentsOrderByMusicStyle;
 const orderByMusicStyle = (list, field, musicStyle) => {
-    const order = exports.getInstrumentsOrderByMusicStyle(musicStyle);
-    return utils_1.orderByMatch(list, field, order);
+    const order = (0, exports.getInstrumentsOrderByMusicStyle)(musicStyle);
+    return (0, utils_1.orderByMatch)(list, field, order);
 };
 exports.orderByMusicStyle = orderByMusicStyle;

package/helpers/notifications.d.ts

@@ -27,9 +27,9 @@ export declare enum NotificationEventActions {
     ReminderMorningPending = "reminderMorningPending",
     ReminderRollcall = "reminderRollcall"
 }
-declare type RealtionScopeToNotification = Record<EventoFbFunctionsTypes.EditScope, NotificationEventActions>;
+type RealtionScopeToNotification = Record<EventoFbFunctionsTypes.EditScope, NotificationEventActions>;
 export declare const editScopeToAction: RealtionScopeToNotification;
-declare type RelationActionNotification = Record<NotificationEventActions, NotificationActions>;
+type RelationActionNotification = Record<NotificationEventActions, NotificationActions>;
 export declare const notificationPerformance: RelationActionNotification;
 export declare const notificationSinglePractice: RelationActionNotification;
 export declare const notificationMultiplePractice: RelationActionNotification;

package/helpers/objects.d.ts

@@ -1,6 +1,6 @@
-export declare const toArray: <T>(obj: Record<string, T>) => (T & {
+export declare const mapToArray: <V>(obj: Record<string, V>) => (V & {
     id: string;
 })[];
-export declare const map: <KIn extends string, VIn, KOut extends string, VOut>(obj: Record<KIn, VIn>, fn: (key: `${KIn}`, value: VIn, index?: number | undefined) => [KOut, VOut]) => Record<KOut, VOut>;
-export declare const filter: <K extends string, V>(obj: Record<K, V>, fn: (key: `${Exclude<K, symbol>}`, value: V, index?: number | undefined) => unknown) => Record<`${Exclude<K, symbol>}`, V>;
-export declare const forEach: <K extends string, V>(obj: Record<K, V>, fn: (key: `${Exclude<K, symbol>}`, value: V, index?: number | undefined) => unknown) => void;
+export declare const map: <KIn extends string, VIn, KOut extends string, VOut>(obj: Record<KIn, VIn>, fn: (key: `${KIn}`, value: VIn, index?: number) => [KOut, VOut]) => Record<KOut, VOut>;
+export declare const filter: <K extends string, V>(obj: Record<K, V>, fn: (key: `${Exclude<K, symbol>}`, value: V, index?: number) => unknown) => Record<`${Exclude<K, symbol>}`, V>;
+export declare const forEach: <K extends string, V>(obj: Record<K, V>, fn: (key: `${Exclude<K, symbol>}`, value: V, index?: number) => unknown) => void;

package/helpers/objects.js

@@ -1,28 +1,28 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.forEach = exports.filter = exports.map = exports.toArray = void 0;
-const ts_extras_1 = require("ts-extras");
-const toArray = (obj) => {
-    return ts_extras_1.objectEntries(obj).map(([key, value]) => ({
+exports.forEach = exports.filter = exports.map = exports.mapToArray = void 0;
+const ts_extras_1 = require("./ts-extras");
+const mapToArray = (obj) => {
+    return (0, ts_extras_1.objectEntries)(obj).map(([key, value]) => ({
         ...value,
         id: key,
     }));
 };
-exports.toArray = toArray;
+exports.mapToArray = mapToArray;
 const map = (obj, fn) => {
-    const entries = ts_extras_1.objectEntries(obj);
+    const entries = (0, ts_extras_1.objectEntries)(obj);
     const mappedEntries = entries.map(([key, value], index) => fn(key, value, index));
-    return ts_extras_1.objectFromEntries(mappedEntries);
+    return (0, ts_extras_1.objectFromEntries)(mappedEntries);
 };
 exports.map = map;
 const filter = (obj, fn) => {
-    const entries = ts_extras_1.objectEntries(obj);
+    const entries = (0, ts_extras_1.objectEntries)(obj);
     const filteredEntries = entries.filter(([key, value], index) => fn(key, value, index));
-    return ts_extras_1.objectFromEntries(filteredEntries);
+    return (0, ts_extras_1.objectFromEntries)(filteredEntries);
 };
 exports.filter = filter;
 const forEach = (obj, fn) => {
-    const entries = ts_extras_1.objectEntries(obj);
+    const entries = (0, ts_extras_1.objectEntries)(obj);
     return entries.forEach(([key, value], index) => fn(key, value, index));
 };
 exports.forEach = forEach;

package/helpers/ts-extras/array-includes.d.ts

@@ -0,0 +1,21 @@
+/**
+An alternative to `Array#includes()` that properly acts as a type guard.
+
+It was [rejected](https://github.com/microsoft/TypeScript/issues/26255#issuecomment-748211891) from being done in TypeScript itself.
+
+@example
+```
+import {arrayIncludes} from 'ts-extras';
+
+const values = ['a', 'b', 'c'] as const;
+const valueToCheck: unknown = 'a';
+
+if (arrayIncludes(values, valueToCheck)) {
+    // We now know that the value is of type `typeof values[number]`.
+}
+```
+
+@category Improved builtin
+@category Type guard
+*/
+export declare function arrayIncludes<Type extends SuperType, SuperType = unknown>(array: Type[] | readonly Type[], item: SuperType, fromIndex?: number): item is Type;

package/helpers/ts-extras/array-includes.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.arrayIncludes = void 0;
+/**
+An alternative to `Array#includes()` that properly acts as a type guard.
+
+It was [rejected](https://github.com/microsoft/TypeScript/issues/26255#issuecomment-748211891) from being done in TypeScript itself.
+
+@example
+```
+import {arrayIncludes} from 'ts-extras';
+
+const values = ['a', 'b', 'c'] as const;
+const valueToCheck: unknown = 'a';
+
+if (arrayIncludes(values, valueToCheck)) {
+    // We now know that the value is of type `typeof values[number]`.
+}
+```
+
+@category Improved builtin
+@category Type guard
+*/
+function arrayIncludes(array, item, fromIndex) {
+    return array.includes(item, fromIndex);
+}
+exports.arrayIncludes = arrayIncludes;

package/helpers/ts-extras/as-mutable.d.ts

@@ -0,0 +1,16 @@
+import { Writable } from 'type-fest';
+/**
+Cast the given value to be [`Mutable`](https://github.com/sindresorhus/type-fest/blob/main/source/mutable.d.ts).
+
+This is useful because of a TypeScript limitation: https://github.com/microsoft/TypeScript/issues/45618#issuecomment-908072756
+
+@example
+```
+import {asMutable} from 'ts-extras';
+
+const mutableContext = asMutable((await import('x')).context);
+```
+
+@category General
+*/
+export declare function asMutable<T>(value: T): Writable<T>;

package/helpers/ts-extras/as-mutable.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.asMutable = void 0;
+/**
+Cast the given value to be [`Mutable`](https://github.com/sindresorhus/type-fest/blob/main/source/mutable.d.ts).
+
+This is useful because of a TypeScript limitation: https://github.com/microsoft/TypeScript/issues/45618#issuecomment-908072756
+
+@example
+```
+import {asMutable} from 'ts-extras';
+
+const mutableContext = asMutable((await import('x')).context);
+```
+
+@category General
+*/
+function asMutable(value) {
+    return value; // eslint-disable-line @typescript-eslint/no-unsafe-return,@typescript-eslint/no-explicit-any
+}
+exports.asMutable = asMutable;

package/helpers/ts-extras/assert-error.d.ts

@@ -0,0 +1,30 @@
+/**
+Assert that the given value is an `Error`.
+
+If the value is not an `Error`, a helpful `TypeError` will be thrown.
+
+This can be useful as any value could potentially be thrown, but in practice, it's always an `Error`. However, because of this, TypeScript makes the caught error in a try/catch statement `unknown`, which is inconvenient to deal with.
+
+@example
+```
+import {assertError} from 'ts-extras';
+
+try {
+    fetchUnicorns();
+} catch (error: unknown) {
+    assertError(error)
+
+    // `error` is now of type `Error`
+
+    if (error.message === 'Failed to fetch') {
+        retry();
+        returnl
+    }
+
+    throw error;
+}
+```
+
+@category Type guard
+*/
+export declare function assertError(value: unknown): asserts value is Error;

package/helpers/ts-extras/assert-error.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertError = void 0;
+/**
+Assert that the given value is an `Error`.
+
+If the value is not an `Error`, a helpful `TypeError` will be thrown.
+
+This can be useful as any value could potentially be thrown, but in practice, it's always an `Error`. However, because of this, TypeScript makes the caught error in a try/catch statement `unknown`, which is inconvenient to deal with.
+
+@example
+```
+import {assertError} from 'ts-extras';
+
+try {
+    fetchUnicorns();
+} catch (error: unknown) {
+    assertError(error)
+
+    // `error` is now of type `Error`
+
+    if (error.message === 'Failed to fetch') {
+        retry();
+        returnl
+    }
+
+    throw error;
+}
+```
+
+@category Type guard
+*/
+function assertError(value) {
+    if (!(value instanceof Error || Object.prototype.toString.call(value) === '[object Error]')) {
+        throw new TypeError(`Expected an \`Error\`, got \`${JSON.stringify(value)}\` (${typeof value})`);
+    }
+}
+exports.assertError = assertError;

package/helpers/ts-extras/index.d.ts

@@ -0,0 +1,15 @@
+export { arrayIncludes } from './array-includes';
+export { asMutable } from './as-mutable';
+export { assertError } from './assert-error';
+export { isDefined } from './is-defined';
+export { isPresent } from './is-present';
+export { isEmpty } from './is-empty';
+export { isFinite } from './is-finite';
+export { isInfinite } from './is-infinite';
+export { isInteger } from './is-integer';
+export { isSafeInteger } from './is-safe-integer';
+export { objectEntries } from './object-entries';
+export { objectFromEntries } from './object-from-entries';
+export { objectHasOwn } from './object-has-own';
+export { objectKeys } from './object-keys';
+export { setHas } from './set-has';

package/helpers/ts-extras/index.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setHas = exports.objectKeys = exports.objectHasOwn = exports.objectFromEntries = exports.objectEntries = exports.isSafeInteger = exports.isInteger = exports.isInfinite = exports.isFinite = exports.isEmpty = exports.isPresent = exports.isDefined = exports.assertError = exports.asMutable = exports.arrayIncludes = void 0;
+var array_includes_1 = require("./array-includes");
+Object.defineProperty(exports, "arrayIncludes", { enumerable: true, get: function () { return array_includes_1.arrayIncludes; } });
+var as_mutable_1 = require("./as-mutable");
+Object.defineProperty(exports, "asMutable", { enumerable: true, get: function () { return as_mutable_1.asMutable; } });
+var assert_error_1 = require("./assert-error");
+Object.defineProperty(exports, "assertError", { enumerable: true, get: function () { return assert_error_1.assertError; } });
+var is_defined_1 = require("./is-defined");
+Object.defineProperty(exports, "isDefined", { enumerable: true, get: function () { return is_defined_1.isDefined; } });
+var is_present_1 = require("./is-present");
+Object.defineProperty(exports, "isPresent", { enumerable: true, get: function () { return is_present_1.isPresent; } });
+var is_empty_1 = require("./is-empty");
+Object.defineProperty(exports, "isEmpty", { enumerable: true, get: function () { return is_empty_1.isEmpty; } });
+var is_finite_1 = require("./is-finite");
+Object.defineProperty(exports, "isFinite", { enumerable: true, get: function () { return is_finite_1.isFinite; } });
+var is_infinite_1 = require("./is-infinite");
+Object.defineProperty(exports, "isInfinite", { enumerable: true, get: function () { return is_infinite_1.isInfinite; } });
+var is_integer_1 = require("./is-integer");
+Object.defineProperty(exports, "isInteger", { enumerable: true, get: function () { return is_integer_1.isInteger; } });
+var is_safe_integer_1 = require("./is-safe-integer");
+Object.defineProperty(exports, "isSafeInteger", { enumerable: true, get: function () { return is_safe_integer_1.isSafeInteger; } });
+var object_entries_1 = require("./object-entries");
+Object.defineProperty(exports, "objectEntries", { enumerable: true, get: function () { return object_entries_1.objectEntries; } });
+var object_from_entries_1 = require("./object-from-entries");
+Object.defineProperty(exports, "objectFromEntries", { enumerable: true, get: function () { return object_from_entries_1.objectFromEntries; } });
+var object_has_own_1 = require("./object-has-own");
+Object.defineProperty(exports, "objectHasOwn", { enumerable: true, get: function () { return object_has_own_1.objectHasOwn; } });
+var object_keys_1 = require("./object-keys");
+Object.defineProperty(exports, "objectKeys", { enumerable: true, get: function () { return object_keys_1.objectKeys; } });
+var set_has_1 = require("./set-has");
+Object.defineProperty(exports, "setHas", { enumerable: true, get: function () { return set_has_1.setHas; } });

package/helpers/ts-extras/is-defined.d.ts

@@ -0,0 +1,16 @@
+/**
+Check whether a value is defined, meaning it is not `undefined`.
+
+This can be useful as a type guard, as for example, `[1, undefined].filter(Boolean)` does not always type-guard correctly.
+
+@example
+```
+import {isDefined} from 'ts-extras';
+
+[1, undefined, 2].filter(isDefined);
+//=> [1, 2]
+```
+
+@category Type guard
+*/
+export declare function isDefined<T>(value: T | undefined): value is T;

package/helpers/ts-extras/is-defined.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isDefined = void 0;
+/**
+Check whether a value is defined, meaning it is not `undefined`.
+
+This can be useful as a type guard, as for example, `[1, undefined].filter(Boolean)` does not always type-guard correctly.
+
+@example
+```
+import {isDefined} from 'ts-extras';
+
+[1, undefined, 2].filter(isDefined);
+//=> [1, 2]
+```
+
+@category Type guard
+*/
+function isDefined(value) {
+    return value !== undefined;
+}
+exports.isDefined = isDefined;

package/helpers/ts-extras/is-empty.d.ts

@@ -0,0 +1,20 @@
+/**
+Check whether an array is empty.
+
+This is useful because doing `array.length === 0` on its own won't work as a type-guard.
+
+@example
+```
+import {isEmpty} from 'ts-extras';
+
+isEmpty([1, 2, 3]);
+//=> false
+
+isEmpty([]);
+//=> true
+```
+
+@category Type guard
+*/
+export declare function isEmpty(array: readonly unknown[]): array is readonly [];
+export declare function isEmpty(array: unknown[]): array is [];

package/helpers/ts-extras/is-empty.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isEmpty = void 0;
+function isEmpty(array) {
+    return array.length === 0;
+}
+exports.isEmpty = isEmpty;

package/helpers/ts-extras/is-finite.d.ts

@@ -0,0 +1,8 @@
+import { Finite } from 'type-fest';
+/**
+An alternative to `Number.isFinite()` that properly acts as a type guard.
+
+@category Improved builtin
+@category Type guard
+*/
+export declare const isFinite: <T extends number>(value: T) => value is Finite<T>;

package/helpers/ts-extras/is-finite.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isFinite = void 0;
+/**
+An alternative to `Number.isFinite()` that properly acts as a type guard.
+
+@category Improved builtin
+@category Type guard
+*/
+exports.isFinite = Number.isFinite;

package/helpers/ts-extras/is-infinite.d.ts

@@ -0,0 +1,7 @@
+import { NegativeInfinity, PositiveInfinity } from 'type-fest';
+/**
+Check whether a value is infinite.
+
+@category Type guard
+*/
+export declare function isInfinite(value: unknown): value is NegativeInfinity | PositiveInfinity;

package/helpers/ts-extras/is-infinite.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isInfinite = void 0;
+/**
+Check whether a value is infinite.
+
+@category Type guard
+*/
+function isInfinite(value) {
+    return !Number.isNaN(value) && !Number.isFinite(value);
+}
+exports.isInfinite = isInfinite;

package/helpers/ts-extras/is-integer.d.ts

@@ -0,0 +1,8 @@
+import { Integer } from 'type-fest';
+/**
+An alternative to `Number.isInteger()` that properly acts as a type guard.
+
+@category Improved builtin
+@category Type guard
+*/
+export declare const isInteger: <T extends number>(value: T) => value is Integer<T>;

package/helpers/ts-extras/is-integer.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isInteger = void 0;
+/**
+An alternative to `Number.isInteger()` that properly acts as a type guard.
+
+@category Improved builtin
+@category Type guard
+*/
+exports.isInteger = Number.isInteger;

package/helpers/ts-extras/is-present.d.ts

@@ -0,0 +1,16 @@
+/**
+Check whether a value is present (non-nullable), meaning it is neither `null` or `undefined`.
+
+This can be useful as a type guard, as for example, `[1, null].filter(Boolean)` does not always type-guard correctly.
+
+@example
+```
+import {isPresent} from 'ts-extras';
+
+[1, null, 2, undefined].filter(isPresent);
+//=> [1, 2]
+```
+
+@category Type guard
+*/
+export declare function isPresent<T>(value: T): value is NonNullable<T>;

package/helpers/ts-extras/is-present.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isPresent = void 0;
+/**
+Check whether a value is present (non-nullable), meaning it is neither `null` or `undefined`.
+
+This can be useful as a type guard, as for example, `[1, null].filter(Boolean)` does not always type-guard correctly.
+
+@example
+```
+import {isPresent} from 'ts-extras';
+
+[1, null, 2, undefined].filter(isPresent);
+//=> [1, 2]
+```
+
+@category Type guard
+*/
+function isPresent(value) {
+    return value !== null && value !== undefined;
+}
+exports.isPresent = isPresent;

package/helpers/ts-extras/is-safe-integer.d.ts

@@ -0,0 +1,8 @@
+import { Integer } from 'type-fest';
+/**
+An alternative to `Number.isSafeInteger()` that properly acts as a type guard.
+
+@category Improved builtin
+@category Type guard
+*/
+export declare const isSafeInteger: <T extends number>(value: T) => value is Integer<T>;

package/helpers/ts-extras/is-safe-integer.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isSafeInteger = void 0;
+/**
+An alternative to `Number.isSafeInteger()` that properly acts as a type guard.
+
+@category Improved builtin
+@category Type guard
+*/
+exports.isSafeInteger = Number.isSafeInteger;

package/helpers/ts-extras/object-entries.d.ts

@@ -0,0 +1,23 @@
+import { ObjectKeys } from './object-keys';
+/**
+A strongly-typed version of `Object.entries()`.
+
+This is useful since `Object.entries()` always returns an array of `Array<[string, T]>`. This function returns a strongly-typed array of the entries of the given object.
+
+- [TypeScript issues about this](https://github.com/microsoft/TypeScript/pull/12253)
+
+@example
+```
+import {objectEntries} from 'ts-extras';
+
+const stronglyTypedEntries = objectEntries({a: 1, b: 2, c: 3});
+//=> Array<['a' | 'b' | 'c', number]>
+
+const untypedEntries = Object.entries(items);
+//=> Array<[string, number]>
+```
+
+@category Improved builtin
+@category Type guard
+*/
+export declare const objectEntries: <Type extends Record<PropertyKey, unknown>>(value: Type) => [`${Exclude<keyof Type, symbol>}`, Type[`${Exclude<keyof Type, symbol>}`]][];

package/helpers/ts-extras/object-entries.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.objectEntries = void 0;
+/**
+A strongly-typed version of `Object.entries()`.
+
+This is useful since `Object.entries()` always returns an array of `Array<[string, T]>`. This function returns a strongly-typed array of the entries of the given object.
+
+- [TypeScript issues about this](https://github.com/microsoft/TypeScript/pull/12253)
+
+@example
+```
+import {objectEntries} from 'ts-extras';
+
+const stronglyTypedEntries = objectEntries({a: 1, b: 2, c: 3});
+//=> Array<['a' | 'b' | 'c', number]>
+
+const untypedEntries = Object.entries(items);
+//=> Array<[string, number]>
+```
+
+@category Improved builtin
+@category Type guard
+*/
+exports.objectEntries = Object.entries;

package/helpers/ts-extras/object-from-entries.d.ts

@@ -0,0 +1,26 @@
+/**
+A strongly-typed version of `Object.fromEntries()`.
+
+This is useful since `Object.fromEntries()` always returns `{[key: string]: T}`. This function returns a strongly-typed object from the given array of entries.
+
+- [TypeScript issues about this](https://github.com/microsoft/TypeScript/issues/35745)
+
+@example
+```
+import {objectFromEntries} from 'ts-extras';
+
+const stronglyTypedObjectFromEntries = objectFromEntries([
+    ['a', 123],
+    ['b', 'someString'],
+    ['c', true],
+]);
+//=> {a: number; b: string; c: boolean}
+
+const untypedEntries = Object.fromEntries(entries);
+//=> {[key: string]: string}
+```
+
+@category Improved builtin
+@category Type guard
+*/
+export declare const objectFromEntries: <Key extends PropertyKey, Entries extends readonly (readonly [Key, unknown])[]>(values: Entries) => { [K in Extract<Entries[number], readonly [Key, unknown]>[0]]: Extract<Entries[number], readonly [K, unknown]>[1]; };