@premiate/strapi-plugin-maplibre-field 1.0.6

package/dist/_chunks/index-nbk0hg-O.js

@@ -0,0 +1,170 @@
+"use strict";
+const React = require("react");
+const jsxRuntime = require("react/jsx-runtime");
+const icons = require("@strapi/icons");
+const designSystem = require("@strapi/design-system");
+const styledComponents = require("styled-components");
+const __variableDynamicImportRuntimeHelper = (glob, path, segs) => {
+  const v = glob[path];
+  if (v) {
+    return typeof v === "function" ? v() : Promise.resolve(v);
+  }
+  return new Promise((_, reject) => {
+    (typeof queueMicrotask === "function" ? queueMicrotask : setTimeout)(
+      reject.bind(
+        null,
+        new Error(
+          "Unknown variable dynamic import: " + path + (path.split("/").length !== segs ? ". Note that variables only represent file names one level deep." : "")
+        )
+      )
+    );
+  });
+};
+const name$1 = "@premiate/strapi-plugin-maplibre-field";
+const strapi = {
+  name: "maplibre-field"
+};
+const pluginPkg = {
+  name: name$1,
+  strapi
+};
+const pluginId = pluginPkg.name.replace(/^(@[^/]+\/)?strapi-plugin-/i, "");
+const Initializer = ({ setPlugin }) => {
+  const ref = React.useRef(false);
+  React.useEffect(() => {
+    if (!ref.current) {
+      setPlugin("maplibre-field");
+      ref.current = true;
+    }
+  }, [setPlugin]);
+  return null;
+};
+const IconBox = styledComponents.styled(designSystem.Flex)`
+  /* Hard code color values */
+  /* to stay consistent between themes */
+  background-color: #f0f0ff; /* primary100 */
+  border: 1px solid #d9d8ff; /* primary200 */
+
+  svg > path {
+    fill: #4945ff; /* primary600 */
+  }
+`;
+const PluginIcon = () => {
+  return /* @__PURE__ */ jsxRuntime.jsx(IconBox, { justifyContent: "center", alignItems: "center", width: 7, height: 6, hasRadius: true, "aria-hidden": true, children: /* @__PURE__ */ jsxRuntime.jsx(icons.PinMap, {}) });
+};
+const mutateLayouts = (layouts) => {
+  return layouts.map((row) => {
+    return row.map((field) => {
+      const hasMapFieldEnabled = field.attribute?.pluginOptions?.["maplibre-field"]?.enabled;
+      if (!hasMapFieldEnabled) {
+        return field;
+      }
+      return {
+        ...field,
+        attribute: {
+          ...field.attribute,
+          customField: `plugin::${pluginId}.map`
+        }
+      };
+    });
+  });
+};
+const mutateEditViewHook = (editLayout) => {
+  if (!editLayout?.layout || !Array.isArray(editLayout.layout)) {
+    console.warn("maplibre-field: Invalid EditLayout structure received", editLayout);
+    return editLayout;
+  }
+  const mutatedLayout = mutateLayouts(editLayout.layout);
+  return {
+    ...editLayout,
+    layout: mutatedLayout
+  };
+};
+const prefixPluginTranslations = (trad, pluginId2) => {
+  if (!pluginId2) {
+    throw new TypeError("pluginId can't be empty");
+  }
+  return Object.keys(trad).reduce((acc, current) => {
+    acc[`${pluginId2}.${current}`] = trad[current];
+    return acc;
+  }, {});
+};
+const name = pluginPkg.strapi.name;
+const index = {
+  register(app) {
+    app.customFields.register({
+      name: "map",
+      pluginId,
+      type: "json",
+      intlLabel: {
+        id: "maplibre-field.label",
+        defaultMessage: "Map"
+      },
+      intlDescription: {
+        id: "maplibre-field.description",
+        defaultMessage: "A map custom field using MapLibre"
+      },
+      icon: PluginIcon,
+      components: {
+        Input: async () => Promise.resolve().then(() => require(
+          /* webpackChunkName: "input-component" */
+          "./index-CGJogtZr.js"
+        ))
+      },
+      options: {
+        advanced: [
+          {
+            sectionTitle: null,
+            items: [
+              {
+                name: "options.pluginOptions.i18n.localized",
+                type: "checkbox",
+                intlLabel: {
+                  id: "maplibre-field.i18n.localized.label",
+                  defaultMessage: "Enable localization for this field"
+                },
+                description: {
+                  id: "maplibre-field.i18n.localized.description",
+                  defaultMessage: "The field can have different values in each language"
+                },
+                defaultValue: false
+              }
+            ]
+          }
+        ]
+      }
+    });
+    app.registerPlugin({
+      id: pluginId,
+      initializer: Initializer,
+      isReady: false,
+      name
+    });
+  },
+  bootstrap(app) {
+    app.registerHook(
+      "Admin/CM/pages/EditView/mutate-edit-view-layout",
+      mutateEditViewHook
+    );
+  },
+  async registerTrads({ locales }) {
+    const importedTrads = await Promise.all(
+      locales.map((locale) => {
+        return __variableDynamicImportRuntimeHelper(/* @__PURE__ */ Object.assign({ "./translations/de.json": () => Promise.resolve().then(() => require("./de-Dq_t3Z6M.js")), "./translations/en.json": () => Promise.resolve().then(() => require("./en-CgSPA-1L.js")), "./translations/es.json": () => Promise.resolve().then(() => require("./es-Sgja1XAa.js")), "./translations/fr.json": () => Promise.resolve().then(() => require("./fr-B3JIzyzo.js")), "./translations/it.json": () => Promise.resolve().then(() => require("./it-BgWDIXzn.js")) }), `./translations/${locale}.json`, 3).then(({ default: data }) => {
+          return {
+            data: prefixPluginTranslations(data, pluginId),
+            locale
+          };
+        }).catch(() => {
+          return {
+            data: {},
+            locale
+          };
+        });
+      })
+    );
+    return Promise.resolve(importedTrads);
+  }
+};
+exports.index = index;
+exports.pluginId = pluginId;

