@element-editor/ui 0.0.0-stage → 0.2.0

package/dist/useContextMenu-DJ2Cti85.js

@@ -0,0 +1,10 @@
+import { useState as c, useCallback as e } from "react";
+function p() {
+  const [n, t] = c(null), o = e((u, l, a) => {
+    t({ x: u, y: l, data: a });
+  }, []), s = e(() => t(null), []);
+  return { state: n, open: o, close: s };
+}
+export {
+  p as u
+};

package/dist/useContextMenu-DbxMvb1s.cjs

@@ -0,0 +1 @@
+"use strict";const e=require("react");function a(){const[n,t]=e.useState(null),s=e.useCallback((c,l,o)=>{t({x:c,y:l,data:o})},[]),u=e.useCallback(()=>t(null),[]);return{state:n,open:s,close:u}}exports.useContextMenu=a;

package/dist/useFocusTrap-BBjPCfDR.cjs

@@ -0,0 +1 @@
+"use strict";const l=require("react");function a(e,r=!0){l.useEffect(()=>{if(!e.current||!r)return;const o=document.activeElement;function c(t){if(t.key!=="Tab")return;const s=e.current;if(!s)return;const n=f(s);if(n.length===0)return;const u=n[0],i=n[n.length-1];t.shiftKey?document.activeElement===u&&(t.preventDefault(),i.focus()):document.activeElement===i&&(t.preventDefault(),u.focus())}return document.addEventListener("keydown",c),()=>{document.removeEventListener("keydown",c),o==null||o.focus()}},[e,r])}function f(e){return Array.from(e.querySelectorAll('a[href], button:not(:disabled), input:not(:disabled), select:not(:disabled), textarea:not(:disabled), [tabindex]:not([tabindex="-1"])'))}exports.useFocusTrap=a;

package/dist/useFocusTrap-CKxKT8De.js

@@ -0,0 +1,25 @@
+import { useEffect as l } from "react";
+function m(e, o = !0) {
+  l(() => {
+    if (!e.current || !o) return;
+    const r = document.activeElement;
+    function c(t) {
+      if (t.key !== "Tab") return;
+      const s = e.current;
+      if (!s) return;
+      const n = a(s);
+      if (n.length === 0) return;
+      const u = n[0], i = n[n.length - 1];
+      t.shiftKey ? document.activeElement === u && (t.preventDefault(), i.focus()) : document.activeElement === i && (t.preventDefault(), u.focus());
+    }
+    return document.addEventListener("keydown", c), () => {
+      document.removeEventListener("keydown", c), r == null || r.focus();
+    };
+  }, [e, o]);
+}
+function a(e) {
+  return Array.from(e.querySelectorAll('a[href], button:not(:disabled), input:not(:disabled), select:not(:disabled), textarea:not(:disabled), [tabindex]:not([tabindex="-1"])'));
+}
+export {
+  m as u
+};

package/dist/useJumpToFeature-Bdz2hqOC.js

@@ -0,0 +1,16 @@
+import { useCallback as s } from "react";
+import { getGeometryBBox as a } from "@element-editor/core";
+import { g as l } from "./useAdapterControls-DVjkwRZ_.js";
+function i() {
+  const { panTo: e, fitBounds: o } = l();
+  return s((t) => {
+    if (t.geometry.type === "Point") {
+      const [r, m] = t.geometry.coordinates;
+      e == null || e([m, r]);
+    } else
+      o == null || o(t.bbox || a(t.geometry));
+  }, [e, o]);
+}
+export {
+  i as u
+};

package/dist/useJumpToFeature-LwjxGzfy.cjs

@@ -0,0 +1 @@
+"use strict";const u=require("react"),c=require("@element-editor/core"),n=require("./useAdapterControls-BBObhzVX.cjs");function a(){const{panTo:e,fitBounds:t}=n.useMapController();return u.useCallback(r=>{if(r.geometry.type==="Point"){const[o,s]=r.geometry.coordinates;e==null||e([s,o])}else t==null||t(r.bbox||c.getGeometryBBox(r.geometry))},[e,t])}exports.useJumpToFeature=a;

package/dist/useWindowFocus-D-_yEm_V.cjs

