🎯 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/passport/dist/abstract.strategy.d.ts

@@ -0,0 +1,3 @@
+export declare abstract class AbstractStrategy {
+    abstract validate(...args: any[]): any;
+}

backend/node_modules/@nestjs/passport/dist/abstract.strategy.js

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

backend/node_modules/@nestjs/passport/dist/auth.guard.d.ts

@@ -0,0 +1,12 @@
+import { CanActivate, ExecutionContext } from '@nestjs/common';
+import { Type } from './interfaces';
+import { IAuthModuleOptions } from './interfaces/auth-module.options';
+export type IAuthGuard = CanActivate & {
+    logIn<TRequest extends {
+        logIn: Function;
+    } = any>(request: TRequest): Promise<void>;
+    handleRequest<TUser = any>(err: any, user: any, info: any, context: ExecutionContext, status?: any): TUser;
+    getAuthenticateOptions(context: ExecutionContext): IAuthModuleOptions | undefined;
+    getRequest(context: ExecutionContext): any;
+};
+export declare const AuthGuard: (type?: string | string[]) => Type<IAuthGuard>;

backend/node_modules/@nestjs/passport/dist/auth.guard.js

@@ -0,0 +1,88 @@
+"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.AuthGuard = void 0;
+const common_1 = require("@nestjs/common");
+const passport = require("passport");
+const auth_module_options_1 = require("./interfaces/auth-module.options");
+const options_1 = require("./options");
+const memoize_util_1 = require("./utils/memoize.util");
+exports.AuthGuard = (0, memoize_util_1.memoize)(createAuthGuard);
+const NO_STRATEGY_ERROR = `In order to use "defaultStrategy", please, ensure to import PassportModule in each place where AuthGuard() is being used. Otherwise, passport won't work correctly.`;
+const authLogger = new common_1.Logger('AuthGuard');
+function createAuthGuard(type) {
+    let MixinAuthGuard = class MixinAuthGuard {
+        constructor(options) {
+            this.options = {};
+            this.options = options ?? this.options;
+            if (!type && !this.options.defaultStrategy) {
+                authLogger.error(NO_STRATEGY_ERROR);
+            }
+        }
+        async canActivate(context) {
+            const options = {
+                ...options_1.defaultOptions,
+                ...this.options,
+                ...(await this.getAuthenticateOptions(context))
+            };
+            const [request, response] = [
+                this.getRequest(context),
+                this.getResponse(context)
+            ];
+            const passportFn = createPassportContext(request, response);
+            const user = await passportFn(type || this.options.defaultStrategy, options, (err, user, info, status) => this.handleRequest(err, user, info, context, status));
+            request[options.property || options_1.defaultOptions.property] = user;
+            return true;
+        }
+        getRequest(context) {
+            return context.switchToHttp().getRequest();
+        }
+        getResponse(context) {
+            return context.switchToHttp().getResponse();
+        }
+        async logIn(request) {
+            const user = request[this.options.property || options_1.defaultOptions.property];
+            await new Promise((resolve, reject) => request.logIn(user, this.options, (err) => err ? reject(err) : resolve()));
+        }
+        handleRequest(err, user, info, context, status) {
+            if (err || !user) {
+                throw err || new common_1.UnauthorizedException();
+            }
+            return user;
+        }
+        getAuthenticateOptions(context) {
+            return undefined;
+        }
+    };
+    __decorate([
+        (0, common_1.Optional)(),
+        (0, common_1.Inject)(auth_module_options_1.AuthModuleOptions),
+        __metadata("design:type", auth_module_options_1.AuthModuleOptions)
+    ], MixinAuthGuard.prototype, "options", void 0);
+    MixinAuthGuard = __decorate([
+        __param(0, (0, common_1.Optional)()),
+        __metadata("design:paramtypes", [auth_module_options_1.AuthModuleOptions])
+    ], MixinAuthGuard);
+    const guard = (0, common_1.mixin)(MixinAuthGuard);
+    return guard;
+}
+const createPassportContext = (request, response) => (type, options, callback) => new Promise((resolve, reject) => passport.authenticate(type, options, (err, user, info, status) => {
+    try {
+        request.authInfo = info;
+        return resolve(callback(err, user, info, status));
+    }
+    catch (err) {
+        reject(err);
+    }
+})(request, response, (err) => (err ? reject(err) : resolve())));

