sygnal 5.4.0 → 6.0.0

package/src/cycle/state/pickCombine.ts

@@ -1,201 +0,0 @@
-import xs, {Stream, InternalListener, OutSender, Operator, NO} from 'xstream';
-import {InternalInstances} from './types';
-
-class PickCombineListener<Si, T>
-  implements InternalListener<T>, OutSender<Array<T>> {
-  private key: string;
-  public out: Stream<Array<T>>;
-  public p: PickCombine<Si, T>;
-  public val: T;
-  public ins: Stream<T>;
-
-  constructor(
-    key: string,
-    out: Stream<Array<T>>,
-    p: PickCombine<Si, T>,
-    ins: Stream<T>
-  ) {
-    this.key = key;
-    this.out = out;
-    this.p = p;
-    this.val = NO as any;
-    this.ins = ins;
-  }
-
-  public _n(t: T): void {
-    const p = this.p,
-      out = this.out;
-    this.val = t;
-    if (out === null) {
-      return;
-    }
-    this.p.up();
-  }
-
-  public _e(err: any): void {
-    const out = this.out;
-    if (out === null) {
-      return;
-    }
-    out._e(err);
-  }
-
-  public _c(): void {}
-}
-
-// True when the items present both before and after appear in a different relative
-// order. Additions emit through the new item's sink and removals are handled
-// separately, so only a permutation of the surviving items counts here.
-function isReordered(prev: Array<string>, next: Array<string>, dict: Map<string, any>): boolean {
-  const m = prev.length;
-  if (m === next.length) {
-    let same = true;
-    for (let i = 0; i < m && same; ++i) same = prev[i] === next[i];
-    if (same) return false;
-  }
-  let j = 0;
-  const seen = new Set(prev);
-  for (let i = 0; i < next.length; ++i) {
-    const key = next[i];
-    if (!seen.has(key)) continue;
-    while (j < m && !dict.has(prev[j])) ++j;
-    if (prev[j] !== key) return true;
-    ++j;
-  }
-  return false;
-}
-
-class PickCombine<Si, R> implements Operator<InternalInstances<Si>, Array<R>> {
-  public type = 'combine';
-  public ins: Stream<InternalInstances<Si>>;
-  public out: Stream<Array<R>>;
-  public sel: string;
-  public ils: Map<string, PickCombineListener<Si, R>>;
-  public inst: InternalInstances<Si>;
-  // item keys in the order of the last instances (B-010: detect pure reorders)
-  public keys: Array<string>;
-
-  constructor(sel: string, ins: Stream<InternalInstances<Si>>) {
-    this.ins = ins;
-    this.sel = sel;
-    this.out = null as any;
-    this.ils = new Map();
-    this.inst = null as any;
-    this.keys = [];
-  }
-
-  public _start(out: Stream<Array<R>>): void {
-    this.out = out;
-    this.ins._add(this);
-  }
-
-  public _stop(): void {
-    this.ins._remove(this);
-    const ils = this.ils;
-    ils.forEach(il => {
-      il.ins._remove(il);
-      il.ins = null as any;
-      il.out = null as any;
-      il.val = null as any;
-    });
-    ils.clear();
-    this.out = null as any;
-    this.ils = new Map();
-    this.inst = null as any;
-    this.keys = [];
-  }
-
-  public up(): void {
-    const arr = this.inst.arr;
-    const n = arr.length;
-    const ils = this.ils;
-    const outArr: Array<R> = Array(n);
-    for (let i = 0; i < n; ++i) {
-      const sinks = arr[i];
-      const key = (sinks as any)._key as string;
-      if (!ils.has(key)) {
-        return;
-      }
-      const val = (ils.get(key) as any).val;
-      if (val === NO) {
-        return;
-      }
-      outArr[i] = val;
-    }
-    this.out._n(outArr);
-  }
-
-  public _n(inst: InternalInstances<Si>): void {
-    this.inst = inst;
-    const arrSinks = inst.arr;
-    const ils = this.ils;
-    const out = this.out;
-    const sel = this.sel;
-    const dict = inst.dict;
-    const n = arrSinks.length;
-    // remove
-    let removed = false;
-    ils.forEach((il, key) => {
-      if (!dict.has(key)) {
-        il.ins._remove(il);
-        il.ins = null as any;
-        il.out = null as any;
-        il.val = null as any;
-        ils.delete(key);
-        removed = true;
-      }
-    });
-    if (n === 0) {
-      this.keys = [];
-      out._n([]);
-      return;
-    }
-    // add
-    const keys: Array<string> = Array(n);
-    for (let i = 0; i < n; ++i) {
-      const sinks = arrSinks[i];
-      const key = (sinks as any)._key as string;
-      keys[i] = key;
-      if (!(sinks as any)[sel]) {
-        throw new Error('pickCombine found an undefined child sink stream');
-      }
-      const sink: Stream<any> = xs.fromObservable((sinks as any)[sel]);
-      if (!ils.has(key)) {
-        ils.set(key, new PickCombineListener(key, out, this, sink));
-        sink._add(ils.get(key) as PickCombineListener<Si, R>);
-      }
-    }
-    const reordered = isReordered(this.keys, keys, dict);
-    this.keys = keys;
-    // B-010: a permutation (swap, reverse, move) neither removes an item nor makes an
-    // item sink emit, so re-emit whenever the order of keys changed. up() waits until
-    // every item has emitted, so a brand new item still triggers its own emission.
-    if (removed || reordered) {
-      this.up();
-    }
-  }
-
-  public _e(e: any): void {
-    const out = this.out;
-    if (out === null) {
-      return;
-    }
-    out._e(e);
-  }
-
-  public _c(): void {
-    const out = this.out;
-    if (out === null) {
-      return;
-    }
-    out._c();
-  }
-}
-
-export function pickCombine(selector: string) {
-  return function pickCombineOperator(
-    inst$: Stream<InternalInstances<any>>
-  ): Stream<Array<any>> {
-    return new Stream(new PickCombine(selector, inst$));
-  };
-}

