@postxl/utils 0.1.8

package/LICENSE

@@ -0,0 +1,22 @@
+(The MIT License)
+
+Copyright (c) 2020 @catamphetamine <purecatamphetamine@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/README.md

@@ -0,0 +1,3 @@
+# PXL Utils
+
+`utils` is a selection of utility functions that are used in multiple packages and projects.

package/dist/DefaultMap.d.ts

@@ -0,0 +1,11 @@
+/**
+ * A map extension that returns a default value if the key is not found.
+ */
+export declare class DefaultMap<Key, Value> extends Map<Key, Value> {
+    private readonly _default;
+    /**
+     * A function that returns the default value for the map.
+     */
+    constructor(_default: () => Value);
+    get(key: Key): Value;
+}

package/dist/DefaultMap.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DefaultMap = void 0;
+/**
+ * A map extension that returns a default value if the key is not found.
+ */
+class DefaultMap extends Map {
+    _default;
+    /**
+     * A function that returns the default value for the map.
+     */
+    constructor(_default) {
+        super();
+        this._default = _default;
+    }
+    get(key) {
+        const value = super.get(key);
+        if (value) {
+            return value;
+        }
+        const defaultValue = this._default();
+        this.set(key, defaultValue);
+        return defaultValue;
+    }
+}
+exports.DefaultMap = DefaultMap;

package/dist/NestedMap.d.ts

@@ -0,0 +1,16 @@
+export declare class NestedMap<Key1, Key2, Item> {
+    private readonly getKey1;
+    private readonly getKey2;
+    private readonly _map;
+    constructor(getKey1: (item: Item) => Key1, getKey2: (item: Item) => Key2, items?: Item[]);
+    get(key1: Key1, key2: Key2): Item | undefined;
+    private getKeys;
+    set(item: Item): void;
+    delete(item: Item): void;
+    clear(): void;
+    get size(): number;
+    get keys(): Iterable<Key1>;
+    get values(): Iterable<Item>;
+    get entries(): Iterable<[Key1, Key2, Item]>;
+    get [Symbol.iterator](): Iterable<[Key1, Key2, Item]>;
+}

package/dist/NestedMap.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NestedMap = void 0;
+class NestedMap {
+    getKey1;
+    getKey2;
+    _map = new Map();
+    constructor(getKey1, getKey2, items = []) {
+        this.getKey1 = getKey1;
+        this.getKey2 = getKey2;
+        for (const item of items) {
+            this.set(item);
+        }
+    }
+    get(key1, key2) {
+        const map = this._map.get(key1);
+        if (!map) {
+            return undefined;
+        }
+        return map.get(key2);
+    }
+    getKeys(item) {
+        return [this.getKey1(item), this.getKey2(item)];
+    }
+    set(item) {
+        const [key1, key2] = this.getKeys(item);
+        let map = this._map.get(key1);
+        if (!map) {
+            map = new Map();
+            this._map.set(key1, map);
+        }
+        map.set(key2, item);
+    }
+    delete(item) {
+        const [key1, key2] = this.getKeys(item);
+        const map = this._map.get(key1);
+        if (!map) {
+            return;
+        }
+        map.delete(key2);
+    }
+    clear() {
+        this._map.clear();
+    }
+    get size() {
+        return Array.from(this._map.values()).reduce((sum, map) => sum + map.size, 0);
+    }
+    get keys() {
+        return this._map.keys();
+    }
+    get values() {
+        const values = [];
+        for (const map of this._map.values()) {
+            for (const value of map.values()) {
+                values.push(value);
+            }
+        }
+        return values;
+    }
+    get entries() {
+        const entries = [];
+        for (const [key1, map] of this._map.entries()) {
+            for (const [key2, value] of map.entries()) {
+                entries.push([key1, key2, value]);
+            }
+        }
+        return entries;
+    }
+    get [Symbol.iterator]() {
+        return this.entries;
+    }
+}
+exports.NestedMap = NestedMap;