package/dist/_chunks/it-BgWDIXzn.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const it = {
+  "maplibre-field.label": "Mappa",
+  "maplibre-field.search": "Cerca un indirizzo o luogo su OpenStreetMap",
+  "maplibre-field.description": "Un custom field per mappe usando Maplibre",
+  "maplibre-field.fields.address": "indirizzo",
+  "maplibre-field.fields.longitude": "longitudine",
+  "maplibre-field.fields.latitude": "latitudine",
+  "maplibre-field.geocoding.success": "Indirizzo aggiornato con successo",
+  "maplibre-field.geocoding.error": "Impossibile recuperare l'indirizzo. Riprova.",
+  "maplibre-field.geocoding.no-results": "Nessun indirizzo trovato per questa posizione",
+  "maplibre-field.i18n.localized.label": "Abilita la localizzazione per questo campo",
+  "maplibre-field.i18n.localized.description": "Il campo può avere valori diversi in ogni lingua"
+};
+exports.default = it;

package/dist/_chunks/it-CoUEVPt6.mjs

@@ -0,0 +1,16 @@
+const it = {
+  "maplibre-field.label": "Mappa",
+  "maplibre-field.search": "Cerca un indirizzo o luogo su OpenStreetMap",
+  "maplibre-field.description": "Un custom field per mappe usando Maplibre",
+  "maplibre-field.fields.address": "indirizzo",
+  "maplibre-field.fields.longitude": "longitudine",
+  "maplibre-field.fields.latitude": "latitudine",
+  "maplibre-field.geocoding.success": "Indirizzo aggiornato con successo",
+  "maplibre-field.geocoding.error": "Impossibile recuperare l'indirizzo. Riprova.",
+  "maplibre-field.geocoding.no-results": "Nessun indirizzo trovato per questa posizione",
+  "maplibre-field.i18n.localized.label": "Abilita la localizzazione per questo campo",
+  "maplibre-field.i18n.localized.description": "Il campo può avere valori diversi in ogni lingua"
+};
+export {
+  it as default
+};

package/dist/admin/index.js

@@ -0,0 +1,3 @@
+"use strict";
+const index = require("../_chunks/index-nbk0hg-O.js");
+module.exports = index.index;

package/dist/admin/index.mjs

@@ -0,0 +1,4 @@
+import { i } from "../_chunks/index-BF5T-kqa.mjs";
+export {
+  i as default
+};

package/dist/admin/src/components/Initializer.d.ts

@@ -0,0 +1,6 @@
+/// <reference types="react" />
+interface InitializerProps {
+    setPlugin: (id: string) => void;
+}
+declare const Initializer: React.FC<InitializerProps>;
+export default Initializer;

package/dist/admin/src/components/MapInput/basemap-control.d.ts

@@ -0,0 +1,8 @@
+import type { MapStyle } from '../../../../server/src/types/config';
+interface BasemapControlProps {
+    mapStyles: MapStyle[];
+    currentStyleUrl: string;
+    onStyleChange: (styleUrl: string) => void;
+}
+export default function BasemapControlComponent({ mapStyles, currentStyleUrl, onStyleChange, }: BasemapControlProps): null;
+export {};