backend/node_modules/@nestjs/passport/dist/index.d.ts

@@ -0,0 +1,6 @@
+export * from './abstract.strategy';
+export * from './auth.guard';
+export * from './interfaces';
+export * from './passport.module';
+export * from './passport/passport.serializer';
+export * from './passport/passport.strategy';

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

@@ -0,0 +1,22 @@
+"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("./abstract.strategy"), exports);
+__exportStar(require("./auth.guard"), exports);
+__exportStar(require("./interfaces"), exports);
+__exportStar(require("./passport.module"), exports);
+__exportStar(require("./passport/passport.serializer"), exports);
+__exportStar(require("./passport/passport.strategy"), exports);

backend/node_modules/@nestjs/passport/dist/interfaces/auth-module.options.d.ts

@@ -0,0 +1,21 @@
+import { ModuleMetadata, Type } from '@nestjs/common';
+export interface IAuthModuleOptions<T = any> {
+    defaultStrategy?: string | string[];
+    session?: boolean;
+    property?: string;
+    [key: string]: any;
+}
+export interface AuthOptionsFactory {
+    createAuthOptions(): Promise<IAuthModuleOptions> | IAuthModuleOptions;
+}
+export interface AuthModuleAsyncOptions extends Pick<ModuleMetadata, 'imports'> {
+    useExisting?: Type<AuthOptionsFactory>;
+    useClass?: Type<AuthOptionsFactory>;
+    useFactory?: (...args: any[]) => Promise<IAuthModuleOptions> | IAuthModuleOptions;
+    inject?: any[];
+}
+export declare class AuthModuleOptions implements IAuthModuleOptions {
+    defaultStrategy?: string | string[];
+    session?: boolean;
+    property?: string;
+}

backend/node_modules/@nestjs/passport/dist/interfaces/auth-module.options.js

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

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

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

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

@@ -0,0 +1,18 @@
+"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("./auth-module.options"), exports);
+__exportStar(require("./type.interface"), exports);

backend/node_modules/@nestjs/passport/dist/interfaces/type.interface.d.ts

@@ -0,0 +1,3 @@
+export interface Type<T = any> extends Function {
+    new (...args: any[]): T;
+}

backend/node_modules/@nestjs/passport/dist/interfaces/type.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

backend/node_modules/@nestjs/passport/dist/options.d.ts

@@ -0,0 +1,4 @@
+export declare const defaultOptions: {
+    session: boolean;
+    property: string;
+};

backend/node_modules/@nestjs/passport/dist/options.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultOptions = void 0;
+exports.defaultOptions = {
+    session: false,
+    property: 'user'
+};

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

@@ -0,0 +1,8 @@
+import { DynamicModule } from '@nestjs/common';
+import { AuthModuleAsyncOptions, IAuthModuleOptions } from './interfaces/auth-module.options';
+export declare class PassportModule {
+    static register(options: IAuthModuleOptions): DynamicModule;
+    static registerAsync(options: AuthModuleAsyncOptions): DynamicModule;
+    private static createAsyncProviders;
+    private static createAsyncOptionsProvider;
+}

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

