@openstax/ts-utils 1.1.30 → 1.1.31

package/dist/esm/index.d.ts

@@ -1,29 +1,4 @@
-import { UnionToIntersection } from './types';
-export declare const getKeyValue: <K extends string>(key: K) => <O extends { [key in K]?: any; }>(obj: O) => O[K];
-export declare const getKeyValueOr: <K extends string, V, Od extends { [key in K]?: any; } = { [key_1 in K]?: any; }>(key: K, defaultValue: V) => <O extends Od extends undefined ? { [key_2 in K]?: any; } : Od>(obj: O) => V | NonNullable<O[K]>;
-export declare const putKeyValue: <K extends string>(key: K) => <O extends { [key in K]?: any; }>(obj: O, value: O[K]) => O;
-export declare const coerceArray: <T>(thing: T | T[] | undefined) => T[];
-declare type FlowFn<A, R> = (...args: [A]) => R;
-declare type AnyFlowFn = FlowFn<any, any>;
-declare type FlowFnResult<F, A> = F extends FlowFn<A, infer R> ? R : never;
-declare type FlowResult<C, A> = C extends [infer F1, ...infer Cr] ? F1 extends AnyFlowFn ? Cr extends never[] ? FlowFnResult<F1, A> : FlowResult<Cr, FlowFnResult<F1, A>> : never : never;
-declare type FlowChainArg<C> = C extends [infer F1, ...infer _] ? F1 extends FlowFn<infer A, any> ? A : never : never;
-export declare const flow: <C extends AnyFlowFn[]>(...chain: C) => (param: FlowChainArg<C>) => FlowResult<C, FlowChainArg<C>>;
-export declare const fnIf: <T1, T2>(condition: boolean, trueValue: T1, falseValue: T2) => T1 | T2;
-export declare const mapFind: <I, R>(array: I[], mapper: (item: I) => R, predicate?: (result: R) => boolean) => R | undefined;
-declare type HashValue = string | number | boolean | null | HashCompoundValue;
-declare type HashCompoundValue = Array<HashValue> | {
-    [key: string]: HashValue;
-};
-export declare const hashValue: (value: HashValue) => string;
-export declare const once: <F extends (...args: any[]) => any>(fn: F) => F;
-export declare const partitionSequence: <T, P>(getPartition: (thing: T, previous?: P | undefined) => {
-    matches?: boolean | undefined;
-    value: P;
-}, sequence: T[]) => [P, T[]][];
-export declare const memoize: <F extends (...args: any[]) => any>(fn: F) => F;
-export declare const roundToPrecision: (num: number, places: number) => number;
-export declare const getCommonProperties: <T1 extends {}, T2 extends {}>(thing1: T1, thing2: T2) => (keyof T1 & keyof T2)[];
-export declare const merge: <T extends {}[]>(...[thing1, ...tail]: T) => UnionToIntersection<T[number]>;
-export declare const tuple: <A extends any[]>(...args: A) => A;
-export {};
+export * from './misc/partitionSequence';
+export * from './misc/helpers';
+export * from './misc/merge';
+export * from './misc/hashValue';

package/dist/esm/index.js