package/dist/TypedMapping.d.ts

@@ -0,0 +1,26 @@
+type IdentifiersBase = Record<string, string>;
+type Mapping<T> = Map<T, T>;
+/**
+ * A map of typed mappings.
+ */
+export declare class TypedMapping<Identifiers extends IdentifiersBase> {
+    private mappings;
+    constructor(mappings?: {
+        [Model in keyof Identifiers]?: Mapping<Identifiers[Model]>;
+    });
+    /**
+     * Creates a new mapping from the original id to the new id.
+     */
+    set<Model extends keyof Identifiers>({ model, id }: {
+        model: Model;
+        id: Identifiers[Model];
+    }, newId: Identifiers[Model]): this;
+    /**
+     * Returns the id if there exists a mapping, otherwise returns the original id.
+     */
+    get<Model extends keyof Identifiers>({ model, id, }: {
+        model: Model;
+        id: Identifiers[Model];
+    }): Identifiers[Model];
+}
+export {};

package/dist/TypedMapping.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TypedMapping = void 0;
+/**
+ * A map of typed mappings.
+ */
+class TypedMapping {
+    mappings;
+    constructor(mappings = {}) {
+        this.mappings = mappings;
+    }
+    /**
+     * Creates a new mapping from the original id to the new id.
+     */
+    set({ model, id }, newId) {
+        if (!this.mappings[model]) {
+            this.mappings[model] = new Map();
+        }
+        this.mappings[model].set(id, newId);
+        return this;
+    }
+    /**
+     * Returns the id if there exists a mapping, otherwise returns the original id.
+     */
+    get({ model, id, }) {
+        const mapping = this.mappings[model]?.get(id);
+        if (!mapping) {
+            return id;
+        }
+        return mapping;
+    }
+}
+exports.TypedMapping = TypedMapping;

package/dist/array.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Adds a value to a sorted array and keeps the array sorted.
+ *
+ * O(n)
+ */
+export declare function addAndSort<T>(arr: T[], value: T, predicate: (t: T) => number): T[];

package/dist/array.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addAndSort = addAndSort;
+/**
+ * Adds a value to a sorted array and keeps the array sorted.
+ *
+ * O(n)
+ */
+function addAndSort(arr, value, predicate) {
+    arr.push(value);
+    let i = arr.length - 1;
+    const item = arr[i];
+    const order = predicate(item);
+    while (i > 0 && order < predicate(arr[i - 1])) {
+        arr[i] = arr[i - 1];
+        i -= 1;
+    }
+    arr[i] = item;
+    return arr;
+}

package/dist/async.d.ts

@@ -0,0 +1,3 @@
+type AsyncMapFn<T, R> = (item: T, index: number) => Promise<R>;
+export declare function mapLimit<T, R>(arr: T[], iterator: AsyncMapFn<T, R>, limit?: number): Promise<(R | undefined)[]>;
+export {};

package/dist/async.js

@@ -0,0 +1,40 @@
+"use strict";
+//Credit: https://codeburst.io/async-map-with-limited-parallelism-in-node-js-2b91bd47af70
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mapLimit = mapLimit;
+const defaultConcurrency = 5;
+// async maps over all values of an array but limits the number of concurrent operations
+async function mapLimit(arr, iterator, limit = defaultConcurrency) {
+    const result = [];
+    if (arr.length === 0) {
+        return result;
+    }
+    const generator = arrayGenerator(arr);
+    limit = Math.min(limit, arr.length);
+    const workers = new Array(limit);
+    for (let i = 0; i < limit; i++) {
+        workers.push(worker(i, generator, iterator, result));
+    }
+    await Promise.all(workers);
+    return result;
+}
+function* arrayGenerator(array) {
+    for (let index = 0; index < array.length; index++) {
+        const currentValue = array[index];
+        yield [currentValue, index];
+    }
+}
+async function worker(id, gen, mapFn, result) {
+    for (const [currentValue, index] of gen) {
+        result[index] = undefined;
+        if (currentValue === undefined) {
+            return;
+        }
+        try {
+            result[index] = await mapFn(currentValue, index);
+        }
+        catch (e) {
+            console.error(`Worker ${id} --- index ${index} item ${JSON.stringify(currentValue)} failed`, e);
+        }
+    }
+}

