🎯 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/jwt/dist/index.d.ts

@@ -0,0 +1,5 @@
+export * from './interfaces';
+export * from './jwt.errors';
+export * from './jwt.module';
+export * from './jwt.service';
+export { TokenExpiredError, NotBeforeError, JsonWebTokenError } from 'jsonwebtoken';

backend/node_modules/@nestjs/jwt/dist/index.js

@@ -0,0 +1,25 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JsonWebTokenError = exports.NotBeforeError = exports.TokenExpiredError = void 0;
+__exportStar(require("./interfaces"), exports);
+__exportStar(require("./jwt.errors"), exports);
+__exportStar(require("./jwt.module"), exports);
+__exportStar(require("./jwt.service"), exports);
+var jsonwebtoken_1 = require("jsonwebtoken");
+Object.defineProperty(exports, "TokenExpiredError", { enumerable: true, get: function () { return jsonwebtoken_1.TokenExpiredError; } });
+Object.defineProperty(exports, "NotBeforeError", { enumerable: true, get: function () { return jsonwebtoken_1.NotBeforeError; } });
+Object.defineProperty(exports, "JsonWebTokenError", { enumerable: true, get: function () { return jsonwebtoken_1.JsonWebTokenError; } });

backend/node_modules/@nestjs/jwt/dist/interfaces/index.d.ts

@@ -0,0 +1 @@
+export * from './jwt-module-options.interface';

backend/node_modules/@nestjs/jwt/dist/interfaces/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./jwt-module-options.interface"), exports);

backend/node_modules/@nestjs/jwt/dist/interfaces/jwt-module-options.interface.d.ts

@@ -0,0 +1,37 @@
+/// <reference types="node" />
+import { ModuleMetadata, Provider, Type } from '@nestjs/common';
+import * as jwt from 'jsonwebtoken';
+export declare enum JwtSecretRequestType {
+    SIGN = 0,
+    VERIFY = 1
+}
+export interface JwtModuleOptions {
+    global?: boolean;
+    signOptions?: jwt.SignOptions;
+    secret?: string | Buffer;
+    publicKey?: string | Buffer;
+    privateKey?: jwt.Secret;
+    secretOrPrivateKey?: jwt.Secret;
+    secretOrKeyProvider?: (requestType: JwtSecretRequestType, tokenOrPayload: string | object | Buffer, options?: jwt.VerifyOptions | jwt.SignOptions) => jwt.Secret | Promise<jwt.Secret>;
+    verifyOptions?: jwt.VerifyOptions;
+}
+export interface JwtOptionsFactory {
+    createJwtOptions(): Promise<JwtModuleOptions> | JwtModuleOptions;
+}
+export interface JwtModuleAsyncOptions extends Pick<ModuleMetadata, 'imports'> {
+    global?: boolean;
+    useExisting?: Type<JwtOptionsFactory>;
+    useClass?: Type<JwtOptionsFactory>;
+    useFactory?: (...args: any[]) => Promise<JwtModuleOptions> | JwtModuleOptions;
+    inject?: any[];
+    extraProviders?: Provider[];
+}
+export interface JwtSignOptions extends jwt.SignOptions {
+    secret?: string | Buffer;
+    privateKey?: jwt.Secret;
+}
+export interface JwtVerifyOptions extends jwt.VerifyOptions {
+    secret?: string | Buffer;
+    publicKey?: string | Buffer;
+}
+export type GetSecretKeyResult = string | Buffer | jwt.Secret;

backend/node_modules/@nestjs/jwt/dist/interfaces/jwt-module-options.interface.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JwtSecretRequestType = void 0;
+var JwtSecretRequestType;
+(function (JwtSecretRequestType) {
+    JwtSecretRequestType[JwtSecretRequestType["SIGN"] = 0] = "SIGN";
+    JwtSecretRequestType[JwtSecretRequestType["VERIFY"] = 1] = "VERIFY";
+})(JwtSecretRequestType || (exports.JwtSecretRequestType = JwtSecretRequestType = {}));

backend/node_modules/@nestjs/jwt/dist/jwt.constants.d.ts

@@ -0,0 +1 @@
+export declare const JWT_MODULE_OPTIONS = "JWT_MODULE_OPTIONS";

backend/node_modules/@nestjs/jwt/dist/jwt.constants.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JWT_MODULE_OPTIONS = void 0;
+exports.JWT_MODULE_OPTIONS = 'JWT_MODULE_OPTIONS';

backend/node_modules/@nestjs/jwt/dist/jwt.errors.d.ts

@@ -0,0 +1,2 @@
+export declare class WrongSecretProviderError extends Error {
+}

backend/node_modules/@nestjs/jwt/dist/jwt.errors.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WrongSecretProviderError = void 0;
+class WrongSecretProviderError extends Error {
+}
+exports.WrongSecretProviderError = WrongSecretProviderError;