@@ -0,0 +1 @@
+"use strict";const h=require("react/jsx-runtime"),q=require("@phosphor-icons/react"),g=require("./index-BKdDZ4Y9.cjs"),i=require("react"),p=require("@element-editor/core"),D=require("./useAccentStyle-hsGvyHZc.cjs");function L({onClick:e,label:a="Close"}){return h.jsx("button",{onMouseDown:o=>o.stopPropagation(),onClick:e,"aria-label":a,className:`flex ${g.panelHeaderIconBtn}`,children:h.jsx(q.X,{size:16})})}const m=1;function R(e){return!!e&&typeof e=="object"&&typeof e.x=="number"&&typeof e.y=="number"}function w(e){return{x:Math.max(0,Math.min(window.innerWidth-120,e.x)),y:Math.max(0,Math.min(window.innerHeight-60,e.y))}}function z(e,a){const o=D.useElementEditorConfig(),[d,u]=i.useState(()=>{const n=p.readPersisted(e,m,r=>R(r)?r:null,o);return n?w(n):a}),c=i.useRef(d);c.current=d,i.useEffect(()=>{function n(){u(r=>{const l=w(r);return l.x===r.x&&l.y===r.y?r:(p.writePersisted(e,m,l,o),l)})}return window.addEventListener("resize",n),()=>window.removeEventListener("resize",n)},[e,o]);const S=i.useCallback(n=>{if(n.button!==0)return;n.preventDefault();const r=n.clientX,l=n.clientY,x=c.current.x,y=c.current.y,C=g.startDragShield("grabbing");let t=n.currentTarget;for(;t&&getComputedStyle(t).position!=="fixed";)t=t.parentElement;const M=(t==null?void 0:t.style.left)??"",P=(t==null?void 0:t.style.top)??"";function v(b){const f=w({x:x+b.clientX-r,y:y+b.clientY-l});if(c.current=f,!t){u(f);return}t.style.left=M.replace(`${x}px`,`${f.x}px`),t.style.top=P.replace(`${y}px`,`${f.y}px`)}function E(){C(),u(c.current),p.writePersisted(e,m,c.current,o),window.removeEventListener("mousemove",v),window.removeEventListener("mouseup",E)}window.addEventListener("mousemove",v),window.addEventListener("mouseup",E)},[e,o]);return{pos:d,onHandleMouseDown:S}}let s=1e3;function W(e=!0){const[a,o]=i.useState(()=>(s+=1,s));i.useEffect(()=>{e&&(s+=1,o(s))},[e]);const d=i.useCallback(()=>{o(u=>u===s?u:(s+=1,s))},[]);return{zIndex:a,focus:d}}exports.CloseButton=L;exports.useDragWindow=z;exports.useWindowFocus=W;

package/dist/useWindowFocus-DGAWA1au.js

@@ -0,0 +1,80 @@
+import { jsx as E } from "react/jsx-runtime";
+import { X as z } from "@phosphor-icons/react";
+import { a as D, s as X } from "./index-CtZterPc.js";
+import { useState as b, useRef as $, useEffect as g, useCallback as M } from "react";
+import { readPersisted as R, writePersisted as h } from "@element-editor/core";
+import { u as Y } from "./useAccentStyle-CPo2XqAn.js";
+function Z({ onClick: e, label: a = "Close" }) {
+  return /* @__PURE__ */ E(
+    "button",
+    {
+      onMouseDown: (o) => o.stopPropagation(),
+      onClick: e,
+      "aria-label": a,
+      className: `flex ${D}`,
+      children: /* @__PURE__ */ E(z, { size: 16 })
+    }
+  );
+}
+const f = 1;
+function H(e) {
+  return !!e && typeof e == "object" && typeof e.x == "number" && typeof e.y == "number";
+}
+function m(e) {
+  return {
+    x: Math.max(0, Math.min(window.innerWidth - 120, e.x)),
+    y: Math.max(0, Math.min(window.innerHeight - 60, e.y))
+  };
+}
+function k(e, a) {
+  const o = Y(), [l, i] = b(() => {
+    const n = R(e, f, (r) => H(r) ? r : null, o);
+    return n ? m(n) : a;
+  }), u = $(l);
+  u.current = l, g(() => {
+    function n() {
+      i((r) => {
+        const c = m(r);
+        return c.x === r.x && c.y === r.y ? r : (h(e, f, c, o), c);
+      });
+    }
+    return window.addEventListener("resize", n), () => window.removeEventListener("resize", n);
+  }, [e, o]);
+  const C = M((n) => {
+    if (n.button !== 0) return;
+    n.preventDefault();
+    const r = n.clientX, c = n.clientY, d = u.current.x, w = u.current.y, L = X("grabbing");
+    let t = n.currentTarget;
+    for (; t && getComputedStyle(t).position !== "fixed"; ) t = t.parentElement;
+    const P = (t == null ? void 0 : t.style.left) ?? "", S = (t == null ? void 0 : t.style.top) ?? "";
+    function x(y) {
+      const p = m({ x: d + y.clientX - r, y: w + y.clientY - c });
+      if (u.current = p, !t) {
+        i(p);
+        return;
+      }
+      t.style.left = P.replace(`${d}px`, `${p.x}px`), t.style.top = S.replace(`${w}px`, `${p.y}px`);
+    }
+    function v() {
+      L(), i(u.current), h(e, f, u.current, o), window.removeEventListener("mousemove", x), window.removeEventListener("mouseup", v);
+    }
+    window.addEventListener("mousemove", x), window.addEventListener("mouseup", v);
+  }, [e, o]);
+  return { pos: l, onHandleMouseDown: C };
+}
+let s = 1e3;
+function F(e = !0) {
+  const [a, o] = b(() => (s += 1, s));
+  g(() => {
+    e && (s += 1, o(s));
+  }, [e]);
+  const l = M(() => {
+    o((i) => i === s ? i : (s += 1, s));
+  }, []);
+  return { zIndex: a, focus: l };
+}
+export {
+  Z as C,
+  F as a,
+  k as u
+};