package/dist/buffer.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Compares two string or buffer values for equality.
+ */
+export declare function equals(a: string | Buffer, b: string | Buffer): boolean;

package/dist/buffer.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.equals = equals;
+/**
+ * Compares two string or buffer values for equality.
+ */
+function equals(a, b) {
+    if (typeof a === 'string' && typeof b === 'string') {
+        return a === b;
+    }
+    if (Buffer.isBuffer(a) && Buffer.isBuffer(b)) {
+        return a.equals(b);
+    }
+    return false;
+}

package/dist/check-port.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Checks if a port is available.
+ */
+export declare function checkPortAvailability(port: number): Promise<boolean>;

package/dist/check-port.js

@@ -0,0 +1,27 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkPortAvailability = checkPortAvailability;
+const net_1 = __importDefault(require("net"));
+/**
+ * Checks if a port is available.
+ */
+async function checkPortAvailability(port) {
+    return new Promise((resolve) => {
+        const tester = net_1.default.createConnection({ port }, () => {
+            // Port can be connected to, so something is listening on it
+            tester.destroy();
+            resolve(false);
+        });
+        //Port cannot be connected to, so it is available
+        tester.on('error', () => {
+            resolve(true);
+        });
+        // Port is available
+        tester.on('close', () => {
+            resolve(false);
+        });
+    });
+}

package/dist/datetime.d.ts

@@ -0,0 +1,4 @@
+/**
+ * returns the default time stamp in format YYMMDD HHMM
+ */
+export declare function timeStamp(): string;

package/dist/datetime.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.timeStamp = timeStamp;
+/**
+ * returns the default time stamp in format YYMMDD HHMM
+ */
+function timeStamp() {
+    const date = new Date();
+    const year = date.getFullYear().toString().slice(-2);
+    const month = (date.getMonth() + 1).toString().padStart(2, '0');
+    const day = date.getDate().toString().padStart(2, '0');
+    const hour = date.getHours().toString().padStart(2, '0');
+    const minute = date.getMinutes().toString().padStart(2, '0');
+    return `${year}${month}${day} ${hour}${minute}`;
+}

package/dist/dictionary.d.ts

@@ -0,0 +1,8 @@
+export type Dictionary<Value, Key extends string = string> = Record<Key, Value>;
+export declare function toDict<Value, Key extends string = string>(data: Value[], keyFn: (item: Value) => Key): Dictionary<Value, Key>;
+export declare function idToDict<T extends {
+    id: string | number;
+}>(data: T[]): Dictionary<T>;
+export declare function mapDict<S, T>(dict: Dictionary<S>, predicate: (item: S) => T): Dictionary<T>;
+export declare function filterDict<T>(dict: Dictionary<T>, predicate: (item: T) => boolean): Dictionary<T>;
+export declare function dictGetAndAssert<Key extends string, Value>(dict: Dictionary<Value>, key: Key): NonNullable<Value>;

package/dist/dictionary.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toDict = toDict;
+exports.idToDict = idToDict;
+exports.mapDict = mapDict;
+exports.filterDict = filterDict;
+exports.dictGetAndAssert = dictGetAndAssert;
+function toDict(data, keyFn) {
+    const result = {};
+    for (const item of data) {
+        result[keyFn(item)] = item;
+    }
+    return result;
+}
+function idToDict(data) {
+    const result = {};
+    for (const item of data) {
+        result[item.id.toString()] = item;
+    }
+    return result;
+}
+function mapDict(dict, predicate) {
+    const result = {};
+    for (const [key, value] of Object.entries(dict)) {
+        result[key] = predicate(value);
+    }
+    return result;
+}
+function filterDict(dict, predicate) {
+    const result = {};
+    for (const [key, value] of Object.entries(dict)) {
+        if (predicate(value)) {
+            result[key] = value;
+        }
+    }
+    return result;
+}
+function dictGetAndAssert(dict, key) {
+    const value = dict[key];
+    if (value === null || value === undefined) {
+        throw new Error(`Key ${key} not found`);
+    }
+    return value;
+}

