closeActionMode() {
   const mode = this.getActionMode();
   if (mode === ActionMode.None) {
     return;
   }
   if (mode === ActionMode.Selection) {
     if (this.queryStore(getActionModeSelections).length) {
       // TODO: move this logic out into a component (it's confusing)
       this.store.dispatch(new SetActionModeSelections([]));
     } else {
       this.store.dispatch(new SetActionMode(ActionMode.None));
     }
   } else {
     this.store.dispatch(new SetActionMode(ActionMode.Selection));
   }
 }

 private queryStore<T>(selector: OutputSelector<Object, T, (res: Object) => T>) {
   let obj: T;
   this.store
     .select(selector)
     .pipe(first())
     .subscribe(o => (obj = o));
   return obj;
 }

 private onSuccess(
   importType: ImportType,
   resetWorkspace: boolean,
   vls: ReadonlyArray<VectorLayer>,
   animation?: Animation,
   hiddenLayerIds?: ReadonlySet<string>,
 ) {
   if (importType === ImportType.Json) {
     ga('send', 'event', 'Import', 'JSON');
     this.store.dispatch(new ResetWorkspace(vls[0], animation, hiddenLayerIds));
   } else {
     if (importType === ImportType.Svg) {
       ga('send', 'event', 'Import', 'SVG');
     } else if (importType === ImportType.VectorDrawable) {
       ga('send', 'event', 'Import', 'Vector Drawable');
     }
     if (resetWorkspace) {
       this.store.dispatch(new ResetWorkspace());
     }
     this.layerTimelineService.importLayers(vls);
     // TODO: count number of individual layers?
     this.snackBarService.show(
       `Imported ${vls.length} layer${vls.length === 1 ? '' : 's'}`,
       'Dismiss',
       Duration.Short,
     );
   }
 }

 toggleSubPathSelection(source: ActionSource, subIdx: number) {
   const selections = [...this.getSelections()];
   _.remove(selections, s => s.type !== SelectionType.SubPath || s.source !== source);
   const type = SelectionType.SubPath;
   const toggledSelections = this.toggleSelections(selections, [{ type, source, subIdx }]);
   this.store.dispatch(new SetActionModeSelections(toggledSelections));
 }

 /**
  * Replaces an existing layer in the tree with a new layer. Note that
  * this method assumes that both layers still have the same children layers.
  */
 swapLayers(layerId: string, newLayer: Layer) {
   if (layerId === newLayer.id) {
     this.updateLayer(newLayer);
     return;
   }
   const vl = this.getVectorLayer();
   const parent = LayerUtil.findParent(vl, layerId).clone();
   const layerIndex = _.findIndex(parent.children, l => l.id === layerId);
   const children = [...parent.children];
   children.splice(layerIndex, 1, newLayer);
   parent.children = children;
   const actions: Action[] = [
     new SetVectorLayer(LayerUtil.updateLayer(vl, parent)),
     ...this.buildCleanupLayerIdActions(layerId),
   ];
   const animation = this.getAnimation();
   const oldLayerBlocks = animation.blocks.filter(b => b.layerId === layerId);
   const newAnimatableProperties = new Set(newLayer.animatableProperties.keys());
   // Preserve any blocks that are still animatable with the new layer.
   const newLayerBlocks = oldLayerBlocks
     .filter(b => newAnimatableProperties.has(b.propertyName))
     .map(b => {
       b = b.clone();
       b.layerId = newLayer.id;
       return b;
     });
   const newAnimation = animation.clone();
   newAnimation.blocks = [
     ...animation.blocks.filter(b => b.layerId !== layerId),
     ...newLayerBlocks,
   ];
   actions.push(new SetAnimation(newAnimation));
   this.store.dispatch(new BatchAction(...actions));
 }

 shiftPointToFront() {
   const selections = this.getSelections().filter(s => s.type === SelectionType.Point);
   const { source, subIdx, cmdIdx } = selections[0];
   const activePath = this.getActivePathBlockValue(source);
   const pm = activePath.mutate();
   pm.shiftSubPathForward(subIdx, cmdIdx);
   this.store.dispatch(this.buildUpdatedActivePathBlockAnimationAction(source, pm.build()));
 }

 private get vectorLayer() {
   let vectorLayer: VectorLayer;
   this.store
     .select(getVectorLayer)
     .pipe(first())
     .subscribe(vl => (vectorLayer = vl));
   return vectorLayer;
 }

 private getHiddenLayerIds() {
   let hiddenLayerIds: ReadonlySet<string>;
   this.store
     .select(getHiddenLayerIds)
     .pipe(first())
     .subscribe(ids => (hiddenLayerIds = ids));
   return hiddenLayerIds;
 }

 getThemeType() {
   let result: { themeType: ThemeType; isInitialPageLoad: boolean };
   this.store
     .select(getThemeType)
     .pipe(first())
     .subscribe(res => (result = res));
   return result;
 }

 private getAnimation() {
   let animation: Animation;
   this.store
     .select(getAnimation)
     .pipe(first())
     .subscribe(anim => (animation = anim));
   return animation;
 }