zilla-util 1.2.27

package/src/deep.ts

@@ -0,0 +1,348 @@
+export type ObjectNav = {
+    append?: boolean;
+    remove?: number;
+    next?: string | number;
+};
+
+export const parseDeep = (fieldPath: string): ObjectNav[] => {
+    const parts = fieldPath.split(".");
+    const operations: ObjectNav[] = [];
+    for (let i = 0; i < parts.length; i++) {
+        const part = parts[i];
+        let squareBracketStart = part.indexOf("[");
+        if (squareBracketStart !== -1) {
+            const field = part.substring(0, squareBracketStart);
+            operations.push({ next: field });
+            while (squareBracketStart !== -1) {
+                const squareBracketEnd = part.indexOf("]", squareBracketStart);
+                if (squareBracketEnd === -1) {
+                    throw new Error(`parseDeep: invalid fieldPath (missing closing square bracket): ${fieldPath}`);
+                }
+                const index = part.substring(squareBracketStart + 1, squareBracketEnd);
+                if (index.length === 0) {
+                    operations.push({ append: true });
+                } else if (index.startsWith("-")) {
+                    operations.push({ remove: parseInt(index.substring(1)) });
+                } else {
+                    operations.push({ next: parseInt(index) });
+                }
+                squareBracketStart = part.indexOf("[", squareBracketEnd);
+            }
+        } else {
+            operations.push({ next: part });
+        }
+    }
+    // coalesce append operations into their preceding next
+    const ops = [];
+    let opsIndex = 0;
+    for (let i = 0; i < operations.length; i++) {
+        if (operations[i].append && opsIndex > 0) {
+            ops[opsIndex - 1].append = true;
+        } else {
+            ops[opsIndex] = operations[i];
+            opsIndex++;
+        }
+    }
+    return ops;
+};
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export const deepGet = <T>(obj: any, fieldPath: string): T | undefined => {
+    const operations = parseDeep(fieldPath);
+
+    let thing = obj;
+    for (let i = 0; i < operations.length; i++) {
+        const op = operations[i];
+        if (op.append) {
+            throw new Error(`deepGet: invalid fieldPath (cannot append): ${fieldPath}`);
+        }
+        if (op.remove) {
+            throw new Error(`deepGet: invalid fieldPath (cannot remove): ${fieldPath}`);
+        }
+        const next = op.next;
+        if (typeof next === "string" || typeof next === "number") {
+            if (typeof thing === "undefined" || thing == null) return undefined;
+            thing = thing[next];
+        }
+    }
+    return thing;
+};
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export const deepUpdate = (obj: any, fieldPath: string, value: any) => {
+    const operations = parseDeep(fieldPath);
+
+    let thing = obj;
+    for (let i = 0; i < operations.length - 1; i++) {
+        const op = operations[i];
+        const next = op.next;
+        if (op.append && next) {
+            if (typeof thing[next] === "undefined" || thing[next] == null) {
+                const nextThing = {};
+                thing[next] = [nextThing];
+                thing = nextThing;
+            } else if (Array.isArray(thing[next])) {
+                thing[next].push({});
+                thing = thing[next][thing[next].length - 1];
+            } else {
+                throw new Error(`deepUpdate: invalid fieldPath (cannot append to non-array): ${fieldPath}`);
+            }
+        } else if (typeof next === "string" || typeof next === "number") {
+            if (!(next in thing)) {
+                thing[next] = {};
+            }
+            thing = thing[next];
+        }
+    }
+
+    const lastOp = operations[operations.length - 1];
+    if (lastOp.append) {
+        if (typeof lastOp.next === "string" || typeof lastOp.next === "number") {
+            if (Array.isArray(thing[lastOp.next])) {
+                thing[lastOp.next].push(value);
+            } else {
+                thing[lastOp.next] = [value];
+            }
+        } else if (lastOp.next && Array.isArray(thing[lastOp.next])) {
+            thing[lastOp.next].push(value);
+        } else if (typeof lastOp.next === "undefined" || lastOp.next == null) {
+            thing.push(value);
+        } else {
+            throw new Error(`deepUpdate: invalid lastOp (${JSON.stringify(lastOp)}), cannot append`);
+        }
+    } else if (typeof lastOp.remove === "number") {
+        thing.splice(lastOp.remove, 1);
+    } else {
+        thing[lastOp.next as string | number] = value;
+    }
+};
+
+export const deepEquals = <T>(object1: T, object2: T): boolean => {
+    if (object1 === object2) return true;
+
+    const keys1 = Object.keys(object1 as Record<keyof T, unknown>) as (keyof T)[];
+    const keys2 = Object.keys(object2 as Record<keyof T, unknown>) as (keyof T)[];
+
+    if (keys1.length === 0 || keys1.length !== keys2.length) {
+        return false;
+    }
+
+    return keys1.every((key) => {
+        const val1 = object1[key];
+        const val2 = object2[key];
+        const areObjects = isObject(val1) && isObject(val2);
+
+        if ((areObjects && !deepEquals(val1, val2)) || (!areObjects && val1 !== val2)) {
+            return false;
+        }
+
+        return true;
+    });
+};
+
+export const deepAtLeastEquals = <T>(subset: Partial<T>, superset: Partial<T>, ignore?: (keyof T)[]): boolean => {
+    if (subset === superset) return true;
+
+    const keysSubset = Object.keys(subset as Record<keyof T, unknown>) as (keyof T)[];
+
+    return keysSubset
+        .filter((k) => !ignore || !ignore.includes(k))
+        .every((key) => {
+            if (!(key in superset)) {
+                return false;
+            }
+
+            const val1 = subset[key];
+            const val2 = superset[key];
+
+            if (val2 === undefined) {
+                // Ensure superset contains the property
+                return false;
+            }
+
+            const areObjects = isObject(val1) && isObject(val2);
+
+            if (areObjects) {
+                return deepAtLeastEquals(val1 as Record<string, unknown>, val2 as Partial<Record<string, unknown>>);
+            }
+
+            return val1 === val2;
+        });
+};
+
+export const isObject = <T>(object: T): boolean => object != null && typeof object === "object";
+
+export const stripNonAlphaNumericKeys = <T>(obj: T, exclude?: RegExp | RegExp[]): T => {
+    const skip: RegExp[] = [];
+    if (Array.isArray(exclude)) {
+        skip.push(...exclude);
+    } else if (exclude) {
+        skip.push(exclude);
+    }
+    for (const key in obj) {
+        // Check if key contains any non-alphanumeric characters
+        if (/[^a-z0-9_]/i.test(key) && !skip.find((s) => s.test(key))) {
+            delete obj[key];
+        } else if (typeof obj[key] === "object" && obj[key] !== null) {
+            // If the value is a nested object or array, recurse into it
+            stripNonAlphaNumericKeys(obj[key], exclude);
+        }
+    }
+    return obj;
+};
+
+export const hasDuplicateProperty = (things: Record<string, unknown>[], prop: string): boolean => {
+    const found = new Set();
+    return things.some((entry) => {
+        if (found.has(entry[prop])) {
+            return true; // Found a duplicate
+        } else {
+            found.add(entry[prop]);
+            return false;
+        }
+    });
+};
+
+export const hasUniqueProperty = (things: Record<string, unknown>[], prop: string): boolean =>
+    !hasDuplicateProperty(things, prop);
+
+export const filterObject = <T>(obj: Record<string, T>, keys: string[]): Record<string, T> =>
+    keys.reduce(
+        (acc: Record<string, T>, key: string) =>
+            // eslint-disable-next-line no-prototype-builtins
+            obj.hasOwnProperty(key) ? { ...acc, [key]: obj[key] } : acc,
+        {}
+    );
+
+export const isEmpty = (obj?: unknown | null | undefined): boolean => {
+    if (typeof obj === "undefined" || obj == null || obj === "" || (Array.isArray(obj) && obj.length === 0)) {
+        return true;
+    } else if (typeof obj === "object") {
+        const fields = Object.keys(obj);
+        if (fields.length === 0) return true;
+        let allEmpty = true;
+        for (const fieldName of Object.keys(obj)) {
+            if (!isEmpty((obj as Record<string, unknown>)[fieldName])) {
+                allEmpty = false;
+                break;
+            }
+        }
+        if (allEmpty) return true;
+    }
+    return false;
+};
+
+export const isNotEmpty = (obj?: unknown | null | undefined): boolean => !isEmpty(obj);
+
+export const filterProperties = (obj: Record<string, unknown>, propNames: string[]): Record<string, unknown> => {
+    return propNames.reduce((acc, prop) => {
+        if (Object.prototype.hasOwnProperty.call(obj, prop)) {
+            acc[prop] = obj[prop];
+        }
+        return acc;
+    }, {} as Record<string, unknown>);
+};
+
+export const deepEqualsForFields = (
+    o1: Record<string, unknown>,
+    o2: Record<string, unknown>,
+    propNames: string[]
+): boolean => {
+    const t1 = filterProperties(o1, propNames);
+    const t2 = filterProperties(o2, propNames);
+    return deepEquals(t1, t2);
+};
+
+export const FN_ALWAYS_TRUE = () => true;
+export const FN_ALWAYS_FALSE = () => false;
+
+const proxyCache = new WeakMap<object, unknown>();
+const arrayMutators = new Set([
+    "push",
+    "pop",
+    "shift",
+    "unshift",
+    "splice",
+    "sort",
+    "reverse",
+    "fill",
+    "copyWithin",
+    "append",
+]);
+
+export const immutify = <T>(obj: T): T => {
+    if (obj === null || typeof obj !== "object") return obj;
+    if (proxyCache.has(obj)) return proxyCache.get(obj) as T;
+
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const handler: ProxyHandler<any> = Array.isArray(obj)
+        ? {
+              get(target, prop, receiver) {
+                  if (typeof prop === "string" && arrayMutators.has(prop)) return () => undefined;
+                  const value = Reflect.get(target, prop, receiver);
+                  return value && typeof value === "object" ? immutify(value) : value;
+              },
+              set: FN_ALWAYS_TRUE,
+              deleteProperty: FN_ALWAYS_TRUE,
+              defineProperty: FN_ALWAYS_TRUE,
+              setPrototypeOf: FN_ALWAYS_TRUE,
+          }
+        : {
+              get(target, prop, receiver) {
+                  const value = Reflect.get(target, prop, receiver);
+                  return value && typeof value === "object" ? immutify(value) : value;
+              },
+              set: FN_ALWAYS_TRUE,
+              deleteProperty: FN_ALWAYS_TRUE,
+              defineProperty: FN_ALWAYS_TRUE,
+              setPrototypeOf: FN_ALWAYS_TRUE,
+          };
+
+    const proxy = new Proxy(obj, handler);
+    proxyCache.set(obj, proxy);
+    return proxy;
+};
+
+export const copyWithRegExp = <T>(obj: T): T => {
+    if (obj instanceof RegExp) {
+        return new RegExp(obj.source, obj.flags) as T;
+    }
+    if (Array.isArray(obj)) {
+        const arr: unknown[] = [];
+        for (const item of obj) {
+            arr.push(copyWithRegExp(item));
+        }
+        return arr as T;
+    }
+    if (obj && typeof obj === "object") {
+        const newObj: Record<string, unknown> = {};
+        for (const [key, val] of Object.entries(obj)) {
+            newObj[key] = copyWithRegExp(val);
+        }
+        return newObj as T;
+    }
+    return obj;
+};
+
+export const deepTransform = (
+    input: unknown,
+    predicate: (value: unknown) => boolean,
+    transformer: (value: unknown) => unknown
+): unknown => {
+    if (predicate(input)) return transformer(input);
+
+    if (Array.isArray(input)) {
+        return input.map((item) => deepTransform(item, predicate, transformer));
+    }
+
+    if (input !== null && typeof input === "object") {
+        const result: Record<string | number | symbol, unknown> = {};
+        for (const key of Reflect.ownKeys(input)) {
+            const value = (input as Record<string | number | symbol, unknown>)[key];
+            result[key] = deepTransform(value, predicate, transformer);
+        }
+        return result;
+    }
+
+    return input;
+};

