🎯 MapView v2.0 - Global Deployment Ready

✨ MAJOR FEATURES:
• Auto-zoom intelligence với smart bounds fitting
• Enhanced 3D GPS markers với pulsing effects
• Professional route display với 6-layer rendering
• Status-based parking icons với availability indicators
• Production-ready build optimizations

🗺️ AUTO-ZOOM FEATURES:
• Smart bounds fitting cho GPS + selected parking
• Adaptive padding (50px) cho visual balance
• Max zoom control (level 16) để tránh quá gần
• Dynamic centering khi không có selection

🎨 ENHANCED VISUALS:
• 3D GPS marker với multi-layer pulse effects
• Advanced parking icons với status colors
• Selection highlighting với animation
• Dimming system cho non-selected items

🛣️ ROUTE SYSTEM:
• OpenRouteService API integration
• Multi-layer route rendering (glow, shadow, main, animated)
• Real-time distance & duration calculation
• Visual route info trong popup

📱 PRODUCTION READY:
• SSR safe với dynamic imports
• Build errors resolved
• Global deployment via Vercel
• Optimized performance

🌍 DEPLOYMENT:
• Vercel: https://whatever-ctk2auuxr-phong12hexdockworks-projects.vercel.app
• Bundle size: 22.8 kB optimized
• Global CDN distribution
• HTTPS enabled

💾 VERSION CONTROL:
• MapView-v2.0.tsx backup created
• MAPVIEW_VERSIONS.md documentation
• Full version history tracking

backend/node_modules/@nestjs/core/hooks/before-app-shutdown.hook.d.ts

@@ -0,0 +1,9 @@
+import { Module } from '../injector/module';
+/**
+ * Calls the `beforeApplicationShutdown` function on the module and its children
+ * (providers / controllers).
+ *
+ * @param module The module which will be initialized
+ * @param signal The signal which caused the shutdown
+ */
+export declare function callBeforeAppShutdownHook(module: Module, signal?: string): Promise<void>;

backend/node_modules/@nestjs/core/hooks/before-app-shutdown.hook.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.callBeforeAppShutdownHook = callBeforeAppShutdownHook;
+const shared_utils_1 = require("@nestjs/common/utils/shared.utils");
+const iterare_1 = require("iterare");
+const transient_instances_1 = require("../injector/helpers/transient-instances");
+/**
+ * Checks if the given instance has the `beforeApplicationShutdown` function
+ *
+ * @param instance The instance which should be checked
+ */
+function hasBeforeApplicationShutdownHook(instance) {
+    return (0, shared_utils_1.isFunction)(instance.beforeApplicationShutdown);
+}
+/**
+ * Calls the given instances
+ */
+function callOperator(instances, signal) {
+    return (0, iterare_1.iterate)(instances)
+        .filter(instance => !(0, shared_utils_1.isNil)(instance))
+        .filter(hasBeforeApplicationShutdownHook)
+        .map(async (instance) => instance.beforeApplicationShutdown(signal))
+        .toArray();
+}
+/**
+ * Calls the `beforeApplicationShutdown` function on the module and its children
+ * (providers / controllers).
+ *
+ * @param module The module which will be initialized
+ * @param signal The signal which caused the shutdown
+ */
+async function callBeforeAppShutdownHook(module, signal) {
+    const providers = module.getNonAliasProviders();
+    const [_, moduleClassHost] = providers.shift();
+    const instances = [
+        ...module.controllers,
+        ...providers,
+        ...module.injectables,
+        ...module.middlewares,
+    ];
+    const nonTransientInstances = (0, transient_instances_1.getNonTransientInstances)(instances);
+    await Promise.all(callOperator(nonTransientInstances, signal));
+    const transientInstances = (0, transient_instances_1.getTransientInstances)(instances);
+    await Promise.all(callOperator(transientInstances, signal));
+    const moduleClassInstance = moduleClassHost.instance;
+    if (moduleClassInstance &&
+        hasBeforeApplicationShutdownHook(moduleClassInstance) &&
+        moduleClassHost.isDependencyTreeStatic()) {
+        await moduleClassInstance.beforeApplicationShutdown(signal);
+    }
+}

backend/node_modules/@nestjs/core/hooks/index.d.ts

@@ -0,0 +1,5 @@
+export * from './on-app-bootstrap.hook';
+export * from './on-app-shutdown.hook';
+export * from './on-module-destroy.hook';
+export * from './on-module-init.hook';
+export * from './before-app-shutdown.hook';

