@vuu-ui/grid-layout 4.0.0-alpha.1

package/src/GridCommand.js

@@ -0,0 +1,395 @@
+import { uuid } from "@vuu-ui/vuu-utils";
+import { regeneratePlaceholders, removeGridItem, replaceGridItem, resizeTrackTo, resizeTracksAdjacent, resizeTracksProportionally, splitGridItem } from "./GridGeometry.js";
+import { GridLayoutModel } from "./GridLayoutModel.js";
+import { GridModelChildItem } from "./GridModel.js";
+import { gridStackItemIds } from "./GridStack.js";
+class GridCommandExecutionError extends Error {
+    code;
+    constructor({ code, message }){
+        super(message);
+        this.name = "GridCommandExecutionError";
+        this.code = code;
+    }
+}
+const assertNever = (value)=>{
+    throw Error(`Unhandled GridCommand: ${JSON.stringify(value)}`);
+};
+const success = (command)=>({
+        command: command.type,
+        ok: true
+    });
+const failure = (command, code, message)=>({
+        command: command.type,
+        error: {
+            code,
+            message
+        },
+        ok: false
+    });
+const geometryFailure = (command, { code, message })=>{
+    switch(code){
+        case "GEOMETRY_ERROR":
+            throw Error(message);
+        case "INVALID_TARGET":
+            return failure(command, "INVALID_TARGET", message);
+        case "ITEM_NOT_FOUND":
+            return failure(command, "ITEM_NOT_FOUND", message);
+        case "MEASUREMENT_REQUIRED":
+            return failure(command, "MEASUREMENT_REQUIRED", message);
+        case "NON_RESIZABLE":
+            return failure(command, "NON_RESIZABLE", message);
+        case "TRACK_NOT_FOUND":
+            return failure(command, "TRACK_NOT_FOUND", message);
+        default:
+            return failure(command, "INVALID_ITEM", message);
+    }
+};
+const stackFailure = (command, { code, message })=>failure(command, code, message);
+const toPosition = ({ span, start })=>({
+        end: start + span,
+        start
+    });
+const toChildItem = (item, stackId)=>new GridModelChildItem({
+        ...item,
+        column: toPosition(item.column),
+        row: toPosition(item.row),
+        stackId
+    });
+const toConstraints = (constraints)=>constraints?.map(({ minimum, trackIndices })=>({
+            minimum,
+            trackIndices: [
+                ...trackIndices
+            ]
+        })) ?? [];
+class LegacyGridCommandExecutor {
+    gridModel;
+    gridLayoutModel;
+    constructor(gridModel, gridLayoutModel = new GridLayoutModel(gridModel)){
+        this.gridModel = gridModel;
+        this.gridLayoutModel = gridLayoutModel;
+    }
+    execute(command) {
+        switch(command.type){
+            case "add-item":
+                {
+                    const invalid = this.validateNewItem(command, command.item);
+                    if (invalid) return invalid;
+                    this.gridModel.addChildItem(toChildItem(command.item));
+                    return success(command);
+                }
+            case "move-item":
+                {
+                    const invalid = this.validatePair(command, command.itemId, command.targetId);
+                    if (invalid) return invalid;
+                    const stackedMember = this.rejectStackMember(command, command.itemId, command.targetId);
+                    if (stackedMember) return stackedMember;
+                    const geometry = this.gridModel.toGeometry();
+                    const split = this.gridModel.runGeometry((measurements)=>splitGridItem(geometry, {
+                            droppedItemId: command.itemId,
+                            splitDirection: command.position,
+                            targetItemId: command.targetId
+                        }, measurements));
+                    if (!split.ok) return geometryFailure(command, split.error);
+                    this.gridLayoutModel.applySplitTransition(split.value);
+                    this.gridModel.getChildItem(command.itemId, true).dragging = false;
+                    return success(command);
+                }
+            case "replace-item":
+                {
+                    const invalid = this.validatePair(command, command.itemId, command.targetId);
+                    if (invalid) return invalid;
+                    const stackedMember = this.rejectStackMember(command, command.itemId, command.targetId);
+                    if (stackedMember) return stackedMember;
+                    const replaced = replaceGridItem(this.gridModel.toGeometry(), {
+                        droppedItemId: command.itemId,
+                        targetItemId: command.targetId
+                    });
+                    if (!replaced.ok) return geometryFailure(command, replaced.error);
+                    this.gridLayoutModel.applyReplaceTransition(replaced.value);
+                    this.gridModel.getChildItem(command.itemId, true).dragging = false;
+                    return success(command);
+                }
+            case "replace-stack-item":
+                {
+                    const invalid = this.requireTab(command, command.stackId, command.itemId) ?? this.requireItem(command, command.targetId);
+                    if (invalid) return invalid;
+                    const target = this.gridModel.getChildItem(command.targetId, true);
+                    if (target.stackId || "stacked-content" === target.type) return failure(command, "INVALID_TARGET", "A stack member can only replace a standalone grid item");
+                    const removed = this.gridModel.removeStackItem(command.stackId, command.itemId);
+                    if (!removed.ok) return stackFailure(command, removed.error);
+                    const item = this.gridModel.getChildItem(command.itemId, true);
+                    item.stackId = void 0;
+                    item.contentDetached = void 0;
+                    item.contentVisible = true;
+                    item.dragging = false;
+                    const replaced = replaceGridItem(this.gridModel.toGeometry(), {
+                        droppedItemId: command.itemId,
+                        targetItemId: command.targetId
+                    });
+                    if (!replaced.ok) return geometryFailure(command, replaced.error);
+                    this.gridLayoutModel.applyReplaceTransition(replaced.value);
+                    return success(command);
+                }
+            case "remove-item":
+                {
+                    const invalid = this.requireItem(command, command.itemId);
+                    if (invalid) return invalid;
+                    return this.removeItem(command, command.itemId, command.reason);
+                }
+            case "resize-track":
+                {
+                    const invalid = this.requireTracks(command, command.track, [
+                        command.index
+                    ]);
+                    if (invalid) return invalid;
+                    const resized = this.gridModel.tracks.runTrackGeometry(command.track, (tracks)=>resizeTrackTo(tracks, command.index, command.size, command.track));
+                    if (!resized.ok) return geometryFailure(command, resized.error);
+                    this.gridModel.tracks.applyTrackTransition(command.track, resized.value);
+                    return success(command);
+                }
+            case "resize-tracks":
+                {
+                    if (!Number.isFinite(command.delta)) return failure(command, "INVALID_ITEM", "Grid track resize delta must be finite");
+                    if ("adjacent" === command.distribution && command.resizedTrackIndex === command.contraTrackIndex) return failure(command, "INVALID_TARGET", "Adjacent track resize requires two distinct tracks");
+                    const indices = "adjacent" === command.distribution ? [
+                        command.resizedTrackIndex,
+                        command.contraTrackIndex
+                    ] : [
+                        ...command.beforeTrackIndices,
+                        ...command.afterTrackIndices,
+                        ...(command.beforeConstraints ?? []).flatMap(({ trackIndices })=>trackIndices),
+                        ...(command.afterConstraints ?? []).flatMap(({ trackIndices })=>trackIndices)
+                    ];
+                    if ("proportional" === command.distribution && command.initialSizes && (command.initialSizes.length !== this.gridModel.tracks.getTracks(command.track).length || command.initialSizes.some((size)=>!Number.isFinite(size) || size < 0))) return failure(command, "INVALID_ITEM", `Initial ${command.track} sizes must contain one non-negative value per track`);
+                    const invalid = this.requireTracks(command, command.track, indices) ?? this.validateResizeCommand(command) ?? this.applyMeasurements(command, command.track, indices, command.measuredSizes);
+                    if (invalid) return invalid;
+                    const resizedTracks = this.gridModel.tracks.runTrackGeometry(command.track, (tracks)=>"adjacent" === command.distribution ? resizeTracksAdjacent(tracks, {
+                            contraTrackIndex: command.contraTrackIndex,
+                            delta: command.delta,
+                            resizedTrackIndex: command.resizedTrackIndex
+                        }, command.track) : resizeTracksProportionally(tracks, {
+                            afterConstraints: toConstraints(command.afterConstraints),
+                            afterTrackIndices: command.afterTrackIndices,
+                            beforeConstraints: toConstraints(command.beforeConstraints),
+                            beforeTrackIndices: command.beforeTrackIndices,
+                            delta: command.delta,
+                            initialSizes: command.initialSizes
+                        }, command.track));
+                    if (!resizedTracks.ok) return geometryFailure(command, resizedTracks.error);
+                    this.gridModel.tracks.applyTrackTransition(command.track, resizedTracks.value);
+                    return success(command);
+                }
+            case "create-stack":
+                {
+                    const invalid = this.validatePair(command, command.itemId, command.targetId);
+                    if (invalid) return invalid;
+                    if (this.gridModel.getChildItem(command.itemId, true).stackId || this.gridModel.getChildItem(command.targetId, true).stackId) return failure(command, "INVALID_TARGET", "A new stack requires two unstacked items");
+                    const created = this.gridModel.createStack(command.targetId, command.itemId);
+                    if (!created.ok) return stackFailure(command, created.error);
+                    this.gridModel.getChildItem(command.itemId, true).dragging = false;
+                    if (command.selectedItemId) {
+                        const selected = this.gridModel.selectStackItem(created.value.stackId, command.selectedItemId);
+                        if (!selected.ok) return stackFailure(command, selected.error);
+                    }
+                    return success(command);
+                }
+            case "add-stack-item":
+                {
+                    const invalid = this.requireStack(command, command.stackId) ?? this.validateNewItem(command, command.item);
+                    if (invalid) return invalid;
+                    if (void 0 === command.position !== (void 0 === command.targetItemId)) return failure(command, "INVALID_TARGET", "A stack placement requires both position and targetItemId");
+                    const stack = this.gridModel.getChildItem(command.stackId, true);
+                    const added = this.gridModel.addStackItem(command.stackId, toChildItem({
+                        ...command.item,
+                        column: {
+                            span: stack.column.end - stack.column.start,
+                            start: stack.column.start
+                        },
+                        row: {
+                            span: stack.row.end - stack.row.start,
+                            start: stack.row.start
+                        }
+                    }, command.stackId), command.position && command.targetItemId ? {
+                        position: command.position,
+                        target: command.targetItemId
+                    } : void 0);
+                    if (!added.ok) return stackFailure(command, added.error);
+                    return success(command);
+                }
+            case "remove-stack-item":
+                {
+                    const invalid = this.requireTab(command, command.stackId, command.itemId);
+                    if (invalid) return invalid;
+                    return this.removeItem(command, command.itemId, "close");
+                }
+            case "move-item-to-stack":
+                {
+                    const invalid = this.requireItem(command, command.itemId) ?? this.requireStack(command, command.stackId);
+                    if (invalid) return invalid;
+                    if (void 0 === command.position !== (void 0 === command.targetItemId)) return failure(command, "INVALID_TARGET", "A stack placement requires both position and targetItemId");
+                    if (command.fromStackId) {
+                        const tabFailure = this.requireTab(command, command.fromStackId, command.itemId);
+                        if (tabFailure) return tabFailure;
+                        const removed = this.gridModel.removeStackItem(command.fromStackId, command.itemId);
+                        if (!removed.ok) return stackFailure(command, removed.error);
+                    } else if (!this.gridModel.getChildItem(command.itemId, true).dragging) {
+                        const removed = this.removeItem(command, command.itemId, "drag");
+                        if (!removed.ok) return removed;
+                    }
+                    const item = this.gridModel.getChildItem(command.itemId, true);
+                    item.stackId = void 0;
+                    item.contentDetached = void 0;
+                    item.dragging = false;
+                    const added = this.gridModel.addStackMember(command.stackId, command.itemId, command.position && command.targetItemId ? {
+                        position: command.position,
+                        target: command.targetItemId
+                    } : void 0);
+                    if (!added.ok) return stackFailure(command, added.error);
+                    const selected = this.gridModel.selectStackItem(command.stackId, command.itemId);
+                    return selected.ok ? success(command) : stackFailure(command, selected.error);
+                }
+            case "move-stack-item-to-grid":
+                {
+                    const invalid = this.requireTab(command, command.stackId, command.itemId) ?? this.requireItem(command, command.targetId);
+                    if (invalid) return invalid;
+                    const stackItemIds = gridStackItemIds(this.gridModel.getStackState(command.stackId));
+                    const targetId = command.targetId === command.stackId && 2 === stackItemIds.length ? stackItemIds.find((itemId)=>itemId !== command.itemId) : command.targetId;
+                    if (!targetId) return failure(command, "INVALID_TARGET", `Grid stack #${command.stackId} has no remaining split target`);
+                    const removed = this.gridModel.removeStackItem(command.stackId, command.itemId);
+                    if (!removed.ok) return stackFailure(command, removed.error);
+                    const item = this.gridModel.getChildItem(command.itemId, true);
+                    item.stackId = void 0;
+                    item.contentDetached = void 0;
+                    item.contentVisible = true;
+                    item.dragging = false;
+                    const split = this.gridModel.runGeometry((measurements)=>splitGridItem(this.gridModel.toGeometry(), {
+                            droppedItemId: command.itemId,
+                            splitDirection: command.position,
+                            targetItemId: targetId
+                        }, measurements));
+                    if (!split.ok) return geometryFailure(command, split.error);
+                    this.gridLayoutModel.applySplitTransition(split.value);
+                    return success(command);
+                }
+            case "select-stack-item":
+                {
+                    const invalid = this.requireTab(command, command.stackId, command.itemId);
+                    if (invalid) return invalid;
+                    const selected = this.gridModel.selectStackItem(command.stackId, command.itemId);
+                    if (!selected.ok) return stackFailure(command, selected.error);
+                    return success(command);
+                }
+            case "reorder-stack-item":
+                {
+                    const invalid = this.requireTab(command, command.stackId, command.itemId) ?? this.requireTab(command, command.stackId, command.targetItemId);
+                    if (invalid) return invalid;
+                    const reordered = this.gridModel.reorderStackItem(command.stackId, {
+                        activate: command.activate ?? false,
+                        itemId: command.itemId,
+                        placement: command.position,
+                        targetItemId: command.targetItemId
+                    });
+                    if (!reordered.ok) return stackFailure(command, reordered.error);
+                    return success(command);
+                }
+            case "rename-item":
+                {
+                    const invalid = this.requireItem(command, command.itemId);
+                    if (invalid) return invalid;
+                    this.gridModel.updateChildTitle(command.itemId, command.title);
+                    return success(command);
+                }
+            case "regenerate-placeholders":
+                this.gridModel.applyPlaceholderTransition(regeneratePlaceholders(this.gridModel.toGeometry(), uuid));
+                return success(command);
+            default:
+                return assertNever(command);
+        }
+    }
+    removeItem(command, itemId, reason) {
+        const geometry = this.gridModel.toGeometry();
+        const removed = this.gridModel.runGeometry((measurements)=>removeGridItem(geometry, {
+                itemId,
+                reason
+            }, {
+                createPlaceholderId: uuid,
+                measurements
+            }));
+        if (!removed.ok) return geometryFailure(command, removed.error);
+        this.gridLayoutModel.applyRemoveTransition(removed.value);
+        return success(command);
+    }
+    applyMeasurements(command, trackType, indices, measuredSizes) {
+        const tracks = this.gridModel.tracks.getTracks(trackType);
+        if (measuredSizes) {
+            if (measuredSizes.length !== tracks.length || measuredSizes.some((size)=>!Number.isFinite(size) || size < 0)) return failure(command, "INVALID_ITEM", `Measured ${trackType} sizes must contain one non-negative value per track`);
+            measuredSizes.forEach((size, index)=>{
+                tracks[index].measuredValue = size;
+            });
+            indices.forEach((index)=>{
+                if (tracks[index].isFraction) tracks[index].convertUnitsToPixels();
+            });
+        }
+        if (indices.some((index)=>tracks[index].isFraction && !tracks[index].isMeasured)) return failure(command, "MEASUREMENT_REQUIRED", `Fractional ${trackType} resize requires measuredSizes`);
+    }
+    validateResizeCommand(command) {
+        const tracks = this.gridModel.tracks.getTracks(command.track);
+        if ("adjacent" === command.distribution) {
+            const currentSize = (index)=>command.measuredSizes?.[index] ?? (tracks[index].isFraction ? void 0 : tracks[index].numericValue);
+            const resizedSize = currentSize(command.resizedTrackIndex);
+            const contraSize = currentSize(command.contraTrackIndex);
+            if (void 0 !== resizedSize && resizedSize + command.delta < 0 || void 0 !== contraSize && contraSize - command.delta < 0) return failure(command, "INVALID_ITEM", "Adjacent track resize cannot produce a negative track size");
+            return;
+        }
+        const before = new Set(command.beforeTrackIndices);
+        const after = new Set(command.afterTrackIndices);
+        if (before.size !== command.beforeTrackIndices.length || after.size !== command.afterTrackIndices.length || [
+            ...before
+        ].some((index)=>after.has(index))) return failure(command, "INVALID_TARGET", "Proportional track resize groups must contain unique, disjoint tracks");
+        for (const [constraints, group] of [
+            [
+                command.beforeConstraints ?? [],
+                before
+            ],
+            [
+                command.afterConstraints ?? [],
+                after
+            ]
+        ])for (const { minimum, trackIndices } of constraints)if (!Number.isFinite(minimum) || minimum < 0 || trackIndices.some((index)=>!group.has(index))) return failure(command, "INVALID_ITEM", "Grid track resize constraints must reference their own group and have non-negative minimums");
+    }
+    requireItem(command, itemId) {
+        if (!this.gridModel.getChildItem(itemId)) return failure(command, "ITEM_NOT_FOUND", `[GridModel] GridItem #${itemId} not found`);
+    }
+    requireStack(command, stackId) {
+        const stack = this.gridModel.getChildItem(stackId);
+        if (!stack || "stacked-content" !== stack.type) return failure(command, "STACK_NOT_FOUND", `Grid stack #${stackId} not found`);
+    }
+    requireTab(command, stackId, itemId) {
+        const invalidStack = this.requireStack(command, stackId);
+        if (invalidStack) return invalidStack;
+        if (!gridStackItemIds(this.gridModel.getStackState(stackId)).includes(itemId)) return failure(command, "TAB_NOT_FOUND", `Grid tab #${itemId} not found in stack #${stackId}`);
+    }
+    requireTracks(command, trackType, indices) {
+        const trackCount = this.gridModel.tracks.getTracks(trackType).length;
+        const missing = indices.find((index)=>!Number.isInteger(index) || index < 0 || index >= trackCount);
+        if (void 0 !== missing) return failure(command, "TRACK_NOT_FOUND", `Grid ${trackType} track #${missing} not found`);
+    }
+    validateNewItem(command, item) {
+        if (this.gridModel.getChildItem(item.id)) return failure(command, "DUPLICATE_ITEM_ID", `Grid item #${item.id} already exists`);
+        const { colCount, rowCount } = this.gridModel.tracks;
+        if (!item.id || !Number.isInteger(item.column.start) || !Number.isInteger(item.column.span) || !Number.isInteger(item.row.start) || !Number.isInteger(item.row.span) || item.column.start < 1 || item.row.start < 1 || item.column.span < 1 || item.row.span < 1 || item.column.start + item.column.span > colCount + 1 || item.row.start + item.row.span > rowCount + 1) return failure(command, "INVALID_ITEM", `Grid item #${item.id} has invalid grid coordinates`);
+    }
+    validatePair(command, itemId, targetId) {
+        const invalid = this.requireItem(command, itemId) ?? this.requireItem(command, targetId);
+        if (invalid) return invalid;
+        if (itemId === targetId) return failure(command, "INVALID_TARGET", `Grid item #${itemId} cannot target itself`);
+    }
+    rejectStackMember(command, ...itemIds) {
+        const stackedMember = itemIds.map((itemId)=>this.gridModel.getChildItem(itemId, true)).find(({ stackId })=>void 0 !== stackId);
+        if (stackedMember) return failure(command, "INVALID_TARGET", `Stack member #${stackedMember.id} must be moved through a stack command`);
+    }
+}
+const throwForGridCommandFailure = (result)=>{
+    if (!result.ok) throw new GridCommandExecutionError(result.error);
+};
+export { GridCommandExecutionError, LegacyGridCommandExecutor, throwForGridCommandFailure };

