@loona/angular
Version:
App State Management done with GraphQL (angular integration)
504 lines (494 loc) • 39 kB
JavaScript
import { InjectionToken, Injectable, ErrorHandler, Inject, NgModule, Injector } from '@angular/core';
import { Observable, BehaviorSubject, Subject, queueScheduler, merge, throwError, from } from 'rxjs';
import { Apollo } from 'apollo-angular';
import { observeOn, tap, catchError } from 'rxjs/operators';
import { isMutation, getMutation, isDocument, Manager, withUpdates, getActionType, buildActionFromResult, buildActionFromError, buildContext, getNameOfMutation, isMutationAsAction, METADATA_KEY, buildGetCacheKey, LoonaLink } from '@loona/core';
export { Manager, LoonaLink, State, Mutation, Update, Resolve, Effect } from '@loona/core';
import { ApolloCache } from 'apollo-cache';
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,missingReturn,uselessCode} checked by tsc
*/
/** @type {?} */
const INITIAL_STATE = new InjectionToken('Loona/State');
/** @type {?} */
const CHILD_STATE = new InjectionToken('Loona/ChildState');
/** @type {?} */
const LOONA_CACHE = new InjectionToken('Loona/Cache');
/** @type {?} */
const INIT = '@@init';
/** @type {?} */
const ROOT_EFFECTS_INIT = '@@effects/init';
/** @type {?} */
const UPDATE_EFFECTS = '@@effects/update';
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,missingReturn,uselessCode} checked by tsc
*/
/**
* @template V
*/
class Actions extends Observable {
}
class ScannedActions extends Subject {
/**
* @return {?}
*/
ngOnDestroy() {
this.complete();
}
}
ScannedActions.decorators = [
{ type: Injectable }
];
class InnerActions extends BehaviorSubject {
constructor() {
super({ type: INIT });
}
/**
* @param {?} action
* @return {?}
*/
next(action) {
if (typeof action === 'undefined') {
throw new TypeError(`Actions must be objects`);
}
else if (typeof action.type === 'undefined') {
throw new TypeError(`Actions must have a type property`);
}
super.next(action);
}
/**
* @return {?}
*/
complete() { }
/**
* @return {?}
*/
ngOnDestroy() {
super.complete();
}
}
InnerActions.decorators = [
{ type: Injectable }
];
/** @nocollapse */
InnerActions.ctorParameters = () => [];
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,missingReturn,uselessCode} checked by tsc
*/
class Loona {
/**
* @param {?} apollo
* @param {?} manager
* @param {?} actions
* @param {?} scannedActions
* @param {?} errorHandler
*/
constructor(apollo, manager, actions, scannedActions, errorHandler) {
this.apollo = apollo;
this.manager = manager;
this.actions = actions;
this.direct$ = new Subject();
this.queue$ = merge(actions, this.direct$).pipe(observeOn(queueScheduler));
this.queue$.subscribe({
next: action => {
scannedActions.next(action);
},
error: error => {
errorHandler.handleError(error);
},
});
}
/**
* @template T, V
* @param {?} queryOrOptions
* @param {?=} variables
* @param {?=} options
* @return {?}
*/
query(queryOrOptions, variables, options) {
return this.apollo.watchQuery(isDocument(queryOrOptions)
? Object.assign({ query: queryOrOptions, variables }, options) : queryOrOptions);
}
/**
* @template T, V
* @param {?} mutationOrOptions
* @param {?=} variables
* @param {?=} options
* @return {?}
*/
mutate(mutationOrOptions, variables, options) {
/** @type {?} */
const config = isDocument(mutationOrOptions)
? Object.assign({ mutation: mutationOrOptions, variables }, options) : mutationOrOptions;
return this.apollo
.mutate(withUpdates(config, this.manager))
.pipe(tap(result => {
this.direct$.next(buildActionFromResult(config, result));
}), catchError(error => {
this.direct$.next(buildActionFromError(config, error));
return throwError(error);
}));
}
/**
* @param {?} action
* @return {?}
*/
dispatch(action) {
if (isMutation(action)) {
/** @type {?} */
const mutation = getMutation(action);
this.mutate(Object.assign({ mutation }, action)).subscribe();
}
else {
this.actions.next(Object.assign({ type: getActionType(action) }, action));
}
}
/**
* @template T
* @return {?}
*/
extract() {
return this.apollo.getClient().extract();
}
/**
* @return {?}
*/
reset() {
this.apollo.getClient().resetStore();
}
/**
* @param {?} state
* @return {?}
*/
restore(state) {
this.apollo.getClient().restore(state);
}
}
Loona.decorators = [
{ type: Injectable }
];
/** @nocollapse */
Loona.ctorParameters = () => [
{ type: Apollo },
{ type: Manager },
{ type: InnerActions },
{ type: ScannedActions },
{ type: ErrorHandler }
];
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,missingReturn,uselessCode} checked by tsc
*/
class Effects {
/**
* @param {?} loona
* @param {?} apollo
* @param {?} cache
*/
constructor(loona, apollo, cache) {
this.effects = {};
this.getContext = () => (Object.assign({}, buildContext({
cache,
getCacheKey: buildGetCacheKey(cache),
}, apollo.getClient()), { dispatch: loona.dispatch.bind(loona) }));
}
/**
* @param {?} instance
* @param {?=} meta
* @return {?}
*/
addEffects(instance, meta) {
if (!meta) {
return;
}
for (const type in meta) {
if (!this.effects[type]) {
this.effects[type] = [];
}
meta[type].forEach(({ propName }) => {
this.effects[type].push(instance[propName].bind(instance));
});
}
}
/**
* @param {?} action
* @return {?}
*/
runEffects(action) {
/** @type {?} */
let type = action.type;
if (isMutationAsAction(action)) {
type = getNameOfMutation(action.options.mutation);
}
/** @type {?} */
const effectsToRun = this.effects[type];
if (effectsToRun) {
effectsToRun.forEach(effect => {
effect(action, this.getContext());
});
}
}
}
Effects.decorators = [
{ type: Injectable }
];
/** @nocollapse */
Effects.ctorParameters = () => [
{ type: Loona },
{ type: Apollo },
{ type: ApolloCache, decorators: [{ type: Inject, args: [LOONA_CACHE,] }] }
];
class EffectsRunner {
/**
* @param {?} effects
* @param {?} scannedActions
*/
constructor(effects, scannedActions) {
this.effects = effects;
this.scannedActions = scannedActions;
this.actionsSubscription = null;
}
/**
* @return {?}
*/
start() {
if (!this.actionsSubscription) {
this.actionsSubscription = this.scannedActions.subscribe(action => {
this.effects.runEffects(action);
});
}
}
/**
* @return {?}
*/
ngOnDestroy() {
if (this.actionsSubscription) {
this.actionsSubscription.unsubscribe();
this.actionsSubscription = null;
}
}
}
EffectsRunner.decorators = [
{ type: Injectable }
];
/** @nocollapse */
EffectsRunner.ctorParameters = () => [
{ type: Effects },
{ type: ScannedActions }
];
/**
* @return {?}
*/
function mapStates() {
/** @type {?} */
const names = [];
/** @type {?} */
const add = (state) => {
names.push(state.constructor && state.constructor.name);
};
return { names, add };
}
/**
* @param {?} state
* @param {?} injector
* @return {?}
*/
function extractState(state, injector) {
return {
instance: injector.get(state),
meta: state[METADATA_KEY],
};
}
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,missingReturn,uselessCode} checked by tsc
*/
/**
* @template T
* @param {?} val
* @return {?}
*/
function isObservable(val) {
return val instanceof Observable;
}
/**
* @param {?} resolver
* @return {?}
*/
function handleObservable(resolver) {
return (...args) => {
/** @type {?} */
let result;
try {
result = resolver(...args);
}
catch (e) {
return Promise.reject(e);
}
return result instanceof Promise || isObservable(result)
? from(result).toPromise()
: Promise.resolve(result);
};
}
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,missingReturn,uselessCode} checked by tsc
*/
class LoonaRootModule {
/**
* @param {?} effects
* @param {?} states
* @param {?} loona
* @param {?} manager
* @param {?} runner
* @param {?} injector
*/
constructor(effects, states, loona, manager, runner, injector) {
this.effects = effects;
runner.start();
const { names, add } = mapStates();
states.forEach(state => {
const { instance, meta } = extractState(state, injector);
manager.addState(instance, meta, handleObservable);
this.addEffects(instance, meta.effects);
add(instance);
});
loona.dispatch({
type: ROOT_EFFECTS_INIT,
states: names,
});
}
/**
* @param {?} state
* @param {?=} meta
* @return {?}
*/
addEffects(state, meta) {
this.effects.addEffects(state, meta);
}
}
LoonaRootModule.decorators = [
{ type: NgModule }
];
/** @nocollapse */
LoonaRootModule.ctorParameters = () => [
{ type: Effects },
{ type: Array, decorators: [{ type: Inject, args: [INITIAL_STATE,] }] },
{ type: Loona },
{ type: Manager },
{ type: EffectsRunner },
{ type: Injector }
];
class LoonaChildModule {
/**
* @param {?} states
* @param {?} injector
* @param {?} manager
* @param {?} loona
* @param {?} rootModule
*/
constructor(states, injector, manager, loona, rootModule) {
const { names, add } = mapStates();
states.forEach(state => {
const { instance, meta } = extractState(state, injector);
manager.addState(instance, meta, handleObservable);
rootModule.addEffects(instance, meta.effects);
add(instance);
});
loona.dispatch({
type: UPDATE_EFFECTS,
states: names,
});
}
}
LoonaChildModule.decorators = [
{ type: NgModule }
];
/** @nocollapse */
LoonaChildModule.ctorParameters = () => [
{ type: Array, decorators: [{ type: Inject, args: [CHILD_STATE,] }] },
{ type: Injector },
{ type: Manager },
{ type: Loona },
{ type: LoonaRootModule }
];
class LoonaModule {
/**
* @param {?=} states
* @return {?}
*/
static forRoot(states = []) {
return {
ngModule: LoonaRootModule,
providers: [
Loona,
InnerActions,
ScannedActions,
{
provide: Actions,
useExisting: ScannedActions,
},
...states,
{ provide: INITIAL_STATE, useValue: states },
{
provide: Manager,
useFactory: managerFactory,
deps: [LOONA_CACHE, Injector],
},
{
provide: LoonaLink,
useFactory: linkFactory,
deps: [Manager],
},
Effects,
EffectsRunner,
],
};
}
/**
* @param {?=} states
* @return {?}
*/
static forChild(states = []) {
return {
ngModule: LoonaChildModule,
providers: [...states, { provide: CHILD_STATE, useValue: states }],
};
}
}
LoonaModule.decorators = [
{ type: NgModule }
];
/**
* @param {?} manager
* @return {?}
*/
function linkFactory(manager) {
return new LoonaLink(manager);
}
/**
* @param {?} cache
* @param {?} injector
* @return {?}
*/
function managerFactory(cache, injector) {
/** @type {?} */
const manager = new Manager({
cache,
getClient: () => injector.get(Apollo).getClient(),
});
return manager;
}
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,missingReturn,uselessCode} checked by tsc
*/
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,missingReturn,uselessCode} checked by tsc
*/
export { Actions, Loona, LoonaModule, INITIAL_STATE, CHILD_STATE, LOONA_CACHE, INIT, UPDATE_EFFECTS, ROOT_EFFECTS_INIT, InnerActions as ɵb, ScannedActions as ɵa, Effects as ɵg, EffectsRunner as ɵh, LoonaChildModule as ɵd, LoonaRootModule as ɵc, linkFactory as ɵe, managerFactory as ɵf };
//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"loona.angular.js.map","sources":["ng://@loona/angular/tokens.ts","ng://@loona/angular/actions.ts","ng://@loona/angular/client.ts","ng://@loona/angular/effects.ts","ng://@loona/angular/utils.ts","ng://@loona/angular/module.ts"],"sourcesContent":["import {InjectionToken} from '@angular/core';\nimport {ApolloCache} from 'apollo-cache';\nimport {StateClass, Metadata} from '@loona/core';\n\nexport const INITIAL_STATE = new InjectionToken<StateClass<Metadata>>(\n  'Loona/State',\n);\nexport const CHILD_STATE = new InjectionToken<StateClass<Metadata>>(\n  'Loona/ChildState',\n);\nexport const LOONA_CACHE = new InjectionToken<ApolloCache<any>>('Loona/Cache');\n\nexport const INIT = '@@init';\nexport const ROOT_EFFECTS_INIT = '@@effects/init';\nexport const UPDATE_EFFECTS = '@@effects/update';\n","import {Injectable, OnDestroy} from '@angular/core';\nimport {Observable, BehaviorSubject, Subject} from 'rxjs';\nimport {Action} from '@loona/core';\n\nimport {INIT} from './tokens';\n\nexport class Actions<V = Action> extends Observable<V> {}\n\n@Injectable()\nexport class ScannedActions extends Subject<Action> implements OnDestroy {\n  ngOnDestroy() {\n    this.complete();\n  }\n}\n\n@Injectable()\nexport class InnerActions extends BehaviorSubject<Action> implements OnDestroy {\n  constructor() {\n    super({type: INIT});\n  }\n\n  next(action: Action) {\n    if (typeof action === 'undefined') {\n      throw new TypeError(`Actions must be objects`);\n    } else if (typeof action.type === 'undefined') {\n      throw new TypeError(`Actions must have a type property`);\n    }\n\n    super.next(action);\n  }\n\n  complete() {}\n\n  ngOnDestroy() {\n    super.complete();\n  }\n}\n","import {Injectable, ErrorHandler} from '@angular/core';\nimport {Apollo, QueryRef} from 'apollo-angular';\nimport {\n  WatchQueryOptions,\n  MutationOptions as CoreMutationOptions,\n} from 'apollo-client';\nimport {FetchResult} from 'apollo-link';\nimport {Observable, Subject, queueScheduler, merge, throwError} from 'rxjs';\nimport {observeOn, tap, catchError} from 'rxjs/operators';\nimport {DocumentNode} from 'graphql';\nimport {\n  isMutation,\n  getMutation,\n  Action,\n  isDocument,\n  Manager,\n  withUpdates,\n  getActionType,\n  buildActionFromResult,\n  buildActionFromError,\n} from '@loona/core';\n\nimport {InnerActions, ScannedActions} from './actions';\n\nexport type Omit<T, K extends keyof T> = Pick<T, Exclude<keyof T, K>>;\n\nexport interface QueryOptions\n  extends Omit<WatchQueryOptions, 'query' | 'variables'> {}\n\nexport interface MutationOptions\n  extends Omit<CoreMutationOptions, 'mutation' | 'variables'> {}\n\nexport type R = Record<string, any>;\n\nexport interface TypedVariables<V> {\n  variables?: V;\n}\n\n@Injectable()\nexport class Loona {\n  private queue$: Observable<Action>;\n  private direct$ = new Subject<Action>();\n\n  constructor(\n    private apollo: Apollo,\n    private manager: Manager,\n    private actions: InnerActions,\n    scannedActions: ScannedActions,\n    errorHandler: ErrorHandler,\n  ) {\n    this.queue$ = merge(actions, this.direct$).pipe(observeOn(queueScheduler));\n    this.queue$.subscribe({\n      next: action => {\n        scannedActions.next(action);\n      },\n      error: error => {\n        errorHandler.handleError(error);\n      },\n    });\n  }\n\n  query<T, V = any>(\n    query: DocumentNode,\n    variables?: V,\n    options?: QueryOptions,\n  ): QueryRef<T, V>;\n\n  query<T, V = any>(\n    options: WatchQueryOptions & TypedVariables<V>,\n  ): QueryRef<T, V>;\n\n  query<T, V = any>(\n    queryOrOptions: DocumentNode | (WatchQueryOptions & TypedVariables<V>),\n    variables?: V,\n    options?: QueryOptions,\n  ): QueryRef<T, V> {\n    return this.apollo.watchQuery<T, V>(\n      isDocument(queryOrOptions)\n        ? {\n            query: queryOrOptions,\n            variables,\n            ...options,\n          }\n        : queryOrOptions,\n    );\n  }\n\n  mutate<T, V = R>(\n    mutation: DocumentNode,\n    variables?: V,\n    options?: MutationOptions,\n  ): Observable<FetchResult<T>>;\n\n  mutate<T, V = R>(\n    options: CoreMutationOptions<T, V>,\n  ): Observable<FetchResult<T>>;\n\n  mutate<T, V = R>(\n    mutationOrOptions: DocumentNode | CoreMutationOptions<T, V>,\n    variables?: V,\n    options?: MutationOptions,\n  ): Observable<FetchResult<T>> {\n    const config = isDocument(mutationOrOptions)\n      ? {\n          mutation: mutationOrOptions,\n          variables,\n          ...options,\n        }\n      : mutationOrOptions;\n\n    return this.apollo\n      .mutate<T, V>(withUpdates<T, V>(config, this.manager))\n      .pipe(\n        tap(result => {\n          this.direct$.next(buildActionFromResult(config, result));\n        }),\n        catchError(error => {\n          this.direct$.next(buildActionFromError(config, error));\n          return throwError(error);\n        }),\n      );\n  }\n\n  dispatch(action: any): void {\n    if (isMutation(action)) {\n      const mutation = getMutation(action);\n\n      this.mutate({\n        mutation,\n        ...action,\n      }).subscribe();\n    } else {\n      this.actions.next({\n        type: getActionType(action),\n        ...action,\n      });\n    }\n  }\n\n  extract<T = any>(): T {\n    return this.apollo.getClient().extract();\n  }\n\n  reset(): void {\n    this.apollo.getClient().resetStore();\n  }\n\n  restore(state: any): void {\n    this.apollo.getClient().restore(state);\n  }\n}\n","import {\n  buildContext,\n  getNameOfMutation,\n  isMutationAsAction,\n  Metadata,\n  EffectMethod,\n  Action,\n  EffectContext,\n  StateClass,\n  METADATA_KEY,\n  buildGetCacheKey,\n} from '@loona/core';\nimport {Injectable, Inject, OnDestroy, Injector} from '@angular/core';\nimport {ApolloCache} from 'apollo-cache';\nimport {Apollo} from 'apollo-angular';\nimport {Subscription} from 'rxjs';\n\nimport {Loona} from './client';\nimport {LOONA_CACHE} from './tokens';\nimport {ScannedActions} from './actions';\n\n@Injectable()\nexport class Effects {\n  effects: Record<string, Array<EffectMethod>> = {};\n  getContext: () => EffectContext;\n\n  constructor(\n    loona: Loona,\n    apollo: Apollo,\n    @Inject(LOONA_CACHE) cache: ApolloCache<any>,\n  ) {\n    this.getContext = () => ({\n      ...buildContext(\n        {\n          cache,\n          getCacheKey: buildGetCacheKey(cache),\n        },\n        apollo.getClient(),\n      ),\n      dispatch: loona.dispatch.bind(loona),\n    });\n  }\n\n  addEffects(instance: any, meta?: Metadata.Effects) {\n    if (!meta) {\n      return;\n    }\n\n    for (const type in meta) {\n      if (!this.effects[type]) {\n        this.effects[type] = [];\n      }\n\n      meta[type].forEach(({propName}) => {\n        this.effects[type].push(instance[propName].bind(instance));\n      });\n    }\n  }\n\n  runEffects(action: Action) {\n    let type = action.type;\n\n    if (isMutationAsAction(action)) {\n      type = getNameOfMutation(action.options.mutation);\n    }\n\n    const effectsToRun = this.effects[type];\n\n    if (effectsToRun) {\n      effectsToRun.forEach(effect => {\n        effect(action, this.getContext());\n      });\n    }\n  }\n}\n\n@Injectable()\nexport class EffectsRunner implements OnDestroy {\n  private actionsSubscription: Subscription | null = null;\n\n  constructor(\n    private effects: Effects,\n    private scannedActions: ScannedActions,\n  ) {}\n\n  start() {\n    if (!this.actionsSubscription) {\n      this.actionsSubscription = this.scannedActions.subscribe(action => {\n        this.effects.runEffects(action);\n      });\n    }\n  }\n\n  ngOnDestroy() {\n    if (this.actionsSubscription) {\n      this.actionsSubscription.unsubscribe();\n      this.actionsSubscription = null;\n    }\n  }\n}\n\nexport function mapStates() {\n  const names: string[] = [];\n  const add = (state: any) => {\n    names.push(state.constructor && state.constructor.name);\n  };\n\n  return {names, add};\n}\n\nexport function extractState(\n  state: StateClass<Metadata>,\n  injector: Injector,\n): {\n  instance: any;\n  meta: Metadata;\n} {\n  return {\n    instance: injector.get(state),\n    meta: state[METADATA_KEY],\n  };\n}\n","import {Observable, from} from 'rxjs';\n\nexport function isObservable<T = any>(val: any): val is Observable<T> {\n  return val instanceof Observable;\n}\n\nexport function handleObservable(resolver: any) {\n  return (...args: any[]) => {\n    let result: any;\n\n    try {\n      result = resolver(...args);\n    } catch (e) {\n      return Promise.reject(e);\n    }\n\n    return result instanceof Promise || isObservable(result)\n      ? from(result).toPromise()\n      : Promise.resolve(result);\n  };\n}\n","import {NgModule, ModuleWithProviders, Injector, Inject} from '@angular/core';\nimport {ApolloCache} from 'apollo-cache';\nimport {Apollo} from 'apollo-angular';\nimport {Manager, LoonaLink, StateClass, Metadata} from '@loona/core';\n\nimport {Loona} from './client';\nimport {InnerActions, ScannedActions, Actions} from './actions';\nimport {EffectsRunner, Effects, mapStates, extractState} from './effects';\nimport {\n  INITIAL_STATE,\n  CHILD_STATE,\n  LOONA_CACHE,\n  ROOT_EFFECTS_INIT,\n  UPDATE_EFFECTS,\n} from './tokens';\nimport {handleObservable} from './utils';\n\n@NgModule()\nexport class LoonaRootModule {\n  constructor(\n    private effects: Effects,\n    @Inject(INITIAL_STATE) states: StateClass<Metadata>[],\n    loona: Loona,\n    manager: Manager,\n    runner: EffectsRunner,\n    injector: Injector,\n  ) {\n    runner.start();\n\n    const {names, add} = mapStates();\n\n    states.forEach(state => {\n      const {instance, meta} = extractState(state, injector);\n\n      manager.addState(instance, meta, handleObservable);\n      this.addEffects(instance, meta.effects);\n      add(instance);\n    });\n\n    loona.dispatch({\n      type: ROOT_EFFECTS_INIT,\n      states: names,\n    });\n  }\n\n  addEffects(state: any, meta?: Metadata.Effects) {\n    this.effects.addEffects(state, meta);\n  }\n}\n\n@NgModule()\nexport class LoonaChildModule {\n  constructor(\n    @Inject(CHILD_STATE) states: StateClass<Metadata>[],\n    injector: Injector,\n    manager: Manager,\n    loona: Loona,\n    rootModule: LoonaRootModule,\n  ) {\n    const {names, add} = mapStates();\n\n    states.forEach(state => {\n      const {instance, meta} = extractState(state, injector);\n\n      manager.addState(instance, meta, handleObservable);\n      rootModule.addEffects(instance, meta.effects);\n      add(instance);\n    });\n\n    loona.dispatch({\n      type: UPDATE_EFFECTS,\n      states: names,\n    });\n  }\n}\n\n@NgModule()\nexport class LoonaModule {\n  static forRoot(states: any[] = []): ModuleWithProviders {\n    return {\n      ngModule: LoonaRootModule,\n      providers: [\n        Loona,\n        InnerActions,\n        ScannedActions,\n        {\n          provide: Actions,\n          useExisting: ScannedActions,\n        },\n        ...states,\n        {provide: INITIAL_STATE, useValue: states},\n        {\n          provide: Manager,\n          useFactory: managerFactory,\n          deps: [LOONA_CACHE, Injector],\n        },\n        {\n          provide: LoonaLink,\n          useFactory: linkFactory,\n          deps: [Manager],\n        },\n        Effects,\n        EffectsRunner,\n      ],\n    };\n  }\n\n  static forChild(states: any[] = []): ModuleWithProviders {\n    return {\n      ngModule: LoonaChildModule,\n      providers: [...states, {provide: CHILD_STATE, useValue: states}],\n    };\n  }\n}\n\nexport function linkFactory(manager: Manager): LoonaLink {\n  return new LoonaLink(manager);\n}\n\nexport function managerFactory(\n  cache: ApolloCache<any>,\n  injector: Injector,\n): Manager {\n  const manager = new Manager({\n    cache,\n    getClient: () => injector.get(Apollo).getClient(),\n  });\n\n  return manager;\n}\n"],"names":[],"mappings":"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"}