@zelgadis87/utils-core 5.2.12 → 5.3.0

package/dist/utils/operations.d.ts

@@ -1,28 +0,0 @@
-export type TOperation<T, E = Error> = {
-    success: false;
-    error: E;
-} | {
-    success: true;
-    data: T;
-};
-export type TAsyncOperation<T, E = Error> = Promise<TOperation<T, E>>;
-export type TOperationTuple<T, E = Error> = [T, undefined] | [undefined, E];
-export type TAsyncOperationTuple<T, E = Error> = Promise<TOperationTuple<T, E>>;
-export type TValidation<T, E = Error> = {
-    success: false;
-    errors: E[];
-} | {
-    success: true;
-    data: T;
-};
-export type TAsyncValidation<T, E = Error> = Promise<TValidation<T, E>>;
-export declare const Operation: {
-    ok: <const T>(data: T) => {
-        readonly success: true;
-        readonly data: T;
-    };
-    ko: <const E>(error: E) => {
-        readonly success: false;
-        readonly error: E;
-    };
-};

package/dist/utils/primitives.d.ts

@@ -1,3 +0,0 @@
-export type TTimeoutHandle = ReturnType<typeof setTimeout>;
-export type TIntervalHandle = ReturnType<typeof setInterval>;
-export type TPrimitive = string | number | boolean | null;

package/dist/utils/promises.d.ts

@@ -1,10 +0,0 @@
-import TimeDuration from "../time/TimeDuration.js";
-import { TAsyncFunction, TFunction } from "./functions.js";
-export type TPromisable<T> = T | Promise<T>;
-export declare function asPromise<T>(promisable: TPromisable<T>): Promise<T>;
-export declare function promiseSequence<R>(...fns: TFunction<void, Promise<R>>[]): TFunction<void, Promise<R[]>>;
-export declare function delayPromise<T>(duration: TimeDuration): TAsyncFunction<T, T>;
-export declare class TimeoutError extends Error {
-}
-export declare function awaitAtMost<T>(promise: Promise<T>, duration: TimeDuration): Promise<T>;
-export declare const NEVER: Promise<unknown>;

package/dist/utils/random.d.ts

@@ -1,3 +0,0 @@
-import { TPositiveNumber } from "./numbers.ts";
-export declare function randomNumberInInterval(min: number, max: number): number;
-export declare const randomId: (length: TPositiveNumber) => string;

package/dist/utils/records/entries.d.ts

@@ -1,7 +0,0 @@
-import { TFunction } from "../_index";
-export declare function dictToEntries<V, K extends string = string>(obj: Record<K, V>): [K, V][];
-export declare function entriesToDict<V, K extends string = string>(entries: [K, V][]): Record<K, V>;
-export declare function entriesToEntries<K1 extends string, V1, K2 extends string, V2>(dict: Record<K1, V1>, mapper: TFunction<[K1, V1], [K2, V2]>): Record<K2, V2>;
-/** @deprecated[2025.08.01]: Compatibility layer. */
-export declare const mapEntries: typeof entriesToEntries;
-export declare function entriesToList<K1 extends string, V1, R>(dict: Record<K1, V1>, mapper: TFunction<[K1, V1], R>): Array<R>;

package/dist/utils/records.d.ts

