@augment-vir/common 4.2.1 → 4.3.0

package/dist/augments/array.d.ts

@@ -1,9 +1,9 @@
 import { AtLeastTuple } from './tuple';
 import { ArrayElement } from './type';
-export declare function filterOutIndexes<T>(array: Readonly<T[]>, indexes: Readonly<number[]>): T[];
-export declare function flatten2dArray<T>(array2d: T[][]): T[];
+export declare function filterOutIndexes<T>(array: ReadonlyArray<T>, indexes: ReadonlyArray<number>): T[];
+export declare function flatten2dArray<T>(array2d: ReadonlyArray<ReadonlyArray<T>>): T[];
 export declare type AtLeastOneEntryArray<ArrayGeneric extends ReadonlyArray<any>> = AtLeastTuple<ArrayElement<ArrayGeneric>, 1>;
-export declare function trimArrayStrings(input: string[]): string[];
+export declare function trimArrayStrings(input: ReadonlyArray<string>): string[];
 /**
  * Acts like calling Array.prototype.forEach in that all elements are executed upon in order, and
  * each execution is blocking. Meaning, the callback won't be called on element 2 until the callback
@@ -11,7 +11,7 @@ export declare function trimArrayStrings(input: string[]): string[];
  */
 export declare function awaitedForEach<OriginalGeneric>(input: ReadonlyArray<OriginalGeneric>, callback: (arrayElement: OriginalGeneric, index: number, wholeArray: ReadonlyArray<OriginalGeneric>) => void | PromiseLike<void>): Promise<void>;
 export declare function awaitedBlockingMap<OriginalGeneric, MappedGeneric>(input: ReadonlyArray<OriginalGeneric>, callback: (arrayElement: OriginalGeneric, index: number, wholeArray: ReadonlyArray<OriginalGeneric>) => MappedGeneric | PromiseLike<MappedGeneric>): Promise<Awaited<MappedGeneric>[]>;