package/dist/format.d.ts

@@ -0,0 +1 @@
+export declare function format(n: number, locale?: string): string;

package/dist/format.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.format = format;
+function format(n, locale = 'en-US') {
+    return new Intl.NumberFormat(locale).format(n);
+}

package/dist/group-by.d.ts

@@ -0,0 +1,8 @@
+export declare const groupBy: <T, U extends string | number>(predicate: (x: T) => U, items: T[]) => Partial<Record<U, T[]>>;
+export declare const groupByCurried: <T, U extends string | number>(predicate: (x: T) => U) => ((items: T[]) => Partial<Record<U, T[]>>);
+export declare const groupByToDict: <Id extends string | number, WithId extends {
+    id: Id;
+}, GroupId extends string | number>(predicate: (x: WithId) => GroupId, items: WithId[]) => Partial<Record<GroupId, Record<Id, WithId>>>;
+export declare const groupByToMap: <T extends {
+    id: ItemID;
+}, ItemID extends string | number, GroupID extends string | number>(getGroupId: (x: T) => GroupID, items: T[]) => Map<GroupID, Map<ItemID, T>>;

package/dist/group-by.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.groupByToMap = exports.groupByToDict = exports.groupByCurried = exports.groupBy = void 0;
+const groupBy = (predicate, items) => {
+    const result = {};
+    for (const item of items) {
+        const key = predicate(item);
+        const group = result[key];
+        if (group === undefined) {
+            result[key] = [item];
+        }
+        else {
+            group.push(item);
+        }
+    }
+    return result;
+};
+exports.groupBy = groupBy;
+const groupByCurried = (predicate) => {
+    const result = {};
+    return (items) => {
+        for (const item of items) {
+            const key = predicate(item);
+            const group = result[key];
+            if (group === undefined) {
+                result[key] = [item];
+            }
+            else {
+                group.push(item);
+            }
+        }
+        return result;
+    };
+};
+exports.groupByCurried = groupByCurried;
+const groupByToDict = (predicate, items) => {
+    const result = {};
+    for (const item of items) {
+        const key = predicate(item);
+        const group = result[key];
+        if (group === undefined) {
+            result[key] = { [item.id]: item };
+        }
+        else {
+            group[item.id] = item;
+        }
+    }
+    return result;
+};
+exports.groupByToDict = groupByToDict;
+const groupByToMap = (getGroupId, items) => {
+    const result = new Map();
+    for (const item of items) {
+        const groupId = getGroupId(item);
+        if (!result.has(groupId)) {
+            result.set(groupId, new Map());
+        }
+        const group = result.get(groupId);
+        if (group !== undefined) {
+            group.set(item.id, item);
+        }
+    }
+    return result;
+};
+exports.groupByToMap = groupByToMap;

package/dist/index.d.ts

@@ -0,0 +1,25 @@
+export * from './DefaultMap';
+export * from './NestedMap';
+export * from './TypedMapping';
+export * from './array';
+export * from './async';
+export * from './buffer';
+export * from './check-port';
+export * from './datetime';
+export * from './dictionary';
+export * from './format';
+export * from './group-by';
+export * from './map';
+export * from './omit';
+export * from './pagination';
+export * from './random';
+export * from './remove-secrets';
+export * from './remove-undefined';
+export * from './result';
+export * from './sort';
+export * from './string-colors';
+export * from './string';
+export * from './types';
+export * from './uniq';
+export * from './zod';
+export * from './zod-excel.decoders';

package/dist/index.js

