sygnal 2.6.2 → 2.6.3

package/dist/index.cjs.js

@@ -4,14 +4,14 @@ Object.defineProperty(exports, '__esModule', { value: true });
 
 var isolate = require('@cycle/isolate');
 var state = require('@cycle/state');
-var xstream$1 = require('xstream');
+var xs$1 = require('xstream');
 var run$1 = require('@cycle/run');
 var dom = require('@cycle/dom');
 
 function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
 
 var isolate__default = /*#__PURE__*/_interopDefaultLegacy(isolate);
-var xstream__default = /*#__PURE__*/_interopDefaultLegacy(xstream$1);
+var xs__default = /*#__PURE__*/_interopDefaultLegacy(xs$1);
 
 function collection(component, stateLense, opts={}) {
   const {
@@ -2777,11 +2777,11 @@ function switchable(factories, name$, initial, opts={}) {
   const nameType     = typeof name$;
 
   if (!name$) throw new Error(`Missing 'name$' parameter for switchable()`)
-  if (!(nameType === 'string' || nameType === 'function' || name$ instanceof xstream$1.Stream)) {
+  if (!(nameType === 'string' || nameType === 'function' || name$ instanceof xs$1.Stream)) {
     throw new Error(`Invalid 'name$' parameter for switchable(): expects Stream, String, or Function`)
   }
 
-  if (name$ instanceof xstream$1.Stream) {
+  if (name$ instanceof xs$1.Stream) {
     const withInitial$ = name$
       .compose(_default$5())
       .startWith(initial)
@@ -2791,7 +2791,7 @@ function switchable(factories, name$, initial, opts={}) {
     const mapFunction = (nameType === 'function' && name$) || (state => state[name$]);
     return sources => {
       const state$ = sources && ((typeof stateSourceName === 'string' && sources[stateSourceName]) || sources.STATE || sources.state).stream;
-      if (!state$ instanceof xstream$1.Stream) throw new Error(`Could not find the state source: ${ stateSourceName }`)
+      if (!state$ instanceof xs$1.Stream) throw new Error(`Could not find the state source: ${ stateSourceName }`)
       const _name$ = state$
         .map(mapFunction)
         .filter(name => typeof name === 'string')
@@ -2823,7 +2823,7 @@ function _switchable (factories, sources, name$, switched=['DOM'], stateSourceNa
     .map(([name, factory]) => {
       if (sources[stateSourceName]) {
         const state$ = sources[stateSourceName].stream;
-        const switched = xstream__default["default"].combine(name$, state$)
+        const switched = xs__default["default"].combine(name$, state$)
                            .filter(([newComponentName, _]) => newComponentName == name)
                            .map(([_, state]) => state)
                            .remember();
@@ -2840,7 +2840,7 @@ function _switchable (factories, sources, name$, switched=['DOM'], stateSourceNa
         obj[sinkName] = name$
           .map( newComponentName => {
             const sink = sinks.find(([componentName, _]) => componentName === newComponentName);
-            return (sink && sink[1][sinkName]) || xstream__default["default"].never()
+            return (sink && sink[1][sinkName]) || xs__default["default"].never()
           })
           .flatten()
           .remember()
@@ -2848,7 +2848,7 @@ function _switchable (factories, sources, name$, switched=['DOM'], stateSourceNa
       } else {
         const definedSinks = sinks.filter(([_,sink]) => sink[sinkName] !== undefined)
                                   .map(([_,sink]) => sink[sinkName]);
-        obj[sinkName] = xstream__default["default"].merge(...definedSinks);
+        obj[sinkName] = xs__default["default"].merge(...definedSinks);
       }
       return obj
     }, {});
@@ -3152,17 +3152,6 @@ function debounce(period) {
 }
 var _default$2 = debounce$1.default = debounce;
 
-// import syntax has bugs for xstream in Node context
-// this attempts to normalize to work in both Node and browser
-// if (!xs.never && xs.default && xs.default.never) {
-//   xs.never = xs.default.never
-//   xs.merge = xs.default.merge
-//   xs.of    = xs.default.of
-// }
-// const concat = (Concat && Concat.default) ? Concat.default : Concat
-// const delay  = (Delay && Delay.default) ? Delay.default : Delay
-// const dropRepeats = (DropRepeats && DropRepeats.default) ? DropRepeats.default : DropRepeats
-
 const ENVIRONMENT = ((typeof window != 'undefined' && window) || (process && process.env)) || {};
 
 
@@ -3222,6 +3211,7 @@ class Component {
   // response
   // view
   // children
+  // components
   // initialState
   // calculated
   // storeCalculatedInState
@@ -3278,9 +3268,11 @@ class Component {
       }));
     }
 
+    // TODO: this is a hack to allow the root component to be created without an intent or model
+    //       refactor to avoid using a global variable
     if (IS_ROOT_COMPONENT && typeof this.intent === 'undefined' && typeof this.model === 'undefined') {
       this.initialState = initialState || true;
-      this.intent = _ => ({__NOOP_ACTION__:xstream__default["default"].never()});
+      this.intent = _ => ({__NOOP_ACTION__:xs__default["default"].never()});
       this.model = {
         __NOOP_ACTION__: state => state
       };
@@ -3312,7 +3304,7 @@ class Component {
 
     this.intent$ = this.intent(this.sources);
 
-    if (!(this.intent$ instanceof xstream$1.Stream) && (typeof this.intent$ != 'object')) {
+    if (!(this.intent$ instanceof xs$1.Stream) && (typeof this.intent$ != 'object')) {
       throw new Error('Intent must return either an action$ stream or map of event streams')
     }
   }
@@ -3321,21 +3313,21 @@ class Component {
     const requestSource  = (this.sources && this.sources[this.requestSourceName]) || null;
 
     if (!this.intent$) {
-      this.action$ = xstream__default["default"].never();
+      this.action$ = xs__default["default"].never();
       return
     }
 
     let runner;
-    if (this.intent$ instanceof xstream$1.Stream) {
+    if (this.intent$ instanceof xs$1.Stream) {
       runner = this.intent$;
     } else {
       const mapped = Object.entries(this.intent$)
                            .map(([type, data$]) => data$.map(data => ({type, data})));
-      runner = xstream__default["default"].merge(xstream__default["default"].never(), ...mapped);
+      runner = xs__default["default"].merge(xs__default["default"].never(), ...mapped);
     }
 
-    const action$  = ((runner instanceof xstream$1.Stream) ? runner : (runner.apply && runner(this.sources) || xstream__default["default"].never()));
-    const wrapped$ = _default$3(xstream__default["default"].of({ type: BOOTSTRAP_ACTION }), action$)
+    const action$  = ((runner instanceof xs$1.Stream) ? runner : (runner.apply && runner(this.sources) || xs__default["default"].never()));
+    const wrapped$ = _default$3(xs__default["default"].of({ type: BOOTSTRAP_ACTION }), action$)
       .compose(_default$4(10));
 
     let initialApiData;
@@ -3343,12 +3335,12 @@ class Component {
       initialApiData = requestSource.select('initial')
         .flatten();
     } else {
-      initialApiData = xstream__default["default"].never();
+      initialApiData = xs__default["default"].never();
     }
 
     const hydrate$ = initialApiData.map(data => ({ type: HYDRATE_ACTION, data }));
 
-    this.action$   = xstream__default["default"].merge(wrapped$, hydrate$)
+    this.action$   = xs__default["default"].merge(wrapped$, hydrate$)
       .compose(this.log(({ type }) => `Action triggered: <${ type }>`));
   }
 
@@ -3405,7 +3397,7 @@ class Component {
               if (actionType === 'function') {
                 const enhancedState = this.addCalculated(this.currentState);
                 const result = action(enhancedState, req);
-                return xstream__default["default"].of({ ...obj, data: result })
+                return xs__default["default"].of({ ...obj, data: result })
               } else {
                 this.action$.shamefullySendNext(obj);
 
@@ -3415,7 +3407,7 @@ class Component {
                   const selected$ = source[REQUEST_SELECTOR_METHOD](_reqId);
                   return [ ...acc, selected$ ]
                 }, []);
-                return xstream__default["default"].merge(...responses)
+                return xs__default["default"].merge(...responses)
               }
             } catch(err) {
               console.error(err);
@@ -3423,11 +3415,11 @@ class Component {
           }).flatten();
         return [ ...acc, route$ ]
       }, []);
-      const mapped$ = xstream__default["default"].merge(...mapped);
+      const mapped$ = xs__default["default"].merge(...mapped);
       return [ ...acc, mapped$ ]
     }, []);
 
-    this.response$ = xstream__default["default"].merge(...wrapped)
+    this.response$ = xs__default["default"].merge(...wrapped)
       .compose(this.log(res => {
         if (res._action) return `[${ this.requestSourceName }] response data received for Action: <${ res._action }>`
         return `[${ this.requestSourceName }] response data received from FUNCTION`
@@ -3458,14 +3450,14 @@ class Component {
   initModel$() {
     if (typeof this.model == 'undefined') {
       this.model$ = this.sourceNames.reduce((a,s) => {
-        a[s] = xstream__default["default"].never();
+        a[s] = xs__default["default"].never();
         return a
       }, {});
       return
     }
 
     const initial  = { type: INITIALIZE_ACTION, data: this.initialState };
-    const shimmed$ = this.initialState ? _default$3(xstream__default["default"].of(initial), this.action$).compose(_default$4(0)) : this.action$;
+    const shimmed$ = this.initialState ? _default$3(xs__default["default"].of(initial), this.action$).compose(_default$4(0)) : this.action$;
     const onState  = this.makeOnAction(shimmed$, true, this.action$);
     const onNormal = this.makeOnAction(this.action$, false, this.action$);
 
@@ -3514,7 +3506,7 @@ class Component {
 
     const model$ = Object.entries(reducers).reduce((acc, entry) => {
       const [sink, streams] = entry;
-      acc[sink] = xstream__default["default"].merge(xstream__default["default"].never(), ...streams);
+      acc[sink] = xs__default["default"].merge(xs__default["default"].never(), ...streams);
       return acc
     }, {});
 
@@ -3533,7 +3525,7 @@ class Component {
           next: this.log(({ _reqId, _action }) => `Unhandled response for request: ${ _action } ${ _reqId }`)
         });
       }
-      this.sendResponse$ = xstream__default["default"].never();
+      this.sendResponse$ = xs__default["default"].never();
       return
     }
 
@@ -3561,7 +3553,7 @@ class Component {
       return [ ...acc, mapped$ ]
     }, []);
 
-    this.sendResponse$ = xstream__default["default"].merge(...out$)
+    this.sendResponse$ = xs__default["default"].merge(...out$)
       .compose(this.log(({ _reqId, _action }) => `[${ this.requestSourceName }] response sent for: <${ _action }>`));
   }
 
@@ -3589,7 +3581,7 @@ class Component {
   }
 
   initSubComponentSink$() {
-    const subComponentSink$ = xstream__default["default"].create({
+    const subComponentSink$ = xs__default["default"].create({
       start: listener => {
         this.newSubComponentSinks = listener.next.bind(listener);
       },
@@ -3602,7 +3594,7 @@ class Component {
   }
 
   initSubComponentsRendered$() {
-    const stream = xstream__default["default"].create({
+    const stream = xs__default["default"].create({
       start: (listener) => {
         this.subComponentsRendered = listener.next.bind(listener);
       },
@@ -3615,7 +3607,7 @@ class Component {
 
   initVdom$() {
     if (typeof this.view != 'function') {
-      this.vdom$ = xstream__default["default"].of(null);
+      this.vdom$ = xs__default["default"].of(null);
       return
     }
 
@@ -3633,17 +3625,17 @@ class Component {
   initSinks() {
     this.sinks = this.sourceNames.reduce((acc, name) => {
       if (name == this.DOMSourceName) return acc
-      const subComponentSink$ = this.subComponentSink$ ? this.subComponentSink$.map(sinks => sinks[name]).filter(sink => !!sink).flatten() : xstream__default["default"].never();
+      const subComponentSink$ = this.subComponentSink$ ? this.subComponentSink$.map(sinks => sinks[name]).filter(sink => !!sink).flatten() : xs__default["default"].never();
       if (name === this.stateSourceName) {
-        acc[name] = xstream__default["default"].merge((this.model$[name] || xstream__default["default"].never()), subComponentSink$, this.sources[this.stateSourceName].stream.filter(_ => false), ...this.children$[name]);
+        acc[name] = xs__default["default"].merge((this.model$[name] || xs__default["default"].never()), subComponentSink$, this.sources[this.stateSourceName].stream.filter(_ => false), ...this.children$[name]);
       } else {
-        acc[name] = xstream__default["default"].merge((this.model$[name] || xstream__default["default"].never()), subComponentSink$, ...this.children$[name]);
+        acc[name] = xs__default["default"].merge((this.model$[name] || xs__default["default"].never()), subComponentSink$, ...this.children$[name]);
       }
       return acc
     }, {});
 
     this.sinks[this.DOMSourceName]     = this.vdom$;
-    this.sinks[this.requestSourceName] = xstream__default["default"].merge(this.sendResponse$ ,this.sinks[this.requestSourceName]);
+    this.sinks[this.requestSourceName] = xs__default["default"].merge(this.sendResponse$ ,this.sinks[this.requestSourceName]);
   }
 
   makeOnAction(action$, isStateSink=true, rootAction$) {
@@ -3737,7 +3729,7 @@ class Component {
     const renderParams = { ...this.children$[this.DOMSourceName] };
 
     const enhancedState = state && state.isolateSource(state, { get: state => this.addCalculated(state) });
-    const stateStream   = (enhancedState && enhancedState.stream) || xstream__default["default"].never();
+    const stateStream   = (enhancedState && enhancedState.stream) || xs__default["default"].never();
 
     renderParams.state                 = stateStream;
     renderParams[this.stateSourceName] = stateStream;
@@ -3758,7 +3750,7 @@ class Component {
       streams.push(stream);
     });
 
-    const combined = xstream__default["default"].combine(...streams)
+    const combined = xs__default["default"].combine(...streams)
       // map the streams from an array back to an object with the render parameter names as the keys
       .map(arr => {
         return names.reduce((acc, name, index) => {
@@ -3800,8 +3792,8 @@ class Component {
           return acc
         }
 
-        const props$    = xstream__default["default"].create().startWith(props);
-        const children$ = xstream__default["default"].create().startWith(children);
+        const props$    = xs__default["default"].create().startWith(props);
+        const children$ = xs__default["default"].create().startWith(children);
 
         let instantiator;
 
@@ -3815,7 +3807,7 @@ class Component {
 
         const sink$ = instantiator(el, props$, children$);
 
-        sink$[this.DOMSourceName] = sink$[this.DOMSourceName] ? this.makeCoordinatedSubComponentDomSink(sink$[this.DOMSourceName]) : xstream__default["default"].never();
+        sink$[this.DOMSourceName] = sink$[this.DOMSourceName] ? this.makeCoordinatedSubComponentDomSink(sink$[this.DOMSourceName]) : xs__default["default"].never();
 
         acc[id] = { sink$, props$, children$ };
 
@@ -3829,7 +3821,7 @@ class Component {
 
       const mergedSinksByType = Object.entries(sinkArrsByType).reduce((acc, [name, streamArr]) => {
         if (streamArr.length === 0) return acc
-        acc[name] = streamArr.length === 1 ? streamArr[0] : xstream__default["default"].merge(...streamArr);
+        acc[name] = streamArr.length === 1 ? streamArr[0] : xs__default["default"].merge(...streamArr);
         return acc
       }, {});
 
@@ -3859,7 +3851,7 @@ class Component {
     const props     = data.props || {};
     el.children || [];
 
-    const combined$ = xstream__default["default"].combine(this.sources[this.stateSourceName].stream.startWith(this.currentState), props$, children$)
+    const combined$ = xs__default["default"].combine(this.sources[this.stateSourceName].stream.startWith(this.currentState), props$, children$)
       .map(([state, __props, __children]) => {
         return typeof state === 'object' ? { ...this.addCalculated(state), __props, __children } : { value: state, __props, __children }
       });
@@ -3903,7 +3895,6 @@ class Component {
           return state
         },
         set: (oldState, newState) => {
-          console.log('COLL SET', newState);
           return newState
         }
       };
@@ -3931,7 +3922,17 @@ class Component {
         console.error(`Collection component in ${ this.name } has an invalid 'from' field: Expecting 'undefined', a string indicating an array property in the state, or an object with 'get' and 'set' functions for retrieving and setting child state from the current state. Attempting to use parent component state.`);
         lense = undefined;
       } else {
-        lense = { get: stateField.get, set: stateField.set };
+        lense = {
+          get: (state) => {
+            const newState = stateField.get(state);
+            if (!Array.isArray(newState)) {
+              console.warn(`State getter function in collection component of ${ this.name } did not return an array: No components will be instantiated in the collection. Returned value:`, newState);
+              return []
+            }
+            return newState
+          },
+          set: stateField.set
+        };
       }
     } else {
       console.error(`Collection component in ${ this.name } has an invalid 'from' field: Expecting 'undefined', a string indicating an array property in the state, or an object with 'get' and 'set' functions for retrieving and setting child state from the current state. Attempting to use parent component state.`);
@@ -3951,7 +3952,7 @@ class Component {
     const props     = data.props  || {};
     el.children || [];
 
-    const combined$ = xstream__default["default"].combine(this.sources[this.stateSourceName].stream.startWith(this.currentState), props$, children$)
+    const combined$ = xs__default["default"].combine(this.sources[this.stateSourceName].stream.startWith(this.currentState), props$, children$)
       .map(([state, __props, __children]) => {
         return typeof state === 'object' ? { ...this.addCalculated(state), __props, __children } : { value: state, __props, __children }
       });
@@ -3970,7 +3971,6 @@ class Component {
           console.warn(`Switchable sub-component of ${ this.name } attempted to update state on a calculated field '${ stateField }': Update ignored`);
           return oldState
         }
-        console.log('SWITCH SET', newState);
         if (typeof newState !== 'object' || newState instanceof Array) return { ...oldState, [stateField]: newState }
         const { __props, __children, ...sanitized } = newState;
         return { ...oldState, [stateField]: sanitized }
@@ -4020,7 +4020,7 @@ class Component {
     const props     = data.props  || {};
     el.children || [];
 
-    const combined$ = xstream__default["default"].combine(this.sources[this.stateSourceName].stream.startWith(this.currentState), props$, children$)
+    const combined$ = xs__default["default"].combine(this.sources[this.stateSourceName].stream.startWith(this.currentState), props$, children$)
       .map(([state, __props, __children]) => {
         return typeof state === 'object' ? { ...this.addCalculated(state), __props, __children } : { value: state, __props, __children }
       });
@@ -4087,7 +4087,7 @@ class Component {
   }
 
   renderVdom(componentInstances$) {
-    return xstream__default["default"].combine(this.subComponentsRendered$, componentInstances$)
+    return xs__default["default"].combine(this.subComponentsRendered$, componentInstances$)
       .compose(_default$2(5))
       .map(([_, components]) => {
         const componentNames = Object.keys(this.components);
@@ -4096,7 +4096,7 @@ class Component {
         const entries = Object.entries(components).filter(([id]) => id !== '::ROOT::');
 
         if (entries.length === 0) {
-          return xstream__default["default"].of(root)
+          return xs__default["default"].of(root)
         }
 
         const ids = [];
@@ -4106,9 +4106,9 @@ class Component {
             return val.sink$[this.DOMSourceName].startWith(undefined)
           });
 
-        if (vdom$.length === 0) return xstream__default["default"].of(root)
+        if (vdom$.length === 0) return xs__default["default"].of(root)
 
-        return xstream__default["default"].combine(...vdom$)
+        return xs__default["default"].combine(...vdom$)
           .compose(_default$2(10))
           .map(vdoms => {
             const withIds = vdoms.reduce((acc, vdom, index) => {
@@ -4183,7 +4183,7 @@ function getComponents(currentElement, componentNames, depth=0, index=0) {
       if (!props.of)                            throw new Error(`Collection element missing required 'component' property`)
       if (typeof props.of !== 'string' && typeof props.of !== 'function')         throw new Error(`Invalid 'component' property of collection element: found ${ typeof props.of } requires string or component factory function`)
       if (typeof props.of !== 'function' && !componentNames.includes(props.of))   throw new Error(`Specified component for collection not found: ${ props.of }`)
-      if (typeof props.from !== 'undefined' && !(typeof props.from === 'string' || Array.isArray(props.from))) console.warn(`No valid array found in the 'value' property of collection ${ typeof props.of === 'string' ? props.of : 'function component' }: no collection components will be created`);
+      if (typeof props.from !== 'undefined' && !(typeof props.from === 'string' || Array.isArray(props.from) || typeof props.from.get === 'function')) console.warn(`No valid array found for collection ${ typeof props.of === 'string' ? props.of : 'function component' }: no collection components will be created`, props.from);
       currentElement.data.isCollection = true;
       currentElement.data.props ||= {};
     } else if (isSwitchable) {
@@ -4272,7 +4272,7 @@ function processForm(form, options={}) {
 
   const eventStream$ = events.map(event => form.events(event));
 
-  const merged$ = xstream__default["default"].merge(...eventStream$);
+  const merged$ = xs__default["default"].merge(...eventStream$);
 
   return merged$.map((e) => {
     if (preventDefault) e.preventDefault();
@@ -4333,7 +4333,7 @@ function eventBusDriver(out$) {
       const all = !type;
       const _type = (Array.isArray(type)) ? type : [type];
       let cb;
-      const in$ = xstream__default["default"].create({
+      const in$ = xs__default["default"].create({
         start: (listener) => {
           cb = ({detail: event}) => {
             const data = (event && event.data) || null;
@@ -4740,7 +4740,7 @@ var _default = sampleCombine$1.default = sampleCombine;
 
 Object.defineProperty(exports, 'xs', {
   enumerable: true,
-  get: function () { return xstream__default["default"]; }
+  get: function () { return xs__default["default"]; }
 });
 exports.ABORT = ABORT;
 exports.classes = classes;