TypesTypes

// With @element-editor/react:
import type { FeatureCollection, GeoJSONFeature, Schema } from '@element-editor/react'

// With an adapter, or for the other types on this page:
import type { FeatureCollection, GeoJSONFeature, Schema } from '@element-editor/core'

interface FeatureCollection {
  type: 'FeatureCollection'
  metadata: {
    schemas: Schema[]
    groups: Group[]
  }
  features: GeoJSONFeature[]
}

interface GeoJSONFeature {
  type: 'Feature'
  id: string                       // UUID; always present
  geometry: Geometry
  properties: Record<string, unknown>
  schemaId?: string                // RFC 7946 §6.1 — links feature to a Schema
  groupId?: string                 // RFC 7946 §6.1 — links feature to a Group
  hidden?: boolean                 // RFC 7946 §6.1 — visibility toggle
  _drawType?: DrawType             // RFC 7946 §6.1 — original drawing tool
  bbox?: [number, number, number, number]  // RFC 7946 §5 — [w, s, e, n]
}

interface FeatureCollectionInput {
  type: 'FeatureCollection'
  metadata?: { schemas?: Schema[]; groups?: Group[] }   // missing: the default schema, no groups
  features: GeoJSONFeatureInput[]
  bbox?: BBoxInput                                      // ignored
}

interface GeoJSONFeatureInput {
  type: 'Feature'
  id?: string | number                          // missing or '': a UUID; a number becomes a string ('0' included)
  geometry: GeometryInput | null                // null: left out on import, reported (see below)
  properties?: Record<string, unknown> | null   // missing or null: {}
  bbox?: BBoxInput                              // recomputed by Element
  schemaId?: string
  groupId?: string
  hidden?: boolean
  _drawType?: DrawType
}

type PositionInput = number[]                   // [lng, lat] or [lng, lat, altitude, …]
type BBoxInput = [number, number, number, number] | [number, number, number, number, number, number]
type GeometryInput =                            // every RFC 7946 geometry; each may carry a bbox
  | { type: 'Point'; coordinates: PositionInput }
  | { type: 'MultiPoint' | 'LineString'; coordinates: PositionInput[] }
  | { type: 'MultiLineString' | 'Polygon'; coordinates: PositionInput[][] }
  | { type: 'MultiPolygon'; coordinates: PositionInput[][][] }
  | { type: 'GeometryCollection'; geometries: GeometryInput[] }

import type { FeatureCollectionInput } from '@element-editor/react'

const data: FeatureCollectionInput = {
  type: 'FeatureCollection',
  features: [{ type: 'Feature', id: 1, geometry: { type: 'Point', coordinates: [14.42, 50.09] }, properties: null }],
}

import type * as GeoJSON from 'geojson'
const fc: GeoJSON.FeatureCollection = await (await fetch('/parcels.geojson')).json()
<ElementEditor initialData={fc} />            // no cast needed
ref.current?.setFeatureCollection(fc)

type DrawType = 'circle' | 'rectangle' | 'route'

interface Schema {
  id: string            // features reference it in `schemaId`
  name: string          // shown in the schema editor and the feature panel
  fields: SchemaField[] // in display order
}

import type { Schema } from '@element-editor/react'

const parcel: Schema = {
  id: 'parcel',
  name: 'Parcel',
  fields: [
    { key: 'owner', label: 'Owner', type: 'text', required: true },
    { key: 'area_ha', label: 'Area (ha)', type: 'number', required: false, min: 0 },
  ],
}

interface SchemaField {
  key: string         // auto-generated slug from label; used as the properties key
  label: string       // display name shown in forms
  type: FieldType
  required: boolean
  options?: string[]  // only for type 'select'
  min?: number        // only for type 'number'
  max?: number        // only for type 'number'
}

type FieldType = 'text' | 'textarea' | 'number' | 'url' | 'select' | 'date' | 'boolean'

interface Group {
  id: string
  name: string
  collapsed: boolean
  hidden?: boolean
}

interface PointGeometry {
  type: 'Point'
  coordinates: [number, number]  // [longitude, latitude]
}

interface LineStringGeometry {
  type: 'LineString'
  coordinates: [number, number][]  // [[lng, lat], ...]
}

interface PolygonGeometry {
  type: 'Polygon'
  coordinates: [number, number][][]  // [outer ring, ...optional inner rings (holes)]
}

