@ixfx/process 0.43.0 → 0.56.0

package/bundle/index.d.ts

@@ -1,172 +0,0 @@
-//#region src/types.d.ts
-type Process<TIn, TOut> = (value: TIn) => TOut;
-type ProcessFactory<TIn, TOut> = () => Process<TIn, TOut>;
-type Processors1<T1, T2> = [Process<T1, T2>];
-type Processors2<T1, T2, T3> = [Process<T1, T2>, Process<T2, T3>];
-type Processors3<T1, T2, T3, T4> = [Process<T1, T2>, Process<T2, T3>, Process<T3, T4>];
-type Processors4<T1, T2, T3, T4, T5> = [Process<T1, T2>, Process<T2, T3>, Process<T3, T4>, Process<T4, T5>];
-type Processors5<T1, T2, T3, T4, T5, T6> = [Process<T1, T2>, Process<T2, T3>, Process<T3, T4>, Process<T4, T5>, Process<T5, T6>];
-type Processors<T1, T2, T3, T4, T5, T6> = Processors1<T1, T2> | Processors2<T1, T2, T3> | Processors3<T1, T2, T3, T4> | Processors4<T1, T2, T3, T4, T5> | Processors5<T1, T2, T3, T4, T5, T6>;
-/**
- * A rank function that compares A and B.
- * Returns the highest value, 'a' or 'b'.
- * Returns 'eq' if values are equal
- */
-type RankFunction<T> = (a: T, b: T) => `a` | `b` | `eq`;
-type RankOptions = {
-  /**
-   * If set, only values with this JS type are included
-   */
-  includeType?: `string` | `number` | `object` | `boolean`;
-  /**
-   * If _true_, also emits values when they rank equal with current highest.
-   * _false_ by default
-   */
-  emitEqualRanked?: boolean;
-  /**
-   * If _true_, emits the current highest value even if it hasn't changed.
-   * This means it will match the tempo of the incoming stream.
-   */
-  emitRepeatHighest?: boolean;
-};
-//# sourceMappingURL=types.d.ts.map
-//#endregion
-//#region src/basic.d.ts
-/**
- * Outputs the current largest-seen value
- * @returns
- */
-declare const max: () => Process<number | number[], number>;
-/**
- * Outputs the current smallest-seen value
- * @returns
- */
-declare const min: () => Process<number | number[], number>;
-/**
- * Returns a sum of values
- * @returns
- */
-declare const sum: () => Process<number | number[], number>;
-/**
- * Returns the current average of input values
- * @returns
- */
-declare const average: () => Process<number | number[], number>;
-/**
- * Returns the tally (ie number of) values
- * @param countArrayItems
- * @returns
- */
-declare const tally: (countArrayItems: boolean) => Process<any, number>;
-/**
- * Returns the 'best' value seen so far as determined by a ranking function.
- * This is similar to min/max but usable for objects.
- * @param r
- * @param options
- * @returns
- */
-declare function rank<In>(r: RankFunction<In>, options?: Partial<RankOptions>): (value: In) => In | undefined;
-//# sourceMappingURL=basic.d.ts.map
-//#endregion
-//#region src/cancel-error.d.ts
-declare class CancelError extends Error {
-  constructor(message: any);
-}
-//# sourceMappingURL=cancel-error.d.ts.map
-//#endregion
-//#region src/flow.d.ts
-declare function flow<T1, T2>(...processors: [Process<T1, T2>]): (value: T1) => T2;
-declare function flow<T1, T2, T3>(...processors: [Process<T1, T2>, Process<T2, T3>]): (value: T1) => T3;
-declare function flow<T1, T2, T3, T4>(...processors: [Process<T1, T2>, Process<T2, T3>, Process<T3, T4>]): (value: T1) => T4;
-declare function flow<T1, T2, T3, T4, T5>(...processors: [Process<T1, T2>, Process<T2, T3>, Process<T3, T4>, Process<T4, T5>]): (value: T1) => T5;
-declare function flow<T1, T2, T3, T4, T5, T6>(...processors: [Process<T1, T2>, Process<T2, T3>, Process<T3, T4>, Process<T4, T5>, Process<T5, T6>]): (value: T1) => T6;
-//# sourceMappingURL=flow.d.ts.map
-
-//#endregion
-//#region src/if-undefined.d.ts
-/**
- * Calls a function if the input value is not undefined.
- * Return value from function is passed to next function in flow.
- *
- * ```js
- * const flow = Process.flow(
- *  Process.max(),
- *  Process.seenLastToUndefined(),
- *  Process.ifNotUndefined(v => {
- *    console.log(`v:`, v);
- *  })
- * );
- * flow(100); // Prints 'v:100'
- * flow(90);  // Nothing happens max value has not changed
- * flow(110); // Prints 'v:110'
- * ```
- * @param fn
- * @returns
- */
-declare function ifNotUndefined<TIn, TOut>(fn: (value: Exclude<TIn, undefined>) => TOut): (value: TIn) => TIn | TOut;
-/**
- * Cancels the remaining flow operations if _undefined_ is an input.
- * See also {@link ifUndefined} or {@link ifNotUndefined}.
- *
- * ```js
- * const c3 = Process.flow(
- *  Basic.max(),
- *  Process.seenLastToUndefined(),
- *  Process.cancelIfUndefined(),
- *  (v => {
- *   console.log(v);
- *  })
- * );
- * c3(100); // Prints '100'
- * c3(90);  // Doesn't print anything since max does not change
- * c3(110); // Prints '110'
- * ```
- * @returns
- */
-declare function cancelIfUndefined<TIn>(): (value: TIn | undefined) => TIn;
-/**
- * Returns the output of `fn` if the input value is _undefined_.
- * See also: {@link ifNotUndefined} and {@link cancelIfUndefined}.
- * @param fn
- * @returns
- */
-declare function ifUndefined<TIn, TOut>(fn: () => TOut): (value: TIn) => TOut | (TIn & ({} | null));
-//# sourceMappingURL=if-undefined.d.ts.map
-//#endregion
-//#region src/seen.d.ts
-/**
- * If a value is same as the previous value, _undefined_ is emitted instead.
- *
- * @param eq Equality function. If not specified, === semantics are used.
- * @returns
- */
-declare function seenLastToUndefined<TIn>(eq?: (a: TIn, b: TIn) => boolean): Process<TIn, TIn | undefined>;
-/**
- * If a value is same as any previously-seen value, _undefined_ is emitted instead.
- *
- * It stores all previous values and compares against them for each new value.
- * This would likely be not very efficient compared to {@link seenToUndefinedByKey} which uses a one-time computed
- * key and efficient storage of only the keys (using a Set).
- *
- * @param eq Equality function. If not specified, === semantics are used.
- * @returns
- */
-declare function seenToUndefined<TIn>(eq?: (a: TIn, b: TIn) => boolean): Process<TIn, TIn | undefined>;
-/**
- * If a value is the same as any previously-seen value, _undefined_ is emitted instead.
- *
- * This version uses a function to create a string key of the object, by default JSON.stringify.
- * Thus we don't need to store all previously seen objects, just their keys.
- *
- * Alternatively, if a key function doesn't make sense for the value, use
- * {@link seenToUndefined}, which stores the values (less efficient).
- *
- * @param toString
- * @returns
- */
-declare function seenToUndefinedByKey<TIn>(toString?: (value: TIn) => string): Process<TIn, TIn | undefined>;
-//# sourceMappingURL=seen.d.ts.map
-
-//#endregion
-export { CancelError, type Process, ProcessFactory, Processors, Processors1, Processors2, Processors3, Processors4, Processors5, RankFunction, RankOptions, average, cancelIfUndefined, flow, ifNotUndefined, ifUndefined, max, min, rank, seenLastToUndefined, seenToUndefined, seenToUndefinedByKey, sum, tally };
-//# sourceMappingURL=index.d.ts.map

