context 1.1.4 → 1.2.1

package/CHANGELOG.md

@@ -0,0 +1,41 @@
+# context - Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](http://keepachangelog.com/en/1.0.0/) and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.html).
+
+## 1.2.1 - 2021-12-24
+### Fixed and improved
+- 7e8d48d  Update changelog (ealush)
+
+## 2.0.0 2021-12-24
+
+- 7c43eab major(context): use named export in context (ealush)
+
+## 1.1.16 - 2021-07-02
+
+### Fixed and improved
+
+- 34e0414 improved conditions (undefined)
+- 33f4e46 release (undefined)
+- 6fe40c7 better bundle (undefined)
+- c6387ab before ts settings (undefined)
+- c0e9708 generate correct d.ts file (undefined)
+- 8e01b8e x (undefined)
+- afb3960 x (undefined)
+- e0a8463 add changelog support (undefined)
+- cc46c38 current (undefined)
+
+## 1.1.15 - 2021-07-02
+
+### Fixed and improved
+
+- 34e0414 improved conditions (undefined)
+- 33f4e46 release (undefined)
+- 6fe40c7 better bundle (undefined)
+- c6387ab before ts settings (undefined)
+- c0e9708 generate correct d.ts file (undefined)
+- 8e01b8e x (undefined)
+- afb3960 x (undefined)
+- e0a8463 add changelog support (undefined)
+- cc46c38 current (undefined)

package/README.md

@@ -1,434 +1,140 @@
 # Context
 
-Simple utility that creates a multi-layered context singleton.
-It allows you to keep reference for shared variables, and access them later down in your function call even if not declared in the same scope.
+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.
 
