@postxl/utils 0.1.8

package/dist/map.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mapMap = mapMap;
+exports.mapMapValues = mapMapValues;
+exports.mapMapKeyValues = mapMapKeyValues;
+exports.mapMapKeys = mapMapKeys;
+exports.filterMap = filterMap;
+exports.mapGetAndAssert = mapGetAndAssert;
+exports.mapToDict = mapToDict;
+function mapMap(map, predicate) {
+    const result = new Map();
+    for (const [key, value] of map.entries()) {
+        result.set(key, predicate(value, key));
+    }
+    return result;
+}
+function mapMapValues(map, predicate) {
+    const result = [];
+    for (const [key, value] of map.entries()) {
+        result.push(predicate(value, key));
+    }
+    return result;
+}
+/**
+ *
+ */
+function mapMapKeyValues(map, keyPredicate, valuePredicate) {
+    const result = new Map();
+    for (const [key, value] of map.entries()) {
+        result.set(keyPredicate(key, value), valuePredicate(value, key));
+    }
+    return result;
+}
+/**
+ * Maps keys of a map.
+ */
+function mapMapKeys(map, keyPredicate) {
+    const result = new Map();
+    for (const [key, value] of map.entries()) {
+        result.set(keyPredicate(key, value), value);
+    }
+    return result;
+}
+/**
+ * Filters values from a map.
+ */
+function filterMap(map, predicate) {
+    const result = new Map();
+    for (const [key, value] of map.entries()) {
+        if (predicate(value, key)) {
+            result.set(key, value);
+        }
+    }
+    return result;
+}
+/**
+ * Gets a value from a map and asserts that it exists.
+ */
+function mapGetAndAssert(map, key) {
+    const value = map.get(key);
+    if (!value) {
+        throw new Error(`Key ${JSON.stringify(key)} not found`);
+    }
+    return value;
+}
+/**
+ * Converts a map to a dictionary.
+ */
+function mapToDict(map) {
+    const result = {};
+    for (const [key, value] of map.entries()) {
+        result[key] = value;
+    }
+    return result;
+}

package/dist/omit.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Omits a key from an object
+ */
+export declare function omit<T extends Record<string, unknown>>(obj: T, key: string): Omit<T, typeof key>;

package/dist/omit.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.omit = omit;
+/**
+ * Omits a key from an object
+ */
+function omit(obj, key) {
+    const { [key]: _, ...rest } = obj;
+    return rest;
+}

package/dist/pagination.d.ts

@@ -0,0 +1,6 @@
+export type Page<Item> = {
+    total: number;
+    offset: number;
+    items: Item[];
+};
+export declare const slice: <Item>(items: Item[], skip?: number, take?: number) => Page<Item>;

package/dist/pagination.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.slice = void 0;
+const slice = (items, skip, take) => {
+    const start = skip ?? 0;
+    const end = take ? start + take : undefined;
+    return {
+        total: items.length,
+        offset: start,
+        items: items.slice(start, end),
+    };
+};
+exports.slice = slice;

package/dist/random.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Returns a randomly generated alphanumeric string.
+ */
+export declare const generateRandomAlphanumericString: (length: number) => string;

package/dist/random.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateRandomAlphanumericString = void 0;
+const crypto_1 = require("crypto");
+const CHARS = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789';
+/**
+ * Returns a randomly generated alphanumeric string.
+ */
+const generateRandomAlphanumericString = (length) => {
+    let result = '';
+    for (let i = 0; i < length; i++) {
+        result += CHARS[(0, crypto_1.randomInt)(CHARS.length)];
+    }
+    return result;
+};
+exports.generateRandomAlphanumericString = generateRandomAlphanumericString;

package/dist/remove-secrets.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Removes secrets from the given configuration object.
+ *
+ * Recursively checks all properties of the object for keys that end with
+ * `key`, `secret`, `password`, `token` and replaces them with '***'.
+ *
+ * Also checks for keys the end with `connection` or `connectionString` and
+ * replaces the connection string with the same string but with the password
+ * replaced with '***'.
+ */
+export declare function removeSecrets<T extends Record<string, unknown>>(config: T): T;

