proximiio-js-library 1.17.5 → 1.17.6

package/README.md

@@ -446,6 +446,15 @@ const map = new Proximiio.Map({
    // If set to true only features inside defined time range in metadata.dateStart and metadata.dateEnd will be shown
    useTimerangeData: false,
 
+   // If set to true, routing will avoid paths that are closed according to their working hours
+   // (properties._workingHoursEnabled + properties.workingHours), evaluated against the device's local time.
+   // Paths marked properties.available: false are always avoided, regardless of this option.
+   useWorkingHours: false,
+
+   // If set to true (together with useWorkingHours), routing to a destination POI that is currently
+   // closed according to its working hours will be refused instead of computed
+   excludeClosedPois: false,
+
    // If enabled we automatically send analytics from routing to our API, default: true
    sendAnalytics: true,
 

package/lib/components/map/main.d.ts

@@ -205,6 +205,8 @@ export interface Options {
     blockFeatureClickWhileRouting?: boolean;
     hiddenAmenities?: string[];
     useTimerangeData?: boolean;
+    useWorkingHours?: boolean;
+    excludeClosedPois?: boolean;
     sendAnalytics?: boolean;
     defaultFilter?: {
         key: string;

package/lib/components/map/main.js

@@ -250,6 +250,8 @@ export class Map {
             routeWithDetails: true,
             blockFeatureClickWhileRouting: false,
             useTimerangeData: false,
+            useWorkingHours: false,
+            excludeClosedPois: false,
             sendAnalytics: true,
             autoLevelChange: false,
             autoRestartAnimationAfterFloorChange: false,
@@ -772,7 +774,10 @@ export class Map {
                 this.routingSource.setLevelChangers(levelChangers);
                 this.routingSource.setFloors(this.state.floors);
                 this.geojsonSource.fetch(optimizedFeatures);
-                this.routingSource.routing.setData(features.originalFeatures);
+                this.routingSource.routing.setData(features.originalFeatures, {
+                    useWorkingHours: this.defaultOptions.useWorkingHours,
+                    excludeClosedPois: this.defaultOptions.excludeClosedPois,
+                });
                 this.prepareStyle(this.state.style);
                 this.state = Object.assign(Object.assign({}, this.state), { initializing: false, kiosks: (_a = kiosks === null || kiosks === void 0 ? void 0 : kiosks.data) !== null && _a !== void 0 ? _a : [], amenities, features: features.modifiedFeatures, ads: (_b = ads === null || ads === void 0 ? void 0 : ads.data) !== null && _b !== void 0 ? _b : [], optimizedFeatures, allFeatures: new FeatureCollection(features.modifiedFeatures), levelChangers: new FeatureCollection({ features: levelChangers }), zoom: this.defaultOptions.zoomLevel ? this.defaultOptions.zoomLevel : (_c = this.defaultOptions.mapboxOptions) === null || _c === void 0 ? void 0 : _c.zoom });
                 this.onDataFetchedListener.next(true);

package/lib/components/map/routing.d.ts

@@ -1,14 +1,24 @@
 import Feature from '../../models/feature';
 import { FeatureCollection } from '@turf/helpers';
 import { WayfindingConfigModel } from '../../models/wayfinding';
+export interface RoutingWorkingHoursOptions {
+    useWorkingHours?: boolean;
+    excludeClosedPois?: boolean;
+    /** Override "now" for previewing a route at a different time. Defaults to the device's current time. */
+    datetime?: Date;
+}
 export default class Routing {
     data: FeatureCollection;
+    rawData: FeatureCollection;
     wayfinding: any;
     forceFloorLevel: number;
     routeWithDetails: boolean;
     config: WayfindingConfigModel;
+    workingHoursOptions: RoutingWorkingHoursOptions;
     constructor();
-    setData(collection: FeatureCollection): void;
+    private filterRoutableFeatures;
+    setData(collection: FeatureCollection, options?: RoutingWorkingHoursOptions): void;
+    setWorkingHoursOptions(options: RoutingWorkingHoursOptions): void;
     toggleOnlyAccessible(onlyAccessible: any): void;
     setConfig(config: WayfindingConfigModel): void;
     route({ start, finish, stops, stepsNavigation, priorityEntrance, }: {
@@ -18,6 +28,9 @@ export default class Routing {
         stepsNavigation?: 'disabled' | 'simple' | 'simple-levelChangers' | 'full' | 'full-levelChangers' | 'landmark' | 'landmark-levelChangers';
         priorityEntrance?: Feature;
     }): {
+        destinationOpen: boolean;
+    } | {
+        destinationOpen: boolean;
         paths: any;
         points: any;
         route: {};

package/lib/components/map/routing.js

@@ -12,14 +12,33 @@ import { Wayfinding } from '../../../lib/assets/wayfinding';
 import Feature from '../../models/feature';
 import { lineString, point } from '@turf/helpers';
 import osrmTextInstructionsPackage from 'osrm-text-instructions';
+import { isOpenAt, nowClientTime } from './workingHours';
 const version = 'v5';
 const osrmTextInstructions = osrmTextInstructionsPackage(version);
 export default class Routing {
     constructor() {
+        this.workingHoursOptions = {};
         this.data = {};
     }
-    setData(collection) {
-        this.data = collection;
+    filterRoutableFeatures(collection) {
+        const time = nowClientTime(this.workingHoursOptions.datetime);
+        const features = (collection.features || []).filter((f) => {
+            var _a;
+            if (((_a = f.properties) === null || _a === void 0 ? void 0 : _a.class) !== 'path')
+                return true;
+            // Unavailable paths are always avoided, independently of any option.
+            if (f.properties.available === false)
+                return false;
+            if (this.workingHoursOptions.useWorkingHours && !isOpenAt(f.properties, time))
+                return false;
+            return true;
+        });
+        return Object.assign(Object.assign({}, collection), { features });
+    }
+    setData(collection, options) {
+        this.rawData = collection;
+        this.workingHoursOptions = Object.assign(Object.assign({}, this.workingHoursOptions), options);
+        this.data = this.filterRoutableFeatures(this.rawData);
         this.wayfinding = new Wayfinding(this.data);
         this.wayfinding.preprocess();
         // pathfinding.load(neighbourList, wallOffsets);
@@ -29,6 +48,14 @@ export default class Routing {
         // avoidRevolvingDoors: true
         // });
     }
+    setWorkingHoursOptions(options) {
+        this.workingHoursOptions = Object.assign(Object.assign({}, this.workingHoursOptions), options);
+        if (this.rawData) {
+            this.data = this.filterRoutableFeatures(this.rawData);
+            this.wayfinding = new Wayfinding(this.data);
+            this.wayfinding.preprocess();
+        }
+    }
     toggleOnlyAccessible(onlyAccessible) {
         if (onlyAccessible) {
             this.wayfinding.setConfiguration({
@@ -62,6 +89,11 @@ export default class Routing {
         this.wayfinding.setConfiguration(config);
     }
     route({ start, finish, stops, stepsNavigation = 'full', priorityEntrance, }) {
+        const time = nowClientTime(this.workingHoursOptions.datetime);
+        const destinationOpen = this.workingHoursOptions.useWorkingHours && finish ? isOpenAt(finish.properties, time) : undefined;
+        if (destinationOpen === false && this.workingHoursOptions.excludeClosedPois) {
+            return { destinationOpen: false };
+        }
         const isMultipoint = stops && stops.length > 1;
         let points = null;
         let details = null;
@@ -397,7 +429,10 @@ export default class Routing {
             }
             levelPoints[point.properties.level].push(point);
         });
-        return { paths, points, route: {}, fullPath: {}, levelPaths, levelPoints, details };
+        return Object.assign({ paths,
+            points, route: {}, fullPath: {}, levelPaths,
+            levelPoints,
+            details }, (destinationOpen !== undefined && { destinationOpen }));
     }
     cityRoute({ start, finish, language = 'en' }) {
         return __awaiter(this, void 0, void 0, function* () {

package/lib/components/map/sources/routing_source.d.ts

@@ -1,6 +1,6 @@
 import DataSource from './data_source';
 import Feature from '../../../models/feature';
-import Routing from '../routing';
+import Routing, { RoutingWorkingHoursOptions } from '../routing';
 import { GuidanceStep, WayfindingConfigModel } from '../../../models/wayfinding';
 import { FloorModel } from '../../../models/floor';
 interface ChangeContainer {
@@ -45,6 +45,7 @@ export default class RoutingSource extends DataSource {
     constructor();
     toggleAccessible(value: any): void;
     setConfig(config: WayfindingConfigModel): void;
+    setWorkingHoursOptions(options: RoutingWorkingHoursOptions): void;
     setNavigationType(type: 'mall' | 'city' | 'combined'): void;
     setStepsNavigation(value: 'disabled' | 'simple' | 'simple-levelChangers' | 'full' | 'full-levelChangers' | 'landmark' | 'landmark-levelChangers'): void;
     setInitialBearing(initialBearing: number): void;

package/lib/components/map/sources/routing_source.js

@@ -28,6 +28,9 @@ export default class RoutingSource extends DataSource {
     setConfig(config) {
         this.routing.setConfig(config);
     }
+    setWorkingHoursOptions(options) {
+        this.routing.setWorkingHoursOptions(options);
+    }
     setNavigationType(type) {
         this.navigationType = type;
     }
@@ -108,6 +111,10 @@ export default class RoutingSource extends DataSource {
                     }
                 }
                 // @ts-ignore
+                if ((route === null || route === void 0 ? void 0 : route.destinationOpen) === false) {
+                    this.notify('destination-closed');
+                }
+                // @ts-ignore
                 let paths = route === null || route === void 0 ? void 0 : route.paths;
                 // @ts-ignore
                 this.route = route === null || route === void 0 ? void 0 : route.paths;

package/lib/components/map/workingHours.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Working-hours support for client-side routing.
+ *
+ * Features may carry on `properties`:
+ *   _workingHoursEnabled: true
+ *   workingHours: [ ["14:00","22:00"], ... ]  // 7 entries, index 0 = SUNDAY
+ *
+ * This runs on the end user's own device, so "now" is simply the browser's
+ * local clock — unlike a server serving clients across timezones, there is
+ * no offset to strip: `Date#getDay/getHours/getMinutes` already reflect the
+ * device's local wall-clock time.
+ *
+ * Malformed or missing data fails OPEN: bad venue data must never make a
+ * feature unroutable.
+ */
+export type ClientTime = {
+    /** 0 = Sunday … 6 = Saturday, matching the workingHours array order. */
+    weekday: number;
+    /** Minutes since local midnight, 0–1439. */
+    minutes: number;
+};
+/**
+ * Derive weekday + wall-clock minutes from a local Date (defaults to now).
+ */
+export declare function nowClientTime(date?: Date): ClientTime;
+/**
+ * Is a feature open at the given client time?
+ *
+ * - Features without `_workingHoursEnabled: true` (or with malformed
+ *   `workingHours`) are always open.
+ * - A window with `from < to` covers [from, to) that day.
+ * - An overnight window (`from > to`, e.g. 22:00–06:00) covers [from, 24:00)
+ *   that day plus [00:00, to) of the NEXT day — so we also check whether
+ *   yesterday's window spills past midnight into now.
+ * - `from === to` means closed all day (zero-length window).
+ */
+export declare function isOpenAt(properties: any, time: ClientTime): boolean;

package/lib/components/map/workingHours.js

@@ -0,0 +1,76 @@
+/**
+ * Working-hours support for client-side routing.
+ *
+ * Features may carry on `properties`:
+ *   _workingHoursEnabled: true
+ *   workingHours: [ ["14:00","22:00"], ... ]  // 7 entries, index 0 = SUNDAY
+ *
+ * This runs on the end user's own device, so "now" is simply the browser's
+ * local clock — unlike a server serving clients across timezones, there is
+ * no offset to strip: `Date#getDay/getHours/getMinutes` already reflect the
+ * device's local wall-clock time.
+ *
+ * Malformed or missing data fails OPEN: bad venue data must never make a
+ * feature unroutable.
+ */
+const HH_MM = /^(\d{1,2}):(\d{2})$/;
+const MINUTES_PER_DAY = 24 * 60;
+/**
+ * Derive weekday + wall-clock minutes from a local Date (defaults to now).
+ */
+export function nowClientTime(date = new Date()) {
+    return { weekday: date.getDay(), minutes: date.getHours() * 60 + date.getMinutes() };
+}
+function toMinutes(value) {
+    if (typeof value !== 'string')
+        return undefined;
+    const m = HH_MM.exec(value.trim());
+    if (!m)
+        return undefined;
+    const hours = Number(m[1]);
+    const minutes = Number(m[2]);
+    if (hours > 24 || minutes > 59)
+        return undefined;
+    return Math.min(hours * 60 + minutes, MINUTES_PER_DAY);
+}
+function dayWindow(workingHours, weekday) {
+    if (!Array.isArray(workingHours) || workingHours.length !== 7)
+        return undefined;
+    const day = workingHours[weekday];
+    if (!Array.isArray(day) || day.length < 2)
+        return undefined;
+    const from = toMinutes(day[0]);
+    const to = toMinutes(day[1]);
+    if (from === undefined || to === undefined)
+        return undefined;
+    return { from, to };
+}
+/**
+ * Is a feature open at the given client time?
+ *
+ * - Features without `_workingHoursEnabled: true` (or with malformed
+ *   `workingHours`) are always open.
+ * - A window with `from < to` covers [from, to) that day.
+ * - An overnight window (`from > to`, e.g. 22:00–06:00) covers [from, 24:00)
+ *   that day plus [00:00, to) of the NEXT day — so we also check whether
+ *   yesterday's window spills past midnight into now.
+ * - `from === to` means closed all day (zero-length window).
+ */
+export function isOpenAt(properties, time) {
+    if ((properties === null || properties === void 0 ? void 0 : properties._workingHoursEnabled) !== true)
+        return true;
+    const workingHours = properties.workingHours;
+    if (!Array.isArray(workingHours) || workingHours.length !== 7)
+        return true;
+    const today = dayWindow(workingHours, time.weekday);
+    if (today === undefined)
+        return true;
+    if (today.from < today.to && time.minutes >= today.from && time.minutes < today.to)
+        return true;
+    if (today.from > today.to && time.minutes >= today.from)
+        return true;
+    const yesterday = dayWindow(workingHours, (time.weekday + 6) % 7);
+    if (yesterday !== undefined && yesterday.from > yesterday.to && time.minutes < yesterday.to)
+        return true;
+    return false;
+}