package/bundle/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","names":[],"sources":["../src/types.ts","../src/basic.ts","../src/cancel-error.ts","../src/flow.ts","../src/if-undefined.ts","../src/seen.ts"],"sourcesContent":[],"mappings":"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"}

package/bundle/index.js

@@ -1,2 +0,0 @@
-const e=()=>{let e=-(2**53-1),t=t=>{let n=Array.isArray(t)?t:[t];for(let t of n){if(typeof t!=`number`)break;e=Math.max(t,e)}return e};return t},t=()=>{let e=2**53-1,t=t=>{let n=Array.isArray(t)?t:[t];for(let t of n){if(typeof t!=`number`)break;e=Math.min(t,e)}return e};return t},n=()=>{let e=0,t=t=>{let n=Array.isArray(t)?t:[t];for(let t of n){if(typeof t!=`number`)continue;e+=t}return e};return t},r=()=>{let e=0,t=0,n=n=>{let r=Array.isArray(n)?n:[n];for(let n of r){if(typeof n!=`number`)continue;t++,e+=n}return e/t};return n},i=e=>{let t=0,n=n=>(e&&Array.isArray(n)?t+=n.length:t++,t);return n};function a(e,t={}){let n=t.includeType,r=t.emitEqualRanked??!1,i=t.emitRepeatHighest??!1,a;return t=>{if(!(n&&typeof t!==n)){if(a===void 0)return a=t,a;{let n=e(t,a);if(n==`a`)return a=t,a;if(n===`eq`&&r||i)return a}}}}var o=class extends Error{constructor(e){super(e),this.name=`CancelError`}};function s(...e){return t=>{let n=t;for(let t of e)try{n=t(n)}catch(e){if(e instanceof o)break;throw e}return n}}function c(e){return t=>{if(t===void 0)return t;let n=e(t);return n}}function l(){return e=>{if(e===void 0)throw new o(`cancel`);return e}}function u(e){return t=>t===void 0?e():t}const d=(e,t)=>e===t,f=e=>typeof e==`string`?e:JSON.stringify(e);function p(e){e===void 0&&(e=d);let t;return e=>{if(e!==t)return t=e,e}}function m(e){let t=[];return e===void 0&&(e=d),n=>{if(n!==void 0){for(let r of t)if(e(r,n))return;return t.push(n),n}}}function h(e){let t=new Set;return e===void 0&&(e=f),n=>{if(n===void 0)return;let r=e(n);if(!t.has(r))return t.add(r),n}}export{o as CancelError,r as average,l as cancelIfUndefined,s as flow,c as ifNotUndefined,u as ifUndefined,e as max,t as min,a as rank,p as seenLastToUndefined,m as seenToUndefined,h as seenToUndefinedByKey,n as sum,i as tally};
-//# sourceMappingURL=index.js.map