package/dist/utils/booleanValue.d.cts

@@ -0,0 +1,4 @@
+/** Text (typed or pasted) as a boolean, or `null` when it isn't one ("maybe"). */
+export declare function parseBooleanText(text: string): boolean | null;
+/** Whether a stored boolean field value counts as on. Missing / unknown values are off. */
+export declare function readBooleanValue(value: unknown): boolean;

package/dist/utils/booleanValue.d.ts

@@ -0,0 +1,4 @@
+/** Text (typed or pasted) as a boolean, or `null` when it isn't one ("maybe"). */
+export declare function parseBooleanText(text: string): boolean | null;
+/** Whether a stored boolean field value counts as on. Missing / unknown values are off. */
+export declare function readBooleanValue(value: unknown): boolean;

package/dist/utils/clipboardError.d.cts

@@ -0,0 +1,3 @@
+import { EmittedEvent } from '../contexts/EventContext.cjs';
+/** A failed copy button: reported quietly (onError only); the button just doesn't show "Copied". */
+export declare function clipboardErrorEvent(err: unknown): EmittedEvent;

package/dist/utils/clipboardError.d.ts

@@ -0,0 +1,3 @@
+import { EmittedEvent } from '../contexts/EventContext.js';
+/** A failed copy button: reported quietly (onError only); the button just doesn't show "Copied". */
+export declare function clipboardErrorEvent(err: unknown): EmittedEvent;

package/dist/utils/download.d.cts

@@ -0,0 +1,42 @@
+/**
+ * Trigger a browser download of a GeoJSON text payload via a synthetic
+ * `<a download>` click. Centralises the Blob → object-URL → click → revoke
+ * dance so adapter-leaflet's `ref.exportAs('geojson')`, adapter-maplibre's
+ * `ref.exportAs('geojson')`, and `useGeoJSONExport.exportToFile()` all share
+ * one implementation.
+ *
+ * Returns the resolved filename and the byte size of the downloaded blob,
+ * so callers don't have to allocate a second Blob just to measure bytes.
+ *
+ * NOTE: completion is not observable. The browser may show a "Save As" dialog
+ * the user can cancel; this function returns immediately regardless. Use
+ * {@link saveGeoJSONFile} when you need to know whether the user actually
+ * saved (e.g. to gate a success toast).
+ */
+export declare function triggerGeoJSONDownload(text: string, filename?: string): {
+    name: string;
+    bytes: number;
+};
+/**
+ * Same payload as {@link triggerGeoJSONDownload}, but uses the File System
+ * Access API (`showSaveFilePicker`) when available so the caller can `await`
+ * an actual save confirmation:
+ *
+ *   const result = await saveGeoJSONFile(text)
+ *   if (result) toast.success(`Exported ${result.name}`)  // user saved
+ *   // result === null → user cancelled, OR legacy fallback (we can't tell)
+ *
+ * Resolves with `{ name, bytes }` ONLY when we know the file was written
+ * to disk (Chromium with the API). Resolves with `null` when:
+ *   - the user cancelled the picker (Chromium), or
+ *   - the browser doesn't support the API (Firefox / Safari) — falls back
+ *     to the legacy `<a download>` flow silently, returning `null` so callers
+ *     don't show pre-mature "exported!" feedback for an action the user may
+ *     have aborted in the OS Save dialog.
+ *
+ * Pattern intentional: a pre-mature success toast is worse than no toast.
+ */
+export declare function saveGeoJSONFile(text: string, filename?: string): Promise<{
+    name: string;
+    bytes: number;
+} | null>;

