🎯 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/fork-ts-checker-webpack-plugin/lib/issue/index.d.ts

@@ -0,0 +1,3 @@
+export * from './issue';
+export * from './issue-severity';
+export * from './issue-location';

backend/node_modules/fork-ts-checker-webpack-plugin/lib/issue/index.js

@@ -0,0 +1,15 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (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("./issue"), exports);
+__exportStar(require("./issue-severity"), exports);
+__exportStar(require("./issue-location"), exports);

backend/node_modules/fork-ts-checker-webpack-plugin/lib/issue/issue-config.d.ts

@@ -0,0 +1,8 @@
+import type * as webpack from 'webpack';
+import type { IssueOptions } from './issue-options';
+import type { IssuePredicate } from './issue-predicate';
+interface IssueConfig {
+    predicate: IssuePredicate;
+}
+declare function createIssueConfig(compiler: webpack.Compiler, options: IssueOptions | undefined): IssueConfig;
+export { IssueConfig, createIssueConfig };

backend/node_modules/fork-ts-checker-webpack-plugin/lib/issue/issue-config.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createIssueConfig = void 0;
+const issue_match_1 = require("./issue-match");
+const issue_predicate_1 = require("./issue-predicate");
+function createIssuePredicateFromOption(context, option) {
+    if (Array.isArray(option)) {
+        return (0, issue_predicate_1.composeIssuePredicates)(option.map((option) => typeof option === 'function' ? option : (0, issue_match_1.createIssuePredicateFromIssueMatch)(context, option)));
+    }
+    return typeof option === 'function'
+        ? option
+        : (0, issue_match_1.createIssuePredicateFromIssueMatch)(context, option);
+}
+function createIssueConfig(compiler, options) {
+    const context = compiler.options.context || process.cwd();
+    if (!options) {
+        options = {};
+    }
+    const include = options.include
+        ? createIssuePredicateFromOption(context, options.include)
+        : (0, issue_predicate_1.createTrivialIssuePredicate)(true);
+    const exclude = options.exclude
+        ? createIssuePredicateFromOption(context, options.exclude)
+        : (0, issue_predicate_1.createTrivialIssuePredicate)(false);
+    return {
+        predicate: (issue) => include(issue) && !exclude(issue),
+    };
+}
+exports.createIssueConfig = createIssueConfig;

backend/node_modules/fork-ts-checker-webpack-plugin/lib/issue/issue-location.d.ts

@@ -0,0 +1,8 @@
+import type { IssuePosition } from './issue-position';
+interface IssueLocation {
+    start: IssuePosition;
+    end: IssuePosition;
+}
+declare function compareIssueLocations(locationA?: IssueLocation, locationB?: IssueLocation): number;
+declare function formatIssueLocation(location: IssueLocation): string;
+export { IssueLocation, compareIssueLocations, formatIssueLocation };

backend/node_modules/fork-ts-checker-webpack-plugin/lib/issue/issue-location.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatIssueLocation = exports.compareIssueLocations = void 0;
+const issue_position_1 = require("./issue-position");
+function compareIssueLocations(locationA, locationB) {
+    if (locationA === locationB) {
+        return 0;
+    }
+    if (!locationA) {
+        return -1;
+    }
+    if (!locationB) {
+        return 1;
+    }
+    return ((0, issue_position_1.compareIssuePositions)(locationA.start, locationB.start) ||
+        (0, issue_position_1.compareIssuePositions)(locationA.end, locationB.end));
+}
+exports.compareIssueLocations = compareIssueLocations;
+function formatIssueLocation(location) {
+    return `${location.start.line}:${location.start.column}`;
+}
+exports.formatIssueLocation = formatIssueLocation;

backend/node_modules/fork-ts-checker-webpack-plugin/lib/issue/issue-match.d.ts

@@ -0,0 +1,5 @@
+import type { IssuePredicate } from './issue-predicate';
+import type { Issue } from './index';
+declare type IssueMatch = Partial<Pick<Issue, 'severity' | 'code' | 'file'>>;
+declare function createIssuePredicateFromIssueMatch(context: string, match: IssueMatch): IssuePredicate;
+export { IssueMatch, createIssuePredicateFromIssueMatch };

backend/node_modules/fork-ts-checker-webpack-plugin/lib/issue/issue-match.js

