context 4.0.0 → 4.0.1

package/src/__tests__/cascade.test.ts

@@ -0,0 +1,342 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+
+import { createCascade, CtxCascadeApi } from '../context';
+
+describe('Cascading Context', () => {
+  let ctx: CtxCascadeApi<any>;
+
+  beforeEach(() => {
+    ctx = createCascade();
+  });
+  describe('createCascade', () => {
+    it('Should return a new context on each run', () => {
+      expect(createCascade()).not.toBe(createCascade());
+    });
+
+    it('Should return all methods', () => {
+      expect(createCascade()).toMatchSnapshot();
+    });
+  });
+
+  describe('context.run', () => {
+    it('Should create a new context instance', () => {
+      const top = ctx.use();
+
+      ctx.run({}, () => {
+        expect(ctx.use()).not.toBe(top);
+      });
+    });
+
+    it('Should pass no arguments to the callback', () => {
+      ctx.run({}, (...args) => {
+        expect(args).toHaveLength(0);
+      });
+    });
+
+    it('Adds provided `ctxref` properties to current context level', () => {
+      ctx.run(
+        {
+          id: 55,
+          user: 'boomsa',
+        },
+        () => {
+          expect(ctx.use().id).toBe(55);
+          expect(ctx.use().user).toBe('boomsa');
+        },
+      );
+    });
+
+    it('Returns undefined when property is not in context', () => {
+      ctx.run(
+        {
+          id: 55,
+        },
+        () => {
+          expect(ctx.use().id).toBe(55);
+          expect(ctx.use().user).toBeUndefined();
+        },
+      );
+    });
+
+    it('Should clear context after callback run', () => {
+      expect(ctx.use()).toBeUndefined();
+      ctx.run({ a: 1 }, () => {
+        expect(ctx.use()).toMatchSnapshot();
+        ctx.run({ b: 2 }, () => {
+          expect(ctx.use()).toMatchSnapshot();
+        });
+      });
+      expect(ctx.use()).toBeUndefined();
+    });
+
+    describe('Context nesting', () => {
+      it('Should refer to closest defined value', () => {
+        ctx.run(
+          {
+            id: 99,
+            name: 'watermelonbunny',
+          },
+          () => {
+            expect(ctx.use().id).toBe(99);
+            expect(ctx.use().name).toBe('watermelonbunny');
+
+            ctx.run(
+              {
+                name: 'Emanuelle',
+                color: 'blue',
+              },
+              () => {
+                expect(ctx.use().id).toBe(99);
+                expect(ctx.use().name).toBe('Emanuelle');
+                expect(ctx.use().color).toBe('blue');
+
+                ctx.run({}, () => {
+                  expect(ctx.use().id).toBe(99);
+                  expect(ctx.use().name).toBe('Emanuelle');
+                  expect(ctx.use().color).toBe('blue');
+                });
+              },
+            );
+          },
+        );
+      });
+
+      it('Should return previous context value after nested context run', () => {
+        ctx.run(
+          {
+            id: 99,
+            name: 'watermelonbunny',
+          },
+          () => {
+            ctx.run(
+              {
+                name: 'Emanuelle',
+                color: 'blue',
+              },
+              () => {
+                ctx.run({}, () => null);
+                expect(ctx.use().id).toBe(99);
+                expect(ctx.use().name).toBe('Emanuelle');
+                expect(ctx.use().color).toBe('blue');
+                expect(ctx.use()).toMatchInlineSnapshot(`
+                  {
+                    "color": "blue",
+                    "id": 99,
+                    "name": "Emanuelle",
+                  }
+                `);
+              },
+            );
+            expect(ctx.use().id).toBe(99);
+            expect(ctx.use().name).toBe('watermelonbunny');
+            expect(ctx.use()).toMatchInlineSnapshot(`
+              {
+                "id": 99,
+                "name": "watermelonbunny",
+              }
+            `);
+          },
+        );
+      });
+    });
+  });
+
+  describe('context.bind', () => {
+    it('Returns a function', () => {
+      expect(typeof ctx.bind({}, vi.fn())).toBe('function');
+    });
+
+    it('Wraps the function with context', () => {
+      return new Promise<void>(done => {
+        const fn = () => {
+          expect(ctx.use()).toMatchInlineSnapshot(`
+            {
+              "value": 55,
+            }
+          `);
+          done(); // this makes sure the function actually runs
+        };
+        const bound = ctx.bind({ value: 55 }, fn);
+        bound();
+      });
+    });
+
+    it('Passes runtime arguments to bound function', () => {
+      const fn = vi.fn();
+      const args = Array.from({ length: 100 }, (_, i) => `${i}`); // 1-100
+      ctx.bind({}, fn)(...args);
+
+      expect(fn).toHaveBeenCalledWith(...args);
+    });
+
+    it('Maintains normal context behavior when runs within context.run', () => {
+      return new Promise<void>(done => {
+        const fn = () => {
+          expect(ctx.use()).toMatchObject({ value: 200, value2: 300 });
+          expect(ctx.use()).toMatchInlineSnapshot(`
+            {
+              "value": 200,
+              "value2": 300,
+            }
+          `);
+          done();
+        };
+
+        const bound = ctx.bind({ value2: 300 }, fn);
+        ctx.run({ value: 200, value2: 200 }, bound);
+      });
+    });
+  });
+
+  describe('context.use', () => {
+    describe('When in an active context', () => {
+      it('Should return a cloned ctxRef object', () => {
+        const ctxRef = { a: 1, b: 2 };
+
+        ctx.run(ctxRef, () => {
+          expect(ctx.use()).toEqual(ctxRef);
+        });
+      });
+
+      it('Should return a frozen context object', () => {
+        const ctxRef = { a: 1, b: 2 };
+
+        ctx.run(ctxRef, () => {
+          expect(Object.isFrozen(ctx.use())).toBe(true);
+        });
+      });
+
+      describe('When before running the context', () => {
+        it('Should return undefined', () => {
+          expect(ctx.use()).toBeUndefined();
+        });
+      });
+
+      describe('When after closing the context', () => {
+        it('Should return undefined', () => {
+          ctx.run({}, () => {});
+          expect(ctx.use()).toBeUndefined();
+        });
+      });
+    });
+  });
+
+  describe('context.useX', () => {
+    describe('When in an active context', () => {
+      it('Should return a cloned ctxRef object', () => {
+        const ctxRef = { a: 1, b: 2 };
+
+        ctx.run(ctxRef, () => {
+          expect(ctx.useX()).toEqual(ctxRef);
+        });
+      });
+
+      it('Should return a frozen context object', () => {
+        const ctxRef = { a: 1, b: 2 };
+
+        ctx.run(ctxRef, () => {
+          expect(Object.isFrozen(ctx.useX())).toBe(true);
+        });
+      });
+
+      describe('When before running the context', () => {
+        it('Should throw error', () => {
+          expect(() => ctx.useX()).toThrow('Not inside of a running context.');
+        });
+
+        it('Should allow a custom context message', () => {
+          expect(() => ctx.useX('Custom Failure Message')).toThrow(
+            'Custom Failure Message',
+          );
+        });
+      });
+
+      describe('When after closing the context', () => {
+        beforeEach(() => {
+          ctx.run({}, () => {});
+        });
+
+        it('Should return undefined', () => {
+          expect(() => ctx.useX()).toThrow('Not inside of a running context.');
+        });
+
+        it('Should allow a custom context message', () => {
+          expect(() => ctx.useX('Custom Failure Message')).toThrow(
+            'Custom Failure Message',
+          );
+        });
+      });
+    });
+  });
+
+  describe('init argument', () => {
+    it('Should run init function on every context.run', () => {
+      const init = vi.fn();
+
+      const ctx = createCascade(init);
+
+      expect(init).not.toHaveBeenCalled();
+
+      ctx.run({}, () => {
+        expect(init).toHaveBeenCalledTimes(1);
+        ctx.run({}, () => {
+          expect(init).toHaveBeenCalledTimes(2);
+          ctx.run({}, () => {
+            expect(init).toHaveBeenCalledTimes(3);
+          });
+        });
+      });
+      expect(init).toHaveBeenCalledTimes(3);
+
+      ctx.run({}, () => {
+        expect(init).toHaveBeenCalledTimes(4);
+      });
+      expect(init).toHaveBeenCalledTimes(4);
+    });
+
+    it('Should accept ctxRef as first argument', () => {
+      const init = vi.fn();
+
+      const ctx = createCascade(init);
+      const ref1 = { a: 1, b: 2 };
+      const ref2 = { a: 2, b: 3 };
+
+      ctx.run(ref1, () => {
+        ctx.run(ref2, () => null);
+      });
+      expect(init.mock.calls[0][0]).toBe(ref1);
+      expect(init.mock.calls[1][0]).toBe(ref2);
+    });
+
+    it('Should accept parentContext as second argument', () => {
+      const init = vi.fn();
+
+      const ctx = createCascade(init);
+      let p1;
+      ctx.run({}, () => {
+        p1 = ctx.use();
+        ctx.run({}, () => null);
+      });
+      expect(init.mock.calls[0][1]).toBeUndefined();
+      expect(init.mock.calls[1][1]).toBe(p1);
+    });
+
+    it('When not nullish, should use init value as ctxRef', () => {
+      const ctx = createCascade<{ override?: boolean; value?: string }>(() => ({
+        override: true,
+      }));
+      ctx.run({ value: 'x' }, () => {
+        expect(ctx.useX().override).toBe(true);
+        expect(ctx.useX().value).toBeUndefined();
+      });
+    });
+
+    it('When nullish, should default to ctxRef', () => {
+      const ctx = createCascade(() => null);
+
+      ctx.run({ value: 'x' }, () => {
+        expect(ctx.useX().value).toBe('x');
+      });
+    });
+  });
+});