backend/node_modules/@nestjs/core/hooks/index.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./on-app-bootstrap.hook"), exports);
+tslib_1.__exportStar(require("./on-app-shutdown.hook"), exports);
+tslib_1.__exportStar(require("./on-module-destroy.hook"), exports);
+tslib_1.__exportStar(require("./on-module-init.hook"), exports);
+tslib_1.__exportStar(require("./before-app-shutdown.hook"), exports);

backend/node_modules/@nestjs/core/hooks/on-app-bootstrap.hook.d.ts

@@ -0,0 +1,8 @@
+import { Module } from '../injector/module';
+/**
+ * Calls the `onApplicationBootstrap` function on the module and its children
+ * (providers / controllers).
+ *
+ * @param module The module which will be initialized
+ */
+export declare function callModuleBootstrapHook(module: Module): Promise<any>;

backend/node_modules/@nestjs/core/hooks/on-app-bootstrap.hook.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.callModuleBootstrapHook = callModuleBootstrapHook;
+const shared_utils_1 = require("@nestjs/common/utils/shared.utils");
+const iterare_1 = require("iterare");
+const transient_instances_1 = require("../injector/helpers/transient-instances");
+/**
+ * Checks if the given instance has the `onApplicationBootstrap` function
+ *
+ * @param instance The instance which should be checked
+ */
+function hasOnAppBootstrapHook(instance) {
+    return (0, shared_utils_1.isFunction)(instance.onApplicationBootstrap);
+}
+/**
+ * Calls the given instances
+ */
+function callOperator(instances) {
+    return (0, iterare_1.iterate)(instances)
+        .filter(instance => !(0, shared_utils_1.isNil)(instance))
+        .filter(hasOnAppBootstrapHook)
+        .map(async (instance) => instance.onApplicationBootstrap())
+        .toArray();
+}
+/**
+ * Calls the `onApplicationBootstrap` function on the module and its children
+ * (providers / controllers).
+ *
+ * @param module The module which will be initialized
+ */
+async function callModuleBootstrapHook(module) {
+    const providers = module.getNonAliasProviders();
+    // Module (class) instance is the first element of the providers array
+    // Lifecycle hook has to be called once all classes are properly initialized
+    const [_, moduleClassHost] = providers.shift();
+    const instances = [
+        ...module.controllers,
+        ...providers,
+        ...module.injectables,
+        ...module.middlewares,
+    ];
+    const nonTransientInstances = (0, transient_instances_1.getNonTransientInstances)(instances);
+    await Promise.all(callOperator(nonTransientInstances));
+    const transientInstances = (0, transient_instances_1.getTransientInstances)(instances);
+    await Promise.all(callOperator(transientInstances));
+    // Call the instance itself
+    const moduleClassInstance = moduleClassHost.instance;
+    if (moduleClassInstance &&
+        hasOnAppBootstrapHook(moduleClassInstance) &&
+        moduleClassHost.isDependencyTreeStatic()) {
+        await moduleClassInstance.onApplicationBootstrap();
+    }
+}

backend/node_modules/@nestjs/core/hooks/on-app-shutdown.hook.d.ts

@@ -0,0 +1,9 @@
+import { Module } from '../injector/module';
+/**
+ * Calls the `onApplicationShutdown` function on the module and its children
+ * (providers / controllers).
+ *
+ * @param module The module which will be initialized
+ * @param signal
+ */
+export declare function callAppShutdownHook(module: Module, signal?: string): Promise<any>;

