@progressive-development/pd-spa-helper 0.4.0 → 0.5.1

package/dist/node_modules/mini-rx-store/index.esm.js

@@ -1,458 +0,0 @@
-import { BehaviorSubject, Subject, pipe, queueScheduler } from "rxjs";
-import { filter } from "../rxjs/dist/esm5/internal/operators/filter.js";
-import { observeOn } from "../rxjs/dist/esm5/internal/operators/observeOn.js";
-import { map } from "../rxjs/dist/esm5/internal/operators/map.js";
-import { distinctUntilChanged } from "../rxjs/dist/esm5/internal/operators/distinctUntilChanged.js";
-import { withLatestFrom } from "../rxjs/dist/esm5/internal/operators/withLatestFrom.js";
-import { tap } from "../rxjs/dist/esm5/internal/operators/tap.js";
-import { catchError } from "../rxjs/dist/esm5/internal/operators/catchError.js";
-class StoreExtension {
-  constructor() {
-    this.sortOrder = 0;
-  }
-}
-const EFFECT_METADATA_KEY = "@mini-rx/effectMetaData";
-const miniRxNameSpace = "@mini-rx";
-function createMiniRxActionType(miniRxActionType, featureKey) {
-  return miniRxNameSpace + (featureKey ? "/" + featureKey : "") + "/" + miniRxActionType;
-}
-function createMiniRxAction(miniRxActionType, featureKey) {
-  return {
-    type: createMiniRxActionType(miniRxActionType, featureKey)
-  };
-}
-const setStateActionTypeKey = "setStateActionType";
-function isFeatureStoreSetStateAction(action) {
-  return action[setStateActionTypeKey] === "@mini-rx/feature-store";
-}
-function isComponentStoreSetStateAction(action) {
-  return action[setStateActionTypeKey] === "@mini-rx/component-store";
-}
-function select(mapFn) {
-  return pipe(map(mapFn), distinctUntilChanged());
-}
-function miniRxError(message) {
-  throw new Error(miniRxNameSpace + ": " + message);
-}
-function miniRxConsoleError(message, err) {
-  console.error(miniRxNameSpace + ": " + message + "\nDetails:", err);
-}
-function hasEffectMetaData(param) {
-  return param.hasOwnProperty(EFFECT_METADATA_KEY);
-}
-function beautifyActionForLogging(action, state) {
-  if (isFeatureStoreSetStateAction(action) || isComponentStoreSetStateAction(action)) {
-    return {
-      type: action.type,
-      payload: action.stateOrCallback
-    };
-  }
-  return action;
-}
-function calcNewState(state, stateOrCallback) {
-  const newPartialState = typeof stateOrCallback === "function" ? stateOrCallback(state) : stateOrCallback;
-  return Object.assign(Object.assign({}, state), newPartialState);
-}
-function combineMetaReducers(metaReducers) {
-  return (reducer) => {
-    return metaReducers.reduceRight((previousValue, currentValue) => {
-      return currentValue(previousValue);
-    }, reducer);
-  };
-}
-function sortExtensions(extensions) {
-  return [...extensions].sort((a, b) => {
-    return a.sortOrder - b.sortOrder;
-  });
-}
-function defaultEffectsErrorHandler(observable$, retryAttemptLeft = 10) {
-  return observable$.pipe(catchError((error) => {
-    miniRxConsoleError(`An error occurred in the Effect. MiniRx resubscribed the Effect automatically and will do so ${retryAttemptLeft - 1} more times.
-Please provide error handling inside the Effect using \`catchError\` or \`tapResponse\`.`, error);
-    if (retryAttemptLeft <= 1) {
-      return observable$;
-    }
-    return defaultEffectsErrorHandler(observable$, retryAttemptLeft - 1);
-  }));
-}
-function combineReducers(reducers) {
-  const reducerKeys = Object.keys(reducers);
-  const reducerKeyLength = reducerKeys.length;
-  return (state = {}, action) => {
-    const stateKeysLength = Object.keys(state).length;
-    let hasChanged = stateKeysLength !== reducerKeyLength;
-    const nextState = {};
-    for (let i = 0; i < reducerKeyLength; i++) {
-      const key = reducerKeys[i];
-      const reducer = reducers[key];
-      const previousStateForKey = state[key];
-      const nextStateForKey = reducer(previousStateForKey, action);
-      nextState[key] = nextStateForKey;
-      hasChanged = hasChanged || nextStateForKey !== previousStateForKey;
-    }
-    return hasChanged ? nextState : state;
-  };
-}
-class State {
-  constructor(initialState) {
-    this.initialState = initialState;
-    this.stateSource = new BehaviorSubject(this.initialState);
-    this.state$ = this.stateSource.asObservable().pipe(
-      // Skip the first (undefined) value of the BehaviorSubject
-      // Very similar to a ReplaySubject(1), but more lightweight
-      // Emits a state object (when calling the `set` method)
-      filter((v) => !!v)
-    );
-  }
-  get() {
-    return this.stateSource.value;
-  }
-  set(v) {
-    this.stateSource.next(v);
-  }
-  patch(stateOrCallback) {
-    if (!this.get()) {
-      throw new Error("State is not initialized.");
-    }
-    this.stateSource.next(calcNewState(this.get(), stateOrCallback));
-  }
-  select(mapFn) {
-    if (!mapFn) {
-      return this.state$;
-    }
-    return this.state$.pipe(select(mapFn));
-  }
-}
-class ActionsOnQueue {
-  constructor() {
-    this.actionsSource = new Subject();
-    this.actions$ = this.actionsSource.asObservable().pipe(
-      observeOn(queueScheduler)
-      // Prevent stack overflow: https://blog.cloudboost.io/so-how-does-rx-js-queuescheduler-actually-work-188c1b46526e
-    );
-  }
-  dispatch(action) {
-    this.actionsSource.next(action);
-  }
-}
-let isStoreInitialized = false;
-const reducerState = new State();
-const reducer$ = reducerState.select((v) => {
-  const combinedMetaReducer = combineMetaReducers(v.metaReducers);
-  const combinedReducer = v.combineReducersFn(v.featureReducers);
-  return combinedMetaReducer(combinedReducer);
-});
-function hasFeatureReducers() {
-  return !!Object.keys(reducerState.get().featureReducers).length;
-}
-function checkFeatureExists(featureKey) {
-  if (reducerState.get().featureReducers.hasOwnProperty(featureKey)) {
-    miniRxError(`Feature "${featureKey}" already exists.`);
-  }
-}
-function addReducer(featureKey, reducer) {
-  initStore();
-  checkFeatureExists(featureKey);
-  reducerState.patch((state) => ({
-    featureReducers: Object.assign(Object.assign({}, state.featureReducers), {
-      [featureKey]: reducer
-    })
-  }));
-}
-function addMetaReducers(...reducers) {
-  reducerState.patch((state) => ({
-    metaReducers: [...state.metaReducers, ...reducers]
-  }));
-}
-function updateCombineReducersFn(combineReducersFn) {
-  reducerState.patch({
-    combineReducersFn
-  });
-}
-const actionsOnQueue = new ActionsOnQueue();
-const actions$ = actionsOnQueue.actions$;
-const appState = new State();
-function initStore() {
-  if (isStoreInitialized) {
-    return;
-  }
-  reducerState.set({
-    featureReducers: {},
-    metaReducers: [],
-    combineReducersFn: combineReducers
-  });
-  let reducer;
-  reducer$.subscribe((v) => reducer = v);
-  actionsOnQueue.actions$.subscribe((action) => {
-    const newState = reducer(
-      appState.get(),
-      // Initially undefined, but the reducer can handle undefined (by falling back to initial state)
-      action
-    );
-    appState.set(newState);
-  });
-  isStoreInitialized = true;
-}
-function configureStore$1(config = {}) {
-  var _a, _b;
-  initStore();
-  if (hasFeatureReducers()) {
-    miniRxError("`configureStore` detected reducers. Did you instantiate FeatureStores before calling `configureStore`?");
-  }
-  if (config.combineReducersFn) {
-    updateCombineReducersFn(config.combineReducersFn);
-  }
-  if ((_a = config.metaReducers) === null || _a === void 0 ? void 0 : _a.length) {
-    addMetaReducers(...config.metaReducers);
-  }
-  if ((_b = config.extensions) === null || _b === void 0 ? void 0 : _b.length) {
-    const sortedExtensions = sortExtensions(config.extensions);
-    sortedExtensions.forEach((extension) => addExtension(extension));
-  }
-  if (config.reducers) {
-    Object.keys(config.reducers).forEach((featureKey) => {
-      addReducer(featureKey, config.reducers[featureKey]);
-    });
-  }
-  if (config.initialState) {
-    appState.set(config.initialState);
-  }
-  dispatch(createMiniRxAction(
-    "init"
-    /* INIT */
-  ));
-}
-function addFeature(featureKey, reducer, config = {}) {
-  var _a;
-  reducer = ((_a = config.metaReducers) === null || _a === void 0 ? void 0 : _a.length) ? combineMetaReducers(config.metaReducers)(reducer) : reducer;
-  if (typeof config.initialState !== "undefined") {
-    reducer = createReducerWithInitialState(reducer, config.initialState);
-  }
-  addReducer(featureKey, reducer);
-  dispatch(createMiniRxAction(
-    "init",
-    featureKey
-  ));
-}
-function effect(effect$) {
-  const effectWithErrorHandler$ = defaultEffectsErrorHandler(effect$);
-  effectWithErrorHandler$.subscribe((action) => {
-    let shouldDispatch = true;
-    if (hasEffectMetaData(effect$)) {
-      const metaData = effect$[EFFECT_METADATA_KEY];
-      shouldDispatch = !!metaData.dispatch;
-    }
-    if (shouldDispatch) {
-      dispatch(action);
-    }
-  });
-}
-function addExtension(extension) {
-  const metaReducer = extension.init();
-  if (metaReducer) {
-    addMetaReducers(metaReducer);
-  }
-  if (extension.id === 1) ;
-}
-function dispatch(action) {
-  actionsOnQueue.dispatch(action);
-}
-function createReducerWithInitialState(reducer, initialState) {
-  return (state = initialState, action) => {
-    return reducer(state, action);
-  };
-}
-let isStoreConfigured = false;
-function configureStore(config) {
-  if (!isStoreConfigured) {
-    configureStore$1(config);
-    isStoreConfigured = true;
-    return {
-      feature: addFeature,
-      select: appState.select.bind(appState),
-      dispatch,
-      effect
-    };
-  }
-  miniRxError("`configureStore` was called multiple times.");
-}
-function isEqual(first, second) {
-  if (first === second) {
-    return true;
-  }
-  if (Number.isNaN(first) && Number.isNaN(second)) {
-    return true;
-  }
-  return false;
-}
-function areInputsEqual(newInputs, lastInputs) {
-  if (newInputs.length !== lastInputs.length) {
-    return false;
-  }
-  for (let i = 0; i < newInputs.length; i++) {
-    if (!isEqual(newInputs[i], lastInputs[i])) {
-      return false;
-    }
-  }
-  return true;
-}
-function memoizeOne(resultFn) {
-  let cache = null;
-  function memoized(...newArgs) {
-    if (cache && cache.lastThis === this && areInputsEqual(newArgs, cache.lastArgs)) {
-      return cache.lastResult;
-    }
-    const lastResult = resultFn.apply(this, newArgs);
-    cache = {
-      lastResult,
-      lastArgs: newArgs,
-      lastThis: this
-    };
-    return lastResult;
-  }
-  return memoized;
-}
-function createSelector(...args) {
-  if (args.length === 1 && isSelectorsDictionary(args[0])) {
-    args = extractArgsFromSelectorsDictionary(args[0]);
-  }
-  const selectors = args.slice(0, args.length - 1);
-  const projector = args[args.length - 1];
-  const memoizedProjector = memoizeOne(projector);
-  return memoizeOne((state) => {
-    const selectorResults = selectors.map((fn) => fn(state));
-    return memoizedProjector.apply(null, selectorResults);
-  });
-}
-function createFeatureSelector(featureKey) {
-  if (featureKey) {
-    return createSelector((state) => state[featureKey], (featureState) => featureState);
-  }
-  return (state) => state;
-}
-const createFeatureStateSelector = createFeatureSelector;
-function isSelectorsDictionary(selectors) {
-  return !!selectors && typeof selectors === "object" && Object.values(selectors).every((selector) => typeof selector === "function");
-}
-function extractArgsFromSelectorsDictionary(selectorsDictionary) {
-  const selectors = Object.values(selectorsDictionary);
-  const resultKeys = Object.keys(selectorsDictionary);
-  const projector = (...selectorResults) => resultKeys.reduce((result, key, index) => Object.assign(Object.assign({}, result), {
-    [key]: selectorResults[index]
-  }), {});
-  return [...selectors, projector];
-}
-const defaultOptions = {
-  name: "MiniRx - Redux DevTools",
-  traceLimit: 25
-};
-class ReduxDevtoolsExtension extends StoreExtension {
-  constructor(options) {
-    super();
-    this.options = options;
-    this.id = 3;
-    if (!window) {
-      miniRxError("The Redux DevTools are only supported in browser environments.");
-    }
-    this._optionsForNgExtension = options;
-    this.devtoolsExtension = window.__REDUX_DEVTOOLS_EXTENSION__;
-    this.options = Object.assign(Object.assign({}, defaultOptions), this.options);
-  }
-  get optionsForNgExtension() {
-    return this._optionsForNgExtension;
-  }
-  init() {
-    if (this.devtoolsExtension) {
-      this.devtoolsConnection = this.devtoolsExtension.connect(this.options);
-      actions$.pipe(withLatestFrom(appState.select()), tap(([action, state]) => {
-        const actionForDevTools = beautifyActionForLogging(action);
-        this.devtoolsConnection.send(actionForDevTools, state);
-      })).subscribe();
-      this.devtoolsConnection.subscribe(this.onDevToolsMessage.bind(this));
-    }
-  }
-  onDevToolsMessage(message) {
-    if (message.type === "DISPATCH") {
-      switch (message.payload.type) {
-        case "JUMP_TO_STATE":
-        case "JUMP_TO_ACTION":
-          this.updateState(JSON.parse(message.state));
-      }
-    }
-  }
-  updateState(state) {
-    appState.set(state);
-  }
-}
-class LoggerExtension extends StoreExtension {
-  constructor() {
-    super(...arguments);
-    this.id = 2;
-    this.hasCsSupport = true;
-  }
-  init() {
-    return loggerMetaReducer;
-  }
-}
-function loggerMetaReducer(reducer) {
-  return (state, action) => {
-    const actionToLog = beautifyActionForLogging(action);
-    const nextState = reducer(state, action);
-    console.log("%c" + action.type, "color: #25c2a0", "\nAction:", actionToLog, "\nState: ", nextState);
-    return nextState;
-  };
-}
-function deepFreeze(o) {
-  Object.freeze(o);
-  const oIsFunction = typeof o === "function";
-  const hasOwnProp = Object.prototype.hasOwnProperty;
-  Object.getOwnPropertyNames(o).forEach(function(prop) {
-    if (hasOwnProp.call(o, prop) && (oIsFunction ? prop !== "caller" && prop !== "callee" && prop !== "arguments" : true) && o[prop] !== null && (typeof o[prop] === "object" || typeof o[prop] === "function") && !Object.isFrozen(o[prop])) {
-      deepFreeze(o[prop]);
-    }
-  });
-  return o;
-}
-class ImmutableStateExtension extends StoreExtension {
-  constructor() {
-    super(...arguments);
-    this.id = 0;
-    this.hasCsSupport = true;
-  }
-  init() {
-    return storeFreeze;
-  }
-}
-function storeFreeze(reducer) {
-  return (state, action) => {
-    if (state) {
-      deepFreeze(state);
-    }
-    const nextState = reducer(state, action);
-    deepFreeze(nextState);
-    return nextState;
-  };
-}
-const DEFAULT_EFFECT_CONFIG = {
-  dispatch: true
-};
-function createEffect(v, config) {
-  const value = Object.assign(Object.assign({}, DEFAULT_EFFECT_CONFIG), config);
-  Object.defineProperty(v, EFFECT_METADATA_KEY, {
-    value
-  });
-  return v;
-}
-export {
-  ImmutableStateExtension,
-  LoggerExtension,
-  ReduxDevtoolsExtension,
-  StoreExtension,
-  actions$,
-  configureStore,
-  createEffect,
-  createFeatureSelector,
-  createFeatureStateSelector,
-  createSelector,
-  hasEffectMetaData
-};

