@sakuzu/maplibre-gl-draw 1.0.0

package/dist/api/import-export/image-import.js

@@ -0,0 +1,53 @@
+// SPDX-FileCopyrightText: 2026 SAKAIDA Atsushi
+// SPDX-License-Identifier: AGPL-3.0-only
+/**
+ * Import of image files (creates an Image feature)
+ */
+import { processImageFile } from '../../shared/utils/image.js';
+/**
+ * Imports an image file and creates an Image feature
+ */
+export async function loadImage(file, options, deps) {
+    if (!options.coordinate) {
+        throw new Error('Image files require coordinate option');
+    }
+    const { store, autoNameGenerator, generateFeatureId, getCurrentLayerId } = deps;
+    const processed = await processImageFile(file);
+    // Create the FileData
+    const fileId = generateFeatureId();
+    const fileData = {
+        id: fileId,
+        mimeType: processed.mimeType,
+        dataURL: processed.dataUrl,
+    };
+    // Create the Image feature
+    const featureId = generateFeatureId();
+    const layerId = options.layerId || getCurrentLayerId();
+    const autoName = autoNameGenerator.generateName('Image');
+    const feature = {
+        id: featureId,
+        type: 'Image',
+        coordinates: options.coordinate,
+        layerId,
+        properties: {
+            imageFileId: fileId,
+            imageWidth: processed.width,
+            imageHeight: processed.height,
+            createdZoom: options.zoom ?? 1,
+            ...(autoName !== undefined && { name: autoName }),
+        },
+        locked: false,
+        visible: true,
+    };
+    // Create the file and the feature in a transaction
+    store.transact(() => {
+        store.createFile(fileData);
+        store.createFeature(feature);
+        store.setSelection('feature', [featureId]);
+    });
+    return {
+        format: 'image',
+        featureIds: [featureId],
+        replaced: false,
+    };
+}

package/dist/api/import-export/index.d.ts

@@ -0,0 +1,9 @@
+import type { ExportFormat, ExportOptions, ExportResult, LoadOptions, LoadResult } from '../../store/types.js';
+/**
+ * Import/Export API interface
+ */
+export interface ImportExportAPI {
+    load(source: File | unknown, options?: LoadOptions): Promise<LoadResult>;
+    export(format: ExportFormat, options?: ExportOptions): ExportResult;
+    getSuggestedFileName(): string;
+}

package/dist/api/import-export/index.js