package/dist/remove-secrets.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.removeSecrets = removeSecrets;
+const is_object_1 = require("./is-object");
+/**
+ * Removes secrets from the given configuration object.
+ *
+ * Recursively checks all properties of the object for keys that end with
+ * `key`, `secret`, `password`, `token` and replaces them with '***'.
+ *
+ * Also checks for keys the end with `connection` or `connectionString` and
+ * replaces the connection string with the same string but with the password
+ * replaced with '***'.
+ */
+function removeSecrets(config) {
+    const newConfig = {};
+    for (const [key, value] of Object.entries(config)) {
+        newConfig[key] = processValue(key, value);
+    }
+    return newConfig;
+}
+function processValue(key, value) {
+    if (typeof value === 'string') {
+        return processString(key, value);
+    }
+    else if (Array.isArray(value)) {
+        return value.map((item) => removeSecrets(item));
+    }
+    else if (typeof value === 'object' && (0, is_object_1.isPlainObject)(value)) {
+        return removeSecrets(value);
+    }
+    return value;
+}
+function processString(key, value) {
+    if (key.endsWith('key') || key.endsWith('secret') || key.endsWith('password') || key.endsWith('token')) {
+        return hidePassword(value);
+    }
+    else if (key.endsWith('connection') || key.endsWith('connectionString')) {
+        return hidePasswordInConnectionString(value);
+    }
+    else {
+        return value;
+    }
+}
+function hidePasswordInConnectionString(connection) {
+    return (connection
+        // e.g. postgresql://user:password@host
+        .replace(/^(.*):\/\/(.*):(.*)@(.*)$/, '$1://$2:***@$4') //NOSONAR - this is only used to parse environment variables, so no risk of external DOS attacks
+        // e.g. user:password@host
+        .replace(/^(.*):(.*)@(.*)$/, '$1:***@$3') //NOSONAR - this is only used to parse environment variables, so no risk of external DOS attacks
+    );
+}
+function hidePassword(password) {
+    if (password === '') {
+        return 'nothing provided!';
+    }
+    if (password === 'secret') {
+        return 'default provided!';
+    }
+    return '***';
+}

package/dist/remove-undefined.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Removes all undefined properties from an object.
+ *
+ * NOTE: This is useful when using the `Partial<T>` type modifier in combination with the spread operator to prevent
+ *       overriding with undefined values.
+ */
+export declare function removeUndefinedProperties<T extends Record<string, unknown>>(obj: T): {
+    [K in keyof T]: T[K] extends undefined ? never : T[K];
+};

package/dist/remove-undefined.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.removeUndefinedProperties = removeUndefinedProperties;
+/**
+ * Removes all undefined properties from an object.
+ *
+ * NOTE: This is useful when using the `Partial<T>` type modifier in combination with the spread operator to prevent
+ *       overriding with undefined values.
+ */
+function removeUndefinedProperties(obj) {
+    const newObj = {};
+    for (const key in obj) {
+        const value = obj[key];
+        if (value !== undefined) {
+            // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+            // @ts-expect-error
+            newObj[key] = value;
+        }
+    }
+    return newObj;
+}

package/dist/result.d.ts

@@ -0,0 +1,24 @@
+export declare const OK = "OK";
+export declare const ERR = "ERR";
+export type Ok<Value> = {
+    type: typeof OK;
+    value: Value;
+};
+export type Err<ErrorType> = {
+    type: typeof ERR;
+    error: ErrorType;
+};
+export type Result<Value, ErrorType = TypedError<'genericError'>> = Ok<Value> | Err<ErrorType>;
+export declare const ok: <Value, ErrorType>(value: Value) => Result<Value, ErrorType>;
+export declare const err: <Value, ErrorType>(error: ErrorType) => Result<Value, ErrorType>;
+export declare const result: <Value, ErrorType>(getValue: () => Promise<Value>, errHandler: (e: Error) => ErrorType) => Promise<Result<Value, ErrorType>>;
+export declare const isOk: <Value, ErrorType>(r: Result<Value, ErrorType>) => r is Ok<Value>;
+export declare const isErr: <Value, ErrorType>(r: Result<Value, ErrorType>) => r is Err<ErrorType>;
+export declare const unwrap: <Value, ErrorType>(r: Result<Value, ErrorType>) => Value;
+export declare const withDefault: <Value, ErrorType>(r: Result<Value, ErrorType>, defaultValue: Value) => Value;
+export declare const map: <FROMValue, TOValue, Error>(func: (t: FROMValue) => TOValue, r: Result<FROMValue, Error>) => Result<TOValue, Error>;
+export type TypedError<T extends string> = {
+    type: T;
+    message: string;
+    error: Error;
+};

