@igo2/geo 1.15.4 → 16.0.0-rc.1

package/lib/feature/shared/strategies/loading.d.ts

@@ -1,75 +1,75 @@
-import { EntityStoreStrategy } from '@igo2/common';
-import { FeatureMotion } from '../feature.enums';
-import { FeatureStoreLoadingStrategyOptions } from '../feature.interfaces';
-import { FeatureStore } from '../store';
-/**
- * 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 declare class FeatureStoreLoadingStrategy extends EntityStoreStrategy {
-    protected options: FeatureStoreLoadingStrategyOptions;
-    /**
-     * Subscription to the store's features
-     */
-    private stores$$;
-    private motion;
-    constructor(options: FeatureStoreLoadingStrategyOptions);
-    /**
-     * Bind this strategy to a store and start watching for entities changes
-     * @param store Feature store
-     */
-    bindStore(store: FeatureStore): void;
-    /**
-     * Unbind this strategy from a store and stop watching for entities changes
-     * @param store Feature store
-     */
-    unbindStore(store: FeatureStore): void;
-    /**
-     * Define the motion to apply on load
-     * @param motion Feature motion
-     */
-    setMotion(motion: FeatureMotion): void;
-    /**
-     * Start watching all stores already bound to that strategy at once.
-     * @internal
-     */
-    protected doActivate(): void;
-    /**
-     * Stop watching all stores bound to that strategy
-     * @internal
-     */
-    protected doDeactivate(): void;
-    /**
-     * 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
-     */
-    private watchStore;
-    /**
-     * Stop watching for entities changes in a store.
-     * @param store Feature store
-     */
-    private unwatchStore;
-    /**
-     * Stop watching for entities changes in all stores.
-     */
-    private unwatchAll;
-    /**
-     * 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
-     */
-    private onFeaturesChange;
-    /**
-     * Selects the best motion
-     * @param store A FeatureStore to apply the motion
-     * @returns The motion selected
-     */
-    private selectMotion;
-}
+import { EntityStoreStrategy } from '@igo2/common';
+import { FeatureMotion } from '../feature.enums';
+import { FeatureStoreLoadingStrategyOptions } from '../feature.interfaces';
+import { FeatureStore } from '../store';
+/**
+ * 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 declare class FeatureStoreLoadingStrategy extends EntityStoreStrategy {
+    protected options: FeatureStoreLoadingStrategyOptions;
+    /**
+     * Subscription to the store's features
+     */
+    private stores$$;
+    private motion;
+    constructor(options: FeatureStoreLoadingStrategyOptions);
+    /**
+     * Bind this strategy to a store and start watching for entities changes
+     * @param store Feature store
+     */
+    bindStore(store: FeatureStore): void;
+    /**
+     * Unbind this strategy from a store and stop watching for entities changes
+     * @param store Feature store
+     */
+    unbindStore(store: FeatureStore): void;
+    /**
+     * Define the motion to apply on load
+     * @param motion Feature motion
+     */
+    setMotion(motion: FeatureMotion): void;
+    /**
+     * Start watching all stores already bound to that strategy at once.
+     * @internal
+     */
+    protected doActivate(): void;
+    /**
+     * Stop watching all stores bound to that strategy
+     * @internal
+     */
+    protected doDeactivate(): void;
+    /**
+     * 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
+     */
+    private watchStore;
+    /**
+     * Stop watching for entities changes in a store.
+     * @param store Feature store
+     */
+    private unwatchStore;
+    /**
+     * Stop watching for entities changes in all stores.
+     */
+    private unwatchAll;
+    /**
+     * 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
+     */
+    private onFeaturesChange;
+    /**
+     * Selects the best motion
+     * @param store A FeatureStore to apply the motion
+     * @returns The motion selected
+     */
+    private selectMotion;
+}

package/lib/feature/shared/strategies/search.d.ts