@@ -0,0 +1,107 @@
+// SPDX-FileCopyrightText: 2026 SAKAIDA Atsushi
+// SPDX-License-Identifier: AGPL-3.0-only
+/**
+ * Orchestrator of the Import/Export API
+ *
+ * createImportExportAPI is a thin orchestrator that detects the format and then delegates
+ * to each import/export function. The implementation is spread across format-detection /
+ * geojson-import / geojson-export / native-format / image-import / file-name.
+ */
+import { isImageFile } from '../../shared/utils/image.js';
+import { buildExportFileName } from './file-name.js';
+import { isGeoJSONFeatureCollection, isNativeFormat } from './format-detection.js';
+import { exportGeoJSON } from './geojson-export.js';
+import { loadGeoJSON } from './geojson-import.js';
+import { loadImage } from './image-import.js';
+import { exportNative, loadNative } from './native-format.js';
+/**
+ * Creates the Import/Export API
+ *
+ * @internal
+ */
+export function createImportExportAPI(context) {
+    const { store, generateFeatureId, getCurrentLayerId, autoNameGenerator } = context;
+    const importDeps = {
+        store,
+        autoNameGenerator,
+        generateFeatureId,
+        getCurrentLayerId,
+    };
+    const api = {
+        /**
+         * Loads data or a file.
+         *
+         * Detects the kind of source automatically and handles it accordingly:
+         *   - File: detects the file kind automatically (image / .json / .geojson)
+         *   - object: detects the data format automatically (native format /
+         *     GeoJSON FeatureCollection)
+         */
+        async load(source, options) {
+            if (source instanceof File) {
+                if (isImageFile(source)) {
+                    return loadImage(source, options || {}, importDeps);
+                }
+                const fileName = source.name.toLowerCase();
+                const mimeType = source.type;
+                const isJsonFile = fileName.endsWith('.json') ||
+                    fileName.endsWith('.geojson') ||
+                    mimeType === 'application/json' ||
+                    mimeType === 'application/geo+json';
+                if (isJsonFile) {
+                    const text = await source.text();
+                    let data;
+                    try {
+                        data = JSON.parse(text);
+                    }
+                    catch (error) {
+                        const detail = error instanceof Error ? error.message : String(error);
+                        throw new Error(`Invalid JSON file "${source.name}": ${detail}`);
+                    }
+                    return api.load(data, options);
+                }
+                throw new Error(`Unsupported file type: ${source.type || source.name}`);
+            }
+            if (isNativeFormat(source)) {
+                return loadNative(source, { store });
+            }
+            if (isGeoJSONFeatureCollection(source)) {
+                return loadGeoJSON(source, importDeps, { flattenMulti: options?.flattenMulti });
+            }
+            throw new Error('Unsupported data format. Expected native format or GeoJSON FeatureCollection.');
+        },
+        /**
+         * Exports the data
+         */
+        export(format, options) {
+            const metadata = store.getMetadata();
+            if (format === 'native') {
+                const data = exportNative(store, options);
+                const fileName = options?.fileName || buildExportFileName(metadata, '.maplibre-gl-draw.json');
+                return {
+                    format: 'native',
+                    data: JSON.stringify(data, null, 2),
+                    mimeType: 'application/json',
+                    fileName,
+                };
+            }
+            if (format === 'geojson') {
+                const data = exportGeoJSON(store, options);
+                const fileName = options?.fileName || buildExportFileName(metadata, '.geojson');
+                return {
+                    format: 'geojson',
+                    data: JSON.stringify(data, null, 2),
+                    mimeType: 'application/geo+json',
+                    fileName,
+                };
+            }
+            throw new Error(`Unsupported export format: ${format}`);
+        },
+        /**
+         * Generates a suggested export file name
+         */
+        getSuggestedFileName() {
+            return buildExportFileName(store.getMetadata(), '.maplibre-gl-draw.json');
+        },
+    };
+    return api;
+}

package/dist/api/import-export/native-format.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Import / export of the native format
+ */
+import type { Store } from '../../store/store.js';
+import type { Data, ExportOptions, LoadResult } from '../../store/types.js';
+/**
+ * Exports the current data in the native format
+ */
+export declare function exportNative(store: Store, options?: ExportOptions): Data;
+/**
+ * Imports the native format (replaces the existing data)
+ */
+export declare function loadNative(data: Data, deps: {
+    store: Store;
+}): Promise<LoadResult>;

package/dist/api/import-export/native-format.js