package/dist/utils/download.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Trigger a browser download of a GeoJSON text payload via a synthetic
+ * `<a download>` click. Centralises the Blob → object-URL → click → revoke
+ * dance so adapter-leaflet's `ref.exportAs('geojson')`, adapter-maplibre's
+ * `ref.exportAs('geojson')`, and `useGeoJSONExport.exportToFile()` all share
+ * one implementation.
+ *
+ * Returns the resolved filename and the byte size of the downloaded blob,
+ * so callers don't have to allocate a second Blob just to measure bytes.
+ *
+ * NOTE: completion is not observable. The browser may show a "Save As" dialog
+ * the user can cancel; this function returns immediately regardless. Use
+ * {@link saveGeoJSONFile} when you need to know whether the user actually
+ * saved (e.g. to gate a success toast).
+ */
+export declare function triggerGeoJSONDownload(text: string, filename?: string): {
+    name: string;
+    bytes: number;
+};
+/**
+ * Same payload as {@link triggerGeoJSONDownload}, but uses the File System
+ * Access API (`showSaveFilePicker`) when available so the caller can `await`
+ * an actual save confirmation:
+ *
+ *   const result = await saveGeoJSONFile(text)
+ *   if (result) toast.success(`Exported ${result.name}`)  // user saved
+ *   // result === null → user cancelled, OR legacy fallback (we can't tell)
+ *
+ * Resolves with `{ name, bytes }` ONLY when we know the file was written
+ * to disk (Chromium with the API). Resolves with `null` when:
+ *   - the user cancelled the picker (Chromium), or
+ *   - the browser doesn't support the API (Firefox / Safari) — falls back
+ *     to the legacy `<a download>` flow silently, returning `null` so callers
+ *     don't show pre-mature "exported!" feedback for an action the user may
+ *     have aborted in the OS Save dialog.
+ *
+ * Pattern intentional: a pre-mature success toast is worse than no toast.
+ */
+export declare function saveGeoJSONFile(text: string, filename?: string): Promise<{
+    name: string;
+    bytes: number;
+} | null>;

package/dist/utils/geojsonDocument.d.cts