package/src/error.ts

@@ -0,0 +1,7 @@
+export const wrapError = (context: string, err: unknown): Error => {
+    if (err instanceof Error) {
+        return new Error(context, { cause: err });
+    } else {
+        return new Error(`${context}: ${String(err)}`);
+    }
+};

package/src/hash.ts

@@ -0,0 +1,20 @@
+import Sha256 from "./sha256.js";
+export const sha256 = (s: unknown) => Sha256.hash(`${s}`);
+
+export const insertAtIndex = (str: string, insert: string, index: number): string => {
+    return str.slice(0, index) + insert + str.slice(index);
+};
+
+export const shaLevels = (val: string | number | boolean, levels: number): string => {
+    return dirLevels(sha256(`${val}`), levels);
+};
+
+export const dirLevels = (val: string | number | boolean, levels: number): string => {
+    let s = `${val}`;
+    if (levels > 0) {
+        for (let i = 0; i < levels; i++) {
+            s = insertAtIndex(s, "/", 2 + 3 * i);
+        }
+    }
+    return s;
+};

package/src/index.ts

@@ -0,0 +1,17 @@
+export * from "./array.js";
+export * from "./base64.js";
+export * from "./crypto.js";
+export * from "./date.js";
+export * from "./deep.js";
+export * from "./error.js";
+export * from "./hash.js";
+export * from "./logger.js";
+export * from "./lru.js";
+export * from "./msg.js";
+export * from "./object.js";
+export * from "./retry.js";
+export * from "./package.js";
+export * from "./string.js";
+export * from "./subst.js";
+export * from "./time.js";
+export * from "./url.js";