@@ -0,0 +1,126 @@
+// SPDX-FileCopyrightText: 2026 SAKAIDA Atsushi
+// SPDX-License-Identifier: AGPL-3.0-only
+import { NATIVE_VERSION } from './constants.js';
+import { validateNativeData } from './native-validation.js';
+/** The layer that survives the replacement (it is updated in place when the data has it) */
+const DEFAULT_LAYER_ID = 'default-layer';
+/**
+ * Exports the current data in the native format
+ */
+export function exportNative(store, options) {
+    let features = store.getAllFeatures();
+    const layers = store.getAllLayers();
+    const groups = store.getAllGroups();
+    if (options?.featureIds && options.featureIds.length > 0) {
+        const featureIdSet = new Set(options.featureIds);
+        features = features.filter((f) => featureIdSet.has(f.id));
+    }
+    if (options?.layerIds && options.layerIds.length > 0) {
+        const layerIdSet = new Set(options.layerIds);
+        features = features.filter((f) => layerIdSet.has(f.layerId));
+    }
+    // Get only the files that are in use
+    const usedFileIds = new Set();
+    for (const feature of features) {
+        if (feature.type === 'Image' && feature.properties.imageFileId) {
+            usedFileIds.add(feature.properties.imageFileId);
+        }
+    }
+    const files = store.getAllFiles();
+    const filesRecord = {};
+    for (const file of files) {
+        if (usedFileIds.has(file.id)) {
+            filesRecord[file.id] = file;
+        }
+    }
+    const metadata = store.getMetadata();
+    const now = new Date().toISOString();
+    return {
+        version: NATIVE_VERSION,
+        created: now,
+        modified: now,
+        metadata: Object.keys(metadata).length > 0 ? metadata : undefined,
+        layers,
+        // The whole stacking order, entries of the application that are not layers included
+        layerOrder: [...store.getLayerOrder()],
+        groups,
+        features,
+        files: Object.keys(filesRecord).length > 0 ? filesRecord : undefined,
+    };
+}
+/**
+ * Imports the native format (replaces the existing data)
+ */
+export async function loadNative(data, deps) {
+    const { store } = deps;
+    // Validate before applying. Since store.transact does not roll back, if an exception
+    // is thrown on invalid data after the existing data has been cleared, the existing data
+    // is lost. Everything the steps below rely on (the shape of the layers, groups, features
+    // and files, the references between them, and the uniqueness of the ids) is checked
+    // before the destructive operation, so a problem throws while the existing data is
+    // still intact.
+    const retainedLayerIds = new Set();
+    if (store.getLayer(DEFAULT_LAYER_ID))
+        retainedLayerIds.add(DEFAULT_LAYER_ID);
+    const { layers, layerOrder, groups, features, files } = await validateNativeData(data, retainedLayerIds);
+    const featureIds = features.map((f) => f.id);
+    // A kept layer the data does not list goes to the back, where it stays when the data does
+    // not mention it (every layer must be on the stacking order to be drawn)
+    const retainedUnlisted = [...retainedLayerIds].filter((id) => !layerOrder.includes(id));
+    // Import atomically (silent, so a subscriber that records changes leaves it out)
+    store.transact(() => {
+        // 1. Clear the existing data
+        const existingFeatures = store.getAllFeatures();
+        for (const feature of existingFeatures) {
+            store.deleteFeature(feature.id);
+        }
+        const existingGroups = store.getAllGroups();
+        for (const group of existingGroups) {
+            store.deleteGroup(group.id);
+        }
+        const existingLayers = store.getAllLayers();
+        for (const layer of existingLayers) {
+            if (layer.id !== DEFAULT_LAYER_ID) {
+                store.deleteLayer(layer.id);
+            }
+        }
+        // The files belong to the features that were just removed, and the data brings its own
+        // (leaving them would also make a file id of the data collide)
+        for (const file of store.getAllFiles()) {
+            store.deleteFile(file.id);
+        }
+        // 2. Import the layers
+        for (const layer of layers) {
+            if (store.getLayer(layer.id)) {
+                store.updateLayer(layer.id, layer);
+            }
+            else {
+                store.createLayer(layer);
+            }
+        }
+        // 3. Import the groups
+        for (const group of groups) {
+            store.createGroup(group);
+        }
+        // 4. Import the features
+        for (const feature of features) {
+            store.createFeature(feature);
+        }
+        // 5. Import the files
+        for (const file of files) {
+            store.createFile(file);
+        }
+        // 6. Replace the whole stacking order. Entries that are not layers are replaced too, so
+        //    nothing of the previous document is left on it
+        store.setLayerOrder([...retainedUnlisted, ...layerOrder]);
+        // 7. Import the metadata
+        if (data.metadata) {
+            store.setMetadata(data.metadata);
+        }
+    }, 'silent');
+    return {
+        format: 'native',
+        featureIds,
+        replaced: true,
+    };
+}

