react-native-map4d-map-dtqg 0.1.4 → 0.1.5

package/lib/typescript/components/internal/DefaultRoadmapStyle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DefaultRoadmapStyle.d.ts","sourceRoot":"","sources":["../../../../src/components/internal/DefaultRoadmapStyle.js"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAkyGC"}

package/lib/typescript/components/internal/GeojsonStyleUtils.d.ts

@@ -0,0 +1,3 @@
+export function buildGeojsonStyle(mapStyle: any, sourceUrl: any, items: any): string;
+export function createCategoryItemsSignature(items: any): string;
+//# sourceMappingURL=GeojsonStyleUtils.d.ts.map

package/lib/typescript/components/internal/GeojsonStyleUtils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"GeojsonStyleUtils.d.ts","sourceRoot":"","sources":["../../../../src/components/internal/GeojsonStyleUtils.js"],"names":[],"mappings":"AAuGA,qFAwCC;AAtDD,iEAYC"}

package/lib/typescript/index.d.ts

@@ -0,0 +1,13 @@
+import { MFMapView } from './components/MFMapView';
+import { MFBanDoSo } from './components/MFBanDoSo';
+import { MFMarker } from './components/MFMarker';
+import { MFCircle } from './components/MFCircle';
+import { MFPolyline } from './components/MFPolyline';
+import { MFPolygon } from './components/MFPolygon';
+import { MFPOI } from './components/MFPOI';
+import { MFDirectionsRenderer } from './components/MFDirectionsRenderer';
+import { MFTileOverlay } from './components/MFTileOverlay';
+import { MFBuilding } from './components/MFBuilding';
+import { AreaFocuser } from './components/extends/AreaFocuser';
+export { MFMapView, MFBanDoSo, MFMarker, MFCircle, MFPolyline, MFPolygon, MFPOI, MFDirectionsRenderer, MFTileOverlay, MFBuilding, AreaFocuser };
+//# sourceMappingURL=index.d.ts.map

package/lib/typescript/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.js"],"names":[],"mappings":"0BAAwB,wBAAwB;0BACtB,wBAAwB;yBAC3B,uBAAuB;yBACvB,uBAAuB;2BACrB,yBAAyB;0BAC1B,wBAAwB;sBAC5B,oBAAoB;qCACL,mCAAmC;8BAC1C,4BAA4B;2BAC/B,yBAAyB;4BACxB,kCAAkC"}

package/lib/typescript/native/Map4dMapNativeModule.d.ts

@@ -0,0 +1,2 @@
+export function getMap4dMapNativeModule(): any;
+//# sourceMappingURL=Map4dMapNativeModule.d.ts.map

package/lib/typescript/native/Map4dMapNativeModule.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Map4dMapNativeModule.d.ts","sourceRoot":"","sources":["../../../src/native/Map4dMapNativeModule.js"],"names":[],"mappings":"AAEO,+CAAiE"}

package/lib/typescript/native/NativeModuleResolver.d.ts

@@ -0,0 +1,3 @@
+export function getNativeModule(moduleName: any): any;
+export function getUIManager(): any;
+//# sourceMappingURL=NativeModuleResolver.d.ts.map

package/lib/typescript/native/NativeModuleResolver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"NativeModuleResolver.d.ts","sourceRoot":"","sources":["../../../src/native/NativeModuleResolver.js"],"names":[],"mappings":"AAEO,sDAiBN;AAEM,oCAWN"}

package/lib/typescript/native/ViewManagerCommand.d.ts

@@ -0,0 +1,11 @@
+export function getViewManagerCommandId(componentName: any, commandName: any): any;
+export function runViewManagerCommand({ componentName, moduleName, commandName, args, reactTag, platform, rejectOnError, }: {
+    componentName: any;
+    moduleName: any;
+    commandName: any;
+    args?: never[] | undefined;
+    reactTag: any;
+    platform?: "ios" | "android" | "macos" | "windows" | "web" | undefined;
+    rejectOnError?: boolean | undefined;
+}): any;
+//# sourceMappingURL=ViewManagerCommand.d.ts.map

package/lib/typescript/native/ViewManagerCommand.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ViewManagerCommand.d.ts","sourceRoot":"","sources":["../../../src/native/ViewManagerCommand.js"],"names":[],"mappings":"AAWO,mFAkBN;AAEM;;;;;;;;QAkDN"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-map4d-map-dtqg",
-  "version": "0.1.4",
+  "version": "0.1.5",
   "description": "Map4dMap SDK for React Native",
   "main": "lib/commonjs/index",
   "module": "lib/module/index",
