Implement { map: true } in channels

azothjs · Mar 14, 2024 · ad22f5a · ad22f5a
1 parent bc21869
commit ad22f5a
Show file tree

Hide file tree

Showing 6 changed files with 240 additions and 66 deletions.
diff --git a/packages/azoth/package.json b/packages/azoth/package.json
@@ -1,6 +1,6 @@
 {
     "name": "azoth",
-    "version": "1.1.15",
+    "version": "1.1.16",
     "description": "Azoth JSX hypermedia",
     "author": "Marty Nelson",
     "license": "MIT",

diff --git a/packages/channels/generators.js b/packages/channels/generators.js
@@ -1,30 +1,40 @@
+import { ConflictingOptionsError, OptionMissingFunctionArgumentError } from './throw.js';
 
-export function subject(transform, options) {
-    if(!options && typeof transform === 'object') {
-        options = transform;
-        transform = null;
-    }
-
-    let initialValue, startWith;
+function resolveOptions(options, transform) {
+    let initialValue, startWith, map = false;
     if(options) {
         initialValue = options.initialValue;
         startWith = options.startWith;
+        map = options.map ?? false;
         if(initialValue !== undefined) {
-            if(startWith !== undefined) {
-                throw new Error('Cannot specify both initialValue and startWith option');
-            }
-            if(!transform) {
-                throw new Error('Cannot specify initialValue without a transform function');
-            }
+            if(startWith !== undefined) new ConflictingOptionsError();
+            if(!transform) throw new OptionMissingFunctionArgumentError('initialValue');
+        }
+        if(map && !transform) {
+            throw new OptionMissingFunctionArgumentError();
         }
     }
+    return { initialValue, startWith, map };
+}
+
+export function subject(transform, options) {
+    if(!options && typeof transform === 'object') {
+        options = transform;
+        transform = null;
+    }
+
+    const { initialValue, startWith, map } = resolveOptions(options, transform);
 
     const relay = { resolve: null };
 
     let unsentEarlyDispatch = null;
 
     function dispatch(payload) {
-        if(transform) payload = transform(payload);
+        if(transform) {
+            if(map) payload = payload.map(transform);
+            else payload = transform(payload);
+        }
+
         if(relay.resolve) relay.resolve(payload);
         else {
             // eslint-disable-next-line eqeqeq

diff --git a/packages/channels/package.json b/packages/channels/package.json
@@ -1,6 +1,6 @@
 {
     "name": "@azothjs/channels",
-    "version": "0.1.3",
+    "version": "0.1.4",
     "description": "Asynchronous layout channels",
     "author": "Marty Nelson",
     "license": "MIT",
@@ -21,12 +21,12 @@
     "type": "module",
     "main": "./index.js",
     "files": [
-        "use.js",
-        "repeat.js",
         "consume.js",
-        "throw.js",
         "generators.js",
         "index.js",
+        "repeat.js",
+        "throw.js",
+        "use.js",
         "with-resolvers-polyfill.js",
         "README"
     ],

diff --git a/packages/channels/throw.js b/packages/channels/throw.js
@@ -5,4 +5,20 @@ export class AsyncSourceTypeError extends TypeError {
 Unexpected asynchronous data source type "${type}". Expected an async data provider type, or \
 a function that returns an async data provider type."`);
     }
-}
+}
+
+
+export class OptionMissingFunctionArgumentError extends TypeError {
+    constructor(option = 'map: true') {
+        super(`\
+More arguments needed: option "${option}" requires a mapping function.`);
+    }
+}
+
+export class ConflictingOptionsError extends TypeError {
+    constructor() {
+        super(`\
+Cannot specify both initialValue and startWith options.`);
+    }
+}
+
diff --git a/packages/channels/use.js b/packages/channels/use.js
@@ -1,5 +1,5 @@
 import { Multicast } from './generators.js';
-import { AsyncSourceTypeError } from './throw.js';
+import { AsyncSourceTypeError, OptionMissingFunctionArgumentError } from './throw.js';
 
 export function use(asyncSource, ...args) {
     const [channels, options] = getArguments(args);
@@ -33,21 +33,41 @@ function getArguments(channels) {
 
 function fromPromise(promise, channel, options) {
     const startWith = options?.startWith;
+    const map = options?.map ?? false;
     if(startWith) {
-        return fromPromiseStartWith(promise, channel, startWith);
+        return fromPromiseStartWith(startWith, promise, channel, map);
     }
-    return channel ? promise.then(channel) : promise;
+    return promiseResolution(promise, channel, map);
 }
 
-async function* fromPromiseStartWith(promise, channel, startWith) {
+async function* fromPromiseStartWith(startWith, promise, channel, map) {
     yield startWith;
-    yield channel ? promise.then(channel) : promise;
+    yield promiseResolution(promise, channel, map);
+}
+
+function promiseResolution(promise, channel, map) {
+    if(map) {
+        if(!channel) throw new OptionMissingFunctionArgumentError();
+        // TODO: include or suppress index? which param???
+        // collapse "slottable" back into props???
+        return promise.then(array => array.map(channel));
+    }
+    return channel ? promise.then(channel) : promise;
 }
 
 async function* fromAsyncIterator(iterator, channel, options) {
     const startWith = options?.startWith;
+    const map = options?.map ?? false;
+    if(map && !channel) throw new OptionMissingFunctionArgumentError();
+
     if(startWith) yield startWith;
+
     for await(const value of iterator) {
+        if(map) {
+            yield value.map(channel);
+            continue;
+        }
+
         yield channel ? channel(value) : value;
     }
 }
@@ -61,12 +81,12 @@ function branchPromise(promise, channels) {
     });
 }
 
-function branchAsyncIterator(iterator, channels, options) {
+function branchAsyncIterator(iterator, channels) {
     const multicast = new Multicast(iterator);
     return channels.map(channel => {
         if(Array.isArray(channel)) { // [channel, options]
             return multicast.subscriber(channel[0], channel[1]);
         }
-        return multicast.subscriber(channel, options);
+        return multicast.subscriber(channel);
     });
 }