@ixfx/process 0.36.0

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

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

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

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

package/dist/__tests__/process.test.js

@@ -0,0 +1,85 @@
+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

@@ -0,0 +1,37 @@
+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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,129 @@
+/**
+ * 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

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

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

@@ -0,0 +1 @@
+{"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

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

package/dist/src/flow.d.ts

@@ -0,0 +1,7 @@
+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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,37 @@
+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

@@ -0,0 +1,49 @@
+/**
+/**
+ * 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

@@ -0,0 +1 @@
+{"version":3,"file":"if-undefined.d.ts","sourceRoot":"","sources":["../../src/if-undefined.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;GAmBG;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"}

package/dist/src/if-undefined.js

@@ -0,0 +1,69 @@
+import { CancelError } from "./cancel-error.js";
+/**
+/**
+ * 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 function ifNotUndefined(fn) {
+    return (value) => {
+        if (value === undefined)
+            return value;
+        const v = fn(value);
+        return v;
+    };
+}
+/**
+ * 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 function cancelIfUndefined() {
+    return (value) => {
+        if (value === undefined)
+            throw new CancelError(`cancel`);
+        return value;
+    };
+}
+/**
+ * Returns the output of `fn` if the input value is _undefined_.
+ * See also: {@link ifNotUndefined} and {@link cancelIfUndefined}.
+ * @param fn
+ * @returns
+ */
+export function ifUndefined(fn) {
+    return (value) => {
+        if (value === undefined)
+            return fn();
+        else
+            return value;
+    };
+}

package/dist/src/index.d.ts

@@ -0,0 +1,7 @@
+export type * from './types.js';
+export * from './basic.js';
+export * from './cancel-error.js';
+export * from './flow.js';
+export * from './if-undefined.js';
+export * from './seen.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,mBAAmB,YAAY,CAAC;AAChC,cAAe,YAAY,CAAC;AAC5B,cAAc,mBAAmB,CAAC;AAClC,cAAc,WAAW,CAAC;AAC1B,cAAc,mBAAmB,CAAC;AAClC,cAAc,WAAW,CAAA"}

package/dist/src/index.js

@@ -0,0 +1,5 @@
+export * from './basic.js';
+export * from './cancel-error.js';
+export * from './flow.js';
+export * from './if-undefined.js';
+export * from './seen.js';

package/dist/src/seen.d.ts

@@ -0,0 +1,30 @@
+import type { Process } from "./types.js";
+/**
+ * If a value is same as the previous value, _undefined_ is emitted instead.
+ * @param eq Equality function. If not specified, === semantics are used.
+ * @returns
+ */
+export 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
+ */
+export 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
+ */
+export declare function seenToUndefinedByKey<TIn>(toString?: (value: TIn) => string): Process<TIn, TIn | undefined>;
+//# sourceMappingURL=seen.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"seen.d.ts","sourceRoot":"","sources":["../../src/seen.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC;AAG1C;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,EAAE,CAAC,EAAE,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,GAAG,KAAK,OAAO,GAAG,OAAO,CAAC,GAAG,EAAE,GAAG,GAAG,SAAS,CAAC,CAUxG;AAED;;;;;;;;GAQG;AACH,wBAAgB,eAAe,CAAC,GAAG,EAAE,EAAE,CAAC,EAAE,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,GAAG,KAAK,OAAO,GAAG,OAAO,CAAC,GAAG,EAAE,GAAG,GAAG,SAAS,CAAC,CAWpG;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,oBAAoB,CAAC,GAAG,EAAE,QAAQ,CAAC,EAAE,CAAC,KAAK,EAAE,GAAG,KAAK,MAAM,GAAG,OAAO,CAAC,GAAG,EAAE,GAAG,GAAG,SAAS,CAAC,CAU1G"}

package/dist/src/seen.js