backend/node_modules/@nestjs/jwt/dist/jwt.module.d.ts

@@ -0,0 +1,8 @@
+import { DynamicModule } from '@nestjs/common';
+import { JwtModuleAsyncOptions, JwtModuleOptions } from './interfaces/jwt-module-options.interface';
+export declare class JwtModule {
+    static register(options: JwtModuleOptions): DynamicModule;
+    static registerAsync(options: JwtModuleAsyncOptions): DynamicModule;
+    private static createAsyncProviders;
+    private static createAsyncOptionsProvider;
+}

backend/node_modules/@nestjs/jwt/dist/jwt.module.js

@@ -0,0 +1,67 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var JwtModule_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JwtModule = void 0;
+const common_1 = require("@nestjs/common");
+const jwt_constants_1 = require("./jwt.constants");
+const jwt_providers_1 = require("./jwt.providers");
+const jwt_service_1 = require("./jwt.service");
+let JwtModule = JwtModule_1 = class JwtModule {
+    static register(options) {
+        return {
+            module: JwtModule_1,
+            global: options.global,
+            providers: (0, jwt_providers_1.createJwtProvider)(options)
+        };
+    }
+    static registerAsync(options) {
+        return {
+            module: JwtModule_1,
+            global: options.global,
+            imports: options.imports || [],
+            providers: [
+                ...this.createAsyncProviders(options),
+                ...(options.extraProviders ?? [])
+            ]
+        };
+    }
+    static createAsyncProviders(options) {
+        if (options.useExisting || options.useFactory) {
+            return [this.createAsyncOptionsProvider(options)];
+        }
+        return [
+            this.createAsyncOptionsProvider(options),
+            {
+                provide: options.useClass,
+                useClass: options.useClass
+            }
+        ];
+    }
+    static createAsyncOptionsProvider(options) {
+        if (options.useFactory) {
+            return {
+                provide: jwt_constants_1.JWT_MODULE_OPTIONS,
+                useFactory: options.useFactory,
+                inject: options.inject || []
+            };
+        }
+        return {
+            provide: jwt_constants_1.JWT_MODULE_OPTIONS,
+            useFactory: async (optionsFactory) => await optionsFactory.createJwtOptions(),
+            inject: [options.useExisting || options.useClass]
+        };
+    }
+};
+exports.JwtModule = JwtModule;
+exports.JwtModule = JwtModule = JwtModule_1 = __decorate([
+    (0, common_1.Module)({
+        providers: [jwt_service_1.JwtService],
+        exports: [jwt_service_1.JwtService]
+    })
+], JwtModule);

backend/node_modules/@nestjs/jwt/dist/jwt.providers.d.ts

@@ -0,0 +1,2 @@
+import { JwtModuleOptions } from './interfaces/jwt-module-options.interface';
+export declare function createJwtProvider(options: JwtModuleOptions): any[];

backend/node_modules/@nestjs/jwt/dist/jwt.providers.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createJwtProvider = void 0;
+const jwt_constants_1 = require("./jwt.constants");
+function createJwtProvider(options) {
+    return [{ provide: jwt_constants_1.JWT_MODULE_OPTIONS, useValue: options || {} }];
+}
+exports.createJwtProvider = createJwtProvider;

backend/node_modules/@nestjs/jwt/dist/jwt.service.d.ts

@@ -0,0 +1,18 @@
+/// <reference types="node" />
+import * as jwt from 'jsonwebtoken';
+import { JwtModuleOptions, JwtSignOptions, JwtVerifyOptions } from './interfaces';
+export declare class JwtService {
+    private readonly options;
+    private readonly logger;
+    constructor(options?: JwtModuleOptions);
+    sign(payload: string, options?: Omit<JwtSignOptions, keyof jwt.SignOptions>): string;
+    sign(payload: Buffer | object, options?: JwtSignOptions): string;
+    signAsync(payload: string, options?: Omit<JwtSignOptions, keyof jwt.SignOptions>): Promise<string>;
+    signAsync(payload: Buffer | object, options?: JwtSignOptions): Promise<string>;
+    verify<T extends object = any>(token: string, options?: JwtVerifyOptions): T;
+    verifyAsync<T extends object = any>(token: string, options?: JwtVerifyOptions): Promise<T>;
+    decode<T = any>(token: string, options?: jwt.DecodeOptions): T;
+    private mergeJwtOptions;
+    private overrideSecretFromOptions;
+    private getSecretKey;
+}

backend/node_modules/@nestjs/jwt/dist/jwt.service.js