package/src/__tests__/context.test.ts

@@ -0,0 +1,104 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+
+import { createContext, CtxApi } from '../context';
+
+describe('Context', () => {
+  let ctx: CtxApi<any>;
+
+  beforeEach(() => {
+    ctx = createContext();
+  });
+
+  describe('Exposed Methods', () => {
+    it('should have a use method', () => {
+      expect(ctx.use).toBeInstanceOf(Function);
+    });
+
+    it('should have a run method', () => {
+      expect(ctx.run).toBeInstanceOf(Function);
+    });
+  });
+
+  describe('use', () => {
+    describe('When not inside of an active context', () => {
+      describe('When a default value was not provided', () => {
+        it('should return undefined', () => {
+          expect(ctx.use()).toBeUndefined();
+        });
+      });
+
+      describe('When a default value was provided', () => {
+        beforeEach(() => {
+          ctx = createContext('i am the default value!');
+        });
+
+        it('should return the default value', () => {
+          expect(ctx.use()).toBe('i am the default value!');
+        });
+      });
+    });
+  });
+
+  describe('useX', () => {
+    describe('When not inside of an active context', () => {
+      it('Should throw an error', () => {
+        expect(() => {
+          ctx.useX();
+        }).toThrow('Not inside of a running context.');
+      });
+
+      it('Should throw an error with a custom message when passed', () => {
+        expect(() => {
+          ctx.useX('i am the error message!');
+        }).toThrow('i am the error message!');
+      });
+
+      describe('When a default value was provided', () => {
+        beforeEach(() => {
+          ctx = createContext('i am the default value!');
+        });
+        it('Should disregard default value', () => {
+          expect(() => {
+            ctx.useX();
+          }).toThrow('Not inside of a running context.');
+        });
+      });
+    });
+  });
+
+  describe('run', () => {
+    describe('It should set the current context value to the passed value', () => {
+      it('should set the current context value to the passed value', () => {
+        const value = { some: 'object' };
+        ctx.run(value, () => {
+          expect(ctx.use()).toBe(value);
+        });
+      });
+    });
+
+    describe('When nesting run calls', () => {
+      it("sets each layer's context with its respective value", () => {
+        const value_a = { some: 'object' };
+        ctx.run(value_a, () => {
+          expect(ctx.use()).toBe(value_a);
+          const value_b = { another: 'obj' };
+          ctx.run(value_b, () => {
+            expect(ctx.use()).toBe(value_b);
+          });
+        });
+      });
+
+      it('Restores the previous context value when exiting a context layer', () => {
+        const value_a = { some: 'object' };
+        ctx.run(value_a, () => {
+          const value_b = { another: 'obj' };
+          ctx.run(value_b, () => {
+            expect(ctx.use()).toBe(value_b);
+          });
+          expect(ctx.use()).toBe(value_a);
+        });
+        expect(ctx.use()).toBeUndefined();
+      });
+    });
+  });
+});