package/dist/node_modules/pwa-helpers/media-query.js

@@ -1,17 +0,0 @@
-/**
-@license
-Copyright (c) 2018 The Polymer Project Authors. All rights reserved.
-This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
-The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
-The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
-Code distributed by Google as part of the polymer project is also
-subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
-*/
-const installMediaQueryWatcher = (mediaQuery, layoutChangedCallback) => {
-  let mql = window.matchMedia(mediaQuery);
-  mql.addListener((e) => layoutChangedCallback(e.matches));
-  layoutChangedCallback(mql.matches);
-};
-export {
-  installMediaQueryWatcher
-};

package/dist/node_modules/rxjs/dist/esm5/internal/Observable.js

@@ -1,100 +0,0 @@
-import { SafeSubscriber, Subscriber } from "./Subscriber.js";
-import { isSubscription } from "./Subscription.js";
-import { observable } from "./symbol/observable.js";
-import { pipeFromArray } from "./util/pipe.js";
-import { config } from "./config.js";
-import { isFunction } from "./util/isFunction.js";
-import { errorContext } from "./util/errorContext.js";
-var Observable = function() {
-  function Observable2(subscribe) {
-    if (subscribe) {
-      this._subscribe = subscribe;
-    }
-  }
-  Observable2.prototype.lift = function(operator) {
-    var observable2 = new Observable2();
-    observable2.source = this;
-    observable2.operator = operator;
-    return observable2;
-  };
-  Observable2.prototype.subscribe = function(observerOrNext, error, complete) {
-    var _this = this;
-    var subscriber = isSubscriber(observerOrNext) ? observerOrNext : new SafeSubscriber(observerOrNext, error, complete);
-    errorContext(function() {
-      var _a = _this, operator = _a.operator, source = _a.source;
-      subscriber.add(operator ? operator.call(subscriber, source) : source ? _this._subscribe(subscriber) : _this._trySubscribe(subscriber));
-    });
-    return subscriber;
-  };
-  Observable2.prototype._trySubscribe = function(sink) {
-    try {
-      return this._subscribe(sink);
-    } catch (err) {
-      sink.error(err);
-    }
-  };
-  Observable2.prototype.forEach = function(next, promiseCtor) {
-    var _this = this;
-    promiseCtor = getPromiseCtor(promiseCtor);
-    return new promiseCtor(function(resolve, reject) {
-      var subscriber = new SafeSubscriber({
-        next: function(value) {
-          try {
-            next(value);
-          } catch (err) {
-            reject(err);
-            subscriber.unsubscribe();
-          }
-        },
-        error: reject,
-        complete: resolve
-      });
-      _this.subscribe(subscriber);
-    });
-  };
-  Observable2.prototype._subscribe = function(subscriber) {
-    var _a;
-    return (_a = this.source) === null || _a === void 0 ? void 0 : _a.subscribe(subscriber);
-  };
-  Observable2.prototype[observable] = function() {
-    return this;
-  };
-  Observable2.prototype.pipe = function() {
-    var operations = [];
-    for (var _i = 0; _i < arguments.length; _i++) {
-      operations[_i] = arguments[_i];
-    }
-    return pipeFromArray(operations)(this);
-  };
-  Observable2.prototype.toPromise = function(promiseCtor) {
-    var _this = this;
-    promiseCtor = getPromiseCtor(promiseCtor);
-    return new promiseCtor(function(resolve, reject) {
-      var value;
-      _this.subscribe(function(x) {
-        return value = x;
-      }, function(err) {
-        return reject(err);
-      }, function() {
-        return resolve(value);
-      });
-    });
-  };
-  Observable2.create = function(subscribe) {
-    return new Observable2(subscribe);
-  };
-  return Observable2;
-}();
-function getPromiseCtor(promiseCtor) {
-  var _a;
-  return (_a = promiseCtor !== null && promiseCtor !== void 0 ? promiseCtor : config.Promise) !== null && _a !== void 0 ? _a : Promise;
-}
-function isObserver(value) {
-  return value && isFunction(value.next) && isFunction(value.error) && isFunction(value.complete);
-}
-function isSubscriber(value) {
-  return value && value instanceof Subscriber || isObserver(value) && isSubscription(value);
-}
-export {
-  Observable
-};