context 1.1.1 → 2.0.0-next-03ba92

package/CHANGELOG.md

@@ -0,0 +1,60 @@
+# 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).
+
+## 2.0.0 - 2021-11-20
+### Changed or removed
+- 7c43eab  major(context): used named export in context (ealush)
+- e8652bc  breaking(vest, enforce): prepare next major (ealush)
+- dab8e00  breaking(vest, enforce): prepare next major (ealush)
+
+### Added
+- 220127b  added(n4s): partial rule modifier (undefined)
+- b5ce72d  feat(n4s): context propagation within enforce (undefined)
+
+### Fixed and improved
+- f721b2d  patch(vest): replace warns boolean flag with enum (ealush)
+- bed7040  vx: add back to workspace (ealush)
+- f2d458d  update build artifacts (ealush)
+- package.json
+- .eslintrc.js
+- packages/anyone/README.md
+- packages/anyone/package.json
+- packages/anyone/package.json
+- 4d88c04  patch: add nodejs exports (undefined)
+- packages/anyone/package.json
+- 26af06b  chore: reduce complexity, remove all lint errors (undefined)
+- packages/anyone/.npmignore
+- .github/PULL_REQUEST_TEMPLATE.md
+- ba68539  lint: handling lint of all packages (ealush)
+- .gitignore
+
+## 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,137 @@
 # 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 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.
 
-# The Concepts
+![image](https://user-images.githubusercontent.com/11255103/137119151-6912d3f1-ab48-4c91-a426-76af8abc8c55.png)
 
-Lets take a quick look at how this would work
+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.
 
-```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}`);
-}
-```
-
-This will print:
-
-My Name is Sam
-My Name is David
-
-So as we see 'run' allows us to run a function and access the specific variable we assigned to the object.
-
-Why is this useful? Why not just do
-
-```js
-sayMyName('Sam');
-sayMyName('David');
-
-function sayMyName(name) {
-  console.log(`My Name is ${name}`);
-}
-```
-
-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'
-
-```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.
+## API Reference
 
-What if we want to share a value between these functions?
-We can initialize createContext with a value
+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.
 
-```js
-// getNames.js
-
-import createContext from 'context';
-
-const context = createContext((ctx, parentCtx) => {
-  return Object.assign({}, ctx, { lastName: 'Smith' });
-});
-
-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
+### createContext()
 
-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.
-
-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.
+Context's default export, it creates a context singleton object that can later be referenced.
 
 ```js
-//counter.js
-import createContext from 'context';
-
-const context = createContext();
+// ctx.js
+import { createContext } from 'context';
 
-function counter() {}
+export default createContext(); // { run: ƒ, bind: ƒ, use: ƒ, useX: ƒ }
 ```
 
-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.
+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
-//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;
+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: [],
+    });
   }
 
-  function getVals() {
-    return values;
-  }
-}
+  // we're in a sub context, so we already have those default values.
+  return ctx;
+});
 ```
 
-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.
+### run()
 
-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.
+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(func) {
-  const values = {};
-
-  function add(val) {
-    if (!values[val]) {
-      values[val] = 0;
-    }
-
-    values[val] += 1;
-  }
-
-  function getVals() {
-    return values;
-  }
+// myFunction.js
+import ctx from './ctx';
+import sayUsername from './sayUsername';
 
-  const ref = { add, getVals };
-  return context.bind({ ref }, func);
+function myFunction(username) {
+  return ctx.run({ username }, sayUsername);
 }
 ```
 
-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!
+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.
 
-Not what we wanted...
+### use() and useX()
 
-We want a function that will run our function, have access to values but won't require us to modify our existing function.
+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.
 
-so lets create a function called track.
-'track' will return a function that will modify values and run out function
+- 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
-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;
-}
- 
-
-
-```
+// sayUsername.js
+import ctx from './ctx';
 
-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.
-
-```js
-//counter.js
-import createContext from 'context';
+function sayUsername() {
+  const context = ctx.use(); // { username: 'John Doe' }
 
-const context = createContext();
-
-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';
-
-const countIt = counter(func => {
-  return track(func);
-});
+// handleCart.js
+import ctx from './ctx';
 
-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.
+### bind()
 
-We pass readFile to countIt and create a new function dReadFile
-
-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
-
-```js
-// myContext.js
-import createContext from 'context';
-
-export default createContext();
-```
+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
-// framework.js
+// getProductData.js
+import ctx from './ctx';
 
-import context from './myContext.js';
+function getProductData(productId) {
+  return ctx.bind({ productId }, handleProductData);
 
-function suite(id, tests) {
-  context.run({ suiteId: id }, () => tests()); // ...
-}
-
-function group(name, groupTests) {
-  const { suiteId } = context.use();
-
-  context.run(
-    {
-      group: name,
-    },
-    () => groupTests()
-  );
-}
-
-function test(message, cb) {
-  const { suiteId, group } = context.use();
-
-  const testId = Math.random(); // 0.8418151199238901
-
-  const testData = context.run({ test: testId }, () => cb()); // ...
+  fetchProduct(productId).then(data => {
+    handleProductData(data);
+    // will run the function handleProductData within our context, even though there is no context running at the moment.
+  });
 }
-
-export { suite, group, test } from './framework';
 ```
 
-```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',
-              }
-            }
-          }
-         */
-    });
-  });
-});
-```
+## Troubleshooting
 
-## Binding a function with context
+### Working with async functions/promises
 
-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.
+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.
 
-```js
-const boundFunction = ctx.bind(ctxRef, fn, ...args);
+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.
 
-boundFunction(); // Will run with the context as if you run it directly within ctx.run();
-```
+#### But my function is still running. Why did the context clear?
+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.
 
-## Context initialization
+#### Ok, so what do I do?
+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"}