Major updates for v0.11.0

README.md

@@ -34,32 +34,19 @@ module.exports = {
   output: 'path-to-output/filename.js',
   variables: {
     imports: [ `import S from 's-js'` ],
-    computed: 'S',
-    sample: 'S.sample',
-    root: 'S.root',
-    cleanup: 'S.cleanup'
+    declarations: {
+      wrap: 'S',
+    }
   }
 }
 ```
 
 These symbols should reference an observable API with the following functionality:
 
-### computed(fn) : void
+### wrap(fn) : void
 
 This is used to wrap all expressions in computations. Your wrap method is expected to call fn with the previously evaluated value if the arity is 1 to allow for reducing computations.
 
-### root(fn) : any
-
-This indicates a new disposable context. The fn should be provided a dispose method that can be called to free all computations in the context.
-
-### sample(fn) : any
-
-A method that causes dependencies within not to be tracked.
-
-### cleanup(fn) : void
-
-This method should register a cleanup method to be called when the context is released.
-
 Then you run the cli command:
 ```sh
 > dom-expressions

babel.config.js

@@ -1,5 +1,8 @@
-// babel.config.js
 module.exports = {
-  presets: [['@babel/preset-env', {targets: {node: 'current'}}]],
-  plugins: [['babel-plugin-jsx-dom-expressions', {moduleName: './runtime.js'}]]
+  env: {
+    test: {
+      presets: [['@babel/preset-env', {targets: {node: 'current'}}]],
+      plugins: [['babel-plugin-jsx-dom-expressions', {moduleName: './runtime.js', alwaysCreateComponents: true}]]
+    }
+  }
 };

dom-expressions.config.js

@@ -2,40 +2,9 @@ module.exports = {
   output: 'test/runtime.js',
   variables: {
     imports: [ `import {
-      comp as wrap, sample, root, cleanup, getContextOwner as currentContext,
-      setContext, makeDataNode, value
+      comp as wrap, getContextOwner as currentContext,
     } from '@ryansolid/s-js'` ],
-    declarations: {
-      memo: `(fn) => {
-        const s = value(fn());
-        wrap(() => s(fn()));
-        return s;
-      }`,
-      SuspenseContext: `{
-        id: 'suspense', initFn: () => {
-          let counter = 0;
-          const s = makeDataNode(),
-            store = {
-              increment: () => ++counter === 1 && !store.initializing && s.next(),
-              decrement: () => --counter === 0 && s.next(),
-              suspended: () => {
-                s.current();
-                return counter;
-              },
-              initializing: true
-            }
-          return store;
-        }
-      }`,
-      registerSuspense: `(fn) => {
-        wrap(() => {
-          const c = SuspenseContext.initFn();
-          setContext(SuspenseContext.id, c);
-          fn(c);
-          c.initializing = false;
-        });
-      }`
-    },
-    includeContext: true
+    includeContext: true,
+    classComponents: true
   }
 }