@@ -0,0 +1,168 @@
+import { Text, ChangeSet, ChangeSpec } from '@codemirror/state';
+import { GeoJSONFeature, Group, Schema } from '@element-editor/core';
+/**
+ * The GeoJSON inspector's document, built feature by feature so it can be
+ * filled in slices and patched per feature. The text is byte-identical to
+ * `dataStore.exportGeoJSON()` (= `JSON.stringify(collection, null, 2)`):
+ * JSON.stringify indents by depth only, so a feature's text inside the
+ * collection is its own pretty JSON shifted right by 4 spaces.
+ *
+ * Layout (1-based lines):  header (H lines, ends `  "features": [`)
+ *                          feature 0 … n-1 (every line but the last feature's
+ *                          closing `    }` carries a trailing `,`)
+ *                          `  ]`, `}`
+ * An empty collection is the header object as one block (`"features": []`).
+ */
+/** What the editor's document currently holds: one line count per feature, aligned with `features`. */
+export interface DocMap {
+    features: readonly GeoJSONFeature[];
+    counts: number[];
+    headerLines: number;
+    schemas: Schema[];
+    groups: Group[];
+}
+export type LinesOf = (f: GeoJSONFeature) => string[];
+/** A feature's lines, indented as they appear inside the collection (no trailing comma). */
+export declare function featureLines(f: GeoJSONFeature): string[];
+/** The header lines; for an empty collection, the whole document. */
+export declare function headerLines(schemas: Schema[], groups: Group[], empty: boolean): string[];
+/** Whole document as lines + its map. */
+export declare function buildDoc(features: readonly GeoJSONFeature[], schemas: Schema[], groups: Group[], linesOf: LinesOf): {
+    text: Text;
+    map: DocMap;
+};
+/**
+ * buildDoc's lines in pieces — the header, one piece per feature (separator
+ * comma included), the footer — so a large document can be serialised and
+ * shown slice by slice. Concatenated, the pieces are exactly buildDoc's lines.
+ */
+export declare function docPieces(features: readonly GeoJSONFeature[], schemas: Schema[], groups: Group[], linesOf: LinesOf): Generator<string[]>;
+/** The map for a document that docPieces / buildDoc produced. */
+export declare function docMapOf(features: readonly GeoJSONFeature[], schemas: Schema[], groups: Group[], linesOf: LinesOf): DocMap;
+/** Line number (1-based) of each feature's first line. */
+export declare function featureStartLines(map: DocMap): number[];
+/** Index of the feature whose lines include `line` (1-based), or -1 (header, separators, footer). */
+export declare function featureIndexAtLine(map: DocMap, line: number): number;
+/**
+ * Changes that turn `doc` (described by `map`) into the document for the new
+ * state, touching only features whose object reference changed, plus the
+ * header when schemas/groups changed. Returns null when it must be rebuilt
+ * (empty ↔ non-empty).
+ */
+export declare function diffDoc(doc: Text, map: DocMap, features: readonly GeoJSONFeature[], schemas: Schema[], groups: Group[], linesOf: LinesOf): {
+    changes: ChangeSpec[];
+    map: DocMap;
+} | null;
+export type EditResult = 
+/** An edit touches the header or the footer: parse the whole document. */
+{
+    kind: 'full';
+}
+/**
+ * The edited features' text doesn't parse (mid-typing): write nothing, wait
+ * for more typing. `from`…`to` is the first failing run's text in the new
+ * document (features only, no outer separators), for locating the error.
+ */
+ | {
+    kind: 'invalid';
+    from: number;
+    to: number;
+}
+/**
+ * The new feature list: edited features re-parsed (deleted ones gone), every
+ * other one the same object. `counts` is the updated map's line counts, or
+ * null when an edit split one feature into several (the map no longer
+ * applies until `canonicalRuns` rewrites the text). `around` lists the new
+ * indices next to each edit, for `separatorFixes` to check. `runs` are the
+ * re-parsed feature runs: old indices `i`…`j` (inclusive, ascending), now
+ * `length` features.
+ */
+ | {
+    kind: 'ok';
+    features: unknown[];
+    counts: number[] | null;
+    around: number[];
+    runs: EditRun[];
+};
+export interface EditRun {
+    i: number;
+    j: number;
+    length: number;
+}
+/**
+ * Whether parsed text is a feature the store takes — mirrors the guard in
+ * core's `updateFeaturesFromEditor`, so half-typed text (geometry lines
+ * deleted to retype them) reads as mid-typing instead of being refused.
+ */
+export declare function isFeature(f: unknown): boolean;
+/** Why parsed text isn't a feature the store takes, in plain words (for a value `isFeature` refuses). */
+export declare function featureIssue(f: unknown): string;
+/**
+ * Where `text` stops being JSON as `parseLenient` reads it (the same stray
+ * commas forgiven), with the reason in plain words; null when it parses.
+ * `JSON.parse` can't tell: its message carries a position in some engines
+ * only (Safari gives none), in its own wording.
+ */
+export declare function jsonError(text: string): {
+    pos: number;
+    message: string;
+} | null;
+/**
+ * Re-parses only the features the user's edits touched. `base` is the
+ * document `map` describes, `changes` the user's edits since (base → `doc`).
+ * An edit inside one feature re-parses that feature; one spanning several
+ * (deleting whole features, or the separator between two) re-parses the run
+ * from the first to the last, as `[text]` read leniently — empty when they
+ * were all deleted. Commas left over between features are `separatorFixes`'
+ * business.
+ */
+export declare function parseEdits(base: Text, map: DocMap, changes: ChangeSet, doc: Text): EditResult;
+/** The smallest single change turning `a` into `b` (common prefix and suffix kept), offset by `at`; null when equal. */
+export declare function smallestChange(a: string, b: string, at?: number): {
+    from: number;
+    to: number;
+    insert: string;
+} | null;
+/**
+ * Rewrites the runs `parseEdits` re-parsed as buildDoc prints them, so the
+ * per-feature map applies again whatever the user's text looked like (one
+ * feature split into several, a pasted feature on one line, …). `features` is
+ * the committed list, aligned with the parse (the store may have added ids or
+ * empty properties). Each run's region runs from the end of the feature before
+ * it (or the header) to the start of the one after it (or the footer), so the
+ * separators are rewritten too; adjacent runs share one region. The changes
+ * apply to `doc` (= `changes` applied to `base`) and are each the smallest
+ * replacement, so text already in shape — say a feature copied from the
+ * inspector — is left alone. Returns them with the map's new line counts.
+ */
+export declare function canonicalRuns(base: Text, map: DocMap, changes: ChangeSet, doc: Text, runs: readonly EditRun[], features: readonly GeoJSONFeature[], linesOf: LinesOf): {
+    changes: ChangeSpec[];
+    counts: number[];
+};
+/**
+ * Checks that the features at `around` sit in `doc` exactly where `counts`
+ * says, in buildDoc's shape (`    {` … `    },`, the last one `    }` before
+ * `  ]`). Returns the edits that restore it — only ever dropping the comma a
+ * deleted last feature leaves on the new last one — or null when the text is
+ * otherwise off (the caller then parses the whole document).
+ */
+export declare function separatorFixes(doc: Text, headerLines: number, counts: readonly number[], around: Iterable<number>): ChangeSpec[] | null;
+/** Whether two change sets over the same document touch overlapping (or adjacent) ranges. */
+export declare function changesOverlap(a: ChangeSet, b: ChangeSet): boolean;
+/**
+ * Feature line ranges found by scanning the document, for when the user has
+ * typed into it and the map no longer applies. A feature starts at a line that
+ * is exactly `    {`; stops once feature `index` is found. Counting starts
+ * at `fromLine`.
+ */
+export declare function scanFeatureRange(doc: Text, index: number, fromLine?: number): {
+    start: number;
+    end: number;
+} | null;
+/**
+ * Parses the inspector's text, forgiving what deleting whole lines leaves
+ * behind: an empty document (an empty collection) and stray commas — trailing
+ * (`},\n  ]`), leading (`[,`) or doubled (`},,{`). Commas inside strings are
+ * left alone. Null when it still isn't JSON.
+ */
+export declare function parseLenient(text: string): unknown;

