AnnotationStoreProvider

Source

index.js

import CompositeClosureHelper from 'paraviewweb/src/Common/Core/CompositeClosureHelper';
import AnnotationBuilder from 'paraviewweb/src/Common/Misc/AnnotationBuilder';
import SelectionBuilder from 'paraviewweb/src/Common/Misc/SelectionBuilder';

// ----------------------------------------------------------------------------
// Annotation Store Provider
// ----------------------------------------------------------------------------

const dupNameRegex = /^(.+)\s\(([\d]+)\)$/;
const PROVIDER_NAME = 'AnnotationStoreProvider';

function annotationStoreProvider(publicAPI, model) {
  if (!model.annotationStore) {
    model.annotationStore = {};
  }

  publicAPI.loadStoredAnnotationsFromState = () => {
    if (publicAPI.isA('PersistentStateProvider')) {
      model.annotationStore = publicAPI.getPersistentState(PROVIDER_NAME);
      // The AnnotationBuilder and SelectionBuilder need to know where to start
      // their generation number count.
      let maxAnnoGen = 0;
      let maxSelGen = 0;
      Object.keys(model.annotationStore).forEach((annoId) => {
        const anno = model.annotationStore[annoId];
        if (anno.generation > maxAnnoGen) {
          maxAnnoGen = anno.generation;
        }
        if (anno.selection.generation > maxSelGen) {
          maxSelGen = anno.selection.generation;
        }
      });
      AnnotationBuilder.setInitialGenerationNumber(maxAnnoGen);
      SelectionBuilder.setInitialGenerationNumber(maxSelGen);
    }
  };

  publicAPI.getStoredAnnotationNames = () => {
    const val = Object.keys(model.annotationStore).map(
      (id) => model.annotationStore[id].name
    );
    val.sort();
    return val;
  };

  publicAPI.getNextStoredAnnotationName = (name) => {
    const allNames = publicAPI.getStoredAnnotationNames();
    let newName = name;
    if (!name || name.length === 0) {
      newName = model.defaultEmptyAnnotationName;
    }

    if (allNames.indexOf(newName) === -1) {
      return newName;
    }

    const [, base, countStr] = dupNameRegex.exec(newName) || [
      newName,
      newName,
      '0',
    ];
    let count = Number(countStr) || 0;

    while (allNames.indexOf(newName) !== -1) {
      count += 1;
      newName = `${base} (${count})`;
    }

    return newName;
  };

  publicAPI.getStoredAnnotation = (id) => model.annotationStore[id];

  publicAPI.getStoredAnnotations = () => model.annotationStore;

  publicAPI.setStoredAnnotation = (id, annotation) => {
    const changeSet = {
      id,
      annotation,
      action: 'new',
    };
    if (model.annotationStore[id]) {
      changeSet.action = 'save';
    }
    model.annotationStore[id] = annotation;
    if (publicAPI.isA('PersistentStateProvider')) {
      publicAPI.setPersistentState(PROVIDER_NAME, model.annotationStore);
    }
    publicAPI.fireStoreAnnotationChange(changeSet);
  };

  publicAPI.updateStoredAnnotations = (updates) => {
    Object.keys(updates).forEach((annoId) => {
      model.annotationStore[annoId] = updates[annoId];
    });
    if (publicAPI.isA('PersistentStateProvider')) {
      publicAPI.setPersistentState(PROVIDER_NAME, model.annotationStore);
    }
    publicAPI.fireStoreAnnotationChange({ action: 'updates' });
  };

  publicAPI.deleteStoredAnnotation = (id) => {
    const changeSet = {
      id,
      action: 'delete',
      annotation: model.annotationStore[id],
    };
    delete model.annotationStore[id];
    if (publicAPI.isA('PersistentStateProvider')) {
      publicAPI.setPersistentState(PROVIDER_NAME, model.annotationStore);
    }
    publicAPI.fireStoreAnnotationChange(changeSet);
  };
}

// ----------------------------------------------------------------------------
// Object factory
// ----------------------------------------------------------------------------

const DEFAULT_VALUES = {
  // annotationStore: null,
  defaultEmptyAnnotationName: 'Empty',
};

// ----------------------------------------------------------------------------

export function extend(publicAPI, model, initialValues = {}) {
  Object.assign(model, DEFAULT_VALUES, initialValues);

  CompositeClosureHelper.destroy(publicAPI, model);
  CompositeClosureHelper.isA(publicAPI, model, PROVIDER_NAME);
  CompositeClosureHelper.event(publicAPI, model, 'StoreAnnotationChange');
  CompositeClosureHelper.set(publicAPI, model, ['defaultEmptyAnnotationName']);
  CompositeClosureHelper.get(publicAPI, model, ['defaultEmptyAnnotationName']);

  annotationStoreProvider(publicAPI, model);
}

// ----------------------------------------------------------------------------

export const newInstance = CompositeClosureHelper.newInstance(extend);

// ----------------------------------------------------------------------------

export default { newInstance, extend };