interface MultiPointGeometry {
  type: 'MultiPoint'
  coordinates: [number, number][]
}

interface MultiLineStringGeometry {
  type: 'MultiLineString'
  coordinates: [number, number][][]
}

interface MultiPolygonGeometry {
  type: 'MultiPolygon'
  coordinates: [number, number][][][]
}

interface GeometryCollectionGeometry {
  type: 'GeometryCollection'
  geometries: SimpleGeometry[]
}

type SimpleGeometry =
  | PointGeometry
  | MultiPointGeometry
  | LineStringGeometry
  | MultiLineStringGeometry
  | PolygonGeometry
  | MultiPolygonGeometry

type Geometry = SimpleGeometry | GeometryCollectionGeometry

type CoordinateGeometry = SimpleGeometry

import { isSimpleGeometry } from '@element-editor/core'

if (isSimpleGeometry(feature.geometry)) {
  feature.geometry.coordinates  // narrowed to SimpleGeometry
}

type EditingMode =
  | 'none'
  | 'place-point'
  | 'draw-line'
  | 'draw-polygon'
  | 'draw-circle'
  | 'draw-rect'
  | 'draw-route'
  | 'draw-freehand'
  | 'picker'
  | 'measure'
  | 'cut-hole'
  | 'slice-shape'
  | 'simplify-shape'
  | 'smooth-shape'
  | 'buffer-shape'
  | 'measure'

interface DataStore {
  // State
  features: GeoJSONFeature[]
  schemas: Schema[]
  groups: Group[]
  selectedIds: string[]
  selectedGroupId: string | null   // the explicitly selected group (Cmd+G); cleared by every feature-selection action
  lastUsedSchemaId: string | null
  lastActiveGroupId: string | null
  undoStack: UndoEntry[]   // UndoEntry = { features: GeoJSONFeature[]; groups?: Group[]; schemas?: Schema[]; extras?: unknown }
  redoStack: UndoEntry[]
  lastModifiedAt: number | null
  clipboard: GeoJSONFeature[]
  maxFeatures?: number     // undefined = unlimited
  currentZoom: number
  geometryMode: 'visual' | 'spatial'

  // Feature actions
  // Refused by `maxFeatures` (the error is reported via onError): addFeature returns null, the other adding actions false
  addFeature: (
    feature: GeoJSONFeature,
    options?: { insertAfterId?: string; skipSnapshot?: boolean; programmatic?: boolean; undoable?: boolean },
  ) => GeoJSONFeature | null   // the stored feature
  updateFeature: (
    id: string,
    updates: Partial<Pick<GeoJSONFeature, 'properties' | 'geometry' | 'schemaId' | 'hidden'>> & { _drawType?: undefined },  // _drawType: undefined clears it
    options?: { skipValidation?: boolean },
  ) => void
  /** updateFeature for many features: one array copy, one notification, at most one undo step. */
  updateFeatures: (
    updates: ReadonlyArray<{ id: string; patch: FeaturePatch }>,   // FeaturePatch = updateFeature's `updates`
    options?: { skipValidation?: boolean; undoable?: boolean },
  ) => void
  updateFeatureValidation: (id: string, warnings: string[], errors: string[]) => void
  deleteFeature: (id: string) => void
  /** Removes many features in one step; returns how many were removed. `undoable: false` also drops them from undo/redo. */
  deleteFeatures: (ids: Iterable<string>, options?: { undoable?: boolean }) => number
  /** Removes `removeIds` and adds `added` (at the top) in one commit and ONE undo step, then selects the added features (boolean ops). */
  replaceFeatures: (removeIds: Iterable<string>, added: GeoJSONFeature[]) => boolean
  duplicateFeature: (id: string) => boolean
  duplicateFeaturesAtPosition: (entries: Array<{ sourceId: string; geometry: GeoJSONFeature['geometry'] }>) => boolean
  duplicateSelection: () => boolean
  copySelection: () => Promise<boolean>   // true when the system clipboard was written too
  pasteSelection: () => boolean   // all-or-nothing under maxFeatures
  takeSnapshot: () => void
  /** Lets the host keep its own state in each undo entry (`extras`): `capture` runs on every snapshot, `restore` on undo/redo. */
  setUndoExtrasHandlers: (capture: () => unknown, restore: (extras: unknown) => void) => void