package/bundle/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","names":["max","value: number | number[]","min","tally","countArrayItems: boolean","r: RankFunction<In>","options: Partial<RankOptions>","best: In | undefined","value: In","message: any","value: T1","fn: (value: Exclude<TIn, undefined>) => TOut","value: TIn","value: TIn | undefined","fn: () => TOut","a: T","b: T","itemToMakeStringFor: V","eq?: (a: TIn, b: TIn) => boolean","lastValue: TIn | undefined","value: TIn","seen: TIn[]","toString?: (value: TIn) => string"],"sources":["../src/basic.ts","../src/cancel-error.ts","../src/flow.ts","../src/if-undefined.ts","../src/util.ts","../src/seen.ts"],"sourcesContent":["import type { Process, RankFunction, RankOptions } from \"./types.js\";\nexport type { Process } from \"./types.js\";\n/**\n * Outputs the current largest-seen value\n * @returns \n */\nexport const max = (): Process<number | number[], number> => {\n  let max = Number.MIN_SAFE_INTEGER;\n  const compute = (value: number | number[]) => {\n    const valueArray = Array.isArray(value) ? value : [ value ];\n    for (const subValue of valueArray) {\n      if (typeof subValue !== `number`) break;\n      max = Math.max(subValue, max);\n    }\n    return max;\n  }\n  return compute;\n}\n\n/**\n * Outputs the current smallest-seen value\n * @returns\n */\nexport const min = (): Process<number | number[], number> => {\n  let min = Number.MAX_SAFE_INTEGER;\n  const compute = (value: number | number[]) => {\n    const valueArray = Array.isArray(value) ? value : [ value ];\n    for (const subValue of valueArray) {\n      if (typeof subValue !== `number`) break;\n      min = Math.min(subValue, min);\n    }\n    return min;\n  }\n  return compute;\n}\n\n/**\n * Returns a sum of values\n * @returns \n */\nexport const sum = (): Process<number | number[], number> => {\n  let t = 0;\n  const compute = (value: number | number[]) => {\n    const valueArray = Array.isArray(value) ? value : [ value ];\n    for (const subValue of valueArray) {\n      if (typeof subValue !== `number`) continue;\n      t += subValue;\n    }\n    return t;\n  }\n  return compute;\n}\n\n/**\n * Returns the current average of input values\n * @returns \n */\nexport const average = (): Process<number | number[], number> => {\n  let total = 0;\n  let tally = 0;\n  const compute = (value: number | number[]) => {\n    const valueArray = Array.isArray(value) ? value : [ value ];\n    for (const subValue of valueArray) {\n      if (typeof subValue !== `number`) continue;\n      tally++;\n      total += subValue;\n    }\n    return total / tally;\n  }\n  return compute;\n}\n\n/**\n * Returns the tally (ie number of) values\n * @param countArrayItems \n * @returns \n */\nexport const tally = (countArrayItems: boolean): Process<any, number> => {\n  let t = 0;\n  const compute = (value: number | number[]) => {\n    if (countArrayItems) {\n      if (Array.isArray(value)) t += value.length;\n      else t++;\n    } else {\n      t++;\n    }\n    return t;\n  }\n  return compute;\n}\n\n\n\n/**\n * Returns the 'best' value seen so far as determined by a ranking function.\n * This is similar to min/max but usable for objects.\n * @param r \n * @param options \n * @returns \n */\nexport function rank<In>(r: RankFunction<In>, options: Partial<RankOptions> = {}) {\n  const includeType = options.includeType;\n  const emitEqualRanked = options.emitEqualRanked ?? false;\n  const emitRepeatHighest = options.emitRepeatHighest ?? false;\n  let best: In | undefined;\n  return (value: In) => {\n    if (includeType && typeof value !== includeType) return;\n    if (best === undefined) {\n      best = value;\n      return best;\n    } else {\n      const result = r(value, best);\n      //console.log(`result: ${ result } value: ${ JSON.stringify(value) } best: ${ JSON.stringify(best) }`);\n      if (result == `a`) {\n        // New value is the current best\n        best = value;\n        return best;\n      } else if (result === `eq` && emitEqualRanked) {\n        // New value is same rank as previous, but we have flag on\n        return best;\n      } else if (emitRepeatHighest) {\n        // Emit current highest due to flag\n        return best;\n      }\n    }\n  }\n}\n\n\n","export class CancelError extends Error {\n  constructor(message: any) {\n    super(message);\n    this.name = `CancelError`;\n  }\n}","import { CancelError } from \"./cancel-error.js\";\nimport type { Process, Processors } from \"./types.js\";\nexport function flow<T1, T2>(...processors: [ Process<T1, T2> ]): (value: T1) => T2;\nexport function flow<T1, T2, T3>(...processors: [ Process<T1, T2>, Process<T2, T3> ]): (value: T1) => T3;\nexport function flow<T1, T2, T3, T4>(...processors: [ Process<T1, T2>, Process<T2, T3>, Process<T3, T4> ]): (value: T1) => T4;\nexport function flow<T1, T2, T3, T4, T5>(...processors: [ Process<T1, T2>, Process<T2, T3>, Process<T3, T4>, Process<T4, T5> ]): (value: T1) => T5;\nexport function flow<T1, T2, T3, T4, T5, T6>(...processors: [ Process<T1, T2>, Process<T2, T3>, Process<T3, T4>, Process<T4, T5>, Process<T5, T6> ]): (value: T1) => T6;\n\n/**\n * Creates a flow of data processors (up to 5 are supported).\n * The flow is encapsulated in a function that accepts an input value an returns an output.\n * \n * ```js\n * const p = flow(\n *  (value:string) => value.toUpperCase(), // Convert to uppercase\n *  (value:string) => value.at(0) === 'A') // If first letter is an A, return true\n * );\n * p('apple'); // True\n * ```\n * \n * Each processing function is expected to take in one input value and return one value.\n * @param processors \n * @returns \n */\nexport function flow<T1, T2, T3, T4, T5, T6>(...processors: Processors<T1, T2, T3, T4, T5, T6>): (value: T1) => T2 | T3 | T4 | T5 | T6 {\n  return (value: T1) => {\n    let v = value;\n    for (const p of processors) {\n      try {\n        // @ts-expect-error\n        v = p(v) as T1;\n      } catch (err) {\n        if (err instanceof CancelError) {\n          break;\n        } else {\n          throw err;\n        }\n      }\n    }\n    return v as T2 | T3 | T4 | T5 | T6;\n  }\n}\n","import { CancelError } from \"./cancel-error.js\";\n\n\n/**\n * Calls a function if the input value is not undefined.\n * Return value from function is passed to next function in flow.\n * \n * ```js\n * const flow = Process.flow(\n *  Process.max(),\n *  Process.seenLastToUndefined(),\n *  Process.ifNotUndefined(v => {\n *    console.log(`v:`, v);\n *  })\n * );\n * flow(100); // Prints 'v:100'\n * flow(90);  // Nothing happens max value has not changed\n * flow(110); // Prints 'v:110'\n * ```\n * @param fn \n * @returns \n */\nexport function ifNotUndefined<TIn, TOut>(fn: (value: Exclude<TIn, undefined>) => TOut) {\n  return (value: TIn) => {\n    if (value === undefined) return value;\n    const v = fn(value as Exclude<TIn, undefined>);\n    return v;\n  }\n}\n\n\n\n/**\n * Cancels the remaining flow operations if _undefined_ is an input.\n * See also {@link ifUndefined} or {@link ifNotUndefined}.\n * \n * ```js\n * const c3 = Process.flow(\n *  Basic.max(),\n *  Process.seenLastToUndefined(),\n *  Process.cancelIfUndefined(),\n *  (v => {\n *   console.log(v);\n *  })\n * );\n * c3(100); // Prints '100'\n * c3(90);  // Doesn't print anything since max does not change\n * c3(110); // Prints '110'\n * ```\n * @returns \n */\nexport function cancelIfUndefined<TIn>() {\n  return (value: TIn | undefined) => {\n    if (value === undefined) throw new CancelError(`cancel`);\n    return value as TIn;\n  }\n}\n/**\n * Returns the output of `fn` if the input value is _undefined_.\n * See also: {@link ifNotUndefined} and {@link cancelIfUndefined}.\n * @param fn \n * @returns \n */\nexport function ifUndefined<TIn, TOut>(fn: () => TOut) {\n  return (value: TIn) => {\n    if (value === undefined) return fn();\n    else return value;\n  }\n}","/**\n * Default comparer function is equiv to checking `a === b`.\n * Use {@link isEqualValueDefault} to compare by value, via comparing JSON string representation.\n */\nexport const isEqualDefault = <T>(a: T, b: T): boolean => a === b;\n\n/**\n * A default converter to string that uses JSON.stringify if its an object, or the thing itself if it's a string\n */\nexport const toStringDefault = <V>(itemToMakeStringFor: V): string =>\n  typeof itemToMakeStringFor === `string`\n    ? itemToMakeStringFor\n    : JSON.stringify(itemToMakeStringFor);","import type { Process } from \"./types.js\";\nimport { isEqualDefault, toStringDefault } from \"./util.js\";\n\n/**\n * If a value is same as the previous value, _undefined_ is emitted instead.\n * \n * @param eq Equality function. If not specified, === semantics are used.\n * @returns \n */\nexport function seenLastToUndefined<TIn>(eq?: (a: TIn, b: TIn) => boolean): Process<TIn, TIn | undefined> {\n  if (typeof eq === `undefined`) eq = isEqualDefault;\n  let lastValue: TIn | undefined;\n  return (value: TIn) => {\n    if (value !== lastValue) {\n      lastValue = value;\n      return value;\n    }\n    return undefined;\n  }\n}\n\n/**\n * If a value is same as any previously-seen value, _undefined_ is emitted instead.\n * \n * It stores all previous values and compares against them for each new value. \n * This would likely be not very efficient compared to {@link seenToUndefinedByKey} which uses a one-time computed\n * key and efficient storage of only the keys (using a Set).\n *  \n * @param eq Equality function. If not specified, === semantics are used.\n * @returns \n */\nexport function seenToUndefined<TIn>(eq?: (a: TIn, b: TIn) => boolean): Process<TIn, TIn | undefined> {\n  const seen: TIn[] = [];\n  if (typeof eq === `undefined`) eq = isEqualDefault;\n  return (value: TIn) => {\n    if (value === undefined) return;\n    for (const s of seen) {\n      if (eq(s, value)) return;\n    }\n    seen.push(value);\n    return value;\n  }\n}\n\n/**\n * If a value is the same as any previously-seen value, _undefined_ is emitted instead.\n * \n * This version uses a function to create a string key of the object, by default JSON.stringify.\n * Thus we don't need to store all previously seen objects, just their keys.\n * \n * Alternatively, if a key function doesn't make sense for the value, use\n * {@link seenToUndefined}, which stores the values (less efficient).\n * \n * @param toString \n * @returns \n */\nexport function seenToUndefinedByKey<TIn>(toString?: (value: TIn) => string): Process<TIn, TIn | undefined> {\n  const seen = new Set<string>();\n  if (typeof toString === `undefined`) toString = toStringDefault;\n  return (value: TIn) => {\n    if (value === undefined) return;\n    const key = toString(value);\n    if (seen.has(key)) return;\n    seen.add(key);\n    return value;\n  }\n}"],"mappings":"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"}