backend/node_modules/@nestjs/core/hooks/on-app-shutdown.hook.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.callAppShutdownHook = callAppShutdownHook;
+const shared_utils_1 = require("@nestjs/common/utils/shared.utils");
+const iterare_1 = require("iterare");
+const transient_instances_1 = require("../injector/helpers/transient-instances");
+/**
+ * Checks if the given instance has the `onApplicationShutdown` function
+ *
+ * @param instance The instance which should be checked
+ */
+function hasOnAppShutdownHook(instance) {
+    return (0, shared_utils_1.isFunction)(instance.onApplicationShutdown);
+}
+/**
+ * Calls the given instances
+ */
+function callOperator(instances, signal) {
+    return (0, iterare_1.iterate)(instances)
+        .filter(instance => !(0, shared_utils_1.isNil)(instance))
+        .filter(hasOnAppShutdownHook)
+        .map(async (instance) => instance.onApplicationShutdown(signal))
+        .toArray();
+}
+/**
+ * Calls the `onApplicationShutdown` function on the module and its children
+ * (providers / controllers).
+ *
+ * @param module The module which will be initialized
+ * @param signal
+ */
+async function callAppShutdownHook(module, signal) {
+    const providers = module.getNonAliasProviders();
+    // Module (class) instance is the first element of the providers array
+    // Lifecycle hook has to be called once all classes are properly initialized
+    const [_, moduleClassHost] = providers.shift();
+    const instances = [
+        ...module.controllers,
+        ...providers,
+        ...module.injectables,
+        ...module.middlewares,
+    ];
+    const nonTransientInstances = (0, transient_instances_1.getNonTransientInstances)(instances);
+    await Promise.all(callOperator(nonTransientInstances, signal));
+    const transientInstances = (0, transient_instances_1.getTransientInstances)(instances);
+    await Promise.all(callOperator(transientInstances, signal));
+    // Call the instance itself
+    const moduleClassInstance = moduleClassHost.instance;
+    if (moduleClassInstance &&
+        hasOnAppShutdownHook(moduleClassInstance) &&
+        moduleClassHost.isDependencyTreeStatic()) {
+        await moduleClassInstance.onApplicationShutdown(signal);
+    }
+}

backend/node_modules/@nestjs/core/hooks/on-module-destroy.hook.d.ts

@@ -0,0 +1,8 @@
+import { Module } from '../injector/module';
+/**
+ * Calls the `onModuleDestroy` function on the module and its children
+ * (providers / controllers).
+ *
+ * @param module The module which will be initialized
+ */
+export declare function callModuleDestroyHook(module: Module): Promise<any>;

backend/node_modules/@nestjs/core/hooks/on-module-destroy.hook.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.callModuleDestroyHook = callModuleDestroyHook;
+const shared_utils_1 = require("@nestjs/common/utils/shared.utils");
+const iterare_1 = require("iterare");
+const transient_instances_1 = require("../injector/helpers/transient-instances");
+/**
+ * Returns true or false if the given instance has a `onModuleDestroy` function
+ *
+ * @param instance The instance which should be checked
+ */
+function hasOnModuleDestroyHook(instance) {
+    return (0, shared_utils_1.isFunction)(instance.onModuleDestroy);
+}
+/**
+ * Calls the given instances onModuleDestroy hook
+ */
+function callOperator(instances) {
+    return (0, iterare_1.iterate)(instances)
+        .filter(instance => !(0, shared_utils_1.isNil)(instance))
+        .filter(hasOnModuleDestroyHook)
+        .map(async (instance) => instance.onModuleDestroy())
+        .toArray();
+}
+/**
+ * Calls the `onModuleDestroy` function on the module and its children
+ * (providers / controllers).
+ *
+ * @param module The module which will be initialized
+ */
+async function callModuleDestroyHook(module) {
+    const providers = module.getNonAliasProviders();
+    // Module (class) instance is the first element of the providers array
+    // Lifecycle hook has to be called once all classes are properly destroyed
+    const [_, moduleClassHost] = providers.shift();
+    const instances = [
+        ...module.controllers,
+        ...providers,
+        ...module.injectables,
+        ...module.middlewares,
+    ];
+    const nonTransientInstances = (0, transient_instances_1.getNonTransientInstances)(instances);
+    await Promise.all(callOperator(nonTransientInstances));
+    const transientInstances = (0, transient_instances_1.getTransientInstances)(instances);
+    await Promise.all(callOperator(transientInstances));
+    // Call the module instance itself
+    const moduleClassInstance = moduleClassHost.instance;
+    if (moduleClassInstance &&
+        hasOnModuleDestroyHook(moduleClassInstance) &&
+        moduleClassHost.isDependencyTreeStatic()) {
+        await moduleClassInstance.onModuleDestroy();
+    }
+}

backend/node_modules/@nestjs/core/hooks/on-module-init.hook.d.ts

@@ -0,0 +1,8 @@
+import { Module } from '../injector/module';
+/**
+ * Calls the `onModuleInit` function on the module and its children
+ * (providers / controllers).
+ *
+ * @param module The module which will be initialized
+ */
+export declare function callModuleInitHook(module: Module): Promise<void>;

