@igo2/geo 1.15.4 → 16.0.0-rc.1

package/esm2022/lib/feature/shared/strategies/in-map-resolution.mjs

@@ -0,0 +1,96 @@
+import { EntityStoreStrategy } from '@igo2/common';
+/**
+ * This strategy maintain the store features updated while the map is scrolled.
+ * The features's state inside the map's resolution are tagged inMapResolution = true;
+ */
+export class FeatureStoreInMapResolutionStrategy extends EntityStoreStrategy {
+    options;
+    /**
+     * Subscription to the store's OL source changes
+     */
+    stores$$ = new Map();
+    resolution$$ = [];
+    empty$$;
+    constructor(options) {
+        super(options);
+        this.options = options;
+    }
+    /**
+     * Bind this strategy to a store and start watching for Ol source changes
+     * @param store Feature store
+     */
+    bindStore(store) {
+        super.bindStore(store);
+        if (this.active === true) {
+            this.watchStore(store);
+        }
+        this.empty$$ = store.empty$.subscribe(() => this.updateEntitiesInResolution(store, store.layer.map.viewController.getResolution()));
+    }
+    /**
+     * Unbind this strategy from a store and stop watching for Ol source changes
+     * @param store Feature store
+     */
+    unbindStore(store) {
+        super.unbindStore(store);
+        if (this.active === true) {
+            this.unwatchStore(store);
+        }
+    }
+    /**
+     * Start watching all stores already bound to that strategy at once.
+     * @internal
+     */
+    doActivate() {
+        this.stores.forEach((store) => this.watchStore(store));
+    }
+    /**
+     * Stop watching all stores bound to that strategy
+     * @internal
+     */
+    doDeactivate() {
+        this.unwatchAll();
+    }
+    /**
+     * Watch for a store's  OL source changes
+     * @param store Feature store
+     */
+    watchStore(store) {
+        if (this.stores$$.has(store)) {
+            return;
+        }
+        this.updateEntitiesInResolution(store, store.layer.map.viewController.getResolution());
+        this.resolution$$.push(store.layer.map.viewController.resolution$.subscribe((res) => {
+            this.updateEntitiesInResolution(store, res);
+        }));
+    }
+    updateEntitiesInResolution(store, mapResolution) {
+        if (mapResolution > store.layer.minResolution &&
+            mapResolution < store.layer.maxResolution) {
+            store.state.updateAll({ inMapResolution: true });
+        }
+        else {
+            store.state.updateAll({ inMapResolution: false });
+        }
+    }
+    /**
+     * Stop watching for a store's OL source changes
+     * @param store Feature store
+     */
+    unwatchStore(store) {
+        const key = this.stores$$.get(store);
+        if (key !== undefined) {
+            this.stores$$.delete(store);
+        }
+    }
+    /**
+     * Stop watching for OL source changes in all stores.
+     */
+    unwatchAll() {
+        this.stores$$.clear();
+        this.resolution$$.map((state) => state.unsubscribe());
+        if (this.empty$$) {
+            this.empty$$.unsubscribe();
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/feature/shared/strategies/index.mjs

@@ -0,0 +1,8 @@
+export * from './in-map-extent';
+export * from './in-map-resolution';
+export * from './geo-properties';
+export * from './loading';
+export * from './loading-layer';
+export * from './selection';
+export * from './search';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9nZW8vc3JjL2xpYi9mZWF0dXJlL3NoYXJlZC9zdHJhdGVnaWVzL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsaUJBQWlCLENBQUM7QUFDaEMsY0FBYyxxQkFBcUIsQ0FBQztBQUNwQyxjQUFjLGtCQUFrQixDQUFDO0FBQ2pDLGNBQWMsV0FBVyxDQUFDO0FBQzFCLGNBQWMsaUJBQWlCLENBQUM7QUFDaEMsY0FBYyxhQUFhLENBQUM7QUFDNUIsY0FBYyxVQUFVLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL2luLW1hcC1leHRlbnQnO1xuZXhwb3J0ICogZnJvbSAnLi9pbi1tYXAtcmVzb2x1dGlvbic7XG5leHBvcnQgKiBmcm9tICcuL2dlby1wcm9wZXJ0aWVzJztcbmV4cG9ydCAqIGZyb20gJy4vbG9hZGluZyc7XG5leHBvcnQgKiBmcm9tICcuL2xvYWRpbmctbGF5ZXInO1xuZXhwb3J0ICogZnJvbSAnLi9zZWxlY3Rpb24nO1xuZXhwb3J0ICogZnJvbSAnLi9zZWFyY2gnO1xuIl19

package/esm2022/lib/feature/shared/strategies/loading-layer.mjs

@@ -0,0 +1,104 @@
+import { EntityStoreStrategy } from '@igo2/common';
+import { ClusterDataSource } from '../../../datasource/shared/datasources/cluster-datasource';
+/**
+ * This strategy loads a layer's features into it's store counterpart.
+ * The layer -> store binding is a one-way binding. That means any OL feature
+ * added to the layer will be added to the store but the opposite is false.
+ *
+ * Important: In it's current state, this strategy is to meant to be combined
+ * with a standard Loading strategy and it would probably cause recursion issues.
+ */
+export class FeatureStoreLoadingLayerStrategy extends EntityStoreStrategy {
+    options;
+    /**
+     * Subscription to the store's OL source changes
+     */
+    stores$$ = new Map();
+    constructor(options) {
+        super(options);
+        this.options = options;
+    }
+    /**
+     * Bind this strategy to a store and start watching for Ol source changes
+     * @param store Feature store
+     */
+    bindStore(store) {
+        super.bindStore(store);
+        if (this.active === true) {
+            this.watchStore(store);
+        }
+    }
+    /**
+     * Unbind this strategy from a store and stop watching for Ol source changes
+     * @param store Feature store
+     */
+    unbindStore(store) {
+        super.unbindStore(store);
+        if (this.active === true) {
+            this.unwatchStore(store);
+        }
+    }
+    /**
+     * Start watching all stores already bound to that strategy at once.
+     * @internal
+     */
+    doActivate() {
+        this.stores.forEach((store) => this.watchStore(store));
+    }
+    /**
+     * Stop watching all stores bound to that strategy
+     * @internal
+     */
+    doDeactivate() {
+        this.unwatchAll();
+    }
+    /**
+     * Watch for a store's  OL source changes
+     * @param store Feature store
+     */
+    watchStore(store) {
+        if (this.stores$$.has(store)) {
+            return;
+        }
+        this.onSourceChanges(store);
+        const olSource = store.layer.ol.getSource();
+        olSource.on('change', (event) => {
+            this.onSourceChanges(store);
+        });
+    }
+    /**
+     * Stop watching for a store's OL source changes
+     * @param store Feature store
+     */
+    unwatchStore(store) {
+        const key = this.stores$$.get(store);
+        if (key !== undefined) {
+            this.stores$$.delete(store);
+        }
+    }
+    /**
+     * Stop watching for OL source changes in all stores.
+     */
+    unwatchAll() {
+        Array.from(this.stores$$.entries()).forEach((entries) => { });
+        this.stores$$.clear();
+    }
+    /**
+     * Load features from an OL source into a  store or clear the store if the source is empty
+     * @param features Store filtered features
+     * @param store Feature store
+     */
+    onSourceChanges(store) {
+        let olFeatures = store.layer.ol.getSource().getFeatures();
+        if (store.layer.dataSource instanceof ClusterDataSource) {
+            olFeatures = olFeatures.flatMap((cluster) => cluster.get('features'));
+        }
+        if (olFeatures.length === 0) {
+            store.clear();
+        }
+        else {
+            store.setStoreOlFeatures(olFeatures);
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/feature/shared/strategies/loading.mjs

@@ -0,0 +1,136 @@
+import { EntityStoreStrategy } from '@igo2/common';
+import { FeatureMotion } from '../feature.enums';
+/**
+ * This strategy loads a store's features into it's layer counterpart.
+ * The store -> layer binding is a one-way binding. That means any entity
+ * added to the store will be added to the layer but the opposite is false.
+ *
+ * Important: This strategy observes filtered entities, not raw entities. This
+ * is not configurable yet.
+ */
+export class FeatureStoreLoadingStrategy extends EntityStoreStrategy {
+    options;
+    /**
+     * Subscription to the store's features
+     */
+    stores$$ = new Map();
+    motion;
+    constructor(options) {
+        super(options);
+        this.options = options;
+        this.setMotion(options.motion);
+    }
+    /**
+     * Bind this strategy to a store and start watching for entities changes
+     * @param store Feature store
+     */
+    bindStore(store) {
+        super.bindStore(store);
+        if (this.active === true) {
+            this.watchStore(store);
+        }
+    }
+    /**
+     * Unbind this strategy from a store and stop watching for entities changes
+     * @param store Feature store
+     */
+    unbindStore(store) {
+        super.unbindStore(store);
+        if (this.active === true) {
+            this.unwatchStore(store);
+        }
+    }
+    /**
+     * Define the motion to apply on load
+     * @param motion Feature motion
+     */
+    setMotion(motion) {
+        this.motion = motion;
+    }
+    /**
+     * Start watching all stores already bound to that strategy at once.
+     * @internal
+     */
+    doActivate() {
+        this.stores.forEach((store) => this.watchStore(store));
+    }
+    /**
+     * Stop watching all stores bound to that strategy
+     * @internal
+     */
+    doDeactivate() {
+        this.unwatchAll();
+    }
+    /**
+     * Watch for entities changes in a store.
+     * Important: Never observe a store's sorted entities. It makes no sense
+     * to display sorted entities (instead of unsorted) on a layer and it
+     * would potentially result in a lot of useless computation.
+     * @param store Feature store
+     */
+    watchStore(store) {
+        if (this.stores$$.has(store)) {
+            return;
+        }
+        const subscription = store.view
+            .all$()
+            .subscribe((features) => this.onFeaturesChange(features, store));
+        this.stores$$.set(store, subscription);
+    }
+    /**
+     * Stop watching for entities changes in a store.
+     * @param store Feature store
+     */
+    unwatchStore(store) {
+        const subscription = this.stores$$.get(store);
+        if (subscription !== undefined) {
+            subscription.unsubscribe();
+            this.stores$$.delete(store);
+        }
+    }
+    /**
+     * Stop watching for entities changes in all stores.
+     */
+    unwatchAll() {
+        Array.from(this.stores$$.entries()).forEach((entries) => {
+            entries[1].unsubscribe();
+        });
+        this.stores$$.clear();
+    }
+    /**
+     * Load features into a layer or clear the layer if the array of features is empty.
+     * @param features Store filtered features
+     * @param store Feature store
+     */
+    onFeaturesChange(features, store) {
+        if (features.length === 0) {
+            store.clearLayer();
+        }
+        else {
+            store.setLayerFeatures(features, this.selectMotion(store), this.options.viewScale, this.options.areaRatio, this.options.getFeatureId);
+        }
+    }
+    /**
+     * Selects the best motion
+     * @param store A FeatureStore to apply the motion
+     * @returns The motion selected
+     */
+    selectMotion(store) {
+        if (this.motion !== undefined) {
+            return this.motion;
+        }
+        if (store.pristine === true) {
+            // If features have just been loaded into the store, move/zoom on them
+            return FeatureMotion.Default;
+        }
+        else if (store.count > store.view.count) {
+            // If features have been filtered, move/zoom on the remaining ones
+            return FeatureMotion.Default;
+        }
+        else {
+            // On insert, update or delete, do nothing
+            return FeatureMotion.None;
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"loading.js","sourceRoot":"","sources":["../../../../../../../packages/geo/src/lib/feature/shared/strategies/loading.ts"],"names":[],"mappings":"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","sourcesContent":["import { Subscription } from 'rxjs';\n\nimport { EntityStoreStrategy } from '@igo2/common';\n\nimport { FeatureMotion } from '../feature.enums';\nimport {\n  Feature,\n  FeatureStoreLoadingStrategyOptions\n} from '../feature.interfaces';\nimport { FeatureStore } from '../store';\n\n/**\n * This strategy loads a store's features into it's layer counterpart.\n * The store -> layer binding is a one-way binding. That means any entity\n * added to the store will be added to the layer but the opposite is false.\n *\n * Important: This strategy observes filtered entities, not raw entities. This\n * is not configurable yet.\n */\nexport class FeatureStoreLoadingStrategy extends EntityStoreStrategy {\n  /**\n   * Subscription to the store's features\n   */\n  private stores$$ = new Map<FeatureStore, Subscription>();\n\n  private motion: FeatureMotion;\n\n  constructor(protected options: FeatureStoreLoadingStrategyOptions) {\n    super(options);\n    this.setMotion(options.motion);\n  }\n\n  /**\n   * Bind this strategy to a store and start watching for entities changes\n   * @param store Feature store\n   */\n  bindStore(store: FeatureStore) {\n    super.bindStore(store);\n    if (this.active === true) {\n      this.watchStore(store);\n    }\n  }\n\n  /**\n   * Unbind this strategy from a store and stop watching for entities changes\n   * @param store Feature store\n   */\n  unbindStore(store: FeatureStore) {\n    super.unbindStore(store);\n    if (this.active === true) {\n      this.unwatchStore(store);\n    }\n  }\n\n  /**\n   * Define the motion to apply on load\n   * @param motion Feature motion\n   */\n  setMotion(motion: FeatureMotion) {\n    this.motion = motion;\n  }\n\n  /**\n   * Start watching all stores already bound to that strategy at once.\n   * @internal\n   */\n  protected doActivate() {\n    this.stores.forEach((store: FeatureStore) => this.watchStore(store));\n  }\n\n  /**\n   * Stop watching all stores bound to that strategy\n   * @internal\n   */\n  protected doDeactivate() {\n    this.unwatchAll();\n  }\n\n  /**\n   * Watch for entities changes in a store.\n   * Important: Never observe a store's sorted entities. It makes no sense\n   * to display sorted entities (instead of unsorted) on a layer and it\n   * would potentially result in a lot of useless computation.\n   * @param store Feature store\n   */\n  private watchStore(store: FeatureStore) {\n    if (this.stores$$.has(store)) {\n      return;\n    }\n\n    const subscription = store.view\n      .all$()\n      .subscribe((features: Feature[]) =>\n        this.onFeaturesChange(features, store)\n      );\n    this.stores$$.set(store, subscription);\n  }\n\n  /**\n   * Stop watching for entities changes in a store.\n   * @param store Feature store\n   */\n  private unwatchStore(store: FeatureStore) {\n    const subscription = this.stores$$.get(store);\n    if (subscription !== undefined) {\n      subscription.unsubscribe();\n      this.stores$$.delete(store);\n    }\n  }\n\n  /**\n   * Stop watching for entities changes in all stores.\n   */\n  private unwatchAll() {\n    Array.from(this.stores$$.entries()).forEach(\n      (entries: [FeatureStore, Subscription]) => {\n        entries[1].unsubscribe();\n      }\n    );\n    this.stores$$.clear();\n  }\n\n  /**\n   * Load features into a layer or clear the layer if the array of features is empty.\n   * @param features Store filtered features\n   * @param store Feature store\n   */\n  private onFeaturesChange(features: Feature[], store: FeatureStore) {\n    if (features.length === 0) {\n      store.clearLayer();\n    } else {\n      store.setLayerFeatures(\n        features,\n        this.selectMotion(store),\n        this.options.viewScale,\n        this.options.areaRatio,\n        this.options.getFeatureId\n      );\n    }\n  }\n\n  /**\n   * Selects the best motion\n   * @param store A FeatureStore to apply the motion\n   * @returns The motion selected\n   */\n  private selectMotion(store: FeatureStore) {\n    if (this.motion !== undefined) {\n      return this.motion;\n    }\n\n    if (store.pristine === true) {\n      // If features have just been loaded into the store, move/zoom on them\n      return FeatureMotion.Default;\n    } else if (store.count > store.view.count) {\n      // If features have been filtered, move/zoom on the remaining ones\n      return FeatureMotion.Default;\n    } else {\n      // On insert, update or delete, do nothing\n      return FeatureMotion.None;\n    }\n  }\n}\n"]}

package/esm2022/lib/feature/shared/strategies/search.mjs

@@ -0,0 +1,159 @@
+import { Document } from 'flexsearch';
+import { EntityStoreStrategy } from '@igo2/common';
+import { skipWhile } from 'rxjs/operators';
+/**
+ *
+ * This strategy loads a layer's features's properties into a searchable index.
+ */
+export class FeatureStoreSearchIndexStrategy extends EntityStoreStrategy {
+    options;
+    /**
+     * Subscription to the store's OL source changes
+     */
+    stores$$ = new Map();
+    constructor(options) {
+        super(options);
+        this.options = options;
+    }
+    /**
+     * Bind this strategy to a store and start watching for entities changes
+     * @param store Feature store
+     */
+    bindStore(store) {
+        super.bindStore(store);
+        if (this.active === true) {
+            this.watchStore(store);
+        }
+    }
+    /**
+     * Unbind this strategy from a store and stop watching for entities changes
+     * @param store Feature store
+     */
+    unbindStore(store) {
+        super.unbindStore(store);
+        if (this.active === true) {
+            this.unwatchStore(store);
+        }
+    }
+    /**
+     * Start watching all stores already bound to that strategy at once.
+     * @internal
+     */
+    doActivate() {
+        this.stores.forEach((store) => this.watchStore(store));
+    }
+    /**
+     * Stop watching all stores bound to that strategy
+     * @internal
+     */
+    doDeactivate() {
+        this.unwatchAll();
+    }
+    initStoreSearchIndex(store) {
+        store.searchDocument = new Document({ tokenize: 'full' });
+    }
+    /**
+     * Watch for a store's entities changes
+     * @param store Feature store
+     */
+    watchStore(store) {
+        if (this.stores$$.has(store)) {
+            return;
+        }
+        this.initStoreSearchIndex(store);
+        store.entities$
+            .pipe(skipWhile((e) => !e.length))
+            .subscribe(() => this.onEntitiesChanges(store));
+    }
+    /**
+     * Stop watching for a store's entities changes
+     * @param store Feature store
+     */
+    unwatchStore(store) {
+        const key = this.stores$$.get(store);
+        if (key !== undefined) {
+            store.searchDocument = undefined;
+            this.stores$$.delete(store);
+        }
+    }
+    /**
+     * Stop watching for OL source changes in all stores.
+     */
+    unwatchAll() {
+        Array.from(this.stores$$.entries()).forEach((entries) => { });
+        this.stores$$.clear();
+    }
+    /**
+     * Maintain searcahble index for every loaded entities
+     * @param store Feature store
+     */
+    onEntitiesChanges(store) {
+        const ratio = this.options.percentDistinctValueRatio || 2;
+        const featuresProperties = [];
+        store.index.forEach((value, key) => {
+            const fp = value.properties;
+            fp.igoSearchID = key;
+            featuresProperties.push(fp);
+        });
+        const toIndex = [];
+        let columnsToNotIndex = [];
+        let contentToIndex = [];
+        if (this.options.sourceFields) {
+            columnsToNotIndex = this.options.sourceFields.filter((sf) => !sf.searchIndex?.enabled);
+            contentToIndex = this.options.sourceFields
+                .filter((sf) => sf.searchIndex?.enabled)
+                .map((sf2) => {
+                return Object.assign({}, { field: sf2.name, tokenize: 'full' }, sf2.searchIndex);
+            });
+        }
+        else {
+            if (featuresProperties.length) {
+                // THIS METHOD COMPUTE COLUMN DISTINCT VALUE TO FILTER WHICH COLUMN TO INDEX BASED ON A RATIO or discard float columns
+                const columns = Object.keys(featuresProperties[0]);
+                const columnsToIndex = [];
+                columnsToNotIndex = columns
+                    .map((column) => {
+                    const distinctValues = [
+                        ...new Set(featuresProperties.map((item) => item[column]))
+                    ];
+                    // identify column to not index based on a ratio distinctValues/nb of features OR discart exclusive float column (ex: lat, long)
+                    if ((distinctValues.length / featuresProperties.length) * 100 <=
+                        ratio ||
+                        distinctValues.every((n) => Number(n) === n && n % 1 !== 0)) {
+                        columnsToNotIndex.push(column);
+                    }
+                    else {
+                        columnsToIndex.push(column);
+                    }
+                })
+                    .filter((f) => f);
+                const keysToIndex = columnsToIndex.filter((f) => f !== 'igoSearchID');
+                contentToIndex = keysToIndex.map((key) => {
+                    return { field: key, tokenize: 'full' };
+                });
+            }
+        }
+        store.index.forEach((value, key) => {
+            const propertiesToIndex = JSON.parse(JSON.stringify(value.properties));
+            columnsToNotIndex.map((c) => delete propertiesToIndex[c]);
+            if (Object.keys(propertiesToIndex).length) {
+                toIndex.push(propertiesToIndex);
+            }
+        });
+        if (toIndex.length === 0) {
+            this.initStoreSearchIndex(store);
+        }
+        else {
+            store.searchDocument = new Document({
+                document: {
+                    id: 'igoSearchID',
+                    index: contentToIndex
+                }
+            });
+            toIndex.map((i) => {
+                store.searchDocument.add(i.igoSearchID, i);
+            });
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"search.js","sourceRoot":"","sources":["../../../../../../../packages/geo/src/lib/feature/shared/strategies/search.ts"],"names":[],"mappings":"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","sourcesContent":["import { Document, DocumentOptions } from 'flexsearch';\nimport { EntityStoreStrategy } from '@igo2/common';\nimport { FeatureStore } from '../store';\nimport { FeatureStoreSearchIndexStrategyOptions } from '../feature.interfaces';\nimport { skipWhile } from 'rxjs/operators';\n\n/**\n *\n * This strategy loads a layer's features's properties into a searchable index.\n */\nexport class FeatureStoreSearchIndexStrategy extends EntityStoreStrategy {\n  /**\n   * Subscription to the store's OL source changes\n   */\n  private stores$$ = new Map<FeatureStore, string>();\n\n  constructor(protected options: FeatureStoreSearchIndexStrategyOptions) {\n    super(options);\n  }\n\n  /**\n   * Bind this strategy to a store and start watching for entities changes\n   * @param store Feature store\n   */\n  bindStore(store: FeatureStore) {\n    super.bindStore(store);\n    if (this.active === true) {\n      this.watchStore(store);\n    }\n  }\n\n  /**\n   * Unbind this strategy from a store and stop watching for entities changes\n   * @param store Feature store\n   */\n  unbindStore(store: FeatureStore) {\n    super.unbindStore(store);\n    if (this.active === true) {\n      this.unwatchStore(store);\n    }\n  }\n\n  /**\n   * Start watching all stores already bound to that strategy at once.\n   * @internal\n   */\n  protected doActivate() {\n    this.stores.forEach((store: FeatureStore) => this.watchStore(store));\n  }\n\n  /**\n   * Stop watching all stores bound to that strategy\n   * @internal\n   */\n  protected doDeactivate() {\n    this.unwatchAll();\n  }\n\n  private initStoreSearchIndex(store) {\n    store.searchDocument = new Document({ tokenize: 'full' });\n  }\n\n  /**\n   * Watch for a store's entities changes\n   * @param store Feature store\n   */\n  private watchStore(store: FeatureStore) {\n    if (this.stores$$.has(store)) {\n      return;\n    }\n    this.initStoreSearchIndex(store);\n\n    store.entities$\n      .pipe(skipWhile((e) => !e.length))\n      .subscribe(() => this.onEntitiesChanges(store));\n  }\n\n  /**\n   * Stop watching for a store's entities changes\n   * @param store Feature store\n   */\n  private unwatchStore(store: FeatureStore) {\n    const key = this.stores$$.get(store);\n    if (key !== undefined) {\n      store.searchDocument = undefined;\n      this.stores$$.delete(store);\n    }\n  }\n\n  /**\n   * Stop watching for OL source changes in all stores.\n   */\n  private unwatchAll() {\n    Array.from(this.stores$$.entries()).forEach(\n      (entries: [FeatureStore, string]) => {}\n    );\n    this.stores$$.clear();\n  }\n\n  /**\n   * Maintain searcahble index for every loaded entities\n   * @param store Feature store\n   */\n  private onEntitiesChanges(store: FeatureStore) {\n    const ratio = this.options.percentDistinctValueRatio || 2;\n    const featuresProperties = [];\n    store.index.forEach((value, key) => {\n      const fp = value.properties;\n      fp.igoSearchID = key;\n      featuresProperties.push(fp);\n    });\n    const toIndex = [];\n    let columnsToNotIndex = [];\n    let contentToIndex = [];\n    if (this.options.sourceFields) {\n      columnsToNotIndex = this.options.sourceFields.filter(\n        (sf) => !sf.searchIndex?.enabled\n      );\n      contentToIndex = this.options.sourceFields\n        .filter((sf) => sf.searchIndex?.enabled)\n        .map((sf2) => {\n          return Object.assign(\n            {},\n            { field: sf2.name, tokenize: 'full' },\n            sf2.searchIndex\n          );\n        });\n    } else {\n      if (featuresProperties.length) {\n        // THIS METHOD COMPUTE COLUMN DISTINCT VALUE TO FILTER WHICH COLUMN TO INDEX BASED ON A RATIO or discard float columns\n        const columns = Object.keys(featuresProperties[0]);\n        const columnsToIndex = [];\n        columnsToNotIndex = columns\n          .map((column) => {\n            const distinctValues = [\n              ...new Set(featuresProperties.map((item) => item[column]))\n            ];\n            // identify column to not index based on a ratio distinctValues/nb of features OR discart exclusive float column (ex: lat, long)\n            if (\n              (distinctValues.length / featuresProperties.length) * 100 <=\n                ratio ||\n              distinctValues.every((n) => Number(n) === n && n % 1 !== 0)\n            ) {\n              columnsToNotIndex.push(column);\n            } else {\n              columnsToIndex.push(column);\n            }\n          })\n          .filter((f) => f);\n        const keysToIndex = columnsToIndex.filter((f) => f !== 'igoSearchID');\n        contentToIndex = keysToIndex.map((key) => {\n          return { field: key, tokenize: 'full' };\n        });\n      }\n    }\n    store.index.forEach((value, key) => {\n      const propertiesToIndex = JSON.parse(JSON.stringify(value.properties));\n      columnsToNotIndex.map((c) => delete propertiesToIndex[c]);\n      if (Object.keys(propertiesToIndex).length) {\n        toIndex.push(propertiesToIndex);\n      }\n    });\n\n    if (toIndex.length === 0) {\n      this.initStoreSearchIndex(store);\n    } else {\n      store.searchDocument = new Document({\n        document: {\n          id: 'igoSearchID',\n          index: contentToIndex\n        } as DocumentOptions<any>\n      });\n      toIndex.map((i) => {\n        store.searchDocument.add(i.igoSearchID, i);\n      });\n    }\n  }\n}\n"]}