package/dist/result.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.map = exports.withDefault = exports.unwrap = exports.isErr = exports.isOk = exports.result = exports.err = exports.ok = exports.ERR = exports.OK = void 0;
+exports.OK = 'OK';
+exports.ERR = 'ERR';
+const ok = (value) => ({
+    type: exports.OK,
+    value,
+});
+exports.ok = ok;
+const err = (error) => ({
+    type: exports.ERR,
+    error,
+});
+exports.err = err;
+const result = async (getValue, errHandler) => {
+    try {
+        return (0, exports.ok)(await getValue());
+    }
+    catch (e) {
+        return (0, exports.err)(errHandler(e));
+    }
+};
+exports.result = result;
+const isOk = (r) => r.type === exports.OK;
+exports.isOk = isOk;
+const isErr = (r) => r.type === exports.ERR;
+exports.isErr = isErr;
+const unwrap = (r) => {
+    if ((0, exports.isErr)(r)) {
+        throw new Error(typeof r.error === 'string' ? r.error : JSON.stringify(r.error));
+    }
+    return r.value;
+};
+exports.unwrap = unwrap;
+const withDefault = (r, defaultValue) => {
+    if ((0, exports.isErr)(r)) {
+        return defaultValue;
+    }
+    return r.value;
+};
+exports.withDefault = withDefault;
+const map = (func, r) => {
+    if (r.type === exports.ERR) {
+        return r;
+    }
+    return (0, exports.ok)(func(r.value));
+};
+exports.map = map;

package/dist/sort.d.ts

@@ -0,0 +1,17 @@
+export type CompareFn<T> = (a: T, b: T) => number;
+export type Direction = 'asc' | 'desc';
+export declare const sort: <Item>(items: Item[], dir?: Direction, compareFn?: CompareFn<Item>) => Item[];
+/**
+ * Compare fields of an object.
+ */
+export declare const compareFields: <T>(key: keyof T) => CompareFn<T>;
+export type Getter<T> = (data: T) => unknown;
+export declare const compare: <T>(getter: Getter<T>) => CompareFn<T>;
+export declare const keyGetter: <T>(key: keyof T) => Getter<T>;
+export declare const compareValues: CompareFn<unknown>;
+export declare const compareDates: CompareFn<Date>;
+export declare const compareStrings: CompareFn<string>;
+export declare const compareNumbers: CompareFn<number>;
+export declare const compareBooleans: CompareFn<boolean>;
+export declare const booleanCode: (bool: boolean) => number;
+export declare const setDirection: <Item>(items: Item[], dir: Direction) => Item[];

package/dist/sort.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setDirection = exports.booleanCode = exports.compareBooleans = exports.compareNumbers = exports.compareStrings = exports.compareDates = exports.compareValues = exports.keyGetter = exports.compare = exports.compareFields = exports.sort = void 0;
+const sort = (items, dir = 'asc', compareFn = exports.compareValues) => (0, exports.setDirection)(items.toSorted(compareFn), dir);
+exports.sort = sort;
+/**
+ * Compare fields of an object.
+ */
+const compareFields = (key) => {
+    return (a, b) => (0, exports.compareValues)(a[key], b[key]);
+};
+exports.compareFields = compareFields;
+const compare = (getter) => {
+    return (a, b) => (0, exports.compareValues)(getter(a), getter(b));
+};
+exports.compare = compare;
+const keyGetter = (key) => {
+    return (data) => data[key];
+};
+exports.keyGetter = keyGetter;
+const compareValues = (a, b) => {
+    switch (true) {
+        // In case one item is undefined or null and the other is not, we place the non-null item first.
+        case (a === undefined || a === null) && b !== undefined && b !== null:
+            return 1;
+        case (b === undefined || b === null) && a !== undefined && a !== null:
+            return -1;
+        case (a === undefined || a === null) && (b === undefined || b === null):
+            return 0;
+        case a instanceof Date && b instanceof Date:
+            return (0, exports.compareDates)(a, b);
+        case typeof a === 'string' && typeof b === 'string':
+            return (0, exports.compareStrings)(a, b);
+        case typeof a === 'number' && typeof b === 'number':
+            return (0, exports.compareNumbers)(a, b);
+        case typeof a === 'boolean' && typeof b === 'boolean':
+            return (0, exports.compareBooleans)(a, b);
+        default:
+            return 0;
+    }
+};
+exports.compareValues = compareValues;
+const compareDates = (a, b) => (0, exports.compareStrings)(a.toISOString(), b.toISOString());
+exports.compareDates = compareDates;
+const compareStrings = (a, b) => {
+    const aLower = a.trim().toLowerCase();
+    const bLower = b.trim().toLowerCase();
+    if (aLower === bLower) {
+        return 0;
+    }
+    return aLower > bLower ? 1 : -1;
+};
+exports.compareStrings = compareStrings;
+const compareNumbers = (a, b) => a - b;
+exports.compareNumbers = compareNumbers;
+const compareBooleans = (a, b) => (0, exports.booleanCode)(a) - (0, exports.booleanCode)(b);
+exports.compareBooleans = compareBooleans;
+const booleanCode = (bool) => (bool ? 1 : 0);
+exports.booleanCode = booleanCode;
+const setDirection = (items, dir) => {
+    return dir === 'desc' ? items.toReversed() : items;
+};
+exports.setDirection = setDirection;