@@ -1,210 +1,4 @@
-import { createHash } from 'crypto';
-import deepEqual from 'deep-equal';
-import { isPlainObject } from './guards';
-/*
- * there was a reason i made these instead of using lodash/fp but i forget what it was. i think maybe
- * these do more validation that the second function gets a compatible object.
- *
- * const getAuthor = getKeyValue('author');
- * const author = getAuthor(book);
- *
- * const getAuthorOrNope = getKeyValueOr('author', 'nope');
- * const authorOrNope = getAuthorOrNope(book);
- *
- * const putAuthor = putKeyValue('author');
- * const newBook = putAuthor(book, 'tom');
- * */
-export const getKeyValue = (key) => (obj) => obj[key];
-export const getKeyValueOr = (key, defaultValue) => (obj) => obj[key] || defaultValue;
-export const putKeyValue = (key) => (obj, value) => ({ ...obj, [key]: value });
-export const coerceArray = (thing) => thing instanceof Array ? thing : thing !== undefined ? [thing] : [];
-/*
- * this is like lodash/flow but it uses a recursive type instead of hard-coding parameters
- */
-export const flow = (...chain) => (param) => {
-    let result = param;
-    for (const fn of chain) {
-        result = fn(result);
-    }
-    return result;
-};
-/*
- * a shameful helper to avoid needing to test code coverage of branches
- */
-export const fnIf = (condition, trueValue, falseValue) => condition ? trueValue : falseValue;
-/*
- * maps the array and returns the first result that matches the predicate
- * avoids processing extra elements that would happen with .map().find() or .reduce
- *
- * eg the third element of the array is never processed:
- *   const result = mapFind([1,2,3], x => 'hello'.charAt(x), x => x === 'l');
- */
-export const mapFind = (array, mapper, predicate = (r) => !!r) => {
-    for (const item of array) {
-        const mapped = mapper(item);
-        if (predicate(mapped)) {
-            return mapped;
-        }
-    }
-};
-/*
- * creates a string hash of lots of different kinds of things.
- *
- * eg:
- *   hashValue({someKey: 'someValue'})
- * */
-export const hashValue = (value) => {
-    // hack for sorting keys https://stackoverflow.com/a/53593328/14809536
-    const allKeys = new Set();
-    JSON.stringify(value, (k, v) => (allKeys.add(k), v));
-    const strValue = JSON.stringify(value, Array.from(allKeys).sort());
-    return createHash('sha1').update(strValue).digest('hex');
-};
-/*
- * returns a function that will only ever call the given function once, returning the first result for every subsequent call
- *
- * eg:
- *   const heavyFunction = () => 'hello';
- *   const butOnlyOnce = once(() => 'hello');
- *
- *   heavyFunction() // returns `hello`;
- *   butOnlyOnce() // returns `hello`;
- */
-export const once = (fn) => {
-    const initialValue = {};
-    let result = initialValue;
-    return ((...args) => result === initialValue ? (result = fn(...args)) : result);
-};
-/*
- * partitions a sequence based on a partition function returning {value: any; matches?: boolean}
- *  - if the function returns `matches` explicitly then adjacent matching elements will
- *    be grouped and the predicate value in the result will be from the last item in the group
- *  - if the function returns only a value then matching will be evaluated based on the deep
- *    equality of the value with its neighbors
- *
- * this is different from lodash/partition and lodash/groupBy because:
- *  - it preserves the order of the items, items will only be grouped if they are already adjacent
- *  - there can be any number of groups
- *  - it tells you the partition value
- *  - the partition value can be reduced, if you care (so you can like, partition on sequential values)
- *
- *  simple predicate:
- *    returns: [[0, [1,2]], [1, [3,4,5]]]
- *    partitionSequence((n: number) => ({value: Math.floor(n / 3)}), [1,2,3,4,5])
- *
- *  mutating partition:
- *    returns: [
- *      [{min: 1,max: 3}, [1,2,3]],
- *      [{min: 5,max: 6}, [5,6]],
- *      [{min: 8,max: 8}, [8]],
- *    ]
- *    partitionSequence(
- *      (n: number, p?: {min: number; max: number}) =>
- *        p && p.max + 1 === n
- *          ? {value: {...p, max: n}, matches: true}
- *          : {value: {min: n, max: n}, matches: false}
- *      , [1,2,3,5,6,8]
- *    )
- */
-export const partitionSequence = (getPartition, sequence) => {
-    const appendItem = (result, item) => {
-        const current = result[result.length - 1];
-        const itemPartition = getPartition(item, current === null || current === void 0 ? void 0 : current[0]);
-        if (current && ((itemPartition.matches === undefined && deepEqual(current[0], itemPartition.value))
-            || itemPartition.matches)) {
-            current[0] = itemPartition.value;
-            current[1].push(item);
-        }
-        else {
-            result.push([itemPartition.value, [item]]);
-        }
-        return result;
-    };
-    return sequence.reduce(appendItem, []);
-};
-/*
- * memoizes a function with any number of arguments
- */
-export const memoize = (fn) => {
-    const cache = {};
-    const resolveCache = (cacheLayer, [first, ...rest]) => {
-        if (!first) {
-            return cacheLayer;
-        }
-        const layers = first instanceof Object
-            ? (cacheLayer.weakLayers = (cacheLayer.weakLayers || (typeof WeakMap === 'undefined' ? undefined : new WeakMap())))
-            : (cacheLayer.strongLayers = (cacheLayer.strongLayers || new Map()));
-        // argument is an object and WeakMap is not supported
-        if (!layers) {
-            return {};
-        }
-        const layer = layers.get(first) || {};
-        if (!layers.has(first)) {
-            layers.set(first, layer);
-        }
-        return resolveCache(layer, rest);
-    };
-    return ((...args) => {
-        const thisCache = resolveCache(cache, args);
-        return thisCache.result = (thisCache.result || fn(...args));
-    });
-};
-/*
- * rounds number to given number of places
- *
- * eg:
- *  roundToPrecision(1234.123, 2); // returns 1200
- *  roundToPrecision(1234.123, -2); // returns 1234.12
- *  roundToPrecision(1234.125, -2); // returns 1234.13
- */
-export const roundToPrecision = (num, places) => {
-    const multiplier = Math.pow(10, -1 * places);
-    // https://stackoverflow.com/a/11832950/14809536
-    return Math.round((num + Number.EPSILON) * multiplier) / multiplier;
-};
-export const getCommonProperties = (thing1, thing2) => Object.keys(thing1).filter((key) => Object.keys(thing2).includes(key));
-/*
- * recursive merge properties of inputs. values are merged if they are
- * plain objects or arrays, otherwise if the same property exists in both
- * objects the value from the second argument will win.
- *
- * unlike lodash merge, this will not change object references for values that
- * exist only in one parameter.
- *
- * eg:
- *   merge({thing: 'one'}, {thing: 'two', otherKey: 'one'}, {coolKey: 'coolValue'});
- */
-export const merge = (...[thing1, ...tail]) => {
-    const mergedTail = tail.length > 0
-        ? merge(...tail)
-        : null;
-    if (!mergedTail) {
-        return thing1;
-    }
-    return {
-        ...thing1,
-        ...mergedTail,
-        ...getCommonProperties(thing1, mergedTail).reduce((result, property) => ({
-            ...result,
-            ...(isPlainObject(thing1[property]) && isPlainObject(mergedTail[property])
-                ? { [property]: merge(thing1[property], mergedTail[property]) }
-                : (Array.isArray(thing1[property]) && Array.isArray(mergedTail[property]))
-                    ? { [property]: [...thing1[property], ...mergedTail[property]] }
-                    : {}),
-        }), {}),
-    };
-};
-/*
- * a silly utility to help typescript realize an array is a tuple
- *
- * eg:
- *  const a = [5, 'string'] // type is `Array<string | number>`
- *  const t = tuple(5, 'string') type is `[5, 'string']`
- *
- * both have the same javascript value, but one is forced to be a tuple, which
- * is nice if its structure is important. examples are like the React.useState
- * pattern where there are two return values in a tuple, or if you're feeding
- * Object.fromEntries
- *
- */
-export const tuple = (...args) => args;
+export * from './misc/partitionSequence';
+export * from './misc/helpers';
+export * from './misc/merge';
+export * from './misc/hashValue';