package/src/cycle/state/pickMerge.ts

@@ -1,122 +0,0 @@
-import xs, {Stream, InternalListener, OutSender, Operator} from 'xstream';
-import {InternalInstances} from './types';
-
-class PickMergeListener<Si, T> implements InternalListener<T>, OutSender<T> {
-  public ins: Stream<T>;
-  public out: Stream<T>;
-  public p: PickMerge<Si, T>;
-
-  constructor(out: Stream<T>, p: PickMerge<Si, T>, ins: Stream<T>) {
-    this.ins = ins;
-    this.out = out;
-    this.p = p;
-  }
-
-  public _n(t: T): void {
-    const p = this.p,
-      out = this.out;
-    if (out === null) {
-      return;
-    }
-    out._n(t);
-  }
-
-  public _e(err: any): void {
-    const out = this.out;
-    if (out === null) {
-      return;
-    }
-    out._e(err);
-  }
-
-  public _c(): void {}
-}
-
-class PickMerge<Si, T> implements Operator<InternalInstances<Si>, T> {
-  public type = 'pickMerge';
-  public ins: Stream<InternalInstances<Si>>;
-  public out: Stream<T>;
-  public sel: string;
-  public ils: Map<string, PickMergeListener<Si, T>>;
-  public inst: InternalInstances<Si>;
-
-  constructor(sel: string, ins: Stream<InternalInstances<Si>>) {
-    this.ins = ins;
-    this.out = null as any;
-    this.sel = sel;
-    this.ils = new Map();
-    this.inst = null as any;
-  }
-
-  public _start(out: Stream<T>): void {
-    this.out = out;
-    this.ins._add(this);
-  }
-
-  public _stop(): void {
-    this.ins._remove(this);
-    const ils = this.ils;
-    ils.forEach((il, key) => {
-      il.ins._remove(il);
-      il.ins = null as any;
-      il.out = null as any;
-      ils.delete(key);
-    });
-    ils.clear();
-    this.out = null as any;
-    this.ils = new Map();
-    this.inst = null as any;
-  }
-
-  public _n(inst: InternalInstances<Si>): void {
-    this.inst = inst;
-    const arrSinks = inst.arr;
-    const ils = this.ils;
-    const out = this.out;
-    const sel = this.sel;
-    const n = arrSinks.length;
-    // add
-    for (let i = 0; i < n; ++i) {
-      const sinks = arrSinks[i];
-      const key = (sinks as any)._key as string;
-      const sink: Stream<any> = xs.fromObservable((sinks as any)[sel] || xs.never());
-      if (!ils.has(key)) {
-        ils.set(key, new PickMergeListener(out, this, sink));
-        sink._add(ils.get(key) as PickMergeListener<Si, T>);
-      }
-    }
-    // remove
-    ils.forEach((il, key) => {
-      if (!inst.dict.has(key) || !inst.dict.get(key)) {
-        il.ins._remove(il);
-        il.ins = null as any;
-        il.out = null as any;
-        ils.delete(key);
-      }
-    });
-  }
-
-  public _e(err: any) {
-    const u = this.out;
-    if (u === null) {
-      return;
-    }
-    u._e(err);
-  }
-
-  public _c() {
-    const u = this.out;
-    if (u === null) {
-      return;
-    }
-    u._c();
-  }
-}
-
-export function pickMerge(selector: string) {
-  return function pickMergeOperator(
-    inst$: Stream<InternalInstances<any>>
-  ): Stream<any> {
-    return new Stream(new PickMerge(selector, inst$));
-  };
-}

