@igo2/geo 18.0.1-next.2 → 18.0.2

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

@@ -0,0 +1,99 @@
+import { EntityStoreStrategy } from '@igo2/common/entity';
+import { debounceTime } from 'rxjs';
+/**
+ * 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$
+            .pipe(debounceTime(250))
+            .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,103 @@
+import { EntityStoreStrategy } from '@igo2/common/entity';
+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', () => {
+            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() {
+        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/entity';
+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 { EntityStoreStrategy } from '@igo2/common/entity';\n\nimport { Subscription } from 'rxjs';\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,158 @@
+import { EntityStoreStrategy } from '@igo2/common/entity';
+import { Document as FlexSearchDocument } from 'flexsearch';
+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 FlexSearchDocument({ 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() {
+        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) => {
+            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 FlexSearchDocument({
+                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 { EntityStoreStrategy } from '@igo2/common/entity';\n\nimport { DocumentOptions, Document as FlexSearchDocument } from 'flexsearch';\nimport { skipWhile } from 'rxjs/operators';\n\nimport { FeatureStoreSearchIndexStrategyOptions } from '../feature.interfaces';\nimport { FeatureStore } from '../store';\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 FlexSearchDocument({ 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    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) => {\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 FlexSearchDocument({\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"]}