package/src/context.ts

@@ -0,0 +1,100 @@
+import type { CB, Maybe } from 'vest-utils';
+import {
+  assign,
+  defaultTo,
+  invariant,
+  dynamicValue,
+  Nullable,
+} from 'vest-utils';
+
+const USEX_DEFAULT_ERROR_MESSAGE = 'Not inside of a running context.';
+const EMPTY_CONTEXT = Symbol();
+
+/**
+ * Base context interface.
+ */
+export function createContext<T>(defaultContextValue?: T): CtxApi<T> {
+  let contextValue: T | symbol = EMPTY_CONTEXT;
+
+  return {
+    run,
+    use,
+    useX,
+  };
+
+  function use(): T {
+    return (isInsideContext() ? contextValue : defaultContextValue) as T;
+  }
+
+  function useX(errorMessage?: string): T {
+    invariant(
+      isInsideContext(),
+      defaultTo(errorMessage, USEX_DEFAULT_ERROR_MESSAGE),
+    );
+    return contextValue as T;
+  }
+
+  function run<R>(value: T, cb: () => R): R {
+    const parentContext = isInsideContext() ? use() : EMPTY_CONTEXT;
+
+    contextValue = value;
+
+    const res = cb();
+
+    contextValue = parentContext;
+    return res;
+  }
+
+  function isInsideContext(): boolean {
+    return contextValue !== EMPTY_CONTEXT;
+  }
+}
+
+/**
+ * Cascading context - another implementation of context, that assumes the context value is an object.
+ * When nesting context runs, the the values of the current layer merges with the layers above it.
+ */
+export function createCascade<T extends Record<string, unknown>>(
+  init?: (value: Partial<T>, parentContext: Maybe<T>) => Nullable<T>,
+): CtxCascadeApi<T> {
+  const ctx = createContext<T>();
+
+  return {
+    bind,
+    run,
+    use: ctx.use,
+    useX: ctx.useX,
+  };
+
+  function run<R>(value: Partial<T>, fn: () => R): R {
+    const parentContext = ctx.use();
+
+    const initResult = dynamicValue(init, value, parentContext) ?? value;
+
+    const out = assign({}, parentContext ? parentContext : {}, initResult) as T;
+
+    return ctx.run(Object.freeze(out), fn) as R;
+  }
+
+  function bind<Fn extends CB>(value: Partial<T>, fn: Fn) {
+    return function (...runTimeArgs: Parameters<Fn>) {
+      return run<ReturnType<Fn>>(value, function () {
+        return fn(...runTimeArgs);
+      });
+    } as Fn;
+  }
+}
+
+type ContextConsumptionApi<T> = {
+  use: () => T;
+  useX: (errorMessage?: string) => T;
+};
+
+export type CtxApi<T> = ContextConsumptionApi<T> & {
+  run: <R>(value: T, cb: () => R) => R;
+};
+
+export type CtxCascadeApi<T> = ContextConsumptionApi<T> & {
+  run: <R>(value: Partial<T>, fn: () => R) => R;
+  bind: <Fn extends CB>(value: Partial<T>, fn: Fn) => Fn;
+};