package/dist/__tests__/process.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=process.test.d.ts.map

package/dist/__tests__/process.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"process.test.d.ts","sourceRoot":"","sources":["../../__tests__/process.test.ts"],"names":[],"mappings":""}

package/dist/__tests__/process.test.js

@@ -1,85 +0,0 @@
-import { test, expect } from 'vitest';
-import * as Basic from '../src/basic.js';
-import * as Process from '../src/index.js';
-test('seen', () => {
-    const c1Results = [];
-    const c1 = Process.flow(Process.seenToUndefined(), v => {
-        c1Results.push(v);
-    });
-    c1('hello');
-    c1('hello');
-    c1('bye');
-    expect(c1Results).toEqual([`hello`, undefined, `bye`]);
-    const c2Results = [];
-    const c2 = Process.flow(Process.seenToUndefinedByKey(), v => {
-        c2Results.push(v);
-    });
-    c2({ name: `a` });
-    c2({ name: `b` });
-    c2({ name: `a` });
-    expect(c2Results).toEqual([{ name: 'a' }, { name: 'b' }, undefined]);
-    const c3 = Process.flow(Process.seenLastToUndefined);
-});
-test(`basic`, () => {
-    const c1 = Process.flow(Basic.max(), Process.seenLastToUndefined());
-    expect(c1(100)).toBe(100);
-    expect(c1(90)).toBeFalsy();
-    // @ts-expect-error
-    expect(c1(null)).toBeFalsy();
-    expect(c1(110)).toBe(110);
-    const c2Results = [];
-    const c2 = Process.flow(Basic.max(), Process.seenLastToUndefined(), Process.ifNotUndefined(v => {
-        c2Results.push(v);
-    }));
-    c2(100);
-    c2(90);
-    c2(110);
-    expect(c2Results).toEqual([100, 110]);
-    const c3Results = [];
-    const c3 = Process.flow(Basic.max(), Process.seenLastToUndefined(), Process.cancelIfUndefined(), (v => {
-        c3Results.push(v);
-    }));
-    c3(100);
-    c3(90);
-    c3(110);
-    expect(c3Results).toEqual([100, 110]);
-});
-test(`math`, () => {
-    const c1 = Process.flow(Basic.max());
-    expect(c1(100)).toBe(100);
-    expect(c1(110)).toBe(110);
-    expect(c1(90)).toBe(110);
-    // @ts-expect-error
-    expect(c1(undefined)).toBe(110);
-    // @ts-expect-error
-    expect(c1(null)).toBe(110);
-    // @ts-expect-error
-    expect(c1(`hello`)).toBe(110);
-    const c2 = Process.flow(Basic.min());
-    expect(c2(100)).toBe(100);
-    expect(c2(110)).toBe(100);
-    expect(c2(90)).toBe(90);
-    // @ts-expect-error
-    expect(c2(undefined)).toBe(90);
-    // @ts-expect-error
-    expect(c2(null)).toBe(90);
-    // @ts-expect-error
-    expect(c2(`hello`)).toBe(90);
-    const c3 = Process.flow(Basic.sum());
-    expect(c3(10)).toBe(10);
-    expect(c3(20)).toBe(30);
-    expect(c3(30)).toBe(60);
-    // @ts-expect-error
-    expect(c3(undefined)).toBe(60);
-    // @ts-expect-error
-    expect(c3(null)).toBe(60);
-    // @ts-expect-error
-    expect(c3(`hello`)).toBe(60);
-    const c4 = Process.flow(Basic.tally(false));
-    expect(c4(100)).toBe(1);
-    expect(c4(110)).toBe(2);
-    expect(c4(90)).toBe(3);
-    expect(c4(undefined)).toBe(4);
-    expect(c4(null)).toBe(5);
-    expect(c4(`hello`)).toBe(6);
-});