package/dist/esm/misc/hashValue.d.ts

@@ -0,0 +1,6 @@
+declare type HashValue = string | number | boolean | null | HashCompoundValue;
+declare type HashCompoundValue = Array<HashValue> | {
+    [key: string]: HashValue;
+};
+export declare const hashValue: (value: HashValue) => string;
+export {};

package/dist/esm/misc/hashValue.js

@@ -0,0 +1,14 @@
+import { createHash } from 'crypto';
+/*
+ * creates a string hash of lots of different kinds of things.
+ *
+ * eg:
+ *   hashValue({someKey: 'someValue'})
+ * */
+export const hashValue = (value) => {
+    // hack for sorting keys https://stackoverflow.com/a/53593328/14809536
+    const allKeys = new Set();
+    JSON.stringify(value, (k, v) => (allKeys.add(k), v));
+    const strValue = JSON.stringify(value, Array.from(allKeys).sort());
+    return createHash('sha1').update(strValue).digest('hex');
+};

package/dist/esm/misc/helpers.d.ts

@@ -0,0 +1,17 @@
+export declare const getKeyValue: <K extends string>(key: K) => <O extends { [key in K]?: any; }>(obj: O) => O[K];
+export declare const getKeyValueOr: <K extends string, V, Od extends { [key in K]?: any; } = { [key_1 in K]?: any; }>(key: K, defaultValue: V) => <O extends Od extends undefined ? { [key_2 in K]?: any; } : Od>(obj: O) => V | NonNullable<O[K]>;
+export declare const putKeyValue: <K extends string>(key: K) => <O extends { [key in K]?: any; }>(obj: O, value: O[K]) => O;
+export declare const coerceArray: <T>(thing: T | T[] | undefined) => T[];
+declare type FlowFn<A, R> = (...args: [A]) => R;
+declare type AnyFlowFn = FlowFn<any, any>;
+declare type FlowFnResult<F, A> = F extends FlowFn<A, infer R> ? R : never;
+declare type FlowResult<C, A> = C extends [infer F1, ...infer Cr] ? F1 extends AnyFlowFn ? Cr extends never[] ? FlowFnResult<F1, A> : FlowResult<Cr, FlowFnResult<F1, A>> : never : never;
+declare type FlowChainArg<C> = C extends [infer F1, ...infer _] ? F1 extends FlowFn<infer A, any> ? A : never : never;
+export declare const flow: <C extends AnyFlowFn[]>(...chain: C) => (param: FlowChainArg<C>) => FlowResult<C, FlowChainArg<C>>;
+export declare const fnIf: <T1, T2>(condition: boolean, trueValue: T1, falseValue: T2) => T1 | T2;
+export declare const mapFind: <I, R>(array: I[], mapper: (item: I) => R, predicate?: (result: R) => boolean) => R | undefined;
+export declare const once: <F extends (...args: any[]) => any>(fn: F) => F;
+export declare const memoize: <F extends (...args: any[]) => any>(fn: F) => F;
+export declare const roundToPrecision: (num: number, places: number) => number;
+export declare const tuple: <A extends any[]>(...args: A) => A;
+export {};