@@ -0,0 +1,41 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./DefaultMap"), exports);
+__exportStar(require("./NestedMap"), exports);
+__exportStar(require("./TypedMapping"), exports);
+__exportStar(require("./array"), exports);
+__exportStar(require("./async"), exports);
+__exportStar(require("./buffer"), exports);
+__exportStar(require("./check-port"), exports);
+__exportStar(require("./datetime"), exports);
+__exportStar(require("./dictionary"), exports);
+__exportStar(require("./format"), exports);
+__exportStar(require("./group-by"), exports);
+__exportStar(require("./map"), exports);
+__exportStar(require("./omit"), exports);
+__exportStar(require("./pagination"), exports);
+__exportStar(require("./random"), exports);
+__exportStar(require("./remove-secrets"), exports);
+__exportStar(require("./remove-undefined"), exports);
+__exportStar(require("./result"), exports);
+__exportStar(require("./sort"), exports);
+__exportStar(require("./string-colors"), exports);
+__exportStar(require("./string"), exports);
+__exportStar(require("./types"), exports);
+__exportStar(require("./uniq"), exports);
+__exportStar(require("./zod"), exports);
+__exportStar(require("./zod-excel.decoders"), exports);

package/dist/is-object.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Returns true if the value is an object, false otherwise.
+ */
+export declare function isObject(value: unknown): value is Record<string, unknown>;
+/**
+ * Only returns true for plain objects, not for classes or functions
+ */
+export declare function isPlainObject(value: unknown): value is Record<string, unknown>;
+/**
+ * Returns true if the value is a function, false otherwise.
+ */
+export declare function isFunction(value: unknown): value is Function;

package/dist/is-object.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isObject = isObject;
+exports.isPlainObject = isPlainObject;
+exports.isFunction = isFunction;
+/**
+ * Returns true if the value is an object, false otherwise.
+ */
+function isObject(value) {
+    return typeof value === 'object' && value !== null;
+}
+/**
+ * Only returns true for plain objects, not for classes or functions
+ */
+function isPlainObject(value) {
+    return value !== null && typeof value === 'object' && value.constructor === Object;
+}
+/**
+ * Returns true if the value is a function, false otherwise.
+ */
+// eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
+function isFunction(value) {
+    return typeof value === 'function';
+}

package/dist/map.d.ts

@@ -0,0 +1,22 @@
+export declare function mapMap<Key, ValueFrom, ValueTo>(map: Map<Key, ValueFrom>, predicate: (item: ValueFrom, key: Key) => ValueTo): Map<Key, ValueTo>;
+export declare function mapMapValues<Key, ValueFrom, ValueTo>(map: Map<Key, ValueFrom>, predicate: (item: ValueFrom, key: Key) => ValueTo): ValueTo[];
+/**
+ *
+ */
+export declare function mapMapKeyValues<KeyFrom, KeyTo, ValueFrom, ValueTo>(map: Map<KeyFrom, ValueFrom>, keyPredicate: (key: KeyFrom, value: ValueFrom) => KeyTo, valuePredicate: (item: ValueFrom, key: KeyFrom) => ValueTo): Map<KeyTo, ValueTo>;
+/**
+ * Maps keys of a map.
+ */
+export declare function mapMapKeys<KeyFrom, KeyTo, Value>(map: Map<KeyFrom, Value>, keyPredicate: (key: KeyFrom, value: Value) => KeyTo): Map<KeyTo, Value>;
+/**
+ * Filters values from a map.
+ */
+export declare function filterMap<Key, Value>(map: Map<Key, Value>, predicate: (item: Value, key: Key) => boolean): Map<Key, Value>;
+/**
+ * Gets a value from a map and asserts that it exists.
+ */
+export declare function mapGetAndAssert<Key, Value>(map: Map<Key, Value>, key: Key): Value;
+/**
+ * Converts a map to a dictionary.
+ */
+export declare function mapToDict<Key extends string | number, Value>(map: Map<Key, Value>): Record<Key, Value>;