package/dist/src/basic.d.ts

@@ -1,37 +0,0 @@
-import type { Process, RankFunction, RankOptions } from "./types.js";
-export type { Process } from "./types.js";
-/**
- * Outputs the current largest-seen value
- * @returns
- */
-export declare const max: () => Process<number | number[], number>;
-/**
- * Outputs the current smallest-seen value
- * @returns
- */
-export declare const min: () => Process<number | number[], number>;
-/**
- * Returns a sum of values
- * @returns
- */
-export declare const sum: () => Process<number | number[], number>;
-/**
- * Returns the current average of input values
- * @returns
- */
-export declare const average: () => Process<number | number[], number>;
-/**
- * Returns the tally (ie number of) values
- * @param countArrayItems
- * @returns
- */
-export declare const tally: (countArrayItems: boolean) => Process<any, number>;
-/**
- * Returns the 'best' value seen so far as determined by a ranking function.
- * This is similar to min/max but usable for objects.
- * @param r
- * @param options
- * @returns
- */
-export declare function rank<In>(r: RankFunction<In>, options?: Partial<RankOptions>): (value: In) => In | undefined;
-//# sourceMappingURL=basic.d.ts.map

package/dist/src/basic.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"basic.d.ts","sourceRoot":"","sources":["../../src/basic.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AACrE,YAAY,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC;AAC1C;;;GAGG;AACH,eAAO,MAAM,GAAG,QAAO,OAAO,CAAC,MAAM,GAAG,MAAM,EAAE,EAAE,MAAM,CAWvD,CAAA;AAED;;;GAGG;AACH,eAAO,MAAM,GAAG,QAAO,OAAO,CAAC,MAAM,GAAG,MAAM,EAAE,EAAE,MAAM,CAWvD,CAAA;AAED;;;GAGG;AACH,eAAO,MAAM,GAAG,QAAO,OAAO,CAAC,MAAM,GAAG,MAAM,EAAE,EAAE,MAAM,CAWvD,CAAA;AAED;;;GAGG;AACH,eAAO,MAAM,OAAO,QAAO,OAAO,CAAC,MAAM,GAAG,MAAM,EAAE,EAAE,MAAM,CAa3D,CAAA;AAED;;;;GAIG;AACH,eAAO,MAAM,KAAK,GAAI,iBAAiB,OAAO,KAAG,OAAO,CAAC,GAAG,EAAE,MAAM,CAYnE,CAAA;AAID;;;;;;GAMG;AACH,wBAAgB,IAAI,CAAC,EAAE,EAAE,CAAC,EAAE,YAAY,CAAC,EAAE,CAAC,EAAE,OAAO,GAAE,OAAO,CAAC,WAAW,CAAM,IAKtE,OAAO,EAAE,oBAqBlB"}