package/dist/string-colors.d.ts

@@ -0,0 +1,44 @@
+/**
+ * A function that returns a string with a specific color.
+ */
+export type ColorFn = (input: string) => string;
+/**
+ * Colors a string in red color (using ANSI escape codes).
+ */
+export declare function red(input: string): string;
+/**
+ * Colors a string in green color (using ANSI escape codes).
+ */
+export declare function green(input: string): string;
+/**
+ * Colors a string in yellow color (using ANSI escape codes).
+ */
+export declare function yellow(input: string): string;
+/**
+ * Colors a string in blue color (using ANSI escape codes).
+ */
+export declare function blue(input: string): string;
+/**
+ * Colors a string in cyan color (using ANSI escape codes).
+ */
+export declare function cyan(input: string): string;
+/**
+ * Colors a string in gray color (using ANSI escape codes).
+ */
+export declare function gray(input: string): string;
+/**
+ * Colors a string in bold color (using ANSI escape codes).
+ */
+export declare function bold(input: string): string;
+/**
+ * Colors a string in underline color (using ANSI escape codes).
+ */
+export declare function underline(input: string): string;
+/**
+ * Colors a string in italic color (using ANSI escape codes).
+ */
+export declare function italic(input: string): string;
+/**
+ * Inverts the color of a string (using ANSI escape codes).
+ */
+export declare function inverse(input: string): string;

package/dist/string-colors.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.red = red;
+exports.green = green;
+exports.yellow = yellow;
+exports.blue = blue;
+exports.cyan = cyan;
+exports.gray = gray;
+exports.bold = bold;
+exports.underline = underline;
+exports.italic = italic;
+exports.inverse = inverse;
+/**
+ * Colors a string in red color (using ANSI escape codes).
+ */
+function red(input) {
+    return `\u001b[31m${input}\u001b[39m`;
+}
+/**
+ * Colors a string in green color (using ANSI escape codes).
+ */
+function green(input) {
+    return `\u001b[32m${input}\u001b[39m`;
+}
+/**
+ * Colors a string in yellow color (using ANSI escape codes).
+ */
+function yellow(input) {
+    return `\u001b[33m${input}\u001b[39m`;
+}
+/**
+ * Colors a string in blue color (using ANSI escape codes).
+ */
+function blue(input) {
+    return `\u001b[34m${input}\u001b[39m`;
+}
+/**
+ * Colors a string in cyan color (using ANSI escape codes).
+ */
+function cyan(input) {
+    return `\u001b[36m${input}\u001b[39m`;
+}
+/**
+ * Colors a string in gray color (using ANSI escape codes).
+ */
+function gray(input) {
+    return `\u001b[90m${input}\u001b[39m`;
+}
+/**
+ * Colors a string in bold color (using ANSI escape codes).
+ */
+function bold(input) {
+    return `\u001b[1m${input}\u001b[22m`;
+}
+/**
+ * Colors a string in underline color (using ANSI escape codes).
+ */
+function underline(input) {
+    return `\u001b[4m${input}\u001b[24m`;
+}
+/**
+ * Colors a string in italic color (using ANSI escape codes).
+ */
+function italic(input) {
+    return `\u001b[3m${input}\u001b[23m`;
+}
+/**
+ * Inverts the color of a string (using ANSI escape codes).
+ */
+function inverse(input) {
+    return `\u001b[7m${input}\u001b[27m`;
+}

package/dist/string.d.ts