@@ -1,55 +1,55 @@
-import { EntityStoreStrategy } from '@igo2/common';
-import { FeatureStore } from '../store';
-import { FeatureStoreSearchIndexStrategyOptions } from '../feature.interfaces';
-/**
- *
- * This strategy loads a layer's features's properties into a searchable index.
- */
-export declare class FeatureStoreSearchIndexStrategy extends EntityStoreStrategy {
-    protected options: FeatureStoreSearchIndexStrategyOptions;
-    /**
-     * Subscription to the store's OL source changes
-     */
-    private stores$$;
-    constructor(options: FeatureStoreSearchIndexStrategyOptions);
-    /**
-     * Bind this strategy to a store and start watching for entities changes
-     * @param store Feature store
-     */
-    bindStore(store: FeatureStore): void;
-    /**
-     * Unbind this strategy from a store and stop watching for entities changes
-     * @param store Feature store
-     */
-    unbindStore(store: FeatureStore): void;
-    /**
-     * Start watching all stores already bound to that strategy at once.
-     * @internal
-     */
-    protected doActivate(): void;
-    /**
-     * Stop watching all stores bound to that strategy
-     * @internal
-     */
-    protected doDeactivate(): void;
-    private initStoreSearchIndex;
-    /**
-     * Watch for a store's entities changes
-     * @param store Feature store
-     */
-    private watchStore;
-    /**
-     * Stop watching for a store's entities changes
-     * @param store Feature store
-     */
-    private unwatchStore;
-    /**
-     * Stop watching for OL source changes in all stores.
-     */
-    private unwatchAll;
-    /**
-     * Maintain searcahble index for every loaded entities
-     * @param store Feature store
-     */
-    private onEntitiesChanges;
-}
+import { EntityStoreStrategy } from '@igo2/common';
+import { FeatureStore } from '../store';
+import { FeatureStoreSearchIndexStrategyOptions } from '../feature.interfaces';
+/**
+ *
+ * This strategy loads a layer's features's properties into a searchable index.
+ */
+export declare class FeatureStoreSearchIndexStrategy extends EntityStoreStrategy {
+    protected options: FeatureStoreSearchIndexStrategyOptions;
+    /**
+     * Subscription to the store's OL source changes
+     */
+    private stores$$;
+    constructor(options: FeatureStoreSearchIndexStrategyOptions);
+    /**
+     * Bind this strategy to a store and start watching for entities changes
+     * @param store Feature store
+     */
+    bindStore(store: FeatureStore): void;
+    /**
+     * Unbind this strategy from a store and stop watching for entities changes
+     * @param store Feature store
+     */
+    unbindStore(store: FeatureStore): void;
+    /**
+     * Start watching all stores already bound to that strategy at once.
+     * @internal
+     */
+    protected doActivate(): void;
+    /**
+     * Stop watching all stores bound to that strategy
+     * @internal
+     */
+    protected doDeactivate(): void;
+    private initStoreSearchIndex;
+    /**
+     * Watch for a store's entities changes
+     * @param store Feature store
+     */
+    private watchStore;
+    /**
+     * Stop watching for a store's entities changes
+     * @param store Feature store
+     */
+    private unwatchStore;
+    /**
+     * Stop watching for OL source changes in all stores.
+     */
+    private unwatchAll;
+    /**
+     * Maintain searcahble index for every loaded entities
+     * @param store Feature store
+     */
+    private onEntitiesChanges;
+}

package/lib/feature/shared/strategies/selection.d.ts