-export declare function isInTypedArray<T>(array: T[], input: any): input is T;
+export declare function isInTypedArray<T>(array: ReadonlyArray<T>, input: any): input is T;
 declare type MapCallbackType<ArrayType extends ReadonlyArray<any>, OutputType> = (value: ArrayElement<ArrayType>, index: number, array: ArrayType) => OutputType;
 /** Preserves tuple types. */
 export declare function typedMap<InputArrayGeneric extends ReadonlyArray<any>, OutputType>(arrayToMap: InputArrayGeneric, mapCallback: MapCallbackType<InputArrayGeneric, OutputType>): {

package/dist/augments/date.d.ts

@@ -1,4 +1,4 @@
-export declare const englishFullMonthNames: string[];
+export declare const englishFullMonthNames: readonly ["january", "february", "march", "april", "may", "june", "july", "august", "september", "october", "november", "december"];
 export declare const englishShortMonthNames: string[];
 export declare class InvalidDateError extends Error {
     readonly name = "InvalidDateError";

package/dist/augments/error.d.ts

@@ -1,8 +1,8 @@
 import { AtLeastTuple } from './tuple';
 export declare function combineErrors(errors: AtLeastTuple<Error, 1>): Error;
-export declare function combineErrors(errors: never[]): undefined;
-export declare function combineErrors(errors: Error[]): Error | undefined;
+export declare function combineErrors(errors: ReadonlyArray<never>): undefined;
+export declare function combineErrors(errors: ReadonlyArray<Error>): Error | undefined;
 export declare function combineErrors(errors?: undefined): undefined;
-export declare function combineErrorMessages(errors?: (Error | string | undefined)[] | undefined): string;
+export declare function combineErrorMessages(errors?: ReadonlyArray<Error | string | undefined> | undefined): string;
 export declare function extractErrorMessage(error: unknown): string;
 export declare function ensureError(input: unknown): Error;

package/dist/augments/number.d.ts

@@ -24,4 +24,4 @@ export declare function clamp(
  *     'Z', // zetta- sextillion
  *     'Y', // yotta- septillion
  */
-export declare function truncateNumber(originalValue: unknown, suffixes?: readonly string[]): string;
+export declare function truncateNumber(originalValue: unknown, suffixes?: ReadonlyArray<string>): string;

package/dist/augments/object.d.ts

@@ -4,14 +4,14 @@ export declare function getEnumTypedKeys<T extends object>(input: T): (keyof T)[
 export declare function getEnumTypedValues<T extends object>(input: T): T[keyof T][];
 export declare function isEnumValue<T extends object>(input: unknown, checkEnum: T): input is T[keyof T];
 export declare function isKeyof<ObjectGeneric>(key: PropertyKey, object: ObjectGeneric): key is keyof object;
-export declare function filterToEnumValues<T extends object>(inputs: unknown[], checkEnum: T, caseInsensitive?: boolean): T[keyof T][];
+export declare function filterToEnumValues<T extends object>(inputs: ReadonlyArray<unknown>, checkEnum: T, caseInsensitive?: boolean): T[keyof T][];
 export declare function getObjectTypedKeys<ObjectGeneric extends unknown>(input: ObjectGeneric): ReadonlyArray<keyof ObjectGeneric>;
 export declare function getObjectTypedValues<ObjectGeneric extends unknown>(input: ObjectGeneric): ObjectGeneric[keyof ObjectGeneric][];
 declare type ExtractValue<KeyGeneric extends PropertyKey, ParentGeneric> = KeyGeneric extends keyof ParentGeneric ? RequiredBy<ParentGeneric, KeyGeneric>[KeyGeneric] : KeyGeneric extends keyof Extract<ParentGeneric, Record<KeyGeneric, any>> ? RequiredBy<Extract<ParentGeneric, Record<KeyGeneric, any>>, KeyGeneric>[KeyGeneric] : never;
 declare type CombinedParentValue<KeyGeneric extends PropertyKey, ParentGeneric> = ExtractValue<KeyGeneric, ParentGeneric> extends never ? unknown : ExtractValue<KeyGeneric, ParentGeneric>;
 declare type CombineTypeWithKey<KeyGeneric extends PropertyKey, ParentGeneric> = ParentGeneric & Record<KeyGeneric, CombinedParentValue<KeyGeneric, ParentGeneric>>;
 export declare function typedHasProperty<KeyGeneric extends PropertyKey, ParentGeneric>(inputObject: ParentGeneric, inputKey: KeyGeneric): inputObject is CombineTypeWithKey<KeyGeneric, ParentGeneric>;
-export declare function typedHasProperties<KeyGeneric extends PropertyKey, ParentGeneric>(inputObject: ParentGeneric, inputKeys: KeyGeneric[]): inputObject is CombineTypeWithKey<KeyGeneric, ParentGeneric>;
+export declare function typedHasProperties<KeyGeneric extends PropertyKey, ParentGeneric>(inputObject: ParentGeneric, inputKeys: ReadonlyArray<KeyGeneric>): inputObject is CombineTypeWithKey<KeyGeneric, ParentGeneric>;
 export declare function isObject(input: any): input is NonNullable<object>;
 export declare function getEntriesSortedByKey(input: object): [string, unknown][];
 export declare function areJsonEqual(a: object, b: object): boolean;

package/dist/augments/string.d.ts

@@ -7,14 +7,14 @@
  *   to begin with.
  * @param conjunction Defaults to 'and'. The conjunction to be used before the final element.
  */
-export declare function joinWithFinalConjunction<T>(list: T[], conjunction?: string): string;
+export declare function joinWithFinalConjunction(list: ReadonlyArray<any>, conjunction?: string): string;
 export declare function removeAnsiEscapeCodes(input: string): string;
 export declare const removeColor: typeof removeAnsiEscapeCodes;
 export declare function removeCommasFromNumberString(numberString: string): string;
 /** Collapse all consecutive white space into just one space and trim surrounding whitespace. */
 export declare function collapseWhiteSpace(input: string): string;
 /** Same as String.prototype.split but includes the delimiter to split by in the output array. */
-export declare function splitIncludeSplit(original: string, splitterInput: string | RegExp, caseSensitive: boolean): string[];
+export declare function splitIncludeSplit(original: string, splitterInput: string | RegExp, caseSensitive: boolean): readonly string[];
 export declare type CasingOptions = {
     capitalizeFirstLetter: boolean;
 };

package/dist/augments/type-of.d.ts

@@ -0,0 +1,17 @@
+declare function getTypeOf(x: any): "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function";
+export declare type TypeOf = ReturnType<typeof getTypeOf>;
+export declare type TypeOfWithArray = TypeOf | 'array';
+export declare type TypeOfMapping = {
+    array: any[];
+    bigint: bigint;
+    boolean: boolean;
+    function: (...args: any[]) => any;
+    number: number;
+    object: object;
+    string: string;
+    symbol: symbol;
+    undefined: undefined;
+};
+export declare function typeOfWithArray(input: unknown): TypeOfWithArray;
+export declare function isTypeOfWithArray<T extends TypeOfWithArray>(input: unknown, testType: T): input is TypeOfMapping[T];
+export {};

package/dist/augments/type-of.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isTypeOfWithArray = exports.typeOfWithArray = void 0;
+function getTypeOf(x) {
+    return typeof x;
+}
+function typeOfWithArray(input) {
+    return Array.isArray(input) ? 'array' : typeof input;
+}
+exports.typeOfWithArray = typeOfWithArray;
+function isTypeOfWithArray(input, testType) {
+    const inputType = typeOfWithArray(input);
+    return inputType === testType;
+}
+exports.isTypeOfWithArray = isTypeOfWithArray;

package/dist/index.d.ts

@@ -10,4 +10,5 @@ export * from './augments/regexp';
 export * from './augments/string';
 export * from './augments/tuple';
 export * from './augments/type';
+export * from './augments/type-of';
 export * from './augments/type-test';

package/dist/index.js

@@ -26,4 +26,5 @@ __exportStar(require("./augments/regexp"), exports);
 __exportStar(require("./augments/string"), exports);
 __exportStar(require("./augments/tuple"), exports);
 __exportStar(require("./augments/type"), exports);
+__exportStar(require("./augments/type-of"), exports);
 __exportStar(require("./augments/type-test"), exports);

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@augment-vir/common",
-    "version": "4.2.1",
+    "version": "4.3.0",
     "homepage": "https://github.com/electrovir/augment-vir/tree/main/packages/common",
     "bugs": {
         "url": "https://github.com/electrovir/augment-vir/issues"
@@ -22,7 +22,8 @@
         "test": "echo \"use common-test to run tests\" && exit 0"
     },
     "dependencies": {
-        "@type-challenges/utils": "^0.1.1"
+        "@type-challenges/utils": "^0.1.1",
+        "type-fest": "^3.2.0"
     },
     "devDependencies": {
         "prettier": "^2.7.1",