@@ -0,0 +1,115 @@
+export declare function upperFirst(s: string): string;
+export declare function lowerFirst(s: string): string;
+/**
+ * Returns a pluralized version of the given string based on the count.
+ */
+export declare function pluralize(s: string, count?: number): string;
+/**
+ * Returns true if the given string is already pluralized.
+ */
+export declare function isPlural(s: string): boolean;
+/**
+ * Type modifier that converts all keys of an object to capitalized versions.
+ */
+export type CapitalizedKeys<T extends Record<string, unknown>> = {
+    [K in keyof T as CapitalizeFirstLetter<string & K>]: T[K];
+};
+/**
+ * Type modifier that converts the first letter of a string to a capital letter.
+ */
+type CapitalizeFirstLetter<S extends string> = `${Capitalize<Extract<S, string>>}`;
+/**
+ * Converts all keys of an object to capitalized versions in a type-safe way.
+ */
+export declare function capitalizeKeys<T extends Record<string, unknown>>(obj: T): CapitalizedKeys<T>;
+/**
+ * Type modifier that converts all keys of an object to uncapitalized versions.
+ */
+export type UncapitalizedKeys<T extends Record<string, unknown>> = {
+    [K in keyof T as UncapitalizeFirstLetter<string & K>]: T[K];
+};
+/**
+ * Type modifier that converts the first letter of a string to an uncapitalized letter.
+ */
+type UncapitalizeFirstLetter<S extends string> = `${Uncapitalize<Extract<S, string>>}`;
+/**
+ * Converts all keys of an object to uncapitalized versions in a type-safe way.
+ */
+export declare function uncapitalizeKeys<T extends Record<string, unknown>>(obj: T): UncapitalizedKeys<T>;
+/**
+ * Returns the same string with a lowercase first letter.
+ */
+export declare function uncapitalize(str: string): string;
+/**
+ * Returns the same string with an uppercase first letter.
+ */
+export declare function capitalize(str: string): string;
+/**
+ * Returns the camelCase version of the given string.
+ *
+ * Camel case examples:
+ *  `toCamelCase('hello world')` -> 'helloWorld',
+ *  `toCamelCase('hello_world')` -> 'helloWorld',
+ *  `toCamelCase('helloWorld')` -> 'helloWorld'
+ *  `toCamelCase('HelloWorld')` -> 'helloWorld'
+ *  `toCamelCase('hello_world')` -> 'helloWorld'
+ */
+export declare function toCamelCase(str: string): string;
+/**
+ * Validates if a string is in camelCase format
+ */
+export declare function isCamelCase(str: string): boolean;
+/**
+ * Returns the PascalCase version of the given string.
+ *
+ * Examples:
+ *   `toPascalCase('hello world')` -> 'HelloWorld'
+ *   `toPascalCase('hello_world')` -> 'HelloWorld'
+ *   `toPascalCase('helloWorld')` -> 'HelloWorld'
+ *   `toPascalCase('Hello-World')` -> 'HelloWorld'
+ *   `toPascalCase('HELLO_WORLD')` -> 'HelloWorld'
+ */
+export declare function toPascalCase(str: string): string;
+/**
+ * Validates if a string is in PascalCase format
+ */
+export declare function isPascalCase(str: string): boolean;
+/**
+ * Returns the snake_case version of the given string.
+ *
+ * Examples:
+ *   `toSnakeCase('hello world')` -> 'hello_world'
+ *   `toSnakeCase('helloWorld')` -> 'hello_world'
+ *   `toSnakeCase('HelloWorld')` -> 'hello_world'
+ *   `toSnakeCase('HELLO_WORLD')` -> 'hello_world'
+ */
+export declare function toSnakeCase(str: string): string;
+/**
+ * Validates if a string is in snake_case format
+ */
+export declare function isSnakeCase(str: string): boolean;
+/**
+ * Converts each line of a string to a commented line
+ */
+export declare function commentLines(lines: string): string;
+export declare function toHumanReadable(input: string): string;
+export type Conjugated = {
+    PascalCase: string;
+    PascalCasePlural: string;
+    camelCase: string;
+    camelCasePlural: string;
+    snake_case: string;
+    snake_case_plural: string;
+    pluralized: string;
+    uncapitalizedPlural: string;
+    uncapitalized: string;
+    capitalized: string;
+    capitalizedPlural: string;
+};
+/**
+ * Provide all relevant conjugation of a name
+ */
+export declare function conjugateNames(name: string): Conjugated;
+export declare function slugify(str: string): string;
+export declare function isSlug(str: string): boolean;
+export {};