@@ -0,0 +1,20 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createIssuePredicateFromIssueMatch = void 0;
+const path_1 = __importDefault(require("path"));
+const minimatch_1 = __importDefault(require("minimatch"));
+const forward_slash_1 = require("../utils/path/forward-slash");
+function createIssuePredicateFromIssueMatch(context, match) {
+    return (issue) => {
+        const matchesSeverity = !match.severity || match.severity === issue.severity;
+        const matchesCode = !match.code || match.code === issue.code;
+        const matchesFile = !issue.file ||
+            (!!issue.file &&
+                (!match.file || (0, minimatch_1.default)((0, forward_slash_1.forwardSlash)(path_1.default.relative(context, issue.file)), match.file)));
+        return matchesSeverity && matchesCode && matchesFile;
+    };
+}
+exports.createIssuePredicateFromIssueMatch = createIssuePredicateFromIssueMatch;

backend/node_modules/fork-ts-checker-webpack-plugin/lib/issue/issue-options.d.ts

@@ -0,0 +1,8 @@
+import type { IssueMatch } from './issue-match';
+import type { IssuePredicate } from './issue-predicate';
+declare type IssuePredicateOption = IssuePredicate | IssueMatch | (IssuePredicate | IssueMatch)[];
+interface IssueOptions {
+    include?: IssuePredicateOption;
+    exclude?: IssuePredicateOption;
+}
+export { IssueOptions, IssuePredicateOption };

backend/node_modules/fork-ts-checker-webpack-plugin/lib/issue/issue-options.js

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

backend/node_modules/fork-ts-checker-webpack-plugin/lib/issue/issue-position.d.ts

@@ -0,0 +1,6 @@
+interface IssuePosition {
+    line: number;
+    column: number;
+}
+declare function compareIssuePositions(positionA?: IssuePosition, positionB?: IssuePosition): number;
+export { IssuePosition, compareIssuePositions };

backend/node_modules/fork-ts-checker-webpack-plugin/lib/issue/issue-position.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compareIssuePositions = void 0;
+function compareIssuePositions(positionA, positionB) {
+    if (positionA === positionB) {
+        return 0;
+    }
+    if (!positionA) {
+        return -1;
+    }
+    if (!positionB) {
+        return 1;
+    }
+    return (Math.sign(positionA.line - positionB.line) || Math.sign(positionA.column - positionB.column));
+}
+exports.compareIssuePositions = compareIssuePositions;

backend/node_modules/fork-ts-checker-webpack-plugin/lib/issue/issue-predicate.d.ts

@@ -0,0 +1,5 @@
+import type { Issue } from './index';
+declare type IssuePredicate = (issue: Issue) => boolean;
+declare function createTrivialIssuePredicate(result: boolean): IssuePredicate;
+declare function composeIssuePredicates(predicates: IssuePredicate[]): IssuePredicate;
+export { IssuePredicate, createTrivialIssuePredicate, composeIssuePredicates };

backend/node_modules/fork-ts-checker-webpack-plugin/lib/issue/issue-predicate.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.composeIssuePredicates = exports.createTrivialIssuePredicate = void 0;
+function createTrivialIssuePredicate(result) {
+    return () => result;
+}
+exports.createTrivialIssuePredicate = createTrivialIssuePredicate;
+function composeIssuePredicates(predicates) {
+    return (issue) => predicates.some((predicate) => predicate(issue));
+}
+exports.composeIssuePredicates = composeIssuePredicates;

backend/node_modules/fork-ts-checker-webpack-plugin/lib/issue/issue-severity.d.ts

@@ -0,0 +1,4 @@
+declare type IssueSeverity = 'error' | 'warning';
+declare function isIssueSeverity(value: unknown): value is IssueSeverity;
+declare function compareIssueSeverities(severityA: IssueSeverity, severityB: IssueSeverity): number;
+export { IssueSeverity, isIssueSeverity, compareIssueSeverities };

backend/node_modules/fork-ts-checker-webpack-plugin/lib/issue/issue-severity.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compareIssueSeverities = exports.isIssueSeverity = void 0;
+function isIssueSeverity(value) {
+    return ['error', 'warning'].includes(value);
+}
+exports.isIssueSeverity = isIssueSeverity;
+function compareIssueSeverities(severityA, severityB) {
+    const [priorityA, priorityB] = [severityA, severityB].map((severity) => ['warning' /* 0 */, 'error' /* 1 */].indexOf(severity));
+    return Math.sign(priorityB - priorityA);
+}
+exports.compareIssueSeverities = compareIssueSeverities;