package/dist/src/basic.js

@@ -1,129 +0,0 @@
-/**
- * Outputs the current largest-seen value
- * @returns
- */
-export const max = () => {
-    let max = Number.MIN_SAFE_INTEGER;
-    const compute = (value) => {
-        const valueArray = Array.isArray(value) ? value : [value];
-        for (const subValue of valueArray) {
-            if (typeof subValue !== `number`)
-                break;
-            max = Math.max(subValue, max);
-        }
-        return max;
-    };
-    return compute;
-};
-/**
- * Outputs the current smallest-seen value
- * @returns
- */
-export const min = () => {
-    let min = Number.MAX_SAFE_INTEGER;
-    const compute = (value) => {
-        const valueArray = Array.isArray(value) ? value : [value];
-        for (const subValue of valueArray) {
-            if (typeof subValue !== `number`)
-                break;
-            min = Math.min(subValue, min);
-        }
-        return min;
-    };
-    return compute;
-};
-/**
- * Returns a sum of values
- * @returns
- */
-export const sum = () => {
-    let t = 0;
-    const compute = (value) => {
-        const valueArray = Array.isArray(value) ? value : [value];
-        for (const subValue of valueArray) {
-            if (typeof subValue !== `number`)
-                continue;
-            t += subValue;
-        }
-        return t;
-    };
-    return compute;
-};
-/**
- * Returns the current average of input values
- * @returns
- */
-export const average = () => {
-    let total = 0;
-    let tally = 0;
-    const compute = (value) => {
-        const valueArray = Array.isArray(value) ? value : [value];
-        for (const subValue of valueArray) {
-            if (typeof subValue !== `number`)
-                continue;
-            tally++;
-            total += subValue;
-        }
-        return total / tally;
-    };
-    return compute;
-};
-/**
- * Returns the tally (ie number of) values
- * @param countArrayItems
- * @returns
- */
-export const tally = (countArrayItems) => {
-    let t = 0;
-    const compute = (value) => {
-        if (countArrayItems) {
-            if (Array.isArray(value))
-                t += value.length;
-            else
-                t++;
-        }
-        else {
-            t++;
-        }
-        return t;
-    };
-    return compute;
-};
-/**
- * Returns the 'best' value seen so far as determined by a ranking function.
- * This is similar to min/max but usable for objects.
- * @param r
- * @param options
- * @returns
- */
-export function rank(r, options = {}) {
-    const includeType = options.includeType;
-    const emitEqualRanked = options.emitEqualRanked ?? false;
-    const emitRepeatHighest = options.emitRepeatHighest ?? false;
-    let best;
-    return (value) => {
-        if (includeType && typeof value !== includeType)
-            return;
-        if (best === undefined) {
-            best = value;
-            return best;
-        }
-        else {
-            const result = r(value, best);
-            //console.log(`result: ${ result } value: ${ JSON.stringify(value) } best: ${ JSON.stringify(best) }`);
-            if (result == `a`) {
-                // New value is the current best
-                best = value;
-                return best;
-            }
-            else if (result === `eq` && emitEqualRanked) {
-                // New value is same rank as previous, but we have flag on
-                return best;
-            }
-            else if (emitRepeatHighest) {
-                // Emit current highest due to flag
-                return best;
-            }
-        }
-    };
-}