package/dist/esm/misc/helpers.js

@@ -0,0 +1,115 @@
+/*
+ * there was a reason i made these instead of using lodash/fp but i forget what it was. i think maybe
+ * these do more validation that the second function gets a compatible object.
+ *
+ * const getAuthor = getKeyValue('author');
+ * const author = getAuthor(book);
+ *
+ * const getAuthorOrNope = getKeyValueOr('author', 'nope');
+ * const authorOrNope = getAuthorOrNope(book);
+ *
+ * const putAuthor = putKeyValue('author');
+ * const newBook = putAuthor(book, 'tom');
+ * */
+export const getKeyValue = (key) => (obj) => obj[key];
+export const getKeyValueOr = (key, defaultValue) => (obj) => obj[key] || defaultValue;
+export const putKeyValue = (key) => (obj, value) => ({ ...obj, [key]: value });
+export const coerceArray = (thing) => thing instanceof Array ? thing : thing !== undefined ? [thing] : [];
+/*
+ * this is like lodash/flow but it uses a recursive type instead of hard-coding parameters
+ */
+export const flow = (...chain) => (param) => {
+    let result = param;
+    for (const fn of chain) {
+        result = fn(result);
+    }
+    return result;
+};
+/*
+ * a shameful helper to avoid needing to test code coverage of branches
+ */
+export const fnIf = (condition, trueValue, falseValue) => condition ? trueValue : falseValue;
+/*
+ * maps the array and returns the first result that matches the predicate
+ * avoids processing extra elements that would happen with .map().find() or .reduce
+ *
+ * eg the third element of the array is never processed:
+ *   const result = mapFind([1,2,3], x => 'hello'.charAt(x), x => x === 'l');
+ */
+export const mapFind = (array, mapper, predicate = (r) => !!r) => {
+    for (const item of array) {
+        const mapped = mapper(item);
+        if (predicate(mapped)) {
+            return mapped;
+        }
+    }
+};
+/*
+ * returns a function that will only ever call the given function once, returning the first result for every subsequent call
+ *
+ * eg:
+ *   const heavyFunction = () => 'hello';
+ *   const butOnlyOnce = once(() => 'hello');
+ *
+ *   heavyFunction() // returns `hello`;
+ *   butOnlyOnce() // returns `hello`;
+ */
+export const once = (fn) => {
+    const initialValue = {};
+    let result = initialValue;
+    return ((...args) => result === initialValue ? (result = fn(...args)) : result);
+};
+/*
+ * memoizes a function with any number of arguments
+ */
+export const memoize = (fn) => {
+    const cache = {};
+    const resolveCache = (cacheLayer, [first, ...rest]) => {
+        if (!first) {
+            return cacheLayer;
+        }
+        const layers = first instanceof Object
+            ? (cacheLayer.weakLayers = (cacheLayer.weakLayers || (typeof WeakMap === 'undefined' ? undefined : new WeakMap())))
+            : (cacheLayer.strongLayers = (cacheLayer.strongLayers || new Map()));
+        // argument is an object and WeakMap is not supported
+        if (!layers) {
+            return {};
+        }
+        const layer = layers.get(first) || {};
+        if (!layers.has(first)) {
+            layers.set(first, layer);
+        }
+        return resolveCache(layer, rest);
+    };
+    return ((...args) => {
+        const thisCache = resolveCache(cache, args);
+        return thisCache.result = (thisCache.result || fn(...args));
+    });
+};
+/*
+ * rounds number to given number of places
+ *
+ * eg:
+ *  roundToPrecision(1234.123, 2); // returns 1200
+ *  roundToPrecision(1234.123, -2); // returns 1234.12
+ *  roundToPrecision(1234.125, -2); // returns 1234.13
+ */
+export const roundToPrecision = (num, places) => {
+    const multiplier = Math.pow(10, -1 * places);
+    // https://stackoverflow.com/a/11832950/14809536
+    return Math.round((num + Number.EPSILON) * multiplier) / multiplier;
+};
+/*
+ * a silly utility to help typescript realize an array is a tuple
+ *
+ * eg:
+ *  const a = [5, 'string'] // type is `Array<string | number>`
+ *  const t = tuple(5, 'string') type is `[5, 'string']`
+ *
+ * both have the same javascript value, but one is forced to be a tuple, which
+ * is nice if its structure is important. examples are like the React.useState
+ * pattern where there are two return values in a tuple, or if you're feeding
+ * Object.fromEntries
+ *
+ */
+export const tuple = (...args) => args;

