@jgengine/core 0.10.0 → 0.12.0

package/dist/editor/grid.js

@@ -0,0 +1,366 @@
+/** The grid-layer cell-schema version this build writes and migrates toward. */
+export const CURRENT_GRID_SCHEMA_VERSION = 1;
+/**
+ * The value id a layer treats as empty/background (default `""`). Cells holding this value are
+ * never stored, so it is what {@link getGridCell} returns for any unset cell.
+ * @capability editor-grids Resolve a grid layer's empty/background value id.
+ */
+export function gridEmptyValue(layer) {
+    return layer.empty ?? "";
+}
+/** Builds the sparse-map key for a cell. @internal */
+export function gridCellKey(col, row) {
+    return `${col},${row}`;
+}
+/**
+ * Parses a `"col,row"` sparse-map key back into integer coordinates, or `null` when malformed.
+ * @capability editor-grids Decode a grid layer's sparse cell key.
+ */
+export function parseGridCellKey(key) {
+    const comma = key.indexOf(",");
+    if (comma <= 0)
+        return null;
+    const col = Number.parseInt(key.slice(0, comma), 10);
+    const row = Number.parseInt(key.slice(comma + 1), 10);
+    if (!Number.isInteger(col) || !Number.isInteger(row))
+        return null;
+    return { col, row };
+}
+/**
+ * True when `col,row` falls inside the layer's declared bounds.
+ * @capability editor-grids Bounds-check a grid coordinate before reading or writing it.
+ */
+export function inGridBounds(layer, col, row) {
+    return col >= 0 && row >= 0 && col < layer.cols && row < layer.rows;
+}
+/**
+ * Reads the value id at `col,row`, returning the layer's empty value for any unset or
+ * out-of-bounds cell. The one read path both gameplay and rendering share.
+ * @capability editor-grids Read a grid cell's value id.
+ */
+export function getGridCell(layer, col, row) {
+    if (!inGridBounds(layer, col, row))
+        return gridEmptyValue(layer);
+    return layer.cells[gridCellKey(col, row)] ?? gridEmptyValue(layer);
+}
+/**
+ * Samples the value id at `col,row` — the eyedropper. Identical to {@link getGridCell}, named for
+ * the authoring op that picks up a cell's value to paint with.
+ * @capability editor-grids Eyedrop (sample) a grid cell's value for painting.
+ */
+export function eyedropGridCell(layer, col, row) {
+    return getGridCell(layer, col, row);
+}
+/**
+ * Returns a copy of the layer with `col,row` set to `value`, dropping the cell when `value` is the
+ * empty value (that is the erase op). Out-of-bounds writes and no-op writes return the layer
+ * unchanged, so callers can diff by identity.
+ * @capability editor-grids Paint or erase a single grid cell (immutable).
+ */
+export function setGridCell(layer, col, row, value) {
+    if (!inGridBounds(layer, col, row))
+        return layer;
+    const empty = gridEmptyValue(layer);
+    const key = gridCellKey(col, row);
+    const cells = { ...layer.cells };
+    if (value === empty) {
+        if (!(key in cells))
+            return layer;
+        delete cells[key];
+    }
+    else {
+        if (cells[key] === value)
+            return layer;
+        cells[key] = value;
+    }
+    return { ...layer, cells };
+}
+/**
+ * Erases `col,row` back to the layer's empty value — {@link setGridCell} with the empty value.
+ * @capability editor-grids Erase a single grid cell (immutable).
+ */
+export function eraseGridCell(layer, col, row) {
+    return setGridCell(layer, col, row, gridEmptyValue(layer));
+}
+/**
+ * Applies a batch of cell edits in one pass, returning the same layer when nothing changed. The
+ * op the editor uses for a drag stroke, a paste, or any multi-cell paint/erase.
+ * @capability editor-grids Paint or erase many grid cells in one immutable update.
+ */
+export function paintGridCells(layer, edits) {
+    const empty = gridEmptyValue(layer);
+    const cells = { ...layer.cells };
+    let changed = false;
+    for (const edit of edits) {
+        if (!inGridBounds(layer, edit.col, edit.row))
+            continue;
+        const key = gridCellKey(edit.col, edit.row);
+        if (edit.value === empty) {
+            if (key in cells) {
+                delete cells[key];
+                changed = true;
+            }
+        }
+        else if (cells[key] !== edit.value) {
+            cells[key] = edit.value;
+            changed = true;
+        }
+    }
+    return changed ? { ...layer, cells } : layer;
+}
+/**
+ * Fills the inclusive rectangle spanning the two corners with `value` (the rectangle tool). Corners
+ * may be given in any order; the clamped in-bounds portion is painted.
+ * @capability editor-grids Fill a grid rectangle with one value (immutable).
+ */
+export function fillGridRect(layer, col0, row0, col1, row1, value) {
+    const cLo = Math.max(0, Math.min(col0, col1));
+    const cHi = Math.min(layer.cols - 1, Math.max(col0, col1));
+    const rLo = Math.max(0, Math.min(row0, row1));
+    const rHi = Math.min(layer.rows - 1, Math.max(row0, row1));
+    const edits = [];
+    for (let row = rLo; row <= rHi; row += 1) {
+        for (let col = cLo; col <= cHi; col += 1)
+            edits.push({ col, row, value });
+    }
+    return paintGridCells(layer, edits);
+}
+/**
+ * Flood-fills the 4-connected region of cells sharing the seed cell's value, replacing it with
+ * `value` (the bucket tool). Bounded by the layer's declared bounds, so it never scans the world.
+ * @capability editor-grids Bucket flood-fill a contiguous grid region (immutable).
+ */
+export function floodFillGrid(layer, col, row, value) {
+    if (!inGridBounds(layer, col, row))
+        return layer;
+    const target = getGridCell(layer, col, row);
+    if (target === value)
+        return layer;
+    const edits = [];
+    const seen = new Set();
+    const stack = [[col, row]];
+    while (stack.length > 0) {
+        const [c, r] = stack.pop();
+        if (!inGridBounds(layer, c, r))
+            continue;
+        const key = gridCellKey(c, r);
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        if (getGridCell(layer, c, r) !== target)
+            continue;
+        edits.push({ col: c, row: r, value });
+        stack.push([c + 1, r], [c - 1, r], [c, r + 1], [c, r - 1]);
+    }
+    return paintGridCells(layer, edits);
+}
+/**
+ * Resizes the layer's bounds to `cols`×`rows`, dropping any cells that fall outside the new extent
+ * (values are anchored at the origin corner). Negative or fractional sizes are floored to `≥ 0`.
+ * @capability editor-grids Resize a grid layer's bounds, trimming out-of-range cells (immutable).
+ */
+export function resizeGridLayer(layer, cols, rows) {
+    const nextCols = Math.max(0, Math.floor(cols));
+    const nextRows = Math.max(0, Math.floor(rows));
+    if (nextCols === layer.cols && nextRows === layer.rows)
+        return layer;
+    const cells = {};
+    for (const [key, value] of Object.entries(layer.cells)) {
+        const parsed = parseGridCellKey(key);
+        if (parsed !== null && parsed.col < nextCols && parsed.row < nextRows)
+            cells[key] = value;
+    }
+    return { ...layer, cols: nextCols, rows: nextRows, cells };
+}
+/**
+ * Every non-empty, in-bounds cell of a layer, sorted row-major (rendering-independent iteration).
+ * @capability editor-grids Iterate a grid layer's non-empty cells, row-major.
+ */
+export function gridCellEntries(layer) {
+    const out = [];
+    for (const [key, value] of Object.entries(layer.cells)) {
+        const parsed = parseGridCellKey(key);
+        if (parsed === null || !inGridBounds(layer, parsed.col, parsed.row))
+            continue;
+        out.push({ col: parsed.col, row: parsed.row, value });
+    }
+    out.sort((a, b) => a.row - b.row || a.col - b.col);
+    return out;
+}
+/**
+ * Visits every non-empty cell of a layer row-major. Allocation-light convenience over
+ * {@link gridCellEntries} for runtime scans that only need a callback.
+ * @capability editor-grids Walk a grid layer's non-empty cells with a callback.
+ */
+export function forEachGridCell(layer, visit) {
+    for (const cell of gridCellEntries(layer))
+        visit(cell);
+}
+/**
+ * Counts the non-empty, in-bounds cells of a layer.
+ * @capability editor-grids Count a grid layer's non-empty cells.
+ */
+export function gridCellCount(layer) {
+    let count = 0;
+    for (const [key, value] of Object.entries(layer.cells)) {
+        if (value === gridEmptyValue(layer))
+            continue;
+        const parsed = parseGridCellKey(key);
+        if (parsed !== null && inGridBounds(layer, parsed.col, parsed.row))
+            count += 1;
+    }
+    return count;
+}
+/**
+ * Every in-bounds cell holding `value`, sorted row-major — the query gameplay uses to find all
+ * spawns, hazards, gates, etc. of one kind without touching a renderer.
+ * @capability editor-grids Query all grid cells holding a given value.
+ */
+export function gridCellsOfValue(layer, value) {
+    return gridCellEntries(layer).filter((cell) => cell.value === value);
+}
+/**
+ * World-space center of cell `col,row`, honoring the layer's origin, cell size, and axis mapping.
+ * The shared cell→world map for both placement and rendering.
+ * @capability editor-grids Map a grid cell to its world-space center.
+ */
+export function gridCellToWorld(layer, col, row) {
+    const primary = col * layer.cellSize;
+    const secondary = row * layer.cellSize;
+    if ((layer.axes ?? "xz") === "xy") {
+        return { x: layer.origin.x + primary, y: layer.origin.y + secondary, z: layer.origin.z };
+    }
+    return { x: layer.origin.x + primary, y: layer.origin.y, z: layer.origin.z + secondary };
+}
+/**
+ * Inverse of {@link gridCellToWorld}: the nearest cell to a world point (may be out of bounds).
+ * The shared world→cell map runtime uses to answer "which cell is the player standing on".
+ * @capability editor-grids Map a world-space point to its nearest grid cell.
+ */
+export function worldToGridCell(layer, x, y, z) {
+    const col = Math.round((x - layer.origin.x) / layer.cellSize);
+    if ((layer.axes ?? "xz") === "xy") {
+        return { col, row: Math.round((y - layer.origin.y) / layer.cellSize) };
+    }
+    return { col, row: Math.round((z - layer.origin.z) / layer.cellSize) };
+}
+/**
+ * The value id at the grid cell nearest a world point — {@link worldToGridCell} then
+ * {@link getGridCell}. Answers "what tile is here" straight from a world position.
+ * @capability editor-grids Read the grid value at a world-space point.
+ */
+export function getGridCellAtWorld(layer, x, y, z) {
+    const { col, row } = worldToGridCell(layer, x, y, z);
+    return getGridCell(layer, col, row);
+}
+/**
+ * Looks up a palette entry by value id.
+ * @capability editor-grids Find a grid palette entry by value id.
+ */
+export function findGridPaletteEntry(layer, value) {
+    return layer.palette?.find((entry) => entry.id === value);
+}
+/**
+ * Builds the value-id → glyph map from a layer's palette, for ASCII/glyph export.
+ * @capability editor-grids Derive a value→glyph legend from a grid layer's palette.
+ */
+export function gridGlyphMap(layer) {
+    const map = {};
+    for (const entry of layer.palette ?? []) {
+        if (entry.glyph !== undefined)
+            map[entry.id] = entry.glyph;
+    }
+    return map;
+}
+/**
+ * Creates a grid layer from a partial init, defaulting cell size to `1`, origin to the world
+ * origin, and axes to `"xz"`. Runs the result through {@link migrateGridLayer} so it is normalized
+ * and bounds-clean.
+ * @capability editor-grids Create a normalized, empty grid layer to author into.
+ */
+export function createGridLayer(init) {
+    return migrateGridLayer({
+        id: init.id,
+        kind: init.kind,
+        ...(init.label === undefined ? {} : { label: init.label }),
+        origin: init.origin ?? { x: 0, y: 0, z: 0 },
+        ...(init.axes === undefined ? {} : { axes: init.axes }),
+        cellSize: init.cellSize ?? 1,
+        cols: init.cols,
+        rows: init.rows,
+        ...(init.empty === undefined ? {} : { empty: init.empty }),
+        cells: init.cells ?? {},
+        ...(init.palette === undefined ? {} : { palette: init.palette.map((entry) => ({ ...entry })) }),
+        ...(init.visible === undefined ? {} : { visible: init.visible }),
+        ...(init.meta === undefined ? {} : { meta: { ...init.meta } }),
+    });
+}
+/**
+ * Normalizes a grid layer forward to the current cell-schema version: clamps `cols`/`rows` to
+ * non-negative integers, drops out-of-bounds and empty-valued cells, and stamps `schemaVersion`.
+ * The single migration seam every loader and authoring op funnels new/old layers through, so a
+ * layer from an older document or an import adapter always lands in a valid, minimal shape.
+ * @capability editor-grids Migrate/normalize a grid layer to the current cell schema.
+ */
+export function migrateGridLayer(layer) {
+    const cols = Math.max(0, Math.floor(layer.cols));
+    const rows = Math.max(0, Math.floor(layer.rows));
+    const empty = layer.empty ?? "";
+    const cells = {};
+    for (const [key, value] of Object.entries(layer.cells)) {
+        if (value === empty)
+            continue;
+        const parsed = parseGridCellKey(key);
+        if (parsed === null || parsed.col < 0 || parsed.row < 0 || parsed.col >= cols || parsed.row >= rows) {
+            continue;
+        }
+        cells[gridCellKey(parsed.col, parsed.row)] = value;
+    }
+    return {
+        id: layer.id,
+        kind: layer.kind,
+        ...(layer.label === undefined ? {} : { label: layer.label }),
+        origin: { x: layer.origin.x, y: layer.origin.y, z: layer.origin.z },
+        ...(layer.axes === undefined ? {} : { axes: layer.axes }),
+        cellSize: layer.cellSize,
+        cols,
+        rows,
+        ...(empty === "" ? {} : { empty }),
+        cells,
+        ...(layer.palette === undefined ? {} : { palette: layer.palette.map((entry) => ({ ...entry })) }),
+        ...(layer.visible === undefined ? {} : { visible: layer.visible }),
+        ...(layer.parentId === undefined ? {} : { parentId: layer.parentId }),
+        ...(layer.meta === undefined ? {} : { meta: { ...layer.meta } }),
+        schemaVersion: CURRENT_GRID_SCHEMA_VERSION,
+    };
+}
+/**
+ * Deep-clones a grid layer so authoring edits and history snapshots never alias source cells.
+ * @capability editor-grids Deep-clone a grid layer.
+ */
+export function cloneGridLayer(layer) {
+    return {
+        id: layer.id,
+        kind: layer.kind,
+        ...(layer.label === undefined ? {} : { label: layer.label }),
+        origin: { ...layer.origin },
+        ...(layer.axes === undefined ? {} : { axes: layer.axes }),
+        cellSize: layer.cellSize,
+        cols: layer.cols,
+        rows: layer.rows,
+        ...(layer.empty === undefined ? {} : { empty: layer.empty }),
+        cells: { ...layer.cells },
+        ...(layer.palette === undefined
+            ? {}
+            : {
+                palette: layer.palette.map((entry) => ({
+                    ...entry,
+                    ...(entry.meta === undefined ? {} : { meta: { ...entry.meta } }),
+                })),
+            }),
+        ...(layer.visible === undefined ? {} : { visible: layer.visible }),
+        ...(layer.parentId === undefined ? {} : { parentId: layer.parentId }),
+        ...(layer.meta === undefined ? {} : { meta: { ...layer.meta } }),
+        ...(layer.schemaVersion === undefined ? {} : { schemaVersion: layer.schemaVersion }),
+    };
+}