  // Selection
  selectFeature: (id: string | null) => void
  toggleSelection: (id: string) => void
  setSelection: (ids: string[]) => void
  clearSelection: () => void
  selectGroup: (id: string | null) => void   // marks the selected group; doesn't touch selectedIds
  deleteSelection: () => void

  // Multi-geometry
  breakMultiGeometry: (id: string) => boolean
  mergeFeatures: () => void

  // History
  undo: () => void
  redo: () => void

  // Groups
  addGroup: (name: string) => void
  updateGroup: (id: string, updates: Partial<Pick<Group, 'name' | 'collapsed' | 'hidden'>>) => void
  deleteGroup: (id: string, mode: 'ungroup' | 'delete-features') => void
  toggleGroupCollapsed: (id: string) => void
  toggleGroupHidden: (id: string) => void
  toggleFeatureHidden: (id: string) => void
  moveFeatureToGroup: (featureId: string, groupId: string | null) => void
  reorderFeatures: (orderedIds: string[]) => void
  reorderGroups: (orderedIds: string[]) => void
  groupSelection: (name?: string) => string | null   // new group from the selection; null when it was empty
  ungroupSelection: () => void

  // Schemas
  getDefaultSchema: () => Schema
  getSchemaForFeature: (featureId: string) => Schema
  getVisibleSchemas: () => Schema[]
  setLastUsedSchemaId: (id: string) => void
  addSchema: (name: string, fields?: SchemaField[]) => string   // returns the new id
  updateSchema: (id: string, updates: { name: string }) => void
  deleteSchema: (id: string) => void   // no-op on the last schema
  addSchemaField: (schemaId: string, field: SchemaField) => void
  updateSchemaField: (schemaId: string, key: string, updates: Partial<SchemaField>) => void
  removeSchemaField: (schemaId: string, key: string) => void

  // Import / export
  exportGeoJSON: () => string
  importGeoJSON: (
    raw: unknown,
    mode: 'replace' | 'merge',
    limits?: { maxFeatures?: number; maxInputSize?: number; undoable?: boolean },
  ) => { skipped: number; duplicates: number; truncated: boolean }  // limits.maxFeatures defaults to the store's maxFeatures; undoable: false (replace) adds no undo step and clears the history
  updateFeaturesFromEditor: (raw: unknown) => void   // applies the GeoJSON inspector's edited text

  // Feature limit
  setMaxFeatures: (max?: number) => void
  canAddFeatures: (count: number) => boolean  // false = over the limit; also reports the error

  // Geometry mode
  setGeometryMode: (mode: 'visual' | 'spatial') => void
  setCurrentZoom: (z: number) => void
}

import type { UIStore } from '@element-editor/core'

const selectTableOpen = (s: UIStore) => s.tableOpen

type ShortcutId =
  | 'place-point'
  | 'draw-line'
  | 'draw-polygon'
  | 'draw-route'
  | 'draw-circle'
  | 'draw-rect'
  | 'draw-freehand'
  | 'picker'
  | 'measure'
  | 'cut-hole'
  | 'slice-shape'
  | 'break-apart'
  | 'toggle-table'
  | 'toggle-transform'
  | 'show-shortcuts'
  | 'toggle-geojson'
  | 'toggle-schema'
  | 'toggle-sidebar'
  | 'set-zoom'

type FixedShortcutId =
  | 'undo'
  | 'redo'
  | 'select-all'
  | 'delete-selected'
  | 'search-places'
  | 'finish-drawing'
  | 'cancel'
  | 'group-selection'
  | 'ungroup-selection'
  | 'edit-selected'
  | 'toggle-sticky-tool'
  | 'import-geojson'
  | 'export-geojson'

type AccentShade = 50 | 100 | 200 | 300 | 400 | 500 | 600 | 700 | 800 | 900 | 950
type AccentPalette = Record<AccentShade, string> // hex colours, e.g. '#3b82f6'

const DEFAULT_ACCENT = '#3b82f6'

function accentPalette(accent?: string): AccentPalette              // any CSS colour; unrecognised → default blue
function readAccentPalette(el: Element | null | undefined): AccentPalette // inherited --elm-accent of el
function resolveColor(input: string): [number, number, number] | null     // any CSS colour → RGB