TypeScript concat.default函数代码示例

 function app(sources: TestSources) {
   return {
     other: concat(
       sources.other.take(6).map(x => String(x)).startWith('a'),
       xs.never(),
     ),
   };
 }

 function app(sources: {DOM: DOMSource}) {
   return {
     DOM: concat(
       xs.of(h2('.blesh', 'Blesh')),
       xs.of(h3('.blish', 'Blish')).compose(delay(150)),
       xs.of(h4('.blosh', 'Blosh')).compose(delay(150)),
     ),
   };
 }

 function app(_sources: TestSources) {
   return {
     other: concat(
       _sources.other
         .take(6)
         .map(String)
         .startWith('a'),
       xs.never()
     ),
   };
 }

 function app(sources: {DOM: MainDOMSource}) {
   const vtree1$ = xs.of(span('.tab1', 'Hi'));
   const vtree2$ = xs.of(span('.tab2', 'Hello'));
   const first$ = sources.DOM.isolateSink(vtree1$, '1');
   const second$ = sources.DOM.isolateSink(vtree2$, '2');
   const switched$ = concat(
     xs.of(1).compose(delay(50)),
     xs.of(2).compose(delay(50)),
     xs.of(1).compose(delay(50)),
     xs.of(2).compose(delay(50)),
     xs.of(1).compose(delay(50)),
     xs.of(2).compose(delay(50)),
   ).map(i => i === 1 ? first$ : second$).flatten();
   return {
     DOM: switched$,
   };
 }

 return function mainWithState(sources: Forbid<So, N>): Omit<Si, N> {
   const reducerMimic$ = xs.create<Reducer<T>>();
   const state$ = reducerMimic$
     .fold((state, reducer) => reducer(state), void 0 as T | undefined)
     .drop(1);
   const innerSources: So = sources as any;
   innerSources[name] = new StateSource<any>(state$, name);
   const sinks = main(innerSources);
   if (sinks[name]) {
     const stream$ = concat(
       xs.fromObservable<Reducer<T>>(sinks[name]),
       xs.never()
     );
     stream$.subscribe({
       next: i => schedule(() => reducerMimic$._n(i)),
       error: err => schedule(() => reducerMimic$._e(err)),
       complete: () => schedule(() => reducerMimic$._c()),
     });
   }
   return sinks as any;
 };

  function DOMDriver(vnode$: Stream<VNode>, name = 'DOM'): MainDOMSource {
    domDriverInputGuard(vnode$);
    const sanitation$ = xs.create<null>();

    const firstRoot$ = domReady$.map(() => {
      const firstRoot = getValidNode(container) || document.body;
      vnodeWrapper = new VNodeWrapper(firstRoot);
      return firstRoot;
    });

    // We need to subscribe to the sink (i.e. vnode$) synchronously inside this
    // driver, and not later in the map().flatten() because this sink is in
    // reality a SinkProxy from @cycle/run, and we don't want to miss the first
    // emission when the main() is connected to the drivers.
    // Read more in issue #739.
    const rememberedVNode$ = vnode$.remember();
    rememberedVNode$.addListener({});

    // The mutation observer internal to mutationConfirmed$ should
    // exist before elementAfterPatch$ calls mutationObserver.observe()
    mutationConfirmed$.addListener({});

    const elementAfterPatch$ = firstRoot$
      .map(
        firstRoot =>
          xs
            .merge(rememberedVNode$.endWhen(sanitation$), sanitation$)
            .map(vnode => vnodeWrapper.call(vnode))
            .startWith(addRootScope(toVNode(firstRoot)))
            .fold(patch, toVNode(firstRoot))
            .drop(1)
            .map(unwrapElementFromVNode)
            .startWith(firstRoot as any)
            .map(el => {
              mutationObserver.observe(el, {
                childList: true,
                attributes: true,
                characterData: true,
                subtree: true,
                attributeOldValue: true,
                characterDataOldValue: true,
              });
              return el;
            })
            .compose(dropCompletion) // don't complete this stream
      )
      .flatten();

    const rootElement$ = concat(domReady$, mutationConfirmed$)
      .endWhen(sanitation$)
      .compose(sampleCombine(elementAfterPatch$))
      .map(arr => arr[1])
      .remember();

    // Start the snabbdom patching, over time
    rootElement$.addListener({error: reportSnabbdomError});

    const delegator = new EventDelegator(rootElement$, isolateModule);

    return new MainDOMSource(
      rootElement$,
      sanitation$,
      [],
      isolateModule,
      delegator,
      name
    );
  }