package/dist/esm/misc/merge.d.ts

@@ -0,0 +1,3 @@
+import type { UnionToIntersection } from '../types';
+export declare const getCommonProperties: <T1 extends {}, T2 extends {}>(thing1: T1, thing2: T2) => (keyof T1 & keyof T2)[];
+export declare const merge: <T extends {}[]>(...[thing1, ...tail]: T) => UnionToIntersection<T[number]>;

package/dist/esm/misc/merge.js

@@ -0,0 +1,33 @@
+import { isPlainObject } from '../guards';
+export const getCommonProperties = (thing1, thing2) => Object.keys(thing1).filter((key) => Object.keys(thing2).includes(key));
+/*
+ * recursive merge properties of inputs. values are merged if they are
+ * plain objects or arrays, otherwise if the same property exists in both
+ * objects the value from the second argument will win.
+ *
+ * unlike lodash merge, this will not change object references for values that
+ * exist only in one parameter.
+ *
+ * eg:
+ *   merge({thing: 'one'}, {thing: 'two', otherKey: 'one'}, {coolKey: 'coolValue'});
+ */
+export const merge = (...[thing1, ...tail]) => {
+    const mergedTail = tail.length > 0
+        ? merge(...tail)
+        : null;
+    if (!mergedTail) {
+        return thing1;
+    }
+    return {
+        ...thing1,
+        ...mergedTail,
+        ...getCommonProperties(thing1, mergedTail).reduce((result, property) => ({
+            ...result,
+            ...(isPlainObject(thing1[property]) && isPlainObject(mergedTail[property])
+                ? { [property]: merge(thing1[property], mergedTail[property]) }
+                : (Array.isArray(thing1[property]) && Array.isArray(mergedTail[property]))
+                    ? { [property]: [...thing1[property], ...mergedTail[property]] }
+                    : {}),
+        }), {}),
+    };
+};