package/dist/src/cancel-error.d.ts

@@ -1,4 +0,0 @@
-export declare class CancelError extends Error {
-    constructor(message: any);
-}
-//# sourceMappingURL=cancel-error.d.ts.map

package/dist/src/cancel-error.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"cancel-error.d.ts","sourceRoot":"","sources":["../../src/cancel-error.ts"],"names":[],"mappings":"AAAA,qBAAa,WAAY,SAAQ,KAAK;gBACxB,OAAO,EAAE,GAAG;CAIzB"}

package/dist/src/cancel-error.js

@@ -1,6 +0,0 @@
-export class CancelError extends Error {
-    constructor(message) {
-        super(message);
-        this.name = `CancelError`;
-    }
-}

package/dist/src/flow.d.ts

@@ -1,7 +0,0 @@
-import type { Process } from "./types.js";
-export declare function flow<T1, T2>(...processors: [Process<T1, T2>]): (value: T1) => T2;
-export declare function flow<T1, T2, T3>(...processors: [Process<T1, T2>, Process<T2, T3>]): (value: T1) => T3;
-export declare function flow<T1, T2, T3, T4>(...processors: [Process<T1, T2>, Process<T2, T3>, Process<T3, T4>]): (value: T1) => T4;
-export declare function flow<T1, T2, T3, T4, T5>(...processors: [Process<T1, T2>, Process<T2, T3>, Process<T3, T4>, Process<T4, T5>]): (value: T1) => T5;
-export declare function flow<T1, T2, T3, T4, T5, T6>(...processors: [Process<T1, T2>, Process<T2, T3>, Process<T3, T4>, Process<T4, T5>, Process<T5, T6>]): (value: T1) => T6;
-//# sourceMappingURL=flow.d.ts.map