package/dist/admin/src/components/MapInput/credits-control.d.ts

@@ -0,0 +1,10 @@
+import React from 'react';
+import type { MapRef } from 'react-map-gl/maplibre';
+interface CreditsControlProps {
+    mapRef: React.RefObject<MapRef>;
+}
+/**
+ * React wrapper for MapLibre Credits Control
+ */
+declare const CreditsControl: React.FC<CreditsControlProps>;
+export default CreditsControl;

package/dist/admin/src/components/MapInput/geocoder-control.d.ts

@@ -0,0 +1,20 @@
+import React from 'react';
+import type { MapRef } from 'react-map-gl/maplibre';
+import '@maplibre/maplibre-gl-geocoder/dist/maplibre-gl-geocoder.css';
+interface GeocoderResult {
+    result: {
+        center?: [number, number];
+        place_name: string;
+        geometry?: {
+            type: string;
+            coordinates: [number, number];
+        };
+    };
+}
+interface GeocoderControlProps {
+    mapRef: React.RefObject<MapRef>;
+    position?: string;
+    onResult?: (evt: GeocoderResult) => void;
+}
+declare const GeocoderControl: React.FC<GeocoderControlProps>;
+export default GeocoderControl;

package/dist/admin/src/components/MapInput/index.d.ts

@@ -0,0 +1,19 @@
+import React from 'react';
+import 'maplibre-gl/dist/maplibre-gl.css';
+interface MapFieldProps {
+    intlLabel: {
+        id: string;
+        defaultMessage: string;
+    };
+    name: string;
+    onChange: (event: {
+        target: {
+            name: string;
+            value: string;
+            type: string;
+        };
+    }) => void;
+    value: string | null;
+}
+declare const MapField: React.FC<MapFieldProps>;
+export default MapField;

package/dist/admin/src/components/MapInput/layer-control.d.ts

@@ -0,0 +1,18 @@
+import React from 'react';
+import type { MapRef } from 'react-map-gl/maplibre';
+export interface LayerConfig {
+    id: string;
+    name: string;
+    enabled: boolean;
+    color?: string;
+}
+interface LayerControlProps {
+    mapRef: React.RefObject<MapRef>;
+    layers: LayerConfig[];
+    onLayerToggle: (layerId: string, enabled: boolean) => void;
+}
+/**
+ * React wrapper for MapLibre Layer Control
+ */
+declare const LayerControl: React.FC<LayerControlProps>;
+export default LayerControl;

package/dist/admin/src/components/PluginIcon.d.ts

@@ -0,0 +1,2 @@
+declare const PluginIcon: () => import("react/jsx-runtime").JSX.Element;
+export default PluginIcon;

package/dist/admin/src/hooks/usePluginConfig.d.ts

@@ -0,0 +1,2 @@
+import type { MapLibreConfig } from '../../../server/src/types/config';
+export declare const usePluginConfig: () => MapLibreConfig;

package/dist/admin/src/index.d.ts

@@ -0,0 +1,16 @@
+declare const _default: {
+    register(app: any): void;
+    bootstrap(app: any): void;
+    registerTrads({ locales }: {
+        locales: string[];
+    }): Promise<({
+        data: {
+            [x: string]: string;
+        };
+        locale: string;
+    } | {
+        data: {};
+        locale: string;
+    })[]>;
+};
+export default _default;

package/dist/admin/src/mutations/mutateEditViewHook.d.ts

@@ -0,0 +1,30 @@
+interface EditFieldLayout {
+    attribute?: {
+        customField?: string;
+        pluginOptions?: {
+            [key: string]: {
+                enabled?: boolean;
+            };
+        };
+        type?: string;
+    };
+    name?: string;
+    size?: number;
+    [key: string]: any;
+}
+interface EditLayout {
+    layout: Array<Array<EditFieldLayout>>;
+    components: {
+        [uid: string]: {
+            layout: Array<EditFieldLayout>;
+            settings: any;
+        };
+    };
+    metadatas: {
+        [key: string]: any;
+    };
+    options: any;
+    settings: any;
+}
+declare const mutateEditViewHook: (editLayout: EditLayout) => EditLayout;
+export default mutateEditViewHook;

package/dist/admin/src/services/poi-service.d.ts