package/src/logger.ts

@@ -0,0 +1,35 @@
+export type GenericLogger = {
+    isSilent: () => boolean;
+    isAnyEnabled: () => boolean;
+    isTraceEnabled: () => boolean;
+    isVerboseEnabled: () => boolean;
+    isDebugEnabled: () => boolean;
+    isInfoEnabled: () => boolean;
+    isWarningEnabled: () => boolean;
+    isErrorEnabled: () => boolean;
+    trace: (message: string, ...args: unknown[]) => void;
+    verbose: (message: string, ...args: unknown[]) => void;
+    debug: (message: string, ...args: unknown[]) => void;
+    log: (message: string, ...args: unknown[]) => void;
+    info: (message: string, ...args: unknown[]) => void;
+    warn: (message: string, ...args: unknown[]) => void;
+    error: (message: string, ...args: unknown[]) => void;
+};
+
+export const DEFAULT_LOGGER: GenericLogger = {
+    isSilent: () => false,
+    isAnyEnabled: () => true,
+    isTraceEnabled: () => true,
+    isVerboseEnabled: () => true,
+    isDebugEnabled: () => true,
+    isInfoEnabled: () => true,
+    isWarningEnabled: () => true,
+    isErrorEnabled: () => true,
+    trace: (message: string, ...args: unknown[]) => console.trace(message, ...args),
+    verbose: (message: string, ...args: unknown[]) => console.trace(message, ...args),
+    debug: (message: string, ...args: unknown[]) => console.debug(message, ...args),
+    log: (message: string, ...args: unknown[]) => console.log(message, ...args),
+    info: (message: string, ...args: unknown[]) => console.info(message, ...args),
+    warn: (message: string, ...args: unknown[]) => console.warn(message, ...args),
+    error: (message: string, ...args: unknown[]) => console.error(message, ...args),
+}