package/dist/api/import-export/native-validation.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Validation of native-format data before it replaces the store
+ *
+ * Loading the native format clears the existing data first, and store.transact does not roll
+ * back. Every property the import relies on is therefore checked here, before anything is
+ * deleted: a problem throws while the existing data is still intact. The checks follow the
+ * native format described in docs/reference/data-format.md.
+ */
+import type { Data, Feature, FileData, Group, Layer } from '../../store/types.js';
+/** Native data that passed validation, with the files normalized */
+export interface ValidatedNativeData {
+    layers: Layer[];
+    /** The stacking order, from the back */
+    layerOrder: string[];
+    groups: Group[];
+    /** The features in data order, each style reduced to its usable keys */
+    features: Feature[];
+    files: FileData[];
+}
+/**
+ * Validates native data before the destructive part of the import
+ *
+ * @param data - the data to load
+ * @param retainedLayerIds - IDs of the layers that remain in the store after it is cleared
+ * @throws when anything the import relies on is missing or malformed, or when the data has
+ *   another major version
+ */
+export declare function validateNativeData(data: Data, retainedLayerIds: ReadonlySet<string>): Promise<ValidatedNativeData>;

package/dist/api/import-export/native-validation.js

@@ -0,0 +1,212 @@
+// SPDX-FileCopyrightText: 2026 SAKAIDA Atsushi
+// SPDX-License-Identifier: AGPL-3.0-only
+import { NATIVE_VERSION } from './constants.js';
+import { normalizeEmbeddedFile } from './embedded-file.js';
+import { describeCoordinateProblem } from './geometry-validation.js';
+import { sanitizeFeatureStyle } from './style-validation.js';
+function fail(message) {
+    throw new Error(`Invalid native data: ${message}`);
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function isNonEmptyString(value) {
+    return typeof value === 'string' && value !== '';
+}
+function validateLayer(layer, index) {
+    if (!isRecord(layer))
+        fail(`layers[${index}] is not an object`);
+    const where = `layer "${String(layer.id)}"`;
+    if (!isNonEmptyString(layer.id))
+        fail(`layers[${index}] has no valid string id`);
+    if (typeof layer.name !== 'string')
+        fail(`${where} has no string name`);
+    if (typeof layer.visible !== 'boolean')
+        fail(`${where} has no boolean visible`);
+    if (typeof layer.locked !== 'boolean')
+        fail(`${where} has no boolean locked`);
+    if (typeof layer.opacity !== 'number' || !Number.isFinite(layer.opacity)) {
+        fail(`${where} has no finite opacity`);
+    }
+    if (!Array.isArray(layer.order) || !layer.order.every((id) => typeof id === 'string')) {
+        fail(`${where} has no order array of strings`);
+    }
+    if (layer.metadata !== undefined && !isRecord(layer.metadata)) {
+        fail(`${where} has a metadata that is not an object`);
+    }
+    if (layer.styleRule !== undefined && !isRecord(layer.styleRule)) {
+        fail(`${where} has a styleRule that is not an object`);
+    }
+    return layer;
+}
+function validateGroup(group, index) {
+    if (!isRecord(group))
+        fail(`groups[${index}] is not an object`);
+    const where = `group "${String(group.id)}"`;
+    if (!isNonEmptyString(group.id))
+        fail(`groups[${index}] has no valid string id`);
+    if (typeof group.name !== 'string')
+        fail(`${where} has no string name`);
+    if (typeof group.visible !== 'boolean')
+        fail(`${where} has no boolean visible`);
+    if (typeof group.locked !== 'boolean')
+        fail(`${where} has no boolean locked`);
+    if (!Array.isArray(group.featureIds) || !group.featureIds.every((id) => typeof id === 'string')) {
+        fail(`${where} has no featureIds array of strings`);
+    }
+    return group;
+}
+/** Parses a semantic version (major.minor.patch, with an optional pre-release or build) */
+function parseVersion(value) {
+    const match = /^(\d+)\.(\d+)\.(\d+)(?:[-+].*)?$/.exec(value);
+    return match ? [Number(match[1]), Number(match[2]), Number(match[3])] : null;
+}
+/**
+ * Checks the version of the data against the version this library writes
+ *
+ * Another major version is rejected, because it can change the meaning of any field. A newer
+ * minor version only adds fields, so it is read with a warning: the fields it adds are kept
+ * as they are but not interpreted.
+ */
+function validateVersion(version) {
+    if (typeof version !== 'string')
+        fail('version is not a string');
+    const parsed = parseVersion(version);
+    if (!parsed)
+        fail(`version "${version}" is not a semantic version`);
+    const [major, minor] = parsed;
+    const [supportedMajor, supportedMinor] = parseVersion(NATIVE_VERSION);
+    if (major !== supportedMajor) {
+        fail(`version ${version} is not supported (this library reads ${supportedMajor}.x)`);
+    }
+    if (minor > supportedMinor) {
+        console.warn(`Native data version ${version} is newer than ${NATIVE_VERSION}; ` +
+            'the fields it adds are kept but not interpreted');
+    }
+}
+/**
+ * Validates a feature and returns it with its style reduced to the usable keys
+ */
+function validateFeature(feature, index, layerIds, groupIds) {
+    if (!isRecord(feature))
+        fail(`features[${index}] is not an object`);
+    if (!isNonEmptyString(feature.id))
+        fail('feature without a valid string id');
+    const where = `feature "${feature.id}"`;
+    if (!isNonEmptyString(feature.type))
+        fail(`${where} has no string type`);
+    const coordinateProblem = describeCoordinateProblem(feature.type, feature.coordinates);
+    if (coordinateProblem)
+        fail(`${where} has ${coordinateProblem}`);
+    if (typeof feature.layerId !== 'string' || !layerIds.has(feature.layerId)) {
+        fail(`${where} refers to a layer that does not exist`);
+    }
+    if (feature.groupId !== undefined &&
+        (typeof feature.groupId !== 'string' || !groupIds.has(feature.groupId))) {
+        fail(`${where} refers to a group that does not exist`);
+    }
+    if (!isRecord(feature.properties))
+        fail(`${where} has no properties object`);
+    if (feature.style !== undefined && !isRecord(feature.style)) {
+        fail(`${where} has a style that is not an object`);
+    }
+    if (typeof feature.visible !== 'boolean')
+        fail(`${where} has no boolean visible`);
+    if (typeof feature.locked !== 'boolean')
+        fail(`${where} has no boolean locked`);
+    // A style key of the wrong type or form is dropped rather than rejecting the file: the
+    // store accepts any value through its API, so the library's own export can carry one
+    if (feature.style === undefined)
+        return feature;
+    const { style: _style, ...rest } = feature;
+    const style = sanitizeFeatureStyle(feature.style);
+    return (style === undefined ? rest : { ...rest, style });
+}
+async function validateFiles(files) {
+    if (files === undefined)
+        return [];
+    if (!isRecord(files))
+        fail('files is not an object');
+    const result = [];
+    for (const [key, file] of Object.entries(files)) {
+        if (!isRecord(file) || !isNonEmptyString(file.id) || file.id !== key) {
+            fail(`file "${key}" is not an object whose id matches its key`);
+        }
+        const content = await normalizeEmbeddedFile(file.dataURL, file.mimeType);
+        if (!content) {
+            fail(`file "${key}" is not an embedded PNG / JPEG / WebP / GIF data URL of its declared type`);
+        }
+        result.push({ ...file, ...content });
+    }
+    return result;
+}
+/**
+ * Validates the stacking order: distinct non-empty strings that list every layer of the data
+ *
+ * Entries that are not layers belong to the application and are kept as they are.
+ */
+function validateLayerOrder(value, layers) {
+    if (!Array.isArray(value))
+        fail('layerOrder is not an array');
+    const seen = new Set();
+    for (const [index, entry] of value.entries()) {
+        if (!isNonEmptyString(entry))
+            fail(`layerOrder[${index}] is not a non-empty string`);
+        if (seen.has(entry))
+            fail(`layerOrder lists "${entry}" twice`);
+        seen.add(entry);
+    }
+    for (const layer of layers) {
+        if (!seen.has(layer.id))
+            fail(`layerOrder does not list layer "${layer.id}"`);
+    }
+    return value;
+}
+/**
+ * Validates native data before the destructive part of the import
+ *
+ * @param data - the data to load
+ * @param retainedLayerIds - IDs of the layers that remain in the store after it is cleared
+ * @throws when anything the import relies on is missing or malformed, or when the data has
+ *   another major version
+ */
+export async function validateNativeData(data, retainedLayerIds) {
+    validateVersion(data.version);
+    if (!Array.isArray(data.features))
+        fail('features is not an array');
+    if (data.layers !== undefined && !Array.isArray(data.layers))
+        fail('layers is not an array');
+    if (data.groups !== undefined && !Array.isArray(data.groups))
+        fail('groups is not an array');
+    if (data.metadata !== undefined && !isRecord(data.metadata))
+        fail('metadata is not an object');
+    const layers = (data.layers ?? []).map(validateLayer);
+    const layerIds = new Set(retainedLayerIds);
+    const seenLayerIds = new Set();
+    for (const layer of layers) {
+        if (seenLayerIds.has(layer.id))
+            fail(`duplicate layer id "${layer.id}"`);
+        seenLayerIds.add(layer.id);
+        layerIds.add(layer.id);
+    }
+    const layerOrder = validateLayerOrder(data.layerOrder, layers);
+    // Feature and group IDs share the entries of layer.order, so they must not collide either
+    const itemIds = new Set();
+    const groups = (data.groups ?? []).map(validateGroup);
+    const groupIds = new Set();
+    for (const group of groups) {
+        if (itemIds.has(group.id))
+            fail(`duplicate group id "${group.id}"`);
+        itemIds.add(group.id);
+        groupIds.add(group.id);
+    }
+    const features = data.features.map((entry, index) => {
+        const feature = validateFeature(entry, index, layerIds, groupIds);
+        if (itemIds.has(feature.id))
+            fail(`duplicate feature id "${feature.id}"`);
+        itemIds.add(feature.id);
+        return feature;
+    });
+    const files = await validateFiles(data.files);
+    return { layers, layerOrder, groups, features, files };
+}

package/dist/api/import-export/own-property.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Copying of user-defined properties
+ *
+ * Property names come from the data being imported, so `__proto__` is an ordinary key there
+ * (JSON.parse creates it as an own property). Assigning it with `target[key] = value` would
+ * replace the prototype of the target instead, which hides the key, makes the other keys of
+ * the value appear as inherited properties and loses the key on the next export. Properties
+ * are therefore defined as own data properties, the same as JSON.parse does.
+ */
+export declare function setOwnProperty(target: Record<string, unknown>, key: string, value: unknown): void;

package/dist/api/import-export/own-property.js

@@ -0,0 +1,19 @@
+// SPDX-FileCopyrightText: 2026 SAKAIDA Atsushi
+// SPDX-License-Identifier: AGPL-3.0-only
+/**
+ * Copying of user-defined properties
+ *
+ * Property names come from the data being imported, so `__proto__` is an ordinary key there
+ * (JSON.parse creates it as an own property). Assigning it with `target[key] = value` would
+ * replace the prototype of the target instead, which hides the key, makes the other keys of
+ * the value appear as inherited properties and loses the key on the next export. Properties
+ * are therefore defined as own data properties, the same as JSON.parse does.
+ */
+export function setOwnProperty(target, key, value) {
+    Object.defineProperty(target, key, {
+        value,
+        writable: true,
+        enumerable: true,
+        configurable: true,
+    });
+}

package/dist/api/import-export/style-validation.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Validation of an imported feature style
+ *
+ * A style arrives from a file (the maplibre-gl-draw:style property of GeoJSON, the style of a
+ * native feature, the simplestyle-spec keys) and reaches the renderer, which parses the
+ * colors as #rgb / #rrggbb and uses the numbers as they are. A value of the wrong type or
+ * form (a number or null for a color, `red`, an opacity of 5) would make the parsing throw or
+ * produce NaN, so each known key is checked here and a key that fails is dropped. Keys this
+ * library does not define are kept unchanged, whatever their value: they belong to the host or
+ * to an extension, which gives features keys of its own and checks their values where it reads
+ * them (values reach the Store through updateFeature and a replaced store as well, without
+ * passing here).
+ */
+import type { FeatureStyle } from '../../store/types.js';
+type Check = (value: unknown) => boolean;
+/** A #rgb or #rrggbb color */
+export declare const isHexColor: Check;
+/**
+ * Returns the usable part of an imported style
+ *
+ * A key of FeatureStyle whose value fails its check is dropped; every other key is kept.
+ *
+ * @param value The style as read from the file
+ * @returns The style, or undefined when the value is not an object or nothing is left
+ */
+export declare function sanitizeFeatureStyle(value: unknown): FeatureStyle | undefined;
+export {};

package/dist/api/import-export/style-validation.js

@@ -0,0 +1,49 @@
+// SPDX-FileCopyrightText: 2026 SAKAIDA Atsushi
+// SPDX-License-Identifier: AGPL-3.0-only
+import { setOwnProperty } from './own-property.js';
+const HEX_COLOR = /^#(?:[0-9a-f]{3}|[0-9a-f]{6})$/i;
+/** A #rgb or #rrggbb color */
+export const isHexColor = (value) => typeof value === 'string' && HEX_COLOR.test(value);
+const isFiniteNumber = (value) => typeof value === 'number' && Number.isFinite(value);
+const isOpacity = (value) => isFiniteNumber(value) && value >= 0 && value <= 1;
+const isNonNegative = (value) => isFiniteNumber(value) && value >= 0;
+const oneOf = (...values) => (value) => typeof value === 'string' && values.includes(value);
+/** The check of every key of FeatureStyle */
+const STYLE_CHECK_TABLE = {
+    fillColor: isHexColor,
+    fillOpacity: isOpacity,
+    strokeColor: isHexColor,
+    strokeWidth: isNonNegative,
+    strokeOpacity: isOpacity,
+    lineStyle: oneOf('solid', 'dashed', 'dotted'),
+    pointRadius: isNonNegative,
+    pointColor: isHexColor,
+    pointShape: oneOf('circle', 'square', 'triangle', 'star'),
+    imageOpacity: isOpacity,
+};
+const STYLE_CHECKS = new Map(Object.entries(STYLE_CHECK_TABLE));
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+/**
+ * Returns the usable part of an imported style
+ *
+ * A key of FeatureStyle whose value fails its check is dropped; every other key is kept.
+ *
+ * @param value The style as read from the file
+ * @returns The style, or undefined when the value is not an object or nothing is left
+ */
+export function sanitizeFeatureStyle(value) {
+    if (!isRecord(value))
+        return undefined;
+    const style = {};
+    let kept = 0;
+    for (const [key, entry] of Object.entries(value)) {
+        const check = STYLE_CHECKS.get(key);
+        if (check && !check(entry))
+            continue;
+        setOwnProperty(style, key, entry);
+        kept++;
+    }
+    return kept > 0 ? style : undefined;
+}