@@ -0,0 +1,160 @@
+/**
+ * POI Service Layer
+ *
+ * Handles POI queries from multiple sources (Nominatim, Custom GeoJSON APIs)
+ * Provides distance calculations, viewport filtering, and data transformation
+ */
+/**
+ * Properties for a LocationFeature (all optional, omitted if not available)
+ */
+export interface LocationProperties {
+    /** POI name or short location name */
+    name?: string;
+    /** Full formatted address */
+    address?: string;
+    /** Source identifier: "nominatim" or custom source ID like "fotta-skatespots" */
+    source?: string;
+    /** Original ID from the source */
+    sourceId?: string;
+    /** Display name of the source layer, e.g., "Fotta Skatespots" */
+    sourceLayer?: string;
+    /** POI category/type: "skating_spot", "bus_stop", etc. */
+    category?: string;
+    /** How the location was created: "search" | "poi_click" | "map_click" */
+    inputMethod?: 'search' | 'poi_click' | 'map_click';
+    /** Original metadata preserved from the source */
+    metadata?: Record<string, unknown>;
+}
+/**
+ * GeoJSON Feature for storing location data (RFC 7946 compliant)
+ * This is the canonical format for storing locations in the database.
+ */
+export interface LocationFeature {
+    type: 'Feature';
+    geometry: {
+        type: 'Point';
+        coordinates: [number, number];
+    };
+    properties: LocationProperties;
+}
+/**
+ * Create a LocationFeature with clean properties (no null/empty values)
+ * @param coordinates [lng, lat] coordinates
+ * @param properties Optional properties to include
+ * @returns LocationFeature with only defined, non-empty properties
+ */
+export declare function createLocationFeature(coordinates: [number, number], properties?: Partial<LocationProperties>): LocationFeature;
+export interface POI {
+    id: string;
+    name: string;
+    type: string;
+    coordinates: [number, number];
+    address: string;
+    distance?: number;
+    metadata?: Record<string, any>;
+    source: 'nominatim' | 'custom';
+    mapName?: string;
+    layerId?: string;
+}
+export interface GeoJSONFeature {
+    id?: string;
+    type: 'Feature';
+    geometry: {
+        type: 'Point';
+        coordinates: [number, number];
+    };
+    properties: {
+        name?: string | null;
+        [key: string]: any;
+    };
+}
+export interface GeoJSONFeatureCollection {
+    type: 'FeatureCollection';
+    features: GeoJSONFeature[];
+}
+export interface POIServiceConfig {
+    nominatimUrl: string;
+    customApiUrl?: string | null;
+    mapName?: string;
+    layerId?: string;
+    radius: number;
+    categories: string[];
+}
+/**
+ * Calculate distance between two coordinates using Haversine formula
+ * @param coord1 First coordinate [lng, lat]
+ * @param coord2 Second coordinate [lng, lat]
+ * @returns Distance in meters
+ */
+export declare function calculateDistance(coord1: [number, number], coord2: [number, number]): number;
+/**
+ * Query POIs from custom GeoJSON API
+ * @param apiUrl Custom API endpoint URL
+ * @param searchQuery Optional search query for filtering
+ * @returns Array of GeoJSON features
+ */
+export declare function queryCustomAPI(apiUrl: string, searchQuery?: string): Promise<GeoJSONFeature[]>;
+/**
+ * Query POIs near coordinates from Nominatim
+ * Uses /reverse endpoint with high zoom level to get specific POIs
+ * @param lat Latitude
+ * @param lng Longitude
+ * @param radius Search radius in meters
+ * @param nominatimUrl Nominatim API base URL
+ * @returns Array of POIs
+ */
+export declare function queryNominatim(lat: number, lng: number, radius: number, nominatimUrl: string): Promise<POI[]>;
+/**
+ * Convert GeoJSON feature to POI interface
+ * @param feature GeoJSON feature
+ * @param clickCoords Optional reference coordinates for distance calculation
+ * @param mapName Optional display name for the custom map source
+ * @param layerId Optional ID of the layer this POI belongs to
+ * @returns POI object or null if invalid
+ */
+export declare function geoJSONFeatureToPOI(feature: GeoJSONFeature, clickCoords?: [number, number], mapName?: string, layerId?: string): POI | null;
+/**
+ * Filter GeoJSON features by distance from click point
+ * @param features Array of GeoJSON features
+ * @param clickCoords Click coordinates [lng, lat]
+ * @param radius Maximum distance in meters
+ * @returns Filtered features within radius
+ */
+export declare function filterByDistance(features: GeoJSONFeature[], clickCoords: [number, number], radius: number): GeoJSONFeature[];
+/**
+ * Find nearest POI to click coordinates
+ * @param clickCoordinates Click coordinates [lng, lat]
+ * @param pois Array of POIs
+ * @returns Nearest POI or null if none found
+ */
+export declare function findNearestPOI(clickCoordinates: [number, number], pois: POI[]): POI | null;
+/**
+ * Search POIs for geocoder (queries custom POI sources only)
+ * Note: Nominatim search is handled directly by geocoder-control.tsx
+ * @param query Search query string
+ * @param config POI service configuration
+ * @returns Array of custom POIs only
+ */
+export declare function searchPOIsForGeocoder(query: string, config: POIServiceConfig): Promise<POI[]>;
+/**
+ * Search nearby POIs for snap (double-click) - queries BOTH sources
+ * @param lat Latitude
+ * @param lng Longitude
+ * @param config POI service configuration
+ * @returns Array of POIs from both Nominatim and Custom API
+ */
+export declare function searchNearbyPOIsForSnap(lat: number, lng: number, config: POIServiceConfig): Promise<POI[]>;
+/**
+ * Query POIs for viewport display
+ * @param bounds Map bounds {north, south, east, west}
+ * @param center Map center [lng, lat]
+ * @param maxDisplay Maximum number of POIs to display
+ * @param config POI service configuration
+ * @returns Array of POIs sorted by distance from center
+ */
+export declare function queryPOIsForViewport(bounds: {
+    north: number;
+    south: number;
+    east: number;
+    west: number;
+}, center: [number, number], maxDisplay: number, config: POIServiceConfig): Promise<POI[]>;