package/src/lru.ts

@@ -0,0 +1,187 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { ZillaClock, DEFAULT_CLOCK } from "zilla-util";
+import { GenericLogger } from "./logger.js";
+import {safeStringify} from "./string.js";
+
+export interface LRUCacheConfig {
+    maxSize?: number;
+    maxAge?: number;
+    clock?: ZillaClock;
+    touchOnGet?: boolean;
+    logger?: GenericLogger;
+}
+
+export class LRUCache<K, V> {
+    private readonly maxSize: number;
+    private readonly maxAge?: number;
+    private cache: Map<K, { value: V; timestamp: number }>;
+    private clock: ZillaClock;
+    private touchOnGet?: boolean;
+    private logger?: GenericLogger;
+
+    constructor({ maxSize = 100, maxAge, clock = DEFAULT_CLOCK, touchOnGet = true, logger }: LRUCacheConfig = {}) {
+        if (maxSize <= 0) throw new Error("maxSize must be positive");
+        this.maxSize = maxSize;
+        this.maxAge = maxAge;
+        this.cache = new Map();
+        this.clock = clock;
+        this.touchOnGet = touchOnGet;
+        this.logger = logger;
+        if (this.logger && this.logger.isTraceEnabled()) {
+            if (clock.constructor) {
+                this.logger.trace(`LRUCache.constructor now=${this.clock.now()} using clock=${clock.constructor}`);
+            } else {
+                this.logger.trace(
+                    `LRUCache.constructor now=${this.clock.now()} using clock=${
+                        clock === DEFAULT_CLOCK ? "DEFAULT_CLOCK" : "custom-clock"
+                    }`
+                );
+            }
+        }
+    }
+
+    get(key: K): V | undefined {
+        if (this.logger && this.logger.isTraceEnabled()) {
+            this.logger.trace(`LRUCache.get(${key}) now=${this.clock.now()} starting`);
+        }
+        const entry = this.cache.get(key);
+        if (this.logger && this.logger.isTraceEnabled()) {
+            this.logger.trace(
+                `LRUCache.get(${key}) now=${this.clock.now()} entry=${entry ? safeStringify(entry) : "undefined"}`
+            );
+        }
+        if (!entry) {
+            return undefined;
+        }
+
+        if (this.maxAge !== undefined && this.clock.now() - entry.timestamp > this.maxAge) {
+            if (this.logger && this.logger.isTraceEnabled()) {
+                this.logger.trace(
+                    `LRUCache.get(${key}) now=${this.clock.now()} EXPIRED entry=${
+                        entry ? safeStringify(entry) : "undefined"
+                    }`
+                );
+            }
+            this.cache.delete(key);
+            return undefined;
+        }
+
+        if (this.touchOnGet) {
+            if (this.logger && this.logger.isTraceEnabled()) {
+                this.logger.trace(
+                    `LRUCache.get(${key}) now=${this.clock.now()} TOUCH-ON-GET entry=${
+                        entry ? safeStringify(entry) : "undefined"
+                    }`
+                );
+            }
+            this.cache.delete(key);
+            this.cache.set(key, { ...entry, timestamp: this.clock.now() });
+        }
+        if (this.logger && this.logger.isTraceEnabled()) {
+            this.logger.trace(`LRUCache.get(${key}) now=${this.clock.now()} RETURNING entry.value=${entry.value}`);
+        }
+        return entry.value;
+    }
+
+    set(key: K, value: V): void {
+        if (this.logger && this.logger.isTraceEnabled()) {
+            this.logger.trace(`LRUCache.set(${key}) now=${this.clock.now()} starting`);
+        }
+        if (this.cache.has(key)) {
+            if (this.logger && this.logger.isTraceEnabled()) {
+                this.logger.trace(`LRUCache.set(${key}) now=${this.clock.now()} KEY FOUND DELETING`);
+            }
+            this.cache.delete(key);
+        } else if (this.cache.size >= this.maxSize) {
+            if (this.logger && this.logger.isTraceEnabled()) {
+                this.logger.trace(
+                    `LRUCache.set(${key}) now=${this.clock.now()} this.cache.size=${this.cache.size} >= this.maxSize=${
+                        this.maxSize
+                    } EVICTING`
+                );
+            }
+            this.evict();
+        }
+        if (this.logger && this.logger.isTraceEnabled()) {
+            this.logger.trace(`LRUCache.set(${key}) now=${this.clock.now()} SETTING value=${safeStringify(value)}`);
+        }
+        this.cache.set(key, { value, timestamp: this.clock.now() });
+    }
+
+    private evict(): void {
+        if (this.logger && this.logger.isTraceEnabled()) {
+            this.logger.trace(`LRUCache.evict now=${this.clock.now()} starting`);
+        }
+        const oldestKey = this.cache.keys().next().value;
+        if (oldestKey !== undefined) {
+            if (this.logger && this.logger.isTraceEnabled()) {
+                this.logger.trace(`LRUCache.evict now=${this.clock.now()} DELETING oldestKey=${oldestKey}`);
+            }
+            this.cache.delete(oldestKey);
+        } else {
+            if (this.logger && this.logger.isTraceEnabled()) {
+                this.logger.trace(`LRUCache.evict now=${this.clock.now()} NOTHING TO DELETE oldestKey=undefined`);
+            }
+        }
+    }
+
+    delete(key: K): void {
+        if (this.logger && this.logger.isTraceEnabled()) {
+            this.logger.trace(`LRUCache.delete(${key}) now=${this.clock.now()} starting`);
+        }
+        this.cache.delete(key);
+        if (this.logger && this.logger.isTraceEnabled()) {
+            this.logger.trace(`LRUCache.delete(${key}) now=${this.clock.now()} finished`);
+        }
+    }
+
+    clear(): void {
+        if (this.logger && this.logger.isTraceEnabled()) {
+            this.logger.trace(`LRUCache.clear now=${this.clock.now()} starting`);
+        }
+        this.cache.clear();
+        if (this.logger && this.logger.isTraceEnabled()) {
+            this.logger.trace(`LRUCache.clear now=${this.clock.now()} finished`);
+        }
+    }
+}
+
+export function withLRUCache<V>(
+    fn: (...args: any[]) => Promise<V>,
+    cacheOrConfig?: LRUCache<string, V> | LRUCacheConfig,
+    keyFn?: (...args: any[]) => string
+): (...args: any[]) => Promise<V>;
+
+export function withLRUCache<V>(
+    fn: (...args: any[]) => V,
+    cacheOrConfig?: LRUCache<string, V> | LRUCacheConfig,
+    keyFn?: (...args: any[]) => string
+): (...args: any[]) => V;
+
+export function withLRUCache<V>(
+    fn: (...args: any[]) => V | Promise<V>,
+    cacheOrConfig?: LRUCache<string, V> | LRUCacheConfig,
+    keyFn?: (...args: any[]) => string
+): (...args: any[]) => V | Promise<V> {
+    const cache = cacheOrConfig instanceof LRUCache ? cacheOrConfig : new LRUCache<string, V>(cacheOrConfig);
+
+    const defaultKeyFn = (...args: any[]): string =>
+        JSON.stringify(args, (key, value) => (typeof value === "function" ? value.toString() : value));
+
+    return (...args: any[]): V | Promise<V> => {
+        const key = (keyFn ?? defaultKeyFn)(...args);
+        const cachedValue = cache.get(key);
+        if (cachedValue !== undefined) return cachedValue;
+
+        const result = fn(...args);
+        if (result instanceof Promise) {
+            return result.then((resolvedResult) => {
+                cache.set(key, resolvedResult);
+                return resolvedResult;
+            });
+        } else {
+            cache.set(key, result);
+            return result;
+        }
+    };
+}