package/src/cycle/state/withState.ts

@@ -1,47 +0,0 @@
-import xs, {Stream} from 'xstream';
-import {concat} from '../../extra/xstreamExtras';
-import {MainFn, Reducer} from './types';
-import {StateSource} from './StateSource';
-
-export type Omit<T, K extends keyof T> = {[P in Exclude<keyof T, K>]: T[P]};
-
-export type Forbid<T, K extends keyof T> = Omit<T, K> & {[P in K]?: never};
-
-export type OSo<T, N extends string> = {[P in N]: StateSource<T>};
-export type OSi<T, N extends string> = {[P in N]: Stream<Reducer<T>>};
-
-export type MainWithState<
-  So extends OSo<T, N>,
-  Si extends OSi<T, N>,
-  T,
-  N extends string
-> = MainFn<Forbid<So, N>, Omit<Si, N>>;
-
-export function withState<
-  So extends OSo<T, N>,
-  Si extends OSi<T, N>,
-  T = any,
-  N extends string = 'state'
->(main: MainFn<So, Si>, name: N = 'state' as N): MainWithState<So, Si, T, N> {
-  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 as any)[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 => queueMicrotask(() => reducerMimic$._n(i)),
-        error: err => queueMicrotask(() => reducerMimic$._e(err)),
-        complete: () => queueMicrotask(() => reducerMimic$._c()),
-      });
-    }
-    return sinks as any;
-  };
-}

package/src/pragma/fn.ts

@@ -1,55 +0,0 @@
-// TODO: stop using extend here
-// @ts-ignore — no type declarations for 'extend'
-import _extend from 'extend'
-
-import * as is from './is'
-
-export const extend = (...objs: any[]): any => _extend(true, ...objs)
-
-export const assign = (...objs: any[]): any => _extend(false, ...objs)
-
-export const reduceDeep = <T>(arr: any[], fn: (acc: T, value: any) => T, initial: T): T => {
-  let result = initial
-  for (let i = 0; i < arr.length; i++) {
-    const value = arr[i]
-    if (is.array(value)) {
-      result = reduceDeep(value, fn, result)
-    } else {
-      result = fn(result, value)
-    }
-  }
-  return result
-}
-
-export const mapObject = (obj: Record<string, any>, fn: (key: string, val: any) => any): any => Object.keys(obj).map(
-  (key) => fn(key, obj[key])
-).reduce(
-  (acc: any, curr: any) => extend(acc, curr),
-  {}
-)
-
-export const deepifyKeys = (obj: Record<string, any>, modules: Record<string, any>): any => mapObject(obj,
-  (key: string, val: any) => {
-    const dashIndex = key.indexOf('-')
-    if (dashIndex > -1 && modules[key.slice(0, dashIndex)] !== undefined) {
-      const moduleData = {
-        [key.slice(dashIndex + 1)]: val
-      }
-      return {
-        [key.slice(0, dashIndex)]: moduleData
-      }
-    }
-    return { [key]: val }
-  }
-)
-
-export const flatifyKeys = (obj: Record<string, any>): any => mapObject(obj,
-  (mod: string, data: any) => !is.object(data) ? ({ [mod]: data }) : mapObject(
-    flatifyKeys(data),
-    (key: string, val: any) => ({ [`${mod}-${key}`]: val })
-  )
-)
-
-export const omit = (key: string, obj: Record<string, any>): any => mapObject(obj,
-  (mod: string, data: any) => mod !== key ? ({ [mod]: data }) : {}
-)