package/dist/esm/misc/partitionSequence.d.ts

@@ -0,0 +1,4 @@
+export declare const partitionSequence: <T, P>(getPartition: (thing: T, previous?: P | undefined) => {
+    matches?: boolean | undefined;
+    value: P;
+}, sequence: T[]) => [P, T[]][];

package/dist/esm/misc/partitionSequence.js

@@ -0,0 +1,48 @@
+import deepEqual from 'deep-equal';
+/*
+ * partitions a sequence based on a partition function returning {value: any; matches?: boolean}
+ *  - if the function returns `matches` explicitly then adjacent matching elements will
+ *    be grouped and the predicate value in the result will be from the last item in the group
+ *  - if the function returns only a value then matching will be evaluated based on the deep
+ *    equality of the value with its neighbors
+ *
+ * this is different from lodash/partition and lodash/groupBy because:
+ *  - it preserves the order of the items, items will only be grouped if they are already adjacent
+ *  - there can be any number of groups
+ *  - it tells you the partition value
+ *  - the partition value can be reduced, if you care (so you can like, partition on sequential values)
+ *
+ *  simple predicate:
+ *    returns: [[0, [1,2]], [1, [3,4,5]]]
+ *    partitionSequence((n: number) => ({value: Math.floor(n / 3)}), [1,2,3,4,5])
+ *
+ *  mutating partition:
+ *    returns: [
+ *      [{min: 1,max: 3}, [1,2,3]],
+ *      [{min: 5,max: 6}, [5,6]],
+ *      [{min: 8,max: 8}, [8]],
+ *    ]
+ *    partitionSequence(
+ *      (n: number, p?: {min: number; max: number}) =>
+ *        p && p.max + 1 === n
+ *          ? {value: {...p, max: n}, matches: true}
+ *          : {value: {min: n, max: n}, matches: false}
+ *      , [1,2,3,5,6,8]
+ *    )
+ */
+export const partitionSequence = (getPartition, sequence) => {
+    const appendItem = (result, item) => {
+        const current = result[result.length - 1];
+        const itemPartition = getPartition(item, current === null || current === void 0 ? void 0 : current[0]);
+        if (current && ((itemPartition.matches === undefined && deepEqual(current[0], itemPartition.value))
+            || itemPartition.matches)) {
+            current[0] = itemPartition.value;
+            current[1].push(item);
+        }
+        else {
+            result.push([itemPartition.value, [item]]);
+        }
+        return result;
+    };
+    return sequence.reduce(appendItem, []);
+};

package/dist/esm/services/authProvider/decryption.js

@@ -1,7 +1,7 @@
 import { compactDecrypt, compactVerify, importSPKI } from 'jose';
-import { once } from '../..';
 import { resolveConfigValue } from '../../config/resolveConfigValue';
 import { ifDefined } from '../../guards';
+import { once } from '../../misc/helpers';
 import { getAuthTokenOrCookie } from '.';
 export const decryptionAuthProvider = (initializer) => (configProvider) => {
     const config = configProvider[ifDefined(initializer.configSpace, 'decryption')];