package/dist/admin/src/utils/getTrad.d.ts

@@ -0,0 +1,2 @@
+declare const getTrad: (id: string) => string;
+export default getTrad;

package/dist/admin/src/utils/pluginId.d.ts

@@ -0,0 +1,2 @@
+declare const pluginId: string;
+export default pluginId;

package/dist/admin/src/utils/prefixPluginTranslations.d.ts

@@ -0,0 +1,3 @@
+type TradOptions = Record<string, string>;
+export declare const prefixPluginTranslations: (trad: TradOptions, pluginId: string) => TradOptions;
+export {};

package/dist/server/index.js

@@ -0,0 +1,107 @@
+"use strict";
+const register = ({ strapi }) => {
+  strapi.customFields.register({
+    name: "map",
+    plugin: "maplibre-field",
+    type: "json"
+    // Icon will be loaded from admin side via intlLabel
+  });
+};
+const bootstrap = () => {
+};
+const destroy = ({ strapi }) => {
+};
+const schema = {
+  mapStyles: {
+    type: "array",
+    default: [
+      {
+        id: "satellite",
+        name: "Satellite",
+        url: "https://api.maptiler.com/maps/satellite-v4/style.json?key=sOr6q24xbu24UhKuyK8a",
+        isDefault: true
+      },
+      {
+        id: "osm",
+        name: "OpenStreetMap",
+        url: "https://api.maptiler.com/maps/openstreetmap/style.json?key=sOr6q24xbu24UhKuyK8a"
+      }
+    ]
+  },
+  defaultZoom: {
+    type: "number",
+    default: 4.5
+  },
+  defaultCenter: {
+    type: "array",
+    default: [0, 0]
+  },
+  geocodingProvider: {
+    type: "string",
+    default: "nominatim"
+  },
+  nominatimUrl: {
+    type: "string",
+    default: "https://nominatim.openstreetmap.org"
+  },
+  poiDisplayEnabled: {
+    type: "boolean",
+    default: true,
+    description: "Display POI markers on map"
+  },
+  poiMinZoom: {
+    type: "number",
+    default: 10,
+    description: "Minimum zoom level to display POI markers"
+  },
+  poiMaxDisplay: {
+    type: "number",
+    default: 100,
+    description: "Maximum number of POIs to display on map"
+  },
+  poiSearchEnabled: {
+    type: "boolean",
+    default: true,
+    description: "Include custom API results in search field"
+  },
+  poiSnapRadius: {
+    type: "number",
+    default: 5,
+    description: "Snap radius in meters for double-click POI detection (default: 5m)"
+  }
+};
+const config$1 = {
+  default: schema,
+  validator() {
+  }
+};
+const config = ({ strapi }) => ({
+  getConfig(ctx) {
+    const config2 = strapi.config.get("plugin::maplibre-field");
+    console.log("[MapLibre Controller] Returning config:", JSON.stringify(config2, null, 2));
+    ctx.body = config2;
+  }
+});
+const controllers = {
+  config
+};
+const routes = [
+  {
+    method: "GET",
+    path: "/config",
+    handler: "config.getConfig",
+    config: {
+      auth: false
+      // No authentication needed - config is public
+    }
+  }
+];
+const index = {
+  register,
+  bootstrap,
+  destroy,
+  config: config$1,
+  controllers,
+  routes
+};
+module.exports = index;