@@ -1,63 +0,0 @@
-export * from './records/entries.js';
-export type TEmpty = Record<string, never>;
-export type TKeysOfType<T, V> = {
-    [K in keyof T]-?: T[K] extends V ? K : never;
-}[keyof T];
-export declare function dictToList<T>(obj: Record<string | number, T>): T[];
-export declare function pick<T extends object, K extends keyof T>(o: T, keys: K[]): Pick<T, K>;
-export type TOptionsWithoutDefaults<T, R> = Partial<T> & Required<Omit<T, keyof R>>;
-export type TOptionalKeysForType<T> = {
-    [K in keyof T]-?: {} extends Pick<T, K> ? K : never;
-}[keyof T];
-export type TRequiredKeysForType<T> = Exclude<keyof T, TOptionalKeysForType<T>>;
-export type TAllKeysOptional<T> = TRequiredKeysForType<T> extends never ? true : false;
-export type TConditionalParameter<T> = TAllKeysOptional<T> extends true ? T | undefined : T;
-export type TConditionalParameterOptions<T, R> = TConditionalParameter<TOptionsWithoutDefaults<T, R>>;
-/**
- * Given a type T, replaces all fields of type From to fields of type To.
- */
-export type TReplaceType<T, From, To> = {
-    [K in keyof T]: T[K] extends From ? To : T[K];
-};
-/**
- * Given a type T, make field K required instead of optional.
- */
-export type TWithRequiredProperty<T, K extends keyof T> = T & {
-    [Property in K]-?: T[Property];
-};
-/**
- * Given a type T, make all fields required instead of optional.
- */
-export type TWithRequiredProperties<T> = Required<T>;
-/**
- * Type that forces a record to contain a few properties, but allows for extraneous properties.
- */
-export type TWithExtras<R extends Record<any, any>, T extends Record<any, any> = Record<string, unknown>> = R & T;
-/**
- * Types that improves the human readability of a Typescript type.
- */
-export type TPrettify<T> = {
-    [K in keyof T]: T[K];
-} & {};
-export declare function shallowRecordEquals(a: Record<string, unknown>, b: Record<string, unknown>): boolean;
-/**
- * A utility type that checks if any property in a record type `T` has the `never` type.
- * This type evaluates to `true` if at least one property in `T` is of type `never`, and `false` otherwise.
- * It's commonly used to create compile-time assertions that prevent unintended changes where properties might accidentally become `never` due to type mismatches.
- *
- * @example Advanced usage for type guards
- * ```typescript
- * type TMap = { a: string; b: number; c: boolean };
- * type TJsonSerializable = string | number | boolean;
- *
- * type TFiltered = {
- *   [K in keyof TMap]: TMap[K] extends TJsonSerializable ? TMap[K] : never;
- * };
- *
- * // If TMap changes and some property becomes not serializable, TFiltered will have 'never' values
- * const _guard: THasNever<TFiltered> = false; // Compile error if any property became 'never'
- * ```
- */
-export type THasNever<T> = {
-    [K in keyof T]: [T[K]] extends [never] ? true : false;
-}[keyof T] extends false ? false : true;

package/dist/utils/strings/StringParts.d.ts

@@ -1,38 +0,0 @@
-import { TReadableArray } from "../arrays.js";
-import { TMaybe } from "../nulls.js";
-export declare class StringParts {
-    private readonly _parts;
-    private constructor();
-    toUpperCase(): StringParts;
-    toLowerCase(): StringParts;
-    capitalizeFirst(): StringParts;
-    capitalizeEach(): StringParts;
-    get parts(): string[];
-    get tail(): string[];
-    get first(): TMaybe<string>;
-    get last(): TMaybe<string>;
-    get length(): number;
-    trim(): StringParts;
-    toSnakeCase(): string;
-    toCamelCase(): string;
-    toKebabCase(): string;
-    toPascalCase(): string;
-    toHumanCase(): string;
-    join(separator: string): string;
-    mergeWith({ parts: otherParts }: {
-        parts: TReadableArray<string>;
-    }): StringParts;
-    slice(start: number, end?: number): StringParts;
-    splice(start: number, deleteCount: number, ...items: string[]): StringParts;
-    push(part: string): StringParts;
-    shift(part: string): StringParts;
-    reverse(): StringParts;
-    static fromString: (s: string, separator?: string | RegExp) => StringParts;
-    static fromParts: (...parts: string[]) => StringParts;
-    /**
-     * Tries to convert a word in PascalCase to an array of words. Will not work if there are spaces or special characters. Does not cope well on uppercase abbreviations (eg, "CSS").
-     * @param s a string in PascalCase.
-     * @returns a StringParts where each sub-word in PascalCase is now a part.
-     */
-    static tryToParsePascalCaseWord(s: string): StringParts;
-}

package/dist/utils/strings.d.ts

@@ -1,20 +0,0 @@
-import { TMaybe } from "./nulls.js";
-export * from './strings/StringParts.js';
-export type THtmlString = string;
-export type TUrl = string;
-export type TRelativeUrl = string;
-export declare function hashCode(str: string): number;
-export declare function repeat(char: string, times: number): string;
-export declare function capitalizeWord(word: string): string;
-export declare function splitWords(text: string, regEx?: RegExp): string[];
-export declare function stringToNumber(s: string | null | undefined): number | null;
-export declare function pad(str: string, n: number, char: string, where?: 'left' | 'right'): string;
-export declare function padLeft(str: string, n: number, char: string): string;
-export declare function padRight(str: string, n: number, char: string): string;
-export declare function ellipsis(str: string, maxLength: number): string;
-export declare function pluralize(n: number, singular: string, plural?: string): string;
-export declare function isString(source: unknown): source is string;
-export declare function isEmpty(source: string): boolean;
-export declare function isNullOrUndefinedOrEmpty(source: TMaybe<string>): boolean;
-export declare function wrapWithString(str: string, delimiter: string): string;
-export declare function wrapWithString(str: string, start: string, end: string): string;