@@ -28,8 +28,12 @@
     "prepare": "bob build",
     "release": "release-it",
     "example": "yarn --cwd example",
+    "example:new": "yarn --cwd example-new-arch",
+    "example:new:start": "yarn --cwd example-new-arch start",
     "pods": "cd example && pod-install --quiet",
-    "bootstrap": "yarn example && yarn && yarn pods"
+    "pods:new": "cd example-new-arch && pod-install --quiet",
+    "bootstrap": "yarn example && yarn && yarn pods",
+    "bootstrap:new": "yarn example:new && yarn pods:new"
   },
   "keywords": [
     "react",
@@ -51,35 +55,39 @@
     "registry": "https://registry.npmjs.org/"
   },
   "devDependencies": {
+    "@babel/core": "^7.25.2",
     "@commitlint/config-conventional": "^11.0.0",
     "@react-native-community/eslint-config": "^2.0.0",
     "@release-it/conventional-changelog": "^2.0.0",
-    "@types/jest": "^26.0.0",
-    "@types/react": "^16.9.19",
-    "@types/react-native": "0.62.13",
+    "@react-native/babel-preset": "0.86.0",
+    "@react-native/jest-preset": "0.86.0",
+    "@types/jest": "^29.5.14",
+    "@types/react": "^19.1.8",
     "commitlint": "^11.0.0",
     "deprecated-react-native-prop-types": "^2.3.0",
     "eslint": "^7.2.0",
     "eslint-config-prettier": "^7.0.0",
     "eslint-plugin-prettier": "^3.1.3",
     "husky": "^6.0.0",
-    "jest": "^26.0.1",
+    "jest": "^29.7.0",
     "pod-install": "^0.1.0",
     "prettier": "^2.0.5",
-    "react": "16.13.1",
-    "react-native": "0.63.4",
-    "react-native-builder-bob": "^0.18.2",
+    "react": "19.2.3",
+    "react-native": "0.86.0",
+    "react-native-builder-bob": "^0.40.12",
     "release-it": "^14.2.2",
-    "typescript": "^4.1.3"
+    "typescript": "^5.6.3"
   },
   "peerDependencies": {
     "react": "*",
     "react-native": "*"
   },
   "jest": {
-    "preset": "react-native",
+    "preset": "@react-native/jest-preset",
     "modulePathIgnorePatterns": [
+      "<rootDir>/example/",
       "<rootDir>/example/node_modules",
+      "<rootDir>/example-new-arch/",
       "<rootDir>/lib/"
     ]
   },
@@ -148,5 +156,13 @@
         }
       ]
     ]
+  },
+  "codegenConfig": {
+    "name": "Map4dMapSpec",
+    "type": "modules",
+    "jsSrcsDir": "src/specs",
+    "android": {
+      "javaPackageName": "com.reactnativemap4dmap"
+    }
   }
 }

package/src/components/MFBanDoSo/constants.js

@@ -0,0 +1,32 @@
+const SELECTOR_DRAWER_TRANSLATE_X = -320;
+const SELECTOR_OPEN_DURATION_MS = 240;
+const SELECTOR_CLOSE_DURATION_MS = 210;
+const SELECTOR_TITLE = 'Chọn lớp dữ liệu trên bản đồ';
+const LEGEND_TITLE = 'Chú giải';
+
+const API_HOST = 'https://cmcdtqg-gateway.dieuhanhso.vn';
+const SOURCE_URL_PATH = 'bds/api/tile/vector/{z}/{x}/{y}.pbf?p=1';
+const CATEGORY_CONFIG_URL_PATH = 'bds/api/BanDo/dau-tu/category-config';
+
+function buildApiUrl(path, isStaging) {
+  const stagingSegment = isStaging ? '/staging' : '';
+  return `${API_HOST}${stagingSegment}/${path}`;
+}
+
+function getSourceUrl(isStaging) {
+  return buildApiUrl(SOURCE_URL_PATH, isStaging);
+}
+
+function getCategoryConfigUrl(isStaging) {
+  return buildApiUrl(CATEGORY_CONFIG_URL_PATH, isStaging);
+}
+
+export {
+  SELECTOR_DRAWER_TRANSLATE_X,
+  SELECTOR_OPEN_DURATION_MS,
+  SELECTOR_CLOSE_DURATION_MS,
+  SELECTOR_TITLE,
+  LEGEND_TITLE,
+  getSourceUrl,
+  getCategoryConfigUrl,
+};