package/dist/utils/geojsonDocument.d.ts

@@ -0,0 +1,168 @@
+import { Text, ChangeSet, ChangeSpec } from '@codemirror/state';
+import { GeoJSONFeature, Group, Schema } from '@element-editor/core';
+/**
+ * The GeoJSON inspector's document, built feature by feature so it can be
+ * filled in slices and patched per feature. The text is byte-identical to
+ * `dataStore.exportGeoJSON()` (= `JSON.stringify(collection, null, 2)`):
+ * JSON.stringify indents by depth only, so a feature's text inside the
+ * collection is its own pretty JSON shifted right by 4 spaces.
+ *
+ * Layout (1-based lines):  header (H lines, ends `  "features": [`)
+ *                          feature 0 … n-1 (every line but the last feature's
+ *                          closing `    }` carries a trailing `,`)
+ *                          `  ]`, `}`
+ * An empty collection is the header object as one block (`"features": []`).
+ */
+/** What the editor's document currently holds: one line count per feature, aligned with `features`. */
+export interface DocMap {
+    features: readonly GeoJSONFeature[];
+    counts: number[];
+    headerLines: number;
+    schemas: Schema[];
+    groups: Group[];
+}
+export type LinesOf = (f: GeoJSONFeature) => string[];
+/** A feature's lines, indented as they appear inside the collection (no trailing comma). */
+export declare function featureLines(f: GeoJSONFeature): string[];
+/** The header lines; for an empty collection, the whole document. */
+export declare function headerLines(schemas: Schema[], groups: Group[], empty: boolean): string[];
+/** Whole document as lines + its map. */
+export declare function buildDoc(features: readonly GeoJSONFeature[], schemas: Schema[], groups: Group[], linesOf: LinesOf): {
+    text: Text;
+    map: DocMap;
+};
+/**
+ * buildDoc's lines in pieces — the header, one piece per feature (separator
+ * comma included), the footer — so a large document can be serialised and
+ * shown slice by slice. Concatenated, the pieces are exactly buildDoc's lines.
+ */
+export declare function docPieces(features: readonly GeoJSONFeature[], schemas: Schema[], groups: Group[], linesOf: LinesOf): Generator<string[]>;
+/** The map for a document that docPieces / buildDoc produced. */
+export declare function docMapOf(features: readonly GeoJSONFeature[], schemas: Schema[], groups: Group[], linesOf: LinesOf): DocMap;
+/** Line number (1-based) of each feature's first line. */
+export declare function featureStartLines(map: DocMap): number[];
+/** Index of the feature whose lines include `line` (1-based), or -1 (header, separators, footer). */
+export declare function featureIndexAtLine(map: DocMap, line: number): number;
+/**
+ * Changes that turn `doc` (described by `map`) into the document for the new
+ * state, touching only features whose object reference changed, plus the
+ * header when schemas/groups changed. Returns null when it must be rebuilt
+ * (empty ↔ non-empty).
+ */
+export declare function diffDoc(doc: Text, map: DocMap, features: readonly GeoJSONFeature[], schemas: Schema[], groups: Group[], linesOf: LinesOf): {
+    changes: ChangeSpec[];
+    map: DocMap;
+} | null;
+export type EditResult = 
+/** An edit touches the header or the footer: parse the whole document. */
+{
+    kind: 'full';
+}
+/**
+ * The edited features' text doesn't parse (mid-typing): write nothing, wait
+ * for more typing. `from`…`to` is the first failing run's text in the new
+ * document (features only, no outer separators), for locating the error.
+ */
+ | {
+    kind: 'invalid';
+    from: number;
+    to: number;
+}
+/**
+ * The new feature list: edited features re-parsed (deleted ones gone), every
+ * other one the same object. `counts` is the updated map's line counts, or
+ * null when an edit split one feature into several (the map no longer
+ * applies until `canonicalRuns` rewrites the text). `around` lists the new
+ * indices next to each edit, for `separatorFixes` to check. `runs` are the
+ * re-parsed feature runs: old indices `i`…`j` (inclusive, ascending), now
+ * `length` features.
+ */
+ | {
+    kind: 'ok';
+    features: unknown[];
+    counts: number[] | null;
+    around: number[];
+    runs: EditRun[];
+};
+export interface EditRun {
+    i: number;
+    j: number;
+    length: number;
+}
+/**
+ * Whether parsed text is a feature the store takes — mirrors the guard in
+ * core's `updateFeaturesFromEditor`, so half-typed text (geometry lines
+ * deleted to retype them) reads as mid-typing instead of being refused.
+ */
+export declare function isFeature(f: unknown): boolean;
+/** Why parsed text isn't a feature the store takes, in plain words (for a value `isFeature` refuses). */
+export declare function featureIssue(f: unknown): string;
+/**
+ * Where `text` stops being JSON as `parseLenient` reads it (the same stray
+ * commas forgiven), with the reason in plain words; null when it parses.
+ * `JSON.parse` can't tell: its message carries a position in some engines
+ * only (Safari gives none), in its own wording.
+ */
+export declare function jsonError(text: string): {
+    pos: number;
+    message: string;
+} | null;
+/**
+ * Re-parses only the features the user's edits touched. `base` is the
+ * document `map` describes, `changes` the user's edits since (base → `doc`).
+ * An edit inside one feature re-parses that feature; one spanning several
+ * (deleting whole features, or the separator between two) re-parses the run
+ * from the first to the last, as `[text]` read leniently — empty when they
+ * were all deleted. Commas left over between features are `separatorFixes`'
+ * business.
+ */
+export declare function parseEdits(base: Text, map: DocMap, changes: ChangeSet, doc: Text): EditResult;
+/** The smallest single change turning `a` into `b` (common prefix and suffix kept), offset by `at`; null when equal. */
+export declare function smallestChange(a: string, b: string, at?: number): {
+    from: number;
+    to: number;
+    insert: string;
+} | null;
+/**
+ * Rewrites the runs `parseEdits` re-parsed as buildDoc prints them, so the
+ * per-feature map applies again whatever the user's text looked like (one
+ * feature split into several, a pasted feature on one line, …). `features` is
+ * the committed list, aligned with the parse (the store may have added ids or
+ * empty properties). Each run's region runs from the end of the feature before
+ * it (or the header) to the start of the one after it (or the footer), so the
+ * separators are rewritten too; adjacent runs share one region. The changes
+ * apply to `doc` (= `changes` applied to `base`) and are each the smallest
+ * replacement, so text already in shape — say a feature copied from the
+ * inspector — is left alone. Returns them with the map's new line counts.
+ */
+export declare function canonicalRuns(base: Text, map: DocMap, changes: ChangeSet, doc: Text, runs: readonly EditRun[], features: readonly GeoJSONFeature[], linesOf: LinesOf): {
+    changes: ChangeSpec[];
+    counts: number[];
+};
+/**
+ * Checks that the features at `around` sit in `doc` exactly where `counts`
+ * says, in buildDoc's shape (`    {` … `    },`, the last one `    }` before
+ * `  ]`). Returns the edits that restore it — only ever dropping the comma a
+ * deleted last feature leaves on the new last one — or null when the text is
+ * otherwise off (the caller then parses the whole document).
+ */
+export declare function separatorFixes(doc: Text, headerLines: number, counts: readonly number[], around: Iterable<number>): ChangeSpec[] | null;
+/** Whether two change sets over the same document touch overlapping (or adjacent) ranges. */
+export declare function changesOverlap(a: ChangeSet, b: ChangeSet): boolean;
+/**
+ * Feature line ranges found by scanning the document, for when the user has
+ * typed into it and the map no longer applies. A feature starts at a line that
+ * is exactly `    {`; stops once feature `index` is found. Counting starts
+ * at `fromLine`.
+ */
+export declare function scanFeatureRange(doc: Text, index: number, fromLine?: number): {
+    start: number;
+    end: number;
+} | null;
+/**
+ * Parses the inspector's text, forgiving what deleting whole lines leaves
+ * behind: an empty document (an empty collection) and stray commas — trailing
+ * (`},\n  ]`), leading (`[,`) or doubled (`},,{`). Commas inside strings are
+ * left alone. Null when it still isn't JSON.
+ */
+export declare function parseLenient(text: string): unknown;

