@progressive-development/pd-spa-helper 0.3.102 → 0.3.104

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

@@ -0,0 +1,458 @@
+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

@@ -0,0 +1,17 @@
+/**
+@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

@@ -0,0 +1,100 @@
+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
+};