package/src/components/MFBanDoSo/helpers.js

@@ -0,0 +1,273 @@
+import { createCategoryItemsSignature } from '../internal/GeojsonStyleUtils';
+
+function normalizeColorValue(color) {
+  if (typeof color === 'string' && color.trim().length > 0) {
+    return color.trim();
+  }
+
+  if (Array.isArray(color) && typeof color[0] === 'string' && color[0].trim().length > 0) {
+    return color[0].trim();
+  }
+
+  return null;
+}
+
+function resolveItemsFromCategoryResponse(json) {
+  const data = json?.data ?? json;
+
+  if (Array.isArray(data)) {
+    return data;
+  }
+
+  if (Array.isArray(data?.items)) {
+    return data.items;
+  }
+
+  if (Array.isArray(json?.items)) {
+    return json.items;
+  }
+
+  return [];
+}
+
+function resolveCategoryGroupMetadataFromResponse(json) {
+  const data = json?.data ?? json;
+  const groups = Array.isArray(data?.groups)
+    ? data.groups
+    : Array.isArray(json?.groups)
+      ? json.groups
+      : [];
+
+  const titleByKey = {};
+  const orderKeys = [];
+
+  groups.forEach((group, index) => {
+    if (!group || typeof group !== 'object') {
+      return;
+    }
+
+    const rawKeyValue = [group.key, group.code, group.group, group.id]
+      .find((value) => value != null && `${value}`.trim().length > 0);
+
+    if (rawKeyValue == null) {
+      return;
+    }
+
+    const key = `${rawKeyValue}`.trim();
+    const rawTitleValue = [
+      group.title,
+      group.name,
+      group.label,
+      group.display_name,
+      group.displayName,
+    ].find((value) => typeof value === 'string' && value.trim().length > 0);
+
+    const title = rawTitleValue ? rawTitleValue.trim() : key;
+
+    titleByKey[key] = title;
+
+    const preferredOrder = Number.isFinite(group.order) ? group.order : index;
+    orderKeys.push({
+      key,
+      order: preferredOrder,
+      index,
+    });
+  });
+
+  orderKeys.sort((a, b) => {
+    if (a.order === b.order) {
+      return a.index - b.index;
+    }
+    return a.order - b.order;
+  });
+
+  return {
+    titleByKey,
+    orderedKeys: orderKeys.map((entry) => entry.key),
+  };
+}
+
+function normalizeCategoryItems(items) {
+  if (!Array.isArray(items)) {
+    return [];
+  }
+
+  return items.map((item) => ({
+    ...item,
+    checked: item?.checked !== false,
+  }));
+}
+
+function getSelectedCategoryItems(items) {
+  return (Array.isArray(items) ? items : []).filter(
+    (item) => item?.checked !== false
+  );
+}
+
+function resolveCategoryGroupKey(item) {
+  const rawGroup = typeof item?.group === 'string' ? item.group.trim() : '';
+  return rawGroup.length > 0 ? rawGroup : '__ungrouped__';
+}
+
+function createCategoryGroupSections(items, titleByKey = {}, orderedKeys = []) {
+  const list = Array.isArray(items) ? items : [];
+  const groupedMap = new Map();
+
+  list.forEach((item, index) => {
+    const groupKey = resolveCategoryGroupKey(item);
+    const mappedTitle =
+      typeof titleByKey[groupKey] === 'string' && titleByKey[groupKey].trim().length > 0
+        ? titleByKey[groupKey].trim()
+        : null;
+    const groupTitle = mappedTitle || (groupKey === '__ungrouped__' ? 'Khac' : groupKey);
+
+    if (!groupedMap.has(groupKey)) {
+      groupedMap.set(groupKey, {
+        key: groupKey,
+        title: groupTitle,
+        items: [],
+      });
+    }
+
+    groupedMap.get(groupKey).items.push({
+      item,
+      index,
+    });
+  });
+
+  const sections = Array.from(groupedMap.values());
+  if (!Array.isArray(orderedKeys) || orderedKeys.length === 0) {
+    return sections;
+  }
+
+  const orderMap = orderedKeys.reduce((acc, key, index) => {
+    if (typeof key === 'string' && key.length > 0) {
+      acc[key] = index;
+    }
+    return acc;
+  }, {});
+
+  return sections.sort((a, b) => {
+    const aOrder = Object.prototype.hasOwnProperty.call(orderMap, a.key)
+      ? orderMap[a.key]
+      : Number.MAX_SAFE_INTEGER;
+    const bOrder = Object.prototype.hasOwnProperty.call(orderMap, b.key)
+      ? orderMap[b.key]
+      : Number.MAX_SAFE_INTEGER;
+
+    if (aOrder === bOrder) {
+      return a.title.localeCompare(b.title);
+    }
+    return aOrder - bOrder;
+  });
+}
+
+function reconcileExpandedGroupKeys(groupSections, previousExpandedGroupKeys) {
+  const prev =
+    previousExpandedGroupKeys && typeof previousExpandedGroupKeys === 'object'
+      ? previousExpandedGroupKeys
+      : {};
+
+  return (Array.isArray(groupSections) ? groupSections : []).reduce(
+    (acc, group) => {
+      const key = group?.key;
+      if (typeof key !== 'string' || key.length === 0) {
+        return acc;
+      }
+
+      acc[key] = typeof prev[key] === 'boolean' ? prev[key] : true;
+      return acc;
+    },
+    {}
+  );
+}
+
+function createSelectedCategoryItemsSignature(items) {
+  return createCategoryItemsSignature(getSelectedCategoryItems(items));
+}
+
+function toggleCategoryItemChecked(items, targetKey, targetIndex) {
+  return (Array.isArray(items) ? items : []).map((item, index) => {
+    const currentKey = item?.key ?? `index-${index}`;
+    const isTarget = currentKey === targetKey && index === targetIndex;
+
+    if (!isTarget) {
+      return item;
+    }
+
+    return {
+      ...item,
+      checked: !(item?.checked !== false),
+    };
+  });
+}
+
+function toggleCategoryGroupChecked(items, targetGroupKey, checkedValue) {
+  if (typeof targetGroupKey !== 'string' || targetGroupKey.length === 0) {
+    return Array.isArray(items) ? items : [];
+  }
+
+  const nextChecked = checkedValue !== false;
+
+  return (Array.isArray(items) ? items : []).map((item) => {
+    const groupKey = resolveCategoryGroupKey(item);
+    if (groupKey !== targetGroupKey) {
+      return item;
+    }
+
+    return {
+      ...item,
+      checked: nextChecked,
+    };
+  });
+}
+
+function extractColorFromItemStyle(item) {
+  if (!item || typeof item !== 'object') {
+    return null;
+  }
+
+  const lineColor = normalizeColorValue(item?.style?.line?.[0]?.draw?.color);
+  if (lineColor) {
+    return lineColor;
+  }
+
+  const fillColor = normalizeColorValue(item?.style?.fill?.[0]?.draw?.color);
+  if (fillColor) {
+    return fillColor;
+  }
+
+  const symbolColor = normalizeColorValue(item?.style?.symbol?.[0]?.draw?.icon_color);
+  if (symbolColor) {
+    return symbolColor;
+  }
+
+  return null;
+}
+
+function resolveCategoryItemColor(item) {
+  const customColor = normalizeColorValue(item?.color);
+  if (customColor) {
+    return customColor;
+  }
+
+  const styleColor = extractColorFromItemStyle(item);
+  if (styleColor) {
+    return styleColor;
+  }
+
+  return null;
+}
+
+export {
+  createCategoryGroupSections,
+  createSelectedCategoryItemsSignature,
+  getSelectedCategoryItems,
+  normalizeCategoryItems,
+  reconcileExpandedGroupKeys,
+  resolveCategoryGroupMetadataFromResponse,
+  resolveCategoryItemColor,
+  resolveItemsFromCategoryResponse,
+  toggleCategoryGroupChecked,
+  toggleCategoryItemChecked,
+};

package/src/components/MFBanDoSo/propTypes.js

@@ -0,0 +1,14 @@
+import PropTypes from 'prop-types';
+import { MFMapView } from '../MFMapView';
+
+const banDoSoPropTypes = {
+  ...MFMapView.propTypes,
+
+  /**
+   * If `true` (default), fetch category config and vector tiles from the staging API.
+   * If `false`, use the production API (no `/staging` path segment).
+   */
+  isStaging: PropTypes.bool,
+};
+
+export { banDoSoPropTypes };