package/dist/utils/geometryWorkerClient.d.cts

@@ -0,0 +1,6 @@
+import { Geometry } from 'geojson';
+import { GeometryWorkerRequest } from '@element-editor/core/internal';
+export declare function runGeometryWorkerOperation(payload: GeometryWorkerRequest['payload'], { timeoutMs }?: {
+    timeoutMs?: number;
+}): Promise<Geometry>;
+export declare function disposeGeometryWorker(): void;

package/dist/utils/geometryWorkerClient.d.ts

@@ -0,0 +1,6 @@
+import { Geometry } from 'geojson';
+import { GeometryWorkerRequest } from '@element-editor/core/internal';
+export declare function runGeometryWorkerOperation(payload: GeometryWorkerRequest['payload'], { timeoutMs }?: {
+    timeoutMs?: number;
+}): Promise<Geometry>;
+export declare function disposeGeometryWorker(): void;

package/dist/utils/layerOrder.d.cts

@@ -0,0 +1,9 @@
+import { GeoJSONFeature, Group } from '@element-editor/core';
+/** Returns feature IDs in the visual order they appear in the layer list. */
+export declare function getVisualFeatureOrder(features: GeoJSONFeature[], groups: Group[]): string[];
+/**
+ * Like `getVisualFeatureOrder` but skips features inside collapsed groups
+ * (they aren't rendered, so they shouldn't receive keyboard focus when tabbing
+ * through inline rename inputs).
+ */
+export declare function getTabbableFeatureIds(features: GeoJSONFeature[], groups: Group[]): string[];