package/types/context.d.cts

@@ -0,0 +1,27 @@
+import { CB, Maybe, Nullable } from "vest-utils";
+
+//#region src/context.d.ts
+
+/**
+ * Base context interface.
+ */
+declare function createContext<T>(defaultContextValue?: T): CtxApi<T>;
+/**
+ * Cascading context - another implementation of context, that assumes the context value is an object.
+ * When nesting context runs, the the values of the current layer merges with the layers above it.
+ */
+declare function createCascade<T extends Record<string, unknown>>(init?: (value: Partial<T>, parentContext: Maybe<T>) => Nullable<T>): CtxCascadeApi<T>;
+type ContextConsumptionApi<T> = {
+  use: () => T;
+  useX: (errorMessage?: string) => T;
+};
+type CtxApi<T> = ContextConsumptionApi<T> & {
+  run: <R>(value: T, cb: () => R) => R;
+};
+type CtxCascadeApi<T> = ContextConsumptionApi<T> & {
+  run: <R>(value: Partial<T>, fn: () => R) => R;
+  bind: <Fn extends CB>(value: Partial<T>, fn: Fn) => Fn;
+};
+//#endregion
+export { CtxApi, CtxCascadeApi, createCascade, createContext };
+//# sourceMappingURL=context.d.cts.map