@@ -1,176 +1,176 @@
-import OlDragBoxInteraction from 'ol/interaction/DragBox';
-import { EntityStoreStrategy } from '@igo2/common';
-import { IgoMap } from '../../../map/shared/map';
-import { FeatureStoreSelectionStrategyOptions } from '../feature.interfaces';
-import { FeatureStore } from '../store';
-import { FeatureMotion } from '../feature.enums';
-export declare class OlDragSelectInteraction extends OlDragBoxInteraction {
-    constructor(options: any);
-}
-/**
- * This strategy synchronizes a store and a layer selected entities.
- * The store <-> layer binding is a two-way binding.
- *
- * In many cases, a single strategy bound to multiple stores
- * will yield better results that multiple strategies with each their
- * own store. In the latter scenario, a click on overlapping features
- * would trigger the strategy of each layer and they would cancel
- * each other as well as move the map view around needlessly.
- */
-export declare class FeatureStoreSelectionStrategy extends EntityStoreStrategy {
-    protected options: FeatureStoreSelectionStrategyOptions;
-    /**
-     * Listener to the map click event that allows selecting a feature
-     * by clicking on the map
-     */
-    private mapClickListener;
-    private olDragSelectInteraction;
-    private olDragSelectInteractionEndKey;
-    /**
-     * Subscription to all stores selected entities
-     */
-    private stores$$;
-    private motion;
-    /**
-     * The map the layers belong to
-     */
-    get map(): IgoMap;
-    /**
-     * A feature store that'll contain the selected features. It has it's own
-     * layer, shared by all the stores this staretgy is bound to.
-     */
-    get overlayStore(): FeatureStore;
-    private _overlayStore;
-    constructor(options: FeatureStoreSelectionStrategyOptions);
-    /**
-     * Bind this strategy to a store and force this strategy's
-     * reactivation to properly setup watchers.
-     * @param store Feature store
-     */
-    bindStore(store: FeatureStore): void;
-    /**
-     * Unbind this strategy from a store and force this strategy's
-     * reactivation to properly setup watchers.
-     * @param store Feature store
-     */
-    unbindStore(store: FeatureStore): void;
-    /**
-     * Define the motion to apply on select
-     * @param motion Feature motion
-     */
-    setMotion(motion: FeatureMotion): void;
-    /**
-     * Unselect all entities, from all stores
-     */
-    unselectAll(): void;
-    /**
-     * Clear the overlay
-     */
-    clear(): void;
-    /**
-     * Deactivate the selection without removing the selection
-     * overlay.
-     */
-    deactivateSelection(): void;
-    /**
-     * Add the overlay layer, setup the map click lsitener and
-     * start watching for stores selection
-     * @internal
-     */
-    protected doActivate(): void;
-    /**
-     * Remove the overlay layer, remove the map click lsitener and
-     * stop watching for stores selection
-     * @internal
-     */
-    protected doDeactivate(): void;
-    /**
-     * Create a single observable of all the stores. With a single observable,
-     * features can be added all at once to the overlay layer and a single
-     * motion can be performed. Multiple observable would have
-     * a cancelling effect on each other.
-     */
-    private watchAll;
-    /**
-     * Stop watching for selection in all stores.
-     */
-    private unwatchAll;
-    /**
-     * Add a 'singleclick' listener to the map that'll allow selecting
-     * features by clicking on the map. The selection will be performed
-     * only on the layers bound to this strategy.
-     */
-    private listenToMapClick;
-    /**
-     * Remove the map click listener
-     */
-    private unlistenToMapClick;
-    /**
-     * On map click, select feature at pixel
-     * @param event OL MapBrowserPointerEvent
-     */
-    private onMapClick;
-    /**
-     * Add a drag box interaction and, on drag box end, select features
-     */
-    private addDragBoxInteraction;
-    /**
-     * Remove drag box interaction
-     */
-    private removeDragBoxInteraction;
-    /**
-     * On dragbox end, select features in drag box
-     * @param event OL MapBrowserPointerEvent
-     */
-    private onDragBoxEnd;
-    /**
-     * When features are selected from the store, add
-     * them to this startegy's overlay layer (select on map)
-     * @param features Store features
-     */
-    private onSelectFromStore;
-    /**
-     * When features are selected from the map, also select them
-     * in their store.
-     * @param olFeatures OL feature objects
-     */
-    private onSelectFromMap;
-    /**
-     * Select features in store
-     * @param store: Feature store
-     * @param features Features
-     */
-    private selectFeaturesFromStore;
-    /**
-     * Unselect all features from store
-     * @param store: Feature store
-     */
-    private unselectAllFeaturesFromStore;
-    /**
-     * This method returns a store -> features mapping from a list
-     * of OL selected features. OL features keep a reference to the store
-     * they are from.
-     * @param olFeatures: OL feature objects
-     * @returns Store -> features mapping
-     */
-    private groupFeaturesByStore;
-    /**
-     * Create an overlay store that'll contain the selected features.
-     * @returns Overlay store
-     */
-    private createOverlayStore;
-    /**
-     * Create an overlay store that'll contain the selected features.
-     * @returns Overlay layer
-     */
-    private createOverlayLayer;
-    /**
-     * Add the overlay store's layer to the map to display the selected
-     * features.
-     */
-    private addOverlayLayer;
-    /**
-     * Remove the overlay layer from the map
-     */
-    private removeOverlayLayer;
-}
+import OlDragBoxInteraction from 'ol/interaction/DragBox';
+import { EntityStoreStrategy } from '@igo2/common';
+import { IgoMap } from '../../../map/shared/map';
+import { FeatureStoreSelectionStrategyOptions } from '../feature.interfaces';
+import { FeatureStore } from '../store';
+import { FeatureMotion } from '../feature.enums';
+export declare class OlDragSelectInteraction extends OlDragBoxInteraction {
+    constructor(options: any);
+}
+/**
+ * This strategy synchronizes a store and a layer selected entities.
+ * The store <-> layer binding is a two-way binding.
+ *
+ * In many cases, a single strategy bound to multiple stores
+ * will yield better results that multiple strategies with each their
+ * own store. In the latter scenario, a click on overlapping features
+ * would trigger the strategy of each layer and they would cancel
+ * each other as well as move the map view around needlessly.
+ */
+export declare class FeatureStoreSelectionStrategy extends EntityStoreStrategy {
+    protected options: FeatureStoreSelectionStrategyOptions;
+    /**
+     * Listener to the map click event that allows selecting a feature
+     * by clicking on the map
+     */
+    private mapClickListener;
+    private olDragSelectInteraction;
+    private olDragSelectInteractionEndKey;
+    /**
+     * Subscription to all stores selected entities
+     */
+    private stores$$;
+    private motion;
+    /**
+     * The map the layers belong to
+     */
+    get map(): IgoMap;
+    /**
+     * A feature store that'll contain the selected features. It has it's own
+     * layer, shared by all the stores this staretgy is bound to.
+     */
+    get overlayStore(): FeatureStore;
+    private _overlayStore;
+    constructor(options: FeatureStoreSelectionStrategyOptions);
+    /**
+     * Bind this strategy to a store and force this strategy's
+     * reactivation to properly setup watchers.
+     * @param store Feature store
+     */
+    bindStore(store: FeatureStore): void;
+    /**
+     * Unbind this strategy from a store and force this strategy's
+     * reactivation to properly setup watchers.
+     * @param store Feature store
+     */
+    unbindStore(store: FeatureStore): void;
+    /**
+     * Define the motion to apply on select
+     * @param motion Feature motion
+     */
+    setMotion(motion: FeatureMotion): void;
+    /**
+     * Unselect all entities, from all stores
+     */
+    unselectAll(): void;
+    /**
+     * Clear the overlay
+     */
+    clear(): void;
+    /**
+     * Deactivate the selection without removing the selection
+     * overlay.
+     */
+    deactivateSelection(): void;
+    /**
+     * Add the overlay layer, setup the map click lsitener and
+     * start watching for stores selection
+     * @internal
+     */
+    protected doActivate(): void;
+    /**
+     * Remove the overlay layer, remove the map click lsitener and
+     * stop watching for stores selection
+     * @internal
+     */
+    protected doDeactivate(): void;
+    /**
+     * Create a single observable of all the stores. With a single observable,
+     * features can be added all at once to the overlay layer and a single
+     * motion can be performed. Multiple observable would have
+     * a cancelling effect on each other.
+     */
+    private watchAll;
+    /**
+     * Stop watching for selection in all stores.
+     */
+    private unwatchAll;
+    /**
+     * Add a 'singleclick' listener to the map that'll allow selecting
+     * features by clicking on the map. The selection will be performed
+     * only on the layers bound to this strategy.
+     */
+    private listenToMapClick;
+    /**
+     * Remove the map click listener
+     */
+    private unlistenToMapClick;
+    /**
+     * On map click, select feature at pixel
+     * @param event OL MapBrowserPointerEvent
+     */
+    private onMapClick;
+    /**
+     * Add a drag box interaction and, on drag box end, select features
+     */
+    private addDragBoxInteraction;
+    /**
+     * Remove drag box interaction
+     */
+    private removeDragBoxInteraction;
+    /**
+     * On dragbox end, select features in drag box
+     * @param event OL MapBrowserPointerEvent
+     */
+    private onDragBoxEnd;
+    /**
+     * When features are selected from the store, add
+     * them to this startegy's overlay layer (select on map)
+     * @param features Store features
+     */
+    private onSelectFromStore;
+    /**
+     * When features are selected from the map, also select them
+     * in their store.
+     * @param olFeatures OL feature objects
+     */
+    private onSelectFromMap;
+    /**
+     * Select features in store
+     * @param store: Feature store
+     * @param features Features
+     */
+    private selectFeaturesFromStore;
+    /**
+     * Unselect all features from store
+     * @param store: Feature store
+     */
+    private unselectAllFeaturesFromStore;
+    /**
+     * This method returns a store -> features mapping from a list
+     * of OL selected features. OL features keep a reference to the store
+     * they are from.
+     * @param olFeatures: OL feature objects
+     * @returns Store -> features mapping
+     */
+    private groupFeaturesByStore;
+    /**
+     * Create an overlay store that'll contain the selected features.
+     * @returns Overlay store
+     */
+    private createOverlayStore;
+    /**
+     * Create an overlay store that'll contain the selected features.
+     * @returns Overlay layer
+     */
+    private createOverlayLayer;
+    /**
+     * Add the overlay store's layer to the map to display the selected
+     * features.
+     */
+    private addOverlayLayer;
+    /**
+     * Remove the overlay layer from the map
+     */
+    private removeOverlayLayer;
+}