-Originally built for [vest](https://github.com/ealush/vest) validation framework.
+## How Context Works?
 
-# The Concepts
+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 storage object. When your function finishes running, the context is cleared.
 
-Lets take a quick look at how this would work
+![image](https://user-images.githubusercontent.com/11255103/137119151-6912d3f1-ab48-4c91-a426-76af8abc8c55.png)
 
-```js
-import createContext from 'context';
-
-const context = createContext();
-
-context.run({ name: 'Sam' }, sayMyName);
-context.run({ name: 'David' }, sayMyName);
-
-function sayMyName() {
-  const { name } = context.use();
-  console.log(`My Name is ${name}`);
-}
-```
+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.
 
-This will print:
+## API Reference
 
-My Name is Sam
-My Name is David
+Context tries to mimic the behavior of Javascript scopes without actually being in the same scopes, and the API is built around context initialization, setting of values within the context and retrieving values.
 
-So as we see 'run' allows us to run a function and access the specific variable we assigned to the object.
+### createContext()
 
-Why is this useful? Why not just do
+Context's default export, it creates a context singleton object that can later be referenced.
 
 ```js
-sayMyName('Sam');
-sayMyName('David');
+// ctx.js
+import { createContext } from 'context';
 
-function sayMyName(name) {
-  console.log(`My Name is ${name}`);
-}
+export default createContext(); // { run: ƒ, bind: ƒ, use: ƒ, useX: ƒ }
 ```
 
-We will be getting the same results. Right?
-
-It's the next feature that illustrates context's power.
-Instead of using 'run'. we will use 'bind'
+createContext also accepts an initialization function that's run every time ctx.run is called. It allows intercepting the context initialization and adding custom logic, or default values.
+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.
 
 ```js
-// getNames.js
-
-import createContext from 'context';
-
-const context = createContext();
-
-const samName = context.bind({ name: 'Sam' }, sayMyName);
-const davidName = context.bind({ name: 'David' }, sayMyName);
-
-function sayMyName() {
-  const { name } = context.use();
-  console.log(`My Name is ${name}`);
-}
-
-export { samName, davidName };
-
-//index.js
-
-samName();
-davidName();
-```
-
-This will once again print
-
-My Name is Sam
-My Name is David
-
-Except now, because context is a singleton anywhere we run these functions they will print those values.
-
-What if we want to share a value between these functions?
-We can initialize createContext with a value
-
-```js
-// getNames.js
-
-import createContext from 'context';
+createContext((ctx, parentContext) => {
+  if (parentContext === null) {
+    // we're at the top level
+    // so let's add a default cart object
+    return Object.assign(ctx, {
+      cart: [],
+    });
+  }
 
-const context = createContext((ctx, parentCtx) => {
-  return Object.assign({}, ctx, { lastName: 'Smith' });
+  // we're in a sub context, so we already have those default values.
+  return ctx;
 });
-
-const samName = context.bind({ name: 'Sam' }, sayMyName);
-const davidName = context.bind({ name: 'David' }, sayMyName);
-
-function sayMyName() {
-  const { name, lastName } = context.use();
-  console.log(`My Name is ${name} ${lastName}`);
-}
-
-export { samName, davidName };
-
-//index.js
-
-samName();
-davidName();
-```
-
-will print
-
-My Name is Sam Smith
-My Name is David Smith
-
-These example are pretty contrived
-
-Lets try something a little more real world.
-
-# Real World Example
-
-What if we wanted to keep track of how many times a function was called.
-We want to create an environment where we pass the function we want to track and receive exactly the same function.
-The only difference is that the function is going to have a count property which we will be able to call at any time.
-
-So lets start
-
-```js
-//counter.js
-import createContext from 'context';
-
-const context = createContext();
 ```
 
-We've seen this before, we are creating the context object.
+### run()
 
-Now I want to have a main context that will store the values of all the functions that are running.
-in context world it will look like this.
-Just a parent function called counter.
+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
-//counter.js
-import createContext from 'context';
-
-const context = createContext();
-
-function counter() {}
-```
-
-In this function I am going to want to store the function name and the count.
-I add a couple of functions add and getVals.
+// myFunction.js
+import ctx from './ctx';
+import sayUsername from './sayUsername';
 
-```js
-//counter.js
-import createContext from 'context';
-
-const context = createContext();
-
-function counter() {
-  const values = {};
-
-  function add(val) {
-    if (!values[val]) {
-      values[val] = 0;
-    }
-
-    values[val] += 1;
-  }
-
-  function getVals() {
-    return values;
-  }
+function myFunction(username) {
+  return ctx.run({ username }, sayUsername);
 }
 ```
 
-At this stage it won't accomplish much.
-What I want counter to return is a function that holds 'values' in its context. We will use context.bind for that.
-So imagine a box and counter is the outer most box. In it is the values object and anything I put into the box will have access to that object.
-and what do I want to put in the box? The function I want to count.
+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.
 
-I add an argument func to counter.
-This will be the function we want to count.
-I create a ref object which I will then pass to the function.
-This object is accessible to the the function thanks to context.
+### use() and useX()
 
-```js
-//counter.js
-import createContext from 'context';
-
-const context = createContext();
-
-function counter(func) {
-  const values = {};
-
-  function add(val) {
-    if (!values[val]) {
-      values[val] = 0;
-    }
+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.
 
-    values[val] += 1;
-  }
-
-  function getVals() {
-    return values;
-  }
-
-  const ref = { add, getVals };
-  return context.bind({ ref }, func);
-}
-```
-
-great! wait no, this function that is returned will run our function we passed and it does have access to values but in order to use values we have to modify our function!
-
-Not what we wanted...
-
-We want a function that will run our function, have access to values but won't require us to modify our existing function.
-
-so lets create a function called track.
-'track' will return a function that will modify values and run out function
-
-```js
-//counter.js
-function track(func) {
-  const { ref } = context.use();
-
- 
-  function holder(args) {
-    ref.add(func.name);
-    holder.count = ref.getVals()[func.name];
-    holder.getAll = () => {
-      return ref.getVals();
-    };
-    return func(args);
-  }
-
-  return holder;
-}
- 
-
-
-```
-
-In 'track' I am using context.use and I can do this because I am going to pass it to context.bind. If I didn't run it in either context.run or context.bind this will not work. It basically is looking for the outer box.
-
-I pull out ref which holds the reference to values.
-
-The function 'holder' is going to run 'add' from ref and since functions in javascript are object we are going to pass the resulting value into a 'count' property.
-We are also creating a getAll function to the function.
-Then our function will run and the result will return as if no change was ever made.
+- 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
-//counter.js
-import createContext from 'context';
+// sayUsername.js
+import ctx from './ctx';
 
-const context = createContext();
+function sayUsername() {
+  const context = ctx.use(); // { username: 'John Doe' }
 
-function track(func) {
-  const { ref } = context.use();
-
-  function holder(args) {
-    ref.add(func.name);
-    holder.count = ref.getVals()[func.name];
-    holder.getAll = () => {
-      return ref.getVals();
-    };
-    return func(args);
+  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 holder;
+  return `Hello, ${context.username}!`;
 }
-
-function counter(tracker) {
-  const values = {};
-
-  function add(val) {
-    if (!values[val]) {
-      values[val] = 0;
-    }
-
-    values[val] += 1;
-  }
-
-  function getVals() {
-    return values;
-  }
-
-  const ref = { add, getVals };
-
-  return context.bind({ ref }, tracker); //
-}
-
-export { counter, track };
 ```
 
-Lets see how we use this.
-
 ```js
-// index.js
-import { counter, track } from './counter';
+// handleCart.js
+import ctx from './ctx';
 
-const countIt = counter(func => {
-  return track(func);
-});
-
-function goToServer() {
-  console.log('going to server');
-}
+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.
 
-function readFile(file) {
-  console.log('readingFile ' + file);
+  return `You have ${context.cart.items.length} items in your cart.`;
 }
-const dReadFile = countIt(readFile);
-const dgoToServer = countIt(goToServer);
-
-readFile('important.docx');
-
-dReadFile('mainfile.js');
-dReadFile('secondary.js');
-console.log(dReadFile.count);
-
-dgoToServer();
-console.log(dgoToServer.count);
-
-console.log(dReadFile.getAll());
 ```
 
-Imagine a situation where you have functions that are trying to reach a server and read a file.
-
-We don't want to modify them but create a wrapper function to keep track
-of how many times it runs.
-
-So to create our first box we have the counter function.
-It stores the values and receives a deferred anonymous function.
-We are passing our function the anonymous function which then gets passed to the tracker function.
-The tracker function receives our function runs the count returns the result of our function
-
-We assign this wrapper to the variable countIt.
-
-We pass readFile to countIt and create a new function dReadFile
+### bind()
 
-When we run dReadFile it will behave like readFile but will store the count within.
-
-Since context is a singleton anywhere we run this function within our project it will keep correct track of our count.
-
-# Other Examples
+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.
 
 ```js
-// myContext.js
-import createContext from 'context';
-
-export default createContext();
-```
-
-```js
-// framework.js
-
-import context from './myContext.js';
+// getProductData.js
+import ctx from './ctx';
 
-function suite(id, tests) {
-  context.run({ suiteId: id }, () => tests()); // ...
-}
-
-function group(name, groupTests) {
-  const { suiteId } = context.use();
+function getProductData(productId) {
+  return ctx.bind({ productId }, handleProductData);
 
-  context.run(
-    {
-      group: name,
-    },
-    () => groupTests()
-  );
+  fetchProduct(productId).then(data => {
+    handleProductData(data);
+    // will run the function handleProductData within our context, even though there is no context running at the moment.
+  });
 }
+```
 
-function test(message, cb) {
-  const { suiteId, group } = context.use();
+## Troubleshooting
 
-  const testId = Math.random(); // 0.8418151199238901
+### Working with async functions/promises
 
-  const testData = context.run({ test: testId }, () => cb()); // ...
-}
+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.
 
-export { suite, group, test } from './framework';
-```
+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.
 
-```js
-import testFramework from './framwork.js';
-
-suite('some_id', () => {
-  /*
-    context now is:
-    {
-      suiteId: 'some_id'
-    }
- */
-
-  group('some_group_name', () => {
-    /*
-      context now is:
-      {
-        group: 'some_group_name',
-        parentContext: {
-          suiteId: 'some_id',
-        }
-      }
-     */
-
-    test('blah blah', () => {
-      /*
-          context now is:
-          {
-            test: 0.8418151199238901,
-            parentContext: {
-              group: 'some_group_name',
-              parentContext: {
-                suiteId: 'some_id',
-              }
-            }
-          }
-         */
-    });
-  });
-});
-```
-
-## Binding a function with context
+#### But my function is still running. Why did the context clear?
 
-You can bind a function to a context with ctx.bind, this allows you to create a bound function that's when called - will be called with that bound context, even if not in the same scope anymore.
+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.
 
-```js
-const boundFunction = ctx.bind(ctxRef, fn, ...args);
-
-boundFunction(); // Will run with the context as if you run it directly within ctx.run();
-```
+#### Ok, so what do I do?
 
-## Context initialization
+There are multiple strategies of handling async functions with context.
 
-You can add an init function to your context creation. The init function will run every time you call context.run, to allow you to set in-flight keys to your context. It accepts two params - the provided ctxRef, and the parent context when nested.
+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.
 
+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.

package/dist/cjs/context.development.js

@@ -0,0 +1,81 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var assign = Object.assign;
+
+function isFunction(value) {
+    return typeof value === 'function';
+}
+
+function optionalFunctionValue(value) {
+    var args = [];
+    for (var _i = 1; _i < arguments.length; _i++) {
+        args[_i - 1] = arguments[_i];
+    }
+    return isFunction(value) ? value.apply(void 0, args) : value;
+}
+
+function defaultTo(callback, defaultValue) {
+    var _a;
+    return (_a = optionalFunctionValue(callback)) !== null && _a !== void 0 ? _a : defaultValue;
+}
+
+/**
+ * Throws a timed out error.
+ */
+function throwError(devMessage, productionMessage) {
+    throw new Error(devMessage );
+}
+
+// eslint-disable-next-line max-lines-per-function
+function createContext(init) {
+    var storage = { ancestry: [] };
+    return {
+        bind: bind,
+        run: run,
+        use: use,
+        useX: useX
+    };
+    function useX(errorMessage) {
+        var _a;
+        return ((_a = storage.ctx) !== null && _a !== void 0 ? _a : throwError(defaultTo(errorMessage, 'Context was used after it was closed')));
+    }
+    function run(ctxRef, fn) {
+        var _a;
+        var parentContext = use();
+        var out = assign({}, parentContext ? parentContext : {}, (_a = optionalFunctionValue(init, ctxRef, parentContext)) !== null && _a !== void 0 ? _a : ctxRef);
+        var ctx = set(Object.freeze(out));
+        storage.ancestry.unshift(ctx);
+        var res = fn(ctx);
+        clear();
+        return res;
+    }
+    function bind(ctxRef, fn) {
+        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+        // @ts-ignore - this one's pretty hard to get right
+        var returnedFn = function () {
+            var runTimeArgs = [];
+            for (var _i = 0; _i < arguments.length; _i++) {
+                runTimeArgs[_i] = arguments[_i];
+            }
+            return run(ctxRef, function () {
+                return fn.apply(void 0, runTimeArgs);
+            });
+        };
+        return returnedFn;
+    }
+    function use() {
+        return storage.ctx;
+    }
+    function set(value) {
+        return (storage.ctx = value);
+    }
+    function clear() {
+        var _a;
+        storage.ancestry.shift();
+        set((_a = storage.ancestry[0]) !== null && _a !== void 0 ? _a : null);
+    }
+}
+
+exports.createContext = createContext;

package/dist/cjs/context.production.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0});var n=Object.assign;function t(n){return"function"==typeof n}function r(n){for(var r=[],e=1;e<arguments.length;e++)r[e-1]=arguments[e];return t(n)?n.apply(void 0,r):n}function e(n,t){var e;return null!==(e=r(n))&&void 0!==e?e:t}exports.createContext=function(t){function u(e,u){var i,f,a=o();return e=n({},a||{},null!==(i=r(t,e,a))&&void 0!==i?i:e),i=c.ctx=Object.freeze(e),c.ancestry.unshift(i),u=u(i),c.ancestry.shift(),c.ctx=null!==(f=c.ancestry[0])&&void 0!==f?f:null,u}function o(){return c.ctx}var c={ancestry:[]};return{bind:function(n,t){return function(){for(var r=[],e=0;e<arguments.length;e++)r[e]=arguments[e];return u(n,(function(){return t.apply(void 0,r)}))}},run:u,use:o,useX:function(n){var t;return null!==(t=c.ctx)&&void 0!==t?t:function(n,t){throw Error(e(t,n))}(e(n,"Context was used after it was closed"))}}};

package/dist/cjs/package.json

@@ -0,0 +1 @@
+{"type":"commonjs"}

package/dist/es/context.development.js

@@ -0,0 +1,77 @@
+var assign = Object.assign;
+
+function isFunction(value) {
+    return typeof value === 'function';
+}
+
+function optionalFunctionValue(value) {
+    var args = [];
+    for (var _i = 1; _i < arguments.length; _i++) {
+        args[_i - 1] = arguments[_i];
+    }
+    return isFunction(value) ? value.apply(void 0, args) : value;
+}
+
+function defaultTo(callback, defaultValue) {
+    var _a;
+    return (_a = optionalFunctionValue(callback)) !== null && _a !== void 0 ? _a : defaultValue;
+}
+
+/**
+ * Throws a timed out error.
+ */
+function throwError(devMessage, productionMessage) {
+    throw new Error(devMessage );
+}
+
+// eslint-disable-next-line max-lines-per-function
+function createContext(init) {
+    var storage = { ancestry: [] };
+    return {
+        bind: bind,
+        run: run,
+        use: use,
+        useX: useX
+    };
+    function useX(errorMessage) {
+        var _a;
+        return ((_a = storage.ctx) !== null && _a !== void 0 ? _a : throwError(defaultTo(errorMessage, 'Context was used after it was closed')));
+    }
+    function run(ctxRef, fn) {
+        var _a;
+        var parentContext = use();
+        var out = assign({}, parentContext ? parentContext : {}, (_a = optionalFunctionValue(init, ctxRef, parentContext)) !== null && _a !== void 0 ? _a : ctxRef);
+        var ctx = set(Object.freeze(out));
+        storage.ancestry.unshift(ctx);
+        var res = fn(ctx);
+        clear();
+        return res;
+    }
+    function bind(ctxRef, fn) {
+        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+        // @ts-ignore - this one's pretty hard to get right
+        var returnedFn = function () {
+            var runTimeArgs = [];
+            for (var _i = 0; _i < arguments.length; _i++) {
+                runTimeArgs[_i] = arguments[_i];
+            }
+            return run(ctxRef, function () {
+                return fn.apply(void 0, runTimeArgs);
+            });
+        };
+        return returnedFn;
+    }
+    function use() {
+        return storage.ctx;
+    }
+    function set(value) {
+        return (storage.ctx = value);
+    }
+    function clear() {
+        var _a;
+        storage.ancestry.shift();
+        set((_a = storage.ancestry[0]) !== null && _a !== void 0 ? _a : null);
+    }
+}
+
+export { createContext };

package/dist/es/context.production.js

@@ -0,0 +1 @@
+var n=Object.assign;function t(n){for(var t=[],r=1;r<arguments.length;r++)t[r-1]=arguments[r];return"function"==typeof n?n.apply(void 0,t):n}function r(n,r){var e;return null!==(e=t(n))&&void 0!==e?e:r}export function createContext(e){function u(r,u){var c,a,f=o();return r=n({},f||{},null!==(c=t(e,r,f))&&void 0!==c?c:r),c=i.ctx=Object.freeze(r),i.ancestry.unshift(c),u=u(c),i.ancestry.shift(),i.ctx=null!==(a=i.ancestry[0])&&void 0!==a?a:null,u}function o(){return i.ctx}var i={ancestry:[]};return{bind:function(n,t){return function(){for(var r=[],e=0;e<arguments.length;e++)r[e]=arguments[e];return u(n,(function(){return t.apply(void 0,r)}))}},run:u,use:o,useX:function(n){var t;if(null===(t=i.ctx)||void 0===t)throw n=r(n,"Context was used after it was closed"),Error(r(void 0,n));return t}}}

package/dist/es/package.json

@@ -0,0 +1 @@
+{"type":"module"}

package/dist/umd/context.development.js

@@ -0,0 +1,87 @@
+(function (global, factory) {
+  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
+  typeof define === 'function' && define.amd ? define(['exports'], factory) :
+  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.context = {}));
+}(this, (function (exports) { 'use strict';
+
+  var assign = Object.assign;
+
+  function isFunction(value) {
+      return typeof value === 'function';
+  }
+
+  function optionalFunctionValue(value) {
+      var args = [];
+      for (var _i = 1; _i < arguments.length; _i++) {
+          args[_i - 1] = arguments[_i];
+      }
+      return isFunction(value) ? value.apply(void 0, args) : value;
+  }
+
+  function defaultTo(callback, defaultValue) {
+      var _a;
+      return (_a = optionalFunctionValue(callback)) !== null && _a !== void 0 ? _a : defaultValue;
+  }
+
+  /**
+   * Throws a timed out error.
+   */
+  function throwError(devMessage, productionMessage) {
+      throw new Error(devMessage );
+  }
+
+  // eslint-disable-next-line max-lines-per-function
+  function createContext(init) {
+      var storage = { ancestry: [] };
+      return {
+          bind: bind,
+          run: run,
+          use: use,
+          useX: useX
+      };
+      function useX(errorMessage) {
+          var _a;
+          return ((_a = storage.ctx) !== null && _a !== void 0 ? _a : throwError(defaultTo(errorMessage, 'Context was used after it was closed')));
+      }
+      function run(ctxRef, fn) {
+          var _a;
+          var parentContext = use();
+          var out = assign({}, parentContext ? parentContext : {}, (_a = optionalFunctionValue(init, ctxRef, parentContext)) !== null && _a !== void 0 ? _a : ctxRef);
+          var ctx = set(Object.freeze(out));
+          storage.ancestry.unshift(ctx);
+          var res = fn(ctx);
+          clear();
+          return res;
+      }
+      function bind(ctxRef, fn) {
+          // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+          // @ts-ignore - this one's pretty hard to get right
+          var returnedFn = function () {
+              var runTimeArgs = [];
+              for (var _i = 0; _i < arguments.length; _i++) {
+                  runTimeArgs[_i] = arguments[_i];
+              }
+              return run(ctxRef, function () {
+                  return fn.apply(void 0, runTimeArgs);
+              });
+          };
+          return returnedFn;
+      }
+      function use() {
+          return storage.ctx;
+      }
+      function set(value) {
+          return (storage.ctx = value);
+      }
+      function clear() {
+          var _a;
+          storage.ancestry.shift();
+          set((_a = storage.ancestry[0]) !== null && _a !== void 0 ? _a : null);
+      }
+  }
+
+  exports.createContext = createContext;
+
+  Object.defineProperty(exports, '__esModule', { value: true });
+
+})));

package/dist/umd/context.production.js

@@ -0,0 +1 @@
+"use strict";!function(n,t){"object"==typeof exports&&"undefined"!=typeof module?t(exports):"function"==typeof define&&define.amd?define(["exports"],t):t((n="undefined"!=typeof globalThis?globalThis:n||self).context={})}(this,(function(n){function t(n){for(var t=[],e=1;e<arguments.length;e++)t[e-1]=arguments[e];return"function"==typeof n?n.apply(void 0,t):n}function e(n,e){var r;return null!==(r=t(n))&&void 0!==r?r:e}var r=Object.assign;n.createContext=function(n){function o(e,o){var f,c,s=u();return e=r({},s||{},null!==(f=t(n,e,s))&&void 0!==f?f:e),f=i.ctx=Object.freeze(e),i.ancestry.unshift(f),o=o(f),i.ancestry.shift(),i.ctx=null!==(c=i.ancestry[0])&&void 0!==c?c:null,o}function u(){return i.ctx}var i={ancestry:[]};return{bind:function(n,t){return function(){for(var e=[],r=0;r<arguments.length;r++)e[r]=arguments[r];return o(n,(function(){return t.apply(void 0,e)}))}},run:o,use:u,useX:function(n){var t;if(null===(t=i.ctx)||void 0===t)throw n=e(n,"Context was used after it was closed"),Error(e(void 0,n));return t}}},Object.defineProperty(n,"__esModule",{value:!0})}));

package/package.json

@@ -1,45 +1,46 @@
 {
-  "version": "1.1.4",
+  "version": "1.2.1",
   "license": "MIT",
-  "main": "dist/index.js",
-  "typings": "dist/index.d.ts",
-  "files": [
-    "dist",
-    "src"
-  ],
-  "engines": {
-    "node": ">=10"
-  },
-  "scripts": {
-    "start": "tsdx watch",
-    "build": "tsdx build",
-    "test": "tsdx test",
-    "lint": "tsdx lint",
-    "prepare": "tsdx build"
-  },
-  "peerDependencies": {},
-  "husky": {
-    "hooks": {
-      "pre-commit": "tsdx lint"
-    }
-  },
-  "prettier": {
-    "printWidth": 80,
-    "semi": true,
-    "singleQuote": true,
-    "trailingComma": "es5"
-  },
+  "main": "./dist/cjs/context.js",
+  "types": "./types/context.d.ts",
   "name": "context",
   "author": "ealush",
-  "module": "dist/context.esm.js",
-  "devDependencies": {
-    "husky": "^4.2.5",
-    "tsdx": "^0.13.2",
-    "tslib": "^2.0.1",
-    "typescript": "^4.0.2"
+  "scripts": {
+    "test": "vx test",
+    "build": "vx build",
+    "release": "vx release"
+  },
+  "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",
+    "./": "./"
   },
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/ealush/context.git"
+    "url": "https://github.com/ealush/vest.git",
+    "directory": "packages/context"
+  },
+  "bugs": {
+    "url": "https://github.com/ealush/vest.git/issues"
   }
 }

package/tsconfig.json

@@ -0,0 +1,8 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "declarationMap": true,
+    "declarationDir": "./types",
+    "outDir": "./dist"
+  }
+}

package/types/context.d.ts

@@ -0,0 +1,7 @@
+declare function createContext<T extends Record<string, unknown>>(init?: (ctxRef: Partial<T>, parentContext: T | void) => T | null): {
+    run: <R>(ctxRef: Partial<T>, fn: (context: T) => R) => R;
+    bind: <Fn extends (...args: any[]) => any>(ctxRef: Partial<T>, fn: Fn) => Fn;
+    use: () => T | undefined;
+    useX: (errorMessage?: string) => T;
+};
+export { createContext };

package/dist/context.cjs.development.js

@@ -1,80 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-function _extends() {
-  _extends = Object.assign || function (target) {
-    for (var i = 1; i < arguments.length; i++) {
-      var source = arguments[i];
-
-      for (var key in source) {
-        if (Object.prototype.hasOwnProperty.call(source, key)) {
-          target[key] = source[key];
-        }
-      }
-    }
-
-    return target;
-  };
-
-  return _extends.apply(this, arguments);
-}
-
-function createContext(init) {
-  var storage = {
-    ancestry: []
-  };
-  return {
-    run: run,
-    bind: bind,
-    use: use
-  };
-
-  function run(ctxRef, fn) {
-    var _init;
-
-    var parentContext = use();
-
-    var out = _extends({}, parentContext ? parentContext : {}, (_init = init === null || init === void 0 ? void 0 : init(ctxRef, parentContext)) !== null && _init !== void 0 ? _init : ctxRef);
-
-    var ctx = set(Object.freeze(out));
-    storage.ancestry.unshift(ctx);
-    var res = fn(ctx);
-    clear();
-    return res;
-  }
-
-  function bind(ctxRef, fn) {
-    for (var _len = arguments.length, args = new Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) {
-      args[_key - 2] = arguments[_key];
-    }
-
-    return function () {
-      for (var _len2 = arguments.length, runTimeArgs = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
-        runTimeArgs[_key2] = arguments[_key2];
-      }
-
-      return run(ctxRef, function () {
-        return fn.apply(void 0, args.concat(runTimeArgs));
-      });
-    };
-  }
-
-  function use() {
-    return storage.ctx;
-  }
-
-  function set(value) {
-    return storage.ctx = value;
-  }
-
-  function clear() {
-    var _storage$ancestry$;
-
-    storage.ancestry.shift();
-    set((_storage$ancestry$ = storage.ancestry[0]) !== null && _storage$ancestry$ !== void 0 ? _storage$ancestry$ : null);
-  }
-}
-
-exports.default = createContext;
-//# sourceMappingURL=context.cjs.development.js.map

package/dist/context.cjs.development.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"context.cjs.development.js","sources":["../src/index.ts"],"sourcesContent":["export default function createContext<T extends Record<string, any>>(\n  init?: (ctxRef: T, parentContext: T | void) => T | null\n) {\n  const storage: { ctx?: T; ancestry: T[] } = { ancestry: [] };\n\n  return {\n    run,\n    bind,\n    use,\n  };\n\n  function run<R>(ctxRef: T, fn: (context: T) => R): R {\n    const parentContext = use();\n\n    const out = {\n      ...(parentContext ? parentContext : {}),\n      ...(init?.(ctxRef, parentContext) ?? ctxRef),\n    };\n\n    const ctx = set(Object.freeze(out));\n    storage.ancestry.unshift(ctx);\n    const res = fn(ctx);\n\n    clear();\n    return res;\n  }\n\n  function bind<R>(ctxRef: T, fn: (...args: any[]) => R, ...args: any[]) {\n    return function(...runTimeArgs: any[]) {\n      return run<R>(ctxRef, function() {\n        return fn(...args, ...runTimeArgs);\n      });\n    };\n  }\n\n  function use() {\n    return storage.ctx;\n  }\n\n  function set(value: T): T {\n    return (storage.ctx = value);\n  }\n\n  function clear() {\n    storage.ancestry.shift();\n    set(storage.ancestry[0] ?? null);\n  }\n}\n"],"names":["createContext","init","storage","ancestry","run","bind","use","ctxRef","fn","parentContext","out","ctx","set","Object","freeze","unshift","res","clear","args","runTimeArgs","value","shift"],"mappings":";;;;;;;;;;;;;;;;;;;;;;SAAwBA,cACtBC;AAEA,MAAMC,OAAO,GAA+B;AAAEC,IAAAA,QAAQ,EAAE;AAAZ,GAA5C;AAEA,SAAO;AACLC,IAAAA,GAAG,EAAHA,GADK;AAELC,IAAAA,IAAI,EAAJA,IAFK;AAGLC,IAAAA,GAAG,EAAHA;AAHK,GAAP;;AAMA,WAASF,GAAT,CAAgBG,MAAhB,EAA2BC,EAA3B;;;AACE,QAAMC,aAAa,GAAGH,GAAG,EAAzB;;AAEA,QAAMI,GAAG,gBACHD,aAAa,GAAGA,aAAH,GAAmB,EAD7B,WAEHR,IAFG,aAEHA,IAFG,uBAEHA,IAAI,CAAGM,MAAH,EAAWE,aAAX,CAFD,yCAE8BF,MAF9B,CAAT;;AAKA,QAAMI,GAAG,GAAGC,GAAG,CAACC,MAAM,CAACC,MAAP,CAAcJ,GAAd,CAAD,CAAf;AACAR,IAAAA,OAAO,CAACC,QAAR,CAAiBY,OAAjB,CAAyBJ,GAAzB;AACA,QAAMK,GAAG,GAAGR,EAAE,CAACG,GAAD,CAAd;AAEAM,IAAAA,KAAK;AACL,WAAOD,GAAP;AACD;;AAED,WAASX,IAAT,CAAiBE,MAAjB,EAA4BC,EAA5B;sCAA0DU;AAAAA,MAAAA;;;AACxD,WAAO;yCAAYC;AAAAA,QAAAA;;;AACjB,aAAOf,GAAG,CAAIG,MAAJ,EAAY;AACpB,eAAOC,EAAE,MAAF,SAAMU,IAAN,QAAeC,WAAf,EAAP;AACD,OAFS,CAAV;AAGD,KAJD;AAKD;;AAED,WAASb,GAAT;AACE,WAAOJ,OAAO,CAACS,GAAf;AACD;;AAED,WAASC,GAAT,CAAaQ,KAAb;AACE,WAAQlB,OAAO,CAACS,GAAR,GAAcS,KAAtB;AACD;;AAED,WAASH,KAAT;;;AACEf,IAAAA,OAAO,CAACC,QAAR,CAAiBkB,KAAjB;AACAT,IAAAA,GAAG,uBAACV,OAAO,CAACC,QAAR,CAAiB,CAAjB,CAAD,mEAAwB,IAAxB,CAAH;AACD;AACF;;;;"}

package/dist/context.cjs.production.min.js

@@ -1,2 +0,0 @@
-"use strict";function n(){return(n=Object.assign||function(n){for(var r=1;r<arguments.length;r++){var t=arguments[r];for(var e in t)Object.prototype.hasOwnProperty.call(t,e)&&(n[e]=t[e])}return n}).apply(this,arguments)}Object.defineProperty(exports,"__esModule",{value:!0}),exports.default=function(r){var t={ancestry:[]};return{run:e,bind:function(n,r){for(var t=arguments.length,u=new Array(t>2?t-2:0),o=2;o<t;o++)u[o-2]=arguments[o];return function(){for(var t=arguments.length,o=new Array(t),c=0;c<t;c++)o[c]=arguments[c];return e(n,(function(){return r.apply(void 0,u.concat(o))}))}},use:u};function e(e,c){var a,i=u(),f=n({},i||{},null!==(a=null==r?void 0:r(e,i))&&void 0!==a?a:e),l=o(Object.freeze(f));t.ancestry.unshift(l);var s,v=c(l);return t.ancestry.shift(),o(null!==(s=t.ancestry[0])&&void 0!==s?s:null),v}function u(){return t.ctx}function o(n){return t.ctx=n}};
-//# sourceMappingURL=context.cjs.production.min.js.map

package/dist/context.cjs.production.min.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"context.cjs.production.min.js","sources":["../src/index.ts"],"sourcesContent":["export default function createContext<T extends Record<string, any>>(\n  init?: (ctxRef: T, parentContext: T | void) => T | null\n) {\n  const storage: { ctx?: T; ancestry: T[] } = { ancestry: [] };\n\n  return {\n    run,\n    bind,\n    use,\n  };\n\n  function run<R>(ctxRef: T, fn: (context: T) => R): R {\n    const parentContext = use();\n\n    const out = {\n      ...(parentContext ? parentContext : {}),\n      ...(init?.(ctxRef, parentContext) ?? ctxRef),\n    };\n\n    const ctx = set(Object.freeze(out));\n    storage.ancestry.unshift(ctx);\n    const res = fn(ctx);\n\n    clear();\n    return res;\n  }\n\n  function bind<R>(ctxRef: T, fn: (...args: any[]) => R, ...args: any[]) {\n    return function(...runTimeArgs: any[]) {\n      return run<R>(ctxRef, function() {\n        return fn(...args, ...runTimeArgs);\n      });\n    };\n  }\n\n  function use() {\n    return storage.ctx;\n  }\n\n  function set(value: T): T {\n    return (storage.ctx = value);\n  }\n\n  function clear() {\n    storage.ancestry.shift();\n    set(storage.ancestry[0] ?? null);\n  }\n}\n"],"names":["init","storage","ancestry","run","bind","ctxRef","fn","args","runTimeArgs","use","parentContext","out","ctx","set","Object","freeze","unshift","res","shift","value"],"mappings":"4SACEA,OAEMC,EAAsC,CAAEC,SAAU,UAEjD,CACLC,IAAAA,EACAC,cAoBeC,EAAWC,8BAA8BC,mCAAAA,2BACjD,sCAAYC,2BAAAA,yBACVL,EAAOE,GAAQ,kBACbC,eAAMC,SAASC,SAtB1BC,IAAAA,YAGON,EAAOE,EAAWC,SACnBI,EAAgBD,IAEhBE,OACAD,GAAgC,aAChCV,MAAAA,SAAAA,EAAOK,EAAQK,kBAAkBL,GAGjCO,EAAMC,EAAIC,OAAOC,OAAOJ,IAC9BV,EAAQC,SAASc,QAAQJ,SACnBK,EAAMX,EAAGM,UAuBfX,EAAQC,SAASgB,QACjBL,YAAIZ,EAAQC,SAAS,kBAAM,MArBpBe,WAWAR,WACAR,EAAQW,aAGRC,EAAIM,UACHlB,EAAQW,IAAMO"}

package/dist/context.esm.js

@@ -1,76 +0,0 @@
-function _extends() {
-  _extends = Object.assign || function (target) {
-    for (var i = 1; i < arguments.length; i++) {
-      var source = arguments[i];
-
-      for (var key in source) {
-        if (Object.prototype.hasOwnProperty.call(source, key)) {
-          target[key] = source[key];
-        }
-      }
-    }
-
-    return target;
-  };
-
-  return _extends.apply(this, arguments);
-}
-
-function createContext(init) {
-  var storage = {
-    ancestry: []
-  };
-  return {
-    run: run,
-    bind: bind,
-    use: use
-  };
-
-  function run(ctxRef, fn) {
-    var _init;
-
-    var parentContext = use();
-
-    var out = _extends({}, parentContext ? parentContext : {}, (_init = init === null || init === void 0 ? void 0 : init(ctxRef, parentContext)) !== null && _init !== void 0 ? _init : ctxRef);
-
-    var ctx = set(Object.freeze(out));
-    storage.ancestry.unshift(ctx);
-    var res = fn(ctx);
-    clear();
-    return res;
-  }
-
-  function bind(ctxRef, fn) {
-    for (var _len = arguments.length, args = new Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) {
-      args[_key - 2] = arguments[_key];
-    }
-
-    return function () {
-      for (var _len2 = arguments.length, runTimeArgs = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
-        runTimeArgs[_key2] = arguments[_key2];
-      }
-
-      return run(ctxRef, function () {
-        return fn.apply(void 0, args.concat(runTimeArgs));
-      });
-    };
-  }
-
-  function use() {
-    return storage.ctx;
-  }
-
-  function set(value) {
-    return storage.ctx = value;
-  }
-
-  function clear() {
-    var _storage$ancestry$;
-
-    storage.ancestry.shift();
-    set((_storage$ancestry$ = storage.ancestry[0]) !== null && _storage$ancestry$ !== void 0 ? _storage$ancestry$ : null);
-  }
-}
-
-export default createContext;
-//# sourceMappingURL=context.esm.js.map

package/dist/context.esm.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"context.esm.js","sources":["../src/index.ts"],"sourcesContent":["export default function createContext<T extends Record<string, any>>(\n  init?: (ctxRef: T, parentContext: T | void) => T | null\n) {\n  const storage: { ctx?: T; ancestry: T[] } = { ancestry: [] };\n\n  return {\n    run,\n    bind,\n    use,\n  };\n\n  function run<R>(ctxRef: T, fn: (context: T) => R): R {\n    const parentContext = use();\n\n    const out = {\n      ...(parentContext ? parentContext : {}),\n      ...(init?.(ctxRef, parentContext) ?? ctxRef),\n    };\n\n    const ctx = set(Object.freeze(out));\n    storage.ancestry.unshift(ctx);\n    const res = fn(ctx);\n\n    clear();\n    return res;\n  }\n\n  function bind<R>(ctxRef: T, fn: (...args: any[]) => R, ...args: any[]) {\n    return function(...runTimeArgs: any[]) {\n      return run<R>(ctxRef, function() {\n        return fn(...args, ...runTimeArgs);\n      });\n    };\n  }\n\n  function use() {\n    return storage.ctx;\n  }\n\n  function set(value: T): T {\n    return (storage.ctx = value);\n  }\n\n  function clear() {\n    storage.ancestry.shift();\n    set(storage.ancestry[0] ?? null);\n  }\n}\n"],"names":["createContext","init","storage","ancestry","run","bind","use","ctxRef","fn","parentContext","out","ctx","set","Object","freeze","unshift","res","clear","args","runTimeArgs","value","shift"],"mappings":";;;;;;;;;;;;;;;;;;SAAwBA,cACtBC;AAEA,MAAMC,OAAO,GAA+B;AAAEC,IAAAA,QAAQ,EAAE;AAAZ,GAA5C;AAEA,SAAO;AACLC,IAAAA,GAAG,EAAHA,GADK;AAELC,IAAAA,IAAI,EAAJA,IAFK;AAGLC,IAAAA,GAAG,EAAHA;AAHK,GAAP;;AAMA,WAASF,GAAT,CAAgBG,MAAhB,EAA2BC,EAA3B;;;AACE,QAAMC,aAAa,GAAGH,GAAG,EAAzB;;AAEA,QAAMI,GAAG,gBACHD,aAAa,GAAGA,aAAH,GAAmB,EAD7B,WAEHR,IAFG,aAEHA,IAFG,uBAEHA,IAAI,CAAGM,MAAH,EAAWE,aAAX,CAFD,yCAE8BF,MAF9B,CAAT;;AAKA,QAAMI,GAAG,GAAGC,GAAG,CAACC,MAAM,CAACC,MAAP,CAAcJ,GAAd,CAAD,CAAf;AACAR,IAAAA,OAAO,CAACC,QAAR,CAAiBY,OAAjB,CAAyBJ,GAAzB;AACA,QAAMK,GAAG,GAAGR,EAAE,CAACG,GAAD,CAAd;AAEAM,IAAAA,KAAK;AACL,WAAOD,GAAP;AACD;;AAED,WAASX,IAAT,CAAiBE,MAAjB,EAA4BC,EAA5B;sCAA0DU;AAAAA,MAAAA;;;AACxD,WAAO;yCAAYC;AAAAA,QAAAA;;;AACjB,aAAOf,GAAG,CAAIG,MAAJ,EAAY;AACpB,eAAOC,EAAE,MAAF,SAAMU,IAAN,QAAeC,WAAf,EAAP;AACD,OAFS,CAAV;AAGD,KAJD;AAKD;;AAED,WAASb,GAAT;AACE,WAAOJ,OAAO,CAACS,GAAf;AACD;;AAED,WAASC,GAAT,CAAaQ,KAAb;AACE,WAAQlB,OAAO,CAACS,GAAR,GAAcS,KAAtB;AACD;;AAED,WAASH,KAAT;;;AACEf,IAAAA,OAAO,CAACC,QAAR,CAAiBkB,KAAjB;AACAT,IAAAA,GAAG,uBAACV,OAAO,CAACC,QAAR,CAAiB,CAAjB,CAAD,mEAAwB,IAAxB,CAAH;AACD;AACF;;;;"}

package/dist/index.d.ts

@@ -1,5 +0,0 @@
-export default function createContext<T extends Record<string, any>>(init?: (ctxRef: T, parentContext: T | void) => T | null): {
-    run: <R>(ctxRef: T, fn: (context: T) => R) => R;
-    bind: <R_1>(ctxRef: T, fn: (...args: any[]) => R_1, ...args: any[]) => (...runTimeArgs: any[]) => R_1;
-    use: () => T | undefined;
-};

package/dist/index.js

@@ -1,8 +0,0 @@
-
-'use strict'
-
-if (process.env.NODE_ENV === 'production') {
-  module.exports = require('./context.cjs.production.min.js')
-} else {
-  module.exports = require('./context.cjs.development.js')
-}

package/src/index.ts

@@ -1,48 +0,0 @@
-export default function createContext<T extends Record<string, any>>(
-  init?: (ctxRef: T, parentContext: T | void) => T | null
-) {
-  const storage: { ctx?: T; ancestry: T[] } = { ancestry: [] };
-
-  return {
-    run,
-    bind,
-    use,
-  };
-
-  function run<R>(ctxRef: T, fn: (context: T) => R): R {
-    const parentContext = use();
-
-    const out = {
-      ...(parentContext ? parentContext : {}),
-      ...(init?.(ctxRef, parentContext) ?? ctxRef),
-    };
-
-    const ctx = set(Object.freeze(out));
-    storage.ancestry.unshift(ctx);
-    const res = fn(ctx);
-
-    clear();
-    return res;
-  }
-
-  function bind<R>(ctxRef: T, fn: (...args: any[]) => R, ...args: any[]) {
-    return function(...runTimeArgs: any[]) {
-      return run<R>(ctxRef, function() {
-        return fn(...args, ...runTimeArgs);
-      });
-    };
-  }
-
-  function use() {
-    return storage.ctx;
-  }
-
-  function set(value: T): T {
-    return (storage.ctx = value);
-  }
-
-  function clear() {
-    storage.ancestry.shift();
-    set(storage.ancestry[0] ?? null);
-  }
-}