package/types/context.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"context.d.cts","names":["CB","Maybe","Nullable","createContext","T","CtxApi","createCascade","Record","Partial","CtxCascadeApi","ContextConsumptionApi","R","Fn"],"sources":["../src/context.d.ts"],"sourcesContent":["import type { CB, Maybe } from 'vest-utils';\nimport { Nullable } from 'vest-utils';\n/**\n * Base context interface.\n */\nexport declare function createContext<T>(defaultContextValue?: T): CtxApi<T>;\n/**\n * Cascading context - another implementation of context, that assumes the context value is an object.\n * When nesting context runs, the the values of the current layer merges with the layers above it.\n */\nexport declare function createCascade<T extends Record<string, unknown>>(init?: (value: Partial<T>, parentContext: Maybe<T>) => Nullable<T>): CtxCascadeApi<T>;\ntype ContextConsumptionApi<T> = {\n    use: () => T;\n    useX: (errorMessage?: string) => T;\n};\nexport type CtxApi<T> = ContextConsumptionApi<T> & {\n    run: <R>(value: T, cb: () => R) => R;\n};\nexport type CtxCascadeApi<T> = ContextConsumptionApi<T> & {\n    run: <R>(value: Partial<T>, fn: () => R) => R;\n    bind: <Fn extends CB>(value: Partial<T>, fn: Fn) => Fn;\n};\nexport {};\n"],"mappings":";;;;;AAKA;;AAA0EI,iBAAlDD,aAAkDC,CAAAA,CAAAA,CAAAA,CAAAA,mBAAAA,CAAAA,EAAXA,CAAWA,CAAAA,EAAPC,MAAOD,CAAAA,CAAAA,CAAAA;;;AAK1E;;AAAgGA,iBAAxEE,aAAwEF,CAAAA,UAAhDG,MAAgDH,CAAAA,MAAAA,EAAAA,OAAAA,CAAAA,CAAAA,CAAAA,IAAAA,CAAAA,EAAAA,CAAAA,KAAAA,EAARI,OAAQJ,CAAAA,CAAAA,CAAAA,EAAAA,aAAAA,EAAmBH,KAAnBG,CAAyBA,CAAzBA,CAAAA,EAAAA,GAAgCF,QAAhCE,CAAyCA,CAAzCA,CAAAA,CAAAA,EAA8CK,aAA9CL,CAA4DA,CAA5DA,CAAAA;KAC3FM,qBADmFF,CAAAA,CAAAA,CAAAA,GAAAA;EAAiCJ,GAAAA,EAAAA,GAAAA,GAE1GA,CAF0GA;EAANH,IAAAA,EAAAA,CAAAA,YAAAA,CAAAA,EAAAA,MAAAA,EAAAA,GAG9EG,CAH8EH;CAAsBG;AAATF,KAKpHG,MALoHH,CAAAA,CAAAA,CAAAA,GAKxGQ,qBALwGR,CAKlFE,CALkFF,CAAAA,GAAAA;EAA4BE,GAAAA,EAAAA,CAAAA,CAAAA,CAAAA,CAAAA,KAAAA,EAMxIA,CANwIA,EAAAA,EAAAA,EAAAA,GAAAA,GAM3HO,CAN2HP,EAAAA,GAMrHO,CANqHP;CAAdK;AAAa,KAQ/IA,aAR+I,CAAA,CAAA,CAAA,GAQ5HC,qBAR4H,CAQtGN,CARsG,CAAA,GAAA;EACtJM,GAAAA,EAAAA,CAAAA,CAAAA,CAAAA,CAAAA,KAAAA,EAQeF,OARfE,CAQuBN,CARF,CAAA,EAAA,EAAAA,EAAAA,GAAA,GAQgBO,CANLP,EAAC,GAMUO,CANV;EAE1BN,IAAAA,EAAAA,CAAAA,WAKUL,EALJI,CAAAA,CAAAA,KAAA,EAKeI,OALf,CAKuBJ,CALvB,CAAA,EAAA,EAAA,EAK+BQ,EAL/B,EAAA,GAKsCA,EALtC;CAA4BR"}

