drf-react-by-schema 0.28.7 → 0.28.9

package/dist/components/forms/inputs/MapGeometryPicker.js

@@ -0,0 +1,344 @@
+"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 __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 () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __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.default = MapGeometryPicker;
+const react_1 = __importStar(require("react"));
+const Box_1 = __importDefault(require("@mui/material/Box"));
+const TextField_1 = __importDefault(require("@mui/material/TextField"));
+const FormHelperText_1 = __importDefault(require("@mui/material/FormHelperText"));
+const styles_1 = require("@mui/material/styles");
+const react_leaflet_1 = require("react-leaflet");
+const leaflet_1 = __importDefault(require("leaflet"));
+require("leaflet/dist/leaflet.css");
+// leaflet-draw does not export; augments global L with Control.Draw.
+require("leaflet-draw");
+require("leaflet-draw/dist/leaflet.draw.css");
+const leafletMarker_1 = require("./leafletMarker");
+const texts_1 = require("../../../styles/texts");
+const utils_1 = require("../../../utils");
+// Markers need a servable icon; leaflet's stock icons 404 inside an SPA.
+(0, leafletMarker_1.applyDefaultLeafletIcon)();
+// Build the drf-react-by-schema geometry out of leaflet-draw features. Leaflet
+// already parses/produces GeoJSON (L.geoJSON, FeatureGroup.toGeoJSON), so here
+// we only reshape the resulting features into the right geometry type.
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function buildOutput(geometry, features) {
+    const geoms = features.map((f) => f === null || f === void 0 ? void 0 : f.geometry).filter((g) => g);
+    if (geometry === 'point') {
+        const point = geoms.find((g) => g.type === 'Point');
+        return point ? { type: 'Point', coordinates: point.coordinates } : null;
+    }
+    if (geometry === 'polygon') {
+        const polygon = geoms.find((g) => g.type === 'Polygon');
+        return polygon ? { type: 'Polygon', coordinates: polygon.coordinates } : null;
+    }
+    if (geometry === 'multipoint') {
+        const coords = geoms.filter((g) => g.type === 'Point').map((g) => g.coordinates);
+        return coords.length ? { type: 'MultiPoint', coordinates: coords } : null;
+    }
+    if (geometry === 'multipolygon') {
+        const coords = geoms.filter((g) => g.type === 'Polygon').map((g) => g.coordinates);
+        return coords.length ? { type: 'MultiPolygon', coordinates: coords } : null;
+    }
+    // geometrycollection: points and polygons drawn together
+    const list = geoms.filter((g) => g.type === 'Point' || g.type === 'Polygon');
+    return list.length ? { type: 'GeometryCollection', geometries: list } : null;
+}
+// Counts the markers/polygons currently drawn so single-instance fields can
+// hide their "add" tool once one shape already exists.
+function layerCounts(featureGroup) {
+    let markers = 0;
+    let polygons = 0;
+    featureGroup.eachLayer((layer) => {
+        if (layer instanceof leaflet_1.default.Marker)
+            markers += 1;
+        else if (layer instanceof leaflet_1.default.Polygon)
+            polygons += 1;
+    });
+    return { markers, polygons };
+}
+// The geometry picker only enables marker + polygon draw plus edit/remove, so only
+// those leaflet-draw strings are themeable here. Build the subset shown by the UI.
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function leafletDrawLocalization(gt) {
+    return {
+        draw: {
+            toolbar: {
+                actions: { title: gt.cancelDrawing, text: gt.cancelDrawing },
+                finish: { title: gt.finishDrawing, text: gt.finishDrawing },
+                undo: { title: gt.undoPoint, text: gt.undoPoint },
+                buttons: { marker: gt.drawAMarker, polygon: gt.drawAPolygon },
+            },
+            handlers: {
+                marker: { tooltip: { start: gt.clickToPlaceMarker } },
+                polygon: {
+                    tooltip: {
+                        start: gt.clickToStartShape,
+                        cont: gt.clickToContinueShape,
+                        end: gt.clickToCloseShape,
+                    },
+                },
+            },
+        },
+        edit: {
+            toolbar: {
+                actions: {
+                    save: { title: gt.saveChanges, text: gt.saveChanges },
+                    cancel: { title: gt.cancelEdit, text: gt.cancelEdit },
+                    clearAll: { title: gt.clearAll, text: gt.clearAll },
+                },
+                buttons: {
+                    edit: gt.editLayers,
+                    editDisabled: gt.editLayersDisabled,
+                    remove: gt.deleteLayers,
+                    removeDisabled: gt.deleteLayersDisabled,
+                },
+            },
+            handlers: {
+                edit: { tooltip: { text: gt.dragToEditFeatures, subtext: gt.clickCancelToUndo } },
+                remove: { tooltip: { text: gt.clickFeatureToRemove } },
+            },
+        },
+    };
+}
+// Deep-merge the themed subset over leaflet-draw's global (English) defaults so any
+// string we don't theme keeps a sane value. leaflet-draw reads L.drawLocal at runtime.
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function deepMerge(target, source) {
+    for (const key in source) {
+        const sv = source[key];
+        const tv = target === null || target === void 0 ? void 0 : target[key];
+        if (sv && typeof sv === 'object' && !Array.isArray(sv) && tv && typeof tv === 'object' && !Array.isArray(tv)) {
+            target[key] = deepMerge(tv, sv);
+        }
+        else {
+            target[key] = sv;
+        }
+    }
+    return target;
+}
+function applyLeafletDrawLocalization(gt) {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    deepMerge(leaflet_1.default.drawLocal, leafletDrawLocalization(gt));
+}
+// Which draw tools each geometry allows.
+const markerEnabledFor = (g) => g === 'point' || g === 'multipoint' || g === 'geometrycollection';
+const polygonEnabledFor = (g) => g === 'polygon' || g === 'multipolygon' || g === 'geometrycollection';
+// Attaches leaflet-draw to the react-leaflet map and emits GeoJSON on changes.
+// Per-geometry behavior:
+//   point / polygon         -> single instance (add hidden once one exists; move/remove)
+//   multipoint              -> many draggable/removable points
+//   multipolygon            -> many editable/removable polygons
+//   geometrycollection      -> many points AND many polygons
+function DrawEditor({ geometry, value, onChange, }) {
+    const map = (0, react_leaflet_1.useMap)();
+    const texts = (0, texts_1.getThemeTexts)((0, styles_1.useTheme)());
+    const featureGroupRef = (0, react_1.useRef)(null);
+    const drawControlRef = (0, react_1.useRef)(null);
+    const lastEmittedRef = (0, react_1.useRef)('__init__');
+    const onChangeRef = (0, react_1.useRef)(onChange);
+    onChangeRef.current = onChange;
+    const geometryRef = (0, react_1.useRef)(geometry);
+    geometryRef.current = geometry;
+    // Hides the add tool for single-instance fields once a shape exists; existing
+    // shapes stay draggable (points) / editable (polygons) and removable.
+    const updateCap = () => {
+        const featureGroup = featureGroupRef.current;
+        const drawControl = drawControlRef.current;
+        if (!featureGroup || !drawControl)
+            return;
+        const g = geometryRef.current;
+        const { markers, polygons } = layerCounts(featureGroup);
+        const single = isSingle(g);
+        const capMarker = single && g === 'point' && markers > 0;
+        const capPolygon = single && g === 'polygon' && polygons > 0;
+        // setDrawingOptions() only stores options — it does not re-render the
+        // toolbar, so a capped single-instance field would keep an active "add"
+        // button. Rebuild the control so the button is actually hidden/disabled.
+        map.removeControl(drawControl);
+        const rebuilt = new leaflet_1.default.Control.Draw({
+            draw: {
+                marker: markerEnabledFor(g) && !capMarker ? {} : false,
+                polygon: polygonEnabledFor(g) && !capPolygon ? {} : false,
+                polyline: false,
+                rectangle: false,
+                circle: false,
+                circlemarker: false,
+            },
+            edit: { featureGroup },
+        });
+        drawControlRef.current = rebuilt;
+        map.addControl(rebuilt);
+    };
+    const emit = () => {
+        var _a;
+        const featureGroup = featureGroupRef.current;
+        if (!featureGroup)
+            return;
+        const g = geometryRef.current;
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const output = buildOutput(g, ((_a = featureGroup.toGeoJSON()) === null || _a === void 0 ? void 0 : _a.features) || []);
+        const text = output ? JSON.stringify(output) : '';
+        lastEmittedRef.current = text;
+        onChangeRef.current(text || null);
+        updateCap();
+    };
+    // Markers are draggable so an existing point can be moved; drag-end updates value.
+    const applyBehaviors = (layer) => {
+        if (layer instanceof leaflet_1.default.Marker) {
+            layer.options.draggable = true;
+            layer.on('dragend', emit);
+        }
+    };
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const addGeoJSON = (data) => {
+        const featureGroup = featureGroupRef.current;
+        if (!featureGroup || !data)
+            return;
+        leaflet_1.default.geoJSON(data).eachLayer((layer) => {
+            featureGroup.addLayer(layer);
+            applyBehaviors(layer);
+        });
+        const bounds = featureGroup.getBounds();
+        if (bounds.isValid())
+            map.fitBounds(bounds, { padding: [40, 40] });
+    };
+    (0, react_1.useEffect)(() => {
+        applyLeafletDrawLocalization(texts.geometry);
+        const featureGroup = new leaflet_1.default.FeatureGroup().addTo(map);
+        featureGroupRef.current = featureGroup;
+        const g = geometryRef.current;
+        const drawControl = new leaflet_1.default.Control.Draw({
+            draw: {
+                marker: markerEnabledFor(g) ? {} : false,
+                polygon: polygonEnabledFor(g) ? {} : false,
+                polyline: false,
+                rectangle: false,
+                circle: false,
+                circlemarker: false,
+            },
+            edit: { featureGroup },
+        });
+        drawControlRef.current = drawControl;
+        map.addControl(drawControl);
+        map.on(leaflet_1.default.Draw.Event.CREATED, 
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        (e) => {
+            // Forbid a second single-instance shape (point/polygon) even if the
+            // toolbar was manually re-enabled.
+            const g = geometryRef.current;
+            if (isSingle(g)) {
+                const isMarker = e.layer instanceof leaflet_1.default.Marker;
+                const isPolygon = e.layer instanceof leaflet_1.default.Polygon;
+                const { markers, polygons } = layerCounts(featureGroup);
+                if ((g === 'point' && isMarker && markers > 0) ||
+                    (g === 'polygon' && isPolygon && polygons > 0)) {
+                    return;
+                }
+            }
+            featureGroup.addLayer(e.layer);
+            applyBehaviors(e.layer);
+            emit();
+        });
+        map.on(leaflet_1.default.Draw.Event.EDITED, emit);
+        map.on(leaflet_1.default.Draw.Event.DELETED, emit);
+        const initial = (0, utils_1.parseGeoJSON)(geometry, value);
+        if (initial)
+            addGeoJSON(initial);
+        updateCap();
+        return () => {
+            if (drawControlRef.current)
+                map.removeControl(drawControlRef.current);
+            map.removeLayer(featureGroup);
+            featureGroupRef.current = null;
+            drawControlRef.current = null;
+        };
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, []);
+    // Sync externally-driven value (reset after save/edit elsewhere). Avoids the
+    // feedback loop when this component itself emitted the change. Malformed text
+    // keeps the last valid geometry on the map (an error is shown in the field);
+    // only a legitimate empty value clears the features.
+    (0, react_1.useEffect)(() => {
+        const normalized = value || '';
+        if (normalized === lastEmittedRef.current)
+            return;
+        lastEmittedRef.current = normalized;
+        const featureGroup = featureGroupRef.current;
+        if (!featureGroup)
+            return;
+        const geo = (0, utils_1.parseGeoJSON)(geometry, value);
+        if (geo) {
+            featureGroup.clearLayers();
+            addGeoJSON(geo);
+        }
+        else if (normalized.trim() === '') {
+            featureGroup.clearLayers();
+            updateCap();
+        }
+        // malformed non-empty text: keep current features, error is shown in the field
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [value, geometry, map]);
+    return null;
+}
+function MapGeometryPicker({ geometry, value, label, onChange, error, helperText, sx, height = 340, }) {
+    const texts = (0, texts_1.getThemeTexts)((0, styles_1.useTheme)());
+    const geometryTexts = texts.geometry;
+    const valueText = value || '';
+    // Malformed detection: non-empty text that isn't GeoJSON (or of the wrong
+    // geometry type). Invalid input is flagged as an error instead of silently
+    // wiping the features from the map.
+    const malformed = valueText.trim() !== '' && !(0, utils_1.parseGeoJSON)(geometry, valueText);
+    return (react_1.default.createElement(Box_1.default, { sx: Object.assign({ mt: 1, mb: 1, width: '100%' }, sx) },
+        react_1.default.createElement(Box_1.default, { "data-testid": `map-${geometry}`, sx: {
+                height,
+                width: '100%',
+                overflow: 'hidden',
+                borderRadius: 1,
+                border: (t) => `1px solid ${error ? t.palette.error.main : t.palette.divider}`,
+                zIndex: 1 /* keep leaflet controls above MUI overlays */,
+            } },
+            react_1.default.createElement(react_leaflet_1.MapContainer, { center: [-14.235, -51.9253], zoom: 4, style: { height: '100%', width: '100%' }, zoomControl: false },
+                react_1.default.createElement(react_leaflet_1.ZoomControl, { zoomInTitle: geometryTexts.zoomIn, zoomOutTitle: geometryTexts.zoomOut }),
+                react_1.default.createElement(react_leaflet_1.TileLayer, { attribution: "\u00A9 OpenStreetMap contributors", url: "https://{s}.tile.openstreetmap.org/{z}/{x}/{y}.png" }),
+                react_1.default.createElement(DrawEditor, { geometry: geometry, value: value, onChange: onChange }))),
+        react_1.default.createElement(TextField_1.default, { value: value, onChange: (e) => onChange(e.target.value || null), variant: "outlined", margin: "dense", fullWidth: true, size: "small", label: geometry === 'point' ? geometryTexts.labelPoint : geometryTexts.labelOther, multiline: geometry !== 'point', minRows: geometry !== 'point' ? 3 : 1, sx: { mt: 1 }, error: malformed, helperText: malformed ? geometryTexts.malformed : geometryTexts.synced }),
+        label && react_1.default.createElement(FormHelperText_1.default, { sx: { mt: 0.5 } }, label),
+        (helperText || error) && (react_1.default.createElement(FormHelperText_1.default, { error: error, sx: { mt: 0.5 } }, helperText))));
+}
+const isSingle = (g) => g === 'point' || g === 'polygon';

package/dist/components/forms/inputs/PatternFieldBySchema.d.ts

@@ -0,0 +1,4 @@
+import React from 'react';
+import { FieldBySchemaProps } from '../../../@types';
+export default function PatternFieldBySchema({ name, schema, control, errors, fieldKey, index, sx, type, autoComplete, disabled, onValueChange, autoFocus, ...other }: FieldBySchemaProps): React.JSX.Element | undefined;
+//# sourceMappingURL=PatternFieldBySchema.d.ts.map

package/dist/components/forms/inputs/PatternFieldBySchema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PatternFieldBySchema.d.ts","sourceRoot":"","sources":["../../../../src/components/forms/inputs/PatternFieldBySchema.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,OAAO,CAAC;AAM1B,OAAO,EAAE,kBAAkB,EAAE,MAAM,iBAAiB,CAAC;AAErD,MAAM,CAAC,OAAO,UAAU,oBAAoB,CAAC,EAC3C,IAAI,EACJ,MAAM,EACN,OAAO,EACP,MAAM,EACN,QAAQ,EACR,KAAK,EACL,EAAc,EACd,IAAI,EACJ,YAAY,EACZ,QAAQ,EACR,aAAa,EACb,SAAS,EACT,GAAG,KAAK,EACT,EAAE,kBAAkB,iCA8DpB"}

package/dist/components/forms/inputs/PatternFieldBySchema.js

@@ -0,0 +1,56 @@
+"use strict";
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = PatternFieldBySchema;
+const react_1 = __importDefault(require("react"));
+const react_hook_form_1 = require("react-hook-form");
+const react_number_format_1 = require("react-number-format");
+const TextField_1 = __importDefault(require("@mui/material/TextField"));
+const utils_1 = require("../../../utils");
+function PatternFieldBySchema(_a) {
+    var _b;
+    var { name, schema, control, errors, fieldKey, index, sx = { mr: 2 }, type, autoComplete, disabled, onValueChange, autoFocus } = _a, other = __rest(_a, ["name", "schema", "control", "errors", "fieldKey", "index", "sx", "type", "autoComplete", "disabled", "onValueChange", "autoFocus"]);
+    if (!(name in schema)) {
+        console.error(`PatternFieldBySchema: could not find schema for ${name}! Not rendering`);
+        return;
+    }
+    const fieldSchema = schema[name];
+    if (fieldKey && index && index >= 0) {
+        name = `${fieldKey}.${index}.${name}`;
+    }
+    const { error, helperText } = fieldKey && index && index >= 0
+        ? (0, utils_1.errorProps)({
+            fieldKey,
+            index,
+            fieldKeyProp: name,
+            errors,
+        })
+        : {
+            error: errors && Boolean(errors[name]),
+            helperText: errors && errors[name] ? (_b = errors[name]) === null || _b === void 0 ? void 0 : _b.message : fieldSchema.help_text || '',
+        };
+    return (react_1.default.createElement(react_hook_form_1.Controller, { name: name, control: control, render: ({ field }) => {
+            const { ref } = field, props = __rest(field, ["ref"]);
+            return (react_1.default.createElement(react_number_format_1.PatternFormat, Object.assign({ inputRef: ref }, props, other, { id: name, key: name, label: fieldSchema.label, required: (0, utils_1.isFieldRequired)(fieldSchema), disabled: fieldSchema.disabled === true || disabled, onChange: undefined, onValueChange: (values) => {
+                    field.onChange(values.value);
+                    if (onValueChange) {
+                        onValueChange(values.value);
+                    }
+                }, margin: "normal", fullWidth: true, error: error, helperText: helperText, sx: sx, type: type, autoComplete: autoComplete, autoFocus: autoFocus, 
+                // valueIsNumericString
+                format: fieldSchema.pattern_format || '', mask: "_", customInput: TextField_1.default })));
+        } }));
+}

package/dist/components/forms/inputs/TextFieldBySchema.d.ts

@@ -0,0 +1,4 @@
+import React from 'react';
+import { FieldBySchemaProps } from '../../../@types';
+export default function TextFieldBySchema({ name, schema, control, errors, multiline, minRows, fieldKey, index, sx, type, autoComplete, disabled, onValueChange, autoFocus, ...other }: FieldBySchemaProps): React.JSX.Element | undefined;
+//# sourceMappingURL=TextFieldBySchema.d.ts.map

package/dist/components/forms/inputs/TextFieldBySchema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TextFieldBySchema.d.ts","sourceRoot":"","sources":["../../../../src/components/forms/inputs/TextFieldBySchema.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,OAAO,CAAC;AAK1B,OAAO,EAAE,kBAAkB,EAAE,MAAM,iBAAiB,CAAC;AAErD,MAAM,CAAC,OAAO,UAAU,iBAAiB,CAAC,EACxC,IAAI,EACJ,MAAM,EACN,OAAO,EACP,MAAM,EACN,SAAiB,EACjB,OAAO,EACP,QAAQ,EACR,KAAK,EACL,EAAc,EACd,IAAI,EACJ,YAAY,EACZ,QAAQ,EACR,aAAa,EACb,SAAS,EACT,GAAG,KAAK,EACT,EAAE,kBAAkB,iCA6DpB"}

package/dist/components/forms/inputs/TextFieldBySchema.js

@@ -0,0 +1,56 @@
+"use strict";
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = TextFieldBySchema;
+const react_1 = __importDefault(require("react"));
+const react_hook_form_1 = require("react-hook-form");
+const TextField_1 = __importDefault(require("@mui/material/TextField"));
+const utils_1 = require("../../../utils");
+function TextFieldBySchema(_a) {
+    var _b;
+    var { name, schema, control, errors, multiline = false, minRows, fieldKey, index, sx = { mr: 2 }, type, autoComplete, disabled, onValueChange, autoFocus } = _a, other = __rest(_a, ["name", "schema", "control", "errors", "multiline", "minRows", "fieldKey", "index", "sx", "type", "autoComplete", "disabled", "onValueChange", "autoFocus"]);
+    if (!(name in schema)) {
+        console.error(`TextFieldBySchema: could not find schema for ${name}! Not rendering`);
+        return;
+    }
+    const fieldSchema = schema[name];
+    if (fieldKey && index && index >= 0) {
+        name = `${fieldKey}.${index}.${name}`;
+    }
+    if (fieldSchema.type === 'password') {
+        type = 'password';
+    }
+    if (type === 'password') {
+        autoComplete = 'current-password';
+    }
+    const { error, helperText } = fieldKey && index && index >= 0
+        ? (0, utils_1.errorProps)({
+            fieldKey,
+            index,
+            fieldKeyProp: name,
+            errors,
+        })
+        : {
+            error: errors && Boolean(errors[name]),
+            helperText: errors && errors[name] ? (_b = errors[name]) === null || _b === void 0 ? void 0 : _b.message : fieldSchema.help_text || '',
+        };
+    return (react_1.default.createElement(react_hook_form_1.Controller, { name: name, control: control, render: ({ field }) => (react_1.default.createElement(TextField_1.default, Object.assign({}, field, other, { id: name, key: name, label: fieldSchema.label, required: (0, utils_1.isFieldRequired)(fieldSchema), disabled: fieldSchema.disabled === true || disabled, onChange: (e) => {
+                field.onChange(e.target.value);
+                if (onValueChange) {
+                    onValueChange(e);
+                }
+            }, margin: "normal", fullWidth: true, multiline: multiline, error: error, helperText: helperText, sx: sx, type: type, autoComplete: autoComplete, minRows: minRows, autoFocus: autoFocus }))) }));
+}

package/dist/components/forms/inputs/leafletMarker.d.ts

@@ -0,0 +1,12 @@
+import L from 'leaflet';
+export declare const DEFAULT_MARKER_PIN_SVG: string;
+export declare const DEFAULT_MARKER_SHADOW_SVG: string;
+export declare const DEFAULT_MARKER_ICON_URL: string;
+export declare const DEFAULT_MARKER_SHADOW_URL: string;
+/**
+ * Point L.Icon.Default at a servable marker so geometry widgets render points.
+ * No args: apply the built-in SVG icon once; skip if any icon is already set.
+ * With `userOptions`: always merge (custom marker wins).
+ */
+export declare function applyDefaultLeafletIcon(userOptions?: Partial<L.IconOptions>): void;
+//# sourceMappingURL=leafletMarker.d.ts.map

package/dist/components/forms/inputs/leafletMarker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"leafletMarker.d.ts","sourceRoot":"","sources":["../../../../src/components/forms/inputs/leafletMarker.ts"],"names":[],"mappings":"AAAA,OAAO,CAAC,MAAM,SAAS,CAAC;AAKxB,eAAO,MAAM,sBAAsB,QAIzB,CAAC;AAEX,eAAO,MAAM,yBAAyB,QAG5B,CAAC;AAIX,eAAO,MAAM,uBAAuB,QAAoC,CAAC;AACzE,eAAO,MAAM,yBAAyB,QAAuC,CAAC;AAgB9E;;;;GAIG;AACH,wBAAgB,uBAAuB,CAAC,WAAW,CAAC,EAAE,OAAO,CAAC,CAAC,CAAC,WAAW,CAAC,GAAG,IAAI,CAalF"}

package/dist/components/forms/inputs/leafletMarker.js

@@ -0,0 +1,52 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_MARKER_SHADOW_URL = exports.DEFAULT_MARKER_ICON_URL = exports.DEFAULT_MARKER_SHADOW_SVG = exports.DEFAULT_MARKER_PIN_SVG = void 0;
+exports.applyDefaultLeafletIcon = applyDefaultLeafletIcon;
+const leaflet_1 = __importDefault(require("leaflet"));
+// Leaflet's stock icons are page-relative PNGs that 404 inside an SPA. Use an
+// inline-SVG data-URI default so markers render under any bundler with no assets.
+exports.DEFAULT_MARKER_PIN_SVG = '<svg xmlns="http://www.w3.org/2000/svg" width="25" height="41" viewBox="0 0 25 41">' +
+    '<path d="M12.5 0C6.7 0 2.1 4.2 2.1 9.4c0 7.7 10.4 31.6 10.4 31.6S22.9 17.1 22.9 9.4C22.9 4.2 18.3 0 12.5 0z" fill="#3388ff" stroke="#ffffff" stroke-width="1.5" stroke-linejoin="round"/>' +
+    '<circle cx="12.5" cy="9" r="6.2" fill="#ffffff"/>' +
+    '</svg>';
+exports.DEFAULT_MARKER_SHADOW_SVG = '<svg xmlns="http://www.w3.org/2000/svg" width="41" height="41" viewBox="0 0 41 41">' +
+    '<path d="M20.5 38c-5.4 0-9.7-1-9.9-2.2-.2-1.2 4.1-2.1 9.6-2.1 5.6 0 10.2 1 10 2.2-.2 1.2-4.3 2.1-9.7 2.1z" fill="rgba(0,0,0,0.4)"/>' +
+    '</svg>';
+const toDataUri = (svg) => `data:image/svg+xml;charset=utf-8,${encodeURIComponent(svg)}`;
+exports.DEFAULT_MARKER_ICON_URL = toDataUri(exports.DEFAULT_MARKER_PIN_SVG);
+exports.DEFAULT_MARKER_SHADOW_URL = toDataUri(exports.DEFAULT_MARKER_SHADOW_SVG);
+let applied = false;
+const DEFAULT_ICON_OPTIONS = {
+    iconUrl: exports.DEFAULT_MARKER_ICON_URL,
+    iconRetinaUrl: exports.DEFAULT_MARKER_ICON_URL, // SVG scales; stays crisp on retina
+    shadowUrl: exports.DEFAULT_MARKER_SHADOW_URL,
+    iconSize: leaflet_1.default.point(25, 41),
+    iconAnchor: leaflet_1.default.point(12, 41),
+    popupAnchor: leaflet_1.default.point(1, -34),
+    tooltipAnchor: leaflet_1.default.point(16, -28),
+    shadowSize: leaflet_1.default.point(41, 41),
+    shadowAnchor: leaflet_1.default.point(12, 41),
+};
+/**
+ * Point L.Icon.Default at a servable marker so geometry widgets render points.
+ * No args: apply the built-in SVG icon once; skip if any icon is already set.
+ * With `userOptions`: always merge (custom marker wins).
+ */
+function applyDefaultLeafletIcon(userOptions) {
+    if (userOptions) {
+        leaflet_1.default.Icon.Default.mergeOptions(userOptions); // explicit custom icon wins
+        applied = true;
+        return;
+    }
+    if (applied)
+        return;
+    if (leaflet_1.default.Icon.Default.prototype.options.iconUrl) {
+        applied = true; // consumer already picked their own icon; keep it
+        return;
+    }
+    leaflet_1.default.Icon.Default.mergeOptions(DEFAULT_ICON_OPTIONS);
+    applied = true;
+}

package/dist/context/APIWrapper.d.ts

@@ -0,0 +1,18 @@
+import React from 'react';
+import { TField } from '../@types';
+import { DialogType, FormTools, PageFormType, SnackBarType } from './APIWrapperContext';
+interface APIWrapperProps<T extends TField = void> {
+    handleLoading: (x: boolean) => void;
+    setSnackBar: (x: Partial<SnackBarType>) => void;
+    setDialog: (newState: Partial<DialogType> | null) => void;
+    pageForm: PageFormType<T> | null;
+    setPageForm: (x: Partial<PageFormType<T>>) => void;
+    resetPageForm: () => void;
+    formTools?: FormTools<T>;
+    setFormTools: (x: FormTools<T>) => void;
+    children: React.ReactNode;
+}
+declare function APIWrapper({ handleLoading, setSnackBar, setDialog, pageForm, setPageForm, resetPageForm, formTools, setFormTools, children, }: APIWrapperProps): React.JSX.Element;
+declare const _default: React.MemoExoticComponent<typeof APIWrapper>;
+export default _default;
+//# sourceMappingURL=APIWrapper.d.ts.map

package/dist/context/APIWrapper.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"APIWrapper.d.ts","sourceRoot":"","sources":["../../src/context/APIWrapper.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAwE,MAAM,OAAO,CAAC;AAM7F,OAAO,EAgBL,MAAM,EAGP,MAAM,WAAW,CAAC;AAkCnB,OAAO,EAEL,UAAU,EAEV,SAAS,EAMT,YAAY,EACZ,YAAY,EACb,MAAM,qBAAqB,CAAC;AAI7B,UAAU,eAAe,CAAC,CAAC,SAAS,MAAM,GAAG,IAAI;IAC/C,aAAa,EAAE,CAAC,CAAC,EAAE,OAAO,KAAK,IAAI,CAAC;IACpC,WAAW,EAAE,CAAC,CAAC,EAAE,OAAO,CAAC,YAAY,CAAC,KAAK,IAAI,CAAC;IAChD,SAAS,EAAE,CAAC,QAAQ,EAAE,OAAO,CAAC,UAAU,CAAC,GAAG,IAAI,KAAK,IAAI,CAAC;IAC1D,QAAQ,EAAE,YAAY,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC;IACjC,WAAW,EAAE,CAAC,CAAC,EAAE,OAAO,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC,KAAK,IAAI,CAAC;IACnD,aAAa,EAAE,MAAM,IAAI,CAAC;IAC1B,SAAS,CAAC,EAAE,SAAS,CAAC,CAAC,CAAC,CAAC;IACzB,YAAY,EAAE,CAAC,CAAC,EAAE,SAAS,CAAC,CAAC,CAAC,KAAK,IAAI,CAAC;IACxC,QAAQ,EAAE,KAAK,CAAC,SAAS,CAAC;CAC3B;AAED,iBAAS,UAAU,CAAC,EAClB,aAAa,EACb,WAAW,EACX,SAAS,EACT,QAAQ,EACR,WAAW,EACX,aAAa,EACb,SAAS,EACT,YAAY,EACZ,QAAQ,GACT,EAAE,eAAe,qBA2uBjB;;AAED,wBAAsC"}