backend/node_modules/fork-ts-checker-webpack-plugin/lib/issue/issue-webpack-error.d.ts

@@ -0,0 +1,9 @@
+import * as webpack from 'webpack';
+import type { FormatterPathType } from '../formatter';
+import type { Issue } from './issue';
+declare class IssueWebpackError extends webpack.WebpackError {
+    readonly issue: Issue;
+    readonly hideStack = true;
+    constructor(message: string, pathType: FormatterPathType, issue: Issue);
+}
+export { IssueWebpackError };

backend/node_modules/fork-ts-checker-webpack-plugin/lib/issue/issue-webpack-error.js

@@ -0,0 +1,51 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IssueWebpackError = void 0;
+const path_1 = __importDefault(require("path"));
+const webpack = __importStar(require("webpack"));
+const forward_slash_1 = require("../utils/path/forward-slash");
+const relative_to_context_1 = require("../utils/path/relative-to-context");
+const issue_location_1 = require("./issue-location");
+class IssueWebpackError extends webpack.WebpackError {
+    constructor(message, pathType, issue) {
+        super(message);
+        this.issue = issue;
+        this.hideStack = true;
+        // to display issue location using `loc` property, webpack requires `error.module` which
+        // should be a NormalModule instance.
+        // to avoid such a dependency, we do a workaround - error.file will contain formatted location instead
+        if (issue.file) {
+            this.file =
+                pathType === 'absolute'
+                    ? (0, forward_slash_1.forwardSlash)(path_1.default.resolve(issue.file))
+                    : (0, relative_to_context_1.relativeToContext)(issue.file, process.cwd());
+            if (issue.location) {
+                this.file += `:${(0, issue_location_1.formatIssueLocation)(issue.location)}`;
+            }
+        }
+        Error.captureStackTrace(this, this.constructor);
+    }
+}
+exports.IssueWebpackError = IssueWebpackError;

backend/node_modules/fork-ts-checker-webpack-plugin/lib/issue/issue.d.ts

@@ -0,0 +1,12 @@
+import type { IssueLocation } from './issue-location';
+import type { IssueSeverity } from './issue-severity';
+interface Issue {
+    severity: IssueSeverity;
+    code: string;
+    message: string;
+    file?: string;
+    location?: IssueLocation;
+}
+declare function isIssue(value: unknown): value is Issue;
+declare function deduplicateAndSortIssues(issues: Issue[]): Issue[];
+export { Issue, isIssue, deduplicateAndSortIssues };

backend/node_modules/fork-ts-checker-webpack-plugin/lib/issue/issue.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deduplicateAndSortIssues = exports.isIssue = void 0;
+const issue_location_1 = require("./issue-location");
+const issue_severity_1 = require("./issue-severity");
+function isIssue(value) {
+    return (!!value &&
+        typeof value === 'object' &&
+        (0, issue_severity_1.isIssueSeverity)(value.severity) &&
+        !!value.code &&
+        !!value.message);
+}
+exports.isIssue = isIssue;
+function compareStrings(stringA, stringB) {
+    if (stringA === stringB) {
+        return 0;
+    }
+    if (stringA === undefined || stringA === null) {
+        return -1;
+    }
+    if (stringB === undefined || stringB === null) {
+        return 1;
+    }
+    return stringA.toString().localeCompare(stringB.toString());
+}
+function compareIssues(issueA, issueB) {
+    return ((0, issue_severity_1.compareIssueSeverities)(issueA.severity, issueB.severity) ||
+        compareStrings(issueA.file, issueB.file) ||
+        (0, issue_location_1.compareIssueLocations)(issueA.location, issueB.location) ||
+        compareStrings(issueA.code, issueB.code) ||
+        compareStrings(issueA.message, issueB.message) ||
+        0 /* EqualTo */);
+}
+function equalsIssues(issueA, issueB) {
+    return compareIssues(issueA, issueB) === 0;
+}
+function deduplicateAndSortIssues(issues) {
+    const sortedIssues = issues.filter(isIssue).sort(compareIssues);
+    return sortedIssues.filter((issue, index) => index === 0 || !equalsIssues(issue, sortedIssues[index - 1]));
+}
+exports.deduplicateAndSortIssues = deduplicateAndSortIssues;