@@ -0,0 +1,67 @@
+import { isEqualDefault, toStringDefault } from "./util.js";
+/**
+ * If a value is same as the previous value, _undefined_ is emitted instead.
+ * @param eq Equality function. If not specified, === semantics are used.
+ * @returns
+ */
+export function seenLastToUndefined(eq) {
+    if (eq === undefined)
+        eq = isEqualDefault;
+    let lastValue;
+    return (value) => {
+        if (value !== lastValue) {
+            lastValue = value;
+            return value;
+        }
+        return 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
+ */
+export function seenToUndefined(eq) {
+    let seen = [];
+    if (eq === undefined)
+        eq = isEqualDefault;
+    return (value) => {
+        if (value === undefined)
+            return;
+        for (const s of seen) {
+            if (eq(s, value))
+                return;
+        }
+        seen.push(value);
+        return value;
+    };
+}
+/**
+ * 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
+ */
+export function seenToUndefinedByKey(toString) {
+    let seen = new Set();
+    if (toString === undefined)
+        toString = toStringDefault;
+    return (value) => {
+        if (value === undefined)
+            return;
+        const key = toString(value);
+        if (seen.has(key))
+            return;
+        seen.add(key);
+        return value;
+    };
+}

package/dist/src/types.d.ts

@@ -0,0 +1,51 @@
+export type Process<TIn, TOut> = (value: TIn) => TOut;
+export type ProcessFactory<TIn, TOut> = () => Process<TIn, TOut>;
+export type Processors1<T1, T2> = [
+    Process<T1, T2>
+];
+export type Processors2<T1, T2, T3> = [
+    Process<T1, T2>,
+    Process<T2, T3>
+];
+export type Processors3<T1, T2, T3, T4> = [
+    Process<T1, T2>,
+    Process<T2, T3>,
+    Process<T3, T4>
+];
+export type Processors4<T1, T2, T3, T4, T5> = [
+    Process<T1, T2>,
+    Process<T2, T3>,
+    Process<T3, T4>,
+    Process<T4, T5>
+];
+export type Processors5<T1, T2, T3, T4, T5, T6> = [
+    Process<T1, T2>,
+    Process<T2, T3>,
+    Process<T3, T4>,
+    Process<T4, T5>,
+    Process<T5, T6>
+];
+export 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
+ */
+export type RankFunction<T> = (a: T, b: T) => `a` | `b` | `eq`;
+export 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

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/types.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,OAAO,CAAC,GAAG,EAAE,IAAI,IAAI,CAAC,KAAK,EAAE,GAAG,KAAK,IAAI,CAAC;AACtD,MAAM,MAAM,cAAc,CAAC,GAAG,EAAE,IAAI,IAAI,MAAM,OAAO,CAAC,GAAG,EAAE,IAAI,CAAC,CAAC;AAEjE,MAAM,MAAM,WAAW,CAAC,EAAE,EAAE,EAAE,IAAI;IAChC,OAAO,CAAC,EAAE,EAAE,EAAE,CAAC;CAChB,CAAA;AAED,MAAM,MAAM,WAAW,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,IAAI;IACpC,OAAO,CAAC,EAAE,EAAE,EAAE,CAAC;IACf,OAAO,CAAC,EAAE,EAAE,EAAE,CAAC;CAChB,CAAA;AAED,MAAM,MAAM,WAAW,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,IAAI;IACxC,OAAO,CAAC,EAAE,EAAE,EAAE,CAAC;IACf,OAAO,CAAC,EAAE,EAAE,EAAE,CAAC;IACf,OAAO,CAAC,EAAE,EAAE,EAAE,CAAC;CAChB,CAAA;AAED,MAAM,MAAM,WAAW,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,IAAI;IAC5C,OAAO,CAAC,EAAE,EAAE,EAAE,CAAC;IACf,OAAO,CAAC,EAAE,EAAE,EAAE,CAAC;IACf,OAAO,CAAC,EAAE,EAAE,EAAE,CAAC;IACf,OAAO,CAAC,EAAE,EAAE,EAAE,CAAC;CAChB,CAAA;AAED,MAAM,MAAM,WAAW,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,IAAI;IAChD,OAAO,CAAC,EAAE,EAAE,EAAE,CAAC;IACf,OAAO,CAAC,EAAE,EAAE,EAAE,CAAC;IACf,OAAO,CAAC,EAAE,EAAE,EAAE,CAAC;IACf,OAAO,CAAC,EAAE,EAAE,EAAE,CAAC;IACf,OAAO,CAAC,EAAE,EAAE,EAAE,CAAC;CAChB,CAAA;AACD,MAAM,MAAM,UAAU,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,IAAI,WAAW,CAAC,EAAE,EAAE,EAAE,CAAC,GAAG,WAAW,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,GAAG,WAAW,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,GAAG,WAAW,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,GAAG,WAAW,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC;AAGrM;;;;GAIG;AACH,MAAM,MAAM,YAAY,CAAC,CAAC,IAAI,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,KAAK,GAAG,GAAG,GAAG,GAAG,IAAI,CAAA;AAE9D,MAAM,MAAM,WAAW,GAAG;IACxB;;OAEG;IACH,WAAW,CAAC,EAAE,QAAQ,GAAG,QAAQ,GAAG,QAAQ,GAAG,SAAS,CAAA;IACxD;;;OAGG;IACH,eAAe,CAAC,EAAE,OAAO,CAAA;IACzB;;;OAGG;IACH,iBAAiB,CAAC,EAAE,OAAO,CAAA;CAC5B,CAAA"}

package/dist/src/types.js

@@ -0,0 +1 @@
+export {};

package/dist/src/util.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Default comparer function is equiv to checking `a === b`.
+ * Use {@link isEqualValueDefault} to compare by value, via comparing JSON string representation.
+ */
+export declare const isEqualDefault: <T>(a: T, b: T) => boolean;
+/**
+ * A default converter to string that uses JSON.stringify if its an object, or the thing itself if it's a string
+ */
+export declare const toStringDefault: <V>(itemToMakeStringFor: V) => string;
+//# sourceMappingURL=util.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"util.d.ts","sourceRoot":"","sources":["../../src/util.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,eAAO,MAAM,cAAc,GAAI,CAAC,EAAE,GAAG,CAAC,EAAE,GAAG,CAAC,KAAG,OAAkB,CAAC;AAElE;;GAEG;AACH,eAAO,MAAM,eAAe,GAAI,CAAC,EAAE,qBAAqB,CAAC,KAAG,MAGnB,CAAC"}

package/dist/src/util.js

@@ -0,0 +1,11 @@
+/**
+ * Default comparer function is equiv to checking `a === b`.
+ * Use {@link isEqualValueDefault} to compare by value, via comparing JSON string representation.
+ */
+export const isEqualDefault = (a, b) => a === b;
+/**
+ * A default converter to string that uses JSON.stringify if its an object, or the thing itself if it's a string
+ */
+export const toStringDefault = (itemToMakeStringFor) => typeof itemToMakeStringFor === `string`
+    ? itemToMakeStringFor
+    : JSON.stringify(itemToMakeStringFor);

package/dist/tsconfig.tsbuildinfo

@@ -0,0 +1 @@
+{"root":["../src/basic.ts","../src/cancel-error.ts","../src/flow.ts","../src/if-undefined.ts","../src/index.ts","../src/seen.ts","../src/types.ts","../src/util.ts","../__tests__/process.test.ts"],"version":"5.8.3"}

package/package.json

@@ -0,0 +1,34 @@
+{
+	"name": "@ixfx/process",
+	"version": "0.36.0",
+	"license": "MIT",
+	"type": "module",
+	"sideEffects": false,
+	"files": [
+		"dist/"
+	],
+	"exports": {
+		".": {
+			"types": "./src/index.ts",
+			"import": "./src/index.ts"
+		},
+		"./basic": {
+			"types": "./src/basic.ts",
+			"import": "./src/basic.ts"
+		}
+	},
+	"dependencies": {},
+	"publishConfig": {
+		"main": "dist/src/index.js",
+		"exports": {
+			".": {
+				"types": "./dist/src/index.d.ts",
+				"import": "./dist/src/index.js"
+			},
+			"./basic": {
+				"types": "./dist/src/basic.d.ts",
+				"import": "./dist/src/basic.js"
+			}
+		}
+	}
+}