package/src/GridComponentSettings.js

@@ -0,0 +1,163 @@
+import { toJsonValue } from "./json-value.js";
+const jsonIssue = (issue, component, code, version)=>({
+        code,
+        componentId: component.id,
+        componentType: component.type,
+        message: issue.message,
+        path: issue.path,
+        version
+    });
+const codecError = (issue, component, code, version)=>({
+        code,
+        componentId: component.id,
+        componentType: component.type,
+        message: issue.message,
+        path: issue.path,
+        version
+    });
+class GridComponentSettingsRegistry {
+    #codecs = new Map();
+    register(type, codec) {
+        if (!type) throw new Error("Grid component type must not be empty");
+        if (!Number.isInteger(codec.version) || codec.version < 1) throw new Error(`Grid component codec "${type}" has an invalid version`);
+        if (this.#codecs.has(type)) throw new Error(`Grid component codec "${type}" is already registered`);
+        this.#codecs.set(type, {
+            decode: codec.decode,
+            encode: (settings)=>codec.isSettings(settings) ? codec.encode(settings) : {
+                    error: {
+                        code: "INVALID_SETTINGS_TYPE",
+                        message: `settings do not match component type "${type}"`,
+                        path: "$"
+                    },
+                    ok: false
+                },
+            migrations: codec.migrations ?? {},
+            version: codec.version
+        });
+    }
+    encode(component) {
+        const codec = this.#codecs.get(component.type);
+        if (!codec) return {
+            error: {
+                code: "UNKNOWN_COMPONENT_TYPE",
+                componentId: component.id,
+                componentType: component.type,
+                message: `component type "${component.type}" is not registered`,
+                path: "$.type"
+            },
+            ok: false
+        };
+        const encoded = codec.encode(component.settings);
+        if (!encoded.ok) return {
+            error: codecError(encoded.error, component, "COMPONENT_ENCODE_FAILED", codec.version),
+            ok: false
+        };
+        const json = toJsonValue(encoded.value, "$.settings");
+        if (!json.ok) return {
+            error: jsonIssue(json.error, component, "COMPONENT_ENCODE_FAILED", codec.version),
+            ok: false
+        };
+        return {
+            ok: true,
+            value: {
+                id: component.id,
+                settings: json.value,
+                type: component.type,
+                version: codec.version
+            }
+        };
+    }
+    decode(component) {
+        const codec = this.#codecs.get(component.type);
+        if (!codec) return {
+            error: {
+                code: "UNKNOWN_COMPONENT_TYPE",
+                componentId: component.id,
+                componentType: component.type,
+                message: `component type "${component.type}" is not registered`,
+                path: "$.type",
+                version: component.version
+            },
+            ok: false
+        };
+        if (component.version > codec.version || component.version < 1) return {
+            error: {
+                code: "UNSUPPORTED_COMPONENT_VERSION",
+                componentId: component.id,
+                componentType: component.type,
+                message: `component settings version ${component.version} is not supported; current version is ${codec.version}`,
+                path: "$.version",
+                version: component.version
+            },
+            ok: false
+        };
+        let value = component.settings;
+        for(let version = component.version; version < codec.version; version += 1){
+            const migrate = codec.migrations[version];
+            if (!migrate) return {
+                error: {
+                    code: "UNSUPPORTED_COMPONENT_VERSION",
+                    componentId: component.id,
+                    componentType: component.type,
+                    message: `no migration from component settings version ${version}`,
+                    path: "$.version",
+                    version
+                },
+                ok: false
+            };
+            const migrated = migrate(value);
+            if (!migrated.ok) return {
+                error: codecError(migrated.error, component, "COMPONENT_MIGRATION_FAILED", version),
+                ok: false
+            };
+            const json = toJsonValue(migrated.value, "$.settings");
+            if (!json.ok) return {
+                error: jsonIssue(json.error, component, "COMPONENT_MIGRATION_FAILED", version),
+                ok: false
+            };
+            value = json.value;
+        }
+        const decoded = codec.decode(value);
+        return decoded.ok ? {
+            ok: true,
+            value: {
+                ...component,
+                settings: decoded.value,
+                version: codec.version
+            }
+        } : {
+            error: codecError(decoded.error, component, "COMPONENT_DECODE_FAILED", component.version),
+            ok: false
+        };
+    }
+}
+class GridComponentRendererRegistry {
+    #renderers = new Map();
+    register(type, isSettings, render) {
+        if (this.#renderers.has(type)) throw new Error(`Grid component renderer "${type}" is already registered`);
+        this.#renderers.set(type, {
+            isSettings,
+            render: (settings, componentId)=>{
+                if (!isSettings(settings)) throw new Error(`Decoded settings do not match renderer "${type}"`);
+                return render(settings, componentId);
+            }
+        });
+    }
+    render(component) {
+        const renderer = this.#renderers.get(component.type);
+        if (!renderer) throw new Error(`Grid component renderer "${component.type}" is not registered`);
+        return renderer.render(component.settings, component.id);
+    }
+}
+class GridLayoutContentRegistry {
+    #entries = new Map();
+    entries() {
+        return new Map(this.#entries);
+    }
+    replace(components, resolve) {
+        const next = new Map();
+        for (const component of components)next.set(component.id, resolve(component));
+        this.#entries = next;
+    }
+}
+export { GridComponentRendererRegistry, GridComponentSettingsRegistry, GridLayoutContentRegistry };