package/dist/utils/layerOrder.d.ts

@@ -0,0 +1,9 @@
+import { GeoJSONFeature, Group } from '@element-editor/core';
+/** Returns feature IDs in the visual order they appear in the layer list. */
+export declare function getVisualFeatureOrder(features: GeoJSONFeature[], groups: Group[]): string[];
+/**
+ * Like `getVisualFeatureOrder` but skips features inside collapsed groups
+ * (they aren't rendered, so they shouldn't receive keyboard focus when tabbing
+ * through inline rename inputs).
+ */
+export declare function getTabbableFeatureIds(features: GeoJSONFeature[], groups: Group[]): string[];

package/dist/utils/lazyWithPreload.d.cts

@@ -0,0 +1,24 @@
+import { ComponentType } from 'react';
+type Loader<T extends ComponentType<any>> = () => Promise<{
+    default: T;
+}>;
+/**
+ * `React.lazy` plus `.preload()` — start fetching the chunk before first render.
+ * Once the chunk is in, it renders the component directly: React.lazy would
+ * still suspend on its first render (the resolved promise is only read a
+ * microtask later), and React 19 holds back revealing a suspended boundary's
+ * content for ~300 ms — the GeoJSON inspector opened ~280 ms late because of it.
+ */
+export declare function lazyWithPreload<T extends ComponentType<any>>(load: Loader<T>): T & {
+    preload: () => Promise<unknown>;
+};
+export declare function registerPreload(...items: Array<{
+    preload: () => Promise<unknown>;
+}>): void;
+/**
+ * Fetch every lazy editor panel (GeoJSON inspector, data table, modals…) once
+ * the browser is idle, so their first open is instant instead of waiting on a
+ * chunk download. Idle-time only: never competes with the initial render.
+ */
+export declare function preloadEditorPanelsWhenIdle(): void;
+export {};