context 4.0.0 → 4.0.1

package/README.md

@@ -1,214 +1,79 @@
 # Context 🪆
 
-[![Join Discord](https://badgen.net/discord/online-members/WmADZpJnSe?icon=discord&label=Discord)](https://discord.gg/WmADZpJnSe) [![Version](https://badgen.net/npm/v/vest?&icon=npm)](https://www.npmjs.com/package/context) [![Downloads](https://badgen.net/npm/dt/context?label=Downloads)](https://www.npmjs.com/package/context) [![bundlephobia](https://badgen.net/bundlephobia/minzip/context)](https://bundlephobia.com/package/context) [![Status](https://badgen.net/github/status/ealush/vest)](https://github.com/ealush/vest/actions)
+Lightweight context propagation for JavaScript and TypeScript. Create a scoped storage object, run code inside it, and read the active value anywhere down the call stack - without depending on React.
 
-Simple utility for context propagation within Javascript applications and libraries. Loosely based on the ideas behind React's context, allows you to achieve the same goals (and more) without actually using react.
-It allows you to keep reference for shared variables, and access them down in your function call even if not declared in the same scope.
+- `createContext(defaultValue?)` – simplest option with a single value per run.
+- `createCascade(initializer?)` – merges parent and child context objects, ideal for layered data.
+- `bind` – capture context for later execution (useful with async callbacks).
 
-## How Context Works?
+## Installation
 
-The way context works is quite simple. Creating a context initializes a closure with a context storage object. When you run your context call, it takes your values, and places them in the context's closure. When your function finishes running, the context is cleared.
-
-The reason the context is cleared after its run is so that items can't override one another. Assume you have two running the same async function twice, and it writes to the context, expecting to read the value somewhere down the line. Now you have two competing consumers of this single resource, and one eventually get the wrong value since they both read from and write to the same place.
-
-## API Reference
-
-### Top Level Exports
-
-The context package exports these two functions:
-
-- `createContext`: Creates a new context.
-- `createCascade`: Creates a new cascading context.
-
-## createContext()
-
-Create context is the minimal implementation of context. It allows propagation of values down in your function call.
-
-createContext takes a single argument - defaultContextValue. This value is used when not withing a running context.
-
-### Arguments
-
-| Argument            | Type  | Optional? | Description                                                  |
-| ------------------- | ----- | --------- | ------------------------------------------------------------ |
-| defaultContextValue | `any` | Yes       | The default value to use when not withing a running context. |
-
-### Returned object
-
-`createContext` returns an object containing the following functions:
-
-- `use`: Returns the current context value, or the default value when not withing a running context.
-- `useX`: Returns the current context, throws an error if not within a running context or the context is undefined. `useX` will throw even if a default value is provided.
-- `run`: Runs the context, passing the given value into the context.
-
-**Note About Typescript Usage**
-For convenience, `use` assumes we're alwyas inside a context. If you want to have runtime safety, you can use `useX` instead to make sure you're excplicitly using a defined context.
-
-### Usage Example
-
-```js
-const context = createContext(0); // Create a context with a default value of 0.
-
-function myFunc() {
-  context.run(100, someOtherFunc); // Run the context with a value of 100.
-}
-
-function someOtherFunc() {
-  const number = context.use(); // Returns the value of the context.
-}
+```bash
+npm i context
 ```
 
-## createCascade()
-
-`createCascade` is a more advanced version of `createContext` that allows you to create cascading contexts. It assumes the value is always an object, and when nesting context layers, it merges their values together.
-
-`createCascade` does not take a default value, but an initializer function instead. This initializer is called on each `run` call, and it allows you to modify or augment the context value being passed down. The init function is passed the context object run was called with, and the parent context if it was called within a previously created context. The init function needs to return the desired context object.
-
-### Arguments
+## createContext
 
-| Argument    | Type       | Optional? | Description                                                  |
-| ----------- | ---------- | --------- | ------------------------------------------------------------ |
-| initializer | `Function` | Yes       | The initializer function to use when creating a new context. |
-
-The initializer function can either return the the next context object. If null is returned itself, the initializer will take no effect.
-The initializer receives the context object, and the parent context object, if present.
-
-### Returned object
-
-`createCascade` returns an object containing the following functions:
-
-- `use`: Returns the current context value.
-- `useX`: Returns the current context, throws an error if not within a running context.
-- `run`: Runs the context, passing the given value into the context. Merges the given value with the parent context if it exists, while not overriding the parent context.
-- `bind`: Binds a given function to the context. Allows for delayd execution of a function as if it was called within the context.
-
-### Usage Examples
-
-#### Initializer Function
+Create an isolated context with an optional default value used outside of a running scope.
 
 ```js
-createCascade((ctx, parentContext) => {
-  if (parentContext === null) {
-    // we're at the top level
-    // so let's add a default cart object
-    return Object.assign(ctx, {
-      cart: [],
-    });
-  }
-
-  // we're in a sub context, so we already have those default values.
-  return ctx;
-});
-```
-
-#### run()
+import { createContext } from 'context';
 
-Runs a callback function within the context. It takes an object referencing the data you want to store within your context, and a callback function to run.
-
-```js
-// myFunction.js
-import ctx from './ctx';
-import sayUsername from './sayUsername';
+const requestContext = createContext({ requestId: undefined });
 
-function myFunction(username) {
-  return ctx.run({ username }, sayUsername);
+function handleRequest(requestId) {
+  return requestContext.run({ requestId }, () => {
+    logRequest();
+    return doWork();
+  });
 }
-```
-
-If `run` is called within a different `run` call, the context values will be merged when the callback is run. When we exit our callback, the context will be reset to the values it had before the call.
-
-### use() and useX()
 
-These are the main ways to access the context within your code. They return the current object that stored within the context, and differ in the way they handle calls outside of the context.
-
-- use() returns the current object stored within the context, or null if we're not within a `run` call.
-- useX() returns the current object stored within the context, or throws an error if we're not within a `run` call.
-  - useX also takes an optional argument that will be used as the error message if the context is not found.
-
-```js
-// sayUsername.js
-import ctx from './ctx';
-
-function sayUsername() {
-  const context = ctx.use(); // { username: 'John Doe' }
-
-  if (!context) {
-    // we're not within a `run` call. This function was called outside of a running context.
-    return "Hey, I don't know you, and this is crazy!";
-  }
-
-  return `Hello, ${context.username}!`;
+function logRequest() {
+  // Inside run → current context value
+  console.log(requestContext.use().requestId);
 }
 ```
 
-```js
-// handleCart.js
-import ctx from './ctx';
+**API:**
 
-function handleCart() {
-  const context = ctx.useX(
-    'handleCart was called outside of a running context'
-  ); // { cart: { items: [ 'foo', 'bar' ] } }
-  // This throws an error if we're not within a `run` call.
-  // You should catch this error and handle it somewhere above this function.
+- `run(value, callback)` – activates the context for the callback. Nested runs temporarily override the value and restore it afterwards.
+- `use()` – returns the current value or the default when no context is active.
+- `useX(message?)` – like `use`, but throws if called outside of `run`, ignoring any default value.
 
-  return `You have ${context.cart.items.length} items in your cart.`;
-}
-```
-
-### bind()
+## createCascade
 
-Bind a function to a context. It takes an object referencing the data you want to store within your context, and a callback function to run. It returns a function that can be called with the same arguments as the original function. The function will then internally call `run` with the same arguments, and return the result of the callback function, so it is useful if you want to reference a context after it was closed, for example - when running an async function.
+`createCascade` composes context objects instead of replacing them. Each `run` merges the current value with the parent context, so shared properties flow down while children can add or override keys.
 
 ```js
-// getProductData.js
-import ctx from './ctx';
+import { createCascade } from 'context';
 
-function getProductData(productId) {
-  return ctx.bind({ productId }, handleProductData);
+const userContext = createCascade();
 
-  fetchProduct(productId).then(data => {
-    handleProductData(data);
-    // will run the function handleProductData within our context, even though there is no context running at the moment.
+userContext.run({ user: { id: 5, name: 'Ada' } }, () => {
+  // child run inherits id/name and adds role
+  userContext.run({ user: { role: 'admin' } }, () => {
+    const ctx = userContext.use();
+    // ctx.user => { id: 5, name: 'Ada', role: 'admin' }
   });
-}
-```
-
-## Typescript Support
-
-both `createContext` and `createCascade` have full typescript support. To gain the full benefits of typescript within your context, it is best to annotate your context with its types:
-
-```ts
-const someContext = createContext<number>(0);
-
-const someCascadeContext = createCascade<{
-  username: string;
-  firstName: string;
-  middleName?: string;
-  lastName: string;
-  age: number;
-}>();
+});
 ```
 
-This meakes sure that all the functions (`run`, `use`, `useX` and `bind`) will be aware of these types, and either accept them as inputs, or add them to the return value.
-
-## Troubleshooting
-
-### Working with async functions/promises
-
-Working with context inside within async code may lead to unexpected results when we don't fully consider what's happening. Trying to call your context from the async part of your code will probably return `null` instead of your values.
+**API additions:**
 
-This is known and expected behavior. Context is a synchronous context propagation tool that completely relies on the synchronous nature of function calls in JS - this is exactly what allows context to run.
+- `use()` / `useX(message?)` – return the merged object for the current layer.
+- `run(value, callback)` – merges `value` into the parent context without passing arguments to `callback`.
+- `bind(value, callback)` – returns a function that executes `callback` inside a context seeded with `value`, preserving arguments when invoked later.
 
-#### But my function is still running. Why did the context clear?
+## TypeScript
 
-The async parts of your function are actually not executed along with your sync code, and even though you "await" it, the browser carries on and allows other code to run in between instead of blocking execution until your async code is complete.
+Both factories are fully typed. Annotate your contexts for stricter checks:
 
-#### Ok, so what do I do?
-
-There are multiple strategies of handling async functions with context.
+```ts
+const settings = createContext<{ locale: string }>();
+const session = createCascade<{ user?: { id: string } }>();
+```
 
-1. Pulling your values from context right before your async call
-   This is the most obvious and easiest to achieve, though not always what you need. The basic idea is that you take whatever you need from the context when it is still available to you.
+## Notes
 
-2. context.bind or context.run your async function to the context you extracted
-   This is the next logical step - you have a function that you know should run later with your context. You can bind your context to it for delayed execution. When your function runs later down the line within your asynchronous code, internally it will still have access to whatever you bound to it.
+- Context is synchronous by design; reading it after an async boundary requires `bind` or wrapping the async call inside `run`.
+- Each `run` call leaves the parent context untouched once the callback completes.

package/dist/context.cjs

@@ -0,0 +1,64 @@
+let vest_utils = require("vest-utils");
+
+//#region src/context.ts
+const USEX_DEFAULT_ERROR_MESSAGE = "Not inside of a running context.";
+const EMPTY_CONTEXT = Symbol();
+/**
+* Base context interface.
+*/
+function createContext(defaultContextValue) {
+	let contextValue = EMPTY_CONTEXT;
+	return {
+		run,
+		use,
+		useX
+	};
+	function use() {
+		return isInsideContext() ? contextValue : defaultContextValue;
+	}
+	function useX(errorMessage) {
+		(0, vest_utils.invariant)(isInsideContext(), (0, vest_utils.defaultTo)(errorMessage, USEX_DEFAULT_ERROR_MESSAGE));
+		return contextValue;
+	}
+	function run(value, cb) {
+		const parentContext = isInsideContext() ? use() : EMPTY_CONTEXT;
+		contextValue = value;
+		const res = cb();
+		contextValue = parentContext;
+		return res;
+	}
+	function isInsideContext() {
+		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.
+*/
+function createCascade(init) {
+	const ctx = createContext();
+	return {
+		bind,
+		run,
+		use: ctx.use,
+		useX: ctx.useX
+	};
+	function run(value, fn) {
+		const parentContext = ctx.use();
+		const initResult = (0, vest_utils.dynamicValue)(init, value, parentContext) ?? value;
+		const out = (0, vest_utils.assign)({}, parentContext ? parentContext : {}, initResult);
+		return ctx.run(Object.freeze(out), fn);
+	}
+	function bind(value, fn) {
+		return function(...runTimeArgs) {
+			return run(value, function() {
+				return fn(...runTimeArgs);
+			});
+		};
+	}
+}
+
+//#endregion
+exports.createCascade = createCascade;
+exports.createContext = createContext;
+//# sourceMappingURL=context.cjs.map

package/dist/context.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"context.cjs","names":["contextValue: T | symbol"],"sources":["../src/context.ts"],"sourcesContent":["import type { CB, Maybe } from 'vest-utils';\nimport {\n  assign,\n  defaultTo,\n  invariant,\n  dynamicValue,\n  Nullable,\n} from 'vest-utils';\n\nconst USEX_DEFAULT_ERROR_MESSAGE = 'Not inside of a running context.';\nconst EMPTY_CONTEXT = Symbol();\n\n/**\n * Base context interface.\n */\nexport function createContext<T>(defaultContextValue?: T): CtxApi<T> {\n  let contextValue: T | symbol = EMPTY_CONTEXT;\n\n  return {\n    run,\n    use,\n    useX,\n  };\n\n  function use(): T {\n    return (isInsideContext() ? contextValue : defaultContextValue) as T;\n  }\n\n  function useX(errorMessage?: string): T {\n    invariant(\n      isInsideContext(),\n      defaultTo(errorMessage, USEX_DEFAULT_ERROR_MESSAGE),\n    );\n    return contextValue as T;\n  }\n\n  function run<R>(value: T, cb: () => R): R {\n    const parentContext = isInsideContext() ? use() : EMPTY_CONTEXT;\n\n    contextValue = value;\n\n    const res = cb();\n\n    contextValue = parentContext;\n    return res;\n  }\n\n  function isInsideContext(): boolean {\n    return contextValue !== EMPTY_CONTEXT;\n  }\n}\n\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 function createCascade<T extends Record<string, unknown>>(\n  init?: (value: Partial<T>, parentContext: Maybe<T>) => Nullable<T>,\n): CtxCascadeApi<T> {\n  const ctx = createContext<T>();\n\n  return {\n    bind,\n    run,\n    use: ctx.use,\n    useX: ctx.useX,\n  };\n\n  function run<R>(value: Partial<T>, fn: () => R): R {\n    const parentContext = ctx.use();\n\n    const initResult = dynamicValue(init, value, parentContext) ?? value;\n\n    const out = assign({}, parentContext ? parentContext : {}, initResult) as T;\n\n    return ctx.run(Object.freeze(out), fn) as R;\n  }\n\n  function bind<Fn extends CB>(value: Partial<T>, fn: Fn) {\n    return function (...runTimeArgs: Parameters<Fn>) {\n      return run<ReturnType<Fn>>(value, function () {\n        return fn(...runTimeArgs);\n      });\n    } as Fn;\n  }\n}\n\ntype ContextConsumptionApi<T> = {\n  use: () => T;\n  useX: (errorMessage?: string) => T;\n};\n\nexport type CtxApi<T> = ContextConsumptionApi<T> & {\n  run: <R>(value: T, cb: () => R) => R;\n};\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};\n"],"mappings":";;;AASA,MAAM,6BAA6B;AACnC,MAAM,gBAAgB,QAAQ;;;;AAK9B,SAAgB,cAAiB,qBAAoC;CACnE,IAAIA,eAA2B;AAE/B,QAAO;EACL;EACA;EACA;EACD;CAED,SAAS,MAAS;AAChB,SAAQ,iBAAiB,GAAG,eAAe;;CAG7C,SAAS,KAAK,cAA0B;AACtC,4BACE,iBAAiB,4BACP,cAAc,2BAA2B,CACpD;AACD,SAAO;;CAGT,SAAS,IAAO,OAAU,IAAgB;EACxC,MAAM,gBAAgB,iBAAiB,GAAG,KAAK,GAAG;AAElD,iBAAe;EAEf,MAAM,MAAM,IAAI;AAEhB,iBAAe;AACf,SAAO;;CAGT,SAAS,kBAA2B;AAClC,SAAO,iBAAiB;;;;;;;AAQ5B,SAAgB,cACd,MACkB;CAClB,MAAM,MAAM,eAAkB;AAE9B,QAAO;EACL;EACA;EACA,KAAK,IAAI;EACT,MAAM,IAAI;EACX;CAED,SAAS,IAAO,OAAmB,IAAgB;EACjD,MAAM,gBAAgB,IAAI,KAAK;EAE/B,MAAM,0CAA0B,MAAM,OAAO,cAAc,IAAI;EAE/D,MAAM,6BAAa,EAAE,EAAE,gBAAgB,gBAAgB,EAAE,EAAE,WAAW;AAEtE,SAAO,IAAI,IAAI,OAAO,OAAO,IAAI,EAAE,GAAG;;CAGxC,SAAS,KAAoB,OAAmB,IAAQ;AACtD,SAAO,SAAU,GAAG,aAA6B;AAC/C,UAAO,IAAoB,OAAO,WAAY;AAC5C,WAAO,GAAG,GAAG,YAAY;KACzB"}

package/dist/context.mjs

@@ -0,0 +1,63 @@
+import { assign, defaultTo, dynamicValue, invariant } from "vest-utils";
+
+//#region src/context.ts
+const USEX_DEFAULT_ERROR_MESSAGE = "Not inside of a running context.";
+const EMPTY_CONTEXT = Symbol();
+/**
+* Base context interface.
+*/
+function createContext(defaultContextValue) {
+	let contextValue = EMPTY_CONTEXT;
+	return {
+		run,
+		use,
+		useX
+	};
+	function use() {
+		return isInsideContext() ? contextValue : defaultContextValue;
+	}
+	function useX(errorMessage) {
+		invariant(isInsideContext(), defaultTo(errorMessage, USEX_DEFAULT_ERROR_MESSAGE));
+		return contextValue;
+	}
+	function run(value, cb) {
+		const parentContext = isInsideContext() ? use() : EMPTY_CONTEXT;
+		contextValue = value;
+		const res = cb();
+		contextValue = parentContext;
+		return res;
+	}
+	function isInsideContext() {
+		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.
+*/
+function createCascade(init) {
+	const ctx = createContext();
+	return {
+		bind,
+		run,
+		use: ctx.use,
+		useX: ctx.useX
+	};
+	function run(value, fn) {
+		const parentContext = ctx.use();
+		const initResult = dynamicValue(init, value, parentContext) ?? value;
+		const out = assign({}, parentContext ? parentContext : {}, initResult);
+		return ctx.run(Object.freeze(out), fn);
+	}
+	function bind(value, fn) {
+		return function(...runTimeArgs) {
+			return run(value, function() {
+				return fn(...runTimeArgs);
+			});
+		};
+	}
+}
+
+//#endregion
+export { createCascade, createContext };
+//# sourceMappingURL=context.mjs.map

package/dist/context.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"context.mjs","names":["contextValue: T | symbol"],"sources":["../src/context.ts"],"sourcesContent":["import type { CB, Maybe } from 'vest-utils';\nimport {\n  assign,\n  defaultTo,\n  invariant,\n  dynamicValue,\n  Nullable,\n} from 'vest-utils';\n\nconst USEX_DEFAULT_ERROR_MESSAGE = 'Not inside of a running context.';\nconst EMPTY_CONTEXT = Symbol();\n\n/**\n * Base context interface.\n */\nexport function createContext<T>(defaultContextValue?: T): CtxApi<T> {\n  let contextValue: T | symbol = EMPTY_CONTEXT;\n\n  return {\n    run,\n    use,\n    useX,\n  };\n\n  function use(): T {\n    return (isInsideContext() ? contextValue : defaultContextValue) as T;\n  }\n\n  function useX(errorMessage?: string): T {\n    invariant(\n      isInsideContext(),\n      defaultTo(errorMessage, USEX_DEFAULT_ERROR_MESSAGE),\n    );\n    return contextValue as T;\n  }\n\n  function run<R>(value: T, cb: () => R): R {\n    const parentContext = isInsideContext() ? use() : EMPTY_CONTEXT;\n\n    contextValue = value;\n\n    const res = cb();\n\n    contextValue = parentContext;\n    return res;\n  }\n\n  function isInsideContext(): boolean {\n    return contextValue !== EMPTY_CONTEXT;\n  }\n}\n\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 function createCascade<T extends Record<string, unknown>>(\n  init?: (value: Partial<T>, parentContext: Maybe<T>) => Nullable<T>,\n): CtxCascadeApi<T> {\n  const ctx = createContext<T>();\n\n  return {\n    bind,\n    run,\n    use: ctx.use,\n    useX: ctx.useX,\n  };\n\n  function run<R>(value: Partial<T>, fn: () => R): R {\n    const parentContext = ctx.use();\n\n    const initResult = dynamicValue(init, value, parentContext) ?? value;\n\n    const out = assign({}, parentContext ? parentContext : {}, initResult) as T;\n\n    return ctx.run(Object.freeze(out), fn) as R;\n  }\n\n  function bind<Fn extends CB>(value: Partial<T>, fn: Fn) {\n    return function (...runTimeArgs: Parameters<Fn>) {\n      return run<ReturnType<Fn>>(value, function () {\n        return fn(...runTimeArgs);\n      });\n    } as Fn;\n  }\n}\n\ntype ContextConsumptionApi<T> = {\n  use: () => T;\n  useX: (errorMessage?: string) => T;\n};\n\nexport type CtxApi<T> = ContextConsumptionApi<T> & {\n  run: <R>(value: T, cb: () => R) => R;\n};\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};\n"],"mappings":";;;AASA,MAAM,6BAA6B;AACnC,MAAM,gBAAgB,QAAQ;;;;AAK9B,SAAgB,cAAiB,qBAAoC;CACnE,IAAIA,eAA2B;AAE/B,QAAO;EACL;EACA;EACA;EACD;CAED,SAAS,MAAS;AAChB,SAAQ,iBAAiB,GAAG,eAAe;;CAG7C,SAAS,KAAK,cAA0B;AACtC,YACE,iBAAiB,EACjB,UAAU,cAAc,2BAA2B,CACpD;AACD,SAAO;;CAGT,SAAS,IAAO,OAAU,IAAgB;EACxC,MAAM,gBAAgB,iBAAiB,GAAG,KAAK,GAAG;AAElD,iBAAe;EAEf,MAAM,MAAM,IAAI;AAEhB,iBAAe;AACf,SAAO;;CAGT,SAAS,kBAA2B;AAClC,SAAO,iBAAiB;;;;;;;AAQ5B,SAAgB,cACd,MACkB;CAClB,MAAM,MAAM,eAAkB;AAE9B,QAAO;EACL;EACA;EACA,KAAK,IAAI;EACT,MAAM,IAAI;EACX;CAED,SAAS,IAAO,OAAmB,IAAgB;EACjD,MAAM,gBAAgB,IAAI,KAAK;EAE/B,MAAM,aAAa,aAAa,MAAM,OAAO,cAAc,IAAI;EAE/D,MAAM,MAAM,OAAO,EAAE,EAAE,gBAAgB,gBAAgB,EAAE,EAAE,WAAW;AAEtE,SAAO,IAAI,IAAI,OAAO,OAAO,IAAI,EAAE,GAAG;;CAGxC,SAAS,KAAoB,OAAmB,IAAQ;AACtD,SAAO,SAAU,GAAG,aAA6B;AAC/C,UAAO,IAAoB,OAAO,WAAY;AAC5C,WAAO,GAAG,GAAG,YAAY;KACzB"}

package/package.json

@@ -1,8 +1,8 @@
 {
-  "version": "4.0.0",
+  "version": "4.0.1",
   "license": "MIT",
-  "main": "./dist/cjs/context.js",
-  "types": "./types/context.d.ts",
+  "main": "./dist/context.cjs",
+  "types": "./types/context.d.cts",
   "name": "context",
   "author": "ealush",
   "scripts": {
@@ -11,41 +11,33 @@
     "release": "vx release"
   },
   "dependencies": {
-    "vest-utils": "^0.0.5"
-  },
-  "module": "./dist/es/context.production.js",
-  "exports": {
-    ".": {
-      "development": {
-        "types": "./types/context.d.ts",
-        "browser": "./dist/es/context.development.js",
-        "umd": "./dist/umd/context.development.js",
-        "import": "./dist/es/context.development.js",
-        "require": "./dist/cjs/context.development.js",
-        "node": "./dist/cjs/context.development.js",
-        "module": "./dist/es/context.development.js",
-        "default": "./dist/cjs/context.development.js"
-      },
-      "types": "./types/context.d.ts",
-      "browser": "./dist/es/context.production.js",
-      "umd": "./dist/umd/context.production.js",
-      "import": "./dist/es/context.production.js",
-      "require": "./dist/cjs/context.production.js",
-      "node": "./dist/cjs/context.production.js",
-      "module": "./dist/es/context.production.js",
-      "default": "./dist/cjs/context.production.js"
-    },
-    "./package.json": "./package.json",
-    "./*": "./*"
+    "vest-utils": "^2.0.1"
   },
+  "module": "./dist/context.mjs",
   "repository": {
     "type": "git",
-    "url": "https://github.com/ealush/vest.git",
+    "url": "git+https://github.com/ealush/vest.git",
     "directory": "packages/context"
   },
   "bugs": {
     "url": "https://github.com/ealush/vest.git/issues"
   },
-  "unpkg": "./dist/umd/context.production.js",
-  "jsdelivr": "./dist/umd/context.production.js"
+  "unpkg": "./dist/context.mjs",
+  "jsdelivr": "./dist/context.mjs",
+  "exports": {
+    ".": {
+      "types": "./types/context.d.cts",
+      "require": "./dist/context.cjs",
+      "import": "./dist/context.mjs"
+    },
+    "./*": {
+      "types": "./types/context.d.cts",
+      "default": "./*"
+    },
+    "./package.json": "./package.json",
+    "./context": "./types/context.d.cts",
+    "./context.d.ts": "./types/context.d.ts",
+    "./types/*": "./types/*",
+    "./dist/*": "./dist/*"
+  }
 }

package/src/__tests__/__snapshots__/cascade.test.ts.snap

@@ -0,0 +1,23 @@
+// Vitest Snapshot v1, https://vitest.dev/guide/snapshot.html
+
+exports[`Cascading Context > context.run > Should clear context after callback run 1`] = `
+{
+  "a": 1,
+}
+`;
+
+exports[`Cascading Context > context.run > Should clear context after callback run 2`] = `
+{
+  "a": 1,
+  "b": 2,
+}
+`;
+
+exports[`Cascading Context > createCascade > Should return all methods 1`] = `
+{
+  "bind": [Function],
+  "run": [Function],
+  "use": [Function],
+  "useX": [Function],
+}
+`;