package/types/context.d.mts

@@ -0,0 +1,27 @@
+import { CB, Maybe, Nullable } from "vest-utils";
+
+//#region src/context.d.ts
+
+/**
+ * Base context interface.
+ */
+declare function createContext<T>(defaultContextValue?: T): CtxApi<T>;
+/**
+ * Cascading context - another implementation of context, that assumes the context value is an object.
+ * When nesting context runs, the the values of the current layer merges with the layers above it.
+ */
+declare function createCascade<T extends Record<string, unknown>>(init?: (value: Partial<T>, parentContext: Maybe<T>) => Nullable<T>): CtxCascadeApi<T>;
+type ContextConsumptionApi<T> = {
+  use: () => T;
+  useX: (errorMessage?: string) => T;
+};
+type CtxApi<T> = ContextConsumptionApi<T> & {
+  run: <R>(value: T, cb: () => R) => R;
+};
+type CtxCascadeApi<T> = ContextConsumptionApi<T> & {
+  run: <R>(value: Partial<T>, fn: () => R) => R;
+  bind: <Fn extends CB>(value: Partial<T>, fn: Fn) => Fn;
+};
+//#endregion
+export { CtxApi, CtxCascadeApi, createCascade, createContext };
+//# sourceMappingURL=context.d.mts.map

package/types/context.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"context.d.mts","names":["CB","Maybe","Nullable","createContext","T","CtxApi","createCascade","Record","Partial","CtxCascadeApi","ContextConsumptionApi","R","Fn"],"sources":["../src/context.d.ts"],"sourcesContent":["import type { CB, Maybe } from 'vest-utils';\nimport { Nullable } from 'vest-utils';\n/**\n * Base context interface.\n */\nexport declare function createContext<T>(defaultContextValue?: T): CtxApi<T>;\n/**\n * Cascading context - another implementation of context, that assumes the context value is an object.\n * When nesting context runs, the the values of the current layer merges with the layers above it.\n */\nexport declare function createCascade<T extends Record<string, unknown>>(init?: (value: Partial<T>, parentContext: Maybe<T>) => Nullable<T>): CtxCascadeApi<T>;\ntype ContextConsumptionApi<T> = {\n    use: () => T;\n    useX: (errorMessage?: string) => T;\n};\nexport type CtxApi<T> = ContextConsumptionApi<T> & {\n    run: <R>(value: T, cb: () => R) => R;\n};\nexport type CtxCascadeApi<T> = ContextConsumptionApi<T> & {\n    run: <R>(value: Partial<T>, fn: () => R) => R;\n    bind: <Fn extends CB>(value: Partial<T>, fn: Fn) => Fn;\n};\nexport {};\n"],"mappings":";;;;;AAKA;;AAA0EI,iBAAlDD,aAAkDC,CAAAA,CAAAA,CAAAA,CAAAA,mBAAAA,CAAAA,EAAXA,CAAWA,CAAAA,EAAPC,MAAOD,CAAAA,CAAAA,CAAAA;;;AAK1E;;AAAgGA,iBAAxEE,aAAwEF,CAAAA,UAAhDG,MAAgDH,CAAAA,MAAAA,EAAAA,OAAAA,CAAAA,CAAAA,CAAAA,IAAAA,CAAAA,EAAAA,CAAAA,KAAAA,EAARI,OAAQJ,CAAAA,CAAAA,CAAAA,EAAAA,aAAAA,EAAmBH,KAAnBG,CAAyBA,CAAzBA,CAAAA,EAAAA,GAAgCF,QAAhCE,CAAyCA,CAAzCA,CAAAA,CAAAA,EAA8CK,aAA9CL,CAA4DA,CAA5DA,CAAAA;KAC3FM,qBADmFF,CAAAA,CAAAA,CAAAA,GAAAA;EAAiCJ,GAAAA,EAAAA,GAAAA,GAE1GA,CAF0GA;EAANH,IAAAA,EAAAA,CAAAA,YAAAA,CAAAA,EAAAA,MAAAA,EAAAA,GAG9EG,CAH8EH;CAAsBG;AAATF,KAKpHG,MALoHH,CAAAA,CAAAA,CAAAA,GAKxGQ,qBALwGR,CAKlFE,CALkFF,CAAAA,GAAAA;EAA4BE,GAAAA,EAAAA,CAAAA,CAAAA,CAAAA,CAAAA,KAAAA,EAMxIA,CANwIA,EAAAA,EAAAA,EAAAA,GAAAA,GAM3HO,CAN2HP,EAAAA,GAMrHO,CANqHP;CAAdK;AAAa,KAQ/IA,aAR+I,CAAA,CAAA,CAAA,GAQ5HC,qBAR4H,CAQtGN,CARsG,CAAA,GAAA;EACtJM,GAAAA,EAAAA,CAAAA,CAAAA,CAAAA,CAAAA,KAAAA,EAQeF,OARfE,CAQuBN,CARF,CAAA,EAAA,EAAAA,EAAAA,GAAA,GAQgBO,CANLP,EAAC,GAMUO,CANV;EAE1BN,IAAAA,EAAAA,CAAAA,WAKUL,EALJI,CAAAA,CAAAA,KAAA,EAKeI,OALf,CAKuBJ,CALvB,CAAA,EAAA,EAAA,EAK+BQ,EAL/B,EAAA,GAKsCA,EALtC;CAA4BR"}