package/dist/src/flow.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"flow.d.ts","sourceRoot":"","sources":["../../src/flow.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,OAAO,EAAc,MAAM,YAAY,CAAC;AACtD,wBAAgB,IAAI,CAAC,EAAE,EAAE,EAAE,EAAE,GAAG,UAAU,EAAE,CAAE,OAAO,CAAC,EAAE,EAAE,EAAE,CAAC,CAAE,GAAG,CAAC,KAAK,EAAE,EAAE,KAAK,EAAE,CAAC;AACpF,wBAAgB,IAAI,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,GAAG,UAAU,EAAE,CAAE,OAAO,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,OAAO,CAAC,EAAE,EAAE,EAAE,CAAC,CAAE,GAAG,CAAC,KAAK,EAAE,EAAE,KAAK,EAAE,CAAC;AACzG,wBAAgB,IAAI,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,GAAG,UAAU,EAAE,CAAE,OAAO,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,OAAO,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,OAAO,CAAC,EAAE,EAAE,EAAE,CAAC,CAAE,GAAG,CAAC,KAAK,EAAE,EAAE,KAAK,EAAE,CAAC;AAC9H,wBAAgB,IAAI,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,GAAG,UAAU,EAAE,CAAE,OAAO,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,OAAO,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,OAAO,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,OAAO,CAAC,EAAE,EAAE,EAAE,CAAC,CAAE,GAAG,CAAC,KAAK,EAAE,EAAE,KAAK,EAAE,CAAC;AACnJ,wBAAgB,IAAI,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,GAAG,UAAU,EAAE,CAAE,OAAO,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,OAAO,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,OAAO,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,OAAO,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,OAAO,CAAC,EAAE,EAAE,EAAE,CAAC,CAAE,GAAG,CAAC,KAAK,EAAE,EAAE,KAAK,EAAE,CAAC"}

package/dist/src/flow.js

@@ -1,37 +0,0 @@
-import { CancelError } from "./cancel-error.js";
-/**
- * Creates a flow of data processors (up to 5 are supported).
- * The flow is encapsulated in a function that accepts an input value an returns an output.
- *
- * ```js
- * const p = flow(
- *  (value:string) => value.toUpperCase(), // Convert to uppercase
- *  (value:string) => value.at(0) === 'A') // If first letter is an A, return true
- * );
- * p('apple'); // True
- * ```
- *
- * Each processing function is expected to take in one input value and return one value.
- * @param processors
- * @returns
- */
-export function flow(...processors) {
-    return (value) => {
-        let v = value;
-        for (const p of processors) {
-            try {
-                // @ts-expect-error
-                v = p(v);
-            }
-            catch (err) {
-                if (err instanceof CancelError) {
-                    break;
-                }
-                else {
-                    throw err;
-                }
-            }
-        }
-        return v;
-    };
-}

package/dist/src/if-undefined.d.ts

@@ -1,48 +0,0 @@
-/**
- * Calls a function if the input value is not undefined.
- * Return value from function is passed to next function in flow.
- *
- * ```js
- * const flow = Process.flow(
- *  Process.max(),
- *  Process.seenLastToUndefined(),
- *  Process.ifNotUndefined(v => {
- *    console.log(`v:`, v);
- *  })
- * );
- * flow(100); // Prints 'v:100'
- * flow(90);  // Nothing happens max value has not changed
- * flow(110); // Prints 'v:110'
- * ```
- * @param fn
- * @returns
- */
-export declare function ifNotUndefined<TIn, TOut>(fn: (value: Exclude<TIn, undefined>) => TOut): (value: TIn) => TIn | TOut;
-/**
- * Cancels the remaining flow operations if _undefined_ is an input.
- * See also {@link ifUndefined} or {@link ifNotUndefined}.
- *
- * ```js
- * const c3 = Process.flow(
- *  Basic.max(),
- *  Process.seenLastToUndefined(),
- *  Process.cancelIfUndefined(),
- *  (v => {
- *   console.log(v);
- *  })
- * );
- * c3(100); // Prints '100'
- * c3(90);  // Doesn't print anything since max does not change
- * c3(110); // Prints '110'
- * ```
- * @returns
- */
-export declare function cancelIfUndefined<TIn>(): (value: TIn | undefined) => TIn;
-/**
- * Returns the output of `fn` if the input value is _undefined_.
- * See also: {@link ifNotUndefined} and {@link cancelIfUndefined}.
- * @param fn
- * @returns
- */
-export declare function ifUndefined<TIn, TOut>(fn: () => TOut): (value: TIn) => TOut | (TIn & ({} | null));
-//# sourceMappingURL=if-undefined.d.ts.map

package/dist/src/if-undefined.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"if-undefined.d.ts","sourceRoot":"","sources":["../../src/if-undefined.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,cAAc,CAAC,GAAG,EAAE,IAAI,EAAE,EAAE,EAAE,CAAC,KAAK,EAAE,OAAO,CAAC,GAAG,EAAE,SAAS,CAAC,KAAK,IAAI,IAC5E,OAAO,GAAG,gBAKnB;AAID;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,iBAAiB,CAAC,GAAG,MAC3B,OAAO,GAAG,GAAG,SAAS,KAEZ,GAAG,CAEtB;AACD;;;;;GAKG;AACH,wBAAgB,WAAW,CAAC,GAAG,EAAE,IAAI,EAAE,EAAE,EAAE,MAAM,IAAI,IAC3C,OAAO,GAAG,gCAInB"}