package/dist/editor/gridAdapters.d.ts

@@ -0,0 +1,80 @@
+import { type EditorGridAxes, type EditorGridLayer, type EditorGridPaletteEntry } from "./grid.js";
+import type { EditorVec3 } from "./types.js";
+/**
+ * Options for importing an ASCII/glyph map into a grid layer. Provide `glyphMap` (char → value id)
+ * or a `palette` whose entries carry `glyph`s (or both — `glyphMap` wins on conflict). Any glyph
+ * not mapped, and any short-row padding, resolves to `empty`.
+ * @capability editor-grid-import Configure an ASCII/glyph → grid-layer import.
+ */
+export interface AsciiGridImportOptions {
+    id: string;
+    kind: string;
+    label?: string;
+    /** Explicit char → value id map. Merged over glyphs derived from `palette`. */
+    glyphMap?: Record<string, string>;
+    palette?: readonly EditorGridPaletteEntry[];
+    /** Value id for unmapped glyphs and ragged-row padding. Default `""`. */
+    empty?: string;
+    cellSize?: number;
+    origin?: EditorVec3;
+    axes?: EditorGridAxes;
+    meta?: Record<string, unknown>;
+}
+/**
+ * Parses an ASCII/glyph map — one row per text line, one char per cell — into a grid layer. Each
+ * glyph is resolved to a value id via the palette/`glyphMap`; unmapped glyphs and padding become
+ * the empty value, so a mostly-open room stays sparse. The canonical representation is the
+ * returned {@link EditorGridLayer}; ASCII is just this import path into it, never the source of
+ * truth. Bounds are the row count × longest row.
+ * @capability editor-grid-import Import an ASCII/glyph map into a grid layer.
+ */
+export declare function importAsciiGrid(text: string, options: AsciiGridImportOptions): EditorGridLayer;
+/** Options for rendering a grid layer back out as an ASCII/glyph map. */
+export interface AsciiGridExportOptions {
+    /** value id → char. Defaults to the layer's palette glyphs. */
+    glyphMap?: Record<string, string>;
+    /** Char emitted for empty cells. Default `"."`. */
+    emptyGlyph?: string;
+}
+/**
+ * Renders a grid layer back to an ASCII/glyph map (rows top to bottom). Value ids map to chars via
+ * the layer palette (or an override map); empty cells become `emptyGlyph`. Round-trips with
+ * {@link importAsciiGrid} when the glyph legend matches.
+ * @capability editor-grid-import Export a grid layer as an ASCII/glyph map.
+ */
+export declare function exportAsciiGrid(layer: EditorGridLayer, options?: AsciiGridExportOptions): string;
+/** Options for importing a CSV grid (one value id per cell). */
+export interface CsvGridImportOptions {
+    id: string;
+    kind: string;
+    label?: string;
+    /** Field separator. Default `","`. */
+    delimiter?: string;
+    /** Value id for blank fields and ragged-row padding. Default `""`. */
+    empty?: string;
+    cellSize?: number;
+    origin?: EditorVec3;
+    axes?: EditorGridAxes;
+    palette?: readonly EditorGridPaletteEntry[];
+    meta?: Record<string, unknown>;
+}
+/**
+ * Parses a CSV grid — one row per line, one value id per comma-separated field — into a grid
+ * layer. Blank fields become the empty value. Unlike ASCII this carries multi-character value ids
+ * directly, so it suits grids whose cell values are names rather than single glyphs.
+ * @capability editor-grid-import Import a CSV grid (value id per cell) into a grid layer.
+ */
+export declare function importCsvGrid(text: string, options: CsvGridImportOptions): EditorGridLayer;
+/** Options for exporting a grid layer as CSV. */
+export interface CsvGridExportOptions {
+    /** Field separator. Default `","`. */
+    delimiter?: string;
+    /** Text emitted for empty cells. Default `""`. */
+    emptyField?: string;
+}
+/**
+ * Renders a grid layer as CSV — one row per line, each cell's value id as a field, empty cells as
+ * `emptyField`. Round-trips with {@link importCsvGrid}.
+ * @capability editor-grid-import Export a grid layer as CSV.
+ */
+export declare function exportCsvGrid(layer: EditorGridLayer, options?: CsvGridExportOptions): string;