package/types/context.d.ts

@@ -1,23 +1,27 @@
-import { CB } from 'vest-utils';
+import { CB, Maybe, Nullable } from "vest-utils";
+
+//#region src/context.d.ts
+
 /**
  * Base context interface.
  */
-declare function createContext<T extends unknown>(defaultContextValue?: T): CtxApi<T>;
+declare function createContext<T>(defaultContextValue?: T): CtxApi<T>;
 /**
  * Cascading context - another implementation of context, that assumes the context value is an object.
  * When nesting context runs, the the values of the current layer merges with the layers above it.
  */
-declare function createCascade<T extends Record<string, unknown>>(init?: (value: Partial<T>, parentContext: T | void) => T | null): CtxCascadeApi<T>;
+declare function createCascade<T extends Record<string, unknown>>(init?: (value: Partial<T>, parentContext: Maybe<T>) => Nullable<T>): CtxCascadeApi<T>;
 type ContextConsumptionApi<T> = {
-    use: () => T;
-    useX: (errorMessage?: string) => T;
+  use: () => T;
+  useX: (errorMessage?: string) => T;
 };
 type CtxApi<T> = ContextConsumptionApi<T> & {
-    run: <R>(value: T, cb: () => R) => R;
+  run: <R>(value: T, cb: () => R) => R;
 };
 type CtxCascadeApi<T> = ContextConsumptionApi<T> & {
-    run: <R>(value: Partial<T>, fn: () => R) => R;
-    bind: <Fn extends CB>(value: Partial<T>, fn: Fn) => Fn;
+  run: <R>(value: Partial<T>, fn: () => R) => R;
+  bind: <Fn extends CB>(value: Partial<T>, fn: Fn) => Fn;
 };
-export { createContext, createCascade, CtxApi, CtxCascadeApi };
-//# sourceMappingURL=context.d.ts.map
+//#endregion
+export { CtxApi, CtxCascadeApi, createCascade, createContext };
+//# sourceMappingURL=context.d.cts.map

package/vitest.config.ts

@@ -0,0 +1,21 @@
+import path, { resolve } from 'path';
+import { fileURLToPath } from 'url';
+
+import { defineConfig } from 'vitest/config';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+export default defineConfig({
+  test: {
+    globals: true,
+    include: ['./**/__tests__/*.test.ts'],
+    setupFiles: [resolve(__dirname, '../../', 'vx/config/vitest')],
+  },
+  root: __dirname,
+  resolve: {
+    alias: {
+      context: resolve(__dirname, 'src/context.ts'),
+    },
+  },
+});