backend/node_modules/@nestjs/core/hooks/on-module-init.hook.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.callModuleInitHook = callModuleInitHook;
+const shared_utils_1 = require("@nestjs/common/utils/shared.utils");
+const iterare_1 = require("iterare");
+const transient_instances_1 = require("../injector/helpers/transient-instances");
+/**
+ * Returns true or false if the given instance has a `onModuleInit` function
+ *
+ * @param instance The instance which should be checked
+ */
+function hasOnModuleInitHook(instance) {
+    return (0, shared_utils_1.isFunction)(instance.onModuleInit);
+}
+/**
+ * Calls the given instances
+ */
+function callOperator(instances) {
+    return (0, iterare_1.iterate)(instances)
+        .filter(instance => !(0, shared_utils_1.isNil)(instance))
+        .filter(hasOnModuleInitHook)
+        .map(async (instance) => instance.onModuleInit())
+        .toArray();
+}
+/**
+ * Calls the `onModuleInit` function on the module and its children
+ * (providers / controllers).
+ *
+ * @param module The module which will be initialized
+ */
+async function callModuleInitHook(module) {
+    const providers = module.getNonAliasProviders();
+    // Module (class) instance is the first element of the providers array
+    // Lifecycle hook has to be called once all classes are properly initialized
+    const [_, moduleClassHost] = providers.shift();
+    const instances = [
+        ...module.controllers,
+        ...providers,
+        ...module.injectables,
+        ...module.middlewares,
+    ];
+    const nonTransientInstances = (0, transient_instances_1.getNonTransientInstances)(instances);
+    await Promise.all(callOperator(nonTransientInstances));
+    const transientInstances = (0, transient_instances_1.getTransientInstances)(instances);
+    await Promise.all(callOperator(transientInstances));
+    // Call the instance itself
+    const moduleClassInstance = moduleClassHost.instance;
+    if (moduleClassInstance &&
+        hasOnModuleInitHook(moduleClassInstance) &&
+        moduleClassHost.isDependencyTreeStatic()) {
+        await moduleClassInstance.onModuleInit();
+    }
+}

backend/node_modules/@nestjs/core/hooks/utils/get-instances-grouped-by-hierarchy-level.d.ts

@@ -0,0 +1,3 @@
+import { InjectionToken } from '@nestjs/common';
+import { InstanceWrapper } from '../../injector/instance-wrapper';
+export declare function getInstancesGroupedByHierarchyLevel(...collections: Array<Map<InjectionToken, InstanceWrapper> | Array<[InjectionToken, InstanceWrapper]>>): Map<number, unknown[]>;

backend/node_modules/@nestjs/core/hooks/utils/get-instances-grouped-by-hierarchy-level.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getInstancesGroupedByHierarchyLevel = getInstancesGroupedByHierarchyLevel;
+function getInstancesGroupedByHierarchyLevel(...collections) {
+    const groupedByHierarchyLevel = new Map();
+    for (const collection of collections) {
+        for (const [_, wrapper] of collection) {
+            if (!wrapper.isDependencyTreeStatic()) {
+                continue;
+            }
+            const level = wrapper.hierarchyLevel;
+            if (!groupedByHierarchyLevel.has(level)) {
+                groupedByHierarchyLevel.set(level, []);
+            }
+            const byHierarchyLevelGroup = groupedByHierarchyLevel.get(level);
+            if (wrapper.isTransient) {
+                const staticTransientInstances = wrapper
+                    .getStaticTransientInstances()
+                    .filter(i => !!i)
+                    .map(i => i.instance);
+                byHierarchyLevelGroup.push(...staticTransientInstances);
+                continue;
+            }
+            if (wrapper.instance) {
+                byHierarchyLevelGroup.push(wrapper.instance);
+            }
+        }
+    }
+    return groupedByHierarchyLevel;
+}

backend/node_modules/@nestjs/core/hooks/utils/get-sorted-hierarchy-levels.d.ts

@@ -0,0 +1 @@
+export declare function getSortedHierarchyLevels(groups: Map<number, unknown[]>, order?: 'ASC' | 'DESC'): number[];

backend/node_modules/@nestjs/core/hooks/utils/get-sorted-hierarchy-levels.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSortedHierarchyLevels = getSortedHierarchyLevels;
+function getSortedHierarchyLevels(groups, order = 'ASC') {
+    const comparator = order === 'ASC'
+        ? (a, b) => a - b
+        : (a, b) => b - a;
+    const levels = Array.from(groups.keys()).sort(comparator);
+    return levels;
+}