@@ -0,0 +1,58 @@
+"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 PassportModule_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PassportModule = void 0;
+const common_1 = require("@nestjs/common");
+const auth_module_options_1 = require("./interfaces/auth-module.options");
+let PassportModule = exports.PassportModule = PassportModule_1 = class PassportModule {
+    static register(options) {
+        return {
+            module: PassportModule_1,
+            providers: [{ provide: auth_module_options_1.AuthModuleOptions, useValue: options }],
+            exports: [auth_module_options_1.AuthModuleOptions]
+        };
+    }
+    static registerAsync(options) {
+        return {
+            module: PassportModule_1,
+            imports: options.imports || [],
+            providers: this.createAsyncProviders(options),
+            exports: [auth_module_options_1.AuthModuleOptions]
+        };
+    }
+    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: auth_module_options_1.AuthModuleOptions,
+                useFactory: options.useFactory,
+                inject: options.inject || []
+            };
+        }
+        return {
+            provide: auth_module_options_1.AuthModuleOptions,
+            useFactory: async (optionsFactory) => await optionsFactory.createAuthOptions(),
+            inject: [options.useExisting || options.useClass]
+        };
+    }
+};
+exports.PassportModule = PassportModule = PassportModule_1 = __decorate([
+    (0, common_1.Module)({})
+], PassportModule);

backend/node_modules/@nestjs/passport/dist/passport/passport.serializer.d.ts

@@ -0,0 +1,7 @@
+import * as passport from 'passport';
+export declare abstract class PassportSerializer {
+    abstract serializeUser(user: any, done: Function): any;
+    abstract deserializeUser(payload: any, done: Function): any;
+    constructor();
+    getPassportInstance(): passport.PassportStatic;
+}

backend/node_modules/@nestjs/passport/dist/passport/passport.serializer.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PassportSerializer = void 0;
+const passport = require("passport");
+class PassportSerializer {
+    constructor() {
+        const passportInstance = this.getPassportInstance();
+        passportInstance.serializeUser((user, done) => this.serializeUser(user, done));
+        passportInstance.deserializeUser((payload, done) => this.deserializeUser(payload, done));
+    }
+    getPassportInstance() {
+        return passport;
+    }
+}
+exports.PassportSerializer = PassportSerializer;

backend/node_modules/@nestjs/passport/dist/passport/passport.strategy.d.ts

@@ -0,0 +1,4 @@
+import { Type } from '../interfaces';
+export declare function PassportStrategy<T extends Type<any> = any>(Strategy: T, name?: string | undefined, callbackArity?: true | number): {
+    new (...args: any[]): InstanceType<T>;
+};

backend/node_modules/@nestjs/passport/dist/passport/passport.strategy.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PassportStrategy = void 0;
+const passport = require("passport");
+function PassportStrategy(Strategy, name, callbackArity) {
+    class MixinStrategy extends Strategy {
+        constructor(...args) {
+            const callback = async (...params) => {
+                const done = params[params.length - 1];
+                try {
+                    const validateResult = await this.validate(...params);
+                    if (Array.isArray(validateResult)) {
+                        done(null, ...validateResult);
+                    }
+                    else {
+                        done(null, validateResult);
+                    }
+                }
+                catch (err) {
+                    done(err, null);
+                }
+            };
+            if (callbackArity !== undefined) {
+                const validate = new.target?.prototype?.validate;
+                const arity = callbackArity === true ? validate.length + 1 : callbackArity;
+                if (validate) {
+                    Object.defineProperty(callback, 'length', {
+                        value: arity
+                    });
+                }
+            }
+            super(...args, callback);
+            const passportInstance = this.getPassportInstance();
+            if (name) {
+                passportInstance.use(name, this);
+            }
+            else {
+                passportInstance.use(this);
+            }
+        }
+        getPassportInstance() {
+            return passport;
+        }
+    }
+    return MixinStrategy;
+}
+exports.PassportStrategy = PassportStrategy;

backend/node_modules/@nestjs/passport/dist/utils/memoize.util.d.ts

@@ -0,0 +1 @@
+export declare function memoize(fn: Function): (...args: any[]) => any;

backend/node_modules/@nestjs/passport/dist/utils/memoize.util.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.memoize = void 0;
+const defaultKey = 'default';
+function memoize(fn) {
+    const cache = {};
+    return (...args) => {
+        const n = args[0] || defaultKey;
+        if (n in cache) {
+            return cache[n];
+        }
+        else {
+            const result = fn(n === defaultKey ? undefined : n);
+            cache[n] = result;
+            return result;
+        }
+    };
+}
+exports.memoize = memoize;