package/dist/editor/gridAdapters.js

@@ -0,0 +1,134 @@
+import { createGridLayer, getGridCell, gridCellKey, gridEmptyValue, gridGlyphMap, } from "./grid.js";
+function normalizeLines(text) {
+    const lines = text.replace(/\r\n?/g, "\n").split("\n");
+    while (lines.length > 0 && lines[lines.length - 1] === "")
+        lines.pop();
+    return lines;
+}
+function glyphToValue(options) {
+    const map = {};
+    for (const entry of options.palette ?? []) {
+        if (entry.glyph !== undefined)
+            map[entry.glyph] = entry.id;
+    }
+    return { ...map, ...(options.glyphMap ?? {}) };
+}
+/**
+ * Parses an ASCII/glyph map — one row per text line, one char per cell — into a grid layer. Each
+ * glyph is resolved to a value id via the palette/`glyphMap`; unmapped glyphs and padding become
+ * the empty value, so a mostly-open room stays sparse. The canonical representation is the
+ * returned {@link EditorGridLayer}; ASCII is just this import path into it, never the source of
+ * truth. Bounds are the row count × longest row.
+ * @capability editor-grid-import Import an ASCII/glyph map into a grid layer.
+ */
+export function importAsciiGrid(text, options) {
+    const lines = normalizeLines(text);
+    const rows = lines.length;
+    let cols = 0;
+    for (const line of lines)
+        cols = Math.max(cols, line.length);
+    const map = glyphToValue(options);
+    const empty = options.empty ?? "";
+    const cells = {};
+    lines.forEach((line, row) => {
+        for (let col = 0; col < line.length; col += 1) {
+            const value = map[line[col]] ?? empty;
+            if (value !== empty)
+                cells[gridCellKey(col, row)] = value;
+        }
+    });
+    return createGridLayer({
+        id: options.id,
+        kind: options.kind,
+        ...(options.label === undefined ? {} : { label: options.label }),
+        cols,
+        rows,
+        ...(options.cellSize === undefined ? {} : { cellSize: options.cellSize }),
+        ...(options.origin === undefined ? {} : { origin: options.origin }),
+        ...(options.axes === undefined ? {} : { axes: options.axes }),
+        ...(empty === "" ? {} : { empty }),
+        cells,
+        ...(options.palette === undefined ? {} : { palette: options.palette }),
+        ...(options.meta === undefined ? {} : { meta: options.meta }),
+    });
+}
+/**
+ * Renders a grid layer back to an ASCII/glyph map (rows top to bottom). Value ids map to chars via
+ * the layer palette (or an override map); empty cells become `emptyGlyph`. Round-trips with
+ * {@link importAsciiGrid} when the glyph legend matches.
+ * @capability editor-grid-import Export a grid layer as an ASCII/glyph map.
+ */
+export function exportAsciiGrid(layer, options = {}) {
+    const glyphMap = options.glyphMap ?? gridGlyphMap(layer);
+    const emptyGlyph = options.emptyGlyph ?? ".";
+    const empty = gridEmptyValue(layer);
+    const lines = [];
+    for (let row = 0; row < layer.rows; row += 1) {
+        let line = "";
+        for (let col = 0; col < layer.cols; col += 1) {
+            const value = getGridCell(layer, col, row);
+            line += value === empty ? emptyGlyph : (glyphMap[value] ?? (value.charAt(0) || emptyGlyph));
+        }
+        lines.push(line);
+    }
+    return lines.join("\n");
+}
+/**
+ * Parses a CSV grid — one row per line, one value id per comma-separated field — into a grid
+ * layer. Blank fields become the empty value. Unlike ASCII this carries multi-character value ids
+ * directly, so it suits grids whose cell values are names rather than single glyphs.
+ * @capability editor-grid-import Import a CSV grid (value id per cell) into a grid layer.
+ */
+export function importCsvGrid(text, options) {
+    const delimiter = options.delimiter ?? ",";
+    const empty = options.empty ?? "";
+    const lines = normalizeLines(text);
+    const rows = lines.length;
+    let cols = 0;
+    const parsed = lines.map((line) => {
+        const fields = line.split(delimiter).map((field) => field.trim());
+        cols = Math.max(cols, fields.length);
+        return fields;
+    });
+    const cells = {};
+    parsed.forEach((fields, row) => {
+        fields.forEach((value, col) => {
+            if (value !== "" && value !== empty)
+                cells[gridCellKey(col, row)] = value;
+        });
+    });
+    return createGridLayer({
+        id: options.id,
+        kind: options.kind,
+        ...(options.label === undefined ? {} : { label: options.label }),
+        cols,
+        rows,
+        ...(options.cellSize === undefined ? {} : { cellSize: options.cellSize }),
+        ...(options.origin === undefined ? {} : { origin: options.origin }),
+        ...(options.axes === undefined ? {} : { axes: options.axes }),
+        ...(empty === "" ? {} : { empty }),
+        cells,
+        ...(options.palette === undefined ? {} : { palette: options.palette }),
+        ...(options.meta === undefined ? {} : { meta: options.meta }),
+    });
+}
+/**
+ * Renders a grid layer as CSV — one row per line, each cell's value id as a field, empty cells as
+ * `emptyField`. Round-trips with {@link importCsvGrid}.
+ * @capability editor-grid-import Export a grid layer as CSV.
+ */
+export function exportCsvGrid(layer, options = {}) {
+    const delimiter = options.delimiter ?? ",";
+    const emptyField = options.emptyField ?? "";
+    const empty = gridEmptyValue(layer);
+    const lines = [];
+    for (let row = 0; row < layer.rows; row += 1) {
+        const fields = [];
+        for (let col = 0; col < layer.cols; col += 1) {
+            const value = getGridCell(layer, col, row);
+            fields.push(value === empty ? emptyField : value);
+        }
+        lines.push(fields.join(delimiter));
+    }
+    return lines.join("\n");
+}