package/src/msg.ts

@@ -0,0 +1,33 @@
+export enum ZillaMsgTransportType {
+    email = "email",
+    sms = "sms",
+}
+
+export const MESSAGE_TYPE_VALUES: ZillaMsgTransportType[] = Object.values(ZillaMsgTransportType);
+
+export type ZillaMsgRecipient = {
+    name?: string;
+    destination: string;
+};
+
+export type ZillaMessage = {
+    transport: string;
+    type: ZillaMsgTransportType;
+    via: string;
+    template: string;
+    locale: string;
+    from: string;
+    to: string;
+    messages: Record<string, string>;
+    ctime: number;
+};
+
+export type ZillaMsgTransport = {
+    name: string;
+    type: ZillaMsgTransportType;
+    sender: string;
+    via: () => string;
+    templates: string[];
+    formatTo: (recipient: ZillaMsgRecipient) => string;
+    send: (recipient: ZillaMsgRecipient, rendered: Record<string, string>) => Promise<unknown>;
+};

package/src/object.ts

@@ -0,0 +1,43 @@
+import { SortedSet } from "./array.js";
+
+export type EmptyObjectType = Record<string, never>;
+
+export const keysByValue = <K extends string, V>(obj: Record<K, V>, val: V): K[] => {
+    return (Object.keys(obj) as K[]).filter((k) => obj[k] === val);
+};
+
+export const firstKeyByValue = <K extends string, V>(obj: Record<K, V>, val: V): K | undefined => {
+    return (Object.keys(obj) as K[]).find((k) => obj[k] === val);
+};
+
+export const enumRecord = <E extends string | number | symbol, V>(
+    e: Record<string, E>,
+    init: V | ((e?: E) => V)
+): Record<E, V> => {
+    const o = {} as Record<E, V>;
+    for (const k of Object.values(e) as E[]) {
+        o[k] = typeof init === "function" ? (init as (e?: E) => V)(k) : init;
+    }
+    return o;
+};
+
+export const setsToArrays = <K extends string, V>(input: Record<K, SortedSet<V>>): Record<K, V[]> =>
+    Object.fromEntries(Object.entries(input).map(([k, set]) => [k, (set as SortedSet<V>).toArray()])) as Record<K, V[]>;
+
+export const findDuplicates = <T>(items: T[], field: keyof T): string[] => {
+    const counts = new Map<string, number>();
+    for (const item of items) {
+        const key = String(item[field]);
+        counts.set(key, (counts.get(key) ?? 0) + 1);
+    }
+    return [...counts].filter(([, n]) => n > 1).map(([k]) => k);
+};
+
+export const reverseEnum = <E extends Record<string, string>>(enumObj: E): Record<string, string> => {
+    const rev: Record<string, string> = {};
+    (Object.keys(enumObj) as Array<keyof E>).forEach((key: keyof E): void => {
+        const value: string = enumObj[key];
+        rev[value] = key as string;
+    });
+    return rev;
+};