🎯 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/class-validator/cjs/metadata/ConstraintMetadata.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConstraintMetadata = void 0;
+const container_1 = require("../container");
+/**
+ * This metadata interface contains information for custom validators.
+ */
+class ConstraintMetadata {
+    // -------------------------------------------------------------------------
+    // Constructor
+    // -------------------------------------------------------------------------
+    constructor(target, name, async = false) {
+        this.target = target;
+        this.name = name;
+        this.async = async;
+    }
+    // -------------------------------------------------------------------------
+    // Accessors
+    // -------------------------------------------------------------------------
+    /**
+     * Instance of the target custom validation class which performs validation.
+     */
+    get instance() {
+        return (0, container_1.getFromContainer)(this.target);
+    }
+}
+exports.ConstraintMetadata = ConstraintMetadata;
+//# sourceMappingURL=ConstraintMetadata.js.map

backend/node_modules/class-validator/cjs/metadata/ConstraintMetadata.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ConstraintMetadata.js","sourceRoot":"","sources":["../../../src/metadata/ConstraintMetadata.ts"],"names":[],"mappings":";;;AACA,4CAAgD;AAEhD;;GAEG;AACH,MAAa,kBAAkB;IAoB7B,4EAA4E;IAC5E,cAAc;IACd,4EAA4E;IAE5E,YAAY,MAAgB,EAAE,IAAa,EAAE,QAAiB,KAAK;QACjE,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC;QACrB,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC;QACjB,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC;IACrB,CAAC;IAED,4EAA4E;IAC5E,YAAY;IACZ,4EAA4E;IAE5E;;OAEG;IACH,IAAI,QAAQ;QACV,OAAO,IAAA,4BAAgB,EAA+B,IAAI,CAAC,MAAM,CAAC,CAAC;IACrE,CAAC;CACF;AAxCD,gDAwCC","sourcesContent":["import { ValidatorConstraintInterface } from '../validation/ValidatorConstraintInterface';\nimport { getFromContainer } from '../container';\n\n/**\n * This metadata interface contains information for custom validators.\n */\nexport class ConstraintMetadata {\n  // -------------------------------------------------------------------------\n  // Properties\n  // -------------------------------------------------------------------------\n\n  /**\n   * Target class which performs validation.\n   */\n  target: Function;\n\n  /**\n   * Custom validation's name, that will be used as validation error type.\n   */\n  name: string;\n\n  /**\n   * Indicates if this validation is asynchronous or not.\n   */\n  async: boolean;\n\n  // -------------------------------------------------------------------------\n  // Constructor\n  // -------------------------------------------------------------------------\n\n  constructor(target: Function, name?: string, async: boolean = false) {\n    this.target = target;\n    this.name = name;\n    this.async = async;\n  }\n\n  // -------------------------------------------------------------------------\n  // Accessors\n  // -------------------------------------------------------------------------\n\n  /**\n   * Instance of the target custom validation class which performs validation.\n   */\n  get instance(): ValidatorConstraintInterface {\n    return getFromContainer<ValidatorConstraintInterface>(this.target);\n  }\n}\n"]}

backend/node_modules/class-validator/cjs/metadata/MetadataStorage.js

@@ -0,0 +1,156 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getMetadataStorage = exports.MetadataStorage = void 0;
+const ValidationSchemaToMetadataTransformer_1 = require("../validation-schema/ValidationSchemaToMetadataTransformer");
+const utils_1 = require("../utils");
+/**
+ * Storage all metadatas.
+ */
+class MetadataStorage {
+    constructor() {
+        // -------------------------------------------------------------------------
+        // Private properties
+        // -------------------------------------------------------------------------
+        this.validationMetadatas = new Map();
+        this.constraintMetadatas = new Map();
+    }
+    get hasValidationMetaData() {
+        return !!this.validationMetadatas.size;
+    }
+    // -------------------------------------------------------------------------
+    // Public Methods
+    // -------------------------------------------------------------------------
+    /**
+     * Adds a new validation metadata.
+     */
+    addValidationSchema(schema) {
+        const validationMetadatas = new ValidationSchemaToMetadataTransformer_1.ValidationSchemaToMetadataTransformer().transform(schema);
+        validationMetadatas.forEach(validationMetadata => this.addValidationMetadata(validationMetadata));
+    }
+    /**
+     * Adds a new validation metadata.
+     */
+    addValidationMetadata(metadata) {
+        const existingMetadata = this.validationMetadatas.get(metadata.target);
+        if (existingMetadata) {
+            existingMetadata.push(metadata);
+        }
+        else {
+            this.validationMetadatas.set(metadata.target, [metadata]);
+        }
+    }
+    /**
+     * Adds a new constraint metadata.
+     */
+    addConstraintMetadata(metadata) {
+        const existingMetadata = this.constraintMetadatas.get(metadata.target);
+        if (existingMetadata) {
+            existingMetadata.push(metadata);
+        }
+        else {
+            this.constraintMetadatas.set(metadata.target, [metadata]);
+        }
+    }
+    /**
+     * Groups metadata by their property names.
+     */
+    groupByPropertyName(metadata) {
+        const grouped = {};
+        metadata.forEach(metadata => {
+            if (!grouped[metadata.propertyName])
+                grouped[metadata.propertyName] = [];
+            grouped[metadata.propertyName].push(metadata);
+        });
+        return grouped;
+    }
+    /**
+     * Gets all validation metadatas for the given object with the given groups.
+     */
+    getTargetValidationMetadatas(targetConstructor, targetSchema, always, strictGroups, groups) {
+        const includeMetadataBecauseOfAlwaysOption = (metadata) => {
+            // `metadata.always` overrides global default.
+            if (typeof metadata.always !== 'undefined')
+                return metadata.always;
+            // `metadata.groups` overrides global default.
+            if (metadata.groups && metadata.groups.length)
+                return false;
+            // Use global default.
+            return always;
+        };
+        const excludeMetadataBecauseOfStrictGroupsOption = (metadata) => {
+            if (strictGroups) {
+                // Validation is not using groups.
+                if (!groups || !groups.length) {
+                    // `metadata.groups` has at least one group.
+                    if (metadata.groups && metadata.groups.length)
+                        return true;
+                }
+            }
+            return false;
+        };
+        // get directly related to a target metadatas
+        const filteredForOriginalMetadatasSearch = this.validationMetadatas.get(targetConstructor) || [];
+        const originalMetadatas = filteredForOriginalMetadatasSearch.filter(metadata => {
+            if (metadata.target !== targetConstructor && metadata.target !== targetSchema)
+                return false;
+            if (includeMetadataBecauseOfAlwaysOption(metadata))
+                return true;
+            if (excludeMetadataBecauseOfStrictGroupsOption(metadata))
+                return false;
+            if (groups && groups.length > 0)
+                return metadata.groups && !!metadata.groups.find(group => groups.indexOf(group) !== -1);
+            return true;
+        });
+        // get metadatas for inherited classes
+        const filteredForInheritedMetadatasSearch = [];
+        for (const [key, value] of this.validationMetadatas.entries()) {
+            if (targetConstructor.prototype instanceof key) {
+                filteredForInheritedMetadatasSearch.push(...value);
+            }
+        }
+        const inheritedMetadatas = filteredForInheritedMetadatasSearch.filter(metadata => {
+            // if target is a string it's means we validate against a schema, and there is no inheritance support for schemas
+            if (typeof metadata.target === 'string')
+                return false;
+            if (metadata.target === targetConstructor)
+                return false;
+            if (metadata.target instanceof Function && !(targetConstructor.prototype instanceof metadata.target))
+                return false;
+            if (includeMetadataBecauseOfAlwaysOption(metadata))
+                return true;
+            if (excludeMetadataBecauseOfStrictGroupsOption(metadata))
+                return false;
+            if (groups && groups.length > 0)
+                return metadata.groups && !!metadata.groups.find(group => groups.indexOf(group) !== -1);
+            return true;
+        });
+        // filter out duplicate metadatas, prefer original metadatas instead of inherited metadatas
+        const uniqueInheritedMetadatas = inheritedMetadatas.filter(inheritedMetadata => {
+            return !originalMetadatas.find(originalMetadata => {
+                return (originalMetadata.propertyName === inheritedMetadata.propertyName &&
+                    originalMetadata.type === inheritedMetadata.type);
+            });
+        });
+        return originalMetadatas.concat(uniqueInheritedMetadatas);
+    }
+    /**
+     * Gets all validator constraints for the given object.
+     */
+    getTargetValidatorConstraints(target) {
+        return this.constraintMetadatas.get(target) || [];
+    }
+}
+exports.MetadataStorage = MetadataStorage;
+/**
+ * Gets metadata storage.
+ * Metadata storage follows the best practices and stores metadata in a global variable.
+ */
+function getMetadataStorage() {
+    const global = (0, utils_1.getGlobal)();
+    if (!global.classValidatorMetadataStorage) {
+        global.classValidatorMetadataStorage = new MetadataStorage();
+    }
+    return global.classValidatorMetadataStorage;
+}
+exports.getMetadataStorage = getMetadataStorage;
+//# sourceMappingURL=MetadataStorage.js.map

backend/node_modules/class-validator/cjs/metadata/ValidationMetadata.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ValidationMetadata = void 0;
+/**
+ * This metadata contains validation rules.
+ */
+class ValidationMetadata {
+    // -------------------------------------------------------------------------
+    // Constructor
+    // -------------------------------------------------------------------------
+    constructor(args) {
+        /**
+         * Validation groups used for this validation.
+         */
+        this.groups = [];
+        /**
+         * Specifies if validated value is an array and each of its item must be validated.
+         */
+        this.each = false;
+        /*
+         * A transient set of data passed through to the validation result for response mapping
+         */
+        this.context = undefined;
+        this.type = args.type;
+        this.name = args.name;
+        this.target = args.target;
+        this.propertyName = args.propertyName;
+        this.constraints = args === null || args === void 0 ? void 0 : args.constraints;
+        this.constraintCls = args.constraintCls;
+        this.validationTypeOptions = args.validationTypeOptions;
+        if (args.validationOptions) {
+            this.message = args.validationOptions.message;
+            this.groups = args.validationOptions.groups;
+            this.always = args.validationOptions.always;
+            this.each = args.validationOptions.each;
+            this.context = args.validationOptions.context;
+        }
+    }
+}
+exports.ValidationMetadata = ValidationMetadata;
+//# sourceMappingURL=ValidationMetadata.js.map

backend/node_modules/class-validator/cjs/metadata/ValidationMetadata.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ValidationMetadata.js","sourceRoot":"","sources":["../../../src/metadata/ValidationMetadata.ts"],"names":[],"mappings":";;;AAGA;;GAEG;AACH,MAAa,kBAAkB;IAiE7B,4EAA4E;IAC5E,cAAc;IACd,4EAA4E;IAE5E,YAAY,IAA4B;QA7BxC;;WAEG;QACH,WAAM,GAAa,EAAE,CAAC;QAOtB;;WAEG;QACH,SAAI,GAAY,KAAK,CAAC;QAEtB;;WAEG;QACH,YAAO,GAAS,SAAS,CAAC;QAYxB,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC,IAAI,CAAC;QACtB,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC,IAAI,CAAC;QACtB,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC,MAAM,CAAC;QAC1B,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC,YAAY,CAAC;QACtC,IAAI,CAAC,WAAW,GAAG,IAAI,aAAJ,IAAI,uBAAJ,IAAI,CAAE,WAAW,CAAC;QACrC,IAAI,CAAC,aAAa,GAAG,IAAI,CAAC,aAAa,CAAC;QACxC,IAAI,CAAC,qBAAqB,GAAG,IAAI,CAAC,qBAAqB,CAAC;QACxD,IAAI,IAAI,CAAC,iBAAiB,EAAE,CAAC;YAC3B,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC,iBAAiB,CAAC,OAAO,CAAC;YAC9C,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC,iBAAiB,CAAC,MAAM,CAAC;YAC5C,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC,iBAAiB,CAAC,MAAM,CAAC;YAC5C,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC,iBAAiB,CAAC,IAAI,CAAC;YACxC,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC,iBAAiB,CAAC,OAAO,CAAC;QAChD,CAAC;IACH,CAAC;CACF;AArFD,gDAqFC","sourcesContent":["import { ValidationMetadataArgs } from './ValidationMetadataArgs';\nimport { ValidationArguments } from '../validation/ValidationArguments';\n\n/**\n * This metadata contains validation rules.\n */\nexport class ValidationMetadata {\n  // -------------------------------------------------------------------------\n  // Properties\n  // -------------------------------------------------------------------------\n\n  /**\n   * Validation type.\n   */\n  type: string;\n\n  /**\n   * Validator name.\n   */\n  name?: string;\n\n  /**\n   * Target class to which this validation is applied.\n   */\n  target: Function | string;\n\n  /**\n   * Property of the object to be validated.\n   */\n  propertyName: string;\n\n  /**\n   * Constraint class that performs validation. Used only for custom validations.\n   */\n  constraintCls: Function;\n\n  /**\n   * Array of constraints of this validation.\n   */\n  constraints: any[];\n\n  /**\n   * Validation message to be shown in the case of error.\n   */\n  message: string | ((args: ValidationArguments) => string);\n\n  /**\n   * Validation groups used for this validation.\n   */\n  groups: string[] = [];\n\n  /**\n   * Indicates if validation must be performed always, no matter of validation groups used.\n   */\n  always?: boolean;\n\n  /**\n   * Specifies if validated value is an array and each of its item must be validated.\n   */\n  each: boolean = false;\n\n  /*\n   * A transient set of data passed through to the validation result for response mapping\n   */\n  context?: any = undefined;\n\n  /**\n   * Extra options specific to validation type.\n   */\n  validationTypeOptions: any;\n\n  // -------------------------------------------------------------------------\n  // Constructor\n  // -------------------------------------------------------------------------\n\n  constructor(args: ValidationMetadataArgs) {\n    this.type = args.type;\n    this.name = args.name;\n    this.target = args.target;\n    this.propertyName = args.propertyName;\n    this.constraints = args?.constraints;\n    this.constraintCls = args.constraintCls;\n    this.validationTypeOptions = args.validationTypeOptions;\n    if (args.validationOptions) {\n      this.message = args.validationOptions.message;\n      this.groups = args.validationOptions.groups;\n      this.always = args.validationOptions.always;\n      this.each = args.validationOptions.each;\n      this.context = args.validationOptions.context;\n    }\n  }\n}\n"]}

backend/node_modules/class-validator/cjs/metadata/ValidationMetadataArgs.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=ValidationMetadataArgs.js.map

backend/node_modules/class-validator/cjs/metadata/ValidationMetadataArgs.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ValidationMetadataArgs.js","sourceRoot":"","sources":["../../../src/metadata/ValidationMetadataArgs.ts"],"names":[],"mappings":"","sourcesContent":["import { ValidationOptions } from '../decorator/ValidationOptions';\n\n/**\n * Constructor arguments for ValidationMetadata class.\n */\nexport interface ValidationMetadataArgs {\n  /**\n   * Validation type.\n   */\n  type: string;\n\n  /**\n   * Validator name.\n   */\n  name?: string;\n\n  /**\n   * Object that is used to be validated.\n   */\n  target: Function | string;\n\n  /**\n   * Property of the object to be validated.\n   */\n  propertyName: string;\n\n  /**\n   * Constraint class that performs validation. Used only for custom validations.\n   */\n  constraintCls?: Function;\n\n  /**\n   * Array of constraints of this validation.\n   */\n  constraints?: any[];\n\n  /**\n   * Validation options.\n   */\n  validationOptions?: ValidationOptions;\n\n  /**\n   * Extra options specific to validation type.\n   */\n  validationTypeOptions?: any;\n}\n"]}