@@ -0,0 +1,125 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JwtService = void 0;
+const common_1 = require("@nestjs/common");
+const jwt = require("jsonwebtoken");
+const interfaces_1 = require("./interfaces");
+const jwt_constants_1 = require("./jwt.constants");
+const jwt_errors_1 = require("./jwt.errors");
+let JwtService = class JwtService {
+    constructor(options = {}) {
+        this.options = options;
+        this.logger = new common_1.Logger('JwtService');
+    }
+    sign(payload, options) {
+        const signOptions = this.mergeJwtOptions({ ...options }, 'signOptions');
+        const secret = this.getSecretKey(payload, options, 'privateKey', interfaces_1.JwtSecretRequestType.SIGN);
+        if (secret instanceof Promise) {
+            secret.catch(() => { });
+            this.logger.warn('For async version of "secretOrKeyProvider", please use "signAsync".');
+            throw new jwt_errors_1.WrongSecretProviderError();
+        }
+        const allowedSignOptKeys = ['secret', 'privateKey'];
+        const signOptKeys = Object.keys(signOptions);
+        if (typeof payload === 'string' &&
+            signOptKeys.some((k) => !allowedSignOptKeys.includes(k))) {
+            throw new Error('Payload as string is not allowed with the following sign options: ' +
+                signOptKeys.join(', '));
+        }
+        return jwt.sign(payload, secret, signOptions);
+    }
+    signAsync(payload, options) {
+        const signOptions = this.mergeJwtOptions({ ...options }, 'signOptions');
+        const secret = this.getSecretKey(payload, options, 'privateKey', interfaces_1.JwtSecretRequestType.SIGN);
+        const allowedSignOptKeys = ['secret', 'privateKey'];
+        const signOptKeys = Object.keys(signOptions);
+        if (typeof payload === 'string' &&
+            signOptKeys.some((k) => !allowedSignOptKeys.includes(k))) {
+            throw new Error('Payload as string is not allowed with the following sign options: ' +
+                signOptKeys.join(', '));
+        }
+        return new Promise((resolve, reject) => Promise.resolve()
+            .then(() => secret)
+            .then((scrt) => {
+            jwt.sign(payload, scrt, signOptions, (err, encoded) => err ? reject(err) : resolve(encoded));
+        }));
+    }
+    verify(token, options) {
+        const verifyOptions = this.mergeJwtOptions({ ...options }, 'verifyOptions');
+        const secret = this.getSecretKey(token, options, 'publicKey', interfaces_1.JwtSecretRequestType.VERIFY);
+        if (secret instanceof Promise) {
+            secret.catch(() => { });
+            this.logger.warn('For async version of "secretOrKeyProvider", please use "verifyAsync".');
+            throw new jwt_errors_1.WrongSecretProviderError();
+        }
+        return jwt.verify(token, secret, verifyOptions);
+    }
+    verifyAsync(token, options) {
+        const verifyOptions = this.mergeJwtOptions({ ...options }, 'verifyOptions');
+        const secret = this.getSecretKey(token, options, 'publicKey', interfaces_1.JwtSecretRequestType.VERIFY);
+        return new Promise((resolve, reject) => Promise.resolve()
+            .then(() => secret)
+            .then((scrt) => {
+            jwt.verify(token, scrt, verifyOptions, (err, decoded) => err ? reject(err) : resolve(decoded));
+        })
+            .catch(reject));
+    }
+    decode(token, options) {
+        return jwt.decode(token, options);
+    }
+    mergeJwtOptions(options, key) {
+        delete options.secret;
+        if (key === 'signOptions') {
+            delete options.privateKey;
+        }
+        else {
+            delete options.publicKey;
+        }
+        return options
+            ? {
+                ...(this.options[key] || {}),
+                ...options
+            }
+            : this.options[key];
+    }
+    overrideSecretFromOptions(secret) {
+        if (this.options.secretOrPrivateKey) {
+            this.logger.warn(`"secretOrPrivateKey" has been deprecated, please use the new explicit "secret" or use "secretOrKeyProvider" or "privateKey"/"publicKey" exclusively.`);
+            secret = this.options.secretOrPrivateKey;
+        }
+        return secret;
+    }
+    getSecretKey(token, options, key, secretRequestType) {
+        const secret = this.options.secretOrKeyProvider
+            ? this.options.secretOrKeyProvider(secretRequestType, token, options)
+            : options?.secret ||
+                this.options.secret ||
+                (key === 'privateKey'
+                    ? options?.privateKey || this.options.privateKey
+                    : options?.publicKey ||
+                        this.options.publicKey) ||
+                this.options[key];
+        return secret instanceof Promise
+            ? secret.then((sec) => this.overrideSecretFromOptions(sec))
+            : this.overrideSecretFromOptions(secret);
+    }
+};
+exports.JwtService = JwtService;
+exports.JwtService = JwtService = __decorate([
+    (0, common_1.Injectable)(),
+    __param(0, (0, common_1.Optional)()),
+    __param(0, (0, common_1.Inject)(jwt_constants_1.JWT_MODULE_OPTIONS)),
+    __metadata("design:paramtypes", [Object])
+], JwtService);