package/lib/feature/shared/strategies.utils.d.ts

@@ -1,17 +1,17 @@
-import { FeatureStore } from './store';
-import { FeatureStoreSelectionStrategy } from './strategies/selection';
-import { FeatureStoreLoadingStrategy } from './strategies/loading';
-/**
- * Try to add a loading strategy to a store and activate it.
- * If no strategy is given to that function, a basic one will be created.
- * @param store The store to bind the loading strategy
- * @param strategy An optional loading strategy
- */
-export declare function tryAddLoadingStrategy(store: FeatureStore, strategy?: FeatureStoreLoadingStrategy): void;
-/**
- * Try to add a selection strategy to a store and activate it.
- * If no strategy is given to that function, a basic one will be created.
- * @param store The store to bind the selection strategy
- * @param [strategy] An optional selection strategy
- */
-export declare function tryAddSelectionStrategy(store: FeatureStore, strategy?: FeatureStoreSelectionStrategy): void;
+import { FeatureStore } from './store';
+import { FeatureStoreSelectionStrategy } from './strategies/selection';
+import { FeatureStoreLoadingStrategy } from './strategies/loading';
+/**
+ * Try to add a loading strategy to a store and activate it.
+ * If no strategy is given to that function, a basic one will be created.
+ * @param store The store to bind the loading strategy
+ * @param strategy An optional loading strategy
+ */
+export declare function tryAddLoadingStrategy(store: FeatureStore, strategy?: FeatureStoreLoadingStrategy): void;
+/**
+ * Try to add a selection strategy to a store and activate it.
+ * If no strategy is given to that function, a basic one will be created.
+ * @param store The store to bind the selection strategy
+ * @param [strategy] An optional selection strategy
+ */
+export declare function tryAddSelectionStrategy(store: FeatureStore, strategy?: FeatureStoreSelectionStrategy): void;